home *** CD-ROM | disk | FTP | other *** search
/ BCI NET / BCI NET Dec 94.iso / archives / telecomm / terms / term-4.1-source.lha / Extras / Source / term-Source.lha / termXEM.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-26  |  22.2 KB  |  1,202 lines
  1. /*
  2. **    termXEM.c
  3. **
  4. **    External emulation support routines
  5. **
  6. **    Copyright © 1990-1994 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12.     /* GetOptionMode(struct xpr_option *Option):
  13.      *
  14.      *    Turn text into a boolean value.
  15.      */
  16.  
  17. STATIC BYTE __regargs
  18. GetOptionMode(struct xem_option *Option)
  19. {
  20.     if(Option)
  21.     {
  22.         STATIC STRPTR TrueOptions[] =
  23.         {
  24.             "ON",
  25.             "TRUE",
  26.             "T",
  27.             "YES",
  28.             "Y",
  29.             NULL
  30.         };
  31.  
  32.         register WORD i;
  33.  
  34.         for(i = 0 ; TrueOptions[i] ; i++)
  35.         {
  36.             if(!Stricmp(Option -> xemo_value,TrueOptions[i]))
  37.                 return(TRUE);
  38.         }
  39.     }
  40.  
  41.     return(FALSE);
  42. }
  43.  
  44. STATIC LONG __saveds __asm
  45. xem_sflush(VOID)
  46. {
  47.     return((LONG)DoSerialCmd(CMD_CLEAR));
  48. }
  49.  
  50. STATIC LONG __saveds __asm
  51. xem_squery(VOID)
  52. {
  53.     if(WriteRequest)
  54.     {
  55.         ULONG    Waiting;
  56.         UWORD    Status;
  57.  
  58.         GetSerialInfo(&Waiting,&Status);
  59.  
  60.             /* Return error if carrier is lost. */
  61.  
  62.         if((Status & CIAF_COMCD) && Config -> SerialConfig -> CheckCarrier)
  63.         {
  64.             ObtainSemaphore(&OnlineSemaphore);
  65.  
  66.             WasOnline    = Online;
  67.             Online        = FALSE;
  68.  
  69.             ReleaseSemaphore(&OnlineSemaphore);
  70.         }
  71.         else
  72.             return((LONG)Waiting);
  73.     }
  74.  
  75.     return(-1);
  76. }
  77.  
  78. STATIC LONG __saveds __asm
  79. xem_sread(register __a0 APTR Buffer,register __d0 LONG Size,register __d1 ULONG Timeout)
  80. {
  81.         /* Are both IORequests available? */
  82.  
  83.     if(WriteRequest && ReadRequest)
  84.     {
  85.             /* Valid size parameter? */
  86.  
  87.         if(Size > 0)
  88.         {
  89.             ULONG    Waiting;
  90.             UWORD    Status;
  91.  
  92.             GetSerialInfo(&Waiting,&Status);
  93.  
  94.                 /* Return error if carrier is lost. */
  95.  
  96.             if(Config -> SerialConfig -> CheckCarrier)
  97.             {
  98.                 if(Status & CIAF_COMCD)
  99.                 {
  100.                     ObtainSemaphore(&OnlineSemaphore);
  101.  
  102.                     WasOnline    = Online;
  103.                     Online        = FALSE;
  104.  
  105.                     ReleaseSemaphore(&OnlineSemaphore);
  106.  
  107.                     return(-1);
  108.                 }
  109.             }
  110.  
  111.             /* ALWAYS */
  112.             {
  113.                 if(Waiting)
  114.                 {
  115.                         /* No timeout specified? Read as many
  116.                          * bytes as available.
  117.                          */
  118.  
  119.                     if(!Timeout)
  120.                     {
  121.                         if(Waiting > Size)
  122.                             Waiting = Size;
  123.  
  124.                         if(DoSerialRead(Buffer,Waiting))
  125.                             Waiting = ReadRequest -> IOSer . io_Actual;
  126.  
  127.                         BytesIn += Waiting;
  128.  
  129.                         return((LONG)Waiting);
  130.                     }
  131.  
  132.                         /* Enough data pending to be read? */
  133.  
  134.                     if(Waiting >= Size)
  135.                     {
  136.                         if(DoSerialRead(Buffer,Size))
  137.                             Size = ReadRequest -> IOSer . io_Actual;
  138.  
  139.                         BytesIn += Size;
  140.  
  141.                         return(Size);
  142.                     }
  143.                 }
  144.                 else
  145.                 {
  146.                         /* No timeout & no bytes available:
  147.                          * return immediately.
  148.                          */
  149.  
  150.                     if(!Timeout)
  151.                         return(0);
  152.                 }
  153.             }
  154.  
  155.             /* ALWAYS */
  156.             {
  157.                 register ULONG SignalSet;
  158.  
  159.                     /* Set up the timer. */
  160.  
  161.                 TimeRequest -> tr_node . io_Command    = TR_ADDREQUEST;
  162.                 TimeRequest -> tr_time . tv_secs    = Timeout / MILLION;
  163.                 TimeRequest -> tr_time . tv_micro    = Timeout % MILLION;
  164.  
  165.                     /* Prevent early termination. */
  166.  
  167.                 ClrSignal(SIG_SERIAL | SIG_TIMER);
  168.  
  169.                     /* Start IO... */
  170.  
  171.                 SendIO(TimeRequest);
  172.  
  173.                     /* Set up the read request. */
  174.  
  175.                 StartSerialRead(Buffer,Size);
  176.  
  177.                 FOREVER
  178.                 {
  179.                     SignalSet = Wait(SIG_SERIAL | SIG_TIMER);
  180.  
  181.                         /* Receive buffer filled? */
  182.  
  183.                     if(SignalSet & SIG_SERIAL)
  184.                     {
  185.                             /* Abort the timer request. */
  186.  
  187.                         if(!CheckIO(TimeRequest))
  188.                             AbortIO(TimeRequest);
  189.  
  190.                         WaitIO(TimeRequest);
  191.  
  192.                             /* Did the request terminate gracefully? */
  193.  
  194.                         if(WaitSerialRead())
  195.                             Size = ReadRequest -> IOSer . io_Actual;
  196.  
  197.                         BytesIn += Size;
  198.  
  199.                         return(Size);
  200.                     }
  201.  
  202.                         /* Hit by timeout? */
  203.  
  204.                     if(SignalSet & SIG_TIMER)
  205.                     {
  206.                             /* Abort the read request. */
  207.  
  208.                         StopSerialRead();
  209.  
  210.                             /* Remove the timer request. */
  211.  
  212.                         WaitIO(TimeRequest);
  213.  
  214.                             /* Did the driver receive any
  215.                              * data?
  216.                              */
  217.  
  218.                         if(ReadRequest -> IOSer . io_Actual)
  219.                         {
  220.                             BytesIn += ReadRequest -> IOSer . io_Actual;
  221.  
  222.                             return((LONG)ReadRequest -> IOSer . io_Actual);
  223.                         }
  224.                         else
  225.                         {
  226.                                 /* Take a second look and query the number of
  227.                                  * bytes ready to be received, there may
  228.                                  * still be some bytes in the buffer.
  229.                                  * Note: this depends on the way the
  230.                                  * driver handles read abort.
  231.                                  */
  232.  
  233.                             Waiting = GetSerialWaiting();
  234.  
  235.                                 /* Don't read too much. */
  236.  
  237.                             if(Size > Waiting)
  238.                                 Size = Waiting;
  239.  
  240.                                 /* Are there any bytes to be transferred? */
  241.  
  242.                             if(Size)
  243.                             {
  244.                                     /* Read the data. */
  245.  
  246.                                 if(DoSerialRead(Buffer,Size))
  247.                                     Size = ReadRequest -> IOSer . io_Actual;
  248.  
  249.                                 BytesIn += Size;
  250.                             }
  251.  
  252.                             return(Size);
  253.                         }
  254.                     }
  255.                 }
  256.             }
  257.         }
  258.         else
  259.             return(0);
  260.     }
  261.     else
  262.         return(-1);
  263. }
  264.  
  265. STATIC ULONG __saveds __asm
  266. xem_toptions(register __d0 LONG NumOpts,register __a0 struct xem_option **Opts)
  267. {
  268.     if(NumOpts && Opts)
  269.     {
  270.         enum    {    GAD_USE=1,GAD_CANCEL,GAD_SPECIAL };
  271.  
  272.         struct LayoutHandle    *Handle;
  273.         ULONG             Flags = NULL;
  274.  
  275.             /* We only have 32 bits! */
  276.  
  277.         if(NumOpts > 32)
  278.             NumOpts = 32;
  279.  
  280.         if(Handle = LT_CreateHandleTags(Window -> WScreen,
  281.             LH_LocaleHook,    &LocaleHook,
  282.         TAG_DONE))
  283.         {
  284.             struct Window    *PanelWindow;
  285.             LONG         i,Split;
  286.  
  287.             if(NumOpts > 16)
  288.                 Split = NumOpts / 2;
  289.             else
  290.                 Split = -1;
  291.  
  292.             LT_New(Handle,
  293.                 LA_Type,    VERTICAL_KIND,
  294.             TAG_DONE);
  295.             {
  296.                 LT_New(Handle,
  297.                     LA_Type,    HORIZONTAL_KIND,
  298.                     LA_LabelID,    MSG_V36_1501,
  299.                 TAG_DONE);
  300.                 {
  301.                     LT_New(Handle,
  302.                         LA_Type,    VERTICAL_KIND,
  303.                     TAG_DONE);
  304.                     {
  305.                         for(i = 0 ; i < NumOpts ; i++)
  306.                         {
  307.                             if(Opts[i])
  308.                             {
  309.                                 switch(Opts[i] -> xemo_type)
  310.                                 {
  311.                                     case XEMO_BOOLEAN:
  312.  
  313.                                         LT_New(Handle,
  314.                                             LA_Type,    CHECKBOX_KIND,
  315.                                             LA_LabelText,    Opts[i] -> xemo_description,
  316.                                             LA_ID,        GAD_SPECIAL + i,
  317.                                             GTCB_Checked,    GetOptionMode(Opts[i]),
  318.                                         TAG_DONE);
  319.  
  320.                                         break;
  321.  
  322.                                     case XEMO_LONG:
  323.  
  324.                                         LT_New(Handle,
  325.                                             LA_Type,        INTEGER_KIND,
  326.                                             LA_LabelText,        Opts[i] -> xemo_description,
  327.                                             LA_ID,            GAD_SPECIAL + i,
  328.                                             LA_Chars,        15,
  329.                                             GTIN_Number,        Atol(Opts[i] -> xemo_value),
  330.                                             LAIN_UseIncrementers,    TRUE,
  331.                                         TAG_DONE);
  332.  
  333.                                         break;
  334.  
  335.                                     case XEMO_STRING:
  336.  
  337.                                         LT_New(Handle,
  338.                                             LA_Type,    STRING_KIND,
  339.                                             LA_LabelText,    Opts[i] -> xemo_description,
  340.                                             LA_ID,        GAD_SPECIAL + i,
  341.                                             LA_Chars,    15,
  342.                                             GTST_String,    Opts[i] -> xemo_value,
  343.                                             GTST_MaxChars,    Opts[i] -> xemo_length - 1,
  344.                                         TAG_DONE);
  345.  
  346.                                         break;
  347.  
  348.                                     case XEMO_COMMPAR:
  349.  
  350.                                         LT_New(Handle,
  351.                                             LA_Type,    STRING_KIND,
  352.                                             LA_LabelText,    Opts[i] -> xemo_description,
  353.                                             LA_ID,        GAD_SPECIAL + i,
  354.                                             LA_Chars,    15,
  355.                                             LA_HighLabel,    TRUE,
  356.                                             GTST_String,    Opts[i] -> xemo_value,
  357.                                             GTST_MaxChars,    Opts[i] -> xemo_length - 1,
  358.                                         TAG_DONE);
  359.  
  360.                                         break;
  361.  
  362.                                     case XEMO_HEADER:
  363.  
  364.                                         LT_New(Handle,
  365.                                             LA_Type,    TEXT_KIND,
  366.                                             LA_LabelText,    Opts[i] -> xemo_description,
  367.                                             LA_HighLabel,    TRUE,
  368.                                             GTTX_Text,    " ",
  369.                                         TAG_DONE);
  370.  
  371.                                         break;
  372.  
  373.                                     case XEMO_COMMAND:
  374.  
  375.                                         LT_New(Handle,
  376.                                             LA_Type,    BUTTON_KIND,
  377.                                             LA_LabelText,    Opts[i] -> xemo_description,
  378.                                             LA_ID,        GAD_SPECIAL + i,
  379.                                             LA_Chars,    15,
  380.                                         TAG_DONE);
  381.  
  382.                                         break;
  383.                                 }
  384.                             }
  385.  
  386.                             if(i == Split)
  387.                             {
  388.                                 LT_EndGroup(Handle);
  389.  
  390.                                 LT_New(Handle,
  391.                                     LA_Type,    VERTICAL_KIND,
  392.                                 TAG_DONE);
  393.                             }
  394.                         }
  395.  
  396.                         LT_EndGroup(Handle);
  397.                     }
  398.  
  399.                     LT_EndGroup(Handle);
  400.                 }
  401.  
  402.                 LT_New(Handle,
  403.                     LA_Type,    VERTICAL_KIND,
  404.                 TAG_DONE);
  405.                 {
  406.                     LT_New(Handle,LA_Type,XBAR_KIND,LAXB_FullSize,TRUE,TAG_DONE);
  407.  
  408.                     LT_EndGroup(Handle);
  409.                 }
  410.  
  411.                 LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  412.                     LAGR_SameSize,    TRUE,
  413.                     LAGR_Spread,    TRUE,
  414.                 TAG_DONE);
  415.                 {
  416.                     LT_New(Handle,
  417.                         LA_Type,    BUTTON_KIND,
  418.                         LA_LabelID,    MSG_GLOBAL_USE_GAD,
  419.                         LA_ID,        GAD_USE,
  420.                         LABT_ReturnKey,    TRUE,
  421.                         LABT_ExtraFat,    TRUE,
  422.                     TAG_DONE);
  423.  
  424.                     LT_New(Handle,
  425.                         LA_Type,    BUTTON_KIND,
  426.                         LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  427.                         LA_ID,        GAD_CANCEL,
  428.                         LABT_EscKey,    TRUE,
  429.                         LABT_ExtraFat,    TRUE,
  430.                     TAG_DONE);
  431.  
  432.                     LT_EndGroup(Handle);
  433.                 }
  434.  
  435.                 LT_EndGroup(Handle);
  436.             }
  437.  
  438.             if(PanelWindow = LT_Layout(Handle,OptionTitle ? OptionTitle : LocaleString(MSG_V36_1840),NULL,0,0,IDCMP_CLOSEWINDOW,0,
  439.                 LAWN_HelpHook,        &GuideHook,
  440.                 LAWN_Parent,        Window,
  441.                 WA_DepthGadget,        TRUE,
  442.                 WA_CloseGadget,        TRUE,
  443.                 WA_DragBar,        TRUE,
  444.                 WA_RMBTrap,        TRUE,
  445.                 WA_Activate,        TRUE,
  446.             TAG_DONE))
  447.             {
  448.                 struct IntuiMessage    *Message;
  449.                 BOOLEAN             Done = FALSE;
  450.                 ULONG             MsgClass,
  451.                              MsgQualifier;
  452.                 UWORD             MsgCode;
  453.                 struct Gadget        *MsgGadget;
  454.                 BOOLEAN             CheckFlags = FALSE;
  455.  
  456.                 PushWindow(PanelWindow);
  457.  
  458.                 LT_ShowWindow(Handle,TRUE);
  459.  
  460.                 do
  461.                 {
  462.                     if(Wait(PORTMASK(PanelWindow -> UserPort) | SIG_BREAK) & SIG_BREAK)
  463.                         break;
  464.  
  465.                     while(Message = (struct IntuiMessage *)GT_GetIMsg(PanelWindow -> UserPort))
  466.                     {
  467.                         MsgClass    = Message -> Class;
  468.                         MsgQualifier    = Message -> Qualifier;
  469.                         MsgCode        = Message -> Code;
  470.                         MsgGadget    = (struct Gadget *)Message -> IAddress;
  471.  
  472.                         GT_ReplyIMsg(Message);
  473.  
  474.                         LT_HandleInput(Handle,MsgQualifier,&MsgClass,&MsgCode,&MsgGadget);
  475.  
  476.                         if(MsgClass == IDCMP_CLOSEWINDOW)
  477.                             Done = TRUE;
  478.  
  479.                         if(MsgClass == IDCMP_GADGETUP)
  480.                         {
  481.                             switch(MsgGadget -> GadgetID)
  482.                             {
  483.                                 case GAD_USE:
  484.  
  485.                                     Done = CheckFlags = TRUE;
  486.                                     break;
  487.  
  488.                                 case GAD_CANCEL:
  489.  
  490.                                     Done = TRUE;
  491.                                     break;
  492.  
  493.                                 default:
  494.  
  495.                                     if(MsgGadget -> GadgetID - GAD_SPECIAL < NumOpts)
  496.                                     {
  497.                                         i = MsgGadget -> GadgetID - GAD_SPECIAL;
  498.  
  499.                                         if(Opts[i] -> xemo_type == XEMO_COMMAND || (Opts[i] -> xemo_type == XEMO_COMMPAR && MsgCode != '\t'))
  500.                                         {
  501.                                             Flags = (1L << i);
  502.  
  503.                                             Done = CheckFlags = TRUE;
  504.                                         }
  505.                                     }
  506.  
  507.                                     break;
  508.                             }
  509.                         }
  510.                     }
  511.                 }
  512.                 while(!Done);
  513.  
  514.                 PopWindow();
  515.  
  516.                 if(CheckFlags)
  517.                 {
  518.                     LT_LockWindow(PanelWindow);
  519.  
  520.                     for(i = 0 ; i < NumOpts ; i++)
  521.                     {
  522.                         if(Opts[i])
  523.                         {
  524.                             switch(Opts[i] -> xemo_type)
  525.                             {
  526.                                 case XEMO_BOOLEAN:
  527.  
  528.                                     if(LT_GetAttributes(Handle,GAD_SPECIAL + i,TAG_DONE) != GetOptionMode(Opts[i]))
  529.                                     {
  530.                                         Flags |= (1L << i);
  531.  
  532.                                         if(LT_GetAttributes(Handle,GAD_SPECIAL + i,TAG_DONE))
  533.                                             strcpy(Opts[i] -> xemo_value,"yes");
  534.                                         else
  535.                                             strcpy(Opts[i] -> xemo_value,"no");
  536.  
  537.                                         NewOptions = TRUE;
  538.                                     }
  539.  
  540.                                     break;
  541.  
  542.                                 case XEMO_LONG:
  543.  
  544.                                     if(Atol(Opts[i] -> xemo_value) != LT_GetAttributes(Handle,GAD_SPECIAL + i,TAG_DONE))
  545.                                     {
  546.                                         Flags |= (1L << i);
  547.  
  548.                                         SPrintf(Opts[i] -> xemo_value,"%ld",LT_GetAttributes(Handle,GAD_SPECIAL + i,TAG_DONE));
  549.  
  550.                                         NewOptions = TRUE;
  551.                                     }
  552.  
  553.                                     break;
  554.  
  555.                                 case XEMO_COMMPAR:
  556.                                 case XEMO_STRING:
  557.  
  558.                                     if(strcmp(Opts[i] -> xemo_value,(STRPTR)LT_GetAttributes(Handle,GAD_SPECIAL + i,TAG_DONE)))
  559.                                     {
  560.                                         Flags |= (1L << i);
  561.  
  562.                                         strcpy(Opts[i] -> xemo_value,(STRPTR)LT_GetAttributes(Handle,GAD_SPECIAL + i,TAG_DONE));
  563.  
  564.                                         NewOptions = TRUE;
  565.                                     }
  566.  
  567.                                     break;
  568.                             }
  569.                         }
  570.                     }
  571.  
  572.                     LT_UnlockWindow(PanelWindow);
  573.                 }
  574.                 else
  575.                     Flags = NULL;
  576.             }
  577.  
  578.             LT_DeleteHandle(Handle);
  579.         }
  580.  
  581.         return(Flags);
  582.     }
  583.     else
  584.         return(NULL);
  585. }
  586.  
  587.     /* xem_swrite():
  588.      *
  589.      *    Send a few bytes across the serial line.
  590.      */
  591.  
  592. STATIC LONG __saveds __asm
  593. xem_swrite(register __a0 STRPTR Buffer,register __d0 LONG Size)
  594. {
  595.     if(WriteRequest)
  596.     {
  597.         SerWrite(Buffer,Size);
  598.  
  599.         return(0);
  600.     }
  601.     else
  602.         return(-1);
  603. }
  604.  
  605.     /* xem_sbreak():
  606.      *
  607.      *    Send a break signal across the serial line.
  608.      */
  609.  
  610. STATIC LONG __asm __saveds
  611. xem_sbreak(VOID)
  612. {
  613.     if(!WriteRequest)
  614.         return(-1);
  615.     else
  616.     {
  617.         SendBreak();
  618.  
  619.         return(0);
  620.     }
  621. }
  622.  
  623.     /* xem_sstart():
  624.      *
  625.      *    Restart serial read activity.
  626.      */
  627.  
  628. STATIC VOID __asm __saveds
  629. xem_sstart(VOID)
  630. {
  631.     RestartSerial(FALSE);
  632. }
  633.  
  634.     /* xem_sstop():
  635.      *
  636.      *    Stop serial read activity.
  637.      */
  638.  
  639. STATIC LONG __asm __saveds
  640. xem_sstop(VOID)
  641. {
  642.     StopSerialRead();
  643.  
  644.     return(0);
  645. }
  646.  
  647.     /* xem_tgets(STRPTR Prompt,STRPTR Buffer,ULONG Size):
  648.      *
  649.      *    Get a string from the user.
  650.      */
  651.  
  652. STATIC LONG __saveds __asm
  653. xem_tgets(register __a0 STRPTR Prompt,register __a1 STRPTR Buffer,register __d0 ULONG Size)
  654. {
  655.     enum    {    GAD_OK=1,GAD_CANCEL,GAD_STRING };
  656.  
  657.     struct LayoutHandle    *Handle;
  658.     LONG             Success = FALSE;
  659.     UBYTE             LocalBuffer[256];
  660.  
  661.     if(strlen(Buffer) > 255)
  662.     {
  663.         CopyMem(Buffer,LocalBuffer,255);
  664.  
  665.         LocalBuffer[255] = 0;
  666.     }
  667.     else
  668.         strcpy(LocalBuffer,Buffer);
  669.  
  670.     if(!Prompt)
  671.         Prompt = LocaleString(MSG_TERMXPR_INPUT_REQUIRED_TXT);
  672.  
  673.     if(Handle = LT_CreateHandleTags(Window -> WScreen,
  674.         LH_LocaleHook,    &LocaleHook,
  675.     TAG_DONE))
  676.     {
  677.         struct Window *PanelWindow;
  678.  
  679.         LT_New(Handle,
  680.             LA_Type,    VERTICAL_KIND,
  681.         TAG_DONE);
  682.         {
  683.             LT_New(Handle,
  684.                 LA_Type,    VERTICAL_KIND,
  685.                 LA_LabelText,    Prompt,
  686.             TAG_DONE);
  687.             {
  688.                 LT_New(Handle,
  689.                     LA_Type,    STRING_KIND,
  690.                     LA_STRPTR,    LocalBuffer,
  691.                     LA_Chars,    30,
  692.                     GTST_MaxChars,    Size,
  693.                 TAG_DONE);
  694.  
  695.                 LT_EndGroup(Handle);
  696.             }
  697.  
  698.             LT_New(Handle,
  699.                 LA_Type,VERTICAL_KIND,
  700.             TAG_DONE);
  701.             {
  702.                 LT_New(Handle,
  703.                     LA_Type,    XBAR_KIND,
  704.                     LAXB_FullSize,    TRUE,
  705.                 TAG_DONE);
  706.  
  707.                 LT_EndGroup(Handle);
  708.             }
  709.  
  710.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  711.                 LAGR_SameSize,    TRUE,
  712.                 LAGR_Spread,    TRUE,
  713.             TAG_DONE);
  714.             {
  715.                 LT_New(Handle,
  716.                     LA_Type,    BUTTON_KIND,
  717.                     LA_LabelID,    MSG_TERMXPR_OKAY_GAD,
  718.                     LA_ID,        GAD_OK,
  719.                     LABT_ReturnKey,    TRUE,
  720.                     LABT_ExtraFat,    TRUE,
  721.                 TAG_DONE);
  722.  
  723.                 LT_New(Handle,
  724.                     LA_Type,    BUTTON_KIND,
  725.                     LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  726.                     LA_ID,        GAD_CANCEL,
  727.                     LABT_EscKey,    TRUE,
  728.                     LABT_ExtraFat,    TRUE,
  729.                 TAG_DONE);
  730.  
  731.                 LT_EndGroup(Handle);
  732.             }
  733.         }
  734.  
  735.         if(PanelWindow = LT_Layout(Handle,LocaleString(MSG_GLOBAL_ENTER_TEXT_TXT),NULL,0,0,IDCMP_CLOSEWINDOW,0,
  736.             LAWN_HelpHook,        &GuideHook,
  737.             LAWN_Parent,        Window,
  738.             WA_DepthGadget,        TRUE,
  739.             WA_CloseGadget,        TRUE,
  740.             WA_DragBar,        TRUE,
  741.             WA_RMBTrap,        TRUE,
  742.             WA_Activate,        TRUE,
  743.         TAG_DONE))
  744.         {
  745.             struct IntuiMessage    *Message;
  746.             BOOLEAN             Done = FALSE;
  747.             ULONG             MsgClass,
  748.                          MsgQualifier;
  749.             UWORD             MsgCode;
  750.             struct Gadget        *MsgGadget;
  751.  
  752.             PushWindow(PanelWindow);
  753.  
  754.             LT_ShowWindow(Handle,TRUE);
  755.  
  756.             LT_Activate(Handle,GAD_STRING);
  757.  
  758.             do
  759.             {
  760.                 if(Wait(PORTMASK(PanelWindow -> UserPort) | SIG_BREAK) & SIG_BREAK)
  761.                     break;
  762.  
  763.                 while(Message = (struct IntuiMessage *)GT_GetIMsg(PanelWindow -> UserPort))
  764.                 {
  765.                     MsgClass    = Message -> Class;
  766.                     MsgQualifier    = Message -> Qualifier;
  767.                     MsgCode        = Message -> Code;
  768.                     MsgGadget    = (struct Gadget *)Message -> IAddress;
  769.  
  770.                     GT_ReplyIMsg(Message);
  771.  
  772.                     LT_HandleInput(Handle,MsgQualifier,&MsgClass,&MsgCode,&MsgGadget);
  773.  
  774.                     if(MsgClass == IDCMP_CLOSEWINDOW)
  775.                         Done = TRUE;
  776.  
  777.                     if(MsgClass == IDCMP_GADGETUP)
  778.                     {
  779.                         switch(MsgGadget -> GadgetID)
  780.                         {
  781.                             case GAD_STRING:
  782.  
  783.                                 if(MsgCode == '\r')
  784.                                 {
  785.                                     strcpy(Buffer,LocalBuffer);
  786.  
  787.                                     Success = Done = TRUE;
  788.  
  789.                                     LT_PressButton(Handle,GAD_OK);
  790.                                 }
  791.  
  792.                                 break;
  793.  
  794.                             case GAD_OK:
  795.  
  796.                                 strcpy(Buffer,LocalBuffer);
  797.  
  798.                                 Success = Done = TRUE;
  799.                                 break;
  800.  
  801.                             case GAD_CANCEL:
  802.  
  803.                                 Done = TRUE;
  804.                                 break;
  805.                         }
  806.                     }
  807.                 }
  808.             }
  809.             while(!Done);
  810.  
  811.             PopWindow();
  812.         }
  813.  
  814.         LT_DeleteHandle(Handle);
  815.     }
  816.  
  817.     return(Success);
  818. }
  819.  
  820.     /* xem_tbeep(ULONG Times,ULONG Delay):
  821.      *
  822.      *    Beep the terminal display.
  823.      */
  824.  
  825. STATIC VOID __saveds __asm
  826. xem_tbeep(register __d0 ULONG Times,register __d1 ULONG Delay)
  827. {
  828.     WORD i;
  829.  
  830.     for(i = 0 ; i < Times ; i++)
  831.     {
  832.             /* Handle the visual part. */
  833.  
  834.         if(Config -> TerminalConfig -> BellMode != BELL_AUDIBLE)
  835.         {
  836.             if(StatusProcess)
  837.                 Signal(StatusProcess,SIG_BELL);
  838.         }
  839.  
  840.             /* Let it beep. */
  841.  
  842.         if(Config -> TerminalConfig -> BellMode == BELL_AUDIBLE || Config -> TerminalConfig -> BellMode == BELL_BOTH)
  843.             SoundPlay(SOUND_BELL);
  844.     }
  845. }
  846.  
  847.     /* xem_macrodispatch(struct XEmulatorMacroKey *XEM_MacroKey):
  848.      *
  849.      *    Dispatch a macro key call.
  850.      */
  851.  
  852. STATIC LONG __saveds __asm
  853. xem_macrodispatch(register __a0 struct XEmulatorMacroKey *XEM_MacroKey)
  854. {
  855.     VOID (*Routine)(VOID);
  856.  
  857.         /* If a routine to call is available (most likely xON or xOFF),
  858.          * make a call to it, else process the macro key data.
  859.          */
  860.  
  861.     if(Routine = (VPTR)XEM_MacroKey -> xmk_UserData)
  862.         (*Routine)();
  863.     else
  864.         SerialCommand(MacroKeys -> Keys[XEM_MacroKey -> xmk_Qualifier][XEM_MacroKey -> xmk_Code - 0x50]);
  865.  
  866.     return(0);
  867. }
  868.  
  869.     /* SetEmulatorOptions(BYTE Mode):
  870.      *
  871.      *    Save or load the emulator options.
  872.      */
  873.  
  874. BYTE __regargs
  875. SetEmulatorOptions(BYTE Mode)
  876. {
  877.     BYTE Success = FALSE;
  878.  
  879.         /* Is the library available and running? */
  880.  
  881.     if(XEmulatorBase && XEM_IO)
  882.     {
  883.             /* Are we using the new library code? */
  884.  
  885.         if(XEmulatorBase -> lib_Version >= 4)
  886.         {
  887.                 /* Get the name of the library. */
  888.  
  889.             strcpy(SharedBuffer,FilePart(XEmulatorBase -> lib_Node . ln_Name));
  890.  
  891.                 /* Does it have any name? */
  892.  
  893.             if(SharedBuffer[0])
  894.             {
  895.                 UBYTE    OtherBuffer[50];
  896.                 WORD    i;
  897.  
  898.                     /* Strip the `.library' bit. */
  899.  
  900.                 for(i = strlen(SharedBuffer) - 1 ; i >= 0 ; i--)
  901.                 {
  902.                     if(SharedBuffer[i] == '.')
  903.                     {
  904.                         SharedBuffer[i] = 0;
  905.  
  906.                         break;
  907.                     }
  908.                 }
  909.  
  910.                     /* What are we to do? */
  911.  
  912.                 if(Mode == XEM_PREFS_LOAD)
  913.                 {
  914.                         /* Restore settings... */
  915.  
  916.                     strcpy(OtherBuffer,"ENV:");
  917.  
  918.                     if(AddPart(OtherBuffer,SharedBuffer,50))
  919.                     {
  920.                             /* If we can't load them,
  921.                              * reset to defaults.
  922.                              */
  923.  
  924.                         if(!XEmulatorPreferences(XEM_IO,OtherBuffer,Mode))
  925.                         {
  926.                             strcpy(OtherBuffer,"ENV:xem");
  927.  
  928.                             if(AddPart(OtherBuffer,SharedBuffer,50))
  929.                             {
  930.                                 if(XEmulatorPreferences(XEM_IO,OtherBuffer,Mode))
  931.                                     Success = TRUE;
  932.                             }
  933.                         }
  934.                         else
  935.                             Success = TRUE;
  936.  
  937.                         if(!Success)
  938.                             XEmulatorPreferences(XEM_IO,NULL,XEM_PREFS_RESET);
  939.                     }
  940.                 }
  941.                 else
  942.                 {
  943.                         /* Save settings to ENV: */
  944.  
  945.                     strcpy(OtherBuffer,"ENV:");
  946.  
  947.                     if(AddPart(OtherBuffer,SharedBuffer,50))
  948.                     {
  949.                         if(XEmulatorPreferences(XEM_IO,OtherBuffer,Mode))
  950.                             Success = TRUE;
  951.                     }
  952.  
  953.                     if(Success)
  954.                     {
  955.                         Success = FALSE;
  956.  
  957.                             /* Save settings to ENVARC: */
  958.  
  959.                         strcpy(OtherBuffer,"ENVARC:");
  960.  
  961.                         if(AddPart(OtherBuffer,SharedBuffer,50))
  962.                         {
  963.                             if(XEmulatorPreferences(XEM_IO,OtherBuffer,Mode))
  964.                                 Success = TRUE;
  965.                         }
  966.                     }
  967.                 }
  968.             }
  969.         }
  970.     }
  971.  
  972.         /* Return result. */
  973.  
  974.     return(Success);
  975. }
  976.  
  977.     /* SetupEmulator(BYTE OpenConsole):
  978.      *
  979.      *    Initialize the XEM_IO structure.
  980.      */
  981.  
  982. STATIC BYTE
  983. SetupEmulator(VOID)
  984. {
  985.     if(!XEM_IO)
  986.     {
  987.         if(XEM_IO = (struct XEM_IO *)AllocVec(sizeof(struct XEM_IO),MEMF_ANY | MEMF_CLEAR | MEMF_PUBLIC))
  988.         {
  989.             XEM_IO -> xem_window        = Window;
  990.             XEM_IO -> xem_font        = CurrentFont;
  991.             XEM_IO -> xem_signal        = &XEM_Signal;
  992.             XEM_IO -> xem_screendepth    = Window -> WScreen -> RastPort . BitMap -> Depth;
  993.  
  994.             XEM_IO -> xem_sread        = xem_sread;
  995.             XEM_IO -> xem_swrite        = xem_swrite;
  996.             XEM_IO -> xem_sflush        = xem_sflush;
  997.             XEM_IO -> xem_sbreak        = xem_sbreak;
  998.             XEM_IO -> xem_squery        = xem_squery;
  999.             XEM_IO -> xem_sstart        = xem_sstart;
  1000.             XEM_IO -> xem_sstop        = xem_sstop;
  1001.  
  1002.             XEM_IO -> xem_tbeep        = xem_tbeep;
  1003.             XEM_IO -> xem_tgets        = xem_tgets;
  1004.             XEM_IO -> xem_toptions        = xem_toptions;
  1005.  
  1006.             XEM_IO -> xem_process_macrokeys    = xem_macrodispatch;
  1007.  
  1008.             return(TRUE);
  1009.         }
  1010.     }
  1011.     else
  1012.         return(FALSE);
  1013.  
  1014.     return(FALSE);
  1015. }
  1016.  
  1017.     /* CloseEmulator():
  1018.      *
  1019.      *    Close the emulation library.
  1020.      */
  1021.  
  1022. VOID
  1023. CloseEmulator()
  1024. {
  1025.     if(XEmulatorBase)
  1026.     {
  1027.         if(XEM_IO)
  1028.         {
  1029.             XEmulatorMacroKeyFilter(XEM_IO,NULL);
  1030.             XEmulatorCloseConsole(XEM_IO);
  1031.             XEmulatorCleanup(XEM_IO);
  1032.         }
  1033.  
  1034.         CloseLibrary(XEmulatorBase);
  1035.  
  1036.         if(XEM_IO)
  1037.             FreeVec(XEM_IO);
  1038.  
  1039.         strcpy(EmulationName,LocaleString(MSG_TERMXEM_NO_EMULATION_TXT));
  1040.  
  1041.         XEmulatorBase    = NULL;
  1042.         XEM_Signal    = NULL;
  1043.         XEM_IO        = NULL;
  1044.  
  1045.         RasterEnabled = TRUE;
  1046.  
  1047.         ClearCursor();
  1048.  
  1049.         Reset();
  1050.  
  1051.         DrawCursor();
  1052.     }
  1053. }
  1054.  
  1055.     /* OpenEmulator(STRPTR Name):
  1056.      *
  1057.      *    Open an emulation library.
  1058.      */
  1059.  
  1060. BYTE __regargs
  1061. OpenEmulator(STRPTR Name)
  1062. {
  1063.     CloseEmulator();
  1064.  
  1065.     XEM_HostData . Source        = NULL;
  1066.     XEM_HostData . Destination    = NULL;
  1067.     XEM_HostData . InESC        = FALSE;
  1068.     XEM_HostData . InCSI        = FALSE;
  1069.  
  1070.     if(XEmulatorBase = OpenLibrary(Name,0))
  1071.     {
  1072.         ClearCursor();
  1073.  
  1074.         Reset();
  1075.  
  1076.         if(SetupEmulator())
  1077.         {
  1078.             SetWrMsk(RPort,DepthMask);
  1079.  
  1080.             ClearSerial();
  1081.  
  1082.             if(XEmulatorSetup(XEM_IO))
  1083.             {
  1084.                 RestartSerial(FALSE);
  1085.  
  1086.                 SetEmulatorOptions(XEM_PREFS_LOAD);
  1087.  
  1088.                 if(XEmulatorOpenConsole(XEM_IO))
  1089.                 {
  1090.                     STRPTR LibName = FilePart(XEmulatorBase -> lib_Node . ln_Name);
  1091.  
  1092.                     strcpy(EmulationName,&LibName[3]);
  1093.  
  1094.                     EmulationName[strlen(EmulationName) - 8] = 0;
  1095.  
  1096.                     SetupXEM_MacroKeys(MacroKeys);
  1097.  
  1098.                     return(TRUE);
  1099.                 }
  1100.             }
  1101.             else
  1102.                 RestartSerial(FALSE);
  1103.         }
  1104.  
  1105.         DrawCursor();
  1106.  
  1107.         CloseLibrary(XEmulatorBase);
  1108.  
  1109.         strcpy(EmulationName,LocaleString(MSG_TERMXEM_NO_EMULATION_TXT));
  1110.  
  1111.         XEmulatorBase    = NULL;
  1112.         XEM_Signal    = NULL;
  1113.     }
  1114.  
  1115.     return(FALSE);
  1116. }
  1117.  
  1118.     /* XOff():
  1119.      *
  1120.      *    Small local routine, complements XOn() in Serial.c
  1121.      */
  1122.  
  1123. STATIC VOID
  1124. XOff(VOID)
  1125. {
  1126.     if(Status == STATUS_HOLDING)
  1127.     {
  1128.         UBYTE c = XOF;
  1129.  
  1130.         SerWrite(&c,1);
  1131.  
  1132.         Status = STATUS_READY;
  1133.     }
  1134. }
  1135.  
  1136.     /* SetupXEM_MacroKeys(struct MacroKeys *Keys):
  1137.      *
  1138.      *    Sets up the internal representation of the macro key
  1139.      *    data to fit the XEM specification.
  1140.      */
  1141.  
  1142. VOID __regargs
  1143. SetupXEM_MacroKeys(struct MacroKeys *Keys)
  1144. {
  1145.         /* Are we allowed to do what we want to do? */
  1146.  
  1147.     if(XEM_MacroKeys && XEmulatorBase && Config -> TerminalConfig -> EmulationMode == EMULATION_EXTERNAL)
  1148.     {
  1149.         WORD i,j,k = 0;
  1150.  
  1151.             /* Clear the macro list. */
  1152.  
  1153.         NewList(&XEM_MacroList);
  1154.  
  1155.             /* Run down the list of qualifiers. */
  1156.  
  1157.         for(i = XMKQ_NONE ; i <= XMKQ_CONTROL ; i++)
  1158.         {
  1159.                 /* Run down the function keys. */
  1160.  
  1161.             for(j = 0 ; j < 10 ; j++)
  1162.             {
  1163.                     /* If the key has no data attached,
  1164.                      * don't use it in the list.
  1165.                      */
  1166.  
  1167.                 if(Keys -> Keys[i][j][0])
  1168.                 {
  1169.                     XEM_MacroKeys[k] . xmk_Type        = XMKT_RAWKEY;
  1170.                     XEM_MacroKeys[k] . xmk_Qualifier    = i;
  1171.                     XEM_MacroKeys[k] . xmk_Code        = 0x50 + j;
  1172.                     XEM_MacroKeys[k] . xmk_UserData        = NULL;
  1173.  
  1174.                     AddTail(&XEM_MacroList,(struct Node *)&XEM_MacroKeys[k++]);
  1175.                 }
  1176.             }
  1177.         }
  1178.  
  1179.             /* Take care of the rest, add support for the xON key. */
  1180.  
  1181.         XEM_MacroKeys[k] . xmk_Type         = XMKT_COOKED;
  1182.         XEM_MacroKeys[k] . xmk_Qualifier    = NULL;
  1183.         XEM_MacroKeys[k] . xmk_Code        = XON;
  1184.         XEM_MacroKeys[k] . xmk_UserData        = (APTR)DoxON;
  1185.  
  1186.         AddTail(&XEM_MacroList,(struct Node *)&XEM_MacroKeys[k++]);
  1187.  
  1188.             /* Take care of the xOFF key. */
  1189.  
  1190.         XEM_MacroKeys[k] . xmk_Type         = XMKT_COOKED;
  1191.         XEM_MacroKeys[k] . xmk_Qualifier    = NULL;
  1192.         XEM_MacroKeys[k] . xmk_Code        = XOF;
  1193.         XEM_MacroKeys[k] . xmk_UserData        = (APTR)XOff;
  1194.  
  1195.         AddTail(&XEM_MacroList,(struct Node *)&XEM_MacroKeys[k]);
  1196.  
  1197.             /* Make the emulator notice the new settings. */
  1198.  
  1199.         XEmulatorMacroKeyFilter(XEM_IO,&XEM_MacroList);
  1200.     }
  1201. }
  1202.