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).

https://bugzilla.gnome.org/show_bug.cgi?id=770026

docs/reference/gtk/gtk-docs.sgml

@@ -299,7 +299,7 @@
     </chapter>
 
     <chapter id="Gestures">
-      <title>Gestures</title>
+      <title>Gestures and event handling</title>
       <xi:include href="xml/gtkeventcontroller.xml" />
       <xi:include href="xml/gtkgesture.xml" />
       <xi:include href="xml/gtkgesturesingle.xml" />
@@ -310,6 +310,7 @@
       <xi:include href="xml/gtkgestureswipe.xml" />
       <xi:include href="xml/gtkgesturerotate.xml" />
       <xi:include href="xml/gtkgesturezoom.xml" />
+      <xi:include href="xml/gtkpadcontroller.xml" />
     </chapter>
 
     <chapter id="DeprecatedObjects">

docs/reference/gtk/gtk3-sections.txt

@@ -8450,6 +8450,28 @@ GTK_GESTURE_ZOOM_GET_CLASS
 gtk_gesture_zoom_get_type
 </SECTION>
 
+<SECTION>
+<FILE>gtkpadcontroller</FILE>
+<TITLE>GtkPadController</TITLE>
+GtkPadController
+gtk_pad_controller_new
+gtk_pad_controller_set_action_entries
+gtk_pad_controller_set_action
+GtkPadActionType
+GtkPadActionEntry
+
+<SUBSECTION Standard>
+GTK_TYPE_PAD_CONTROLLER
+GTK_PAD_CONTROLLER
+GTK_PAD_CONTROLLER_CLASS
+GTK_IS_PAD_CONTROLLER
+GTK_IS_PAD_CONTROLLER_CLASS
+GTK_PAD_CONTROLLER_GET_CLASS
+
+<SUBSECTION Private>
+gtk_pad_controller_get_type
+</SECTION>
+
 <SECTION>
 <FILE>gtkstacksidebar</FILE>
 GtkStackSidebar

docs/reference/gtk/gtk3.types.in

@@ -133,6 +133,7 @@ gtk_numerable_icon_get_type
 gtk_offscreen_window_get_type
 gtk_orientable_get_type
 gtk_overlay_get_type
+gtk_pad_controller_get_type
 gtk_page_setup_get_type
 @DISABLE_ON_W32@gtk_page_setup_unix_dialog_get_type
 gtk_paned_get_type

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		\

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>

gtk/gtkpadcontroller.c

