#include "tcurves.h"

//#include "tpalette.h"

#include "tvectorimage.h"

#include "tvectorimageP.h"

#include "tstroke.h"

//#include "tgl.h"

#include "tvectorrenderdata.h"

#include "tmathutil.h"

//#include "tdebugmessage.h"

#include "tofflinegl.h"

//#include "tcolorstyles.h"

#include "tpaletteutil.h"

#include "tthreadmessage.h"

#include "tsimplecolorstyles.h"

#include <memory></memory>

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

typedef TVectorImage::IntersectionBranch IntersectionBranch;

namespace

{

typedef std::set<int> DisabledStrokeStyles;</int>

// uso getDisabledStrokeStyleSet() invece che accedere direttamente alla

// variabile per assicurarmi che il tutto funzioni anche quando viene

// usato PRIMA del main (per iniziativa di un costruttore di una variabile

// globale, p.es.).

// per l'idioma: cfr. Modern C++ design, Andrei Alexandrescu, Addison Wesley 2001, p.133

inline DisabledStrokeStyles &getDisabledStrokeStyleSet()

{

	static DisabledStrokeStyles disabledStokeStyles;

	return disabledStokeStyles;

}

inline bool isStrokeStyleEnabled__(int index)

{

	DisabledStrokeStyles &disabledSet = getDisabledStrokeStyleSet();

	return disabledSet.find(index) == disabledSet.end();

}

} // namespace

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

/*!

Permette di copiare effettuare delle copie delle curve

*/

/*

template <class container=""> </class>

class StrokeArrayInsertIterator

{    

  Container& container;

public:

  explicit    StrokeArrayInsertIterator(Container& Line)

    :container(Line)

  {};

  StrokeArrayInsertIterator& operator=(const VIStroke* value )

  {

    TStroke *stroke = new TStroke(*(value->m_s));

    stroke->setId(value->m_s->getId());

    container.push_back(new VIStroke(stroke));

    return *this;

  };

  StrokeArrayInsertIterator&  operator*()       { return *this; }

  StrokeArrayInsertIterator&  operator++()       { return *this; }

  StrokeArrayInsertIterator   operator++(int val){ return *this; }

};

*/

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

/*!

TVectorImage::Imp: implementation of TVectorImage class

\relates  TVectorImage

*/

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

TVectorImage::Imp::Imp(TVectorImage *vi)

	: m_areValidRegions(false), m_notIntersectingStrokes(false), m_computeRegions(true), m_autocloseTolerance(c_newAutocloseTolerance), m_maxGroupId(1), m_maxGhostGroupId(1), m_mutex(new TThread::Mutex()), m_vi(vi), m_intersectionData(0), m_computedAlmostOnce(false), m_justLoaded(false), m_insideGroup(TGroupId()), m_minimizeEdges(true)

#ifdef NEW_REGION_FILL

	  ,

	  m_regionFinder(0)

#endif

{

#ifdef NEW_REGION_FILL

	resetRegionFinder();

#endif

	initRegionsData();

}

TVectorImage::Imp::~Imp()

{

	//delete m_regionFinder;

	deleteRegionsData();

	delete m_mutex;

}

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

TVectorImage::TVectorImage(bool loaded)

	: m_imp(new TVectorImage::Imp(this))

{

	if (loaded)

		m_imp->m_justLoaded = true;

}

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

TVectorImage::~TVectorImage()

{

}

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

int TVectorImage::isInsideGroup() const

{

	return m_imp->m_insideGroup.getDepth();

}

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

int TVectorImage::addStrokeToGroup(TStroke *stroke, int strokeIndex)

{

	if (!m_imp->m_strokes[strokeIndex]->m_groupId.isGrouped())

		return addStroke(stroke, true);

	for (int i = m_imp->m_strokes.size() - 1; i >= 0; i--)

		if (m_imp->m_strokes[i]->m_groupId == m_imp->m_strokes[strokeIndex]->m_groupId) {

			m_imp->insertStrokeAt(new VIStroke(stroke, m_imp->m_strokes[i]->m_groupId), i + 1);

			return i + 1;

		}

	assert(false);

	return -1;

}

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

int TVectorImage::addStroke(TStroke *stroke, bool discardPoints)

