[mutter] Move alarm and xids management to MetaX11Display



commit 722c975aca9aa9bb55ccdc00b981e76b2fe331c6
Author: Armin Krezović <krezovic armin gmail com>
Date:   Sat Aug 26 18:56:44 2017 +0200

    Move alarm and xids management to MetaX11Display
    
    https://bugzilla.gnome.org/show_bug.cgi?id=759538

 src/backends/x11/meta-barrier-x11.c   |  10 ++--
 src/compositor/compositor.c           |   2 +-
 src/core/core.c                       |   3 +-
 src/core/display-private.h            |  36 ------------
 src/core/display.c                    | 102 ++++++----------------------------
 src/core/frame.c                      |   5 +-
 src/core/stack-tracker.c              |   3 +-
 src/core/window.c                     |  16 +++---
 src/tests/test-runner.c               |  13 +++--
 src/tests/test-utils.c                |   6 +-
 src/tests/test-utils.h                |   4 +-
 src/wayland/meta-xwayland-selection.c |   4 +-
 src/x11/events.c                      |  30 ++++++----
 src/x11/meta-x11-display-private.h    |  34 ++++++++++++
 src/x11/meta-x11-display.c            |  81 +++++++++++++++++++++++++++
 src/x11/window-props.c                |  27 +++++----
 src/x11/window-x11.c                  |  30 +++++-----
 src/x11/xprops.c                      |   2 +-
 18 files changed, 216 insertions(+), 192 deletions(-)
---
diff --git a/src/backends/x11/meta-barrier-x11.c b/src/backends/x11/meta-barrier-x11.c
index cccbab966..d861edf01 100644
--- a/src/backends/x11/meta-barrier-x11.c
+++ b/src/backends/x11/meta-barrier-x11.c
@@ -97,7 +97,7 @@ _meta_barrier_impl_x11_destroy (MetaBarrierImpl *impl)
     return;
 
   XFixesDestroyPointerBarrier (dpy, priv->xbarrier);
-  g_hash_table_remove (display->xids, &priv->xbarrier);
+  g_hash_table_remove (display->x11_display->xids, &priv->xbarrier);
   priv->xbarrier = 0;
 }
 
@@ -134,7 +134,7 @@ meta_barrier_impl_x11_new (MetaBarrier *barrier)
                                                allowed_motion_dirs,
                                                0, NULL);
 
-  g_hash_table_insert (display->xids, &priv->xbarrier, barrier);
+  g_hash_table_insert (display->x11_display->xids, &priv->xbarrier, barrier);
 
   return META_BARRIER_IMPL (self);
 }
@@ -174,8 +174,8 @@ meta_barrier_fire_xevent (MetaBarrier    *barrier,
 }
 
 gboolean
