home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / communication / bbs / termv4.6 / extras / source / term-source.lha / TransferPanel.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-03-18  |  15.2 KB  |  695 lines
  1. /*
  2. **    TransferPanel.c
  3. **
  4. **    File transfer control panel support routines
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. **
  9. **    :ts=4
  10. */
  11.  
  12. #ifndef _GLOBAL_H
  13. #include "Global.h"
  14. #endif
  15.  
  16. STATIC BYTE LastStatus            = -1;
  17. STATIC LONG TransferInfoCount    = 0;
  18.  
  19. STATIC ULONG __saveds __asm
  20. TransferListViewRender(REG(a0) struct Hook *Hook,REG(a1) struct LVDrawMsg *Msg,REG(a2) struct Node *Node)
  21. {
  22.         /* We only know how to redraw lines. */
  23.  
  24.     if(Msg->lvdm_MethodID == LV_DRAW)
  25.     {
  26.         struct RastPort    *RPort    = Msg->lvdm_RastPort;
  27.         LONG             Left    = Msg->lvdm_Bounds.MinX,
  28.                          Top    = Msg->lvdm_Bounds.MinY,
  29.                          Width    = Msg->lvdm_Bounds.MaxX - Msg->lvdm_Bounds.MinX + 1,
  30.                          Height    = Msg->lvdm_Bounds.MaxY - Msg->lvdm_Bounds.MinY + 1,
  31.                          FgPen,BgPen,
  32.                          Len,LabelLen;
  33.         STRPTR             String = Node->ln_Name;
  34.         UWORD            *Pens;
  35.  
  36.         Pens = Msg->lvdm_DrawInfo->dri_Pens;
  37.  
  38.             /* Determine the rendering pens. */
  39.  
  40.         if(Msg->lvdm_State == LVR_SELECTED)
  41.         {
  42.             FgPen = FILLTEXTPEN;
  43.             BgPen = FILLPEN;
  44.         }
  45.         else
  46.         {
  47.             FgPen = TEXTPEN;
  48.             BgPen = BACKGROUNDPEN;
  49.         }
  50.  
  51.         FgPen = Pens[FgPen];
  52.         BgPen = Pens[BgPen];
  53.  
  54.         SetABPenDrMd(RPort,BgPen,BgPen,JAM2);
  55.         RectFill(RPort,Left,Top,Left + 1,Top + Height - 1);
  56.  
  57.         Left    += 2;
  58.         Width    -= 2;
  59.  
  60.             /* Is this an error message? */
  61.  
  62.         if(*String++ == '*' && BgPen != Pens[HIGHLIGHTTEXTPEN])
  63.             FgPen = Pens[HIGHLIGHTTEXTPEN];
  64.  
  65.             /* Determine length of vanilla name. */
  66.  
  67.         LabelLen = strlen(String);
  68.  
  69.             /* Try to make it fit. */
  70.  
  71.         while(LabelLen > 0 && (Len = TextLength(RPort,String,LabelLen)) > Width)
  72.             LabelLen--;
  73.  
  74.             /* Print the vanilla name if possible. */
  75.  
  76.         if(LabelLen)
  77.         {
  78.             SetAPen(RPort,FgPen);
  79.  
  80.             PlaceText(RPort,Left,Top,String,LabelLen);
  81.  
  82.             Left    += Len;
  83.             Width    -= Len;
  84.         }
  85.  
  86.             /* Fill the area to follow the vanilla name. */
  87.  
  88.         if(Width > 0)
  89.         {
  90.             SetAPen(RPort,BgPen);
  91.             FillBox(RPort,Left,Top,Width,Height);
  92.         }
  93.  
  94.             /* If the item happens to be disabled, draw the cross-hatch
  95.              * pattern across it.
  96.              */
  97.  
  98.         ListViewStateFill(Msg);
  99.  
  100.         return(LVCB_OK);
  101.     }
  102.     else
  103.         return(LVCB_UNKNOWN);
  104. }
  105.  
  106.     /* AddTransferInfo(STRPTR Message,...):
  107.      *
  108.      *    Add another entry to the transfer information list.
  109.      */
  110.  
  111. VOID __stdargs
  112. AddTransferInfo(BOOL Error,STRPTR Message,...)
  113. {
  114.     STATIC UBYTE __far TempBuffer[256];
  115.  
  116.     struct Node    *Node;
  117.     va_list         VarArgs;
  118.  
  119.     if(Kick30)
  120.     {
  121.         va_start(VarArgs,Message);
  122.         VSPrintf(&TempBuffer[1],Message,VarArgs);
  123.         va_end(VarArgs);
  124.  
  125.         if(Error)
  126.             TempBuffer[0] = '*';
  127.         else
  128.             TempBuffer[0] = ' ';
  129.     }
  130.     else
  131.     {
  132.         va_start(VarArgs,Message);
  133.         VSPrintf(TempBuffer,Message,VarArgs);
  134.         va_end(VarArgs);
  135.     }
  136.  
  137.     if(Node = CreateNode(TempBuffer))
  138.     {
  139.         LT_SetAttributes(TransferHandle,GAD_TRANSFER_INFORMATION_LIST,
  140.             GTLV_Labels,    ~0,
  141.         TAG_DONE);
  142.  
  143.         if(TransferInfoCount == 100)
  144.         {
  145.             FreeVecPooled(RemHead(&TransferInfoList));
  146.  
  147.             TransferInfoCount = 99;
  148.         }
  149.  
  150.         AddTail(&TransferInfoList,Node);
  151.  
  152.         LT_SetAttributes(TransferHandle,GAD_TRANSFER_INFORMATION_LIST,
  153.             GTLV_Labels,        &TransferInfoList,
  154.             GTLV_Top,            TransferInfoCount,
  155.             GTLV_MakeVisible,    TransferInfoCount,
  156.         TAG_DONE);
  157.  
  158.         TransferInfoCount++;
  159.     }
  160. }
  161.  
  162.     /* TransferPanel(STRPTR Title):
  163.      *
  164.      *    Open the transfer window.
  165.      */
  166.  
  167. BOOL
  168. TransferPanel(STRPTR Title)
  169. {
  170.     if(TransferWindow)
  171.         return(TRUE);
  172.     else
  173.     {
  174.         STATIC struct Hook ListViewHook =
  175.         {
  176.             {NULL},
  177.             (HOOKFUNC)TransferListViewRender
  178.         };
  179.  
  180.         TransferFailed = TransferAborted = FALSE;
  181.  
  182.         if(Status != STATUS_DOWNLOAD && Status != STATUS_UPLOAD)
  183.         {
  184.             LastStatus = Status;
  185.  
  186.             Status = STATUS_DOWNLOAD;
  187.         }
  188.         else
  189.             LastStatus = -1;
  190.  
  191.         if(Window)
  192.             TransferHandle = LT_CreateHandleTags(Window->WScreen,LH_LocaleHook,&LocaleHook,TAG_DONE);
  193.         else
  194.             TransferHandle = LT_CreateHandleTags(NULL,LH_LocaleHook,&LocaleHook,TAG_DONE);
  195.  
  196.         if(TransferHandle)
  197.         {
  198.             STATIC LONG LabelGroups[5][2] =
  199.             {
  200.                 MSG_TRANSFERPANEL_FILE_TXT,
  201.                     MSG_TRANSFERPANEL_COMPLETION_TIME_TXT,
  202.  
  203.                 MSG_TRANSFERPANEL_FILE_SIZE_TXT,
  204.                     MSG_TRANSFERPANEL_BLOCKS_TRANSFERRED_TXT,
  205.  
  206.                 MSG_TRANSFERPANEL_ESTIMATED_TIME_TXT,
  207.                     MSG_TRANSFERPANEL_ELAPSED_TIME_TXT,
  208.  
  209.                 MSG_TRANSFERPANEL_CHARACTERS_PER_SECOND_TXT,
  210.                     MSG_TRANSFERPANEL_BLOCK_SIZE_TXT,
  211.  
  212.                 MSG_TRANSFERPANEL_NUMBER_OF_ERRORS_TXT,
  213.                     MSG_TRANSFERPANEL_NUMBER_OF_TIMEOUTS_TXT,
  214.             };
  215.  
  216.             struct IBox Bounds;
  217.             LONG len,max,i,j;
  218.  
  219.             max = LT_LabelChars(TransferHandle,LocaleString(MSG_TRANSFERPANEL_PROTOCOL_TXT));
  220.             len = LT_LabelChars(TransferHandle,LocaleString(MSG_TRANSFERPANEL_INFORMATION_GAD));
  221.  
  222.             if(len > max)
  223.                 max = len;
  224.  
  225.             for(i = 0 ; i < 5 ; i++)
  226.             {
  227.                 for(j = LabelGroups[i][0] ; j <= LabelGroups[i][1] ; j++)
  228.                 {
  229.                     len = LT_LabelChars(TransferHandle,LocaleString(j));
  230.  
  231.                     if(len > max)
  232.                         max = len;
  233.                 }
  234.             }
  235.  
  236.             LT_New(TransferHandle,
  237.                 LA_Type,VERTICAL_KIND,
  238.             TAG_DONE);
  239.             {
  240.                 LT_New(TransferHandle,
  241.                     LA_Type,VERTICAL_KIND,
  242.                 TAG_DONE);
  243.                 {
  244.                     LT_New(TransferHandle,
  245.                         LA_Type,VERTICAL_KIND,
  246.                     TAG_DONE);
  247.                     {
  248.                         UBYTE    LocalBuffer[60];
  249.                         WORD    Len;
  250.  
  251.                         strcpy(LocalBuffer,FilePart(LastXprLibrary));
  252.  
  253.                         if((Len = strlen(LocalBuffer)) > 3)
  254.                         {
  255.                             UBYTE    ProtocolBuffer[60];
  256.                             WORD    i;
  257.  
  258.                             strcpy(ProtocolBuffer,&LocalBuffer[3]);
  259.  
  260.                             for(i = 0 ; i < Len - 3 ; i++)
  261.                             {
  262.                                 if(ProtocolBuffer[i] == '.')
  263.                                 {
  264.                                     ProtocolBuffer[i] = 0;
  265.  
  266.                                     break;
  267.                                 }
  268.                             }
  269.  
  270.                             ProtocolBuffer[0] = ToUpper(ProtocolBuffer[0]);
  271.  
  272.                             SPrintf(LocalBuffer,"[%s]",ProtocolBuffer);
  273.                         }
  274.                         else
  275.                             strcpy(LocalBuffer,"-");
  276.  
  277.                         LT_New(TransferHandle,
  278.                             LA_Type,            TEXT_KIND,
  279.                             LA_LabelID,            MSG_TRANSFERPANEL_PROTOCOL_TXT,
  280.                             LA_LabelChars,        max,
  281.                             LA_Chars,            50,
  282.                             LA_ID,                GAD_TRANSFER_PROTOCOL,
  283.                             GTTX_Text,            LocalBuffer,
  284.                             GTTX_CopyText,        TRUE,
  285.                             GTTX_Border,        TRUE,
  286.                         TAG_DONE);
  287.  
  288.                         LT_New(TransferHandle,
  289.                             LA_Type,            LISTVIEW_KIND,
  290.                             LA_LabelID,            MSG_TRANSFERPANEL_INFORMATION_GAD,
  291.                             LA_LabelChars,        max,
  292.                             LA_LabelPlace,        PLACE_LEFT,
  293.                             LA_ID,                GAD_TRANSFER_INFORMATION_LIST,
  294.                             LA_Chars,            50,
  295.                             LA_Lines,            2,
  296.                             LALV_MaxGrowY,        10,
  297.                             LALV_CursorKey,        TRUE,
  298.                             GTLV_ReadOnly,        TRUE,
  299.                             GTLV_CallBack,        &ListViewHook,
  300.                             GTLV_MaxPen,        MAX(TransferHandle->DrawInfo->dri_Pens[BLOCKPEN],MAX(TransferHandle->DrawInfo->dri_Pens[TEXTPEN],MAX(TransferHandle->DrawInfo->dri_Pens[BACKGROUNDPEN],MAX(TransferHandle->DrawInfo->dri_Pens[FILLTEXTPEN],MAX(TransferHandle->DrawInfo->dri_Pens[FILLPEN],TransferHandle->DrawInfo->dri_Pens[HIGHLIGHTTEXTPEN]))))),
  301.                         TAG_DONE);
  302.  
  303.                         LT_New(TransferHandle,
  304.                             LA_Type,            XBAR_KIND,
  305.                         TAG_DONE);
  306.  
  307.                         LT_New(TransferHandle,
  308.                             LA_Type,            BOX_KIND,
  309.                             LA_ID,                GAD_TRANSFER_FILE,
  310.                             LA_Chars,            50,
  311.                             LA_LabelChars,        max,
  312.                             LABX_FirstLabel,    MSG_TRANSFERPANEL_FILE_TXT,
  313.                             LABX_LastLabel,        MSG_TRANSFERPANEL_COMPLETION_TIME_TXT,
  314.                             LABX_ReserveSpace,    TRUE,
  315.                         TAG_DONE);
  316.  
  317.                         LT_New(TransferHandle,
  318.                             LA_Type,            XBAR_KIND,
  319.                         TAG_DONE);
  320.  
  321.                         LT_EndGroup(TransferHandle);
  322.                     }
  323.  
  324.                     LT_New(TransferHandle,
  325.                         LA_Type,HORIZONTAL_KIND,
  326.                     TAG_DONE);
  327.                     {
  328.                         LT_New(TransferHandle,
  329.                             LA_Type,VERTICAL_KIND,
  330.                         TAG_DONE);
  331.                         {
  332.                             LT_New(TransferHandle,
  333.                                 LA_Type,            BOX_KIND,
  334.                                 LA_ID,                GAD_TRANSFER_SIZE,
  335.                                 LA_LabelChars,        max,
  336.                                 LA_Chars,            15,
  337.                                 LABX_FirstLabel,    MSG_TRANSFERPANEL_FILE_SIZE_TXT,
  338.                                 LABX_LastLabel,        MSG_TRANSFERPANEL_BLOCKS_TRANSFERRED_TXT,
  339.                                 LABX_ReserveSpace,    TRUE,
  340.                             TAG_DONE);
  341.  
  342.                             LT_New(TransferHandle,
  343.                                 LA_Type,            BOX_KIND,
  344.                                 LA_LabelChars,        max,
  345.                                 LA_ID,                GAD_TRANSFER_TOTALTIME,
  346.                                 LABX_FirstLabel,    MSG_TRANSFERPANEL_ESTIMATED_TIME_TXT,
  347.                                 LABX_LastLabel,        MSG_TRANSFERPANEL_ELAPSED_TIME_TXT,
  348.                                 LABX_ReserveSpace,    TRUE,
  349.                             TAG_DONE);
  350.  
  351.                             LT_EndGroup(TransferHandle);
  352.                         }
  353.  
  354.                         LT_New(TransferHandle,
  355.                             LA_Type,                VERTICAL_KIND,
  356.                             LAGR_LastAttributes,    TRUE,
  357.                         TAG_DONE);
  358.                         {
  359.                             LT_New(TransferHandle,
  360.                                 LA_Type,            BOX_KIND,
  361.                                 LA_ID,                GAD_TRANSFER_SECONDS,
  362.                                 LA_LabelChars,        max,
  363.                                 LA_Chars,            15,
  364.                                 LABX_FirstLabel,    MSG_TRANSFERPANEL_CHARACTERS_PER_SECOND_TXT,
  365.                                 LABX_LastLabel,        MSG_TRANSFERPANEL_BLOCK_SIZE_TXT,
  366.                                 LABX_ReserveSpace,    TRUE,
  367.                             TAG_DONE);
  368.  
  369.                             LT_New(TransferHandle,
  370.                                 LA_Type,            BOX_KIND,
  371.                                 LA_ID,                GAD_TRANSFER_ERRORS,
  372.                                 LA_LabelChars,        max,
  373.                                 LABX_FirstLabel,    MSG_TRANSFERPANEL_NUMBER_OF_ERRORS_TXT,
  374.                                 LABX_LastLabel,        MSG_TRANSFERPANEL_NUMBER_OF_TIMEOUTS_TXT,
  375.                                 LABX_ReserveSpace,    TRUE,
  376.                             TAG_DONE);
  377.  
  378.                             LT_EndGroup(TransferHandle);
  379.                         }
  380.  
  381.                         LT_EndGroup(TransferHandle);
  382.                     }
  383.  
  384.                     LT_New(TransferHandle,
  385.                         LA_Type,HORIZONTAL_KIND,
  386.                     TAG_DONE);
  387.                     {
  388.                         LT_New(TransferHandle,
  389.                             LA_Type,XBAR_KIND,
  390.                         TAG_DONE);
  391.  
  392.                         LT_EndGroup(TransferHandle);
  393.                     }
  394.  
  395.                     LT_New(TransferHandle,
  396.                         LA_Type,        HORIZONTAL_KIND,
  397.                         LAGR_SameSize,    TRUE,
  398.                         LAGR_Spread,    TRUE,
  399.                     TAG_DONE);
  400.                     {
  401.                         LONG len1,len2,max;
  402.  
  403.                         len1 = 4 + strlen(LocaleString(MSG_TRANSFERPANEL_DATA_TRANSFERRED_GAD)) + 1;
  404.                         len2 = 8 + strlen(LocaleString(MSG_TRANSFERPANEL_TIME_TO_GO_GAD)) + 1;
  405.  
  406.                         if(len1 > len2)
  407.                             max = len1;
  408.                         else
  409.                             max = len2;
  410.  
  411.                         if(max < 30)
  412.                             max = 30;
  413.  
  414.                         LT_New(TransferHandle,
  415.                             LA_Type,        GAUGE_KIND,
  416.                             LA_Chars,        max,
  417.                             LA_LabelPlace,    PLACE_IN,
  418.                             LA_ID,            GAD_TRANSFER_PERCENT,
  419.                             LAGA_NoTicks,    TRUE,
  420.                             LAGA_InfoLength,len1,
  421.                         TAG_DONE);
  422.  
  423.                         LT_New(TransferHandle,
  424.                             LA_Type,        GAUGE_KIND,
  425.                             LA_LabelPlace,    PLACE_IN,
  426.                             LA_ID,            GAD_TRANSFER_TIME,
  427.                             LAGA_NoTicks,    TRUE,
  428.                             LAGA_InfoLength,len2,
  429.                         TAG_DONE);
  430.  
  431.                         LT_EndGroup(TransferHandle);
  432.                     }
  433.  
  434.                     LT_EndGroup(TransferHandle);
  435.                 }
  436.  
  437.                 LT_New(TransferHandle,
  438.                     LA_Type,VERTICAL_KIND,
  439.                 TAG_DONE);
  440.                 {
  441.                     LT_New(TransferHandle,
  442.                         LA_Type,        XBAR_KIND,
  443.                         LAXB_FullSize,    TRUE,
  444.                     TAG_DONE);
  445.  
  446.                     LT_EndGroup(TransferHandle);
  447.                 }
  448.  
  449.                 LT_New(TransferHandle,LA_Type,HORIZONTAL_KIND,
  450.                     LAGR_Spread,TRUE,
  451.                 TAG_DONE);
  452.                 {
  453.                     LT_New(TransferHandle,
  454.                         LA_Type,        BUTTON_KIND,
  455.                         LA_LabelID,        MSG_TRANSFERPANEL_SKIP_CURRENT_FILE_GAD,
  456.                         LA_ID,            GAD_TRANSFER_SKIP,
  457.                         LABT_ExtraFat,    TRUE,
  458.                     TAG_DONE);
  459.  
  460.                     LT_New(TransferHandle,
  461.                         LA_Type,        BUTTON_KIND,
  462.                         LA_LabelID,        MSG_TRANSFERPANEL_ABORT_CURRENT_FILE_GAD,
  463.                         LA_ID,            GAD_TRANSFER_ABORT_FILE,
  464.                         LABT_ExtraFat,    TRUE,
  465.                     TAG_DONE);
  466.  
  467.                     LT_New(TransferHandle,
  468.                         LA_Type,        BUTTON_KIND,
  469.                         LA_LabelID,        MSG_TRANSFERPANEL_ABORT_ENTIRE_TRANSFER_GAD,
  470.                         LA_ID,            GAD_TRANSFER_ABORT,
  471.                         LABT_EscKey,    TRUE,
  472.                         LABT_ExtraFat,    TRUE,
  473.                     TAG_DONE);
  474.  
  475.                     LT_EndGroup(TransferHandle);
  476.                 }
  477.  
  478.                 LT_EndGroup(TransferHandle);
  479.             }
  480.  
  481.             TransferZoomed = FALSE;
  482.  
  483.             if(Window)
  484.             {
  485.                 Bounds.Left    = WindowLeft + Window->LeftEdge;
  486.                 Bounds.Top    = WindowTop + Window->TopEdge;
  487.             }
  488.             else
  489.             {
  490.                 Bounds.Left    = WindowLeft;
  491.                 Bounds.Top    = WindowTop;
  492.             }
  493.  
  494.             Bounds.Width    = WindowWidth;
  495.             Bounds.Height    = WindowHeight;
  496.  
  497.             if(TransferWindow = LT_Layout(TransferHandle,TransferWindowTitle = Title,&Bounds,0,0,IDCMP_CLOSEWINDOW,0,
  498.                 LAWN_HelpHook,        &GuideHook,
  499. //                LAWN_Parent,        Window,
  500.                 WA_DepthGadget,        TRUE,
  501.                 WA_CloseGadget,        TRUE,
  502.                 WA_DragBar,            TRUE,
  503.                 WA_RMBTrap,            TRUE,
  504.                 LAWN_Zoom,            TRUE,
  505.             TAG_DONE))
  506.             {
  507.                 BOOL    Activate,Move;
  508.                 LONG    i;
  509.  
  510.                 GuideContext(CONTEXT_TRANSFER);
  511.  
  512.                 if(Config->MiscConfig->AlertMode == ALERT_SCREEN || Config->MiscConfig->AlertMode == ALERT_BEEP_SCREEN)
  513.                     Move = Activate = TRUE;
  514.                 else
  515.                 {
  516.                     ULONG IntuiLock = LockIBase(NULL);
  517.  
  518.                     Activate = Move = FALSE;
  519.  
  520.                     if(IntuitionBase->ActiveScreen == Screen)
  521.                         Activate = TRUE;
  522.                     else
  523.                     {
  524.                         if(IntuitionBase->ActiveWindow && IntuitionBase->ActiveWindow->UserPort && IntuitionBase->ActiveWindow->UserPort->mp_Flags == PA_SIGNAL && IntuitionBase->ActiveWindow->UserPort->mp_SigTask == FindTask(NULL))
  525.                             Activate = TRUE;
  526.                     }
  527.  
  528.                     UnlockIBase(IntuiLock);
  529.                 }
  530.  
  531.                 if(Config->TransferConfig->TransferNotification == XFERNOTIFY_NEVER || Config->TransferConfig->TransferNotification == XFERNOTIFY_END)
  532.                     Move = Activate = FALSE;
  533.  
  534.                 if(Move)
  535.                 {
  536.                     if(TransferWindow->WScreen->LeftEdge > 0)
  537.                     {
  538.                         if(TransferWindow->WScreen->TopEdge > 0)
  539.                             MoveScreen(TransferWindow->WScreen,-TransferWindow->WScreen->LeftEdge,-TransferWindow->WScreen->TopEdge);
  540.                         else
  541.                             MoveScreen(TransferWindow->WScreen,-TransferWindow->WScreen->LeftEdge,0);
  542.                     }
  543.                     else
  544.                     {
  545.                         if(TransferWindow->WScreen->TopEdge > 0)
  546.                             MoveScreen(TransferWindow->WScreen,0,-TransferWindow->WScreen->TopEdge);
  547.                     }
  548.  
  549.                     WindowToFront(TransferWindow);
  550.  
  551.                     ScreenToFront(TransferWindow->WScreen);
  552.                 }
  553.  
  554.                 if(Activate)
  555.                     ActivateWindow(TransferWindow);
  556.  
  557.                 PushWindow(TransferWindow);
  558.  
  559.                 for(i = 0 ; i < 6 ; i++)
  560.                 {
  561.                     if(i < 4)
  562.                     {
  563.                         if(i < 2)
  564.                         {
  565.                             LT_SetAttributes(TransferHandle,GAD_TRANSFER_TOTALTIME,
  566.                                 LABX_Index,    i,
  567.                                 LABX_Text,    "-",
  568.                             TAG_DONE);
  569.  
  570.                             LT_SetAttributes(TransferHandle,GAD_TRANSFER_ERRORS,
  571.                                 LABX_Index,    i,
  572.                                 LABX_Text,    "-",
  573.                             TAG_DONE);
  574.                         }
  575.  
  576.                         LT_SetAttributes(TransferHandle,GAD_TRANSFER_FILE,
  577.                             LABX_Index,    i,
  578.                             LABX_Text,    "-",
  579.                         TAG_DONE);
  580.                     }
  581.  
  582.                     LT_SetAttributes(TransferHandle,GAD_TRANSFER_SIZE,
  583.                         LABX_Index,    i,
  584.                         LABX_Text,    "-",
  585.                     TAG_DONE);
  586.  
  587.                     LT_SetAttributes(TransferHandle,GAD_TRANSFER_SECONDS,
  588.                         LABX_Index,    i,
  589.                         LABX_Text,    "-",
  590.                     TAG_DONE);
  591.                 }
  592.  
  593.                 return(TRUE);
  594.             }
  595.  
  596.             LT_DeleteHandle(TransferHandle);
  597.  
  598.             TransferHandle = NULL;
  599.         }
  600.     }
  601.  
  602.     return(FALSE);
  603. }
  604.  
  605.     /* DeleteTransferPanel(BOOL WaitForPrompt):
  606.      *
  607.      *    Close the transfer window.
  608.      */
  609.  
  610. VOID
  611. DeleteTransferPanel(BOOL WaitForPrompt)
  612. {
  613.         /* Can any pending garbage. */
  614.  
  615.     if(TransferError)
  616.         FlushSerialRead();
  617.  
  618.         /* Wait for user to close the window? */
  619.  
  620.     if(WaitForPrompt && TransferHandle)
  621.     {
  622.         struct IntuiMessage    *Message;
  623.         BOOL                 Done = FALSE;
  624.         ULONG                 MsgClass,
  625.                              MsgQualifier;
  626.         UWORD                 MsgCode;
  627.         struct Gadget        *MsgGadget;
  628.  
  629.         LT_SetAttributes(TransferHandle,GAD_TRANSFER_SKIP,
  630.             GA_Disabled,    TRUE,
  631.         TAG_DONE);
  632.  
  633.         LT_SetAttributes(TransferHandle,GAD_TRANSFER_ABORT_FILE,
  634.             GA_Disabled,    TRUE,
  635.         TAG_DONE);
  636.  
  637.         do
  638.         {
  639.             if(Wait(PORTMASK(TransferWindow->UserPort) | SIG_BREAK) & SIG_BREAK)
  640.                 break;
  641.  
  642.             while(Message = (struct IntuiMessage *)GT_GetIMsg(TransferWindow->UserPort))
  643.             {
  644.                 MsgClass        = Message->Class;
  645.                 MsgQualifier    = Message->Qualifier;
  646.                 MsgCode            = Message->Code;
  647.                 MsgGadget        = (struct Gadget *)Message->IAddress;
  648.  
  649.                 GT_ReplyIMsg(Message);
  650.  
  651.                 LT_HandleInput(TransferHandle,MsgQualifier,&MsgClass,&MsgCode,&MsgGadget);
  652.  
  653.                 if(MsgClass == IDCMP_CLOSEWINDOW || (MsgClass == IDCMP_GADGETUP && MsgGadget->GadgetID == GAD_TRANSFER_ABORT))
  654.                     Done = TRUE;
  655.             }
  656.         }
  657.         while(!Done);
  658.     }
  659.  
  660.     TransferAbortState = 0;
  661.     TransferAbortCount = 0;
  662.  
  663.     TransferError = FALSE;
  664.  
  665.     if(FileTransferInfo)
  666.     {
  667.         FreeFileTransferInfo(FileTransferInfo);
  668.  
  669.         FileTransferInfo = NULL;
  670.     }
  671.  
  672.     if(LastStatus != -1)
  673.         Status = LastStatus;
  674.  
  675.     LastStatus = -1;
  676.  
  677.     if(TransferHandle)
  678.     {
  679.         LT_DeleteHandle(TransferHandle);
  680.  
  681.         TransferHandle = NULL;
  682.     }
  683.  
  684.     if(TransferInfoList.lh_Head->ln_Succ)
  685.     {
  686.         FreeList(&TransferInfoList);
  687.  
  688.         TransferInfoCount = 0;
  689.     }
  690.  
  691.     TransferWindow = NULL;
  692.  
  693.     ReleaseWindows();
  694. }
  695.