#include "rasterselectiontool.h"

#include "vectorselectiontool.h"

#include "drawutil.h"

#include "tenv.h"

#include "tools/toolhandle.h"

#include "toonz/tdistort.h"

#include "toonz/glrasterpainter.h"

#include "toonz/toonzimageutils.h"

#include "toonzqt/tselectionhandle.h"

#include "toonzqt/imageutils.h"

using namespace ToolUtils;

using namespace DragSelectionTool;

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

// RasterFreeDeformer

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

RasterFreeDeformer::RasterFreeDeformer(TRasterP ras)

    : FreeDeformer(), m_ras(ras), m_newRas(), m_noAntialiasing(false) {

  TRect r       = ras->getBounds();

  m_originalP00 = convert(r.getP00());

  m_originalP11 = convert(r.getP11());

  m_newPoints.push_back(m_originalP00);

  m_newPoints.push_back(convert(r.getP10()));

  m_newPoints.push_back(m_originalP11);

  m_newPoints.push_back(convert(r.getP01()));

}

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

RasterFreeDeformer::~RasterFreeDeformer() {}

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

void RasterFreeDeformer::setPoint(int index, const TPointD &p) {

  m_newPoints[index] = p;

}

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

void RasterFreeDeformer::setPoints(const TPointD &p0, const TPointD &p1,

                                   const TPointD &p2, const TPointD &p3) {

  m_newPoints[0] = p0;

  m_newPoints[1] = p1;

  m_newPoints[2] = p2;

  m_newPoints[3] = p3;

}

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

void RasterFreeDeformer::deformImage() {

  TPointD p00 = TPointD();

  TPointD p10 = m_newPoints[1] - m_newPoints[0];

  TPointD p11 = m_newPoints[2] - m_newPoints[0];

  TPointD p01 = m_newPoints[3] - m_newPoints[0];

  double x0 = std::min({p00.x, p10.x, p11.x, p01.x});

  double y0 = std::min({p00.y, p10.y, p11.y, p01.y});

  double x1 = std::max({p00.x, p10.x, p11.x, p01.x});

  double y1 = std::max({p00.y, p10.y, p11.y, p01.y});

  TRectD sourceRect(TPointD(), TPointD(m_ras->getLx(), m_ras->getLy()));

  BilinearDistorterBase dist(sourceRect.getP00(), sourceRect.getP10(),

                             sourceRect.getP01(), sourceRect.getP11(), p00, p10,

                             p01, p11);

  TRect destRect(tfloor(x0), tfloor(y0), tceil(x1) - 1, tceil(y1) - 1);

  if (TRasterCM32P ras = (TRasterCM32P)m_ras)

    m_newRas = TRasterCM32P(destRect.getLx(), destRect.getLy());

  else if (TRaster32P ras = (TRaster32P)m_ras)

    m_newRas = TRaster32P(destRect.getLx(), destRect.getLy());

  TRasterP newRas(m_newRas);  // Someway, conversion from TRasterCM32P to

                              // TRasterP is not automatic

  distort(newRas, m_ras, dist, destRect.getP00(),

          m_noAntialiasing ? TRop::ClosestPixel : TRop::Bilinear);

}

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

// UndoRasterDeform

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

