isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-25 04:22:05 +00:00
Code Issues Packages Projects Releases Wiki Activity
cd1749a2a5
mutter/clutter/osx/clutter-event-osx.c

497 lines
15 KiB
C
Raw Blame History

/* Clutter - An OpenGL based 'interactive canvas' library.
* OSX backend - event loops integration
*
* Copyright (C) 2007-2008 Tommi Komulainen <tommi.komulainen@iki.fi>
* Copyright (C) 2007 OpenedHand Ltd.
* Copyright (C) 2011 Crystalnix <vgachkaylo@crystalnix.com>
*
* 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 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, see <http://www.gnu.org/licenses/>.
*
*
*/
#include "config.h"
#include "clutter-osx.h"
#include "clutter-device-manager-osx.h"
#include "clutter-stage-osx.h"
#import <AppKit/AppKit.h>
#include <glib.h>
#include "clutter-debug.h"
#include "clutter-device-manager.h"
#include "clutter-event-private.h"
#include "clutter-keysyms.h"
#include "clutter-private.h"
#include "clutter-stage-private.h"
#define WHEEL_DELTA 1
/*************************************************************************/
@interface NSEvent (Clutter)
- (gint)clutterTime;
- (gint)clutterButton;
- (void)clutterX:(gfloat*)ptrX y:(gfloat*)ptrY;
- (gint)clutterModifierState;
- (guint)clutterKeyVal;
@end
@implementation NSEvent (Clutter)
- (gint)clutterTime
{
return [self timestamp] * 1000;
}
- (gint)clutterButton
{
switch ([self buttonNumber])
{
case 0: return 1; /* left */
case 1: return 3; /* right */
case 2: return 2; /* middle */
default: return 1 + [self buttonNumber];
}
}
- (void)clutterX:(gfloat*)ptrX y:(gfloat*)ptrY
{
NSView *view = [[self window] contentView];
NSPoint pt = [view convertPoint:[self locationInWindow] fromView:nil];
*ptrX = pt.x;
*ptrY = pt.y;
}
- (gint)clutterModifierState
{
guint mods = [self modifierFlags];
guint type = [self type];
gint rv = 0;
/* add key masks */
if (mods & NSAlphaShiftKeyMask)
rv |= CLUTTER_LOCK_MASK;
if (mods & NSShiftKeyMask)
rv |= CLUTTER_SHIFT_MASK;
if (mods & NSControlKeyMask)
rv |= CLUTTER_CONTROL_MASK;
if (mods & NSAlternateKeyMask)
rv |= CLUTTER_MOD1_MASK;
if (mods & NSCommandKeyMask)
rv |= CLUTTER_MOD2_MASK;
/* add button mask */
if ((type == NSLeftMouseDragged) ||
(type == NSRightMouseDragged) ||
(type == NSOtherMouseDragged))
rv |= CLUTTER_BUTTON1_MASK << [self buttonNumber];
return rv;
}
- (guint)clutterKeyVal
{
unichar c;
/* FIXME: doing this right is a lot of work, see gdkkeys-quartz.c in gtk+
* For now handle some common/simple keys only. Might not work with other
* hardware than mine (MacBook Pro, finnish layout). Sorry.
*
* charactersIgnoringModifiers ignores most modifiers, not Shift though.
* So, for all Shift-modified keys we'll end up reporting 'keyval' identical
* to 'unicode_value' Instead of <Shift>a or <Shift>3 you'd get <Shift>A
* and <Shift>#
*/
if ([self type] == NSFlagsChanged)
{
switch ([self keyCode])
{
case 54: // Right Command
return CLUTTER_KEY_Meta_R;
case 55: // Left Command
return CLUTTER_KEY_Meta_L;
case 57: // Capslock
return CLUTTER_KEY_Caps_Lock;
case 56: // Left Shift
return CLUTTER_KEY_Shift_L;
case 60: // Right Shift
return CLUTTER_KEY_Shift_R;
case 58: // Left Alt
return CLUTTER_KEY_Alt_L;
case 61: // Right Alt
return CLUTTER_KEY_Alt_R;
case 59: // Left Ctrl
return CLUTTER_KEY_Control_L;
case 62: // Right Ctrl
return CLUTTER_KEY_Control_R;
case 63: // Function
return CLUTTER_KEY_function;
default: // No such key??!??
CLUTTER_NOTE (EVENT, "Got NSFlagsChanged event with keyCode not a known modifier key: %d",
[self keyCode]);
return CLUTTER_KEY_VoidSymbol;
}
}
c = [[self charactersIgnoringModifiers] characterAtIndex:0];
/* Latin-1 characters, 1:1 mapping - this ought to be reliable */
if ((c >= 0x0020 && c <= 0x007e) ||
(c >= 0x00a0 && c <= 0x00ff))
return c;
switch (c)
{
/* these should be fairly standard */
/* (maybe add 0x0008 (Ctrl+H) for backspace too) */
case 0x000d:
return CLUTTER_KEY_Return;
case 0x001b:
return CLUTTER_KEY_Escape;
case 0x007f:
return CLUTTER_KEY_BackSpace;
/* Defined in NSEvent.h */
case NSUpArrowFunctionKey:
return CLUTTER_KEY_Up;
case NSDownArrowFunctionKey:
return CLUTTER_KEY_Down;
case NSLeftArrowFunctionKey:
return CLUTTER_KEY_Left;
case NSRightArrowFunctionKey:
return CLUTTER_KEY_Right;
case NSF1FunctionKey:
return CLUTTER_KEY_F1;
case NSF2FunctionKey:
return CLUTTER_KEY_F2;
case NSF3FunctionKey:
return CLUTTER_KEY_F3;
case NSF4FunctionKey:
return CLUTTER_KEY_F4;
case NSF5FunctionKey:
return CLUTTER_KEY_F5;
case NSF6FunctionKey:
return CLUTTER_KEY_F6;
case NSF7FunctionKey:
return CLUTTER_KEY_F7;
case NSF8FunctionKey:
return CLUTTER_KEY_F8;
case NSF9FunctionKey:
return CLUTTER_KEY_F9;
case NSF10FunctionKey:
return CLUTTER_KEY_F10;
case NSF11FunctionKey:
return CLUTTER_KEY_F11;
case NSF12FunctionKey:
return CLUTTER_KEY_F12;
case NSInsertFunctionKey:
return CLUTTER_KEY_Insert;
case NSDeleteFunctionKey:
return CLUTTER_KEY_Delete;
case NSHomeFunctionKey:
return CLUTTER_KEY_Home;
case NSEndFunctionKey:
return CLUTTER_KEY_End;
case NSPageUpFunctionKey:
return CLUTTER_KEY_Page_Up;
case NSPageDownFunctionKey:
return CLUTTER_KEY_Page_Down;
}
CLUTTER_NOTE (BACKEND, "unhandled unicode key 0x%x (%d)", c, c);
/* hardware dependent, worksforme(tm) Redundant due to above, left around as
* example.
*/
switch ([self keyCode])
{
case 115:
return CLUTTER_KEY_Home;
case 116:
return CLUTTER_KEY_Page_Up;
case 117:
return CLUTTER_KEY_Delete;
case 119:
return CLUTTER_KEY_End;
case 121:
return CLUTTER_KEY_Page_Down;
case 123:
return CLUTTER_KEY_Left;
case 124:
return CLUTTER_KEY_Right;
case 125:
return CLUTTER_KEY_Down;
case 126:
return CLUTTER_KEY_Up;
}
return 0;
}
@end
/*************************************************************************/
static void
take_and_queue_event (ClutterEvent *event)
{
_clutter_event_push (event, FALSE);
}
static void
process_scroll_event (ClutterEvent *event,
gboolean isVertical)
{
ClutterStageWindow *impl;
ClutterStageOSX *stage_osx;
gfloat *scroll_pos;
impl = _clutter_stage_get_window (event->any.stage);
stage_osx = CLUTTER_STAGE_OSX (impl);
scroll_pos = isVertical
? &(stage_osx->scroll_pos_y)
: &(stage_osx->scroll_pos_x);
while (abs (*scroll_pos) >= WHEEL_DELTA)
{
ClutterEvent *event_gen = clutter_event_new (CLUTTER_SCROLL);
event_gen->scroll.time = event->any.time;
event_gen->scroll.modifier_state = event->scroll.modifier_state;
event_gen->any.stage = event->any.stage;
event_gen->scroll.x = event->scroll.x;
event_gen->scroll.y = event->scroll.y;
if (*scroll_pos > 0)
{
event_gen->scroll.direction = isVertical ? CLUTTER_SCROLL_UP : CLUTTER_SCROLL_RIGHT;
*scroll_pos -= WHEEL_DELTA;
}
else
{
event_gen->scroll.direction = isVertical ? CLUTTER_SCROLL_DOWN : CLUTTER_SCROLL_LEFT;
*scroll_pos += WHEEL_DELTA;
}
clutter_event_set_device (event_gen, clutter_event_get_device (event));
take_and_queue_event (event_gen);
CLUTTER_NOTE (EVENT, "scroll %s at %f,%f",
(event_gen->scroll.direction == CLUTTER_SCROLL_UP) ? "UP" :
(
(event_gen->scroll.direction == CLUTTER_SCROLL_DOWN) ? "DOWN" :
(
(event_gen->scroll.direction == CLUTTER_SCROLL_RIGHT) ? "RIGHT" : "LEFT")),
event->scroll.x, event->scroll.y);
}
}
static gboolean
clutter_event_osx_translate (NSEvent *nsevent,
ClutterEvent *event)
{
ClutterDeviceManagerOSX *manager_osx;
ClutterDeviceManager *manager;
ClutterStageOSX *stage_osx;
ClutterStageWindow *impl;
ClutterStage *stage;
manager = clutter_device_manager_get_default ();
if (manager == NULL)
return FALSE;
stage = event->any.stage;
impl = _clutter_stage_get_window (event->any.stage);
stage_osx = CLUTTER_STAGE_OSX (impl);
manager_osx = CLUTTER_DEVICE_MANAGER_OSX (manager);
event->any.time = [nsevent clutterTime];
switch ([nsevent type])
{
case NSLeftMouseDown:
case NSRightMouseDown:
case NSOtherMouseDown:
event->type = CLUTTER_BUTTON_PRESS;
/* fall through */
case NSLeftMouseUp:
case NSRightMouseUp:
case NSOtherMouseUp:
if (event->type != CLUTTER_BUTTON_PRESS)
event->type = CLUTTER_BUTTON_RELEASE;
event->button.button = [nsevent clutterButton];
event->button.click_count = [nsevent clickCount];
event->motion.modifier_state = [nsevent clutterModifierState];
[nsevent clutterX:&(event->button.x) y:&(event->button.y)];
clutter_event_set_device (event, manager_osx->core_pointer);
CLUTTER_NOTE (EVENT, "button %d %s at %f,%f clicks=%d",
(int)[nsevent buttonNumber],
event->type == CLUTTER_BUTTON_PRESS ? "press" : "release",
event->button.x, event->button.y,
event->button.click_count);
return TRUE;
case NSMouseMoved:
case NSLeftMouseDragged:
case NSRightMouseDragged:
case NSOtherMouseDragged:
event->type = CLUTTER_MOTION;
[nsevent clutterX:&(event->motion.x) y:&(event->motion.y)];
event->motion.modifier_state = [nsevent clutterModifierState];
clutter_event_set_device (event, manager_osx->core_pointer);
CLUTTER_NOTE (EVENT, "motion %d at %f,%f",
(int)[nsevent buttonNumber],
event->button.x, event->button.y);
return TRUE;
case NSMouseEntered:
event->type = CLUTTER_ENTER;
[nsevent clutterX:&(event->crossing.x) y:&(event->crossing.y)];
event->crossing.related = NULL;
event->crossing.source = CLUTTER_ACTOR (stage);
clutter_event_set_device (event, manager_osx->core_pointer);
_clutter_input_device_set_stage (manager_osx->core_pointer, stage);
CLUTTER_NOTE (EVENT, "enter at %f,%f",
event->crossing.x, event->crossing.y);
return TRUE;
case NSMouseExited:
event->type = CLUTTER_LEAVE;
[nsevent clutterX:&(event->crossing.x) y:&(event->crossing.y)];
event->crossing.related = NULL;
event->crossing.source = CLUTTER_ACTOR (stage);
clutter_event_set_device (event, manager_osx->core_pointer);
_clutter_input_device_set_stage (manager_osx->core_pointer, NULL);
CLUTTER_NOTE (EVENT, "exit at %f,%f",
event->crossing.x, event->crossing.y);
return TRUE;
case NSScrollWheel:
stage_osx->scroll_pos_x += [nsevent deltaX];
stage_osx->scroll_pos_y += [nsevent deltaY];
[nsevent clutterX:&(event->scroll.x) y:&(event->scroll.y)];
event->scroll.modifier_state = [nsevent clutterModifierState];
clutter_event_set_device (event, manager_osx->core_pointer);
process_scroll_event (event, TRUE);
process_scroll_event (event, FALSE);
break;
case NSFlagsChanged:
// FIXME: This logic fails if the user presses both Shift keys at once, for example:
// we treat releasing one of them as keyDown.
switch ([nsevent keyCode])
{
case 54: // Right Command
case 55: // Left Command
if ([nsevent modifierFlags] & NSCommandKeyMask)
event->type = CLUTTER_KEY_PRESS;
break;
case 57: // Capslock
if ([nsevent modifierFlags] & NSAlphaShiftKeyMask)
event->type = CLUTTER_KEY_PRESS;
break;
case 56: // Left Shift
case 60: // Right Shift
if ([nsevent modifierFlags] & NSShiftKeyMask)
event->type = CLUTTER_KEY_PRESS;
break;
case 58: // Left Alt
case 61: // Right Alt
if ([nsevent modifierFlags] & NSAlternateKeyMask)
event->type = CLUTTER_KEY_PRESS;
break;
case 59: // Left Ctrl
case 62: // Right Ctrl
if ([nsevent modifierFlags] & NSControlKeyMask)
event->type = CLUTTER_KEY_PRESS;
break;
case 63: // Function
if ([nsevent modifierFlags] & NSFunctionKeyMask)
event->type = CLUTTER_KEY_PRESS;
break;
}
/* fall through */
case NSKeyDown:
if ([nsevent type] == NSKeyDown)
event->type = CLUTTER_KEY_PRESS;
/* fall through */
case NSKeyUp:
if (event->type != CLUTTER_KEY_PRESS)
event->type = CLUTTER_KEY_RELEASE;
event->key.hardware_keycode = [nsevent keyCode];
event->key.modifier_state = [nsevent clutterModifierState];
event->key.keyval = [nsevent clutterKeyVal];
event->key.unicode_value = ([nsevent type] == NSFlagsChanged)
? (gunichar)'\0'
: [[nsevent characters] characterAtIndex:0];
clutter_event_set_device (event, manager_osx->core_keyboard);
CLUTTER_NOTE (EVENT, "key %d (%s) (%s) %s, keyval %d",
[nsevent keyCode],
([nsevent type] == NSFlagsChanged) ? "NULL" : [[nsevent characters] UTF8String],
([nsevent type] == NSFlagsChanged) ? "NULL" : [[nsevent charactersIgnoringModifiers] UTF8String],
(event->type == CLUTTER_KEY_PRESS) ? "press" : "release",
event->key.keyval);
return TRUE;
default:
CLUTTER_NOTE (EVENT, "unhandled event %d", (int)[nsevent type]);
break;
}
return FALSE;
}
void
_clutter_event_osx_put (NSEvent *nsevent,
ClutterStage *wrapper)
{
ClutterEvent *event = clutter_event_new (CLUTTER_NOTHING);
/* common fields */
event->any.stage = wrapper;
event->any.time = [nsevent clutterTime];
if (clutter_event_osx_translate (nsevent, event))
{
g_assert (event->type != CLUTTER_NOTHING);
_clutter_event_push (event, FALSE);
}
else
clutter_event_free (event);
}
Reference in New Issue View Git Blame Copy Permalink