/*

Simple DirectMedia Layer

This software is provided 'as-is', without any express or implied

warranty. In no event will the authors be held liable for any damages

arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,

including commercial applications, and to alter it and redistribute it

freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not

claim that you wrote the original software. If you use this software

in a product, an acknowledgment in the product documentation would be

appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be

misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

*/

#include "SDL_config.h"

#if SDL_VIDEO_DRIVER_COCOA

#include "SDL_cocoavideo.h"

#include "../../events/SDL_keyboard_c.h"

#include "../../events/scancodes_darwin.h"

#include <Carbon/Carbon.h>

#define DEBUG_IME(...)

#ifndef NX_DEVICERCTLKEYMASK

#define NX_DEVICELCTLKEYMASK 0x00000001

#endif

#ifndef NX_DEVICELSHIFTKEYMASK

#define NX_DEVICELSHIFTKEYMASK 0x00000002

#endif

#ifndef NX_DEVICERSHIFTKEYMASK

#define NX_DEVICERSHIFTKEYMASK 0x00000004

#endif

#ifndef NX_DEVICELCMDKEYMASK

#define NX_DEVICELCMDKEYMASK 0x00000008

#endif

#ifndef NX_DEVICERCMDKEYMASK

#define NX_DEVICERCMDKEYMASK 0x00000010

#endif

#ifndef NX_DEVICELALTKEYMASK

#define NX_DEVICELALTKEYMASK 0x00000020

#endif

#ifndef NX_DEVICERALTKEYMASK

#define NX_DEVICERALTKEYMASK 0x00000040

#endif

#ifndef NX_DEVICERCTLKEYMASK

#define NX_DEVICERCTLKEYMASK 0x00002000

#endif

@interface SDLTranslatorResponder : NSView <NSTextInput>

{

NSString *_markedText;

NSRange _markedRange;

NSRange _selectedRange;

SDL_Rect _inputRect;

}

- (void) doCommandBySelector:(SEL)myselector;

- (void) setInputRect:(SDL_Rect *) rect;

@end

@implementation SDLTranslatorResponder

- (void) setInputRect:(SDL_Rect *) rect

{

_inputRect = *rect;

}

- (void) insertText:(id) aString

{

const char *str;

DEBUG_IME(@"insertText: %@", aString);

/* Could be NSString or NSAttributedString, so we have

* to test and convert it before return as SDL event */

if ([aString isKindOfClass: [NSAttributedString class]])

str = [[aString string] UTF8String];

else

str = [aString UTF8String];

SDL_SendKeyboardText(str);

}

- (void) doCommandBySelector:(SEL) myselector

{

/* No need to do anything since we are not using Cocoa

selectors to handle special keys, instead we use SDL

key events to do the same job.

*/

}

- (BOOL) hasMarkedText

{

return _markedText != nil;

}

- (NSRange) markedRange

{

return _markedRange;

}

- (NSRange) selectedRange

{

return _selectedRange;

}

- (void) setMarkedText:(id) aString

selectedRange:(NSRange) selRange

{

if ([aString isKindOfClass: [NSAttributedString class]])

aString = [aString string];

if ([aString length] == 0)

{

[self unmarkText];

return;

}

if (_markedText != aString)

{

[_markedText release];

_markedText = [aString retain];

}

_selectedRange = selRange;

_markedRange = NSMakeRange(0, [aString length]);

SDL_SendEditingText([aString UTF8String],

selRange.location, selRange.length);

DEBUG_IME(@"setMarkedText: %@, (%d, %d)", _markedText,

selRange.location, selRange.length);

}

- (void) unmarkText

{

[_markedText release];

_markedText = nil;

SDL_SendEditingText("", 0, 0);

}

- (NSRect) firstRectForCharacterRange: (NSRange) theRange

