#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;

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

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> &);
};

#endif