home *** CD-ROM | disk | FTP | other *** search
/ Amiga Elysian Archive / AmigaElysianArchive.iso / commod / yak15a.lha / Yak / Source / help.c < prev    next >
C/C++ Source or Header  |  1993-05-18  |  13KB  |  609 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. static struct Window *curwin;
  30.  
  31. /* static protos */
  32. static void __regargs InitHelpGadget(UWORD num, LONG tagtype, LONG tagvalue);
  33. static void InitHelpGadgets(void);
  34. static void __regargs InitHotKeyGadget(UWORD num, LONG tagtype, LONG tagvalue);
  35. static void InitHotKeyGadgets(void);
  36. static void __regargs NewPattern(UWORD gdx, UWORD n, struct Gadget *gad);
  37. static BOOL ShowHelpWindow(void);
  38. static BOOL ShowHotKeyWindow(void);
  39. static BOOL SwitchWindows(void);
  40. static LONG HandleHelpIDCMP(void);
  41. static LONG HandleHotKeyIDCMP(void);
  42.  
  43.  
  44. /* menu numbers */
  45. #define LOAD 0
  46. #define SAVE 1
  47. #define HIDE 2
  48. #define QUIT 3
  49.  
  50. /* initialise individual gadget in help window */
  51. static void __regargs
  52. InitHelpGadget(UWORD num, LONG tagtype, LONG tagvalue)
  53. {
  54.     GT_SetGadgetAttrs(HelpGadgets[num], HelpWnd, NULL, tagtype, tagvalue, TAG_DONE);
  55. }
  56.  
  57. /* initialise all gadgets */
  58. static void
  59. InitHelpGadgets()
  60. {
  61.     UWORD    i;
  62.  
  63.     for (i = 0; i < NUM_TOGGLES; i++)
  64.         if (toggles[i].gadid != -1)
  65.             InitHelpGadget(toggles[i].gadid,
  66.                    GTCB_Checked,
  67.                    toggles[i].pos); 
  68.  
  69.     InitHelpGadget(GDX_MBMethod, GTCY_Active, mouseblank);
  70.     InitHelpGadget(GDX_ScrTONum, GTIN_Number, blanksecs);
  71.     InitHelpGadget(GDX_MouseTONum, GTIN_Number, mblanksecs);
  72.     InitHelpGadget(GDX_ClickVol, GTIN_Number, click_volume);
  73.     InitHelpGadget(GDX_AutoPat, GTST_String, (LONG)patterns[YP_AUTOSCR_PAT].patstr);
  74.     InitHelpGadget(GDX_ClickPat, GTST_String, (LONG)patterns[YP_CLICKSCR_PAT].patstr);
  75.     InitHelpGadget(GDX_PopPat, GTST_String, (LONG)patterns[YP_POPWIN_PAT].patstr);
  76.     InitHelpGadget(GDX_ClickWinPat, GTST_String, (LONG)patterns[YP_CLICKWIN_PAT].patstr);
  77. }
  78.  
  79. /* show current window */
  80. BOOL
  81. ShowWindow()
  82. {
  83.     WBenchToFront();
  84.     if (curwin)        /* already open... */
  85.     {
  86.         WindowToFront(curwin);
  87.         ActivateWindow(curwin);
  88.         return TRUE;
  89.     }
  90.  
  91.     if (SetupScreen())    /* try to get lock on WB */
  92.         return FALSE;
  93.  
  94.     return ShowHelpWindow();
  95. }
  96.  
  97. /* show our help window */
  98. static BOOL
  99. ShowHelpWindow()
  100. {
  101.     static char    title[80];
  102.  
  103.     strcpy(title, VERSION_NAME ": HotKey = <");
  104.     strcat(title, PopKeyStr);
  105.     strcat(title, ">");
  106.     HelpWdt = title;
  107.  
  108.     if (!OpenHelpWindow())    /* like the name says... */
  109.     {
  110.         InitHelpGadgets();
  111.         wndsigflag = 1 << HelpWnd->UserPort->mp_SigBit;
  112.         curwin = HelpWnd;
  113.         return TRUE;
  114.     }
  115.     CloseDownScreen();
  116.     return FALSE;
  117. }
  118.  
  119. /* show our help window */
  120. static BOOL
  121. ShowHotKeyWindow()
  122. {
  123.     if (!OpenHotKeyWindow())    /* like the name says... */
  124.     {
  125.         InitHotKeyGadgets();
  126.         wndsigflag = 1 << HotKeyWnd->UserPort->mp_SigBit;
  127.         curwin = HotKeyWnd;
  128.         return TRUE;
  129.     }
  130.     CloseDownScreen();
  131.     return FALSE;
  132. }
  133.  
  134. /* hide our window */
  135. void
  136. HideWindow()
  137. {
  138.     if (curwin)
  139.     {
  140.         if (curwin == HelpWnd)
  141.             CloseHelpWindow();
  142.         else
  143.             CloseHotKeyWindow();
  144.  
  145.         CloseDownScreen();
  146.         wndsigflag = NULL;
  147.         curwin = HelpWnd = HotKeyWnd = NULL;
  148.     }
  149. }
  150.  
  151. /* switch between windows */
  152. static BOOL
  153. SwitchWindows()
  154. {
  155.     if (curwin == HelpWnd)
  156.     {
  157.         HelpLeft = HotKeyLeft = HelpWnd->LeftEdge;
  158.         HelpTop = HotKeyTop = HelpWnd->TopEdge;
  159.         CloseHelpWindow();
  160.         return ShowHotKeyWindow();
  161.     } else {
  162.         CloseHotKeyWindow();
  163.         return ShowHelpWindow();
  164.     }
  165. }
  166.  
  167. /* handle pattern string-gadget */
  168. static void __regargs
  169. NewPattern(UWORD gdx, UWORD n, struct Gadget *gad)
  170. {
  171.     char *newpatstr;
  172.  
  173.     newpatstr = GetString(gad);
  174.     if (!InitPattern(newpatstr, n))
  175.     {
  176.         DisplayBeep(Scr);
  177.         InitHelpGadget(gdx, GTST_String, (LONG)patterns[n].patstr);
  178.     }
  179. }
  180.  
  181. /* handle window events */
  182. LONG
  183. HandleIDCMP()
  184. {
  185.     if (curwin == HelpWnd)
  186.         return HandleHelpIDCMP();
  187.     else
  188.         return HandleHotKeyIDCMP();
  189. }
  190.  
  191. /* handle help window events */
  192. static LONG
  193. HandleHelpIDCMP()
  194. {
  195.     struct IntuiMessage *msg;
  196.     struct Gadget   *gadget;
  197.     ULONG           class;
  198.     UWORD        code;
  199.     LONG        num;
  200.  
  201.     while (msg = GT_GetIMsg(HelpWnd->UserPort))
  202.     {
  203.         class = msg->Class;
  204.         code = msg->Code;
  205.         gadget = (struct Gadget *)msg->IAddress;
  206.         GT_ReplyIMsg(msg);
  207.  
  208.         switch (class)
  209.         {
  210.         case CLOSEWINDOW:
  211.             HideWindow();
  212.             return HELP_OKAY;
  213.  
  214.         case GADGETUP:
  215.         case GADGETDOWN:
  216.             switch (gadget->GadgetID)
  217.             {
  218.             case GD_EditHotkeys: 
  219.                 if (!SwitchWindows())
  220.                     PostError("Couldn't open other window");
  221.                 return HELP_OKAY;
  222.  
  223.             case GD_AutoPat:
  224.                 NewPattern(GDX_AutoPat, YP_AUTOSCR_PAT, gadget);
  225.                 break;
  226.  
  227.             case GD_ClickPat:
  228.                 NewPattern(GDX_ClickPat, YP_CLICKSCR_PAT, gadget);
  229.                 break;
  230.  
  231.             case GD_PopPat:
  232.                 NewPattern(GDX_PopPat, YP_POPWIN_PAT, gadget);
  233.                 break;
  234.  
  235.             case GD_ClickWinPat:
  236.                 NewPattern(GDX_ClickWinPat, YP_CLICKWIN_PAT, gadget);
  237.                 break;
  238.  
  239.             case GD_Hide:
  240.                 HideWindow();
  241.                 return HELP_OKAY;
  242.  
  243.             case GD_Quit:
  244.                 HideWindow();
  245.                 return HELP_QUIT;
  246.  
  247.             case GD_AutoCheck:    /* toggle */
  248.                 autopoint ^= TRUE;
  249.                 break;
  250.  
  251.             case GD_AutoPopCheck:    /* toggle */
  252.                 autopop ^= TRUE;
  253.                 break;
  254.  
  255.             case GD_KeyActCheck:    /* toggle */
  256.                 keyactivate ^= TRUE;
  257.                 break;
  258.  
  259.             case GD_CTFCheck:    /* toggle */
  260.                 clicktofront ^= TRUE;
  261.                 break;
  262.  
  263.             case GD_CTBCheck:    /* toggle */
  264.                 clicktoback ^= TRUE;
  265.                 break;
  266.  
  267.             case GD_ScrCycleCheck:    /* toggle */
  268.                 screencycle ^= TRUE;
  269.                 break;
  270.  
  271.             case GD_WildStarCheck:    /* toggle */
  272.                 wildstar ^= TRUE;
  273.                 if (wildstar) WILDSTARON; else WILDSTAROFF;
  274.                 break;
  275.  
  276.             case GD_ScrActCheck:    /* toggle */
  277.                 scractivate ^= TRUE;
  278.                 break;
  279.  
  280.             case GD_RMBActCheck:    /* toggle */
  281.                 rmbactivate ^= TRUE;
  282.                 break;
  283.  
  284.             case GD_ScrTONum:
  285.                 num = GetNumber(gadget);
  286.                 if (num >= 0) {
  287.                     blanksecs = num;
  288.                     blankcount = blanktimeout = blanksecs*10;
  289.                 } else {
  290.                     InitHelpGadget(GDX_ScrTONum, GTIN_Number, blanksecs);
  291.                     DisplayBeep(HelpWnd->WScreen);
  292.                 }
  293.                 break;
  294.  
  295.             case GD_MouseTONum:
  296.                 num = GetNumber(gadget);
  297.                 if (num >= 0) {
  298.                     mblanksecs = num;
  299.                     mblankcount = mblanktimeout = mblanksecs*10;
  300.                 } else {
  301.                     InitHelpGadget(GDX_MouseTONum, GTIN_Number, mblanksecs);
  302.                     DisplayBeep(HelpWnd->WScreen);
  303.                 }
  304.                 break;
  305.  
  306.             case GD_ClickVol:
  307.                 num = GetNumber(gadget);
  308.                 if (num >= 0 && num <= 64) {
  309.                     click_volume = num;
  310.                 } else {
  311.                     InitHelpGadget(GDX_ClickVol, GTIN_Number, click_volume);
  312.                     DisplayBeep(HelpWnd->WScreen);
  313.                 }
  314.                 break;
  315.  
  316.             case GD_MBMethod:
  317.                 mouseblank = code;
  318.                 mblankcount = mblanktimeout;
  319.                 break;
  320.  
  321.             } /* switch (gadget->GadgetID) */
  322.             break;
  323.  
  324.         case REFRESHWINDOW:
  325.             GT_BeginRefresh(HelpWnd);
  326.             HelpRender();
  327.             GT_EndRefresh(HelpWnd, TRUE);
  328.             break;
  329.  
  330.         case IDCMP_MENUPICK:
  331.             while (code != MENUNULL) 
  332.             {
  333.                 struct MenuItem *item = ItemAddress(HelpMenus, code);
  334.  
  335.                 switch (ITEMNUM(code))
  336.                 {
  337.                 case LOAD:
  338.                     LoadSettings();
  339.                     InitHelpGadgets();
  340.                     break;
  341.                 case SAVE:
  342.                     SaveSettings();
  343.                     break;
  344.                 case HIDE:
  345.                     HideWindow();
  346.                     return HELP_OKAY;
  347.                 case QUIT:
  348.                     HideWindow();
  349.                     return HELP_QUIT;
  350.                 }
  351.                 code = item->NextSelect;
  352.  
  353.             } /* while more menuchoices */
  354.             break;
  355.  
  356.         } /* switch (class) */
  357.  
  358.     } /* while more messages */
  359.  
  360.     return HELP_OKAY;
  361. }
  362.  
  363. /*******************************************************************************
  364.  *    HOTKEY SPECIFIC DATA/ROUTINES
  365.  *    perhaps move to another file?
  366.  *******************************************************************************/
  367.  
  368. /* prototypes */
  369. static struct Node *GetNode(struct List *lh, UWORD n);
  370. static UWORD GetNodeNum(struct List *lh, struct Node *node);
  371.  
  372. /* external data */
  373. static YakHotKey    *curhk;
  374. static UWORD        curtype;
  375.  
  376. /* get nth node in list - list MUST have >= n nodes!!! */
  377. static struct Node *
  378. GetNode(struct List *lh, UWORD n)
  379. {
  380.     struct Node *ln;
  381.  
  382.     for (ln = lh->lh_Head; n--; ln = ln->ln_Succ)
  383.         ;
  384.     return ln;
  385. }
  386.  
  387. /* get number of node in list - node MUST be there! */
  388. static UWORD
  389. GetNodeNum(struct List *lh, struct Node *node)
  390. {
  391.     struct Node *ln;
  392.     UWORD i;
  393.  
  394.     for (i = 0, ln = lh->lh_Head; ln != node; ln = ln->ln_Succ, i++)
  395.         ;
  396.     return i;
  397. }
  398.  
  399. /* initialise individual gadget in hotkey window */
  400. static void __regargs
  401. InitHotKeyGadget(UWORD num, LONG tagtype, LONG tagvalue)
  402. {
  403.     GT_SetGadgetAttrs(HotKeyGadgets[num], HotKeyWnd, NULL, tagtype, tagvalue, TAG_DONE);
  404. }
  405.  
  406. /* initialise all gadgets */
  407. static void
  408. InitHotKeyGadgets()
  409. {
  410.     InitHotKeyGadget(GDX_Hotkeys, GTLV_Labels, (LONG)keylist(curtype));
  411.     InitHotKeyGadget(GDX_Actions, GTLV_Selected, curtype);
  412.  
  413.     InitHotKeyGadget(GDX_Delete, GA_Disabled, !curhk);
  414.     InitHotKeyGadget(GDX_HKStr, GA_Disabled, !curhk);
  415.  
  416.     /* something selected */
  417.     if (curhk)
  418.     {
  419.         UWORD n = GetNodeNum(keylist(curtype), (struct Node *)curhk);
  420.  
  421.         if (YHK_Has_Options(curhk))
  422.         {
  423.             InitHotKeyGadget(GDX_Options, GA_Disabled, FALSE);
  424.             InitHotKeyGadget(GDX_Options, GTCY_Active, (LONG)curhk->yhk_Options);
  425.         }
  426.  
  427.         if (YHK_Takes_Arg(curhk))
  428.         {
  429.             InitHotKeyGadget(GDX_Argument, GA_Disabled, FALSE);
  430.             InitHotKeyGadget(GDX_Argument, GTST_String, (LONG)curhk->yhk_ArgStr);
  431.         }
  432.  
  433.         InitHotKeyGadget(GDX_Hotkeys, GTLV_Selected, n);
  434.         InitHotKeyGadget(GDX_Hotkeys, GTLV_Top, n);
  435.         InitHotKeyGadget(GDX_HKStr, GTST_String, (LONG)curhk->yhk_KeyDef);
  436.     }
  437.     else    /* no current hotkey */
  438.     {
  439.         InitHotKeyGadget(GDX_HKStr, GTST_String, (LONG)"");
  440.         InitHotKeyGadget(GDX_Options, GTCY_Active, 0);
  441.         InitHotKeyGadget(GDX_Argument, GTST_String, (LONG)"");
  442.  
  443.         InitHotKeyGadget(GDX_Argument, GA_Disabled, TRUE);
  444.         InitHotKeyGadget(GDX_Options, GA_Disabled, TRUE);
  445.     }
  446. }
  447.  
  448. /* handle hotkey window events */
  449. static LONG
  450. HandleHotKeyIDCMP()
  451. {
  452.     struct IntuiMessage *msg;
  453.     struct Gadget   *gadget;
  454.     ULONG           class;
  455.     UWORD        code;
  456.  
  457.     while (msg = GT_GetIMsg(HotKeyWnd->UserPort))
  458.     {
  459.         class = msg->Class;
  460.         code = msg->Code;
  461.         gadget = (struct Gadget *)msg->IAddress;
  462.         GT_ReplyIMsg(msg);
  463.  
  464.         switch (class)
  465.         {
  466.         case CLOSEWINDOW:
  467.             HideWindow();
  468.             return HELP_OKAY;
  469.  
  470.         case VANILLAKEY:
  471.             switch (code)
  472.             {
  473.             case 'a': case 'A':    /* Add */
  474.                 goto key_a;
  475.  
  476.             case 'd': case 'D':    /* Delete */
  477.                 goto key_d;
  478.  
  479.             case 'r': case 'R':    /* Return... */
  480.                 goto key_r;
  481.  
  482.             case 'c':        /* aCtion */
  483.                 code = curtype+1;
  484.                 if (code == NUM_HOTKEY_TYPES)
  485.                     code = 0;
  486.                 goto key_c;
  487.  
  488.             case 'C':    /* aCtion */
  489.                 code = curtype-1;
  490.                 if (code == (UWORD)(-1))
  491.                     code = NUM_HOTKEY_TYPES-1;
  492.                 goto key_c;
  493.  
  494.             case 'h': case 'H':    /* Hotkey */
  495.                 if (curhk)
  496.                     ActivateGadget(HotKeyGadgets[GDX_HKStr], HotKeyWnd, NULL);
  497.                 else if (numkeys(curtype))
  498.                 {
  499.                     code = 0;
  500.                     goto key_h;
  501.                 }
  502.                 break;
  503.  
  504.             case 't': case 'T':    /* argumenT */
  505.                 if (curhk && YHK_Takes_Arg(curhk))
  506.                     ActivateGadget(HotKeyGadgets[GDX_Argument], HotKeyWnd, NULL);
  507.                 break;
  508.  
  509.             case 'o': case 'O':    /* Options */
  510.                 if (curhk && YHK_Has_Options(curhk))
  511.                 {
  512.                     WORD sign = (code == 'o' ? 1 : -1);
  513.                     WORD newopts = curhk->yhk_Options;
  514.                     newopts += sign;
  515.                     if (newopts == -1)
  516.                         newopts = NUM_OPTIONS-1;
  517.                     else if (newopts == NUM_OPTIONS)
  518.                         newopts = 0;
  519.                     curhk->yhk_Options = newopts;
  520.                     InitHotKeyGadget(GDX_Options, GTCY_Active, (LONG)curhk->yhk_Options);
  521.                 }
  522.                 break;
  523.             }
  524.             break;
  525.  
  526.         case GADGETUP:
  527.         case GADGETDOWN:
  528.             switch (gadget->GadgetID)
  529.             {
  530.             case GD_Hotkeys:
  531.             key_h:    curhk = (YakHotKey *)GetNode(keylist(curtype), code);
  532.                 InitHotKeyGadgets();
  533.                 ActivateGadget(HotKeyGadgets[GDX_HKStr], HotKeyWnd, NULL);
  534.                 break;
  535.  
  536.             case GD_HKStr:
  537.                 if (!curhk)    /* shouldn't happen */
  538.                     break;
  539.                 if (ModifyYHKKeyDef(curhk, GetString(gadget)))
  540.                 {
  541.                     InitHotKeyGadget(GDX_Hotkeys, GTLV_Labels, (LONG)keylist(curtype));
  542.                     if (YHK_Takes_Arg(curhk))
  543.                         ActivateGadget(HotKeyGadgets[GDX_Argument], HotKeyWnd, NULL);
  544.  
  545.                 }
  546.                 else
  547.                 {
  548.                     InitHotKeyGadgets();
  549.                     ActivateGadget(HotKeyGadgets[GDX_HKStr], HotKeyWnd, NULL);
  550.                 }
  551.                 break;
  552.  
  553.             case GD_Argument:
  554.                 if (!curhk)    /* shouldn't happen */
  555.                     break;
  556.                 if (!(ModifyYHKArgStr(curhk, GetString(gadget))))
  557.                     InitHotKeyGadgets();
  558.                 break;
  559.  
  560.             case GD_Actions:
  561.             key_c:    if (code != curtype)
  562.                 {
  563.                     curtype = code;
  564.                     curhk = NULL;
  565.                     InitHotKeyGadgets();
  566.                 }
  567.                 break;
  568.  
  569.             case GD_Options:
  570.                 if (curhk)
  571.                     curhk->yhk_Options = code;
  572.                 break;
  573.  
  574.             case GD_Add:
  575.             key_a:    curhk = NewYakHotKey(curtype);
  576.                 InitHotKeyGadgets();
  577.                 ActivateGadget(HotKeyGadgets[GDX_HKStr], HotKeyWnd, NULL);
  578.                 break;
  579.  
  580.             case GD_Delete:
  581.             key_d:    if (curhk)
  582.                 {
  583.                     DeleteYakHotKey(curhk);
  584.                     curhk = NULL;
  585.                     InitHotKeyGadgets();
  586.                 }
  587.                 break;
  588.  
  589.             case GD_Return:
  590.             key_r:    curhk = NULL;    /* in case of reloading */
  591.                 if (!SwitchWindows())
  592.                     PostError("Couldn't open other window");
  593.                 return HELP_OKAY;
  594.  
  595.             } /* switch (gadget->GadgetID) */
  596.             break;
  597.  
  598.         case REFRESHWINDOW:
  599.             GT_BeginRefresh(HotKeyWnd);
  600.             GT_EndRefresh(HotKeyWnd, TRUE);
  601.             break;
  602.  
  603.         } /* switch (class) */
  604.  
  605.     } /* while more messages */
  606.  
  607.     return HELP_OKAY;
  608. }
  609.