{

NSWindow *window = [self window];

NSRect contentRect = [window contentRectForFrameRect: [window frame]];

float windowHeight = contentRect.size.height;

NSRect rect = NSMakeRect(_inputRect.x, windowHeight - _inputRect.y - _inputRect.h,

_inputRect.w, _inputRect.h);

DEBUG_IME(@"firstRectForCharacterRange: (%d, %d): windowHeight = %g, rect = %@",

theRange.location, theRange.length, windowHeight,

NSStringFromRect(rect));

rect.origin = [[self window] convertBaseToScreen: rect.origin];

return rect;

}

- (NSAttributedString *) attributedSubstringFromRange: (NSRange) theRange

{

DEBUG_IME(@"attributedSubstringFromRange: (%d, %d)", theRange.location, theRange.length);

return nil;

}

- (NSInteger) conversationIdentifier

{

}

/* This method returns the index for character that is

* nearest to thePoint. thPoint is in screen coordinate system.

*/

- (NSUInteger) characterIndexForPoint:(NSPoint) thePoint

{

DEBUG_IME(@"characterIndexForPoint: (%g, %g)", thePoint.x, thePoint.y);

return 0;

}

/* This method is the key to attribute extension.

* We could add new attributes through this method.

* NSInputServer examines the return value of this

* method & constructs appropriate attributed string.

*/

- (NSArray *) validAttributesForMarkedText

{

return [NSArray array];

}

@end

* differentiating between left and right versions of the keys.

*/

static void

DoUnsidedModifiers(unsigned short scancode,

unsigned int oldMods, unsigned int newMods)

{

const int mapping[] = {

SDL_SCANCODE_CAPSLOCK,

SDL_SCANCODE_LSHIFT,

SDL_SCANCODE_LCTRL,

SDL_SCANCODE_LALT,

SDL_SCANCODE_LGUI

};

unsigned int i, bit;

/* Iterate through the bits, testing each against the current modifiers */

for (i = 0, bit = NSAlphaShiftKeyMask; bit <= NSCommandKeyMask; bit <<= 1, ++i) {

unsigned int oldMask, newMask;

oldMask = oldMods & bit;

newMask = newMods & bit;

if (oldMask && oldMask != newMask) { /* modifier up event */

/* If this was Caps Lock, we need some additional voodoo to make SDL happy */

if (bit == NSAlphaShiftKeyMask) {

SDL_SendKeyboardKey(SDL_PRESSED, mapping[i]);

}

SDL_SendKeyboardKey(SDL_RELEASED, mapping[i]);

} else if (newMask && oldMask != newMask) { /* modifier down event */

SDL_SendKeyboardKey(SDL_PRESSED, mapping[i]);

/* If this was Caps Lock, we need some additional voodoo to make SDL happy */

if (bit == NSAlphaShiftKeyMask) {

SDL_SendKeyboardKey(SDL_RELEASED, mapping[i]);

}

}

}

}

* function reverts back to behavior before the distinction between

* sides was made.

*/

static void

HandleNonDeviceModifier(unsigned int device_independent_mask,

unsigned int oldMods,

unsigned int newMods,

SDL_Scancode scancode)

