#ifndef CPP_BOOPSI_GADGETS_H
#define CPP_BOOPSI_GADGETS_H

// Gadgets, insbesondere für den Layouter nützlich
//
// Autor: Jochen Becher
//
// Historie:
// Version 1.0 am 28. Februar 94

#ifndef CPP_BOOPSI_BOOPSICLASS_H
#include <classes/boopsi/boopsiclass.h>
#endif

#ifndef CPP_BOOPSI_GADGETCLASS_H
#include <classes/boopsi/gadgetclass.h>
#endif

#ifndef CPP_WORKBENCH_WORKBENCH_H
#include <classes/workbench/workbench.h>
#endif

#ifndef CPP_DATASTRUCTURES_STRINGARRAY_H
#include <classes/datastructures/stringarray.h>
#endif

#define IBT_AdjustLeft   0
#define IBT_AdjustRight  1

#define IBTA_ImageAdjust   (TAG_USER +  1) // I·G, ULONG
#define IBTA_Font          (TAG_USER +  2) // ISG, struct TextAttr *
#define IBTA_LabelMark     (TAG_USER +  3) // I·G, UBYTE
#define IBTA_AutoWidth     (TAG_USER +  4) // ··G, LONG
#define IBTA_AutoHeight    (TAG_USER +  5) // ··G, LONG
#define IBTA_LeftBorder    (TAG_USER +  6) // ··G, LONG
#define IBTA_RightBorder   (TAG_USER +  7) // ··G, LONG
#define IBTA_TopBorder     (TAG_USER +  8) // ··G, LONG
#define IBTA_BottomBorder  (TAG_USER +  9) // ··G, LONG

class IButtonClass : public BoopsiClass {
public:
	IButtonClass();
private:
	static ULONG dispatcher(Class *cl, Object *o, Msg msg);
	static ULONG render(Class *cl, struct Gadget *g,
		struct gpRender *msg, struct InstanceData *);
	static WORD labelWidth(Class *cl, struct Gadget *g,
		struct InstanceData *);
	static WORD labelHeight(Class *cl, struct Gadget *g,
		struct InstanceData *);
};

class BIButtonC : public BGadgetC, public GButtonC {
public:
	BIButtonC(GadgetEventC *ev,WindowC &w, Tag tag1type, ...)
		: BGadgetC(ev,ibc.boopsiclass(),NULL,w,(struct TagItem *) &tag1type),
		  GButtonC() { };
	BIButtonC(GadgetEventC *ev,WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,ibc.boopsiclass(),NULL,w,tags), GButtonC() { };
	WORD leftBorder() const { return (WORD) getAttr(IBTA_LeftBorder); };
	WORD rightBorder() const { return (WORD) getAttr(IBTA_RightBorder); };
	WORD topBorder() const { return (WORD) getAttr(IBTA_TopBorder); };
	WORD bottomBorder() const { return (WORD) getAttr(IBTA_BottomBorder); };
	BOOL disable(BOOL value) { return BGadgetC::disable(value) };
	BOOL isDisabled() const { return BGadgetC::isDisabled() };
	BOOL activate(BOOL v) { return FALSE; };
	VOID setTextAttr(const TextAttrC *f) { setAttrs(IBTA_Font,f,TAG_END); };
	TextAttrC *textAttr() const { return (struct TextAttrC *) getAttr(IBTA_Font); };
protected:
	BIButtonC(GadgetEventC *ev, struct IClass *c, STRPTR pubclass,
		WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,c,pubclass,w,tags), GButtonC() { };
private:
	static IButtonClass ibc;
};

// *************************************************************

#define STRA_Font           (TAG_USER + 1) // ISG, struct TextAttr *
#define STRA_LabelMark      (TAG_USER + 2) // I·G, UBYTE
#define STRA_LeftBorder     (TAG_USER + 3) // ··G, LONG
#define STRA_RightBorder    (TAG_USER + 4) // ··G, LONG
#define STRA_TopBorder      (TAG_USER + 5) // ··G, LONG
#define STRA_BottomBorder   (TAG_USER + 6) // ··G, LONG
#define STRA_AutoWidth      (TAG_USER + 7) // ··G, LONG
#define STRA_AutoHeight     (TAG_USER + 8) // ··G, LONG
#define STRA_Columns        (TAG_USER + 9) // ISG, ULONG

class StringClass : public BoopsiClass {
public:
	StringClass();
private:
	static ULONG dispatcher(Class *cl, Object *o, Msg msg);
	static ULONG render(Class *cl, struct Gadget *g,
		struct gpRender *msg, struct InstanceData *);
	static VOID calcBorders(Class *cl, struct Gadget *g,
		struct InstanceData *data);
	static WORD calcWidth(Class *cl, struct Gadget *g,
		struct InstanceData *data);
	static WORD calcHeight(Class *cl, struct Gadget *g,
		struct InstanceData *data);
};

