Menus.h

Go to the documentation of this file.

 
#ifndef __MENUS__
#define __MENUS__
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __EVENTS__
#include <Events.h>
#endif
 
#ifndef __QUICKDRAW__
#include <Quickdraw.h>
#endif
 
#ifndef __FONTS__
#include <Fonts.h>
#endif
 
#ifndef __TEXTCOMMON__
#include <TextCommon.h>
#endif
 
#ifndef __PROCESSES__
#include <Processes.h>
#endif
 
#ifndef __APPLEEVENTS__
#include <AppleEvents.h>
#endif
 
#ifndef __COLLECTIONS__
#include <Collections.h>
#endif
 
#ifndef __MACERRORS__
#include <MacErrors.h>
#endif
 
#ifndef __CFSTRING__
#include <CFString.h>
#endif
 
#ifndef __CFUUID__
#include <CFUUID.h>
#endif
 
#if PRAGMA_ONCE
#pragma once
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#if PRAGMA_IMPORT
#pragma import on
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = mac68k
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  /*  © Menu Constants */
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  enum
  {
    noMark = 0 /* mark symbol for SetItemMark; other mark symbols are defined in
                  Fonts.h */
  };
 
  enum
  {
    /* menu defProc messages */
    kMenuDrawMsg = 0,
    kMenuSizeMsg = 2,
    kMenuPopUpMsg = 3,
    kMenuCalcItemMsg = 5,
    kMenuThemeSavvyMsg =
        7, /* is your MDEF theme-savvy?  If so, return kThemeSavvyMenuResponse in
              the whichItem parameter*/
    mDrawMsg = 0,
    mSizeMsg = 2,
    mPopUpMsg = 3, /* position the popup menu rect appropriately */
    mCalcItemMsg = 5
  };
 
#if CALL_NOT_IN_CARBON
  enum
  {
    mChooseMsg = 1,
    mDrawItemMsg = 4,
    kMenuChooseMsg = 1,
    kMenuDrawItemMsg = 4
  };
 
#endif /* CALL_NOT_IN_CARBON */
 
  enum
  {
    kThemeSavvyMenuResponse = 0x7473 /* should be returned in *whichItem when
                                        handling kMenuThemeSavvyMsg*/
  };
 
  /* these MDEF messages are only supported in Carbon*/
  enum
  {
    kMenuInitMsg = 8,
    kMenuDisposeMsg = 9,
    kMenuFindItemMsg = 10,
    kMenuHiliteItemMsg = 11,
    kMenuDrawItemsMsg = 12
  };
 
  enum
  {
    textMenuProc = 0,
    hMenuCmd = 27,                /*itemCmd == 0x001B ==> hierarchical menu*/
    hierMenu = -1,                /*a hierarchical menu - for InsertMenu call*/
    kInsertHierarchicalMenu = -1, /*a better name for hierMenu */
    mctAllItems = -98,            /*search for all Items for the given ID*/
    mctLastIDIndic = -99          /*last color table entry has this in ID field*/
  };
 
  /* Constants for use with MacOS 8.0 (Appearance 1.0) and later*/
  enum
  {
    kMenuStdMenuProc = 63,
    kMenuStdMenuBarProc = 63
  };
 
  /* For use with Get/SetMenuItemModifiers*/
  enum
  {
    kMenuNoModifiers = 0,             /* Mask for no modifiers*/
    kMenuShiftModifier = (1 << 0),    /* Mask for shift key modifier*/
    kMenuOptionModifier = (1 << 1),   /* Mask for option key modifier*/
    kMenuControlModifier = (1 << 2),  /* Mask for control key modifier*/
    kMenuNoCommandModifier = (1 << 3) /* Mask for no command key modifier*/
  };
 
  /* For use with Get/SetMenuItemIconHandle*/
  enum
  {
    kMenuNoIcon = 0,         /* No icon*/
    kMenuIconType = 1,       /* Type for ICON*/
    kMenuShrinkIconType = 2, /* Type for ICON plotted 16 x 16*/
    kMenuSmallIconType = 3,  /* Type for SICN*/
    kMenuColorIconType = 4,  /* Type for cicn*/
    kMenuIconSuiteType = 5,  /* Type for Icon Suite*/
    kMenuIconRefType = 6,    /* Type for Icon Ref*/
    kMenuCGImageRefType = 7, /* Type for a CGImageRef (Mac OS X only)*/
    kMenuSystemIconSelectorType =
        8, /* Type for an IconRef registered with Icon Services under
              kSystemIconsCreator (after Mac OS X 10.0.x only)*/
    kMenuIconResourceType =
        9 /* Type for a CFStringRef naming a resource in the main bundle of the
             process (after Mac OS X 10.0.x only)*/
  };
 
  /* For use with Get/SetMenuItemKeyGlyph*/
  enum
  {
    kMenuNullGlyph = 0x00, /* Null (always glyph 1)*/
    kMenuTabRightGlyph =
        0x02, /* Tab to the right key (for left-to-right script systems)*/
    kMenuTabLeftGlyph =
        0x03,                 /* Tab to the left key (for right-to-left script systems)*/
    kMenuEnterGlyph = 0x04,   /* Enter key*/
    kMenuShiftGlyph = 0x05,   /* Shift key*/
    kMenuControlGlyph = 0x06, /* Control key*/
    kMenuOptionGlyph = 0x07,  /* Option key*/
    kMenuSpaceGlyph = 0x09,   /* Space (always glyph 3) key*/
    kMenuDeleteRightGlyph =
        0x0A,                             /* Delete to the right key (for right-to-left script systems)*/
    kMenuReturnGlyph = 0x0B,              /* Return key (for left-to-right script systems)*/
    kMenuReturnR2LGlyph = 0x0C,           /* Return key (for right-to-left script systems)*/
    kMenuNonmarkingReturnGlyph = 0x0D,    /* Nonmarking return key*/
    kMenuPencilGlyph = 0x0F,              /* Pencil key*/
    kMenuDownwardArrowDashedGlyph = 0x10, /* Downward dashed arrow key*/
    kMenuCommandGlyph = 0x11,             /* Command key*/
    kMenuCheckmarkGlyph = 0x12,           /* Checkmark key*/
    kMenuDiamondGlyph = 0x13,             /* Diamond key*/
    kMenuAppleLogoFilledGlyph = 0x14,     /* Apple logo key (filled)*/
    kMenuParagraphKoreanGlyph = 0x15,     /* Unassigned (paragraph in Korean)*/
    kMenuDeleteLeftGlyph =
        0x17,                          /* Delete to the left key (for left-to-right script systems)*/
    kMenuLeftArrowDashedGlyph = 0x18,  /* Leftward dashed arrow key*/
    kMenuUpArrowDashedGlyph = 0x19,    /* Upward dashed arrow key*/
    kMenuRightArrowDashedGlyph = 0x1A, /* Rightward dashed arrow key*/
    kMenuEscapeGlyph = 0x1B,           /* Escape key*/
    kMenuClearGlyph = 0x1C,            /* Clear key*/
    kMenuLeftDoubleQuotesJapaneseGlyph =
        0x1D, /* Unassigned (left double quotes in Japanese)*/
    kMenuRightDoubleQuotesJapaneseGlyph =
        0x1E,                           /* Unassigned (right double quotes in Japanese)*/
    kMenuTrademarkJapaneseGlyph = 0x1F, /* Unassigned (trademark in Japanese)*/
    kMenuBlankGlyph = 0x61,             /* Blank key*/
    kMenuPageUpGlyph = 0x62,            /* Page up key*/
    kMenuCapsLockGlyph = 0x63,          /* Caps lock key*/
    kMenuLeftArrowGlyph = 0x64,         /* Left arrow key*/
    kMenuRightArrowGlyph = 0x65,        /* Right arrow key*/
    kMenuNorthwestArrowGlyph = 0x66,    /* Northwest arrow key*/
    kMenuHelpGlyph = 0x67,              /* Help key*/
    kMenuUpArrowGlyph = 0x68,           /* Up arrow key*/
    kMenuSoutheastArrowGlyph = 0x69,    /* Southeast arrow key*/
    kMenuDownArrowGlyph = 0x6A,         /* Down arrow key*/
    kMenuPageDownGlyph = 0x6B,          /* Page down key*/
    kMenuAppleLogoOutlineGlyph = 0x6C,  /* Apple logo key (outline)*/
    kMenuContextualMenuGlyph = 0x6D,    /* Contextual menu key*/
    kMenuPowerGlyph = 0x6E,             /* Power key*/
    kMenuF1Glyph = 0x6F,                /* F1 key*/
    kMenuF2Glyph = 0x70,                /* F2 key*/
    kMenuF3Glyph = 0x71,                /* F3 key*/
    kMenuF4Glyph = 0x72,                /* F4 key*/
    kMenuF5Glyph = 0x73,                /* F5 key*/
    kMenuF6Glyph = 0x74,                /* F6 key*/
    kMenuF7Glyph = 0x75,                /* F7 key*/
    kMenuF8Glyph = 0x76,                /* F8 key*/
    kMenuF9Glyph = 0x77,                /* F9 key*/
    kMenuF10Glyph = 0x78,               /* F10 key*/
    kMenuF11Glyph = 0x79,               /* F11 key*/
    kMenuF12Glyph = 0x7A,               /* F12 key*/
    kMenuF13Glyph = 0x87,               /* F13 key*/
    kMenuF14Glyph = 0x88,               /* F14 key*/
    kMenuF15Glyph = 0x89,               /* F15 key*/
    kMenuControlISOGlyph = 0x8A         /* Control key (ISO standard)*/
  };
 
  typedef UInt32 MenuAttributes;
  enum
  {
 
    kMenuAttrExcludesMarkColumn = (1 << 0),
 
    kMenuAttrAutoDisable = (1 << 2),
 
    kMenuAttrUsePencilGlyph = (1 << 3)
  };
 
  typedef UInt32 MenuItemAttributes;
  enum
  {
 
    kMenuItemAttrDisabled = (1 << 0),
 
    kMenuItemAttrIconDisabled = (1 << 1),
 
    kMenuItemAttrSubmenuParentChoosable = (1 << 2),
 
    kMenuItemAttrDynamic = (1 << 3),
 
    kMenuItemAttrNotPreviousAlternate = (1 << 4),
 
    kMenuItemAttrHidden = (1 << 5),
 
    kMenuItemAttrSeparator = (1 << 6),
 
    kMenuItemAttrSectionHeader = (1 << 7),
 
    kMenuItemAttrIgnoreMeta = (1 << 8),
 
    kMenuItemAttrAutoRepeat = (1 << 9),
 
    kMenuItemAttrUseVirtualKey = (1 << 10),
 
    kMenuItemAttrCustomDraw = (1 << 11)
  };
 
  typedef UInt32 MenuTrackingMode;
  enum
  {
 
    kMenuTrackingModeMouse = 1,
 
    kMenuTrackingModeKeyboard = 2
  };
 
  typedef UInt32 MenuEventOptions;
  enum
  {
 
    kMenuEventIncludeDisabledItems = 0x0001,
 
    kMenuEventQueryOnly = 0x0002,
 
    kMenuEventDontCheckSubmenus = 0x0004
  };
 
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  /*  © Menu Types */
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  typedef SInt16 MenuID;
  typedef UInt16 MenuItemIndex;
  typedef UInt32 MenuCommand;