DragSelectionTool::UndoRasterDeform::UndoRasterDeform(RasterSelectionTool *tool)

    : TUndo()

    , m_tool(tool)

    , m_oldBBox(tool->getBBox())

    , m_newBBox()

    , m_oldCenter(tool->getCenter())

    , m_newCenter()

    , m_dim() {

  RasterSelection *selection = (RasterSelection *)tool->getSelection();

  m_oldStrokes               = selection->getStrokes();

  m_oldFloatingImageId =

      "UndoRasterDeform_old_floating_" + std::to_string(m_id++);

  TRasterP floatingRas = selection->getFloatingSelection();

  TImageP floatingImage;

  if (TRasterCM32P toonzRas = (TRasterCM32P)(floatingRas)) {

    floatingImage = TToonzImageP(toonzRas, toonzRas->getBounds());

    m_dim         = toonzRas->getSize();

    m_pixelSize   = toonzRas->getPixelSize();

  }

  if (TRaster32P fullColorRas = (TRaster32P)(floatingRas)) {

    floatingImage = TRasterImageP(fullColorRas);

    m_dim         = fullColorRas->getSize();

    m_pixelSize   = fullColorRas->getPixelSize();

  }

  if (TRasterGR8P grRas = (TRasterGR8P)(floatingRas)) {

    floatingImage = TRasterImageP(grRas);

    m_dim         = grRas->getSize();

    m_pixelSize   = grRas->getPixelSize();

  }

  TImageCache::instance()->add(m_oldFloatingImageId, floatingImage, false);

}

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

DragSelectionTool::UndoRasterDeform::~UndoRasterDeform() {

  if (TImageCache::instance()->isCached(m_oldFloatingImageId))

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

  if (TImageCache::instance()->isCached(m_newFloatingImageId))

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

}

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

void DragSelectionTool::UndoRasterDeform::registerRasterDeformation() {

  RasterSelection *selection = (RasterSelection *)m_tool->getSelection();

  m_newStrokes               = selection->getStrokes();

  m_newFloatingImageId =

      "UndoRasterDeform_new_floating_" + std::to_string(m_id);

  TRasterP floatingRas = selection->getFloatingSelection();

  TImageP floatingImage;

  if (TRasterCM32P toonzRas = (TRasterCM32P)(floatingRas))

    floatingImage = TToonzImageP(toonzRas, toonzRas->getBounds());

  if (TRaster32P fullColorRas = (TRaster32P)(floatingRas))

    floatingImage = TRasterImageP(fullColorRas);

  if (TRasterGR8P grRas = (TRasterGR8P)(floatingRas))

    floatingImage = TRasterImageP(grRas);

  TImageCache::instance()->add(m_newFloatingImageId, floatingImage, false);

  m_newBBox   = m_tool->getBBox();

  m_newCenter = m_tool->getCenter();

}

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

void DragSelectionTool::UndoRasterDeform::undo() const {

  RasterSelection *selection = (RasterSelection *)m_tool->getSelection();

  if (!selection->isFloating()) return;

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

  TRasterP ras;

  if (TToonzImageP ti = (TToonzImageP)(img)) ras = ti->getRaster();

  if (TRasterImageP ri = (TRasterImageP)(img)) ras = ri->getRaster();

  selection->setFloatingSeletion(ras);

  selection->setStrokes(m_oldStrokes);

  m_tool->setBBox(m_oldBBox);

  m_tool->setCenter(m_oldCenter);

  m_tool->invalidate();

  m_tool->decreaseTransformationCount();

}

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

void DragSelectionTool::UndoRasterDeform::redo() const {

  RasterSelection *selection = (RasterSelection *)m_tool->getSelection();

  if (!selection->isFloating()) return;

  TToonzImageP img = TImageCache::instance()->get(m_newFloatingImageId, false);

  TRasterP ras;

  if (TToonzImageP ti = (TToonzImageP)(img)) ras = ti->getRaster();

  if (TRasterImageP ri = (TRasterImageP)(img)) ras = ri->getRaster();

  selection->setStrokes(m_newStrokes);

  m_tool->setBBox(m_newBBox);

  m_tool->setCenter(m_newCenter);

  m_tool->invalidate();

  m_tool->increaseTransformationCount();

}

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

int DragSelectionTool::UndoRasterDeform::getSize() const {

  return sizeof(*this) + (m_dim.lx * m_dim.ly * m_pixelSize);

}

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

int DragSelectionTool::UndoRasterDeform::m_id = 0;

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

// UndoRasterTransform

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

