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

// tregion.h: interface for the TRegion class.

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

#if !defined(TREGION_H)

#define TREGION_H

#include <memory></memory>

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

#include "tgeometry.h"

//#include "tsmartpointer.h"

#undef DVAPI

#undef DVVAR

#ifdef TVECTORIMAGE_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

//=============================================================================

//forward declarations

class TStroke;

//class  TVectorRenderData;

class TRegion;

class TRegionProp;

//class TVectorPalette;

//=============================================================================

class TRegionId

{

public:

	int m_strokeId;

	float m_midW;

	bool m_direction;

	TRegionId(int strokeId, float midW, bool direction)

		: m_strokeId(strokeId), m_midW(midW), m_direction(direction)

	{

	}

};

class TFilledRegionInf

{

public:

	TRegionId m_regionId;

	int m_styleId;

	TFilledRegionInf(int strokeId, float midW, bool direction, int styleId)

		: m_regionId(strokeId, midW, direction), m_styleId(styleId)

	{

	}

	TFilledRegionInf(TRegionId regionId, int styleId)

		: m_regionId(regionId), m_styleId(styleId)

	{

	}

};

//=============================================================================

class TGeneralEdge

{

public:

	enum Type {

		eNormal,

		eAutoclose

	};

	Type m_type;

	TGeneralEdge(Type type) : m_type(type) {}

};

class TEdge : public TGeneralEdge

{

public:

	TStroke *m_s;

	double m_w0, m_w1;

	int m_index;

	TRegion *m_r;

	int m_styleId;

	bool m_toBeDeleted;

	//bool m_forward;

public:

	TEdge()

		: TGeneralEdge(eNormal), m_s(0), m_w0(-1), m_w1(-1), m_index(-1), m_r(0), m_styleId(0), m_toBeDeleted(false)

	//, m_forward(true)

	{

	}

	TEdge(TStroke *ref, UINT index, double w0, double w1, bool toBeDeletedWithStroke, int styleId)

		: TGeneralEdge(eNormal), m_s(ref), m_w0(w0), m_w1(w1), m_index(index), m_r(0), m_styleId(styleId), m_toBeDeleted(toBeDeletedWithStroke)

	//, m_forward(forward)

	{

	}

	/* TEdge(TStroke* ref, bool toBeDeletedWithStroke)

      : m_s (ref)

      , m_w0  (-1)

      , m_w1  (-1) 

      , m_r(0)

      , m_styleId(0) 

			, m_toBeDeleted(toBeDeletedWithStroke)

      {}*/

	TEdge(const TEdge &e, bool toBeDeletedWithStroke)

		: TGeneralEdge(eNormal), m_s(e.m_s), m_w0(e.m_w0), m_w1(e.m_w1), m_index(e.m_index), m_r(e.m_r), m_styleId(e.m_styleId), m_toBeDeleted(toBeDeletedWithStroke)

	//, m_forward(e.m_forward)

	{

	}

	TEdge &operator=(const TEdge &e)

	{

		m_s = e.m_s;

		m_w0 = e.m_w0;

		m_w1 = e.m_w1;

		m_index = e.m_index;

		m_r = e.m_r;

		m_styleId = e.m_styleId;

		m_toBeDeleted = e.m_toBeDeleted;

		//m_forward = e.m_forward;

		return *this;

	}

	TEdge(const TEdge &e) : TGeneralEdge(eNormal), m_s(e.m_s), m_w0(e.m_w0), m_w1(e.m_w1), m_index(e.m_index), m_r(e.m_r), m_styleId(e.m_styleId), m_toBeDeleted(e.m_toBeDeleted) /*, m_forward(e.m_forward)*/ {}

	bool operator<(const TEdge &e) const

	{

		return (e.m_s == m_s) ? ((e.m_w0 == m_w0) ? e.m_w1 < m_w1 : e.m_w0 < m_w0) : e.m_s < m_s;

	}