#if !OPAQUE_TOOLBOX_STRUCTS
  struct MenuInfo
  {
    MenuID menuID;    /* in Carbon use Get/SetMenuID*/
    short menuWidth;  /* in Carbon use Get/SetMenuWidth*/
    short menuHeight; /* in Carbon use Get/SetMenuHeight*/
    Handle menuProc;  /* not supported in Carbon*/
    long enableFlags; /* in Carbon use Enable/DisableMenuItem, IsMenuItemEnable*/
    Str255 menuData;  /* in Carbon use Get/SetMenuTitle*/
  };
  typedef struct MenuInfo MenuInfo;
  typedef MenuInfo *MenuPtr;
  typedef MenuPtr *MenuHandle;
#else
typedef struct OpaqueMenuHandle *MenuHandle;
#endif /* !OPAQUE_TOOLBOX_STRUCTS */
 
  /* MenuRef and MenuHandle are equivalent. Use either. We don't care.*/
  typedef MenuHandle MenuRef;
  typedef Handle MenuBarHandle;
  struct MCEntry
  {
    MenuID mctID;      /*menu ID.  ID = 0 is the menu bar*/
    short mctItem;     /*menu Item. Item = 0 is a title*/
    RGBColor mctRGB1;  /*usage depends on ID and Item*/
    RGBColor mctRGB2;  /*usage depends on ID and Item*/
    RGBColor mctRGB3;  /*usage depends on ID and Item*/
    RGBColor mctRGB4;  /*usage depends on ID and Item*/
    short mctReserved; /*reserved for internal use*/
  };
  typedef struct MCEntry MCEntry;
  typedef MCEntry *MCEntryPtr;
  typedef MCEntry MCTable[1];
  typedef MCEntry *MCTablePtr;
  typedef MCTablePtr *MCTableHandle;
  struct MenuCRsrc
  {
    short numEntries;    /*number of entries*/
    MCTable mcEntryRecs; /*ARRAY [1..numEntries] of MCEntry*/
  };
  typedef struct MenuCRsrc MenuCRsrc;
  typedef MenuCRsrc *MenuCRsrcPtr;
  typedef MenuCRsrcPtr *MenuCRsrcHandle;
#if TARGET_OS_WIN32
  // QuickTime 3.0
  struct MenuAccessKeyRec
  {
    short count;
    long flags;
    unsigned char keys[1];
  };
  typedef struct MenuAccessKeyRec MenuAccessKeyRec;
  typedef MenuAccessKeyRec *MenuAccessKeyPtr;
  typedef MenuAccessKeyPtr *MenuAccessKeyHandle;
