home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 240.lha / PickPacket_v1.0 / Sources / pickpack.c < prev    next >
C/C++ Source or Header  |  1989-05-04  |  28KB  |  943 lines
  1. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
  2. * |_o_o|\\ Copyright (c) 1989 The Software Distillery.                    *
  3. * |. o.| ||          All Rights Reserved                                  *
  4. * | .  | ||          Written by John Toebes and Doug Walker               *
  5. * | o  | ||          The Software Distillery                              *
  6. * |  . |//           235 Trillingham Lane                                 *
  7. * ======             Cary, NC 27513                                       *
  8. *                    BBS:(919)-471-6436                                   *
  9. \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  10. #include "pickpack.h"
  11. #include "pwgen.h"
  12.  
  13. #ifdef DEBUG
  14. int debug = 0;
  15. #endif
  16.  
  17. #define RES1LINE 124
  18. #define RES2LINE 136
  19.  
  20. static int Sendit(int);
  21. static int PutRes(int, LONG, int, struct MsgPort *);
  22. static int GetArg(int, LONG *, char *);
  23. static void setgad(struct Gadget *, char *, int, struct Window *, int);
  24.  
  25. void main(int, char **);
  26. void MemCleanup(void);
  27.  
  28. /* Global variables */
  29.  
  30. struct Window *Window;
  31. struct TmpRas tmpras;
  32.  
  33.  
  34. static char menutrans[7][14] = {
  35. {
  36. /* FILEHANDLE    */ SEL_HANDLE,
  37. /* FILEINFOBLOCK */ SEL_FILEINFO,
  38. /* INFODATA      */ SEL_INFODATA,
  39. /* BUFFER        */ SEL_BUFFER,
  40. /*               */ 0,
  41. /* SEND          */ SEL_SEND,
  42. /*               */ 0,
  43. /* HELP          */ SEL_HELP,
  44. /*               */ 0,
  45. /* QUIT          */ SEL_QUIT
  46. },
  47.  
  48. {
  49. /* OPENINPUT     */ SEL_OPENINPUT,
  50. /* OPENOUTPUT    */ SEL_OPENOUTPUT,
  51. /* OPENUPDATE    */ SEL_OPENUPDATE,
  52. /* READ          */ SEL_READ,
  53. /* WRITE         */ SEL_WRITE,
  54. /* SEEK          */ SEL_SEEK,
  55. /* CLOSE         */ SEL_CLOSE,
  56. /* TRUNCATE      */ SEL_TRUNCATE
  57. },
  58.  
  59. {
  60. /* LOCK          */ SEL_LOCK,
  61. /* DUPLOCK       */ SEL_DUPLOCK,
  62. /* UNLOCK        */ SEL_UNLOCK,
  63. /* EXAMINE       */ SEL_EXAMINE,
  64. /* EXNEXT        */ SEL_EXNEXT,
  65. /* CREATEDIR     */ SEL_CREATEDIR,
  66. /* DELETE        */ SEL_DELETE,
  67. /* RENAME        */ SEL_RENAME,
  68. /* PARENT        */ SEL_PARENT,
  69. /* SETPROTECT    */ SEL_SETPROTECT,
  70. /* SETCOMMENT    */ SEL_SETCOMMENT,
  71. /* SETDATE       */ SEL_SETDATE
  72. },
  73.  
  74. {
  75. /* CURRENTVOL    */ SEL_CURRENTVOL,
  76. /* INFO          */ SEL_INFO,
  77. /* DISKINFO      */ SEL_DISKINFO,
  78. /* RENAMEDISK    */ SEL_RENAMEDISK
  79. },
  80.  
  81. {
  82. /* DIE           */ SEL_DIE,
  83. /* FLUSH         */ SEL_FLUSH,
  84. /* MORECACHE     */ SEL_MORECACHE,
  85. /* INHIBIT       */ SEL_INHIBIT,
  86. /* WRITE_PROTECT */ SEL_WRITE_PROTECT,
  87. /* NETWORKHELLO  */ SEL_NETWORKHELLO,
  88. /* DEBUG         */ SEL_DEBUG,
  89. /* SETTRANS      */ SEL_SETTRANS
  90. },
  91.  
  92. {
  93. /* PickPacket V1.0   */ 0,
  94. /* Copyright...  */ 0,
  95. /* All Rights..  */ 0,
  96. /* See PickPacket... */ 0,
  97. /* MUG SHOT      */ 0
  98. },
  99.  
  100. {
  101. /* DOSTRUE           -1 */ SEL_MIN1,
  102. /* DOSFALSE           0 */ SEL_ZERO,
  103. /*                      */ 0,
  104. /* OFFSET_BEGINNING  -1 */ SEL_MIN1,
  105. /* OFFSET_CURRENT     0 */ SEL_ZERO,
  106. /* OFFSET_END         1 */ SEL_ONE,
  107. /*                      */ 0,
  108. /* SHARED_LOCK       -2 */ SEL_MIN2,
  109. /* ACCESS_READ       -2 */ SEL_MIN2,
  110. /*                      */ 0,
  111. /* EXCLUSIVE_LOCK    -1 */ SEL_MIN1,
  112. /* ACCESS_WRITE      -1 */ SEL_MIN1,
  113. /*                      */ 0,
  114. /* NULL               0 */ SEL_ZERO
  115. }
  116.  
  117. };
  118.  
  119. UBYTE Buf1[14], Buf2[14], Buf3[14], Buf4[14], BufN[32];
  120. static struct IntuiText 
  121. Buf1Text = {3, 0, JAM2, 328,  62, &TOPAZ80, Buf1, NULL      },
  122. Buf2Text = {3, 0, JAM2, 328,  78, &TOPAZ80, Buf2, &Buf1Text },
  123. Buf3Text = {3, 0, JAM2, 328,  94, &TOPAZ80, Buf3, &Buf2Text },
  124. Buf4Text = {3, 0, JAM2, 328, 110, &TOPAZ80, Buf4, &Buf3Text },
  125. NameText = {3, 0, JAM2,  80,  46, &TOPAZ80, BufN, &Buf4Text };
  126.  
  127. struct packettype
  128.    {
  129.    int number;
  130.    char *name;
  131.    int arg1, arg2, arg3, arg4, res1;
  132.    };
  133.  
  134. struct packettype packets[] = {
  135. { 0 }, /* First action begins at 0 */
  136. { ACTION_FINDINPUT,     "ACTION_FINDINPUT",      HAN, LCK, STR,   0, FLG },
  137. { ACTION_FINDOUTPUT,    "ACTION_FINDOUTPUT",     HAN, LCK, STR,   0, FLG },
  138. { ACTION_FINDUPDATE,    "ACTION_FINDUPDATE",     HAN, LCK, STR,   0, FLG },
  139. { ACTION_READ,          "ACTION_READ",           AG1, BUF, NUM,   0, NUM },
  140. { ACTION_WRITE,         "ACTION_WRITE",          AG1, BUF, NUM,   0, NUM },
  141. { ACTION_SEEK,          "ACTION_SEEK",           AG1, NUM, NUM,   0, NUM },
  142. { ACTION_END,           "ACTION_END",            AG1,   0,   0,   0, FLG },
  143. { ACTION_TRUNCATE,      "ACTION_TRUNCATE",       AG1,   0,   0,   0, FLG },
  144. { ACTION_LOCATE_OBJECT, "ACTION_LOCATE_OBJECT",  LCK, STR, NUM,   0, LCK },
  145. { ACTION_COPY_DIR,      "ACTION_COPY_DIR",       LCK,   0,   0,   0, LCK },
  146. { ACTION_FREE_LOCK,     "ACTION_FREE_LOCK",      LCK,   0,   0,   0, FLG },
  147. { ACTION_EXAMINE_OBJECT,"ACTION_EXAMINE_OBJECT", LCK, FIB,   0,   0, FLG },
  148. { ACTION_EXAMINE_NEXT,  "ACTION_EXAMINE_NEXT",   LCK, FIB,   0,   0, FLG },
  149. { ACTION_CREATE_DIR,    "ACTION_CREATE_DIR",     LCK, STR,   0,   0, LCK },
  150. { ACTION_DELETE_OBJECT, "ACTION_DELETE_OBJECT",  LCK, STR,   0,   0, FLG },
  151. { ACTION_RENAME_OBJECT, "ACTION_RENAME_OBJECT",  LCK, STR, LCK, STR, FLG },
  152. { ACTION_PARENT,        "ACTION_PARENT",         LCK,   0,   0,   0, LCK },
  153. { ACTION_SET_PROTECT,   "ACTION_SET_PROTECT",      0, LCK, STR, NUM, FLG },
  154. { ACTION_SET_COMMENT,   "ACTION_SET_COMMENT",      0, LCK, STR, STR, FLG },
  155. { ACTION_SET_DATE,      "ACTION_SET_DATE",       LCK, BUF,   0,   0, FLG },
  156. { ACTION_CURRENT_VOLUME,"ACTION_CURRENT_VOLUME",   0,   0,   0,   0, VOL },
  157. { ACTION_INFO,          "ACTION_INFO",           LCK, INF,   0,   0, FLG },
  158. { ACTION_DISK_INFO,     "ACTION_DISK_INFO",      INF,   0,   0,   0, FLG },
  159. { ACTION_RENAME_DISK,   "ACTION_RENAME_DISK",    STR,   0,   0,   0, FLG },
  160. { ACTION_DIE,           "ACTION_DIE",              0,   0,   0,   0, FLG },
  161. { ACTION_FLUSH,         "ACTION_FLUSH",            0,   0,   0,   0, FLG },
  162. { ACTION_MORE_CACHE,    "ACTION_MORE_CACHE",     NUM,   0,   0,   0, NUM },
  163. { ACTION_INHIBIT,       "ACTION_INHIBIT",        NUM,   0,   0,   0, FLG },
  164. { ACTION_WRITE_PROTECT, "ACTION_WRITE_PROTECT",  FLG, NUM,   0,   0, FLG },
  165. { ACTION_NETWORK_HELLO, "ACTION_NETWORK_HELLO",  STR,   0,   0,   0, FLG },
  166. { ACTION_HANDLER_DEBUG, "ACTION_HANDLER_DEBUG",  NUM,   0,   0,   0, NUM },
  167. { ACTION_SET_TRANS,     "ACTION_SET_TRANS",      STR, NUM,   0,   0, FLG },
  168. { 0 } /* Last packet type is 0 */
  169. };
  170.  
  171. char *typnames[] = 
  172. { 
  173.   "<UNUSED>     ",
  174.   "STRING       ",
  175.   "BOOLEAN      ",
  176.   "FileLock     ",
  177.   "FileHandle   ",
  178.   "FileInfoBlock",
  179.   "fh_Arg1      ",
  180.   "InfoData     ",
  181.   "Integer      ",
  182.   "Volume Node  ",
  183.   "<BAD 10>     ",
  184.   "Data Buffer  "
  185. };
  186.  
  187. extern struct WBStartup *WBenchMsg;
  188.  
  189. #define NOCONST 12345
  190.  
  191. #define LASTACT ((sizeof(packets)/sizeof(struct packettype))-2)
  192. void main(argc, argv)
  193. int argc;
  194. char **argv;
  195. {
  196.   struct IntuiMessage *message;
  197.   int setconst;
  198.   int run = 1;
  199.   int select, newsel, len;
  200.   struct Gadget *gad;
  201.   struct Window *CurrentWindow;
  202.  
  203.   char *tmpchar;
  204.   BPTR olddir;
  205.  
  206.   olddir = NULL;
  207.   if(argc == 0)
  208.   {
  209.      /* Workbench startup */
  210.      if(WBenchMsg->sm_ArgList->wa_Lock != NULL)
  211.         olddir = CurrentDir(WBenchMsg->sm_ArgList->wa_Lock);
  212.      else
  213.      {
  214.         BUG(1, ("pickpack: Wa_Lock is NULL\n"))
  215.      }
  216.   }
  217.  
  218. #ifdef DEBUG
  219.   if(argc>0 && argv[1][0] == '-' && 
  220.      (argv[1][1] == 'd' || argv[1][1] == 'D'))
  221.   {
  222.      stcd_i(argv[1]+2, &debug);
  223.      BUG(0, ("*** Debugging initialized at level %d\n", debug))
  224.      argc--, argv++;
  225.   }
  226. #endif
  227.  
  228.   if(argc>1) strcpy(DevNameSIBuff, argv[1]);
  229.  
  230.   if ((IntuitionBase = (struct IntuitionBase *)
  231.                OpenLibrary("intuition.library", 0)) == NULL) 
  232.   {
  233.      BUG(0, ("Can't open intuition.library\n"))
  234.      exit(1);
  235.   }
  236.   if ((GfxBase = (struct GfxBase *)
  237.          OpenLibrary("graphics.library", 0)) == NULL) 
  238.   {
  239.      BUG(0, ("Can't open graphics.library\n"))
  240.      exit(2);
  241.   }
  242.   if ((Window = OpenWindow(&NewWindowStructure1)) == NULL) 
  243.   {
  244.      BUG(0, ("Can't open window\n"))
  245.      exit(3);
  246.   }
  247.  
  248.   /* Initialize the code to handle structure windows */
  249.   InitST(Window->UserPort);
  250.  
  251.   SetDrMd(Window->RPort, JAM1);
  252.  
  253.   SetMenuStrip(Window, &Menu1);
  254.  
  255.   select = SEL_LOCK;
  256.   CurrentWindow = NULL;
  257.   setconst = NOCONST;
  258.  
  259.   while(run >= 0)
  260.   {
  261.      BUG(3, ("pickpack: Top of loop\n"))
  262.      if (run)
  263.         {
  264.         memset(BufN, ' ', 24);
  265.         len = strlen(packets[select].name);
  266.         if (len > 23) len = 23;
  267.         memcpy(BufN, packets[select].name, len);
  268.         BufN[23] = 0;
  269.         strcpy(Buf1, typnames[packets[select].arg1]);
  270.         strcpy(Buf2, typnames[packets[select].arg2]);
  271.         strcpy(Buf3, typnames[packets[select].arg3]);
  272.         strcpy(Buf4, typnames[packets[select].arg4]);
  273.         PrintIText(Window->RPort, &NameText, 0, 0);
  274.         run = 0;
  275.         }
  276.  
  277.      while((message = (struct IntuiMessage *) GetMsg(Window->UserPort)) == NULL)
  278.      {
  279.         /* No messages, it's safe to close windows */
  280.         PurgeST();
  281.         Wait(1 << Window->UserPort->mp_SigBit);
  282.      }
  283.      
  284.      switch(message->Class)
  285.      {
  286.         case NEWSIZE:
  287.            status("");
  288.            BUG(2, ("Doing a newsize on the window %08lx\n", message->IDCMPWindow))
  289.            MoveWind(message->IDCMPWindow, 0);
  290.            break;
  291.  
  292.         case CLOSEWINDOW:
  293.            status("");
  294.            BUG(1, ("pickpack: shutting down\n"))
  295.            if (message->IDCMPWindow == Window)
  296.               run = -1;
  297.            else
  298.               {
  299.               BUG(2, ("pickpack: Purge Item\n"))
  300.               UnlinkST(message->IDCMPWindow);
  301.               CurrentWindow = NULL;
  302.               BUG(3, ("pickpack: Active window changed to 0x%08x\n", CurrentWindow))
  303.               }
  304.            setconst = NOCONST;
  305.            break;
  306.  
  307.         case ACTIVEWINDOW:
  308.            if (message->IDCMPWindow != Window)
  309.               CurrentWindow = message->IDCMPWindow;
  310.            BUG(3, ("pickpack: Active window changed to 0x%08x\n", CurrentWindow))
  311.            break;
  312.  
  313.         case INACTIVEWINDOW:
  314.            if (message->IDCMPWindow != Window)
  315.               CurrentWindow = message->IDCMPWindow;
  316.            BUG(3, ("pickpack: InActiveWindow to 0x%08x\n", message->IDCMPWindow))
  317.            break;
  318.  
  319.         case MENUPICK:
  320.            status("");
  321.            if (message->Code == MENUNULL) break;
  322.            newsel = menutrans[MENUNUM(message->Code)][ITEMNUM(message->Code)];
  323.            BUG(9, ("pickpack: MENUNUM %d ITEMNUM %d newsel %d\n",
  324.               MENUNUM(message->Code), ITEMNUM(message->Code), newsel))
  325.            setconst = NOCONST;
  326.            switch(newsel)
  327.            {
  328.               case 0: 
  329.                  BUG(1, ("pickpack: 0 menu pick\n"))
  330.                  break;
  331.  
  332.               case SEL_HELP:
  333.                  goto DOHELP;
  334.                  break;
  335.  
  336.               case SEL_SEND:
  337.                  BUG(2, ("pickpack: Sending packet\n"))
  338.                  if(Sendit(select)) DisplayBeep(NULL);
  339.                  CurrentWindow = NULL;
  340.                  break;
  341.  
  342.               case SEL_HANDLE:
  343.                  BUG(2, ("pickpack: SEL_HANDLE menu pick\n"))
  344.                  CurrentWindow = AllocST(ST_HANDLE, NULL, 0);
  345.                  BUG(3, ("pickpack: Active window changed to 0x%08x\n", CurrentWindow))
  346.                  break;
  347.  
  348.               case SEL_FILEINFO:
  349.                  BUG(2, ("pickpack: SEL_FILEINFO menu pick\n"))
  350.                  CurrentWindow = AllocST(ST_FIB, NULL, 0);
  351.                  BUG(3, ("pickpack: Active window changed to 0x%08x\n", CurrentWindow))
  352.                  break;
  353.  
  354.               case SEL_INFODATA:
  355.                  BUG(2, ("pickpack: SEL_INFODATA menu pick\n"))
  356.                  CurrentWindow = AllocST(ST_INFO, NULL, 0);
  357.                  BUG(3, ("pickpack: Active window changed to 0x%08x\n", CurrentWindow))
  358.                  break;
  359.  
  360.               case SEL_BUFFER:
  361.                  BUG(2, ("pickpack: SEL_BUFFER menu pick\n"))
  362.                  reqinit();
  363.                  BUG(3, ("pickpack: Active window changed to 0x%08x\n", CurrentWindow))
  364.                  break;
  365.  
  366.               case SEL_QUIT:
  367.                  BUG(2, ("pickpack: SEL_QUIT menu pick\n"))
  368.                  run = -1; 
  369.                  break;
  370.  
  371.               case SEL_MIN2:
  372.               case SEL_MIN1:
  373.               case SEL_ZERO:
  374.               case SEL_ONE:
  375.                  setconst = newsel - SEL_ZERO;
  376.                  status("Select field to recieve constant value");
  377.                  break;
  378.  
  379.               default:
  380.                  BUG(2, ("pickpack: %d menu pick\n", newsel))
  381.                  select = newsel;
  382.                  run = 1;
  383.                  break;
  384.            }
  385.            BUG(3, ("pickpack: Menu end Active window changed to 0x%08x\n", CurrentWindow))
  386.            CurrentWindow = NULL;
  387.            break;
  388.  
  389.         case GADGETDOWN:
  390.         case GADGETUP:
  391.            status("");
  392.            BUG(2, ("pickpack: GADGETDOWN/GADGETUP\n"))
  393.            gad = (struct Gadget *)message->IAddress;
  394.            switch(gad->GadgetID)
  395.            {
  396.               case GAD_BUFLEN:
  397.               case GAD_BLOK:
  398.               case GAD_BLCAN:
  399.                  len = reqkill();
  400.                  if(len > 0 && gad->GadgetID != GAD_BLCAN)
  401.                     CurrentWindow = AllocST(ST_DATA, NULL, len);
  402.                  break;
  403.  
  404.               case GAD_SEND:
  405.                  BUG(2, ("pickpack: Sending packet\n"))
  406.                  if(Sendit(select)) DisplayBeep(NULL);
  407.                  CurrentWindow = NULL;
  408.                  break;
  409.  
  410.               case GAD_ARG1:
  411.                  BUG(2, ("pickpack: Case GAD_ARG1\n"))
  412.                  setgad(&STR1, STR1SIBuff, packets[select].arg1,
  413.                         CurrentWindow, setconst);
  414.                  CurrentWindow = NULL;
  415.                  break;
  416.  
  417.               case GAD_ARG2:
  418.                  BUG(2, ("pickpack: Case GAD_ARG2\n"))
  419.                  setgad(&STR2, STR2SIBuff, packets[select].arg2,
  420.                         CurrentWindow, setconst);
  421.                  CurrentWindow = NULL;
  422.                  break;
  423.  
  424.               case GAD_ARG3:
  425.                  BUG(2, ("pickpack: Case GAD_ARG3\n"))
  426.                  setgad(&STR3, STR3SIBuff, packets[select].arg3, 
  427.                         CurrentWindow, setconst);
  428.                  CurrentWindow = NULL;
  429.                  break;
  430.  
  431.               case GAD_ARG4:
  432.                  BUG(2, ("pickpack: Case GAD_ARG4\n"))
  433.                  setgad(&STR4, STR4SIBuff, packets[select].arg4, 
  434.                         CurrentWindow, setconst);
  435.                  CurrentWindow = NULL;
  436.                  break;
  437.  
  438.               case GAD_PREV:
  439.                  BUG(2, ("pickpack: Case GAD_PREV\n"))
  440.                  select--;
  441.                  if (select < 1)
  442.                     select = LASTACT;
  443.                  run = 1;
  444.                  CurrentWindow = NULL;
  445.                  BUG(3, ("pickpack: prev: Active window changed to 0x%08x\n", CurrentWindow))
  446.                  break;
  447.  
  448.               case GAD_NEXT:
  449.                  BUG(2, ("pickpack: Case GAD_NEXT\n"))
  450.                  select++;
  451.                  if (select > LASTACT)
  452.                     select = 1;
  453.                  run = 1;
  454.                  BUG(3, ("pickpack: next: Active window changed to 0x%08x\n", CurrentWindow))
  455.                  CurrentWindow = NULL;
  456.                  break;
  457.  
  458.               case GAD_HANDLE:
  459.                  BUG(2, ("pickpack: GAD_HANDLE gadget pick\n"))
  460.                  CurrentWindow = AllocST(ST_HANDLE, NULL, 0);
  461.                  BUG(3, ("pickpack: Active window changed to 0x%08x\n", CurrentWindow))
  462.                  break;
  463.  
  464.               case GAD_FILEINFO:
  465.                  BUG(2, ("pickpack: GAD_FILEINFO gadget pick\n"))
  466.                  CurrentWindow = AllocST(ST_FIB, NULL, 0);
  467.                  BUG(3, ("pickpack: Active window changed to 0x%08x\n", CurrentWindow))
  468.                  break;
  469.  
  470.               case GAD_INFODATA:
  471.                  BUG(2, ("pickpack: GAD_INFODATA gadget pick\n"))
  472.                  CurrentWindow = AllocST(ST_INFO, NULL, 0);
  473.                  BUG(3, ("pickpack: Active window changed to 0x%08x\n", CurrentWindow))
  474.                  break;
  475.  
  476.               case GAD_BUFFER:
  477.                  BUG(2, ("pickpack: GAD_BUFFER gadget pick\n"))
  478.                  reqinit();
  479.                  BUG(3, ("pickpack: Active window changed to 0x%08x\n", CurrentWindow))
  480.                  break;
  481. #ifdef DEBUG
  482.               case GAD_DEBUG:
  483.                  debug = atoi(DBGVALSIBuff);
  484.                  BUG(1, ("Debugging set to level %d\n", debug))
  485.                  break;
  486. #endif
  487.               case GAD_UP:
  488.               case GAD_DOWN:
  489.               case GAD_SLIDER:
  490.                  BUG(2, ("Doing a move on the window %08lx\n", message->IDCMPWindow))
  491.                  MoveWind(message->IDCMPWindow, GAD_SLIDER-gad->GadgetID);
  492.                  break;
  493.  
  494.               default:
  495.                  BUG(2, ("pickpack: default gadget\n"))
  496.                  CurrentWindow = NULL;
  497.                  BUG(3, ("pickpack: default: Active window changed to 0x%08x\n", CurrentWindow))
  498.                  break;
  499.  
  500.            }
  501.            setconst = NOCONST;
  502.            break;
  503.  
  504.         case SELECTUP:
  505.         case MOUSEBUTTONS:
  506.            BUG(2, ("pickpack: SELECTUP/MOUSEBUTTONS\n"))
  507.            break;  /* Don't change the status() message */
  508.  
  509.         case RAWKEY:
  510.            BUG(2, ("pickpack: RAWKEY\n"))
  511.            status("");
  512.            if (message->Code == 0x5f || /* Help Key */
  513.                message->Code == 0x3a || /* / ? key */
  514.                message->Code == 0x25)   /* h key */
  515.            {
  516. DOHELP:
  517.               BUG(3, ("pickpack: HELP requested\n"))
  518.               if(GetHelp(&tmpchar, &len) ||
  519.                  AllocST(ST_VIEW, (APTR)tmpchar, len))
  520.               {
  521.                  BUG(1, ("pickpack: There's no help for you!\n"))
  522.               }
  523.               
  524.            }
  525.            CurrentWindow = NULL;
  526.            break;
  527.  
  528.         default:
  529.            BUG(2, ("pickpack: Unknown IntuiMessage\n"))
  530.            CurrentWindow = NULL;
  531.            break;
  532.      }
  533.      ReplyMsg((struct Message *)message);
  534.   }
  535.   TermST();
  536.  
  537.   if(olddir) CurrentDir(olddir);
  538.  
  539.   ClearMenuStrip(Window);
  540.   CloseWindow(Window);
  541.   CloseLibrary(IntuitionBase);
  542.   CloseLibrary(GfxBase);
  543.   exit(0);
  544. }
  545.  
  546. static void setgad(gad, buf, type, wind, val)
  547. struct Gadget *gad;
  548. char *buf;
  549. int type;
  550. struct Window *wind;
  551. int val;
  552. {
  553. if (val != NOCONST)
  554.    {
  555.    /* We have a pending constant to deal with */
  556.    switch(type)
  557.        {
  558.        case FLG:
  559.           if (val == 0) strcpy(buf, "DOSTRUE");
  560.           else if (val == -1) strcpy(buf, "DOSFALSE");
  561.           else
  562.              {
  563.              DisplayBeep(NULL);
  564.              status("Invalid flag value");
  565.              return;
  566.              }
  567.           break;
  568.        case LCK:
  569.           if (val != 0)
  570.              {
  571.              DisplayBeep(NULL);
  572.              status("Invalid lock value");
  573.              return;
  574.              }
  575.           /* Fall through to the num */             
  576.        case NUM:
  577.           sprintf(buf, "%d", val);      
  578.           break;
  579.        default:
  580.           status("Numeric argument not allowed");
  581.           DisplayBeep(NULL);
  582.           return;
  583.        }
  584.    }
  585. else if (wind != NULL)
  586.    {
  587.    switch(type)
  588.       {
  589.       case LCK:
  590.       case HAN:
  591.       case FIB:
  592.       case AG1:
  593.       case INF:
  594.       case VOL:
  595.       case BUF:
  596.          strcpy(buf, wind->Title);
  597.          break;
  598.  
  599.       case NUM:
  600.          sprintf(buf, "%d", WindSize(wind));
  601.          break;
  602.  
  603.       default:
  604.          status("Window argument not allowed");
  605.          DisplayBeep(NULL);
  606.          break;
  607.       }
  608.    }
  609.  
  610. else
  611.    {
  612.    status("No argument pending for field");
  613.    return;
  614.    }
  615.  
  616. RefreshGList(gad, Window, NULL, 1);
  617. }
  618.  
  619. #define FNLEN 101
  620. static int fnused;
  621. static char fn1[FNLEN], fn2[FNLEN];
  622.  
  623. static int Sendit(select)
  624. int select;
  625. {
  626.    int rc;
  627.    struct MsgPort *pid;
  628.    char buf[100];
  629.    LONG args[8];
  630.    LONG res[2];
  631.    BUG(1,("Sendit: Entry, select %d device '%s'\n", select, DevNameSIBuff))
  632.  
  633.    pid = DeviceProc(DevNameSIBuff);
  634.    if(!pid)
  635.    {
  636.       BUG(1, ("Sendit: Exit, no such device\n"))
  637.       sprintf(buf, "Unknown device '%s'", DevNameSIBuff);
  638.       status(buf);
  639.       return(RC_ERRNODEVICE);
  640.    }
  641.  
  642.    fnused = 0;
  643.  
  644.    if (rc=GetArg(packets[select].arg1, args,   STR1SIBuff))
  645.    {
  646.      status("Invalid value for dp_Arg1");
  647.      return(rc);
  648.    }
  649.    if (rc=GetArg(packets[select].arg2, args+1, STR2SIBuff))
  650.    {
  651.      status("Invalid value for dp_Arg2");
  652.      return(rc);
  653.    }
  654.    if (rc=GetArg(packets[select].arg3, args+2, STR3SIBuff))
  655.    {
  656.      status("Invalid value for dp_Arg3");
  657.      return(rc);
  658.    }
  659.    if (rc=GetArg(packets[select].arg4, args+3, STR4SIBuff))
  660.    {
  661.      status("Invalid value for dp_Arg4");
  662.      return(rc);
  663.    }
  664.  
  665.    sendpkt(pid, packets[select].number, args, 4, res);
  666.  
  667.    BUG(1, ("Sendit: Sendpkt returned %ld, %ld\n", res[0], res[1]))
  668.  
  669.    PutRes(packets[select].res1, res[0], RES1LINE, pid);
  670.    PutRes(RCNUM, res[1], RES2LINE, pid);
  671.  
  672.    switch(packets[select].number)
  673.    {
  674.       case ACTION_FREE_LOCK:
  675.       {
  676.          struct Window *tmpw;
  677.          tmpw = STToWind(BADDR(args[0]));
  678.          NameST(tmpw, NULL, NULL);
  679.          UnlinkST(tmpw);
  680.          break;
  681.       }
  682.  
  683.       case ACTION_END:
  684.          NameST(STToWind((APTR)args[0]), NULL, NULL);
  685.          break;
  686.  
  687.       case ACTION_FINDINPUT:
  688.       case ACTION_FINDOUTPUT:
  689.       case ACTION_FINDUPDATE:
  690.          if(res[0] == DOSTRUE)
  691.             NameST(STToWind(BADDR(args[0])), STR3SIBuff, pid);
  692.          break;
  693.  
  694.       case ACTION_DISK_INFO:
  695.          DisplayST(STToWind(BADDR(args[0])));
  696.          break;
  697.  
  698.       case ACTION_EXAMINE_OBJECT:
  699.       case ACTION_EXAMINE_NEXT:
  700.       case ACTION_INFO:
  701.          DisplayST(STToWind(BADDR(args[1])));
  702.          break;
  703.  
  704.       case ACTION_READ:
  705.       case ACTION_WRITE:
  706.          DisplayST(STToWind(BADDR(args[0])));
  707.          DisplayST(STToWind((APTR)args[1]));
  708.          break;
  709.    }
  710.  
  711.    return(RC_OK);
  712. }
  713.  
  714. static struct IntuiText ResText = {
  715.     1,0,JAM2,   /* front and back text pens, drawmode and fill byte */
  716.     0,0,        /* XY origin relative to container TopLeft */
  717.     &TOPAZ80,   /* font pointer or NULL for default */
  718.     NULL,       /* pointer to text */
  719.     NULL        /* next IntuiText structure */
  720. };
  721.  
  722.  
  723. static int PutRes(vtype, res, top, pid)
  724. int vtype;
  725. LONG res;
  726. int top;
  727. struct MsgPort *pid;
  728. {
  729.    int rc;
  730.    struct Window *w;
  731.    char data[100];
  732.  
  733.    BUG(1, ("PutRes: Entry, vtype %d\n"))
  734.  
  735.    ResText.IText = data;
  736.    ResText.FrontPen = 1;
  737.    ResText.BackPen = 0;
  738.    memset(data, ' ', 50);
  739.    rc = RC_OK;
  740.    switch(vtype)
  741.    {
  742.       case 0:
  743.          break;
  744.  
  745.       case FLG:
  746.          if(res == DOSFALSE) strcpy(data, "DOSFALSE");
  747.          else if(res == DOSTRUE) strcpy(data, "DOSTRUE");
  748.          else sprintf(data, "??? %ld ???", res);
  749.          break;
  750.  
  751.       case LCK:
  752.          if(res)
  753.          {
  754.             if(AllocST(ST_LOCK, BADDR(res), 0))
  755.             {
  756.                w = STToWind(BADDR(res));
  757.                strcpy(data, w->Title);
  758.                NameST(w, fn1+1, pid);
  759.             }
  760.          }
  761.          else
  762.          {
  763.             strcpy(data, "NULL");
  764.          }
  765.          break;
  766.  
  767.       case RCNUM:
  768.          sprintf(data, "RC %ld - ", res);
  769.          switch(res)
  770.             {
  771.             case 103: strcat(data, "insufficient free store"); break;
  772.             case 105: strcat(data, "task table full!"); break;
  773.             case 120: strcat(data, "argument line invalid or too long"); break;
  774.             case 121: strcat(data, "file is not an object module"); break;
  775.             case 122: strcat(data, "invalid resident library during load"); break;
  776.             case 202: strcat(data, "object in use"); break;
  777.             case 203: strcat(data, "object already exists"); break;
  778.             case 204: strcat(data, "directory not found"); break;
  779.             case 205: strcat(data, "object not found"); break;
  780.             case 206: strcat(data, "invalid window description"); break;
  781.             case 209: strcat(data, "packet request type unknown"); break;
  782.             case 210: strcat(data, "stream name component invalid"); break;
  783.             case 211: strcat(data, "invalid object lock"); break;
  784.             case 212: strcat(data, "object not of required type"); break;
  785.             case 213: strcat(data, "disk not validated"); break;
  786.             case 214: strcat(data, "disk write-protected"); break;
  787.             case 215: strcat(data, "rename across devices attempted"); break;
  788.             case 216: strcat(data, "directory not empty"); break;
  789.             case 218: strcat(data, "device (or volume) not mounted"); break;
  790.             case 219: strcat(data, "seek failure"); break;
  791.             case 220: strcat(data, "comment too big"); break;
  792.             case 221: strcat(data, "disk full"); break;
  793.             case 222: strcat(data, "file is protected from deletion"); break;
  794.             case 223: strcat(data, "file is write protected"); break;
  795.             case 224: strcat(data, "file is read protected"); break;
  796.             case 225: strcat(data, "not a valid DOS disk"); break;
  797.             case 226: strcat(data, "no disk in drive"); break;
  798.             case 232: strcat(data, "no more entries in directory"); break;
  799.             case   0: break;
  800.             default:  strcat(data, "???????"); break;
  801.             }
  802.          break;
  803.  
  804.       case NUM:
  805.          sprintf(data, "%ld", res);
  806.          break;
  807.  
  808.       case VOL:
  809.          rc = RC_ERRBADDATA;
  810.          break;
  811.  
  812.       default:
  813.          rc = RC_ERRBADDATA;
  814.          break;
  815.    }
  816.  
  817.    if(rc == RC_OK) 
  818.    {
  819.       data[strlen(data)] = ' ';
  820.       data[42] = 0;
  821.       PrintIText(Window->RPort, &ResText, 80, top);
  822.       BUG(1, ("PutRes: Data value is %s\n", data))
  823.    }
  824. #ifdef DEBUG
  825.    else
  826.       BUG(1, ("PutRes: Bad RC %d\n", rc))
  827. #endif
  828.  
  829.    return(rc);
  830. }
  831.  
  832. void status(msg)
  833. char *msg;
  834. {
  835. char data[100];
  836. int len;
  837.  
  838. len = strlen(msg);
  839. memset(data, ' ', 50);
  840. if (len > 50) len = 50;
  841. memcpy(data, msg, len);
  842. data[50] = 0;
  843. ResText.FrontPen = 0;
  844. ResText.BackPen = (len == 0 ? 0 : 1);
  845. ResText.IText = data;
  846. PrintIText(Window->RPort, &ResText, 19, 148);
  847. }
  848.  
  849. static int GetArg(vtype, arg, data)
  850. int vtype;
  851. LONG *arg;
  852. char *data;
  853. {
  854.    int rc;
  855.    unsigned char *tmpchar;
  856.    APTR v;
  857.  
  858.    BUG(1, ("GetArg: Entry, vtype %d data %s\n", vtype, data))
  859.  
  860.    *arg = 0;
  861.  
  862.    rc = RC_OK;
  863.    switch(abs(vtype))
  864.    {
  865.       case 0:
  866.          break;
  867.  
  868.       case STR:
  869.          tmpchar = (unsigned char *)(fnused ? fn2 : fn1);
  870.          strcpy(tmpchar+1, data);
  871.          tmpchar[0] = strlen(data);
  872.          *arg = MKBADDR(tmpchar);
  873.          break;
  874.  
  875.       case FLG:
  876.          if(stricmp(data, "DOSTRUE")) *arg = DOSTRUE;
  877.          else if(stricmp(data, "DOSFALSE")) *arg = DOSFALSE;
  878.          else rc = RC_ERRBADDATA;
  879.          break;
  880.  
  881.       case LCK:
  882.          if(data[0] == '0' || data[0] == '\0')
  883.          {
  884.             *arg = NULL;
  885.             break;
  886.          }
  887.          v = FindST(data, ST_LOCK);
  888.          if(!v) rc = RC_ERRBADDATA;
  889.          else *arg = (LONG)MKBADDR(v);
  890.          break;
  891.  
  892.       case HAN:
  893.          v = FindST(data, ST_HANDLE);
  894.          if(!v) rc = RC_ERRBADDATA;
  895.          else *arg = (LONG)MKBADDR(v);
  896.          break;
  897.  
  898.       case FIB:
  899.          v = FindST(data, ST_FIB);
  900.          if(!v) rc = RC_ERRBADDATA;
  901.          else *arg = (LONG)MKBADDR(v);
  902.          break;
  903.  
  904.       case AG1:
  905.          v = FindST(data, ST_HANDLE);
  906.          if(!v) rc = RC_ERRBADDATA;
  907.          else *arg = (LONG)((struct FileHandle *)v)->fh_Arg1;
  908.          break;
  909.  
  910.       case INF:
  911.          v = FindST(data, ST_INFO);
  912.          if(!v) rc = RC_ERRBADDATA;
  913.          else *arg = (LONG)MKBADDR(v);
  914.          break;
  915.  
  916.       case NUM:
  917.          stcd_l(data, arg);
  918.          break;
  919.  
  920.       case VOL:
  921.          rc = RC_ERRBADDATA;
  922.          break;
  923.  
  924.       case BUF:
  925.          v = FindST(data, ST_DATA);
  926.          if(!v) rc = RC_ERRBADDATA;
  927.          else *arg = (LONG)v;
  928.          break;
  929.  
  930.       default:
  931.          rc = RC_ERRBADDATA;
  932.          break;
  933.    }
  934.  
  935. #ifdef DEBUG
  936.    if(rc)
  937.       BUG(1, ("GetArg: Bad RC %d\n", rc))
  938.    else
  939.       BUG(1, ("GetArg: arg %d (0x%08x)\n", *arg, *arg))
  940. #endif
  941.  
  942.    return(rc);
  943. }