// TnzTools includes

#include "tools/toolhandle.h"

#include "tools/toolutils.h"

#include "tools/tool.h"

#include "tools/cursors.h"

// TnzQt includes

#include "toonzqt/imageutils.h"

// TnzLib includes

#include "toonz/txshlevelhandle.h"

#include "toonz/tframehandle.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/txsheethandle.h"

#include "toonz/strokegenerator.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/stage2.h"

// TnzBase includes

#include "tenv.h"

// TnzCore includes

#include "tmathutil.h"

#include "tundo.h"

#include "tstroke.h"

#include "tvectorimage.h"

#include "ttoonzimage.h"

#include "tproperty.h"

#include "tgl.h"

#include "tinbetween.h"

#include "drawutil.h"

// Qt includes

#include <qcoreapplication>  // For Qt translation support</qcoreapplication>

using namespace ToolUtils;

TEnv::DoubleVar EraseVectorSize("InknpaintEraseVectorSize", 10);

TEnv::StringVar EraseVectorType("InknpaintEraseVectorType", "Normal");

TEnv::IntVar EraseVectorSelective("InknpaintEraseVectorSelective", 0);

TEnv::IntVar EraseVectorInvert("InknpaintEraseVectorInvert", 0);

TEnv::IntVar EraseVectorRange("InknpaintEraseVectorRange", 0);

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

// Eraser Tool

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

namespace {

#define NORMAL_ERASE L"Normal"

#define RECT_ERASE L"Rectangular"

#define FREEHAND_ERASE L"Freehand"

#define POLYLINE_ERASE L"Polyline"

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

const double minDistance2 = 16.0;  // 4 pixel

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

void mapToVector(const std::map<int, *="" vistroke=""> &theMap,</int,>

                 std::vector<int> &theVect) {</int>

  assert(theMap.size() == theVect.size());

  std::map<int, *="" vistroke="">::const_iterator it = theMap.begin();</int,>

  UINT i = 0;

  for (; it != theMap.end(); ++it) {

    theVect[i++] = it->first;

  }

}

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

class UndoEraser : public ToolUtils::TToolUndo {

  std::vector<tfilledregioninf> m_oldFillInformation, m_newFillInformation;</tfilledregioninf>

  int m_row;

  int m_column;

public:

  std::map<int, *="" vistroke=""> m_originalStrokes;</int,>

  std::map<int, *="" vistroke=""> m_newStrokes;</int,>

  UndoEraser(TXshSimpleLevel *level, const TFrameId &frameId)

      : ToolUtils::TToolUndo(level, frameId) {

    TVectorImageP image = level->getFrame(m_frameId, true);

    if (!image) return;

    TTool::Application *app = TTool::getApplication();

    if (app) {

      m_row    = app->getCurrentFrame()->getFrame();

      m_column = app->getCurrentColumn()->getColumnIndex();

    }

    ImageUtils::getFillingInformationInArea(image, m_oldFillInformation,

                                            image->getBBox());

  }

  void onAdd() {

    TVectorImageP image = m_level->getFrame(m_frameId, true);

    assert(!!image);

    if (!image) return;

    ImageUtils::getFillingInformationInArea(image, m_newFillInformation,

                                            image->getBBox());

  }

  ~UndoEraser() {

    std::map<int, *="" vistroke="">::const_iterator it;</int,>

    for (it = m_originalStrokes.begin(); it != m_originalStrokes.end(); ++it)

      deleteVIStroke(it->second);

    for (it = m_newStrokes.begin(); it != m_newStrokes.end(); ++it)

      deleteVIStroke(it->second);

  }

  void addOldStroke(int index, VIStroke *stroke) {

    VIStroke *s = cloneVIStroke(stroke);

    m_originalStrokes.insert(std::map<int, *="" vistroke="">::value_type(index, s));</int,>

  }

  void addNewStroke(int index, VIStroke *stroke) {

    VIStroke *s = cloneVIStroke(stroke);

    m_newStrokes.insert(std::map<int, *="" vistroke="">::value_type(index, s));</int,>

  }