{

	if (discardPoints) {

		TRectD bBox = stroke->getBBox();

		if (bBox.x0 == bBox.x1 && bBox.y0 == bBox.y1) //empty stroke: discard

			return -1;

	}

	if (m_imp->m_insideGroup != TGroupId()) {

		int i;

		for (i = m_imp->m_strokes.size() - 1; i >= 0; i--)

			if (m_imp->m_insideGroup.isParentOf(m_imp->m_strokes[i]->m_groupId)) {

				m_imp->insertStrokeAt(new VIStroke(stroke, m_imp->m_strokes[i]->m_groupId), i + 1);

				return i + 1;

			}

	}

	TGroupId gid;

	if (m_imp->m_strokes.empty() || m_imp->m_strokes.back()->m_groupId.isGrouped() != 0)

		gid = TGroupId(this, true);

	else

		gid = m_imp->m_strokes.back()->m_groupId;

	m_imp->m_strokes.push_back(new VIStroke(stroke, gid));

	m_imp->m_areValidRegions = false;

	return m_imp->m_strokes.size() - 1;

}

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

void TVectorImage::moveStrokes(int fromIndex, int count, int moveBefore)

{

#ifdef _DEBUG

	m_imp->checkGroups();

#endif

	m_imp->moveStrokes(fromIndex, count, moveBefore, true);

#ifdef _DEBUG

	m_imp->checkGroups();

#endif

}

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

void TVectorImage::Imp::moveStrokes(int fromIndex, int count, int moveBefore, bool regroup)

{

	assert(fromIndex >= 0 && fromIndex < (int)m_strokes.size());

	assert(moveBefore >= 0 && moveBefore <= (int)m_strokes.size());

	assert(count > 0);

	assert(fromIndex != moveBefore);

	for (int i = 0; i < count; i++)

		if (fromIndex < moveBefore)

			moveStroke(fromIndex, moveBefore);

		else

			moveStroke(fromIndex + i, moveBefore + i);

	std::vector<int> changedStrokes;</int>

	if (regroup)

		regroupGhosts(changedStrokes);

	if (!changedStrokes.empty())

		notifyChangedStrokes(changedStrokes, std::vector<tstroke *="">(), false);</tstroke>

}

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

void TVectorImage::insertStrokeAt(VIStroke *vs, int strokeIndex, bool recomputeRegions)

{

	m_imp->insertStrokeAt(vs, strokeIndex, recomputeRegions);

}

/*

void TVectorImage::insertStrokeAt(TStroke *stroke, int strokeIndex, const TGroupId& id)

{

VIStroke* vs;

vs = new VIStroke(stroke, id);

m_imp->insertStrokeAt(vs, strokeIndex);

}

*/

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

/*

TRectD TVectorImage::addStroke(const std::vector<tthickpoint> &points)</tthickpoint>

{

//  era:  TStroke *stroke = makeTStroke(points);

  TStroke *stroke = TStroke::interpolate(points, 5.0);

  m_imp->m_strokes.push_back(new VIStroke( stroke) );

  m_imp->m_areValidRegions = false;

  return stroke->getBBox();

}

*/

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

bool isRegionWithStroke(TRegion *region, TStroke *s)

{

	for (UINT i = 0; i < region->getEdgeCount(); i++)

		if (region->getEdge(i)->m_s == s)

			return true;

	return false;

}

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

void deleteSubRegionWithStroke(TRegion *region, TStroke *s)

{

	for (int i = 0; i < (int)region->getSubregionCount(); i++) {

		deleteSubRegionWithStroke(region->getSubregion(i), s);

		if (isRegionWithStroke(region->getSubregion(i), s)) {

			TRegion *r = region->getSubregion(i);

			r->moveSubregionsTo(region);

			assert(r->getSubregionCount() == 0);

			region->deleteSubregion(i);

			delete r;

			i--;

		}

	}

}

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

TStroke *TVectorImage::removeStroke(int index, bool doComputeRegions)

{

	return m_imp->removeStroke(index, doComputeRegions);

}

TStroke *TVectorImage::Imp::removeStroke(int index, bool doComputeRegions)

{

	assert(index >= 0 && index < (int)m_strokes.size());

	QMutexLocker sl(m_mutex);

	VIStroke *stroke = m_strokes[index];

	eraseIntersection(index);

	m_strokes.erase(m_strokes.begin() + index);

	if (m_computedAlmostOnce) {

		reindexEdges(index);

		if (doComputeRegions)

			computeRegions();

	}

	return stroke->m_s;

}

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

