776 lines
23 KiB
C++
776 lines
23 KiB
C++
|
|
|
|
#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 final : 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, getPixelSize(), false, &balloons);
|
|
if (!linked)
|
|
drawBalloon(p1, hookName, balloonColor, balloonOffset, getPixelSize(), 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), getPixelSize(), 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(); }
|