Debian Codegraph @

clutter/gdk/clutter-event-gdk.c

raw
1 /* Clutter.
2 * An OpenGL based 'interactive canvas' library.
3 *
4 * Copyright (C) 2006, 2007, 2008 OpenedHand Ltd
5 * Copyright (C) 2009, 2010 Intel Corp.
6 * 2011 Giovanni Campagna <[email protected]>
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
20 *
21 *
22 *
23 * Authored by:
24 * Matthew Allum <[email protected]>
25 * Emmanuele Bassi <[email protected]>
26 */
27
28 #include "config.h"
29
30 #include "clutter-gdk.h"
31 #include "clutter-backend-gdk.h"
32 #include "clutter-device-manager-gdk.h"
33 #include "clutter-stage-gdk.h"
34
35 #include "clutter-actor-private.h"
36 #include "clutter-backend-private.h"
37 #include "clutter-debug.h"
38 #include "clutter-device-manager-private.h"
39 #include "clutter-event-private.h"
40 #include "clutter-main.h"
41 #include "clutter-paint-volume-private.h"
42 #include "clutter-stage-private.h"
43
44 #include <string.h>
45
46 #include <glib.h>
47
48 /**
49 * clutter_gdk_handle_event:
50 * @event: a #GdkEvent
51 *
52 * This function processes a single GDK event; it can be used to hook
53 * into external event processing
54 *
55 * Return value: #GdkFilterReturn. %GDK_FILTER_REMOVE indicates that
56 * Clutter has internally handled the event and the caller should do
57 * no further processing. %GDK_FILTER_CONTINUE indicates that Clutter
58 * is either not interested in the event, or has used the event to
59 * update internal state without taking any exclusive action.
60 * %GDK_FILTER_TRANSLATE will not occur.
61 *
62 */
63 GdkFilterReturn
64 clutter_gdk_handle_event (GdkEvent *gdk_event)
65 {
66 ClutterDeviceManager *device_manager;
67 ClutterBackendGdk *backend_gdk;
68 ClutterBackend *backend;
69 ClutterStage *stage = NULL;
70 ClutterEvent *event = NULL;
71 gint spin = 0;
72 GdkFilterReturn result = GDK_FILTER_CONTINUE;
73 ClutterInputDevice *device, *source_device;
74 GdkDevice *gdk_device;
75
76 backend = clutter_get_default_backend ();
77 if (!CLUTTER_IS_BACKEND_GDK (backend))
78 return GDK_FILTER_CONTINUE;
79
80 if (gdk_event->any.window == NULL)
81 return GDK_FILTER_CONTINUE;
82
83 device_manager = clutter_device_manager_get_default ();
84 if (G_UNLIKELY (device_manager == NULL))
85 return GDK_FILTER_CONTINUE;
86
87 backend_gdk = CLUTTER_BACKEND_GDK (backend);
88 stage = clutter_gdk_get_stage_from_window (gdk_event->any.window);
89
90 gdk_device = gdk_event_get_device (gdk_event);
91 if (gdk_device != NULL)
92 device = _clutter_device_manager_gdk_lookup_device (device_manager,
93 gdk_device);
94 else
95 device = NULL;
96
97 gdk_device = gdk_event_get_source_device (gdk_event);
98 if (gdk_device != NULL)
99 source_device = _clutter_device_manager_gdk_lookup_device (device_manager,
100 gdk_device);
101 else
102 source_device = NULL;
103
104 if (stage == NULL)
105 return GDK_FILTER_CONTINUE;
106
107 _clutter_threads_acquire_lock ();
108
109 switch (gdk_event->type)
110 {
111 case GDK_DELETE:
112 event = clutter_event_new (CLUTTER_DELETE);
113 break;
114
115 case GDK_DESTROY:
116 event = clutter_event_new (CLUTTER_DESTROY_NOTIFY);
117 break;
118
119 case GDK_EXPOSE:
120 {
121 ClutterPaintVolume clip;
122 ClutterVertex origin;
123
124 CLUTTER_NOTE (EVENT, "Expose for stage '%s' [%p] { %d, %d - %d x %d }",
125 _clutter_actor_get_debug_name (CLUTTER_ACTOR (stage)),
126 stage,
127 gdk_event->expose.area.x,
128 gdk_event->expose.area.y,
129 gdk_event->expose.area.width,
130 gdk_event->expose.area.height);
131
132 origin.x = gdk_event->expose.area.x;
133 origin.y = gdk_event->expose.area.y;
134 origin.z = 0;
135
136 _clutter_paint_volume_init_static (&clip, CLUTTER_ACTOR (stage));
137
138 clutter_paint_volume_set_origin (&clip, &origin);
139 clutter_paint_volume_set_width (&clip, gdk_event->expose.area.width);
140 clutter_paint_volume_set_height (&clip, gdk_event->expose.area.height);
141
142 _clutter_actor_queue_redraw_with_clip (CLUTTER_ACTOR (stage), 0, &clip);
143
144 clutter_paint_volume_free (&clip);
145 }
146 break;
147
148 case GDK_DAMAGE:
149 /* This is handled by cogl */
150 break;
151
152 case GDK_MOTION_NOTIFY:
153 event = clutter_event_new (CLUTTER_MOTION);
154 event->motion.time = gdk_event->motion.time;
155 event->motion.x = gdk_event->motion.x;
156 event->motion.y = gdk_event->motion.y;
157 event->motion.axes = NULL;
158 /* It's all X in the end, right? */
159 event->motion.modifier_state = gdk_event->motion.state;
160 clutter_event_set_device (event, device);
161 clutter_event_set_source_device (event, source_device);
162 CLUTTER_NOTE (EVENT, "Motion notifiy [%.2f, %.2f]",
163 event->motion.x,
164 event->motion.y);
165 break;
166
167 case GDK_BUTTON_PRESS:
168 case GDK_BUTTON_RELEASE:
169 event = clutter_event_new (gdk_event->type == GDK_BUTTON_PRESS ?
170 CLUTTER_BUTTON_PRESS :
171 CLUTTER_BUTTON_RELEASE);
172 event->button.time = gdk_event->button.time;
173 event->button.x = gdk_event->button.x;
174 event->button.y = gdk_event->button.y;
175 event->button.axes = NULL;
176 event->button.modifier_state = gdk_event->button.state;
177 event->button.button = gdk_event->button.button;
178 event->button.click_count = 1;
179 clutter_event_set_device (event, device);
180 clutter_event_set_source_device (event, source_device);
181 CLUTTER_NOTE (EVENT, "Button %d %s [%.2f, %.2f]",
182 event->button.button,
183 event->type == CLUTTER_BUTTON_PRESS ? "press" : "release",
184 event->button.x,
185 event->button.y);
186 break;
187
188 case GDK_TOUCH_BEGIN:
189 case GDK_TOUCH_END:
190 case GDK_TOUCH_CANCEL:
191 case GDK_TOUCH_UPDATE:
192 event = clutter_event_new (gdk_event->type == GDK_TOUCH_BEGIN ?
193 CLUTTER_TOUCH_BEGIN :
194 ((gdk_event->type == GDK_TOUCH_END) ?
195 CLUTTER_TOUCH_END :
196 (gdk_event->type == GDK_TOUCH_UPDATE ?
197 CLUTTER_TOUCH_UPDATE :
198 CLUTTER_TOUCH_CANCEL)));
199 event->touch.time = gdk_event->touch.time;
200 event->touch.x = gdk_event->touch.x;
201 event->touch.y = gdk_event->touch.y;
202 event->touch.sequence = (ClutterEventSequence *) gdk_event->touch.sequence;
203 event->touch.modifier_state = gdk_event->touch.state;
204 clutter_event_set_device (event, device);
205 clutter_event_set_source_device (event, source_device);
206 CLUTTER_NOTE (EVENT, "Touch %p %s [%",
207 event->touch.sequence,
208 event->type == CLUTTER_TOUCH_BEGIN ? "begin" :
209 (event->type == CLUTTER_TOUCH_END ? "end" :
210 (event->type == CLUTTER_TOUCH_UPDATE ? "update"
211 : "cancel")),
212 event->touch.x, event->touch.y);
213 break;
214
215 case GDK_2BUTTON_PRESS:
216 case GDK_3BUTTON_PRESS:
217 /* these are handled by clutter-main.c updating click_count */
218 break;
219
220 case GDK_KEY_PRESS:
221 case GDK_KEY_RELEASE:
222 event = clutter_event_new (gdk_event->type == GDK_KEY_PRESS ?
223 CLUTTER_KEY_PRESS :
224 CLUTTER_KEY_RELEASE);
225 event->key.time = gdk_event->key.time;
226 event->key.modifier_state = gdk_event->key.state;
227 event->key.keyval = gdk_event->key.keyval;
228 event->key.hardware_keycode = gdk_event->key.hardware_keycode;
229 event->key.unicode_value = g_utf8_get_char (gdk_event->key.string);
230 clutter_event_set_device (event, device);
231 clutter_event_set_source_device (event, source_device);
232 CLUTTER_NOTE (EVENT, "Key %d %s",
233 event->key.keyval,
234 event->type == CLUTTER_KEY_PRESS ? "press" : "release");
235 break;
236
237 case GDK_ENTER_NOTIFY:
238 case GDK_LEAVE_NOTIFY:
239 event = clutter_event_new (gdk_event->type == GDK_ENTER_NOTIFY ?
240 CLUTTER_ENTER :
241 CLUTTER_LEAVE);
242 event->crossing.source = CLUTTER_ACTOR (stage);
243 event->crossing.time = gdk_event_get_time (gdk_event);
244 event->crossing.x = gdk_event->crossing.x;
245 event->crossing.y = gdk_event->crossing.y;
246
247 /* XXX: no better fallback here? */
248 clutter_event_set_device (event, device);
249 clutter_event_set_source_device (event, source_device);
250 if (gdk_event->type == GDK_ENTER_NOTIFY)
251 _clutter_input_device_set_stage (clutter_event_get_device (event), stage);
252 else if (gdk_event->type == GDK_LEAVE_NOTIFY &&
253 gdk_event->crossing.mode != GDK_CROSSING_TOUCH_BEGIN &&
254 gdk_event->crossing.mode != GDK_CROSSING_TOUCH_END &&
255 gdk_event->crossing.mode != GDK_CROSSING_DEVICE_SWITCH)
256 _clutter_input_device_set_stage (clutter_event_get_device (event), NULL);
257 CLUTTER_NOTE (EVENT, "Crossing %s [%.2f, %.2f]",
258 event->type == CLUTTER_ENTER ? "enter" : "leave",
259 event->crossing.x,
260 event->crossing.y);
261 break;
262
263 case GDK_FOCUS_CHANGE:
264 if (gdk_event->focus_change.in)
265 _clutter_stage_update_state (stage, 0, CLUTTER_STAGE_STATE_ACTIVATED);
266 else
267 _clutter_stage_update_state (stage, CLUTTER_STAGE_STATE_ACTIVATED, 0);
268 break;
269
270 case GDK_CONFIGURE:
271 {
272 gfloat w, h;
273
274 clutter_actor_get_size (CLUTTER_ACTOR (stage), &w, &h);
275
276 /* Notify gdk stage backend of the new position. This is used
277 by foreign stages to reposition themselves on wayland. */
278 _clutter_stage_gdk_notify_configure (CLUTTER_STAGE_GDK (_clutter_stage_get_window (stage)),
279 gdk_event->configure.x,
280 gdk_event->configure.y,
281 gdk_event->configure.width,
282 gdk_event->configure.height);
283
284 if ((int) w != gdk_event->configure.width ||
285 (int) h != gdk_event->configure.height)
286 {
287 clutter_actor_set_size (CLUTTER_ACTOR (stage),
288 gdk_event->configure.width,
289 gdk_event->configure.height);
290 }
291 }
292 break;
293
294 case GDK_SCROLL:
295 event = clutter_event_new (CLUTTER_SCROLL);
296 event->scroll.time = gdk_event->scroll.time;
297 event->scroll.x = gdk_event->scroll.x;
298 event->scroll.y = gdk_event->scroll.y;
299 event->scroll.modifier_state = gdk_event->scroll.state;
300 event->scroll.axes = NULL;
301 /* XXX: must keep ClutterScrollDirection compatible with GdkScrollDirection */
302 event->scroll.direction = (ClutterScrollDirection) gdk_event->scroll.direction;
303 clutter_event_set_device (event, device);
304 clutter_event_set_source_device (event, source_device);
305 clutter_event_set_scroll_delta (event,
306 gdk_event->scroll.delta_x,
307 gdk_event->scroll.delta_y);
308 break;
309
310 case GDK_WINDOW_STATE:
311 if (gdk_event->window_state.changed_mask & GDK_WINDOW_STATE_FULLSCREEN)
312 {
313 gboolean is_fullscreen;
314
315 is_fullscreen = (gdk_event->window_state.new_window_state & GDK_WINDOW_STATE_FULLSCREEN) != 0;
316 if (is_fullscreen)
317 _clutter_stage_update_state (stage, 0, CLUTTER_STAGE_STATE_FULLSCREEN);
318 else
319 _clutter_stage_update_state (stage, CLUTTER_STAGE_STATE_FULLSCREEN, 0);
320 }
321 break;
322
323 case GDK_SETTING:
324 _clutter_backend_gdk_update_setting (backend_gdk, gdk_event->setting.name);
325 break;
326
327 default:
328 break;
329 }
330
331 if (event != NULL)
332 {
333 event->any.stage = stage;
334
335 if (gdk_event->any.send_event)
336 event->any.flags = CLUTTER_EVENT_FLAG_SYNTHETIC;
337
338 _clutter_event_push (event, FALSE);
339
340 spin = 1;
341
342 CLUTTER_NOTE (EVENT, "Translated one event from Gdk");
343
344 /* handle also synthetic enter/leave events */
345 if (event->type == CLUTTER_MOTION)
346 spin += 2;
347
348 while (spin > 0 && (event = clutter_event_get ()))
349 {
350 /* forward the event into clutter for emission etc. */
351 _clutter_stage_queue_event (event->any.stage, event, FALSE);
352 --spin;
353 }
354
355 result = GDK_FILTER_REMOVE;
356 }
357
358 _clutter_threads_release_lock ();
359
360 return result;
361 }