* macosx/tkMacOSXCarbonEvents.c: add window event target carbon event

	* macosx/tkMacOSXEvent.c:	 handler for all kEventClassWindow and
	* macosx/tkMacOSXEvent.h:	 kEventClassMouse events;
	* macosx/tkMacOSXNotify.c:	 move all remaining events except for
	* macosx/tkMacOSXWindowEvent.c:	 kEventClassKeyboard from dispatcher to
	application event handler; pass event handler callRef downstream; fix
	debug event tracing; process all tcl event types in carbon event timer;
	delay carbon event timer first fire; add TkMacOSXTrackingLoop() to mark
	enter/exit of event tracking loop during which all tcl events but only
	carbon update events should be processed by the timer (replaces various
	calls to Tcl_SetServiceMode()); rename TkMacOSXReceiveAndProcessEvent()
	to TkMacOSXReceiveAndDispatchEvent(), move it from tkMacOSXEvent.c to
	tkMacOSXCarbonEvents.c and modify it to dequeue only update events
	during a tracking loop; add TkMacOSXRunTclEventLoop() to standardize
	the various ways in use to run the tcl event loop; add handling of
	kEventClassAppearance events (for ScrollBarVariantChanged event).

	* macosx/tkMacOSXDialog.c:	use new TkMacOSXTrackingLoop() around
	* macosx/tkMacOSXEvent.c:	blocking API that puts up modal dialogs
	* macosx/tkMacOSXMenu.c:	or when entering/exiting menu/control
	* macosx/tkMacOSXMouseEvent.c:	tracking, window dragging and other
	* macosx/tkMacOSXScale.c:	mouse tracking loops.
	* macosx/tkMacOSXScrlbr.c:
	* macosx/tkMacOSXWindowEvent.c:
	* macosx/tkMacOSXWm.c:

	* macosx/tkMacOSXDialog.c:	use new TkMacOSXRunTclEventLoop()
	* macosx/tkMacOSXScale.c:	instead of Tcl_DoOneEvent(),
	* macosx/tkMacOSXScrlbr.c:	Tcl_ServiceAll(), TclServiceIdle()
	* macosx/tkMacOSXWindowEvent.c:	and Tcl_GlobalEval("update idletasks").

	* macosx/tkMacOSXColor.c: make available as Tk system colors all
	* macosx/tkMacOSXPort.h:  appearance manager brushes, text colors and
	backgrounds with new and legacy names, as well as the fully transparent
	color "systemTransparent"; add TkMacOSXSetColorIn{Port,Context}() to
	directly set an X pixel color value in the current QD port resp. the
	given CG context without requiring passage through rgb representation
	(lossy for most system colors); modernize/remove Classic-era code;
	replace crufty strcmp() elseifs by Tcl_GetIndexFromObjStruct().

	* macosx/tkMacOSXButton.c:	use new TkMacOSXSetColorInPort()
	* macosx/tkMacOSXDraw.c:	instead of setting rgb color directly
	* macosx/tkMacOSXMenubutton.c:	to allow for non-rgb system colors.

	* macosx/tkMacOSXCursor.c: implement "none" cursor as on other
	platforms [Patch 1615427]; add all missing appearance manager cursors.

	* macosx/tkMacOSXDefault.h: set SELECT_FG_COLORs to None to match aqua
	L&F; use standard system color names; use new 'menu' system font;
	correct default scrollbar width.

	* macosx/tkMacOSXDraw.c:	standardize initialization, use and
	* macosx/tkMacOSXInt.h:		emptying of various static temp rgns
	* macosx/tkMacOSXRegion.c:	onto two global RgnHandles; in debug
	* macosx/tkMacOSXSubwindows.c:	builds, verify emptiness of these temp
	* macosx/tkMacOSXWindowEvent.c:	rgns before use.

	* macosx/tkMacOSXDraw.c: add TkMacOSX{Setup,Restore}DrawingContext() to
	* macosx/tkMacOSXInt.h:  abstract common setup & teardown of drawing
	environment (for both CG and QD); save/restore QD theme drawing state;
	handle GC clip region; add TkpClipDrawableToRect() to allow clipped
	drawing into drawable regardless of GC used; use new system color
	"systemWindowHeaderBackground" to setup background in themed toplevels;
	correct implementation of TkMacOSXMakeStippleMap().

	* macosx/tkMacOSXEntry.c:  use new TkMacOSXSetupDrawingContext() and
	* macosx/tkMacOSXFont.c:   TkMacOSXRestoreDrawingContext() instead of
	* macosx/ttkMacOSXTheme.c: various setup/teardown procs like
	TkMacOSX{SetUp,Release}CGContext(), TkMacOSXQuarz{Start,End}Draw(),
	TkMacOSXSetUpGraphicsPort() etc.

	* macosx/tkMacOSXEmbed.c: add CG context and drawable clip rgn fields
	* macosx/tkMacOSXInt.h:   to MacDrawable struct.
	* macosx/tkMacOSXSubwindows.c:

	* macosx/tkMacOSXDialog.c: make -parent option of tk_getOpenFile et al.
	use the sheet version of NavServices dialogs; ensure native parent win
	exists before using StandardSheet API for tk_messageBox [Bug 1677611];
	force sheets to behave like app-modal dialogs via WindowModality() API;
	use more modern ColorPicker API.

	* macosx/tkAboutDlg.r: use themed movable modal dialog, fix (c) year.

	* macosx/tkMacOSXEntry.c:  take xOff/yOff of MacDrawable into account
	* macosx/ttkMacOSXTheme.c: when computing locations/bounds to ensure
	correct posititioning when not drawing into intermediate pixmap.

	* macosx/tkMacOSXFont.c: use appearance manager API to map system font
	* macosx/tkMacOSXFont.h: names to TkFonts; add "menu" system font for
	menu item text drawing from MDEF; always draw with CG; remove QD
	dependent stippling algorithm; move most header declarations into the
	source file (as they were not used anywhere else).

	* macosx/tkMacOSXMenu.c:		 large-scale rewrite of custom
	* macosx/tkMacOSXMenu.r (removed):	 MDEF and related code that
	* macosx/Wish.xcode/project.pbxproj:	 restores many longtime-MIA
	* macosx/Wish.xcodeproj/project.pbxproj: features to working order
	* unix/Makefile.in:			 (e.g. images, custom colors &
	fonts in menus etc); implement compound menu items; use Appearance Mgr
	and ThemeText APIs to mimic native MDEF as closely as possible when
	default "menu" system font is used; remove now obsolete SICN drawing
	code and resources.

	* macosx/tkMacOSXCarbonEvents.c: handle additional menu carbon events
	* macosx/tkMacOSXEvent.c:	 in order to support <<MenuSelect>> in
	* macosx/tkMacOSXMenu.c:	 the menubar and in menus that are not
	* macosx/tkMacOSXMenus.c:	 using the custom MDEF [Bug 1620826];
	fix early and missing clearing of current Tk active menu entry; fix
	extraneous sending of <<MenuSelect>> during active menu entry clearing.

	* macosx/tkMacOSXMouseEvent.c: add support for async window dragging by
	the window server; set the corresponding window attribute by default.

	* macosx/tkMacOSXMouseEvent.c: rationalized handling order of
	non-mousedown events; add TkMacOSXModifierState() to retrieve the
	current key modifiers in carbon format.

	* macosx/tkMacOSXScrlbr.c: use appearance manager API to retrieve
	scrollbar component metrics; add awareness of multiple possibilites for
	scrollbar arrow position in aqua and handle user changes to arrow
	position pref; handle difference in metrics of small & large scrollbar
	variants; handle aqua "jump to here" scrollbar behaviour; correct
	computation of scroll view size and position; enforce min scrollbar
	height to avoid scrollbar component overlap; erase scrollbar area
	outside of standard width; remove broken auto-adjust code; account for
	window class when leaving space for grow box; remove code to manually
	draw grow box; use modern API for thumb scroll proc; replace
	HiliteControl() by modern API; replace control mgr constants with
	appearance mgr equivalents.

	* macosx/tkMacOSXSubwindows.c: use SetWindowBounds() API instead of
	SizeWindow(); invalidate clip regions after X{Map,Unmap}Window as fix
	for [Bug 940117] made them dependent on mapping state; remove unneeded
	calls to TkMacOSXInvalClipRgns() and unnecessary setting of QD port;
	use native-endian pixmap on intel; remove obsolete pixmap pix locking.

	* macosx/tkMacOSXWindowEvent.c: handle only the first of a batch of
	kEventAppAvailableWindowBoundsChanged events sent per transaction;
	handle kEventWindowBoundsChanged event to support live window resizing
	and centralized sending of location/size changed ConfigureNotify
	events; ensure HIGrowBox is redrawn after bounds change; constrain
	window after dragging to ensure titlebar is not inacessible
	offscreen or under dock/menubar; handle kEventWindowGetRegion and
	kEventWindowDrawContent for transparent windows to mark resp. paint
	content region as transparent; handle kEventWindowConstrain for
	fullscreen windows to ensure bounds match new screen size; enter/exit
	fullscreen UIMode upon activation/deactivation of fullscreen window.

	* macosx/tkMacOSXWm.c: use live-resize and async-drag carbon window
	* macosx/tkMacOSXWm.h: attributes for toplevels by default; implement
	new [wm attributes] -topmost, -transparent and -fullscreen; refactor
	WmAttributesCmd() parallelling the tkUnixWm.c implementation, use thus
	factored proc to set proxy icon from [wm iconbitmap]; dynamically
	determine default values for toplevel min and max sizes (similar to
	tkWinWm.c impl): min sizes depend on window class & attributes to
	ensure visibility of all titlebar widgets and grow box, max sizes
	depend on maximal window bounds for all active displays; factor out
	code that puts into effect changes to master or override_redirect; use
	RepositionWindow() API to determine staggered initial window bounds;
	correct resize limit calculations, handle gridding and use modern
	resize API in TkMacOSXGrowToplevel(); remove sending of ConfigureNotify
	after resize or zoom (now handled by BoundsChanged handler); correct
	composite carbon window attribute handling, remove currently unusable
	attributes and add new attributes in [tk::unsupported::MacWindowStyle];
	ensure validity of window class and attributes before use; apply
	changes to window class when handling carbon window attribute changes
	(if HIWindowChangeClass() API available); add debug build warning
	message when deprecated window style is used instead of window class;
	use transparent HIGrowBox for resizable windows; avoid unnecessary
	calls to window structure width API; use tcl time API in TkpGetMS();
	add TkMacOSXEnterExitFullscreen() to enter/exit UIMode with dock and
	menubar hidden; restrict wmTracing output to debug builds; remove
	unneeded calls to TkMacOSXInvalClipRgns() and unnecessary setting of QD
	port; workaround GetWindowStructureWidths() Carbon bug (bogus results
	for never-mapped floating windows).

	* macosx/tkMacOSXXStubs.c (TkMacOSXDisplayChanged): add maximal window
	bounds field to Screen record (in ext_data), computed as the union of
	available window positioning bounds of all graphics devices (displays).

	* macosx/tkMacOSXBitmap.c: fix macRoman encoding leak.
	* macosx/tkMacOSXCursor.c:

	* macosx/tkMacOSXDebug.c (TkMacOSXCarbonEventToAscii): use static
	* macosx/tkMacOSXDebug.h: buffer to simplify callers; const fixes.

	* macosx/tkMacOSXBitmap.c: use more efficient QDSwapPort() instead of
	* macosx/tkMacOSXButton.c: GetPort()/SetPort()/GetGWorld()/SetGWorld().
	* macosx/tkMacOSXDraw.c:
	* macosx/tkMacOSXMenubutton.c:
	* macosx/tkMacOSXScale.c:
	* macosx/tkMacOSXScrlbr.c:
	* macosx/tkMacOSXXStubs.c:

	* macosx/tkMacOSXColor.c: use kHIToolboxVersionNumber for runtime OS
	* macosx/tkMacOSXEntry.c: version check rather than Gestalt() etc.
	* macosx/tkMacOSXInt.h:
	* macosx/tkMacOSXWm.c:

	* macosx/tkMacOSXDraw.c: remove obsolete and now incorrect
	* macosx/tkMacOSXInt.h:  tkMenuCascadeRgn clipping code.
	* macosx/tkMacOSXMenu.c:

	* macosx/tkMacOSXHLEvents.c: replace Tcl_GlobalEval() resp. Tcl_Eval()
	* macosx/tkMacOSXScrlbr.c:   by Tcl_EvalEx().
	* macosx/tkMacOSXInit.c:

	* macosx/tkMacOSXInit.c (TkpInit): reorder initialization steps.

	* macosx/tkMacOSXKeyEvent.c: remove pre-10.2 support.

	* macosx/tkMacOSXMenus.c: remove now useless call to
	TkMacOSXHandleTearoffMenu(); use \x.. quoting for non-latin1 macroman
	literar chars to allow file to be edited as utf-8.

	* macosx/tkMacOSXScale.c: replace TrackControl() by modern
	* macosx/tkMacOSXScrlbr.c: HandleControlClick() API (using new
	TkMacOSXModifierState()).

	* macosx/tkMacOSXInt.h:		move all constant #defines needed to
	* macosx/tkMacOSXColor.c:	support building on older OS X releases
	* macosx/tkMacOSXEvent.h:	to a central location in tkMacOSXInt.h.
	* macosx/tkMacOSXFont.c:
	* macosx/tkMacOSXMenu.c:
	* macosx/tkMacOSXMenubutton.c:
	* macosx/tkMacOSXMenus.c:
	* macosx/tkMacOSXMouseEvent.c:
	* macosx/tkMacOSXWm.c:
	* macosx/ttkMacOSXTheme.c:

	* macosx/tkMacOSXInt.h:		 add ChkErr() macro to factor out
	* macosx/tkMacOSXButton.c:	 Carbon OSStatus return value checking
	* macosx/tkMacOSXCarbonEvents.c: and TkMacOSXDbgMsg() macro to factour
	* macosx/tkMacOSXClipboard.c:	 out debug message output; use these
	* macosx/tkMacOSXColor.c:	 macros to replace #ifdef TK_MAC_DEBUG
	* macosx/tkMacOSXCursor.c:	 blocks & direct printing to stderr,
	* macosx/tkMacOSXDebug.c:	 and to do additional OSStatus return
	* macosx/tkMacOSXDialog.c:	 checking, and to standardize OSStatus
	* macosx/tkMacOSXDraw.c:	 usage.
	* macosx/tkMacOSXEntry.c:
	* macosx/tkMacOSXEvent.c:
	* macosx/tkMacOSXFont.c:
	* macosx/tkMacOSXHLEvents.c:
	* macosx/tkMacOSXInit.c:
	* macosx/tkMacOSXKeyEvent.c:
	* macosx/tkMacOSXMenu.c:
	* macosx/tkMacOSXMenubutton.c:
	* macosx/tkMacOSXMenus.c:
	* macosx/tkMacOSXMouseEvent.c:
	* macosx/tkMacOSXScrlbr.c:
	* macosx/tkMacOSXSubwindows.c:
	* macosx/tkMacOSXWindowEvent.c:
	* macosx/tkMacOSXWm.c:
	* macosx/tkMacOSXXStubs.c:

	* macosx/tkMacOSXSend.c:	remove duplicate/unused declarations
	* macosx/tkMacOSXXStubs.c:

	* macosx/tkMacOSXDebug.c:	const fixes.
	* macosx/tkMacOSXInit.c:
	* macosx/tkMacOSXTest.c:
	* macosx/tkMacOSXWm.c:
	* macosx/tkMacOSXXStubs.c:

	* macosx/Wish-Info.plist.in: add tcl document extensions/mime types and
	LSMinimumSystemVersion, LSRequiresCarbon & NSAppleScriptEnabled keys.

	* macosx/Wish-Common.xcconfig: add Wish's Info.plist as __info_plist
	section to tktest; enable more warnings.

	* macosx/Wish.xcodeproj/project.pbxproj: add 'DebugMemCompile' build
	configuration that calls configure with --enable-symbols=all; disable
	configure check for __attribute__((__visibility__("hidden"))) in Debug
	configuration to restore availability of ZeroLink.

	* macosx/Wish-Common.xcconfig:	fix whitespace.
	* macosx/Wish-Debug.xcconfig:
	* macosx/Wish-Release.xcconfig:
	* macosx/tkMacOSXAETE.r:
	* macosx/tkMacOSXConfig.c:
	* macosx/tkMacOSXCursors.r:
	* macosx/tkMacOSXKeyboard.c:
	* macosx/tkMacOSXSend.c:
	* macosx/ttkMacOSXTheme.c:
	* macosx/tkMacOSXXCursors.r:
	* macosx/README:

	* macosx/GNUmakefile:		fix/add copyright and license refs.
	* macosx/Tk-Info.plist.in:
	* macosx/Wish-Info.plist.in:
	* macosx/Wish.xcode/project.pbxproj:
	* macosx/Wish.xcodeproj/project.pbxproj:
	* macosx/tkMacOSX.h:

1 files changed, 414 insertions, 235 deletions

diff --git a/macosx/tkMacOSXCarbonEvents.c b/macosx/tkMacOSXCarbonEvents.c
index 18c519e..a6916bc 100644
--- a/macosx/tkMacOSXCarbonEvents.c
+++ b/macosx/tkMacOSXCarbonEvents.c
@@ -11,56 +11,56 @@
  *	application event target.
  *
  * Copyright 2001, Apple Computer, Inc.
- * Copyright (c) 2005 Daniel A. Steffen <das@users.sourceforge.net>
+ * Copyright (c) 2005-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: tkMacOSXCarbonEvents.c,v 1.15 2007/04/21 19:06:37 hobbs Exp $
+ *	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: tkMacOSXCarbonEvents.c,v 1.16 2007/04/23 21:24:33 das Exp $
  */
 
 #include "tkMacOSXInt.h"
@@ -68,66 +68,79 @@
 #include "tkMacOSXDebug.h"
 
 /*
-#ifdef	TK_MAC_DEBUG
+#ifdef TK_MAC_DEBUG
 #define TK_MAC_DEBUG_CARBON_EVENTS
 #endif
 */
 
-/* Declarations of functions used only in this file */
+/*
+ * Declarations of functions used only in this file:
+ */
+
 static OSStatus CarbonEventHandlerProc(EventHandlerCallRef callRef,
-			      EventRef event, void *userData);
-static OSStatus InstallStandardApplicationEventHandler();
-static void ExitRaelEventHandlerProc (EventHandlerCallRef, EventRef, void*)
-	__attribute__ ((__noreturn__));
+	EventRef event, void *userData);
+static OSStatus InstallStandardApplicationEventHandler(void);
+static void ExitRaelEventHandlerProc(EventHandlerCallRef callRef,
+	EventRef event, void *userData) __attribute__ ((__noreturn__));
 static void CarbonTimerProc(EventLoopTimerRef timer, void *userData);
 