{

unsigned int oldMask, newMask;

/* Isolate just the bits we care about in the depedent bits so we can

oldMask = oldMods & device_independent_mask;

newMask = newMods & device_independent_mask;

if (oldMask && oldMask != newMask) {

SDL_SendKeyboardKey(SDL_RELEASED, scancode);

} else if (newMask && oldMask != newMask) {

SDL_SendKeyboardKey(SDL_PRESSED, scancode);

}

}

* This function sets the actual SDL_PrivateKeyboard event.

*/

static void

HandleModifierOneSide(unsigned int oldMods, unsigned int newMods,

unsigned int sided_device_dependent_mask)

{

unsigned int old_dep_mask, new_dep_mask;

old_dep_mask = oldMods & sided_device_dependent_mask;

new_dep_mask = newMods & sided_device_dependent_mask;

/* We now know that this side bit flipped. But we don't know if

* find out which it is.

*/

if (new_dep_mask && old_dep_mask != new_dep_mask) {

SDL_SendKeyboardKey(SDL_PRESSED, scancode);

} else {

SDL_SendKeyboardKey(SDL_RELEASED, scancode);

}

}

/* This is a helper function for DoSidedModifiers.

* This function will figure out if the modifier key is the left or right side,

* e.g. left-shift vs right-shift.

*/

static void

HandleModifierSide(int device_independent_mask,

unsigned int oldMods, unsigned int newMods,

SDL_Scancode left_scancode,

unsigned int right_device_dependent_mask)

{

unsigned int device_dependent_mask = (left_device_dependent_mask |

right_device_dependent_mask);

unsigned int diff_mod;

/* On the basis that the device independent mask is set, but there are

* no device dependent flags set, we'll assume that we can't detect this

* keyboard and revert to the unsided behavior.

*/

if ((device_dependent_mask & newMods) == 0) {

/* Revert to the old behavior */

HandleNonDeviceModifier(device_independent_mask, oldMods, newMods, left_scancode);

return;

}

/* XOR the previous state against the new state to see if there's a change */

diff_mod = (device_dependent_mask & oldMods) ^

(device_dependent_mask & newMods);

if (diff_mod) {

* to handle them separately just in case the values can simulataneously

* change or if the bits don't both exist.

*/

if (left_device_dependent_mask & diff_mod) {

HandleModifierOneSide(oldMods, newMods, left_scancode, left_device_dependent_mask);

}

if (right_device_dependent_mask & diff_mod) {

HandleModifierOneSide(oldMods, newMods, right_scancode, right_device_dependent_mask);

}

}

}

* This function will release a key press in the case that

* it is clear that the modifier has been released (i.e. one side

* can't still be down).

*/

static void

unsigned int right_device_dependent_mask)

{

unsigned int device_dependent_mask = (left_device_dependent_mask |

right_device_dependent_mask);

/* On the basis that the device independent mask is set, but there are

* no device dependent flags set, we'll assume that we can't detect this

* keyboard and revert to the unsided behavior.

*/

if ((device_dependent_mask & oldMods) == 0) {

/* In this case, we can't detect the keyboard, so use the left side

* to represent both, and release it.

*/

SDL_SendKeyboardKey(SDL_RELEASED, left_scancode);

return;

}

* But I'm being paranoid so I want to handle each separately,

* so I hope this doesn't cause other problems.

*/

if ( left_device_dependent_mask & oldMods ) {

SDL_SendKeyboardKey(SDL_RELEASED, left_scancode);

}

if ( right_device_dependent_mask & oldMods ) {

SDL_SendKeyboardKey(SDL_RELEASED, right_scancode);

}

}

/* This is a helper function for DoSidedModifiers.

* This function handles the CapsLock case.

*/

static void

HandleCapsLock(unsigned short scancode,

unsigned int oldMods, unsigned int newMods)

{

unsigned int oldMask, newMask;

oldMask = oldMods & NSAlphaShiftKeyMask;

newMask = newMods & NSAlphaShiftKeyMask;

if (oldMask != newMask) {

SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_CAPSLOCK);

SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_CAPSLOCK);

}

oldMask = oldMods & NSNumericPadKeyMask;

newMask = newMods & NSNumericPadKeyMask;

if (oldMask != newMask) {

SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_NUMLOCKCLEAR);

SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_NUMLOCKCLEAR);

}

}

* correct side of the key.

*/

static void

DoSidedModifiers(unsigned short scancode,

unsigned int oldMods, unsigned int newMods)

