• Pull-Down Menus. A pull-down menu is identified by a menu title in the menu bar. Each pull-down menu comprises a menu title and one or more menu items.

• Submenus. A submenu is a menu that is attached to another menu. A menu to which a submenu is attached is referred to as a hierarchical menu.

• Pop-Up Menus. A pop-up menu is a menu which does not appear in the menu bar but rather appears on another part of the screen when the user presses the mouse button while the cursor is at a particular location.

• Menu Definition Function. When you define a menu, you must specify the required menu definition function (MDEF). The Menu Manager uses that MDEF to draw the menu items in a menu, determine which item the user chose, insert scrolling indicators as items in a menu, calculate the menu's dimensions, etc. An MDEF thus determines the look and behaviour of menus.

• Menu Bar Definition Function. The Menu Manager uses the menu bar definition function to draw and clear the menu bar, determine whether the cursor is currently within the menu bar or any currently displayed menu, calculate the left edges of menu titles, highlight a menu title, invert the entire menu bar, draw the menu's shadow box, and save/restore the bits behind a menu. A menu bar definition function thus determines the look and behaviour of the menu bar.

When you define your menus and menu bar, you specify the definition functions that the Menu Manager should use when managing them. Ordinarily, you will use the standard functions; however, as with most other elements of the Macintosh user interface, the option is available to write your own custom definition function if you need to provide features not available in the standard definition functions. Given the new features added by the latest standard definition functions, however, it is all but impossible to conceive of circumstances that would require the writing of a custom definition function.

Chapter 20 - Lists and Custom List Definition Functions includes an example of custom definition functions for another element of the user interface known as a list.

Generally, the menu bar should always be visible. If you want to hide the menu bar for some reason, you should provide a method (for example, a keyboard equivalent for a menu command) to allow the user to make the menu bar reappear.

The 'MBAR' Resource. Each application has its own menu bar, which is defined by an 'MBAR' resource. This resource lists the order and resource ID of each menu appearing in your menu bar. Your menu's 'MBAR' resource should be defined such that the Apple menu is the first menu in the menu bar, with the File and Edit menus being the next two. The Help and Application menus do not need to be defined in the 'MBAR' resource, since the Menu Manager automatically adds them to the menu bar when the application calls GetNewMBar provided that your menu bar includes the Apple menu.

Menus

Your application can disable any menu, which causes the Menu Manager to dim that menu's title and all associated menu items. The menu items can also be disabled individually. Your application should specify whether menu items are enabled or disabled when it first defines and creates a menu and can enable or disable items at any time thereafter.

The 'MENU' Resource. For each menu, you define the menu title and the individual characteristics of its menu items in a 'MENU' resource.

The 'xmnu' Resource. For each menu, you may also define an 'xmnu' (extended menu) resource. The 'xmnu' resource was introduced with Mac OS 8 and the Appearance Manager and is, in effect, the extension of the 'MENU' resource required to provide for additional menu features. . Note that you do not need to provide this resource if you do not require these additional features. An 'xmnu' resource must have the same ID as the 'MENU' resource it extends

Menu Items

• An icon, small icon, reduced icon, colour icon, or an icon from an icon family to the left of the menu item's text. (Note that items with small or reduced icons cannot have submenus.)

  The various icon types are described at Chapter 13- Offsreeen Graphics Worlds, Pictures, Cursors, and Icons.

  Historical Note Support for icon families was introduced with Mac OS 8 and the Appearance Manager.

• A checkmark or other marking character to the left of the menu item's text, indicating the status of the menu item or the mode it controls. (A menu item can have a mark or a submenu, but not both.)

• The symbols for the item's keyboard equivalent. (An item that has a keyboard equivalent cannot have a submenu, a small icon or a reduced icon.)

• A triangular indicator to the right of a menu item's text to indicate that the item has a submenu. (An item that has a submenu cannot have a keyboard equivalent, a marking character, a small icon or a reduced icon.)

• A font style (bold, italic, etc.) for the menu item's text.

• The text of the menu item.

• The ellipsis character (...) as the last character in the text of the menu item, indicating that, before executing the command, the application will display a dialog box requesting more information from the user. (The ellipsis character should not be used in menu items which display informational dialogs or a confirmational alert.)

• A dimmed appearance when the application disables the item. (When the menu title is dimmed, all menu items in that menu are also dimmed.)