-meta_display_process_barrier_xevent (MetaDisplay *display,
-                                     XIEvent     *event)
+meta_x11_display_process_barrier_xevent (MetaX11Display *x11_display,
+                                         XIEvent        *event)
 {
   MetaBarrier *barrier;
   XIBarrierEvent *xev;
@@ -193,7 +193,7 @@ meta_display_process_barrier_xevent (MetaDisplay *display,
     }
 
   xev = (XIBarrierEvent *) event;
-  barrier = g_hash_table_lookup (display->xids, &xev->barrier);
+  barrier = g_hash_table_lookup (x11_display->xids, &xev->barrier);
   if (barrier != NULL)
     {
       meta_barrier_fire_xevent (barrier, xev);
diff --git a/src/compositor/compositor.c b/src/compositor/compositor.c
index 26fb3ae9c..f43d2da1b 100644
--- a/src/compositor/compositor.c
+++ b/src/compositor/compositor.c
@@ -758,7 +758,7 @@ meta_compositor_process_event (MetaCompositor *compositor,
       if (window == NULL)
         {
           Window xwin = ((XDamageNotifyEvent *) event)->drawable;
-          window = meta_display_lookup_x_window (compositor->display, xwin);
+          window = meta_x11_display_lookup_x_window (x11_display, xwin);
         }
 
       if (window)
diff --git a/src/core/core.c b/src/core/core.c
index 40ab1e613..d0caeca7a 100644
--- a/src/core/core.c
+++ b/src/core/core.c
@@ -29,6 +29,7 @@
 #include <meta/errors.h>
 #include "util-private.h"
 
+#include "x11/meta-x11-display-private.h"
 #include "x11/window-x11.h"
 #include "x11/window-x11-private.h"
 
@@ -51,7 +52,7 @@ get_window (Display *xdisplay,
   MetaWindow *window;
 
   display = meta_display_for_x_display (xdisplay);
-  window = meta_display_lookup_x_window (display, frame_xwindow);
+  window = meta_x11_display_lookup_x_window (display->x11_display, frame_xwindow);
 
   if (window == NULL || window->frame == NULL)
     {
diff --git a/src/core/display-private.h b/src/core/display-private.h
index 88c895575..17282e749 100644
--- a/src/core/display-private.h
+++ b/src/core/display-private.h
@@ -102,10 +102,6 @@ typedef enum {
   META_EVENT_ROUTE_FRAME_BUTTON,
 } MetaEventRoute;
 
-typedef gboolean (*MetaAlarmFilter) (MetaDisplay           *display,
-                                     XSyncAlarmNotifyEvent *event,
-                                     gpointer               data);
-
 typedef void (* MetaDisplayWindowFunc) (MetaWindow *window,
                                         gpointer    user_data);
 
@@ -165,7 +161,6 @@ struct _MetaDisplay
 
   /*< private-ish >*/
   MetaScreen *screen;
-  GHashTable *xids;
   GHashTable *stamps;
   GHashTable *wayland_windows;
 
@@ -257,9 +252,6 @@ struct _MetaDisplay
   MetaGestureTracker *gesture_tracker;
   ClutterEventSequence *pointer_emulating_sequence;
 
-  MetaAlarmFilter alarm_filter;
-  gpointer alarm_filter_data;
-
   ClutterActor *current_pad_osd;
 
   MetaStartupNotification *startup_notification;
@@ -299,17 +291,6 @@ void meta_display_unmanage_windows (MetaDisplay *display,
 int           meta_display_stack_cmp           (const void *a,
                                                 const void *b);
 
-/* A given MetaWindow may have various X windows that "belong"
- * to it, such as the frame window.
- */
-MetaWindow* meta_display_lookup_x_window     (MetaDisplay *display,
-                                              Window       xwindow);
-void        meta_display_register_x_window   (MetaDisplay *display,
-                                              Window      *xwindowp,
-                                              MetaWindow  *window);
-void        meta_display_unregister_x_window (MetaDisplay *display,
-                                              Window       xwindow);
-
 /* Each MetaWindow is uniquely identified by a 64-bit "stamp"; unlike a
  * a MetaWindow *, a stamp will never be recycled
  */
@@ -338,14 +319,6 @@ void        meta_display_register_wayland_window   (MetaDisplay *display,
 void        meta_display_unregister_wayland_window (MetaDisplay *display,
                                                     MetaWindow  *window);
 
-MetaWindow* meta_display_lookup_sync_alarm     (MetaDisplay *display,
-                                                XSyncAlarm   alarm);
-void        meta_display_register_sync_alarm   (MetaDisplay *display,
-                                                XSyncAlarm  *alarmp,
-                                                MetaWindow  *window);
-void        meta_display_unregister_sync_alarm (MetaDisplay *display,
-                                                XSyncAlarm   alarm);
-
 void        meta_display_notify_window_created (MetaDisplay  *display,
                                                 MetaWindow   *window);
 
@@ -412,11 +385,6 @@ void meta_display_accelerator_activate (MetaDisplay     *display,
                                         ClutterKeyEvent *event);
 gboolean meta_display_modifiers_accelerator_activate (MetaDisplay *display);
 
-#ifdef HAVE_XI23
-gboolean meta_display_process_barrier_xevent (MetaDisplay *display,
-                                              XIEvent     *event);
-#endif /* HAVE_XI23 */
-
 void meta_display_set_input_focus_xwindow (MetaDisplay *display,
                                            MetaScreen  *screen,
                                            Window       window,
@@ -456,10 +424,6 @@ void meta_display_cancel_touch (MetaDisplay *display);
 
 gboolean meta_display_windows_are_interactable (MetaDisplay *display);
 
-void meta_display_set_alarm_filter (MetaDisplay    *display,
-                                    MetaAlarmFilter filter,
-                                    gpointer        data);
-
 void meta_display_show_tablet_mapping_notification (MetaDisplay        *display,
                                                     ClutterInputDevice *pad,
                                                     const gchar        *pretty_name);
diff --git a/src/core/display.c b/src/core/display.c
index 64442b659..ba05aea91 100644
--- a/src/core/display.c
+++ b/src/core/display.c
@@ -732,9 +732,6 @@ meta_display_open (void)
 
   meta_display_init_events_x11 (display);
 
-  display->xids = g_hash_table_new (meta_unsigned_long_hash,
-                                        meta_unsigned_long_equal);
-
   /* Create the leader window here. Set its properties and
    * use the timestamp from one of the PropertyNotify events
    * that will follow.
@@ -847,7 +844,9 @@ meta_display_open (void)
 
   if (old_active_xwindow != None)
     {
-      MetaWindow *old_active_window = meta_display_lookup_x_window (display, old_active_xwindow);
+      MetaWindow *old_active_window;
+      old_active_window = meta_x11_display_lookup_x_window (display->x11_display,
+                                                            old_active_xwindow);
       if (old_active_window)
         meta_window_focus (old_active_window, timestamp);
       else
@@ -898,17 +897,20 @@ meta_display_list_windows (MetaDisplay          *display,
 
   winlist = NULL;
 
-  g_hash_table_iter_init (&iter, display->xids);
-  while (g_hash_table_iter_next (&iter, &key, &value))
+  if (display->x11_display)
     {
-      MetaWindow *window = value;
+      g_hash_table_iter_init (&iter, display->x11_display->xids);
+      while (g_hash_table_iter_next (&iter, &key, &value))
+        {
+          MetaWindow *window = value;
 
-      if (!META_IS_WINDOW (window) || window->unmanaging)
-        continue;
+          if (!META_IS_WINDOW (window) || window->unmanaging)
+            continue;
 
-      if (!window->override_redirect ||
-          (flags & META_LIST_INCLUDE_OVERRIDE_REDIRECT) != 0)
-        winlist = g_slist_prepend (winlist, window);
+          if (!window->override_redirect ||
+              (flags & META_LIST_INCLUDE_OVERRIDE_REDIRECT) != 0)
+            winlist = g_slist_prepend (winlist, window);
+        }
     }
 
   g_hash_table_iter_init (&iter, display->wayland_windows);
@@ -1015,11 +1017,6 @@ meta_display_close (MetaDisplay *display,
   /* Stop caring about events */
   meta_display_free_events_x11 (display);
 
-  /* Must be after all calls to meta_window_unmanage() since they
-   * unregister windows
-   */
-  g_hash_table_destroy (display->xids);
-
   if (display->leader_window != None)
     XDestroyWindow (display->x11_display->xdisplay, display->leader_window);
 
@@ -1459,32 +1456,6 @@ request_xserver_input_focus_change (MetaDisplay *display,
     meta_display_remove_autoraise_callback (display);
 }
 
-MetaWindow*
-meta_display_lookup_x_window (MetaDisplay *display,
-                              Window       xwindow)
-{
-  return g_hash_table_lookup (display->xids, &xwindow);
-}
-
-void
-meta_display_register_x_window (MetaDisplay *display,
-                                Window      *xwindowp,
-                                MetaWindow  *window)
-{
-  g_return_if_fail (g_hash_table_lookup (display->xids, xwindowp) == NULL);
-
-  g_hash_table_insert (display->xids, xwindowp, window);
-}
-
-void
-meta_display_unregister_x_window (MetaDisplay *display,
-                                  Window       xwindow)
-{
-  g_return_if_fail (g_hash_table_lookup (display->xids, &xwindow) != NULL);
-
-  g_hash_table_remove (display->xids, &xwindow);
-}
-
 void
 meta_display_register_wayland_window (MetaDisplay *display,
                                       MetaWindow  *window)
@@ -1530,7 +1501,8 @@ meta_display_lookup_stack_id (MetaDisplay *display,
                               guint64      stack_id)
 {
   if (META_STACK_ID_IS_X11 (stack_id))
-    return meta_display_lookup_x_window (display, (Window)stack_id);
+    return meta_x11_display_lookup_x_window (display->x11_display,
+                                             (Window)stack_id);
   else
     return meta_display_lookup_stamp (display, stack_id);
 }
@@ -1561,37 +1533,6 @@ meta_display_describe_stack_id (MetaDisplay *display,
   return result;
 }
 
-/* We store sync alarms in the window ID hash table, because they are
- * just more types of XIDs in the same global space, but we have
- * typesafe functions to register/unregister for readability.
- */
-
-MetaWindow*
-meta_display_lookup_sync_alarm (MetaDisplay *display,
-                                XSyncAlarm   alarm)
-{
-  return g_hash_table_lookup (display->xids, &alarm);
-}
-
-void
-meta_display_register_sync_alarm (MetaDisplay *display,
-                                  XSyncAlarm  *alarmp,
-                                  MetaWindow  *window)
-{
-  g_return_if_fail (g_hash_table_lookup (display->xids, alarmp) == NULL);
-
-  g_hash_table_insert (display->xids, alarmp, window);
-}
-
-void
-meta_display_unregister_sync_alarm (MetaDisplay *display,
-                                    XSyncAlarm   alarm)
-{
-  g_return_if_fail (g_hash_table_lookup (display->xids, &alarm) != NULL);
-
-  g_hash_table_remove (display->xids, &alarm);
-}
-
 void
 meta_display_notify_window_created (MetaDisplay  *display,
                                     MetaWindow   *window)
@@ -3044,17 +2985,6 @@ meta_display_is_pointer_emulating_sequence (MetaDisplay          *display,
   return display->pointer_emulating_sequence == sequence;
 }
 
-void
-meta_display_set_alarm_filter (MetaDisplay    *display,
-                               MetaAlarmFilter filter,
-                               gpointer        data)
-{
-  g_return_if_fail (filter == NULL || display->alarm_filter == NULL);
-
-  display->alarm_filter = filter;
-  display->alarm_filter_data = data;
-}
-
 void
 meta_display_request_pad_osd (MetaDisplay        *display,
                               ClutterInputDevice *pad,
diff --git a/src/core/frame.c b/src/core/frame.c
index ab8686b2d..1fb885d06 100644
--- a/src/core/frame.c
+++ b/src/core/frame.c
@@ -85,7 +85,7 @@ meta_window_ensure_frame (MetaWindow *window)
   XChangeWindowAttributes (x11_display->xdisplay,
                           frame->xwindow, CWEventMask, &attrs);
 
-  meta_display_register_x_window (window->display, &frame->xwindow, window);
+  meta_x11_display_register_x_window (x11_display, &frame->xwindow, window);
 
   meta_error_trap_push (x11_display);
   if (window->mapped)
@@ -201,8 +201,7 @@ meta_window_destroy_frame (MetaWindow *window)
 
   meta_ui_frame_unmanage (frame->ui_frame);
 
-  meta_display_unregister_x_window (window->display,
-                                    frame->xwindow);
+  meta_x11_display_unregister_x_window (x11_display, frame->xwindow);
 
   window->frame = NULL;
   if (window->frame_bounds)
diff --git a/src/core/stack-tracker.c b/src/core/stack-tracker.c
index 9971d1045..a5ef6de45 100644
--- a/src/core/stack-tracker.c
+++ b/src/core/stack-tracker.c
@@ -851,8 +851,9 @@ meta_stack_tracker_sync_stack (MetaStackTracker *tracker)
 
       if (META_STACK_ID_IS_X11 (window))
         {
+          MetaX11Display *x11_display = tracker->screen->display->x11_display;
           MetaWindow *meta_window =
-            meta_display_lookup_x_window (tracker->screen->display, (Window)window);
+            meta_x11_display_lookup_x_window (x11_display, (Window)window);
 
           /* When mapping back from xwindow to MetaWindow we have to be a bit careful;
            * children of the root could include unmapped windows created by toolkits
diff --git a/src/core/window.c b/src/core/window.c
index e1bac2ae8..342d9650e 100644
--- a/src/core/window.c
+++ b/src/core/window.c
@@ -7488,8 +7488,8 @@ meta_window_get_transient_for (MetaWindow *window)
   if (window->transient_for)
     return window->transient_for;
   else if (window->xtransient_for)
-    return meta_display_lookup_x_window (window->display,
-                                         window->xtransient_for);
+    return meta_x11_display_lookup_x_window (window->display->x11_display,
+                                             window->xtransient_for);
   else
     return NULL;
 }
@@ -8050,24 +8050,24 @@ window_has_pointer_wayland (MetaWindow *window)
 static gboolean
 window_has_pointer_x11 (MetaWindow *window)
 {
-  MetaDisplay *display = window->display;
+  MetaX11Display *x11_display = window->display->x11_display;
   Window root, child;
   double root_x, root_y, x, y;
   XIButtonState buttons;
   XIModifierState mods;
   XIGroupState group;
 
-  meta_error_trap_push (display->x11_display);
-  XIQueryPointer (display->x11_display->xdisplay,
+  meta_error_trap_push (x11_display);
+  XIQueryPointer (x11_display->xdisplay,
                   META_VIRTUAL_CORE_POINTER_ID,
-                  display->x11_display->xroot,
+                  x11_display->xroot,
                   &root, &child,
                   &root_x, &root_y, &x, &y,
                   &buttons, &mods, &group);
-  meta_error_trap_pop (display->x11_display);
+  meta_error_trap_pop (x11_display);
   free (buttons.mask);
 
-  return meta_display_lookup_x_window (display, child) == window;
+  return meta_x11_display_lookup_x_window (x11_display, child) == window;
 }
 
 gboolean
diff --git a/src/tests/test-runner.c b/src/tests/test-runner.c
index 2fef451a3..2eb45b9b5 100644
--- a/src/tests/test-runner.c
+++ b/src/tests/test-runner.c
@@ -41,7 +41,7 @@ typedef struct {
 } TestCase;
 
 static gboolean
-test_case_alarm_filter (MetaDisplay           *display,
+test_case_alarm_filter (MetaX11Display        *x11_display,
                         XSyncAlarmNotifyEvent *event,
                         gpointer               data)
 {
@@ -49,12 +49,12 @@ test_case_alarm_filter (MetaDisplay           *display,
   GHashTableIter iter;
   gpointer key, value;
 
-  if (async_waiter_alarm_filter (test->waiter, display, event))
+  if (async_waiter_alarm_filter (test->waiter, x11_display, event))
     return TRUE;
 
   g_hash_table_iter_init (&iter, test->clients);
   while (g_hash_table_iter_next (&iter, &key, &value))
-    if (test_client_alarm_filter (value, display, event))
+    if (test_client_alarm_filter (value, x11_display, event))
       return TRUE;
 
   return FALSE;
@@ -103,8 +103,8 @@ test_case_new (void)
                                             test_case_log_func,
                                             test);
 
-  meta_display_set_alarm_filter (meta_get_display (),
-                                 test_case_alarm_filter, test);
+  meta_x11_display_set_alarm_filter (meta_get_display ()->x11_display,
+                                     test_case_alarm_filter, test);
 
   test->clients = g_hash_table_new (g_str_hash, g_str_equal);
   test->waiter = async_waiter_new ();
@@ -501,7 +501,8 @@ test_case_destroy (TestCase *test,
 
   async_waiter_destroy (test->waiter);
 
-  meta_display_set_alarm_filter (meta_get_display (), NULL, NULL);
+  meta_x11_display_set_alarm_filter (meta_get_display ()->x11_display,
+                                     NULL, NULL);
 
   g_hash_table_destroy (test->clients);
   g_free (test);
diff --git a/src/tests/test-utils.c b/src/tests/test-utils.c
index 9faf2a9b8..04b4c501e 100644
--- a/src/tests/test-utils.c
+++ b/src/tests/test-utils.c
@@ -162,7 +162,7 @@ async_waiter_set_and_wait (AsyncWaiter *waiter)
 
 gboolean
 async_waiter_alarm_filter (AsyncWaiter           *waiter,
-                           MetaDisplay           *display,
+                           MetaX11Display        *x11_display,
                            XSyncAlarmNotifyEvent *event)
 {
   if (event->alarm != waiter->alarm)
@@ -335,11 +335,11 @@ test_client_find_window (TestClient *client,
 
 gboolean
 test_client_alarm_filter (TestClient            *client,
-                          MetaDisplay           *display,
+                          MetaX11Display        *x11_display,
                           XSyncAlarmNotifyEvent *event)
 {
   if (client->waiter)
-    return async_waiter_alarm_filter (client->waiter, display, event);
+    return async_waiter_alarm_filter (client->waiter, x11_display, event);
   else
     return FALSE;
 }
diff --git a/src/tests/test-utils.h b/src/tests/test-utils.h
index 61250a798..9280e7ead 100644
--- a/src/tests/test-utils.h
+++ b/src/tests/test-utils.h
@@ -44,7 +44,7 @@ void test_init (int    argc,
                 char **argv);
 
 gboolean async_waiter_alarm_filter (AsyncWaiter           *waiter,
-                                    MetaDisplay           *display,
+                                    MetaX11Display        *x11_display,
                                     XSyncAlarmNotifyEvent *event);
 
 void async_waiter_set_and_wait (AsyncWaiter *waiter);
@@ -56,7 +56,7 @@ void async_waiter_destroy (AsyncWaiter *waiter);
 char * test_client_get_id (TestClient *client);
 
 gboolean test_client_alarm_filter (TestClient            *client,
-                                   MetaDisplay           *display,
+                                   MetaX11Display        *x11_display,
                                    XSyncAlarmNotifyEvent *event);
 
 gboolean test_client_wait (TestClient *client,
diff --git a/src/wayland/meta-xwayland-selection.c b/src/wayland/meta-xwayland-selection.c
index b70687bbd..f5fc257b6 100644
--- a/src/wayland/meta-xwayland-selection.c
+++ b/src/wayland/meta-xwayland-selection.c
@@ -610,8 +610,8 @@ wayland_selection_data_new (XSelectionRequestEvent *request_event,
   data->cancellable = g_cancellable_new ();
   data->stream = g_unix_input_stream_new (p[0], TRUE);
 
-  data->window = meta_display_lookup_x_window (display,
-                                               data->request_event.requestor);
+  data->window = meta_x11_display_lookup_x_window (x11_display,
+                                                   data->request_event.requestor);
 
   /* Do *not* change the event mask on the root window, bugger! */
   if (!data->window && data->request_event.requestor != x11_display->xroot)
diff --git a/src/x11/events.c b/src/x11/events.c
index 24878775e..0d446fd58 100644
--- a/src/x11/events.c
+++ b/src/x11/events.c
@@ -856,7 +856,9 @@ handle_input_xevent (MetaDisplay  *display,
     }
 
   modified = xievent_get_modified_window (display, input_event);
-  window = modified != None ? meta_display_lookup_x_window (display, modified) : NULL;
+  window = modified != None ?
+           meta_x11_display_lookup_x_window (display->x11_display, modified) :
+           NULL;
 
   /* If this is an event for a GTK+ widget, let GTK+ handle it. */
   if (meta_ui_window_is_widget (display->screen->ui, modified))
@@ -1173,7 +1175,8 @@ notify_bell (MetaDisplay *display,
   XkbBellNotifyEvent *xkb_bell_event = (XkbBellNotifyEvent*) xkb_ev;
   MetaWindow *window;
 
-  window = meta_display_lookup_x_window (display, xkb_bell_event->window);
+  window = meta_x11_display_lookup_x_window (display->x11_display,
+                                             xkb_bell_event->window);
   if (!window && display->focus_window && display->focus_window->frame)
     window = display->focus_window;
 
@@ -1202,7 +1205,7 @@ handle_other_xevent (MetaDisplay *display,
   gboolean bypass_gtk = FALSE;
 
   modified = event_get_modified_window (display, event);
-  window = modified != None ? meta_display_lookup_x_window (display, modified) : NULL;
+  window = modified != None ? meta_x11_display_lookup_x_window (x11_display, modified) : NULL;
   frame_was_receiver = (window && window->frame && modified == window->frame->xwindow);
 
   /* We only want to respond to _NET_WM_USER_TIME property notify
@@ -1219,8 +1222,8 @@ handle_other_xevent (MetaDisplay *display,
   if (META_X11_DISPLAY_HAS_XSYNC (x11_display) &&
       event->type == (x11_display->xsync_event_base + XSyncAlarmNotify))
     {
-      MetaWindow *alarm_window = meta_display_lookup_sync_alarm (display,
-                                                                 ((XSyncAlarmNotifyEvent*)event)->alarm);
+      MetaWindow *alarm_window = meta_x11_display_lookup_sync_alarm (x11_display,
+                                                                     ((XSyncAlarmNotifyEvent*)event)->alarm);
 
       if (alarm_window != NULL)
         {
@@ -1232,10 +1235,10 @@ handle_other_xevent (MetaDisplay *display,
         }
       else
         {
-          if (display->alarm_filter &&
-              display->alarm_filter (display,
-                                     (XSyncAlarmNotifyEvent*)event,
-                                     display->alarm_filter_data))
+          if (x11_display->alarm_filter &&
+              x11_display->alarm_filter (x11_display,
+                                         (XSyncAlarmNotifyEvent*)event,
+                                          x11_display->alarm_filter_data))
             bypass_gtk = TRUE;
         }
 
@@ -1748,7 +1751,8 @@ meta_display_handle_xevent (MetaDisplay *display,
       meta_topic (META_DEBUG_FOCUS, "Earlier attempt to focus %s failed\n",
                   display->focus_window->desc);
       meta_display_update_focus_window (display,
-                                        meta_display_lookup_x_window (display, display->server_focus_window),
+                                        meta_x11_display_lookup_x_window (display->x11_display,
+                                                                          display->server_focus_window),
                                         display->server_focus_window,
                                         display->server_focus_serial,
                                         FALSE);
@@ -1780,7 +1784,7 @@ meta_display_handle_xevent (MetaDisplay *display,
     }
 
 #ifdef HAVE_XI23
-  if (meta_display_process_barrier_xevent (display, input_event))
+  if (meta_x11_display_process_barrier_xevent (display->x11_display, input_event))
     {
       bypass_gtk = bypass_compositor = TRUE;
       goto out;
@@ -1814,7 +1818,9 @@ meta_display_handle_xevent (MetaDisplay *display,
  out:
   if (!bypass_compositor)
     {
-      MetaWindow *window = modified != None ? meta_display_lookup_x_window (display, modified) : NULL;
+      MetaWindow *window = modified != None ?
+                           meta_x11_display_lookup_x_window (display->x11_display, modified) :
+                           NULL;
 
       if (meta_compositor_process_event (display->compositor, event, window))
         bypass_gtk = TRUE;
diff --git a/src/x11/meta-x11-display-private.h b/src/x11/meta-x11-display-private.h
index a4d29590b..6ccaf97cc 100644
--- a/src/x11/meta-x11-display-private.h
+++ b/src/x11/meta-x11-display-private.h
@@ -33,6 +33,10 @@
 #include "meta/types.h"
 #include "meta/meta-x11-display.h"
 
+typedef gboolean (*MetaAlarmFilter) (MetaX11Display        *x11_display,
+                                     XSyncAlarmNotifyEvent *event,
+                                     gpointer               data);
+
 struct _MetaX11Display
 {
   GObject parent;
@@ -54,6 +58,11 @@ struct _MetaX11Display
 #include "x11/atomnames.h"
 #undef item
 
+  GHashTable *xids;
+
+  MetaAlarmFilter alarm_filter;
+  gpointer alarm_filter_data;
+
   int composite_event_base;
   int composite_error_base;
   int composite_major_version;
@@ -96,4 +105,29 @@ Cursor meta_x11_display_create_x_cursor (MetaX11Display *x11_display,
 
 void meta_x11_display_reload_cursor (MetaX11Display *x11_display);
 
+MetaWindow *meta_x11_display_lookup_x_window     (MetaX11Display *x11_display,
+                                                  Window          xwindow);
+void        meta_x11_display_register_x_window   (MetaX11Display *x11_display,
+                                                  Window         *xwindowp,
+                                                  MetaWindow     *window);
+void        meta_x11_display_unregister_x_window (MetaX11Display *x11_display,
+                                                  Window          xwindow);
+
+MetaWindow *meta_x11_display_lookup_sync_alarm     (MetaX11Display *x11_display,
+                                                    XSyncAlarm      alarm);
+void        meta_x11_display_register_sync_alarm   (MetaX11Display *x11_display,
+                                                    XSyncAlarm     *alarmp,
+                                                    MetaWindow     *window);
+void        meta_x11_display_unregister_sync_alarm (MetaX11Display *x11_display,
+                                                    XSyncAlarm      alarm);
+
+#ifdef HAVE_XI23
+gboolean meta_x11_display_process_barrier_xevent (MetaX11Display *x11_display,
+                                                  XIEvent        *event);
+#endif /* HAVE_XI23 */
+
+void meta_x11_display_set_alarm_filter (MetaX11Display *x11_display,
+                                        MetaAlarmFilter filter,
+                                        gpointer        data);
+
 #endif /* META_X11_DISPLAY_PRIVATE_H */
diff --git a/src/x11/meta-x11-display.c b/src/x11/meta-x11-display.c
index 613766022..797f990c2 100644
--- a/src/x11/meta-x11-display.c
+++ b/src/x11/meta-x11-display.c
@@ -68,6 +68,15 @@ meta_x11_display_dispose (GObject *object)
 {
   MetaX11Display *x11_display = META_X11_DISPLAY (object);
 
+  if (x11_display->xids)
+    {
+      /* Must be after all calls to meta_window_unmanage() since they
+       * unregister windows
+       */
+      g_hash_table_destroy (x11_display->xids);
+      x11_display->xids = NULL;
+    }
+
   if (x11_display->xroot != None)
     {
       meta_error_trap_push (x11_display);
@@ -397,6 +406,9 @@ meta_x11_display_new (MetaDisplay *display, GError **error)
 
   update_cursor_theme (x11_display);
 
+  x11_display->xids = g_hash_table_new (meta_unsigned_long_hash,
+                                        meta_unsigned_long_equal);
+
   return x11_display;
 }
 
@@ -556,3 +568,72 @@ update_cursor_theme (MetaX11Display *x11_display)
       set_cursor_theme (xdisplay);
     }
 }
+
+MetaWindow *
+meta_x11_display_lookup_x_window (MetaX11Display *x11_display,
+                                  Window          xwindow)
+{
+  return g_hash_table_lookup (x11_display->xids, &xwindow);
+}
+
+void
+meta_x11_display_register_x_window (MetaX11Display *x11_display,
+                                    Window         *xwindowp,
+                                    MetaWindow     *window)
+{
+  g_return_if_fail (g_hash_table_lookup (x11_display->xids, xwindowp) == NULL);
+
+  g_hash_table_insert (x11_display->xids, xwindowp, window);
+}
+
+void
+meta_x11_display_unregister_x_window (MetaX11Display *x11_display,
+                                      Window          xwindow)
+{
+  g_return_if_fail (g_hash_table_lookup (x11_display->xids, &xwindow) != NULL);
+
+  g_hash_table_remove (x11_display->xids, &xwindow);
+}
+
+
+/* We store sync alarms in the window ID hash table, because they are
+ * just more types of XIDs in the same global space, but we have
+ * typesafe functions to register/unregister for readability.
+ */
+
+MetaWindow *
+meta_x11_display_lookup_sync_alarm (MetaX11Display *x11_display,
+                                    XSyncAlarm      alarm)
+{
+  return g_hash_table_lookup (x11_display->xids, &alarm);
+}
+
+void
+meta_x11_display_register_sync_alarm (MetaX11Display *x11_display,
+                                      XSyncAlarm     *alarmp,
+                                      MetaWindow     *window)
+{
+  g_return_if_fail (g_hash_table_lookup (x11_display->xids, alarmp) == NULL);
+
+  g_hash_table_insert (x11_display->xids, alarmp, window);
+}
+
+void
+meta_x11_display_unregister_sync_alarm (MetaX11Display *x11_display,
+                                        XSyncAlarm      alarm)
+{
+  g_return_if_fail (g_hash_table_lookup (x11_display->xids, &alarm) != NULL);
+
+  g_hash_table_remove (x11_display->xids, &alarm);
+}
+
+void
+meta_x11_display_set_alarm_filter (MetaX11Display *x11_display,
+                                   MetaAlarmFilter filter,
+                                   gpointer        data)
+{
+  g_return_if_fail (filter == NULL || x11_display->alarm_filter == NULL);
+
+  x11_display->alarm_filter = filter;
+  x11_display->alarm_filter_data = data;
+}
diff --git a/src/x11/window-props.c b/src/x11/window-props.c
index 8a8f37863..48c239177 100644
--- a/src/x11/window-props.c
+++ b/src/x11/window-props.c
@@ -468,8 +468,8 @@ reload_net_wm_user_time_window (MetaWindow    *window,
       if (window->user_time_window != None)
         {
           /* See the comment to the meta_display_register_x_window call below. */
-          meta_display_unregister_x_window (window->display,
-                                            window->user_time_window);
+          meta_x11_display_unregister_x_window (window->display->x11_display,
+                                                window->user_time_window);
           /* Don't get events on not-managed windows */
           XSelectInput (window->display->x11_display->xdisplay,
                         window->user_time_window,
@@ -479,10 +479,12 @@ reload_net_wm_user_time_window (MetaWindow    *window,
       /* Ensure the new user time window is not used on another MetaWindow,
        * and unset its user time window if that is the case.
        */
-      prev_owner = meta_display_lookup_x_window (window->display, value->v.xwindow);
+      prev_owner = meta_x11_display_lookup_x_window (window->display->x11_display,
+                                                     value->v.xwindow);
       if (prev_owner && prev_owner->user_time_window == value->v.xwindow)
         {
-          meta_display_unregister_x_window (window->display, value->v.xwindow);
+          meta_x11_display_unregister_x_window (window->display->x11_display,
+                                               value->v.xwindow);
           prev_owner->user_time_window = None;
         }
 
@@ -502,9 +504,9 @@ reload_net_wm_user_time_window (MetaWindow    *window,
            * than atom__NET_WM_USER_TIME ones, but I just don't care
            * and it's not specified in the spec anyway.
            */
-          meta_display_register_x_window (window->display,
-                                          &window->user_time_window,
-                                          window);
+          meta_x11_display_register_x_window (window->display->x11_display,
+                                              &window->user_time_window,
+                                              window);
           /* Just listen for property notify events */
           XSelectInput (window->display->x11_display->xdisplay,
                         window->user_time_window,
@@ -1630,7 +1632,8 @@ reload_transient_for (MetaWindow    *window,
     {
       transient_for = value->v.xwindow;
 
-      parent = meta_display_lookup_x_window (window->display, transient_for);
+      parent = meta_x11_display_lookup_x_window (window->display->x11_display,
+                                                 transient_for);
       if (!parent)
         {
           meta_warning ("Invalid WM_TRANSIENT_FOR window 0x%lx specified for %s.\n",
@@ -1649,8 +1652,8 @@ reload_transient_for (MetaWindow    *window,
               break;
             }
 
-          parent = meta_display_lookup_x_window (parent->display,
-                                                 parent->xtransient_for);
+          parent = meta_x11_display_lookup_x_window (parent->display->x11_display,
+                                                     parent->xtransient_for);
         }
     }
   else
@@ -1671,8 +1674,8 @@ reload_transient_for (MetaWindow    *window,
     meta_window_set_transient_for (window, NULL);
   else
     {
-      parent = meta_display_lookup_x_window (window->display,
-                                             window->xtransient_for);
+      parent = meta_x11_display_lookup_x_window (window->display->x11_display,
+                                                 window->xtransient_for);
       meta_window_set_transient_for (window, parent);
     }
 }
diff --git a/src/x11/window-x11.c b/src/x11/window-x11.c
index e27f78f27..66bc8ae19 100644
--- a/src/x11/window-x11.c
+++ b/src/x11/window-x11.c
@@ -510,7 +510,9 @@ meta_window_x11_manage (MetaWindow *window)
 
   meta_icon_cache_init (&priv->icon_cache);
 
-  meta_display_register_x_window (display, &window->xwindow, window);
+  meta_x11_display_register_x_window (display->x11_display,
+                                      &window->xwindow,
+                                      window);
 
   /* assign the window to its group, or create a new group if needed */
   window->group = NULL;
@@ -617,7 +619,7 @@ meta_window_x11_unmanage (MetaWindow *window)
                   window->xwindow);
     }
 
-  meta_display_unregister_x_window (window->display, window->xwindow);
+  meta_x11_display_unregister_x_window (x11_display, window->xwindow);
 
   /* Put back anything we messed up */
   if (priv->border_width != 0)
@@ -645,8 +647,8 @@ meta_window_x11_unmanage (MetaWindow *window)
 
   if (window->user_time_window != None)
     {
-      meta_display_unregister_x_window (window->display,
-                                        window->user_time_window);
+      meta_x11_display_unregister_x_window (x11_display,
+                                            window->user_time_window);
       window->user_time_window = None;
     }
 
@@ -2247,8 +2249,8 @@ meta_window_x11_configure_request (MetaWindow *window,
               MetaDisplay *display;
 
               display = meta_window_get_display (window);
-              sibling = meta_display_lookup_x_window (display,
-                                                      event->xconfigurerequest.above);
+              sibling = meta_x11_display_lookup_x_window (display->x11_display,
+                                                          event->xconfigurerequest.above);
               if (sibling == NULL)
                 return TRUE;
 
@@ -2340,14 +2342,14 @@ handle_net_restack_window (MetaDisplay *display,
   if (event->xclient.data.l[0] != 2)
     return;
 
-  window = meta_display_lookup_x_window (display,
-                                         event->xclient.window);
+  window = meta_x11_display_lookup_x_window (display->x11_display,
+                                             event->xclient.window);
 
   if (window)
     {
       if (event->xclient.data.l[1])
-        sibling = meta_display_lookup_x_window (display,
-                                                event->xclient.data.l[1]);
+        sibling = meta_x11_display_lookup_x_window (display->x11_display,
+                                                    event->xclient.data.l[1]);
 
       restack_window (window, sibling, event->xclient.data.l[2]);
     }
@@ -3484,7 +3486,7 @@ meta_window_x11_create_sync_request_alarm (MetaWindow *window)
                                                  &values);
 
   if (meta_error_trap_pop_with_return (x11_display) == Success)
-    meta_display_register_sync_alarm (window->display, &window->sync_request_alarm, window);
+    meta_x11_display_register_sync_alarm (x11_display, &window->sync_request_alarm, window);
   else
     {
       window->sync_request_alarm = None;
@@ -3495,11 +3497,13 @@ meta_window_x11_create_sync_request_alarm (MetaWindow *window)
 void
 meta_window_x11_destroy_sync_request_alarm (MetaWindow *window)
 {
+  MetaX11Display *x11_display = window->display->x11_display;
+
   if (window->sync_request_alarm != None)
     {
       /* Has to be unregistered _before_ clearing the structure field */
-      meta_display_unregister_sync_alarm (window->display, window->sync_request_alarm);
-      XSyncDestroyAlarm (window->display->x11_display->xdisplay,
+      meta_x11_display_unregister_sync_alarm (x11_display, window->sync_request_alarm);
+      XSyncDestroyAlarm (x11_display->xdisplay,
                          window->sync_request_alarm);
       window->sync_request_alarm = None;
     }
diff --git a/src/x11/xprops.c b/src/x11/xprops.c
index 47bded438..be0d47423 100644
--- a/src/x11/xprops.c
+++ b/src/x11/xprops.c
@@ -132,7 +132,7 @@ validate_or_free_results (GetPropertyResults *results,
   prop_name = XGetAtomName (x11_display->xdisplay, results->xatom);
   meta_error_trap_pop (x11_display);
 
-  w = meta_display_lookup_x_window (results->display, results->xwindow);
+  w = meta_x11_display_lookup_x_window (x11_display, results->xwindow);
 
   if (w != NULL)
     {



[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]