#if CALL_NOT_IN_CARBON
  void
  SetMenuItemHotKey(MenuRef menu, short itemID, char hotKey, long flags);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* TARGET_OS_WIN32 */
 
  struct MenuTrackingData
  {
    MenuRef menu;
    MenuItemIndex itemSelected;
    MenuItemIndex itemUnderMouse;
    Rect itemRect;
    SInt32 virtualMenuTop;
    SInt32 virtualMenuBottom;
  };
  typedef struct MenuTrackingData MenuTrackingData;
  typedef MenuTrackingData *MenuTrackingDataPtr;
 
  struct MDEFHiliteItemData
  {
 
    MenuItemIndex previousItem;
 
    MenuItemIndex newItem;
 
    void *context;
  };
  typedef struct MDEFHiliteItemData MDEFHiliteItemData;
  typedef MDEFHiliteItemData *MDEFHiliteItemDataPtr;
  typedef MDEFHiliteItemData HiliteMenuItemData;
  typedef MDEFHiliteItemDataPtr HiliteMenuItemDataPtr;
 
  struct MDEFDrawData
  {
 
    MenuTrackingData trackingData;
 
    void *context;
  };
  typedef struct MDEFDrawData MDEFDrawData;
  typedef MDEFDrawData *MDEFDrawDataPtr;
 
  struct MDEFFindItemData
  {
 
    MenuTrackingData trackingData;
 
    void *context;
  };
  typedef struct MDEFFindItemData MDEFFindItemData;
  typedef MDEFFindItemData *MDEFFindItemDataPtr;
 
  struct MDEFDrawItemsData
  {
 
    MenuItemIndex firstItem;
 
    MenuItemIndex lastItem;
 
    MenuTrackingData *trackingData;
 
    void *context;
  };
  typedef struct MDEFDrawItemsData MDEFDrawItemsData;
  typedef MDEFDrawItemsData *MDEFDrawItemsDataPtr;
 
  enum
  {
 
    kMenuItemDataText = (1 << 0),
 
    kMenuItemDataMark = (1 << 1),
 
    kMenuItemDataCmdKey = (1 << 2),
 
    kMenuItemDataCmdKeyGlyph = (1 << 3),
 
    kMenuItemDataCmdKeyModifiers = (1 << 4),
 
    kMenuItemDataStyle = (1 << 5),
 
    kMenuItemDataEnabled = (1 << 6),
 
    kMenuItemDataIconEnabled = (1 << 7),
 
    kMenuItemDataIconID = (1 << 8),
 
    kMenuItemDataIconHandle = (1 << 9),
 
    kMenuItemDataCommandID = (1 << 10),
 
    kMenuItemDataTextEncoding = (1 << 11),
    kMenuItemDataSubmenuID = (1 << 12),
    kMenuItemDataSubmenuHandle = (1 << 13),
    kMenuItemDataFontID = (1 << 14),
    kMenuItemDataRefcon = (1 << 15),
    kMenuItemDataAttributes = (1 << 16),
    kMenuItemDataCFString = (1 << 17),
 
    kMenuItemDataProperties = (1 << 18),
 
    kMenuItemDataIndent = (1 << 19),
 
    kMenuItemDataCmdVirtualKey = (1 << 20),
    kMenuItemDataAllDataVersionOne = 0x000FFFFF,
    kMenuItemDataAllDataVersionTwo =
        kMenuItemDataAllDataVersionOne | kMenuItemDataCmdVirtualKey
  };
 
  typedef UInt64 MenuItemDataFlags;
 
  struct MenuItemDataRec
  {
    MenuItemDataFlags whichData;
    StringPtr text;
    UniChar mark;
    UniChar cmdKey;
    UInt32 cmdKeyGlyph;
    UInt32 cmdKeyModifiers;
    Style style;
    Boolean enabled;
    Boolean iconEnabled;
    UInt8 filler1;
    SInt32 iconID;
    UInt32 iconType;
    Handle iconHandle;
    MenuCommand cmdID;
    TextEncoding encoding;
    MenuID submenuID;
    MenuRef submenuHandle;
    SInt32 fontID;
    UInt32 refcon;
    OptionBits attr;
    CFStringRef cfText;
    Collection properties;
    UInt32 indent;
    UInt16 cmdVirtualKey;
  };
  typedef struct MenuItemDataRec MenuItemDataRec;
  typedef MenuItemDataRec *MenuItemDataPtr;
  typedef UInt32 MenuItemID;
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  /*  © Menu ProcPtrs */
  /*                                                                                      */
  /*  All of these procs are considered deprecated.  Developers interested in
   * portability */
  /*  to Carbon should avoid them entirely, if at all possible. */
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  typedef CALLBACK_API(void, MenuDefProcPtr)(short message, MenuRef theMenu,
                                             Rect *menuRect, Point hitPt,
                                             short *whichItem);
  typedef STACK_UPP_TYPE(MenuDefProcPtr) MenuDefUPP;
  MenuDefUPP
  NewMenuDefUPP(MenuDefProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppMenuDefProcInfo = 0x0000FF80
  }; /* pascal no_return_value Func(2_bytes, 4_bytes, 4_bytes, 4_bytes, 4_bytes)
      */
#ifdef __cplusplus
  inline MenuDefUPP NewMenuDefUPP(MenuDefProcPtr userRoutine)
  {
    return (MenuDefUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppMenuDefProcInfo, GetCurrentArchitecture());
  }