class BStringC : public BGadgetC, GStringC {
public:
	BStringC(GadgetEventC *ev, WindowC &w, Tag tag1type, ...)
		: BGadgetC(ev,lc.boopsiclass(),NULL,w,(struct TagItem *) &tag1type) { };
	BStringC(GadgetEventC *ev, WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,lc.boopsiclass(),NULL,w,tags) { };
	WORD leftBorder() const { return (WORD) getAttr(STRA_LeftBorder); };
	WORD rightBorder() const { return (WORD) getAttr(STRA_RightBorder); };
	WORD topBorder() const { return (WORD) getAttr(STRA_TopBorder); };
	WORD bottomBorder() const { return (WORD) getAttr(STRA_BottomBorder); };
	BOOL disable(BOOL value) { return BGadgetC::disable(value) };
	BOOL isDisabled() const { return BGadgetC::isDisabled() };
	BOOL activate(BOOL v) { return FALSE; };
	VOID setTextAttr(const TextAttrC *f) { setAttrs(STRA_Font,f,TAG_END); };
	TextAttrC *textAttr() const { return (struct TextAttrC *) getAttr(STRA_Font); };
	VOID set(STRPTR s) { setAttrs(STRINGA_TextVal,s,TAG_END); };
	STRPTR get() { return (STRPTR) getAttr(STRINGA_TextVal); };
protected:
	BStringC(GadgetEventC *ev, struct IClass *c, STRPTR pubclass,
			WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,c,pubclass,w,tags) { };
private:
	static StringClass lc;
};

class BIntegerC : public BGadgetC, public GIntegerC {
public:
	BIntegerC(GadgetEventC *ev, WindowC &w, Tag tag1type, ...);
	BIntegerC(GadgetEventC *ev, WindowC &w, struct TagItem *tags);
	WORD leftBorder() const { return (WORD) getAttr(STRA_LeftBorder); };
	WORD rightBorder() const { return (WORD) getAttr(STRA_RightBorder); };
	WORD topBorder() const { return (WORD) getAttr(STRA_TopBorder); };
	WORD bottomBorder() const { return (WORD) getAttr(STRA_BottomBorder); };
	BOOL disable(BOOL value) { return BGadgetC::disable(value) };
	BOOL isDisabled() const { return BGadgetC::isDisabled() };
	BOOL activate(BOOL v) { return FALSE; };
	VOID setTextAttr(const TextAttrC *f) { setAttrs(STRA_Font,f,TAG_END); };
	TextAttrC *textAttr() const { return (struct TextAttrC *) getAttr(STRA_Font); };
	VOID set(LONG s) { setAttrs(STRINGA_LongVal,s,TAG_END); };
	LONG get() { return (LONG) getAttr(STRINGA_LongVal); };
protected:
	BIntegerC(GadgetEventC *ev, struct IClass *c, STRPTR pubclass,
			WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,c,pubclass,w,tags) { };
private:
	static StringClass lc;
};

// *************************************************************

#define CB_LabelLeft      0
#define CB_LabelRight     1

#define CBA_Font           (TAG_USER + 1) // ISG, struct TextAttr *
#define CBA_LabelPlace     (TAG_USER + 2) // I·G, ULONG
#define CBA_LeftBorder     (TAG_USER + 3) // ··G, LONG
#define CBA_RightBorder    (TAG_USER + 4) // ··G, LONG
#define CBA_TopBorder      (TAG_USER + 5) // ··G, LONG
#define CBA_BottomBorder   (TAG_USER + 6) // ··G, LONG
#define CBA_AutoWidth      (TAG_USER + 7) // ··G, LONG
#define CBA_AutoHeight     (TAG_USER + 8) // ··G, LONG
#define CBA_ReadOnly       (TAG_USER + 9) // ISG, BOOL
#define CBA_LabelMark      (TAG_USER +10) // I·G, UBYTE

class CheckboxClass : public BoopsiClass {
public:
	CheckboxClass();
private:
	static ULONG dispatcher(Class *cl, Object *o, Msg msg);
	static ULONG render(Class *cl, struct Gadget *g,
		struct gpRender *msg, struct InstanceData *);
	static VOID calcBorders(Class *cl, struct Gadget *g,
		struct InstanceData *data);
	static WORD calcWidth(Class *cl, struct Gadget *g,
		struct InstanceData *data);
	static WORD calcHeight(Class *cl, struct Gadget *g,
		struct InstanceData *data);
};

class BCheckboxC : public BGadgetC, public GCheckboxC {
public:
	BCheckboxC(GadgetEventC *ev, WindowC &w, Tag tag1type, ...)
		: BGadgetC(ev,cbc.boopsiclass(),NULL,w,(struct TagItem *) &tag1type) { };
	BCheckboxC(GadgetEventC *ev, WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,cbc.boopsiclass(),NULL,w,tags) { };
	WORD leftBorder() const { return (WORD) getAttr(CBA_LeftBorder); };
	WORD rightBorder() const { return (WORD) getAttr(CBA_RightBorder); };
	WORD topBorder() const { return (WORD) getAttr(CBA_TopBorder); };
	WORD bottomBorder() const { return (WORD) getAttr(CBA_BottomBorder); };
	BOOL disable(BOOL value) { return BGadgetC::disable(value) };
	BOOL isDisabled() const { return BGadgetC::isDisabled() };
	BOOL activate(BOOL v) { return FALSE; };
	VOID setTextAttr(const TextAttrC *f) { setAttrs(CBA_Font,f,TAG_END); };
	TextAttrC *textAttr() const { return (struct TextAttrC *) getAttr(CBA_Font); };
	VOID check(BOOL v) { setAttrs(GA_Selected, v, TAG_END); };
	BOOL checked()  { return (BOOL) getAttr(GA_Selected); };
protected:
	BCheckboxC(GadgetEventC *ev, struct IClass *c, STRPTR pubclass,
			WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,c,pubclass,w,tags) { };
private:
	static CheckboxClass cbc;
};

