src/video/cocoa/SDL_cocoakeyboard.m
changeset 4465 3e69e077cb95
parent 4436 d3c193100522
child 4498 3d91e31fcf71
equal deleted inserted replaced
4464:fa77a6429698 4465:3e69e077cb95
    60 {
    60 {
    61     NSString *_markedText;
    61     NSString *_markedText;
    62     NSRange   _markedRange;
    62     NSRange   _markedRange;
    63     NSRange   _selectedRange;
    63     NSRange   _selectedRange;
    64     SDL_Rect  _inputRect;
    64     SDL_Rect  _inputRect;
    65     int       _keyboard;
       
    66 }
    65 }
    67 - (void) doCommandBySelector:(SEL)myselector;
    66 - (void) doCommandBySelector:(SEL)myselector;
    68 - (void) setInputRect:(SDL_Rect *) rect;
    67 - (void) setInputRect:(SDL_Rect *) rect;
    69 - (void) setKeyboard:(int) keyboard;
       
    70 @end
    68 @end
    71 
    69 
    72 @implementation SDLTranslatorResponder
    70 @implementation SDLTranslatorResponder
    73 
       
    74 - (void) setKeyboard:(int) keyboard
       
    75 {
       
    76     _keyboard = keyboard;
       
    77 }
       
    78 
    71 
    79 - (void) setInputRect:(SDL_Rect *) rect
    72 - (void) setInputRect:(SDL_Rect *) rect
    80 {
    73 {
    81     _inputRect = *rect;
    74     _inputRect = *rect;
    82 }
    75 }
    92     if ([aString isKindOfClass: [NSAttributedString class]])
    85     if ([aString isKindOfClass: [NSAttributedString class]])
    93         str = [[aString string] UTF8String];
    86         str = [[aString string] UTF8String];
    94     else
    87     else
    95         str = [aString UTF8String];
    88         str = [aString UTF8String];
    96 
    89 
    97     SDL_SendKeyboardText(_keyboard, str);
    90     SDL_SendKeyboardText(str);
    98 }
    91 }
    99 
    92 
   100 - (void) doCommandBySelector:(SEL) myselector
    93 - (void) doCommandBySelector:(SEL) myselector
   101 {
    94 {
   102     // No need to do anything since we are not using Cocoa
    95     // No need to do anything since we are not using Cocoa
   138     }
   131     }
   139 
   132 
   140     _selectedRange = selRange;
   133     _selectedRange = selRange;
   141     _markedRange = NSMakeRange(0, [aString length]);
   134     _markedRange = NSMakeRange(0, [aString length]);
   142 
   135 
   143     SDL_SendEditingText(_keyboard, [aString UTF8String],
   136     SDL_SendEditingText([aString UTF8String],
   144                         selRange.location, selRange.length);
   137                         selRange.location, selRange.length);
   145 
   138 
   146     DEBUG_IME(@"setMarkedText: %@, (%d, %d)", _markedText,
   139     DEBUG_IME(@"setMarkedText: %@, (%d, %d)", _markedText,
   147           selRange.location, selRange.length);
   140           selRange.location, selRange.length);
   148 }
   141 }
   202 
   195 
   203 /* This is the original behavior, before support was added for 
   196 /* This is the original behavior, before support was added for 
   204  * differentiating between left and right versions of the keys.
   197  * differentiating between left and right versions of the keys.
   205  */
   198  */
   206 static void
   199 static void
   207 DoUnsidedModifiers(int keyboard, unsigned short scancode,
   200 DoUnsidedModifiers(unsigned short scancode,
   208                    unsigned int oldMods, unsigned int newMods)
   201                    unsigned int oldMods, unsigned int newMods)
   209 {
   202 {
   210     const int mapping[] = {
   203     const int mapping[] = {
   211         SDL_SCANCODE_CAPSLOCK,
   204         SDL_SCANCODE_CAPSLOCK,
   212         SDL_SCANCODE_LSHIFT,
   205         SDL_SCANCODE_LSHIFT,
   224         newMask = newMods & bit;
   217         newMask = newMods & bit;
   225 
   218 
   226         if (oldMask && oldMask != newMask) {        /* modifier up event */
   219         if (oldMask && oldMask != newMask) {        /* modifier up event */
   227             /* If this was Caps Lock, we need some additional voodoo to make SDL happy */
   220             /* If this was Caps Lock, we need some additional voodoo to make SDL happy */
   228             if (bit == NSAlphaShiftKeyMask) {
   221             if (bit == NSAlphaShiftKeyMask) {
   229                 SDL_SendKeyboardKey(keyboard, SDL_PRESSED, mapping[i]);
   222                 SDL_SendKeyboardKey(SDL_PRESSED, mapping[i]);
   230             }
   223             }
   231             SDL_SendKeyboardKey(keyboard, SDL_RELEASED, mapping[i]);
   224             SDL_SendKeyboardKey(SDL_RELEASED, mapping[i]);
   232         } else if (newMask && oldMask != newMask) { /* modifier down event */
   225         } else if (newMask && oldMask != newMask) { /* modifier down event */
   233             SDL_SendKeyboardKey(keyboard, SDL_PRESSED, mapping[i]);
   226             SDL_SendKeyboardKey(SDL_PRESSED, mapping[i]);
   234             /* If this was Caps Lock, we need some additional voodoo to make SDL happy */
   227             /* If this was Caps Lock, we need some additional voodoo to make SDL happy */
   235             if (bit == NSAlphaShiftKeyMask) {
   228             if (bit == NSAlphaShiftKeyMask) {
   236                 SDL_SendKeyboardKey(keyboard, SDL_RELEASED, mapping[i]);
   229                 SDL_SendKeyboardKey(SDL_RELEASED, mapping[i]);
   237             }
   230             }
   238         }
   231         }
   239     }
   232     }
   240 }
   233 }
   241 
   234 
   242 /* This is a helper function for HandleModifierSide. This 
   235 /* This is a helper function for HandleModifierSide. This 
   243  * function reverts back to behavior before the distinction between
   236  * function reverts back to behavior before the distinction between
   244  * sides was made.
   237  * sides was made.
   245  */
   238  */
   246 static void
   239 static void
   247 HandleNonDeviceModifier(int keyboard,
   240 HandleNonDeviceModifier(unsigned int device_independent_mask,
   248                         unsigned int device_independent_mask,
       
   249                         unsigned int oldMods,
   241                         unsigned int oldMods,
   250                         unsigned int newMods,
   242                         unsigned int newMods,
   251                         SDL_scancode scancode)
   243                         SDL_scancode scancode)
   252 {
   244 {
   253     unsigned int oldMask, newMask;
   245     unsigned int oldMask, newMask;
   257      */ 
   249      */ 
   258     oldMask = oldMods & device_independent_mask;
   250     oldMask = oldMods & device_independent_mask;
   259     newMask = newMods & device_independent_mask;
   251     newMask = newMods & device_independent_mask;
   260     
   252     
   261     if (oldMask && oldMask != newMask) {
   253     if (oldMask && oldMask != newMask) {
   262         SDL_SendKeyboardKey(keyboard, SDL_RELEASED, scancode);
   254         SDL_SendKeyboardKey(SDL_RELEASED, scancode);
   263     } else if (newMask && oldMask != newMask) {
   255     } else if (newMask && oldMask != newMask) {
   264         SDL_SendKeyboardKey(keyboard, SDL_PRESSED, scancode);
   256         SDL_SendKeyboardKey(SDL_PRESSED, scancode);
   265     }
   257     }
   266 }
   258 }
   267 
   259 
   268 /* This is a helper function for HandleModifierSide. 
   260 /* This is a helper function for HandleModifierSide. 
   269  * This function sets the actual SDL_PrivateKeyboard event.
   261  * This function sets the actual SDL_PrivateKeyboard event.
   270  */
   262  */
   271 static void
   263 static void
   272 HandleModifierOneSide(int keyboard,
   264 HandleModifierOneSide(unsigned int oldMods, unsigned int newMods,
   273                       unsigned int oldMods, unsigned int newMods,
       
   274                       SDL_scancode scancode, 
   265                       SDL_scancode scancode, 
   275                       unsigned int sided_device_dependent_mask)
   266                       unsigned int sided_device_dependent_mask)
   276 {
   267 {
   277     unsigned int old_dep_mask, new_dep_mask;
   268     unsigned int old_dep_mask, new_dep_mask;
   278 
   269 
   285     /* We now know that this side bit flipped. But we don't know if
   276     /* We now know that this side bit flipped. But we don't know if
   286      * it went pressed to released or released to pressed, so we must 
   277      * it went pressed to released or released to pressed, so we must 
   287      * find out which it is.
   278      * find out which it is.
   288      */
   279      */
   289     if (new_dep_mask && old_dep_mask != new_dep_mask) {
   280     if (new_dep_mask && old_dep_mask != new_dep_mask) {
   290         SDL_SendKeyboardKey(keyboard, SDL_PRESSED, scancode);
   281         SDL_SendKeyboardKey(SDL_PRESSED, scancode);
   291     } else {
   282     } else {
   292         SDL_SendKeyboardKey(keyboard, SDL_RELEASED, scancode);
   283         SDL_SendKeyboardKey(SDL_RELEASED, scancode);
   293     }
   284     }
   294 }
   285 }
   295 
   286 
   296 /* This is a helper function for DoSidedModifiers.
   287 /* This is a helper function for DoSidedModifiers.
   297  * This function will figure out if the modifier key is the left or right side, 
   288  * This function will figure out if the modifier key is the left or right side, 
   298  * e.g. left-shift vs right-shift. 
   289  * e.g. left-shift vs right-shift. 
   299  */
   290  */
   300 static void
   291 static void
   301 HandleModifierSide(int keyboard,
   292 HandleModifierSide(int device_independent_mask, 
   302                    int device_independent_mask, 
       
   303                    unsigned int oldMods, unsigned int newMods, 
   293                    unsigned int oldMods, unsigned int newMods, 
   304                    SDL_scancode left_scancode, 
   294                    SDL_scancode left_scancode, 
   305                    SDL_scancode right_scancode,
   295                    SDL_scancode right_scancode,
   306                    unsigned int left_device_dependent_mask, 
   296                    unsigned int left_device_dependent_mask, 
   307                    unsigned int right_device_dependent_mask)
   297                    unsigned int right_device_dependent_mask)
   314      * no device dependent flags set, we'll assume that we can't detect this 
   304      * no device dependent flags set, we'll assume that we can't detect this 
   315      * keyboard and revert to the unsided behavior.
   305      * keyboard and revert to the unsided behavior.
   316      */
   306      */
   317     if ((device_dependent_mask & newMods) == 0) {
   307     if ((device_dependent_mask & newMods) == 0) {
   318         /* Revert to the old behavior */
   308         /* Revert to the old behavior */
   319         HandleNonDeviceModifier(keyboard, device_independent_mask, oldMods, newMods, left_scancode);
   309         HandleNonDeviceModifier(device_independent_mask, oldMods, newMods, left_scancode);
   320         return;
   310         return;
   321     }
   311     }
   322 
   312 
   323     /* XOR the previous state against the new state to see if there's a change */
   313     /* XOR the previous state against the new state to see if there's a change */
   324     diff_mod = (device_dependent_mask & oldMods) ^
   314     diff_mod = (device_dependent_mask & oldMods) ^
   327         /* A change in state was found. Isolate the left and right bits 
   317         /* A change in state was found. Isolate the left and right bits 
   328          * to handle them separately just in case the values can simulataneously
   318          * to handle them separately just in case the values can simulataneously
   329          * change or if the bits don't both exist.
   319          * change or if the bits don't both exist.
   330          */
   320          */
   331         if (left_device_dependent_mask & diff_mod) {
   321         if (left_device_dependent_mask & diff_mod) {
   332             HandleModifierOneSide(keyboard, oldMods, newMods, left_scancode, left_device_dependent_mask);
   322             HandleModifierOneSide(oldMods, newMods, left_scancode, left_device_dependent_mask);
   333         }
   323         }
   334         if (right_device_dependent_mask & diff_mod) {
   324         if (right_device_dependent_mask & diff_mod) {
   335             HandleModifierOneSide(keyboard, oldMods, newMods, right_scancode, right_device_dependent_mask);
   325             HandleModifierOneSide(oldMods, newMods, right_scancode, right_device_dependent_mask);
   336         }
   326         }
   337     }
   327     }
   338 }
   328 }
   339    
   329    
   340 /* This is a helper function for DoSidedModifiers.
   330 /* This is a helper function for DoSidedModifiers.
   341  * This function will release a key press in the case that 
   331  * This function will release a key press in the case that 
   342  * it is clear that the modifier has been released (i.e. one side 
   332  * it is clear that the modifier has been released (i.e. one side 
   343  * can't still be down).
   333  * can't still be down).
   344  */
   334  */
   345 static void
   335 static void
   346 ReleaseModifierSide(int keyboard,
   336 ReleaseModifierSide(unsigned int device_independent_mask, 
   347                     unsigned int device_independent_mask, 
       
   348                     unsigned int oldMods, unsigned int newMods,
   337                     unsigned int oldMods, unsigned int newMods,
   349                     SDL_scancode left_scancode, 
   338                     SDL_scancode left_scancode, 
   350                     SDL_scancode right_scancode,
   339                     SDL_scancode right_scancode,
   351                     unsigned int left_device_dependent_mask, 
   340                     unsigned int left_device_dependent_mask, 
   352                     unsigned int right_device_dependent_mask)
   341                     unsigned int right_device_dependent_mask)
   360      */
   349      */
   361     if ((device_dependent_mask & oldMods) == 0) {
   350     if ((device_dependent_mask & oldMods) == 0) {
   362         /* In this case, we can't detect the keyboard, so use the left side 
   351         /* In this case, we can't detect the keyboard, so use the left side 
   363          * to represent both, and release it. 
   352          * to represent both, and release it. 
   364          */
   353          */
   365         SDL_SendKeyboardKey(keyboard, SDL_RELEASED, left_scancode);
   354         SDL_SendKeyboardKey(SDL_RELEASED, left_scancode);
   366         return;
   355         return;
   367     }
   356     }
   368 
   357 
   369     /* 
   358     /* 
   370      * This could have been done in an if-else case because at this point,
   359      * This could have been done in an if-else case because at this point,
   371      * we know that all keys have been released when calling this function. 
   360      * we know that all keys have been released when calling this function. 
   372      * But I'm being paranoid so I want to handle each separately,
   361      * But I'm being paranoid so I want to handle each separately,
   373      * so I hope this doesn't cause other problems.
   362      * so I hope this doesn't cause other problems.
   374      */
   363      */
   375     if ( left_device_dependent_mask & oldMods ) {
   364     if ( left_device_dependent_mask & oldMods ) {
   376         SDL_SendKeyboardKey(keyboard, SDL_RELEASED, left_scancode);
   365         SDL_SendKeyboardKey(SDL_RELEASED, left_scancode);
   377     }
   366     }
   378     if ( right_device_dependent_mask & oldMods ) {
   367     if ( right_device_dependent_mask & oldMods ) {
   379         SDL_SendKeyboardKey(keyboard, SDL_RELEASED, right_scancode);
   368         SDL_SendKeyboardKey(SDL_RELEASED, right_scancode);
   380     }
   369     }
   381 }
   370 }
   382 
   371 
   383 /* This is a helper function for DoSidedModifiers.
   372 /* This is a helper function for DoSidedModifiers.
   384  * This function handles the CapsLock case.
   373  * This function handles the CapsLock case.
   385  */
   374  */
   386 static void
   375 static void
   387 HandleCapsLock(int keyboard, unsigned short scancode,
   376 HandleCapsLock(unsigned short scancode,
   388                unsigned int oldMods, unsigned int newMods)
   377                unsigned int oldMods, unsigned int newMods)
   389 {
   378 {
   390     unsigned int oldMask, newMask;
   379     unsigned int oldMask, newMask;
   391     
   380     
   392     oldMask = oldMods & NSAlphaShiftKeyMask;
   381     oldMask = oldMods & NSAlphaShiftKeyMask;
   393     newMask = newMods & NSAlphaShiftKeyMask;
   382     newMask = newMods & NSAlphaShiftKeyMask;
   394 
   383 
   395     if (oldMask != newMask) {
   384     if (oldMask != newMask) {
   396         SDL_SendKeyboardKey(keyboard, SDL_PRESSED, SDL_SCANCODE_CAPSLOCK);
   385         SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_CAPSLOCK);
   397         SDL_SendKeyboardKey(keyboard, SDL_RELEASED, SDL_SCANCODE_CAPSLOCK);
   386         SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_CAPSLOCK);
   398     }
   387     }
   399 
   388 
   400     oldMask = oldMods & NSNumericPadKeyMask;
   389     oldMask = oldMods & NSNumericPadKeyMask;
   401     newMask = newMods & NSNumericPadKeyMask;
   390     newMask = newMods & NSNumericPadKeyMask;
   402 
   391 
   403     if (oldMask != newMask) {
   392     if (oldMask != newMask) {
   404         SDL_SendKeyboardKey(keyboard, SDL_PRESSED, SDL_SCANCODE_NUMLOCKCLEAR);
   393         SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_NUMLOCKCLEAR);
   405         SDL_SendKeyboardKey(keyboard, SDL_RELEASED, SDL_SCANCODE_NUMLOCKCLEAR);
   394         SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_NUMLOCKCLEAR);
   406     }
   395     }
   407 }
   396 }
   408 
   397 
   409 /* This function will handle the modifier keys and also determine the 
   398 /* This function will handle the modifier keys and also determine the 
   410  * correct side of the key.
   399  * correct side of the key.
   411  */
   400  */
   412 static void
   401 static void
   413 DoSidedModifiers(int keyboard, unsigned short scancode,
   402 DoSidedModifiers(unsigned short scancode,
   414                  unsigned int oldMods, unsigned int newMods)
   403                  unsigned int oldMods, unsigned int newMods)
   415 {
   404 {
   416 	/* Set up arrays for the key syms for the left and right side. */
   405 	/* Set up arrays for the key syms for the left and right side. */
   417     const SDL_scancode left_mapping[]  = {
   406     const SDL_scancode left_mapping[]  = {
   418         SDL_SCANCODE_LSHIFT,
   407         SDL_SCANCODE_LSHIFT,
   433     const unsigned int right_device_mapping[] = { NX_DEVICERSHIFTKEYMASK, NX_DEVICERCTLKEYMASK, NX_DEVICERALTKEYMASK, NX_DEVICERCMDKEYMASK };
   422     const unsigned int right_device_mapping[] = { NX_DEVICERSHIFTKEYMASK, NX_DEVICERCTLKEYMASK, NX_DEVICERALTKEYMASK, NX_DEVICERCMDKEYMASK };
   434 
   423 
   435     unsigned int i, bit;
   424     unsigned int i, bit;
   436 
   425 
   437     /* Handle CAPSLOCK separately because it doesn't have a left/right side */
   426     /* Handle CAPSLOCK separately because it doesn't have a left/right side */
   438     HandleCapsLock(keyboard, scancode, oldMods, newMods);
   427     HandleCapsLock(scancode, oldMods, newMods);
   439 
   428 
   440     /* Iterate through the bits, testing each against the old modifiers */
   429     /* Iterate through the bits, testing each against the old modifiers */
   441     for (i = 0, bit = NSShiftKeyMask; bit <= NSCommandKeyMask; bit <<= 1, ++i) {
   430     for (i = 0, bit = NSShiftKeyMask; bit <= NSCommandKeyMask; bit <<= 1, ++i) {
   442         unsigned int oldMask, newMask;
   431         unsigned int oldMask, newMask;
   443 		
   432 		
   446 		
   435 		
   447         /* If the bit is set, we must always examine it because the left
   436         /* If the bit is set, we must always examine it because the left
   448          * and right side keys may alternate or both may be pressed.
   437          * and right side keys may alternate or both may be pressed.
   449          */
   438          */
   450         if (newMask) {
   439         if (newMask) {
   451             HandleModifierSide(keyboard, bit, oldMods, newMods,
   440             HandleModifierSide(bit, oldMods, newMods,
   452                                left_mapping[i], right_mapping[i],
   441                                left_mapping[i], right_mapping[i],
   453                                left_device_mapping[i], right_device_mapping[i]);
   442                                left_device_mapping[i], right_device_mapping[i]);
   454         }
   443         }
   455         /* If the state changed from pressed to unpressed, we must examine
   444         /* If the state changed from pressed to unpressed, we must examine
   456             * the device dependent bits to release the correct keys.
   445             * the device dependent bits to release the correct keys.
   457             */
   446             */
   458         else if (oldMask && oldMask != newMask) {
   447         else if (oldMask && oldMask != newMask) {
   459             ReleaseModifierSide(keyboard, bit, oldMods, newMods,
   448             ReleaseModifierSide(bit, oldMods, newMods,
   460                               left_mapping[i], right_mapping[i],
   449                               left_mapping[i], right_mapping[i],
   461                               left_device_mapping[i], right_device_mapping[i]);
   450                               left_device_mapping[i], right_device_mapping[i]);
   462         }
   451         }
   463     }
   452     }
   464 }
   453 }
   475     /* 
   464     /* 
   476      * Starting with Panther (10.3.0), the ability to distinguish between 
   465      * Starting with Panther (10.3.0), the ability to distinguish between 
   477      * left side and right side modifiers is available.
   466      * left side and right side modifiers is available.
   478      */
   467      */
   479     if (data->osversion >= 0x1030) {
   468     if (data->osversion >= 0x1030) {
   480         DoSidedModifiers(data->keyboard, scancode, data->modifierFlags, modifierFlags);
   469         DoSidedModifiers(scancode, data->modifierFlags, modifierFlags);
   481     } else {
   470     } else {
   482         DoUnsidedModifiers(data->keyboard, scancode, data->modifierFlags, modifierFlags);
   471         DoUnsidedModifiers(scancode, data->modifierFlags, modifierFlags);
   483     }
   472     }
   484     data->modifierFlags = modifierFlags;
   473     data->modifierFlags = modifierFlags;
   485 }
   474 }
   486 
   475 
   487 static void
   476 static void
   547 
   536 
   548             if (len > 0 && s[0] != 0x10) {
   537             if (len > 0 && s[0] != 0x10) {
   549                 keymap[scancode] = s[0];
   538                 keymap[scancode] = s[0];
   550             }
   539             }
   551         }
   540         }
   552         SDL_SetKeymap(data->keyboard, 0, keymap, SDL_NUM_SCANCODES);
   541         SDL_SetKeymap(0, keymap, SDL_NUM_SCANCODES);
   553         return;
   542         return;
   554     }
   543     }
   555 
   544 
   556 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1050
   545 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1050
   557 cleanup:
   546 cleanup:
   601                     c = macroman_table[c - 128];
   590                     c = macroman_table[c - 128];
   602                 }
   591                 }
   603                 keymap[scancode] = c;
   592                 keymap[scancode] = c;
   604             }
   593             }
   605         }
   594         }
   606         SDL_SetKeymap(data->keyboard, 0, keymap, SDL_NUM_SCANCODES);
   595         SDL_SetKeymap(0, keymap, SDL_NUM_SCANCODES);
   607         return;
   596         return;
   608     }
   597     }
   609 #endif
   598 #endif
   610 }
   599 }
   611 
   600 
   612 void
   601 void
   613 Cocoa_InitKeyboard(_THIS)
   602 Cocoa_InitKeyboard(_THIS)
   614 {
   603 {
   615     SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
   604     SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
   616     SDL_Keyboard keyboard;
   605 
   617 
       
   618     SDL_zero(keyboard);
       
   619     data->keyboard = SDL_AddKeyboard(&keyboard, -1);
       
   620     UpdateKeymap(data);
   606     UpdateKeymap(data);
   621     
   607     
   622     /* Set our own names for the platform-dependent but layout-independent keys */
   608     /* Set our own names for the platform-dependent but layout-independent keys */
   623     /* This key is NumLock on the MacBook keyboard. :) */
   609     /* This key is NumLock on the MacBook keyboard. :) */
   624     /*SDL_SetScancodeName(SDL_SCANCODE_NUMLOCKCLEAR, "Clear");*/
   610     /*SDL_SetScancodeName(SDL_SCANCODE_NUMLOCKCLEAR, "Clear");*/
   643     if (!data->fieldEdit) {
   629     if (!data->fieldEdit) {
   644         data->fieldEdit =
   630         data->fieldEdit =
   645             [[SDLTranslatorResponder alloc] initWithFrame: NSMakeRect(0.0, 0.0, 0.0, 0.0)];
   631             [[SDLTranslatorResponder alloc] initWithFrame: NSMakeRect(0.0, 0.0, 0.0, 0.0)];
   646     }
   632     }
   647 
   633 
   648     [data->fieldEdit setKeyboard: data->keyboard];
       
   649 
       
   650     if (![[data->fieldEdit superview] isEqual: parentView])
   634     if (![[data->fieldEdit superview] isEqual: parentView])
   651     {
   635     {
   652         // DEBUG_IME(@"add fieldEdit to window contentView");
   636         // DEBUG_IME(@"add fieldEdit to window contentView");
   653         [data->fieldEdit removeFromSuperview];
   637         [data->fieldEdit removeFromSuperview];
   654         [parentView addSubview: data->fieldEdit];
   638         [parentView addSubview: data->fieldEdit];
   684 Cocoa_HandleKeyEvent(_THIS, NSEvent *event)
   668 Cocoa_HandleKeyEvent(_THIS, NSEvent *event)
   685 {
   669 {
   686     SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
   670     SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
   687     unsigned short scancode = [event keyCode];
   671     unsigned short scancode = [event keyCode];
   688     SDL_scancode code;
   672     SDL_scancode code;
       
   673 #if 0
   689     const char *text;
   674     const char *text;
       
   675 #endif
   690 
   676 
   691     if ((scancode == 10 || scancode == 50) && KBGetLayoutType(LMGetKbdType()) == kKeyboardISO) {
   677     if ((scancode == 10 || scancode == 50) && KBGetLayoutType(LMGetKbdType()) == kKeyboardISO) {
   692         /* see comments in SDL_cocoakeys.h */
   678         /* see comments in SDL_cocoakeys.h */
   693         scancode = 60 - scancode;
   679         scancode = 60 - scancode;
   694     }
   680     }
   704     case NSKeyDown:
   690     case NSKeyDown:
   705         if (![event isARepeat]) {
   691         if (![event isARepeat]) {
   706             /* See if we need to rebuild the keyboard layout */
   692             /* See if we need to rebuild the keyboard layout */
   707             UpdateKeymap(data);
   693             UpdateKeymap(data);
   708 
   694 
   709             SDL_SendKeyboardKey(data->keyboard, SDL_PRESSED, code);
   695             SDL_SendKeyboardKey(SDL_PRESSED, code);
   710 #if 1
   696 #if 1
   711             if (code == SDL_SCANCODE_UNKNOWN) {
   697             if (code == SDL_SCANCODE_UNKNOWN) {
   712                 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);
   698                 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);
   713             }
   699             }
   714 #endif
   700 #endif
   717             /* 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. */
   703             /* 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. */
   718             [data->fieldEdit interpretKeyEvents:[NSArray arrayWithObject:event]];
   704             [data->fieldEdit interpretKeyEvents:[NSArray arrayWithObject:event]];
   719 #if 0
   705 #if 0
   720             text = [[event characters] UTF8String];
   706             text = [[event characters] UTF8String];
   721             if(text && *text) {
   707             if(text && *text) {
   722                 SDL_SendKeyboardText(data->keyboard, text);
   708                 SDL_SendKeyboardText(text);
   723                 [data->fieldEdit setString:@""];
   709                 [data->fieldEdit setString:@""];
   724             }
   710             }
   725 #endif
   711 #endif
   726         }
   712         }
   727         break;
   713         break;
   728     case NSKeyUp:
   714     case NSKeyUp:
   729         SDL_SendKeyboardKey(data->keyboard, SDL_RELEASED, code);
   715         SDL_SendKeyboardKey(SDL_RELEASED, code);
   730         break;
   716         break;
   731     case NSFlagsChanged:
   717     case NSFlagsChanged:
   732         /* FIXME CW 2007-08-14: check if this whole mess that takes up half of this file is really necessary */
   718         /* FIXME CW 2007-08-14: check if this whole mess that takes up half of this file is really necessary */
   733         HandleModifiers(_this, scancode, [event modifierFlags]);
   719         HandleModifiers(_this, scancode, [event modifierFlags]);
   734         break;
   720         break;
   738 }
   724 }
   739 
   725 
   740 void
   726 void
   741 Cocoa_QuitKeyboard(_THIS)
   727 Cocoa_QuitKeyboard(_THIS)
   742 {
   728 {
   743     SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
       
   744     NSAutoreleasePool *pool;
       
   745 
       
   746     SDL_DelKeyboard(data->keyboard);
       
   747 }
   729 }
   748 
   730 
   749 /* vi: set ts=4 sw=4 expandtab: */
   731 /* vi: set ts=4 sw=4 expandtab: */