#include "filltool.h"

#include "toonz/tframehandle.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/tpalettehandle.h"

#include "toonz/preferences.h"

#include "toonz/txsheethandle.h"

#include "toonz/tobjecthandle.h"

#include "toonz/tscenehandle.h"

#include "tools/toolhandle.h"

#include "tools/toolutils.h"

#include "toonz/tonionskinmaskhandle.h"

#include "timagecache.h"

#include "tundo.h"

#include "tpalette.h"

#include "tcolorstyles.h"

#include "tvectorimage.h"

#include "tools/cursors.h"

#include "ttoonzimage.h"

#include "tproperty.h"

#include "tenv.h"

#include "tools/stylepicker.h"

#include "toonz/stage2.h"

#include "tstroke.h"

#include "drawutil.h"

#include "tsystem.h"

#include "tinbetween.h"

#include "tregion.h"

#include "tgl.h"

#include "trop.h"

#include "toonz/onionskinmask.h"

#include "toonz/ttileset.h"

#include "toonz/ttilesaver.h"

#include "toonz/toonzimageutils.h"

#include "toonz/levelproperties.h"

#include "toonz/txshcell.h"

#include "toonzqt/imageutils.h"

#include "autofill.h"

#include "historytypes.h"

#include <stack></stack>

// For Qt translation support

#include <qcoreapplication></qcoreapplication>

using namespace ToolUtils;

//#define LINES L"Lines"

//#define AREAS L"Areas"

//#define ALL L"Lines & Areas"

#define NORMALFILL L"Normal"

#define RECTFILL L"Rectangular"

#define FREEHANDFILL L"Freehand"

#define POLYLINEFILL L"Polyline"

TEnv::IntVar MinFillDepth("InknpaintMinFillDepth", 0);

TEnv::IntVar MaxFillDepth("InknpaintMaxFillDepth", 10);

TEnv::StringVar FillType("InknpaintFillType", "Normal");

TEnv::StringVar FillColorType("InknpaintFillColorType", "Areas");

TEnv::IntVar FillSelective("InknpaintFillSelective", 0);

TEnv::IntVar FillOnion("InknpaintFillOnion", 0);

TEnv::IntVar FillSegment("InknpaintFillSegment", 0);

TEnv::IntVar FillRange("InknpaintFillRange", 0);

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

namespace {

inline int vectorFill(const TVectorImageP &img, const std::wstring &type,

                      const TPointD &point, int style, bool emptyOnly = false) {

  if (type == ALL || type == LINES) {

    int oldStyleId = img->fillStrokes(point, style);

    if (oldStyleId != -1) return oldStyleId;

  }

  if (type == ALL || type == AREAS) return img->fill(point, style, emptyOnly);

  return -1;

}

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

// VectorFillUndo

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

class VectorFillUndo final : public TToolUndo {

  int m_oldColorStyle;

  int m_newColorStyle;

  TPointD m_point;

  std::wstring m_type;

  int m_row;

  int m_column;

public:

  VectorFillUndo(int newColorStyle, int oldColorStyle, std::wstring fillType,

                 TPointD clickPoint, TXshSimpleLevel *sl, const TFrameId &fid)

      : TToolUndo(sl, fid)

      , m_newColorStyle(newColorStyle)

      , m_oldColorStyle(oldColorStyle)

      , m_point(clickPoint)

      , m_type(fillType) {

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

    if (app) {

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

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

    }

  }

  void undo() const override {

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

    if (!app) return;

    app->getCurrentLevel()->setLevel(m_level.getPointer());

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

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

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

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

    } else

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

    assert(img);

    if (!img) return;

    QMutexLocker lock(img->getMutex());

    vectorFill(img, m_type, m_point, m_oldColorStyle);

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

    notifyImageChanged();

  }

  void redo() const override {

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

    if (!app) return;

    app->getCurrentLevel()->setLevel(m_level.getPointer());

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

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

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

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

    } else

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

    assert(img);

    if (!img) return;

    QMutexLocker lock(img->getMutex());

    vectorFill(img, m_type, m_point, m_newColorStyle);

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

