External/libmks
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/libmks.git synced 2024-12-22 13:45:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'bilelmoussaoui/touch-support' into 'main'

Browse Source 
Add touch events support

See merge request chergert/libmks!26
This commit is contained in:
Christian Hergert 2023-06-15 23:03:54 +00:00
commit 092e6cd418
14 changed files with 630 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
lib/dbus-display1.xml
View File

@ -39,8 +39,9 @@
"Text" (see :dbus:prop:`Type` and other properties).
Interactions with a console may be done with
:dbus:iface:`org.qemu.Display1.Keyboard` and
:dbus:iface:`org.qemu.Display1.Mouse` interfaces when available.
:dbus:iface:`org.qemu.Display1.Keyboard`,
:dbus:iface:`org.qemu.Display1.Mouse` and
:dbus:iface:`org.qemu.Display1.Touch` interfaces when available.
-->
<interface name="org.qemu.Display1.Console">
<!--
@ -237,6 +238,46 @@
<property name="IsAbsolute" type="b" access="read"/>
</interface>
<!--
org.qemu.Display1.Touch:
This interface in implemented on ``/org/qemu/Display1/Console_$id`` (see
:dbus:iface:`~org.qemu.Display1.Console` documentation).
.. _dbus-kind-values:
**Kind values**::
Begin = 0
Update = 1
End = 2
Cancel = 3
-->
<interface name="org.qemu.Display1.Touch">
<!--
SendEvent:
@kind: The touch event kind
@num_slot: The slot number.
@x: The x coordinates.
@y: The y coordinates.
Send a touch gesture begin event.
-->
<method name="SendEvent">
<arg type="u" name="kind" direction="in"/>
<arg type="t" name="num_slot" direction="in"/>
<arg type="d" name="x" direction="in"/>
<arg type="d" name="y" direction="in"/>
</method>
<!--
MaxSlots:
The maximum number of slots.
-->
<property name="MaxSlots" type="i" access="read"/>
</interface>
<!--
org.qemu.Display1.Listener:

1
lib/libmks.h
View File

@ -35,6 +35,7 @@ G_BEGIN_DECLS
# include "mks-screen.h"
# include "mks-screen-attributes.h"
# include "mks-session.h"
# include "mks-touchable.h"
# include "mks-types.h"
# include "mks-version.h"
# include "mks-version-macros.h"

2
lib/meson.build
View File

