* 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, 138 insertions, 162 deletions

diff --git a/macosx/tkMacOSXEvent.c b/macosx/tkMacOSXEvent.c
index b94606e..82aea7a 100644
--- a/macosx/tkMacOSXEvent.c
+++ b/macosx/tkMacOSXEvent.c
@@ -1,109 +1,110 @@
-/* 
+/*
  * tkMacOSXEvent.c --
  *
- * This file contains the basic Mac OS X Event handling routines.
+ *	This file contains the basic Mac OS X Event handling routines.
  *
  * Copyright (c) 1995-1997 Sun Microsystems, Inc.
  * Copyright 2001, Apple Computer, Inc.
- * Copyright (c) 2005-2006 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.
  *
- * RCS: @(#) $Id: tkMacOSXEvent.c,v 1.14 2007/04/21 19:06:38 hobbs Exp $
+ * RCS: @(#) $Id: tkMacOSXEvent.c,v 1.15 2007/04/23 21:24:33 das Exp $
  */
 
 #include "tkMacOSXInt.h"
 #include "tkMacOSXEvent.h"
 #include "tkMacOSXDebug.h"
 
+
 /*
  *----------------------------------------------------------------------
  *
  * TkMacOSXFlushWindows --
  *
- *      This routine flushes all the Carbon windows of the application.  It
- *      is called by the setup procedure for the Tcl/Carbon event source.
+ *	This routine flushes all the Carbon windows of the application. It
+ *	is called by the setup procedure for the Tcl/Carbon event source.
  *
  * Results:
- *      None.
+ *	None.
  *
  * Side effects:
- *      Flushes all Carbon windows
+ *	Flushes all Carbon windows
  *
  *----------------------------------------------------------------------
  */
 
 MODULE_SCOPE void
-TkMacOSXFlushWindows ()
+TkMacOSXFlushWindows (void)
 {
     WindowRef wRef = GetWindowList();
-    
+
     while (wRef) {
-        CGrafPtr portPtr = GetWindowPort(wRef);
-        if (QDIsPortBuffered(portPtr)) {
-            QDFlushPortBuffer(portPtr, NULL);
-        }
-        wRef = GetNextWindow(wRef);
+	CGrafPtr portPtr = GetWindowPort(wRef);
+	if (QDIsPortBuffered(portPtr)) {
+	    QDFlushPortBuffer(portPtr, NULL);
+	}
+	wRef = GetNextWindow(wRef);
     }
 }
 
-/*      
+/*
  *----------------------------------------------------------------------
- *   
+ *
  * TkMacOSXProcessEvent --
- *   
- *      This dispatches a filtered Carbon event to the appropriate handler
  *
- *      Note on MacEventStatus.stopProcessing: Please be conservative in the
- *      individual handlers and don't assume the event is fully handled
- *      unless you *really* need to ensure that other handlers don't see the
- *      event anymore.  Some OS manager or library might be interested in
- *      events even after they are already handled on the Tk level.
+ *	This dispatches a filtered Carbon event to the appropriate handler
  *
- * Results: 
- *      0 on success
- *      -1 on failure
+ *	Note on MacEventStatus.stopProcessing: Please be conservative in the
+ *	individual handlers and don't assume the event is fully handled
+ *	unless you *really* need to ensure that other handlers don't see the
+ *	event anymore. Some OS manager or library might be interested in
+ *	events even after they are already handled on the Tk level.
+ *
+ * Results:
+ *	0 on success
+ *	-1 on failure
  *
  * Side effects:
- *      Converts a Carbon event to a Tk event
- *   
+ *	Converts a Carbon event to a Tk event
+ *
  *----------------------------------------------------------------------
  */
 