A keyboard equivalent is any combination of the Command key, optionally one or more modifier keys (Shift, Option, Control), and another key. A Command-key equivalent such as _-C is thus, by definition, also a keyboard equivalent.

You should not assign a Command-Shift-number key sequence to a menu item as its keyboard equivalent; Command-Shift-number key sequences are reserved for use as 'FKEY' resources. Command-Shift-number key sequences are not returned to your application, but instead are processed by the Event Manager. The Event Manager invokes the 'FKEY' resource with a resource ID that corresponds to the number that activates it.

Reserved Command-Key Equivalents. Apple reserves the following Command-key equivalents, which should be used in the File and Edit menus of your application:

Other common keyboard equivalents are:

Menus Added Automatically By the Menu Manager

Your application does not need to take any action if the user chooses an item from the Application menu. However, if the user chooses an item added by your application to the Help menu, your application is responsible for taking the appropriate action.

The Apple Menu

To create your application's Apple menu, firstly define the Apple menu title, the characteristics of your application's About command and the divider following it in a 'MENU' resource. Then insert the contents of the Apple Menu Items folder into your application's Apple menu by calling AppendResMenu, with 'DRVR' specified as the resource type in the parameter theType.

When the user chooses the About command, your application should display a dialog box or an alert box containing your application's name, version number, copyright information, any other information as required, and an OK button.

When the user chooses an item other than the About command, your application should call the OpenDeskAcc function, which schedules the chosen item for execution and then returns to your application. At the next call to WaitNextEvent, your application receives a suspend event and the chosen item becomes the foreground process.

The File Menu

All Macintosh applications should include the standard editing commands (Undo, Cut, Copy, Paste and Clear) so as to support those operations in dialog boxes.

An additional word or phrase should be added to Undo to clarify exactly what action your application will reverse. Other commands may be added if they are related to editing or changing the contents of your application's documents.

The Help Menu

You should, however, not add an item to the Help menu in this way if you are providing online help using Apple Help (see below).

Help Balloons

The Application Menu

Your application should indicate which font is in use by adding a checkmark to the left of the name in the Font menu. If the current selection contains more than one font, a dash should be placed next to the name of each font the selection contains. When the user starts entering text at the insertion point, your application should display text in the current font.

Font Attributes

The standard pop-up menu is actually implemented as a control, specifically, the pop-up menu button control. Its appearance (see Fig 3) and behaviour is thus determined by a pop-up menu button control definition function.

Because pop-up menus are implemented as controls, they are addressed at Chapter 7 - Introduction to Controls. Further information in this chapter will be limited to the provision of the 'MENU' resource required by the pop-up menu button control.

Menu Structures, Menu IDs and Item Numbers, Command IDs, and Menu Lists

     struct MenuInfo 
     {
       short   menuID;       // Menu ID of the menu.
       short   menuWidth;    // Horizontal dimensions of the menu in pixels.
       short   menuHeight;   // Vertical dimensions of the menu in pixels.
       Handle  menuProc;     // Handle to the menu definition procedure.
       long    enableFlags;  // Enabled/disabled flags.
       Str255  menuData;     // Menu title
     };
     typedef struct MenuInfo MenuInfo;
     typedef MenuInfo *MenuPtr;
     typedef MenuPtr *MenuHandle;

• Pull-down menus must use a menu ID greater than 0.

• Submenus of an application must use a menu ID of from 1 to 235.

When your application initialises the Menu Manager, the Menu Manager creates the menu list. The menu list is initially empty but changes as your application adds menus to it or removes menus from it programmatically.

Creating Your Application's Menus

When creating resources using Resorcerer, it is advisable that you refer to a diagram and description of the structure of the resource and relate that to the various items in the Resorcerer editing windows. Accordingly, the following describes the structure of those resources associated with the creation of menus.

Structure of a Compiled 'MBAR' Resource

Structure of a Compiled 'MENU' Resource

The following describes the main fields of the 'MENU' resource:

The following describes the main fields of the variable length data for each menu item. Note that various alternatives apply to the icon number, keyboard equivalent, and marking character fields. For example, a menu item can have a keyboard equivalent or a submenu, but not both.

Structure of a Compiled 'xmnu' Resource

The following describes the fields of a compiled 'xmnu' resource:

Each entry in a 'xmnu' resource corresponds to a menu item. The following describes the main fields of an extended menu item entry.

