#include "brushtool.h"

// TnzTools includes

#include "tools/toolhandle.h"

#include "tools/toolutils.h"

#include "tools/tooloptions.h"

#include "bluredbrush.h"

// TnzQt includes

#include "toonzqt/dvdialog.h"

#include "toonzqt/imageutils.h"

// TnzLib includes

#include "toonz/tobjecthandle.h"

#include "toonz/txsheethandle.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/tframehandle.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/txsheet.h"

#include "toonz/tstageobject.h"

#include "toonz/tstageobjectspline.h"

#include "toonz/rasterstrokegenerator.h"

#include "toonz/ttileset.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/toonzimageutils.h"

#include "toonz/palettecontroller.h"

#include "toonz/stage2.h"

// TnzCore includes

#include "tstream.h"

#include "tcolorstyles.h"

#include "tvectorimage.h"

#include "tenv.h"

#include "tregion.h"

#include "tstroke.h"

#include "tgl.h"

#include "trop.h"

// Qt includes

#include <qpainter></qpainter>

using namespace ToolUtils;

TEnv::DoubleVar VectorBrushMinSize("InknpaintVectorBrushMinSize", 1);

TEnv::DoubleVar VectorBrushMaxSize("InknpaintVectorBrushMaxSize", 5);

TEnv::IntVar VectorCapStyle("InknpaintVectorCapStyle", 0);

TEnv::IntVar VectorJoinStyle("InknpaintVectorJoinStyle", 0);

TEnv::IntVar VectorMiterValue("InknpaintVectorMiterValue", 4);

TEnv::DoubleVar RasterBrushMinSize("InknpaintRasterBrushMinSize", 1);

TEnv::DoubleVar RasterBrushMaxSize("InknpaintRasterBrushMaxSize", 5);

TEnv::DoubleVar BrushAccuracy("InknpaintBrushAccuracy", 20);

TEnv::IntVar BrushSelective("InknpaintBrushSelective", 0);

TEnv::IntVar BrushBreakSharpAngles("InknpaintBrushBreakSharpAngles", 0);

TEnv::IntVar RasterBrushPencilMode("InknpaintRasterBrushPencilMode", 0);

TEnv::IntVar BrushPressureSensibility("InknpaintBrushPressureSensibility", 1);

TEnv::DoubleVar RasterBrushHardness("RasterBrushHardness", 100);

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

#define ROUNDC_WSTR L"round_cap"

#define BUTT_WSTR L"butt_cap"

#define PROJECTING_WSTR L"projecting_cap"

#define ROUNDJ_WSTR L"round_join"

#define BEVEL_WSTR L"bevel_join"

#define MITER_WSTR L"miter_join"

#define CUSTOM_WSTR L"<custom>"</custom>

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

//

// (Da mettere in libreria) : funzioni che spezzano una stroke

// nei suoi punti angolosi. Lo facciamo specialmente per limitare

// i problemi di fill.

//

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

//

// Split a stroke in n+1 parts, according to n parameter values

// Input:

//      stroke            = stroke to split

//      parameterValues[] = vector of parameters where I want to split the

//      stroke

//                          assert: 0

// Output:

//      strokes[]         = the split strokes

//

// note: stroke is unchanged

//