    notifyImageChanged();

  }

  void onAdd() override {}

  int getSize() const override { return sizeof(*this); }

  QString getToolName() override {

    return QString("Fill Tool : %1").arg(QString::fromStdWString(m_type));

  }

  int getHistoryType() override { return HistoryType::FillTool; }

};

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

// VectorRectFillUndo

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

class VectorRectFillUndo final : public TToolUndo {

  std::vector<tfilledregioninf> *m_regionFillInformation;</tfilledregioninf>

  std::vector<std::pair<int, int="">> *m_strokeFillInformation;</std::pair<int,>

  TRectD m_selectionArea;

  int m_styleId;

  bool m_unpaintedOnly;

  TStroke *m_stroke;

public:

  ~VectorRectFillUndo() {

    if (m_regionFillInformation) delete m_regionFillInformation;

    if (m_strokeFillInformation) delete m_strokeFillInformation;

    if (m_stroke) delete m_stroke;

  }

  VectorRectFillUndo(std::vector<tfilledregioninf> *regionFillInformation,</tfilledregioninf>

                     std::vector<std::pair<int, int="">> *strokeFillInformation,</std::pair<int,>

                     TRectD selectionArea, TStroke *stroke, int styleId,

                     bool unpaintedOnly, TXshSimpleLevel *sl,

                     const TFrameId &fid)

      : TToolUndo(sl, fid)

      , m_regionFillInformation(regionFillInformation)

      , m_strokeFillInformation(strokeFillInformation)

      , m_selectionArea(selectionArea)

      , m_styleId(styleId)

      , m_unpaintedOnly(unpaintedOnly)

      , m_stroke(0) {

    if (stroke) m_stroke = new TStroke(*stroke);

  }

  void undo() const override {

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

    if (!app) return;

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

    assert(!!img);

    if (!img) return;

    if (m_regionFillInformation) {

      for (UINT i = 0; i < m_regionFillInformation->size(); i++) {

        TRegion *reg = img->getRegion((*m_regionFillInformation)[i].m_regionId);

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

      }

    }

    if (m_strokeFillInformation) {

      for (UINT i = 0; i < m_strokeFillInformation->size(); i++) {

        TStroke *s = img->getStroke((*m_strokeFillInformation)[i].first);

        s->setStyle((*m_strokeFillInformation)[i].second);

      }

    }

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

    notifyImageChanged();

  }

  void redo() const override {

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

    if (!app) return;

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

    assert(img);

    if (!img) return;

    img->selectFill(m_selectionArea, m_stroke, m_styleId, m_unpaintedOnly,

                    m_regionFillInformation != 0, m_strokeFillInformation != 0);

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

    notifyImageChanged();

  }

  void onAdd() override {}

  int getSize() const override {

    int size1 = m_regionFillInformation ? m_regionFillInformation->capacity() *

                                              sizeof(m_regionFillInformation)

                                        : 0;

    int size2 = m_strokeFillInformation ? m_strokeFillInformation->capacity() *

                                              sizeof(m_strokeFillInformation)

                                        : 0;

    return sizeof(*this) + size1 + size2 + 500;

  }

  QString getToolName() override { return QString("Fill Tool : "); }

  int getHistoryType() override { return HistoryType::FillTool; }

};

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

// VectorGapSizeChangeUndo

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

class VectorGapSizeChangeUndo final : public TToolUndo {

  double m_oldGapSize;

  double m_newGapSize;

  int m_row;

  int m_column;

  TVectorImageP m_vi;

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

public:

  VectorGapSizeChangeUndo(double oldGapSize, double newGapSize,

                          TXshSimpleLevel *sl, const TFrameId &fid,

                          TVectorImageP vi,

                          std::vector<tfilledregioninf> oldFillInformation)</tfilledregioninf>

      : TToolUndo(sl, fid)

      , m_oldGapSize(oldGapSize)

      , m_newGapSize(newGapSize)

      , m_oldFillInformation(oldFillInformation)

      , m_vi(vi) {

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

    if (app) {

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

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

    }

  }

  void undo() const override {

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

    if (!app || !m_level) return;

    app->getCurrentLevel()->setLevel(m_level.getPointer());

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

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

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

    } else

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

    m_vi->setAutocloseTolerance(m_oldGapSize);

    int count = m_vi->getStrokeCount();

