3bfa549e8b
- using std::string; - using std::wstring; - using std::ostream; - using std::istream; - using std::iostream; - using std::ostrstream; - using std::istrstream; - using std::fstream;
344 lines
8.3 KiB
C++
344 lines
8.3 KiB
C++
|
|
|
|
#include "tools/tool.h"
|
|
#include "tools/toolutils.h"
|
|
#include "toonz/txsheethandle.h"
|
|
#include "tools/toolhandle.h"
|
|
#include "toonz/tframehandle.h"
|
|
#include "toonz/tcolumnhandle.h"
|
|
#include "toonz/txshlevelhandle.h"
|
|
#include "tools/strokeselection.h"
|
|
#include "tools/tool.h"
|
|
|
|
#include "tmathutil.h"
|
|
#include "tstroke.h"
|
|
#include "tools/cursors.h"
|
|
#include "tundo.h"
|
|
#include "tvectorimage.h"
|
|
#include "tthreadmessage.h"
|
|
|
|
#include "toonzqt/imageutils.h"
|
|
#include "toonzqt/tselectionhandle.h"
|
|
|
|
#include "tgl.h"
|
|
|
|
using namespace ToolUtils;
|
|
|
|
//=============================================================================
|
|
namespace
|
|
{
|
|
|
|
//=============================================================================
|
|
// UndoCutter
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class UndoCutter : public ToolUtils::TToolUndo
|
|
{
|
|
int m_newStrokeId1;
|
|
int m_newStrokeId2;
|
|
int m_pos;
|
|
|
|
VIStroke *m_oldStroke;
|
|
|
|
std::vector<TFilledRegionInf> *m_fillInformation;
|
|
std::vector<DoublePair> *m_sortedWRanges;
|
|
|
|
int m_row;
|
|
int m_column;
|
|
|
|
public:
|
|
UndoCutter(TXshSimpleLevel *level,
|
|
const TFrameId &frameId,
|
|
VIStroke *oldStroke,
|
|
int pos,
|
|
int newStrokeId1,
|
|
int newStrokeId2,
|
|
std::vector<TFilledRegionInf> *fillInformation,
|
|
std::vector<DoublePair> *sortedWRanges)
|
|
: TToolUndo(level, frameId), m_oldStroke(oldStroke), m_newStrokeId1(newStrokeId1), m_newStrokeId2(newStrokeId2), m_pos(pos), m_fillInformation(fillInformation), m_sortedWRanges(sortedWRanges)
|
|
{
|
|
TTool::Application *app = TTool::getApplication();
|
|
if (app) {
|
|
m_row = app->getCurrentFrame()->getFrame();
|
|
m_column = app->getCurrentColumn()->getColumnIndex();
|
|
}
|
|
}
|
|
|
|
~UndoCutter()
|
|
{
|
|
deleteVIStroke(m_oldStroke);
|
|
delete m_sortedWRanges;
|
|
delete m_fillInformation;
|
|
}
|
|
|
|
void undo() const
|
|
{
|
|
TTool::Application *app = TTool::getApplication();
|
|
if (!app)
|
|
return;
|
|
if (dynamic_cast<StrokeSelection *>(TTool::getApplication()->getCurrentSelection()->getSelection()))
|
|
TTool::getApplication()->getCurrentSelection()->setSelection(0);
|
|
|
|
if (app->getCurrentFrame()->isEditingScene()) {
|
|
app->getCurrentColumn()->setColumnIndex(m_column);
|
|
app->getCurrentFrame()->setFrame(m_row);
|
|
} else
|
|
app->getCurrentFrame()->setFid(m_frameId);
|
|
TVectorImageP image = m_level->getFrame(m_frameId, true);
|
|
assert(!!image);
|
|
if (!image)
|
|
return;
|
|
QMutexLocker lock(image->getMutex());
|
|
VIStroke *stroke;
|
|
|
|
stroke = image->getStrokeById(m_newStrokeId1);
|
|
if (stroke)
|
|
image->deleteStroke(stroke);
|
|
|
|
stroke = image->getStrokeById(m_newStrokeId2);
|
|
if (stroke)
|
|
image->deleteStroke(stroke);
|
|
|
|
stroke = cloneVIStroke(m_oldStroke);
|
|
|
|
image->insertStrokeAt(stroke, m_pos);
|
|
|
|
UINT size = m_fillInformation->size();
|
|
if (!size) {
|
|
app->getCurrentXsheet()->notifyXsheetChanged();
|
|
notifyImageChanged();
|
|
return;
|
|
}
|
|
|
|
image->findRegions();
|
|
TRegion *reg;
|
|
for (UINT i = 0; i < size; i++) {
|
|
reg = image->getRegion((*m_fillInformation)[i].m_regionId);
|
|
assert(reg);
|
|
if (reg)
|
|
reg->setStyle((*m_fillInformation)[i].m_styleId);
|
|
}
|
|
app->getCurrentXsheet()->notifyXsheetChanged();
|
|
notifyImageChanged();
|
|
}
|
|
|
|
void redo() const
|
|
{
|
|
TTool::Application *app = TTool::getApplication();
|
|
if (!app)
|
|
return;
|
|
if (app->getCurrentFrame()->isEditingScene()) {
|
|
app->getCurrentColumn()->setColumnIndex(m_column);
|
|
app->getCurrentFrame()->setFrame(m_row);
|
|
} else
|
|
app->getCurrentFrame()->setFid(m_frameId);
|
|
TVectorImageP image = m_level->getFrame(m_frameId, true);
|
|
assert(!!image);
|
|
if (!image)
|
|
return;
|
|
QMutexLocker lock(image->getMutex());
|
|
|
|
bool isSelfLoop = image->getStroke(m_pos)->isSelfLoop();
|
|
image->splitStroke(m_pos, *m_sortedWRanges);
|
|
|
|
image->getStroke(m_pos)->setId(m_newStrokeId1);
|
|
if (!isSelfLoop && m_sortedWRanges->size() == 2)
|
|
image->getStroke(m_pos + 1)->setId(m_newStrokeId2);
|
|
|
|
app->getCurrentXsheet()->notifyXsheetChanged();
|
|
notifyImageChanged();
|
|
}
|
|
|
|
int getSize() const
|
|
{
|
|
return sizeof(*this) + m_fillInformation->capacity() * sizeof(TFilledRegionInf) + 500;
|
|
}
|
|
|
|
QString getToolName()
|
|
{
|
|
return QString("Cutter Tool");
|
|
}
|
|
};
|
|
|
|
//=============================================================================
|
|
// CutterTool
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class CutterTool : public TTool
|
|
{
|
|
|
|
public:
|
|
bool m_mouseDown;
|
|
|
|
TPointD m_vTan;
|
|
|
|
TThickPoint m_cursor;
|
|
TPointD m_speed;
|
|
int m_cursorId;
|
|
double m_pW;
|
|
|
|
CutterTool()
|
|
: TTool("T_Cutter"), m_mouseDown(false), m_cursorId(ToolCursor::CutterCursor)
|
|
{
|
|
bind(TTool::VectorImage);
|
|
}
|
|
|
|
ToolType getToolType() const { return TTool::LevelWriteTool; }
|
|
|
|
void draw()
|
|
{
|
|
//TAffine viewMatrix = getViewer()->getViewMatrix();
|
|
//glPushMatrix();
|
|
//tglMultMatrix(viewMatrix);
|
|
|
|
const double pixelSize = getPixelSize();
|
|
|
|
double len = m_cursor.thick + 15 * pixelSize;
|
|
|
|
if (m_speed != TPointD(0, 0)) {
|
|
|
|
TPointD v = m_speed;
|
|
TPointD p = (TPointD)m_cursor;
|
|
|
|
v = rotate90(v);
|
|
v = normalize(v);
|
|
|
|
v = v * (len);
|
|
|
|
tglColor(TPixelD(0.1, 0.9, 0.1));
|
|
tglDrawSegment(p - v, p + v);
|
|
}
|
|
//glPopMatrix();
|
|
}
|
|
|
|
void leftButtonDown(const TPointD &pos, const TMouseEvent &)
|
|
{
|
|
TVectorImageP vi = TImageP(getImage(true));
|
|
if (!vi)
|
|
return;
|
|
QMutexLocker sl(vi->getMutex());
|
|
|
|
double dist, pW;
|
|
UINT strokeIndex;
|
|
|
|
TStroke *strokeRef;
|
|
|
|
if (vi->getNearestStroke(pos, pW, strokeIndex, dist) && pW >= 0 && pW <= 1) {
|
|
double w;
|
|
|
|
strokeRef = vi->getStroke(strokeIndex);
|
|
|
|
double hitPointLen = strokeRef->getLength(pW);
|
|
double totalLen = strokeRef->getLength();
|
|
|
|
double len = hitPointLen;
|
|
|
|
if (!strokeRef->isSelfLoop()) {
|
|
if (len < TConsts::epsilon)
|
|
w = 0;
|
|
else
|
|
w = strokeRef->getParameterAtLength(len);
|
|
|
|
if (len > totalLen - TConsts::epsilon)
|
|
w = 1;
|
|
else
|
|
w = strokeRef->getParameterAtLength(len);
|
|
} else {
|
|
if (len < 0)
|
|
len += totalLen;
|
|
|
|
if (len > totalLen)
|
|
len -= totalLen;
|
|
|
|
w = strokeRef->getParameterAtLength(len);
|
|
}
|
|
|
|
std::vector<DoublePair> *sortedWRanges = new std::vector<DoublePair>;
|
|
|
|
if (strokeRef->isSelfLoop()) {
|
|
sortedWRanges->push_back(std::make_pair(0, w));
|
|
sortedWRanges->push_back(std::make_pair(w, 1));
|
|
} else {
|
|
if (w == 0 || w == 1)
|
|
sortedWRanges->push_back(std::make_pair(0, 1));
|
|
else {
|
|
sortedWRanges->push_back(std::make_pair(0, w));
|
|
sortedWRanges->push_back(std::make_pair(w, 1));
|
|
}
|
|
}
|
|
|
|
std::vector<TFilledRegionInf> *fillInformation = new std::vector<TFilledRegionInf>;
|
|
ImageUtils::getFillingInformationOverlappingArea(vi, *fillInformation, strokeRef->getBBox());
|
|
|
|
VIStroke *oldStroke = cloneVIStroke(vi->getVIStroke(strokeIndex));
|
|
bool isSelfLoop = vi->getStroke(strokeIndex)->isSelfLoop();
|
|
vi->splitStroke(strokeIndex, *sortedWRanges);
|
|
|
|
TUndo *nundo;
|
|
|
|
TXshSimpleLevel *sl = TTool::getApplication()->getCurrentLevel()->getSimpleLevel();
|
|
assert(sl);
|
|
TFrameId id = getCurrentFid();
|
|
if (isSelfLoop || sortedWRanges->size() == 1) {
|
|
nundo = new UndoCutter(sl, id, oldStroke, strokeIndex, vi->getStroke(strokeIndex)->getId(), -1, fillInformation, sortedWRanges);
|
|
} else {
|
|
assert(strokeIndex + 1 < vi->getStrokeCount());
|
|
nundo = new UndoCutter(sl, id, oldStroke, strokeIndex, vi->getStroke(strokeIndex)->getId(), vi->getStroke(strokeIndex + 1)->getId(), fillInformation, sortedWRanges);
|
|
}
|
|
|
|
TUndoManager::manager()->add(nundo);
|
|
|
|
invalidate();
|
|
notifyImageChanged();
|
|
}
|
|
invalidate();
|
|
}
|
|
|
|
void mouseMove(const TPointD &pos, const TMouseEvent &e)
|
|
{
|
|
TVectorImageP vi = TImageP(getImage(true));
|
|
if (!vi) {
|
|
m_speed = TPointD(0, 0);
|
|
return;
|
|
}
|
|
|
|
// select nearest stroke and finds its parameter
|
|
double dist, pW;
|
|
UINT stroke;
|
|
|
|
if (vi->getNearestStroke(pos, pW, stroke, dist)) {
|
|
TStroke *strokeRef = vi->getStroke(stroke);
|
|
m_speed = strokeRef->getSpeed(pW);
|
|
m_cursor = strokeRef->getThickPoint(pW);
|
|
m_pW = pW;
|
|
} else {
|
|
m_speed = TPointD(0, 0);
|
|
}
|
|
invalidate();
|
|
}
|
|
|
|
void onLeave()
|
|
{
|
|
m_speed = TPointD(0, 0);
|
|
}
|
|
|
|
void onActivate()
|
|
{
|
|
}
|
|
void onEnter()
|
|
{
|
|
if ((TVectorImageP)getImage(false))
|
|
m_cursorId = ToolCursor::CutterCursor;
|
|
else
|
|
m_cursorId = ToolCursor::CURSOR_NO;
|
|
}
|
|
|
|
int getCursorId() const { return m_cursorId; }
|
|
|
|
} cutterTool;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
} // namespace
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//TTool *getCutterTool() {return &cutterTool;}
|