void TVectorImage::removeStrokes(const std::vector<int> &toBeRemoved, bool deleteThem, bool recomputeRegions)</int>

{

	m_imp->removeStrokes(toBeRemoved, deleteThem, recomputeRegions);

}

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

void TVectorImage::Imp::removeStrokes(const std::vector<int> &toBeRemoved, bool deleteThem, bool recomputeRegions)</int>

{

	QMutexLocker sl(m_mutex);

	for (int i = toBeRemoved.size() - 1; i >= 0; i--) {

		assert(i == 0 || toBeRemoved[i - 1] < toBeRemoved[i]);

		UINT index = toBeRemoved[i];

		eraseIntersection(index);

		if (deleteThem)

			delete m_strokes[index];

		m_strokes.erase(m_strokes.begin() + index);

	}

	if (m_computedAlmostOnce && !toBeRemoved.empty()) {

		reindexEdges(toBeRemoved, false);

		if (recomputeRegions)

			computeRegions();

		else

			m_areValidRegions = false;

	}

}

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

void TVectorImage::deleteStroke(int index)

{

	TStroke *stroke = removeStroke(index);

	delete stroke;

}

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

void TVectorImage::deleteStroke(VIStroke *stroke)

{

	UINT index = 0;

	for (; index < m_imp->m_strokes.size(); index++)

		if (m_imp->m_strokes[index] == stroke) {

			deleteStroke(index);

			return;

		}

}

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

/*

void TVectorImage::validateRegionEdges(TStroke* stroke, bool invalidate)

{

if (invalidate)

  for (UINT i=0; i

    {

    TRegion *r = getRegion(i);

//  if ((*cit)->getBBox().contains(stroke->getBBox()))

    for (UINT j=0; j<r->getEdgeCount(); j++)</r->

      {

      TEdge* edge = r->getEdge(j);

      if (edge->m_s == stroke)

        edge->m_w0 = edge->m_w1 = -1;

      }

    }

else

 for (UINT i=0; i

    {

    TRegion *r = getRegion(i);

//  if ((*cit)->getBBox().contains(stroke->getBBox()))

    for (UINT j=0; j<r->getEdgeCount(); j++)</r->

      {

      TEdge* edge = r->getEdge(j);

      if (edge->m_w0==-1)

        {

        int index;

        double t, dummy;

        edge->m_s->getNearestChunk(edge->m_p0, t, index, dummy);

        edge->m_w0 = getWfromChunkAndT(edge->m_s, index, t);

        edge->m_s->getNearestChunk(edge->m_p1, t, index, dummy);

        edge->m_w1 = getWfromChunkAndT(edge->m_s, index, t);

        }

      }

    }

}

*/

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

UINT TVectorImage::getStrokeCount() const

{

	return m_imp->m_strokes.size();

}

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

/*

void  TVectorImage::addSeed(const TPointD& p, const TPixel& color)

{

m_imp->m_seeds.push_back(TFillSeed(color, p, NULL));

}

*/

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

UINT TVectorImage::getRegionCount() const

{

	//  assert( m_imp->m_areValidRegions || m_imp->m_regions.empty());

	return m_imp->m_regions.size();

}

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

TRegion *TVectorImage::getRegion(UINT index) const

{

	assert(index < m_imp->m_regions.size());

	//  assert( m_imp->m_areValidRegions );

	return m_imp->m_regions[index];

}

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

TRegion *TVectorImage::getRegion(TRegionId regId) const

{

	int index = getStrokeIndexById(regId.m_strokeId);

	assert(m_imp->m_areValidRegions);

	TRegion *reg = m_imp->getRegion(regId, index);

	//assert( reg );

	return reg;

}

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

TRegion *TVectorImage::Imp::getRegion(TRegionId regId, int index) const

