home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 5 / FreshFish_July-August1994.bin / bbs / util / yak-1.59.lha / Yak-1.59 / Src / Help.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-02  |  11.2 KB  |  382 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 "gui.h"
  27. #include "version.h"
  28.  
  29. #define CATCOMP_NUMBERS
  30. #include "locale/yak_locale_strings.h"
  31.  
  32. extern LONG (*HandleIDCMP)(void);
  33.  
  34. struct Window *curwin;
  35.  
  36. /* static protos */
  37. static void InitRootGadgets(void);
  38.  
  39. static __regargs void NewPattern(UWORD gdx, UWORD n, struct Gadget *gad);
  40. BOOL ShowRootWindow(void);
  41. static BOOL SwitchToHotkeyWindow(void);
  42. static BOOL SwitchToMiscWindow(void);
  43. static BOOL SwitchToBlankWindow(void);
  44.  
  45.  
  46. /* menu numbers */
  47. #define LOAD 0
  48. #define SAVE 1
  49. #define HIDE 2
  50. #define QUIT 3
  51.  
  52. /* initialise individual gadget in specified window */
  53. __regargs void
  54. InitWindowGadget(UWORD num, LONG tagtype, LONG tagvalue, UBYTE WindowID)
  55. {
  56.         switch(WindowID)
  57.         {
  58.           case ROOT_WINDOW:
  59.                 GT_SetGadgetAttrs(RootGadgets[num], RootWnd, NULL, tagtype, tagvalue, TAG_DONE);
  60.                 break;
  61.  
  62.           case HOTKEY_WINDOW:
  63.                 GT_SetGadgetAttrs(HotKeyGadgets[num], HotKeyWnd, NULL, tagtype, tagvalue, TAG_DONE);
  64.                 break;
  65.  
  66.           case MISC_WINDOW:
  67.                 GT_SetGadgetAttrs(MiscGadgets[num], MiscWnd, NULL, tagtype, tagvalue, TAG_DONE);
  68.                 break;
  69.  
  70.           case BLANK_WINDOW:
  71.                 GT_SetGadgetAttrs(BlankGadgets[num], BlankWnd, NULL, tagtype, tagvalue, TAG_DONE);
  72.                 break;
  73.           case KEYDEF_WINDOW:
  74.                 GT_SetGadgetAttrs(KeyDefGadgets[num], KeyDefWnd, NULL, tagtype, tagvalue, TAG_DONE);
  75.                 break;
  76.         }
  77. }
  78.  
  79.  
  80. __regargs void
  81. InitToggleGadgets( UBYTE WindowID )
  82. {
  83.         UWORD   i;
  84.  
  85.         for (i = 0; i < NUM_TOGGLES; i++)
  86.                 if ((toggles[i].gadid != -1) &&
  87.                         (toggles[i].winid == WindowID))
  88.                 {
  89.                         InitWindowGadget(toggles[i].gadid,
  90.                                    GTCB_Checked,
  91.                                    toggles[i].pos,
  92.                                    WindowID); 
  93.                 }
  94. }
  95.  
  96.  
  97.  
  98. /* initialise all gadgets */
  99. static void
  100. InitRootGadgets(void)
  101. {
  102.         InitToggleGadgets(ROOT_WINDOW);
  103.  
  104.         InitWindowGadget(GDX_AutoPat, GTST_String, (LONG)patterns[YP_AUTOSCR_PAT].patstr, ROOT_WINDOW);
  105.         InitWindowGadget(GDX_ClickPat, GTST_String, (LONG)patterns[YP_CLICKSCR_PAT].patstr, ROOT_WINDOW);
  106.         InitWindowGadget(GDX_PopPat, GTST_String, (LONG)patterns[YP_POPWIN_PAT].patstr, ROOT_WINDOW);
  107.         InitWindowGadget(GDX_ClickWinPat, GTST_String, (LONG)patterns[YP_CLICKWIN_PAT].patstr, ROOT_WINDOW);
  108.         InitWindowGadget(GDX_ClickWinPat, GTCY_Active, qualifier, ROOT_WINDOW);
  109. }
  110.  
  111.  
  112. /* show current window */
  113. BOOL
  114. ShowYakInterface(void)
  115. {
  116.         
  117.         if (curwin)             /* already opened */
  118.         {
  119.                 ScreenToFront(curwin->WScreen);
  120.                 WindowToFront(curwin);
  121.                 ActivateWindow(curwin);
  122.                 return TRUE;
  123.         }
  124.  
  125.         if (SetupScreen())      
  126.                 return FALSE;
  127.         
  128.         return ShowRootWindow();
  129. }
  130.  
  131.  
  132.  
  133. /* show our Root window */
  134. BOOL
  135. ShowRootWindow(void)
  136. {
  137.     InitGUI ();
  138.  
  139.         if (!OpenRootWindow())  /* like the name says... */
  140.         {
  141.                 InitRootGadgets();
  142.                 wndsigflag = 1 << RootWnd->UserPort->mp_SigBit;
  143.                 HandleIDCMP = HandleRootIDCMP;
  144.                 curwin = RootWnd;
  145.  
  146.                 return TRUE;
  147.         }
  148.         CloseDownScreen();
  149.         return FALSE;
  150. }
  151.  
  152.  
  153. /* update windows position for next openings */
  154. void
  155. UpdateWindowsPosition (void)
  156. {
  157.         RootLeft = curwin->LeftEdge;
  158.         WindowTop = curwin->TopEdge;
  159. }
  160.  
  161.  
  162. /* hide our window */
  163. void
  164. HideInterface(void)
  165. {
  166.         if (curwin)
  167.         {
  168.                 UpdateWindowsPosition();
  169.  
  170.                 if (RootWnd)    
  171.                     CloseRootWindow();
  172.                 else
  173.                     if (MiscWnd)    
  174.                         CloseMiscWindow();
  175.                     else
  176.                         if (HotKeyWnd)  
  177.                             CloseHotKeyWindow();
  178.                         else
  179.                             if (BlankWnd)   
  180.                                 CloseBlankWindow();
  181.                             else
  182.                                 CloseKeyDefWindow();
  183.                 
  184.                 CloseDownScreen();
  185.                 wndsigflag = NULL;
  186.                 curwin = NULL;
  187.         }
  188. }
  189.  
  190. /* switch from Root window to hotkey window */
  191. static BOOL
  192. SwitchToHotkeyWindow(void)
  193. {
  194.         HotKeyLeft = RootWnd->LeftEdge;
  195.         WindowTop = RootWnd->TopEdge;
  196.         CloseRootWindow();
  197.         return ShowHotKeyWindow();
  198. }
  199.  
  200. /* switch from Root window to misc window */
  201. static BOOL
  202. SwitchToMiscWindow(void)
  203. {
  204.         MiscLeft = RootWnd->LeftEdge;
  205.         WindowTop = RootWnd->TopEdge;
  206.         CloseRootWindow();
  207.         return ShowMiscWindow();
  208. }
  209.  
  210. /* switch from Root window to blank window */
  211. static BOOL
  212. SwitchToBlankWindow(void)
  213. {
  214.         BlankLeft = RootWnd->LeftEdge;
  215.         WindowTop = RootWnd->TopEdge;
  216.         CloseRootWindow();
  217.         return ShowBlankWindow();
  218. }       
  219.  
  220.  
  221.  
  222. /* handle pattern string-gadget */
  223. static __regargs void
  224. NewPattern(UWORD gdx, UWORD n, struct Gadget *gad)
  225. {
  226.         char *newpatstr;
  227.  
  228.         newpatstr = GetString(gad);
  229.         if (!InitPattern(newpatstr, n))
  230.         {
  231.                 DisplayBeep(Scr);
  232.                 InitWindowGadget(gdx, GTST_String, (LONG)patterns[n].patstr, ROOT_WINDOW);
  233.         }
  234. }
  235.  
  236.  
  237.  
  238. /* handle Root window events */
  239. LONG
  240. HandleRootIDCMP(void)
  241. {
  242.         struct IntuiMessage *msg;
  243.         struct Gadget   *gadget;
  244.         ULONG           class;
  245.         UWORD           code;
  246.  
  247.         while (msg = GT_GetIMsg(RootWnd->UserPort))
  248.         {
  249.                 class = msg->Class;
  250.                 code = msg->Code;
  251.                 gadget = (struct Gadget *)msg->IAddress;
  252.                 GT_ReplyIMsg(msg);
  253.  
  254.                 switch (class)
  255.                 {
  256.                   case CLOSEWINDOW:
  257.                         HideInterface();
  258.                         return ROOT_OKAY;
  259.  
  260.                   case GADGETUP:
  261.                   case GADGETDOWN:
  262.                         switch (gadget->GadgetID)
  263.                         {
  264.                           case GD_EditHotkeys: 
  265.                                 if (!SwitchToHotkeyWindow())
  266.                                         PostError(getString(Couldnt_open_other_window_ERR));
  267.                                 return ROOT_OKAY;
  268.  
  269.                           case GD_Miscellaneous: 
  270.                                 if (!SwitchToMiscWindow())
  271.                                         PostError(getString(Couldnt_open_other_window_ERR));
  272.                                 return ROOT_OKAY;
  273.  
  274.                           case GD_Blanking:
  275.                                 if (!SwitchToBlankWindow())
  276.                                         PostError(getString(Couldnt_open_other_window_ERR));
  277.                                 return ROOT_OKAY;
  278.  
  279.                           case GD_AutoPat:
  280.                                 NewPattern(GDX_AutoPat, YP_AUTOSCR_PAT, gadget);
  281.                                 break;
  282.  
  283.                           case GD_ClickPat:
  284.                                 NewPattern(GDX_ClickPat, YP_CLICKSCR_PAT, gadget);
  285.                                 break;
  286.  
  287.                           case GD_PopPat:
  288.                                 NewPattern(GDX_PopPat, YP_POPWIN_PAT, gadget);
  289.                                 break;
  290.  
  291.                           case GD_ClickWinPat:
  292.                                 NewPattern(GDX_ClickWinPat, YP_CLICKWIN_PAT, gadget);
  293.                                 break;
  294.  
  295.                           case GD_Hide:
  296.                                 HideInterface();
  297.                                 return ROOT_OKAY;
  298.  
  299.                           case GD_Quit:
  300.                                 HideInterface();
  301.                                 return ROOT_QUIT;
  302.  
  303.                           case GD_AutoCheck: /* toggle */
  304.                                 autopoint ^= TRUE;
  305.                                 break;
  306.  
  307.                           case GD_AutoPopCheck: /* toggle */
  308.                                 autopop ^= TRUE;
  309.                                 break;
  310.  
  311.                           case GD_KeyActCheck: /* toggle */
  312.                                 keyactivate ^= TRUE;
  313.                                 break;
  314.  
  315.                           case GD_CTFCheck:     /* toggle */
  316.                                 clicktofront ^= TRUE;
  317.                                 break;
  318.  
  319.                           case GD_CTBCheck:     /* toggle */
  320.                                 clicktoback ^= TRUE;
  321.                                 break;
  322.  
  323.                           case GD_ScrCycleCheck: /* toggle */
  324.                                 screencycle ^= TRUE;
  325.                                 break;
  326.  
  327.                           case GD_ScrActCheck: /* toggle */
  328.                                 scractivate ^= TRUE;
  329.                                 break;
  330.  
  331.                           case GD_RMBActCheck: /* toggle */
  332.                                 rmbactivate ^= TRUE;
  333.                                 break;
  334.  
  335.                           case GD_MMBActCheck: /* toggle */
  336.                                 mmbactivate ^= TRUE;
  337.                                 break;
  338.  
  339.  
  340.                         }                                       /* switch (gadget->GadgetID) */
  341.                         break;
  342.  
  343.                   case REFRESHWINDOW:
  344.                         GT_BeginRefresh(RootWnd);
  345.                         RootRender();
  346.                         GT_EndRefresh(RootWnd, TRUE);
  347.                         break;
  348.  
  349.                   case IDCMP_MENUPICK:
  350.                         while (code != MENUNULL) 
  351.                         {
  352.                                 struct MenuItem *item = ItemAddress(RootMenus, code);
  353.  
  354.                                 switch (ITEMNUM(code))
  355.                                 {
  356.                                   case LOAD:
  357.                                         LoadSettings();
  358.                                         InitRootGadgets();
  359.                                         break;
  360.                                   case SAVE:
  361.                                         SaveSettings();
  362.                                         break;
  363.                                   case HIDE:
  364.                                         HideInterface();
  365.                                         return ROOT_OKAY;
  366.                                   case QUIT:
  367.                                         HideInterface();
  368.                                         return ROOT_QUIT;
  369.                                 }
  370.                                 code = item->NextSelect;
  371.  
  372.                         }                                       /* while more menuchoices */
  373.                         break;
  374.  
  375.                 }                                               /* switch (class) */
  376.  
  377.         }                                                       /* while more messages */
  378.  
  379.         return ROOT_OKAY;
  380. }
  381.  
  382.