The information in an 'xmnu' resource is set for specified menu items; it is not necessary to create an extended menu entry for all menu items in a menu.

It is not necessary to provide 'xmnu' resources if your application's menus do not require the additional features introduced with Mac OS 8 and the Appearance Manager.

Creating 'MBAR', 'MENU', and 'xmnu' Resources Using Resorcerer

Creating 'MENU' Resources

Fig 9 shows the same View menu with the Floating Palettes menu item being edited. This item has a submenu; accordingly, the Sub-menu ID radio button has been clicked and the resource ID of the submenu's 'MENU' resource has been entered. The item also has an icon provided by a 'CICN' or 'cicn' resource with a resource ID of 257.

Creating 'MENU' Resources for Submenus

Creating 'xmnu' Resources

Creating the Menu Bar and Pull-Down Menus

SetMenuBar should then be used to set the current menu list as the menu list created by your application. A call to DrawMenuBar completes the process by drawing the menu bar, displaying all the menu titles in the current menu list.

Creating an Hierarchical Menu

As the user traverses menu items, if an item has a submenu, the MenuSelect function looks in the submenu portion of the menu list for the submenu. It then searches for a menu with a defined menu ID that matches the menu ID specified by the hierarchical menu item. If it finds a match, it attaches the submenu to the menu item.

• Read the relevant 'MENU' resource in with GetMenu, add it to the current menu list with InsertMenu, and update the menu bar with DrawMenuBar.

• Use NewMenu to create a new empty menu, use AppendMenu, InsertMenuItem, InsertResMenu, or AppendResMenu to fill the menu with menu items, add the menu to the current menu list using InsertMenu, and update the menu bar using DrawMenuBar.

Specifying the Format of Help Messages. The example at Fig 12 specifies the format of the help messages as (Pascal) text strings stored within the 'hmnu' resource itself. Clicking on the pop-up button adjacent to Message record type opens a pop-up menu which facilitates the choice of other formats (and also provides an option which enables you to instruct the Help Manager to skip the item). The items in the pop-up menu and their meanings are as follows:

Text for Help Balloons. The text of your help balloons for menus should answer at least one of the following questions:

• What is this? For example, when the user moves the cursor over the title of the File menu in the title bar, the beginning of the balloon text should be "File menu".

• What does this do? For example, when the user moves the cursor over the Find item in a File menu, the balloon text should be "Finds and selects items with the characteristics you specify" or similar.

• A handle to the menu structure of the menu containing the desired item.

• The number of the menu item.

• A variable which either specifies the data to set or identifies where to return information about that item.

• DisableItem and EnableItem, which both take a handle to the menu structure that identifies the desired menu and either the item number of the menu to be enabled/disabled or a value of 0 to indicate that the entire menu is to be enabled/disabled. DisableItem and EnableItem can only disable and enable menu items with item numbers up to 31.

• In Mac OS 8.5 and later, DisableMenuItem and EnableMenuItem. Unlike DisableItem and EnableItem, DisableMenuItem and EnableMenuItem can enable and disable menu items with item numbers greater than 31.

If you disable an entire menu, the Menu Manager dims that menu's title at the next call to DrawMenuBar and dims all menu items when it displays the menu. If you enable an entire menu, the Menu Manager enables only the menu title and any items that you did not previously disable individually.

Other Appearance Changes

Adding Items to a Menu

• A handle to the menu structure of the menu involved.

• A string describing the items to add.