    std::vector<int> v(count);</int>

    int i;

    for (i = 0; i < (int)count; i++) v[i] = i;

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

    if (m_vi->isComputedRegionAlmostOnce()) m_vi->findRegions();

    if (m_oldFillInformation.size()) {

      for (UINT j = 0; j < m_oldFillInformation.size(); j++) {

        TRegion *reg = m_vi->getRegion(m_oldFillInformation[j].m_regionId);

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

      }

    }

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

    app->getCurrentTool()->notifyToolChanged();

    notifyImageChanged();

  }

  void redo() const override {

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

    if (!app || !m_level) return;

    app->getCurrentLevel()->setLevel(m_level.getPointer());

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

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

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

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

    } else

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

    m_vi->setAutocloseTolerance(m_newGapSize);

    int count = m_vi->getStrokeCount();

    std::vector<int> v(count);</int>

    int i;

    for (i = 0; i < (int)count; i++) v[i] = i;

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

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

    app->getCurrentTool()->notifyToolChanged();

    notifyImageChanged();

  }

  void onAdd() override {}

  int getSize() const override { return sizeof(*this); }

  QString getToolName() override {

    return QString("Fill Tool: Set Gap Size ") + QString::number(m_newGapSize);

  }

  int getHistoryType() override { return HistoryType::FillTool; }

};

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

// RasterFillUndo

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

class RasterFillUndo final : public TRasterUndo {

  FillParameters m_params;

  bool m_saveboxOnly;

public:

  /*RasterFillUndo(TTileSetCM32 *tileSet, TPoint fillPoint,

                                                           int paintId, int

     fillDepth,

                                                           std::wstring

     fillType, bool isSegment,

                                                           bool selective, bool

     isShiftFill,

                                                           TXshSimpleLevel* sl,

     const TFrameId& fid)*/

  RasterFillUndo(TTileSetCM32 *tileSet, const FillParameters ¶ms,

                 TXshSimpleLevel *sl, const TFrameId &fid, bool saveboxOnly)

      : TRasterUndo(tileSet, sl, fid, false, false, 0)

      , m_params(params)

      , m_saveboxOnly(saveboxOnly) {}

  void redo() const override {

    TToonzImageP image = getImage();

    if (!image) return;

    bool recomputeSavebox = false;

    TRasterCM32P r;

    if (m_saveboxOnly) {

      TRectD temp = image->getBBox();

      TRect ttemp = convert(temp);

      r           = image->getRaster()->extract(ttemp);

    } else

      r = image->getRaster();

    if (m_params.m_fillType == ALL || m_params.m_fillType == AREAS) {

      if (m_params.m_shiftFill) {

        FillParameters aux(m_params);

        aux.m_styleId    = (m_params.m_styleId == 0) ? 1 : 0;

        recomputeSavebox = fill(r, aux);

      }

      recomputeSavebox = fill(r, m_params);

    }

    if (m_params.m_fillType == ALL || m_params.m_fillType == LINES) {

      if (m_params.m_segment)

        inkSegment(r, m_params.m_p, m_params.m_styleId, 2.51, true);

      else

        inkFill(r, m_params.m_p, m_params.m_styleId, 2);

    }

    if (recomputeSavebox) ToolUtils::updateSaveBox();

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

    if (app) {

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

      notifyImageChanged();

    }

  }

  int getSize() const override {

    return sizeof(*this) + TRasterUndo::getSize();

  }

  QString getToolName() override {

    return QString("Fill Tool : %1")

        .arg(QString::fromStdWString(m_params.m_fillType));

  }

  int getHistoryType() override { return HistoryType::FillTool; }

};

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

// RasterRectFillUndo

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

class RasterRectFillUndo final : public TRasterUndo {

  TRect m_fillArea;

  int m_paintId;

  std::wstring m_colorType;

  TStroke *m_s;

  bool m_onlyUnfilled;

  TPalette *m_palette;

public:

  ~RasterRectFillUndo() {

    if (m_s) delete m_s;

  }

  RasterRectFillUndo(TTileSetCM32 *tileSet, TStroke *s, TRect fillArea,

                     int paintId, TXshSimpleLevel *level,

                     std::wstring colorType, bool onlyUnfilled,

                     const TFrameId &fid, TPalette *palette)

