home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 550b.lha / Term_v1.8a / Source.LZH / termXPR.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-21  |  36.8 KB  |  1,670 lines
  1. /* $Revision Header * Header built automatically - do not edit! *************
  2.  *
  3.  *    (C) Copyright 1990 by Olaf 'Olsen' Barthel & MXM
  4.  *
  5.  *    Name .....: TermXPR.c
  6.  *    Created ..: Monday 21-Jan-91 20:12
  7.  *    Revision .: 0
  8.  *
  9.  *    Date            Author          Comment
  10.  *    =========       ========        ====================
  11.  *    21-Jan-91       Olsen           Created this file!
  12.  *
  13.  * $Revision Header ********************************************************/
  14.  
  15. #include "TermGlobal.h"
  16.  
  17. enum    {    MEN_SKIP=1,MEN_NEWLIB=1,MEN_ONLINE,MEN_ABORT,MEN_QUITPANEL };
  18. enum    {    MEN_OKAY=1,MEN_CANCEL,MEN_LOADSOMEFILE };
  19.  
  20. STATIC struct NewMenu OptionsMenu[] =
  21. {
  22.     { NM_TITLE, "Project",             0 , 0, 0, (APTR)0},
  23.     {  NM_ITEM, "Select New Protocol",    "P", 0, 0, (APTR)MEN_NEWLIB},
  24.     {  NM_ITEM, NM_BARLABEL,         0 , 0, 0, (APTR)0},
  25.     {  NM_ITEM, "Quit",            "Q", 0, 0, (APTR)MEN_QUITPANEL},
  26.     { NM_END, 0,                 0 , 0, 0, (APTR)0}
  27. };
  28.  
  29. struct NewMenu GetsMenu[] =
  30. {
  31.     { NM_TITLE, "Project",         0 , 0, 0, (APTR)0},
  32.     {  NM_ITEM, "Okay",        "O", 0, 0, (APTR)MEN_OKAY},
  33.     {  NM_ITEM, "Cancel",        "C", 0, 0, (APTR)MEN_CANCEL},
  34.     {  NM_ITEM, NM_BARLABEL,     0 , 0, 0, (APTR)0},
  35.     {  NM_ITEM, "Quit",        "Q", 0, 0, (APTR)MEN_QUITPANEL},
  36.     { NM_END, 0,             0 , 0, 0, (APTR)0}
  37. };
  38.  
  39.     /* This tiny flag controls whether xpr_fopen opened a file
  40.      * for writing/appending or not. Since only a single library is
  41.      * allowed to make the call a single variable may suffice.
  42.      */
  43.  
  44. STATIC BYTE FileWrite;
  45.  
  46.     /* xpr_fopen(UBYTE *FileName,UBYTE *AccessMode):
  47.      *
  48.      *    Open a file for random access.
  49.      */
  50.  
  51. LONG __saveds __asm
  52. xpr_fopen(register __a0 UBYTE *FileName,register __a1 UBYTE *AccessMode)
  53. {
  54.     BPTR File = NULL,SomeLock;
  55.  
  56.     switch(AccessMode[0])
  57.     {
  58.         case 'r':    if(AccessMode[1] == '+')
  59.                     File = Open(FileName,MODE_READWRITE);
  60.                 else
  61.                     File = Open(FileName,MODE_OLDFILE);
  62.  
  63.                 if(File)
  64.                     LogAction("Send file \"%s\".",FileName);
  65.  
  66.                 break;
  67.  
  68.         case 'w':    if(AccessMode[1] == '+')
  69.                 {
  70.                     if(SomeLock = Lock(FileName,ACCESS_WRITE))
  71.                     {
  72.                         UnLock(SomeLock);
  73.  
  74.                         DeleteFile(FileName);
  75.                     }
  76.  
  77.                     File = Open(FileName,MODE_READWRITE);
  78.                 }
  79.                 else
  80.                     File = Open(FileName,MODE_NEWFILE);
  81.  
  82.                 if(File)
  83.                 {
  84.                     FileWrite = TRUE;
  85.  
  86.                     LogAction("Receive file \"%s\".",FileName);
  87.                 }
  88.  
  89.                 AddDownloadObject(FileName);
  90.  
  91.                 break;
  92.  
  93.         case 'a':    if(SomeLock = Lock(FileName,ACCESS_WRITE))
  94.                 {
  95.                     UnLock(SomeLock);
  96.  
  97.                     if(File = Open(FileName,MODE_READWRITE))
  98.                     {
  99.                         if(Seek(File,0,OFFSET_END) == -1)
  100.                         {
  101.                             Close(File);
  102.  
  103.                             File = NULL;
  104.                         }
  105.                     }
  106.                 }
  107.                 else
  108.                     File = Open(FileName,MODE_NEWFILE);
  109.  
  110.                 if(File)
  111.                 {
  112.                     FileWrite = TRUE;
  113.  
  114.                     LogAction("Update file \"%s\".",FileName);
  115.                 }
  116.  
  117.                 break;
  118.     }
  119.  
  120.     return(File);
  121. }
  122.  
  123.     /* xpr_fclose(BPTR File):
  124.      *
  125.      *    Close a file opened by xpr_fopen.
  126.      */
  127.  
  128. LONG __saveds __asm
  129. xpr_fclose(register __a0 BPTR File)
  130. {
  131.     UBYTE SomeBuffer[256];
  132.     LONG Success;
  133.  
  134.     Success = NameFromFH(File,SomeBuffer,256);
  135.  
  136.     Close(File);
  137.  
  138.     if(Success)
  139.     {
  140.         if(!GetFileSize(SomeBuffer))
  141.         {
  142.             if(FileWrite)
  143.             {
  144.                 DeleteFile(SomeBuffer);
  145.  
  146.                 LogAction("Close file \"%s\" (incomplete file removed).",SomeBuffer);
  147.             }
  148.             else
  149.                 LogAction("Close file \"%s\".",SomeBuffer);
  150.         }
  151.         else
  152.         {
  153.             LogAction("Close file \"%s\".",SomeBuffer);
  154.  
  155.                 /* Try to identify the file type. */
  156.  
  157.             if(FileWrite)
  158.                 Identify(SomeBuffer);
  159.         }
  160.     }
  161.  
  162.     FileWrite = FALSE;
  163.  
  164.     return(1);
  165. }
  166.  
  167.     /* xpr_fread(APTR Buffer,LONG Size,LONG Count,BPTR File):
  168.      *
  169.      *    Read a few bytes from a file.
  170.      */
  171.  
  172. LONG __saveds __asm
  173. xpr_fread(register __a0 APTR Buffer,register __d0 LONG Size,register __d1 LONG Count,register __a1 BPTR File)
  174. {
  175.     return(Read(File,Buffer,Size * Count) / Size);
  176. }
  177.  
  178.     /* xpr_fwrite(APTR Buffer,LONG Size,LONG Count,BPTR File):
  179.      *
  180.      *    Write a few bytes to a file.
  181.      */
  182.  
  183. LONG __saveds __asm
  184. xpr_fwrite(register __a0 APTR Buffer,register __d0 LONG Size,register __d1 LONG Count,register __a1 BPTR File)
  185. {
  186.     return(Write(File,Buffer,Size * Count) / Size);
  187. }
  188.  
  189.     /* xpr_sread(UBYTE *Buffer,LONG Size,LONG Timeout):
  190.      *
  191.      *    Read a few bytes from the serial port (including
  192.      *    timeouts).
  193.      */
  194.  
  195. ULONG __saveds __asm
  196. xpr_sread(register __a0 UBYTE *Buffer,register __d0 LONG Size,register __d1 LONG Timeout)
  197. {
  198.     if(!WriteRequest)
  199.         return(0);
  200.  
  201.     if(Size)
  202.     {
  203.         ULONG SignalSet,Length;
  204.  
  205.         if(Timeout < 1)
  206.         {
  207.             WriteRequest -> IOSer . io_Command = SDCMD_QUERY;
  208.  
  209.             DoIO(WriteRequest);
  210.  
  211.             if((Length = WriteRequest -> IOSer . io_Actual) > 0)
  212.             {
  213.                 if(Length > Size)
  214.                     Length = Size;
  215.  
  216.                 ReadRequest -> IOSer . io_Command    = CMD_READ;
  217.                 ReadRequest -> IOSer . io_Data        = Buffer;
  218.                 ReadRequest -> IOSer . io_Length    = Length;
  219.  
  220.                 DoIO(ReadRequest);
  221.             }
  222.  
  223.             return(Length);
  224.         }
  225.  
  226.         TimeRequest -> tr_node . io_Command    = TR_ADDREQUEST;
  227.         TimeRequest -> tr_time . tv_secs    = Timeout >= MILLION ? Timeout / MILLION : 0;
  228.         TimeRequest -> tr_time . tv_micro    = Timeout % MILLION;
  229.  
  230.         ReadRequest -> IOSer . io_Command    = CMD_READ;
  231.         ReadRequest -> IOSer . io_Data        = Buffer;
  232.         ReadRequest -> IOSer . io_Length    = Size;
  233.  
  234.             /* Prevent early termination. */
  235.  
  236.         SetSignal(0,(1 << ReadPort -> mp_SigBit) | (1 << TimeRequest -> tr_node . io_Message . mn_ReplyPort -> mp_SigBit));
  237.  
  238.         SendIO(ReadRequest);
  239.         SendIO(TimeRequest);
  240.  
  241.         FOREVER
  242.         {
  243.             SignalSet = (1 << ReadPort -> mp_SigBit) | (1 << TimeRequest -> tr_node . io_Message . mn_ReplyPort -> mp_SigBit);
  244.  
  245.             if(TransferWindow)
  246.                 SignalSet |= 1 << TransferWindow -> UserPort -> mp_SigBit;
  247.  
  248.             SignalSet = Wait(SignalSet);
  249.  
  250.             if(SignalSet & (1 << TimeRequest -> tr_node . io_Message . mn_ReplyPort -> mp_SigBit))
  251.             {
  252.                 WaitIO(TimeRequest);
  253.  
  254.                 AbortIO(ReadRequest);
  255.                 WaitIO(ReadRequest);
  256.  
  257.                 return(ReadRequest -> IOSer . io_Actual);
  258.             }
  259.  
  260.             if(SignalSet & (1 << ReadPort -> mp_SigBit))
  261.             {
  262.                 WaitIO(ReadRequest);
  263.  
  264.                 AbortIO(TimeRequest);
  265.                 WaitIO(TimeRequest);
  266.  
  267.                 return(ReadRequest -> IOSer . io_Actual);
  268.             }
  269.  
  270.             if(TransferWindow)
  271.             {
  272.                 if(SignalSet & (1 << TransferWindow -> UserPort -> mp_SigBit))
  273.                 {
  274.                     if(xpr_chkabort() == -1)
  275.                     {
  276.                         AbortIO(TimeRequest);
  277.                         WaitIO(TimeRequest);
  278.  
  279.                         AbortIO(ReadRequest);
  280.                         WaitIO(ReadRequest);
  281.  
  282.                         return(-1);
  283.                     }
  284.                 }
  285.             }
  286.         }
  287.     }
  288.  
  289.     return(0);
  290. }
  291.  
  292.     /* xpr_swrite(UBYTE *Buffer,LONG Size):
  293.      *
  294.      *    Write a few bytes to the serial port.
  295.      */
  296.  
  297. LONG __saveds __asm
  298. xpr_swrite(register __a0 UBYTE *Buffer,register __d0 LONG Size)
  299. {
  300.     if(!WriteRequest)
  301.         return(-1);
  302.  
  303.     WriteRequest -> IOSer . io_Command    = CMD_WRITE;
  304.     WriteRequest -> IOSer . io_Data        = Buffer;
  305.     WriteRequest -> IOSer . io_Length    = Size;
  306.  
  307.     return((LONG)DoIO(WriteRequest));
  308. }
  309.  
  310.     /* xpr_sflush():
  311.      *
  312.      *    Release the contents of all serial buffers.
  313.      */
  314.  
  315. LONG __saveds
  316. xpr_sflush()
  317. {
  318.     if(!WriteRequest)
  319.         return(-1);
  320.  
  321.     WriteRequest -> IOSer . io_Command = CMD_CLEAR;
  322.  
  323.     return((LONG)DoIO(WriteRequest));
  324. }
  325.  
  326.     /* xpr_update(struct XPR_UPDATE *UpdateInfo):
  327.      *
  328.      *    Update the information displayed in the transfer window.
  329.      */
  330.  
  331. LONG __saveds __asm
  332. xpr_update(register __a0 struct XPR_UPDATE *UpdateInfo)
  333. {
  334.     if(!TransferWindow)
  335.     {
  336.         BlockWindows();
  337.  
  338.         LogAction("Initiate binary download.");
  339.  
  340.         if(!TransferPanel("Receive File(s)"))
  341.         {
  342.             ReleaseWindows();
  343.  
  344.             return(0);
  345.         }
  346.     }
  347.  
  348.     if(UpdateInfo)
  349.     {
  350.         if((UpdateInfo -> xpru_updatemask & XPRU_PROTOCOL) && UpdateInfo -> xpru_protocol)
  351.             TransferInfo(20, 0,"%-50.50s",UpdateInfo -> xpru_protocol);
  352.  
  353.         if((UpdateInfo -> xpru_updatemask & XPRU_FILENAME) && UpdateInfo -> xpru_filename)
  354.             TransferInfo(20, 2,"%-50.50s",UpdateInfo -> xpru_filename);
  355.  
  356.         if((UpdateInfo -> xpru_updatemask & XPRU_FILESIZE) && UpdateInfo -> xpru_filesize != -1)
  357.             TransferInfo(20, 3,"%ld",UpdateInfo -> xpru_filesize);
  358.  
  359.         if((UpdateInfo -> xpru_updatemask & XPRU_BYTES) && UpdateInfo -> xpru_bytes != -1)
  360.             TransferInfo(20, 5,"%ld",UpdateInfo -> xpru_bytes);
  361.  
  362.         if((UpdateInfo -> xpru_updatemask & XPRU_BLOCKS) && UpdateInfo -> xpru_blocks != -1)
  363.             TransferInfo(55, 5,"%ld",UpdateInfo -> xpru_blocks);
  364.  
  365.         if((UpdateInfo -> xpru_updatemask & XPRU_BLOCKCHECK) && UpdateInfo -> xpru_blockcheck)
  366.             TransferInfo(20, 6,"%-14.14s",UpdateInfo -> xpru_blockcheck);
  367.  
  368.         if((UpdateInfo -> xpru_updatemask & XPRU_BLOCKSIZE) && UpdateInfo -> xpru_blocksize != -1)
  369.             TransferInfo(55, 6,"%ld",UpdateInfo -> xpru_blocksize);
  370.  
  371.         if((UpdateInfo -> xpru_updatemask & XPRU_EXPECTTIME) && UpdateInfo -> xpru_expecttime)
  372.             TransferInfo(20, 8,"%-14.14s",UpdateInfo -> xpru_expecttime);
  373.  
  374.         if((UpdateInfo -> xpru_updatemask & XPRU_ELAPSEDTIME) && UpdateInfo -> xpru_elapsedtime)
  375.             TransferInfo(55, 8,"%-14.14s",UpdateInfo -> xpru_elapsedtime);
  376.  
  377.         if((UpdateInfo -> xpru_updatemask & XPRU_MSG) && UpdateInfo -> xpru_msg)
  378.             TransferInfo(20,10,"%-50.50s",UpdateInfo -> xpru_msg);
  379.  
  380.         if((UpdateInfo -> xpru_updatemask & XPRU_ERRORMSG) && UpdateInfo -> xpru_errormsg)
  381.             TransferInfo(20,11,"%-50.50s",UpdateInfo -> xpru_errormsg);
  382.  
  383.         if((UpdateInfo -> xpru_updatemask & XPRU_ERRORS) && UpdateInfo -> xpru_errors != -1)
  384.             TransferInfo(20,13,"%ld",UpdateInfo -> xpru_errors);
  385.  
  386.         if((UpdateInfo -> xpru_updatemask & XPRU_TIMEOUTS) && UpdateInfo -> xpru_timeouts != -1)
  387.             TransferInfo(55,13,"%ld",UpdateInfo -> xpru_timeouts);
  388.  
  389.         if((UpdateInfo -> xpru_updatemask & XPRU_PACKETTYPE) && UpdateInfo -> xpru_packettype != -1)
  390.             TransferInfo(20,15,"%ld/%lc",UpdateInfo -> xpru_packettype,UpdateInfo -> xpru_packettype);
  391.  
  392.         if((UpdateInfo -> xpru_updatemask & XPRU_PACKETDELAY) && UpdateInfo -> xpru_packetdelay != -1)
  393.             TransferInfo(55,15,"%ld",UpdateInfo -> xpru_packetdelay);
  394.  
  395.         if((UpdateInfo -> xpru_updatemask & XPRU_DATARATE) && UpdateInfo -> xpru_datarate != -1)
  396.             TransferInfo(20,16,"%ld",UpdateInfo -> xpru_datarate);
  397.  
  398.         if((UpdateInfo -> xpru_updatemask & XPRU_CHARDELAY) && UpdateInfo -> xpru_chardelay != -1)
  399.             TransferInfo(55,16,"%ld",UpdateInfo -> xpru_chardelay);
  400.     }
  401.  
  402.     return(1);
  403. }
  404.  
  405.     /* xpr_chkabort():
  406.      *
  407.      *    Check if the user has aborted the transfer.
  408.      */
  409.  
  410. LONG __saveds
  411. xpr_chkabort()
  412. {
  413.     if(TransferWindow)
  414.     {
  415.         struct IntuiMessage    *Massage;
  416.         ULONG             Class,Code;
  417.         struct Gadget        *Gadget;
  418.  
  419.         while(Massage = (struct IntuiMessage *)GT_GetIMsg(TransferWindow -> UserPort))
  420.         {
  421.             Class    = Massage -> Class;
  422.             Code    = Massage -> Code;
  423.             Gadget    = (struct Gadget *)Massage -> IAddress;
  424.  
  425.             GT_ReplyIMsg(Massage);
  426.  
  427.             if(Class == IDCMP_MENUPICK)
  428.             {
  429.                 struct MenuItem *MenuItem;
  430.  
  431.                 while(Code != MENUNULL)
  432.                 {
  433.                     MenuItem = ItemAddress(TransferMenu,Code);
  434.  
  435.                     switch((ULONG)MENU_USERDATA(MenuItem))
  436.                     {
  437.                         case MEN_ABORT:
  438.                         case MEN_QUITPANEL:    LogAction("Transfer aborted.");
  439.  
  440.                                     return(-1);
  441.  
  442.                                     break;
  443.  
  444.                         case MEN_SKIP:        LogAction("File skipped.");
  445.  
  446.                                     return(1);
  447.  
  448.                         default:        break;
  449.                     }
  450.  
  451.                     Code = MenuItem -> NextSelect;
  452.                 }
  453.             }
  454.  
  455.             if(Class == IDCMP_CLOSEWINDOW)
  456.             {
  457.                 LogAction("Transfer aborted.");
  458.  
  459.                 return(-1);
  460.             }
  461.  
  462.             if(Class == IDCMP_GADGETUP)
  463.             {
  464.                 if(Gadget -> GadgetID == 0)
  465.                 {
  466.                     LogAction("Transfer aborted.");
  467.  
  468.                     return(-1);
  469.                 }
  470.  
  471.                 if(Gadget -> GadgetID == 1)
  472.                 {
  473.                     LogAction("File skipped.");
  474.  
  475.                     return(1);
  476.                 }
  477.             }
  478.         }
  479.     }
  480.  
  481.     return(0);
  482. }
  483.  
  484.     /* The following subroutine creates the gadgets required by
  485.      * xpr_gets().
  486.      */
  487.  
  488. struct Gadget *
  489. CreateAllGetsGadgets(BYTE LoadGadget,UBYTE *String,UBYTE *Prompt,LONG *WindowWidth,struct Gadget **GadgetArray,struct Gadget **GadgetList,APTR VisualInfo,UWORD TopEdge)
  490. {
  491.     struct Gadget        *Gadget;
  492.     struct NewGadget     NewGadget;
  493.     UWORD             Counter = 0;
  494.  
  495.     if(Gadget = CreateContext(GadgetList))
  496.     {
  497.         SHORT Width = strlen(Prompt);
  498.  
  499.         if(Width < 40)
  500.             Width = 40;
  501.  
  502.         NewGadget . ng_Width        = Width * 8 + 6;
  503.         NewGadget . ng_Height        = 12;
  504.         NewGadget . ng_GadgetText    = Prompt;
  505.         NewGadget . ng_TextAttr        = &DefaultFont;
  506.         NewGadget . ng_VisualInfo    = VisualInfo;
  507.         NewGadget . ng_GadgetID        = Counter;
  508.         NewGadget . ng_Flags        = NG_HIGHLABEL|PLACETEXT_ABOVE;
  509.         NewGadget . ng_LeftEdge        = 10;
  510.         NewGadget . ng_TopEdge        = 1 + TopEdge + 8 + 8;
  511.  
  512.         GadgetArray[Counter++] = Gadget = CreateGadget(STRING_KIND,Gadget,&NewGadget,
  513.             GTST_MaxChars,    256,
  514.             GTST_String,    String,
  515.         TAG_DONE);
  516.  
  517.         NewGadget . ng_Width        = 52;
  518.         NewGadget . ng_Height        = 12;
  519.         NewGadget . ng_GadgetText    = "_Okay";
  520.         NewGadget . ng_GadgetID        = Counter;
  521.         NewGadget . ng_Flags        = 0;
  522.         NewGadget . ng_TopEdge        = Gadget -> TopEdge + Gadget -> Height + 3;
  523.  
  524.         GadgetArray[Counter++] = Gadget = CreateGadget(BUTTON_KIND,Gadget,&NewGadget,
  525.             GT_Underscore,    '_',
  526.         TAG_DONE);
  527.  
  528.         if(LoadGadget)
  529.         {
  530.             NewGadget . ng_Width        = 76;
  531.             NewGadget . ng_GadgetText    = "_Load File";
  532.             NewGadget . ng_GadgetID        = Counter;
  533.             NewGadget . ng_LeftEdge        = (Width * 8 + 6 - NewGadget . ng_Width) >> 1;
  534.  
  535.             GadgetArray[Counter] = Gadget = CreateGadget(BUTTON_KIND,Gadget,&NewGadget,
  536.                 GT_Underscore,    '_',
  537.             TAG_DONE);
  538.         }
  539.  
  540.         Counter++;
  541.  
  542.         NewGadget . ng_Width        = 52;
  543.         NewGadget . ng_GadgetText    = "_Cancel";
  544.         NewGadget . ng_GadgetID        = Counter;
  545.         NewGadget . ng_LeftEdge        = GadgetArray[0] -> LeftEdge + GadgetArray[0] -> Width + 6 - NewGadget . ng_Width;
  546.  
  547.         GadgetArray[Counter++] = Gadget = CreateGadget(BUTTON_KIND,Gadget,&NewGadget,
  548.             GT_Underscore,    '_',
  549.         TAG_DONE);
  550.  
  551.         if(Gadget)
  552.         {
  553.             *WindowWidth = GadgetArray[0] -> Width + 32;
  554.  
  555.             DubGadList(GadgetArray[0]);
  556.         }
  557.     }
  558.  
  559.     return(Gadget);
  560. }
  561.  
  562.     /* xpr_gets(UBYTE *Prompt,UBYTE *Buffer):
  563.      *
  564.      *    Prompt the user for string input.
  565.      */
  566.  
  567. LONG __saveds __asm
  568. xpr_gets(register __a0 UBYTE *Prompt,register __a1 UBYTE *Buffer)
  569. {
  570.     struct Gadget    *GadgetList;
  571.     struct Gadget    *GadgetArray[4];
  572.     struct Window    *PanelWindow;
  573.     struct Menu    *PanelMenu;
  574.     LONG         Width,Success = FALSE;
  575.  
  576.     if(!Prompt)
  577.         Prompt = "Input Required";
  578.  
  579.     if(CreateAllGetsGadgets(FALSE,Buffer,Prompt,&Width,&GadgetArray[0],&GadgetList,VisualInfo,Screen -> WBorTop + Screen -> Font -> ta_YSize + 1))
  580.     {
  581.         if(PanelMenu = CreateMenus(GetsMenu,
  582.             GTMN_FrontPen, 0,
  583.         TAG_DONE))
  584.         {
  585.             if(LayoutMenus(PanelMenu,VisualInfo,
  586.                 GTMN_TextAttr,&DefaultFont,
  587.             TAG_DONE))
  588.             {
  589.                 if(PanelWindow = OpenWindowTags(NULL,
  590.                     WA_Width,    Width,
  591.                     WA_Height,    56,
  592.  
  593.                     WA_Left,    (Screen -> Width - Width) >> 1,
  594.                     WA_Top,        (Screen -> Height - 56) >> 1,
  595.  
  596.                     WA_Activate,    TRUE,
  597.                     WA_DragBar,    TRUE,
  598.                     WA_DepthGadget,    TRUE,
  599.                     WA_CloseGadget,    TRUE,
  600.                     WA_RMBTrap,    TRUE,
  601.                     WA_CustomScreen,Screen,
  602.  
  603.                     WA_IDCMP,    IDCMP_GADGETDOWN | IDCMP_ACTIVEWINDOW | IDCMP_CLOSEWINDOW | IDCMP_GADGETUP | IDCMP_MENUPICK | IDCMP_RAWKEY,
  604.  
  605.                     WA_Title,    "Enter A String",
  606.                 TAG_DONE))
  607.                 {
  608.                     struct IntuiMessage    *Massage;
  609.                     ULONG             Class,Code;
  610.                     struct Gadget        *Gadget;
  611.                     BYTE             Terminated = FALSE;
  612.  
  613.                     PushWindow(PanelWindow);
  614.  
  615.                     SetMenuStrip(PanelWindow,PanelMenu);
  616.  
  617.                     PanelWindow -> Flags &= ~WFLG_RMBTRAP;
  618.  
  619.                     AddGList(PanelWindow,GadgetList,(UWORD)-1,(UWORD)-1,NULL);
  620.                     RefreshGList(GadgetList,PanelWindow,NULL,(UWORD)-1);
  621.                     GT_RefreshWindow(PanelWindow,NULL);
  622.  
  623.                     ActiveGadget = GadgetArray[0];
  624.  
  625.                     ActivateGadget(GadgetArray[0],PanelWindow,NULL);
  626.  
  627.                     while(!Terminated)
  628.                     {
  629.                         WaitPort(PanelWindow -> UserPort);
  630.  
  631.                         while(!Terminated && (Massage = (struct IntuiMessage *)GT_GetIMsg(PanelWindow -> UserPort)))
  632.                         {
  633.                             Class    = Massage -> Class;
  634.                             Code    = Massage -> Code;
  635.                             Gadget    = (struct Gadget *)Massage -> IAddress;
  636.  
  637.                             GT_ReplyIMsg(Massage);
  638.  
  639.                             if(Class == IDCMP_GADGETDOWN)
  640.                             {
  641.                                 if((Gadget -> GadgetType & GTYP_GTYPEMASK) == STRGADGET)
  642.                                     ActiveGadget = Gadget;
  643.                             }
  644.  
  645.                             if(Class == IDCMP_RAWKEY)
  646.                             {
  647.                                 if(Code == IECODE_UP_PREFIX|103 && CommandWindow == PanelWindow)
  648.                                     ActivateGadget(CommandGadget,PanelWindow,NULL);
  649.                             }
  650.  
  651.                             if(Class == IDCMP_ACTIVEWINDOW)
  652.                                 ActivateGadget(GadgetArray[0],PanelWindow,NULL);
  653.  
  654.                             if(Class == IDCMP_MENUPICK)
  655.                             {
  656.                                 struct MenuItem *MenuItem;
  657.  
  658.                                 while(Code != MENUNULL)
  659.                                 {
  660.                                     MenuItem = ItemAddress(PanelMenu,Code);
  661.  
  662.                                     switch((ULONG)MENU_USERDATA(MenuItem))
  663.                                     {
  664.                                         case MEN_CANCEL:
  665.                                         case MEN_QUITPANEL:    Class = IDCMP_CLOSEWINDOW;
  666.                                                     break;
  667.  
  668.                                         case MEN_OKAY:        strcpy(Buffer,((struct StringInfo *)GadgetArray[0] -> SpecialInfo) -> Buffer);
  669.  
  670.                                                     Success = TRUE;
  671.  
  672.                                                     Terminated = TRUE;
  673.                                                     break;
  674.                                     }
  675.  
  676.                                     Code = MenuItem -> NextSelect;
  677.                                 }
  678.  
  679.                                 if(ActiveGadget)
  680.                                     ActivateGadget(ActiveGadget,PanelWindow,NULL);
  681.                             }
  682.  
  683.                             if(Class == IDCMP_CLOSEWINDOW)
  684.                                 Terminated = TRUE;
  685.  
  686.                             if(Class == IDCMP_GADGETUP)
  687.                             {
  688.                                 if(!DontActivate)
  689.                                 {
  690.                                     switch(Gadget -> GadgetID)
  691.                                     {
  692.                                         case 0:
  693.                                         case 1:    strcpy(Buffer,((struct StringInfo *)GadgetArray[0] -> SpecialInfo) -> Buffer);
  694.  
  695.                                             Success = TRUE;
  696.  
  697.                                             Terminated = TRUE;
  698.                                             break;
  699.  
  700.                                         case 3:    Terminated = TRUE;
  701.                                             break;
  702.                                     }
  703.                                 }
  704.                                 else
  705.                                     DontActivate = FALSE;
  706.                             }
  707.                         }
  708.                     }
  709.  
  710.                     PanelWindow -> Flags |= WFLG_RMBTRAP;
  711.  
  712.                     ClearMenuStrip(PanelWindow);
  713.  
  714.                     RemoveGList(PanelWindow,GadgetList,(UWORD)-1);
  715.  
  716.                     PopWindow();
  717.  
  718.                     CloseWindow(PanelWindow);
  719.                 }
  720.  
  721.                 FreeGadgets(GadgetList);
  722.             }
  723.  
  724.             FreeMenus(PanelMenu);
  725.         }
  726.     }
  727.  
  728.     return(Success);
  729. }
  730.  
  731.     /* xpr_setserial(LONG Status):
  732.      *
  733.      *    Set/read the serial status (parameters).
  734.      */
  735.  
  736. LONG __saveds __asm
  737. xpr_setserial(register __d0 LONG Status)
  738. {
  739.     STATIC LONG XprBauds[12] =
  740.     {
  741.         110,
  742.         300,
  743.         1200,
  744.         2400,
  745.         4800,
  746.         9600,
  747.         19200,
  748.         31250,
  749.         38400,
  750.         57600,
  751.         76800,
  752.         115200
  753.     };
  754.  
  755.     LONG Return,i;
  756.  
  757.     if(!WriteRequest)
  758.         return(-1);
  759.  
  760.     WriteRequest -> IOSer . io_Command = SDCMD_QUERY;
  761.     DoIO(WriteRequest);
  762.  
  763.     Return = WriteRequest -> io_SerFlags & 0xFF;
  764.  
  765.     if(WriteRequest -> io_ExtFlags & SEXTF_MSPON)
  766.         Return |= ST_PARTYMARKON;
  767.  
  768.     if(WriteRequest -> io_ExtFlags & SEXTF_MARK)
  769.         Return |= ST_PARTYMARK;
  770.  
  771.     if(WriteRequest -> io_StopBits == 2)
  772.         Return |= ST_2BITS;
  773.  
  774.     if(WriteRequest -> io_ReadLen == 7)
  775.         Return |= ST_READ7;
  776.  
  777.     if(WriteRequest -> io_WriteLen == 7)
  778.         Return |= ST_WRITE7;
  779.  
  780.     for(i = 0 ; i < 12 ; i++)
  781.     {
  782.         if(WriteRequest -> io_Baud == XprBauds[i])
  783.         {
  784.             Return |= (i << 16);
  785.  
  786.             break;
  787.         }
  788.     }
  789.  
  790.     if(Status != -1)
  791.     {
  792.         WriteRequest -> IOSer . io_Command    = SDCMD_SETPARAMS;
  793.  
  794.         WriteRequest -> io_SerFlags        = Status & 0xFF;
  795.         WriteRequest -> io_ExtFlags        = 0;
  796.  
  797.         if(Status & ST_PARTYMARKON)
  798.             WriteRequest -> io_ExtFlags |= SEXTF_MSPON;
  799.  
  800.         if(Status & ST_PARTYMARK)
  801.             WriteRequest -> io_ExtFlags |= SEXTF_MARK;
  802.  
  803.         if(Status & ST_2BITS)
  804.             WriteRequest -> io_StopBits = 2;
  805.         else
  806.             WriteRequest -> io_StopBits = 1;
  807.  
  808.         if(Status & ST_READ7)
  809.             WriteRequest -> io_ReadLen = 7;
  810.         else
  811.             WriteRequest -> io_ReadLen = 8;
  812.  
  813.         if(Status & ST_WRITE7)
  814.             WriteRequest -> io_WriteLen = 7;
  815.         else
  816.             WriteRequest -> io_WriteLen = 8;
  817.  
  818.         DoIO(WriteRequest);
  819.  
  820.         ReadRequest -> io_SerFlags    = WriteRequest -> io_SerFlags;
  821.         ReadRequest -> io_ExtFlags    = WriteRequest -> io_ExtFlags;
  822.  
  823.         ReadRequest -> io_StopBits    = WriteRequest -> io_StopBits;
  824.         ReadRequest -> io_ReadLen    = WriteRequest -> io_ReadLen;
  825.         ReadRequest -> io_WriteLen    = WriteRequest -> io_WriteLen;
  826.     }
  827.  
  828.     return(Return);
  829. }
  830.  
  831.     /* xpr_ffirst(UBYTE *Buffer,UBYTE *Pattern):
  832.      *
  833.      *    Batch file upload: find the first matching file and return
  834.      *    its name.
  835.      */
  836.  
  837. LONG __saveds __asm
  838. xpr_ffirst(register __a0 UBYTE *Buffer,register __a1 UBYTE *Pattern)
  839. {
  840.     if(MultipleFiles)
  841.     {
  842.         FileCount = 0;
  843.  
  844.         strcpy(Buffer,FileArg[FileCount++] . wa_Name);
  845.  
  846.         return(1);
  847.     }
  848.     else
  849.     {
  850.         FileMatch = TRUE;
  851.  
  852.         if(!MatchFirst(Pattern,FileAnchor))
  853.         {
  854.             if(FileAnchor -> ap_Info . fib_DirEntryType < 0)
  855.             {
  856.                 strcpy(Buffer,FileAnchor -> ap_Info . fib_FileName);
  857.  
  858.                 return(1);
  859.             }
  860.             else
  861.             {
  862.                 while(!MatchNext(FileAnchor))
  863.                 {
  864.                     if(FileAnchor -> ap_Info . fib_DirEntryType < 0)
  865.                     {
  866.                         strcpy(Buffer,FileAnchor -> ap_Info . fib_FileName);
  867.  
  868.                         return(1);
  869.                     }
  870.                 }
  871.             }
  872.         }
  873.     }
  874.  
  875.     return(0);
  876. }
  877.  
  878.     /* xpr_fnext(LONG OldState,UBYTE *Buffer,UBYTE *Pattern):
  879.      *
  880.      *    Batch file upload: find the next matching file
  881.      *    - if any - and return its name.
  882.      */
  883.  
  884. LONG __saveds __asm
  885. xpr_fnext(register __d0 LONG OldState,register __a0 UBYTE *Buffer,register __a1 UBYTE *Pattern)
  886. {
  887.     if(MultipleFiles)
  888.     {
  889.         if(FileCount < FileCountMax)
  890.         {
  891.             strcpy(Buffer,FileArg[FileCount++] . wa_Name);
  892.             return(1);
  893.         }
  894.     }
  895.     else
  896.     {
  897.         while(!MatchNext(FileAnchor))
  898.         {
  899.             if(FileAnchor -> ap_Info . fib_DirEntryType < 0)
  900.             {
  901.                 strcpy(Buffer,FileAnchor -> ap_Info . fib_FileName);
  902.                 return(1);
  903.             }
  904.         }
  905.     }
  906.  
  907.     return(0);
  908. }
  909.  
  910.     /* xpr_finfo(UBYTE *FileName,LONG InfoType):
  911.      *
  912.      *    Return information on a given file.
  913.      */
  914.  
  915. LONG __saveds __asm
  916. xpr_finfo(register __a0 UBYTE *FileName,register __d0 LONG InfoType)
  917. {
  918.     struct FileInfoBlock    *FileInfo;
  919.     BPTR             FileLock;
  920.  
  921.     if(InfoType == 1)
  922.     {
  923.         LONG Size = 0;
  924.  
  925.         if(FileInfo = AllocMem(sizeof(struct FileInfoBlock),MEMF_PUBLIC))
  926.         {
  927.             if(FileLock = Lock(FileName,ACCESS_READ))
  928.             {
  929.                 if(Examine(FileLock,FileInfo))
  930.                     Size = FileInfo -> fib_Size;
  931.  
  932.                 UnLock(FileLock);
  933.             }
  934.  
  935.             FreeMem(FileInfo,sizeof(struct FileInfoBlock));
  936.         }
  937.  
  938.         return(Size);
  939.     }
  940.  
  941.     if(InfoType == 2)
  942.         return(BinaryTransfer ? 1 : 2);
  943. }
  944.  
  945.     /* xpr_fseek(BPTR File,LONG Offset,LONG Origin):
  946.      *
  947.      *    Move the read/write pointer in a file.
  948.      */
  949.  
  950. LONG __saveds __asm
  951. xpr_fseek(register __a0 BPTR File,register __d0 LONG Offset,register __d1 LONG Origin)
  952. {
  953.     switch(Origin)
  954.     {
  955.         case 0:    Origin = OFFSET_BEGINNING;
  956.             break;
  957.  
  958.         case 1:    Origin = OFFSET_CURRENT;
  959.             break;
  960.  
  961.         case 2:    Origin = OFFSET_END;
  962.             break;
  963.  
  964.         default:return(-1);
  965.     }
  966.  
  967.     if(Seek(File,Offset,Origin) == -1)
  968.         return(-1);
  969.     else
  970.         return(0);
  971. }
  972.  
  973.     /* The following routines are to support the xpr_options function. */
  974.  
  975. STATIC BYTE
  976. GetOptionMode(struct xpr_option *Option)
  977. {
  978.     if(Option)
  979.     {
  980.         if(!StrCmp(Option -> xpro_value,"OFF"))
  981.             return(FALSE);
  982.  
  983.         if(!StrCmp(Option -> xpro_value,"FALSE"))
  984.             return(FALSE);
  985.  
  986.         if(!StrCmp(Option -> xpro_value,"F"))
  987.             return(FALSE);
  988.  
  989.         if(!StrCmp(Option -> xpro_value,"NO"))
  990.             return(FALSE);
  991.  
  992.         if(!StrCmp(Option -> xpro_value,"N"))
  993.             return(FALSE);
  994.  
  995.  
  996.         if(!StrCmp(Option -> xpro_value,"ON"))
  997.             return(TRUE);
  998.  
  999.         if(!StrCmp(Option -> xpro_value,"TRUE"))
  1000.             return(TRUE);
  1001.  
  1002.         if(!StrCmp(Option -> xpro_value,"T"))
  1003.             return(TRUE);
  1004.  
  1005.         if(!StrCmp(Option -> xpro_value,"YES"))
  1006.             return(TRUE);
  1007.  
  1008.         if(!StrCmp(Option -> xpro_value,"Y"))
  1009.             return(TRUE);
  1010.     }
  1011.  
  1012.     return(FALSE);
  1013. }
  1014.  
  1015. STATIC struct Gadget *
  1016. CreateAllOptionGadgets(LONG *Count,LONG *Width,LONG *Height,LONG NumOpts,struct xpr_option *Opts[],struct Gadget *GadgetArray[],struct Gadget **GadgetList,APTR VisualInfo,UWORD TopEdge)
  1017. {
  1018.     struct Gadget        *Gadget;
  1019.     struct NewGadget     NewGadget;
  1020.     LONG             i,MaxLength = 0,AddTop = 0;
  1021.  
  1022.     *Count = 0;
  1023.  
  1024.     if(Gadget = CreateContext(GadgetList))
  1025.     {
  1026.         NewGadget . ng_TopEdge        = 1 + TopEdge - 2;
  1027.         NewGadget . ng_Height        = 12;
  1028.         NewGadget . ng_Width        = 208;
  1029.  
  1030.         NewGadget . ng_TextAttr        = &DefaultFont;
  1031.         NewGadget . ng_VisualInfo    = VisualInfo;
  1032.         NewGadget . ng_Flags        = NG_HIGHLABEL;
  1033.  
  1034.         for(i = 0 ; i < NumOpts ; i++)
  1035.         {
  1036.             if(!Opts[i])
  1037.                 continue;
  1038.  
  1039.             switch(Opts[i] -> xpro_type)
  1040.             {
  1041.                 case XPRO_BOOLEAN:
  1042.  
  1043.                     NewGadget . ng_GadgetText    = Opts[i] -> xpro_description;
  1044.                     NewGadget . ng_GadgetID        = i;
  1045.                     NewGadget . ng_LeftEdge        = 218;
  1046.                     NewGadget . ng_TopEdge        = NewGadget . ng_TopEdge + AddTop;
  1047.  
  1048.                     GadgetArray[i] = Gadget = CreateGadget(CHECKBOX_KIND,Gadget,&NewGadget,
  1049.                         GTCB_Checked,GetOptionMode(Opts[i]),
  1050.                     TAG_DONE);
  1051.  
  1052.                     if(Gadget)
  1053.                         AddTop = Gadget -> Height + 1;
  1054.  
  1055.                     break;
  1056.  
  1057.                 case XPRO_LONG:
  1058.  
  1059.                     NewGadget . ng_GadgetText    = Opts[i] -> xpro_description;
  1060.                     NewGadget . ng_GadgetID        = i;
  1061.                     NewGadget . ng_LeftEdge        = 218;
  1062.                     NewGadget . ng_TopEdge        = NewGadget . ng_TopEdge + AddTop;
  1063.  
  1064.                     GadgetArray[i] = Gadget = CreateGadget(INTEGER_KIND,Gadget,&NewGadget,
  1065.                         GTIN_Number,atol(Opts[i] -> xpro_value),
  1066.                     TAG_DONE);
  1067.  
  1068.                     AddTop = 13;
  1069.  
  1070.                     break;
  1071.  
  1072.                 case XPRO_STRING:
  1073.                 case XPRO_COMMPAR:
  1074.  
  1075.                     NewGadget . ng_GadgetText    = Opts[i] -> xpro_description;
  1076.                     NewGadget . ng_GadgetID        = i;
  1077.                     NewGadget . ng_LeftEdge        = 218;
  1078.                     NewGadget . ng_TopEdge        = NewGadget . ng_TopEdge + AddTop;
  1079.  
  1080.                     GadgetArray[i] = Gadget = CreateGadget(STRING_KIND,Gadget,&NewGadget,
  1081.                         GTST_String,    Opts[i] -> xpro_value,
  1082.                         GTST_MaxChars,    Opts[i] -> xpro_length,
  1083.                     TAG_DONE);
  1084.  
  1085.                     AddTop = 13;
  1086.  
  1087.                     break;
  1088.  
  1089.                 case XPRO_HEADER:
  1090.  
  1091.                     NewGadget . ng_GadgetText    = "";
  1092.                     NewGadget . ng_GadgetID        = i;
  1093.                     NewGadget . ng_LeftEdge        = 10;
  1094.                     NewGadget . ng_TopEdge        = NewGadget . ng_TopEdge + AddTop;
  1095.  
  1096.                     GadgetArray[i] = Gadget = CreateGadget(TEXT_KIND,Gadget,&NewGadget,
  1097.                         GTTX_Text,Opts[i] -> xpro_description,
  1098.                     TAG_DONE);
  1099.  
  1100.                     AddTop = 11;
  1101.  
  1102.                     break;
  1103.  
  1104.                 case XPRO_COMMAND:
  1105.  
  1106.                     NewGadget . ng_GadgetText    = Opts[i] -> xpro_description;
  1107.                     NewGadget . ng_GadgetID        = i;
  1108.                     NewGadget . ng_LeftEdge        = 10;
  1109.                     NewGadget . ng_TopEdge        = NewGadget . ng_TopEdge + 13;
  1110.  
  1111.                     GadgetArray[i] = Gadget = CreateGadget(BUTTON_KIND,Gadget,&NewGadget,
  1112.                         TAG_DONE);
  1113.  
  1114.                     if(Gadget)
  1115.                         AddTop = Gadget -> Height + 1;
  1116.  
  1117.                     MaxLength = 25;
  1118.  
  1119.                     break;
  1120.  
  1121.                 default:break;
  1122.             }
  1123.  
  1124.             if(Gadget)
  1125.             {
  1126.                 if(strlen(NewGadget . ng_GadgetText) > MaxLength)
  1127.                     MaxLength = strlen(NewGadget . ng_GadgetText);
  1128.             }
  1129.         }
  1130.  
  1131.         NewGadget . ng_GadgetText    = "Current Protocol";
  1132.         NewGadget . ng_GadgetID        = 32;
  1133.         NewGadget . ng_LeftEdge        = 218;
  1134.         NewGadget . ng_TopEdge        = NewGadget . ng_TopEdge + AddTop + 2;
  1135.  
  1136.         GadgetArray[i++] = Gadget = CreateGadget(STRING_KIND,Gadget,&NewGadget,
  1137.             GTST_MaxChars,    40,
  1138.             GTST_String,    LastXprLibrary,
  1139.         TAG_DONE);
  1140.  
  1141.         NewGadget . ng_GadgetText    = "Select New _Protocol";
  1142.         NewGadget . ng_GadgetID        = 33;
  1143.         NewGadget . ng_TopEdge        = NewGadget . ng_TopEdge + 13;
  1144.  
  1145.         GadgetArray[i++] = Gadget = CreateGadget(BUTTON_KIND,Gadget,&NewGadget,
  1146.             GT_Underscore,    '_',
  1147.         TAG_DONE);
  1148.  
  1149.         if(Gadget)
  1150.         {
  1151.             *Height = Gadget -> TopEdge + Gadget -> Height + 3;
  1152.  
  1153.             if(MaxLength < 16)
  1154.                 MaxLength = 16;
  1155.  
  1156.             if(MaxLength < 25)
  1157.             {
  1158.                 LONG j;
  1159.  
  1160.                 MaxLength = (25 - MaxLength) * 8;
  1161.  
  1162.                 for(j = 0 ; j < NumOpts ; j++)
  1163.                 {
  1164.                     if(Opts[j] && GadgetArray[j])
  1165.                     {
  1166.                         if(Opts[j] -> xpro_type != XPRO_HEADER)
  1167.                             GadgetArray[j] -> LeftEdge -= MaxLength;
  1168.                     }
  1169.                 }
  1170.  
  1171.                 GadgetArray[i - 1] -> LeftEdge -= MaxLength;
  1172.                 GadgetArray[i - 2] -> LeftEdge -= MaxLength;
  1173.             }
  1174.  
  1175.             *Width = Gadget -> LeftEdge + Gadget -> Width + 10;
  1176.  
  1177.             *Count = i;
  1178.         }
  1179.     }
  1180.  
  1181.     DubGadList(GadgetArray[0]);
  1182.  
  1183.     return(Gadget);
  1184. }
  1185.  
  1186.     /* xpr_options(LONG NumOpts,struct xpr_option **Opts):
  1187.      *
  1188.      *    Provide a more polished user interface to set the
  1189.      *    transfer protocol options.
  1190.      */
  1191.  
  1192. ULONG __saveds __asm
  1193. xpr_options(register __d0 LONG NumOpts,register __a0 struct xpr_option **Opts)
  1194. {
  1195.     struct Gadget    *GadgetList;
  1196.     struct Gadget    *GadgetArray[33];
  1197.     struct Window    *PanelWindow;
  1198.     struct Menu    *PanelMenu;
  1199.     LONG         Width,Height,i,Count;
  1200.  
  1201.     ULONG         Flags = 0;
  1202.  
  1203.     if(CreateAllOptionGadgets(&Count,&Width,&Height,NumOpts,Opts,&GadgetArray[0],&GadgetList,VisualInfo,Screen -> WBorTop + Screen -> Font -> ta_YSize + 1))
  1204.     {
  1205.         if(PanelMenu = CreateMenus(OptionsMenu,
  1206.             GTMN_FrontPen, 0,
  1207.         TAG_DONE))
  1208.         {
  1209.             if(LayoutMenus(PanelMenu,VisualInfo,
  1210.                 GTMN_TextAttr,&DefaultFont,
  1211.             TAG_DONE))
  1212.             {
  1213.                 if(PanelWindow = OpenWindowTags(NULL,
  1214.                     WA_Width,    Width,
  1215.                     WA_Height,    Height,
  1216.  
  1217.                     WA_Left,    (Screen -> Width - Width) >> 1,
  1218.                     WA_Top,        (Screen -> Height - Height) >> 1,
  1219.  
  1220.                     WA_Activate,    TRUE,
  1221.                     WA_DragBar,    TRUE,
  1222.                     WA_DepthGadget,    TRUE,
  1223.                     WA_CloseGadget,    TRUE,
  1224.                     WA_RMBTrap,    TRUE,
  1225.                     WA_CustomScreen,Screen,
  1226.  
  1227.                     WA_IDCMP,    IDCMP_GADGETDOWN | IDCMP_ACTIVEWINDOW | IDCMP_CLOSEWINDOW | CHECKBOXIDCMP | IDCMP_MENUPICK | IDCMP_RAWKEY,
  1228.  
  1229.                     WA_Title,    "Transfer Preferences",
  1230.                 TAG_DONE))
  1231.                 {
  1232.                     struct IntuiMessage    *Massage;
  1233.                     ULONG             Class,Code;
  1234.                     struct Gadget        *Gadget;
  1235.                     BYTE             Terminated = FALSE;
  1236.  
  1237.                     PushWindow(PanelWindow);
  1238.  
  1239.                     SetMenuStrip(PanelWindow,PanelMenu);
  1240.  
  1241.                     PanelWindow -> Flags &= ~WFLG_RMBTRAP;
  1242.  
  1243.                     AddGList(PanelWindow,GadgetList,(UWORD)-1,(UWORD)-1,NULL);
  1244.                     RefreshGList(GadgetList,PanelWindow,NULL,(UWORD)-1);
  1245.                     GT_RefreshWindow(PanelWindow,NULL);
  1246.  
  1247.                     for(i = 0 ; i < Count ; i++)
  1248.                     {
  1249.                         if((GadgetArray[i] -> GadgetType & GTYP_GTYPEMASK) == GTYP_STRGADGET)
  1250.                         {
  1251.                             ActivateGadget(GadgetArray[i],PanelWindow,NULL);
  1252.  
  1253.                             ActiveGadget = GadgetArray[i];
  1254.  
  1255.                             break;
  1256.                         }
  1257.                     }
  1258.  
  1259.                     while(!Terminated)
  1260.                     {
  1261.                         WaitPort(PanelWindow -> UserPort);
  1262.  
  1263.                         while(!Terminated && (Massage = (struct IntuiMessage *)GT_GetIMsg(PanelWindow -> UserPort)))
  1264.                         {
  1265.                             Class    = Massage -> Class;
  1266.                             Code    = Massage -> Code;
  1267.                             Gadget    = (struct Gadget *)Massage -> IAddress;
  1268.  
  1269.                             GT_ReplyIMsg(Massage);
  1270.  
  1271.                             if(Class == IDCMP_GADGETDOWN)
  1272.                             {
  1273.                                 if((Gadget -> GadgetType & GTYP_GTYPEMASK) == GTYP_STRGADGET)
  1274.                                     ActiveGadget = Gadget;
  1275.                             }
  1276.  
  1277.                             if(Class == IDCMP_RAWKEY)
  1278.                             {
  1279.                                 if(Code == IECODE_UP_PREFIX|103 && CommandWindow == PanelWindow)
  1280.                                     ActivateGadget(CommandGadget,PanelWindow,NULL);
  1281.                             }
  1282.  
  1283.                             if(Class == IDCMP_ACTIVEWINDOW && ActiveGadget)
  1284.                                 ActivateGadget(ActiveGadget,PanelWindow,NULL);
  1285.  
  1286.                             if(Class == IDCMP_MENUPICK)
  1287.                             {
  1288.                                 struct MenuItem *MenuItem;
  1289.  
  1290.                                 while(Code != MENUNULL)
  1291.                                 {
  1292.                                     MenuItem = ItemAddress(PanelMenu,Code);
  1293.  
  1294.                                     switch((ULONG)MENU_USERDATA(MenuItem))
  1295.                                     {
  1296.                                         case MEN_QUITPANEL:    Class = IDCMP_CLOSEWINDOW;
  1297.                                                     break;
  1298.  
  1299.                                         case MEN_NEWLIB:    Class = IDCMP_GADGETUP;
  1300.                                                     Gadget = GadgetArray[Count - 1];
  1301.                                                     break;
  1302.                                     }
  1303.  
  1304.                                     Code = MenuItem -> NextSelect;
  1305.                                 }
  1306.  
  1307.                                 if(ActiveGadget)
  1308.                                     ActivateGadget(ActiveGadget,PanelWindow,NULL);
  1309.                             }
  1310.  
  1311.                             if(Class == IDCMP_CLOSEWINDOW)
  1312.                             {
  1313.                                 for(i = 0 ; i < NumOpts ; i++)
  1314.                                 {
  1315.                                     switch(Opts[i] -> xpro_type)
  1316.                                     {
  1317.                                         case XPRO_BOOLEAN:    if(((GadgetArray[i] -> Flags & GFLG_SELECTED) && !GetOptionMode(Opts[i])) || (!(GadgetArray[i] -> Flags & GFLG_SELECTED) && GetOptionMode(Opts[i])))
  1318.                                                     {
  1319.                                                         Flags |= (i << i);
  1320.  
  1321.                                                         if(GadgetArray[i] -> Flags & GFLG_SELECTED)
  1322.                                                             strcpy(Opts[i] -> xpro_value,"yes");
  1323.                                                         else
  1324.                                                             strcpy(Opts[i] -> xpro_value,"no");
  1325.  
  1326.                                                         NewOptions = TRUE;
  1327.                                                     }
  1328.                                                     break;
  1329.  
  1330.                                         case XPRO_LONG:
  1331.                                         case XPRO_STRING:
  1332.                                         case XPRO_COMMPAR:    if(strcmp(Opts[i] -> xpro_value,((struct StringInfo *)GadgetArray[i] -> SpecialInfo) -> Buffer))
  1333.                                                     {
  1334.                                                         Flags |= (i << i);
  1335.  
  1336.                                                         strcpy(Opts[i] -> xpro_value,((struct StringInfo *)GadgetArray[i] -> SpecialInfo) -> Buffer);
  1337.  
  1338.                                                         NewOptions = TRUE;
  1339.                                                     }
  1340.                                                     break;
  1341.                                     }
  1342.                                 }
  1343.  
  1344.                                 Terminated = TRUE;
  1345.                             }
  1346.  
  1347.                             if(Class == IDCMP_GADGETUP)
  1348.                             {
  1349.                                 if(Gadget -> GadgetID < NumOpts)
  1350.                                 {
  1351.                                     if(Opts[Gadget -> GadgetID] -> xpro_type == XPRO_COMMAND)
  1352.                                     {
  1353.                                         Flags |= (1 << Gadget -> GadgetID);
  1354.  
  1355.                                         Terminated = TRUE;
  1356.                                     }
  1357.                                 }
  1358.  
  1359.                                 if(Gadget -> GadgetID == 32)
  1360.                                 {
  1361.                                     if(strcmp(LastXprLibrary,((struct StringInfo *)Gadget -> SpecialInfo) -> Buffer))
  1362.                                     {
  1363.                                         strcpy(LastXprLibrary,((struct StringInfo *)Gadget -> SpecialInfo) -> Buffer);
  1364.                                         NewLibrary = TRUE;
  1365.                                     }
  1366.                                 }
  1367.  
  1368.                                 if(Gadget -> GadgetID == 33)
  1369.                                 {
  1370.                                     struct FileRequester *AslFileRequest;
  1371.  
  1372.                                     if(AslFileRequest = (struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
  1373.                                         ASL_Window,    PanelWindow,
  1374.                                         ASL_File,    ((struct StringInfo *)GadgetArray[NumOpts] -> SpecialInfo) -> Buffer,
  1375.                                         ASL_Dir,    "LIBS:",
  1376.                                         ASL_Hail,    "Select Transfer Protocol",
  1377.                                         ASL_FuncFlags,    0,
  1378.                                         ASL_Pattern,    "xpr#?.library",
  1379.                                         ASL_OKText,    "Select",
  1380.                                     TAG_END))
  1381.                                     {
  1382.                                         SetWait(PanelWindow);
  1383.                                         PanelWindow -> Flags |= WFLG_RMBTRAP;
  1384.  
  1385.                                         if(AslRequestTags(AslFileRequest,TAG_DONE))
  1386.                                         {
  1387.                                             if(AslFileRequest -> rf_File[0])
  1388.                                             {
  1389.                                                 if(strcmp(AslFileRequest -> rf_File,((struct StringInfo *)GadgetArray[NumOpts] -> SpecialInfo) -> Buffer))
  1390.                                                 {
  1391.                                                     GT_SetGadgetAttrs(GadgetArray[NumOpts],PanelWindow,NULL,
  1392.                                                         GTST_String,AslFileRequest -> rf_File,
  1393.                                                     TAG_DONE);
  1394.  
  1395.                                                     strcpy(LastXprLibrary,AslFileRequest -> rf_File);
  1396.  
  1397.                                                     NewLibrary = TRUE;
  1398.                                                 }
  1399.                                             }
  1400.                                         }
  1401.  
  1402.                                         ClearPointer(PanelWindow);
  1403.                                         PanelWindow -> Flags &= ~WFLG_RMBTRAP;
  1404.  
  1405.                                         FreeAslRequest(AslFileRequest);
  1406.                                     }
  1407.                                 }
  1408.                             }
  1409.                         }
  1410.                     }
  1411.  
  1412.                     PanelWindow -> Flags |= WFLG_RMBTRAP;
  1413.  
  1414.                     ClearMenuStrip(PanelWindow);
  1415.  
  1416.                     RemoveGList(PanelWindow,GadgetList,(UWORD)-1);
  1417.  
  1418.                     PopWindow();
  1419.  
  1420.                     CloseWindow(PanelWindow);
  1421.                 }
  1422.             }
  1423.  
  1424.             FreeMenus(PanelMenu);
  1425.         }
  1426.  
  1427.         FreeGadgets(GadgetList);
  1428.     }
  1429.  
  1430.     return(Flags);
  1431. }
  1432.  
  1433.     /* xpr_unlink(UBYTE *FileName):
  1434.      *
  1435.      *    Remove (delete) a given file.
  1436.      */
  1437.  
  1438. LONG __saveds __asm
  1439. xpr_unlink(register __a0 UBYTE *FileName)
  1440. {
  1441.     LONG Success = DeleteFile(FileName) ? 0 : -1;
  1442.  
  1443.     if(Success)
  1444.         LogAction("Delete file \"%s\".",FileName);
  1445.  
  1446.     return(Success);
  1447. }
  1448.  
  1449.     /* xpr_squery():
  1450.      *
  1451.      *    Check how many characters are present in the serial buffer.
  1452.      */
  1453.  
  1454. LONG __saveds
  1455. xpr_squery()
  1456. {
  1457.     if(!WriteRequest)
  1458.         return(-1);
  1459.  
  1460.     WriteRequest -> IOSer . io_Command = SDCMD_QUERY;
  1461.  
  1462.     if(!DoIO(WriteRequest))
  1463.         return((LONG)WriteRequest -> IOSer . io_Actual);
  1464.     else
  1465.         return(-1);
  1466. }
  1467.  
  1468.     /* xpr_getptr(LONG InfoType):
  1469.      *
  1470.      *    Return a pointer to the term custom screen.
  1471.      */
  1472.  
  1473. LONG __saveds __asm
  1474. xpr_getptr(register __d0 LONG InfoType)
  1475. {
  1476.     if(InfoType == 1)
  1477.         return((LONG)Screen);
  1478.     else
  1479.         return(-1);
  1480. }
  1481.  
  1482.     /* xpr_stealopts(UBYTE *Prompt,UBYTE *Buffer):
  1483.      *
  1484.      *    Steal the contents of the options buffer (replacement
  1485.      *    for xpr_gets).
  1486.      */
  1487.  
  1488. LONG __saveds __asm
  1489. xpr_stealopts(register __a0 UBYTE *Prompt,register __a1 UBYTE *Buffer)
  1490. {
  1491.     if(Buffer)
  1492.         strcpy(ProtocolOptsBuffer,Buffer);
  1493.  
  1494.     return(1);
  1495. }
  1496.  
  1497.     /* ProtocolSetup():
  1498.      *
  1499.      *    Set up the library and options for the external protocol.
  1500.      */
  1501.  
  1502. BYTE
  1503. ProtocolSetup()
  1504. {
  1505.     UBYTE NameBuffer[40],TestBuffer[40],i;
  1506.  
  1507.         /* Close the old library if still open. */
  1508.  
  1509.     if(XProtocolBase)
  1510.     {
  1511.         XProtocolCleanup(XprIO);
  1512.  
  1513.         CloseLibrary(XProtocolBase);
  1514.     }
  1515.  
  1516.         /* Clear the XPR interface buffer. */
  1517.  
  1518.     memset(XprIO,0,sizeof(struct XPR_IO));
  1519.  
  1520.         /* Copy the name of the library. */
  1521.  
  1522.     strcpy(NameBuffer,FilePart(LastXprLibrary));
  1523.  
  1524.         /* Extract the name itself (strip the `.library'). */
  1525.  
  1526.     for(i = strlen(NameBuffer) - 1 ; i >= 0 ; i--)
  1527.     {
  1528.         if(NameBuffer[i] == '.')
  1529.         {
  1530.             NameBuffer[i] = 0;
  1531.             break;
  1532.         }
  1533.     }
  1534.  
  1535.         /* Copy the result to the test buffer and check
  1536.          * if the transfer protocol is a sort of ZModem.
  1537.          */
  1538.  
  1539.     strcpy(TestBuffer,&NameBuffer[3]);
  1540.  
  1541.     TestBuffer[6] = 0;
  1542.  
  1543.     if(!StrCmp(TestBuffer,"zmodem"))
  1544.         UsesZModem = TRUE;
  1545.     else
  1546.         UsesZModem = FALSE;
  1547.  
  1548.         /* Obtain the protocol default settings. */
  1549.  
  1550.     if(!GetEnvDOS(NameBuffer,ProtocolOptsBuffer))
  1551.         ProtocolOptsBuffer[0] = 0;
  1552.  
  1553.         /* Initialize the interface structure. */
  1554.  
  1555.     XprIO -> xpr_filename    = ProtocolOptsBuffer;
  1556.     XprIO -> xpr_fopen    = (APTR)xpr_fopen;
  1557.     XprIO -> xpr_fclose    = (APTR)xpr_fclose;
  1558.     XprIO -> xpr_fread    = (APTR)xpr_fread;
  1559.     XprIO -> xpr_fwrite    = (APTR)xpr_fwrite;
  1560.     XprIO -> xpr_sread    = (APTR)xpr_sread;
  1561.     XprIO -> xpr_swrite    = (APTR)xpr_swrite;
  1562.     XprIO -> xpr_sflush    = (APTR)xpr_sflush;
  1563.     XprIO -> xpr_update    = (APTR)xpr_update;
  1564.     XprIO -> xpr_chkabort    = (APTR)xpr_chkabort;
  1565.     XprIO -> xpr_gets    = (APTR)xpr_gets;
  1566.     XprIO -> xpr_setserial    = (APTR)xpr_setserial;
  1567.     XprIO -> xpr_ffirst    = (APTR)xpr_ffirst;
  1568.     XprIO -> xpr_fnext    = (APTR)xpr_fnext;
  1569.     XprIO -> xpr_finfo    = (APTR)xpr_finfo;
  1570.     XprIO -> xpr_fseek    = (APTR)xpr_fseek;
  1571.     XprIO -> xpr_extension    = 4;
  1572.     XprIO -> xpr_options    = (APTR)xpr_options;
  1573.     XprIO -> xpr_unlink    = (APTR)xpr_unlink;
  1574.     XprIO -> xpr_squery    = (APTR)xpr_squery;
  1575.     XprIO -> xpr_getptr    = (APTR)xpr_getptr;
  1576.  
  1577.         /* Try to open the library. */
  1578.  
  1579.     if(XProtocolBase = (struct Library *)OpenLibrary(LastXprLibrary,0))
  1580.     {
  1581.             /* Set up the library. */
  1582.  
  1583.         TransferBits = XProtocolSetup(XprIO);
  1584.  
  1585.             /* Successful initialization? */
  1586.  
  1587.         if(!(TransferBits & XPRS_SUCCESS))
  1588.         {
  1589.             MyEasyRequest(Window,"Failed to set up protocol\n\"%s\"!","Continue",LastXprLibrary);
  1590.  
  1591.             CloseLibrary(XProtocolBase);
  1592.  
  1593.             XProtocolBase = NULL;
  1594.  
  1595.             LastXprLibrary[0] = 0;
  1596.  
  1597.             TransferBits = 0;
  1598.  
  1599.             return(FALSE);
  1600.         }
  1601.     }
  1602.     else
  1603.         MyEasyRequest(Window,"Failed to open protocol\n\"%s\"!","Continue",LastXprLibrary);
  1604.  
  1605.     return(TRUE);
  1606. }
  1607.  
  1608.     /* SaveProtocolOpts():
  1609.      *
  1610.      *    Save the current protocol settings to an environment variable.
  1611.      */
  1612.  
  1613. VOID
  1614. SaveProtocolOpts()
  1615. {
  1616.         /* It's time to save the altered options. */
  1617.  
  1618.     if(NewOptions)
  1619.     {
  1620.         UBYTE NameBuffer[60],i;
  1621.  
  1622.             /* Strip the `.library' part. */
  1623.  
  1624.         strcpy(NameBuffer,LastXprLibrary);
  1625.  
  1626.         for(i = strlen(NameBuffer) - 1 ; i >= 0 ; i--)
  1627.         {
  1628.             if(NameBuffer[i] == '.')
  1629.             {
  1630.                 NameBuffer[i] = 0;
  1631.                 break;
  1632.             }
  1633.         }
  1634.  
  1635.             /* Cause the xpr.library to prompt for
  1636.              * input. We expect the library to fill
  1637.              * the prompt string with the default
  1638.              * settings. The resulting string is
  1639.              * intercepted by xpr_stealopts, saved
  1640.              * to an environment variable and will
  1641.              * serve as a reinitialization string
  1642.              * later.
  1643.              */
  1644.  
  1645.         XprIO -> xpr_filename    = NULL;
  1646.         XprIO -> xpr_gets    = (APTR)xpr_stealopts;
  1647.         XprIO -> xpr_extension    = 4;
  1648.         XprIO -> xpr_options    = (APTR)NULL;
  1649.  
  1650.         XProtocolSetup(XprIO);
  1651.  
  1652.             /* Save the options in case anything goes
  1653.              * wrong.
  1654.              */
  1655.  
  1656.         NewOptions = FALSE;
  1657.  
  1658.         SetEnvDOS(NameBuffer,ProtocolOptsBuffer);
  1659.  
  1660.             /* Reinitialize the library. */
  1661.  
  1662.         XprIO -> xpr_filename    = ProtocolOptsBuffer;
  1663.         XprIO -> xpr_gets    = (APTR)xpr_gets;
  1664.         XprIO -> xpr_extension    = 4;
  1665.         XprIO -> xpr_options    = (APTR)xpr_options;
  1666.  
  1667.         XProtocolSetup(XprIO);
  1668.     }
  1669. }
  1670.