#include "tools/toolutils.h"

#include "tools/toolhandle.h"

#include "toonzqt/imageutils.h"

#include "trop.h"

#include "tools/tool.h"

#include "tstroke.h"

#include "timageinfo.h"

#include "timagecache.h"

#include "tgl.h"

#include "toonz/txsheethandle.h"

#include "toonz/tframehandle.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/tscenehandle.h"

#include "toonz/txshleveltypes.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/tpalettehandle.h"

#include "toonz/txshlevel.h"

#include "toonz/txshcell.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/imagemanager.h"

#include "toonz/ttileset.h"

#include "toonz/toonzimageutils.h"

#include "toonz/levelproperties.h"

#include "toonz/tstageobjectspline.h"

#include "toonz/tobjecthandle.h"

#include "toonz/tstageobject.h"

#include "toonz/trasterimageutils.h"

#include "toonz/levelset.h"

#include "toonz/toonzscene.h"

#include "toonz/preferences.h"

#include "toonz/palettecontroller.h"

#include "toonz/txshchildlevel.h"

#include "toonzqt/tselectionhandle.h"

#include "toonzqt/icongenerator.h"

#include "toonzqt/selection.h"

#include "toonzqt/gutil.h"

#include "tools/strokeselection.h"

#include <qpainter></qpainter>

#include <qpainterpath></qpainterpath>

#include <qglwidget>  // for QGLWidget::convertToGLFormat</qglwidget>

#include <qfont></qfont>

#include <qfontmetrics></qfontmetrics>

//****************************************************************************************

//    Local namespace

//****************************************************************************************

namespace {

//! Riempie il vettore \b theVect con gli indici degli stroke contenuti nel

//! mapping \b theMap.

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;

  }

}

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

void updateSaveBox(const TToonzImageP &ti) {

  if (ti) {

    assert(ti->getRaster());            // Image should have a raster

    assert(ti->getSubsampling() == 1);  // Image should not be subsampled -

                                        // modified images must be the ORIGINAL

                                        // ones

    const TRect &savebox = ti->getSavebox();

    {

      TRect newSaveBox;

      TRop::computeBBox(ti->getRaster(), newSaveBox);  // This iterates the

                                                       // WHOLE raster to find

                                                       // its new savebox!

      if (!Preferences::instance()->isMinimizeSaveboxAfterEditing())

        newSaveBox +=

            savebox;  // If not minimizing the savebox, it cannot be shrunk.

      ti->setSavebox(newSaveBox);

    }

  }

}

}  // namespace

//****************************************************************************************

//    ToolUtils namespace

//****************************************************************************************

void ToolUtils::updateSaveBox(const TXshSimpleLevelP &sl, const TFrameId &fid) {

  // TODO: Savebox updates should not happen on mouse updates. This is,

  // unfortunately, what currently happens.

  sl->setDirtyFlag(true);

  TImageP img = sl->getFrame(fid, true);  // The image will be modified (it

                                          // should already have been, though)

  if (!img) return;

  // Observe that the returned image will forcedly have subsampling 1

  ::updateSaveBox(img);

  TImageInfo *info = sl->getFrameInfo(fid, true);

  ImageBuilder::setImageInfo(*info, img.getPointer());

}

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

void ToolUtils::updateSaveBox(const TXshSimpleLevelP &sl, const TFrameId &fid,

                              TImageP img) {

  sl->setFrame(fid, img);

  ToolUtils::updateSaveBox(sl, fid);

}

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

void ToolUtils::updateSaveBox() {

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

  if (!application) return;

  TXshLevel *xl = application->getCurrentLevel()->getLevel();

  if (!xl) return;

  TXshSimpleLevel *sl = xl->getSimpleLevel();

  if (!sl || sl->getType() != TZP_XSHLEVEL) return;

  TFrameId fid = getFrameId();

  ToolUtils::updateSaveBox(sl, fid);

}

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

//! Return the right value in both case: LevelFrame and SceneFrame.