      : TRasterUndo(tileSet, level, fid, false, false, 0)

      , m_fillArea(fillArea)

      , m_paintId(paintId)

      , m_colorType(colorType)

      , m_onlyUnfilled(onlyUnfilled)

      , m_palette(palette) {

    m_s = s ? new TStroke(*s) : 0;

  }

  void redo() const override {

    TToonzImageP image = getImage();

    if (!image) return;

    TRasterCM32P ras = image->getRaster();

    AreaFiller filler(ras);

    if (!m_s)

      filler.rectFill(m_fillArea, m_paintId, m_onlyUnfilled,

                      m_colorType != LINES, m_colorType != AREAS);

    else

      filler.strokeFill(m_s, m_paintId, m_onlyUnfilled, m_colorType != LINES,

                        m_colorType != AREAS);

    if (m_palette) {

      TRect rect   = m_fillArea;

      TRect bounds = ras->getBounds();

      if (bounds.overlaps(rect)) {

        rect *= bounds;

        const TTileSetCM32::Tile *tile =

            m_tiles->getTile(m_tiles->getTileCount() - 1);

        TRasterCM32P rbefore;

        tile->getRaster(rbefore);

        fillautoInks(ras, rect, rbefore, m_palette);

      }

    }

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

    if (app) {

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

      notifyImageChanged();

    }

  }

  int getSize() const override {

    int size =

        m_s ? m_s->getControlPointCount() * sizeof(TThickPoint) + 100 : 0;

    return sizeof(*this) + TRasterUndo::getSize() + size;

  }

  QString getToolName() override {

    return QString("Fill Tool : %1").arg(QString::fromStdWString(m_colorType));

  }

  int getHistoryType() override { return HistoryType::FillTool; }

};

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

// RasterRectAutoFillUndo

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

class RasterRectAutoFillUndo final : public TRasterUndo {

  TRect m_rectToFill;

  TFrameId m_fidToLearn;

  bool m_onlyUnfilled;

public:

  ~RasterRectAutoFillUndo() {}

  RasterRectAutoFillUndo(TTileSetCM32 *tileSet, const TRect &rectToFill,

                         TXshSimpleLevel *level, bool onlyUnfilled,

                         const TFrameId ¤tFid, const TFrameId &fidToLearn)

      : TRasterUndo(tileSet, level, currentFid, false, false, 0)

      , m_rectToFill(rectToFill)

      , m_onlyUnfilled(onlyUnfilled)

      , m_fidToLearn(fidToLearn) {}

  void redo() const override {

    TToonzImageP image        = getImage();

    TToonzImageP imageToLearn = m_level->getFrame(m_fidToLearn, false);

    if (!image || !imageToLearn) return;

    rect_autofill_learn(imageToLearn, m_rectToFill.x0, m_rectToFill.y0,

                        m_rectToFill.x1, m_rectToFill.y1);

    TTileSetCM32 tileSet(image->getRaster()->getSize());

    bool recomputeBBox = rect_autofill_apply(

        image, m_rectToFill.x0, m_rectToFill.y0, m_rectToFill.x1,

        m_rectToFill.y1, m_onlyUnfilled, &tileSet);

    if (recomputeBBox) ToolUtils::updateSaveBox();

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

    if (app) {

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

      notifyImageChanged();

    }

  }

  int getSize() const override {

    return sizeof(*this) + TRasterUndo::getSize();

  }

};

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

// RasterStrokeAutoFillUndo

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

class RasterStrokeAutoFillUndo final : public TRasterUndo {

  TTileSetCM32 *m_tileSet;

public:

  ~RasterStrokeAutoFillUndo() {

    if (m_tileSet) delete m_tileSet;

  }

  RasterStrokeAutoFillUndo(TTileSetCM32 *tileSet, TXshSimpleLevel *level,

                           const TFrameId ¤tFid)

      : TRasterUndo(tileSet, level, currentFid, false, false, 0)

      , m_tileSet(0) {}

  void setTileSet(TTileSetCM32 *tileSet) { m_tileSet = tileSet; }

