#pragma once

#ifndef TW_INCLUDED

#define TW_INCLUDED

#include "traster.h"

#undef DVAPI

#undef DVVAR

#ifdef TWIN_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

class TMouseEvent;

class TCursor;

class TDragDropListener;

//-------------------------------------------------------------

class DVAPI TGuiColor

{

	int m_red, m_green, m_blue;

	//mutable void* m_imp;

	//bool  m_isStock;

	//int m_shade;

	//TUINT32 *m_index;

	//mutable bool m_allocated;

public:

	//static const int m_maxShade;

	TGuiColor(int r, int g, int b);

	TGuiColor();

	~TGuiColor();

	//TGuiColor(const TGuiColor&);

	//TGuiColor& operator=(const TGuiColor&);

	// TUINT32 getIndex(int shade=0) const;

	// TUINT32 getRGB(int shade=0) const;

	int red() const { return m_red; }

	int green() const { return m_green; }

	int blue() const { return m_blue; }

	void computeShade(int index, int &r, int &g, int &b) const;

	//void* imp() const {return m_imp;}

	//void imp(void* imp) const { m_imp = imp; }

	//bool isStock() const { return m_isStock; }

protected:

	void initStockColor();

};

//-------------------------------------------------------------

class TWidgetImp;

//class TTarget {};

//class TTimerTarget {};

class TWidget;

typedef std::vector<twidget *=""> TWidgetList;</twidget>

//-------------------------------------------------------------

class DVAPI TWidget

// : public TTarget, public TTimerTarget

