home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Misc / YAK211SR.LHA / Yak_2.11_Src / Prefs / GadTools / Options_Window.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-16  |  22.7 KB  |  784 lines
  1.  
  2.  
  3. #include <exec/types.h>
  4. #include <exec/memory.h>
  5. #include <intuition/intuition.h>
  6. #include <intuition/classes.h>
  7. #include <intuition/classusr.h>
  8. #include <intuition/imageclass.h>
  9. #include <intuition/gadgetclass.h>
  10. #include <intuition/intuitionbase.h>
  11. #include <libraries/gadtools.h>
  12.  
  13. #include <proto/exec.h>
  14. #include <proto/intuition.h>
  15. #include <proto/gadtools.h>
  16. #include <proto/graphics.h>
  17. #include <proto/wb.h>
  18. #include <string.h>
  19.  
  20. #include "code.h"
  21. #include "version.h"
  22. #include "hotkey_types.h"
  23. #include "yak.h"
  24. #include "gui.h"
  25. #include "Options_window.h"
  26.  
  27. #include "yak_locale_strings.h"
  28.  
  29. #ifdef _DCC
  30. #  include <lists.h>
  31. #else
  32. #  include "sas_lists.h"
  33. #endif
  34.  
  35.  
  36. IMPORT LONG (*HandleIDCMP)(VOID);
  37. IMPORT YakHotKey       *curhk;
  38. IMPORT UWORD            curtype;
  39.  
  40. struct Window   *OptionsWnd = NULL;
  41. struct Gadget   *OptionsGList = NULL;
  42. struct Gadget   *OptionsGadgets[Options_CNT];
  43. UWORD            OptionsWidth = 500;
  44. UWORD            OptionsHeight;
  45. UBYTE           *OptionsWdt = NULL;
  46. BOOL             OptionsWdi = FALSE;
  47.  
  48. struct AppWindow      *OptionsAppWin;         /* AppWindow pointer */
  49. IMPORT struct MsgPort *AppMsgPort;
  50.  
  51. UWORD                 CurPage = 0;
  52. struct GadgetData    *PageNGad;
  53. struct Gadget        *PageGList = NULL;
  54. STRPTR               *PageLabels;
  55. UWORD                 PageGNum;
  56.  
  57. UWORD OptGadNum;
  58.  
  59.  
  60. /* Online help system */
  61. IMPORT void ShowYakHelp(char *, char *);
  62. IMPORT void CloseYakHelp(void);
  63. IMPORT char *PrefsHelp;
  64.  
  65.  
  66. #define CHECKBOX_HEIGHT   11
  67. #define CHECKBOX_WIDTH    26
  68. static struct TagItem CHECKBOX_GTAGS[] = { (GTCB_Scaled),TRUE,(TAG_DONE) };
  69. #define STRING_HEIGHT     14
  70. #define STRING_WIDTH      244
  71. static struct TagItem STRING_GTAGS[] = { (GTST_MaxChars),99,(TAG_DONE) };
  72. #define INTEGER_HEIGHT    14
  73. #define INTEGER_WIDTH     120
  74. static  struct TagItem INTEGER_GTAGS[]  = {(GTIN_MaxChars),11,(STRINGA_Justification),STRINGRIGHT,(TAG_DONE)};
  75.  
  76.  
  77. #define  Margin           6
  78. #define  PageOffY        21
  79. #define  BottomBoxHeight 19
  80.  
  81.  
  82. UWORD OptionsGTypes[] =
  83. {
  84.         CYCLE_KIND,
  85.         BUTTON_KIND,
  86.         BUTTON_KIND,
  87.         BUTTON_KIND
  88. };
  89.  
  90.  
  91. struct NewGadget OptionsNGad[] =
  92. {
  93.           6, 4, 488, 13, NULL, NULL, GD_Page_Opts,   0,            NULL, NULL,
  94.           6, 0, 100, 13, NULL, NULL, GD_OK_Opts,     PLACETEXT_IN, NULL, OK_STRING,
  95.         150, 0, 200, 13, NULL, NULL, GD_Default_Opts,PLACETEXT_IN, NULL, MENU_DEFAULT_STRING,
  96.         394, 0, 100, 13, NULL, NULL, GD_Cancel_Opts, PLACETEXT_IN, NULL, CANCEL_STRING
  97. };
  98.  
  99.  
  100. ULONG OptionsGTags[] =
  101. {
  102.         (GTCY_Labels), NULL, (TAG_DONE),
  103.         (TAG_DONE),
  104.         (TAG_DONE),
  105.         (TAG_DONE)
  106. };
  107.  
  108.  
  109.  
  110. VOID
  111. GetYakOption(VOID)
  112. {
  113.     UWORD ol, optslist=YHK_Takes_Opt(curhk);
  114.     UWORD NGad=0;
  115.  
  116.     for (ol=0; ol<optslist; ol++)
  117.     {
  118.         OptDescription *curdesc=yhktypes[curhk->yhk_Type].yhkt_OptsList[ol].Desc;
  119.         UWORD as=0;   /* ArgStr number */
  120.         UWORD an=0;   /* ArgNum number */
  121.         UWORD dn=0;   /* Desc.  number */
  122.         UWORD oldflags=curhk->yhk_Option[ol].Flags;
  123.  
  124.         curhk->yhk_Option[ol].Flags = 0;
  125.  
  126.         while (curdesc->Type != NO_OPT)
  127.         {
  128.             UWORD  gad;
  129.             STRPTR argstr=NULL;
  130.  
  131.             gad = NGad + curdesc->DisplayID;
  132.  
  133.             switch(curdesc->Type)
  134.             {
  135.                 case TOGGLE_OPT:
  136.                     curhk->yhk_Option[ol].Flags |= PageNGad[gad].gd_Flag;
  137.                     break;
  138.  
  139.                 case STRING_OPT:
  140.                     if (PageNGad[gad].gd_Flag)
  141.                         argstr = DupStr(PageNGad[gad].gd_ArgStr);
  142.                     if (oldflags & curdesc->LocalID)
  143.                         FreeVec(curhk->yhk_Option[ol].ArgStr[as]);
  144.                     if (argstr)
  145.                         curhk->yhk_Option[ol].Flags |= PageNGad[gad].gd_Flag;
  146.                     curhk->yhk_Option[ol].ArgStr[as] = argstr;
  147.                     as++;
  148.                     break;
  149.  
  150.                 case INTEGER_OPT:
  151.                     if (PageNGad[gad].gd_Flag)
  152.                         curhk->yhk_Option[ol].Flags |= PageNGad[gad].gd_Flag;
  153.                     curhk->yhk_Option[ol].ArgNum[an] = PageNGad[gad].gd_ArgNum;
  154.                     an++;
  155.                     break;
  156.             }
  157.  
  158.             curdesc++;
  159.             dn++;
  160.         }
  161.         NGad += dn;
  162.     }
  163. }
  164.  
  165.  
  166. static void
  167. DisableOptionsGadgets(UWORD listID, UWORD IDs, BOOL state)
  168. {
  169.     UWORD gad;
  170.  
  171.     for (gad=0; gad<OptGadNum; gad++)
  172.     {
  173.         if ((PageNGad[gad].gd_ListID == listID) &&
  174.             (PageNGad[gad].gd_Desc->LocalID & IDs))
  175.             PageNGad[gad].gd_Disabled = state;
  176.     }
  177. }
  178.  
  179.  
  180. static void
  181. MutualExcludeOptionsGadgets(UWORD listID, UWORD ID, UWORD excludeIDs)
  182. {
  183.     UWORD gad;
  184.  
  185.     for (gad=0; gad<OptGadNum; gad++)
  186.     {
  187.         if (PageNGad[gad].gd_ListID == listID)
  188.         {
  189.             if (PageNGad[gad].gd_Desc->LocalID & ID)
  190.                 PageNGad[gad].gd_Flag = PageNGad[gad].gd_Desc->LocalID;
  191.  
  192.             if (PageNGad[gad].gd_Flag & excludeIDs)
  193.                 PageNGad[gad].gd_Flag = 0;
  194.         }
  195.     }
  196. }
  197.  
  198.  
  199.  
  200. VOID 
  201. InitOptionsGadgets(VOID)
  202. {
  203.     UWORD gad;
  204.  
  205.     for (gad=0; gad<OptGadNum; gad++)
  206.     {
  207.         if (PageNGad[gad].gd_Desc->ActivateIDs)
  208.             DisableOptionsGadgets(PageNGad[gad].gd_ListID,
  209.                                   PageNGad[gad].gd_Desc->ActivateIDs,
  210.                                   (PageNGad[gad].gd_Flag ? FALSE: TRUE));
  211.     }
  212.  
  213.     GT_SetGadgetAttrs(OptionsGadgets[GDX_Page_Opts], OptionsWnd, NULL,
  214.                       GTCY_Active, CurPage, TAG_DONE);
  215.  
  216.     for(gad=0; gad<OptGadNum; gad++)
  217.     {
  218.         if (PageNGad[gad].gd_ListID == CurPage)
  219.         {
  220.             switch(PageNGad[gad].gd_Type)
  221.             {
  222.                 case CHECKBOX_KIND:
  223.                     GT_SetGadgetAttrs(PageNGad[gad].gd_Gadget, OptionsWnd, NULL,
  224.                                       GTCB_Checked, (BOOL)PageNGad[gad].gd_Flag, TAG_DONE);
  225.                     break;
  226.  
  227.                 case STRING_KIND:
  228.                     GT_SetGadgetAttrs(PageNGad[gad].gd_Gadget, OptionsWnd, NULL,
  229.                                       GTST_String, (LONG)PageNGad[gad].gd_ArgStr, TAG_DONE);
  230.                     break;
  231.  
  232.                 case INTEGER_KIND:
  233.                     GT_SetGadgetAttrs(PageNGad[gad].gd_Gadget, OptionsWnd, NULL,
  234.                                       GTIN_Number, (LONG)PageNGad[gad].gd_ArgNum, TAG_DONE);
  235.                     break;
  236.             }
  237.  
  238.             GT_SetGadgetAttrs(PageNGad[gad].gd_Gadget, OptionsWnd, NULL,
  239.                               GA_Disabled, (BOOL)PageNGad[gad].gd_Disabled, TAG_DONE);
  240.         }
  241.     }
  242. }
  243.  
  244.  
  245.  
  246. static void
  247. SetDefaultOptionsGadgets(void)
  248. {
  249.     UWORD           gad;
  250.  
  251.     for (gad=0; gad<OptGadNum; gad++)
  252.     {
  253.         OptDescription *curdesc=PageNGad[gad].gd_Desc;
  254.  
  255.         PageNGad[gad].gd_Flag = curdesc->DefFlag;
  256.  
  257.         switch (curdesc->Type)
  258.         {
  259.             case STRING_OPT:
  260.                 PageNGad[gad].gd_ArgStr = curdesc->DefArgStr;
  261.                 break;
  262.  
  263.             case INTEGER_OPT:
  264.                 PageNGad[gad].gd_ArgNum = curdesc->DefArgNum;
  265.                 break;
  266.         }
  267.     }
  268.     InitOptionsGadgets();
  269. }
  270.  
  271.  
  272.  
  273. static void
  274. BuildGadgetArray( void )
  275. {
  276.     UWORD NGad,gad;
  277.     UWORD ol, optslist;
  278.     OptDescription *curdesc;
  279.     UWORD BoxHeight=0;
  280.     UWORD GadX, GadY;
  281.  
  282.     optslist  = YHK_Takes_Opt(curhk);
  283.  
  284.     /* Find number of gadgets */
  285.     OptGadNum = 0;
  286.     for (ol=0; ol<optslist; ol++)
  287.     {
  288.         curdesc = yhktypes[curhk->yhk_Type].yhkt_OptsList[ol].Desc;
  289.  
  290.         while (curdesc->Type != NO_OPT)
  291.         {
  292.             OptGadNum++;
  293.             curdesc++;
  294.         }
  295.     }
  296.  
  297.  
  298.     /* Allocate some memory */
  299.     PageNGad   = (struct GadgetData *)AllocVec(OptGadNum*sizeof(struct GadgetData), MEMF_PUBLIC|MEMF_CLEAR);
  300.     PageLabels = (STRPTR *)AllocVec((optslist+1)*sizeof(STRPTR), MEMF_PUBLIC|MEMF_CLEAR);
  301.  
  302.     /* Now fill the arrays */
  303.     GadX  = OptionsWidth-Margin-STRING_WIDTH;
  304.  
  305.     NGad = 0;
  306.  
  307.     for (ol=0; ol<optslist; ol++)
  308.     {
  309.         UWORD as=0;   /* ArgStr number */
  310.         UWORD an=0;   /* ArgNum number */
  311.         UWORD dn=0;   /* Desc.  number */
  312.  
  313.         curdesc = yhktypes[curhk->yhk_Type].yhkt_OptsList[ol].Desc;
  314.  
  315.         PageLabels[ol] = getString(yhktypes[curhk->yhk_Type].yhkt_OptsList[ol].LabelID);
  316.  
  317.         while (curdesc->Type != NO_OPT)
  318.         {
  319.             gad = NGad + curdesc->DisplayID;
  320.  
  321.             switch(curdesc->Type)
  322.             {
  323.                 case TOGGLE_OPT:
  324.                     PageNGad[gad].gd_Width    = CHECKBOX_WIDTH;
  325.                     PageNGad[gad].gd_Height   = CHECKBOX_HEIGHT;
  326.                     PageNGad[gad].gd_Type     = CHECKBOX_KIND;
  327.                     PageNGad[gad].gd_Tags     = CHECKBOX_GTAGS;
  328.                     PageNGad[gad].gd_Flag = (curhk->yhk_Option[ol].Flags & curdesc->LocalID);
  329.                     break;
  330.  
  331.                 case STRING_OPT:
  332.                     PageNGad[gad].gd_Width    = STRING_WIDTH;
  333.                     PageNGad[gad].gd_Height   = STRING_HEIGHT;
  334.                     PageNGad[gad].gd_Type     = STRING_KIND;
  335.                     PageNGad[gad].gd_Tags     = STRING_GTAGS;
  336.                     if (PageNGad[gad].gd_Flag = (curhk->yhk_Option[ol].Flags & curdesc->LocalID))
  337.                     {
  338.                         PageNGad[gad].gd_ArgStr = curhk->yhk_Option[ol].ArgStr[as];
  339.                     }
  340.                     as++;
  341.                     break;
  342.  
  343.                 case INTEGER_OPT:
  344.                     PageNGad[gad].gd_Width    = INTEGER_WIDTH;
  345.                     PageNGad[gad].gd_Height   = INTEGER_HEIGHT;
  346.                     PageNGad[gad].gd_Type     = INTEGER_KIND;
  347.                     PageNGad[gad].gd_Tags     = INTEGER_GTAGS;
  348.                     if (PageNGad[gad].gd_Flag = (curhk->yhk_Option[ol].Flags & curdesc->LocalID))
  349.                     {
  350.                         PageNGad[gad].gd_ArgNum = curhk->yhk_Option[ol].ArgNum[an];
  351.                     }
  352.                     an++;
  353.                     break;
  354.  
  355.             }
  356.  
  357.             PageNGad[gad].gd_ListID   = ol;
  358.             PageNGad[gad].gd_Desc     = curdesc;
  359.             PageNGad[gad].gd_Flags    = PLACETEXT_LEFT;
  360.             PageNGad[gad].gd_Text     = getString(curdesc->LabelID);
  361.             PageNGad[gad].gd_ReturnID = GD_FirstOption + gad;
  362.  
  363.             curdesc++;
  364.             dn++;
  365.         }
  366.  
  367.         GadY = PageOffY;
  368.  
  369.         for (gad=NGad; dn; dn--, gad++)
  370.         {
  371.             PageNGad[gad].gd_LeftEdge = GadX;
  372.             PageNGad[gad].gd_TopEdge  = GadY;
  373.  
  374.             GadY += PageNGad[gad].gd_Height + 1;
  375.         }
  376.         GadY += 3;
  377.  
  378.         NGad = gad;
  379.  
  380.         if (GadY > BoxHeight)
  381.             BoxHeight = GadY;
  382.     }
  383.  
  384.  
  385.     /* Ok & Cancel Gadgets */
  386.     OptionsNGad[GDX_OK_Opts].ng_TopEdge = BoxHeight+3;
  387.     OptionsNGad[GDX_Default_Opts].ng_TopEdge = BoxHeight+3;
  388.     OptionsNGad[GDX_Cancel_Opts].ng_TopEdge = BoxHeight+3;
  389.  
  390.     OptionsHeight = BoxHeight + BottomBoxHeight;
  391. }
  392.  
  393.  
  394. static BOOL
  395. CreatePage(void)
  396. {
  397.  
  398.     struct NewGadget  ng;
  399.     struct Gadget    *g;
  400.     UWORD             lc;
  401.  
  402.     if (! (g = CreateContext(&PageGList)))
  403.     {
  404.             return(FALSE);
  405.     }
  406.  
  407.     PageGNum = 0;
  408.     for(lc = 0; lc < OptGadNum; lc++)
  409.     {
  410.         if (PageNGad[lc].gd_ListID == CurPage)
  411.         {
  412.             ng.ng_VisualInfo = VisualInfo;
  413.             ng.ng_TextAttr   = Font;
  414.             ng.ng_LeftEdge   = OffX + ComputeX(PageNGad[lc].gd_LeftEdge);
  415.             ng.ng_TopEdge    = OffY + ComputeY(PageNGad[lc].gd_TopEdge);
  416.             ng.ng_Width      = ComputeX(PageNGad[lc].gd_Width);
  417.             ng.ng_Height     = ComputeY(PageNGad[lc].gd_Height);
  418.             ng.ng_Flags      = PageNGad[lc].gd_Flags;
  419.             ng.ng_GadgetText = PageNGad[lc].gd_Text;
  420.             ng.ng_GadgetID   = PageNGad[lc].gd_ReturnID;
  421.  
  422.             PageNGad[lc].gd_Gadget = g = CreateGadgetA((ULONG)PageNGad[lc].gd_Type, g, &ng, PageNGad[lc].gd_Tags);
  423.             PageGNum++;
  424.  
  425.             if (NOT g)
  426.                     return(FALSE);
  427.         }
  428.     }
  429.     return TRUE;
  430.  
  431. }
  432.  
  433.  
  434. static VOID
  435. FreePage(void)
  436. {
  437.     struct IntuiMessage *msg;
  438.  
  439.     /* We forbid here to keep out of race conditions with Intuition */
  440.     Forbid();
  441.  
  442.     msg = GetHead(&OptionsWnd->UserPort->mp_MsgList);
  443.  
  444.     while (msg)
  445.     {
  446.          struct IntuiMessage *nextmsg=GetSucc(msg), *imsg;
  447.  
  448.          if (imsg = GT_FilterIMsg(msg))
  449.          {
  450.              UWORD ID=((struct Gadget *)imsg->IAddress)->GadgetID;
  451.              ULONG class = imsg->Class;
  452.  
  453.              /* Revert to the original message */
  454.              msg = GT_PostFilterIMsg(imsg);
  455.  
  456.              if ((class == GADGETUP) && (ID >= GD_FirstOption))
  457.              {
  458.                  /* Yes: Remove this message from port */
  459.                  Remove((struct Node *) msg);
  460.                  ReplyMsg((struct Message *) msg);
  461.              }
  462.          }
  463.  
  464.          /* Get pointer to next message */
  465.          msg = nextmsg;
  466.     }
  467.  
  468.     /* Turn multitasking back on */
  469.     Permit();
  470.  
  471.     /* Free gadgets of the previous page */
  472.     FreeGadgets(PageGList);
  473. }
  474.  
  475.  
  476. VOID
  477. OptionsRender(VOID)
  478. {
  479.     UWORD Width, Height;
  480.  
  481.     ComputeFont( OptionsWidth, OptionsHeight );
  482.  
  483.     Width = ComputeX(OptionsWidth);
  484.     Height= ComputeY(OptionsHeight) - ComputeY(BottomBoxHeight);
  485.     
  486.     DrawThinBevelBox( Scr, OptionsWnd->RPort,
  487.                       OffX,  OffY,
  488.                       Width, Height,
  489.                       FALSE );
  490.  
  491.     DrawThinBevelBox( Scr, OptionsWnd->RPort,
  492.                       OffX,  OffY + Height,
  493.                       Width, ComputeY(BottomBoxHeight),
  494.                       FALSE );
  495.  
  496. }
  497.  
  498.  
  499. int
  500. OpenOptionsWindow(VOID)
  501. {
  502.     struct NewGadget  ng;
  503.     struct Gadget    *g;
  504.     UWORD             lc,tc;
  505.     WORD              wleft=WindowLeft, wtop=WindowTop;
  506.     UWORD             ww, wh;
  507.  
  508.     ComputeFont(OptionsWidth, OptionsHeight);
  509.  
  510.     ww = OffX + ComputeX(OptionsWidth) + Scr->WBorRight;
  511.     wh = OffY + ComputeY(OptionsHeight) + Scr->WBorBottom;
  512.  
  513.     if ((ww > Scr->Width) || (wh > Scr->Height))
  514.         return(5L);
  515.  
  516.     SetUpWindowCoordinates(ww, wh, &wleft, &wtop);
  517.  
  518.     if (! (g = CreateContext(&OptionsGList)))
  519.     {
  520.             return(1L);
  521.     }
  522.  
  523.     for(lc = 0,tc = 0; lc < Options_CNT; lc++)
  524.     {
  525.  
  526.             CopyMem((char *)&OptionsNGad[ lc ],(char *)&ng,(long)sizeof(struct NewGadget));
  527.  
  528.             ng.ng_VisualInfo = VisualInfo;
  529.             ng.ng_TextAttr   = Font;
  530.             ng.ng_LeftEdge   = OffX +ComputeX(ng.ng_LeftEdge);
  531.             ng.ng_TopEdge    = OffY +ComputeY(ng.ng_TopEdge);
  532.             ng.ng_Width      = ComputeX(ng.ng_Width);
  533.             ng.ng_Height     = ComputeY(ng.ng_Height);
  534.  
  535.             if ( lc == GDX_Page_Opts )
  536.                 OptionsGTags[ tc+1 ] = (ULONG)&PageLabels[0];
  537.  
  538.             OptionsGadgets[ lc ] = g = CreateGadgetA((ULONG)OptionsGTypes[ lc ],g,&ng,(struct TagItem *) &OptionsGTags[ tc ]);
  539.  
  540.             while(OptionsGTags[ tc ])
  541.                     tc += 2;
  542.  
  543.             tc++;
  544.  
  545.         if (NOT g)
  546.                 return(2L);
  547.     }
  548.  
  549.     if (NOT (OptionsWnd = OpenWindowTags(NULL,
  550.                         WA_Left,         wleft,
  551.                         WA_Top,          wtop,
  552.                         WA_Width,        ww,
  553.                         WA_Height,       wh,
  554.                         WA_IDCMP,        BUTTONIDCMP|CHECKBOXIDCMP|CYCLEIDCMP|STRINGIDCMP|INTEGERIDCMP|IDCMP_REFRESHWINDOW|IDCMP_RAWKEY,
  555.                         WA_Flags,        WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_SMART_REFRESH,
  556.                         WA_Gadgets,      OptionsGList,
  557.                         WA_Title,        OptionsWdt,
  558.                         WA_ScreenTitle,  getString(COPYRIGHT_STRING),
  559.                         WA_PubScreen,    Scr,
  560.                         WA_PubScreenName,PubScreenName,
  561.                         TAG_DONE)))
  562.     return(4L);
  563.  
  564.     OptionsAppWin = AddAppWindowA(0, 0, OptionsWnd, AppMsgPort, NULL);
  565.  
  566.     GT_RefreshWindow(OptionsWnd,NULL);
  567.  
  568.     OptionsRender();
  569.  
  570.     return(0L);
  571. }
  572.  
  573.  
  574.  
  575. VOID
  576. CloseOptionsWindow(VOID)
  577. {
  578.     FreeVec(PageNGad);
  579.     FreeVec(PageLabels);
  580.  
  581.     CloseOneWindow(OptionsWnd,NULL,OptionsGList,OptionsAppWin);
  582.     OptionsWnd = NULL;
  583. }
  584.  
  585.  
  586.  
  587.  
  588. /* handle Options window events */
  589. LONG
  590. HandleOptionsIDCMP(VOID)
  591. {
  592.         struct IntuiMessage *msg;
  593.         struct Gadget       *gadget;
  594.         ULONG                class;
  595.         UWORD                code;
  596.         UWORD                ID;
  597.         BOOL                 close=FALSE;
  598.         LONG                 ret=RET_OKAY;
  599.  
  600.         while (!close && (msg = GT_GetIMsg(OptionsWnd->UserPort)))
  601.         {
  602.                 class = msg->Class;
  603.                 code = msg->Code;
  604.                 gadget = (struct Gadget *)msg->IAddress;
  605.                 GT_ReplyIMsg(msg);
  606.  
  607.                 switch (class)
  608.                 {
  609.                   case GADGETUP:
  610.                   case GADGETDOWN:
  611.                         switch (ID=gadget->GadgetID)
  612.                         {
  613.                             case GD_Page_Opts:
  614.                                 if (code != CurPage)
  615.                                 {
  616.                                     /* New page index */
  617.                                     CurPage = code;
  618.  
  619.                                     /* Remove and free the previous page */
  620.                                     RemoveGList(OptionsWnd, PageGList, PageGNum+1);
  621.                                     FreePage();
  622.  
  623.                                     /* Wipe out the inner area of the page */
  624.                                     SetBPen(OptionsWnd->RPort, 0);
  625.                                     SetAPen(OptionsWnd->RPort, 0);
  626.                                     RectFill(OptionsWnd->RPort, OffX+1,
  627.                                                                 OffY+ComputeY(PageOffY),
  628.                                                                 OffX+ComputeX(OptionsWidth)-2,
  629.                                                                 OffY+ComputeY(OptionsHeight)-ComputeY(BottomBoxHeight)-2);
  630.  
  631.                                     /* Create and add the new page */
  632.                                     CreatePage();
  633.                                     AddGList(OptionsWnd, PageGList, ~0, PageGNum+1, NULL);
  634.  
  635.                                     /* Refresh display */
  636.                                     RefreshGadgets(PageGList, OptionsWnd, NULL);
  637.                                     GT_RefreshWindow(OptionsWnd,NULL);
  638.                                     InitOptionsGadgets();
  639.                                 }
  640.                                 break;
  641.  
  642.                             case GD_Default_Opts:
  643.                                 SetDefaultOptionsGadgets();
  644.                                 break;
  645.  
  646.                             case GD_OK_Opts:
  647.                                 GetYakOption();
  648.                                 CloseOptionsWindow();
  649.                                 if (!ShowWindowID(HOTKEY_WINDOW))
  650.                                     ret = RET_QUIT;
  651.                                 close = TRUE;
  652.                                 CurPage = 0;
  653.                                 break;
  654.  
  655.                             case GD_Cancel_Opts:
  656.                                 CloseOptionsWindow();
  657.                                 if (!ShowWindowID(HOTKEY_WINDOW))
  658.                                     ret = RET_QUIT;
  659.                                 close = TRUE;
  660.                                 CurPage = 0;
  661.                                 break;
  662.  
  663.  
  664.                             default:
  665.                                 ID = ID - GD_FirstOption;
  666.                                 if (PageNGad[ID].gd_ListID == CurPage)
  667.                                 {
  668.                                     switch(PageNGad[ID].gd_Type)
  669.                                     {
  670.                                         case CHECKBOX_KIND:
  671.                                             PageNGad[ID].gd_Flag ^= PageNGad[ID].gd_Desc->LocalID;
  672.  
  673.                                             if (PageNGad[ID].gd_Desc->ExcludeIDs)
  674.                                                 MutualExcludeOptionsGadgets(PageNGad[ID].gd_ListID,
  675.                                                                             PageNGad[ID].gd_Desc->LocalID,
  676.                                                                             PageNGad[ID].gd_Desc->ExcludeIDs);
  677.                                             InitOptionsGadgets();
  678.                                             break;
  679.  
  680.                                         case STRING_KIND:
  681.                                             PageNGad[ID].gd_ArgStr = GetString(gadget);
  682.                                             if (*PageNGad[ID].gd_ArgStr)
  683.                                                 PageNGad[ID].gd_Flag = PageNGad[ID].gd_Desc->LocalID;
  684.                                             else
  685.                                                 PageNGad[ID].gd_Flag = 0;
  686.                                             InitOptionsGadgets();
  687.                                             break;
  688.  
  689.                                         case INTEGER_KIND:
  690.                                             PageNGad[ID].gd_ArgNum = GetNumber(gadget);
  691.                                             PageNGad[ID].gd_Flag   = PageNGad[ID].gd_Desc->LocalID;
  692.                                             InitOptionsGadgets();
  693.                                             break;
  694.                                     }
  695.                                 }
  696.                                 break;
  697.                         }
  698.                         break;
  699.  
  700.                   case IDCMP_RAWKEY:
  701.                         /* Help key pressed */
  702.                         if (code == 95)
  703.                         {
  704.                             /* Display the node */
  705.                             ShowYakHelp(PrefsHelp, yhktypes[curtype].yhkt_HelpNode);
  706.                         }
  707.                         break;
  708.  
  709.                   case REFRESHWINDOW:
  710.                         GT_BeginRefresh(OptionsWnd);
  711.                         GT_EndRefresh(OptionsWnd, TRUE);
  712.                         break;
  713.  
  714.                 }                  /* switch (class) */
  715.  
  716.         }                          /* while more messages */
  717.  
  718.         return ret;
  719. }
  720.  
  721.  
  722.  
  723. /* show our Options window */
  724. BOOL
  725. ShowOptionsWindow(VOID)
  726. {
  727.     static char title[80];
  728.  
  729.     BuildGadgetArray();
  730.  
  731.     strcpy(title, getString(Options_Window_TITLE));
  732.     strcat(title, " ");
  733.     if (curhk->yhk_Name)
  734.         {
  735.                 strcat(title, curhk->yhk_Name);
  736.         }
  737.         else
  738.         {
  739.                 strcat(title, "<<unnamed>>");
  740.         }
  741.         OptionsWdt = title;
  742.  
  743.     if (!OptionsWdi)
  744.     {
  745.         OptionsWdi = TRUE;
  746.  
  747.         LocalizeNGadLabels (Options_CNT, OptionsNGad);
  748.     }
  749.  
  750.     if (!OpenOptionsWindow()) /* like the name says... */
  751.     {
  752.         CreatePage();
  753.         AddGList(OptionsWnd, PageGList, ~0, PageGNum+1, NULL);
  754.         RefreshGadgets(PageGList, OptionsWnd, NULL);
  755.         GT_RefreshWindow(OptionsWnd, NULL);
  756.  
  757.         InitOptionsGadgets();
  758.         wndsigflag = 1 << OptionsWnd->UserPort->mp_SigBit;
  759.         curwin = OptionsWnd;
  760.         curwinID = OPTIONS_WINDOW;
  761.         HandleIDCMP = HandleOptionsIDCMP;
  762.         return TRUE;
  763.     }
  764.  
  765.     FreeVec(PageNGad);
  766.     FreeVec(PageLabels);
  767.  
  768.     FreeGadgets(OptionsGList);
  769.     CloseDownScreen();
  770.     curwin =  NULL;
  771.     wndsigflag = 0L;
  772.     return FALSE;
  773. }
  774.  
  775.  
  776. /* switch from Root window to Options window */
  777. BOOL
  778. SwitchToOptionsWindow(VOID)
  779. {
  780.     CloseWindowID(HOTKEY_WINDOW);
  781.     return ShowOptionsWindow();
  782. }       
  783.  
  784.