: _nodeId(nodeId)

, _graphModel(scene.graphModel())

, _nodeState(*this)

, _proxyWidget(nullptr)

{

scene.addItem(this);

setFlag(QGraphicsItem::ItemDoesntPropagateOpacityToChildren, true);

setFlag(QGraphicsItem::ItemSendsScenePositionChanges, true);

setLockedState();

setCacheMode(QGraphicsItem::DeviceCoordinateCache);

// commented for performance

// since we are not using shadow and opacity no need to be called

// updateStyle();

setAcceptHoverEvents(true);

setZValue(0);

embedQWidget();

nodeScene()->nodeGeometry().recomputeSize(_nodeId);

QPointF const pos = _graphModel.nodeData<QPointF>(_nodeId, NodeRole::Position);

setPos(pos);

connect(&_graphModel, &AbstractGraphModel::nodeFlagsUpdated, this, [this](NodeId const nodeId) {

if (_nodeId == nodeId)

setLockedState();

});

{

AbstractNodeGeometry &geometry = nodeScene()->nodeGeometry();

geometry.recomputeSize(_nodeId);

if (auto w = _graphModel.nodeData(_nodeId, NodeRole::Widget).value<QWidget *>()) {

_proxyWidget = new QGraphicsProxyWidget(this);

_proxyWidget->setWidget(w);

_proxyWidget->setPreferredWidth(5);

geometry.recomputeSize(_nodeId);

if (w->sizePolicy().verticalPolicy() & QSizePolicy::ExpandFlag) {

unsigned int widgetHeight = geometry.size(_nodeId).height()

- geometry.captionRect(_nodeId).height();

// If the widget wants to use as much vertical space as possible, set

// it to have the geom's equivalentWidgetHeight.

_proxyWidget->setMinimumHeight(widgetHeight);

}

_proxyWidget->setPos(geometry.widgetPosition(_nodeId));

//update();

_proxyWidget->setOpacity(1.0);

_proxyWidget->setFlag(QGraphicsItem::ItemIgnoresParentOpacity);

}

{

NodeFlags flags = _graphModel.nodeFlags(_nodeId);

bool const locked = flags.testFlag(NodeFlag::Locked);

// should we check if realy changed!

_nodeState.setLocked(locked);

if (!_nodeState.isRoot()) {

setFlag(QGraphicsItem::ItemIsMovable, !locked);

setFlag(QGraphicsItem::ItemIsSelectable, !locked);

setFlag(QGraphicsItem::ItemIsFocusable, !locked);

}

update();

{

const QVariant style = _graphModel.nodeData(_nodeId, NodeRole::Style);

NodeStyle nodeStyle(style);

auto effect = dynamic_cast<QGraphicsDropShadowEffect *>(graphicsEffect());

// creating shadow effect has negative impact on the performance.

if (nodeStyle.ShadowColor != Qt::transparent && effect == nullptr) {

effect = new QGraphicsDropShadowEffect;

effect->setOffset(0, 0);

effect->setBlurRadius(10);

setGraphicsEffect(effect);

}

if (nodeStyle.ShadowColor == Qt::transparent) {

setGraphicsEffect(nullptr);

} else {

effect->setColor(nodeStyle.ShadowColor);

}

setOpacity(nodeStyle.Opacity);

{

AbstractNodeGeometry &geometry = nodeScene()->nodeGeometry();

return geometry.boundingRect(_nodeId);

//return NodeGeometry(_nodeId, _graphModel, nodeScene()).boundingRect();

{

AbstractNodeGeometry &geometry = nodeScene()->nodeGeometry();

_proxyWidget->setPos(geometry.widgetPosition(_nodeId));

{

auto const &connected = _graphModel.allConnectionIds(_nodeId);

for (auto &cnId : connected) {

auto cgo = nodeScene()->connectionGraphicsObject(cnId);

if (cgo)

cgo->move();

}

{

_nodeState.storeConnectionForReaction(cgo);

update();

{

painter->setClipRect(option->exposedRect);

nodeScene()->nodePainter().paint(painter, *this);

{

if (change == ItemScenePositionHasChanged && scene()) {

moveConnections();

}

return QGraphicsObject::itemChange(change, value);

{

if (_nodeState.locked())

return;

AbstractNodeGeometry &geometry = nodeScene()->nodeGeometry();

for (PortType portToCheck : {PortType::In, PortType::Out}) {

QPointF nodeCoord = sceneTransform().inverted().map(event->scenePos());

PortIndex const portIndex = geometry.checkPortHit(_nodeId, portToCheck, nodeCoord);

if (portIndex == InvalidPortIndex)

continue;

auto const &connected = _graphModel.connections(_nodeId, portToCheck, portIndex);

// Start dragging existing connection.

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

auto const &cnId = *connected.begin();

// Need ConnectionGraphicsObject

NodeConnectionInteraction interaction(*this,

*nodeScene()->connectionGraphicsObject(cnId),

*nodeScene());

if (_graphModel.detachPossible(cnId))

interaction.disconnect(portToCheck);

} else // initialize new Connection

{

if (portToCheck == PortType::Out) {

auto const outPolicy = _graphModel

.portData(_nodeId,

portToCheck,

portIndex,

PortRole::ConnectionPolicyRole)

.value<ConnectionPolicy>();

if (!connected.empty() && outPolicy == ConnectionPolicy::One) {

for (auto &cnId : connected) {

_graphModel.deleteConnection(cnId);

// not handled in nodeeditor undo events

Q_EMIT nodeScene()->connectionRemoved();

}

}

ConnectionId const incompleteConnectionId = makeIncompleteConnectionId(_nodeId,

portToCheck,

portIndex);

nodeScene()->makeDraftConnection(incompleteConnectionId);

// otherwise we will have a error connecting the root!

if (_nodeState.isRoot())

return;

} // if port == out

}

}

if (_graphModel.nodeFlags(_nodeId) & NodeFlag::Resizable) {

auto pos = event->pos();

bool const hit = geometry.resizeHandleRect(_nodeId).contains(QPoint(pos.x(), pos.y()));

_nodeState.setResizing(hit);

}

auto otherButtons = event->buttons() ^ event->button();

if (otherButtons == Qt::NoButton) {

_nodeState.setPressedPos(event->scenePos());

}

QGraphicsObject::mousePressEvent(event);

if (isSelected()) {

Q_EMIT nodeScene()->nodeSelected(_nodeId);

}

{

if (_nodeState.locked())

return;

// Deselect all other items after this one is selected.

// Unless we press a CTRL button to add the item to the selected group before

// starting moving.

if (!isSelected()) {

if (!event->modifiers().testFlag(Qt::ControlModifier))

scene()->clearSelection();

setSelected(true);

Q_EMIT nodeScene()->nodeSelected(_nodeId);

}

if (_nodeState.resizing()) {

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

if (auto w = _graphModel.nodeData<QWidget *>(_nodeId, NodeRole::Widget)) {

prepareGeometryChange();

auto oldSize = w->size();

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

w->resize(oldSize);

AbstractNodeGeometry &geometry = nodeScene()->nodeGeometry();

// Passes the new size to the model.

geometry.recomputeSize(_nodeId);

update();

moveConnections();

event->accept();

}

} else {

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

nodeScene()->undoStack().push(new MoveNodeCommand(nodeScene(), diff));

event->accept();

}

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

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

nodeScene()->setSceneRect(r);

{

if (_nodeState.locked())

return;

if (!_nodeState.resizing() && _nodeState.pressedPos() != event->scenePos()) {

Q_EMIT nodeScene()->nodeMoved(_nodeId, scenePos());

auto otherButtons = event->buttons();

if (otherButtons == Qt::NoButton) {

_nodeState.setPressedPos(event->scenePos());

}

}

_nodeState.setResizing(false);

QGraphicsObject::mouseReleaseEvent(event);

// position connections precisely after fast node move

moveConnections();

if (isSelected()) {

Q_EMIT nodeScene()->nodeSelected(_nodeId);

}

Q_EMIT nodeScene()->nodeClicked(_nodeId);

{

// bring all the colliding nodes to background

QList<QGraphicsItem *> overlapItems = collidingItems();

for (QGraphicsItem *item : overlapItems) {

if (item->zValue() > 0.0 && item->zValue() < 20) {

item->setZValue(0.0);

}

}

// bring this node forward

setZValue(1.0);

_nodeState.setHovered(true);

update();

Q_EMIT nodeScene()->nodeHovered(_nodeId, event->screenPos());

event->accept();

{

_nodeState.setHovered(false);

setZValue(0.0);

update();

Q_EMIT nodeScene()->nodeHoverLeft(_nodeId);

event->accept();

{

auto pos = event->pos();

//NodeGeometry geometry(_nodeId, _graphModel, nodeScene());

AbstractNodeGeometry &geometry = nodeScene()->nodeGeometry();

if ((_graphModel.nodeFlags(_nodeId) | NodeFlag::Resizable)

&& geometry.resizeHandleRect(_nodeId).contains(QPoint(pos.x(), pos.y()))) {

setCursor(QCursor(Qt::SizeFDiagCursor));

} else {

setCursor(QCursor());

}

event->accept();

{

QGraphicsItem::mouseDoubleClickEvent(event);

Q_EMIT nodeScene()->nodeDoubleClicked(_nodeId);

{

if (_nodeState.locked() || _nodeState.isRoot())

return;

Q_EMIT nodeScene()->nodeContextMenu(_nodeId, mapToScene(event->pos()));