home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / µSim 1.1 / source / DoMenu.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-25  |  12.7 KB  |  549 lines  |  [TEXT/CWIE]
  1. /*
  2. Copyright © 1993-1997 Fabrizio Oddone
  3. ••• ••• ••• ••• ••• ••• ••• ••• ••• •••
  4. This source code is distributed as freeware:
  5. you may copy, exchange, modify this code.
  6. You may include this code in any kind of application: freeware,
  7. shareware, or commercial, provided that full credits are given.
  8. You may not sell or distribute this code for profit.
  9. */
  10.  
  11. #include    <Limits.h>
  12.  
  13. #include    "UtilsSys7.h"
  14. #include    "Internet.h"
  15. #include    "FabLibResIDs.h"
  16. #include    "SimResIDs.h"
  17.  
  18. #include    "AEHandlers.h"
  19. #include    "Globals.h"
  20. #include    "Animation.h"
  21. #include    "Assembler.h"
  22. #include    "ControlStore.h"
  23. #include    "Disasm.h"
  24. #include    "DoMenu.h"
  25. #include    "Dump.h"
  26. #include    "Input.h"
  27. #include    "Main.h"
  28. #include    "Microprogram_Ed.h"
  29. #include    "myMemory.h"
  30. #include    "Preferences.h"
  31. #include    "Registers.h"
  32. #include    "Simulator.h"
  33. #include    "SimUtils.h"
  34. #include    "GrowZone.h"
  35.  
  36. #if defined(FabSystem7orlater)
  37.  
  38. //#pragma segment Main
  39.  
  40. static short sLastCommand = kST_STOPPED;
  41.  
  42.  
  43. static void DoMenuApple(short theItem);
  44. static void DoMenuEdit(short theItem);
  45. static void DoMenuMemory(short theItem);
  46. static void DoMenuRegs(short theItem);
  47. static void DoMenuHDisasm(short theItem);
  48. static void DoMenuHDump(short theItem);
  49. static void DoMenuControl(short theItem);
  50. static void CompletePreviousInstruction(void);
  51. static void DoMenuAssembler(short theItem);
  52.  
  53.  
  54. void SetLastMenuCommand(short newLastCmd)
  55. {
  56. sLastCommand = newLastCmd;
  57. }
  58.  
  59. void DoMenuApple(short theItem)
  60. {
  61. Str255    DAName;
  62.  
  63. if (theItem == kMItem_About__Simulato) {
  64. //    myAbout(DoIdle, nil, DoUpdate, DoActivate);
  65.     myMovableModalAbout(gPrefs.remembWind ? &gPrefs.aboutTL : nil,
  66.         gPrefs.remembWind ? &gPrefs.creditsTL : nil,
  67.         AdjustMenus,
  68.         Handle_My_Menu,
  69.         DomyKeyEvent,
  70.         DoUpdate,
  71.         DoActivate,
  72.         DoHighLevelEvent,
  73.         DoOSEvent,
  74.         DoIdle,
  75.         gSleep
  76.         );
  77.     UnloadSeg(myAbout);
  78.     }
  79. else {
  80.     GetMenuItemText(gMenu_Apple, theItem, DAName);
  81.     (void)OpenDeskAcc(DAName);
  82.     AdjustMenus(nil);
  83.     }
  84. }
  85.  
  86. void DoMenuFile(short theItem)
  87. {
  88. OSErr    err;
  89.  
  90. switch (theItem) {
  91.     case kMItem_New:
  92.         if (ReadyToTerminate()) {
  93.             DoNew();
  94.             UnloadSeg(DoNew);
  95.             DoMenuWindows(kMItem_Microprogram);
  96.             }
  97.         break;
  98.     case kMItem_Open_Control_St: {
  99.         StandardFileReply    mySFR;
  100.         SFTypeList    myTypeList;
  101.  
  102.         if (ReadyToTerminate()) {
  103.             myTypeList[0] = kFTY_CSTORE;
  104.             myTypeList[1] = kFTY_CSTOREPAD;
  105.             StandardGetFile(0L, 2, myTypeList, &mySFR);
  106.             if (mySFR.sfGood) {
  107.                 err = myOpenCSFile(&mySFR.sfFile, mySFR.sfScript,
  108.                                         (mySFR.sfFlags & kfIsStationery) != 0);
  109.                 UnloadSeg(myOpenCSFile);
  110.                 if (err)
  111.                     ErrorAlert(err);
  112.                 }
  113.             }
  114.         }
  115.         break;
  116.     case kMItem_Close:
  117.         (void)ReadyToTerminate();
  118.         break;
  119.     case kMItem_Save_Control_St:
  120.         err = mySaveCSFile(kGOT_SAVE);
  121.         UnloadSeg(mySaveCSFile);
  122.         if (err)
  123.             if (err != 1)
  124.                 ErrorAlert(err);
  125.         break;
  126.     case kMItem_Save_Control_St2:
  127.         err = mySaveCSFile(kGOT_SAVEAS);
  128.         UnloadSeg(mySaveCSFile);
  129.         if (err)
  130.             if (err != 1)
  131.                 ErrorAlert(err);
  132.         break;
  133.     case kMItem_Save_CS_Stationery:
  134.         err = mySaveCSFile(kGOT_SAVESTATIONERY);
  135.         UnloadSeg(mySaveCSFile);
  136.         if (err)
  137.             if (err != 1)
  138.                 ErrorAlert(err);
  139.         break;
  140.     case kMItem_Revert_to_Saved:
  141.         if (CautionAlert_UPP(kALRT_REVERT, myStdFilterProc) == ok) {
  142.             err = RevertFile();
  143.             UnloadSeg(RevertFile);
  144.             if (err)
  145.                 ErrorAlert(err);
  146.             }
  147.         break;
  148.     case kMItem_Prefs:
  149.         Preferences();
  150.         UnloadSeg(Preferences);
  151.         break;
  152.     case kMItem_Quit:
  153.         if (ReadyToTerminate())
  154.             gDoneFlag = true;
  155.         break;
  156.     }
  157. }
  158.  
  159. void DoMenuEdit(short theItem)
  160. {
  161. Ptr    scPtr;
  162. union u_mir *scanPtr;
  163. union u_mir    tmpmir;
  164. OSErr    err;
  165. Byte    val;
  166.  
  167. if (SystemEdit(theItem - 1) == false) {
  168.     switch (theItem) {
  169. /* not implemented yet */
  170. //        case kMItem_Undo:
  171. //            break;
  172.         case kMItem_Cut:
  173.             if (gTheInput) {
  174.                 TECut(gTheInput);
  175.                 if (gWPtr_Microprogram_Ed == FrontWindow())
  176.                     Microprog_TextWasModified();
  177.                 else if (gWPtr_IO == FrontWindow())
  178.                     AdjustScrollbars(gWPtr_IO, false);
  179.                 if ((err = ZeroScrap()) == noErr)
  180.                     err = TEToScrap();
  181.                 if (err)
  182.                     ErrorAlert(err);
  183.                 }
  184.             else if ((gWPtr_Microprogram_Ed == FrontWindow()) &&
  185.                         (keyDownDest == kKEY_LIST))
  186.                 if (err = SendClipMsg(kCLIPMSG_CUT))
  187.                     ErrorAlert(err);
  188.             break;
  189.  
  190.         case kMItem_Copy:
  191.             if (gTheInput) {
  192.                 TECopy(gTheInput);
  193.                 if ((err = ZeroScrap()) == noErr)
  194.                     err = TEToScrap();
  195.                 if (err)
  196.                     ErrorAlert(err);
  197.                 }
  198.             else if ((gWPtr_Microprogram_Ed == FrontWindow()) &&
  199.                         (keyDownDest == kKEY_LIST))
  200.                 if (err = SendClipMsg(kCLIPMSG_COPY))
  201.                     ErrorAlert(err);
  202.             break;
  203.  
  204.         case kMItem_Paste:
  205.             if (gTheInput) {
  206.                 TEPaste(gTheInput);
  207.                 if (gWPtr_Microprogram_Ed == FrontWindow())
  208.                     Microprog_TextWasModified();
  209.                 else if (gWPtr_IO == FrontWindow())
  210.                     AdjustScrollbars(gWPtr_IO, false);
  211.                 }
  212.             else if ((gWPtr_Microprogram_Ed == FrontWindow()) &&
  213.                         (keyDownDest == kKEY_LIST))
  214.                 if (err = SendClipMsg(kCLIPMSG_PASTE))
  215.                     ErrorAlert(err);
  216.             break;
  217.  
  218.         case kMItem_Clear:
  219.             if (gTheInput) {
  220.                 TEDelete(gTheInput);
  221.                 if (gWPtr_Microprogram_Ed == FrontWindow())
  222.                     Microprog_TextWasModified();
  223.                 else if (gWPtr_IO == FrontWindow())
  224.                     AdjustScrollbars(gWPtr_IO, false);
  225.                 }
  226.             else if ((gWPtr_Microprogram_Ed == FrontWindow()) &&
  227.                         (keyDownDest == kKEY_LIST))
  228.                 if (err = SendClipMsg(kCLIPMSG_CLEAR))
  229.                     ErrorAlert(err);
  230.             break;
  231.         case kMItem_Select_All:
  232.             if (gTheInput)
  233.                 TESetSelect(0, SHRT_MAX, gTheInput);
  234.             break;
  235.         case kMItem_Insert:
  236. //            LSetDrawingMode(false, Lists[kL_COMMENTS]);
  237.             BlockMoveData(gCsMemory + theSelection[kL_COMMENTS],
  238.                 gCsMemory + theSelection[kL_COMMENTS] + 1,
  239.                 sizeof(union u_mir)*(maxLLine[kL_COMMENTS] - theSelection[kL_COMMENTS]));
  240.             gCsMemory[theSelection[kL_COMMENTS]].cstore = 0L;
  241.             for (scanPtr = gCsMemory; scanPtr < (gCsMemory + maxLLine[kL_COMMENTS]);
  242.                     tmpmir = *scanPtr++)
  243.                 if (tmpmir.bits.addr >= theSelection[kL_COMMENTS])
  244.                     if (tmpmir.bits.addr != 0x7F) { /* WARNING: non-portable form */
  245.                         tmpmir.bits.addr++;
  246.                         *(scanPtr - 1) = tmpmir;
  247.                         }
  248.             for (scPtr = gAssMemory; scPtr < (gAssMemory + kSIZE_ASSMEM); val = *scPtr++)
  249.                 if (val >= theSelection[kL_COMMENTS]) {
  250.                     val++;
  251.                     *(scPtr - 1) = val;
  252.                     }
  253.             LDelRow(1, maxLLine[kL_COMMENTS], Lists[kL_COMMENTS]);
  254.             LAddRow(1, theSelection[kL_COMMENTS]++, Lists[kL_COMMENTS]);
  255.             DocumentIsDirty(true);
  256. //            LSetDrawingMode(true, Lists[kL_COMMENTS]);
  257.             LAutoScroll(Lists[kL_COMMENTS]);
  258.             break;
  259.         case kMItem_Delete:
  260. //            LSetDrawingMode(false, Lists[kL_COMMENTS]);
  261.             for (scanPtr = gCsMemory; scanPtr < (gCsMemory + maxLLine[kL_COMMENTS]);
  262.                     tmpmir = *scanPtr++)
  263.                 if (tmpmir.bits.addr >= theSelection[kL_COMMENTS])
  264.                     if (tmpmir.bits.addr) {
  265.                         tmpmir.bits.addr--;
  266.                         *(scanPtr - 1) = tmpmir;
  267.                         }
  268.             for (scPtr = gAssMemory; scPtr < (gAssMemory + kSIZE_ASSMEM); val = *scPtr++)
  269.                 if (val > theSelection[kL_COMMENTS]) {
  270.                     val--;
  271.                     *(scPtr - 1) = val;
  272.                     }
  273.             SelectLLine(kL_COMMENTS, theSelection[kL_COMMENTS] + 1);
  274.             BlockMoveData(gCsMemory + theSelection[kL_COMMENTS],
  275.                 gCsMemory + theSelection[kL_COMMENTS] - 1,
  276.                 sizeof(union u_mir)*(maxLLine[kL_COMMENTS] - theSelection[kL_COMMENTS] + 1));
  277.             gCsMemory[maxLLine[kL_COMMENTS]].cstore = 0L;
  278.             LDelRow(1, --theSelection[kL_COMMENTS], Lists[kL_COMMENTS]);
  279.             LAddRow(1, maxLLine[kL_COMMENTS], Lists[kL_COMMENTS]);
  280.             DocumentIsDirty(true);
  281. //            LSetDrawingMode(true, Lists[kL_COMMENTS]);
  282.             LAutoScroll(Lists[kL_COMMENTS]);
  283.             break;
  284.         case kMItem_CopyBugReport:
  285.             CopyBugReportForm(nil);
  286.             UnloadSeg(CopyBugReportForm);
  287.             break;
  288.         case kMItem_CopyEmailAddr:
  289.             CopyEMailAddrToClip();
  290.             break;
  291.         case kMItem_SendEmail:
  292.             InternetLaunch(gICinst, &gICerr, myStdFilterProcNoCancel, myIdleFunct, kSTR_MAILTOURL);
  293.             break;
  294.         }
  295.     }
  296. }
  297.  
  298. void DoMenuWindows(short theItem)
  299. {
  300. register WindowPtr    wind;
  301.  
  302. switch (theItem) {
  303.     case kMItem_Animation:
  304.         wind = gWPtr_Animation;
  305.         break;
  306.     case kMItem_Registers:
  307.         wind = gWPtr_Registers;
  308.         break;
  309.     case kMItem_IO:
  310.         wind = gWPtr_IO;
  311.         break;
  312.     case kMItem_Microprogram:
  313.         PrepareOpenMicroprogram();
  314.         wind = gWPtr_Microprogram_Ed;
  315.         break;
  316.     case kMItem_Disasm:
  317.         wind = gWPtr_Disasm;
  318.         break;
  319.     case kMItem_Dump:
  320.         wind = gWPtr_Dump;
  321.         break;
  322.     }
  323. ShowWindowAndCheckMenu(wind, theItem);
  324. SelectWindow(wind);
  325. }
  326.  
  327. void ShowWindowAndCheckMenu(WindowPtr w, short theMenuItem)
  328. {
  329. if (((WindowPeek)w)->visible == false) {
  330.     CheckItem(gMenu_Windows, theMenuItem, true);
  331.     SetPort(w);
  332.     ShowWindow(w);
  333.     }
  334. }
  335.  
  336. void DoMenuMemory(short theItem)
  337. {
  338. register OSErr    err;
  339.  
  340. switch (theItem) {
  341.     case kMItem_Open: {
  342.         StandardFileReply    mySFR;
  343.         SFTypeList    myTypeList;
  344.  
  345.         myTypeList[0] = kFTY_RAM;
  346.         StandardGetFile(0L, 1, myTypeList, &mySFR);
  347.         if (mySFR.sfGood) {
  348.             if (err = myOpenFile(&mySFR.sfFile, gMMemory, kSIZE_RAM))
  349.                 ErrorAlert(err);
  350.             UnloadSeg(myOpenFile);
  351.             }
  352.         }
  353.         break;
  354.     case kMItem_Save_As:
  355.         if (err = mySaveFile(gMMemory, kSIZE_RAM, kFTY_RAM, kSTR_RAMPROMPT, kSTR_RAMDEFNAME))
  356.             ErrorAlert(err);
  357.         UnloadSeg(mySaveFile);
  358.         break;
  359.     }
  360. }
  361.  
  362. void    DoMenuRegs(short theItem)
  363. {
  364. OSErr    err;
  365.  
  366. switch (theItem) {
  367.     case kMItem_Open: {
  368.         StandardFileReply    mySFR;
  369.         SFTypeList    myTypeList;
  370.  
  371.         myTypeList[0] = kFTY_REG;
  372.         StandardGetFile(0L, 1, myTypeList, &mySFR);
  373.         if (mySFR.sfGood) {
  374.             if (err = OpenProcessorState(&mySFR.sfFile))
  375.                 ErrorAlert(err);
  376.             UnloadSeg(OpenProcessorState);
  377.             }
  378.         }
  379.         break;
  380.     case kMItem_Save_As:
  381.         if (err = SaveProcessorState())
  382.             ErrorAlert(err);
  383.         UnloadSeg(SaveProcessorState);
  384.         break;
  385.     }
  386. }
  387.  
  388. static void    DoMenuHDisasm(short theItem)
  389. {
  390. ScrollDisasmTo((unsigned short)gRegs[theItem - 1] >> 1);
  391. }
  392.  
  393. static void    DoMenuHDump(short theItem)
  394. {
  395. ScrollDumpTo((unsigned short)gRegs[theItem - 1] >> 3);
  396. }
  397.  
  398. void DoMenuControl(short theItem)
  399. {
  400. static const short toDeact[] = {    kP_MPC2INC, kP_INCR, kP_MPC2CST, kP_CST2MIR,
  401.                             kP_REG2LTCH1, kP_REG2LTCH2, kP_ALATCH, kP_BLATCH,
  402.                             kP_AMUX2ALU, kP_BLTCH2ALU, kP_ALU, kP_ALU2SH,
  403.                             kP_SHIFTER, kP_SH2REGS1, kP_SH2REGS2, kP_SH2REGS3,
  404.                             kP_MAR, kP_BLTCH2MAR1, kP_BLTCH2MAR2,
  405.                             kP_MBR, kP_SH2MBR1, kP_SH2MBR2, kP_MAP, kP_MAPREGS,
  406.                             kP_ALTCH2AMUX, kP_AMUX, kP_MBR2AMUX,
  407.                             kP_INC2MMUX1, kP_INC2MMUX2, kP_MMUX, kP_MPC,
  408.                             kC_ADDR1, kC_ADDR2, kP_MMUX2MPC, 0 };
  409.  
  410. OSErr    err;
  411.  
  412. switch (theItem) {
  413.     case kMItem_Go:
  414.         gRstatus = kST_GOING;
  415.         CompletePreviousInstruction();
  416.         sLastCommand = kST_GOING;
  417.         break;
  418.     case kMItem_Stop:
  419.         StopIt();
  420.         sLastCommand = kST_STOPPED;
  421.         break;
  422.     case kMItem_StepSub:
  423.         gRstatus = kST_STEPSUBCYC;
  424.         if (sLastCommand != kST_STEPSUBCYC) {
  425.             DeactivateObjs(toDeact);
  426.             sLastCommand = kST_STEPSUBCYC;
  427.             }
  428.         break;
  429.     case kMItem_StepMicro:
  430.         gRstatus = kST_STEPMPROG;
  431.         sLastCommand = kST_STEPMPROG;
  432.         break;
  433.     case kMItem_StepInstr:
  434.         gRstatus = kST_STEPASM;
  435.         CompletePreviousInstruction();
  436.         sLastCommand = kST_STEPASM;
  437.         break;
  438.     case kMItem_ResetMem:
  439.         if ((err = CautionAlert_UPP(kALRT_RESETMEM, myStdFilterProc)) == ok) {
  440.             MyZeroBuffer((long *)gMMemory, numOfLongs(kSIZE_RAM));
  441.             ResetMemory();
  442.             InvalDump();
  443.             InvalDisasm();
  444.             }
  445.         break;
  446.     case kMItem_ResetRegs:
  447.         if ((err = CautionAlert_UPP(kALRT_RESETREGS, myStdFilterProc)) == ok) {
  448.             ResetRegisters();
  449.             UnloadSeg(ResetRegisters);
  450.             ChangedRegister(kREG_PC);
  451.             ChangedRegister(kREG_SP);
  452.             ChangedBox(kP_MPC - kFIRST_PICT);
  453.             }
  454.         break;
  455.     case kMItem_SelectCurMPC:
  456.         SelectLLine(kL_COMMENTS, gParts[kP_MPC - kFIRST_PICT]);
  457.         DoMenuWindows(kMItem_Microprogram);
  458.         break;
  459.     }
  460. }
  461.  
  462. /* CompletePreviousInstruction: keeps in sync the processor when
  463. alternating different step modes with continuous execution */
  464.  
  465. static void CompletePreviousInstruction(void)
  466. {
  467. while (gSubclk) {
  468.     ExecuteInstructions(gSubclk++);
  469.     gSubclk &= 3;
  470.     }
  471. }
  472.  
  473. void DoMenuAssembler(short theItem)
  474. {
  475. OSErr    err;
  476.  
  477. switch (theItem) {
  478.     case kMItem_Assemble_file: {
  479.         StandardFileReply    mySFR;
  480.         SFTypeList    myTypeList;
  481.  
  482.         myTypeList[0] = 'TEXT';
  483.         StandardGetFile(0L, 1, myTypeList, &mySFR);
  484.         if (mySFR.sfGood) {
  485.             if (err = myAsmFile(&mySFR.sfFile))
  486.                 ErrorAlert(err);
  487.             UnloadSeg(myAsmFile);
  488.             }
  489.         }
  490.         break;
  491.     case kMItem_AsmPrefs:
  492.         DoAsmPrefsDialog();
  493.         UnloadSeg(DoAsmPrefsDialog);
  494.         break;
  495.     }
  496. }
  497.  
  498. void Handle_My_Menu(long myMenu)
  499. {
  500. short    theMenu, theItem;
  501.  
  502. theMenu = HiWrd(myMenu);
  503. if (theMenu) {
  504.     theItem = LoWrd(myMenu);
  505.     switch (theMenu) {
  506.         case kRes_Menu_HMemory:
  507.             DoMenuMemory(theItem);
  508.             break;
  509.         case kRes_Menu_HRegs:
  510.             DoMenuRegs(theItem);
  511.             break;
  512.         case kRes_Menu_HDisasm:
  513.             DoMenuHDisasm(theItem);
  514.             break;
  515.         case kRes_Menu_HDump:
  516.             DoMenuHDump(theItem);
  517.             break;
  518.         case kMENU_HCopyWebLocation:
  519.             CopyWWWURLToClip(theItem);
  520.             break;
  521.         case kMENU_HVisitWebLocation:
  522.             InternetLaunch(gICinst, &gICerr, myStdFilterProcNoCancel, myIdleFunct, kSTR_WWWURLHOME - 1 + theItem);
  523.             break;
  524.         case kRes_Menu_Apple:
  525.             DoMenuApple(theItem);
  526.             break;
  527.         case kRes_Menu_File:
  528.             DoMenuFile(theItem);
  529.             break;
  530.         case kRes_Menu_Edit:
  531.             DoMenuEdit(theItem);
  532.             break;
  533.         case kRes_Menu_Windows:
  534.             DoMenuWindows(theItem);
  535.             break;
  536.         case kRes_Menu_Control:
  537.             DoMenuControl(theItem);
  538.             break;
  539.         case kRes_Menu_Assembler:
  540.             DoMenuAssembler(theItem);
  541.             break;
  542.         }
  543.     }
  544. HiliteMenu(0);
  545. }
  546.  
  547. #endif
  548.  
  549.