As an example of the use of metacharacters, assume that the following two strings are stored in a string list ('STR#') resource:

     Pick a Colour...
     (^2!=Everything<B/E

The Menu Manager adds 256 to the number you specify, and uses the result as the icon's resource ID.

     MenuHandle myMenu;
     Str255     itemString;
     ...
     myMenu = GetMenuHandle(mLibrary);
     GetIndString(itemString,300,1);
     AppendMenu(myMenu,itemString);

     MenuHandle myMenu;
     Str255     ItemString;
     ...
     myMenu = GetMenuHandle(mColours);
     GetIndString(itemString,300,2);
     InsertMenuItem(myMenu,itemString,iRed);

     MenuHandle	myMenu;
     ...
     myMenu = GetMenuHandle(mEdit);
     AppendMenu(myMenu,"\pUndo/Z;-;Cut/X;Copy/C;Paste/V");

     InsertMenuItem(myMenu,"\pPaste/V;Copy/C;Cut/X-;-;Undo/Z",0);

     AppendMenu(myMenu,"\p(-");

For example, you can use AppendResMenu to add the names of all font resources in the Fonts folder as menu items in your application's Font menu. Similarly, AppendResMenu can be used to add all of the items from the Apple Menu Items folder to your application's Apple menu (with 'DRVR' specified as the resource type in the call). These are common instances of when you will need to add items not already defined in a 'MENU' resource.

Adding Items to the Help Menu

If some of your menu items have keyboard equivalents, your application should detect such key-down events. If an examination of the modifiers field of the event structure reveals that the Command key was down, your application should first adjust its menus and then call MenuEvent. MenuEvent scans the current menu list for a menu item that has a matching keyboard equivalent. Like MenuSelect, MenuEvent returns a long integer containing the menu ID and the item number.

If the user did not actually choose a menu command with the mouse, or if the user pressed a keyboard combination which did not map to a keyboard equivalent, MenuSelect and MenuEvent return 0 in the high word, the value in the low word being undefined.

Further Handling - Command IDs Not Used

Using this method, the menu ID and item number should be extracted from the long integer returned by MenuSelect and MenuEvent in the usual way. The menu ID should then be used in a call to GetMenuHandle to get the handle to the menu's menu structure. This handle and the menu item should then be used in a call to GetMenuItemCommandID, which returns the unique value that you previously assigned to the item (that is, the item's command ID). Your application should then switch according to that command ID, calling the other application-defined functions which respond appropriately to that menu command.

Unhighlighting the Menu Title

     void  doAdjustMenus(void)
     {
       WindowPtr windowPtr;
       SInt16    windowType;

       windowPtr = FrontWindow();
       windowType = doGetWindowType(windowPtr);

       switch windowType 
       {
         case kMyDocWindow:
           doAdjustFileMenuForDocWindow();
           doAdjustEditMenuForDocWindow();
           // Adjust others.
           break;

         case kMyModelessDialogWindow:
           doAdjustMenusForModelessDialogs();
           break;

         case kNil:
           doAdjustMenusNoWindows();
           break;
       };

       DrawMenuBar;
     }

     void doAdjustFileMenuForDocWindow(void)
     {
       MenuHandle menuHdl;

       menuHdl = GetMenuHandle(mFile);
       EnableItem (menuHdl,iNew);
       EnableItem (menuHdl,iOpen);
       DisableItem(menuHdl,iClose);
       DisableItem(menuHdl,iSave);
       DisableItem(menuHdl,iSaveAs);
       DisableItem(menuHdl,iPageSetup);
       DisableItem(menuHdl,iPrint);
       EnableItem (menuHdl,iQuit);
     }

If your application provides an About command as the first menu item in the Apple menu, and the user chooses this item, you should display the About box. Otherwise, your application should use the GetMenuItemText function to get the menu item text and then call the OpenDeskAcc function, passing the text of the chosen menu item as a parameter.

The OpenDeskAcc function prepares to open the desktop object chosen by the user. For example, if the user chose a document created by the SimpleText application, OpenDeskAcc schedules SimpleText for execution (or prepares to open it if it was not already open) and returns to your application. On your application's next call to WaitNextEvent, your application receives a suspend event and the Process Manager makes SimpleText the foreground process, instructing it to open the chosen document.

Handling Help Menu Choices

Size menus should, in addition to displaying available font sizes, provide an Other command to enable the user to specify a size not currently listed in the menu. When the user chooses the Other command, the current font size should be displayed in a dialog box which allows the user to enter the desired font size. If the user chooses a size not already in the menu, a checkmark should be added to the Other menu item and the chosen size should be added in parenthesis to the text of the Other command.

Handling the Menu Choice

     void  doHandleSizeCommand(SInt16 menuItem)
     {
       SInt16   numItems;
       Boolean  addItem;
       SInt32   sizeChosen;

       numItems = CountMenuItems(GetMenuHandle(mSize));

       if(menuItem == numItems)   // If user chose Other, display dialog box. If the
       {                          // user-specified size is not in the menu, add a
         doDisplayOtherBox(sizeChosen); // checkmark to the Other command and add
       }                          // new font size to the text of the Other command.
       else                       // Return sizeChosen.
       {                                // User chose a size.  Remove marks from
         doRemoveMarksFromSizeMenu();   // item/s showing previous size.  Add mark
         CheckMenuItem(GetMenuHandle(mSize),menuItem,true); // to chosen item.
         sizeChosen = doItemToSize(menuItem);  // Convert item number to font size.
       }
       doResizeSelection(sizeChosen);     // Update document state or user selection.
     }