TFrameId ToolUtils::getFrameId() {

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

  if (!app) return TFrameId();

  TFrameHandle *frameHandle = app->getCurrentFrame();

  if (frameHandle->isEditingScene()) {

    TXsheet *xsh = app->getCurrentXsheet()->getXsheet();

    if (!xsh) return 0;

    int row = frameHandle->getFrame();

    int col = app->getCurrentColumn()->getColumnIndex();

    if (col < 0) return 0;

    TXshCell cell = xsh->getCell(row, col);

    return cell.getFrameId();

  } else

    return frameHandle->getFid();

}

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

void ToolUtils::drawRect(const TRectD &rect, const TPixel32 &color,

                         unsigned short stipple, bool doContrast) {

  GLint src, dst;

  bool isEnabled;

  tglColor(color);

  if (doContrast) {

    if (color == TPixel32::Black) tglColor(TPixel32(90, 90, 90));

    isEnabled = glIsEnabled(GL_BLEND);

    glGetIntegerv(GL_BLEND_SRC, &src);

    glGetIntegerv(GL_BLEND_DST, &dst);

    glEnable(GL_BLEND);

    glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA);

  }

  if (stipple != 0xffff) {

    glLineStipple(1, stipple);

    glEnable(GL_LINE_STIPPLE);

  }

  glBegin(GL_LINE_STRIP);

  tglVertex(rect.getP00());

  tglVertex(rect.getP01());

  tglVertex(rect.getP11());

  tglVertex(rect.getP10());

  tglVertex(rect.getP00());

  glEnd();

  glDisable(GL_LINE_STIPPLE);

  if (doContrast) {

    if (!isEnabled) glDisable(GL_BLEND);

    glBlendFunc(src, dst);

  }

}

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

void ToolUtils::fillRect(const TRectD &rect, const TPixel32 &color) {

  tglColor(color);

  glBegin(GL_QUADS);

  tglVertex(rect.getP00());

  tglVertex(rect.getP01());

  tglVertex(rect.getP11());

  tglVertex(rect.getP10());

  tglVertex(rect.getP00());

  glEnd();

}

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

void ToolUtils::drawPoint(const TPointD &q, double pixelSize) {

  double size = pixelSize * 2.0;

  glBegin(GL_QUADS);

  glVertex2d(q.x - size, q.y - size);

  glVertex2d(q.x - size, q.y + size);

  glVertex2d(q.x + size, q.y + size);

  glVertex2d(q.x + size, q.y - size);

  glEnd();

}

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

void ToolUtils::drawCross(const TPointD &q, double pixelSize) {

  double size = pixelSize;

  glBegin(GL_LINES);

  glVertex2d(q.x - size, q.y);

  glVertex2d(q.x + size, q.y);

  glEnd();

  glBegin(GL_LINES);

  glVertex2d(q.x, q.y - size);

  glVertex2d(q.x, q.y + size);

  glEnd();

}

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

void ToolUtils::drawArrow(const TSegment &s, double pixelSize) {

  TPointD v, vn;

  double length = s.getLength() * pixelSize;

  if (length == 0) return;

  v  = normalize(s.getSpeed());

  vn = v;

  TPointD p1 = s.getP0() + v * length;

  glBegin(GL_LINES);

  tglVertex(s.getP0());

  tglVertex(p1);

  glEnd();

  v = v * length * 0.7;

  vn = vn * length * 0.2;

  TPointD p;

  glBegin(GL_TRIANGLES);

  p = s.getP0() + v + rotate90(vn);

  tglVertex(p);

  tglVertex(p1);

  p = s.getP0() + v + rotate270(vn);

  tglVertex(p);

  glEnd();

}

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

void ToolUtils::drawSquare(const TPointD &pos, double r,

                           const TPixel32 &color) {

  TRectD rect(pos - TPointD(r, r), pos + TPointD(r, r));

  tglColor(color);

  glBegin(GL_LINE_STRIP);

  tglVertex(rect.getP00());

  tglVertex(rect.getP01());

  tglVertex(rect.getP11());

  tglVertex(rect.getP10());

  tglVertex(rect.getP00());

  glEnd();

}

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

