home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 500-599 / ff589.lza / Term / TermSrc.lha / Packet.c < prev    next >
C/C++ Source or Header  |  1991-11-24  |  20KB  |  906 lines
  1. /* $Revision Header * Header built automatically - do not edit! *************
  2.  *
  3.  *    (C) Copyright 1991 by Olaf 'Olsen' Barthel & MXM
  4.  *
  5.  *    Name .....: Packet.c
  6.  *    Created ..: Wednesday 06-Feb-91 12:35
  7.  *    Revision .: 0
  8.  *
  9.  *    Date            Author          Comment
  10.  *    =========       ========        ====================
  11.  *    06-Feb-91       Olsen           Created this file!
  12.  *
  13.  * $Revision Header ********************************************************/
  14.  
  15. #include "TermGlobal.h"
  16.  
  17.     /* Some private data required to handle both the window,
  18.      * the editing functions and the command history buffer.
  19.      */
  20.  
  21. STATIC struct Hook         PacketHook;
  22. STATIC UBYTE             PacketWorkBuffer[256];
  23. STATIC struct StringInfo    *PacketInfo;
  24.  
  25. STATIC struct Node        *PacketNode;
  26. STATIC LONG             PacketLine;
  27.  
  28. STATIC LONG             PacketX = -1,PacketY = -1,PacketWidth = -1,PacketHeight = -1;
  29.  
  30.     /* The menu to attach to the packet window. */
  31.  
  32. enum    {    MEN_LOADHISTORY=1,MEN_SAVEHISTORY,MEN_CLEARHISTORY,MEN_OTHERWINDOW,MEN_QUITPANEL };
  33.  
  34. STATIC struct NewMenu NewPacketMenu[] =
  35. {
  36.     { NM_TITLE, "Project",         0 , 0, 0, (APTR)0},
  37.     {  NM_ITEM, "Load History...",    "O", 0, 0, (APTR)MEN_LOADHISTORY},
  38.     {  NM_ITEM, "Save History...",    "S", 0, 0, (APTR)MEN_SAVEHISTORY},
  39.     {  NM_ITEM, NM_BARLABEL,     0 , 0, 0, (APTR)0},
  40.     {  NM_ITEM, "Clear History",    "K", 0, 0, (APTR)MEN_CLEARHISTORY},
  41.     {  NM_ITEM, NM_BARLABEL,     0 , 0, 0, (APTR)0},
  42.     {  NM_ITEM, "Other Window",    "-", 0, 0, (APTR)MEN_OTHERWINDOW},
  43.     {  NM_ITEM, NM_BARLABEL,     0 , 0, 0, (APTR)0},
  44.     {  NM_ITEM, "Quit",        "Q", 0, 0, (APTR)MEN_QUITPANEL},
  45.     { NM_END, 0,             0 , 0, 0, (APTR)0}
  46. };
  47.  
  48.     /* ClearPacketHistory():
  49.      *
  50.      *    Release the command history.
  51.      */
  52.  
  53. VOID
  54. ClearPacketHistory()
  55. {
  56.     struct Node *SomeNode,*NextNode;
  57.  
  58.     SomeNode = PacketHistoryList . lh_Head;
  59.  
  60.     while(SomeNode -> ln_Succ)
  61.     {
  62.         NextNode = SomeNode -> ln_Succ;
  63.  
  64.         Remove(SomeNode);
  65.  
  66.         FreeVec(SomeNode);
  67.  
  68.         SomeNode = NextNode;
  69.     }
  70.  
  71.     PacketNode = PacketHistoryList . lh_Head;
  72.  
  73.     PacketLine = 0;
  74. }
  75.  
  76.     /* DeletePacketWindow():
  77.      *
  78.      *    Delete the packet window and release the command
  79.      *    history.
  80.      */
  81.  
  82. VOID
  83. DeletePacketWindow()
  84. {
  85.     if(PacketWindow)
  86.     {
  87.         PacketWindow -> Flags |= WFLG_RMBTRAP;
  88.  
  89.         ClearMenuStrip(PacketWindow);
  90.  
  91.         if(PacketGadgetList)
  92.             RemoveGList(PacketWindow,PacketGadgetList,(UWORD)-1);
  93.  
  94.         PacketX        = PacketWindow -> LeftEdge;
  95.         PacketY        = PacketWindow -> TopEdge;
  96.  
  97.         PacketWidth    = PacketWindow -> Width;
  98.         PacketHeight    = PacketWindow -> Height;
  99.  
  100.         CloseWindow(PacketWindow);
  101.  
  102.         PacketWindow = NULL;
  103.     }
  104.  
  105.     if(PacketGadgetList)
  106.     {
  107.         FreeGadgets(PacketGadgetList);
  108.  
  109.         PacketGadgetList = NULL;
  110.     }
  111.  
  112.     ClearPacketHistory();
  113.  
  114.     if(PacketMenu)
  115.     {
  116.         FreeMenus(PacketMenu);
  117.  
  118.         PacketMenu = NULL;
  119.     }
  120. }
  121.  
  122.     /* AddPacketHistory(UBYTE *Buffer):
  123.      *
  124.      *    Add a line to the packet window command history. This
  125.      *    works very much the same as the AddLine()-routine.
  126.      */
  127.  
  128. VOID
  129. AddPacketHistory(UBYTE *Buffer)
  130. {
  131.     struct Node *SomeNode;
  132.  
  133.     if(SomeNode = (struct Node *)AllocVec(sizeof(struct Node) + strlen(Buffer) + 1,MEMF_PUBLIC|MEMF_CLEAR))
  134.     {
  135.         SomeNode -> ln_Name = (UBYTE *)(SomeNode + 1);
  136.  
  137.         strcpy(SomeNode -> ln_Name,Buffer);
  138.  
  139.         AddTail(&PacketHistoryList,SomeNode);
  140.  
  141.         PacketNode = NULL;
  142.  
  143.         PacketLine++;
  144.     }
  145. }
  146.  
  147.     /* CreateAllGadgets():
  148.      *
  149.      *    Create the packet string gadget.
  150.      */
  151.  
  152. STATIC struct Gadget *
  153. CreateAllGadgets(LONG Width,struct Gadget **GadgetArray,struct Gadget **GadgetList,APTR VisualInfo,UWORD TopEdge)
  154. {
  155.     struct Gadget        *Gadget;
  156.     struct NewGadget     NewGadget;
  157.  
  158.     memset(&NewGadget,0,sizeof(struct NewGadget));
  159.  
  160.     if(Gadget = CreateContext(GadgetList))
  161.     {
  162.         NewGadget . ng_Width        = Width - 26;
  163.         NewGadget . ng_Height        = PacketHeight - 15;
  164.         NewGadget . ng_GadgetText    = NULL;
  165.         NewGadget . ng_TextAttr        = &DefaultFont;
  166.         NewGadget . ng_VisualInfo    = VisualInfo;
  167.         NewGadget . ng_GadgetID        = 0;
  168.         NewGadget . ng_Flags        = 0;
  169.         NewGadget . ng_LeftEdge        = 6;
  170.         NewGadget . ng_TopEdge        = 1 + TopEdge;
  171.  
  172.         GadgetArray[0] = Gadget = CreateGadget(STRING_KIND,Gadget,&NewGadget,
  173.             GTST_MaxChars,    256,
  174.             GTST_EditHook,    &PacketHook,
  175.             GA_TabCycle,    FALSE,
  176.         TAG_DONE);
  177.     }
  178.  
  179.     return(Gadget);
  180. }
  181.  
  182.     /* CreatePacketWindow():
  183.      *
  184.      *    Open the packet window and allocate the command history
  185.      *    buffer.
  186.      */
  187.  
  188. BYTE
  189. CreatePacketWindow()
  190. {
  191.     PacketNode = PacketHistoryList . lh_Head;
  192.  
  193.     if(PacketMenu = CreateMenus(NewPacketMenu,
  194.         GTMN_FrontPen, 0,
  195.     TAG_DONE))
  196.     {
  197.         if(LayoutMenus(PacketMenu,VisualInfo,
  198.             GTMN_TextAttr,&DefaultFont,
  199.         TAG_DONE))
  200.         {
  201.             if(PacketWidth == -1)
  202.                 PacketWidth = Screen -> Width;
  203.  
  204.             if(PacketHeight == -1)
  205.                 PacketHeight = 29;
  206.  
  207.             if(PacketX == -1 || (PacketX + PacketWidth > Screen -> Width))
  208.             {
  209.                 PacketX = 0;
  210.  
  211.                 if(PacketX + PacketWidth > Screen -> Width)
  212.                     PacketWidth = Screen -> Width;
  213.             }
  214.  
  215.             if(PacketY == -1 || (PacketY + PacketHeight > Screen -> Height))
  216.             {
  217.                 PacketY = Window -> TopEdge + Window -> Height;
  218.  
  219.                 if(PacketY + PacketHeight > Screen -> Height)
  220.                     PacketHeight = 29;
  221.             }
  222.  
  223.             if(CreateAllGadgets(PacketWidth,&PacketGadgetArray[0],&PacketGadgetList,VisualInfo,Screen -> WBorTop + Screen -> Font -> ta_YSize + 1))
  224.             {
  225.                 if(PacketWindow = OpenWindowTags(NULL,
  226.                     WA_Width,    PacketWidth,
  227.                     WA_Height,    PacketHeight,
  228.  
  229.                     WA_Left,    PacketX,
  230.                     WA_Top,        PacketY,
  231.  
  232.                     WA_Activate,    TRUE,
  233.                     WA_DragBar,    TRUE,
  234.                     WA_DepthGadget,    TRUE,
  235.                     WA_CloseGadget,    TRUE,
  236.                     WA_RMBTrap,    TRUE,
  237.                     WA_SizeGadget,    TRUE,
  238.                     WA_MinWidth,    80,
  239.                     WA_MinHeight,    29,
  240.                     WA_MaxWidth,    Screen -> Width,
  241.                     WA_MaxHeight,    29,
  242.                     WA_CustomScreen,Screen,
  243.  
  244.                     WA_IDCMP,    STRINGIDCMP | IDCMP_NEWSIZE | IDCMP_CLOSEWINDOW | IDCMP_MENUPICK | IDCMP_ACTIVEWINDOW | IDCMP_RAWKEY,
  245.  
  246.                     WA_Title,    "Packet Window",
  247.                 TAG_DONE))
  248.                 {
  249.                     InitHook(&PacketHook,PacketKey);
  250.  
  251.                     PacketInfo = (struct StringInfo *)PacketGadgetArray[0] -> SpecialInfo;
  252.  
  253.                     AddGList(PacketWindow,PacketGadgetList,(UWORD)-1,(UWORD)-1,NULL);
  254.                     RefreshGList(PacketGadgetList,PacketWindow,NULL,(UWORD)-1);
  255.                     GT_RefreshWindow(PacketWindow,NULL);
  256.  
  257.                     SetMenuStrip(PacketWindow,PacketMenu);
  258.  
  259.                     PacketWindow -> Flags &= ~WFLG_RMBTRAP;
  260.  
  261.                     ActivateGadget(PacketGadgetArray[0],PacketWindow,NULL);
  262.                     return(TRUE);
  263.                 }
  264.             }
  265.         }
  266.     }
  267.  
  268.     DeletePacketWindow();
  269.  
  270.     return(FALSE);
  271. }
  272.  
  273.     /* PacketKey(struct Hook *Hook,struct SGWork *Work,ULONG *Msg):
  274.      *
  275.      *    This is a string gadget editing call back routine
  276.      *    (a so-called `hook') which is to perform all the
  277.      *    line editing and command history actions supported
  278.      *    by the packet window.
  279.      */
  280.  
  281. VOID
  282. PacketKey(struct Hook *Hook,struct SGWork *Work,ULONG *Msg)
  283. {
  284.         /* Someone activated the string gadget and
  285.          * hit a key.
  286.          */
  287.  
  288.     if(Msg[0] == SGH_KEY)
  289.     {
  290.         if(Work -> IEvent -> ie_Qualifier & IEQUALIFIER_RCOMMAND)
  291.         {
  292.             if(Work -> Code == 'c')
  293.             {
  294.                 Work -> Actions &= ~SGA_USE;
  295.                 Work -> Actions |= SGA_BEEP;
  296.  
  297.                 if(Work -> PrevBuffer[0])
  298.                 {
  299.                     struct MsgPort *ReplyPort;
  300.  
  301.                     if(ReplyPort = CreateMsgPort())
  302.                     {
  303.                         struct Message ClipMessage;
  304.  
  305.                         ClipMessage . mn_Node . ln_Name    = Work -> PrevBuffer;
  306.                         ClipMessage . mn_ReplyPort    = ReplyPort;
  307.                         ClipMessage . mn_Length        = sizeof(struct Message);
  308.  
  309.                         PutMsg(ClipPort,&ClipMessage);
  310.  
  311.                         WaitPort(ReplyPort);
  312.  
  313.                         GetMsg(ReplyPort);
  314.  
  315.                         DeleteMsgPort(ReplyPort);
  316.  
  317.                         Work -> Actions &= ~SGA_BEEP;
  318.                     }
  319.                 }
  320.  
  321.                 return;
  322.             }
  323.  
  324.             if(Work -> Code == 'v')
  325.             {
  326.                 Work -> Actions &= ~SGA_USE;
  327.                 Work -> Actions |= SGA_BEEP;
  328.  
  329.                 if(!(Work -> Gadget -> Activation & GACT_LONGINT))
  330.                 {
  331.                     struct MsgPort *ReplyPort;
  332.  
  333.                     if(ReplyPort = CreateMsgPort())
  334.                     {
  335.                         STATIC UBYTE    Buffer[2048];
  336.                         struct Message    ClipMessage;
  337.  
  338.                         Buffer[0] = 0;
  339.  
  340.                         ClipMessage . mn_Node . ln_Name    = &Buffer[0];
  341.                         ClipMessage . mn_ReplyPort    = ReplyPort;
  342.                         ClipMessage . mn_Length        = sizeof(struct Message);
  343.  
  344.                         PutMsg(ClipPort,&ClipMessage);
  345.  
  346.                         WaitPort(ReplyPort);
  347.  
  348.                         GetMsg(ReplyPort);
  349.  
  350.                         DeleteMsgPort(ReplyPort);
  351.  
  352.                         if(Buffer[0])
  353.                         {
  354.                             WORD Len = strlen(Buffer);
  355.  
  356.                             while(Len > 0 && Work -> NumChars + Len > Work -> StringInfo -> MaxChars)
  357.                                 Len--;
  358.  
  359.                             if(Len > 0)
  360.                             {
  361.                                 STATIC UBYTE OtherBuffer[2048];
  362.  
  363.                                 Buffer[Len] = 0;
  364.  
  365.                                 if(Work -> StringInfo -> UndoBuffer)
  366.                                     strcpy(Work -> StringInfo -> UndoBuffer,Work -> PrevBuffer);
  367.  
  368.                                 Work -> StringInfo -> UndoPos = --Work -> BufferPos;
  369.  
  370.                                 if(Work -> BufferPos)
  371.                                     CopyMem(Work -> PrevBuffer,OtherBuffer,Work -> BufferPos);
  372.  
  373.                                 OtherBuffer[Work -> BufferPos] = 0;
  374.  
  375.                                 strcat(OtherBuffer,Buffer);
  376.  
  377.                                 strcat(OtherBuffer,&Work -> PrevBuffer[Work -> BufferPos]);
  378.  
  379.                                 strcpy(Work -> WorkBuffer,OtherBuffer);
  380.  
  381.                                 Work -> BufferPos += Len;
  382.                                 Work -> NumChars    += Len;
  383.  
  384.                                 Work -> Actions    |= SGA_USE;
  385.                                 Work -> EditOp     = EO_BIGCHANGE;
  386.  
  387.                                 Work -> Actions &= ~SGA_BEEP;
  388.                             }
  389.                         }
  390.                         else
  391.                             Work -> Actions &= ~SGA_BEEP;
  392.                     }
  393.                 }
  394.  
  395.                 return;
  396.             }
  397.         }
  398.  
  399.             /* Right-Amiga-key was pressed, release the
  400.              * string gadget so user may select a menu
  401.              * item.
  402.              */
  403.  
  404.         if((Work -> IEvent -> ie_Qualifier & AMIGARIGHT) && Work -> IEvent -> ie_Code < 96)
  405.         {
  406.             if(!(Work -> IEvent -> ie_Qualifier & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT)) && (Work -> IEvent -> ie_Code == KEYCODE_X || Work -> IEvent -> ie_Code == KEYCODE_Q))
  407.                 return;
  408.             else
  409.             {
  410.                 Work -> Actions |= (SGA_END|SGA_REUSE);
  411.                 Work -> Actions &= ~(SGA_USE|SGA_BEEP);
  412.  
  413.                 CommandWindow = Work -> GadgetInfo -> gi_Window;
  414.                 CommandGadget = Work -> Gadget;
  415.             }
  416.         }
  417.  
  418.             /* The user pressed the cursor-right key to
  419.              * move the cursor to the next word in the buffer.
  420.              */
  421.  
  422.         if(Work -> IEvent -> ie_Code == CURSORRIGHT && (Work -> IEvent -> ie_Qualifier & IEQUALIFIER_CONTROL))
  423.         {
  424.             if(Work -> BufferPos != Work -> NumChars)
  425.             {
  426.                 WORD i,Position = -1;
  427.  
  428.                 for(i = Work -> BufferPos ; i < Work -> NumChars ; i++)
  429.                 {
  430.                     if(Work -> WorkBuffer[i] == ' ')
  431.                     {
  432.                         for( ; i < Work -> NumChars ; i++)
  433.                         {
  434.                             if(Work -> WorkBuffer[i] != ' ')
  435.                             {
  436.                                 Position = i;
  437.                                 break;
  438.                             }
  439.                         }
  440.  
  441.                         break;
  442.                     }
  443.                 }
  444.  
  445.                 if(Position != -1)
  446.                     Work -> BufferPos = Position;
  447.                 else
  448.                     Work -> BufferPos = Work -> NumChars;
  449.  
  450.                 Work -> EditOp = EO_MOVECURSOR;
  451.             }
  452.         }
  453.  
  454.             /* The user pressed the cursor-right key to
  455.              * move the cursor to the previous word in the buffer.
  456.              */
  457.  
  458.         if(Work -> IEvent -> ie_Code == CURSORLEFT && (Work -> IEvent -> ie_Qualifier & IEQUALIFIER_CONTROL))
  459.         {
  460.             if(Work -> BufferPos)
  461.             {
  462.                 WORD i,Position = -1;
  463.  
  464.                 for(i = Work -> BufferPos ; i >= 0 ; i--)
  465.                 {
  466.                     if(Work -> WorkBuffer[i] != ' ')
  467.                     {
  468.                         Position = i;
  469.                         break;
  470.                     }
  471.                 }
  472.  
  473.                 if(Position == -1)
  474.                     Position = 0;
  475.  
  476.                 if(Position)
  477.                 {
  478.                     i = Position;
  479.  
  480.                     Position = -1;
  481.  
  482.                     for( ; i >= 0 ; i--)
  483.                     {
  484.                         if(Work -> WorkBuffer[i] == ' ')
  485.                         {
  486.                             Position = i + 1;
  487.                             break;
  488.                         }
  489.                     }
  490.                 }
  491.  
  492.                 if(Position != -1)
  493.                     Work -> BufferPos = Position;
  494.                 else
  495.                     Work -> BufferPos = 0;
  496.  
  497.                 Work -> EditOp = EO_MOVECURSOR;
  498.             }
  499.         }
  500.  
  501.             /* The user pressed the cursor-up key to
  502.              * scroll through the command history.
  503.              */
  504.  
  505.         if(Work -> IEvent -> ie_Code == CURSORUP)
  506.         {
  507.                 /* Shift key: jump to first command
  508.                  * history entry.
  509.                  */
  510.  
  511.             if(Work -> IEvent -> ie_Qualifier & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT))
  512.             {
  513.                 PacketNode = PacketHistoryList . lh_Head;
  514.  
  515.                 if(PacketNode -> ln_Succ)
  516.                 {
  517.                     Work -> WorkBuffer    = PacketNode -> ln_Name;
  518.                     Work -> NumChars    = strlen(Work -> WorkBuffer);
  519.                     Work -> EditOp        = EO_BIGCHANGE;
  520.                 }
  521.             }
  522.             else
  523.             {
  524.                 BYTE TakeIt = FALSE;
  525.  
  526.                 if(!PacketNode)
  527.                 {
  528.                     PacketNode = PacketHistoryList . lh_TailPred;
  529.  
  530.                     if(PacketNode -> ln_Succ)
  531.                         TakeIt = TRUE;
  532.                 }
  533.                 else
  534.                 {
  535.                     if(PacketNode -> ln_Pred -> ln_Pred)
  536.                     {
  537.                         PacketNode = PacketNode -> ln_Pred;
  538.  
  539.                         TakeIt = TRUE;
  540.                     }
  541.                 }
  542.  
  543.                 if(TakeIt)
  544.                 {
  545.                     /* Jump to previous command
  546.                      * history entry.
  547.                      */
  548.  
  549.                     Work -> WorkBuffer    = PacketNode -> ln_Name;
  550.                     Work -> NumChars    = strlen(Work -> WorkBuffer);
  551.  
  552.                     Work -> EditOp = EO_BIGCHANGE;
  553.                 }
  554.             }
  555.         }
  556.  
  557.             /* The user pressed the cursor-down key to
  558.              * scroll through the command history.
  559.              */
  560.  
  561.         if(Work -> IEvent -> ie_Code == CURSORDOWN)
  562.         {
  563.                 /* Shift key: jump to last command
  564.                  * history entry.
  565.                  */
  566.  
  567.             if(Work -> IEvent -> ie_Qualifier & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT))
  568.             {
  569.                 if(PacketHistoryList . lh_Head -> ln_Succ)
  570.                 {
  571.                     PacketNode = PacketHistoryList . lh_TailPred;
  572.  
  573.                     if(PacketNode -> ln_Succ)
  574.                         Work -> WorkBuffer = PacketNode -> ln_Name;
  575.                     else
  576.                         Work -> WorkBuffer = "";
  577.  
  578.                     Work -> EditOp        = EO_BIGCHANGE;
  579.                     Work -> NumChars    = strlen(Work -> WorkBuffer);
  580.                 }
  581.             }
  582.             else
  583.             {
  584.                 if(PacketNode)
  585.                 {
  586.                     if(PacketNode -> ln_Succ)
  587.                     {
  588.                         PacketNode = PacketNode -> ln_Succ;
  589.  
  590.                         Work -> WorkBuffer = PacketNode -> ln_Name;
  591.                     }
  592.                     else
  593.                         Work -> WorkBuffer = "";
  594.  
  595.                     Work -> EditOp        = EO_BIGCHANGE;
  596.                     Work -> NumChars    = strlen(Work -> WorkBuffer);
  597.                 }
  598.             }
  599.         }
  600.     }
  601. }
  602.  
  603.     /* HandlePacket():
  604.      *
  605.      *    Process the input coming through the packet window.
  606.      */
  607.  
  608. BYTE
  609. HandlePacket()
  610. {
  611.     struct IntuiMessage    *Massage;
  612.     ULONG             Class,Code;
  613.     struct Gadget        *Gadget;
  614.     struct FileRequest    *FileRequest;
  615.     UBYTE             DummyBuffer[256];
  616.     BYTE             SwapWindow = FALSE;
  617.  
  618.         /* Are we already shut down? */
  619.  
  620.     if(PacketWindow)
  621.     {
  622.         if(Massage = (struct IntuiMessage *)GT_GetIMsg(PacketWindow -> UserPort))
  623.         {
  624.             Class    = Massage -> Class;
  625.             Code    = Massage -> Code;
  626.             Gadget    = (struct Gadget *)Massage -> IAddress;
  627.  
  628.             GT_ReplyIMsg(Massage);
  629.  
  630.                 /* Re-enable the string gadget if necessary. */
  631.  
  632.             if(Class == IDCMP_RAWKEY)
  633.                 if(Code == IECODE_UP_PREFIX|103 && CommandWindow == PacketWindow)
  634.                     ActivateGadget(CommandGadget,PacketWindow,NULL);
  635.  
  636.                 /* Handle the menu. */
  637.  
  638.             if(Class == IDCMP_MENUPICK)
  639.             {
  640.                 struct MenuItem *MenuItem;
  641.  
  642.                 while(Code != MENUNULL)
  643.                 {
  644.                     MenuItem = ItemAddress(PacketMenu,Code);
  645.  
  646.                     switch((ULONG)GTMENUITEM_USERDATA(MenuItem))
  647.                     {
  648.                         case MEN_QUITPANEL:    Class = IDCMP_CLOSEWINDOW;
  649.                                     break;
  650.  
  651.                         case MEN_LOADHISTORY:    BlockWindows();
  652.  
  653.                                     if(FileRequest = GetFile("Load History","","",DummyBuffer,NULL,FALSE,FALSE,FALSE,"Load"))
  654.                                     {
  655.                                         if(GetFileSize(DummyBuffer))
  656.                                         {
  657.                                             BPTR SomeFile;
  658.  
  659.                                             if(SomeFile = Open(DummyBuffer,MODE_OLDFILE))
  660.                                             {
  661.                                                 if(PacketLine)
  662.                                                 {
  663.                                                     switch(MyEasyRequest(Window,"The packet history still holds %ld\nlines, do you wish to continue?","Discard History|Append History|Cancel",PacketLine))
  664.                                                     {
  665.                                                         case 1:    ClearPacketHistory();
  666.                                                             break;
  667.  
  668.                                                         case 2:    break;
  669.  
  670.                                                         case 0:    Close(SomeFile);
  671.                                                             SomeFile = NULL;
  672.                                                             break;
  673.                                                     }
  674.                                                 }
  675.  
  676.                                                 if(SomeFile)
  677.                                                 {
  678.                                                     LineRead(NULL,NULL,NULL);
  679.  
  680.                                                     while(LineRead(SomeFile,DummyBuffer,255))
  681.                                                         AddPacketHistory(DummyBuffer);
  682.  
  683.                                                     Close(SomeFile);
  684.                                                 }
  685.                                             }
  686.                                         }
  687.                                     }
  688.  
  689.                                     ReleaseWindows();
  690.                                     break;
  691.  
  692.                         case MEN_SAVEHISTORY:    BlockWindows();
  693.  
  694.                                     if(!PacketLine)
  695.                                         MyEasyRequest(Window,"There isn't anything in the\npacket history right now.","Continue");
  696.                                     else
  697.                                     {
  698.                                         if(FileRequest = GetFile("Save History","","",DummyBuffer,NULL,TRUE,FALSE,FALSE,"Save"))
  699.                                         {
  700.                                             BPTR SomeFile = NULL;
  701.  
  702.                                                 /* If the file we are about
  703.                                                  * to create already exists,
  704.                                                  * ask the user whether we are
  705.                                                  * to create, append or skip
  706.                                                  * the file.
  707.                                                  */
  708.  
  709.                                             if(GetFileSize(DummyBuffer))
  710.                                             {
  711.                                                 switch(MyEasyRequest(Window,"File %s already exists!","Create New File|Append Data|Cancel",DummyBuffer))
  712.                                                 {
  713.                                                     case 1:    SomeFile = Open(DummyBuffer,MODE_NEWFILE);
  714.                                                         break;
  715.  
  716.                                                     case 2:    if(SomeFile = Open(DummyBuffer,MODE_READWRITE))
  717.                                                         {
  718.                                                             if(Seek(SomeFile,0,OFFSET_END) == -1)
  719.                                                             {
  720.                                                                 Close(SomeFile);
  721.  
  722.                                                                 SomeFile = NULL;
  723.                                                             }
  724.                                                         }
  725.                                                         break;
  726.                                                 }
  727.                                             }
  728.                                             else
  729.                                                 SomeFile = Open(DummyBuffer,MODE_NEWFILE);
  730.  
  731.                                             if(!SomeFile)
  732.                                                 MyEasyRequest(Window,"Error opening file %s!","Continue",DummyBuffer);
  733.                                             else
  734.                                             {
  735.                                                 struct Node *SomeNode;
  736.  
  737.                                                 SomeNode = PacketHistoryList . lh_Head;
  738.  
  739.                                                 while(SomeNode -> ln_Succ)
  740.                                                 {
  741.                                                     FPrintf(SomeFile,"%s\n",SomeNode -> ln_Name);
  742.  
  743.                                                     SomeNode = SomeNode -> ln_Succ;
  744.                                                 }
  745.  
  746.                                                 Close(SomeFile);
  747.                                             }
  748.  
  749.                                             FreeAslRequest(FileRequest);
  750.                                         }
  751.                                     }
  752.  
  753.                                     ReleaseWindows();
  754.  
  755.                                     break;
  756.  
  757.                         case MEN_CLEARHISTORY:  BlockWindows();
  758.  
  759.                                     ClearPacketHistory();
  760.  
  761.                                     ReleaseWindows();
  762.                                     break;
  763.  
  764.                         case MEN_OTHERWINDOW:    SwapWindow = TRUE;
  765.                                     break;
  766.  
  767.                         default:        break;
  768.                     }
  769.  
  770.                     Code = MenuItem -> NextSelect;
  771.                 }
  772.  
  773.                 ActivateGadget(PacketGadgetArray[0],PacketWindow,NULL);
  774.             }
  775.  
  776.                 /* Shut down. */
  777.  
  778.             if(Class == IDCMP_CLOSEWINDOW)
  779.                 DeletePacketWindow();
  780.  
  781.                 /* Activate the string gadget as well. */
  782.  
  783.             if(Class == IDCMP_ACTIVEWINDOW)
  784.                 ActivateGadget(PacketGadgetArray[0],PacketWindow,NULL);
  785.  
  786.             if(Class == IDCMP_NEWSIZE)
  787.             {
  788.                 PacketWindow -> Flags |= WFLG_RMBTRAP;
  789.  
  790.                 strcpy(DummyBuffer,PacketInfo -> Buffer);
  791.  
  792.                 RemoveGList(PacketWindow,PacketGadgetList,(UWORD)-1);
  793.  
  794.                 FreeGadgets(PacketGadgetList);
  795.  
  796.                 PacketGadgetList = NULL;
  797.  
  798.                 SetAPen(PacketWindow -> RPort,0);
  799.                 RectFill(PacketWindow -> RPort,PacketWindow -> BorderLeft,PacketWindow -> BorderTop,PacketWindow -> Width - PacketWindow -> BorderRight,PacketWindow -> Height - PacketWindow -> BorderBottom);
  800.                 RefreshWindowFrame(PacketWindow);
  801.  
  802.                 if(CreateAllGadgets(PacketWindow -> Width,&PacketGadgetArray[0],&PacketGadgetList,VisualInfo,Screen -> WBorTop + Screen -> Font -> ta_YSize + 1))
  803.                 {
  804.                     PacketInfo = (struct StringInfo *)PacketGadgetArray[0] -> SpecialInfo;
  805.  
  806.                     strcpy(PacketInfo -> Buffer,DummyBuffer);
  807.  
  808.                     AddGList(PacketWindow,PacketGadgetList,(UWORD)-1,(UWORD)-1,NULL);
  809.                     RefreshGList(PacketGadgetList,PacketWindow,NULL,(UWORD)-1);
  810.                     GT_RefreshWindow(PacketWindow,NULL);
  811.  
  812.                     PacketWindow -> Flags &= ~WFLG_RMBTRAP;
  813.  
  814.                     ActivateGadget(PacketGadgetArray[0],PacketWindow,NULL);
  815.                 }
  816.                 else
  817.                     DeletePacketWindow();
  818.             }
  819.  
  820.                 /* User has entered a string. */
  821.  
  822.             if(Class == IDCMP_GADGETUP)
  823.             {
  824.                     /* Just pressed Right-Amiga? */
  825.  
  826.                 if(!DontActivate)
  827.                 {
  828.                         /* Is there anything in the buffer at all? */
  829.  
  830.                     if(PacketInfo -> Buffer)
  831.                     {
  832.                             /* Perform selective history (don't
  833.                              * buffer anything that's already
  834.                              * in the command history.
  835.                              */
  836.  
  837.                         if(PacketNode -> ln_Succ)
  838.                         {
  839.                             if(strcmp(PacketNode -> ln_Name,PacketInfo -> Buffer))
  840.                                 AddPacketHistory(PacketInfo -> Buffer);
  841.                             else
  842.                                 PacketNode = NULL;
  843.                         }
  844.                         else
  845.                             AddPacketHistory(PacketInfo -> Buffer);
  846.  
  847.                         strcpy(DummyBuffer,PacketInfo -> Buffer);
  848.  
  849.                             /* Convert alien IBM characters. */
  850.  
  851.                         if(Config . Font == FONT_IBM)
  852.                         {
  853.                             WORD i;
  854.                             UBYTE Char;
  855.  
  856.                             for(i = 0 ; i < strlen(DummyBuffer) ; i++)
  857.                             {
  858.                                 if(Char = IBMConversion[DummyBuffer[i]])
  859.                                     DummyBuffer[i] = Char;
  860.                             }
  861.                         }
  862.  
  863.                             /* Execute the command. */
  864.  
  865.                         SerialCommand(DummyBuffer);
  866.                     }
  867.  
  868.                         /* Clear the packet window string
  869.                          * gadget.
  870.                          */
  871.  
  872.                     PacketInfo -> Buffer[0] = 0;
  873.  
  874.                     RefreshGList(PacketGadgetList,PacketWindow,NULL,(UWORD)-1);
  875.  
  876.                         /* Send a terminating `CR'. */
  877.  
  878.                     switch(Config . SendCR)
  879.                     {
  880.                         case CR_IGNORE:    break;
  881.  
  882.                         case CR_ASCR:    SerWrite("\r",1);
  883.                                 break;
  884.  
  885.                         case CR_ASCRLF:    SerWrite("\r\n",2);
  886.                                 break;
  887.                     }
  888.  
  889.                         /* Re-activate the string gadget. */
  890.  
  891.                     ActivateGadget(PacketGadgetArray[0],PacketWindow,NULL);
  892.                 }
  893.                 else
  894.                     DontActivate = FALSE;
  895.             }
  896.  
  897.             if(SwapWindow)
  898.                 BumpWindow(Window);
  899.  
  900.             return(TRUE);
  901.         }
  902.     }
  903.  
  904.     return(FALSE);
  905. }
  906.