void split(TStroke *stroke, const std::vector<double> ¶meterValues,</double>

           std::vector<tstroke *=""> &strokes) {</tstroke>

  TThickPoint p2;

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

  TThickPoint lastPoint = stroke->getControlPoint(0);

  int n                 = parameterValues.size();

  int chunk;

  double t;

  int last_chunk = -1, startPoint = 0;

  double lastLocT = 0;

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

    points.push_back(lastPoint);  // Add first point of the stroke

    double w =

        parameterValues[i];  // Global parameter. along the stroke 0<=w<=1

    stroke->getChunkAndT(w, chunk,

                         t);  // t: local parameter in the chunk-th quadratic

    if (i == 0)

      startPoint = 1;

    else {

      int indexAfterLastT =

          stroke->getControlPointIndexAfterParameter(parameterValues[i - 1]);

      startPoint = indexAfterLastT;

      if ((indexAfterLastT & 1) && lastLocT != 1) startPoint++;

    }

    int endPoint = 2 * chunk + 1;

    if (lastLocT != 1 && i > 0) {

      if (last_chunk != chunk || t == 1)

        points.push_back(p2);  // If the last local t is not an extreme

                               // add the point p2

    }

    for (int j = startPoint; j < endPoint; j++)

      points.push_back(stroke->getControlPoint(j));

    TThickPoint p, A, B, C;

    p       = stroke->getPoint(w);

    C       = stroke->getControlPoint(2 * chunk + 2);

    B       = stroke->getControlPoint(2 * chunk + 1);

    A       = stroke->getControlPoint(2 * chunk);

    p.thick = A.thick;

    if (last_chunk != chunk) {

      TThickPoint p1 = (1 - t) * A + t * B;

      points.push_back(p1);

      p.thick = p1.thick;

    } else {

      if (t != 1) {

        // If the i-th cut point belong to the same chunk of the (i-1)-th cut

        // point.

        double tInters  = lastLocT / t;

        TThickPoint p11 = (1 - t) * A + t * B;

        TThickPoint p1  = (1 - tInters) * p11 + tInters * p;

        points.push_back(p1);

        p.thick = p1.thick;

      }

    }

    points.push_back(p);

    if (t != 1) p2 = (1 - t) * B + t * C;

    assert(points.size() & 1);

    // Add new stroke

    TStroke *strokeAdd = new TStroke(points);

    strokeAdd->setStyle(stroke->getStyle());

    strokeAdd->outlineOptions() = stroke->outlineOptions();

    strokes.push_back(strokeAdd);

    lastPoint  = p;

    last_chunk = chunk;

    lastLocT   = t;

    points.clear();

  }

  // Add end stroke

  points.push_back(lastPoint);

  if (lastLocT != 1) points.push_back(p2);

  startPoint =

      stroke->getControlPointIndexAfterParameter(parameterValues[n - 1]);

  if ((stroke->getControlPointIndexAfterParameter(parameterValues[n - 1]) &

       1) &&

      lastLocT != 1)

    startPoint++;

  for (int j = startPoint; j < stroke->getControlPointCount(); j++)

    points.push_back(stroke->getControlPoint(j));

  assert(points.size() & 1);

  TStroke *strokeAdd = new TStroke(points);

  strokeAdd->setStyle(stroke->getStyle());

  strokeAdd->outlineOptions() = stroke->outlineOptions();

  strokes.push_back(strokeAdd);

  points.clear();

}

// Compute Parametric Curve Curvature

// By Formula:

// k(t)=(|p'(t) x p''(t)|)/Norm2(p')^3

// p(t) is parametric curve

// Input:

//      dp  = First Derivate.

//      ddp = Second Derivate

// Output:

//      return curvature value.

//      Note: if the curve is a single point (that's dp=0) or it is a straight

//      line (that's ddp=0) return 0

double curvature(TPointD dp, TPointD ddp) {

  if (dp == TPointD(0, 0))

    return 0;

  else

    return fabs(cross(dp, ddp) / pow(norm2(dp), 1.5));

}

// Find the max curvature points of a stroke.

// Input:

//      stroke.

//      angoloLim =  Value (radians) of the Corner between two tangent vector.

//                   Up this value the two corner can be considered angular.

//      curvMaxLim = Value of the max curvature.

//                   Up this value the point can be considered a max curvature

//                   point.

// Output:

//      parameterValues = vector of max curvature parameter points