// *************************************************************

#define CY_LabelLeft     0
#define CY_LabelRight    1

#define CYA_Labels        (TAG_USER + 1) // ISG, STRPTR *
#define CYA_Active        (TAG_USER + 2) // ISG, ULONG
#define CYA_Font          (TAG_USER + 3) // ISG, struct TextAttr *
#define CYA_MinMenu       (TAG_USER + 4) // ISG, ULONG
#define CYA_LeftBorder    (TAG_USER + 5) // ··G, LONG
#define CYA_RightBorder   (TAG_USER + 6) // ··G, LONG
#define CYA_TopBorder     (TAG_USER + 7) // ··G, LONG
#define CYA_BottomBorder  (TAG_USER + 8) // ··G, LONG
#define CYA_AutoWidth     (TAG_USER + 9) // ··G, LONG
#define CYA_AutoHeight    (TAG_USER +10) // ··G, LONG
#define CYA_Columns       (TAG_USER +11) // ISG, ULONG
#define CYA_LabelPlace    (TAG_USER +12) // I·G, ULONG
#define CYA_LabelMark     (TAG_USER +13) // I·G, UBYTE
#define CYA_Next          (TAG_USER +14) // ·S·
#define CYA_Prev          (TAG_USER +15) // ·S·

class CycleClass : public BoopsiClass {
public:
	CycleClass();
private:
	static ULONG dispatcher(Class *cl, Object *o, Msg msg);
	static ULONG renderCycle(Class *cl, struct Gadget *,
		struct gpRender *msg, struct InstanceData *);
	static ULONG calcWidth(Class *cl, struct Gadget *,
		struct InstanceData *);
	static ULONG calcHeight(Class *cl, struct Gadget *,
		struct InstanceData *);
	static VOID calcBorders(Class *cl, struct Gadget *,
		struct InstanceData *);
};

class BCycleC : public BGadgetC, public GCycleC {
public:
	BCycleC(GadgetEventC *ev, WindowC &w, stringarray &, Tag tag1type, ...);
	BCycleC(GadgetEventC *ev,WindowC &w, stringarray &, struct TagItem *tags);
	WORD leftBorder() const { return (WORD) getAttr(CYA_LeftBorder); };
	WORD rightBorder() const { return (WORD) getAttr(CYA_RightBorder); };
	WORD topBorder() const { return (WORD) getAttr(CYA_TopBorder); };
	WORD bottomBorder() const { return (WORD) getAttr(CYA_BottomBorder); };
	BOOL disable(BOOL value) { return BGadgetC::disable(value) };
	BOOL isDisabled() const { return BGadgetC::isDisabled() };
	BOOL activate(BOOL v) { return FALSE; };
	VOID setTextAttr(const TextAttrC *f) { setAttrs(CYA_Font,f,TAG_END); };
	TextAttrC *textAttr() const { return (struct TextAttrC *) getAttr(CYA_Font); };
	VOID select(ULONG s) { setAttrs(CYA_Active,s,TAG_END); };
	ULONG selected() { return getAttr(CYA_Active); };
	VOID setLabels(STRPTR *);
	VOID setLabels(STRPTR label1, ...);
	STRPTR *getLabels();
	ULONG labelsCount();
	UWORD addLabel(STRPTR label);
	VOID remLabel(UWORD count);
protected:
	BCycleC(GadgetEventC *ev, struct IClass *c, STRPTR pubclass,
		WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,c,pubclass,w,tags), GCycleC() { };
private:
	static CycleClass pmc;
	stringarray labels;
};

// *************************************************************

#define RD_LabelsLeft   0
#define RD_LabelsRight  1

#define RDA_Font         (TAG_USER + 1) // ISG, struct TextAttr
#define RDA_LabelsPlace  (TAG_USER + 2) // I·G, ULONG
#define RDA_Labels       (TAG_USER + 3) // I·G, STRPTR *
#define RDA_LeftBorder   (TAG_USER + 4) // ··G, LONG
#define RDA_RightBorder  (TAG_USER + 5) // ··G, LONG
#define RDA_TopBorder    (TAG_USER + 6) // ··G, LONG
#define RDA_BottomBorder (TAG_USER + 7) // ··G, LONG
#define RDA_AutoWidth    (TAG_USER + 8) // ··G, LONG
#define RDA_AutoHeight   (TAG_USER + 9) // ··G, LONG
#define RDA_Active       (TAG_USER +10) // ISG, ULONG
#define RDA_Spacing      (TAG_USER +11) // I·G, ULONG
#define RDA_LabelMark    (TAG_USER +12) // I·G, UBYTE
#define RDA_Next         (TAG_USER +13) // ·S·
#define RDA_Prev         (TAG_USER +14) // ·S·

