#include "tools/tool.h"

#include "tools/toolutils.h"

#include "toonz/txshlevelhandle.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 "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/fill.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/txshsimplelevel.h"

#include "toonz/onionskinmask.h"

#include "toonz/ttileset.h"

#include "toonz/ttilesaver.h"

#include "toonz/toonzimageutils.h"

#include "toonz/levelproperties.h"

#include "toonz/strokegenerator.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; }

};

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

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

  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)

      filler.rectFill(rasterFillArea, cs, onlyUnfilled, colorType != LINES,

                      colorType != AREAS);

    else

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

                        colorType != AREAS);

    TPalette *plt                     = ti->getPalette();

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

    std::set<int> autoInks;</int>

    autoInks.insert(3);

    autoInks.insert(4);

    autoInks.insert(5);

    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,

                                                  selArea);

    }

    VectorRectFillUndo *fUndo =

        new VectorRectFillUndo(regionFillInformation, strokeFillInformation,

                               selArea, stroke, cs, onlyUnfilled, sl, fid);

    QMutexLocker lock(vi->getMutex());

    if (vi->selectFill(area, stroke, cs, onlyUnfilled, colorType != LINES,

                       colorType != AREAS))

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

    else

      delete fUndo;

  }

}

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

// doFill

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

void doFill(const TImageP &img, const TPointD &pos, FillParameters ¶ms,

            bool isShiftFill, TXshSimpleLevel *sl, const TFrameId &fid) {

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

  if (!app) return;

  if (TToonzImageP ti = TToonzImageP(img)) {

    TPoint offs(0, 0);

    TRasterCM32P ras = ti->getRaster();

    if (Preferences::instance()->getFillOnlySavebox()) {

      TRectD bbox = ti->getBBox();

      TRect ibbox = convert(bbox);

      offs        = ibbox.getP00();

      ras         = ti->getRaster()->extract(ibbox);

    }

    bool recomputeSavebox = false;

    TPalette *plt         = ti->getPalette();

    if (!ras.getPointer() || ras->isEmpty()) return;

    ras->lock();

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

    TTileSaverCM32 tileSaver(ras, tileSet);

    TDimension imageSize = ti->getSize();

    TPointD p(imageSize.lx % 2 ? 0.0 : 0.5, imageSize.ly % 2 ? 0.0 : 0.5);

    /*-- params.m_p = convert(pos-p)では、マイナス座標でずれが生じる --*/

    TPointD tmp_p = pos - p;

    params.m_p = TPoint((int)floor(tmp_p.x + 0.5), (int)floor(tmp_p.y + 0.5));

    params.m_p += ti->getRaster()->getCenter();

    params.m_p -= offs;

    params.m_shiftFill = isShiftFill;

    TRect rasRect(ras->getSize());

    if (!rasRect.contains(params.m_p)) {

      ras->unlock();

      return;

    }

    if (plt && hasAutoInks(plt)) params.m_palette = plt;

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

      if (isShiftFill) {

        FillParameters aux(params);

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

        recomputeSavebox = fill(ras, aux, &tileSaver);

      }

      recomputeSavebox = fill(ras, params, &tileSaver);

    }

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

      if (params.m_segment)

        inkSegment(ras, params.m_p, params.m_styleId, 2.51, true, &tileSaver);

      else if (!params.m_segment)

        inkFill(ras, params.m_p, params.m_styleId, 2, &tileSaver);

    }

    if (tileSaver.getTileSet()->getTileCount() != 0) {

      static int count = 0;

      TSystem::outputDebug("FILL" + std::to_string(count++) + "\n");

      if (offs != TPoint())

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

          TTileSet::Tile *t = tileSet->editTile(i);

          t->m_rasterBounds = t->m_rasterBounds + offs;

        }

      TUndoManager::manager()->add(