@@ -0,0 +1,467 @@
+/* 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>
+ */
+
+/**
+ * SECTION:gtkpadcontroller
+ * @Short_description: Controller for drawing tablet pads
+ * @Title: GtkPadController
+ * @See_also: #GtkEventController, #GdkDevicePad
+ *
+ * #GtkPadController is an event controller for the pads found in drawing
+ * tablets (The collection of buttons and tactile sensors often found around
+ * the stylus-sensitive area).
+ *
+ * These buttons and sensors have no implicit meaning, and by default they
+ * perform no action, this event controller is provided to map those to
+ * #GAction objects, thus letting the application give those a more semantic
+ * meaning.
+ *
+ * Buttons and sensors are not constrained to triggering a single action, some
+ * %GDK_SOURCE_TABLET_PAD devices feature multiple "modes", all these input
+ * elements have one current mode, which may determine the final action
+ * being triggered. Pad devices often divide buttons and sensors into groups,
+ * all elements in a group share the same current mode, but different groups
+ * may have different modes. See gdk_device_pad_get_n_groups() and
+ * gdk_device_pad_get_group_n_modes().
+ *
+ * Each of the actions that a given button/strip/ring performs for a given
+ * mode is defined by #GtkPadActionEntry, it contains an action name that
+ * will be looked up in the given #GActionGroup and activated whenever the
+ * specified input element and mode are triggered.
+ *
+ * A simple example of #GtkPadController usage, assigning button 1 in all
+ * modes and pad devices to an "invert-selection" action:
+ * |[
+ *   GtkPadActionEntry *pad_actions[] = {
+ *     { GTK_PAD_ACTION_BUTTON, 1, -1, "Invert selection", "pad-actions.invert-selection" },
+ *     …
+ *   };
+ *
+ *   …
+ *   action_group = g_simple_action_group_new ();
+ *   action = g_simple_action_new ("pad-actions.invert-selection", NULL);
+ *   g_signal_connect (action, "activate", on_invert_selection_activated, NULL);
+ *   g_action_map_add_action (G_ACTION_MAP (action_group), action);
+ *   …
+ *   pad_controller = gtk_pad_controller_new (window, action_group, NULL);
+ * ]|
+ */
+
+#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)
+{
+}
+
+/**
+ * gtk_pad_controller_new:
+ * @window: a #GtkWindow
+ * @group: #GActionGroup to trigger actions from
+ * @pad: (nullable): A %GDK_SOURCE_TABLET_PAD device, or %NULL to handle all pads
+ *
+ * Creates a new #GtkPadController that will associate events from @pad to
+ * actions. A %NULL pad may be provided so the controller manages all pad devices
+ * generically, it is discouraged to mix #GtkPadController objects with %NULL
+ * and non-%NULL @pad argument on the same @window, as execution order is not
+ * guaranteed.
+ *
+ * The #GtkPadController is created with no mapped actions. In order to map pad
+ * events to actions, use gtk_pad_controller_set_action_entries() or
+ * gtk_pad_controller_set_action().
+ *
+ * Returns: A newly created #GtkPadController
+ *
+ * Since: 3.22
+ **/
+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);
+}
+
+/**
+ * gtk_pad_controller_set_action_entries:
+ * @controller: a #GtkPadController
+ * @entries: (array length=n_entries): the action entries to set on @controller
+ * @n_entries: the number of elements in @entries
+ *
+ * This is a convenience function to add a group of action entries on
+ * @controller. See #GtkPadActionEntry and gtk_pad_controller_set_action().
+ *
+ * Since: 3.22
+ **/
+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]);
+}
+
+/**
+ * gtk_pad_controller_set_action:
+ * @controller: a #GtkPadController
+ * @type: the type of pad feature that will trigger this action
+ * @index: the 0-indexed button/ring/strip number that will trigger this action
+ * @mode: the mode that will trigger this action, or -1 for all modes.
+ * @label: Human readable description of this action, this string should
+ *   be deemed user-visible.
+ * @action_name: action name that will be activated in the #GActionGroup
+ *
+ * Adds an individual action to @controller. This action will only be activated
+ * if the given button/ring/strip number in @index is interacted while
+ * the current mode is @mode. -1 may be used for simple cases, so the action
+ * is triggered on all modes.
+ *
+ * The given @label should be considered user-visible, so internationalization
+ * rules apply. Some windowing systems may be able to use those for user
+ * feedback.
+ *
+ * Since: 3.22
+ **/
+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);
+}

gtk/gtkpadcontroller.h

@@ -0,0 +1,99 @@
+/* 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;
+
+/**
+ * GtkPadActionType:
+ * @GTK_PAD_ACTION_BUTTON: Action is triggered by a pad button
+ * @GTK_PAD_ACTION_RING: Action is triggered by a pad ring
+ * @GTK_PAD_ACTION_STRIP: Action is triggered by a pad strip
+ *
+ * The type of a pad action.
+ */
+typedef enum {
+  GTK_PAD_ACTION_BUTTON,
+  GTK_PAD_ACTION_RING,
+  GTK_PAD_ACTION_STRIP
+} GtkPadActionType;
+
+/**
+ * GtkPadActionEntry:
+ * @type: the type of pad feature that will trigger this action entry.
+ * @index: the 0-indexed button/ring/strip number that will trigger this action
+ *   entry.
+ * @mode: the mode that will trigger this action entry, or -1 for all modes.
+ * @label: Human readable description of this action entry, this string should
+ *   be deemed user-visible.
+ * @action_name: action name that will be activated in the #GActionGroup.
+ *
+ * Struct defining a pad action entry.
+ */
+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_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__ */