home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Sound / MidI / SYNTHLIB.LHA / Synth_Librarian / sources / SynthLib / SynthLib.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-23  |  17.7 KB  |  768 lines
  1. /**************************************************************/
  2. /* $VER: SynthLib.c Revison 1.1                               */
  3. /* This file is part of Synth Librarian v1.1                  */
  4. /* ©1993-1994 Jean-Alexis MONTIGNIES                          */
  5. /* This file must not be distributed modified or separatly    */
  6. /* without my written permission                              */
  7. /* See Synth_Librarian.guide for more details                 */
  8. /**************************************************************/
  9.  
  10. /* Synth librarian main part */
  11.  
  12. #define __USE_SYSBASE
  13. #include <exec/types.h>
  14. #include <proto/exec.h>
  15. #include <proto/gadtools.h>
  16. #include <proto/intuition.h>
  17. #include <proto/utility.h>
  18. #include <libraries/gadtools.h>
  19. #include <graphics/gfx.h>
  20. #include <exec/ports.h>
  21. #include <graphics/gfxbase.h>
  22. #include <intuition/intuition.h>
  23. #include <intuition/gadgetclass.h>
  24. #include <intuition/classes.h>
  25. #include <intuition/classusr.h>
  26. #include <dos/dos.h>
  27. #include <dos/dosextens.h>
  28. #include <dos/dostags.h>
  29. #include <proto/dos.h>
  30. #include <libraries/locale.h>
  31. #include <proto/locale.h>
  32. #include <string.h>
  33. #include <stdio.h>
  34.  
  35. #define CATCOMP_NUMBERS
  36. #define CATCOMP_BLOCK
  37. #include "SynthLibLoc.h"
  38.  
  39. #include "SynthLib.h"
  40. #include "SynthLibInt.h"
  41.  
  42. #define GT_STRING(G)    (((struct StringInfo *)(((struct Gadget *)(G)) -> SpecialInfo)) -> Buffer)
  43.  
  44. #define MAIN_FLAGS_CANTEND MAIN_FLAGS_COMTASK
  45.  
  46. STRPTR VersionString="$VER: Synth Librarian v1.0  ©1993-1994 Jean-Alexis MONTIGNIES";
  47. struct DriverData *DD;
  48. BPTR DSeg;
  49. struct DriverData *(*DInit)(ULONG (*GetData)(ULONG));
  50. struct DriverData *InitDriver (ULONG (*GetData)(ULONG));
  51.  
  52. struct LocaleInfo MLi;
  53. struct MsgPort *MainPort=NULL,*ComTaskPort;
  54. struct Process *TaskCom;
  55. struct LibMessage *AMess,MyMess;
  56.  
  57. struct List DumpList={(struct Node*)&DumpList.lh_Tail,
  58.                       0,(struct Node*)&DumpList.lh_Head,0,0};
  59.  
  60. typedef char String[256];
  61. String Messages[2];
  62.  
  63. struct EasyStruct AboutES = {
  64.     sizeof (struct EasyStruct),
  65.     0,
  66.     NULL,
  67.     NULL,
  68.     NULL
  69.  };
  70.  
  71. ULONG Flags;
  72. BOOL MainMessUsed;
  73. BYTE MessageDisplayed;
  74. ULONG SelectedNumber;
  75. struct DumpNode *SelectedDump;
  76. ULONG SelectedRequest;
  77. struct Node *SelectedRequestNode;
  78.  
  79. STRPTR GetString(struct LocaleInfo *li, LONG stringNum,char *CatCompBlock);
  80. void main(void);
  81. int InitAll(void);
  82. void CloseAll(void);
  83. void EndComTask(void);
  84. int SendMainMsg(UBYTE Code,APTR Data);
  85. void StartComTask(void);
  86. void HandleCom( void );
  87. void AvailablesGadgets( void );
  88. void NewMessage(char *Str,UBYTE Code);
  89. void SelectDump(ULONG Number);
  90. void SelectRequest(ULONG Number);
  91. void AknowledgeMessage( void );
  92. void AddDumpToList(struct DumpNode *Node);
  93. void DropDump(struct DumpNode *ANode);
  94. void LoadDriver(STRPTR Name);
  95. ULONG GetData(ULONG Number);
  96. BOOL CloseDriver(void);
  97. BPTR GetDriverSeg(void);
  98. void CheckForUnknowns(struct DumpNode *Node);
  99.  
  100. STRPTR GetString(struct LocaleInfo *li, LONG stringNum,char *CatCompBlock)
  101. {
  102. LONG   *l;
  103. UWORD  *w;
  104. STRPTR  builtIn;
  105.  
  106.     l = (LONG *)CatCompBlock;
  107.  
  108.     while (*l != stringNum)
  109.     {
  110.         w = (UWORD *)((ULONG)l + 4);
  111.         l = (LONG *)((ULONG)l + (ULONG)*w + 6);
  112.     }
  113.     builtIn = (STRPTR)((ULONG)l + 6);
  114.  
  115.     if (LocaleBase)
  116.         return(GetCatalogStr(li->li_Catalog,stringNum,builtIn));
  117.  
  118.     return(builtIn);
  119. }
  120.  
  121. int InitAll()
  122.  {int ReturnCode=0;
  123.   if (LocaleBase=MLi.li_LocaleBase=OpenLibrary("locale.library",0L))
  124.     MLi.li_Catalog=OpenCatalog(NULL,"SynthLib/SynthLib.catalog",OC_BuiltInLanguage,"english",TAG_DONE);
  125.  
  126.   if (!(GfxBase=(struct GfxBase *)OpenLibrary("graphics.library",0L)))
  127.     ReturnCode=MG_INIT_GRAPHICS;
  128.  
  129.   if (!ReturnCode)
  130.     if (!(IntuitionBase=(struct IntuitionBase *)OpenLibrary("intuition.library",37L)))
  131.       ReturnCode=MG_INIT_INTUITION;
  132.  
  133.   if (!ReturnCode)
  134.     if (!(GadToolsBase=OpenLibrary("gadtools.library",0L)))
  135.       ReturnCode=MG_INIT_GADTOOLS;
  136.  
  137.   if (!ReturnCode)
  138.     if (!(UtilityBase=OpenLibrary("utility.library",0L)))
  139.       ReturnCode=MG_INIT_UTILITY;
  140.  
  141.   if (!ReturnCode)
  142.     if (FileOpInit())
  143.       ReturnCode=MG_INIT_ASL;
  144.  
  145.   if (!ReturnCode)
  146.     if (SetupScreen())
  147.       ReturnCode=MG_INIT_SCREEN;
  148.  
  149.   if (!ReturnCode)
  150.     if (OpenLibWindow())
  151.       ReturnCode=MG_INIT_WINDOW;
  152.      else
  153.      {
  154.       MessageDisplayed=-1;
  155.       SelectedNumber=~0;
  156.       SelectedDump=NULL;
  157.       SelectedRequest=~0;
  158.       SelectedRequestNode=0;
  159.      }
  160.  
  161.   if (!ReturnCode)
  162.     if (!(MainPort=CreatePort(0,0)))
  163.       ReturnCode=MG_INIT_PORT;
  164.      else
  165.      {
  166.       MyMess.LMess.mn_ReplyPort=MainPort;
  167.       MainMessUsed=FALSE;
  168.      }
  169.  
  170.   Flags=0;
  171.  
  172.   return(ReturnCode);
  173.  }
  174.  
  175. void CloseAll()
  176.  {
  177.   if (DD)
  178.    {GT_SetGadgetAttrs(LibGadgets[GD_TypeList],LibWnd,NULL,GTLV_Labels,NULL,TAG_DONE);
  179.     DD->Close();
  180. #ifndef DEBUG_SL
  181.     UnLoadSeg(DSeg);
  182. #endif
  183.    }
  184.   LibNew();
  185.   CloseLibWindow();
  186.   CloseDownScreen();
  187.  
  188.   FileOpClose();
  189.  
  190.   if (UtilityBase)
  191.     CloseLibrary(UtilityBase);
  192.  
  193.   if (GadToolsBase)
  194.     CloseLibrary(GadToolsBase);
  195.  
  196.   if (IntuitionBase)
  197.     CloseLibrary((struct Library *)IntuitionBase);
  198.  
  199.   if (GfxBase)
  200.     CloseLibrary((struct Library *)GfxBase);
  201.  
  202.   if (MainPort)
  203.     DeletePort(MainPort);
  204.  
  205.   if (MLi.li_LocaleBase)
  206.    {
  207.     CloseCatalog(MLi.li_Catalog);
  208.     CloseLibrary(MLi.li_LocaleBase);
  209.    }
  210.  }
  211.  
  212. void NewMessage(char *Str,UBYTE Code)
  213.  {if (Str && (Code>=0) && (Code<=1))
  214.    {stccpy(Messages[Code],Str,255);
  215.     if (MessageDisplayed<=Code)
  216.      {MessageDisplayed=Code;
  217.       GT_SetGadgetAttrs(LibGadgets[GD_Info],LibWnd,NULL,GTTX_Text,Messages[Code],TAG_DONE);
  218.      }
  219.    }
  220.  }
  221.  
  222. void AknowledgeMessage()
  223.  {if (MessageDisplayed>=1)
  224.    {MessageDisplayed--;
  225.     GT_SetGadgetAttrs(LibGadgets[GD_Info],LibWnd,NULL,GTTX_Text,Messages[MessageDisplayed],TAG_DONE);
  226.    }
  227.  }
  228.  
  229. int LibCloseWindow(void)
  230.  {Flags|=MAIN_FLAGS_END;
  231.   EndComTask();
  232.   return(0);
  233.  }
  234.  
  235. int DataNodesClicked()
  236.  {SelectDump(LibMsg.Code);
  237.   return(0);
  238.  }
  239.  
  240. int NodeNameClicked()
  241.  {if (SelectedNumber!=~0)
  242.    {GT_SetGadgetAttrs(LibGadgets[GD_DataNodes],LibWnd,NULL,GTLV_Labels,~0,TAG_DONE);
  243.     stccpy(SelectedDump->Name,GT_STRING(LibMsg.IAddress),32);
  244.     SelectedDump->Flags&= ~NODE_FLAGS_UNNAMED;
  245.     GT_SetGadgetAttrs(LibGadgets[GD_DataNodes],LibWnd,NULL,GTLV_Labels,&DumpList,TAG_DONE);
  246.     SelectDump(~0);
  247.    }
  248.   return(0);
  249.  }
  250.  
  251. int AboutLib()
  252.  {AboutES.es_TextFormat=GetString(&MLi,MG_INFO_ABOUT,MainCatBlock);
  253.   AboutES.es_GadgetFormat=GetString(&MLi,MG_INFO_OK,MainCatBlock);
  254.   EasyRequest( LibWnd, &AboutES, NULL );
  255.   return(0);
  256.  }
  257.  
  258. int AboutDriver(void)
  259.  {if (DD && DD->About)
  260.    {AboutES.es_TextFormat=DD->About();
  261.     AboutES.es_GadgetFormat=GetString(&MLi,MG_INFO_OK,MainCatBlock);
  262.     EasyRequest( LibWnd, &AboutES, NULL );
  263.    }
  264.   return(0);
  265.  }
  266.  
  267. int RemoveLib()
  268.  {if (SelectedDump)
  269.    {struct DumpNode *RNode;
  270.  
  271.     RNode=SelectedDump;
  272.     SelectDump(~0);
  273.     GT_SetGadgetAttrs(LibGadgets[GD_DataNodes],LibWnd,NULL,GTLV_Labels,~0,TAG_DONE);
  274.     DropDump(RNode);
  275.     GT_SetGadgetAttrs(LibGadgets[GD_DataNodes],LibWnd,NULL,GTLV_Labels,&DumpList,TAG_DONE);
  276.    }
  277.   return(0);
  278.  }
  279.  
  280. int SENDClicked()
  281.  {if ((SelectedNumber!=~0) && (Flags && MAIN_FLAGS_COMTASK))
  282.     if(!SendMainMsg(MSGCODE_SEND,(APTR)SelectedDump))
  283.      {
  284.       SelectedDump->Flags|=NODE_FLAGS_BUSY;
  285.       Flags|=MAIN_FLAGS_SEND;
  286.  
  287.       AvailablesGadgets();
  288.      }
  289.   return(0);
  290.  }
  291.  
  292. int AbortClicked()
  293.  {if (Flags && MAIN_FLAGS_COMTASK) SendMainMsg(MSGCODE_ABORT,0);
  294.   return(0);
  295.  }
  296.  
  297. int TypeListClicked()
  298.  {SelectRequest(LibMsg.Code);
  299.   return(0);
  300.  }
  301.  
  302. int RequestClicked()
  303.  {if ((SelectedRequest!=~0) && (Flags & MAIN_FLAGS_COMTASK))
  304.     if(!SendMainMsg(MSGCODE_REQUEST,(APTR)SelectedRequestNode))
  305.      {
  306.       Flags|=MAIN_FLAGS_REQUEST;
  307.  
  308.       AvailablesGadgets();
  309.      }
  310.   return(0);
  311.  }
  312.  
  313. void DropDump(struct DumpNode *ANode)
  314.  {if (!(ANode->Flags & NODE_FLAGS_BUSY))
  315.    {
  316.     Remove((struct Node *)ANode);
  317.     FreeMem(ANode->Dump,ANode->DumpLength);
  318.     if (ANode->Data)
  319.       FreeMem(ANode->Data,ANode->DataLength);
  320.  
  321.     FreeMem(ANode,sizeof(struct DumpNode));
  322.    }
  323.    else
  324.     NewMessage(GetString(&MLi,MG_ERROR_INUSE,MainCatBlock),1);
  325.  }
  326.  
  327. int LibNew()
  328.  {struct DumpNode *Node1,*Node2;
  329.  
  330.   SelectDump(~0);
  331.  
  332.   GT_SetGadgetAttrs(LibGadgets[GD_DataNodes],LibWnd,NULL,GTLV_Labels,~0,TAG_DONE);
  333.   Node1=(struct DumpNode *)DumpList.lh_Head;
  334.  
  335.   while (Node2=(struct DumpNode *)Node1->DNode.ln_Succ)
  336.    {DropDump(Node1);
  337.     Node1=Node2;
  338.    }
  339.  
  340.   GT_SetGadgetAttrs(LibGadgets[GD_DataNodes],LibWnd,NULL,GTLV_Labels,&DumpList,TAG_DONE);
  341.  
  342.   Flags&=~MAIN_FLAGS_NAMED;
  343.   return(0);
  344.  }
  345.  
  346. void CheckForUnknowns(struct DumpNode *Node)
  347.  {struct Node * TypeNode;
  348.   if ((!(Node->Name[0])) || (Node->Flags & NODE_FLAGS_UNNAMED))
  349.    {strcpy(Node->Name,GetString(&MLi,MG_NODE_UNNAMED,MainCatBlock));
  350.     Node->Flags|=NODE_FLAGS_UNNAMED;
  351.    }
  352.  
  353.   if (!(Node->Type[0]))
  354.     Node->Flags|=NODE_FLAGS_UNTYPED;
  355.  
  356.   if (DD && (Node->Flags & NODE_FLAGS_UNTYPED))
  357.     if (DD->Recognize)
  358.       if (TypeNode=DD->Recognize(Node))
  359.        {strcpy (Node->Type,TypeNode->ln_Name);
  360.         Node->Flags&= ~NODE_FLAGS_UNTYPED;
  361.        }
  362.  
  363.   if (Node->Flags & NODE_FLAGS_UNTYPED)
  364.     strcpy(Node->Type,GetString(&MLi,MG_NODE_UNTYPED,MainCatBlock));
  365. }
  366.  
  367. void AddDumpToList(struct DumpNode *Node)
  368.  {
  369.   Node->DNode.ln_Name=(char *)&(Node->Name);
  370.   Node->DNode.ln_Type=0;
  371.  
  372.   CheckForUnknowns(Node);
  373.  
  374.   SelectDump(~0);
  375.   GT_SetGadgetAttrs(LibGadgets[GD_DataNodes],LibWnd,NULL,GTLV_Labels,~0,TAG_DONE);
  376.  
  377.   AddTail(&DumpList,(struct Node *)Node);
  378.  
  379.   GT_SetGadgetAttrs(LibGadgets[GD_DataNodes],LibWnd,NULL,GTLV_Labels,&DumpList,TAG_DONE);
  380.  
  381.   AvailablesGadgets();
  382.  }
  383.  
  384. void SelectDump(ULONG Number)
  385.  {
  386.   SelectedNumber=Number;
  387.   if (SelectedNumber==~0)
  388.    {
  389.     SelectedDump=0;
  390.     GT_SetGadgetAttrs(LibGadgets[GD_DUMP_TYPE],LibWnd,NULL,GTTX_Text,NULL,TAG_DONE);
  391.     GT_SetGadgetAttrs(LibGadgets[GD_DUMP_LENGTH],LibWnd,NULL,GTNM_Number,0,TAG_DONE);
  392.    }
  393.    else
  394.    {SelectedDump=(struct DumpNode *)DumpList.lh_Head;
  395.  
  396.     while((SelectedDump->DNode.ln_Succ) && Number--)
  397.       SelectedDump=(struct DumpNode *)SelectedDump->DNode.ln_Succ;
  398.  
  399.     if (SelectedDump->DNode.ln_Succ)
  400.      {
  401.       GT_SetGadgetAttrs(LibGadgets[GD_DUMP_TYPE],LibWnd,NULL,GTTX_Text,SelectedDump->Type,TAG_DONE);
  402.       GT_SetGadgetAttrs(LibGadgets[GD_DUMP_LENGTH],LibWnd,NULL,GTNM_Number,(ULONG)SelectedDump->DumpLength,TAG_DONE);
  403.      }
  404.      else
  405.      {SelectedNumber=~0;
  406.       SelectedDump=NULL;
  407.      }
  408.    }
  409.   AvailablesGadgets();
  410.  }
  411.  
  412. void SelectRequest(ULONG Number)
  413.  {
  414.   if (DD)
  415.     if (DD->TypeList)
  416.      {SelectedRequest=Number;
  417.       if (SelectedRequest==~0)
  418.         SelectedRequestNode=0;
  419.        else
  420.        {SelectedRequestNode=DD->TypeList->lh_Head;
  421.  
  422.         while((SelectedRequestNode->ln_Succ) && Number--)
  423.           SelectedRequestNode=SelectedRequestNode->ln_Succ;
  424.  
  425.         if (!SelectedRequestNode->ln_Succ)
  426.          {SelectedRequest=~0;
  427.           SelectedRequestNode=NULL;
  428.          }
  429.        }
  430.      }
  431.      else
  432.      {SelectedRequestNode=0;
  433.       SelectedRequest=~0;
  434.      }
  435.    else
  436.    {SelectedRequestNode=0;
  437.     SelectedRequest=~0;
  438.    }
  439.  
  440.   AvailablesGadgets();
  441.  }
  442.  
  443. int SERIALClicked( void )
  444.  {if (!(Flags & (MAIN_FLAGS_CLOSETASK | MAIN_FLAGS_END)))
  445.    {if (Flags & MAIN_FLAGS_COMTASK)
  446.       EndComTask();
  447.      else
  448.       StartComTask();
  449.    }
  450.  
  451.   return (0);
  452.  }
  453.  
  454.  
  455. int NewDriver(void)
  456.  {if (!(Flags & MAIN_FLAGS_CHANGE_DRIVER))
  457.     if (CloseDriver())
  458.       LoadDriver(NULL);
  459.      else
  460.       Flags|=MAIN_FLAGS_CHANGE_DRIVER;
  461.  
  462.   return(0);
  463.  }
  464.  
  465. BOOL CloseDriver(void)
  466.  {BOOL ReturnCode;
  467.  
  468.   if (DD)
  469.     if (Flags & MAIN_FLAGS_DRIVER)
  470.  
  471.      {
  472.       SendMainMsg(MSGCODE_QUIT_DRIVER,0);
  473.       ReturnCode=FALSE;
  474.      }
  475.      else
  476.      {
  477.       SelectRequest(~0);
  478.       GT_SetGadgetAttrs(LibGadgets[GD_TypeList],LibWnd,NULL,GTLV_Labels,0,TAG_DONE);
  479.       DD->Close();
  480.       DD=NULL;
  481.       ReturnCode=TRUE;
  482.       AvailablesGadgets();
  483.      }
  484.    else
  485.     ReturnCode=TRUE;
  486.  
  487.   return(ReturnCode);
  488.  }
  489.  
  490. void EndComTask(void)
  491. {
  492.  if (Flags & MAIN_FLAGS_COMTASK)
  493.   {Flags|=MAIN_FLAGS_CLOSETASK;
  494.    SendMainMsg(MSGCODE_EXIT,0);
  495.    AvailablesGadgets();
  496.   }
  497. }
  498.  
  499. int SendMainMsg(UBYTE Code,APTR Data)
  500. {if (MainMessUsed)
  501.    return(1);
  502.   else
  503.   {MainMessUsed=TRUE;
  504.    MyMess.Code=Code;
  505.    MyMess.Data=Data;
  506.    PutMsg(ComTaskPort,(struct Message *)&MyMess);
  507.    return(0);
  508.   }
  509. }
  510.  
  511. void LoadDriver(STRPTR Name)
  512.  {
  513.   Flags&=~MAIN_FLAGS_CHANGE_DRIVER;
  514.  
  515. #ifndef DEBUG_SL
  516.   if (Name)
  517.     DSeg=LoadSeg(Name);
  518.    else
  519.     DSeg=GetDriverSeg();
  520. #endif
  521.  
  522. #ifndef DEBUG_SL
  523.   if (DSeg)
  524.    {DInit=(DSeg+1)<<2;
  525. #else
  526.   if (TRUE)
  527.    {DInit=InitDriver;
  528. #endif
  529.     DD=DInit(GetData);
  530.     GT_SetGadgetAttrs(LibGadgets[GD_TypeList],LibWnd,NULL,GTLV_Labels,DD->TypeList,TAG_DONE);
  531. #ifndef DEBUG_SL
  532.     if (!DD)
  533.       UnLoadSeg(DSeg);
  534. #endif
  535.     if (Flags & MAIN_FLAGS_COMTASK)
  536.      {
  537.       SendMainMsg(MSGCODE_NEW_DRIVER,(UBYTE *)DD->Driver);
  538.       Flags|=MAIN_FLAGS_CHANGE_DRIVER;
  539.      }
  540.    }
  541.    else
  542.     DD=NULL;
  543.  }
  544.  
  545. __saveds ULONG GetData(ULONG Number)
  546. {ULONG ReturnCode;
  547.  
  548.   switch(Number)
  549.    {case GTD_DosBase:
  550.       ReturnCode=(ULONG)DOSBase;
  551.  
  552.       break;
  553.  
  554.     case GTD_ExecBase:
  555.       ReturnCode=(ULONG)SysBase;
  556.  
  557.       break;
  558.  
  559.     case GTD_LocaleBase:
  560.       ReturnCode=(ULONG)LocaleBase;
  561.  
  562.       break;
  563.  
  564.     case GTD_IntuitionBase:
  565.       ReturnCode=(ULONG)IntuitionBase;
  566.  
  567.       break;
  568.  
  569.     default:
  570.       ReturnCode=0;
  571.  
  572.    }
  573.   return(ReturnCode);
  574.  }
  575.  
  576. void StartComTask(void)
  577.  {
  578.   TaskCom=CreateNewProcTags(NP_Entry,ComTask,NP_StackSize,4096,
  579.                                NP_Name,"SynthLib MIDI Task");
  580.  
  581.   if (TaskCom)
  582.    {
  583.     Wait(1<<(MainPort->mp_SigBit));
  584.     AMess=(struct LibMessage *)GetMsg(MainPort);
  585.     NewMessage(AMess->Data,AMess->Code);
  586.  
  587.     if (AMess->Code==MSGCODE_INFO)
  588.      {ComTaskPort=AMess->LMess.mn_ReplyPort;
  589.       Flags|=MAIN_FLAGS_COMTASK;
  590.       if (DD)
  591.         SendMainMsg(MSGCODE_NEW_DRIVER,(UBYTE *)DD->Driver);
  592.      }
  593.      else
  594.       Flags|=MAIN_FLAGS_CLOSETASK;
  595.  
  596.     ReplyMsg((struct Message *)AMess);
  597.  
  598.     AvailablesGadgets();
  599.    }
  600.  }
  601.  
  602. void HandleCom( void )
  603.  {while(AMess=(struct LibMessage *)GetMsg(MainPort))
  604.  
  605.     if(AMess->LMess.mn_ReplyPort==MainPort)
  606.  
  607.      {MainMessUsed=FALSE;
  608.       if (AMess->Code & MSGCODE_IGNORED)
  609.         switch(AMess->Code & ~MSGCODE_IGNORED)
  610.          {case MSGCODE_SEND:
  611.             ((struct DumpNode *)AMess->Data)->Flags&=~NODE_FLAGS_BUSY;
  612.             Flags&=~MAIN_FLAGS_SEND;
  613.             AvailablesGadgets();
  614.  
  615.             break;
  616.  
  617.           case MSGCODE_REQUEST:
  618.  
  619.             Flags&=~MAIN_FLAGS_REQUEST;
  620.  
  621.             break;
  622.  
  623.           case MSGCODE_NEW_DRIVER:
  624.  
  625.             Flags&=~MAIN_FLAGS_CHANGE_DRIVER;
  626.  
  627.             break;
  628.          }
  629.        else
  630.         switch(AMess->Code)
  631.          {case MSGCODE_NEW_DRIVER:
  632.  
  633.             Flags|=MAIN_FLAGS_DRIVER;
  634.             Flags&=~MAIN_FLAGS_CHANGE_DRIVER;
  635.             AvailablesGadgets();
  636.          }
  637.      }
  638.      else
  639.      {
  640.       switch (AMess->Code)
  641.        {case MSGCODE_REQ_RESULT:
  642.  
  643.           Flags&=~MAIN_FLAGS_REQUEST;
  644.           if (AMess->Data)
  645.             AddDumpToList((struct DumpNode *)AMess->Data);
  646.            else
  647.             AvailablesGadgets();
  648.  
  649.           break;
  650.  
  651.         case MSGCODE_BYE:
  652.           Signal((struct Task *)TaskCom,SIGBREAKF_CTRL_C);
  653.           Flags&=~(MAIN_FLAGS_COMTASK | MAIN_FLAGS_CLOSETASK | MAIN_FLAGS_DRIVER | MAIN_FLAGS_CHANGE_DRIVER);
  654.           AvailablesGadgets();
  655.           NewMessage(AMess->Data,0);
  656.  
  657.           break;
  658.  
  659.         case MSGCODE_DRIVER_QUITED:
  660.           Flags&=~MAIN_FLAGS_DRIVER;
  661.           AvailablesGadgets();
  662.           CloseDriver();
  663.           if (Flags & MAIN_FLAGS_CHANGE_DRIVER)
  664.            {
  665.             LoadDriver(NULL);
  666.            }
  667.  
  668.           break;
  669.  
  670.         case MSGCODE_DATA:
  671.  
  672.           AddDumpToList((struct DumpNode *)AMess->Data);
  673.  
  674.           break;
  675.  
  676.         case MSGCODE_SEND_FINISHED:
  677.  
  678.           ((struct DumpNode *)AMess->Data)->Flags&=~NODE_FLAGS_BUSY;
  679.           Flags&=~MAIN_FLAGS_SEND;
  680.  
  681.           AvailablesGadgets();
  682.  
  683.           break;
  684.  
  685.         case MSGCODE_INFO:
  686.         case MSGCODE_ERROR:
  687.  
  688.           NewMessage(AMess->Data,AMess->Code);
  689.  
  690.           break;
  691.        }
  692.       ReplyMsg((struct Message *)AMess);
  693.      }
  694.  }
  695.  
  696. void AvailablesGadgets( void )
  697.  {BOOL Cond1;
  698.   /*if ((Flags & FLAGS_MAIN_COMTASK) && !(Flags & FLAGS_CLOSETASK))*/
  699.   GT_SetGadgetAttrs(LibGadgets[GD_SERIAL],LibWnd,NULL,GTCB_Checked,((Flags&MAIN_FLAGS_COMTASK)!=0),TAG_DONE);
  700.   GT_SetGadgetAttrs(LibGadgets[GD_SERIAL],LibWnd,NULL,GA_Disabled,((Flags & MAIN_FLAGS_CLOSETASK)!=0),TAG_DONE);
  701.   Cond1=((Flags & MAIN_FLAGS_COMTASK) && (Flags & MAIN_FLAGS_DRIVER) && !(Flags & (MAIN_FLAGS_CLOSETASK | MAIN_FLAGS_SEND | MAIN_FLAGS_REQUEST)));
  702.   GT_SetGadgetAttrs(LibGadgets[GD_SEND],LibWnd,NULL,GA_Disabled,(!Cond1 || (SelectedNumber==~0)),TAG_DONE);
  703.   GT_SetGadgetAttrs(LibGadgets[GD_Request],LibWnd,NULL,GA_Disabled,(!Cond1 || (SelectedRequest==~0)),TAG_DONE);
  704.   if (DumpList.lh_Head->ln_Succ && (MAIN_FLAGS_NAMED & Flags))
  705.     OnMenu(LibWnd,FULLMENUNUM(0,4,0));
  706.    else
  707.     OffMenu(LibWnd,FULLMENUNUM(0,4,0));
  708.  
  709.   if (DumpList.lh_Head->ln_Succ)
  710.     OnMenu(LibWnd,FULLMENUNUM(0,5,0));
  711.    else
  712.     OffMenu(LibWnd,FULLMENUNUM(0,5,0));
  713.  
  714.   if (SelectedNumber!=~0)
  715.     OnMenu(LibWnd,FULLMENUNUM(1,2,0));
  716.    else
  717.     OffMenu(LibWnd,FULLMENUNUM(1,2,0));
  718.  
  719.   if (SelectedNumber!=~0)
  720.     if (SelectedDump->Flags & NODE_FLAGS_BUSY)
  721.       OffMenu(LibWnd,FULLMENUNUM(1,0,0));
  722.      else
  723.       OnMenu(LibWnd,FULLMENUNUM(1,0,0));
  724.    else
  725.     OffMenu(LibWnd,FULLMENUNUM(1,0,0));
  726.  
  727.   if (Cond1 && (SelectedNumber!=~0))
  728.     OnMenu(LibWnd,FULLMENUNUM(1,4,0));
  729.    else
  730.     OffMenu(LibWnd,FULLMENUNUM(1,4,0));
  731.  
  732.   if (Flags & MAIN_FLAGS_DRIVER)
  733.     OnMenu(LibWnd,FULLMENUNUM(2,2,0));
  734.    else
  735.     OffMenu(LibWnd,FULLMENUNUM(2,2,0));
  736.  
  737.  }
  738.  
  739. void main( void )
  740.  {int Error;
  741.   ULONG WaitCom,WaitIntui,WaitAll,WichSignal;
  742.  
  743.   Error=InitAll();
  744.  
  745.   if (!Error)
  746.    {
  747.     StartComTask();
  748.  
  749.     WaitIntui=1<<(LibWnd->UserPort->mp_SigBit);
  750.     WaitCom=1<<(MainPort->mp_SigBit);
  751.     WaitAll=WaitCom | WaitIntui;
  752.  
  753.     HandleLibIDCMP();
  754.     HandleCom();
  755.  
  756.       while ((Flags & MAIN_FLAGS_CANTEND) || !(Flags & MAIN_FLAGS_END))
  757.        {WichSignal=Wait(WaitAll);
  758.         if (WichSignal & WaitIntui)
  759.           HandleLibIDCMP();
  760.         if (WichSignal & WaitCom)
  761.           HandleCom();
  762.        }
  763.    }
  764.    else
  765.      printf("%s\n",GetString(&MLi,Error,MainCatBlock));
  766.   CloseAll();
  767.  }
  768.