-/* Static data used by several functions in this file */
+/*
+ * Static data used by several functions in this file:
+ */
+
 static jmp_buf exitRaelJmpBuf;
 static EventLoopTimerRef carbonTimer = NULL;
 static int carbonTimerEnabled = 0;
+static EventHandlerUPP carbonEventHandlerUPP = NULL;
+static Tcl_Interp *carbonEventInterp = NULL;
+static int inTrackingLoop = 0;
 
+
 /*
  *----------------------------------------------------------------------
  *
  * CarbonEventHandlerProc --
  *
- *	  This procedure is the handler for all registered CarbonEvents.
+ *	This procedure is the handler for all registered CarbonEvents.
  *
  * Results:
- *	  OS status code.
+ *	OS status code.
  *
  * Side effects:
- *	  Dispatches CarbonEvents.
+ *	Dispatches CarbonEvents.
  *
  *----------------------------------------------------------------------
  */
 
 static OSStatus
-CarbonEventHandlerProc (
-	EventHandlerCallRef callRef,
-	EventRef event,
-	void *userData)
+CarbonEventHandlerProc(
+    EventHandlerCallRef callRef,
+    EventRef event,
+    void *userData)
 {
-    OSStatus	     result = eventNotHandledErr;
-    TkMacOSXEvent    macEvent;
-    MacEventStatus   eventStatus;
+    OSStatus err = eventNotHandledErr;
+    TkMacOSXEvent macEvent;
+    MacEventStatus eventStatus;
 
     macEvent.eventRef = event;
-    macEvent.eClass = GetEventClass(macEvent.eventRef);
-    macEvent.eKind = GetEventKind(macEvent.eventRef);
+    macEvent.eClass = GetEventClass(event);
+    macEvent.eKind = GetEventKind(event);
     macEvent.interp = (Tcl_Interp *) userData;
+    macEvent.callRef = callRef;
     bzero(&eventStatus, sizeof(eventStatus));
 
-#if defined(TK_MAC_DEBUG) && defined(TK_MAC_DEBUG_CARBON_EVENTS)
-    char buf [256];
+#ifdef TK_MAC_DEBUG_CARBON_EVENTS
     if (macEvent.eKind != kEventMouseMoved &&
 	    macEvent.eKind != kEventMouseDragged) {
-	TkMacOSXCarbonEventToAscii(event, buf);
-	fprintf(stderr, "CarbonEventHandlerProc started handling %s\n", buf);
+	TkMacOSXDbgMsg("Started handling %s",
+		TkMacOSXCarbonEventToAscii(event));
 	TkMacOSXInitNamedDebugSymbol(HIToolbox, void, _DebugPrintEvent,
 		EventRef inEvent);
 	if (_DebugPrintEvent) {
-	    /* Carbon-internal event debugging (c.f. Technote 2124) */
+	    /*
+	     * Carbon-internal event debugging (c.f. Technote 2124)
+	     */
+
 	    _DebugPrintEvent(event);
 	}
     }
@@ -135,18 +148,18 @@ CarbonEventHandlerProc (
 
     TkMacOSXProcessEvent(&macEvent,&eventStatus);
     if (eventStatus.stopProcessing) {
-	result = noErr;
+	err = noErr;
     }
 
-#if defined(TK_MAC_DEBUG) && defined(TK_MAC_DEBUG_CARBON_EVENTS)
+#ifdef TK_MAC_DEBUG_CARBON_EVENTS
     if (macEvent.eKind != kEventMouseMoved &&
 	    macEvent.eKind != kEventMouseDragged) {
-	fprintf(stderr,
-		"CarbonEventHandlerProc finished handling %s: %s handled\n",
-		buf, eventStatus.stopProcessing ? "   " : "not");
+	TkMacOSXDbgMsg("Finished handling %s: %s handled",
+		TkMacOSXCarbonEventToAscii(event),
+		eventStatus.stopProcessing ? "   " : "not");
     }
 #endif /* TK_MAC_DEBUG_CARBON_EVENTS */
-    return result;
+    return err;
 }
 
 /*
@@ -154,104 +167,95 @@ 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)
+TkMacOSXInitCarbonEvents(
+    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},
+	{kEventClassKeyboard,	 kEventRawKeyDown},
+	{kEventClassKeyboard,	 kEventRawKeyRepeat},
+	{kEventClassKeyboard,	 kEventRawKeyUp},
+	{kEventClassKeyboard,	 kEventRawKeyModifiersChanged},
+	{kEventClassKeyboard,	 kEventRawKeyRepeat},
     };
     const EventTypeSpec applicationEventTypes[] = {
-	    {kEventClassMenu,		kEventMenuBeginTracking},
-	    {kEventClassMenu,		kEventMenuEndTracking},
-	    {kEventClassCommand,	kEventCommandProcess},
-	    {kEventClassCommand,	kEventCommandUpdateStatus},
-	    {kEventClassMouse,		kEventMouseWheelMoved},
-	    {kEventClassWindow,		kEventWindowExpanded},
-	    {kEventClassApplication,	kEventAppHidden},
-	    {kEventClassApplication,	kEventAppShown},
-	    {kEventClassApplication,    kEventAppAvailableWindowBoundsChanged},
+	{kEventClassMenu,	 kEventMenuBeginTracking},
+	{kEventClassMenu,	 kEventMenuEndTracking},
+	{kEventClassMenu,	 kEventMenuOpening},
+	{kEventClassMenu,	 kEventMenuTargetItem},
+	{kEventClassCommand,	 kEventCommandProcess},
+	{kEventClassCommand,	 kEventCommandUpdateStatus},
+	{kEventClassApplication, kEventAppActivated},
+	{kEventClassApplication, kEventAppDeactivated},
+	{kEventClassApplication, kEventAppQuit},
+	{kEventClassApplication, kEventAppHidden},
+	{kEventClassApplication, kEventAppShown},
+	{kEventClassApplication, kEventAppAvailableWindowBoundsChanged},
+	{kEventClassAppearance,	 kEventAppearanceScrollBarVariantChanged},
     };
-    EventHandlerUPP handler = NewEventHandlerUPP(CarbonEventHandlerProc);
 
-    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
-    }
+    carbonEventHandlerUPP = NewEventHandlerUPP(CarbonEventHandlerProc);
+    carbonEventInterp = interp;
+    ChkErr(InstallStandardApplicationEventHandler);
+    ChkErr(InstallEventHandler, GetEventDispatcherTarget(),
+	    carbonEventHandlerUPP, GetEventTypeCount(dispatcherEventTypes),
+	    dispatcherEventTypes, (void *) carbonEventInterp, NULL);
+    ChkErr(InstallEventHandler, GetApplicationEventTarget(),
+	    carbonEventHandlerUPP, GetEventTypeCount(applicationEventTypes),
+	    applicationEventTypes, (void *) carbonEventInterp, NULL);
 
-#if defined(TK_MAC_DEBUG) && defined(TK_MAC_DEBUG_CARBON_EVENTS)
-    TkMacOSXInitNamedDebugSymbol(HIToolbox, void, TraceEventByName, char*);
-    if (TraceEventByName) {
+#ifdef TK_MAC_DEBUG_CARBON_EVENTS
+    TkMacOSXInitNamedDebugSymbol(HIToolbox, void, _TraceEventByName,
+	    CFStringRef);
+    if (_TraceEventByName) {
 	/* Carbon-internal event debugging (c.f. Technote 2124) */
-	TraceEventByName("kEventMouseDown");
-	TraceEventByName("kEventMouseUp");
-	TraceEventByName("kEventMouseWheelMoved");
-	TraceEventByName("kEventMouseScroll");
-	TraceEventByName("kEventWindowUpdate");
-	TraceEventByName("kEventWindowActivated");
-	TraceEventByName("kEventWindowDeactivated");
-	TraceEventByName("kEventRawKeyDown");
-	TraceEventByName("kEventRawKeyRepeat");
-	TraceEventByName("kEventRawKeyUp");
-	TraceEventByName("kEventRawKeyModifiersChanged");
-	TraceEventByName("kEventRawKeyRepeat");
-	TraceEventByName("kEventAppActivated");
-	TraceEventByName("kEventAppDeactivated");
-	TraceEventByName("kEventAppQuit");
-	TraceEventByName("kEventMenuBeginTracking");
-	TraceEventByName("kEventMenuEndTracking");
-	TraceEventByName("kEventCommandProcess");
-	TraceEventByName("kEventCommandUpdateStatus");
-	TraceEventByName("kEventWindowExpanded");
-	TraceEventByName("kEventAppHidden");
-	TraceEventByName("kEventAppShown");
-	TraceEventByName("kEventAppAvailableWindowBoundsChanged");
+	_TraceEventByName(CFSTR("kEventRawKeyDown"));
+	_TraceEventByName(CFSTR("kEventRawKeyRepeat"));
+	_TraceEventByName(CFSTR("kEventRawKeyUp"));
+	_TraceEventByName(CFSTR("kEventRawKeyModifiersChanged"));
+	_TraceEventByName(CFSTR("kEventRawKeyRepeat"));
+	_TraceEventByName(CFSTR("kEventMenuBeginTracking"));
+	_TraceEventByName(CFSTR("kEventMenuEndTracking"));
+	_TraceEventByName(CFSTR("kEventMenuOpening"));
+	_TraceEventByName(CFSTR("kEventMenuTargetItem"));
+	_TraceEventByName(CFSTR("kEventCommandProcess"));
+	_TraceEventByName(CFSTR("kEventCommandUpdateStatus"));
+	_TraceEventByName(CFSTR("kEventAppActivated"));
+	_TraceEventByName(CFSTR("kEventAppDeactivated"));
+	_TraceEventByName(CFSTR("kEventAppQuit"));
+	_TraceEventByName(CFSTR("kEventAppHidden"));
+	_TraceEventByName(CFSTR("kEventAppShown"));
+	_TraceEventByName(CFSTR("kEventAppAvailableWindowBoundsChanged"));
+	_TraceEventByName(CFSTR("kEventAppearanceScrollBarVariantChanged"));
+	_TraceEventByName(CFSTR("kEventMouseDown"));
+	_TraceEventByName(CFSTR("kEventMouseUp"));
+#if 0
+	_TraceEventByName(CFSTR("kEventMouseMoved"));
+	_TraceEventByName(CFSTR("kEventMouseDragged"));
+#endif
+	_TraceEventByName(CFSTR("kEventMouseWheelMoved"));
+	_TraceEventByName(CFSTR("kEventMouseScroll"));
+	_TraceEventByName(CFSTR("kEventWindowActivated"));
+	_TraceEventByName(CFSTR("kEventWindowDeactivated"));
+	_TraceEventByName(CFSTR("kEventWindowUpdate"));
+	_TraceEventByName(CFSTR("kEventWindowExpanded"));
+	_TraceEventByName(CFSTR("kEventWindowBoundsChanged"));
+	_TraceEventByName(CFSTR("kEventWindowDragStarted"));
+	_TraceEventByName(CFSTR("kEventWindowDragCompleted"));
+	_TraceEventByName(CFSTR("kEventWindowConstrain"));
+	_TraceEventByName(CFSTR("kEventWindowGetRegion"));
+	_TraceEventByName(CFSTR("kEventWindowDrawContent"));
     }
 #endif /* TK_MAC_DEBUG_CARBON_EVENTS */
 }
