home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #16 / NN_1992_16.iso / spool / comp / sys / mac / programm / 13142 < prev    next >
Encoding:
Text File  |  1992-07-29  |  20.0 KB  |  867 lines
  1. Path: sparky!uunet!zaphod.mps.ohio-state.edu!uakari.primate.wisc.edu!ames!eos!data.nas.nasa.gov!taligent!keith@taligent.com
  2. From: keith@taligent.com (Keith Rollin)
  3. Newsgroups: comp.sys.mac.programmer
  4. Subject: Re: menubar in dialogs (long)
  5. Message-ID: <Bs55p8.1D8@taligent.com>
  6. Date: 29 Jul 92 08:17:31 GMT
  7. References: <kaas-280792151810@jojo.cc.ruu.nl>
  8. Sender: usenet@taligent.com (More Bytes Than You Can Read)
  9. Organization: Taligent
  10. Lines: 855
  11.  
  12. In article <kaas-280792151810@jojo.cc.ruu.nl>, kaas@cc.ruu.nl (Dick Kaas)
  13. writes:
  14. > 
  15. > I'm planning to write a TCL pane for a menu-bar.
  16. > 
  17. > Is there a simple way to implement a menubar into dialogs  (like WP and
  18. > superboomerang) without having to write a complete menu package by
  19. > yourself?
  20. > 
  21. > I have looked at the low memory globals, such as MenuBarHook etc. None of
  22. > these seem useful.
  23. >
  24.  
  25. I did one of these. I wouldn't consider the approach I took to be "simple."
  26. Although I wrote the bulk of it in a couple of nights, they were long nights. I
  27. had to re-implement and wrap up a lot of stuff. My first attempt that tried
  28. setting the origin of the window manager port at strategic times didn't work
  29. because of a bug in System 7.0's background saving and restoring routines.
  30.  
  31. I did it as a control to make it easy for others to use. It's included below.
  32.  
  33. How to use: create a control item in your DITL, and specify the CDEF shown
  34. below. When the user clicks on the item, the dialog manager will call
  35. TrackControl. If you are writing a TCL pane, then call TrackControl yourself.
  36. The control will track the menus and leave the chosen item in contrlValue, so
  37. all you have to do is call GetCtlValue to get the chosen menu item.
  38.  
  39. If you want to manipulate the menubar, use one of the macros starting with a "Z"
  40. included below. Those macros will call the CDEF directly with a custom message
  41. number. Please note that for the CallIt macro to work, the CDEF must be marked
  42. as locked. If you don't want to lock your CDEF, then you'll need a more
  43. elaborate way to call the CDEF than just dereferencing the handle and jumping.
  44. As an example of what you might need, I've included a commented-out function at
  45. the end of this posting that calls the standard MBDF directly.
  46.  
  47. A note: pay no attention to the UseGlobals and DoneWithGlobals stuff. That's for
  48. an MPW package that allows globals in standalone code. If you are using THINK C,
  49. don't worry about it. If you are using MPW, use the techniques shown in Technote
  50. #256.
  51.  
  52. (BTW: as you'll see below, MenubarHook _was_ useful!)
  53.  
  54. As a final note, I found it useful to write a wrapper for the standard MDEF.
  55. Because the below CDEF essentially works by using popup menus, you need to have
  56. fine control over where the popup menus show up. The standard MBDF will try to
  57. position popup menus so that as much of them will appear on the screen as
  58. possible. However, we don't want that with our menubar CDEF; we want to the top
  59. of the menu to be right below the menubar. Therefore, I wrap up the standard
  60. MDEF with one of my own that first calls the standard MDEF, and then checks to
  61. see if the message handled was mPopUpMsg. If so, the top of the menu is adjusted
  62. by executing "menuRect->top = *itemID;".
  63.  
  64. Sorry for the lack of any comments in the source code...
  65.  
  66. -------------
  67. MenubarCDEF.h
  68. -------------
  69.  
  70. #ifndef THINK_C
  71. #include <Controls.h>
  72. #endif
  73.  
  74. #define kStayPutMDEF    90
  75.  
  76. #define clearMenuBar    128
  77. #define deleteMenu        129            // param = ID of menu to remove
  78. #define drawMenuBar        130
  79. #define flashMenuBar    131            // param = ID of menu to flash
  80. #define getMenuBar        132            // result = handle to custom data
  81. #define getMHandle        133            // param = menu ID, result = menuHandle
  82. #define hiliteMenu        134            // param = ID of menu to hilite
  83. #define insertMenu        135            // param = menuHandle, varCode = before menu ID
  84. #define menuKey            136            // param = char, result = same as MenuKey
  85. #define menuSelect        137            // param = startPt, result = same as MenuSelect
  86. #define setMenuBar        138            // param = result from getMenuBar
  87.  
  88. typedef pascal long (*CDEFProc)(short varCode, ControlHandle theControl,
  89.                                     short msg, long param);
  90.  
  91. #define CallIt(ctl) ((CDEFProc) *((**ctl).contrlDefProc))
  92.  
  93. #define ZClearMenuBar(ctl)            CallIt(ctl)(0, ctl, clearMenuBar, 0)
  94. #define ZDeleteMenu(ctl, menuID)    CallIt(ctl)(0, ctl, deleteMenu, menuID)
  95. #define ZDrawMenuBar(ctl)            CallIt(ctl)(0, ctl, drawMenuBar, 0)
  96. #define ZFlashMenuBar(ctl, menuID)    CallIt(ctl)(0, ctl, flashMenuBar, menuID)
  97. #define ZGetMenuBar(ctl)            (Handle) CallIt(ctl)(0, ctl, getMenuBar, 0)
  98. #define ZGetMHandle(ctl, menuID)    (MenuHandle) CallIt(ctl)(0, ctl, getMHandle,
  99. menuID)
  100. #define ZHiliteMenu(ctl, menuID)    CallIt(ctl)(0, ctl, hiliteMenu, 0)
  101. #define ZInsertMenu(ctl, mh, id)    CallIt(ctl)(id, ctl, insertMenu, mh)
  102. #define ZMenuKey(ctl, key)            CallIt(ctl)(0, ctl, menuKey, key)
  103. #define ZMenuSelect(ctl, startPt)    CallIt(ctl)(0, ctl, menuSelect, startPt)
  104. #define ZSetMenuBar(ctl, mbar)        CallIt(ctl)(0, ctl, setMenuBar, mbar)
  105.  
  106.  
  107.  
  108. -------------
  109. MenubarCDEF.c
  110. -------------
  111.  
  112.  
  113. /*
  114.     To do:
  115.     
  116.     % Support hierarchicals
  117.     % Support color
  118. */
  119.  
  120. #include "MetaGlobal.h"
  121. #include "MenubarCDEF.h"
  122.  
  123. #ifdef THINK_C
  124.     #include <SetUpA4.h>
  125.     Ptr GetA0(void) = { 0x2008 };
  126. #else
  127.     #include <Types.h>
  128.     #include <Memory.h>
  129.     #include <Menus.h>
  130.     #include <OSEvents.h>            // For EvQPtr
  131.     #include <Resources.h>            // For GetResource
  132.     #include <Script.h>                // For GetMBarHeight
  133.     #include <ToolUtils.h>            // For HiWord, LoWord
  134.     #include <Windows.h>            // we return inMenubar as our part
  135.     #include "SAGlobals.h"
  136.     
  137.     #define MenuHook (*(ProcPtr*) 0xA30)
  138.     #define MenuList (*(Handle*) 0xA1C)
  139. #endif
  140.  
  141. #define NIL                NULL
  142. #define kTopMargin        1
  143. #define kBottomMargin    1
  144. #define kTextMargin        8
  145.  
  146.  
  147. typedef struct {
  148.     MenuHandle        menu;
  149.     short            menuLeft;
  150. } MenuRec, *MenuRecPtr;
  151.  
  152.  
  153. typedef struct {
  154.     MenuHandle        menu;
  155.     short            reserved;
  156. } HMenuRec, *HMenuRecPtr;
  157.  
  158.  
  159. typedef struct {
  160.     short            lastMenu;
  161.     short            lastRight;
  162.     short            mbResID;
  163.     MenuRec            menus[1];
  164.     //    short            lastHMenu;
  165.     //    PixMapHandle    menuTitleSave;
  166.     //    MenuRec            hmenus[1];
  167. } MenuBar, *MenuBarPtr, **MenuBarHdl;
  168.  
  169.  
  170. ProcPtr            gOldMenuHook;
  171. ControlHandle    gControl;
  172. MenuBarHdl        gMenuList;
  173. short            gTheMenu;            // _Index_ of currently hilighted menu
  174. short            gNormalHeight;
  175. FontInfo        gFontInfo;
  176. short            gBaseline;
  177.  
  178.  
  179. pascal long        main(short varCode, ControlHandle theControl, short msg, long
  180. param);
  181.  
  182. void            DrawMyControl(short part);
  183. short            TestMyControl(Point location);
  184. void            InitMyControl(void);
  185. void            DisposeMyControl(void);
  186.  
  187. void            DoClearMenuBar(void);
  188. void            DoDeleteMenu(short menuID);
  189. void            DoDrawMenuBar(void);
  190. void            DoFlashMenuBar(short menuID);
  191. MenuBarHdl        DoGetMenuBar(void);
  192. MenuHandle        DoGetMHandle(short menuID);
  193. void            DoHiliteMenu(short menuID);
  194. void            DoInsertMenu(MenuHandle menu, short before);
  195. long            DoMenuKey(char theKey);
  196. long            DoMenuSelect(Point startPt);
  197. void            DoSetMenuBar(MenuBarHdl menuBar);
  198.  
  199. void            DrawMenuTitle(short menuIndex);
  200. short            FindHitMenu(Point location);        // returns menuIndex (or -1)
  201. short            GetFreeHMenuID(void);
  202. Rect            GetHitRect(short menuIndex);
  203. Rect            GetInvertRect(short menuIndex);
  204. short            GetMenuCount(void);
  205. MenuHandle        GetNthMenu(short index);
  206. Point            GetTitleLocation(short menuIndex);
  207. short            IDToIndex(short);
  208. short            IndexToID(short);
  209. void            MyMenuHook(void);
  210. void            SwapMenuBars(void);
  211.  
  212. //--------------------------------------------------------------------------------
  213.  
  214. pascal long    main(short varCode, ControlHandle theControl, short msg, long param)
  215. {
  216.     long        result;
  217.     Ptr            oldA5;
  218.     char        oldState;
  219.     Handle        ourHandle;
  220.     Ptr            ourPtr;
  221.  
  222.     ourPtr = GetA0();
  223.  
  224. #ifdef THINK_C
  225.     RememberA0();
  226.     SetUpA4();
  227. #else
  228.     oldA5 = UseGlobals();
  229. #endif
  230.  
  231.     ourHandle = RecoverHandle(ourPtr);
  232.     oldState = HGetState(ourHandle);
  233.     HLock(ourHandle);
  234.     
  235.     result = 0;
  236.     gControl = theControl;
  237.     GetFontInfo(&gFontInfo);
  238.     gBaseline = kTopMargin + gFontInfo.leading + gFontInfo.ascent;
  239.  
  240.     if (msg < 128) {
  241.         switch (msg) {
  242.             case drawCntl:
  243.                 DrawMyControl((short) param);
  244.                 break;
  245.             case testCntl:
  246.                 result = TestMyControl(*(Point*) ¶m);
  247.                 break;
  248.             case initCntl:
  249.                 InitMyControl();
  250.                 break;
  251.             case dispCntl:
  252.                 DisposeMyControl();
  253.                 break;
  254.             case calcCntlRgn:
  255.             case calcThumbRgn:
  256.                 RectRgn((RgnHandle) param, &(**gControl).contrlRect);
  257.                 result = 1;
  258.                 break;
  259.         }
  260.     } else {
  261.         switch (msg) {
  262.             case clearMenuBar:
  263.                 DoClearMenuBar();
  264.                 break;
  265.             case deleteMenu:
  266.                 DoDeleteMenu((short) param);
  267.                 break;
  268.             case drawMenuBar:
  269.                 DoDrawMenuBar();
  270.                 break;
  271.             case flashMenuBar:
  272.                 DoFlashMenuBar((short) param);
  273.                 break;
  274.             case getMenuBar:
  275.                 result = (long) DoGetMenuBar();
  276.                 break;
  277.             case getMHandle:
  278.                 result = (long) DoGetMHandle((short) param);
  279.                 break;
  280.             case hiliteMenu:
  281.                 DoHiliteMenu((short) param);
  282.                 break;
  283.             case insertMenu:
  284.                 DoInsertMenu((MenuHandle) param, varCode);
  285.                 break;
  286.             case menuKey:
  287.                 result = DoMenuKey((char) param);
  288.                 break;
  289.             case menuSelect:
  290.                 result = DoMenuSelect(*(Point*) ¶m);
  291.                 break;
  292.             case setMenuBar:
  293.                 DoSetMenuBar((MenuBarHdl) param);
  294.                 break;
  295.         }
  296.     }
  297.  
  298. #ifdef THINK_C
  299.     RestoreA4();
  300. #else
  301.     DoneWithGlobals(oldA5);
  302. #endif
  303.     
  304.     HSetState(ourHandle, oldState);
  305.  
  306.     return result;
  307. }
  308.  
  309.  
  310. //--------------------------------------------------------------------------------
  311.  
  312. void    DrawMyControl(short part)
  313. {
  314. #pragma unused (part)
  315.  
  316.     if ((**gControl).contrlVis != false) {
  317.         DoDrawMenuBar();
  318.     }
  319. }
  320.  
  321.  
  322. //--------------------------------------------------------------------------------
  323.  
  324. short    TestMyControl(Point location)
  325. {
  326.     short        hitPart;
  327.     
  328.     hitPart = 0;
  329.     if (FindHitMenu(location) >= 0) {
  330.         hitPart = inMenuBar;
  331.         if (Button()) {
  332.             DoMenuSelect(location);
  333.             if ((**gControl).contrlValue == 0) {
  334.                 hitPart = 0;
  335.             }
  336.         }
  337.     }
  338.  
  339.     return hitPart;
  340. }
  341.  
  342.  
  343. //--------------------------------------------------------------------------------
  344.  
  345. void    InitMyControl()
  346. {
  347.     Handle        menuBar;
  348.  
  349.     gOldMenuHook = NIL;
  350.     gMenuList = NIL;
  351.     gTheMenu = -1;
  352.     gNormalHeight = GetMBarHeight();
  353.     (**gControl).contrlRect.bottom = (**gControl).contrlRect.top + gBaseline
  354.                         + gFontInfo.descent + gFontInfo.leading + kBottomMargin;
  355.  
  356.     GetMBarHeight() = 0;
  357.     menuBar = GetNewMBar((**gControl).contrlMin);
  358.     if (menuBar != NIL) {
  359.         gMenuList = (MenuBarHdl) menuBar;
  360.     } else {
  361.         menuBar = GetMenuBar();
  362.         ClearMenuBar();
  363.         gMenuList = (MenuBarHdl) GetMenuBar();
  364.         SetMenuBar(menuBar);
  365.         DisposeHandle(menuBar);
  366.     }
  367.     GetMBarHeight() = gNormalHeight;
  368. }
  369.  
  370.  
  371. //--------------------------------------------------------------------------------
  372.  
  373. void    DisposeMyControl()
  374. {
  375.     DisposeHandle((Handle) gMenuList);
  376. }
  377.  
  378.  
  379. //--------------------------------------------------------------------------------
  380.  
  381. void    DoClearMenuBar()
  382. {
  383.     SwapMenuBars();
  384.     ClearMenuBar();
  385.     SwapMenuBars();
  386. }
  387.  
  388.  
  389. //--------------------------------------------------------------------------------
  390.  
  391. void    DoDeleteMenu(short menuID)
  392. {
  393.     if (IndexToID(gTheMenu) == menuID)
  394.         gTheMenu = -1;
  395.  
  396.     SwapMenuBars();
  397.     DeleteMenu(menuID);
  398.     SwapMenuBars();
  399. }
  400.  
  401.  
  402. //--------------------------------------------------------------------------------
  403.  
  404. void    DoDrawMenuBar()
  405. {
  406.     Rect            frame;
  407.     short            loop;
  408.  
  409.     PenNormal();
  410.     frame = (**gControl).contrlRect;
  411.     FrameRect(&frame);
  412.  
  413.     gTheMenu = -1;
  414.     for (loop = GetMenuCount() - 1; loop >= 0; loop--) {
  415.         DrawMenuTitle(loop);
  416.     }
  417. }
  418.  
  419.  
  420. //--------------------------------------------------------------------------------
  421.  
  422. void    DoFlashMenuBar(short menuID)
  423. {
  424.     Rect        bounds;
  425.  
  426.     if (menuID != 0)
  427.         DoHiliteMenu(menuID);
  428.     else {
  429.         bounds = (**gControl).contrlRect;
  430.         InsetRect(&bounds, 1, 1);
  431.         InvertRect(&bounds);
  432.     }
  433. }
  434.  
  435.  
  436. //--------------------------------------------------------------------------------
  437.  
  438. MenuBarHdl    DoGetMenuBar()
  439. {
  440.     return gMenuList;
  441. }
  442.  
  443.  
  444. //--------------------------------------------------------------------------------
  445.  
  446. MenuHandle    DoGetMHandle(short menuID)
  447. {
  448.     short    menuIndex;
  449.     
  450.     menuIndex = IDToIndex(menuID);
  451.     if (menuIndex >= 0)
  452.         return GetNthMenu(menuIndex);
  453.     else
  454.         return NIL;
  455. }
  456.  
  457.  
  458. //--------------------------------------------------------------------------------
  459.  
  460. void    DoHiliteMenu(short menuID)
  461. {
  462.     short        menuIndex;
  463.     Rect        invertRect;
  464.     
  465.     menuIndex = IDToIndex(menuID);
  466.     if (menuIndex != gTheMenu) {
  467.         if (menuIndex >= 0) {
  468.             invertRect = GetInvertRect(menuIndex);
  469.             InvertRect(&invertRect);
  470.         }
  471.         gTheMenu = menuIndex;
  472.     }
  473. }
  474.  
  475.  
  476. //--------------------------------------------------------------------------------
  477.  
  478. void    DoInsertMenu(MenuHandle menu, short before)
  479. {
  480.     SwapMenuBars();
  481.     InsertMenu(menu, before);
  482.     SwapMenuBars();
  483. }
  484.  
  485.  
  486. //--------------------------------------------------------------------------------
  487.  
  488. long    DoMenuKey(char theKey)
  489. {
  490.     char            upperKey[2];
  491.     short            loop;
  492.     MenuHandle        menu;
  493.     short            mItems;
  494.     short            menuItem;
  495.     short            key;
  496.  
  497.     upperKey[0] = 1;
  498.     upperKey[1] = theKey;
  499.     UprString((StringPtr) &upperKey, true);
  500.  
  501.     for (loop = GetMenuCount() - 1; loop >= 0; loop--) {
  502.         menu = GetNthMenu(loop);
  503.         mItems = CountMItems(menu);
  504.         for (menuItem = 1; menuItem <= mItems; menuItem++) {
  505.             if (menuItem > 31 || (((**menu).enableFlags & (1 << menuItem)) != 0)) {
  506.                 GetItemCmd(menu, menuItem, &key);
  507.                 if (key == upperKey[1]) {
  508.                     return ((long) (**menu).menuID << 16) + menuItem;
  509.                 }
  510.             }
  511.         }
  512.     }
  513.  
  514.     return 0;
  515. }
  516.  
  517.  
  518. //--------------------------------------------------------------------------------
  519.  
  520. long    DoMenuSelect(Point startPt)
  521. {
  522. #pragma unused (startPt)
  523.  
  524.     Point            currentLocation;
  525.     short            oldMenuIndex;
  526.     short            newMenuIndex;
  527.     Rect            invertRect;
  528.     Point            where;
  529.     MenuHandle        menu;
  530.     long            menuAndItem;
  531.     short            oldMenuID;
  532.     Handle            myMDEF;
  533.  
  534.     menuAndItem = 0;
  535.     while (Button()) {
  536.         GetMouse(¤tLocation);
  537.         oldMenuIndex = gTheMenu;
  538.         newMenuIndex = FindHitMenu(currentLocation);
  539.         if (oldMenuIndex != newMenuIndex) {
  540.             gTheMenu = newMenuIndex;
  541.             DrawMenuTitle(oldMenuIndex);
  542.             if (newMenuIndex >= 0) {
  543.                 DrawMenuTitle(newMenuIndex);
  544.     
  545.                 invertRect = GetInvertRect(newMenuIndex);
  546.                 where.v = invertRect.bottom + 1;
  547.                 where.h = invertRect.left + 1;
  548.                 LocalToGlobal(&where);
  549.     
  550.                 gOldMenuHook = MenuHook;
  551.                 MenuHook = (ProcPtr) MyMenuHook;
  552.     
  553.                 menu = GetNthMenu(newMenuIndex);
  554.     
  555.                 oldMenuID = (**menu).menuID;
  556.                 (**menu).menuID = GetFreeHMenuID();
  557.     
  558.                 myMDEF = GetResource('MDEF', kStayPutMDEF);
  559.                 if (myMDEF != NIL) {
  560.                     (**(StdHeaderHdl) myMDEF).refCon = (long) (**menu).menuProc;
  561.                     (**menu).menuProc = myMDEF;
  562.                 }
  563.     
  564.                 InsertMenu(menu, hierMenu);
  565.                 menuAndItem = PopUpMenuSelect(menu, where.v, where.h, 1);
  566.                 DeleteMenu((**menu).menuID);
  567.     
  568.                 (**menu).menuID = oldMenuID;
  569.     
  570.                 if (myMDEF != NIL) {
  571.                     (**menu).menuProc = (Handle) (**(StdHeaderHdl) myMDEF).refCon;
  572.                     (**(StdHeaderHdl) myMDEF).refCon = (long) NIL;
  573.                 }
  574.     
  575.                 MenuHook = gOldMenuHook;
  576.     
  577.                 if (HiWord(menuAndItem) != 0)
  578.                     menuAndItem = ((long) oldMenuID << 16) + (short) menuAndItem;
  579.     
  580.                 (**gControl).contrlValue = HiWord(menuAndItem);
  581.                 (**gControl).contrlMax = LoWord(menuAndItem);
  582.             }
  583.         }
  584.     }
  585.  
  586.     if (gTheMenu != -1) {
  587.         oldMenuIndex = gTheMenu;
  588.         gTheMenu = -1;
  589.         DrawMenuTitle(oldMenuIndex);
  590.     }
  591.  
  592.     return menuAndItem;
  593. }
  594.  
  595.  
  596. //--------------------------------------------------------------------------------
  597.  
  598. void    DoSetMenuBar(MenuBarHdl menuBar)
  599. {
  600.     DisposeHandle((Handle) gMenuList);
  601.     gMenuList = menuBar;
  602.     DoDrawMenuBar();
  603. }
  604.  
  605.  
  606. //--------------------------------------------------------------------------------
  607.  
  608. void    DrawMenuTitle(short menuIndex)
  609. {
  610.     Rect            invertRect;
  611.     Point            titleLocation;
  612.     MenuHandle        menu;
  613.  
  614.     if ((menuIndex >= 0) && (menuIndex < GetMenuCount())) {
  615.  
  616.         invertRect = GetInvertRect(menuIndex);
  617.         EraseRect(&invertRect);
  618.  
  619.         menu = GetNthMenu(menuIndex);
  620.         if ((((**menu).enableFlags & 1) == 0) || ((**gControl).contrlHilite == 255))
  621.             TextMode(grayishTextOr);
  622.         else
  623.             TextMode(srcOr);
  624.         
  625.         titleLocation = GetTitleLocation(menuIndex);
  626.         MoveTo(titleLocation.h, titleLocation.v);
  627.         HLock((Handle) menu);
  628.         DrawString((**menu).menuData);
  629.         HUnlock((Handle) menu);
  630.  
  631.         if (gTheMenu == menuIndex)
  632.             InvertRect(&invertRect);
  633.     }
  634. }
  635.  
  636.  
  637. //--------------------------------------------------------------------------------
  638.  
  639. short    FindHitMenu(Point location)
  640. {
  641.     short            loop;
  642.     Rect            hitRect;
  643.  
  644.     for (loop = GetMenuCount() - 1; loop >= 0; loop--) {
  645.         hitRect = GetHitRect(loop);
  646.         if (PtInRect(location, &hitRect)) {
  647.             break;
  648.         }
  649.     }
  650.  
  651.     return loop;        // returns -1 if no hit
  652. }
  653.  
  654.  
  655. //--------------------------------------------------------------------------------
  656.  
  657. short    GetFreeHMenuID(void)
  658. {
  659.     short    index;
  660.  
  661.     for (index = 235-20; index > 0; index--) {
  662.         if (GetMHandle(index) == NIL)
  663.             return index;
  664.     }
  665.     return -1;
  666. }
  667.  
  668.  
  669. //--------------------------------------------------------------------------------
  670.  
  671. Rect    GetHitRect(short menuIndex)
  672. {
  673.     Rect        bounds;
  674.     RectPtr        rectPtr;
  675.     MenuBarPtr    menuBarPtr;
  676.     
  677.     rectPtr = &(**gControl).contrlRect;
  678.     menuBarPtr = *gMenuList;
  679.  
  680.     bounds.top = rectPtr->top + 1;
  681.     bounds.bottom = rectPtr->bottom - 1;
  682.     bounds.left = rectPtr->left + menuBarPtr->menus[menuIndex].menuLeft;
  683.     menuIndex++;
  684.     bounds.right = rectPtr->left + ((menuIndex < GetMenuCount())
  685.                                         ? menuBarPtr->menus[menuIndex].menuLeft
  686.                                         : menuBarPtr->lastRight);
  687.     
  688.     return bounds;
  689. }
  690.  
  691.  
  692. //--------------------------------------------------------------------------------
  693.  
  694. Rect    GetInvertRect(short menuIndex)
  695. {
  696.     Rect        bounds;
  697.     
  698.     bounds = GetHitRect(menuIndex);
  699.     bounds.left--;
  700.     bounds.right += 4;
  701.     return bounds;
  702. }
  703.  
  704.  
  705. //--------------------------------------------------------------------------------
  706.  
  707. short    GetMenuCount()
  708. {
  709.     return (**gMenuList).lastMenu / (short) sizeof(MenuRec);
  710. }
  711.  
  712.  
  713. //--------------------------------------------------------------------------------
  714.  
  715. MenuHandle    GetNthMenu(short index)
  716. {
  717.     return (**gMenuList).menus[index].menu;
  718. }
  719.  
  720.  
  721. //--------------------------------------------------------------------------------
  722.  
  723. Point    GetTitleLocation(short menuIndex)
  724. {
  725.     Point    result;
  726.     
  727.     result.h = (**gMenuList).menus[menuIndex].menuLeft + kTextMargin;
  728.     result.v = (**gControl).contrlRect.top + gBaseline;
  729.     
  730.     return result;
  731. }
  732.  
  733.  
  734. //--------------------------------------------------------------------------------
  735.  
  736. short    IDToIndex(short menuID)
  737. {
  738.     short        loop;
  739.  
  740.     for (loop = GetMenuCount() - 1; loop >= 0; loop--) {
  741.         if ((**GetNthMenu(loop)).menuID == menuID)
  742.             break;
  743.     }
  744.     return loop;
  745. }
  746.  
  747.  
  748. //--------------------------------------------------------------------------------
  749.  
  750. short    IndexToID(short menuIndex)
  751. {
  752.     if ((menuIndex >= 0) && (menuIndex < GetMenuCount()))
  753.         return (**GetNthMenu(menuIndex)).menuID;
  754.     else
  755.         return 0;
  756. }
  757.  
  758.  
  759. //--------------------------------------------------------------------------------
  760.  
  761. void    MyMenuHook()
  762. {
  763.     typedef void (*MenuHookProc)(void);
  764.  
  765.     GrafPtr        oldPort;
  766.     Point        mouseLocation;
  767.     short        hitMenu;
  768.     Ptr            oldA5;
  769.  
  770. #ifdef THINK_C
  771.     SetUpA4();
  772. #else
  773.     oldA5 = UseGlobals();
  774. #endif
  775.  
  776.     if (gOldMenuHook != NIL)
  777.         ((MenuHookProc) gOldMenuHook)();
  778.  
  779.     GetPort(&oldPort);
  780.     SetPort((**gControl).contrlOwner);
  781.     GetMouse(&mouseLocation);
  782.     hitMenu = FindHitMenu(mouseLocation);
  783.     if ((hitMenu >= 0) && (hitMenu != gTheMenu)) {
  784.         PostEvent(mouseUp, 0);
  785.     }
  786.     SetPort(oldPort);
  787.  
  788. #ifdef THINK_C
  789.     RestoreA4();
  790. #else
  791.     DoneWithGlobals(oldA5);
  792. #endif
  793. }
  794.  
  795.  
  796. //--------------------------------------------------------------------------------
  797.  
  798. void    SwapMenuBars()
  799. {
  800.     MenuBarHdl        oldMenuBar;
  801.     
  802.     oldMenuBar = (MenuBarHdl) MenuList;
  803.     MenuList = (Handle) gMenuList;
  804.     gMenuList = oldMenuBar;
  805. }
  806.  
  807.  
  808.  
  809.  
  810.  
  811. #if 0
  812.  
  813. void            CalcMenuPositions(short index);
  814. long            CallMBDF(short message, short param1, long param2);
  815.  
  816. //--------------------------------------------------------------------------------
  817.  
  818. void    CalcMenuPositions(short index)
  819. {
  820.     SwapMenuBars();
  821.     CallMBDF(2, 0, (index+1) * 6);
  822.     SwapMenuBars();
  823. }
  824.  
  825.  
  826. //--------------------------------------------------------------------------------
  827.  
  828. long    CallMBDF(short message, short param1, long param2)
  829. {
  830.     typedef pascal long (*MBDFProc)(short selector, short message, short
  831. parameter1,
  832.                                         long parameter2);
  833.     Handle        mbdfHandle;
  834.     short        mbResID;
  835.     short        resID;
  836.     short        mbVariant;
  837.     char        oldState;
  838.     long        result;
  839.     
  840.     mbResID = (**gMenuList).mbResID;
  841.     resID = mbResID >> 3;
  842.     mbVariant = mbResID & 0x0007;
  843.     mbdfHandle = GetResource('MBDF', resID);
  844.     if (mbdfHandle != NIL) {
  845.         if (*mbdfHandle == NIL)  {
  846.             LoadResource(mbdfHandle);
  847.         }
  848.         if (*mbdfHandle != NIL) {
  849.         
  850.             oldState = HGetState(mbdfHandle);
  851.             HLock(mbdfHandle);
  852.             result = ((MBDFProc) *mbdfHandle)(mbVariant, message, param1, param2);
  853.             HSetState(mbdfHandle, oldState);
  854.             return result;
  855.         }
  856.     }
  857.  
  858.     SysError(dsMBarNFnd);
  859. }
  860. #endif
  861.  
  862.  
  863. --
  864. Keith Rollin
  865. Phantom Programmer
  866. Taligent, Inc.
  867.