* unix/tcl.m4 (Darwin): add 64bit support, check for Tiger copyfile(),

	add CFLAGS to SHLIB_LD to support passing -isysroot in env(CFLAGS) to
	configure (flag can't be present twice, so can't be in both CFLAGS and
	LDFLAGS during configure), don't use -prebind when deploying on 10.4,
	define TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING (rdar://3171542).
	(SC_ENABLE_LANGINFO, SC_TIME_HANDLER): add/fix caching, fix obsolete
	autoconf macros. Sync with tcl/unix/tcl.m4.

	* unix/configure.in: fix obsolete autoconf macros, sync gratuitous
	formatting/ordering differences with tcl/unix/configure.in.

	* unix/Makefile.in: add CFLAGS to wish/tktest link to make executable
	linking the same as during configure (needed to avoid loosing any linker
	relevant flags in CFLAGS, in particular flags that can't be in LDFLAGS).
	Avoid concurrent linking of wish and compiling of tkTestInit.o during
	parallel make, fix dependencies and flags for building tkMacOSXInit.o
	(checkstubs, checkexports): dependency and Darwin fixes
	(dist): add new macosx files.

	* macosx/tkMacOSXEvent.c (TkMacOSXProcessEvent):
	* macosx/tkMacOSXEvent.h:
	* macosx/tkMacOSXMouseEvent.c (TkMacOSXProcessMouseEvent):
	* macosx/tkMacOSXCarbonEvents.c: install standard application event
	handler, add & call functions to start and stop carbon even timer that
	runs the tcl event loop periodically during a nested carbon event loop
	in the toolbox (e.g. during menutracking) to ensure tcl timers etc
	continue to fire, register app event handler for menu tracking and HI
	command carbon events, move menu event handling to new handlers for
	those carbon events, no longer register for/handle appleevent carbon
	event (now dealt with by standard application event handler), event
	debugging code dynamically acquires carbon event debugging functions to
	allow use on Tiger where they are no longer exported from HIToolbox.

	* macosx/tkMacOSXFont.c (TkMacOSXUseAntialiasedText):
	* macosx/tkMacOSXKeyEvent.c (GetKeyboardLayout):
	* macosx/tkMacOSXCarbonEvents.c (TkMacOSXInitCarbonEvents):
	* macosx/tkMacOSXInit.c:
	* macosx/tkMacOSXInt.h: abstract common code to dynamically acquire
	address of a named symbol (from a loaded dynamic library) into new
	function TkMacOSXGetNamedSymbol() and macro TkMacOSXInitNamedSymbol.

	* macosx/tkMacOSXMenu.c (TkpNewMenu):
	* macosx/tkMacOSXMenubutton.c (MenuButtonInitControl):
	* macosx/tkMacOSXMenus.c (TkMacOSXHandleMenuSelect): switch to  modern
	utf8 aware menu manager API, remove obsolete code, add error handling.

	* macosx/tkMacOSXMouseEvent.c: define OSX 10.3 or later only constants
	if necessary to allow compilation on OSX 10.2

	* macosx/tkMacOSXWm.c (UpdateSizeHints): remove code that is never
	executed.

	* xlib/xgc.c (XCreateGC): sync with core-8-4-branch change.

	* generic/tk.h: add/correct location of version numbers in macosx files.

	* generic/tkInt.h: clarify fat compile comment.

	* macosx/Wish.pbproj/default.pbxuser (new file):
	* macosx/Wish.pbproj/jingham.pbxuser:
	* macosx/Wish.pbproj/project.pbxproj:
	* macosx/Wish.xcode/default.pbxuser:
	* macosx/Wish.xcode/project.pbxproj:
	* macosx/Wish.xcodeproj/default.pbxuser (new file):
	* macosx/Wish.xcodeproj/project.pbxproj (new file): new/updated projects
	for Xcode 2.2 on 10.4, Xcode 1.5 on 10.3 & ProjectBuilder on 10.2, with
	native tktest targets and support for universal (fat) compiles.

	* macosx/Tk-Info.plist (removed):
	* macosx/Wish-Info.plist (removed):
	* macosx/buildTkConfig.tcl (removed): remove obsolete build files.

	* macosx/README: clarification/cleanup, document new Xcode projects and
	universal (fat) builds via CFLAGS (i.e. ppc and i386 at the same time).

	* unix/Makefile.in:
	* unix/aclocal.m4:
	* unix/configure.in:
	* macosx/configure.ac (new file): add support for inclusion of
	unix/configure.in by macosx/configure.ac, allows generation of a config
	headers enabled configure script in macosx (required by Xcode projects).

	* macosx/GNUmakefile: rename from Makefile to avoid overwriting by
	configure run in tk/macosx, add support for reusing configure cache,
	build target fixes.

	* generic/tk3d.h:
	* generic/tkButton.h:
	* generic/tkCanvas.c:
	* generic/tkCanvas.h:
	* generic/tkColor.h:
	* generic/tkEntry.h:
	* generic/tkFileFilter.h:
	* generic/tkFont.c:
	* generic/tkFont.h:
	* generic/tkImage.c:
	* generic/tkImgPhoto.c:
	* generic/tkInt.h:
	* generic/tkMenu.c:
	* generic/tkMenu.h:
	* generic/tkMenubutton.h:
	* generic/tkScale.h:
	* generic/tkScrollbar.h:
	* generic/tkSelect.h:
	* generic/tkStubInit.c:
	* generic/tkStubLib.c:
	* generic/tkText.h:
	* generic/tkUndo.h:
	* macosx/tkMacOSXButton.c:
	* macosx/tkMacOSXDebug.c:
	* macosx/tkMacOSXDebug.h:
	* macosx/tkMacOSXDialog.c:
	* macosx/tkMacOSXDraw.c:
	* macosx/tkMacOSXEntry.c:
	* macosx/tkMacOSXFont.c:
	* macosx/tkMacOSXInt.h:
	* macosx/tkMacOSXMenu.c:
	* macosx/tkMacOSXMenubutton.c:
	* macosx/tkMacOSXMouseEvent.c:
	* macosx/tkMacOSXSend.c:
	* macosx/tkMacOSXSubwindows.c:
	* macosx/tkMacOSXWindowEvent.c:
	* macosx/tkMacOSXWm.c:
	* macosx/tkMacOSXXStubs.c:
	* unix/tkUnixButton.c:
	* unix/tkUnixMenu.c:
	* xlib/xgc.c: ensure externally visible symbols not contained in stubs
	table are declared as MODULE_SCOPE (or as static if not used outside of
	own source file), #ifdef out a few Xlib and aqua functions that are
	never called. These changes allow 'make checkstubs' to complete without
	error on Darwin with gcc 4.

	* macosx/tkMacOSXTest.c:
	* macosx/tkMacOSXPort.h:
	* win/tkWinTest.c:
	* generic/tkInt.decls: add functions needed by tktest to internal stubs
	table, correct signature of TkMacOSXHandleMenuSelect, add XSync to aqua
	Xlib stubs.

	* unix/tkUnixSend.c:
	* generic/tkText.c:
	* generic/tkTest.c: #ifdef unix only declarations.
	(TestmetricsCmd): unify win and mac implementation.
	(TestsendCmd): move to tkUnixSend.c to avoid access to global var.
	(TesttextCmd): move to tkText.c to avoid having to put all the internal
	text functions it uses into the stubs table.

	* generic/tkTextDisp.c:
	* macosx/tkMacOSXInit.c:
	* macosx/tkMacOSXKeyEvent.c:
	* macosx/tkMacOSXWindowEvent.c:
	* macosx/tkMacOSXXStubs.c: fix gcc 4 warnings.

	* macosx/tkMacOSXNotify.c:
	* macosx/tkMacOSXScrlbr.c: sync with core-8-4-branch.

	* generic/tkIntDecls.h:
	* generic/tkIntPlatDecls.h:
	* generic/tkIntXlibDecls.h:
	* generic/tkStubInit.c:
	* unix/configure:
	* unix/tkConfig.h.in: regen.

1 files changed, 343 insertions, 85 deletions

diff --git a/macosx/tkMacOSXCarbonEvents.c b/macosx/tkMacOSXCarbonEvents.c
index 94e5f13..ef2e32d 100644
--- a/macosx/tkMacOSXCarbonEvents.c
+++ b/macosx/tkMacOSXCarbonEvents.c
@@ -2,12 +2,19 @@
  * tkMacOSXCarbonEvents.c --
  *
  *	This file implements functions that register for and handle
- *      various Carbon Events.  The reason a separate set of handlers 
- *      is necessary is that not all interesting events get delivered
- *      directly to the event queue through ReceiveNextEvent.  Some only
- *      get delivered if you register a Carbon Event Handler for the event.
+ *	various Carbon Events and Timers. Most carbon events of interest
+ *	to TkAqua are processed in a handler registered on the dispatcher
+ *	event target so that we get first crack at them before HIToolbox
+ *	dispatchers/processes them further.
+ *	As some events are sent directly to the focus or app event target
+ *	and not dispatched normally, we also register a handler on the
+ *	application event target.
  *
- *      Copyright 2001, Apple Computer, Inc.
+ * Copyright 2001, Apple Computer, Inc.
+ * Copyright (c) 2005 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
@@ -53,7 +60,7 @@
  *      software in accordance with the terms specified in this
  *      license.
  *
- * RCS: @(#) $Id: tkMacOSXCarbonEvents.c,v 1.5 2005/09/10 15:11:15 das Exp $
+ * RCS: @(#) $Id: tkMacOSXCarbonEvents.c,v 1.6 2005/11/27 02:36:14 das Exp $
  */
 
 #include "tkInt.h"
@@ -62,69 +69,83 @@
 #include "tkMacOSXDebug.h"
 
 /*
-#ifdef  TK_MAC_DEBUG
+#ifdef	TK_MAC_DEBUG
 #define TK_MAC_DEBUG_CARBON_EVENTS
 #endif
 */
 
-#ifdef TK_MAC_DEBUG_CARBON_EVENTS
-/* Carbon-internal event debugging routines (c.f. Technote 2124): */
-void _DebugPrintEvent(EventRef inEvent);
-void _TraceEventByName(CFStringRef eventName);
-#endif /* TK_MAC_DEBUG_CARBON_EVENTS */
-
 /* Declarations of functions used only in this file */
-static OSStatus CarbonEventHandlerProc (
-                              EventHandlerCallRef callRef,
-                              EventRef inEvent,
-                              void *userData);
+static OSStatus CarbonEventHandlerProc(EventHandlerCallRef callRef,
+			      EventRef event, void *userData);
+static OSStatus InstallStandardApplicationEventHandler();
+static void ExitRaelEventHandlerProc (EventHandlerCallRef, EventRef, void*)
+	__attribute__ ((__noreturn__));
+static void CarbonTimerProc(EventLoopTimerRef timer, void *userData);
+
+/* Static data used by several functions in this file */
+static jmp_buf exitRaelJmpBuf;
+static EventLoopTimerRef carbonTimer = NULL;
+static int carbonTimerEnabled = 0;
 
 /*
  *----------------------------------------------------------------------
  *
  * CarbonEventHandlerProc --
  *
- *        This procedure is the handler for all registered CarbonEvents.
+ *	  This procedure is the handler for all registered CarbonEvents.
  *
  * Results:
- *        None.
+ *	  OS status code.
  *
  * Side effects:
- *        Dispatches CarbonEvents.
+ *	  Dispatches CarbonEvents.
  *
  *----------------------------------------------------------------------
  */
 
 static OSStatus
 CarbonEventHandlerProc (
-        EventHandlerCallRef callRef,
-        EventRef inEvent,
-        void *inUserData)
+	EventHandlerCallRef callRef,
+	EventRef event,
+	void *userData)
 {
-    OSStatus         result = eventNotHandledErr;
+    OSStatus	     result = eventNotHandledErr;
     TkMacOSXEvent    macEvent;
     MacEventStatus   eventStatus;
 
+    macEvent.eventRef = event;
+    macEvent.eClass = GetEventClass(macEvent.eventRef);
+    macEvent.eKind = GetEventKind(macEvent.eventRef);
+    macEvent.interp = (Tcl_Interp *) userData;
+    bzero(&eventStatus, sizeof(eventStatus));
+
 #ifdef TK_MAC_DEBUG_CARBON_EVENTS
     char buf [256];
-    CarbonEventToAscii(inEvent, buf);
-    fprintf(stderr, "CarbonEventHandlerProc started handling %s\n", buf);
-    _DebugPrintEvent(inEvent);
+    if (macEvent.eKind != kEventMouseMoved &&
+	    macEvent.eKind != kEventMouseDragged) {
+	CarbonEventToAscii(event, buf);
+	fprintf(stderr, "CarbonEventHandlerProc started handling %s\n", buf);
+	TkMacOSXInitNamedSymbol(HIToolbox, void, _DebugPrintEvent,
+		EventRef inEvent);
+	if (_DebugPrintEvent) {
+	    /* Carbon-internal event debugging (c.f. Technote 2124) */
+	    _DebugPrintEvent(event);
+	}
+    }
 #endif /* TK_MAC_DEBUG_CARBON_EVENTS */
 
-    macEvent.eventRef = inEvent;
-    macEvent.eClass = GetEventClass(macEvent.eventRef);
-    macEvent.eKind = GetEventKind(macEvent.eventRef);
-    macEvent.interp = (Tcl_Interp *) inUserData;
-    bzero(&eventStatus, sizeof(eventStatus));
     TkMacOSXProcessEvent(&macEvent,&eventStatus);
     if (eventStatus.stopProcessing) {
-        result = noErr;
+	result = noErr;
     }
 
 #ifdef TK_MAC_DEBUG_CARBON_EVENTS
-    fprintf(stderr, "CarbonEventHandlerProc finished handling %s: %s handled\n", buf,
-                eventStatus.stopProcessing ? "   " : "not");
+    if (macEvent.eKind != kEventMouseMoved &&
+	    macEvent.eKind != kEventMouseDragged) {
+	fprintf(stderr,
+		"CarbonEventHandlerProc finished handling %s: %s handled\n",
+		buf, eventStatus.stopProcessing ? "   " : "not");
+    }
 #endif /* TK_MAC_DEBUG_CARBON_EVENTS */
     return result;
 }
@@ -134,75 +155,312 @@ CarbonEventHandlerProc (
  *
  * TkMacOSXInitCarbonEvents --
  *
- *        This procedure initializes all CarbonEvent handlers.
+ *	  This procedure initializes all CarbonEvent handlers.
  *
  * Results:
- *        None.
+ *	  None.
  *
  * Side effects:
- *        Handlers for Carbon Events are registered.
+ *	  Handlers for Carbon Events are registered.
  *
  *----------------------------------------------------------------------
  */
 
 MODULE_SCOPE void
 TkMacOSXInitCarbonEvents (
-        Tcl_Interp *interp)
+	Tcl_Interp *interp)
 {
+    OSStatus err;
     const EventTypeSpec dispatcherEventTypes[] = {
-            {kEventClassMouse,          kEventMouseDown},
-            {kEventClassMouse,          kEventMouseUp},
-            {kEventClassMouse,          kEventMouseMoved},
-            {kEventClassMouse,          kEventMouseDragged},
-            {kEventClassMouse,          kEventMouseWheelMoved},
-            {kEventClassWindow,         kEventWindowUpdate},
-            {kEventClassWindow,         kEventWindowActivated},
-            {kEventClassWindow,         kEventWindowDeactivated},
-            {kEventClassKeyboard,       kEventRawKeyDown},
-            {kEventClassKeyboard,       kEventRawKeyRepeat},
-            {kEventClassKeyboard,       kEventRawKeyUp},
-            {kEventClassKeyboard,       kEventRawKeyModifiersChanged},
-            {kEventClassKeyboard,       kEventRawKeyRepeat},
-            {kEventClassApplication,    kEventAppActivated},
-            {kEventClassApplication,    kEventAppDeactivated},
-            {kEventClassApplication,    kEventAppQuit},
-            {kEventClassAppleEvent,     kEventAppleEvent},
+	    {kEventClassMouse,		kEventMouseDown},
+	    {kEventClassMouse,		kEventMouseUp},
+	    {kEventClassMouse,		kEventMouseMoved},
+	    {kEventClassMouse,		kEventMouseDragged},
+	    {kEventClassMouse,		kEventMouseWheelMoved},
+	    {kEventClassWindow,		kEventWindowUpdate},
+	    {kEventClassWindow,		kEventWindowActivated},
+	    {kEventClassWindow,		kEventWindowDeactivated},
+	    {kEventClassKeyboard,	kEventRawKeyDown},
+	    {kEventClassKeyboard,	kEventRawKeyRepeat},
+	    {kEventClassKeyboard,	kEventRawKeyUp},
+	    {kEventClassKeyboard,	kEventRawKeyModifiersChanged},
+	    {kEventClassKeyboard,	kEventRawKeyRepeat},
+	    {kEventClassApplication,	kEventAppActivated},
+	    {kEventClassApplication,	kEventAppDeactivated},
+	    {kEventClassApplication,	kEventAppQuit},
     };
     const EventTypeSpec applicationEventTypes[] = {
-            {kEventClassWindow,         kEventWindowExpanded},
-            {kEventClassApplication,    kEventAppHidden},
-            {kEventClassApplication,    kEventAppShown},
+	    {kEventClassMenu,		kEventMenuBeginTracking},
+	    {kEventClassMenu,		kEventMenuEndTracking},
+	    {kEventClassCommand,	kEventCommandProcess},
+	    {kEventClassWindow,		kEventWindowExpanded},
+	    {kEventClassApplication,	kEventAppHidden},
+	    {kEventClassApplication,	kEventAppShown},
     };
     EventHandlerUPP handler = NewEventHandlerUPP(CarbonEventHandlerProc);
 
-    InstallEventHandler(GetEventDispatcherTarget(), handler,
-            GetEventTypeCount(dispatcherEventTypes), dispatcherEventTypes,
-            (void *) interp, NULL);
-    InstallEventHandler(GetApplicationEventTarget(), handler,
-            GetEventTypeCount(applicationEventTypes), applicationEventTypes,
-            (void *) interp, NULL);
+    err = InstallStandardApplicationEventHandler();
+    if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+	fprintf(stderr, "InstallStandardApplicationEventHandler failed, %d\n",
+		(int) err);
+#endif
+    }
+    err = InstallEventHandler(GetEventDispatcherTarget(), handler,
+	    GetEventTypeCount(dispatcherEventTypes), dispatcherEventTypes,
+	    (void *) interp, NULL);
+    if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+	fprintf(stderr, "InstallEventHandler failed, %d\n", (int) err);
+#endif
+    }
+    err = InstallEventHandler(GetApplicationEventTarget(), handler,
+	    GetEventTypeCount(applicationEventTypes), applicationEventTypes,
+	    (void *) interp, NULL);
+    if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+	fprintf(stderr, "InstallEventHandler failed, %d\n", (int) err);
+#endif
+    }
+
+#ifdef TK_MAC_DEBUG_CARBON_EVENTS
+    TkMacOSXInitNamedSymbol(HIToolbox, void, _TraceEventByName, CFStringRef);
+    if (_TraceEventByName) {
+	/* Carbon-internal event debugging (c.f. Technote 2124) */
+	_TraceEventByName(CFSTR("kEventMouseDown"));
+	_TraceEventByName(CFSTR("kEventMouseUp"));
+	_TraceEventByName(CFSTR("kEventMouseWheelMoved"));
+	_TraceEventByName(CFSTR("kEventWindowUpdate"));
+	_TraceEventByName(CFSTR("kEventWindowActivated"));
+	_TraceEventByName(CFSTR("kEventWindowDeactivated"));
+	_TraceEventByName(CFSTR("kEventRawKeyDown"));
+	_TraceEventByName(CFSTR("kEventRawKeyRepeat"));
+	_TraceEventByName(CFSTR("kEventRawKeyUp"));
+	_TraceEventByName(CFSTR("kEventRawKeyModifiersChanged"));
+	_TraceEventByName(CFSTR("kEventRawKeyRepeat"));
+	_TraceEventByName(CFSTR("kEventAppActivated"));
+	_TraceEventByName(CFSTR("kEventAppDeactivated"));
+	_TraceEventByName(CFSTR("kEventAppQuit"));
+	_TraceEventByName(CFSTR("kEventMenuBeginTracking"));
+	_TraceEventByName(CFSTR("kEventMenuEndTracking"));
+	_TraceEventByName(CFSTR("kEventCommandProcess"));
+	_TraceEventByName(CFSTR("kEventWindowExpanded"));
+	_TraceEventByName(CFSTR("kEventAppHidden"));
+	_TraceEventByName(CFSTR("kEventAppShown"));
+    }
+#endif /* TK_MAC_DEBUG_CARBON_EVENTS */
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * InstallStandardApplicationEventHandler --
+ *
+ *	  This procedure installs the carbon standard application event
+ *	  handler.
+ *
+ * Results:
+ *	  OS status code.
+ *
+ * Side effects:
+ *	  Standard handlers for application Carbon Events are registered.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static OSStatus
+InstallStandardApplicationEventHandler()
+{
+   /*
+    * This is a hack to workaround missing Carbon API to install the standard
+    * application event handler (InstallStandardEventHandler() does not work
+    * on the application target). The only way to install the standard app
+    * handler is to call RunApplicationEventLoop(), but since we are running
+    * our own event loop, we'll immediately need to break out of RAEL again:
+    * we do this via longjmp out of the ExitRaelEventHandlerProc event handler
+    * called first off from RAEL by posting a high priority dummy event.
+    * This workaround is derived from a similar approach in Technical Q&A 1061.
+    */
+    enum { kExitRaelEvent = 'ExiT' };
+    const EventTypeSpec exitRaelEventType =
+	    { kExitRaelEvent,		kExitRaelEvent};
+    EventHandlerUPP exitRaelEventHandler;
+    EventHandlerRef exitRaelEventHandlerRef = NULL;
+    EventRef exitRaelEvent = NULL;
+    OSStatus err = memFullErr;
+
+    exitRaelEventHandler = NewEventHandlerUPP(
+	    (EventHandlerProcPtr) ExitRaelEventHandlerProc);
+    if (exitRaelEventHandler) {
+	err = InstallEventHandler(GetEventDispatcherTarget(),
+		exitRaelEventHandler, 1, &exitRaelEventType, NULL,
+		&exitRaelEventHandlerRef);
+    }
+    if (err == noErr) {
+	err = CreateEvent(NULL, kExitRaelEvent, kExitRaelEvent, 
+		GetCurrentEventTime(), kEventAttributeNone, &exitRaelEvent);
+    }
+    if (err == noErr) {
+	err = PostEventToQueue(GetMainEventQueue(), exitRaelEvent,
+		kEventPriorityHigh);
+    }
+    if (err == noErr) {
+	if (!setjmp(exitRaelJmpBuf)) {
+	    RunApplicationEventLoop();
+	    /* This point should never be reached ! */
+	    Tcl_Panic("RunApplicationEventLoop exited !");
+	}
+    }
+    if (exitRaelEvent) {
+	ReleaseEvent(exitRaelEvent);
+    }
+    if (exitRaelEventHandlerRef) {
+	RemoveEventHandler(exitRaelEventHandlerRef);
+    }
+    if (exitRaelEventHandler) {
+	DisposeEventHandlerUPP(exitRaelEventHandler);
+    }
+    return err;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ExitRaelEventHandlerProc --
+ *
+ *	  This procedure is the dummy event handler used to break out of
+ *	  RAEL via longjmp, it is called as the first ever event handler
+ *	  in RAEL by posting a high priority dummy event.
+ *
+ * Results:
+ *	  None. Never returns !
+ *
+ * Side effects:
+ *	  longjmp back to InstallStandardApplicationEventHandler().
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+ExitRaelEventHandlerProc (
+	EventHandlerCallRef callRef,
+	EventRef event, void *userData)
+{
+    longjmp(exitRaelJmpBuf, 1);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * CarbonTimerProc --
+ *
+ *	  This procedure is the carbon timer handler that runs the tcl
+ *	  event loop periodically. It does not process TCL_WINDOW_EVENTS
+ *	  to avoid reentry issues with Carbon, nor TCL_IDLE_EVENTS since
+ *	  it is only intended to be called during short periods of busy
+ *	  time such as during menu tracking.
+ *
+ * Results:
+ *	  None.
+ *
+ * Side effects:
+ *	  Runs the Tcl event loop.
+ *
+ *----------------------------------------------------------------------
+ */
 
+static void
+CarbonTimerProc (
+	EventLoopTimerRef timer,
+	void *userData)
+{
+    while(carbonTimerEnabled && Tcl_DoOneEvent(
+	    TCL_FILE_EVENTS|TCL_TIMER_EVENTS|TCL_DONT_WAIT)) {
 #ifdef TK_MAC_DEBUG_CARBON_EVENTS
-    _TraceEventByName(CFSTR("kEventMouseDown"));
-    _TraceEventByName(CFSTR("kEventMouseUp"));
-    _TraceEventByName(CFSTR("kEventMouseMoved"));
-    _TraceEventByName(CFSTR("kEventMouseDragged"));
-    _TraceEventByName(CFSTR("kEventMouseWheelMoved"));
-    _TraceEventByName(CFSTR("kEventWindowUpdate"));
-    _TraceEventByName(CFSTR("kEventWindowActivated"));
-    _TraceEventByName(CFSTR("kEventWindowDeactivated"));
-    _TraceEventByName(CFSTR("kEventRawKeyDown"));
-    _TraceEventByName(CFSTR("kEventRawKeyRepeat"));
-    _TraceEventByName(CFSTR("kEventRawKeyUp"));
-    _TraceEventByName(CFSTR("kEventRawKeyModifiersChanged"));
-    _TraceEventByName(CFSTR("kEventRawKeyRepeat"));
-    _TraceEventByName(CFSTR("kEventAppActivated"));
-    _TraceEventByName(CFSTR("kEventAppDeactivated"));
-    _TraceEventByName(CFSTR("kEventAppQuit"));
-    _TraceEventByName(CFSTR("kEventAppleEvent"));
-    _TraceEventByName(CFSTR("kEventWindowExpanded"));
-    _TraceEventByName(CFSTR("kEventAppHidden"));
-    _TraceEventByName(CFSTR("kEventAppShown"));
+	fprintf(stderr, "Processed tcl event from carbon timer\n");
 #endif /* TK_MAC_DEBUG_CARBON_EVENTS */
+    }
 }
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkMacOSXStartTclEventLoopCarbonTimer --
+ *
+ *	  This procedure installs (if necessary) and starts a carbon
+ *	  event timer that runs the tcl event loop periodically.
+ *	  It should be called whenever a nested carbon event loop is
+ *	  run by HIToolbox (e.g. during menutracking) to ensure that
+ *	  non-window non-idle tcl events are processed.
+ *
+ * Results:
+ *	  OS status code.
+ *
+ * Side effects:
+ *	  Carbon event timer is installed and started.
+ *
+ *----------------------------------------------------------------------
+ */
+
+MODULE_SCOPE OSStatus
+TkMacOSXStartTclEventLoopCarbonTimer()
+{
+    OSStatus err;
+
+    if(!carbonTimer) {
+	EventLoopTimerUPP timerUPP = NewEventLoopTimerUPP(CarbonTimerProc);
+	err = InstallEventLoopTimer(GetMainEventLoop(), kEventDurationNoWait,
+		5 * kEventDurationMillisecond, timerUPP, NULL, &carbonTimer);
+	if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+	    fprintf(stderr, "InstallEventLoopTimer failed, %d\n", (int) err);
+#endif
+	}
+    } else {
+	err = SetEventLoopTimerNextFireTime(carbonTimer, kEventDurationNoWait);
+	if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+	    fprintf(stderr, "SetEventLoopTimerNextFireTime failed, %d\n",
+		    (int) err);
+#endif
+	}
+    }
+    carbonTimerEnabled = 1;
+    return err;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkMacOSXStopTclEventLoopCarbonTimer --
+ *
+ *	  This procedure stops the carbon event timer started by
+ *	  TkMacOSXStartTclEventLoopCarbonTimer().
+ *
+ * Results:
+ *	  OS status code.
+ *
+ * Side effects:
+ *	 Carbon event timer is stopped.
+ *
+ *----------------------------------------------------------------------
+ */
+
+MODULE_SCOPE OSStatus
+TkMacOSXStopTclEventLoopCarbonTimer()
+{
+    OSStatus err = noErr;
 
+    if(carbonTimer) {
+	err = SetEventLoopTimerNextFireTime(carbonTimer, kEventDurationForever);
+	if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+	    fprintf(stderr, "SetEventLoopTimerNextFireTime failed, %d\n",
+		    (int) err);
+#endif
+	}
+    }
+    carbonTimerEnabled = 0;
+    return err;
+}
+