  void undo() const {

    TTool::Application *app = TTool::getApplication();

    if (!app) return;

    TFrameId currentFid;

    if (app->getCurrentFrame()->isEditingScene()) {

      app->getCurrentColumn()->setColumnIndex(m_column);

      app->getCurrentFrame()->setFrame(m_row);

      currentFid = TFrameId(m_row + 1);

    } else {

      app->getCurrentFrame()->setFid(m_frameId);

      currentFid = m_frameId;

    }

    TVectorImageP image = m_level->getFrame(m_frameId, true);

    assert(image);

    if (!image) return;

    QMutexLocker lock(image->getMutex());

    std::vector<int> newStrokeIndex(m_newStrokes.size());</int>

    mapToVector(m_newStrokes, newStrokeIndex);

    image->removeStrokes(newStrokeIndex, true, false);

    std::map<int, *="" vistroke="">::const_iterator it = m_originalStrokes.begin();</int,>

    UINT i = 0;

    VIStroke *s;

    for (; it != m_originalStrokes.end(); ++it) {

      s = cloneVIStroke(it->second);

      image->insertStrokeAt(s, it->first);

    }

    if (image->isComputedRegionAlmostOnce())

      image->findRegions();  // in futuro togliere. Serve perche' la

                             // removeStrokes, se gli si dice

    // di non calcolare le regioni, e' piu' veloce ma poi chrash tutto

    UINT size = m_oldFillInformation.size();

    if (!size) {

      app->getCurrentXsheet()->notifyXsheetChanged();

      notifyImageChanged();

      return;

    }

    TRegion *reg;

    i = 0;

    for (; i < size; i++) {

      reg = image->getRegion(m_oldFillInformation[i].m_regionId);

      assert(reg);

      if (reg) reg->setStyle(m_oldFillInformation[i].m_styleId);

    }

    app->getCurrentXsheet()->notifyXsheetChanged();

    notifyImageChanged();

  }

  void redo() const {

    TTool::Application *app = TTool::getApplication();

    if (!app) return;

    TFrameId currentFid;

    if (app->getCurrentFrame()->isEditingScene()) {

      app->getCurrentColumn()->setColumnIndex(m_column);

      app->getCurrentFrame()->setFrame(m_row);

      currentFid = TFrameId(m_row + 1);

    } else {

      app->getCurrentFrame()->setFid(m_frameId);

      currentFid = m_frameId;

    }

    TVectorImageP image = m_level->getFrame(m_frameId, true);

    assert(image);

    if (!image) return;

    QMutexLocker lock(image->getMutex());

    std::vector<int> oldStrokeIndex(m_originalStrokes.size());</int>

    mapToVector(m_originalStrokes, oldStrokeIndex);

    image->removeStrokes(oldStrokeIndex, true, false);

    std::map<int, *="" vistroke="">::const_iterator it = m_newStrokes.begin();</int,>

    UINT i = 0;

    VIStroke *s;

    for (; it != m_newStrokes.end(); ++it) {

      s = cloneVIStroke(it->second);

      image->insertStrokeAt(s, it->first);

    }

    if (image->isComputedRegionAlmostOnce())

      image->findRegions();  // in futuro togliere. Serve perche' la

                             // removeStrokes, se gli si dice

    // di non calcolare le regioni, e' piu' veloce ma poi chrash tutto

    UINT size = m_newFillInformation.size();

    if (!size) {

      app->getCurrentXsheet()->notifyXsheetChanged();

      notifyImageChanged();

      return;

    }

    TRegion *reg;

    i = 0;

    for (; i < size; i++) {

      reg = image->getRegion(m_newFillInformation[i].m_regionId);

      assert(reg);

      if (reg) reg->setStyle(m_newFillInformation[i].m_styleId);

    }

    app->getCurrentXsheet()->notifyXsheetChanged();

    notifyImageChanged();

  }

  int getSize() const {

    return sizeof(*this) +

           (m_oldFillInformation.capacity() + m_newFillInformation.capacity()) *

               sizeof(TFilledRegionInf) +

           500;

  }

  QString getToolName() { return QString("Vector Eraser Tool"); }

  int getHistoryType() { return HistoryType::EraserTool; }

};

}  // namespace

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

//  EraserTool class declaration

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

class EraserTool : public TTool {

  Q_DECLARE_TR_FUNCTIONS(EraserTool)

public:

  EraserTool();

  ~EraserTool();

  ToolType getToolType() const { return TTool::LevelWriteTool; }

  void draw();

  void startErase(

      TVectorImageP vi,

      const TPointD &pos);  //, const TImageLocation &imageLocation);

  void erase(TVectorImageP vi, const TPointD &pos);

  void erase(TVectorImageP vi,

             TRectD &rect);  //, const TImageLocation &imageLocation);