void ToolUtils::drawRectWhitArrow(const TPointD &pos, double r) {

  if (TTool::getApplication()->getCurrentObject()->isSpline()) return;

  TRectD rect(pos - TPointD(14 * r, 2 * r), pos + TPointD(14 * r, 2 * r));

  tglColor(TPixel32::Black);

  glBegin(GL_POLYGON);

  tglVertex(rect.getP00());

  tglVertex(rect.getP10());

  tglVertex(rect.getP11());

  tglVertex(rect.getP01());

  glEnd();

  double par = 5 * r;

  TPointD p01 = 0.5 * (rect.getP00() + rect.getP10());

  TPointD p02 = 0.5 * (rect.getP01() + rect.getP11());

  TPointD p11 = TPointD(p01.x, p01.y - par);

  TPointD p12 = TPointD(p02.x, p02.y + par);

  TPointD p;

  tglColor(TPixel32(130, 130, 130));

  glBegin(GL_TRIANGLES);

  p = p11 + rotate90(TPointD(0, par));

  tglVertex(p);

  tglVertex(p01);

  p = p11 + rotate270(TPointD(0, par));

  tglVertex(p);

  glEnd();

  glBegin(GL_TRIANGLES);

  p = p12 + rotate90(TPointD(0, -par));

  tglVertex(p);

  tglVertex(p02);

  p = p12 + rotate270(TPointD(0, -par));

  tglVertex(p);

  glEnd();

}

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

QRadialGradient ToolUtils::getBrushPad(int size, double hardness) {

  hardness        = tcrop(hardness, 0.0, 0.97);

  double halfSize = size * 0.5;

  double x        = halfSize * hardness;

  TQuadratic q(TPointD(x, 1.0), TPointD((halfSize + x) * 0.5, 0.0),

               TPointD(halfSize, 0.0));

  QRadialGradient rd(QPointF(halfSize, halfSize), halfSize,

                     QPointF(halfSize, halfSize));

  rd.setColorAt(0, QColor(0, 0, 0));

  double t;

  double offset = halfSize - x;

  assert(offset > 0);

  for (t = 0; t <= 1; t += 1.0 / offset) {

    TPointD p = q.getPoint(t);

    int value = 255 * p.y;

    rd.setColorAt(p.x / halfSize, QColor(0, 0, 0, value));

  }

  return rd;

}

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

QList<trect> ToolUtils::splitRect(const TRect &first, const TRect &second) {</trect>

  TRect intersection = first * second;

  QList<trect> rects;</trect>

  if (intersection.isEmpty()) {

    rects.append(first);

    return rects;

  }

  TRect rect;

  if (first.x0 < intersection.x0) {

    rect = TRect(first.getP00(), TPoint(intersection.x0 - 1, first.y1));

    rects.append(rect);

  }

  if (intersection.x1 < first.x1) {

    rect = TRect(TPoint(intersection.x1 + 1, first.y0), first.getP11());

    rects.append(rect);

  }

  if (intersection.y1 < first.y1) {

    rect =

        TRect(intersection.x0, intersection.y1 + 1, intersection.x1, first.y1);

    rects.append(rect);

  }

  if (first.y0 < intersection.y0) {

    rect =

        TRect(intersection.x0, first.y0, intersection.x1, intersection.y0 - 1);

    rects.append(rect);

  }

  return rects;

}

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

