开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
Menus.h
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：58k
源码类别：

多媒体编程

开发平台：

Visual C++

Menus.h：源码内容
  1. /*
  2.      File:       Menus.h
  3.  
  4.      Contains:   Menu Manager Interfaces.
  5.  
  6.      Version:    Technology: Mac OS 9.0
  7.                  Release:    QuickTime 6.0.2
  8.  
  9.      Copyright:  (c) 1985-2001 by Apple Computer, Inc., all rights reserved.
  10.  
  11.      Bugs?:      For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. */
  17. #ifndef __MENUS__
  18. #define __MENUS__
  20. #ifndef __MACTYPES__
  21. #include "MacTypes.h"
  22. #endif
  24. #ifndef __EVENTS__
  25. #include "Events.h"
  26. #endif
  28. #ifndef __QUICKDRAW__
  29. #include "Quickdraw.h"
  30. #endif
  32. #ifndef __FONTS__
  33. #include "Fonts.h"
  34. #endif
  36. #ifndef __TEXTCOMMON__
  37. #include "TextCommon.h"
  38. #endif
  40. #ifndef __PROCESSES__
  41. #include "Processes.h"
  42. #endif
  44. #ifndef __APPLEEVENTS__
  45. #include "AppleEvents.h"
  46. #endif
  48. #ifndef __COLLECTIONS__
  49. #include "Collections.h"
  50. #endif
  52. #ifndef __MACERRORS__
  53. #include "MacErrors.h"
  54. #endif
  58. #if PRAGMA_ONCE
  59. #pragma once
  60. #endif
  62. #ifdef __cplusplus
  63. extern "C" {
  64. #endif
  66. #if PRAGMA_IMPORT
  67. #pragma import on
  68. #endif
  70. #if PRAGMA_STRUCT_ALIGN
  71.     #pragma options align=mac68k
  72. #elif PRAGMA_STRUCT_PACKPUSH
  73.     #pragma pack(push, 2)
  74. #elif PRAGMA_STRUCT_PACK
  75.     #pragma pack(2)
  76. #endif
  79. /*--------------------------------------------------------------------------------------*/
  80. /*  o Menu Constants                                                                    */
  81. /*--------------------------------------------------------------------------------------*/
  82. enum {
  83.     noMark                      = 0                             /*mark symbol for MarkItem*/
  84. };
  86. enum {
  87.                                                                 /* menu defProc messages */
  88.     kMenuDrawMsg                = 0,
  89.     kMenuSizeMsg                = 2,
  90.     kMenuPopUpMsg               = 3,
  91.     kMenuCalcItemMsg            = 5,
  92.     kMenuThemeSavvyMsg          = 7,                            /* is your MDEF theme-savvy?  If so, return hex 7473 in the whichItem parameter*/
  93.     mDrawMsg                    = 0,
  94.     mSizeMsg                    = 2,
  95.     mPopUpMsg                   = 3,                            /* position the popup menu rect appropriately */
  96.     mCalcItemMsg                = 5
  97. };
  99. #if CALL_NOT_IN_CARBON
  100. /*
  101.    Carbon MDEFs must replace mChooseMsg with the new messages kMenuFindItemMsg and kMenuHiliteItemMsg. 
  102.    mDrawItemMsg was used by the popup menu control before 8.5, but is no longer used. 
  103. */
  104. enum {
  105.     mChooseMsg                  = 1,
  106.     mDrawItemMsg                = 4,
  107.     kMenuChooseMsg              = 1,
  108.     kMenuDrawItemMsg            = 4
  109. };
  111. #endif  /* CALL_NOT_IN_CARBON */
  113. enum {
  114.     kThemeSavvyMenuResponse     = 0x7473
  115. };
  117. /* these MDEF messages are only supported in Carbon*/
  118. enum {
  119.     kMenuInitMsg                = 8,
  120.     kMenuDisposeMsg             = 9,
  121.     kMenuFindItemMsg            = 10,
  122.     kMenuHiliteItemMsg          = 11
  123. };
  125. enum {
  126.     textMenuProc                = 0,
  127.     hMenuCmd                    = 27,                           /*itemCmd == 0x001B ==> hierarchical menu*/
  128.     hierMenu                    = -1,                           /*a hierarchical menu - for InsertMenu call*/
  129.     kInsertHierarchicalMenu     = -1,                           /*a better name for hierMenu */
  130.     mctAllItems                 = -98,                          /*search for all Items for the given ID*/
  131.     mctLastIDIndic              = -99                           /*last color table entry has this in ID field*/
  132. };
  134. /* Constants for use with MacOS 8.0 (Appearance 1.0) and later*/
  135. enum {
  136.     kMenuStdMenuProc            = 63,
  137.     kMenuStdMenuBarProc         = 63
  138. };
  140. enum {
  141.     kMenuNoModifiers            = 0,                            /* Mask for no modifiers*/
  142.     kMenuShiftModifier          = (1 << 0),                     /* Mask for shift key modifier*/
  143.     kMenuOptionModifier         = (1 << 1),                     /* Mask for option key modifier*/
  144.     kMenuControlModifier        = (1 << 2),                     /* Mask for control key modifier*/
  145.     kMenuNoCommandModifier      = (1 << 3)                      /* Mask for no command key modifier*/
  146. };
  148. enum {
  149.     kMenuNoIcon                 = 0,                            /* No icon*/
  150.     kMenuIconType               = 1,                            /* Type for ICON*/
  151.     kMenuShrinkIconType         = 2,                            /* Type for ICON plotted 16 x 16*/
  152.     kMenuSmallIconType          = 3,                            /* Type for SICN*/
  153.     kMenuColorIconType          = 4,                            /* Type for cicn*/
  154.     kMenuIconSuiteType          = 5,                            /* Type for Icon Suite*/
  155.     kMenuIconRefType            = 6                             /* Type for Icon Ref*/
  156. };
  158. enum {
  159.     kMenuAttrExcludesMarkColumn = (1 << 0),                     /* No space is allocated for the mark character */
  160.     kMenuAttrAutoDisable        = (1 << 2)                      /* Menu title is automatically disabled when all items are disabled */
  161. };
  163. typedef OptionBits                      MenuAttributes;
  164. enum {
  165.     kMenuItemAttrSubmenuParentChoosable = (1 << 2)              /* Parent item of a submenu is still selectable by the user */
  166. };
  168. typedef OptionBits                      MenuItemAttributes;
  170. typedef UInt32 MenuTrackingMode;
  171. enum {
  172.     kMenuTrackingModeMouse      = 1,                            /* Menus are being tracked using the mouse*/
  173.     kMenuTrackingModeKeyboard   = 2                             /* Menus are being tracked using the keyboard*/
  174. };
  176. /*--------------------------------------------------------------------------------------*/
  177. /*  o Menu Types                                                                        */
  178. /*--------------------------------------------------------------------------------------*/
  179. typedef SInt16                          MenuID;
  180. typedef UInt16                          MenuItemIndex;
  181. typedef UInt32                          MenuCommand;
  182. #if !OPAQUE_TOOLBOX_STRUCTS
  184. struct MenuInfo {
  185.     MenuID                          menuID;
  186.     short                           menuWidth;
  187.     short                           menuHeight;
  188.     Handle                          menuProc;
  189.     long                            enableFlags;
  190.     Str255                          menuData;
  191. };
  192. typedef struct MenuInfo                 MenuInfo;
  194. typedef MenuInfo *                      MenuPtr;
  195. typedef MenuPtr *                       MenuHandle;
  196. #else
  197. typedef struct OpaqueMenuHandle*        MenuHandle;
  198. #endif  /* !OPAQUE_TOOLBOX_STRUCTS */
  200. /* MenuRef and MenuHandle are equivalent. Use either. We don't care.*/
  201. typedef MenuHandle                      MenuRef;
  203. struct MCEntry {
  204.     MenuID                          mctID;                      /*menu ID.  ID = 0 is the menu bar*/
  205.     short                           mctItem;                    /*menu Item. Item = 0 is a title*/
  206.     RGBColor                        mctRGB1;                    /*usage depends on ID and Item*/
  207.     RGBColor                        mctRGB2;                    /*usage depends on ID and Item*/
  208.     RGBColor                        mctRGB3;                    /*usage depends on ID and Item*/
  209.     RGBColor                        mctRGB4;                    /*usage depends on ID and Item*/
  210.     short                           mctReserved;                /*reserved for internal use*/
  211. };
  212. typedef struct MCEntry                  MCEntry;
  213. typedef MCEntry *                       MCEntryPtr;
  215. typedef MCEntry                         MCTable[1];
  216. typedef MCEntry *                       MCTablePtr;
  217. typedef MCTablePtr *                    MCTableHandle;
  219. struct MenuCRsrc {
  220.     short                           numEntries;                 /*number of entries*/
  221.     MCTable                         mcEntryRecs;                /*ARRAY [1..numEntries] of MCEntry*/
  222. };
  223. typedef struct MenuCRsrc                MenuCRsrc;
  224. typedef MenuCRsrc *                     MenuCRsrcPtr;
  225. typedef MenuCRsrcPtr *                  MenuCRsrcHandle;
  226. #if TARGET_OS_WIN32
  227. /* QuickTime 3.0 */
  229. struct MenuAccessKeyRec {
  230.     short                           count;
  231.     long                            flags;
  232.     unsigned char                   keys[1];
  233. };
  234. typedef struct MenuAccessKeyRec         MenuAccessKeyRec;
  236. typedef MenuAccessKeyRec *              MenuAccessKeyPtr;
  237. typedef MenuAccessKeyPtr *              MenuAccessKeyHandle;
  238. #if CALL_NOT_IN_CARBON
  239. EXTERN_API_C( void )
  240. SetMenuItemHotKey               (MenuRef                menu,
  241.                                  short                  itemID,
  242.                                  char                   hotKey,
  243.                                  long                   flags);
  245. #endif  /* CALL_NOT_IN_CARBON */
  247. #endif  /* TARGET_OS_WIN32 */
  250. struct MenuTrackingData {
  251.     MenuRef                         menu;
  252.     MenuItemIndex                   itemSelected;
  253.     MenuItemIndex                   itemUnderMouse;
  254.     Rect                            itemRect;
  255.     SInt32                          virtualMenuTop;
  256.     SInt32                          virtualMenuBottom;
  257. };
  258. typedef struct MenuTrackingData         MenuTrackingData;
  259. typedef MenuTrackingData *              MenuTrackingDataPtr;
  261. struct HiliteMenuItemData {
  262.     MenuItemIndex                   previousItem;
  263.     MenuItemIndex                   newItem;
  264. };
  265. typedef struct HiliteMenuItemData       HiliteMenuItemData;
  266. typedef HiliteMenuItemData *            HiliteMenuItemDataPtr;
  267. /*--------------------------------------------------------------------------------------*/
  268. /*  o Menu ProcPtrs                                                                     */
  269. /*                                                                                      */
  270. /*  All of these procs are considered deprecated.  Developers interested in portability */
  271. /*  to Carbon should avoid them entirely, if at all possible.                           */
  272. /*--------------------------------------------------------------------------------------*/
  273. typedef CALLBACK_API( void , MenuDefProcPtr )(short message, MenuRef theMenu, Rect *menuRect, Point hitPt, short *whichItem);
  274. typedef STACK_UPP_TYPE(MenuDefProcPtr)                          MenuDefUPP;
  275. #if OPAQUE_UPP_TYPES
  276.     EXTERN_API(MenuDefUPP)
  277.     NewMenuDefUPP                  (MenuDefProcPtr          userRoutine);
  279.     EXTERN_API(void)
  280.     DisposeMenuDefUPP              (MenuDefUPP              userUPP);
  282.     EXTERN_API(void)
  283.     InvokeMenuDefUPP               (short                   message,
  284.                                     MenuRef                 theMenu,
  285.                                     Rect *                  menuRect,
  286.                                     Point                   hitPt,
  287.                                     short *                 whichItem,
  288.                                     MenuDefUPP              userUPP);
  290. #else
  291.     enum { uppMenuDefProcInfo = 0x0000FF80 };                       /* pascal no_return_value Func(2_bytes, 4_bytes, 4_bytes, 4_bytes, 4_bytes) */
  292.     #define NewMenuDefUPP(userRoutine)                              (MenuDefUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppMenuDefProcInfo, GetCurrentArchitecture())
  293.     #define DisposeMenuDefUPP(userUPP)                              DisposeRoutineDescriptor(userUPP)
  294.     #define InvokeMenuDefUPP(message, theMenu, menuRect, hitPt, whichItem, userUPP)  CALL_FIVE_PARAMETER_UPP((userUPP), uppMenuDefProcInfo, (message), (theMenu), (menuRect), (hitPt), (whichItem))
  295. #endif
  296. /* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
  297. #define NewMenuDefProc(userRoutine)                             NewMenuDefUPP(userRoutine)
  298. #define CallMenuDefProc(userRoutine, message, theMenu, menuRect, hitPt, whichItem) InvokeMenuDefUPP(message, theMenu, menuRect, hitPt, whichItem, userRoutine)
  299. typedef CALLBACK_API( long , MenuBarDefProcPtr )(short selector, short message, short parameter1, long parameter2);
  300. typedef CALLBACK_API( void , MenuHookProcPtr )(void );
  301. typedef CALLBACK_API( short , MBarHookProcPtr )(Rect *menuRect);
  302. typedef STACK_UPP_TYPE(MenuBarDefProcPtr)                       MenuBarDefUPP;
  303. typedef STACK_UPP_TYPE(MenuHookProcPtr)                         MenuHookUPP;
  304. typedef STACK_UPP_TYPE(MBarHookProcPtr)                         MBarHookUPP;
  305. #if OPAQUE_UPP_TYPES
  306. #if CALL_NOT_IN_CARBON
  307.     EXTERN_API(MenuBarDefUPP)
  308.     NewMenuBarDefUPP               (MenuBarDefProcPtr       userRoutine);
  310.     EXTERN_API(MenuHookUPP)
  311.     NewMenuHookUPP                 (MenuHookProcPtr         userRoutine);
  313.     EXTERN_API(MBarHookUPP)
  314.     NewMBarHookUPP                 (MBarHookProcPtr         userRoutine);
  316.     EXTERN_API(void)
  317.     DisposeMenuBarDefUPP           (MenuBarDefUPP           userUPP);
  319.     EXTERN_API(void)
  320.     DisposeMenuHookUPP             (MenuHookUPP             userUPP);
  322.     EXTERN_API(void)
  323.     DisposeMBarHookUPP             (MBarHookUPP             userUPP);
  325.     EXTERN_API(long)
  326.     InvokeMenuBarDefUPP            (short                   selector,
  327.                                     short                   message,
  328.                                     short                   parameter1,
  329.                                     long                    parameter2,
  330.                                     MenuBarDefUPP           userUPP);
  332.     EXTERN_API(void)
  333.     InvokeMenuHookUPP              (MenuHookUPP             userUPP);
  335.     EXTERN_API(short)
  336.     InvokeMBarHookUPP              (Rect *                  menuRect,
  337.                                     MBarHookUPP             userUPP);
  339. #endif  /* CALL_NOT_IN_CARBON */
  341. #else
  342.     enum { uppMenuBarDefProcInfo = 0x00003AB0 };                    /* pascal 4_bytes Func(2_bytes, 2_bytes, 2_bytes, 4_bytes) */
  343.     enum { uppMenuHookProcInfo = 0x00000000 };                      /* pascal no_return_value Func() */
  344.     enum { uppMBarHookProcInfo = 0x000000CF };                      /* SPECIAL_CASE_PROCINFO(12) */
  345.     #define NewMenuBarDefUPP(userRoutine)                           (MenuBarDefUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppMenuBarDefProcInfo, GetCurrentArchitecture())
  346.     #define NewMenuHookUPP(userRoutine)                             (MenuHookUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppMenuHookProcInfo, GetCurrentArchitecture())
  347.     #define NewMBarHookUPP(userRoutine)                             (MBarHookUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppMBarHookProcInfo, GetCurrentArchitecture())
  348.     #define DisposeMenuBarDefUPP(userUPP)                           DisposeRoutineDescriptor(userUPP)
  349.     #define DisposeMenuHookUPP(userUPP)                             DisposeRoutineDescriptor(userUPP)
  350.     #define DisposeMBarHookUPP(userUPP)                             DisposeRoutineDescriptor(userUPP)
  351.     #define InvokeMenuBarDefUPP(selector, message, parameter1, parameter2, userUPP)  (long)CALL_FOUR_PARAMETER_UPP((userUPP), uppMenuBarDefProcInfo, (selector), (message), (parameter1), (parameter2))
  352.     #define InvokeMenuHookUPP(userUPP)                              CALL_ZERO_PARAMETER_UPP((userUPP), uppMenuHookProcInfo)
  353.     #define InvokeMBarHookUPP(menuRect, userUPP)                    (short)CALL_ONE_PARAMETER_UPP((userUPP), uppMBarHookProcInfo, (menuRect))
  354. #endif
  355. /* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
  356. #define NewMenuBarDefProc(userRoutine)                          NewMenuBarDefUPP(userRoutine)
  357. #define NewMenuHookProc(userRoutine)                            NewMenuHookUPP(userRoutine)
  358. #define NewMBarHookProc(userRoutine)                            NewMBarHookUPP(userRoutine)
  359. #define CallMenuBarDefProc(userRoutine, selector, message, parameter1, parameter2) InvokeMenuBarDefUPP(selector, message, parameter1, parameter2, userRoutine)
  360. #define CallMenuHookProc(userRoutine)                           InvokeMenuHookUPP(userRoutine)
  361. #define CallMBarHookProc(userRoutine, menuRect)                 InvokeMBarHookUPP(menuRect, userRoutine)
  362. enum {
  363.     kMenuDefProcPtr             = 0                             /* raw proc-ptr access based on old MDEF */
  364. };
  367. typedef UInt32                          MenuDefType;
  369. struct MenuDefSpec {
  370.     MenuDefType                     defType;
  371.     union {
  372.         MenuDefUPP                      defProc;
  373.     }                                 u;
  374. };
  375. typedef struct MenuDefSpec              MenuDefSpec;
  376. typedef MenuDefSpec *                   MenuDefSpecPtr;
  377. /*--------------------------------------------------------------------------------------*/
  378. /*  o Menu Manager Initialization                                                       */
  379. /*--------------------------------------------------------------------------------------*/
  380. #if CALL_NOT_IN_CARBON
  381. EXTERN_API( void )
  382. InitProcMenu                    (short                  resID)                              ONEWORDINLINE(0xA808);
  384. EXTERN_API( void )
  385. InitMenus                       (void)                                                      ONEWORDINLINE(0xA930);
  387. /*--------------------------------------------------------------------------------------*/
  388. /*  o Menu Manipulation                                                                 */
  389. /*--------------------------------------------------------------------------------------*/
  390. #endif  /* CALL_NOT_IN_CARBON */
  392. EXTERN_API( MenuRef )
  393. NewMenu                         (MenuID                 menuID,
  394.                                  ConstStr255Param       menuTitle)                          ONEWORDINLINE(0xA931);
  396. #if TARGET_OS_MAC
  397.     #define MacGetMenu GetMenu
  398. #endif
  399. EXTERN_API( MenuRef )
  400. MacGetMenu                      (short                  resourceID)                         ONEWORDINLINE(0xA9BF);
  402. EXTERN_API( void )
  403. DisposeMenu                     (MenuRef                theMenu)                            ONEWORDINLINE(0xA932);
  405. EXTERN_API( void )
  406. CalcMenuSize                    (MenuRef                theMenu)                            ONEWORDINLINE(0xA948);
  408. EXTERN_API( short )
  409. CountMenuItems                  (MenuRef                theMenu)                            ONEWORDINLINE(0xA950);
  411. /* CountMItems() has been renamed to CountMenuItems() in Carbon */
  412. #if CALL_NOT_IN_CARBON
  413. EXTERN_API( short )
  414. CountMItems                     (MenuRef                theMenu)                            ONEWORDINLINE(0xA950);
  416. #if CALL_NOT_IN_CARBON
  417. #define CountMenuItems( menu )  CountMItems( menu )
  418. #endif /* CALL_NOT_IN_CARBON */
  420. /* Routines available in Mac OS 8.5 and later */
  422. #endif  /* CALL_NOT_IN_CARBON */
  424. EXTERN_API( OSStatus )
  425. GetMenuFont                     (MenuRef                menu,
  426.                                  SInt16 *               outFontID,
  427.                                  UInt16 *               outFontSize);
  429. EXTERN_API( OSStatus )
  430. SetMenuFont                     (MenuRef                menu,
  431.                                  SInt16                 inFontID,
  432.                                  UInt16                 inFontSize);
  434. EXTERN_API( Boolean )
  435. GetMenuExcludesMarkColumn       (MenuRef                menu);
  437. EXTERN_API( OSStatus )
  438. SetMenuExcludesMarkColumn       (MenuRef                menu,
  439.                                  Boolean                excludesMark);
  441. /* Routines available in Carbon only*/
  443. EXTERN_API( OSStatus )
  444. RegisterMenuDefinition          (SInt16                 inResID,
  445.                                  MenuDefSpecPtr         inDefSpec);
  447. EXTERN_API( OSStatus )
  448. CreateNewMenu                   (MenuID                 menuID,
  449.                                  MenuAttributes         menuAttributes,
  450.                                  MenuRef *              outMenuRef);
  452. EXTERN_API( OSStatus )
  453. CreateCustomMenu                (const MenuDefSpec *    defSpec,
  454.                                  MenuID                 menuID,
  455.                                  MenuAttributes         menuAttributes,
  456.                                  MenuRef *              outMenuRef);
  458. /*--------------------------------------------------------------------------------------*/
  459. /*  o Menu Item Insertion                                                               */
  460. /*--------------------------------------------------------------------------------------*/
  461. #if TARGET_OS_MAC
  462.     #define MacAppendMenu AppendMenu
  463. #endif
  464. EXTERN_API( void )
  465. MacAppendMenu                   (MenuRef                menu,
  466.                                  ConstStr255Param       data)                               ONEWORDINLINE(0xA933);
  468. EXTERN_API( void )
  469. InsertResMenu                   (MenuRef                theMenu,
  470.                                  ResType                theType,
  471.                                  short                  afterItem)                          ONEWORDINLINE(0xA951);
  473. EXTERN_API( void )
  474. AppendResMenu                   (MenuRef                theMenu,
  475.                                  ResType                theType)                            ONEWORDINLINE(0xA94D);
  477. #if TARGET_OS_MAC
  478.     #define MacInsertMenuItem InsertMenuItem
  479. #endif
  480. EXTERN_API( void )
  481. MacInsertMenuItem               (MenuRef                theMenu,
  482.                                  ConstStr255Param       itemString,
  483.                                  short                  afterItem)                          ONEWORDINLINE(0xA826);
  485. EXTERN_API( void )
  486. DeleteMenuItem                  (MenuRef                theMenu,
  487.                                  short                  item)                               ONEWORDINLINE(0xA952);
  489. EXTERN_API( void )
  490. InsertFontResMenu               (MenuRef                theMenu,
  491.                                  short                  afterItem,
  492.                                  short                  scriptFilter)                       THREEWORDINLINE(0x303C, 0x0400, 0xA825);
  494. EXTERN_API( void )
  495. InsertIntlResMenu               (MenuRef                theMenu,
  496.                                  ResType                theType,
  497.                                  short                  afterItem,
  498.                                  short                  scriptFilter)                       THREEWORDINLINE(0x303C, 0x0601, 0xA825);
  500. /* Routines available in Mac OS 8.5 and later*/
  502. EXTERN_API( OSStatus )
  503. AppendMenuItemText              (MenuRef                menu,
  504.                                  ConstStr255Param       inString);
  506. EXTERN_API( OSStatus )
  507. InsertMenuItemText              (MenuRef                menu,
  508.                                  ConstStr255Param       inString,
  509.                                  MenuItemIndex          afterItem);
  511. /* Routines available in Carbon and later*/
  513. /*--------------------------------------------------------------------------------------*/
  514. /*  o Menu Events                                                                       */
  515. /*--------------------------------------------------------------------------------------*/
  516. EXTERN_API( long )
  517. MenuKey                         (CharParameter          ch)                                 ONEWORDINLINE(0xA93E);
  519. EXTERN_API( long )
  520. MenuSelect                      (Point                  startPt)                            ONEWORDINLINE(0xA93D);
  522. EXTERN_API( long )
  523. PopUpMenuSelect                 (MenuRef                menu,
  524.                                  short                  top,
  525.                                  short                  left,
  526.                                  short                  popUpItem)                          ONEWORDINLINE(0xA80B);
  528. EXTERN_API( long )
  529. MenuChoice                      (void)                                                      ONEWORDINLINE(0xAA66);
  531. /* Routines available in Mac OS 8.0 (Appearance 1.0) and later*/
  532. EXTERN_API( UInt32 )
  533. MenuEvent                       (const EventRecord *    inEvent)                            THREEWORDINLINE(0x303C, 0x020C, 0xA825);
  536. /*--------------------------------------------------------------------------------------*/
  537. /*  o Menu Bar                                                                          */
  538. /*--------------------------------------------------------------------------------------*/
  539. EXTERN_API( short )
  540. GetMBarHeight                   (void)                                                      TWOWORDINLINE(0x3EB8, 0x0BAA);
  542. #if TARGET_OS_MAC
  543.     #define MacDrawMenuBar DrawMenuBar
  544. #endif
  545. EXTERN_API( void )
  546. MacDrawMenuBar                  (void)                                                      ONEWORDINLINE(0xA937);
  548. EXTERN_API( void )
  549. InvalMenuBar                    (void)                                                      ONEWORDINLINE(0xA81D);
  551. EXTERN_API( void )
  552. HiliteMenu                      (MenuID                 menuID)                             ONEWORDINLINE(0xA938);
  554. EXTERN_API( Handle )
  555. GetNewMBar                      (short                  menuBarID)                          ONEWORDINLINE(0xA9C0);
  557. EXTERN_API( Handle )
  558. GetMenuBar                      (void)                                                      ONEWORDINLINE(0xA93B);
  560. EXTERN_API( void )
  561. SetMenuBar                      (Handle                 menuList)                           ONEWORDINLINE(0xA93C);
  563. EXTERN_API( MenuRef )
  564. GetMenuHandle                   (MenuID                 menuID)                             ONEWORDINLINE(0xA949);
  566. #if TARGET_OS_MAC
  567.     #define MacInsertMenu InsertMenu
  568. #endif
  569. EXTERN_API( void )
  570. MacInsertMenu                   (MenuRef                theMenu,
  571.                                  MenuID                 beforeID)                           ONEWORDINLINE(0xA935);
  573. #if TARGET_OS_MAC
  574.     #define MacDeleteMenu DeleteMenu
  575. #endif
  576. EXTERN_API( void )
  577. MacDeleteMenu                   (MenuID                 menuID)                             ONEWORDINLINE(0xA936);
  579. EXTERN_API( void )
  580. ClearMenuBar                    (void)                                                      ONEWORDINLINE(0xA934);
  582. EXTERN_API( void )
  583. SetMenuFlashCount               (short                  count)                              ONEWORDINLINE(0xA94A);
  585. /* SetMenuFlash() has been renamed to SetMenuFlashCount() in Carbon */
  586. #if CALL_NOT_IN_CARBON
  587. EXTERN_API( void )
  588. SetMenuFlash                    (short                  count)                              ONEWORDINLINE(0xA94A);
  590. #if CALL_NOT_IN_CARBON
  591. #define SetMenuFlashCount( count )  SetMenuFlash( count )
  592. #endif /* CALL_NOT_IN_CARBON */
  593. #endif  /* CALL_NOT_IN_CARBON */
  595. EXTERN_API( void )
  596. FlashMenuBar                    (MenuID                 menuID)                             ONEWORDINLINE(0xA94C);
  598. /* These are obsolete because Carbon does not support desk accessories.*/
  599. #if CALL_NOT_IN_CARBON
  600. EXTERN_API( Boolean )
  601. SystemEdit                      (short                  editCmd)                            ONEWORDINLINE(0xA9C2);
  603. EXTERN_API( void )
  604. SystemMenu                      (long                   menuResult)                         ONEWORDINLINE(0xA9B5);
  606. /* Routines available in Mac OS 8.5 and later*/
  607. #endif  /* CALL_NOT_IN_CARBON */
  609. EXTERN_API( Boolean )
  610. IsMenuBarVisible                (void);
  612. EXTERN_API( void )
  613. ShowMenuBar                     (void);
  615. EXTERN_API( void )
  616. HideMenuBar                     (void);
  618. /*--------------------------------------------------------------------------------------*/
  619. /*  o Menu Item Accessors                                                               */
  620. /*--------------------------------------------------------------------------------------*/
  621. #if TARGET_OS_MAC
  622.     #define MacCheckMenuItem CheckMenuItem
  623. #endif
  624. EXTERN_API( void )
  625. MacCheckMenuItem                (MenuRef                theMenu,
  626.                                  short                  item,
  627.                                  Boolean                checked)                            ONEWORDINLINE(0xA945);
  629. /* CheckItem() has been renamed to CheckMenuItem() in Carbon */
  630. #if CALL_NOT_IN_CARBON
  631. EXTERN_API( void )
  632. CheckItem                       (MenuRef                theMenu,
  633.                                  short                  item,
  634.                                  Boolean                checked)                            ONEWORDINLINE(0xA945);
  636. #if TARGET_OS_MAC && CALL_NOT_IN_CARBON
  637. #define CheckMenuItem( menu, item, checked ) CheckItem( menu, item, checked )
  638. #endif
  639. #endif  /* CALL_NOT_IN_CARBON */
  641. EXTERN_API( void )
  642. SetMenuItemText                 (MenuRef                theMenu,
  643.                                  short                  item,
  644.                                  ConstStr255Param       itemString)                         ONEWORDINLINE(0xA947);
  646. EXTERN_API( void )
  647. GetMenuItemText                 (MenuRef                theMenu,
  648.                                  short                  item,
  649.                                  Str255                 itemString)                         ONEWORDINLINE(0xA946);
  651. EXTERN_API( void )
  652. SetItemMark                     (MenuRef                theMenu,
  653.                                  short                  item,
  654.                                  CharParameter          markChar)                           ONEWORDINLINE(0xA944);
  656. EXTERN_API( void )
  657. GetItemMark                     (MenuRef                theMenu,
  658.                                  short                  item,
  659.                                  CharParameter *        markChar)                           ONEWORDINLINE(0xA943);
  661. EXTERN_API( void )
  662. SetItemCmd                      (MenuRef                theMenu,
  663.                                  short                  item,
  664.                                  CharParameter          cmdChar)                            ONEWORDINLINE(0xA84F);
  666. EXTERN_API( void )
  667. GetItemCmd                      (MenuRef                theMenu,
  668.                                  short                  item,
  669.                                  CharParameter *        cmdChar)                            ONEWORDINLINE(0xA84E);
  671. EXTERN_API( void )
  672. SetItemIcon                     (MenuRef                theMenu,
  673.                                  short                  item,
  674.                                  short                  iconIndex)                          ONEWORDINLINE(0xA940);
  676. /* icon is returned in high byte of 16-bit iconIndex */
  677. EXTERN_API( void )
  678. GetItemIcon                     (MenuRef                theMenu,
  679.                                  short                  item,
  680.                                  short *                iconIndex)                          ONEWORDINLINE(0xA93F);
  682. EXTERN_API( void )
  683. SetItemStyle                    (MenuRef                theMenu,
  684.                                  short                  item,
  685.                                  StyleParameter         chStyle)                            ONEWORDINLINE(0xA942);
  687. EXTERN_API( void )
  688. GetItemStyle                    (MenuRef                theMenu,
  689.                                  short                  item,
  690.                                  Style *                chStyle);
  692. /* These APIs are not supported in Carbon. Please use EnableMenuItem and */
  693. /* DisableMenuItem (available back through Mac OS 8.5) instead.          */
  694. #if CALL_NOT_IN_CARBON
  695. EXTERN_API( void )
  696. DisableItem                     (MenuRef                theMenu,
  697.                                  short                  item)                               ONEWORDINLINE(0xA93A);
  699. EXTERN_API( void )
  700. EnableItem                      (MenuRef                theMenu,
  701.                                  short                  item)                               ONEWORDINLINE(0xA939);
  703. /* Routines available in Mac OS 8.0 (Appearance 1.0) and later*/
  705. #endif  /* CALL_NOT_IN_CARBON */
  707. EXTERN_API( OSErr )
  708. SetMenuItemCommandID            (MenuRef                inMenu,
  709.                                  SInt16                 inItem,
  710.                                  MenuCommand            inCommandID)                        THREEWORDINLINE(0x303C, 0x0502, 0xA825);
  712. EXTERN_API( OSErr )
  713. GetMenuItemCommandID            (MenuRef                inMenu,
  714.                                  SInt16                 inItem,
  715.                                  MenuCommand *          outCommandID)                       THREEWORDINLINE(0x303C, 0x0503, 0xA825);
  717. EXTERN_API( OSErr )
  718. SetMenuItemModifiers            (MenuRef                inMenu,
  719.                                  SInt16                 inItem,
  720.                                  UInt8                  inModifiers)                        THREEWORDINLINE(0x303C, 0x0404, 0xA825);
  722. EXTERN_API( OSErr )
  723. GetMenuItemModifiers            (MenuRef                inMenu,
  724.                                  SInt16                 inItem,
  725.                                  UInt8 *                outModifiers)                       THREEWORDINLINE(0x303C, 0x0505, 0xA825);
  727. EXTERN_API( OSErr )
  728. SetMenuItemIconHandle           (MenuRef                inMenu,
  729.                                  SInt16                 inItem,
  730.                                  UInt8                  inIconType,
  731.                                  Handle                 inIconHandle)                       THREEWORDINLINE(0x303C, 0x0606, 0xA825);
  733. EXTERN_API( OSErr )
  734. GetMenuItemIconHandle           (MenuRef                inMenu,
  735.                                  SInt16                 inItem,
  736.                                  UInt8 *                outIconType,
  737.                                  Handle *               outIconHandle)                      THREEWORDINLINE(0x303C, 0x0707, 0xA825);
  739. EXTERN_API( OSErr )
  740. SetMenuItemTextEncoding         (MenuRef                inMenu,
  741.                                  SInt16                 inItem,
  742.                                  TextEncoding           inScriptID)                         THREEWORDINLINE(0x303C, 0x0408, 0xA825);
  744. EXTERN_API( OSErr )
  745. GetMenuItemTextEncoding         (MenuRef                inMenu,
  746.                                  SInt16                 inItem,
  747.                                  TextEncoding *         outScriptID)                        THREEWORDINLINE(0x303C, 0x0509, 0xA825);
  749. EXTERN_API( OSErr )
  750. SetMenuItemHierarchicalID       (MenuRef                inMenu,
  751.                                  SInt16                 inItem,
  752.                                  MenuID                 inHierID)                           THREEWORDINLINE(0x303C, 0x040D, 0xA825);
  754. EXTERN_API( OSErr )
  755. GetMenuItemHierarchicalID       (MenuRef                inMenu,
  756.                                  SInt16                 inItem,
  757.                                  MenuID *               outHierID)                          THREEWORDINLINE(0x303C, 0x050E, 0xA825);
  759. EXTERN_API( OSErr )
  760. SetMenuItemFontID               (MenuRef                inMenu,
  761.                                  SInt16                 inItem,
  762.                                  SInt16                 inFontID)                           THREEWORDINLINE(0x303C, 0x040F, 0xA825);
  764. EXTERN_API( OSErr )
  765. GetMenuItemFontID               (MenuRef                inMenu,
  766.                                  SInt16                 inItem,
  767.                                  SInt16 *               outFontID)                          THREEWORDINLINE(0x303C, 0x0510, 0xA825);
  769. EXTERN_API( OSErr )
  770. SetMenuItemRefCon               (MenuRef                inMenu,
  771.                                  SInt16                 inItem,
  772.                                  UInt32                 inRefCon)                           THREEWORDINLINE(0x303C, 0x050A, 0xA825);
  774. EXTERN_API( OSErr )
  775. GetMenuItemRefCon               (MenuRef                inMenu,
  776.                                  SInt16                 inItem,
  777.                                  UInt32 *               outRefCon)                          THREEWORDINLINE(0x303C, 0x050B, 0xA825);
  779. /* Please use the menu item property APIs in Carbon.*/
  780. #if CALL_NOT_IN_CARBON
  781. EXTERN_API( OSErr )
  782. SetMenuItemRefCon2              (MenuRef                inMenu,
  783.                                  SInt16                 inItem,
  784.                                  UInt32                 inRefCon2)                          THREEWORDINLINE(0x303C, 0x0511, 0xA825);
  786. EXTERN_API( OSErr )
  787. GetMenuItemRefCon2              (MenuRef                inMenu,
  788.                                  SInt16                 inItem,
  789.                                  UInt32 *               outRefCon2)                         THREEWORDINLINE(0x303C, 0x0512, 0xA825);
  791. #endif  /* CALL_NOT_IN_CARBON */
  793. EXTERN_API( OSErr )
  794. SetMenuItemKeyGlyph             (MenuRef                inMenu,
  795.                                  SInt16                 inItem,
  796.                                  SInt16                 inGlyph)                            THREEWORDINLINE(0x303C, 0x0513, 0xA825);
  798. EXTERN_API( OSErr )
  799. GetMenuItemKeyGlyph             (MenuRef                inMenu,
  800.                                  SInt16                 inItem,
  801.                                  SInt16 *               outGlyph)                           THREEWORDINLINE(0x303C, 0x0514, 0xA825);
  803. /* Routines available in Mac OS 8.5 and later (supporting enabling/disabling of > 31 items)*/
  805. #if TARGET_OS_MAC
  806.     #define MacEnableMenuItem EnableMenuItem
  807. #endif
  808. EXTERN_API( void )
  809. MacEnableMenuItem               (MenuRef                theMenu,
  810.                                  MenuItemIndex          item);
  812. EXTERN_API( void )
  813. DisableMenuItem                 (MenuRef                theMenu,
  814.                                  MenuItemIndex          item);
  816. EXTERN_API( Boolean )
  817. IsMenuItemEnabled               (MenuRef                menu,
  818.                                  MenuItemIndex          item);
  820. EXTERN_API( void )
  821. EnableMenuItemIcon              (MenuRef                theMenu,
  822.                                  MenuItemIndex          item)                               THREEWORDINLINE(0x303C, 0x0019, 0xA825);
  824. EXTERN_API( void )
  825. DisableMenuItemIcon             (MenuRef                theMenu,
  826.                                  MenuItemIndex          item)                               THREEWORDINLINE(0x303C, 0x0020, 0xA825);
  828. EXTERN_API( Boolean )
  829. IsMenuItemIconEnabled           (MenuRef                menu,
  830.                                  MenuItemIndex          item)                               THREEWORDINLINE(0x303C, 0x0018, 0xA825);
  832. /*--------------------------------------------------------------------------------------*/
  833. /*  o Menu Item Color Tables                                                            */
  834. /*                                                                                      */
  835. /*  Menu color manipulation is considered deprecated with the advent of the Appearance  */
  836. /*  Manager.  Avoid using these routines if possible                                    */
  837. /*--------------------------------------------------------------------------------------*/
  838. EXTERN_API( void )
  839. DeleteMCEntries                 (MenuID                 menuID,
  840.                                  short                  menuItem)                           ONEWORDINLINE(0xAA60);
  842. EXTERN_API( MCTableHandle )
  843. GetMCInfo                       (void)                                                      ONEWORDINLINE(0xAA61);
  845. EXTERN_API( void )
  846. SetMCInfo                       (MCTableHandle          menuCTbl)                           ONEWORDINLINE(0xAA62);
  848. EXTERN_API( void )
  849. DisposeMCInfo                   (MCTableHandle          menuCTbl)                           ONEWORDINLINE(0xAA63);
  851. EXTERN_API( MCEntryPtr )
  852. GetMCEntry                      (MenuID                 menuID,
  853.                                  short                  menuItem)                           ONEWORDINLINE(0xAA64);
  855. EXTERN_API( void )
  856. SetMCEntries                    (short                  numEntries,
  857.                                  MCTablePtr             menuCEntries)                       ONEWORDINLINE(0xAA65);
  860. /*--------------------------------------------------------------------------------------*/
  861. /* o Properties  (Mac OS 8.5 and later)                                                 */
  862. /*                                                                                      */
  863. /* With the following property APIs, you can attach any piece of data you'd like to a   */
  864. /* menu or menu item. Passing zero for the item number parameter indicates you'd like   */
  865. /* to attach the data to the menu itself, and not to any specific menu item.            */
  866. /*--------------------------------------------------------------------------------------*/
  867. enum {
  868.     kMenuPropertyPersistent     = 0x00000001                    /* whether this property gets saved when flattening the menu*/
  869. };
  871. EXTERN_API( OSStatus )
  872. GetMenuItemProperty             (MenuRef                menu,
  873.                                  MenuItemIndex          item,
  874.                                  OSType                 propertyCreator,
  875.                                  OSType                 propertyTag,
  876.                                  UInt32                 bufferSize,
  877.                                  UInt32 *               actualSize,
  878.                                  void *                 propertyBuffer);
  880. EXTERN_API( OSStatus )
  881. GetMenuItemPropertySize         (MenuRef                menu,
  882.                                  MenuItemIndex          item,
  883.                                  OSType                 propertyCreator,
  884.                                  OSType                 propertyTag,
  885.                                  UInt32 *               size);
  887. EXTERN_API( OSStatus )
  888. SetMenuItemProperty             (MenuRef                menu,
  889.                                  MenuItemIndex          item,
  890.                                  OSType                 propertyCreator,
  891.                                  OSType                 propertyTag,
  892.                                  UInt32                 propertySize,
  893.                                  const void *           propertyData);
  895. EXTERN_API( OSStatus )
  896. RemoveMenuItemProperty          (MenuRef                menu,
  897.                                  MenuItemIndex          item,
  898.                                  OSType                 propertyCreator,
  899.                                  OSType                 propertyTag);
  901. EXTERN_API( OSStatus )
  902. GetMenuItemPropertyAttributes   (MenuRef                menu,
  903.                                  MenuItemIndex          item,
  904.                                  OSType                 propertyCreator,
  905.                                  OSType                 propertyTag,
  906.                                  UInt32 *               attributes);
  908. EXTERN_API( OSStatus )
  909. ChangeMenuItemPropertyAttributes (MenuRef               menu,
  910.                                  MenuItemIndex          item,
  911.                                  OSType                 propertyCreator,
  912.                                  OSType                 propertyTag,
  913.                                  UInt32                 attributesToSet,
  914.                                  UInt32                 attributesToClear);
  916. /*--------------------------------------------------------------------------------------*/
  917. /*  o Attributes (Carbon and later)                                                     */
  918. /*                                                                                      */
  919. /*  Each menu and menu item has attribute flags.                                        */
  920. /*--------------------------------------------------------------------------------------*/
  921. EXTERN_API( OSStatus )
  922. GetMenuAttributes               (MenuRef                menu,
  923.                                  MenuAttributes *       outAttributes);
  925. EXTERN_API( OSStatus )
  926. ChangeMenuAttributes            (MenuRef                menu,
  927.                                  MenuAttributes         setTheseAttributes,
  928.                                  MenuAttributes         clearTheseAttributes);
  930. EXTERN_API( OSStatus )
  931. GetMenuItemAttributes           (MenuRef                menu,
  932.                                  MenuItemIndex          item,
  933.                                  MenuItemAttributes *   outAttributes);
  935. EXTERN_API( OSStatus )
  936. ChangeMenuItemAttributes        (MenuRef                menu,
  937.                                  MenuItemIndex          item,
  938.                                  MenuItemAttributes     setTheseAttributes,
  939.                                  MenuItemAttributes     clearTheseAttributes);
  941. /*--------------------------------------------------------------------------------------*/
  942. /*  o Mass menu item enabling and disabling (Carbon and later)                          */
  943. /*                                                                                      */
  944. /*  Useful when rewriting code that whacks the enableFlags field directly.              */
  945. /*--------------------------------------------------------------------------------------*/
  946. EXTERN_API( void )
  947. DisableAllMenuItems             (MenuRef                theMenu);
  949. EXTERN_API( void )
  950. EnableAllMenuItems              (MenuRef                theMenu);
  952. EXTERN_API( Boolean )
  953. MenuHasEnabledItems             (MenuRef                theMenu);
  955. /*--------------------------------------------------------------------------------------*/
  956. /*  o Menu tracking status (Carbon and later)                                           */
  957. /*                                                                                      */
  958. /*  Get info about the selected menu item during menu tracking. Replaces direct access  */
  959. /*  to low-mem globals that used to hold this info.                                     */
  960. /*--------------------------------------------------------------------------------------*/
  961. EXTERN_API( OSStatus )
  962. GetMenuTrackingData             (MenuRef                theMenu,
  963.                                  MenuTrackingData *     outData);
  965. /*--------------------------------------------------------------------------------------*/
  966. /*  o.Universal command ID access (Carbon and later)                                    */
  967. /*                                                                                      */
  968. /*  These APIs allow you to operate on menu items strictly by command ID, with no       */
  969. /*  knowledge of a menu item's index.                                                   */
  970. /*--------------------------------------------------------------------------------------*/
  971. EXTERN_API( ItemCount )
  972. CountMenuItemsWithCommandID     (MenuRef                menu,
  973.                                  MenuCommand            commandID);
  975. EXTERN_API( OSStatus )
  976. GetIndMenuItemWithCommandID     (MenuRef                menu,
  977.                                  MenuCommand            commandID,
  978.                                  UInt32                 itemIndex,
  979.                                  MenuRef *              outMenu,
  980.                                  MenuItemIndex *        outIndex);
  982. EXTERN_API( void )
  983. EnableMenuCommand               (MenuRef                theMenu,
  984.                                  MenuCommand            commandID);
  986. EXTERN_API( void )
  987. DisableMenuCommand              (MenuRef                theMenu,
  988.                                  MenuCommand            commandID);
  990. EXTERN_API( Boolean )
  991. IsMenuCommandEnabled            (MenuRef                menu,
  992.                                  MenuCommand            commandID);
  994. EXTERN_API( OSStatus )
  995. GetMenuCommandProperty          (MenuRef                menu,
  996.                                  MenuCommand            commandID,
  997.                                  OSType                 propertyCreator,
  998.                                  OSType                 propertyTag,
  999.                                  ByteCount              bufferSize,
  1000.                                  ByteCount *            actualSize,
  1001.                                  void *                 propertyBuffer);
  1003. EXTERN_API( OSStatus )
  1004. GetMenuCommandPropertySize      (MenuRef                menu,
  1005.                                  MenuCommand            commandID,
  1006.                                  OSType                 propertyCreator,
  1007.                                  OSType                 propertyTag,
  1008.                                  ByteCount *            size);
  1010. EXTERN_API( OSStatus )
  1011. SetMenuCommandProperty          (MenuRef                menu,
  1012.                                  MenuCommand            commandID,
  1013.                                  OSType                 propertyCreator,
  1014.                                  OSType                 propertyTag,
  1015.                                  ByteCount              propertySize,
  1016.                                  const void *           propertyData);
  1018. EXTERN_API( OSStatus )
  1019. RemoveMenuCommandProperty       (MenuRef                menu,
  1020.                                  MenuCommand            commandID,
  1021.                                  OSType                 propertyCreator,
  1022.                                  OSType                 propertyTag);
  1025. /*--------------------------------------------------------------------------------------*/
  1026. /*  o.Standard font menu (Carbon and later)                                             */
  1027. /*                                                                                      */
  1028. /*  These APIs allow you to create and use the standard font menu.                      */
  1029. /*--------------------------------------------------------------------------------------*/
  1030. enum {
  1031.     kHierarchicalFontMenuOption = 0x00000001
  1032. };
  1034. EXTERN_API( OSStatus )
  1035. CreateStandardFontMenu          (MenuRef                menu,
  1036.                                  MenuItemIndex          afterItem,
  1037.                                  MenuID                 firstHierMenuID,
  1038.                                  OptionBits             options,
  1039.                                  ItemCount *            outHierMenuCount);
  1041. EXTERN_API( OSStatus )
  1042. UpdateStandardFontMenu          (MenuRef                menu,
  1043.                                  ItemCount *            outHierMenuCount);
  1045. EXTERN_API( OSStatus )
  1046. GetFontFamilyFromMenuSelection  (MenuRef                menu,
  1047.                                  MenuItemIndex          item,
  1048.                                  FMFontFamily *         outFontFamily,
  1049.                                  FMFontStyle *          outStyle);
  1051. /*--------------------------------------------------------------------------------------*/
  1052. /*  o Contextual Menu routines and constants                                            */
  1053. /*  available with Conxtextual Menu extension 1.0 and later                             */
  1054. /*--------------------------------------------------------------------------------------*/
  1055. /* Gestalt Selector for classic 68K apps only. */
  1056. /* CFM apps should weak link and check the symbols. */
  1057. enum {
  1058.     gestaltContextualMenuAttr   = FOUR_CHAR_CODE('cmnu'),
  1059.     gestaltContextualMenuUnusedBit = 0,
  1060.     gestaltContextualMenuTrapAvailable = 1
  1061. };
  1063. /* Values indicating what kind of help the application supports */
  1064. enum {
  1065.     kCMHelpItemNoHelp           = 0,
  1066.     kCMHelpItemAppleGuide       = 1,
  1067.     kCMHelpItemOtherHelp        = 2
  1068. };
  1070. /* Values indicating what was chosen from the menu */
  1071. enum {
  1072.     kCMNothingSelected          = 0,
  1073.     kCMMenuItemSelected         = 1,
  1074.     kCMShowHelpSelected         = 3
  1075. };
  1077. EXTERN_API( OSStatus )
  1078. InitContextualMenus             (void)                                                      TWOWORDINLINE(0x7001, 0xAA72);
  1080. EXTERN_API( Boolean )
  1081. IsShowContextualMenuClick       (const EventRecord *    inEvent)                            TWOWORDINLINE(0x7002, 0xAA72);
  1083. EXTERN_API( OSStatus )
  1084. ContextualMenuSelect            (MenuRef                inMenu,
  1085.                                  Point                  inGlobalLocation,
  1086.                                  Boolean                inReserved,
  1087.                                  UInt32                 inHelpType,
  1088.                                  ConstStr255Param       inHelpItemString,
  1089.                                  const AEDesc *         inSelection,
  1090.                                  UInt32 *               outUserSelectionType,
  1091.                                  SInt16 *               outMenuID,
  1092.                                  MenuItemIndex *        outMenuItem)                        TWOWORDINLINE(0x7003, 0xAA72);
  1094. EXTERN_API( Boolean )
  1095. ProcessIsContextualMenuClient   (ProcessSerialNumber *  inPSN)                              TWOWORDINLINE(0x7004, 0xAA72);
  1098. /*--------------------------------------------------------------------------------------*/
  1099. /*  o Contextual Menu Plugin Notes                                                      */
  1100. /*                                                                                      */
  1101. /*  For Mac OS X, we will support a new type of Contextual Menu Plugin: the CFM-based   */
  1102. /*  plugin. Each plugin must be a separate file in the Contextual Menu Items subfolder  */
  1103. /*  of the system folder. It must export two functions and has the option of exporting  */
  1104. /*  a third; these three functions are virtually identical to the methods that must be  */
  1105. /*  supported by a SOM-based plugin.                                                        */
  1106. /*                                                                                      */
  1107. /*  The required symbols must be named "ExamineContext" and "HandleSelection".          */
  1108. /*  The optional symbol must be named "PostMenuCleanup".                                */
  1109. /*                                                                                      */
  1110. /*  The ExamineContext routine must have the following prototype:                       */
  1111. /*      pascal OSStatus ExamineContext( const AEDesc* inContext,                        */
  1112. /*                                      AEDescList* outCommandPairs );                  */
  1113. /*                                                                                      */
  1114. /*  The HandleSelection routine must have the following prototype:                      */
  1115. /*      pascal OSStatus HandleSelection(    const AEDesc* inContext,                    */
  1116. /*                                          SInt32 inCommandID );                       */
  1117. /*                                                                                      */
  1118. /*  The PostMenuCleanup routine must have the following prototype:                      */
  1119. /*      pascal void PostMenuCleanup(     void );                                            */
  1120. /*--------------------------------------------------------------------------------------*/
  1122. #if CALL_NOT_IN_CARBON
  1123. EXTERN_API_C( MenuRef )
  1124. newmenu                         (MenuID                 menuID,
  1125.                                  const char *           menuTitle);
  1127. EXTERN_API_C( void )
  1128. appendmenu                      (MenuRef                menu,
  1129.                                  const char *           data);
  1131. EXTERN_API_C( void )
  1132. insertmenuitem                  (MenuRef                theMenu,
  1133.                                  const char *           itemString,
  1134.                                  short                  afterItem);
  1136. EXTERN_API_C( long )
  1137. menuselect                      (const Point *          startPt);
  1139. EXTERN_API_C( void )
  1140. setmenuitemtext                 (MenuRef                menu,
  1141.                                  short                  item,
  1142.                                  const char *           itemString);
  1144. EXTERN_API_C( void )
  1145. getmenuitemtext                 (MenuRef                menu,
  1146.                                  short                  item,
  1147.                                  char *                 itemString);
  1149. #endif  /* CALL_NOT_IN_CARBON */
  1151. #if OLDROUTINENAMES
  1152. #define AddResMenu(theMenu, theType) AppendResMenu(theMenu, theType)
  1153. #define InsMenuItem(theMenu, itemString, afterItem) InsertMenuItem(theMenu, itemString, afterItem)
  1154. #define DelMenuItem( theMenu, item ) DeleteMenuItem( theMenu, item )
  1155. #if TARGET_OS_MAC
  1156. #define SetItem MacSetItem
  1157. #define GetItem MacGetItem
  1158. #endif
  1159. #define MacSetItem(theMenu, item, itemString) SetMenuItemText(theMenu, item, itemString)
  1160. #define MacGetItem(theMenu, item, itemString) GetMenuItemText(theMenu, item, itemString)
  1161. #define GetMHandle(menuID) GetMenuHandle(menuID)
  1162. #define DelMCEntries(menuID, menuItem) DeleteMCEntries(menuID, menuItem)
  1163. #define DispMCInfo(menuCTbl) DisposeMCInfo(menuCTbl)
  1164. #if CALL_NOT_IN_CARBON
  1165. #define addresmenu(menu, data) appendresmenu(menu, data)
  1166. #define getitem(menu, item, itemString) getmenuitemtext(menu, item, itemString)
  1167. #define setitem(menu, item, itemString) setmenuitemtext(menu, item, itemString)
  1168. #define insmenuitem(theMenu, itemString, afterItem) insertmenuitem(theMenu, itemString, afterItem)
  1169. #endif
  1170. #endif  /* OLDROUTINENAMES */
  1172. #if ACCESSOR_CALLS_ARE_FUNCTIONS
  1173. /* Getters */
  1174. EXTERN_API( MenuID )
  1175. GetMenuID                       (MenuRef                menu);
  1177. EXTERN_API( SInt16 )
  1178. GetMenuWidth                    (MenuRef                menu);
  1180. EXTERN_API( SInt16 )
  1181. GetMenuHeight                   (MenuRef                menu);
  1183. EXTERN_API( StringPtr )
  1184. GetMenuTitle                    (MenuRef                menu,
  1185.                                  Str255                 title);
  1187. EXTERN_API( OSStatus )
  1188. GetMenuDefinition               (MenuRef                menu,
  1189.                                  MenuDefSpecPtr         outDefSpec);
  1191. /* Setters */
  1192. EXTERN_API( void )
  1193. SetMenuID                       (MenuRef                menu,
  1194.                                  MenuID                 menuID);
  1196. EXTERN_API( void )
  1197. SetMenuWidth                    (MenuRef                menu,
  1198.                                  SInt16                 width);
  1200. EXTERN_API( void )
  1201. SetMenuHeight                   (MenuRef                menu,
  1202.                                  SInt16                 height);
  1204. EXTERN_API( OSStatus )
  1205. SetMenuTitle                    (MenuRef                menu,
  1206.                                  ConstStr255Param       title);
  1208. EXTERN_API( OSStatus )
  1209. SetMenuDefinition               (MenuRef                menu,
  1210.                                  const MenuDefSpec *    defSpec);
  1212. #endif  /* ACCESSOR_CALLS_ARE_FUNCTIONS */
  1216. #if TARGET_OS_WIN32
  1217. #endif  /* TARGET_OS_WIN32 */
  1220. #if PRAGMA_STRUCT_ALIGN
  1221.     #pragma options align=reset
  1222. #elif PRAGMA_STRUCT_PACKPUSH
  1223.     #pragma pack(pop)
  1224. #elif PRAGMA_STRUCT_PACK
  1225.     #pragma pack()
  1226. #endif
  1228. #ifdef PRAGMA_IMPORT_OFF
  1229. #pragma import off
  1230. #elif PRAGMA_IMPORT
  1231. #pragma import reset
  1232. #endif
  1234. #ifdef __cplusplus
  1235. }
  1236. #endif
  1238. #endif /* __MENUS__ */