  void stopErase(TVectorImageP vi);

  void leftButtonDown(const TPointD &pos, const TMouseEvent &e);

  void leftButtonDrag(const TPointD &pos, const TMouseEvent &e);

  void leftButtonUp(const TPointD &pos, const TMouseEvent &);

  void leftButtonDoubleClick(const TPointD &pos, const TMouseEvent &e);

  void mouseMove(const TPointD &pos, const TMouseEvent &e);

  bool onPropertyChanged(std::string propertyName);

  void onEnter();

  void onLeave();

  void onActivate();

  TPropertyGroup *getProperties(int targetType) { return &m_prop; }

  int getCursorId() const { return ToolCursor::EraserCursor; }

  void onImageChanged();

  /*-- ドラッグ中にツールが切り替わった場合、Eraseの終了処理を行う --*/

  void onDeactivate();

private:

  TPropertyGroup m_prop;

  TEnumProperty m_eraseType;

  TDoubleProperty m_toolSize;

  TBoolProperty m_selective;

  TBoolProperty m_invertOption;

  TBoolProperty m_multi;

  double m_pointSize, m_distance2;

  TPointD m_mousePos,  //!< Current mouse position.

      m_oldMousePos,   //!< Previous mouse position.

      m_brushPos,      //!< Position the brush will be painted at.

      m_firstPos;      //!< Either The first point inserted either in m_track or

                       //!m_polyline

                       //!  (depending on selected erase mode).

  UndoEraser *m_undo;

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

  TRectD m_selectingRect, m_firstRect;

  TFrameId m_firstFrameId, m_veryFirstFrameId;

  TXshSimpleLevelP m_level;

  std::pair<int, int=""> m_currCell;</int,>

  StrokeGenerator m_track;  //!< Lazo selection generator.

  std::vector<tpointd> m_polyline;  //!< Polyline points.</tpointd>

  TStroke *m_stroke;  //!< Stores the stroke generated by m_track.

  TStroke

      *m_firstStroke;  //!< Stores the first stroke in the "frame range" case.

  double m_thick;

  bool m_firstTime, m_active, m_firstFrameSelected;

private:

  void resetMulti();

  void updateTranslation();

  // Metodi per disegnare la linea della modalita' Freehand

  void startFreehand(const TPointD &pos);

  void freehandDrag(const TPointD &pos);

  void closeFreehand(const TPointD &pos);

  // Metodi per disegnare la linea della modalita' Polyline

  void addPointPolyline(const TPointD &pos);

  void closePolyline(const TPointD &pos);

  void eraseRegion(const TVectorImageP vi, TStroke *stroke);

  void multiEraseRect(TFrameId firstFrameId, TFrameId lastFrameId,

                      TRectD firstRect, TRectD lastRect, bool invert);

  void doMultiErase(TFrameId &firstFrameId, TFrameId &lastFrameId,

                    const TStroke *firstStroke, const TStroke *lastStroke);

  void doErase(double t, const TXshSimpleLevelP &sl, const TFrameId &fid,

               const TVectorImageP &firstImage, const TVectorImageP &lastImage);

  void multiEreserRegion(TStroke *stroke, const TMouseEvent &e);

} eraserTool;

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

//  EraserTool implemention

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

EraserTool::EraserTool()

    : TTool("T_Eraser")

    , m_eraseType("Type:")             // "W_ToolOptions_Erasetype"

    , m_toolSize("Size:", 1, 100, 10)  // "W_ToolOptions_EraserToolSize"

    , m_selective("Selective", false)  // "W_ToolOptions_Selective"

    , m_invertOption("Invert", false)  // "W_ToolOptions_Invert"

    , m_multi("Frame Range", false)    // "W_ToolOptions_FrameRange"

    , m_pointSize(-1)

    , m_undo(0)

    , m_currCell(-1, -1)

    , m_stroke(0)

    , m_thick(5)

    , m_active(false)

    , m_firstTime(true) {

  bind(TTool::VectorImage);

  m_prop.bind(m_toolSize);

  m_prop.bind(m_eraseType);

  m_eraseType.addValue(NORMAL_ERASE);

  m_eraseType.addValue(RECT_ERASE);

  m_eraseType.addValue(FREEHAND_ERASE);

  m_eraseType.addValue(POLYLINE_ERASE);

  m_prop.bind(m_selective);

  m_prop.bind(m_invertOption);

  m_prop.bind(m_multi);

  m_selective.setId("Selective");

  m_invertOption.setId("Invert");

  m_multi.setId("FrameRange");

  m_eraseType.setId("Type");

}

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

