home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d9xx / d971 / yak.lha / Yak / Source / help.c < prev    next >
C/C++ Source or Header  |  1993-12-21  |  15KB  |  693 lines
  1. /*
  2.  * help.c
  3.  * 
  4.  * Opens help/settings window and handles events.
  5.  * For yak.
  6.  * 
  7.  * Martin W. Scott, 12-Sep-92.
  8.  */
  9. #include <exec/types.h>
  10. #include <dos/dosextens.h>
  11. #include <graphics/gfxmacros.h>
  12. #include <libraries/commodities.h>
  13. #include <intuition/gadgetclass.h>
  14. #include <intuition/intuition.h>
  15. #include <libraries/gadtools.h>
  16. #include <proto/exec.h>
  17. #include <proto/dos.h>
  18. #include <proto/intuition.h>
  19. #include <proto/gadtools.h>
  20. #include <proto/graphics.h>
  21. #include <proto/commodities.h>
  22. #include <string.h>
  23.  
  24. #include "yak.h"
  25. #include "hotkey_types.h"
  26. #include "popup.h"
  27. #include "version.h"
  28.  
  29. #define CATCOMP_NUMBERS
  30. #include "yak_locale_strings.h"
  31.  
  32. static struct Window *curwin;
  33.  
  34. /* static protos */
  35. static void __regargs InitHelpGadget(UWORD num, LONG tagtype, LONG tagvalue);
  36. static void InitHelpGadgets(void);
  37. static void __regargs InitHotKeyGadget(UWORD num, LONG tagtype, LONG tagvalue);
  38. static void InitHotKeyGadgets(void);
  39. static void __regargs InitMiscGadget(UWORD num, LONG tagtype, LONG tagvalue);
  40. static void InitMiscGadgets(void);
  41. static void __regargs NewPattern(UWORD gdx, UWORD n, struct Gadget *gad);
  42. static BOOL ShowHelpWindow(void);
  43. static BOOL ShowHotKeyWindow(void);
  44. static BOOL ShowMiscWindow(void);
  45. static BOOL SwitchToHotkeyWindow(void);
  46. static BOOL SwitchToMiscWindow(void);
  47. static LONG HandleHelpIDCMP(void);
  48. static LONG HandleHotKeyIDCMP(void);
  49. static LONG HandleMiscIDCMP(void);
  50.  
  51.  
  52. /* menu numbers */
  53. #define LOAD 0
  54. #define SAVE 1
  55. #define HIDE 2
  56. #define QUIT 3
  57.  
  58. /* initialise individual gadget in help window */
  59. static void __regargs
  60. InitHelpGadget(UWORD num, LONG tagtype, LONG tagvalue)
  61. {
  62.     GT_SetGadgetAttrs(HelpGadgets[num], HelpWnd, NULL, tagtype, tagvalue, TAG_DONE);
  63. }
  64.  
  65. /* initialise all gadgets */
  66. static void
  67. InitHelpGadgets(void)
  68. {
  69.     UWORD    i;
  70.  
  71.     for (i = 0; i < NUM_TOGGLES; i++)
  72.         if (toggles[i].gadid != -1)
  73.             InitHelpGadget(toggles[i].gadid,
  74.                    GTCB_Checked,
  75.                    toggles[i].pos); 
  76.  
  77.     InitHelpGadget(GDX_ScrTONum, GTIN_Number, blanksecs);
  78.     InitHelpGadget(GDX_MouseTONum, GTIN_Number, mblanksecs);
  79.     InitHelpGadget(GDX_AutoPat, GTST_String, (LONG)patterns[YP_AUTOSCR_PAT].patstr);
  80.     InitHelpGadget(GDX_ClickPat, GTST_String, (LONG)patterns[YP_CLICKSCR_PAT].patstr);
  81.     InitHelpGadget(GDX_PopPat, GTST_String, (LONG)patterns[YP_POPWIN_PAT].patstr);
  82.     InitHelpGadget(GDX_ClickWinPat, GTST_String, (LONG)patterns[YP_CLICKWIN_PAT].patstr);
  83.     InitHelpGadget(GDX_ClickWinPat, GTCY_Active, qualifier);
  84. }
  85.  
  86. /* show current window */
  87. BOOL
  88. ShowWindow(void)
  89. {
  90.     
  91.     if (curwin)        /* already opened */
  92.     {
  93.         ScreenToFront(curwin->WScreen);
  94.         WindowToFront(curwin);
  95.         ActivateWindow(curwin);
  96.         return TRUE;
  97.     }
  98.  
  99.     if (SetupScreen())    
  100.         return FALSE;
  101.     
  102.     return ShowHelpWindow();
  103. }
  104.  
  105.  
  106.  
  107. /* show our help window */
  108. static BOOL
  109. ShowHelpWindow(void)
  110. {
  111.     InitGUI ();
  112.  
  113.     if (!OpenHelpWindow())    /* like the name says... */
  114.     {
  115.         InitHelpGadgets();
  116.         wndsigflag = 1 << HelpWnd->UserPort->mp_SigBit;
  117.         curwin = HelpWnd;
  118.         return TRUE;
  119.     }
  120.     CloseDownScreen();
  121.     return FALSE;
  122. }
  123.  
  124. /* show our hotkey window */
  125. static BOOL
  126. ShowHotKeyWindow(void)
  127. {
  128.     if (!OpenHotKeyWindow())    /* like the name says... */
  129.     {
  130.         InitHotKeyGadgets();
  131.         wndsigflag = 1 << HotKeyWnd->UserPort->mp_SigBit;
  132.         curwin = HotKeyWnd;
  133.         return TRUE;
  134.     }
  135.     CloseDownScreen();
  136.     return FALSE;
  137. }
  138.  
  139. /* show our misc window */
  140. static BOOL
  141. ShowMiscWindow(void)
  142. {
  143.     if (!OpenMiscWindow())    /* like the name says... */
  144.     {
  145.         InitMiscGadgets();
  146.         wndsigflag = 1 << MiscWnd->UserPort->mp_SigBit;
  147.         curwin = MiscWnd;
  148.         return TRUE;
  149.     }
  150.     CloseDownScreen();
  151.     return FALSE;
  152. }
  153.  
  154.  
  155. /* update windows position for next openings */
  156. void
  157. UpdateWindowsPosition (void)
  158. {
  159.     HelpLeft = curwin->LeftEdge;
  160.     WindowTop = curwin->TopEdge;
  161. }
  162.  
  163.  
  164. /* hide our window */
  165. void
  166. HideWindow(void)
  167. {
  168.     if (curwin)
  169.     {
  170.         UpdateWindowsPosition();
  171.         if (curwin == HelpWnd)
  172.             CloseHelpWindow();
  173.         else
  174.             if (curwin == MiscWnd)
  175.                 CloseMiscWindow();
  176.             else
  177.                 CloseHotKeyWindow();
  178.         
  179.         CloseDownScreen();
  180.         wndsigflag = NULL;
  181.         curwin = HelpWnd = HotKeyWnd = MiscWnd = NULL;
  182.     }
  183. }
  184.  
  185. /* switch from help window to hotkey window */
  186. static BOOL
  187. SwitchToHotkeyWindow(void)
  188. {
  189.         HotKeyLeft = HelpWnd->LeftEdge;
  190.         WindowTop = HelpWnd->TopEdge;
  191.         CloseHelpWindow();
  192.         return ShowHotKeyWindow();
  193. }
  194.  
  195. /* switch from help window to misc window */
  196. static BOOL
  197. SwitchToMiscWindow(void)
  198. {
  199.         MiscLeft = HelpWnd->LeftEdge;
  200.         WindowTop = HelpWnd->TopEdge;
  201.         CloseHelpWindow();
  202.         return ShowMiscWindow();
  203. }
  204.  
  205.  
  206.  
  207. /* handle pattern string-gadget */
  208. static void __regargs
  209. NewPattern(UWORD gdx, UWORD n, struct Gadget *gad)
  210. {
  211.     char *newpatstr;
  212.  
  213.     newpatstr = GetString(gad);
  214.     if (!InitPattern(newpatstr, n))
  215.     {
  216.         DisplayBeep(Scr);
  217.         InitHelpGadget(gdx, GTST_String, (LONG)patterns[n].patstr);
  218.     }
  219. }
  220.  
  221. /* handle window events */
  222. LONG
  223. HandleIDCMP(void)
  224. {
  225.     if (curwin == HelpWnd)
  226.         return HandleHelpIDCMP();
  227.     else    
  228.         if (curwin == MiscWnd)
  229.             return HandleMiscIDCMP();
  230.         else
  231.         return HandleHotKeyIDCMP();
  232. }
  233.  
  234. /* handle help window events */
  235. static LONG
  236. HandleHelpIDCMP(void)
  237. {
  238.     struct IntuiMessage *msg;
  239.     struct Gadget   *gadget;
  240.     ULONG           class;
  241.     UWORD        code;
  242.     LONG        num;
  243.  
  244.     while (msg = GT_GetIMsg(HelpWnd->UserPort))
  245.     {
  246.         class = msg->Class;
  247.         code = msg->Code;
  248.         gadget = (struct Gadget *)msg->IAddress;
  249.         GT_ReplyIMsg(msg);
  250.  
  251.         switch (class)
  252.         {
  253.         case CLOSEWINDOW:
  254.             HideWindow();
  255.             return HELP_OKAY;
  256.  
  257.         case GADGETUP:
  258.         case GADGETDOWN:
  259.             switch (gadget->GadgetID)
  260.             {
  261.             case GD_EditHotkeys: 
  262.                 if (!SwitchToHotkeyWindow())
  263.                     PostError(getString(Couldnt_open_other_window_ERR));
  264.                 return HELP_OKAY;
  265.  
  266.             case GD_Miscellaneous: 
  267.                 if (!SwitchToMiscWindow())
  268.                     PostError(getString(Couldnt_open_other_window_ERR));
  269.                 return HELP_OKAY;
  270.  
  271.             case GD_AutoPat:
  272.                 NewPattern(GDX_AutoPat, YP_AUTOSCR_PAT, gadget);
  273.                 break;
  274.  
  275.             case GD_ClickPat:
  276.                 NewPattern(GDX_ClickPat, YP_CLICKSCR_PAT, gadget);
  277.                 break;
  278.  
  279.             case GD_PopPat:
  280.                 NewPattern(GDX_PopPat, YP_POPWIN_PAT, gadget);
  281.                 break;
  282.  
  283.             case GD_ClickWinPat:
  284.                 NewPattern(GDX_ClickWinPat, YP_CLICKWIN_PAT, gadget);
  285.                 break;
  286.  
  287.             case GD_Hide:
  288.                 HideWindow();
  289.                 return HELP_OKAY;
  290.  
  291.             case GD_Quit:
  292.                 HideWindow();
  293.                 return HELP_QUIT;
  294.  
  295.             case GD_AutoCheck:    /* toggle */
  296.                 autopoint ^= TRUE;
  297.                 break;
  298.  
  299.             case GD_AutoPopCheck:    /* toggle */
  300.                 autopop ^= TRUE;
  301.                 break;
  302.  
  303.             case GD_KeyActCheck:    /* toggle */
  304.                 keyactivate ^= TRUE;
  305.                 break;
  306.  
  307.             case GD_CTFCheck:    /* toggle */
  308.                 clicktofront ^= TRUE;
  309.                 break;
  310.  
  311.             case GD_CTBCheck:    /* toggle */
  312.                 clicktoback ^= TRUE;
  313.                 break;
  314.  
  315.             case GD_ScrCycleCheck:    /* toggle */
  316.                 screencycle ^= TRUE;
  317.                 break;
  318.  
  319.             case GD_WildStarCheck:    /* toggle */
  320.                 wildstar ^= TRUE;
  321.                 if (wildstar) WILDSTARON; else WILDSTAROFF;
  322.                 break;
  323.  
  324.             case GD_NoClickCheck:    /* toggle */
  325.                 noclick ^= TRUE;
  326.                 SetClickDrive(noclick);
  327.                 break;
  328.  
  329.             case GD_ScrActCheck:    /* toggle */
  330.                 scractivate ^= TRUE;
  331.                 break;
  332.  
  333.             case GD_RMBActCheck:    /* toggle */
  334.                 rmbactivate ^= TRUE;
  335.                 break;
  336.  
  337.             case GD_MMBActCheck:    /* toggle */
  338.                 mmbactivate ^= TRUE;
  339.                 break;
  340.  
  341.             case GD_ScrTONum:
  342.                 num = GetNumber(gadget);
  343.                 if (num >= 0) {
  344.                     blanksecs = num;
  345.                     blankcount = blanktimeout = blanksecs*10;
  346.                 } else {
  347.                     InitHelpGadget(GDX_ScrTONum, GTIN_Number, blanksecs);
  348.                     DisplayBeep(HelpWnd->WScreen);
  349.                 }
  350.                 break;
  351.  
  352.             case GD_MouseTONum:
  353.                 num = GetNumber(gadget);
  354.                 if (num >= 0) {
  355.                     mblanksecs = num;
  356.                     mblankcount = mblanktimeout = mblanksecs*10;
  357.                 } else {
  358.                     InitHelpGadget(GDX_MouseTONum, GTIN_Number, mblanksecs);
  359.                     DisplayBeep(HelpWnd->WScreen);
  360.                 }
  361.                 break;
  362.  
  363.             } /* switch (gadget->GadgetID) */
  364.             break;
  365.  
  366.         case REFRESHWINDOW:
  367.             GT_BeginRefresh(HelpWnd);
  368.             HelpRender();
  369.             GT_EndRefresh(HelpWnd, TRUE);
  370.             break;
  371.  
  372.         case IDCMP_MENUPICK:
  373.             while (code != MENUNULL) 
  374.             {
  375.                 struct MenuItem *item = ItemAddress(HelpMenus, code);
  376.  
  377.                 switch (ITEMNUM(code))
  378.                 {
  379.                 case LOAD:
  380.                     LoadSettings();
  381.                     InitHelpGadgets();
  382.                     break;
  383.                 case SAVE:
  384.                     SaveSettings();
  385.                     break;
  386.                 case HIDE:
  387.                     HideWindow();
  388.                     return HELP_OKAY;
  389.                 case QUIT:
  390.                     HideWindow();
  391.                     return HELP_QUIT;
  392.                 }
  393.                 code = item->NextSelect;
  394.  
  395.             } /* while more menuchoices */
  396.             break;
  397.  
  398.         } /* switch (class) */
  399.  
  400.     } /* while more messages */
  401.  
  402.     return HELP_OKAY;
  403. }
  404.  
  405. /*******************************************************************************
  406.  *    HOTKEY SPECIFIC DATA/ROUTINES
  407.  *    perhaps move to another file?
  408.  *******************************************************************************/
  409.  
  410. /* prototypes */
  411. static struct Node *GetNode(struct List *lh, UWORD n);
  412. static UWORD GetNodeNum(struct List *lh, struct Node *node);
  413.  
  414. /* external data */
  415. static YakHotKey    *curhk;
  416. static UWORD        curtype;
  417.  
  418. /* get nth node in list - list MUST have >= n nodes!!! */
  419. static struct Node *
  420. GetNode(struct List *lh, UWORD n)
  421. {
  422.     struct Node *ln;
  423.  
  424.     for (ln = lh->lh_Head; n--; ln = ln->ln_Succ)
  425.         ;
  426.     return ln;
  427. }
  428.  
  429. /* get number of node in list - node MUST be there! */
  430. static UWORD
  431. GetNodeNum(struct List *lh, struct Node *node)
  432. {
  433.     struct Node *ln;
  434.     UWORD i;
  435.  
  436.     for (i = 0, ln = lh->lh_Head; ln != node; ln = ln->ln_Succ, i++)
  437.         ;
  438.     return i;
  439. }
  440.  
  441. /* initialise individual gadget in hotkey window */
  442. static void __regargs
  443. InitHotKeyGadget(UWORD num, LONG tagtype, LONG tagvalue)
  444. {
  445.     GT_SetGadgetAttrs(HotKeyGadgets[num], HotKeyWnd, NULL, tagtype, tagvalue, TAG_DONE);
  446. }
  447.  
  448. /* initialise all gadgets of hotkey window */
  449. static void
  450. InitHotKeyGadgets(void)
  451. {
  452.     InitHotKeyGadget(GDX_Hotkeys, GTLV_Labels, (LONG)keylist(curtype));
  453.     InitHotKeyGadget(GDX_Actions, GTLV_Selected, curtype);
  454.  
  455.     InitHotKeyGadget(GDX_Delete, GA_Disabled, !curhk);
  456.     InitHotKeyGadget(GDX_HKStr, GA_Disabled, !curhk);
  457.  
  458.     /* something selected */
  459.     if (curhk)
  460.     {
  461.         UWORD n = GetNodeNum(keylist(curtype), (struct Node *)curhk);
  462.  
  463.         if (YHK_Has_Options(curhk))
  464.         {
  465.             InitHotKeyGadget(GDX_Options, GA_Disabled, FALSE);
  466.             InitHotKeyGadget(GDX_Options, GTCY_Active, (LONG)curhk->yhk_Options);
  467.         }
  468.  
  469.         if (YHK_Takes_Arg(curhk))
  470.         {
  471.             InitHotKeyGadget(GDX_Argument, GA_Disabled, FALSE);
  472.             InitHotKeyGadget(GDX_Argument, GTST_String, (LONG)curhk->yhk_ArgStr);
  473.         }
  474.  
  475.         InitHotKeyGadget(GDX_Hotkeys, GTLV_Selected, n);
  476.         InitHotKeyGadget(GDX_Hotkeys, GTLV_Top, n);
  477.         InitHotKeyGadget(GDX_HKStr, GTST_String, (LONG)curhk->yhk_KeyDef);
  478.     }
  479.     else    /* no current hotkey */
  480.     {
  481.         InitHotKeyGadget(GDX_HKStr, GTST_String, (LONG)"");
  482.         InitHotKeyGadget(GDX_Options, GTCY_Active, 0);
  483.         InitHotKeyGadget(GDX_Argument, GTST_String, (LONG)"");
  484.  
  485.         InitHotKeyGadget(GDX_Argument, GA_Disabled, TRUE);
  486.         InitHotKeyGadget(GDX_Options, GA_Disabled, TRUE);
  487.     }
  488. }
  489.  
  490.  
  491.  
  492. /* handle hotkey window events */
  493. static LONG
  494. HandleHotKeyIDCMP(void)
  495. {
  496.     struct IntuiMessage *msg;
  497.     struct Gadget   *gadget;
  498.     ULONG           class;
  499.     UWORD        code;
  500.  
  501.     while (msg = GT_GetIMsg(HotKeyWnd->UserPort))
  502.     {
  503.         class = msg->Class;
  504.         code = msg->Code;
  505.         gadget = (struct Gadget *)msg->IAddress;
  506.         GT_ReplyIMsg(msg);
  507.  
  508.         switch (class)
  509.         {
  510.         case CLOSEWINDOW:
  511.             HideWindow();
  512.             return HELP_OKAY;
  513.  
  514.         case GADGETUP:
  515.         case GADGETDOWN:
  516.             switch (gadget->GadgetID)
  517.             {
  518.             case GD_Hotkeys:
  519.                 curhk = (YakHotKey *)GetNode(keylist(curtype), code);
  520.                 InitHotKeyGadgets();
  521.                 ActivateGadget(HotKeyGadgets[GDX_HKStr], HotKeyWnd, NULL);
  522.                 break;
  523.  
  524.             case GD_HKStr:
  525.                 if (!curhk)    /* shouldn't happen */
  526.                     break;
  527.                 if (ModifyYHKKeyDef(curhk, GetString(gadget)))
  528.                 {
  529.                     InitHotKeyGadget(GDX_Hotkeys, GTLV_Labels, (LONG)keylist(curtype));
  530.                     if (YHK_Takes_Arg(curhk))
  531.                         ActivateGadget(HotKeyGadgets[GDX_Argument], HotKeyWnd, NULL);
  532.  
  533.                 }
  534.                 else
  535.                 {
  536.                     InitHotKeyGadgets();
  537.                     ActivateGadget(HotKeyGadgets[GDX_HKStr], HotKeyWnd, NULL);
  538.                 }
  539.                 break;
  540.  
  541.             case GD_Argument:
  542.                 if (!curhk)    /* shouldn't happen */
  543.                     break;
  544.                 if (!(ModifyYHKArgStr(curhk, GetString(gadget))))
  545.                     InitHotKeyGadgets();
  546.                 break;
  547.  
  548.             case GD_Actions:
  549.                 if (code != curtype)
  550.                 {
  551.                     curtype = code;
  552.                     curhk = NULL;
  553.                     InitHotKeyGadgets();
  554.                 }
  555.                 break;
  556.  
  557.             case GD_Options:
  558.                 if (curhk)
  559.                     curhk->yhk_Options = code;
  560.                 break;
  561.  
  562.             case GD_Add:
  563.                 curhk = NewYakHotKey(curtype);
  564.                 InitHotKeyGadgets();
  565.                 ActivateGadget(HotKeyGadgets[GDX_HKStr], HotKeyWnd, NULL);
  566.                 break;
  567.  
  568.             case GD_Delete:
  569.                 if (curhk)
  570.                 {
  571.                     DeleteYakHotKey(curhk);
  572.                     curhk = NULL;
  573.                     InitHotKeyGadgets();
  574.                 }
  575.                 break;
  576.  
  577.             case GD_Return:
  578.                 curhk = NULL;    /* in case of reloading */
  579.                 UpdateWindowsPosition();
  580.                 CloseHotKeyWindow();
  581.                 if (!ShowHelpWindow())
  582.                     PostError(getString(Couldnt_open_other_window_ERR));
  583.                 return HELP_OKAY;
  584.  
  585.             } /* switch (gadget->GadgetID) */
  586.             break;
  587.  
  588.         case REFRESHWINDOW:
  589.             GT_BeginRefresh(HotKeyWnd);
  590.             GT_EndRefresh(HotKeyWnd, TRUE);
  591.             break;
  592.  
  593.         } /* switch (class) */
  594.  
  595.     } /* while more messages */
  596.  
  597.     return HELP_OKAY;
  598. }
  599.  
  600.  
  601. /* initialise individual gadget in misc window */
  602. static void __regargs
  603. InitMiscGadget(UWORD num, LONG tagtype, LONG tagvalue)
  604. {
  605.     GT_SetGadgetAttrs(MiscGadgets[num], MiscWnd, NULL, tagtype, tagvalue, TAG_DONE);
  606. }
  607.  
  608. /* initialise all gadgets of Misc window */
  609. static void
  610. InitMiscGadgets(void)
  611. {
  612.     InitMiscGadget(GDX_MBMethod, GTCY_Active, mouseblank);
  613.     InitMiscGadget(GDX_ClickVol, GTIN_Number, click_volume);
  614.     InitMiscGadget(GDX_AutoPointDelay, GTIN_Number, autopoint_delay);
  615. }
  616.  
  617.  
  618. /* handle Misc window events */
  619. static LONG
  620. HandleMiscIDCMP(void)
  621. {
  622.     struct IntuiMessage *msg;
  623.     struct Gadget   *gadget;
  624.     ULONG           class;
  625.     UWORD        code;
  626.     LONG        num;
  627.  
  628.     while (msg = GT_GetIMsg(MiscWnd->UserPort))
  629.     {
  630.         class = msg->Class;
  631.         code = msg->Code;
  632.         gadget = (struct Gadget *)msg->IAddress;
  633.         GT_ReplyIMsg(msg);
  634.  
  635.         switch (class)
  636.         {
  637.         case CLOSEWINDOW:
  638.             HideWindow();
  639.             return HELP_OKAY;
  640.  
  641.         case GADGETUP:
  642.         case GADGETDOWN:
  643.             switch (gadget->GadgetID)
  644.             {
  645.             case GD_Return2:
  646.                 UpdateWindowsPosition();
  647.                 CloseMiscWindow();
  648.                 if (!ShowHelpWindow())
  649.                     PostError(getString(Couldnt_open_other_window_ERR));
  650.                 return HELP_OKAY;
  651.  
  652.             case GD_ClickVol:
  653.                 num = GetNumber(gadget);
  654.                 if (num >= 0 && num <= 64) {
  655.                     click_volume = num;
  656.                 } else {
  657.                     InitHelpGadget(GDX_ClickVol, GTIN_Number, click_volume);
  658.                     DisplayBeep(HelpWnd->WScreen);
  659.                 }
  660.                 break;
  661.  
  662.             case GD_AutoPointDelay:
  663.                 num = GetNumber(gadget);
  664.                 if (num >= 0 && num <= 5) {
  665.                     autopoint_delay = num;
  666.                 } else {
  667.                     InitHelpGadget(GDX_AutoPointDelay, GTIN_Number, autopoint_delay);
  668.                     DisplayBeep(MiscWnd->WScreen);
  669.                 }
  670.                 break;
  671.  
  672.  
  673.             case GD_MBMethod:
  674.                 mouseblank = code;
  675.                 mblankcount = mblanktimeout;
  676.                 break;
  677.  
  678.             } /* switch (gadget->GadgetID) */
  679.             break;
  680.  
  681.         case REFRESHWINDOW:
  682.             GT_BeginRefresh(MiscWnd);
  683.             GT_EndRefresh(MiscWnd, TRUE);
  684.             break;
  685.  
  686.         } /* switch (class) */
  687.  
  688.     } /* while more messages */
  689.  
  690.     return HELP_OKAY;
  691. }
  692.     
  693.