Merge of TkAqua Cocoa portmacosx_cocoa_merge

1 files changed, 859 insertions, 3969 deletions

diff --git a/macosx/tkMacOSXMenu.c b/macosx/tkMacOSXMenu.c
index 76b9e6b..1f59f71 100644
--- a/macosx/tkMacOSXMenu.c
+++ b/macosx/tkMacOSXMenu.c
@@ -4,13 +4,13 @@
  *	This module implements the Mac-platform specific features of menus.
  *
  * Copyright (c) 1996-1997 by Sun Microsystems, Inc.
- * Copyright 2001, Apple Computer, Inc.
- * Copyright (c) 2005-2007 Daniel A. Steffen <das@users.sourceforge.net>
+ * Copyright 2001-2009, Apple Inc.
+ * Copyright (c) 2005-2009 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.
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkMacOSXMenu.c,v 1.51 2009/02/06 08:11:40 das Exp $
+ * RCS: @(#) $Id: tkMacOSXMenu.c,v 1.52 2009/06/29 14:35:01 das Exp $
  */
 
 #include "tkMacOSXPrivate.h"
@@ -18,6 +18,7 @@
 #include "tkMenu.h"
 #include "tkColor.h"
 #include "tkFont.h"
+#include "tkMacOSXWm.h"
 #include "tkMacOSXDebug.h"
 
 /*
@@ -26,622 +27,365 @@
 #endif
 */
 
-#define USE_TK_MDEF
-
-typedef struct MacMenu {
-    MenuRef menuHdl;		/* The Menu Manager data structure. */
-#ifdef USE_TK_MDEF
-    int useMDEF;		/* true if this menu uses the MDEF */
-#endif
-} MacMenu;
-
-typedef struct MenuEntryUserData {
-    Drawable mdefDrawable;
-    TkMenuEntry *mePtr;
-    Tk_Font tkfont;
-    Tk_FontMetrics *fmPtr;
-} MenuEntryUserData;
-
-/*
- * Platform specific flags for menu entries
- *
- * ENTRY_COMMAND_ACCEL		Indicates the entry has the command key
- *				in its accelerator string.
- * ENTRY_OPTION_ACCEL		Indicates the entry has the option key
- *				in its accelerator string.
- * ENTRY_SHIFT_ACCEL		Indicates the entry has the shift key
- *				in its accelerator string.
- * ENTRY_CONTROL_ACCEL		Indicates the entry has the control key
- *				in its accelerator string.
- */
-
-#define ENTRY_COMMAND_ACCEL	ENTRY_PLATFORM_FLAG1
-#define ENTRY_OPTION_ACCEL	ENTRY_PLATFORM_FLAG2
-#define ENTRY_SHIFT_ACCEL	ENTRY_PLATFORM_FLAG3
-#define ENTRY_CONTROL_ACCEL	ENTRY_PLATFORM_FLAG4
-#define ENTRY_ACCEL_MASK	(ENTRY_COMMAND_ACCEL | ENTRY_OPTION_ACCEL \
-				| ENTRY_SHIFT_ACCEL | ENTRY_CONTROL_ACCEL)
-#define MODIFIER_NUM 4
-
-/*
- * This structure is used to keep track of subfields within Macintosh menu
- * items.
- */
-
-typedef struct EntryGeometry {
-    int accelTextStart;		/* Offset into the accel string where the text
-				 * starts. Everything before this is modifier
-				 * key descriptions. */
-    int modifierWidth;		/* Width of modifier symbols. */
-    int accelTextWidth;		/* Width of the text after the modifier
-				 * keys. */
-    int nonAccelMargin;		/* The width of the margin for entries without
-				 * accelerators. */
-    int modifierNum;		/* Number of modifiers */
-    Tcl_UniChar modifierUniChars[MODIFIER_NUM];
-				/* Modifiers in unicode */
-    char accelGlyph;		/* Accelerator glyph, if any */
-} EntryGeometry;
-
-/*
- * Structure to keep track of toplevel windows and their menubars.
- */
-
-typedef struct TopLevelMenubarList {
-    struct TopLevelMenubarList *nextPtr;
-				/* The next window in the list. */
-    Tk_Window tkwin;		/* The toplevel window. */
-    TkMenu *menuPtr;		/* The menu associated with this toplevel. */
-} TopLevelMenubarList;
-
-/*
- * Platform-specific flags for menus.
- *
- * MENU_APPLE_MENU		0 indicates a custom Apple menu has not been
- *				installed; 1 a custom Apple menu has been
- *				installed.
- * MENU_HELP_MENU		0 indicates a custom Help menu has not been
- *				installed; 1 a custom Help menu has been
- *				installed.
- * MENU_RECONFIGURE_PENDING	1 indicates that an idle handler has been
- *				scheduled to reconfigure the Macintosh
- *				MenuHandle.
- */
-
-#define MENU_APPLE_MENU			MENU_PLATFORM_FLAG1
-#define MENU_HELP_MENU			MENU_PLATFORM_FLAG2
-#define MENU_RECONFIGURE_PENDING	MENU_PLATFORM_FLAG3
-
-#define CASCADE_CMD (0x1b)	/* The special command char for cascade
-				 * menus. */
-#define MENUBAR_REDRAW_PENDING 1
-
-static int gNoTkMenus = 0;	/* This is used by Tk_MacOSXTurnOffMenus as
-				 * the flag that Tk is not to draw any
-				 * menus. */
-
-static Tcl_HashTable commandTable;
-				/* The list of menuInstancePtrs associated
-				 * with menu ids. */
-static short currentAppleMenuID;
-				/* The id of the current Apple menu. 0 for
-				 * none. */
-static short currentHelpMenuID; /* The id of the current Help menu. 0 for
-				 * none. */
-static Tcl_Interp *currentMenuBarInterp;
-				/* The interpreter of the window that owns the
-				 * current menubar. */
-static char *currentMenuBarName;
-				/* Malloced. Name of current menu in menu bar.
-				 * NULL if no menu set. TO DO: make this a
-				 * DString. */
-static Tk_Window currentMenuBarOwner;
-				/* Which window owns the current menu bar. */
-static int inPostMenu;		/* We cannot be re-entrant like X windows. */
-static short lastMenuID;	/* To pass to NewMenu; need to figure out a
-				 * good way to do this. */
-static short lastCascadeID;	/* Cascades have to have ids that are less
-				 * than 256. */
-static int menuBarFlags;	/* Used for whether the menu bar needs
-				 * redrawing or not. */
-
-struct MenuCommandHandlerData { /* This is the ClientData we pass to */
-    TkMenu *menuPtr;		/* Tcl_DoWhenIdle to move handling */
-    int index;			/* menu commands to the event loop. */
+#define ENTRY_HELP_MENU		ENTRY_PLATFORM_FLAG1
+#define ENTRY_APPLE_MENU	ENTRY_PLATFORM_FLAG2
+#define ENTRY_WINDOWS_MENU	ENTRY_PLATFORM_FLAG3
+
+#define sl(s) ((int) (sizeof(s "") - 1))
+#define SPECIALMENU(n, f) {.name = "." #n, .len = sl(#n) + 1, \
+	.flag = ENTRY_##f##_MENU }
+static const struct {
+    const char *name; const size_t len; const int flag;
+} specialMenus[] = {
+    SPECIALMENU(help,	HELP),
+    SPECIALMENU(apple,	APPLE),
+    SPECIALMENU(window,	WINDOWS),
+    {NULL}
 };
-
-static TopLevelMenubarList *windowListPtr;
-				/* A list of windows that have menubars set. */
-
-/*
- * Array of unicode, charcode and utf representations of the most common
- * special menu symbols.
- */
-
-typedef struct MenuSymbol {
-    const Tcl_UniChar unicode;
-    const char charCode;
-    /* char padding; */
-    int utfLen, width;
-    char utf[TCL_UTF_MAX + 1];
-} MenuSymbol;
-
-static MenuSymbol menuSymbols[] = {
-    {kCommandUnicode,	kCommandCharCode},
-    {kOptionUnicode,	kMenuOptionGlyph},
-    {kControlUnicode,	kMenuControlGlyph},
-    {kShiftUnicode,	kMenuShiftGlyph},
-    {kCheckUnicode,	kCheckCharCode},
-    {kDiamondUnicode,	kDiamondCharCode},
-    {kBulletUnicode,	kBulletCharCode},
-    {0x2026,		kNullCharCode},
-    {0,			0},
+#undef SPECIALMENU
+#define MODIFIER(n, f) {.name = #n, .len = sl(#n), .mask = f }
+static const struct {
+    const char *name; const size_t len; const NSUInteger mask;
+} modifiers[] = {
+    MODIFIER(Control,	NSControlKeyMask),
+    MODIFIER(Ctrl,	NSControlKeyMask),
+    MODIFIER(Option,	NSAlternateKeyMask),
+    MODIFIER(Opt,	NSAlternateKeyMask),
+    MODIFIER(Alt,	NSAlternateKeyMask),
+    MODIFIER(Shift,	NSShiftKeyMask),
+    MODIFIER(Command,	NSCommandKeyMask),
+    MODIFIER(Cmd,	NSCommandKeyMask),
+    MODIFIER(Meta,	NSCommandKeyMask),
+    {NULL}
 };
-
-enum MenuSymbolIdx {
-    COMMAND_SYMBOL,
-    OPTION_SYMBOL,
-    CONTROL_SYMBOL,
-    SHIFT_SYMBOL,
-    CHECK_SYMBOL,
-    DIAMDOND_SYMBOL,
-    BULLET_SYMBOL,
-    ELLIPSIS_SYMBOL,
+#undef MODIFIER
+#define ACCEL(n, c) {.name = #n, .len = sl(#n), .ch = c }
+static const struct {
+    const char *name; const size_t len; const UniChar ch;
+} specialAccelerators[] = {
+    ACCEL(PageUp,	NSPageUpFunctionKey),
+    ACCEL(PageDown,	NSPageDownFunctionKey),
+    ACCEL(Left,		NSLeftArrowFunctionKey),
+    ACCEL(Right,	NSRightArrowFunctionKey),
+    ACCEL(Up,		NSUpArrowFunctionKey),
+    ACCEL(Down,		NSDownArrowFunctionKey),
+    ACCEL(Escape,	0x001b),
+    ACCEL(Clear,	NSClearDisplayFunctionKey),
+    ACCEL(Enter,	NSEnterCharacter),
+    ACCEL(Backspace,	NSBackspaceCharacter),
+    ACCEL(Space,	' '),
+    ACCEL(Tab,		NSTabCharacter),
+    ACCEL(BackTab,	NSBackTabCharacter),
+    ACCEL(Delete,	NSDeleteCharacter),
+    ACCEL(Home,		NSHomeFunctionKey),
+    ACCEL(End,		NSEndFunctionKey),
+    ACCEL(Return,	NSCarriageReturnCharacter),
+    ACCEL(Help,		NSHelpFunctionKey),
+    ACCEL(Power,	0x233d),
+    ACCEL(Eject,	0xf804),
+    {NULL}
 };
+#undef ACCEL
+#undef sl
 
-MenuRef tkCurrentAppleMenu = NULL;
-
-static SInt32 menuMarkColumnWidth = 0, menuMarkIndent = 0;
+static int gNoTkMenus = 0;	/* This is used by Tk_MacOSXTurnOffMenus as
+				 * the flag that Tk is not to draw any
+				 * menus. */
+static int inPostMenu = 0;
+static unsigned long defaultBg = 0, defaultFg = 0;
+static SInt32 menuMarkColumnWidth = 0, menuIconTrailingEdgeMargin = 0;
 static SInt32 menuTextLeadingEdgeMargin = 0, menuTextTrailingEdgeMargin = 0;
 static SInt16 menuItemExtraHeight = 0, menuItemExtraWidth = 0;
 static SInt16 menuSeparatorHeight = 0;
 
-/*
- * Forward declarations for procedures defined later in this file:
- */
-
-MODULE_SCOPE int	TkMacOSXGetNewMenuID(Tcl_Interp *interp,
-			    TkMenu *menuInstPtr, int cascade,
-			    short *menuIDPtr);
-MODULE_SCOPE void	TkMacOSXFreeMenuID(short menuID);
-
-static void		CompleteIdlers(TkMenu *menuPtr);
-static void		DrawMenuBarWhenIdle(ClientData clientData);
-static void		DrawMenuEntryAccelerator(TkMenu *menuPtr,
-			    TkMenuEntry *mePtr, Drawable d, GC gc,
-			    Tk_Font tkfont, const Tk_FontMetrics *fmPtr,
-			    Tk_3DBorder activeBorder, int x, int y, int width,
-			    int height, int drawArrow);
-static void		DrawMenuEntryBackground(TkMenu *menuPtr,
-			    TkMenuEntry *mePtr, Drawable d,
-			    Tk_3DBorder activeBorder, Tk_3DBorder bgBorder,
-			    int x, int y, int width, int heigth);
-static void		DrawMenuEntryIndicator(TkMenu *menuPtr,
-			    TkMenuEntry *mePtr, Drawable d, GC gc,
-			    GC indicatorGC, Tk_Font tkfont,
-			    const Tk_FontMetrics *fmPtr, int x, int y,
-			    int width, int height);
-static void		DrawMenuEntryLabel(TkMenu *menuPtr,TkMenuEntry *mePtr,
-			    Drawable d, GC gc, Tk_Font tkfont,
-			    const Tk_FontMetrics *fmPtr, int x, int y,
-			    int width, int height);
-static void		DrawMenuSeparator(TkMenu *menuPtr, TkMenuEntry *mePtr,
-			    Drawable d, GC gc, Tk_Font tkfont,
-			    const Tk_FontMetrics *fmPtr, int x, int y,
-			    int width, int height);
-static void		DrawTearoffEntry(TkMenu *menuPtr, TkMenuEntry *mePtr,
-			    Drawable d, GC gc, Tk_Font tkfont,
-			    const Tk_FontMetrics *fmPtr, int x, int y,
-			    int width, int height);
-static void		EventuallyInvokeMenu(ClientData data);
-static void		GetEntryText(TkMenuEntry *mePtr,
-			    Tcl_DString *dStringPtr);
-static void		GetMenuAccelGeometry(TkMenu *menuPtr,
-			    TkMenuEntry *mePtr, Tk_Font tkfont,
-			    const Tk_FontMetrics *fmPtr, int *modWidthPtr,
-			    int *textWidthPtr, int *heightPtr);
-static void		GetMenuLabelGeometry(TkMenuEntry *mePtr,
-			    Tk_Font tkfont, const Tk_FontMetrics *fmPtr,
-			    int *widthPtr, int *heightPtr);
-static void		GetMenuIndicatorGeometry(TkMenu *menuPtr,
-			    TkMenuEntry *mePtr, Tk_Font tkfont,
-			    const Tk_FontMetrics *fmPtr, int *widthPtr,
-			    int *heightPtr);
-static void		GetMenuSeparatorGeometry(TkMenu *menuPtr,
-			    TkMenuEntry *mePtr, Tk_Font tkfont,
-			    const Tk_FontMetrics *fmPtr, int *widthPtr,
-			    int *heightPtr);
-static TkMenuEntry *	GetParentMenuEntry(TkMenu *menuPtr);
-static void		GetTearoffEntryGeometry(TkMenu *menuPtr,
-			    TkMenuEntry *mePtr, Tk_Font tkfont,
-			    const Tk_FontMetrics *fmPtr, int *widthPtr,
-			    int *heightPtr);
-static char		FindMarkCharacter(TkMenuEntry *mePtr);
-static int		GetUtfMarkCharacter(char markChar,
-			    const char **markUtfPtr);
-static TkMenu *		MenuPtrForMenuRef(MenuRef menu);
-static int		ParseAccelerators(const char **accelStringPtr,
-			    int *modifierNumPtr,
-			    Tcl_UniChar *modifierUniChars,
-			    int *modifierWidth);
-static void		MenuSelectEvent(TkMenu *menuPtr);
-static void		ReconfigureIndividualMenu(TkMenu *menuPtr,
-			    MenuHandle macMenuHdl, int base);
-static void		ReconfigureMacintoshMenu(ClientData clientData);
-static void		RecursivelyClearActiveMenu(TkMenu *menuPtr);
-static void		RecursivelyDeleteMenu(TkMenu *menuPtr);
-static void		RecursivelyInsertMenu(TkMenu *menuPtr);
-static void		SetDefaultMenubar(void);
-static int		SetMenuCascade(TkMenu *menuPtr);
-
-#ifdef USE_TK_MDEF
-#define SCREEN_MARGIN 5
-static MacDrawable macMDEFDrawable;
-				/* Drawable for use by MDEF code */
-static int MDEFScrollFlag = 0;	/* Used so that popups don't scroll too
-				 * soon. */
-static MenuItemDrawingUPP tkThemeMenuItemDrawingUPP;
-				/* Points to the UPP for theme Item
-				 * drawing. */
-static Tcl_Obj *useMDEFVar;
-
-static void		DrawMenuBackground(TkMenu *menuPtr, Rect *menuRectPtr,
-			    Drawable d);
-static void		MenuDefProc(short message, MenuHandle menu,
-			    Rect *menuRectPtr, Point hitPt, short *whichItem);
-static void		HandleMenuHiliteMsg(MenuRef menu, Rect *menuRectPtr,
-			    Point hitPt, SInt16 *whichItem, TkMenu *menuPtr);
-static void		HandleMenuDrawMsg(MenuRef menu, Rect *menuRectPtr,
-			    Point hitPt, SInt16 *whichItem, TkMenu *menuPtr);
-static void		HandleMenuFindItemMsg(MenuRef menu, Rect *menuRectPtr,
-			    Point hitPt, SInt16 *whichItem, TkMenu *menuPtr);
-static void		HandleMenuPopUpMsg(MenuRef menu, Rect *menuRectPtr,
-			    Point hitPt, SInt16 *whichItem, TkMenu *menuPtr);
-static void		HandleMenuCalcItemMsg(MenuRef menu, Rect *menuRectPtr,
-			    Point hitPt, SInt16 *whichItem, TkMenu *menuPtr);
-static void		AppearanceEntryDrawWrapper(TkMenuEntry *mePtr,
-			    Rect *menuRectPtr, MenuTrackingData *mtdPtr,
-			    Drawable d, Tk_FontMetrics *fmPtr, Tk_Font tkfont,
-			    int erase);
-static pascal void	ThemeMenuItemDrawingProc(const Rect *inBounds,
-			    SInt16 inDepth, Boolean inIsColorDevice,
-			    SInt32 inUserData);
-#else /* USE_TK_MDEF */
-#   define useMDEF 0
-#endif /* USE_TK_MDEF */
-
-#define IS_THEME_MENU_FONT(tkfont) (strcmp(Tk_NameOfFont(tkfont), "menu") == 0)
-
-/*
- *----------------------------------------------------------------------
- *
- * DrawThemeText --
- *
- *	Wrapper for DrawThemeTextBox API.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-DrawThemeText(
-    Drawable d,
-    GC gc,
-    CFStringRef string,
-    ThemeFontID font,
-    ThemeDrawState drawState,
-    const Rect* bounds,
-    int baseline,
-    int just)
-{
-    TkMacOSXDrawingContext dc;
-    Rect adjustedBounds;
-
-    /*
-     * Menu item text drawn with the .Keyboard font (used for
-     * kThemeMenuItemCmdKeyFont) won't always have the same ascent and
-     * baseline as text drawn with the regular menu item font, since the
-     * glyphs in the .Keyboard font may have a different height. Therefore, we
-     * first determine the baseline of the text and then adjust the bounds
-     * rect so the baseline aligns with the overall baseline of the menu item.
-     */
-
-    if (font == kThemeMenuItemCmdKeyFont) {
-	Point size;
-	SInt16 cmdKeyBaseline;
-
-	GetThemeTextDimensions(string, font, drawState, false, &size,
-		&cmdKeyBaseline);
-	adjustedBounds = *bounds;
-	OffsetRect(&adjustedBounds, 0, baseline - bounds->top - size.v -
-		cmdKeyBaseline);
-	bounds = &adjustedBounds;
+static void	CheckForSpecialMenu(TkMenu *menuPtr);
+static NSString *ParseAccelerator(const char *accel, NSUInteger *maskPtr);
+static int	GenerateMenuSelectEvent(TKMenu *menu, NSMenuItem *menuItem);
+static void	MenuSelectEvent(TkMenu *menuPtr);
+static void	RecursivelyClearActiveMenu(TkMenu *menuPtr);
+static int	ModifierCharWidth(Tk_Font tkfont);
+
+#pragma mark TKMenu
+
+@interface TKMenu(TKMenuPrivate)
+- (id)initWithTkMenu:(TkMenu *)tkMenu;
+- (TkMenu *)tkMenu;
+- (int)tkIndexOfItem:(NSMenuItem *)menuItem;
+- (void)insertItem:(NSMenuItem *)newItem atTkIndex:(NSInteger)index;
+@end
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1060
+#define TKMenu_NSMenuDelegate <NSMenuDelegate>
+#else
+#define TKMenu_NSMenuDelegate
+#endif
+@interface TKMenu(TKMenuDelegate) TKMenu_NSMenuDelegate
+@end
+
+@implementation TKMenu
+- (void)setSpecial:(NSUInteger)special {
+    NSAssert(!_tkSpecial, @"Cannot change specialness of a special menu");
+    _tkSpecial = special;
+}
+- (BOOL)isSpecial:(NSUInteger)special {
+    return (_tkSpecial == special);
+}
+@end
+
+@implementation TKMenu(TKMenuPrivate)
+- (id)initWithTitle:(NSString *)aTitle {
+    self = [super initWithTitle:aTitle];
+    if (self) {
+	_tkMenu = NULL;
+	_tkOffset = 0;
+	_tkItemCount = 0;
+	_tkSpecial = 0;
+	[self setDelegate:self];
+    }
+    return self;
+}
+- (id)initWithTkMenu:(TkMenu *)tkMenu {
+    NSString *title = [[NSString alloc] initWithUTF8String:
+	    Tk_PathName(tkMenu->tkwin)];
+    self = [self initWithTitle:title];
+    [title release];
+    if (self) {
+	_tkMenu = tkMenu;
+    }
+    return self;
+}
+- (id)copyWithZone:(NSZone *)zone {
+    TKMenu *copy = [super copyWithZone:zone];
+    NSAssert(_tkMenu == nil, @"Cannot copy tkMenu");
+    copy->_tkMenu = _tkMenu;
+    copy->_tkOffset = _tkOffset;
+    copy->_tkItemCount = _tkItemCount;
+    copy->_tkSpecial = _tkSpecial;
+    return copy;
+}
+- (TkMenu *)tkMenu {
+    return _tkMenu;
+}
+- (int)tkIndexOfItem:(NSMenuItem *)menuItem {
+    return [self indexOfItem:menuItem] - _tkOffset;
+}
+- (void)insertItem:(NSMenuItem *)newItem atTkIndex:(NSInteger)index {
+    [super insertItem:newItem atIndex:index + _tkOffset];
+    _tkItemCount++;
+}
+- (void)insertItem:(NSMenuItem *)newItem atIndex:(NSInteger)index {
+    if (_tkMenu && index >= 0) {
+	if ((NSUInteger)index <= _tkOffset) {
+	    _tkOffset++;
+	} else {
+	    NSAssert((NSUInteger)index >= _tkItemCount + _tkOffset,
+		    @"Cannot insert in the middle of Tk menu");
+	}
     }
-    if (TkMacOSXSetupDrawingContext(d, gc, 1, &dc)) {
-	ChkErr(DrawThemeTextBox, string, font, drawState, false, bounds, just,
-		dc.context);
-	TkMacOSXRestoreDrawingContext(&dc);
+    [super insertItem:newItem atIndex:index];
+}
+- (void)removeItemAtIndex:(NSInteger)index {
+    if (_tkMenu && index >= 0) {
+	if ((NSUInteger)index < _tkOffset) {
+	    _tkOffset--;
+	} else if ((NSUInteger)index < _tkItemCount + _tkOffset) {
+	    _tkItemCount--;
+	}
     }
+    [super removeItemAtIndex:index];
 }
-
-/*
- *----------------------------------------------------------------------
- *
- * MeasureThemeText --
- *
- *	Wrapper for GetThemeTextDimensions API.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-MeasureThemeText(
-    CFStringRef string,
-    ThemeFontID font)
-{
-    Point pt;
-
-    ChkErr(GetThemeTextDimensions, string, font, kThemeStateActive, false, &pt,
-	    NULL);
-    return pt.h;
+- (NSMenuItem *)newTkMenuItem:(TkMenuEntry *)mePtr {
+    NSMenuItem *menuItem = [[NSMenuItem alloc] initWithTitle:@""
+	action:@selector(tkMenuItemInvoke:) keyEquivalent:@""];
+    [menuItem setTarget:self];
+    [menuItem setTag:(NSInteger)mePtr];
+    return menuItem;
 }
-
-/*
- *----------------------------------------------------------------------
- *
- * TkMacOSXUseID --
- *
- *	Take the ID out of the available list for new menus. Used by the
- *	default menu bar's menus so that they do not get created at the tk
- *	level. See TkMacOSXGetNewMenuID for more information.
- *
- * Results:
- *	Returns TCL_OK if the id was not in use. Returns TCL_ERROR if the id
- *	was in use.
- *
- * Side effects:
- *	A hash table entry in the command table is created with a NULL value.
- *
- *----------------------------------------------------------------------
- */
+@end
 
-int
-TkMacOSXUseMenuID(
-    short macID)		/* The id to take out of the table */
-{
-    Tcl_HashEntry *commandEntryPtr;
-    int newEntry;
-    int iMacID = macID; /* Do this to remove compiler warning */
-
-    TkMenuInit();
-    commandEntryPtr = Tcl_CreateHashEntry(&commandTable, (char *) iMacID,
-	    &newEntry);
-    if (!newEntry) {
-	return TCL_ERROR;
-    }
-    Tcl_SetHashValue(commandEntryPtr, NULL);
-    return TCL_OK;
+@implementation TKMenu(TKMenuActions)
+// target methods
+- (BOOL)validateMenuItem:(NSMenuItem *)menuItem {
+    return [menuItem isEnabled];
 }
-
-/*
- *----------------------------------------------------------------------
- *
- * TkMacOSXGetNewMenuID --
- *
- *	Allocates a new menu id and marks it in use. Each menu on the mac must
- *	be designated by a unique id, which is a short. In addition, some ids
- *	are reserved by the system. Since Tk uses mostly dynamic menus, we
- *	must allocate and free these ids on the fly. We use the id as a key
- *	into a hash table; if there is no hash entry, we know that we can use
- *	the id.
- *
- *	Carbon allows a much larger number of menus than the old APIs. I
- *	believe this is 32768, but am not sure. This code just uses 2000 as
- *	the upper limit. Unfortunately tk leaks menus when cloning, under some
- *	circumstances (see bug on sourceforge).
- *
- * Results:
- *	Returns TCL_OK if succesful; TCL_ERROR if there are no more ids of the
- *	appropriate type to allocate. menuIDPtr contains the new id if
- *	succesful.
- *
- * Side effects:
- *	An entry is created for the menu in the command hash table, and the
- *	hash entry is stored in the appropriate field in the menu data
- *	structure.
- *
- *----------------------------------------------------------------------
- */
-
-int
-TkMacOSXGetNewMenuID(
-    Tcl_Interp *interp,		/* Used for error reporting */
-    TkMenu *menuPtr,		/* The menu we are working with */
-    int cascade,		/* 0 if we are working with a normal menu;
-				 * 1 if we are working with a cascade */
-    short *menuIDPtr)		/* The resulting id */
-{
-    int found = 0;
-    int newEntry;
-    Tcl_HashEntry *commandEntryPtr = NULL;
-    short returnID = *menuIDPtr;
-
+- (void)tkMenuItemInvoke:(id)sender {
     /*
-     * The following code relies on shorts and unsigned chars wrapping when
-     * the highest value is incremented. Also, the values between 236 and 255
-     * inclusive are reserved for DA's by the Mac OS.
+     * With the delegate matching key equivalents, when a menu action is sent
+     * in response to a key equivalent, sender is the whole menu and not the
+     * the specific menu item, use this to ignore key equivalents for our menus
+     * (as Tk handles them directly via bindings).
      */
-
-    if (!cascade) {
-	short curID = lastMenuID + 1;
-
-	if (curID == 236) {
-	    curID = 256;
-	}
-
-	while (curID != lastMenuID) {
-	    int iCurID = curID;
-	    commandEntryPtr = Tcl_CreateHashEntry(&commandTable,
-		    (char *) iCurID, &newEntry);
-	    if (newEntry == 1) {
-		found = 1;
-		lastMenuID = returnID = curID;
-		break;
-	    }
-	    curID++;
-	    if (curID == 236) {
-		curID = 256;
-	    }
-	}
-    } else {
-	/*
-	 * Cascade ids must be between 0 and 235 only, so they must be dealt
-	 * with separately.
-	 */
-
-	short curID = lastCascadeID + 1;
-
-	if (curID == 2000) {
-	    curID = 0;
-	}
-
-	while (curID != lastCascadeID) {
-	    int iCurID = curID;
-	    commandEntryPtr = Tcl_CreateHashEntry(&commandTable,
-		    (char *) iCurID, &newEntry);
-	    if (newEntry == 1) {
-		found = 1;
-		lastCascadeID = returnID = curID;
-		break;
+    if ([sender isKindOfClass:[NSMenuItem class]]) {
+	NSMenuItem *menuItem = (NSMenuItem *)sender;
+	TkMenu *menuPtr = (TkMenu *)_tkMenu;
+	TkMenuEntry *mePtr = (TkMenuEntry *)[menuItem tag];
+	if (menuPtr && mePtr) {
+	    Tcl_Interp *interp = menuPtr->interp;
+	    Tcl_Preserve(interp);
+	    Tcl_Preserve(menuPtr);
+	    int result = TkInvokeMenu(interp, menuPtr, mePtr->index);
+	    if (result != TCL_OK && result != TCL_CONTINUE &&
+		    result != TCL_BREAK) {
+		Tcl_AddErrorInfo(interp, "\n    (menu invoke)");
+		Tcl_BackgroundException(interp, result);
 	    }
-	    curID++;
-	    if (curID == 2000) {
-		curID = 0;
+	    Tcl_Release(menuPtr);
+	    Tcl_Release(interp);
+	}
+    }
+}
+@end
+
+@implementation TKMenu(TKMenuDelegate)
+#define keyEquivModifiersMatch(km, m) (( \
+    ((km) & NSCommandKeyMask) != ((m) & NSCommandKeyMask) || \
+    ((km) & NSAlternateKeyMask) != ((m) & NSAlternateKeyMask) || \
+    ((km) & NSControlKeyMask) != ((m) & NSControlKeyMask) || \
+    (((km) & NSShiftKeyMask) != ((m) & NSShiftKeyMask) && \
+    ((m) & NSFunctionKeyMask))) ? NO : YES)
+- (BOOL)menuHasKeyEquivalent:(NSMenu*)menu forEvent:(NSEvent*)event
+	target:(id*)target action:(SEL*)action {
+    NSString *key = [event charactersIgnoringModifiers];
+    NSUInteger modifiers = [event modifierFlags] &
+	    NSDeviceIndependentModifierFlagsMask;
+    if (modifiers == (NSCommandKeyMask | NSShiftKeyMask) &&
+	    [key compare:@"?"] == NSOrderedSame) {
+	return NO;
+    }
+    NSArray *itemArray = [self itemArray];
+    for (NSMenuItem *item in itemArray) {
+	if ([item isEnabled] && [[item keyEquivalent] compare:key] ==
+		NSOrderedSame) {
+	    NSUInteger keyEquivModifiers = [item keyEquivalentModifierMask];
+	    if (keyEquivModifiersMatch(keyEquivModifiers, modifiers)) {
+		*target = [item target];
+		*action = [item action];
+		return YES;
 	    }
 	}
     }
-
-    if (!found) {
-	Tcl_ResetResult(interp);
-	Tcl_AppendResult(interp, "No more menus can be allocated.", NULL);
-	return TCL_ERROR;
-    }
-    Tcl_SetHashValue(commandEntryPtr, menuPtr);
-    *menuIDPtr = returnID;
-    return TCL_OK;
+    return NO;
 }
-
-/*
- *----------------------------------------------------------------------
- *
- * TkMacOSXFreeMenuID --
- *
- *	Marks the id as free.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	The hash table entry for the ID is cleared.
- *
- *----------------------------------------------------------------------
- */
-
-void
-TkMacOSXFreeMenuID(
-    short menuID)		/* The id to free */
-{
-    Tcl_HashEntry *entryPtr = Tcl_FindHashEntry(&commandTable,
-	    (char*)(intptr_t)menuID);
-
-    if (entryPtr != NULL) {
-	 Tcl_DeleteHashEntry(entryPtr);
+- (void)menuWillOpen:(NSMenu *)menu {
+    if (_tkMenu) {
+	//RecursivelyClearActiveMenu(_tkMenu);
+	GenerateMenuSelectEvent((TKMenu *)[self supermenu],
+		[self itemInSupermenu]);
     }
-    if (menuID == currentAppleMenuID) {
-	currentAppleMenuID = 0;
+}
+- (void)menuDidClose:(NSMenu *)menu {
+    if (_tkMenu) {
+	RecursivelyClearActiveMenu(_tkMenu);
     }
-    if (menuID == currentHelpMenuID) {
-	currentHelpMenuID = 0;
+}
+- (void)menu:(NSMenu *)menu willHighlightItem:(NSMenuItem *)item {
+    if (_tkMenu) {
+	GenerateMenuSelectEvent(self, item);
     }
 }
-
-/*
- *----------------------------------------------------------------------
- *
- * MenuPtrForMenuRef --
- *
- *	Returns a pointer to the TkMenu corresponding to a given Carbon
- *	MenuRef.
- *
- * Results:
- *	Returns a pointer to a TkMenu or NULL.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-TkMenu *
-MenuPtrForMenuRef(
-    MenuRef menu)
-{
-    TkMenu *menuPtr = NULL;
-    MenuID menuID = GetMenuID(menu);
-    Tcl_HashEntry *commandEntryPtr =
-	    Tcl_FindHashEntry(&commandTable, (char*)(intptr_t)menuID);
-
-    if (commandEntryPtr) {
-	menuPtr = Tcl_GetHashValue(commandEntryPtr);
+- (void)menuNeedsUpdate:(NSMenu*)menu {
+    TkMenu *menuPtr = (TkMenu *)_tkMenu;
+    if (menuPtr) {
+	Tcl_Interp *interp = menuPtr->interp;
+	Tcl_Preserve(interp);
+	Tcl_Preserve(menuPtr);
+	int result = TkPostCommand(_tkMenu);
+	if (result != TCL_OK && result != TCL_CONTINUE && result != TCL_BREAK) {
+	    Tcl_AddErrorInfo(interp, "\n    (menu preprocess)");
+	    Tcl_BackgroundException(interp, result);
+	}
+	Tcl_Release(menuPtr);
+	Tcl_Release(interp);
     }
-    return menuPtr;
 }
-
-/*
- *----------------------------------------------------------------------
- *
- * GetParentMenuEntry --
- *
- *	Returns a pointer to the parent's TkMenuEntry of a given TkMenu.
- *
- * Results:
- *	Returns a pointer to a TkMenuEntry or NULL.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
+@end
 
-TkMenuEntry*
-GetParentMenuEntry(
-    TkMenu *menuPtr)
-{
-    TkMenuEntry *cascadeEntryPtr;
+#pragma mark TKApplication(TKMenu)
 
-    for (cascadeEntryPtr = menuPtr->menuRefPtr->parentEntryPtr;
-	    cascadeEntryPtr != NULL;
-	    cascadeEntryPtr = cascadeEntryPtr->nextCascadePtr) {
-	const char *name = (cascadeEntryPtr->namePtr == NULL) ? ""
-		: Tcl_GetString(cascadeEntryPtr->namePtr);
+@interface NSApplication(TKMenu)
+- (void)setAppleMenu:(NSMenu *)menu;
+@end
 
-	if (strcmp(name, Tk_PathName(menuPtr->tkwin)) == 0) {
-	    break;
+@implementation TKApplication(TKMenu)
+- (void)menuBeginTracking:(NSNotification *)notification {
+#ifdef TK_MAC_DEBUG_NOTIFICATIONS
+    TKLog(@"-[%@(%p) %s] %@", [self class], self, _cmd, notification);
+#endif
+    //TkMacOSXClearMenubarActive();
+    //TkMacOSXPreprocessMenu();
+}
+- (void)menuEndTracking:(NSNotification *)notification {
+#ifdef TK_MAC_DEBUG_NOTIFICATIONS
+    TKLog(@"-[%@(%p) %s] %@", [self class], self, _cmd, notification);
+#endif
+    if (!inPostMenu) {
+	TkMacOSXClearMenubarActive();
+    }
+}
+- (void)tkSetMainMenu:(TKMenu *)menu {
+    if (gNoTkMenus) {
+	return;
+    }
+    TKMenu *applicationMenu = nil;
+    if (menu) {
+	NSMenuItem *applicationMenuItem = [menu numberOfItems] ?
+		[menu itemAtIndex:0] : nil;
+	if (![menu isSpecial:tkMainMenu]) {
+	    TkMenuEntry *mePtr = (TkMenuEntry *)[applicationMenuItem tag];
+	    if (!mePtr || !(mePtr->entryFlags & ENTRY_APPLE_MENU)) {
+		applicationMenuItem = [NSMenuItem itemWithSubmenu:
+			[[_defaultApplicationMenu copy] autorelease]];
+		[menu insertItem:applicationMenuItem atIndex:0];
+	    }
+	    [menu setSpecial:tkMainMenu];
 	}
+	applicationMenu = (TKMenu *)[applicationMenuItem submenu];
+	if (![applicationMenu isSpecial:tkApplicationMenu]) {
+	    for (NSMenuItem *item in _defaultApplicationMenuItems) {
+		[applicationMenu addItem:[[item copy] autorelease]];
+	    }
+	    [applicationMenu setSpecial:tkApplicationMenu];
+	}
+	NSArray *itemArray = [menu itemArray];
+	for (NSMenuItem *item in itemArray) {
+	    TkMenuEntry *mePtr = (TkMenuEntry *)[item tag];
+	    TKMenu *submenu = (TKMenu *)[item submenu];
+	    if (mePtr && submenu) {
+		if ((mePtr->entryFlags & ENTRY_WINDOWS_MENU) &&
+			![submenu isSpecial:tkWindowsMenu]) {
+		    NSInteger index = 0;
+		    for (NSMenuItem *i in _defaultWindowsMenuItems) {
+			[submenu insertItem:[[i copy] autorelease] atIndex:
+				index++];
+		    }
+		    [self setWindowsMenu:submenu];
+		    [submenu setSpecial:tkWindowsMenu];
+		} else if ((mePtr->entryFlags & ENTRY_HELP_MENU) &&
+			![submenu isSpecial:tkHelpMenu]) {
+		    NSInteger index = 0;
+		    for (NSMenuItem *i in _defaultHelpMenuItems) {
+			[submenu insertItem:[[i copy] autorelease] atIndex:
+				index++];
+		    }
+		    [submenu setSpecial:tkHelpMenu];
+		}
+	    }
+	}
+    } else {
+	menu = _defaultMainMenu;
+	applicationMenu = _defaultApplicationMenu;
+    }
+    NSMenuItem *servicesMenuItem = [applicationMenu itemWithTitle:@"Services"];
+    if (servicesMenuItem && [servicesMenuItem submenu] != _servicesMenu) {
+	[[_servicesMenu itemInSupermenu] setSubmenu:nil];
+	[servicesMenuItem setSubmenu:_servicesMenu];
     }
-    return cascadeEntryPtr;
+    [self setAppleMenu:applicationMenu];
+    [self setMainMenu:menu];
 }
+@end
+
+#pragma mark -
 
 /*
  *----------------------------------------------------------------------
@@ -652,10 +396,10 @@ GetParentMenuEntry(
  *	in.
  *
  * Results:
- *	Returns a standard TCL error.
+ *	Returns a standard Tcl error.
  *
  * Side effects:
- *	Allocates a Macintosh menu handle and puts in the platformData field
+ *	Allocates a NSMenu and puts it into the platformData field
  *	of the menuPtr.
  *
  *----------------------------------------------------------------------
@@ -666,82 +410,10 @@ TkpNewMenu(
     TkMenu *menuPtr)		/* The common structure we are making the
 				 * platform structure for. */
 {
-    short menuID;
-    MenuRef macMenuHdl;
-#ifdef USE_TK_MDEF
-    MenuDefSpec menuDefSpec;
-    Tcl_Obj *useMDEFObjPtr;
-    int useMDEF = 1;
-#endif
-    int error = TCL_OK;
-    OSStatus err;
-    CFStringRef cfStr;
-
-    error = TkMacOSXGetNewMenuID(menuPtr->interp, menuPtr, 0, &menuID);
-    if (error != TCL_OK) {
-	return error;
-    }
-    err = ChkErr(CreateNewMenu, menuID, kMenuAttrDoNotUseUserCommandKeys,
-	    &macMenuHdl);
-    if (err != noErr) {
-	Tcl_AppendResult(menuPtr->interp, "CreateNewMenu failed.", NULL);
-	return TCL_ERROR;
-    }
-    cfStr = CFStringCreateWithCString(NULL, Tk_PathName(menuPtr->tkwin),
-	    kCFStringEncodingUTF8);
-    if (!cfStr) {
-	Tcl_AppendResult(menuPtr->interp, "CFStringCreateWithCString failed.",
-		NULL);
-	return TCL_ERROR;
-    }
-    err = ChkErr(SetMenuTitleWithCFString, macMenuHdl, cfStr);
-    CFRelease(cfStr);
-    if (err != noErr) {
-	Tcl_AppendResult(menuPtr->interp, "SetMenuTitleWithCFString failed.",
-		NULL);
-	return TCL_ERROR;
-    }
-
-    menuPtr->platformData = (TkMenuPlatformData) ckalloc(sizeof(MacMenu));
-    ((MacMenu *) menuPtr->platformData)->menuHdl = macMenuHdl;
-
-#ifdef USE_TK_MDEF
-    /*
-     * Check whether we want to use the custom mdef or not. For now
-     * the default is to use it unless the variable is explicitly
-     * set to no.
-     */
-
-    useMDEFObjPtr = Tcl_ObjGetVar2(menuPtr->interp, useMDEFVar, NULL,
-	    TCL_GLOBAL_ONLY);
-    if (useMDEFObjPtr == NULL || Tcl_GetBooleanFromObj(NULL, useMDEFObjPtr,
-	    &useMDEF) == TCL_ERROR || useMDEF) {
-	menuDefSpec.defType = kMenuDefProcPtr;
-	menuDefSpec.u.defProc = MenuDefProc;
-	ChkErr(SetMenuDefinition, macMenuHdl, &menuDefSpec);
-    }
-    ((MacMenu *) menuPtr->platformData)->useMDEF = useMDEF;
-#endif /* USE_TK_MDEF */
-
-    if ((currentMenuBarInterp == menuPtr->interp)
-	    && (currentMenuBarName != NULL)) {
-	Tk_Window parentWin = Tk_Parent(menuPtr->tkwin);
-
-	if (strcmp(currentMenuBarName, Tk_PathName(parentWin)) == 0) {
-	    if ((strcmp(Tk_PathName(menuPtr->tkwin)
-		    + strlen(Tk_PathName(parentWin)), ".apple") == 0)
-		    || (strcmp(Tk_PathName(menuPtr->tkwin)
-		    + strlen(Tk_PathName(parentWin)), ".help") == 0)) {
-		if (!(menuBarFlags & MENUBAR_REDRAW_PENDING)) {
-		    Tcl_DoWhenIdle(DrawMenuBarWhenIdle, NULL);
-		    menuBarFlags |= MENUBAR_REDRAW_PENDING;
-		}
-	    }
-	}
-    }
-
-    menuPtr->menuFlags |= MENU_RECONFIGURE_PENDING;
-    Tcl_DoWhenIdle(ReconfigureMacintoshMenu, menuPtr);
+    TKMenu *menu = [[TKMenu alloc] initWithTkMenu:menuPtr];
+    menuPtr->platformData = (TkMenuPlatformData)
+	    TkMacOSXMakeUncollectable(menu);
+    CheckForSpecialMenu(menuPtr);
     return TCL_OK;
 }
 
@@ -765,330 +437,45 @@ void
 TkpDestroyMenu(
     TkMenu *menuPtr)		/* The common menu structure */
 {
-    MenuRef macMenuHdl = ((MacMenu *) menuPtr->platformData)->menuHdl;
-
-    if (menuPtr->menuFlags & MENU_RECONFIGURE_PENDING) {
-	Tcl_CancelIdleCall(ReconfigureMacintoshMenu, menuPtr);
-	menuPtr->menuFlags &= ~MENU_RECONFIGURE_PENDING;
-    }
-    if (GetMenuID(macMenuHdl) == currentHelpMenuID) {
-	MenuRef helpMenuHdl;
-	MenuItemIndex helpIndex;
-
-	if ((HMGetHelpMenu(&helpMenuHdl,&helpIndex) == noErr)
-		&& (helpMenuHdl != NULL)) {
-	    int i, count = CountMenuItems(helpMenuHdl);
-
-	    for (i = helpIndex; i <= count; i++) {
-		DeleteMenuItem(helpMenuHdl, helpIndex);
-	    }
-	}
-	currentHelpMenuID = 0;
-    }
-    if (menuPtr->platformData != NULL) {
-	MenuID menuID = GetMenuID(macMenuHdl);
-
-	DeleteMenu(menuID);
-	TkMacOSXFreeMenuID(menuID);
-	DisposeMenu(macMenuHdl);
-	ckfree((char *) menuPtr->platformData);
-	menuPtr->platformData = NULL;
-    }
+    TkMacOSXMakeCollectableAndRelease(menuPtr->platformData);
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * SetMenuCascade --
+ * TkpMenuNewEntry --
  *
- *	Does any cleanup to change a menu from a normal to a cascade.
+ *	Adds a pointer to a new menu entry structure with the platform-
+ *	specific fields filled in. The Macintosh uses the platformEntryData
+ *	field of the TkMenuEntry record.
  *
  * Results:
- *	Standard Tcl error.
+ *	Standard TCL error.
  *
  * Side effects:
- *	The mac menu id is reset.
+ *	Storage gets allocated. New menu entry data is put into the
+ *	platformEntryData field of the mePtr.
  *
  *----------------------------------------------------------------------
  */
 
 int
-SetMenuCascade(
-    TkMenu *menuPtr)		/* The menu we are setting up to be a
-				 * cascade. */
-{
-    MenuHandle macMenuHdl = ((MacMenu *) menuPtr->platformData)->menuHdl;
-    MenuID newMenuID, menuID = GetMenuID(macMenuHdl);
-    int error = TCL_OK;
-
-    if (menuID >= 256) {
-	error = TkMacOSXGetNewMenuID(menuPtr->interp, menuPtr, 1, &newMenuID);
-	if (error == TCL_OK) {
-	    TkMacOSXFreeMenuID(menuID);
-	    SetMenuID(macMenuHdl,newMenuID);
-	}
-    }
-    return error;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * TkpDestroyMenuEntry --
- *
- *	Cleans up platform-specific menu entry items.
- *
- * Results:
- *	None
- *
- * Side effects:
- *	All platform-specific allocations are freed up.
- *
- *----------------------------------------------------------------------
- */
-
-void
-TkpDestroyMenuEntry(
-    TkMenuEntry *mePtr)		/* The common structure for the menu entry. */
-{
-    TkMenu *menuPtr = mePtr->menuPtr;
-
-    ckfree((char *) mePtr->platformEntryData);
-    if ((menuPtr->platformData != NULL)
-	    && !(menuPtr->menuFlags & MENU_RECONFIGURE_PENDING)) {
-	menuPtr->menuFlags |= MENU_RECONFIGURE_PENDING;
-	Tcl_DoWhenIdle(ReconfigureMacintoshMenu, menuPtr);
-    }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * GetEntryText --
- *
- *	Given a menu entry, gives back the text that should go in it.
- *	Separators should be done by the caller, as they have to be handled
- *	specially. This is primarily used to do a substitution between "..."
- *	and the ellipsis character which looks nicer.
- *
- * Results:
- *	itemText points to the new text for the item.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-void
-GetEntryText(
-    TkMenuEntry *mePtr,		/* A pointer to the menu entry. */
-    Tcl_DString *dStringPtr)	/* The DString to put the text into. This
-				 * will be initialized by this routine. */
+TkpMenuNewEntry(
+    TkMenuEntry *mePtr)		/* The menu we are adding an entry to */
 {
-#ifdef USE_TK_MDEF
-    const int useMDEF = ((MacMenu *) mePtr->menuPtr->platformData)->useMDEF;
-#endif
-    int noLabel = (mePtr->labelPtr == NULL || mePtr->labelLength == 0);
-
-    Tcl_DStringInit(dStringPtr);
-    if (mePtr->type == TEAROFF_ENTRY && (useMDEF || noLabel)) {
-	Tcl_DStringAppend(dStringPtr, "(Tear-off)", -1);
-    } else if (mePtr->imagePtr != NULL && (useMDEF || noLabel) &&
-	    mePtr->compound == COMPOUND_NONE) {
-	Tcl_DStringAppend(dStringPtr, "(Image)", -1);
-    } else if (mePtr->bitmapPtr != NULL && (useMDEF || noLabel) &&
-	    mePtr->compound == COMPOUND_NONE) {
-	Tcl_DStringAppend(dStringPtr, "(Pixmap)", -1);
-    } else if (noLabel) {
-	/*
-	 * The Mac menu manager does not like null strings.
-	 */
-
-	Tcl_DStringAppend(dStringPtr, " ", -1);
+    TKMenu *menu = (TKMenu *) mePtr->menuPtr->platformData;
+    NSMenuItem *menuItem;
+    if (mePtr->type == SEPARATOR_ENTRY || mePtr->type == TEAROFF_ENTRY) {
+	menuItem = [[NSMenuItem separatorItem] retain];
     } else {
-	int length;
-	char *text = Tcl_GetStringFromObj(mePtr->labelPtr, &length);
-	char *dStringText;
-	int i;
-
-	for (i = 0; *text; text++, i++) {
-	    if ((*text == '.') && (*(text+1) == '.') && (*(text+2) == '.')) {
-		Tcl_DStringAppend(dStringPtr, menuSymbols[ELLIPSIS_SYMBOL].utf,
-			menuSymbols[ELLIPSIS_SYMBOL].utfLen);
-		i += menuSymbols[ELLIPSIS_SYMBOL].utfLen - 1;
-		text += 2;
-	    } else {
-		Tcl_DStringSetLength(dStringPtr,
-			Tcl_DStringLength(dStringPtr) + 1);
-		dStringText = Tcl_DStringValue(dStringPtr);
-		dStringText[i] = *text;
-	    }
-	}
+	menuItem = [menu newTkMenuItem:mePtr];
     }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * FindMarkCharacter --
- *
- *	Finds the Macintosh mark character based on the font of the item. We
- *	calculate a good mark character based on the font that this item is
- *	rendered in.
- *
- * Results:
- *	Mark char.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-char
-FindMarkCharacter(
-    TkMenuEntry *mePtr)		/* The entry we are finding the character
-				 * for. */
-{
-    static const char markChars[] = {kCheckCharCode, kDiamondCharCode,
-	    kBulletCharCode, '-', kCheckCharCode};
-    const char *markChar = markChars;
-    int i = sizeof(markChars);
-    Tk_Font tkfont;
-
-    tkfont = Tk_GetFontFromObj(mePtr->menuPtr->tkwin,
-	    (mePtr->fontPtr == NULL) ? mePtr->menuPtr->fontPtr
-	    : mePtr->fontPtr);
-
-    while (--i) {
-	if (!TkMacOSXIsCharacterMissing(tkfont, *markChar)) {
-	    break;
-	}
-	markChar++;
-    }
-    return *markChar;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * GetUtfMarkCharacter --
- *
- *	Get the utf8 string for the given mark character, taking into account
- *	the special menu font char codes.
- *
- * Results:
- *	Length of returned utf8 string.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-int
-GetUtfMarkCharacter(
-    char markChar,
-    const char **markUtfPtr)
-{
-    const MenuSymbol *ms = menuSymbols;
-    int len = 0;
-
-    while (ms->unicode) {
-	if (ms->charCode && ms->charCode == markChar) {
-	    *markUtfPtr = ms->utf;
-	    len = ms->utfLen;
-	    break;
-	}
-	ms++;
-    }
-    if (!len) {
-	static char markUtf[TCL_UTF_MAX + 1];
-
-	Tcl_ExternalToUtf(NULL, TkMacOSXCarbonEncoding, &markChar, 1, 0, NULL,
-		markUtf, TCL_UTF_MAX + 1, NULL, &len, NULL);
-	*markUtfPtr = markUtf;
-    }
-    return len;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * ParseAccelerators --
- *
- *	Parse menu accelerator string.
- *
- * Results:
- *	Accelerator flags.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-int
-ParseAccelerators(
-    const char **accelStringPtr,
-    int *modifierNumPtr,
-    Tcl_UniChar *modifierUniChars,
-    int *modifierWidth)
-{
-    struct Modif {
-	const char *name;
-	const size_t len;
-	const int flag, symbol;
-    };
-#define MODIF(n, f) { #n, sizeof(#n)-1, ENTRY_##f##_ACCEL, f##_SYMBOL }
-    static const struct Modif modifs[] = {
-	MODIF(Control,	CONTROL),
-	MODIF(Ctrl,	CONTROL),
-	MODIF(Option,	OPTION),
-	MODIF(Opt,	OPTION),
-	MODIF(Alt,	OPTION),
-	MODIF(Shift,	SHIFT),
-	MODIF(Command,	COMMAND),
-	MODIF(Cmd,	COMMAND),
-	MODIF(Meta,	COMMAND),
-	{ NULL, 0, 0, 0}
-    };
-#undef MODIF
-    const char *accelString = *accelStringPtr;
-    int flags = 0, num = 0, seen = 0, width = 0;
-    const struct Modif *m;
-
-    while (1) {
-	m = modifs;
-	while (m->name) {
-	    int l = m->len;
-
-	    if (!strncasecmp(accelString, m->name, l) &&
-		    (accelString[l] == '-' || accelString[l] == '+')) {
-		flags |= m->flag;
-		accelString += l+1;
-		break;
-	    }
-	    m++;
-	}
-	if (!m->name || !*accelString) {
-	    break;
-	}
-    }
-    m = modifs;
-    while (m->name && num < MODIFIER_NUM) {
-	if (flags & m->flag && !(seen & m->flag)) {
-	    modifierUniChars[num++] = menuSymbols[m->symbol].unicode;
-	    width += menuSymbols[m->symbol].width;
-	    seen |= m->flag;
-	}
-	m++;
-    }
-    *accelStringPtr = accelString;
-    *modifierNumPtr = num;
-    *modifierWidth = width;
-    return flags;
+    mePtr->platformEntryData = (TkMenuPlatformEntryData)
+	    TkMacOSXMakeUncollectable(menuItem);
+    /* Caller TkMenuEntry() already did this same insertion into the generic
+     * TkMenu so we just match it for the platform menu. */
+    [menu insertItem:menuItem atTkIndex:mePtr->index];
+    return TCL_OK;
 }
 
 /*
@@ -1114,408 +501,123 @@ TkpConfigureMenuEntry(
     TkMenuEntry *mePtr) 	/* Information about menu entry; may or may
 				 * not already have values for some fields. */
 {
-    TkMenu *menuPtr = mePtr->menuPtr;
-    EntryGeometry *geometryPtr = (EntryGeometry *) mePtr->platformEntryData;
-
-    /*
-     * Cascade menus have to have menu IDs of less than 256. So we need to
-     * change the child menu if this has been configured for a cascade item.
-     */
-
-    if (mePtr->type == CASCADE_ENTRY) {
-	if ((mePtr->childMenuRefPtr != NULL)
-		&& (mePtr->childMenuRefPtr->menuPtr != NULL)) {
-	    MenuHandle childMenuHdl = ((MacMenu *) mePtr
-		    ->childMenuRefPtr->menuPtr->platformData)->menuHdl;
-
-	    if (childMenuHdl != NULL) {
-		int error = SetMenuCascade(mePtr->childMenuRefPtr->menuPtr);
-
-		if (error != TCL_OK) {
-		    return error;
-		}
-
-		if (menuPtr->menuType == MENUBAR) {
-		    CFStringRef cfStr = CFStringCreateWithCString(NULL,
-			    (!(mePtr->labelPtr) ? "" :
-			    Tcl_GetString(mePtr->labelPtr)),
-			    kCFStringEncodingUTF8);
-
-		    if (cfStr) {
-			SetMenuTitleWithCFString(childMenuHdl, cfStr);
-			CFRelease(cfStr);
-		    }
-		}
-	    }
-	}
-    }
-
-    /*
-     * We need to parse the accelerator string. If it has the strings for
-     * Command, Control, Shift or Option, we need to flag it so we can draw
-     * the symbols for it. We also need to precalcuate the position of the
-     * first real character we are drawing.
-     */
-
-    if (0 == mePtr->accelLength) {
-	geometryPtr->accelTextStart = -1;
-    } else {
-	const char *accelString = (mePtr->accelPtr == NULL) ? ""
-		: Tcl_GetString(mePtr->accelPtr);
-	const char *accelStart = accelString;
-
-	mePtr->entryFlags &= ~ENTRY_ACCEL_MASK;
-	mePtr->entryFlags |= ParseAccelerators(&accelString,
-		&geometryPtr->modifierNum, geometryPtr->modifierUniChars,
-		&geometryPtr->modifierWidth);
-	geometryPtr->accelTextStart = (ptrdiff_t)(accelString - accelStart);
-    }
-
-    if (!(menuPtr->menuFlags & MENU_RECONFIGURE_PENDING)) {
-	menuPtr->menuFlags |= MENU_RECONFIGURE_PENDING;
-	Tcl_DoWhenIdle(ReconfigureMacintoshMenu, menuPtr);
-    }
-
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * ReconfigureIndividualMenu --
- *
- *	This routine redoes the guts of the menu. It works from a base item
- *	and offset, so that a regular menu will just have all of its items
- *	added, but the help menu will have all of its items appended after the
- *	apple-defined items.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	The Macintosh menu handle is updated
- *
- *----------------------------------------------------------------------
- */
-
-void
-ReconfigureIndividualMenu(
-    TkMenu *menuPtr,		/* The menu we are affecting. */
-    MenuHandle macMenuHdl,	/* The macintosh menu we are affecting. Will
-				 * not necessarily be menuPtr->platformData
-				 * because this could be the help menu. */
-    int base)			/* The last index that we do not want touched.
-				 * 0 for normal menus; # of system help menu
-				 * items for help menus. */
-{
-    int count;
-    int index;
-    TkMenuEntry *mePtr;
-    int parentDisabled = 0;
-
-#ifdef TK_MAC_DEBUG_MENUS
-    /*
-     * Carbon-internal menu debugging (c.f. Technote 2124)
-     */
-
-    TkMacOSXInitNamedDebugSymbol(HIToolbox, void, DebugPrintMenu,
-	    MenuRef menu);
-    if (DebugPrintMenu) {
-	DebugPrintMenu(macMenuHdl);
-    }
-#endif
-
-    mePtr = GetParentMenuEntry(menuPtr);
-    if (mePtr && mePtr->state == ENTRY_DISABLED) {
-	parentDisabled = 1;
-    }
-
-    /*
-     * First, we get rid of all of the old items.
-     */
-
-    count = CountMenuItems(macMenuHdl);
-    for (index = base; index < count; index++) {
-	DeleteMenuItem(macMenuHdl, base + 1);
-    }
-
-    count = menuPtr->numEntries;
-
-    for (index = 1; index <= count; index++) {
-	mePtr = menuPtr->entries[index - 1];
-
-	/*
-	 * We have to do separators separately because SetMenuItemText does
-	 * not parse meta-characters.
-	 */
-
-	if (mePtr->type == SEPARATOR_ENTRY) {
-	    AppendMenuItemTextWithCFString(macMenuHdl, NULL,
-		    kMenuItemAttrSeparator | kMenuItemAttrDisabled, 0, NULL);
-	} else {
-	    Tcl_DString itemTextDString;
-	    CFStringRef cfStr;
-
-	    GetEntryText(mePtr, &itemTextDString);
-	    cfStr = CFStringCreateWithCString(NULL,
-		    Tcl_DStringValue(&itemTextDString), kCFStringEncodingUTF8);
-	    if (cfStr) {
-		AppendMenuItemTextWithCFString(macMenuHdl, cfStr, 0, 0, NULL);
-		CFRelease(cfStr);
-	    } else {
-		AppendMenuItemTextWithCFString(macMenuHdl, CFSTR ("<Error>"),
-			0, 0, NULL);
-	    }
-	    Tcl_DStringFree(&itemTextDString);
-
-	    /*
-	     * Set enabling and disabling correctly.
-	     */
-
-	    if (parentDisabled || (mePtr->state == ENTRY_DISABLED)) {
-		DisableMenuItem(macMenuHdl, base + index);
+    NSMenuItem *menuItem = (NSMenuItem *) mePtr->platformEntryData;
+    NSString *title = @"";
+    NSAttributedString *attributedTitle = nil;
+    NSImage *image = nil;
+    NSString *keyEquivalent = @"";
+    NSUInteger modifierMask = NSCommandKeyMask;
+    NSMenu *submenu = nil;
+    NSDictionary *attributes;
+    int imageWidth, imageHeight;
+    GC gc = (mePtr->textGC ? mePtr->textGC : mePtr->menuPtr->textGC);
+    Tcl_Obj *fontPtr = (mePtr->fontPtr ? mePtr->fontPtr :
+	    mePtr->menuPtr->fontPtr);
+
+    if (mePtr->image) {
+    	Tk_SizeOfImage(mePtr->image, &imageWidth, &imageHeight);
+	image = TkMacOSXGetNSImageWithTkImage(mePtr->menuPtr->display,
+		mePtr->image, imageWidth, imageHeight);
+    } else if (mePtr->bitmapPtr != None) {
+	Pixmap bitmap = Tk_GetBitmapFromObj(mePtr->menuPtr->tkwin,
+		mePtr->bitmapPtr);
+	Tk_SizeOfBitmap(mePtr->menuPtr->display, bitmap, &imageWidth,
+		&imageHeight);
+	image = TkMacOSXGetNSImageWithBitmap(mePtr->menuPtr->display, bitmap,
+		gc, imageWidth, imageHeight);
+    }
+    [menuItem setImage:image];
+    if ((!image || mePtr->compound != COMPOUND_NONE) && mePtr->labelPtr &&
+	    mePtr->labelLength) {
+	title = [[[NSString alloc] initWithBytes:Tcl_GetString(mePtr->labelPtr)
+		length:mePtr->labelLength encoding:NSUTF8StringEncoding]
+		autorelease];
+	if ([title hasSuffix:@"..."]) {
+	    title = [NSString stringWithFormat:@"%@%C",
+		    [title substringToIndex:[title length] - 3], 0x2026];
+	}
+    }
+    [menuItem setTitle:title];
+    if (strcmp(Tcl_GetString(fontPtr), "menu") || gc->foreground != defaultFg
+	    || gc->background != defaultBg) {
+	attributes = TkMacOSXNSFontAttributesForFont(Tk_GetFontFromObj(
+		mePtr->menuPtr->tkwin, fontPtr));
+	if (gc->foreground != defaultFg || gc->background != defaultBg) {
+	    NSColor *color = TkMacOSXGetNSColor(gc, gc->foreground != defaultFg ?
+		    gc->foreground : gc->background);
+	    attributes = [[attributes mutableCopy] autorelease];
+	    [(NSMutableDictionary *)attributes setObject:color
+		    forKey:NSForegroundColorAttributeName];
+	}
+	if (attributes) {
+	    attributedTitle = [[[NSAttributedString alloc]
+		    initWithString:title attributes:attributes] autorelease];
+	}
+    }
+    [menuItem setAttributedTitle:attributedTitle];
+    [menuItem setEnabled:!(mePtr->state == ENTRY_DISABLED)];
+    [menuItem setState:((mePtr->type == CHECK_BUTTON_ENTRY ||
+	    mePtr->type == RADIO_BUTTON_ENTRY) && mePtr->indicatorOn &&
+	    (mePtr->entryFlags & ENTRY_SELECTED) ? NSOnState : NSOffState)];
+    if (mePtr->type != CASCADE_ENTRY && mePtr->accelPtr && mePtr->accelLength) {
+	keyEquivalent = ParseAccelerator(Tcl_GetString(mePtr->accelPtr),
+		&modifierMask);
+    }
+    [menuItem setKeyEquivalent:keyEquivalent];
+    [menuItem setKeyEquivalentModifierMask:modifierMask];
+    if (mePtr->type == CASCADE_ENTRY && mePtr->namePtr) {
+	TkMenuReferences *menuRefPtr;
+
+	menuRefPtr = TkFindMenuReferencesObj(mePtr->menuPtr->interp,
+		mePtr->namePtr);
+	if (menuRefPtr && menuRefPtr->menuPtr) {
+	    CheckForSpecialMenu(menuRefPtr->menuPtr);
+	    submenu = (TKMenu *) menuRefPtr->menuPtr->platformData;
+	    if ([submenu supermenu] && [menuItem submenu] != submenu) {
+		/*
+		* This happens during a clone, where the parent menu is cloned
+		* before its children, so just ignore this temprary setting,
+		* it will be changed shortly (c.f. tkMenu.c CloneMenu())
+		*/
+		submenu = nil;
 	    } else {
-		EnableMenuItem(macMenuHdl, base + index);
-	    }
-
-	    /*
-	     * Set the check mark for check entries and radio entries.
-	     */
-
-	    SetItemMark(macMenuHdl, base + index, 0);
-	    if ((mePtr->type == CHECK_BUTTON_ENTRY)
-		    || (mePtr->type == RADIO_BUTTON_ENTRY)) {
-		CheckMenuItem(macMenuHdl, base + index, (mePtr->entryFlags
-			& ENTRY_SELECTED) && mePtr->indicatorOn);
-		if (mePtr->indicatorOn
-			&& (mePtr->entryFlags & ENTRY_SELECTED)) {
-		    SetItemMark(macMenuHdl, base + index,
-			    FindMarkCharacter(mePtr));
-		}
-	    }
-
-	    if (mePtr->type == CASCADE_ENTRY) {
-		if ((mePtr->childMenuRefPtr != NULL)
-			&& (mePtr->childMenuRefPtr->menuPtr != NULL)) {
-		    MenuHandle childMenuHdl =
-			    ((MacMenu *) mePtr->childMenuRefPtr
-			    ->menuPtr->platformData)->menuHdl;
-
-		    if (childMenuHdl != NULL) {
-			ChkErr(SetMenuItemHierarchicalID, macMenuHdl,
-				base + index, GetMenuID(childMenuHdl));
-		    }
-
-		    /*
-		     * If we changed the highligthing of this menu, its
-		     * children all have to be reconfigured so that their
-		     * state will be reflected in the menubar.
-		     */
-
-		    if (!(mePtr->childMenuRefPtr->menuPtr->menuFlags
-			    & MENU_RECONFIGURE_PENDING)) {
-			mePtr->childMenuRefPtr->menuPtr->menuFlags
-				|= MENU_RECONFIGURE_PENDING;
-			Tcl_DoWhenIdle(ReconfigureMacintoshMenu,
-				mePtr->childMenuRefPtr->menuPtr);
-		    }
-		}
-	    }
-
-	    if ((mePtr->type != CASCADE_ENTRY) && (mePtr->accelPtr != NULL)) {
-		int accelLen, modifiers = 0, hasCmd = 0;
-		EntryGeometry *geometryPtr = (EntryGeometry *)
-			mePtr->platformEntryData;
-		int offset = geometryPtr->accelTextStart;
-		char *accel = Tcl_GetStringFromObj(mePtr->accelPtr, &accelLen);
-
-		accelLen -= offset;
-		accel += offset;
-		if (mePtr->entryFlags & ENTRY_OPTION_ACCEL) {
-		    modifiers |= kMenuOptionModifier;
-		}
-		if (mePtr->entryFlags & ENTRY_SHIFT_ACCEL) {
-		    modifiers |= kMenuShiftModifier;
-		}
-		if (mePtr->entryFlags & ENTRY_CONTROL_ACCEL) {
-		    modifiers |= kMenuControlModifier;
-		}
-		if (mePtr->entryFlags & ENTRY_COMMAND_ACCEL) {
-		    hasCmd = 1;
-		}
-		if (accelLen == 1) {
-		    if (hasCmd || (modifiers != 0 && modifiers !=
-			    kMenuShiftModifier)) {
-			SetItemCmd(macMenuHdl, base + index, accel[0]);
-			if (!hasCmd) {
-			    modifiers |= kMenuNoCommandModifier;
-			}
-		    }
-		} else {
-		    /*
-		     * Convert from accelerator names to Carbon menu glyphs.
-		     */
-
-		    struct Glyph {
-			const char *name;
-			const size_t len;
-			const char glyph;
-		    };
-#define GLYPH(n, g) { #n, sizeof(#n)-1, kMenu##g##Glyph }
-		    static const struct Glyph glyphs[] = {
-			GLYPH(PageUp,	PageUp),
-			GLYPH(PageDown, PageDown),
-			GLYPH(Left,	LeftArrow),
-			GLYPH(Right,	RightArrow),
-			GLYPH(Up,	UpArrow),
-			GLYPH(Down,	DownArrow),
-			GLYPH(Escape,	Escape),
-			GLYPH(Clear,	Clear),
-			GLYPH(Enter,	Enter),
-			GLYPH(Backspace,DeleteLeft),
-			GLYPH(Space,	Space),
-			GLYPH(Tab,	TabRight),
-			GLYPH(Delete,	DeleteRight),
-			GLYPH(Home,	NorthwestArrow),
-			GLYPH(End,	SoutheastArrow),
-			GLYPH(Return,	Return),
-			GLYPH(Help,	Help),
-			GLYPH(Power,	Power),
-			{ NULL, 0, 0}
-		    };
-#undef GLYPH
-		    const struct Glyph *g = glyphs;
-		    char glyph = 0;
-
-		    if (accel[0] == 'F' && accelLen < 4 &&
-			    (accel[1] > '0' && accel[1] <= '9')) {
-			int fkey = accel[1] - '0';
-
-			if (accelLen == 3) {
-			    if (accel[2] >= '0' && accel[2] <= '9') {
-				fkey = 10 * fkey + (accel[2] - '0');
-			    } else {
-				fkey = 0;
-			    }
-			}
-			if (fkey >= 1 && fkey <= 12) {
-			    glyph = kMenuF1Glyph + fkey - 1;
-			} else if (fkey >= 13 && fkey <= 15) {
-			    glyph = kMenuF13Glyph + fkey - 13;
-			}
-		    } else while (g->name) {
-			if (accel[0] == g->name[0] &&
-				(size_t)accelLen == g->len &&
-				!strncasecmp(accel, g->name, g->len)) {
-			    glyph = g->glyph;
-			    break;
-			}
-			g++;
-		    }
-		    if (glyph) {
-			ChkErr(SetMenuItemKeyGlyph, macMenuHdl, base + index,
-				glyph);
-			if (!hasCmd) {
-			    modifiers |= kMenuNoCommandModifier;
-			}
-			geometryPtr->accelGlyph = glyph;
-		    }
-		}
-		ChkErr(SetMenuItemModifiers, macMenuHdl, base + index,
-			modifiers);
+		[submenu setTitle:title];
 	    }
 	}
     }
+    [menuItem setSubmenu:submenu];
+    return TCL_OK;
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * ReconfigureMacintoshMenu --
- *
- *	Rebuilds the Macintosh MenuHandle items from the menu. Called usually
- *	as an idle handler, but can be called synchronously if the menu is
- *	about to be posted.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Configuration information get set for mePtr; old resources get freed,
- *	if any need it.
- *
- *----------------------------------------------------------------------
- */
-
-void
-ReconfigureMacintoshMenu(
-    ClientData clientData)	/* Information about menu entry; may or may
-				 * not already have values for some fields. */
-{
-    TkMenu *menuPtr = clientData;
-    MenuHandle macMenuHdl = ((MacMenu *) menuPtr->platformData)->menuHdl;
-    MenuHandle helpMenuHdl = NULL;
-
-    menuPtr->menuFlags &= ~MENU_RECONFIGURE_PENDING;
-
-    if (NULL == macMenuHdl) {
-	return;
-    }
-
-    ReconfigureIndividualMenu(menuPtr, macMenuHdl, 0);
-
-    if (GetMenuID(macMenuHdl) == currentHelpMenuID) {
-	MenuItemIndex helpIndex;
-
-	HMGetHelpMenu(&helpMenuHdl,&helpIndex);
-	if (helpMenuHdl != NULL) {
-	    ReconfigureIndividualMenu(menuPtr, helpMenuHdl, helpIndex - 1);
-	}
-    }
-
-    if (menuPtr->menuType == MENUBAR) {
-	if (!(menuBarFlags & MENUBAR_REDRAW_PENDING)) {
-	    Tcl_DoWhenIdle(DrawMenuBarWhenIdle, NULL);
-	    menuBarFlags |= MENUBAR_REDRAW_PENDING;
-	}
-    }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * CompleteIdlers --
+ * TkpDestroyMenuEntry --
  *
- *	Completes all idle handling so that the menus are in sync when the
- *	user invokes them with the mouse.
+ *	Cleans up platform-specific menu entry items.
  *
  * Results:
- *	None.
+ *	None
  *
  * Side effects:
- *	The Macintosh menu handles are flushed out.
+ *	All platform-specific allocations are freed up.
  *
  *----------------------------------------------------------------------
  */
 
 void
-CompleteIdlers(
-    TkMenu *menuPtr)		/* The menu we are completing. */
+TkpDestroyMenuEntry(
+    TkMenuEntry *mePtr)
 {
-    int i;
-
-    if (menuPtr->menuFlags & MENU_RECONFIGURE_PENDING) {
-	Tcl_CancelIdleCall(ReconfigureMacintoshMenu, menuPtr);
-	ReconfigureMacintoshMenu(menuPtr);
-    }
-
-    for (i = 0; i < menuPtr->numEntries; i++) {
-	if ((menuPtr->entries[i]->type == CASCADE_ENTRY) &&
-		(menuPtr->entries[i]->childMenuRefPtr != NULL) &&
-		(menuPtr->entries[i]->childMenuRefPtr->menuPtr != NULL)) {
-	    CompleteIdlers(menuPtr->entries[i]->childMenuRefPtr->menuPtr);
+    if (mePtr->platformEntryData && mePtr->menuPtr->platformData) {
+	TKMenu *menu = (TKMenu *) mePtr->menuPtr->platformData;
+	NSMenuItem *menuItem = (NSMenuItem *)mePtr->platformEntryData;
+	NSInteger index = [menu indexOfItem:menuItem];
+	if (index > -1) {
+	    [menu removeItemAtIndex:index];
 	}
     }
+    TkMacOSXMakeCollectableAndRelease(mePtr->platformEntryData);
 }
 
 /*
@@ -1543,476 +645,55 @@ TkpPostMenu(
 				 * to be posted. */
     int y)			/* The global y-coordinate */
 {
-    MenuHandle macMenuHdl = ((MacMenu *) menuPtr->platformData)->menuHdl;
-    long popUpResult;
-    int result;
-
-    if (inPostMenu > 0) {
-	Tcl_AppendResult(interp,
-		"Cannot call post menu while already posting menu", NULL);
-	result = TCL_ERROR;
+    NSWindow *win = [NSApp keyWindow];
+    if (win) {
+	inPostMenu = 1;
+	int oldMode = Tcl_SetServiceMode(TCL_SERVICE_NONE);
+	NSView *view = [win contentView];
+	NSRect frame = NSMakeRect(x + 9, tkMacOSXZeroScreenHeight - y - 9, 1, 1);
+	frame.origin = [view convertPoint:
+		[win convertScreenToBase:frame.origin] fromView:nil];
+	NSMenu *menu = (NSMenu *) menuPtr->platformData;
+	NSPopUpButtonCell *popUpButtonCell = [[NSPopUpButtonCell alloc]
+		initTextCell:@"" pullsDown:NO];
+	[popUpButtonCell setMenu:menu];
+	[popUpButtonCell selectItem:nil];
+	[popUpButtonCell performClickWithFrame:frame inView:view];
+	[popUpButtonCell release];
+	Tcl_SetServiceMode(oldMode);
+	inPostMenu = 0;
+	return TCL_OK;
     } else {
-	short menuID;
-	Window window;
-	int oldWidth = menuPtr->totalWidth;
-
-	inPostMenu++;
-	result = TkPreprocessMenu(menuPtr);
-
-	/*
-	 * The post commands could have deleted the menu, which means we are
-	 * dead and should go away.
-	 */
-
-	if (result != TCL_OK || !menuPtr->tkwin) {
-	    goto endPostMenu;
-	}
-
-	CompleteIdlers(menuPtr);
-	if (menuBarFlags & MENUBAR_REDRAW_PENDING) {
-	    Tcl_CancelIdleCall(DrawMenuBarWhenIdle, NULL);
-	    DrawMenuBarWhenIdle(NULL);
-	}
-	RecursivelyInsertMenu(menuPtr);
-
-	TkMacOSXTrackingLoop(1);
-	popUpResult = PopUpMenuSelect(macMenuHdl, y, x, menuPtr->active);
-	TkMacOSXTrackingLoop(0);
-	menuPtr->totalWidth = oldWidth;
-
-	/*
-	 * Simulate the mouse up.
-	 */
-
-	window = Tk_WindowId(menuPtr->tkwin);
-	TkGenerateButtonEventForXPointer(window);
-
-	/*
-	 * Dispatch the command.
-	 */
-
-	menuID = HiWord(popUpResult);
-	if (menuID != 0) {
-	    result = TkMacOSXDispatchMenuEvent(menuID, LoWord(popUpResult));
-	}
-
-endPostMenu:
-	inPostMenu--;
-    }
-    return result;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * TkpMenuNewEntry --
- *
- *	Adds a pointer to a new menu entry structure with the platform-
- *	specific fields filled in. The Macintosh uses the platformEntryData
- *	field of the TkMenuEntry record to store geometry information.
- *
- * Results:
- *	Standard TCL error.
- *
- * Side effects:
- *	Storage gets allocated. New menu entry data is put into the
- *	platformEntryData field of the mePtr.
- *
- *----------------------------------------------------------------------
- */
-
-int
-TkpMenuNewEntry(
-    TkMenuEntry *mePtr)		/* The menu we are adding an entry to */
-{
-    EntryGeometry *geometryPtr = (EntryGeometry *)
-	    ckalloc(sizeof(EntryGeometry));
-    TkMenu *menuPtr = mePtr->menuPtr;
-
-    geometryPtr->accelTextStart = 0;
-    geometryPtr->accelTextWidth = 0;
-    geometryPtr->nonAccelMargin = 0;
-    geometryPtr->modifierWidth = 0;
-    geometryPtr->modifierNum = 0;
-    geometryPtr->accelGlyph = 0;
-    mePtr->platformEntryData = (TkMenuPlatformEntryData) geometryPtr;
-    if (!(menuPtr->menuFlags & MENU_RECONFIGURE_PENDING)) {
-	menuPtr->menuFlags |= MENU_RECONFIGURE_PENDING;
-	Tcl_DoWhenIdle(ReconfigureMacintoshMenu, menuPtr);
-    }
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * Tk_MacOSXTurnOffMenus --
- *
- *	Turns off all the menu drawing code. This is more than just disabling
- *	the "menu" command, this means that Tk will NEVER touch the menubar.
- *	It is needed in the Plugin, where Tk does not own the menubar.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	A flag is set which will disable all menu drawing.
- *
- *----------------------------------------------------------------------
- */
-
-void
-Tk_MacOSXTurnOffMenus(void)
-{
-    gNoTkMenus = 1;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * DrawMenuBarWhenIdle --
- *
- *	Update the menu bar next time there is an idle event.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Menu bar is redrawn.
- *
- *----------------------------------------------------------------------
- */
-
-void
-DrawMenuBarWhenIdle(
-    ClientData clientData)	/* ignored here */
-{
-    TkMenuReferences *menuRefPtr;
-    TkMenu *appleMenuPtr, *helpMenuPtr, *menuBarPtr = NULL;
-    MenuHandle macMenuHdl;
-    Tcl_HashEntry *hashEntryPtr;
-
-    /*
-     * If we have been turned off, exit.
-     */
-
-    if (gNoTkMenus) {
-	return;
-    }
-
-    /*
-     * We need to clear the apple and help menus of any extra items.
-     */
-
-    if (currentAppleMenuID != 0) {
-	hashEntryPtr = Tcl_FindHashEntry(&commandTable,
-		(char*)(intptr_t)currentAppleMenuID);
-	appleMenuPtr = Tcl_GetHashValue(hashEntryPtr);
-	TkpDestroyMenu(appleMenuPtr);
-	TkpNewMenu(appleMenuPtr);
-	appleMenuPtr->menuFlags &= ~MENU_APPLE_MENU;
-	appleMenuPtr->menuFlags |= MENU_RECONFIGURE_PENDING;
-	Tcl_DoWhenIdle(ReconfigureMacintoshMenu, appleMenuPtr);
-    }
-
-    if (currentHelpMenuID != 0) {
-	hashEntryPtr = Tcl_FindHashEntry(&commandTable,
-		(char*)(intptr_t)currentHelpMenuID);
-	helpMenuPtr = Tcl_GetHashValue(hashEntryPtr);
-	TkpDestroyMenu(helpMenuPtr);
-	TkpNewMenu(helpMenuPtr);
-	helpMenuPtr->menuFlags &= ~MENU_HELP_MENU;
-	helpMenuPtr->menuFlags |= MENU_RECONFIGURE_PENDING;
-	Tcl_DoWhenIdle(ReconfigureMacintoshMenu, helpMenuPtr);
-    }
-
-    /*
-     * We need to find the clone of this menu that is the menubar. Once we do
-     * that, for every cascade in the menu, we need to insert the Mac menu in
-     * the Mac menubar. Finally, we need to redraw the menubar.
-     */
-
-    menuRefPtr = NULL;
-    if (currentMenuBarName != NULL) {
-	menuRefPtr = TkFindMenuReferences(currentMenuBarInterp,
-		currentMenuBarName);
-    }
-    if (menuRefPtr) {
-	TkMenu *menuPtr;
-	TkMenu *cascadeMenuPtr;
-	char *appleMenuName, *helpMenuName;
-	int appleIndex = -1, helpIndex = -1, i;
-
-	menuPtr = menuRefPtr->menuPtr;
-	if (menuPtr != NULL) {
-	    TkMenuReferences *specialMenuRefPtr;
-	    TkMenuEntry *specialEntryPtr;
-
-	    appleMenuName = ckalloc(strlen(currentMenuBarName) + 1 +
-		    strlen(".apple") + 1);
-	    sprintf(appleMenuName, "%s.apple", Tk_PathName(menuPtr->tkwin));
-	    specialMenuRefPtr = TkFindMenuReferences(currentMenuBarInterp,
-		    appleMenuName);
-	    if ((specialMenuRefPtr != NULL)
-		    && (specialMenuRefPtr->menuPtr != NULL)) {
-		for (specialEntryPtr = specialMenuRefPtr->parentEntryPtr;
-			specialEntryPtr != NULL;
-			specialEntryPtr = specialEntryPtr->nextCascadePtr) {
-		    if (specialEntryPtr->menuPtr == menuPtr) {
-			appleIndex = specialEntryPtr->index;
-			break;
-		    }
-		}
-	    }
-	    ckfree(appleMenuName);
-
-	    helpMenuName = ckalloc(strlen(currentMenuBarName) + 1 +
-		    strlen(".help") + 1);
-	    sprintf(helpMenuName, "%s.help", Tk_PathName(menuPtr->tkwin));
-	    specialMenuRefPtr = TkFindMenuReferences(currentMenuBarInterp,
-		    helpMenuName);
-	    if ((specialMenuRefPtr != NULL)
-		    && (specialMenuRefPtr->menuPtr != NULL)) {
-		for (specialEntryPtr = specialMenuRefPtr->parentEntryPtr;
-			specialEntryPtr != NULL;
-			specialEntryPtr = specialEntryPtr->nextCascadePtr) {
-		    if (specialEntryPtr->menuPtr == menuPtr) {
-			helpIndex = specialEntryPtr->index;
-			break;
-		    }
-		}
-	    }
-	    ckfree(helpMenuName);
-	}
-
-	for (menuBarPtr = menuPtr;
-		(menuBarPtr != NULL) && (menuBarPtr->menuType != MENUBAR);
-		menuBarPtr = menuBarPtr->nextInstancePtr) {
-	    /*
-	     * Null loop body.
-	     */
-	}
-
-	if (menuBarPtr) {
-	    if (menuBarPtr->tearoff != menuPtr->tearoff) {
-		if (menuBarPtr->tearoff) {
-		    appleIndex = (-1 == appleIndex) ? appleIndex
-			    : appleIndex + 1;
-		    helpIndex = (-1 == helpIndex) ? helpIndex
-			    : helpIndex + 1;
-		} else {
-		    appleIndex = (-1 == appleIndex) ? appleIndex
-			    : appleIndex - 1;
-		    helpIndex = (-1 == helpIndex) ? helpIndex
-			    : helpIndex - 1;
-		}
-	    }
-	    ClearMenuBar();
-
-	    if (appleIndex == -1) {
-		InsertMenu(tkAppleMenu, 0);
-		currentAppleMenuID = 0;
-		tkCurrentAppleMenu = tkAppleMenu;
-	    } else {
-		short appleID;
-
-		appleMenuPtr = menuBarPtr->entries[appleIndex]
-			->childMenuRefPtr->menuPtr;
-		TkpDestroyMenu(appleMenuPtr);
-		TkMacOSXGetNewMenuID(appleMenuPtr->interp, appleMenuPtr, 0,
-			&appleID);
-		macMenuHdl = NewMenu(appleID, "\p\024");
-		appleMenuPtr->platformData = (TkMenuPlatformData)
-			ckalloc(sizeof(MacMenu));
-		((MacMenu *)appleMenuPtr->platformData)->menuHdl
-			= macMenuHdl;
-		appleMenuPtr->menuFlags |= MENU_APPLE_MENU;
-		if (!(appleMenuPtr->menuFlags
-			& MENU_RECONFIGURE_PENDING)) {
-		    appleMenuPtr->menuFlags |= MENU_RECONFIGURE_PENDING;
-		    Tcl_DoWhenIdle(ReconfigureMacintoshMenu, appleMenuPtr);
-		}
-		InsertMenu(macMenuHdl, 0);
-		RecursivelyInsertMenu(appleMenuPtr);
-		currentAppleMenuID = appleID;
-		tkCurrentAppleMenu = macMenuHdl;
-	    }
-	    if (helpIndex == -1) {
-		currentHelpMenuID = 0;
-	    }
-
-	    for (i = 0; i < menuBarPtr->numEntries; i++) {
-		if (i == appleIndex) {
-		    if (menuBarPtr->entries[i]->state == ENTRY_DISABLED) {
-			DisableMenuItem(((MacMenu *) menuBarPtr->entries[i]
-				->childMenuRefPtr->menuPtr
-				->platformData)->menuHdl, 0);
-		    } else {
-			EnableMenuItem(((MacMenu *) menuBarPtr->entries[i]
-				->childMenuRefPtr->menuPtr
-				->platformData)->menuHdl, 0);
-		    }
-		    continue;
-		} else if (i == helpIndex) {
-		    TkMenu *helpMenuPtr = menuBarPtr->entries[i]
-			    ->childMenuRefPtr->menuPtr;
-
-		    if (helpMenuPtr == NULL) {
-			continue;
-		    }
-		    helpMenuPtr->menuFlags |= MENU_HELP_MENU;
-		    if (!(helpMenuPtr->menuFlags
-			    & MENU_RECONFIGURE_PENDING)) {
-			helpMenuPtr->menuFlags
-				|= MENU_RECONFIGURE_PENDING;
-			Tcl_DoWhenIdle(ReconfigureMacintoshMenu, helpMenuPtr);
-		    }
-		    macMenuHdl =
-			    ((MacMenu *) helpMenuPtr->platformData)->menuHdl;
-		    currentHelpMenuID = GetMenuID(macMenuHdl);
-		} else if (menuBarPtr->entries[i]->type
-			== CASCADE_ENTRY) {
-		    if ((menuBarPtr->entries[i]->childMenuRefPtr != NULL)
-			    && menuBarPtr->entries[i]->childMenuRefPtr
-			    ->menuPtr != NULL) {
-			cascadeMenuPtr = menuBarPtr->entries[i]
-				->childMenuRefPtr->menuPtr;
-			macMenuHdl = ((MacMenu *) cascadeMenuPtr
-				->platformData)->menuHdl;
-			DeleteMenu(GetMenuID(macMenuHdl));
-			InsertMenu(macMenuHdl, 0);
-			RecursivelyInsertMenu(cascadeMenuPtr);
-			if (menuBarPtr->entries[i]->state == ENTRY_DISABLED) {
-			    DisableMenuItem(((MacMenu *) menuBarPtr->entries[i]
-				    ->childMenuRefPtr->menuPtr
-				    ->platformData)->menuHdl, 0);
-			} else {
-			    EnableMenuItem(((MacMenu *) menuBarPtr->entries[i]
-				    ->childMenuRefPtr->menuPtr
-				    ->platformData)->menuHdl, 0);
-			 }
-		    }
-		}
-	    }
-	}
-    }
-    if (!menuRefPtr || !menuBarPtr) {
-	SetDefaultMenubar();
-    }
-    DrawMenuBar();
-    menuBarFlags &= ~MENUBAR_REDRAW_PENDING;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * RecursivelyInsertMenu --
- *
- *	Puts all of the cascades of this menu in the Mac hierarchical list.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	The menubar is changed.
- *
- *----------------------------------------------------------------------
- */
-
-void
-RecursivelyInsertMenu(
-    TkMenu *menuPtr)		/* All of the cascade items in this menu will
-				 * be inserted into the mac menubar. */
-{
-    int i;
-    TkMenu *cascadeMenuPtr;
-    MenuHandle macMenuHdl;
-
-    for (i = 0; i < menuPtr->numEntries; i++) {
-	if (menuPtr->entries[i]->type == CASCADE_ENTRY) {
-	    if ((menuPtr->entries[i]->childMenuRefPtr != NULL) &&
-		    (menuPtr->entries[i]->childMenuRefPtr->menuPtr != NULL)) {
-		cascadeMenuPtr = menuPtr->entries[i]->childMenuRefPtr->menuPtr;
-		macMenuHdl =
-			((MacMenu *) cascadeMenuPtr->platformData)->menuHdl;
-		InsertMenu(macMenuHdl, -1);
-		RecursivelyInsertMenu(cascadeMenuPtr);
-	    }
-	}
+	return TCL_ERROR;
     }
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * RecursivelyDeleteMenu --
+ * TkpSetWindowMenuBar --
  *
- *	Takes all of the cascades of this menu out of the Mac hierarchical
- *	list.
+ *	Associates a given menu with a window.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	The menubar is changed.
+ *	On Windows and UNIX, associates the platform menu with the platform
+ *	window.
  *
  *----------------------------------------------------------------------
  */
 
 void
-RecursivelyDeleteMenu(
-    TkMenu *menuPtr)		/* All of the cascade items in this menu will
-				 * be deleted from the mac menubar. */
+TkpSetWindowMenuBar(
+    Tk_Window tkwin,		/* The window we are setting the menu in */
+    TkMenu *menuPtr)		/* The menu we are setting */
 {
-    int i;
-    TkMenu *cascadeMenuPtr;
-    MenuHandle macMenuHdl;
-
-    for (i = 0; i < menuPtr->numEntries; i++) {
-	if (menuPtr->entries[i]->type == CASCADE_ENTRY) {
-	    if ((menuPtr->entries[i]->childMenuRefPtr != NULL) &&
-		    (menuPtr->entries[i]->childMenuRefPtr->menuPtr != NULL)) {
-		cascadeMenuPtr = menuPtr->entries[i]->childMenuRefPtr->menuPtr;
-		macMenuHdl =
-			((MacMenu *) cascadeMenuPtr->platformData)->menuHdl;
-		DeleteMenu(GetMenuID(macMenuHdl));
-		RecursivelyDeleteMenu(cascadeMenuPtr);
-	    }
-	}
-    }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * SetDefaultMenubar --
- *
- *	Puts the Apple, File and Edit menus into the Macintosh menubar.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	The menubar is changed.
- *
- *----------------------------------------------------------------------
- */
+    TkWindow *winPtr = (TkWindow *) tkwin;
 
-void
-SetDefaultMenubar(void)
-{
-    if (currentMenuBarName != NULL) {
-	ckfree(currentMenuBarName);
-	currentMenuBarName = NULL;
-    }
-    currentMenuBarOwner = NULL;
-    ClearMenuBar();
-    InsertMenu(tkAppleMenu, 0);
-    InsertMenu(tkFileMenu, 0);
-    InsertMenu(tkEditMenu, 0);
-    if (!(menuBarFlags & MENUBAR_REDRAW_PENDING)) {
-	Tcl_DoWhenIdle(DrawMenuBarWhenIdle, NULL);
-	menuBarFlags |= MENUBAR_REDRAW_PENDING;
+    if (winPtr->wmInfoPtr) {
+	winPtr->wmInfoPtr->menuPtr = menuPtr;
     }
 }
 
@@ -2040,296 +721,93 @@ TkpSetMainMenubar(
     char *menuName)		/* The name of the menu to put in front. If
 				 * NULL, use the default menu bar. */
 {
-    TkWindow *winPtr = (TkWindow *) tkwin;
-    WindowRef macWindowPtr;
-    WindowRef frontNonFloating;
-
-    macWindowPtr = TkMacOSXDrawableWindow(winPtr->window);
-
-    frontNonFloating = ActiveNonFloatingWindow();
-    if ((macWindowPtr == NULL) || (macWindowPtr != frontNonFloating)) {
-	return;
-    }
-
-    if ((currentMenuBarInterp != interp) || (currentMenuBarOwner != tkwin)
-	    || (currentMenuBarName == NULL) || (menuName == NULL)
-	    || (strcmp(menuName, currentMenuBarName) != 0)) {
-	Tk_Window searchWindow;
-	TopLevelMenubarList *listPtr;
-
-	if (currentMenuBarName != NULL) {
-	    ckfree(currentMenuBarName);
-	}
-
-	if (menuName == NULL) {
-	    searchWindow = tkwin;
-	    if (strcmp(Tk_Class(searchWindow), "Menu") == 0) {
-		TkMenuReferences *menuRefPtr;
-
-		menuRefPtr = TkFindMenuReferences(interp, Tk_PathName(tkwin));
-		if (menuRefPtr != NULL) {
-		    TkMenu *menuPtr = menuRefPtr->menuPtr;
-
-		    if (menuPtr != NULL) {
-			searchWindow = menuPtr->masterMenuPtr->tkwin;
-		    }
-		}
-	    }
-	    for (; searchWindow != NULL;
-		    searchWindow = Tk_Parent(searchWindow)) {
-		for (listPtr = windowListPtr; listPtr != NULL;
-			listPtr = listPtr->nextPtr) {
-		    if (listPtr->tkwin == searchWindow) {
-			break;
-		    }
-		}
-		if (listPtr != NULL) {
-		    menuName = Tk_PathName(
-			    listPtr->menuPtr->masterMenuPtr->tkwin);
-		    break;
-		}
-	    }
-	}
-
-	if (menuName == NULL) {
-	    currentMenuBarName = NULL;
+    static Tcl_Interp *currentInterp = NULL;
+    TKMenu *menu = nil;
+    if (menuName) {
+	TkWindow *winPtr = (TkWindow *) tkwin;
+	if (winPtr->wmInfoPtr && winPtr->wmInfoPtr->menuPtr &&
+		winPtr->wmInfoPtr->menuPtr->masterMenuPtr &&
+		winPtr->wmInfoPtr->menuPtr->masterMenuPtr->tkwin &&
+		!strcmp(menuName, Tk_PathName(
+		winPtr->wmInfoPtr->menuPtr->masterMenuPtr->tkwin))) {
+	    menu = (TKMenu *) winPtr->wmInfoPtr->menuPtr->platformData;
 	} else {
-	    currentMenuBarName = ckalloc(strlen(menuName) + 1);
-	    strcpy(currentMenuBarName, menuName);
-	}
-	currentMenuBarOwner = tkwin;
-	currentMenuBarInterp = interp;
-    }
-    if (!(menuBarFlags & MENUBAR_REDRAW_PENDING)) {
-	Tcl_DoWhenIdle(DrawMenuBarWhenIdle, NULL);
-	menuBarFlags |= MENUBAR_REDRAW_PENDING;
-    }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * TkpSetWindowMenuBar --
- *
- *	Associates a given menu with a window.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	On Windows and UNIX, associates the platform menu with the platform
- *	window.
- *
- *----------------------------------------------------------------------
- */
-
-void
-TkpSetWindowMenuBar(
-    Tk_Window tkwin,		/* The window we are setting the menu in */
-    TkMenu *menuPtr)		/* The menu we are setting */
-{
-    TopLevelMenubarList *listPtr, *prevPtr;
-
-    /*
-     * Remove any existing reference to this window.
-     */
-
-    for (prevPtr = NULL, listPtr = windowListPtr;
-	    listPtr != NULL;
-	    prevPtr = listPtr, listPtr = listPtr->nextPtr) {
-	if (listPtr->tkwin == tkwin) {
-	    break;
-	}
-    }
-
-    if (listPtr != NULL) {
-	if (prevPtr != NULL) {
-	    prevPtr->nextPtr = listPtr->nextPtr;
-	} else {
-	    windowListPtr = listPtr->nextPtr;
+	    TkMenuReferences *menuRefPtr = TkFindMenuReferences(interp,
+		    menuName);
+	    if (menuRefPtr && menuRefPtr->menuPtr &&
+		    menuRefPtr->menuPtr->platformData) {
+		menu = (TKMenu *) menuRefPtr->menuPtr->platformData;
+	    }
 	}
-	ckfree((char *) listPtr);
     }
-
-    if (menuPtr != NULL) {
-	listPtr = (TopLevelMenubarList *) ckalloc(sizeof(TopLevelMenubarList));
-	listPtr->nextPtr = windowListPtr;
-	windowListPtr = listPtr;
-	listPtr->tkwin = tkwin;
-	listPtr->menuPtr = menuPtr;
+    if (menu || interp != currentInterp) {
+	[NSApp tkSetMainMenu:menu];
     }
+    currentInterp = interp;
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * EventuallyInvokeMenu --
+ * CheckForSpecialMenu --
  *
- *	This IdleTime callback actually invokes the menu command scheduled in
- *	TkMacOSXDispatchMenuEvent.
+ *	Given a menu, check to see whether or not it is a cascade in
+ *	a menubar with one of the special names .apple, .help or .window
+ *	If it is, the entry that points to this menu will be marked.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Commands get executed.
+ *	Will set entryFlags appropriately.
  *
  *----------------------------------------------------------------------
  */
 
-void
-EventuallyInvokeMenu (
-    ClientData data)
+static void
+CheckForSpecialMenu(
+    TkMenu *menuPtr)		/* The menu we are checking */
 {
-    struct MenuCommandHandlerData *realData = data;
-    int code;
-
-    code = TkInvokeMenu(realData->menuPtr->interp, realData->menuPtr,
-	    realData->index);
-
-    if (code != TCL_OK && code != TCL_CONTINUE && code != TCL_BREAK) {
-	Tcl_AddErrorInfo(realData->menuPtr->interp, "\n    (menu invoke)");
-	Tcl_BackgroundException(realData->menuPtr->interp, code);
-    }
-
-    if (realData->menuPtr->tkwin) {
-	RecursivelyClearActiveMenu(realData->menuPtr);
+    if (!menuPtr->masterMenuPtr->tkwin) {
+	return;
     }
-    TkMacOSXClearMenubarActive();
-
-    Tcl_Release(realData->menuPtr->interp);
-    Tcl_Release(realData->menuPtr);
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * TkMacOSXDispatchMenuEvent --
- *
- *	Given a menu id and an item, dispatches the command associated with
- *	it.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Commands for the event are scheduled for execution at idle time.
- *
- *----------------------------------------------------------------------
- */
-
-int
-TkMacOSXDispatchMenuEvent(
-    int menuID,			/* The menu id of the menu we are invoking */
-    int index)			/* The one-based index of the item that was
-				 * selected. */
-{
-    int result = TCL_OK;
-
-    if (menuID != 0) {
-	if (menuID == kHMHelpMenuID) {
-	    if (currentMenuBarOwner != NULL) {
-		TkMenuReferences *helpMenuRef;
-		char *helpMenuName = ckalloc(strlen(currentMenuBarName)
-			+ strlen(".help") + 1);
-
-		sprintf(helpMenuName, "%s.help", currentMenuBarName);
-		helpMenuRef = TkFindMenuReferences(currentMenuBarInterp,
-			helpMenuName);
-		ckfree(helpMenuName);
-		if ((helpMenuRef != NULL) && (helpMenuRef->menuPtr != NULL)) {
-		    MenuRef outHelpMenu;
-		    MenuItemIndex itemIndex;
-		    int newIndex;
-
-		    HMGetHelpMenu(&outHelpMenu, &itemIndex);
-		    newIndex = index - itemIndex;
-		    result = TkInvokeMenu(currentMenuBarInterp,
-			    helpMenuRef->menuPtr, newIndex);
-		}
-	    }
-	} else {
-	    Tcl_HashEntry *commandEntryPtr =
-		    Tcl_FindHashEntry(&commandTable, (char*)(intptr_t)menuID);
-	    if (commandEntryPtr != NULL) {
-		TkMenu *menuPtr = (TkMenu *) Tcl_GetHashValue(commandEntryPtr);
-
-		if ((currentAppleMenuID == menuID)
-			&& (index > menuPtr->numEntries + 1)) {
-		    /*
-		     * We don't need to do anything here, the standard
-		     * Application event handler will open the built-in Apple
-		     * menu item for us.
-		     */
-
-		    result = TCL_OK;
+    for (TkMenuEntry *cascadeEntryPtr = menuPtr->menuRefPtr->parentEntryPtr;
+	    cascadeEntryPtr; cascadeEntryPtr = cascadeEntryPtr->nextCascadePtr) {
+	if (cascadeEntryPtr->menuPtr->menuType == MENUBAR
+		&& cascadeEntryPtr->menuPtr->masterMenuPtr->tkwin) {
+	    TkMenu *masterMenuPtr = cascadeEntryPtr->menuPtr->masterMenuPtr;
+	    int i = 0;
+	    Tcl_DString ds;
+
+	    Tcl_DStringInit(&ds);
+	    Tcl_DStringAppend(&ds, Tk_PathName(masterMenuPtr->tkwin), -1);
+	    while (specialMenus[i].name) {
+		Tcl_DStringAppend(&ds, specialMenus[i].name,
+			specialMenus[i].len);
+		if (strcmp(Tcl_DStringValue(&ds),
+			Tk_PathName(menuPtr->masterMenuPtr->tkwin)) == 0) {
+		    cascadeEntryPtr->entryFlags |= specialMenus[i].flag;
 		} else {
-		    struct MenuCommandHandlerData *data =
-			    (struct MenuCommandHandlerData *)
-			    ckalloc(sizeof(struct MenuCommandHandlerData));
-
-		    Tcl_Preserve(menuPtr->interp);
-		    Tcl_Preserve(menuPtr);
-		    data->menuPtr = menuPtr;
-		    data->index = index - 1;
-		    Tcl_DoWhenIdle(EventuallyInvokeMenu, data);
-		    /* result = TkInvokeMenu(menuPtr->interp, menuPtr, index - 1); */
+		    cascadeEntryPtr->entryFlags &= ~specialMenus[i].flag;
 		}
-	    } else {
-		return TCL_ERROR;
+		Tcl_DStringSetLength(&ds, Tcl_DStringLength(&ds) -
+			specialMenus[i].len);
+		i++;
 	    }
+	    Tcl_DStringFree(&ds);
 	}
     }
-    return result;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * GetMenuIndicatorGeometry --
- *
- *	Gets the width and height of the indicator area of a menu.
- *
- * Results:
- *	widthPtr and heightPtr are set.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-void
-GetMenuIndicatorGeometry (
-    TkMenu *menuPtr,		/* The menu we are drawing */
-    TkMenuEntry *mePtr,		/* The entry we are measuring */
-    Tk_Font tkfont,		/* Precalculated font */
-    const Tk_FontMetrics *fmPtr,/* Precalculated font metrics */
-    int *widthPtr,		/* The resulting width */
-    int *heightPtr)		/* The resulting height */
-{
-    *heightPtr = fmPtr->linespace + menuItemExtraHeight;
-    if (IS_THEME_MENU_FONT(tkfont)) {
-	*widthPtr = menuMarkColumnWidth;
-    } else {
-	const char markChar = FindMarkCharacter(mePtr);
-	const char *markUtf = NULL;
-	int len;
-
-	len = GetUtfMarkCharacter(markChar, &markUtf);
-	*widthPtr = Tk_TextWidth(tkfont, markUtf, len) + 2*menuMarkIndent;
-    }
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * GetMenuAccelGeometry --
+ * ParseAccelerator --
  *
- *	Gets the width and height of the accelerator area of a menu.
+ *	Parse accelerator string.
  *
  * Results:
- *	widthPtr and heightPtr are set.
+ *	Accelerator string & flags.
  *
  * Side effects:
  *	None.
@@ -2337,818 +815,94 @@ GetMenuIndicatorGeometry (
  *----------------------------------------------------------------------
  */
 
-void
-GetMenuAccelGeometry (
-    TkMenu *menuPtr,		/* The menu we are measuring */
-    TkMenuEntry *mePtr,		/* The entry we are measuring */
-    Tk_Font tkfont,		/* The precalculated font */
-    const Tk_FontMetrics *fmPtr,/* The precalculated font metrics */
-    int *modWidthPtr,		/* The width of all of the key
-				 * modifier symbols. */
-    int *textWidthPtr,		/* The resulting width */
-    int *heightPtr)		/* The resulting height */
+static NSString*
+ParseAccelerator(
+    const char *accel,
+    NSUInteger *maskPtr)
 {
-    *heightPtr = fmPtr->linespace + menuItemExtraHeight;
-    *modWidthPtr = menuSymbols[COMMAND_SYMBOL].width;
-    *textWidthPtr = 0;
-    if (mePtr->type != CASCADE_ENTRY && mePtr->accelLength > 0) {
-	const char *accel = (mePtr->accelPtr == NULL) ? ""
-		: Tcl_GetString(mePtr->accelPtr);
-	EntryGeometry *geometryPtr = (EntryGeometry*)mePtr->platformEntryData;
-
-	if (IS_THEME_MENU_FONT(tkfont)) {
-	    CFStringRef cfStr;
-	    int width = 0;
-	    int maxWidth = ((TkFont *)tkfont)->fm.maxWidth;
+    unichar ch = 0;
+    size_t len;
+    int i;
 
-	    if (geometryPtr->accelGlyph) {
-		cfStr = CFStringCreateWithBytes(NULL,
-			(UInt8*)&geometryPtr->accelGlyph, 1,
-			kTextEncodingMacKeyboardGlyphs, false);
-		if (cfStr) {
-		    width = MeasureThemeText(cfStr, kThemeMenuItemCmdKeyFont);
-		    CFRelease(cfStr);
-		}
-	    }
-	    if ((mePtr->entryFlags & ENTRY_ACCEL_MASK) == 0) {
-		if (!geometryPtr->accelGlyph) {
-		     width = Tk_TextWidth(tkfont, accel, mePtr->accelLength);
-		 }
-		*textWidthPtr = maxWidth;
-		if (width < maxWidth) {
-		    *modWidthPtr = 0;
-		} else {
-		    *modWidthPtr = width - maxWidth;
-		}
-	    } else {
-		if (!geometryPtr->accelGlyph) {
-		    width = Tk_TextWidth(tkfont, accel +
-			    geometryPtr->accelTextStart, mePtr->accelLength -
-			    geometryPtr->accelTextStart);
-		}
-		if (width < maxWidth) {
-		    *textWidthPtr = maxWidth;
-		} else {
-		    *textWidthPtr = width;
-		}
-		if (geometryPtr->modifierNum) {
-		    *modWidthPtr = geometryPtr->modifierWidth;
-		}
+    *maskPtr = 0;
+    while (1) {
+	i = 0;
+	while (modifiers[i].name) {
+	    int l = modifiers[i].len;
+
+	    if (!strncasecmp(accel, modifiers[i].name, l) &&
+		    (accel[l] == '-' || accel[l] == '+')) {
+		*maskPtr |= modifiers[i].mask;
+		accel += l+1;
+		break;
 	    }
-	} else {
-	    *textWidthPtr = Tk_TextWidth(tkfont, accel, mePtr->accelLength);
+	    i++;
 	}
-    }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * GetTearoffEntryGeometry --
- *
- *	Gets the width and height of of a tearoff entry.
- *
- * Results:
- *	widthPtr and heightPtr are set.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-void
-GetTearoffEntryGeometry (
-    TkMenu *menuPtr,		/* The menu we are drawing */
-    TkMenuEntry *mePtr,		/* The entry we are measuring */
-    Tk_Font tkfont,		/* The precalculated font */
-    const Tk_FontMetrics *fmPtr,/* The precalculated font metrics */
-    int *widthPtr,		/* The resulting width */
-    int *heightPtr)		/* The resulting height */
-{
-#ifdef USE_TK_MDEF
-    const int useMDEF = ((MacMenu *) menuPtr->platformData)->useMDEF;
-#endif
-    if (useMDEF && menuPtr->menuType != TEAROFF_MENU) {
-	*heightPtr = fmPtr->linespace + menuItemExtraHeight;
-	*widthPtr = menuPtr->totalWidth;
-    } else {
-	*widthPtr = *heightPtr = 0;
-    }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * GetMenuSeparatorGeometry --
- *
- *	Gets the width and height of menu separator.
- *
- * Results:
- *	widthPtr and heightPtr are set.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-void
-GetMenuSeparatorGeometry(
-    TkMenu *menuPtr,		/* The menu we are drawing */
-    TkMenuEntry *mePtr,		/* The entry we are measuring */
-    Tk_Font tkfont,		/* The precalculated font */
-    const Tk_FontMetrics *fmPtr,/* The precalcualted font metrics */
-    int *widthPtr,		/* The resulting width */
-    int *heightPtr)		/* The resulting height */
-{
-    *widthPtr = 0;
-    *heightPtr = menuSeparatorHeight;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * DrawMenuEntryIndicator --
- *
- *	This procedure draws the indicator part of a menu.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Commands are output to X to display the menu in its
- *	current mode.
- *
- *----------------------------------------------------------------------
- */
-
-void
-DrawMenuEntryIndicator(
-    TkMenu *menuPtr,		/* The menu we are drawing */
-    TkMenuEntry *mePtr,		/* The entry we are drawing */
-    Drawable d,			/* The drawable we are drawing */
-    GC gc,			/* The GC we are drawing with */
-    GC indicatorGC,		/* The GC to use for the indicator */
-    Tk_Font tkfont,		/* The precalculated font */
-    const Tk_FontMetrics *fmPtr,/* The precalculated font metrics */
-    int x,			/* topleft hand corner of entry */
-    int y,			/* topleft hand corner of entry */
-    int width,			/* width of entry */
-    int height)			/* height of entry */
-{
-    if ((mePtr->type == CHECK_BUTTON_ENTRY) ||
-	    (mePtr->type == RADIO_BUTTON_ENTRY)) {
-	if (mePtr->indicatorOn && (mePtr->entryFlags & ENTRY_SELECTED)) {
-	    short mark;
-	    int baseline = y + (height + fmPtr->ascent - fmPtr->descent)/2;
-
-	    GetItemMark(((MacMenu *) menuPtr->platformData)->menuHdl,
-		    mePtr->index + 1, &mark);
-	    if (IS_THEME_MENU_FONT(tkfont)) {
-		ThemeFontID font = kThemeMenuItemMarkFont;
-		TextEncoding encoding = GetApplicationTextEncoding();
-		CFStringRef cfStr;
-		ThemeDrawState drawState;
-		Rect bounds = {y, x + menuMarkIndent, y + height, x + width};
-
-		if (mark < kSpaceCharCode) {
-		    font = kThemeMenuItemCmdKeyFont;
-		    encoding = kTextEncodingMacKeyboardGlyphs;
-		}
-		switch (mePtr->state) {
-		case ENTRY_ACTIVE:
-		    drawState = kThemeStatePressed;
-		    break;
-		case ENTRY_DISABLED:
-		    drawState = kThemeStateInactive;
-		    break;
-		default:
-		    drawState = kThemeStateActive;
-		    break;
-		}
-		cfStr = CFStringCreateWithBytes(NULL, (UInt8*)&mark, 1,
-			encoding, false);
-		if (cfStr) {
-		    DrawThemeText(d, gc, cfStr, font, drawState, &bounds,
-			    baseline, teFlushDefault);
-		    CFRelease(cfStr);
-		}
-	    } else if (mark != 0) {
-		const char *markUtf = NULL;
-		int len;
-
-		len = GetUtfMarkCharacter(mark, &markUtf);
-		Tk_DrawChars(menuPtr->display, d, gc, tkfont, markUtf, len,
-		    x + menuMarkIndent, baseline);
-	    }
+	if (!modifiers[i].name || !*accel) {
+	    break;
 	}
     }
-}
-
-#ifdef USE_TK_MDEF
-/*
- *----------------------------------------------------------------------
- *
- * DrawMenuBackground --
- *
- *	If Appearance is present, draws the Appearance background
- *
- * Results:
- *	Nothing
- *
- * Side effects:
- *	Commands are output to X to display the menu in its current mode.
- *
- *----------------------------------------------------------------------
- */
-
-void
-DrawMenuBackground(
-    TkMenu *menuPtr,
-    Rect *menuRectPtr,		/* The menu rect */
-    Drawable d)			/* What we are drawing into */
-{
-    Tk_3DBorder border;
-
-    EraseMenuBackground(((MacMenu *) menuPtr->platformData)->menuHdl,
-	    menuRectPtr, ((MacDrawable*)d)->context);
-    border = Tk_Get3DBorderFromObj(menuPtr->tkwin, menuPtr->borderPtr);
-    Tk_Fill3DRectangle(menuPtr->tkwin, d, border,
-	    menuRectPtr->left, menuRectPtr->top,
-	    menuRectPtr->right - menuRectPtr->left,
-	    menuRectPtr->bottom - menuRectPtr->top, 0, TK_RELIEF_FLAT);
-}
-#endif /* USE_TK_MDEF */
-
-/*
- *----------------------------------------------------------------------
- *
- * DrawMenuEntryAccelerator --
- *
- *	This procedure draws the accelerator part of a menu.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Commands are output to X to display the menu in its current mode.
- *
- *----------------------------------------------------------------------
- */
+    len = strlen(accel);
+    if (len > 1) {
+	i = 0;
+	if (accel[0] == 'F' && len < 4 && accel[1] > '0' && accel[1] <= '9') {
+	    int fkey = accel[1] - '0';
 
-void
-DrawMenuEntryAccelerator(
-    TkMenu *menuPtr,		/* The menu we are drawing */
-    TkMenuEntry *mePtr,		/* The entry we are drawing */
-    Drawable d,			/* The drawable we are drawing in */
-    GC gc,			/* The gc to draw into */
-    Tk_Font tkfont,		/* The precalculated font */
-    const Tk_FontMetrics *fmPtr,/* The precalculated font metrics */
-    Tk_3DBorder activeBorder,	/* border for menu background */
-    int x,			/* The left side of the entry */
-    int y,			/* The top of the entry */
-    int width,			/* The width of the entry */
-    int height,			/* The height of the entry */
-    int drawArrow)		/* Whether or not to draw cascade arrow */
-{
-    if (mePtr->type != CASCADE_ENTRY && mePtr->accelLength > 0) {
-	const char *accel = (mePtr->accelPtr == NULL) ? ""
-		: Tcl_GetString(mePtr->accelPtr);
-	EntryGeometry *geometryPtr = (EntryGeometry*)mePtr->platformEntryData;
-	int leftEdge = x + width - geometryPtr->accelTextWidth;
-	int baseline = y + (height + fmPtr->ascent - fmPtr->descent) / 2;
-
-	if (IS_THEME_MENU_FONT(tkfont)) {
-	    CFStringRef cfStr;
-	    ThemeDrawState drawState;
-
-	    switch (mePtr->state) {
-	    case ENTRY_ACTIVE:
-		drawState = kThemeStatePressed;
-		break;
-	    case ENTRY_DISABLED:
-		drawState = kThemeStateInactive;
-		break;
-	    default:
-		drawState = kThemeStateActive;
-		break;
-	    }
-	    if ((mePtr->entryFlags & ENTRY_ACCEL_MASK) == 0) {
-		leftEdge -= geometryPtr->modifierWidth;
-	    }
-	    if (geometryPtr->accelGlyph) {
-		Rect bounds = {y, leftEdge, y + height, leftEdge +
-			geometryPtr->accelTextWidth};
-
-		cfStr = CFStringCreateWithBytes(NULL,
-			(UInt8*)&geometryPtr->accelGlyph, 1,
-			kTextEncodingMacKeyboardGlyphs, false);
-		if (cfStr) {
-		    DrawThemeText(d, gc, cfStr, kThemeMenuItemCmdKeyFont,
-			    drawState, &bounds, baseline, teFlushDefault);
-		    CFRelease(cfStr);
+	    if (len == 3) {
+		if (accel[2] >= '0' && accel[2] <= '9') {
+		    fkey = 10 * fkey + (accel[2] - '0');
+		} else {
+		    fkey = 0;
 		}
-	    } else {
-		Tk_DrawChars(menuPtr->display, d, gc, tkfont, accel +
-			geometryPtr->accelTextStart, mePtr->accelLength -
-			geometryPtr->accelTextStart, leftEdge, baseline);
 	    }
-	    if (geometryPtr->modifierNum) {
-		Rect bounds = {y, leftEdge - geometryPtr->modifierWidth,
-			y + height, leftEdge};
-
-		cfStr = CFStringCreateWithCharacters(NULL,
-			geometryPtr->modifierUniChars,
-			geometryPtr->modifierNum);
-		if (cfStr) {
-		    DrawThemeText(d, gc, cfStr, kThemeMenuItemCmdKeyFont,
-			    drawState, &bounds, baseline, teFlushDefault);
-		    CFRelease(cfStr);
-		}
+	    if (fkey >= 1 && fkey <= 15) {
+		ch = NSF1FunctionKey + fkey - 1;
 	    }
-	} else {
-	    Tk_DrawChars(menuPtr->display, d, gc, tkfont, accel,
-		    mePtr->accelLength, leftEdge, baseline);
+	} else while (specialAccelerators[i].name) {
+	    if (accel[0] == specialAccelerators[i].name[0] &&
+		    len == specialAccelerators[i].len && !strncasecmp(accel,
+		    specialAccelerators[i].name, specialAccelerators[i].len)) {
+		ch = specialAccelerators[i].ch;
+		break;
+	    }
+	    i++;
 	}
     }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * DrawMenuSeparator --
- *
- *	The menu separator is drawn.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Commands are output to X to display the menu in its current mode.
- *
- *----------------------------------------------------------------------
- */
-
-void
-DrawMenuSeparator(
-    TkMenu *menuPtr,		/* The menu we are drawing */
-    TkMenuEntry *mePtr,		/* The entry we are drawing */
-    Drawable d,			/* The drawable we are drawing into */
-    GC gc,			/* The gc we are drawing with */
-    Tk_Font tkfont,		/* The precalculated font */
-    const Tk_FontMetrics *fmPtr,/* The precalculated font metrics */
-    int x,			/* left coordinate of entry */
-    int y,			/* top coordinate of entry */
-    int width,			/* width of entry */
-    int height)			/* height of entry */
-{
-    TkMacOSXDrawingContext dc;
-    Rect r;
-
-    r.top = y;
-    r.left = x;
-    r.bottom = y + height;
-    r.right = x + width;
-    if (TkMacOSXSetupDrawingContext(d, gc, 1, &dc)) {
-	ChkErr(DrawThemeMenuSeparator, &r);
-	TkMacOSXRestoreDrawingContext(&dc);
-    }
-}
-
-#ifdef USE_TK_MDEF
-/*
- *----------------------------------------------------------------------
- *
- * AppearanceEntryDrawWrapper --
- *
- *	It routes to the Appearance Managers DrawThemeEntry, which will then
- *	call us back after setting up the drawing context.
- *
- * Results:
- *	A menu entry is drawn
- *
- * Side effects:
- *	None
- *
- *----------------------------------------------------------------------
- */
-
-void
-AppearanceEntryDrawWrapper(
-    TkMenuEntry *mePtr,
-    Rect *menuRectPtr,
-    MenuTrackingData *mtdPtr,
-    Drawable d,
-    Tk_FontMetrics *fmPtr,
-    Tk_Font tkfont,
-    int erase)
-{
-    MenuEntryUserData meData;
-    Rect itemRect;
-    ThemeMenuState theState;
-    ThemeMenuItemType theType;
-    Tk_FontMetrics entryMetrics;
-
-    meData.mePtr = mePtr;
-    meData.mdefDrawable = d;
-    if (mePtr->fontPtr == NULL) {
-	meData.fmPtr = fmPtr;
-	meData.tkfont = tkfont;
+    if (ch) {
+	return [[[NSString alloc] initWithCharacters:&ch length:1] autorelease];
     } else {
-	meData.tkfont = Tk_GetFontFromObj(mePtr->menuPtr->tkwin,
-		mePtr->fontPtr);
-	Tk_GetFontMetrics(meData.tkfont, &entryMetrics);
-	fmPtr = &entryMetrics;
-    }
-    itemRect.left = menuRectPtr->left + mePtr->x;
-    itemRect.top = mtdPtr->virtualMenuTop + mePtr->y;
-    itemRect.right = mePtr->entryFlags & ENTRY_LAST_COLUMN ?
-	    menuRectPtr->right : itemRect.left + mePtr->width;
-    itemRect.bottom = itemRect.top + mePtr->height;
-
-    if (mePtr->state == ENTRY_ACTIVE) {
-	theState = kThemeMenuSelected;
-    } else if (mePtr->state == ENTRY_DISABLED) {
-	theState = kThemeMenuDisabled;
-    } else {
-	theState = kThemeMenuActive;
-    }
-    if (mePtr->type == CASCADE_ENTRY) {
-	theType = kThemeMenuItemHierarchical;
-    } else {
-	theType = kThemeMenuItemPlain;
-    }
-    if (erase) {
-	DisableScreenUpdates();
-	DrawMenuBackground(mePtr->menuPtr, &itemRect, d);
-    }
-    DrawThemeMenuItem(menuRectPtr, &itemRect,
-	    mtdPtr->virtualMenuTop, mtdPtr->virtualMenuBottom, theState,
-	    theType | kThemeMenuItemNoBackground, tkThemeMenuItemDrawingUPP,
-	    (unsigned long) &meData);
-    if (erase) {
-	EnableScreenUpdates();
+	return [[[[NSString alloc] initWithUTF8String:accel] autorelease]
+		lowercaseString];
     }
 }
 
 /*
- *----------------------------------------------------------------------
- *
- * ThemeMenuItemDrawingProc --
- *
- *	This routine is called from the Appearance DrawThemeMenuEntry
- *
- * Results:
- *	A menu entry is drawn
- *
- * Side effects:
- *	None
- *
- *----------------------------------------------------------------------
- */
-
-pascal void
-ThemeMenuItemDrawingProc(
-    const Rect *inBounds,
-    SInt16 inDepth,
-    Boolean inIsColorDevice,
-    SInt32 inUserData)
-{
-    MenuEntryUserData *meData = (MenuEntryUserData *) inUserData;
-
-    TkpDrawMenuEntry(meData->mePtr, meData->mdefDrawable, meData->tkfont,
-	    meData->fmPtr, inBounds->left, inBounds->top, inBounds->right -
-	    inBounds->left + menuItemExtraWidth, inBounds->bottom -
-	    inBounds->top + menuItemExtraHeight, 0, 1);
-}
-#endif /* USE_TK_MDEF */
-
-/*
- *----------------------------------------------------------------------
- *
- * TkMacOSXHandleTearoffMenu() --
- *
- *	This routine sees if the MDEF has set a menu and a mouse position for
- *	tearing off and makes a tearoff menu if it has.
- *
- * Results:
- *	menuPtr->interp will have the result of the tearoff command.
- *
- * Side effects:
- *	A new tearoff menu is created if it is supposed to be.
- *
- *----------------------------------------------------------------------
- */
-
-void
-TkMacOSXHandleTearoffMenu(void)
-{
-    /*
-     * Obsolete: Nothing to do.
-     */
-}
-
-/*
  *--------------------------------------------------------------
  *
- * TkpInitializeMenuBindings --
+ * ModifierCharWidth --
  *
- *	For every interp, initializes the bindings for Windows menus. Does
- *	nothing on Mac or XWindows.
+ *	Helper mesuring width of command char in given font.
  *
  * Results:
- *	None.
+ *	Width of command char.
  *
  * Side effects:
- *	C-level bindings are setup for the interp which will handle Alt-key
- *	sequences for menus without beeping or interfering with user-defined
- *	Alt-key bindings.
- *
- *--------------------------------------------------------------
- */
-
-void
-TkpInitializeMenuBindings(
-    Tcl_Interp *interp,		/* The interpreter to set. */
-    Tk_BindingTable bindingTable)
-				/* The table to add to. */
-{
-    /*
-     * Nothing to do.
-     */
-}
-
-/*
- *--------------------------------------------------------------
- *
- * TkpComputeMenubarGeometry --
- *
- *	This procedure is invoked to recompute the size and layout of a menu
- *	that is a menubar clone.
- *
- * Results:
  *	None.
  *
- * Side effects:
- *	Fields of menu entries are changed to reflect their current positions,
- *	and the size of the menu window itself may be changed.
- *
  *--------------------------------------------------------------
  */
 
-void
-TkpComputeMenubarGeometry(
-    TkMenu *menuPtr)		/* Structure describing menu. */
-{
-    TkpComputeStandardMenuGeometry(menuPtr);
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * DrawTearoffEntry --
- *
- *	This procedure draws a tearoff entry.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Commands are output to X to display the menu in its current mode.
- *
- *----------------------------------------------------------------------
- */
-
-void
-DrawTearoffEntry(
-    TkMenu *menuPtr,		/* The menu we are drawing */
-    TkMenuEntry *mePtr,		/* The entry we are drawing */
-    Drawable d,			/* The drawable we are drawing into */
-    GC gc,			/* The gc we are drawing with */
-    Tk_Font tkfont,		/* The font we are drawing with */
-    const Tk_FontMetrics *fmPtr,/* The metrics we are drawing with */
-    int x,			/* Left edge of entry. */
-    int y,			/* Top edge of entry. */
-    int width,			/* Width of entry. */
-    int height)			/* Height of entry. */
-{
-    XPoint points[2];
-    int margin, segmentWidth, maxX;
-    Tk_3DBorder border;
-
-    if (menuPtr->menuType != MASTER_MENU ) {
-	return;
-    }
-
-    margin = fmPtr->linespace/2;
-    points[0].x = x;
-    points[0].y = y + height/2;
-    points[1].y = points[0].y;
-    segmentWidth = 6;
-    maxX  = x + menuPtr->totalWidth - 1;
-    border = Tk_Get3DBorderFromObj(menuPtr->tkwin, menuPtr->borderPtr);
-
-    while (points[0].x < maxX) {
-	points[1].x = points[0].x + segmentWidth;
-	if (points[1].x > maxX) {
-	    points[1].x = maxX;
-	}
-	Tk_Draw3DPolygon(menuPtr->tkwin, d, border, points, 2, 1,
-		TK_RELIEF_RAISED);
-	points[0].x += 2*segmentWidth;
-    }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * TkMacOSXSetHelpMenuItemCount --
- *
- *	Has to be called after the first call to InsertMenu. Sets up the
- *	global variable for the number of items in the unmodified help menu.
- *	NB. Nobody uses this any more, since you can get the number of system
- *	help items from HMGetHelpMenu trivially. But it is in the stubs
- *	table...
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Nothing.
- *
- *----------------------------------------------------------------------
- */
-
-void
-TkMacOSXSetHelpMenuItemCount(void)
-{
-    /*
-     * Obsolete: Nothing to do.
-     */
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * TkMacOSXMenuClick --
- *
- *	Prepares a menubar for MenuSelect or MenuKey.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Any pending configurations of the menubar are completed.
- *
- *----------------------------------------------------------------------
- */
-
-void
-TkMacOSXMenuClick(void)
-{
-    TkMenu *menuPtr;
-    TkMenuReferences *menuRefPtr;
-
-    if ((currentMenuBarInterp != NULL) && (currentMenuBarName != NULL)) {
-	menuRefPtr = TkFindMenuReferences(currentMenuBarInterp,
-		currentMenuBarName);
-	for (menuPtr = menuRefPtr->menuPtr->masterMenuPtr;
-		menuPtr != NULL; menuPtr = menuPtr->nextInstancePtr) {
-	    if (menuPtr->menuType == MENUBAR) {
-		CompleteIdlers(menuPtr);
-		break;
-	    }
-	}
-    }
-
-    if (menuBarFlags & MENUBAR_REDRAW_PENDING) {
-	Tcl_CancelIdleCall(DrawMenuBarWhenIdle, NULL);
-	DrawMenuBarWhenIdle(NULL);
-    }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * TkpDrawMenuEntry --
- *
- *	Draws the given menu entry at the given coordinates with the given
- *	attributes.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	X Server commands are executed to display the menu entry.
- *
- *----------------------------------------------------------------------
- */
-
-void
-TkpDrawMenuEntry(
-    TkMenuEntry *mePtr,		/* The entry to draw */
-    Drawable d,			/* What to draw into */
-    Tk_Font tkfont,		/* Precalculated font for menu */
-    const Tk_FontMetrics *menuMetricsPtr,
-				/* Precalculated metrics for menu */
-    int x,			/* X-coordinate of topleft of entry */
-    int y,			/* Y-coordinate of topleft of entry */
-    int width,			/* Width of the entry rectangle */
-    int height,			/* Height of the current rectangle */
-    int strictMotif,		/* Boolean flag */
-    int drawArrow)		/* Whether or not to draw the cascade
-				 * arrow for cascade items. Only applies
-				 * to Windows. */
+static int
+ModifierCharWidth(Tk_Font tkfont)
 {
-    GC gc;
-    TkMenu *menuPtr = mePtr->menuPtr;
-    int padY = (menuPtr->menuType == MENUBAR) ? 3 : 0;
-    GC indicatorGC;
-    Tk_3DBorder bgBorder, activeBorder;
-    const Tk_FontMetrics *fmPtr;
-    Tk_FontMetrics entryMetrics;
-    int adjustedY = y + padY;
-    int adjustedHeight = height - 2 * padY;
-
-    /*
-     * Choose the gc for drawing the foreground part of the entry. Under
-     * Appearance, we pass a null (appearanceGC) to tell ourselves not to
-     * change whatever color the appearance manager has set.
-     */
-
-    if ((mePtr->state == ENTRY_ACTIVE) && !strictMotif) {
-	gc = mePtr->activeGC;
-	if (gc == NULL) {
-	    gc = menuPtr->activeGC;
-	}
-    } else {
-	TkMenuEntry *parentEntryPtr = GetParentMenuEntry(menuPtr);
-
-	if (((parentEntryPtr && parentEntryPtr->state == ENTRY_DISABLED) ||
-		(mePtr->state == ENTRY_DISABLED)) &&
-		(menuPtr->disabledFgPtr != NULL)) {
-	    gc = mePtr->disabledGC;
-	    if (gc == NULL) {
-		gc = menuPtr->disabledGC;
-	    }
-	} else {
-	    gc = mePtr->textGC;
-	    if (gc == NULL) {
-		gc = menuPtr->textGC;
-	    }
-	}
-    }
-
-    indicatorGC = mePtr->indicatorGC;
-    if (indicatorGC == NULL) {
-	indicatorGC = menuPtr->indicatorGC;
-    }
+    static NSString *cmdChar = nil;
 
-    bgBorder = Tk_Get3DBorderFromObj(menuPtr->tkwin,
-	    (mePtr->borderPtr == NULL)
-	    ? menuPtr->borderPtr : mePtr->borderPtr);
-    if (strictMotif) {
-	activeBorder = bgBorder;
-    } else {
-	activeBorder = Tk_Get3DBorderFromObj(menuPtr->tkwin,
-	    (mePtr->activeBorderPtr == NULL)
-	    ? menuPtr->activeBorderPtr : mePtr->activeBorderPtr);
-    }
-
-    if (mePtr->fontPtr == NULL) {
-	fmPtr = menuMetricsPtr;
-    } else {
-	tkfont = Tk_GetFontFromObj(menuPtr->tkwin, mePtr->fontPtr);
-	Tk_GetFontMetrics(tkfont, &entryMetrics);
-	fmPtr = &entryMetrics;
-    }
-
-    /*
-     * Need to draw the entire background, including padding. On Unix, for
-     * menubars, we have to draw the rest of the entry taking into account the
-     * padding.
-     */
-
-    DrawMenuEntryBackground(menuPtr, mePtr, d, activeBorder, bgBorder, x, y,
-	    width, height);
-
-    if (mePtr->type == SEPARATOR_ENTRY) {
-	DrawMenuSeparator(menuPtr, mePtr, d, gc, tkfont,
-		fmPtr, x, adjustedY, width, adjustedHeight);
-    } else if (mePtr->type == TEAROFF_ENTRY) {
-	DrawTearoffEntry(menuPtr, mePtr, d, gc, tkfont, fmPtr, x, adjustedY,
-		width, adjustedHeight);
-    } else {
-	DrawMenuEntryLabel(menuPtr, mePtr, d, gc, tkfont, fmPtr, x,
-		adjustedY, width, adjustedHeight);
-	DrawMenuEntryAccelerator(menuPtr, mePtr, d, gc, tkfont, fmPtr,
-		activeBorder, x, adjustedY, width, adjustedHeight, drawArrow);
-	if (!mePtr->hideMargin) {
-	    DrawMenuEntryIndicator(menuPtr, mePtr, d, gc, indicatorGC, tkfont,
-		    fmPtr, x, adjustedY, width, adjustedHeight);
-	}
+    if (!cmdChar) {
+	unichar cmd = kCommandUnicode;
+	cmdChar = [[NSString alloc] initWithCharacters:&cmd length:1];
     }
+    return [cmdChar sizeWithAttributes:
+	    TkMacOSXNSFontAttributesForFont(tkfont)].width;
 }
 
 /*
@@ -3175,13 +929,12 @@ TkpComputeStandardMenuGeometry(
 {
     Tk_Font tkfont, menuFont;
     Tk_FontMetrics menuMetrics, entryMetrics, *fmPtr;
-    int x, y, height, modifierWidth, labelWidth, indicatorSpace;
-    int windowWidth, windowHeight, accelWidth, maxAccelTextWidth;
-    int i, j, lastColumnBreak, maxModifierWidth, maxWidth, nonAccelMargin;
-    int maxNonAccelMargin, maxEntryWithAccelWidth, maxEntryWithoutAccelWidth;
+    int modifierCharWidth, menuModifierCharWidth;
+    int x, y, modifierWidth, labelWidth, indicatorSpace;
+    int windowWidth, windowHeight, accelWidth;
+    int i, j, lastColumnBreak, maxWidth;
     int entryWidth, maxIndicatorSpace, borderWidth, activeBorderWidth;
     TkMenuEntry *mePtr, *columnEntryPtr;
-    EntryGeometry *geometryPtr;
     int haveAccel = 0;
 
     if (menuPtr->tkwin == NULL) {
@@ -3193,10 +946,7 @@ TkpComputeStandardMenuGeometry(
     Tk_GetPixelsFromObj(NULL, menuPtr->tkwin, menuPtr->activeBorderWidthPtr,
 	    &activeBorderWidth);
     x = y = borderWidth;
-    indicatorSpace = labelWidth = accelWidth = maxAccelTextWidth = 0;
     windowHeight = maxWidth = lastColumnBreak = 0;
-    maxModifierWidth = maxNonAccelMargin = 0;
-    maxEntryWithAccelWidth = maxEntryWithoutAccelWidth = 0;
     maxIndicatorSpace = 0;
 
     /*
@@ -3211,6 +961,7 @@ TkpComputeStandardMenuGeometry(
 
     menuFont = Tk_GetFontFromObj(menuPtr->tkwin, menuPtr->fontPtr);
     Tk_GetFontMetrics(menuFont, &menuMetrics);
+    menuModifierCharWidth = ModifierCharWidth(menuFont);
 
     for (i = 0; i < menuPtr->numEntries; i++) {
 	mePtr = menuPtr->entries[i];
@@ -3225,10 +976,12 @@ TkpComputeStandardMenuGeometry(
 	if (mePtr->fontPtr == NULL) {
 	    tkfont = menuFont;
 	    fmPtr = &menuMetrics;
+	    modifierCharWidth = menuModifierCharWidth;
 	} else {
 	    tkfont = Tk_GetFontFromObj(menuPtr->tkwin, mePtr->fontPtr);
 	    Tk_GetFontMetrics(tkfont, &entryMetrics);
 	    fmPtr = &entryMetrics;
+	    modifierCharWidth = ModifierCharWidth(tkfont);
 	}
 
 	if ((i > 0) && mePtr->columnBreak) {
@@ -3237,44 +990,20 @@ TkpComputeStandardMenuGeometry(
 	    }
 	    for (j = lastColumnBreak; j < i; j++) {
 		columnEntryPtr = menuPtr->entries[j];
-		geometryPtr =
-			(EntryGeometry *) columnEntryPtr->platformEntryData;
-
 		columnEntryPtr->indicatorSpace = maxIndicatorSpace;
 		columnEntryPtr->width = maxIndicatorSpace + maxWidth
 			+ 2 * activeBorderWidth;
-		geometryPtr->accelTextWidth = maxAccelTextWidth;
-		geometryPtr->modifierWidth = maxModifierWidth;
 		columnEntryPtr->x = x;
 		columnEntryPtr->entryFlags &= ~ENTRY_LAST_COLUMN;
-		if (maxEntryWithoutAccelWidth > maxEntryWithAccelWidth) {
-		    geometryPtr->nonAccelMargin = maxEntryWithoutAccelWidth
-			    - maxEntryWithAccelWidth;
-		    if (geometryPtr->nonAccelMargin > maxNonAccelMargin) {
-			geometryPtr->nonAccelMargin = maxNonAccelMargin;
-		    }
-		} else {
-		    geometryPtr->nonAccelMargin = 0;
-		}
 	    }
 	    x += maxIndicatorSpace + maxWidth + 2 * borderWidth;
-	    windowWidth = x;
-	    maxWidth = maxIndicatorSpace = maxAccelTextWidth = 0;
-	    maxModifierWidth = maxNonAccelMargin = maxEntryWithAccelWidth = 0;
-	    maxEntryWithoutAccelWidth = 0;
+	    maxWidth = maxIndicatorSpace = 0;
 	    lastColumnBreak = i;
 	    y = borderWidth;
 	}
-	/*geometryPtr = (EntryGeometry *) mePtr->platformEntryData;*/ /* dead code */
-
-	if (mePtr->type == SEPARATOR_ENTRY) {
-	    GetMenuSeparatorGeometry(menuPtr, mePtr, tkfont,
-		    fmPtr, &entryWidth, &height);
-	    mePtr->height = height;
-	} else if (mePtr->type == TEAROFF_ENTRY) {
-	    GetTearoffEntryGeometry(menuPtr, mePtr, tkfont,
-		    fmPtr, &entryWidth, &height);
-	    mePtr->height = height;
+	accelWidth = modifierWidth = indicatorSpace = 0;
+	if (mePtr->type == SEPARATOR_ENTRY || mePtr->type == TEAROFF_ENTRY) {
+	    mePtr->height = menuSeparatorHeight;
 	} else {
 	    /*
 	     * For each entry, compute the height required by that particular
@@ -3285,71 +1014,81 @@ TkpComputeStandardMenuGeometry(
 	     * on the type of the entry.
 	     */
 
-	    GetMenuLabelGeometry(mePtr, tkfont, fmPtr, &labelWidth, &height);
-	    mePtr->height = height;
+	    NSMenuItem *menuItem = (NSMenuItem *) mePtr->platformEntryData;
+	    int haveImage = 0, width = 0, height = 0;
+
+	    if (mePtr->image) {
+		Tk_SizeOfImage(mePtr->image, &width, &height);
+		haveImage = 1;
+	    } else if (mePtr->bitmapPtr) {
+		Pixmap bitmap = Tk_GetBitmapFromObj(menuPtr->tkwin,
+			mePtr->bitmapPtr);
+		Tk_SizeOfBitmap(menuPtr->display, bitmap, &width, &height);
+		haveImage = 1;
+	    }
+	    if (!haveImage || (mePtr->compound != COMPOUND_NONE)) {
+		NSAttributedString *attrTitle = [menuItem attributedTitle];
+		NSSize size;
 
-	    nonAccelMargin = 0;
-	    if (mePtr->type == CASCADE_ENTRY) {
-		GetMenuAccelGeometry(menuPtr, mePtr, tkfont, fmPtr,
-			&modifierWidth, &accelWidth, &height);
-	    } else if (mePtr->accelLength == 0) {
-		if (haveAccel && !mePtr->hideMargin) {
-		    if (IS_THEME_MENU_FONT(tkfont)) {
-			nonAccelMargin = menuSymbols[COMMAND_SYMBOL].width;
-		    } else {
-			nonAccelMargin = Tk_TextWidth(tkfont,
-				menuSymbols[COMMAND_SYMBOL].utf,
-				menuSymbols[COMMAND_SYMBOL].utfLen);
-		    }
+		if (attrTitle) {
+		    size = [attrTitle size];
+		} else {
+		    size = [[menuItem title] sizeWithAttributes:
+			TkMacOSXNSFontAttributesForFont(tkfont)];
 		}
-		accelWidth = modifierWidth = 0;
-	    } else {
-		GetMenuAccelGeometry(menuPtr, mePtr, tkfont,
-			fmPtr, &modifierWidth, &accelWidth, &height);
-		if (height > mePtr->height) {
-		    mePtr->height = height;
+		size.width += menuTextLeadingEdgeMargin +
+			menuTextTrailingEdgeMargin;
+		if (size.height < fmPtr->linespace) {
+		    size.height = fmPtr->linespace;
+		}
+		if (haveImage && (mePtr->compound != COMPOUND_NONE)) {
+		    int margin = width + menuIconTrailingEdgeMargin;
+
+		    if (margin > menuTextLeadingEdgeMargin) {
+			margin = menuTextLeadingEdgeMargin;
+		    }
+		    width += size.width + menuIconTrailingEdgeMargin - margin;
+		    if (size.height > height) {
+			height = size.height;
+		    }
+		} else {
+		    width = size.width;
+		    height = size.height;
 		}
 	    }
+	    labelWidth = width + menuItemExtraWidth;
+	    mePtr->height = height + menuItemExtraHeight;
 
-	    if (!(mePtr->hideMargin)) {
-		GetMenuIndicatorGeometry(menuPtr, mePtr, tkfont,
-			fmPtr, &indicatorSpace, &height);
-		if (height > mePtr->height) {
-		    mePtr->height = height;
+	    if (mePtr->type == CASCADE_ENTRY) {
+		modifierWidth = modifierCharWidth;
+	    } else if (mePtr->accelLength == 0) {
+		if (haveAccel && !mePtr->hideMargin) {
+		    modifierWidth = modifierCharWidth;
 		}
 	    } else {
-		indicatorSpace = 0;
-	    }
+		NSUInteger modifMask = [menuItem keyEquivalentModifierMask];
+		int i = 0;
 
-	    if (nonAccelMargin > maxNonAccelMargin) {
-		maxNonAccelMargin = nonAccelMargin;
-	    }
-	    if (accelWidth > maxAccelTextWidth) {
-		maxAccelTextWidth = accelWidth;
+		while (modifiers[i].name) {
+		    if (modifMask & modifiers[i].mask) {
+			modifMask &= ~modifiers[i].mask;
+			modifierWidth += modifierCharWidth;
+		    }
+		    i++;
+		}
+		accelWidth = [[menuItem keyEquivalent] sizeWithAttributes:
+			TkMacOSXNSFontAttributesForFont(tkfont)].width;
 	    }
-	    if (modifierWidth > maxModifierWidth) {
-		maxModifierWidth = modifierWidth;
+	    if (!mePtr->hideMargin) {
+		indicatorSpace = menuMarkColumnWidth;
 	    }
 	    if (indicatorSpace > maxIndicatorSpace) {
 		maxIndicatorSpace = indicatorSpace;
 	    }
-
-	    entryWidth = labelWidth + modifierWidth + accelWidth
-		    + nonAccelMargin;
-
+	    entryWidth = labelWidth + modifierWidth + accelWidth;
 	    if (entryWidth > maxWidth) {
 		maxWidth = entryWidth;
 	    }
-
-	    if (mePtr->accelLength > 0) {
-		if (entryWidth > maxEntryWithAccelWidth) {
-		    maxEntryWithAccelWidth = entryWidth;
-		}
-	    } else {
-		if (entryWidth > maxEntryWithoutAccelWidth) {
-		    maxEntryWithoutAccelWidth = entryWidth;
-		}
-	    }
 	    mePtr->height += 2 * activeBorderWidth;
 	}
 	mePtr->y = y;
@@ -3361,33 +1100,16 @@ TkpComputeStandardMenuGeometry(
 
     for (j = lastColumnBreak; j < menuPtr->numEntries; j++) {
 	columnEntryPtr = menuPtr->entries[j];
-	geometryPtr = (EntryGeometry *) columnEntryPtr->platformEntryData;
-
 	columnEntryPtr->indicatorSpace = maxIndicatorSpace;
 	columnEntryPtr->width = maxIndicatorSpace + maxWidth
 		+ 2 * activeBorderWidth;
-	geometryPtr->accelTextWidth = maxAccelTextWidth;
 	columnEntryPtr->x = x;
 	columnEntryPtr->entryFlags |= ENTRY_LAST_COLUMN;
-	if (maxEntryWithoutAccelWidth > maxEntryWithAccelWidth) {
-	    geometryPtr->nonAccelMargin = maxEntryWithoutAccelWidth
-		    - maxEntryWithAccelWidth;
-	    if (geometryPtr->nonAccelMargin > maxNonAccelMargin) {
-		geometryPtr->nonAccelMargin = maxNonAccelMargin;
-	    }
-	} else {
-	    geometryPtr->nonAccelMargin = 0;
-	}
     }
     windowWidth = x + maxIndicatorSpace + maxWidth
 	    + 2 * activeBorderWidth + borderWidth;
     windowHeight += borderWidth;
 
-    /*
-     * The X server doesn't like zero dimensions, so round up to at least 1 (a
-     * zero-sized menu should never really occur, anyway).
-     */
-
     if (windowWidth <= 0) {
 	windowWidth = 1;
     }
@@ -3401,351 +1123,7 @@ TkpComputeStandardMenuGeometry(
 /*
  *----------------------------------------------------------------------
  *
- * DrawMenuEntryLabel --
- *
- *	This procedure draws the label part of a menu.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Commands are output to X to display the menu in its current mode.
- *
- *----------------------------------------------------------------------
- */
-
-void
-DrawMenuEntryLabel(
-    TkMenu *menuPtr,		/* The menu we are drawing */
-    TkMenuEntry *mePtr,		/* The entry we are drawing */
-    Drawable d,			/* What we are drawing into */
-    GC gc,			/* The gc we are drawing into */
-    Tk_Font tkfont,		/* The precalculated font */
-    const Tk_FontMetrics *fmPtr,/* The precalculated font metrics */
-    int x,			/* left edge */
-    int y,			/* right edge */
-    int width,			/* width of entry */
-    int height)			/* height of entry */
-{
-    int imageWidth, imageHeight, textWidth = 0, textHeight = 0;
-    int indicatorSpace =  mePtr->indicatorSpace;
-    int leftEdge = x + indicatorSpace;
-    int haveImage = 0, haveText = 0;
-    int imageXOffset = 0, imageYOffset = 0;
-    int textXOffset = 0, textYOffset = 0;
-    Pixmap bitmap = (Pixmap) NULL;
-    Tcl_DString itemTextDString;
-
-    /*
-     * Work out what we will need to draw first.
-     */
-
-    if (mePtr->image != NULL) {
-	Tk_SizeOfImage(mePtr->image, &imageWidth, &imageHeight);
-	haveImage = 1;
-    } else if (mePtr->bitmapPtr != NULL) {
-	bitmap = Tk_GetBitmapFromObj(menuPtr->tkwin, mePtr->bitmapPtr);
-	Tk_SizeOfBitmap(menuPtr->display, bitmap, &imageWidth, &imageHeight);
-	haveImage = 1;
-    }
-    if (!haveImage || (mePtr->compound != COMPOUND_NONE)) {
-	if (mePtr->labelLength > 0) {
-	    GetEntryText(mePtr, &itemTextDString);
-	    if (mePtr->compound != COMPOUND_NONE) {
-		textWidth = Tk_TextWidth(tkfont,
-			Tcl_DStringValue(&itemTextDString),
-			Tcl_DStringLength(&itemTextDString)) +
-			menuTextLeadingEdgeMargin + menuTextTrailingEdgeMargin;
-		textHeight = fmPtr->linespace;
-	    }
-	    haveText = 1;
-	}
-    }
-
-    /*
-     * Now work out what the relative positions are.
-     */
-
-    if (haveImage && haveText && (mePtr->compound != COMPOUND_NONE)) {
-	int fullWidth = (imageWidth > textWidth ? imageWidth : textWidth);
-
-	switch ((enum compound) mePtr->compound) {
-	case COMPOUND_TOP:
-	    textXOffset = (fullWidth - textWidth)/2;
-	    textYOffset = imageHeight/2 + 2;
-	    imageXOffset = (fullWidth - imageWidth)/2;
-	    imageYOffset = -textHeight/2;
-	    break;
-	case COMPOUND_BOTTOM:
-	    textXOffset = (fullWidth - textWidth)/2;
-	    textYOffset = -imageHeight/2;
-	    imageXOffset = (fullWidth - imageWidth)/2;
-	    imageYOffset = textHeight/2 + 2;
-	    break;
-	case COMPOUND_LEFT:
-	    /*
-	     * Position image in the indicator space to the left of the
-	     * entries, unless this entry is a radio|check button because then
-	     * the indicator space will be used.
-	     */
-
-	    textXOffset = imageWidth + 2 - menuTextLeadingEdgeMargin;
-	    if ((mePtr->type != CHECK_BUTTON_ENTRY)
-		    && (mePtr->type != RADIO_BUTTON_ENTRY)) {
-		textXOffset -= indicatorSpace;
-		imageXOffset = -indicatorSpace;
-	    }
-	    if (textXOffset < 0) {
-		textXOffset = 0;
-	    }
-	    break;
-	case COMPOUND_RIGHT:
-	    imageXOffset = textWidth + 2 - menuTextTrailingEdgeMargin;
-	    break;
-	case COMPOUND_CENTER:
-	    textXOffset = (fullWidth - textWidth)/2;
-	    imageXOffset = (fullWidth - imageWidth)/2;
-	    break;
-	case COMPOUND_NONE:
-	    /*
-	     * Never reached.
-	     */
-	    break;
-	}
-    }
-
-    /*
-     * Draw label and/or bitmap or image for entry.
-     */
-
-    if (mePtr->image != NULL) {
-	if ((mePtr->selectImage != NULL)
-		&& (mePtr->entryFlags & ENTRY_SELECTED)) {
-	    Tk_RedrawImage(mePtr->selectImage, 0, 0, imageWidth, imageHeight,
-		    d, leftEdge + imageXOffset,
-		    y + (mePtr->height - imageHeight)/2 + imageYOffset);
-	} else {
-	    Tk_RedrawImage(mePtr->image, 0, 0, imageWidth, imageHeight,
-		    d, leftEdge + imageXOffset,
-		    y + (mePtr->height - imageHeight)/2 + imageYOffset);
-	}
-    } else if (mePtr->bitmapPtr != NULL) {
-	XCopyPlane(menuPtr->display, bitmap, d, gc, 0, 0, imageWidth,
-		imageHeight, leftEdge + imageXOffset,
-		y + (mePtr->height - imageHeight)/2  + imageYOffset, 1);
-    }
-    if (haveText) {
-	int baseline = y + (height + fmPtr->ascent - fmPtr->descent)/2;
-
-	Tk_DrawChars(menuPtr->display, d, gc, tkfont,
-		Tcl_DStringValue(&itemTextDString),
-		Tcl_DStringLength(&itemTextDString),
-		leftEdge + menuTextLeadingEdgeMargin + textXOffset,
-		baseline + textYOffset);
-	Tcl_DStringFree(&itemTextDString);
-    }
-
-    if (mePtr->state == ENTRY_DISABLED) {
-	if (menuPtr->disabledFgPtr == NULL) {
-	    /* XFillRectangle(menuPtr->display, d, menuPtr->disabledGC, x, y,
-		    width, height); */
-	} else if ((mePtr->image != NULL)
-		&& (menuPtr->disabledImageGC != None)) {
-	    XFillRectangle(menuPtr->display, d, menuPtr->disabledImageGC,
-		    leftEdge + imageXOffset,
-		    y + (mePtr->height - imageHeight)/2 + imageYOffset,
-		    imageWidth, imageHeight);
-	}
-    }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * DrawMenuEntryBackground --
- *
- *	This procedure draws the background part of a menu entry. Under
- *	Appearance, we only draw the background if the entry's border is set,
- *	we DO NOT inherit it from the menu...
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Commands are output to X to display the menu in its current mode.
- *
- *----------------------------------------------------------------------
- */
-
-void
-DrawMenuEntryBackground(
-    TkMenu *menuPtr,		/* The menu we are drawing. */
-    TkMenuEntry *mePtr,		/* The entry we are drawing. */
-    Drawable d,			/* What we are drawing into */
-    Tk_3DBorder activeBorder,	/* Border for active items */
-    Tk_3DBorder bgBorder,	/* Border for the background */
-    int x,			/* left edge */
-    int y,			/* top edge */
-    int width,			/* width of rectangle to draw */
-    int height)			/* height of rectangle to draw */
-{
-    if ((menuPtr->menuType == TEAROFF_MENU)
-	    || ((mePtr->state == ENTRY_ACTIVE)
-		    && (mePtr->activeBorderPtr != None))
-	    || ((mePtr->state != ENTRY_ACTIVE) && (mePtr->borderPtr != None))) {
-	if (mePtr->state == ENTRY_ACTIVE) {
-	    bgBorder = activeBorder;
-	}
-	Tk_Fill3DRectangle(menuPtr->tkwin, d, bgBorder,
-		x, y, width, height, 0, TK_RELIEF_FLAT);
-    }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * GetMenuLabelGeometry --
- *
- *	Figures out the size of the label portion of a menu item.
- *
- * Results:
- *	widthPtr and heightPtr are filled in with the correct geometry
- *	information.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-void
-GetMenuLabelGeometry(
-    TkMenuEntry *mePtr,		/* The entry we are computing */
-    Tk_Font tkfont,		/* The precalculated font */
-    const Tk_FontMetrics *fmPtr,/* The precalculated metrics */
-    int *widthPtr,		/* The resulting width of the label portion */
-    int *heightPtr)		/* The resulting height of the label portion */
-{
-    TkMenu *menuPtr = mePtr->menuPtr;
-    int haveImage = 0, tornOff = (menuPtr->menuType == TEAROFF_MENU);
-#ifdef USE_TK_MDEF
-    const int useMDEF = ((MacMenu *) menuPtr->platformData)->useMDEF;
-#endif
-
-    if (mePtr->image != NULL && (useMDEF || tornOff)) {
-	Tk_SizeOfImage(mePtr->image, widthPtr, heightPtr);
-	haveImage = 1;
-    } else if (mePtr->bitmapPtr != NULL && (useMDEF || tornOff)) {
-	Pixmap bitmap = Tk_GetBitmapFromObj(menuPtr->tkwin, mePtr->bitmapPtr);
-	Tk_SizeOfBitmap(menuPtr->display, bitmap, widthPtr, heightPtr);
-	haveImage = 1;
-    }
-    if (!haveImage || (mePtr->compound != COMPOUND_NONE)) {
-	int textWidth = 0, textHeight = fmPtr->linespace;
-
-	if (mePtr->labelPtr != NULL) {
-	    Tcl_DString itemTextDString;
-
-	    GetEntryText(mePtr, &itemTextDString);
-	    textWidth = Tk_TextWidth(tkfont,
-		    Tcl_DStringValue(&itemTextDString),
-		    Tcl_DStringLength(&itemTextDString)) +
-		    menuTextLeadingEdgeMargin + menuTextTrailingEdgeMargin;
-	    Tcl_DStringFree(&itemTextDString);
-
-	    if (haveImage && (mePtr->compound != COMPOUND_NONE)) {
-		switch ((enum compound) mePtr->compound) {
-		    int margin;
-
-		case COMPOUND_TOP:
-		case COMPOUND_BOTTOM:
-		    if (textWidth > *widthPtr) {
-			*widthPtr = textWidth;
-		    }
-		    *heightPtr += textHeight + 2;
-		    break;
-		case COMPOUND_LEFT:
-		    margin = *widthPtr + 2;
-		    if (margin > menuTextLeadingEdgeMargin) {
-			margin = menuTextLeadingEdgeMargin;
-		    }
-		    *widthPtr += textWidth + 2 - margin;
-		    if (textHeight > *heightPtr) {
-			*heightPtr = textHeight;
-		    }
-		    break;
-		case COMPOUND_RIGHT:
-		    margin = menuTextTrailingEdgeMargin;
-		    *widthPtr += textWidth + 2 - margin;
-		    if (textHeight > *heightPtr) {
-			*heightPtr = textHeight;
-		    }
-		    break;
-		case COMPOUND_CENTER:
-		    if (textWidth > *widthPtr) {
-			*widthPtr = textWidth;
-		    }
-		    if (textHeight > *heightPtr) {
-			*heightPtr = textHeight;
-		    }
-		    break;
-		case COMPOUND_NONE:
-		    /*
-		     * Never reached.
-		     */
-		    break;
-		}
-		goto labelGeomDone;
-	    }
-	}
-	*widthPtr = textWidth;
-	*heightPtr = textHeight;
-    }
-
-  labelGeomDone:
-    *heightPtr += menuItemExtraHeight;
-    *widthPtr += menuItemExtraWidth;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * TkMacOSXGenerateParentMenuSelectEvent --
- *
- *	Respond to a hierarchical menu being opened.
- *
- * Results:
- *	True if event(s) are generated - false otherwise.
- *
- * Side effects:
- *	Places a virtual event on the event queue.
- *
- *----------------------------------------------------------------------
- */
-
-int
-TkMacOSXGenerateParentMenuSelectEvent(
-    MenuRef menu)
-{
-    TkMenu *menuPtr = MenuPtrForMenuRef(menu);
-
-    if (menuPtr) {
-	TkMenuEntry *parentEntryPtr = GetParentMenuEntry(menuPtr);
-
-	if (parentEntryPtr && (menuPtr = parentEntryPtr->menuPtr)) {
-	    TkActivateMenuEntry(menuPtr, parentEntryPtr->index);
-	    MenuSelectEvent(menuPtr);
-	    Tcl_ServiceAll();
-	    return true;
-	}
-    }
-    return false;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * TkMacOSXGenerateMenuSelectEvent --
+ * GenerateMenuSelectEvent --
  *
  *	Respond to a menu item being selected.
  *
@@ -3759,27 +1137,26 @@ TkMacOSXGenerateParentMenuSelectEvent(
  */
 
 int
-TkMacOSXGenerateMenuSelectEvent(
-    MenuRef menu,
-    MenuItemIndex index)
+GenerateMenuSelectEvent(
+    TKMenu *menu,
+    NSMenuItem *menuItem)
 {
-    TkMenu *menuPtr = MenuPtrForMenuRef(menu);
-    int item = index - 1;
+    TkMenu *menuPtr = [menu tkMenu];
 
     if (menuPtr) {
-	if (item < 0 || item >= menuPtr->numEntries ||
-		(menuPtr->entries[item])->state == ENTRY_DISABLED) {
+	int index = [menu tkIndexOfItem:menuItem];
+	if (index < 0 || index >= menuPtr->numEntries ||
+		(menuPtr->entries[index])->state == ENTRY_DISABLED) {
 	    TkActivateMenuEntry(menuPtr, -1);
 	} else {
-	    TkActivateMenuEntry(menuPtr, item);
+	    TkActivateMenuEntry(menuPtr, index);
 	    MenuSelectEvent(menuPtr);
-	    Tcl_ServiceAll();
 	    return true;
 	}
     }
     return false;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -3805,46 +1182,22 @@ MenuSelectEvent(
 
     bzero(&event, sizeof(XVirtualEvent));
     event.type = VirtualEvent;
-    event.serial = menuPtr->display->request;
+    event.serial = LastKnownRequestProcessed(menuPtr->display);
     event.send_event = false;
     event.display = menuPtr->display;
-    Tk_MakeWindowExist(menuPtr->tkwin);
     event.event = Tk_WindowId(menuPtr->tkwin);
     event.root = XRootWindow(menuPtr->display, 0);
     event.subwindow = None;
     event.time = TkpGetMS();
-
     XQueryPointer(NULL, None, NULL, NULL, &event.x_root, &event.y_root, NULL,
 	    NULL, &event.state);
     event.same_screen = true;
     event.name = Tk_GetUid("MenuSelect");
-    Tk_QueueWindowEvent((XEvent *) &event, TCL_QUEUE_TAIL);
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * TkMacOSXClearActiveMenu --
- *
- *	Clears Tk's active entry for the given MenuRef.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Generates <<MenuSelect>> virtual events.
- *
- *----------------------------------------------------------------------
- */
-
-void
-TkMacOSXClearActiveMenu(
-    MenuRef menu)
-{
-    TkMenu *menuPtr = MenuPtrForMenuRef(menu);
-
-    if (menuPtr) {
-	RecursivelyClearActiveMenu(menuPtr);
+    Tk_MakeWindowExist(menuPtr->tkwin);
+    if (Tcl_GetServiceMode() != TCL_SERVICE_NONE) {
+	Tk_HandleEvent((XEvent *) &event);
+    } else {
+	Tk_QueueWindowEvent((XEvent *) &event, TCL_QUEUE_TAIL);
     }
 }
 
@@ -3902,20 +1255,11 @@ RecursivelyClearActiveMenu(
 void
 TkMacOSXClearMenubarActive(void)
 {
-    TkMenuReferences *menuBarRefPtr;
-
-    if (currentMenuBarName != NULL) {
-	menuBarRefPtr = TkFindMenuReferences(currentMenuBarInterp,
-		currentMenuBarName);
-	if ((menuBarRefPtr != NULL) && (menuBarRefPtr->menuPtr != NULL)) {
-	    TkMenu *menuPtr;
-
-	    for (menuPtr = menuBarRefPtr->menuPtr->masterMenuPtr;
-		    menuPtr != NULL; menuPtr = menuPtr->nextInstancePtr) {
-		if (menuPtr->menuType == MENUBAR) {
-		    RecursivelyClearActiveMenu(menuPtr);
-		}
-	    }
+    NSMenu *mainMenu = [NSApp mainMenu];
+    if (mainMenu && [mainMenu isKindOfClass:[TKMenu class]]) {
+	TkMenu *menuPtr = [(TKMenu *)mainMenu tkMenu];
+	if (menuPtr && menuPtr->numEntries && menuPtr->entries) {
+	    RecursivelyClearActiveMenu(menuPtr);
 	}
     }
 }
@@ -3923,29 +1267,25 @@ TkMacOSXClearMenubarActive(void)
 /*
  *----------------------------------------------------------------------
  *
- * TkpMenuNotifyToplevelCreate --
+ * Tk_MacOSXTurnOffMenus --
  *
- *	This routine reconfigures the menu and the clones indicated by
- *	menuName becuase a toplevel has been created and any system menus need
- *	to be created. Only applicable to Windows.
+ *	Turns off all the menu drawing code. This is more than just disabling
+ *	the "menu" command, this means that Tk will NEVER touch the menubar.
+ *	It is needed in the Plugin, where Tk does not own the menubar.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	An idle handler is set up to do the reconfiguration.
+ *	A flag is set which will disable all menu drawing.
  *
  *----------------------------------------------------------------------
  */
 
 void
-TkpMenuNotifyToplevelCreate(
-    Tcl_Interp *interp,		/* The interp the menu lives in. */
-    char *menuName)		/* The name of the menu to reconfigure. */
+Tk_MacOSXTurnOffMenus(void)
 {
-    /*
-     * Nothing to do.
-     */
+    gNoTkMenus = 1;
 }
 
 /*
@@ -3967,58 +1307,37 @@ TkpMenuNotifyToplevelCreate(
 void
 TkpMenuInit(void)
 {
-    MenuSymbol *ms = menuSymbols;
-    CFStringRef cfStr;
+    TkColor *tkColPtr;
 
-    lastMenuID = 256;
-    Tcl_InitHashTable(&commandTable, TCL_ONE_WORD_KEYS);
-    currentMenuBarOwner = NULL;
-    currentAppleMenuID = 0;
-    currentHelpMenuID = 0;
-    currentMenuBarInterp = NULL;
-    currentMenuBarName = NULL;
-    windowListPtr = NULL;
+    NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
+#define observe(n, s) [nc addObserver:NSApp selector:@selector(s) name:(n) object:nil]
+    observe(NSMenuDidBeginTrackingNotification, menuBeginTracking:);
+    observe(NSMenuDidEndTrackingNotification, menuEndTracking:);
+#undef observe
 
-#ifdef USE_TK_MDEF
-    tkThemeMenuItemDrawingUPP
-	    = NewMenuItemDrawingUPP(ThemeMenuItemDrawingProc);
-    useMDEFVar = Tcl_NewStringObj("::tk::mac::useCustomMDEF", -1);
-    macMDEFDrawable.winPtr = NULL;
-    macMDEFDrawable.xOff = 0;
-    macMDEFDrawable.yOff = 0;
-    macMDEFDrawable.visRgn = NULL;
-    macMDEFDrawable.aboveVisRgn = NULL;
-    macMDEFDrawable.drawRect = CGRectNull;
-    macMDEFDrawable.referenceCount = 0;
-    macMDEFDrawable.toplevel = NULL;
-    macMDEFDrawable.flags = 0;
-    macMDEFDrawable.grafPtr = NULL;
-    macMDEFDrawable.context = NULL;
-    macMDEFDrawable.size = CGSizeZero;
-#endif
+    [NSMenuItem setUsesUserKeyEquivalents:NO];
+    tkColPtr = TkpGetColor(None, DEF_MENU_BG_COLOR);
+    defaultBg = tkColPtr->color.pixel;
+    ckfree((char *) tkColPtr);
+    tkColPtr = TkpGetColor(None, DEF_MENU_FG);
+    defaultFg = tkColPtr->color.pixel;
+    ckfree((char *) tkColPtr);
 
     ChkErr(GetThemeMetric, kThemeMetricMenuMarkColumnWidth,
 	    &menuMarkColumnWidth);
-    ChkErr(GetThemeMetric, kThemeMetricMenuMarkIndent, &menuMarkIndent);
     ChkErr(GetThemeMetric, kThemeMetricMenuTextLeadingEdgeMargin,
 	    &menuTextLeadingEdgeMargin);
     ChkErr(GetThemeMetric, kThemeMetricMenuTextTrailingEdgeMargin,
 	    &menuTextTrailingEdgeMargin);
+    ChkErr(GetThemeMetric, kThemeMetricMenuIconTrailingEdgeMargin,
+	    &menuIconTrailingEdgeMargin);
     ChkErr(GetThemeMenuItemExtra, kThemeMenuItemPlain, &menuItemExtraHeight,
 	    &menuItemExtraWidth);
     ChkErr(GetThemeMenuSeparatorHeight, &menuSeparatorHeight);
-
-    while (ms->unicode) {
-	ms->utfLen = Tcl_UniCharToUtf(ms->unicode, ms->utf);
-	ms->utf[ms->utfLen] = 0;
-	cfStr = CFStringCreateWithCharacters(NULL, &ms->unicode, 1);
-	if (cfStr) {
-	    ms->width = MeasureThemeText(cfStr, kThemeMenuItemCmdKeyFont);
-	    CFRelease(cfStr);
-	}
-	ms++;
-    }
 }
+
+#pragma mark -
+#pragma mark NOPs
 
 /*
  *----------------------------------------------------------------------
@@ -4047,702 +1366,273 @@ TkpMenuThreadInit(void)
 /*
  *----------------------------------------------------------------------
  *
- * TkpPreprocessMacMenu --
+ * TkpMenuNotifyToplevelCreate --
  *
- *    Handle preprocessing of menubar if it exists.
+ *	This routine reconfigures the menu and the clones indicated by
+ *	menuName becuase a toplevel has been created and any system menus need
+ *	to be created. Only applicable to Windows.
  *
  * Results:
- *    None.
+ *	None.
  *
  * Side effects:
- *    All post commands for the current menubar get executed.
+ *	An idle handler is set up to do the reconfiguration.
  *
  *----------------------------------------------------------------------
  */
 
 void
-TkMacOSXPreprocessMenu(void)
+TkpMenuNotifyToplevelCreate(
+    Tcl_Interp *interp,		/* The interp the menu lives in. */
+    char *menuName)		/* The name of the menu to reconfigure. */
 {
-    if ((currentMenuBarName != NULL) && (currentMenuBarInterp != NULL)) {
-	TkMenuReferences *mbRefPtr =
-		TkFindMenuReferences(currentMenuBarInterp,currentMenuBarName);
+    /*
+     * Nothing to do.
+     */
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * TkpInitializeMenuBindings --
+ *
+ *	For every interp, initializes the bindings for Windows menus. Does
+ *	nothing on Mac or XWindows.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	C-level bindings are setup for the interp which will handle Alt-key
+ *	sequences for menus without beeping or interfering with user-defined
+ *	Alt-key bindings.
+ *
+ *--------------------------------------------------------------
+ */
 
-	if ((mbRefPtr != NULL) && (mbRefPtr->menuPtr != NULL)) {
-	    int code;
+void
+TkpInitializeMenuBindings(
+    Tcl_Interp *interp,		/* The interpreter to set. */
+    Tk_BindingTable bindingTable)
+				/* The table to add to. */
+{
+    /*
+     * Nothing to do.
+     */
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * TkpComputeMenubarGeometry --
+ *
+ *	This procedure is invoked to recompute the size and layout of a menu
+ *	that is a menubar clone.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Fields of menu entries are changed to reflect their current positions,
+ *	and the size of the menu window itself may be changed.
+ *
+ *--------------------------------------------------------------
+ */
 
-	    Tcl_Preserve(currentMenuBarInterp);
-	    code = TkPreprocessMenu(mbRefPtr->menuPtr->masterMenuPtr);
-	    if ((code != TCL_OK) && (code != TCL_CONTINUE)
-		    && (code != TCL_BREAK)) {
-		Tcl_AddErrorInfo(currentMenuBarInterp,
-			"\n    (menu preprocess)");
-		Tcl_BackgroundException(currentMenuBarInterp, code);
-	    }
-	    Tcl_Release(currentMenuBarInterp);
-	}
-    }
+void
+TkpComputeMenubarGeometry(
+    TkMenu *menuPtr)		/* Structure describing menu. */
+{
+    TkpComputeStandardMenuGeometry(menuPtr);
 }
 
-#ifdef USE_TK_MDEF
-#pragma mark MDEF
+
 /*
  *----------------------------------------------------------------------
  *
- * MenuDefProc --
+ * TkpDrawMenuEntry --
  *
- *	This routine is the MDEF handler for Tk. It receives all messages for
- *	the menu and dispatches them.
+ *	Draws the given menu entry at the given coordinates with the given
+ *	attributes.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	This routine causes menus to be drawn and will certainly allocate
- *	memory as a result. Also, the menu can scroll up and down, and various
- *	other interface actions can take place.
+ *	X Server commands are executed to display the menu entry.
  *
  *----------------------------------------------------------------------
  */
 
 void
-MenuDefProc(
-    SInt16 message,		/* What action are we taking? */
-    MenuRef menu,		/* The menu we are working with */
-    Rect *menuRectPtr,		/* A pointer to the rect for the whole
-				 * menu. */
-    Point hitPt,		/* Where the mouse was clicked for the
-				 * appropriate messages. */
-    SInt16 *whichItem)		/* Output result. Which item was hit by the
-				 * user? */
+TkpDrawMenuEntry(
+    TkMenuEntry *mePtr,		/* The entry to draw */
+    Drawable d,			/* What to draw into */
+    Tk_Font tkfont,		/* Precalculated font for menu */
+    const Tk_FontMetrics *menuMetricsPtr,
+				/* Precalculated metrics for menu */
+    int x,			/* X-coordinate of topleft of entry */
+    int y,			/* Y-coordinate of topleft of entry */
+    int width,			/* Width of the entry rectangle */
+    int height,			/* Height of the current rectangle */
+    int strictMotif,		/* Boolean flag */
+    int drawArrow)		/* Whether or not to draw the cascade
+				 * arrow for cascade items. Only applies
+				 * to Windows. */
 {
-    TkMenu *menuPtr;
-    Tcl_HashEntry *commandEntryPtr;
-    MenuID menuID;
-
-    menuID = GetMenuID(menu);
-    commandEntryPtr = Tcl_FindHashEntry(&commandTable, (char*)(intptr_t)menuID);
-    if (!commandEntryPtr) return;
-    menuPtr = Tcl_GetHashValue(commandEntryPtr);
-
-    switch (message) {
-    case kMenuInitMsg:
-	*whichItem = noErr;
-	break;
-    case kMenuDisposeMsg:
-	break;
-    case kMenuHiliteItemMsg:
-	HandleMenuHiliteMsg(menu, menuRectPtr, hitPt, whichItem, menuPtr);
-	break;
-    case kMenuCalcItemMsg:
-	HandleMenuCalcItemMsg(menu, menuRectPtr, hitPt, whichItem, menuPtr);
-	break;
-    case kMenuDrawItemsMsg:
-#ifdef TK_MAC_DEBUG_MENUS
-	TkMacOSXDbgMsg("MDEF: DrawItemsMsg");
-#endif
-	/*
-	 * We do nothing here, because we don't support the Menu Managers
-	 * dynamic item groups
-	 */
-
-	break;
-    case kMenuThemeSavvyMsg:
-	*whichItem = kThemeSavvyMenuResponse;
-	break;
-    case kMenuSizeMsg:
-#ifdef TK_MAC_DEBUG_MENUS
-	TkMacOSXDbgMsg("MDEF: SizeMsg %d, %d", hitPt.h, hitPt.v);
-#endif
-	SetMenuWidth(menu, hitPt.h < menuPtr->totalWidth ? hitPt.h :
-		menuPtr->totalWidth);
-	SetMenuHeight(menu, hitPt.v < menuPtr->totalHeight ? hitPt.v :
-		menuPtr->totalHeight);
-	break;
-    case kMenuDrawMsg:
-	HandleMenuDrawMsg(menu, menuRectPtr, hitPt, whichItem, menuPtr);
-	break;
-    case kMenuFindItemMsg:
-	HandleMenuFindItemMsg(menu, menuRectPtr, hitPt, whichItem, menuPtr);
-	break;
-    case kMenuPopUpMsg:
-	HandleMenuPopUpMsg(menu, menuRectPtr, hitPt, whichItem, menuPtr);
-	break;
-    }
 }
+
+#pragma mark Obsolete
 
 /*
  *----------------------------------------------------------------------
  *
- * HandleMenuHiliteMsg --
+ * TkMacOSXPreprocessMenu --
  *
- *	Handles the MenuDefProc's hilite message.
+ *    Handle preprocessing of menubar if it exists.
  *
  * Results:
- *	A menu entry is drawn
+ *    None.
  *
  * Side effects:
- *	None
+ *    All post commands for the current menubar get executed.
  *
  *----------------------------------------------------------------------
  */
 
 void
-HandleMenuHiliteMsg(
-    MenuRef menu,
-    Rect *menuRectPtr,
-    Point hitPt,
-    SInt16 *whichItem,
-    TkMenu *menuPtr)
+TkMacOSXPreprocessMenu(void)
 {
-    OSStatus err;
-    Tk_Font tkfont;
-    Tk_FontMetrics fontMetrics;
-    MDEFHiliteItemData *hidPtr = (MDEFHiliteItemData *) whichItem;
-    int oldItem = hidPtr->previousItem - 1;
-    int newItem = hidPtr->newItem - 1;
-    MenuTrackingData mtd, *mtdPtr = &mtd;
-
-#ifdef TK_MAC_DEBUG_MENUS
-    TkMacOSXDbgMsg("MDEF: HiliteMsg %d -> %d", hidPtr->previousItem,
-	    hidPtr->newItem);
-#endif
-    GetPort(&macMDEFDrawable.grafPtr);
-    macMDEFDrawable.context = (CGContextRef) hidPtr->context;
-
-    err = ChkErr(GetMenuTrackingData, menu, mtdPtr);
-    if (err != noErr) {
-	return;
-    }
-
-    tkfont = Tk_GetFontFromObj(menuPtr->tkwin, menuPtr->fontPtr);
-    Tk_GetFontMetrics(tkfont, &fontMetrics);
-    if (oldItem >= 0) {
-	AppearanceEntryDrawWrapper(menuPtr->entries[oldItem], menuRectPtr,
-		mtdPtr, (Drawable) &macMDEFDrawable, &fontMetrics, tkfont, 1);
-    }
-    if (newItem >= 0) {
-	AppearanceEntryDrawWrapper(menuPtr->entries[newItem], menuRectPtr,
-		mtdPtr, (Drawable) &macMDEFDrawable, &fontMetrics, tkfont, 0);
-    }
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * HandleMenuDrawMsg --
+ * TkMacOSXUseID --
  *
- *	Handles the MenuDefProc's draw message.
+ *	Take the ID out of the available list for new menus. Used by the
+ *	default menu bar's menus so that they do not get created at the tk
+ *	level. See TkMacOSXGetNewMenuID for more information.
  *
  * Results:
- *	A menu entry is drawn
+ *	Returns TCL_OK if the id was not in use. Returns TCL_ERROR if the id
+ *	was in use.
  *
  * Side effects:
- *	None
+ *	A hash table entry in the command table is created with a NULL value.
  *
  *----------------------------------------------------------------------
  */
 
-void
-HandleMenuDrawMsg(
-    MenuRef menu,
-    Rect *menuRectPtr,
-    Point hitPt,
-    SInt16 *whichItem,
-    TkMenu *menuPtr)
+int
+TkMacOSXUseMenuID(
+    short macID)		/* The id to take out of the table */
 {
-    Tk_Font menuFont;
-    Tk_FontMetrics fontMetrics;
-    TkMenuEntry *mePtr;
-    int i;
-    Rect menuClipRect, bounds;
-    MDEFDrawData *ddPtr = (MDEFDrawData *) whichItem;
-    MenuTrackingData *mtdPtr = &(ddPtr->trackingData);
-    TkWindow *winPtr = (TkWindow *) menuPtr->tkwin;
-
-    GetPort(&macMDEFDrawable.grafPtr);
-    GetPortBounds(macMDEFDrawable.grafPtr, &bounds);
-    macMDEFDrawable.context = (CGContextRef) ddPtr->context;
-#ifdef TK_MAC_DEBUG_MENUS
-    TkMacOSXDbgMsg("MDEF: DrawMsg %d - %d; %d - %d", menuRectPtr->top,
-	    menuRectPtr->bottom, bounds.top, bounds.bottom);
-#endif
-    winPtr->changes.x = menuRectPtr->left;
-    winPtr->changes.y = menuRectPtr->top;
-    winPtr->changes.width = menuRectPtr->right - menuRectPtr->left;
-    winPtr->changes.height = menuRectPtr->bottom - menuRectPtr->top;
-    TkpClipDrawableToRect(menuPtr->display, (Drawable) &macMDEFDrawable,
-	    0, 0, -1, -1);
-#if 0
-    if (menuPtr->menuRefPtr->topLevelListPtr != NULL) {
-	menuType = kThemeMenuTypePullDown;
-    } else if (menuPtr->menuRefPtr->parentEntryPtr != NULL) {
-	menuType = kThemeMenuTypeHierarchical;
-    } else {
-	menuType = kThemeMenuTypePopUp;
-    }
-#endif
-    DrawMenuBackground(menuPtr, menuRectPtr, (Drawable) &macMDEFDrawable);
-    menuFont = Tk_GetFontFromObj(menuPtr->tkwin, menuPtr->fontPtr);
-    Tk_GetFontMetrics(menuFont, &fontMetrics);
-    menuClipRect = *menuRectPtr;
-    mtdPtr->virtualMenuBottom = mtdPtr->virtualMenuTop + menuPtr->totalHeight;
-
-    /*
-     * Next, figure out scrolling information.
-     */
-
-    if ((menuRectPtr->bottom - menuRectPtr->top) < menuPtr->totalHeight) {
-	short arrowHeight = fontMetrics.linespace + 1;
-	Rect arrowRect, eraseRect;
-	ThemeMenuState menuState = IsMenuItemEnabled(menu, 0) ?
-		kThemeMenuActive : kThemeMenuDisabled;
-
-	if (mtdPtr->virtualMenuTop < menuRectPtr->top) {
-	    arrowRect = bounds;
-	    /*arrowRect.top += 1;*/
-	    arrowRect.bottom = arrowRect.top + arrowHeight;
-	    eraseRect = arrowRect;
-	    eraseRect.top = menuRectPtr->top;
-	    menuClipRect.top = arrowRect.bottom;
-	    ChkErr(EraseMenuBackground, menu, &eraseRect,
-		    macMDEFDrawable.context);
-	    ChkErr(DrawThemeMenuItem, menuRectPtr, &arrowRect,
-		    mtdPtr->virtualMenuTop, mtdPtr->virtualMenuBottom,
-		    menuState, kThemeMenuItemScrollUpArrow, NULL, 0);
-#ifdef TK_MAC_DEBUG_MENUS
-	    TkMacOSXDbgMsg("upArrow:   %d - %d, %d - %d", arrowRect.top,
-		    arrowRect.bottom, arrowRect.left, arrowRect.right);
-#endif
-	}
-	if (mtdPtr->virtualMenuBottom > menuRectPtr->bottom) {
-	    arrowRect = bounds;
-	    arrowRect.bottom -= 1;
-	    arrowRect.top = arrowRect.bottom - arrowHeight;
-	    eraseRect = arrowRect;
-	    eraseRect.bottom = menuRectPtr->bottom;
-	    menuClipRect.bottom = arrowRect.top;
-	    ChkErr(EraseMenuBackground, menu, &eraseRect,
-		    macMDEFDrawable.context);
-	    ChkErr(DrawThemeMenuItem, menuRectPtr, &arrowRect,
-		    mtdPtr->virtualMenuTop, mtdPtr->virtualMenuBottom,
-		    menuState, kThemeMenuItemScrollDownArrow, NULL, 0);
-#ifdef TK_MAC_DEBUG_MENUS
-	    TkMacOSXDbgMsg("downArrow: %d - %d, %d - %d", arrowRect.top,
-		    arrowRect.bottom, arrowRect.left, arrowRect.right);
-#endif
-	}
-	TkpClipDrawableToRect(menuPtr->display, (Drawable) &macMDEFDrawable,
-		menuClipRect.left, menuClipRect.top, menuClipRect.right -
-		menuClipRect.left, menuClipRect.bottom - menuClipRect.top);
-    }
-
-    /*
-     * Now, actually draw the menu. Don't draw entries that are higher than
-     * the top arrow, and don't draw entries that are lower than the bottom.
-     */
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TkMacOSXDispatchMenuEvent --
+ *
+ *	Given a menu id and an item, dispatches the command associated with
+ *	it.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Commands for the event are scheduled for execution at idle time.
+ *
+ *----------------------------------------------------------------------
+ */
 
-    for (i = 0; i < menuPtr->numEntries; i++) {
-	mePtr = menuPtr->entries[i];
-	if (mtdPtr->virtualMenuTop + mePtr->y + mePtr->height <
-		menuClipRect.top || mtdPtr->virtualMenuTop + mePtr->y >
-		menuClipRect.bottom) {
-	    continue;
-	}
-	AppearanceEntryDrawWrapper(mePtr, menuRectPtr, mtdPtr,
-		(Drawable) &macMDEFDrawable, &fontMetrics, menuFont, 0);
-    }
-    MDEFScrollFlag = 1;
+int
+TkMacOSXDispatchMenuEvent(
+    int menuID,			/* The menu id of the menu we are invoking */
+    int index)			/* The one-based index of the item that was
+				 * selected. */
+{
+    return TCL_ERROR;
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * HandleMenuFindItemMsg --
+ * TkMacOSXHandleTearoffMenu() --
  *
- *	Handles the MenuDefProc's FindItems message. We have to respond by
- *	filling in the itemSelected, itemUnderMouse and itemRect fields. This
- *	is also the time to scroll the menu if it is too long to fit on the
- *	screen.
+ *	This routine sees if the MDEF has set a menu and a mouse position for
+ *	tearing off and makes a tearoff menu if it has.
  *
  * Results:
- *	The Menu system is informed of the selected item & the item under the
- *	mouse.
+ *	menuPtr->interp will have the result of the tearoff command.
  *
  * Side effects:
- *	The menu might get scrolled.
+ *	A new tearoff menu is created if it is supposed to be.
  *
  *----------------------------------------------------------------------
  */
 
 void
-HandleMenuFindItemMsg(
-    MenuRef menu,
-    Rect *menuRectPtr,
-    Point hitPt,
-    SInt16 *whichItem,
-    TkMenu *menuPtr)
+TkMacOSXHandleTearoffMenu(void)
 {
-    Tk_Font menuFont;
-    Tk_FontMetrics fontMetrics;
-    TkMenuEntry *mePtr;
-    int i, newItem = -1, itemUnderMouse = -1;
-    Rect itemRect = {0, 0, 0, 0}, menuClipRect, bounds;
-    int hasTopScroll, hasBottomScroll;
-    MDEFFindItemData *fiPtr = (MDEFFindItemData *)whichItem;
-    MenuTrackingData *mtdPtr = &(fiPtr->trackingData), topMtd;
-    enum {
-	DONT_SCROLL, DOWN_SCROLL, UP_SCROLL
-    } scrollDirection;
-    short arrowHeight;
-
-#ifdef TK_MAC_DEBUG_MENUS
-    static Point lastHitPt = {0, 0};
-
-    if (hitPt.h != lastHitPt.h || hitPt.v != lastHitPt.v) {
-	lastHitPt = hitPt;
-	TkMacOSXDbgMsg("MDEF: FindItemMsg: %d, %d", hitPt.h, hitPt.v);
-    }
-#endif
-
-    GetPort(&macMDEFDrawable.grafPtr);
-    GetPortBounds(macMDEFDrawable.grafPtr, &bounds);
-    macMDEFDrawable.context = (CGContextRef) fiPtr->context;
-
-    /*
-     * Now we need to take care of scrolling the menu.
-     */
-
-    menuFont = Tk_GetFontFromObj(menuPtr->tkwin, menuPtr->fontPtr);
-    Tk_GetFontMetrics(menuFont, &fontMetrics);
-    arrowHeight = fontMetrics.linespace + 1;
-    menuClipRect = *menuRectPtr;
-    hasTopScroll = mtdPtr->virtualMenuTop < menuRectPtr->top;
-    hasBottomScroll = mtdPtr->virtualMenuBottom > menuRectPtr->bottom;
-    scrollDirection = DONT_SCROLL;
-    if (hasTopScroll) {
-	menuClipRect.top = bounds.top + arrowHeight;
-	if (hitPt.v < menuClipRect.top) {
-	    newItem = -1;
-	    scrollDirection = DOWN_SCROLL;
-	}
-    }
-    if (hasBottomScroll) {
-	menuClipRect.bottom = bounds.bottom - 1 - arrowHeight;
-	if (hitPt.v > menuClipRect.bottom) {
-	    newItem = -1;
-	    scrollDirection = UP_SCROLL;
-	}
-    }
-    if (MDEFScrollFlag) {
-	scrollDirection = DONT_SCROLL;
-	MDEFScrollFlag = 0;
-    }
     /*
-     * Don't scroll if there are other menus open above us
+     * Obsolete: Nothing to do.
      */
-    ChkErr(GetMenuTrackingData, NULL, &topMtd);
-    if (menu != topMtd.menu) {
-	scrollDirection = DONT_SCROLL;
-    }
-    if (scrollDirection == DONT_SCROLL) {
-	/*
-	 * Find out which item was hit. If it is the same as the old item, we
-	 * don't need to do anything.
-	 */
-
-	if (PtInRect(hitPt, menuRectPtr)) {
-	    for (i = 0; i < menuPtr->numEntries; i++) {
-		mePtr = menuPtr->entries[i];
-		itemRect.left = menuRectPtr->left + mePtr->x;
-		itemRect.top = mtdPtr->virtualMenuTop + mePtr->y;
-		itemRect.right = mePtr->entryFlags & ENTRY_LAST_COLUMN ?
-			menuRectPtr->right : itemRect.left + mePtr->width;
-		itemRect.bottom = itemRect.top + mePtr->height;
-		if (PtInRect(hitPt, &itemRect)) {
-		    if ((mePtr->type == SEPARATOR_ENTRY)
-			    || (mePtr->state == ENTRY_DISABLED)) {
-			newItem = -1;
-			itemUnderMouse = i;
-		    } else {
-			TkMenuEntry *parentEntryPtr =
-				GetParentMenuEntry(menuPtr);
-
-			if (parentEntryPtr &&
-				parentEntryPtr->state == ENTRY_DISABLED) {
-			    newItem = -1;
-			    itemUnderMouse = i;
-			} else {
-			    newItem = i;
-			    itemUnderMouse = i;
-			}
-		    }
-		    break;
-		}
-	    }
-	}
-    } else {
-	short scrollAmt;
-	unsigned long scrollDelay;
-	Rect arrowRect, eraseRect, scrolledMenuClipRect;
-	ThemeMenuState menuState = IsMenuItemEnabled(menu, 0) ?
-		kThemeMenuActive : kThemeMenuDisabled;
-	int oldItem = mtdPtr->itemSelected - 1;
-	short d;
-
-	TkpClipDrawableToRect(menuPtr->display, (Drawable) &macMDEFDrawable,
-		0, 0, -1, -1);
-	scrollAmt = fontMetrics.linespace + menuItemExtraHeight;
-	if (scrollDirection == UP_SCROLL) {
-	    scrollAmt = -scrollAmt;
-	    d = hitPt.v - bounds.bottom;
-	} else {
-	    d = bounds.top - hitPt.v;
-	}
-	scrollDelay = (d >= scrollAmt/2) ? 1 : 10;
-	menuClipRect = *menuRectPtr;
-	if (mtdPtr->virtualMenuTop + scrollAmt < menuRectPtr->top) {
-	    arrowRect = bounds;
-	    /*arrowRect.top += 1;*/
-	    arrowRect.bottom = arrowRect.top + arrowHeight;
-	    eraseRect = arrowRect;
-	    eraseRect.top = menuRectPtr->top;
-	    menuClipRect.top = arrowRect.bottom;
-	    if (!hasTopScroll) {
-		ChkErr(EraseMenuBackground, menu, &eraseRect,
-			macMDEFDrawable.context);
-		ChkErr(DrawThemeMenuItem, menuRectPtr, &arrowRect,
-			mtdPtr->virtualMenuTop + scrollAmt,
-			mtdPtr->virtualMenuBottom + scrollAmt,
-			menuState, kThemeMenuItemScrollUpArrow, NULL, 0);
-#ifdef TK_MAC_DEBUG_MENUS
-		TkMacOSXDbgMsg("upArrow:   %d - %d, %d - %d", arrowRect.top,
-			arrowRect.bottom, arrowRect.left, arrowRect.right);
-#endif
-	    }
-	}
-	if (mtdPtr->virtualMenuBottom + scrollAmt > menuRectPtr->bottom) {
-	    arrowRect = bounds;
-	    arrowRect.bottom -= 1;
-	    arrowRect.top = arrowRect.bottom - arrowHeight;
-	    eraseRect = arrowRect;
-	    eraseRect.bottom = menuRectPtr->bottom;
-	    menuClipRect.bottom = arrowRect.top;
-	    if (!hasBottomScroll) {
-		ChkErr(EraseMenuBackground, menu, &eraseRect,
-			macMDEFDrawable.context);
-		ChkErr(DrawThemeMenuItem, menuRectPtr, &arrowRect,
-			mtdPtr->virtualMenuTop + scrollAmt,
-			mtdPtr->virtualMenuBottom + scrollAmt,
-			menuState, kThemeMenuItemScrollDownArrow, NULL, 0);
-#ifdef TK_MAC_DEBUG_MENUS
-		TkMacOSXDbgMsg("downArrow: %d - %d, %d - %d", arrowRect.top,
-			arrowRect.bottom, arrowRect.left, arrowRect.right);
-#endif
-	    }
-	}
-	TkpClipDrawableToRect(menuPtr->display, (Drawable) &macMDEFDrawable,
-		menuClipRect.left, menuClipRect.top, menuClipRect.right -
-		menuClipRect.left, menuClipRect.bottom - menuClipRect.top);
-	TkActivateMenuEntry(menuPtr, -1);
-	if (oldItem >= 0) {
-	    AppearanceEntryDrawWrapper(menuPtr->entries[oldItem], menuRectPtr,
-		    mtdPtr, (Drawable) &macMDEFDrawable, &fontMetrics,
-		    menuFont, 1);
-	}
-	ChkErr(ScrollMenuImage, menu, &menuClipRect, 0, scrollAmt,
-		macMDEFDrawable.context);
-	mtdPtr->virtualMenuTop += scrollAmt;
-	mtdPtr->virtualMenuBottom += scrollAmt;
-	scrolledMenuClipRect = menuClipRect;
-	OffsetRect(&scrolledMenuClipRect, 0, scrollAmt);
-	menuClipRect = bounds;
-	if (mtdPtr->virtualMenuTop < menuRectPtr->top) {
-	    menuClipRect.top += arrowHeight;
-	}
-	if (mtdPtr->virtualMenuBottom > menuRectPtr->bottom) {
-	    menuClipRect.bottom -= arrowHeight;
-	}
-	TkpClipDrawableToRect(menuPtr->display, (Drawable) &macMDEFDrawable,
-		menuClipRect.left, menuClipRect.top, menuClipRect.right -
-		menuClipRect.left, menuClipRect.bottom - menuClipRect.top);
-	if (scrolledMenuClipRect.bottom < menuClipRect.bottom) {
-	    menuClipRect.top = scrolledMenuClipRect.bottom;
-	} else if (scrolledMenuClipRect.top < menuClipRect.top) {
-	    menuClipRect.bottom = scrolledMenuClipRect.top;
-	}
-	for (i = 0; i < menuPtr->numEntries; i++) {
-	    mePtr = menuPtr->entries[i];
-	    if (mtdPtr->virtualMenuTop + mePtr->y + mePtr->height <
-		    menuClipRect.top || mtdPtr->virtualMenuTop + mePtr->y >
-		    menuClipRect.bottom) {
-		continue;
-	    }
-#ifdef TK_MAC_DEBUG_MENUS
-	    TkMacOSXDbgMsg("Drawing item %i", i);
-#endif
-	    AppearanceEntryDrawWrapper(mePtr, menuRectPtr, mtdPtr,
-		    (Drawable) &macMDEFDrawable, &fontMetrics, menuFont, 1);
-	}
-	Delay(scrollDelay, NULL);
-    }
-    mtdPtr->itemSelected = newItem + 1;
-    mtdPtr->itemUnderMouse = itemUnderMouse + 1;
-    mtdPtr->itemRect = itemRect;
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * HandleMenuPopUpMsg --
+ * TkMacOSXSetHelpMenuItemCount --
  *
- *	Handles the MenuDefProc's PopUp message. The menu is posted with the
- *	selected item at the point given in hitPt.
+ *	Has to be called after the first call to InsertMenu. Sets up the
+ *	global variable for the number of items in the unmodified help menu.
+ *	NB. Nobody uses this any more, since you can get the number of system
+ *	help items from HMGetHelpMenu trivially. But it is in the stubs
+ *	table...
  *
  * Results:
- *	A menu is posted.
+ *	None.
  *
  * Side effects:
- *	None.
+ *	Nothing.
  *
  *----------------------------------------------------------------------
  */
 
 void
-HandleMenuPopUpMsg(
-    MenuRef menu,
-    Rect *menuRectPtr,
-    Point hitPt,
-    SInt16 *whichItem,
-    TkMenu *menuPtr)
+TkMacOSXSetHelpMenuItemCount(void)
 {
-    int maxMenuHeight;
-    int oldItem;
-    Rect portRect;
-    BitMap screenBits;
-    static SInt16 menuBarHeight = 0;
-
-#ifdef TK_MAC_DEBUG_MENUS
-    TkMacOSXDbgMsg("MDEF: PopUpMsg");
-#endif
-
-    if (!menuBarHeight) {
-	ChkErr(GetThemeMenuBarHeight, &menuBarHeight);
-    }
-    GetQDGlobalsScreenBits(&screenBits);
-
-    /*
-     * Note that for some oddball reason, h and v are reversed in the point
-     * given to us by the MDEF.
-     */
-
-    oldItem = *whichItem;
-    if (oldItem >= menuPtr->numEntries) {
-	oldItem = -1;
-    }
-    portRect.top = 0;
-    portRect.bottom = 1280;
-    maxMenuHeight = screenBits.bounds.bottom - screenBits.bounds.top
-	    - menuBarHeight - SCREEN_MARGIN;
-    if (menuPtr->totalHeight > maxMenuHeight) {
-	menuRectPtr->top = menuBarHeight;
-    } else {
-	int delta;
-
-	menuRectPtr->top = hitPt.h;
-	if (oldItem >= 0) {
-	    menuRectPtr->top -= menuPtr->entries[oldItem]->y;
-	}
-
-	if (menuRectPtr->top < menuBarHeight) {
-	    /*
-	     * Displace downward if the menu would stick off the top of the
-	     * screen.
-	     */
-
-	    menuRectPtr->top = menuBarHeight + SCREEN_MARGIN;
-	} else {
-	    /*
-	     * Or upward if the menu sticks off the bottom end...
-	     */
-
-	    delta = menuRectPtr->top + menuPtr->totalHeight - maxMenuHeight;
-	    if (delta > 0) {
-		menuRectPtr->top -= delta;
-	    }
-	}
-    }
-    menuRectPtr->left = hitPt.v;
-    menuRectPtr->right = menuRectPtr->left + menuPtr->totalWidth;
-    menuRectPtr->bottom = menuRectPtr->top +
-	    ((maxMenuHeight < menuPtr->totalHeight)
-	    ? maxMenuHeight : menuPtr->totalHeight);
-    if (menuRectPtr->top == menuBarHeight) {
-	*whichItem = hitPt.h;
-    } else {
-	*whichItem = menuRectPtr->top;
-    }
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * HandleMenuCalcItemMsg --
+ * TkMacOSXMenuClick --
  *
- *	Handles the MenuDefProc's CalcItem message. It is supposed to
- *	calculate the Rect of the menu entry in whichItem in the menu, and put
- *	that in menuRectPtr. I assume this works, but I have never seen the
- *	MenuManager send this message.
+ *	Prepares a menubar for MenuSelect or MenuKey.
  *
  * Results:
- *	The Menu Manager is informed of the bounding rect of a menu rect.
+ *	None.
  *
  * Side effects:
- *	None.
+ *	Any pending configurations of the menubar are completed.
  *
  *----------------------------------------------------------------------
  */
 
 void
-HandleMenuCalcItemMsg(
-    MenuRef menu,
-    Rect *menuRectPtr,
-    Point hitPt,
-    SInt16 *whichItem,
-    TkMenu *menuPtr)
+TkMacOSXMenuClick(void)
 {
-    TkMenuEntry *mePtr;
-    MenuTrackingData mtd, *mtdPtr = &mtd;
-    OSStatus err;
-    int virtualTop, item = *whichItem-1;
-
-    err = ChkErr(GetMenuTrackingData, menu, mtdPtr);
-    if (err == noErr) {
-	virtualTop = mtdPtr->virtualMenuTop;
-    } else {
-	virtualTop = 0;
-    }
-
-    if (item >= 0 && item < menuPtr->numEntries) {
-	mePtr = menuPtr->entries[item];
-	menuRectPtr->left = mePtr->x;
-	menuRectPtr->top = mePtr->y + virtualTop;
-	if (mePtr->entryFlags & ENTRY_LAST_COLUMN) {
-	    menuRectPtr->right = menuPtr->totalWidth;
-	} else {
-	    menuRectPtr->right = mePtr->x + mePtr->width;
-	}
-	menuRectPtr->bottom = menuRectPtr->top + mePtr->height;
-    }
-#ifdef TK_MAC_DEBUG_MENUS
-    TkMacOSXDbgMsg("MDEF: CalcItemMsg %d: %d, %d", *whichItem,
-	    menuRectPtr->left, menuRectPtr->top);
-#endif
 }
-#endif /* USE_TK_MDEF */
 
 /*
  * Local Variables:
- * fill-column: 78
+ * mode: c
  * c-basic-offset: 4
+ * fill-column: 79
+ * coding: utf-8
  * End:
  */