home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / amiga / comms / comprgs / t22bd2.lha / Quelltext / termSource / GadgetSupport.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-05-16  |  15.8 KB  |  763 lines
  1. /*
  2. **    $Id: GadgetSupport.c,v 1.3 92/05/15 22:24:44 olsen Sta Locker: olsen $
  3. **    $Revision: 1.3 $
  4. **    $Date: 92/05/15 22:24:44 $
  5. **
  6. **    GadTools object management support routines
  7. **
  8. **    Copyright ⌐ 1990-1992 by Olaf `Olsen' Barthel & MXM
  9. **        All Rights Reserved
  10. */
  11.  
  12.     /* Some includes for starters. */
  13.  
  14. #include <intuition/intuition.h>
  15. #include <libraries/gadtools.h>
  16. #include <utility/tagitem.h>
  17. #include <exec/memory.h>
  18.  
  19. #include <clib/intuition_protos.h>
  20. #include <clib/exec_protos.h>
  21.  
  22. #include <stdarg.h>
  23.  
  24.     /* External data. */
  25.  
  26. extern struct Library    *GadToolsBase;
  27. extern struct Gadget    *ActiveGadget;
  28.  
  29.     /* This structure will help us to remember the current state of
  30.      * a GadTools object.
  31.      */
  32.  
  33. struct GadgetSupportInfo
  34. {
  35.     struct GadgetSupportInfo    *PointBack;    /* Points back to itself. */
  36.     struct Gadget            *Gadget;    /* Points back to the host. */
  37.  
  38.     WORD                 Kind;        /* Item type (BUTTON_KIND, STRING_KIND, etc.) */
  39.     UBYTE                 Key;        /* The key to press. */
  40.     BYTE                 ReadOnly;    /* LISTVIEW_KIND only: is this a read-only object? */
  41.     LONG                 Current,    /* Current state or counter. */
  42.                      Min,        /* Minimum value for `Current'. */
  43.                      Max;        /* Maximum value for `Current'. */
  44. };
  45.  
  46.     /* Local routines. */
  47.  
  48. struct Gadget *    CreateGadget(ULONG Kind,struct Gadget *Previous,struct NewGadget *New,...);
  49. VOID        FreeGadgets(struct Gadget *GadgetList);
  50. VOID        GT_SetGadgetAttrs(struct Gadget *Gadget,struct Window *Window,struct Requester *Requester,...);
  51. VOID        GT_ReplyIMsg(struct IntuiMessage *Message);
  52.  
  53. VOID        KeySelect(struct Gadget **GadgetList,WORD Last,UBYTE Key,struct Window *Window,struct Gadget **Gadget,ULONG *Class,LONG *Code);
  54.  
  55.     /* The original gadtools.library routines. */
  56.  
  57. struct Gadget *    OldCreateGadgetA(ULONG,struct Gadget *,struct NewGadget *,struct TagItem *);
  58. VOID        OldFreeGadget(struct Gadget *);
  59. VOID        OldGT_SetGadgetAttrsA(struct Gadget *,struct Window *,struct Requester *,struct TagItem *);
  60. VOID        OldGT_ReplyIMsg(struct IntuiMessage *);
  61.  
  62.     /* Pragma calls: the easy way. */
  63.  
  64. #pragma libcall GadToolsBase OldCreateGadgetA 1E A98004
  65. #pragma libcall GadToolsBase OldFreeGadgets 24 801
  66. #pragma libcall GadToolsBase OldGT_SetGadgetAttrsA 2A BA9804
  67. #pragma libcall GadToolsBase OldGT_ReplyIMsg 4E 901
  68.  
  69.     /* CreateGadget():
  70.      *
  71.      *    A frontend to the original routine.
  72.      */
  73.  
  74. struct Gadget *
  75. CreateGadget(ULONG Kind,struct Gadget *Previous,struct NewGadget *New,...)
  76. {
  77.     va_list                 VarArgs;
  78.     struct TagItem            *TagList;
  79.     struct GadgetSupportInfo    *Info = NULL;
  80.     WORD                 i;
  81.     UBYTE                 Underscore = 0;
  82.     struct Gadget            *Result;
  83.  
  84.     va_start(VarArgs,New);
  85.  
  86.     TagList = (struct TagItem *)VarArgs;
  87.  
  88.     switch(Kind)
  89.     {
  90.         case STRING_KIND:
  91.         case INTEGER_KIND:
  92.         case BUTTON_KIND:
  93.         case CHECKBOX_KIND:
  94.         case CYCLE_KIND:
  95.         case LISTVIEW_KIND:
  96.         case MX_KIND:
  97.         case PALETTE_KIND:
  98.         case SCROLLER_KIND:
  99.         case SLIDER_KIND:
  100.  
  101.             for(i = 0 ; TagList[i] . ti_Tag != TAG_DONE ; i++)
  102.             {
  103.                 if(TagList[i] . ti_Tag == GT_Underscore)
  104.                 {
  105.                     Underscore = TagList[i] . ti_Data;
  106.  
  107.                     break;
  108.                 }
  109.             }
  110.  
  111.             if(Underscore)
  112.             {
  113.                 if(New -> ng_GadgetText)
  114.                 {
  115.                     for(i = 0 ; i < strlen(New -> ng_GadgetText) ; i++)
  116.                     {
  117.                         if(New -> ng_GadgetText[i] == Underscore)
  118.                         {
  119.                             if(New -> ng_GadgetText[i + 1] > 32)
  120.                             {
  121.                                 if(Info = (struct GadgetSupportInfo *)AllocMem(sizeof(struct GadgetSupportInfo),MEMF_ANY | MEMF_CLEAR))
  122.                                 {
  123.                                     Info -> PointBack    = Info;
  124.                                     Info -> Kind        = Kind;
  125.                                     Info -> Key        = New -> ng_GadgetText[i + 1];
  126.  
  127.                                     if(Info -> Kind == PALETTE_KIND)
  128.                                     {
  129.                                         Info -> Current    = 1;
  130.                                         Info -> Max    = 1;
  131.                                     }
  132.  
  133.                                     if(Info -> Kind == LISTVIEW_KIND)
  134.                                         Info -> Current    = ~0;
  135.  
  136.                                     break;
  137.                                 }
  138.                             }
  139.                         }
  140.                     }
  141.                 }
  142.             }
  143.  
  144.             break;
  145.  
  146.         default:
  147.  
  148.             break;
  149.     }
  150.  
  151.     New -> ng_UserData = Info;
  152.  
  153.     if(Info)
  154.     {
  155.         struct Node    *Node;
  156.         struct List    *List;
  157.         LONG         Count;
  158.         STRPTR        *Strings;
  159.         BYTE         ShowSelected = FALSE;
  160.  
  161.         for(i = 0 ; TagList[i] . ti_Tag != TAG_DONE ; i++)
  162.         {
  163.             switch(TagList[i] . ti_Tag)
  164.             {
  165.                 case GTCB_Checked:
  166.                 case GTCY_Active:
  167.                 case GTLV_Selected:
  168.                 case GTMX_Active:
  169.                 case GTSC_Top:
  170.                 case GTSL_Level:
  171.                 case GTPA_Color:
  172.  
  173.                     Info -> Current = TagList[i] . ti_Data;
  174.                     break;
  175.  
  176.                 case GTSL_Min:
  177.  
  178.                     Info -> Min = TagList[i] . ti_Data;
  179.                     break;
  180.  
  181.                 case GTSC_Total:
  182.                 case GTSL_Max:
  183.  
  184.                     Info -> Max = TagList[i] . ti_Data;
  185.                     break;
  186.  
  187.                 case GTPA_Depth:
  188.  
  189.                     Info -> Max = (1 << ((LONG)TagList[i] . ti_Data)) - 1;
  190.                     break;
  191.  
  192.                 case GTLV_ReadOnly:
  193.  
  194.                     if(!ShowSelected)
  195.                         Info -> ReadOnly = TRUE;
  196.  
  197.                     break;
  198.  
  199.                 case GTLV_ShowSelected:
  200.  
  201.                     ShowSelected = TRUE;
  202.  
  203.                     Info -> ReadOnly = FALSE;
  204.  
  205.                     break;
  206.  
  207.                 case GTCY_Labels:
  208.                 case GTMX_Labels:
  209.  
  210.                     Count = 0;
  211.  
  212.                     if(Strings = (STRPTR *)TagList[i] . ti_Data)
  213.                     {
  214.                         while(Strings[Count])
  215.                             Count++;
  216.                     }
  217.  
  218.                     if(Count)
  219.                         Info -> Max = Count - 1;
  220.  
  221.                     break;
  222.  
  223.                 case GTLV_Labels:
  224.  
  225.                     Count = 0;
  226.  
  227.                     if(TagList[i] . ti_Data != NULL && TagList[i] . ti_Data != ~0)
  228.                     {
  229.                         List = (struct List *)TagList[i] . ti_Data;
  230.  
  231.                         Node = List -> lh_Head;
  232.  
  233.                         while(Node -> ln_Succ)
  234.                         {
  235.                             Count++;
  236.  
  237.                             Node = Node -> ln_Succ;
  238.                         }
  239.                     }
  240.  
  241.                     if(Count)
  242.                         Info -> Max = Count - 1;
  243.  
  244.                     break;
  245.  
  246.                 default:
  247.  
  248.                     break;
  249.             }
  250.         }
  251.  
  252.         if(Result = OldCreateGadgetA(Kind,Previous,New,TagList))
  253.             Info -> Gadget = Result;
  254.         else
  255.             FreeMem(Info,sizeof(struct GadgetSupportInfo));
  256.     }
  257.     else
  258.         Result = OldCreateGadgetA(Kind,Previous,New,TagList);
  259.  
  260.     va_end(VarArgs);
  261.  
  262.     return(Result);
  263. }
  264.  
  265.     /* GT_SetGadgetAttrs():
  266.      *
  267.      *    A frontend to the original routine.
  268.      */
  269.  
  270. VOID
  271. GT_SetGadgetAttrs(struct Gadget *Gadget,struct Window *Window,struct Requester *Requester,...)
  272. {
  273.     va_list                 VarArgs;
  274.     struct TagItem            *TagList;
  275.     struct GadgetSupportInfo    *Info;
  276.  
  277.     va_start(VarArgs,Requester);
  278.  
  279.     TagList = (struct TagItem *)VarArgs;
  280.  
  281.     if(Info = (struct GadgetSupportInfo *)Gadget -> UserData)
  282.     {
  283.         if(Info -> PointBack == Info)
  284.         {
  285.             struct Node    *Node;
  286.             struct List    *List;
  287.             LONG         Count;
  288.             STRPTR        *Strings;
  289.             WORD         i;
  290.  
  291.             for(i = 0 ; TagList[i] . ti_Tag != TAG_DONE ; i++)
  292.             {
  293.                 switch(TagList[i] . ti_Tag)
  294.                 {
  295.                     case GTCB_Checked:
  296.                     case GTCY_Active:
  297.                     case GTLV_Selected:
  298.                     case GTMX_Active:
  299.                     case GTSC_Top:
  300.                     case GTSL_Level:
  301.                     case GTPA_Color:
  302.  
  303.                         Info -> Current = TagList[i] . ti_Data;
  304.                         break;
  305.  
  306.                     case GTSL_Min:
  307.  
  308.                         Info -> Min = TagList[i] . ti_Data;
  309.                         break;
  310.  
  311.                     case GTSC_Total:
  312.                     case GTSL_Max:
  313.  
  314.                         Info -> Max = TagList[i] . ti_Data;
  315.                         break;
  316.  
  317.                     case GTCY_Labels:
  318.  
  319.                         Count = 0;
  320.  
  321.                         if(Strings = (STRPTR *)TagList[i] . ti_Data)
  322.                         {
  323.                             while(Strings[Count])
  324.                                 Count++;
  325.                         }
  326.  
  327.                         if(Count)
  328.                             Info -> Max = Count - 1;
  329.  
  330.                         break;
  331.  
  332.                     case GTLV_Labels:
  333.  
  334.                         Count = 0;
  335.  
  336.                         if(TagList[i] . ti_Data != NULL && TagList[i] . ti_Data != ~0)
  337.                         {
  338.                             List = (struct List *)TagList[i] . ti_Data;
  339.  
  340.                             Node = List -> lh_Head;
  341.  
  342.                             while(Node -> ln_Succ)
  343.                             {
  344.                                 Count++;
  345.  
  346.                                 Node = Node -> ln_Succ;
  347.                             }
  348.                         }
  349.  
  350.                         if(Count)
  351.                             Info -> Max = Count - 1;
  352.  
  353.                         break;
  354.  
  355.                     default:
  356.  
  357.                         break;
  358.                 }
  359.             }
  360.         }
  361.     }
  362.  
  363.     OldGT_SetGadgetAttrsA(Gadget,Window,Requester,TagList);
  364.  
  365.     va_end(VarArgs);
  366. }
  367.  
  368.     /* FreeGadgets(struct Gadget *GadgetList):
  369.      *
  370.      *    A frontend to the original routine.
  371.      */
  372.  
  373. VOID
  374. FreeGadgets(struct Gadget *GadgetList)
  375. {
  376.     struct Gadget            *Gadget = GadgetList;
  377.     struct GadgetSupportInfo    *Info;
  378.  
  379.     while(Gadget)
  380.     {
  381.         if(Info = (struct GadgetSupportInfo *)Gadget -> UserData)
  382.         {
  383.             if(Info -> PointBack == Info && Info -> Gadget == Gadget)
  384.                 FreeMem(Info,sizeof(struct GadgetSupportInfo));
  385.         }
  386.  
  387.         Gadget = Gadget -> NextGadget;
  388.     }
  389.  
  390.     OldFreeGadgets(GadgetList);
  391. }
  392.  
  393.     /* GT_ReplyIMsg(struct IntuiMessage *Message):
  394.      *
  395.      *    A frontend to the original routine.
  396.      */
  397.  
  398. VOID
  399. GT_ReplyIMsg(struct IntuiMessage *Message)
  400. {
  401.     if(Message)
  402.     {
  403.         if(Message -> Class == IDCMP_GADGETUP || Message -> Class == IDCMP_GADGETDOWN || Message -> Class == IDCMP_MOUSEMOVE)
  404.         {
  405.             struct Gadget *Gadget;
  406.  
  407.             if(Gadget = (struct Gadget *)Message -> IAddress)
  408.             {
  409.                 struct GadgetSupportInfo *Info = Gadget -> UserData;
  410.  
  411.                 if(Info)
  412.                 {
  413.                     if(Info -> PointBack == Info)
  414.                     {
  415.                         LONG Value = (WORD)Message -> Code;
  416.  
  417.                         switch(Info -> Kind)
  418.                         {
  419.                             case CHECKBOX_KIND:
  420.  
  421.                                 if(Gadget -> Flags & GFLG_SELECTED)
  422.                                     Info -> Current = TRUE;
  423.                                 else
  424.                                     Info -> Current = FALSE;
  425.  
  426.                                 break;
  427.  
  428.                             case CYCLE_KIND:
  429.  
  430.                                 Info -> Current = Message -> Code;
  431.  
  432.                                 break;
  433.  
  434.                             case LISTVIEW_KIND:
  435.  
  436.                                 Info -> Current = Message -> Code;
  437.  
  438.                                 break;
  439.  
  440.                             case MX_KIND:
  441.  
  442.                                 Info -> Current = Message -> Code;
  443.  
  444.                                 break;
  445.  
  446.                             case SCROLLER_KIND:
  447.  
  448.                                 Info -> Current = Message -> Code;
  449.  
  450.                                 break;
  451.  
  452.                             case SLIDER_KIND:
  453.  
  454.                                 if(Info -> Min >= 0 && Value < 0)
  455.                                     Info -> Current = Message -> Code;
  456.                                 else
  457.                                     Info -> Current = Value;
  458.  
  459.                                 break;
  460.  
  461.                             case PALETTE_KIND:
  462.  
  463.                                 Info -> Current = Message -> Code;
  464.  
  465.                                 break;
  466.  
  467.                             default:
  468.  
  469.                                 break;
  470.                         }
  471.                     }
  472.                 }
  473.             }
  474.         }
  475.     }
  476.  
  477.     OldGT_ReplyIMsg(Message);
  478. }
  479.  
  480.     /* KeySelect():
  481.      *
  482.      *    Handles gadget keystroke activation.
  483.      */
  484.  
  485. VOID
  486. KeySelect(struct Gadget **GadgetList,WORD Last,UBYTE Key,struct Window *Window,struct Gadget **Gadget,ULONG *Class,LONG *Code)
  487. {
  488.     if(Key == '\033' && (Window -> Flags & WFLG_CLOSEGADGET))
  489.         *Class = IDCMP_CLOSEWINDOW;
  490.     else
  491.     {
  492.         struct GadgetSupportInfo    *Info;
  493.         WORD                 i;
  494.         BYTE                 Forward,
  495.                          GotIt = FALSE;
  496.  
  497.         for(i = 0 ; !GotIt && i <= Last ; i++)
  498.         {
  499.             if(!(GadgetList[i] -> Flags & GFLG_DISABLED))
  500.             {
  501.                 if(Info = GadgetList[i] -> UserData)
  502.                 {
  503.                     if(Info -> PointBack == Info)
  504.                     {
  505.                         if(ToUpper(Info -> Key) == ToUpper(Key))
  506.                         {
  507.                             if(ToUpper(Info -> Key) == Key)
  508.                                 Forward = FALSE;
  509.                             else
  510.                                 Forward = TRUE;
  511.  
  512.                             switch(Info -> Kind)
  513.                             {
  514.                                 case STRING_KIND:
  515.                                 case INTEGER_KIND:    ActivateGadget(ActiveGadget = GadgetList[i],Window,NULL);
  516.  
  517.                                             *Class    = IDCMP_GADGETDOWN;
  518.                                             *Code    = 0;
  519.                                             *Gadget    = GadgetList[i];
  520.  
  521.                                             GotIt = TRUE;
  522.  
  523.                                             break;
  524.  
  525.                                 case BUTTON_KIND:    *Class    = IDCMP_GADGETUP;
  526.                                             *Code    = 0;
  527.                                             *Gadget    = GadgetList[i];
  528.  
  529.                                             GotIt = TRUE;
  530.  
  531.                                             break;
  532.  
  533.                                 case CHECKBOX_KIND:    GT_SetGadgetAttrs(GadgetList[i],Window,NULL,
  534.                                                 GTCB_Checked,    Info -> Current ? FALSE : TRUE,
  535.                                             TAG_DONE);
  536.  
  537.                                             *Class    = IDCMP_GADGETUP;
  538.                                             *Code    = Info -> Current;
  539.                                             *Gadget    = GadgetList[i];
  540.  
  541.                                             GotIt = TRUE;
  542.  
  543.                                             break;
  544.  
  545.                                 case CYCLE_KIND:    if(Forward)
  546.                                             {
  547.                                                 GT_SetGadgetAttrs(GadgetList[i],Window,NULL,
  548.                                                     GTCY_Active,    (Info -> Current == Info -> Max) ? 0 : Info -> Current + 1,
  549.                                                 TAG_DONE);
  550.                                             }
  551.                                             else
  552.                                             {
  553.                                                 GT_SetGadgetAttrs(GadgetList[i],Window,NULL,
  554.                                                     GTCY_Active,    Info -> Current ? Info -> Current - 1 : Info -> Max,
  555.                                                 TAG_DONE);
  556.                                             }
  557.  
  558.                                             *Class    = IDCMP_GADGETUP;
  559.                                             *Code    = Info -> Current;
  560.                                             *Gadget    = GadgetList[i];
  561.  
  562.                                             GotIt = TRUE;
  563.  
  564.                                             break;
  565.  
  566.                                 case LISTVIEW_KIND:    if(Forward)
  567.                                             {
  568.                                                 if(Info -> Current == ~0)
  569.                                                     Info -> Current = -1;
  570.  
  571.                                                 if(Info -> Current < Info -> Max)
  572.                                                 {
  573.                                                     if(Info -> ReadOnly)
  574.                                                     {
  575.                                                         GT_SetGadgetAttrs(GadgetList[i],Window,NULL,
  576.                                                             GTLV_Top,    Info -> Current + 1,
  577.                                                         TAG_DONE);
  578.                                                     }
  579.                                                     else
  580.                                                     {
  581.                                                         GT_SetGadgetAttrs(GadgetList[i],Window,NULL,
  582.                                                             GTLV_Selected,    Info -> Current + 1,
  583.                                                             GTLV_Top,    Info -> Current + 1,
  584.                                                         TAG_DONE);
  585.                                                     }
  586.  
  587.                                                     *Class    = IDCMP_GADGETUP;
  588.                                                     *Code    = Info -> Current;
  589.                                                     *Gadget    = GadgetList[i];
  590.                                                 }
  591.                                             }
  592.                                             else
  593.                                             {
  594.                                                 if(Info -> Current == ~0)
  595.                                                     Info -> Current = Info -> Max + 1;
  596.  
  597.                                                 if(Info -> Current > Info -> Min)
  598.                                                 {
  599.                                                     if(Info -> ReadOnly)
  600.                                                     {
  601.                                                         GT_SetGadgetAttrs(GadgetList[i],Window,NULL,
  602.                                                             GTLV_Top,    Info -> Current - 1,
  603.                                                         TAG_DONE);
  604.                                                     }
  605.                                                     else
  606.                                                     {
  607.                                                         GT_SetGadgetAttrs(GadgetList[i],Window,NULL,
  608.                                                             GTLV_Selected,    Info -> Current - 1,
  609.                                                             GTLV_Top,    Info -> Current - 1,
  610.                                                         TAG_DONE);
  611.                                                     }
  612.  
  613.                                                     *Class    = IDCMP_GADGETUP;
  614.                                                     *Code    = Info -> Current;
  615.                                                     *Gadget    = GadgetList[i];
  616.                                                 }
  617.                                             }
  618.  
  619.                                             GotIt = TRUE;
  620.  
  621.                                             break;
  622.  
  623.                                 case MX_KIND:        if(Forward)
  624.                                             {
  625.                                                 if(Info -> Current < Info -> Max)
  626.                                                 {
  627.                                                     GT_SetGadgetAttrs(GadgetList[i],Window,NULL,
  628.                                                         GTMX_Active,    *Code = Info -> Current + 1,
  629.                                                     TAG_DONE);
  630.  
  631.                                                     *Class    = IDCMP_GADGETUP;
  632.                                                     *Code    = Info -> Current;
  633.                                                     *Gadget    = GadgetList[i];
  634.                                                 }
  635.                                             }
  636.                                             else
  637.                                             {
  638.                                                 if(Info -> Current > Info -> Min)
  639.                                                 {
  640.                                                     GT_SetGadgetAttrs(GadgetList[i],Window,NULL,
  641.                                                         GTMX_Active,    *Code = Info -> Current - 1,
  642.                                                     TAG_DONE);
  643.  
  644.                                                     *Class    = IDCMP_GADGETUP;
  645.                                                     *Code    = Info -> Current;
  646.                                                     *Gadget    = GadgetList[i];
  647.                                                 }
  648.                                             }
  649.  
  650.                                             GotIt = TRUE;
  651.  
  652.                                             break;
  653.  
  654.                                 case PALETTE_KIND:    if(Forward)
  655.                                             {
  656.                                                 GT_SetGadgetAttrs(GadgetList[i],Window,NULL,
  657.                                                     GTPA_Color,    (Info -> Current == Info -> Max) ? 0 : Info -> Current + 1,
  658.                                                 TAG_DONE);
  659.                                             }
  660.                                             else
  661.                                             {
  662.                                                 GT_SetGadgetAttrs(GadgetList[i],Window,NULL,
  663.                                                     GTPA_Color,    Info -> Current ? Info -> Current - 1 : Info -> Max,
  664.                                                 TAG_DONE);
  665.                                             }
  666.  
  667.                                             *Class    = IDCMP_GADGETUP;
  668.                                             *Code    = Info -> Current;
  669.                                             *Gadget    = GadgetList[i];
  670.  
  671.                                             GotIt = TRUE;
  672.  
  673.                                             break;
  674.  
  675.                                 case SCROLLER_KIND:    if(Forward)
  676.                                             {
  677.                                                 if(Info -> Current < Info -> Max)
  678.                                                 {
  679.                                                     GT_SetGadgetAttrs(GadgetList[i],Window,NULL,
  680.                                                         GTSC_Top,    Info -> Current + 1,
  681.                                                     TAG_DONE);
  682.  
  683.                                                     *Class    = IDCMP_MOUSEMOVE;
  684.                                                     *Code    = Info -> Current;
  685.                                                     *Gadget    = GadgetList[i];
  686.                                                 }
  687.                                             }
  688.                                             else
  689.                                             {
  690.                                                 if(Info -> Current > Info -> Min)
  691.                                                 {
  692.                                                     GT_SetGadgetAttrs(GadgetList[i],Window,NULL,
  693.                                                         GTSC_Top,    Info -> Current - 1,
  694.                                                     TAG_DONE);
  695.  
  696.                                                     *Class    = IDCMP_MOUSEMOVE;
  697.                                                     *Code    = Info -> Current;
  698.                                                     *Gadget    = GadgetList[i];
  699.                                                 }
  700.                                             }
  701.  
  702.                                             GotIt = TRUE;
  703.  
  704.                                             break;
  705.  
  706.                                 case SLIDER_KIND:    if(Forward)
  707.                                             {
  708.                                                 if(Info -> Current < Info -> Max)
  709.                                                 {
  710.                                                     GT_SetGadgetAttrs(GadgetList[i],Window,NULL,
  711.                                                         GTSL_Level,    Info -> Current + 1,
  712.                                                     TAG_DONE);
  713.  
  714.                                                     *Class    = IDCMP_MOUSEMOVE;
  715.                                                     *Code    = Info -> Current;
  716.                                                     *Gadget    = GadgetList[i];
  717.                                                 }
  718.                                             }
  719.                                             else
  720.                                             {
  721.                                                 if(Info -> Current > Info -> Min)
  722.                                                 {
  723.                                                     GT_SetGadgetAttrs(GadgetList[i],Window,NULL,
  724.                                                         GTSL_Level,    Info -> Current - 1,
  725.                                                     TAG_DONE);
  726.  
  727.                                                     *Class    = IDCMP_MOUSEMOVE;
  728.                                                     *Code    = Info -> Current;
  729.                                                     *Gadget    = GadgetList[i];
  730.                                                 }
  731.                                             }
  732.  
  733.                                             GotIt = TRUE;
  734.  
  735.                                             break;
  736.  
  737.                                 default:        break;
  738.                             }
  739.                         }
  740.                     }
  741.                 }
  742.             }
  743.         }
  744.  
  745.         if(!GotIt)
  746.         {
  747.             for(i = 0 ; i <= Last ; i++)
  748.             {
  749.                 if(!(GadgetList[i] -> Flags & GFLG_DISABLED) && (GadgetList[i] -> GadgetType & GTYP_GTYPEMASK) == GTYP_STRGADGET)
  750.                 {
  751.                     ActivateGadget(ActiveGadget = GadgetList[i],Window,NULL);
  752.  
  753.                     *Class    = IDCMP_GADGETDOWN;
  754.                     *Code    = 0;
  755.                     *Gadget    = GadgetList[i];
  756.  
  757.                     break;
  758.                 }
  759.             }
  760.         }
  761.     }
  762. }
  763.