  void redo() const override {

    TToonzImageP image = getImage();

    if (!image) return;

    ToonzImageUtils::paste(image, m_tileSet);

    ToolUtils::updateSaveBox(m_level, m_frameId);

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

    if (app) {

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

      notifyImageChanged();

    }

  }

  int getSize() const override {

    return sizeof(*this) + TRasterUndo::getSize() + m_tileSet->getMemorySize();

  }

};

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

// RasterRectAutoFillUndo

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

class VectorAutoFillUndo final : public TToolUndo {

  std::vector<tfilledregioninf> *m_regionFillInformation;</tfilledregioninf>

  TRectD m_selectionArea;

  TStroke *m_selectingStroke;

  bool m_unpaintedOnly;

  TFrameId m_onionFid;

  int m_row;

  int m_column;

public:

  ~VectorAutoFillUndo() {

    if (m_regionFillInformation) delete m_regionFillInformation;

    if (m_selectingStroke) delete m_selectingStroke;

  }

  VectorAutoFillUndo(std::vector<tfilledregioninf> *regionFillInformation,</tfilledregioninf>

                     TRectD selectionArea, TStroke *selectingStroke,

                     bool unpaintedOnly, TXshSimpleLevel *sl,

                     const TFrameId &fid, const TFrameId &onionFid)

      : TToolUndo(sl, fid)

      , m_regionFillInformation(regionFillInformation)

      , m_selectionArea(selectionArea)

      , m_unpaintedOnly(unpaintedOnly)

      , m_onionFid(onionFid) {

    m_selectingStroke = selectingStroke ? new TStroke(*selectingStroke) : 0;

  }

  void undo() const override {

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

    if (!app) return;

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

    ;

    assert(!!img);

    if (!img) return;

    if (m_regionFillInformation) {

      for (UINT i = 0; i < m_regionFillInformation->size(); i++) {

        TRegion *reg = img->getRegion((*m_regionFillInformation)[i].m_regionId);

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

      }

    }

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

    notifyImageChanged();

  }

  void redo() const override {

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

    if (!app) return;

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

    assert(img);

    if (!img) return;

    TVectorImageP onionImg = m_level->getFrame(m_onionFid, false);

    if (!onionImg) return;

    if (m_selectingStroke) {

      stroke_autofill_learn(onionImg, m_selectingStroke);

      stroke_autofill_apply(img, m_selectingStroke, m_unpaintedOnly);

    } else {

      rect_autofill_learn(onionImg, m_selectionArea);

      rect_autofill_apply(img, m_selectionArea, m_unpaintedOnly);

    }

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

    notifyImageChanged();

  }

  int getSize() const override {

    int size = m_selectingStroke ? m_selectingStroke->getControlPointCount() *

                                           sizeof(TThickPoint) +

                                       100

                                 : 0;

    return sizeof(*this) +

           m_regionFillInformation->capacity() *

               sizeof(m_regionFillInformation) +

           500 + size;

  }

};

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

void doRectAutofill(const TImageP &img, const TRectD selectingRect,

                    bool onlyUnfilled, const OnionSkinMask &osMask,

                    TXshSimpleLevel *sl, const TFrameId ¤tFid) {

  TToonzImageP ti(img);

  TVectorImageP vi(img);

  if (!img || !sl) return;

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

  osMask.getAll(sl->guessIndex(currentFid), rows);

  if (rows.empty()) return;

  TFrameId onionFid;

  int i;

  for (i = 0; i < (int)rows.size(); i++) {

    const TFrameId &app = sl->index2fid(rows[i]);

    if (app > currentFid) break;

    onionFid = app;

  }

  if (onionFid.isEmptyFrame()) onionFid = sl->index2fid(rows[0]);

  if (onionFid.isEmptyFrame() || onionFid == currentFid || !sl->isFid(onionFid))

    return;

  if (ti) {

    TRect rect = ToonzImageUtils::convertWorldToRaster(selectingRect, ti);

    TToonzImageP onionImg(sl->getFrame(onionFid, false));

    if (!onionImg) return;

    TRect workRect = rect * ti->getRaster()->getBounds();

    if (workRect.isEmpty()) return;

    rect_autofill_learn(onionImg, workRect.x0, workRect.y0, workRect.x1,

                        workRect.y1);

    TTileSetCM32 *tileSet = new TTileSetCM32(ti->getRaster()->getSize());

    bool recomputeBBox =

        rect_autofill_apply(ti, workRect.x0, workRect.y0, workRect.x1,

                            workRect.y1, onlyUnfilled, tileSet);

    if (recomputeBBox) ToolUtils::updateSaveBox();

    if (tileSet->getTileCount() > 0)

      TUndoManager::manager()->add(new RasterRectAutoFillUndo(

          tileSet, workRect, sl, onlyUnfilled, currentFid, onionFid));

  } else if (vi) {

    TVectorImageP onionImg(sl->getFrame(onionFid, false));

    if (!onionImg) return;

    std::vector<tfilledregioninf> *regionFillInformation =</tfilledregioninf>

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

    ImageUtils::getFillingInformationInArea(vi, *regionFillInformation,

                                            selectingRect);

    onionImg->findRegions();

    vi->findRegions();

    rect_autofill_learn(onionImg, selectingRect);

    bool hasFilled = rect_autofill_apply(vi, selectingRect, onlyUnfilled);

    if (hasFilled)

      TUndoManager::manager()->add(

          new VectorAutoFillUndo(regionFillInformation, selectingRect, 0,

                                 onlyUnfilled, sl, currentFid, onionFid));

  }

}

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

