[gtk+/wip/wayland-tablet-v2: 11/19] gtk: Add GtkPadController



commit 4c4be5f16c00be08036fcc107a509fb8f2e41551
Author: Carlos Garnacho <carlosg gnome org>
Date:   Thu Aug 4 19:22:34 2016 +0200

    gtk: Add GtkPadController
    
    This GdkEventController is a helper object to handle pad events,
    it allows setting a mapping to action names, to be triggered in
    the given action group.
    
    In order to help on places where advanced mapping/configurability
    of pad features is not desirable, this controller also allows
    passing a NULL pad device, meaning it will listen on all pads,
    and/or passing -1 on mode/index, so an action applies to all
    modes/features (eg. strips/rings).

 gtk/Makefile.am        |    2 +
 gtk/gtk.h              |    1 +
 gtk/gtkpadcontroller.c |  369 ++++++++++++++++++++++++++++++++++++++++++++++++
 gtk/gtkpadcontroller.h |   82 +++++++++++
 4 files changed, 454 insertions(+), 0 deletions(-)
---
diff --git a/gtk/Makefile.am b/gtk/Makefile.am
index ed6c224..3b76b82 100644
--- a/gtk/Makefile.am
+++ b/gtk/Makefile.am
@@ -250,6 +250,7 @@ gtk_public_h_sources =              \
        gtkoffscreenwindow.h    \
        gtkorientable.h         \
        gtkoverlay.h            \
+       gtkpadcontroller.h      \
        gtkpagesetup.h          \
        gtkpaned.h              \
        gtkpapersize.h          \
@@ -829,6 +830,7 @@ gtk_base_c_sources =                \
        gtkoffscreenwindow.c    \
        gtkorientable.c         \
        gtkoverlay.c            \
+       gtkpadcontroller.c      \
        gtkpagesetup.c          \
        gtkpaned.c              \
        gtkpango.c              \
diff --git a/gtk/gtk.h b/gtk/gtk.h
index c818f32..7b901e1 100644
--- a/gtk/gtk.h
+++ b/gtk/gtk.h
@@ -152,6 +152,7 @@
 #include <gtk/gtkoffscreenwindow.h>
 #include <gtk/gtkorientable.h>
 #include <gtk/gtkoverlay.h>
+#include <gtk/gtkpadcontroller.h>
 #include <gtk/gtkpagesetup.h>
 #include <gtk/gtkpapersize.h>
 #include <gtk/gtkpaned.h>
