#ifndef GLAREA_INCLUDED
#define GLAREA_INCLUDED

//#include "traster.h"
#include "tw/tw.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 TStopWatch;

class DVAPI TGLArea : public TWidget
{

	void swapBuffers();
	TStopWatch *m_stopwatch;
	double m_framePerSecond;

	void computeOcclusingRegion();
	void deleteOcclusingRegion();
	//void  redrawUncoveredArea(const TPoint &);

	std::vector<TRect> *m_arrayOfRectToRedraw;

protected:
// int m_lx, m_ly;

// double m_angle;

#define PEZZA_DISABLE_REDRAW

#if defined(MACOSX) && defined(PEZZA_DISABLE_REDRAW)
	bool m_disableRedraw;
#endif

	TPoint m_lastPos;
	TPointD m_pan;			 // world origin (win coords) (n. m_pan*2 are integer)
	TPointD m_zoomFactor;	// "world pixel" dimension (win coords) (integer if >=1)
	TDimensionD m_pixelSize; // 1/zoomFactor; win pixel dimension (world coords)

	double m_zoomLevel; // m_zoomFactor = e^m_zoomLevel

	// supported extensions
	static bool m_bgraSupported;

	bool m_isInsideScreen;
	void onGLContextCreated();

public:
	class PickItem
	{
	public:
		UINT m_label;
		UINT m_zMin;
		UINT m_zMax;

		PickItem(UINT label, UINT zmin, UINT zmax)
			: m_label(label), m_zMin(zmin), m_zMax(zmax)
		{
		}

		~PickItem() {}
	private:
		//not implemented
		PickItem();
	};

	TGLArea(TWidget *parent, string name = "GLArea");
	~TGLArea();

	void repaint();
	void configureNotify(const TDimension &);
	void create();

	void paintIncrementally();

	//  void rectwrite(const TRaster32P &ras, const TPoint &p);
	void over(const TRaster32P &ras, const TPoint &p);
	void over(const TRasterGR8P &ras, const TPoint &p);

	inline TPointD win2world(const TPointD &p) const;
	inline TPointD world2win(const TPointD &p) const;

	inline TAffine getWin2WorldMatrix() const;
	inline TAffine getWorld2WinMatrix() const;

	void scroll(const TPoint &d);  // viewport coordinates
	void lookAt(const TPointD &d); // world coordinates of the desired window center

	// n. zoomCenter : viewport coords
	void setZoomLevel(double zlevel, const TPoint &zoomCenter);
	void changeZoomLevel(double d, const TPoint &center);
	virtual void onZoomChange() {}

	void fitToWindow(const TRectD &worldRect);

	void middleButtonDown(const TMouseEvent &e);
	void middleButtonDrag(const TMouseEvent &e);
	void middleButtonUp(const TMouseEvent &e);

	void draw();
	virtual void drawIncrementally();

	virtual void drawForPick() { draw(); }

	void pick(const TPoint &point, vector<PickItem> &items);

	double getFramePerSecond() const { return m_framePerSecond; }

	static bool isBGRASupported() { return m_bgraSupported; }

	bool unProject(
		TPointD &output,

		const TPoint &mousePos,
		const T3DPointD &planeOrigin,
		const T3DPointD &u,
		const T3DPointD &v) const;

	void makeCurrent(); // Gl context
	bool m_dontSwapBuffers;
};

inline TPointD TGLArea::win2world(const TPointD &p) const
{
	TPointD q = p - m_pan;
	return TPointD(m_pixelSize.lx * q.x, m_pixelSize.ly * q.y);
}

inline TPointD TGLArea::world2win(const TPointD &p) const
{
	return m_pan + TPointD(p.x * m_zoomFactor.x, p.y * m_zoomFactor.y);
}

inline TAffine TGLArea::getWin2WorldMatrix() const
{
	return TScale(m_pixelSize.lx, m_pixelSize.ly) * TTranslation(-m_pan);
}

inline TAffine TGLArea::getWorld2WinMatrix() const
{
	return TTranslation(m_pan) * TScale(m_zoomFactor.x, m_zoomFactor.y);
}

#endif