{

public:

	enum Alignment { BEGIN,

					 CENTER,

					 END };

	enum FocusHandling { IGNORE_FOCUS,

						 STOP_FOCUS,

						 LISTEN_TO_FOCUS };

protected:

	TRect m_placement;

	int m_xoff, m_yoff;

	bool m_mapped; // e' arrivato il MapNotify

	bool m_hidden; // il widget non vuole mostrarsi

	bool m_childrenChanged;

	//TTimer *m_timer;

	TWidget *m_parent, *m_sonKeeper;

	std::string m_name, m_contextHelpReference;

	std::wstring m_shortHelp, m_longHelp;

	int m_cursorIdx;

	TWidgetList *m_sons;

	TWidgetImp *m_imp;

	friend class TWidgetImp;

	TGuiColor m_backgroundColor, m_foregroundColor;

	bool m_popupMode, m_menuMode, m_fixedSize, m_fullColor, m_openGL;

	bool m_enabled, m_menuRelated;

	TDragDropListener *m_dragDropListener;

	std::string m_fontName;

	int m_fontSize;

	int m_fontOrientation;

	static TWidget *m_selectionOwner;

	static TWidget *m_focusOwner;

	// not implemented (cannot copy and assign widget)

private:

	TWidget(const TWidget &);

	TWidget &operator=(const TWidget &);

protected:

	virtual void create();

	virtual void setDecoration();

	virtual void destroyImp();

	void createSons();

public:

	TWidget(TWidget *parent = 0, std::string name = "unnamed");

	virtual ~TWidget();

	//

	// geometry

	//

	const TRect &getGeometry() const { return m_placement; }

	TPoint getPosition() const { return m_placement.getP00(); }

	virtual TPoint getHotSpot() const { return TPoint(0, 0); }

	TDimension getSize() const { return m_placement.getSize(); }

	TRect getBounds() const { return TRect(TPoint(), getSize()); }

	int getLx() const { return m_placement.getLx(); }

	int getLy() const { return m_placement.getLy(); }

	inline void setPlacement(const TRect &rect) { m_placement = rect; }

	inline void setGeometry(int x0, int y0, int x1, int y1)

	{

		setGeometry(TRect(x0, y0, x1, y1));

	}

	virtual void setGeometry(const TRect &rect);

	void setGeometry(const TPoint &pos, const TDimension &size)

	{

		setGeometry(TRect(pos, size));

	}

	inline void setSize(int w, int h)

	{

		setGeometry(getPosition(), TDimension(w, h));

	}

	inline void setSize(const TDimension &size)

	{

		setSize(size.lx, size.ly);

	}

	inline void setPosition(int x, int y)

	{

		setGeometry(TPoint(x, y), getSize());

	}

	inline void setPosition(const TPoint &pt)

	{

		setGeometry(pt, getSize());

	}

	inline bool contains(int x, int y) const { return contains(TPoint(x, y)); }

	inline bool contains(const TPoint &p) const { return m_placement.contains(p); }

	TPoint getScreenPosition() const;

	//

	// name, parent & sons

	//

	inline TWidget *getParent() const { return m_parent; }

	inline std::string getName() const { return m_name; }

	virtual void setParent(TWidget *p);

	virtual void addSon(TWidget *son);

	virtual void removeSon(TWidget *son);

	inline int getSonCount() const { return m_sons->size(); }

	inline TWidget *getSon(int i) const { return i < 0 || i >= (int)(m_sons->size()) ? 0 : (*m_sons)[i]; }

	//

	// help messages

	//

	std::wstring getLongHelp() const;

	std::wstring getShortHelp() const;

	void setHelp(std::string shortHelp, std::string longHelp);

	void setHelp(std::wstring shortHelp, std::wstring longHelp);

	virtual std::string getContextHelpReference(const TPoint &)

	{

		return m_contextHelpReference;

	}

	void setContextHelpReference(std::string s)

	{

		m_contextHelpReference = s;

	}

	//void delegateHelpToParent();

	virtual std::wstring getTooltipString(const TPoint &) { return getShortHelp(); }

	//

	// misc

	//

	inline bool isHidden() const { return m_hidden; }

	inline bool isMapped() const { return m_mapped; }

	void enable();

	void disable();

	inline bool isEnabled() const { return m_enabled; }

	void show();

	void hide();

	// n.b. non chiamare map/unmap, ma show/hide

	virtual void map();

	virtual void unmap();

	virtual void doModal();

	virtual void undock();

	virtual void dock(TWidget *parent);

	virtual TWidget *findSubWidget(const TPoint &pt);

	virtual void repaint();

	void sendRepaint() { sendRepaint(getBounds()); }

	void sendRepaint(const TRect &);

	virtual void paste();

	virtual void startDragAndDrop(std::string stringToDrop);

	typedef unsigned int CursorIndex;

	inline CursorIndex getCurrentCursor() { return m_cursorIdx; }

	void changeCursor(CursorIndex new_cur);

	TWidgetImp *getImp() { return m_imp; }

	void startTimer(TINT32 period);

	void stopTimer();

	virtual void getSelection();

	virtual void onFocusChange(bool on);

	virtual bool getFocus() { return false; }

	virtual void circulateFocus();

	virtual void copyRegion(

		const TPoint &dst,

		const TPoint &src,

		const TDimension &size);

	//

	// draw

	//

	void flush();

	virtual void draw() {}

	virtual void invalidate();

	virtual void invalidate(const TRect &rect);

	void getClipRect(TRect &rect);

	virtual void clear();

	virtual void drawText(const TPoint &p, std::string text);

	virtual void drawText(const TPoint &p, std::wstring text);

	virtual void drawText(const TRect &r, std::string text, Alignment alignment = CENTER);

	virtual void drawText(const TRect &r, std::wstring text, Alignment alignment = CENTER);

	virtual void drawMultiLineText(const TRect &r, std::string text);

	virtual void drawMultiLineText(const TRect &r, std::wstring text);

	virtual TDimension getTextSize(std::string text);

	virtual TDimension getTextSize(std::wstring text);

	virtual TDimension getTextSize(std::string text, std::string font, int fontSize);

	virtual TDimension getTextSize(std::wstring text, std::string font, int fontSize);

	inline void drawPoint(int x, int y) { drawLine(x, y, x, y); }

	virtual void drawLine(const TPoint &p0, const TPoint &p1);

	inline void drawLine(int x0, int y0, int x1, int y1)

	{

		drawLine(TPoint(x0, y0), TPoint(x1, y1));

	}

	virtual void drawVLine(const TPoint &p0, int length)

	{

		drawLine(p0, p0 + TPoint(0, length - 1));

	}

	virtual void drawHLine(const TPoint &p0, int length)

	{

		drawLine(p0, p0 + TPoint(length - 1, 0));

	}

	virtual void drawDottedLine(const TPoint &p0, const TPoint &p1);

	inline void drawDottedLine(int x0, int y0, int x1, int y1)

	{

		drawDottedLine(TPoint(x0, y0), TPoint(x1, y1));

	}

	virtual void drawRect(const TRect &);

	virtual void fillRect(const TRect &);

	virtual void drawRect(int x0, int y0, int x1, int y1)

	{

		drawRect(TRect(x0, y0, x1, y1));

	}

	virtual void fillRect(int x0, int y0, int x1, int y1)

	{

		fillRect(TRect(x0, y0, x1, y1));

	}

	virtual void draw3DRect(const TRect &,

							bool pressed = false, int border = 1);

	virtual void fill3DRect(const TRect &,

							bool pressed = false, int border = 1);

	virtual void drawDottedRect(const TRect &);

	virtual void drawDottedRect(int x0, int y0, int x1, int y1)

	{

		drawDottedRect(TRect(x0, y0, x1, y1));

	}

	virtual void fillPolygon(

		const TGuiColor &fillColor,

		const TGuiColor &borderColor,

		const TPoint points[],

		int pointCount);

	virtual void clear(const TRect &);

	virtual void drawImage(int index, const TPoint &);

	virtual void setColor(const TGuiColor &, int shade = 0);

	virtual void setBackgroundColor(const TGuiColor &);

	TGuiColor getBackgroundColor() const { return m_backgroundColor; }

	TGuiColor getForegroundColor() const { return m_foregroundColor; }

	static const TGuiColor White;

	static const TGuiColor Black;

	virtual void rectwrite(const TRaster32P &, const TPoint &);

	virtual void setFontSize(int size);

	virtual void setFont(std::string name, int size = 0, int orientation = 0);

	//

	// events

	//

	virtual void enter(const TPoint &) {}

	virtual void leave(const TPoint &) {}

	virtual void mouseMove(const TMouseEvent &) {}

	virtual void leftButtonDown(const TMouseEvent &) {}

	virtual void leftButtonDrag(const TMouseEvent &) {}

	virtual void leftButtonUp(const TMouseEvent &) {}

	virtual void rightButtonDown(const TMouseEvent &) {}

	virtual void rightButtonDrag(const TMouseEvent &) {}

	virtual void rightButtonUp(const TMouseEvent &) {}

	virtual void middleButtonDown(const TMouseEvent &) {}

	virtual void middleButtonDrag(const TMouseEvent &) {}

	virtual void middleButtonUp(const TMouseEvent &) {}

	virtual void leftButtonDoubleClick(const TMouseEvent &) {}

	virtual void middleButtonDoubleClick(const TMouseEvent &) {}

	virtual void rightButtonDoubleClick(const TMouseEvent &) {}

	virtual void mouseWheel(const TMouseEvent &, int wheel) {}

	virtual void keyDown(int, TUINT32, const TPoint &) {}

	virtual void configureNotify(const TDimension &) {}

	virtual void onPaste(std::string) {}

	// virtual void close() {unmap();}

	virtual void onDrop(std::string) {}

	virtual std::string getToolTip() { return ""; }

	virtual void onTimer(int) {}

	virtual void onChildrenChanged() {}

	virtual bool onNcPaint(bool is_active, const TDimension &window_size, const TRect &caption_rect);

public:

	static void setFocusOwner(TWidget *w);

	static TWidget *getFocusOwner();

	virtual FocusHandling getFocusHandling() const { return IGNORE_FOCUS; }

	static void placeInteractively(TRect &);

	// brutto brutto qui

	virtual void maximize(TWidget *) {}

	virtual bool isMaximized(TWidget *) { return false; }

	//

	// drag & drop

	//

	// virtual bool acceptDrop() {return false;}

	void enableDropTarget(TDragDropListener *dragDropListener);

	TDragDropListener *getDragDropListener() const { return m_dragDropListener; }

	static void yield(); // processa tutti gli eventi in attesa

	static void setMode(int mode);

	// misc

	TPoint getAbsolutePosition() const;

	static TPoint getMouseAbsolutePosition();

	TPoint getMouseRelativePosition() const;

	// brutto. serve per filtrare gli eventi durante il menu event loop

	bool isMenuRelated() const { return m_menuRelated; }

	// se non altro e' brutto il nome

	//NB: il nome e' brutto... ora questo e' anche sbagliato

	static void processAllPendingMessages(); // questa processa solo i WM_PAINT

	static void processAllPendingMessages2(); // questa processa tutto

	// mah? serve a evitare il circuito invalidate() -> repaint(); chiama direttamente

	// repaint() (creando l'opportuno GC su windows)

	//void paintRegion(const TRect &rect);

	static TDimension getScreenSize();

	static void getScreenPlacement(std::vector<trecti> &);</trecti>

};

#endif