DragSelectionTool::UndoRasterTransform::UndoRasterTransform(

    RasterSelectionTool *tool)

    : m_tool(tool) {

  m_oldDeformValues = m_tool->m_deformValues;

  RasterSelection *selection =

      dynamic_cast<rasterselection *="">(tool->getSelection());</rasterselection>

  m_oldTransform = selection->getTransformation();

  m_oldCenter    = tool->getCenter();

  m_oldBbox      = tool->getBBox();

}

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

void DragSelectionTool::UndoRasterTransform::setChangedValues() {

  m_newDeformValues = m_tool->m_deformValues;

  RasterSelection *selection =

      dynamic_cast<rasterselection *="">(m_tool->getSelection());</rasterselection>

  m_newTransform = selection->getTransformation();

  m_newCenter    = m_tool->getCenter();

  m_newBbox      = m_tool->getBBox();

}

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

void DragSelectionTool::UndoRasterTransform::undo() const {

  m_tool->transformFloatingSelection(m_oldTransform, m_oldCenter, m_oldBbox);

  m_tool->m_deformValues = m_oldDeformValues;

  m_tool->decreaseTransformationCount();

  TTool::getApplication()->getCurrentTool()->notifyToolChanged();

}

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

void DragSelectionTool::UndoRasterTransform::redo() const {

  m_tool->transformFloatingSelection(m_newTransform, m_newCenter, m_newBbox);

  m_tool->m_deformValues = m_newDeformValues;

  m_tool->increaseTransformationCount();

  TTool::getApplication()->getCurrentTool()->notifyToolChanged();

}

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

// RasterDeformTool

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

DragSelectionTool::RasterDeformTool::RasterDeformTool(RasterSelectionTool *tool,

                                                      bool freeDeformer)

    : DeformTool(tool)

    , m_transformUndo(0)

    , m_deformUndo(0)

    , m_isFreeDeformer(freeDeformer) {

  if (!m_isFreeDeformer) m_transformUndo = new UndoRasterTransform(tool);

}

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

void DragSelectionTool::RasterDeformTool::applyTransform(FourPoints bbox) {

  RasterSelectionTool *tool = (RasterSelectionTool *)getTool();

  tool->setNewFreeDeformer();

  if (!m_deformUndo) m_deformUndo = new UndoRasterDeform(tool);

  RasterSelection *selection =

      dynamic_cast<rasterselection *="">(tool->getSelection());</rasterselection>

  assert(selection);

  FourPoints realBbox = bbox * selection->getTransformation().inv();

  RasterFreeDeformer *freeDeformer =

      (RasterFreeDeformer *)tool->getFreeDeformer();

  freeDeformer->setNoAntialiasing(tool->getNoAntialiasingValue());

  freeDeformer->setPoints(realBbox.getP00(), realBbox.getP10(),

                          realBbox.getP11(), realBbox.getP01());

  freeDeformer->deformImage();

  selection->setFloatingSeletion(freeDeformer->getImage());

  VectorFreeDeformer *vectorFreeDeformer = tool->getSelectionFreeDeformer();

  if (vectorFreeDeformer) {

    vectorFreeDeformer->setPoints(realBbox.getP00(), realBbox.getP10(),

                                  realBbox.getP11(), realBbox.getP01());

    vectorFreeDeformer->deformImage();

    TVectorImage *vi = vectorFreeDeformer->getDeformedImage();

    std::vector<tstroke> newStrokes;</tstroke>

    int i;

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

      newStrokes.push_back(*(vi->getStroke(i)));

    selection->setStrokes(newStrokes);

  }

  tool->m_deformValues.m_isSelectionModified = true;

  if (!m_isDragging) tool->notifyImageChanged();

}

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

void DragSelectionTool::RasterDeformTool::applyTransform(TAffine aff,

                                                         bool modifyCenter) {

  m_transform *= aff;

  RasterSelectionTool *tool = dynamic_cast<rasterselectiontool *="">(getTool());</rasterselectiontool>

  RasterSelection *rasterSelection =

      dynamic_cast<rasterselection *="">(getTool()->getSelection());</rasterselection>

  rasterSelection->transform(aff);

  tool->setBBox(tool->getBBox() * aff);

  if (modifyCenter) tool->setCenter(aff * tool->getCenter());

  if (!m_isDragging && !rasterSelection->isFloating())

    rasterSelection->makeFloating();

  else if (!m_isDragging)

    tool->notifyImageChanged();

}

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