class RadioClass : public BoopsiClass {
public:
	RadioClass();
private:
	static ULONG dispatcher(Class *cl, Object *o, Msg msg);
	static ULONG render(Class *cl, struct Gadget *g,
		struct gpRender *msg, struct InstanceData *);
	static VOID calcBorders(Class *cl, struct Gadget *g,
		struct InstanceData *data);
	static ULONG countLabels(STRPTR *labels);
	static WORD calcWidth(Class *cl, struct Gadget *g,
		struct InstanceData *data);
	static WORD calcHeight(Class *cl, struct Gadget *g,
		struct InstanceData *data);
};

class BRadioC : public BGadgetC, public GRadioC {
public:
	BRadioC(GadgetEventC *ev, WindowC &w, Tag tag1type, ...)
		: BGadgetC(ev,rc.boopsiclass(),NULL,w,(struct TagItem *) &tag1type) { };
	BRadioC(GadgetEventC *ev, WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,rc.boopsiclass(),NULL,w,tags) { };
	WORD leftBorder() const { return (WORD) getAttr(RDA_LeftBorder); };
	WORD rightBorder() const { return (WORD) getAttr(RDA_RightBorder); };
	WORD topBorder() const { return (WORD) getAttr(RDA_TopBorder); };
	WORD bottomBorder() const { return (WORD) getAttr(RDA_BottomBorder); };
	BOOL disable(BOOL value) { return BGadgetC::disable(value) };
	BOOL isDisabled() const { return BGadgetC::isDisabled() };
	BOOL activate(BOOL v) { return FALSE; };
	VOID setTextAttr(const TextAttrC *f) { setAttrs(RDA_Font,f,TAG_END); };
	TextAttrC *textAttr() const { return (struct TextAttrC *) getAttr(RDA_Font); };
	VOID select(ULONG v) { setAttrs(RDA_Active, v, TAG_END); };
	ULONG selected() { return getAttr(RDA_Active); };
protected:
	BRadioC(GadgetEventC *ev, struct IClass *c, STRPTR pubclass,
			WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,c,pubclass,w,tags) { };
private:
	static RadioClass rc;
};

// *************************************************************

#define SLA_Font          (TAG_USER + 1) // ISG, struct TextAttr *
#define SLA_ValuePlace    (TAG_USER + 2) // I·G, ULONG
#define SLA_LabelPlace    (TAG_USER + 3) // I·G, ULONG
#define SLA_Min           (TAG_USER + 4) // ISG, LONG
#define SLA_Max           (TAG_USER + 5) // ISG, LONG
#define SLA_Level         (TAG_USER + 6) // ISG, LONG
#define SLA_LeftBorder    (TAG_USER + 7) // ··G, LONG
#define SLA_RightBorder   (TAG_USER + 8) // ··G, LONG
#define SLA_TopBorder     (TAG_USER + 9) // ··G, LONG
#define SLA_BottomBorder  (TAG_USER +10) // ··G, LONG
#define SLA_AutoWidth     (TAG_USER +11) // ··G, LONG
#define SLA_AutoHeight    (TAG_USER +12) // ··G, LONG
#define SLA_Freedom       (TAG_USER +13) // I·G, ULONG

class SliderClass : public BoopsiClass {
public:
	SliderClass();
private:
	static ULONG dispatcher(Class *cl, Object *o, Msg msg);
	static ULONG render(Class *cl, struct Gadget *g,
		struct gpRender *msg, struct InstanceData *);
	static VOID calcBorders(Class *cl, struct Gadget *g,
		struct InstanceData *data);
	static WORD calcWidth(Class *cl, struct Gadget *g,
		struct InstanceData *data);
	static WORD calcHeight(Class *cl, struct Gadget *g,
		struct InstanceData *data);
};

class BSliderC : public BGadgetC, GSliderC {
public:
	BSliderC(GadgetEventC *ev, WindowC &w, Tag tag1type, ...)
		: BGadgetC(ev,sc.boopsiclass(),NULL,w,(struct TagItem *) &tag1type) { };
	BSliderC(GadgetEventC *ev, WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,sc.boopsiclass(),NULL,w,tags) { };
	WORD leftBorder() const { return (WORD) getAttr(SLA_LeftBorder); };
	WORD rightBorder() const { return (WORD) getAttr(SLA_RightBorder); };
	WORD topBorder() const { return (WORD) getAttr(SLA_TopBorder); };
	WORD bottomBorder() const { return (WORD) getAttr(SLA_BottomBorder); };
	BOOL disable(BOOL value) { return BGadgetC::disable(value) };
	BOOL isDisabled() const { return BGadgetC::isDisabled() };
	BOOL activate(BOOL v) { return FALSE; };
	VOID setTextAttr(const TextAttrC *f) { setAttrs(SLA_Font,f,TAG_END); };
	TextAttrC *textAttr() const { return (struct TextAttrC *) getAttr(SLA_Font); };
	VOID setMin(UWORD m) { setAttrs(SLA_Min,m,TAG_END); };
	VOID setMax(UWORD m) { setAttrs(SLA_Max,m,TAG_END); };
	VOID setLevel(UWORD l) { setAttrs(SLA_Level,l,TAG_END); };
	UWORD min() { return (UWORD) getAttr(SLA_Min); };
	UWORD max() { return (UWORD) getAttr(SLA_Max); };
	UWORD level() { return (UWORD) getAttr(SLA_Level); };
protected:
	BSliderC(GadgetEventC *ev, struct IClass *c, STRPTR pubclass,
			WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,c,pubclass,w,tags) { };
private:
	static SliderClass sc;
};