{

	assert(index != -1);

	if (index == -1)

		return 0;

	assert(index < (int)m_strokes.size());

	if (index >= (int)m_strokes.size())

		return 0;

	std::list<tedge *=""> &edgeList = m_strokes[index]->m_edgeList;</tedge>

	std::list<tedge *="">::iterator endList = edgeList.end();</tedge>

	double w0;

	double w1;

	for (std::list<tedge *="">::iterator it = edgeList.begin(); it != endList; ++it) {</tedge>

		w0 = (*it)->m_w0;

		w1 = (*it)->m_w1;

		if (w0 < w1) {

			if (w0 < regId.m_midW && regId.m_midW < w1 && regId.m_direction)

				return (*it)->m_r;

		} else {

			if (w1 < regId.m_midW && regId.m_midW < w0 && !regId.m_direction)

				return (*it)->m_r;

		}

	}

#ifdef _DEBUG

	TPointD cp1 = m_strokes[index]->m_s->getControlPoint(0);

	TPointD cp2 = m_strokes[index]->m_s->getControlPoint(m_strokes[index]->m_s->getControlPointCount() - 1);

#endif

	return 0;

}

/*

TRegion* TVectorImage::getRegion(TRegionId regId) const

{

  int index = getStrokeIndexById(regId.m_strokeId);

  assert(index!=-1);

  if( index == -1 )

    return 0;

  assert( index < (int)m_imp->m_strokes.size() );

  if( index >= (int)m_imp->m_strokes.size() )

    return 0;

  std::list<tedge*> &edgeList = m_imp->m_strokes[index]->m_edgeList;</tedge*>

  std::list<tedge*>::iterator endList = edgeList.end();</tedge*>

  double w0;

  double w1;

  for(list<tedge*>::iterator it= edgeList.begin(); it!=endList; ++it)</tedge*>

  {

    w0 = (*it)->m_w0;

    w1 = (*it)->m_w1;

    if(w0

    {

      if( w0 < regId.m_midW && regId.m_midW < w1 && regId.m_direction )

        return (*it)->m_r;

    }

    else

    {

      if( w1 < regId.m_midW && regId.m_midW < w0 && !regId.m_direction )

        return (*it)->m_r;

    }

  }

  return 0;   

}

*/

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

void TVectorImage::setEdgeColors(int strokeIndex, int leftColorIndex, int rightColorIndex)

{

	std::list<tedge *=""> &ll = m_imp->m_strokes[strokeIndex]->m_edgeList;</tedge>

	std::list<tedge *="">::const_iterator l = ll.begin();</tedge>

	std::list<tedge *="">::const_iterator l_e = ll.end();</tedge>

	for (; l != l_e; ++l) {

		//double w0 = (*l)->m_w0, w1 = (*l)->m_w1;

		if ((*l)->m_w0 > (*l)->m_w1) {

			if (leftColorIndex != -1)

				(*l)->m_styleId = leftColorIndex;

			else if (rightColorIndex != -1)

				(*l)->m_styleId = rightColorIndex;

		} else {

			if (rightColorIndex != -1)

				(*l)->m_styleId = rightColorIndex;

			else if (leftColorIndex != -1)

				(*l)->m_styleId = leftColorIndex;

		}

	}

}

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

TStroke *TVectorImage::getStroke(UINT index) const

{

	assert(index < m_imp->m_strokes.size());

	return m_imp->m_strokes[index]->m_s;

}

VIStroke *TVectorImage::getVIStroke(UINT index) const

{

	assert(index < m_imp->m_strokes.size());

	return m_imp->m_strokes[index];

}

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

VIStroke *TVectorImage::getStrokeById(int id) const

{

	int n = m_imp->m_strokes.size();

	for (int i = 0; i < n; i++)

		if (m_imp->m_strokes[i]->m_s->getId() == id)

			return m_imp->m_strokes[i];

	return 0;

}

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

int TVectorImage::getStrokeIndexById(int id) const

{

	int n = m_imp->m_strokes.size();

	for (int i = 0; i < n; i++)

		if (m_imp->m_strokes[i]->m_s->getId() == id)

			return i;

	return -1;

}

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

int TVectorImage::getStrokeIndex(TStroke *stroke) const

{

	int n = m_imp->m_strokes.size();

	for (int i = 0; i < n; i++)

		if (m_imp->m_strokes[i]->m_s == stroke)

			return i;

	return -1;

}

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

TRectD TVectorImage::getBBox() const

