home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / C / OTL-MC7.DMS / in.adf / classsource.lha / ClassSource / Libraries / GadTools / GadTools.c
Encoding:
C/C++ Source or Header  |  1995-02-12  |  34.5 KB  |  1,599 lines
  1. #include <classes/Libraries/GadTools.h>
  2.  
  3. #include <exec/libraries.h>
  4.  
  5. #pragma -
  6. #include <pragma/gadtools_lib.h>
  7. #include <pragma/intuition_lib.h>
  8. #include <pragma/graphics_lib.h>
  9. #include <pragma/utility_lib.h>
  10. #include <pragma/exec_lib.h>
  11. #include <pragma/layers_lib.h>
  12. #pragma +
  13.  
  14. extern struct Library *GadToolsBase;
  15.  
  16. VisualInfoC::VisualInfoC()
  17. {
  18.     vi = NULL;
  19. }
  20.  
  21. VisualInfoC::VisualInfoC(ScreenC &s)
  22. {
  23.     vi = NULL;
  24.     getInfo(s);
  25. }
  26.  
  27. VisualInfoC::VisualInfoC(WindowC &w)
  28. {
  29.     vi = NULL;
  30.     getInfo(w);
  31. }
  32.  
  33. VisualInfoC::VisualInfoC(const VisualInfoC &s)
  34. {
  35.     vi = NULL;
  36. }
  37.  
  38. VisualInfoC::~VisualInfoC()
  39. {
  40.     freeInfo();
  41. }
  42.  
  43. VisualInfoC &VisualInfoC::operator= (const VisualInfoC &s)
  44. {
  45.     if (this != &s)
  46.     {
  47.         freeInfo();
  48.         vi = NULL;
  49.     };
  50.     return *this;
  51. }
  52.  
  53. VOID VisualInfoC::getInfo(ScreenC &s)
  54. {
  55.     freeInfo();
  56.     if (!s.screen())
  57.         throw VisualInfoX();
  58.     if (!(vi = GetVisualInfo(s.screen(),TAG_END)))
  59.         throw VisualInfoX();
  60. }
  61.  
  62. VOID VisualInfoC::getInfo(WindowC &w)
  63. {
  64.     freeInfo();
  65.     if (!w.window())
  66.         throw VisualInfoX();
  67.     if (!(vi = GetVisualInfo(w.window()->WScreen,TAG_END)))
  68.         throw VisualInfoX();
  69. }
  70.  
  71. VOID VisualInfoC::freeInfo()
  72. {
  73.     if (vi)
  74.     {
  75.         FreeVisualInfo(vi);
  76.         vi = NULL;
  77.     };
  78. }
  79.  
  80. // *************************************************************
  81.  
  82. MenuItemC::MenuItemC(STRPTR name, const MenuEventC *event,
  83.     STRPTR short_key,    BOOL disabled, BOOL checkmark, BOOL checked)
  84. {
  85.     const struct NewMenu n = { NM_ITEM,name,short_key,
  86.         (disabled ? NM_ITEMDISABLED : 0)|(checkmark ? CHECKIT|MENUTOGGLE : 0)|
  87.         (checked ? CHECKED : 0), 0, (APTR) event };
  88.     newmenu = n;
  89. }
  90.  
  91. VOID MenuItemC::rebuild(gen_arraylist &l)
  92. {
  93.     (struct NewMenu &) l.addTail() = newmenu;
  94. }
  95.  
  96. // *************************************************************
  97.  
  98. MenuSeperatorC::MenuSeperatorC()
  99.     : MenuItemC(NM_BARLABEL)
  100. {
  101. }
  102.  
  103. // *************************************************************
  104.  
  105. MenuSubtitleC::MenuSubtitleC(STRPTR name, const MenuEventC *event,
  106.     BOOL disabled)
  107.     : MenuItemC(name,event,NULL,disabled)
  108. {
  109. }
  110.  
  111. VOID MenuSubtitleC::add(MenuItemC &m)
  112. {
  113.     addTail(m);
  114. }
  115.  
  116. VOID MenuSubtitleC::rebuild(gen_arraylist &l)
  117. {
  118.     MenuItemC::rebuild(l);
  119.     ListCursorC lc(*this);
  120.     while (!lc.isDone()) {
  121.         ((MenuItemC *) lc.item())->rebuild(l);
  122.         lc.next();
  123.     };
  124. }
  125.  
  126. // *************************************************************
  127.  
  128. MenuTitleC::MenuTitleC(STRPTR name, const MenuEventC *event,
  129.     BOOL disabled)
  130. {
  131.     struct NewMenu n = { NM_TITLE, name, NULL,
  132.         (disabled ? NM_MENUDISABLED : 0), 0, (APTR) event };
  133.     newmenu = n;
  134. }
  135.  
  136. VOID MenuTitleC::add(MenuItemC &m)
  137. {
  138.     addTail(m);
  139. }
  140.  
  141. VOID MenuTitleC::rebuild(gen_arraylist &l)
  142. {
  143.     (struct NewMenu &) l.addTail() = newmenu;
  144.     ListCursorC lc(*this);
  145.     while (!lc.isDone()) {
  146.         ((MenuItemC *) lc.item())->rebuild(l);
  147.         lc.next();
  148.     };
  149. }
  150.  
  151. // *************************************************************
  152.  
  153. MenuC::MenuC(VisualInfoC &vi)
  154.     : newmenu(sizeof(struct NewMenu))
  155. {
  156.     strip = NULL;
  157.     layouted = FALSE;
  158.     visualinfo = &vi;
  159. }
  160.  
  161. MenuC::~MenuC()
  162. {
  163.     FreeMenus(strip);
  164. }
  165.  
  166. VOID MenuC::add(MenuTitleC &m)
  167. {
  168.     addTail(m);
  169. }
  170.  
  171. BOOL MenuC::layout(Tag tag1type, ...)
  172. {
  173.     return layout((struct TagItem *) &tag1type);
  174. }
  175.  
  176. BOOL MenuC::layout(struct TagItem *tags)
  177. {
  178.     if (visualinfo->visualInfo() != NULL)
  179.     {
  180.         newmenu.clear();
  181.         ListCursorC lc(*this);
  182.         while (!lc.isDone()) {
  183.             ((MenuTitleC *) lc.item())->rebuild(newmenu);
  184.             lc.next();
  185.         };
  186.         struct NewMenu n = {NM_END, NULL, NULL, 0, 0, NULL };
  187.         (struct NewMenu &) newmenu.addTail() = n;
  188.         if (!(strip = CreateMenus(&((struct NewMenu &) (newmenu.operator[](0))),
  189.                 TAG_MORE, tags)))
  190.             return FALSE;
  191.         return layouted = LayoutMenus(strip,visualinfo->visualInfo(),
  192.             TAG_MORE, tags);
  193.     };
  194.     return FALSE;
  195. }
  196.  
  197. // *************************************************************
  198.  
  199. MenuEventHandlerC::MenuEventHandlerC(MenuC &m, ULONG IDCMPclass)
  200.     : IDCMPEventHandlerC(IDCMPclass)
  201. {
  202.     menu = &m;
  203. }
  204.  
  205. MenuEventHandlerC::~MenuEventHandlerC()
  206. {
  207. }
  208.  
  209. // *************************************************************
  210.  
  211. MenuPickHandlerC::MenuPickHandlerC(MenuC &m)
  212.     : MenuEventHandlerC(m,IDCMP_MENUPICK)
  213. {
  214.     _exit = FALSE;
  215. }
  216.  
  217. MenuPickHandlerC::~MenuPickHandlerC()
  218. {
  219. }
  220.  
  221. BOOL MenuPickHandlerC::_handle(IntuiMessageC &msg)
  222. {
  223.     UWORD menuNumber = msg.Code;
  224.     while (menuNumber != MENUNULL)
  225.     {
  226.         struct MenuItem *item = ItemAddress(menu->menu(),menuNumber);
  227.         MenuEventC *event = (MenuEventC *) (GTMENUITEM_USERDATA(item));
  228.         if (event)
  229.         {
  230.             if (event->pick((WindowC *) msg.IDCMPWindow->UserData,menu,&msg))
  231.             {
  232.                 _exit = TRUE;
  233.                 return TRUE;
  234.             };
  235.         };
  236.         menuNumber = item->NextSelect;
  237.     };
  238.     return TRUE;
  239. }
  240.  
  241. // *************************************************************
  242.  
  243. MenuHelpHandlerC::MenuHelpHandlerC(MenuC &m)
  244.     : MenuEventHandlerC(m,IDCMP_MENUHELP)
  245. {
  246. }
  247.  
  248. MenuHelpHandlerC::~MenuHelpHandlerC()
  249. {
  250. }
  251.  
  252. static struct Menu *MenuAddress(struct Menu *strip, UWORD number)
  253. {
  254.     UWORD menunum = MENUNUM(number);
  255.     if (menunum == NOMENU)
  256.         return NULL;
  257.     UWORD i = 0;
  258.     while ((strip != NULL) && (i < menunum))
  259.     {
  260.         i++;
  261.         strip = strip->NextMenu;
  262.     };
  263.     return strip;
  264. }
  265.  
  266. BOOL MenuHelpHandlerC::_handle(IntuiMessageC &msg)
  267. {
  268.     int menuNumber = msg.Code;
  269.     MenuEventC *event = NULL;
  270.     if (ITEMNUM(menuNumber) != NOITEM)
  271.     {
  272.         struct MenuItem *item = ItemAddress(menu->menu(),menuNumber);
  273.         if (item)
  274.             event = (MenuEventC *) GTMENUITEM_USERDATA(item);
  275.     }
  276.     else if (MENUNUM(menuNumber) != NOMENU)
  277.     {
  278.         struct Menu *menutitle = MenuAddress(menu->menu(),menuNumber);
  279.         if (menutitle)
  280.             event = (MenuEventC *) (GTMENU_USERDATA(menutitle));
  281.     };
  282.     if (event)
  283.     {
  284.         event->help((WindowC *) msg.IDCMPWindow->UserData,menu,&msg);
  285.     };
  286.     return TRUE;
  287. }
  288.  
  289. // ***********************************************************
  290.  
  291. BOOL GTIDCMPortC::handle(ULONG)
  292. {
  293.     if (port())
  294.     {
  295.         MessageC *msg;
  296.         while (msg = (MessageC *) GT_GetIMsg(port()))
  297.         {
  298.             if (handleMsg(*msg))
  299.                 return TRUE;
  300.         };
  301.     };
  302.     return FALSE;
  303. }
  304.  
  305. BOOL GTIDCMPortC::handleMsg(MessageC &msg)
  306. {
  307.     ListCursorC lc(*this);
  308.     BOOL r = FALSE;
  309.     imsg = (IntuiMessageC &) msg;
  310.     if ((imsg.Class & (IDCMP_SIZEVERIFY|IDCMP_MENUVERIFY|IDCMP_REQVERIFY)) == 0)
  311.         GT_ReplyIMsg((struct IntuiMessage *) &msg);
  312.     while (!lc.isDone()) {
  313.         MessageHandlerC *h = (MessageHandlerC *) lc.item();
  314.         if (h->forMe(imsg))
  315.         {
  316.             if (h->handle(imsg))
  317.             {
  318.                 BOOL b = h->exit();
  319.                 r = r | b;
  320.             };
  321.         };
  322.         lc.next();
  323.     };
  324.     if ((imsg.Class & (IDCMP_SIZEVERIFY|IDCMP_MENUVERIFY|IDCMP_REQVERIFY)) != 0)
  325.         GT_ReplyIMsg((struct IntuiMessage *) &msg);
  326.     return r;
  327. }
  328.  
  329. // ***********************************************************
  330.  
  331. GTWindowC::GTWindowC(GTIDCMPortC &p, Tag tag1Type, ...)
  332.     : WindowC(p,(struct TagItem *) &tag1Type)
  333. {
  334. }
  335.  
  336. GTWindowC::GTWindowC(GTIDCMPortC &p, struct TagItem *tags)
  337.     : WindowC(p,tags)
  338. {
  339. }
  340.  
  341. GTWindowC::~GTWindowC()
  342. {
  343. }
  344.  
  345. VOID GTWindowC::open(struct TagItem *tagList)
  346. {
  347.     WindowC::open(tagList);
  348.     GT_RefreshWindow(window(),NULL);
  349. }
  350.  
  351. VOID GTWindowC::refreshGadgets()
  352. {
  353.     WindowC::refreshGadgets();
  354.     if (window())
  355.         GT_RefreshWindow(window(),NULL);
  356. }
  357.  
  358. VOID GTWindowC::beginRefresh()
  359. {
  360.     if (window())
  361.         GT_BeginRefresh(window());
  362. }
  363.  
  364. VOID GTWindowC::endRefresh(BOOL Complete)
  365. {
  366.     if (window())
  367.         GT_EndRefresh(window(),Complete);
  368. }
  369.  
  370. VOID GTWindowC::refreshFrame()
  371. {
  372.     WindowC::refreshFrame();
  373.     if (window())
  374.         GT_RefreshWindow(window(),NULL);
  375. }
  376.  
  377. VOID GTWindowC::freeIDCMP()
  378. {
  379.     Forbid();
  380.     MsgPort *idcmport = window()->UserPort;
  381.     struct IntuiMessage *msg;
  382.     struct Node *succ;
  383.     if (idcmport)
  384.     {
  385.         msg = (struct IntuiMessage *) idcmport->mp_MsgList.lh_Head;
  386.         while (succ = msg->ExecMessage.mn_Node.ln_Succ)
  387.         {
  388.             if (msg->IDCMPWindow == window())
  389.             {
  390.                 Remove((struct Node *) msg);
  391.                 ReplyMsg((struct Message *) msg);
  392.             }
  393.             msg = (IntuiMessage *) succ;
  394.         };
  395.     };
  396.     window()->UserPort = NULL;
  397.     ModifyIDCMP(window(),0);
  398.     Permit();
  399. }
  400.  
  401. // ***********************************************************
  402. GTWindowRefreshHandlerChainC::GTWindowRefreshHandlerChainC(GTWindowC &w)
  403.         : WindowRefreshHandlerChainC(w)
  404. {
  405.     gtwindow = &w;
  406. }
  407.  
  408. BOOL GTWindowRefreshHandlerChainC::handle(MessageC &msg)
  409. {
  410.     LockLayerInfo(&window()->window()->WScreen->LayerInfo);
  411.     gtwindow->beginRefresh();
  412.     WindowEventHandlerChainC::handle(msg);
  413.     gtwindow->endRefresh(TRUE);
  414.     UnlockLayerInfo(&window()->window()->WScreen->LayerInfo);
  415.     return TRUE;
  416. }
  417.  
  418. // ***********************************************************
  419.  
  420. #define PLACETEXT_MASK (PLACETEXT_LEFT|PLACETEXT_RIGHT|PLACETEXT_ABOVE|PLACETEXT_BELOW|PLACETEXT_IN)
  421.  
  422. GTGadgetC::GTGadgetC(GadgetEventC *ev, ULONG kind,
  423.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  424.         STRPTR label, ULONG flags, ULONG defaultplace,
  425.         const TextAttrC *tattr, UWORD id, struct TagItem *taglist)
  426.     : GadgetC(ev), tags(taglist)
  427. {
  428.     gadgetkind = kind;
  429.     ngadget.ng_LeftEdge = LeftEdge;
  430.     ngadget.ng_TopEdge = TopEdge;
  431.     ngadget.ng_Width = Width;
  432.     ngadget.ng_Height = Height;
  433.     ngadget.ng_GadgetText = label;
  434.     if (!(flags & PLACETEXT_MASK))
  435.         flags |= defaultplace;
  436.     ngadget.ng_Flags = flags;
  437.     ngadget.ng_TextAttr = (struct TextAttr *) tattr;
  438.     ngadget.ng_GadgetID = id;
  439.     ngadget.ng_UserData = (APTR) (GadgetC *) this;
  440.     leftB = 0;
  441.     rightB = 0;
  442.     topB = 0;
  443.     bottomB = 0;
  444.     labelWidth = 0;
  445.     privtattr = tattr != NULL;
  446.     if (!tags.find(GT_Underscore))
  447.     {
  448.         tags.append(GT_Underscore,'_',TAG_END);
  449.     };
  450. }
  451.  
  452. GTGadgetC::GTGadgetC(GadgetEventC *ev, ULONG kind,
  453.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  454.         STRPTR label, ULONG flags, ULONG defaultplace,
  455.         const TextAttrC *tattr, UWORD id, Tag tag1type, ...)
  456.     : GadgetC(ev), tags((struct TagItem *) &tag1type)
  457. {
  458.     gadgetkind = kind;
  459.     ngadget.ng_LeftEdge = LeftEdge;
  460.     ngadget.ng_TopEdge = TopEdge;
  461.     ngadget.ng_Width = Width;
  462.     ngadget.ng_Height = Height;
  463.     ngadget.ng_GadgetText = label;
  464.     if (!(flags & PLACETEXT_MASK))
  465.         flags |= defaultplace;
  466.     ngadget.ng_Flags = flags;
  467.     ngadget.ng_TextAttr = (struct TextAttr *) tattr;
  468.     ngadget.ng_GadgetID = id;
  469.     ngadget.ng_UserData = (APTR) (GadgetC *) this;
  470.     leftB = 0;
  471.     rightB = 0;
  472.     topB = 0;
  473.     bottomB = 0;
  474.     labelWidth = 0;
  475.     privtattr = tattr != NULL;
  476.     if (!tags.find(GT_Underscore))
  477.     {
  478.         tags.append(GT_Underscore,'_',TAG_END);
  479.     };
  480. }
  481.  
  482. GTGadgetC::~GTGadgetC()
  483. {
  484. }
  485.  
  486. struct Gadget *GTGadgetC::rebuild(struct Gadget *prev)
  487. {
  488.     if (!prev)
  489.         return NULL;
  490.     if (!vi->isValid())
  491.         return NULL;
  492.     ngadget.ng_VisualInfo = vi->visualInfo();
  493.     return gadget_ob = CreateGadgetA(gadgetkind,prev,&ngadget,tags.tags());
  494. }
  495.  
  496. VOID GTGadgetC::erase(WindowC *w)
  497. {
  498.     if (w && gadget_ob)
  499.     {
  500.         if (w->rastPort())
  501.             EraseRect(w->rastPort(),
  502.                 ngadget.ng_LeftEdge-leftB,
  503.                 ngadget.ng_TopEdge-topB,
  504.                 ngadget.ng_LeftEdge+ngadget.ng_Width+rightB-1,
  505.                 ngadget.ng_TopEdge+ngadget.ng_Height+bottomB-1)
  506.     };
  507. }
  508.  
  509. VOID GTGadgetC::setLeft(WORD left)
  510. {
  511.     ngadget.ng_LeftEdge = left;
  512. }
  513.  
  514. VOID GTGadgetC::setTop(WORD top)
  515. {
  516.     ngadget.ng_TopEdge = top;
  517. }
  518.  
  519. VOID GTGadgetC::setWidth(WORD width)
  520. {
  521.     ngadget.ng_Width = width;
  522.     leftB = 0;
  523.     rightB = 0;
  524.     if (label() && textAttr())
  525.     {
  526.         if (labelWidth <= 0)
  527.         {
  528.             IntuiText l;
  529.             l.ITextFont = (struct TextAttr *) textAttr();
  530.             l.IText = label();
  531.             labelWidth = IntuiTextLength(&l);
  532.         };
  533.         if (ngadget.ng_Flags & PLACETEXT_LEFT)
  534.             leftB = labelWidth + 8;
  535.         if (ngadget.ng_Flags & PLACETEXT_RIGHT)
  536.             rightB = labelWidth + 7;
  537.         if (ngadget.ng_Flags & (PLACETEXT_ABOVE|PLACETEXT_BELOW))
  538.         {
  539.             /* register */ WORD db = labelWidth-ngadget.ng_Width-leftB-rightB;
  540.             if (db > 0)
  541.             {
  542.                 leftB += (db+1) >> 1;
  543.                 rightB += db >> 1;
  544.             };
  545.         };
  546.     };
  547. }
  548.  
  549. VOID GTGadgetC::setHeight(WORD height)
  550. {
  551.     ngadget.ng_Height = height;
  552.     topB = 0;
  553.     bottomB = 0;
  554.     if (textAttr() && label())
  555.     {
  556.         WORD lheight = ((struct TextAttr *) textAttr())->ta_YSize;
  557.         if (ngadget.ng_Flags & PLACETEXT_ABOVE)
  558.             topB = lheight + 4;
  559.         if (ngadget.ng_Flags & PLACETEXT_BELOW)
  560.             bottomB = lheight + 4;
  561.         if (ngadget.ng_Flags & (PLACETEXT_LEFT|PLACETEXT_RIGHT))
  562.         {
  563.             /* register */ WORD db = lheight-ngadget.ng_Height - topB - bottomB;
  564.             if (db > 0)
  565.             {
  566.                 topB += (db + 1) >> 1;
  567.                 bottomB += db >> 1;
  568.             };
  569.         };
  570.     };
  571. }
  572.  
  573. BOOL GTGadgetC::disable(BOOL value)
  574. {
  575.     setAttrs(GA_Disabled,value,TAG_END);
  576.     return TRUE;
  577. }
  578.  
  579. BOOL GTGadgetC::isDisabled()
  580. {
  581.     if (gadget_ob)
  582.         return (gadget_ob->Flags & GFLG_DISABLED) != 0;
  583.     return FALSE;
  584. }
  585.  
  586. VOID GTGadgetC::setTextAttr(const TextAttrC *tattr)
  587. {
  588.     ngadget.ng_TextAttr = (struct TextAttr *) tattr;
  589.     privtattr = tattr != NULL;
  590.     labelWidth = 0;
  591.     calcBorders();
  592. };
  593.  
  594. VOID GTGadgetC::setDefTextAttr(const TextAttrC *tattr)
  595. {
  596.     if ((!ngadget.ng_TextAttr) || (!privtattr))
  597.     {
  598.         ngadget.ng_TextAttr = (struct TextAttr *) tattr;
  599.     };
  600.     labelWidth = 0;
  601.     calcBorders();
  602. };
  603.  
  604. VOID GTGadgetC::setAttrs(struct TagItem *taglist)
  605. {
  606.     if (gadget_ob && window && window->window())
  607.         GT_SetGadgetAttrsA(gadget_ob,window->window(),NULL,taglist);
  608.     tags.set(taglist);
  609. }
  610.  
  611. VOID GTGadgetC::setAttrs(Tag tag1Type, ...)
  612. {
  613.     if (gadget_ob && window && window->window())
  614.         GT_SetGadgetAttrsA(gadget_ob,window->window(),
  615.             NULL,(struct TagItem *) &tag1Type);
  616.     tags.set((struct TagItem *) &tag1Type);
  617. }
  618.  
  619. LONG GTGadgetC::getAttrs(struct TagItem *taglist)
  620. {
  621.     if (GadToolsBase->lib_Version >= 39)
  622.     {
  623.         if (gadget_ob && window && window->window())
  624.             return GT_GetGadgetAttrsA(gadget_ob,window->window(),NULL,taglist);
  625.     };
  626.     LONG tagcounter = 0;
  627.     while (taglist != NULL)
  628.     {
  629.         ULONG *toData = (ULONG *) taglist->ti_Data;
  630.         if (toData)
  631.         {
  632.             struct TagItem *tag = FindTagItem(taglist->ti_Tag,tags.tags());
  633.             if (tag)
  634.             {
  635.                 *toData = tag->ti_Data;
  636.                 tagcounter++;
  637.             };
  638.         };
  639.         taglist++;
  640.     };
  641.     return tagcounter;
  642. }
  643.  
  644. LONG GTGadgetC::getAttrs(Tag tag1type, ...)
  645. {
  646.     return getAttrs((struct TagItem *) &tag1type);
  647. }
  648.  
  649. ULONG GTGadgetC::labelPlace()
  650. {
  651.     return ngadget.ng_Flags & PLACETEXT_MASK;
  652. }
  653.  
  654. VOID GTGadgetC::calcBorders()
  655. {
  656.     ULONG place = ngadget.ng_Flags & PLACETEXT_MASK;
  657.     leftB = 0;
  658.     rightB = 0;
  659.     topB = 0;
  660.     bottomB = 0;
  661.     if (label() && textAttr())
  662.     {
  663.         if (labelWidth <= 0)
  664.         {
  665.             IntuiText l;
  666.             l.ITextFont = (struct TextAttr *) textAttr();
  667.             l.IText = label();
  668.             labelWidth = IntuiTextLength(&l);
  669.         };
  670.         WORD lheight = ((struct TextAttr *) textAttr())->ta_YSize;
  671.         if (place & PLACETEXT_LEFT)
  672.             leftB = labelWidth+8;
  673.         if (place & PLACETEXT_RIGHT)
  674.             rightB = labelWidth+7;
  675.         if (place & PLACETEXT_ABOVE)
  676.             topB = lheight+4;
  677.         if (place & PLACETEXT_BELOW)
  678.             bottomB = lheight+4;
  679.         if (place & (PLACETEXT_LEFT|PLACETEXT_RIGHT))
  680.         {
  681.             /* register */ WORD db = lheight-ngadget.ng_Height-topB-bottomB;
  682.             if (db > 0)
  683.             {
  684.                 topB += (db+1) >> 1;
  685.                 bottomB += db >> 1;
  686.             };
  687.         };
  688.         if (place & (PLACETEXT_ABOVE|PLACETEXT_BELOW))
  689.         {
  690.             /* register */ WORD db = labelWidth-ngadget.ng_Width-leftB-rightB;
  691.             if (db > 0)
  692.             {
  693.                 leftB += (db+1) >> 1;
  694.                 rightB += db >> 1;
  695.             };
  696.         };
  697.     };
  698. }
  699.  
  700. // ***********************************************************
  701.  
  702. GTGadgetListC::GTGadgetListC(
  703.     const TextAttrC &tattr, VisualInfoC &vinfo, GTWindowC &w)
  704. {
  705.     textattr = (TextAttrC *) &tattr;
  706.     vi = &vinfo;
  707.     window = &w;
  708.     lastGadget = NULL;
  709. }
  710.  
  711. GTGadgetListC::~GTGadgetListC()
  712. {
  713.     if (lastGadget)
  714.         lastGadget->NextGadget = NULL;
  715.     FreeGadgets(gadget_ob);
  716. }
  717.  
  718. VOID GTGadgetListC::add(GTGadgetC &g)
  719. {
  720.     g.vi = vi;
  721.     g.window = window;
  722.     g.setDefTextAttr(textattr);
  723.     GadgetListC::add(g);
  724. }
  725.  
  726. struct Gadget *GTGadgetListC::rebuild(struct Gadget *prev)
  727. {
  728.     ListCursorC lc(*this);
  729.     lc.last();
  730.     while (!lc.isDone()) {
  731.         ((GadgetC *) lc.item())->free();
  732.         lc.prev();
  733.     };
  734.     if (lastGadget)
  735.         lastGadget->NextGadget = NULL;
  736.     FreeGadgets(gadget_ob);
  737.     lastGadget = NULL;
  738.     gadget_ob = NULL;
  739.     if (!prev)
  740.         return NULL;
  741.     struct Gadget *p = CreateContext(&gadget_ob);
  742.     if (p)
  743.     {
  744.         prev->NextGadget = gadget_ob;
  745.         prev = p;
  746.         lc.last();
  747.         while (!lc.isDone()) {
  748.             if (!((GadgetC *) lc.item())->textAttr())
  749.                 ((GadgetC *) lc.item())->setDefTextAttr(textattr);
  750.             if (!(prev = ((GadgetC *) lc.item())->rebuild(prev)))
  751.             {
  752.                 FreeGadgets(gadget_ob);
  753.                 gadget_ob = NULL;
  754.                 return NULL;
  755.             };
  756.             lc.prev();
  757.         };
  758.         lastGadget = prev;
  759.         return prev;
  760.     };
  761.     return NULL;
  762. }
  763.  
  764. VOID GTGadgetListC::setTextAttr(const TextAttrC *tattr)
  765. {
  766.     if (tattr)
  767.     {
  768.         textattr = (TextAttrC *) tattr;
  769.         ListCursorC lc(*this);
  770.         while (!lc.isDone())
  771.         {
  772.             ((GadgetC *) lc.item())->setDefTextAttr(textattr);
  773.             lc.next();
  774.         };
  775.     };
  776. }
  777.  
  778. // ***********************************************************
  779.  
  780. GTAnchorGadgetListC::GTAnchorGadgetListC(const TextAttrC &t,
  781.         VisualInfoC &v, GTWindowC &w)
  782.     : GTGadgetListC(t,v,w)
  783. {
  784. }
  785.  
  786. GTAnchorGadgetListC::~GTAnchorGadgetListC()
  787. {
  788. }
  789.  
  790. // ***********************************************************
  791.  
  792. GTRootGadgetListC::GTRootGadgetListC(GTWindowC &w,
  793.     const TextAttrC &tattr, VisualInfoC &vinfo)
  794.     : glist(tattr,vinfo,w)
  795. {
  796.     window = &w;
  797.     w.setGadgetList(glist);
  798. }
  799.  
  800. GTRootGadgetListC::~GTRootGadgetListC()
  801. {
  802.     window->clearGadgetList();
  803. }
  804.  
  805. VOID GTRootGadgetListC::add(GTGadgetC &g)
  806. {
  807.     glist.add(g);
  808. }
  809.  
  810. VOID GTRootGadgetListC::rebuild(BOOL refresh)
  811. {
  812.     window->clearGadgetList(FALSE,FALSE);
  813.     struct Gadget first;
  814.     glist.rebuild(&first);
  815.     window->addIDCMP(glist.idcmp());
  816.     window->resetGadgetList(refresh);
  817. }
  818.  
  819. VOID GTRootGadgetListC::erase()
  820. {
  821.     window->clearGadgetList();
  822.     glist.erase(window);
  823. }
  824.  
  825. VOID GTRootGadgetListC::refresh()
  826. {
  827.     glist.refresh(window);
  828. }
  829.  
  830. VOID GTRootGadgetListC::setTextAttr(const TextAttrC *tattr)
  831. {
  832.     glist.setTextAttr(tattr);
  833. }
  834.  
  835. // ***********************************************************
  836.  
  837. GTButtonC::GTButtonC(GadgetEventC *event,
  838.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  839.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  840.         struct TagItem *taglist)
  841.     : GTGadgetC(event,BUTTON_KIND,LeftEdge,TopEdge,
  842.         Width,Height,label,flags,PLACETEXT_IN,tattr,id,taglist),
  843.       GButtonC()
  844. {
  845. }
  846.  
  847. GTButtonC::GTButtonC(GadgetEventC *event,
  848.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  849.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  850.         Tag tag1Type, ...)
  851.     : GTGadgetC(event,BUTTON_KIND,LeftEdge,TopEdge,
  852.         Width,Height,label,flags,PLACETEXT_IN,tattr,id,
  853.         (struct TagItem *) &tag1Type),
  854.       GButtonC()
  855. {
  856. }
  857.  
  858. // ***********************************************************
  859.  
  860. GTStringC::GTStringC(GadgetEventC *event,
  861.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  862.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  863.         struct TagItem *taglist)
  864.     : GTGadgetC(event,STRING_KIND,LeftEdge,TopEdge,
  865.         Width,Height,label,flags,PLACETEXT_LEFT,tattr,id,taglist),
  866.       GStringC()
  867. {
  868. }
  869.  
  870. GTStringC::GTStringC(GadgetEventC *event,
  871.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  872.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  873.         Tag tag1Type, ...)
  874.     : GTGadgetC(event,STRING_KIND,LeftEdge,TopEdge,
  875.         Width,Height,label,flags,PLACETEXT_LEFT,tattr,id,
  876.         (struct TagItem *) &tag1Type),
  877.       GStringC()
  878. {
  879. }
  880.  
  881. VOID GTStringC::free()
  882. {
  883.     if (gadget_ob)
  884.     {
  885.         str = get();
  886.         taglist()->set(GTST_String,(STRPTR) str,TAG_END);
  887.     };
  888. }
  889.  
  890. VOID GTStringC::set(STRPTR s)
  891. {
  892.     setAttrs(GTST_String,s,TAG_END);
  893. }
  894.  
  895. STRPTR GTStringC::get()
  896. {
  897.     if (gadget_ob)
  898.         return (STRPTR) ((struct StringInfo *) gadget_ob->SpecialInfo)->Buffer;
  899.     return NULL;
  900. }
  901.  
  902. // ***********************************************************
  903.  
  904. GTIntegerC::GTIntegerC(GadgetEventC *event,
  905.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  906.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  907.         struct TagItem *taglist)
  908.     : GTGadgetC(event,INTEGER_KIND,LeftEdge,TopEdge,
  909.         Width,Height,label,flags,PLACETEXT_LEFT,tattr,id,taglist),
  910.       GIntegerC()
  911. {
  912. }
  913.  
  914. GTIntegerC::GTIntegerC(GadgetEventC *event,
  915.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  916.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  917.         Tag tag1Type, ...)
  918.     : GTGadgetC(event,INTEGER_KIND,LeftEdge,TopEdge,
  919.         Width,Height,label,flags,PLACETEXT_LEFT,tattr,id,
  920.         (struct TagItem *) &tag1Type),
  921.       GIntegerC()
  922. {
  923. }
  924.  
  925. VOID GTIntegerC::free()
  926. {
  927.     if (gadget_ob)
  928.         taglist()->set(GTIN_Number,get(),TAG_END);
  929. }
  930.  
  931. VOID GTIntegerC::set(LONG integer)
  932. {
  933.     setAttrs(GTIN_Number,integer,TAG_END);
  934. }
  935.  
  936. LONG GTIntegerC::get()
  937. {
  938.     if (gadget_ob)
  939.         return ((struct StringInfo *) gadget_ob->SpecialInfo)->LongInt;
  940. }
  941.  
  942. // ***********************************************************
  943.  
  944. GTCheckboxC::GTCheckboxC(GadgetEventC *event,
  945.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  946.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  947.         struct TagItem *taglist)
  948.     : GTGadgetC(event,CHECKBOX_KIND,LeftEdge,TopEdge,
  949.         Width,Height,label,flags,PLACETEXT_LEFT,tattr,id,taglist),
  950.       GCheckboxC()
  951. {
  952. }
  953.  
  954. GTCheckboxC::GTCheckboxC(GadgetEventC *event,
  955.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  956.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  957.         Tag tag1Type, ...)
  958.     : GTGadgetC(event,CHECKBOX_KIND,LeftEdge,TopEdge,
  959.         Width,Height,label,flags,PLACETEXT_LEFT,tattr,id,
  960.         (struct TagItem *) &tag1Type),
  961.       GCheckboxC()
  962. {
  963. }
  964.  
  965. VOID GTCheckboxC::free()
  966. {
  967.     if (gadget_ob)
  968.         taglist()->set(GTCB_Checked,checked(),TAG_END);
  969. }
  970.  
  971. VOID GTCheckboxC::check(BOOL value)
  972. {
  973.     setAttrs(GTCB_Checked,value,TAG_END);
  974. }
  975.  
  976. BOOL GTCheckboxC::checked()
  977. {
  978.     if (gadget_ob)
  979.         return (gadget_ob->Flags & GFLG_SELECTED) != 0;
  980.     return FALSE;
  981. }
  982.  
  983. // ***********************************************************
  984.  
  985. VOID GTRadioEventC::up(WindowC *, GadgetC *g, IntuiMessageC *msg)
  986. {
  987.     ((struct GTRadioC *) g)->setAttrs(GTMX_Active,msg->Code,TAG_END);
  988. }
  989.  
  990. // ***********************************************************
  991.  
  992. GTRadioC::GTRadioC(GadgetEventC *event,
  993.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  994.         stringarray &buttonLabels,
  995.         STRPTR label, ULONG flags, ULONG place, const TextAttrC *tattr,
  996.         UWORD id, struct TagItem *tags)
  997.     : GTGadgetC(event,MX_KIND,LeftEdge,TopEdge,
  998.         Width,Height,label,flags & (~PLACETEXT_MASK),0,tattr,id,tags),
  999.       GRadioC(),
  1000.       labels(buttonLabels)
  1001. {
  1002.     labelsplace = place & (PLACETEXT_LEFT|PLACETEXT_RIGHT);
  1003.     if (!labelsplace)
  1004.         labelsplace = PLACETEXT_LEFT;
  1005.     struct TagItem *l = taglist()->find(GTMX_Labels);
  1006.     if (l)
  1007.         l->ti_Data = (ULONG) labels.strings()
  1008.     else
  1009.         taglist()->append(GTMX_Labels,(ULONG) labels.strings(),TAG_END);
  1010. }
  1011.  
  1012. GTRadioC::GTRadioC(GadgetEventC *event,
  1013.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  1014.         stringarray &buttonLabels,
  1015.         STRPTR label, ULONG flags, ULONG place, const TextAttrC *tattr,
  1016.         UWORD id, Tag tag1Type, ...)
  1017.     : GTGadgetC(event,MX_KIND,LeftEdge,TopEdge,
  1018.         Width,Height,label,flags & (~PLACETEXT_MASK),0,tattr,id,
  1019.         (struct TagItem *) &tag1Type),
  1020.       GRadioC(),
  1021.       labels(buttonLabels)
  1022. {
  1023.     labelsplace = place & (PLACETEXT_LEFT|PLACETEXT_RIGHT);
  1024.     if (!labelsplace)
  1025.         labelsplace = PLACETEXT_LEFT;
  1026.     struct TagItem *l = taglist()->find(GTMX_Labels);
  1027.     if (l)
  1028.         l->ti_Data = (ULONG) labels.strings()
  1029.     else
  1030.         taglist()->append(GTMX_Labels,(ULONG) labels.strings(),TAG_END);
  1031. }
  1032.  
  1033. VOID GTRadioC::free()
  1034. {
  1035.     if (gadget_ob)
  1036.         taglist()->set(GTMX_Active,selected(),TAG_END);
  1037. }
  1038.  
  1039. struct Gadget *GTRadioC::rebuild(struct Gadget *prev)
  1040. {
  1041.     if (!prev)
  1042.         return NULL;
  1043.     if (!vinfo()->isValid())
  1044.         return NULL;
  1045.     NewGadget ng = *newgadget();
  1046.     ng.ng_Height = ((struct TextAttr *) textAttr())->ta_YSize+1;
  1047.     ng.ng_Flags = (ng.ng_Flags & (~PLACETEXT_MASK)) | labelsplace;
  1048.     ng.ng_VisualInfo = vinfo()->visualInfo();
  1049.     return gadget_ob = CreateGadgetA(MX_KIND,prev,&ng,taglist()->tags());
  1050. }
  1051.  
  1052. VOID GTRadioC::calcBorders()
  1053. {
  1054.     GTGadgetC::calcBorders();
  1055.     WORD lwidth = 0;
  1056.     STRPTR *labels = (STRPTR *) taglist()->getData(GTMX_Labels,NULL);
  1057.     if (labels && textAttr())
  1058.     {
  1059.         IntuiText l;
  1060.         l.ITextFont = (struct TextAttr *) textAttr();
  1061.         while (*labels) {
  1062.             l.IText = *labels;
  1063.             /* register */ WORD lw = IntuiTextLength(&l);
  1064.             if (lw > lwidth)
  1065.                 lwidth = lw;
  1066.             labels++;
  1067.         };
  1068.     };
  1069.     if (labelsplace & PLACETEXT_LEFT)
  1070.     {
  1071.         if (lwidth + 8 > leftB)
  1072.             leftB = lwidth + 8;
  1073.     };
  1074.     if (labelsplace & PLACETEXT_RIGHT)
  1075.     {
  1076.         if (lwidth + 7 > rightB)
  1077.             rightB = lwidth + 7;
  1078.     };
  1079. }
  1080.  
  1081. VOID GTRadioC::select(ULONG active)
  1082. {
  1083.     setAttrs(GTMX_Active,(ULONG) active, TAG_END);
  1084. }
  1085.  
  1086. ULONG GTRadioC::selected()
  1087. {
  1088.     ULONG retval = ~0;
  1089.     getAttrs(GTMX_Active,&retval,TAG_END);
  1090.     return retval;
  1091. }
  1092.  
  1093. // ***********************************************************
  1094.  
  1095. VOID GTCycleEventC::up(WindowC *, GadgetC *g, IntuiMessageC *msg)
  1096. {
  1097.     ((struct GTCycleC *) g)->setAttrs(GTCY_Active,msg->Code,TAG_END);
  1098. }
  1099.  
  1100. // ***********************************************************
  1101.  
  1102. GTCycleC::GTCycleC(GadgetEventC *event,
  1103.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  1104.         stringarray &cyclelabels,
  1105.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  1106.         struct TagItem *tags)
  1107.     : GTGadgetC(event,CYCLE_KIND,LeftEdge,TopEdge,
  1108.         Width,Height,label,flags,PLACETEXT_LEFT,tattr,id,tags),
  1109.       GCycleC(),
  1110.       labels(cyclelabels)
  1111. {
  1112.     struct TagItem *l = taglist()->find(GTCY_Labels);
  1113.     if (l)
  1114.         l->ti_Data = (ULONG) labels.strings()
  1115.     else
  1116.         taglist()->append(GTCY_Labels,(ULONG) labels.strings(),TAG_END);
  1117. }
  1118.  
  1119. GTCycleC::GTCycleC(GadgetEventC *event,
  1120.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  1121.         stringarray &cyclelabels,
  1122.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  1123.         Tag tag1Type, ...)
  1124.     : GTGadgetC(event,CYCLE_KIND,LeftEdge,TopEdge,
  1125.         Width,Height,label,flags,PLACETEXT_LEFT,tattr,id,
  1126.         (struct TagItem *) &tag1Type),
  1127.       GCycleC(),
  1128.       labels(cyclelabels)
  1129. {
  1130.     struct TagItem *l = taglist()->find(GTCY_Labels);
  1131.     if (l)
  1132.         l->ti_Data = (ULONG) labels.strings()
  1133.     else
  1134.         taglist()->append(GTCY_Labels,(ULONG) labels.strings(),TAG_END);
  1135. }
  1136.  
  1137. VOID GTCycleC::free()
  1138. {
  1139.     if (gadget_ob)
  1140.         taglist()->set(GTCY_Active,selected(),TAG_END);
  1141. }
  1142.  
  1143. struct Gadget *GTCycleC::rebuild(struct Gadget *prev)
  1144. {
  1145.     if (!prev)
  1146.         return NULL;
  1147.     if (!vinfo()->isValid())
  1148.         return NULL;
  1149.     newgadget()->ng_VisualInfo = vinfo()->visualInfo();
  1150.     gadget_ob = CreateGadgetA(CYCLE_KIND,prev,newgadget(),taglist()->tags());
  1151.     return gadget_ob;
  1152. }
  1153.  
  1154. VOID GTCycleC::setLabels(STRPTR *l)
  1155. {
  1156.     labels = stringarray(l);
  1157.     setAttrs(GTCY_Labels,(ULONG) labels.strings(),TAG_END);
  1158. }
  1159.  
  1160. VOID GTCycleC::setLabels(STRPTR label1, ...)
  1161. {
  1162.     labels = stringarray(&label1);
  1163.     setAttrs(GTCY_Labels,(ULONG) labels.strings(),TAG_END);
  1164. }
  1165.  
  1166. STRPTR *GTCycleC::getLabels()
  1167. {
  1168.     return labels.strings();
  1169. }
  1170.  
  1171. ULONG GTCycleC::labelsCount()
  1172. {
  1173.     return labels.length();
  1174. }
  1175.  
  1176. UWORD GTCycleC::addLabel(STRPTR label)
  1177. {
  1178.     if (!label)
  1179.         return ~0;
  1180.     UWORD retval = (UWORD) labels.length();
  1181.     labels.addTail(label);
  1182.     setAttrs(GTCY_Labels,(ULONG) labels.strings(),TAG_END);
  1183.     return retval;
  1184. }
  1185.  
  1186. VOID GTCycleC::remLabel(UWORD count)
  1187. {
  1188.     if (count != ~0)
  1189.     {
  1190.         labels.remove(count);
  1191.         setAttrs(GTCY_Labels,(ULONG) labels.strings(),TAG_END);
  1192.     };
  1193. }
  1194.  
  1195. VOID GTCycleC::select(ULONG active)
  1196. {
  1197.     setAttrs(GTCY_Active,active,TAG_END);
  1198. }
  1199.  
  1200. ULONG GTCycleC::selected()
  1201. {
  1202.     ULONG retval = ~0;
  1203.     getAttrs(GTCY_Active,&retval,TAG_END);
  1204.     return retval;
  1205. }
  1206.  
  1207. // ***********************************************************
  1208.  
  1209. VOID GTSliderEventC::up(WindowC *, GadgetC *g, IntuiMessageC *msg)
  1210. {
  1211.     ((struct GTSliderC *) g)->setAttrs(GTSL_Level,msg->Code,TAG_END);
  1212. }
  1213.  
  1214. // ***********************************************************
  1215.  
  1216. GTSliderC::GTSliderC(GadgetEventC *event,
  1217.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  1218.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  1219.         struct TagItem *taglist)
  1220.     : GTGadgetC(event,SLIDER_KIND,LeftEdge,TopEdge,
  1221.         Width,Height,label,flags,PLACETEXT_LEFT,tattr,id,taglist),
  1222.       GSliderC()
  1223. {
  1224. }
  1225.  
  1226. GTSliderC::GTSliderC(GadgetEventC *event,
  1227.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  1228.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  1229.         Tag tag1Type, ...)
  1230.     : GTGadgetC(event,SLIDER_KIND,LeftEdge,TopEdge,
  1231.         Width,Height,label,flags,PLACETEXT_LEFT,tattr,id,
  1232.         (struct TagItem *) &tag1Type),
  1233.       GSliderC()
  1234. {
  1235. }
  1236.  
  1237. VOID GTSliderC::free()
  1238. {
  1239.     if (gadget_ob)
  1240.         taglist()->set(GTSL_Level,level(),TAG_END);
  1241. }
  1242.  
  1243. VOID GTSliderC::calcBorders()
  1244. {
  1245.     GTGadgetC::calcBorders();
  1246.     UWORD maxlevellen = taglist()->getData(GTSL_MaxLevelLen,0);
  1247.     if (maxlevellen > 0 && textAttr())
  1248.     {
  1249.         IntuiText l;
  1250.         l.ITextFont = (struct TextAttr *) textAttr();
  1251.         l.IText = "0";
  1252.         ULONG levelwidth = IntuiTextLength(&l)*maxlevellen;
  1253.         ULONG levelheight = ((struct TextAttr *) textAttr())->ta_YSize;
  1254.         ULONG lplace = taglist()->getData(GTSL_LevelPlace,PLACETEXT_LEFT);
  1255.         if (lplace & PLACETEXT_LEFT)
  1256.         {
  1257.             if (levelwidth+8 > leftB)
  1258.                 leftB = levelwidth+8;
  1259.         };
  1260.         if (lplace & PLACETEXT_RIGHT)
  1261.         {
  1262.             if (levelwidth+7 > rightB)
  1263.                 rightB = levelwidth+7;
  1264.         };
  1265.         if (lplace & PLACETEXT_ABOVE)
  1266.         {
  1267.             if (levelheight > topB)
  1268.                 topB = levelheight;
  1269.         };
  1270.         if (lplace & PLACETEXT_BELOW)
  1271.         {
  1272.             if (levelheight > bottomB)
  1273.                 bottomB = levelheight;
  1274.         };
  1275.         if (lplace & (PLACETEXT_LEFT|PLACETEXT_RIGHT|PLACETEXT_IN))
  1276.         {
  1277.             LONG db = levelheight-height()-topB-bottomB;
  1278.             if (db > 0)
  1279.             {
  1280.                 topB += (db+1) >> 1;
  1281.                 bottomB += db >> 1;
  1282.             };
  1283.         };
  1284.         if (lplace & (PLACETEXT_ABOVE|PLACETEXT_BELOW|PLACETEXT_IN))
  1285.         {
  1286.             LONG db = levelwidth-width()-leftB-rightB;
  1287.             if (db > 0)
  1288.             {
  1289.                 leftB += (db+1) >> 1;
  1290.                 rightB += db >> 1;
  1291.             };
  1292.         };
  1293.     };
  1294. }
  1295.  
  1296. VOID GTSliderC::setMin(UWORD min)
  1297. {
  1298.     setAttrs(GTSL_Min,min,TAG_END);
  1299. }
  1300.  
  1301. UWORD GTSliderC::min()
  1302. {
  1303.     LONG retval = 0;
  1304.     getAttrs(GTSL_Min,&retval,TAG_END);
  1305.     return retval;
  1306. }
  1307.  
  1308. VOID GTSliderC::setMax(UWORD max)
  1309. {
  1310.     setAttrs(GTSL_Max,max,TAG_END);
  1311. }
  1312.  
  1313. UWORD GTSliderC::max()
  1314. {
  1315.     LONG retval = 0;
  1316.     getAttrs(GTSL_Max,&retval,TAG_END);
  1317.     return retval;
  1318. }
  1319.  
  1320. VOID GTSliderC::setLevel(UWORD level)
  1321. {
  1322.     setAttrs(GTSL_Level,level,TAG_END);
  1323. }
  1324.  
  1325. UWORD GTSliderC::level()
  1326. {
  1327.     LONG retval = 0;
  1328.     getAttrs(GTSL_Level,&retval,TAG_END);
  1329.     return retval;
  1330. }
  1331.  
  1332. // ***********************************************************
  1333.  
  1334. VOID GTScrollerEventC::up(WindowC *, GadgetC *g, IntuiMessageC *msg)
  1335. {
  1336.     ((GTScrollerC *) g)->setAttrs(GTSC_Top,msg->Code,TAG_END);
  1337. }
  1338.  
  1339. // ***********************************************************
  1340.  
  1341. GTScrollerC::GTScrollerC(GadgetEventC *event,
  1342.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  1343.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  1344.         struct TagItem *taglist)
  1345.     : GTGadgetC(event,SCROLLER_KIND,LeftEdge,TopEdge,
  1346.         Width,Height,label,flags,PLACETEXT_LEFT,tattr,id,taglist),
  1347.       GScrollerC()
  1348. {
  1349. }
  1350.  
  1351. GTScrollerC::GTScrollerC(GadgetEventC *event,
  1352.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  1353.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  1354.         Tag tag1Type, ...)
  1355.     : GTGadgetC(event,SCROLLER_KIND,LeftEdge,TopEdge,
  1356.         Width,Height,label,flags,PLACETEXT_LEFT,tattr,id,
  1357.         (struct TagItem *) &tag1Type),
  1358.       GScrollerC()
  1359. {
  1360. }
  1361.  
  1362. VOID GTScrollerC::free()
  1363. {
  1364.     if (gadget_ob)
  1365.         taglist()->set(GTSC_Top,pot(),TAG_END);
  1366. }
  1367.  
  1368. VOID GTScrollerC::setPot(UWORD top)
  1369. {
  1370.     setAttrs(GTSC_Top,top,TAG_END);
  1371. }
  1372.  
  1373. UWORD GTScrollerC::pot()
  1374. {
  1375.     LONG retval = 0;
  1376.     getAttrs(GTSC_Top,&retval,TAG_END);
  1377.     return retval;
  1378. }
  1379.  
  1380. VOID GTScrollerC::setTotal(UWORD total)
  1381. {
  1382.     setAttrs(GTSC_Total,total,TAG_END);
  1383. }
  1384.  
  1385. UWORD GTScrollerC::total()
  1386. {
  1387.     LONG retval = 0;
  1388.     getAttrs(GTSC_Total,&retval,TAG_END);
  1389.     return retval;
  1390. }
  1391.  
  1392. VOID GTScrollerC::setVisible(UWORD visible)
  1393. {
  1394.     setAttrs(GTSC_Visible,visible,TAG_END);
  1395. }
  1396.  
  1397. UWORD GTScrollerC::visible()
  1398. {
  1399.     LONG retval = 0;
  1400.     getAttrs(GTSC_Visible,&retval,TAG_END);
  1401.     return retval;
  1402. }
  1403.  
  1404. // ***********************************************************
  1405.  
  1406. VOID GTListviewEventC::up(WindowC *, GadgetC *g, IntuiMessageC *msg)
  1407. {
  1408.     ((GTListviewC *) g)->setAttrs(GTLV_Selected,msg->Code,TAG_END);
  1409. }
  1410.  
  1411. // ***********************************************************
  1412.  
  1413. GTListviewC::GTListviewC(GadgetEventC *event,
  1414.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  1415.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  1416.         struct TagItem *tags)
  1417.     : GTGadgetC(event,LISTVIEW_KIND,LeftEdge,TopEdge,
  1418.         Width,Height,label,flags,PLACETEXT_ABOVE,tattr,id,tags),
  1419.       GListviewC()
  1420. {
  1421.     list = (EListC *) taglist()->getData(GTLV_Labels,NULL);
  1422. }
  1423.  
  1424. GTListviewC::GTListviewC(GadgetEventC *event,
  1425.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  1426.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  1427.         Tag tag1Type, ...)
  1428.     : GTGadgetC(event,LISTVIEW_KIND,LeftEdge,TopEdge,
  1429.         Width,Height,label,flags,PLACETEXT_ABOVE,tattr,id,
  1430.         (struct TagItem *) &tag1Type),
  1431.       GListviewC()
  1432. {
  1433.     list = (EListC *) taglist()->getData(GTLV_Labels,NULL);
  1434. }
  1435.  
  1436. VOID GTListviewC::free()
  1437. {
  1438.     if (gadget_ob)
  1439.         taglist()->set(GTLV_Selected,selected(),TAG_END);
  1440. }
  1441.  
  1442. VOID GTListviewC::setList(EListC *header)
  1443. {
  1444.     list = header;
  1445.     setAttrs(GTLV_Labels,list,TAG_END);
  1446. }
  1447.  
  1448. EListC *GTListviewC::getList()
  1449. {
  1450.     return list;
  1451. }
  1452.  
  1453. VOID GTListviewC::detachList()
  1454. {
  1455.     setAttrs(GTLV_Labels,~0,TAG_END);
  1456. }
  1457.  
  1458. VOID GTListviewC::attachList()
  1459. {
  1460.     setAttrs(GTLV_Labels,list,TAG_END);
  1461. }
  1462.  
  1463. VOID GTListviewC::select(ULONG selected)
  1464. {
  1465.     setAttrs(GTLV_Selected,selected,TAG_END);
  1466. }
  1467.  
  1468. ULONG GTListviewC::selected()
  1469. {
  1470.     LONG retval = ~0;
  1471.     getAttrs(GTLV_Selected,&retval,TAG_END);
  1472.     return retval;
  1473. }
  1474.  
  1475. VOID GTListviewC::clearSelection()
  1476. {
  1477.     setAttrs(GTLV_Selected,~0,TAG_END);
  1478. }
  1479.  
  1480. // ***********************************************************
  1481.  
  1482. VOID GTPaletteEventC::up(WindowC *, GadgetC *g, IntuiMessageC *msg)
  1483. {
  1484.     ((GTPaletteC *) g)->setAttrs(GTPA_Color,msg->Code,TAG_END);
  1485. }
  1486.  
  1487. // ***********************************************************
  1488.  
  1489. GTPaletteC::GTPaletteC(GadgetEventC *event,
  1490.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  1491.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  1492.         struct TagItem *taglist)
  1493.     : GTGadgetC(event,PALETTE_KIND,LeftEdge,TopEdge,
  1494.         Width,Height,label,flags,PLACETEXT_LEFT,tattr,id,taglist),
  1495.       GPaletteC()
  1496. {
  1497. }
  1498.  
  1499. GTPaletteC::GTPaletteC(GadgetEventC *event,
  1500.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  1501.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  1502.         Tag tag1Type, ...)
  1503.     : GTGadgetC(event,PALETTE_KIND,LeftEdge,TopEdge,
  1504.         Width,Height,label,flags,PLACETEXT_LEFT,tattr,id,
  1505.         (struct TagItem *) &tag1Type),
  1506.       GPaletteC()
  1507. {
  1508. }
  1509.  
  1510. VOID GTPaletteC::free()
  1511. {
  1512.     if (gadget_ob)
  1513.         taglist()->set(GTPA_Color,selected(),TAG_END);
  1514. }
  1515.  
  1516. VOID GTPaletteC::select(ULONG color)
  1517. {
  1518.     setAttrs(GTPA_Color,color,TAG_END);
  1519. }
  1520.  
  1521. ULONG GTPaletteC::selected()
  1522. {
  1523.     LONG retval = ~0;
  1524.     getAttrs(GTPA_Color,&retval,TAG_END);
  1525.     return retval;
  1526. }
  1527.  
  1528. // ***********************************************************
  1529.  
  1530. GTTextC::GTTextC(GadgetEventC *event,
  1531.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  1532.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  1533.         struct TagItem *taglist)
  1534.     : GTGadgetC(event,TEXT_KIND,LeftEdge,TopEdge,
  1535.         Width,Height,label,flags,PLACETEXT_LEFT,tattr,id,taglist),
  1536.       GTextC()
  1537. {
  1538. }
  1539.  
  1540. GTTextC::GTTextC(GadgetEventC *event,
  1541.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  1542.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  1543.         Tag tag1Type, ...)
  1544.     : GTGadgetC(event,TEXT_KIND,LeftEdge,TopEdge,
  1545.         Width,Height,label,flags,PLACETEXT_LEFT,tattr,id,
  1546.         (struct TagItem *) &tag1Type),
  1547.       GTextC()
  1548. {
  1549. }
  1550.  
  1551. VOID GTTextC::set(STRPTR text)
  1552. {
  1553.     setAttrs(GTTX_Text,text,TAG_END);
  1554. }
  1555.  
  1556. STRPTR GTTextC::get()
  1557. {
  1558.     STRPTR retval = NULL;
  1559.     getAttrs(GTTX_Text,&retval,TAG_END);
  1560.     return retval;
  1561. }
  1562.  
  1563. // ***********************************************************
  1564.  
  1565. GTNumberC::GTNumberC(GadgetEventC *event,
  1566.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  1567.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  1568.         struct TagItem *taglist)
  1569.     : GTGadgetC(event,NUMBER_KIND,LeftEdge,TopEdge,
  1570.         Width,Height,label,flags,PLACETEXT_LEFT,tattr,id,taglist),
  1571.       GNumberC()
  1572. {
  1573. }
  1574.  
  1575. GTNumberC::GTNumberC(GadgetEventC *event,
  1576.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  1577.         STRPTR label, ULONG flags, const TextAttrC *tattr, UWORD id,
  1578.         Tag tag1Type, ...)
  1579.     : GTGadgetC(event,NUMBER_KIND,LeftEdge,TopEdge,
  1580.         Width,Height,label,flags,PLACETEXT_LEFT,tattr,id,
  1581.         (struct TagItem *) &tag1Type),
  1582.       GNumberC()
  1583. {
  1584. }
  1585.  
  1586. VOID GTNumberC::set(LONG number)
  1587. {
  1588.     setAttrs(GTNM_Number,number,TAG_END);
  1589. }
  1590.  
  1591. LONG GTNumberC::get()
  1592. {
  1593.     LONG retval = 0;
  1594.     getAttrs(GTNM_Number,&retval,TAG_END);
  1595.     return retval;
  1596. }
  1597.  
  1598. // ***********************************************************
  1599.