[gtk+/xi2-playground: 7/12] Add test applications for multidevice events.
- From: Carlos Garnacho <carlosg src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gtk+/xi2-playground: 7/12] Add test applications for multidevice events.
- Date: Tue, 15 Jun 2010 19:09:45 +0000 (UTC)
commit c908c6bb9b4f5bf667c07524a0f14b0a6eba71d8
Author: Carlos Garnacho <carlosg gnome org>
Date: Mon Jun 7 15:44:00 2010 +0200
Add test applications for multidevice events.
configure.ac | 1 +
tests/Makefile.am | 2 +
tests/multidevice/Makefile.am | 47 +++
tests/multidevice/testangle.c | 197 ++++++++++++
tests/multidevice/testcoordinates.c | 45 +++
tests/multidevice/testcoordinatewidget.c | 251 +++++++++++++++
tests/multidevice/testcoordinatewidget.h | 57 ++++
tests/multidevice/testphotoalbum.c | 111 +++++++
tests/multidevice/testphotoalbumwidget.c | 508 ++++++++++++++++++++++++++++++
tests/multidevice/testphotoalbumwidget.h | 60 ++++
10 files changed, 1279 insertions(+), 0 deletions(-)
---
diff --git a/configure.ac b/configure.ac
index 8db352d..de1f0bb 100644
--- a/configure.ac
+++ b/configure.ac
@@ -2115,6 +2115,7 @@ demos/Makefile
demos/gtk-demo/Makefile
demos/gtk-demo/geninclude.pl
tests/Makefile
+tests/multidevice/Makefile
docs/Makefile
docs/reference/Makefile
docs/reference/gdk-pixbuf/Makefile
diff --git a/tests/Makefile.am b/tests/Makefile.am
index 679262e..0f9bc53 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -1,6 +1,8 @@
## Makefile.am for gtk+/tests
include $(top_srcdir)/Makefile.decl
+SUBDIRS = multidevice
+
INCLUDES = \
-I$(top_srcdir) \
-I$(top_builddir)/gdk \
diff --git a/tests/multidevice/Makefile.am b/tests/multidevice/Makefile.am
new file mode 100644
index 0000000..a26d276
--- /dev/null
+++ b/tests/multidevice/Makefile.am
@@ -0,0 +1,47 @@
+## Makefile.am for gtk+/tests/mpx
+include $(top_srcdir)/Makefile.decl
+
+INCLUDES = \
+ -I$(top_srcdir) \
+ -I$(top_builddir)/gdk \
+ -I$(top_srcdir)/gdk \
+ -DGDK_DISABLE_DEPRECATED \
+ -DGTK_DISABLE_DEPRECATED \
+ $(GTK_DEBUG_FLAGS) \
+ $(GTK_DEP_CFLAGS)
+
+DEPS = \
+ $(top_builddir)/gdk-pixbuf/libgdk_pixbuf-$(GTK_API_VERSION).la \
+ $(top_builddir)/gdk/$(gdktargetlib) \
+ $(top_builddir)/gtk/$(gtktargetlib)
+
+LDADDS = \
+ $(top_builddir)/gdk-pixbuf/libgdk_pixbuf-$(GTK_API_VERSION).la \
+ $(top_builddir)/gdk/$(gdktargetlib) \
+ $(top_builddir)/gtk/$(gtktargetlib)
+
+noinst_PROGRAMS = \
+ testangle \
+ testcoordinates \
+ testphotoalbum
+
+testangle_DEPENDENCIES = $(TEST_DEPS)
+testcoordinates_DEPENDENCIES = $(TEST_DEPS)
+testphotoalbum_DEPENDENCIES = $(TEST_DEPS)
+
+testangle_LDADD = $(LDADDS)
+testcoordinates_LDADD = $(LDADDS)
+testphotoalbum_LDADD = $(LDADDS)
+
+testangle_SOURCES = \
+ testangle.c
+
+testcoordinates_SOURCES = \
+ testcoordinatewidget.c \
+ testcoordinatewidget.h \
+ testcoordinates.c
+
+testphotoalbum_SOURCES = \
+ testphotoalbumwidget.c \
+ testphotoalbumwidget.h \
+ testphotoalbum.c
diff --git a/tests/multidevice/testangle.c b/tests/multidevice/testangle.c
new file mode 100644
index 0000000..c87ec46
--- /dev/null
+++ b/tests/multidevice/testangle.c
@@ -0,0 +1,197 @@
+/*
+ * Copyright (C) 2009 Carlos Garnacho <carlosg gnome org>
+ *
+ * This work is provided "as is"; redistribution and modification
+ * in whole or in part, in any medium, physical or electronic is
+ * permitted without restriction.
+ *
+ * This work 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.
+ *
+ * In no event shall the authors or contributors be liable for any
+ * direct, indirect, incidental, special, exemplary, or consequential
+ * damages (including, but not limited to, procurement of substitute
+ * goods or services; loss of use, data, or profits; or business
+ * interruption) however caused and on any theory of liability, whether
+ * in contract, strict liability, or tort (including negligence or
+ * otherwise) arising in any way out of the use of this software, even
+ * if advised of the possibility of such damage.
+ */
+
+#include <gtk/gtk.h>
+
+typedef struct DeviceData DeviceData;
+typedef struct Data Data;
+
+struct Data
+{
+ GtkDeviceGroup *group;
+
+ gdouble x;
+ gdouble y;
+ gdouble angle;
+ gdouble distance;
+};
+
+static gboolean
+button_press_cb (GtkWidget *widget,
+ GdkEvent *event,
+ gpointer user_data)
+{
+ Data *data;
+ GList *devices;
+
+ data = (Data *) user_data;
+ devices = gtk_device_group_get_devices (data->group);
+
+ if (g_list_length (devices) < 2)
+ gtk_device_group_add_device (data->group, gdk_event_get_device (event));
+
+ return FALSE;
+}
+
+static gboolean
+button_release_cb (GtkWidget *widget,
+ GdkEvent *event,
+ gpointer user_data)
+{
+ Data *data;
+
+ data = (Data *) user_data;
+
+ gtk_device_group_remove_device (data->group, gdk_event_get_device (event));
+
+ return FALSE;
+}
+
+static void
+multidevice_cb (GtkWidget *widget,
+ GtkDeviceGroup *group,
+ GtkMultiDeviceEvent *event,
+ gpointer user_data)
+{
+ Data *data;
+
+ data = user_data;
+
+ if (event->n_events > 0)
+ {
+ data->x = event->events[0]->x;
+ data->y = event->events[0]->y;
+ }
+
+ if (event->n_events > 1)
+ {
+ gdk_events_get_distance ((GdkEvent *) event->events[0],
+ (GdkEvent *) event->events[1],
+ &data->distance);
+ gdk_events_get_angle ((GdkEvent *) event->events[0],
+ (GdkEvent *) event->events[1],
+ &data->angle);
+ }
+ else
+ {
+ data->distance = 0;
+ data->angle = 0;
+ }
+
+ gtk_widget_queue_draw (widget);
+}
+
+static gboolean
+expose_cb (GtkWidget *widget,
+ GdkEventExpose *event,
+ gpointer user_data)
+{
+ Data *data;
+ cairo_t *cr;
+ GList *devices;
+
+ data = (Data *) user_data;
+
+ devices = gtk_device_group_get_devices (data->group);
+
+ if (!devices)
+ return TRUE;
+
+ cr = gdk_cairo_create (widget->window);
+ cairo_translate (cr, data->x, data->y);
+
+ cairo_save (cr);
+
+ cairo_set_source_rgb (cr, 0., 0., 0.);
+ cairo_move_to (cr, 0, 0);
+ cairo_rel_line_to (cr, 1000, 0);
+ cairo_stroke (cr);
+
+ cairo_restore (cr);
+
+ if (data->angle > 0)
+ {
+ cairo_save (cr);
+
+ cairo_set_source_rgb (cr, 0, 0, 1);
+ cairo_move_to (cr, 0, 0);
+
+ cairo_arc (cr,
+ 0.,
+ 0.,
+ MAX (10., data->distance),
+ 0.,
+ data->angle);
+
+ cairo_close_path (cr);
+
+ cairo_fill (cr);
+
+ cairo_restore (cr);
+
+ cairo_set_source_rgb (cr, 1., 0., 0.);
+ cairo_rotate (cr, data->angle);
+ cairo_move_to (cr, 0, 0);
+ cairo_rel_line_to (cr, data->distance, 0);
+ cairo_stroke (cr);
+ }
+
+ cairo_destroy (cr);
+
+ return TRUE;
+}
+
+int
+main (int argc, gchar *argv[])
+{
+ GtkWidget *window;
+ Data data = { 0 };
+
+ gtk_init (&argc, &argv);
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_widget_set_app_paintable (window, TRUE);
+
+ data.group = gtk_widget_create_device_group (window);
+
+ gtk_widget_add_events (window,
+ (GDK_POINTER_MOTION_MASK |
+ GDK_BUTTON_PRESS_MASK |
+ GDK_BUTTON_RELEASE_MASK |
+ GDK_BUTTON_MOTION_MASK));
+
+ gtk_widget_set_support_multidevice (window, TRUE);
+
+ g_signal_connect (window, "button-press-event",
+ G_CALLBACK (button_press_cb), &data);
+ g_signal_connect (window, "button-release-event",
+ G_CALLBACK (button_release_cb), &data);
+ g_signal_connect (window, "multidevice-event",
+ G_CALLBACK (multidevice_cb), &data);
+ g_signal_connect (window, "expose-event",
+ G_CALLBACK (expose_cb), &data);
+
+ gtk_widget_show (window);
+
+ gtk_main ();
+
+ return 0;
+}
diff --git a/tests/multidevice/testcoordinates.c b/tests/multidevice/testcoordinates.c
new file mode 100644
index 0000000..dc43645
--- /dev/null
+++ b/tests/multidevice/testcoordinates.c
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2009 Carlos Garnacho <carlosg gnome org>
+ *
+ * This work is provided "as is"; redistribution and modification
+ * in whole or in part, in any medium, physical or electronic is
+ * permitted without restriction.
+ *
+ * This work 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.
+ *
+ * In no event shall the authors or contributors be liable for any
+ * direct, indirect, incidental, special, exemplary, or consequential
+ * damages (including, but not limited to, procurement of substitute
+ * goods or services; loss of use, data, or profits; or business
+ * interruption) however caused and on any theory of liability, whether
+ * in contract, strict liability, or tort (including negligence or
+ * otherwise) arising in any way out of the use of this software, even
+ * if advised of the possibility of such damage.
+ */
+
+#include <gtk/gtk.h>
+#include "testcoordinatewidget.h"
+
+int
+main (int argc, char *argv[])
+{
+ GtkWidget *window, *widget;
+
+ gtk_init (&argc, &argv);
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ widget = test_coordinate_widget_new ();
+ gtk_container_add (GTK_CONTAINER (window), widget);
+
+ g_signal_connect (window, "delete-event",
+ G_CALLBACK (gtk_main_quit), NULL);
+
+ gtk_widget_show_all (window);
+
+ gtk_main ();
+
+ return 0;
+}
diff --git a/tests/multidevice/testcoordinatewidget.c b/tests/multidevice/testcoordinatewidget.c
new file mode 100644
index 0000000..f9f3887
--- /dev/null
+++ b/tests/multidevice/testcoordinatewidget.c
@@ -0,0 +1,251 @@
+/*
+ * Copyright (C) 2009 Carlos Garnacho <carlosg gnome org>
+ *
+ * This work is provided "as is"; redistribution and modification
+ * in whole or in part, in any medium, physical or electronic is
+ * permitted without restriction.
+ *
+ * This work 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.
+ *
+ * In no event shall the authors or contributors be liable for any
+ * direct, indirect, incidental, special, exemplary, or consequential
+ * damages (including, but not limited to, procurement of substitute
+ * goods or services; loss of use, data, or profits; or business
+ * interruption) however caused and on any theory of liability, whether
+ * in contract, strict liability, or tort (including negligence or
+ * otherwise) arising in any way out of the use of this software, even
+ * if advised of the possibility of such damage.
+ */
+
+#include "testcoordinatewidget.h"
+
+#define TEST_COORDINATE_WIDGET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TEST_TYPE_COORDINATE_WIDGET, TestCoordinateWidgetPrivate))
+
+typedef struct TestCoordinateWidgetPrivate TestCoordinateWidgetPrivate;
+
+struct TestCoordinateWidgetPrivate
+{
+ GtkDeviceGroup *group;
+ GHashTable *coordinates;
+};
+
+static void test_coordinate_widget_class_init (TestCoordinateWidgetClass *klass);
+static void test_coordinate_widget_init (TestCoordinateWidget *coordinate);
+
+static void test_coordinate_widget_destroy (GtkObject *object);
+
+static gboolean test_coordinate_widget_button_press (GtkWidget *widget,
+ GdkEventButton *event);
+static gboolean test_coordinate_widget_button_release (GtkWidget *widget,
+ GdkEventButton *event);
+static gboolean test_coordinate_widget_expose (GtkWidget *widget,
+ GdkEventExpose *event);
+
+static void test_coordinate_widget_multidevice_event (GtkWidget *widget,
+ GtkDeviceGroup *group,
+ GtkMultiDeviceEvent *event);
+
+G_DEFINE_TYPE (TestCoordinateWidget, test_coordinate_widget, GTK_TYPE_DRAWING_AREA)
+
+
+static void
+test_coordinate_widget_class_init (TestCoordinateWidgetClass *klass)
+{
+ GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+ object_class->destroy = test_coordinate_widget_destroy;
+
+ widget_class->button_press_event = test_coordinate_widget_button_press;
+ widget_class->button_release_event = test_coordinate_widget_button_release;
+ widget_class->expose_event = test_coordinate_widget_expose;
+
+ g_type_class_add_private (klass, sizeof (TestCoordinateWidgetPrivate));
+}
+
+static void
+test_coordinate_widget_init (TestCoordinateWidget *coord)
+{
+ TestCoordinateWidgetPrivate *priv;
+ GtkWidget *widget;
+
+ priv = TEST_COORDINATE_WIDGET_GET_PRIVATE (coord);
+ widget = GTK_WIDGET (coord);
+
+ priv->coordinates = g_hash_table_new_full (g_direct_hash,
+ g_direct_equal,
+ (GDestroyNotify) g_object_unref,
+ (GDestroyNotify) g_free);
+
+ gtk_widget_add_events (widget,
+ (GDK_BUTTON_PRESS_MASK |
+ GDK_BUTTON_RELEASE_MASK |
+ GDK_POINTER_MOTION_MASK |
+ GDK_ENTER_NOTIFY_MASK |
+ GDK_LEAVE_NOTIFY_MASK));
+
+ priv->group = gtk_widget_create_device_group (GTK_WIDGET (coord));
+ gtk_widget_set_support_multidevice (widget, TRUE);
+
+ /* Multidevice events are not exposed through GtkWidgetClass */
+ g_signal_connect (coord, "multidevice-event",
+ G_CALLBACK (test_coordinate_widget_multidevice_event), NULL);
+}
+
+static void
+test_coordinate_widget_destroy (GtkObject *object)
+{
+ TestCoordinateWidgetPrivate *priv;
+
+ priv = TEST_COORDINATE_WIDGET_GET_PRIVATE (object);
+
+ if (priv->coordinates)
+ {
+ g_hash_table_destroy (priv->coordinates);
+ priv->coordinates = NULL;
+ }
+
+ if (priv->group)
+ {
+ gtk_widget_remove_device_group (GTK_WIDGET (object), priv->group);
+ priv->group = NULL;
+ }
+
+ GTK_OBJECT_CLASS (test_coordinate_widget_parent_class)->destroy (object);
+}
+
+static gboolean
+test_coordinate_widget_button_press (GtkWidget *widget,
+ GdkEventButton *event)
+{
+ TestCoordinateWidgetPrivate *priv;
+ GdkDevice *device;
+
+ priv = TEST_COORDINATE_WIDGET_GET_PRIVATE (widget);
+ device = gdk_event_get_device ((GdkEvent *) event);
+
+ gtk_device_group_add_device (priv->group, device);
+
+ return FALSE;
+}
+
+static gboolean
+test_coordinate_widget_button_release (GtkWidget *widget,
+ GdkEventButton *event)
+{
+ TestCoordinateWidgetPrivate *priv;
+ GdkDevice *device;
+
+ priv = TEST_COORDINATE_WIDGET_GET_PRIVATE (widget);
+ device = gdk_event_get_device ((GdkEvent *) event);
+
+ gtk_device_group_remove_device (priv->group, device);
+
+ return FALSE;
+}
+
+static void
+test_coordinate_widget_multidevice_event (GtkWidget *widget,
+ GtkDeviceGroup *group,
+ GtkMultiDeviceEvent *event)
+{
+ TestCoordinateWidgetPrivate *priv;
+ GdkEventMotion *ev;
+ GdkPoint *point;
+
+ priv = TEST_COORDINATE_WIDGET_GET_PRIVATE (widget);
+
+ if (event->type == GTK_EVENT_DEVICE_REMOVED)
+ g_hash_table_remove (priv->coordinates, event->updated_device);
+ else
+ {
+ point = g_hash_table_lookup (priv->coordinates, event->updated_device);
+ ev = event->updated_event;
+
+ if (G_UNLIKELY (!point))
+ {
+ point = g_new (GdkPoint, 1);
+ g_hash_table_insert (priv->coordinates,
+ g_object_ref (event->updated_device),
+ point);
+ }
+
+ point->x = ev->x;
+ point->y = ev->y;
+ }
+
+ gtk_widget_queue_draw (widget);
+}
+
+static gboolean
+test_coordinate_widget_expose (GtkWidget *widget,
+ GdkEventExpose *event)
+{
+ TestCoordinateWidgetPrivate *priv;
+ GList *coords, *c;
+ cairo_t *cr;
+
+ priv = TEST_COORDINATE_WIDGET_GET_PRIVATE (widget);
+ cr = gdk_cairo_create (widget->window);
+
+ coords = g_hash_table_get_values (priv->coordinates);
+
+ cairo_set_source_rgb (cr, 1., 1., 1.);
+ cairo_rectangle (cr,
+ widget->allocation.x,
+ widget->allocation.y,
+ widget->allocation.width,
+ widget->allocation.height);
+ cairo_fill (cr);
+
+ cairo_set_source_rgb (cr, 0.8, 0.8, 0.8);
+
+ for (c = coords; c; c = c->next)
+ {
+ GdkPoint *point;
+
+ point = c->data;
+
+ cairo_move_to (cr, point->x, 0);
+ cairo_rel_line_to (cr, 0, widget->allocation.height);
+
+ cairo_move_to (cr, 0, point->y);
+ cairo_rel_line_to (cr, widget->allocation.width, 0);
+ }
+
+ cairo_stroke (cr);
+
+ cairo_set_source_rgba (cr, 0.5, 0., 0., 0.5);
+
+ if (g_list_length (coords) > 1)
+ {
+ for (c = coords; c; c = c->next)
+ {
+ GdkPoint *point;
+
+ point = c->data;
+
+ cairo_line_to (cr, point->x, point->y);
+ }
+
+ cairo_close_path (cr);
+ cairo_fill_preserve (cr);
+
+ cairo_set_source_rgba (cr, 0., 0., 0.5, 0.5);
+ cairo_stroke (cr);
+ }
+
+ cairo_destroy (cr);
+
+ g_list_free (coords);
+
+ return TRUE;
+}
+
+GtkWidget *
+test_coordinate_widget_new (void)
+{
+ return g_object_new (TEST_TYPE_COORDINATE_WIDGET, NULL);
+}
diff --git a/tests/multidevice/testcoordinatewidget.h b/tests/multidevice/testcoordinatewidget.h
new file mode 100644
index 0000000..bfa764d
--- /dev/null
+++ b/tests/multidevice/testcoordinatewidget.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2009 Carlos Garnacho <carlosg gnome org>
+ *
+ * This work is provided "as is"; redistribution and modification
+ * in whole or in part, in any medium, physical or electronic is
+ * permitted without restriction.
+ *
+ * This work 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.
+ *
+ * In no event shall the authors or contributors be liable for any
+ * direct, indirect, incidental, special, exemplary, or consequential
+ * damages (including, but not limited to, procurement of substitute
+ * goods or services; loss of use, data, or profits; or business
+ * interruption) however caused and on any theory of liability, whether
+ * in contract, strict liability, or tort (including negligence or
+ * otherwise) arising in any way out of the use of this software, even
+ * if advised of the possibility of such damage.
+ */
+
+#ifndef __TEST_COORDINATE_WIDGET_H__
+#define __TEST_COORDINATE_WIDGET_H__
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define TEST_TYPE_COORDINATE_WIDGET (test_coordinate_widget_get_type ())
+#define TEST_COORDINATE_WIDGET(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TEST_TYPE_COORDINATE_WIDGET, TestCoordinateWidget))
+#define TEST_COORDINATE_WIDGET_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), TEST_TYPE_COORDINATE_WIDGET, TestCoordinateWidgetClass))
+#define TEST_IS_COORDINATE_WIDGET(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TEST_TYPE_COORDINATE_WIDGET))
+#define TEST_IS_COORDINATE_WIDGET_CLASS(c) (G_TYPE_CHECK_CLASS_TYPE ((c), TEST_TYPE_COORDINATE_WIDGET))
+#define TEST_COORDINATE_WIDGET_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TEST_TYPE_COORDINATE_WIDGET, TestCoordinateWidgetClass))
+
+typedef struct TestCoordinateWidget TestCoordinateWidget;
+typedef struct TestCoordinateWidgetClass TestCoordinateWidgetClass;
+
+struct TestCoordinateWidget
+{
+ GtkDrawingArea parent_instance;
+};
+
+struct TestCoordinateWidgetClass
+{
+ GtkDrawingAreaClass parent_class;
+};
+
+
+GType test_coordinate_widget_get_type (void) G_GNUC_CONST;
+
+GtkWidget * test_coordinate_widget_new (void);
+
+
+G_END_DECLS
+
+#endif /* __TEST_COORDINATE_WIDGET_H__ */
diff --git a/tests/multidevice/testphotoalbum.c b/tests/multidevice/testphotoalbum.c
new file mode 100644
index 0000000..008e5e5
--- /dev/null
+++ b/tests/multidevice/testphotoalbum.c
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2009 Carlos Garnacho <carlosg gnome org>
+ *
+ * This work is provided "as is"; redistribution and modification
+ * in whole or in part, in any medium, physical or electronic is
+ * permitted without restriction.
+ *
+ * This work 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.
+ *
+ * In no event shall the authors or contributors be liable for any
+ * direct, indirect, incidental, special, exemplary, or consequential
+ * damages (including, but not limited to, procurement of substitute
+ * goods or services; loss of use, data, or profits; or business
+ * interruption) however caused and on any theory of liability, whether
+ * in contract, strict liability, or tort (including negligence or
+ * otherwise) arising in any way out of the use of this software, even
+ * if advised of the possibility of such damage.
+ */
+
+#include <gtk/gtk.h>
+#include "testphotoalbumwidget.h"
+
+static void
+add_image (TestPhotoAlbumWidget *album,
+ const gchar *image_path)
+{
+ GdkPixbuf *pixbuf;
+
+ pixbuf = gdk_pixbuf_new_from_file_at_size (image_path,
+ 200, -1,
+ NULL);
+ if (pixbuf)
+ {
+ test_photo_album_widget_add_image (album, pixbuf);
+ g_object_unref (pixbuf);
+ }
+}
+
+static void
+read_directory (GFile *directory,
+ TestPhotoAlbumWidget *album)
+{
+ GFileEnumerator *enumerator;
+ GError *error = NULL;
+ GFileInfo *info;
+
+ enumerator = g_file_enumerate_children (directory,
+ G_FILE_ATTRIBUTE_STANDARD_NAME,
+ G_FILE_QUERY_INFO_NONE,
+ NULL,
+ &error);
+
+ if (error)
+ {
+ g_warning ("%s\n", error->message);
+ g_error_free (error);
+ return;
+ }
+
+ while ((info = g_file_enumerator_next_file (enumerator, NULL, NULL)) != NULL)
+ {
+ GFile *file;
+ gchar *path;
+
+ file = g_file_get_child (directory, g_file_info_get_name (info));
+
+ path = g_file_get_path (file);
+ add_image (album, path);
+ g_free (path);
+
+ g_object_unref (file);
+ }
+
+ g_file_enumerator_close (enumerator, NULL, NULL);
+ g_object_unref (enumerator);
+}
+
+int
+main (int argc, char *argv[])
+{
+ GtkWidget *window, *widget;
+ GFile *dir;
+
+ if (argc != 2)
+ {
+ g_print ("USAGE: %s <path-to-directory-with-images>\n", argv[0]);
+ return -1;
+ }
+
+ gtk_init (&argc, &argv);
+
+ dir = g_file_new_for_commandline_arg (argv[1]);
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ widget = test_photo_album_widget_new ();
+ gtk_container_add (GTK_CONTAINER (window), widget);
+
+ g_signal_connect (window, "delete-event",
+ G_CALLBACK (gtk_main_quit), NULL);
+
+ read_directory (dir, TEST_PHOTO_ALBUM_WIDGET (widget));
+
+ gtk_widget_show_all (window);
+
+ gtk_main ();
+
+ return 0;
+}
diff --git a/tests/multidevice/testphotoalbumwidget.c b/tests/multidevice/testphotoalbumwidget.c
new file mode 100644
index 0000000..b530069
--- /dev/null
+++ b/tests/multidevice/testphotoalbumwidget.c
@@ -0,0 +1,508 @@
+/*
+ * Copyright (C) 2009 Carlos Garnacho <carlosg gnome org>
+ *
+ * This work is provided "as is"; redistribution and modification
+ * in whole or in part, in any medium, physical or electronic is
+ * permitted without restriction.
+ *
+ * This work 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.
+ *
+ * In no event shall the authors or contributors be liable for any
+ * direct, indirect, incidental, special, exemplary, or consequential
+ * damages (including, but not limited to, procurement of substitute
+ * goods or services; loss of use, data, or profits; or business
+ * interruption) however caused and on any theory of liability, whether
+ * in contract, strict liability, or tort (including negligence or
+ * otherwise) arising in any way out of the use of this software, even
+ * if advised of the possibility of such damage.
+ */
+
+#include "testphotoalbumwidget.h"
+#include <math.h>
+
+#define TEST_PHOTO_ALBUM_WIDGET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TEST_TYPE_PHOTO_ALBUM_WIDGET, TestPhotoAlbumWidgetPrivate))
+
+typedef struct TestPhotoAlbumWidgetPrivate TestPhotoAlbumWidgetPrivate;
+typedef struct TestPhoto TestPhoto;
+
+struct TestPhoto
+{
+ GdkPixbuf *pixbuf;
+ GtkDeviceGroup *group;
+ gdouble center_x;
+ gdouble center_y;
+ gdouble x;
+ gdouble y;
+ gdouble angle;
+ gdouble zoom;
+
+ GdkRegion *region;
+
+ gdouble base_zoom;
+ gdouble base_angle;
+ gdouble initial_distance;
+ gdouble initial_angle;
+};
+
+struct TestPhotoAlbumWidgetPrivate
+{
+ GPtrArray *photos;
+};
+
+static GQuark quark_group_photo = 0;
+
+
+static void test_photo_album_widget_class_init (TestPhotoAlbumWidgetClass *klass);
+static void test_photo_album_widget_init (TestPhotoAlbumWidget *album);
+
+static void test_photo_album_widget_destroy (GtkObject *object);
+
+static gboolean test_photo_album_widget_button_press (GtkWidget *widget,
+ GdkEventButton *event);
+static gboolean test_photo_album_widget_button_release (GtkWidget *widget,
+ GdkEventButton *event);
+static void test_photo_album_widget_multidevice_event (GtkWidget *widget,
+ GtkDeviceGroup *group,
+ GtkMultiDeviceEvent *event);
+static gboolean test_photo_album_widget_expose (GtkWidget *widget,
+ GdkEventExpose *event);
+
+G_DEFINE_TYPE (TestPhotoAlbumWidget, test_photo_album_widget, GTK_TYPE_DRAWING_AREA)
+
+
+static void
+test_photo_album_widget_class_init (TestPhotoAlbumWidgetClass *klass)
+{
+ GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+ object_class->destroy = test_photo_album_widget_destroy;
+
+ widget_class->button_press_event = test_photo_album_widget_button_press;
+ widget_class->button_release_event = test_photo_album_widget_button_release;
+ widget_class->expose_event = test_photo_album_widget_expose;
+
+ g_type_class_add_private (klass, sizeof (TestPhotoAlbumWidgetPrivate));
+
+ quark_group_photo = g_quark_from_static_string ("group-photo");
+}
+
+static void
+test_photo_album_widget_init (TestPhotoAlbumWidget *album)
+{
+ TestPhotoAlbumWidgetPrivate *priv;
+ GtkWidget *widget;
+
+ priv = TEST_PHOTO_ALBUM_WIDGET_GET_PRIVATE (album);
+ widget = GTK_WIDGET (album);
+
+ priv->photos = g_ptr_array_new ();
+
+ gtk_widget_add_events (widget,
+ (GDK_POINTER_MOTION_MASK |
+ GDK_BUTTON_MOTION_MASK |
+ GDK_BUTTON_PRESS_MASK |
+ GDK_BUTTON_RELEASE_MASK));
+
+ gtk_widget_set_support_multidevice (widget, TRUE);
+
+ /* Multidevice events are not exposed through GtkWidgetClass */
+ g_signal_connect (album, "multidevice-event",
+ G_CALLBACK (test_photo_album_widget_multidevice_event), NULL);
+}
+
+static void
+calculate_rotated_point (gdouble angle,
+ gdouble zoom,
+ gdouble center_x,
+ gdouble center_y,
+ gdouble point_x,
+ gdouble point_y,
+ gdouble *ret_x,
+ gdouble *ret_y)
+{
+ gdouble distance, xd, yd, ang;
+
+ xd = center_x - point_x;
+ yd = center_y - point_y;
+
+ if (xd == 0 && yd == 0)
+ {
+ *ret_x = center_x;
+ *ret_y = center_y;
+ return;
+ }
+
+ distance = sqrt ((xd * xd) + (yd * yd));
+ distance *= zoom;
+
+ ang = atan2 (xd, yd);
+
+ /* Invert angle */
+ ang = (2 * G_PI) - ang;
+
+ /* Shift it 270° */
+ ang += 3 * (G_PI / 2);
+
+ /* And constraint it to 0°-360° */
+ ang = fmod (ang, 2 * G_PI);
+ ang += angle;
+
+ *ret_x = center_x + (distance * cos (ang));
+ *ret_y = center_y + (distance * sin (ang));
+}
+
+static void
+allocate_photo_region (TestPhoto *photo)
+{
+ GdkPoint points[4];
+ gint width, height, i;
+
+ width = gdk_pixbuf_get_width (photo->pixbuf);
+ height = gdk_pixbuf_get_height (photo->pixbuf);
+
+ /* Top/left */
+ points[0].x = photo->x - photo->center_x;
+ points[0].y = photo->y - photo->center_y;
+
+ /* Top/right */
+ points[1].x = photo->x - photo->center_x + width;
+ points[1].y = photo->y - photo->center_y;
+
+ /* Bottom/right */
+ points[2].x = photo->x - photo->center_x + width;
+ points[2].y = photo->y - photo->center_y + height;
+
+ /* Bottom/left */
+ points[3].x = photo->x - photo->center_x;
+ points[3].y = photo->y - photo->center_y + height;
+
+ for (i = 0; i < 4; i++)
+ {
+ gdouble ret_x, ret_y;
+
+ calculate_rotated_point (photo->angle,
+ photo->zoom,
+ photo->x,
+ photo->y,
+ (gdouble) points[i].x,
+ (gdouble) points[i].y,
+ &ret_x,
+ &ret_y);
+
+ points[i].x = (gint) ret_x;
+ points[i].y = (gint) ret_y;
+ }
+
+ if (photo->region)
+ gdk_region_destroy (photo->region);
+
+ photo->region = gdk_region_polygon (points, 4, GDK_WINDING_RULE);
+}
+
+static TestPhoto *
+test_photo_new (TestPhotoAlbumWidget *album,
+ GdkPixbuf *pixbuf)
+{
+ TestPhoto *photo;
+ static gdouble angle = 0;
+
+ photo = g_slice_new0 (TestPhoto);
+ photo->pixbuf = g_object_ref (pixbuf);
+ photo->group = gtk_widget_create_device_group (GTK_WIDGET (album));
+ g_object_set_qdata (G_OBJECT (photo->group), quark_group_photo, photo);
+
+ photo->center_x = 0;
+ photo->center_y = 0;
+ photo->x = 0;
+ photo->y = 0;
+ photo->angle = angle;
+ photo->zoom = 1.0;
+
+ angle += 0.1;
+
+ allocate_photo_region (photo);
+
+ return photo;
+}
+
+static void
+test_photo_free (TestPhoto *photo,
+ TestPhotoAlbumWidget *album)
+{
+ g_object_unref (photo->pixbuf);
+ gtk_widget_remove_device_group (GTK_WIDGET (album), photo->group);
+
+ g_slice_free (TestPhoto, photo);
+}
+
+static void
+test_photo_raise (TestPhoto *photo,
+ TestPhotoAlbumWidget *album)
+{
+ TestPhotoAlbumWidgetPrivate *priv;
+
+ priv = TEST_PHOTO_ALBUM_WIDGET_GET_PRIVATE (album);
+ g_ptr_array_remove (priv->photos, photo);
+ g_ptr_array_add (priv->photos, photo);
+}
+
+static void
+test_photo_album_widget_destroy (GtkObject *object)
+{
+ TestPhotoAlbumWidgetPrivate *priv;
+
+ priv = TEST_PHOTO_ALBUM_WIDGET_GET_PRIVATE (object);
+
+ if (priv->photos)
+ {
+ g_ptr_array_foreach (priv->photos, (GFunc) test_photo_free, object);
+ g_ptr_array_free (priv->photos, TRUE);
+ priv->photos = NULL;
+ }
+
+ GTK_OBJECT_CLASS (test_photo_album_widget_parent_class)->destroy (object);
+}
+
+static TestPhoto *
+find_photo_at_position (TestPhotoAlbumWidget *album,
+ gdouble x,
+ gdouble y)
+{
+ TestPhotoAlbumWidgetPrivate *priv;
+ TestPhoto *photo;
+ gint i;
+
+ priv = TEST_PHOTO_ALBUM_WIDGET_GET_PRIVATE (album);
+
+ for (i = priv->photos->len - 1; i >= 0; i--)
+ {
+ photo = g_ptr_array_index (priv->photos, i);
+
+ if (gdk_region_point_in (photo->region, (gint) x, (gint) y))
+ return photo;
+ }
+
+ return NULL;
+}
+
+static gboolean
+test_photo_album_widget_button_press (GtkWidget *widget,
+ GdkEventButton *event)
+{
+ TestPhoto *photo;
+
+ photo = find_photo_at_position (TEST_PHOTO_ALBUM_WIDGET (widget), event->x, event->y);
+
+ if (!photo)
+ return FALSE;
+
+ test_photo_raise (photo, TEST_PHOTO_ALBUM_WIDGET (widget));
+ gtk_device_group_add_device (photo->group, event->device);
+
+ return TRUE;
+}
+
+static gboolean
+test_photo_album_widget_button_release (GtkWidget *widget,
+ GdkEventButton *event)
+{
+ GtkDeviceGroup *group;
+
+ group = gtk_widget_get_group_for_device (widget, event->device);
+
+ if (group)
+ gtk_device_group_remove_device (group, event->device);
+
+ return TRUE;
+}
+
+static void
+test_photo_album_widget_multidevice_event (GtkWidget *widget,
+ GtkDeviceGroup *group,
+ GtkMultiDeviceEvent *event)
+{
+ TestPhotoAlbumWidgetPrivate *priv;
+ GdkRegion *region;
+ TestPhoto *photo;
+ gboolean new_center = FALSE;
+ gboolean new_position = FALSE;
+ gdouble event_x, event_y;
+
+ priv = TEST_PHOTO_ALBUM_WIDGET_GET_PRIVATE (widget);
+ photo = g_object_get_qdata (G_OBJECT (group), quark_group_photo);
+
+ region = gdk_region_copy (photo->region);
+
+ if (event->n_events == 1)
+ {
+ if (event->type == GTK_EVENT_DEVICE_REMOVED)
+ {
+ /* Device was just removed, unset zoom/angle info */
+ photo->base_zoom = 0;
+ photo->base_angle = 0;
+ photo->initial_angle = 0;
+ photo->initial_distance = 0;
+ new_center = TRUE;
+ }
+ else if (event->type == GTK_EVENT_DEVICE_ADDED)
+ new_center = TRUE;
+
+ event_x = event->events[0]->x;
+ event_y = event->events[0]->y;
+ new_position = TRUE;
+ }
+ else if (event->n_events == 2)
+ {
+ gdouble distance, angle;
+
+ gdk_events_get_center ((GdkEvent *) event->events[0],
+ (GdkEvent *) event->events[1],
+ &event_x, &event_y);
+
+ gdk_events_get_distance ((GdkEvent *) event->events[0],
+ (GdkEvent *) event->events[1],
+ &distance);
+
+ gdk_events_get_angle ((GdkEvent *) event->events[0],
+ (GdkEvent *) event->events[1],
+ &angle);
+
+ if (event->type == GTK_EVENT_DEVICE_ADDED)
+ {
+ photo->base_zoom = photo->zoom;
+ photo->base_angle = photo->angle;
+ photo->initial_angle = angle;
+ photo->initial_distance = distance;
+ new_center = TRUE;
+ }
+
+ photo->zoom = photo->base_zoom * (distance / photo->initial_distance);
+ photo->angle = photo->base_angle + (angle - photo->initial_angle);
+ new_position = TRUE;
+ }
+
+ if (new_center)
+ {
+ gdouble origin_x, origin_y;
+
+ origin_x = photo->x - photo->center_x;
+ origin_y = photo->y - photo->center_y;
+
+ calculate_rotated_point (- photo->angle,
+ 1 / photo->zoom,
+ photo->x - origin_x,
+ photo->y - origin_y,
+ event_x - origin_x,
+ event_y - origin_y,
+ &photo->center_x,
+ &photo->center_y);
+ }
+
+ if (new_position)
+ {
+ photo->x = event_x;
+ photo->y = event_y;
+ }
+
+ allocate_photo_region (photo);
+
+ gdk_region_union (region, photo->region);
+ gdk_region_shrink (region, -4, -4);
+
+ gdk_window_invalidate_region (widget->window, region, FALSE);
+}
+
+static gboolean
+test_photo_album_widget_expose (GtkWidget *widget,
+ GdkEventExpose *event)
+{
+ TestPhotoAlbumWidgetPrivate *priv;
+ cairo_t *cr;
+ gint i;
+
+ priv = TEST_PHOTO_ALBUM_WIDGET_GET_PRIVATE (widget);
+ cr = gdk_cairo_create (widget->window);
+
+ for (i = 0; i < priv->photos->len; i++)
+ {
+ TestPhoto *photo = g_ptr_array_index (priv->photos, i);
+ GdkRegion *region;
+ gint width, height;
+
+ region = gdk_region_copy (photo->region);
+ gdk_region_shrink (region, -4, -4);
+
+ gdk_region_intersect (region, event->region);
+
+ if (gdk_region_empty (region))
+ {
+ gdk_region_destroy (region);
+ continue;
+ }
+
+ width = gdk_pixbuf_get_width (photo->pixbuf);
+ height = gdk_pixbuf_get_height (photo->pixbuf);
+
+ cairo_save (cr);
+
+ gdk_cairo_region (cr, region);
+ cairo_clip (cr);
+
+ cairo_translate (cr, photo->x, photo->y);
+
+ cairo_scale (cr, photo->zoom, photo->zoom);
+ cairo_rotate (cr, photo->angle);
+ gdk_cairo_set_source_pixbuf (cr,
+ photo->pixbuf,
+ - photo->center_x,
+ - photo->center_y);
+
+ cairo_rectangle (cr,
+ - photo->center_x,
+ - photo->center_y,
+ width, height);
+ cairo_fill_preserve (cr);
+
+ cairo_set_source_rgb (cr, 0., 0., 0.);
+ cairo_stroke (cr);
+
+ cairo_restore (cr);
+
+ gdk_region_destroy (region);
+ }
+
+ cairo_destroy (cr);
+
+ return TRUE;
+}
+
+GtkWidget *
+test_photo_album_widget_new (void)
+{
+ return g_object_new (TEST_TYPE_PHOTO_ALBUM_WIDGET, NULL);
+}
+
+void
+test_photo_album_widget_add_image (TestPhotoAlbumWidget *album,
+ GdkPixbuf *pixbuf)
+{
+ TestPhotoAlbumWidgetPrivate *priv;
+ TestPhoto *photo;
+
+ g_return_if_fail (TEST_IS_PHOTO_ALBUM_WIDGET (album));
+ g_return_if_fail (GDK_IS_PIXBUF (pixbuf));
+
+ priv = TEST_PHOTO_ALBUM_WIDGET_GET_PRIVATE (album);
+
+ photo = test_photo_new (album, pixbuf);
+ g_ptr_array_add (priv->photos, photo);
+
+ if (gtk_widget_get_realized (album) &&
+ gtk_widget_is_drawable (album))
+ gdk_window_invalidate_region (GTK_WIDGET (album)->window,
+ photo->region,
+ FALSE);
+}
diff --git a/tests/multidevice/testphotoalbumwidget.h b/tests/multidevice/testphotoalbumwidget.h
new file mode 100644
index 0000000..0a36378
--- /dev/null
+++ b/tests/multidevice/testphotoalbumwidget.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2009 Carlos Garnacho <carlosg gnome org>
+ *
+ * This work is provided "as is"; redistribution and modification
+ * in whole or in part, in any medium, physical or electronic is
+ * permitted without restriction.
+ *
+ * This work 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.
+ *
+ * In no event shall the authors or contributors be liable for any
+ * direct, indirect, incidental, special, exemplary, or consequential
+ * damages (including, but not limited to, procurement of substitute
+ * goods or services; loss of use, data, or profits; or business
+ * interruption) however caused and on any theory of liability, whether
+ * in contract, strict liability, or tort (including negligence or
+ * otherwise) arising in any way out of the use of this software, even
+ * if advised of the possibility of such damage.
+ */
+
+#ifndef __TEST_PHOTO_ALBUM_WIDGET_H__
+#define __TEST_PHOTO_ALBUM_WIDGET_H__
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define TEST_TYPE_PHOTO_ALBUM_WIDGET (test_photo_album_widget_get_type ())
+#define TEST_PHOTO_ALBUM_WIDGET(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TEST_TYPE_PHOTO_ALBUM_WIDGET, TestPhotoAlbumWidget))
+#define TEST_PHOTO_ALBUM_WIDGET_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), TEST_TYPE_PHOTO_ALBUM_WIDGET, TestPhotoAlbumWidgetClass))
+#define TEST_IS_PHOTO_ALBUM_WIDGET(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TEST_TYPE_PHOTO_ALBUM_WIDGET))
+#define TEST_IS_PHOTO_ALBUM_WIDGET_CLASS(c) (G_TYPE_CHECK_CLASS_TYPE ((c), TEST_TYPE_PHOTO_ALBUM_WIDGET))
+#define TEST_PHOTO_ALBUM_WIDGET_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TEST_TYPE_PHOTO_ALBUM_WIDGET, TestPhotoAlbumWidgetClass))
+
+typedef struct TestPhotoAlbumWidget TestPhotoAlbumWidget;
+typedef struct TestPhotoAlbumWidgetClass TestPhotoAlbumWidgetClass;
+
+struct TestPhotoAlbumWidget
+{
+ GtkDrawingArea parent_instance;
+};
+
+struct TestPhotoAlbumWidgetClass
+{
+ GtkDrawingAreaClass parent_class;
+};
+
+
+GType test_photo_album_widget_get_type (void) G_GNUC_CONST;
+
+GtkWidget * test_photo_album_widget_new (void);
+
+void test_photo_album_widget_add_image (TestPhotoAlbumWidget *album,
+ GdkPixbuf *pixbuf);
+
+
+G_END_DECLS
+
+#endif /* __TEST_PHOTO_ALBUM_WIDGET_H__ */
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
