Node& node)

: _scene(scene)

, _node(node)

, _locked(false)

, _proxyWidget(nullptr)

{

_scene.addItem(this);

setFlag(QGraphicsItem::ItemDoesntPropagateOpacityToChildren, true);

setFlag(QGraphicsItem::ItemIsMovable, true);

setFlag(QGraphicsItem::ItemIsFocusable, true);

setFlag(QGraphicsItem::ItemIsSelectable, true);

setFlag(QGraphicsItem::ItemSendsScenePositionChanges, true);

setCacheMode( QGraphicsItem::DeviceCoordinateCache );

auto const &nodeStyle = node.nodeDataModel()->nodeStyle();

{

auto effect = new QGraphicsDropShadowEffect;

effect->setOffset(4, 4);

effect->setBlurRadius(20);

effect->setColor(nodeStyle.ShadowColor);

setGraphicsEffect(effect);

}

setOpacity(nodeStyle.Opacity);

setAcceptHoverEvents(true);

setZValue(0);

embedQWidget();

// connect to the move signals to emit the move signals in FlowScene

auto onMoveSlot = [this] {

_scene.nodeMoved(_node, pos());

};

connect(this, &QGraphicsObject::xChanged, this, onMoveSlot);

connect(this, &QGraphicsObject::yChanged, this, onMoveSlot);

{

NodeGeometry & geom = _node.nodeGeometry();

if (auto w = _node.nodeDataModel()->embeddedWidget())

{

_proxyWidget = new QGraphicsProxyWidget(this);

_proxyWidget->setWidget(w);

_proxyWidget->setPreferredWidth(5);

geom.recalculateSize();

_proxyWidget->setPos(geom.widgetPosition());

update();

_proxyWidget->setOpacity(1.0);

_proxyWidget->setFlag(QGraphicsItem::ItemIgnoresParentOpacity);

}

{

NodeState const & nodeState = _node.nodeState();

auto moveConnections =

[&](PortType portType)

{

auto const & connectionEntries =

nodeState.getEntries(portType);

for (auto const & connections : connectionEntries)

{

for (auto & con : connections)

con.second->getConnectionGraphicsObject().move();

}

};

moveConnections(PortType::In);

moveConnections(PortType::Out);

{

_locked = locked;

setFlag(QGraphicsItem::ItemIsMovable, !locked);

setFlag(QGraphicsItem::ItemIsFocusable, !locked);

setFlag(QGraphicsItem::ItemIsSelectable, !locked);

QStyleOptionGraphicsItem const* option,

QWidget* )

{

painter->setClipRect(option->exposedRect);

NodePainter::paint(painter, _node, _scene);

{

if (change == ItemPositionChange && scene())

{

moveConnections();

}

return QGraphicsItem::itemChange(change, value);

{

if(_locked) return;

// deselect all other items after this one is selected

if (!isSelected() &&

!(event->modifiers() & Qt::ControlModifier))

{

_scene.clearSelection();

}

auto clickPort =

[&](PortType portToCheck)

{

NodeGeometry & nodeGeometry = _node.nodeGeometry();

// TODO do not pass sceneTransform

int portIndex = nodeGeometry.checkHitScenePoint(portToCheck,

event->scenePos(),

sceneTransform());

if (portIndex != INVALID)

{

NodeState const & nodeState = _node.nodeState();

std::unordered_map<QUuid, Connection*> connections =

nodeState.connections(portToCheck, portIndex);

// start dragging existing connection

if (!connections.empty() && portToCheck == PortType::In)

{

auto con = connections.begin()->second;

NodeConnectionInteraction interaction(_node, *con, _scene);

interaction.disconnect(portToCheck);

}

else // initialize new Connection

{

const auto outPolicy = _node.nodeDataModel()->portOutConnectionPolicy(portIndex);

if (!connections.empty() &&

portToCheck == PortType::Out &&

outPolicy == NodeDataModel::ConnectionPolicy::One)

{

_scene.deleteConnection( *connections.begin()->second );

}

// todo add to FlowScene

auto connection = _scene.createConnection(portToCheck,

_node,

portIndex);

_node.nodeState().setConnection(portToCheck,

portIndex,

*connection);

connection->getConnectionGraphicsObject().grabMouse();

}

}

};

clickPort(PortType::In);

clickPort(PortType::Out);

auto pos = event->pos();

auto & geom = _node.nodeGeometry();

auto & state = _node.nodeState();

if (_node.nodeDataModel()->resizable() &&

geom.resizeRect().contains(QPoint(pos.x(),

pos.y())))

{

state.setResizing(true);

}

{

auto & geom = _node.nodeGeometry();

auto & state = _node.nodeState();

if (state.resizing())

{

auto diff = event->pos() - event->lastPos();

if (auto w = _node.nodeDataModel()->embeddedWidget())

{

prepareGeometryChange();

auto oldSize = w->size();

oldSize += QSize(diff.x(), diff.y());

w->setFixedSize(oldSize);

_proxyWidget->setMinimumSize(oldSize);

_proxyWidget->setMaximumSize(oldSize);

_proxyWidget->setPos(geom.widgetPosition());

geom.recalculateSize();

update();

moveConnections();

event->accept();

}

}

else

{

QGraphicsObject::mouseMoveEvent(event);

if (event->lastPos() != event->pos())

moveConnections();

event->ignore();

}

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

r = r.united(mapToScene(boundingRect()).boundingRect());

scene()->setSceneRect(r);

{

auto & state = _node.nodeState();

state.setResizing(false);

QGraphicsObject::mouseReleaseEvent(event);

// position connections precisely after fast node move

moveConnections();

{

// bring all the colliding nodes to background

QList<QGraphicsItem *> overlapItems = collidingItems();

for (QGraphicsItem *item : overlapItems)

{

if (item->zValue() > 0.0)

{

item->setZValue(0.0);

}

}

// bring this node forward

setZValue(1.0);

_node.nodeGeometry().setHovered(true);

update();

_scene.nodeHovered(node(), event->screenPos());

event->accept();

{

_node.nodeGeometry().setHovered(false);

update();

_scene.nodeHoverLeft(node());

event->accept();

{

auto pos = event->pos();

auto & geom = _node.nodeGeometry();

if (_node.nodeDataModel()->resizable() &&

geom.resizeRect().contains(QPoint(pos.x(), pos.y())))

{

setCursor(QCursor(Qt::SizeFDiagCursor));

}

else

{

setCursor(QCursor());

}

event->accept();

{

QGraphicsItem::mouseDoubleClickEvent(event);

_scene.nodeDoubleClicked(node());