{

	UINT strokeCount = m_imp->m_strokes.size();

	if (strokeCount == 0)

		return TRectD();

	TPalette *plt = getPalette();

	TRectD bbox;

	for (UINT i = 0; i < strokeCount; ++i) {

		TRectD r = m_imp->m_strokes[i]->m_s->getBBox();

		TColorStyle *style = 0;

		if (plt)

			style = plt->getStyle(m_imp->m_strokes[i]->m_s->getStyle());

		if (dynamic_cast<trasterimagepatternstrokestyle *="">(style) ||</trasterimagepatternstrokestyle>

			dynamic_cast<tvectorimagepatternstrokestyle *="">(style)) //con i pattern style, il render a volte taglia sulla bbox dello stroke....</tvectorimagepatternstrokestyle>

																   //aumento la bbox della meta' delle sue dimensioni:pezzaccia.

			r = r.enlarge(std::max(r.getLx() * 0.25, r.getLy() * 0.25));

		bbox = ((i == 0) ? r : bbox + r);

	}

	return bbox;

}

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

bool TVectorImage::getNearestStroke(

	const TPointD &p,

	double &outW,

	UINT &strokeIndex,

	double &dist2,

	bool onlyInCurrentGroup) const

{

	dist2 = (std::numeric_limits<double>::max)();</double>

	strokeIndex = getStrokeCount();

	outW = -1;

	double

		tempdis2,

		tempPar;

	for (int i = 0; i < (int)m_imp->m_strokes.size(); ++i) {

		if (onlyInCurrentGroup && !inCurrentGroup(i))

			continue;

		TStroke *s = m_imp->m_strokes[i]->m_s;

		tempPar = s->getW(p);

		tempdis2 = tdistance2(TThickPoint(p, 0), s->getThickPoint(tempPar));

		if (tempdis2 < dist2) {

			outW = tempPar;

			dist2 = tempdis2;

			strokeIndex = i;

		}

	}

	return dist2 < (std::numeric_limits<double>::max)();</double>

}

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

#if defined(LINUX) || defined(MACOSX)

void TVectorImage::render(const TVectorRenderData &rd, TRaster32P &ras)

{

	//hardRenderVectorImage(rd,ras,this);

}

#endif

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

//#include "timage_io.h"

TRaster32P TVectorImage::render(bool onlyStrokes)

{

	TRect bBox = convert(getBBox());

	if (bBox.isEmpty())

		return (TRaster32P)0;

	std::auto_ptr<tofflinegl> offlineGlContext(new TOfflineGL(bBox.getSize()));</tofflinegl>

	offlineGlContext->clear(TPixel32(0, 0, 0, 0));

	offlineGlContext->makeCurrent();

	TVectorRenderData rd(TTranslation(-convert(bBox.getP00())), TRect(bBox.getSize()), getPalette(), 0, true, true);

	rd.m_drawRegions = !onlyStrokes;

	offlineGlContext->draw(this, rd, false);

	return offlineGlContext->getRaster()->clone();

	//hardRenderVectorImage(rd,ras,this);

}

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

TRegion *TVectorImage::getRegion(const TPointD &p)

{

#ifndef NEW_REGION_FILL

	if (!isComputedRegionAlmostOnce())

		return 0;

	if (!m_imp->m_areValidRegions)

		m_imp->computeRegions();

#endif

	return m_imp->getRegion(p);

}

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

TRegion *TVectorImage::Imp::getRegion(const TPointD &p)

{

	int strokeIndex = (int)m_strokes.size() - 1;

	while (strokeIndex >= 0) {

		for (UINT regionIndex = 0; regionIndex < m_regions.size(); regionIndex++)

			if (areDifferentGroup(strokeIndex, false, regionIndex, true) == -1 && m_regions[regionIndex]->contains(p))

				return m_regions[regionIndex]->getRegion(p);

		int curr = strokeIndex;

		while (strokeIndex >= 0 && areDifferentGroup(curr, false, strokeIndex, false) == -1)

			strokeIndex--;

	}

	return 0;

}

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

int TVectorImage::fillStrokes(const TPointD &p, int styleId)

{

	UINT index;

	double outW, dist2;

	if (getNearestStroke(p, outW, index, dist2, true)) {

		double thick = getStroke(index)->getThickPoint(outW).thick * 1.25;

		if (thick < 0.5)

			thick = 0.5;

		if (dist2 > thick * thick)

			return -1;

		assert(index >= 0 && index < m_imp->m_strokes.size());

		int ret = m_imp->m_strokes[index]->m_s->getStyle();

		m_imp->m_strokes[index]->m_s->setStyle(styleId);

		return ret;

	}

	return -1;

}

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

#ifdef NEW_REGION_FILL

void TVectorImage::resetRegionFinder()

{

	m_imp->resetRegionFinder();

}