	inline int getStyle() const { return m_styleId; }

	inline void setStyle(int styleId) { m_styleId = styleId; }

	inline bool operator==(const TEdge &b) const

	{

		return m_s == b.m_s && ((m_w0 == b.m_w0 && m_w1 == b.m_w1) || (m_w0 == b.m_w1 && m_w1 == b.m_w0));

	}

private:

	TEdge(TStroke *ref);

};

/*

#ifdef _WIN32

template class DVAPI TSmartPointerT<tedge>; </tedge>

#endif

typedef TSmartPointerT<tedge> TEdgeP;</tedge>

*/

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

//void addRegion(vector<tregion*>& regionArray, TRegion *region);</tregion*>

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

class DVAPI TRegion

{

	class Imp;

	std::unique_ptr<imp> m_imp;</imp>

public:

	TRegion();

	~TRegion();

	TRectD getBBox() const;

	bool contains(const TPointD &p) const;

	bool contains(const TRegion &r) const;

	bool contains(const TStroke &s, bool mayIntersect = false) const;

	bool contains(const TEdge &e) const;

	//! returns the region equivalent to r, 0 if does not exists.

	TRegion *findRegion(const TRegion &r) const;

	TRegion *getSubregion(UINT index) const;

	UINT getSubregionCount() const;

	void deleteSubregion(UINT index);

	void addSubregion(TRegion *region);

	TEdge *getEdge(UINT index) const;

	TEdge *getLastEdge() const;

	UINT getEdgeCount() const;

	void addEdge(TEdge *e, bool minimizeEdges);

	TEdge *popFrontEdge();

	TEdge *popBackEdge();

	void moveSubregionsTo(TRegion *r);

	//it returns the  style of the region before filling or -1 if not filled.

	int fill(const TPointD &p, int styleId);

	bool selectFill(const TRectD &selectArea, int styleId);

	//! returns the smallest subregions (including this) containing p

	TRegion *getRegion(const TPointD &p);

	int getStyle() const;

	void setStyle(int styleId);

	void autoFill(int styleId, bool oddLevel);

	bool isSubRegionOf(const TRegion &r) const;

	bool getInternalPoint(TPointD &p);

	TRegionProp *getProp();

	void setProp(TRegionProp *prop);

	TRegionId getId();

	void invalidateProp();

	void invalidateBBox();

	void print();

	//friend void addRegion(vector<tregion*>& regionArray, TRegion *region);</tregion*>

	void computeScanlineIntersections(double y, std::vector<double> &intersections) const;</double>

	int scanlineIntersectionsBefore(double x, double y, bool horiz) const;

	int leftScanlineIntersections(double x, double y) const

	{

		return scanlineIntersectionsBefore(x, y, true);

	}

#ifdef _DEBUG

	void checkRegion();

#endif

};

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

/*Spostata in tregion.cpp

inline int TRegion::getStyle() const

{

int ret = 0;

  UINT i=0, j, n=getEdgeCount();

  for (; i

  {

	  int styleId = getEdge(i)->getStyle();

      if(styleId != 0 && ret==0) 

			  {

				//assert(styleId<100);

				ret =  styleId;

				if (i>0) for (j=0;j<i;j++) getedge(i)-="">setStyle(ret);</i;j++)>

				}

			else if (styleId!=ret)

			  getEdge(i)->setStyle(ret);

  }

  return ret;

}

*/

class DVAPI TRegionFeatureFormula

{

public:

	virtual void update(const TPointD &p1, const TPointD &p2) = 0;

};

//permette di calcolare varie grandesse sul poligono della regione,

//come l'area, il baricentro, il perimetro...

//per usarla si deve sottoclassare la classe virtuale TRegionFeatureFormula

//specificando la formual della grandezza da calcolare.

void DVAPI computeRegionFeature(const TRegion &r, TRegionFeatureFormula &formula);

#endif // !defined(TREGION_H)

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

//  End Of File

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