void DragSelectionTool::RasterDeformTool::addTransformUndo() {

  RasterSelection *rasterSelection =

      dynamic_cast<rasterselection *="">(getTool()->getSelection());</rasterselection>

  if (!rasterSelection || !rasterSelection->isFloating()) return;

  RasterSelectionTool *tool = dynamic_cast<rasterselectiontool *="">(getTool());</rasterselectiontool>

  assert(tool);

  if (!m_isFreeDeformer) {

    if (!m_transformUndo) return;

    m_transformUndo->setChangedValues();

    m_transform = TAffine();

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

  } else {

    if (!m_deformUndo) return;

    m_deformUndo->registerRasterDeformation();

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

  }

  tool->increaseTransformationCount();

}

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

// RasterRotationTool

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

DragSelectionTool::RasterRotationTool::RasterRotationTool(

    RasterSelectionTool *tool)

    : RasterDeformTool(tool, false) {

  m_rotation = new Rotation(this);

}

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

void DragSelectionTool::RasterRotationTool::transform(TAffine aff,

                                                      double angle) {

  applyTransform(aff, false);

}

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

void DragSelectionTool::RasterRotationTool::leftButtonDrag(

    const TPointD &pos, const TMouseEvent &e) {

  m_rotation->leftButtonDrag(pos, e);

}

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

void DragSelectionTool::RasterRotationTool::draw() { m_rotation->draw(); }

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

// RasterFreeDeformTool

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

DragSelectionTool::RasterFreeDeformTool::RasterFreeDeformTool(

    RasterSelectionTool *tool)

    : RasterDeformTool(tool, true) {

  m_freeDeform = new FreeDeform(this);

}

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

void DragSelectionTool::RasterFreeDeformTool::leftButtonDrag(

    const TPointD &pos, const TMouseEvent &e) {

  m_freeDeform->leftButtonDrag(pos, e);

}

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

// RasterMoveSelectionTool

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

DragSelectionTool::RasterMoveSelectionTool::RasterMoveSelectionTool(

    RasterSelectionTool *tool)

    : RasterDeformTool(tool, false) {

  m_moveSelection = new MoveSelection(this);

}

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

void DragSelectionTool::RasterMoveSelectionTool::transform(TAffine aff) {

  applyTransform(aff, true);

}

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

void DragSelectionTool::RasterMoveSelectionTool::leftButtonDown(

    const TPointD &pos, const TMouseEvent &e) {

  m_moveSelection->leftButtonDown(pos, e);

  RasterDeformTool::leftButtonDown(pos, e);

}

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

void DragSelectionTool::RasterMoveSelectionTool::leftButtonDrag(

    const TPointD &pos, const TMouseEvent &e) {

  m_moveSelection->leftButtonDrag(pos, e);

}

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

// RasterScaleTool

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

DragSelectionTool::RasterScaleTool::RasterScaleTool(RasterSelectionTool *tool,

                                                    int type)

    : RasterDeformTool(tool, true) {

  m_scale = new Scale(this, type);

}

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

TPointD DragSelectionTool::RasterScaleTool::transform(int index,

                                                      TPointD newPos) {

  SelectionTool *tool = getTool();

  TPointD scaleValue  = tool->m_deformValues.m_scaleValue;

  std::vector<fourpoints> startBboxs = m_scale->getStartBboxs();</fourpoints>

  FourPoints bbox =

      m_scale->bboxScaleInCenter(index, startBboxs[0], newPos, scaleValue,

                                 m_scale->getStartCenter(), true);

  if (bbox == startBboxs[0]) return scaleValue;

  // Se non ho scalato rispetto al centro calcolo la posizione del nuovo centro

  if (!m_scale->scaleInCenter())

    tool->setCenter(m_scale->getNewCenter(index, startBboxs[0], scaleValue));

  applyTransform(bbox);

  tool->setBBox(bbox);

  return scaleValue;

}

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