// *************************************************************

#define ASCA_Arrows        (TAG_USER + 1) // I·G, BOOL
#define ASCA_LeftBorder    (TAG_USER + 2) // ··G, LONG
#define ASCA_RightBorder   (TAG_USER + 3) // ··G, LONG
#define ASCA_TopBorder     (TAG_USER + 4) // ··G, LONG
#define ASCA_BottomBorder  (TAG_USER + 5) // ··G, LONG
#define ASCA_AutoWidth     (TAG_USER + 6) // ··G, LONG
#define ASCA_AutoHeight    (TAG_USER + 7) // ··G, LONG
#define ASCA_Freedom       (TAG_USER + 8) // I·G, ULONG
#define ASCA_Top           (TAG_USER + 9) // ISG, UWORD
#define ASCA_Visible       (TAG_USER +10) // ISG, UWORD
#define ASCA_Total         (TAG_USER +11) // ISG, UWORD
#define ASCA_Borderless    (TAG_USER +12) // I·G, BOOL

class ArrowScrollerClass : public BoopsiClass {
public:
	ArrowScrollerClass();
private:
	static ULONG dispatcher(Class *cl, Object *o, Msg msg);
	static ULONG render(Class *cl, struct Gadget *g,
		struct gpRender *msg, struct InstanceData *, BOOL overGadget = FALSE);
	static VOID calcArrows(Class *cl, struct Gadget *g,
		struct InstanceData *data);
	static VOID scrollUpLeft(Class *cl, struct Gadget *g,
		struct InstanceData *data, struct GadgetInfo *);
	static VOID scrollDownRight(Class *cl, struct Gadget *g,
		struct InstanceData *data, struct GadgetInfo *);
	static WORD calcWidth(Class *cl, struct Gadget *g,
		struct InstanceData *data);
	static WORD calcHeight(Class *cl, struct Gadget *g,
		struct InstanceData *data);
};

class BArrowScrollerC : public BGadgetC, GScrollerC {
public:
	BArrowScrollerC(GadgetEventC *ev, WindowC &w, Tag tag1type, ...)
		: BGadgetC(ev,sc.boopsiclass(),NULL,w,(struct TagItem *) &tag1type) { };
	BArrowScrollerC(GadgetEventC *ev, WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,sc.boopsiclass(),NULL,w,tags) { };
	WORD leftBorder() const { return (WORD) getAttr(ASCA_LeftBorder); };
	WORD rightBorder() const { return (WORD) getAttr(ASCA_RightBorder); };
	WORD topBorder() const { return (WORD) getAttr(ASCA_TopBorder); };
	WORD bottomBorder() const { return (WORD) getAttr(ASCA_BottomBorder); };
	BOOL disable(BOOL value) { return BGadgetC::disable(value) };
	BOOL isDisabled() const { return BGadgetC::isDisabled() };
	BOOL activate(BOOL v) { return FALSE; };
	VOID setPot(UWORD p) { setAttrs(ASCA_Top,p,TAG_END); };
	VOID setTotal(UWORD t) { setAttrs(ASCA_Total,t,TAG_END); };
	VOID setVisible(UWORD v) { setAttrs(ASCA_Visible,v,TAG_END); };
	UWORD pot() { return (UWORD) getAttr(ASCA_Top); };
	UWORD total() { return (UWORD) getAttr(ASCA_Total); };
	UWORD visible() { return (UWORD) getAttr(ASCA_Visible); };
protected:
	BArrowScrollerC(GadgetEventC *ev, struct IClass *c, STRPTR pubclass,
			WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,c,pubclass,w,tags) { };
private:
	static ArrowScrollerClass sc;
};

// *************************************************************

#define LS_AdjustLeft       0
#define LS_AdjustRight      1