{

const SDL_Scancode left_mapping[] = {

SDL_SCANCODE_LSHIFT,

SDL_SCANCODE_LCTRL,

SDL_SCANCODE_LALT,

SDL_SCANCODE_LGUI

};

const SDL_Scancode right_mapping[] = {

SDL_SCANCODE_RSHIFT,

SDL_SCANCODE_RCTRL,

SDL_SCANCODE_RALT,

SDL_SCANCODE_RGUI

};

/* Set up arrays for the device dependent masks with indices that

* correspond to the _mapping arrays

*/

const unsigned int left_device_mapping[] = { NX_DEVICELSHIFTKEYMASK, NX_DEVICELCTLKEYMASK, NX_DEVICELALTKEYMASK, NX_DEVICELCMDKEYMASK };

const unsigned int right_device_mapping[] = { NX_DEVICERSHIFTKEYMASK, NX_DEVICERCTLKEYMASK, NX_DEVICERALTKEYMASK, NX_DEVICERCMDKEYMASK };

unsigned int i, bit;

/* Handle CAPSLOCK separately because it doesn't have a left/right side */

HandleCapsLock(scancode, oldMods, newMods);

/* Iterate through the bits, testing each against the old modifiers */

for (i = 0, bit = NSShiftKeyMask; bit <= NSCommandKeyMask; bit <<= 1, ++i) {

unsigned int oldMask, newMask;

oldMask = oldMods & bit;

newMask = newMods & bit;

/* If the bit is set, we must always examine it because the left

* and right side keys may alternate or both may be pressed.

*/

if (newMask) {

HandleModifierSide(bit, oldMods, newMods,

left_mapping[i], right_mapping[i],

left_device_mapping[i], right_device_mapping[i]);

}

/* If the state changed from pressed to unpressed, we must examine

* the device dependent bits to release the correct keys.

*/

else if (oldMask && oldMask != newMask) {

ReleaseModifierSide(bit, oldMods, newMods,

left_mapping[i], right_mapping[i],

left_device_mapping[i], right_device_mapping[i]);

}

}

}

static void

HandleModifiers(_THIS, unsigned short scancode, unsigned int modifierFlags)

{

SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;

if (modifierFlags == data->modifierFlags) {

}

/*

* Starting with Panther (10.3.0), the ability to distinguish between

* left side and right side modifiers is available.

*/

if (data->osversion >= 0x1030) {

DoSidedModifiers(scancode, data->modifierFlags, modifierFlags);

} else {

DoUnsidedModifiers(scancode, data->modifierFlags, modifierFlags);

}

data->modifierFlags = modifierFlags;

}

static void

UpdateKeymap(SDL_VideoData *data)

{

TISInputSourceRef key_layout;

const void *chr_data;

int i;

SDL_Scancode scancode;

SDL_Keycode keymap[SDL_NUM_SCANCODES];

/* See if the keymap needs to be updated */

key_layout = TISCopyCurrentKeyboardLayoutInputSource();

if (key_layout == data->key_layout) {

return;

}

data->key_layout = key_layout;

SDL_GetDefaultKeymap(keymap);

CFDataRef uchrDataRef = TISGetInputSourceProperty(key_layout, kTISPropertyUnicodeKeyLayoutData);

if (uchrDataRef)

chr_data = CFDataGetBytePtr(uchrDataRef);

else

goto cleanup;

if (chr_data) {

UInt32 keyboard_type = LMGetKbdType();

OSStatus err;

for (i = 0; i < SDL_arraysize(darwin_scancode_table); i++) {

UniChar s[8];

UniCharCount len;

UInt32 dead_key_state;

/* Make sure this scancode is a valid character scancode */

scancode = darwin_scancode_table[i];

if (scancode == SDL_SCANCODE_UNKNOWN ||

(keymap[scancode] & SDLK_SCANCODE_MASK)) {

continue;

}

dead_key_state = 0;

err = UCKeyTranslate ((UCKeyboardLayout *) chr_data,

i, kUCKeyActionDown,

0, keyboard_type,

kUCKeyTranslateNoDeadKeysMask,

&dead_key_state, 8, &len, s);

if (err != noErr)

continue;

if (len > 0 && s[0] != 0x10) {

keymap[scancode] = s[0];

}

}

SDL_SetKeymap(0, keymap, SDL_NUM_SCANCODES);

return;

}

cleanup:

CFRelease(key_layout);

}

void

Cocoa_InitKeyboard(_THIS)

