[gtk+/wip/events: 21/25] API: gtk: Add GtkGesture
- From: Benjamin Otte <otte src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gtk+/wip/events: 21/25] API: gtk: Add GtkGesture
- Date: Wed, 14 Mar 2012 18:43:31 +0000 (UTC)
commit b469025153d7ff4dc2b802752d5f847244067cc8
Author: Benjamin Otte <otte redhat com>
Date: Tue Mar 13 21:38:55 2012 +0100
API: gtk: Add GtkGesture
GtkGesture is a GtkEventTracker that knows about sequences and sends
information about them.
gtk/Makefile.am | 6 +
gtk/gtk.h | 3 +
gtk/gtkgesture.c | 371 ++++++++++++++++++++++++++++++++++++++++++++
gtk/gtkgesture.h | 89 +++++++++++
gtk/gtkgesturerecognizer.c | 60 +++++++
gtk/gtkgesturerecognizer.h | 60 +++++++
6 files changed, 589 insertions(+), 0 deletions(-)
---
diff --git a/gtk/Makefile.am b/gtk/Makefile.am
index b29f6cd..8ebb37b 100644
--- a/gtk/Makefile.am
+++ b/gtk/Makefile.am
@@ -251,6 +251,8 @@ gtk_public_h_sources = \
gtkfontchooserdialog.h \
gtkfontchooserwidget.h \
gtkframe.h \
+ gtkgesture.h \
+ gtkgesturerecognizer.h \
gtkgradient.h \
gtkgrid.h \
gtkiconfactory.h \
@@ -317,6 +319,7 @@ gtk_public_h_sources = \
gtkseparator.h \
gtkseparatormenuitem.h \
gtkseparatortoolitem.h \
+ gtksequence.h \
gtksettings.h \
gtkshow.h \
gtksizegroup.h \
@@ -672,6 +675,8 @@ gtk_base_c_sources = \
gtkfontchooserutils.c \
gtkfontchooserwidget.c \
gtkframe.c \
+ gtkgesture.c \
+ gtkgesturerecognizer.c \
gtkgradient.c \
gtkgrid.c \
gtkiconcache.c \
@@ -756,6 +761,7 @@ gtk_base_c_sources = \
gtkseparator.c \
gtkseparatormenuitem.c \
gtkseparatortoolitem.c \
+ gtksequence.c \
gtksequencetracker.c \
gtksettings.c \
gtksizegroup.c \
diff --git a/gtk/gtk.h b/gtk/gtk.h
index 97f5fef..e3fa16e 100644
--- a/gtk/gtk.h
+++ b/gtk/gtk.h
@@ -109,6 +109,8 @@
#include <gtk/gtkfontchooserdialog.h>
#include <gtk/gtkfontchooserwidget.h>
#include <gtk/gtkframe.h>
+#include <gtk/gtkgesture.h>
+#include <gtk/gtkgesturerecognizer.h>
#include <gtk/gtkgradient.h>
#include <gtk/gtkgrid.h>
#include <gtk/gtkiconfactory.h>
@@ -173,6 +175,7 @@
#include <gtk/gtkseparator.h>
#include <gtk/gtkseparatormenuitem.h>
#include <gtk/gtkseparatortoolitem.h>
+#include <gtk/gtksequence.h>
#include <gtk/gtksettings.h>
#include <gtk/gtkshow.h>
#include <gtk/gtksizegroup.h>
diff --git a/gtk/gtkgesture.c b/gtk/gtkgesture.c
new file mode 100644
index 0000000..7dd4371
--- /dev/null
+++ b/gtk/gtkgesture.c
@@ -0,0 +1,371 @@
+/*
+ * Copyright  2012 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.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 Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors: Benjamin Otte <otte gnome org>
+ */
+
+#include "config.h"
+
+#include "gtkgesture.h"
+
+#include "gtkeventtrackerprivate.h"
+#include "gtkintl.h"
+#include "gtksequence.h"
+
+/**
+ * SECTION:gtkgesture
+ * @Short_description: Gesture recognition
+ * @Title: GtkGesture
+ * @See_also: #GtkGestureRecognizer, #GtkEventTracker
+ *
+ * The #GtkGesture object - or rather its subclasses - are #GtkEventTrackers
+ * that cooperates with other #GtkGestures on the recognizing of
+ * #GdkSequences.
+ *
+ * #GtkGesture was added in GTK 3.6.
+ */
+
+
+enum {
+ PROP_0
+};
+
+struct _GtkGesturePrivate {
+ GPtrArray *sequences;
+
+ guint accepted :1;
+};
+
+G_DEFINE_ABSTRACT_TYPE (GtkGesture, gtk_gesture, GTK_TYPE_EVENT_TRACKER)
+
+static void
+gtk_gesture_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ //GtkGesture *gesture = GTK_GESTURE (object);
+ //GtkGesturePrivate *priv = gesture->priv;
+
+ switch (prop_id)
+ {
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gtk_gesture_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ //GtkGesture *gesture = GTK_GESTURE (object);
+ //GtkGesturePrivate *priv = gesture->priv;
+
+ switch (prop_id)
+ {
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gtk_gesture_remove_all_sequences (GtkGesture *gesture)
+{
+ GtkGesturePrivate *priv = gesture->priv;
+
+ if (priv->accepted)
+ return;
+
+ while (priv->sequences->len > 0)
+ gtk_gesture_remove_sequence (gesture, g_ptr_array_index (priv->sequences,
+ priv->sequences->len - 1));
+}
+
+static void
+gtk_gesture_dispose (GObject *object)
+{
+ GtkGesture *gesture = GTK_GESTURE (object);
+ GtkGesturePrivate *priv = gesture->priv;
+
+ gtk_gesture_remove_all_sequences (gesture);
+
+ g_ptr_array_unref (priv->sequences);
+ priv->sequences = NULL;
+
+ G_OBJECT_CLASS (gtk_gesture_parent_class)->dispose (object);
+}
+
+static void
+gtk_gesture_default_sequence_given (GtkGesture *gesture,
+ GdkEventSequence *sequence)
+{
+}
+
+static void
+gtk_gesture_default_sequence_stolen (GtkGesture *gesture,
+ GdkEventSequence *sequence,
+ GtkGesture *stealer)
+{
+ gtk_event_tracker_cancel (GTK_EVENT_TRACKER (gesture));
+}
+
+static void
+gtk_gesture_class_init (GtkGestureClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ klass->sequence_stolen = gtk_gesture_default_sequence_stolen;
+ klass->sequence_given = gtk_gesture_default_sequence_given;
+
+ object_class->dispose = gtk_gesture_dispose;
+ object_class->set_property = gtk_gesture_set_property;
+ object_class->get_property = gtk_gesture_get_property;
+
+ g_type_class_add_private (object_class, sizeof (GtkGesturePrivate));
+}
+
+static void
+gtk_gesture_init (GtkGesture *gesture)
+{
+ GtkGesturePrivate *priv;
+
+ priv = gesture->priv = G_TYPE_INSTANCE_GET_PRIVATE (gesture,
+ GTK_TYPE_GESTURE,
+ GtkGesturePrivate);
+
+ priv->sequences = g_ptr_array_new ();
+}
+
+static void
+gtk_gesture_accept_sequence (GtkGesture *stealer,
+ GdkEventSequence *sequence)
+{
+ GtkEventTracker *tracker, *next;
+
+ for (tracker = _gtk_event_tracker_get_next (GTK_EVENT_TRACKER (stealer));
+ tracker;
+ tracker = next)
+ {
+ GtkGesture *gesture;
+
+ next = _gtk_event_tracker_get_next (tracker);
+
+ if (!GTK_IS_GESTURE (tracker))
+ continue;
+
+ gesture = GTK_GESTURE (tracker);
+
+ if (!gtk_gesture_has_sequence (gesture, sequence))
+ continue;
+
+ /* need some magic here because a lot of gestures wanna cancel themselves
+ * in this vfunc */
+ g_object_ref (gesture);
+
+ GTK_GESTURE_GET_CLASS (gesture)->sequence_stolen (gesture,
+ sequence,
+ stealer);
+
+ next = _gtk_event_tracker_get_next (tracker);
+ g_object_unref (gesture);
+ }
+}
+
+static void
+gtk_gesture_give_sequence (GtkGesture *gesture,
+ GdkEventSequence *sequence)
+{
+ GtkGestureClass *klass = GTK_GESTURE_GET_CLASS (gesture);
+
+ klass->sequence_given (gesture, sequence);
+}
+
+/**
+ * gtk_gesture_add_sequence:
+ * @gesture: the gesture
+ * @sequence: the sequence to add to @gesture
+ *
+ * Marks @gesture as working with @sequence. If @gesture is or gets
+ * accepted, other gestures will be notified about @gesture using @sequence
+ * and @gesture will be notified if other gestures use @sequence.
+ **/
+void
+gtk_gesture_add_sequence (GtkGesture *gesture,
+ GdkEventSequence *sequence)
+{
+ GtkGesturePrivate *priv;
+ gboolean new_owner;
+
+ g_return_if_fail (GTK_IS_GESTURE (gesture));
+ g_return_if_fail (sequence != NULL);
+
+ priv = gesture->priv;
+ new_owner = gtk_sequence_get_owner (sequence) == NULL;
+
+ g_ptr_array_add (priv->sequences, sequence);
+ if (new_owner)
+ gtk_gesture_give_sequence (gesture, sequence);
+ if (priv->accepted)
+ gtk_gesture_accept_sequence (gesture, sequence);
+}
+
+/**
+ * gtk_gesture_remove_sequence:
+ * @gesture: the gesture
+ * @sequence: the sequence to remove. It must have been added with
+ * gtk_gesture_add_sequence() previously.
+ *
+ * Removes the sequence from the list of tracked sequences. This function
+ * does nothing if the gesture has been accepted.
+ *
+ * This function should only be called from #GtkGesture implementations.
+ **/
+void
+gtk_gesture_remove_sequence (GtkGesture *gesture,
+ GdkEventSequence *sequence)
+{
+ GtkGesturePrivate *priv;
+ gboolean was_owner;
+
+ g_return_if_fail (GTK_IS_GESTURE (gesture));
+ g_return_if_fail (sequence != NULL);
+
+ priv = gesture->priv;
+
+ if (priv->accepted)
+ return;
+
+ was_owner = gtk_gesture_owns_sequence (gesture, sequence);
+
+ g_ptr_array_remove (priv->sequences, sequence);
+
+ if (was_owner)
+ {
+ GtkEventTracker *tracker;
+
+ for (tracker = _gtk_event_tracker_get_next (GTK_EVENT_TRACKER (gesture));
+ tracker;
+ tracker = _gtk_event_tracker_get_next (tracker))
+ {
+ if (GTK_IS_GESTURE (tracker) &&
+ gtk_gesture_has_sequence (GTK_GESTURE (tracker), sequence))
+ {
+ gtk_gesture_give_sequence (GTK_GESTURE (tracker), sequence);
+ break;
+ }
+ }
+ }
+}
+
+gboolean
+gtk_gesture_has_sequence (GtkGesture *gesture,
+ GdkEventSequence *sequence)
+{
+ GtkGesturePrivate *priv;
+ guint i;
+
+ g_return_val_if_fail (GTK_IS_GESTURE (gesture), FALSE);
+ g_return_val_if_fail (sequence != NULL, FALSE);
+
+ priv = gesture->priv;
+
+ for (i = 0; i < priv->sequences->len; i++)
+ {
+ if (g_ptr_array_index (priv->sequences, i) == sequence)
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+gboolean
+gtk_gesture_owns_sequence (GtkGesture *gesture,
+ GdkEventSequence *sequence)
+{
+ g_return_val_if_fail (GTK_IS_GESTURE (gesture), FALSE);
+ g_return_val_if_fail (sequence != NULL, FALSE);
+
+ return gtk_sequence_get_owner (sequence) == gesture;
+}
+
+gboolean
+gtk_gesture_owns_all_sequences (GtkGesture *gesture)
+{
+ GtkGesturePrivate *priv;
+ guint i;
+
+ g_return_val_if_fail (GTK_IS_GESTURE (gesture), FALSE);
+
+ priv = gesture->priv;
+
+ for (i = 0; i < priv->sequences->len; i++)
+ {
+ if (!gtk_gesture_owns_sequence (gesture,
+ g_ptr_array_index (priv->sequences, i)))
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/**
+ * gtk_gesture_accept:
+ * @gesture: the gesture to accept
+ *
+ * Accepts @gesture if it hasn't been accepted yet. An accepted gesture
+ * is a gesture that will successfully finish to recognize itself.
+ *
+ * If a gesture marks itself as accepted, all its sequences that were
+ * added with gtk_gesture_add_sequence() are assumed to be consumed by
+ * this @gesture and other gestures will be notified about this.
+ *
+ * This function should only be called from #GtkGesture implementations.
+ **/
+void
+gtk_gesture_accept (GtkGesture *gesture)
+{
+ GtkGesturePrivate *priv;
+ guint i;
+
+ g_return_if_fail (GTK_IS_GESTURE (gesture));
+
+ priv = gesture->priv;
+
+ if (priv->accepted)
+ return;
+
+ priv->accepted = TRUE;
+
+ for (i = 0; i < priv->sequences->len; i++)
+ {
+ gtk_gesture_accept_sequence (gesture,
+ g_ptr_array_index (priv->sequences, i));
+ }
+}
+
+gboolean
+gtk_gesture_is_accepted (GtkGesture *gesture)
+{
+ g_return_val_if_fail (GTK_IS_GESTURE (gesture), FALSE);
+
+ return gesture->priv->accepted;
+}
+
diff --git a/gtk/gtkgesture.h b/gtk/gtkgesture.h
new file mode 100644
index 0000000..5bc36c6
--- /dev/null
+++ b/gtk/gtkgesture.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright  2012 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.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 Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors: Benjamin Otte <otte gnome org>
+ */
+
+#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
+#ifndef __GTK_GESTURE_H__
+#define __GTK_GESTURE_H__
+
+#include <gtk/gtkeventtracker.h>
+#include <gdk/gdk.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_GESTURE (gtk_gesture_get_type ())
+#define GTK_GESTURE(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GTK_TYPE_GESTURE, GtkGesture))
+#define GTK_GESTURE_CLASS(cls) (G_TYPE_CHECK_CLASS_CAST (cls, GTK_TYPE_GESTURE, GtkGestureClass))
+#define GTK_IS_GESTURE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GTK_TYPE_GESTURE))
+#define GTK_IS_GESTURE_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE (obj, GTK_TYPE_GESTURE))
+#define GTK_GESTURE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_GESTURE, GtkGestureClass))
+
+typedef struct _GtkGesture GtkGesture;
+typedef struct _GtkGestureClass GtkGestureClass;
+typedef struct _GtkGesturePrivate GtkGesturePrivate;
+
+struct _GtkGesture
+{
+ GtkEventTracker parent;
+
+ GtkGesturePrivate *priv;
+};
+
+struct _GtkGestureClass
+{
+ GtkEventTrackerClass parent_class;
+
+ void (* sequence_given) (GtkGesture * gesture,
+ GdkEventSequence * sequence);
+ void (* sequence_stolen) (GtkGesture * gesture,
+ GdkEventSequence * sequence,
+ GtkGesture * accepter);
+
+ /* Padding for future expansion */
+ void (*_gtk_reserved0) (void);
+ void (*_gtk_reserved1) (void);
+ void (*_gtk_reserved2) (void);
+ void (*_gtk_reserved3) (void);
+ void (*_gtk_reserved4) (void);
+ void (*_gtk_reserved5) (void);
+ void (*_gtk_reserved6) (void);
+ void (*_gtk_reserved7) (void);
+};
+
+GType gtk_gesture_get_type (void) G_GNUC_CONST;
+
+void gtk_gesture_add_sequence (GtkGesture *gesture,
+ GdkEventSequence *sequence);
+void gtk_gesture_remove_sequence (GtkGesture *gesture,
+ GdkEventSequence *sequence);
+gboolean gtk_gesture_has_sequence (GtkGesture *gesture,
+ GdkEventSequence *sequence);
+gboolean gtk_gesture_owns_sequence (GtkGesture *gesture,
+ GdkEventSequence *sequence);
+gboolean gtk_gesture_owns_all_sequences(GtkGesture *gesture);
+
+void gtk_gesture_accept (GtkGesture *gesture);
+gboolean gtk_gesture_is_accepted (GtkGesture *gesture);
+
+G_END_DECLS
+
+#endif /* __GTK_GESTURE_H__ */
diff --git a/gtk/gtkgesturerecognizer.c b/gtk/gtkgesturerecognizer.c
new file mode 100644
index 0000000..7f66d40
--- /dev/null
+++ b/gtk/gtkgesturerecognizer.c
@@ -0,0 +1,60 @@
+/*
+ * Copyright  2012 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.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 Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors: Benjamin Otte <otte gnome org>
+ */
+
+#include "config.h"
+
+#include "gtkgesturerecognizer.h"
+
+#include "gtkgesture.h"
+
+/**
+ * SECTION:gtkgesturerecognizer
+ * @Short_description: Recognizes gestures
+ * @Title: GtkGestureRecognizer
+ * @See_also: #GtkGesture, #GtkEventRecognizer
+ *
+ * FIXME
+ *
+ * #GtkGestureRecognizer was added in GTK 3.6.
+ */
+
+G_DEFINE_ABSTRACT_TYPE (GtkGestureRecognizer, gtk_gesture_recognizer, GTK_TYPE_EVENT_RECOGNIZER)
+
+static void
+gtk_gesture_recognizer_finished (GtkEventRecognizer *recognizer,
+ GtkEventTracker *tracker)
+{
+ gtk_gesture_accept (GTK_GESTURE (tracker));
+}
+
+static void
+gtk_gesture_recognizer_class_init (GtkGestureRecognizerClass *klass)
+{
+ GtkEventRecognizerClass *recognizer_class = GTK_EVENT_RECOGNIZER_CLASS (klass);
+
+ recognizer_class->finished = gtk_gesture_recognizer_finished;
+
+ gtk_event_recognizer_class_set_tracker_type (recognizer_class, GTK_TYPE_GESTURE);
+}
+
+static void
+gtk_gesture_recognizer_init (GtkGestureRecognizer *recognizer)
+{
+}
diff --git a/gtk/gtkgesturerecognizer.h b/gtk/gtkgesturerecognizer.h
new file mode 100644
index 0000000..31d829c
--- /dev/null
+++ b/gtk/gtkgesturerecognizer.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright  2012 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.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 Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors: Benjamin Otte <otte gnome org>
+ */
+
+#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
+#ifndef __GTK_GESTURE_RECOGNIZER_H__
+#define __GTK_GESTURE_RECOGNIZER_H__
+
+#include <gtk/gtkeventrecognizer.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_GESTURE_RECOGNIZER (gtk_gesture_recognizer_get_type ())
+#define GTK_GESTURE_RECOGNIZER(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GTK_TYPE_GESTURE_RECOGNIZER, GtkGestureRecognizer))
+#define GTK_GESTURE_RECOGNIZER_CLASS(cls) (G_TYPE_CHECK_CLASS_CAST (cls, GTK_TYPE_GESTURE_RECOGNIZER, GtkGestureRecognizerClass))
+#define GTK_IS_GESTURE_RECOGNIZER(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GTK_TYPE_GESTURE_RECOGNIZER))
+#define GTK_IS_GESTURE_RECOGNIZER_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE (obj, GTK_TYPE_GESTURE_RECOGNIZER))
+#define GTK_GESTURE_RECOGNIZER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_GESTURE_RECOGNIZER, GtkGestureRecognizerClass))
+
+typedef struct _GtkGestureRecognizer GtkGestureRecognizer;
+typedef struct _GtkGestureRecognizerClass GtkGestureRecognizerClass;
+typedef struct _GtkGestureRecognizerPrivate GtkGestureRecognizerPrivate;
+
+struct _GtkGestureRecognizer
+{
+ GtkEventRecognizer parent;
+
+ GtkGestureRecognizerPrivate *priv;
+};
+
+struct _GtkGestureRecognizerClass
+{
+ GtkEventRecognizerClass parent_class;
+};
+
+GType gtk_gesture_recognizer_get_type (void) G_GNUC_CONST;
+
+
+G_END_DECLS
+
+#endif /* __GTK_GESTURE_RECOGNIZER_H__ */
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