#define LSA_Font            (TAG_USER +  1) // ISG, struct TextAttr *
#define LSA_Spacing         (TAG_USER +  2) // ISG, UWORD
#define LSA_Attach          (TAG_USER +  3) // ISG, struct List *
#define LSA_Detach          (TAG_USER +  4) // ·S·, BOOL
#define LSA_Top             (TAG_USER +  5) // ISG, LONG
#define LSA_Active          (TAG_USER +  6) // ISG, LONG
#define LSA_ReadOnly        (TAG_USER +  7) // ISG, BOOL
#define LSA_Next            (TAG_USER +  8) // ·S·
#define LSA_Prev            (TAG_USER +  9) // ·S·
#define LSA_Visible         (TAG_USER + 10) // ···
#define LSA_Total           (TAG_USER + 11) // ···
#define LSA_Frame           (TAG_USER + 12) // I·G, Object *
#define LSA_ItemHeight      (TAG_USER + 13) // ISG, UWORD
#define LSA_LeftBorder      (TAG_USER + 14) // ··G, LONG
#define LSA_RightBorder     (TAG_USER + 15) // ··G, LONG
#define LSA_TopBorder       (TAG_USER + 16) // ··G, LONG
#define LSA_BottomBorder    (TAG_USER + 17) // ··G, LONG
#define LSA_AutoWidth       (TAG_USER + 18) // ··G, LONG
#define LSA_AutoHeight      (TAG_USER + 19) // ··G, LONG
#define LSA_Columns         (TAG_USER + 20) // ISG, ULONG
#define LSA_Lines           (TAG_USER + 21) // ISG, ULONG
#define LSA_LabelMark       (TAG_USER + 22) // I·G, UBYTE
#define LSA_HorizLeft       (TAG_USER + 23) // ISG, UWORD
#define LSA_HorizWidth      (TAG_USER + 24) // ···
#define LSA_HorizTotal      (TAG_USER + 25) // ···
#define LSA_HorizTarget     (TAG_USER + 26) // ISG, Object *
#define LSA_HorizMap        (TAG_USER + 27) // ISG, struct TagItem *
#define LSA_HorizAdjust     (TAG_USER + 28) // ISG, ULONG

class ListClass : public BoopsiClass {
public:
	ListClass();
private:
	static ULONG dispatcher(Class *cl, Object *o, Msg msg);
	static ULONG render(Class *cl, struct Gadget *g,
		struct gpRender *msg, struct InstanceData *, BOOL fullrender = TRUE);
	static ULONG countListLength(struct InstanceData *);
	static VOID NotifyTarget(Class *cl, Object *o,
		struct InstanceData *data, struct GadgetInfo *ginfo, ULONG flags);
	static VOID calcBorders(Class *cl, struct Gadget *g,
		struct InstanceData *data);
	static WORD calcWidth(Class *cl, struct Gadget *g,
		struct InstanceData *data);
	static WORD calcHeight(Class *cl, struct Gadget *g,
		struct InstanceData *data);
};

class BListC : public BGadgetC, public GListviewC {
public:
	BListC(GadgetEventC *ev,WindowC &w, Tag tag1type, ...)
		: BGadgetC(ev,lic.boopsiclass(),NULL,w,(struct TagItem *) &tag1type),
		  GListviewC() { };
	BListC(GadgetEventC *ev,WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,lic.boopsiclass(),NULL,w,tags), GListviewC() { };
	WORD leftBorder() const { return (WORD) getAttr(LSA_LeftBorder); };
	WORD rightBorder() const { return (WORD) getAttr(LSA_RightBorder); };
	WORD topBorder() const { return (WORD) getAttr(LSA_TopBorder); };
	WORD bottomBorder() const { return (WORD) getAttr(LSA_BottomBorder); };
	BOOL disable(BOOL value) { return BGadgetC::disable(value) };
	BOOL isDisabled() const { return BGadgetC::isDisabled() };
	BOOL activate(BOOL v) { return FALSE; };
	VOID setTextAttr(const TextAttrC *f) { setAttrs(LSA_Font,f,TAG_END); };
	TextAttrC *textAttr() const { return (struct TextAttrC *) getAttr(LSA_Font); };
	VOID select(ULONG l) { setAttrs(LSA_Active,l,TAG_END); };
	ULONG selected() { return getAttr(LSA_Active); };
	VOID clearSelection() { setAttrs(LSA_Active,~0,TAG_END); };
	VOID setList(EListC *header) { setAttrs(LSA_Attach,header,TAG_END); };
	EListC *getList() { return (EListC *) getAttr(LSA_Attach); };
	VOID detachList() { setAttrs(LSA_Detach,TRUE,TAG_END); };
	VOID attachList() { setAttrs(LSA_Attach,~0,TAG_END); };
protected:
	BListC(GadgetEventC *ev, struct IClass *c, STRPTR pubclass,
		WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,c,pubclass,w,tags), GListviewC() { };
private:
	static ListClass lic;
};

// *************************************************************

#define LVA_VertScroller    (TAG_USER + 50) // I·G, BOOL
#define LVA_HorizScroller   (TAG_USER + 51) // I·G, BOOL

class ListviewClass : public BoopsiClass {
public:
	ListviewClass();
	static Class *listclass() { return lic.boopsiclass(); };
	static Class *scrollerclass() { return asc.boopsiclass(); };
private:
	static ULONG dispatcher(Class *cl, Object *o, Msg msg);
	static ULONG render(Class *cl, struct Gadget *g,
		struct gpRender *msg, struct InstanceData *);
	static ListClass lic;
	static ArrowScrollerClass asc;
};

