brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

eis: Remove meta_ prefix from variables

Browse Source 
This is more or less never used elsewhere, so don't start here.

Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/3228>
This commit is contained in:
Jonas Ådahl 2023-08-15 12:49:16 +02:00 committed by Marge Bot
parent da380f2732
commit 7e8bc5850e
4 changed files with 187 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

254
src/backends/meta-eis-client.c
View File

@ -45,7 +45,7 @@ struct _MetaEisDevice
struct _MetaEisClient struct _MetaEisClient
{ {
GObject parent_instance; GObject parent_instance;
MetaEis *meta_eis; MetaEis *eis;
MetaViewportInfo *viewports; MetaViewportInfo *viewports;
struct eis_client *eis_client; struct eis_client *eis_client;
@ -56,7 +56,7 @@ struct _MetaEisClient
G_DEFINE_TYPE (MetaEisClient, meta_eis_client, G_TYPE_OBJECT) G_DEFINE_TYPE (MetaEisClient, meta_eis_client, G_TYPE_OBJECT)
typedef void (* MetaEisDeviceConfigFunc) (MetaEisClient *meta_eis_client, typedef void (* MetaEisDeviceConfigFunc) (MetaEisClient *client,
struct eis_device *device); struct eis_device *device);
static bool static bool
@ -81,39 +81,39 @@ bit_clear (guchar *array,
} }
static void static void
notify_key (MetaEisDevice *meta_eis_device, notify_key (MetaEisDevice *device,
uint32_t key, uint32_t key,
gboolean is_press) gboolean is_press)
{ {
ClutterKeyState state; ClutterKeyState state;
state = is_press ? CLUTTER_KEY_STATE_PRESSED : CLUTTER_KEY_STATE_RELEASED; state = is_press ? CLUTTER_KEY_STATE_PRESSED : CLUTTER_KEY_STATE_RELEASED;
clutter_virtual_input_device_notify_key (meta_eis_device->device, clutter_virtual_input_device_notify_key (device->device,
g_get_monotonic_time (), g_get_monotonic_time (),
key, key,
state); state);
} }
static void static void
notify_button (MetaEisDevice *meta_eis_device, notify_button (MetaEisDevice *device,
uint32_t button, uint32_t button,
gboolean is_press) gboolean is_press)
{ {
ClutterButtonState state; ClutterButtonState state;
state = is_press ? CLUTTER_BUTTON_STATE_PRESSED : CLUTTER_BUTTON_STATE_RELEASED; state = is_press ? CLUTTER_BUTTON_STATE_PRESSED : CLUTTER_BUTTON_STATE_RELEASED;
clutter_virtual_input_device_notify_button (meta_eis_device->device, clutter_virtual_input_device_notify_button (device->device,
g_get_monotonic_time (), g_get_monotonic_time (),
button, button,
state); state);
} }
static void static void
remove_device (MetaEisClient *meta_eis_client, remove_device (MetaEisClient *client,
struct eis_device *eis_device, struct eis_device *eis_device,
gboolean remove_from_hashtable) gboolean remove_from_hashtable)
{ {
MetaEisDevice *meta_eis_device = eis_device_get_user_data (eis_device); MetaEisDevice *device = eis_device_get_user_data (eis_device);
struct eis_keymap *eis_keymap = eis_device_keyboard_get_keymap (eis_device); struct eis_keymap *eis_keymap = eis_device_keyboard_get_keymap (eis_device);
if (eis_keymap) if (eis_keymap)
@ -125,11 +125,11 @@ remove_device (MetaEisClient *meta_eis_client,
eis_device_pause (eis_device); eis_device_pause (eis_device);
eis_device_remove (eis_device); eis_device_remove (eis_device);
g_clear_pointer (&meta_eis_device->eis_device, eis_device_unref); g_clear_pointer (&device->eis_device, eis_device_unref);
g_clear_object (&meta_eis_device->device); g_clear_object (&device->device);
if (remove_from_hashtable) if (remove_from_hashtable)
g_hash_table_remove (meta_eis_client->eis_devices, eis_device); g_hash_table_remove (client->eis_devices, eis_device);
} }
static gboolean static gboolean
@ -137,24 +137,24 @@ drop_device (gpointer htkey,
gpointer value, gpointer value,
gpointer data) gpointer data)
{ {
MetaEisClient *meta_eis_client = data; MetaEisClient *client = data;
struct eis_device *eis_device = htkey; struct eis_device *eis_device = htkey;
MetaEisDevice *meta_eis_device = eis_device_get_user_data (eis_device); MetaEisDevice *device = eis_device_get_user_data (eis_device);
uint32_t key, button; uint32_t key, button;
for (key = 0; key < MAX_KEY; key++) for (key = 0; key < MAX_KEY; key++)
{ {
if (bit_is_set (meta_eis_device->key_state, key)) if (bit_is_set (device->key_state, key))
notify_key (meta_eis_device, key, FALSE); notify_key (device, key, FALSE);
} }
for (button = 0; button < MAX_BUTTON; button++) for (button = 0; button < MAX_BUTTON; button++)
{ {
if (bit_is_set (meta_eis_device->button_state, key)) if (bit_is_set (device->button_state, key))
notify_button (meta_eis_device, button, FALSE); notify_button (device, button, FALSE);
} }
remove_device (meta_eis_client, eis_device, FALSE); remove_device (client, eis_device, FALSE);
return TRUE; return TRUE;
} }
@ -166,7 +166,7 @@ meta_eis_device_free (MetaEisDevice *device)
} }
static void static void
configure_rel (MetaEisClient *meta_eis_client, configure_rel (MetaEisClient *client,
struct eis_device *eis_device) struct eis_device *eis_device)
{ {
eis_device_configure_capability (eis_device, EIS_DEVICE_CAP_POINTER); eis_device_configure_capability (eis_device, EIS_DEVICE_CAP_POINTER);
@ -175,7 +175,7 @@ configure_rel (MetaEisClient *meta_eis_client,
} }
static void static void
configure_keyboard (MetaEisClient *meta_eis_client, configure_keyboard (MetaEisClient *client,
struct eis_device *eis_device) struct eis_device *eis_device)
{ {
size_t len; size_t len;
@ -187,7 +187,7 @@ configure_keyboard (MetaEisClient *meta_eis_client,
eis_device_configure_capability (eis_device, EIS_DEVICE_CAP_KEYBOARD); eis_device_configure_capability (eis_device, EIS_DEVICE_CAP_KEYBOARD);
xkb_keymap = xkb_keymap =
meta_backend_get_keymap (meta_eis_get_backend (meta_eis_client->meta_eis)); meta_backend_get_keymap (meta_eis_get_backend (client->eis));
if (!xkb_keymap) if (!xkb_keymap)
return; return;
@ -217,21 +217,21 @@ configure_keyboard (MetaEisClient *meta_eis_client,
} }
static void static void
configure_abs (MetaEisClient *meta_eis_client, configure_abs (MetaEisClient *client,
struct eis_device *eis_device) struct eis_device *eis_device)
{ {
int idx = 0; int idx = 0;
MtkRectangle rect; MtkRectangle rect;
float scale; float scale;
if (!meta_eis_client->viewports) if (!client->viewports)
return; /* FIXME: should be an error */ return; /* FIXME: should be an error */
eis_device_configure_capability (eis_device, EIS_DEVICE_CAP_POINTER_ABSOLUTE); eis_device_configure_capability (eis_device, EIS_DEVICE_CAP_POINTER_ABSOLUTE);
eis_device_configure_capability (eis_device, EIS_DEVICE_CAP_BUTTON); eis_device_configure_capability (eis_device, EIS_DEVICE_CAP_BUTTON);
eis_device_configure_capability (eis_device, EIS_DEVICE_CAP_SCROLL); eis_device_configure_capability (eis_device, EIS_DEVICE_CAP_SCROLL);
while (meta_viewport_info_get_view_info (meta_eis_client->viewports, idx++, &rect, &scale)) while (meta_viewport_info_get_view_info (client->viewports, idx++, &rect, &scale))
{ {
struct eis_region *r = eis_device_new_region (eis_device); struct eis_region *r = eis_device_new_region (eis_device);
eis_region_set_offset (r, rect.x, rect.y); eis_region_set_offset (r, rect.x, rect.y);
@ -243,35 +243,35 @@ configure_abs (MetaEisClient *meta_eis_client,
} }
static void static void
add_device (MetaEisClient *meta_eis_client, add_device (MetaEisClient *client,
struct eis_seat *eis_seat, struct eis_seat *eis_seat,
ClutterInputDeviceType type, ClutterInputDeviceType type,
const char *name_suffix, const char *name_suffix,
MetaEisDeviceConfigFunc extra_config_func) MetaEisDeviceConfigFunc extra_config_func)
{ {
MetaBackend *backend = meta_eis_get_backend (meta_eis_client->meta_eis); MetaBackend *backend = meta_eis_get_backend (client->eis);
MetaEisDevice *meta_eis_device; MetaEisDevice *device;
ClutterSeat *seat = meta_backend_get_default_seat (backend); ClutterSeat *seat = meta_backend_get_default_seat (backend);
ClutterVirtualInputDevice *device; ClutterVirtualInputDevice *virtual_device;
struct eis_device *eis_device; struct eis_device *eis_device;
gchar *name; gchar *name;
device = clutter_seat_create_virtual_device (seat, type); virtual_device = clutter_seat_create_virtual_device (seat, type);
eis_device = eis_seat_new_device (eis_seat); eis_device = eis_seat_new_device (eis_seat);
name = g_strdup_printf ("%s %s", eis_client_get_name (meta_eis_client->eis_client), name = g_strdup_printf ("%s %s", eis_client_get_name (client->eis_client),
name_suffix); name_suffix);
eis_device_configure_name (eis_device, name); eis_device_configure_name (eis_device, name);
if (extra_config_func) if (extra_config_func)
extra_config_func (meta_eis_client, eis_device); extra_config_func (client, eis_device);
meta_eis_device = g_new0 (MetaEisDevice, 1); device = g_new0 (MetaEisDevice, 1);
meta_eis_device->eis_device = eis_device_ref (eis_device); device->eis_device = eis_device_ref (eis_device);
meta_eis_device->device = device; device->device = virtual_device;
eis_device_set_user_data (eis_device, meta_eis_device); eis_device_set_user_data (eis_device, device);
g_hash_table_insert (meta_eis_client->eis_devices, g_hash_table_insert (client->eis_devices,
eis_device, /* owns the initial ref now */ eis_device, /* owns the initial ref now */
meta_eis_device); device);
eis_device_add (eis_device); eis_device_add (eis_device);
eis_device_resume (eis_device); eis_device_resume (eis_device);
@ -279,49 +279,49 @@ add_device (MetaEisClient *meta_eis_client,
} }
static void static void
handle_motion_relative (MetaEisClient *meta_eis_client, handle_motion_relative (MetaEisClient *client,
struct eis_event *event) struct eis_event *event)
{ {
struct eis_device *eis_device = eis_event_get_device (event); struct eis_device *eis_device = eis_event_get_device (event);
MetaEisDevice *meta_eis_device = eis_device_get_user_data (eis_device); MetaEisDevice *device = eis_device_get_user_data (eis_device);
double dx, dy; double dx, dy;
dx = eis_event_pointer_get_dx (event); dx = eis_event_pointer_get_dx (event);
dy = eis_event_pointer_get_dy (event); dy = eis_event_pointer_get_dy (event);
clutter_virtual_input_device_notify_relative_motion (meta_eis_device->device, clutter_virtual_input_device_notify_relative_motion (device->device,
g_get_monotonic_time (), g_get_monotonic_time (),
dx, dy); dx, dy);
} }
static void static void
handle_motion_absolute (MetaEisClient *meta_eis_client, handle_motion_absolute (MetaEisClient *client,
struct eis_event *event) struct eis_event *event)
{ {
struct eis_device *eis_device = eis_event_get_device (event); struct eis_device *eis_device = eis_event_get_device (event);
MetaEisDevice *meta_eis_device = eis_device_get_user_data (eis_device); MetaEisDevice *device = eis_device_get_user_data (eis_device);
double x, y; double x, y;
x = eis_event_pointer_get_absolute_x (event); x = eis_event_pointer_get_absolute_x (event);
y = eis_event_pointer_get_absolute_y (event); y = eis_event_pointer_get_absolute_y (event);
clutter_virtual_input_device_notify_absolute_motion (meta_eis_device->device, clutter_virtual_input_device_notify_absolute_motion (device->device,
g_get_monotonic_time (), g_get_monotonic_time (),
x, y); x, y);
} }
static void static void
handle_scroll (MetaEisClient *meta_eis_client, handle_scroll (MetaEisClient *client,
struct eis_event *event) struct eis_event *event)
{ {
struct eis_device *eis_device = eis_event_get_device (event); struct eis_device *eis_device = eis_event_get_device (event);
MetaEisDevice *meta_eis_device = eis_device_get_user_data (eis_device); MetaEisDevice *device = eis_device_get_user_data (eis_device);
double dx, dy; double dx, dy;
dx = eis_event_scroll_get_dx (event); dx = eis_event_scroll_get_dx (event);
dy = eis_event_scroll_get_dy (event); dy = eis_event_scroll_get_dy (event);
clutter_virtual_input_device_notify_scroll_continuous (meta_eis_device->device, clutter_virtual_input_device_notify_scroll_continuous (device->device,
g_get_monotonic_time (), g_get_monotonic_time (),
dx, dy, dx, dy,
CLUTTER_SCROLL_SOURCE_UNKNOWN, CLUTTER_SCROLL_SOURCE_UNKNOWN,
@ -329,11 +329,11 @@ handle_scroll (MetaEisClient *meta_eis_client,
} }
static void static void
handle_scroll_stop (MetaEisClient *meta_eis_client, handle_scroll_stop (MetaEisClient *client,
struct eis_event *event) struct eis_event *event)
{ {
struct eis_device *eis_device = eis_event_get_device (event); struct eis_device *eis_device = eis_event_get_device (event);
MetaEisDevice *meta_eis_device = eis_device_get_user_data (eis_device); MetaEisDevice *device = eis_device_get_user_data (eis_device);
ClutterScrollFinishFlags finish_flags = CLUTTER_SCROLL_FINISHED_NONE; ClutterScrollFinishFlags finish_flags = CLUTTER_SCROLL_FINISHED_NONE;
if (eis_event_scroll_get_stop_x (event)) if (eis_event_scroll_get_stop_x (event))
@ -342,7 +342,7 @@ handle_scroll_stop (MetaEisClient *meta_eis_client,
finish_flags |= CLUTTER_SCROLL_FINISHED_VERTICAL; finish_flags |= CLUTTER_SCROLL_FINISHED_VERTICAL;
if (finish_flags != CLUTTER_SCROLL_FINISHED_NONE) if (finish_flags != CLUTTER_SCROLL_FINISHED_NONE)
clutter_virtual_input_device_notify_scroll_continuous (meta_eis_device->device, clutter_virtual_input_device_notify_scroll_continuous (device->device,
g_get_monotonic_time (), g_get_monotonic_time (),
0.0, 0.0, 0.0, 0.0,
CLUTTER_SCROLL_SOURCE_UNKNOWN, CLUTTER_SCROLL_SOURCE_UNKNOWN,
@ -350,11 +350,11 @@ handle_scroll_stop (MetaEisClient *meta_eis_client,
} }
static void static void
handle_scroll_cancel (MetaEisClient *meta_eis_client, handle_scroll_cancel (MetaEisClient *client,
struct eis_event *event) struct eis_event *event)
{ {
struct eis_device *eis_device = eis_event_get_device (event); struct eis_device *eis_device = eis_event_get_device (event);
MetaEisDevice *meta_eis_device = eis_device_get_user_data (eis_device); MetaEisDevice *device = eis_device_get_user_data (eis_device);
double dx = 0.0, dy = 0.0; double dx = 0.0, dy = 0.0;
/* There's no real match for the EIS scroll cancel event, so let's just send a /* There's no real match for the EIS scroll cancel event, so let's just send a
@ -367,7 +367,7 @@ handle_scroll_cancel (MetaEisClient *meta_eis_client,
dy = 0.01; dy = 0.01;
if (dx != 0.0 || dy != 0.0) if (dx != 0.0 || dy != 0.0)
clutter_virtual_input_device_notify_scroll_continuous (meta_eis_device->device, clutter_virtual_input_device_notify_scroll_continuous (device->device,
g_get_monotonic_time (), g_get_monotonic_time (),
dx, dy, dx, dy,
CLUTTER_SCROLL_SOURCE_UNKNOWN, CLUTTER_SCROLL_SOURCE_UNKNOWN,
@ -375,11 +375,11 @@ handle_scroll_cancel (MetaEisClient *meta_eis_client,
} }
static void static void
handle_scroll_discrete (MetaEisClient *meta_eis_client, handle_scroll_discrete (MetaEisClient *client,
struct eis_event *event) struct eis_event *event)
{ {
struct eis_device *eis_device = eis_event_get_device (event); struct eis_device *eis_device = eis_event_get_device (event);
MetaEisDevice *meta_eis_device = eis_device_get_user_data (eis_device); MetaEisDevice *device = eis_device_get_user_data (eis_device);
int dx, dy; int dx, dy;
/* FIXME: need to handle the remainders here for high-resolution scrolling */ /* FIXME: need to handle the remainders here for high-resolution scrolling */
@ -391,7 +391,7 @@ handle_scroll_discrete (MetaEisClient *meta_eis_client,
{ {
if (dx > 0) if (dx > 0)
{ {
clutter_virtual_input_device_notify_discrete_scroll (meta_eis_device->device, clutter_virtual_input_device_notify_discrete_scroll (device->device,
g_get_monotonic_time (), g_get_monotonic_time (),
CLUTTER_SCROLL_RIGHT, CLUTTER_SCROLL_RIGHT,
CLUTTER_SCROLL_SOURCE_UNKNOWN); CLUTTER_SCROLL_SOURCE_UNKNOWN);
@ -399,7 +399,7 @@ handle_scroll_discrete (MetaEisClient *meta_eis_client,
} }
else if (dx < 0) else if (dx < 0)
{ {
clutter_virtual_input_device_notify_discrete_scroll (meta_eis_device->device, clutter_virtual_input_device_notify_discrete_scroll (device->device,
g_get_monotonic_time (), g_get_monotonic_time (),
CLUTTER_SCROLL_LEFT, CLUTTER_SCROLL_LEFT,
CLUTTER_SCROLL_SOURCE_UNKNOWN); CLUTTER_SCROLL_SOURCE_UNKNOWN);
@ -408,7 +408,7 @@ handle_scroll_discrete (MetaEisClient *meta_eis_client,
if (dy > 0) if (dy > 0)
{ {
clutter_virtual_input_device_notify_discrete_scroll (meta_eis_device->device, clutter_virtual_input_device_notify_discrete_scroll (device->device,
g_get_monotonic_time (), g_get_monotonic_time (),
CLUTTER_SCROLL_DOWN, CLUTTER_SCROLL_DOWN,
CLUTTER_SCROLL_SOURCE_UNKNOWN); CLUTTER_SCROLL_SOURCE_UNKNOWN);
@ -416,7 +416,7 @@ handle_scroll_discrete (MetaEisClient *meta_eis_client,
} }
else if (dy < 0) else if (dy < 0)
{ {
clutter_virtual_input_device_notify_discrete_scroll (meta_eis_device->device, clutter_virtual_input_device_notify_discrete_scroll (device->device,
g_get_monotonic_time (), g_get_monotonic_time (),
CLUTTER_SCROLL_UP, CLUTTER_SCROLL_UP,
CLUTTER_SCROLL_SOURCE_UNKNOWN); CLUTTER_SCROLL_SOURCE_UNKNOWN);
@ -426,11 +426,11 @@ handle_scroll_discrete (MetaEisClient *meta_eis_client,
} }
static void static void
handle_button (MetaEisClient *meta_eis_client, handle_button (MetaEisClient *client,
struct eis_event *event) struct eis_event *event)
{ {
struct eis_device *eis_device = eis_event_get_device (event); struct eis_device *eis_device = eis_event_get_device (event);
MetaEisDevice *meta_eis_device = eis_device_get_user_data (eis_device); MetaEisDevice *device = eis_device_get_user_data (eis_device);
uint32_t button; uint32_t button;
gboolean is_press = eis_event_button_get_is_press (event); gboolean is_press = eis_event_button_get_is_press (event);
@ -455,24 +455,24 @@ handle_button (MetaEisClient *meta_eis_client,
if (button > MAX_BUTTON) if (button > MAX_BUTTON)
return; return;
if (is_press && !bit_is_set (meta_eis_device->button_state, button)) if (is_press && !bit_is_set (device->button_state, button))
bit_set (meta_eis_device->button_state, button); bit_set (device->button_state, button);
else if (!is_press && bit_is_set (meta_eis_device->button_state, button)) else if (!is_press && bit_is_set (device->button_state, button))
bit_clear (meta_eis_device->button_state, button); bit_clear (device->button_state, button);
else else
return; /* Duplicate press/release, should've been filtered by libeis */ return; /* Duplicate press/release, should've been filtered by libeis */
notify_button (meta_eis_device, notify_button (device,
button, button,
eis_event_button_get_is_press (event)); eis_event_button_get_is_press (event));
} }
static void static void
handle_key (MetaEisClient *meta_eis_client, handle_key (MetaEisClient *client,
struct eis_event *event) struct eis_event *event)
{ {
struct eis_device *eis_device = eis_event_get_device (event); struct eis_device *eis_device = eis_event_get_device (event);
MetaEisDevice *meta_eis_device = eis_device_get_user_data (eis_device); MetaEisDevice *device = eis_device_get_user_data (eis_device);
uint32_t key; uint32_t key;
gboolean is_press = eis_event_keyboard_get_key_is_press (event); gboolean is_press = eis_event_keyboard_get_key_is_press (event);
@ -481,14 +481,14 @@ handle_key (MetaEisClient *meta_eis_client,
if (key > MAX_KEY) if (key > MAX_KEY)
return; return;
if (is_press && !bit_is_set (meta_eis_device->key_state, key)) if (is_press && !bit_is_set (device->key_state, key))
bit_set (meta_eis_device->key_state, key); bit_set (device->key_state, key);
else if (!is_press && bit_is_set (meta_eis_device->key_state, key)) else if (!is_press && bit_is_set (device->key_state, key))
bit_clear (meta_eis_device->key_state, key); bit_clear (device->key_state, key);
else else
return; /* Duplicate press/release, should've been filtered by libeis */ return; /* Duplicate press/release, should've been filtered by libeis */
notify_key (meta_eis_device, key, is_press); notify_key (device, key, is_press);
} }
static gboolean static gboolean
@ -508,24 +508,24 @@ static void
on_keymap_changed (MetaBackend *backend, on_keymap_changed (MetaBackend *backend,
gpointer data) gpointer data)
{ {
MetaEisClient *meta_eis_client = data; MetaEisClient *client = data;
/* Changing the keymap means we have to remove our device and recreate it /* Changing the keymap means we have to remove our device and recreate it
* with the new keymap. * with the new keymap.
*/ */
g_hash_table_foreach_remove (meta_eis_client->eis_devices, g_hash_table_foreach_remove (client->eis_devices,
drop_kbd_devices, drop_kbd_devices,
meta_eis_client); client);
add_device (meta_eis_client, add_device (client,
meta_eis_client->eis_seat, client->eis_seat,
CLUTTER_KEYBOARD_DEVICE, CLUTTER_KEYBOARD_DEVICE,
"virtual keyboard", "virtual keyboard",
configure_keyboard); configure_keyboard);
} }
gboolean gboolean
meta_eis_client_process_event (MetaEisClient *meta_eis_client, meta_eis_client_process_event (MetaEisClient *client,
struct eis_event *event) struct eis_event *event)
{ {
enum eis_event_type type = eis_event_get_type (event); enum eis_event_type type = eis_event_get_type (event);
@ -536,26 +536,26 @@ meta_eis_client_process_event (MetaEisClient *meta_eis_client,
case EIS_EVENT_SEAT_BIND: case EIS_EVENT_SEAT_BIND:
eis_seat = eis_event_get_seat (event); eis_seat = eis_event_get_seat (event);
if (eis_event_seat_has_capability (event, EIS_DEVICE_CAP_POINTER)) if (eis_event_seat_has_capability (event, EIS_DEVICE_CAP_POINTER))
add_device (meta_eis_client, add_device (client,
eis_seat, eis_seat,
CLUTTER_POINTER_DEVICE, CLUTTER_POINTER_DEVICE,
"virtual pointer", "virtual pointer",
configure_rel); configure_rel);
if (eis_event_seat_has_capability (event, EIS_DEVICE_CAP_KEYBOARD)) if (eis_event_seat_has_capability (event, EIS_DEVICE_CAP_KEYBOARD))
{ {
add_device (meta_eis_client, add_device (client,
eis_seat, eis_seat,
CLUTTER_KEYBOARD_DEVICE, CLUTTER_KEYBOARD_DEVICE,
"virtual keyboard", "virtual keyboard",
configure_keyboard); configure_keyboard);
g_signal_connect (meta_eis_get_backend (meta_eis_client->meta_eis), g_signal_connect (meta_eis_get_backend (client->eis),
"keymap-changed", "keymap-changed",
G_CALLBACK (on_keymap_changed), G_CALLBACK (on_keymap_changed),
meta_eis_client); client);
} }
if (eis_event_seat_has_capability (event, EIS_DEVICE_CAP_POINTER_ABSOLUTE)) if (eis_event_seat_has_capability (event, EIS_DEVICE_CAP_POINTER_ABSOLUTE))
add_device (meta_eis_client, add_device (client,
eis_seat, eis_seat,
CLUTTER_POINTER_DEVICE, CLUTTER_POINTER_DEVICE,
"virtual absolute pointer", "virtual absolute pointer",
@ -565,31 +565,31 @@ meta_eis_client_process_event (MetaEisClient *meta_eis_client,
/* We only have one seat, so if the client unbinds from that /* We only have one seat, so if the client unbinds from that
* just disconnect it, no point keeping it alive */ * just disconnect it, no point keeping it alive */
case EIS_EVENT_DEVICE_CLOSED: case EIS_EVENT_DEVICE_CLOSED:
remove_device (meta_eis_client, eis_event_get_device (event), TRUE); remove_device (client, eis_event_get_device (event), TRUE);
break; break;
case EIS_EVENT_POINTER_MOTION: case EIS_EVENT_POINTER_MOTION:
handle_motion_relative (meta_eis_client, event); handle_motion_relative (client, event);
break; break;
case EIS_EVENT_POINTER_MOTION_ABSOLUTE: case EIS_EVENT_POINTER_MOTION_ABSOLUTE:
handle_motion_absolute (meta_eis_client, event); handle_motion_absolute (client, event);
break; break;
case EIS_EVENT_BUTTON_BUTTON: case EIS_EVENT_BUTTON_BUTTON:
handle_button (meta_eis_client, event); handle_button (client, event);
break; break;
case EIS_EVENT_SCROLL_DELTA: case EIS_EVENT_SCROLL_DELTA:
handle_scroll (meta_eis_client, event); handle_scroll (client, event);
break; break;
case EIS_EVENT_SCROLL_STOP: case EIS_EVENT_SCROLL_STOP:
handle_scroll_stop (meta_eis_client, event); handle_scroll_stop (client, event);
break; break;
case EIS_EVENT_SCROLL_CANCEL: case EIS_EVENT_SCROLL_CANCEL:
handle_scroll_cancel (meta_eis_client, event); handle_scroll_cancel (client, event);
break; break;
case EIS_EVENT_SCROLL_DISCRETE: case EIS_EVENT_SCROLL_DISCRETE:
handle_scroll_discrete (meta_eis_client, event); handle_scroll_discrete (client, event);
break; break;
case EIS_EVENT_KEYBOARD_KEY: case EIS_EVENT_KEYBOARD_KEY:
handle_key (meta_eis_client, event); handle_key (client, event);
break; break;
case EIS_EVENT_FRAME: case EIS_EVENT_FRAME:
/* FIXME: we should be accumulating the above events */ /* FIXME: we should be accumulating the above events */
@ -620,21 +620,21 @@ drop_abs_devices (gpointer key,
} }
static void static void
meta_eis_client_set_viewports (MetaEisClient *meta_eis_client, meta_eis_client_set_viewports (MetaEisClient *client,
MetaViewportInfo *viewports) MetaViewportInfo *viewports)
{ {
/* Updating viewports means we have to recreate our absolute pointer /* Updating viewports means we have to recreate our absolute pointer
* devices. */ * devices. */
g_hash_table_foreach_remove (meta_eis_client->eis_devices, g_hash_table_foreach_remove (client->eis_devices,
drop_abs_devices, drop_abs_devices,
meta_eis_client); client);
g_clear_object (&meta_eis_client->viewports); g_clear_object (&client->viewports);
meta_eis_client->viewports = g_object_ref (viewports); client->viewports = g_object_ref (viewports);
add_device (meta_eis_client, add_device (client,
meta_eis_client->eis_seat, client->eis_seat,
CLUTTER_POINTER_DEVICE, CLUTTER_POINTER_DEVICE,
"virtual absolute pointer", "virtual absolute pointer",
configure_abs); configure_abs);
@ -642,45 +642,45 @@ meta_eis_client_set_viewports (MetaEisClient *meta_eis_client,
static void static void
on_monitors_changed (MetaMonitorManager *monitor_manager, on_monitors_changed (MetaMonitorManager *monitor_manager,
MetaEisClient *meta_eis_client) MetaEisClient *client)
{ {
MetaViewportInfo *viewports; MetaViewportInfo *viewports;
viewports = meta_monitor_manager_get_viewports (monitor_manager); viewports = meta_monitor_manager_get_viewports (monitor_manager);
meta_eis_client_set_viewports (meta_eis_client, viewports); meta_eis_client_set_viewports (client, viewports);
} }
static void static void
meta_eis_client_disconnect (MetaEisClient *meta_eis_client) meta_eis_client_disconnect (MetaEisClient *client)
{ {
MetaBackend *backend = meta_eis_get_backend (meta_eis_client->meta_eis); MetaBackend *backend = meta_eis_get_backend (client->eis);
MetaMonitorManager *monitor_manager = meta_backend_get_monitor_manager (backend); MetaMonitorManager *monitor_manager = meta_backend_get_monitor_manager (backend);
g_signal_handlers_disconnect_by_func (monitor_manager, g_signal_handlers_disconnect_by_func (monitor_manager,
on_monitors_changed, on_monitors_changed,
meta_eis_client); client);
g_hash_table_foreach_remove (meta_eis_client->eis_devices, drop_device, meta_eis_client); g_hash_table_foreach_remove (client->eis_devices, drop_device, client);
g_clear_pointer (&meta_eis_client->eis_seat, eis_seat_unref); g_clear_pointer (&client->eis_seat, eis_seat_unref);
if (meta_eis_client->eis_client) if (client->eis_client)
eis_client_disconnect (meta_eis_client->eis_client); eis_client_disconnect (client->eis_client);
g_clear_pointer (&meta_eis_client->eis_client, eis_client_unref); g_clear_pointer (&client->eis_client, eis_client_unref);
g_clear_object (&meta_eis_client->viewports); g_clear_object (&client->viewports);
} }
MetaEisClient * MetaEisClient *
meta_eis_client_new (MetaEis *meta_eis, meta_eis_client_new (MetaEis *eis,
struct eis_client *eis_client) struct eis_client *eis_client)
{ {
MetaEisClient *meta_eis_client; MetaEisClient *client;
MetaBackend *backend; MetaBackend *backend;
MetaMonitorManager *monitor_manager; MetaMonitorManager *monitor_manager;
MetaViewportInfo *viewports; MetaViewportInfo *viewports;
struct eis_seat *eis_seat; struct eis_seat *eis_seat;
meta_eis_client = g_object_new (META_TYPE_EIS_CLIENT, NULL); client = g_object_new (META_TYPE_EIS_CLIENT, NULL);
meta_eis_client->meta_eis = meta_eis; client->eis = eis;
meta_eis_client->eis_client = eis_client_ref (eis_client); client->eis_client = eis_client_ref (eis_client);
eis_client_set_user_data (meta_eis_client->eis_client, meta_eis_client); eis_client_set_user_data (client->eis_client, client);
/* We're relying on some third party to filter clients for us */ /* We're relying on some third party to filter clients for us */
eis_client_connect (eis_client); eis_client_connect (eis_client);
@ -700,37 +700,37 @@ meta_eis_client_new (MetaEis *meta_eis,
eis_seat_add (eis_seat); eis_seat_add (eis_seat);
eis_seat_unref (eis_seat); eis_seat_unref (eis_seat);
meta_eis_client->eis_seat = eis_seat_ref (eis_seat); client->eis_seat = eis_seat_ref (eis_seat);
meta_eis_client->eis_devices = g_hash_table_new_full (g_direct_hash, g_direct_equal, client->eis_devices = g_hash_table_new_full (g_direct_hash, g_direct_equal,
(GDestroyNotify) eis_device_unref, (GDestroyNotify) eis_device_unref,
(GDestroyNotify) meta_eis_device_free); (GDestroyNotify) meta_eis_device_free);
backend = meta_eis_get_backend (meta_eis); backend = meta_eis_get_backend (eis);
monitor_manager = meta_backend_get_monitor_manager (backend); monitor_manager = meta_backend_get_monitor_manager (backend);
viewports = meta_monitor_manager_get_viewports (monitor_manager); viewports = meta_monitor_manager_get_viewports (monitor_manager);
meta_eis_client_set_viewports (meta_eis_client, viewports); meta_eis_client_set_viewports (client, viewports);
g_signal_connect (monitor_manager, "monitors-changed", g_signal_connect (monitor_manager, "monitors-changed",
G_CALLBACK (on_monitors_changed), G_CALLBACK (on_monitors_changed),
meta_eis_client); client);
return meta_eis_client; return client;
} }
static void static void
meta_eis_client_init (MetaEisClient *meta_eis_client) meta_eis_client_init (MetaEisClient *client)
{ {
} }
static void static void
meta_eis_client_finalize (GObject *object) meta_eis_client_finalize (GObject *object)
{ {
MetaEisClient *meta_eis_client = META_EIS_CLIENT (object); MetaEisClient *client = META_EIS_CLIENT (object);
g_signal_handlers_disconnect_by_func (meta_eis_get_backend (meta_eis_client->meta_eis), g_signal_handlers_disconnect_by_func (meta_eis_get_backend (client->eis),
on_keymap_changed, on_keymap_changed,
meta_eis_client); client);
meta_eis_client_disconnect (meta_eis_client); meta_eis_client_disconnect (client);
G_OBJECT_CLASS (meta_eis_client_parent_class)->finalize (object); G_OBJECT_CLASS (meta_eis_client_parent_class)->finalize (object);
} }

4
src/backends/meta-eis-client.h
View File

@ -31,8 +31,8 @@
G_DECLARE_FINAL_TYPE (MetaEisClient, meta_eis_client, G_DECLARE_FINAL_TYPE (MetaEisClient, meta_eis_client,
META, EIS_CLIENT, GObject) META, EIS_CLIENT, GObject)
MetaEisClient *meta_eis_client_new (MetaEis *meta_eis, MetaEisClient *meta_eis_client_new (MetaEis *eis,
struct eis_client *eis_client); struct eis_client *eis_client);
gboolean meta_eis_client_process_event (MetaEisClient *meta_eis_client, gboolean meta_eis_client_process_event (MetaEisClient *client,
struct eis_event *eis_event); struct eis_event *eis_event);

100
src/backends/meta-eis.c
View File

@ -33,7 +33,7 @@ struct _MetaEventSource
{ {
GSource source; GSource source;
MetaEis *meta_eis; MetaEis *eis;
GPollFD event_poll_fd; GPollFD event_poll_fd;
}; };
@ -51,80 +51,80 @@ struct _MetaEis
G_DEFINE_TYPE (MetaEis, meta_eis, G_TYPE_OBJECT) G_DEFINE_TYPE (MetaEis, meta_eis, G_TYPE_OBJECT)
MetaBackend * MetaBackend *
meta_eis_get_backend (MetaEis *meta_eis) meta_eis_get_backend (MetaEis *eis)
{ {
return meta_eis->backend; return eis->backend;
} }
void void
meta_eis_remove_all_clients (MetaEis *meta_eis) meta_eis_remove_all_clients (MetaEis *eis)
{ {
g_hash_table_remove_all (meta_eis->eis_clients); g_hash_table_remove_all (eis->eis_clients);
} }
static void static void
meta_eis_remove_client (MetaEis *meta_eis, meta_eis_remove_client (MetaEis *eis,
struct eis_client *eis_client) struct eis_client *eis_client)
{ {
g_hash_table_remove (meta_eis->eis_clients, eis_client); g_hash_table_remove (eis->eis_clients, eis_client);
} }
static void static void
meta_eis_add_client (MetaEis *meta_eis, meta_eis_add_client (MetaEis *eis,
struct eis_client *eis_client) struct eis_client *eis_client)
{ {
MetaEisClient *meta_eis_client; MetaEisClient *client;
meta_eis_client = meta_eis_client_new (meta_eis, eis_client); client = meta_eis_client_new (eis, eis_client);
g_hash_table_insert (meta_eis->eis_clients, g_hash_table_insert (eis->eis_clients,
eis_client_ref (eis_client), eis_client_ref (eis_client),
meta_eis_client); client);
} }
static void static void
process_event (MetaEis *meta_eis, process_event (MetaEis *eis,
struct eis_event *event) struct eis_event *event)
{ {
enum eis_event_type type = eis_event_get_type (event); enum eis_event_type type = eis_event_get_type (event);
struct eis_client *eis_client = eis_event_get_client (event); struct eis_client *eis_client = eis_event_get_client (event);
MetaEisClient *meta_eis_client; MetaEisClient *client;
switch (type) switch (type)
{ {
case EIS_EVENT_CLIENT_CONNECT: case EIS_EVENT_CLIENT_CONNECT:
meta_eis_add_client (meta_eis, eis_client); meta_eis_add_client (eis, eis_client);
break; break;
case EIS_EVENT_CLIENT_DISCONNECT: case EIS_EVENT_CLIENT_DISCONNECT:
meta_eis_remove_client (meta_eis, eis_client); meta_eis_remove_client (eis, eis_client);
break; break;
default: default:
meta_eis_client = g_hash_table_lookup (meta_eis->eis_clients, eis_client); client = g_hash_table_lookup (eis->eis_clients, eis_client);
if (!meta_eis_client) if (!client)
{ {
g_warning ("Event for unknown EIS client: %s", g_warning ("Event for unknown EIS client: %s",
eis_client_get_name (eis_client)); eis_client_get_name (eis_client));
return; return;
} }
meta_eis_client_process_event (meta_eis_client, event); meta_eis_client_process_event (client, event);
break; break;
} }
} }
static void static void
process_events (MetaEis *meta_eis) process_events (MetaEis *eis)
{ {
struct eis_event *e; struct eis_event *e;
while ((e = eis_get_event (meta_eis->eis))) while ((e = eis_get_event (eis->eis)))
{ {
process_event (meta_eis, e); process_event (eis, e);
eis_event_unref (e); eis_event_unref (e);
} }
} }
static MetaEventSource * static MetaEventSource *
meta_event_source_new (MetaEis *meta_eis, meta_event_source_new (MetaEis *eis,
int fd, int fd,
GSourceFuncs *event_funcs) GSourceFuncs *event_funcs)
{ {
@ -135,7 +135,7 @@ meta_event_source_new (MetaEis *meta_eis,
event_source = (MetaEventSource *) source; event_source = (MetaEventSource *) source;
/* setup the source */ /* setup the source */
event_source->meta_eis = meta_eis; event_source->eis = eis;
event_source->event_poll_fd.fd = fd; event_source->event_poll_fd.fd = fd;
event_source->event_poll_fd.events = G_IO_IN; event_source->event_poll_fd.events = G_IO_IN;
@ -167,12 +167,12 @@ meta_event_prepare (GSource *g_source,
int *timeout_ms) int *timeout_ms)
{ {
MetaEventSource *source = (MetaEventSource *) g_source; MetaEventSource *source = (MetaEventSource *) g_source;
MetaEis *meta_eis = source->meta_eis; MetaEis *eis = source->eis;
struct eis_event *e; struct eis_event *e;
*timeout_ms = -1; *timeout_ms = -1;
e = eis_peek_event (meta_eis->eis); e = eis_peek_event (eis->eis);
if (e) if (e)
{ {
eis_event_unref (e); eis_event_unref (e);
@ -198,10 +198,10 @@ meta_event_dispatch (GSource *g_source,
gpointer user_data) gpointer user_data)
{ {
MetaEventSource *source = (MetaEventSource *) g_source; MetaEventSource *source = (MetaEventSource *) g_source;
MetaEis *meta_eis = source->meta_eis; MetaEis *eis = source->eis;
eis_dispatch (meta_eis->eis); eis_dispatch (eis->eis);
process_events (meta_eis); process_events (eis);
return TRUE; return TRUE;
} }
@ -238,13 +238,13 @@ eis_logger (struct eis *eis,
} }
int int
meta_eis_add_client_get_fd (MetaEis *meta_eis) meta_eis_add_client_get_fd (MetaEis *eis)
{ {
return eis_backend_fd_add_client (meta_eis->eis); return eis_backend_fd_add_client (eis->eis);
} }
static int static int
try_and_find_free_eis_socket (MetaEis *meta_eis) try_and_find_free_eis_socket (MetaEis *eis)
{ {
int rc; int rc;
int n; int n;
@ -253,7 +253,7 @@ try_and_find_free_eis_socket (MetaEis *meta_eis)
for (n = 0; n < 100; n++) for (n = 0; n < 100; n++)
{ {
g_snprintf (socketname, sizeof (socketname), "eis-%d", n); g_snprintf (socketname, sizeof (socketname), "eis-%d", n);
rc = eis_setup_backend_socket (meta_eis->eis, socketname); rc = eis_setup_backend_socket (eis->eis, socketname);
if (rc == 0) if (rc == 0)
{ {
g_info ("Using EIS socket: %s", socketname); g_info ("Using EIS socket: %s", socketname);
@ -267,35 +267,35 @@ try_and_find_free_eis_socket (MetaEis *meta_eis)
MetaEis * MetaEis *
meta_eis_new (MetaBackend *backend) meta_eis_new (MetaBackend *backend)
{ {
MetaEis *meta_eis; MetaEis *eis;
int fd; int fd;
int rc; int rc;
meta_eis = g_object_new (META_TYPE_EIS, NULL); eis = g_object_new (META_TYPE_EIS, NULL);
meta_eis->backend = backend; eis->backend = backend;
meta_eis->eis = eis_new (meta_eis); eis->eis = eis_new (eis);
rc = try_and_find_free_eis_socket (meta_eis); rc = try_and_find_free_eis_socket (eis);
if (rc != 0) if (rc != 0)
{ {
g_warning ("Failed to initialize the EIS socket: %s", g_strerror (-rc)); g_warning ("Failed to initialize the EIS socket: %s", g_strerror (-rc));
g_clear_pointer (&meta_eis->eis, eis_unref); g_clear_pointer (&eis->eis, eis_unref);
return NULL; return NULL;
} }
eis_log_set_handler (meta_eis->eis, eis_logger); eis_log_set_handler (eis->eis, eis_logger);
eis_log_set_priority (meta_eis->eis, EIS_LOG_PRIORITY_DEBUG); eis_log_set_priority (eis->eis, EIS_LOG_PRIORITY_DEBUG);
fd = eis_get_fd (meta_eis->eis); fd = eis_get_fd (eis->eis);
meta_eis->event_source = meta_event_source_new (meta_eis, fd, &eis_event_funcs); eis->event_source = meta_event_source_new (eis, fd, &eis_event_funcs);
return meta_eis; return eis;
} }
static void static void
meta_eis_init (MetaEis *meta_eis) meta_eis_init (MetaEis *eis)
{ {
meta_eis->eis_clients = g_hash_table_new_full (g_direct_hash, g_direct_equal, eis->eis_clients = g_hash_table_new_full (g_direct_hash, g_direct_equal,
(GDestroyNotify) eis_client_unref, (GDestroyNotify) eis_client_unref,
(GDestroyNotify) g_object_unref); (GDestroyNotify) g_object_unref);
} }
@ -303,11 +303,11 @@ meta_eis_init (MetaEis *meta_eis)
static void static void
meta_eis_finalize (GObject *object) meta_eis_finalize (GObject *object)
{ {
MetaEis *meta_eis = META_EIS (object); MetaEis *eis = META_EIS (object);
g_clear_pointer (&meta_eis->event_source, meta_event_source_free); g_clear_pointer (&eis->event_source, meta_event_source_free);
g_clear_pointer (&meta_eis->eis, eis_unref); g_clear_pointer (&eis->eis, eis_unref);
g_clear_pointer (&meta_eis->eis_clients, g_hash_table_destroy); g_clear_pointer (&eis->eis_clients, g_hash_table_destroy);
G_OBJECT_CLASS (meta_eis_parent_class)->finalize (object); G_OBJECT_CLASS (meta_eis_parent_class)->finalize (object);
} }

6
src/backends/meta-eis.h
View File

@ -30,6 +30,6 @@ G_DECLARE_FINAL_TYPE (MetaEis, meta_eis,
META, EIS, GObject) META, EIS, GObject)
MetaEis * meta_eis_new (MetaBackend *backend); MetaEis * meta_eis_new (MetaBackend *backend);
MetaBackend * meta_eis_get_backend (MetaEis *meta_eis); MetaBackend * meta_eis_get_backend (MetaEis *eis);
int meta_eis_add_client_get_fd (MetaEis *meta_eis); int meta_eis_add_client_get_fd (MetaEis *eis);
void meta_eis_remove_all_clients (MetaEis *meta_eis); void meta_eis_remove_all_clients (MetaEis *eis);