void findMaxCurvPoints(TStroke *stroke, const float &angoloLim,

                       const float &curvMaxLim,

                       std::vector<double> ¶meterValues) {</double>

  TPointD tg1, tg2;  // Tangent vectors

  TPointD dp, ddp;  // First and Second derivate.

  parameterValues.clear();

  int cpn = stroke ? stroke->getControlPointCount() : 0;

  for (int j = 2; j < cpn; j += 2) {

    TPointD p0 = stroke->getControlPoint(j - 2);

    TPointD p1 = stroke->getControlPoint(j - 1);

    TPointD p2 = stroke->getControlPoint(j);

    TPointD q = p1 - (p0 + p2) * 0.5;

    // Search corner point

    if (j > 2) {

      tg2 = -p0 + p2 + 2 * q;  // Tangent vector to this chunk at t=0

      double prod_scal =

          tg2 * tg1;  // Inner product between tangent vectors at t=0.

      assert(tg1 != TPointD(0, 0) || tg2 != TPointD(0, 0));

      // Compute corner between two tangent vectors

      double angolo =

          acos(prod_scal / (pow(norm2(tg2), 0.5) * pow(norm2(tg1), 0.5)));

      // Add corner point

      if (angolo > angoloLim) {

        double w = getWfromChunkAndT(stroke, (UINT)(0.5 * (j - 2)),

                                     0);  //  transform lacal t to global t

        parameterValues.push_back(w);

      }

    }

    tg1 = -p0 + p2 - 2 * q;  // Tangent vector to this chunk at t=1

    // End search corner point

    // Search max curvature point

    // Value of t where the curvature function has got an extreme.

    // (Point where first derivate is null)

    double estremo_int = 0;

    double t           = -1;

    if (q != TPointD(0, 0)) {

      t = 0.25 * (2 * q.x * q.x + 2 * q.y * q.y - q.x * p0.x + q.x * p2.x -

                  q.y * p0.y + q.y * p2.y) /

          (q.x * q.x + q.y * q.y);

      dp  = -p0 + p2 + 2 * q - 4 * t * q;  // First derivate of the curve

      ddp = -4 * q;                        // Second derivate of the curve

      estremo_int = curvature(dp, ddp);

      double h    = 0.01;

      dp          = -p0 + p2 + 2 * q - 4 * (t + h) * q;

      double c_dx = curvature(dp, ddp);

      dp          = -p0 + p2 + 2 * q - 4 * (t - h) * q;

      double c_sx = curvature(dp, ddp);

      // Check the point is a max and not a minimum

      if (estremo_int < c_dx && estremo_int < c_sx) {

        estremo_int = 0;

      }

    }

    double curv_max = estremo_int;

    // Compute curvature at the extreme of interval [0,1]

    // Compute curvature at t=0 (Left extreme)

    dp                = -p0 + p2 + 2 * q;

    double estremo_sx = curvature(dp, ddp);

    // Compute curvature at t=1 (Right extreme)

    dp                = -p0 + p2 - 2 * q;

    double estremo_dx = curvature(dp, ddp);

    // Compare curvature at the extreme of interval [0,1] with the internal

    // value

    double t_ext;

    if (estremo_sx >= estremo_dx)

      t_ext = 0;

    else

      t_ext           = 1;

    double maxEstremi = std::max(estremo_dx, estremo_sx);

    if (maxEstremi > estremo_int) {

      t        = t_ext;

      curv_max = maxEstremi;

    }

    // Add max curvature point

    if (t >= 0 && t <= 1 && curv_max > curvMaxLim) {

      double w = getWfromChunkAndT(stroke, (UINT)(0.5 * (j - 2)),

                                   t);  // transform local t to global t

      parameterValues.push_back(w);

    }

    // End search max curvature point

  }

  // Delete duplicate of parameterValues

  // Because some max cuvature point can coincide with the corner point

  if ((int)parameterValues.size() > 1) {

    std::sort(parameterValues.begin(), parameterValues.end());

    parameterValues.erase(

        std::unique(parameterValues.begin(), parameterValues.end()),

        parameterValues.end());

  }

}

void addStroke(TTool::Application *application, const TVectorImageP &vi,

               TStroke *stroke, bool breakAngles, bool frameCreated,

               bool levelCreated) {

  QMutexLocker lock(vi->getMutex());

  if (application->getCurrentObject()->isSpline()) {

    application->getCurrentXsheet()->notifyXsheetChanged();

    return;

  }

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

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

  const float angoloLim =

      1;  // Value (radians) of the Corner between two tangent vector.

          // Up this value the two corner can be considered angular.

  const float curvMaxLim = 0.8;  // Value of the max curvature.

  // Up this value the point can be considered a max curvature point.

  findMaxCurvPoints(stroke, angoloLim, curvMaxLim, corners);

  TXshSimpleLevel *sl = application->getCurrentLevel()->getSimpleLevel();

  TFrameId id = application->getCurrentTool()->getTool()->getCurrentFid();

  if (!corners.empty()) {

    if (breakAngles)

      split(stroke, corners, strokes);

    else

      strokes.push_back(new TStroke(*stroke));

    int n = strokes.size();

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

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

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

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

      ImageUtils::getFillingInformationOverlappingArea(vi, *fillInformation,

                                                       stroke->getBBox());

      TStroke *str = new TStroke(*strokes[i]);

      vi->addStroke(str);

      TUndoManager::manager()->add(new UndoPencil(str, fillInformation, sl, id,

                                                  frameCreated, levelCreated));

    }

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

  } else {

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

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

    ImageUtils::getFillingInformationOverlappingArea(vi, *fillInformation,

                                                     stroke->getBBox());

    TStroke *str = new TStroke(*stroke);

    vi->addStroke(str);

    TUndoManager::manager()->add(new UndoPencil(str, fillInformation, sl, id,

                                                frameCreated, levelCreated));

  }

  for (int k = 0; k < (int)strokes.size(); k++) delete strokes[k];

  strokes.clear();

  application->getCurrentTool()->getTool()->notifyImageChanged();

}

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

