: QGraphicsView(parent)

, _clearSelectionAction(Q_NULLPTR)

, _deleteSelectionAction(Q_NULLPTR)

, _duplicateSelectionAction(Q_NULLPTR)

, _copySelectionAction(Q_NULLPTR)

, _pasteAction(Q_NULLPTR)

{

setDragMode(QGraphicsView::ScrollHandDrag);

setRenderHint(QPainter::Antialiasing);

setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

setTransformationAnchor(QGraphicsView::AnchorUnderMouse);

setCacheMode(QGraphicsView::CacheBackground);

setViewportUpdateMode(QGraphicsView::BoundingRectViewportUpdate);

auto const &flowViewStyle = StyleCollection::flowViewStyle();

setBackgroundBrush(flowViewStyle.BackgroundColor);

setScaleRange(0.3, 2);

// Sets the scene rect to its maximum possible ranges to avoid autu scene range

// re-calculation when expanding the all QGraphicsItems common rect.

int maxSize = 32767;

setSceneRect(-maxSize, -maxSize, (maxSize * 2), (maxSize * 2));

: GraphicsView(parent)

{

setScene(scene);

{

QGraphicsView::setScene(scene);

{

// setup actions

delete _clearSelectionAction;

_clearSelectionAction = new QAction(QStringLiteral("Clear Selection"), this);

_clearSelectionAction->setShortcutContext(Qt::ShortcutContext::WidgetShortcut);

_clearSelectionAction->setShortcut(Qt::Key_Escape);

connect(_clearSelectionAction, &QAction::triggered, scene, &QGraphicsScene::clearSelection);

addAction(_clearSelectionAction);

}

{

delete _deleteSelectionAction;

_deleteSelectionAction = new QAction(QStringLiteral("Delete Selection"), this);

_deleteSelectionAction->setShortcutContext(Qt::ShortcutContext::WidgetShortcut);

_deleteSelectionAction->setShortcut(QKeySequence(QKeySequence::Delete));

connect(_deleteSelectionAction,

&QAction::triggered,

this,

&GraphicsView::onDeleteSelectedObjects);

addAction(_deleteSelectionAction);

}

// as we handle manually

return;

{

delete _duplicateSelectionAction;

_duplicateSelectionAction = new QAction(QStringLiteral("Duplicate Selection"), this);

_duplicateSelectionAction->setShortcutContext(Qt::ShortcutContext::WidgetShortcut);

_duplicateSelectionAction->setShortcut(QKeySequence(Qt::CTRL | Qt::Key_D));

connect(_duplicateSelectionAction,

&QAction::triggered,

this,

&GraphicsView::onDuplicateSelectedObjects);

addAction(_duplicateSelectionAction);

}

{

delete _copySelectionAction;

_copySelectionAction = new QAction(QStringLiteral("Copy Selection"), this);

_copySelectionAction->setShortcutContext(Qt::ShortcutContext::WidgetShortcut);

_copySelectionAction->setShortcut(QKeySequence(QKeySequence::Copy));

connect(_copySelectionAction,

&QAction::triggered,

this,

&GraphicsView::onCopySelectedObjects);

addAction(_copySelectionAction);

}

{

delete _pasteAction;

_pasteAction = new QAction(QStringLiteral("Copy Selection"), this);

_pasteAction->setShortcutContext(Qt::ShortcutContext::WidgetShortcut);

_pasteAction->setShortcut(QKeySequence(QKeySequence::Paste));

connect(_pasteAction, &QAction::triggered, this, &GraphicsView::onPasteObjects);

addAction(_pasteAction);

}

auto undoAction = scene->undoStack().createUndoAction(this, tr("&Undo"));

undoAction->setShortcuts(QKeySequence::Undo);

addAction(undoAction);

auto redoAction = scene->undoStack().createRedoAction(this, tr("&Redo"));

redoAction->setShortcuts(QKeySequence::Redo);

addAction(redoAction);

{

if (scene()) {

scene()->setSceneRect(QRectF());

QRectF sceneRect = scene()->sceneRect();

if (sceneRect.width() > this->rect().width() || sceneRect.height() > this->rect().height()) {

fitInView(sceneRect, Qt::KeepAspectRatio);

}

centerOn(sceneRect.center());

}

{

if (itemAt(event->pos())) {

QGraphicsView::contextMenuEvent(event);

return;

}

auto const scenePos = mapToScene(event->pos());

QMenu *menu = nodeScene()->createSceneMenu(scenePos);

if (menu) {

menu->exec(event->globalPos());

}

nodeScene()->cleanupSceneMenu(menu);

{

QPoint delta = event->angleDelta();

if (delta.y() == 0) {

event->ignore();

return;

}

double const d = delta.y() / std::abs(delta.y());

if (d > 0.0)

scaleUp();

else

scaleDown();

{

if (maximum < minimum)

std::swap(minimum, maximum);

minimum = std::max(0.0, minimum);

maximum = std::max(0.0, maximum);

_scaleRange = {minimum, maximum};

setupScale(transform().m11());

{

minimum = _scaleRange.minimum;

maximum = _scaleRange.maximum;

{

double const step = 1.2;

double const factor = std::pow(step, 1.0);

if (_scaleRange.maximum > 0) {

QTransform t = transform();

t.scale(factor, factor);

if (t.m11() >= _scaleRange.maximum) {

setupScale(t.m11());

return;

}

}

scale(factor, factor);

Q_EMIT scaleChanged(transform().m11());

{

double const step = 1.2;

double const factor = std::pow(step, -1.0);

if (_scaleRange.minimum > 0) {

QTransform t = transform();

t.scale(factor, factor);

if (t.m11() <= _scaleRange.minimum) {

setupScale(t.m11());

return;

}

}

scale(factor, factor);

Q_EMIT scaleChanged(transform().m11());

{

scale = std::max(_scaleRange.minimum, std::min(_scaleRange.maximum, scale));

if (scale <= 0)

return;

if (scale == transform().m11())

return;

QTransform matrix;

matrix.scale(scale, scale);

setTransform(matrix, false);

Q_EMIT scaleChanged(scale);

{

QPointF const pastePosition = scenePastePosition();

nodeScene()->undoStack().push(new CopyCommand(nodeScene()));

nodeScene()->undoStack().push(new PasteCommand(nodeScene(), pastePosition));

{

QPointF const pastePosition = scenePastePosition();

nodeScene()->undoStack().push(new PasteCommand(nodeScene(), pastePosition));

{

switch (event->key()) {

case Qt::Key_Shift:

setDragMode(QGraphicsView::RubberBandDrag);

break;

default:

break;

}

QGraphicsView::keyPressEvent(event);

{

switch (event->key()) {

case Qt::Key_Shift:

setDragMode(QGraphicsView::ScrollHandDrag);

break;

default:

break;

}

QGraphicsView::keyReleaseEvent(event);

{

if (!itemAt(event->pos())) {

Q_EMIT voidPressed();

}

QGraphicsView::mousePressEvent(event);

if (event->button() == Qt::LeftButton) {

_clickPos = mapToScene(event->pos());

}

{

QGraphicsView::mouseMoveEvent(event);

if (scene()->mouseGrabberItem() == nullptr && event->buttons() == Qt::LeftButton) {

// Make sure shift is not being pressed

if ((event->modifiers() & Qt::ShiftModifier) == 0) {

QPointF difference = _clickPos - mapToScene(event->pos());

setSceneRect(sceneRect().translated(difference.x(), difference.y()));

}

}

{

auto const &flowViewStyle = StyleCollection::flowViewStyle();

if (backgroundBrush().color() != flowViewStyle.BackgroundColor) {

// might be needed if style changed at runtime

setBackgroundBrush(flowViewStyle.BackgroundColor);

}

QGraphicsView::drawBackground(painter, r);

auto drawGrid = [&](double gridStep) {

QRect windowRect = rect();

QPointF tl = mapToScene(windowRect.topLeft());

QPointF br = mapToScene(windowRect.bottomRight());

double left = std::floor(tl.x() / gridStep - 0.5);

double right = std::floor(br.x() / gridStep + 1.0);

double bottom = std::floor(tl.y() / gridStep - 0.5);

double top = std::floor(br.y() / gridStep + 1.0);

// vertical lines

for (int xi = int(left); xi <= int(right); ++xi) {

QLineF line(xi * gridStep, bottom * gridStep, xi * gridStep, top * gridStep);

painter->drawLine(line);

}

// horizontal lines

for (int yi = int(bottom); yi <= int(top); ++yi) {

QLineF line(left * gridStep, yi * gridStep, right * gridStep, yi * gridStep);

painter->drawLine(line);

}

};

QPen pfine(flowViewStyle.FineGridColor, 1.0);

painter->setPen(pfine);

drawGrid(15);

QPen p(flowViewStyle.CoarseGridColor, 1.0);

painter->setPen(p);

drawGrid(150);

{

QGraphicsView::showEvent(event);

centerScene();

{

QPoint origin = mapFromGlobal(QCursor::pos());

QRect const viewRect = rect();

if (!viewRect.contains(origin))

origin = viewRect.center();

return mapToScene(origin);