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 / SerialPanel.c < prev    next >
C/C++ Source or Header  |  1991-12-03  |  18KB  |  657 lines
  1. /* $Revision Header * Header built automatically - do not edit! *************
  2.  *
  3.  *    (C) Copyright 1991 by Olaf 'Olsen' Barthel & MXM
  4.  *
  5.  *    Name .....: SerialPanel.c
  6.  *    Created ..: Monday 21-Jan-91 20:12
  7.  *    Revision .: 0
  8.  *
  9.  *    Date            Author          Comment
  10.  *    =========       ========        ====================
  11.  *    21-Jan-91       Olsen           Created this file!
  12.  *
  13.  * $Revision Header ********************************************************/
  14.  
  15. #include "TermGlobal.h"
  16.  
  17. enum    {    GAD_BAUD,GAD_DATABITS,GAD_PARITY,GAD_STOPBITS,GAD_HANDSHAKING,GAD_DUPLEX,
  18.         GAD_HIGHSPEED,GAD_BREAKLENGTH,GAD_DEVICE,GAD_SELECT,GAD_UNIT,GAD_USE,GAD_CANCEL };
  19.  
  20. #define WIDTH    335
  21. #define HEIGHT    172
  22.  
  23. STATIC LONG Bauds[15] =
  24. {
  25.     110,300,1200,2400,4800,7200,9600,12000,14400,19200,31250,38400,57600,76800,115200
  26. };
  27.  
  28. STATIC STRPTR DataBits[3] =
  29. {
  30.     (STRPTR)"Seven",
  31.     (STRPTR)"Eight",
  32.     NULL
  33. };
  34.  
  35. STATIC STRPTR Parity[6] =
  36. {
  37.     (STRPTR)"None",
  38.     (STRPTR)"Even",
  39.     (STRPTR)"Odd",
  40.     (STRPTR)"Mark",
  41.     (STRPTR)"Space",
  42.     NULL
  43. };
  44.  
  45. STATIC STRPTR StopBits[3] =
  46. {
  47.     (STRPTR)"One",
  48.     (STRPTR)"Two",
  49.     NULL
  50. };
  51.  
  52. STATIC STRPTR Handshaking[4] =
  53. {
  54.     (STRPTR)"XON/XOFF",
  55.     (STRPTR)"RTS/CTS",
  56.     (STRPTR)"None",
  57.     NULL
  58. };
  59.  
  60. STATIC STRPTR Duplex[3] =
  61. {
  62.     (STRPTR)"Full",
  63.     (STRPTR)"Half (Local Echo)",
  64.     NULL
  65. };
  66.  
  67. enum    {    MEN_BAUD=1,MEN_DATABITS,MEN_PARITY,MEN_STOPBITS,MEN_HANDSHAKING,
  68.         MEN_DUPLEX,MEN_HIGHSPEED,MEN_SELECT,MEN_USE,MEN_CANCEL,MEN_QUITPANEL };
  69.  
  70. STATIC struct NewMenu SerialMenu[] =
  71. {
  72.     { NM_TITLE, "Project",             0 , 0, 0, (APTR)0},
  73.     {  NM_ITEM, "Baud Rate",        "R", 0, 0, (APTR)MEN_BAUD},
  74.     {  NM_ITEM, "Bits/Char",        "B", 0, 0, (APTR)MEN_DATABITS},
  75.     {  NM_ITEM, "Parity",            "P", 0, 0, (APTR)MEN_PARITY},
  76.     {  NM_ITEM, "Stop Bits",        "S", 0, 0, (APTR)MEN_STOPBITS},
  77.     {  NM_ITEM, "Handshaking",        "H", 0, 0, (APTR)MEN_HANDSHAKING},
  78.     {  NM_ITEM, "Duplex",            "D", 0, 0, (APTR)MEN_DUPLEX},
  79.     {  NM_ITEM, "High Speed Mode",        "M", 0, 0, (APTR)MEN_HIGHSPEED},
  80.     {  NM_ITEM, "Select New Device",    "N", 0, 0, (APTR)MEN_SELECT},
  81.     {  NM_ITEM, NM_BARLABEL,         0 , 0, 0, (APTR)0},
  82.     {  NM_ITEM, "Use",            "U", 0, 0, (APTR)MEN_USE},
  83.     {  NM_ITEM, "Cancel",            "C", 0, 0, (APTR)MEN_CANCEL},
  84.     {  NM_ITEM, NM_BARLABEL,         0 , 0, 0, (APTR)0},
  85.     {  NM_ITEM, "Quit",            "Q", 0, 0, (APTR)MEN_QUITPANEL},
  86.     { NM_END, 0,                 0 , 0, 0, (APTR)0}
  87. };
  88.  
  89. STATIC LONG __saveds
  90. ShowBaud(struct Gadget *SomeGadget,WORD Level)
  91. {
  92.     return(Bauds[Level]);
  93. }
  94.  
  95. STATIC struct Gadget *
  96. CreateAllGadgets(struct Configuration *Config,struct Gadget **GadgetArray,struct Gadget **GadgetList,APTR VisualInfo,UWORD TopEdge)
  97. {
  98.     struct Gadget        *Gadget;
  99.     struct NewGadget     NewGadget;
  100.     UWORD             Counter = 0;
  101.     WORD             i,Rate;
  102.  
  103.     memset(&NewGadget,0,sizeof(struct NewGadget));
  104.  
  105.     if(Gadget = CreateContext(GadgetList))
  106.     {
  107.         for(i = 0 ; i < 13 ; i++)
  108.         {
  109.             if(Config -> BaudRate == Bauds[i])
  110.             {
  111.                 Rate = i;
  112.                 break;
  113.             }
  114.         }
  115.  
  116.         NewGadget . ng_Width        = 164;
  117.         NewGadget . ng_Height        = 12;
  118.         NewGadget . ng_GadgetText    = "  Baud _Rate       ";
  119.         NewGadget . ng_TextAttr        = &DefaultFont;
  120.         NewGadget . ng_VisualInfo    = VisualInfo;
  121.         NewGadget . ng_GadgetID        = Counter;
  122.         NewGadget . ng_LeftEdge        = (strlen(NewGadget . ng_GadgetText) + 2 - 1) * 8 + 1;
  123.         NewGadget . ng_TopEdge        = 1 + TopEdge;
  124.  
  125.         GadgetArray[Counter++] = Gadget = CreateGadget(SLIDER_KIND,Gadget,&NewGadget,
  126.             GT_Underscore,        '_',
  127.             GTSL_Min,        0,
  128.             GTSL_Max,        14,
  129.             GTSL_Level,        Rate,
  130.             GTSL_DispFunc,        ShowBaud,
  131.             GTSL_LevelFormat,    "%6ld",
  132.             GTSL_MaxLevelLen,    6,
  133.         TAG_DONE);
  134.  
  135.         NewGadget . ng_GadgetText    = "_Bits/Char";
  136.         NewGadget . ng_GadgetID        = Counter;
  137.         NewGadget . ng_TopEdge        = NewGadget . ng_TopEdge + NewGadget . ng_Height + 1;
  138.  
  139.         GadgetArray[Counter++] = Gadget = CreateGadget(CYCLE_KIND,Gadget,&NewGadget,
  140.             GT_Underscore,    '_',
  141.             GTCY_Labels,    DataBits,
  142.             GTCY_Active,    Config -> BitsPerChar - 7,
  143.         TAG_DONE);
  144.  
  145.         NewGadget . ng_GadgetText    = "_Parity";
  146.         NewGadget . ng_GadgetID        = Counter;
  147.         NewGadget . ng_TopEdge        = NewGadget . ng_TopEdge + NewGadget . ng_Height + 1;
  148.  
  149.         GadgetArray[Counter++] = Gadget = CreateGadget(CYCLE_KIND,Gadget,&NewGadget,
  150.             GT_Underscore,    '_',
  151.             GTCY_Labels,    Parity,
  152.             GTCY_Active,    Config -> Parity,
  153.         TAG_DONE);
  154.  
  155.         NewGadget . ng_GadgetText    = "_Stop Bits";
  156.         NewGadget . ng_GadgetID        = Counter;
  157.         NewGadget . ng_TopEdge        = NewGadget . ng_TopEdge + NewGadget . ng_Height + 1;
  158.  
  159.         GadgetArray[Counter++] = Gadget = CreateGadget(CYCLE_KIND,Gadget,&NewGadget,
  160.             GT_Underscore,    '_',
  161.             GTCY_Labels,    StopBits,
  162.             GTCY_Active,    Config -> StopBits - 1,
  163.         TAG_DONE);
  164.  
  165.         NewGadget . ng_GadgetText    = "_Handshaking";
  166.         NewGadget . ng_GadgetID        = Counter;
  167.         NewGadget . ng_TopEdge        = NewGadget . ng_TopEdge + NewGadget . ng_Height + 1;
  168.  
  169.         GadgetArray[Counter++] = Gadget = CreateGadget(CYCLE_KIND,Gadget,&NewGadget,
  170.             GT_Underscore,    '_',
  171.             GTCY_Labels,    Handshaking,
  172.             GTCY_Active,    Config -> Handshaking,
  173.         TAG_DONE);
  174.  
  175.         NewGadget . ng_GadgetText    = "_Duplex";
  176.         NewGadget . ng_GadgetID        = Counter;
  177.         NewGadget . ng_TopEdge        = NewGadget . ng_TopEdge + NewGadget . ng_Height + 1;
  178.  
  179.         GadgetArray[Counter++] = Gadget = CreateGadget(CYCLE_KIND,Gadget,&NewGadget,
  180.             GT_Underscore,    '_',
  181.             GTCY_Labels,    Duplex,
  182.             GTCY_Active,    Config -> Duplex,
  183.         TAG_DONE);
  184.  
  185.         NewGadget . ng_GadgetText    = "High-Speed _Mode";
  186.         NewGadget . ng_GadgetID        = Counter;
  187.         NewGadget . ng_TopEdge        = NewGadget . ng_TopEdge + NewGadget . ng_Height + 1;
  188.         NewGadget . ng_Width        = 26;
  189.         NewGadget . ng_Height        = 11;
  190.  
  191.         GadgetArray[Counter++] = Gadget = CreateGadget(CHECKBOX_KIND,Gadget,&NewGadget,
  192.             GT_Underscore,    '_',
  193.             GTCB_Checked,    Config -> HighSpeed,
  194.         TAG_DONE);
  195.  
  196.         NewGadget . ng_GadgetText    = "Break Length (µs)";
  197.         NewGadget . ng_GadgetID        = Counter;
  198.         NewGadget . ng_TopEdge        = NewGadget . ng_TopEdge + NewGadget . ng_Height + 1;
  199.         NewGadget . ng_Width        = 164;
  200.         NewGadget . ng_Height        = 12;
  201.  
  202.         GadgetArray[Counter++] = Gadget = CreateGadget(INTEGER_KIND,Gadget,&NewGadget,
  203.             GTIN_MaxChars,    8,
  204.             GTIN_Number,    Config -> BreakLength,
  205.             GTST_EditHook,    &CommandHook,
  206.         TAG_DONE);
  207.  
  208.         NewGadget . ng_GadgetText    = "Serial Device";
  209.         NewGadget . ng_GadgetID        = Counter;
  210.         NewGadget . ng_TopEdge        = NewGadget . ng_TopEdge + NewGadget . ng_Height + 1;
  211.  
  212.         GadgetArray[Counter++] = Gadget = CreateGadget(STRING_KIND,Gadget,&NewGadget,
  213.             GTST_MaxChars,    40,
  214.             GTST_String,    Config -> SerialDevice,
  215.             GTST_EditHook,    &CommandHook,
  216.         TAG_DONE);
  217.  
  218.         NewGadget . ng_GadgetText    = "Select _New Device";
  219.         NewGadget . ng_GadgetID        = Counter;
  220.         NewGadget . ng_TopEdge        = NewGadget . ng_TopEdge + 13;
  221.  
  222.         GadgetArray[Counter++] = Gadget = CreateGadget(BUTTON_KIND,Gadget,&NewGadget,
  223.             GT_Underscore,    '_',
  224.         TAG_DONE);
  225.  
  226.         NewGadget . ng_GadgetText    = "Device Unit Number";
  227.         NewGadget . ng_GadgetID        = Counter;
  228.         NewGadget . ng_TopEdge        = NewGadget . ng_TopEdge + NewGadget . ng_Height + 1;
  229.  
  230.         GadgetArray[Counter++] = Gadget = CreateGadget(INTEGER_KIND,Gadget,&NewGadget,
  231.             GTIN_MaxChars,    2,
  232.             GTIN_Number,    Config -> UnitNumber,
  233.             GTST_EditHook,    &CommandHook,
  234.         TAG_DONE);
  235.  
  236.         NewGadget . ng_Width        = 52;
  237.         NewGadget . ng_Height        = 12;
  238.         NewGadget . ng_GadgetText    = "_Use";
  239.         NewGadget . ng_GadgetID        = Counter;
  240.         NewGadget . ng_Flags        = 0;
  241.         NewGadget . ng_LeftEdge        = 10;
  242.         NewGadget . ng_TopEdge        = HEIGHT - 3 - NewGadget . ng_Height;
  243.  
  244.         GadgetArray[Counter++] = Gadget = CreateGadget(BUTTON_KIND,Gadget,&NewGadget,
  245.             GT_Underscore,    '_',
  246.         TAG_DONE);
  247.  
  248.         NewGadget . ng_GadgetText    = "_Cancel";
  249.         NewGadget . ng_GadgetID        = Counter;
  250.         NewGadget . ng_LeftEdge        = WIDTH - 10 - NewGadget . ng_Width;
  251.  
  252.         GadgetArray[Counter++] = Gadget = CreateGadget(BUTTON_KIND,Gadget,&NewGadget,
  253.             GT_Underscore,    '_',
  254.         TAG_DONE);
  255.     }
  256.  
  257.     return(Gadget);
  258. }
  259.  
  260.     /* SelectDevice(UBYTE *Name,struct Window *ParentWindow):
  261.      *
  262.      *    Select a new serial driver device using the
  263.      *    asl.library file requester.
  264.      */
  265.  
  266. STATIC BYTE
  267. SelectDevice(UBYTE *Name,struct Window *ParentWindow)
  268. {
  269.     struct FileRequester    *AslFileRequest;
  270.     UBYTE            *File;
  271.     BYTE             NewDevice = FALSE;
  272.  
  273.     File = Name;
  274.  
  275.     if(FilePart(File) == File)
  276.         strcpy(SharedBuffer,"DEVS:");
  277.     else
  278.     {
  279.         UBYTE *Temp;
  280.  
  281.         strcpy(SharedBuffer,File);
  282.  
  283.         Temp = PathPart(SharedBuffer);
  284.  
  285.         Temp[0] = 0;
  286.  
  287.         File = FilePart(File);
  288.     }
  289.  
  290.     if(AslFileRequest = (struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
  291.         ASL_Window,    ParentWindow,
  292.         ASL_File,    File,
  293.         ASL_Dir,    SharedBuffer,
  294.         ASL_Hail,    "Select Device",
  295.         ASL_FuncFlags,    0,
  296.         ASL_Pattern,    "#?.device",
  297.         ASL_OKText,    "Select",
  298.     TAG_END))
  299.     {
  300.         if(AslRequestTags(AslFileRequest,TAG_DONE))
  301.         {
  302.             if(AslFileRequest -> rf_File[0])
  303.             {
  304.                 strcpy(SharedBuffer,AslFileRequest -> rf_Dir);
  305.  
  306.                 if(!AddPart(SharedBuffer,AslFileRequest -> rf_File,256))
  307.                     strcpy(SharedBuffer,AslFileRequest -> rf_File);
  308.  
  309.                 if(Stricmp(SharedBuffer,Name))
  310.                 {
  311.                     strcpy(Name,SharedBuffer);
  312.  
  313.                     NewDevice = TRUE;
  314.                 }
  315.             }
  316.         }
  317.  
  318.         FreeAslRequest(AslFileRequest);
  319.     }
  320.  
  321.     return(NewDevice);
  322. }
  323.  
  324. BYTE
  325. SerialPanel(struct Configuration *Config)
  326. {
  327.     struct Window    *PanelWindow;
  328.     struct Menu    *PanelMenu;
  329.     struct Gadget    *GadgetList = NULL;
  330.     struct Gadget    *GadgetArray[GAD_CANCEL + 1];
  331.     UBYTE         DummyBuffer[256];
  332.  
  333.     LONG         i;
  334.  
  335.     CopyMem(Config,&PrivateConfig,sizeof(struct Configuration));
  336.  
  337.     if(CreateAllGadgets(Config,&GadgetArray[0],&GadgetList,VisualInfo,Screen -> WBorTop + Screen -> Font -> ta_YSize + 1))
  338.     {
  339.         if(PanelMenu = CreateMenus(SerialMenu,
  340.             GTMN_FrontPen, 0,
  341.         TAG_DONE))
  342.         {
  343.             if(LayoutMenus(PanelMenu,VisualInfo,
  344.                 GTMN_TextAttr,&DefaultFont,
  345.             TAG_DONE))
  346.             {
  347.                 if(PanelWindow = OpenWindowTags(NULL,
  348.                     WA_Left,    (Screen -> Width - WIDTH) >> 1,
  349.                     WA_Top,        (Screen -> Height - HEIGHT) >> 1,
  350.                     WA_Width,    WIDTH,
  351.                     WA_Height,    HEIGHT,
  352.  
  353.                     WA_Activate,    TRUE,
  354.                     WA_DragBar,    TRUE,
  355.                     WA_DepthGadget,    TRUE,
  356.                     WA_RMBTrap,    TRUE,
  357.                     WA_DepthGadget,    TRUE,
  358.                     WA_CloseGadget,    TRUE,
  359.                     WA_CustomScreen,Screen,
  360.  
  361.                     WA_IDCMP,    IDCMP_GADGETDOWN | IDCMP_ACTIVEWINDOW | IDCMP_CLOSEWINDOW | SLIDERIDCMP | CHECKBOXIDCMP | LISTVIEWIDCMP | IDCMP_MENUPICK | IDCMP_RAWKEY,
  362.  
  363.                     WA_Title,    "Serial Preferences",
  364.                 TAG_DONE))
  365.                 {
  366.                     struct IntuiMessage    *Massage;
  367.                     ULONG             Class,Code,Value;
  368.                     struct Gadget        *Gadget;
  369.                     BYTE             Terminated = FALSE;
  370.  
  371.                     PushWindow(PanelWindow);
  372.  
  373.                     AddGList(PanelWindow,GadgetList,(UWORD)-1,(UWORD)-1,NULL);
  374.                     RefreshGList(GadgetList,PanelWindow,NULL,(UWORD)-1);
  375.                     GT_RefreshWindow(PanelWindow,NULL);
  376.  
  377.                     SetMenuStrip(PanelWindow,PanelMenu);
  378.  
  379.                     PanelWindow -> Flags &= ~WFLG_RMBTRAP;
  380.  
  381.                     ActivateGadget(GadgetArray[GAD_BREAKLENGTH],PanelWindow,NULL);
  382.  
  383.                     ActiveGadget = GadgetArray[GAD_BREAKLENGTH];
  384.  
  385.                     while(!Terminated)
  386.                     {
  387.                         WaitPort(PanelWindow -> UserPort);
  388.  
  389.                         while(!Terminated && (Massage = (struct IntuiMessage *)GT_GetIMsg(PanelWindow -> UserPort)))
  390.                         {
  391.                             Class    = Massage -> Class;
  392.                             Code    = Massage -> Code;
  393.                             Gadget    = (struct Gadget *)Massage -> IAddress;
  394.  
  395.                             GT_ReplyIMsg(Massage);
  396.  
  397.                             if(Class == IDCMP_GADGETDOWN)
  398.                             {
  399.                                 if((Gadget -> GadgetType & GTYP_GTYPEMASK) == STRGADGET)
  400.                                     ActiveGadget = Gadget;
  401.                             }
  402.  
  403.                             if(Class == IDCMP_ACTIVEWINDOW && ActiveGadget)
  404.                                 ActivateGadget(ActiveGadget,PanelWindow,NULL);
  405.  
  406.                             if(Class == IDCMP_RAWKEY)
  407.                             {
  408.                                 if(Code == IECODE_UP_PREFIX|103 && CommandWindow == PanelWindow)
  409.                                     ActivateGadget(CommandGadget,PanelWindow,NULL);
  410.                             }
  411.  
  412.                             if(Class == IDCMP_MENUPICK)
  413.                             {
  414.                                 struct MenuItem *MenuItem;
  415.  
  416.                                 while(Code != MENUNULL)
  417.                                 {
  418.                                     MenuItem = ItemAddress(PanelMenu,Code);
  419.  
  420.                                     switch((ULONG)GTMENUITEM_USERDATA(MenuItem))
  421.                                     {
  422.                                         case MEN_QUITPANEL:    Class = IDCMP_CLOSEWINDOW;
  423.                                                     break;
  424.  
  425.                                         case MEN_BAUD:        if(Config -> BaudRate == Bauds[11])
  426.                                                         Value = 0;
  427.                                                     else
  428.                                                     {
  429.                                                         for(i = 0 ; i < 13 ; i++)
  430.                                                         {
  431.                                                             if(Config -> BaudRate == Bauds[i])
  432.                                                             {
  433.                                                                 Value = i + 1;
  434.                                                                 break;
  435.                                                             }
  436.                                                         }
  437.                                                     }
  438.  
  439.                                                     GT_SetGadgetAttrs(GadgetArray[GAD_BAUD],PanelWindow,NULL,
  440.                                                         GTSL_Level,Value,
  441.                                                     TAG_DONE);
  442.  
  443.                                                     Config -> BaudRate = Bauds[Value];
  444.  
  445.                                                     break;
  446.  
  447.                                         case MEN_DATABITS:    if(Config -> BitsPerChar == 8)
  448.                                                         Value = 0;
  449.                                                     else
  450.                                                         Value = 1;
  451.  
  452.                                                     GT_SetGadgetAttrs(GadgetArray[GAD_DATABITS],PanelWindow,NULL,
  453.                                                         GTCY_Active,Value,
  454.                                                     TAG_DONE);
  455.  
  456.                                                     Class = IDCMP_GADGETUP;
  457.                                                     Gadget = GadgetArray[GAD_DATABITS];
  458.                                                     Code = Value;
  459.  
  460.                                                     goto GadCheck;
  461.  
  462.                                         case MEN_PARITY:    if(Config -> Parity == PARITY_SPACE)
  463.                                                         Value = PARITY_NONE;
  464.                                                     else
  465.                                                         Value = Config -> Parity + 1;
  466.  
  467.                                                     GT_SetGadgetAttrs(GadgetArray[GAD_PARITY],PanelWindow,NULL,
  468.                                                         GTCY_Active,Value,
  469.                                                     TAG_DONE);
  470.  
  471.                                                     Class = IDCMP_GADGETUP;
  472.                                                     Gadget = GadgetArray[GAD_PARITY];
  473.                                                     Code = Value;
  474.  
  475.                                                     goto GadCheck;
  476.  
  477.                                         case MEN_STOPBITS:    if(Config -> StopBits == 2)
  478.                                                         Value = 0;
  479.                                                     else
  480.                                                         Value = 1;
  481.  
  482.                                                     GT_SetGadgetAttrs(GadgetArray[GAD_STOPBITS],PanelWindow,NULL,
  483.                                                         GTCY_Active,Value,
  484.                                                     TAG_DONE);
  485.  
  486.                                                     Class = IDCMP_GADGETUP;
  487.                                                     Gadget = GadgetArray[GAD_STOPBITS];
  488.                                                     Code = Value;
  489.  
  490.                                                     goto GadCheck;
  491.  
  492.                                         case MEN_HANDSHAKING:    if(Config -> Handshaking == HANDSHAKING_NONE)
  493.                                                             Value = HANDSHAKING_XONXOFF;
  494.                                                     else
  495.                                                         Value = Config -> Handshaking + 1;
  496.  
  497.                                                     GT_SetGadgetAttrs(GadgetArray[GAD_HANDSHAKING],PanelWindow,NULL,
  498.                                                         GTCY_Active,Value,
  499.                                                     TAG_DONE);
  500.  
  501.                                                     Class = IDCMP_GADGETUP;
  502.                                                     Gadget = GadgetArray[GAD_HANDSHAKING];
  503.                                                     Code = Value;
  504.  
  505.                                                     goto GadCheck;
  506.  
  507.                                         case MEN_DUPLEX:    if(Config -> Duplex == DUPLEX_FULL)
  508.                                                         Value = DUPLEX_HALF;
  509.                                                     else
  510.                                                         Value = DUPLEX_FULL;
  511.  
  512.                                                     GT_SetGadgetAttrs(GadgetArray[GAD_DUPLEX],PanelWindow,NULL,
  513.                                                         GTCY_Active,Value,
  514.                                                     TAG_DONE);
  515.  
  516.                                                     Class = IDCMP_GADGETUP;
  517.                                                     Gadget = GadgetArray[GAD_DUPLEX];
  518.                                                     Code = Value;
  519.  
  520.                                                     goto GadCheck;
  521.  
  522.                                         case MEN_HIGHSPEED:    GT_SetGadgetAttrs(GadgetArray[GAD_HIGHSPEED],PanelWindow,NULL,
  523.                                                         GTCB_Checked,GadgetArray[GAD_HIGHSPEED] -> Flags & GFLG_SELECTED ? FALSE : TRUE,
  524.                                                     TAG_DONE);
  525.  
  526.                                                     break;
  527.  
  528.                                         case MEN_SELECT:    Class = IDCMP_GADGETUP;
  529.                                                     Gadget = GadgetArray[GAD_SELECT];
  530.                                                     break;
  531.  
  532.                                         case MEN_USE:        Class = IDCMP_GADGETUP;
  533.                                                     Gadget = GadgetArray[GAD_USE];
  534.                                                     break;
  535.  
  536.                                         case MEN_CANCEL:    Class = IDCMP_GADGETUP;
  537.                                                     Gadget = GadgetArray[GAD_CANCEL];
  538.                                                     break;
  539.  
  540.                                         default:        break;
  541.                                     }
  542.  
  543.                                     Code = MenuItem -> NextSelect;
  544.                                 }
  545.  
  546.                                 if(ActiveGadget)
  547.                                     ActivateGadget(ActiveGadget,PanelWindow,NULL);
  548.                             }
  549.  
  550.                             if(Class == IDCMP_CLOSEWINDOW)
  551.                                 Terminated = TRUE;
  552.  
  553.                             if(Class == IDCMP_MOUSEMOVE)
  554.                             {
  555.                                 switch(Gadget -> GadgetID)
  556.                                 {
  557.                                     case GAD_BAUD:    Config -> BaudRate = Bauds[Code];
  558.                                             break;
  559.  
  560.                                     default:    break;
  561.                                 }
  562.                             }
  563.  
  564. GadCheck:                        if(Class == IDCMP_GADGETUP)
  565.                             {
  566.                                 switch(Gadget -> GadgetID)
  567.                                 {
  568.                                     case GAD_DUPLEX:    Config -> Duplex = Code;
  569.                                                 break;
  570.  
  571.                                     case GAD_HANDSHAKING:    Config -> Handshaking = Code;
  572.                                                 break;
  573.  
  574.                                     case GAD_STOPBITS:    Config -> StopBits = 1 + Code;
  575.                                                 break;
  576.  
  577.                                     case GAD_PARITY:    Config -> Parity = Code;
  578.                                                 break;
  579.  
  580.                                     case GAD_DATABITS:    Config -> BitsPerChar = 7 + Code;
  581.                                                 break;
  582.  
  583.                                     case GAD_SELECT:    strcpy(DummyBuffer,((struct StringInfo *)GadgetArray[GAD_DEVICE] -> SpecialInfo) -> Buffer);
  584.  
  585.                                                 SetWait(PanelWindow);
  586.  
  587.                                                 PanelWindow -> Flags |= WFLG_RMBTRAP;
  588.  
  589.                                                 if(SelectDevice(DummyBuffer,PanelWindow))
  590.                                                 {
  591.                                                     if(strlen(DummyBuffer) > 39)
  592.                                                     {
  593.                                                         GT_SetGadgetAttrs(GadgetArray[GAD_DEVICE],PanelWindow,NULL,
  594.                                                             GTST_String,FilePart(DummyBuffer),
  595.                                                         TAG_DONE);
  596.                                                     }
  597.                                                     else
  598.                                                     {
  599.                                                         GT_SetGadgetAttrs(GadgetArray[GAD_DEVICE],PanelWindow,NULL,
  600.                                                             GTST_String,DummyBuffer,
  601.                                                         TAG_DONE);
  602.                                                     }
  603.                                                 }
  604.  
  605.                                                 ClearPointer(PanelWindow);
  606.                                                 PanelWindow -> Flags &= ~WFLG_RMBTRAP;
  607.  
  608.                                                 break;
  609.  
  610.                                     case GAD_USE:        Terminated = TRUE;
  611.  
  612.                                                 Config -> UnitNumber = ((struct StringInfo *)GadgetArray[GAD_UNIT] -> SpecialInfo) -> LongInt;
  613.  
  614.                                                 strcpy(Config -> SerialDevice,((struct StringInfo *)GadgetArray[GAD_DEVICE] -> SpecialInfo) -> Buffer);
  615.  
  616.                                                 Config -> BreakLength = ((struct StringInfo *)GadgetArray[GAD_BREAKLENGTH] -> SpecialInfo) -> LongInt;
  617.  
  618.                                                 Config -> HighSpeed = GadgetArray[GAD_HIGHSPEED] -> Flags & GFLG_SELECTED;
  619.  
  620.                                                 break;
  621.  
  622.                                     case GAD_CANCEL:    Terminated = TRUE;
  623.  
  624.                                                 CopyMem(&PrivateConfig,Config,sizeof(struct Configuration));
  625.  
  626.                                                 break;
  627.  
  628.                                     default:        break;
  629.                                 }
  630.                             }
  631.                         }
  632.                     }
  633.  
  634.                     PanelWindow -> Flags |= WFLG_RMBTRAP;
  635.  
  636.                     ClearMenuStrip(PanelWindow);
  637.  
  638.                     RemoveGList(PanelWindow,GadgetList,(UWORD)-1);
  639.  
  640.                     PopWindow();
  641.  
  642.                     CloseWindow(PanelWindow);
  643.                 }
  644.             }
  645.  
  646.             FreeMenus(PanelMenu);
  647.         }
  648.     }
  649.  
  650.     FreeGadgets(GadgetList);
  651.  
  652.     if(memcmp(&PrivateConfig,Config,sizeof(struct Configuration)))
  653.         return(TRUE);
  654.     else
  655.         return(FALSE);
  656. }
  657.