//

// Gennaro: end

//

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

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

//

// Helper functions and classes

//

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

namespace {

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

void addStrokeToImage(TTool::Application *application, const TVectorImageP &vi,

                      TStroke *stroke, bool breakAngles, bool frameCreated,

                      bool levelCreated) {

  QMutexLocker lock(vi->getMutex());

  addStroke(application, vi.getPointer(), stroke, breakAngles, frameCreated,

            levelCreated);

  // la notifica viene gia fatta da addStroke!

  // getApplication()->getCurrentTool()->getTool()->notifyImageChanged();

}

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

class RasterBrushUndo : public TRasterUndo {

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

  int m_styleId;

  bool m_selective;

  bool m_isPencil;

public:

  RasterBrushUndo(TTileSetCM32 *tileSet, const std::vector<tthickpoint> &points,</tthickpoint>

                  int styleId, bool selective, TXshSimpleLevel *level,

                  const TFrameId &frameId, bool isPencil, bool isFrameCreated,

                  bool isLevelCreated)

      : TRasterUndo(tileSet, level, frameId, isFrameCreated, isLevelCreated, 0)

      , m_points(points)

      , m_styleId(styleId)

      , m_selective(selective)

      , m_isPencil(isPencil) {}

  void redo() const override {

    insertLevelAndFrameIfNeeded();

    TToonzImageP image = getImage();

    TRasterCM32P ras   = image->getRaster();

    RasterStrokeGenerator m_rasterTrack(

        ras, BRUSH, NONE, m_styleId, m_points[0], m_selective, 0, !m_isPencil);

    m_rasterTrack.setPointsSequence(m_points);

    m_rasterTrack.generateStroke(m_isPencil);

    image->setSavebox(image->getSavebox() +

                      m_rasterTrack.getBBox(m_rasterTrack.getPointsSequence()));

    ToolUtils::updateSaveBox();

    TTool::getApplication()->getCurrentXsheet()->notifyXsheetChanged();

    notifyImageChanged();

  }

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

  QString getToolName() override { return QString("Brush Tool"); }

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

};

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

class RasterBluredBrushUndo : public TRasterUndo {

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

  int m_styleId;

  bool m_selective;

  int m_maxThick;

  double m_hardness;

public:

  RasterBluredBrushUndo(TTileSetCM32 *tileSet,

                        const std::vector<tthickpoint> &points, int styleId,</tthickpoint>

                        bool selective, TXshSimpleLevel *level,

                        const TFrameId &frameId, int maxThick, double hardness,

                        bool isFrameCreated, bool isLevelCreated)

      : TRasterUndo(tileSet, level, frameId, isFrameCreated, isLevelCreated, 0)

      , m_points(points)

      , m_styleId(styleId)

      , m_selective(selective)

      , m_maxThick(maxThick)

      , m_hardness(hardness) {}

  void redo() const override {

    if (m_points.size() == 0) return;

    insertLevelAndFrameIfNeeded();

    TToonzImageP image     = getImage();

    TRasterCM32P ras       = image->getRaster();

    TRasterCM32P backupRas = ras->clone();

    TRaster32P workRaster(ras->getSize());

    QRadialGradient brushPad = ToolUtils::getBrushPad(m_maxThick, m_hardness);

    workRaster->clear();

    BluredBrush brush(workRaster, m_maxThick, brushPad, false);

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

    points.push_back(m_points[0]);

    TRect bbox = brush.getBoundFromPoints(points);

    brush.addPoint(m_points[0], 1);

    brush.updateDrawing(ras, ras, bbox, m_styleId, m_selective);

    if (m_points.size() > 1) {

      points.clear();

      points.push_back(m_points[0]);

      points.push_back(m_points[1]);

      bbox = brush.getBoundFromPoints(points);

      brush.addArc(m_points[0], (m_points[1] + m_points[0]) * 0.5, m_points[1],

                   1, 1);

      brush.updateDrawing(ras, backupRas, bbox, m_styleId, m_selective);

      int i;

      for (i = 1; i + 2 < (int)m_points.size(); i = i + 2) {

        points.clear();

        points.push_back(m_points[i]);

        points.push_back(m_points[i + 1]);

        points.push_back(m_points[i + 2]);

        bbox = brush.getBoundFromPoints(points);

        brush.addArc(m_points[i], m_points[i + 1], m_points[i + 2], 1, 1);

        brush.updateDrawing(ras, backupRas, bbox, m_styleId, m_selective);

      }

    }

    ToolUtils::updateSaveBox();

    TTool::getApplication()->getCurrentXsheet()->notifyXsheetChanged();

    notifyImageChanged();

  }

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