@@ -259,22 +263,66 @@ TkMacOSXInitCarbonEvents (
 /*
  *----------------------------------------------------------------------
  *
+ * TkMacOSXInstallWindowCarbonEventHandler --
+ *
+ *	This procedure installs our window CarbonEvent handler.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Handler for Carbon Events is registered.
+ *
+ *----------------------------------------------------------------------
+ */
+
+MODULE_SCOPE void
+TkMacOSXInstallWindowCarbonEventHandler(
+	Tcl_Interp *interp, WindowRef window)
+{
+    const EventTypeSpec windowEventTypes[] = {
+	{kEventClassMouse,	 kEventMouseDown},
+	{kEventClassMouse,	 kEventMouseUp},
+	{kEventClassMouse,	 kEventMouseMoved},
+	{kEventClassMouse,	 kEventMouseDragged},
+	{kEventClassMouse,	 kEventMouseWheelMoved},
+	{kEventClassWindow,	 kEventWindowActivated},
+	{kEventClassWindow,	 kEventWindowDeactivated},
+	{kEventClassWindow,	 kEventWindowUpdate},
+	{kEventClassWindow,	 kEventWindowExpanded},
+	{kEventClassWindow,	 kEventWindowBoundsChanged},
+	{kEventClassWindow,	 kEventWindowDragStarted},
+	{kEventClassWindow,	 kEventWindowDragCompleted},
+	{kEventClassWindow,	 kEventWindowConstrain},
+	{kEventClassWindow,	 kEventWindowGetRegion},
+	{kEventClassWindow,	 kEventWindowDrawContent},
+    };
+
+    ChkErr(InstallEventHandler, GetWindowEventTarget(window),
+	    carbonEventHandlerUPP, GetEventTypeCount(windowEventTypes),
+	    windowEventTypes, (void *) (interp ? interp : carbonEventInterp),
+	    NULL);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
  * InstallStandardApplicationEventHandler --
  *
- *	  This procedure installs the carbon standard application event
- *	  handler.
+ *	This procedure installs the carbon standard application event
+ *	handler.
  *
  * Results:
- *	  OS status code.
+ *	OS status code.
  *
  * Side effects:
- *	  Standard handlers for application Carbon Events are registered.
+ *	Standard handlers for application Carbon Events are registered.
  *
  *----------------------------------------------------------------------
  */
 
 static OSStatus
-InstallStandardApplicationEventHandler()
+InstallStandardApplicationEventHandler(void)
 {
    /*
     * This is a hack to workaround missing Carbon API to install the standard
@@ -286,9 +334,12 @@ InstallStandardApplicationEventHandler()
     * 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};
+    enum {
+	kExitRaelEvent = 'ExiT'
+    };
+    const EventTypeSpec exitRaelEventType = {
+	kExitRaelEvent, kExitRaelEvent
+    };
     EventHandlerUPP exitRaelEventHandler;
     EventHandlerRef exitRaelEventHandlerRef = NULL;
     EventRef exitRaelEvent = NULL;
@@ -297,22 +348,26 @@ InstallStandardApplicationEventHandler()
     exitRaelEventHandler = NewEventHandlerUPP(
 	    (EventHandlerProcPtr) ExitRaelEventHandlerProc);
     if (exitRaelEventHandler) {
-	err = InstallEventHandler(GetEventDispatcherTarget(),
+	err = ChkErr(InstallEventHandler, GetEventDispatcherTarget(),
 		exitRaelEventHandler, 1, &exitRaelEventType, NULL,
 		&exitRaelEventHandlerRef);
     }
     if (err == noErr) {
-	err = CreateEvent(NULL, kExitRaelEvent, kExitRaelEvent, 
+	err = ChkErr(CreateEvent, NULL, kExitRaelEvent, kExitRaelEvent,
 		GetCurrentEventTime(), kEventAttributeNone, &exitRaelEvent);
     }
     if (err == noErr) {
-	err = PostEventToQueue(GetMainEventQueue(), exitRaelEvent,
+	err = ChkErr(PostEventToQueue, GetMainEventQueue(), exitRaelEvent,
 		kEventPriorityHigh);
     }
     if (err == noErr) {
 	if (!setjmp(exitRaelJmpBuf)) {
 	    RunApplicationEventLoop();
-	    /* This point should never be reached ! */
+
+	    /*
+	     * This point should never be reached!
+	     */
+
 	    Tcl_Panic("RunApplicationEventLoop exited !");
 	}
     }
@@ -333,23 +388,24 @@ InstallStandardApplicationEventHandler()
  *
  * 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.
+ *	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 !
+ *	None. Never returns !
  *
  * Side effects:
- *	  longjmp back to InstallStandardApplicationEventHandler().
+ *	longjmp back to InstallStandardApplicationEventHandler().
  *
  *----------------------------------------------------------------------
  */
 
 static void
-ExitRaelEventHandlerProc (
-	EventHandlerCallRef callRef,
-	EventRef event, void *userData)
+ExitRaelEventHandlerProc(
+    EventHandlerCallRef callRef,
+    EventRef event,
+    void *userData)
 {
     longjmp(exitRaelJmpBuf, 1);
 }
@@ -357,37 +413,57 @@ ExitRaelEventHandlerProc (
 /*
  *----------------------------------------------------------------------
  *
+ * TkMacOSXRunTclEventLoop --
+ *
+ *	Process a limited number of tcl events.
+ *
+ * Results:
+ *	Returns 1 if events were handled and 0 otherwise.
+ *
+ * Side effects:
+ *	Runs the Tcl event loop.
+ *
+ *----------------------------------------------------------------------
+ */
+
+MODULE_SCOPE int
+TkMacOSXRunTclEventLoop(void)
+{
+    int i = 4, result = 0;
+
+    /* Avoid starving main event loop: process at most 4 events. */
+    while(--i && Tcl_ServiceAll()) {
+	result = 1;
+    }
+    return result;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
  * 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.
+ *	This procedure is the carbon timer handler that runs the tcl
+ *	event loop periodically.
  *
  * Results:
- *	  None.
+ *	None.
  *
  * Side effects:
- *	  Runs the Tcl event loop.
+ *	Runs the Tcl event loop.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-CarbonTimerProc (
-	EventLoopTimerRef timer,
-	void *userData)
+CarbonTimerProc(
+    EventLoopTimerRef timer,
+    void *userData)
 {
-    if(carbonTimerEnabled) {
-	/* Avoid starving main event loop: process at most 4 events. */
-	int i = 4;
-	while(--i && Tcl_DoOneEvent(
-		TCL_FILE_EVENTS|TCL_TIMER_EVENTS|TCL_DONT_WAIT)) {
-#if defined(TK_MAC_DEBUG) && defined(TK_MAC_DEBUG_CARBON_EVENTS)
-	    fprintf(stderr, "Processed tcl event from carbon timer\n");
+    if(carbonTimerEnabled > 0 && TkMacOSXRunTclEventLoop()) {
+#ifdef TK_MAC_DEBUG_CARBON_EVENTS
+	TkMacOSXDbgMsg("Processed tcl events from carbon timer");
 #endif /* TK_MAC_DEBUG_CARBON_EVENTS */
-	}
     }
 }
 
@@ -396,80 +472,183 @@ CarbonTimerProc (
  *
  * 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.
+ *	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 might
+ *	run by HIToolbox (e.g. during mouse tracking) to ensure that
+ *	tcl events continue to be processed.
  *
  * Results:
- *	  OS status code.
+ *	OS status code.
  *
  * Side effects:
- *	  Carbon event timer is installed and started.
+ *	Carbon event timer is installed and started.
  *
  *----------------------------------------------------------------------
  */
 
 MODULE_SCOPE OSStatus
-TkMacOSXStartTclEventLoopCarbonTimer()
+TkMacOSXStartTclEventLoopCarbonTimer(void)
 {
-    OSStatus err;
+    OSStatus err = noErr;
 
-    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
+    if (++carbonTimerEnabled > 0) {
+	if(!carbonTimer) {
+	    EventLoopTimerUPP timerUPP = NewEventLoopTimerUPP(CarbonTimerProc);
+
+	    err = ChkErr(InstallEventLoopTimer, GetMainEventLoop(),
+		    5 * kEventDurationMillisecond,
+		    5 * kEventDurationMillisecond,
+		    timerUPP, NULL, &carbonTimer);
+	} else {
+	    err = ChkErr(SetEventLoopTimerNextFireTime, carbonTimer,
+		    5 * kEventDurationMillisecond);
 	}
     }
-    carbonTimerEnabled = 1;
     return err;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
  * TkMacOSXStopTclEventLoopCarbonTimer --
  *
- *	  This procedure stops the carbon event timer started by
- *	  TkMacOSXStartTclEventLoopCarbonTimer().
+ *	This procedure stops the carbon event timer started by
+ *	TkMacOSXStartTclEventLoopCarbonTimer().
  *
  * Results:
- *	  OS status code.
+ *	OS status code.
  *
  * Side effects:
- *	 Carbon event timer is stopped.
+ *	Carbon event timer is stopped.
  *
  *----------------------------------------------------------------------
  */
 
 MODULE_SCOPE OSStatus
-TkMacOSXStopTclEventLoopCarbonTimer()
+TkMacOSXStopTclEventLoopCarbonTimer(void)
 {
     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
+    if (--carbonTimerEnabled == 0) {
+	if(carbonTimer) {
+	    err = ChkErr(SetEventLoopTimerNextFireTime, carbonTimer,
+		    kEventDurationForever);
 	}
     }
-    carbonTimerEnabled = 0;
     return err;
 }
 
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkMacOSXTrackingLoop --
+ *
+ *	Call with 1 before entering a mouse tracking loop (e.g. window
+ *	resizing or menu tracking) to enable tcl event processing but
+ *	disable  carbon event processing (except for update events)
+ *	during the loop, and with 0 after exiting the loop to reset.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+MODULE_SCOPE void
+TkMacOSXTrackingLoop(int tracking)
+{
+    static int previousServiceMode = TCL_SERVICE_NONE;
+
+    if (tracking) {
+	inTrackingLoop++;
+	previousServiceMode = Tcl_SetServiceMode(TCL_SERVICE_ALL);
+	TkMacOSXStartTclEventLoopCarbonTimer();
+#ifdef TK_MAC_DEBUG_CARBON_EVENTS
+	TkMacOSXDbgMsg("Entering tracking loop");
+#endif /* TK_MAC_DEBUG_CARBON_EVENTS */
+    } else {
+	TkMacOSXStopTclEventLoopCarbonTimer();
+	previousServiceMode = Tcl_SetServiceMode(previousServiceMode);
+	inTrackingLoop--;
+#ifdef TK_MAC_DEBUG_CARBON_EVENTS
+	TkMacOSXDbgMsg("Exiting tracking loop");
+#endif /* TK_MAC_DEBUG_CARBON_EVENTS */
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkMacOSXReceiveAndDispatchEvent --
+ *
+ *	This receives a carbon event and sends it to the carbon event
+ *	dispatcher.
+ *
+ * Results:
+ *	Mac OS status
+ *
+ * Side effects:
+ *	This receives and dispatches the next Carbon event.
+ *
+ *----------------------------------------------------------------------
+ */
+MODULE_SCOPE OSStatus
+TkMacOSXReceiveAndDispatchEvent(void)
+{
+    static EventTargetRef targetRef = NULL;
+    int numEventTypes = 0;
+    const EventTypeSpec *eventTypes = NULL;
+    EventRef eventRef;
+    OSStatus err;
+    const EventTypeSpec trackingEventTypes[] = {
+	{'dniw',		 kEventWindowUpdate},
+	{kEventClassWindow,	 kEventWindowUpdate},
+    };
+
+    if (inTrackingLoop > 0) {
+	eventTypes = trackingEventTypes;
+	numEventTypes = GetEventTypeCount(trackingEventTypes);
+    }
+
+    /*
+     * This is a poll, since we have already counted the events coming
+     * into this routine, and are guaranteed to have one waiting.
+     */
+
+    err = ReceiveNextEvent(numEventTypes, eventTypes,
+	    kEventDurationNoWait, true, &eventRef);
+    if (err == noErr) {
+#ifdef TK_MAC_DEBUG_CARBON_EVENTS
+	UInt32 kind = GetEventKind(eventRef);
+
+	if (kind != kEventMouseMoved && kind != kEventMouseDragged) {
+	    TkMacOSXDbgMsg("Dispatching %s", TkMacOSXCarbonEventToAscii(eventRef));
+	    TkMacOSXInitNamedDebugSymbol(HIToolbox, void, _DebugPrintEvent,
+		    EventRef inEvent);
+	    if (_DebugPrintEvent) {
+		/* Carbon-internal event debugging (c.f. Technote 2124) */
+		_DebugPrintEvent(eventRef);
+	    }
+	}
+#endif /* TK_MAC_DEBUG_CARBON_EVENTS */
+	if (!targetRef) {
+	    targetRef = GetEventDispatcherTarget();
+	}
+	TkMacOSXStartTclEventLoopCarbonTimer();
+	err = SendEventToEventTarget(eventRef, targetRef);
+	TkMacOSXStopTclEventLoopCarbonTimer();
+	if (err != noErr && err != eventLoopTimedOutErr
+		&& err != eventNotHandledErr) {
+	    TkMacOSXDbgMsg("SendEventToEventTarget(%s) failed: %ld",
+		    TkMacOSXCarbonEventToAscii(eventRef), err);
+	}
+	ReleaseEvent(eventRef);
+    } else if (err != eventLoopTimedOutErr) {
+	TkMacOSXDbgMsg("ReceiveNextEvent failed: %ld", err);
+    }
+    return err;
+}