VuoRendererInputListDrawer.cc

Go to the documentation of this file.

 
#include "VuoRendererInputListDrawer.hh"
#include "VuoRendererPort.hh"
#include "VuoRendererSignaler.hh"
 
VuoRendererInputListDrawer::VuoRendererInputListDrawer(VuoNode *baseNode, VuoRendererSignaler *signaler)
    : VuoRendererInputDrawer(baseNode, signaler)
{
    dragInProgress = false;
 
    this->dragHandleIsHovered = false;
    mousePositionAtLastPortCountAdjustment = QPointF(NAN,NAN);
 
    updateCachedBoundingRect();
}
 
void VuoRendererInputListDrawer::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
    VuoNode *hostNode = getUnderlyingHostNode();
    if (hostNode && hostNode->hasRenderer() && hostNode->getRenderer()->isSelected() && !isSelected())
        this->setSelected(true);
 
    drawBoundingRect(painter);
 
    VuoRendererColors::SelectionType selectionType = (isSelected()? VuoRendererColors::directSelection : VuoRendererColors::noSelection);
    qint64 timeOfLastActivity = (getRenderActivity()? timeLastExecutionEnded : VuoRendererItem::notTrackingActivity);
    VuoRendererColors *drawerColors = new VuoRendererColors(getBase()->getTintColor(),
                                                      selectionType,
                                                      false,
                                                      _eligibilityHighlight,
                                                      timeOfLastActivity);
 
    VuoRendererColors *dragHandleColors = new VuoRendererColors(getBase()->getTintColor(),
                                                      selectionType,
                                                      dragHandleIsHovered,
                                                      _eligibilityHighlight,
                                                      timeOfLastActivity);
 
    // Drawer frame
    QPainterPath drawerFrame = getDrawerPath(true);
    painter->fillPath(drawerFrame, drawerColors->nodeFill());
 
    // Drag handle
    if (dragHandleIsHovered)
    {
        painter->setClipPath(drawerFrame);
        painter->fillRect(getDragHandleRect(), dragHandleColors->nodeFill());
        painter->setClipping(false);
    }
    painter->fillPath(getMakeListDragHandlePath(), dragHandleColors->nodeFrame());
 
    // Child input ports
    layoutPorts();
 
    delete drawerColors;
    delete dragHandleColors;
}
 
QPainterPath VuoRendererInputListDrawer::getMakeListNodePath() const
{
    QPainterPath p;
    p.addPath(getDrawerPath(true));
    return p;
}
 
QPainterPath VuoRendererInputListDrawer::getMakeListDragHandlePath() const
{
    QPainterPath p;
    QRectF r = getDragHandleRect();
    QRectF r2(floor(r.center().x()) - 3, r.top()+2, 7, 1);
    p.addRoundedRect(r2, 1,1);
    return p;
}
 
QRectF VuoRendererInputListDrawer::boundingRect(void) const
{
    return cachedBoundingRect;
}
 
void VuoRendererInputListDrawer::updateCachedBoundingRect()
{
    cachedBoundingRect = getMakeListNodePath().boundingRect();
    cachedBoundingRect = cachedBoundingRect.united(getExtendedDragHandleRect());
 
    // Antialiasing bleed
    cachedBoundingRect.adjust(-1,-1,1,1);
 
    cachedBoundingRect = cachedBoundingRect.toAlignedRect();
}
 
void VuoRendererInputListDrawer::updateGeometry()
{
    VuoRendererInputDrawer::updateGeometry();
    updateCachedBoundingRect();
}
 
QPainterPath VuoRendererInputListDrawer::shape() const
{
    QPainterPath p;
    p.addPath(getDrawerPath(true));
    p.addRect(getExtendedDragHandleRect());
    p.setFillRule(Qt::WindingFill);
 
    return p;
}
 
