mutter/src/backends/meta-input-device.c
Jonas Ådahl c390f70edc backend: Set up and use ownership chains
This means objects have an owner, where the chain eventually always
leads to a MetaContext. This also means that all objects can find their
way to other object instances via the chain, instead of scattered global
singletons.

This is a squashed commit originally containing the following:

cursor-tracker: Don't get backend from singleton

idle-manager: Don't get backend from singleton

input-device: Pass pointer to backend during construction

The backend is needed during construction to get the wacom database.

input-mapper: Pass backend when constructing

monitor: Don't get backend from singleton

monitor-manager: Get backend directly from monitor manager

remote: Get backend from manager class

For the remote desktop and screen cast implementations, replace getting
the backend from singletons with getting it via the manager classes.

launcher: Pass backend during construction

device-pool: Pass backend during construction

Instead of passing the (maybe null) launcher, pass the backend, and get
the launcher from there. That way we always have a way to some known
context from the device pool.

drm-buffer/gbm: Get backend via device pool

cursor-renderer: Get backend directly from renderer

input-device: Get backend getter

input-settings: Add backend construct property and getter

input-settings/x11: Don't get backend from singleton

renderer: Get backend from renderer itself

seat-impl: Add backend getter

seat/native: Get backend from instance struct

stage-impl: Get backend from stage impl itself

x11/xkb-a11y: Don't get backend from singleton

backend/x11/nested: Don't get Wayland compositor from singleton

crtc: Add backend property

Adding a link to the GPU isn't enough; the virtual CRTCs of virtual
monitors doesn't have one.

cursor-tracker: Don't get display from singleton

remote: Don't get display from singleton

seat: Don't get display from singleton

backend/x11: Don't get display from singleton

Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2718>
2022-12-17 13:52:51 +00:00

184 lines
5.0 KiB
C

/*
* Copyright © 2020 Red Hat Ltd.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
* Author: Carlos Garnacho <carlosg@gnome.org>
*/
#include "config.h"
#include "backends/meta-backend-private.h"
#include "meta-input-device-private.h"
typedef struct _MetaInputDevicePrivate MetaInputDevicePrivate;
struct _MetaInputDevicePrivate
{
MetaBackend *backend;
#ifdef HAVE_LIBWACOM
WacomDevice *wacom_device;
#else
/* Just something to have non-zero sized struct otherwise */
gpointer wacom_device;
#endif
};
enum
{
PROP_0,
PROP_BACKEND,
PROP_WACOM_DEVICE,
N_PROPS
};
static GParamSpec *props[N_PROPS] = { 0 };
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (MetaInputDevice,
meta_input_device,
CLUTTER_TYPE_INPUT_DEVICE)
static void
meta_input_device_init (MetaInputDevice *input_device)
{
}
static void
meta_input_device_constructed (GObject *object)
{
#ifdef HAVE_LIBWACOM
MetaInputDevice *input_device;
WacomDeviceDatabase *wacom_db;
MetaInputDevicePrivate *priv;
const char *node;
#endif
G_OBJECT_CLASS (meta_input_device_parent_class)->constructed (object);
#ifdef HAVE_LIBWACOM
input_device = META_INPUT_DEVICE (object);
priv = meta_input_device_get_instance_private (input_device);
wacom_db = meta_backend_get_wacom_database (priv->backend);
node = clutter_input_device_get_device_node (CLUTTER_INPUT_DEVICE (input_device));
priv->wacom_device = libwacom_new_from_path (wacom_db, node,
WFALLBACK_NONE, NULL);
#endif /* HAVE_LIBWACOM */
}
static void
meta_input_device_finalize (GObject *object)
{
#ifdef HAVE_LIBWACOM
MetaInputDevicePrivate *priv;
priv = meta_input_device_get_instance_private (META_INPUT_DEVICE (object));
g_clear_pointer (&priv->wacom_device, libwacom_destroy);
#endif /* HAVE_LIBWACOM */
G_OBJECT_CLASS (meta_input_device_parent_class)->finalize (object);
}
static void
meta_input_device_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
MetaInputDevicePrivate *priv;
priv = meta_input_device_get_instance_private (META_INPUT_DEVICE (object));
switch (prop_id)
{
case PROP_BACKEND:
priv->backend = g_value_get_object (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
meta_input_device_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
MetaInputDevicePrivate *priv;
priv = meta_input_device_get_instance_private (META_INPUT_DEVICE (object));
switch (prop_id)
{
case PROP_WACOM_DEVICE:
g_value_set_pointer (value, priv->wacom_device);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
meta_input_device_class_init (MetaInputDeviceClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->constructed = meta_input_device_constructed;
object_class->finalize = meta_input_device_finalize;
object_class->set_property = meta_input_device_set_property;
object_class->get_property = meta_input_device_get_property;
props[PROP_BACKEND] =
g_param_spec_object ("backend",
"backend",
"MetaBackend",
META_TYPE_BACKEND,
G_PARAM_WRITABLE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
props[PROP_WACOM_DEVICE] =
g_param_spec_pointer ("wacom-device",
"Wacom device",
"Wacom device",
G_PARAM_READABLE |
G_PARAM_STATIC_STRINGS);
g_object_class_install_properties (object_class, N_PROPS, props);
}
#ifdef HAVE_LIBWACOM
WacomDevice *
meta_input_device_get_wacom_device (MetaInputDevice *input_device)
{
MetaInputDevicePrivate *priv;
priv = meta_input_device_get_instance_private (input_device);
return priv->wacom_device;
}
#endif /* HAVE_LIBWACOM */
MetaBackend *
meta_input_device_get_backend (MetaInputDevice *input_device)
{
MetaInputDevicePrivate *priv =
meta_input_device_get_instance_private (input_device);
return priv->backend;
}