The subject of menu access when alert boxes, movable alert boxes, modal dialog boxes, moveable modal dialog boxes, and modeless dialog boxes are displayed is somewhat involved, and is addressed in detail at Chapter 8 - Dialogs and Alerts.

Main Menu Manager Constants, Data Types, and Functions

• The constants, data types, and functions introduced with Mac OS 8 and the Appearance Manager are shown in light blue.

• The functions introduced with Mac OS 8.5 are shown in a dark blue.

• Those older constants, data types and functions affected by the introduction of Mac OS 8 and the Appearance Manager, but which may still be used in certain circumstances, are shown in red.

noMark       = 0
commandMark  = 17
checkMark    = 18
diamondMark  = 19
appleMark    = 20

hierMenu  = -1

kMenuCommandModifiers  = 0         // If no bit is set, only the Command key is used.
kMenuShiftModifier     = (1 << 0)  // If this bit is set, Shift key is used.
kMenuOptionModifier    = (1 << 1)  // If this bit is set, Option key is used.
kMenuControlModifier   = (1 << 2)  // If this bit is set, Control key is used.
kMenuNoCommandModifier = (1 << 3)  // If this bit is set, Command key is not used.

kMenuNoIcon          = 0  // No icon.
kMenuIconType        = 1  // 'ICON' handle.
kMenuShrinkIconType  = 2  // 32-by-32 'ICON' handle shrunk (at display time) to 16-by-16.
kMenuSmallIconType   = 3  // 'SICN' handle.
kMenuColorIconType   = 4  // 'cicn' handle.
kMenuIconSuiteType   = 5  // Icon suite handle.

struct MenuInfo
{
  short  menuID;       // Number that identifies the menu.
  short  menuWidth;    // Width (in pixels) of menu.
  short  menuHeight;   // Height (in pixels) of menu.
  Handle menuProc;     // Menu definition procedure.
  long   enableFlags;  // Indicates whether menu and menu items are enabled.
  Str255 menuData;     // Title of menu.
};
typedef struct MenuInfo MenuInfo;
typedef MenuInfo *MenuPtr;
typedef MenuPtr *MenuHandle;

void   InitMenus();

MenuHandle  NewMenu(short menuID, ConstStr255Param menuTitle);
MenuHandle  GetMenu(short resourceID);

void   InsertMenu(MenuHandle theMenu,short beforeID);
void   DeleteMenu(short menuID);
void   ClearMenuBar(void);

Handle   GetNewMBar(short menuBarID);

Handle  GetMenuBar(void);
void    SetMenuBar(Handle menuList);
short   GetMBarHeight(void);

void   DrawMenuBar(void);
void   InvalMenuBar(void);

void     HideMenuBar(void);
void     ShowMenuBar(void);
Boolean  IsMenuBarVisible(void);

Boolean  GetMenuExcludesMarkColumn(MenuHandle menu);
OSStatus SetMenuExcludesMarkColumn(MenuHandle menu,Boolean excludesMark);

long   MenuKey(short ch);
Uint32 MenuEvent (EventRecord* inEvent);
long   MenuSelect(Point startPt);
long   MenuChoice(void);
void   HiliteMenu(short menuID);
long   PopUpMenuSelect(MenuHandle menu,short top,short left,short popUpItem);

MenuHandle  GetMenuHandle(short menuID);
OSErr       HMGetHelpMenuHandle(MenuHandle *mh);

void   AppendMenu(MenuHandle menu,ConstStr255Param data);
void   InsertMenuItem(MenuHandle theMenu,ConstStr255Param itemString,short afterItem);
OSStatus AppendMenuItemText(MenuHandle menu,ConstStr255Param inString);
OSStatus InsertMenuItemText(MenuHandle menu,ConstStr255Param inString,UInt16 afterItem);
void   DeleteMenuItem(MenuHandle theMenu,short item);
void   AppendResMenu(MenuHandle theMenu,ResType theType);
void   InsertResMenu(MenuHandle theMenu,ResType theType,short afterItem);