void doStrokeAutofill(const TImageP &img, TStroke *selectingStroke,

                      bool onlyUnfilled, const OnionSkinMask &osMask,

                      TXshSimpleLevel *sl, const TFrameId ¤tFid) {

  TToonzImageP ti(img);

  TVectorImageP vi(img);

  if (!img || !sl) return;

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

  osMask.getAll(sl->guessIndex(currentFid), rows);

  if (rows.empty()) return;

  TFrameId onionFid;

  int i;

  for (i = 0; i < (int)rows.size(); i++) {

    const TFrameId &app = sl->index2fid(rows[i]);

    if (app > currentFid) break;

    onionFid = app;

  }

  if (onionFid.isEmptyFrame()) onionFid = sl->index2fid(rows[0]);

  if (onionFid.isEmptyFrame() || onionFid == currentFid || !sl->isFid(onionFid))

    return;

  if (ti) {

    TToonzImageP onionImg(sl->getFrame(onionFid, false));

    if (!onionImg) return;

    TRasterCM32P ras = onionImg->getRaster();

    TPointD center   = ras->getCenterD();

    TPoint pos;

    TRaster32P image =

        convertStrokeToImage(selectingStroke, ras->getBounds(), pos);

    TRect bbox = (image->getBounds() + pos).enlarge(2);

    pos        = bbox.getP00();

    TRasterCM32P onionAppRas = ras->extract(bbox)->clone();

    TRasterCM32P tiAppRas    = ti->getRaster()->extract(bbox)->clone();

    TRect workRect = onionAppRas->getBounds().enlarge(-1);

    TToonzImageP onionApp(onionAppRas, workRect);

    TToonzImageP tiApp(tiAppRas, workRect);

    ToonzImageUtils::eraseImage(onionApp, image, TPoint(2, 2), true, true, true,

                                false, 1);

    ToonzImageUtils::eraseImage(tiApp, image, TPoint(2, 2), true, true, true,

                                false, 1);

    rect_autofill_learn(onionApp, workRect.x0, workRect.y0, workRect.x1,

                        workRect.y1);

    TTileSetCM32 *tileSet = new TTileSetCM32(ti->getRaster()->getSize());

    bool recomputeBBox =

        rect_autofill_apply(tiApp, workRect.x0, workRect.y0, workRect.x1,

                            workRect.y1, onlyUnfilled, tileSet);

    delete tileSet;

    tileSet = new TTileSetCM32(ti->getRaster()->getSize());

    tileSet->add(ti->getRaster(), bbox);

    RasterStrokeAutoFillUndo *undo =

        new RasterStrokeAutoFillUndo(tileSet, sl, currentFid);

    TRop::over(ti->getRaster(), tiAppRas, pos);

    TTileSetCM32 *newTileSet = new TTileSetCM32(ti->getRaster()->getSize());

    newTileSet->add(ti->getRaster(), bbox);

    undo->setTileSet(newTileSet);

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

  } else if (vi) {

    TVectorImageP onionImg(sl->getFrame(onionFid, false));

    if (!onionImg) return;

    std::vector<tfilledregioninf> *regionFillInformation =</tfilledregioninf>

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

    ImageUtils::getFillingInformationInArea(vi, *regionFillInformation,

                                            selectingStroke->getBBox());

    onionImg->findRegions();

    vi->findRegions();

    stroke_autofill_learn(onionImg, selectingStroke);

    bool hasFilled = stroke_autofill_apply(vi, selectingStroke, onlyUnfilled);

    if (hasFilled)

      TUndoManager::manager()->add(new VectorAutoFillUndo(

          regionFillInformation, TRectD(), selectingStroke, onlyUnfilled, sl,

          currentFid, onionFid));

  }

}

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