TRaster32P ToolUtils::convertStrokeToImage(TStroke *stroke,

                                           const TRect &imageBounds,

                                           TPoint &pos, bool pencilMode) {

  int count = stroke->getControlPointCount();

  if (count == 0) return TRaster32P();

  TPointD imgCenter = TPointD((imageBounds.x0 + imageBounds.x1) * 0.5,

                              (imageBounds.y0 + imageBounds.y1) * 0.5);

  TStroke s(*stroke);

  // check self looped stroke

  TThickPoint first = s.getControlPoint(0);

  TThickPoint back  = s.getControlPoint(count - 1);

  if (first != back) {

    TPointD mid = (first + back) * 0.5;

    s.setControlPoint(count, mid);

    s.setControlPoint(count + 1, first);

  }

  // check bounds intersection

  s.transform(TTranslation(imgCenter));

  TRectD bbox = s.getBBox();

  TRect rect(tfloor(bbox.x0), tfloor(bbox.y0), tfloor(bbox.x1),

             tfloor(bbox.y1));

  pos = rect.getP00();

  pos = TPoint(pos.x > 0 ? pos.x : 0, pos.y > 0 ? pos.y : 0);

  rect *= imageBounds;

  if (rect.isEmpty()) return TRaster32P();

  // creates the image

  QImage img(rect.getLx(), rect.getLy(), QImage::Format_ARGB32);

  img.fill(Qt::transparent);

  QColor color = Qt::black;

  QPainter p(&img);

  p.setPen(QPen(color, 1, Qt::SolidLine));

  p.setBrush(color);

  p.setRenderHint(QPainter::Antialiasing, !pencilMode);

  QPainterPath path = strokeToPainterPath(&s);

  QRectF pathRect   = path.boundingRect();

  p.translate(-toQPoint(pos));

  p.drawPath(path);

  return rasterFromQImage(img, true, false);

}

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

TStroke *ToolUtils::merge(const ArrayOfStroke &a) {

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

  TStroke *ref      = 0;

  int controlPoints = 0;

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

    ref = a[i];

    assert(ref);

    if (!ref) continue;

    controlPoints = ref->getControlPointCount() - 1;

    for (int j = 0; j < controlPoints; ++j)

      v.push_back(ref->getControlPoint(j));

  }

  if (controlPoints > 0) v.push_back(ref->getControlPoint(controlPoints));

  TStroke *out = new TStroke(v);

  return out;

}

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

//

// TToolUndo

//

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

ToolUtils::TToolUndo::TToolUndo(TXshSimpleLevel *level, const TFrameId &frameId,

                                bool createdFrame, bool createdLevel,

                                const TPaletteP &oldPalette)

    : TUndo()

    , m_level(level)

    , m_frameId(frameId)

    , m_oldPalette(oldPalette)

    , m_col(-2)

    , m_row(-1)

    , m_isEditingLevel(false)

    , m_createdFrame(createdFrame)

    , m_createdLevel(createdLevel)

    , m_renumberedLevel(TTool::m_isLevelRenumbererd)

    , m_imageId("") {

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

  m_isEditingLevel        = app->getCurrentFrame()->isEditingLevel();

  if (!m_isEditingLevel) {

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

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

    m_cellsData = TTool::m_cellsData;

  }

  if (m_renumberedLevel) {

    m_oldFids = TTool::m_oldFids;

    m_newFids = TTool::m_newFids;

  }

  if (createdFrame) {

    m_imageId = "TToolUndo" + std::to_string(m_idCount++);

    TImageCache::instance()->add(m_imageId, level->getFrame(frameId, false),

                                 false);

  }

}

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

ToolUtils::TToolUndo::~TToolUndo() {

  TImageCache::instance()->remove(m_imageId);

}

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

