isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2025-04-12 05:09:38 +00:00
Code Issues Packages Projects Releases Wiki Activity
mutter/src/backends/x11/meta-backend-x11.c
Jonas Ådahl 0debb24e12 barriers: Make barriers fully part of the backend 
Prior to this commit, barriers were created with a MetaDisplay pointer,
despite being entities related and owned by the backend. In the X11
case, it was also not hooked up to the backend X11 connection, but the
clutter one, meaning for example that the logic was active (but dormant)
also for the Xwayland connection.

Fix this by moving X11 barrier management and event processing fully to
the backend. Also replace passing a display pointer with passing a
backend pointer. Keep the display pointer around for a release, but mark
it as deprecated.

Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2442>
2022-07-26 20:27:24 +00:00

1047 lines
32 KiB
C
Raw Blame History

/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
* Copyright (C) 2014 Red Hat
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program 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
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*
* Written by:
* Jasper St. Pierre <jstpierre@mecheye.net>
*/
/**
* SECTION:meta-backend-x11
* @title: MetaBackendX11
* @short_description: A X11 MetaBackend
*
* MetaBackendX11 is an implementation of #MetaBackend using X and X
* extensions, like XInput and XKB.
*/
#include "config.h"
#include "backends/x11/meta-backend-x11.h"
#include <X11/XKBlib.h>
#include <X11/Xlib-xcb.h>
#include <X11/extensions/sync.h>
#include <stdlib.h>
#include <string.h>
#include <xkbcommon/xkbcommon-x11.h>
#include "backends/meta-idle-monitor-private.h"
#include "backends/meta-keymap-utils.h"
#include "backends/meta-stage-private.h"
#include "backends/x11/meta-barrier-x11.h"
#include "backends/x11/meta-clutter-backend-x11.h"
#include "backends/x11/meta-event-x11.h"
#include "backends/x11/meta-seat-x11.h"
#include "backends/x11/meta-stage-x11.h"
#include "backends/x11/meta-renderer-x11.h"
#include "backends/x11/meta-xkb-a11y-x11.h"
#include "clutter/clutter.h"
#include "compositor/compositor-private.h"
#include "core/display-private.h"
#include "meta/meta-cursor-tracker.h"
#include "meta/util.h"
struct _MetaBackendX11Private
{
/* The host X11 display */
Display *xdisplay;
Screen *xscreen;
xcb_connection_t *xcb;
GSource *source;
Window root_window;
int xsync_event_base;
int xsync_error_base;
XSyncAlarm user_active_alarm;
XSyncCounter counter;
int current_touch_replay_sync_serial;
int pending_touch_replay_sync_serial;
Atom touch_replay_sync_atom;
int xinput_opcode;
int xinput_event_base;
int xinput_error_base;
Time latest_evtime;
gboolean have_xinput_23;
uint8_t xkb_event_base;
uint8_t xkb_error_base;
gulong keymap_state_changed_id;
struct xkb_keymap *keymap;
xkb_layout_index_t keymap_layout_group;
MetaLogicalMonitor *cached_current_logical_monitor;
MetaX11Barriers *barriers;
};
typedef struct _MetaBackendX11Private MetaBackendX11Private;
static GInitableIface *initable_parent_iface;
static void
initable_iface_init (GInitableIface *initable_iface);
G_DEFINE_TYPE_WITH_CODE (MetaBackendX11, meta_backend_x11, META_TYPE_BACKEND,
G_ADD_PRIVATE (MetaBackendX11)
G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
initable_iface_init));
static void
uint64_to_xsync_value (uint64_t value,
XSyncValue *xsync_value)
{
XSyncIntsToValue (xsync_value, value & 0xffffffff, value >> 32);
}
static XSyncAlarm
xsync_user_active_alarm_set (MetaBackendX11Private *priv)
{
XSyncAlarmAttributes attr;
XSyncValue delta;
unsigned long flags;
flags = (XSyncCACounter | XSyncCAValueType | XSyncCATestType |
XSyncCAValue | XSyncCADelta | XSyncCAEvents);
XSyncIntToValue (&delta, 0);
attr.trigger.counter = priv->counter;
attr.trigger.value_type = XSyncAbsolute;
attr.delta = delta;
attr.events = TRUE;
uint64_to_xsync_value (1, &attr.trigger.wait_value);
attr.trigger.test_type = XSyncNegativeTransition;
return XSyncCreateAlarm (priv->xdisplay, flags, &attr);
}
static XSyncCounter
find_idletime_counter (MetaBackendX11Private *priv)
{
int i;
int n_counters;
XSyncSystemCounter *counters;
XSyncCounter counter = None;
counters = XSyncListSystemCounters (priv->xdisplay, &n_counters);
for (i = 0; i < n_counters; i++)
{
if (g_strcmp0 (counters[i].name, "IDLETIME") == 0)
{
counter = counters[i].counter;
break;
}
}
XSyncFreeSystemCounterList (counters);
return counter;
}
static void
handle_alarm_notify (MetaBackend *backend,
XSyncAlarmNotifyEvent *alarm_event)
{
MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
MetaIdleMonitor *idle_monitor;
XSyncAlarmAttributes attr;
ClutterBackend *clutter_backend;
ClutterSeat *seat;
ClutterInputDevice *pointer;
if (alarm_event->state != XSyncAlarmActive ||
alarm_event->alarm != priv->user_active_alarm)
return;
attr.events = TRUE;
XSyncChangeAlarm (priv->xdisplay, priv->user_active_alarm,
XSyncCAEvents, &attr);
clutter_backend = meta_backend_get_clutter_backend (backend);
seat = clutter_backend_get_default_seat (clutter_backend);
pointer = clutter_seat_get_pointer (seat);
idle_monitor = meta_backend_get_idle_monitor (backend, pointer);
meta_idle_monitor_reset_idletime (idle_monitor);
}
static void
meta_backend_x11_translate_device_event (MetaBackendX11 *x11,
XIDeviceEvent *device_event)
{
MetaBackendX11Class *backend_x11_class =
META_BACKEND_X11_GET_CLASS (x11);
backend_x11_class->translate_device_event (x11, device_event);
}
static void
maybe_translate_touch_replay_pointer_event (MetaBackendX11 *x11,
XIDeviceEvent *device_event)
{
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
if (!device_event->send_event &&
device_event->time != META_CURRENT_TIME &&
priv->current_touch_replay_sync_serial !=
priv->pending_touch_replay_sync_serial &&
XSERVER_TIME_IS_BEFORE (device_event->time, priv->latest_evtime))
{
/* Emulated pointer events received after XIRejectTouch is received
* on a passive touch grab will contain older timestamps, update those
* so we dont get InvalidTime at grabs.
*/
device_event->time = priv->latest_evtime;
}
}
static void
translate_device_event (MetaBackendX11 *x11,
XIDeviceEvent *device_event)
{
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
meta_backend_x11_translate_device_event (x11, device_event);
if (!device_event->send_event && device_event->time != META_CURRENT_TIME)
priv->latest_evtime = device_event->time;
}
static void
meta_backend_x11_translate_crossing_event (MetaBackendX11 *x11,
XIEnterEvent *enter_event)
{
MetaBackendX11Class *backend_x11_class =
META_BACKEND_X11_GET_CLASS (x11);
if (backend_x11_class->translate_crossing_event)
backend_x11_class->translate_crossing_event (x11, enter_event);
}
static void
translate_crossing_event (MetaBackendX11 *x11,
XIEnterEvent *enter_event)
{
/* Throw out weird events generated by grabs. */
if (enter_event->mode == XINotifyGrab ||
enter_event->mode == XINotifyUngrab)
{
enter_event->event = None;
return;
}
meta_backend_x11_translate_crossing_event (x11, enter_event);
}
/* Clutter makes the assumption that there is only one X window
* per stage, which is a valid assumption to make for a generic
* application toolkit. As such, it will ignore any events sent
* to the a stage that isn't its X window.
*
* When running as an X window manager, we need to respond to
* events from lots of windows. Trick Clutter into translating
* these events by pretending we got an event on the stage window.
*/
static void
maybe_spoof_event_as_stage_event (MetaBackendX11 *x11,
XIEvent *input_event)
{
switch (input_event->evtype)
{
case XI_Motion:
case XI_ButtonPress:
case XI_ButtonRelease:
maybe_translate_touch_replay_pointer_event (x11,
(XIDeviceEvent *) input_event);
G_GNUC_FALLTHROUGH;
case XI_KeyPress:
case XI_KeyRelease:
case XI_TouchBegin:
case XI_TouchUpdate:
case XI_TouchEnd:
translate_device_event (x11, (XIDeviceEvent *) input_event);
break;
case XI_Enter:
case XI_Leave:
translate_crossing_event (x11, (XIEnterEvent *) input_event);
break;
default:
break;
}
}
static gboolean
handle_input_event (MetaBackendX11 *x11,
XEvent *event)
{
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
if (event->type == GenericEvent &&
event->xcookie.extension == priv->xinput_opcode)
{
XIEvent *input_event = (XIEvent *) event->xcookie.data;
MetaX11Barriers *barriers;
barriers = meta_backend_x11_get_barriers (x11);
if (barriers &&
meta_x11_barriers_process_xevent (barriers, input_event))
return TRUE;
maybe_spoof_event_as_stage_event (x11, input_event);
}
return FALSE;
}
static void
keymap_changed (MetaBackend *backend)
{
MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
if (priv->keymap)
{
xkb_keymap_unref (priv->keymap);
priv->keymap = NULL;
}
g_signal_emit_by_name (backend, "keymap-changed", 0);
}
static gboolean
meta_backend_x11_handle_host_xevent (MetaBackendX11 *backend_x11,
XEvent *event)
{
MetaBackendX11Class *backend_x11_class =
META_BACKEND_X11_GET_CLASS (backend_x11);
return backend_x11_class->handle_host_xevent (backend_x11, event);
}
static void
handle_host_xevent (MetaBackend *backend,
XEvent *event)
{
MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
gboolean bypass_clutter = FALSE;
MetaDisplay *display;
switch (event->type)
{
case ClientMessage:
if (event->xclient.window == meta_backend_x11_get_xwindow (x11) &&
event->xclient.message_type == priv->touch_replay_sync_atom)
priv->current_touch_replay_sync_serial = event->xclient.data.l[0];
break;
default:
break;
}
XGetEventData (priv->xdisplay, &event->xcookie);
display = meta_get_display ();
if (display)
{
MetaCompositor *compositor = display->compositor;
MetaPluginManager *plugin_mgr =
meta_compositor_get_plugin_manager (compositor);
if (meta_plugin_manager_xevent_filter (plugin_mgr, event))
bypass_clutter = TRUE;
}
bypass_clutter = (meta_backend_x11_handle_host_xevent (x11, event) ||
bypass_clutter);
if (event->type == (priv->xsync_event_base + XSyncAlarmNotify))
handle_alarm_notify (backend, (XSyncAlarmNotifyEvent *) event);
if (event->type == priv->xkb_event_base)
{
XkbEvent *xkb_ev = (XkbEvent *) event;
if (xkb_ev->any.device == META_VIRTUAL_CORE_KEYBOARD_ID)
{
switch (xkb_ev->any.xkb_type)
{
case XkbNewKeyboardNotify:
case XkbMapNotify:
keymap_changed (backend);
break;
case XkbStateNotify:
if (xkb_ev->state.changed & XkbGroupLockMask)
{
int layout_group;
gboolean layout_group_changed;
layout_group = xkb_ev->state.locked_group;
layout_group_changed =
(int) priv->keymap_layout_group != layout_group;
priv->keymap_layout_group = layout_group;
if (layout_group_changed)
meta_backend_notify_keymap_layout_group_changed (backend,
layout_group);
}
break;
default:
break;
}
}
}
if (!bypass_clutter)
{
if (handle_input_event (x11, event))
goto done;
meta_x11_handle_event (backend, event);
}
done:
XFreeEventData (priv->xdisplay, &event->xcookie);
}
typedef struct {
GSource base;
GPollFD event_poll_fd;
MetaBackend *backend;
} XEventSource;
static gboolean
x_event_source_prepare (GSource *source,
int *timeout)
{
XEventSource *x_source = (XEventSource *) source;
MetaBackend *backend = x_source->backend;
MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
*timeout = -1;
return XPending (priv->xdisplay);
}
static gboolean
x_event_source_check (GSource *source)
{
XEventSource *x_source = (XEventSource *) source;
MetaBackend *backend = x_source->backend;
MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
return XPending (priv->xdisplay);
}
static gboolean
x_event_source_dispatch (GSource *source,
GSourceFunc callback,
gpointer user_data)
{
XEventSource *x_source = (XEventSource *) source;
MetaBackend *backend = x_source->backend;
MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
while (XPending (priv->xdisplay))
{
XEvent event;
XNextEvent (priv->xdisplay, &event);
handle_host_xevent (backend, &event);
}
return TRUE;
}
static GSourceFuncs x_event_funcs = {
x_event_source_prepare,
x_event_source_check,
x_event_source_dispatch,
};
static GSource *
x_event_source_new (MetaBackend *backend)
{
MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
GSource *source;
XEventSource *x_source;
source = g_source_new (&x_event_funcs, sizeof (XEventSource));
g_source_set_name (source, "[mutter] X events");
x_source = (XEventSource *) source;
x_source->backend = backend;
x_source->event_poll_fd.fd = ConnectionNumber (priv->xdisplay);
x_source->event_poll_fd.events = G_IO_IN;
g_source_add_poll (source, &x_source->event_poll_fd);
g_source_attach (source, NULL);
return source;
}
static void
on_monitors_changed (MetaMonitorManager *manager,
MetaBackend *backend)
{
MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
priv->cached_current_logical_monitor = NULL;
}
static void
on_kbd_a11y_changed (MetaInputSettings *input_settings,
MetaKbdA11ySettings *a11y_settings,
MetaBackend *backend)
{
ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend);
ClutterSeat *seat = clutter_backend_get_default_seat (clutter_backend);
meta_seat_x11_apply_kbd_a11y_settings (seat, a11y_settings);
}
static void
meta_backend_x11_post_init (MetaBackend *backend)
{
MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
MetaMonitorManager *monitor_manager;
ClutterBackend *clutter_backend;
ClutterSeat *seat;
MetaInputSettings *input_settings;
int major, minor;
priv->source = x_event_source_new (backend);
if (!XSyncQueryExtension (priv->xdisplay, &priv->xsync_event_base, &priv->xsync_error_base) ||
!XSyncInitialize (priv->xdisplay, &major, &minor))
meta_fatal ("Could not initialize XSync");
priv->counter = find_idletime_counter (priv);
if (priv->counter == None)
meta_fatal ("Could not initialize XSync counter");
priv->user_active_alarm = xsync_user_active_alarm_set (priv);
if (!xkb_x11_setup_xkb_extension (priv->xcb,
XKB_X11_MIN_MAJOR_XKB_VERSION,
XKB_X11_MIN_MINOR_XKB_VERSION,
XKB_X11_SETUP_XKB_EXTENSION_NO_FLAGS,
NULL, NULL,
&priv->xkb_event_base,
&priv->xkb_error_base))
meta_fatal ("X server doesn't have the XKB extension, version %d.%d or newer",
XKB_X11_MIN_MAJOR_XKB_VERSION, XKB_X11_MIN_MINOR_XKB_VERSION);
META_BACKEND_CLASS (meta_backend_x11_parent_class)->post_init (backend);
monitor_manager = meta_backend_get_monitor_manager (backend);
g_signal_connect (monitor_manager, "monitors-changed-internal",
G_CALLBACK (on_monitors_changed), backend);
priv->touch_replay_sync_atom = XInternAtom (priv->xdisplay,
"_MUTTER_TOUCH_SEQUENCE_SYNC",
False);
clutter_backend = meta_backend_get_clutter_backend (backend);
seat = clutter_backend_get_default_seat (clutter_backend);
meta_seat_x11_notify_devices (META_SEAT_X11 (seat),
CLUTTER_STAGE (meta_backend_get_stage (backend)));
input_settings = meta_backend_get_input_settings (backend);
if (input_settings)
{
g_signal_connect_object (meta_backend_get_input_settings (backend),
"kbd-a11y-changed",
G_CALLBACK (on_kbd_a11y_changed), backend, 0);
if (meta_input_settings_maybe_restore_numlock_state (input_settings))
{
unsigned int num_mask;
num_mask = XkbKeysymToModifiers (priv->xdisplay, XK_Num_Lock);
XkbLockModifiers (priv->xdisplay, XkbUseCoreKbd, num_mask, num_mask);
}
}
}
static ClutterBackend *
meta_backend_x11_create_clutter_backend (MetaBackend *backend)
{
return CLUTTER_BACKEND (meta_clutter_backend_x11_new (backend));
}
static ClutterSeat *
meta_backend_x11_create_default_seat (MetaBackend *backend,
GError **error)
{
MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
int event_base, first_event, first_error;
int major, minor;
MetaSeatX11 *seat_x11;
if (!XQueryExtension (priv->xdisplay,
"XInputExtension",
&event_base,
&first_event,
&first_error))
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Failed to query XInputExtension");
return NULL;
}
major = 2;
minor = 3;
if (XIQueryVersion (priv->xdisplay, &major, &minor) == BadRequest)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Incompatible XInputExtension version");
return NULL;
}
seat_x11 = meta_seat_x11_new (backend,
event_base,
META_VIRTUAL_CORE_POINTER_ID,
META_VIRTUAL_CORE_KEYBOARD_ID);
return CLUTTER_SEAT (seat_x11);
}
static gboolean
meta_backend_x11_grab_device (MetaBackend *backend,
int device_id,
uint32_t timestamp)
{
MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits };
int ret;
if (timestamp != META_CURRENT_TIME &&
XSERVER_TIME_IS_BEFORE (timestamp, priv->latest_evtime))
timestamp = priv->latest_evtime;
XISetMask (mask.mask, XI_ButtonPress);
XISetMask (mask.mask, XI_ButtonRelease);
XISetMask (mask.mask, XI_Enter);
XISetMask (mask.mask, XI_Leave);
XISetMask (mask.mask, XI_Motion);
XISetMask (mask.mask, XI_KeyPress);
XISetMask (mask.mask, XI_KeyRelease);
ret = XIGrabDevice (priv->xdisplay, device_id,
meta_backend_x11_get_xwindow (x11),
timestamp,
None,
XIGrabModeAsync, XIGrabModeAsync,
False, /* owner_events */
&mask);
return (ret == Success);
}
static gboolean
meta_backend_x11_ungrab_device (MetaBackend *backend,
int device_id,
uint32_t timestamp)
{
MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
int ret;
ret = XIUngrabDevice (priv->xdisplay, device_id, timestamp);
XFlush (priv->xdisplay);
return (ret == Success);
}
static void
meta_backend_x11_finish_touch_sequence (MetaBackend *backend,
ClutterEventSequence *sequence,
MetaSequenceState state)
{
MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
int event_mode;
if (state == META_SEQUENCE_ACCEPTED)
event_mode = XIAcceptTouch;
else if (state == META_SEQUENCE_REJECTED)
event_mode = XIRejectTouch;
else
g_return_if_reached ();
XIAllowTouchEvents (priv->xdisplay,
META_VIRTUAL_CORE_POINTER_ID,
clutter_event_sequence_get_slot (sequence),
DefaultRootWindow (priv->xdisplay), event_mode);
if (state == META_SEQUENCE_REJECTED)
{
XClientMessageEvent ev;
ev = (XClientMessageEvent) {
.type = ClientMessage,
.window = meta_backend_x11_get_xwindow (x11),
.message_type = priv->touch_replay_sync_atom,
.format = 32,
.data.l[0] = ++priv->pending_touch_replay_sync_serial,
};
XSendEvent (priv->xdisplay, meta_backend_x11_get_xwindow (x11),
False, 0, (XEvent *) &ev);
}
}
static MetaLogicalMonitor *
meta_backend_x11_get_current_logical_monitor (MetaBackend *backend)
{
MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
MetaCursorTracker *cursor_tracker;
graphene_point_t point;
MetaMonitorManager *monitor_manager;
MetaLogicalMonitor *logical_monitor;
if (priv->cached_current_logical_monitor)
return priv->cached_current_logical_monitor;
cursor_tracker = meta_backend_get_cursor_tracker (backend);
meta_cursor_tracker_get_pointer (cursor_tracker, &point, NULL);
monitor_manager = meta_backend_get_monitor_manager (backend);
logical_monitor =
meta_monitor_manager_get_logical_monitor_at (monitor_manager,
point.x, point.y);
if (!logical_monitor && monitor_manager->logical_monitors)
logical_monitor = monitor_manager->logical_monitors->data;
priv->cached_current_logical_monitor = logical_monitor;
return priv->cached_current_logical_monitor;
}
static struct xkb_keymap *
meta_backend_x11_get_keymap (MetaBackend *backend)
{
MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
if (priv->keymap == NULL)
{
struct xkb_context *context = meta_create_xkb_context ();
priv->keymap = xkb_x11_keymap_new_from_device (context,
priv->xcb,
xkb_x11_get_core_keyboard_device_id (priv->xcb),
XKB_KEYMAP_COMPILE_NO_FLAGS);
if (priv->keymap == NULL)
priv->keymap = xkb_keymap_new_from_names (context, NULL, XKB_KEYMAP_COMPILE_NO_FLAGS);
xkb_context_unref (context);
}
return priv->keymap;
}
static xkb_layout_index_t
meta_backend_x11_get_keymap_layout_group (MetaBackend *backend)
{
MetaBackendX11 *x11 = META_BACKEND_X11 (backend);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
return priv->keymap_layout_group;
}
void
meta_backend_x11_handle_event (MetaBackendX11 *x11,
XEvent *xevent)
{
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
priv->cached_current_logical_monitor = NULL;
}
uint8_t
meta_backend_x11_get_xkb_event_base (MetaBackendX11 *x11)
{
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
return priv->xkb_event_base;
}
static void
init_xkb_state (MetaBackendX11 *x11)
{
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
struct xkb_keymap *keymap;
int32_t device_id;
struct xkb_state *state;
keymap = meta_backend_get_keymap (META_BACKEND (x11));
device_id = xkb_x11_get_core_keyboard_device_id (priv->xcb);
state = xkb_x11_state_new_from_device (keymap, priv->xcb, device_id);
priv->keymap_layout_group =
xkb_state_serialize_layout (state, XKB_STATE_LAYOUT_LOCKED);
xkb_state_unref (state);
}
static gboolean
init_xinput (MetaBackendX11 *backend_x11,
GError **error)
{
MetaBackendX11Private *priv =
meta_backend_x11_get_instance_private (backend_x11);
gboolean has_xi = FALSE;
if (XQueryExtension (priv->xdisplay,
"XInputExtension",
&priv->xinput_opcode,
&priv->xinput_error_base,
&priv->xinput_event_base))
{
int major, minor;
major = 2; minor = 3;
if (XIQueryVersion (priv->xdisplay, &major, &minor) == Success)
{
int version;
version = (major * 10) + minor;
if (version >= 22)
has_xi = TRUE;
if (version >= 23)
priv->have_xinput_23 = TRUE;
}
}
if (!has_xi)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"X server doesn't have the XInput extension, "
"version 2.2 or newer");
return FALSE;
}
return TRUE;
}
static gboolean
meta_backend_x11_initable_init (GInitable *initable,
GCancellable *cancellable,
GError **error)
{
MetaContext *context = meta_backend_get_context (META_BACKEND (initable));
MetaBackendX11 *x11 = META_BACKEND_X11 (initable);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
Display *xdisplay;
const char *xdisplay_name;
xdisplay_name = g_getenv ("DISPLAY");
if (!xdisplay_name)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Unable to open display, DISPLAY not set");
return FALSE;
}
xdisplay = XOpenDisplay (xdisplay_name);
if (!xdisplay)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Unable to open display '%s'", xdisplay_name);
return FALSE;
}
XSynchronize (xdisplay, meta_context_is_x11_sync (context));
priv->xdisplay = xdisplay;
priv->xscreen = DefaultScreenOfDisplay (xdisplay);
priv->xcb = XGetXCBConnection (priv->xdisplay);
priv->root_window = DefaultRootWindow (xdisplay);
init_xkb_state (x11);
if (!init_xinput (x11, error))
return FALSE;
if (priv->have_xinput_23)
priv->barriers = meta_x11_barriers_new (x11);
return initable_parent_iface->init (initable, cancellable, error);
}
static void
initable_iface_init (GInitableIface *initable_iface)
{
initable_parent_iface = g_type_interface_peek_parent (initable_iface);
initable_iface->init = meta_backend_x11_initable_init;
}
static void
meta_backend_x11_dispose (GObject *object)
{
MetaBackend *backend = META_BACKEND (object);
MetaBackendX11 *x11 = META_BACKEND_X11 (object);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
if (priv->keymap_state_changed_id)
{
ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend);
ClutterSeat *seat = clutter_backend_get_default_seat (clutter_backend);
ClutterKeymap *keymap;
seat = clutter_backend_get_default_seat (clutter_backend);
keymap = clutter_seat_get_keymap (seat);
g_clear_signal_handler (&priv->keymap_state_changed_id, keymap);
}
if (priv->user_active_alarm != None)
{
XSyncDestroyAlarm (priv->xdisplay, priv->user_active_alarm);
priv->user_active_alarm = None;
}
G_OBJECT_CLASS (meta_backend_x11_parent_class)->dispose (object);
}
static void
meta_backend_x11_finalize (GObject *object)
{
MetaBackendX11 *x11 = META_BACKEND_X11 (object);
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
g_clear_pointer (&priv->keymap, xkb_keymap_unref);
G_OBJECT_CLASS (meta_backend_x11_parent_class)->finalize (object);
}
static void
meta_backend_x11_class_init (MetaBackendX11Class *klass)
{
MetaBackendClass *backend_class = META_BACKEND_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->dispose = meta_backend_x11_dispose;
object_class->finalize = meta_backend_x11_finalize;
backend_class->create_clutter_backend = meta_backend_x11_create_clutter_backend;
backend_class->create_default_seat = meta_backend_x11_create_default_seat;
backend_class->post_init = meta_backend_x11_post_init;
backend_class->grab_device = meta_backend_x11_grab_device;
backend_class->ungrab_device = meta_backend_x11_ungrab_device;
backend_class->finish_touch_sequence = meta_backend_x11_finish_touch_sequence;
backend_class->get_current_logical_monitor = meta_backend_x11_get_current_logical_monitor;
backend_class->get_keymap = meta_backend_x11_get_keymap;
backend_class->get_keymap_layout_group = meta_backend_x11_get_keymap_layout_group;
}
static void
meta_backend_x11_init (MetaBackendX11 *x11)
{
XInitThreads ();
}
Display *
meta_backend_x11_get_xdisplay (MetaBackendX11 *x11)
{
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
return priv->xdisplay;
}
Screen *
meta_backend_x11_get_xscreen (MetaBackendX11 *x11)
{
MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11);
return priv->xscreen;
}
Window
meta_backend_x11_get_root_xwindow (MetaBackendX11 *backend_x11)
{
MetaBackendX11Private *priv =
meta_backend_x11_get_instance_private (backend_x11);
return priv->root_window;
}
Window
meta_backend_x11_get_xwindow (MetaBackendX11 *x11)
{
ClutterActor *stage = meta_backend_get_stage (META_BACKEND (x11));
return meta_x11_get_stage_window (CLUTTER_STAGE (stage));
}
void
meta_backend_x11_reload_cursor (MetaBackendX11 *x11)
{
MetaBackend *backend = META_BACKEND (x11);
MetaCursorRenderer *cursor_renderer =
meta_backend_get_cursor_renderer (backend);
meta_cursor_renderer_force_update (cursor_renderer);
}
void
meta_backend_x11_sync_pointer (MetaBackendX11 *backend_x11)
{
MetaBackend *backend = META_BACKEND (backend_x11);
ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend);
ClutterSeat *seat = clutter_backend_get_default_seat (clutter_backend);
ClutterInputDevice *pointer = clutter_seat_get_pointer (seat);
ClutterStage *stage = CLUTTER_STAGE (meta_backend_get_stage (backend));
ClutterModifierType modifiers;
ClutterEvent *event;
graphene_point_t pos;
event = clutter_event_new (CLUTTER_MOTION);
clutter_seat_query_state (seat, pointer, NULL, &pos, &modifiers);
clutter_event_set_flags (event, CLUTTER_EVENT_FLAG_SYNTHETIC);
clutter_event_set_coords (event, pos.x, pos.y);
clutter_event_set_device (event, pointer);
clutter_event_set_state (event, modifiers);
clutter_event_set_source_device (event, NULL);
clutter_event_set_stage (event, stage);
clutter_event_put (event);
clutter_event_free (event);
}
MetaX11Barriers *
meta_backend_x11_get_barriers (MetaBackendX11 *backend_x11)
{
MetaBackendX11Private *priv =
meta_backend_x11_get_instance_private (backend_x11);
return priv->barriers;
}
Reference in New Issue View Git Blame Copy Permalink