home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Misc / YAK211SR.LHA / Yak_2.11_Src / Prefs / GadTools / Hotkey_window.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-16  |  14.8 KB  |  528 lines
  1.  
  2. /*
  3.  *  Source machine generated by GadToolsBox V2.0b
  4.  *  which is (c) Copyright 1991-1993 Jaba Development
  5.  *
  6.  *  GUI Designed by : Martin W Scott, Gaël Marziou & Philippe Bastiani
  7.  */
  8.  
  9.  
  10.  
  11.  
  12. #include <exec/types.h>
  13. #include <intuition/intuition.h>
  14. #include <intuition/classes.h>
  15. #include <intuition/classusr.h>
  16. #include <intuition/imageclass.h>
  17. #include <intuition/gadgetclass.h>
  18. #include <intuition/intuitionbase.h>
  19. #include <libraries/gadtools.h>
  20. #include <graphics/displayinfo.h>
  21. #include <graphics/gfxbase.h>
  22. #include <proto/exec.h>
  23. #include <proto/intuition.h>
  24. #include <proto/gadtools.h>
  25. #include <proto/graphics.h>
  26. #include <proto/locale.h>
  27. #include <proto/utility.h>
  28. #include <proto/wb.h>
  29. #include <string.h>
  30.  
  31. #include "code.h"
  32. #include "yak.h"
  33. #include "version.h"
  34. #include "hotkey_types.h"
  35. #include "gui.h"
  36. #include "hotkey_window.h"
  37. #include "KeyDef_window.h"
  38. #include "Options_window.h"
  39. #include "Requesters.h"
  40.  
  41. #define CATCOMP_NUMBERS
  42. #include "yak_locale_strings.h"
  43.  
  44. #ifdef _DCC
  45. #  include <lists.h>
  46. #else
  47. #  include "sas_lists.h"
  48. #endif
  49.  
  50.  
  51.  
  52. IMPORT struct Catalog    *Catalog;
  53.  
  54. extern LONG (*HandleIDCMP)(VOID);
  55.  
  56. struct Window   *HotKeyWnd = NULL;
  57. struct Gadget   *HotKeyGList = NULL;
  58. struct Gadget   *HotKeyGadgets[HotKey_CNT];
  59. UWORD            HotKeyWidth = 560;
  60. UWORD            HotKeyHeight = 175;
  61. UBYTE           *HotKeyWdt = NULL;
  62. BOOL             HotKeyWdi = FALSE;
  63.  
  64. struct AppWindow      *HotKeyAppWin;         /* AppWindow pointer */
  65. IMPORT struct MsgPort *AppMsgPort;
  66.  
  67. /* Online help system */
  68. IMPORT void ShowYakHelp(char *, char *);
  69. IMPORT char *PrefsHelp;
  70.  
  71.  
  72. UBYTE *State1Labels[3];
  73.  
  74.  
  75. VOID
  76. InitState1Labels(VOID)
  77. {
  78.     State1Labels[0] = getString(STATE_INACTIVE_STRING);
  79.     State1Labels[1] = getString(STATE_ACTIVE_STRING);
  80.     State1Labels[2] = NULL;
  81. }
  82.  
  83.  
  84.  
  85. IMPORT struct MinList Actions1List;
  86.  
  87. struct Node Actions1Nodes[NUM_HOTKEY_TYPES];
  88.  
  89.  
  90. VOID
  91. InitActionsList(void)
  92. {
  93.     UBYTE i;
  94.  
  95.     for (i=0; i<NUM_HOTKEY_TYPES ;i++)
  96.     {
  97.         Actions1Nodes[i].ln_Name  = getString(yhktypes[i].yhkt_nameID);
  98.     }
  99.  
  100.     Actions1Nodes[0].ln_Succ = &Actions1Nodes[1];
  101.     Actions1Nodes[0].ln_Pred = (struct Node *)&Actions1List.mlh_Head;
  102.  
  103.     for (i=1; i<NUM_HOTKEY_TYPES-1 ;i++)
  104.     {
  105.         Actions1Nodes[i].ln_Succ = &Actions1Nodes[i+1];
  106.         Actions1Nodes[i].ln_Pred = &Actions1Nodes[i-1];
  107.     }
  108.  
  109.     Actions1Nodes[NUM_HOTKEY_TYPES-1].ln_Succ = (struct Node *)&Actions1List.mlh_Tail;
  110.     Actions1Nodes[NUM_HOTKEY_TYPES-1].ln_Pred = &Actions1Nodes[NUM_HOTKEY_TYPES-2];
  111.  
  112. }
  113.  
  114. struct MinList Actions1List = {
  115.     (struct MinNode *)&Actions1Nodes[0],
  116.     (struct MinNode *)NULL,
  117.     (struct MinNode *)&Actions1Nodes[15] };
  118.  
  119.  
  120.  
  121.  
  122. UWORD HotKeyGTypes[] = {
  123.         LISTVIEW_KIND,
  124.         LISTVIEW_KIND,
  125.         BUTTON_KIND,
  126.         BUTTON_KIND,
  127.         CYCLE_KIND,
  128.         BUTTON_KIND,
  129.         STRING_KIND,
  130.         BUTTON_KIND,
  131.         BUTTON_KIND
  132. };
  133.  
  134. struct NewGadget HotKeyNGad[] = {
  135.           6,  15, 255, 96, NULL, NULL, GD_Actions,    PLACETEXT_ABOVE|NG_HIGHLABEL, NULL, ACTIONS_STRING,
  136.         300,  15, 255, 64, NULL, NULL, GD_Hotkeys,    PLACETEXT_ABOVE|NG_HIGHLABEL, NULL, HOTKEYS_STRING,
  137.         300,  93, 110, 13, NULL, NULL, GD_Add,        PLACETEXT_IN, NULL, ADD_STRING,
  138.         445,  93, 110, 13, NULL, NULL, GD_Delete,     PLACETEXT_IN, NULL, DELETE_STRING,
  139.         300, 135, 255, 13, NULL, NULL, GD_State,      PLACETEXT_LEFT, NULL, STATE_STRING,
  140.         230, 159, 100, 13, NULL, NULL, GD_Return,     PLACETEXT_IN, NULL, OK_STRING,
  141.         300,  77, 255, 14, NULL, NULL, GD_Name,       0, NULL, NULL,
  142.         300, 120, 124, 13, NULL, NULL, GD_Definition, PLACETEXT_IN, NULL, DEFINITION_STRING,
  143.         431, 120, 124, 13, NULL, NULL, GD_Options,    PLACETEXT_IN, NULL, OPTIONS_STRING
  144. };
  145.  
  146.  
  147. ULONG HotKeyGTags[] = {
  148.         (GTLV_Labels), (ULONG)&Actions1List, (GTLV_ShowSelected), NULL, (TAG_DONE),
  149.         (GTLV_ShowSelected), NULL, (TAG_DONE),
  150.         (TAG_DONE),
  151.         (TAG_DONE),
  152.         (GTCY_Labels), (ULONG)&State1Labels[ 0 ],   (TAG_DONE),
  153.         (TAG_DONE),
  154.         (GTST_MaxChars), 512, (TAG_DONE),
  155.         (TAG_DONE),
  156.         (TAG_DONE)
  157. };
  158.  
  159. VOID
  160. HotKeyRender(VOID)
  161. {
  162.     UWORD Width, Height;
  163.  
  164.     ComputeFont(HotKeyWidth,HotKeyHeight);
  165.  
  166.     Width  = ComputeX(HotKeyWidth);
  167.     Height = ComputeY(156);
  168.  
  169.     DrawThinBevelBox(Scr, HotKeyWnd->RPort,OffX,
  170.                      OffY,
  171.                      Width,
  172.                      Height,
  173.                      FALSE);
  174.  
  175.     DrawThinBevelBox(Scr, HotKeyWnd->RPort,OffX,
  176.                      OffY + Height,
  177.                      Width,
  178.                      ComputeY(HotKeyHeight)-Height,
  179.                      FALSE);
  180. }
  181.  
  182.  
  183.  
  184.  
  185. int
  186. OpenHotKeyWindow(VOID)
  187. {
  188.     struct NewGadget        ng;
  189.     struct Gadget   *g;
  190.     UWORD           lc, tc;
  191.     WORD            wleft=WindowLeft, wtop=WindowTop;
  192.     UWORD           ww, wh;
  193.  
  194.     ComputeFont( HotKeyWidth, HotKeyHeight );
  195.  
  196.     ww = OffX + ComputeX( HotKeyWidth ) + Scr->WBorRight;
  197.     wh = OffY + ComputeY( HotKeyHeight ) + Scr->WBorBottom;
  198.  
  199.     SetUpWindowCoordinates(ww, wh, &wleft, &wtop);
  200.  
  201.     if ( ! ( g = CreateContext( &HotKeyGList )))
  202.             return( 1L );
  203.  
  204.     for( lc = 0, tc = 0; lc < HotKey_CNT; lc++ ) {
  205.  
  206.             CopyMem((char * )&HotKeyNGad[ lc ], (char * )&ng, (long)sizeof( struct NewGadget ));
  207.  
  208.             ng.ng_VisualInfo = VisualInfo;
  209.             ng.ng_TextAttr   = Font;
  210.             ng.ng_LeftEdge   = OffX + ComputeX( ng.ng_LeftEdge );
  211.             ng.ng_TopEdge    = OffY + ComputeY( ng.ng_TopEdge );
  212.             ng.ng_Width      = ComputeX( ng.ng_Width );
  213.             ng.ng_Height     = ComputeY( ng.ng_Height);
  214.  
  215.             HotKeyGadgets[ lc ] = g = CreateGadgetA((ULONG)HotKeyGTypes[ lc ], g, &ng, ( struct TagItem * )&HotKeyGTags[ tc ] );
  216.  
  217.             while ( HotKeyGTags[ tc ] )
  218.                 tc += 2;
  219.             
  220.             tc++;
  221.  
  222.             if ( NOT g )
  223.                     return( 2L );
  224.     }
  225.  
  226.     if (! (HotKeyWnd = OpenWindowTags(NULL,
  227.                                       WA_Left,        wleft,
  228.                                       WA_Top,         wtop,
  229.                                       WA_Width,       ww,
  230.                                       WA_Height,      wh,
  231.                                       WA_IDCMP,       LISTVIEWIDCMP|STRINGIDCMP|CYCLEIDCMP|BUTTONIDCMP|IDCMP_VANILLAKEY|IDCMP_REFRESHWINDOW|IDCMP_RAWKEY,
  232.                                       WA_Flags,       WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_SMART_REFRESH,
  233.                                       WA_Gadgets,     HotKeyGList,
  234.                                       WA_Title,       HotKeyWdt,
  235.                                       WA_ScreenTitle,getString(COPYRIGHT_STRING),
  236.                                       WA_PubScreen,   Scr,
  237.                                       WA_PubScreenName,PubScreenName,
  238.                                       TAG_DONE)))
  239.         return(4L);
  240.  
  241.     HotKeyAppWin = AddAppWindowA(0, 0, HotKeyWnd, AppMsgPort, NULL);
  242.  
  243.     GT_RefreshWindow(HotKeyWnd,NULL);
  244.  
  245.     HotKeyRender();
  246.  
  247.     return(0L);
  248. }
  249.  
  250.  
  251.  
  252.  
  253. VOID
  254. CloseHotKeyWindow(VOID)
  255. {
  256.         CloseOneWindow (HotKeyWnd,NULL,HotKeyGList,HotKeyAppWin);
  257.         HotKeyWnd = NULL;
  258. }
  259.  
  260.  
  261. /*******************************************************************************
  262.  *      HOTKEY SPECIFIC DATA/ROUTINES
  263.  *      perhaps move to another file?
  264.  *******************************************************************************/
  265.  
  266. /* prototypes */
  267. static struct Node *GetNode(struct List *lh, UWORD n);
  268. static UWORD GetNodeNum(struct List *lh, struct Node *node);
  269.  
  270. /* external data */
  271. YakHotKey       *curhk=NULL;
  272. UWORD           curtype=0;
  273.  
  274. /* get number of node in list - node MUST be there! */
  275. static UWORD
  276. GetNodeNum(struct List *lh, struct Node *node)
  277. {
  278.         struct Node *ln;
  279.         UWORD i;
  280.  
  281.         for (i = 0, ln = GetHead(lh); ln != node; ln = GetSucc(ln), i++)
  282.                 ;
  283.         return i;
  284. }
  285.  
  286. /* get nth node in list - list MUST have >= n nodes!!! */
  287. static struct Node *
  288. GetNode(struct List *lh, UWORD n)
  289. {
  290.         struct Node *ln;
  291.  
  292.         for (ln = GetHead(lh); n--; ln = GetSucc(ln))
  293.                 ;
  294.         return ln;
  295. }
  296.  
  297.  
  298.  
  299. /* initialise all gadgets of hotkey window */
  300. static void
  301. InitHotKeyGadgets(VOID)
  302. {
  303.  
  304.     InitWindowGadget(GDX_Hotkeys, GTLV_Labels, (LONG)keylist(curtype), HOTKEY_WINDOW);
  305.     InitWindowGadget(GDX_Actions, GTLV_Selected, curtype, HOTKEY_WINDOW);
  306.  
  307.     InitWindowGadget(GDX_Delete, GA_Disabled, !curhk, HOTKEY_WINDOW);
  308.     /* something selected */
  309.     if (curhk)
  310.     {
  311.         UWORD n = GetNodeNum(keylist(curtype), (struct Node *)curhk);
  312.  
  313.         InitWindowGadget(GDX_Name,    GA_Disabled, FALSE,                 HOTKEY_WINDOW);
  314.         InitWindowGadget(GDX_Name,    GTST_String, (LONG)curhk->yhk_Name, HOTKEY_WINDOW);
  315.  
  316.         InitWindowGadget(GDX_State,   GA_Disabled,  FALSE,    HOTKEY_WINDOW);
  317.         InitWindowGadget(GDX_State,   GTCY_Active,  (LONG)curhk->yhk_State, HOTKEY_WINDOW);
  318.  
  319.         InitWindowGadget(GDX_Actions, GTLV_Top,      curtype, HOTKEY_WINDOW);
  320.         InitWindowGadget(GDX_Hotkeys, GTLV_Top     , n,       HOTKEY_WINDOW);
  321.         InitWindowGadget(GDX_Hotkeys, GTLV_Selected, n,       HOTKEY_WINDOW);
  322.  
  323.         InitWindowGadget(GDX_Definition, GA_Disabled,  FALSE,    HOTKEY_WINDOW);
  324.         
  325.         if(YHK_Takes_Opt(curhk))
  326.             InitWindowGadget(GDX_Options, GA_Disabled,  FALSE,    HOTKEY_WINDOW);
  327.         else
  328.             InitWindowGadget(GDX_Options, GA_Disabled,  TRUE,    HOTKEY_WINDOW);
  329.     }
  330.     else                        /* no current hotkey */
  331.     {
  332.         InitWindowGadget(GDX_Hotkeys, GTLV_Selected, -1, HOTKEY_WINDOW);
  333.  
  334.         InitWindowGadget(GDX_Name,    GTST_String, (LONG)"", HOTKEY_WINDOW);
  335.         InitWindowGadget(GDX_Name,    GA_Disabled, TRUE,     HOTKEY_WINDOW);
  336.  
  337.         InitWindowGadget(GDX_State,   GTCY_Active, 0, HOTKEY_WINDOW);
  338.         InitWindowGadget(GDX_State,   GA_Disabled, TRUE, HOTKEY_WINDOW);
  339.  
  340.         InitWindowGadget(GDX_Definition, GA_Disabled, TRUE, HOTKEY_WINDOW);
  341.         InitWindowGadget(GDX_Options,    GA_Disabled, TRUE, HOTKEY_WINDOW);
  342.     }
  343. }
  344.  
  345.  
  346. /* handle hotkey window events */
  347. LONG
  348. HandleHotKeyIDCMP(VOID)
  349. {
  350.     struct IntuiMessage *msg;
  351.     struct Gadget       *gadget;
  352.     ULONG               class;
  353.     UWORD               code;
  354.     BOOL                close=FALSE;
  355.     LONG                ret=RET_OKAY;
  356.  
  357.     while (!close && (msg = GT_GetIMsg(HotKeyWnd->UserPort)))
  358.     {
  359.         class = msg->Class;
  360.         code = msg->Code;
  361.         gadget = (struct Gadget *)msg->IAddress;
  362.         GT_ReplyIMsg(msg);
  363.  
  364.         switch (class)
  365.         {
  366.           case GADGETUP:
  367.           case GADGETDOWN:
  368.             switch (gadget->GadgetID)
  369.             {
  370.               case GD_Actions:
  371.                 if (code != curtype)
  372.                 {
  373.                     curtype = code;
  374.                     curhk = (YakHotKey *)GetHead(keylist(curtype));
  375.                     InitHotKeyGadgets();
  376.                 }
  377.                 break;
  378.  
  379.               case GD_Hotkeys:
  380.                 curhk = (YakHotKey *)GetNode(keylist(curtype), code);
  381.                 InitHotKeyGadgets();
  382.                 break;
  383.  
  384.               case GD_State:
  385.                 if (curhk)
  386.                     curhk->yhk_State = code;
  387.                 InitHotKeyGadgets();
  388.                 break;
  389.  
  390.               case GD_Add:
  391.                 if (curhk=NewYakHotKey(curtype))
  392.                 {
  393.                     DefaultOptions(curhk);
  394.                     InitHotKeyGadgets();
  395.                     ActivateGadget(HotKeyGadgets[GDX_Name], HotKeyWnd, NULL);
  396.                 }
  397.                 break;
  398.  
  399.               case GD_Delete:
  400.                 if (curhk)
  401.                 {
  402.                     DeleteYakHotKey(curhk);
  403.                     curhk = NULL;
  404.                     InitHotKeyGadgets();
  405.                 }
  406.                 break;
  407.  
  408.               case GD_Name:
  409.                 if (!ModifyYHKName(curhk, GetString(gadget)))
  410.                     ActivateGadget(HotKeyGadgets[GDX_Name], HotKeyWnd, NULL);
  411.                 InitHotKeyGadgets();
  412.                 break;
  413.  
  414.               case GD_Definition:
  415.                 if (curhk)
  416.                 {
  417.                     if (!SwitchToKeyDefWindow(HOTKEY_WINDOW,
  418.                                               curhk,
  419.                                               curhk->yhk_Name))
  420.                     {
  421.                         PostError(getString(Couldnt_open_other_window_ERR));
  422.                         ret= RET_QUIT;
  423.                     }
  424.                     close=TRUE;
  425.                 }
  426.                 break;
  427.  
  428.               case GD_Options:
  429.                 if (curhk)
  430.                 {
  431.                     if (!SwitchToOptionsWindow())
  432.                     {
  433.                         PostError(getString(Couldnt_open_other_window_ERR));
  434.                         ret = RET_QUIT;
  435.                     }
  436.                     close=TRUE;
  437.                 }
  438.                 break;
  439.  
  440.               case GD_Return:
  441.                 {
  442.                     APTR  err=0L;
  443.  
  444.                     for (curtype=0; (curtype < NUM_HOTKEY_TYPES) && !err; curtype++)
  445.                         for (curhk=(YakHotKey *)GetHead(keylist(curtype));
  446.                              curhk && !(err=ControlYakHotKey(curhk));
  447.                              curhk=(YakHotKey *)GetSucc(curhk))
  448.                            ;
  449.  
  450.                     if (!err)
  451.                     {
  452.                         curtype = 0;
  453.                         CloseHotKeyWindow();
  454.                         if (!ShowWindowID(ROOT_WINDOW))
  455.                             ret = RET_QUIT;
  456.                         close=TRUE;
  457.                     }
  458.                     else
  459.                     {
  460.                         curtype--;
  461.                         InitHotKeyGadgets();
  462.                         PostError(getString(err));
  463.                     }
  464.                 }
  465.                 break;
  466.  
  467.             }                   /* switch (gadget->GadgetID) */
  468.             break;
  469.  
  470.           case IDCMP_RAWKEY:
  471.                 /* Help key pressed */
  472.                 if (code == 95)
  473.                 {
  474.                     /* Display the node */
  475.                     ShowYakHelp(PrefsHelp, "Hotkeys");
  476.                 }
  477.                 break;
  478.  
  479.           case REFRESHWINDOW:
  480.             GT_BeginRefresh(HotKeyWnd);
  481.             GT_EndRefresh(HotKeyWnd, TRUE);
  482.             break;
  483.  
  484.         }                       /* switch (class) */
  485.  
  486.     }                           /* while more messages */
  487.  
  488.     return ret;
  489. }
  490.  
  491. /* show our hotkey window */
  492. BOOL
  493. ShowHotKeyWindow(VOID)
  494. {
  495.     if (!HotKeyWdi)
  496.     {
  497.         HotKeyWdi = TRUE;
  498.  
  499.         HotKeyWdt = getString(EDIT_HOTKEYS_STRING);
  500.         LocalizeNGadLabels (HotKey_CNT, HotKeyNGad);
  501.         InitActionsList ();
  502.         InitState1Labels ();
  503.     }
  504.  
  505.     if (!OpenHotKeyWindow())    /* like the name says... */
  506.     {
  507.         if (curwinID == ROOT_WINDOW)
  508.         {
  509.             curhk = (YakHotKey *)GetNode(keylist(curtype), 0);
  510.         }
  511.             
  512.         InitHotKeyGadgets();
  513.         wndsigflag = 1 << HotKeyWnd->UserPort->mp_SigBit;
  514.         curwin = HotKeyWnd;
  515.         curwinID = HOTKEY_WINDOW;
  516.         HandleIDCMP = HandleHotKeyIDCMP;
  517.  
  518.         return TRUE;
  519.     }
  520.  
  521.     FreeGadgets(HotKeyGList);
  522.     CloseDownScreen();
  523.     curwin =  NULL;
  524.     wndsigflag = 0L;
  525.     return FALSE;
  526. }
  527.  
  528.