home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD1.bin / new / util / cdity / yak / src / help.c < prev    next >
C/C++ Source or Header  |  1994-10-05  |  12KB  |  393 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. }
  109.  
  110.  
  111. /* show current window */
  112. BOOL
  113. ShowYakInterface(void)
  114. {
  115.         
  116.         if (curwin)             /* already opened */
  117.         {
  118.                 ScreenToFront(curwin->WScreen);
  119.                 WindowToFront(curwin);
  120.                 ActivateWindow(curwin);
  121.                 return TRUE;
  122.         }
  123.  
  124.         if (SetupScreen())      
  125.                 return FALSE;
  126.         
  127.         return ShowRootWindow();
  128. }
  129.  
  130.  
  131.  
  132. /* show our Root window */
  133. BOOL
  134. ShowRootWindow(void)
  135. {
  136.     InitGUI ();
  137.  
  138.         if (!OpenRootWindow())  /* like the name says... */
  139.         {
  140.                 InitRootGadgets();
  141.                 wndsigflag = 1 << RootWnd->UserPort->mp_SigBit;
  142.                 HandleIDCMP = HandleRootIDCMP;
  143.                 curwin = RootWnd;
  144.  
  145.                 return TRUE;
  146.         }
  147.  
  148.     FreeGadgets(RootGList);
  149.     FreeMenus(RootMenus);
  150.     CloseDownScreen();
  151.     curwin =  NULL;
  152.     wndsigflag = 0L;
  153.     return FALSE;
  154.  
  155. }
  156.  
  157.  
  158. /* update windows position for next openings */
  159. void
  160. UpdateWindowsPosition (void)
  161. {
  162.         RootLeft = curwin->LeftEdge;
  163.         WindowTop = curwin->TopEdge;
  164. }
  165.  
  166.  
  167. /* hide our window */
  168. void
  169. HideInterface(void)
  170. {
  171.         if (curwin)
  172.         {
  173.                 UpdateWindowsPosition();
  174.  
  175.                 if (RootWnd)    
  176.                     CloseRootWindow();
  177.                 else
  178.                     if (MiscWnd)    
  179.                         CloseMiscWindow();
  180.                     else
  181.                         if (HotKeyWnd)  
  182.                             CloseHotKeyWindow();
  183.                         else
  184.                             if (BlankWnd)   
  185.                                 CloseBlankWindow();
  186.                             else
  187.                                 CloseKeyDefWindow();
  188.                 
  189.                 CloseDownScreen();
  190.                 wndsigflag = NULL;
  191.                 curwin = NULL;
  192.         }
  193. }
  194.  
  195.  
  196. /* switch from Root window to hotkey window */
  197. static BOOL
  198. SwitchToHotkeyWindow(void)
  199. {
  200.     
  201.         HotKeyLeft = RootWnd->LeftEdge;
  202.         WindowTop = RootWnd->TopEdge;
  203.         CloseRootWindow();
  204.         return ShowHotKeyWindow();
  205. }
  206.  
  207. /* switch from Root window to misc window */
  208. static BOOL
  209. SwitchToMiscWindow(void)
  210. {
  211.         MiscLeft = RootWnd->LeftEdge;
  212.         WindowTop = RootWnd->TopEdge;
  213.         CloseRootWindow();
  214.         return ShowMiscWindow();
  215. }
  216.  
  217. /* switch from Root window to blank window */
  218. static BOOL
  219. SwitchToBlankWindow(void)
  220. {
  221.         BlankLeft = RootWnd->LeftEdge;
  222.         WindowTop = RootWnd->TopEdge;
  223.         CloseRootWindow();
  224.         return ShowBlankWindow();
  225. }       
  226.  
  227.  
  228.  
  229. /* handle pattern string-gadget */
  230. static __regargs void
  231. NewPattern(UWORD gdx, UWORD n, struct Gadget *gad)
  232. {
  233.         char *newpatstr;
  234.  
  235.         newpatstr = GetString(gad);
  236.         if (!InitPattern(newpatstr, n))
  237.         {
  238.                 DisplayBeep(Scr);
  239.                 InitWindowGadget(gdx, GTST_String, (LONG)patterns[n].patstr, ROOT_WINDOW);
  240.         }
  241. }
  242.  
  243.  
  244.  
  245. /* handle Root window events */
  246. LONG
  247. HandleRootIDCMP(void)
  248. {
  249.         struct IntuiMessage *msg;
  250.         struct Gadget   *gadget;
  251.         ULONG           class;
  252.         UWORD           code;
  253.  
  254.         while (msg = GT_GetIMsg(RootWnd->UserPort))
  255.         {
  256.                 class = msg->Class;
  257.                 code = msg->Code;
  258.                 gadget = (struct Gadget *)msg->IAddress;
  259.                 GT_ReplyIMsg(msg);
  260.  
  261.                 switch (class)
  262.                 {
  263.                   case CLOSEWINDOW:
  264.                         HideInterface();
  265.                         return ROOT_OKAY;
  266.  
  267.                   case GADGETUP:
  268.                   case GADGETDOWN:
  269.                         switch (gadget->GadgetID)
  270.                         {
  271.                           case GD_EditHotkeys: 
  272.                                 if (!SwitchToHotkeyWindow())
  273.                                         PostError(getString(Couldnt_open_other_window_ERR));
  274.                                 return ROOT_OKAY;
  275.  
  276.                           case GD_Miscellaneous: 
  277.                                 if (!SwitchToMiscWindow())
  278.                                         PostError(getString(Couldnt_open_other_window_ERR));
  279.                                 return ROOT_OKAY;
  280.  
  281.                           case GD_Blanking:
  282.                                 if (!SwitchToBlankWindow())
  283.                                         PostError(getString(Couldnt_open_other_window_ERR));
  284.                                 return ROOT_OKAY;
  285.  
  286.                           case GD_AutoPat:
  287.                                 NewPattern(GDX_AutoPat, YP_AUTOSCR_PAT, gadget);
  288.                                 break;
  289.  
  290.                           case GD_ClickPat:
  291.                                 NewPattern(GDX_ClickPat, YP_CLICKSCR_PAT, gadget);
  292.                                 break;
  293.  
  294.                           case GD_PopPat:
  295.                                 NewPattern(GDX_PopPat, YP_POPWIN_PAT, gadget);
  296.                                 break;
  297.  
  298.                           case GD_ClickWinPat:
  299.                                 NewPattern(GDX_ClickWinPat, YP_CLICKWIN_PAT, gadget);
  300.                                 break;
  301.  
  302.                           case GD_Hide:
  303.                                 HideInterface();
  304.                                 return ROOT_O