{

SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;

UpdateKeymap(data);

/* Set our own names for the platform-dependent but layout-independent keys */

/* This key is NumLock on the MacBook keyboard. :) */

/*SDL_SetScancodeName(SDL_SCANCODE_NUMLOCKCLEAR, "Clear");*/

SDL_SetScancodeName(SDL_SCANCODE_LALT, "Left Option");

SDL_SetScancodeName(SDL_SCANCODE_LGUI, "Left Command");

SDL_SetScancodeName(SDL_SCANCODE_RALT, "Right Option");

SDL_SetScancodeName(SDL_SCANCODE_RGUI, "Right Command");

}

void

Cocoa_StartTextInput(_THIS)

{

SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

NSView *parentView = [[NSApp keyWindow] contentView];

/* We only keep one field editor per process, since only the front most

* window can receive text input events, so it make no sense to keep more

* than one copy. When we switched to another window and requesting for

* text input, simply remove the field editor from its superview then add

* it to the front most window's content view */

if (!data->fieldEdit) {

data->fieldEdit =

[[SDLTranslatorResponder alloc] initWithFrame: NSMakeRect(0.0, 0.0, 0.0, 0.0)];

}

if (![[data->fieldEdit superview] isEqual: parentView])

{

[data->fieldEdit removeFromSuperview];

[parentView addSubview: data->fieldEdit];

[[NSApp keyWindow] makeFirstResponder: data->fieldEdit];

[pool release];

}

void

Cocoa_StopTextInput(_THIS)

{

SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;

if (data && data->fieldEdit) {

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

[data->fieldEdit removeFromSuperview];

[data->fieldEdit release];

data->fieldEdit = nil;

[pool release];

}

}

void

Cocoa_SetTextInputRect(_THIS, SDL_Rect *rect)

{

SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;

SDL_InvalidParamError("rect");

return;

}

[data->fieldEdit setInputRect: rect];

}

void

Cocoa_HandleKeyEvent(_THIS, NSEvent *event)

{

SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;

unsigned short scancode = [event keyCode];

SDL_Scancode code;

#if 0

const char *text;

#endif

if ((scancode == 10 || scancode == 50) && KBGetLayoutType(LMGetKbdType()) == kKeyboardISO) {

/* see comments in SDL_cocoakeys.h */

scancode = 60 - scancode;

}

if (scancode < SDL_arraysize(darwin_scancode_table)) {

code = darwin_scancode_table[scancode];

}

else {

/* Hmm, does this ever happen? If so, need to extend the keymap... */

code = SDL_SCANCODE_UNKNOWN;

}

switch ([event type]) {

case NSKeyDown:

if (![event isARepeat]) {

/* See if we need to rebuild the keyboard layout */

UpdateKeymap(data);

}

SDL_SendKeyboardKey(SDL_PRESSED, code);

#if 1

if (code == SDL_SCANCODE_UNKNOWN) {

fprintf(stderr, "The key you just pressed is not recognized by SDL. To help get this fixed, report this to the SDL mailing list <sdl@libsdl.org> or to Christian Walther <cwalther@gmx.ch>. Mac virtual key code is %d.\n", scancode);

}

#endif

if (SDL_EventState(SDL_TEXTINPUT, SDL_QUERY)) {

/* FIXME CW 2007-08-16: only send those events to the field editor for which we actually want text events, not e.g. esc or function keys. Arrow keys in particular seem to produce crashes sometimes. */

[data->fieldEdit interpretKeyEvents:[NSArray arrayWithObject:event]];

#if 0

text = [[event characters] UTF8String];

if(text && *text) {

SDL_SendKeyboardText(text);

[data->fieldEdit setString:@""];

}

#endif

}

break;

case NSKeyUp:

SDL_SendKeyboardKey(SDL_RELEASED, code);

break;

case NSFlagsChanged:

/* FIXME CW 2007-08-14: check if this whole mess that takes up half of this file is really necessary */

HandleModifiers(_this, scancode, [event modifierFlags]);

break;

default: /* just to avoid compiler warnings */

break;

}

}

void

Cocoa_QuitKeyboard(_THIS)

{

}

#endif /* SDL_VIDEO_DRIVER_COCOA */

/* vi: set ts=4 sw=4 expandtab: */