home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / Mark Pilgrim / MSG Demo 1.4 / source / Shell ƒ / menus.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-30  |  13.0 KB  |  544 lines  |  [TEXT/KAHL]
  1. /**********************************************************************\
  2.  
  3. File:        menus.c
  4.  
  5. Purpose:    This module handles menu selections.
  6.  
  7. This program is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2 of the License, or
  10. (at your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program in a file named "GNU General Public License".
  19. If not, write to the Free Software Foundation, 675 Mass Ave,
  20. Cambridge, MA 02139, USA.
  21.  
  22. \**********************************************************************/
  23.  
  24. #include "graphics.h"
  25. #include "menus.h"
  26. #include "help.h"
  27. #include "prefs.h"
  28. #include "environment.h"
  29. #include "sounds.h"
  30. #include "error.h"
  31. #include "file interface.h"
  32. #include "program globals.h"
  33. #include "demo.h"
  34. #include "demo crash.h"
  35. #include "file management.h"
  36. #include "debinhex dispatch.h"
  37.  
  38. extern    long        menuDisable : 0x0b54;
  39.  
  40. Boolean            gMenuEnabled;
  41. MenuHandle        gAppleMenu;
  42. MenuHandle        gFileMenu;
  43. MenuHandle        gEditMenu;
  44. MenuHandle        gWipesMenu;
  45. MenuHandle        gAdditionsMenu;
  46. MenuHandle        gScrollMenu;
  47. MenuHandle        gFluffMenu;
  48. MenuHandle        gHelpMenu;
  49. MenuHandle        gCrashMenu;
  50.  
  51. #define NUM_ORIGINALS    CountMItems(gWipesMenu)
  52. #define NUM_ADDITIONS    CountMItems(gAdditionsMenu)
  53. #define    NUM_SCROLLS        CountMItems(gScrollMenu)
  54.  
  55. enum
  56. {
  57.     helpMenu = 200, crashMenu,
  58.     
  59.     appleMenu = 400, fileMenu, editMenu, wipesMenu, additionsMenu, scrollMenu, fluffMenu,
  60.     
  61.     aboutItem = 1, aboutMSGItem, helpPointerItem,
  62.     
  63.     openItem = 1, closeItem, deBinHexItem = 4, disableQuitItem = 6, enableQuitItem,
  64.         forceQuitItem = 9, quitItem,
  65.     
  66.     undoItem = 1, cutItem = 3, copyItem, pasteItem, clearItem,
  67.     
  68.     spiralItem = 3, caste1Item = 5, rippleItem = 8, dissolveItem = 9, caste2Item = 11,
  69.     
  70.     serendipityItem = 9, bulgeItem = 10, splitScrollItem = 5, scrollInItem = 6,
  71.     
  72.     repeatItem = 1, reverseToggle, effectsOnlyItem = 4, effectsPlusReverseEffectsItem,
  73.         effectsPlusFadesItem, reverseEffectsPlusFadesItem, fullScreenFadesItem,
  74.         soundToggle = 10, crashPointerItem = 12
  75. };
  76.  
  77. /*-----------------------------------------------------------------------------------*/
  78. /* internal stuff for menus.c                                                        */
  79.  
  80. void HandleAppleMenu(int menuItem);
  81. void HandleFileMenu(int menuItem);
  82. void HandleEditMenu(int menuItem);
  83. void HandleTheWipe(int menuItem, int offset, int maxItem);
  84. void HandleHelpMenu(int menuItem);
  85. void HandleFluffMenu(int menuItem);
  86. void HandleCrashMenu(int menuItem);
  87.  
  88.  
  89. Boolean InitTheMenus(void)
  90. {
  91.     Handle        MBARHandle;
  92.     
  93.     if ((MBARHandle=GetNewMBar(400))==0L)        /* sez which menus are in menu bar. */
  94.         return FALSE;
  95.     SetMenuBar(MBARHandle);                        /* set this to be THE menu bar to use. */
  96.     
  97.     if ((gAppleMenu=GetMHandle(appleMenu))==0L)    /* GetNewMBar also got menu handles of */
  98.         return FALSE;
  99.     if ((gFileMenu=GetMHandle(fileMenu))==0L)    /* every menu it includes, so just */
  100.         return FALSE;
  101.     if ((gEditMenu=GetMHandle(editMenu))==0L)    /* grab these handles and assign them */
  102.         return FALSE;
  103.     if ((gWipesMenu=GetMHandle(wipesMenu))==0L)
  104.         return FALSE;
  105.     if ((gAdditionsMenu=GetMHandle(additionsMenu))==0L)
  106.         return FALSE;
  107.     if ((gScrollMenu=GetMHandle(scrollMenu))==0L)
  108.         return FALSE;
  109.     if ((gFluffMenu=GetMHandle(fluffMenu))==0L)
  110.         return FALSE;
  111.     
  112.     if ((gHelpMenu=GetMenu(helpMenu))==0L)
  113.         return FALSE;
  114.     if ((gCrashMenu=GetMenu(crashMenu))==0L)
  115.         return FALSE;
  116.     InsertMenu(gHelpMenu, -1);
  117.     InsertMenu(gCrashMenu, -1);
  118.     
  119.     AddResMenu(gAppleMenu, 'DRVR');                /* adds control panels to apple menu */
  120.     
  121.     AdjustMenus();                                /* dim/enable/check/mark menus/items */
  122.     DrawMenuBar();                                /* draws the actual menu bar */
  123.     
  124.     return TRUE;
  125. }
  126.  
  127. void AdjustMenus(void)
  128. {
  129.     WindowPeek    theWindow;
  130.     int            kind;
  131.     
  132.     if (gInProgress)
  133.     {
  134.         DisableItem(gAppleMenu, aboutItem);
  135.         DisableItem(gAppleMenu, aboutMSGItem);
  136.         DisableItem(gAppleMenu, helpPointerItem);
  137.         if (gSystemSevenOrLater)
  138.         {
  139.             DisableItem(gFileMenu, openItem);
  140.             DisableItem(gFileMenu, closeItem);
  141.             DisableItem(gFileMenu, deBinHexItem);
  142.             DisableItem(gFileMenu, disableQuitItem);
  143.             DisableItem(gFileMenu, enableQuitItem);
  144.             DisableItem(gFileMenu, quitItem);
  145.         }
  146.         else DisableItem(gFileMenu, 0);
  147.         
  148.         DisableItem(gEditMenu, 0);
  149.         DisableItem(gWipesMenu, 0);
  150.         DisableItem(gAdditionsMenu, 0);
  151.         DisableItem(gScrollMenu, 0);
  152.         DisableItem(gFluffMenu, 0);
  153.     }
  154.     else
  155.     {
  156.         EnableItem(gAppleMenu, aboutItem);
  157.         EnableItem(gAppleMenu, aboutMSGItem);
  158.         EnableItem(gAppleMenu, helpPointerItem);
  159.         EnableItem(gFileMenu, deBinHexItem);
  160.         EnableItem(gWipesMenu, 0);
  161.         EnableItem(gAdditionsMenu, 0);
  162.         EnableItem(gScrollMenu, 0);
  163.         EnableItem(gFluffMenu, 0);
  164.         
  165.         theWindow = (WindowPeek)FrontWindow();
  166.         kind = theWindow ? theWindow->windowKind : 0;
  167.         
  168.         if(kind < 0)
  169.             EnableItem(gEditMenu, 0);
  170.         else
  171.             DisableItem(gEditMenu, 0);
  172.         
  173.         if (theWindow)
  174.             EnableItem(gFileMenu, closeItem);
  175.         else
  176.             DisableItem(gFileMenu, closeItem);
  177.         
  178.         if(gTheWindow[kMainWindow])
  179.             DisableItem(gFileMenu, openItem);
  180.         else
  181.             EnableItem(gFileMenu, openItem);
  182.         
  183.         if (gDisableQuit)
  184.         {
  185.             DisableItem(gFileMenu, quitItem);
  186.             DisableItem(gFileMenu, disableQuitItem);
  187.             EnableItem(gFileMenu, enableQuitItem);
  188.         }
  189.         else
  190.         {
  191.             EnableItem(gFileMenu, quitItem);
  192.             EnableItem(gFileMenu, disableQuitItem);
  193.             DisableItem(gFileMenu, enableQuitItem);
  194.         }
  195.         if (gLastWipe==-1)
  196.             DisableItem(gFluffMenu, repeatItem);
  197.         else
  198.             EnableItem(gFluffMenu, repeatItem);
  199.         
  200.         if (gWipeStatus==kFullScreen)
  201.         {
  202.             DisableItem(gWipesMenu, caste1Item);
  203.             DisableItem(gWipesMenu, rippleItem);
  204.             DisableItem(gWipesMenu, dissolveItem);
  205.             DisableItem(gWipesMenu, caste2Item);
  206.         }
  207.         else
  208.         {
  209.             EnableItem(gWipesMenu, caste1Item);
  210.             EnableItem(gWipesMenu, rippleItem);
  211.             EnableItem(gWipesMenu, dissolveItem);
  212.             EnableItem(gWipesMenu, caste2Item);
  213.         }
  214.         
  215.         if (gIsReversed)
  216.         {
  217.             DisableItem(gWipesMenu, spiralItem);
  218.             DisableItem(gAdditionsMenu, serendipityItem);
  219.             DisableItem(gAdditionsMenu, bulgeItem);
  220.             DisableItem(gScrollMenu, scrollInItem);
  221.             DisableItem(gScrollMenu, splitScrollItem);
  222.         }
  223.         else
  224.         {
  225.             EnableItem(gWipesMenu, spiralItem);
  226.             EnableItem(gAdditionsMenu, serendipityItem);
  227.             EnableItem(gAdditionsMenu, bulgeItem);
  228.             EnableItem(gScrollMenu, scrollInItem);
  229.             EnableItem(gScrollMenu, splitScrollItem);
  230.         }
  231.         if (gSoundAvailable)
  232.             EnableItem(gFluffMenu, soundToggle);
  233.         else
  234.             DisableItem(gFluffMenu, soundToggle);
  235.     }
  236.     
  237.     CheckItem(gFluffMenu, effectsOnlyItem, (gWipeStatus==kEffectsOnly));
  238.     CheckItem(gFluffMenu, effectsPlusReverseEffectsItem, (gWipeStatus==kEffectsPlusReverseEffects));
  239.     CheckItem(gFluffMenu, effectsPlusFadesItem, (gWipeStatus==kFadesPlusEffects));
  240.     CheckItem(gFluffMenu, reverseEffectsPlusFadesItem, (gWipeStatus==kFadesPlusReverseEffects));
  241.     CheckItem(gFluffMenu, fullScreenFadesItem, (gWipeStatus==kFullScreen));
  242.     CheckItem(gFluffMenu, soundToggle, gSoundToggle&&gSoundAvailable);
  243. }
  244.  
  245. void HandleMenu(long mSelect)
  246. {
  247.     int            menuID = HiWord(mSelect);
  248.     int            menuItem = LoWord(mSelect);
  249.     
  250.     if (menuID==0)
  251.     {
  252.         menuID=HiWord(menuDisable);
  253.         menuItem=LoWord(menuDisable);
  254.         gMenuEnabled=FALSE;
  255.     }
  256.     else gMenuEnabled=TRUE;
  257.     menuDisable=0L;
  258.  
  259.     switch (menuID)
  260.     {
  261.         case appleMenu:
  262.             HandleAppleMenu(menuItem);
  263.             break;
  264.         case fileMenu:
  265.             HandleFileMenu(menuItem);
  266.             break;    
  267.         case editMenu:
  268.             HandleEditMenu(menuItem);
  269.             break;
  270.         case wipesMenu:
  271.             HandleTheWipe(menuItem, 0, NUM_ORIGINALS);
  272.             break;
  273.         case additionsMenu:
  274.             HandleTheWipe(menuItem, NUM_ORIGINALS, NUM_ADDITIONS);
  275.             break;
  276.         case scrollMenu:
  277.             HandleTheWipe(menuItem, NUM_ORIGINALS+NUM_ADDITIONS, NUM_SCROLLS);
  278.             break;
  279.         case helpMenu:
  280.             HandleHelpMenu(menuItem);
  281.             break;
  282.         case fluffMenu:
  283.             HandleFluffMenu(menuItem);
  284.             break;
  285.         case crashMenu:
  286.             HandleCrashMenu(menuItem);
  287.             break;
  288.     }
  289. }
  290.  
  291. void DoTheCloseThing(WindowPeek theWindow)
  292. /* a standard close procedure, called when "close" is chosen from File menu and when
  293.    a window is closed through its close box */
  294. {
  295.     Boolean            gotone;
  296.     int                i;
  297.     int                kind;
  298.     
  299.     kind = theWindow ? theWindow->windowKind : 0;
  300.     if (kind<0)        /* DA window or other system window */
  301.         CloseDeskAcc(kind);
  302.     else
  303.     {
  304.         gotone=FALSE;
  305.         /* see if it's one of ours */
  306.         for (i=0; (i<NUM_WINDOWS) && (!gotone); i++)
  307.             gotone=(theWindow==gTheWindow[i]);
  308.         
  309.         if (gotone)        /* if it's one of ours...  see graphics.c */
  310.             CloseTheWindow(gTheWindowData[i-1]);    /* this may return FALSE = not closed */
  311.         else
  312.             DisposeWindow(theWindow);        /* not one of ours, so just close it */
  313.     
  314.         AdjustMenus();    /* may affect which menu items or menus are available, etc */
  315.     }
  316. }
  317.  
  318. void HandleAppleMenu(int menuItem)
  319. {
  320.     GrafPtr        savePort;
  321.     Str255        name;
  322.     
  323.     switch (menuItem)
  324.     {
  325.         case aboutItem:
  326.             if (gMenuEnabled)
  327.                 OpenTheWindow(kAbout);
  328.             else DoSound(sound_fluff, TRUE);
  329.             break;
  330.         case aboutMSGItem:
  331.             if (gMenuEnabled)
  332.                 OpenTheWindow(kAboutMSG);
  333.             else DoSound(sound_fluff, TRUE);
  334.             break;
  335.         case helpPointerItem:
  336.             if (gMenuEnabled)
  337.                 HandleHelpMenu(1);
  338.             else DoSound(sound_fluff, TRUE);
  339.             break;
  340.         default:
  341.             if (menuItem > helpPointerItem+1)
  342.             {
  343.                 GetPort(&savePort);
  344.                 GetItem(gAppleMenu, menuItem, name);
  345.                 OpenDeskAcc(name);
  346.                 SetPort(savePort);
  347.             }
  348.             break;
  349.     }
  350. }
  351.  
  352. void HandleFileMenu(int menuItem)
  353. {
  354.     WindowPtr            theWindow;
  355.     int                    i;
  356.     Boolean                gotone;
  357.     
  358.     switch (menuItem)
  359.     {
  360.         case openItem:
  361.             if (gMenuEnabled)
  362.                 OpenTheWindow(kMainWindow);
  363.             else
  364.                 DoSound(sound_fluff, TRUE);
  365.             break;
  366.         case closeItem:
  367.             if (FrontWindow()!=0L)
  368.                 DoTheCloseThing(FrontWindow());
  369.             else
  370.                 DoSound(sound_fluff, TRUE);
  371.             break;
  372.         case deBinHexItem:
  373.             if (gMenuEnabled)
  374.             {
  375.                 if (GetSourceFile(&inputFS))
  376.                     HandleError(DeBinHexDispatch(), FALSE);
  377.             }
  378.             else DoSound(sound_fluff, TRUE);
  379.             break;
  380.         case disableQuitItem:
  381.             if (gMenuEnabled)
  382.             {
  383.                 gDisableQuit=TRUE;
  384.                 AdjustMenus();
  385.             }
  386.             else DoSound(sound_fluff, TRUE);
  387.             break;
  388.         case enableQuitItem:
  389.             if (gMenuEnabled)
  390.             {
  391.                 gDisableQuit=FALSE;
  392.                 AdjustMenus();
  393.             }
  394.             else DoSound(sound_fluff, TRUE);
  395.             break;
  396.         case forceQuitItem:
  397.             if (gMenuEnabled)
  398.                 SysError(0x4e22);
  399.             else DoSound(sound_fluff, TRUE);
  400.             break;
  401.         case quitItem:
  402.             if (!gInProgress)
  403.                 gDone=TRUE;
  404.             else DoSound(sound_fluff, TRUE);
  405.             break;
  406.     }
  407. }
  408.  
  409. void HandleEditMenu(int menuItem)
  410. {
  411.     if ((menuItem>0) && (menuItem!=2))
  412.     {
  413.         if (gMenuEnabled)
  414.             SystemEdit(menuItem - 1);
  415.         else DoSound(sound_fluff, TRUE);
  416.     }
  417. }
  418.  
  419. void HandleTheWipe(int menuItem, int offset, int maxItem)
  420. {
  421.     if ((menuItem>0) && (menuItem<=maxItem))
  422.     {
  423.         if (gMenuEnabled)
  424.         {
  425.             if (gWipeStatus==kFullScreen)
  426.                 DoFullScreenFade(menuItem+offset);
  427.             else
  428.             {
  429.                 OpenTheWindow(kMainWindow);
  430.                 gWhichWipe=menuItem+offset;
  431.                 OpenTheWindow(kMainWindow);
  432.                 if (gWipeStatus==kEffectsPlusReverseEffects)
  433.                 {
  434.                     gIsReversed=!gIsReversed;
  435.                     gWhichWipe=menuItem+offset;
  436.                     OpenTheWindow(kMainWindow);
  437.                     gIsReversed=!gIsReversed;
  438.                 }
  439.             }
  440.         }
  441.         else DoSound(sound_fluff, TRUE);
  442.     }
  443. }
  444.  
  445. void HandleHelpMenu(int menuItem)
  446. {
  447.     gLastHelp=gWhichHelp;
  448.     gWhichHelp=menuItem;
  449.     OpenTheWindow(kHelp);
  450. }
  451.  
  452. void HandleFluffMenu(int menuItem)
  453. {
  454.     switch (menuItem)
  455.     {
  456.         case repeatItem:
  457.             if (gMenuEnabled)
  458.                 HandleTheWipe(gLastWipe, 0, 999);
  459.             else DoSound(sound_fluff, TRUE);
  460.             break;
  461.         case soundToggle:
  462.             if (gMenuEnabled)
  463.             {
  464.                 gSoundToggle=!gSoundToggle;
  465.                 DoSound(sound_on, TRUE);
  466.             }
  467.             else DoSound(sound_fluff, TRUE);
  468.             break;
  469.         case effectsOnlyItem:
  470.             if (gMenuEnabled)
  471.                 gWipeStatus=kEffectsOnly;
  472.             else DoSound(sound_fluff, TRUE);
  473.             break;
  474.         case effectsPlusReverseEffectsItem:
  475.             if (gMenuEnabled)
  476.                 gWipeStatus=kEffectsPlusReverseEffects;
  477.             else DoSound(sound_fluff, TRUE);
  478.             break;
  479.         case effectsPlusFadesItem:
  480.             if (gMenuEnabled)
  481.                 gWipeStatus=kFadesPlusEffects;
  482.             else DoSound(sound_fluff, TRUE);
  483.             break;
  484.         case reverseEffectsPlusFadesItem:
  485.             if (gMenuEnabled)
  486.                 gWipeStatus=kFadesPlusReverseEffects;
  487.             else DoSound(sound_fluff, TRUE);
  488.             break;
  489.         case fullScreenFadesItem:
  490.             if (gMenuEnabled)
  491.                 gWipeStatus=kFullScreen;
  492.             else DoSound(sound_fluff, TRUE);
  493.             break;
  494.         case reverseToggle:
  495.             if (gMenuEnabled)
  496.             {
  497.                 gIsReversed=!gIsReversed;
  498.                 ReverseAllWipes();
  499.             }
  500.             else DoSound(sound_fluff, TRUE);
  501.             break;
  502.         case crashPointerItem:
  503.             if (!gMenuEnabled)
  504.                 DoSound(sound_fluff, TRUE);
  505.             break;
  506.     }
  507. }
  508.  
  509. void HandleCrashMenu(int menuItem)
  510. {
  511.     if (menuItem>0)
  512.         CrashAndBurn(menuItem);
  513. }
  514.  
  515. void ReverseAllWipes(void)
  516. {
  517.     int                whichMenu, whichItem, i;
  518.     MenuHandle        thisMenu;
  519.     Str255            thisName;
  520.     char            thisChar;
  521.     
  522.     for (whichMenu=0; whichMenu<3; whichMenu++)
  523.     {
  524.         switch (whichMenu)
  525.         {
  526.             case 0:    thisMenu=gWipesMenu;        break;
  527.             case 1:    thisMenu=gAdditionsMenu;    break;
  528.             case 2:    thisMenu=gScrollMenu;        break;
  529.         }
  530.         
  531.         for (whichItem=CountMItems(thisMenu); whichItem>0; whichItem--)
  532.         {
  533.             GetItem(thisMenu, whichItem, thisName);
  534.             for (i=thisName[0]; i>thisName[0]/2; i--)
  535.             {
  536.                 thisChar=thisName[i];
  537.                 thisName[i]=thisName[thisName[0]-i+1];
  538.                 thisName[thisName[0]-i+1]=thisChar;
  539.             }
  540.             SetItem(thisMenu, whichItem, thisName);
  541.         }
  542.     }
  543. }
  544.