  QString getToolName() override { return QString("Brush Tool"); }

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

};

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

double computeThickness(int pressure, const TDoublePairProperty &property,

                        bool isPath) {

  if (isPath) return 0.0;

  double p                    = pressure / 255.0;

  double t                    = p * p * p;

  double thick0               = property.getValue().first;

  double thick1               = property.getValue().second;

  if (thick1 < 0.0001) thick0 = thick1 = 0.0;

  return (thick0 + (thick1 - thick0) * t) * 0.5;

}

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

int computeThickness(int pressure, const TIntPairProperty &property,

                     bool isPath) {

  if (isPath) return 0.0;

  double p   = pressure / 255.0;

  double t   = p * p * p;

  int thick0 = property.getValue().first;

  int thick1 = property.getValue().second;

  return tround(thick0 + (thick1 - thick0) * t);

}

}  // namespace

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

//

// BrushTool

//

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

BrushTool::BrushTool(std::string name, int targetType)

    : TTool(name)

    , m_thickness("Size", 0, 100, 0, 5)

    , m_rasThickness("Size", 1, 100, 1, 5)

    , m_accuracy("Accuracy:", 1, 100, 20)

    , m_hardness("Hardness:", 0, 100, 100)

    , m_preset("Preset:")

    , m_selective("Selective", false)

    , m_breakAngles("Break", true)

    , m_pencil("Pencil", false)

    , m_pressure("Pressure", true)

    , m_capStyle("Cap")

    , m_joinStyle("Join")

    , m_miterJoinLimit("Miter:", 0, 100, 4)

    , m_rasterTrack(0)

    , m_styleId(0)

    , m_modifiedRegion()

    , m_bluredBrush(0)

    , m_active(false)

    , m_enabled(false)

    , m_isPrompting(false)

    , m_firstTime(true)

    , m_presetsLoaded(false)

    , m_workingFrameId(TFrameId()) {

  bind(targetType);

  if (targetType & TTool::Vectors) {

    m_prop[0].bind(m_thickness);

    m_prop[0].bind(m_accuracy);

    m_prop[0].bind(m_breakAngles);

    m_breakAngles.setId("BreakSharpAngles");

  }

  if (targetType & TTool::ToonzImage) {

    m_prop[0].bind(m_rasThickness);

    m_prop[0].bind(m_hardness);

    m_prop[0].bind(m_selective);

    m_prop[0].bind(m_pencil);

    m_pencil.setId("PencilMode");

    m_selective.setId("Selective");

  }

  m_prop[0].bind(m_pressure);

  m_prop[0].bind(m_preset);

  m_preset.setId("BrushPreset");

  m_preset.addValue(CUSTOM_WSTR);

  m_pressure.setId("PressureSensibility");

  m_capStyle.addValue(BUTT_WSTR);

  m_capStyle.addValue(ROUNDC_WSTR);

  m_capStyle.addValue(PROJECTING_WSTR);

  m_capStyle.setId("Cap");

  m_joinStyle.addValue(MITER_WSTR);

  m_joinStyle.addValue(ROUNDJ_WSTR);

  m_joinStyle.addValue(BEVEL_WSTR);

  m_joinStyle.setId("Join");

  m_miterJoinLimit.setId("Miter");

  if (targetType & TTool::Vectors) {

    m_prop[1].bind(m_capStyle);

    m_prop[1].bind(m_joinStyle);

    m_prop[1].bind(m_miterJoinLimit);

  }

}

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

ToolOptionsBox *BrushTool::createOptionsBox() {

  TPaletteHandle *currPalette =

      TTool::getApplication()->getPaletteController()->getCurrentLevelPalette();

  ToolHandle *currTool = TTool::getApplication()->getCurrentTool();

  return new BrushToolOptionsBox(0, this, currPalette, currTool);

}

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