void ToolUtils::TToolUndo::insertLevelAndFrameIfNeeded() const {

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

  if (m_renumberedLevel) {

    TXsheet *xsh = app->getCurrentScene()->getScene()->getTopXsheet();

    std::vector<txshchildlevel *=""> childLevels;</txshchildlevel>

    ToolUtils::doUpdateXSheet(m_level.getPointer(), m_oldFids, m_newFids, xsh,

                              childLevels);

    m_level->renumber(m_newFids);

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

  }

  if (m_createdLevel) {

    TLevelSet *levelSet = app->getCurrentScene()->getScene()->getLevelSet();

    if (levelSet) {

      levelSet->insertLevel(m_level.getPointer());

      app->getCurrentScene()->notifyCastChange();

    }

  }

  if (m_createdFrame) {

    TXsheet *xsh = app->getCurrentXsheet()->getXsheet();

    TImageP img  = TImageCache::instance()->get(m_imageId, false);

    m_level->setFrame(m_frameId, img);

    if (!m_isEditingLevel) {

      for (const TTool::CellOps &cellOps : m_cellsData) {

        TXshCell cell;

        if (cellOps.type == TTool::CellOps::BlankToExisting)

          cell = xsh->getCell(cellOps.r0 - 1, m_col);

        else

          cell = TXshCell(m_level.getPointer(), m_frameId);

        for (int r = cellOps.r0; r <= cellOps.r1; r++)

          xsh->setCell(r, m_col, cell);

      }

    }

    app->getCurrentLevel()->notifyLevelChange();

  }

}

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

void ToolUtils::TToolUndo::removeLevelAndFrameIfNeeded() const {

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

  if (m_createdFrame) {

    m_level->eraseFrame(m_frameId);

    if (!m_isEditingLevel) {

      TXsheet *xsh = app->getCurrentXsheet()->getXsheet();

      for (const TTool::CellOps &cellOps : m_cellsData) {

        TXshCell cell;

        if (cellOps.type == TTool::CellOps::ExistingToNew)

          cell = xsh->getCell(cellOps.r0 - 1, m_col);

        for (int r = cellOps.r0; r <= cellOps.r1; r++)

          xsh->setCell(r, m_col, cell);

      }

    }

    if (m_createdLevel) {

      // butta il livello

      TLevelSet *levelSet = app->getCurrentScene()->getScene()->getLevelSet();

      if (levelSet) {

        levelSet->removeLevel(m_level.getPointer());

        app->getCurrentScene()->notifyCastChange();

      }

    }

    app->getCurrentLevel()->notifyLevelChange();

  }

  if (m_oldPalette.getPointer()) {

    m_level->getPalette()->assign(m_oldPalette->clone());

    app->getPaletteController()

        ->getCurrentLevelPalette()

        ->notifyPaletteChanged();

  }

  if (m_renumberedLevel) {

    TXsheet *xsh = app->getCurrentScene()->getScene()->getTopXsheet();

    std::vector<txshchildlevel *=""> childLevels;</txshchildlevel>

    ToolUtils::doUpdateXSheet(m_level.getPointer(), m_newFids, m_oldFids, xsh,

                              childLevels);

    m_level->renumber(m_oldFids);

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

  }

}

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

void ToolUtils::TToolUndo::notifyImageChanged() const {

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

  TXshSimpleLevel *currentSl = 0;

  TFrameId currentFrameId;

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

    TXshLevel *xl = app->getCurrentLevel()->getLevel();

    if (!xl) return;

    currentSl      = xl->getSimpleLevel();

    currentFrameId = app->getCurrentFrame()->getFid();

  } else {

    int row = app->getCurrentFrame()->getFrame();

    int col = app->getCurrentColumn()->getColumnIndex();

    if (col < 0) return;

    TXsheet *xsh = app->getCurrentXsheet()->getXsheet();

    if (!xsh) return;

    TXshCell cell  = xsh->getCell(row, col);

    currentSl      = cell.getSimpleLevel();

    currentFrameId = cell.getFrameId();

  }

  if (currentSl == m_level.getPointer() && currentFrameId == m_frameId) {

    TTool *tool = app->getCurrentTool()->getTool();

    if (tool) tool->onImageChanged();

  }

  IconGenerator::instance()->invalidate(m_level.getPointer(), m_frameId);

  IconGenerator::instance()->invalidateSceneIcon();

  if (m_level && m_level->getType() == PLI_XSHLEVEL) {

    std::string id = m_level->getImageId(m_frameId) + "_rasterized";

    ImageManager::instance()->invalidate(id);

  }

}

