home *** CD-ROM | disk | FTP | other *** search
/ Amiga Times / AmigaTimes.iso / internet / Term / Extras / Source / gtlayout-source.lha / LT_HandleInput.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-10-10  |  43.0 KB  |  2,023 lines
  1. /*
  2. **    GadTools layout toolkit
  3. **
  4. **    Copyright © 1993-1996 by Olaf `Olsen' Barthel
  5. **        Freely distributable.
  6. **
  7. **    :ts=4
  8. */
  9.  
  10. #ifndef _GTLAYOUT_GLOBAL_H
  11. #include "gtlayout_global.h"
  12. #endif
  13.  
  14. STATIC LONG
  15. CurrentWrap(ObjectNode *Node,LONG Current)
  16. {
  17.     if(Current > Node->Max)
  18.         Current = Node->Min;
  19.     else
  20.     {
  21.         if(Current < Node->Min)
  22.             Current = Node->Max;
  23.     }
  24.  
  25.     return(Current);
  26. }
  27.  
  28. STATIC BOOL
  29. CurrentInBounds(ObjectNode *Node,LONG Current)
  30. {
  31.     return((BOOL)(Node->Min <= Current && Current <= Node->Max && Current != Node->Current));
  32. }
  33.  
  34. /****** gtlayout.library/LT_HandleInput ******************************************
  35. *
  36. *   NAME
  37. *    LT_HandleInput -- Filter IntuiMessage data.
  38. *
  39. *   SYNOPSIS
  40. *    LT_HandleInput(Handle,Qualifier,Class,Code,Gadget);
  41. *                     A0      D0      A1    A2    A3
  42. *
  43. *    VOID LT_HandleInput(LayoutHandle *,ULONG,ULONG *,
  44. *                        UWORD *,struct Gadget **);
  45. *
  46. *   FUNCTION
  47. *    In order to keep track of user interface actions, such as
  48. *    keys getting pressed, sliders getting moved, etc. your
  49. *    code is to call LT_HandleInput() with data copied from the
  50. *    IntuiMessage it has just received and replied.
  51. *
  52. *   INPUTS
  53. *    Handle - Pointer to a LayoutHandle structure.
  54. *
  55. *    Qualifier - The Qualifier value copied from the
  56. *        IntuiMessage structure.
  57. *
  58. *    Class - Pointer to the ULONG variable which holds the
  59. *        value copied from the Class entry of the
  60. *        IntuiMessage structure.
  61. *
  62. *    Code - Pointer to the UWORD variable which holds the
  63. *        value copied from the Code entry of the
  64. *        IntuiMessage structure.
  65. *
  66. *    Gadget - Pointer to the Gadget value copied from the
  67. *        IAddress entry of the IntuiMessage structure.
  68. *
  69. *   RESULT
  70. *    none
  71. *
  72. *   EXAMPLE
  73. *    struct IntuiMessage *IntuiMessage;
  74. *    ULONG Qualifier,Class;
  75. *    UWORD Code;
  76. *    struct Gadget *Gadget;
  77. *
  78. *    for(;;)
  79. *    {
  80. *        WaitPort(Window->UserPort);
  81. *
  82. *        while(IntuiMessage = GT_GetIMsg(Window->UserPort))
  83. *        {
  84. *            Class = IntuiMessage->Class;
  85. *            Code = IntuiMessage->Code;
  86. *            Qualifier = IntuiMessage->Qualifier;
  87. *            Gadget = IntuiMessage->Gadget;
  88. *
  89. *            GT_ReplyIMsg(IntuiMessage);
  90. *
  91. *            LT_HandleInput(Handle,Qualifier,&Class,&Code,&Gadget);
  92. *        }
  93. *    }
  94. *
  95. *   NOTES
  96. *    For BOOPSI_KIND objects keystroke activation may lead to
  97. *    unexpected results. Your application will hear a IDCMP_GADGETUP
  98. *    event, the IntuiMessage->Code value will hold the ANSI key
  99. *    code of the key the user pressed.
  100. *
  101. *    Do not call this routine before you have actually
  102. *    replied the IntuiMessage received or weird things
  103. *    may happen. This is not a suggestion, it's a threat.
  104. *
  105. ******************************************************************************
  106. *
  107. */
  108.  
  109. VOID LIBENT
  110. LT_HandleInput(REG(a0) LayoutHandle *Handle,REG(d0) ULONG MsgQualifier,REG(a1) ULONG *MsgClass,REG(a2) UWORD *MsgCode,REG(a3) struct Gadget **MsgGadget)
  111. {
  112.     ObjectNode *Node;
  113.     BOOL Activate;
  114.  
  115.     if(!Handle)
  116.         return;
  117.  
  118.     if(Handle->Failed)
  119.     {
  120.         *MsgClass = IDCMP_CLOSEWINDOW;
  121.  
  122.         if(!Handle->NeedDelay)
  123.             Handle->NeedDelay = TRUE;
  124.         else
  125.             LTP_Delay(0,500000);    // Give the guy a break
  126.  
  127.         return;
  128.     }
  129.  
  130.     Activate = FALSE;
  131.  
  132.     switch(*MsgClass)
  133.     {
  134.         case IDCMP_CHANGEWINDOW:
  135.  
  136.             if(!(Handle->Window->Flags & WFLG_SIZEGADGET) && (Handle->Window->Flags & WFLG_HASZOOM) && !V39)
  137.             {
  138. #ifdef DO_BOOPSI_KIND
  139.                 if(Handle->BOOPSIList)
  140.                     RefreshGList((struct Gadget *)Handle->BOOPSIList,Handle->Window,NULL,(UWORD)-1);
  141. #endif    /* DO_BOOPSI_KIND */
  142.  
  143.                 RefreshGList(Handle->List,Handle->Window,NULL,(UWORD)-1);
  144.  
  145.                 GT_RefreshWindow(Handle->Window,NULL);
  146.  
  147.                 LTP_DrawGroup(Handle,Handle->TopGroup);
  148.             }
  149.  
  150.             break;
  151.  
  152.         case IDCMP_NEWSIZE:
  153.  
  154.                 // Did the user cancel the resize operation?
  155.  
  156.             if(Handle->SizeVerified && Handle->SizeWidth == Handle->Window->Width && Handle->SizeHeight == Handle->Window->Height)
  157.             {
  158.                 Handle->SizeVerified    = FALSE;
  159.                 Handle->SizeWidth    = 0;
  160.                 Handle->SizeHeight    = 0;
  161.  
  162.                     // Put the gadgets back in
  163.  
  164.                 AddGList(Handle->Window,Handle->List,(UWORD)-1,(UWORD)-1,NULL);
  165.             }
  166.             else
  167.             {
  168.                 struct IBox Box;
  169.  
  170.                 Handle->SizeWidth    = 0;
  171.                 Handle->SizeHeight    = 0;
  172.  
  173.                 Box.Left    = 0;
  174.                 Box.Top        = 0;
  175.                 Box.Width    = Handle->Window->Width;
  176.                 Box.Height    = Handle->Window->Height;
  177.  
  178.                 LT_LockWindow(Handle->Window);
  179.  
  180.                 if(Handle->ResizeView)
  181.                     Handle->ResizeView->Special.List.IgnoreListContents = TRUE;
  182.  
  183.                 LT_RebuildTags(Handle,TRUE,
  184.                     LAWN_Bounds,    &Box,
  185.                 TAG_DONE);
  186.  
  187.                 LT_UnlockWindow(Handle->Window);
  188.  
  189.                 if(Handle->Failed)
  190.                     *MsgClass = IDCMP_CLOSEWINDOW;
  191.                 else
  192.                     *MsgClass = NULL;
  193.             }
  194.  
  195.             break;
  196.  
  197.         case IDCMP_REFRESHWINDOW:
  198.  
  199.             if(Handle->AutoRefresh)
  200.             {
  201.                 LT_BeginRefresh(Handle);
  202.  
  203.                 LT_EndRefresh(Handle,TRUE);
  204.  
  205.                 *MsgClass = NULL;
  206.             }
  207.  
  208.             break;
  209.  
  210.         case IDCMP_INTUITICKS:
  211.  
  212.             if(Handle->ActiveIncrementer)
  213.             {
  214.                 if(Handle->IncrementerCountdown > 0)
  215.                     Handle->IncrementerCountdown--;
  216.  
  217.                 if(Handle->IncrementerCountdown <= 0)
  218.                 {
  219.                     if(Handle->ActiveIncrementer->Host->Flags & GFLG_SELECTED)
  220.                     {
  221.                         if(Handle->ActiveIncrementer->Type == TAPEDECK_KIND)
  222.                         {
  223.                             *MsgClass    = IDCMP_GADGETUP;
  224.                             *MsgCode    = 0;
  225.                             *MsgGadget    = Handle->ActiveIncrementer->Host;
  226.                         }
  227.                         else
  228.                         {
  229.                             ObjectNode *Parent;
  230.                             LONG Number;
  231.  
  232.                             if(Handle->IncrementerAccelerate > 0 && !(MsgQualifier & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT)))
  233.                                 Handle->IncrementerAccelerate--;
  234.  
  235.                             if(Handle->IncrementerAccelerate <= 0)
  236.                             {
  237.                                 Handle->IncrementerAccelerate = 10;
  238.  
  239.                                 Handle->IncrementerIncrement *= 2;
  240.                             }
  241.  
  242.                             *MsgClass    = IDCMP_GADGETUP;
  243.                             *MsgCode    = 0;
  244.                             *MsgGadget    = Handle->ActiveIncrementer->Special.Incrementer.Parent;
  245.  
  246.                             Parent = (*MsgGadget)->UserData;
  247.  
  248.                             if(Parent->Special.Integer.IncrementerHook)
  249.                                 Number = CallHookPkt(Parent->Special.Integer.IncrementerHook,(APTR)LT_GetAttributes(Handle,Parent->ID,LAPR_Object,Parent,TAG_DONE),Handle->ActiveIncrementer->Special.Incrementer.Amount < 0 ? (APTR)INCREMENTERMSG_DECREMENT : (APTR)INCREMENTERMSG_INCREMENT);
  250.                             else
  251.                                 Number = ((LONG)LT_GetAttributes(Handle,Parent->ID,LAPR_Object,Parent,TAG_DONE)) + Handle->ActiveIncrementer->Special.Incrementer.Amount * Handle->IncrementerIncrement;
  252.  
  253.                             if(Number < Parent->Min)
  254.                                 Number = Parent->Min;
  255.                             else
  256.                             {
  257.                                 if(Number > Parent->Max)
  258.                                     Number = Parent->Max;
  259.                             }
  260.  
  261.                             LT_SetAttributes(Handle,Parent->ID,
  262.                                 LAPR_Object,    Parent,
  263.                                 GTIN_Number,    Number,
  264.                             TAG_DONE);
  265.                         }
  266.                     }
  267.                     else
  268.                     {
  269.                         Handle->IncrementerIncrement    = 1;
  270.                         Handle->IncrementerAccelerate    = 10;
  271.                     }
  272.  
  273.                     if(Handle->IncrementerIncrement == 1)
  274.                         Handle->IncrementerCountdown = 2;
  275.                 }
  276.             }
  277.  
  278.             break;
  279.  
  280.         case IDCMP_RAWKEY:
  281.         {
  282.             UBYTE Buffer[10];
  283.             LONG Key;
  284.             struct InputEvent event;
  285.             BOOL KeyUp;
  286.  
  287.             if((*MsgCode & ~IECODE_UP_PREFIX) == 95 && Handle->HelpHook)
  288.             {
  289.                 if(!(*MsgCode & IECODE_UP_PREFIX))
  290.                 {
  291.                     ObjectNode *Item;
  292.                     struct HelpMsg Message;
  293.                     struct IBox Box;
  294.  
  295.                     Item = LTP_FindNode_Position(Handle->TopGroup,Handle->Window->MouseX,Handle->Window->MouseY);
  296.  
  297.                     if(Item == Handle->TopGroup)
  298.                     {
  299.                         if(Item->ID <= PHANTOM_GROUP_ID)
  300.                             Item = NULL;
  301.                     }
  302.  
  303.                     if(Item)
  304.                     {
  305.                         Message.ObjectID = Item->ID;
  306.  
  307.                         Box.Left    = Item->Left;
  308.                         Box.Top        = Item->Top;
  309.                         Box.Width    = Item->Width;
  310.                         Box.Height    = Item->Height;
  311.                     }
  312.                     else
  313.                     {
  314.                         Message.ObjectID = -1;
  315.  
  316.                         Box.Left    = 0;
  317.                         Box.Top        = 0;
  318.                         Box.Width    = Handle->Window->Width;
  319.                         Box.Height    = Handle->Window->Height;
  320.                     }
  321.  
  322.                     Message.Handle = Handle;
  323.  
  324.                     CallHookPkt(Handle->HelpHook,&Message,&Box);
  325.                 }
  326.  
  327.                 if(Handle->RawKeyFilter)
  328.                     *MsgClass = NULL;
  329.  
  330.                 break;
  331.             }
  332.  
  333.             if((*MsgCode >= 99 && *MsgCode <= 103) || *MsgCode == 96 || *MsgCode == 97)
  334.             {
  335.                 if(Handle->RawKeyFilter)
  336.                     *MsgClass = NULL;
  337.  
  338.                 break;
  339.             }
  340.  
  341.             event.ie_NextEvent            = NULL;
  342.             event.ie_Code                 = (*MsgCode) & ~IECODE_UP_PREFIX;
  343.             event.ie_Qualifier            = MsgQualifier & ~QUALIFIER_SHIFT;
  344.             event.ie_Class                = IECLASS_RAWKEY;
  345.             event.ie_SubClass            = 0;
  346.             event.ie_position.ie_addr    = (APTR)*MsgGadget;
  347.  
  348.             Buffer[0] = 0;
  349.  
  350.             if(MapRawKey(&event,Buffer,9,NULL) < 1)
  351.             {
  352.                 if(Handle->RawKeyFilter)
  353.                     *MsgClass = NULL;
  354.  
  355.                 break;
  356.             }
  357.  
  358.             if(!(Key = Buffer[0]))
  359.             {
  360.                 if(Handle->RawKeyFilter)
  361.                     *MsgClass = NULL;
  362.  
  363.                 break;
  364.             }
  365.  
  366.             if((*MsgCode) & IECODE_UP_PREFIX)
  367.                 KeyUp = TRUE;
  368.             else
  369.                 KeyUp = FALSE;
  370.  
  371.             if(!KeyUp && Handle->CursorKey && (*MsgCode == CURSORUP || *MsgCode == CURSORDOWN))
  372.             {
  373.                 ObjectNode *Node;
  374.                 struct Gadget *Gadget;
  375.                 LONG NewState;
  376.                 LONG CurrentTop;
  377.  
  378.                 Handle->ClickSeconds = Handle->ClickMicros = 0;
  379.  
  380.                 Node        = Handle->CursorKey;
  381.                 Gadget        = Node->Host;
  382.                 NewState    = Node->Current;
  383.  
  384.                 if(V39)
  385.                 {
  386.                     GT_GetGadgetAttrs(Gadget,Handle->Window,NULL,
  387.                         GTLV_Top,&CurrentTop,
  388.                     TAG_DONE);
  389.                 }
  390.  
  391.                 if(*MsgCode == CURSORDOWN)
  392.                 {
  393.                     if(MsgQualifier & QUALIFIER_SHIFT)
  394.                     {
  395.                         if(V39)
  396.                         {
  397.                             if(NewState != CurrentTop + Node->Lines - 1)
  398.                                 NewState = CurrentTop + Node->Lines - 1;
  399.                             else
  400.                                 NewState += Node->Lines;
  401.                         }
  402.                         else
  403.                             NewState += Node->Lines;
  404.                     }
  405.                     else
  406.                     {
  407.                         if(MsgQualifier & (QUALIFIER_ALT | QUALIFIER_CONTROL))
  408.                             NewState = Node->Max;
  409.                         else
  410.                             NewState++;
  411.                     }
  412.                 }
  413.                 else
  414.                 {
  415.                     if(MsgQualifier & QUALIFIER_SHIFT)
  416.                     {
  417.                         if(V39)
  418.                         {
  419.                             if(NewState != CurrentTop)
  420.                                 NewState = CurrentTop;
  421.                             else
  422.                                 NewState -= Node->Lines;
  423.                         }
  424.                         else
  425.                             NewState -= Node->Lines;
  426.                     }
  427.                     else
  428.                     {
  429.                         if(MsgQualifier & (QUALIFIER_ALT | QUALIFIER_CONTROL))
  430.                             NewState = Node->Min;
  431.                         else
  432.                             NewState--;
  433.                     }
  434.                 }
  435.  
  436.                 if(NewState < Node->Min)
  437.                     NewState = Node->Min;
  438.                 else
  439.                 {
  440.                     if(NewState > Node->Max)
  441.                         NewState = Node->Max;
  442.                 }
  443.  
  444.                 if(NewState != Node->Current || Node->Max == Node->Min)
  445.                 {
  446.                     ULONG WhichTag;
  447.  
  448.                     if(V39)
  449.                         WhichTag = GTLV_MakeVisible;
  450.                     else
  451.                         WhichTag = GTLV_Top;
  452.  
  453.                     Node->Current = NewState;
  454.  
  455.                     GT_SetGadgetAttrs(Gadget,Handle->Window,NULL,
  456.                         WhichTag,    Node->Current,
  457.                         Node->Special.List.LinkID != -1 ? GTLV_Selected : TAG_IGNORE,Node->Current,
  458.                     TAG_DONE);
  459.  
  460.                     LTP_PutStorage(Node);
  461.  
  462.                     *MsgClass    = IDCMP_GADGETUP;
  463.                     *MsgCode    = Node->Current;
  464.                     *MsgGadget    = Gadget;
  465.  
  466.                     if(Node->Special.List.AutoPageID != -1)
  467.                         *MsgClass = NULL;
  468.  
  469.                     if(!LTP_NotifyPager(Handle,Node->Special.List.AutoPageID,Node->Current))
  470.                         *MsgClass = IDCMP_CLOSEWINDOW;
  471.                 }
  472.                 else
  473.                 {
  474.                     if(Handle->RawKeyFilter)
  475.                         *MsgClass = NULL;
  476.                 }
  477.  
  478.                 Handle->ActiveFrame = NULL;
  479.  
  480.                 return;
  481.             }
  482.  
  483.             if(Key == '\t' && !KeyUp)
  484.             {
  485.                 ObjectNode *Node;
  486.  
  487.                 if(Handle->RawKeyFilter)
  488.                     *MsgClass = NULL;
  489.  
  490.                 if(Node = Handle->TabKey)
  491.                 {
  492.                     if(!(Node->Disabled))
  493.                     {
  494.                         LONG Choice;
  495.  
  496.                         if(MsgQualifier & QUALIFIER_SHIFT)
  497.                             Choice = Node->Current - 1;
  498.                         else
  499.                             Choice = Node->Current + 1;
  500.  
  501.                         Choice = CurrentWrap(Node,Choice);
  502.  
  503.                         if(Choice != Node->Current)
  504.                         {
  505.                             LONG AutoPageID,Type;
  506.                             BOOL CanBlink;
  507.  
  508.                             *MsgClass = IDCMP_GADGETUP;
  509.  
  510.                             CanBlink = FALSE;
  511.  
  512.                             switch(Node->Type)
  513.                             {
  514.                                 case CYCLE_KIND:
  515.  
  516.                                     AutoPageID    = Node->Special.Cycle.AutoPageID;
  517.                                     Type        = GTCY_Active;
  518.                                     CanBlink    = TRUE;
  519.                                     break;
  520. #if defined(DO_POPUP_KIND) && defined(DO_BOOPSI_KIND)
  521.                                 case POPUP_KIND:
  522.  
  523.                                     AutoPageID    = Node->Special.Popup.AutoPageID;
  524.                                     Type        = LAPU_Active;
  525.                                     CanBlink    = TRUE;
  526.                                     break;
  527. #endif
  528. #if defined(DO_TAB_KIND) && defined(DO_BOOPSI_KIND)
  529.                                 case TAB_KIND:
  530.  
  531.                                     AutoPageID    = Node->Special.Tab.AutoPageID;
  532.                                     Type        = LATB_Active;
  533.                                     break;
  534. #endif
  535.                                 case MX_KIND:
  536.  
  537.                                     AutoPageID    = Node->Special.Radio.AutoPageID;
  538.                                     Type        = GTMX_Active;
  539.  
  540.                                     *MsgClass = IDCMP_GADGETDOWN;
  541.  
  542.                                     break;
  543.                             }
  544.  
  545.                             *MsgCode    = (UWORD)Choice;
  546.                             *MsgGadget    = Node->Host;
  547.  
  548.                             if(CanBlink)
  549.                                 LTP_BlinkButton(Handle,*MsgGadget);
  550.  
  551.                             LT_SetAttributes(Handle,Node->ID,
  552.                                 Type,Choice,
  553.                             TAG_DONE);
  554.  
  555.                             if(AutoPageID != -1)
  556.                                 *MsgClass = NULL;
  557.  
  558.                             if(!LTP_NotifyPager(Handle,AutoPageID,Choice))
  559.                                 *MsgClass = IDCMP_CLOSEWINDOW;
  560.                         }
  561.                     }
  562.                 }
  563.  
  564.                 Handle->ActiveFrame = NULL;
  565.  
  566.                 return;
  567.             }
  568.  
  569.             if(Key == '\33' && !KeyUp)
  570.             {
  571.                 ObjectNode *Node;
  572.  
  573.                 Handle->ClickSeconds = Handle->ClickMicros = 0;
  574.  
  575.                 if(Node = Handle->EscKey)
  576.                 {
  577.                     if(!Node->Disabled)
  578.                     {
  579.                         LTP_BlinkButton(Handle,Node->Host);
  580.  
  581.                         *MsgCode    = 0;
  582.                         *MsgGadget    = Node->Host;
  583.                         *MsgClass    = IDCMP_GADGETUP;
  584.                     }
  585.                     else
  586.                     {
  587.                         if(Handle->RawKeyFilter)
  588.                             *MsgClass = NULL;
  589.                     }
  590.                 }
  591.                 else
  592.                 {
  593.                     if(Handle->Window->Flags & WFLG_CLOSEGADGET)
  594.                     {
  595.                         *MsgCode    = 0;
  596.                         *MsgGadget    = NULL;
  597.                         *MsgClass    = IDCMP_CLOSEWINDOW;
  598.                     }
  599.                     else
  600.                     {
  601.                         if(Handle->RawKeyFilter)
  602.                             *MsgClass = NULL;
  603.                     }
  604.                 }
  605.  
  606.                 Handle->ActiveFrame = NULL;
  607.  
  608.                 return;
  609.             }
  610.             else
  611.             {
  612.                 struct Gadget *Gadget;
  613.                 ObjectNode *Node;
  614.                 BOOL FoundIt,Forward,Swallow;
  615.                 LONG NewValue;
  616.                 LONG i;
  617.  
  618.                 if(Handle->ReturnKey && Key == '\r')
  619.                 {
  620.                     Node = Handle->ReturnKey;
  621.  
  622.                     if(!KeyUp && !Node->Disabled)
  623.                     {
  624.                         LTP_BlinkButton(Handle,Node->Host);
  625.  
  626.                         *MsgClass    = IDCMP_GADGETUP;
  627.                         *MsgCode    = 0;
  628.                         *MsgGadget    = Node->Host;
  629.                     }
  630.                     else
  631.                     {
  632.                         if(Handle->RawKeyFilter)
  633.                             *MsgClass = NULL;
  634.                     }
  635.  
  636.                     Handle->ClickSeconds = Handle->ClickMicros = 0;
  637.  
  638.                     Handle->ActiveFrame = NULL;
  639.  
  640.                     return;
  641.                 }
  642.  
  643.                 if(MsgQualifier & QUALIFIER_SHIFT)
  644.                     Forward = FALSE;
  645.                 else
  646.                     Forward = TRUE;
  647.  
  648.                 FoundIt = FALSE;
  649.  
  650.                 for(i = 0 ; !FoundIt && i < Handle->Count ; i++)
  651.                 {
  652.                     if(Gadget = Handle->GadgetArray[i])
  653.                     {
  654.                         if(GETOBJECT(Gadget,Node))
  655.                         {
  656.                             if(Key == Node->Key)
  657.                             {
  658.                                 if(Node->Disabled)
  659.                                     break;
  660.                                 else
  661.                                 {
  662.                                     Swallow = FALSE;
  663.  
  664.                                     NewValue = Node->Current;
  665.  
  666.                                     switch(Node->Type)
  667.                                     {
  668. #ifdef DO_BOOPSI_KIND
  669.                                         case BOOPSI_KIND:
  670.  
  671.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  672.                                             {
  673.                                                 if(Node->Special.BOOPSI.ActivateHook)
  674.                                                 {
  675.                                                     if(CallHookPkt(Node->Special.BOOPSI.ActivateHook,(APTR)Handle,(APTR)Node->Host))
  676.                                                     {
  677.                                                         Swallow = TRUE;
  678.                                                         break;
  679.                                                     }
  680.                                                 }
  681.  
  682.                                                 *MsgClass    = IDCMP_GADGETUP;
  683.                                                 *MsgCode    = Forward ? 1 : (UWORD)-1;
  684.                                                 *MsgGadget    = Gadget;
  685.                                             }
  686.                                             else
  687.                                                 Swallow = TRUE;
  688.  
  689.                                             break;
  690. #ifdef DO_POPUP_KIND
  691.                                         case POPUP_KIND:
  692.  
  693.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  694.                                             {
  695.                                                 if(Forward)
  696.                                                     NewValue++;
  697.                                                 else
  698.                                                     NewValue--;
  699.  
  700.                                                 NewValue = CurrentWrap(Node,NewValue);
  701.  
  702.                                                 LTP_BlinkButton(Handle,Node->Host);
  703.  
  704.                                                 LT_SetAttributes(Handle,0,
  705.                                                     LAPR_Gadget,    Node->Host,
  706.                                                     LAPU_Active,    NewValue,
  707.                                                 TAG_DONE);
  708.  
  709.                                                 *MsgClass    = IDCMP_GADGETUP;
  710.                                                 *MsgCode    = Node->Current;
  711.                                                 *MsgGadget    = Node->Host;
  712.                                             }
  713.                                             else
  714.                                                 Swallow = TRUE;
  715.  
  716.                                             break;
  717. #endif    // DO_POPUP_KIND
  718.  
  719. #ifdef DO_TAB_KIND
  720.                                         case TAB_KIND:
  721.  
  722.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  723.                                             {
  724.                                                 if(Forward)
  725.                                                     NewValue++;
  726.                                                 else
  727.                                                     NewValue--;
  728.  
  729.                                                 NewValue = CurrentWrap(Node,NewValue);
  730.  
  731.                                                 LT_SetAttributes(Handle,0,
  732.                                                     LAPR_Gadget,    Node->Host,
  733.                                                     LAPU_Active,    NewValue,
  734.                                                 TAG_DONE);
  735.  
  736.                                                 *MsgClass    = IDCMP_GADGETUP;
  737.                                                 *MsgCode    = Node->Current;
  738.                                                 *MsgGadget    = Node->Host;
  739.                                             }
  740.                                             else
  741.                                                 Swallow = TRUE;
  742.  
  743.                                             break;
  744. #endif    // DO_TAB_KIND
  745. #endif    /* DO_BOOPSI_KIND */
  746. #ifdef DO_TAPEDECK_KIND
  747.                                         case TAPEDECK_KIND:
  748.  
  749.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  750.                                             {
  751.                                                 if(Node->Special.TapeDeck.Toggle)
  752.                                                 {
  753.                                                     LT_SetAttributes(Handle,Node->ID,
  754.                                                         LAPR_Object,    Node,
  755.                                                         LATD_Pressed,    !Node->Current,
  756.                                                     TAG_DONE);
  757.                                                 }
  758.                                                 else
  759.                                                     LTP_BlinkButton(Handle,Gadget);
  760.  
  761.                                                 if(Gadget->Flags & GFLG_SELECTED)
  762.                                                     *MsgCode = TRUE;
  763.                                                 else
  764.                                                     *MsgCode = FALSE;
  765.  
  766.                                                 *MsgClass    = IDCMP_GADGETUP;
  767.                                                 *MsgGadget    = Gadget;
  768.                                             }
  769.                                             else
  770.                                                 Swallow = TRUE;
  771.  
  772.                                             break;
  773. #endif    /* DO_TAPEDECK_KIND */
  774.                                         case CHECKBOX_KIND:
  775.  
  776.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  777.                                             {
  778.                                                 Node->Current = !Node->Current;
  779.  
  780.                                                 LTP_PutStorage(Node);
  781.  
  782.                                                 GT_SetGadgetAttrs(Gadget,Handle->Window,NULL,
  783.                                                     GTCB_Checked,Node->Current,
  784.                                                 TAG_DONE);
  785.  
  786.                                                 *MsgClass    = IDCMP_GADGETUP;
  787.                                                 *MsgCode    = Node->Current;
  788.                                                 *MsgGadget    = Gadget;
  789.                                             }
  790.                                             else
  791.                                                 Swallow = TRUE;
  792.  
  793.                                             FoundIt = TRUE;
  794.  
  795.                                             break;
  796.  
  797.                                         case LISTVIEW_KIND:
  798.  
  799.                                             if(!KeyUp)
  800.                                             {
  801.                                                 if(NewValue == -1)
  802.                                                 {
  803.                                                     if(Node->Min != -1)
  804.                                                     {
  805.                                                         if(Forward)
  806.                                                             NewValue = Node->Min;
  807.                                                         else
  808.                                                             NewValue = Node->Max;
  809.                                                     }
  810.                                                 }
  811.                                                 else
  812.                                                 {
  813.                                                     if(Forward)
  814.                                                         NewValue++;
  815.                                                     else
  816.                                                         NewValue--;
  817.                                                 }
  818.  
  819.                                                 if(CurrentInBounds(Node,NewValue))
  820.                                                 {
  821.                                                     ULONG WhichTag;
  822.  
  823.                                                     if(V39)
  824.                                                         WhichTag = GTLV_MakeVisible;
  825.                                                     else
  826.                                                         WhichTag = GTLV_Top;
  827.  
  828.                                                     GT_SetGadgetAttrs(Gadget,Handle->Window,NULL,
  829.                                                         WhichTag,Node->Current = NewValue,
  830.                                                         Node->Special.List.LinkID != -1 ? GTLV_Selected : TAG_IGNORE,Node->Current,
  831.                                                     TAG_DONE);
  832.  
  833.                                                     LTP_PutStorage(Node);
  834.  
  835.                                                     *MsgClass    = IDCMP_GADGETUP;
  836.                                                     *MsgCode    = Node->Current;
  837.                                                     *MsgGadget    = Gadget;
  838.  
  839.                                                     if(Node->Special.List.AutoPageID != -1)
  840.                                                     {
  841.                                                         *MsgClass = NULL;
  842.  
  843.                                                         if(!LTP_NotifyPager(Handle,Node->Special.List.AutoPageID,Node->Current))
  844.                                                             *MsgClass = IDCMP_CLOSEWINDOW;
  845.                                                     }
  846.                                                 }
  847.                                                 else
  848.                                                     Swallow = TRUE;
  849.                                             }
  850.                                             else
  851.                                                 Swallow = TRUE;
  852.  
  853.                                             FoundIt = TRUE;
  854.  
  855.                                             break;
  856.  
  857.                                         case MX_KIND:
  858.  
  859.                                             if(!KeyUp)
  860.                                             {
  861.                                                 if(Forward)
  862.                                                     NewValue++;
  863.                                                 else
  864.                                                     NewValue--;
  865.  
  866.                                                 if(CurrentInBounds(Node,NewValue))
  867.                                                 {
  868.                                                     GT_SetGadgetAttrs(Gadget,Handle->Window,NULL,
  869.                                                         GTMX_Active,Node->Current = NewValue,
  870.                                                     TAG_DONE);
  871.  
  872.                                                     LTP_PutStorage(Node);
  873.  
  874.                                                     *MsgClass    = IDCMP_GADGETDOWN;
  875.                                                     *MsgCode    = Node->Current;
  876.                                                     *MsgGadget    = Gadget;
  877.  
  878.                                                     if(Node->Special.Radio.AutoPageID != -1)
  879.                                                     {
  880.                                                         *MsgClass = NULL;
  881.  
  882.                                                         if(!LTP_NotifyPager(Handle,Node->Special.Radio.AutoPageID,Node->Current))
  883.                                                             *MsgClass = IDCMP_CLOSEWINDOW;
  884.                                                     }
  885.                                                 }
  886.                                                 else
  887.                                                     Swallow = TRUE;
  888.                                             }
  889.                                             else
  890.                                                 Swallow = TRUE;
  891.  
  892.                                             FoundIt = TRUE;
  893.  
  894.                                             break;
  895.  
  896.                                         case TEXT_KIND:
  897.  
  898.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  899.                                             {
  900.                                                 if(Node->Special.Text.Picker)
  901.                                                 {
  902.                                                     LTP_BlinkButton(Handle,Node->Special.Text.Picker);
  903.  
  904.                                                     *MsgClass    = IDCMP_IDCMPUPDATE;
  905.                                                     *MsgCode    = 0;
  906.                                                     *MsgGadget    = Gadget;
  907.                                                 }
  908.                                                 else
  909.                                                     Swallow = TRUE;
  910.                                             }
  911.                                             else
  912.                                                 Swallow = TRUE;
  913.  
  914.                                             FoundIt = TRUE;
  915.  
  916.                                             break;
  917.  
  918.                                         case NUMBER_KIND:
  919.  
  920.                                             Swallow = TRUE;
  921.                                             FoundIt = TRUE;
  922.  
  923.                                             break;
  924.  
  925.                                         case CYCLE_KIND:
  926.  
  927.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  928.                                             {
  929.                                                 if(Forward)
  930.                                                     NewValue++;
  931.                                                 else
  932.                                                     NewValue--;
  933.  
  934.                                                 NewValue = CurrentWrap(Node,NewValue);
  935.  
  936.                                                 LTP_BlinkButton(Handle,Gadget);
  937.  
  938.                                                 GT_SetGadgetAttrs(Gadget,Handle->Window,NULL,
  939.                                                     GTCY_Active,Node->Current = NewValue,
  940.                                                 TAG_DONE);
  941.  
  942.                                                 LTP_PutStorage(Node);
  943.  
  944.                                                 *MsgClass    = IDCMP_GADGETUP;
  945.                                                 *MsgCode    = Node->Current;
  946.                                                 *MsgGadget    = Gadget;
  947.  
  948.                                                 if(Node->Special.Cycle.AutoPageID != -1)
  949.                                                 {
  950.                                                     *MsgClass = NULL;
  951.  
  952.                                                     if(!LTP_NotifyPager(Handle,Node->Special.Cycle.AutoPageID,Node->Current))
  953.                                                         *MsgClass = IDCMP_CLOSEWINDOW;
  954.                                                 }
  955.                                             }
  956.                                             else
  957.                                                 Swallow = TRUE;
  958.  
  959.                                             FoundIt = TRUE;
  960.  
  961.                                             break;
  962.  
  963.                                         case PALETTE_KIND:
  964.  
  965.                                             if(!KeyUp)
  966.                                             {
  967.                                                 if(Node->Special.Palette.UsePicker)
  968.                                                 {
  969.                                                     if(!(MsgQualifier & IEQUALIFIER_REPEAT))
  970.                                                     {
  971.                                                         LTP_BlinkButton(Handle,Node->Special.Palette.Picker);
  972.  
  973.                                                         *MsgClass    = IDCMP_IDCMPUPDATE;
  974.                                                         *MsgCode    = 0;
  975.                                                         *MsgGadget    = Gadget;
  976.                                                     }
  977.                                                     else
  978.                                                         Swallow = TRUE;
  979.  
  980.                                                     FoundIt = TRUE;
  981.  
  982.                                                     break;
  983.                                                 }
  984.  
  985.                                                 if(Node->Special.Palette.TranslateBack)
  986.                                                 {
  987.                                                     LONG Index = Node->Special.Palette.TranslateBack[Node->Current];
  988.  
  989.                                                     if(Index < Node->Min)
  990.                                                         Index = Node->Min;
  991.                                                     else
  992.                                                     {
  993.                                                         if(Index > Node->Max)
  994.                                                             Index = Node->Max;
  995.                                                     }
  996.  
  997.                                                     if(Forward)
  998.                                                         Index++;
  999.                                                     else
  1000.                                                         Index--;
  1001.  
  1002.                                                     if(Index < Node->Min)
  1003.                                                         Index = Node->Min;
  1004.                                                     else
  1005.                                                     {
  1006.                                                         if(Index > Node->Max)
  1007.                                                             Index = Node->Max;
  1008.                                                     }
  1009.  
  1010.                                                     NewValue = Node->Special.Palette.ColourTable[Index];
  1011.                                                 }
  1012.                                                 else
  1013.                                                 {
  1014.                                                     if(Forward)
  1015.                                                         NewValue++;
  1016.                                                     else
  1017.                                                         NewValue--;
  1018.                                                 }
  1019.  
  1020.                                                 if(CurrentInBounds(Node,NewValue))
  1021.                                                 {
  1022.                                                     GT_SetGadgetAttrs(Gadget,Handle->Window,NULL,
  1023.                                                         GTPA_Color,Node->Current = NewValue,
  1024.                                                     TAG_DONE);
  1025.  
  1026.                                                     LTP_PutStorage(Node);
  1027.  
  1028.                                                     *MsgClass    = IDCMP_GADGETUP;
  1029.                                                     *MsgCode    = Node->Current;
  1030.                                                     *MsgGadget    = Gadget;
  1031.                                                 }
  1032.                                                 else
  1033.                                                     Swallow = TRUE;
  1034.                                             }
  1035.                                             else
  1036.                                                 Swallow = TRUE;
  1037.  
  1038.                                             FoundIt = TRUE;
  1039.  
  1040.                                             break;
  1041.  
  1042.                                         case SLIDER_KIND:
  1043.  
  1044.                                             if(KeyUp)
  1045.                                             {
  1046.                                                 *MsgClass    = IDCMP_GADGETUP;
  1047.                                                 *MsgCode    = Node->Current;
  1048.                                                 *MsgGadget    = Gadget;
  1049.                                             }
  1050.                                             else
  1051.                                             {
  1052.                                                 if(Forward)
  1053.                                                     NewValue++;
  1054.                                                 else
  1055.                                                     NewValue--;
  1056.  
  1057.                                                 if(CurrentInBounds(Node,NewValue))
  1058.                                                 {
  1059.                                                     GT_SetGadgetAttrs(Gadget,Handle->Window,NULL,
  1060.                                                         GTSL_Level,Node->Current = NewValue,
  1061.                                                     TAG_DONE);
  1062.  
  1063.                                                     LTP_PutStorage(Node);
  1064.  
  1065.                                                     *MsgClass    = IDCMP_MOUSEMOVE;
  1066.                                                     *MsgCode    = Node->Current;
  1067.                                                     *MsgGadget    = Gadget;
  1068.                                                 }
  1069.                                                 else
  1070.                                                     Swallow = TRUE;
  1071.                                             }
  1072.  
  1073.                                             FoundIt = TRUE;
  1074.  
  1075.                                             break;
  1076.  
  1077. #ifdef DO_LEVEL_KIND
  1078.                                         case LEVEL_KIND:
  1079.  
  1080.                                             if(KeyUp)
  1081.                                             {
  1082.                                                 *MsgClass    = IDCMP_GADGETUP;
  1083.                                                 *MsgCode    = Node->Current;
  1084.                                                 *MsgGadget    = Gadget;
  1085.  
  1086.                                                 LTP_PutStorage(Node);
  1087.                                             }
  1088.                                             else
  1089.                                             {
  1090.                                                 if(Forward)
  1091.                                                     NewValue++;
  1092.                                                 else
  1093.                                                     NewValue--;
  1094.  
  1095.                                                 if(CurrentInBounds(Node,NewValue))
  1096.                                                 {
  1097.                                                     LT_SetAttributes(Handle,Node->ID,
  1098.                                                         LAPR_Object,    Node,
  1099.                                                         LAVL_Level,        NewValue,
  1100.                                                     TAG_DONE);
  1101.  
  1102.                                                     *MsgClass    = IDCMP_MOUSEMOVE;
  1103.                                                     *MsgCode    = NewValue;
  1104.                                                     *MsgGadget    = Gadget;
  1105.                                                 }
  1106.                                                 else
  1107.                                                     Swallow = TRUE;
  1108.                                             }
  1109.  
  1110.                                             FoundIt = TRUE;
  1111.  
  1112.                                             break;
  1113. #endif    /* DO_LEVEL_KIND */
  1114.  
  1115.                                         case SCROLLER_KIND:
  1116.  
  1117.                                             if(KeyUp)
  1118.                                             {
  1119.                                                 *MsgClass    = IDCMP_GADGETUP;
  1120.                                                 *MsgCode    = Node->Current;
  1121.                                                 *MsgGadget    = Gadget;
  1122.                                             }
  1123.                                             else
  1124.                                             {
  1125.                                                 if(Forward)
  1126.                                                     NewValue++;
  1127.                                                 else
  1128.                                                     NewValue--;
  1129.  
  1130.                                                 if(CurrentInBounds(Node,NewValue))
  1131.                                                 {
  1132.                                                     GT_SetGadgetAttrs(Gadget,Handle->Window,NULL,
  1133.                                                         GTSC_Top,Node->Current = NewValue,
  1134.                                                     TAG_DONE);
  1135.  
  1136.                                                     LTP_PutStorage(Node);
  1137.  
  1138.                                                     *MsgClass    = IDCMP_MOUSEMOVE;
  1139.                                                     *MsgCode    = Node->Current;
  1140.                                                     *MsgGadget    = Gadget;
  1141.                                                 }
  1142.                                                 else
  1143.                                                     Swallow = TRUE;
  1144.                                             }
  1145.  
  1146.                                             FoundIt = TRUE;
  1147.  
  1148.                                             break;
  1149.  
  1150.                                         case STRING_KIND:
  1151.                                         case PASSWORD_KIND:
  1152.  
  1153.                                             if(!KeyUp)
  1154.                                             {
  1155.                                                 if(Node->Special.String.Picker && !Forward)
  1156.                                                 {
  1157.                                                     LTP_BlinkButton(Handle,Node->Special.String.Picker);
  1158.  
  1159.                                                     *MsgClass    = IDCMP_IDCMPUPDATE;
  1160.                                                     *MsgCode    = 0;
  1161.                                                     *MsgGadget    = Gadget;
  1162.                                                 }
  1163.                                                 else
  1164.                                                 {
  1165.                                                     ActivateGadget(Gadget,Handle->Window,NULL);
  1166.  
  1167.                                                     *MsgClass    = IDCMP_GADGETDOWN;
  1168.                                                     *MsgCode    = 0;
  1169.                                                     *MsgGadget    = Gadget;
  1170.  
  1171.                                                     Handle->Previous = Gadget;
  1172.                                                 }
  1173.                                             }
  1174.                                             else
  1175.                                                 Swallow = TRUE;
  1176.  
  1177.                                             FoundIt = TRUE;
  1178.  
  1179.                                             break;
  1180.  
  1181.                                         case INTEGER_KIND:
  1182.  
  1183.                                             if(!KeyUp)
  1184.                                             {
  1185.                                                 if(Node->Special.Integer.UseIncrementers)
  1186.                                                 {
  1187.                                                     ObjectNode *incNode,*Parent;
  1188.                                                     struct Gadget *Incrementer;
  1189.                                                     LONG Number;
  1190.  
  1191.                                                     Parent = (ObjectNode *)Gadget->UserData;
  1192.  
  1193.                                                     if(Forward)
  1194.                                                     {
  1195.                                                         incNode = Node->Special.Integer.RightIncrementer->UserData;
  1196.  
  1197.                                                         Incrementer = Node->Special.Integer.RightIncrementer;
  1198.                                                     }
  1199.                                                     else
  1200.                                                     {
  1201.                                                         incNode = Node->Special.Integer.LeftIncrementer->UserData;
  1202.  
  1203.                                                         Incrementer = Node->Special.Integer.LeftIncrementer;
  1204.                                                     }
  1205.  
  1206.                                                     if(Parent->Special.Integer.IncrementerHook)
  1207.                                                         Number = CallHookPkt(Parent->Special.Integer.IncrementerHook,(APTR)LT_GetAttributes(Handle,Parent->ID,LAPR_Object,Parent,TAG_DONE),incNode->Special.Incrementer.Amount < 0 ? (APTR)INCREMENTERMSG_DECREMENT : (APTR)INCREMENTERMSG_INCREMENT);
  1208.                                                     else
  1209.                                                         Number = LT_GetAttributes(Handle,Parent->ID,LAPR_Object,Parent,TAG_DONE) + incNode->Special.Incrementer.Amount;
  1210.  
  1211.                                                     if(CurrentInBounds(Parent,Number))
  1212.                                                     {
  1213.                                                         LTP_BlinkButton(Handle,Incrementer);
  1214.  
  1215.                                                         LT_SetAttributes(Handle,Parent->ID,
  1216.                                                             LAPR_Object,    Parent,
  1217.                                                             GTIN_Number,    Number,
  1218.                                                         TAG_DONE);
  1219.  
  1220.                                                         *MsgClass = IDCMP_GADGETUP;
  1221.                                                     }
  1222.                                                 }
  1223.                                                 else
  1224.                                                 {
  1225.                                                     ActivateGadget(Gadget,Handle->Window,NULL);
  1226.  
  1227.                                                     *MsgClass = IDCMP_GADGETDOWN;
  1228.                                                 }
  1229.  
  1230.                                                 *MsgCode    = 0;
  1231.                                                 *MsgGadget    = Gadget;
  1232.  
  1233.                                                 Handle->Previous = Gadget;
  1234.                                             }
  1235.                                             else
  1236.                                                 Swallow = TRUE;
  1237.  
  1238.                                             FoundIt = TRUE;
  1239.  
  1240.                                             break;
  1241.  
  1242.                                         case BUTTON_KIND:
  1243.  
  1244.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  1245.                                             {
  1246.                                                 LTP_BlinkButton(Handle,Gadget);
  1247.  
  1248.                                                 *MsgClass    = IDCMP_GADGETUP;
  1249.                                                 *MsgCode    = 0;
  1250.                                                 *MsgGadget    = Gadget;
  1251.                                             }
  1252.                                             else
  1253.                                                 Swallow = TRUE;
  1254.  
  1255.                                             FoundIt = TRUE;
  1256.  
  1257.                                             break;
  1258.                                     }
  1259.  
  1260.                                     if(Swallow)
  1261.                                     {
  1262.                                         if(Handle->RawKeyFilter)
  1263.                                             *MsgClass = NULL;
  1264.                                     }
  1265.                                 }
  1266.                             }
  1267.                         }
  1268.                     }
  1269.                 }
  1270.  
  1271.                 if(FoundIt)
  1272.                     Handle->ClickSeconds = Handle->ClickMicros = 0;
  1273.             }
  1274.  
  1275.             Handle->ActiveFrame = NULL;
  1276.  
  1277.             break;
  1278.         }
  1279.  
  1280.         case IDCMP_GADGETDOWN:
  1281.  
  1282.             if(GETOBJECT((*MsgGadget),Node))
  1283.             {
  1284.                 if(Node->Type != LISTVIEW_KIND)
  1285.                     Handle->ClickSeconds = Handle->ClickMicros = 0;
  1286.  
  1287.                 Handle->ActiveFrame = NULL;
  1288.  
  1289.                 switch(Node->Type)
  1290.                 {
  1291. #ifdef DO_LEVEL_KIND
  1292.                     case LEVEL_KIND:
  1293.  
  1294.                         Handle->CurrentLevel = Node;
  1295.  
  1296.                         *MsgCode = Node->Current;
  1297.  
  1298.                         break;
  1299. #endif    /* DO_LEVEL_KIND */
  1300.                     case STRING_KIND:
  1301.                     case INTEGER_KIND:
  1302.                     case PASSWORD_KIND:
  1303.  
  1304.                         Handle->Previous = *MsgGadget;
  1305.                         break;
  1306. #ifdef DO_TAPEDECK_KIND
  1307.                     case TAPEDECK_KIND:
  1308.  
  1309.                         if(Node->Special.TapeDeck.Tick)
  1310.                         {
  1311.                             Handle->ActiveIncrementer        = Node;
  1312.                             Handle->IncrementerCountdown    = 2;
  1313.                             Handle->IncrementerAccelerate    = 10;
  1314.                             Handle->IncrementerIncrement    = 1;
  1315.  
  1316.                             *MsgClass    = IDCMP_GADGETUP;
  1317.                             *MsgCode    = 0;
  1318.                         }
  1319.                         else
  1320.                         {
  1321.                             if(Node->Special.TapeDeck.Toggle)
  1322.                             {
  1323.                                 if((*MsgGadget)->Flags & GFLG_SELECTED)
  1324.                                     *MsgCode = TRUE;
  1325.                                 else
  1326.                                     *MsgCode = FALSE;
  1327.  
  1328.                                 Node->Current = *MsgCode;
  1329.  
  1330.                                 LTP_PutStorage(Node);
  1331.  
  1332.                                 if(Handle->Previous && !Node->PageSelector)
  1333.                                     Activate = TRUE;
  1334.  
  1335.                                 *MsgClass = IDCMP_GADGETUP;
  1336.                             }
  1337.                         }
  1338.  
  1339.                         break;
  1340. #endif    /* DO_TAPEDECK_KIND */
  1341.                     case MX_KIND:
  1342.  
  1343.                         if(!V39 && Node->Disabled)
  1344.                         {
  1345.                             GT_SetGadgetAttrs(*MsgGadget,Handle->Window,NULL,
  1346.                                 GTMX_Active,Node->Current,
  1347.                             TAG_DONE);
  1348.  
  1349.                             *MsgClass = NULL;
  1350.                         }
  1351.                         else
  1352.                         {
  1353.                             Node->Current = *MsgCode;
  1354.  
  1355.                             LTP_PutStorage(Node);
  1356.  
  1357.                             if(Node->Special.Radio.AutoPageID != -1)
  1358.                             {
  1359.                                 *MsgClass = NULL;
  1360.  
  1361.                                 if(!LTP_NotifyPager(Handle,Node->Special.Radio.AutoPageID,Node->Current))
  1362.                                     *MsgClass = IDCMP_CLOSEWINDOW;
  1363.                             }
  1364.  
  1365.                             if(Handle->Previous && !Node->PageSelector)
  1366.                                 Activate = TRUE;
  1367.                         }
  1368.  
  1369.                         break;
  1370.  
  1371.                     case SLIDER_KIND:
  1372.  
  1373.                         if(Node->Min < 0)
  1374.                             Node->Current = (WORD)*MsgCode;
  1375.                         else
  1376.                             Node->Current = *MsgCode;
  1377.  
  1378.                         LTP_PutStorage(Node);
  1379.  
  1380.                         if(Handle->Previous && !Node->PageSelector)
  1381.                             Activate = TRUE;
  1382.  
  1383.                         break;
  1384.  
  1385.                     case SCROLLER_KIND:
  1386.  
  1387.                         Node->Current = *MsgCode;
  1388.  
  1389.                         LTP_PutStorage(Node);
  1390.  
  1391.                         if(Handle->Previous && !Node->PageSelector)
  1392.                             Activate = TRUE;
  1393.  
  1394.                         break;
  1395.  
  1396.                     case INCREMENTER_KIND:
  1397.  
  1398.                         Handle->ActiveIncrementer        = Node;
  1399.                         Handle->IncrementerCountdown    = 6;
  1400.                         Handle->IncrementerAccelerate    = 10;
  1401.                         Handle->IncrementerIncrement    = 1;
  1402.  
  1403.                         *MsgClass    = IDCMP_GADGETUP;
  1404.                         *MsgCode    = 0;
  1405.                         *MsgGadget    = Node->Special.Incrementer.Parent;
  1406.  
  1407.                         /* ALWAYS */
  1408.                         {
  1409.                             struct ObjectNode *Parent;
  1410.                             LONG Number;
  1411.  
  1412.                             Parent = (ObjectNode *)(*MsgGadget)->UserData;
  1413.  
  1414.                             if(Parent->Special.Integer.IncrementerHook)
  1415.                                 Number = CallHookPkt(Parent->Special.Integer.IncrementerHook,(APTR)LT_GetAttributes(Handle,Parent->ID,LAPR_Object,Parent,TAG_DONE),Node->Special.Incrementer.Amount < 0 ? (APTR)INCREMENTERMSG_DECREMENT : (APTR)INCREMENTERMSG_INCREMENT);
  1416.                             else
  1417.                                 Number = LT_GetAttributes(Handle,Parent->ID,LAPR_Object,Parent,TAG_DONE) + Node->Special.Incrementer.Amount;
  1418.  
  1419.                             if(Number >= Parent->Min && Number <= Parent->Max)
  1420.                                 LT_SetAttributes(Handle,Parent->ID,LAPR_Object,Parent,GTIN_Number,Number,TAG_DONE);
  1421.                             else
  1422.                                 *MsgClass = NULL;
  1423.                         }
  1424.  
  1425.                         break;
  1426.                 }
  1427.             }
  1428.  
  1429.             break;
  1430.  
  1431.         case IDCMP_MOUSEBUTTONS:
  1432.         {
  1433.             ObjectNode *Node;
  1434.             LONG x,y;
  1435.  
  1436.             x = Handle->Window->MouseX;
  1437.             y = Handle->Window->MouseY;
  1438.  
  1439.             Node = LTP_FindNode_Position(Handle->TopGroup,x,y);
  1440.  
  1441.             if(((*MsgCode) & IECODE_UP_PREFIX) && Handle->Previous)
  1442.                 Activate = TRUE;
  1443.  
  1444.             if(Node && !Node->Disabled)
  1445.             {
  1446.                 if(*MsgCode == SELECTDOWN)
  1447.                 {
  1448.                     switch(Node->Type)
  1449.                     {
  1450.                         case CHECKBOX_KIND:
  1451.  
  1452.                             Node->Current = !Node->Current;
  1453.  
  1454.                             LTP_PutStorage(Node);
  1455.  
  1456.                             GT_SetGadgetAttrs(Node->Host,Handle->Window,NULL,
  1457.                                 GTCB_Checked,Node->Current,
  1458.                             TAG_DONE);
  1459.  
  1460.                             *MsgClass    = IDCMP_GADGETUP;
  1461.                             *MsgCode    = Node->Current;
  1462.                             *MsgGadget    = Node->Host;
  1463.  
  1464.                             break;
  1465.  
  1466.                         case MX_KIND:
  1467.                         {
  1468.                             LONG Index = LTP_Find_Clicked_Item(Handle,Node,x,y);
  1469.  
  1470.                             if(Index != -1)
  1471.                             {
  1472.                                 Node->Current = Index;
  1473.  
  1474.                                 GT_SetGadgetAttrs(Node->Host,Handle->Window,NULL,
  1475.                                     GTMX_Active,Index,
  1476.                                 TAG_DONE);
  1477.  
  1478.                                 LTP_PutStorage(Node);
  1479.  
  1480.                                 *MsgClass    = IDCMP_GADGETDOWN;
  1481.                                 *MsgCode    = Index;
  1482.                                 *MsgGadget    = Node->Host;
  1483.  
  1484.                                 if(Node->Special.Cycle.AutoPageID != -1)
  1485.                                     *MsgClass = NULL;
  1486.  
  1487.                                 if(!LTP_NotifyPager(Handle,Node->Special.Cycle.AutoPageID,Node->Current))
  1488.                                     *MsgClass = IDCMP_CLOSEWINDOW;
  1489.                             }
  1490.  
  1491.                             break;
  1492.                         }
  1493.  
  1494.                         case FRAME_KIND:
  1495.  
  1496.                             if(Node->Special.Frame.GenerateEvents)
  1497.                             {
  1498.                                 if(Node->Special.Frame.DrawBox)
  1499.                                 {
  1500.                                     if(x < Node->Left + 2 || x >= Node->Left + Node->Width - 2 || y < Node->Top + 1 || y >= Node->Top + Node->Height - 2)
  1501.                                         break;
  1502.                                 }
  1503.  
  1504.                                 *MsgClass    = IDCMP_GADGETDOWN;
  1505.                                 *MsgGadget    = &Node->Special.Frame.Dummy;
  1506.  
  1507.                                 Handle->ActiveFrame = Node;
  1508.                             }
  1509.  
  1510.                             break;
  1511.                     }
  1512.                 }
  1513.  
  1514.                 if(*MsgCode == SELECTUP)
  1515.                 {
  1516.                         // Now this is a real kludge; as of v37 the
  1517.                         // MX_KIND labels are not part of the gadget
  1518.                         // itself and a plain SELECTDOWN mouse event
  1519.                         // is sent as soon as the user clicks on it.
  1520.                         // This changed with v39 which presumably had
  1521.                         // some code in there to map mouse clicks on
  1522.                         // the gadget labels to proper buttonpress
  1523.                         // events. Now, try as you might the click is
  1524.                         // swallowed and we have to do with the
  1525.                         // SELECTUP, sigh...
  1526.  
  1527.                     if(V39 && Node->Type == MX_KIND)
  1528.                     {
  1529.                         LONG Index;
  1530.  
  1531.                         Index = LTP_Find_Clicked_Item(Handle,Node,x,y);
  1532.  
  1533.                         if(Index != -1)
  1534.                         {
  1535.                             GT_SetGadgetAttrs(Node->Host,Handle->Window,NULL,
  1536.                                 GTMX_Active,Index,
  1537.                             TAG_DONE);
  1538.  
  1539.                             Node->Current = Index;
  1540.  
  1541.                             LTP_PutStorage(Node);
  1542.  
  1543.                             *MsgClass    = IDCMP_GADGETDOWN;
  1544.                             *MsgCode    = Index;
  1545.                             *MsgGadget    = Node->Host;
  1546.  
  1547.                             if(Node->Special.Cycle.AutoPageID != -1)
  1548.                                 *MsgClass = NULL;
  1549.  
  1550.                             if(!LTP_NotifyPager(Handle,Node->Special.Cycle.AutoPageID,Node->Current))
  1551.                                 *MsgClass = IDCMP_CLOSEWINDOW;
  1552.                         }
  1553.                     }
  1554.  
  1555.                     if(Handle->ActiveIncrementer)
  1556.                     {
  1557.                         if(Handle->ActiveIncrementer->Type == TAPEDECK_KIND && Handle->ActiveIncrementer ->Special.TapeDeck.Tick)
  1558.                         {
  1559.                             Handle->ActiveIncrementer = NULL;
  1560.  
  1561.                             *MsgClass    = IDCMP_GADGETUP;
  1562.                             *MsgCode    = 1;
  1563.                         }
  1564.                         else
  1565.                         {
  1566.                             if(((ObjectNode *)Handle->ActiveIncrementer->Special.Incrementer.Parent->UserData)->Type == INTEGER_KIND)
  1567.                             {
  1568.                                 *MsgGadget    = Handle->ActiveIncrementer->Special.Incrementer.Parent;
  1569.                                 *MsgClass    = IDCMP_GADGETUP;
  1570.                                 *MsgCode    = 1;
  1571.                             }
  1572.  
  1573.                             Handle->ActiveIncrementer = NULL;
  1574.                         }
  1575.                     }
  1576.  
  1577.                     if(Handle->ActiveFrame)
  1578.                     {
  1579.                         *MsgClass    = IDCMP_GADGETUP;
  1580.                         *MsgGadget    = &Node->Special.Frame.Dummy;
  1581.  
  1582.                         Handle->ActiveFrame = NULL;
  1583.                     }
  1584.                 }
  1585.             }
  1586.  
  1587.             break;
  1588.         }
  1589.  
  1590.         case IDCMP_GADGETUP:
  1591.  
  1592. #ifdef DO_LEVEL_KIND
  1593.             Handle->CurrentLevel = NULL;
  1594. #endif    /* DO_LEVEL_KIND */
  1595.  
  1596.             Handle->ActiveFrame = NULL;
  1597.  
  1598.             if(GETOBJECT((*MsgGadget),Node))
  1599.             {
  1600.                 if(Node->Type != LISTVIEW_KIND)
  1601.                     Handle->ClickSeconds = Handle->ClickMicros = 0;
  1602.  
  1603.                 switch(Node->Type)
  1604.                 {
  1605.                     case PASSWORD_KIND:
  1606.                     case STRING_KIND:
  1607.  
  1608.                         LTP_PutStorage(Node);
  1609.  
  1610.                         if(*MsgCode == 0x5F && Handle->HelpHook)
  1611.                         {
  1612.                             struct HelpMsg Message;
  1613.                             struct IBox Box;
  1614.  
  1615.                             Message.ObjectID = Node->ID;
  1616.  
  1617.                             Box.Left    = Node->Left;
  1618.                             Box.Top        = Node->Top;
  1619.                             Box.Width    = Node->Width;
  1620.                             Box.Height    = Node->Height;
  1621.  
  1622.                             Message.Handle = Handle;
  1623.  
  1624.                             CallHookPkt(Handle->HelpHook,&Message,&Box);
  1625.  
  1626.                             *MsgClass = NULL;
  1627.                         }
  1628.                         else
  1629.                             Handle->Previous = NULL;
  1630.  
  1631.                         break;
  1632.  
  1633.                     case INTEGER_KIND:
  1634.                     {
  1635.                         struct StringInfo *StringInfo = (struct StringInfo *)(*MsgGadget)->SpecialInfo;
  1636.                         LONG Contents = StringInfo->LongInt;
  1637.  
  1638.                         if(Contents < Node->Min)
  1639.                             Contents = Node->Min;
  1640.                         else
  1641.                         {
  1642.                             if(Contents > Node->Max)
  1643.                                 Contents = Node->Max;
  1644.                         }
  1645.  
  1646.                         LT_SetAttributes(Handle,(*MsgGadget)->GadgetID,GTIN_Number,Contents,TAG_DONE);
  1647.  
  1648.                         LTP_PutStorage(Node);
  1649.  
  1650.                         if(*MsgCode == 0x5F && Handle->HelpHook)
  1651.                         {
  1652.                             struct HelpMsg Message;
  1653.                             struct IBox Box;
  1654.  
  1655.                             Message.ObjectID = Node->ID;
  1656.  
  1657.                             Box.Left    = Node->Left;
  1658.                             Box.Top        = Node->Top;
  1659.                             Box.Width    = Node->Width;
  1660.                             Box.Height    = Node->Height;
  1661.  
  1662.                             Message.Handle = Handle;
  1663.  
  1664.                             CallHookPkt(Handle->HelpHook,&Message,&Box);
  1665.  
  1666.                             *MsgClass = NULL;
  1667.                         }
  1668.                         else
  1669.                             Handle->Previous = NULL;
  1670.  
  1671.                         break;
  1672.                     }
  1673.  
  1674.                     case CHECKBOX_KIND:
  1675.  
  1676.                         if(!V39)
  1677.                         {
  1678.                             if((*MsgGadget)->Flags & GFLG_SELECTED)
  1679.                                 *MsgCode = TRUE;
  1680.                             else
  1681.                                 *MsgCode = FALSE;
  1682.                         }
  1683.  
  1684.                         Node->Current = *MsgCode;
  1685.  
  1686.                         LTP_PutStorage(Node);
  1687.  
  1688.                         if(Handle->Previous && !Node->PageSelector)
  1689.                             Activate = TRUE;
  1690.  
  1691.                         break;
  1692. #ifdef DO_TAPEDECK_KIND
  1693.                     case TAPEDECK_KIND:
  1694.  
  1695.                         if(Node->Special.TapeDeck.Tick)
  1696.                         {
  1697.                             Handle->ActiveIncrementer = NULL;
  1698.  
  1699.                             *MsgClass    = IDCMP_GADGETUP;
  1700.                             *MsgCode    = 1;
  1701.                         }
  1702.                         else
  1703.                         {
  1704.                             if(Node->Special.TapeDeck.Toggle)
  1705.                             {
  1706.                                 if((*MsgGadget)->Flags & GFLG_SELECTED)
  1707.                                     *MsgCode = TRUE;
  1708.                                 else
  1709.                                     *MsgCode = FALSE;
  1710.  
  1711.                                 Node->Current = *MsgCode;
  1712.  
  1713.                                 LTP_PutStorage(Node);
  1714.                             }
  1715.                         }
  1716.  
  1717.                         if(Handle->Previous && !Node->PageSelector)
  1718.                             Activate = TRUE;
  1719.  
  1720.                         break;
  1721. #endif    /* DO_TAPEDECK_KIND */
  1722. #if defined(DO_POPUP_KIND) && defined(DO_BOOPSI_KIND)
  1723.                     case POPUP_KIND:
  1724.  
  1725.                         Node->Current = *MsgCode;
  1726.  
  1727.                         LTP_PutStorage(Node);
  1728.  
  1729.                         if(Handle->Previous && !Node->PageSelector)
  1730.                             Activate = TRUE;
  1731.  
  1732.                         if(Node->Special.Popup.AutoPageID != -1)
  1733.                         {
  1734.                             *MsgClass = NULL;
  1735.  
  1736.                             if(!LTP_NotifyPager(Handle,Node->Special.Popup.AutoPageID,Node->Current))
  1737.                                 *MsgClass = IDCMP_CLOSEWINDOW;
  1738.                         }
  1739.  
  1740.                         break;
  1741. #endif
  1742.  
  1743. #if defined(DO_TAB_KIND) && defined(DO_BOOPSI_KIND)
  1744.                     case TAB_KIND:
  1745.  
  1746.                         Node->Current = *MsgCode;
  1747.  
  1748.                         LTP_PutStorage(Node);
  1749.  
  1750.                         if(Handle->Previous && !Node->PageSelector)
  1751.                             Activate = TRUE;
  1752.  
  1753.                         if(Node->Special.Tab.AutoPageID != -1)
  1754.                         {
  1755.                             *MsgClass = NULL;
  1756.  
  1757.                             if(!LTP_NotifyPager(Handle,Node->Special.Tab.AutoPageID,Node->Current))
  1758.                                 *MsgClass = IDCMP_CLOSEWINDOW;
  1759.                         }
  1760.  
  1761.                         break;
  1762. #endif
  1763.                     case CYCLE_KIND:
  1764.  
  1765.                         Node->Current = *MsgCode;
  1766.  
  1767.                         LTP_PutStorage(Node);
  1768.  
  1769.                         if(Handle->Previous && !Node->PageSelector)
  1770.                             Activate = TRUE;
  1771.  
  1772.                         if(Node->Special.Cycle.AutoPageID != -1)
  1773.                         {
  1774.                             *MsgClass = NULL;
  1775.  
  1776.                             if(!LTP_NotifyPager(Handle,Node->Special.Cycle.AutoPageID,Node->Current))
  1777.                                 *MsgClass = IDCMP_CLOSEWINDOW;
  1778.                         }
  1779.  
  1780.                         break;
  1781.  
  1782.                     case PALETTE_KIND:
  1783.  
  1784.                         Node->Current = *MsgCode;
  1785.  
  1786.                         LTP_PutStorage(Node);
  1787.  
  1788.                         if(Handle->Previous && !Node->PageSelector)
  1789.                             Activate = TRUE;
  1790.  
  1791.                         break;
  1792.  
  1793.                     case MX_KIND:
  1794.  
  1795.                         if(!V39 && Node->Disabled)
  1796.                         {
  1797.                             GT_SetGadgetAttrs(*MsgGadget,Handle->Window,NULL,
  1798.                                 GTMX_Active,Node->Current,
  1799.                             TAG_DONE);
  1800.  
  1801.                             *MsgClass = NULL;
  1802.                         }
  1803.                         else
  1804.                         {
  1805.                             Node->Current = *MsgCode;
  1806.  
  1807.                             LTP_PutStorage(Node);
  1808.  
  1809.                             if(Node->Special.Radio.AutoPageID != -1)
  1810.                             {
  1811.                                 *MsgClass = NULL;
  1812.  
  1813.                                 if(!LTP_NotifyPager(Handle,Node->Special.Radio.AutoPageID,Node->Current))
  1814.                                     *MsgClass = IDCMP_CLOSEWINDOW;
  1815.                             }
  1816.  
  1817.                             if(Handle->Previous && !Node->PageSelector)
  1818.                                 Activate = TRUE;
  1819.                         }
  1820.  
  1821.                         break;
  1822.  
  1823.                     case SLIDER_KIND:
  1824.  
  1825.                         if(Node->Min < 0)
  1826.                             Node->Current = (WORD)*MsgCode;
  1827.                         else
  1828.                             Node->Current = *MsgCode;
  1829.  
  1830.                         LTP_PutStorage(Node);
  1831.  
  1832.                         if(Handle->Previous && !Node->PageSelector)
  1833.                             Activate = TRUE;
  1834.  
  1835.                         break;
  1836. #ifdef DO_LEVEL_KIND
  1837.                     case LEVEL_KIND:
  1838.  
  1839.                         *MsgCode    = Node->Current;
  1840.                         *MsgGadget    = Node->Host;
  1841.  
  1842.                         LTP_PutStorage(Node);
  1843.  
  1844.                         break;
  1845. #endif    /* DO_LEVEL_KIND */
  1846.                     case SCROLLER_KIND:
  1847.  
  1848.                         Node->Current = *MsgCode;
  1849.  
  1850.                         LTP_PutStorage(Node);
  1851.  
  1852.                         if(Handle->Previous && !Node->PageSelector)
  1853.                             Activate = TRUE;
  1854.  
  1855.                         break;
  1856.  
  1857.                     case PICKER_KIND:
  1858.  
  1859.                         *MsgClass    = IDCMP_IDCMPUPDATE;
  1860.                         *MsgCode    = 0;
  1861.                         *MsgGadget    = Node->Special.Picker.Parent;
  1862.  
  1863.                         if(Handle->Previous && !Node->PageSelector)
  1864.                             Activate = TRUE;
  1865.  
  1866.                         break;
  1867.  
  1868.                     case INCREMENTER_KIND:
  1869.  
  1870.                         if(((ObjectNode *)Handle->ActiveIncrementer->Special.Incrementer.Parent->UserData)->Type == INTEGER_KIND)
  1871.                         {
  1872.                             *MsgGadget    = Handle->ActiveIncrementer->Special.Incrementer.Parent;
  1873.                             *MsgClass    = IDCMP_GADGETUP;
  1874.                             *MsgCode    = 1;
  1875.                         }
  1876.  
  1877.                         Handle->ActiveIncrementer = NULL;
  1878.                         break;
  1879.  
  1880.                     case LISTVIEW_KIND:
  1881.  
  1882.                         if(Node->Current != *MsgCode || Node != Handle->ClickObject)
  1883.                         {
  1884.                             CurrentTime(&Handle->ClickSeconds,&Handle->ClickMicros);
  1885.  
  1886.                             Handle->ClickObject = Node;
  1887.                         }
  1888.                         else
  1889.                         {
  1890.                             ULONG Seconds,Micros;
  1891.  
  1892.                             CurrentTime(&Seconds,&Micros);
  1893.  
  1894.                             if(DoubleClick(Handle->ClickSeconds,Handle->ClickMicros,Seconds,Micros))
  1895.                                 *MsgClass = IDCMP_IDCMPUPDATE;
  1896.  
  1897.                             Handle->ClickSeconds    = Seconds;
  1898.                             Handle->ClickMicros    = Micros;
  1899.                         }
  1900.  
  1901.                         Node->Current = *MsgCode;
  1902.  
  1903.                         LTP_PutStorage(Node);
  1904.  
  1905.                         if(Node->Special.List.AutoPageID != -1)
  1906.                             *MsgClass = NULL;
  1907.  
  1908.                         if(!LTP_NotifyPager(Handle,Node->Special.List.AutoPageID,Node->Current))
  1909.                             *MsgClass = IDCMP_CLOSEWINDOW;
  1910.  
  1911.                         if(Node->Special.List.Link)
  1912.                         {
  1913.                             Handle->Previous = Node->Special.List.Link;
  1914.  
  1915.                             if(!Node->PageSelector)
  1916.                                 Activate = TRUE;
  1917.                         }
  1918.                         else
  1919.                         {
  1920.                             if(Handle->Previous && !Node->PageSelector)
  1921.                                 Activate = TRUE;
  1922.                         }
  1923.  
  1924.                         break;
  1925.  
  1926.                     default:
  1927.  
  1928.                         if(Handle->Previous && !Node->PageSelector)
  1929.                             Activate = TRUE;
  1930.  
  1931.                         break;
  1932.                 }
  1933.             }
  1934.  
  1935.             break;
  1936.  
  1937.         case IDCMP_MOUSEMOVE:
  1938.  
  1939. #ifdef DO_LEVEL_KIND
  1940.             if(Handle->CurrentLevel)
  1941.                 Node = Handle->CurrentLevel;
  1942.             else
  1943. #endif
  1944.                 GETOBJECT((*MsgGadget),Node);
  1945.  
  1946.             if(Node)
  1947.             {
  1948.                 if(Node->Type != LISTVIEW_KIND)
  1949.                     Handle->ClickSeconds = Handle->ClickMicros = 0;
  1950.  
  1951.                 switch(Node->Type)
  1952.                 {
  1953.                     case SCROLLER_KIND:
  1954.  
  1955.                         Node->Current = *MsgCode;
  1956.  
  1957.                         LTP_PutStorage(Node);
  1958.  
  1959.                         break;
  1960.  
  1961.                     case SLIDER_KIND:
  1962.  
  1963.                         if(Node->Min < 0)
  1964.                             Node->Current = (WORD)*MsgCode;
  1965.                         else
  1966.                             Node->Current = *MsgCode;
  1967.  
  1968.                         LTP_PutStorage(Node);
  1969.  
  1970.                         break;
  1971. #ifdef DO_LEVEL_KIND
  1972.                     case LEVEL_KIND:
  1973.  
  1974.                         *MsgCode    = Node->Current;
  1975.                         *MsgGadget  = Node->Host;
  1976.  
  1977.                         LTP_PutStorage(Node);
  1978.  
  1979.                         break;
  1980. #endif    /* DO_LEVEL_KIND */
  1981.                 }
  1982.             }
  1983.  
  1984.             break;
  1985.  
  1986.         case IDCMP_ACTIVEWINDOW:
  1987.  
  1988.             if(Handle->Previous)
  1989.             {
  1990.                 Activate = TRUE;
  1991.  
  1992.                 *MsgClass    = IDCMP_GADGETDOWN;
  1993.                 *MsgCode    = 0;
  1994.                 *MsgGadget    = Handle->Previous;
  1995.             }
  1996.  
  1997.             break;
  1998.  
  1999.         case IDCMP_INACTIVEWINDOW:
  2000.  
  2001.             Handle->ActiveIncrementer = NULL;
  2002.             Handle->ActiveFrame = NULL;
  2003.             break;
  2004.     }
  2005.  
  2006.     if(Handle->AutoActivate && Activate && Handle->Previous)
  2007.     {
  2008.         if(GETOBJECT(Handle->Previous,Node))
  2009.         {
  2010.             if(!Node->Disabled)
  2011.             {
  2012.                 if(Node->Type == BOOPSI_KIND)
  2013.                 {
  2014.                     if(Node->Special.BOOPSI.ActivateHook)
  2015.                         CallHookPkt(Node->Special.BOOPSI.ActivateHook,(APTR)Handle,(APTR)Node->Host);
  2016.                 }
  2017.                 else
  2018.                     ActivateGadget(Handle->Previous,Handle->Window,NULL);
  2019.             }
  2020.         }
  2021.     }
  2022. }
  2023.