class BListviewC : public BListC {
public:
	BListviewC(GadgetEventC *ev, WindowC &w, Tag tag1type, ...)
		: BListC(ev,lc.boopsiclass(),NULL,w,(struct TagItem *) &tag1type) { };
	BListviewC(GadgetEventC *ev, WindowC &w, struct TagItem *tags)
		: BListC(ev,lc.boopsiclass(),NULL,w,tags) { };
protected:
	BListviewC(GadgetEventC *ev, struct IClass *c, STRPTR pubclass,
			WindowC &w, struct TagItem *tags)
		: BListC(ev,c,pubclass,w,tags) { };
private:
	static ListviewClass lc;
};

// *************************************************************

#define LB_LabelLeft      0
#define LB_LabelRight     1

#define LB_AdjustLeft     0
#define LB_AdjustCenter   1
#define LB_AdjustRight    2

#define LBA_Font           (TAG_USER + 1) // ISG, struct TextAttr *
#define LBA_Text           (TAG_USER + 2) // ISG, STRPTR
#define LBA_Number         (TAG_USER + 3) // ISG, LONG
#define LBA_LabelPlace     (TAG_USER + 4) // I·G, ULONG
#define LBA_Adjust         (TAG_USER + 5) // ISG, ULONG
#define LBA_Border         (TAG_USER + 6) // I·G, BOOL
#define LBA_LeftBorder     (TAG_USER + 7) // ··G, LONG
#define LBA_RightBorder    (TAG_USER + 8) // ··G, LONG
#define LBA_TopBorder      (TAG_USER + 9) // ··G, LONG
#define LBA_BottomBorder   (TAG_USER +10) // ··G, LONG
#define LBA_AutoWidth      (TAG_USER +11) // ··G, LONG
#define LBA_AutoHeight     (TAG_USER +12) // ··G, LONG
#define LBA_Columns        (TAG_USER +13) // ISG, ULONG

class LabelClass : public BoopsiClass {
public:
	LabelClass();
private:
	static ULONG dispatcher(Class *cl, Object *o, Msg msg);
	static ULONG render(Class *cl, struct Gadget *g,
		struct gpRender *msg, struct InstanceData *);
	static VOID calcBorders(Class *cl, struct Gadget *g,
		struct InstanceData *data);
	static WORD calcWidth(Class *cl, struct Gadget *g,
		struct InstanceData *data);
	static WORD calcHeight(Class *cl, struct Gadget *g,
		struct InstanceData *data);
};

class BTextC : public BGadgetC, GTextC {
public:
	BTextC(GadgetEventC *ev, WindowC &w, Tag tag1type, ...)
		: BGadgetC(ev,lc.boopsiclass(),NULL,w,(struct TagItem *) &tag1type) { };
	BTextC(GadgetEventC *ev, WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,lc.boopsiclass(),NULL,w,tags) { };
	WORD leftBorder() const { return (WORD) getAttr(LBA_LeftBorder); };
	WORD rightBorder() const { return (WORD) getAttr(LBA_RightBorder); };
	WORD topBorder() const { return (WORD) getAttr(LBA_TopBorder); };
	WORD bottomBorder() const { return (WORD) getAttr(LBA_BottomBorder); };
	BOOL disable(BOOL value) { return BGadgetC::disable(value) };
	BOOL isDisabled() const { return BGadgetC::isDisabled() };
	BOOL activate(BOOL v) { return FALSE; };
	VOID setTextAttr(const TextAttrC *f) { setAttrs(LBA_Font,f,TAG_END); };
	TextAttrC *textAttr() const { return (struct TextAttrC *) getAttr(LBA_Font); };
	VOID set(STRPTR s) { setAttrs(LBA_Text,s,TAG_END); };
	STRPTR get() { return (STRPTR) getAttr(LBA_Text); };
protected:
	BTextC(GadgetEventC *ev, struct IClass *c, STRPTR pubclass,
			WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,c,pubclass,w,tags) { };
private:
	static LabelClass lc;
};

class BNumberC : public BGadgetC, GNumberC {
public:
	BNumberC(GadgetEventC *ev, WindowC &w, Tag tag1type, ...);
	BNumberC(GadgetEventC *ev, WindowC &w, struct TagItem *tags);
	WORD leftBorder() const { return (WORD) getAttr(LBA_LeftBorder); };
	WORD rightBorder() const { return (WORD) getAttr(LBA_RightBorder); };
	WORD topBorder() const { return (WORD) getAttr(LBA_TopBorder); };
	WORD bottomBorder() const { return (WORD) getAttr(LBA_BottomBorder); };
	BOOL disable(BOOL value) { return BGadgetC::disable(value) };
	BOOL isDisabled() const { return BGadgetC::isDisabled() };
	BOOL activate(BOOL v) { return FALSE; };
	VOID setTextAttr(const TextAttrC *f) { setAttrs(LBA_Font,f,TAG_END); };
	TextAttrC *textAttr() const { return (struct TextAttrC *) getAttr(LBA_Font); };
	VOID set(LONG s) { setAttrs(LBA_Number,s,TAG_END); };
	LONG get() { return (LONG) getAttr(LBA_Number); };
protected:
	BNumberC(GadgetEventC *ev, struct IClass *c, STRPTR pubclass,
			WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,c,pubclass,w,tags) { };
private:
	static LabelClass lc;
};