void DragSelectionTool::RasterScaleTool::leftButtonDown(const TPointD &pos,

                                                        const TMouseEvent &e) {

  m_scale->leftButtonDown(pos, e);

  RasterDeformTool::leftButtonDown(pos, e);

}

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

void DragSelectionTool::RasterScaleTool::leftButtonDrag(const TPointD &pos,

                                                        const TMouseEvent &e) {

  m_scale->leftButtonDrag(pos, e);

}

TEnv::IntVar ModifySavebox("ModifySavebox", 0);

TEnv::IntVar NoAntialiasing("NoAntialiasing", 0);

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

// RasterSelectionTool

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

RasterSelectionTool::RasterSelectionTool(int targetType)

    : SelectionTool(targetType)

    , m_transformationCount(0)

    , m_selectionFreeDeformer(0)

    , m_noAntialiasing("No Antialiasing", false)

    , m_modifySavebox("Modify Savebox", false)

    , m_setSaveboxTool(0) {

  m_prop.bind(m_noAntialiasing);

  m_rasterSelection.setView(this);

  if (m_targetType & ToonzImage) {

    m_setSaveboxTool = new SetSaveboxTool(this);

    m_modifySavebox.setId("ModifySavebox");

  }

}

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

void RasterSelectionTool::setBBox(const DragSelectionTool::FourPoints &points,

                                  int index) {

  if (m_bboxs.empty()) return;

  assert((int)m_bboxs.size() > index);

  m_bboxs[index]                  = points;

  TAffine aff                     = m_rasterSelection.getTransformation();

  DragSelectionTool::FourPoints p = points * aff.inv();

  m_rasterSelection.setSelectionBbox(p.getBox());

}

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

void RasterSelectionTool::setNewFreeDeformer() {

  if (!m_freeDeformers.empty() || isSelectionEmpty()) return;

  TImageP image = (TImageP)getImage(true);

  TToonzImageP ti  = (TToonzImageP)image;

  TRasterImageP ri = (TRasterImageP)image;

  if (!ti && !ri) return;

  if (!isFloating()) m_rasterSelection.makeFloating();

  m_freeDeformers.push_back(

      new RasterFreeDeformer(m_rasterSelection.getFloatingSelection()));

  std::vector<tstroke> strokes = m_rasterSelection.getOriginalStrokes();</tstroke>

  if (!strokes.empty()) {

    TVectorImage *vi = new TVectorImage();

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

    // Devo deformare anche gli strokes della selezione!!!

    int i;

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

      vi->addStroke(new TStroke(strokes[i]));

      indices.insert(i);

    }

    m_selectionFreeDeformer = new VectorFreeDeformer(vi, indices);

    m_selectionFreeDeformer->setPreserveThickness(true);

  }

}

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

VectorFreeDeformer *RasterSelectionTool::getSelectionFreeDeformer() const {

  return m_selectionFreeDeformer;

}

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

bool RasterSelectionTool::isFloating() const {

  return m_rasterSelection.isFloating();

}

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

