* carbon/ (new directory): copy of current state of 'macosx'

	source directory, to preserve legacy TkAqua implementation based on
	Carbon API (with support for Mac OS X releases older than 10.5).


FossilOrigin-Name: 163cd900fe33c2611ac6298e741371b92a36a334

1 files changed, 1169 insertions, 0 deletions

diff --git a/carbon/tkMacOSXKeyEvent.c b/carbon/tkMacOSXKeyEvent.c
new file mode 100644
index 0000000..5bce60d
--- /dev/null
+++ b/carbon/tkMacOSXKeyEvent.c
@@ -0,0 +1,1169 @@
+/*
+ * tkMacOSXKeyEvent.c --
+ *
+ *	This file implements functions that decode & handle keyboard events on
+ *	MacOS X.
+ *
+ * Copyright 2001, Apple Computer, Inc.
+ * Copyright (c) 2006-2007 Daniel A. Steffen <das@users.sourceforge.net>
+ *
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ *	The following terms apply to all files originating from Apple Computer,
+ *	Inc. ("Apple") and associated with the software unless explicitly
+ *	disclaimed in individual files.
+ *
+ *	Apple hereby grants permission to use, copy, modify, distribute, and
+ *	license this software and its documentation for any purpose, provided
+ *	that existing copyright notices are retained in all copies and that
+ *	this notice is included verbatim in any distributions. No written
+ *	agreement, license, or royalty fee is required for any of the
+ *	authorized uses. Modifications to this software may be copyrighted by
+ *	their authors and need not follow the licensing terms described here,
+ *	provided that the new terms are clearly indicated on the first page of
+ *	each file where they apply.
+ *
+ *	IN NO EVENT SHALL APPLE, THE AUTHORS OR DISTRIBUTORS OF THE SOFTWARE BE
+ *	LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR
+ *	CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE, ITS
+ *	DOCUMENTATION, OR ANY DERIVATIVES THEREOF, EVEN IF APPLE OR THE AUTHORS
+ *	HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. APPLE, THE AUTHORS
+ *	AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, BUT
+ *	NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR
+ *	A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE IS PROVIDED
+ *	ON AN "AS IS" BASIS, AND APPLE,THE AUTHORS AND DISTRIBUTORS HAVE NO
+ *	OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
+ *	MODIFICATIONS.
+ *
+ *	GOVERNMENT USE: If you are acquiring this software on behalf of the
+ *	U.S. government, the Government shall have only "Restricted Rights" in
+ *	the software and related documentation as defined in the Federal
+ *	Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2). If you are
+ *	acquiring the software on behalf of the Department of Defense, the
+ *	software shall be classified as "Commercial Computer Software" and the
+ *	Government shall have only "Restricted Rights" as defined in Clause
+ *	252.227-7013 (c) (1) of DFARs. Notwithstanding the foregoing, the
+ *	authors grant the U.S. Government and others acting in its behalf
+ *	permission to use and distribute the software in accordance with the
+ *	terms specified in this license.
+ *
+ * RCS: @(#) $Id: tkMacOSXKeyEvent.c,v 1.1 2009/06/26 01:42:47 das Exp $
+ */
+
+#include "tkMacOSXPrivate.h"
+#include "tkMacOSXEvent.h"
+
+/*
+#ifdef TK_MAC_DEBUG
+#define TK_MAC_DEBUG_KEYBOARD
+#endif
+*/
+
+typedef struct {
+    WindowRef whichWindow;
+    int global_x, global_y;
+    int local_x, local_y;
+    unsigned int state;
+    UInt32 keyCode;
+    UInt32 keyModifiers;
+    UInt32 message;
+    unsigned char ch;
+} KeyEventData;
+
+static Tk_Window grabWinPtr = NULL;
+				/* Current grab window, NULL if no grab. */
+static Tk_Window keyboardGrabWinPtr = NULL;
+				/* Current keyboard grab window. */
+static UInt32 deadKeyStateUp = 0;
+				/* The deadkey state for the current sequence
+				 * of keyup events or 0 if not in a deadkey
+				 * sequence */
+static UInt32 deadKeyStateDown = 0;
+				/* Ditto for keydown */
+
+/*
+ * Declarations for functions used only in this file.
+ */
+
+static int		GenerateKeyEvent(UInt32 eKind, KeyEventData *e,
+			    UInt32 savedKeyCode, UInt32 savedModifiers,
+			    const UniChar *chars, int numChars);
+static TextEncoding	GetKCHREncoding(ScriptCode script, SInt32 layoutid);
+static int		GetKeyboardLayout(Ptr *resourcePtr,
+			    TextEncoding *encodingPtr);
+static int		InitKeyData(KeyEventData *keyEventDataPtr);
+static int		InitKeyEvent(XEvent *eventPtr, KeyEventData *e,
+			    UInt32 savedKeyCode, UInt32 savedModifiers);
+static int		KeycodeToUnicodeViaKCHRResource(UniChar *uniChars,
+			    int maxChars, Ptr kchr, TextEncoding encoding,
+			    EventKind eKind, UInt32 keycode, UInt32 modifiers,
+			    UInt32 *deadKeyStatePtr);
+static int		KeycodeToUnicodeViaUnicodeResource(UniChar *uniChars,
+			    int maxChars, Ptr uchr, EventKind eKind,
+			    UInt32 keycode, UInt32 modifiers,
+			    UInt32 *deadKeyStatePtr);
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkMacOSXProcessKeyboardEvent --
+ *
+ *	This routine processes the event in eventPtr, and generates the
+ *	appropriate Tk events from it.
+ *
+ * Results:
+ *	True if event(s) are generated - false otherwise.
+ *
+ * Side effects:
+ *	Additional events may be place on the Tk event queue.
+ *
+ *----------------------------------------------------------------------
+ */
+
+MODULE_SCOPE int
+TkMacOSXProcessKeyboardEvent(
+    TkMacOSXEvent *eventPtr,
+    MacEventStatus *statusPtr)
+{
+    static UInt32 savedKeyCode = 0;
+    static UInt32 savedModifiers = 0;
+    static UniChar savedChar = 0;
+    OSStatus err;
+    KeyEventData keyEventData;
+    MenuRef menuRef;
+    MenuItemIndex menuItemIndex;
+    int eventGenerated;
+    UniChar uniChars[5]; /* make this larger, if needed */
+    UInt32 uniCharsLen = 0;
+
+    if (!InitKeyData(&keyEventData)) {
+	statusPtr->err = 1;
+	return false;
+    }
+
+    /*
+     * Because of the way that Tk operates, we can't in general funnel menu
+     * accelerators through IsMenuKeyEvent. Tk treats accelerators as mere
+     * decoration, and the user has to install bindings to get them to fire.
+     *
+     * However, the only way to trigger the Hide & Hide Others functions is by
+     * invoking the Menu command for Hide. So there is no nice way to provide a
+     * Tk command to hide the app which would be available for a binding. So I
+     * am going to hijack Command-H and Command-Shift-H here, and run the menu
+     * commands. Since the HI Guidelines explicitly reserve these for Hide,
+     * this isn't such a bad thing. Also, if you do rebind Command-H to another
+     * menu item, Hide will lose its binding.
+     *
+     * Note that I don't really do anything at this point, I just mark
+     * stopProcessing as 0 and return, and then the RecieveAndProcessEvent code
+     * will dispatch the event to the default handler.
+     */
+
+    if ((eventPtr->eKind == kEventRawKeyDown
+	    || eventPtr->eKind == kEventRawKeyRepeat)
+	    && IsMenuKeyEvent(tkCurrentAppleMenu, eventPtr->eventRef,
+		    kMenuEventQueryOnly, &menuRef, &menuItemIndex)) {
+	MenuCommand menuCmd;
+
+	GetMenuItemCommandID (menuRef, menuItemIndex, &menuCmd);
+	switch (menuCmd) {
+	case kHICommandHide:
+	case kHICommandHideOthers:
+	case kHICommandShowAll:
+	case kHICommandPreferences:
+	case kHICommandQuit:
+	    statusPtr->stopProcessing = 0;
+
+	    /*
+	     * TODO: may not be on event on queue.
+	     */
+
+	    return 0;
+	default:
+	    break;
+	}
+    }
+
+    err = ChkErr(GetEventParameter, eventPtr->eventRef,
+	    kEventParamKeyMacCharCodes, typeChar, NULL,
+	    sizeof(keyEventData.ch), NULL, &keyEventData.ch);
+    if (err != noErr) {
+	statusPtr->err = 1;
+	return false;
+    }
+    err = ChkErr(GetEventParameter, eventPtr->eventRef, kEventParamKeyCode,
+	    typeUInt32, NULL, sizeof(keyEventData.keyCode), NULL,
+	    &keyEventData.keyCode);
+    if (err != noErr) {
+	statusPtr->err = 1;
+	return false;
+    }
+    err = ChkErr(GetEventParameter, eventPtr->eventRef,
+	    kEventParamKeyModifiers, typeUInt32, NULL,
+	    sizeof(keyEventData.keyModifiers), NULL,
+	    &keyEventData.keyModifiers);
+    if (err != noErr) {
+	statusPtr->err = 1;
+	return false;
+    }
+
+    switch (eventPtr->eKind) {
+    case kEventRawKeyUp:
+    case kEventRawKeyDown:
+    case kEventRawKeyRepeat: {
+	UInt32 *deadKeyStatePtr;
+
+	if (kEventRawKeyDown == eventPtr->eKind) {
+	    deadKeyStatePtr = &deadKeyStateDown;
+	} else {
+	    deadKeyStatePtr = &deadKeyStateUp;
+	}
+
+	uniCharsLen = TkMacOSXKeycodeToUnicode(uniChars,
+		sizeof(uniChars)/sizeof(*uniChars), eventPtr->eKind,
+		keyEventData.keyCode, keyEventData.keyModifiers,
+		deadKeyStatePtr);
+	break;
+    }
+    }
+
+    if (kEventRawKeyUp == eventPtr->eKind) {
+	/*
+	 * For some reason the deadkey processing for KeyUp doesn't work
+	 * sometimes, so we fudge and use the last detected KeyDown.
+	 */
+
+	if ((0 == uniCharsLen) && (0 != savedChar)) {
+	    uniChars[0] = savedChar;
+	    uniCharsLen = 1;
+	}
+
+	/*
+	 * Suppress keyup events while we have a deadkey sequence on keydown.
+	 * We still *do* want to collect deadkey state in this situation if
+	 * the system provides it, that's why we do this only after
+	 * TkMacOSXKeycodeToUnicode().
+	 */
+
+	if (0 != deadKeyStateDown) {
+	    uniCharsLen = 0;
+	}
+    }
+
+    keyEventData.message = keyEventData.ch|(keyEventData.keyCode << 8);
+
+    eventGenerated = GenerateKeyEvent(eventPtr->eKind, &keyEventData,
+	    savedKeyCode, savedModifiers, uniChars, uniCharsLen);
+
+    savedModifiers = keyEventData.keyModifiers;
+
+    if ((kEventRawKeyDown == eventPtr->eKind) && (uniCharsLen > 0)) {
+	savedChar = uniChars[0];
+    } else {
+	savedChar = 0;
+    }
+
+    statusPtr->stopProcessing = 1;
+
+    if (eventGenerated == 0) {
+	savedKeyCode = keyEventData.message;
+	return false;
+    }
+    if (eventGenerated == -1) {
+	savedKeyCode = 0;
+	statusPtr->stopProcessing = 0;
+	return false;
+    }
+    savedKeyCode = 0;
+    return true;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * GenerateKeyEvent --
+ *
+ *	Given Macintosh keyUp, keyDown & autoKey events (in their "raw" form)
+ *	and a list of unicode characters this function generates the
+ *	appropriate X key events.
+ *
+ *	Parameter eKind is a raw keyboard event. e contains the data sent with
+ *	the event. savedKeyCode and savedModifiers contain the values from the
+ *	last event that came before (see TkMacOSXProcessKeyboardEvent()).
+ *	chars/numChars has the Unicode characters for which we want to create
+ *	events.
+ *
+ * Results:
+ *	1 if an event was generated, -1 for any error.
+ *
+ * Side effects:
+ *	Additional events may be place on the Tk event queue.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+GenerateKeyEvent(
+    UInt32 eKind,
+    KeyEventData * e,
+    UInt32 savedKeyCode,
+    UInt32 savedModifiers,
+    const UniChar * chars,
+    int numChars)
+{
+    XEvent event;
+    int i;
+
+    if (-1 == InitKeyEvent(&event, e, savedKeyCode, savedModifiers)) {
+	return -1;
+    }
+
+    if (kEventRawKeyModifiersChanged == eKind) {
+	if (savedModifiers > e->keyModifiers) {
+	    event.xany.type = KeyRelease;
+	} else {
+	    event.xany.type = KeyPress;
+	}
+
+	/*
+	 * Use special '-1' to signify a special keycode to our platform
+	 * specific code in tkMacOSXKeyboard.c. This is rather like what
+	 * happens on Windows.
+	 */
+
+	event.xany.send_event = -1;
+
+	/*
+	 * Set keycode (which was zero) to the changed modifier
+	 */
+
+	event.xkey.keycode = (e->keyModifiers ^ savedModifiers);
+	Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
+    } else {
+	for (i = 0; i < numChars; ++i) {
+	    /*
+	     * Encode one char in the trans_chars array that was already
+	     * introduced for MS Windows. Don't encode the string, if it is a
+	     * control character but was not generated with a real control
+	     * modifier. Such control characters get generated by KeyTrans()
+	     * for special keys, but we rather want to identify those by their
+	     * KeySyms.
+	     */
+
+	    event.xkey.trans_chars[0] = 0;
+	    if ((controlKey & e->keyModifiers) || (chars[i] >= ' ')) {
+		int done = Tcl_UniCharToUtf(chars[i],event.xkey.trans_chars);
+
+		event.xkey.trans_chars[done] = 0;
+	    }
+
+	    switch(eKind) {
+	    case kEventRawKeyDown:
+		event.xany.type = KeyPress;
+		Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
+		break;
+	    case kEventRawKeyUp:
+		event.xany.type = KeyRelease;
+		Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
+		break;
+	    case kEventRawKeyRepeat:
+		event.xany.type = KeyRelease;
+		Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
+		event.xany.type = KeyPress;
+		Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
+		break;
+	    default:
+		TkMacOSXDbgMsg("Invalid parameter eKind %ld", eKind);
+		return -1;
+	    }
+	}
+    }
+
+    return 1;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * InitKeyData --
+ *
+ *	This routine initializes a KeyEventData structure by asking the OS and
+ *	Tk for all the global information needed here.
+ *
+ * Results:
+ *	True if the current front window can be found in Tk data structures,
+ *	false otherwise.
+ *
+ * Side Effects:
+ *	None
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+InitKeyData(
+    KeyEventData *keyEventDataPtr)
+{
+    memset(keyEventDataPtr, 0, sizeof(*keyEventDataPtr));
+
+    keyEventDataPtr->whichWindow = ActiveNonFloatingWindow();
+    if (keyEventDataPtr->whichWindow == NULL) {
+	return false;
+    }
+
+    XQueryPointer(NULL, None, NULL, NULL, &keyEventDataPtr->global_x,
+	    &keyEventDataPtr->global_y, &keyEventDataPtr->local_x,
+	    &keyEventDataPtr->local_y, &keyEventDataPtr->state);
+    return true;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * InitKeyEvent --
+ *
+ *	Initialize an XEvent structure by asking Tk for global information.
+ *	Also uses a KeyEventData structure and other current state.
+ *
+ * Results:
+ *	1 on success, -1 for any error.
+ *
+ * Side effects:
+ *	Additional events may be place on the Tk event queue.
+ *
+ *----------------------------------------------------------------------
+ */
+
+/*
+ * We have a general problem here. How do we handle 'Option-char' keypresses?
+ * The problem is that we might want to bind to some of these (e.g. Cmd-Opt-d
+ * is 'uncomment' in Alpha). OTOH Option-d actually produces a real character
+ * on MacOS, namely a mathematical delta.
+ *
+ * The current behaviour is that a binding goes by the combinations of
+ * modifiers and base keysym, that is Option-d. The string value of the event
+ * is the mathematical delta character, so if no binding calls [break], the
+ * text widget will insert that character.
+ *
+ * Note that this is similar to control combinations on all platforms. They
+ * also generate events that have the base character as keysym and a real
+ * control character as character value. So Ctrl+C gets us the keysym XK_C, the
+ * modifier Control (so you can bind <Control-C>) and a string value as
+ * "\u0003".
+ *
+ * For a different solutions we may want for the event to contain keysyms for
+ * *both* the 'Opt-d' side of things and the mathematical delta. Then a binding
+ * on Opt-d will trigger, but a binding on mathematical delta would also
+ * trigger. This would require changes in the core, though.
+ */
+
+static int
+InitKeyEvent(
+    XEvent * eventPtr,
+    KeyEventData * e,
+    UInt32 savedKeyCode,
+    UInt32 savedModifiers)
+{
+    Window window;
+    Tk_Window tkwin;
+    TkDisplay *dispPtr;
+
+    /*
+     * The focus must be in the FrontWindow on the Macintosh. We then query Tk
+     * to determine the exact Tk window that owns the focus.
+     */
+
+    window = TkMacOSXGetXWindow(e->whichWindow);
+    dispPtr = TkGetDisplayList();
+    tkwin = Tk_IdToWindow(dispPtr->display, window);
+
+    if (!tkwin) {
+	TkMacOSXDbgMsg("tkwin == NULL");
+	return -1;
+    }
+
+    tkwin = (Tk_Window) ((TkWindow *) tkwin)->dispPtr->focusPtr;
+    if (!tkwin) {
+	TkMacOSXDbgMsg("tkwin == NULL");
+	return -1;
+    }
+
+    eventPtr->xany.send_event = false;
+    eventPtr->xany.serial = Tk_Display(tkwin)->request;
+
+    eventPtr->xkey.same_screen = true;
+    eventPtr->xkey.subwindow = None;
+    eventPtr->xkey.time = TkpGetMS();
+    eventPtr->xkey.x_root = e->global_x;
+    eventPtr->xkey.y_root = e->global_y;
+    eventPtr->xkey.window = Tk_WindowId(tkwin);
+    eventPtr->xkey.display = Tk_Display(tkwin);
+    eventPtr->xkey.root = XRootWindow(Tk_Display(tkwin), 0);
+    eventPtr->xkey.state = e->state;
+    eventPtr->xkey.trans_chars[0] = 0;
+
+    Tk_TopCoordsToWindow(tkwin, e->local_x, e->local_y, &eventPtr->xkey.x,
+	    &eventPtr->xkey.y);
+
+    eventPtr->xkey.keycode = e->ch | ((savedKeyCode & charCodeMask) << 8) |
+	    ((e->message&keyCodeMask) << 8);
+    return 1;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * GetKeyboardLayout --
+ *
+ *	Queries the OS for a pointer to a keyboard resource.
+ *
+ *	This function works with the keyboard layout switch menu. It uses
+ *	Keyboard Layout Services, where available.
+ *
+ * Results:
+ *	1 if there is returned a Unicode 'uchr' resource in *resourcePtr, 0 if
+ *	it is a classic 'KCHR' resource. A pointer to the actual resource data
+ *	goes into *resourcePtr. If the resource is a 'KCHR' resource, the
+ *	corresponding Mac encoding goes into *encodingPtr.
+ *
+ * Side effects:
+ *	Sets some internal static variables.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+GetKeyboardLayout(
+    Ptr *resourcePtr,
+    TextEncoding *encodingPtr)
+{
+    static KeyboardLayoutRef lastLayout = NULL;
+    static SInt32 lastLayoutId;
+    static TextEncoding lastEncoding = kTextEncodingMacRoman;
+    static Ptr uchr = NULL;
+    static Ptr KCHR = NULL;
+    int hasLayoutChanged = false;
+    KeyboardLayoutRef currentLayout = NULL;
+    SInt32 currentLayoutId = 0;
+    ScriptCode currentKeyScript;
+
+    currentKeyScript = GetScriptManagerVariable(smKeyScript);
+
+    /*
+     * Use the Keyboard Layout Services.
+     */
+
+    KLGetCurrentKeyboardLayout(&currentLayout);
+
+    if (currentLayout != NULL) {
+	/*
+	 * The layout pointer could in theory be the same for different
+	 * layouts, only the id gives us the information that the
+	 * keyboard has actually changed. OTOH the layout object can
+	 * also change and it could still be the same layoutid.
+	 */
+
+	KLGetKeyboardLayoutProperty(currentLayout, kKLIdentifier,
+		(const void **) &currentLayoutId);
+
+	if ((lastLayout != currentLayout)
+		|| (lastLayoutId != currentLayoutId)) {
+#ifdef TK_MAC_DEBUG_KEYBOARD
+	    TkMacOSXDbgMsg("Use KLS");
+#endif
+	    hasLayoutChanged = true;
+
+	    /*
+	     * Reinitialize all relevant variables.
+	     */
+
+	    lastLayout = currentLayout;
+	    lastLayoutId = currentLayoutId;
+	    uchr = NULL;
+	    KCHR = NULL;
+
+	    if ((KLGetKeyboardLayoutProperty(currentLayout,
+		    kKLuchrData, (const void **) &uchr) == noErr)
+		    && (uchr != NULL)) {
+		/* done */
+	    } else if ((KLGetKeyboardLayoutProperty(currentLayout,
+		    kKLKCHRData, (const void**)&KCHR) == noErr)
+		    && (KCHR != NULL)) {
+		/* done */
+	    }
+	}
+    }
+
+    if (hasLayoutChanged) {
+#ifdef TK_MAC_DEBUG_KEYBOARD
+	if (KCHR) {
+	    TkMacOSXDbgMsg("New 'KCHR' layout %ld", currentLayoutId);
+	} else if (uchr) {
+	    TkMacOSXDbgMsg("New 'uchr' layout %ld", currentLayoutId);
+	} else {
+	    TkMacOSXDbgMsg("Use cached layout (should have been %ld)",
+		    currentLayoutId);
+	}
+#endif
+
+	deadKeyStateUp = deadKeyStateDown = 0;
+
+	/*
+	 * If we did get a new 'KCHR', compute its encoding and put it into
+	 * lastEncoding.
+	 *
+	 * If we didn't get a new 'KCHR' and if we have no 'uchr' either, get
+	 * some 'KCHR' from the OS cache and leave lastEncoding at its current
+	 * value. This should better not happen, it doesn't really work.
+	 */
+
+	if (KCHR) {
+	    lastEncoding = GetKCHREncoding(currentKeyScript, currentLayoutId);
+#ifdef TK_MAC_DEBUG_KEYBOARD
+	    TkMacOSXDbgMsg("New 'KCHR' encoding %lu (%lu + 0x%lX)",
+		    lastEncoding, lastEncoding & 0xFFFFL,
+		    lastEncoding & ~0xFFFFL);
+#endif
+	} else if (!uchr) {
+	    KCHR = (Ptr)(intptr_t) GetScriptManagerVariable(smKCHRCache);
+	}
+    }
+
+    if (uchr) {
+	*resourcePtr = uchr;
+	return 1;
+    }
+    *resourcePtr = KCHR;
+    *encodingPtr = lastEncoding;
+    return 0;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * GetKCHREncoding --
+ *
+ *	Upgrade a WorldScript code to a TEC encoding based on the keyboard
+ *	layout id.
+ *
+ * Results:
+ *	The TEC code that corresponds best to the combination of WorldScript
+ *	code and 'KCHR' id.
+ *
+ * Side effects:
+ *	None.
+ *
+ * Rationale and Notes:
+ *	WorldScript codes are sometimes not unique encodings. E.g. Icelandic
+ *	uses script smRoman (0), but the actual encoding is
+ *	kTextEncodingMacIcelandic (37). ftp://ftp.unicode.org/Public
+ *	/MAPPINGS/VENDORS/APPLE/README.TXT has a good summary of these
+ *	variants. So we need to upgrade the script to an encoding with
+ *	GetTextEncodingFromScriptInfo().
+ *
+ *	'KCHR' ids are usually region codes (see the comments in Script.h).
+ *	Where they are not, we get a paramErr from the OS function and have
+ *	appropriate fallbacks.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static TextEncoding
+GetKCHREncoding(
+    ScriptCode script,
+    SInt32 layoutid)
+{
+    RegionCode region = layoutid;
+    TextEncoding encoding = script;
+
+    if (GetTextEncodingFromScriptInfo(script, kTextLanguageDontCare, region,
+	    &encoding) == noErr) {
+	return encoding;
+    }
+
+    /*
+     * GetTextEncodingFromScriptInfo() doesn't know about more exotic layouts.
+     * This provides a fallback for good measure. In an ideal world, exotic
+     * layouts would always provide a 'uchr' resource anyway, so we wouldn't
+     * need this.
+     *
+     * We can add more keyboard layouts, if we get actual complaints. Farsi or
+     * other Celtic/Gaelic layouts would be candidates.
+     */
+
+    switch (layoutid) {
+	/*
+	 * Icelandic and Faroese (planned). These layouts are sold by Apple
+	 * Iceland for legacy applications.
+	 */
+
+    case 1800: case 1821:
+	return kTextEncodingMacIcelandic;
+
+	/*
+	 * Irish and Welsh. These layouts are mentioned in <Script.h>.
+	 *
+	 * FIXME: This may have to be kTextEncodingMacGaelic instead, but I
+	 * can't locate layouts of this type for testing.
+	 */
+
+    case 581: case 779:
+	return kTextEncodingMacCeltic;
+    }
+
+    /*
+     * The valid script codes are also the valid default encoding codes, so if
+     * nothing else helps, fall back on those.
+     */
+
+    return script;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * KeycodeToUnicodeViaUnicodeResource --
+ *
+ *	Given MacOS key event data this function generates the Unicode
+ *	characters. It does this using a 'uchr' and the UCKeyTranslate API.
+ *
+ *	The parameter deadKeyStatePtr can be NULL, if no deadkey handling is
+ *	needed.
+ *
+ *	Tested and known to work with US, Hebrew, Greek and Russian layouts as
+ *	well as "Unicode Hex Input".
+ *
+ * Results:
+ *	The number of characters generated if any, 0 if we are waiting for
+ *	another byte of a dead-key sequence. Fills in the uniChars array with a
+ *	Unicode string.
+ *
+ * Side Effects:
+ *	None
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+KeycodeToUnicodeViaUnicodeResource(
+    UniChar *uniChars,
+    int maxChars,
+    Ptr uchr,
+    EventKind eKind,
+    UInt32 keycode,
+    UInt32 modifiers,
+    UInt32 *deadKeyStatePtr)
+{
+    int action;
+    unsigned long keyboardType;
+    OptionBits options = 0;
+    UInt32 dummy_state;
+    UniCharCount actuallength;
+    OSStatus err;
+
+    keycode &= 0xFF;
+    modifiers = (modifiers >> 8) & 0xFF;
+    keyboardType = LMGetKbdType();
+
+    if (NULL==deadKeyStatePtr) {
+	options = kUCKeyTranslateNoDeadKeysMask;
+	dummy_state = 0;
+	deadKeyStatePtr = &dummy_state;
+    }
+
+    switch(eKind) {
+    case kEventRawKeyDown:
+	action = kUCKeyActionDown;
+	break;
+    case kEventRawKeyUp:
+	action = kUCKeyActionUp;
+	break;
+    case kEventRawKeyRepeat:
+	action = kUCKeyActionAutoKey;
+	break;
+    default:
+	TkMacOSXDbgMsg("Invalid parameter eKind %d", eKind);
+	return 0;
+    }
+
+    err = ChkErr(UCKeyTranslate, (const UCKeyboardLayout *) uchr, keycode,
+	    action, modifiers, keyboardType, options, deadKeyStatePtr,
+	    maxChars, &actuallength, uniChars);
+
+    if ((0 == actuallength) && (0 != *deadKeyStatePtr)) {
+	/*
+	 * More data later
+	 */
+
+	return 0;
+    }
+
+    /*
+     * Some IMEs leave residue. :-(
+     */
+
+    *deadKeyStatePtr = 0;
+
+    if (err != noErr) {
+	actuallength = 0;
+    }
+
+    return actuallength;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * KeycodeToUnicodeViaKCHRResource --
+ *
+ *	Given MacOS key event data this function generates the Unicode
+ *	characters. It does this using a 'KCHR' and the KeyTranslate API.
+ *
+ *	The parameter deadKeyStatePtr can be NULL, if no deadkey handling is
+ *	needed.
+ *
+ * Results:
+ *	The number of characters generated if any, 0 if we are waiting for
+ *	another byte of a dead-key sequence. Fills in the uniChars array with a
+ *	Unicode string.
+ *
+ * Side Effects:
+ *	None
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+KeycodeToUnicodeViaKCHRResource(
+    UniChar *uniChars,
+    int maxChars,
+    Ptr kchr,
+    TextEncoding encoding,
+    EventKind eKind,
+    UInt32 keycode,
+    UInt32 modifiers,
+    UInt32 *deadKeyStatePtr)
+{
+    UInt32 result;
+    char macBuff[3];
+    char *macStr;
+    int macStrLen, uniStrLen;
+    UInt32 dummy_state = 0;
+    CFStringRef cfString;
+
+    if (NULL == deadKeyStatePtr) {
+	deadKeyStatePtr = &dummy_state;
+    }
+
+    keycode |= modifiers;
+    result = KeyTranslate(kchr, keycode, deadKeyStatePtr);
+
+    if ((0 == result) && (0 != dummy_state)) {
+	/*
+	 * 'dummy_state' gets only filled if the caller did not want deadkey
+	 * processing (deadKeyStatePtr was NULL originally), but we still have
+	 * a deadkey. We just push the keycode for the space bar to get the
+	 * real key value.
+	 */
+
+	result = KeyTranslate(kchr, 0x31, deadKeyStatePtr);
+	*deadKeyStatePtr = 0;
+    }
+
+    if ((0 == result) && (0 != *deadKeyStatePtr)) {
+	/*
+	 * More data later
+	 */
+
+	return 0;
+    }
+
+    macBuff[0] = (char) (result >> 16);
+    macBuff[1] = (char) result;
+    macBuff[2] = 0;
+
+    if (0 != macBuff[0]) {
+	/*
+	 * If the first byte is valid, the second is too.
+	 */
+
+	macStr = macBuff;
+	macStrLen = 2;
+    } else if (0 != macBuff[1]) {
+	/*
+	 * Only the second is valid.
+	 */
+
+	macStr = macBuff+1;
+	macStrLen = 1;
+    } else {
+	/*
+	 * No valid bytes at all -- shouldn't happen.
+	 */
+
+	macStr = NULL;
+	macStrLen = 0;
+    }
+
+    if (macStrLen <= 0) {
+	return 0;
+    }
+
+    /*
+     * Use the CFString conversion routines. This is the easiest and most
+     * compatible way to get from an 8-bit string and a MacOS script code to a
+     * Unicode string.
+     *
+     * FIXME: The system ships with an Irish 'KCHR' but without the
+     * corresponding macCeltic encoding, which triggers the error below. Tcl
+     * doesn't have the macCeltic encoding either right now, so until we get
+     * that, we can just as well stick to this code. The right fix would be to
+     * use the Tcl encodings and add macCeltic and probably others
+     * there. Suitable Unicode data files for the missing encodings are
+     * available from www.evertype.com.
+     */
+
+    cfString = CFStringCreateWithCStringNoCopy(NULL, macStr, encoding,
+	    kCFAllocatorNull);
+    if (cfString == NULL) {
+	TkMacOSXDbgMsg("CFString: Can't convert with encoding %ld", encoding);
+	return 0;
+    }
+
+    uniStrLen = CFStringGetLength(cfString);
+    if (uniStrLen > maxChars) {
+	uniStrLen = maxChars;
+    }
+    CFStringGetCharacters(cfString, CFRangeMake(0,uniStrLen), uniChars);
+    CFRelease(cfString);
+
+    return uniStrLen;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkMacOSXKeycodeToUnicode --
+ *
+ *	Given MacOS key event data this function generates the Unicode
+ *	characters. It does this using OS resources and APIs.
+ *
+ *	The parameter deadKeyStatePtr can be NULL, if no deadkey handling is
+ *	needed.
+ *
+ *	This function is called from XKeycodeToKeysym() in tkMacOSKeyboard.c.
+ *
+ * Results:
+ *	The number of characters generated if any, 0 if we are waiting for
+ *	another byte of a dead-key sequence. Fills in the uniChars array with a
+ *	Unicode string.
+ *
+ * Side Effects:
+ *	None
+ *
+ *----------------------------------------------------------------------
+ */
+
+MODULE_SCOPE int
+TkMacOSXKeycodeToUnicode(
+    UniChar *uniChars,
+    int maxChars,
+    EventKind eKind,
+    UInt32 keycode,
+    UInt32 modifiers,
+    UInt32 *deadKeyStatePtr)
+{
+    Ptr resource = NULL;
+    TextEncoding encoding;
+
+    if (GetKeyboardLayout(&resource, &encoding)) {
+	return KeycodeToUnicodeViaUnicodeResource(uniChars, maxChars,
+		resource, eKind, keycode, modifiers, deadKeyStatePtr);
+    } else {
+	return KeycodeToUnicodeViaKCHRResource(uniChars, maxChars, resource,
+		encoding, eKind, keycode, modifiers, deadKeyStatePtr);
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * XGrabKeyboard --
+ *
+ *	Simulates a keyboard grab by setting the focus.
+ *
+ * Results:
+ *	Always returns GrabSuccess.
+ *
+ * Side effects:
+ *	Sets the keyboard focus to the specified window.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+XGrabKeyboard(
+    Display* display,
+    Window grab_window,
+    Bool owner_events,
+    int pointer_mode,
+    int keyboard_mode,
+    Time time)
+{
+    keyboardGrabWinPtr = Tk_IdToWindow(display, grab_window);
+
+    return GrabSuccess;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * XUngrabKeyboard --
+ *
+ *	Releases the simulated keyboard grab.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Sets the keyboard focus back to the value before the grab.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+XUngrabKeyboard(
+    Display* display,
+    Time time)
+{
+    keyboardGrabWinPtr = NULL;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkMacOSXGetCapture --
+ *
+ * Results:
+ *	Returns the current grab window
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tk_Window
+TkMacOSXGetCapture(void)
+{
+    return grabWinPtr;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkpSetCapture --
+ *
+ *	This function captures the mouse so that all future events will be
+ *	reported to this window, even if the mouse is outside the window. If
+ *	the specified window is NULL, then the mouse is released.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Sets the capture flag and captures the mouse.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+TkpSetCapture(
+    TkWindow *winPtr)		/* Capture window, or NULL. */
+{
+    while (winPtr && !Tk_IsTopLevel(winPtr)) {
+	winPtr = winPtr->parentPtr;
+    }
+#if 0
+    {
+	TkWindow *w = NULL;
+	WindowModality m;
+
+	if (winPtr) {
+	    w = winPtr;
+	    m = kWindowModalityAppModal;
+	} else if (grabWinPtr) {
+	    w = (TkWindow *) grabWinPtr;
+	    m = kWindowModalityNone;
+	}
+
+	if (w && w->window != None && TkMacOSXHostToplevelExists(w)) {
+	    ChkErr(SetWindowModality, TkMacOSXDrawableWindow(w->window), m,
+		    NULL);
+	}
+    }
+#endif
+    grabWinPtr = (Tk_Window) winPtr;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tk_SetCaretPos --
+ *
+ *	This enables correct placement of the XIM caret. This is called by
+ *	widgets to indicate their cursor placement, and the caret location is
+ *	used by TkpGetString to place the XIM caret.
+ *
+ * Results:
+ *	None
+ *
+ * Side effects:
+ *	None
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tk_SetCaretPos(
+    Tk_Window tkwin,
+    int x,
+    int y,
+    int height)
+{
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkMacOSXInitKeyboard --
+ *
+ *	This procedure initializes the keyboard layout.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+MODULE_SCOPE void
+TkMacOSXInitKeyboard(
+    Tcl_Interp *interp)
+{
+    Ptr resource;
+    TextEncoding encoding;
+
+    GetKeyboardLayout(&resource, &encoding);
+}
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 79
+ * coding: utf-8
+ * End:
+ */