-MODULE_SCOPE int  
-TkMacOSXProcessEvent(TkMacOSXEvent * eventPtr, MacEventStatus * statusPtr)
+MODULE_SCOPE int
+TkMacOSXProcessEvent(
+    TkMacOSXEvent *eventPtr,
+    MacEventStatus *statusPtr)
 {
     switch (eventPtr->eClass) {
-        case kEventClassMouse:
-            TkMacOSXProcessMouseEvent(eventPtr, statusPtr);
-            break;
-        case kEventClassWindow:
-            TkMacOSXProcessWindowEvent(eventPtr, statusPtr);
-            break;  
-        case kEventClassKeyboard:
-            TkMacOSXProcessKeyboardEvent(eventPtr, statusPtr);
-            break;
-        case kEventClassApplication:
-            TkMacOSXProcessApplicationEvent(eventPtr, statusPtr);
-            break;
-        case kEventClassMenu:
-            TkMacOSXProcessMenuEvent(eventPtr, statusPtr);
-            break;  
-        case kEventClassCommand:
-            TkMacOSXProcessCommandEvent(eventPtr, statusPtr);
-            break;  
-        default:
-#ifdef TK_MAC_DEBUG
-            {
-                char buf [256];
-                fprintf(stderr,
-                    "Unrecognised event : %s\n",
-                    TkMacOSXCarbonEventToAscii(eventPtr->eventRef, buf));
-            }
-#endif
-            break;
-    }   
+	case kEventClassMouse:
+	    TkMacOSXProcessMouseEvent(eventPtr, statusPtr);
+	    break;
+	case kEventClassWindow:
+	    TkMacOSXProcessWindowEvent(eventPtr, statusPtr);
+	    break;
+	case kEventClassKeyboard:
+	    TkMacOSXProcessKeyboardEvent(eventPtr, statusPtr);
+	    break;
+	case kEventClassApplication:
+	    TkMacOSXProcessApplicationEvent(eventPtr, statusPtr);
+	    break;
+	case kEventClassAppearance:
+	    TkMacOSXProcessAppearanceEvent(eventPtr, statusPtr);
+	    break;
+	case kEventClassMenu:
+	    TkMacOSXProcessMenuEvent(eventPtr, statusPtr);
+	    break;
+	case kEventClassCommand:
+	    TkMacOSXProcessCommandEvent(eventPtr, statusPtr);
+	    break;
+	default: {
+	    TkMacOSXDbgMsg("Unrecognised event: %s",
+		    TkMacOSXCarbonEventToAscii(eventPtr->eventRef));
+	    break;
+	}
+    }
     return 0;
 }
 
@@ -112,51 +113,81 @@ TkMacOSXProcessEvent(TkMacOSXEvent * eventPtr, MacEventStatus * statusPtr)
  *
  * TkMacOSXProcessMenuEvent --
  *
- *	  This routine processes the event in eventPtr, and
- *	  generates the appropriate Tk events from it.
+ *	This routine processes the event in eventPtr, and
+ *	generates the appropriate Tk events from it.
  *
  * Results:
- *	  True if event(s) are generated - false otherwise.
+ *	True if event(s) are generated - false otherwise.
  *
  * Side effects:
- *	  Additional events may be place on the Tk event queue.
+ *	Additional events may be place on the Tk event queue.
  *
  *----------------------------------------------------------------------
  */
 
 MODULE_SCOPE int
