From: Florian "sp1rit"​ Date: Sun, 8 May 2022 14:31:43 +0000 (+0200) Subject: gtk: gtkgesturestylus: implemented `stylus-only` property X-Git-Tag: archive/raspbian/4.12.3+ds-1+rpi1~1^2^2^2~22^2~9^2~39^2~2 X-Git-Url: https://dgit.raspbian.org/?a=commitdiff_plain;h=789778105d4bb4eb16b10291dffeac543090672a;p=gtk4.git gtk: gtkgesturestylus: implemented `stylus-only` property this allows setting a Gtk.GestureStylus to a state, where it can be used to handle non-stylus devices (e.g. mice). This might be useful for applications that handle stylus input, but want to allow falling back to a mice, if the user is unable to provide stylus input. --- diff --git a/gtk/gtkgesturestylus.c b/gtk/gtkgesturestylus.c index d10dfe1a05..8e187c2545 100644 --- a/gtk/gtkgesturestylus.c +++ b/gtk/gtkgesturestylus.c @@ -34,7 +34,16 @@ #include "gtkmain.h" #include "gtknative.h" -G_DEFINE_TYPE (GtkGestureStylus, gtk_gesture_stylus, GTK_TYPE_GESTURE_SINGLE) +typedef struct { + gboolean stylus_only; +} GtkGestureStylusPrivate; + +G_DEFINE_TYPE_WITH_PRIVATE (GtkGestureStylus, gtk_gesture_stylus, GTK_TYPE_GESTURE_SINGLE) + +enum { + PROP_STYLUS_ONLY = 1, + N_PROPERTIES +}; enum { PROXIMITY, @@ -44,20 +53,55 @@ enum { N_SIGNALS }; +static GParamSpec* obj_properties[N_PROPERTIES] = { NULL, }; static guint signals[N_SIGNALS] = { 0, }; +static void gtk_gesture_stylus_get_property (GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec) +{ + GtkGestureStylus* gesture = GTK_GESTURE_STYLUS(object); + + switch (prop_id) { + case PROP_STYLUS_ONLY: + g_value_set_boolean(value, gtk_gesture_stylus_get_stylus_only(gesture)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void gtk_gesture_stylus_set_property (GObject* object, + guint prop_id, + const GValue* value, + GParamSpec* pspec) +{ + GtkGestureStylus* gesture = GTK_GESTURE_STYLUS(object); + + switch (prop_id) { + case PROP_STYLUS_ONLY: + gtk_gesture_stylus_set_stylus_only(gesture, g_value_get_boolean(value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + static gboolean gtk_gesture_stylus_handle_event (GtkEventController *controller, GdkEvent *event, double x, double y) { + GtkGestureStylusPrivate* priv; GdkModifierType modifiers; guint n_signal; + priv = gtk_gesture_stylus_get_instance_private(GTK_GESTURE_STYLUS(controller)); GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_stylus_parent_class)->handle_event (controller, event, x, y); - if (!gdk_event_get_device_tool (event)) + if (!(priv->stylus_only || gdk_event_get_device_tool (event))) return FALSE; switch ((guint) gdk_event_get_event_type (event)) @@ -88,8 +132,25 @@ gtk_gesture_stylus_handle_event (GtkEventController *controller, static void gtk_gesture_stylus_class_init (GtkGestureStylusClass *klass) { + GObjectClass* object_class; GtkEventControllerClass *event_controller_class; + object_class = G_OBJECT_CLASS (klass); + object_class->get_property = gtk_gesture_stylus_get_property; + object_class->set_property = gtk_gesture_stylus_set_property; + + /** + * GtkGestureStylus:stylus-only: (attributes org.gtk.Property.get=gtk_gesture_stylus_get_stylus_only org.gtk.Property.set=gtk_gesture_stylus_set_stylus_only) + * + * If this gesture should exclusively react to stylus input devices. + */ + obj_properties[PROP_STYLUS_ONLY] = g_param_spec_boolean("stylus-only", + P_("Stylus only"), + P_("Should this gesture exclusively react to stylus input devices."), + TRUE, + G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_CONSTRUCT); + g_object_class_install_properties(object_class, N_PROPERTIES, obj_properties); + event_controller_class = GTK_EVENT_CONTROLLER_CLASS (klass); event_controller_class->handle_event = gtk_gesture_stylus_handle_event; @@ -177,6 +238,9 @@ gtk_gesture_stylus_class_init (GtkGestureStylusClass *klass) static void gtk_gesture_stylus_init (GtkGestureStylus *gesture) { + GtkGestureStylusPrivate* priv = gtk_gesture_stylus_get_instance_private(gesture); + + priv->stylus_only = TRUE; } /** @@ -193,6 +257,53 @@ gtk_gesture_stylus_new (void) NULL); } +/** + * gtk_gesture_stylus_get_stylus_only: (attributes org.gtk.Method.get_property=stylus-only) + * @gesture: A `GtkGestureStylus` + * + * gets the state of stylus-only, based on which the gesture will + * either exclusively signal events from stylus input devices or + * for any input devices (e.g. mice). + * + * Returns: The state of stylus-only set via [method@Gtk.GestureStylus.set_stylus_only] + */ +gboolean +gtk_gesture_stylus_get_stylus_only(GtkGestureStylus* gesture) { + GtkGestureStylusPrivate* priv; + + g_return_val_if_fail(GTK_IS_GESTURE_STYLUS(gesture), FALSE); + + priv = gtk_gesture_stylus_get_instance_private(gesture); + + return priv->stylus_only; +} + +/** + * gtk_gesture_stylus_set_stylus_only: (attributes org.gtk.Method.set_property=stylus-only) + * @gesture: A `GtkGestureStylus` + * @stylus_only: %TRUE if the gesture should process exclusivly handle events from styluses + * + * sets the state of stylus-only + * + * If true, the gesture will exclusivly handle events from stylus input deivces, + * otherwise it'll handle events from any pointing device. + */ +void +gtk_gesture_stylus_set_stylus_only(GtkGestureStylus* gesture, gboolean stylus_only) { + GtkGestureStylusPrivate* priv; + + g_return_if_fail(GTK_IS_GESTURE_STYLUS(gesture)); + + priv = gtk_gesture_stylus_get_instance_private(gesture); + + if (priv->stylus_only == stylus_only) + return; + + priv->stylus_only = stylus_only; + + g_object_notify_by_pspec (G_OBJECT (gesture), obj_properties[PROP_STYLUS_ONLY]); +} + /** * gtk_gesture_stylus_get_axis: * @gesture: a `GtkGestureStylus` diff --git a/gtk/gtkgesturestylus.h b/gtk/gtkgesturestylus.h index df31f5277a..4bd06128d9 100644 --- a/gtk/gtkgesturestylus.h +++ b/gtk/gtkgesturestylus.h @@ -43,6 +43,12 @@ GType gtk_gesture_stylus_get_type (void) G_GNUC_CONST; GDK_AVAILABLE_IN_ALL GtkGesture * gtk_gesture_stylus_new (void); +GDK_AVAILABLE_IN_4_8 +gboolean gtk_gesture_stylus_get_stylus_only (GtkGestureStylus* gesture); +GDK_AVAILABLE_IN_4_8 +void gtk_gesture_stylus_set_stylus_only (GtkGestureStylus* gesture, + gboolean stylus_only); + GDK_AVAILABLE_IN_ALL gboolean gtk_gesture_stylus_get_axis (GtkGestureStylus *gesture, GdkAxisUse axis,