void RasterSelectionTool::modifySelectionOnClick(TImageP image,

                                                 const TPointD &pos,

                                                 const TMouseEvent &e) {

  const TXshCell &imageCell = TTool::getImageCell();

  TToonzImageP ti  = (TToonzImageP)image;

  TRasterImageP ri = (TRasterImageP)image;

  if (!ti && !ri) return;

  m_rasterSelection.makeCurrent();

  updateAction(pos, e);

  m_firstPos = m_curPos = pos;

  if (!m_rasterSelection.isEmpty() && !m_rasterSelection.isFloating() &&

      e.isShiftPressed() && !m_rasterSelection.isTransformed()) {

    m_selectingRect.empty();

    m_transformationCount = 0;

    m_selecting           = true;

  } else if (!m_rasterSelection.isEmpty()) {

    m_selectingRect.empty();

    m_selecting = false;

    if (m_what == Outside && m_rasterSelection.isFloating()) {

      m_rasterSelection.pasteFloatingSelection();

    } else if (m_what == Outside && !m_rasterSelection.isFloating()) {

      m_rasterSelection.setCurrentImage(image, imageCell);

      m_rasterSelection.selectNone();

      m_bboxs.clear();

      m_selectingRect.empty();

      m_selecting = true;

    } else {

      if (!m_rasterSelection.isFloating() &&

          (m_what == Inside || m_what == ROTATION || m_what == SCALE ||

           m_what == SCALE_X || m_what == SCALE_Y)) {

        m_rasterSelection.makeFloating();

        m_transformationCount = 0;

        m_rasterSelection.setTransformationCount(0);

      }

    }

  } else {

    if (m_what == Outside) {

      m_rasterSelection.setCurrentImage(image, imageCell);

      m_rasterSelection.selectNone();

      m_bboxs.clear();

      m_selectingRect.empty();

      m_selecting = true;

    }

  }

  invalidate();

}

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

void RasterSelectionTool::leftButtonDown(const TPointD &pos,

                                         const TMouseEvent &e) {

  if (m_setSaveboxTool && m_modifySavebox.getValue()) {

    m_setSaveboxTool->leftButtonDown(pos);

    return;

  }

  SelectionTool::leftButtonDown(pos, e);

}

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

void RasterSelectionTool::mouseMove(const TPointD &pos, const TMouseEvent &e) {

  if (m_setSaveboxTool && m_modifySavebox.getValue()) {

    if (!m_leftButtonMousePressed)

      m_cursorId = m_setSaveboxTool->getCursorId(pos);

    return;

  }

  SelectionTool::mouseMove(pos, e);

}

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

void RasterSelectionTool::leftButtonDrag(const TPointD &pos,

                                         const TMouseEvent &e) {

  if (m_setSaveboxTool && m_modifySavebox.getValue()) {

    m_setSaveboxTool->leftButtonDrag(pos);

    invalidate();

    return;

  }

  if (m_dragTool) {

    m_dragTool->leftButtonDrag(pos, e);

    invalidate();

    return;

  }

  TImageP image    = getImage(true);

  TToonzImageP ti  = (TToonzImageP)image;

  TRasterImageP ri = (TRasterImageP)image;

  if (!ti && !ri) return;

  if (m_selecting) {

    if (m_strokeSelectionType.getValue() == RECT_SELECTION) {

      TDimension imageSize;

      if (ti)

        imageSize = ti->getSize();

      else if (ri)

        imageSize = ri->getRaster()->getSize();

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

      TRectD rectD(tround(std::min(m_firstPos.x, pos.x) - p.x) + p.x,

                   tround(std::min(m_firstPos.y, pos.y) - p.y) + p.y,

                   tround(std::max(m_firstPos.x, pos.x) - p.x) + p.x,

                   tround(std::max(m_firstPos.y, pos.y) - p.y) + p.y);

      m_selectingRect = rectD;

      m_bboxs.clear();

      invalidate();

    } else if (m_strokeSelectionType.getValue() == FREEHAND_SELECTION)

      freehandDrag(pos);

    return;

  }

  double pixelSize        = getPixelSize();

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

  if (!app || m_justSelected || !m_selecting ||

      tdistance2(pos, m_curPos) < 9.0 * pixelSize * pixelSize)

    return;

  m_curPos = pos;

  if (m_strokeSelectionType.getValue() == FREEHAND_SELECTION)

    freehandDrag(pos);

  else if (m_strokeSelectionType.getValue() == RECT_SELECTION) {

    bool selectOverlappingStroke = (m_firstPos.x > pos.x);

    TRectD rect(m_firstPos, pos);

    m_selectingRect = rect;

    invalidate();

  }

}

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

