sungmg/mutter-performance-source
1
0
Fork 0
Code Activity

core: Setup and use ownership chains

Browse source 
As with other parts, make objects have the ability to walk up the
ownership chain to the context, to get things like the Wayland
compositor or backend instances.

Contains these squashed commits:

display: Don't get backend from singleton

window: Don't get backend from singleton

keybindings: Don't get backend from singleton

workspace: Don't get backend from singleton

display: Don't get Wayland compositor from singleton

selection: Add display getter

context/main: Get backend directly from the context

clipboard-manager: Don't get display from singleton

stack-tracker: Don't use singleton MetaLater API

startup-notification: Hook up sequences and activations to display

This allows using context aware API directly.

Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2718>
This commit is contained in:
Jonas Ådahl 2022-05-27 22:27:07 +02:00 committed by Robert Mader
parent 0e8aaebc00
commit dd2beae6a8
18 changed files with 243 additions and 97 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
src/core/constraints.c
View file

@ -121,6 +121,8 @@ typedef enum
typedef struct typedef struct
{ {
MetaBackend *backend;
MetaRectangle orig; MetaRectangle orig;
MetaRectangle current; MetaRectangle current;
MetaRectangle temporary; MetaRectangle temporary;
@ -205,7 +207,8 @@ static gboolean constrain_partially_onscreen (MetaWindow *window,
ConstraintPriority priority, ConstraintPriority priority,
gboolean check_only); gboolean check_only);
static void setup_constraint_info (ConstraintInfo *info, static void setup_constraint_info (MetaBackend *backend,
ConstraintInfo *info,
MetaWindow *window, MetaWindow *window,
MetaMoveResizeFlags flags, MetaMoveResizeFlags flags,
MetaGravity resize_gravity, MetaGravity resize_gravity,
@ -291,6 +294,9 @@ meta_window_constrain (MetaWindow *window,
int *rel_x, int *rel_x,
int *rel_y) int *rel_y)
{ {
MetaDisplay *display = meta_window_get_display (window);
MetaContext *context = meta_display_get_context (display);
MetaBackend *backend = meta_context_get_backend (context);
ConstraintInfo info; ConstraintInfo info;
ConstraintPriority priority = PRIORITY_MINIMUM; ConstraintPriority priority = PRIORITY_MINIMUM;
gboolean satisfied = FALSE; gboolean satisfied = FALSE;
@ -301,7 +307,8 @@ meta_window_constrain (MetaWindow *window,
orig->x, orig->y, orig->width, orig->height, orig->x, orig->y, orig->width, orig->height,
new->x, new->y, new->width, new->height); new->x, new->y, new->width, new->height);
setup_constraint_info (&info, setup_constraint_info (backend,
&info,
window, window,
flags, flags,
resize_gravity, resize_gravity,
@ -338,20 +345,21 @@ meta_window_constrain (MetaWindow *window,
} }
static void static void
setup_constraint_info (ConstraintInfo *info, setup_constraint_info (MetaBackend *backend,
ConstraintInfo *info,
MetaWindow *window, MetaWindow *window,
MetaMoveResizeFlags flags, MetaMoveResizeFlags flags,
MetaGravity resize_gravity, MetaGravity resize_gravity,
const MetaRectangle *orig, const MetaRectangle *orig,
MetaRectangle *new) MetaRectangle *new)
{ {
MetaBackend *backend = meta_get_backend ();
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
MetaLogicalMonitor *logical_monitor; MetaLogicalMonitor *logical_monitor;
MetaWorkspace *cur_workspace; MetaWorkspace *cur_workspace;
MetaPlacementRule *placement_rule; MetaPlacementRule *placement_rule;
info->backend = backend;
info->orig = *orig; info->orig = *orig;
info->current = *new; info->current = *new;
info->temporary = *orig; info->temporary = *orig;
@ -532,9 +540,8 @@ place_window_if_needed(MetaWindow *window,
!window->minimized && !window->minimized &&
!window->fullscreen) !window->fullscreen)
{ {
MetaBackend *backend = meta_get_backend ();
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (info->backend);
MetaRectangle orig_rect; MetaRectangle orig_rect;
MetaRectangle placed_rect; MetaRectangle placed_rect;
MetaWorkspace *cur_workspace; MetaWorkspace *cur_workspace;
@ -1688,9 +1695,8 @@ constrain_to_single_monitor (MetaWindow *window,
ConstraintPriority priority, ConstraintPriority priority,
gboolean check_only) gboolean check_only)
{ {
MetaBackend *backend = meta_get_backend ();
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (info->backend);
if (priority > PRIORITY_ENTIRELY_VISIBLE_ON_SINGLE_MONITOR) if (priority > PRIORITY_ENTIRELY_VISIBLE_ON_SINGLE_MONITOR)
return TRUE; return TRUE;

73
src/core/display.c
View file

@ -211,6 +211,24 @@ meta_display_show_osd (MetaDisplay *display,
const gchar *icon_name, const gchar *icon_name,
const gchar *message); const gchar *message);
static MetaBackend *
backend_from_display (MetaDisplay *display)
{
MetaContext *context = meta_display_get_context (display);
return meta_context_get_backend (context);
}
#ifdef HAVE_WAYLAND
static MetaWaylandCompositor *
wayland_compositor_from_display (MetaDisplay *display)
{
MetaContext *context = meta_display_get_context (display);
return meta_context_get_wayland_compositor (context);
}
#endif
static void static void
meta_display_get_property(GObject *object, meta_display_get_property(GObject *object,
guint prop_id, guint prop_id,
@ -614,7 +632,7 @@ meta_display_remove_pending_pings_for_window (MetaDisplay *display,
static MetaCompositor * static MetaCompositor *
create_compositor (MetaDisplay *display) create_compositor (MetaDisplay *display)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_display (display);
#ifdef HAVE_WAYLAND #ifdef HAVE_WAYLAND
#ifdef HAVE_NATIVE_BACKEND #ifdef HAVE_NATIVE_BACKEND
@ -643,7 +661,7 @@ meta_display_cancel_touch (MetaDisplay *display)
if (!meta_is_wayland_compositor ()) if (!meta_is_wayland_compositor ())
return; return;
compositor = meta_wayland_compositor_get_default (); compositor = wayland_compositor_from_display (display);
meta_wayland_touch_cancel (compositor->seat->touch); meta_wayland_touch_cancel (compositor->seat->touch);
#endif #endif
} }
@ -667,7 +685,7 @@ gesture_tracker_state_changed (MetaGestureTracker *tracker,
{ {
MetaBackend *backend; MetaBackend *backend;
backend = meta_get_backend (); backend = backend_from_display (display);
meta_backend_finish_touch_sequence (backend, sequence, state); meta_backend_finish_touch_sequence (backend, sequence, state);
break; break;
} }
@ -795,7 +813,7 @@ meta_display_init_x11 (MetaDisplay *display,
GAsyncReadyCallback callback, GAsyncReadyCallback callback,
gpointer user_data) gpointer user_data)
{ {
MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default (); MetaWaylandCompositor *compositor = wayland_compositor_from_display (display);
g_autoptr (GTask) task = NULL; g_autoptr (GTask) task = NULL;
@ -933,7 +951,7 @@ meta_display_new (MetaContext *context,
if (meta_is_wayland_compositor ()) if (meta_is_wayland_compositor ())
{ {
MetaWaylandCompositor *wayland_compositor = MetaWaylandCompositor *wayland_compositor =
meta_wayland_compositor_get_default (); wayland_compositor_from_display (display);
MetaX11DisplayPolicy x11_display_policy; MetaX11DisplayPolicy x11_display_policy;
meta_wayland_compositor_init_display (wayland_compositor, display); meta_wayland_compositor_init_display (wayland_compositor, display);
@ -1277,7 +1295,7 @@ meta_grab_op_is_moving (MetaGrabOp op)
gboolean gboolean
meta_display_windows_are_interactable (MetaDisplay *display) meta_display_windows_are_interactable (MetaDisplay *display)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_display (display);
MetaStage *stage = META_STAGE (meta_backend_get_stage (backend)); MetaStage *stage = META_STAGE (meta_backend_get_stage (backend));
if (clutter_stage_get_grab_actor (CLUTTER_STAGE (stage))) if (clutter_stage_get_grab_actor (CLUTTER_STAGE (stage)))
@ -1427,9 +1445,9 @@ void
meta_display_sync_wayland_input_focus (MetaDisplay *display) meta_display_sync_wayland_input_focus (MetaDisplay *display)
{ {
#ifdef HAVE_WAYLAND #ifdef HAVE_WAYLAND
MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default (); MetaWaylandCompositor *compositor = wayland_compositor_from_display (display);
MetaWindow *focus_window = NULL; MetaWindow *focus_window = NULL;
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_display (display);
ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend); ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend);
ClutterSeat *seat = clutter_backend_get_default_seat (clutter_backend); ClutterSeat *seat = clutter_backend_get_default_seat (clutter_backend);
MetaStage *stage = META_STAGE (meta_backend_get_stage (backend)); MetaStage *stage = META_STAGE (meta_backend_get_stage (backend));
@ -1739,7 +1757,7 @@ root_cursor_prepare_at (MetaCursorSpriteXcursor *sprite_xcursor,
MetaDisplay *display) MetaDisplay *display)
{ {
MetaCursorSprite *cursor_sprite = META_CURSOR_SPRITE (sprite_xcursor); MetaCursorSprite *cursor_sprite = META_CURSOR_SPRITE (sprite_xcursor);
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_display (display);
if (meta_backend_is_stage_views_scaled (backend)) if (meta_backend_is_stage_views_scaled (backend))
{ {
@ -1787,7 +1805,7 @@ meta_display_reload_cursor (MetaDisplay *display)
{ {
MetaCursor cursor = display->current_cursor; MetaCursor cursor = display->current_cursor;
MetaCursorSpriteXcursor *sprite_xcursor; MetaCursorSpriteXcursor *sprite_xcursor;
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_display (display);
MetaCursorTracker *cursor_tracker = meta_backend_get_cursor_tracker (backend); MetaCursorTracker *cursor_tracker = meta_backend_get_cursor_tracker (backend);
sprite_xcursor = meta_cursor_sprite_xcursor_new (cursor, cursor_tracker); sprite_xcursor = meta_cursor_sprite_xcursor_new (cursor, cursor_tracker);
@ -1882,7 +1900,7 @@ meta_display_begin_grab_op (MetaDisplay *display,
int root_x, int root_x,
int root_y) int root_y)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_display (display);
MetaWindow *grab_window = NULL; MetaWindow *grab_window = NULL;
MetaEventRoute event_route; MetaEventRoute event_route;
@ -1931,7 +1949,8 @@ meta_display_begin_grab_op (MetaDisplay *display,
if (pointer_already_grabbed) if (pointer_already_grabbed)
display->grab_have_pointer = TRUE; display->grab_have_pointer = TRUE;
if (META_IS_BACKEND_X11 (meta_get_backend ()) && display->x11_display) if (META_IS_BACKEND_X11 (backend_from_display (display)) &&
display->x11_display)
{ {
/* Since grab operations often happen as a result of implicit /* Since grab operations often happen as a result of implicit
* pointer operations on the display X11 connection, we need * pointer operations on the display X11 connection, we need
@ -2046,7 +2065,7 @@ meta_display_end_grab_op (MetaDisplay *display,
if (display->grab_have_pointer) if (display->grab_have_pointer)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_display (display);
meta_backend_ungrab_device (backend, META_VIRTUAL_CORE_POINTER_ID, timestamp); meta_backend_ungrab_device (backend, META_VIRTUAL_CORE_POINTER_ID, timestamp);
} }
@ -2896,7 +2915,7 @@ meta_display_get_size (MetaDisplay *display,
int *width, int *width,
int *height) int *height)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_display (display);
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
int display_width, display_height; int display_width, display_height;
@ -3015,7 +3034,7 @@ meta_display_request_pad_osd (MetaDisplay *display,
ClutterInputDevice *pad, ClutterInputDevice *pad,
gboolean edition_mode) gboolean edition_mode)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_display (display);
MetaInputMapper *input_mapper; MetaInputMapper *input_mapper;
const gchar *layout_path = NULL; const gchar *layout_path = NULL;
ClutterActor *osd; ClutterActor *osd;
@ -3032,7 +3051,7 @@ meta_display_request_pad_osd (MetaDisplay *display,
if (display->current_pad_osd) if (display->current_pad_osd)
return; return;
input_mapper = meta_backend_get_input_mapper (meta_get_backend ()); input_mapper = meta_backend_get_input_mapper (backend_from_display (display));
if (input_mapper) if (input_mapper)
{ {
@ -3086,7 +3105,7 @@ meta_display_get_pad_action_label (MetaDisplay *display,
MetaWaylandTabletSeat *tablet_seat; MetaWaylandTabletSeat *tablet_seat;
MetaWaylandTabletPad *tablet_pad = NULL; MetaWaylandTabletPad *tablet_pad = NULL;
compositor = meta_wayland_compositor_get_default (); compositor = wayland_compositor_from_display (display);
tablet_seat = meta_wayland_tablet_manager_ensure_seat (compositor->tablet_manager, tablet_seat = meta_wayland_tablet_manager_ensure_seat (compositor->tablet_manager,
compositor->seat); compositor->seat);
if (tablet_seat) if (tablet_seat)
@ -3124,7 +3143,7 @@ lookup_tablet_monitor (MetaDisplay *display,
MetaLogicalMonitor *monitor; MetaLogicalMonitor *monitor;
gint monitor_idx = -1; gint monitor_idx = -1;
input_mapper = meta_backend_get_input_mapper (meta_get_backend ()); input_mapper = meta_backend_get_input_mapper (backend_from_display (display));
if (!input_mapper) if (!input_mapper)
return -1; return -1;
@ -3488,7 +3507,7 @@ static gboolean
check_fullscreen_func (gpointer data) check_fullscreen_func (gpointer data)
{ {
MetaDisplay *display = data; MetaDisplay *display = data;
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_display (display);
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
GList *logical_monitors, *l; GList *logical_monitors, *l;
@ -3605,7 +3624,7 @@ int
meta_display_get_monitor_index_for_rect (MetaDisplay *display, meta_display_get_monitor_index_for_rect (MetaDisplay *display,
MetaRectangle *rect) MetaRectangle *rect)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_display (display);
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
MetaLogicalMonitor *logical_monitor; MetaLogicalMonitor *logical_monitor;
@ -3623,7 +3642,7 @@ meta_display_get_monitor_neighbor_index (MetaDisplay *display,
int which_monitor, int which_monitor,
MetaDisplayDirection direction) MetaDisplayDirection direction)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_display (display);
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
MetaLogicalMonitor *logical_monitor; MetaLogicalMonitor *logical_monitor;
@ -3649,7 +3668,7 @@ meta_display_get_monitor_neighbor_index (MetaDisplay *display,
int int
meta_display_get_current_monitor (MetaDisplay *display) meta_display_get_current_monitor (MetaDisplay *display)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_display (display);
MetaLogicalMonitor *logical_monitor; MetaLogicalMonitor *logical_monitor;
logical_monitor = meta_backend_get_current_logical_monitor (backend); logical_monitor = meta_backend_get_current_logical_monitor (backend);
@ -3672,7 +3691,7 @@ meta_display_get_current_monitor (MetaDisplay *display)
int int
meta_display_get_n_monitors (MetaDisplay *display) meta_display_get_n_monitors (MetaDisplay *display)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_display (display);
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
@ -3692,7 +3711,7 @@ meta_display_get_n_monitors (MetaDisplay *display)
int int
meta_display_get_primary_monitor (MetaDisplay *display) meta_display_get_primary_monitor (MetaDisplay *display)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_display (display);
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
MetaLogicalMonitor *logical_monitor; MetaLogicalMonitor *logical_monitor;
@ -3720,7 +3739,7 @@ meta_display_get_monitor_geometry (MetaDisplay *display,
int monitor, int monitor,
MetaRectangle *geometry) MetaRectangle *geometry)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_display (display);
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
MetaLogicalMonitor *logical_monitor; MetaLogicalMonitor *logical_monitor;
@ -3752,7 +3771,7 @@ float
meta_display_get_monitor_scale (MetaDisplay *display, meta_display_get_monitor_scale (MetaDisplay *display,
int monitor) int monitor)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_display (display);
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
MetaLogicalMonitor *logical_monitor; MetaLogicalMonitor *logical_monitor;
@ -3788,7 +3807,7 @@ gboolean
meta_display_get_monitor_in_fullscreen (MetaDisplay *display, meta_display_get_monitor_in_fullscreen (MetaDisplay *display,
int monitor) int monitor)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_display (display);
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
MetaLogicalMonitor *logical_monitor; MetaLogicalMonitor *logical_monitor;

7
src/core/events.c
View file

@ -231,11 +231,12 @@ meta_display_handle_event (MetaDisplay *display,
MetaGestureTracker *gesture_tracker; MetaGestureTracker *gesture_tracker;
ClutterEventSequence *sequence; ClutterEventSequence *sequence;
gboolean has_grab; gboolean has_grab;
#ifdef HAVE_WAYLAND
MetaWaylandCompositor *wayland_compositor;
#endif
#ifdef HAVE_WAYLAND #ifdef HAVE_WAYLAND
MetaWaylandCompositor *wayland_compositor = NULL; wayland_compositor = meta_context_get_wayland_compositor (context);
if (meta_is_wayland_compositor ())
wayland_compositor = meta_wayland_compositor_get_default ();
#endif #endif
has_grab = stage_has_grab (display); has_grab = stage_has_grab (display);

78
src/core/keybindings.c
View file

@ -1420,6 +1420,10 @@ meta_change_keygrab (MetaKeyBindingManager *keys,
gboolean grab, gboolean grab,
MetaResolvedKeyCombo *resolved_combo) MetaResolvedKeyCombo *resolved_combo)
{ {
MetaBackendX11 *backend_x11;
Display *xdisplay;
GArray *mods;
int i;
unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 }; unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits }; XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits };
@ -1429,10 +1433,8 @@ meta_change_keygrab (MetaKeyBindingManager *keys,
if (meta_is_wayland_compositor ()) if (meta_is_wayland_compositor ())
return; return;
MetaBackendX11 *backend = META_BACKEND_X11 (meta_get_backend ()); backend_x11 = META_BACKEND_X11 (keys->backend);
Display *xdisplay = meta_backend_x11_get_xdisplay (backend); xdisplay = meta_backend_x11_get_xdisplay (backend_x11);
GArray *mods;
int i;
/* Grab keycode/modmask, together with /* Grab keycode/modmask, together with
* all combinations of ignored modifiers. * all combinations of ignored modifiers.
@ -1753,10 +1755,13 @@ meta_display_ungrab_accelerator (MetaDisplay *display,
} }
static gboolean static gboolean
grab_keyboard (Window xwindow, grab_keyboard (MetaBackend *backend,
guint32 timestamp, Window xwindow,
int grab_mode) uint32_t timestamp,
int grab_mode)
{ {
MetaBackendX11 *backend_x11;
Display *xdisplay;
int grab_status; int grab_status;
unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 }; unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
@ -1772,8 +1777,8 @@ grab_keyboard (Window xwindow,
* presses * presses
*/ */
MetaBackendX11 *backend = META_BACKEND_X11 (meta_get_backend ()); backend_x11 = META_BACKEND_X11 (backend);
Display *xdisplay = meta_backend_x11_get_xdisplay (backend); xdisplay = meta_backend_x11_get_xdisplay (backend_x11);
/* Strictly, we only need to set grab_mode on the keyboard device /* Strictly, we only need to set grab_mode on the keyboard device
* while the pointer should always be XIGrabModeAsync. Unfortunately * while the pointer should always be XIGrabModeAsync. Unfortunately
@ -1797,13 +1802,17 @@ grab_keyboard (Window xwindow,
} }
static void static void
ungrab_keyboard (guint32 timestamp) ungrab_keyboard (MetaBackend *backend,
uint32_t timestamp)
{ {
MetaBackendX11 *backend_x11;
Display *xdisplay;
if (meta_is_wayland_compositor ()) if (meta_is_wayland_compositor ())
return; return;
MetaBackendX11 *backend = META_BACKEND_X11 (meta_get_backend ()); backend_x11 = META_BACKEND_X11 (backend);
Display *xdisplay = meta_backend_x11_get_xdisplay (backend); xdisplay = meta_backend_x11_get_xdisplay (backend_x11);
XIUngrabDevice (xdisplay, META_VIRTUAL_CORE_KEYBOARD_ID, timestamp); XIUngrabDevice (xdisplay, META_VIRTUAL_CORE_KEYBOARD_ID, timestamp);
} }
@ -1812,6 +1821,9 @@ gboolean
meta_window_grab_all_keys (MetaWindow *window, meta_window_grab_all_keys (MetaWindow *window,
guint32 timestamp) guint32 timestamp)
{ {
MetaDisplay *display = meta_window_get_display (window);
MetaContext *context = meta_display_get_context (display);
MetaBackend *backend = meta_context_get_backend (context);
Window grabwindow; Window grabwindow;
gboolean retval = TRUE; gboolean retval = TRUE;
@ -1835,7 +1847,7 @@ meta_window_grab_all_keys (MetaWindow *window,
meta_topic (META_DEBUG_KEYBINDINGS, meta_topic (META_DEBUG_KEYBINDINGS,
"Grabbing all keys on window %s", window->desc); "Grabbing all keys on window %s", window->desc);
retval = grab_keyboard (grabwindow, timestamp, XIGrabModeAsync); retval = grab_keyboard (backend, grabwindow, timestamp, XIGrabModeAsync);
} }
if (retval) if (retval)
{ {
@ -1854,7 +1866,13 @@ meta_window_ungrab_all_keys (MetaWindow *window,
if (window->all_keys_grabbed) if (window->all_keys_grabbed)
{ {
if (!meta_is_wayland_compositor()) if (!meta_is_wayland_compositor())
ungrab_keyboard (timestamp); {
MetaDisplay *display = meta_window_get_display (window);
MetaContext *context = meta_display_get_context (display);
MetaBackend *backend = meta_context_get_backend (context);
ungrab_keyboard (backend, timestamp);
}
window->grab_on_frame = FALSE; window->grab_on_frame = FALSE;
window->all_keys_grabbed = FALSE; window->all_keys_grabbed = FALSE;
@ -1868,25 +1886,30 @@ meta_window_ungrab_all_keys (MetaWindow *window,
void void
meta_display_freeze_keyboard (MetaDisplay *display, guint32 timestamp) meta_display_freeze_keyboard (MetaDisplay *display, guint32 timestamp)
{ {
MetaBackend *backend = meta_get_backend (); MetaContext *context = meta_display_get_context (display);
MetaBackend *backend = meta_context_get_backend (context);
if (!META_IS_BACKEND_X11 (backend)) if (!META_IS_BACKEND_X11 (backend))
return; return;
Window window = meta_backend_x11_get_xwindow (META_BACKEND_X11 (backend)); Window window = meta_backend_x11_get_xwindow (META_BACKEND_X11 (backend));
grab_keyboard (window, timestamp, XIGrabModeSync); grab_keyboard (backend, window, timestamp, XIGrabModeSync);
} }
void void
meta_display_ungrab_keyboard (MetaDisplay *display, guint32 timestamp) meta_display_ungrab_keyboard (MetaDisplay *display, guint32 timestamp)
{ {
ungrab_keyboard (timestamp); MetaContext *context = meta_display_get_context (display);
MetaBackend *backend = meta_context_get_backend (context);
ungrab_keyboard (backend, timestamp);
} }
void void
meta_display_unfreeze_keyboard (MetaDisplay *display, guint32 timestamp) meta_display_unfreeze_keyboard (MetaDisplay *display, guint32 timestamp)
{ {
MetaBackend *backend = meta_get_backend (); MetaContext *context = meta_display_get_context (display);
MetaBackend *backend = meta_context_get_backend (context);
if (!META_IS_BACKEND_X11 (backend)) if (!META_IS_BACKEND_X11 (backend))
return; return;
@ -2259,7 +2282,9 @@ process_key_event (MetaDisplay *display,
} }
{ {
MetaBackend *backend = meta_get_backend (); MetaContext *context = meta_display_get_context (display);
MetaBackend *backend = meta_context_get_backend (context);
if (META_IS_BACKEND_X11 (backend)) if (META_IS_BACKEND_X11 (backend))
{ {
Display *xdisplay = meta_backend_x11_get_xdisplay (META_BACKEND_X11 (backend)); Display *xdisplay = meta_backend_x11_get_xdisplay (META_BACKEND_X11 (backend));
@ -3473,7 +3498,8 @@ handle_move_to_monitor (MetaDisplay *display,
MetaKeyBinding *binding, MetaKeyBinding *binding,
gpointer dummy) gpointer dummy)
{ {
MetaBackend *backend = meta_get_backend (); MetaContext *context = meta_display_get_context (display);
MetaBackend *backend = meta_context_get_backend (context);
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
gint which = binding->handler->data; gint which = binding->handler->data;
@ -3594,7 +3620,8 @@ handle_switch_monitor (MetaDisplay *display,
MetaKeyBinding *binding, MetaKeyBinding *binding,
gpointer dummy) gpointer dummy)
{ {
MetaBackend *backend = meta_get_backend (); MetaContext *context = meta_display_get_context (display);
MetaBackend *backend = meta_context_get_backend (context);
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
MetaMonitorSwitchConfigType config_type = MetaMonitorSwitchConfigType config_type =
@ -3614,7 +3641,8 @@ handle_rotate_monitor (MetaDisplay *display,
MetaKeyBinding *binding, MetaKeyBinding *binding,
gpointer dummy) gpointer dummy)
{ {
MetaBackend *backend = meta_get_backend (); MetaContext *context = meta_display_get_context (display);
MetaBackend *backend = meta_context_get_backend (context);
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
@ -3949,7 +3977,8 @@ init_builtin_key_bindings (MetaDisplay *display)
handle_rotate_monitor, 0); handle_rotate_monitor, 0);
#ifdef HAVE_NATIVE_BACKEND #ifdef HAVE_NATIVE_BACKEND
MetaBackend *backend = meta_get_backend (); MetaContext *context = meta_display_get_context (display);
MetaBackend *backend = meta_context_get_backend (context);
if (META_IS_BACKEND_NATIVE (backend)) if (META_IS_BACKEND_NATIVE (backend))
{ {
add_builtin_keybinding (display, add_builtin_keybinding (display,
@ -4452,7 +4481,8 @@ void
meta_display_init_keys (MetaDisplay *display) meta_display_init_keys (MetaDisplay *display)
{ {
MetaKeyBindingManager *keys = &display->key_binding_manager; MetaKeyBindingManager *keys = &display->key_binding_manager;
MetaBackend *backend = meta_get_backend (); MetaContext *context = meta_display_get_context (display);
MetaBackend *backend = meta_context_get_backend (context);
MetaKeyHandler *handler; MetaKeyHandler *handler;
keys->backend = backend; keys->backend = backend;

3
src/core/meta-clipboard-manager.c
View file

@ -22,6 +22,7 @@
#include "config.h" #include "config.h"
#include "core/meta-clipboard-manager.h" #include "core/meta-clipboard-manager.h"
#include "core/meta-selection-private.h"
#include "meta/meta-selection-source-memory.h" #include "meta/meta-selection-source-memory.h"
#define MAX_TEXT_SIZE (4 * 1024 * 1024) /* 4MB */ #define MAX_TEXT_SIZE (4 * 1024 * 1024) /* 4MB */
@ -68,7 +69,7 @@ transfer_cb (MetaSelection *selection,
GAsyncResult *result, GAsyncResult *result,
GOutputStream *output) GOutputStream *output)
{ {
MetaDisplay *display = meta_get_display (); MetaDisplay *display = meta_selection_get_display (selection);
GError *error = NULL; GError *error = NULL;
if (!meta_selection_transfer_finish (selection, result, &error)) if (!meta_selection_transfer_finish (selection, result, &error))

3
src/core/meta-context-main.c
View file

@ -343,7 +343,8 @@ static gboolean
add_persistent_virtual_monitors (MetaContextMain *context_main, add_persistent_virtual_monitors (MetaContextMain *context_main,
GError **error) GError **error)
{ {
MetaBackend *backend = meta_get_backend (); MetaContext *context = META_CONTEXT (context_main);
MetaBackend *backend = meta_context_get_backend (context);
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
GList *l; GList *l;

1
src/core/meta-launch-context.c
View file

@ -176,6 +176,7 @@ meta_launch_context_get_startup_notify_id (GAppLaunchContext *launch_context,
sn = meta_display_get_startup_notification (context->display); sn = meta_display_get_startup_notification (context->display);
seq = g_object_new (META_TYPE_STARTUP_SEQUENCE, seq = g_object_new (META_TYPE_STARTUP_SEQUENCE,
"display", context->display,
"id", startup_id, "id", startup_id,
"application-id", application_id, "application-id", application_id,
"name", g_app_info_get_name (info), "name", g_app_info_get_name (info),

2
src/core/meta-selection-private.h
View file

@ -29,4 +29,6 @@ MetaSelectionSource *
meta_selection_get_current_owner (MetaSelection *selection, meta_selection_get_current_owner (MetaSelection *selection,
MetaSelectionType selection_type); MetaSelectionType selection_type);
MetaDisplay * meta_selection_get_display (MetaSelection *selection);
#endif /* META_SELECTION_PRIVATE_H */ #endif /* META_SELECTION_PRIVATE_H */

6
src/core/meta-selection.c
View file

@ -488,3 +488,9 @@ meta_selection_get_current_owner (MetaSelection *selection,
return selection->owners[selection_type]; return selection->owners[selection_type];
} }
MetaDisplay *
meta_selection_get_display (MetaSelection *selection)
{
return selection->display;
}

8
src/core/place.c
View file

@ -84,7 +84,9 @@ find_next_cascade (MetaWindow *window,
int *new_x, int *new_x,
int *new_y) int *new_y)
{ {
MetaBackend *backend = meta_get_backend (); MetaDisplay *display = meta_window_get_display (window);
MetaContext *context = meta_display_get_context (display);
MetaBackend *backend = meta_context_get_backend (context);
GList *tmp; GList *tmp;
GList *sorted; GList *sorted;
int cascade_x, cascade_y; int cascade_x, cascade_y;
@ -665,7 +667,9 @@ meta_window_place (MetaWindow *window,
int *new_x, int *new_x,
int *new_y) int *new_y)
{ {
MetaBackend *backend = meta_get_backend (); MetaDisplay *display = meta_window_get_display (window);
MetaContext *context = meta_display_get_context (display);
MetaBackend *backend = meta_context_get_backend (context);
GList *windows = NULL; GList *windows = NULL;
MetaLogicalMonitor *logical_monitor; MetaLogicalMonitor *logical_monitor;

28
src/core/stack-tracker.c
View file

@ -584,7 +584,13 @@ void
meta_stack_tracker_free (MetaStackTracker *tracker) meta_stack_tracker_free (MetaStackTracker *tracker)
{ {
if (tracker->sync_stack_later) if (tracker->sync_stack_later)
meta_later_remove (tracker->sync_stack_later); {
MetaCompositor *compositor =
meta_display_get_compositor (tracker->display);
MetaLaters *laters = meta_compositor_get_laters (compositor);
meta_laters_remove (laters, tracker->sync_stack_later);
}
g_array_free (tracker->verified_stack, TRUE); g_array_free (tracker->verified_stack, TRUE);
if (tracker->predicted_stack) if (tracker->predicted_stack)
@ -919,7 +925,10 @@ meta_stack_tracker_sync_stack (MetaStackTracker *tracker)
if (tracker->sync_stack_later) if (tracker->sync_stack_later)
{ {
meta_later_remove (tracker->sync_stack_later); MetaLaters *laters;
laters = meta_compositor_get_laters (tracker->display->compositor);
meta_laters_remove (laters, tracker->sync_stack_later);
tracker->sync_stack_later = 0; tracker->sync_stack_later = 0;
} }
@ -987,12 +996,15 @@ stack_tracker_sync_stack_later (gpointer data)
void void
meta_stack_tracker_queue_sync_stack (MetaStackTracker *tracker) meta_stack_tracker_queue_sync_stack (MetaStackTracker *tracker)
{ {
if (tracker->sync_stack_later == 0) MetaLaters *laters;
{
tracker->sync_stack_later = meta_later_add (META_LATER_SYNC_STACK, if (tracker->sync_stack_later != 0)
stack_tracker_sync_stack_later, return;
tracker, NULL);
} laters = meta_compositor_get_laters (tracker->display->compositor);
tracker->sync_stack_later = meta_laters_add (laters, META_LATER_SYNC_STACK,
stack_tracker_sync_stack_later,
tracker, NULL);
} }
/* When moving an X window we sometimes need an X based sibling. /* When moving an X window we sometimes need an X based sibling.

2
src/core/startup-notification-private.h
View file

@ -49,4 +49,6 @@ MetaStartupSequence *
meta_startup_notification_lookup_sequence (MetaStartupNotification *sn, meta_startup_notification_lookup_sequence (MetaStartupNotification *sn,
const gchar *id); const gchar *id);
MetaDisplay * meta_startup_sequence_get_display (MetaStartupSequence *seq);
#endif /* META_STARTUP_NOTIFICATION_PRIVATE_H */ #endif /* META_STARTUP_NOTIFICATION_PRIVATE_H */

30
src/core/startup-notification.c
View file

@ -49,6 +49,7 @@ enum
enum enum
{ {
PROP_SEQ_0, PROP_SEQ_0,
PROP_SEQ_DISPLAY,
PROP_SEQ_ID, PROP_SEQ_ID,
PROP_SEQ_TIMESTAMP, PROP_SEQ_TIMESTAMP,
PROP_SEQ_ICON_NAME, PROP_SEQ_ICON_NAME,
@ -93,7 +94,10 @@ struct _MetaStartupNotification
guint startup_sequence_timeout_id; guint startup_sequence_timeout_id;
}; };
typedef struct { typedef struct
{
MetaDisplay *display;
char *wmclass; char *wmclass;
char *name; char *name;
char *application_id; char *application_id;
@ -183,6 +187,9 @@ meta_startup_sequence_set_property (GObject *object,
switch (prop_id) switch (prop_id)
{ {
case PROP_SEQ_DISPLAY:
priv->display = g_value_get_object (value);
break;
case PROP_SEQ_ID: case PROP_SEQ_ID:
priv->id = g_value_dup_string (value); priv->id = g_value_dup_string (value);
break; break;
@ -224,6 +231,9 @@ meta_startup_sequence_get_property (GObject *object,
switch (prop_id) switch (prop_id)
{ {
case PROP_SEQ_DISPLAY:
g_value_set_object (value, priv->display);
break;
case PROP_SEQ_ID: case PROP_SEQ_ID:
g_value_set_string (value, priv->id); g_value_set_string (value, priv->id);
break; break;
@ -275,6 +285,13 @@ meta_startup_sequence_class_init (MetaStartupSequenceClass *klass)
0, NULL, NULL, NULL, 0, NULL, NULL, NULL,
G_TYPE_NONE, 0); G_TYPE_NONE, 0);
seq_props[PROP_SEQ_DISPLAY] =
g_param_spec_object ("display",
"Display",
"Display",
META_TYPE_DISPLAY,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY);
seq_props[PROP_SEQ_ID] = seq_props[PROP_SEQ_ID] =
g_param_spec_string ("id", g_param_spec_string ("id",
"ID", "ID",
@ -455,6 +472,17 @@ meta_startup_sequence_get_wmclass (MetaStartupSequence *seq)
return priv->wmclass; return priv->wmclass;
} }
MetaDisplay *
meta_startup_sequence_get_display (MetaStartupSequence *seq)
{
MetaStartupSequencePrivate *priv;
g_return_val_if_fail (META_IS_STARTUP_SEQUENCE (seq), NULL);
priv = meta_startup_sequence_get_instance_private (seq);
return priv->display;
}
static void static void
on_sequence_completed (MetaStartupSequence *seq, on_sequence_completed (MetaStartupSequence *seq,
MetaStartupNotification *sn) MetaStartupNotification *sn)

25
src/core/window.c
View file

@ -224,6 +224,15 @@ enum
static guint window_signals[LAST_SIGNAL] = { 0 }; static guint window_signals[LAST_SIGNAL] = { 0 };
static MetaBackend *
backend_from_window (MetaWindow *window)
{
MetaDisplay *display = meta_window_get_display (window);
MetaContext *context = meta_display_get_context (display);
return meta_context_get_backend (context);
}
static void static void
prefs_changed_callback (MetaPreference pref, prefs_changed_callback (MetaPreference pref,
gpointer data) gpointer data)
@ -986,7 +995,7 @@ meta_window_main_monitor_changed (MetaWindow *window,
MetaLogicalMonitor * MetaLogicalMonitor *
meta_window_find_monitor_from_frame_rect (MetaWindow *window) meta_window_find_monitor_from_frame_rect (MetaWindow *window)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_window (window);
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
MetaRectangle window_rect; MetaRectangle window_rect;
@ -3634,7 +3643,7 @@ static MetaLogicalMonitor *
find_monitor_by_winsys_id (MetaWindow *window, find_monitor_by_winsys_id (MetaWindow *window,
uint64_t winsys_id) uint64_t winsys_id)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_window (window);
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
GList *logical_monitors, *l; GList *logical_monitors, *l;
@ -4626,7 +4635,7 @@ meta_window_focus (MetaWindow *window,
} }
} }
backend = meta_get_backend (); backend = backend_from_window (window);
stage = CLUTTER_STAGE (meta_backend_get_stage (backend)); stage = CLUTTER_STAGE (meta_backend_get_stage (backend));
if (window->display->event_route == META_EVENT_ROUTE_NORMAL && if (window->display->event_route == META_EVENT_ROUTE_NORMAL &&
@ -5771,7 +5780,7 @@ update_move_maybe_tile (MetaWindow *window,
int x, int x,
int y) int y)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_window (window);
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
MetaLogicalMonitor *logical_monitor; MetaLogicalMonitor *logical_monitor;
@ -5927,7 +5936,7 @@ update_move (MetaWindow *window,
else if ((window->shaken_loose || META_WINDOW_MAXIMIZED (window)) && else if ((window->shaken_loose || META_WINDOW_MAXIMIZED (window)) &&
window->tile_mode != META_TILE_LEFT && window->tile_mode != META_TILE_RIGHT) window->tile_mode != META_TILE_LEFT && window->tile_mode != META_TILE_RIGHT)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_window (window);
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
int n_logical_monitors; int n_logical_monitors;
@ -6418,7 +6427,7 @@ meta_window_get_work_area_for_monitor (MetaWindow *window,
int which_monitor, int which_monitor,
MetaRectangle *area) MetaRectangle *area)
{ {
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_window (window);
MetaMonitorManager *monitor_manager = meta_backend_get_monitor_manager (backend); MetaMonitorManager *monitor_manager = meta_backend_get_monitor_manager (backend);
MetaLogicalMonitor *logical_monitor; MetaLogicalMonitor *logical_monitor;
@ -8106,7 +8115,7 @@ window_has_pointer_wayland (MetaWindow *window)
seat = clutter_backend_get_default_seat (clutter_get_default_backend ()); seat = clutter_backend_get_default_seat (clutter_get_default_backend ());
dev = clutter_seat_get_pointer (seat); dev = clutter_seat_get_pointer (seat);
stage = CLUTTER_STAGE (meta_backend_get_stage (meta_get_backend ())); stage = CLUTTER_STAGE (meta_backend_get_stage (backend_from_window (window)));
pointer_actor = clutter_stage_get_device_actor (stage, dev, NULL); pointer_actor = clutter_stage_get_device_actor (stage, dev, NULL);
window_actor = CLUTTER_ACTOR (meta_window_get_compositor_private (window)); window_actor = CLUTTER_ACTOR (meta_window_get_compositor_private (window));
@ -8151,7 +8160,7 @@ window_focus_on_pointer_rest_callback (gpointer data)
MetaFocusData *focus_data = data; MetaFocusData *focus_data = data;
MetaWindow *window = focus_data->window; MetaWindow *window = focus_data->window;
MetaDisplay *display = window->display; MetaDisplay *display = window->display;
MetaBackend *backend = meta_get_backend (); MetaBackend *backend = backend_from_window (window);
MetaCursorTracker *cursor_tracker = meta_backend_get_cursor_tracker (backend); MetaCursorTracker *cursor_tracker = meta_backend_get_cursor_tracker (backend);
graphene_point_t point; graphene_point_t point;
guint32 timestamp; guint32 timestamp;

12
src/core/workspace.c
View file

@ -850,7 +850,8 @@ copy_strut_list(GSList *original)
static void static void
ensure_work_areas_validated (MetaWorkspace *workspace) ensure_work_areas_validated (MetaWorkspace *workspace)
{ {
MetaBackend *backend = meta_get_backend (); MetaContext *context = meta_display_get_context (workspace->display);
MetaBackend *backend = meta_context_get_backend (context);
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
GList *windows; GList *windows;
@ -1070,7 +1071,8 @@ void
meta_workspace_set_builtin_struts (MetaWorkspace *workspace, meta_workspace_set_builtin_struts (MetaWorkspace *workspace,
GSList *struts) GSList *struts)
{ {
MetaBackend *backend = meta_get_backend (); MetaContext *context = meta_display_get_context (workspace->display);
MetaBackend *backend = meta_context_get_backend (context);
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
MetaDisplay *display = workspace->display; MetaDisplay *display = workspace->display;
@ -1163,7 +1165,8 @@ meta_workspace_get_work_area_for_monitor (MetaWorkspace *workspace,
int which_monitor, int which_monitor,
MetaRectangle *area) MetaRectangle *area)
{ {
MetaBackend *backend = meta_get_backend(); MetaContext *context = meta_display_get_context (workspace->display);
MetaBackend *backend = meta_context_get_backend (context);
MetaMonitorManager *monitor_manager = MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend); meta_backend_get_monitor_manager (backend);
MetaLogicalMonitor *logical_monitor; MetaLogicalMonitor *logical_monitor;
@ -1550,7 +1553,8 @@ static MetaWindow *
get_pointer_window (MetaWorkspace *workspace, get_pointer_window (MetaWorkspace *workspace,
MetaWindow *not_this_one) MetaWindow *not_this_one)
{ {
MetaBackend *backend = meta_get_backend (); MetaContext *context = meta_display_get_context (workspace->display);
MetaBackend *backend = meta_context_get_backend (context);
MetaCursorTracker *cursor_tracker = meta_backend_get_cursor_tracker (backend); MetaCursorTracker *cursor_tracker = meta_backend_get_cursor_tracker (backend);
graphene_point_t point; graphene_point_t point;

16
src/wayland/meta-wayland-activation.c
View file

@ -56,6 +56,15 @@ struct _MetaXdgActivationToken
gboolean committed; gboolean committed;
}; };
static MetaDisplay *
display_from_activation (MetaWaylandActivation *activation)
{
MetaContext *context =
meta_wayland_compositor_get_context (activation->compositor);
return meta_context_get_display (context);
}
static void static void
unbind_resource (struct wl_resource *resource) unbind_resource (struct wl_resource *resource)
{ {
@ -104,7 +113,7 @@ sequence_complete_cb (MetaStartupSequence *sequence,
MetaXdgActivationToken *token) MetaXdgActivationToken *token)
{ {
MetaWaylandActivation *activation = token->activation; MetaWaylandActivation *activation = token->activation;
MetaDisplay *display = meta_get_display (); MetaDisplay *display = meta_startup_sequence_get_display (sequence);
if (!g_hash_table_contains (activation->tokens, token->token)) if (!g_hash_table_contains (activation->tokens, token->token))
return; return;
@ -148,7 +157,7 @@ token_commit (struct wl_client *client,
{ {
MetaXdgActivationToken *token = wl_resource_get_user_data (resource); MetaXdgActivationToken *token = wl_resource_get_user_data (resource);
MetaWaylandActivation *activation = token->activation; MetaWaylandActivation *activation = token->activation;
MetaDisplay *display = meta_get_display (); MetaDisplay *display = display_from_activation (activation);
uint64_t timestamp; uint64_t timestamp;
if (token->committed) if (token->committed)
@ -164,6 +173,7 @@ token_commit (struct wl_client *client,
token->committed = TRUE; token->committed = TRUE;
token->token = create_startup_token (activation, display); token->token = create_startup_token (activation, display);
token->sequence = g_object_new (META_TYPE_STARTUP_SEQUENCE, token->sequence = g_object_new (META_TYPE_STARTUP_SEQUENCE,
"display", display,
"id", token->token, "id", token->token,
"application-id", token->app_id, "application-id", token->app_id,
"timestamp", timestamp, "timestamp", timestamp,
@ -321,7 +331,7 @@ activation_activate (struct wl_client *client,
{ {
MetaWaylandActivation *activation = wl_resource_get_user_data (resource); MetaWaylandActivation *activation = wl_resource_get_user_data (resource);
MetaWaylandSurface *surface = wl_resource_get_user_data (surface_resource); MetaWaylandSurface *surface = wl_resource_get_user_data (surface_resource);
MetaDisplay *display = meta_get_display (); MetaDisplay *display = display_from_activation (activation);
MetaXdgActivationToken *token; MetaXdgActivationToken *token;
MetaStartupSequence *sequence; MetaStartupSequence *sequence;
MetaWindow *window; MetaWindow *window;

15
src/wayland/meta-wayland-gtk-shell.c
View file

@ -47,6 +47,8 @@ struct _MetaWaylandGtkShell
{ {
GObject parent; GObject parent;
MetaWaylandCompositor *compositor;
GList *shell_resources; GList *shell_resources;
uint32_t capabilities; uint32_t capabilities;
}; };
@ -170,7 +172,9 @@ gtk_surface_request_focus (struct wl_client *client,
{ {
MetaWaylandGtkSurface *gtk_surface = wl_resource_get_user_data (resource); MetaWaylandGtkSurface *gtk_surface = wl_resource_get_user_data (resource);
MetaWaylandSurface *surface = gtk_surface->surface; MetaWaylandSurface *surface = gtk_surface->surface;
MetaDisplay *display = meta_get_display (); MetaContext *context =
meta_wayland_compositor_get_context (surface->compositor);
MetaDisplay *display = meta_context_get_display (context);
MetaStartupSequence *sequence = NULL; MetaStartupSequence *sequence = NULL;
MetaWindow *window; MetaWindow *window;
@ -491,10 +495,11 @@ gtk_shell_set_startup_id (struct wl_client *client,
struct wl_resource *resource, struct wl_resource *resource,
const char *startup_id) const char *startup_id)
{ {
MetaWaylandGtkShell *gtk_shell = wl_resource_get_user_data (resource);
MetaContext *context =
meta_wayland_compositor_get_context (gtk_shell->compositor);
MetaDisplay *display = meta_context_get_display (context);
MetaStartupSequence *sequence; MetaStartupSequence *sequence;
MetaDisplay *display;
display = meta_get_display ();
sequence = meta_startup_notification_lookup_sequence (display->startup_notification, sequence = meta_startup_notification_lookup_sequence (display->startup_notification,
startup_id); startup_id);
@ -548,6 +553,7 @@ gtk_shell_notify_launch (struct wl_client *client,
timestamp = meta_display_get_current_time_roundtrip (display); timestamp = meta_display_get_current_time_roundtrip (display);
sequence = g_object_new (META_TYPE_STARTUP_SEQUENCE, sequence = g_object_new (META_TYPE_STARTUP_SEQUENCE,
"display", display,
"id", startup_id, "id", startup_id,
"timestamp", timestamp, "timestamp", timestamp,
NULL); NULL);
@ -652,6 +658,7 @@ meta_wayland_gtk_shell_new (MetaWaylandCompositor *compositor)
gtk_shell, bind_gtk_shell) == NULL) gtk_shell, bind_gtk_shell) == NULL)
g_error ("Failed to register a global gtk-shell object"); g_error ("Failed to register a global gtk-shell object");
gtk_shell->compositor = compositor;
gtk_shell->capabilities = calculate_capabilities (); gtk_shell->capabilities = calculate_capabilities ();
meta_prefs_add_listener (prefs_changed, gtk_shell); meta_prefs_add_listener (prefs_changed, gtk_shell);

9
src/x11/meta-startup-notification-x11.c
View file

@ -149,12 +149,14 @@ meta_startup_sequence_x11_class_init (MetaStartupSequenceX11Class *klass)
} }
static MetaStartupSequence * static MetaStartupSequence *
meta_startup_sequence_x11_new (SnStartupSequence *seq) meta_startup_sequence_x11_new (MetaDisplay *display,
SnStartupSequence *seq)
{ {
gint64 timestamp; gint64 timestamp;
timestamp = sn_startup_sequence_get_timestamp (seq); timestamp = sn_startup_sequence_get_timestamp (seq);
return g_object_new (META_TYPE_STARTUP_SEQUENCE_X11, return g_object_new (META_TYPE_STARTUP_SEQUENCE_X11,
"display", display,
"id", sn_startup_sequence_get_id (seq), "id", sn_startup_sequence_get_id (seq),
"icon-name", sn_startup_sequence_get_icon_name (seq), "icon-name", sn_startup_sequence_get_icon_name (seq),
"application-id", sn_startup_sequence_get_application_id (seq), "application-id", sn_startup_sequence_get_application_id (seq),
@ -193,7 +195,8 @@ meta_startup_notification_sn_event (SnMonitorEvent *event,
void *user_data) void *user_data)
{ {
MetaX11Display *x11_display = user_data; MetaX11Display *x11_display = user_data;
MetaStartupNotification *sn = x11_display->display->startup_notification; MetaDisplay *display = meta_x11_display_get_display (x11_display);
MetaStartupNotification *sn = display->startup_notification;
MetaStartupSequence *seq; MetaStartupSequence *seq;
SnStartupSequence *sequence; SnStartupSequence *sequence;
@ -214,7 +217,7 @@ meta_startup_notification_sn_event (SnMonitorEvent *event,
sn_startup_sequence_get_id (sequence), sn_startup_sequence_get_id (sequence),
wmclass ? wmclass : "(unset)"); wmclass ? wmclass : "(unset)");
seq = meta_startup_sequence_x11_new (sequence); seq = meta_startup_sequence_x11_new (display, sequence);
meta_startup_notification_add_sequence (sn, seq); meta_startup_notification_add_sequence (sn, seq);
g_object_unref (seq); g_object_unref (seq);
} }