home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 1 / GoldFishApril1994_CD2.img / d4xx / d419 / parm / parm.c < prev    next >
C/C++ Source or Header  |  1990-12-18  |  11KB  |  464 lines
  1. /*
  2.  *    ParM.c - Copyright © 1990 by S.R. & P.C.
  3.  *
  4.  *    Created:    01 Jul 1990
  5.  *    Modified:    09 Dec 1990  17:39:57
  6.  *
  7.  *    Make>> make
  8.  */
  9.  
  10. #include "WB.h"
  11.  
  12. #define COPYRIGHT "ParM V2.5r Copyright © 1990 by S.R. & P.C."
  13. #define DEFAULT_CONFIG_FILE "S:ParM.cfg"
  14.  
  15. #define DEFAULT_CMD_WINDOW        "CON:0/11/640/100/Command window"
  16. #define DEFAULT_SHELL_WINDOW    "CON:0/11/640/100/ParM Shell"
  17. #define DEFAULT_SHELL_CMD        "AShell"
  18. #define DEFAULT_WAIT_CMD        "WaitReturn"
  19. #define DEFAULT_TMP_DIR            "T:"
  20.  
  21. #define THE_END            0
  22. #define NO_ICON            1
  23. #define NO_REQ            2
  24. #define NO_WIN            3
  25. #define NO_MENUS        4    /* This definition MUST be duplicated in MenuAlloc.c */
  26. #define NO_PORT            5
  27.  
  28. #define OWN_MENU        0
  29.  
  30. #define OPEN_ITEM        0
  31. #define UPDATE_ITEM        1
  32. #define STD_CFG_ITEM    2
  33. #define CMDMODE_ITEM    3
  34. #define COMMAND_ITEM    4
  35. #define CHDIR_ITEM        5
  36. #define QUIT_ITEM        6
  37.  
  38.  
  39. extern void Command(void);
  40. extern BOOL ParseMenus(void);
  41. extern void FreeMenus(void);
  42. extern void InitMenuAlloc(void);
  43. extern void CreateParMenu(short Color);
  44. extern void DoExtMenu(USHORT);
  45. extern void WBFree(struct WBStartup *);
  46.  
  47.  
  48. /*****                global variables                    *****/
  49.  
  50. extern struct ExecBase *SysBase;
  51. extern struct IntuitionBase *IntuitionBase;
  52. extern struct GfxBase *GfxBase;
  53. extern struct ArpBase *ArpBase;
  54. extern struct IconBase *IconBase;
  55. extern struct ReqLib *ReqBase;
  56. extern struct Process *MyProcess;
  57. extern long DefaultStack;
  58. extern char *ReqTitle;
  59. extern struct WBStartup *WBenchMsg;
  60. extern struct Window *Win;
  61. extern struct Menu Menu1;
  62. extern char CurCfg[];
  63. extern char CmdWindow[];
  64. extern char ShellWindow[];
  65. extern char ShellCmd[];
  66. extern char WaitCmd[];
  67. extern char TmpDir[];
  68. extern struct ParmMsgPort *ParMPort;
  69. extern UBYTE menu_pen;
  70. extern BOOL DoNextSelect;
  71.  
  72.  
  73. /*****                 local variables                    *****/
  74.  
  75. static BOOL Own_Window = FALSE;
  76. static BOOL quit = FALSE;
  77. static BYTE ParMenuColor = -1;
  78. static struct FileReq FileReq;
  79. static char Dir[REQ_DSIZE+1];
  80. static char File[REQ_FCHARS+1];
  81. static char Path[REQ_DSIZE+REQ_FCHARS+2];
  82.  
  83. struct ToolTypesArg {
  84.     char *tta_Name;
  85.     char tta_cli_equ;
  86. };
  87.  
  88. static struct ToolTypesArg TTA_List[] = {
  89.     {"STACKSIZE",    's'},
  90.     {"LEFTEDGE",    'x'},
  91.     {"TOPEDGE",        'y'},
  92.     {"DETAILPEN",    'd'},
  93.     {"BLOCKPEN",    'b'},
  94.     {"MENUCOLOR",    'c'},
  95.     {"CONFIGFILE",    'f'},
  96.     {"NODRAGBAR",    'r'},
  97.     {"LITTLE",        'l'}
  98. };
  99.  
  100. #define TTANUM    8    /* Number of ToolTypesArg in List */
  101.  
  102.  
  103. static struct NewWindow NWS = {
  104.     0, 0,    /* window XY origin relative to TopLeft of screen */
  105.     90, 10,    /* window width and height */
  106.     3, 2,    /* detail and block pens */
  107.     MENUPICK,    /* IDCMP flags */
  108.     WINDOWDRAG + WINDOWDEPTH + SIMPLE_REFRESH + NOCAREREFRESH,    /* other window flags */
  109.     NULL,    /* first gadget in gadget list */
  110.     NULL,    /* custom CHECKMARK imagery */
  111.     (UBYTE *)"ParM",    /* window title */
  112.     NULL,    /* custom screen pointer */
  113.     NULL,    /* custom bitmap */
  114.     5, 5,    /* minimum width and height */
  115.     -1, -1,    /* maximum width and height */
  116.     WBENCHSCREEN    /* destination screen type */
  117. };
  118.  
  119.  
  120. /*****  make (and allocate) a copy of the passed string *****/
  121.  
  122. char *copystr(char *str)
  123. {
  124.     char *newstr;
  125.     if (newstr = AllocMem(strlen(str)+1, MEMF_PUBLIC))
  126.         strcpy(newstr, str);
  127.     return newstr;
  128. }
  129.  
  130.  
  131. /***** get CLI window ptr *****/
  132.  
  133. static struct Window *GetWindow(void)
  134. {
  135.     struct InfoData *infodata;
  136.     struct Window *win;
  137.     long args[8];
  138.  
  139.     infodata = AllocMem((long) sizeof(struct InfoData), MEMF_CLEAR | MEMF_PUBLIC);
  140.     args[0] = (long)infodata >> 2;
  141.     SendPacket(ACTION_DISK_INFO, args, (struct MsgPort *)MyProcess->pr_ConsoleTask);
  142.     win = (struct Window *)infodata->id_VolumeNode;
  143.     FreeMem(infodata, (long)sizeof(struct InfoData));
  144.     return win;
  145. }
  146.  
  147.  
  148. /* Configuration managing functions  */
  149.  
  150. static void InstallMenus(void)
  151. {
  152.     menu_pen = ParMenuColor;
  153.     if (!ParseMenus())
  154.         FreeMenus();
  155.     SetMenuStrip(Win, &Menu1);
  156. }
  157.  
  158. void UpDateMenus(void)
  159. {
  160.     ClearMenuStrip(Win);
  161.     InstallMenus();
  162. }
  163.  
  164. static void OpenMenus(void)
  165. {
  166.     char *yuck;
  167.  
  168.     FileReq.Title = "Open";
  169.     strcpy(Dir, CurCfg);
  170.     strcpy(File, yuck = BaseName(Dir));
  171.     *yuck = '\0';        /* cut off filename from fr_Dir */
  172.     if (!FileRequester(&FileReq))
  173.         return;    /* quit if Open canceled */
  174.     strcpy(CurCfg, Path);
  175.     UpDateMenus();
  176. }
  177.  
  178.  
  179. /* Print busy message in place of window title  */
  180.  
  181. static void Busy(BOOL status)
  182. {
  183.     SetWindowTitles(Win, (status)?"Busy":"ParM", COPYRIGHT);
  184. }
  185.  
  186.  
  187. static void Usage(void)
  188. {
  189.     Printf("%s\nUsage: %s [-w] [-x#] [-y#] [-d#] [-b#] [-c#] [-r] [-l] [-s#] [-o] [-fConfigFile]\n", COPYRIGHT, "ParM");
  190.     ArpExit(0, 0);
  191. }
  192.  
  193.  
  194. /* Atcho, bonsoir...  */
  195.  
  196. void Bye(short err)
  197. {
  198.     char *name;
  199.  
  200.     switch (err) {
  201.     case THE_END:
  202.         ClearMenuStrip(Win);
  203.     case NO_MENUS:
  204.         FreeMenus();
  205.         Forbid();
  206.         if (ParMPort->pmp_NumParmTask == 1 && ParMPort->pmp_MsgCnt == 0) {
  207.             RemPort((struct MsgPort *)ParMPort);
  208.             name = ParMPort->pmp_MsgPort.mp_Node.ln_Name;
  209.             FreeMem(name, strlen(name));
  210.             FreeMem(ParMPort, sizeof(struct ParmMsgPort));
  211.         }
  212.         else
  213.             ParMPort->pmp_NumParmTask--;
  214.         Permit();
  215.     case NO_PORT:
  216.         if (Own_Window == TRUE)
  217.             CloseWindowSafely(Win, NULL);
  218.         else
  219.             ModifyIDCMP(Win, 0);
  220.     }
  221.     ArpExit(err, 0L);
  222. }
  223.  
  224.  
  225. /* change parm current directory */
  226.  
  227. static void ChangeDir(char *dir)
  228. {
  229.     BPTR NewLock, OldLock;
  230.  
  231.     NewLock = Lock(dir, ACCESS_READ);
  232.     if (NewLock != NULL) {
  233.         OldLock = CurrentDir(NewLock);
  234.         if (OldLock != NULL)
  235.             UnLock(OldLock);
  236.     }
  237. }
  238.  
  239.  
  240. static void parse_arg(char opt, char *args)
  241. {
  242.     BPTR fh;
  243.     long argl;
  244.  
  245.     argl = Atol(args);
  246.     switch (opt) {
  247.     case 'w':
  248.         Own_Window = TRUE;
  249.         break;
  250.     case 's':
  251.         if (argl >= 4000) DefaultStack = argl;
  252.         break;
  253.     case 'x':
  254.         NWS.LeftEdge = argl;
  255.         Own_Window = TRUE;
  256.         break;
  257.     case 'y':
  258.         NWS.TopEdge = argl;
  259.         Own_Window = TRUE;
  260.         break;
  261.     case 'd':
  262.         NWS.DetailPen = argl;
  263.         Own_Window = TRUE;
  264.         break;
  265.     case 'b':
  266.         NWS.BlockPen = argl;
  267.         Own_Window = TRUE;
  268.         break;
  269.     case 'c':
  270.         ParMenuColor = argl;
  271.         break;
  272.     case 'f':
  273.         strcpy(CurCfg, args);
  274.         break;
  275.     case 'r':    /* no drag bar */
  276.         Own_Window = TRUE;
  277.         NWS.Flags &= ~WINDOWDRAG;
  278.         break;
  279.     case 'l':    /* 'l' for Little window: no depth gadget */
  280.         Own_Window = TRUE;
  281.         NWS.Flags &= ~WINDOWDEPTH;
  282.         NWS.Width -= 51;
  283.         break;
  284.     case 'o':
  285.         if (fh = Open("NIL:", MODE_NEWFILE)) {
  286.             MyProcess->pr_CIS = fh;
  287.             MyProcess->pr_COS = fh;
  288.         }
  289.         break;
  290.     case 'h':    /* those can only happen on CLI invocation */
  291.     default:
  292.         Usage();
  293.     }
  294. }
  295.  
  296.  
  297. void main(int argc, char *argv[])
  298. {
  299.     struct CommandLineInterface *cli;
  300.     struct WBStartup *Msg;
  301.     struct DiskObject *dop;
  302.     struct IntuiMessage *Message;
  303.     ULONG Class;
  304.     USHORT Code;
  305.     char *arg;
  306.     short i;
  307.  
  308.     IntuitionBase = (struct IntuitionBase *)ArpBase->IntuiBase;
  309.     GfxBase = (struct GfxBase *)ArpBase->GfxBase;
  310.     if (!(IconBase = (struct IconBase *)ArpOpenLibrary("icon.library", 0L))) {
  311.         Printf("No icon.library!\n");
  312.         Bye(NO_ICON);
  313.     }
  314.     if (!(ReqBase = (struct ReqLib *)ArpOpenLibrary("req.library", 1L))) {
  315.         Printf("No req.library!\n");
  316.         Bye(NO_REQ);
  317.     }
  318.     FileReq.Dir = Dir;
  319.     FileReq.File = File;
  320.     FileReq.PathName = Path;
  321.     FileReq.dirnamescolor = 3;
  322.     FileReq.devicenamescolor = 3;
  323.     FileReq.stringnamecolor = 2;
  324.     FileReq.stringgadgetcolor = 2;
  325.     FileReq.boxbordercolor = 2;
  326.     FileReq.gadgetboxcolor = 2;
  327.     strcpy(FileReq.Show, "*.cfg");
  328.     MyProcess = (struct Process *)SysBase->ThisTask;
  329.     strcpy(CurCfg, DEFAULT_CONFIG_FILE);
  330.  
  331.     if (argc == 0) {    /* Tool Types parsing */
  332.         Own_Window = TRUE;
  333.         if (dop = GetDiskObject(WBenchMsg->sm_ArgList->wa_Name)) {
  334.             DefaultStack = dop->do_StackSize;
  335.             for (i = 0; i < TTANUM; i++) {
  336.                 if (arg = FindToolType(dop->do_ToolTypes, TTA_List[i].tta_Name))
  337.                     parse_arg(TTA_List[i].tta_cli_equ, arg);
  338.             }
  339.             FreeDiskObject(dop);
  340.         }
  341.     }
  342.     else {    /* CLI parsing */
  343.         cli = (struct CommandLineInterface *)((long)MyProcess->pr_CLI << 2);
  344.         DefaultStack = cli->cli_DefaultStack << 2;
  345.         for (i = 1; i < argc; i++) {
  346.             if (*argv[i] != '-' || strlen(argv[i]) < 2)
  347.                 Usage();
  348.             parse_arg(argv[i][1], &argv[i][2]);
  349.         }
  350.     }
  351.     if (Own_Window == TRUE) {
  352.         if (!(Win = OpenWindow(&NWS)))
  353.             Bye(NO_WIN);
  354.         Busy(FALSE);    /* SetWindowTitles() */
  355.     }
  356.     else {
  357.         Win = GetWindow();
  358.         if (Win->UserPort) {
  359.             SimpleRequest(ReqTitle, "This window already have menus!");
  360.             ArpExit(0, 0);
  361.         }
  362.         else
  363.             ModifyIDCMP(Win, MENUPICK|CLOSEWINDOW);
  364.     }
  365.     if (ParMenuColor < 0) ParMenuColor = Win->DetailPen;
  366.     CreateParMenu(ParMenuColor);
  367.     Forbid();
  368.     if (!(ParMPort = (struct ParmMsgPort *)FindPort("ParM_Port"))) {
  369.         if (!(ParMPort = AllocMem(sizeof(struct ParmMsgPort), MEMF_CLEAR|MEMF_PUBLIC)))
  370.             Bye(NO_PORT);
  371.         ParMPort->pmp_MsgPort.mp_Node.ln_Name = copystr("ParM_Port");
  372.         ParMPort->pmp_MsgPort.mp_Node.ln_Type = NT_MSGPORT;
  373.         ParMPort->pmp_MsgPort.mp_Flags = PA_IGNORE;
  374.         AddPort((struct MsgPort *)ParMPort); /* also init the msg list */
  375.         ParMPort->pmp_NumParmTask = 1;
  376.     }
  377.     else
  378.         ParMPort->pmp_NumParmTask++;
  379.     Permit();
  380.     strcpy(CmdWindow, DEFAULT_CMD_WINDOW);
  381.     strcpy(ShellWindow, DEFAULT_SHELL_WINDOW);
  382.     strcpy(ShellCmd, DEFAULT_SHELL_CMD);
  383.     strcpy(WaitCmd, DEFAULT_WAIT_CMD);
  384.     strcpy(TmpDir, DEFAULT_TMP_DIR);
  385.     InitMenuAlloc();
  386.     InstallMenus();
  387.  
  388.     /* Monitor Menu Events */
  389.  
  390.     while (!quit) {
  391.         WaitPort(Win->UserPort);
  392.         while (Message = (struct IntuiMessage *)GetMsg(Win->UserPort)) {
  393.             Class = Message->Class;
  394.             Code = Message->Code;
  395.             ReplyMsg((struct Message *) Message);
  396.             switch (Class) {
  397.             case 0x0FL:        /* Msg sent bye 'ParMCD' command */
  398.                 ChangeDir((char *)Message->IAddress);
  399.                 break;
  400.             case CLOSEWINDOW:
  401.                 quit = TRUE;
  402.                 break;
  403.             case MENUPICK:
  404.                 DoNextSelect = TRUE;
  405.                 if (Code != MENUNULL) {
  406.                     if (Own_Window)
  407.                         Busy(TRUE);
  408.                     do {
  409.                         switch(MENUNUM(Code)) {
  410.                         case OWN_MENU:
  411.                             switch(ITEMNUM(Code)) {
  412.                             case OPEN_ITEM:
  413.                                 OpenMenus();
  414.                                 DoNextSelect = FALSE;
  415.                                 break;
  416.                             case UPDATE_ITEM:
  417.                                 UpDateMenus();
  418.                                 DoNextSelect = FALSE;
  419.                                 break;
  420.                             case STD_CFG_ITEM:
  421.                                 strcpy(CurCfg, DEFAULT_CONFIG_FILE);
  422.                                 UpDateMenus();
  423.                                 DoNextSelect = FALSE;
  424.                                 break;
  425.                             case COMMAND_ITEM:
  426.                                 Command();
  427.                                 break;
  428.                             case CHDIR_ITEM:
  429.                                 PathName(MyProcess->pr_CurrentDir, Dir, REQ_DSIZE);
  430.                                 FileReq.Flags = FRQDIRONLYM;
  431.                                 FileReq.Title = "Enter New Dir...";
  432.                                 if (FileRequester(&FileReq))
  433.                                     ChangeDir(Dir);
  434.                                 FileReq.Flags = 0;
  435.                                 break;
  436.                             case QUIT_ITEM:
  437.                                 if( TwoGadRequest(ReqTitle, "Really Quit ParM ?") ) {
  438.                                     quit = TRUE;
  439.                                     DoNextSelect = FALSE;
  440.                                 }
  441.                             }
  442.                             break;
  443.                         default:    /* custom menus */
  444.                             DoExtMenu(Code);
  445.                         }
  446.                     } while (DoNextSelect && (Code = ItemAddress(&Menu1, Code)->NextSelect) != MENUNULL);
  447.                     if (Own_Window)
  448.                         Busy(FALSE);
  449.                 }
  450.                 break;
  451.             }
  452.         }
  453.  
  454.         /* See if some wb messages have been replied */
  455.         Forbid();
  456.         while(Msg = (struct WBStartup *)GetMsg((struct MsgPort *)ParMPort)) {
  457.             ParMPort->pmp_MsgCnt--;
  458.             WBFree(Msg);
  459.         }
  460.         Permit();
  461.     }
  462.     Bye(THE_END);
  463. }
  464.