void BrushTool::drawLine(const TPointD &point, const TPointD ¢re,

                         bool horizontal, bool isDecimal) {

  if (!isDecimal) {

    if (horizontal) {

      tglDrawSegment(TPointD(point.x - 1.5, point.y + 0.5) + centre,

                     TPointD(point.x - 0.5, point.y + 0.5) + centre);

      tglDrawSegment(TPointD(point.y - 0.5, -point.x + 1.5) + centre,

                     TPointD(point.y - 0.5, -point.x + 0.5) + centre);

      tglDrawSegment(TPointD(-point.x + 0.5, -point.y + 0.5) + centre,

                     TPointD(-point.x - 0.5, -point.y + 0.5) + centre);

      tglDrawSegment(TPointD(-point.y - 0.5, point.x - 0.5) + centre,

                     TPointD(-point.y - 0.5, point.x + 0.5) + centre);

      tglDrawSegment(TPointD(point.y - 0.5, point.x + 0.5) + centre,

                     TPointD(point.y - 0.5, point.x - 0.5) + centre);

      tglDrawSegment(TPointD(point.x - 0.5, -point.y + 0.5) + centre,

                     TPointD(point.x - 1.5, -point.y + 0.5) + centre);

      tglDrawSegment(TPointD(-point.y - 0.5, -point.x + 0.5) + centre,

                     TPointD(-point.y - 0.5, -point.x + 1.5) + centre);

      tglDrawSegment(TPointD(-point.x - 0.5, point.y + 0.5) + centre,

                     TPointD(-point.x + 0.5, point.y + 0.5) + centre);

    } else {

      tglDrawSegment(TPointD(point.x - 1.5, point.y + 1.5) + centre,

                     TPointD(point.x - 1.5, point.y + 0.5) + centre);

      tglDrawSegment(TPointD(point.x - 1.5, point.y + 0.5) + centre,

                     TPointD(point.x - 0.5, point.y + 0.5) + centre);

      tglDrawSegment(TPointD(point.y + 0.5, -point.x + 1.5) + centre,

                     TPointD(point.y - 0.5, -point.x + 1.5) + centre);

      tglDrawSegment(TPointD(point.y - 0.5, -point.x + 1.5) + centre,

                     TPointD(point.y - 0.5, -point.x + 0.5) + centre);

      tglDrawSegment(TPointD(-point.x + 0.5, -point.y - 0.5) + centre,

                     TPointD(-point.x + 0.5, -point.y + 0.5) + centre);

      tglDrawSegment(TPointD(-point.x + 0.5, -point.y + 0.5) + centre,

                     TPointD(-point.x - 0.5, -point.y + 0.5) + centre);

      tglDrawSegment(TPointD(-point.y - 1.5, point.x - 0.5) + centre,

                     TPointD(-point.y - 0.5, point.x - 0.5) + centre);

      tglDrawSegment(TPointD(-point.y - 0.5, point.x - 0.5) + centre,

                     TPointD(-point.y - 0.5, point.x + 0.5) + centre);

      tglDrawSegment(TPointD(point.y + 0.5, point.x - 0.5) + centre,

                     TPointD(point.y - 0.5, point.x - 0.5) + centre);

      tglDrawSegment(TPointD(point.y - 0.5, point.x - 0.5) + centre,

                     TPointD(point.y - 0.5, point.x + 0.5) + centre);

      tglDrawSegment(TPointD(point.x - 1.5, -point.y - 0.5) + centre,

                     TPointD(point.x - 1.5, -point.y + 0.5) + centre);

      tglDrawSegment(TPointD(point.x - 1.5, -point.y + 0.5) + centre,

                     TPointD(point.x - 0.5, -point.y + 0.5) + centre);

      tglDrawSegment(TPointD(-point.y - 1.5, -point.x + 1.5) + centre,

                     TPointD(-point.y - 0.5, -point.x + 1.5) + centre);

      tglDrawSegment(TPointD(-point.y - 0.5, -point.x + 1.5) + centre,

                     TPointD(-point.y - 0.5, -point.x + 0.5) + centre);

      tglDrawSegment(TPointD(-point.x + 0.5, point.y + 1.5) + centre,

                     TPointD(-point.x + 0.5, point.y + 0.5) + centre);

      tglDrawSegment(TPointD(-point.x + 0.5, point.y + 0.5) + centre,

                     TPointD(-point.x - 0.5, point.y + 0.5) + centre);

    }

  } else {

    if (horizontal) {

      tglDrawSegment(TPointD(point.x - 0.5, point.y + 0.5) + centre,

                     TPointD(point.x + 0.5, point.y + 0.5) + centre);

      tglDrawSegment(TPointD(point.y + 0.5, point.x - 0.5) + centre,

                     TPointD(point.y + 0.5, point.x + 0.5) + centre);

      tglDrawSegment(TPointD(point.y + 0.5, -point.x + 0.5) + centre,

                     TPointD(point.y + 0.5, -point.x - 0.5) + centre);

      tglDrawSegment(TPointD(point.x + 0.5, -point.y - 0.5) + centre,

                     TPointD(point.x - 0.5, -point.y - 0.5) + centre);

      tglDrawSegment(TPointD(-point.x - 0.5, -point.y - 0.5) + centre,

                     TPointD(-point.x + 0.5, -point.y - 0.5) + centre);

      tglDrawSegment(TPointD(-point.y - 0.5, -point.x + 0.5) + centre,

                     TPointD(-point.y - 0.5, -point.x - 0.5) + centre);

      tglDrawSegment(TPointD(-point.y - 0.5, point.x - 0.5) + centre,

                     TPointD(-point.y - 0.5, point.x + 0.5) + centre);

      tglDrawSegment(TPointD(-point.x + 0.5, point.y + 0.5) + centre,

                     TPointD(-point.x - 0.5, point.y + 0.5) + centre);

    } else {

      tglDrawSegment(TPointD(point.x - 0.5, point.y + 1.5) + centre,

                     TPointD(point.x - 0.5, point.y + 0.5) + centre);

      tglDrawSegment(TPointD(point.x - 0.5, point.y + 0.5) + centre,

                     TPointD(point.x + 0.5, point.y + 0.5) + centre);

      tglDrawSegment(TPointD(point.y + 1.5, point.x - 0.5) + centre,

                     TPointD(point.y + 0.5, point.x - 0.5) + centre);

      tglDrawSegment(TPointD(point.y + 0.5, point.x - 0.5) + centre,

                     TPointD(point.y + 0.5, point.x + 0.5) + centre);

      tglDrawSegment(TPointD(point.y + 1.5, -point.x + 0.5) + centre,

                     TPointD(point.y + 0.5, -point.x + 0.5) + centre);

      tglDrawSegment(TPointD(point.y + 0.5, -point.x + 0.5) + centre,

                     TPointD(point.y + 0.5, -point.x - 0.5) + centre);

      tglDrawSegment(TPointD(point.x - 0.5, -point.y - 1.5) + centre,

                     TPointD(point.x - 0.5, -point.y - 0.5) + centre);

      tglDrawSegment(TPointD(point.x - 0.5, -point.y - 0.5) + centre,

                     TPointD(point.x + 0.5, -point.y - 0.5) + centre);

      tglDrawSegment(TPointD(-point.x + 0.5, -point.y - 1.5) + centre,

                     TPointD(-point.x + 0.5, -point.y - 0.5) + centre);

      tglDrawSegment(TPointD(-point.x + 0.5, -point.y - 0.5) + centre,

                     TPointD(-point.x - 0.5, -point.y - 0.5) + centre);

      tglDrawSegment(TPointD(-point.y - 1.5, -point.x + 0.5) + centre,

                     TPointD(-point.y - 0.5, -point.x + 0.5) + centre);

      tglDrawSegment(TPointD(-point.y - 0.5, -point.x + 0.5) + centre,

                     TPointD(-point.y - 0.5, -point.x - 0.5) + centre);

      tglDrawSegment(TPointD(-point.y - 1.5, point.x - 0.5) + centre,

                     TPointD(-point.y - 0.5, point.x - 0.5) + centre);

      tglDrawSegment(TPointD(-point.y - 0.5, point.x - 0.5) + centre,

                     TPointD(-point.y - 0.5, point.x + 0.5) + centre);

      tglDrawSegment(TPointD(-point.x + 0.5, point.y + 1.5) + centre,

                     TPointD(-point.x + 0.5, point.y + 0.5) + centre);

      tglDrawSegment(TPointD(-point.x + 0.5, point.y + 0.5) + centre,

                     TPointD(-point.x - 0.5, point.y + 0.5) + centre);

    }

  }

}

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