void   EnableItem(MenuHandle theMenu,short item);
void   DisableItem(MenuHandle theMenu,short item);
void   EnableMenuItem(MenuHandle theMenu,UInt16 item);
void   DisableMenuItem(MenuHandle theMenu,UInt16 item);
Boolean IsMenuItemEnabled(MenuHandle menu,UInt16 item);
void   EnableMenuItemIcon(MenuHandle theMenu,UInt16 item);
void   DisableMenuItemIcon(MenuHandle theMenu,UInt16 item);
Boolean IsMenuItemIconEnabled(MenuHandle menu,UInt16 item);
void   GetMenuItemText(MenuHandle menu,short item,Str255 itemString); 
void   SetMenuItemText(MenuHandle theMenu, short item, ConstStr255Param itemString);
void   GetItemStyle(MenuHandle theMenu,short item,Style *chStyle); 
void   SetItemStyle(MenuHandle theMenu,short item,short chStyle);
void   GetItemMark(MenuHandle theMenu,short item,short *markChar);
void   SetItemMark(MenuHandle theMenu,short item,short markChar);
void   CheckMenuItem(MenuHandle theMenu,short item,Boolean checked);
OSStatus GetMenuFont(MenuHandle menu,SInt16 *outFontID,UInt16 *outFontSize);
OSStatus SetMenuFont(MenuHandle menu,SInt16 inFontID,UInt16 inFontSize);
void   GetItemIcon(MenuHandle theMenu,short item,short *iconIndex);
void   SetItemIcon(MenuHandle theMenu,short item,short iconIndex);
void   GetItemCmd(MenuHandle theMenu,short item,short *cmdChar);
void   SetItemCmd(MenuHandle theMenu,short item,short cmdChar);
OSErr  SetMenuItemCommandID(MenuHandle inMenu,SInt16 inItem,UInt32 inCommandID);
OSErr  GetMenuItemCommandID(MenuHandle inMenu,SInt16 inItem,UInt32* outCommandID);
OSErr  SetMenuItemFontID(MenuHandle inMenu,SInt16 inItem,SInt16 inFontID);
OSErr  GetMenuItemFontID(MenuHandle inMenu,SInt16 inItem,SInt16* outFontID);
OSErr  SetMenuItemHierarchicalID(MenuHandle inMenu,SInt16 inItem,SInt16 inHierID);
OSErr  GetMenuItemHierarchicalID(MenuHandle inMenu,SInt16 inItem,SInt16 *outHierID);
OSErr  SetMenuItemIconHandle(MenuHandle inMenu,SInt16 inItem,MenuIconType inIconType,
       Handle inIconHandle);
OSErr  GetMenuItemIconHandle(MenuHandle inMenu,SInt16 inItem,MenuIconType outIconType,
       Handle* outIconHandle);
OSErr  SetMenuItemKeyGlyph(MenuHandle inMenu,SInt16 inItem,SInt16 inGlyph);
OSErr  GetMenuItemKeyGlyph(MenuHandle inMenu,SInt16 inItem,SInt16 *outGlyph);
OSErr  SetMenuItemModifiers(MenuHandle inMenu,SInt16 inItem,SInt16 inModifiers);
OSErr  GetMenuItemModifiers(MenuHandle inMenu,SInt16 inItem,SInt16* outModifiers);
OSErr  SetMenuItemRefCon(MenuHandle inMenu,SInt16 inItem,SInt32 inRefCon);
OSErr  GetMenuItemRefCon(MenuHandle inMenu,SInt16 inItem,SInt32* outRefCon);
OSErr  SetMenuItemRefCon2(MenuHandle inMenu,SInt16 inItem,SInt32 inRefCon);
OSErr  GetMenuItemRefCon2(MenuHandle inMenu,SInt16 inItem,SInt32* outRefCon);
OSErr  SetMenuItemTextEncoding(MenuHandle inMenu,SInt16 inItem,TextEncoding inScriptID);
OSErr  GetMenuItemTextEncoding(MenuHandle inMenu,SInt16 inItem,TextEncoding* outScriptID);

void   DisposeMenu(MenuHandle theMenu);

short   CountMenuItems(MenuHandle theMenu);

void   FlashMenuBar(short menuID);
void   SetMenuFlash(short count);

void   CalcMenuSize(MenuHandle theMenu);