Tk Source Code

/*
#ifdef TK_MAC_DEBUG
#define TK_MAC_DEBUG_KEYBOARD
#endif
*/
#define NS_KEYLOG 0

static Tk_Window keyboardGrabWinPtr = NULL; /* Current keyboard grab window. */
static NSWindow *keyboardGrabNSWindow = nil; /* Its underlying NSWindow.*/
static NSModalSession modalSession = nil;
static BOOL processingCompose = NO;
static Tk_Window composeWin = NULL;
static int caret_x = 0, caret_y = 0, caret_height = 0;
static TkWindow *caret_win = NULL;

static void setupXEvent(XEvent *xEvent, Tk_Window tkwin, NSUInteger modifiers);

#pragma mark TKApplication(TKKeyEvent)

@implementation TKApplication(TKKeyEvent)

- (NSEvent *) tkProcessKeyEvent: (NSEvent *) theEvent
{
#ifdef TK_MAC_DEBUG_EVENTS
    TKLog(@"-[%@(%p) %s] %@", [self class], self, _cmd, theEvent);
#endif
    unsigned int keyCode = [theEvent keyCode];
    NSWindow *w = [theEvent window];
    TkWindow *winPtr = TkMacOSXGetTkWindow(w);




    NSUInteger modifiers = ([theEvent modifierFlags] &
			    NSDeviceIndependentModifierFlagsMask);
    NSString *characters = nil;

    NSString *charactersIgnoringModifiers = nil;


    UniChar keychar = 0;
    static NSUInteger savedModifiers = 0;
    static NSMutableArray *nsEvArray;

    if (nsEvArray == nil) {
        nsEvArray = [[NSMutableArray alloc] initWithCapacity: 1];
        processingCompose = NO;



    }

    /*
     * Control-Tab and Control-Shift-Tab are used to switch tabs in a tabbed
     * window.  We do not want to generate an Xevent for these since that might
     * cause the deselected tab to be reactivated.
     */

    if (keyCode == 48 && (modifiers & NSControlKeyMask) == NSControlKeyMask) {
	return theEvent;
    }

    if (!winPtr) {
	return theEvent;
    }

    /*
     * If a local grab is in effect, key events for windows in the
     * grabber's application are redirected to the grabber.  Key events
     * for other applications are delivered normally.  If a global
     * grab is in effect all key events are redirected to the grabber.
     */

    Tk_Window tkwin = (Tk_Window) winPtr;
    TkWindow *grabWinPtr = winPtr->dispPtr->grabWinPtr;
    if (grabWinPtr) {
	if (winPtr->dispPtr->grabFlags ||  /* global grab */
	    grabWinPtr->mainPtr == winPtr->mainPtr){ /* same application */
	    tkwin = (Tk_Window) winPtr->dispPtr->focusPtr;
	}
    }

    NSEventType type = [theEvent type];
    BOOL has_modifiers = NO;

    XEvent xEvent;


    if (type == NSKeyUp || type == NSKeyDown) {
	characters = [theEvent characters];
	keychar = [characters length] > 0 ? [characters characterAtIndex:0] : 0;
	charactersIgnoringModifiers = [theEvent charactersIgnoringModifiers];
	
#if defined(TK_MAC_DEBUG_EVENTS) || NS_KEYLOG == 1
	TKLog(@"-[%@(%p) %s] r=%d mods=%u '%@' '%@' keyCode=%u c=%d %@ %d",
	      [self class], self, _cmd, (type == NSKeyDown) && [theEvent isARepeat],
	      modifiers, characters, charactersIgnoringModifiers, keyCode,
	      ([charactersIgnoringModifiers length] == 0) ? 0 :
	      [charactersIgnoringModifiers characterAtIndex: 0], w, type);
#endif

    }
    if (type == NSKeyDown) {
	has_modifiers = xEvent.xkey.state &
	    (ControlMask | Mod1Mask | Mod3Mask | Mod4Mask);
    }

    /*
     * Build the XEvent.

     */

    setupXEvent(&xEvent, tkwin, modifiers);

    /*
     * Check whether this key event belongs to the caret window.
     */

    Bool has_caret = (TkFocusKeyEvent(winPtr, &xEvent) == caret_win);

    /*
     * A KeyDown event received for the caret window which is not a function key
     * and has no modifiers other than Shift or Option will be processed with the
     * TextInputClient protocol below.  All other key events are handled here
     * by queueing the XEvent created above.
     */

    if (!processingCompose || !has_caret) {
	xEvent.xkey.keycode = (keyCode << 16) | keychar;
	switch (type) {
	case NSFlagsChanged:

	    /*
	     * If the highest bit where they differ was set then this is a press.
	     */


	    xEvent.xany.type = modifiers > savedModifiers ? KeyPress : KeyRelease;

	    /*
	     * The value -1 signals a modifier keycode to the function TkpGetKeySym
	     * defined in tkMacOSXKeyboard.c.
	     */


	    xEvent.xany.send_event = -1;

	    /*
	     * Update savedModifiers for NSFlagsChanged events and no others,
	     * since some non-modifier keys (e.g. function keys) have modifier
	     * flags set
	     */

            savedModifiers = modifiers;
	    break;
	case NSKeyUp:
	    xEvent.xany.type = KeyRelease;
	    break;
	case NSKeyDown:
	    xEvent.xany.type = KeyPress;
	    break;
	default:
	    return theEvent; /* Unrecognized key event. */
	}

        if (type != NSKeyDown ||
	    !has_caret        ||
	    has_modifiers     ||
	    ((keychar >= 0xF700) && (keychar <= 0xF8FF))) {
	    if (type == NSKeyDown && [theEvent isARepeat]) {


		/*

		 * Insert a KeyRelease XEvent before a repeated KeyPress.

		 */

		xEvent.xany.type = KeyRelease;
		Tk_QueueWindowEvent(&xEvent, TCL_QUEUE_TAIL);
		xEvent.xany.type = KeyPress;
            }

	    /*
	     * Queue the XEvent and return.
	     */

            Tk_QueueWindowEvent(&xEvent, TCL_QUEUE_TAIL);
            return theEvent;
	}
    }

    /*
     * Either we are processing a composition or this is a normal KeyDown event
     * for the caret window. Either way the event should be passed to
     * interpretKeyEvents.  But we only need to send KeyDown events.
     */

    switch (type) {
    case NSKeyDown:
	if (NS_KEYLOG) {
	    TKLog(@"keyDown: %s compose sequence.\n",
		  processingCompose == YES ? "Continue" : "Begin");

	}

	/*
	 * Call the interpretKeyEvents method to handle the event as a
	 * TextInputClient.  When the composition sequence is complete, our
	 * implementation of insertText: replacementRange will be called.  that
	 * method generates a key down XEvent with the selected character.  In
	 * IME when multiple characters have the same composition sequence and
	 * the selected character is not the default it may be necessary to hit
	 * the Enter key multiple times before the character is accepted and
	 * rendered. So we repeatedly send Enter key events until inputText has
	 * cleared the processingCompose flag.
	 */

	processingCompose = YES;
	while(processingCompose) {
	    [nsEvArray addObject: theEvent];
	    [[w contentView] interpretKeyEvents: nsEvArray];
	    [nsEvArray removeObject: theEvent];
	    if ([theEvent keyCode] != 36) {
		break;
	    }
	}


	break;






    case NSFlagsChanged:









	savedModifiers = modifiers;







	break;






    default:


	break;




    }






    return theEvent;
}
@end


