sdl-ios-xcode: src/video/cocoa/SDL_cocoakeyboard.m comparison

comparison src/video/cocoa/SDL_cocoakeyboard.m @ 4465:3e69e077cb95

Removed multi-mouse / multi-keyboard support in anticipation of a real multi-mouse and multi-touch API. Plus, this lets me start implementing cursor support.

author	Sam Lantinga <slouken@libsdl.org>
date	Sun, 09 May 2010 20:47:22 -0700
parents	d3c193100522
children	3d91e31fcf71

comparison

equal deleted inserted replaced

-:fa77a6429698
+:3e69e077cb95
 {
 NSString *_markedText;
 NSRange   _markedRange;
 NSRange   _selectedRange;
 SDL_Rect  _inputRect;
-int       _keyboard;
 }
 - (void) doCommandBySelector:(SEL)myselector;
 - (void) setInputRect:(SDL_Rect *) rect;
-- (void) setKeyboard:(int) keyboard;
 @end
 @implementation SDLTranslatorResponder
-- (void) setKeyboard:(int) keyboard
-{
-_keyboard = keyboard;
-}
 - (void) setInputRect:(SDL_Rect *) rect
 {
 _inputRect = *rect;
 }
 if ([aString isKindOfClass: [NSAttributedString class]])
 str = [[aString string] UTF8String];
 else
 str = [aString UTF8String];
-SDL_SendKeyboardText(_keyboard, str);
+SDL_SendKeyboardText(str);
 }
 - (void) doCommandBySelector:(SEL) myselector
 {
 // No need to do anything since we are not using Cocoa
 }
 _selectedRange = selRange;
 _markedRange = NSMakeRange(0, [aString length]);
-SDL_SendEditingText(_keyboard, [aString UTF8String],
+SDL_SendEditingText([aString UTF8String],
 selRange.location, selRange.length);
 DEBUG_IME(@"setMarkedText: %@, (%d, %d)", _markedText,
 selRange.location, selRange.length);
 }
 /* This is the original behavior, before support was added for
 * differentiating between left and right versions of the keys.
 */
 static void
-DoUnsidedModifiers(int keyboard, unsigned short scancode,
+DoUnsidedModifiers(unsigned short scancode,
 unsigned int oldMods, unsigned int newMods)
 {
 const int mapping[] = {
 SDL_SCANCODE_CAPSLOCK,
 SDL_SCANCODE_LSHIFT,
 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(keyboard, SDL_PRESSED, mapping[i]);
+SDL_SendKeyboardKey(SDL_PRESSED, mapping[i]);
 }
-SDL_SendKeyboardKey(keyboard, SDL_RELEASED, mapping[i]);
+SDL_SendKeyboardKey(SDL_RELEASED, mapping[i]);
 } else if (newMask && oldMask != newMask) { /* modifier down event */
-SDL_SendKeyboardKey(keyboard, SDL_PRESSED, mapping[i]);
+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(keyboard, SDL_RELEASED, mapping[i]);
+SDL_SendKeyboardKey(SDL_RELEASED, mapping[i]);
 }
 }
 }
 }
 /* This is a helper function for HandleModifierSide. This
 * function reverts back to behavior before the distinction between
 * sides was made.
 */
 static void