EraserTool::~EraserTool() {

  if (m_stroke) delete m_stroke;

  if (m_firstStroke) delete m_firstStroke;

}

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

void EraserTool::updateTranslation() {

  m_toolSize.setQStringName(tr("Size:"));

  m_selective.setQStringName(tr("Selective"));

  m_invertOption.setQStringName(tr("Invert"));

  m_multi.setQStringName(tr("Frame Range"));

  m_eraseType.setQStringName(tr("Type:"));

}

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

void EraserTool::draw() {

  if (m_pointSize <= 0) return;

  double pixelSize2 = getPixelSize() * getPixelSize();

  m_thick           = pixelSize2 / 2.0;

  TImageP image(getImage(false));

  TVectorImageP vi = image;

  if (vi) {

    bool blackBg = ToonzCheck::instance()->getChecks() & ToonzCheck::eBlackBg;

    if (m_eraseType.getValue() == RECT_ERASE) {

      TPixel color = blackBg ? TPixel32::White : TPixel32::Black;

      if (m_multi.getValue() && m_firstFrameSelected)

        drawRect(m_firstRect, color, 0x3F33, true);

      if (m_active || (m_multi.getValue() && !m_firstFrameSelected))

        drawRect(m_selectingRect, color, 0x3F33, true);

    }

    if (m_eraseType.getValue() == NORMAL_ERASE) {

      tglColor(TPixel32(255, 0, 255));

      tglDrawCircle(m_brushPos, m_pointSize);

    }

    if ((m_eraseType.getValue() == FREEHAND_ERASE ||

         m_eraseType.getValue() == POLYLINE_ERASE) &&

        m_multi.getValue()) {

      TPixel color = blackBg ? TPixel32::White : TPixel32::Black;

      tglColor(color);

      if (m_firstStroke) drawStrokeCenterline(*m_firstStroke, 1);

    }

    if (m_eraseType.getValue() == POLYLINE_ERASE && !m_polyline.empty()) {

      TPixel color = blackBg ? TPixel32::White : TPixel32::Black;

      tglColor(color);

      tglDrawCircle(m_polyline[0], 2);

      glBegin(GL_LINE_STRIP);

      for (UINT i = 0; i < m_polyline.size(); i++) tglVertex(m_polyline[i]);

      tglVertex(m_mousePos);

      glEnd();

    }

  }

}

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

void EraserTool::resetMulti() {

  m_firstFrameSelected = false;

  m_firstRect.empty();

  m_selectingRect.empty();

  TTool::Application *application = TTool::getApplication();

  if (!application) return;

  m_firstFrameId = m_veryFirstFrameId = getCurrentFid();

  m_level = application->getCurrentLevel()->getLevel()

                ? application->getCurrentLevel()->getLevel()->getSimpleLevel()

                : 0;

  if (m_firstStroke) {

    delete m_firstStroke;

    m_firstStroke = 0;

  }

}

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

void EraserTool::startErase(

    TVectorImageP vi,

    const TPointD &pos)  //, const TImageLocation &imageLocation)

{

  UINT size = vi->getStrokeCount();

  m_indexes.resize(size);

  for (UINT i = 0; i < size; i++) m_indexes[i] = i;

  assert(m_undo == 0);

  delete m_undo;

  TXshSimpleLevel *level =

      TTool::getApplication()->getCurrentLevel()->getSimpleLevel();

  m_undo        = new UndoEraser(level, getCurrentFid());

  m_oldMousePos = pos;

  m_distance2   = minDistance2 * getPixelSize() * getPixelSize();

  erase(vi, pos);

}

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

