#include "tools/tool.h"
#include "tools/toolutils.h"
#include "tools/cursors.h"
#include "tproperty.h"
#include "tdata.h"
#include "tconvert.h"
#include "tgl.h"
#include "tstroke.h"
#include "tvectorimage.h"
#include "hookselection.h"
#include "tools/toolhandle.h"
#include "toonzqt/selection.h"
#include "toonz/tframehandle.h"
#include "toonz/txshlevelhandle.h"
#include "toonz/tscenehandle.h"
#include "toonz/txsheethandle.h"
#include "toonz/tcolumnhandle.h"
#include "toonz/hook.h"
#include "toonz/txshlevel.h"
#include "toonz/toonzscene.h"
#include "toonz/txsheet.h"
#include "toonz/txshcell.h"
#include "toonz/txshcolumn.h"
#include "toonz/tstageobjecttree.h"
#include "toonz/txshsimplelevel.h"
#include "toonz/levelproperties.h"
#include "toonz/toonzimageutils.h"
#include "toonz/dpiscale.h"
#include "toonz/onionskinmask.h"
#include "toonz/tonionskinmaskhandle.h"
#include <math.h>
// For Qt translation support
#include <QCoreApplication>
#include <QPainter>
using namespace ToolUtils;
//=============================================================================
namespace {
//-----------------------------------------------------------------------------
//=============================================================================
// OtherHook
//-----------------------------------------------------------------------------
class OtherHook {
public:
int m_columnIndex;
int m_hookIndex;
TPointD m_hookPos;
OtherHook(int columnIndex, int hookIndex, const TPointD &hookPos)
: m_columnIndex(columnIndex)
, m_hookIndex(hookIndex)
, m_hookPos(hookPos) {}
};
} // namespace
//=============================================================================
// HookTool
//-----------------------------------------------------------------------------
class HookTool : public TTool {
Q_DECLARE_TR_FUNCTIONS(HookTool)
HookSelection m_selection;
TPointD m_firstPos, m_lastPos;
int m_hookId, m_hookSide;
bool m_deselectArmed;
HookUndo *m_undo;
std::vector<OtherHook> m_otherHooks;
TPropertyGroup m_prop;
TBoolProperty m_snappedActive;
TPointD m_snappedPos;
std::string m_snappedReason;
TRectD m_shapeBBox;
bool m_snapped, m_hookSetChanged;
bool m_buttonDown;
TPointD m_pivotOffset;
void getOtherHooks(std::vector<OtherHook> &otherHooks);
public:
HookTool();
ToolType getToolType() const override { return TTool::LevelReadTool; }
HookSet *getHookSet() const;
void updateTranslation() override;
void draw() override;
void leftButtonDown(const TPointD &pos, const TMouseEvent &e) override;
void leftButtonDrag(const TPointD &pos, const TMouseEvent &e) override;
void leftButtonUp(const TPointD &pos, const TMouseEvent &) override;
void mouseMove(const TPointD &pos, const TMouseEvent &e) override;
void onActivate() override;
void onDeactivate() override;
void onEnter() override;
void onImageChanged() override {
m_selection.selectNone();
m_hookId = -1;
m_otherHooks.clear();
getOtherHooks(m_otherHooks);
invalidate();
}
TPropertyGroup *getProperties(int targetType) override { return &m_prop; }
int getCursorId() const override { return ToolCursor::MoveCursor; }
void onSelectionChanged() { invalidate(); }
bool select(const TSelection *) { return false; }
bool pick(int &hookId, int &side, const TPointD &pos);
bool snap(TPointD &pos, double &range2);
bool isSnappedActive() const { return m_snappedActive.getValue(); }
bool isEditingScene() const {
return getApplication()->getCurrentFrame()->isEditingScene();
}
// pivot is the hook the level is attached to.
// returns -1 if no pivot is defined.
// Hook1 <==> index=0
int getPivotIndex() {
if (!isEditingScene())
return -1; // a pivot can be defined only when editing a scene
std::string handle =
getXsheet()->getStageObject(getObjectId())->getHandle();
if (handle.find("H") != 0) return -1;
return std::stoi(handle.substr(1)) - 1;
}
void drawHooks(HookSet *hookSet, const TFrameId &fid, bool isOnion);
// other hooks are drawn in the current level reference frame
// when the current matrix changes (e.g. because of a parent change or a
// handle change)
// we must recompute the hooks positions
void updateMatrix() override {
TTool::updateMatrix();
m_otherHooks.clear();
getOtherHooks(m_otherHooks);
}
} hookTool;
//-----------------------------------------------------------------------------
HookTool::HookTool()
: TTool("T_Hook")
, m_hookId(-1)
, m_hookSide(0)
, m_deselectArmed(false)
, m_undo(0)
, m_snappedActive("Snap", true) // W_ToolOptions_Snapped
, m_snappedPos()
, m_snappedReason("")
, m_shapeBBox()
, m_snapped(false)
, m_hookSetChanged(false)
, m_buttonDown(false)
, m_pivotOffset() {
bind(TTool::CommonLevels);
m_prop.bind(m_snappedActive);
m_snappedActive.setId("Snap");
}
//-----------------------------------------------------------------------------
void HookTool::updateTranslation() {
m_snappedActive.setQStringName(tr("Snap"));
}
//-----------------------------------------------------------------------------
HookSet *HookTool::getHookSet() const {
TXshLevel *xl = TTool::getApplication()->getCurrentLevel()->getLevel();
if (!xl) return 0;
return xl->getHookSet();
}
//-----------------------------------------------------------------------------
//
// search for hooks located on other columns (they are used as a reference)
// the position of hooks is computed in the current level reference frame
//
void HookTool::getOtherHooks(std::vector<OtherHook> &otherHooks) {
if (!getViewer()) return;
TPointD dpi = getViewer()->getDpiScale();
TAffine myAffInv = (getCurrentColumnMatrix() * TScale(dpi.x, dpi.y)).inv();
TXsheet *xsh = getXsheet();
int row = getFrame();
int curCol = getColumnIndex();
int i;
for (i = 0; i < xsh->getColumnCount(); i++) {
if (!xsh->getColumn(i) || !xsh->getColumn(i)->isCamstandVisible()) continue;
if (i == curCol) continue;
TXshCell cell = xsh->getCell(row, i);
if (cell.isEmpty()) continue;
TAffine aff =
myAffInv * xsh->getPlacement(TStageObjectId::ColumnId(i), row);
if (cell.getSimpleLevel())
aff = aff * getDpiAffine(cell.getSimpleLevel(), cell.m_frameId, true);
HookSet *hookSet = cell.m_level->getHookSet();
int j;
for (j = 0; j < hookSet->getHookCount(); j++) {
Hook *hook = hookSet->getHook(j);
if (hook == 0 || hook->isEmpty()) continue;
TPointD aPos = aff * hook->getAPos(cell.m_frameId);
TPointD bPos = aff * hook->getBPos(cell.m_frameId);
otherHooks.push_back(OtherHook(i, j, aPos));
}
}
}
//-----------------------------------------------------------------------------
void HookTool::drawHooks(HookSet *hookSet, const TFrameId &fid, bool isOnion) {
int pivotIndex = getPivotIndex();
int i;
for (i = 0; i < hookSet->getHookCount(); i++) {
Hook *hook = hookSet->getHook(i);
if (!hook || hook->isEmpty()) continue;
assert(hook);
TPointD p0 = hook->getAPos(fid);
TPointD p1 = hook->getBPos(fid);
if (pivotIndex == i) {
// translating the pivot doesn't change its actual position, but just the
// m_pivotOffset
// the actual pivot position is changed in the mouseUp event
p0 += m_pivotOffset;
p1 += m_pivotOffset;
}
bool linked = p0 == p1;
drawHook(p0, linked ? NormalHook : PassHookA, m_selection.isSelected(i, 1),
isOnion);
if (!linked) drawHook(p1, PassHookB, m_selection.isSelected(i, 2), isOnion);
}
}
//-----------------------------------------------------------------------------
void HookTool::draw() {
// ToolUtils::drawRect(TRectD(10,10,110,110), TPixel32(255,200,200), 0xFFF0);
// draw the current image bounding box
const double v200 = 200.0 / 255.0;
TImageP image = getImage(false);
if (!image) return;
TToonzImageP ti = image;
TVectorImageP vi = image;
if (ti) {
TRectD bbox =
ToonzImageUtils::convertRasterToWorld(convert(ti->getBBox()), ti);
ToolUtils::drawRect(bbox * ti->getSubsampling(), TPixel32(200, 200, 200),
0x5555);
}
if (vi) {
TRectD bbox = vi->getBBox();
ToolUtils::drawRect(bbox, TPixel32(200, 200, 200), 0x5555);
}
// draw hooks
HookSet *hookSet = getHookSet();
if (!hookSet) return;
TTool::Application *app = TTool::getApplication();
TFrameHandle *fh = app->getCurrentFrame();
TFrameId fid = getCurrentFid();
TXshSimpleLevel *level = 0;
OnionSkinMask osm = app->getCurrentOnionSkin()->getOnionSkinMask();
std::vector<int> os;
if (isEditingScene())
osm.getAll(getFrame(), os);
else {
level = app->getCurrentLevel()->getSimpleLevel();
assert(level);
osm.getAll(level->guessIndex(fid), os);
}
int i;
if (osm.isEnabled())
for (i = 0; i < (int)os.size(); i++) {
if (isEditingScene()) {
const TXshCell &cell = getXsheet()->getCell(
os[i], app->getCurrentColumn()->getColumnIndex());
drawHooks(hookSet, cell.getFrameId(), true);
} else {
const TFrameId &fid2 = level->index2fid(os[i]);
drawHooks(hookSet, fid2, true);
}
}
drawHooks(hookSet, fid, false);
// TXshCell cell = xsh->getCell(row, i);
// draw other level hooks
if (isSnappedActive() && isEditingScene()) {
for (i = 0; i < (int)m_otherHooks.size(); i++) {
drawHook(m_otherHooks[i].m_hookPos, OtherLevelHook, false);
}
}
// draw hooks balloons
std::vector<TRectD> balloons; // this is used to avoid balloons overlapping
int pivotIndex = getPivotIndex();
for (i = 0; i < hookSet->getHookCount(); i++) {
Hook *hook = hookSet->getHook(i);
if (!hook || hook->isEmpty()) continue;
assert(hook);
TPointD p0 = hook->getAPos(fid);
TPointD p1 = hook->getBPos(fid);
bool linked = p0 == p1;
if (i == pivotIndex) {
p0 += m_pivotOffset;
p1 += m_pivotOffset;
}
TPixel32 balloonColor(200, 220, 205, 200);
TPoint balloonOffset(20, 20);
std::string hookName = std::to_string(i + 1);
drawBalloon(p0, hookName, balloonColor, balloonOffset, false, &balloons);
if (!linked)
drawBalloon(p1, hookName, balloonColor, balloonOffset, false, &balloons);
}
// draw snapped hook balloon
if (m_snappedReason != "") {
TPointD pos = m_snappedPos;
TRectD bbox = m_shapeBBox;
if (bbox.getLx() > 0 && bbox.getLy() > 0) {
glColor3d(v200, v200, v200);
glEnable(GL_LINE_STIPPLE);
glLineStipple(5, 0xAAAA);
tglDrawRect(bbox);
glDisable(GL_LINE_STIPPLE);
glBegin(GL_LINES);
glVertex2d(pos.x, bbox.y0);
glVertex2d(pos.x, bbox.y1);
glVertex2d(bbox.x0, pos.y);
glVertex2d(bbox.x1, pos.y);
glEnd();
glDisable(GL_LINE_STIPPLE);
}
drawBalloon(pos, m_snappedReason, TPixel32(200, 250, 180, 200),
TPoint(20, 20), false, &balloons);
}
}
//-----------------------------------------------------------------------------
// side : 1=A,2=B,3=A&B
bool HookTool::pick(int &hookId, int &side, const TPointD &pos) {
HookSet *hookSet = getHookSet();
if (!hookSet) return false;
TFrameId fid = getCurrentFid();
double minDist2 = 1e8;
for (int i = 0; i < hookSet->getHookCount(); i++) {
Hook *hook = hookSet->getHook(i);
if (!hook || hook->isEmpty()) continue;
TPointD aPos = hook->getAPos(fid);
TPointD bPos = hook->getBPos(fid);
bool linked = aPos == bPos;
if (linked) {
double dist2 = tdistance2(pos, aPos);
if (dist2 < minDist2) {
minDist2 = dist2;
hookId = hook->getId();
side = 3;
}
} else {
double aDist2 = tdistance2(pos, aPos);
double bDist2 = tdistance2(pos, bPos);
double dist2 = aDist2;
int s = 1;
if (bDist2 < dist2) {
dist2 = bDist2;
s = 2;
}
if (dist2 < minDist2) {
minDist2 = dist2;
hookId = hook->getId();
side = s;
}
}
}
double pixelSize = getPixelSize();
return minDist2 < 100 * pixelSize * pixelSize;
}
//-----------------------------------------------------------------------------
void HookTool::leftButtonDown(const TPointD &pos, const TMouseEvent &e) {
TTool::Application *app = TTool::getApplication();
if (!app) return;
m_buttonDown = true;
m_snapped = false;
TXshLevel *xl = app->getCurrentLevel()->getLevel();
if (xl && xl->getSimpleLevel()) m_undo = new HookUndo(xl->getSimpleLevel());
m_selection.setLevel(xl);
m_firstPos = m_lastPos = pos;
m_hookId = -1, m_hookSide = 0;
m_deselectArmed = false;
if (pick(m_hookId, m_hookSide, pos)) {
if (m_hookSide == 3) // ho cliccato su un cerchio-croce
{
if (e.isAltPressed()) // con l'alt voglio dividere
{
m_selection.selectNone();
m_selection.select(m_hookId, 2);
} else if (e.isCtrlPressed()) {
// se sono tutti e due selezionati li deseleziono
if (m_selection.isSelected(m_hookId, 1) &&
m_selection.isSelected(m_hookId, 2)) {
m_selection.unselect(m_hookId, 1);
m_selection.unselect(m_hookId, 2);
} else // altrimenti li seleziono tutti e due
{
m_selection.select(m_hookId, 1);
m_selection.select(m_hookId, 2);
}
} else {
// senza control ne' shift ne' alt: se ho cliccato su un hook non
// selezionato
// deseleziono tutti gli altri e lo seleziono, altrimenti lascio tutto
// com'e' e al buttonup se non c'e' stato movimento deseleziono gli
// altri
if (m_selection.isSelected(m_hookId, 1) ||
m_selection.isSelected(m_hookId, 2))
m_deselectArmed = true;
else {
m_selection.selectNone();
m_selection.select(m_hookId, 1);
m_selection.select(m_hookId, 2);
}
}
} else // ho cliccato o su un cerchio o su una croce
{
if (e.isCtrlPressed())
m_selection.invertSelection(m_hookId, m_hookSide);
else {
m_selection.selectNone();
m_selection.select(m_hookId, m_hookSide);
}
}
} else {
// non ho cliccato su nulla: con ctrl non faccio nulla, senza creo un nuovo
// hook
if (!e.isCtrlPressed()) {
m_selection.selectNone();
TFrameId fid = getCurrentFid();
HookSet *hookSet = getHookSet();
if (hookSet && xl->getSimpleLevel() &&
!xl->getSimpleLevel()->isReadOnly()) {
Hook *hook = hookSet->addHook();
m_hookSetChanged = true;
if (hook) {
TPointD ppos(pos);
if (m_snappedReason != "") {
m_snapped = true;
ppos = m_snappedPos;
}
m_snappedReason = "";
hook->setAPos(fid, ppos);
ppos = hook->getAPos(fid);
m_selection.select(hook->getId(), 1);
m_selection.select(hook->getId(), 2);
}
}
}
}
m_pivotOffset = TPointD();
m_selection.makeCurrent();
invalidate();
}
//-----------------------------------------------------------------------------
void HookTool::leftButtonDrag(const TPointD &pp, const TMouseEvent &e) {
TTool::Application *app = TTool::getApplication();
if (!app) return;
if (m_snapped) return;
TFrameId fid = getCurrentFid();
// cerco di capire se sto muovendo un unico hook "unito"
TPointD hookPos;
HookSet *hookSet = getHookSet();
if (!hookSet) return;
bool draggingPivot = false;
int pivotIndex = getPivotIndex();
int i, count = 0;
for (i = 0; i < hookSet->getHookCount(); i++) {
Hook *hook = hookSet->getHook(i);
if (!hook || hook->isEmpty()) continue;
TPointD aPos = hook->getAPos(fid);
TPointD bPos = hook->getBPos(fid);
if (m_selection.isSelected(i, 1) && m_selection.isSelected(i, 2) &&
aPos == bPos) {
count++;
hookPos = aPos;
} else if (m_selection.isSelected(i, 1) || m_selection.isSelected(i, 2)) {
count = 0;
break;
}
if (i == pivotIndex && m_selection.isSelected(i, 1)) draggingPivot = true;
}
TPointD pos(pp);
TPointD delta = pos - m_lastPos;
if (e.isShiftPressed()) {
// se e' pigiato lo shift non snappa e si muove solo in
// orizzontale/verticale
TPointD d = pos - m_firstPos;
if (d.x * d.x > d.y * d.y)
pos.y = m_firstPos.y;
else
pos.x = m_firstPos.x;
delta = pos - m_lastPos;
} else if (count == 1 && isSnappedActive() && !draggingPivot) {
// snappa
TPointD oldHookPos = hookPos;
hookPos += pos - m_lastPos;
double range2 = getPixelSize() * 20;
range2 *= range2;
m_snappedReason = "";
m_shapeBBox = TRectD();
if (snap(hookPos, range2)) {
delta = hookPos - oldHookPos;
pos = delta + m_lastPos;
}
} else if (count > 1 && isSnappedActive() && !draggingPivot) {
TPointD oldHookPos = hookPos;
// delta = pos - m_lastPos;
TPointD snappedDelta = delta;
double range2 = getPixelSize() * 20;
range2 *= range2;
m_snappedReason = "";
m_shapeBBox = TRectD();
for (i = 0; i < hookSet->getHookCount(); i++) {
Hook *hook = hookSet->getHook(i);
if (hook && !hook->isEmpty()) {
if (m_selection.isSelected(i, 1)) {
TPointD p0 = hook->getAPos(fid);
TPointD p1 = p0 + delta;
if (snap(p1, range2)) snappedDelta = p1 - p0;
}
if (m_selection.isSelected(i, 1)) {
TPointD p0 = hook->getBPos(fid);
TPointD p1 = p0 + delta;
if (snap(p1, range2)) snappedDelta = p1 - p0;
}
}
}
pos = m_lastPos + snappedDelta;
delta = snappedDelta;
}
m_lastPos = pos;
TXsheet *xsh = getXsheet();
// std::string handle =
// getXsheet()->getStageObject(TStageObjectId::ColumnId())->getHandle();
// actual movement
for (i = 0; i < hookSet->getHookCount(); i++) {
Hook *hook = hookSet->getHook(i);
if (!hook || hook->isEmpty()) continue;
TPointD aPos = hook->getAPos(fid);
TPointD bPos = hook->getBPos(fid);
bool aSelected = m_selection.isSelected(i, 1);
bool bSelected = m_selection.isSelected(i, 2);
if (pivotIndex == i) {
if (aSelected) {
m_pivotOffset += delta;
if (!bSelected) hook->setBPos(fid, bPos - delta);
} else if (bSelected)
hook->setBPos(fid, bPos + delta);
} else {
if (aSelected) hook->setAPos(fid, aPos + delta);
if (bSelected) hook->setBPos(fid, bPos + delta);
}
m_hookSetChanged = true;
}
getXsheet()->getStageObjectTree()->invalidateAll();
invalidate();
}
//-----------------------------------------------------------------------------
void HookTool::leftButtonUp(const TPointD &pos, const TMouseEvent &) {
TTool::Application *app = TTool::getApplication();
if (!app) return;
// note: apparently sometimes (when the user triple-clicks) we receive this
// event twice
if (!m_buttonDown) return;
m_buttonDown = false;
// if I've moved the pivot hook I have to perform the actual movement in the
// mouse up event
int pivotIndex = getPivotIndex();
if (m_selection.isSelected(pivotIndex, 1) && m_pivotOffset != TPointD()) {
HookSet *hookSet = getHookSet();
if (hookSet) {
Hook *hook = hookSet->getHook(pivotIndex);
if (hook && !hook->isEmpty()) {
TFrameId fid = getCurrentFid();
TPointD aPos = hook->getAPos(fid);
TPointD bPos = hook->getBPos(fid);
hook->setAPos(fid, aPos + m_pivotOffset);
hook->setBPos(fid, bPos + m_pivotOffset);
getXsheet()->getStageObjectTree()->invalidateAll();
updateMatrix();
}
}
}
m_snapped = false;
// m_selection.selectNone();
TXshLevel *xl = app->getCurrentLevel()->getLevel();
if (!xl || !xl->getSimpleLevel()) return;
xl->getSimpleLevel()->getProperties()->setDirtyFlag(true);
TPointD delta = m_lastPos - m_firstPos;
if (m_deselectArmed && norm2(delta) < 10) {
m_selection.selectNone();
m_selection.unselect(m_hookId, 1);
m_selection.unselect(m_hookId, 2);
}
m_deselectArmed = false;
if (m_undo && m_hookSetChanged)
TUndoManager::manager()->add(m_undo);
else {
delete m_undo;
m_undo = 0;
}
m_hookSetChanged = false;
m_pivotOffset = TPointD();
}
//-----------------------------------------------------------------------------
bool HookTool::snap(TPointD &pos, double &range2) {
bool ret = false;
TPointD snappedPos = pos;
TVectorImageP vi = TImageP(getImage(false));
TStroke *selectedShape = 0;
TRectD selectedShapeBBox;
double selectedShapeBBoxArea = 0;
int i, n;
n = vi ? (int)vi->getStrokeCount() : 0;
for (i = 0; i < n; i++) {
TStroke *stroke = vi->getStroke(i);
if (!stroke->isSelfLoop()) continue;
TRectD bbox = stroke->getBBox();
TPointD strokeCenter = 0.5 * (bbox.getP00() + bbox.getP11());
if (bbox.contains(pos)) {
double dist2 = norm2(pos - strokeCenter);
if (dist2 < range2) {
double bboxArea = bbox.getLx() * bbox.getLy();
if (selectedShape == 0 || selectedShapeBBoxArea > bboxArea) {
range2 = dist2;
selectedShape = stroke;
selectedShapeBBox = bbox;
selectedShapeBBoxArea = bboxArea;
}
}
}
}
if (selectedShape) {
m_shapeBBox = selectedShapeBBox;
snappedPos =
0.5 * (selectedShapeBBox.getP00() + selectedShapeBBox.getP11());
m_snappedPos = snappedPos;
m_snappedReason = "shape center";
ret = true;
}
int k = -1;
if (isEditingScene()) {
for (i = 0; i < (int)m_otherHooks.size(); i++) {
double dist2 = norm2(pos - m_otherHooks[i].m_hookPos);
if (dist2 < range2) {
range2 = dist2;
k = i;
}
}
}
if (k >= 0) {
m_shapeBBox = TRectD();
snappedPos = m_otherHooks[k].m_hookPos;
m_snappedPos = snappedPos;
m_snappedReason = "Col" +
std::to_string(m_otherHooks[k].m_columnIndex + 1) + "/" +
std::to_string(m_otherHooks[k].m_hookIndex + 1);
ret = true;
}
pos = snappedPos;
return ret;
}
//-----------------------------------------------------------------------------
void HookTool::mouseMove(const TPointD &pos, const TMouseEvent &e) {
std::string oldReason = m_snappedReason;
TPointD oldPos = m_snappedPos;
m_snappedPos = TPointD();
m_snappedReason = "";
m_shapeBBox = TRectD();
m_otherHooks.clear();
getOtherHooks(m_otherHooks);
int hookId, side;
if (pick(hookId, side, pos)) {
if (oldReason != "") invalidate();
return;
}
if (isSnappedActive()) {
double range2 = getPixelSize() * 20.0;
range2 *= range2;
TPointD snappedPos = pos;
snap(snappedPos, range2);
}
if (m_snappedReason != oldReason || m_snappedPos != oldPos) invalidate();
}
//-----------------------------------------------------------------------------
void HookTool::onActivate() {
// TODO: getApplication()->editImageOrSpline();
m_otherHooks.clear();
getOtherHooks(m_otherHooks);
m_selection.makeCurrent();
}
//-----------------------------------------------------------------------------
void HookTool::onDeactivate() {
m_selection.selectNone();
TSelection::setCurrent(0);
}
//-----------------------------------------------------------------------------
void HookTool::onEnter() { m_selection.makeCurrent(); }