home *** CD-ROM | disk | FTP | other *** search
/ Amiga Times / AmigaTimes.iso / internet / Term / Extras / Source / term-source.lha / TrapPanel.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-10-20  |  15.5 KB  |  739 lines
  1. /*
  2. **    TrapPanel.c
  3. **
  4. **    Editing panel for trap list
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. **
  9. **    :ts=4
  10. */
  11.  
  12. #ifndef _GLOBAL_H
  13. #include "Global.h"
  14. #endif
  15.  
  16. enum    {    GAD_LIST,GAD_SEQUENCE,GAD_COMMAND,
  17.             GAD_TOP,GAD_UP,GAD_DOWN,GAD_END,
  18.             GAD_NEW,GAD_REMOVE,GAD_CLEAR,
  19.             GAD_LOAD,GAD_SAVE,GAD_USE,GAD_CLOSE,
  20.             GAD_DISCARD
  21.         };
  22.  
  23. STATIC VOID
  24. ChangeLocalState(LayoutHandle *Handle,struct GenericList *List,struct TrapNode *Node)
  25. {
  26.     BOOL IsFirst,IsLast,IsEmpty,IsInvalid;
  27.     Tag StringTag;
  28.  
  29.     if(IsEmpty = IsListEmpty((struct List *)List))
  30.         IsFirst = IsLast = IsInvalid = TRUE;
  31.     else
  32.     {
  33.         if(Node)
  34.         {
  35.             IsFirst        = (BOOL)(Node == (struct TrapNode *)((struct List *)List)->lh_Head);
  36.             IsLast        = (BOOL)(Node == (struct TrapNode *)((struct List *)List)->lh_TailPred);
  37.             IsInvalid    = FALSE;
  38.         }
  39.         else
  40.             IsFirst = IsLast = IsInvalid = TRUE;
  41.     }
  42.  
  43.     StringTag = IsInvalid ? GTST_String : TAG_IGNORE;
  44.  
  45.     LT_SetAttributes(Handle,GAD_TOP,
  46.         GA_Disabled,    IsFirst,
  47.     TAG_DONE);
  48.  
  49.     LT_SetAttributes(Handle,GAD_UP,
  50.         GA_Disabled,    IsFirst,
  51.     TAG_DONE);
  52.  
  53.     LT_SetAttributes(Handle,GAD_DOWN,
  54.         GA_Disabled,    IsLast,
  55.     TAG_DONE);
  56.  
  57.     LT_SetAttributes(Handle,GAD_END,
  58.         GA_Disabled,    IsLast,
  59.     TAG_DONE);
  60.  
  61.     LT_SetAttributes(Handle,GAD_SAVE,
  62.         GA_Disabled,    IsEmpty,
  63.     TAG_DONE);
  64.  
  65.     LT_SetAttributes(Handle,GAD_CLEAR,
  66.         GA_Disabled,    IsEmpty,
  67.     TAG_DONE);
  68.  
  69.     LT_SetAttributes(Handle,GAD_REMOVE,
  70.         GA_Disabled,    IsInvalid,
  71.     TAG_DONE);
  72.  
  73.     LT_SetAttributes(Handle,GAD_SEQUENCE,
  74.         GA_Disabled,    IsInvalid,
  75.         StringTag,        "",
  76.     TAG_DONE);
  77.  
  78.     LT_SetAttributes(Handle,GAD_COMMAND,
  79.         GA_Disabled,    IsInvalid,
  80.         StringTag,        "",
  81.     TAG_DONE);
  82. }
  83.  
  84. BOOL
  85. TrapPanelConfig(struct Configuration *LocalConfig,BOOL *ChangedPtr)
  86. {
  87.     struct LayoutHandle    *Handle;
  88.     struct GenericList    *TrapList;
  89.     struct TrapNode        *Node,
  90.                         *Next;
  91.     BOOL                 Changed;
  92.  
  93.     Changed = FALSE;
  94.  
  95.     TrapList = GenericListTable[GLIST_TRAP];
  96.  
  97.     LockGenericList(TrapList);
  98.  
  99.     if(Handle = LT_CreateHandleTags(Window->WScreen,
  100.         LAHN_LocaleHook,    &LocaleHook,
  101.     TAG_DONE))
  102.     {
  103.         struct Window    *LocalWindow;
  104.         struct IBox     Bounds;
  105.  
  106.         LT_New(Handle,
  107.             LA_Type,    VERTICAL_KIND,
  108.         TAG_DONE);
  109.         {
  110.             LT_New(Handle,
  111.                 LA_Type,    VERTICAL_KIND,
  112.                 LA_LabelID,    MSG_TRAPPANEL_TRAP_CONTROLS_TXT,
  113.             TAG_DONE);
  114.             {
  115.                 LONG MaxWidth,MaxHeight;
  116.  
  117.                 MaxWidth = MaxHeight = 0;
  118.  
  119.                 if(TrapList)
  120.                 {
  121.                     struct Node *Node;
  122.                     LONG Len;
  123.  
  124.                     for(Node = (struct Node *)TrapList->ListHeader.mlh_Head ; Node->ln_Succ ; Node = Node->ln_Succ)
  125.                     {
  126.                         Len = strlen(Node->ln_Name);
  127.  
  128.                         if(Len > MaxWidth)
  129.                             MaxWidth = Len;
  130.  
  131.                         MaxHeight++;
  132.                     }
  133.                 }
  134.  
  135.                 if(MaxWidth < 30)
  136.                     MaxWidth = 30;
  137.  
  138.                 if(MaxHeight < 10)
  139.                     MaxHeight = 10;
  140.                 else
  141.                 {
  142.                     if(MaxHeight > 20)
  143.                         MaxHeight = 20;
  144.                 }
  145.  
  146.                 LT_New(Handle,
  147.                     LA_Type,        LISTVIEW_KIND,
  148.                     LA_LabelID,        MSG_TRAPPANEL_TRAP_LIST_TXT,
  149.                     LA_LabelPlace,    PLACE_Left,
  150.                     LA_Chars,        30,
  151.                     LA_ID,            GAD_LIST,
  152.                     LALV_Lines,        10,
  153.                     LALV_CursorKey,    TRUE,
  154.                     LALV_MaxGrowX,    MaxWidth,
  155.                     LALV_MaxGrowY,    MaxHeight,
  156.                     LALV_ResizeY,    TRUE,
  157.                     LALV_ResizeX,    TRUE,
  158.                     GTLV_Labels,    TrapList,
  159.  
  160.                     Kick30 ? LALV_Link : TAG_IGNORE, NIL_LINK,
  161.                 TAG_DONE);
  162.  
  163.                 LT_New(Handle,
  164.                     LA_Type,        STRING_KIND,
  165.                     LA_LabelID,        MSG_TRAPPANEL_SEQUENCE_TXT,
  166.                     LA_ID,            GAD_SEQUENCE,
  167.                     GTST_MaxChars,    255,
  168.                     GA_Disabled,    TRUE,
  169.                 TAG_DONE);
  170.  
  171.                 LT_New(Handle,
  172.                     LA_Type,        STRING_KIND,
  173.                     LA_LabelID,        MSG_TRAPPANEL_COMMAND_TXT,
  174.                     LA_ID,            GAD_COMMAND,
  175.                     GTST_MaxChars,    255,
  176.                     GA_Disabled,    TRUE,
  177.                 TAG_DONE);
  178.  
  179.                 LT_EndGroup(Handle);
  180.             }
  181.  
  182.             LT_New(Handle,
  183.                 LA_Type,    HORIZONTAL_KIND,
  184.             TAG_DONE);
  185.             {
  186.                 LT_New(Handle,
  187.                     LA_Type,        HORIZONTAL_KIND,
  188.                     LA_LabelID,        MSG_V36_0038,
  189.                     LAGR_Spread,    TRUE,
  190.                     LAGR_SameSize,    TRUE,
  191.                 TAG_DONE);
  192.                 {
  193.                     LT_New(Handle,
  194.                         LA_Type,        TAPEDECK_KIND,
  195.                         LATD_ButtonType,TDBT_Previous,
  196.                         LATD_Smaller,    TRUE,
  197.                         LA_ID,            GAD_TOP,
  198.                         LA_NoKey,        TRUE,
  199.                         GA_Disabled,    TRUE,
  200.                     TAG_DONE);
  201.  
  202.                     LT_New(Handle,
  203.                         LA_Type,        TAPEDECK_KIND,
  204.                         LATD_ButtonType,TDBT_Rewind,
  205.                         LATD_Smaller,    TRUE,
  206.                         LA_ID,            GAD_UP,
  207.                         LA_NoKey,        TRUE,
  208.                         GA_Disabled,    TRUE,
  209.                     TAG_DONE);
  210.  
  211.                     LT_New(Handle,
  212.                         LA_Type,        TAPEDECK_KIND,
  213.                         LATD_ButtonType,TDBT_Play,
  214.                         LATD_Smaller,    TRUE,
  215.                         LA_ID,            GAD_DOWN,
  216.                         LA_NoKey,        TRUE,
  217.                         GA_Disabled,    TRUE,
  218.                     TAG_DONE);
  219.  
  220.                     LT_New(Handle,
  221.                         LA_Type,        TAPEDECK_KIND,
  222.                         LATD_ButtonType,TDBT_Next,
  223.                         LATD_Smaller,    TRUE,
  224.                         LA_ID,            GAD_END,
  225.                         LA_NoKey,        TRUE,
  226.                         GA_Disabled,    TRUE,
  227.                     TAG_DONE);
  228.  
  229.                     LT_EndGroup(Handle);
  230.                 }
  231.  
  232.                 LT_New(Handle,
  233.                     LA_Type,        HORIZONTAL_KIND,
  234.                     LA_LabelID,        MSG_V36_0043,
  235.                     LAGR_Spread,    TRUE,
  236.                     LAGR_SameSize,    TRUE,
  237.                 TAG_DONE);
  238.                 {
  239.                     LT_New(Handle,
  240.                         LA_Type,        BUTTON_KIND,
  241.                         LA_LabelID,        MSG_FASTMACROPANEL_NEW_GAD,
  242.                         LA_ID,            GAD_NEW,
  243.                     TAG_DONE);
  244.  
  245.                     LT_New(Handle,
  246.                         LA_Type,        BUTTON_KIND,
  247.                         LA_LabelID,        MSG_GLOBAL_REMOVE_GAD,
  248.                         LA_ID,            GAD_REMOVE,
  249.                         GA_Disabled,    TRUE,
  250.                     TAG_DONE);
  251.  
  252.                     LT_New(Handle,
  253.                         LA_Type,        BUTTON_KIND,
  254.                         LA_LabelID,        MSG_UPLOADQUEUE_CLEAR_TXT,
  255.                         LA_ID,            GAD_CLEAR,
  256.                         GA_Disabled,    IsListEmpty((struct List *)TrapList),
  257.                     TAG_DONE);
  258.  
  259.                     LT_EndGroup(Handle);
  260.                 }
  261.  
  262.                 LT_EndGroup(Handle);
  263.             }
  264.  
  265.             LT_New(Handle,
  266.                 LA_Type,    VERTICAL_KIND,
  267.             TAG_DONE);
  268.             {
  269.                 LT_New(Handle,
  270.                     LA_Type,        XBAR_KIND,
  271.                     LAXB_FullSize,    TRUE,
  272.                 TAG_DONE);
  273.  
  274.                 LT_EndGroup(Handle);
  275.             }
  276.  
  277.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  278.                 LAGR_SameSize,    TRUE,
  279.                 LAGR_Spread,    TRUE,
  280.                 LA_ExtraSpace,    TRUE,
  281.             TAG_DONE);
  282.             {
  283.                 LT_New(Handle,
  284.                     LA_Type,        BUTTON_KIND,
  285.                     LA_LabelID,        MSG_GLOBAL_USE_GAD,
  286.                     LA_ID,            GAD_USE,
  287.                     LABT_ReturnKey,    TRUE,
  288.                     LABT_ExtraFat,    TRUE,
  289.                 TAG_DONE);
  290.  
  291.                 LT_New(Handle,
  292.                     LA_Type,        BUTTON_KIND,
  293.                     LA_LabelID,        MSG_GLOBAL_LOAD_GAD,
  294.                     LA_ID,            GAD_LOAD,
  295.                 TAG_DONE);
  296.  
  297.                 LT_New(Handle,
  298.                     LA_Type,        BUTTON_KIND,
  299.                     LA_LabelID,        MSG_GLOBAL_SAVE_GAD,
  300.                     LA_ID,            GAD_SAVE,
  301.                     GA_Disabled,    IsListEmpty((struct List *)TrapList),
  302.                 TAG_DONE);
  303.  
  304.                 LT_New(Handle,
  305.                     LA_Type,        BUTTON_KIND,
  306.                     LA_LabelID,        MSG_DISCARD_GAD,
  307.                     LA_ID,            GAD_DISCARD,
  308.                 TAG_DONE);
  309.  
  310.                 LT_New(Handle,
  311.                     LA_Type,        BUTTON_KIND,
  312.                     LA_LabelID,        MSG_GLOBAL_CLOSE_TXT,
  313.                     LA_ID,            GAD_CLOSE,
  314.                     LABT_EscKey,    TRUE,
  315.                 TAG_DONE);
  316.  
  317.                 LT_EndGroup(Handle);
  318.             }
  319.  
  320.             LT_EndGroup(Handle);
  321.         }
  322.  
  323.         if(Screen && Window)
  324.         {
  325.             Bounds.Left        = Window->LeftEdge;
  326.             Bounds.Top        = Window->TopEdge;
  327.             Bounds.Width    = Window->Width;
  328.             Bounds.Height    = Window->Height;
  329.         }
  330.  
  331.         if(LocalWindow = LT_Build(Handle,
  332.             LAWN_TitleID,        MSG_TRAPPANEL_TRAP_PREFERENCES_TXT,
  333.             LAWN_HelpHook,        &GuideHook,
  334.             LAWN_Parent,        Window,
  335.             WA_DepthGadget,        TRUE,
  336.             WA_DragBar,            TRUE,
  337.             WA_RMBTrap,            TRUE,
  338.             WA_Activate,        TRUE,
  339.             WA_SimpleRefresh,    TRUE,
  340.  
  341.             Screen ? LAWN_Bounds : TAG_IGNORE, &Bounds,
  342.         TAG_DONE))
  343.         {
  344.             struct IntuiMessage        *Message;
  345.             BOOL                     Done = FALSE;
  346.             ULONG                     MsgClass;
  347.             UWORD                     MsgCode;
  348.             struct Gadget            *MsgGadget;
  349.  
  350.             struct TrapNode            *Selected = NULL;
  351.             LONG                     Offset = -1;
  352.  
  353.             UBYTE                      DummyBuffer[MAX_FILENAME_LENGTH];
  354.             struct FileRequester    *FileRequest;
  355.  
  356.             GuideContext(CONTEXT_TRAPS);
  357.  
  358.             PushWindow(LocalWindow);
  359.  
  360.             do
  361.             {
  362.                 if(Wait(PORTMASK(LocalWindow->UserPort) | SIG_BREAK) & SIG_BREAK)
  363.                     break;
  364.  
  365.                 while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  366.                 {
  367.                     MsgClass    = Message->Class;
  368.                     MsgCode        = Message->Code;
  369.                     MsgGadget    = (struct Gadget *)Message->IAddress;
  370.  
  371.                     LT_ReplyIMsg(Message);
  372.  
  373.                     if(MsgClass == IDCMP_GADGETUP)
  374.                     {
  375.                         switch(MsgGadget->GadgetID)
  376.                         {
  377.                             case GAD_CLOSE:
  378.                             case GAD_USE:
  379.  
  380.                                 if(Selected)
  381.                                 {
  382.                                     strcpy(Selected->Command,LT_GetString(Handle,GAD_COMMAND));
  383.                                     strcpy(Selected->Node.ln_Name,LT_GetString(Handle,GAD_SEQUENCE));
  384.                                 }
  385.  
  386.                                 Done = TRUE;
  387.                                 break;
  388.  
  389.                             case GAD_TOP:
  390.  
  391.                                 MoveListViewNode(Handle,(struct List *)TrapList,GAD_LIST,(struct Node *)Selected,&Offset,MOVE_HEAD);
  392.  
  393.                                 ChangeLocalState(Handle,TrapList,Selected);
  394.  
  395.                                 Changed = TRUE;
  396.  
  397.                                 if(ChangedPtr)
  398.                                     *ChangedPtr = TRUE;
  399.  
  400.                                 break;
  401.  
  402.                             case GAD_UP:
  403.  
  404.                                 MoveListViewNode(Handle,(struct List *)TrapList,GAD_LIST,(struct Node *)Selected,&Offset,MOVE_PRED);
  405.  
  406.                                 ChangeLocalState(Handle,TrapList,Selected);
  407.  
  408.                                 Changed = TRUE;
  409.  
  410.                                 if(ChangedPtr)
  411.                                     *ChangedPtr = TRUE;
  412.  
  413.                                 break;
  414.  
  415.                             case GAD_DOWN:
  416.  
  417.                                 MoveListViewNode(Handle,(struct List *)TrapList,GAD_LIST,(struct Node *)Selected,&Offset,MOVE_SUCC);
  418.  
  419.                                 ChangeLocalState(Handle,TrapList,Selected);
  420.  
  421.                                 Changed = TRUE;
  422.  
  423.                                 if(ChangedPtr)
  424.                                     *ChangedPtr = TRUE;
  425.  
  426.                                 break;
  427.  
  428.                             case GAD_END:
  429.  
  430.                                 MoveListViewNode(Handle,(struct List *)TrapList,GAD_LIST,(struct Node *)Selected,&Offset,MOVE_TAIL);
  431.  
  432.                                 ChangeLocalState(Handle,TrapList,Selected);
  433.  
  434.                                 Changed = TRUE;
  435.  
  436.                                 if(ChangedPtr)
  437.                                     *ChangedPtr = TRUE;
  438.  
  439.                                 break;
  440.  
  441.                             case GAD_NEW:
  442.  
  443.                                 if(Node = CreateTrapNode("",""))
  444.                                 {
  445.                                     LT_SetAttributes(Handle,GAD_LIST,
  446.                                         GTLV_Labels,    ~0,
  447.                                     TAG_DONE);
  448.  
  449.                                     AddGenericListNode(TrapList,(struct Node *)Node,ADD_GLIST_BOTTOM,TRUE);
  450.  
  451.                                     Selected = Node;
  452.                                     Offset = GenericListCount(TrapList) - 1;
  453.  
  454.                                     LT_SetAttributes(Handle,GAD_LIST,
  455.                                         GTLV_Labels,    TrapList,
  456.                                         LALV_Selected,    Offset,
  457.                                     TAG_DONE);
  458.  
  459.                                     LT_SetAttributes(Handle,GAD_COMMAND,
  460.                                         GTST_String,    "",
  461.                                     TAG_DONE);
  462.  
  463.                                     LT_SetAttributes(Handle,GAD_SEQUENCE,
  464.                                         GTST_String,    "",
  465.                                     TAG_DONE);
  466.  
  467.                                     ChangeLocalState(Handle,TrapList,Selected);
  468.  
  469.                                     LT_Activate(Handle,GAD_SEQUENCE);
  470.  
  471.                                     Changed = TRUE;
  472.  
  473.                                     if(ChangedPtr)
  474.                                         *ChangedPtr = TRUE;
  475.                                 }
  476.                                 else
  477.                                     DisplayBeep(LocalWindow->WScreen);
  478.  
  479.                                 break;
  480.  
  481.                             case GAD_CLEAR:
  482.  
  483.                                 LT_SetAttributes(Handle,GAD_LIST,
  484.                                     GTLV_Labels,    ~0,
  485.                                 TAG_DONE);
  486.  
  487.                                 ClearGenericList(TrapList,FALSE);
  488.  
  489.                                 LT_SetAttributes(Handle,GAD_LIST,
  490.                                     GTLV_Labels,    TrapList,
  491.                                     LALV_Selected,    ~0,
  492.                                 TAG_DONE);
  493.  
  494.                                 Selected = NULL;
  495.                                 Offset = -1;
  496.  
  497.                                 ChangeLocalState(Handle,TrapList,Selected);
  498.  
  499.                                 Changed = TRUE;
  500.  
  501.                                 if(ChangedPtr)
  502.                                     *ChangedPtr = FALSE;
  503.  
  504.                                 break;
  505.  
  506.                             case GAD_REMOVE:
  507.  
  508.                                 if(Selected)
  509.                                 {
  510.                                     LT_SetAttributes(Handle,GAD_LIST,
  511.                                         GTLV_Labels,    ~0,
  512.                                     TAG_DONE);
  513.  
  514.                                     Node = (struct TrapNode *)DeleteGenericListNode(TrapList,(struct Node *)Selected,FALSE);
  515.  
  516.                                     LT_SetAttributes(Handle,GAD_LIST,
  517.                                         GTLV_Labels,    TrapList,
  518.                                         LALV_Selected,    Offset = GetNodeOffset((struct Node *)Node,(struct List *)TrapList),
  519.                                     TAG_DONE);
  520.  
  521.                                     Selected = Node;
  522.  
  523.                                     if(Selected)
  524.                                     {
  525.                                         LT_SetAttributes(Handle,GAD_COMMAND,
  526.                                             GTST_String,    Selected->Command,
  527.                                         TAG_DONE);
  528.  
  529.                                         LT_SetAttributes(Handle,GAD_SEQUENCE,
  530.                                             GTST_String,    Selected->Node.ln_Name,
  531.                                         TAG_DONE);
  532.                                     }
  533.  
  534.                                     ChangeLocalState(Handle,TrapList,Selected);
  535.  
  536.                                     Changed = TRUE;
  537.  
  538.                                     if(ChangedPtr)
  539.                                         *ChangedPtr = TRUE;
  540.                                 }
  541.  
  542.                                 break;
  543.  
  544.                             case GAD_LIST:
  545.  
  546.                                 if(Selected)
  547.                                 {
  548.                                     strcpy(Selected->Command,LT_GetString(Handle,GAD_COMMAND));
  549.                                     strcpy(Selected->Node.ln_Name,LT_GetString(Handle,GAD_SEQUENCE));
  550.                                 }
  551.  
  552.                                 if(Selected = (struct TrapNode *)GetListNode(MsgCode,(struct List *)TrapList))
  553.                                 {
  554.                                     Offset = MsgCode;
  555.  
  556.                                     LT_SetAttributes(Handle,GAD_SEQUENCE,
  557.                                         GTST_String,    Selected->Node.ln_Name,
  558.                                     TAG_DONE);
  559.  
  560.                                     LT_SetAttributes(Handle,GAD_COMMAND,
  561.                                         GTST_String,    Selected->Command,
  562.                                     TAG_DONE);
  563.  
  564.                                     ChangeLocalState(Handle,TrapList,Selected);
  565.                                 }
  566.  
  567.                                 break;
  568.  
  569.                             case GAD_SEQUENCE:
  570.  
  571.                                 if(Selected)
  572.                                 {
  573.                                     LT_SetAttributes(Handle,GAD_LIST,
  574.                                         GTLV_Labels,    ~0,
  575.                                     TAG_DONE);
  576.  
  577.                                     Selected = ChangeTrapNode(TrapList,Selected,LT_GetString(Handle,GAD_SEQUENCE),NULL);
  578.  
  579.                                     LT_SetAttributes(Handle,GAD_LIST,
  580.                                         GTLV_Labels,    TrapList,
  581.                                         LALV_Selected,    Offset = GetNodeOffset((struct Node *)Selected,(struct List *)TrapList),
  582.                                     TAG_DONE);
  583.  
  584.                                     LT_SetAttributes(Handle,GAD_COMMAND,
  585.                                         GTST_String,    Selected->Command,
  586.                                     TAG_DONE);
  587.  
  588.                                     LT_SetAttributes(Handle,GAD_SEQUENCE,
  589.                                         GTST_String,    Selected->Node.ln_Name,
  590.                                     TAG_DONE);
  591.  
  592.                                     Changed = TRUE;
  593.  
  594.                                     if(ChangedPtr)
  595.                                         *ChangedPtr = TRUE;
  596.  
  597.                                     LT_Activate(Handle,GAD_COMMAND);
  598.                                 }
  599.  
  600.                                 break;
  601.  
  602.                             case GAD_COMMAND:
  603.  
  604.                                 if(Selected)
  605.                                 {
  606.                                     Selected = ChangeTrapNode(TrapList,Selected,NULL,LT_GetString(Handle,GAD_COMMAND));
  607.  
  608.                                     TrapsChanged = TRUE;
  609.  
  610.                                     if(ChangedPtr)
  611.                                         *ChangedPtr = TRUE;
  612.                                 }
  613.  
  614.                                 break;
  615.  
  616.                             case GAD_LOAD:
  617.  
  618.                                 LT_LockWindow(LocalWindow);
  619.  
  620.                                 strcpy(DummyBuffer,LastTraps);
  621.  
  622.                                 if(FileRequest = OpenSingleFile(LocalWindow,LocaleString(MSG_TRAPPANEL_LOAD_TRAP_SETTINGS_TXT),NULL,"#?.prefs",DummyBuffer,sizeof(DummyBuffer)))
  623.                                 {
  624.                                     FreeAslRequest(FileRequest);
  625.  
  626.                                     LT_SetAttributes(Handle,GAD_LIST,
  627.                                         GTLV_Labels,    ~0,
  628.                                     TAG_DONE);
  629.  
  630.                                     Selected = NULL;
  631.                                     Offset = -1;
  632.  
  633.                                     if(!LoadTraps(DummyBuffer,TrapList))
  634.                                         ShowError(LocalWindow,ERR_LOAD_ERROR,IoErr(),DummyBuffer);
  635.                                     else
  636.                                     {
  637.                                         strcpy(LastTraps,DummyBuffer);
  638.  
  639.                                         if(LocalConfig)
  640.                                             strcpy(LocalConfig->TrapFileName,LastTraps);
  641.  
  642.                                         Changed = TRUE;
  643.  
  644.                                         if(ChangedPtr)
  645.                                             *ChangedPtr = FALSE;
  646.                                     }
  647.  
  648.                                     LT_SetAttributes(Handle,GAD_LIST,
  649.                                         GTLV_Labels,    TrapList,
  650.                                         LALV_Selected,    ~0,
  651.                                     TAG_DONE);
  652.  
  653.                                     ChangeLocalState(Handle,TrapList,Selected);
  654.                                 }
  655.  
  656.                                 LT_UnlockWindow(LocalWindow);
  657.  
  658.                                 break;
  659.  
  660.                             case GAD_SAVE:
  661.  
  662.                                 if(Selected)
  663.                                 {
  664.                                     strcpy(Selected->Command,        LT_GetString(Handle,GAD_COMMAND));
  665.                                     strcpy(Selected->Node.ln_Name,    LT_GetString(Handle,GAD_SEQUENCE));
  666.                                 }
  667.  
  668.                                 LT_LockWindow(LocalWindow);
  669.  
  670.                                 strcpy(DummyBuffer,LastTraps);
  671.  
  672.                                 if(FileRequest = SaveFile(LocalWindow,LocaleString(MSG_TRAPPANEL_SAVE_TRAP_SETTINGS_TXT),NULL,"#?.prefs",DummyBuffer,sizeof(DummyBuffer)))
  673.                                 {
  674.                                     FreeAslRequest(FileRequest);
  675.  
  676.                                     if(!SaveTraps(DummyBuffer,(struct List *)TrapList))
  677.                                         ShowError(LocalWindow,ERR_SAVE_ERROR,IoErr(),DummyBuffer);
  678.                                     else
  679.                                     {
  680.                                         strcpy(LastTraps,DummyBuffer);
  681.  
  682.                                         if(LocalConfig)
  683.                                             strcpy(LocalConfig->TrapFileName,LastTraps);
  684.  
  685.                                         Changed = TRUE;
  686.  
  687.                                         if(ChangedPtr)
  688.                                             *ChangedPtr = FALSE;
  689.                                     }
  690.                                 }
  691.  
  692.                                 LT_UnlockWindow(LocalWindow);
  693.  
  694.                                 break;
  695.  
  696.                             case GAD_DISCARD:
  697.  
  698.                                 LT_SetAttributes(Handle,GAD_LIST,
  699.                                     GTLV_Labels,    ~0,
  700.                                 TAG_DONE);
  701.  
  702.                                 ClearGenericList(TrapList,FALSE);
  703.  
  704.                                 Done = Changed = TRUE;
  705.  
  706.                                 if(ChangedPtr)
  707.                                     *ChangedPtr = FALSE;
  708.  
  709.                                 LastTraps[0] = 0;
  710.  
  711.                                 if(LocalConfig)
  712.                                     strcpy(LocalConfig->TrapFileName,LastTraps);
  713.  
  714.                                 WatchTraps = FALSE;
  715.  
  716.                                 break;
  717.                         }
  718.                     }
  719.                 }
  720.             }
  721.             while(!Done);
  722.  
  723.             PopWindow();
  724.         }
  725.  
  726.         LT_DeleteHandle(Handle);
  727.     }
  728.  
  729.     for(Node = (struct TrapNode *)TrapList->ListHeader.mlh_Head ; Next = (struct TrapNode *)Node->Node.ln_Succ ; Node = Next)
  730.     {
  731.         if(!Node->Node.ln_Name[0] || !Node->SequenceLen)
  732.             DeleteGenericListNode(TrapList,(struct Node *)Node,FALSE);
  733.     }
  734.  
  735.     UnlockGenericList(TrapList);
  736.  
  737.     return(Changed);
  738. }
  739.