void RasterSelectionTool::leftButtonUp(const TPointD &pos,

                                       const TMouseEvent &e) {

  if (m_setSaveboxTool && m_modifySavebox.getValue()) {

    m_setSaveboxTool->leftButtonUp(pos);

    invalidate();

    return;

  }

  m_leftButtonMousePressed = false;

  m_shiftPressed           = false;

  if (m_dragTool) {

    m_dragTool->leftButtonUp(pos, e);

    delete m_dragTool;

    m_dragTool = 0;

    invalidate();

    notifyImageChanged();

    return;

  }

  if (!m_selecting) return;

  // Se stavo modificando la selezione la completo

  TImageP image    = getImage(true);

  TToonzImageP ti  = (TToonzImageP)image;

  TRasterImageP ri = (TRasterImageP)image;

  if (ti || ri) {

    if (m_strokeSelectionType.getValue() == RECT_SELECTION) {

      m_bboxs.push_back(m_selectingRect);

      m_rasterSelection.select(

          TRectD(m_selectingRect.getP00(), m_selectingRect.getP11()));

      m_rasterSelection.setFrameId(getCurrentFid());

      m_selectingRect.empty();

    } else if (m_strokeSelectionType.getValue() == FREEHAND_SELECTION) {

      closeFreehand(pos);

      if (m_stroke->getControlPointCount() > 5) {

        m_rasterSelection.select(*m_stroke);

        m_rasterSelection.setFrameId(getCurrentFid());

        m_rasterSelection.makeCurrent();

      }

    }

  }

  m_selecting    = false;

  m_justSelected = false;

  invalidate();

}

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

void RasterSelectionTool::leftButtonDoubleClick(const TPointD &pos,

                                                const TMouseEvent &e) {

  TImageP image    = getImage(true);

  TToonzImageP ti  = (TToonzImageP)image;

  TRasterImageP ri = (TRasterImageP)image;

  if (!ti && !ri) return;

  if (m_strokeSelectionType.getValue() == POLYLINE_SELECTION &&

      !m_polyline.empty()) {

    closePolyline(pos);

    if (m_stroke) {

      m_rasterSelection.select(*m_stroke);

      m_rasterSelection.setFrameId(getCurrentFid());

      m_rasterSelection.makeCurrent();

    }

    m_selecting = false;

    return;

  }

}

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

/*-- Paste後のフローティング状態の画像の描画 --*/

void RasterSelectionTool::drawFloatingSelection() {

  double pixelSize =

      TTool::getApplication()->getCurrentTool()->getTool()->getPixelSize();

  TAffine aff = m_rasterSelection.getTransformation();

  glPushMatrix();

  tglMultMatrix(aff);

  // draw m_floatingSelection

  if (isFloating()) {

    TRasterP floatingSelection = m_rasterSelection.getFloatingSelection();

    TImageP app;

    if (TRasterCM32P toonzRas = (TRasterCM32P)(floatingSelection))

      app = TToonzImageP(toonzRas, toonzRas->getBounds());

    if (TRaster32P fullColorRas = (TRaster32P)(floatingSelection))

      app = TRasterImageP(fullColorRas);

    if (TRasterGR8P grRas = (TRasterGR8P)(floatingSelection))

      app = TRasterImageP(grRas);

    app->setPalette(m_rasterSelection.getCurrentImage()->getPalette());

    FourPoints points = getBBox() * aff.inv();

    TRectD bbox       = points.getBox();

    TPointD center((bbox.getP00() + bbox.getP11()) * 0.5);

    if (TToonzImageP ti = (TToonzImageP)app)

      GLRasterPainter::drawRaster(TTranslation(center), ti, false);

    if (TRasterImageP ri = (TRasterImageP)app)

      GLRasterPainter::drawRaster(TTranslation(center), ri, true);

  }

  std::vector<tstroke> strokes = m_rasterSelection.getStrokes();</tstroke>

  int i;

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

    TStroke stroke = strokes[i];

    glEnable(GL_LINE_STIPPLE);

    glLineStipple(1, 0xF0F0);

    tglColor(TPixel32::Black);

    drawStrokeCenterline(stroke, pixelSize);

    glDisable(GL_LINE_STIPPLE);

  }

  glPopMatrix();

}

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

