← Back to branch summary

~karl-qdh/ido/select-activate-set-date

« back to all changes in this revision

Viewing changes to example/gesture.c

  • Committer: Cody Russell
  • Date: 2011-01-18 17:12:19 UTC
  • Revision ID: crussell@canonical.com-20110118171219-0fj84pk70yh2zu6d
Remove IdoGestureManager

Show diffs side-by-side

added added

removed removed

Lines of Context:
example/gesture.c
1
 
#include <stdlib.h>
2
 
#include <string.h>
3
 
#include <signal.h>
4
 
 
5
 
#include "idogesturemanager.h"
6
 
 
7
 
static gint    rotate = 0;
8
 
static gdouble scale = 1.0;
9
 
static gdouble translate[2] = { 200, 200 };
10
 
static gint    in_touch = 0;
11
 
 
12
 
static gboolean
13
 
expose_event (GtkWidget      *widget,
14
 
              GdkEventExpose *event,
15
 
              gpointer        data)
16
 
{
17
 
  cairo_t *cr;
18
 
  gdouble radians;
19
 
  gint width = (in_touch > 0) ? 10 : 1;
20
 
 
21
 
  cr = gdk_cairo_create (widget->window);
22
 
 
23
 
  cairo_set_source_rgb (cr, 0, 0, 0);
24
 
  cairo_set_line_width (cr, width);
25
 
 
26
 
  radians = rotate * (G_PI / 180);
27
 
  cairo_translate (cr, translate[0], translate[1]);
28
 
  cairo_scale (cr, scale, scale);
29
 
  cairo_rotate (cr, radians);
30
 
 
31
 
  cairo_rectangle (cr, -50, -50, 100, 100);
32
 
  cairo_stroke_preserve (cr);
33
 
  cairo_set_source_rgb (cr, 1, 0, 1);
34
 
  cairo_fill (cr);
35
 
 
36
 
  cairo_destroy (cr);
37
 
 
38
 
  return FALSE;
39
 
}
40
 
 
41
 
GtkWidget *
42
 
create_window (void)
43
 
{
44
 
  GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
45
 
  GtkWidget *da;
46
 
  const GdkColor white = { 0, 0xffff, 0xffff, 0xffff };
47
 
 
48
 
  gtk_window_set_title (GTK_WINDOW (window), "Touch Demo");
49
 
  gtk_window_set_default_size (GTK_WINDOW (window), 600, 600);
50
 
  g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window);
51
 
 
52
 
  da = gtk_drawing_area_new ();
53
 
  gtk_container_add (GTK_CONTAINER (window), da);
54
 
 
55
 
  gtk_widget_modify_bg (da, GTK_STATE_NORMAL, &white);
56
 
 
57
 
  g_signal_connect (da, "expose-event",
58
 
                    G_CALLBACK (expose_event), NULL);
59
 
 
60
 
  return window;
61
 
}
62
 
 
63
 
static void
64
 
gesture_start (GtkWindow       *window,
65
 
               IdoGestureEvent *event)
66
 
{
67
 
  in_touch++;
68
 
 
69
 
  gtk_widget_queue_draw (GTK_WIDGET (window));
70
 
}
71
 
 
72
 
static void
73
 
gesture_end (GtkWindow       *window,
74
 
             IdoGestureEvent *event)
75
 
{
76
 
  in_touch--;
77
 
 
78
 
  gtk_widget_queue_draw (GTK_WIDGET (window));
79
 
}
80
 
 
81
 
static void
82
 
rotate_update (GtkWindow       *window,
83
 
               IdoGestureEvent *event)
84
 
{
85
 
  IdoEventGestureRotate *e = (IdoEventGestureRotate *)event;
86
 
 
87
 
  rotate += e->angle_delta * 100;
88
 
 
89
 
  gtk_widget_queue_draw (GTK_WIDGET (window));
90
 
}
91
 
 
92
 
static void
93
 
pinch_update (GtkWindow       *window,
94
 
              IdoGestureEvent *event)
95
 
{
96
 
  IdoEventGesturePinch *e = (IdoEventGesturePinch *)event;
97
 
 
98
 
  scale += e->radius_delta / 100;
99
 
 
100
 
  gtk_widget_queue_draw (GTK_WIDGET (window));
101
 
}
102
 
 
103
 
static void
104
 
drag_update (GtkWindow       *window,
105
 
             IdoGestureEvent *event)
106
 
{
107
 
  IdoEventGestureDrag *e = (IdoEventGestureDrag *)event;
108
 
 
109
 
  translate[0] += e->delta_x;
110
 
  translate[1] += e->delta_y;
111
 
 
112
 
  gtk_widget_queue_draw (GTK_WIDGET (window));
113
 
}
114
 
 
115
 
static void
116
 
window_mapped (GtkWidget *widget)
117
 
{
118
 
  IdoGestureManager *manager = ido_gesture_manager_get ();
119
 
  GtkWindow *window = GTK_WINDOW (widget);
120
 
 
121
 
  ido_gesture_manager_register_window (manager,
122
 
                                       window,
123
 
                                       IDO_GESTURE_PINCH,
124
 
                                       2,
125
 
                                       gesture_start,
126
 
                                       pinch_update,
127
 
                                       gesture_end);
128
 
 
129
 
  ido_gesture_manager_register_window (manager,
130
 
                                       window,
131
 
                                       IDO_GESTURE_ROTATE,
132
 
                                       2,
133
 
                                       gesture_start,
134
 
                                       rotate_update,
135
 
                                       gesture_end);
136
 
 
137
 
  ido_gesture_manager_register_window (manager,
138
 
                                       window,
139
 
                                       IDO_GESTURE_DRAG,
140
 
                                       2,
141
 
                                       gesture_start,
142
 
                                       drag_update,
143
 
                                       gesture_end);
144
 
}
145
 
 
146
 
static void
147
 
abort_handler (int x)
148
 
{
149
 
  g_print (" **** ABORT ****\n");
150
 
 
151
 
  exit (1);
152
 
}
153
 
 
154
 
int
155
 
main (int argc, char **argv)
156
 
{
157
 
  GtkWidget *window;
158
 
 
159
 
  gtk_init (&argc, &argv);
160
 
 
161
 
  /* Don't crash X if we're using some shitty Intel graphics like
162
 
   * my Dell XT2 has in it. */
163
 
  signal (SIGABRT, abort_handler);
164
 
 
165
 
  window = create_window ();
166
 
 
167
 
  g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
168
 
  g_signal_connect (window, "map-event", G_CALLBACK (window_mapped), NULL);
169
 
 
170
 
  gtk_widget_show_all (window);
171
 
 
172
 
  gtk_main ();
173
 
 
174
 
  return 0;
175
 
}
176