home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / C / OTL-MC7.DMS / in.adf / classes.lha / Classes / Libraries / GadTools.h < prev   
Encoding:
C/C++ Source or Header  |  1995-01-31  |  28.8 KB  |  783 lines
  1. #ifndef CPP_LIBRARIES_GADTOOLS_H
  2. #define CPP_LIBRARIES_GADTOOLS_H
  3.  
  4. // GadTools Klassen
  5. //
  6. // Autor: Jochen Becher
  7. //
  8. // Historie:
  9. // Version 1.0, am 9. Januar 94
  10.  
  11. #ifndef LIBRARIES_GADTOOLS_H
  12. #include <libraries/gadtools.h>
  13. #endif
  14.  
  15. #ifndef INTUITION_INTUITION_H
  16. #include <intuition/intuition.h>
  17. #endif
  18.  
  19. #ifndef INTUITION_GADGETCLASS_H
  20. #include <intuition/gadgetclass.h>
  21. #endif
  22.  
  23. #ifndef CPP_DATASTRUCTURES_GENARRAYLIST_H
  24. #include <classes/datastructures/genarraylist.h>
  25. #endif
  26.  
  27. #ifndef CPP_DATASTRUCTURES_STRINGARRAY_H
  28. #include <classes/datastructures/stringarray.h>
  29. #endif
  30.  
  31. #ifndef CPP_INTUITION_SCREEN_H
  32. #include <classes/intuition/screen.h>
  33. #endif
  34.  
  35. #ifndef CPP_INTUITION_WINDOW_H
  36. #include <classes/intuition/window.h>
  37. #endif
  38.  
  39. #ifndef CPP_UTILITY_TAGITEM_H
  40. #include <classes/utility/tagitem.h>
  41. #endif
  42.  
  43. #ifndef CPP_INTUITION_GADGETS_H
  44. #include <classes/intuition/gadgets.h>
  45. #endif
  46.  
  47. #ifndef CPP_GRAPHICS_TEXT_H
  48. #include <classes/graphics/text.h>
  49. #endif
  50.  
  51. #ifndef CPP_EXCEPTIONS_EXCEPTIONS_H
  52. #include <classes/exceptions/exceptions.h>
  53. #endif
  54.  
  55. class VisualInfoC {
  56. public:
  57.     VisualInfoC() throw (MemoryX);
  58.     VisualInfoC(ScreenC &) throw (VisualInfoX, MemoryX);
  59.     VisualInfoC(WindowC &) throw (VisualInfoX, MemoryX);
  60.     VisualInfoC(const VisualInfoC &);
  61.     ~VisualInfoC();
  62.     VisualInfoC &operator= (const VisualInfoC &);
  63.     BOOL isValid() const { return vi != NULL; };
  64.     APTR visualInfo() const { return vi; };
  65.     VOID getInfo(ScreenC &) throw (VisualInfoX);
  66.     VOID getInfo(WindowC &) throw (VisualInfoX);
  67.     VOID freeInfo();
  68. protected:
  69.     APTR vi;
  70. };
  71.  
  72. // **********************************************************
  73.  
  74. class MenuC;
  75.  
  76. class MenuEventC {
  77. friend class MenuC;
  78. friend class MenuPickHandlerC;
  79. friend class MenuHelpHandlerC;
  80. public:
  81.     virtual BOOL pick(WindowC *, MenuC *, IntuiMessageC *) { return FALSE; };
  82.     virtual VOID help(WindowC *, MenuC *, IntuiMessageC *) { };
  83. };
  84.  
  85. class MenuItemC : public NodeC {
  86. friend class MenuTitleC;
  87. public:
  88.     MenuItemC(STRPTR name, const MenuEventC * = NULL,
  89.         STRPTR shortKey = NULL, BOOL disabled = FALSE,
  90.         BOOL checkmark = FALSE, BOOL checked = FALSE);
  91.     virtual VOID rebuild(gen_arraylist &);
  92. private:
  93.     struct NewMenu newmenu;
  94. };
  95.  
  96. class MenuSeperatorC : public MenuItemC {
  97. public:
  98.     MenuSeperatorC();
  99. };
  100.  
  101. class MenuSubtitleC : public MenuItemC, protected ListC {
  102. public:
  103.     MenuSubtitleC(STRPTR name, const MenuEventC * = NULL,
  104.         BOOL disabled = FALSE);
  105.     VOID add(MenuItemC &);
  106.     VOID rebuild(gen_arraylist &);
  107. };
  108.  
  109. class MenuTitleC : public NodeC, protected ListC {
  110. friend class MenuC;
  111. public:
  112.     MenuTitleC(STRPTR name, const MenuEventC * = NULL,
  113.         BOOL disabled = FALSE);
  114.     VOID add(MenuItemC &);
  115.     virtual VOID rebuild(gen_arraylist &);
  116. private:
  117.     struct NewMenu newmenu;
  118. };
  119.  
  120. class MenuC : protected ListC {
  121. friend class WindowC;
  122. public:
  123.     MenuC(VisualInfoC &);
  124.     ~MenuC();
  125.     struct Menu *menu() const { return strip };
  126.     VOID add(MenuTitleC &);
  127.     BOOL layout(Tag tag1type, ...);
  128.     BOOL layout(struct TagItem *tags = NULL);
  129.     BOOL isLayouted() const { return layouted; };
  130. private:
  131.     struct Menu *strip;
  132.     BOOL layouted;
  133.     VisualInfoC *visualinfo;
  134.     gen_arraylist newmenu;
  135. };
  136.  
  137. class MenuEventHandlerC : public IDCMPEventHandlerC {
  138. public:
  139.     MenuEventHandlerC(MenuC &, ULONG IDCMPclass);
  140.     ~MenuEventHandlerC();
  141. protected:
  142.     MenuC *menu;
  143. };
  144.  
  145. class MenuPickHandlerC : public MenuEventHandlerC {
  146. public:
  147.     MenuPickHandlerC(MenuC &);
  148.     ~MenuPickHandlerC();
  149.     BOOL exit() { return _exit; };
  150. protected:
  151.     BOOL _handle(IntuiMessageC &);
  152.     BOOL _exit;
  153. };
  154.  
  155. class MenuHelpHandlerC : public MenuEventHandlerC {
  156. public:
  157.     MenuHelpHandlerC(MenuC &);
  158.     ~MenuHelpHandlerC();
  159. protected:
  160.     BOOL _handle(IntuiMessageC &);
  161. };
  162.  
  163. // ***********************************************************
  164.  
  165. class GTIDCMPortC : public IDCMPortC {
  166. public:
  167.     GTIDCMPortC() throw (PortX, MemoryX)
  168.         : IDCMPortC() { };
  169.     GTIDCMPortC(STRPTR name, BYTE pri = 0) throw (PortX, MemoryX)
  170.         : IDCMPortC(name,pri) { };
  171.     GTIDCMPortC(struct MsgPort *port) throw (PortX, MemoryX)
  172.         : IDCMPortC(port) { };
  173.     BOOL handle(ULONG);
  174. protected:
  175.     BOOL handleMsg(MessageC &);
  176. };
  177.  
  178. class GTWindowC : public WindowC {
  179. public:
  180.     GTWindowC(GTIDCMPortC &, Tag tag1Type, ...) throw (MemoryX);
  181.     GTWindowC(GTIDCMPortC &, struct TagItem *tags = NULL) throw (MemoryX);
  182.     ~GTWindowC();
  183.     VOID open(Tag tag1Type, ...) throw (WindowX, MemoryX)
  184.         { GTWindowC::open((struct TagItem *) &tag1Type); };
  185.     VOID open(struct TagItem *tagList = NULL) throw (WindowX, MemoryX);
  186.     VOID refreshGadgets();
  187.     VOID beginRefresh();
  188.     VOID endRefresh(BOOL Complete = TRUE);
  189.     VOID refreshFrame();
  190. protected:
  191.     VOID freeIDCMP();
  192. };
  193.  
  194. class GTWindowRefreshHandlerChainC : public WindowRefreshHandlerChainC {
  195. public:
  196.     GTWindowRefreshHandlerChainC(GTWindowC &w);
  197.     BOOL handle(MessageC &);
  198. protected:
  199.     GTWindowC *gtwindow;
  200. };
  201.  
  202. // ************************************************************
  203.  
  204. class GTGadgetC : public GadgetC {
  205. friend class GTGadgetListC;
  206. public:
  207.     GTGadgetC(GadgetEventC *, ULONG kind,
  208.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  209.         STRPTR label, ULONG flags, ULONG defaultplace,
  210.         const TextAttrC *, UWORD id, struct TagItem *taglist);
  211.     GTGadgetC(GadgetEventC *, ULONG kind,
  212.         WORD LeftEdge, WORD TopEdge, WORD Width, WORD Height,
  213.         STRPTR label, ULONG flags, ULONG defaultplace,
  214.         const TextAttrC *, UWORD id, Tag tag1type, ...);
  215.     ~GTGadgetC();
  216.     struct Gadget *rebuild(struct Gadget *prev);
  217.     VOID erase(WindowC *);
  218.     VOID setLeft(WORD left);
  219.     VOID setTop(WORD top);
  220.     VOID setWidth(WORD width);
  221.     VOID setHeight(WORD height);
  222.     WORD left() const { return ngadget.ng_LeftEdge; };
  223.     WORD top() const { return ngadget.ng_TopEdge; };
  224.     WORD width() const { return ngadget.ng_Width; };
  225.     WORD height() const { return ngadget.ng_Height; };
  226.     WORD leftBorder() const { return leftB; };
  227.     WORD rightBorder() const { return rightB; };
  228.     WORD topBorder() const { return topB; };
  229.     WORD bottomBorder() const { return bottomB; };
  230.     BOOL disable(BOOL value);
  231.     BOOL isDisabled();
  232.     VOID setTextAttr(const TextAttrC *);
  233.     VOID setDefTextAttr(const TextAttrC *);
  234.     TextAttrC *textAttr() const { return (TextAttrC *) ngadget.ng_TextAttr; };
  235.     VOID setAttrs(struct TagItem *taglist);
  236.     VOID setAttrs(Tag tag1type, ...);
  237.     LONG getAttrs(struct TagItem *taglist);
  238.     LONG getAttrs(Tag tag1type, ...);
  239.     STRPTR label() const { return ngadget.ng_GadgetText; };
  240.     ULONG flags() const { return ngadget.ng_Flags; };
  241.     ULONG labelPlace();
  242. protected:
  243.     TagItemC *taglist() { return &tags; };
  244.     struct NewGadget *newgadget() { return &ngadget; };
  245.     virtual VOID calcBorders();
  246.     VisualInfoC *vinfo() const { return vi; };
  247.     WORD leftB;
  248.     WORD rightB;
  249.     WORD topB;
  250.     WORD bottomB;
  251.     WORD labelWidth;
  252.     GTWindowC *window;
  253. private:
  254.     ULONG gadgetkind;
  255.     VisualInfoC *vi;
  256.     struct NewGadget ngadget;
  257.     TagItemC tags;
  258.     BOOL privtattr;
  259. };
  260.  
  261. class GTGadgetListC : public GadgetListC {
  262. public:
  263.     GTGadgetListC(const TextAttrC &,    VisualInfoC &, GTWindowC &);
  264.     ~GTGadgetListC();
  265.     VOID add(GTGadgetC &);
  266.     struct Gadget *rebuild(struct Gadget *prev);
  267.     VOID setTextAttr(const TextAttrC *);
  268. private:
  269.     TextAttrC *textattr;
  270.     VisualInfoC *vi;
  271.     struct Gadget *lastGadget;
  272.     GTWindowC *window;
  273. };
  274.  
  275. class GTAnchorGadgetListC : public GTGadgetListC {
  276. public:
  277.     GTAnchorGadgetListC(const TextAttrC &, VisualInfoC &, GTWindowC &);
  278.     ~GTAnchorGadgetListC();
  279.     BOOL deepfollow() { return FALSE; };
  280. };
  281.  
  282. class GTRootGadgetListC {
  283. public:
  284.     GTRootGadgetListC(GTWindowC &, const TextAttrC &, VisualInfoC &);
  285.     ~GTRootGadgetListC();
  286.     VOID add(GTGadgetC &);
  287.     VOID rebuild(BOOL refresh = TRUE);
  288.     VOID erase();
  289.     VOID refresh();
  290.     VOID setTextAttr(const TextAttrC *);
  291. private:
  292.     GTGadgetListC glist;
  293.     GTWindowC *window;
  294. };
  295.  
  296. // *************************************************************
  297.  
  298. class GTButtonC : public GTGadgetC, public GButtonC {
  299. public:
  300.     GTButtonC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  301.         WORD Width, WORD Height,
  302.         STRPTR label, ULONG flags = 0, const TextAttrC * = NULL,
  303.         UWORD id = 0, struct TagItem *taglist = NULL);
  304.     GTButtonC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  305.         WORD Width, WORD Height,
  306.         STRPTR label, ULONG flags, const TextAttrC *, UWORD id,
  307.         Tag tag1Type, ...);
  308.     struct Gadget *rebuild(struct Gadget *prev) { return GTGadgetC::rebuild(prev); };
  309.     VOID erase(WindowC *w) { GTGadgetC::erase(w); };
  310.     VOID setLeft(WORD leftEdge) { GTGadgetC::setLeft(leftEdge); };
  311.     VOID setTop(WORD topEdge) { GTGadgetC::setTop(topEdge); };
  312.     VOID setWidth(WORD width) { GTGadgetC::setWidth(width); };
  313.     VOID setHeight(WORD height) { GTGadgetC::setHeight(height); };
  314.     WORD left() const { return GTGadgetC::left(); };
  315.     WORD top() const { return GTGadgetC::top(); };
  316.     WORD width() const { return GTGadgetC::width(); };
  317.     WORD height() const { return GTGadgetC::height(); };
  318.     WORD leftBorder() const { return GTGadgetC::leftBorder(); };
  319.     WORD rightBorder() const { return GTGadgetC::rightBorder(); };
  320.     WORD topBorder() const { return GTGadgetC::topBorder(); };
  321.     WORD bottomBorder() const { return GTGadgetC::bottomBorder(); };
  322.     BOOL disable(BOOL value) { return GTGadgetC::disable(value); };
  323.     BOOL isDisabled() { return GTGadgetC::isDisabled(); };
  324.     VOID setTextAttr(const TextAttrC *t) { GTGadgetC::setTextAttr(t); };
  325.     VOID setDefTextAttr(const TextAttrC *t) { GTGadgetC::setDefTextAttr(t); };
  326.     TextAttrC *textAttr() const { return GTGadgetC::textAttr(); };
  327.     ULONG idcmp() const { return BUTTONIDCMP; };
  328. };
  329.  
  330. class GTStringC : public GTGadgetC, public GStringC {
  331. public:
  332.     GTStringC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  333.         WORD Width, WORD Height,
  334.         STRPTR label, ULONG flags = 0, const TextAttrC * = NULL,
  335.         UWORD id = 0, struct TagItem *taglist = NULL);
  336.     GTStringC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  337.         WORD Width, WORD Height,
  338.         STRPTR label, ULONG flags, const TextAttrC *, UWORD id,
  339.         Tag tag1Type, ...);
  340.     VOID free();
  341.     struct Gadget *rebuild(struct Gadget *prev) { return GTGadgetC::rebuild(prev); };
  342.     VOID erase(WindowC *w) { GTGadgetC::erase(w); };
  343.     VOID setLeft(WORD leftEdge) { GTGadgetC::setLeft(leftEdge); };
  344.     VOID setTop(WORD topEdge) { GTGadgetC::setTop(topEdge); };
  345.     VOID setWidth(WORD width) { GTGadgetC::setWidth(width); };
  346.     VOID setHeight(WORD height) { GTGadgetC::setHeight(height); };
  347.     WORD left() const { return GTGadgetC::left(); };
  348.     WORD top() const { return GTGadgetC::top(); };
  349.     WORD width() const { return GTGadgetC::width(); };
  350.     WORD height() const { return GTGadgetC::height(); };
  351.     WORD leftBorder() const { return GTGadgetC::leftBorder(); };
  352.     WORD rightBorder() const { return GTGadgetC::rightBorder(); };
  353.     WORD topBorder() const { return GTGadgetC::topBorder(); };
  354.     WORD bottomBorder() const { return GTGadgetC::bottomBorder(); };
  355.     BOOL disable(BOOL value) { return GTGadgetC::disable(value); };
  356.     BOOL isDisabled() { return GTGadgetC::isDisabled(); };
  357.     BOOL activate(BOOL value) { return FALSE; };
  358.     VOID setTextAttr(const TextAttrC *t) { GTGadgetC::setTextAttr(t); };
  359.     VOID setDefTextAttr(const TextAttrC *t) { GTGadgetC::setDefTextAttr(t); };
  360.     TextAttrC *textAttr() const { return GTGadgetC::textAttr(); };
  361.     ULONG idcmp() const { return STRINGIDCMP; };
  362.     VOID set(STRPTR);
  363.     STRPTR get();
  364. private:
  365.     String str;
  366. };
  367.  
  368. class GTIntegerC : public GTGadgetC, public GIntegerC {
  369. public:
  370.     GTIntegerC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  371.         WORD Width, WORD Height,
  372.         STRPTR label, ULONG flags = 0, const TextAttrC * = NULL,
  373.         UWORD id = 0, struct TagItem *taglist = NULL);
  374.     GTIntegerC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  375.         WORD Width, WORD Height,
  376.         STRPTR label, ULONG flags, const TextAttrC *, UWORD id,
  377.         Tag tag1Type, ...);
  378.     VOID free();
  379.     struct Gadget *rebuild(struct Gadget *prev) { return GTGadgetC::rebuild(prev); };
  380.     VOID erase(WindowC *w) { GTGadgetC::erase(w); };
  381.     VOID setLeft(WORD leftEdge) { GTGadgetC::setLeft(leftEdge); };
  382.     VOID setTop(WORD topEdge) { GTGadgetC::setTop(topEdge); };
  383.     VOID setWidth(WORD width) { GTGadgetC::setWidth(width); };
  384.     VOID setHeight(WORD height) { GTGadgetC::setHeight(height); };
  385.     WORD left() const { return GTGadgetC::left(); };
  386.     WORD top() const { return GTGadgetC::top(); };
  387.     WORD width() const { return GTGadgetC::width(); };
  388.     WORD height() const { return GTGadgetC::height(); };
  389.     WORD leftBorder() const { return GTGadgetC::leftBorder(); };
  390.     WORD rightBorder() const { return GTGadgetC::rightBorder(); };
  391.     WORD topBorder() const { return GTGadgetC::topBorder(); };
  392.     WORD bottomBorder() const { return GTGadgetC::bottomBorder(); };
  393.     BOOL disable(BOOL value) { return GTGadgetC::disable(value); };
  394.     BOOL isDisabled() { return GTGadgetC::isDisabled(); };
  395.     BOOL activate(BOOL value) { return FALSE; };
  396.     VOID setTextAttr(const TextAttrC *t) { GTGadgetC::setTextAttr(t); };
  397.     VOID setDefTextAttr(const TextAttrC *t) { GTGadgetC::setDefTextAttr(t); };
  398.     TextAttrC *textAttr() const { return GTGadgetC::textAttr(); };
  399.     ULONG idcmp() const { return STRINGIDCMP; };
  400.     VOID set(LONG);
  401.     LONG get();
  402. };
  403.  
  404. class GTCheckboxC : public GTGadgetC, public GCheckboxC {
  405. public:
  406.     GTCheckboxC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  407.         WORD Width, WORD Height,
  408.         STRPTR label, ULONG flags = 0, const TextAttrC * = NULL,
  409.         UWORD id = 0, struct TagItem *taglist = NULL);
  410.     GTCheckboxC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  411.         WORD Width, WORD Height,
  412.         STRPTR label, ULONG flags, const TextAttrC *, UWORD id,
  413.         Tag tag1Type, ...);
  414.     VOID free();
  415.     struct Gadget *rebuild(struct Gadget *prev) { return GTGadgetC::rebuild(prev); };
  416.     VOID erase(WindowC *w) { GTGadgetC::erase(w); };
  417.     VOID setLeft(WORD leftEdge) { GTGadgetC::setLeft(leftEdge); };
  418.     VOID setTop(WORD topEdge) { GTGadgetC::setTop(topEdge); };
  419.     VOID setWidth(WORD width) { GTGadgetC::setWidth(width); };
  420.     VOID setHeight(WORD height) { GTGadgetC::setHeight(height); };
  421.     WORD left() const { return GTGadgetC::left(); };
  422.     WORD top() const { return GTGadgetC::top(); };
  423.     WORD width() const { return GTGadgetC::width(); };
  424.     WORD height() const { return GTGadgetC::height(); };
  425.     WORD leftBorder() const { return GTGadgetC::leftBorder(); };
  426.     WORD rightBorder() const { return GTGadgetC::rightBorder(); };
  427.     WORD topBorder() const { return GTGadgetC::topBorder(); };
  428.     WORD bottomBorder() const { return GTGadgetC::bottomBorder(); };
  429.     BOOL disable(BOOL value) { return GTGadgetC::disable(value); };
  430.     BOOL isDisabled() { return GTGadgetC::isDisabled(); };
  431.     VOID setTextAttr(const TextAttrC *t) { GTGadgetC::setTextAttr(t); };
  432.     VOID setDefTextAttr(const TextAttrC *t) { GTGadgetC::setDefTextAttr(t); };
  433.     TextAttrC *textAttr() const { return GTGadgetC::textAttr(); };
  434.     ULONG idcmp() const { return CHECKBOXIDCMP; };
  435.     VOID check(BOOL);
  436.     BOOL checked();
  437. };
  438.  
  439. class GTRadioEventC : public GadgetEventC {
  440. public:
  441.     VOID up(WindowC *, GadgetC *, IntuiMessageC *);
  442. };
  443.  
  444. // Achtung: Das Tag GTMX_Labels MUSS mit einem Parameter NULL angegeben
  445. // werden (CreateGadgetA benutzt offensichtlich nicht die utility.library)
  446.  
  447. class GTRadioC : public GTGadgetC, public GRadioC {
  448. public:
  449.     GTRadioC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  450.         WORD Width, WORD Height, stringarray &buttonLabels,
  451.         STRPTR label = NULL, ULONG flags = 0, ULONG place = 0,
  452.         const TextAttrC * = NULL, UWORD id = 0, struct TagItem *taglist = NULL);
  453.     GTRadioC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  454.         WORD Width, WORD Height, stringarray &buttonLabels,
  455.         STRPTR label, ULONG flags, ULONG place, const TextAttrC *, UWORD id,
  456.         Tag tag1Type, ...);
  457.     VOID free();
  458.     struct Gadget *rebuild(struct Gadget *prev);
  459.     VOID erase(WindowC *w) { GTGadgetC::erase(w); };
  460.     VOID setLeft(WORD leftEdge) { GTGadgetC::setLeft(leftEdge); };
  461.     VOID setTop(WORD topEdge) { GTGadgetC::setTop(topEdge); };
  462.     VOID setWidth(WORD width) { GTGadgetC::setWidth(width); };
  463.     VOID setHeight(WORD height) { GTGadgetC::setHeight(height); };
  464.     WORD left() const { return GTGadgetC::left(); };
  465.     WORD top() const { return GTGadgetC::top(); };
  466.     WORD width() const { return GTGadgetC::width(); };
  467.     WORD height() const { return GTGadgetC::height(); };
  468.     WORD leftBorder() const { return GTGadgetC::leftBorder(); };
  469.     WORD rightBorder() const { return GTGadgetC::rightBorder(); };
  470.     WORD topBorder() const { return GTGadgetC::topBorder(); };
  471.     WORD bottomBorder() const { return GTGadgetC::bottomBorder(); };
  472.     BOOL disable(BOOL value) { return GTGadgetC::disable(value); };
  473.     BOOL isDisabled() { return GTGadgetC::isDisabled(); };
  474.     VOID setTextAttr(const TextAttrC *t) { GTGadgetC::setTextAttr(t); };
  475.     VOID setDefTextAttr(const TextAttrC *t) { GTGadgetC::setDefTextAttr(t); };
  476.     TextAttrC *textAttr() const { return GTGadgetC::textAttr(); };
  477.     ULONG idcmp() const { return MXIDCMP; };
  478.     VOID select(ULONG);
  479.     ULONG selected();
  480. protected:
  481.     VOID calcBorders();
  482. private:
  483.     ULONG labelsplace;
  484.     stringarray labels;
  485. };
  486.  
  487. class GTCycleEventC : public GadgetEventC {
  488. public:
  489.     VOID up(WindowC *, GadgetC *, IntuiMessageC *);
  490. };
  491.  
  492. // Achtung: Das Tag GTCY_Labels MUSS mit einem Parameter NULL angegeben
  493. // werden (CreateGadgetA benutzt offensichtlich nicht die utility.library)
  494.  
  495. class GTCycleC : public GTGadgetC, public GCycleC {
  496. public:
  497.     GTCycleC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  498.         WORD Width, WORD Height, stringarray &cyclelabels,
  499.         STRPTR label, ULONG flags = 0, const TextAttrC * = NULL,
  500.         UWORD id = 0, struct TagItem *taglist = NULL);
  501.     GTCycleC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  502.         WORD Width, WORD Height, stringarray &cyclelabels,
  503.         STRPTR label, ULONG flags, const TextAttrC *, UWORD id,
  504.         Tag tag1Type, ...);
  505.     VOID free();
  506.     struct Gadget *rebuild(struct Gadget *prev);
  507.     VOID erase(WindowC *w) { GTGadgetC::erase(w); };
  508.     VOID setLeft(WORD leftEdge) { GTGadgetC::setLeft(leftEdge); };
  509.     VOID setTop(WORD topEdge) { GTGadgetC::setTop(topEdge); };
  510.     VOID setWidth(WORD width) { GTGadgetC::setWidth(width); };
  511.     VOID setHeight(WORD height) { GTGadgetC::setHeight(height); };
  512.     WORD left() const { return GTGadgetC::left(); };
  513.     WORD top() const { return GTGadgetC::top(); };
  514.     WORD width() const { return GTGadgetC::width(); };
  515.     WORD height() const { return GTGadgetC::height(); };
  516.     WORD leftBorder() const { return GTGadgetC::leftBorder(); };
  517.     WORD rightBorder() const { return GTGadgetC::rightBorder(); };
  518.     WORD topBorder() const { return GTGadgetC::topBorder(); };
  519.     WORD bottomBorder() const { return GTGadgetC::bottomBorder(); };
  520.     BOOL disable(BOOL value) { return GTGadgetC::disable(value); };
  521.     BOOL isDisabled() { return GTGadgetC::isDisabled(); };
  522.     VOID setTextAttr(const TextAttrC *t) { GTGadgetC::setTextAttr(t); };
  523.     VOID setDefTextAttr(const TextAttrC *t) { GTGadgetC::setDefTextAttr(t); };
  524.     TextAttrC *textAttr() const { return GTGadgetC::textAttr(); };
  525.     ULONG idcmp() const { return CYCLEIDCMP; };
  526.     VOID select(ULONG);
  527.     ULONG selected();
  528.     VOID setLabels(STRPTR *);
  529.     VOID setLabels(STRPTR label1, ...);
  530.     STRPTR *getLabels();
  531.     ULONG labelsCount();
  532.     UWORD addLabel(STRPTR label);
  533.     VOID remLabel(UWORD count);
  534. private:
  535.     stringarray labels;
  536. };
  537.  
  538. class GTSliderEventC : public GadgetEventC {
  539. public:
  540.     VOID up(WindowC *, GadgetC *, IntuiMessageC *);
  541. };
  542.  
  543. class GTSliderC : public GTGadgetC, public GSliderC {
  544. public:
  545.     GTSliderC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  546.         WORD Width, WORD Height,
  547.         STRPTR label = NULL, ULONG flags = 0, const TextAttrC * = NULL,
  548.         UWORD id = 0, struct TagItem *taglist = NULL);
  549.     GTSliderC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  550.         WORD Width, WORD Height,
  551.         STRPTR label, ULONG flags, const TextAttrC *, UWORD id,
  552.         Tag tag1Type, ...);
  553.     VOID free();
  554.     struct Gadget *rebuild(struct Gadget *prev) { return GTGadgetC::rebuild(prev); };
  555.     VOID erase(WindowC *w) { GTGadgetC::erase(w); };
  556.     VOID setLeft(WORD leftEdge) { GTGadgetC::setLeft(leftEdge); };
  557.     VOID setTop(WORD topEdge) { GTGadgetC::setTop(topEdge); };
  558.     VOID setWidth(WORD width) { GTGadgetC::setWidth(width); };
  559.     VOID setHeight(WORD height) { GTGadgetC::setHeight(height); };
  560.     WORD left() const { return GTGadgetC::left(); };
  561.     WORD top() const { return GTGadgetC::top(); };
  562.     WORD width() const { return GTGadgetC::width(); };
  563.     WORD height() const { return GTGadgetC::height(); };
  564.     WORD leftBorder() const { return GTGadgetC::leftBorder(); };
  565.     WORD rightBorder() const { return GTGadgetC::rightBorder(); };
  566.     WORD topBorder() const { return GTGadgetC::topBorder(); };
  567.     WORD bottomBorder() const { return GTGadgetC::bottomBorder(); };
  568.     BOOL disable(BOOL value) { return GTGadgetC::disable(value); };
  569.     BOOL isDisabled() { return GTGadgetC::isDisabled(); };
  570.     VOID setTextAttr(const TextAttrC *t) { GTGadgetC::setTextAttr(t); };
  571.     VOID setDefTextAttr(const TextAttrC *t) { GTGadgetC::setDefTextAttr(t); };
  572.     TextAttrC *textAttr() const { return GTGadgetC::textAttr(); };
  573.     ULONG idcmp() const { return SLIDERIDCMP; };
  574.     VOID calcBorders();
  575.     VOID setMin(UWORD);
  576.     VOID setMax(UWORD);
  577.     VOID setLevel(UWORD);
  578.     UWORD min();
  579.     UWORD max();
  580.     UWORD level();
  581. };
  582.  
  583. class GTScrollerEventC : public GadgetEventC {
  584. public:
  585.     VOID up(WindowC *, GadgetC *, IntuiMessageC *);
  586. };
  587.  
  588. class GTScrollerC : public GTGadgetC, public GScrollerC {
  589. public:
  590.     GTScrollerC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  591.         WORD Width, WORD Height,
  592.         STRPTR label = NULL, ULONG flags = 0, const TextAttrC * = NULL,
  593.         UWORD id = 0, struct TagItem *taglist = NULL);
  594.     GTScrollerC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  595.         WORD Width, WORD Height,
  596.         STRPTR label, ULONG flags, const TextAttrC *, UWORD id,
  597.         Tag tag1Type, ...);
  598.     VOID free();
  599.     struct Gadget *rebuild(struct Gadget *prev) { return GTGadgetC::rebuild(prev); };
  600.     VOID erase(WindowC *w) { GTGadgetC::erase(w); };
  601.     VOID setLeft(WORD leftEdge) { GTGadgetC::setLeft(leftEdge); };
  602.     VOID setTop(WORD topEdge) { GTGadgetC::setTop(topEdge); };
  603.     VOID setWidth(WORD width) { GTGadgetC::setWidth(width); };
  604.     VOID setHeight(WORD height) { GTGadgetC::setHeight(height); };
  605.     WORD left() const { return GTGadgetC::left(); };
  606.     WORD top() const { return GTGadgetC::top(); };
  607.     WORD width() const { return GTGadgetC::width(); };
  608.     WORD height() const { return GTGadgetC::height(); };
  609.     WORD leftBorder() const { return GTGadgetC::leftBorder(); };
  610.     WORD rightBorder() const { return GTGadgetC::rightBorder(); };
  611.     WORD topBorder() const { return GTGadgetC::topBorder(); };
  612.     WORD bottomBorder() const { return GTGadgetC::bottomBorder(); };
  613.     BOOL disable(BOOL value) { return GTGadgetC::disable(value); };
  614.     BOOL isDisabled() { return GTGadgetC::isDisabled(); };
  615.     VOID setTextAttr(const TextAttrC *t) { GTGadgetC::setTextAttr(t); };
  616.     VOID setDefTextAttr(const TextAttrC *t) { GTGadgetC::setDefTextAttr(t); };
  617.     TextAttrC *textAttr() const { return GTGadgetC::textAttr(); };
  618.     ULONG idcmp() const { return SCROLLERIDCMP; };
  619.     VOID setPot(UWORD);
  620.     VOID setTotal(UWORD);
  621.     VOID setVisible(UWORD);
  622.     UWORD pot();
  623.     UWORD total();
  624.     UWORD visible();
  625. };
  626.  
  627. class GTListviewEventC : public GadgetEventC {
  628. public:
  629.     VOID up(WindowC *, GadgetC *, IntuiMessageC *);
  630. };
  631.  
  632. class GTListviewC : public GTGadgetC, public GListviewC {
  633. public:
  634.     GTListviewC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  635.         WORD Width, WORD Height,
  636.         STRPTR label, ULONG flags = 0, const TextAttrC * = NULL,
  637.         UWORD id = 0, struct TagItem *taglist = NULL);
  638.     GTListviewC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  639.         WORD Width, WORD Height,
  640.         STRPTR label, ULONG flags, const TextAttrC *, UWORD id,
  641.         Tag tag1Type, ...);
  642.     VOID free();
  643.     struct Gadget *rebuild(struct Gadget *prev) { return GTGadgetC::rebuild(prev); };
  644.     VOID erase(WindowC *w) { GTGadgetC::erase(w); };
  645.     VOID setLeft(WORD leftEdge) { GTGadgetC::setLeft(leftEdge); };
  646.     VOID setTop(WORD topEdge) { GTGadgetC::setTop(topEdge); };
  647.     VOID setWidth(WORD width) { GTGadgetC::setWidth(width); };
  648.     VOID setHeight(WORD height) { GTGadgetC::setHeight(height); };
  649.     WORD left() const { return GTGadgetC::left(); };
  650.     WORD top() const { return GTGadgetC::top(); };
  651.     WORD width() const { return GTGadgetC::width(); };
  652.     WORD height() const { return GTGadgetC::height(); };
  653.     WORD leftBorder() const { return GTGadgetC::leftBorder(); };
  654.     WORD rightBorder() const { return GTGadgetC::rightBorder(); };
  655.     WORD topBorder() const { return GTGadgetC::topBorder(); };
  656.     WORD bottomBorder() const { return GTGadgetC::bottomBorder(); };
  657.     BOOL disable(BOOL value) { return GTGadgetC::disable(value); };
  658.     BOOL isDisabled() { return GTGadgetC::isDisabled(); };
  659.     VOID setTextAttr(const TextAttrC *t) { GTGadgetC::setTextAttr(t); };
  660.     VOID setDefTextAttr(const TextAttrC *t) { GTGadgetC::setDefTextAttr(t); };
  661.     TextAttrC *textAttr() const { return GTGadgetC::textAttr(); };
  662.     ULONG idcmp() const { return LISTVIEWIDCMP; };
  663.     VOID select(ULONG);
  664.     ULONG selected();
  665.     VOID clearSelection();
  666.     VOID setList(EListC *header = NULL);
  667.     EListC *getList();
  668.     VOID detachList();
  669.     VOID attachList();
  670. private:
  671.     EListC *list;
  672. };
  673.  
  674. class GTPaletteEventC : public GadgetEventC {
  675. public:
  676.     VOID up(WindowC *, GadgetC *, IntuiMessageC *);
  677. };
  678.  
  679. class GTPaletteC : public GTGadgetC, public GPaletteC {
  680. public:
  681.     GTPaletteC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  682.         WORD Width, WORD Height,
  683.         STRPTR label = NULL, ULONG flags = 0, const TextAttrC * = NULL,
  684.         UWORD id = 0, struct TagItem *taglist = NULL);
  685.     GTPaletteC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  686.         WORD Width, WORD Height,
  687.         STRPTR label, ULONG flags, const TextAttrC *, UWORD id,
  688.         Tag tag1Type, ...);
  689.     VOID free();
  690.     struct Gadget *rebuild(struct Gadget *prev) { return GTGadgetC::rebuild(prev); };
  691.     VOID erase(WindowC *w) { GTGadgetC::erase(w); };
  692.     VOID setLeft(WORD leftEdge) { GTGadgetC::setLeft(leftEdge); };
  693.     VOID setTop(WORD topEdge) { GTGadgetC::setTop(topEdge); };
  694.     VOID setWidth(WORD width) { GTGadgetC::setWidth(width); };
  695.     VOID setHeight(WORD height) { GTGadgetC::setHeight(height); };
  696.     WORD left() const { return GTGadgetC::left(); };
  697.     WORD top() const { return GTGadgetC::top(); };
  698.     WORD width() const { return GTGadgetC::width(); };
  699.     WORD height() const { return GTGadgetC::height(); };
  700.     WORD leftBorder() const { return GTGadgetC::leftBorder(); };
  701.     WORD rightBorder() const { return GTGadgetC::rightBorder(); };
  702.     WORD topBorder() const { return GTGadgetC::topBorder(); };
  703.     WORD bottomBorder() const { return GTGadgetC::bottomBorder(); };
  704.     BOOL disable(BOOL value) { return GTGadgetC::disable(value); };
  705.     BOOL isDisabled() { return GTGadgetC::isDisabled(); };
  706.     VOID setTextAttr(const TextAttrC *t) { GTGadgetC::setTextAttr(t); };
  707.     VOID setDefTextAttr(const TextAttrC *t) { GTGadgetC::setDefTextAttr(t); };
  708.     TextAttrC *textAttr() const { return GTGadgetC::textAttr(); };
  709.     ULONG idcmp() const { return PALETTEIDCMP; };
  710.     VOID select(ULONG);
  711.     ULONG selected();
  712. };
  713.  
  714. class GTTextC : public GTGadgetC, public GTextC {
  715. public:
  716.     GTTextC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  717.         WORD Width, WORD Height,
  718.         STRPTR label, ULONG flags = 0, const TextAttrC * = NULL,
  719.         UWORD id = 0, struct TagItem *taglist = NULL);
  720.     GTTextC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  721.         WORD Width, WORD Height,
  722.         STRPTR label, ULONG flags, const TextAttrC *, UWORD id,
  723.         Tag tag1Type, ...);
  724.     struct Gadget *rebuild(struct Gadget *prev) { return GTGadgetC::rebuild(prev); };
  725.     VOID erase(WindowC *w) { GTGadgetC::erase(w); };
  726.     VOID setLeft(WORD leftEdge) { GTGadgetC::setLeft(leftEdge); };
  727.     VOID setTop(WORD topEdge) { GTGadgetC::setTop(topEdge); };
  728.     VOID setWidth(WORD width) { GTGadgetC::setWidth(width); };
  729.     VOID setHeight(WORD height) { GTGadgetC::setHeight(height); };
  730.     WORD left() const { return GTGadgetC::left(); };
  731.     WORD top() const { return GTGadgetC::top(); };
  732.     WORD width() const { return GTGadgetC::width(); };
  733.     WORD height() const { return GTGadgetC::height(); };
  734.     WORD leftBorder() const { return GTGadgetC::leftBorder(); };
  735.     WORD rightBorder() const { return GTGadgetC::rightBorder(); };
  736.     WORD topBorder() const { return GTGadgetC::topBorder(); };
  737.     WORD bottomBorder() const { return GTGadgetC::bottomBorder(); };
  738.     BOOL disable(BOOL value) { return GTGadgetC::disable(value); };
  739.     BOOL isDisabled() { return GTGadgetC::isDisabled(); };
  740.     VOID setTextAttr(const TextAttrC *t) { GTGadgetC::setTextAttr(t); };
  741.     VOID setDefTextAttr(const TextAttrC *t) { GTGadgetC::setDefTextAttr(t); };
  742.     TextAttrC *textAttr() const { return GTGadgetC::textAttr(); };
  743.     ULONG idcmp() const { return TEXTIDCMP; };
  744.     VOID set(STRPTR);
  745.     STRPTR get();
  746. };
  747.  
  748. class GTNumberC : public GTGadgetC, public GNumberC {
  749. public:
  750.     GTNumberC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  751.         WORD Width, WORD Height,
  752.         STRPTR label, ULONG flags = 0, const TextAttrC * = NULL,
  753.         UWORD id = 0, struct TagItem *taglist = NULL);
  754.     GTNumberC(GadgetEventC *, WORD LeftEdge, WORD TopEdge,
  755.         WORD Width, WORD Height,
  756.         STRPTR label, ULONG flags, const TextAttrC *, UWORD id,
  757.         Tag tag1Type, ...);
  758.     struct Gadget *rebuild(struct Gadget *prev) { return GTGadgetC::rebuild(prev); };
  759.     VOID erase(WindowC *w) { GTGadgetC::erase(w); };
  760.     VOID setLeft(WORD leftEdge) { GTGadgetC::setLeft(leftEdge); };
  761.     VOID setTop(WORD topEdge) { GTGadgetC::setTop(topEdge); };
  762.     VOID setWidth(WORD width) { GTGadgetC::setWidth(width); };
  763.     VOID setHeight(WORD height) { GTGadgetC::setHeight(height); };
  764.     WORD left() const { return GTGadgetC::left(); };
  765.     WORD top() const { return GTGadgetC::top(); };
  766.     WORD width() const { return GTGadgetC::width(); };
  767.     WORD height() const { return GTGadgetC::height(); };
  768.     WORD leftBorder() const { return GTGadgetC::leftBorder(); };
  769.     WORD rightBorder() const { return GTGadgetC::rightBorder(); };
  770.     WORD topBorder() const { return GTGadgetC::topBorder(); };
  771.     WORD bottomBorder() const { return GTGadgetC::bottomBorder(); };
  772.     BOOL disable(BOOL value) { return GTGadgetC::disable(value); };
  773.     BOOL isDisabled() { return GTGadgetC::isDisabled(); };
  774.     VOID setTextAttr(const TextAttrC *t) { GTGadgetC::setTextAttr(t); };
  775.     VOID setDefTextAttr(const TextAttrC *t) { GTGadgetC::setDefTextAttr(t); };
  776.     TextAttrC *textAttr() const { return GTGadgetC::textAttr(); };
  777.     ULONG idcmp() const { return NUMBERIDCMP; };
  778.     VOID set(LONG);
  779.     LONG get();
  780. };
  781.  
  782. #endif
  783.