int ToolUtils::TToolUndo::m_idCount = 0;

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

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

ToolUtils::TRasterUndo::TRasterUndo(TTileSetCM32 *tiles, TXshSimpleLevel *level,

                                    const TFrameId &frameId, bool createdFrame,

                                    bool createdLevel,

                                    const TPaletteP &oldPalette)

    : TToolUndo(level, frameId, createdFrame, createdLevel, oldPalette)

    , m_tiles(tiles) {}

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

ToolUtils::TRasterUndo::~TRasterUndo() {

  if (m_tiles) delete m_tiles;

}

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

TToonzImageP ToolUtils::TRasterUndo::getImage() const {

  if (m_level->isFid(m_frameId))

    return (TToonzImageP)m_level->getFrame(m_frameId, true);

  return 0;

}

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

int ToolUtils::TRasterUndo::getSize() const {

  int size = sizeof(*this);

  size += sizeof(*(m_level.getPointer()));

  size += sizeof(*(m_oldPalette.getPointer()));

  return m_tiles ? m_tiles->getMemorySize() + size : size;

}

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

void ToolUtils::TRasterUndo::undo() const {

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

  if (!app) return;

  if (m_tiles && m_tiles->getTileCount() > 0) {

    TToonzImageP image = getImage();

    if (!image) return;

    ToonzImageUtils::paste(image, m_tiles);

    ToolUtils::updateSaveBox(m_level, m_frameId);

  }

  removeLevelAndFrameIfNeeded();

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

  notifyImageChanged();

}

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

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

ToolUtils::TFullColorRasterUndo::TFullColorRasterUndo(

    TTileSetFullColor *tiles, TXshSimpleLevel *level, const TFrameId &frameId,

    bool createdFrame, bool createdLevel, const TPaletteP &oldPalette)

    : TToolUndo(level, frameId, createdFrame, createdLevel, oldPalette)

    , m_tiles(tiles) {}

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

ToolUtils::TFullColorRasterUndo::~TFullColorRasterUndo() { delete m_tiles; }

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

TRasterImageP ToolUtils::TFullColorRasterUndo::getImage() const {

  if (m_level->isFid(m_frameId))

    return (TRasterImageP)m_level->getFrame(m_frameId, true);

  return 0;

}

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

int ToolUtils::TFullColorRasterUndo::getSize() const {

  int size = sizeof(*this);

  size += sizeof(*(m_level.getPointer()));

  size += sizeof(*(m_oldPalette.getPointer()));

  return m_tiles ? m_tiles->getMemorySize() + size : size;

}

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

void ToolUtils::TFullColorRasterUndo::undo() const {

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

  if (!app) return;

  if (m_tiles && m_tiles->getTileCount() > 0) {

    TRasterImageP image = getImage();

    if (!image) return;

    std::vector<trect> rects = paste(image, m_tiles);</trect>

    int i;

    TRect resRect = rects[0];

    for (i = 1; i < (int)rects.size(); i++) resRect += rects[i];

  }

  removeLevelAndFrameIfNeeded();

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

  notifyImageChanged();

}

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

std::vector<trect> ToolUtils::TFullColorRasterUndo::paste(</trect>

    const TRasterImageP &ti, const TTileSetFullColor *tileSet) const {

  std::vector<trect> rects;</trect>

  TRasterP raster = ti->getRaster();

  for (int i = 0; i < tileSet->getTileCount(); i++) {

    const TTileSetFullColor::Tile *tile = tileSet->getTile(i);

    TRasterP ras;

    tile->getRaster(ras);

    assert(!!ras);

    raster->copy(ras, tile->m_rasterBounds.getP00());

    rects.push_back(tile->m_rasterBounds);

  }

  return rects;

}

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

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

