mutter/src/backends/meta-backend.c
Chris Mayo 28a599631d backend: Fix build with -Dremote_desktop=false
../mutter-44.0/src/backends/meta-backend.c: In function ‘meta_backend_real_post_init’:
../mutter-44.0/src/backends/meta-backend.c:560:7: error: ‘MetaBackendPrivate’ {aka ‘struct _MetaBackendPrivate’} has no member named ‘remote_access_controller’
  560 |   priv->remote_access_controller =
      |       ^~

Closes: https://gitlab.gnome.org/GNOME/mutter/-/issues/2655
Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2935>
2023-04-03 21:34:54 +00:00

1745 lines
49 KiB
C

/* -*- 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
* @title: MetaBackend
* @short_description: Handles monitor config, modesetting, cursor sprites, ...
*
* MetaBackend is the abstraction that deals with several things like:
* - Modesetting (depending on the backend, this can be done either by X or KMS)
* - Initializing the #MetaSettings
* - Setting up Monitor configuration
* - Input device configuration (using the #ClutterDeviceManager)
* - Creating the #MetaRenderer
* - Setting up the stage of the scene graph (using #MetaStage)
* - Creating the object that deals with the cursor (using #MetaCursorTracker)
* and its possible pointer constraint (using #MetaPointerConstraint)
* - Setting the cursor sprite (using #MetaCursorRenderer)
* - Interacting with logind (using the appropriate D-Bus interface)
* - Querying UPower (over D-Bus) to know when the lid is closed
* - Setup Remote Desktop / Screencasting (#MetaRemoteDesktop)
* - Setup the #MetaEgl object
*
* Note that the #MetaBackend is not a subclass of #ClutterBackend. It is
* responsible for creating the correct one, based on the backend that is
* used (#MetaBackendNative or #MetaBackendX11).
*/
#include "config.h"
#include "backends/meta-backend-private.h"
#include <stdlib.h>
#include "backends/meta-barrier-private.h"
#include "backends/meta-cursor-renderer.h"
#include "backends/meta-cursor-tracker-private.h"
#include "backends/meta-dbus-session-watcher.h"
#include "backends/meta-idle-manager.h"
#include "backends/meta-idle-monitor-private.h"
#include "backends/meta-input-mapper-private.h"
#include "backends/meta-input-settings-private.h"
#include "backends/meta-logical-monitor.h"
#include "backends/meta-monitor-manager-dummy.h"
#include "backends/meta-remote-access-controller-private.h"
#include "backends/meta-settings-private.h"
#include "backends/meta-stage-private.h"
#include "backends/x11/meta-backend-x11.h"
#include "clutter/clutter-mutter.h"
#include "clutter/clutter-seat-private.h"
#include "compositor/meta-dnd-private.h"
#include "core/meta-context-private.h"
#include "meta/main.h"
#include "meta/meta-backend.h"
#include "meta/meta-context.h"
#include "meta/meta-enum-types.h"
#include "meta/util.h"
#ifdef HAVE_REMOTE_DESKTOP
#include "backends/meta-remote-desktop.h"
#include "backends/meta-screen-cast.h"
#endif
#ifdef HAVE_NATIVE_BACKEND
#include "backends/native/meta-backend-native.h"
#endif
#ifdef HAVE_WAYLAND
#include "wayland/meta-wayland.h"
#endif
enum
{
PROP_0,
PROP_CONTEXT,
PROP_CAPABILITIES,
N_PROPS
};
static GParamSpec *obj_props[N_PROPS];
enum
{
KEYMAP_CHANGED,
KEYMAP_LAYOUT_GROUP_CHANGED,
LAST_DEVICE_CHANGED,
LID_IS_CLOSED_CHANGED,
GPU_ADDED,
PREPARE_SHUTDOWN,
N_SIGNALS
};
static guint signals[N_SIGNALS];
#define HIDDEN_POINTER_TIMEOUT 300 /* ms */
struct _MetaBackendPrivate
{
MetaContext *context;
MetaMonitorManager *monitor_manager;
MetaOrientationManager *orientation_manager;
MetaCursorTracker *cursor_tracker;
MetaInputMapper *input_mapper;
MetaIdleManager *idle_manager;
MetaRenderer *renderer;
MetaColorManager *color_manager;
#ifdef HAVE_EGL
MetaEgl *egl;
#endif
MetaSettings *settings;
MetaDbusSessionWatcher *dbus_session_watcher;
MetaRemoteAccessController *remote_access_controller;
#ifdef HAVE_REMOTE_DESKTOP
MetaScreenCast *screen_cast;
MetaRemoteDesktop *remote_desktop;
#endif
#ifdef HAVE_LIBWACOM
WacomDeviceDatabase *wacom_db;
#endif
#ifdef HAVE_GNOME_DESKTOP
GnomePnpIds *pnp_ids;
#endif
ClutterContext *clutter_context;
ClutterSeat *default_seat;
ClutterActor *stage;
GList *gpus;
GList *hw_cursor_inhibitors;
gboolean is_pointer_position_initialized;
guint device_update_idle_id;
ClutterInputDevice *current_device;
MetaPointerConstraint *client_pointer_constraint;
MetaDnd *dnd;
guint upower_watch_id;
GDBusProxy *upower_proxy;
gboolean lid_is_closed;
gboolean on_battery;
guint sleep_signal_id;
GCancellable *cancellable;
GDBusConnection *system_bus;
uint32_t last_pointer_motion;
};
typedef struct _MetaBackendPrivate MetaBackendPrivate;
typedef struct _MetaBackendSource MetaBackendSource;
struct _MetaBackendSource
{
GSource parent;
MetaBackend *backend;
};
static void
initable_iface_init (GInitableIface *initable_iface);
G_DEFINE_ABSTRACT_TYPE_WITH_CODE (MetaBackend, meta_backend, G_TYPE_OBJECT,
G_ADD_PRIVATE (MetaBackend)
G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
initable_iface_init));
static void
meta_backend_dispose (GObject *object)
{
MetaBackend *backend = META_BACKEND (object);
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
g_clear_pointer (&priv->cursor_tracker, meta_cursor_tracker_destroy);
g_clear_object (&priv->current_device);
g_clear_object (&priv->color_manager);
g_clear_object (&priv->monitor_manager);
g_clear_object (&priv->orientation_manager);
#ifdef HAVE_REMOTE_DESKTOP
g_clear_object (&priv->remote_desktop);
g_clear_object (&priv->screen_cast);
#endif
g_clear_object (&priv->dbus_session_watcher);
g_clear_object (&priv->remote_access_controller);
#ifdef HAVE_LIBWACOM
g_clear_pointer (&priv->wacom_db, libwacom_database_destroy);
#endif
#ifdef HAVE_GNOME_DESKTOP
g_clear_object (&priv->pnp_ids);
#endif
if (priv->sleep_signal_id)
{
g_dbus_connection_signal_unsubscribe (priv->system_bus, priv->sleep_signal_id);
priv->sleep_signal_id = 0;
}
if (priv->upower_watch_id)
{
g_bus_unwatch_name (priv->upower_watch_id);
priv->upower_watch_id = 0;
}
g_cancellable_cancel (priv->cancellable);
g_clear_object (&priv->cancellable);
g_clear_object (&priv->system_bus);
g_clear_object (&priv->upower_proxy);
g_clear_handle_id (&priv->device_update_idle_id, g_source_remove);
g_clear_object (&priv->settings);
g_clear_pointer (&priv->default_seat, clutter_seat_destroy);
g_clear_pointer (&priv->stage, clutter_actor_destroy);
g_clear_pointer (&priv->idle_manager, meta_idle_manager_free);
g_clear_object (&priv->renderer);
g_clear_pointer (&priv->clutter_context, clutter_context_free);
g_clear_list (&priv->gpus, g_object_unref);
G_OBJECT_CLASS (meta_backend_parent_class)->dispose (object);
}
void
meta_backend_destroy (MetaBackend *backend)
{
g_object_run_dispose (G_OBJECT (backend));
g_object_unref (backend);
}
static void
meta_backend_sync_screen_size (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
int width, height;
meta_monitor_manager_get_screen_size (priv->monitor_manager, &width, &height);
META_BACKEND_GET_CLASS (backend)->update_screen_size (backend, width, height);
}
static void
reset_pointer_position (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
MetaMonitorManager *monitor_manager = priv->monitor_manager;
ClutterSeat *seat = priv->default_seat;
MetaLogicalMonitor *primary;
primary =
meta_monitor_manager_get_primary_logical_monitor (monitor_manager);
/* Move the pointer out of the way to avoid hovering over reactive
* elements (e.g. users list at login) causing undesired behaviour. */
clutter_seat_warp_pointer (seat,
primary->rect.x + primary->rect.width * 0.9,
primary->rect.y + primary->rect.height * 0.9);
}
static gboolean
should_have_cursor_renderer (ClutterInputDevice *device)
{
switch (clutter_input_device_get_device_type (device))
{
case CLUTTER_POINTER_DEVICE:
if (clutter_input_device_get_device_mode (device) ==
CLUTTER_INPUT_MODE_LOGICAL)
return TRUE;
return FALSE;
case CLUTTER_TABLET_DEVICE:
return TRUE;
default:
return FALSE;
}
}
static void
update_cursors (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
ClutterSeat *seat = priv->default_seat;
MetaCursorRenderer *cursor_renderer;
ClutterInputDevice *pointer, *device;
GList *devices, *l;
pointer = clutter_seat_get_pointer (seat);
devices = clutter_seat_list_devices (seat);
devices = g_list_prepend (devices, pointer);
for (l = devices; l; l = l->next)
{
device = l->data;
if (!should_have_cursor_renderer (device))
continue;
cursor_renderer = meta_backend_get_cursor_renderer_for_device (backend,
device);
if (cursor_renderer)
meta_cursor_renderer_force_update (cursor_renderer);
}
g_list_free (devices);
}
void
meta_backend_monitors_changed (MetaBackend *backend)
{
meta_backend_sync_screen_size (backend);
update_cursors (backend);
}
static gboolean
update_last_device (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
priv->device_update_idle_id = 0;
g_signal_emit (backend, signals[LAST_DEVICE_CHANGED], 0,
priv->current_device);
return G_SOURCE_REMOVE;
}
static void
meta_backend_update_last_device (MetaBackend *backend,
ClutterInputDevice *device)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
if (priv->current_device == device)
return;
if (!device ||
clutter_input_device_get_device_mode (device) == CLUTTER_INPUT_MODE_LOGICAL)
return;
g_set_object (&priv->current_device, device);
if (priv->device_update_idle_id == 0)
{
priv->device_update_idle_id =
g_idle_add ((GSourceFunc) update_last_device, backend);
g_source_set_name_by_id (priv->device_update_idle_id,
"[mutter] update_last_device");
}
}
static inline gboolean
determine_hotplug_pointer_visibility (ClutterSeat *seat)
{
g_autoptr (GList) devices = NULL;
const GList *l;
gboolean has_touchscreen = FALSE, has_pointer = FALSE, has_tablet = FALSE;
devices = clutter_seat_list_devices (seat);
for (l = devices; l; l = l->next)
{
ClutterInputDevice *device = l->data;
ClutterInputDeviceType device_type;
device_type = clutter_input_device_get_device_type (device);
if (device_type == CLUTTER_TOUCHSCREEN_DEVICE)
has_touchscreen = TRUE;
if (device_type == CLUTTER_POINTER_DEVICE ||
device_type == CLUTTER_TOUCHPAD_DEVICE)
has_pointer = TRUE;
if (device_type == CLUTTER_TABLET_DEVICE ||
device_type == CLUTTER_PEN_DEVICE ||
device_type == CLUTTER_ERASER_DEVICE)
{
if (meta_is_wayland_compositor ())
has_tablet = TRUE;
else
has_pointer = TRUE;
}
}
return has_pointer && !has_touchscreen && !has_tablet;
}
static void
on_device_added (ClutterSeat *seat,
ClutterInputDevice *device,
gpointer user_data)
{
MetaBackend *backend = META_BACKEND (user_data);
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
ClutterInputDeviceType device_type;
if (clutter_input_device_get_device_mode (device) ==
CLUTTER_INPUT_MODE_LOGICAL)
return;
device_type = clutter_input_device_get_device_type (device);
if (device_type == CLUTTER_TOUCHSCREEN_DEVICE ||
device_type == CLUTTER_POINTER_DEVICE)
{
meta_cursor_tracker_set_pointer_visible (priv->cursor_tracker,
determine_hotplug_pointer_visibility (seat));
}
if (device_type == CLUTTER_TOUCHSCREEN_DEVICE ||
device_type == CLUTTER_TABLET_DEVICE ||
device_type == CLUTTER_PEN_DEVICE ||
device_type == CLUTTER_ERASER_DEVICE ||
device_type == CLUTTER_CURSOR_DEVICE ||
device_type == CLUTTER_PAD_DEVICE)
meta_input_mapper_add_device (priv->input_mapper, device);
}
static void
on_device_removed (ClutterSeat *seat,
ClutterInputDevice *device,
gpointer user_data)
{
MetaBackend *backend = META_BACKEND (user_data);
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
if (clutter_input_device_get_device_mode (device) ==
CLUTTER_INPUT_MODE_LOGICAL)
return;
meta_input_mapper_remove_device (priv->input_mapper, device);
/* If the device the user last interacted goes away, check again pointer
* visibility.
*/
if (priv->current_device == device)
{
MetaCursorTracker *cursor_tracker = priv->cursor_tracker;
g_clear_object (&priv->current_device);
g_clear_handle_id (&priv->device_update_idle_id, g_source_remove);
meta_cursor_tracker_set_pointer_visible (cursor_tracker,
determine_hotplug_pointer_visibility (seat));
}
if (priv->current_device == device)
meta_backend_update_last_device (backend, NULL);
}
static void
input_mapper_device_mapped_cb (MetaInputMapper *mapper,
ClutterInputDevice *device,
float matrix[6],
MetaInputSettings *input_settings)
{
meta_input_settings_set_device_matrix (input_settings, device, matrix);
}
static void
input_mapper_device_enabled_cb (MetaInputMapper *mapper,
ClutterInputDevice *device,
gboolean enabled,
MetaInputSettings *input_settings)
{
meta_input_settings_set_device_enabled (input_settings, device, enabled);
}
static void
input_mapper_device_aspect_ratio_cb (MetaInputMapper *mapper,
ClutterInputDevice *device,
double aspect_ratio,
MetaInputSettings *input_settings)
{
meta_input_settings_set_device_aspect_ratio (input_settings, device, aspect_ratio);
}
static void
on_prepare_shutdown (MetaContext *context,
MetaBackend *backend)
{
g_signal_emit (backend, signals[PREPARE_SHUTDOWN], 0);
}
static void
on_started (MetaContext *context,
MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
ClutterSeat *seat = priv->default_seat;
meta_cursor_tracker_set_pointer_visible (priv->cursor_tracker,
determine_hotplug_pointer_visibility (seat));
}
static void
meta_backend_real_post_init (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
ClutterSeat *seat = priv->default_seat;
MetaInputSettings *input_settings;
priv->stage = meta_stage_new (backend);
clutter_actor_realize (priv->stage);
META_BACKEND_GET_CLASS (backend)->select_stage_events (backend);
meta_monitor_manager_setup (priv->monitor_manager);
meta_backend_sync_screen_size (backend);
priv->idle_manager = meta_idle_manager_new (backend);
g_signal_connect_object (seat, "device-added",
G_CALLBACK (on_device_added), backend, 0);
g_signal_connect_object (seat, "device-removed",
G_CALLBACK (on_device_removed), backend,
G_CONNECT_AFTER);
priv->input_mapper = meta_input_mapper_new (backend);
input_settings = meta_backend_get_input_settings (backend);
if (input_settings)
{
g_signal_connect (priv->input_mapper, "device-mapped",
G_CALLBACK (input_mapper_device_mapped_cb),
input_settings);
g_signal_connect (priv->input_mapper, "device-enabled",
G_CALLBACK (input_mapper_device_enabled_cb),
input_settings);
g_signal_connect (priv->input_mapper, "device-aspect-ratio",
G_CALLBACK (input_mapper_device_aspect_ratio_cb),
input_settings);
}
priv->remote_access_controller =
meta_remote_access_controller_new ();
priv->dbus_session_watcher =
g_object_new (META_TYPE_DBUS_SESSION_WATCHER, NULL);
#ifdef HAVE_REMOTE_DESKTOP
priv->screen_cast = meta_screen_cast_new (backend);
meta_remote_access_controller_add (
priv->remote_access_controller,
META_DBUS_SESSION_MANAGER (priv->screen_cast));
priv->remote_desktop = meta_remote_desktop_new (backend);
meta_remote_access_controller_add (
priv->remote_access_controller,
META_DBUS_SESSION_MANAGER (priv->remote_desktop));
#endif /* HAVE_REMOTE_DESKTOP */
if (!meta_monitor_manager_is_headless (priv->monitor_manager))
{
reset_pointer_position (backend);
priv->is_pointer_position_initialized = TRUE;
}
meta_monitor_manager_post_init (priv->monitor_manager);
g_signal_connect (priv->context, "prepare-shutdown",
G_CALLBACK (on_prepare_shutdown), backend);
g_signal_connect (priv->context, "started",
G_CALLBACK (on_started), backend);
}
static gboolean
meta_backend_real_grab_device (MetaBackend *backend,
int device_id,
uint32_t timestamp)
{
/* Do nothing */
return TRUE;
}
static gboolean
meta_backend_real_ungrab_device (MetaBackend *backend,
int device_id,
uint32_t timestamp)
{
/* Do nothing */
return TRUE;
}
static void
meta_backend_real_select_stage_events (MetaBackend *backend)
{
/* Do nothing */
}
static gboolean
meta_backend_real_is_lid_closed (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->lid_is_closed;
}
static MetaCursorTracker *
meta_backend_real_create_cursor_tracker (MetaBackend *backend)
{
return g_object_new (META_TYPE_CURSOR_TRACKER,
"backend", backend,
NULL);
}
static gboolean
meta_backend_real_is_headless (MetaBackend *backend)
{
return FALSE;
}
gboolean
meta_backend_is_lid_closed (MetaBackend *backend)
{
return META_BACKEND_GET_CLASS (backend)->is_lid_closed (backend);
}
gboolean
meta_backend_is_headless (MetaBackend *backend)
{
return META_BACKEND_GET_CLASS (backend)->is_headless (backend);
}
static void
upower_properties_changed (GDBusProxy *proxy,
GVariant *changed_properties,
GStrv invalidated_properties,
gpointer user_data)
{
MetaBackend *backend = user_data;
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
GVariant *v;
gboolean reset_idle_time = FALSE;
v = g_variant_lookup_value (changed_properties,
"LidIsClosed",
G_VARIANT_TYPE_BOOLEAN);
if (v)
{
gboolean lid_is_closed;
lid_is_closed = g_variant_get_boolean (v);
g_variant_unref (v);
if (lid_is_closed != priv->lid_is_closed)
{
priv->lid_is_closed = lid_is_closed;
g_signal_emit (backend, signals[LID_IS_CLOSED_CHANGED], 0,
priv->lid_is_closed);
if (!lid_is_closed)
reset_idle_time = TRUE;
}
}
v = g_variant_lookup_value (changed_properties,
"OnBattery",
G_VARIANT_TYPE_BOOLEAN);
if (v)
{
gboolean on_battery;
on_battery = g_variant_get_boolean (v);
g_variant_unref (v);
if (on_battery != priv->on_battery)
{
priv->on_battery = on_battery;
reset_idle_time = TRUE;
}
}
if (reset_idle_time)
meta_idle_manager_reset_idle_time (priv->idle_manager);
}
static void
upower_ready_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
MetaBackend *backend;
MetaBackendPrivate *priv;
GDBusProxy *proxy;
GError *error = NULL;
GVariant *v;
proxy = g_dbus_proxy_new_finish (res, &error);
if (!proxy)
{
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
g_warning ("Failed to create UPower proxy: %s", error->message);
g_error_free (error);
return;
}
backend = META_BACKEND (user_data);
priv = meta_backend_get_instance_private (backend);
priv->upower_proxy = proxy;
g_signal_connect (proxy, "g-properties-changed",
G_CALLBACK (upower_properties_changed), backend);
v = g_dbus_proxy_get_cached_property (proxy, "LidIsClosed");
if (v)
{
priv->lid_is_closed = g_variant_get_boolean (v);
g_variant_unref (v);
if (priv->lid_is_closed)
{
g_signal_emit (backend, signals[LID_IS_CLOSED_CHANGED], 0,
priv->lid_is_closed);
}
}
v = g_dbus_proxy_get_cached_property (proxy, "OnBattery");
if (v)
{
priv->on_battery = g_variant_get_boolean (v);
g_variant_unref (v);
}
}
static void
upower_appeared (GDBusConnection *connection,
const gchar *name,
const gchar *name_owner,
gpointer user_data)
{
MetaBackend *backend = META_BACKEND (user_data);
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
g_dbus_proxy_new (connection,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
"org.freedesktop.UPower",
"/org/freedesktop/UPower",
"org.freedesktop.UPower",
priv->cancellable,
upower_ready_cb,
backend);
}
static void
upower_vanished (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
MetaBackend *backend = META_BACKEND (user_data);
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
g_clear_object (&priv->upower_proxy);
}
static void
meta_backend_constructed (GObject *object)
{
MetaBackend *backend = META_BACKEND (object);
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
MetaBackendClass *backend_class =
META_BACKEND_GET_CLASS (backend);
g_assert (priv->context);
#ifdef HAVE_LIBWACOM
priv->wacom_db = libwacom_database_new ();
if (!priv->wacom_db)
{
g_warning ("Could not create database of Wacom devices, "
"expect tablets to misbehave");
}
#endif
if (backend_class->is_lid_closed == meta_backend_real_is_lid_closed)
{
priv->upower_watch_id = g_bus_watch_name (G_BUS_TYPE_SYSTEM,
"org.freedesktop.UPower",
G_BUS_NAME_WATCHER_FLAGS_NONE,
upower_appeared,
upower_vanished,
backend,
NULL);
}
#ifdef HAVE_EGL
priv->egl = g_object_new (META_TYPE_EGL, NULL);
#endif
G_OBJECT_CLASS (meta_backend_parent_class)->constructed (object);
}
static void
meta_backend_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
MetaBackend *backend = META_BACKEND (object);
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
switch (prop_id)
{
case PROP_CONTEXT:
priv->context = g_value_get_object (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
meta_backend_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
MetaBackend *backend = META_BACKEND (object);
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
switch (prop_id)
{
case PROP_CONTEXT:
g_value_set_object (value, priv->context);
break;
case PROP_CAPABILITIES:
g_value_set_flags (value, meta_backend_get_capabilities (backend));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
meta_backend_class_init (MetaBackendClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->dispose = meta_backend_dispose;
object_class->constructed = meta_backend_constructed;
object_class->set_property = meta_backend_set_property;
object_class->get_property = meta_backend_get_property;
klass->post_init = meta_backend_real_post_init;
klass->grab_device = meta_backend_real_grab_device;
klass->ungrab_device = meta_backend_real_ungrab_device;
klass->select_stage_events = meta_backend_real_select_stage_events;
klass->is_lid_closed = meta_backend_real_is_lid_closed;
klass->create_cursor_tracker = meta_backend_real_create_cursor_tracker;
klass->is_headless = meta_backend_real_is_headless;
obj_props[PROP_CONTEXT] =
g_param_spec_object ("context",
"context",
"MetaContext",
META_TYPE_CONTEXT,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
obj_props[PROP_CAPABILITIES] =
g_param_spec_flags ("capabilities",
"capabilities",
"Backend capabilities",
META_TYPE_BACKEND_CAPABILITIES,
META_BACKEND_CAPABILITY_NONE,
G_PARAM_READABLE |
G_PARAM_STATIC_STRINGS);
g_object_class_install_properties (object_class, N_PROPS, obj_props);
signals[KEYMAP_CHANGED] =
g_signal_new ("keymap-changed",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL, NULL,
G_TYPE_NONE, 0);
signals[KEYMAP_LAYOUT_GROUP_CHANGED] =
g_signal_new ("keymap-layout-group-changed",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL, NULL,
G_TYPE_NONE, 1, G_TYPE_UINT);
signals[LAST_DEVICE_CHANGED] =
g_signal_new ("last-device-changed",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL, NULL,
G_TYPE_NONE, 1, CLUTTER_TYPE_INPUT_DEVICE);
signals[LID_IS_CLOSED_CHANGED] =
g_signal_new ("lid-is-closed-changed",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL, NULL,
G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
/**
* MetaBackend::gpu-added: (skip)
* @backend: the #MetaBackend
* @gpu: the #MetaGpu
*/
signals[GPU_ADDED] =
g_signal_new ("gpu-added",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL, NULL,
G_TYPE_NONE, 1, META_TYPE_GPU);
signals[PREPARE_SHUTDOWN] =
g_signal_new ("prepare-shutdown",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL, NULL,
G_TYPE_NONE, 0);
}
static MetaMonitorManager *
meta_backend_create_monitor_manager (MetaBackend *backend,
GError **error)
{
return META_BACKEND_GET_CLASS (backend)->create_monitor_manager (backend,
error);
}
static MetaColorManager *
meta_backend_create_color_manager (MetaBackend *backend)
{
return META_BACKEND_GET_CLASS (backend)->create_color_manager (backend);
}
static MetaRenderer *
meta_backend_create_renderer (MetaBackend *backend,
GError **error)
{
return META_BACKEND_GET_CLASS (backend)->create_renderer (backend, error);
}
static void
prepare_for_sleep_cb (GDBusConnection *connection,
const gchar *sender_name,
const gchar *object_path,
const gchar *interface_name,
const gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
MetaBackend *backend = user_data;
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
gboolean suspending;
g_variant_get (parameters, "(b)", &suspending);
if (suspending)
return;
meta_idle_manager_reset_idle_time (priv->idle_manager);
}
static void
system_bus_gotten_cb (GObject *object,
GAsyncResult *res,
gpointer user_data)
{
MetaBackend *backend = user_data;
MetaBackendPrivate *priv;
GDBusConnection *bus;
bus = g_bus_get_finish (res, NULL);
if (!bus)
return;
priv = meta_backend_get_instance_private (backend);
priv->system_bus = bus;
priv->sleep_signal_id =
g_dbus_connection_signal_subscribe (priv->system_bus,
"org.freedesktop.login1",
"org.freedesktop.login1.Manager",
"PrepareForSleep",
"/org/freedesktop/login1",
NULL,
G_DBUS_SIGNAL_FLAGS_NONE,
prepare_for_sleep_cb,
backend,
NULL);
}
static void
update_last_device_from_event (MetaBackend *backend,
ClutterEvent *event)
{
ClutterInputDevice *source;
/* Handled elsewhere */
if (event->type == CLUTTER_DEVICE_ADDED ||
event->type == CLUTTER_DEVICE_REMOVED)
return;
source = clutter_event_get_source_device (event);
if (source)
meta_backend_update_last_device (backend, source);
}
static void
update_pointer_visibility_from_event (MetaBackend *backend,
ClutterEvent *event)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
MetaCursorTracker *cursor_tracker = priv->cursor_tracker;
ClutterInputDevice *device;
ClutterInputDeviceType device_type;
uint32_t time_ms;
device = clutter_event_get_source_device (event);
device_type = clutter_input_device_get_device_type (device);
time_ms = clutter_event_get_time (event);
switch (device_type)
{
case CLUTTER_TOUCHSCREEN_DEVICE:
meta_cursor_tracker_set_pointer_visible (cursor_tracker, FALSE);
break;
case CLUTTER_POINTER_DEVICE:
case CLUTTER_TOUCHPAD_DEVICE:
priv->last_pointer_motion = time_ms;
meta_cursor_tracker_set_pointer_visible (cursor_tracker, TRUE);
break;
case CLUTTER_TABLET_DEVICE:
case CLUTTER_PEN_DEVICE:
case CLUTTER_ERASER_DEVICE:
case CLUTTER_CURSOR_DEVICE:
if (meta_is_wayland_compositor () &&
time_ms > priv->last_pointer_motion + HIDDEN_POINTER_TIMEOUT)
meta_cursor_tracker_set_pointer_visible (cursor_tracker, FALSE);
break;
case CLUTTER_KEYBOARD_DEVICE:
case CLUTTER_PAD_DEVICE:
case CLUTTER_EXTENSION_DEVICE:
case CLUTTER_JOYSTICK_DEVICE:
default:
break;
}
}
/* Mutter is responsible for pulling events off the X queue, so Clutter
* doesn't need (and shouldn't) run its normal event source which polls
* the X fd, but we do have to deal with dispatching events that accumulate
* in the clutter queue. This happens, for example, when clutter generate
* enter/leave events on mouse motion - several events are queued in the
* clutter queue but only one dispatched. It could also happen because of
* explicit calls to clutter_event_put(). We add a very simple custom
* event loop source which is simply responsible for pulling events off
* of the queue and dispatching them before we block for new events.
*/
static gboolean
clutter_source_prepare (GSource *source,
int *timeout)
{
*timeout = -1;
return clutter_events_pending ();
}
static gboolean
clutter_source_check (GSource *source)
{
return clutter_events_pending ();
}
static gboolean
clutter_source_dispatch (GSource *source,
GSourceFunc callback,
gpointer user_data)
{
MetaBackendSource *backend_source = (MetaBackendSource *) source;
ClutterEvent *event = clutter_event_get ();
if (event)
{
event->any.stage =
CLUTTER_STAGE (meta_backend_get_stage (backend_source->backend));
clutter_do_event (event);
meta_backend_update_from_event (backend_source->backend, event);
clutter_event_free (event);
}
return TRUE;
}
static GSourceFuncs clutter_source_funcs = {
clutter_source_prepare,
clutter_source_check,
clutter_source_dispatch
};
static ClutterBackend *
meta_clutter_backend_constructor (gpointer user_data)
{
MetaBackend *backend = META_BACKEND (user_data);
return META_BACKEND_GET_CLASS (backend)->create_clutter_backend (backend);
}
static ClutterSeat *
meta_backend_create_default_seat (MetaBackend *backend,
GError **error)
{
return META_BACKEND_GET_CLASS (backend)->create_default_seat (backend, error);
}
static gboolean
init_clutter (MetaBackend *backend,
GError **error)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
MetaBackendSource *backend_source;
GSource *source;
priv->clutter_context = clutter_context_new (meta_clutter_backend_constructor,
backend,
error);
if (!priv->clutter_context)
return FALSE;
priv->default_seat = meta_backend_create_default_seat (backend, error);
if (!priv->default_seat)
return FALSE;
source = g_source_new (&clutter_source_funcs, sizeof (MetaBackendSource));
g_source_set_name (source, "[mutter] Backend");
backend_source = (MetaBackendSource *) source;
backend_source->backend = backend;
g_source_attach (source, NULL);
g_source_unref (source);
return TRUE;
}
static void
meta_backend_post_init (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
META_BACKEND_GET_CLASS (backend)->post_init (backend);
meta_settings_post_init (priv->settings);
}
static gboolean
meta_backend_initable_init (GInitable *initable,
GCancellable *cancellable,
GError **error)
{
MetaBackend *backend = META_BACKEND (initable);
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
priv->settings = meta_settings_new (backend);
priv->orientation_manager = g_object_new (META_TYPE_ORIENTATION_MANAGER, NULL);
priv->monitor_manager = meta_backend_create_monitor_manager (backend, error);
if (!priv->monitor_manager)
return FALSE;
priv->color_manager = meta_backend_create_color_manager (backend);
priv->renderer = meta_backend_create_renderer (backend, error);
if (!priv->renderer)
return FALSE;
priv->cursor_tracker =
META_BACKEND_GET_CLASS (backend)->create_cursor_tracker (backend);
priv->dnd = meta_dnd_new (backend);
priv->cancellable = g_cancellable_new ();
g_bus_get (G_BUS_TYPE_SYSTEM,
priv->cancellable,
system_bus_gotten_cb,
backend);
if (!init_clutter (backend, error))
return FALSE;
meta_backend_post_init (backend);
return TRUE;
}
static void
initable_iface_init (GInitableIface *initable_iface)
{
initable_iface->init = meta_backend_initable_init;
}
static void
meta_backend_init (MetaBackend *backend)
{
}
/**
* meta_backend_get_idle_monitor: (skip)
*/
MetaIdleMonitor *
meta_backend_get_idle_monitor (MetaBackend *backend,
ClutterInputDevice *device)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return meta_idle_manager_get_monitor (priv->idle_manager, device);
}
/**
* meta_backend_get_core_idle_monitor:
*
* Returns: (transfer none): the #MetaIdleMonitor that tracks server-global
* idle time for all devices.
*/
MetaIdleMonitor *
meta_backend_get_core_idle_monitor (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return meta_idle_manager_get_core_monitor (priv->idle_manager);
}
/**
* meta_backend_get_idle_manager: (skip)
*/
MetaIdleManager *
meta_backend_get_idle_manager (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->idle_manager;
}
/**
* meta_backend_get_monitor_manager:
*
* Returns: (transfer none): A #MetaMonitorManager
*/
MetaMonitorManager *
meta_backend_get_monitor_manager (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->monitor_manager;
}
/**
* meta_backend_get_color_manager: (skip)
*/
MetaColorManager *
meta_backend_get_color_manager (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->color_manager;
}
/**
* meta_backend_get_orientation_manager: (skip)
*/
MetaOrientationManager *
meta_backend_get_orientation_manager (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->orientation_manager;
}
MetaCursorTracker *
meta_backend_get_cursor_tracker (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->cursor_tracker;
}
/**
* meta_backend_get_cursor_renderer: (skip)
*/
MetaCursorRenderer *
meta_backend_get_cursor_renderer (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
ClutterInputDevice *pointer;
if (!priv->default_seat)
return NULL;
pointer = clutter_seat_get_pointer (priv->default_seat);
return meta_backend_get_cursor_renderer_for_device (backend, pointer);
}
MetaCursorRenderer *
meta_backend_get_cursor_renderer_for_device (MetaBackend *backend,
ClutterInputDevice *device)
{
g_return_val_if_fail (META_IS_BACKEND (backend), NULL);
g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE (device), NULL);
g_return_val_if_fail (clutter_input_device_get_device_type (device) !=
CLUTTER_KEYBOARD_DEVICE, NULL);
return META_BACKEND_GET_CLASS (backend)->get_cursor_renderer (backend,
device);
}
/**
* meta_backend_get_renderer: (skip)
*/
MetaRenderer *
meta_backend_get_renderer (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->renderer;
}
#ifdef HAVE_EGL
/**
* meta_backend_get_egl: (skip)
*/
MetaEgl *
meta_backend_get_egl (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->egl;
}
#endif /* HAVE_EGL */
/**
* meta_backend_get_settings: (skip)
*/
MetaSettings *
meta_backend_get_settings (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->settings;
}
MetaDbusSessionWatcher *
meta_backend_get_dbus_session_watcher (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->dbus_session_watcher;
}
#ifdef HAVE_REMOTE_DESKTOP
/**
* meta_backend_get_remote_desktop: (skip)
*/
MetaRemoteDesktop *
meta_backend_get_remote_desktop (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->remote_desktop;
}
/**
* meta_backend_get_screen_cast: (skip)
*/
MetaScreenCast *
meta_backend_get_screen_cast (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->screen_cast;
}
#endif /* HAVE_REMOTE_DESKTOP */
/**
* meta_backend_get_remote_access_controller:
* @backend: A #MetaBackend
*
* Return Value: (transfer none): The #MetaRemoteAccessController
*/
MetaRemoteAccessController *
meta_backend_get_remote_access_controller (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->remote_access_controller;
}
/**
* meta_backend_is_rendering_hardware_accelerated:
* @backend: A #MetaBackend
*
* Returns: %TRUE if the rendering is hardware accelerated, otherwise
* %FALSE.
*/
gboolean
meta_backend_is_rendering_hardware_accelerated (MetaBackend *backend)
{
MetaRenderer *renderer = meta_backend_get_renderer (backend);
return meta_renderer_is_hardware_accelerated (renderer);
}
/**
* meta_backend_grab_device: (skip)
*/
gboolean
meta_backend_grab_device (MetaBackend *backend,
int device_id,
uint32_t timestamp)
{
return META_BACKEND_GET_CLASS (backend)->grab_device (backend, device_id, timestamp);
}
/**
* meta_backend_get_context:
* @backend: the #MetaBackend
*
* Returns: (transfer none): The #MetaContext
*/
MetaContext *
meta_backend_get_context (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->context;
}
/**
* meta_backend_ungrab_device: (skip)
*/
gboolean
meta_backend_ungrab_device (MetaBackend *backend,
int device_id,
uint32_t timestamp)
{
return META_BACKEND_GET_CLASS (backend)->ungrab_device (backend, device_id, timestamp);
}
/**
* meta_backend_finish_touch_sequence: (skip)
*/
void
meta_backend_finish_touch_sequence (MetaBackend *backend,
ClutterEventSequence *sequence,
MetaSequenceState state)
{
if (META_BACKEND_GET_CLASS (backend)->finish_touch_sequence)
META_BACKEND_GET_CLASS (backend)->finish_touch_sequence (backend,
sequence,
state);
}
MetaLogicalMonitor *
meta_backend_get_current_logical_monitor (MetaBackend *backend)
{
return META_BACKEND_GET_CLASS (backend)->get_current_logical_monitor (backend);
}
void
meta_backend_set_keymap (MetaBackend *backend,
const char *layouts,
const char *variants,
const char *options)
{
META_BACKEND_GET_CLASS (backend)->set_keymap (backend, layouts, variants, options);
}
/**
* meta_backend_get_keymap: (skip)
*/
struct xkb_keymap *
meta_backend_get_keymap (MetaBackend *backend)
{
return META_BACKEND_GET_CLASS (backend)->get_keymap (backend);
}
xkb_layout_index_t
meta_backend_get_keymap_layout_group (MetaBackend *backend)
{
return META_BACKEND_GET_CLASS (backend)->get_keymap_layout_group (backend);
}
void
meta_backend_lock_layout_group (MetaBackend *backend,
guint idx)
{
META_BACKEND_GET_CLASS (backend)->lock_layout_group (backend, idx);
}
/**
* meta_backend_get_stage:
* @backend: A #MetaBackend
*
* Gets the global #ClutterStage that's managed by this backend.
*
* Returns: (transfer none): the #ClutterStage
*/
ClutterActor *
meta_backend_get_stage (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->stage;
}
ClutterSeat *
meta_backend_get_default_seat (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->default_seat;
}
MetaPointerConstraint *
meta_backend_get_client_pointer_constraint (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->client_pointer_constraint;
}
/**
* meta_backend_set_client_pointer_constraint:
* @backend: a #MetaBackend object.
* @constraint: (nullable): the client constraint to follow.
*
* Sets the current pointer constraint and removes (and unrefs) the previous
* one. If @constraint is %NULL, this means that there is no
* #MetaPointerConstraint active.
*/
void
meta_backend_set_client_pointer_constraint (MetaBackend *backend,
MetaPointerConstraint *constraint)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
META_BACKEND_GET_CLASS (backend)->set_pointer_constraint (backend, constraint);
g_set_object (&priv->client_pointer_constraint, constraint);
}
ClutterBackend *
meta_backend_get_clutter_backend (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
ClutterContext *clutter_context;
clutter_context = priv->clutter_context;
if (!clutter_context)
return NULL;
return clutter_context_get_backend (clutter_context);
}
MetaBackendCapabilities
meta_backend_get_capabilities (MetaBackend *backend)
{
return META_BACKEND_GET_CLASS (backend)->get_capabilities (backend);
}
gboolean
meta_backend_is_stage_views_scaled (MetaBackend *backend)
{
MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend);
MetaLogicalMonitorLayoutMode layout_mode;
layout_mode = monitor_manager->layout_mode;
return layout_mode == META_LOGICAL_MONITOR_LAYOUT_MODE_LOGICAL;
}
MetaInputMapper *
meta_backend_get_input_mapper (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->input_mapper;
}
MetaInputSettings *
meta_backend_get_input_settings (MetaBackend *backend)
{
return META_BACKEND_GET_CLASS (backend)->get_input_settings (backend);
}
/**
* meta_backend_get_dnd:
* @backend: A #MetaDnd
*
* Gets the global #MetaDnd that's managed by this backend.
*
* Returns: (transfer none): the #MetaDnd
*/
MetaDnd *
meta_backend_get_dnd (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->dnd;
}
void
meta_backend_notify_keymap_changed (MetaBackend *backend)
{
g_signal_emit (backend, signals[KEYMAP_CHANGED], 0);
}
void
meta_backend_notify_keymap_layout_group_changed (MetaBackend *backend,
unsigned int locked_group)
{
g_signal_emit (backend, signals[KEYMAP_LAYOUT_GROUP_CHANGED], 0,
locked_group);
}
void
meta_backend_add_gpu (MetaBackend *backend,
MetaGpu *gpu)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
priv->gpus = g_list_append (priv->gpus, gpu);
g_signal_emit (backend, signals[GPU_ADDED], 0, gpu);
}
GList *
meta_backend_get_gpus (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->gpus;
}
#ifdef HAVE_LIBWACOM
WacomDeviceDatabase *
meta_backend_get_wacom_database (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
return priv->wacom_db;
}
#endif
void
meta_backend_add_hw_cursor_inhibitor (MetaBackend *backend,
MetaHwCursorInhibitor *inhibitor)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
priv->hw_cursor_inhibitors = g_list_prepend (priv->hw_cursor_inhibitors,
inhibitor);
}
void
meta_backend_remove_hw_cursor_inhibitor (MetaBackend *backend,
MetaHwCursorInhibitor *inhibitor)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
priv->hw_cursor_inhibitors = g_list_remove (priv->hw_cursor_inhibitors,
inhibitor);
}
gboolean
meta_backend_is_hw_cursors_inhibited (MetaBackend *backend)
{
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
GList *l;
for (l = priv->hw_cursor_inhibitors; l; l = l->next)
{
MetaHwCursorInhibitor *inhibitor = l->data;
if (meta_hw_cursor_inhibitor_is_cursor_inhibited (inhibitor))
return TRUE;
}
return FALSE;
}
void
meta_backend_update_from_event (MetaBackend *backend,
ClutterEvent *event)
{
update_last_device_from_event (backend, event);
update_pointer_visibility_from_event (backend, event);
}
/**
* meta_backend_get_vendor_name:
* @backend: A #MetaBackend object
* @pnp_id: the PNP ID
*
* Find the full vendor name from the given PNP ID.
*
* Returns: (transfer full): A string containing the vendor name,
* or NULL when not found.
*/
char *
meta_backend_get_vendor_name (MetaBackend *backend,
const char *pnp_id)
{
#ifdef HAVE_GNOME_DESKTOP
MetaBackendPrivate *priv = meta_backend_get_instance_private (backend);
if (!priv->pnp_ids)
priv->pnp_ids = gnome_pnp_ids_new ();
return gnome_pnp_ids_get_pnp_id (priv->pnp_ids, pnp_id);
#else
return g_strdup (pnp_id);
#endif
}