home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / C / OTL-MC7.DMS / in.adf / classes.lha / Classes / Layouter / GadTools.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-31  |  25.0 KB  |  578 lines
  1. #ifndef CPP_LAYOUTER_GADTOOLS_H
  2. #define CPP_LAYOUTER_GADTOOLS_H
  3.  
  4. // Layouter für GadTools Gadgets
  5. //
  6. // Autor: Jochen Becher
  7. //
  8. // Historie:
  9. // Version 1.0 am 8. März 94
  10.  
  11. #ifndef CPP_LIBRARIES_GADTOOLS_H
  12. #include <classes/libraries/gadtools.h>
  13. #endif
  14.  
  15. #ifndef CPP_LAYOUTER_LAYOUTER_H
  16. #include <classes/layouter/layouter.h>
  17. #endif
  18.  
  19. #ifndef CPP_LAYOUTER_GADGETS_H
  20. #include <classes/layouter/gadgets.h>
  21. #endif
  22.  
  23. class LGTButtonC : public GTButtonC, public LGButtonC {
  24. public:
  25.     LGTButtonC(GadgetEventC *,
  26.         STRPTR label,
  27.         WORD Width = LAYOUT_AUTOSIZE, WORD Height = LAYOUT_AUTOSIZE,
  28.         ULONG flags = 0, const TextAttrC * = NULL, UWORD id = 0,
  29.         struct TagItem *taglist = NULL);
  30.     LGTButtonC(GadgetEventC *,
  31.         STRPTR label, WORD Width, WORD Height,
  32.         ULONG flags, const TextAttrC *, UWORD id,
  33.         Tag tag1type, ...);
  34.     struct Gadget *rebuild(struct Gadget *prev) { return GTButtonC::rebuild(prev); };
  35.     VOID erase(WindowC *w) { GTButtonC::erase(w); };
  36.     VOID setLeft(WORD left) { GTButtonC::setLeft(left); };
  37.     VOID setTop(WORD top) { GTButtonC::setTop(top); };
  38.     VOID setWidth(WORD width) { GTButtonC::setWidth(width); };
  39.     VOID setHeight(WORD height) { GTButtonC::setHeight(height); };
  40.     WORD left() const { return GTButtonC::left(); };
  41.     WORD top() const { return GTButtonC::top(); };
  42.     WORD width() const { return GTButtonC::width(); };
  43.     WORD height() const { return GTButtonC::height(); };
  44.     WORD leftBorder() const { return GTButtonC::leftBorder(); };
  45.     WORD topBorder() const { return GTButtonC::topBorder(); };
  46.     WORD rightBorder() const { return GTButtonC::rightBorder(); };
  47.     WORD bottomBorder() const { return GTButtonC::bottomBorder(); };
  48.     BOOL disable(BOOL value) { return GTButtonC::disable(value); };
  49.     BOOL isDisabled() const { return GTButtonC::isDisabled(); };
  50.     BOOL activate(BOOL value) { return GTButtonC::activate(value); };
  51.     VOID setTextAttr(const TextAttrC *t) { GTButtonC::setTextAttr(t); };
  52.     VOID setDefTextAttr(const TextAttrC *t) { GTButtonC::setDefTextAttr(t); };
  53.     ULONG idcmp() { return GTButtonC::idcmp(); };
  54.     VOID setInnerBorderWidth(WORD w) { innerBorderWidth = w; };
  55.     VOID setInnerBorderHeight(WORD h) { innerBorderHeight = h; };
  56.     BOOL layoutWidth();
  57.     BOOL layoutHeight();
  58.     BOOL autoWidth() const { return aWidth; };
  59.     BOOL autoHeight() const { return aHeight; };
  60. private:
  61.     WORD innerBorderHeight;
  62.     WORD innerBorderWidth;
  63.     BOOL aWidth;
  64.     BOOL aHeight;
  65. };
  66.  
  67. class LGTStringC : public GTStringC, public LGStringC {
  68. public:
  69.     LGTStringC(GadgetEventC *,
  70.         WORD columns = LAYOUT_AUTOSIZE, STRPTR label = NULL,
  71.         WORD Width = LAYOUT_AUTOSIZE, WORD Height = LAYOUT_AUTOSIZE,
  72.         ULONG flags = 0, const TextAttrC * = NULL, UWORD id = 0,
  73.         struct TagItem *taglist = NULL);
  74.     LGTStringC(GadgetEventC *,
  75.         WORD columns, STRPTR label, WORD Width, WORD Height,
  76.         ULONG flags, const TextAttrC *, UWORD id,
  77.         Tag tag1type, ...);
  78.     struct Gadget *rebuild(struct Gadget *prev) { return GTStringC::rebuild(prev); };
  79.     VOID erase(WindowC *w) { GTStringC::erase(w); };
  80.     VOID setLeft(WORD left) { GTStringC::setLeft(left); };
  81.     VOID setTop(WORD top) { GTStringC::setTop(top); };
  82.     VOID setWidth(WORD width) { GTStringC::setWidth(width); };
  83.     VOID setHeight(WORD height) { GTStringC::setHeight(height); };
  84.     WORD left() const { return GTStringC::left(); };
  85.     WORD top() const { return GTStringC::top(); };
  86.     WORD width() const { return GTStringC::width(); };
  87.     WORD height() const { return GTStringC::height(); };
  88.     WORD leftBorder() const { return GTStringC::leftBorder(); };
  89.     WORD topBorder() const { return GTStringC::topBorder(); };
  90.     WORD rightBorder() const { return GTStringC::rightBorder(); };
  91.     WORD bottomBorder() const { return GTStringC::bottomBorder(); };
  92.     BOOL disable(BOOL value) { return GTStringC::disable(value); };
  93.     BOOL isDisabled() const { return GTStringC::isDisabled(); };
  94.     BOOL activate(BOOL value) { return GTStringC::activate(value); };
  95.     VOID setTextAttr(const TextAttrC *t) { GTStringC::setTextAttr(t); };
  96.     VOID setDefTextAttr(const TextAttrC *t) { GTStringC::setDefTextAttr(t); };
  97.     ULONG idcmp() { return GTStringC::idcmp(); };
  98.     VOID set(STRPTR s) { GTStringC::set(s); };
  99.     STRPTR get() { return GTStringC::get(); };
  100.     VOID setInnerBorderWidth(WORD w) { innerBorderWidth = w; };
  101.     VOID setInnerBorderHeight(WORD h) { innerBorderHeight = h; };
  102.     BOOL layoutWidth();
  103.     BOOL layoutHeight();
  104.     BOOL autoWidth() const { return aWidth; };
  105.     BOOL autoHeight() const { return aHeight; };
  106. private:
  107.     WORD innerBorderHeight;
  108.     WORD innerBorderWidth;
  109.     WORD stringColumns;
  110.     BOOL aWidth;
  111.     BOOL aHeight;
  112. };
  113.  
  114. class LGTIntegerC : public GTIntegerC, public LGIntegerC {
  115. public:
  116.     LGTIntegerC(GadgetEventC *,
  117.         WORD columns = LAYOUT_AUTOSIZE, STRPTR label = NULL,
  118.         WORD Width = LAYOUT_AUTOSIZE, WORD Height = LAYOUT_AUTOSIZE,
  119.         ULONG flags = 0, const TextAttrC * = NULL, UWORD id = 0,
  120.         struct TagItem *taglist = NULL);
  121.     LGTIntegerC(GadgetEventC *,
  122.         WORD columns, STRPTR label, WORD Width, WORD Height,
  123.         ULONG flags, const TextAttrC *, UWORD id,
  124.         Tag tag1type, ...);
  125.     struct Gadget *rebuild(struct Gadget *prev) { return GTIntegerC::rebuild(prev); };
  126.     VOID erase(WindowC *w) { GTIntegerC::erase(w); };
  127.     VOID setLeft(WORD left) { GTIntegerC::setLeft(left); };
  128.     VOID setTop(WORD top) { GTIntegerC::setTop(top); };
  129.     VOID setWidth(WORD width) { GTIntegerC::setWidth(width); };
  130.     VOID setHeight(WORD height) { GTIntegerC::setHeight(height); };
  131.     WORD left() const { return GTIntegerC::left(); };
  132.     WORD top() const { return GTIntegerC::top(); };
  133.     WORD width() const { return GTIntegerC::width(); };
  134.     WORD height() const { return GTIntegerC::height(); };
  135.     WORD leftBorder() const { return GTIntegerC::leftBorder(); };
  136.     WORD topBorder() const { return GTIntegerC::topBorder(); };
  137.     WORD rightBorder() const { return GTIntegerC::rightBorder(); };
  138.     WORD bottomBorder() const { return GTIntegerC::bottomBorder(); };
  139.     BOOL disable(BOOL value) { return GTIntegerC::disable(value); };
  140.     BOOL isDisabled() const { return GTIntegerC::isDisabled(); };
  141.     BOOL activate(BOOL value) { return GTIntegerC::activate(value); };
  142.     VOID setTextAttr(const TextAttrC *t) { GTIntegerC::setTextAttr(t); };
  143.     VOID setDefTextAttr(const TextAttrC *t) { GTIntegerC::setDefTextAttr(t); };
  144.     ULONG idcmp() { return GTIntegerC::idcmp(); };
  145.     VOID set(LONG l) { GTIntegerC::set(l); };
  146.     LONG get() { return GTIntegerC::get(); };
  147.     VOID setInnerBorderWidth(WORD w) { innerBorderWidth = w; };
  148.     VOID setInnerBorderHeight(WORD h) { innerBorderHeight = h; };
  149.     BOOL layoutWidth();
  150.     BOOL layoutHeight();
  151.     BOOL autoWidth() const { return aWidth; };
  152.     BOOL autoHeight() const { return aHeight; };
  153. private:
  154.     WORD innerBorderHeight;
  155.     WORD innerBorderWidth;
  156.     WORD stringColumns;
  157.     BOOL aWidth;
  158.     BOOL aHeight;
  159. };
  160.  
  161. class LGTCheckboxC : public GTCheckboxC, public LGCheckboxC {
  162. public:
  163.     LGTCheckboxC(GadgetEventC *,
  164.         STRPTR label = NULL,
  165.         WORD Width = LAYOUT_AUTOSIZE, WORD Height = LAYOUT_AUTOSIZE,
  166.         ULONG flags = 0, const TextAttrC * = NULL, UWORD id = 0,
  167.         struct TagItem *taglist = NULL);
  168.     LGTCheckboxC(GadgetEventC *,
  169.         STRPTR label, WORD Width, WORD Height,
  170.         ULONG flags, const TextAttrC *, UWORD id,
  171.         Tag tag1type, ...);
  172.     struct Gadget *rebuild(struct Gadget *prev) { return GTCheckboxC::rebuild(prev); };
  173.     VOID erase(WindowC *w) { GTCheckboxC::erase(w); };
  174.     VOID setLeft(WORD left) { GTCheckboxC::setLeft(left); };
  175.     VOID setTop(WORD top) { GTCheckboxC::setTop(top); };
  176.     VOID setWidth(WORD width) { GTCheckboxC::setWidth(width); };
  177.     VOID setHeight(WORD height) { GTCheckboxC::setHeight(height); };
  178.     WORD left() const { return GTCheckboxC::left(); };
  179.     WORD top() const { return GTCheckboxC::top(); };
  180.     WORD width() const { return GTCheckboxC::width(); };
  181.     WORD height() const { return GTCheckboxC::height(); };
  182.     WORD leftBorder() const { return GTCheckboxC::leftBorder(); };
  183.     WORD topBorder() const { return GTCheckboxC::topBorder(); };
  184.     WORD rightBorder() const { return GTCheckboxC::rightBorder(); };
  185.     WORD bottomBorder() const { return GTCheckboxC::bottomBorder(); };
  186.     BOOL disable(BOOL value) { return GTCheckboxC::disable(value); };
  187.     BOOL isDisabled() const { return GTCheckboxC::isDisabled(); };
  188.     BOOL activate(BOOL value) { return GTCheckboxC::activate(value); };
  189.     VOID setTextAttr(const TextAttrC *t) { GTCheckboxC::setTextAttr(t); };
  190.     VOID setDefTextAttr(const TextAttrC *t) { GTCheckboxC::setDefTextAttr(t); };
  191.     ULONG idcmp() { return GTCheckboxC::idcmp(); };
  192.     VOID check(BOOL b) { GTCheckboxC::check(b); };
  193.     BOOL checked() { return GTCheckboxC::checked(); };
  194.     BOOL layoutWidth();
  195.     BOOL layoutHeight();
  196.     BOOL autoWidth() const { return aWidth; };
  197.     BOOL autoHeight() const { return aHeight; };
  198. private:
  199.     BOOL aWidth;
  200.     BOOL aHeight;
  201. };
  202.  
  203. class LGTRadioC : public GTRadioC, public LGRadioC {
  204. public:
  205.     LGTRadioC(GadgetEventC *,
  206.         stringarray &buttonlabels,
  207.         ULONG place = 0, STRPTR label = NULL,
  208.         WORD Width = LAYOUT_AUTOSIZE, WORD Height = LAYOUT_AUTOSIZE,
  209.         ULONG flags = 0, const TextAttrC * = NULL,
  210.         UWORD id = 0, struct TagItem *taglist = NULL);
  211.     LGTRadioC(GadgetEventC *,
  212.         stringarray &buttonlabels,
  213.         ULONG place, STRPTR label, WORD Width, WORD Height,
  214.         ULONG flags, const TextAttrC *, UWORD id,
  215.         Tag tag1type, ...);
  216.     struct Gadget *rebuild(struct Gadget *prev) { return GTRadioC::rebuild(prev); };
  217.     VOID erase(WindowC *w) { GTRadioC::erase(w); };
  218.     VOID setLeft(WORD left) { GTRadioC::setLeft(left); };
  219.     VOID setTop(WORD top) { GTRadioC::setTop(top); };
  220.     VOID setWidth(WORD width) { GTRadioC::setWidth(width); };
  221.     VOID setHeight(WORD height) { GTRadioC::setHeight(height); };
  222.     WORD left() const { return GTRadioC::left(); };
  223.     WORD top() const { return GTRadioC::top(); };
  224.     WORD width() const { return GTRadioC::width(); };
  225.     WORD height() const { return GTRadioC::height(); };
  226.     WORD leftBorder() const { return GTRadioC::leftBorder(); };
  227.     WORD topBorder() const { return GTRadioC::topBorder(); };
  228.     WORD rightBorder() const { return GTRadioC::rightBorder(); };
  229.     WORD bottomBorder() const { return GTRadioC::bottomBorder(); };
  230.     BOOL disable(BOOL value) { return GTRadioC::disable(value); };
  231.     BOOL isDisabled() const { return GTRadioC::isDisabled(); };
  232.     BOOL activate(BOOL value) { return GTRadioC::activate(value); };
  233.     VOID setTextAttr(const TextAttrC *t) { GTRadioC::setTextAttr(t); };
  234.     VOID setDefTextAttr(const TextAttrC *t) { GTRadioC::setDefTextAttr(t); };
  235.     ULONG idcmp() { return GTRadioC::idcmp(); };
  236.     VOID select(ULONG s) { GTRadioC::select(s); };
  237.     ULONG selected() { return GTRadioC::selected(); };
  238.     BOOL layoutWidth();
  239.     BOOL layoutHeight();
  240.     BOOL autoWidth() const { return aWidth; };
  241.     BOOL autoHeight() const { return aHeight; };
  242. private:
  243.     BOOL aWidth;
  244.     BOOL aHeight;
  245. };
  246.  
  247. class LGTCycleC : public GTCycleC, public LGCycleC {
  248. public:
  249.     LGTCycleC(GadgetEventC *,
  250.         stringarray &cyclelabels,
  251.         STRPTR label = NULL,
  252.         WORD Width = LAYOUT_AUTOSIZE, WORD Height = LAYOUT_AUTOSIZE,
  253.         ULONG flags = 0, const TextAttrC * = NULL, UWORD id = 0,
  254.         struct TagItem *taglist = NULL);
  255.     LGTCycleC(GadgetEventC *,
  256.         stringarray &cyclelabels,
  257.         STRPTR label, WORD Width, WORD Height,
  258.         ULONG flags, const TextAttrC *, UWORD id,
  259.         Tag tag1type, ...);
  260.     struct Gadget *rebuild(struct Gadget *prev) { return GTCycleC::rebuild(prev); };
  261.     VOID erase(WindowC *w) { GTCycleC::erase(w); };
  262.     VOID setLeft(WORD left) { GTCycleC::setLeft(left); };
  263.     VOID setTop(WORD top) { GTCycleC::setTop(top); };
  264.     VOID setWidth(WORD width) { GTCycleC::setWidth(width); };
  265.     VOID setHeight(WORD height) { GTCycleC::setHeight(height); };
  266.     WORD left() const { return GTCycleC::left(); };
  267.     WORD top() const { return GTCycleC::top(); };
  268.     WORD width() const { return GTCycleC::width(); };
  269.     WORD height() const { return GTCycleC::height(); };
  270.     WORD leftBorder() const { return GTCycleC::leftBorder(); };
  271.     WORD topBorder() const { return GTCycleC::topBorder(); };
  272.     WORD rightBorder() const { return GTCycleC::rightBorder(); };
  273.     WORD bottomBorder() const { return GTCycleC::bottomBorder(); };
  274.     BOOL disable(BOOL value) { return GTCycleC::disable(value); };
  275.     BOOL isDisabled() const { return GTCycleC::isDisabled(); };
  276.     BOOL activate(BOOL value) { return GTCycleC::activate(value); };
  277.     VOID setTextAttr(const TextAttrC *t) { GTCycleC::setTextAttr(t); };
  278.     VOID setDefTextAttr(const TextAttrC *t) { GTCycleC::setDefTextAttr(t); };
  279.     ULONG idcmp() { return GTCycleC::idcmp(); };
  280.     VOID select(ULONG s) { GTCycleC::select(s); };
  281.     ULONG selected() { return GTCycleC::selected(); };
  282.     VOID setLabels(STRPTR *labels) { GTCycleC::setLabels(labels); };
  283.     VOID setLabels(STRPTR label1, ...) { GTCycleC::setLabels(&label1); };
  284.     STRPTR *getLabels() { return GTCycleC::getLabels(); };
  285.     ULONG labelsCount() { return GTCycleC::labelsCount(); };
  286.     UWORD addLabel(STRPTR label) { return GTCycleC::addLabel(label); };
  287.     VOID remLabel(UWORD count) { GTCycleC::remLabel(count); };
  288.     VOID setInnerBorderWidth(WORD w) { innerBorderWidth = w; };
  289.     VOID setInnerBorderHeight(WORD h) { innerBorderHeight = h; };
  290.     BOOL layoutWidth();
  291.     BOOL layoutHeight();
  292.     BOOL autoWidth() const { return aWidth; };
  293.     BOOL autoHeight() const { return aHeight; };
  294. private:
  295.     WORD innerBorderHeight;
  296.     WORD innerBorderWidth;
  297.     BOOL aWidth;
  298.     BOOL aHeight;
  299. };
  300.  
  301. class LGTSliderC : public GTSliderC, public LGSliderC {
  302. public:
  303.     LGTSliderC(GadgetEventC *,
  304.         STRPTR label = NULL,
  305.         WORD Width = LAYOUT_AUTOSIZE, WORD Height = LAYOUT_AUTOSIZE,
  306.         ULONG flags = 0, const TextAttrC * = NULL, UWORD id = 0,
  307.         struct TagItem *taglist = NULL);
  308.     LGTSliderC(GadgetEventC *,
  309.         STRPTR label, WORD Width, WORD Height,
  310.         ULONG flags, const TextAttrC *, UWORD id,
  311.         Tag tag1type, ...);
  312.     struct Gadget *rebuild(struct Gadget *prev) { return GTSliderC::rebuild(prev); };
  313.     VOID erase(WindowC *w) { GTSliderC::erase(w); };
  314.     VOID setLeft(WORD left) { GTSliderC::setLeft(left); };
  315.     VOID setTop(WORD top) { GTSliderC::setTop(top); };
  316.     VOID setWidth(WORD width) { GTSliderC::setWidth(width); };
  317.     VOID setHeight(WORD height) { GTSliderC::setHeight(height); };
  318.     WORD left() const { return GTSliderC::left(); };
  319.     WORD top() const { return GTSliderC::top(); };
  320.     WORD width() const { return GTSliderC::width(); };
  321.     WORD height() const { return GTSliderC::height(); };
  322.     WORD leftBorder() const { return GTSliderC::leftBorder(); };
  323.     WORD topBorder() const { return GTSliderC::topBorder(); };
  324.     WORD rightBorder() const { return GTSliderC::rightBorder(); };
  325.     WORD bottomBorder() const { return GTSliderC::bottomBorder(); };
  326.     BOOL disable(BOOL value) { return GTSliderC::disable(value); };
  327.     BOOL isDisabled() const { return GTSliderC::isDisabled(); };
  328.     BOOL activate(BOOL value) { return GTSliderC::activate(value); };
  329.     VOID setTextAttr(const TextAttrC *t) { GTSliderC::setTextAttr(t); };
  330.     VOID setDefTextAttr(const TextAttrC *t) { GTSliderC::setDefTextAttr(t); };
  331.     ULONG idcmp() { return GTSliderC::idcmp(); };
  332.     VOID setMin(UWORD m) { GTSliderC::setMin(m); };
  333.     VOID setMax(UWORD m) { GTSliderC::setMax(m); };
  334.     VOID setLevel(UWORD l) { GTSliderC::setLevel(l); };
  335.     UWORD min() { return GTSliderC::min(); };
  336.     UWORD max() { return GTSliderC::max(); };
  337.     UWORD level() { return GTSliderC::level(); };
  338.     BOOL layoutWidth();
  339.     BOOL layoutHeight();
  340.     BOOL autoWidth() const { return aWidth; };
  341.     BOOL autoHeight() const { return aHeight; };
  342. private:
  343.     BOOL aWidth;
  344.     BOOL aHeight;
  345. };
  346.  
  347. class LGTScrollerC : public GTScrollerC, public LGScrollerC {
  348. public:
  349.     LGTScrollerC(GadgetEventC *,
  350.         STRPTR label = NULL,
  351.         WORD Width = LAYOUT_AUTOSIZE, WORD Height = LAYOUT_AUTOSIZE,
  352.         ULONG flags = 0, const TextAttrC * = NULL, UWORD id = 0,
  353.         struct TagItem *taglist = NULL);
  354.     LGTScrollerC(GadgetEventC *,
  355.         STRPTR label, WORD Width, WORD Height,
  356.         ULONG flags, const TextAttrC *, UWORD id,
  357.         Tag tag1type, ...);
  358.     struct Gadget *rebuild(struct Gadget *prev) { return GTScrollerC::rebuild(prev); };
  359.     VOID erase(WindowC *w) { GTScrollerC::erase(w); };
  360.     VOID setLeft(WORD left) { GTScrollerC::setLeft(left); };
  361.     VOID setTop(WORD top) { GTScrollerC::setTop(top); };
  362.     VOID setWidth(WORD width) { GTScrollerC::setWidth(width); };
  363.     VOID setHeight(WORD height) { GTScrollerC::setHeight(height); };
  364.     WORD left() const { return GTScrollerC::left(); };
  365.     WORD top() const { return GTScrollerC::top(); };
  366.     WORD width() const { return GTScrollerC::width(); };
  367.     WORD height() const { return GTScrollerC::height(); };
  368.     WORD leftBorder() const { return GTScrollerC::leftBorder(); };
  369.     WORD topBorder() const { return GTScrollerC::topBorder(); };
  370.     WORD rightBorder() const { return GTScrollerC::rightBorder(); };
  371.     WORD bottomBorder() const { return GTScrollerC::bottomBorder(); };
  372.     BOOL disable(BOOL value) { return GTScrollerC::disable(value); };
  373.     BOOL isDisabled() const { return GTScrollerC::isDisabled(); };
  374.     BOOL activate(BOOL value) { return GTScrollerC::activate(value); };
  375.     VOID setTextAttr(const TextAttrC *t) { GTScrollerC::setTextAttr(t); };
  376.     VOID setDefTextAttr(const TextAttrC *t) { GTScrollerC::setDefTextAttr(t); };
  377.     ULONG idcmp() { return GTScrollerC::idcmp(); };
  378.     VOID setPot(UWORD p) { GTScrollerC::setPot(p); };
  379.     VOID setTotal(UWORD t) { GTScrollerC::setTotal(t); };
  380.     VOID setVisible(UWORD v) { GTScrollerC::setVisible(v); };
  381.     UWORD pot() { return GTScrollerC::pot(); };
  382.     UWORD total() { return GTScrollerC::total(); };
  383.     UWORD visible() { return GTScrollerC::visible(); };
  384.     BOOL layoutWidth();
  385.     BOOL layoutHeight();
  386.     BOOL autoWidth() const { return aWidth; };
  387.     BOOL autoHeight() const { return aHeight; };
  388. private:
  389.     BOOL aWidth;
  390.     BOOL aHeight;
  391. };
  392.  
  393. class LGTListviewC : public GTListviewC, public LGListviewC {
  394. public:
  395.     LGTListviewC(GadgetEventC *,
  396.         WORD entries = LAYOUT_AUTOSIZE, STRPTR label = NULL,
  397.         WORD Width = LAYOUT_AUTOSIZE, WORD Height = LAYOUT_AUTOSIZE,
  398.         ULONG flags = 0, const TextAttrC * = NULL, UWORD id = 0,
  399.         struct TagItem *taglist = NULL);
  400.     LGTListviewC(GadgetEventC *,
  401.         WORD entries, STRPTR label, WORD Width, WORD Height,
  402.         ULONG flags, const TextAttrC *, UWORD id,
  403.         Tag tag1type, ...);
  404.     struct Gadget *rebuild(struct Gadget *prev) { return GTListviewC::rebuild(prev); };
  405.     VOID erase(WindowC *w) { GTListviewC::erase(w); };
  406.     VOID setLeft(WORD left) { GTListviewC::setLeft(left); };
  407.     VOID setTop(WORD top) { GTListviewC::setTop(top); };
  408.     VOID setWidth(WORD width) { GTListviewC::setWidth(width); };
  409.     VOID setHeight(WORD height) { GTListviewC::setHeight(height); };
  410.     WORD left() const { return GTListviewC::left(); };
  411.     WORD top() const { return GTListviewC::top(); };
  412.     WORD width() const { return GTListviewC::width(); };
  413.     WORD height() const { return GTListviewC::height(); };
  414.     WORD leftBorder() const { return GTListviewC::leftBorder(); };
  415.     WORD topBorder() const { return GTListviewC::topBorder(); };
  416.     WORD rightBorder() const { return GTListviewC::rightBorder(); };
  417.     WORD bottomBorder() const { return GTListviewC::bottomBorder(); };
  418.     BOOL disable(BOOL value) { return GTListviewC::disable(value); };
  419.     BOOL isDisabled() const { return GTListviewC::isDisabled(); };
  420.     BOOL activate(BOOL value) { return GTListviewC::activate(value); };
  421.     VOID setTextAttr(const TextAttrC *t) { GTListviewC::setTextAttr(t); };
  422.     VOID setDefTextAttr(const TextAttrC *t) { GTListviewC::setDefTextAttr(t); };
  423.     ULONG idcmp() { return GTListviewC::idcmp(); };
  424.     VOID select(ULONG s) { GTListviewC::select(s); };
  425.     ULONG selected() { return GTListviewC::selected(); };
  426.     VOID clearSelection() { GTListviewC::clearSelection(); };
  427.     VOID setList(EListC *header) { GTListviewC::setList(header); };
  428.     EListC *getList() { return GTListviewC::getList(); };
  429.     VOID detachList() { GTListviewC::detachList(); };
  430.     VOID attachList() { GTListviewC::attachList(); };
  431.     BOOL layoutWidth();
  432.     BOOL layoutHeight();
  433.     BOOL autoWidth() const { return aWidth; };
  434.     BOOL autoHeight() const { return aHeight; };
  435. private:
  436.     WORD listEntries;
  437.     BOOL aWidth;
  438.     BOOL aHeight;
  439. };
  440.  
  441. class LGTPaletteC : public GTPaletteC, public LGPaletteC {
  442. public:
  443.     LGTPaletteC(GadgetEventC *,
  444.         STRPTR label = NULL,
  445.         WORD Width = LAYOUT_AUTOSIZE, WORD Height = LAYOUT_AUTOSIZE,
  446.         ULONG flags = 0, const TextAttrC * = NULL, UWORD id = 0,
  447.         struct TagItem *taglist = NULL);
  448.     LGTPaletteC(GadgetEventC *,
  449.         STRPTR label, WORD Width, WORD Height,
  450.         ULONG flags, const TextAttrC *, UWORD id,
  451.         Tag tag1type, ...);
  452.     struct Gadget *rebuild(struct Gadget *prev) { return GTPaletteC::rebuild(prev); };
  453.     VOID erase(WindowC *w) { GTPaletteC::erase(w); };
  454.     VOID setLeft(WORD left) { GTPaletteC::setLeft(left); };
  455.     VOID setTop(WORD top) { GTPaletteC::setTop(top); };
  456.     VOID setWidth(WORD width) { GTPaletteC::setWidth(width); };
  457.     VOID setHeight(WORD height) { GTPaletteC::setHeight(height); };
  458.     WORD left() const { return GTPaletteC::left(); };
  459.     WORD top() const { return GTPaletteC::top(); };
  460.     WORD width() const { return GTPaletteC::width(); };
  461.     WORD height() const { return GTPaletteC::height(); };
  462.     WORD leftBorder() const { return GTPaletteC::leftBorder(); };
  463.     WORD topBorder() const { return GTPaletteC::topBorder(); };
  464.     WORD rightBorder() const { return GTPaletteC::rightBorder(); };
  465.     WORD bottomBorder() const { return GTPaletteC::bottomBorder(); };
  466.     BOOL disable(BOOL value) { return GTPaletteC::disable(value); };
  467.     BOOL isDisabled() const { return GTPaletteC::isDisabled(); };
  468.     BOOL activate(BOOL value) { return GTPaletteC::activate(value); };
  469.     VOID setTextAttr(const TextAttrC *t) { GTPaletteC::setTextAttr(t); };
  470.     VOID setDefTextAttr(const TextAttrC *t) { GTPaletteC::setDefTextAttr(t); };
  471.     ULONG idcmp() { return GTPaletteC::idcmp(); };
  472.     VOID select(ULONG l) { GTPaletteC::select(l); };
  473.     ULONG selected() { return GTPaletteC::selected(); };
  474.     BOOL layoutWidth();
  475.     BOOL layoutHeight();
  476.     BOOL autoWidth() const { return aWidth; };
  477.     BOOL autoHeight() const { return aHeight; };
  478. private:
  479.     BOOL aWidth;
  480.     BOOL aHeight;
  481. };
  482.  
  483. class LGTTextC : public GTTextC, public LGTextC {
  484. public:
  485.     LGTTextC(GadgetEventC * = NULL,
  486.         WORD columns = LAYOUT_AUTOSIZE, STRPTR label = NULL,
  487.         WORD Width = LAYOUT_AUTOSIZE, WORD Height = LAYOUT_AUTOSIZE,
  488.         ULONG flags = 0, const TextAttrC * = NULL, UWORD id = 0,
  489.         struct TagItem *taglist = NULL);
  490.     LGTTextC(GadgetEventC *,
  491.         WORD columns, STRPTR label, WORD Width, WORD Height,
  492.         ULONG flags, const TextAttrC *, UWORD id,
  493.         Tag tag1type, ...);
  494.     struct Gadget *rebuild(struct Gadget *prev) { return GTTextC::rebuild(prev); };
  495.     VOID erase(WindowC *w) { GTTextC::erase(w); };
  496.     VOID setLeft(WORD left) { GTTextC::setLeft(left); };
  497.     VOID setTop(WORD top) { GTTextC::setTop(top); };
  498.     VOID setWidth(WORD width) { GTTextC::setWidth(width); };
  499.     VOID setHeight(WORD height) { GTTextC::setHeight(height); };
  500.     WORD left() const { return GTTextC::left(); };
  501.     WORD top() const { return GTTextC::top(); };
  502.     WORD width() const { return GTTextC::width(); };
  503.     WORD height() const { return GTTextC::height(); };
  504.     WORD leftBorder() const { return GTTextC::leftBorder(); };
  505.     WORD topBorder() const { return GTTextC::topBorder(); };
  506.     WORD rightBorder() const { return GTTextC::rightBorder(); };
  507.     WORD bottomBorder() const { return GTTextC::bottomBorder(); };
  508.     BOOL disable(BOOL value) { return GTTextC::disable(value); };
  509.     BOOL isDisabled() const { return GTTextC::isDisabled(); };
  510.     BOOL activate(BOOL value) { return GTTextC::activate(value); };
  511.     VOID setTextAttr(const TextAttrC *t) { GTTextC::setTextAttr(t); };
  512.     VOID setDefTextAttr(const TextAttrC *t) { GTTextC::setDefTextAttr(t); };
  513.     ULONG idcmp() { return GTTextC::idcmp(); };
  514.     VOID set(STRPTR s) { GTTextC::set(s); };
  515.     STRPTR get() { return GTTextC::get(); };
  516.     VOID setInnerBorderWidth(WORD w) { innerBorderWidth = w; };
  517.     VOID setInnerBorderHeight(WORD h) { innerBorderHeight = h; };
  518.     BOOL layoutWidth();
  519.     BOOL layoutHeight();
  520.     BOOL autoWidth() const { return aWidth; };
  521.     BOOL autoHeight() const { return aHeight; };
  522. private:
  523.     WORD innerBorderHeight;
  524.     WORD innerBorderWidth;
  525.     WORD textColumns;
  526.     BOOL aWidth;
  527.     BOOL aHeight;
  528. };
  529.  
  530. class LGTNumberC : public GTNumberC, public LGNumberC {
  531. public:
  532.     LGTNumberC(GadgetEventC *,
  533.         WORD columns = LAYOUT_AUTOSIZE, STRPTR label = NULL,
  534.         WORD Width = LAYOUT_AUTOSIZE, WORD Height = LAYOUT_AUTOSIZE,
  535.         ULONG flags = 0, const TextAttrC * = NULL, UWORD id = 0,
  536.         struct TagItem *taglist = NULL);
  537.     LGTNumberC(GadgetEventC *,
  538.         WORD columns, STRPTR label, WORD Width, WORD Height,
  539.         ULONG flags, const TextAttrC *, UWORD id,
  540.         Tag tag1type, ...);
  541.     struct Gadget *rebuild(struct Gadget *prev) { return GTNumberC::rebuild(prev); };
  542.     VOID erase(WindowC *w) { GTNumberC::erase(w); };
  543.     VOID setLeft(WORD left) { GTNumberC::setLeft(left); };
  544.     VOID setTop(WORD top) { GTNumberC::setTop(top); };
  545.     VOID setWidth(WORD width) { GTNumberC::setWidth(width); };
  546.     VOID setHeight(WORD height) { GTNumberC::setHeight(height); };
  547.     WORD left() const { return GTNumberC::left(); };
  548.     WORD top() const { return GTNumberC::top(); };
  549.     WORD width() const { return GTNumberC::width(); };
  550.     WORD height() const { return GTNumberC::height(); };
  551.     WORD leftBorder() const { return GTNumberC::leftBorder(); };
  552.     WORD topBorder() const { return GTNumberC::topBorder(); };
  553.     WORD rightBorder() const { return GTNumberC::rightBorder(); };
  554.     WORD bottomBorder() const { return GTNumberC::bottomBorder(); };
  555.     BOOL disable(BOOL value) { return GTNumberC::disable(value); };
  556.     BOOL isDisabled() const { return GTNumberC::isDisabled(); };
  557.     BOOL activate(BOOL value) { return GTNumberC::activate(value); };
  558.     VOID setTextAttr(const TextAttrC *t) { GTNumberC::setTextAttr(t); };
  559.     VOID setDefTextAttr(const TextAttrC *t) { GTNumberC::setDefTextAttr(t); };
  560.     ULONG idcmp() { return GTNumberC::idcmp(); };
  561.     VOID set(LONG l) { GTNumberC::set(l); };
  562.     LONG get() { return GTNumberC::get(); };
  563.     VOID setInnerBorderWidth(WORD w) { innerBorderWidth = w; };
  564.     VOID setInnerBorderHeight(WORD h) { innerBorderHeight = h; };
  565.     BOOL layoutWidth();
  566.     BOOL layoutHeight();
  567.     BOOL autoWidth() const { return aWidth; };
  568.     BOOL autoHeight() const { return aHeight; };
  569. private:
  570.     WORD innerBorderHeight;
  571.     WORD innerBorderWidth;
  572.     WORD textColumns;
  573.     BOOL aWidth;
  574.     BOOL aHeight;
  575. };
  576.  
  577. #endif
  578.