@implementation TKContentView

    {97,	XK_F6,		NSF6FunctionKey},
    {98,	XK_F7,		NSF7FunctionKey},
    {99,	XK_F3,		NSF3FunctionKey},
    {100,	XK_F8,		NSF8FunctionKey},
    {101,	XK_F9,		NSF9FunctionKey},
    {103,	XK_F11,		NSF11FunctionKey},
    {105,	XK_F13,		NSF13FunctionKey},

    {107,	XK_F14,		NSF14FunctionKey},
    {109,	XK_F10,		NSF10FunctionKey},
    {105,	XK_F13,		NSF13FunctionKey},
    {106,	XK_F16,		NSF16FunctionKey},
    {111,	XK_F12,		NSF12FunctionKey},
    {113,	XK_F15,		NSF15FunctionKey},
    {114,	XK_Help,	NSHelpFunctionKey},
    {115,	XK_Home,	NSHomeFunctionKey},     /* Fn Left */
    {116,	XK_Page_Up,	NSPageUpFunctionKey},   /* Fn Up */
    {117,	XK_Delete,	NSDeleteFunctionKey},   /* Fn Deleete */
    {118,	XK_F4,		NSF4FunctionKey},

};

/*
 * X11 keysyms for modifier keys, in order.
 */

#define NUM_MOD_KEYCODES 14
static KeyCode modKeyArray[NUM_MOD_KEYCODES] = {
    XK_Shift_L,
    XK_Shift_R,
    XK_Control_L,
    XK_Control_R,
    XK_Caps_Lock,
    XK_Shift_Lock,
    XK_Meta_L,
    XK_Meta_R,
    XK_Alt_L,
    XK_Alt_R,
    XK_Super_L,
    XK_Super_R,
    XK_Hyper_L,
    XK_Hyper_R,
};

static int initialized = 0;
static int keyboardChanged = 1;
static Tcl_HashTable virtual2keysym;	/* Maps Mac keyCode to X11 keysym. */
static Tcl_HashTable keysym2keycode;	/* Maps X11 keysym to Mac keycode. */
static int latin1Table[LATIN1_MAX+1];	/* Reverse mapping table for Latin-1. */

/*
 * Prototypes for static functions used in this file.
 */

@implementation TKApplication(TKKeyboard)
- (void) keyboardChanged: (NSNotification *) notification
{
#ifdef TK_MAC_DEBUG_NOTIFICATIONS
    TKLog(@"-[%@(%p) %s] %@", [self class], self, _cmd, notification);
#endif
    keyboardChanged = 1;
}
@end

#pragma mark -

/*
 *----------------------------------------------------------------------

	hPtr = Tcl_CreateHashEntry(&virtual2keysym, INT2PTR(kPtr->virtual),
				   &dummy);
	Tcl_SetHashValue(hPtr, INT2PTR(kPtr->keysym));
	hPtr = Tcl_CreateHashEntry(&keysym2keycode, INT2PTR(kPtr->keysym),
				   &dummy);
	Tcl_SetHashValue(hPtr, INT2PTR(kPtr->keychar | (kPtr->virtual << 16)));
    }
    initialized = 1;
}

/*
 *----------------------------------------------------------------------
 *
 * InitLatin1Table --
 *