-TkMacOSXProcessMenuEvent(TkMacOSXEvent *eventPtr, MacEventStatus * statusPtr)
+TkMacOSXProcessMenuEvent(
+    TkMacOSXEvent *eventPtr,
+    MacEventStatus *statusPtr)
 {
-    int		    menuContext;
-    OSStatus	    status;
+    int menuContext;
+    OSStatus err;
 
     switch (eventPtr->eKind) {
 	case kEventMenuBeginTracking:
 	case kEventMenuEndTracking:
+	case kEventMenuOpening:
+	case kEventMenuTargetItem:
 	    break;
 	default:
 	    return 0;
 	    break;
     }
-    status = GetEventParameter(eventPtr->eventRef, 
-	    kEventParamMenuContext,
-	    typeUInt32, NULL, 
-	    sizeof(menuContext), NULL,
-	    &menuContext);
-    if (status == noErr && (menuContext & kMenuContextMenuBar)) {
-        static int oldMode = TCL_SERVICE_ALL;
-        if (eventPtr->eKind == kEventMenuBeginTracking) {
-            oldMode = Tcl_SetServiceMode(TCL_SERVICE_ALL);
-            TkMacOSXClearMenubarActive();
-        
-            /*
-             * Handle -postcommand
-             */
-        
-            TkMacOSXPreprocessMenu();
-        } else {
-            Tcl_SetServiceMode(oldMode);   
-        }
+    err = ChkErr(GetEventParameter, eventPtr->eventRef, kEventParamMenuContext,
+	    typeUInt32, NULL, sizeof(menuContext), NULL, &menuContext);
+    if (err == noErr && ((menuContext & kMenuContextMenuBarTracking) ||
+	    (menuContext & kMenuContextPopUpTracking))) {
+	switch (eventPtr->eKind) {
+	    MenuRef menu;
+
+	    case kEventMenuBeginTracking:
+		TkMacOSXClearMenubarActive();
+
+		/*
+		 * Handle -postcommand
+		 */
+
+		TkMacOSXPreprocessMenu();
+		TkMacOSXTrackingLoop(1);
+		break;
+	    case kEventMenuEndTracking:
+		TkMacOSXTrackingLoop(0);
+		break;
+	    case kEventMenuOpening:
+		err = ChkErr(GetEventParameter, eventPtr->eventRef,
+			kEventParamDirectObject, typeMenuRef, NULL,
+			sizeof(menu), NULL, &menu);
+		if (err == noErr) {
+		    TkMacOSXClearActiveMenu(menu);
+		    return TkMacOSXGenerateParentMenuSelectEvent(menu);
+		}
+		break;
+	    case kEventMenuTargetItem:
+		err = ChkErr(GetEventParameter, eventPtr->eventRef,
+			kEventParamDirectObject, typeMenuRef, NULL,
+			sizeof(menu), NULL, &menu);
+		if (err == noErr) {
+		    MenuItemIndex index;
+
+		    err = ChkErr(GetEventParameter, eventPtr->eventRef,
+			    kEventParamMenuItemIndex, typeMenuItemIndex, NULL,
+			    sizeof(index), NULL, &index);
+		    if (err == noErr) {
+			return TkMacOSXGenerateMenuSelectEvent(menu, index);
+		    }
+		}
+		break;
+	}
     }
     return 0;
 }
@@ -166,24 +197,26 @@ TkMacOSXProcessMenuEvent(TkMacOSXEvent *eventPtr, MacEventStatus * statusPtr)
  *
  * TkMacOSXProcessCommandEvent --
  *
- *	  This routine processes the event in eventPtr, and
- *	  generates the appropriate Tk events from it.
+ *	This routine processes the event in eventPtr, and
+ *	generates the appropriate Tk events from it.
  *
  * Results:
- *	  True if event(s) are generated - false otherwise.
+ *	True if event(s) are generated - false otherwise.
  *
  * Side effects:
- *	  Additional events may be place on the Tk event queue.
+ *	Additional events may be place on the Tk event queue.
  *
  *----------------------------------------------------------------------
  */
 
 MODULE_SCOPE int
-TkMacOSXProcessCommandEvent(TkMacOSXEvent *eventPtr, MacEventStatus * statusPtr)
+TkMacOSXProcessCommandEvent(
+    TkMacOSXEvent *eventPtr,
+    MacEventStatus * statusPtr)
 {
-    HICommand	    command;
-    int 	    menuContext;
-    OSStatus	    status;
+    HICommand command;
+    int menuContext;
+    OSStatus err;
 
     switch (eventPtr->eKind) {
 	case kEventCommandProcess:
@@ -193,19 +226,15 @@ TkMacOSXProcessCommandEvent(TkMacOSXEvent *eventPtr, MacEventStatus * statusPtr)
 	    return 0;
 	    break;
     }
-    status = GetEventParameter(eventPtr->eventRef, 
-	    kEventParamDirectObject,
-	    typeHICommand, NULL, 
-	    sizeof(command), NULL,
-	    &command);
-    if (status == noErr && (command.attributes & kHICommandFromMenu)) {
+    err = ChkErr(GetEventParameter, eventPtr->eventRef,
+	    kEventParamDirectObject, typeHICommand, NULL, sizeof(command),
+	    NULL, &command);
+    if (err == noErr && (command.attributes & kHICommandFromMenu)) {
 	if (eventPtr->eKind == kEventCommandProcess) {
-	    status = GetEventParameter(eventPtr->eventRef, 
-		    kEventParamMenuContext,
-		    typeUInt32, NULL, 
-		    sizeof(menuContext), NULL,
-		    &menuContext);
-	    if (status == noErr && (menuContext & kMenuContextMenuBar) &&
+	    err = ChkErr(GetEventParameter, eventPtr->eventRef,
+		    kEventParamMenuContext, typeUInt32, NULL,
+		    sizeof(menuContext), NULL, &menuContext);
+	    if (err == noErr && (menuContext & kMenuContextMenuBar) &&
 		    (menuContext & kMenuContextMenuBarTracking)) {
 		TkMacOSXHandleMenuSelect(GetMenuID(command.menu.menuRef),
 			command.menu.menuItemIndex,
@@ -215,15 +244,15 @@ TkMacOSXProcessCommandEvent(TkMacOSXEvent *eventPtr, MacEventStatus * statusPtr)
 	} else {
 	    Tcl_CmdInfo dummy;
 	    if (command.commandID == kHICommandPreferences && eventPtr->interp) {
-		if (Tcl_GetCommandInfo(eventPtr->interp, 
+		if (Tcl_GetCommandInfo(eventPtr->interp,
 			"::tk::mac::ShowPreferences", &dummy)) {
-		    if (!IsMenuItemEnabled(command.menu.menuRef, 
+		    if (!IsMenuItemEnabled(command.menu.menuRef,
 			    command.menu.menuItemIndex)) {
 			EnableMenuItem(command.menu.menuRef,
 				command.menu.menuItemIndex);
 		    }
 		} else {
-		    if (IsMenuItemEnabled(command.menu.menuRef, 
+		    if (IsMenuItemEnabled(command.menu.menuRef,
 			    command.menu.menuItemIndex)) {
 			DisableMenuItem(command.menu.menuRef,
 				command.menu.menuItemIndex);
@@ -236,56 +265,3 @@ TkMacOSXProcessCommandEvent(TkMacOSXEvent *eventPtr, MacEventStatus * statusPtr)
     }
     return 0;
 }
-
-/*
- *----------------------------------------------------------------------
- *
- * TkMacOSXReceiveAndProcessEvent --
- *
- *      This receives a carbon event and converts it to a Tk event
- *
- * Results:
- *      0 on success
- *      Mac OS error number on failure
- *
- * Side effects:
- *      This receives the next Carbon event and converts it to the
- *      appropriate Tk event
- *
- *----------------------------------------------------------------------
- */
-
-MODULE_SCOPE OSStatus
-TkMacOSXReceiveAndProcessEvent()
-{
-    static EventTargetRef targetRef = NULL;
-    EventRef eventRef;
-    OSStatus err;
-
-    /*
-     * This is a poll, since we have already counted the events coming
-     * into this routine, and are guaranteed to have one waiting.
-     */
-     
-    err = ReceiveNextEvent(0, NULL, kEventDurationNoWait, true, &eventRef);
-    if (err == noErr) {
-        if (!targetRef) {
-            targetRef = GetEventDispatcherTarget();
-        }
-        TkMacOSXStartTclEventLoopCarbonTimer();
-        err = SendEventToEventTarget(eventRef,targetRef);
-        TkMacOSXStopTclEventLoopCarbonTimer();
-#ifdef TK_MAC_DEBUG
-        if (err != noErr && err != eventLoopTimedOutErr
-                && err != eventNotHandledErr
-        ) {
-            char buf [256];
-            fprintf(stderr,
-                    "RCNE SendEventToEventTarget (%s) failed, %d\n",
-                    TkMacOSXCarbonEventToAscii(eventRef, buf), (int)err);
-        }
-#endif
-        ReleaseEvent(eventRef);
-    }
-    return err;
-}