void EraserTool::erase(TVectorImageP vi, const TPointD &pos) {

  std::vector<int>::iterator it = m_indexes.begin();</int>

  m_distance2 += tdistance2(m_oldMousePos, pos);

  if (m_distance2 < minDistance2 * getPixelSize() * getPixelSize()) return;

  m_distance2   = 0;

  m_oldMousePos = pos;

  // quadrato circoscritto alla circonferenza

  TRectD circumscribedSquare(pos.x - m_pointSize, pos.y - m_pointSize,

                             pos.x + m_pointSize, pos.y + m_pointSize);

  if (!circumscribedSquare.overlaps(vi->getBBox())) {

    invalidate();

    return;

  }

  std::vector<double> intersections;</double>

  std::vector<doublepair> sortedWRanges;</doublepair>

  std::vector<tstroke *=""> splitStrokes;</tstroke>

  double rectEdge_2 = m_pointSize * M_SQRT1_2;

  // quadrato iscritto nella circonferenza

  TRectD enrolledSquare(pos.x - rectEdge_2, pos.y - rectEdge_2,

                        pos.x + rectEdge_2, pos.y + rectEdge_2);

  UINT i            = 0;

  double pointSize2 = sq(m_pointSize);

  std::vector<int> oneStrokeIndex(1);</int>

  int index = TTool::getApplication()->getCurrentLevelStyleIndex();

  QMutexLocker lock(vi->getMutex());

  while (i < vi->getStrokeCount()) {

    assert(it != m_indexes.end());

    TStroke *oldStroke = vi->getStroke(i);

    if (!vi->inCurrentGroup(i) ||

        (m_selective.getValue() && oldStroke->getStyle() != index)) {

      i++;

      it++;

      continue;

    }

    TRectD strokeBBox = oldStroke->getBBox();

    if (!circumscribedSquare.overlaps(strokeBBox)) {  // stroke all'esterno del

                                                      // quadrato circoscritto

                                                      // alla circonferenxa

      i++;

      it++;

      continue;

    }

    if (enrolledSquare.contains(strokeBBox)) {  // stroke tutta contenuta nel

                                                // quadrato iscritto nella

                                                // circonferenza

      if (*it != -1) m_undo->addOldStroke(*it, vi->getVIStroke(i));

      oneStrokeIndex[0] = i;

      vi->removeStrokes(oneStrokeIndex, true, true);

      it = m_indexes.erase(it);

      continue;

    }

    splitStrokes.clear();

    intersections.clear();

    /*int intersNum=*/intersect(*oldStroke, pos, m_pointSize, intersections);

    /*

#ifdef _DEBUG

if(intersections.size()==2 && intersections[0]==intersections[1])

{

intersections.clear();

intersect( *oldStroke, pos, m_pointSize, intersections );

}

#endif

*/

    if (intersections.empty()) {

      // BASTEREBBE CONTROLLARE UN SOLO PUNTO PERCHE' SE LA

      // STROKE NON INTERSECA IL CERCHIO E CONTENTIENE ALMENO

      // UN PUNTO, LA CONTIENE TUTTA. MA SICCOME NON MI FIDO

      // DELLA INTERSECT, NE CONTROLLO UN PAIO E AVVANTAGGIO (CON L' AND)

      // IL NON CONTENIMENTO, DATO CHE E' MEGLIO CANCELLARE UNA COSA IN

      // MENO, CHE UNA IN PIU'

      if (tdistance2(oldStroke->getPoint(0), pos) < pointSize2 &&

          tdistance2(oldStroke->getPoint(1), pos) <

              pointSize2) {  // stroke tutta contenuta nella circonferenxa

        if (*it != -1) m_undo->addOldStroke(*it, vi->getVIStroke(i));

        oneStrokeIndex[0] = i;

        vi->removeStrokes(oneStrokeIndex, true, true);

        it = m_indexes.erase(it);

      } else {  // non colpita

        i++;

        it++;

      }

      continue;

    }

    //------------------------ almeno un'intersezione

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

    if (intersections.size() == 1) {

      if (oldStroke->isSelfLoop()) {  // una sola intersezione di una stroke

                                      // chiusa con un cerchio dovrebbe accadere

        // solo in caso di sfioramento, quindi faccio finta di nulla

        i++;

        it++;

        continue;

      }

      if (*it != -1) m_undo->addOldStroke(*it, vi->getVIStroke(i));

      double w0            = intersections[0];

      TThickPoint hitPoint = oldStroke->getThickPoint(w0);

      int chunck;

      double t;

      oldStroke->getChunkAndT(w0, chunck, t);

      int chunckIndex;

      double w1;

      if (tdistance2(oldStroke->getPoint(0), pos) < pointSize2) {

        chunckIndex = oldStroke->getChunkCount() - 1;

        w1          = 1;

      } else {

        chunckIndex = 0;

        w1          = 0;

      }

      UINT cI;

      std::vector<tthickpoint> points;</tthickpoint>

      if (w1 == 0) {

        for (cI = chunckIndex; cI < (UINT)chunck; cI++) {

          points.push_back(oldStroke->getChunk(cI)->getThickP0());

          points.push_back(oldStroke->getChunk(cI)->getThickP1());

        }

        TThickQuadratic t1, t2;

        oldStroke->getChunk(chunck)->split(t, t1, t2);

        points.push_back(t1.getThickP0());

        points.push_back(t1.getThickP1());

        points.push_back(hitPoint);

      } else {

        TThickQuadratic t1, t2;

        oldStroke->getChunk(chunck)->split(t, t1, t2);

        points.push_back(hitPoint);

        points.push_back(t2.getThickP1());

        points.push_back(t2.getThickP2());

        for (cI = chunck + 1; cI <= (UINT)chunckIndex; cI++) {

          points.push_back(oldStroke->getChunk(cI)->getThickP1());

          points.push_back(oldStroke->getChunk(cI)->getThickP2());

        }

      }

      oldStroke->reshape(&(points[0]), points.size());

      vi->notifyChangedStrokes(i);  // per adesso cosi', pero' e' lento

      *it = -1;

      i++;

      it++;

      continue;

    }

    //---------- piu'

    //intersezioni--------------------------------------------------------

    if (intersections.size() & 1 &&

        oldStroke->isSelfLoop()) {  // non dovrebbe mai accadere

      assert(0);

      i++;

      it++;

      continue;

    }

    if (intersections.size() == 2 &&

        intersections[0] == intersections[1]) {  // solo sfiorata

      i++;

      it++;

      continue;

    }

    UINT oldStrokeSize = vi->getStrokeCount();

    if (*it != -1) m_undo->addOldStroke(*it, vi->getVIStroke(i));

    sortedWRanges.clear();

    if (tdistance2(vi->getStroke(i)->getPoint(0), pos) > pointSize2) {

      if (intersections[0] == 0.0)

        intersections.erase(intersections.begin());

      else

        intersections.insert(intersections.begin(), 0.0);

    }

    if (intersections[0] != 1.0) intersections.push_back(1.0);

    sortedWRanges.reserve(intersections.size() / 2);

    for (UINT j = 0; j < intersections.size() - 1; j += 2)

      sortedWRanges.push_back(

          std::make_pair(intersections[j], intersections[j + 1]));

#ifdef _DEBUG

    for (UINT kkk = 0; kkk < sortedWRanges.size() - 1; kkk++) {

      assert(sortedWRanges[kkk].first < sortedWRanges[kkk].second);

      assert(sortedWRanges[kkk].second <= sortedWRanges[kkk + 1].first);

    }

    assert(sortedWRanges.back().first < sortedWRanges.back().second);

#endif

    vi->splitStroke(i, sortedWRanges);

    UINT addedStroke = vi->getStrokeCount() -

                       (oldStrokeSize - 1);  //-1 perche' e' quella tolta

    i += addedStroke;

    *it = -1;

    m_indexes.insert(it, addedStroke - 1, -1);

    it = m_indexes.begin() + i;

  }

  invalidate();

}

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