diff --git a/gtk/gtkpadcontroller.c b/gtk/gtkpadcontroller.c
new file mode 100644
index 0000000..d104b38
--- /dev/null
+++ b/gtk/gtkpadcontroller.c
@@ -0,0 +1,369 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2016, Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author(s): Carlos Garnacho <carlosg gnome org>
+ */
+
+#include "config.h"
+
+#include "gtkeventcontrollerprivate.h"
+#include "gtkpadcontroller.h"
+#include "gtkwindow.h"
+#include "gtkprivate.h"
+#include "gtkintl.h"
+
+#ifdef GDK_WINDOWING_WAYLAND
+#include <gdk/wayland/gdkwayland.h>
+#endif
+
+struct _GtkPadController {
+  GtkEventController parent_instance;
+  GActionGroup *action_group;
+  GdkDevice *pad;
+
+  GList *entries;
+};
+
+struct _GtkPadControllerClass {
+  GtkEventControllerClass parent_class;
+};
+
+enum {
+  PROP_0,
+  PROP_ACTION_GROUP,
+  PROP_PAD,
+  N_PROPS
+};
+
+static GParamSpec *pspecs[N_PROPS] = { NULL };
+
+G_DEFINE_TYPE (GtkPadController, gtk_pad_controller, GTK_TYPE_EVENT_CONTROLLER)
+
+static GtkPadActionEntry *
+gtk_pad_action_entry_copy (const GtkPadActionEntry *entry)
+{
+  GtkPadActionEntry *copy;
+
+  copy = g_slice_new0 (GtkPadActionEntry);
+  *copy = *entry;
+  copy->label = g_strdup (entry->label);
+  copy->action_name = g_strdup (entry->action_name);
+
+  return copy;
+}
+
+static void
+gtk_pad_action_entry_free (GtkPadActionEntry *entry)
+{
+  g_free (entry->label);
+  g_free (entry->action_name);
+  g_slice_free (GtkPadActionEntry, entry);
+}
+
+static const GtkPadActionEntry *
+gtk_pad_action_find_match (GtkPadController *controller,
+                           GtkPadActionType  type,
+                           gint              index,
+                           gint              mode)
+{
+  GList *l;
+
+  for (l = controller->entries; l; l = l->next)
+    {
+      GtkPadActionEntry *entry = l->data;
+      gboolean match_index = FALSE, match_mode = FALSE;
+
+      if (entry->type != type)
+        continue;
+
+      match_index = entry->index < 0 || entry->index == index;
+      match_mode = entry->mode < 0 || entry->mode == mode;
+
+      if (match_index && match_mode)
+        return entry;
+    }
+
+  return NULL;
+}
+
+static void
+gtk_pad_controller_activate_action (GtkPadController        *controller,
+                                    const GtkPadActionEntry *entry)
+{
+  g_action_group_activate_action (controller->action_group,
+                                  entry->action_name,
+                                  NULL);
+}
+
+static void
+gtk_pad_controller_handle_mode_switch (GtkPadController *controller,
+                                       GdkDevice        *pad,
+                                       guint             group,
+                                       guint             mode)
+{
+}
+
+static gboolean
+gtk_pad_controller_filter_event (GtkEventController *controller,
+                                 const GdkEvent     *event)
+{
+  GtkPadController *pad_controller = GTK_PAD_CONTROLLER (controller);
+
+  if (event->type != GDK_PAD_BUTTON_PRESS &&
+      event->type != GDK_PAD_BUTTON_RELEASE &&
+      event->type != GDK_PAD_RING &&
+      event->type != GDK_PAD_STRIP &&
+      event->type != GDK_PAD_GROUP_MODE)
+    return TRUE;
+
+  if (pad_controller->pad &&
+      gdk_event_get_source_device (event) != pad_controller->pad)
+    return TRUE;
+
+  return FALSE;
+}
+
+static gboolean
+gtk_pad_controller_handle_event (GtkEventController *controller,
+                                 const GdkEvent     *event)
+{
+  GtkPadController *pad_controller = GTK_PAD_CONTROLLER (controller);
+  const GtkPadActionEntry *entry;
+  GtkPadActionType type;
+  gint index, mode;
+
+  if (event->type == GDK_PAD_GROUP_MODE)
+    {
+      gtk_pad_controller_handle_mode_switch (pad_controller,
+                                             gdk_event_get_source_device (event),
+                                             event->pad_group_mode.group,
+                                             event->pad_group_mode.mode);
+      return GDK_EVENT_PROPAGATE;
+    }
+
+  switch (event->type)
+    {
+    case GDK_PAD_BUTTON_PRESS:
+      type = GTK_PAD_ACTION_BUTTON;
+      index = event->pad_button.button;
+      mode = event->pad_button.mode;
+      break;
+    case GDK_PAD_RING:
+    case GDK_PAD_STRIP:
+      type = event->type == GDK_PAD_RING ?
+        GTK_PAD_ACTION_RING : GTK_PAD_ACTION_STRIP;
+      index = event->pad_axis.index;
+      mode = event->pad_axis.mode;
+      break;
+    default:
+      return GDK_EVENT_PROPAGATE;
+    }
+
+  entry = gtk_pad_action_find_match (pad_controller,
+                                     type, index, mode);
+  if (!entry)
+    return GDK_EVENT_PROPAGATE;
+
+  gtk_pad_controller_activate_action (pad_controller, entry);
+
+  return GDK_EVENT_STOP;
+}
+
+static void
+gtk_pad_controller_set_pad (GtkPadController *controller,
+                            GdkDevice        *pad)
+{
+  g_return_if_fail (!pad || GDK_IS_DEVICE (pad));
+  g_return_if_fail (!pad || gdk_device_get_source (pad) == GDK_SOURCE_TABLET_PAD);
+
+  g_set_object (&controller->pad, pad);
+}
+
+static void
+gtk_pad_controller_set_property (GObject      *object,
+                                 guint         prop_id,
+                                 const GValue *value,
+                                 GParamSpec   *pspec)
+{
+  GtkPadController *controller = GTK_PAD_CONTROLLER (object);
+
+  switch (prop_id)
+    {
+    case PROP_ACTION_GROUP:
+      controller->action_group = g_value_dup_object (value);
+      break;
+    case PROP_PAD:
+      gtk_pad_controller_set_pad (controller, g_value_get_object (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static void
+gtk_pad_controller_get_property (GObject    *object,
+                                 guint       prop_id,
+                                 GValue     *value,
+                                 GParamSpec *pspec)
+{
+  GtkPadController *controller = GTK_PAD_CONTROLLER (object);
+
+  switch (prop_id)
+    {
+    case PROP_ACTION_GROUP:
+      g_value_set_object (value, controller->action_group);
+      break;
+    case PROP_PAD:
+      g_value_set_object (value, controller->pad);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static void
+gtk_pad_controller_dispose (GObject *object)
+{
+  GtkPadController *controller = GTK_PAD_CONTROLLER (object);
+
+  g_clear_object (&controller->action_group);
+  g_clear_object (&controller->pad);
+
+  G_OBJECT_CLASS (gtk_pad_controller_parent_class)->dispose (object);
+}
+
+static void
+gtk_pad_controller_finalize (GObject *object)
+{
+  GtkPadController *controller = GTK_PAD_CONTROLLER (object);
+
+  g_list_free_full (controller->entries, (GDestroyNotify) gtk_pad_action_entry_free);
+
+  G_OBJECT_CLASS (gtk_pad_controller_parent_class)->finalize (object);
+}
+
+static void
+gtk_pad_controller_class_init (GtkPadControllerClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GtkEventControllerClass *controller_class = GTK_EVENT_CONTROLLER_CLASS (klass);
+
+  controller_class->filter_event = gtk_pad_controller_filter_event;
+  controller_class->handle_event = gtk_pad_controller_handle_event;
+
+  object_class->set_property = gtk_pad_controller_set_property;
+  object_class->get_property = gtk_pad_controller_get_property;
+  object_class->dispose = gtk_pad_controller_dispose;
+  object_class->finalize = gtk_pad_controller_finalize;
+
+  pspecs[PROP_ACTION_GROUP] =
+    g_param_spec_object ("action-group",
+                         P_("Action group"),
+                         P_("Action group to launch actions from"),
+                         G_TYPE_ACTION_GROUP,
+                         GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+  pspecs[PROP_PAD] =
+    g_param_spec_object ("pad",
+                         P_("Pad device"),
+                         P_("Pad device to control"),
+                         GDK_TYPE_DEVICE,
+                         GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+
+  g_object_class_install_properties (object_class, N_PROPS, pspecs);
+}
+
+static void
+gtk_pad_controller_init (GtkPadController *controller)
+{
+}
+
+GtkPadController *
+gtk_pad_controller_new (GtkWindow    *window,
+                        GActionGroup *group,
+                        GdkDevice    *pad)
+{
+  g_return_val_if_fail (GTK_IS_WINDOW (window), NULL);
+  g_return_val_if_fail (G_IS_ACTION_GROUP (group), NULL);
+  g_return_val_if_fail (!pad || GDK_IS_DEVICE (pad), NULL);
+  g_return_val_if_fail (!pad || gdk_device_get_source (pad) == GDK_SOURCE_TABLET_PAD, NULL);
+
+  return g_object_new (GTK_TYPE_PAD_CONTROLLER,
+                       "propagation-phase", GTK_PHASE_CAPTURE,
+                       "widget", window,
+                       "action-group", group,
+                       "pad", pad,
+                       NULL);
+}
+
+static gint
+entry_compare_func (gconstpointer a,
+                    gconstpointer b)
+{
+  const GtkPadActionEntry *entry1 = a, *entry2 = b;
+
+  if (entry1->mode > entry2->mode)
+    return -1;
+  else if (entry1->mode < entry2->mode)
+    return 1;
+  else if (entry1->index > entry2->index)
+    return -1;
+  else if (entry1->index < entry2->index)
+    return 1;
+
+  return 0;
+}
+
+static void
+gtk_pad_controller_add_entry (GtkPadController        *controller,
+                              const GtkPadActionEntry *entry)
+{
+  GtkPadActionEntry *copy;
+
+  copy = gtk_pad_action_entry_copy (entry);
+  controller->entries = g_list_insert_sorted (controller->entries, copy,
+                                              (GCompareFunc) entry_compare_func);
+}
+
+void
+gtk_pad_controller_set_action_entries (GtkPadController        *controller,
+                                       const GtkPadActionEntry *entries,
+                                       gint                     n_entries)
+{
+  gint i;
+
+  g_return_if_fail (GTK_IS_PAD_CONTROLLER (controller));
+  g_return_if_fail (entries != NULL);
+
+  for (i = 0; i < n_entries; i++)
+    gtk_pad_controller_add_entry (controller, &entries[i]);
+}
+
+void
+gtk_pad_controller_set_action (GtkPadController *controller,
+                               GtkPadActionType  type,
+                               gint              index,
+                               gint              mode,
+                               const gchar      *label,
+                               const gchar      *action_name)
+{
+  GtkPadActionEntry entry = { type, index, mode,
+                              (gchar *) label, (gchar *) action_name };
+
+  g_return_if_fail (GTK_IS_PAD_CONTROLLER (controller));
+  g_return_if_fail (type <= GTK_PAD_ACTION_RING);
+
+  gtk_pad_controller_add_entry (controller, &entry);
+}
diff --git a/gtk/gtkpadcontroller.h b/gtk/gtkpadcontroller.h
new file mode 100644
index 0000000..9939928
--- /dev/null
+++ b/gtk/gtkpadcontroller.h
@@ -0,0 +1,82 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2016, Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author(s): Carlos Garnacho <carlosg gnome org>
+ */
+
+#ifndef __GTK_PAD_CONTROLLER_H__
+#define __GTK_PAD_CONTROLLER_H__
+
+#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
+#include <gdk/gdk.h>
+#include <gtk/gtkeventcontroller.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_PAD_CONTROLLER         (gtk_pad_controller_get_type ())
+#define GTK_PAD_CONTROLLER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_PAD_CONTROLLER, 
GtkPadController))
+#define GTK_PAD_CONTROLLER_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_PAD_CONTROLLER, 
GtkPadControllerClass))
+#define GTK_IS_PAD_CONTROLLER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_PAD_CONTROLLER))
+#define GTK_IS_PAD_CONTROLLER_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_PAD_CONTROLLER))
+#define GTK_PAD_CONTROLLER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_PAD_CONTROLLER, 
GtkPadControllerClass))
+
+typedef struct _GtkPadController GtkPadController;
+typedef struct _GtkPadControllerClass GtkPadControllerClass;
+typedef struct _GtkPadActionEntry GtkPadActionEntry;
+
+typedef enum {
+  GTK_PAD_ACTION_BUTTON,
+  GTK_PAD_ACTION_RING,
+  GTK_PAD_ACTION_STRIP
+} GtkPadActionType;
+
+struct _GtkPadActionEntry {
+  GtkPadActionType type;
+  gint index;
+  gint mode;
+  gchar *label;
+  gchar *action_name;
+};
+
+GDK_AVAILABLE_IN_3_22
+GType gtk_pad_controller_get_type           (void) G_GNUC_CONST;
+
+GDK_AVAILABLE_IN_3_22
+GtkPadController *gtk_pad_controller_new    (GtkWindow        *window,
+                                             GActionGroup     *group,
+                                             GdkDevice        *pad);
+
+GDK_AVAILABLE_IN_3_22
+void  gtk_pad_controller_set_action_group   (GtkPadController *controller,
+                                             GActionGroup     *group);
+GDK_AVAILABLE_IN_3_22
+void  gtk_pad_controller_set_action_entries (GtkPadController        *controller,
+                                             const GtkPadActionEntry *entries,
+                                             gint                     n_entries);
+GDK_AVAILABLE_IN_3_22
+void  gtk_pad_controller_set_action         (GtkPadController *controller,
+                                             GtkPadActionType  type,
+                                             gint              index,
+                                             gint              mode,
+                                             const gchar      *label,
+                                             const gchar      *action_name);
+
+G_END_DECLS
+
+#endif /* __GTK_PAD_CONTROLLER_H__ */


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]