void BrushTool::drawEmptyCircle(TPointD pos, int thick, bool isLxEven,

                                bool isLyEven, bool isPencil) {

  if (isLxEven) pos.x += 0.5;

  if (isLyEven) pos.y += 0.5;

  if (!isPencil)

    tglDrawCircle(pos, (thick + 1) * 0.5);

  else {

    int x = 0, y = tround((thick * 0.5) - 0.5);

    int d           = 3 - 2 * (int)(thick * 0.5);

    bool horizontal = true, isDecimal = thick % 2 != 0;

    drawLine(TPointD(x, y), pos, horizontal, isDecimal);

    while (y > x) {

      if (d < 0) {

        d          = d + 4 * x + 6;

        horizontal = true;

      } else {

        d          = d + 4 * (x - y) + 10;

        horizontal = false;

        y--;

      }

      x++;

      drawLine(TPointD(x, y), pos, horizontal, isDecimal);

    }

  }

}

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

void BrushTool::updateTranslation() {

  m_thickness.setQStringName(tr("Size"));

  m_rasThickness.setQStringName(tr("Size"));

  m_hardness.setQStringName(tr("Hardness:"));

  m_accuracy.setQStringName(tr("Accuracy:"));

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

  // m_filled.setQStringName(tr("Filled"));

  m_preset.setQStringName(tr("Preset:"));

  m_breakAngles.setQStringName(tr("Break"));

  m_pencil.setQStringName(tr("Pencil"));

  m_pressure.setQStringName(tr("Pressure"));

  m_capStyle.setQStringName(tr("Cap"));

  m_joinStyle.setQStringName(tr("Join"));

  m_miterJoinLimit.setQStringName(tr("Miter:"));

}

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