QRectF VuoRendererInputListDrawer::getDragHandleRect() const
{
    const qreal handleVerticalOffset = 6;
    const qreal handleHeight = 6;
    qreal drawerBottomExtensionWidth = getMaxDrawerLabelWidth();
 
    return QRectF(VuoRendererPort::portRadius - 1,
                  drawerBottomExtensionHeight + handleVerticalOffset,
                  qRound(drawerBottomExtensionWidth) - VuoRendererPort::portRadius + 1,
                  handleHeight);
}
 
QRectF VuoRendererInputListDrawer::getExtendedDragHandleRect() const
{
    return getDragHandleRect().adjusted(-3,-5,3,5);
}
 
void VuoRendererInputListDrawer::extendedHoverEnterEvent(QPointF scenePos)
{
    bool cursorAboveDragHandle = (getExtendedDragHandleRect().translated(this->scenePos()).contains(scenePos));
    prepareGeometryChange();
    dragHandleIsHovered = cursorAboveDragHandle;
}
 
void VuoRendererInputListDrawer::extendedHoverMoveEvent(QPointF scenePos)
{
    bool cursorAboveDragHandle = (getExtendedDragHandleRect().translated(this->scenePos()).contains(scenePos));
    prepareGeometryChange();
    dragHandleIsHovered = cursorAboveDragHandle;
}
 
void VuoRendererInputListDrawer::extendedHoverLeaveEvent()
{
    prepareGeometryChange();
    dragHandleIsHovered = false;
}
 
void VuoRendererInputListDrawer::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
    bool leftButtonPressed = (event->button() == Qt::LeftButton);
    bool pressedOnDragHandle = (getExtendedDragHandleRect().contains(event->pos()));
    if (leftButtonPressed && pressedOnDragHandle)
    {
        setDragInProgress(true);
        mousePositionAtLastPortCountAdjustment = event->pos();
    }
 
    else
        QGraphicsItem::mousePressEvent(event);
}
 
void VuoRendererInputListDrawer::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
    bool leftMouseButtonPressed = (event->buttons() & Qt::LeftButton);
 
    if (leftMouseButtonPressed && dragInProgress)
    {
        if (isnan(mousePositionAtLastPortCountAdjustment.y()))
            mousePositionAtLastPortCountAdjustment = event->pos();
 
        QPointF delta = event->pos() - mousePositionAtLastPortCountAdjustment;
        double steps = delta.y() / VuoRendererPort::portSpacing;
 
        // If the user has dragged the drag handle down, add 1 or more input ports.
        if (steps >= 1.)
            triggerPortCountAdjustment(round(steps), event);
 
        // If the user has dragged the drag handle up, remove 1 or more input ports.
        else if (steps <= -1. && drawerPorts.size() >= 1)
            triggerPortCountAdjustment(fmax(-(int)drawerPorts.size(), round(steps)), event);
    }
 
    else
        QGraphicsItem::mouseMoveEvent(event);
}
 
void VuoRendererInputListDrawer::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
    if (event->button() == Qt::LeftButton)
    {
        if (scene() && (scene()->mouseGrabberItem() == this))
            ungrabMouse();
 
        setDragInProgress(false);
 
        VuoRendererNode::mouseReleaseEvent(event);
    }
 
    else
        QGraphicsItem::mouseReleaseEvent(event);
}
 
void VuoRendererInputListDrawer::setDragInProgress(bool inProgress)
{
    updateGeometry();
    this->dragInProgress = inProgress;
 
    if (signaler)
        signaler->signalDisableDragStickiness(inProgress);
 
    mousePositionAtLastPortCountAdjustment = QPointF(NAN,NAN);
}
 
void VuoRendererInputListDrawer::triggerPortCountAdjustment(int portCountDelta, QGraphicsSceneMouseEvent *event)
{
    mousePositionAtLastPortCountAdjustment = event->pos();
    dragHandleIsHovered = false;
 
    if (signaler)
        signaler->signalInputPortCountAdjustmentRequested(this, portCountDelta, true);
}
 
QRectF VuoRendererInputListDrawer::getOuterNodeFrameBoundingRect(void) const
{
    return getDrawerPath(true).boundingRect();
}