1
2
3 // TnzCore includes
4 #include "tofflinegl.h"
5 #include "tstroke.h"
6 #include "tconvert.h"
7 #include "tvectorimage.h"
8 #include "tundo.h"
9 #include "tconst.h"
10
11 // TnzLib includes
12 #include "toonz/tstageobjectid.h"
13 #include "toonz/tstageobject.h"
14 #include "toonz/tstageobjectspline.h"
15 #include "toonz/txsheet.h"
16 #include "toonz/txshcell.h"
17 #include "toonz/txshcolumn.h"
18 #include "toonz/toonzscene.h"
19 #include "toonz/sceneproperties.h"
20 #include "toonz/tstageobjectcmd.h"
21 #include "toonz/fxcommand.h"
22 #include "toonz/txshzeraryfxcolumn.h"
23 #include "toonz/tcolumnfx.h"
24 #include "toonz/tstageobjecttree.h"
25 #include "toonz/tframehandle.h"
26 #include "toonz/txshchildlevel.h"
27 #include "toonz/txshlevelcolumn.h"
28 #include "toonz/txshleveltypes.h"
29 #include "toonz/tcolumnhandle.h"
30 #include "toonz/hook.h"
31 #include "toonz/preferences.h"
32 #include "toonz/txshsimplelevel.h"
33
34 // TnzQt includes
35 #include "toonzqt/gutil.h"
36 #include "toonzqt/icongenerator.h"
37 #include "toonzqt/stageschematicscene.h"
38 #include "toonzqt/menubarcommand.h"
39
40 // Qt includes
41 #include <QPixmap>
42 #include <QRegExpValidator>
43 #include <QGraphicsSceneMouseEvent>
44 #include <QFocusEvent>
45 #include <QTimer>
46 #include <QMenu>
47 #include <QTextCursor>
48 #include <QSet>
49
50 #include "toonzqt/stageschematicnode.h"
51
52 namespace {
drawCamera(QPainter * painter,const QColor & color,const QPen & pen,double width,double height)53 void drawCamera(QPainter *painter, const QColor &color, const QPen &pen,
54 double width, double height) {
55 QPointF points[3];
56 points[0] = QPointF(width, height);
57 points[1] = QPointF(width, height * 0.5);
58 points[2] = QPointF(width - (height * 2 / 3), height * 0.75);
59 painter->setBrush(color);
60 painter->drawPolygon(points, 3);
61 painter->drawRect(
62 QRectF(width * 0.25, height * 0.5, width * 0.5, height * 0.5));
63 QRectF rect(0, 0, height * 0.49, height * 0.49);
64 rect.moveCenter(QPointF(width * 0.20, height * 0.4));
65 painter->drawEllipse(rect);
66 rect.moveCenter(QPointF((width * 3 / 5) + 1, height * 0.25));
67 painter->drawEllipse(rect);
68 painter->drawLine(0, height * 0.75, width * 0.25, height * 0.75);
69 painter->drawLine(width, height * 0.75, width + 5, height * 0.75);
70 painter->setBrush(QColor(235, 235, 235, 255));
71 painter->drawRect(0, -14, width, 14);
72 }
73 } // namespace
74
75 //========================================================
76 //
77 // ColumnPainter
78 //
79 //========================================================
80
ColumnPainter(StageSchematicColumnNode * parent,double width,double height,const QString & name)81 ColumnPainter::ColumnPainter(StageSchematicColumnNode *parent, double width,
82 double height, const QString &name)
83 : QGraphicsItem(parent)
84 , m_parent(parent)
85 , m_width(width)
86 , m_height(height)
87 , m_name(name) {
88 setFlag(QGraphicsItem::ItemIsMovable, false);
89 setFlag(QGraphicsItem::ItemIsSelectable, false);
90 setFlag(QGraphicsItem::ItemIsFocusable, false);
91 assert(parent->getStageObject()->getId().isColumn());
92 connect(IconGenerator::instance(), SIGNAL(iconGenerated()), this,
93 SLOT(onIconGenerated()));
94
95 StageSchematicScene *stageScene =
96 dynamic_cast<StageSchematicScene *>(scene());
97 if (!stageScene) return;
98
99 TXsheet *xsh = stageScene->getXsheet();
100 int r0, r1, index = parent->getStageObject()->getId().getIndex();
101 xsh->getCellRange(index, r0, r1);
102 if (r0 > r1) return;
103 TXshCell firstCell = xsh->getCell(r0, index);
104 if (!firstCell.isEmpty())
105 m_type = firstCell.m_level->getType();
106 else
107 m_type = NO_XSHLEVEL;
108 }
109
110 //--------------------------------------------------------
111
~ColumnPainter()112 ColumnPainter::~ColumnPainter() {}
113
114 //--------------------------------------------------------
115
boundingRect() const116 QRectF ColumnPainter::boundingRect() const {
117 // iwasawa
118 if (m_parent->isOpened())
119 return QRectF(-5, -54, m_width + 10, m_height + 59);
120 else
121 return QRectF(-5, -5, m_width + 10, m_height + 10);
122 }
123
124 //--------------------------------------------------------
125
paint(QPainter * painter,const QStyleOptionGraphicsItem * option,QWidget * widget)126 void ColumnPainter::paint(QPainter *painter,
127 const QStyleOptionGraphicsItem *option,
128 QWidget *widget) {
129 StageSchematicScene *stageScene =
130 dynamic_cast<StageSchematicScene *>(scene());
131 if (!stageScene) return;
132 // obtain level name and type
133 int levelType;
134 QString levelName;
135 m_parent->getLevelTypeAndName(levelType, levelName);
136
137 QColor nodeColor;
138 SchematicViewer *viewer = stageScene->getSchematicViewer();
139 viewer->getNodeColor(levelType, nodeColor);
140
141 if (m_isReference && levelType != PLT_XSHLEVEL) {
142 painter->setBrush(viewer->getReferenceColumnColor());
143 painter->setPen(nodeColor);
144 } else {
145 painter->setBrush(nodeColor);
146 painter->setPen(Qt::NoPen);
147 }
148
149 if (levelType == PLT_XSHLEVEL)
150 painter->drawRoundRect(0, 0, m_width, m_height, 32, 99);
151 else
152 painter->drawRect(0, 0, m_width, m_height);
153
154 // draw palette icon for palette node
155 if (levelType == PLT_XSHLEVEL) {
156 QPixmap palettePm = QPixmap(":Resources/schematic_palette.png");
157 QRect paletteRect(-3, -1, 20, 16);
158 painter->drawPixmap(paletteRect, palettePm);
159 }
160
161 if (m_parent->isOpened()) {
162 // Draw the pixmap
163 painter->setBrush(Qt::NoBrush);
164 painter->setPen(QColor(0, 0, 0, 255));
165 QPixmap pixmap = scalePixmapKeepingAspectRatio(
166 m_parent->getPixmap(), QSize(m_width, 49), Qt::transparent);
167 if (!pixmap.isNull()) {
168 painter->drawPixmap(QPointF(0, -pixmap.height()), pixmap);
169 } else {
170 painter->setBrush(QColor(255, 255, 255, 255));
171 painter->drawRect(0, -pixmap.height(), m_width, pixmap.height());
172 }
173 }
174 painter->setPen(viewer->getTextColor());
175 painter->setBrush(Qt::NoBrush);
176
177 //! draw the name only if it is not editing
178 if (!m_parent->isNameEditing()) {
179 StageSchematicScene *stageScene =
180 dynamic_cast<StageSchematicScene *>(scene());
181 if (!stageScene) return;
182
183 // if this is current object
184 if (stageScene->getCurrentObject() == m_parent->getStageObject()->getId())
185 painter->setPen(viewer->getSelectedNodeTextColor());
186 QRectF columnNameRect(18, 2, 54, 14);
187 QString elidedName =
188 elideText(m_name, painter->font(), columnNameRect.width());
189 painter->drawText(columnNameRect, Qt::AlignLeft | Qt::AlignVCenter,
190 elidedName);
191 }
192
193 // level names
194 QRectF levelNameRect(18, 16, 54, 14);
195 QString elidedName =
196 elideText(levelName, painter->font(), levelNameRect.width());
197 painter->drawText(levelNameRect, Qt::AlignLeft | Qt::AlignVCenter,
198 elidedName);
199 }
200
201 //--------------------------------------------------------
202
contextMenuEvent(QGraphicsSceneContextMenuEvent * cme)203 void ColumnPainter::contextMenuEvent(QGraphicsSceneContextMenuEvent *cme) {
204 StageSchematicScene *stageScene =
205 dynamic_cast<StageSchematicScene *>(scene());
206 QMenu menu(stageScene->views()[0]);
207
208 QAction *resetCenter = new QAction(tr("&Reset Center"), &menu);
209 connect(resetCenter, SIGNAL(triggered()), stageScene, SLOT(onResetCenter()));
210 QAction *collapse = CommandManager::instance()->getAction("MI_Collapse");
211 QAction *openSubxsh = CommandManager::instance()->getAction("MI_OpenChild");
212 QAction *explodeChild =
213 CommandManager::instance()->getAction("MI_ExplodeChild");
214 QAction *group = CommandManager::instance()->getAction("MI_Group");
215
216 QAction *clear = CommandManager::instance()->getAction("MI_Clear");
217 QAction *copy = CommandManager::instance()->getAction("MI_Copy");
218 QAction *cut = CommandManager::instance()->getAction("MI_Cut");
219 QAction *paste = CommandManager::instance()->getAction("MI_Paste");
220
221 menu.addAction(resetCenter);
222 menu.addSeparator();
223 menu.addAction(collapse);
224 TFrameHandle *frameHandle = stageScene->getFrameHandle();
225 if (frameHandle->getFrameType() == TFrameHandle::SceneFrame) {
226 int col = m_parent->getStageObject()->getId().getIndex();
227 int fr = frameHandle->getFrame();
228 TXsheet *xsh = stageScene->getXsheet();
229 TXshCell cell = xsh->getCell(fr, col);
230 if (dynamic_cast<TXshChildLevel *>(cell.m_level.getPointer())) {
231 menu.addAction(openSubxsh);
232 menu.addAction(explodeChild);
233 }
234 }
235 menu.addSeparator();
236
237 menu.addAction(clear);
238 menu.addAction(copy);
239 menu.addAction(cut);
240 menu.addAction(paste);
241 menu.addSeparator();
242
243 menu.addAction(group);
244 menu.exec(cme->screenPos());
245 }
246
247 //--------------------------------------------------------
248
onIconGenerated()249 void ColumnPainter::onIconGenerated() {
250 if (m_type != OVL_XSHLEVEL) return;
251 StageSchematicScene *stageScene =
252 dynamic_cast<StageSchematicScene *>(scene());
253 if (!stageScene) return;
254
255 TXsheet *xsh = stageScene->getXsheet();
256 int r0, r1, index = m_parent->getStageObject()->getId().getIndex();
257 xsh->getCellRange(index, r0, r1);
258 if (r0 > r1) return;
259 TXshCell firstCell = xsh->getCell(r0, index);
260 int type = firstCell.m_level->getType();
261 if (m_type != type) {
262 m_type = type;
263 update();
264 }
265 }
266
267 //========================================================
268 //
269 // GroupPainter
270 //
271 //========================================================
272
GroupPainter(StageSchematicGroupNode * parent,double width,double height,const QString & name)273 GroupPainter::GroupPainter(StageSchematicGroupNode *parent, double width,
274 double height, const QString &name)
275 : QGraphicsItem(parent)
276 , m_parent(parent)
277 , m_width(width)
278 , m_height(height)
279 , m_name(name) {
280 setFlag(QGraphicsItem::ItemIsMovable, false);
281 setFlag(QGraphicsItem::ItemIsSelectable, false);
282 setFlag(QGraphicsItem::ItemIsFocusable, false);
283 }
284
285 //--------------------------------------------------------
286
~GroupPainter()287 GroupPainter::~GroupPainter() {}
288
289 //--------------------------------------------------------
290
boundingRect() const291 QRectF GroupPainter::boundingRect() const {
292 return QRectF(-5, -5, m_width + 10, m_height + 10);
293 }
294
295 //--------------------------------------------------------
296
paint(QPainter * painter,const QStyleOptionGraphicsItem * option,QWidget * widget)297 void GroupPainter::paint(QPainter *painter,
298 const QStyleOptionGraphicsItem *option,
299 QWidget *widget) {
300 StageSchematicScene *stageScene =
301 dynamic_cast<StageSchematicScene *>(scene());
302 if (!stageScene) return;
303
304 SchematicViewer *viewer = stageScene->getSchematicViewer();
305
306 painter->save();
307 QPen pen;
308 if (m_parent->isSelected()) {
309 painter->setBrush(QColor(0, 0, 0, 0));
310 pen.setColor(QColor(255, 255, 255, 255));
311 pen.setWidth(4.0);
312 pen.setJoinStyle(Qt::RoundJoin);
313 painter->setPen(pen);
314 painter->drawRect(-2, -2, m_width + 4, m_height + 4);
315 }
316 painter->restore();
317
318 {
319 painter->setBrush(viewer->getGroupColor());
320 painter->setPen(Qt::NoPen);
321 painter->drawRect(QRectF(0, 0, m_width, m_height));
322 }
323
324 //! draw the name only if it is not editing
325 if (!m_parent->isNameEditing()) {
326 QFont font("Verdana", 8);
327 painter->setFont(font);
328 if (stageScene->getCurrentObject() == m_parent->getStageObject()->getId())
329 painter->setPen(viewer->getSelectedNodeTextColor());
330 else
331 painter->setPen(viewer->getTextColor());
332
333 QRectF rect(18, 0, 54, 18);
334 QString elidedName = elideText(m_name, painter->font(), rect.width());
335 painter->drawText(rect, Qt::AlignLeft | Qt::AlignVCenter, elidedName);
336 }
337 }
338
339 //--------------------------------------------------------
340
contextMenuEvent(QGraphicsSceneContextMenuEvent * cme)341 void GroupPainter::contextMenuEvent(QGraphicsSceneContextMenuEvent *cme) {
342 StageSchematicScene *stageScene =
343 dynamic_cast<StageSchematicScene *>(scene());
344 QMenu menu(stageScene->views()[0]);
345
346 QAction *group = CommandManager::instance()->getAction("MI_Group");
347 QAction *ungroup = CommandManager::instance()->getAction("MI_Ungroup");
348
349 QAction *editGroup = new QAction(tr("&Open Group"), &menu);
350 connect(editGroup, SIGNAL(triggered()), stageScene, SLOT(onEditGroup()));
351
352 menu.addAction(group);
353 menu.addAction(ungroup);
354 menu.addAction(editGroup);
355 menu.exec(cme->screenPos());
356 }
357
358 //========================================================
359 //
360 // PegbarPainter
361 //
362 //========================================================
363
PegbarPainter(StageSchematicPegbarNode * parent,double width,double height,const QString & name)364 PegbarPainter::PegbarPainter(StageSchematicPegbarNode *parent, double width,
365 double height, const QString &name)
366 : QGraphicsItem(parent)
367 , m_width(width)
368 , m_height(height)
369 , m_parent(parent)
370 , m_name(name) {}
371
372 //--------------------------------------------------------
373
~PegbarPainter()374 PegbarPainter::~PegbarPainter() {}
375
376 //--------------------------------------------------------
377
boundingRect() const378 QRectF PegbarPainter::boundingRect() const {
379 return QRectF(-5, -5, m_width + 10, m_height + 10);
380 }
381
382 //--------------------------------------------------------
383
paint(QPainter * painter,const QStyleOptionGraphicsItem * option,QWidget * widget)384 void PegbarPainter::paint(QPainter *painter,
385 const QStyleOptionGraphicsItem *option,
386 QWidget *widget) {
387 StageSchematicScene *stageScene =
388 dynamic_cast<StageSchematicScene *>(scene());
389
390 if (!stageScene) return;
391 SchematicViewer *viewer = stageScene->getSchematicViewer();
392
393 painter->setBrush(viewer->getPegColor());
394 painter->setPen(Qt::NoPen);
395 painter->drawRect(QRectF(0, 0, m_width, m_height));
396
397 if (!m_parent->isNameEditing()) {
398 if (stageScene->getCurrentObject() == m_parent->getStageObject()->getId())
399 painter->setPen(viewer->getSelectedNodeTextColor());
400 else
401 painter->setPen(viewer->getTextColor());
402 // Draw the name
403 QRectF rect(18, 0, 54, 18);
404 QString elidedName = elideText(m_name, painter->font(), rect.width());
405 painter->drawText(rect, Qt::AlignLeft | Qt::AlignVCenter, elidedName);
406 }
407 }
408
409 //--------------------------------------------------------
410
contextMenuEvent(QGraphicsSceneContextMenuEvent * cme)411 void PegbarPainter::contextMenuEvent(QGraphicsSceneContextMenuEvent *cme) {
412 StageSchematicScene *stageScene =
413 dynamic_cast<StageSchematicScene *>(scene());
414 QMenu menu(stageScene->views()[0]);
415
416 QAction *resetCenter = new QAction(tr("&Reset Center"), &menu);
417 connect(resetCenter, SIGNAL(triggered()), stageScene, SLOT(onResetCenter()));
418
419 QAction *group = CommandManager::instance()->getAction("MI_Group");
420
421 QAction *clear = CommandManager::instance()->getAction("MI_Clear");
422 QAction *copy = CommandManager::instance()->getAction("MI_Copy");
423 QAction *cut = CommandManager::instance()->getAction("MI_Cut");
424 QAction *paste = CommandManager::instance()->getAction("MI_Paste");
425
426 menu.addAction(resetCenter);
427 menu.addSeparator();
428 menu.addAction(clear);
429 menu.addAction(copy);
430 menu.addAction(cut);
431 menu.addAction(paste);
432 menu.addSeparator();
433 menu.addAction(group);
434 menu.exec(cme->screenPos());
435 }
436
437 //========================================================
438 //
439 // CameraPainter
440 //
441 //========================================================
442
CameraPainter(StageSchematicCameraNode * parent,double width,double height,const QString & name)443 CameraPainter::CameraPainter(StageSchematicCameraNode *parent, double width,
444 double height, const QString &name)
445 : QGraphicsItem(parent)
446 , m_width(width)
447 , m_height(height)
448 , m_parent(parent)
449 , m_name(name) {
450 StageSchematicScene *stageScene =
451 dynamic_cast<StageSchematicScene *>(scene());
452 TXsheet *xsh = stageScene->getXsheet();
453 m_isActive = xsh->getStageObjectTree()->getCurrentCameraId() ==
454 parent->getStageObject()->getId();
455 }
456
457 //--------------------------------------------------------
458
~CameraPainter()459 CameraPainter::~CameraPainter() {}
460
461 //--------------------------------------------------------
462
boundingRect() const463 QRectF CameraPainter::boundingRect() const {
464 return QRectF(-5, -5, m_width + 10, m_height + 10);
465 }
466
467 //--------------------------------------------------------
468
paint(QPainter * painter,const QStyleOptionGraphicsItem * option,QWidget * widget)469 void CameraPainter::paint(QPainter *painter,
470 const QStyleOptionGraphicsItem *option,
471 QWidget *widget) {
472 StageSchematicScene *stageScene =
473 dynamic_cast<StageSchematicScene *>(scene());
474 if (!stageScene) return;
475
476 SchematicViewer *viewer = stageScene->getSchematicViewer();
477 QColor cameraColor = m_isActive ? viewer->getActiveCameraColor()
478 : viewer->getOtherCameraColor();
479
480 painter->setBrush(cameraColor);
481 painter->setPen(Qt::NoPen);
482 painter->drawRect(QRectF(0, 0, m_width, m_height));
483
484 if (!m_parent->isNameEditing()) {
485 if (stageScene->getCurrentObject() == m_parent->getStageObject()->getId())
486 painter->setPen(viewer->getSelectedNodeTextColor());
487 else
488 painter->setPen(viewer->getTextColor());
489 // Draw the name
490 QRectF rect(18, 0, 54, 18);
491 QString elidedName = elideText(m_name, painter->font(), rect.width());
492 painter->drawText(rect, Qt::AlignLeft | Qt::AlignVCenter, elidedName);
493 }
494 }
495
496 //--------------------------------------------------------
497
contextMenuEvent(QGraphicsSceneContextMenuEvent * cme)498 void CameraPainter::contextMenuEvent(QGraphicsSceneContextMenuEvent *cme) {
499 StageSchematicScene *stageScene =
500 dynamic_cast<StageSchematicScene *>(scene());
501 QMenu menu(stageScene->views()[0]);
502
503 QAction *cameraSettings =
504 CommandManager::instance()->getAction("MI_CameraStage");
505
506 QAction *resetCenter = new QAction(tr("&Reset Center"), &menu);
507 connect(resetCenter, SIGNAL(triggered()), stageScene, SLOT(onResetCenter()));
508
509 QAction *activate = new QAction(tr("&Activate"), &menu);
510 connect(activate, SIGNAL(triggered()), stageScene, SLOT(onCameraActivate()));
511
512 QAction *clear = CommandManager::instance()->getAction("MI_Clear");
513 QAction *copy = CommandManager::instance()->getAction("MI_Copy");
514 QAction *cut = CommandManager::instance()->getAction("MI_Cut");
515 QAction *paste = CommandManager::instance()->getAction("MI_Paste");
516
517 bool isDeactivated =
518 m_parent->getStageObject()->getId() !=
519 stageScene->getXsheet()->getStageObjectTree()->getCurrentCameraId();
520
521 if (isDeactivated)
522 menu.addAction(activate);
523 else
524 menu.addAction(cameraSettings);
525 menu.addAction(resetCenter);
526 menu.addSeparator();
527 if (isDeactivated) menu.addAction(clear);
528 menu.addAction(copy);
529 if (isDeactivated) menu.addAction(cut);
530 menu.addAction(paste);
531 menu.exec(cme->screenPos());
532 }
533
534 //========================================================
535 //
536 // TablePainter
537 //
538 //========================================================
539
TablePainter(StageSchematicTableNode * parent,double width,double height)540 TablePainter::TablePainter(StageSchematicTableNode *parent, double width,
541 double height)
542 : QGraphicsItem(parent)
543 , m_width(width)
544 , m_height(height)
545 , m_parent(parent) {}
546
547 //--------------------------------------------------------
548
~TablePainter()549 TablePainter::~TablePainter() {}
550
551 //--------------------------------------------------------
552
boundingRect() const553 QRectF TablePainter::boundingRect() const {
554 return QRectF(-5, -5, m_width + 10, m_height + 10);
555 }
556
557 //--------------------------------------------------------
558
paint(QPainter * painter,const QStyleOptionGraphicsItem * option,QWidget * widget)559 void TablePainter::paint(QPainter *painter,
560 const QStyleOptionGraphicsItem *option,
561 QWidget *widget) {
562 QPixmap tablePm = QPixmap(":Resources/schematic_tablenode.png");
563
564 StageSchematicScene *stageScene =
565 dynamic_cast<StageSchematicScene *>(scene());
566 if (!stageScene) return;
567
568 SchematicViewer *viewer = stageScene->getSchematicViewer();
569
570 painter->setBrush(viewer->getTableColor());
571 painter->setPen(Qt::NoPen);
572 painter->drawRect(QRectF(0, 0, m_width, m_height));
573
574 QRect imgRect(3, -3, 24, 24);
575
576 painter->drawPixmap(imgRect, tablePm);
577
578 if (stageScene->getCurrentObject() == m_parent->getStageObject()->getId())
579 painter->setPen(viewer->getSelectedNodeTextColor());
580 else
581 painter->setPen(viewer->getTextColor());
582
583 // Draw the name
584 QRectF rect(30, 0, 42, 18);
585 painter->drawText(rect, Qt::AlignLeft | Qt::AlignVCenter,
586 QString(tr("Table")));
587 }
588
589 //--------------------------------------------------------
590
contextMenuEvent(QGraphicsSceneContextMenuEvent * cme)591 void TablePainter::contextMenuEvent(QGraphicsSceneContextMenuEvent *cme) {
592 StageSchematicScene *stageScene =
593 dynamic_cast<StageSchematicScene *>(scene());
594 QMenu menu(stageScene->views()[0]);
595
596 QAction *resetCenter = new QAction(tr("&Reset Center"), &menu);
597 connect(resetCenter, SIGNAL(triggered()), stageScene, SLOT(onResetCenter()));
598
599 menu.addAction(resetCenter);
600 menu.exec(cme->screenPos());
601 }
602
603 //========================================================
604 //
605 // SplinePainter
606 //
607 //========================================================
608
SplinePainter(StageSchematicSplineNode * parent,double width,double height,const QString & name)609 SplinePainter::SplinePainter(StageSchematicSplineNode *parent, double width,
610 double height, const QString &name)
611 : QGraphicsItem(parent)
612 , m_parent(parent)
613 , m_width(width)
614 , m_height(height)
615 , m_name(name) {}
616
617 //--------------------------------------------------------
618
~SplinePainter()619 SplinePainter::~SplinePainter() {}
620
621 //--------------------------------------------------------
622
boundingRect() const623 QRectF SplinePainter::boundingRect() const {
624 if (m_parent->isOpened())
625 return QRectF(-5, -5, m_width + 10, m_height + 59);
626 else
627 return QRectF(-5, -5, m_width + 10, m_height + 10);
628 }
629
630 //--------------------------------------------------------
631
paint(QPainter * painter,const QStyleOptionGraphicsItem * option,QWidget * widget)632 void SplinePainter::paint(QPainter *painter,
633 const QStyleOptionGraphicsItem *option,
634 QWidget *widget) {
635 StageSchematicScene *stageScene =
636 dynamic_cast<StageSchematicScene *>(scene());
637 if (!stageScene) return;
638
639 SchematicViewer *viewer = stageScene->getSchematicViewer();
640
641 painter->setBrush(viewer->getSplineColor());
642 painter->setPen(Qt::NoPen);
643 painter->drawRoundRect(QRectF(0, 0, m_width, m_height), 20, 99);
644 if (m_parent->isOpened()) {
645 // Draw the pixmap
646 painter->setBrush(Qt::NoBrush);
647 painter->setPen(QColor(0, 0, 0, 255));
648 QPixmap pixmap = scalePixmapKeepingAspectRatio(
649 m_parent->getPixmap(), QSize(m_width, 49), Qt::transparent);
650 if (!pixmap.isNull()) {
651 painter->drawPixmap(QPointF(0, 18), pixmap);
652 } else {
653 painter->setBrush(QColor(255, 255, 255, 255));
654 painter->drawRect(0, 18, m_width, 49);
655 }
656 }
657
658 //! draw the name only if it is not editing
659 if (!m_parent->isNameEditing()) {
660 /* There is no current spline
661 TStageObjectId currObj = stageScene->getCurrentObject();
662 if(currObj.getCode() == m_parent->getSpline()->getId())
663 painter->setPen(viewer->getSelectedNodeTextColor());
664 else
665 */
666 painter->setPen(viewer->getTextColor());
667 QRectF rect(18, 0, 72, 18);
668 QString elidedName = elideText(m_name, painter->font(), rect.width());
669 painter->drawText(rect, Qt::AlignLeft | Qt::AlignVCenter, elidedName);
670 }
671 }
672
673 //--------------------------------------------------------
674
contextMenuEvent(QGraphicsSceneContextMenuEvent * cme)675 void SplinePainter::contextMenuEvent(QGraphicsSceneContextMenuEvent *cme) {
676 StageSchematicScene *stageScene =
677 dynamic_cast<StageSchematicScene *>(scene());
678 QMenu menu(stageScene->views()[0]);
679
680 QAction *removeSpline = new QAction(tr("&Delete"), &menu);
681 connect(removeSpline, SIGNAL(triggered()), stageScene,
682 SLOT(onRemoveSpline()));
683 QAction *saveSpline = new QAction(tr("&Save Motion Path..."), &menu);
684 connect(saveSpline, SIGNAL(triggered()), stageScene, SLOT(onSaveSpline()));
685 QAction *loadSpline = new QAction(tr("&Load Motion Path..."), &menu);
686 connect(loadSpline, SIGNAL(triggered()), stageScene, SLOT(onLoadSpline()));
687
688 QAction *copy = CommandManager::instance()->getAction("MI_Copy");
689 QAction *cut = CommandManager::instance()->getAction("MI_Cut");
690 QAction *paste = CommandManager::instance()->getAction("MI_Paste");
691
692 menu.addAction(saveSpline);
693 menu.addAction(loadSpline);
694 menu.addSeparator();
695 menu.addAction(removeSpline);
696 menu.addAction(copy);
697 menu.addAction(cut);
698 menu.addAction(paste);
699 menu.exec(cme->screenPos());
700 }
701
702 //========================================================
703 //
704 // StageSchematicNodePort
705 //
706 //========================================================
707
StageSchematicNodePort(StageSchematicNodeDock * parent,int type)708 StageSchematicNodePort::StageSchematicNodePort(StageSchematicNodeDock *parent,
709 int type)
710 : SchematicPort(parent, parent->getNode(), type), m_handle("") {
711 QRectF rect = boundingRect();
712 if (parent->isParentPort())
713 m_hook = QPointF(rect.left(), (rect.top() + rect.bottom()) * 0.5);
714 else
715 m_hook = QPointF(rect.right(), (rect.top() + rect.bottom()) * 0.5);
716 }
717
718 //--------------------------------------------------------
719
~StageSchematicNodePort()720 StageSchematicNodePort::~StageSchematicNodePort() {}
721
722 //--------------------------------------------------------
723
boundingRect() const724 QRectF StageSchematicNodePort::boundingRect() const {
725 return QRectF(0, 0, 18, 18);
726 }
727
728 //--------------------------------------------------------
729
paint(QPainter * painter,const QStyleOptionGraphicsItem * option,QWidget * widget)730 void StageSchematicNodePort::paint(QPainter *painter,
731 const QStyleOptionGraphicsItem *option,
732 QWidget *widget) {
733 // StageSchematicNode *node = dynamic_cast<StageSchematicNode *>(getNode());
734 StageSchematicScene *scene =
735 dynamic_cast<StageSchematicScene *>(this->scene());
736 if (scene && scene->isShowLetterOnPortFlagEnabled()) {
737 painter->setBrush(QColor(255, 255, 255, 255));
738 painter->setPen(QColor(180, 180, 180, 255));
739 painter->drawRect(boundingRect());
740 if (m_type == 103 || m_type == 104 || m_type == 105) return;
741 painter->setPen(QColor(0, 0, 0, 255));
742 QFont font("Verdana", 8);
743 painter->setFont(font);
744 QTextOption textOption(Qt::AlignCenter);
745 QString text = m_handle;
746 if (text.size() > 1 && text.at(0) == 'H') text.remove("H");
747 painter->drawText(boundingRect(), text, textOption);
748 } else {
749 QRect imgRect(2, 2, 14, 14);
750 QRect sourceRect = scene->views()[0]->matrix().mapRect(imgRect);
751 QPixmap pixmap;
752
753 if (getType() == eStageParentPort || getType() == eStageParentGroupPort) {
754 if (isHighlighted())
755 pixmap = QIcon(":Resources/port_blue_highlight.svg")
756 .pixmap(sourceRect.size());
757 else
758 pixmap = QIcon(":Resources/port_blue.svg").pixmap(sourceRect.size());
759 } else {
760 if (isHighlighted())
761 pixmap = QIcon(":Resources/port_red_highlight.svg")
762 .pixmap(sourceRect.size());
763 else
764 pixmap = QIcon(":Resources/port_red.svg").pixmap(sourceRect.size());
765 }
766 sourceRect = QRect(0, 0, sourceRect.width() * getDevPixRatio(),
767 sourceRect.height() * getDevPixRatio());
768 painter->drawPixmap(imgRect, pixmap, sourceRect);
769 }
770 }
771
772 //--------------------------------------------------------
773
linkTo(SchematicPort * port,bool checkOnly)774 bool StageSchematicNodePort::linkTo(SchematicPort *port, bool checkOnly) {
775 StageSchematicScene *stageScene =
776 dynamic_cast<StageSchematicScene *>(scene());
777 if (!port) return false;
778
779 StageSchematicNode *srcNode = dynamic_cast<StageSchematicNode *>(getNode());
780 if (this == port && !srcNode->getStageObject()->isGrouped()) {
781 if (!checkOnly)
782 TStageObjectCmd::setParent(srcNode->getStageObject()->getId(),
783 TStageObjectId::NoneId, "",
784 stageScene->getXsheetHandle());
785 return true;
786 }
787 StageSchematicNode *dstNode =
788 dynamic_cast<StageSchematicNode *>(port->getNode());
789 if (!dstNode) return false;
790 if (srcNode == dstNode) return false;
791
792 TStageObject *pegbar = 0, *parentPegbar = 0;
793 SchematicPort *childPort, *parentPort;
794 if (getType() == eStageParentPort && port->getType() == eStageChildPort) {
795 pegbar = srcNode->getStageObject();
796 parentPegbar = dstNode->getStageObject();
797 childPort = this;
798 parentPort = port;
799 } else if (getType() == eStageChildPort &&
800 port->getType() == eStageParentPort) {
801 pegbar = dstNode->getStageObject();
802 parentPegbar = srcNode->getStageObject();
803 childPort = port;
804 parentPort = this;
805 } else
806 return false;
807 if (pegbar->getId().isTable()) return false;
808 if (pegbar->getId().isPegbar() && !parentPegbar->getId().isTable() &&
809 !parentPegbar->getId().isPegbar() && !parentPegbar->getId().isCamera())
810 return false;
811
812 if (parentPegbar == pegbar || parentPegbar->isAncestor(pegbar)) return false;
813 if (parentPegbar->isGrouped() || pegbar->isGrouped()) return false;
814 if (checkOnly) return true;
815
816 StageSchematicNodePort *dstPort =
817 dynamic_cast<StageSchematicNodePort *>(parentPort);
818 if (!dstPort) return false;
819 TStageObjectCmd::setParent(pegbar->getId(), parentPegbar->getId(),
820 dstPort->getHandle().toStdString(),
821 stageScene->getXsheetHandle());
822 return true;
823 }
824
825 //--------------------------------------------------------
826
searchPort(const QPointF & scenePos)827 SchematicPort *StageSchematicNodePort::searchPort(const QPointF &scenePos) {
828 QList<QGraphicsItem *> items = scene()->items(scenePos);
829 int i;
830 for (i = 0; i < items.size(); i++) {
831 StageSchematicNodePort *linkingTo =
832 dynamic_cast<StageSchematicNodePort *>(items[i]);
833 if (linkingTo) {
834 StageSchematicNode *node =
835 dynamic_cast<StageSchematicNode *>(linkingTo->getNode());
836 if (!node->getStageObject()->isGrouped()) return linkingTo;
837 }
838 }
839 return 0;
840 }
841
842 //--------------------------------------------------------
843
hideSnappedLinks(SchematicPort * linkingPort)844 void StageSchematicNodePort::hideSnappedLinks(SchematicPort *linkingPort) {
845 if (!linkingPort) return;
846 if (getType() == eStageChildPort &&
847 linkingPort->getType() == eStageParentPort &&
848 linkingPort->getLinkCount() == 1)
849 linkingPort->getLink(0)->hide();
850 if (getType() == eStageParentPort &&
851 linkingPort->getType() == eStageChildPort && getLinkCount() == 1)
852 getLink(0)->hide();
853 }
854
855 //--------------------------------------------------------
856
showSnappedLinks(SchematicPort * linkingPort)857 void StageSchematicNodePort::showSnappedLinks(SchematicPort *linkingPort) {
858 if (!linkingPort) return;
859 if (getType() == eStageChildPort &&
860 linkingPort->getType() == eStageParentPort &&
861 linkingPort->getLinkCount() == 1) {
862 linkingPort->getLink(0)->show();
863 linkingPort->highLight(true);
864 linkingPort->update();
865 }
866 if (getType() == eStageParentPort &&
867 linkingPort->getType() == eStageChildPort && getLinkCount() == 1) {
868 getLink(0)->show();
869 linkingPort->highLight(true);
870 linkingPort->update();
871 }
872 }
873
874 //========================================================
875 //
876 // StageSchematicSplinePort
877 //
878 //========================================================
879
StageSchematicSplinePort(StageSchematicSplineDock * parent,int type)880 StageSchematicSplinePort::StageSchematicSplinePort(
881 StageSchematicSplineDock *parent, int type)
882 : SchematicPort(parent, parent->getNode(), type), m_parent(parent) {
883 m_squarePixmap = QPixmap(":Resources/schematic_spline_aim_square.svg");
884 m_rhombPixmap = QPixmap(":Resources/schematic_spline_aim_rhomb.svg");
885 QRectF rect = boundingRect();
886 if (parent->isParentPort())
887 m_hook = QPointF((rect.left() + rect.right()) * 0.5, rect.bottom() - 5);
888 else
889 m_hook = QPointF((rect.left() + rect.right()) * 0.5, rect.top() + 5);
890 }
891
892 //--------------------------------------------------------
893
~StageSchematicSplinePort()894 StageSchematicSplinePort::~StageSchematicSplinePort() {}
895
896 //--------------------------------------------------------
897
boundingRect() const898 QRectF StageSchematicSplinePort::boundingRect() const {
899 return QRectF(0, 0, 16, 8);
900 }
901
902 //--------------------------------------------------------
903
paint(QPainter * painter,const QStyleOptionGraphicsItem * option,QWidget * widget)904 void StageSchematicSplinePort::paint(QPainter *painter,
905 const QStyleOptionGraphicsItem *option,
906 QWidget *widget) {
907 QRect rect(0, 0, 16, 8);
908 QRect sourceRect = scene()->views()[0]->matrix().mapRect(rect);
909 QPixmap pixmap;
910
911 if (!m_parent->isParentPort()) {
912 if (getLinkCount() > 0) {
913 static QIcon splineChildIcon(":Resources/spline_child_port.svg");
914 pixmap = splineChildIcon.pixmap(sourceRect.size());
915 } else {
916 static QIcon splineChildDisconIcon(
917 ":Resources/spline_child_port_disconnect.svg");
918 pixmap = splineChildDisconIcon.pixmap(sourceRect.size());
919 }
920 } else {
921 static QIcon splineParentIcon(":Resources/spline_parent_port.svg");
922 pixmap = splineParentIcon.pixmap(sourceRect.size());
923 }
924 sourceRect = QRect(0, 0, sourceRect.width() * getDevPixRatio(),
925 sourceRect.height() * getDevPixRatio());
926 painter->drawPixmap(rect, pixmap, sourceRect);
927 }
928
929 //--------------------------------------------------------
930
linkTo(SchematicPort * port,bool checkOnly)931 bool StageSchematicSplinePort::linkTo(SchematicPort *port, bool checkOnly) {
932 assert(port != 0);
933 StageSchematicScene *stageScene =
934 dynamic_cast<StageSchematicScene *>(scene());
935 StageSchematicNode *node = dynamic_cast<StageSchematicNode *>(getNode());
936 StageSchematicSplineNode *splineNode =
937 dynamic_cast<StageSchematicSplineNode *>(getNode());
938 if (node) {
939 StageSchematicSplineNode *targetSplineNode =
940 dynamic_cast<StageSchematicSplineNode *>(port->getNode());
941 if (!targetSplineNode && port != this) return false;
942 if (!checkOnly && targetSplineNode) {
943 TStageObjectSpline *spline = targetSplineNode->getSpline();
944 TStageObjectCmd::setSplineParent(spline, node->getStageObject(),
945 stageScene->getXsheetHandle());
946 } else if (!checkOnly && port == this)
947 node->getStageObject()->setSpline(0);
948 return true;
949 } else if (splineNode) {
950 StageSchematicNode *targetNode =
951 dynamic_cast<StageSchematicNode *>(port->getNode());
952 if (!targetNode || port->getType() != eStageSplinePort) return false;
953 if (!checkOnly) {
954 TStageObjectSpline *spline = splineNode->getSpline();
955 TStageObjectCmd::setSplineParent(spline, targetNode->getStageObject(),
956 stageScene->getXsheetHandle());
957 }
958 return true;
959 }
960 return false;
961 }
962
963 //--------------------------------------------------------
964
searchPort(const QPointF & scenePos)965 SchematicPort *StageSchematicSplinePort::searchPort(const QPointF &scenePos) {
966 QList<QGraphicsItem *> items = scene()->items(scenePos);
967 int i;
968 for (i = 0; i < items.size(); i++) {
969 StageSchematicSplinePort *linkingTo =
970 dynamic_cast<StageSchematicSplinePort *>(items[i]);
971 if (linkingTo) return linkingTo;
972 }
973 return 0;
974 }
975
976 //--------------------------------------------------------
977
hideSnappedLinks(SchematicPort *)978 void StageSchematicSplinePort::hideSnappedLinks(SchematicPort *) {
979 if (!m_linkingTo) return;
980 StageSchematicNode *node = dynamic_cast<StageSchematicNode *>(getNode());
981 StageSchematicSplineNode *splineNode =
982 dynamic_cast<StageSchematicSplineNode *>(getNode());
983 if (node && getLinkCount() == 1) getLink(0)->hide();
984 if (splineNode && m_linkingTo->getLinkCount() == 1)
985 m_linkingTo->getLink(0)->hide();
986 }
987
988 //--------------------------------------------------------
989
showSnappedLinks(SchematicPort *)990 void StageSchematicSplinePort::showSnappedLinks(SchematicPort *) {
991 if (!m_linkingTo) return;
992 StageSchematicNode *node = dynamic_cast<StageSchematicNode *>(getNode());
993 StageSchematicSplineNode *splineNode =
994 dynamic_cast<StageSchematicSplineNode *>(getNode());
995 if (node && getLinkCount() == 1) getLink(0)->show();
996 if (splineNode && m_linkingTo->getLinkCount() == 1)
997 m_linkingTo->getLink(0)->show();
998 }
999
1000 //========================================================
1001 //
1002 // class SplineAimChanger
1003 //
1004 //========================================================
1005
SplineAimChanger(QGraphicsItem * parent)1006 SplineAimChanger::SplineAimChanger(QGraphicsItem *parent)
1007 : SchematicHandleSpinBox(parent), m_aim(false) {}
1008
1009 //--------------------------------------------------------
1010
~SplineAimChanger()1011 SplineAimChanger::~SplineAimChanger() {}
1012
1013 //--------------------------------------------------------
1014
mouseMoveEvent(QGraphicsSceneMouseEvent * me)1015 void SplineAimChanger::mouseMoveEvent(QGraphicsSceneMouseEvent *me) {
1016 if (m_buttonState == Qt::LeftButton) {
1017 bool increase = false;
1018 int delta = me->screenPos().y() - me->lastScreenPos().y();
1019 if (delta < 0) increase = true;
1020 m_delta += abs(delta);
1021 if (m_delta > 15) {
1022 emit(changeStatus());
1023 m_delta = 0;
1024 }
1025 }
1026 }
1027
1028 //--------------------------------------------------------
1029
mousePressEvent(QGraphicsSceneMouseEvent * me)1030 void SplineAimChanger::mousePressEvent(QGraphicsSceneMouseEvent *me) {
1031 SchematicHandleSpinBox::mousePressEvent(me);
1032 }
1033
1034 //--------------------------------------------------------
1035
mouseReleaseEvent(QGraphicsSceneMouseEvent * me)1036 void SplineAimChanger::mouseReleaseEvent(QGraphicsSceneMouseEvent *me) {
1037 SchematicHandleSpinBox::mouseReleaseEvent(me);
1038 m_delta = 0;
1039 }
1040
1041 //========================================================
1042 //
1043 // class StageSchematicNodeDock
1044 //
1045 //========================================================
1046
StageSchematicNodeDock(StageSchematicNode * parent,bool isParentPort,eStageSchematicPortType type)1047 StageSchematicNodeDock::StageSchematicNodeDock(StageSchematicNode *parent,
1048 bool isParentPort,
1049 eStageSchematicPortType type)
1050 : QGraphicsItem(parent), m_parent(parent), m_isParentPort(isParentPort) {
1051 setFlag(QGraphicsItem::ItemIsSelectable, false);
1052 setFlag(QGraphicsItem::ItemIsFocusable, false);
1053 m_port = new StageSchematicNodePort(this, type);
1054
1055 m_handleSpinBox = new SchematicHandleSpinBox(this);
1056
1057 m_port->setPos(0, 0);
1058 if (isParentPort) {
1059 StageSchematicScene *stageScene =
1060 dynamic_cast<StageSchematicScene *>(scene());
1061 if (stageScene && stageScene->isShowLetterOnPortFlagEnabled())
1062 m_port->setPos(m_handleSpinBox->boundingRect().width(), 0);
1063 m_handleSpinBox->setPos(0, 1);
1064 } else
1065 m_handleSpinBox->setPos(m_port->boundingRect().width(), 1);
1066
1067 m_handleSpinBox->hide();
1068 connect(m_handleSpinBox, SIGNAL(modifyHandle(int)), this,
1069 SLOT(onModifyHandle(int)));
1070 connect(m_handleSpinBox, SIGNAL(sceneChanged()), parent,
1071 SIGNAL(sceneChanged()));
1072 connect(m_handleSpinBox, SIGNAL(handleReleased()), parent,
1073 SLOT(onHandleReleased()));
1074
1075 connect(this, SIGNAL(sceneChanged()), parent, SIGNAL(sceneChanged()));
1076
1077 connect(m_port, SIGNAL(isClicked()), this, SLOT(onPortClicked()));
1078 connect(m_port, SIGNAL(isReleased(const QPointF &)), this,
1079 SLOT(onPortReleased(const QPointF &)));
1080
1081 m_timer = new QTimer(this);
1082 m_timer->setInterval(200);
1083 m_timer->setSingleShot(true);
1084 connect(m_timer, SIGNAL(timeout()), this, SLOT(onTimeOut()));
1085
1086 connect(m_port, SIGNAL(sceneChanged()), parent, SIGNAL(sceneChanged()));
1087 connect(m_port, SIGNAL(xsheetChanged()), parent, SIGNAL(xsheetChanged()));
1088
1089 setZValue(1.5);
1090 #if QT_VERSION >= 0x050000
1091 setAcceptHoverEvents(true);
1092 #else
1093 setAcceptsHoverEvents(true);
1094 #endif
1095 }
1096
1097 //--------------------------------------------------------
1098
~StageSchematicNodeDock()1099 StageSchematicNodeDock::~StageSchematicNodeDock() {}
1100
1101 //--------------------------------------------------------
1102
boundingRect() const1103 QRectF StageSchematicNodeDock::boundingRect() const {
1104 StageSchematicScene *stageScene =
1105 dynamic_cast<StageSchematicScene *>(scene());
1106 QRectF portRect = m_port->boundingRect();
1107 portRect.moveTopLeft(QPointF(0, 0));
1108 if (stageScene && stageScene->isShowLetterOnPortFlagEnabled()) {
1109 QRectF handleRect = m_handleSpinBox->boundingRect();
1110 handleRect.moveTopLeft(QPointF(portRect.width(), handleRect.topLeft().y()));
1111 #if QT_VERSION >= 0x050000
1112 portRect = portRect.united(handleRect);
1113 #else
1114 portRect = portRect.unite(handleRect);
1115 #endif
1116 }
1117 return portRect;
1118 }
1119
1120 //--------------------------------------------------------
1121
paint(QPainter * painter,const QStyleOptionGraphicsItem * option,QWidget * widget)1122 void StageSchematicNodeDock::paint(QPainter *painter,
1123 const QStyleOptionGraphicsItem *option,
1124 QWidget *widget) {}
1125
1126 //--------------------------------------------------------
1127
onModifyHandle(int increase)1128 void StageSchematicNodeDock::onModifyHandle(int increase) {
1129 StageSchematicScene *stageScene =
1130 dynamic_cast<StageSchematicScene *>(scene());
1131 std::string handle(getPort()->getHandle().toStdString());
1132
1133 int index;
1134 if (handle[0] == 'H' && handle.length() > 1)
1135 index = -(std::stoi(handle.substr(1)));
1136 else
1137 index = handle[0] - 'A';
1138 index += -increase; //==1 ? -1 : 1;
1139
1140 int min = (getNode()->getStageObject()->getId().isColumn())
1141 ? -HookSet::maxHooksCount
1142 : 0;
1143 index = tcrop(index, min, 25);
1144
1145 if (index >= 0)
1146 handle = std::string(1, (char)('A' + index));
1147 else
1148 handle = "H" + std::to_string(-index);
1149
1150 if (m_isParentPort)
1151 TStageObjectCmd::setHandle(getNode()->getStageObject()->getId(), handle,
1152 stageScene->getXsheetHandle());
1153 else {
1154 int i, linkCount = getPort()->getLinkCount();
1155 std::vector<TStageObjectId> ids;
1156 for (i = 0; i < linkCount; i++) {
1157 StageSchematicNode *node =
1158 dynamic_cast<StageSchematicNode *>(getPort()->getLinkedNode(i));
1159 if (node) ids.push_back(node->getStageObject()->getId());
1160 }
1161 TStageObjectCmd::setParentHandle(ids, handle,
1162 stageScene->getXsheetHandle());
1163 }
1164 getPort()->setHandle(QString::fromStdString(handle));
1165 getPort()->update();
1166 }
1167
1168 //--------------------------------------------------------
1169
hoverEnterEvent(QGraphicsSceneHoverEvent * he)1170 void StageSchematicNodeDock::hoverEnterEvent(QGraphicsSceneHoverEvent *he) {
1171 QList<QGraphicsItem *> items = scene()->items(he->scenePos());
1172 eStageSchematicPortType type = (eStageSchematicPortType)getPort()->getType();
1173 if (items.contains(m_port) && type != 103 && type != 104 && type != 105) {
1174 m_port->highLight(true);
1175 m_timer->start();
1176 }
1177 QGraphicsItem::hoverEnterEvent(he);
1178 }
1179
1180 //--------------------------------------------------------
1181
hoverLeaveEvent(QGraphicsSceneHoverEvent * he)1182 void StageSchematicNodeDock::hoverLeaveEvent(QGraphicsSceneHoverEvent *he) {
1183 m_port->highLight(false);
1184 m_timer->stop();
1185 m_handleSpinBox->hide();
1186 QGraphicsItem::hoverLeaveEvent(he);
1187 int i;
1188 for (i = 0; i < m_port->getLinkCount(); i++) m_port->getLink(i)->updatePath();
1189 }
1190
1191 //--------------------------------------------------------
1192
hoverMoveEvent(QGraphicsSceneHoverEvent * he)1193 void StageSchematicNodeDock::hoverMoveEvent(QGraphicsSceneHoverEvent *he) {
1194 QList<QGraphicsItem *> items = scene()->items(he->scenePos());
1195 if (!m_port->isHighlighted() && items.contains(m_port)) {
1196 m_port->highLight(true);
1197 eStageSchematicPortType type =
1198 (eStageSchematicPortType)getPort()->getType();
1199 if (!m_timer->isActive() && type != 103 && type != 104 && type != 105)
1200 m_timer->start();
1201 }
1202 QGraphicsItem::hoverMoveEvent(he);
1203 update();
1204 }
1205
1206 //--------------------------------------------------------
1207
onPortClicked()1208 void StageSchematicNodeDock::onPortClicked() {
1209 m_handleSpinBox->hide();
1210 m_timer->stop();
1211 int i;
1212 for (i = 0; i < m_port->getLinkCount(); i++) m_port->getLink(i)->updatePath();
1213 }
1214
1215 //--------------------------------------------------------
1216
onPortReleased(const QPointF & pos)1217 void StageSchematicNodeDock::onPortReleased(const QPointF &pos) {
1218 QRectF portRect = m_port->boundingRect();
1219 portRect.moveTopLeft(m_port->scenePos());
1220 if (portRect.contains(pos)) m_timer->start();
1221 }
1222
1223 //--------------------------------------------------------
1224
onTimeOut()1225 void StageSchematicNodeDock::onTimeOut() {
1226 StageSchematicScene *stageScene =
1227 dynamic_cast<StageSchematicScene *>(scene());
1228 if (stageScene && stageScene->isShowLetterOnPortFlagEnabled())
1229 m_handleSpinBox->show();
1230 StageSchematicNodePort *port = getPort();
1231 int i;
1232 for (i = 0; i < port->getLinkCount(); i++) {
1233 SchematicLink *link = port->getLink(i);
1234 SchematicPort *startPort = link->getStartPort();
1235 SchematicPort *endPort = link->getEndPort();
1236 QPointF startPos = startPort->getLinkEndPoint();
1237 QPointF endPos = endPort->getLinkEndPoint();
1238 if (startPort == port) {
1239 if (port->getType() == 101 && startPos.x() > endPos.x())
1240 startPos = mapToScene(0, boundingRect().height() * 0.5);
1241 if (port->getType() == 102 && startPos.x() < endPos.x())
1242 startPos =
1243 mapToScene(boundingRect().width(), boundingRect().height() * 0.5);
1244 link->updatePath(startPos, endPos);
1245 } else {
1246 if (port->getType() == 101 && startPos.x() < endPos.x())
1247 endPos = mapToScene(0, boundingRect().height() * 0.5);
1248 if (port->getType() == 102 && startPos.x() > endPos.x())
1249 endPos =
1250 mapToScene(boundingRect().width(), boundingRect().height() * 0.5);
1251 link->updatePath(startPos, endPos);
1252 }
1253 }
1254 }
1255
1256 //========================================================
1257 //
1258 // class StageSchematicSplineDock
1259 //
1260 //========================================================
1261
StageSchematicSplineDock(SchematicNode * parent,bool isParentPort,eStageSchematicPortType type)1262 StageSchematicSplineDock::StageSchematicSplineDock(SchematicNode *parent,
1263 bool isParentPort,
1264 eStageSchematicPortType type)
1265 : QGraphicsItem(parent), m_parent(parent), m_isParentPort(isParentPort) {
1266 setFlag(QGraphicsItem::ItemIsSelectable, false);
1267 setFlag(QGraphicsItem::ItemIsFocusable, false);
1268 m_port = new StageSchematicSplinePort(this, type);
1269 #if QT_VERSION >= 0x050000
1270 setAcceptHoverEvents(true);
1271 #else
1272 setAcceptsHoverEvents(true);
1273 #endif
1274
1275 connect(m_port, SIGNAL(sceneChanged()), parent, SIGNAL(sceneChanged()));
1276 connect(m_port, SIGNAL(xsheetChanged()), parent, SIGNAL(xsheetChanged()));
1277 connect(this, SIGNAL(sceneChanged()), parent, SIGNAL(sceneChanged()));
1278 }
1279
1280 //--------------------------------------------------------
1281
~StageSchematicSplineDock()1282 StageSchematicSplineDock::~StageSchematicSplineDock() {}
1283
1284 //--------------------------------------------------------
1285
boundingRect() const1286 QRectF StageSchematicSplineDock::boundingRect() const {
1287 QRectF portRect = m_port->boundingRect();
1288 portRect.moveTopLeft(QPointF(0, 0));
1289 return portRect;
1290 }
1291
1292 //--------------------------------------------------------
1293
paint(QPainter * painter,const QStyleOptionGraphicsItem * option,QWidget * widget)1294 void StageSchematicSplineDock::paint(QPainter *painter,
1295 const QStyleOptionGraphicsItem *option,
1296 QWidget *widget) {}
1297
1298 //========================================================
1299 //
1300 // class StageSchematicNode
1301 //
1302 //========================================================
1303
StageSchematicNode(StageSchematicScene * scene,TStageObject * obj,int width,int height,bool isGroup)1304 StageSchematicNode::StageSchematicNode(StageSchematicScene *scene,
1305 TStageObject *obj, int width, int height,
1306 bool isGroup)
1307 : SchematicNode(scene), m_stageObject(obj), m_isGroup(isGroup) {
1308 m_stageObject->addRef();
1309 m_width = width;
1310 m_height = height;
1311
1312 // aggiunge le porte
1313 qreal y = m_height * 0.5 - 5;
1314 qreal x = m_width * 0.5 - 8;
1315
1316 if (m_isGroup)
1317 m_splineDock =
1318 new StageSchematicSplineDock(this, false, eStageSplineGroupPort);
1319 else
1320 m_splineDock = new StageSchematicSplineDock(this, false, eStageSplinePort);
1321 addPort(-1, m_splineDock->getPort());
1322 m_splineDock->setPos(x, m_height);
1323
1324 m_pathToggle = new SchematicToggle_SplineOptions(
1325 this, QIcon(":Resources/schematic_spline_aim_rhomb.svg"),
1326 QIcon(":Resources/schematic_spline_aim_square.svg"), 0);
1327 m_cpToggle = new SchematicToggle_SplineOptions(
1328 this, QIcon(":Resources/schematic_spline_cp.svg"), 0);
1329 m_pathToggle->setSize(16, 16);
1330 m_cpToggle->setSize(16, 16);
1331 m_cpToggle->setPos(m_splineDock->pos() - QPointF(16, 0));
1332 m_pathToggle->setPos(m_cpToggle->pos() - QPointF(16, 0));
1333 m_pathToggle->setToolTip(tr("Toggle Autorotate Along Motion Path"));
1334 m_cpToggle->setToolTip(tr("Toggle Link Motion Path to Control Points"));
1335
1336 if (m_stageObject->isPathEnabled()) {
1337 if (m_stageObject->isAimEnabled())
1338 m_pathToggle->setState(1);
1339 else
1340 m_pathToggle->setState(2);
1341 }
1342 m_cpToggle->setIsActive(m_stageObject->isUppkEnabled());
1343
1344 connect(m_pathToggle, SIGNAL(stateChanged(int)), scene,
1345 SLOT(onPathToggled(int)));
1346 connect(m_cpToggle, SIGNAL(toggled(bool)), scene, SLOT(onCpToggled(bool)));
1347
1348 if (!m_stageObject->getSpline()) {
1349 m_pathToggle->hide();
1350 m_cpToggle->hide();
1351 }
1352
1353 if (m_isGroup)
1354 m_parentDock =
1355 new StageSchematicNodeDock(this, true, eStageParentGroupPort);
1356 else
1357 m_parentDock = new StageSchematicNodeDock(this, true, eStageParentPort);
1358 addPort(0, m_parentDock->getPort());
1359 if (scene->isShowLetterOnPortFlagEnabled())
1360 m_parentDock->setPos(-m_parentDock->boundingRect().width(), m_height - 15);
1361 else
1362 m_parentDock->setPos(0, 0);
1363 m_parentDock->getPort()->setHandle("B");
1364
1365 StageSchematicNodeDock *childDock;
1366 if (m_isGroup)
1367 childDock = new StageSchematicNodeDock(this, false, eStageChildGroupPort);
1368 else
1369 childDock = new StageSchematicNodeDock(this, false, eStageChildPort);
1370 addPort(1, childDock->getPort());
1371 m_childDocks.append(childDock);
1372 if (scene->isShowLetterOnPortFlagEnabled())
1373 childDock->setPos(m_width, m_height - 15);
1374 else
1375 childDock->setPos(m_width - 18, 0);
1376 childDock->getPort()->setHandle("B");
1377 }
1378
1379 //--------------------------------------------------------
1380
~StageSchematicNode()1381 StageSchematicNode::~StageSchematicNode() { m_stageObject->release(); }
1382
1383 //--------------------------------------------------------
1384
setSchematicNodePos(const QPointF & pos) const1385 void StageSchematicNode::setSchematicNodePos(const QPointF &pos) const {
1386 if (!m_stageObject->isGrouped() || m_stageObject->isGroupEditing())
1387 m_stageObject->setDagNodePos(TPointD(pos.x(), pos.y()));
1388 else {
1389 const StageSchematicGroupNode *groupNode =
1390 dynamic_cast<const StageSchematicGroupNode *>(this);
1391 assert(groupNode);
1392 groupNode->updateObjsDagPosition(TPointD(pos.x(), pos.y()));
1393 }
1394 }
1395
1396 //--------------------------------------------------------
1397
makeChildPort(const QString & label)1398 StageSchematicNodePort *StageSchematicNode::makeChildPort(
1399 const QString &label) {
1400 int i, n = m_childDocks.size();
1401 assert(n > 0);
1402 for (i = 0; i < n - 1; i++)
1403 if (m_childDocks[i]->getPort()->getHandle() == label)
1404 return m_childDocks[i]->getPort();
1405 StageSchematicNodeDock *dock = m_childDocks.back();
1406 dock->getPort()->setHandle(label);
1407 int k;
1408 QString newPortName;
1409 for (k = 0;; k++) {
1410 newPortName = QString(1, (char)('A' + k));
1411 int j;
1412 for (j = 0; j < n; j++) {
1413 QString name = m_childDocks[j]->getPort()->getHandle();
1414 if (name == newPortName) break;
1415 }
1416 if (j == n) break;
1417 }
1418 StageSchematicScene *stageScene =
1419 dynamic_cast<StageSchematicScene *>(scene());
1420 if (stageScene && stageScene->isShowLetterOnPortFlagEnabled()) {
1421 StageSchematicNodeDock *newDock;
1422 if (m_isGroup)
1423 newDock = new StageSchematicNodeDock(this, false, eStageChildGroupPort);
1424 else
1425 newDock = new StageSchematicNodeDock(this, false, eStageChildPort);
1426 addPort(m_childDocks.size() + 1, newDock->getPort());
1427 m_childDocks.append(newDock);
1428 newDock->getPort()->setHandle(newPortName);
1429 }
1430 updateChildDockPositions();
1431 return dock->getPort();
1432 }
1433
1434 //--------------------------------------------------------
1435
makeParentPort(const QString & label)1436 StageSchematicNodePort *StageSchematicNode::makeParentPort(
1437 const QString &label) {
1438 m_parentDock->getPort()->setHandle(label);
1439 return m_parentDock->getPort();
1440 }
1441
1442 //--------------------------------------------------------
1443
setPosition(const QPointF & newPos)1444 void StageSchematicNode::setPosition(const QPointF &newPos) {
1445 if (m_stageObject->isGrouped() && m_stageObject->getEditingGroupId() != -1) {
1446 StageSchematicScene *stageScene =
1447 dynamic_cast<StageSchematicScene *>(scene());
1448 assert(stageScene);
1449 stageScene->updateNestedGroupEditors(this, newPos);
1450 } else
1451 setPos(newPos);
1452 }
1453
1454 //--------------------------------------------------------
1455
updateChildDockPositions()1456 void StageSchematicNode::updateChildDockPositions() {
1457 int i, size = m_childDocks.size();
1458 StageSchematicScene *stageScene =
1459 dynamic_cast<StageSchematicScene *>(scene());
1460 if (stageScene && stageScene->isShowLetterOnPortFlagEnabled()) {
1461 double portHeight = m_childDocks.at(0)->getPort()->boundingRect().height();
1462 double height = size * portHeight;
1463 double y = (m_height - 15 - portHeight * 0.5) + height * 0.5;
1464 for (i = 0; i < size; i++) {
1465 m_childDocks[i]->setPos(m_width, y);
1466 m_childDocks[i]->getPort()->updateLinksGeometry();
1467 y -= portHeight;
1468 }
1469 } else {
1470 double y = 18;
1471 for (i = 0; i < size; i++) {
1472 m_childDocks[i]->setPos(m_width - 18, m_height - y);
1473 m_childDocks[i]->getPort()->updateLinksGeometry();
1474 y += m_childDocks.at(0)->getPort()->boundingRect().height();
1475 }
1476 }
1477 }
1478
1479 //--------------------------------------------------------
1480
onClicked()1481 void StageSchematicNode::onClicked() {
1482 TStageObjectId id = m_stageObject->getId();
1483 emit currentObjectChanged(id, false);
1484 if (id.isColumn())
1485 emit currentColumnChanged(id.getIndex());
1486 else if (id.isCamera() || id.isPegbar() || id.isTable())
1487 emit editObject();
1488 }
1489
1490 //--------------------------------------------------------
1491
onHandleReleased()1492 void StageSchematicNode::onHandleReleased() {
1493 int i;
1494 bool updated = false;
1495 for (i = m_childDocks.size() - 1; i >= 0; i--) {
1496 StageSchematicNodePort *port = m_childDocks[i]->getPort();
1497 assert(port);
1498 if (!port) continue;
1499 QString label = port->getHandle();
1500 int j;
1501 for (j = 0; j < m_childDocks.size(); j++) {
1502 StageSchematicNodePort *refPort = m_childDocks[j]->getPort();
1503 assert(refPort);
1504 if (!refPort) continue;
1505 if (refPort->getHandle() == label && i != j) {
1506 StageSchematicNodeDock *dock = m_childDocks[i];
1507 int k;
1508 if (port->getLinkCount() == 0 || refPort->getLinkCount() == 0) {
1509 updated = true;
1510 break;
1511 }
1512 for (k = port->getLinkCount() - 1; k >= 0; k--) {
1513 SchematicLink *link = port->getLink(k);
1514 assert(link);
1515 if (!link) continue;
1516 if (link->getStartPort() == port)
1517 link->setStartPort(refPort);
1518 else if (link->getEndPort() == port)
1519 link->setEndPort(refPort);
1520 port->removeLink(link);
1521 refPort->addLink(link);
1522 }
1523 m_childDocks.removeAt(i);
1524 delete dock;
1525 updateChildDockPositions();
1526 update();
1527 updated = true;
1528 break;
1529 }
1530 }
1531 if (updated) break;
1532 }
1533
1534 if (updated) {
1535 QSet<QString> labels;
1536 StageSchematicNodePort *freePort = 0;
1537 for (i = 0; i < m_childDocks.size(); i++) {
1538 StageSchematicNodePort *port = m_childDocks[i]->getPort();
1539 assert(port);
1540 if (!port) continue;
1541 if (port->getLinkCount() == 0)
1542 freePort = port;
1543 else
1544 labels.insert(port->getHandle());
1545 }
1546
1547 i = 0;
1548 while (labels.contains(QString(1, (char)('A' + i)))) i++;
1549 freePort->setHandle(QString(1, (char)('A' + i)));
1550 freePort->update();
1551 }
1552 }
1553
1554 //========================================================
1555 //
1556 // class StageSchematicPegbarNode
1557 //
1558 //========================================================
1559
StageSchematicPegbarNode(StageSchematicScene * scene,TStageObject * pegbar)1560 StageSchematicPegbarNode::StageSchematicPegbarNode(StageSchematicScene *scene,
1561 TStageObject *pegbar)
1562 : StageSchematicNode(scene, pegbar, 90, 18) {
1563 std::string name = m_stageObject->getFullName();
1564 std::string id = m_stageObject->getId().toString();
1565 m_name = QString::fromStdString(name);
1566 m_nameItem = new SchematicName(this, 72, 20);
1567 m_nameItem->setName(m_name);
1568 m_nameItem->setPos(16, -1);
1569 m_nameItem->setZValue(2);
1570 connect(m_nameItem, SIGNAL(focusOut()), this, SLOT(onNameChanged()));
1571 m_nameItem->hide();
1572
1573 m_pegbarPainter = new PegbarPainter(this, m_width, m_height, m_name);
1574 m_pegbarPainter->setZValue(1);
1575
1576 QString toolTip =
1577 name == id ? m_name : m_name + " (" + QString::fromStdString(id) + ")";
1578 setToolTip(toolTip);
1579 }
1580
1581 //--------------------------------------------------------
1582
~StageSchematicPegbarNode()1583 StageSchematicPegbarNode::~StageSchematicPegbarNode() {}
1584
1585 //--------------------------------------------------------
1586
boundingRect() const1587 QRectF StageSchematicPegbarNode::boundingRect() const {
1588 return QRectF(-5, -5, m_width + 10, m_height + 10);
1589 }
1590
1591 //--------------------------------------------------------
1592
paint(QPainter * painter,const QStyleOptionGraphicsItem * option,QWidget * widget)1593 void StageSchematicPegbarNode::paint(QPainter *painter,
1594 const QStyleOptionGraphicsItem *option,
1595 QWidget *widget) {
1596 StageSchematicNode::paint(painter, option, widget);
1597 }
1598
1599 //--------------------------------------------------------
1600
mouseDoubleClickEvent(QGraphicsSceneMouseEvent * me)1601 void StageSchematicPegbarNode::mouseDoubleClickEvent(
1602 QGraphicsSceneMouseEvent *me) {
1603 QRectF nameArea(18, 0, m_width - 36, 14);
1604 if (nameArea.contains(me->pos())) {
1605 m_nameItem->setPlainText(m_name);
1606 m_nameItem->show();
1607 m_nameItem->setFocus();
1608 setFlag(QGraphicsItem::ItemIsSelectable, false);
1609 return;
1610 }
1611 }
1612
1613 //--------------------------------------------------------
1614
onNameChanged()1615 void StageSchematicPegbarNode::onNameChanged() {
1616 StageSchematicScene *stageScene =
1617 dynamic_cast<StageSchematicScene *>(scene());
1618 m_nameItem->hide();
1619 m_name = m_nameItem->toPlainText();
1620 m_pegbarPainter->setName(m_name);
1621 setFlag(QGraphicsItem::ItemIsSelectable, true);
1622
1623 TStageObjectId id = m_stageObject->getId();
1624 std::string strId = id.toString();
1625 std::string name = m_name.toStdString();
1626 QString toolTip = name == strId
1627 ? m_name
1628 : m_name + " (" + QString::fromStdString(strId) + ")";
1629 setToolTip(toolTip);
1630 if (id.isPegbar())
1631 TStageObjectCmd::rename(id, m_name.toStdString(),
1632 stageScene->getXsheetHandle());
1633 update();
1634 }
1635
1636 //========================================================
1637 //
1638 // class StageSchematicTableNode
1639 //
1640 //========================================================
1641
StageSchematicTableNode(StageSchematicScene * scene,TStageObject * pegbar)1642 StageSchematicTableNode::StageSchematicTableNode(StageSchematicScene *scene,
1643 TStageObject *pegbar)
1644 : StageSchematicNode(scene, pegbar, 90, 18) {
1645 m_parentDock->hide();
1646 updateChildDockPositions();
1647
1648 m_tablePainter = new TablePainter(this, m_width, m_height);
1649 m_tablePainter->setZValue(1);
1650 }
1651
1652 //--------------------------------------------------------
1653
~StageSchematicTableNode()1654 StageSchematicTableNode::~StageSchematicTableNode() {}
1655
1656 //--------------------------------------------------------
1657
boundingRect() const1658 QRectF StageSchematicTableNode::boundingRect() const {
1659 return QRectF(-5, -5, m_width + 10, m_height + 10);
1660 }
1661
1662 //--------------------------------------------------------
1663
paint(QPainter * painter,const QStyleOptionGraphicsItem * option,QWidget * widget)1664 void StageSchematicTableNode::paint(QPainter *painter,
1665 const QStyleOptionGraphicsItem *option,
1666 QWidget *widget) {
1667 StageSchematicNode::paint(painter, option, widget);
1668 }
1669
1670 //--------------------------------------------------------
1671
1672 //========================================================
1673 //
1674 // class StageSchematicColumnNode
1675 //
1676 //========================================================
1677
StageSchematicColumnNode(StageSchematicScene * scene,TStageObject * pegbar)1678 StageSchematicColumnNode::StageSchematicColumnNode(StageSchematicScene *scene,
1679 TStageObject *pegbar)
1680 : StageSchematicNode(scene, pegbar, 90, 32), m_isOpened(true) {
1681 bool ret = true;
1682
1683 assert(pegbar && pegbar->getId().isColumn());
1684
1685 SchematicViewer *viewer = scene->getSchematicViewer();
1686
1687 TXshColumn *column =
1688 scene->getXsheet()->getColumn(pegbar->getId().getIndex());
1689
1690 std::string name = m_stageObject->getName();
1691
1692 if (column) {
1693 // ZeraryFx columns store name elsewhere
1694 TXshZeraryFxColumn *zColumn = dynamic_cast<TXshZeraryFxColumn *>(column);
1695 if (zColumn)
1696 name =
1697 ::to_string(zColumn->getZeraryColumnFx()->getZeraryFx()->getName());
1698 }
1699
1700 m_name = QString::fromStdString(name);
1701 m_resizeItem = new SchematicThumbnailToggle(this, m_stageObject->isOpened());
1702 m_resizeItem->setPos(2, 0);
1703 m_resizeItem->setZValue(2);
1704 ret = ret && connect(m_resizeItem, SIGNAL(toggled(bool)), this,
1705 SLOT(onChangedSize(bool)));
1706
1707 m_nameItem = new SchematicName(this, 54, 20);
1708 m_nameItem->setName(m_name);
1709 m_nameItem->setPos(16, -1);
1710 m_nameItem->setZValue(2);
1711 ret = ret &&
1712 connect(m_nameItem, SIGNAL(focusOut()), this, SLOT(onNameChanged()));
1713 m_nameItem->hide();
1714
1715 m_renderToggle =
1716 new SchematicToggle(this, viewer->getSchematicPreviewButtonOnImage(),
1717 viewer->getSchematicPreviewButtonBgOnColor(),
1718 viewer->getSchematicPreviewButtonOffImage(),
1719 viewer->getSchematicPreviewButtonBgOffColor(),
1720 SchematicToggle::eIsParentColumn);
1721 ret = ret && connect(m_renderToggle, SIGNAL(toggled(bool)), this,
1722 SLOT(onRenderToggleClicked(bool)));
1723 if (scene) {
1724 if (column) m_renderToggle->setIsActive(column->isPreviewVisible());
1725
1726 m_renderToggle->setPos(72, 0);
1727 m_renderToggle->setZValue(2);
1728
1729 m_cameraStandToggle = new SchematicToggle(
1730 this, viewer->getSchematicCamstandButtonOnImage(),
1731 viewer->getSchematicCamstandButtonTranspImage(),
1732 viewer->getSchematicCamstandButtonBgOnColor(),
1733 viewer->getSchematicCamstandButtonOffImage(),
1734 viewer->getSchematicCamstandButtonBgOffColor(),
1735 SchematicToggle::eIsParentColumn | SchematicToggle::eEnableNullState);
1736 ret = ret && connect(m_cameraStandToggle, SIGNAL(stateChanged(int)), this,
1737 SLOT(onCameraStandToggleClicked(int)));
1738 if (column)
1739 m_cameraStandToggle->setState(column->isCamstandVisible()
1740 ? (column->getOpacity() < 255 ? 2 : 1)
1741 : 0);
1742
1743 m_cameraStandToggle->setPos(72, 7);
1744 m_cameraStandToggle->setZValue(2);
1745 }
1746
1747 qreal y = 14;
1748 m_parentDock->setY(y);
1749 m_childDocks[0]->setY(y);
1750
1751 m_columnPainter = new ColumnPainter(this, m_width, m_height, m_name);
1752 m_columnPainter->setZValue(1);
1753
1754 if (column && !column->isControl() && !column->isRendered() &&
1755 !column->getMeshColumn())
1756 m_columnPainter->setIsReference();
1757
1758 int levelType;
1759 QString levelName;
1760 getLevelTypeAndName(levelType, levelName);
1761 setToolTip(QString("%1 : %2").arg(m_name, levelName));
1762
1763 onChangedSize(m_stageObject->isOpened());
1764 assert(ret);
1765
1766 if (levelType == PLT_XSHLEVEL) {
1767 m_resizeItem->hide();
1768 m_cameraStandToggle->hide();
1769 }
1770 }
1771
1772 //--------------------------------------------------------
1773
~StageSchematicColumnNode()1774 StageSchematicColumnNode::~StageSchematicColumnNode() {}
1775
1776 //--------------------------------------------------------
1777
boundingRect() const1778 QRectF StageSchematicColumnNode::boundingRect() const {
1779 // iwasawa
1780 if (m_isOpened)
1781 return QRectF(-5, -54, m_width + 10, m_height + 59);
1782 else
1783 return QRectF(-5, -5, m_width + 10, m_height + 10);
1784 }
1785
1786 //--------------------------------------------------------
1787
paint(QPainter * painter,const QStyleOptionGraphicsItem * option,QWidget * widget)1788 void StageSchematicColumnNode::paint(QPainter *painter,
1789 const QStyleOptionGraphicsItem *option,
1790 QWidget *widget) {
1791 StageSchematicNode::paint(painter, option, widget);
1792 TStageObjectId id = m_stageObject->getId();
1793 assert(id.isColumn());
1794 QString colNumber = QString::number(id.getIndex() + 1);
1795 QFont font("Verdana", 8);
1796 painter->setFont(font);
1797 StageSchematicScene *scene = dynamic_cast<StageSchematicScene *>(m_scene);
1798 SchematicViewer *viewer = scene->getSchematicViewer();
1799 if (scene && scene->getCurrentObject() == id)
1800 painter->setPen(viewer->getSelectedNodeTextColor());
1801 QFontMetrics metrix(font);
1802 int srcWidth = metrix.width(colNumber);
1803 int srcHeight = metrix.height();
1804 QPointF pos(m_cameraStandToggle->pos() -
1805 QPointF(srcWidth + 1, -srcHeight + 3));
1806 painter->drawText(pos, colNumber);
1807 }
1808
1809 //--------------------------------------------------------
1810
getPixmap()1811 QPixmap StageSchematicColumnNode::getPixmap() {
1812 StageSchematicScene *stageScene =
1813 dynamic_cast<StageSchematicScene *>(scene());
1814 if (!stageScene) return QPixmap();
1815 int columnIndex = m_stageObject->getId().getIndex();
1816 TXsheet *xsh = stageScene->getXsheet();
1817 if (xsh && !xsh->isColumnEmpty(columnIndex)) {
1818 int r0, r1;
1819 xsh->getCellRange(columnIndex, r0, r1);
1820 if (r1 >= r0) {
1821 TXshCell cell = xsh->getCell(r0, columnIndex);
1822 TXshLevel *xl = cell.m_level.getPointer();
1823 if (xl) {
1824 bool onDemand = false;
1825 if (Preferences::instance()->getColumnIconLoadingPolicy() ==
1826 Preferences::LoadOnDemand)
1827 onDemand =
1828 stageScene->getColumnHandle()->getColumnIndex() != columnIndex;
1829 return IconGenerator::instance()->getIcon(xl, cell.m_frameId, false,
1830 onDemand);
1831 }
1832 }
1833 }
1834 return QPixmap();
1835 }
1836
1837 //--------------------------------------------------------
1838
resize(bool maximized)1839 void StageSchematicColumnNode::resize(bool maximized) {
1840 m_resizeItem->setIsDown(!maximized);
1841 }
1842
1843 //--------------------------------------------------------
1844
getLevelTypeAndName(int & ltype,QString & levelName)1845 void StageSchematicColumnNode::getLevelTypeAndName(int <ype,
1846 QString &levelName) {
1847 StageSchematicScene *stageScene =
1848 dynamic_cast<StageSchematicScene *>(scene());
1849 if (!stageScene) {
1850 ltype = NO_XSHLEVEL;
1851 levelName = QString();
1852 return;
1853 }
1854
1855 int columnIndex = m_stageObject->getId().getIndex();
1856 TXsheet *xsh = stageScene->getXsheet();
1857 if (xsh && !xsh->isColumnEmpty(columnIndex)) {
1858 int r0, r1;
1859 xsh->getCellRange(columnIndex, r0, r1);
1860 if (r1 >= r0) {
1861 TXshCell cell = xsh->getCell(r0, columnIndex);
1862 TXshLevel *xl = cell.m_level.getPointer();
1863 if (xl) {
1864 ltype = cell.m_level->getType();
1865
1866 // for Zerary Fx, display FxId
1867 if (ltype == ZERARYFX_XSHLEVEL) {
1868 TXshZeraryFxColumn *zColumn =
1869 dynamic_cast<TXshZeraryFxColumn *>(xsh->getColumn(columnIndex));
1870 if (zColumn) {
1871 TFx *fx = zColumn->getZeraryColumnFx()->getZeraryFx();
1872 levelName = QString::fromStdWString(fx->getFxId());
1873 return;
1874 }
1875 }
1876
1877 levelName = QString::fromStdWString(xl->getName());
1878 return;
1879 }
1880 }
1881 }
1882
1883 ltype = NO_XSHLEVEL;
1884 levelName = QString();
1885 return;
1886 }
1887 //--------------------------------------------------------
1888
onChangedSize(bool expand)1889 void StageSchematicColumnNode::onChangedSize(bool expand) {
1890 prepareGeometryChange();
1891 m_isOpened = expand;
1892 m_stageObject->setIsOpened(m_isOpened);
1893 m_height = 32;
1894 updatePortsPosition();
1895 updateLinksGeometry();
1896 update();
1897 emit nodeChangedSize();
1898 }
1899
1900 //--------------------------------------------------------
1901
updatePortsPosition()1902 void StageSchematicColumnNode::updatePortsPosition() {
1903 qreal x = m_width * 0.5 - 5;
1904 m_splineDock->setPos(x, m_height);
1905 updateChildDockPositions();
1906 }
1907
1908 //--------------------------------------------------------
1909
mouseDoubleClickEvent(QGraphicsSceneMouseEvent * me)1910 void StageSchematicColumnNode::mouseDoubleClickEvent(
1911 QGraphicsSceneMouseEvent *me) {
1912 StageSchematicScene *stageScene =
1913 dynamic_cast<StageSchematicScene *>(scene());
1914 if (!stageScene) return;
1915 QRectF nameArea(14, 0, m_width - 15, 14);
1916 if (nameArea.contains(me->pos())) {
1917 std::string name = m_stageObject->getName();
1918
1919 TStageObjectId id = m_stageObject->getId();
1920 TXshColumn *column = stageScene->getXsheet()->getColumn(id.getIndex());
1921 if (column) {
1922 TXshZeraryFxColumn *fxColumn = dynamic_cast<TXshZeraryFxColumn *>(column);
1923 if (fxColumn)
1924 name = ::to_string(
1925 fxColumn->getZeraryColumnFx()->getZeraryFx()->getName());
1926 }
1927
1928 m_name = QString::fromStdString(name);
1929 m_nameItem->setPlainText(m_name);
1930 m_nameItem->show();
1931 m_nameItem->setFocus();
1932 setFlag(QGraphicsItem::ItemIsSelectable, false);
1933 }
1934 }
1935
1936 //--------------------------------------------------------
1937
onNameChanged()1938 void StageSchematicColumnNode::onNameChanged() {
1939 StageSchematicScene *stageScene =
1940 dynamic_cast<StageSchematicScene *>(scene());
1941 if (!stageScene) return;
1942 m_nameItem->hide();
1943 m_name = m_nameItem->toPlainText();
1944 m_columnPainter->setName(m_name);
1945
1946 int levelType;
1947 QString levelName;
1948 getLevelTypeAndName(levelType, levelName);
1949 setToolTip(QString("%1 : %2").arg(m_name, levelName));
1950
1951 setFlag(QGraphicsItem::ItemIsSelectable, true);
1952
1953 TStageObjectId id = m_stageObject->getId();
1954 if (!id.isColumn()) return;
1955 TXshColumn *column = stageScene->getXsheet()->getColumn(id.getIndex());
1956 TXshZeraryFxColumn *fxColumn = dynamic_cast<TXshZeraryFxColumn *>(column);
1957 if (fxColumn)
1958 TFxCommand::renameFx(fxColumn->getZeraryColumnFx(), m_name.toStdWString(),
1959 stageScene->getXsheetHandle());
1960 else {
1961 TStageObjectCmd::rename(id, m_name.toStdString(),
1962 stageScene->getXsheetHandle());
1963 update();
1964 }
1965 }
1966
1967 //--------------------------------------------------------
1968
onRenderToggleClicked(bool isActive)1969 void StageSchematicColumnNode::onRenderToggleClicked(bool isActive) {
1970 StageSchematicScene *stageScene =
1971 dynamic_cast<StageSchematicScene *>(scene());
1972 if (!stageScene) return;
1973 TXshColumn *column =
1974 stageScene->getXsheet()->getColumn(m_stageObject->getId().getIndex());
1975 if (column) {
1976 column->setPreviewVisible(isActive);
1977 emit sceneChanged();
1978 emit xsheetChanged();
1979 }
1980 }
1981
1982 //--------------------------------------------------------
1983
onCameraStandToggleClicked(int state)1984 void StageSchematicColumnNode::onCameraStandToggleClicked(int state) {
1985 StageSchematicScene *stageScene =
1986 dynamic_cast<StageSchematicScene *>(scene());
1987 if (!stageScene) return;
1988 TXshColumn *column =
1989 stageScene->getXsheet()->getColumn(m_stageObject->getId().getIndex());
1990 if (column) {
1991 // column->setCamstandNextState();
1992 column->setCamstandVisible(!column->isCamstandVisible());
1993 emit sceneChanged();
1994 emit xsheetChanged();
1995 }
1996 }
1997
1998 //========================================================
1999 //
2000 // class StageSchematicCameraNode
2001 //
2002 //========================================================
2003
StageSchematicCameraNode(StageSchematicScene * scene,TStageObject * pegbar)2004 StageSchematicCameraNode::StageSchematicCameraNode(StageSchematicScene *scene,
2005 TStageObject *pegbar)
2006 : StageSchematicNode(scene, pegbar, 90, 18) {
2007 std::string name = m_stageObject->getFullName();
2008 m_name = QString::fromStdString(name);
2009
2010 m_nameItem = new SchematicName(this, 54, 20);
2011 m_nameItem->setName(m_name);
2012
2013 m_nameItem->setPos(16, -2);
2014 connect(m_nameItem, SIGNAL(focusOut()), this, SLOT(onNameChanged()));
2015 m_nameItem->hide();
2016 m_nameItem->setZValue(2);
2017
2018 m_cameraPainter = new CameraPainter(this, m_width, m_height, m_name);
2019 m_cameraPainter->setZValue(1);
2020
2021 setToolTip(m_name);
2022 }
2023
2024 //--------------------------------------------------------
2025
~StageSchematicCameraNode()2026 StageSchematicCameraNode::~StageSchematicCameraNode() {}
2027
2028 //--------------------------------------------------------
2029
boundingRect() const2030 QRectF StageSchematicCameraNode::boundingRect() const {
2031 return QRectF(-5, -5, m_width + 10, m_height + 10);
2032 }
2033
2034 //--------------------------------------------------------
2035
paint(QPainter * painter,const QStyleOptionGraphicsItem * option,QWidget * widget)2036 void StageSchematicCameraNode::paint(QPainter *painter,
2037 const QStyleOptionGraphicsItem *option,
2038 QWidget *widget) {
2039 StageSchematicNode::paint(painter, option, widget);
2040 }
2041
2042 //--------------------------------------------------------
2043
mouseDoubleClickEvent(QGraphicsSceneMouseEvent * me)2044 void StageSchematicCameraNode::mouseDoubleClickEvent(
2045 QGraphicsSceneMouseEvent *me) {
2046 QRectF nameArea(0, -14, m_width, 14);
2047 if (nameArea.contains(me->pos())) {
2048 m_nameItem->setPlainText(m_name);
2049 m_nameItem->show();
2050 m_nameItem->setFocus();
2051 setFlag(QGraphicsItem::ItemIsSelectable, false);
2052 } else {
2053 QAction *cameraSettingsPopup =
2054 CommandManager::instance()->getAction("MI_CameraStage");
2055 cameraSettingsPopup->trigger();
2056 }
2057 }
2058
2059 //--------------------------------------------------------
2060
onNameChanged()2061 void StageSchematicCameraNode::onNameChanged() {
2062 StageSchematicScene *stageScene =
2063 dynamic_cast<StageSchematicScene *>(scene());
2064 m_nameItem->hide();
2065 m_name = m_nameItem->toPlainText();
2066 m_cameraPainter->setName(m_name);
2067 setToolTip(m_name);
2068 setFlag(QGraphicsItem::ItemIsSelectable, true);
2069
2070 TStageObjectId id = m_stageObject->getId();
2071 if (id.isCamera())
2072 TStageObjectCmd::rename(id, m_name.toStdString(),
2073 stageScene->getXsheetHandle());
2074 update();
2075 }
2076
2077 //========================================================
2078 //
2079 // class StageSchematicSplineNode
2080 //
2081 //========================================================
2082
StageSchematicSplineNode(StageSchematicScene * scene,TStageObjectSpline * spline)2083 StageSchematicSplineNode::StageSchematicSplineNode(StageSchematicScene *scene,
2084 TStageObjectSpline *spline)
2085 : SchematicNode(scene), m_spline(spline), m_isOpened(false) {
2086 m_width = 90;
2087 m_height = 18;
2088 assert(spline);
2089
2090 m_dock = new StageSchematicSplineDock(this, true, eStageSplinePort);
2091 addPort(-1, m_dock->getPort());
2092 QRectF rect = m_dock->getPort()->boundingRect();
2093 m_dock->setPos(m_width * 0.5 - rect.width() * 0.5, -rect.height());
2094
2095 m_resizeItem = new SchematicThumbnailToggle(this, m_spline->isOpened());
2096 m_resizeItem->setPos(2, 2);
2097 m_resizeItem->setZValue(2);
2098 connect(m_resizeItem, SIGNAL(toggled(bool)), this, SLOT(onChangedSize(bool)));
2099
2100 std::string name = m_spline->getName();
2101 m_splineName = QString::fromStdString(name);
2102 m_nameItem = new SchematicName(this, 72, 20);
2103 m_nameItem->setName(m_splineName);
2104 m_nameItem->setPos(16, -1);
2105 m_nameItem->setZValue(2);
2106 connect(m_nameItem, SIGNAL(focusOut()), this, SLOT(onNameChanged()));
2107 m_nameItem->hide();
2108
2109 m_splinePainter = new SplinePainter(this, m_width, m_height, m_splineName);
2110 m_splinePainter->setZValue(1);
2111
2112 setToolTip(m_splineName);
2113 onChangedSize(m_spline->isOpened());
2114 }
2115
2116 //--------------------------------------------------------
2117
~StageSchematicSplineNode()2118 StageSchematicSplineNode::~StageSchematicSplineNode() {}
2119
2120 //--------------------------------------------------------
2121
boundingRect() const2122 QRectF StageSchematicSplineNode::boundingRect() const {
2123 if (m_isOpened)
2124 return QRectF(-5, -5, m_width + 10, m_height + 59);
2125 else
2126 return QRectF(-5, -5, m_width + 10, m_height + 10);
2127 }
2128
2129 //--------------------------------------------------------
2130
paint(QPainter * painter,const QStyleOptionGraphicsItem * option,QWidget * widget)2131 void StageSchematicSplineNode::paint(QPainter *painter,
2132 const QStyleOptionGraphicsItem *option,
2133 QWidget *widget) {
2134 SchematicNode::paint(painter, option, widget);
2135 }
2136
2137 //--------------------------------------------------------
2138
onClicked()2139 void StageSchematicSplineNode::onClicked() {
2140 if (m_dock->getPort()->getLinkCount() > 0) {
2141 StageSchematicNode *parentNode =
2142 dynamic_cast<StageSchematicNode *>(m_dock->getPort()->getLinkedNode(0));
2143 TStageObjectId parentId = parentNode->getStageObject()->getId();
2144 emit currentObjectChanged(parentId, true);
2145 }
2146 }
2147
2148 //--------------------------------------------------------
2149
setSchematicNodePos(const QPointF & pos) const2150 void StageSchematicSplineNode::setSchematicNodePos(const QPointF &pos) const {
2151 m_spline->setDagNodePos(TPointD(pos.x(), pos.y()));
2152 }
2153
2154 //--------------------------------------------------------
2155
getPixmap()2156 QPixmap StageSchematicSplineNode::getPixmap() {
2157 return IconGenerator::instance()->getIcon(m_spline);
2158 return QPixmap();
2159 }
2160
2161 //--------------------------------------------------------
2162
resize(bool maximized)2163 void StageSchematicSplineNode::resize(bool maximized) {
2164 m_resizeItem->setIsDown(!maximized);
2165 }
2166
2167 //--------------------------------------------------------
2168
mouseDoubleClickEvent(QGraphicsSceneMouseEvent * me)2169 void StageSchematicSplineNode::mouseDoubleClickEvent(
2170 QGraphicsSceneMouseEvent *me) {
2171 QRectF nameArea(14, 0, m_width - 15, 14);
2172 if (nameArea.contains(me->pos())) {
2173 m_nameItem->setPlainText(m_splineName);
2174 m_nameItem->show();
2175 m_nameItem->setFocus();
2176 setFlag(QGraphicsItem::ItemIsSelectable, false);
2177 }
2178 }
2179
2180 //--------------------------------------------------------
2181
onNameChanged()2182 void StageSchematicSplineNode::onNameChanged() {
2183 m_nameItem->hide();
2184 m_splineName = m_nameItem->toPlainText();
2185 m_splinePainter->setName(m_splineName);
2186 setToolTip(m_splineName);
2187 setFlag(QGraphicsItem::ItemIsSelectable, true);
2188
2189 m_spline->setName(m_splineName.toStdString());
2190 update();
2191 }
2192
2193 //--------------------------------------------------------
2194
onChangedSize(bool expanded)2195 void StageSchematicSplineNode::onChangedSize(bool expanded) {
2196 prepareGeometryChange();
2197 m_isOpened = expanded;
2198 m_spline->setIsOpened(m_isOpened);
2199 m_height = 18;
2200 updateLinksGeometry();
2201 update();
2202 }
2203
2204 //========================================================
2205 //
2206 // class StageSchematicSplineNode
2207 //
2208 //========================================================
2209
StageSchematicGroupNode(StageSchematicScene * scene,TStageObject * root,const QList<TStageObject * > groupedObj)2210 StageSchematicGroupNode::StageSchematicGroupNode(
2211 StageSchematicScene *scene, TStageObject *root,
2212 const QList<TStageObject *> groupedObj)
2213 : StageSchematicNode(scene, root, 90, 18, true)
2214 , m_root(root)
2215 , m_groupedObj(groupedObj) {
2216 int i;
2217 for (i = 0; i < m_groupedObj.size(); i++) m_groupedObj[i]->addRef();
2218 bool ret = true;
2219 std::wstring name = m_stageObject->getGroupName(false);
2220 m_name = QString::fromStdWString(name);
2221
2222 m_nameItem = new SchematicName(this, 72, 20);
2223 m_nameItem->setName(m_name);
2224 m_nameItem->setPos(16, -1);
2225 m_nameItem->setZValue(2);
2226 ret = ret &&
2227 connect(m_nameItem, SIGNAL(focusOut()), this, SLOT(onNameChanged()));
2228 m_nameItem->hide();
2229
2230 // m_childDocks[0]->setPos(m_width - 18, 0);
2231 // m_parentDock->setPos(0, 0);
2232
2233 m_painter = new GroupPainter(this, m_width, m_height, m_name);
2234 m_painter->setZValue(1);
2235
2236 QString id = "Group " + QString::number(getGroupId());
2237 if (m_name != id)
2238 setToolTip(QString("%1 (%2)").arg(m_name, id));
2239 else
2240 setToolTip(m_name);
2241
2242 assert(ret);
2243 }
2244
2245 //--------------------------------------------------------
2246
~StageSchematicGroupNode()2247 StageSchematicGroupNode::~StageSchematicGroupNode() {
2248 int i;
2249 for (i = 0; i < m_groupedObj.size(); i++) m_groupedObj[i]->release();
2250 }
2251
2252 //--------------------------------------------------------
2253
boundingRect() const2254 QRectF StageSchematicGroupNode::boundingRect() const {
2255 return QRectF(-5, -5, m_width + 10, m_height + 10);
2256 }
2257
2258 //--------------------------------------------------------
2259
paint(QPainter * painter,const QStyleOptionGraphicsItem * option,QWidget * widget)2260 void StageSchematicGroupNode::paint(QPainter *painter,
2261 const QStyleOptionGraphicsItem *option,
2262 QWidget *widget) {}
2263
2264 //--------------------------------------------------------
2265
mouseDoubleClickEvent(QGraphicsSceneMouseEvent * me)2266 void StageSchematicGroupNode::mouseDoubleClickEvent(
2267 QGraphicsSceneMouseEvent *me) {
2268 QRectF nameArea(14, 0, m_width - 15, 14);
2269 if (nameArea.contains(me->pos())) {
2270 m_name = QString::fromStdWString(m_root->getGroupName(false));
2271 m_nameItem->setPlainText(m_name);
2272 m_nameItem->show();
2273 m_nameItem->setFocus();
2274 setFlag(QGraphicsItem::ItemIsSelectable, false);
2275 }
2276 }
2277
2278 //--------------------------------------------------------
2279
onNameChanged()2280 void StageSchematicGroupNode::onNameChanged() {
2281 StageSchematicScene *stageScene =
2282 dynamic_cast<StageSchematicScene *>(scene());
2283 if (!stageScene) return;
2284 m_nameItem->hide();
2285 m_name = m_nameItem->toPlainText();
2286 m_painter->setName(m_name);
2287 QString id = "Group " + QString::number(getGroupId());
2288 if (m_name != id)
2289 setToolTip(QString("%1 (%2)").arg(m_name, id));
2290 else
2291 setToolTip(m_name);
2292 setFlag(QGraphicsItem::ItemIsSelectable, true);
2293
2294 TStageObjectCmd::renameGroup(m_groupedObj, m_name.toStdWString(), false,
2295 stageScene->getXsheetHandle());
2296 update();
2297 }
2298
2299 //--------------------------------------------------------
2300
getGroupId()2301 int StageSchematicGroupNode::getGroupId() { return m_root->getGroupId(); }
2302
2303 //--------------------------------------------------------
2304
onChangedSize(bool expanded)2305 void StageSchematicGroupNode::onChangedSize(bool expanded) {
2306 prepareGeometryChange();
2307 m_isOpened = expanded;
2308 int i;
2309 for (i = 0; i < m_groupedObj.size(); i++)
2310 m_groupedObj[i]->setIsOpened(m_isOpened);
2311 if (m_isOpened) {
2312 m_height = 59;
2313 m_nameItem->setPos(4, -6);
2314 } else {
2315 m_height = 14;
2316 m_nameItem->setPos(8, -2);
2317 }
2318 updatePortsPosition();
2319 updateLinksGeometry();
2320 update();
2321 }
2322
2323 //--------------------------------------------------------
2324
updateObjsDagPosition(const TPointD & pos) const2325 void StageSchematicGroupNode::updateObjsDagPosition(const TPointD &pos) const {
2326 TPointD oldPos = m_root->getDagNodePos();
2327 TPointD delta = pos - oldPos;
2328 int i;
2329 for (i = 0; i < m_groupedObj.size(); i++) {
2330 // If the node position is unidentified, then leave the placement of it to
2331 // placeNode() function.
2332 if (m_groupedObj[i]->getDagNodePos() != TConst::nowhere)
2333 m_groupedObj[i]->setDagNodePos(m_groupedObj[i]->getDagNodePos() + delta);
2334 }
2335 }
2336
2337 //--------------------------------------------------------
2338
updatePortsPosition()2339 void StageSchematicGroupNode::updatePortsPosition() {
2340 qreal middleY = m_isOpened ? (14 + m_height) * 0.5 : m_height * 0.5;
2341 qreal y = middleY - (m_parentDock->getPort()->boundingRect().height() * 0.5);
2342
2343 m_parentDock->setPos(-m_parentDock->boundingRect().width(), y);
2344 updateChildDockPositions();
2345 }
2346
2347 //--------------------------------------------------------
2348
resize(bool maximized)2349 void StageSchematicGroupNode::resize(bool maximized) {}
2350