void BrushTool::updateWorkAndBackupRasters(const TRect &rect) {

  TToonzImageP ti = TImageP(getImage(false, 1));

  if (!ti) return;

  TRasterCM32P ras = ti->getRaster();

  TRect _rect     = rect * ras->getBounds();

  TRect _lastRect = m_lastRect * ras->getBounds();

  if (_rect.isEmpty()) return;

  if (m_lastRect.isEmpty()) {

    m_workRas->extract(_rect)->clear();

    m_backupRas->extract(_rect)->copy(ras->extract(_rect));

    return;

  }

  QList<trect> rects = ToolUtils::splitRect(_rect, _lastRect);</trect>

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

    m_workRas->extract(rects[i])->clear();

    m_backupRas->extract(rects[i])->copy(ras->extract(rects[i]));

  }

}

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

void BrushTool::onActivate() {

  if (m_firstTime) {

    m_thickness.setValue(

        TDoublePairProperty::Value(VectorBrushMinSize, VectorBrushMaxSize));

    m_rasThickness.setValue(

        TDoublePairProperty::Value(RasterBrushMinSize, RasterBrushMaxSize));

    m_capStyle.setIndex(VectorCapStyle);

    m_joinStyle.setIndex(VectorJoinStyle);

    m_miterJoinLimit.setValue(VectorMiterValue);

    m_selective.setValue(BrushSelective ? 1 : 0);

    m_breakAngles.setValue(BrushBreakSharpAngles ? 1 : 0);

    m_pencil.setValue(RasterBrushPencilMode ? 1 : 0);

    m_pressure.setValue(BrushPressureSensibility ? 1 : 0);

    m_firstTime = false;

    m_accuracy.setValue(BrushAccuracy);

    m_hardness.setValue(RasterBrushHardness);

  }

  if (m_targetType & TTool::ToonzImage) {

    m_brushPad = ToolUtils::getBrushPad(m_rasThickness.getValue().second,

                                        m_hardness.getValue() * 0.01);

    setWorkAndBackupImages();

  }

  // TODO:app->editImageOrSpline();

}

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

void BrushTool::onDeactivate() {

  /*---

   * ドラッグ中にツールが切り替わった場合に備え、onDeactivateにもMouseReleaseと同じ処理を行う

   * ---*/

  if (m_tileSaver && !m_isPath) {

    bool isValid = m_enabled && m_active;

    m_enabled    = false;

    if (isValid) {

      TImageP image = getImage(true);

      if (TToonzImageP ti = image)

        finishRasterBrush(m_mousePos,

                          1); /*-- 最後のストロークの筆圧は1とする --*/

    }

  }

  m_workRas   = TRaster32P();

  m_backupRas = TRasterCM32P();

}

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

bool BrushTool::preLeftButtonDown() {

  touchImage();

  if (m_isFrameCreated) setWorkAndBackupImages();

  return true;

}

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

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

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

  if (!app) return;

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

  m_isPath  = app->getCurrentObject()->isSpline();

  m_enabled = col >= 0 || m_isPath;

  // todo: gestire autoenable

  if (!m_enabled) return;

  if (!m_isPath) {

    m_currentColor = TPixel32::Black;