775 lines
24 KiB
C++
775 lines
24 KiB
C++
|
|
|
|
#include "tools/imagegrouping.h"
|
|
|
|
// TnzTools includes
|
|
#include "tools/strokeselection.h"
|
|
#include "tools/tool.h"
|
|
#include "tools/toolhandle.h"
|
|
#include "tools/toolutils.h"
|
|
#include "vectorselectiontool.h"
|
|
|
|
// TnzQt includes
|
|
#include "toonzqt/tselectionhandle.h"
|
|
#include "toonzqt/selectioncommandids.h"
|
|
|
|
// TnzLib includes
|
|
#include "toonz/tscenehandle.h"
|
|
#include "toonz/txshlevelhandle.h"
|
|
|
|
// TnzCore includes
|
|
#include "tvectorimage.h"
|
|
#include "tundo.h"
|
|
#include "tthreadmessage.h"
|
|
|
|
// Qt includes
|
|
#include <QMenu>
|
|
|
|
//=============================================================================
|
|
namespace {
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void groupWithoutUndo(TVectorImage *vimg, StrokeSelection *selection) {
|
|
int count = 0, fromStroke = -1, lastSelected = -1;
|
|
|
|
for (int i = 0; i < (int)vimg->getStrokeCount(); i++)
|
|
if (selection->isSelected(i)) {
|
|
if (fromStroke == -1)
|
|
fromStroke = i;
|
|
else if (lastSelected != i - 1) // non sono contigui gli stroke
|
|
// selezionati: faccio affiorare quelli
|
|
// sotto
|
|
{
|
|
int j = 0;
|
|
for (j = 0; j < count; j++) selection->select(fromStroke + j, false);
|
|
vimg->moveStrokes(fromStroke, count, i);
|
|
fromStroke = i - count;
|
|
for (j = 0; j < count; j++) selection->select(fromStroke + j, true);
|
|
}
|
|
lastSelected = i;
|
|
count++;
|
|
}
|
|
|
|
assert(count > 0);
|
|
|
|
vimg->group(fromStroke, count);
|
|
TTool::getApplication()->getCurrentTool()->getTool()->notifyImageChanged();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ungroupWithoutUndo(TVectorImage *vimg, StrokeSelection *selection) {
|
|
for (int i = 0; i < (int)vimg->getStrokeCount();)
|
|
if (selection->isSelected(i)) {
|
|
if (!vimg->isStrokeGrouped(i)) {
|
|
i++;
|
|
continue;
|
|
}
|
|
i += vimg->ungroup(i);
|
|
} else
|
|
i++;
|
|
TTool::getApplication()->getCurrentTool()->getTool()->notifyImageChanged();
|
|
}
|
|
|
|
//=============================================================================
|
|
// GroupUndo
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class GroupUndo : public ToolUtils::TToolUndo {
|
|
std::auto_ptr<StrokeSelection> m_selection;
|
|
|
|
public:
|
|
GroupUndo(TXshSimpleLevel *level, const TFrameId &frameId,
|
|
StrokeSelection *selection)
|
|
: ToolUtils::TToolUndo(level, frameId), m_selection(selection) {}
|
|
|
|
void undo() const {
|
|
TVectorImageP image = m_level->getFrame(m_frameId, true);
|
|
if (image) ungroupWithoutUndo(image.getPointer(), m_selection.get());
|
|
}
|
|
|
|
void redo() const {
|
|
TVectorImageP image = m_level->getFrame(m_frameId, true);
|
|
if (image) groupWithoutUndo(image.getPointer(), m_selection.get());
|
|
}
|
|
|
|
int getSize() const { return sizeof(*this); }
|
|
|
|
QString getToolName() { return QObject::tr("Group"); }
|
|
};
|
|
|
|
//=============================================================================
|
|
// UngroupUndo
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class UngroupUndo : public ToolUtils::TToolUndo {
|
|
std::auto_ptr<StrokeSelection> m_selection;
|
|
|
|
public:
|
|
UngroupUndo(TXshSimpleLevel *level, const TFrameId &frameId,
|
|
StrokeSelection *selection)
|
|
: ToolUtils::TToolUndo(level, frameId), m_selection(selection) {}
|
|
|
|
void undo() const {
|
|
TVectorImageP image = m_level->getFrame(m_frameId, true);
|
|
if (image) groupWithoutUndo(image.getPointer(), m_selection.get());
|
|
}
|
|
|
|
void redo() const {
|
|
TVectorImageP image = m_level->getFrame(m_frameId, true);
|
|
if (image) ungroupWithoutUndo(image.getPointer(), m_selection.get());
|
|
}
|
|
|
|
int getSize() const { return sizeof(*this); }
|
|
|
|
QString getToolName() { return QObject::tr("Ungroup"); }
|
|
};
|
|
|
|
//=============================================================================
|
|
// MoveGroupUndo
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class MoveGroupUndo : public ToolUtils::TToolUndo {
|
|
UCHAR m_moveType;
|
|
int m_refStroke, m_count, m_moveBefore;
|
|
std::vector<std::pair<TStroke *, int>> m_selectedGroups;
|
|
|
|
public:
|
|
MoveGroupUndo(TXshSimpleLevel *level, const TFrameId &frameId, UCHAR moveType,
|
|
int refStroke, int count, int moveBefore,
|
|
const std::vector<std::pair<TStroke *, int>> &selectedGroups)
|
|
: ToolUtils::TToolUndo(level, frameId)
|
|
, m_moveType(moveType)
|
|
, m_refStroke(refStroke)
|
|
, m_count(count)
|
|
, m_moveBefore(moveBefore)
|
|
, m_selectedGroups(selectedGroups) {}
|
|
|
|
~MoveGroupUndo() {}
|
|
|
|
void undo() const {
|
|
int refStroke;
|
|
int moveBefore;
|
|
switch (m_moveType) {
|
|
case TGroupCommand::FRONT:
|
|
refStroke = m_moveBefore - m_count;
|
|
moveBefore = m_refStroke;
|
|
break;
|
|
case TGroupCommand::FORWARD:
|
|
refStroke = m_moveBefore - m_count;
|
|
moveBefore = m_refStroke;
|
|
break;
|
|
case TGroupCommand::BACK:
|
|
refStroke = m_moveBefore;
|
|
moveBefore = m_refStroke + m_count;
|
|
break;
|
|
case TGroupCommand::BACKWARD:
|
|
refStroke = m_moveBefore;
|
|
moveBefore = m_refStroke + m_count;
|
|
break;
|
|
default:
|
|
assert(!"group move not defined!");
|
|
break;
|
|
}
|
|
TVectorImageP image = m_level->getFrame(m_frameId, true);
|
|
if (!image) return;
|
|
QMutexLocker lock(image->getMutex());
|
|
image->moveStrokes(refStroke, m_count, moveBefore);
|
|
StrokeSelection *selection = dynamic_cast<StrokeSelection *>(
|
|
TTool::getApplication()->getCurrentSelection()->getSelection());
|
|
if (selection) { // Se la selezione corrente e' la StrokeSelection
|
|
// seleziono gli stroke che ho modificato con l'undo
|
|
selection->selectNone();
|
|
|
|
for (int i = 0; i < (int)m_selectedGroups.size(); i++) {
|
|
int index = image->getStrokeIndex(m_selectedGroups[i].first);
|
|
if (index == -1) continue;
|
|
for (int j = index; j < index + m_selectedGroups[i].second; j++)
|
|
selection->select(j, true);
|
|
}
|
|
}
|
|
TTool::getApplication()->getCurrentScene()->notifySceneChanged();
|
|
notifyImageChanged();
|
|
}
|
|
|
|
void redo() const {
|
|
TVectorImageP image = m_level->getFrame(m_frameId, true);
|
|
if (!image) return;
|
|
QMutexLocker lock(image->getMutex());
|
|
image->moveStrokes(m_refStroke, m_count, m_moveBefore);
|
|
StrokeSelection *selection = dynamic_cast<StrokeSelection *>(
|
|
TTool::getApplication()->getCurrentSelection()->getSelection());
|
|
if (selection) { // Se la selezione corrente e' la StrokeSelection
|
|
// seleziono gli stroke che ho modificato con il redo
|
|
selection->selectNone();
|
|
|
|
for (int i = 0; i < (int)m_selectedGroups.size(); i++) {
|
|
int index = image->getStrokeIndex(m_selectedGroups[i].first);
|
|
if (index == -1) continue;
|
|
for (int j = index; j < index + m_selectedGroups[i].second; j++)
|
|
selection->select(j, true);
|
|
}
|
|
}
|
|
TTool::getApplication()->getCurrentScene()->notifySceneChanged();
|
|
notifyImageChanged();
|
|
}
|
|
|
|
int getSize() const { return sizeof(*this); }
|
|
|
|
QString getToolName() { return QObject::tr("Move Group"); }
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
} // namespace
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// TGroupCommand
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace {
|
|
|
|
std::vector<std::pair<TStroke *, int>> getSelectedGroups(TVectorImage *vimg,
|
|
StrokeSelection *sel) {
|
|
UINT i, j;
|
|
std::vector<std::pair<TStroke *, int>> ret;
|
|
|
|
for (i = 0; i < vimg->getStrokeCount(); i++)
|
|
if (sel->isSelected(i)) {
|
|
if (vimg->isStrokeGrouped(i)) {
|
|
for (j = i + 1; j < vimg->getStrokeCount() && vimg->sameSubGroup(i, j);
|
|
j++)
|
|
if (!sel->isSelected(j))
|
|
return std::vector<std::pair<TStroke *, int>>();
|
|
ret.push_back(std::pair<TStroke *, int>(vimg->getStroke(i), j - i));
|
|
i = j - 1;
|
|
} else
|
|
ret.push_back(std::pair<TStroke *, int>(vimg->getStroke(i), 1));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
} // namepsace
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
|
|
UCHAR TGroupCommand::getGroupingOptions() {
|
|
TTool *tool = TTool::getApplication()->getCurrentTool()->getTool();
|
|
if (!tool) return 0;
|
|
TVectorImage *vimg = dynamic_cast<TVectorImage *>(tool->getImage(false));
|
|
if (!vimg) return 0;
|
|
|
|
UCHAR mask = 0;
|
|
int count = 0;
|
|
UINT i, j;
|
|
|
|
// spostamento: si possono spostare solo gruppi interi oppure stroke non
|
|
// gruppate
|
|
|
|
std::vector<std::pair<TStroke *, int>> strokeIndexes =
|
|
getSelectedGroups(vimg, m_sel);
|
|
|
|
/*
|
|
//spostamento: si puo' spostare solo un gruppo(e uno solo per volta) oppure
|
|
una stroke singola non gruppata
|
|
for (i=0; i<vimg->getStrokeCount(); i++)
|
|
if (m_sel->isSelected(i))
|
|
{
|
|
if (strokeIndex != -1)
|
|
{
|
|
if (!vimg->isStrokeGrouped(i) ||
|
|
!vimg->sameSubGroup(strokeIndex, i))
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
strokeIndex = i;
|
|
if (vimg->isStrokeGrouped(i))
|
|
{
|
|
for (j=0; j<vimg->getStrokeCount(); j++)
|
|
if (!m_sel->isSelected(j) &&
|
|
vimg->sameSubGroup(i, j))
|
|
break;//non tutto il gruppo e'
|
|
selezionato
|
|
if (j<vimg->getStrokeCount())
|
|
break;
|
|
}
|
|
}
|
|
count++;
|
|
}
|
|
*/
|
|
|
|
if (strokeIndexes.empty()) return 0; // no stroke selected
|
|
|
|
int strokeIndex = vimg->getStrokeIndex(strokeIndexes[0].first);
|
|
|
|
if (strokeIndexes.size() > 1 || strokeIndex > 0) {
|
|
mask |= BACK;
|
|
mask |= BACKWARD;
|
|
}
|
|
if (strokeIndexes.size() > 1 ||
|
|
strokeIndex + strokeIndexes[0].second - 1 <
|
|
(int)vimg->getStrokeCount() - 1) {
|
|
mask |= FRONT;
|
|
mask |= FORWARD;
|
|
}
|
|
|
|
/*
|
|
if (i == vimg->getStrokeCount())
|
|
{
|
|
if (strokeIndex+count<(int)vimg->getStrokeCount())
|
|
{
|
|
mask |= FRONT;
|
|
mask |= FORWARD;
|
|
}
|
|
if (strokeIndex>0)
|
|
{
|
|
mask |= BACK;
|
|
mask |= BACKWARD;
|
|
}
|
|
}
|
|
*/
|
|
|
|
// PER l'UNGROUP: si ungruppa solo se tutti gli stroke selezionati stanno nel
|
|
// gruppo (anche piu' gruppi insieme)
|
|
|
|
for (i = 0; i < vimg->getStrokeCount(); i++) {
|
|
if (m_sel->isSelected(i)) {
|
|
if (!vimg->isStrokeGrouped(i)) break;
|
|
for (j = 0; j < vimg->getStrokeCount(); j++)
|
|
if (!m_sel->isSelected(j) && vimg->sameSubGroup(i, j)) break;
|
|
if (j < vimg->getStrokeCount()) break;
|
|
}
|
|
}
|
|
if (i == vimg->getStrokeCount()) mask |= UNGROUP;
|
|
|
|
// PER il GROUP: si raggruppa solo se:
|
|
// //almeno una delle stroke selezionate non fa parte di gruppi o e' di un
|
|
// gruppo diverso
|
|
// e se c'e' una stroke di un gruppo, allora tutto il gruppo della stroke e'
|
|
// selezionato
|
|
|
|
bool groupingMakesSense = false;
|
|
int refStroke = -1;
|
|
for (i = 0; i < vimg->getStrokeCount(); i++)
|
|
if (m_sel->isSelected(i)) {
|
|
if (vimg->isStrokeGrouped(i)) {
|
|
if (refStroke == -1)
|
|
refStroke = i;
|
|
else if (!vimg->sameSubGroup(refStroke, i))
|
|
groupingMakesSense = true; // gli storke selezionati non sono gia'
|
|
// tutti dello stesso gruppo
|
|
for (j = 0; j < vimg->getStrokeCount(); j++)
|
|
if (!m_sel->isSelected(j) && vimg->sameGroup(i, j)) return mask;
|
|
} else
|
|
groupingMakesSense = true;
|
|
}
|
|
|
|
if (groupingMakesSense) mask |= GROUP;
|
|
|
|
return mask;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifdef NUOVO
|
|
|
|
UCHAR TGroupCommand::getGroupingOptions() {
|
|
TTool *tool = TTool::getApplication()->getCurrentTool()->getTool();
|
|
if (!tool) return 0;
|
|
TVectorImage *vimg = dynamic_cast<TVectorImage *>(tool->getImage(false));
|
|
if (!vimg) return 0;
|
|
|
|
int strokeIndex = -1;
|
|
UCHAR mask = 0;
|
|
int count = 0;
|
|
UINT i, j;
|
|
bool valid = true;
|
|
// spostamento: si puo' spostare solo un gruppo(e uno solo per volta) oppure
|
|
// una stroke singola non gruppata
|
|
std::vector<pair<int, int>> groups;
|
|
|
|
for (i = 0; i < vimg->getStrokeCount() && valid;)
|
|
if (m_sel->isSelected(i)) {
|
|
strokeIndex = i;
|
|
count = 1;
|
|
if (vimg->isStrokeGrouped(i)) {
|
|
for (j = i + 1; j < vimg->getStrokeCount() && valid; j++)
|
|
if (m_sel->isSelected(j) && vimg->sameSubGroup(i, j))
|
|
count++;
|
|
else if (!m_sel->isSelected(j) && vimg->sameSubGroup(i, j))
|
|
valid = false; // non tutto il gruppo e' selezionato
|
|
}
|
|
groups.push_back(pair<int, int>(strokeIndex, count));
|
|
|
|
i = i + count;
|
|
}
|
|
|
|
if (groups.empty()) return 0; // no stroke selected
|
|
|
|
if (!valid) return 0;
|
|
|
|
if (strokeIndex + count < (int)vimg->getStrokeCount()) {
|
|
mask |= FRONT;
|
|
mask |= FORWARD;
|
|
}
|
|
if (strokeIndex > 0) {
|
|
mask |= BACK;
|
|
mask |= BACKWARD;
|
|
}
|
|
|
|
// PER l'UNGROUP: si ungruppa solo se tutti gli stroke selezionati stanno nel
|
|
// gruppo (anche piu' gruppi insieme)
|
|
|
|
for (i = 0; i < vimg->getStrokeCount(); i++) {
|
|
if (m_sel->isSelected(i)) {
|
|
if (!vimg->isStrokeGrouped(i)) break;
|
|
for (j = 0; j < vimg->getStrokeCount(); j++)
|
|
if (!m_sel->isSelected(j) && vimg->sameSubGroup(i, j)) break;
|
|
if (j < vimg->getStrokeCount()) break;
|
|
}
|
|
}
|
|
if (i == vimg->getStrokeCount()) mask |= UNGROUP;
|
|
|
|
// PER il GROUP: si raggruppa solo se:
|
|
// //almeno una delle stroke selezionate non fa parte di gruppi o e' di un
|
|
// gruppo diverso
|
|
// e se c'e' una stroke di un gruppo, allora tutto il gruppo della stroke e'
|
|
// selezionato
|
|
|
|
bool groupingMakesSense = false;
|
|
int refStroke = -1;
|
|
for (i = 0; i < vimg->getStrokeCount(); i++)
|
|
if (m_sel->isSelected(i)) {
|
|
if (vimg->isStrokeGrouped(i)) {
|
|
if (refStroke == -1)
|
|
refStroke = i;
|
|
else if (!vimg->sameSubGroup(refStroke, i))
|
|
groupingMakesSense = true; // gli storke selezionati non sono gia'
|
|
// tutti dello stesso gruppo
|
|
for (j = 0; j < vimg->getStrokeCount(); j++)
|
|
if (!m_sel->isSelected(j) && vimg->sameGroup(i, j)) return mask;
|
|
} else
|
|
groupingMakesSense = true;
|
|
}
|
|
|
|
if (groupingMakesSense) mask |= GROUP;
|
|
|
|
return mask;
|
|
}
|
|
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TGroupCommand::group() {
|
|
if (!(getGroupingOptions() & GROUP)) return;
|
|
|
|
TTool *tool = TTool::getApplication()->getCurrentTool()->getTool();
|
|
if (!tool) return;
|
|
TVectorImage *vimg = (TVectorImage *)tool->getImage(true);
|
|
|
|
if (!vimg) return;
|
|
QMutexLocker lock(vimg->getMutex());
|
|
groupWithoutUndo(vimg, m_sel);
|
|
TXshSimpleLevel *level =
|
|
TTool::getApplication()->getCurrentLevel()->getSimpleLevel();
|
|
TUndoManager::manager()->add(
|
|
new GroupUndo(level, tool->getCurrentFid(), new StrokeSelection(*m_sel)));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TGroupCommand::enterGroup() {
|
|
TTool *tool = TTool::getApplication()->getCurrentTool()->getTool();
|
|
if (!tool) return;
|
|
TVectorImage *vimg = (TVectorImage *)tool->getImage(true);
|
|
|
|
if (!vimg) return;
|
|
int index = -1;
|
|
|
|
for (int i = 0; i < (int)vimg->getStrokeCount(); i++)
|
|
if (m_sel->isSelected(i)) {
|
|
index = i;
|
|
break;
|
|
}
|
|
|
|
if (index == -1) return;
|
|
|
|
if (!vimg->canEnterGroup(index)) return;
|
|
vimg->enterGroup(index);
|
|
TSelection *selection = TSelection::getCurrent();
|
|
if (selection) selection->selectNone();
|
|
|
|
TTool::getApplication()->getCurrentScene()->notifySceneChanged();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TGroupCommand::exitGroup() {
|
|
TTool *tool = TTool::getApplication()->getCurrentTool()->getTool();
|
|
if (!tool) return;
|
|
TVectorImage *vimg = (TVectorImage *)tool->getImage(true);
|
|
|
|
if (!vimg) return;
|
|
vimg->exitGroup();
|
|
TTool::getApplication()->getCurrentScene()->notifySceneChanged();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TGroupCommand::ungroup() {
|
|
if (!(getGroupingOptions() & UNGROUP)) return;
|
|
TTool *tool = TTool::getApplication()->getCurrentTool()->getTool();
|
|
if (!tool) return;
|
|
TVectorImage *vimg = (TVectorImage *)tool->getImage(true);
|
|
if (!vimg) return;
|
|
QMutexLocker lock(vimg->getMutex());
|
|
ungroupWithoutUndo(vimg, m_sel);
|
|
TXshSimpleLevel *level =
|
|
TTool::getApplication()->getCurrentLevel()->getSimpleLevel();
|
|
TUndoManager::manager()->add(new UngroupUndo(level, tool->getCurrentFid(),
|
|
new StrokeSelection(*m_sel)));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/*
|
|
void computeMovingBounds(TVectorImage*vimg, int fromIndex, int toIndex,
|
|
int&lower, int& upper)
|
|
{
|
|
lower = 0;
|
|
upper = vimg->getStrokeCount();
|
|
|
|
int refDepth = vimg->getGroupDepth(fromIndex)-1;
|
|
|
|
if (refDepth==0)
|
|
return;
|
|
|
|
int i;
|
|
for (i=fromIndex-1; i>=0; i--)
|
|
if (vimg->getCommonGroupDepth(fromIndex, i)<refDepth)
|
|
{
|
|
lower = i+1;
|
|
break;
|
|
}
|
|
|
|
for (i=fromIndex+1; i<vimg->getStrokeCount(); i++)
|
|
if (vimg->getCommonGroupDepth(fromIndex, i)<refDepth)
|
|
{
|
|
upper = i;
|
|
break;
|
|
}
|
|
}
|
|
*/
|
|
//-----------------------------------------------------------------------------
|
|
namespace {
|
|
|
|
int commonDepth(TVectorImage *vimg, int index1, int count, int index2) {
|
|
int i, ret = 1000;
|
|
for (i = index1; i < index1 + count; i++)
|
|
ret = std::min(ret, vimg->getCommonGroupDepth(i, index2));
|
|
return ret;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/*
|
|
bool cantMove1(TVectorImage* vimg, int refStroke, int count, int moveBefore,
|
|
bool rev)
|
|
{
|
|
if (moveBefore<(int)vimg->getStrokeCount() && moveBefore>0 &&
|
|
vimg->getCommonGroupDepth(moveBefore-1,
|
|
moveBefore)>commonDepth(vimg, refStroke, count, moveBefore) &&
|
|
vimg->getCommonGroupDepth(moveBefore-1,
|
|
moveBefore)>commonDepth(vimg, refStroke, count, moveBefore-1))
|
|
return true;
|
|
|
|
int prev = (rev)?moveBefore:moveBefore-1;
|
|
|
|
if (refStroke>0 && commonDepth(vimg, refStroke, count,
|
|
refStroke-1)>commonDepth(vimg, refStroke, count, prev))
|
|
return true;
|
|
if (refStroke+count<(int)vimg->getStrokeCount() && commonDepth(vimg,
|
|
refStroke, count, refStroke+count)>commonDepth(vimg, refStroke, count, prev))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
*/
|
|
|
|
} // namespace
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/*
|
|
int i, refStroke=-1, count=0;
|
|
for (i=0; i<(int)vimg->getStrokeCount(); i++)
|
|
if(m_sel->isSelected(i))
|
|
{
|
|
assert(refStroke==-1 || i==0 || m_sel->isSelected(i-1));
|
|
if (refStroke==-1)
|
|
refStroke = i;
|
|
count++;
|
|
}
|
|
|
|
if(count==0) return;
|
|
*/
|
|
|
|
int doMoveGroup(UCHAR moveType, TVectorImage *vimg,
|
|
const std::vector<std::pair<TStroke *, int>> &selectedGroups,
|
|
int index) {
|
|
int refStroke = vimg->getStrokeIndex(selectedGroups[index].first);
|
|
int count = selectedGroups[index].second;
|
|
|
|
int moveBefore;
|
|
switch (moveType) {
|
|
case TGroupCommand::FRONT:
|
|
moveBefore = vimg->getStrokeCount();
|
|
|
|
while (moveBefore >= refStroke + count + 1 &&
|
|
!vimg->canMoveStrokes(refStroke, count, moveBefore))
|
|
moveBefore--;
|
|
if (moveBefore == refStroke + count) return -1;
|
|
|
|
break;
|
|
case TGroupCommand::FORWARD:
|
|
moveBefore = refStroke + count + 1;
|
|
while (moveBefore <= (int)vimg->getStrokeCount() &&
|
|
!vimg->canMoveStrokes(refStroke, count, moveBefore))
|
|
moveBefore++;
|
|
if (moveBefore == vimg->getStrokeCount() + 1) return -1;
|
|
break;
|
|
case TGroupCommand::BACK:
|
|
moveBefore = 0;
|
|
while (moveBefore <= refStroke - 1 &&
|
|
!vimg->canMoveStrokes(refStroke, count, moveBefore))
|
|
moveBefore++;
|
|
if (moveBefore == refStroke) return -1;
|
|
break;
|
|
case TGroupCommand::BACKWARD:
|
|
moveBefore = refStroke - 1;
|
|
while (moveBefore >= 0 &&
|
|
!vimg->canMoveStrokes(refStroke, count, moveBefore))
|
|
moveBefore--;
|
|
if (moveBefore == -1) return -1;
|
|
break;
|
|
default:
|
|
assert(false);
|
|
}
|
|
|
|
vimg->moveStrokes(refStroke, count, moveBefore);
|
|
|
|
TXshSimpleLevel *level =
|
|
TTool::getApplication()->getCurrentLevel()->getSimpleLevel();
|
|
TTool *tool = TTool::getApplication()->getCurrentTool()->getTool();
|
|
TUndoManager::manager()->add(new MoveGroupUndo(level, tool->getCurrentFid(),
|
|
moveType, refStroke, count,
|
|
moveBefore, selectedGroups));
|
|
|
|
return moveBefore;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TGroupCommand::moveGroup(UCHAR moveType) {
|
|
TTool *tool = TTool::getApplication()->getCurrentTool()->getTool();
|
|
if (!tool) return;
|
|
|
|
TVectorImage *vimg = (TVectorImage *)tool->getImage(true);
|
|
if (!vimg) return;
|
|
|
|
std::vector<std::pair<TStroke *, int>> selectedGroups =
|
|
getSelectedGroups(vimg, m_sel);
|
|
if (selectedGroups.empty()) return;
|
|
|
|
int i, j;
|
|
|
|
TUndoManager::manager()->beginBlock();
|
|
|
|
switch (moveType) {
|
|
case TGroupCommand::FRONT:
|
|
case TGroupCommand::BACKWARD:
|
|
i = 0;
|
|
if (moveType == TGroupCommand::BACKWARD &&
|
|
vimg->getStrokeIndex(selectedGroups[i].first) ==
|
|
0) // tutti i gruppi adiacenti gia in fondo non possono essere
|
|
// backwardati
|
|
{
|
|
i++;
|
|
while (i < (int)selectedGroups.size() &&
|
|
vimg->getStrokeIndex(selectedGroups[i - 1].first) +
|
|
selectedGroups[i - 1].second - 1 ==
|
|
vimg->getStrokeIndex(selectedGroups[i].first) - 1)
|
|
i++;
|
|
}
|
|
for (; i <= (int)selectedGroups.size() - 1; i++)
|
|
doMoveGroup(moveType, vimg, selectedGroups,
|
|
i); // vimg->getStrokeIndex(selectedGroups[i].first),
|
|
// selectedGroups[i].second);
|
|
break;
|
|
|
|
case TGroupCommand::BACK:
|
|
case TGroupCommand::FORWARD:
|
|
i = selectedGroups.size() - 1;
|
|
if (moveType == TGroupCommand::FORWARD &&
|
|
vimg->getStrokeIndex(selectedGroups[i].first) +
|
|
selectedGroups[i].second - 1 ==
|
|
vimg->getStrokeCount() - 1) // tutti i gruppi adiacenti gia in cime
|
|
// non possono essere forwardati
|
|
{
|
|
i--;
|
|
while (i >= 0 &&
|
|
vimg->getStrokeIndex(selectedGroups[i + 1].first) - 1 ==
|
|
vimg->getStrokeIndex(selectedGroups[i].first) +
|
|
selectedGroups[i].second - 1)
|
|
i--;
|
|
}
|
|
for (; i >= 0; i--) doMoveGroup(moveType, vimg, selectedGroups, i);
|
|
break;
|
|
|
|
default:
|
|
assert(false);
|
|
}
|
|
|
|
TUndoManager::manager()->endBlock();
|
|
|
|
m_sel->selectNone();
|
|
|
|
for (i = 0; i < (int)selectedGroups.size(); i++) {
|
|
int index = vimg->getStrokeIndex(selectedGroups[i].first);
|
|
for (j = index; j < index + selectedGroups[i].second; j++)
|
|
m_sel->select(j, true);
|
|
}
|
|
|
|
tool->notifyImageChanged();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TGroupCommand::addMenuItems(QMenu *menu) {
|
|
UCHAR optionMask = getGroupingOptions();
|
|
if (optionMask == 0) return;
|
|
|
|
CommandManager *cm = CommandManager::instance();
|
|
|
|
if (optionMask & TGroupCommand::GROUP)
|
|
menu->addAction(cm->getAction(MI_Group));
|
|
|
|
if (optionMask & TGroupCommand::UNGROUP)
|
|
menu->addAction(cm->getAction(MI_Ungroup));
|
|
|
|
if (optionMask & (TGroupCommand::GROUP | TGroupCommand::UNGROUP) &&
|
|
optionMask & (TGroupCommand::FORWARD | TGroupCommand::BACKWARD))
|
|
menu->addSeparator();
|
|
|
|
if (optionMask & TGroupCommand::FORWARD) {
|
|
menu->addAction(cm->getAction(MI_BringToFront));
|
|
menu->addAction(cm->getAction(MI_BringForward));
|
|
}
|
|
if (optionMask & TGroupCommand::BACKWARD) {
|
|
menu->addAction(cm->getAction(MI_SendBack));
|
|
menu->addAction(cm->getAction(MI_SendBackward));
|
|
}
|
|
menu->addSeparator();
|
|
}
|