home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format 77 / af077sub.adf / MUIMENU / MUImenu.lzx / MUIMenu / Source / MUIMenu.c < prev   
Encoding:
C/C++ Source or Header  |  1994-03-02  |  19.0 KB  |  991 lines
  1. /*
  2. **
  3. **                MUI-Menu v.1.00
  4. **
  5. **              By Giuseppe Chiesa 1994 Milano
  6. **
  7. **            E-Mail: chieg@ghost.sm.dsi.unimi.it
  8. **
  9. **        Dedicated to my aunt Ada ...
  10. **
  11. **            Hope you're happier now
  12. **            surely we're more lonely now
  13. **
  14. */
  15.  
  16. /*
  17. **    Features:
  18. **
  19. **    - Dynamic Button Creation ( till 12rows x 4cols Buttons )
  20. **    - Edit Capabilities
  21. **    - Save Data
  22. **    - Editable Config File ( Not Fully Implemented )
  23. **    - Synch or ASynch Execution
  24. **    - MUI facilities ( Great ! )
  25. **    - Parameters Specification
  26. **    - .AmigaGuide DocFile
  27. **    - Keyboard Short-Cuts
  28. **
  29. */
  30.  
  31. /*
  32. **    Future:
  33. **
  34. **    - Maybe a better button positioning for new columns buttons
  35. **        ( Not just some centered elements but on the same
  36. **          rows of the first ones followed by empty buttons )
  37. **    - ...
  38. **
  39. */
  40.  
  41. /*
  42. **
  43. **    Idea, Program Design and Code by Giuseppe Chiesa aka ~Lizard~
  44. **
  45. **    E-Mail : chieg@ghost.sm.dsi.unimi.it
  46. **
  47. **    Original Idea and Program ( DBLMenu ) by Claudio Fuse' aka ~DBL~
  48. **
  49. */
  50.  
  51. #include <exec/types.h>
  52. #include <exec/memory.h>
  53. #include "code.h"
  54. #include <stdio.h>
  55. #include <stdlib.h>
  56. #include <string.h>
  57.  
  58. /* Some definitons */
  59.  
  60. #define _MAX_ITCHARS 16
  61. #define _MAX_PRGCHARS 32
  62. #define _MAX_PARMSCHARS 48
  63.  
  64. #define _MAX_TXTCHARS 24
  65.  
  66. #define _MAX_ROWS 12
  67. #define _MAX_COLS 4
  68. #define _MAX_ELEMENTS _MAX_ROWS * _MAX_COLS
  69.  
  70. #define _QUIT_ID 60
  71. #define _SAVE_ID 61
  72. #define _ADD_ID 62
  73. #define _DEL_ID 63
  74. #define _CHANGE_ID 64
  75. #define _ABOUT_ID 65
  76. #define _OK_ID 66
  77. #define _CANCEL_ID 67
  78. #define _HIDE_ID 68
  79. #define _LAUNCH_ID 70
  80.  
  81. /* Function Declarations - End */
  82.  
  83. void PutTxt( UBYTE * );
  84. BOOL GetVGroup( ULONG );
  85. BOOL AddFunc( void );
  86. BOOL LoadFunc( void );
  87. BOOL SaveFunc( void );
  88. BOOL CleanUpMem( void );
  89. BOOL GetBuffer( FILE * , UBYTE * );
  90.  
  91. /* Function Declaration - End */
  92.  
  93.  
  94.  
  95. /* Global Variables - Begin */
  96.  
  97. /* About Text */
  98.  
  99. UBYTE *Thxtxt="\33c\33bMUI Menu 1.00\33n\n\n\
  100. \33cProgram By\n\33b\33cGiuseppe Chiesa\
  101. \33n\n\n\33cE-Mail: chieg@ghost.sm.dsi.unimi.it\
  102. \n\n\33cMilano-Italy 1994\n\n\33cThanks to\n\n\
  103. \33c\33bFrency\n\33cArturo & Norma\n\n\33n\33c\
  104. Dedicated To\n\n\33c\33bAda\33n\
  105. \n\n\33cGreetings to\n\n\33c\33bClaudio and Furio\33n";
  106.  
  107.  
  108. /*
  109.  
  110.   Typical Item Body
  111.  
  112.     item = Item Name : will be displaied as button text
  113.  
  114.     prog = Program Name : will be executed when item button is pressed
  115.  
  116.     parms = Parameters : If present will follow program as its parms
  117.  
  118.     pos = Array position : used to write and read with Notify Mechanism
  119.  
  120.     async = Asynchronous execution : If TRUE program will be executed
  121.         asynchronously and MGTools will not wait for it to finish
  122.  
  123. */
  124.  
  125. struct element
  126. {
  127. UBYTE *item;
  128. UBYTE *prog;
  129. UBYTE *parms;
  130. ULONG pos;
  131. ULONG async;
  132. };
  133.  
  134. /* Array with all possible elements */
  135.  
  136. struct element els[ _MAX_ELEMENTS ];
  137.  
  138. ULONG pos[ _MAX_ELEMENTS ];
  139.  
  140. /* Array with all possible element buttons and key short-cuts */
  141.  
  142. APTR buttons[ _MAX_ELEMENTS ];
  143. APTR labbuts[ _MAX_ELEMENTS ];
  144. UBYTE keys[ _MAX_ELEMENTS ][2];
  145.  
  146. /* Link struct between main prog and Adder function */
  147.  
  148. struct element transit;
  149.  
  150. /* itnum = Current item number ( last one created ) <= _MAX_ELEMENTS - 1 */
  151.  
  152. ULONG    itnum=0;
  153.  
  154. /* Current VertGroup address */
  155.  
  156. APTR addVgroup,V1,V2,V3,V4;
  157.  
  158. /* Application, Window and Text_Object Address */
  159.  
  160. APTR app,window,txtobj ;
  161.  
  162. /* running Bool, numb ULONG for selecting button and buf for PutTxt func
  163.     Add_Button, Del_Button and Change_Button addresses */
  164.  
  165. BOOL running = TRUE;
  166. ULONG numb=-1;
  167. APTR addbut,delbut,changebut;
  168. UBYTE *infile="S:MUIMenu.data\0";
  169. UBYTE *buf;
  170.  
  171. /* change global flag for changing data function */
  172.  
  173. BOOL change=FALSE;
  174.  
  175. /* Global Variables - End */
  176.  
  177.  
  178.  
  179. /* Function Bodies - Begin */
  180.  
  181.  
  182. /* Writes in txtobj some text formatted to _MAX_TXTCHARS */
  183.  
  184. void PutTxt( UBYTE *txto )
  185. {
  186.  
  187. int i;
  188. BOOL intxt=TRUE;
  189.  
  190. for(i=0; i<=_MAX_TXTCHARS;i++)
  191. {
  192.     if(txto[i]=='\0')
  193.         intxt=FALSE;
  194.  
  195.     if(intxt)
  196.         buf[i]=txto[i];
  197.     else
  198.         buf[i]=' ';
  199. }
  200.  
  201. buf[i]='\0';
  202.  
  203. set(txtobj,MUIA_Text_Contents,buf);
  204.  
  205. }
  206.  
  207. /* Get data function returns FALSE if EOF found */
  208.  
  209. BOOL GetBuffer( FILE *fil, UBYTE *buff)
  210. {
  211.  
  212. int i,c;
  213.  
  214. for(i=0;( c=fgetc(fil) )!='\n' && c!=EOF ; i++)
  215.     buff[i]=c;
  216.  
  217.     buff[i]='\0';
  218.  
  219. if(c=='\n')
  220.     return(TRUE);
  221. else
  222.     return(FALSE);
  223. }
  224.  
  225.  
  226. /* This Function creates a new button and attaches it to the correct VGroup
  227.    For this reason and for enabling add, del and text buttons I had to use
  228.    app, window, addbut, delbut, txtbut addresses and running & numb as
  229.    global variables */
  230.  
  231. BOOL AddButtFunc( void )
  232. {
  233.  
  234.     if( itnum < 26 )
  235.         keys[itnum][0]='b'+itnum;
  236.     else
  237.         keys[itnum][0]='A'+itnum-25;
  238.  
  239.     keys[itnum][1]='\0';
  240.  
  241.     buttons[ itnum ]=\
  242.     HGroup,
  243.     Child,    labbuts[itnum]=TextObject,
  244.         ButtonFrame,
  245.         MUIA_Text_Contents, transit.item,
  246.         MUIA_Text_PreParse, "\33c",
  247.         MUIA_InputMode    , MUIV_InputMode_RelVerify,
  248.         MUIA_Background   , MUII_ButtonBack,
  249.         End,
  250.  
  251.     Child,    TextObject,
  252.         ButtonFrame,
  253.         MUIA_FixWidthTxt,    "A",
  254.         MUIA_Text_Contents, &((keys[itnum])[0]),
  255.         MUIA_Text_PreParse, "\33c",
  256.         MUIA_ControlChar  , keys[itnum][0],
  257.         MUIA_InputMode    , MUIV_InputMode_RelVerify,
  258.         MUIA_Background   , MUII_ButtonBack,
  259.         End,
  260.     End;
  261.     
  262.  
  263.     if(buttons[ itnum ])
  264.         {
  265.     DoMethod(addVgroup,OM_ADDMEMBER,buttons[ itnum ]);
  266.     DoMethod(buttons[itnum],MUIM_Notify,MUIA_Pressed,FALSE,
  267.     app,2,MUIM_Application_ReturnID,_LAUNCH_ID);
  268.  
  269.     strcpy(els[ itnum ].item,transit.item);
  270.     strcpy(els[ itnum ].prog,transit.prog);
  271.     strcpy(els[ itnum ].parms,transit.parms);
  272.     els[ itnum ].async=transit.async;
  273.     els[itnum].pos=itnum;
  274.  
  275.     DoMethod(buttons[itnum],MUIM_Notify,MUIA_Pressed,FALSE,
  276.     buttons[itnum],3,MUIM_WriteLong,els[itnum].pos,&numb);
  277.     PutTxt("Item Added...");
  278.  
  279.     itnum++;
  280.  
  281.     set(delbut,MUIA_Disabled,FALSE);
  282.     set(changebut,MUIA_Disabled,FALSE);
  283.  
  284.     if( itnum == _MAX_ELEMENTS )
  285.         set(addbut,MUIA_Disabled,TRUE);
  286.     
  287.     } /* button created */
  288.     else
  289.         {
  290.         fail(app,NULL);
  291.         running=FALSE;
  292.         }
  293.  
  294.     if(buttons[itnum-1])
  295.     return(TRUE);
  296.     else
  297.     return(FALSE);
  298. }
  299.  
  300.  
  301. /* Gets Button VGroup Address and shows VGroup until
  302.     ~number~ button in rows of 12 elements */
  303.  
  304. BOOL GetVGroup( ULONG number )
  305. {
  306.  
  307.     ldiv_t calc ;
  308.  
  309.     calc = ldiv(number,_MAX_ROWS);
  310.     switch(calc.quot)
  311.     {
  312.         case 0:
  313.         addVgroup=V1;
  314.         set(V1,MUIA_ShowMe,TRUE);
  315.         set(V2,MUIA_ShowMe,FALSE);
  316.         set(V3,MUIA_ShowMe,FALSE);
  317.         set(V4,MUIA_ShowMe,FALSE);
  318.         break;
  319.  
  320.         case 1:
  321.         addVgroup=V2;
  322.         set(V1,MUIA_ShowMe,TRUE);
  323.         set(V2,MUIA_ShowMe,TRUE);
  324.         set(V3,MUIA_ShowMe,FALSE);
  325.         set(V4,MUIA_ShowMe,FALSE);
  326.         break;
  327.  
  328.         case 2:
  329.         addVgroup=V3;
  330.         set(V1,MUIA_ShowMe,TRUE);
  331.         set(V2,MUIA_ShowMe,TRUE);
  332.         set(V3,MUIA_ShowMe,TRUE);
  333.         set(V4,MUIA_ShowMe,FALSE);
  334.         break;
  335.  
  336.         case 3:
  337.         addVgroup=V4;
  338.         set(V1,MUIA_ShowMe,TRUE);
  339.         set(V2,MUIA_ShowMe,TRUE);
  340.         set(V3,MUIA_ShowMe,TRUE);
  341.         set(V4,MUIA_ShowMe,TRUE);
  342.         break;
  343.     }
  344.  
  345.  
  346. return(TRUE);
  347. }
  348.  
  349.  
  350. /* Allocs Memory for new Button Data */
  351.  
  352. BOOL AddFunc( void )
  353. {
  354.  
  355.     if(!change)
  356.     {
  357.     if(itnum < _MAX_ELEMENTS )
  358.     {
  359.     GetVGroup(itnum);
  360.  
  361.     els[itnum].item=(UBYTE *)AllocMem(sizeof(UBYTE)*_MAX_ITCHARS , MEMF_CLEAR);
  362.     els[itnum].prog=(UBYTE *)AllocMem(sizeof(UBYTE)*_MAX_PRGCHARS , MEMF_CLEAR);
  363.     els[itnum].parms=(UBYTE *)AllocMem(sizeof(UBYTE)*_MAX_PARMSCHARS , MEMF_CLEAR);
  364.     return( TRUE );
  365.     }
  366.     else
  367.     return(FALSE);
  368.     }
  369.  
  370. }
  371.  
  372. /* Load Data Function */
  373.  
  374. BOOL LoadFunc( void )
  375. {
  376.  
  377. FILE *in;
  378. char *buffer;
  379.  
  380. BOOL ok=FALSE ,er=FALSE;
  381. BOOL itempres=FALSE;
  382. BOOL okiload=FALSE;
  383.  
  384. buffer=(char *) AllocMem(50*sizeof(char),MEMF_PUBLIC|MEMF_CLEAR);
  385.  
  386. in=fopen(infile,"r");
  387.     if(!in)
  388.     {
  389.     er=TRUE;
  390.     PutTxt("Data File Not Found");
  391.     } /* File Not Found */
  392.  
  393.     if(in)
  394.     {
  395.     okiload=GetBuffer(in,buffer);
  396.     if(strcmp(buffer,"MUIMenu Data File")==0 && okiload  )
  397.     ok=TRUE;
  398.     }
  399.  
  400.     while(ok)
  401.         {
  402.     okiload=GetBuffer(in,buffer);
  403.  
  404.  
  405.     itempres=FALSE;
  406.     if(strcmp(buffer,"ITEM")==0 && okiload)
  407.     itempres=TRUE;
  408.  
  409.     if(itempres)
  410.     {
  411.     okiload=GetBuffer(in,buffer);
  412.     if(okiload)
  413.     {
  414.     strcpy(transit.item,buffer);
  415.     okiload=GetBuffer(in,buffer);
  416.     if(okiload)    
  417.         {
  418.     strcpy(transit.prog,buffer);
  419.     okiload=GetBuffer(in,buffer);
  420.     if(okiload)
  421.             {
  422.     strcpy(transit.parms,buffer);
  423.     okiload=GetBuffer(in,buffer);
  424.     if(okiload)
  425.                 {
  426.     transit.async=atol(buffer);
  427.  
  428.     change=FALSE;
  429.     if(AddFunc())
  430.         AddButtFunc();
  431.                 }
  432.                 else
  433.                 ok=FALSE;
  434.             }
  435.             else
  436.             ok=FALSE;
  437.         }
  438.         else
  439.         ok=FALSE;
  440.     }
  441.     else
  442.     ok=FALSE;
  443.  
  444.     if(!ok)
  445.     er=TRUE;    /* if ok gets FALSE here there's an error so exit */
  446.  
  447.  
  448.     } /* ITEM ok */
  449.  
  450.  
  451.     if(!itempres)
  452.     {
  453.  
  454.     if(strcmp(buffer,"END MUIMenu")==0 && okiload )
  455.     ok=FALSE; /* END ok */
  456.     else
  457.     {
  458.     er=TRUE;
  459.     ok=FALSE;
  460.     } /* END not ok */
  461.  
  462.     }
  463.  
  464.     } /* ok while */
  465.  
  466.     if(in)
  467.     {
  468.     fclose(in);
  469.     if(!er)
  470.     PutTxt("Data Loaded...");
  471.     else
  472.     PutTxt("Data File Error");
  473.     } /* File Found */
  474.  
  475. FreeMem(buffer,50*sizeof(char));
  476.  
  477. return( TRUE );
  478. }
  479.  
  480. /* Save Data Function */
  481.  
  482. BOOL SaveFunc( void )
  483. {
  484.  
  485.  
  486. FILE *out;
  487. char *buffer;
  488.  
  489. int it;
  490.  
  491. buffer=(char *) AllocMem(50*sizeof(char),MEMF_PUBLIC|MEMF_CLEAR);
  492.  
  493. out=fopen(infile,"w");
  494.     if(!out)
  495.     {
  496.     PutTxt("Output File not opened");
  497.     } /* File Not Found */
  498.     else
  499.     {
  500.     fprintf(out,"MUIMenu Data File\n");
  501.     for(it=0;it<itnum;it++)
  502.     {
  503.     fprintf(out,"ITEM\n");
  504.     fprintf(out,"%s\n",els[it].item);
  505.     fprintf(out,"%s\n",els[it].prog);
  506.     fprintf(out,"%s\n",els[it].parms);
  507.     fprintf(out,"%ld\n",els[it].async);
  508.     }
  509.     fprintf(out,"END MUIMenu\n");
  510.  
  511.     if(out)
  512.     fclose(out);
  513.     }
  514.  
  515. FreeMem(buffer,50*sizeof(char));
  516.  
  517. return( TRUE );
  518. }
  519.  
  520. /* Frees all data previously allocated by AddFunc */
  521.  
  522. BOOL CleanUpMem( void )
  523. {
  524.     ULONG act;
  525.  
  526.     for(act=0;act=itnum || !els[act].item ;act++)
  527.         {
  528.         FreeMem(els[ act ].item,sizeof(UBYTE)*_MAX_ITCHARS);
  529.         FreeMem(els[ act ].prog,sizeof(UBYTE)*_MAX_PRGCHARS);
  530.         FreeMem(els[ act ].parms,sizeof(UBYTE)*_MAX_PARMSCHARS);
  531.         }
  532.  
  533. return(TRUE);
  534. }
  535.  
  536. /* Function Bodies - End */
  537.  
  538.  
  539.  
  540.  
  541. /* Main function */
  542.  
  543. int main(int argc,char *argv[])
  544. {
  545.  
  546.     struct DiskObject    *DObj;
  547.     APTR savebut,quitbut,aboutbut;
  548.  
  549.     /* Add Item Window and Child objects */
  550.     APTR addwin,itemobj,prgobj,parmobj,asyncobj,chkobj,okbut,cancbut;
  551.     ULONG signals;
  552.  
  553.     /* Shall contain prog name and following parms */
  554.     UBYTE *launcher;
  555.  
  556.     BOOL tosave = FALSE ;
  557.  
  558.     /* Change flag and item to change */
  559.     ULONG chnum=0;
  560.  
  561.     BOOL deletion=FALSE;
  562.     ULONG delnum=0;
  563.  
  564.     BOOL saveadvert=FALSE;
  565.  
  566.  
  567.     launcher=(UBYTE*)AllocMem(sizeof(UBYTE)*(_MAX_PRGCHARS+_MAX_PARMSCHARS+1),
  568.         MEMF_CLEAR);
  569.  
  570.     buf=(UBYTE *)AllocMem(sizeof(UBYTE)*(_MAX_TXTCHARS + 1), MEMF_CLEAR );
  571.  
  572.     transit.item=(UBYTE *)AllocMem(sizeof(UBYTE)*_MAX_ITCHARS , MEMF_CLEAR);
  573.     transit.prog=(UBYTE *)AllocMem(sizeof(UBYTE)*_MAX_PRGCHARS , MEMF_CLEAR);
  574.     transit.parms=(UBYTE *)AllocMem(sizeof(UBYTE)*_MAX_PARMSCHARS , MEMF_CLEAR);
  575.  
  576.  
  577.     init();
  578.  
  579.     app = ApplicationObject,
  580.         MUIA_Application_Title      , "MUIMenu",
  581.         MUIA_Application_Version    , "VER$: Version 1.00 by G. Chiesa",
  582.         MUIA_Application_Copyright  , "©1994 Giuseppe Chiesa",
  583.         MUIA_Application_Author     , "Giuseppe Chiesa",
  584.         MUIA_Application_Description, "MUI Pop Up Menu for tools execution",
  585.         MUIA_Application_Base       , "MUIMENU",
  586.  
  587.         MUIA_Application_SingleTask,     TRUE,
  588.         MUIA_Application_DiskObject,    DObj=GetDiskObjectNew("PROGDIR:MUIMenu"),
  589.         MUIA_HelpFile,            "MUIMenu.guide",
  590.  
  591.         SubWindow, window = WindowObject,
  592.             MUIA_Window_Title, "MUIMenu",
  593.             MUIA_Window_ID   , MAKE_ID('M','U','M','N'),
  594.  
  595.             MUIA_HelpNode,    "Usage",
  596.  
  597.             WindowContents,VGroup,
  598.  
  599.             MUIA_Frame,        MUIV_Frame_Group,
  600.             MUIA_FrameTitle,    "MUI-Menu 1.00",
  601.  
  602.             Child,        HGroup,
  603.             MUIA_Group_SameSize,    TRUE,
  604.             Child,    V1=VGroup, End,
  605.             Child,    V2=VGroup, End,
  606.             Child,    V3=VGroup, End,
  607.             Child,    V4=VGroup, End,
  608.                     End,
  609.  
  610.             Child,    VSpace(2),
  611.  
  612.             Child,        VGroup,
  613.             Child,    ColGroup(2),
  614.                 MUIA_Group_SameSize,    TRUE,
  615.                 Child,    addbut=KeyButton("ADD",'a'),
  616.                 Child,    delbut=SimpleButton("DELETE"),
  617.  
  618.                 Child,  changebut=SimpleButton("CHANGE"),
  619.                 Child,    aboutbut=SimpleButton("ABOUT"),
  620.  
  621.                 Child,    savebut=SimpleButton("SAVE"),
  622.                 Child,    quitbut=SimpleButton("QUIT"),
  623.                 MUIA_HelpNode,    "EditButtons",
  624.  
  625.                 End,
  626.  
  627.             Child,    HGroup,
  628.                 Child,    Label("Info:"),
  629.                 Child,    txtobj=TextObject,
  630.                 TextFrame,
  631.                 MUIA_Text_Contents,    "",
  632.                 End,
  633.             End,
  634.                 
  635.                 End,
  636.  
  637.                     End,
  638.             End,
  639.  
  640.         SubWindow, addwin=WindowObject,
  641.             MUIA_Window_Title, "Add Item",
  642.             MUIA_Window_ID,    MAKE_ID('A','D','D','T'),
  643.  
  644.             MUIA_HelpNode,    "EditWindow",
  645.  
  646.             WindowContents,    VGroup,
  647.  
  648.             Child,    ColGroup(2),    
  649.  
  650.                 Child,    KeyLabel2("Item Name:",'i'),
  651.                 Child,    itemobj=KeyString("",_MAX_ITCHARS,'i'),
  652.  
  653.                 Child,    KeyLabel2("File Name:",'f'),
  654.                 Child,    prgobj=PopaslObject,
  655.                     MUIA_Popstring_String,KeyString("",_MAX_PRGCHARS,'f'),
  656.                     MUIA_Popstring_Button, PopButton(MUII_PopFile),
  657.                     ASLFR_TitleText, "Please select a file...",
  658.                     End,
  659.  
  660.                 Child,    KeyLabel2("Prg Parms:",'p'),
  661.                 Child,    parmobj=KeyString("",_MAX_PARMSCHARS,'p'),
  662.  
  663.                 Child,    HSpace(80),
  664.                 Child,    HSpace(128),
  665.  
  666.                 End,
  667.  
  668.             Child,    HGroup,
  669.  
  670.                 Child,    asyncobj=KeyLabel("Async:",'a'),
  671.                 Child,    chkobj=CheckMark( TRUE ),
  672.                     MUIA_HelpNode,    "SyncVSAsync",
  673.             End,
  674.  
  675.             Child,    HGroup,
  676.                 MUIA_Group_SameSize,    TRUE,
  677.                 Child,    okbut=KeyButton("OK",'o'),
  678.                 MUIA_HelpNode,    "EditWindow",
  679.                 MUIA_HelpLine,    10,
  680.                 Child,    cancbut=KeyButton("Cancel",'c'),
  681.                 MUIA_HelpNode,    "EditWindow",
  682.                 MUIA_HelpLine,    18,
  683.             End,
  684.                     End,
  685.             End,
  686.  
  687.         End;
  688.  
  689.     if (!app)
  690.         fail(app,"Failed to create Application.");
  691.  
  692.     DoMethod(window,MUIM_Notify,MUIA_Window_CloseRequest,TRUE,
  693.         app,2,MUIM_Application_ReturnID,_HIDE_ID);
  694.  
  695.     DoMethod(quitbut,MUIM_Notify,MUIA_Pressed,FALSE,
  696.         app,2,MUIM_Application_ReturnID,MUIV_Application_ReturnID_Quit);
  697.  
  698.     DoMethod(savebut,MUIM_Notify,MUIA_Pressed,FALSE,
  699.         app,2,MUIM_Application_ReturnID,_SAVE_ID);
  700.  
  701.     DoMethod(addbut,MUIM_Notify,MUIA_Pressed,FALSE,
  702.         app,2,MUIM_Application_ReturnID,_ADD_ID);
  703.  
  704.     DoMethod(delbut,MUIM_Notify,MUIA_Pressed,FALSE,
  705.         app,2,MUIM_Application_ReturnID,_DEL_ID);
  706.  
  707.     DoMethod(changebut,MUIM_Notify,MUIA_Pressed,FALSE,
  708.         app,2,MUIM_Application_ReturnID,_CHANGE_ID);
  709.  
  710.     DoMethod(aboutbut,MUIM_Notify,MUIA_Pressed,FALSE,
  711.         app,2,MUIM_Application_ReturnID,_ABOUT_ID);
  712.  
  713.     DoMethod(okbut,MUIM_Notify,MUIA_Pressed,FALSE,
  714.         app,2,MUIM_Application_ReturnID,_OK_ID);
  715.  
  716.     DoMethod(cancbut,MUIM_Notify,MUIA_Pressed,FALSE,
  717.         app,2,MUIM_Application_ReturnID,_CANCEL_ID);
  718.  
  719.  
  720.     DoMethod(window,MUIM_Window_SetCycleChain,
  721.         addbut,delbut,changebut,aboutbut,savebut,quitbut,NULL);
  722.  
  723.     DoMethod(addwin,MUIM_Window_SetCycleChain,
  724.         itemobj,prgobj,parmobj,chkobj,okbut,cancbut,NULL);
  725.  
  726.  
  727. /*
  728. ** Input loop...
  729. */
  730.     set(V1,MUIA_ShowMe,FALSE);
  731.     set(V2,MUIA_ShowMe,FALSE);
  732.     set(V3,MUIA_ShowMe,FALSE);
  733.     set(V4,MUIA_ShowMe,FALSE);
  734.  
  735.     LoadFunc();
  736.  
  737.     if(itnum==0)
  738.         {
  739.         set(delbut,MUIA_Disabled,TRUE);
  740.         set(changebut,MUIA_Disabled,TRUE);
  741.         }
  742.  
  743.     set(window,MUIA_Window_Open,TRUE);
  744.  
  745.     while (running)
  746.     {
  747.         switch (DoMethod(app,MUIM_Application_Input,&signals))
  748.         {
  749.  
  750.             case _HIDE_ID:
  751.                 set(app,MUIA_Application_Iconified, TRUE);
  752.                 break;
  753.  
  754.             case MUIV_Application_ReturnID_Quit:
  755.                 if(tosave)
  756.                 {
  757.                 if(!saveadvert)
  758.                 {
  759.                 PutTxt("Data Changed SAVE First");
  760.                 saveadvert=TRUE;
  761.                 }
  762.                 else
  763.                 {
  764.                 PutTxt("QUIT without SAVING");
  765.                 Delay(50);            
  766.                 running = FALSE;
  767.                 }
  768.                 }
  769.                 else
  770.                 {
  771.                 running = FALSE;
  772.                 }
  773.                 break;
  774.  
  775.             case _ABOUT_ID:
  776.             if(deletion || change)
  777.             {
  778.             saveadvert=FALSE;
  779.             deletion=FALSE;
  780.             change=FALSE;
  781.             PutTxt("Action Cancelled");
  782.             }
  783.             else
  784.             MUI_RequestA(app,window,0,NULL,"_Thanx",Thxtxt,NULL);
  785.                 break;
  786.  
  787.             case _SAVE_ID:
  788.                 SaveFunc();
  789.                 PutTxt("Data Saved...");
  790.                 tosave=FALSE;
  791.                 saveadvert=FALSE;
  792.                 break;
  793.  
  794.             case _ADD_ID:
  795.                 saveadvert=FALSE;
  796.                 change=FALSE;
  797.                 if(itnum < _MAX_ELEMENTS)
  798.                 {
  799.                 set(itemobj,MUIA_String_Contents,"");
  800.                 set(prgobj,MUIA_String_Contents,"");
  801.                 set(parmobj,MUIA_String_Contents,"");
  802.                 set(chkobj,MUIA_Selected,TRUE);
  803.  
  804.                 set(addwin,MUIA_Window_Open,TRUE);
  805.                 }
  806.                 break;
  807.  
  808.             case _OK_ID:
  809.  
  810.             PutTxt("");
  811.             get(itemobj,MUIA_String_Contents,&transit.item);
  812.             get(prgobj,MUIA_String_Contents,&transit.prog);
  813.             get(parmobj,MUIA_String_Contents,&transit.parms);
  814.             get(chkobj,MUIA_Selected,&transit.async);
  815.  
  816.             set(addwin,MUIA_Window_Open,FALSE);
  817.  
  818.             if(AddFunc())
  819.             {
  820.             tosave=TRUE;
  821.             set(window,MUIA_Window_Open,FALSE);
  822.  
  823.             if(!change)
  824.             AddButtFunc();     /* !change */
  825.             else
  826.             {    
  827.             strcpy(els[ chnum ].item,transit.item);
  828.             strcpy(els[ chnum ].prog,transit.prog);
  829.             strcpy(els[ chnum ].parms,transit.parms);
  830.             els[ chnum ].async=transit.async;
  831.             set(labbuts[chnum],MUIA_Text_Contents,transit.item);
  832.             PutTxt("Item Changed...");
  833.             } /* change */
  834.     
  835.             set(window,MUIA_Window_LeftEdge,MUIV_Window_LeftEdge_Centered);
  836.  
  837.             set(window,MUIA_Window_Open,TRUE);
  838.  
  839.             set(window,MUIA_Window_Activate,TRUE);
  840.  
  841.             } /* AddFunc */
  842.             else
  843.             {    
  844.             PutTxt("No More Space Sorry...");        
  845.             } /* !AddFunc */
  846.  
  847.             change=FALSE;
  848.                 break;
  849.  
  850.             case _CANCEL_ID:
  851.             set(addwin,MUIA_Window_Open,FALSE);
  852.             set(window,MUIA_Window_Activate,TRUE);
  853.             change=FALSE;
  854.  
  855.                 break;
  856.  
  857.             case _DEL_ID:
  858.             if(itnum>0)
  859.             {
  860.             deletion=TRUE;
  861.             PutTxt("Delete - ABOUT Cancel");
  862.             }
  863.             else
  864.             {
  865.         /* Unuseful : Del button gets Disabled when itnum = 0 */
  866.             PutTxt("No Item to Delete");
  867.             deletion=FALSE;
  868.             }
  869.                 break;
  870.  
  871.             case _CHANGE_ID:
  872.             if(itnum>0)
  873.             {
  874.             change=TRUE;
  875.             PutTxt("Change - ABOUT Cancel");
  876.             }
  877.             else
  878.             {
  879.         /* Unuseful : Change button gets Disabled when itnum = 0 */
  880.             PutTxt("No Item to Change");
  881.             change=FALSE;
  882.             }
  883.                 break;
  884.  
  885.             case _LAUNCH_ID:
  886.  
  887.             /* Thanks to Notify capibility numb has already
  888.                been filled with the correct item number */ 
  889.  
  890.             saveadvert=FALSE;
  891.  
  892.             if(!change && !deletion)
  893.             {    
  894.             if(els[numb].async==1L)
  895.                 strcpy(launcher,"C:Run >nil: <nil: ");
  896.             else if(els[numb].async==0L)
  897.                 strcpy(launcher,(UBYTE *)"\0");
  898.  
  899.             strcat(launcher,els[numb].prog);
  900.             strcat(launcher,(UBYTE *)" \0");
  901.             strcat(launcher,els[numb].parms);
  902.  
  903.             if(strcmp(els[numb].prog,"")!=0)
  904.             system(launcher);
  905.             }
  906.  
  907.             if(change)
  908.             {
  909.             PutTxt("");
  910.             chnum=numb;
  911.             set(itemobj,MUIA_String_Contents,els[chnum].item);
  912.             set(prgobj,MUIA_String_Contents,els[chnum].prog);
  913.             set(parmobj,MUIA_String_Contents,els[chnum].parms);
  914.             set(chkobj,MUIA_Selected,els[chnum].async);
  915.             set(addwin,MUIA_Window_Open,TRUE);
  916.             PutTxt("Item Changed...");
  917.             tosave=TRUE;
  918.             }
  919.  
  920.             if(deletion)
  921.             {
  922.             PutTxt("");
  923.             delnum=numb;
  924.             set(window,MUIA_Window_Open,FALSE);
  925.             GetVGroup(numb);
  926.             itnum--;
  927.             if(delnum!=itnum)
  928.             {
  929.             strcpy(els[ delnum ].item,els[ itnum ].item);
  930.             strcpy(els[ delnum ].prog,els[ itnum ].prog);
  931.             strcpy(els[ delnum ].parms,els[ itnum ].parms);
  932.             els[ delnum ].async=els[ itnum ].async;
  933.         set(labbuts[delnum],MUIA_Text_Contents,els[itnum].item);
  934.             }
  935.              DoMethod(addVgroup,OM_REMMEMBER,buttons[itnum]);
  936.             MUI_DisposeObject(buttons[itnum]);
  937.         FreeMem(els[itnum].item,sizeof(UBYTE)*_MAX_ITCHARS);
  938.         FreeMem(els[itnum].prog,sizeof(UBYTE)*_MAX_PRGCHARS);
  939.         FreeMem(els[itnum].parms,sizeof(UBYTE)*_MAX_PARMSCHARS);
  940.             GetVGroup(itnum-1);
  941.             set(window,MUIA_Window_LeftEdge,MUIV_Window_LeftEdge_Centered);
  942.             set(window,MUIA_Window_Open,TRUE);
  943.             if(itnum<_MAX_ELEMENTS)
  944.                 set(addbut,MUIA_Disabled,FALSE);
  945.             tosave=TRUE;
  946.             deletion=FALSE;
  947.             if(itnum==0)
  948.             {
  949.             set(delbut,MUIA_Disabled,TRUE);
  950.             set(changebut,MUIA_Disabled,TRUE);
  951.             }
  952.  
  953.             }
  954.                 break;
  955.  
  956.         }
  957.         if (running && signals) Wait(signals);
  958.  
  959.     }
  960.  
  961.     set(window,MUIA_Window_Open,FALSE);
  962.  
  963.  
  964. /*
  965. ** Shut down...
  966. */
  967.  
  968.     if(app)
  969.     fail(app,NULL);
  970.  
  971.     CleanUpMem();
  972.  
  973.     if(transit.item)
  974.     FreeMem(transit.item,sizeof(UBYTE)* _MAX_ITCHARS );
  975.     if(transit.prog)
  976.     FreeMem(transit.prog,sizeof(UBYTE)* _MAX_PRGCHARS );
  977.     if(transit.parms)
  978.     FreeMem(transit.parms,sizeof(UBYTE)* _MAX_PARMSCHARS );
  979.  
  980.     if(buf)
  981.     FreeMem(buf,sizeof(UBYTE)*(_MAX_TXTCHARS + 1));
  982.  
  983.     if(launcher)
  984.     FreeMem(launcher,sizeof(UBYTE)*(_MAX_PRGCHARS+_MAX_PARMSCHARS+1) );
  985.  
  986.     if(DObj)
  987.     FreeDiskObject(DObj);
  988.  
  989. }
  990.  
  991. /* End of MUIMenu */