#else

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

int TVectorImage::fill(const TPointD &p, int newStyleId, bool onlyEmpty)

{

	TRegion *r = getRegion(p);

	if (onlyEmpty && r && r->getStyle() != 0)

		return -1;

	if (!m_imp->m_areValidRegions)

		m_imp->computeRegions();

	return m_imp->fill(p, newStyleId);

}

#endif

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

/*

void TVectorImage::autoFill(int styleId)

{

m_imp->autoFill(styleId, true);

}

void TVectorImage::Imp::autoFill(int styleId, bool oddLevel)

{

if (!m_areValidRegions)

  computeRegions(); 

for (UINT i = 0; i

  {

  if (oddLevel)

    m_regions[i]->setStyle(styleId);

  m_regions[i]->autoFill(styleId, !oddLevel);

  }

}

*/

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

/*

void TRegion::autoFill(int styleId, bool oddLevel)

{

for (UINT i = 0; i

  {

  TRegion* r = getSubregion(i);

  if (oddLevel)

    r->setStyle(styleId);

  r->autoFill(styleId, !oddLevel);

  }

}

*/

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

int TVectorImage::Imp::fill(const TPointD &p, int styleId)

{

	int strokeIndex = (int)m_strokes.size() - 1;

	while (strokeIndex >= 0) {

		if (!inCurrentGroup(strokeIndex)) {

			strokeIndex--;

			continue;

		}

		for (UINT regionIndex = 0; regionIndex < m_regions.size(); regionIndex++)

			if (areDifferentGroup(strokeIndex, false, regionIndex, true) == -1 && m_regions[regionIndex]->contains(p))

				return m_regions[regionIndex]->fill(p, styleId);

		int curr = strokeIndex;

		while (strokeIndex >= 0 && areDifferentGroup(curr, false, strokeIndex, false) == -1)

			strokeIndex--;

	}

	return -1;

}

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

bool TVectorImage::selectFill(const TRectD &selArea, TStroke *s, int newStyleId, bool onlyUnfilled, bool fillAreas, bool fillLines)

{

	if (!m_imp->m_areValidRegions)

		m_imp->computeRegions();

	return m_imp->selectFill(selArea, s, newStyleId, onlyUnfilled, fillAreas, fillLines);

}

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

bool TVectorImage::Imp::selectFill(const TRectD &selArea, TStroke *s, int newStyleId, bool onlyUnfilled, bool fillAreas, bool fillLines)

{

	bool hitSome = false;

	if (s) {

		TVectorImage aux;

		aux.addStroke(s);

		aux.findRegions();

		for (UINT j = 0; j < aux.getRegionCount(); j++) {

			TRegion *r0 = aux.getRegion(j);

			if (fillAreas)

				for (UINT i = 0; i < m_regions.size(); i++) {

					TRegion *r1 = m_regions[i];

					if (m_insideGroup != TGroupId() && !m_insideGroup.isParentOf(m_strokes[r1->getEdge(0)->m_index]->m_groupId))

						continue;

					if ((!onlyUnfilled || r1->getStyle() == 0) &&

						r0->contains(*r1)) {

						r1->setStyle(newStyleId);

						hitSome = true;

					}

				}

			if (fillLines)

				for (UINT i = 0; i < m_strokes.size(); i++) {

					if (!inCurrentGroup(i))

						continue;

					TStroke *s1 = m_strokes[i]->m_s;

					if ((!onlyUnfilled || s1->getStyle() == 0) &&

						r0->contains(*s1)) {

						s1->setStyle(newStyleId);

						hitSome = true;

					}

				}

		}

		aux.removeStroke(0);

		return hitSome;

	}

	// rect fill

	if (fillAreas)

#ifndef NEW_REGION_FILL

		for (UINT i = 0; i < m_regions.size(); i++) {

			int index, j = 0;

			do

				index = m_regions[i]->getEdge(j++)->m_index;

			while (index < 0 && j < (int)m_regions[i]->getEdgeCount());

			//if index<0, means that the region is purely of autoclose strokes!

			if (m_insideGroup != TGroupId() && index >= 0 && !m_insideGroup.isParentOf(m_strokes[index]->m_groupId))

				continue;

			if (!onlyUnfilled || m_regions[i]->getStyle() == 0)

				hitSome |= m_regions[i]->selectFill(selArea, newStyleId);

		}