// fillRectWithUndo

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

bool inline hasAutoInks(const TPalette *plt) {

  for (int i = 0; i < plt->getStyleCount(); i++)

    if (plt->getStyle(i)->getFlags() != 0) return true;

  return false;

}

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

void fillAreaWithUndo(const TImageP &img, const TRectD &area, TStroke *stroke,

                      bool onlyUnfilled, std::wstring colorType,

                      TXshSimpleLevel *sl, const TFrameId &fid, int cs,

                      bool autopaintLines) {

  TRectD selArea = stroke ? stroke->getBBox() : area;

  if (TToonzImageP ti = img) {

    // allargo di 1 la savebox, perche cosi' il rectfill di tutta l'immagine fa

    // una sola fillata

    TRect enlargedSavebox =

        ti->getSavebox().enlarge(1) * TRect(TPoint(0, 0), ti->getSize());

    TRect rasterFillArea =

        ToonzImageUtils::convertWorldToRaster(selArea, ti) * enlargedSavebox;

    if (rasterFillArea.isEmpty()) return;

    TRasterCM32P ras = ti->getRaster();

    /*-- tileSetでFill範囲のRectをUndoに格納しておく --*/

    TTileSetCM32 *tileSet = new TTileSetCM32(ras->getSize());

    tileSet->add(ras, rasterFillArea);

    AreaFiller filler(ti->getRaster());

    if (!stroke) {

      bool ret = filler.rectFill(rasterFillArea, cs, onlyUnfilled,

                                 colorType != LINES, colorType != AREAS);

      if (!ret) {

        delete tileSet;

        return;

      }

    } else

      filler.strokeFill(stroke, cs, onlyUnfilled, colorType != LINES,

                        colorType != AREAS);

    TPalette *plt = ti->getPalette();

    // !autopaintLines will temporary disable autopaint line feature

    if ((plt && !hasAutoInks(plt)) || !autopaintLines) plt = 0;

    if (plt) {

      TRect rect   = rasterFillArea;

      TRect bounds = ras->getBounds();

      if (bounds.overlaps(rect)) {

        rect *= bounds;

        const TTileSetCM32::Tile *tile =

            tileSet->getTile(tileSet->getTileCount() - 1);

        TRasterCM32P rbefore;

        tile->getRaster(rbefore);

        fillautoInks(ras, rect, rbefore, plt);

      }

    }

    ToolUtils::updateSaveBox(sl, fid);

    TUndoManager::manager()->add(

        new RasterRectFillUndo(tileSet, stroke, rasterFillArea, cs, sl,

                               colorType, onlyUnfilled, fid, plt));

  } else if (TVectorImageP vi = img) {

    TPalette *palette = vi->getPalette();

    assert(palette);

    const TColorStyle *style = palette->getStyle(cs);

    // if( !style->isRegionStyle() )

    // return;

    vi->findRegions();

    std::vector<tfilledregioninf> *regionFillInformation    = 0;</tfilledregioninf>

    std::vector<std::pair<int, int="">> *strokeFillInformation = 0;</std::pair<int,>

    if (colorType != LINES) {

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

      ImageUtils::getFillingInformationInArea(vi, *regionFillInformation,

                                              selArea);

    }

    if (colorType != AREAS) {

      strokeFillInformation = new std::vector<std::pair<int, int="">>;</std::pair<int,>

      ImageUtils::getStrokeStyleInformationInArea(vi, *strokeFillInformation,