ToolUtils::UndoModifyStroke::UndoModifyStroke(TXshSimpleLevel *level,

                                              const TFrameId &frameId,

                                              int strokeIndex)

    : TToolUndo(level, frameId), m_strokeIndex(strokeIndex) {

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

  assert(image);

  TStroke *stroke = image->getStroke(m_strokeIndex);

  int n           = stroke->getControlPointCount();

  for (int i = 0; i < n; i++) m_before.push_back(stroke->getControlPoint(i));

  m_selfLoopBefore = stroke->isSelfLoop();

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

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

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

}

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

ToolUtils::UndoModifyStroke::~UndoModifyStroke() {}

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

void ToolUtils::UndoModifyStroke::onAdd() {

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

  assert(image);

  if (!image) return;

  TStroke *stroke = image->getStroke(m_strokeIndex);

  assert(stroke);

  int n = stroke->getControlPointCount();

  for (int i = 0; i < n; i++) m_after.push_back(stroke->getControlPoint(i));

  m_selfLoopAfter = stroke->isSelfLoop();

}

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

void ToolUtils::UndoModifyStroke::undo() const {

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

  if (!app) return;

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

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

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

  } else

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

  TSelection *selection = app->getCurrentSelection()->getSelection();

  if (selection) selection->selectNone();

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

  assert(image);

  if (!image) return;

  QMutexLocker lock(image->getMutex());

  TStroke *stroke = 0;

  if (image->getStrokeCount() ==

      1)  // && image->getStroke(0)->getStyle()==SplineStyle)

    stroke = image->getStroke(0);

  else

    stroke = image->getStroke(m_strokeIndex);

  if (!stroke) return;

  TStroke *oldStroke = new TStroke(*stroke);

  stroke->reshape(&m_before[0], m_before.size());

  stroke->setSelfLoop(m_selfLoopBefore);

  image->notifyChangedStrokes(m_strokeIndex, oldStroke);

  notifyImageChanged();

  delete oldStroke;

}

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

void ToolUtils::UndoModifyStroke::redo() const {

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

  if (!app) return;

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

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

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

  } else

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

  TSelection *selection = app->getCurrentSelection()->getSelection();

  if (selection) selection->selectNone();

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

  assert(image);

  if (!image) return;

  QMutexLocker lock(image->getMutex());

  TStroke *stroke = 0;

  if (image->getStrokeCount() ==

      1)  //&& image->getStroke(0)->getStyle()==SplineStyle)

    stroke = image->getStroke(0);

  else

    stroke = image->getStroke(m_strokeIndex);

  if (!stroke) return;

  TStroke *oldStroke = new TStroke(*stroke);

  stroke->reshape(&m_after[0], m_after.size());

  stroke->setSelfLoop(m_selfLoopAfter);

  image->notifyChangedStrokes(m_strokeIndex, oldStroke);

  delete oldStroke;

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

  notifyImageChanged();

}

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

int ToolUtils::UndoModifyStroke::getSize() const {

  return (m_before.capacity() + m_after.capacity()) * sizeof(TThickPoint) +

         sizeof(*this) + 500;

}

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

ToolUtils::UndoModifyStrokeAndPaint::UndoModifyStrokeAndPaint(

    TXshSimpleLevel *level, const TFrameId &frameId, int strokeIndex)

    : UndoModifyStroke(level, frameId, strokeIndex), m_fillInformation(0) {

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

  assert(image);

  TStroke *stroke = image->getStroke(strokeIndex);

  m_oldBBox       = stroke->getBBox();

}

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

void ToolUtils::UndoModifyStrokeAndPaint::onAdd() {

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

  assert(!!image);

  if (!image) return;

  UndoModifyStroke::onAdd();

  TStroke *stroke   = image->getStroke(m_strokeIndex);

  m_fillInformation = new std::vector<tfilledregioninf>;</tfilledregioninf>

  ImageUtils::getFillingInformationOverlappingArea(

      image, *m_fillInformation, m_oldBBox, stroke->getBBox());

}

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

void ToolUtils::UndoModifyStrokeAndPaint::undo() const {

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

  if (!application) return;

  UndoModifyStroke::undo();