Debian Codegraph @

clutter/osx/clutter-event-osx.c

raw
1 /* Clutter - An OpenGL based 'interactive canvas' library.
2 * OSX backend - event loops integration
3 *
4 * Copyright (C) 2007-2008 Tommi Komulainen <[email protected]>
5 * Copyright (C) 2007 OpenedHand Ltd.
6 * Copyright (C) 2011 Crystalnix <[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 #include "config.h"
24
25 #include "clutter-osx.h"
26
27 #include "clutter-backend-osx.h"
28 #include "clutter-device-manager-osx.h"
29 #include "clutter-stage-osx.h"
30
31 #import <AppKit/AppKit.h>
32
33 #include <glib.h>
34
35 #include "clutter-debug.h"
36 #include "clutter-device-manager.h"
37 #include "clutter-event-private.h"
38 #include "clutter-keysyms.h"
39 #include "clutter-private.h"
40 #include "clutter-stage-private.h"
41
42 #define WHEEL_DELTA 1
43
44 /*************************************************************************/
45 @interface NSEvent (Clutter)
46 - (gint)clutterTime;
47 - (gint)clutterButton;
48 - (void)clutterX:(gfloat*)ptrX y:(gfloat*)ptrY;
49 - (gint)clutterModifierState;
50 - (guint)clutterKeyVal;
51 @end
52
53 @implementation NSEvent (Clutter)
54 - (gint)clutterTime
55 {
56 return [self timestamp] * 1000;
57 }
58
59 - (gint)clutterButton
60 {
61 switch ([self buttonNumber])
62 {
63 case 0: return CLUTTER_BUTTON_PRIMARY; /* left */
64 case 1: return CLUTTER_BUTTON_SECONDARY; /* right */
65 case 2: return CLUTTER_BUTTON_MIDDLE; /* middle */
66 default: return 1 + [self buttonNumber];
67 }
68 }
69
70 - (void)clutterX:(gfloat*)ptrX y:(gfloat*)ptrY
71 {
72 NSView *view = [[self window] contentView];
73 NSPoint pt = [view convertPoint:[self locationInWindow] fromView:nil];
74
75 *ptrX = pt.x;
76 *ptrY = pt.y;
77 }
78
79 - (gint)clutterModifierState
80 {
81 guint mods = [self modifierFlags];
82 guint type = [self type];
83 gint rv = 0;
84
85 /* add key masks */
86 if (mods & NSAlphaShiftKeyMask)
87 rv |= CLUTTER_LOCK_MASK;
88 if (mods & NSShiftKeyMask)
89 rv |= CLUTTER_SHIFT_MASK;
90 if (mods & NSControlKeyMask)
91 rv |= CLUTTER_CONTROL_MASK;
92 if (mods & NSAlternateKeyMask)
93 rv |= CLUTTER_MOD1_MASK;
94 if (mods & NSCommandKeyMask)
95 rv |= CLUTTER_MOD2_MASK;
96
97 /* add button mask */
98 if ((type == NSLeftMouseDragged) ||
99 (type == NSRightMouseDragged) ||
100 (type == NSOtherMouseDragged))
101 rv |= CLUTTER_BUTTON1_MASK << [self buttonNumber];
102
103 return rv;
104 }
105
106 - (guint)clutterKeyVal
107 {
108 unichar c;
109
110 /* FIXME: doing this right is a lot of work, see gdkkeys-quartz.c in gtk+
111 * For now handle some common/simple keys only. Might not work with other
112 * hardware than mine (MacBook Pro, finnish layout). Sorry.
113 *
114 * charactersIgnoringModifiers ignores most modifiers, not Shift though.
115 * So, for all Shift-modified keys we'll end up reporting 'keyval' identical
116 * to 'unicode_value' Instead of <Shift>a or <Shift>3 you'd get <Shift>A
117 * and <Shift>#
118 */
119
120 if ([self type] == NSFlagsChanged)
121 {
122 switch ([self keyCode])
123 {
124 case 54: // Right Command
125 return CLUTTER_KEY_Meta_R;
126 case 55: // Left Command
127 return CLUTTER_KEY_Meta_L;
128 case 57: // Capslock
129 return CLUTTER_KEY_Caps_Lock;
130 case 56: // Left Shift
131 return CLUTTER_KEY_Shift_L;
132 case 60: // Right Shift
133 return CLUTTER_KEY_Shift_R;
134 case 58: // Left Alt
135 return CLUTTER_KEY_Alt_L;
136 case 61: // Right Alt
137 return CLUTTER_KEY_Alt_R;
138 case 59: // Left Ctrl
139 return CLUTTER_KEY_Control_L;
140 case 62: // Right Ctrl
141 return CLUTTER_KEY_Control_R;
142 case 63: // Function
143 return CLUTTER_KEY_function;
144 default: // No such key??!??
145 CLUTTER_NOTE (EVENT, "Got NSFlagsChanged event with keyCode not a known modifier key: %d",
146 [self keyCode]);
147 return CLUTTER_KEY_VoidSymbol;
148 }
149 }
150
151 c = [[self charactersIgnoringModifiers] characterAtIndex:0];
152
153 /* Latin-1 characters, 1:1 mapping - this ought to be reliable */
154 if ((c >= 0x0020 && c <= 0x007e) ||
155 (c >= 0x00a0 && c <= 0x00ff))
156 return c;
157
158 switch (c)
159 {
160 /* these should be fairly standard */
161 /* (maybe add 0x0008 (Ctrl+H) for backspace too) */
162 case 0x000d:
163 return CLUTTER_KEY_Return;
164 case 0x001b:
165 return CLUTTER_KEY_Escape;
166 case 0x007f:
167 return CLUTTER_KEY_BackSpace;
168 /* Defined in NSEvent.h */
169 case NSUpArrowFunctionKey:
170 return CLUTTER_KEY_Up;
171 case NSDownArrowFunctionKey:
172 return CLUTTER_KEY_Down;
173 case NSLeftArrowFunctionKey:
174 return CLUTTER_KEY_Left;
175 case NSRightArrowFunctionKey:
176 return CLUTTER_KEY_Right;
177 case NSF1FunctionKey:
178 return CLUTTER_KEY_F1;
179 case NSF2FunctionKey:
180 return CLUTTER_KEY_F2;
181 case NSF3FunctionKey:
182 return CLUTTER_KEY_F3;
183 case NSF4FunctionKey:
184 return CLUTTER_KEY_F4;
185 case NSF5FunctionKey:
186 return CLUTTER_KEY_F5;
187 case NSF6FunctionKey:
188 return CLUTTER_KEY_F6;
189 case NSF7FunctionKey:
190 return CLUTTER_KEY_F7;
191 case NSF8FunctionKey:
192 return CLUTTER_KEY_F8;
193 case NSF9FunctionKey:
194 return CLUTTER_KEY_F9;
195 case NSF10FunctionKey:
196 return CLUTTER_KEY_F10;
197 case NSF11FunctionKey:
198 return CLUTTER_KEY_F11;
199 case NSF12FunctionKey:
200 return CLUTTER_KEY_F12;
201 case NSInsertFunctionKey:
202 return CLUTTER_KEY_Insert;
203 case NSDeleteFunctionKey:
204 return CLUTTER_KEY_Delete;
205 case NSHomeFunctionKey:
206 return CLUTTER_KEY_Home;
207 case NSEndFunctionKey:
208 return CLUTTER_KEY_End;
209 case NSPageUpFunctionKey:
210 return CLUTTER_KEY_Page_Up;
211 case NSPageDownFunctionKey:
212 return CLUTTER_KEY_Page_Down;
213 }
214
215 CLUTTER_NOTE (BACKEND, "unhandled unicode key 0x%x (%d)", c, c);
216
217 /* hardware dependent, worksforme(tm) Redundant due to above, left around as
218 * example.
219 */
220 switch ([self keyCode])
221 {
222 case 115:
223 return CLUTTER_KEY_Home;
224 case 116:
225 return CLUTTER_KEY_Page_Up;
226 case 117:
227 return CLUTTER_KEY_Delete;
228 case 119:
229 return CLUTTER_KEY_End;
230 case 121:
231 return CLUTTER_KEY_Page_Down;
232 case 123:
233 return CLUTTER_KEY_Left;
234 case 124:
235 return CLUTTER_KEY_Right;
236 case 125:
237 return CLUTTER_KEY_Down;
238 case 126:
239 return CLUTTER_KEY_Up;
240 }
241
242 return 0;
243 }
244 @end
245
246 /*************************************************************************/
247
248 static void
249 take_and_queue_event (ClutterEvent *event)
250 {
251 _clutter_event_push (event, FALSE);
252 }
253
254 static void
255 process_scroll_event (ClutterEvent *event,
256 gboolean isVertical)
257 {
258 ClutterStageWindow *impl;
259 ClutterStageOSX *stage_osx;
260 gfloat *scroll_pos;
261
262 impl = _clutter_stage_get_window (event->any.stage);
263 stage_osx = CLUTTER_STAGE_OSX (impl);
264
265 scroll_pos = isVertical
266 ? &(stage_osx->scroll_pos_y)
267 : &(stage_osx->scroll_pos_x);
268
269 while (abs (*scroll_pos) >= WHEEL_DELTA)
270 {
271 ClutterEvent *event_gen = clutter_event_new (CLUTTER_SCROLL);
272
273 event_gen->scroll.time = event->any.time;
274 event_gen->scroll.modifier_state = event->scroll.modifier_state;
275 event_gen->any.stage = event->any.stage;
276
277 event_gen->scroll.x = event->scroll.x;
278 event_gen->scroll.y = event->scroll.y;
279
280 if (*scroll_pos > 0)
281 {
282 event_gen->scroll.direction = isVertical ? CLUTTER_SCROLL_UP : CLUTTER_SCROLL_RIGHT;
283 *scroll_pos -= WHEEL_DELTA;
284 }
285 else
286 {
287 event_gen->scroll.direction = isVertical ? CLUTTER_SCROLL_DOWN : CLUTTER_SCROLL_LEFT;
288 *scroll_pos += WHEEL_DELTA;
289 }
290
291 clutter_event_set_device (event_gen, clutter_event_get_device (event));
292
293 take_and_queue_event (event_gen);
294
295 CLUTTER_NOTE (EVENT, "scroll %s at %f,%f",
296 (event_gen->scroll.direction == CLUTTER_SCROLL_UP) ? "UP" :
297 (
298 (event_gen->scroll.direction == CLUTTER_SCROLL_DOWN) ? "DOWN" :
299 (
300 (event_gen->scroll.direction == CLUTTER_SCROLL_RIGHT) ? "RIGHT" : "LEFT")),
301 event->scroll.x, event->scroll.y);
302 }
303 }
304
305 static gboolean
306 clutter_event_osx_translate (NSEvent *nsevent,
307 ClutterEvent *event)
308 {
309 ClutterDeviceManagerOSX *manager_osx;
310 ClutterDeviceManager *manager;
311 ClutterStageOSX *stage_osx;
312 ClutterStageWindow *impl;
313 ClutterStage *stage;
314
315 manager = clutter_device_manager_get_default ();
316 if (manager == NULL)
317 return FALSE;
318
319 stage = event->any.stage;
320 impl = _clutter_stage_get_window (event->any.stage);
321 stage_osx = CLUTTER_STAGE_OSX (impl);
322 manager_osx = CLUTTER_DEVICE_MANAGER_OSX (manager);
323
324 event->any.time = [nsevent clutterTime];
325
326 switch ([nsevent type])
327 {
328 case NSLeftMouseDown:
329 case NSRightMouseDown:
330 case NSOtherMouseDown:
331 event->type = CLUTTER_BUTTON_PRESS;
332 /* fall through */
333 case NSLeftMouseUp:
334 case NSRightMouseUp:
335 case NSOtherMouseUp:
336 if (event->type != CLUTTER_BUTTON_PRESS)
337 event->type = CLUTTER_BUTTON_RELEASE;
338
339 event->button.button = [nsevent clutterButton];
340 event->button.click_count = [nsevent clickCount];
341 event->motion.modifier_state = [nsevent clutterModifierState];
342 [nsevent clutterX:&(event->button.x) y:&(event->button.y)];
343 clutter_event_set_device (event, manager_osx->core_pointer);
344
345 CLUTTER_NOTE (EVENT, "button %d %s at %f,%f clicks=%d",
346 (int)[nsevent buttonNumber],
347 event->type == CLUTTER_BUTTON_PRESS ? "press" : "release",
348 event->button.x, event->button.y,
349 event->button.click_count);
350 return TRUE;
351
352 case NSMouseMoved:
353 case NSLeftMouseDragged:
354 case NSRightMouseDragged:
355 case NSOtherMouseDragged:
356 event->type = CLUTTER_MOTION;
357
358 [nsevent clutterX:&(event->motion.x) y:&(event->motion.y)];
359 event->motion.modifier_state = [nsevent clutterModifierState];
360 clutter_event_set_device (event, manager_osx->core_pointer);
361
362 CLUTTER_NOTE (EVENT, "motion %d at %f,%f",
363 (int)[nsevent buttonNumber],
364 event->button.x, event->button.y);
365 return TRUE;
366
367 case NSMouseEntered:
368 event->type = CLUTTER_ENTER;
369
370 [nsevent clutterX:&(event->crossing.x) y:&(event->crossing.y)];
371 event->crossing.related = NULL;
372 event->crossing.source = CLUTTER_ACTOR (stage);
373 clutter_event_set_device (event, manager_osx->core_pointer);
374
375 _clutter_input_device_set_stage (manager_osx->core_pointer, stage);
376
377 CLUTTER_NOTE (EVENT, "enter at %f,%f",
378 event->crossing.x, event->crossing.y);
379 return TRUE;
380
381 case NSMouseExited:
382 event->type = CLUTTER_LEAVE;
383
384 [nsevent clutterX:&(event->crossing.x) y:&(event->crossing.y)];
385 event->crossing.related = NULL;
386 event->crossing.source = CLUTTER_ACTOR (stage);
387 clutter_event_set_device (event, manager_osx->core_pointer);
388
389 _clutter_input_device_set_stage (manager_osx->core_pointer, NULL);
390
391 CLUTTER_NOTE (EVENT, "exit at %f,%f",
392 event->crossing.x, event->crossing.y);
393 return TRUE;
394
395 case NSScrollWheel:
396 stage_osx->scroll_pos_x += [nsevent deltaX];
397 stage_osx->scroll_pos_y += [nsevent deltaY];
398
399 [nsevent clutterX:&(event->scroll.x) y:&(event->scroll.y)];
400 event->scroll.modifier_state = [nsevent clutterModifierState];
401 clutter_event_set_device (event, manager_osx->core_pointer);
402
403 process_scroll_event (event, TRUE);
404 process_scroll_event (event, FALSE);
405 break;
406
407 case NSFlagsChanged:
408 // FIXME: This logic fails if the user presses both Shift keys at once, for example:
409 // we treat releasing one of them as keyDown.
410 switch ([nsevent keyCode])
411 {
412 case 54: // Right Command
413 case 55: // Left Command
414 if ([nsevent modifierFlags] & NSCommandKeyMask)
415 event->type = CLUTTER_KEY_PRESS;
416 break;
417
418 case 57: // Capslock
419 if ([nsevent modifierFlags] & NSAlphaShiftKeyMask)
420 event->type = CLUTTER_KEY_PRESS;
421 break;
422
423 case 56: // Left Shift
424 case 60: // Right Shift
425 if ([nsevent modifierFlags] & NSShiftKeyMask)
426 event->type = CLUTTER_KEY_PRESS;
427 break;
428
429 case 58: // Left Alt
430 case 61: // Right Alt
431 if ([nsevent modifierFlags] & NSAlternateKeyMask)
432 event->type = CLUTTER_KEY_PRESS;
433 break;
434
435 case 59: // Left Ctrl
436 case 62: // Right Ctrl
437 if ([nsevent modifierFlags] & NSControlKeyMask)
438 event->type = CLUTTER_KEY_PRESS;
439 break;
440
441 case 63: // Function
442 if ([nsevent modifierFlags] & NSFunctionKeyMask)
443 event->type = CLUTTER_KEY_PRESS;
444 break;
445 }
446 /* fall through */
447 case NSKeyDown:
448 if ([nsevent type] == NSKeyDown)
449 event->type = CLUTTER_KEY_PRESS;
450 /* fall through */
451 case NSKeyUp:
452 if (event->type != CLUTTER_KEY_PRESS)
453 event->type = CLUTTER_KEY_RELEASE;
454
455 event->key.hardware_keycode = [nsevent keyCode];
456 event->key.modifier_state = [nsevent clutterModifierState];
457 event->key.keyval = [nsevent clutterKeyVal];
458 event->key.unicode_value = ([nsevent type] == NSFlagsChanged)
459 ? (gunichar)'\0'
460 : [[nsevent characters] characterAtIndex:0];
461 clutter_event_set_device (event, manager_osx->core_keyboard);
462
463 CLUTTER_NOTE (EVENT, "key %d (%s) (%s) %s, keyval %d",
464 [nsevent keyCode],
465 ([nsevent type] == NSFlagsChanged) ? "NULL" : [[nsevent characters] UTF8String],
466 ([nsevent type] == NSFlagsChanged) ? "NULL" : [[nsevent charactersIgnoringModifiers] UTF8String],
467 (event->type == CLUTTER_KEY_PRESS) ? "press" : "release",
468 event->key.keyval);
469 return TRUE;
470
471 default:
472 CLUTTER_NOTE (EVENT, "unhandled event %d", (int)[nsevent type]);
473 break;
474 }
475
476 return FALSE;
477 }
478
479 void
480 _clutter_event_osx_put (NSEvent *nsevent,
481 ClutterStage *wrapper)
482 {
483 ClutterEvent *event = clutter_event_new (CLUTTER_NOTHING);
484
485 /* common fields */
486 event->any.stage = wrapper;
487 event->any.time = [nsevent clutterTime];
488
489 if (clutter_event_osx_translate (nsevent, event))
490 {
491 g_assert (event->type != CLUTTER_NOTHING);
492
493 _clutter_event_push (event, FALSE);
494 }
495 else
496 clutter_event_free (event);
497 }