-HandleNonDeviceModifier(int keyboard,
+HandleNonDeviceModifier(unsigned int device_independent_mask,
-unsigned int device_independent_mask,
 unsigned int oldMods,
 unsigned int newMods,
 SDL_scancode scancode)
 {
 unsigned int oldMask, newMask;
 */
 oldMask = oldMods & device_independent_mask;
 newMask = newMods & device_independent_mask;
 if (oldMask && oldMask != newMask) {
-SDL_SendKeyboardKey(keyboard, SDL_RELEASED, scancode);
+SDL_SendKeyboardKey(SDL_RELEASED, scancode);
 } else if (newMask && oldMask != newMask) {
-SDL_SendKeyboardKey(keyboard, SDL_PRESSED, scancode);
+SDL_SendKeyboardKey(SDL_PRESSED, scancode);
 }
 }
 /* This is a helper function for HandleModifierSide.
 * This function sets the actual SDL_PrivateKeyboard event.
 */
 static void
-HandleModifierOneSide(int keyboard,
+HandleModifierOneSide(unsigned int oldMods, unsigned int newMods,
-unsigned int oldMods, unsigned int newMods,
 SDL_scancode scancode,
 unsigned int sided_device_dependent_mask)
 {
 unsigned int old_dep_mask, new_dep_mask;
 /* We now know that this side bit flipped. But we don't know if
 * it went pressed to released or released to pressed, so we must
 * find out which it is.
 */
 if (new_dep_mask && old_dep_mask != new_dep_mask) {
-SDL_SendKeyboardKey(keyboard, SDL_PRESSED, scancode);
+SDL_SendKeyboardKey(SDL_PRESSED, scancode);
 } else {
-SDL_SendKeyboardKey(keyboard, SDL_RELEASED, scancode);
+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 keyboard,
+HandleModifierSide(int device_independent_mask,
-int device_independent_mask,
 unsigned int oldMods, unsigned int newMods,
 SDL_scancode left_scancode,
 SDL_scancode right_scancode,
 unsigned int left_device_dependent_mask,
 unsigned int right_device_dependent_mask)
 * 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(keyboard, device_independent_mask, oldMods, newMods, left_scancode);
+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) ^
 /* A change in state was found. Isolate the left and right bits
 * 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(keyboard, oldMods, newMods, left_scancode, left_device_dependent_mask);
+HandleModifierOneSide(oldMods, newMods, left_scancode, left_device_dependent_mask);
 }
 if (right_device_dependent_mask & diff_mod) {
-HandleModifierOneSide(keyboard, oldMods, newMods, right_scancode, right_device_dependent_mask);
+HandleModifierOneSide(oldMods, newMods, right_scancode, right_device_dependent_mask);
 }
 }
 }
 /* This is a helper function for DoSidedModifiers.
 * 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
-ReleaseModifierSide(int keyboard,
+ReleaseModifierSide(unsigned int device_independent_mask,
-unsigned int device_independent_mask,
 unsigned int oldMods, unsigned int newMods,
 SDL_scancode left_scancode,
 SDL_scancode right_scancode,
 unsigned int left_device_dependent_mask,
 unsigned int right_device_dependent_mask)
 */
 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(keyboard, SDL_RELEASED, left_scancode);
+SDL_SendKeyboardKey(SDL_RELEASED, left_scancode);
 return;
 }
 /*
 * This could have been done in an if-else case because at this point,
 * we know that all keys have been released when calling this function.
 * 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(keyboard, SDL_RELEASED, left_scancode);
+SDL_SendKeyboardKey(SDL_RELEASED, left_scancode);
 }
 if ( right_device_dependent_mask & oldMods ) {
-SDL_SendKeyboardKey(keyboard, SDL_RELEASED, right_scancode);
+SDL_SendKeyboardKey(SDL_RELEASED, right_scancode);
 }
 }
 /* This is a helper function for DoSidedModifiers.
 * This function handles the CapsLock case.
 */
 static void
-HandleCapsLock(int keyboard, unsigned short scancode,
+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(keyboard, SDL_PRESSED, SDL_SCANCODE_CAPSLOCK);
+SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_CAPSLOCK);
-SDL_SendKeyboardKey(keyboard, SDL_RELEASED, SDL_SCANCODE_CAPSLOCK);
+SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_CAPSLOCK);
 }
 oldMask = oldMods & NSNumericPadKeyMask;
 newMask = newMods & NSNumericPadKeyMask;
 if (oldMask != newMask) {
-SDL_SendKeyboardKey(keyboard, SDL_PRESSED, SDL_SCANCODE_NUMLOCKCLEAR);
+SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_NUMLOCKCLEAR);
-SDL_SendKeyboardKey(keyboard, SDL_RELEASED, SDL_SCANCODE_NUMLOCKCLEAR);
+SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_NUMLOCKCLEAR);
 }
 }
 /* This function will handle the modifier keys and also determine the
 * correct side of the key.
 */
 static void
