home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 5 / FreshFish_July-August1994.bin / bbs / util / yak-1.59.lha / Yak-1.59 / Src / keydef_Window.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-08  |  19.1 KB  |  634 lines
  1. #include <exec/types.h>
  2. #include <exec/memory.h>
  3. #include <dos/dosextens.h>
  4. #include <graphics/displayinfo.h>
  5. #include <graphics/gfxbase.h>
  6. #include <graphics/gfxmacros.h>
  7. #include <intuition/intuition.h>
  8. #include <intuition/classes.h>
  9. #include <intuition/classusr.h>
  10. #include <intuition/imageclass.h>
  11. #include <intuition/gadgetclass.h>
  12. #include <intuition/intuitionbase.h>
  13. #include <libraries/gadtools.h>
  14. #include <libraries/commodities.h>
  15. #include <proto/commodities.h>
  16. #include <proto/keymap.h>
  17. #include <proto/exec.h>
  18. #include <proto/intuition.h>
  19. #include <proto/gadtools.h>
  20. #include <proto/graphics.h>
  21. #include <proto/locale.h>
  22. #include <proto/utility.h>
  23. #include <proto/dos.h>
  24. #include <string.h>
  25. #include <ctype.h>
  26.  
  27.  
  28. #include "code.h"
  29. #include "version.h"
  30. #include "hotkey_types.h"
  31. #include "yak.h"
  32. #include "gui.h"
  33. #include "KeyDef_Window.h"
  34.  
  35. #define CATCOMP_NUMBERS
  36. #include "locale/yak_locale_strings.h"
  37.  
  38.  
  39. extern LONG (*HandleIDCMP)(void);
  40.  
  41.  
  42. struct Window         *KeyDefWnd    = NULL;
  43. struct Gadget         *KeyDefGList  = NULL;
  44. struct Gadget         *KeyDefGadgets[KeyDef_CNT];
  45. UWORD                  KeyDefLeft   = 0;
  46. UWORD                  KeyDefTop    = 0;
  47. UWORD                  KeyDefWidth  = 517;
  48. UWORD                  KeyDefHeight = 85;
  49. UBYTE                 *KeyDefWdt    = NULL;
  50.  
  51. IMPORT YakHotKey      *curhk;
  52. IMPORT UWORD           curtype;
  53.  
  54. static YakKeyDef       KeyDef;
  55.  
  56.  
  57.  
  58. UBYTE *Class0Labels[5];
  59.  
  60. void
  61. InitClass0Labels()
  62. {
  63.     Class0Labels[0] = getString(RawKey_CLASS);
  64.     Class0Labels[1] = getString(RawMouse_CLASS);
  65.     Class0Labels[2] = getString(DiskInserted_CLASS);
  66.     Class0Labels[3] = getString(DiskRemoved_CLASS);
  67.     Class0Labels[4] = NULL;
  68. }
  69.  
  70.  
  71. UBYTE *Stroke0Labels[4];
  72.  
  73. void
  74. InitStroke0Labels()
  75. {
  76.     Stroke0Labels[0] = getString(Down_STROKE);
  77.     Stroke0Labels[1] = getString(Up_STROKE);
  78.     Stroke0Labels[2] = getString(Down_Up_STROKE);
  79.     Stroke0Labels[3] = NULL;
  80. }
  81.  
  82.  
  83. UWORD KeyDefGTypes[] = 
  84. {
  85.         CYCLE_KIND,
  86.         CYCLE_KIND,
  87.         STRING_KIND,
  88.         BUTTON_KIND,
  89.         BUTTON_KIND
  90. };
  91.  
  92. struct NewGadget KeyDefNGad[] = {
  93.          66, 13, 166, 13, NULL, NULL, GD_Class,  PLACETEXT_LEFT, NULL, NULL,
  94.         325, 13, 186, 13, NULL, NULL, GD_Stroke, PLACETEXT_LEFT, NULL, NULL,
  95.         108, 38, 403, 14, NULL, NULL, GD_Desc,   PLACETEXT_LEFT, NULL, NULL,
  96.           6, 68,  79, 13, NULL, NULL, GD_Ok,     PLACETEXT_IN,   NULL, NULL,
  97.         431, 68,  79, 13, NULL, NULL, GD_Cancel, PLACETEXT_IN,   NULL, NULL
  98. };
  99.  
  100.  
  101. void InitKeyDefNGad (void)
  102. {
  103.     KeyDefNGad[GD_Class].ng_GadgetText  = getString(CLASS_STRING);
  104.     KeyDefNGad[GD_Stroke].ng_GadgetText = getString(STROKE_STRING);
  105.     KeyDefNGad[GD_Desc].ng_GadgetText   = getString(DESC_STRING);
  106.     KeyDefNGad[GD_Ok].ng_GadgetText     = getString(OK_STRING);
  107.     KeyDefNGad[GD_Cancel].ng_GadgetText = getString(CANCEL_STRING);
  108. }
  109.  
  110.  
  111.  
  112. ULONG KeyDefGTags[] = {
  113.         (GTCY_Labels), (ULONG)&Class0Labels[ 0 ], (TAG_DONE),
  114.         (GTCY_Labels), (ULONG)&Stroke0Labels[ 0 ], (TAG_DONE),
  115.         (GTST_MaxChars), 256, (TAG_DONE),
  116.         (TAG_DONE),
  117.         (TAG_DONE)
  118. };
  119.  
  120.  
  121.  
  122. static __regargs void
  123. ConvertQualifiers(UWORD qual, UWORD iqual, UWORD squal, char *qualstr)
  124. {
  125.     UWORD i;
  126.  
  127.     *qualstr = '\0';
  128.  
  129.     for (i=0; i<SAMEQUALIFIERS_NUMBER; i++)
  130.     {
  131.         if ((qual & squal & SameQualifierArray[i].qat_ID) == SameQualifierArray[i].qat_ID)
  132.         {
  133.            *qualstr++ = ' ';
  134.            qualstr = stpcpy(qualstr, SameQualifierArray[i].qat_Str);
  135.         }
  136.         if ((iqual & squal & SameQualifierArray[i].qat_ID) == SameQualifierArray[i].qat_ID)
  137.         {
  138.            *qualstr++ = ' ';
  139.            *qualstr++ = '-';
  140.            qualstr = stpcpy(qualstr, SameQualifierArray[i].qat_Str);
  141.         }
  142.  
  143.     }
  144.  
  145.     qual  &= ~squal;
  146.     iqual &= ~squal;
  147.     for (i=0; i<QUALIFIERS_NUMBER; i++)
  148.     {
  149.         if (qual & QualifierArray[i].qat_ID)
  150.         {
  151.            *qualstr++ = ' ';
  152.            qualstr = stpcpy(qualstr, QualifierArray[i].qat_Str);
  153.         }
  154.         if (iqual & QualifierArray[i].qat_ID)
  155.         {
  156.            *qualstr++ = ' ';
  157.            *qualstr++ = '-';
  158.            qualstr = stpcpy(qualstr, QualifierArray[i].qat_Str);
  159.         }
  160.     }
  161. }
  162.  
  163.  
  164. static __regargs BOOL
  165. ConvertCode(UWORD code, char *codestr)
  166. {
  167.   *codestr = '\0';
  168.  
  169.   if (code != NO_IECODE)
  170.   {
  171.       struct InputEvent ievent;
  172.       UWORD  i;
  173.  
  174.       for (i=0; i<CODES_NUMBER; i++)
  175.       {
  176.           if (code == CodeArray[i].cat_Code)
  177.           {
  178.               codestr[0] = ' ';
  179.               strcpy(codestr+1, CodeArray[i].cat_Str);
  180.               return TRUE;
  181.           }
  182.  
  183.       }
  184.  
  185.       ievent.ie_Class         = IECLASS_RAWKEY;
  186.       ievent.ie_Code          = code;
  187.       ievent.ie_Qualifier     = NO_IEQUALIFIER;
  188.       ievent.ie_Prev1DownCode = ievent.ie_Prev1DownQual = NO_IEQUALIFIER;
  189.       ievent.ie_Prev2DownCode = ievent.ie_Prev2DownQual = NO_IEQUALIFIER;
  190.  
  191.       if((MapRawKey(&ievent, codestr+1, 1, NULL) == 1) &&
  192.          (codestr[1] != '-'))             /* forbidden */
  193.       {
  194.           codestr[0] = ' ';
  195.           codestr[2] = '\0';
  196.           return TRUE;
  197.       }
  198.   }
  199.   return FALSE;
  200. }
  201.  
  202.  
  203.  
  204.  
  205.  
  206.  
  207. static __regargs BOOL
  208. BuildKeyDef(YakKeyDef *ykd, STRPTR desc)
  209. {
  210.   BOOL  ret;
  211.   UBYTE codestr[20], qualstr[110];
  212.  
  213.   ConvertQualifiers(ykd->ykd_Qual, ykd->ykd_IQual, ykd->ykd_SQual, qualstr);
  214.  
  215.   if (ykd->ykd_Class > HKCLASS_RAWMOUSE)
  216.       ret = TRUE;
  217.   else
  218.       ret = ConvertCode(ykd->ykd_Code, codestr);
  219.  
  220.   stpcpy(desc, ClassArray[ykd->ykd_Class]);
  221.   strcat(desc, qualstr);
  222.   strcat(desc, StrokeArray[ykd->ykd_Stroke]);
  223.   strcat(desc, codestr);
  224.  
  225.   return ret;
  226.  
  227. }
  228.  
  229.  
  230. /* initialise all gadgets of keydef window */
  231. static void
  232. InitKeyDefGadgets(void)
  233. {
  234.     UBYTE SeqString[127];
  235.     BOOL SeqOk = BuildKeyDef(&KeyDef, SeqString);
  236.  
  237.     InitWindowGadget(GDX_Class,  GTCY_Active, KeyDef.ykd_Class,  KEYDEF_WINDOW);
  238.     InitWindowGadget(GDX_Desc,   GTST_String, (LONG)SeqString,   KEYDEF_WINDOW);
  239.     InitWindowGadget(GDX_Stroke, GTCY_Active, KeyDef.ykd_Stroke, KEYDEF_WINDOW);
  240.     InitWindowGadget(GDX_Stroke, GA_Disabled, KeyDef.ykd_Class,  KEYDEF_WINDOW);
  241.     InitWindowGadget(GDX_Ok,     GA_Disabled, !SeqOk,            KEYDEF_WINDOW);
  242. }
  243.  
  244.  
  245. static __regargs LONG
  246. ParseKeyDef(STRPTR desc, YakKeyDef *ykd)
  247. {
  248.     IX   ix;
  249.     LONG ret;
  250.  
  251.  
  252.     if (!(ret=ParseIX(desc, &ix)))
  253.     {
  254.         /* Class ? */
  255.         switch(ix.ix_Class)
  256.         {
  257.             case IECLASS_RAWKEY:
  258.                 ykd->ykd_Class = HKCLASS_RAWKEY;
  259.                 break;
  260.             case IECLASS_RAWMOUSE:
  261.                 ykd->ykd_Class = HKCLASS_RAWMOUSE;
  262.                 break;
  263.             case IECLASS_DISKINSERTED:
  264.                 ykd->ykd_Class = HKCLASS_DISKINSERTED;
  265.                 break;
  266.             case IECLASS_DISKREMOVED:
  267.                 ykd->ykd_Class = HKCLASS_DISKREMOVED;
  268.                 break;
  269.             default:
  270.                 return -1;
  271.         }
  272.  
  273.         /* Qualifier ? */
  274.         ykd->ykd_Qual  =  ix.ix_Qualifier;
  275.         ykd->ykd_IQual = ~ix.ix_QualMask;
  276.  
  277.         ykd->ykd_SQual = NO_IEQUALIFIER;
  278.         if (ix.ix_QualSame & IXSYM_SHIFT) ykd->ykd_SQual |= IXSYM_SHIFTMASK;
  279.         if (ix.ix_QualSame & IXSYM_CAPS)  ykd->ykd_SQual |= IXSYM_CAPSMASK;
  280.         if (ix.ix_QualSame & IXSYM_ALT)   ykd->ykd_SQual |= IXSYM_ALTMASK;
  281.  
  282.         /* Stroke ? */
  283.         if (ix.ix_Code & IECODE_UP_PREFIX)
  284.             ykd->ykd_Stroke = HKSTROKE_UP;
  285.         else
  286.             if (~ix.ix_CodeMask & IECODE_UP_PREFIX)
  287.                 ykd->ykd_Stroke = HKSTROKE_DOWN_UP;
  288.             else
  289.                 ykd->ykd_Stroke = HKSTROKE_DOWN;
  290.  
  291.         /* Code ? */
  292.         if (!ix.ix_Code && (ix.ix_Class == IECLASS_RAWMOUSE))
  293.             ykd->ykd_Code = NO_IECODE;
  294.         else
  295.             ykd->ykd_Code = ix.ix_Code & ~IECODE_UP_PREFIX;
  296.     }
  297.     else
  298.     {
  299.         if (ret == -2)  /* NULL description */
  300.         {
  301.             ykd->ykd_Class  = HKCLASS_RAWKEY;
  302.             ykd->ykd_Qual   = ykd->ykd_IQual = ykd->ykd_SQual = NO_IEQUALIFIER;
  303.             ykd->ykd_Stroke = HKSTROKE_DOWN;
  304.             ykd->ykd_Code   = NO_IECODE;
  305.         }
  306.     }
  307.  
  308.     return ret;
  309. }
  310.  
  311. static __regargs UWORD
  312. IsQualifierPad(UWORD code)
  313. {
  314.     UWORD i;
  315.  
  316.     for (i=0; i<QUALIFIERSPAD_NUMBER; i++)
  317.         if (QualifierPadArray[i].qpat_Code == code)
  318.             return QualifierPadArray[i].qpat_Qualifier;
  319.  
  320.     return NO_IEQUALIFIER;
  321. }
  322.  
  323.  
  324. /* switch from misc window to keydef window */
  325. BOOL
  326. SwitchToKeyDefWindow(void)
  327. {
  328.     static char title[80];
  329.  
  330.     strcpy(title, getString(DefKey_Window_TITLE));
  331.     strcat(title, " : ");
  332.     strcat(title, Actions1Nodes[curtype].ln_Name);
  333.     KeyDefWdt = title;
  334.  
  335.     KeyDefLeft = HotKeyWnd->LeftEdge;
  336.     WindowTop  = HotKeyWnd->TopEdge;
  337.  
  338.     ParseKeyDef(curhk->yhk_KeyDef, &KeyDef);
  339.  
  340.     CloseHotKeyWindow();
  341.     return ShowKeyDefWindow();
  342. }
  343.  
  344.  
  345. /* handle KeyDef window events */
  346. LONG
  347. HandleKeyDefIDCMP(void)
  348. {
  349.         struct IntuiMessage *msg;
  350.         struct Gadget       *gadget;
  351.         ULONG                class;
  352.         UWORD                code;
  353.         UWORD                qual, newqual;
  354.  
  355.  
  356.         while (msg = GT_GetIMsg(KeyDefWnd->UserPort))
  357.         {
  358.                 class  = msg->Class;
  359.                 code   = msg->Code;
  360.                 qual   = msg->Qualifier;
  361.                 gadget = (struct Gadget *)msg->IAddress;
  362.                 GT_ReplyIMsg(msg);
  363.  
  364.                 switch (class)
  365.                 {
  366.                 case CLOSEWINDOW:
  367.                         HideInterface();
  368.                         return ROOT_OKAY;
  369.  
  370.                 case GADGETUP:
  371.                 case GADGETDOWN:
  372.                         switch (gadget->GadgetID)
  373.                         {
  374.                         case GD_Class:
  375.                                 KeyDef.ykd_Class  = code;
  376.                                 KeyDef.ykd_Stroke = HKSTROKE_DOWN;
  377.                                 KeyDef.ykd_Code   = NO_IECODE;
  378.                                 KeyDef.ykd_Qual = KeyDef.ykd_IQual = KeyDef.ykd_SQual = NO_IEQUALIFIER;
  379.  
  380.                                 InitKeyDefGadgets();
  381.                                 break;
  382.  
  383.                         case GD_Stroke:
  384.                                 if ((KeyDef.ykd_Stroke=code) == HKSTROKE_UP)
  385.                                 {
  386.                                     KeyDef.ykd_Qual  &= ~IEQUALIFIER_REPEAT;
  387.                                     KeyDef.ykd_IQual &= ~IEQUALIFIER_REPEAT;
  388.                                 }
  389.  
  390.                                 InitKeyDefGadgets();
  391.                                 break;
  392.  
  393.                         case GD_Desc:
  394.                                 if (ParseKeyDef(GetString(gadget), &KeyDef) == -1)
  395.                                     PostError(getString(Invalid_hotkey_specif_ERR));
  396.  
  397.                                 InitKeyDefGadgets();
  398.  
  399.                                 break;
  400.  
  401.                         case GD_Cancel:
  402.                                 if (!strcmp(curhk->yhk_Node.ln_Name,"<unset>"))
  403.                                 {
  404.                                    DeleteYakHotKey(curhk);
  405.                                    curhk = NULL;
  406.                                 }
  407.                                 UpdateWindowsPosition();
  408.                                 CloseKeyDefWindow();
  409.                                 if (!ShowHotKeyWindow())
  410.                                         PostError(getString(Couldnt_open_other_window_ERR));
  411.                                 return ROOT_OKAY;
  412.  
  413.                         case GD_Ok:
  414.                                 ModifyYHKKeyDef(curhk, GetString(KeyDefGadgets[GDX_Desc]));
  415.                                 UpdateWindowsPosition();
  416.                                 CloseKeyDefWindow();
  417.                                 if (ShowHotKeyWindow())
  418.                                 {
  419.                                     ActivateWindow(HotKeyWnd);
  420.  
  421.                                     if (YHK_Takes_Arg(curhk))
  422.                                         ActivateGadget(HotKeyGadgets[GDX_Argument], HotKeyWnd, NULL);
  423.                                 }
  424.                                 else
  425.                                     PostError(getString(Couldnt_open_other_window_ERR));
  426.  
  427.                                 return ROOT_OKAY;
  428.  
  429.                         } /* switch (gadget->GadgetID) */
  430.                         break;
  431.  
  432.                 case IDCMP_RAWKEY:
  433.                         if ( (!(code & IECODE_UP_PREFIX) || code == 0xe2 ) &&  /* a downstroke || capslock up*/
  434.                              ((KeyDef.ykd_Class == HKCLASS_RAWKEY) || (KeyDef.ykd_Class == HKCLASS_RAWMOUSE)) )
  435.                         {
  436.                             if (newqual = IsQualifierPad(code))
  437.                             {
  438.                                 newqual &= ~KeyDef.ykd_SQual;
  439.                                 newqual &= ~KeyDef.ykd_IQual;
  440.  
  441.                                 /* Toggle Qualifier */
  442.                                 KeyDef.ykd_Qual ^= newqual;
  443.                             }
  444.                             else
  445.                             {
  446.                                 if (KeyDef.ykd_Class == HKCLASS_RAWKEY)
  447.                                 {
  448.                                     if ((code == KeyDef.ykd_Code) && (KeyDef.ykd_Stroke != HKSTROKE_UP))
  449.                                     {
  450.                                         /* Toggle Repeat Keyword */
  451.                                         if(!(KeyDef.ykd_IQual & IEQUALIFIER_REPEAT))
  452.                                             KeyDef.ykd_Qual  ^= IEQUALIFIER_REPEAT;
  453.  
  454.                                     }
  455.                                     else  /* New key or upstroke mode */
  456.                                     {
  457.                                         KeyDef.ykd_Qual  &= ~IEQUALIFIER_KEYS;
  458.                                         KeyDef.ykd_IQual &= ~IEQUALIFIER_KEYS;
  459.                                         KeyDef.ykd_Qual  |= qual & IEQUALIFIER_NUMERICPAD;
  460.                                         KeyDef.ykd_Code   = code;
  461.                                     }
  462.                                 }
  463.                             }
  464.  
  465.                             InitKeyDefGadgets();
  466.                         }
  467.                         break;
  468.  
  469.                 case IDCMP_MOUSEBUTTONS:
  470.                         if (!(code & IECODE_UP_PREFIX) &&  /* a downstroke */
  471.                              ((KeyDef.ykd_Class == HKCLASS_RAWKEY) || (KeyDef.ykd_Class == HKCLASS_RAWMOUSE)) )
  472.                         {
  473.                             switch(code)
  474.                             {
  475.                                 case IECODE_RBUTTON:
  476.                                     newqual = IEQUALIFIER_RBUTTON;
  477.                                     break;
  478.                                 case IECODE_LBUTTON:
  479.                                     newqual = IEQUALIFIER_LEFTBUTTON;
  480.                                     break;
  481.                                 case IECODE_MBUTTON:
  482.                                     newqual = IEQUALIFIER_MIDBUTTON;
  483.                                     break;
  484.                                 default:
  485.                                     newqual = NO_IEQUALIFIER;
  486.                                     break;
  487.                             }
  488.  
  489.                             newqual &= ~KeyDef.ykd_IQual;
  490.  
  491.                             if (KeyDef.ykd_Class == HKCLASS_RAWMOUSE)
  492.                             {
  493.                                 if (KeyDef.ykd_Code == code)
  494.                                 {
  495.                                     KeyDef.ykd_Qual &= ~newqual;
  496.                                     KeyDef.ykd_Code  = NO_IECODE;
  497.                                 }
  498.                                 else
  499.                                 {
  500.                                     KeyDef.ykd_Qual |= newqual;
  501.                                     KeyDef.ykd_Code  = code;
  502.                                 }
  503.                             }
  504.                             else
  505.                                 KeyDef.ykd_Qual  ^= newqual;
  506.  
  507.                             InitKeyDefGadgets();
  508.                         }
  509.                         break;
  510.  
  511.                 case REFRESHWINDOW:
  512.                         GT_BeginRefresh(KeyDefWnd);
  513.                         GT_EndRefresh(KeyDefWnd, TRUE);
  514.                         break;
  515.  
  516.                 } /* switch (class) */
  517.  
  518.         } /* while more messages */
  519.  
  520.         return ROOT_OKAY;
  521. }
  522.  
  523.  
  524. void 
  525. CloseKeyDefWindow( void )
  526. {
  527.         CloseOneWindow (KeyDefWnd, NULL, KeyDefGList);
  528.         KeyDefWnd = NULL;
  529. }
  530.  
  531.  
  532. void KeyDefRender( void )
  533. {
  534.     UWORD Width, X;
  535.  
  536.     ComputeFont( KeyDefWidth, KeyDefHeight );
  537.  
  538.     Width = ComputeX( 517 ) ;
  539.     X = OffX + ComputeX( 0 ) ;
  540.  
  541.     DrawBevelBox( KeyDefWnd->RPort, X,
  542.                  OffY + ComputeY( 65 ),
  543.                  Width,
  544.                  ComputeY( 20 ),
  545.                  GT_VisualInfo, VisualInfo, TAG_DONE );
  546.     DrawBevelBox( KeyDefWnd->RPort, X,
  547.                  OffY + ComputeY( 0 ),
  548.                  Width,
  549.                  ComputeY( 65 ),
  550.                  GT_VisualInfo, VisualInfo, TAG_DONE );
  551. }
  552.  
  553.  
  554. int 
  555. OpenKeyDefWindow( void )
  556. {
  557.         struct NewGadget        ng;
  558.         struct Gadget   *g;
  559.         UWORD           lc, tc;
  560.         UWORD           wleft = KeyDefLeft, wtop = WindowTop, ww, wh;
  561.  
  562.         ComputeFont( KeyDefWidth, KeyDefHeight );
  563.  
  564.         ww = ComputeX( KeyDefWidth );
  565.         wh = ComputeY( KeyDefHeight );
  566.  
  567.         if (( wleft + ww + OffX + Scr->WBorRight ) > Scr->Width ) wleft = Scr->Width - ww;
  568.         if (( wtop + wh + OffY + Scr->WBorBottom ) > Scr->Height ) wtop = Scr->Height - wh;
  569.  
  570.         if ( ! ( g = CreateContext( &KeyDefGList )))
  571.                 return( 1L );
  572.  
  573.         for( lc = 0, tc = 0; lc < KeyDef_CNT; lc++ ) {
  574.  
  575.                 CopyMem((char * )&KeyDefNGad[ lc ], (char * )&ng, (long)sizeof( struct NewGadget ));
  576.  
  577.                 ng.ng_VisualInfo = VisualInfo;
  578.                 ng.ng_TextAttr   = Font;
  579.                 ng.ng_LeftEdge   = OffX + ComputeX( ng.ng_LeftEdge );
  580.                 ng.ng_TopEdge    = OffY + ComputeY( ng.ng_TopEdge );
  581.                 ng.ng_Width      = ComputeX( ng.ng_Width );
  582.                 ng.ng_Height     = ComputeY( ng.ng_Height);
  583.  
  584.                 KeyDefGadgets[ lc ] = g = CreateGadgetA((ULONG)KeyDefGTypes[ lc ], g, &ng, ( struct TagItem * )&KeyDefGTags[ tc ] );
  585.  
  586.                 while( KeyDefGTags[ tc ] ) tc += 2;
  587.                 tc++;
  588.  
  589.                 if ( NOT g )
  590.                         return( 2L );
  591.         }
  592.  
  593.         if ( ! ( KeyDefWnd = OpenWindowTags( NULL,
  594.                                 WA_Left,         wleft,
  595.                                 WA_Top,          wtop,
  596.                                 WA_Width,        ww + OffX + Scr->WBorRight,
  597.                                 WA_Height,       wh + OffY + Scr->WBorBottom,
  598.                                 WA_IDCMP,        CYCLEIDCMP|TEXTIDCMP|BUTTONIDCMP|IDCMP_MOUSEBUTTONS|IDCMP_CLOSEWINDOW|IDCMP_RAWKEY|IDCMP_REFRESHWINDOW,
  599.                                 WA_Flags,        WFLG_ACTIVATE|WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_CLOSEGADGET|WFLG_SMART_REFRESH|WFLG_RMBTRAP,
  600.                                 WA_Gadgets,      KeyDefGList,
  601.                                 WA_Title,        KeyDefWdt,
  602.                                 WA_ScreenTitle,  getString(COPYRIGHT_STRING),
  603.                                 WA_PubScreen,    TRUE,
  604.                                 WA_PubScreenName,PubScreenName,
  605.                                 TAG_DONE )))
  606.         return( 4L );
  607.  
  608.         GT_RefreshWindow( KeyDefWnd, NULL );
  609.  
  610.         KeyDefRender();
  611.  
  612.         return( 0L );
  613. }
  614.  
  615.  
  616. /* show our KeyDef window */
  617. BOOL
  618. ShowKeyDefWindow(void)
  619. {
  620.     if (!OpenKeyDefWindow())  /* like the name says... */
  621.     {
  622.         InitKeyDefGadgets();
  623.         wndsigflag = 1 << KeyDefWnd->UserPort->mp_SigBit;
  624.         curwin = KeyDefWnd;
  625.         HandleIDCMP = HandleKeyDefIDCMP;
  626.         return TRUE;
  627.     }
  628.     CloseDownScreen();
  629.     return FALSE;
  630. }
  631.  
  632.  
  633.  
  634.