void EraserTool::erase(TVectorImageP vi, TRectD &rect) {

  if (rect.x0 > rect.x1) tswap(rect.x1, rect.x0);

  if (rect.y0 > rect.y1) tswap(rect.y1, rect.y0);

  int i     = 0;

  int index = TTool::getApplication()->getCurrentLevelStyleIndex();

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

  TXshSimpleLevel *level =

      TTool::getApplication()->getCurrentLevel()->getSimpleLevel();

  m_undo = new UndoEraser(level, getCurrentFid());

  for (i = 0; i < (int)vi->getStrokeCount(); i++) {

    if (!vi->inCurrentGroup(i)) continue;

    TStroke *stroke = vi->getStroke(i);

    if (!m_invertOption.getValue()) {

      if ((!m_selective.getValue() || stroke->getStyle() == index) &&

          rect.contains(stroke->getBBox())) {

        m_undo->addOldStroke(i, vi->getVIStroke(i));

        eraseStrokes.push_back(i);

      }

    } else {

      if ((!m_selective.getValue() || stroke->getStyle() == index) &&

          !rect.contains(stroke->getBBox())) {

        m_undo->addOldStroke(i, vi->getVIStroke(i));

        eraseStrokes.push_back(i);

      }

    }

  }

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

    vi->deleteStroke(eraseStrokes[i]);

  TUndoManager::manager()->add(m_undo);

  m_undo = 0;

  invalidate();

}

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