@ -15,6 +15,7 @@ libmks_sources = [
'mks-screen.c',
'mks-screen-attributes.c',
'mks-session.c',
'mks-touchable.c',
]
libmks_headers = [
@ -27,6 +28,7 @@ libmks_headers = [
'mks-screen.h',
'mks-screen-attributes.h',
'mks-session.h',
'mks-touchable.h',
'mks-types.h',
'mks-version-macros.h',
]

3
lib/mks-display-picture-private.h
View File

@ -42,5 +42,8 @@ void mks_display_picture_set_mouse (MksDisplayPicture *self,
MksKeyboard *mks_display_picture_get_keyboard (MksDisplayPicture *self);
void mks_display_picture_set_keyboard (MksDisplayPicture *self,
MksKeyboard *keyboard);
MksTouchable *mks_display_picture_get_touchable (MksDisplayPicture *self);
void mks_display_picture_set_touchable (MksDisplayPicture *self,
MksTouchable *touchable);
G_END_DECLS

173
lib/mks-display-picture.c
View File

@ -26,6 +26,7 @@
#include "mks-display-picture-private.h"
#include "mks-keyboard.h"
#include "mks-mouse.h"
#include "mks-touchable.h"
#include "mks-util-private.h"
struct _MksDisplayPicture
@ -36,6 +37,7 @@ struct _MksDisplayPicture
MksPaintable *paintable;
MksKeyboard *keyboard;
MksMouse *mouse;
MksTouchable *touchable;
double last_mouse_x;
double last_mouse_y;
@ -46,6 +48,7 @@ enum {
PROP_PAINTABLE,
PROP_KEYBOARD,
PROP_MOUSE,
PROP_TOUCHABLE,
N_PROPS
};
@ -67,7 +70,7 @@ mks_display_picture_keyboard_press_cb (GObject *object,
g_assert (MKS_IS_DISPLAY_PICTURE (self));
if (!mks_keyboard_press_finish (keyboard, result, &error))
g_warning ("Keyboard press failed: %s", error->message);
g_debug ("Keyboard press failed: %s", error->message);
}
static void
@ -84,7 +87,7 @@ mks_display_picture_keyboard_release_cb (GObject *object,
g_assert (MKS_IS_DISPLAY_PICTURE (self));
if (!mks_keyboard_release_finish (keyboard, result, &error))
g_warning ("Keyboard release failed: %s", error->message);
g_debug ("Keyboard release failed: %s", error->message);
}
static void
@ -101,7 +104,7 @@ mks_display_picture_mouse_move_to_cb (GObject *object,
g_assert (MKS_IS_DISPLAY_PICTURE (self));
if (!mks_mouse_move_to_finish (mouse, result, &error))
g_warning ("Failed move_to: %s", error->message);
g_debug ("Failed move_to: %s", error->message);
}
static void
@ -118,7 +121,24 @@ mks_display_picture_mouse_move_by_cb (GObject *object,
g_assert (MKS_IS_DISPLAY_PICTURE (self));
if (!mks_mouse_move_by_finish (mouse, result, &error))
g_warning ("Failed move_by: %s", error->message);
g_debug ("Failed move_by: %s", error->message);
}
static void
mks_display_picture_touchable_send_event_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
MksTouchable *touchable = (MksTouchable *)object;
g_autoptr(MksDisplayPicture) self = user_data;
g_autoptr(GError) error = NULL;
g_assert (MKS_IS_TOUCHABLE (touchable));
g_assert (G_IS_ASYNC_RESULT (result));
g_assert (MKS_IS_DISPLAY_PICTURE (self));
if (!mks_touchable_send_event_finish (touchable, result, &error))
g_debug ("Failed to send touch event: %s", error->message);
}
static void
@ -153,7 +173,7 @@ mks_display_picture_mouse_press_cb (GObject *object,
g_assert (MKS_IS_DISPLAY_PICTURE (self));
if (!mks_mouse_press_finish (mouse, result, &error))
g_warning ("Mouse press failed: %s", error->message);
g_debug ("Mouse press failed: %s", error->message);
}
static void
@ -170,9 +190,58 @@ mks_display_picture_mouse_release_cb (GObject *object,
g_assert (MKS_IS_DISPLAY_PICTURE (self));
if (!mks_mouse_release_finish (mouse, result, &error))
g_warning ("Mouse release failed: %s", error->message);
g_debug ("Mouse release failed: %s", error->message);
}
static gboolean
mks_display_picture_event_get_guest_position (MksDisplayPicture *self,
GdkEvent *event,
double *guest_x,
double *guest_y)
{
GdkPaintable *paintable;
GtkNative *native;
int guest_width, guest_height;
graphene_rect_t area;
graphene_point_t translated;
double translate_x, translate_y;
double x, y;
g_assert (MKS_IS_DISPLAY_PICTURE (self));
g_assert (GDK_IS_EVENT (event));
paintable = GDK_PAINTABLE (self->paintable);
native = gtk_widget_get_native (GTK_WIDGET (self));
guest_width = gdk_paintable_get_intrinsic_width (paintable);
guest_height = gdk_paintable_get_intrinsic_height (paintable);
area = GRAPHENE_RECT_INIT (0, 0,
gtk_widget_get_width (GTK_WIDGET (self)),
gtk_widget_get_height (GTK_WIDGET (self)));
gtk_native_get_surface_transform (native, &translate_x, &translate_y);
if (gdk_event_get_position (event, &x, &y))
{
x -= translate_x;
y -= translate_y;
if (!gtk_widget_compute_point (GTK_WIDGET (native),
GTK_WIDGET (self),
&GRAPHENE_POINT_INIT (x, y),
&translated))
return FALSE;
*guest_x = floor (translated.x) / area.size.width * guest_width;
*guest_y = floor (translated.y) / area.size.height * guest_height;
*guest_x = CLAMP (*guest_x, 0, guest_width);
*guest_y = CLAMP (*guest_y, 0, guest_width);
return TRUE;
}
return FALSE;
}
static gboolean
mks_display_picture_legacy_event_cb (MksDisplayPicture *self,
@ -181,19 +250,52 @@ mks_display_picture_legacy_event_cb (MksDisplayPicture *self,
{
GdkPaintable *paintable;
GdkEventType event_type;
GdkEventSequence *sequence;
g_assert (MKS_IS_DISPLAY_PICTURE (self));
g_assert (event != NULL);
g_assert (GDK_IS_EVENT (event));
g_assert (GTK_IS_EVENT_CONTROLLER_LEGACY (controller));
if (self->keyboard == NULL || self->mouse == NULL || self->paintable == NULL)
if (self->keyboard == NULL || self->mouse == NULL || self->touchable == NULL || self->paintable == NULL)
return GDK_EVENT_PROPAGATE;
event_type = gdk_event_get_event_type (event);
paintable = GDK_PAINTABLE (self->paintable);
sequence = gdk_event_get_event_sequence (event);
switch ((int)event_type)
{
case GDK_TOUCH_BEGIN:
case GDK_TOUCH_UPDATE:
case GDK_TOUCH_CANCEL:
case GDK_TOUCH_END:
{
double guest_x, guest_y;
uint64_t num_slot = GPOINTER_TO_UINT (sequence);
MksTouchEventKind kind;
if (event_type == GDK_TOUCH_BEGIN)
kind = MKS_TOUCH_EVENT_BEGIN;
else if (event_type == GDK_TOUCH_UPDATE)
kind = MKS_TOUCH_EVENT_UPDATE;
else if (event_type == GDK_TOUCH_CANCEL)
kind = MKS_TOUCH_EVENT_CANCEL;
else
kind = MKS_TOUCH_EVENT_END;
if (mks_display_picture_event_get_guest_position (self, event, &guest_x, &guest_y))
{
mks_touchable_send_event (self->touchable, kind,
num_slot,
guest_x, guest_y,
NULL,
mks_display_picture_touchable_send_event_cb,
g_object_ref (self));
return GDK_EVENT_STOP;
}
break;
}
case GDK_MOTION_NOTIFY:
{
GdkSurface *surface = gdk_event_get_surface (event);
@ -215,28 +317,9 @@ mks_display_picture_legacy_event_cb (MksDisplayPicture *self,
if (mks_mouse_get_is_absolute (self->mouse))
{
gdouble x, y;
if (gdk_event_get_position (event, &x, &y))
double guest_x, guest_y;
if (mks_display_picture_event_get_guest_position (self, event, &guest_x, &guest_y))
{
graphene_point_t translated;
double guest_x, guest_y;
x -= translate_x;
y -= translate_y;
if (!gtk_widget_compute_point (GTK_WIDGET (native),
GTK_WIDGET (self),
&GRAPHENE_POINT_INIT (x, y),
&translated))
break;
guest_x = floor (translated.x) / area.size.width * guest_width;
guest_y = floor (translated.y) / area.size.height * guest_height;
guest_x = CLAMP (guest_x, 0, guest_width);
guest_y = CLAMP (guest_y, 0, guest_width);
mks_mouse_move_to (self->mouse,
guest_x,
guest_y,
@ -558,6 +641,10 @@ mks_display_picture_get_property (GObject *object,
g_value_set_object (value, mks_display_picture_get_mouse (self));
break;
case PROP_TOUCHABLE:
g_value_set_object (value, mks_display_picture_get_touchable (self));
break;
case PROP_PAINTABLE:
g_value_set_object (value, mks_display_picture_get_paintable (self));
break;
@ -585,6 +672,10 @@ mks_display_picture_set_property (GObject *object,
mks_display_picture_set_mouse (self, g_value_get_object (value));
break;
case PROP_TOUCHABLE:
mks_display_picture_set_touchable (self, g_value_get_object (value));
break;
case PROP_PAINTABLE:
mks_display_picture_set_paintable (self, g_value_get_object (value));
break;
@ -618,6 +709,11 @@ mks_display_picture_class_init (MksDisplayPictureClass *klass)
MKS_TYPE_MOUSE,
(G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS));
properties[PROP_TOUCHABLE] =
g_param_spec_object ("touchable", NULL, NULL,
MKS_TYPE_TOUCHABLE,
(G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS));
properties[PROP_PAINTABLE] =
g_param_spec_object ("paintable", NULL, NULL,
MKS_TYPE_PAINTABLE,
@ -733,3 +829,22 @@ mks_display_picture_set_keyboard (MksDisplayPicture *self,
if (g_set_object (&self->keyboard, keyboard))
g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_KEYBOARD]);
}
MksTouchable *
mks_display_picture_get_touchable (MksDisplayPicture *self)
{
g_return_val_if_fail (MKS_IS_DISPLAY_PICTURE (self), NULL);
return self->touchable;
}
void
mks_display_picture_set_touchable (MksDisplayPicture *self,
MksTouchable *touchable)
{
g_return_if_fail (MKS_IS_DISPLAY_PICTURE (self));
g_return_if_fail (!touchable || MKS_IS_TOUCHABLE (touchable));
if (g_set_object (&self->touchable, touchable))
g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_TOUCHABLE]);
}

2
lib/mks-display.c
View File

@ -141,6 +141,7 @@ mks_display_connect (MksDisplay *self,
{
mks_display_picture_set_keyboard (priv->picture, mks_screen_get_keyboard (screen));
mks_display_picture_set_mouse (priv->picture, mks_screen_get_mouse (screen));
mks_display_picture_set_touchable (priv->picture, mks_screen_get_touchable (screen));
mks_screen_resizer_set_screen (priv->resizer, screen);
mks_screen_attach (screen,
@ -172,6 +173,7 @@ mks_display_disconnect (MksDisplay *self)
mks_display_picture_set_paintable (priv->picture, NULL);
mks_display_picture_set_keyboard (priv->picture, NULL);
mks_display_picture_set_mouse (priv->picture, NULL);
mks_display_picture_set_touchable (priv->picture, NULL);
}
MKS_EXIT;

2
lib/mks-init.c
View File

@ -35,6 +35,7 @@
#include "mks-screen.h"
#include "mks-screen-attributes.h"
#include "mks-session.h"
#include "mks-touchable.h"
#include "mks-version.h"
static void
@ -65,6 +66,7 @@ mks_init_gtypes (void)
g_type_ensure (MKS_TYPE_SCREEN);
g_type_ensure (MKS_TYPE_SCREEN_ATTRIBUTES);
g_type_ensure (MKS_TYPE_SESSION);
g_type_ensure (MKS_TYPE_TOUCHABLE);
}
/**

2
lib/mks-screen-resizer.c
View File

@ -135,7 +135,7 @@ on_screen_configure_cb (GObject *object,
g_assert (MKS_IS_SCREEN_RESIZER (self));
if (!mks_screen_configure_finish (screen, result, &error))
g_warning ("Screen configure failed: %s", error->message);
g_debug ("Screen configure failed: %s", error->message);
self->in_progress = FALSE;
attributes = g_steal_pointer (&self->next_op);

20
lib/mks-screen.c
View File

@ -34,6 +34,7 @@
#include "mks-paintable-private.h"
#include "mks-screen-attributes-private.h"
#include "mks-screen.h"
#include "mks-touchable.h"
struct _MksScreenClass
{
@ -49,6 +50,7 @@ struct _MksScreen
MksKeyboard *keyboard;
MksMouse *mouse;
MksTouchable *touchable;
guint number;
guint width;
@ -206,6 +208,8 @@ mks_screen_setup (MksDevice *device,
self->keyboard = _mks_device_new (MKS_TYPE_KEYBOARD, device->session, object);
else if (MKS_QEMU_IS_MOUSE (iface))
self->mouse = _mks_device_new (MKS_TYPE_MOUSE, device->session, object);
else if (MKS_QEMU_IS_TOUCH (iface))
self->touchable = _mks_device_new (MKS_TYPE_TOUCHABLE, device->session, object);
}
return self->console != NULL &&
@ -360,6 +364,22 @@ mks_screen_get_mouse (MksScreen *self)
return self->mouse;
}
/**
* mks_screen_get_touchable:
* @self: a #MksScreen
*
* Gets the #MksScreen:touchable property.
*
* Returns: (transfer none): a #MksTouchable
*/
MksTouchable *
mks_screen_get_touchable (MksScreen *self)
{
g_return_val_if_fail (MKS_IS_SCREEN (self), NULL);
return self->touchable;
}
/**
* mks_screen_get_kind:
* @self: a #MksScreen

2
lib/mks-screen.h
View File

@ -65,6 +65,8 @@ MksKeyboard *mks_screen_get_keyboard (MksScreen *self);
MKS_AVAILABLE_IN_ALL
MksMouse *mks_screen_get_mouse (MksScreen *self);
MKS_AVAILABLE_IN_ALL
MksTouchable *mks_screen_get_touchable (MksScreen *self);
MKS_AVAILABLE_IN_ALL
guint mks_screen_get_width (MksScreen *self);
MKS_AVAILABLE_IN_ALL
guint mks_screen_get_height (MksScreen *self);

316
lib/mks-touchable.c Normal file
View File

@ -0,0 +1,316 @@
/*
* mks-touchable.c
*
* Copyright 2023 Bilal Elmoussaoui <belmouss@redhat.com>
*
* 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.1 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 General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*/
#include "config.h"
#include "mks-device-private.h"
#include "mks-touchable.h"
#include "mks-util-private.h"
/**
* MksTouchable:
*
* A virtualized QEMU touch device.
*/
struct _MksTouchable
{
MksDevice parent_instance;
MksQemuTouch *touch;
};
struct _MksTouchableClass
{
MksDeviceClass parent_instance;
};
G_DEFINE_FINAL_TYPE (MksTouchable, mks_touchable, MKS_TYPE_DEVICE)
enum {
PROP_0,
PROP_MAX_SLOTS,
N_PROPS
};
static GParamSpec *properties [N_PROPS];
static void
mks_touchable_set_touch (MksTouchable *self,
MksQemuTouch *touch)
{
g_assert (MKS_IS_TOUCHABLE (self));
g_assert (!touch || MKS_QEMU_IS_TOUCH (touch));
g_set_object (&self->touch, touch);
}
static gboolean
mks_touchable_setup (MksDevice *device,
MksQemuObject *object)
{
MksTouchable *self = (MksTouchable *)device;
g_autolist(GDBusInterface) interfaces = NULL;
g_assert (MKS_IS_TOUCHABLE (self));
g_assert (MKS_QEMU_IS_OBJECT (object));
interfaces = g_dbus_object_get_interfaces (G_DBUS_OBJECT (object));
for (const GList *iter = interfaces; iter; iter = iter->next)
{
GDBusInterface *iface = iter->data;
if (MKS_QEMU_IS_TOUCH (iface))
mks_touchable_set_touch (self, MKS_QEMU_TOUCH (iface));
}
return self->touch != NULL;
}
static void
mks_touchable_dispose (GObject *object)
{
MksTouchable *self = (MksTouchable *)object;
g_clear_object (&self->touch);
G_OBJECT_CLASS (mks_touchable_parent_class)->dispose (object);
}
static void
mks_touchable_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
MksTouchable *self = MKS_TOUCHABLE (object);
switch (prop_id)
{
case PROP_MAX_SLOTS:
g_value_set_int (value, mks_touchable_get_max_slots (self));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
mks_touchable_class_init (MksTouchableClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
MksDeviceClass *device_class = MKS_DEVICE_CLASS (klass);
device_class->setup = mks_touchable_setup;
object_class->dispose = mks_touchable_dispose;
object_class->get_property = mks_touchable_get_property;
/**
* MksTouchable:max-slots:
*
* The maximum number of slots.
*/
properties [PROP_MAX_SLOTS] =
g_param_spec_int ("max-slots", NULL, NULL,
0, G_MAXINT, 0,
(G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_properties (object_class, N_PROPS, properties);
}
static void
mks_touchable_init (MksTouchable *self)
{
}
static gboolean
check_touch (MksTouchable *self,
GError **error)
{
if (self->touch == NULL)
{
g_set_error_literal (error,
G_IO_ERROR,
G_IO_ERROR_NOT_CONNECTED,
"Not connected");
return FALSE;
}
return TRUE;
}
static void
mks_touchable_send_event_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
MksQemuTouch *touch = (MksQemuTouch *)object;
g_autoptr(GTask) task = user_data;
g_autoptr(GError) error = NULL;
MKS_ENTRY;
g_assert (MKS_QEMU_IS_TOUCH (touch));
g_assert (G_IS_ASYNC_RESULT (result));
g_assert (G_IS_TASK (task));
if (!mks_qemu_touch_call_send_event_finish (touch, result, &error))
g_task_return_error (task, g_steal_pointer (&error));
else
g_task_return_boolean (task, TRUE);
MKS_EXIT;
}
/**
* mks_touchable_send_event:
* @self: an #MksTouchable
* @num_slot: the slot number
* @x: the x absolute coordinate
* @y: the y absolute coordinate
* @cancellable: (nullable): a #GCancellable
* @callback: a #GAsyncReadyCallback to execute upon completion
* @user_data: closure data for @callback
*
* Send a touch event.
*/
void
mks_touchable_send_event (MksTouchable *self,
MksTouchEventKind kind,
guint64 num_slot,
double x,
double y,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_autoptr(GTask) task = NULL;
g_autoptr(GError) error = NULL;
MKS_ENTRY;
g_return_if_fail (MKS_IS_TOUCHABLE (self));
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_source_tag (task, mks_touchable_send_event);
if (!check_touch (self, &error))
g_task_return_error (task, g_steal_pointer (&error));
else
mks_qemu_touch_call_send_event (self->touch, kind,
num_slot, x, y,
cancellable,
mks_touchable_send_event_cb,
g_steal_pointer (&task));
MKS_EXIT;
}
/**
* mks_touchable_send_event_finish:
* @self: a `MksTouchable`
* @result: a #GAsyncResult provided to callback
* @error: a location for a #GError, or %NULL
*
* Completes a call to [method@Mks.Touchable.send_event].
*
* Returns: %TRUE if the operation completed successfully; otherwise %FALSE
* and @error is set.
*/
gboolean
mks_touchable_send_event_finish (MksTouchable *self,
GAsyncResult *result,
GError **error)
{
gboolean ret;
MKS_ENTRY;
g_return_val_if_fail (MKS_IS_TOUCHABLE (self), FALSE);
g_return_val_if_fail (g_task_is_valid (result, self), FALSE);
ret = g_task_propagate_boolean (G_TASK (result), error);
MKS_RETURN (ret);
}
/**
* mks_touchable_send_event_sync:
* @self: a `MksTouchable`
* @kind: the event kind
* @num_slot: the slot number
* @x: the x absolute coordinate
* @y: the y absolute coordinate
* @cancellable: (nullable): a #GCancellable
* @error: a location for a #GError, or %NULL
*
* Synchronously send a touch event.
*
* Returns: %TRUE if the operation was acknowledged by the QEMU instance;
* otherwise %FALSE and @error is set.
*/
gboolean
mks_touchable_send_event_sync (MksTouchable *self,
MksTouchEventKind kind,
guint64 num_slot,
double x,
double y,
GCancellable *cancellable,
GError **error)
{
gboolean ret;
MKS_ENTRY;
g_return_val_if_fail (MKS_IS_TOUCHABLE (self), FALSE);
g_return_val_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable), FALSE);
if (!check_touch (self, error))
MKS_RETURN (FALSE);
ret = mks_qemu_touch_call_send_event_sync (self->touch, kind,
num_slot, x, y,
cancellable, error);
MKS_RETURN (ret);
}
/**
* mks_touchable_get_max_slots:
* @self: A `MksTouchable`.
*
* Returns the maximum number of slots.
*/
int
mks_touchable_get_max_slots (MksTouchable *self)
{
g_return_val_if_fail (MKS_IS_TOUCHABLE (self), 0);
if (self->touch)
return mks_qemu_touch_get_max_slots (self->touch);
return 0;
}

88
lib/mks-touchable.h Normal file
View File

@ -0,0 +1,88 @@
/*
* mks-touchable.h
*
* Copyright 2023 Bilal Elmoussaoui <belmouss@redhat.com>
*
* 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.1 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 General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*/
#pragma once
#if !defined(MKS_INSIDE) && !defined(MKS_COMPILATION)
# error "Only <libmks.h> can be included directly."
#endif
#include <gio/gio.h>
#include "mks-types.h"
#include "mks-version-macros.h"
G_BEGIN_DECLS
#define MKS_TYPE_TOUCHABLE (mks_touchable_get_type ())
#define MKS_TOUCHABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MKS_TYPE_TOUCHABLE, MksTouchable))
#define MKS_TOUCHABLE_CONST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MKS_TYPE_TOUCHABLE, MksTouchable const))
#define MKS_TOUCHABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MKS_TYPE_TOUCHABLE, MksTouchableClass))
#define MKS_IS_TOUCHABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MKS_TYPE_TOUCHABLE))
#define MKS_IS_TOUCHABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MKS_TYPE_TOUCHABLE))
#define MKS_TOUCHABLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MKS_TYPE_TOUCHABLE, MksTouchableClass))
typedef struct _MksTouchableClass MksTouchableClass;
/**
* MksTouchEventKind:
* @MKS_TOUCH_EVENT_BEGIN: The touch event has just started.
* @MKS_TOUCH_EVENT_UPDATE: The touch event has been updated.
* @MKS_TOUCH_EVENT_END: The touch event has finished.
* @MKS_TOUCH_EVENT_CANCEL: The touch event has been canceled.
*
* The type of a touch event.
*/
typedef enum _MksTouchEventKind
{
MKS_TOUCH_EVENT_BEGIN = 0,
MKS_TOUCH_EVENT_UPDATE = 1,
MKS_TOUCH_EVENT_END = 2,
MKS_TOUCH_EVENT_CANCEL = 3,
} MksTouchEventKind;
MKS_AVAILABLE_IN_ALL
GType mks_touchable_get_type (void) G_GNUC_CONST;
MKS_AVAILABLE_IN_ALL
void mks_touchable_send_event (MksTouchable *self,
MksTouchEventKind kind,
guint64 num_slot,
double x,
double y,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data);
MKS_AVAILABLE_IN_ALL
gboolean mks_touchable_send_event_finish (MksTouchable *self,
GAsyncResult *result,
GError **error);
MKS_AVAILABLE_IN_ALL
gboolean mks_touchable_send_event_sync (MksTouchable *self,
MksTouchEventKind kind,
guint64 num_slot,
double x,
double y,
GCancellable *cancellable,
GError **error);
MKS_AVAILABLE_IN_ALL
int mks_touchable_get_max_slots (MksTouchable *self);
G_END_DECLS

1
lib/mks-types.h
View File

@ -36,5 +36,6 @@ typedef struct _MksScreen MksScreen;
typedef struct _MksSession MksSession;
typedef struct _MksScreenAttributes MksScreenAttributes;
typedef struct _MksSpeaker MksSpeaker;
typedef struct _MksTouchable MksTouchable;
G_END_DECLS

5
tools/mks-connect.c
View File

@ -53,6 +53,9 @@ print_device_info (MksDevice *device,
else if (MKS_IS_MOUSE (device))
g_print (", is-absolute=%u",
mks_mouse_get_is_absolute (MKS_MOUSE (device)));
else if (MKS_IS_TOUCHABLE (device))
g_print (", max-slots=%u",
mks_touchable_get_max_slots (MKS_TOUCHABLE (device)));
g_print (")\n");
if (MKS_IS_SCREEN (device))
@ -60,9 +63,11 @@ print_device_info (MksDevice *device,
MksScreen *screen = MKS_SCREEN (device);
MksKeyboard *keyboard = mks_screen_get_keyboard (screen);
MksMouse *mouse = mks_screen_get_mouse (screen);
MksTouchable *touchable = mks_screen_get_touchable (screen);
print_device_info (MKS_DEVICE (keyboard), depth+1);
print_device_info (MKS_DEVICE (mouse), depth+1);
print_device_info (MKS_DEVICE (touchable), depth+1);
}
}