home *** CD-ROM | disk | FTP | other *** search
/ The CDPD Public Domain Collection for CDTV 2 / CDPD_II_2352.bin / scope / 151-175 / scopedisk159 / parmenu / parm.c < prev    next >
C/C++ Source or Header  |  1992-10-27  |  11KB  |  474 lines
  1. /*
  2.  *    ParM.c - Copyright © 1990 by S.R. & P.C.
  3.  *
  4.  *    Created:    01 Jul 1990
  5.  *    Modified:    01 Jul 1990
  6.  *
  7.  *    Make>> make
  8.  */
  9.  
  10. /*
  11. #define DO_ARP_COPIES
  12. #include <exec/memory.h>
  13. #include <libraries/arpbase.h>
  14. #include <libraries/dosextens.h>
  15. #include <intuition/intuition.h>
  16. #include <intuition/intuitionbase.h>
  17. #include <workbench/workbench.h>
  18. #include <workbench/startup.h>
  19. #include <functions.h>
  20. #include <arp_pragmas.h>
  21. */
  22.  
  23. #include <dos_functions.h>
  24. #include <arpdos_pragmas.h>
  25. #include <arp_ports.h>
  26. #include "ParM.h"
  27.  
  28. #define THE_END        0
  29. #define NO_ARP        1
  30. #define NO_ICON        2
  31. #define NO_WIN        3
  32. #define NO_REQ        4
  33. #define NO_PORT        5
  34.  
  35. #define OWN_MENU    0
  36.  
  37. #define OPEN_ITEM        0
  38. #define UPDATE_ITEM        1
  39. #define COMMAND_ITEM    2
  40. #define CHDIR_ITEM        3
  41. #define QUIT_ITEM        4
  42.  
  43. const char *COPYRIGHT =  "ParM V1.1 Copyright © 1990 by S.R. & P.C.";
  44.  
  45. extern void Command(void);
  46. extern BOOL ParseMenus( void );
  47. extern void FreeMenus( void );
  48. extern void DoExtMenu( USHORT );
  49. extern void WBFree( struct WBStartup * );
  50.  
  51. /*****                global functions                    *****/
  52.  
  53. void Warn( const char * );
  54.  
  55. /*****                global variables                    *****/
  56.  
  57. extern struct IntuitionBase *IntuitionBase;
  58. extern struct GfxBase *GfxBase;
  59. extern struct ArpBase *ArpBase;
  60. extern struct IconBase *IconBase;    /* already defined in manx startup */
  61. extern struct WBStartup *WBenchMsg;    /* defined in manx startup */
  62. extern struct Process *MyProcess;
  63. extern struct Window *Win;
  64. extern struct Menu Menu1;
  65. extern UBYTE menu_pen;
  66. extern char CurCfg[];
  67. extern char CmdWindow[];
  68. extern struct MsgPort *WBReplyPort;
  69. extern short WBCnt;
  70. extern int Enable_Abort;    /* manx startup variable */
  71.  
  72.  
  73. /*****                 local variables                    *****/
  74.  
  75. static struct FileRequester *FileReq;
  76. static BOOL Own_Window = FALSE;
  77. static BOOL quit = FALSE;
  78. static BYTE ParMenuColor = -1;
  79.  
  80.  
  81. struct ToolTypesArg {
  82.     char *tta_Name;
  83.     char tta_cli_equ;
  84. };
  85.  
  86. static struct ToolTypesArg TTA_List[] = {
  87.     { "LEFTEDGE"    , 'x' },
  88.     { "TOPEDGE"        , 'y' },
  89.     { "DETAILPEN"    , 'd' },
  90.     { "BLOCKPEN"    , 'b' },
  91.     { "MENUCOLOR"    , 'c' },
  92.     { "CONFIGFILE"    , 'f' }
  93. };
  94.  
  95. #define TTANUM    6    /* Number of ToolTypesArg in List */
  96.  
  97.  
  98. static char *ErrorTab[] = {
  99.     NULL,
  100.     "You need arp.library V39+",
  101.     "No icon.library !",
  102.     "Can't Open Window",
  103.     "Not enough memory",
  104. };
  105.  
  106. static struct NewWindow NWS = {
  107.     0,0,    /* window XY origin relative to TopLeft of screen */
  108.     90,10,    /* window width and height */
  109.     3,2,    /* detail and block pens */
  110.     MENUPICK,    /* IDCMP flags */
  111.     WINDOWDRAG+WINDOWDEPTH+SIMPLE_REFRESH+NOCAREREFRESH,    /* other window flags */
  112.     NULL,    /* first gadget in gadget list */
  113.     NULL,    /* custom CHECKMARK imagery */
  114.     (UBYTE *)PRG_NAME,    /* window title */
  115.     NULL,    /* custom screen pointer */
  116.     NULL,    /* custom bitmap */
  117.     5,5,    /* minimum width and height */
  118.     -1,-1,    /* maximum width and height */
  119.     WBENCHSCREEN    /* destination screen type */
  120. };
  121.  
  122. /**************************************************/
  123. /************   Warn Requester Data   *************/
  124. /**************************************************/
  125.  
  126. static struct IntuiText BodyText = {
  127.     2,1,JAM1,    /* front and back text pens, drawmode and fill byte */
  128.     14,8,        /* XY origin relative to container TopLeft */
  129.     NULL,        /* font pointer or NULL for default */
  130.     NULL,        /* pointer to text */
  131.     NULL        /* next IntuiText structure */
  132. };
  133.  
  134.  
  135. static struct IntuiText OkText = {
  136.     2,1,JAM1,
  137.     6,3,
  138.     NULL,
  139.     (UBYTE *)"Ok",
  140.     NULL
  141. };
  142.  
  143.  
  144. static struct IntuiText CancelText = {
  145.     2,1,JAM1,    /* front and back text pens, drawmode and fill byte */
  146.     6,3,        /* XY origin relative to container TopLeft */
  147.     NULL,        /* font pointer or NULL for default */
  148.     (UBYTE *)"Cancel",    /* pointer to text */
  149.     NULL        /* next IntuiText structure */
  150. };
  151.  
  152.  
  153. void Warn( const char *text )
  154. {
  155.     static char buf[60];
  156.  
  157.     SPrintf( buf , "%s: %s" , PRG_NAME , text );
  158.     BodyText.IText = (UBYTE *)buf;
  159.     AutoRequest(NULL,&BodyText,NULL,&CancelText,NULL,NULL,60+IntuiTextLength(&BodyText),54);
  160. }
  161.  
  162. static BOOL Confirm( const char *text )
  163. {
  164.     BodyText.IText = (UBYTE *)text;
  165.     return AutoRequest(NULL,&BodyText,&OkText,&CancelText,NULL,NULL,60+IntuiTextLength(&BodyText),54);
  166. }
  167.  
  168. /***** get CLI window ptr *****/
  169.  
  170. static struct Window *GetWindow( void )
  171. {
  172.     struct InfoData *infodata;
  173.     struct Window *win;
  174.     long args[8];
  175.  
  176.     infodata=AllocMem((long)sizeof(struct InfoData),MEMF_CLEAR | MEMF_PUBLIC);
  177.     args[0]=(long)infodata >> 2;
  178.     SendPacket(ACTION_DISK_INFO,args,(struct MsgPort *)MyProcess->pr_ConsoleTask);
  179.     win=(struct Window *)infodata->id_VolumeNode;
  180.     FreeMem(infodata,(long)sizeof(struct InfoData));
  181.     return win;
  182. }
  183.  
  184.  
  185. /*    Configuration managing functions  */
  186.  
  187. static void InstallMenus( void )
  188. {
  189.     if( ! ParseMenus() ) FreeMenus();
  190.     SetMenuStrip( Win , &Menu1 );
  191.     return;
  192. }
  193.  
  194. static void UpDateMenus( void )
  195. {
  196.     ClearMenuStrip( Win );
  197.     FreeMenus();
  198.     InstallMenus();
  199. }
  200.  
  201. static void OpenMenus( void )
  202. {
  203.     char *yuck;
  204.  
  205.     FileReq->fr_Hail = "Open";
  206.     strcpy( FileReq->fr_Dir , CurCfg );
  207.     strcpy( FileReq->fr_File , yuck=BaseName(FileReq->fr_Dir) );
  208.     *yuck = '\0';    /* cut off filename from fr_Dir */
  209.     if( ! FileRequest(FileReq) ) return;    /* quit if Open canceled */
  210.     strcpy( CurCfg , FileReq->fr_Dir );
  211.     TackOn( CurCfg , FileReq->fr_File );
  212.     UpDateMenus();
  213. }
  214.  
  215. static void SetMenFgCol( UBYTE color ) /* set other Front Pen when attached to CLI */
  216. {
  217.     struct MenuItem *mi;
  218.     struct IntuiText *it;
  219.  
  220.     menu_pen = color;
  221.     for( mi=Menu1.FirstItem ; mi ; mi=mi->NextItem )
  222.         for( it=(struct IntuiText *)mi->ItemFill ; it ; it=it->NextText )
  223.             it->FrontPen = color;
  224. }
  225.  
  226.  
  227. /*    Print busy message in place of window title  */
  228.  
  229. static void Busy( BOOL status )
  230. {
  231.     char *Msg;
  232.  
  233.     if( status ) 
  234.         Msg = "Busy";
  235.     else
  236.         Msg = PRG_NAME;
  237.     SetWindowTitles( Win , Msg , COPYRIGHT );
  238. }
  239.  
  240.  
  241. static void Usage( void )
  242. {
  243.     Printf("%s\n",COPYRIGHT);
  244.     Printf("Usage: %s [-w] [-x#] [-y#] [-d#] [-b#] [-c#] [-fConfigFile]\n",PRG_NAME);
  245.     CloseLibrary( IconBase );
  246.     CloseLibrary( ArpBase );
  247.     exit(0);
  248. }
  249.  
  250.  
  251. /*    Atcho, bonsoir...  */
  252.  
  253. static void Bye(short err)
  254. {
  255.     switch( err ) {
  256.     case THE_END :
  257.         ClearMenuStrip( Win );
  258.         FreeMenus();
  259.         DeletePort( WBReplyPort );
  260.     case NO_PORT :
  261.         if( Own_Window == TRUE )
  262.             CloseWindowSafely(Win,NULL);
  263.         else
  264.             ModifyIDCMP( Win , Win->IDCMPFlags & ~MENUPICK );
  265.     case NO_WIN :
  266.     case NO_REQ :
  267.         CloseLibrary( IconBase );
  268.     case NO_ICON :
  269.         CloseLibrary( ArpBase );
  270.     case NO_ARP :
  271.         ;
  272.     }
  273.     if(err) Warn( ErrorTab[(err>3)?4:err] );
  274.     exit(err);
  275. }
  276.  
  277.  
  278. /*    handle workbench replies  */
  279.  
  280. static void DoWBMsg( void )
  281. {
  282.     WBCnt--;
  283.     WBFree( (struct WBStartup *)GetMsg(WBReplyPort) );
  284. }
  285.  
  286.  
  287. /*    handle IntuiMessages  */
  288.  
  289. static void DoIntuiMsg( void )
  290. {
  291.     struct IntuiMessage *Message;
  292.     ULONG Class;
  293.     USHORT Code;
  294.     BPTR NewLock,OldLock;
  295.     BOOL DoNextSelect;
  296.  
  297.     while( Message = (struct IntuiMessage *) GetMsg(Win->UserPort) ) {
  298.         Class = Message->Class;
  299.         Code = Message->Code;
  300.         ReplyMsg( (struct Message *)Message );
  301.         switch( Class ) {
  302.         case MENUPICK :
  303.             DoNextSelect = TRUE;
  304.             if( Code != MENUNULL ) do {
  305.                 switch( MENUNUM( Code ) ) {     
  306.                 case OWN_MENU :
  307.                     switch( ITEMNUM( Code ) ) {
  308.                     case OPEN_ITEM :
  309.                         OpenMenus();
  310.                         DoNextSelect = FALSE;
  311.                         break;
  312.                     case UPDATE_ITEM :
  313.                         UpDateMenus();
  314.                         DoNextSelect = FALSE;
  315.                         break;
  316.                     case COMMAND_ITEM :
  317.                         Command();
  318.                         break;
  319.                     case CHDIR_ITEM :
  320.                         FileReq->fr_Dir[0] = '\0';    /* futur plans: build path string */
  321.                         FileReq->fr_File[0] = '\0';
  322.                         FileReq->fr_Hail = "Enter New Dir...";
  323.                         if( FileRequest(FileReq) ) {
  324.                             NewLock = Lock( FileReq->fr_Dir , ACCESS_READ );
  325.                               if( NewLock != NULL ) {
  326.                                 OldLock = CurrentDir((struct FileLock *)NewLock);
  327.                                 if( OldLock != NULL ) UnLock(OldLock);
  328.                             }
  329.                         }
  330.                         break;
  331.                     case QUIT_ITEM :
  332.                         if( WBCnt == 0 ) {
  333.                             if( Confirm("Really Quit ParM ?") ) {
  334.                                 quit = TRUE;
  335.                                 DoNextSelect = FALSE;
  336.                             }
  337.                         } else
  338.                             Warn("WorkBench Processes Still Active");
  339.                         break;
  340.                     }
  341.                     break;
  342.                 default :    /* custom menus */
  343.                     DoExtMenu( Code );
  344.                 }
  345.             } while( DoNextSelect && (Code=ItemAddress(&Menu1,Code)->NextSelect) != MENUNULL );
  346.             break;
  347.         default :
  348.             ;    /* we only manage MENUPICK events */
  349.         }
  350.     }
  351. }
  352.  
  353.  
  354. static BOOL PortNotEmpty( struct MsgPort *P )
  355. {
  356.     return ( P->mp_MsgList.lh_Head->ln_Succ ) ? TRUE : FALSE;
  357. }
  358.  
  359.  
  360. static void parse_arg( char opt , char *args )
  361. {
  362.     long argl;
  363.  
  364.     argl = Atol( args );
  365.     switch( opt ) {
  366.     case 'w' :
  367.         Own_Window = TRUE;
  368.         break;
  369.     case 'x' :
  370.         NWS.LeftEdge = argl;
  371.         Own_Window = TRUE;
  372.         break;
  373.     case 'y' :
  374.         NWS.TopEdge = argl;
  375.         Own_Window = TRUE;
  376.         break;
  377.     case 'd' :
  378.         NWS.DetailPen = argl;
  379.         Own_Window = TRUE;
  380.         break;
  381.     case 'b' :
  382.         NWS.BlockPen = argl;
  383.         Own_Window = TRUE;
  384.         break;
  385.     case 'c' :
  386.         ParMenuColor = argl;
  387.         break;
  388.     case 'f' :
  389.         strcpy( CurCfg , args );
  390.         break;
  391.     case 'h' :    /* those can only happen on CLI invocation */
  392.     default :
  393.         Usage();
  394.     }
  395. }
  396.  
  397.  
  398. int main(int argc, char *argv[])
  399. {
  400.     ULONG Mask,WBRPMask,WinMask;
  401.     struct DiskObject *dop;
  402.     char *arg;
  403.     SHORT i;
  404.  
  405.     Enable_Abort = 0;    /* disable ^C break */
  406.     if( !(ArpBase = (struct ArpBase *)OpenLibrary("arp.library",39L)) ) Bye(NO_ARP);
  407.     IntuitionBase = (struct IntuitionBase *)ArpBase->IntuiBase;
  408.     GfxBase = (struct GfxBase *)ArpBase->GfxBase;
  409.     if( !(IconBase = (struct IconBase *)OpenLibrary("icon.library",0L)) ) Bye(NO_ICON);
  410.     if( !(FileReq = ArpAllocFreq()) ) Bye(NO_REQ);
  411.     MyProcess = (struct Process *)FindTask(0L);
  412.     strcpy(CurCfg, DEFAULT_CONFIG_FILE);
  413.     strcpy(CmdWindow ,DEFAULT_CMD_WINDOW);
  414.  
  415.     if( argc == 0 ) {    /* Tool Types parsing */
  416.         Own_Window = TRUE;
  417.         if( dop = GetDiskObject(WBenchMsg->sm_ArgList->wa_Name) ) {
  418.             for( i=0 ; i<TTANUM ; i++ ) {        
  419.                 if( arg = FindToolType( dop->do_ToolTypes, TTA_List[i].tta_Name) )
  420.                     parse_arg( TTA_List[i].tta_cli_equ , arg );
  421.             }
  422.             FreeDiskObject(dop);
  423.         }
  424.     } else {    /* CLI parsing */
  425.         for( i=1 ; i<argc ; i++ ) {
  426.             if( argv[i][0] != '-' || strlen(argv[i]) < 2 ) Usage();
  427.             parse_arg( argv[i][1] , &argv[i][2] );
  428.         }
  429.     }
  430.     if( Own_Window == TRUE ) {
  431.         if( !(Win = OpenWindow(&NWS)) ) Bye(NO_WIN);
  432.         Busy( FALSE );
  433.     } else {
  434.         Win = GetWindow();
  435.         if( Win->IDCMPFlags & MENUPICK ) {
  436.             Warn("This window already have menus!");
  437.             CloseLibrary( IconBase );
  438.             CloseLibrary( ArpBase );
  439.             exit(0);
  440.         } else
  441.             ModifyIDCMP( Win , Win->IDCMPFlags | MENUPICK );
  442.     }
  443.     if( ParMenuColor < 0 )
  444.         SetMenFgCol( Win->DetailPen ); /* default FgPen for main menu */
  445.     else
  446.         SetMenFgCol( ParMenuColor );
  447.     FileReq->fr_Window = Win;
  448.     if( !(WBReplyPort = CreatePort(NULL,NULL)) ) Bye(NO_PORT);
  449.     WBRPMask = 1L << WBReplyPort->mp_SigBit;
  450.     WinMask = 1L << Win->UserPort->mp_SigBit;
  451.     InstallMenus();
  452.  
  453.     /* Monitor Menu Events */
  454.  
  455.     while( !quit ) {
  456.         /* Wait only if no messages are queued up at any port */
  457.         while( PortNotEmpty(WBReplyPort) || PortNotEmpty(Win->UserPort) ) {
  458.             if( PortNotEmpty(WBReplyPort) )
  459.                 DoWBMsg();
  460.             else
  461.                 DoIntuiMsg();
  462.         }
  463.         if( Own_Window ) Busy( FALSE );
  464.         Mask = Wait( WinMask | WBRPMask );
  465.         if( Own_Window ) Busy( TRUE );
  466.         if( Mask == WBRPMask )
  467.             DoWBMsg();
  468.         else
  469.             DoIntuiMsg();
  470.     }
  471.     Bye(THE_END);
  472. }
  473.  
  474.