void RasterSelectionTool::draw() {

  TImageP image    = getImage(false);

  TToonzImageP ti  = (TToonzImageP)image;

  TRasterImageP ri = (TRasterImageP)image;

  if (!ti && !ri) return;

  if (m_setSaveboxTool && m_modifySavebox.getValue()) {

    m_setSaveboxTool->draw();

    return;

  }

  glPushMatrix();

  /*-- フローティング画像の描画 --*/

  drawFloatingSelection();

  if (m_strokeSelectionType.getValue() == POLYLINE_SELECTION &&

      !m_rasterSelection.isFloating())

    drawPolylineSelection();

  if (m_rasterSelection.isEmpty()) m_bboxs.clear();

  /*-- 選択範囲の変形ハンドルの描画 --*/

  if (getBBoxsCount() > 0) drawCommandHandle(image.getPointer());

  /*-- 選択範囲の四角形の描画 --*/

  if (m_selecting && !m_selectingRect.isEmpty())

    drawRectSelection(image.getPointer());

  /*-- バウンディングボックスの描画 --*/

  /*

if(ti)

{

   TRectD saveBox = ToonzImageUtils::convertRasterToWorld(ti->getSavebox(), ti);

drawRect(saveBox.enlarge(0.5)*ti->getSubsampling(), TPixel32::Black, 0x5555,

true);

}

*/

  glPopMatrix();

}

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

TSelection *RasterSelectionTool::getSelection() { return &m_rasterSelection; }

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

bool RasterSelectionTool::isSelectionEmpty() {

  TImageP image    = getImage(false);

  TToonzImageP ti  = (TToonzImageP)image;

  TRasterImageP ri = (TRasterImageP)image;

  if (!ti && !ri) return true;

  return m_rasterSelection.isEmpty();

}

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

void RasterSelectionTool::computeBBox() {

  TImageP image    = getImage(false);

  TToonzImageP ti  = (TToonzImageP)image;

  TRasterImageP ri = (TRasterImageP)image;

  if (!ti && !ri) return;

  m_deformValues.reset();

  m_bboxs.clear();

  m_centers.clear();

  {

    std::vector<tstroke> strokes = m_rasterSelection.getStrokes();</tstroke>

    TRectD strokesRect           = m_rasterSelection.getStrokesBound(strokes);

    DragSelectionTool::FourPoints p;

    p = strokesRect;

    p = p * m_rasterSelection.getTransformation();

    m_bboxs.push_back(p);

    m_centers.push_back((p.getP00() + p.getP11()) * 0.5);

    m_rasterSelection.setSelectionBbox(strokesRect);

  }

  if (!m_freeDeformers.empty()) clearPointerContainer(m_freeDeformers);

  if (m_selectionFreeDeformer) {

    delete m_selectionFreeDeformer;

    m_selectionFreeDeformer = 0;

  }

  TTool::getApplication()->getCurrentTool()->notifyToolChanged();

}

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

void RasterSelectionTool::doOnActivate() {

  const TXshCell &imageCell = TTool::getImageCell();

  TImageP image =

      imageCell.getImage(false, 1);  // => See the onImageChanged() warning !

  TToonzImageP ti  = (TToonzImageP)image;

  TRasterImageP ri = (TRasterImageP)image;

  if (!ti && !ri) return;

  m_rasterSelection.makeCurrent();

  m_rasterSelection.setCurrentImage(image, imageCell);

  m_rasterSelection.selectNone();

  m_noAntialiasing.setValue(NoAntialiasing);

  m_rasterSelection.setNoAntialiasing(m_noAntialiasing.getValue());

}

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

void RasterSelectionTool::doOnDeactivate() {

  TTool::getApplication()->getCurrentSelection()->setSelection(0);