External/libmks
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/libmks.git synced 2024-12-22 05:35:21 +00:00
Code Issues Packages Projects Releases Wiki Activity
main
libmks/lib/mks-display-picture.c

852 lines
27 KiB
C
Raw Permalink Normal View History

license: update sources to LGPLv2.1+ See merge request !25
2023-06-02 17:01:16 +00:00
/*
* mks-display-picture.c
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
*
* Copyright 2023 Christian Hergert <chergert@redhat.com>
*
license: update sources to LGPLv2.1+ See merge request !25
2023-06-02 17:01:16 +00:00
* 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.
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
*
license: update sources to LGPLv2.1+ See merge request !25
2023-06-02 17:01:16 +00:00
* 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.
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
Relicense as LGPLv2.1+
2023-06-01 11:04:35 +00:00
* SPDX-License-Identifier: LGPL-2.1-or-later
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
*/
#define G_LOG_DOMAIN "mks-display-picture"
#include "config.h"
#include "mks-display-picture-private.h"
#include "mks-keyboard.h"
#include "mks-mouse.h"
device: Implement the new touch interface
2023-06-15 11:48:55 +00:00
#include "mks-touchable.h"
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
#include "mks-util-private.h"
struct _MksDisplayPicture
{
GtkWidget parent_instance;
GSignalGroup *paintable_signals;
MksPaintable *paintable;
MksKeyboard *keyboard;
MksMouse *mouse;
device: Implement the new touch interface
2023-06-15 11:48:55 +00:00
MksTouchable *touchable;
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
double last_mouse_x;
double last_mouse_y;
};
enum {
PROP_0,
PROP_PAINTABLE,
PROP_KEYBOARD,
PROP_MOUSE,
device: Implement the new touch interface
2023-06-15 11:48:55 +00:00
PROP_TOUCHABLE,
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
N_PROPS
};
G_DEFINE_FINAL_TYPE (MksDisplayPicture, mks_display_picture, GTK_TYPE_WIDGET)
static GParamSpec *properties [N_PROPS];
static void
mks_display_picture_keyboard_press_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
MksKeyboard *keyboard = (MksKeyboard *)object;
g_autoptr(MksDisplayPicture) self = user_data;
g_autoptr(GError) error = NULL;
g_assert (MKS_IS_KEYBOARD (keyboard));
g_assert (G_IS_ASYNC_RESULT (result));
g_assert (MKS_IS_DISPLAY_PICTURE (self));
if (!mks_keyboard_press_finish (keyboard, result, &error))
misc: Replace some of g_warning usages with g_debug To avoid spamming the user's journald
2023-06-13 14:51:08 +00:00
g_debug ("Keyboard press failed: %s", error->message);
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
}
static void
mks_display_picture_keyboard_release_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
MksKeyboard *keyboard = (MksKeyboard *)object;
g_autoptr(MksDisplayPicture) self = user_data;
g_autoptr(GError) error = NULL;
g_assert (MKS_IS_KEYBOARD (keyboard));
g_assert (G_IS_ASYNC_RESULT (result));
g_assert (MKS_IS_DISPLAY_PICTURE (self));
if (!mks_keyboard_release_finish (keyboard, result, &error))
misc: Replace some of g_warning usages with g_debug To avoid spamming the user's journald
2023-06-13 14:51:08 +00:00
g_debug ("Keyboard release failed: %s", error->message);
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
}
static void
mks_display_picture_mouse_move_to_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
MksMouse *mouse = (MksMouse *)object;
g_autoptr(MksDisplayPicture) self = user_data;
g_autoptr(GError) error = NULL;
g_assert (MKS_IS_MOUSE (mouse));
g_assert (G_IS_ASYNC_RESULT (result));
g_assert (MKS_IS_DISPLAY_PICTURE (self));
if (!mks_mouse_move_to_finish (mouse, result, &error))
misc: Replace some of g_warning usages with g_debug To avoid spamming the user's journald
2023-06-13 14:51:08 +00:00
g_debug ("Failed move_to: %s", error->message);
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
}
static void
mks_display_picture_mouse_move_by_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
MksMouse *mouse = (MksMouse *)object;
g_autoptr(MksDisplayPicture) self = user_data;
g_autoptr(GError) error = NULL;
g_assert (MKS_IS_MOUSE (mouse));
g_assert (G_IS_ASYNC_RESULT (result));
g_assert (MKS_IS_DISPLAY_PICTURE (self));
if (!mks_mouse_move_by_finish (mouse, result, &error))
misc: Replace some of g_warning usages with g_debug To avoid spamming the user's journald
2023-06-13 14:51:08 +00:00
g_debug ("Failed move_by: %s", error->message);
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
}
device: Implement the new touch interface
2023-06-15 11:48:55 +00:00
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);
}
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
static void
mks_display_picture_translate_button (MksDisplayPicture *self,
int *button)
{
g_assert (MKS_IS_DISPLAY_PICTURE (self));
g_assert (button != NULL);
switch (*button)
{
case 1: *button = MKS_MOUSE_BUTTON_LEFT; break;
case 2: *button = MKS_MOUSE_BUTTON_MIDDLE; break;
case 3: *button = MKS_MOUSE_BUTTON_RIGHT; break;
case 8: *button = MKS_MOUSE_BUTTON_SIDE; break;
case 9: *button = MKS_MOUSE_BUTTON_EXTRA; break;
default: break;
}
}
static void
mks_display_picture_mouse_press_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
MksMouse *mouse = (MksMouse *)object;
g_autoptr(MksDisplayPicture) self = user_data;
g_autoptr(GError) error = NULL;
g_assert (MKS_IS_MOUSE (mouse));
g_assert (G_IS_ASYNC_RESULT (result));
g_assert (MKS_IS_DISPLAY_PICTURE (self));
if (!mks_mouse_press_finish (mouse, result, &error))
misc: Replace some of g_warning usages with g_debug To avoid spamming the user's journald
2023-06-13 14:51:08 +00:00
g_debug ("Mouse press failed: %s", error->message);
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
}
static void
mks_display_picture_mouse_release_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
MksMouse *mouse = (MksMouse *)object;
g_autoptr(MksDisplayPicture) self = user_data;
g_autoptr(GError) error = NULL;
g_assert (MKS_IS_MOUSE (mouse));
g_assert (G_IS_ASYNC_RESULT (result));
g_assert (MKS_IS_DISPLAY_PICTURE (self));
if (!mks_mouse_release_finish (mouse, result, &error))
misc: Replace some of g_warning usages with g_debug To avoid spamming the user's journald
2023-06-13 14:51:08 +00:00
g_debug ("Mouse release failed: %s", error->message);
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
}
display: Expose a helper for retriving guest position When running an Android VM with GL support, Android somehow enforces support for only touch events making it difficult to work with QEMU + Android for devolpement / demo purposes without a touch screen. This helper is useful for being able to emulate motion / click events as touch ones
2023-06-19 21:57:55 +00:00
gboolean
display-picture: Split guest absolute position into a helper Will be shared with touch events in the next commit
2023-06-15 11:47:20 +00:00
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;
}
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
static gboolean
mks_display_picture_legacy_event_cb (MksDisplayPicture *self,
GdkEvent *event,
GtkEventControllerLegacy *controller)
{
GdkPaintable *paintable;
GdkEventType event_type;
device: Implement the new touch interface
2023-06-15 11:48:55 +00:00
GdkEventSequence *sequence;
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
g_assert (MKS_IS_DISPLAY_PICTURE (self));
display-picture: Split guest absolute position into a helper Will be shared with touch events in the next commit
2023-06-15 11:47:20 +00:00
g_assert (GDK_IS_EVENT (event));
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
g_assert (GTK_IS_EVENT_CONTROLLER_LEGACY (controller));
device: Implement the new touch interface
2023-06-15 11:48:55 +00:00
if (self->keyboard == NULL || self->mouse == NULL || self->touchable == NULL || self->paintable == NULL)
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
return GDK_EVENT_PROPAGATE;
event_type = gdk_event_get_event_type (event);
paintable = GDK_PAINTABLE (self->paintable);
device: Implement the new touch interface
2023-06-15 11:48:55 +00:00
sequence = gdk_event_get_event_sequence (event);
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
switch ((int)event_type)
{
device: Implement the new touch interface
2023-06-15 11:48:55 +00:00
case GDK_TOUCH_BEGIN:
case GDK_TOUCH_UPDATE:
case GDK_TOUCH_CANCEL:
case GDK_TOUCH_END:
{
double guest_x, guest_y;
lib: use GLib numeric types I'm trying to be consistent and keep with GLib type definitions except for char/int/double/float.
2023-06-15 23:09:22 +00:00
guint64 num_slot = GPOINTER_TO_UINT (sequence);
device: Implement the new touch interface
2023-06-15 11:48:55 +00:00
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;
}
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
case GDK_MOTION_NOTIFY:
{
GdkSurface *surface = gdk_event_get_surface (event);
GtkNative *native = gtk_widget_get_native (GTK_WIDGET (self));
int guest_width = gdk_paintable_get_intrinsic_width (paintable);
int guest_height = gdk_paintable_get_intrinsic_height (paintable);
graphene_rect_t area;
double translate_x;
double translate_y;
g_assert (MKS_IS_MOUSE (self->mouse));
g_assert (GDK_IS_SURFACE (surface));
display-picture: remove deprecated allocation API usage
2023-05-17 20:48:21 +00:00
area = GRAPHENE_RECT_INIT (0, 0,
gtk_widget_get_width (GTK_WIDGET (self)),
gtk_widget_get_height (GTK_WIDGET (self)));
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
gtk_native_get_surface_transform (native, &translate_x, &translate_y);
if (mks_mouse_get_is_absolute (self->mouse))
{
display-picture: Split guest absolute position into a helper Will be shared with touch events in the next commit
2023-06-15 11:47:20 +00:00
double guest_x, guest_y;
if (mks_display_picture_event_get_guest_position (self, event, &guest_x, &guest_y))
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
{
mks_mouse_move_to (self->mouse,
guest_x,
guest_y,
NULL,
mks_display_picture_mouse_move_to_cb,
g_object_ref (self));
return GDK_EVENT_STOP;
}
}
else
{
double x, y;
if (gdk_event_get_axis (event, GDK_AXIS_X, &x) &&
gdk_event_get_axis (event, GDK_AXIS_Y, &y))
{
double delta_x = self->last_mouse_x - (x / area.size.width) * guest_width;
double delta_y = self->last_mouse_y - (y / area.size.height) * guest_height;
mks_mouse_move_by (self->mouse,
delta_x,
delta_y,
NULL,
mks_display_picture_mouse_move_by_cb,
g_object_ref (self));
return GDK_EVENT_STOP;
}
}
break;
}
case GDK_BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
{
int button = gdk_button_event_get_button (event);
g_assert (MKS_IS_MOUSE (self->mouse));
mks_display_picture_translate_button (self, &button);
if (event_type == GDK_BUTTON_PRESS)
mks_mouse_press (self->mouse,
button,
NULL,
mks_display_picture_mouse_press_cb,
g_object_ref (self));
else
mks_mouse_release (self->mouse,
button,
NULL,
mks_display_picture_mouse_release_cb,
g_object_ref (self));
return GDK_EVENT_STOP;
}
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
{
guint keycode = gdk_key_event_get_keycode (event);
display-picture: Fix keyval value
2023-04-03 13:31:33 +00:00
guint keyval = gdk_key_event_get_keyval (event);
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
guint qkeycode;
g_assert (MKS_IS_KEYBOARD (self->keyboard));
keyboard: Expose keycode translation helper Useful for exposing keyboard shortcuts triggers on the UI Similar to what Boxes does for Ctrl+Shift+F
2023-04-03 13:41:52 +00:00
mks_keyboard_translate (keyval, keycode, &qkeycode);
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
if (event_type == GDK_KEY_PRESS)
mks_keyboard_press (self->keyboard,
qkeycode,
NULL,
mks_display_picture_keyboard_press_cb,
g_object_ref (self));
else
mks_keyboard_release (self->keyboard,
qkeycode,
NULL,
mks_display_picture_keyboard_release_cb,
g_object_ref (self));
return GDK_EVENT_STOP;
}
case GDK_SCROLL:
{
GdkScrollDirection direction = gdk_scroll_event_get_direction (event);
gboolean inverted = mks_scroll_event_is_inverted (event);
int button = -1;
g_assert (MKS_IS_MOUSE (self->mouse));
switch (direction)
{
case GDK_SCROLL_UP:
button = MKS_MOUSE_BUTTON_WHEEL_UP;
break;
case GDK_SCROLL_DOWN:
button = MKS_MOUSE_BUTTON_WHEEL_DOWN;
break;
lib: use GDK_SCROLL_SMOOTH to enumlate wheel scroll It's really annoying when a touchpad doesn't work at all in a MKS session. So instead of doing nothing, at least try to send a wheel event so that some amount of scroll may occur. Eventually, we need a real touchpad D-Bus interface to deliver events.
2023-02-17 19:49:33 +00:00
case GDK_SCROLL_SMOOTH:
{
double delta_x;
double delta_y;
/*
* Currently there is no touchpad D-Bus interface to communicate
docs: Document most of the public APIs
2023-05-23 10:24:33 +00:00
* with QEMU. That is something we would very much want to have
lib: use GDK_SCROLL_SMOOTH to enumlate wheel scroll It's really annoying when a touchpad doesn't work at all in a MKS session. So instead of doing nothing, at least try to send a wheel event so that some amount of scroll may occur. Eventually, we need a real touchpad D-Bus interface to deliver events.
2023-02-17 19:49:33 +00:00
* in the future so that we can do this properly.
*
* For now, we just "emulate" scroll events by looking at direction
* and sending that across as wheel events. It's enough to be useful
* but far from what we would really want in the long run.
*/
gdk_scroll_event_get_deltas (event, &delta_x, &delta_y);
if (delta_y < 0)
button = MKS_MOUSE_BUTTON_WHEEL_DOWN;
else if (delta_y > 0)
button = MKS_MOUSE_BUTTON_WHEEL_UP;
break;
}
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
case GDK_SCROLL_LEFT:
case GDK_SCROLL_RIGHT:
default:
break;
}
if (button != -1)
{
if (inverted)
{
if (button == MKS_MOUSE_BUTTON_WHEEL_UP)
button = MKS_MOUSE_BUTTON_WHEEL_DOWN;
else if (button == MKS_MOUSE_BUTTON_WHEEL_DOWN)
button = MKS_MOUSE_BUTTON_WHEEL_UP;
}
mks_mouse_press (self->mouse,
button,
NULL,
mks_display_picture_mouse_press_cb,
g_object_ref (self));
return GDK_EVENT_STOP;
}
break;
}
default:
break;
}
return GDK_EVENT_PROPAGATE;
}
static void
mks_display_picture_invalidate_contents_cb (MksDisplayPicture *self,
MksPaintable *paintable)
{
g_assert (MKS_IS_DISPLAY_PICTURE (self));
g_assert (MKS_IS_PAINTABLE (paintable));
gtk_widget_queue_draw (GTK_WIDGET (self));
}
static void
mks_display_picture_invalidate_size_cb (MksDisplayPicture *self,
MksPaintable *paintable)
{
g_assert (MKS_IS_DISPLAY_PICTURE (self));
g_assert (MKS_IS_PAINTABLE (paintable));
gtk_widget_queue_resize (GTK_WIDGET (self));
}
static void
mks_display_picture_notify_cursor_cb (MksDisplayPicture *self,
GParamSpec *pspec,
MksPaintable *paintable)
{
GdkCursor *cursor;
g_assert (MKS_IS_DISPLAY_PICTURE (self));
g_assert (MKS_IS_PAINTABLE (paintable));
cursor = _mks_paintable_get_cursor (paintable);
gtk_widget_set_cursor (GTK_WIDGET (self), cursor);
}
static void
mks_display_picture_mouse_set_cb (MksDisplayPicture *self,
int x,
int y,
MksPaintable *paintable)
{
g_assert (MKS_IS_DISPLAY_PICTURE (self));
g_assert (MKS_IS_PAINTABLE (paintable));
self->last_mouse_x = x;
self->last_mouse_y = y;
}
static void
mks_display_picture_measure (GtkWidget *widget,
GtkOrientation orientation,
int for_size,
int *minimum,
int *natural,
int *minimum_baseline,
int *natural_baseline)
{
MksDisplayPicture *self = (MksDisplayPicture *)widget;
GdkPaintable *paintable;
display-picture: Don't compute min-width/min-height They are not useful for us as we would like the user to be able to shrink the picture. It is a leftover of migrating from GtkPicture
2023-04-13 13:12:44 +00:00
double nat_width, nat_height;
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
int default_width;
int default_height;
g_assert (MKS_IS_DISPLAY_PICTURE (self));
if (self->paintable == NULL || for_size == 0)
{
*minimum = 0;
*natural = 0;
return;
}
paintable = GDK_PAINTABLE (self->paintable);
default_width = gdk_paintable_get_intrinsic_width (paintable);
default_height = gdk_paintable_get_intrinsic_width (paintable);
if (default_width <= 0)
default_width = 640;
if (default_height <= 0)
default_height = 480;
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
gdk_paintable_compute_concrete_size (paintable,
0,
for_size < 0 ? 0 : for_size,
default_width, default_height,
&nat_width, &nat_height);
*minimum = 0;
*natural = ceil (nat_width);
}
else
{
gdk_paintable_compute_concrete_size (paintable,
for_size < 0 ? 0 : for_size,
0,
default_width, default_height,
&nat_width, &nat_height);
*minimum = 0;
*natural = ceil (nat_height);
}
}
static GtkSizeRequestMode
mks_display_picture_get_request_mode (GtkWidget *widget)
{
return GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;
}
static void
mks_display_picture_snapshot (GtkWidget *widget,
GtkSnapshot *snapshot)
{
MksDisplayPicture *self = (MksDisplayPicture *)widget;
if (self->paintable == NULL)
return;
gdk_paintable_snapshot (GDK_PAINTABLE (self->paintable),
snapshot,
display-picture: remove deprecated allocation API usage
2023-05-17 20:48:21 +00:00
gtk_widget_get_width (GTK_WIDGET (self)),
gtk_widget_get_height (GTK_WIDGET (self)));
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
}
static void
mks_display_picture_dispose (GObject *object)
{
MksDisplayPicture *self = (MksDisplayPicture *)object;
g_clear_object (&self->paintable);
g_clear_object (&self->keyboard);
g_clear_object (&self->mouse);
g_clear_object (&self->paintable_signals);
fix: Plug few Touchable related leaks
2023-08-23 08:11:49 +00:00
g_clear_object (&self->touchable);
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
G_OBJECT_CLASS (mks_display_picture_parent_class)->dispose (object);
}
static void
mks_display_picture_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
MksDisplayPicture *self = MKS_DISPLAY_PICTURE (object);
switch (prop_id)
{
case PROP_KEYBOARD:
g_value_set_object (value, mks_display_picture_get_keyboard (self));
break;
case PROP_MOUSE:
g_value_set_object (value, mks_display_picture_get_mouse (self));
break;
device: Implement the new touch interface
2023-06-15 11:48:55 +00:00
case PROP_TOUCHABLE:
g_value_set_object (value, mks_display_picture_get_touchable (self));
break;
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
case PROP_PAINTABLE:
g_value_set_object (value, mks_display_picture_get_paintable (self));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
mks_display_picture_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
MksDisplayPicture *self = MKS_DISPLAY_PICTURE (object);
switch (prop_id)
{
case PROP_KEYBOARD:
mks_display_picture_set_keyboard (self, g_value_get_object (value));
break;
case PROP_MOUSE:
mks_display_picture_set_mouse (self, g_value_get_object (value));
break;
device: Implement the new touch interface
2023-06-15 11:48:55 +00:00
case PROP_TOUCHABLE:
mks_display_picture_set_touchable (self, g_value_get_object (value));
break;
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
case PROP_PAINTABLE:
mks_display_picture_set_paintable (self, g_value_get_object (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
mks_display_picture_class_init (MksDisplayPictureClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
object_class->dispose = mks_display_picture_dispose;
object_class->get_property = mks_display_picture_get_property;
object_class->set_property = mks_display_picture_set_property;
widget_class->measure = mks_display_picture_measure;
widget_class->get_request_mode = mks_display_picture_get_request_mode;
widget_class->snapshot = mks_display_picture_snapshot;
properties[PROP_KEYBOARD] =
g_param_spec_object ("keyboard", NULL, NULL,
MKS_TYPE_KEYBOARD,
(G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS));
properties[PROP_MOUSE] =
g_param_spec_object ("mouse", NULL, NULL,
MKS_TYPE_MOUSE,
(G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS));
device: Implement the new touch interface
2023-06-15 11:48:55 +00:00
properties[PROP_TOUCHABLE] =
g_param_spec_object ("touchable", NULL, NULL,
MKS_TYPE_TOUCHABLE,
(G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS));
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
properties[PROP_PAINTABLE] =
g_param_spec_object ("paintable", NULL, NULL,
MKS_TYPE_PAINTABLE,
(G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS));
g_object_class_install_properties (object_class, N_PROPS, properties);
}
static void
mks_display_picture_init (MksDisplayPicture *self)
{
GtkEventController *controller;
display-picture: set cursor on init Set cursor to none (i.e., hide it) on init. Otherwise, in cases where the define_cursor signal is not received (e.g., atomic kms), there are two cursors painted on the Widget display. Signed-off-by: Albert Esteve <aesteve@redhat.com>
2023-05-24 07:46:28 +00:00
g_autoptr(GdkCursor) gdk_cursor = gdk_cursor_new_from_name ("none", NULL);
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
controller = gtk_event_controller_legacy_new ();
g_signal_connect_object (controller,
"event",
G_CALLBACK (mks_display_picture_legacy_event_cb),
self,
G_CONNECT_SWAPPED);
gtk_event_controller_set_propagation_phase (controller, GTK_PHASE_CAPTURE);
gtk_widget_add_controller (GTK_WIDGET (self), controller);
self->paintable_signals = g_signal_group_new (MKS_TYPE_PAINTABLE);
g_signal_group_connect_object (self->paintable_signals,
"invalidate-contents",
G_CALLBACK (mks_display_picture_invalidate_contents_cb),
self,
G_CONNECT_SWAPPED);
g_signal_group_connect_object (self->paintable_signals,
"invalidate-size",
G_CALLBACK (mks_display_picture_invalidate_size_cb),
self,
G_CONNECT_SWAPPED);
g_signal_group_connect_object (self->paintable_signals,
"notify::cursor",
G_CALLBACK (mks_display_picture_notify_cursor_cb),
self,
G_CONNECT_SWAPPED);
g_signal_group_connect_object (self->paintable_signals,
"mouse-set",
G_CALLBACK (mks_display_picture_mouse_set_cb),
self,
G_CONNECT_SWAPPED);
display-picture: set cursor on init Set cursor to none (i.e., hide it) on init. Otherwise, in cases where the define_cursor signal is not received (e.g., atomic kms), there are two cursors painted on the Widget display. Signed-off-by: Albert Esteve <aesteve@redhat.com>
2023-05-24 07:46:28 +00:00
gtk_widget_set_cursor (GTK_WIDGET (self), gdk_cursor);
lib: add MksDisplayPicture This is a child widget to the MksDisplay which contains just the paintable region of the remote screen. Doing so allows us to avoid having to handle crossing events carefully for things like cursors. Instead, now the MksDisplay calculates the area for the picture and allocates it there. The MksDisplayPicture will always snapshot the paintable using the full area it has been allocated. Event processing can also largely move into the Picture widget which simplifies bounds checking.
2023-02-17 19:40:34 +00:00
gtk_widget_set_focusable (GTK_WIDGET (self), TRUE);
}
GtkWidget *
mks_display_picture_new (void)
{
return g_object_new (MKS_TYPE_DISPLAY_PICTURE, NULL);
}
MksPaintable *
mks_display_picture_get_paintable (MksDisplayPicture *self)
{
g_return_val_if_fail (MKS_IS_DISPLAY_PICTURE (self), NULL);
return self->paintable;
}
void
mks_display_picture_set_paintable (MksDisplayPicture *self,
MksPaintable *paintable)
{
g_return_if_fail (MKS_IS_DISPLAY_PICTURE (self));
g_return_if_fail (!paintable || MKS_IS_PAINTABLE (paintable));
if (g_set_object (&self->paintable, paintable))
{
g_signal_group_set_target (self->paintable_signals, paintable);
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_PAINTABLE]);
gtk_widget_queue_resize (GTK_WIDGET (self));
}
}
MksMouse *
mks_display_picture_get_mouse (MksDisplayPicture *self)
{
g_return_val_if_fail (MKS_IS_DISPLAY_PICTURE (self), NULL);
return self->mouse;
}
void
mks_display_picture_set_mouse (MksDisplayPicture *self,
MksMouse *mouse)
{
g_return_if_fail (MKS_IS_DISPLAY_PICTURE (self));
g_return_if_fail (!mouse || MKS_IS_MOUSE (mouse));
if (g_set_object (&self->mouse, mouse))
g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_MOUSE]);
}
MksKeyboard *
mks_display_picture_get_keyboard (MksDisplayPicture *self)
{
g_return_val_if_fail (MKS_IS_DISPLAY_PICTURE (self), NULL);
return self->keyboard;
}
void
mks_display_picture_set_keyboard (MksDisplayPicture *self,
MksKeyboard *keyboard)
{
g_return_if_fail (MKS_IS_DISPLAY_PICTURE (self));
g_return_if_fail (!keyboard || MKS_IS_KEYBOARD (keyboard));
if (g_set_object (&self->keyboard, keyboard))
g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_KEYBOARD]);
}
device: Implement the new touch interface
2023-06-15 11:48:55 +00:00
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]);
}
Reference in New Issue Copy Permalink