#else
#define NewMenuDefUPP(userRoutine)   \
  (MenuDefUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppMenuDefProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeMenuDefUPP(MenuDefUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeMenuDefUPP(MenuDefUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeMenuDefUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  InvokeMenuDefUPP(short message, MenuRef theMenu, Rect *menuRect, Point hitPt,
                   short *whichItem, MenuDefUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeMenuDefUPP(short message, MenuRef theMenu, Rect *menuRect,
                               Point hitPt, short *whichItem,
                               MenuDefUPP userUPP)
  {
    CALL_FIVE_PARAMETER_UPP(userUPP, uppMenuDefProcInfo, message, theMenu,
                            menuRect, hitPt, whichItem);
  }
#else
#define InvokeMenuDefUPP(message, theMenu, menuRect, hitPt, whichItem,         \
                         userUPP)                                              \
  CALL_FIVE_PARAMETER_UPP((userUPP), uppMenuDefProcInfo, (message), (theMenu), \
                          (menuRect), (hitPt), (whichItem))
#endif
#endif
 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
/* support for pre-Carbon UPP routines: New...Proc and Call...Proc */
#define NewMenuDefProc(userRoutine) NewMenuDefUPP(userRoutine)
#define CallMenuDefProc(userRoutine, message, theMenu, menuRect, hitPt, \
                        whichItem)                                      \
  InvokeMenuDefUPP(message, theMenu, menuRect, hitPt, whichItem, userRoutine)
#endif /* CALL_NOT_IN_CARBON */
 
  typedef CALLBACK_API(long, MenuBarDefProcPtr)(short selector, short message,
                                                short parameter1,
                                                long parameter2);
  typedef CALLBACK_API(void, MenuHookProcPtr)(void);
  typedef CALLBACK_API_REGISTER68K(short, MBarHookProcPtr, (Rect * menuRect));
  typedef STACK_UPP_TYPE(MenuBarDefProcPtr) MenuBarDefUPP;
  typedef STACK_UPP_TYPE(MenuHookProcPtr) MenuHookUPP;
  typedef REGISTER_UPP_TYPE(MBarHookProcPtr) MBarHookUPP;
#if CALL_NOT_IN_CARBON
  MenuBarDefUPP
  NewMenuBarDefUPP(MenuBarDefProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppMenuBarDefProcInfo = 0x00003AB0
  }; /* pascal 4_bytes Func(2_bytes, 2_bytes, 2_bytes, 4_bytes) */
#ifdef __cplusplus
  inline MenuBarDefUPP NewMenuBarDefUPP(MenuBarDefProcPtr userRoutine)
  {
    return (MenuBarDefUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppMenuBarDefProcInfo, GetCurrentArchitecture());
  }
#else
#define NewMenuBarDefUPP(userRoutine)   \
  (MenuBarDefUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppMenuBarDefProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  MenuHookUPP
  NewMenuHookUPP(MenuHookProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppMenuHookProcInfo = 0x00000000
  }; /* pascal no_return_value Func() */
#ifdef __cplusplus
  inline MenuHookUPP NewMenuHookUPP(MenuHookProcPtr userRoutine)
  {
    return (MenuHookUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppMenuHookProcInfo, GetCurrentArchitecture());
  }
#else
#define NewMenuHookUPP(userRoutine)   \
  (MenuHookUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppMenuHookProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  MBarHookUPP
  NewMBarHookUPP(MBarHookProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppMBarHookProcInfo = 0x000000CF
  }; /* SPECIAL_CASE_PROCINFO(12) */
#ifdef __cplusplus
  inline MBarHookUPP NewMBarHookUPP(MBarHookProcPtr userRoutine)
  {
    return (MBarHookUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppMBarHookProcInfo, GetCurrentArchitecture());
  }
#else
#define NewMBarHookUPP(userRoutine)   \
  (MBarHookUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppMBarHookProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeMenuBarDefUPP(MenuBarDefUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeMenuBarDefUPP(MenuBarDefUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeMenuBarDefUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeMenuHookUPP(MenuHookUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeMenuHookUPP(MenuHookUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeMenuHookUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeMBarHookUPP(MBarHookUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeMBarHookUPP(MBarHookUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeMBarHookUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  long
  InvokeMenuBarDefUPP(short selector, short message, short parameter1,
                      long parameter2, MenuBarDefUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline long InvokeMenuBarDefUPP(short selector, short message, short parameter1,
                                  long parameter2, MenuBarDefUPP userUPP)
  {
    return (long)CALL_FOUR_PARAMETER_UPP(userUPP, uppMenuBarDefProcInfo, selector,
                                         message, parameter1, parameter2);
  }
#else
#define InvokeMenuBarDefUPP(selector, message, parameter1, parameter2,        \
                            userUPP)                                          \
  (long)CALL_FOUR_PARAMETER_UPP((userUPP), uppMenuBarDefProcInfo, (selector), \
                                (message), (parameter1), (parameter2))
#endif
#endif
 
  void
  InvokeMenuHookUPP(MenuHookUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeMenuHookUPP(MenuHookUPP userUPP)
  {
    CALL_ZERO_PARAMETER_UPP(userUPP, uppMenuHookProcInfo);
  }
#else
#define InvokeMenuHookUPP(userUPP) \
  CALL_ZERO_PARAMETER_UPP((userUPP), uppMenuHookProcInfo)
#endif
#endif
 
  short
  InvokeMBarHookUPP(Rect *menuRect, MBarHookUPP userUPP);
#if !OPAQUE_UPP_TYPES && \
    (!TARGET_OS_MAC || !TARGET_CPU_68K || TARGET_RT_MAC_CFM)
#ifdef __cplusplus
  inline short InvokeMBarHookUPP(Rect *menuRect, MBarHookUPP userUPP)
  {
    return (short)CALL_ONE_PARAMETER_UPP(userUPP, uppMBarHookProcInfo, menuRect);
  }
#else
#define InvokeMBarHookUPP(menuRect, userUPP) \
  (short)CALL_ONE_PARAMETER_UPP((userUPP), uppMBarHookProcInfo, (menuRect))
#endif
#endif
 
#endif /* CALL_NOT_IN_CARBON */
 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
/* support for pre-Carbon UPP routines: New...Proc and Call...Proc */
#define NewMenuBarDefProc(userRoutine) NewMenuBarDefUPP(userRoutine)
#define NewMenuHookProc(userRoutine) NewMenuHookUPP(userRoutine)
#define NewMBarHookProc(userRoutine) NewMBarHookUPP(userRoutine)
#define CallMenuBarDefProc(userRoutine, selector, message, parameter1, \
                           parameter2)                                 \
  InvokeMenuBarDefUPP(selector, message, parameter1, parameter2, userRoutine)
#define CallMenuHookProc(userRoutine) InvokeMenuHookUPP(userRoutine)
#define CallMBarHookProc(userRoutine, menuRect) \
  InvokeMBarHookUPP(menuRect, userRoutine)
#endif /* CALL_NOT_IN_CARBON */
 
  enum
  {
    kMenuDefProcPtr = 0 /* raw proc-ptr access based on old MDEF */
  };
 
  typedef UInt32 MenuDefType;
  struct MenuDefSpec
  {
    MenuDefType defType;
    union
    {
      MenuDefUPP defProc;
    } u;
  };
  typedef struct MenuDefSpec MenuDefSpec;
  typedef MenuDefSpec *MenuDefSpecPtr;
/*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
/*  © Menu Manager Initialization */
/*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
#if CALL_NOT_IN_CARBON
  void
  InitProcMenu(short resID);
 
  void
  InitMenus(void);
 
/*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
/*  © Menu Manipulation */
/*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
#endif /* CALL_NOT_IN_CARBON */
 
  MenuRef
  NewMenu(MenuID menuID, ConstStr255Param menuTitle);
 
#if TARGET_OS_MAC
#define MacGetMenu GetMenu
#endif
  MenuRef
  MacGetMenu(short resourceID);
 
  void
  DisposeMenu(MenuRef theMenu);
 
  void
  CalcMenuSize(MenuRef theMenu);
 
#if CALL_NOT_IN_CARBON
 
  UInt16
  CountMItems(MenuRef theMenu);
 
#endif /* CALL_NOT_IN_CARBON */
 
  UInt16
  CountMenuItems(MenuRef theMenu);
#if CALL_NOT_IN_CARBON && !TARGET_CPU_68K
#ifdef __cplusplus
  inline DEFINE_API(UInt16) CountMenuItems(MenuRef theMenu)
  {
    return CountMItems(theMenu);
  }
#else
#define CountMenuItems(theMenu) (CountMItems(theMenu))
#endif
#endif
 
  /* Routines available in Mac OS 8.5 and later, and on Mac OS 8.1 and later using
   * CarbonLib 1.1 and later*/
 
  OSStatus
  GetMenuFont(MenuRef menu, SInt16 *outFontID, UInt16 *outFontSize);
 
  OSStatus
  SetMenuFont(MenuRef menu, SInt16 inFontID, UInt16 inFontSize);
 
  Boolean
  GetMenuExcludesMarkColumn(MenuRef menu);
 
  OSStatus
  SetMenuExcludesMarkColumn(MenuRef menu, Boolean excludesMark);
 
  OSStatus
  RegisterMenuDefinition(SInt16 inResID, MenuDefSpecPtr inDefSpec);
 
  OSStatus
  CreateNewMenu(MenuID inMenuID, MenuAttributes inMenuAttributes,
                MenuRef *outMenuRef);
 
  OSStatus
  CreateCustomMenu(const MenuDefSpec *inDefSpec, MenuID inMenuID,
                   MenuAttributes inMenuAttributes, MenuRef *outMenuRef);
 
  Boolean
  IsValidMenu(MenuRef inMenu);
 
  ItemCount
  GetMenuRetainCount(MenuRef inMenu);
 
  OSStatus
  RetainMenu(MenuRef inMenu);
 
  OSStatus
  ReleaseMenu(MenuRef inMenu);
 
  OSStatus
  DuplicateMenu(MenuRef inSourceMenu, MenuRef *outMenu);
 
  OSStatus
  CopyMenuTitleAsCFString(MenuRef inMenu, CFStringRef *outString);
 
  OSStatus
  SetMenuTitleWithCFString(MenuRef inMenu, CFStringRef inString);
 
  OSStatus
  SetMenuTitleIcon(MenuRef inMenu, UInt32 inType, void *inIcon);
 
  OSStatus
  GetMenuTitleIcon(MenuRef inMenu, UInt32 *outType, /* can be NULL */
                   void **outIcon);                 /* can be NULL */
 
  OSStatus
  InvalidateMenuSize(MenuRef inMenu);
 
  Boolean
  IsMenuSizeInvalid(MenuRef inMenu);
 
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  /*  ©©MDEF support */
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  OSStatus
  EraseMenuBackground(MenuRef inMenu, const Rect *inEraseRect,
                      CGContextRef inContext); /* can be NULL */
 
  OSStatus
  ScrollMenuImage(MenuRef inMenu, const Rect *inScrollRect, int inHScroll,
                  int inVScroll, CGContextRef inContext); /* can be NULL */
 
/*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
/*  © Menu Item Insertion */
/*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
#if TARGET_OS_MAC
#define MacAppendMenu AppendMenu
#endif
  void
  MacAppendMenu(MenuRef menu, ConstStr255Param data);
 
  void
  InsertResMenu(MenuRef theMenu, ResType theType, short afterItem);
 
  void
  AppendResMenu(MenuRef theMenu, ResType theType);
 
#if TARGET_OS_MAC
#define MacInsertMenuItem InsertMenuItem
#endif
  void
  MacInsertMenuItem(MenuRef theMenu, ConstStr255Param itemString, short afterItem);
 
  void
  DeleteMenuItem(MenuRef theMenu, short item);
 
  void
  InsertFontResMenu(MenuRef theMenu, short afterItem, short scriptFilter);
 
  void
  InsertIntlResMenu(MenuRef theMenu, ResType theType, short afterItem,
                    short scriptFilter);
 
  OSStatus
  AppendMenuItemText(MenuRef menu, ConstStr255Param inString);
 
  OSStatus
  InsertMenuItemText(MenuRef menu, ConstStr255Param inString,
                     MenuItemIndex afterItem);
 
  OSStatus
  CopyMenuItems(MenuRef inSourceMenu, MenuItemIndex inFirstItem,
                ItemCount inNumItems, MenuRef inDestMenu,
                MenuItemIndex inInsertAfter);
 
  OSStatus
  DeleteMenuItems(MenuRef inMenu, MenuItemIndex inFirstItem,
                  ItemCount inNumItems);
 
  OSStatus
  AppendMenuItemTextWithCFString(MenuRef inMenu, CFStringRef inString,
                                 MenuItemAttributes inAttributes,
                                 MenuCommand inCommandID,
                                 MenuItemIndex *outNewItem); /* can be NULL */
 
  OSStatus
  InsertMenuItemTextWithCFString(MenuRef inMenu, CFStringRef inString,
                                 MenuItemIndex inAfterItem,
                                 MenuItemAttributes inAttributes,
                                 MenuCommand inCommandID);
 
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  /*  © Menu Events */
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  long
  MenuKey(CharParameter ch);
 
  long
  MenuSelect(Point startPt);
 
  long
  PopUpMenuSelect(MenuRef menu, short top, short left, short popUpItem);
 
  long
  MenuChoice(void);
 
  UInt32
  MenuEvent(const EventRecord *inEvent);
 
  Boolean
  IsMenuKeyEvent(MenuRef inStartMenu, EventRef inEvent,
                 MenuEventOptions inOptions, MenuRef *outMenu, /* can be NULL */
                 MenuItemIndex *outMenuItem);                  /* can be NULL */
 
  OSStatus
  InvalidateMenuEnabling(MenuRef inMenu);
 
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  /*  © Menu Bar */
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
 
  short
  GetMBarHeight(void);
 
#if TARGET_OS_MAC
#define MacDrawMenuBar DrawMenuBar
#endif
  void
  MacDrawMenuBar(void);
 
  void
  InvalMenuBar(void);
 
  Boolean
  IsMenuBarInvalid(MenuRef rootMenu);
 
  void
  HiliteMenu(MenuID menuID);
 
  MenuBarHandle
  GetNewMBar(short menuBarID);
 
  MenuBarHandle
  GetMenuBar(void);
 
  void
  SetMenuBar(MenuBarHandle mbar);
 
  OSStatus
  DuplicateMenuBar(MenuBarHandle inMbar, MenuBarHandle *outMbar);
 
  OSStatus
  DisposeMenuBar(MenuBarHandle inMbar);
 
  MenuRef
  GetMenuHandle(MenuID menuID);
 
#define GetMenuRef GetMenuHandle
#if TARGET_OS_MAC
#define MacInsertMenu InsertMenu
#endif
  void
  MacInsertMenu(MenuRef theMenu, MenuID beforeID);
 
#if TARGET_OS_MAC
#define MacDeleteMenu DeleteMenu
#endif
  void
  MacDeleteMenu(MenuID menuID);
 
  void
  ClearMenuBar(void);
 
#if CALL_NOT_IN_CARBON
 
  void
  SetMenuFlash(short count);
 
#endif /* CALL_NOT_IN_CARBON */
 
  void
  SetMenuFlashCount(short count);
#if CALL_NOT_IN_CARBON && !TARGET_CPU_68K
#ifdef __cplusplus
  inline DEFINE_API(void) SetMenuFlashCount(short count) { SetMenuFlash(count); }
#else
#define SetMenuFlashCount(count) (SetMenuFlash(count))
#endif
#endif
 
  void
  FlashMenuBar(MenuID menuID);
 
/* These are obsolete because Carbon does not support desk accessories.*/
#if CALL_NOT_IN_CARBON
  Boolean
  SystemEdit(short editCmd);
 
  void
  SystemMenu(long menuResult);
 
#endif /* CALL_NOT_IN_CARBON */
 
  Boolean
  IsMenuBarVisible(void);
 
  void
  ShowMenuBar(void);
 
  void
  HideMenuBar(void);
 
  MenuRef
  AcquireRootMenu(void);
 
  OSStatus
  SetRootMenu(MenuRef inMenu);
 
/*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
/*  © Menu Item Accessors */
/*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
#if CALL_NOT_IN_CARBON
  void
  CheckItem(MenuRef theMenu, short item, Boolean checked);
 
#endif /* CALL_NOT_IN_CARBON */
 
#if TARGET_OS_MAC
#define MacCheckMenuItem CheckMenuItem
#endif
  void
  MacCheckMenuItem(MenuRef theMenu, short item, Boolean checked);
#if CALL_NOT_IN_CARBON && !TARGET_CPU_68K
#ifdef __cplusplus
  inline DEFINE_API(void)
      MacCheckMenuItem(MenuRef theMenu, short item, Boolean checked)
  {
    CheckItem(theMenu, item, checked);
  }
#else
#if TARGET_OS_MAC
#define CheckMenuItem(theMenu, item, checked) \
  (CheckItem(theMenu, item, checked))
#else
#define MacCheckMenuItem(theMenu, item, checked) \
  (CheckItem(theMenu, item, checked))
#endif
#endif
#endif
 
  void
  SetMenuItemText(MenuRef theMenu, short item, ConstStr255Param itemString);
 
  void
  GetMenuItemText(MenuRef theMenu, short item, Str255 itemString);
 
  void
  SetItemMark(MenuRef theMenu, short item, CharParameter markChar);
 
  void
  GetItemMark(MenuRef theMenu, short item, CharParameter *markChar);
 
  // create submenu with two entries ...
  windowsSubMenu = NewMenu(SMID_CLWIND, "\pClose Window");
  AppendMenu(windowsSubMenu, "\pMyFile");
  </ pre>
              * \copyright THINK Reference © 1991 - 1992 Symantec Corporation
                                                        *    \non_carbon_cfm in InterfaceLib 7.1 and
      later
          *    \carbon_lib in CarbonLib 1.0 and
      later
          *    \mac_os_x in version 10.0 and
      later
              * /
          void
          SetItemCmd(MenuRef theMenu, short item, CharParameter cmdChar);
 
  void
  GetItemCmd(MenuRef theMenu, short item, CharParameter *cmdChar);
 
  void
  SetItemIcon(MenuRef theMenu, short item, short iconIndex);
 
  /* icon is returned in high byte of 16-bit iconIndex */
 
  void
  GetItemIcon(MenuRef theMenu, short item, short *iconIndex);
 
  void
  SetItemStyle(MenuRef theMenu, short item, StyleParameter chStyle);
 
  void
  GetItemStyle(MenuRef theMenu, short item, Style *chStyle);
 
/* These APIs are not supported in Carbon. Please use EnableMenuItem and */
/* DisableMenuItem (available back through Mac OS 8.5) instead.          */
#if CALL_NOT_IN_CARBON
 
  OSErr
  SetMenuItemCommandID(MenuRef inMenu, SInt16 inItem, MenuCommand inCommandID);
 
  OSErr
  GetMenuItemCommandID(MenuRef inMenu, SInt16 inItem, MenuCommand *outCommandID);
 
  OSErr
  SetMenuItemModifiers(MenuRef inMenu, SInt16 inItem, UInt8 inModifiers);
 
  OSErr
  GetMenuItemModifiers(MenuRef inMenu, SInt16 inItem, UInt8 *outModifiers);
 
  OSErr
  SetMenuItemIconHandle(MenuRef inMenu, SInt16 inItem, UInt8 inIconType,
                        Handle inIconHandle);
 
  OSErr
  GetMenuItemIconHandle(MenuRef inMenu, SInt16 inItem, UInt8 *outIconType,
                        Handle *outIconHandle);
 
  OSErr
  SetMenuItemTextEncoding(MenuRef inMenu, SInt16 inItem, TextEncoding inScriptID);
 
  OSErr
  GetMenuItemTextEncoding(MenuRef inMenu, SInt16 inItem,
                          TextEncoding *outScriptID);
 
  OSErr
  SetMenuItemHierarchicalID(MenuRef inMenu, SInt16 inItem, MenuID inHierID);
 
  OSErr
  GetMenuItemHierarchicalID(MenuRef inMenu, SInt16 inItem, MenuID *outHierID);
 
  OSErr
  SetMenuItemFontID(MenuRef inMenu, SInt16 inItem, SInt16 inFontID);
 
  OSErr
  GetMenuItemFontID(MenuRef inMenu, SInt16 inItem, SInt16 *outFontID);
 
  OSErr
  SetMenuItemRefCon(MenuRef inMenu, SInt16 inItem, UInt32 inRefCon);
 
  OSErr
  GetMenuItemRefCon(MenuRef inMenu, SInt16 inItem, UInt32 *outRefCon);
 
/* Please use the menu item property APIs in Carbon.*/
#if CALL_NOT_IN_CARBON
  OSErr
  SetMenuItemRefCon2(MenuRef inMenu, SInt16 inItem, UInt32 inRefCon2);
 
  OSErr
  GetMenuItemRefCon2(MenuRef inMenu, SInt16 inItem, UInt32 *outRefCon2);
 
#endif /* CALL_NOT_IN_CARBON */
 
  OSErr
  SetMenuItemKeyGlyph(MenuRef inMenu, SInt16 inItem, SInt16 inGlyph);
 
  OSErr
  GetMenuItemKeyGlyph(MenuRef inMenu, SInt16 inItem, SInt16 *outGlyph);
 
/* Routines available in Mac OS 8.5 and later (supporting enabling/disabling of
 * > 31 items)*/
 
#if TARGET_OS_MAC
#define MacEnableMenuItem EnableMenuItem
#endif
  void
  MacEnableMenuItem(MenuRef theMenu, MenuItemIndex item);
 
  void
  DisableMenuItem(MenuRef theMenu, MenuItemIndex item);
 
  Boolean
  IsMenuItemEnabled(MenuRef menu, MenuItemIndex item);
 
  void
  EnableMenuItemIcon(MenuRef theMenu, MenuItemIndex item);
 
  void
  DisableMenuItemIcon(MenuRef theMenu, MenuItemIndex item);
 
  Boolean
  IsMenuItemIconEnabled(MenuRef menu, MenuItemIndex item);
 
  OSStatus
  SetMenuItemHierarchicalMenu(MenuRef inMenu, MenuItemIndex inItem,
                              MenuRef inHierMenu); /* can be NULL */
 
  OSStatus
  GetMenuItemHierarchicalMenu(MenuRef inMenu, MenuItemIndex inItem,
                              MenuRef *outHierMenu);
 
  OSStatus
  CopyMenuItemTextAsCFString(MenuRef inMenu, MenuItemIndex inItem,
                             CFStringRef *outString);
 
  OSStatus
  SetMenuItemTextWithCFString(MenuRef inMenu, MenuItemIndex inItem,
                              CFStringRef inString);
 
  OSStatus
  GetMenuItemIndent(MenuRef inMenu, MenuItemIndex inItem, UInt32 *outIndent);
 
  OSStatus
  SetMenuItemIndent(MenuRef inMenu, MenuItemIndex inItem, UInt32 inIndent);
 
  OSStatus
  GetMenuItemCommandKey(MenuRef inMenu, MenuItemIndex inItem,
                        Boolean inGetVirtualKey, UInt16 *outKey);
 
  OSStatus
  SetMenuItemCommandKey(MenuRef inMenu, MenuItemIndex inItem,
                        Boolean inSetVirtualKey, UInt16 inKey);
 
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  /*  © Menu Item Color Tables */
  /*                                                                                      */
  /*  Menu color manipulation is considered deprecated with the advent of the
   * Appearance  */
  /*  Manager.  Avoid using these routines if possible */
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  void
  DeleteMCEntries(MenuID menuID, short menuItem);
 
  MCTableHandle
  GetMCInfo(void);
 
  void
  SetMCInfo(MCTableHandle menuCTbl);
 
  void
  DisposeMCInfo(MCTableHandle menuCTbl);
 
  myMCE.mctRGB2.green = 0;
  myMCE.mctRGB2.blue = 0;
  MyHeapScramble();        // do something to move memory
  SetMCEntries(1, &myMCE); // NOT ptrMCE; may have moved
  Use GetMCInfo to get a copy of the entire menu color table.</ pre>
              * \copyright THINK Reference © 1991 -
          1992 Symantec Corporation
              *    \non_carbon_cfm in InterfaceLib 7.1 and
      later
          *    \carbon_lib in CarbonLib 1.0 and
      later
          *    \mac_os_x in version 10.0 and
      later
              * /
          MCEntryPtr
          GetMCEntry(MenuID menuID, short menuItem);
 
  void
  SetMCEntries(short numEntries, MCTablePtr menuCEntries);
 
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  /* © Properties  (Mac OS 8.5 and later) */
  /*                                                                                      */
  /* With the following property APIs, you can attach any piece of data you'd like
   * to a   */
  /* menu or menu item. Passing zero for the item number parameter indicates you'd
   * like   */
  /* to attach the data to the menu itself, and not to any specific menu item. */
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  enum
  {
    kMenuPropertyPersistent =
        0x00000001 /* whether this property gets saved when flattening the menu*/
  };
 
  OSStatus
  GetMenuItemProperty(MenuRef menu, MenuItemIndex item, OSType propertyCreator,
                      OSType propertyTag, UInt32 bufferSize, UInt32 *actualSize,
                      void *propertyBuffer);
 
  OSStatus
  GetMenuItemPropertySize(MenuRef menu, MenuItemIndex item,
                          OSType propertyCreator, OSType propertyTag,
                          UInt32 *size);
 
  OSStatus
  SetMenuItemProperty(MenuRef menu, MenuItemIndex item, OSType propertyCreator,
                      OSType propertyTag, UInt32 propertySize,
                      const void *propertyData);
 
  OSStatus
  RemoveMenuItemProperty(MenuRef menu, MenuItemIndex item, OSType propertyCreator,
                         OSType propertyTag);
 
  OSStatus
  GetMenuItemPropertyAttributes(MenuRef menu, MenuItemIndex item,
                                OSType propertyCreator, OSType propertyTag,
                                UInt32 *attributes);
 
  OSStatus
  ChangeMenuItemPropertyAttributes(MenuRef menu, MenuItemIndex item,
                                   OSType propertyCreator, OSType propertyTag,
                                   UInt32 attributesToSet,
                                   UInt32 attributesToClear);
 
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  /*  © Attributes (Carbon and later) */
  /*                                                                                      */
  /*  Each menu and menu item has attribute flags. */
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  OSStatus
  GetMenuAttributes(MenuRef menu, MenuAttributes *outAttributes);
 
  OSStatus
  ChangeMenuAttributes(MenuRef menu, MenuAttributes setTheseAttributes,
                       MenuAttributes clearTheseAttributes);
 
  OSStatus
  GetMenuItemAttributes(MenuRef menu, MenuItemIndex item,
                        MenuItemAttributes *outAttributes);
 
  OSStatus
  ChangeMenuItemAttributes(MenuRef menu, MenuItemIndex item,
                           MenuItemAttributes setTheseAttributes,
                           MenuItemAttributes clearTheseAttributes);
 
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  /*  © Mass menu item enabling and disabling (Carbon and later) */
  /*                                                                                      */
  /*  Useful when rewriting code that modifies the enableFlags field directly. */
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  void
  DisableAllMenuItems(MenuRef theMenu);
 
  void
  EnableAllMenuItems(MenuRef theMenu);
 
  Boolean
  MenuHasEnabledItems(MenuRef theMenu);
 
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  /*  © Menu tracking status (Carbon and later) */
  /*                                                                                      */
  /*  Get info about the selected menu item during menu tracking. Replaces direct
   * access  */
  /*  to low-mem globals that previously held this info. */
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  OSStatus
  GetMenuTrackingData(MenuRef theMenu, MenuTrackingData *outData);
 
  OSStatus
  GetMenuType(MenuRef theMenu, UInt16 *outType);
 
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  /*  ©©Universal command ID access (Carbon and later) */
  /*                                                                                      */
  /*  These APIs allow you to operate on menu items strictly by command ID, with
   * no       */
  /*  knowledge of a menu item's index. */
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  ItemCount
  CountMenuItemsWithCommandID(MenuRef inMenu, MenuCommand inCommandID);
 
  OSStatus
  GetIndMenuItemWithCommandID(MenuRef inMenu, MenuCommand inCommandID,
                              UInt32 inItemIndex,
                              MenuRef *outMenu,         /* can be NULL */
                              MenuItemIndex *outIndex); /* can be NULL */
 
  void
  EnableMenuCommand(MenuRef inMenu, MenuCommand inCommandID);
 
  void
  DisableMenuCommand(MenuRef inMenu, MenuCommand inCommandID);
 
  Boolean
  IsMenuCommandEnabled(MenuRef inMenu, MenuCommand inCommandID);
 
  OSStatus
  SetMenuCommandMark(MenuRef inMenu, MenuCommand inCommandID, UniChar inMark);
 
  OSStatus
  GetMenuCommandMark(MenuRef inMenu, MenuCommand inCommandID, UniChar *outMark);
 
  OSStatus
  GetMenuCommandProperty(MenuRef inMenu, MenuCommand inCommandID,
                         OSType inPropertyCreator, OSType inPropertyTag,
                         ByteCount inBufferSize,
                         ByteCount *outActualSize, /* can be NULL */
                         void *inPropertyBuffer);
 
  OSStatus
  GetMenuCommandPropertySize(MenuRef inMenu, MenuCommand inCommandID,
                             OSType inPropertyCreator, OSType inPropertyTag,
                             ByteCount *outSize);
 
  OSStatus
  SetMenuCommandProperty(MenuRef inMenu, MenuCommand inCommandID,
                         OSType inPropertyCreator, OSType inPropertyTag,
                         ByteCount inPropertySize, const void *inPropertyData);
 
  OSStatus
  RemoveMenuCommandProperty(MenuRef inMenu, MenuCommand inCommandID,
                            OSType inPropertyCreator, OSType inPropertyTag);
 
  OSStatus
  CopyMenuItemData(MenuRef menu, MenuItemID item, Boolean isCommandID,
                   MenuItemDataPtr outData);
 
  OSStatus
  SetMenuItemData(MenuRef menu, MenuItemID item, Boolean isCommandID,
                  const MenuItemDataRec *data);
 
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  /*  © Dynamic menu item support (CarbonLib 1.1 and Carbon for Mac OS X, and
   * later)      */
  /*                                                                                      */
  /*  Dynamic menu item support allows a menu item to be redrawn while the menu is
   * open   */
  /*  and visible to the user. Carbon contains automatic support for dynamic items
   * based  */
  /*  on keyboard modifier state. If you need to implement your own variable item
   * state   */
  /*  based on other system state, you can use these APIs to implement it. */
  /*                                                                                      */
  /*  To use the built-in support for dynamic items, you should create a menu
   * containing  */
  /*  several contiguous items with the same command key but different text and
   * modifier  */
  /*  keys. For example, you might have: */
  /*                                                                                      */
  /*      Close       cmd-W */
  /*      Close All   cmd-option-W */
  /*                                                                                      */
  /*  In your MENU resource, you would create the Close and Close All items and
   * give      */
  /*  them each the letter 'W' as the command key; using an associated xmnu
   * resource,     */
  /*  you would specify kMenuOptionModifier as the modifier for the Close All
   * item.       */
  /*                                                                                      */
  /*  After loading your menu from the resource, you must set the
   * kMenuItemAttrDynamic    */
  /*  flag for each dynamic item. In this example, you would use: */
  /*                                                                                      */
  /*      ChangeMenuItemAttributes( menu, kCloseItem, kMenuItemAttrDynamic, 0 );
   */
  /*      ChangeMenuItemAttributes( menu, kCloseAllItem, kMenuItemAttrDynamic, 0
   * );       */
  /*                                                                                      */
  /*  The Menu Manager will now automatically display the correct item depending
   * on       */
  /*  whether the Option key is pressed. The result from MenuSelect will be the
   * item      */
  /*  number of the item that was visible when the menu closed. */
  /*                                                                                      */
  /*  If the Menu Manager's built-in support is not sufficient, you can also
   * change the   */
  /*  attributes of an item yourself and use the UpdateInvalidMenuItems API to
   * cause      */
  /*  the menu to redraw. Changes to a menu item (changing text, command key,
   * style,      */
  /*  etc.) that occur while the menu is open will cause the menu item to be
   * invalidated, */
  /*  but not redrawn. If you need to invalidate the item explicitly yourself,
   * perhaps    */
  /*  because you have a custom MDEF that depends on state not accessed using Menu
   */
  /*  Manager APIs, you can use the InvalidateMenuItems API.
   * UpdateInvalidMenuItems will  */
  /*  scan the menu for invalid items and redraw each, clearing its invalid flag
   */
  /*  afterwards. */
  /*                                                                                      */
  /*  If you need to change menu contents based on modifier key state without
   * using the   */
  /*  built-in support in the Menu Manager, we recommend that you install a Carbon
   * event  */
  /*  handler on your menu for the [kEventClassKeyboard,
   * kEventRawKeyModifiersChanged]    */
  /*  event. Modifier key events are passed to the currently open menu before
   * being sent  */
  /*  to the user focus target. */
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  Boolean
  IsMenuItemInvalid(MenuRef menu, MenuItemIndex item);
 
  OSStatus
  InvalidateMenuItems(MenuRef menu, MenuItemIndex firstItem, ItemCount numItems);
 
  OSStatus
  UpdateInvalidMenuItems(MenuRef menu);
 
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  /*  ©©Standard font menu (Carbon and later) */
  /*                                                                                      */
  /*  These APIs allow you to create and use the standard font menu. */
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  enum
  {
    kHierarchicalFontMenuOption = 0x00000001
  };
 
  OSStatus
  CreateStandardFontMenu(MenuRef menu, MenuItemIndex afterItem,
                         MenuID firstHierMenuID, OptionBits options,
                         ItemCount *outHierMenuCount);
 
  OSStatus
  UpdateStandardFontMenu(MenuRef menu, ItemCount *outHierMenuCount);
 
  OSStatus
  GetFontFamilyFromMenuSelection(MenuRef menu, MenuItemIndex item,
                                 FMFontFamily *outFontFamily,
                                 FMFontStyle *outStyle);
 
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  /*  © Contextual Menu routines and constants */
  /*  available with Conxtextual Menu extension 1.0 and later */
  /*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
  /* Gestalt Selector for classic 68K apps only. */
  /* CFM apps should weak link and check the symbols. */
  enum
  {
    gestaltContextualMenuAttr = FOUR_CHAR_CODE('cmnu'),
    gestaltContextualMenuUnusedBit = 0,
    gestaltContextualMenuTrapAvailable = 1
  };
 
  /* Values indicating what kind of help the application supports */
  enum
  {
    kCMHelpItemNoHelp = 0,
    kCMHelpItemAppleGuide = 1,
    kCMHelpItemOtherHelp = 2
  };
 
  /* Values indicating what was chosen from the menu */
  enum
  {
    kCMNothingSelected = 0,
    kCMMenuItemSelected = 1,
    kCMShowHelpSelected = 3
  };
 
  OSStatus
  InitContextualMenus(void);
 
  Boolean
  IsShowContextualMenuClick(const EventRecord *inEvent);
 
  Boolean
  IsShowContextualMenuEvent(EventRef inEvent);
 
  OSStatus
  ContextualMenuSelect(MenuRef inMenu, Point inGlobalLocation, Boolean inReserved,
                       UInt32 inHelpType,
                       ConstStr255Param inHelpItemString, /* can be NULL */
                       const AEDesc *inSelection,         /* can be NULL */
                       UInt32 *outUserSelectionType, SInt16 *outMenuID,
                       MenuItemIndex *outMenuItem);
 
  Boolean
  ProcessIsContextualMenuClient(ProcessSerialNumber *inPSN);
 
/*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
/*  Contextual Menu Plugin Interface */
/*                                                                                      */
/*  For Mac OS X, we will support a new type of Contextual Menu Plugin: the
 * CFPlugIn    */
/*  based plugin.  Each plugin must be in a CFPlugIn in the Contextual Menu
 * Items       */
/*  folder in one of these paths: */
/*      /System/Library/Contextual Menu Items/ */
/*      /Library/Contextual Menu Items/ */
/*      ~/Library/Contextual Menu Items/ */
/*                                                                                      */
/*  It must export the following functions using the following interface or a
 * C++       */
/*  interface inheriting from IUnknown and including similar functions. */
/*©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©*/
 
/* The Contextual Menu Manager will only load CFPlugIns of type
 * kContextualMenuTypeID */
#define kContextualMenuTypeID                                               \
  (CFUUIDGetConstantUUIDWithBytes(NULL, 0x2F, 0x65, 0x22, 0xE9, 0x3E, 0x66, \
                                  0x11, 0xD5, 0x80, 0xA7, 0x00, 0x30, 0x65, \
                                  0xB3, 0x00, 0xBC))
/* 2F6522E9-3E66-11D5-80A7-003065B300BC */
 
/* Contextual Menu Plugins must implement this Contexual Menu Plugin Interface
 */
#define kContextualMenuInterfaceID                                          \
  (CFUUIDGetConstantUUIDWithBytes(NULL, 0x32, 0x99, 0x7B, 0x62, 0x3E, 0x66, \
                                  0x11, 0xD5, 0xBE, 0xAB, 0x00, 0x30, 0x65, \
                                  0xB3, 0x00, 0xBC))
  /* 32997B62-3E66-11D5-BEAB-003065B300BC */
 
#define CM_IUNKNOWN_C_GUTS                                                  \
  void *_reserved;                                                          \
  SInt32 (*QueryInterface)(void *thisPointer, CFUUIDBytes iid, void **ppv); \
  UInt32 (*AddRef)(void *thisPointer);                                      \
  UInt32 (*Release)(void *thisPointer)
 
  // The function table for the interface
  struct ContextualMenuInterfaceStruct
  {
    CM_IUNKNOWN_C_GUTS;
    OSStatus (*ExamineContext)(void *thisInstance, const AEDesc *inContext,
                               AEDescList *outCommandPairs);
    OSStatus (*HandleSelection)(void *thisInstance, AEDesc *inContext,
                                SInt32 inCommandID);
    void (*PostMenuCleanup)(void *thisInstance);
  };
  typedef struct ContextualMenuInterfaceStruct ContextualMenuInterfaceStruct;
 
  OSStatus
  CMPluginExamineContext(void *thisInstance, const AEDesc *inContext,
                         AEDescList *outCommandPairs);
 
  OSStatus
  CMPluginHandleSelection(void *thisInstance, AEDesc *inContext,
                          SInt32 inCommandID);
 
  void
  CMPluginPostMenuCleanup(void *thisInstance);
 
  /* previously in LowMem.h.  This functions return the menu ID of the hilited
   * menu */
  SInt16
  LMGetTheMenu(void);
 
#if CALL_NOT_IN_CARBON
  MenuRef
  newmenu(MenuID menuID, const char *menuTitle);
 
  void
  appendmenu(MenuRef menu, const char *data);
 
  void
  insertmenuitem(MenuRef theMenu, const char *itemString, short afterItem);
 
  long
  menuselect(const Point *startPt);
 
  void
  setmenuitemtext(MenuRef menu, short item, const char *itemString);
 
  void
  getmenuitemtext(MenuRef menu, short item, char *itemString);
 
#endif /* CALL_NOT_IN_CARBON */
 
#if OLDROUTINENAMES
#define AddResMenu(theMenu, theType) AppendResMenu(theMenu, theType)
#define InsMenuItem(theMenu, itemString, afterItem) \
  InsertMenuItem(theMenu, itemString, afterItem)
#define DelMenuItem(theMenu, item) DeleteMenuItem(theMenu, item)
#if TARGET_OS_MAC
#define SetItem MacSetItem
#define GetItem MacGetItem
#endif
#define MacSetItem(theMenu, item, itemString) \
  SetMenuItemText(theMenu, item, itemString)
#define MacGetItem(theMenu, item, itemString) \
  GetMenuItemText(theMenu, item, itemString)
#define GetMHandle(menuID) GetMenuHandle(menuID)
#define DelMCEntries(menuID, menuItem) DeleteMCEntries(menuID, menuItem)
#define DispMCInfo(menuCTbl) DisposeMCInfo(menuCTbl)
#if CALL_NOT_IN_CARBON
#define addresmenu(menu, data) appendresmenu(menu, data)
#define getitem(menu, item, itemString) getmenuitemtext(menu, item, itemString)
#define setitem(menu, item, itemString) setmenuitemtext(menu, item, itemString)
#define insmenuitem(theMenu, itemString, afterItem) \
  insertmenuitem(theMenu, itemString, afterItem)
#endif
#endif /* OLDROUTINENAMES */
 
#if ACCESSOR_CALLS_ARE_FUNCTIONS
  /* Getters */
  MenuID
  GetMenuID(MenuRef menu);
 
  SInt16
  GetMenuWidth(MenuRef menu);
 
  SInt16
  GetMenuHeight(MenuRef menu);
 
  StringPtr
  GetMenuTitle(MenuRef menu, Str255 title);
 
  OSStatus
  GetMenuDefinition(MenuRef menu, MenuDefSpecPtr outDefSpec);
 
  /* Setters */
  void
  SetMenuID(MenuRef menu, MenuID menuID);
 
  void
  SetMenuWidth(MenuRef menu, SInt16 width);
 
  void
  SetMenuHeight(MenuRef menu, SInt16 height);
 
  OSStatus
  SetMenuTitle(MenuRef menu, ConstStr255Param title);
 
  OSStatus
  SetMenuDefinition(MenuRef menu, const MenuDefSpec *defSpec);
 
#endif /* ACCESSOR_CALLS_ARE_FUNCTIONS */
 
#if TARGET_OS_WIN32
#endif /* TARGET_OS_WIN32 */
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* __MENUS__ */
* / setmenuitemtext(menu, item, itemString)
#define insmenuitem(theMenu, itemString, afterItem) \
  insertmenuitem(theMenu, itemString, afterItem)
#endif
#endif /* OLDROUTINENAMES */
 
#if ACCESSOR_CALLS_ARE_FUNCTIONS
    /* Getters */
    MenuID
    GetMenuID(MenuRef menu);
 
SInt16
GetMenuWidth(MenuRef menu);
 
SInt16
GetMenuHeight(MenuRef menu);
 
StringPtr
GetMenuTitle(MenuRef menu, Str255 title);
 
OSStatus
GetMenuDefinition(MenuRef menu, MenuDefSpecPtr outDefSpec);
 
/* Setters */
void SetMenuID(MenuRef menu, MenuID menuID);
 
void SetMenuWidth(MenuRef menu, SInt16 width);
 
void SetMenuHeight(MenuRef menu, SInt16 height);
 
OSStatus
SetMenuTitle(MenuRef menu, ConstStr255Param title);
 
OSStatus
SetMenuDefinition(MenuRef menu, const MenuDefSpec *defSpec);
 
#endif /* ACCESSOR_CALLS_ARE_FUNCTIONS */
 
#if TARGET_OS_WIN32
#endif /* TARGET_OS_WIN32 */
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* __MENUS__ */
* / RAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif                    /* __MENUS__ */
* /*/*/ * /*/*/ * /*/*/ * /*/*/