void EraserTool::stopErase(TVectorImageP vi) {

  assert(m_undo != 0);

  UINT size = m_indexes.size();

  assert(size == vi->getStrokeCount());

  UINT i = 0;

  for (; i < size; i++) {

    if (m_indexes[i] == -1) m_undo->addNewStroke(i, vi->getVIStroke(i));

  }

  TUndoManager::manager()->add(m_undo);

  m_undo = 0;

  invalidate();

  notifyImageChanged();

}

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

void EraserTool::leftButtonDown(const TPointD &pos, const TMouseEvent &e) {

  m_brushPos = m_mousePos = pos;

  m_active = true;

  TImageP image(getImage(true));

  if (m_eraseType.getValue() == NORMAL_ERASE) {

    if (TVectorImageP vi = image) startErase(vi, pos /*,imageLocation*/);

  } else if (m_eraseType.getValue() == RECT_ERASE) {

    m_selectingRect.x0 = pos.x;

    m_selectingRect.y0 = pos.y;

    m_selectingRect.x1 = pos.x + 1;

    m_selectingRect.y1 = pos.y + 1;

    invalidate();

  } else if (m_eraseType.getValue() == FREEHAND_ERASE) {

    startFreehand(pos);

  } else if (m_eraseType.getValue() == POLYLINE_ERASE) {

    addPointPolyline(pos);

  }

}

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

void EraserTool::leftButtonDrag(const TPointD &pos, const TMouseEvent &e) {

  m_brushPos = m_mousePos = pos;

  if (!m_active) return;

  TImageP image(getImage(true));

  if (m_eraseType.getValue() == RECT_ERASE) {

    m_selectingRect.x1 = pos.x;

    m_selectingRect.y1 = pos.y;

    invalidate();

    return;

  } else if (m_eraseType.getValue() == NORMAL_ERASE) {

    if (TVectorImageP vi = image) erase(vi, pos);

  } else if (m_eraseType.getValue() == FREEHAND_ERASE) {

    freehandDrag(pos);

  }

}

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

void EraserTool::multiEraseRect(TFrameId firstFrameId, TFrameId lastFrameId,

                                TRectD firstRect, TRectD lastRect,

                                bool invert) {

  int r0 = firstFrameId.getNumber();

  int r1 = lastFrameId.getNumber();

  if (r0 > r1) {

    tswap(r0, r1);

    tswap(firstFrameId, lastFrameId);

    tswap(firstRect, lastRect);

  }

  if ((r1 - r0) < 1) return;

  std::vector<tframeid> allFids;</tframeid>

  m_level->getFids(allFids);

  std::vector<tframeid>::iterator i0 = allFids.begin();</tframeid>

  while (i0 != allFids.end() && *i0 < firstFrameId) i0++;

  if (i0 == allFids.end()) return;

  std::vector<tframeid>::iterator i1 = i0;</tframeid>

  while (i1 != allFids.end() && *i1 <= lastFrameId) i1++;

  assert(i0 < i1);

  std::vector<tframeid> fids(i0, i1);</tframeid>

  int m = fids.size();

  assert(m > 0);

  TUndoManager::manager()->beginBlock();

  for (int i = 0; i < m; ++i) {

    TFrameId fid = fids[i];

    assert(firstFrameId <= fid && fid <= lastFrameId);

    TVectorImageP img = (TVectorImageP)m_level->getFrame(fid, true);

    assert(img);

    double t    = m > 1 ? (double)i / (double)(m - 1) : 0.5;

    TRectD rect = interpolateRect(firstRect, lastRect, t);

    // m_level->setFrame(fid, img); //necessario: se la getFrame ha scompattato

    // una img compressa, senza setFrame le modifiche sulla img fatte qui

    // andrebbero perse.

    // Setto fid come corrente per notificare il cambiamento dell'immagine

    TTool::Application *app = TTool::getApplication();

    if (app) {

      if (app->getCurrentFrame()->isEditingScene())

        app->getCurrentFrame()->setFrame(fid.getNumber() - 1);

      else

        app->getCurrentFrame()->setFid(fid);

    }

    erase(img, rect);

    notifyImageChanged();

  }

  TUndoManager::manager()->endBlock();

}

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

void EraserTool::onImageChanged() {

  if (!m_multi.getValue()) return;