-DoSidedModifiers(int keyboard, unsigned short scancode,
+DoSidedModifiers(unsigned short scancode,
 unsigned int oldMods, unsigned int newMods)
 {
 	/* Set up arrays for the key syms for the left and right side. */
 const SDL_scancode left_mapping[]  = {
 SDL_SCANCODE_LSHIFT,
 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(keyboard, scancode, oldMods, newMods);
+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;
 /* 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(keyboard, bit, oldMods, newMods,
+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(keyboard, bit, oldMods, newMods,
+ReleaseModifierSide(bit, oldMods, newMods,
 left_mapping[i], right_mapping[i],
 left_device_mapping[i], right_device_mapping[i]);
 }
 }
 }
 /*
 * Starting with Panther (10.3.0), the ability to distinguish between
 * left side and right side modifiers is available.
 */
 if (data->osversion >= 0x1030) {
-DoSidedModifiers(data->keyboard, scancode, data->modifierFlags, modifierFlags);
+DoSidedModifiers(scancode, data->modifierFlags, modifierFlags);
 } else {
-DoUnsidedModifiers(data->keyboard, scancode, data->modifierFlags, modifierFlags);
+DoUnsidedModifiers(scancode, data->modifierFlags, modifierFlags);
 }
 data->modifierFlags = modifierFlags;
 }
 static void
 if (len > 0 && s[0] != 0x10) {
 keymap[scancode] = s[0];
 }
 }
-SDL_SetKeymap(data->keyboard, 0, keymap, SDL_NUM_SCANCODES);
+SDL_SetKeymap(0, keymap, SDL_NUM_SCANCODES);
 return;
 }
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1050
 cleanup:
 c = macroman_table[c - 128];
 }
 keymap[scancode] = c;
 }
 }
-SDL_SetKeymap(data->keyboard, 0, keymap, SDL_NUM_SCANCODES);
+SDL_SetKeymap(0, keymap, SDL_NUM_SCANCODES);
 return;
 }
 #endif
 }
 void
 Cocoa_InitKeyboard(_THIS)
 {
 SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
-SDL_Keyboard keyboard;
-SDL_zero(keyboard);
-data->keyboard = SDL_AddKeyboard(&keyboard, -1);
 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");*/
 if (!data->fieldEdit) {
 data->fieldEdit =
 [[SDLTranslatorResponder alloc] initWithFrame: NSMakeRect(0.0, 0.0, 0.0, 0.0)];
 }
-[data->fieldEdit setKeyboard: data->keyboard];
 if (![[data->fieldEdit superview] isEqual: parentView])
 {
 // DEBUG_IME(@"add fieldEdit to window contentView");
 [data->fieldEdit removeFromSuperview];
 [parentView addSubview: data->fieldEdit];
 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;
 }
 case NSKeyDown:
 if (![event isARepeat]) {
 /* See if we need to rebuild the keyboard layout */
 UpdateKeymap(data);
-SDL_SendKeyboardKey(data->keyboard, SDL_PRESSED, code);
+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
 /* 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(data->keyboard, text);
+SDL_SendKeyboardText(text);
 [data->fieldEdit setString:@""];
 }
 #endif
 }
 break;
 case NSKeyUp:
-SDL_SendKeyboardKey(data->keyboard, SDL_RELEASED, code);
+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;
 }
 void
 Cocoa_QuitKeyboard(_THIS)
 {
-SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
-NSAutoreleasePool *pool;
-SDL_DelKeyboard(data->keyboard);
 }
 /* vi: set ts=4 sw=4 expandtab: */

Mercurial > sdl-ios-xcode

comparison src/video/cocoa/SDL_cocoakeyboard.m @ 4465:3e69e077cb95