#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 "tcomputeregions.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();

}

*/

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

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

}

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

static 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,</int>

                                 bool deleteThem, bool recomputeRegions) {

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

}

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

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

                                      bool deleteThem, bool recomputeRegions) {

  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;</tedge>

       ++it) {

    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) {

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

    TColorStyle *style = 0;

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

    if (!style) continue;

    // reimplemented in TRasterImagePatternStrokeStyle,

    // TVectorImagePatternStrokeStyle and FlowLineStrokeStyle

    TRectD r = style->getStrokeBBox(stroke);

    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(FREEBSD) || 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::unique_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);

    }

#else

    findRegions(selArea);

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

    if (m_insideGroup != TGroupId() &&

        !m_insideGroup.isParentOf(

            m_strokes[m_regions[i]->getEdge(0)->m_index]->m_groupId))

      continue;

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

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

  }

#endif

  if (fillLines)

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

      if (!inCurrentGroup(i)) continue;

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

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

          selArea.contains(s->getBBox())) {

        s->setStyle(newStyleId);

        hitSome = true;

      }

    }

  return hitSome;

}

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

/*

void  TVectorImageImp::seedFill()

{

  std::vector<tfillseed>::iterator it;</tfillseed>

  TRegion*r;

  TFillStyleP app =NULL;

  for (it=m_seeds.begin(); it!=m_seeds.end(); )

    if ((r=fill(it->m_p, new TColorStyle(it->m_fillStyle.getPointer()) ))!=NULL)

    {

      it->m_r = r;