home *** CD-ROM | disk | FTP | other *** search
/ Amiga Times / AmigaTimes.iso / internet / Term / Extras / Source / term-source.lha / UploadQueue.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-10-20  |  24.6 KB  |  1,162 lines
  1. /*
  2. **    UploadQueue.c
  3. **
  4. **    Upload queue user interface.
  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. enum    {    GAD_LIST=1000,GAD_NAME,
  17.             GAD_ADD,GAD_REMOVE,GAD_CLEAR,GAD_HIDE,
  18.             GAD_ADD_FILES
  19.         };
  20.  
  21. enum    {    APP_ICON=1,APP_WINDOW=2 };
  22.  
  23. enum    {    TRANSFERMSG_TOGGLE_ICON=1,
  24.             TRANSFERMSG_DISPLAYLIST
  25.         };
  26.  
  27. STATIC struct GenericList    *TransferList;
  28. STATIC LONG                     TransferSignal;
  29. STATIC struct MsgQueue        *TransferQueue;
  30.  
  31. STATIC VOID
  32. LocalMsgDestructor(struct DataMsg *Item)
  33. {
  34.     Signal(Item->Client,Item->Mask);
  35. }
  36.  
  37. VOID
  38. NotifyUploadQueue(struct GenericList *UnusedList,WORD Login)
  39. {
  40.     if(TransferProcess)
  41.     {
  42.         LONG SigBit;
  43.  
  44.         if((SigBit = AllocSignal(-1)) != -1)
  45.         {
  46.             struct DataMsg Msg;
  47.  
  48.             InitMsgItem(&Msg,(DESTRUCTOR)LocalMsgDestructor);
  49.  
  50.             Msg.Type    = TRANSFERMSG_DISPLAYLIST;
  51.             Msg.Size    = Login;
  52.             Msg.Client    = FindTask(NULL);
  53.             Msg.Mask    = 1L << SigBit;
  54.  
  55.             ClrSignal(Msg.Mask);
  56.  
  57.             PutMsgItem(TransferQueue,(struct MsgItem *)&Msg);
  58.  
  59.             Wait(Msg.Mask);
  60.  
  61.             FreeSignal(SigBit);
  62.         }
  63.     }
  64. }
  65.  
  66.     /* QueuePanel(struct Window *Window):
  67.      *
  68.      *    Create the user interface for the queue panel.
  69.      */
  70.  
  71. STATIC LayoutHandle *
  72. QueuePanel(struct Window *Parent)
  73. {
  74.     LayoutHandle *Handle;
  75.  
  76.     LockGenericList(TransferList);
  77.  
  78.     if(Handle = LT_CreateHandleTags(Parent ? Parent->WScreen : NULL,
  79.         LAHN_LocaleHook,    &LocaleHook,
  80.     TAG_DONE))
  81.     {
  82.         LONG Left,Top,Width,Height;
  83.         BOOL KeepPosition;
  84.  
  85.         Left = Top = Width = Height = 0;
  86.  
  87.         if(Handle->Screen == Screen)
  88.         {
  89.             KeepPosition = TRUE;
  90.  
  91.             GetWindowInfo(WINDOW_QUEUE,&Left,&Top,&Width,&Height,0,0);
  92.         }
  93.         else
  94.             KeepPosition = FALSE;
  95.  
  96.         LT_New(Handle,
  97.             LA_Type,    VERTICAL_KIND,
  98.         TAG_DONE);
  99.         {
  100.             LT_New(Handle,
  101.                 LA_Type,    VERTICAL_KIND,
  102.             TAG_DONE);
  103.             {
  104.                 LT_New(Handle,
  105.                     LA_Type,        LISTVIEW_KIND,
  106.                     LA_LabelID,        MSG_UPLOADQUEUE_FILES_TO_UPLOAD_TXT,
  107.                     LA_LabelPlace,    PLACE_Above,
  108.                     LA_Chars,        30,
  109.                     LA_ID,            GAD_LIST,
  110.                     LALV_Lines,        10,
  111.                     LALV_CursorKey,    TRUE,
  112.                     LALV_MaxGrowY,    20,
  113.                     LALV_MaxGrowX,    50,
  114.                     LALV_ResizeX,    TRUE,
  115.                     LALV_ResizeY,    TRUE,
  116.                     GTLV_Labels,    TransferList,
  117.  
  118.                     Kick30 ? LALV_Link : TAG_IGNORE,NIL_LINK,
  119.                 TAG_DONE);
  120.  
  121.                 LT_New(Handle,
  122.                     LA_Type,        STRING_KIND,
  123.                     LA_ID,            GAD_NAME,
  124.                     GTST_MaxChars,    MAX_FILENAME_LENGTH - 1,
  125.                     LAST_Picker,    TRUE,
  126.                 TAG_DONE);
  127.  
  128.                 LT_EndGroup(Handle);
  129.             }
  130.  
  131.             LT_New(Handle,
  132.                 LA_Type,        HORIZONTAL_KIND,
  133.                 LA_LabelID,        MSG_V36_0043,
  134.                 LAGR_SameSize,    TRUE,
  135.             TAG_DONE);
  136.             {
  137.                 LT_New(Handle,
  138.                     LA_Type,        BUTTON_KIND,
  139.                     LA_LabelID,        MSG_ADD_SEVERAL_FILES_TXT,
  140.                     LA_ID,            GAD_ADD_FILES,
  141.                 TAG_DONE);
  142.  
  143.                 LT_New(Handle,
  144.                     LA_Type,        BUTTON_KIND,
  145.                     LA_LabelID,        MSG_UPLOADQUEUE_ADD_TXT,
  146.                     LA_ID,            GAD_ADD,
  147.                 TAG_DONE);
  148.  
  149.                 LT_New(Handle,
  150.                     LA_Type,        BUTTON_KIND,
  151.                     LA_LabelID,        MSG_UPLOADQUEUE_REMOVE_TXT,
  152.                     LA_ID,            GAD_REMOVE,
  153.                     GA_Disabled,    TRUE,
  154.                 TAG_DONE);
  155.  
  156.                 LT_New(Handle,
  157.                     LA_Type,        BUTTON_KIND,
  158.                     LA_LabelID,        MSG_UPLOADQUEUE_CLEAR_TXT,
  159.                     LA_ID,            GAD_CLEAR,
  160.                     GA_Disabled,    !TransferList->ListCount,
  161.                 TAG_DONE);
  162.  
  163.                 LT_EndGroup(Handle);
  164.             }
  165.  
  166.             LT_New(Handle,
  167.                 LA_Type,    VERTICAL_KIND,
  168.             TAG_DONE);
  169.             {
  170.                 LT_New(Handle,
  171.                     LA_Type,        XBAR_KIND,
  172.                     LAXB_FullSize,    TRUE,
  173.                 TAG_DONE);
  174.  
  175.                 LT_EndGroup(Handle);
  176.             }
  177.  
  178.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  179.                 LAGR_SameSize,    TRUE,
  180.                 LAGR_Spread,    TRUE,
  181.             TAG_DONE);
  182.             {
  183.                 LT_New(Handle,
  184.                     LA_Type,        BUTTON_KIND,
  185.                     LA_LabelID,        MSG_UPLOADQUEUE_BINARY_UPLOAD_TXT,
  186.                     LA_ID,            UPLOAD_BINARY,
  187.                     LABT_ExtraFat,    TRUE,
  188.                     LABT_ReturnKey,    TRUE,
  189.                     GA_Disabled,    !TransferList->ListCount,
  190.                 TAG_DONE);
  191.  
  192.                 LT_New(Handle,
  193.                     LA_Type,        BUTTON_KIND,
  194.                     LA_LabelID,        MSG_UPLOADQUEUE_TEXT_UPLOAD_TXT,
  195.                     LA_ID,            UPLOAD_TEXT,
  196.                     GA_Disabled,    !TransferList->ListCount,
  197.                 TAG_DONE);
  198.  
  199.                 LT_New(Handle,
  200.                     LA_Type,        BUTTON_KIND,
  201.                     LA_LabelID,        MSG_UPLOADQUEUE_HIDE_TXT,
  202.                     LA_ID,            GAD_HIDE,
  203.                     LABT_EscKey,    TRUE,
  204.                 TAG_DONE);
  205.  
  206.                 LT_EndGroup(Handle);
  207.             }
  208.  
  209.             LT_EndGroup(Handle);
  210.         }
  211.  
  212.         if(LT_Build(Handle,
  213.             LAWN_TitleID,        MSG_UPLOADQUEUE_FILE_UPLOAD_LIST_TXT,
  214.             WA_DepthGadget,        TRUE,
  215.             WA_DragBar,            TRUE,
  216.             WA_RMBTrap,            TRUE,
  217.             WA_Activate,        TRUE,
  218.             WA_SimpleRefresh,    TRUE,
  219.  
  220.             KeepPosition ? LAWN_Left : TAG_IGNORE,            Left,
  221.             KeepPosition ? LAWN_Top : TAG_IGNORE,            Top,
  222.             KeepPosition ? TAG_IGNORE : LAWN_BelowMouse,    TRUE,
  223.         TAG_DONE))
  224.         {
  225.             GuideContext(CONTEXT_UPLOAD_QUEUE);
  226.  
  227.             UnlockGenericList(TransferList);
  228.  
  229.             return(Handle);
  230.         }
  231.  
  232.         LT_DeleteHandle(Handle);
  233.     }
  234.  
  235.     UnlockGenericList(TransferList);
  236.  
  237.     return(NULL);
  238. }
  239.  
  240.     /* HandleQueueWindow(LayoutHandle *Handle):
  241.      *
  242.      *    Process queue panel messages.
  243.      */
  244.  
  245. STATIC LONG
  246. HandleQueueWindow(LayoutHandle *Handle)
  247. {
  248.     struct IntuiMessage        *Message;
  249.     ULONG                     MsgClass;
  250.     UWORD                     MsgCode;
  251.     struct Gadget            *MsgGadget;
  252.  
  253.     struct Node                *Node;
  254.  
  255.     struct Window            *Window = Handle->Window;
  256.     LONG                     Result = 0;
  257.  
  258.     UBYTE                      DummyBuffer[MAX_FILENAME_LENGTH];
  259.     struct FileRequester    *FileRequest;
  260.     struct TagItem             DimensionTags[5];
  261.  
  262.     while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  263.     {
  264.         MsgClass    = Message->Class;
  265.         MsgCode        = Message->Code;
  266.         MsgGadget    = (struct Gadget *)Message->IAddress;
  267.  
  268.         LT_ReplyIMsg(Message);
  269.  
  270.         if(MsgClass == IDCMP_IDCMPUPDATE && MsgGadget->GadgetID == GAD_NAME)
  271.         {
  272.             strcpy(DummyBuffer,LT_GetString(Handle,GAD_NAME));
  273.  
  274.             if(FileRequest = OpenSingleFile(Window,LocaleString(MSG_UPLOADQUEUE_SELECT_FILE_TXT),LocaleString(MSG_GLOBAL_SELECT_TXT),NULL,DummyBuffer,sizeof(DummyBuffer)))
  275.             {
  276.                 LT_SetAttributes(Handle,GAD_NAME,
  277.                     GTST_String,    DummyBuffer,
  278.                 TAG_DONE);
  279.  
  280.                 FreeAslRequest(FileRequest);
  281.             }
  282.  
  283.             LT_Activate(Handle,GAD_NAME);
  284.         }
  285.  
  286.         if(MsgClass == IDCMP_GADGETUP)
  287.         {
  288.             switch(MsgGadget->GadgetID)
  289.             {
  290.                 case GAD_ADD_FILES:
  291.  
  292.                     LT_LockWindow(Window);
  293.  
  294.                     if(!LocalGetCurrentDirName(DummyBuffer,sizeof(DummyBuffer)))
  295.                         DummyBuffer[0] = 0;
  296.  
  297.                     if(FileRequest = AllocAslRequestTags(ASL_FileRequest,
  298.                         ASLFR_Window,            Window,
  299.                         ASLFR_TitleText,        LocaleString(MSG_ADD_FILES_TITLE_TXT),
  300.                         ASLFR_Flags1,            FILF_MULTISELECT | FILF_NEWIDCMP,
  301.                         ASLFR_PositiveText,        LocaleString(MSG_ADD_GAD),
  302.                         ASLFR_NegativeText,        LocaleString(MSG_DONE_GAD),
  303.                         ASLFR_InitialDrawer,    DummyBuffer,
  304.                         ASLFR_TextAttr,            &UserFont,
  305.                         ASLFR_PrivateIDCMP,        TRUE,
  306.                     TAG_MORE,GetDimensionTags(Window,DimensionTags)))
  307.                     {
  308.                         LONG i;
  309.  
  310.                         LockGenericList(TransferList);
  311.  
  312.                         LT_SetAttributes(Handle,GAD_LIST,
  313.                             GTLV_Labels,    ~0,
  314.                         TAG_DONE);
  315.  
  316.                         while(AslRequest(FileRequest,NULL))
  317.                         {
  318.                             for(i = 0 ; i < FileRequest->fr_NumArgs ; i++)
  319.                             {
  320.                                 if(FileRequest->fr_ArgList[i].wa_Lock)
  321.                                 {
  322.                                     if(!NameFromLock(FileRequest->fr_ArgList[i].wa_Lock,DummyBuffer,sizeof(DummyBuffer)))
  323.                                         DummyBuffer[0] = 0;
  324.                                 }
  325.                                 else
  326.                                     strcpy(DummyBuffer,FileRequest->fr_Drawer);
  327.  
  328.                                 if(FileRequest->fr_ArgList[i].wa_Name)
  329.                                 {
  330.                                     if(!AddPart(DummyBuffer,FileRequest->fr_ArgList[i].wa_Name,sizeof(DummyBuffer)))
  331.                                         DummyBuffer[0] = 0;
  332.                                 }
  333.  
  334.                                 if(DummyBuffer[0])
  335.                                 {
  336.                                     if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  337.                                     {
  338.                                         Node->ln_Name = (STRPTR)(Node + 1);
  339.  
  340.                                         strcpy(Node->ln_Name,DummyBuffer);
  341.  
  342.                                         AddGenericListNode(TransferList,Node,ADD_GLIST_BOTTOM,FALSE);
  343.                                     }
  344.                                 }
  345.                             }
  346.  
  347.                             LT_SetAttributes(Handle,GAD_LIST,
  348.                                 GTLV_Labels,    TransferList,
  349.                                 LALV_Selected,    TransferList->ListOffset,
  350.                             TAG_DONE);
  351.                         }
  352.  
  353.                         LT_SetAttributes(Handle,GAD_LIST,
  354.                             GTLV_Labels,    TransferList,
  355.                             LALV_Selected,    TransferList->ListOffset,
  356.                         TAG_DONE);
  357.  
  358.                         if(TransferList->ListCount)
  359.                         {
  360.                             LT_SetAttributes(Handle,GAD_NAME,
  361.                                 GTST_String,    "",
  362.                             TAG_DONE);
  363.  
  364.                             LT_SetAttributes(Handle,GAD_REMOVE,
  365.                                 GA_Disabled,    FALSE,
  366.                             TAG_DONE);
  367.  
  368.                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  369.                                 GA_Disabled,    FALSE,
  370.                             TAG_DONE);
  371.  
  372.                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  373.                                 GA_Disabled,    FALSE,
  374.                             TAG_DONE);
  375.  
  376.                             LT_SetAttributes(Handle,GAD_CLEAR,
  377.                                 GA_Disabled,    FALSE,
  378.                             TAG_DONE);
  379.                         }
  380.  
  381.                         PutDimensionTags(Window,FileRequest->fr_LeftEdge,FileRequest->fr_TopEdge,FileRequest->fr_Width,FileRequest->fr_Height);
  382.  
  383.                         FreeAslRequest(FileRequest);
  384.                     }
  385.  
  386.                     LT_UnlockWindow(Window);
  387.                     break;
  388.  
  389.                 case GAD_ADD:
  390.  
  391.                     if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  392.                     {
  393.                         Node->ln_Name = (STRPTR)(Node + 1);
  394.  
  395.                         Node->ln_Name[0] = 0;
  396.  
  397.                         LockGenericList(TransferList);
  398.  
  399.                         LT_SetAttributes(Handle,GAD_LIST,
  400.                             GTLV_Labels,    ~0,
  401.                         TAG_DONE);
  402.  
  403.                         AddGenericListNode(TransferList,Node,ADD_GLIST_BOTTOM,FALSE);
  404.  
  405.                         LT_SetAttributes(Handle,GAD_LIST,
  406.                             GTLV_Labels,    TransferList,
  407.                             LALV_Selected,    TransferList->ListOffset,
  408.                         TAG_DONE);
  409.  
  410.                         UnlockGenericList(TransferList);
  411.  
  412.                         LT_SetAttributes(Handle,GAD_NAME,
  413.                             GTST_String,    "",
  414.                         TAG_DONE);
  415.  
  416.                         LT_SetAttributes(Handle,GAD_REMOVE,
  417.                             GA_Disabled,    FALSE,
  418.                         TAG_DONE);
  419.  
  420.                         LT_SetAttributes(Handle,UPLOAD_BINARY,
  421.                             GA_Disabled,    FALSE,
  422.                         TAG_DONE);
  423.  
  424.                         LT_SetAttributes(Handle,UPLOAD_TEXT,
  425.                             GA_Disabled,    FALSE,
  426.                         TAG_DONE);
  427.  
  428.                         LT_SetAttributes(Handle,GAD_CLEAR,
  429.                             GA_Disabled,    FALSE,
  430.                         TAG_DONE);
  431.  
  432.                         LT_Activate(Handle,GAD_NAME);
  433.                     }
  434.                     else
  435.                         DisplayBeep(Window->WScreen);
  436.  
  437.                     break;
  438.  
  439.                 case GAD_REMOVE:
  440.  
  441.                     if(TransferList->ListNode)
  442.                     {
  443.                         LockGenericList(TransferList);
  444.  
  445.                         LT_SetAttributes(Handle,GAD_LIST,
  446.                             GTLV_Labels,    ~0,
  447.                         TAG_DONE);
  448.  
  449.                         DeleteGenericListNode(TransferList,NULL,FALSE);
  450.  
  451.                         LT_SetAttributes(Handle,GAD_LIST,
  452.                             GTLV_Labels,    TransferList,
  453.                             LALV_Selected,    TransferList->ListOffset,
  454.                         TAG_DONE);
  455.  
  456.                         if(!TransferList->ListCount)
  457.                         {
  458.                             LT_SetAttributes(Handle,GAD_REMOVE,
  459.                                 GA_Disabled,    TRUE,
  460.                             TAG_DONE);
  461.  
  462.                             LT_SetAttributes(Handle,GAD_NAME,
  463.                                 GTST_String,    "",
  464.                             TAG_DONE);
  465.  
  466.                             LT_SetAttributes(Handle,GAD_CLEAR,
  467.                                 GA_Disabled,    TRUE,
  468.                             TAG_DONE);
  469.  
  470.                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  471.                                 GA_Disabled,    TRUE,
  472.                             TAG_DONE);
  473.  
  474.                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  475.                                 GA_Disabled,    TRUE,
  476.                             TAG_DONE);
  477.                         }
  478.                         else
  479.                         {
  480.                             LT_SetAttributes(Handle,GAD_NAME,
  481.                                 GTST_String,    TransferList->ListNode->ln_Name,
  482.                             TAG_DONE);
  483.                         }
  484.  
  485.                         UnlockGenericList(TransferList);
  486.                     }
  487.  
  488.                     break;
  489.  
  490.                 case GAD_LIST:
  491.  
  492.                     SelectGenericListNode(TransferList,NULL,MsgCode);
  493.  
  494.                     LockGenericList(TransferList);
  495.  
  496.                     if(TransferList->ListNode)
  497.                     {
  498.                         LT_SetAttributes(Handle,GAD_NAME,
  499.                             GTST_String,    TransferList->ListNode->ln_Name,
  500.                         TAG_DONE);
  501.  
  502.                         LT_SetAttributes(Handle,GAD_REMOVE,
  503.                             GA_Disabled,    FALSE,
  504.                         TAG_DONE);
  505.                     }
  506.  
  507.                     UnlockGenericList(TransferList);
  508.  
  509.                     break;
  510.  
  511.                 case GAD_NAME:
  512.  
  513.                     LockGenericList(TransferList);
  514.  
  515.                     LT_SetAttributes(Handle,GAD_LIST,
  516.                         GTLV_Labels,    ~0,
  517.                     TAG_DONE);
  518.  
  519.                     if(TransferList->ListNode)
  520.                         strcpy(TransferList->ListNode->ln_Name,LT_GetString(Handle,GAD_NAME));
  521.                     else
  522.                     {
  523.                         if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  524.                         {
  525.                             Node->ln_Name = (STRPTR)(Node + 1);
  526.  
  527.                             strcpy(Node->ln_Name,LT_GetString(Handle,GAD_NAME));
  528.  
  529.                             AddGenericListNode(TransferList,Node,ADD_GLIST_BOTTOM,FALSE);
  530.  
  531.                             LT_SetAttributes(Handle,GAD_NAME,
  532.                                 GTST_String,    "",
  533.                             TAG_DONE);
  534.  
  535.                             LT_SetAttributes(Handle,GAD_REMOVE,
  536.                                 GA_Disabled,    FALSE,
  537.                             TAG_DONE);
  538.  
  539.                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  540.                                 GA_Disabled,    FALSE,
  541.                             TAG_DONE);
  542.  
  543.                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  544.                                 GA_Disabled,    FALSE,
  545.                             TAG_DONE);
  546.  
  547.                             LT_SetAttributes(Handle,GAD_CLEAR,
  548.                                 GA_Disabled,    FALSE,
  549.                             TAG_DONE);
  550.                         }
  551.                     }
  552.  
  553.                     LT_SetAttributes(Handle,GAD_LIST,
  554.                         GTLV_Labels,    TransferList,
  555.                         LALV_Selected,    ~0,
  556.                     TAG_DONE);
  557.  
  558.                     UnlockGenericList(TransferList);
  559.  
  560.                     LT_SetAttributes(Handle,GAD_REMOVE,
  561.                         GA_Disabled,    TRUE,
  562.                     TAG_DONE);
  563.  
  564.                     LT_SetAttributes(Handle,GAD_NAME,
  565.                         GTST_String,    "",
  566.                     TAG_DONE);
  567.  
  568.                     SelectGenericListNode(TransferList,NULL,-1);
  569.  
  570.                     break;
  571.  
  572.                 case GAD_CLEAR:
  573.  
  574.                     LockGenericList(TransferList);
  575.  
  576.                     LT_SetAttributes(Handle,GAD_LIST,
  577.                         GTLV_Labels,    ~0,
  578.                     TAG_DONE);
  579.  
  580.                     ClearGenericList(TransferList,FALSE);
  581.  
  582.                     LT_SetAttributes(Handle,GAD_LIST,
  583.                         GTLV_Labels,    TransferList,
  584.                         LALV_Selected,    ~0,
  585.                     TAG_DONE);
  586.  
  587.                     UnlockGenericList(TransferList);
  588.  
  589.                     LT_SetAttributes(Handle,GAD_REMOVE,
  590.                         GA_Disabled,    TRUE,
  591.                     TAG_DONE);
  592.  
  593.                     LT_SetAttributes(Handle,GAD_NAME,
  594.                         GTST_String,    "",
  595.                     TAG_DONE);
  596.  
  597.                     LT_SetAttributes(Handle,GAD_CLEAR,
  598.                         GA_Disabled,    TRUE,
  599.                     TAG_DONE);
  600.  
  601.                     LT_SetAttributes(Handle,UPLOAD_BINARY,
  602.                         GA_Disabled,    TRUE,
  603.                     TAG_DONE);
  604.  
  605.                     LT_SetAttributes(Handle,UPLOAD_TEXT,
  606.                         GA_Disabled,    TRUE,
  607.                     TAG_DONE);
  608.  
  609.                     break;
  610.  
  611.                 case UPLOAD_BINARY:
  612.                 case UPLOAD_TEXT:
  613.                 case GAD_HIDE:
  614.  
  615.                     Result = MsgGadget->GadgetID;
  616.                     break;
  617.             }
  618.         }
  619.     }
  620.  
  621.     return(Result);
  622. }
  623.  
  624.     /* QueueEntry(VOID):
  625.      *
  626.      *    The entry point for the queue process.
  627.      */
  628.  
  629. STATIC VOID SAVE_DS
  630. QueueEntry(VOID)
  631. {
  632.     if(TransferQueue = CreateMsgQueue(NULL,0))
  633.     {
  634.         struct MsgPort        *AppPort;
  635.         struct AppIcon        *AppIcon;
  636.         struct AppWindow    *AppWindow;
  637.         APTR                 OldPtr;
  638.  
  639.         if(AppPort = CreateMsgPort())
  640.         {
  641.             if((TransferSignal = AllocSignal(-1)) != -1)
  642.             {
  643.                 ULONG                 Signals;
  644.                 BOOL                 Done = FALSE;
  645.                 LayoutHandle        *Handle;
  646.                 struct Window        *LocalWindow;
  647.                 ULONG                 WindowMask,
  648.                                      TransferMask,
  649.                                      ClientMask;
  650.                 struct AppMessage    *AppMessage;
  651.                 struct DiskObject    *LoadedIcon = NULL;
  652.  
  653.                 if(WorkbenchBase && !Config->TransferConfig->HideUploadIcon)
  654.                 {
  655.                     if(IconBase)
  656.                     {
  657.                         UBYTE LocalBuffer[MAX_FILENAME_LENGTH];
  658.  
  659.                         strcpy(LocalBuffer,Config->PathConfig->DefaultStorage);
  660.  
  661.                         if(AddPart(LocalBuffer,"term_DropIcon",sizeof(LocalBuffer)))
  662.                             LoadedIcon = GetDiskObject(LocalBuffer);
  663.  
  664.                         if(!LoadedIcon)
  665.                             LoadedIcon = GetDiskObject("PROGDIR:term_DropIcon");
  666.                     }
  667.  
  668.                     AppIcon = AddAppIconA(APP_ICON,NULL,LocaleString(MSG_UPLOADQUEUE_TERM_UPLOAD_LIST_TXT),AppPort,NULL,LoadedIcon ? LoadedIcon : &DropIcon,NULL);
  669.                 }
  670.                 else
  671.                     AppIcon = NULL;
  672.  
  673.                 AppWindow        = NULL;
  674.                 WindowMask        = NULL;
  675.                 Handle            = NULL;
  676.                 LocalWindow        = NULL;
  677.                 TransferMask    = TransferQueue->SigMask;
  678.                 ClientMask        = (1L << TransferSignal);
  679.  
  680.                 TransferProcess = (struct Process *)FindTask(NULL);
  681.  
  682.                 OldPtr = NULL;
  683.  
  684.                 Signal((struct Task *)ThisProcess,SIG_HANDSHAKE);
  685.  
  686.                 do
  687.                 {
  688.                     Signals = Wait(SIG_KILL | SIG_SHOW | SIG_HIDE | SIG_GOAWAY | WindowMask | TransferMask | PORTMASK(AppPort));
  689.  
  690.                     if(Signals & TransferMask)
  691.                     {
  692.                         struct DataMsg *Item;
  693.  
  694.                         while(Item = GetMsgItem(TransferQueue))
  695.                         {
  696.                             switch(Item->Type)
  697.                             {
  698.                                     /* Show or hide the icon? */
  699.  
  700.                                 case TRANSFERMSG_TOGGLE_ICON:
  701.  
  702.                                         /* Hide the icon */
  703.  
  704.                                     if(Item->Size)
  705.                                     {
  706.                                         if(AppIcon)
  707.                                         {
  708.                                             RemoveAppIcon(AppIcon);
  709.  
  710.                                             AppIcon = NULL;
  711.                                         }
  712.  
  713.                                         if(LoadedIcon)
  714.                                         {
  715.                                             FreeDiskObject(LoadedIcon);
  716.  
  717.                                             LoadedIcon = NULL;
  718.                                         }
  719.                                     }
  720.                                     else
  721.                                     {
  722.                                         if(!AppIcon)
  723.                                         {
  724.                                             if(WorkbenchBase)
  725.                                             {
  726.                                                 if(IconBase)
  727.                                                 {
  728.                                                     UBYTE LocalBuffer[MAX_FILENAME_LENGTH];
  729.  
  730.                                                     strcpy(LocalBuffer,Config->PathConfig->DefaultStorage);
  731.  
  732.                                                     if(AddPart(LocalBuffer,"term_DropIcon",sizeof(LocalBuffer)))
  733.                                                         LoadedIcon = GetDiskObject(LocalBuffer);
  734.  
  735.                                                     if(!LoadedIcon)
  736.                                                         LoadedIcon = GetDiskObject("PROGDIR:term_DropIcon");
  737.                                                 }
  738.  
  739.                                                 AppIcon = AddAppIconA(APP_ICON,NULL,LocaleString(MSG_UPLOADQUEUE_TERM_UPLOAD_LIST_TXT),AppPort,NULL,LoadedIcon ? LoadedIcon : &DropIcon,NULL);
  740.                                             }
  741.                                             else
  742.                                                 AppIcon = NULL;
  743.                                         }
  744.                                     }
  745.  
  746.                                     break;
  747.  
  748.                                 case TRANSFERMSG_DISPLAYLIST:
  749.  
  750.                                     if(Item->Size)
  751.                                     {
  752.                                         LT_SetAttributes(Handle,GAD_LIST,
  753.                                             GTLV_Labels,    TransferList,
  754.                                             LALV_Selected,    TransferList->ListOffset,
  755.                                         TAG_DONE);
  756.  
  757.                                         if(!TransferList->ListCount)
  758.                                         {
  759.                                             LT_SetAttributes(Handle,GAD_REMOVE,
  760.                                                 GA_Disabled,    TRUE,
  761.                                             TAG_DONE);
  762.  
  763.                                             LT_SetAttributes(Handle,GAD_NAME,
  764.                                                 GTST_String,    "",
  765.                                             TAG_DONE);
  766.  
  767.                                             LT_SetAttributes(Handle,GAD_CLEAR,
  768.                                                 GA_Disabled,    TRUE,
  769.                                             TAG_DONE);
  770.  
  771.                                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  772.                                                 GA_Disabled,    TRUE,
  773.                                             TAG_DONE);
  774.  
  775.                                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  776.                                                 GA_Disabled,    TRUE,
  777.                                             TAG_DONE);
  778.                                         }
  779.                                         else
  780.                                         {
  781.                                             LT_SetAttributes(Handle,GAD_NAME,
  782.                                                 GTST_String,    TransferList->ListNode->ln_Name,
  783.                                             TAG_DONE);
  784.                                         }
  785.                                     }
  786.                                     else
  787.                                     {
  788.                                         LT_SetAttributes(Handle,GAD_LIST,
  789.                                             GTLV_Labels,~0,
  790.                                         TAG_DONE);
  791.                                     }
  792.  
  793.                                     break;
  794.                             }
  795.  
  796.                             DeleteMsgItem((struct MsgItem *)Item);
  797.                         }
  798.                     }
  799.  
  800.                     if(Signals & SIG_HIDE)
  801.                     {
  802.                             if(AppWindow)
  803.                             {
  804.                                 RemoveAppWindow(AppWindow);
  805.  
  806.                                 AppWindow = NULL;
  807.                             }
  808.  
  809.                             if(Handle)
  810.                             {
  811.                                 if(Handle->Window->WScreen == Screen)
  812.                                     PutWindowInfo(WINDOW_QUEUE,Handle->Window->LeftEdge,Handle->Window->TopEdge,Handle->Window->Width,Handle->Window->Height);
  813.  
  814.                                 LT_DeleteHandle(Handle);
  815.  
  816.                                 Handle = NULL;
  817.                             }
  818.  
  819.                             WindowMask    = NULL;
  820.                             LocalWindow    = NULL;
  821.  
  822.                             RestoreWindowPtr(OldPtr);
  823.  
  824.                             Signal((struct Task *)ThisProcess,SIG_HANDSHAKE);
  825.                     }
  826.  
  827.                     if(Signals & SIG_GOAWAY)
  828.                     {
  829.                             if(Handle)
  830.                             {
  831.                                 if(LocalWindow->WScreen == Screen)
  832.                                 {
  833.                                     if(AppWindow)
  834.                                     {
  835.                                         RemoveAppWindow(AppWindow);
  836.  
  837.                                         AppWindow = NULL;
  838.                                     }
  839.  
  840.                                     if(Handle->Window->WScreen == Screen)
  841.                                         PutWindowInfo(WINDOW_QUEUE,Handle->Window->LeftEdge,Handle->Window->TopEdge,Handle->Window->Width,Handle->Window->Height);
  842.  
  843.                                     LT_DeleteHandle(Handle);
  844.  
  845.                                     Handle        = NULL;
  846.                                     WindowMask    = NULL;
  847.                                     LocalWindow    = NULL;
  848.  
  849.                                     RestoreWindowPtr(OldPtr);
  850.                                 }
  851.                             }
  852.  
  853.                             Signal((struct Task *)ThisProcess,SIG_HANDSHAKE);
  854.                     }
  855.  
  856.                     if(Signals & SIG_KILL)
  857.                         break;
  858.  
  859.                     if(Signals & SIG_SHOW)
  860.                     {
  861.                             if(!Handle)
  862.                             {
  863.                                 Forbid();
  864.  
  865.                                 if(Handle = QueuePanel(Window))
  866.                                 {
  867.                                     Permit();
  868.  
  869.                                     if(WorkbenchBase)
  870.                                         AppWindow = AddAppWindowA(APP_WINDOW,NULL,Handle->Window,AppPort,NULL);
  871.                                     else
  872.                                         AppWindow = NULL;
  873.  
  874.                                     LocalWindow    = Handle->Window;
  875.                                     WindowMask    = PORTMASK(LocalWindow->UserPort);
  876.  
  877.                                     ChangeWindowPtr(&OldPtr,(APTR)LocalWindow);
  878.                                 }
  879.                                 else
  880.                                     Permit();
  881.                             }
  882.  
  883.                             if(Handle)
  884.                                 LT_ShowWindow(Handle,TRUE);
  885.                     }
  886.  
  887.                     if(Signals & WindowMask)
  888.                     {
  889.                         struct DataMsg    Msg;
  890.                         LONG            Type;
  891.  
  892.                         switch(Type = HandleQueueWindow(Handle))
  893.                         {
  894.                             case GAD_HIDE:
  895.  
  896.                                 if(AppWindow)
  897.                                 {
  898.                                     RemoveAppWindow(AppWindow);
  899.  
  900.                                     AppWindow = NULL;
  901.                                 }
  902.  
  903.                                 if(Handle)
  904.                                 {
  905.                                     if(Handle->Window->WScreen == Screen)
  906.                                         PutWindowInfo(WINDOW_QUEUE,Handle->Window->LeftEdge,Handle->Window->TopEdge,Handle->Window->Width,Handle->Window->Height);
  907.  
  908.                                     LT_DeleteHandle(Handle);
  909.  
  910.                                     Handle = NULL;
  911.                                 }
  912.  
  913.                                 RestoreWindowPtr(OldPtr);
  914.  
  915.                                 WindowMask    = NULL;
  916.                                 LocalWindow    = NULL;
  917.  
  918.                                 break;
  919.  
  920.                             case UPLOAD_BINARY:
  921.                             case UPLOAD_TEXT:
  922.  
  923.                                 InitMsgItem(&Msg,(DESTRUCTOR)LocalMsgDestructor);
  924.  
  925.                                 Msg.Type    = DATAMSGTYPE_UPLOAD;
  926.                                 Msg.Data    = NULL;
  927.                                 Msg.Size    = Type;
  928.                                 Msg.Client    = (struct Task *)TransferProcess;
  929.                                 Msg.Mask    = ClientMask;
  930.  
  931.                                 Forbid();
  932.  
  933.                                 ClrSignal(ClientMask);
  934.  
  935.                                 PutMsgItem(SpecialQueue,(struct MsgItem *)&Msg);
  936.  
  937.                                 Wait(ClientMask);
  938.  
  939.                                 Permit();
  940.  
  941.                                 break;
  942.                         }
  943.                     }
  944.  
  945.                     if(Signals & PORTMASK(AppPort))
  946.                     {
  947.                         while(AppMessage = (struct AppMessage *)GetMsg(AppPort))
  948.                         {
  949.                                 if(AppMessage->am_Type == AMTYPE_APPWINDOW || AppMessage->am_Type == AMTYPE_APPICON)
  950.                                 {
  951.                                     if(AppMessage->am_Type == AMTYPE_APPICON && !AppMessage->am_NumArgs)
  952.                                     {
  953.                                         if(Handle)
  954.                                             LT_ShowWindow(Handle,TRUE);
  955.                                         else
  956.                                         {
  957.                                             if(Handle = QueuePanel(NULL))
  958.                                             {
  959.                                                 AppWindow = AddAppWindowA(APP_WINDOW,NULL,Handle->Window,AppPort,NULL);
  960.  
  961.                                                 LocalWindow = Handle->Window;
  962.  
  963.                                                 WindowMask = PORTMASK(LocalWindow->UserPort);
  964.  
  965.                                                 ChangeWindowPtr(&OldPtr,(APTR)LocalWindow);
  966.                                             }
  967.                                         }
  968.                                     }
  969.                                     else
  970.                                     {
  971.                                         UBYTE    DummyBuffer[MAX_FILENAME_LENGTH];
  972.                                         BPTR    OldDir,FileLock;
  973.                                         APTR    OldPtr;
  974.                                         LONG    i;
  975.  
  976.                                         DisableDOSRequesters(&OldPtr);
  977.  
  978.                                         LockGenericList(TransferList);
  979.  
  980.                                         LT_SetAttributes(Handle,GAD_LIST,
  981.                                             GTLV_Labels,    ~0,
  982.                                         TAG_DONE);
  983.  
  984.                                         for(i = 0 ; i < AppMessage->am_NumArgs ; i++)
  985.                                         {
  986.                                             if(AppMessage->am_ArgList[i].wa_Name)
  987.                                             {
  988.                                                 OldDir = CurrentDir(AppMessage->am_ArgList[i].wa_Lock);
  989.  
  990.                                                 if(GetFileSize(AppMessage->am_ArgList[i].wa_Name))
  991.                                                 {
  992.                                                     if(FileLock = Lock(AppMessage->am_ArgList[i].wa_Name,ACCESS_READ))
  993.                                                     {
  994.                                                         if(NameFromLock(FileLock,DummyBuffer,sizeof(DummyBuffer)))
  995.                                                         {
  996.                                                             struct Node *Node;
  997.  
  998.                                                             if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  999.                                                             {
  1000.                                                                 Node->ln_Name = (STRPTR)(Node + 1);
  1001.  
  1002.                                                                 strcpy(Node->ln_Name,DummyBuffer);
  1003.  
  1004.                                                                 AddGenericListNode(TransferList,Node,ADD_GLIST_BOTTOM,FALSE);
  1005.                                                             }
  1006.                                                         }
  1007.  
  1008.                                                         UnLock(FileLock);
  1009.                                                     }
  1010.                                                 }
  1011.  
  1012.                                                 CurrentDir(OldDir);
  1013.                                             }
  1014.                                         }
  1015.  
  1016.                                         UnlockGenericList(TransferList);
  1017.  
  1018.                                         EnableDOSRequesters(OldPtr);
  1019.  
  1020.                                         LT_SetAttributes(Handle,GAD_LIST,
  1021.                                             GTLV_Labels,    TransferList,
  1022.                                         TAG_DONE);
  1023.  
  1024.                                         LT_SetAttributes(Handle,GAD_CLEAR,
  1025.                                             GA_Disabled,    !TransferList->ListCount,
  1026.                                         TAG_DONE);
  1027.  
  1028.                                         LT_SetAttributes(Handle,UPLOAD_BINARY,
  1029.                                             GA_Disabled,    !TransferList->ListCount,
  1030.                                         TAG_DONE);
  1031.  
  1032.                                         LT_SetAttributes(Handle,UPLOAD_TEXT,
  1033.                                             GA_Disabled,    !TransferList->ListCount,
  1034.                                         TAG_DONE);
  1035.                                     }
  1036.                                 }
  1037.  
  1038.                                 ReplyMsg((struct Message *)AppMessage);
  1039.                         }
  1040.                     }
  1041.                 }
  1042.                 while(!Done);
  1043.  
  1044.                 if(AppIcon)
  1045.                     RemoveAppIcon(AppIcon);
  1046.  
  1047.                 if(AppWindow)
  1048.                     RemoveAppWindow(AppWindow);
  1049.  
  1050.                 if(LoadedIcon)
  1051.                     FreeDiskObject(LoadedIcon);
  1052.  
  1053.                 if(Handle)
  1054.                 {
  1055.                     if(Handle->Window->WScreen == Screen)
  1056.                         PutWindowInfo(WINDOW_QUEUE,Handle->Window->LeftEdge,Handle->Window->TopEdge,Handle->Window->Width,Handle->Window->Height);
  1057.  
  1058.                     LT_DeleteHandle(Handle);
  1059.                 }
  1060.  
  1061.                 while(AppMessage = (struct AppMessage *)GetMsg(AppPort))
  1062.                     ReplyMsg((struct Message *)AppMessage);
  1063.  
  1064.                 FreeSignal(TransferSignal);
  1065.             }
  1066.         }
  1067.  
  1068.         DeleteMsgQueue(TransferQueue);
  1069.     }
  1070.  
  1071.     Forbid();
  1072.  
  1073.     TransferProcess = NULL;
  1074.  
  1075.     Signal((struct Task *)ThisProcess,SIG_HANDSHAKE);
  1076. }
  1077.  
  1078.     /* CloseQueueWindow():
  1079.      *
  1080.      *    Close the queue window, wherever it may be.
  1081.      */
  1082.  
  1083. VOID
  1084. CloseQueueWindow()
  1085. {
  1086.     ShakeHands((struct Task *)TransferProcess,SIG_GOAWAY);
  1087. }
  1088.  
  1089.     /* DeleteQueueProcess():
  1090.      *
  1091.      *    Terminate the queue handler process.
  1092.      */
  1093.  
  1094. VOID
  1095. DeleteQueueProcess()
  1096. {
  1097.     ShakeHands((struct Task *)TransferProcess,SIG_KILL);
  1098. }
  1099.  
  1100.     /* CreateQueueProcess():
  1101.      *
  1102.      *    Create the queue handler process, if it's still around
  1103.      *    bring it to the front.
  1104.      */
  1105.  
  1106. BOOL
  1107. CreateQueueProcess()
  1108. {
  1109.     if(!TransferProcess)
  1110.     {
  1111.         BPTR UploadDrawer = Lock(Config->PathConfig->BinaryUploadPath,SHARED_LOCK);
  1112.  
  1113.         TransferList = GenericListTable[GLIST_UPLOAD];
  1114.  
  1115.         StartProcessWaitForHandshake("term Upload process",(TASKENTRY)QueueEntry,
  1116.             NP_WindowPtr,    NULL,
  1117.             NP_CurrentDir,    UploadDrawer,
  1118.         TAG_DONE);
  1119.  
  1120.         if(!TransferProcess)
  1121.             UnLock(UploadDrawer);
  1122.     }
  1123.     else
  1124.         Signal((struct Task *)TransferProcess,SIG_SHOW);
  1125.  
  1126.     return((BOOL)(TransferProcess != NULL));
  1127. }
  1128.  
  1129.     /* ToggleUploadQueueIcon():
  1130.      *
  1131.      *    Turn the upload queue appicon on or off.
  1132.      */
  1133.  
  1134. VOID
  1135. ToggleUploadQueueIcon(BOOL Mode)
  1136. {
  1137.     if(TransferProcess)
  1138.     {
  1139.         LONG SigBit;
  1140.  
  1141.         if((SigBit = AllocSignal(-1)) != -1)
  1142.         {
  1143.             struct DataMsg Msg;
  1144.  
  1145.             InitMsgItem(&Msg,(DESTRUCTOR)LocalMsgDestructor);
  1146.  
  1147.             Msg.Type    = TRANSFERMSG_TOGGLE_ICON;
  1148.             Msg.Size    = Mode;
  1149.             Msg.Client    = FindTask(NULL);
  1150.             Msg.Mask    = 1L << SigBit;
  1151.  
  1152.             ClrSignal(Msg.Mask);
  1153.  
  1154.             PutMsgItem(TransferQueue,(struct MsgItem *)&Msg);
  1155.  
  1156.             Wait(Msg.Mask);
  1157.  
  1158.             FreeSignal(SigBit);
  1159.         }
  1160.     }
  1161. }
  1162.