550 lines
17 KiB
C++
550 lines
17 KiB
C++
|
|
|
|
#include "toonzqt/schematicgroupeditor.h"
|
|
#include "toonzqt/fxschematicnode.h"
|
|
#include "toonzqt/fxschematicscene.h"
|
|
#include "toonzqt/stageschematicnode.h"
|
|
#include "toonzqt/stageschematicscene.h"
|
|
#include "toonzqt/schematicnode.h"
|
|
#include "toonzqt/gutil.h"
|
|
#include "toonz/fxcommand.h"
|
|
#include "toonz/tstageobjectcmd.h"
|
|
#include "toonz/tstageobject.h"
|
|
#include "tfxattributes.h"
|
|
#include "tmacrofx.h"
|
|
#include <QAction>
|
|
#include <QMenu>
|
|
#include <QGraphicsSceneContextMenuEvent>
|
|
|
|
//=====================================================
|
|
//
|
|
// SchematicGroupEditor
|
|
//
|
|
//=====================================================
|
|
|
|
SchematicWindowEditor::SchematicWindowEditor(
|
|
const QList<SchematicNode *> &groupedNode, SchematicScene *scene)
|
|
#if QT_VERSION >= 0x050000
|
|
: QGraphicsItem()
|
|
#else
|
|
: QGraphicsItem(0, scene)
|
|
#endif
|
|
, m_groupedNode(groupedNode)
|
|
, m_scene(scene)
|
|
, m_lastPos()
|
|
, m_button(Qt::NoButton)
|
|
, m_isMacroEditor(false) {
|
|
#if QT_VERSION >= 0x050000
|
|
scene->addItem(this);
|
|
#endif
|
|
m_nameItem = new SchematicName(this, 67, 14);
|
|
m_nameItem->setPos(-2, -2);
|
|
m_nameItem->setZValue(1);
|
|
m_nameItem->hide();
|
|
connect(m_nameItem, SIGNAL(focusOut()), this, SLOT(onNameChanged()));
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
SchematicWindowEditor::~SchematicWindowEditor() {}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
QRectF SchematicWindowEditor::boundingRect() const {
|
|
QRectF rect = boundingSceneRect();
|
|
rect.moveTopLeft(QPointF(0, 0));
|
|
rect.adjust(-1, -1, 1, 1);
|
|
return rect;
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void SchematicWindowEditor::paint(QPainter *painter,
|
|
const QStyleOptionGraphicsItem *option,
|
|
QWidget *widget) {
|
|
painter->setPen(QColor(0, 0, 0, 255));
|
|
if (m_isMacroEditor)
|
|
painter->setBrush(QColor(132, 86, 123, 255));
|
|
else
|
|
painter->setBrush(QColor(76, 148, 177, 255));
|
|
QRectF bRect = boundingRect();
|
|
QRectF rect(0, 0, bRect.width(), 15);
|
|
painter->drawRect(rect);
|
|
rect = QRectF(0, 15, bRect.width(), bRect.height() - 15);
|
|
painter->setBrush(QColor(180, 180, 180, 125));
|
|
painter->drawRect(rect);
|
|
|
|
// draw the topRight cross
|
|
rect = QRectF(0, 0, 11, 11);
|
|
rect.moveTopLeft(QPointF(bRect.width() - 13, 2));
|
|
painter->drawRoundedRect(rect, 2, 2);
|
|
painter->setPen(Qt::black);
|
|
painter->drawLine(QPointF(rect.left() + 2, rect.top() + 2),
|
|
QPointF(rect.right() - 2, rect.bottom() - 2));
|
|
painter->drawLine(QPointF(rect.left() + 2, rect.bottom() - 2),
|
|
QPointF(rect.right() - 2, rect.top() + 2));
|
|
|
|
if (!m_nameItem->isVisible()) {
|
|
painter->setPen(Qt::white);
|
|
QFont font("Verdana", 7);
|
|
painter->setFont(font);
|
|
QRectF rect = QRectF(2, 1, bRect.width() - 15, 13);
|
|
QString elidedName = elideText(m_groupName, font, rect.width());
|
|
painter->drawText(rect, elidedName);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void SchematicWindowEditor::resizeNodes(bool maximizeNodes) {
|
|
prepareGeometryChange();
|
|
doResizeNodes(maximizeNodes);
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void SchematicWindowEditor::mousePressEvent(QGraphicsSceneMouseEvent *e) {
|
|
QRectF bRect = boundingRect();
|
|
QRectF rect = QRectF(0, 0, 11, 11);
|
|
rect.moveTopLeft(QPointF(bRect.width() - 13, 2));
|
|
if (rect.contains(e->pos())) {
|
|
closeEditor();
|
|
return;
|
|
}
|
|
|
|
rect = QRectF(0, 0, bRect.width(), 15);
|
|
if (rect.contains(e->pos())) {
|
|
m_button = e->button();
|
|
m_lastPos = e->scenePos();
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void SchematicWindowEditor::mouseMoveEvent(QGraphicsSceneMouseEvent *e) {
|
|
if (m_button == Qt::LeftButton) {
|
|
QPointF delta = e->scenePos() - m_lastPos;
|
|
setPos(scenePos() + delta);
|
|
m_lastPos = e->scenePos();
|
|
int i;
|
|
for (i = 0; i < m_groupedNode.size(); i++) {
|
|
SchematicNode *node = m_groupedNode[i];
|
|
node->setPosition(node->scenePos() + delta);
|
|
node->setSchematicNodePos(node->scenePos());
|
|
node->updateLinksGeometry();
|
|
}
|
|
} else
|
|
e->ignore();
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void SchematicWindowEditor::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) {
|
|
m_button = Qt::NoButton;
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void SchematicWindowEditor::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *e) {
|
|
QRectF bRect = boundingRect();
|
|
QRectF rect = QRectF(2, 0, bRect.width() - 15, 15);
|
|
if (rect.contains(e->pos())) {
|
|
m_nameItem->setPlainText(m_groupName);
|
|
m_nameItem->show();
|
|
m_nameItem->setFocus();
|
|
setFlag(QGraphicsItem::ItemIsSelectable, false);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void SchematicWindowEditor::contextMenuEvent(
|
|
QGraphicsSceneContextMenuEvent *e) {
|
|
QRectF bRect = boundingRect();
|
|
QRectF rect(0, 0, bRect.width(), 15);
|
|
if (!rect.contains(e->pos())) {
|
|
e->ignore();
|
|
return;
|
|
}
|
|
QMenu menu(scene()->views()[0]);
|
|
QAction *close = new QAction(tr("&Close Editor"), &menu);
|
|
connect(close, SIGNAL(triggered()), this, SLOT(closeEditor()));
|
|
|
|
menu.addAction(close);
|
|
menu.exec(e->screenPos());
|
|
}
|
|
|
|
//=====================================================
|
|
//
|
|
// FxSchematicGroupEditor
|
|
//
|
|
//=====================================================
|
|
|
|
FxSchematicGroupEditor::FxSchematicGroupEditor(
|
|
int groupId, const QList<SchematicNode *> &groupedNode,
|
|
SchematicScene *scene)
|
|
: SchematicWindowEditor(groupedNode, scene), m_groupId(groupId) {
|
|
initializeEditor();
|
|
setPos(boundingSceneRect().topLeft());
|
|
m_nameItem->setName(m_groupName);
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
FxSchematicGroupEditor::~FxSchematicGroupEditor() {}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void FxSchematicGroupEditor::initializeEditor() {
|
|
FxSchematicNode *node = dynamic_cast<FxSchematicNode *>(m_groupedNode[0]);
|
|
assert(node);
|
|
TFx *fx = node->getFx();
|
|
assert(fx);
|
|
assert(m_groupId == fx->getAttributes()->getEditingGroupId());
|
|
m_groupName =
|
|
QString::fromStdWString(fx->getAttributes()->getEditingGroupName());
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void FxSchematicGroupEditor::closeEditor() {
|
|
// Ptrebbero esserci delle macro aperte per edit nel gruppo...
|
|
// devo chiedere alla scena di chiuderle per me... da qui non posso farlo!
|
|
FxSchematicScene *fxScene = dynamic_cast<FxSchematicScene *>(scene());
|
|
assert(fxScene);
|
|
fxScene->closeInnerMacroEditor(m_groupId);
|
|
int i;
|
|
for (i = 0; i < m_groupedNode.size(); i++) {
|
|
FxSchematicNode *node = dynamic_cast<FxSchematicNode *>(m_groupedNode[i]);
|
|
if (!node) continue;
|
|
FxGroupNode *groupNode = dynamic_cast<FxGroupNode *>(node);
|
|
if (groupNode) {
|
|
QList<TFxP> fxs = groupNode->getGroupedFxs();
|
|
assert(!fxs.isEmpty());
|
|
int j;
|
|
for (j = 0; j < fxs.size(); j++) {
|
|
fxs[j]->getAttributes()->closeEditingGroup(m_groupId);
|
|
TMacroFx *macro = dynamic_cast<TMacroFx *>(fxs[j].getPointer());
|
|
if (macro) {
|
|
std::vector<TFxP> macroFxs = macro->getFxs();
|
|
int j;
|
|
for (j = 0; j < (int)macroFxs.size(); j++)
|
|
macroFxs[j]->getAttributes()->closeEditingGroup(m_groupId);
|
|
}
|
|
}
|
|
} else {
|
|
TFx *fx = node->getFx();
|
|
assert(fx);
|
|
fx->getAttributes()->closeEditingGroup(m_groupId);
|
|
TMacroFx *macro = dynamic_cast<TMacroFx *>(fx);
|
|
if (macro) {
|
|
std::vector<TFxP> macroFxs = macro->getFxs();
|
|
int j;
|
|
for (j = 0; j < (int)macroFxs.size(); j++)
|
|
macroFxs[j]->getAttributes()->closeEditingGroup(m_groupId);
|
|
}
|
|
}
|
|
}
|
|
m_scene->updateScene();
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void FxSchematicGroupEditor::onNameChanged() {
|
|
int i;
|
|
QList<TFxP> fxs;
|
|
m_nameItem->hide();
|
|
m_groupName = m_nameItem->toPlainText();
|
|
for (i = 0; i < m_groupedNode.size(); i++) {
|
|
FxGroupNode *groupNode = dynamic_cast<FxGroupNode *>(m_groupedNode[i]);
|
|
FxSchematicNode *node = dynamic_cast<FxSchematicNode *>(m_groupedNode[i]);
|
|
if (groupNode)
|
|
fxs.append(groupNode->getGroupedFxs());
|
|
else if (node)
|
|
fxs.append(node->getFx());
|
|
}
|
|
setFlag(QGraphicsItem::ItemIsSelectable, true);
|
|
FxSchematicScene *fxScene = dynamic_cast<FxSchematicScene *>(scene());
|
|
if (!fxScene) return;
|
|
TFxCommand::renameGroup(fxs.toStdList(), m_groupName.toStdWString(), true,
|
|
fxScene->getXsheetHandle());
|
|
update();
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
QRectF FxSchematicGroupEditor::boundingSceneRect() const {
|
|
QRectF rect = m_groupedNode[0]->boundingRect();
|
|
rect.moveTopLeft(m_groupedNode[0]->scenePos() - rect.topLeft());
|
|
int i;
|
|
for (i = 0; i < m_groupedNode.size(); i++) {
|
|
FxSchematicNode *node = dynamic_cast<FxSchematicNode *>(m_groupedNode[i]);
|
|
assert(node);
|
|
TFx *fx = node->getFx();
|
|
assert(fx);
|
|
QRectF app = node->boundingRect();
|
|
app.moveTopLeft(node->scenePos() - app.topLeft());
|
|
bool isASubgroupedNode =
|
|
fx->getAttributes()->getEditingGroupId() != m_groupId;
|
|
if (isASubgroupedNode) {
|
|
QStack<int> idStack = fx->getAttributes()->getGroupIdStack();
|
|
int start = idStack.indexOf(fx->getAttributes()->getEditingGroupId());
|
|
int k = idStack.indexOf(m_groupId, start) + 1;
|
|
int factor = k * 30;
|
|
app.adjust(-factor, -factor, factor, factor);
|
|
}
|
|
#if QT_VERSION >= 0x050000
|
|
rect = rect.united(app);
|
|
#else
|
|
rect = rect.unite(app);
|
|
#endif
|
|
}
|
|
rect.adjust(-20, -35, 0, 20);
|
|
return rect;
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void FxSchematicGroupEditor::setGroupedNodeZValue(int zValue) {
|
|
int i, size = m_groupedNode.size();
|
|
for (i = 0; i < size; i++) {
|
|
FxSchematicNode *node = dynamic_cast<FxSchematicNode *>(m_groupedNode[i]);
|
|
if (!node) continue;
|
|
if (node->getFx()->getAttributes()->getEditingGroupId() == m_groupId)
|
|
node->setZValue(zValue);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void FxSchematicGroupEditor::doResizeNodes(bool maximizeNodes) {}
|
|
|
|
//=====================================================
|
|
//
|
|
// FxSchematicMacroEditor
|
|
//
|
|
//=====================================================
|
|
|
|
FxSchematicMacroEditor::FxSchematicMacroEditor(
|
|
TMacroFx *macro, const QList<SchematicNode *> &groupedNode,
|
|
SchematicScene *scene)
|
|
: SchematicWindowEditor(groupedNode, scene), m_macro(macro) {
|
|
m_isMacroEditor = true;
|
|
initializeEditor();
|
|
setPos(boundingSceneRect().topLeft());
|
|
m_nameItem->setName(m_groupName);
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
FxSchematicMacroEditor::~FxSchematicMacroEditor() {}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void FxSchematicMacroEditor::initializeEditor() {
|
|
m_groupName = QString::fromStdWString(m_macro->getName());
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void FxSchematicMacroEditor::closeEditor() {
|
|
m_macro->editMacro(false);
|
|
m_scene->updateScene();
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void FxSchematicMacroEditor::onNameChanged() {
|
|
QList<TFxP> fxs;
|
|
m_nameItem->hide();
|
|
m_groupName = m_nameItem->toPlainText();
|
|
setFlag(QGraphicsItem::ItemIsSelectable, true);
|
|
FxSchematicScene *fxScene = dynamic_cast<FxSchematicScene *>(scene());
|
|
if (!fxScene) return;
|
|
TFxCommand::renameFx(m_macro, m_groupName.toStdWString(),
|
|
fxScene->getXsheetHandle());
|
|
update();
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
QRectF FxSchematicMacroEditor::boundingSceneRect() const {
|
|
QRectF rect = m_groupedNode[0]->boundingRect();
|
|
rect.moveTopLeft(m_groupedNode[0]->scenePos() - rect.topLeft());
|
|
int i;
|
|
for (i = 0; i < m_groupedNode.size(); i++) {
|
|
FxSchematicNode *node = dynamic_cast<FxSchematicNode *>(m_groupedNode[i]);
|
|
assert(node);
|
|
TFx *fx = node->getFx();
|
|
assert(fx);
|
|
QRectF app = node->boundingRect();
|
|
app.moveTopLeft(node->scenePos() - app.topLeft());
|
|
#if QT_VERSION >= 0x050000
|
|
rect = rect.united(app);
|
|
#else
|
|
rect = rect.unite(app);
|
|
#endif
|
|
}
|
|
rect.adjust(-20, -35, 0, 20);
|
|
return rect;
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void FxSchematicMacroEditor::setGroupedNodeZValue(int zValue) {
|
|
int i, size = m_groupedNode.size();
|
|
for (i = 0; i < size; i++) {
|
|
FxSchematicNode *node = dynamic_cast<FxSchematicNode *>(m_groupedNode[i]);
|
|
if (!node) continue;
|
|
node->setZValue(zValue);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void FxSchematicMacroEditor::mouseMoveEvent(QGraphicsSceneMouseEvent *e) {
|
|
SchematicWindowEditor::mouseMoveEvent(e);
|
|
if (m_button == Qt::LeftButton) {
|
|
TFx *root = m_macro->getRoot();
|
|
TPointD pos = root->getAttributes()->getDagNodePos();
|
|
m_macro->getAttributes()->setDagNodePos(pos);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void FxSchematicMacroEditor::doResizeNodes(bool maximizeNodes) {
|
|
m_macro->getAttributes()->setIsOpened(maximizeNodes);
|
|
}
|
|
|
|
//=====================================================
|
|
//
|
|
// StageSchematicGroupEditor
|
|
//
|
|
//=====================================================
|
|
|
|
StageSchematicGroupEditor::StageSchematicGroupEditor(
|
|
int groupId, const QList<SchematicNode *> &groupedNode,
|
|
SchematicScene *scene)
|
|
: SchematicWindowEditor(groupedNode, scene), m_groupId(groupId) {
|
|
initializeEditor();
|
|
setPos(boundingSceneRect().topLeft());
|
|
m_nameItem->setName(m_groupName);
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
StageSchematicGroupEditor::~StageSchematicGroupEditor() {}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
QRectF StageSchematicGroupEditor::boundingSceneRect() const {
|
|
QRectF rect = m_groupedNode[0]->boundingRect();
|
|
rect.moveTopLeft(m_groupedNode[0]->scenePos() - rect.topLeft());
|
|
int i;
|
|
for (i = 0; i < m_groupedNode.size(); i++) {
|
|
StageSchematicNode *node =
|
|
dynamic_cast<StageSchematicNode *>(m_groupedNode[i]);
|
|
assert(node);
|
|
TStageObject *obj = node->getStageObject();
|
|
assert(obj);
|
|
QRectF app = node->boundingRect();
|
|
app.moveTopLeft(node->scenePos() - app.topLeft());
|
|
bool isASubgroupedNode = obj->getEditingGroupId() != m_groupId;
|
|
if (isASubgroupedNode) app.adjust(-30, -30, 30, 30);
|
|
#if QT_VERSION >= 0x050000
|
|
rect = rect.united(app);
|
|
#else
|
|
rect = rect.unite(app);
|
|
#endif
|
|
}
|
|
rect.adjust(-20, -35, 0, 0);
|
|
return rect;
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void StageSchematicGroupEditor::setGroupedNodeZValue(int zValue) {
|
|
int i, size = m_groupedNode.size();
|
|
for (i = 0; i < size; i++) {
|
|
StageSchematicNode *node =
|
|
dynamic_cast<StageSchematicNode *>(m_groupedNode[i]);
|
|
if (!node) continue;
|
|
if (node->getStageObject()->getEditingGroupId() == m_groupId)
|
|
node->setZValue(zValue);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void StageSchematicGroupEditor::closeEditor() {
|
|
int i;
|
|
for (i = 0; i < m_groupedNode.size(); i++) {
|
|
StageSchematicNode *node =
|
|
dynamic_cast<StageSchematicNode *>(m_groupedNode[i]);
|
|
if (!node) continue;
|
|
StageSchematicGroupNode *groupNode =
|
|
dynamic_cast<StageSchematicGroupNode *>(node);
|
|
if (groupNode) {
|
|
QList<TStageObject *> objs = groupNode->getGroupedObjects();
|
|
assert(!objs.isEmpty());
|
|
int j;
|
|
for (j = 0; j < objs.size(); j++) objs[j]->closeEditingGroup(m_groupId);
|
|
} else {
|
|
TStageObject *obj = node->getStageObject();
|
|
assert(obj);
|
|
obj->closeEditingGroup(m_groupId);
|
|
}
|
|
}
|
|
m_scene->updateScene();
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void StageSchematicGroupEditor::onNameChanged() {
|
|
int i;
|
|
QList<TStageObject *> objs;
|
|
m_nameItem->hide();
|
|
m_groupName = m_nameItem->toPlainText();
|
|
for (i = 0; i < m_groupedNode.size(); i++) {
|
|
StageSchematicGroupNode *groupNode =
|
|
dynamic_cast<StageSchematicGroupNode *>(m_groupedNode[i]);
|
|
StageSchematicNode *node =
|
|
dynamic_cast<StageSchematicNode *>(m_groupedNode[i]);
|
|
if (groupNode)
|
|
objs.append(groupNode->getGroupedObjects());
|
|
else if (node)
|
|
objs.append(node->getStageObject());
|
|
}
|
|
setFlag(QGraphicsItem::ItemIsSelectable, true);
|
|
StageSchematicScene *stageScene =
|
|
dynamic_cast<StageSchematicScene *>(scene());
|
|
if (!stageScene) return;
|
|
TStageObjectCmd::renameGroup(objs, m_groupName.toStdWString(), true,
|
|
stageScene->getXsheetHandle());
|
|
update();
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void StageSchematicGroupEditor::initializeEditor() {
|
|
StageSchematicNode *node =
|
|
dynamic_cast<StageSchematicNode *>(m_groupedNode[0]);
|
|
assert(node);
|
|
TStageObject *obj = node->getStageObject();
|
|
assert(obj);
|
|
assert(m_groupId == obj->getEditingGroupId());
|
|
m_groupName = QString::fromStdWString(obj->getEditingGroupName());
|
|
}
|
|
|
|
//---------------------------------------------------------------
|
|
|
|
void StageSchematicGroupEditor::doResizeNodes(bool maximizeNodes) {
|
|
int i;
|
|
for (i = 0; i < m_groupedNode.size(); i++) {
|
|
StageSchematicNode *node =
|
|
dynamic_cast<StageSchematicNode *>(m_groupedNode[i]);
|
|
assert(node);
|
|
node->getStageObject()->setIsOpened(maximizeNodes);
|
|
}
|
|
}
|