// *************************************************************

#define SVA_Level       (TAG_USER + 1) // ISG, UWORD
#define SVA_Horiz       (TAG_USER + 2) // I·G, BOOL
#define SVA_LUSize      (TAG_USER + 3) // ··G, UWORD
#define SVA_RBSize      (TAG_USER + 4) // ··G, UWORD
#define SVA_AutoRedraw  (TAG_USER + 5) // I··, BOOL
#define SVA_RBPosition  (TAG_USER + 6) // ··G, ULONG
#define SVA_LUMargin    (TAG_USER + 7) // ISG, ULONG
#define SVA_RBMargin    (TAG_USER + 8) // ISG, ULONG

class SplitviewClass : public BoopsiClass {
public:
	SplitviewClass();
private:
	static ULONG dispatcher(Class *cl, Object *o, Msg msg);
	static ULONG render(Class *cl, struct Gadget *g,
		struct gpRender *msg, struct InstanceData *, BOOL selected = FALSE);
	static ULONG renderXor(Class *cl, struct Gadget *g,
		struct gpRender *msg, struct InstanceData *);
	static ULONG clear(Class *cl, struct Gadget *g,
		struct gpRender *msg, struct InstanceData *);
};

class BSplitviewC : public BGadgetC {
public:
	BSplitviewC(GadgetEventC *ev, WindowC &w, Tag tag1type, ...)
		: BGadgetC(ev,svc.boopsiclass(),NULL,w,(struct TagItem *) &tag1type)
		{ };
	BSplitviewC(GadgetEventC *ev,WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,svc.boopsiclass(),NULL,w,tags) { };
protected:
	BSplitviewC(GadgetEventC *ev, struct IClass *c, STRPTR pubclass,
		WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,c,pubclass,w,tags) { };
private:
	static SplitviewClass svc;
};

// *************************************************************

#define WBIDA_DiskObject    (TAG_USER + 1) // ISG, struct DiskObject *
#define WBIDA_Name          (TAG_USER + 2) // IS·, STRPTR
#define WBIDA_Font          (TAG_USER + 3) // ISG, struct TextAttr *
#define WBIDA_LeftBorder    (TAG_USER + 4) // ··G, LONG
#define WBIDA_RightBorder   (TAG_USER + 5) // ··G, LONG
#define WBIDA_TopBorder     (TAG_USER + 6) // ··G, LONG
#define WBIDA_BottomBorder  (TAG_USER + 7) // ··G, LONG
#define WBIDA_AutoWidth     (TAG_USER + 8) // ··G, LONG
#define WBIDA_AutoHeight    (TAG_USER + 9) // ··G, LONG

class WBIconDropClass : public BoopsiClass {
public:
	WBIconDropClass();
private:
	static ULONG dispatcher(Class *cl, Object *o, Msg msg);
	static ULONG render(Class *cl, struct Gadget *g,
		struct gpRender *msg, struct InstanceData *);
	static LONG calcWidth(Class *cl, struct Gadget *g,
		struct InstanceData *);
	static LONG calcHeight(Class *cl, struct Gadget *g,
		struct InstanceData *);
	static WORD calcTopBorder(Class *cl, struct Gadget *g,
		struct InstanceData *);
};

class BWBIconDropC : public BGadgetC {
public:
	BWBIconDropC(GadgetEventC *ev, WindowC &w, Tag tag1type, ...)
		: BGadgetC(ev,idc.boopsiclass(),NULL,w,(struct TagItem *) &tag1type)
		{ };
	BWBIconDropC(GadgetEventC *ev,WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,idc.boopsiclass(),NULL,w,tags) { };
	WORD leftBorder() const { return (WORD) getAttr(WBIDA_LeftBorder); };
	WORD rightBorder() const { return (WORD) getAttr(WBIDA_RightBorder); };
	WORD topBorder() const { return (WORD) getAttr(WBIDA_TopBorder); };
	WORD bottomBorder() const { return (WORD) getAttr(WBIDA_BottomBorder); };
	VOID setTextAttr(const TextAttrC *f) { setAttrs(WBIDA_Font,f,TAG_END); };
	TextAttrC *textAttr() const { return (struct TextAttrC *) getAttr(WBIDA_Font); };
protected:
	BWBIconDropC(GadgetEventC *ev, struct IClass *c, STRPTR pubclass,
		WindowC &w, struct TagItem *tags)
		: BGadgetC(ev,c,pubclass,w,tags) { };
private:
	static WBIconDropClass idc;
};

class IconDropHandlerC : public AppWindowHandlerC {
public:
	IconDropHandlerC(AppWindowC &, BWBIconDropC &);
protected:
	virtual BOOL _forMe(AppMessageC &msg);
private:
	BWBIconDropC *aGadget;
};

// *************************************************************

#endif