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