#include <NodeDelegate.h>

Inheritance diagram for NodeDelegate:

Classes
class	Private

Public Slots
void	slotConfigChanged ()

Signals
void	resetVisibilityStasis ()

Public Member Functions
QWidget *	createEditor (QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const override

void	drawBranches (QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const

bool	editorEvent (QEvent event, QAbstractItemModel model, const QStyleOptionViewItem &option, const QModelIndex &index) override

	NodeDelegate (NodeView view, QObject parent=0)

void	paint (QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const override

void	setModelData (QWidget editor, QAbstractItemModel model, const QModelIndex &index) const override

QSize	sizeHint (const QStyleOptionViewItem &option, const QModelIndex &index) const override

void	slotUpdateIcon ()

void	toggleSolo (const QModelIndex &index)

void	updateEditorGeometry (QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &index) const override

	~NodeDelegate () override

Protected Member Functions
bool	eventFilter (QObject object, QEvent event) override

Private Types
typedef KisNodeModel	Model

typedef NodeView	View

Private Slots
void	slotResetState ()

Private Member Functions
void	changeSelectionAndCurrentIndex (const QModelIndex &index)

QRect	decorationClickRect (const QStyleOptionViewItem &option, const QModelIndex &index) const

void	drawAnimatedDecoration (QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const

void	drawColorLabel (QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const

void	drawDecoration (QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const

void	drawExpandButton (QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const

void	drawFrame (QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const

void	drawIcons (QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const

void	drawProgressBar (QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const

void	drawSelectedButton (QPainter p, const QStyleOptionViewItem &option, const QModelIndex &index, QStyle style) const

void	drawText (QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const

void	drawThumbnail (QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const

void	drawVisibilityIcon (QPainter *p, const QStyleOptionViewItem &option, const QModelIndex &index) const

QRect	filterColorClickRect (const QStyleOptionViewItem &option, const QModelIndex &index) const

QRect	iconsRect (const QStyleOptionViewItem &option, const QModelIndex &index) const

QRect	textRect (const QStyleOptionViewItem &option, const QModelIndex &index) const

QRect	thumbnailClickRect (const QStyleOptionViewItem &option, const QModelIndex &index) const

QRect	visibilityClickRect (const QStyleOptionViewItem &option, const QModelIndex &index) const

Static Private Member Functions
static QStyleOptionViewItem	getOptions (const QStyleOptionViewItem &option, const QModelIndex &index)

Private Attributes
Private *const	d

Detailed Description

See KisNodeModel and NodeView.

A delegate provides the gui machinery, using Qt's model/view terminology. This class is owned by NodeView to do the work of generating the graphical representation of each item.

Definition at line 22 of file NodeDelegate.h.

Member Typedef Documentation

◆ Model

typedef KisNodeModel NodeDelegate::Model

private

Definition at line 50 of file NodeDelegate.h.

◆ View

typedef NodeView NodeDelegate::View

private

Definition at line 51 of file NodeDelegate.h.

Constructor & Destructor Documentation

◆ NodeDelegate()

NodeDelegate::NodeDelegate	(	NodeView *	view,
		QObject *	parent = 0 )

explicit

Definition at line 89 of file NodeDelegate.cpp.

    : QAbstractItemDelegate(parent)
    , d(new Private(this))
{
    d->view = view;
 
    QApplication::instance()->installEventFilter(this);
    connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
    connect(this, SIGNAL(resetVisibilityStasis()), SLOT(slotResetState()));
    slotConfigChanged();
}

References connect(), d, KisConfigNotifier::instance(), resetVisibilityStasis(), slotConfigChanged(), slotResetState(), and NodeDelegate::Private::view.

◆ ~NodeDelegate()

NodeDelegate::~NodeDelegate ( )

override

Definition at line 101 of file NodeDelegate.cpp.

{
    delete d;
}

References d.

Member Function Documentation

◆ changeSelectionAndCurrentIndex()

void NodeDelegate::changeSelectionAndCurrentIndex ( const QModelIndex & index )

private

Definition at line 1166 of file NodeDelegate.cpp.

{
    QItemSelectionModel *selectionModel = d->view->selectionModel();
    const bool wasSelected = selectionModel->isRowSelected(index.row(), index.parent());
 
    // if only one item is selected and that too is us then in that case we don't do anything to
    // the selection.
    if (selectionModel->selectedIndexes().size() == 1
        && selectionModel->isRowSelected(index.row(), index.parent())) {
        selectionModel->select(index, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
    } else {
        selectionModel->select(index, QItemSelectionModel::Toggle | QItemSelectionModel::Rows);
    }
 
    const auto belongToSameRow = [](const QModelIndex &a, const QModelIndex &b) {
        return a.row() == b.row() && a.parent() == b.parent();
    };
 
    // in this condition we move the current index to the best guessed previous one.
    if (wasSelected && belongToSameRow(selectionModel->currentIndex(), index)) {
        selectionModel->setCurrentIndex(selectionModel->selectedRows().last(), QItemSelectionModel::NoUpdate);
    }
}

References d, and NodeDelegate::Private::view.

◆ createEditor()

QWidget * NodeDelegate::createEditor	(	QWidget *	parent,
		const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

override

Definition at line 1190 of file NodeDelegate.cpp.

{
    // #400357 do not override QAbstractItemDelegate::setEditorData to update editor's text
    // because replacing the text while user type is confusing
    const QString &text = index.data(Qt::DisplayRole).toString();
    d->edit = new QLineEdit(text, parent);
    d->edit->setFocusPolicy(Qt::StrongFocus);
    d->edit->installEventFilter(const_cast<NodeDelegate*>(this)); //hack?
    return d->edit;
}

References d, and NodeDelegate::Private::edit.

◆ decorationClickRect()

QRect NodeDelegate::decorationClickRect	(	const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

private

Definition at line 818 of file NodeDelegate.cpp.

{
    Q_UNUSED(index);
    KisNodeViewColorScheme scm;
 
    QRect rc = scm.relDecorationRect();
 
    // Move to current index
    rc.moveTop(option.rect.topLeft().y());
    rc.setHeight(d->rowHeight);
    // Move to correct location.
    if (option.direction == Qt::RightToLeft) {
        rc.moveRight(option.rect.right() - d->thumbnailGeometry.width());
    } else {
        rc.moveLeft(option.rect.left() + d->thumbnailGeometry.width());
    }
 
    return rc;
}

References d, KisNodeViewColorScheme::relDecorationRect(), NodeDelegate::Private::rowHeight, and NodeDelegate::Private::thumbnailGeometry.

◆ drawAnimatedDecoration()

void NodeDelegate::drawAnimatedDecoration	(	QPainter *	p,
		const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

private

Definition at line 932 of file NodeDelegate.cpp.

                                                                                                                         {
 
    KisNodeViewColorScheme scm;
    QRect rc = decorationClickRect(option, index);
 
    QIcon animatedIndicatorIcon = KisIconUtils::loadIcon("layer-animated");
    const bool isAnimated = index.data(KisNodeModel::IsAnimatedRole).toBool();
 
    rc = kisGrowRect(rc, -(scm.decorationMargin()+scm.border()));
 
    if (!isAnimated) return;
 
    if ((option.state & QStyle::State_Children)) return;
 
    const qreal oldOpacity = p->opacity(); // remember previous opacity
 
    if (!(option.state & QStyle::State_Enabled)) {
        p->setOpacity(0.35);
    }
 
    int decorationSize = scm.decorationSize();
 
    QPixmap animPixmap = animatedIndicatorIcon.pixmap(decorationSize,
                                 (option.state & QStyle::State_Enabled) ?
                                 QIcon::Normal : QIcon::Disabled);
 
    p->drawPixmap(rc.bottomLeft()-QPoint(0, scm.decorationSize()-1), animPixmap);
 
    p->setOpacity(oldOpacity);
}

References KisNodeViewColorScheme::border(), decorationClickRect(), KisNodeViewColorScheme::decorationMargin(), KisNodeViewColorScheme::decorationSize(), KisNodeModel::IsAnimatedRole, kisGrowRect(), KisIconUtils::loadIcon(), and p.

◆ drawBranches()

void NodeDelegate::drawBranches	(	QPainter *	p,
		const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

Definition at line 151 of file NodeDelegate.cpp.

{
    p->save();
    drawFrame(p, option, index);
    p->restore();
 
    QModelIndex tmp = index.parent();
 
    // there is no indentation if we have no parent group, so don't draw a branch
    if (!tmp.isValid()) return;
 
    const KisNodeViewColorScheme &scm = *KisNodeViewColorScheme::instance();
 
    int rtlNum = (option.direction == Qt::RightToLeft) ? 1 : -1;
    QPoint nodeCorner = (option.direction == Qt::RightToLeft) ? option.rect.topLeft() : option.rect.topRight();
    int branchSpacing = rtlNum * d->view->indentation();
 
    QPoint base = nodeCorner + 0.5 * QPoint(branchSpacing, option.rect.height()) + QPoint(0, scm.iconSize()/4);
 
    QColor color = scm.gridColor(option, d->view);
    QColor bgColor = option.state & QStyle::State_Selected ?
        qApp->palette().color(QPalette::Base) :
        qApp->palette().color(QPalette::Text);
    color = KisPaintingTweaks::blendColors(color, bgColor, 0.9);
 
    // TODO: if we are a mask type, use dotted lines for the branch style
    // p->setPen(QPen(p->pen().color(), 2, Qt::DashLine, Qt::RoundCap, Qt::RoundJoin));
    p->setPen(QPen(color, 0, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
 
    QPoint p2 = base - QPoint(rtlNum*(qMin(d->view->indentation(), scm.iconSize())/2), 0);
    QPoint p3 = base - QPoint(0, scm.iconSize()/2);
    p->drawLine(base, p2);
    p->drawLine(base, p3);
 
    // draw parent lines (keep drawing until x position is less than 0
    QPoint parentBase1 = base + QPoint(branchSpacing, 0);
    QPoint parentBase2 = p3 + QPoint(branchSpacing, 0);
 
    // indent lines needs to be very subtle to avoid making the docker busy looking
    color = KisPaintingTweaks::blendColors(color, bgColor, 0.9); // makes it a little lighter than L lines
    p->setPen(QPen(color, 0, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
 
 
    int levelRowIndex = tmp.row();
    tmp = tmp.parent(); // Ignore the first group as it was already painted
 
    while (tmp.isValid()) {
        bool moreSiblings = index.model()->rowCount(tmp) > (levelRowIndex + 1);
        if (moreSiblings) {
            p->drawLine(parentBase1, parentBase2);
        }
 
        parentBase1 += QPoint(branchSpacing, 0);
        parentBase2 += QPoint(branchSpacing, 0);
 
        levelRowIndex = tmp.row();
        tmp = tmp.parent();
    }
}

References KisPaintingTweaks::blendColors(), d, drawFrame(), KisNodeViewColorScheme::gridColor(), KisNodeViewColorScheme::iconSize(), KisNodeViewColorScheme::instance(), p, p2, p3, and NodeDelegate::Private::view.

◆ drawColorLabel()

void NodeDelegate::drawColorLabel	(	QPainter *	p,
		const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

private

Definition at line 211 of file NodeDelegate.cpp.

{
    KisNodeViewColorScheme scm;
    const int label = index.data(KisNodeModel::ColorLabelIndexRole).toInt();
    QColor color = scm.colorFromLabelIndex(label);
    if (color.alpha() <= 0) return;
 
    QColor bgColor = qApp->palette().color(QPalette::Base);
    color = KisPaintingTweaks::blendColors(color, bgColor, 0.3);
 
    QRect optionRect = (option.state & QStyle::State_Selected) ? iconsRect(option, index) : option.rect;
 
    p->fillRect(optionRect, color);
}

References KisPaintingTweaks::blendColors(), KisNodeViewColorScheme::colorFromLabelIndex(), KisNodeModel::ColorLabelIndexRole, iconsRect(), and p.

◆ drawDecoration()

void NodeDelegate::drawDecoration	(	QPainter *	p,
		const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

private

Definition at line 882 of file NodeDelegate.cpp.

{
    KisNodeViewColorScheme scm;
    QIcon icon = index.data(Qt::DecorationRole).value<QIcon>();
 
    if (!icon.isNull()) {
        QPixmap pixmap = icon.pixmap(scm.decorationSize(),
                                     (option.state & QStyle::State_Enabled) ?
                                     QIcon::Normal : QIcon::Disabled);
 
        QRect rc = decorationClickRect(option, index);
 
        // Shrink to icon rect
        rc = kisGrowRect(rc, -(scm.decorationMargin()+scm.border()));
 
        const qreal oldOpacity = p->opacity(); // remember previous opacity
 
        if (!(option.state & QStyle::State_Enabled)) {
            p->setOpacity(0.35);
        }
 
        p->drawPixmap(rc.topLeft()-QPoint(0, 1), pixmap);
 
        p->setOpacity(oldOpacity); // restore old opacity
    }
}

References KisNodeViewColorScheme::border(), decorationClickRect(), KisNodeViewColorScheme::decorationMargin(), KisNodeViewColorScheme::decorationSize(), kisGrowRect(), and p.

◆ drawExpandButton()

void NodeDelegate::drawExpandButton	(	QPainter *	p,
		const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

private

Definition at line 909 of file NodeDelegate.cpp.

{
    Q_UNUSED(index);
    KisNodeViewColorScheme scm;
 
    QRect rc = decorationClickRect(option, index);
 
    // Move to current index
//     rc.moveTop(option.rect.topLeft().y());
    // Shrink to icon rect
    rc = kisGrowRect(rc, -(scm.decorationMargin()+scm.border()));
 
    if (!(option.state & QStyle::State_Children)) return;
 
    QString iconName = option.state & QStyle::State_Open ?
        "arrow-down" : ((option.direction == Qt::RightToLeft) ? "arrow-left" : "arrow-right");
    QIcon icon = KisIconUtils::loadIcon(iconName);
    QPixmap pixmap = icon.pixmap(rc.width(),
                                 (option.state & QStyle::State_Enabled) ?
                                 QIcon::Normal : QIcon::Disabled);
    p->drawPixmap(rc.bottomLeft()-QPoint(0, scm.decorationSize()-1), pixmap);
}

References KisNodeViewColorScheme::border(), decorationClickRect(), KisNodeViewColorScheme::decorationMargin(), KisNodeViewColorScheme::decorationSize(), kisGrowRect(), KisIconUtils::loadIcon(), and p.

◆ drawFrame()

void NodeDelegate::drawFrame	(	QPainter *	p,
		const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

private

Definition at line 226 of file NodeDelegate.cpp.

{
    KisNodeViewColorScheme scm;
 
    QPen oldPen = p->pen();
    p->setPen(scm.gridColor(option, d->view));
 
    const QRect visibilityRect = visibilityClickRect(option, index);
    const QRect thumbnailRect  = thumbnailClickRect(option, index);
    const QRect iconsRectR     = iconsRect(option, index);
 
    const float bottomY = thumbnailRect.bottomLeft().y();
 
    QPoint bottomLeftPoint;
    QPoint bottomRightPoint;
    if (option.direction == Qt::RightToLeft) {
        bottomLeftPoint = iconsRectR.bottomLeft();
        bottomRightPoint = visibilityRect.bottomRight();
    } else {
        bottomLeftPoint = visibilityRect.bottomLeft();
        bottomRightPoint = iconsRectR.bottomRight();
    }
 
    // bottom running horizontal line
    p->drawLine(bottomLeftPoint.x(), bottomY,
                bottomRightPoint.x(), bottomY);
 
    // icons' lines are drawn by drawIcons
 
    p->setPen(Qt::blue);
    //KritaUtils::renderExactRect(p, iconsRectR);
    //KritaUtils::renderExactRect(p, textRect(option, index));
    //KritaUtils::renderExactRect(p, visibilityRect);
 
    p->setPen(oldPen);
}

References d, KisNodeViewColorScheme::gridColor(), iconsRect(), p, thumbnailClickRect(), NodeDelegate::Private::view, and visibilityClickRect().

◆ drawIcons()

void NodeDelegate::drawIcons	(	QPainter *	p,
		const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

private

Definition at line 731 of file NodeDelegate.cpp.

{
    KisNodeViewColorScheme scm;
    const QRect rc = iconsRect(option, index);
 
    QTransform oldTransform = p->transform();
    QPen oldPen = p->pen();
    p->setTransform(QTransform::fromTranslate(rc.x(), rc.y()));
    p->setPen(scm.gridColor(option, d->view));
 
    int x = 0;
    const int y = (d->rowHeight - scm.border() - scm.iconSize()) / 2;
    KisBaseNode::PropertyList props = index.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
    QList<OptionalProperty> realProps = d->rightmostProperties(props);
 
    if (option.direction == Qt::RightToLeft) {
        std::reverse(realProps.begin(), realProps.end());
    }
 
    Q_FOREACH (OptionalProperty prop, realProps) {
        x += scm.iconMargin();
        if (prop) {
            QIcon icon = prop->state.toBool() ? prop->onIcon : prop->offIcon;
            bool fullColor = prop->state.toBool() && option.state & QStyle::State_Enabled;
 
            const qreal oldOpacity = p->opacity(); // remember previous opacity
            if (fullColor) {
                p->setOpacity(1.0);
            } else {
                p->setOpacity(0.35);
            }
 
            if (prop->id == KisLayerPropertiesIcons::colorOverlay.id()) {
                // Parent layer can show its color overlay mask color here.
                QRect colorRect(x, y, scm.iconSize(), scm.iconSize());
                colorRect = colorRect.marginsRemoved(QMargins(2, 1, 2, 1));
                p->fillRect(colorRect, index.data(KisNodeModel::LayerColorOverlayColorRole).value<QColor>());
                p->drawRect(colorRect);
            } else {
                p->drawPixmap(x, y, icon.pixmap(scm.iconSize(), QIcon::Normal));
            }
            p->setOpacity(oldOpacity); // restore old opacity
        }
        x += scm.iconSize() + scm.iconMargin();
 
        x += scm.border();
    }
 
    // Draw a color preview "icon" for some types of filter masks,
    // but especially for KisFilterFastColorOverlay.
 
    if (index.data(KisNodeModel::FilterMaskColorRole).isNull() == false) {
        if (!(option.state & QStyle::State_Enabled)) {
            p->setOpacity(0.35);
        } else {
            p->setOpacity(1.0);
        }
 
        const QRect colorRect = filterColorClickRect(option, index).translated(-rc.x(), -rc.y());
        p->fillRect(colorRect, index.data(KisNodeModel::FilterMaskColorRole).value<QColor>());
        p->drawRect(colorRect);
    }
 
    p->setTransform(oldTransform);
    p->setPen(oldPen);
}

References KisNodeViewColorScheme::border(), KisLayerPropertiesIcons::colorOverlay, d, filterColorClickRect(), KisNodeModel::FilterMaskColorRole, KisNodeViewColorScheme::gridColor(), KisNodeViewColorScheme::iconMargin(), KisNodeViewColorScheme::iconSize(), iconsRect(), KoID::id(), KisBaseNode::Property::id, KisNodeModel::LayerColorOverlayColorRole, KisBaseNode::Property::offIcon, KisBaseNode::Property::onIcon, p, KisNodeModel::PropertiesRole, NodeDelegate::Private::rightmostProperties(), NodeDelegate::Private::rowHeight, KisBaseNode::Property::state, and NodeDelegate::Private::view.

◆ drawProgressBar()

void NodeDelegate::drawProgressBar	(	QPainter *	p,
		const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

private

The progress bar will display under the layer name area. The bars have accurate data, so we probably don't need to also show the actual number for % complete

Definition at line 1319 of file NodeDelegate.cpp.

{
    QVariant value = index.data(KisNodeModel::ProgressRole);
    if (!value.isNull() && (value.toInt() >= 0 && value.toInt() <= 100)) {
 
 
        KisNodeViewColorScheme scm;
 
        const QRect thumbnailRect = thumbnailClickRect(option, index);
        const QRect iconsRectR    = iconsRect(option, index);
        const int height = 5;
        const QRect rc = QRect(
            ((option.direction == Qt::RightToLeft) ?
              iconsRectR.bottomRight() :
              thumbnailRect.bottomRight()) - QPoint(0, height),
            ((option.direction == Qt::RightToLeft) ?
              thumbnailRect.bottomLeft() :
              iconsRectR.bottomLeft()));
 
        p->save();
        {
            p->setClipRect(rc);
            QStyle* style = QApplication::style();
            QStyleOptionProgressBar opt;
 
            opt.rect = rc;
            opt.minimum = 0;
            opt.maximum = 100;
            opt.progress = value.toInt();
            opt.textVisible = false;
            opt.textAlignment = Qt::AlignHCenter;
            opt.text = i18n("%1 %", opt.progress);
            opt.state = option.state;
            style->drawControl(QStyle::CE_ProgressBar, &opt, p, 0);
        }
        p->restore();
    }
}

References iconsRect(), p, KisNodeModel::ProgressRole, thumbnailClickRect(), and value().

◆ drawSelectedButton()

void NodeDelegate::drawSelectedButton	(	QPainter *	p,
		const QStyleOptionViewItem &	option,
		const QModelIndex &	index,
		QStyle *	style ) const

private

Definition at line 963 of file NodeDelegate.cpp.

{
    QStyleOptionButton buttonOption;
 
    KisNodeViewColorScheme scm;
    QRect rect = option.rect;
 
    // adjust the icon to not touch the borders
    rect = kisGrowRect(rect, -(scm.thumbnailMargin() + scm.border()));
    // Make the rect a square so the check mark is not distorted. also center
    // it horizontally and vertically with respect to the whole area rect
    constexpr qint32 maximumAllowedSideLength = 48;
    const qint32 minimumSideLength = qMin(rect.width(), rect.height());
    const qint32 sideLength = qMin(minimumSideLength, maximumAllowedSideLength);
    rect =
        QRect(rect.left() + static_cast<qint32>(qRound(static_cast<qreal>(rect.width() - sideLength) / 2.0)),
              rect.top() + static_cast<qint32>(qRound(static_cast<qreal>(rect.height() - sideLength) / 2.0)),
              sideLength, sideLength);
 
    buttonOption.rect = rect;
 
    // Update palette colors to make the check box more readable over the base
    // color
    const QColor prevBaseColor = buttonOption.palette.base().color();
    const qint32 windowLightness = buttonOption.palette.window().color().lightness();
    const qint32 baseLightness = prevBaseColor.lightness();
    const QColor newBaseColor =
        baseLightness > windowLightness ? prevBaseColor.lighter(120) : prevBaseColor.darker(120);
    buttonOption.palette.setColor(QPalette::Window, prevBaseColor);
    buttonOption.palette.setColor(QPalette::Base, newBaseColor);
 
    // check if the current index exists in the selected rows.
    buttonOption.state.setFlag((d->view->selectionModel()->isRowSelected(index.row(), index.parent())
                                    ? QStyle::State_On
                                    : QStyle::State_Off));
    style->drawPrimitive(QStyle::PE_IndicatorCheckBox, &buttonOption, p);
}

References KisNodeViewColorScheme::border(), d, kisGrowRect(), p, KisNodeViewColorScheme::thumbnailMargin(), and NodeDelegate::Private::view.

◆ drawText()

void NodeDelegate::drawText	(	QPainter *	p,
		const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

private

Definition at line 363 of file NodeDelegate.cpp.

{
    KisNodeViewColorScheme scm;
    const QRect rc = textRect(option, index).adjusted(scm.textMargin(), 0,
                                                      -scm.textMargin(), 0);
 
    QPen oldPen = p->pen();
    const qreal oldOpacity = p->opacity(); // remember previous opacity
 
    p->setPen(option.palette.color(QPalette::Active,QPalette::Text ));
 
    if (!(option.state & QStyle::State_Enabled)) {
        p->setOpacity(0.55);
    }
 
    const QString text = index.data(Qt::DisplayRole).toString();
    const QString elided = p->fontMetrics().elidedText(text, Qt::ElideRight, rc.width());
    KisConfig cfg(true);
    if (cfg.layerInfoTextStyle() == KisConfig::LayerInfoTextStyle::INFOTEXT_NONE) {
        p->drawText(rc, Qt::AlignLeft | Qt::AlignVCenter, elided);
    }
    else {
        const QString infoText = index.data(KisNodeModel::InfoTextRole).toString();
        if (infoText.isEmpty()) {
            p->drawText(rc, Qt::AlignLeft | Qt::AlignVCenter, elided);
        } else {
            bool useOneLine = cfg.useInlineLayerInfoText();
            if (!useOneLine) {
                // check whether there is enough space for two lines
                const int textHeight = p->fontMetrics().height();
                useOneLine = rc.height() < textHeight*2;
            }
 
            const int rectCenter = rc.height()/2;
            const int nameWidth = p->fontMetrics().horizontalAdvance(elided);
            // draw the layer name
            if (!useOneLine) {
                // enforce Qt::TextSingleLine because we are adding a line below it
                p->drawText(rc.adjusted(0, 0, 0, -rectCenter), Qt::AlignLeft | Qt::AlignBottom | Qt::TextSingleLine, elided);
            }
            else {
                p->drawText(rc.adjusted(0, 0, 0, 0), Qt::AlignLeft | Qt::AlignVCenter, elided);
            }
            // draw the info-text
            p->save();
            QFont layerInfoTextFont = p->font();
            layerInfoTextFont.setBold(false);
            p->setFont(layerInfoTextFont);
            if (option.state & QStyle::State_Enabled) {
                p->setOpacity(qreal(cfg.layerInfoTextOpacity())/100);
            }
            if (!useOneLine) {
                const QString infoTextElided = p->fontMetrics().elidedText(infoText, Qt::ElideRight, rc.width());
                p->drawText(rc.adjusted(0, rectCenter, 0, 0), Qt::AlignLeft | Qt::AlignTop, infoTextElided);
            }
            else {
                const QString infoTextElided = p->fontMetrics().elidedText(" "+infoText, Qt::ElideRight, rc.width()-nameWidth);
                p->drawText(rc.adjusted(nameWidth, 0, 0, 0), Qt::AlignLeft | Qt::AlignVCenter, infoTextElided);
            }
            p->restore();
        }
    }
 
    p->setPen(oldPen); // restore pen settings
    p->setOpacity(oldOpacity);
}

References KisConfig::INFOTEXT_NONE, KisNodeModel::InfoTextRole, KisConfig::layerInfoTextOpacity(), KisConfig::layerInfoTextStyle(), p, KisNodeViewColorScheme::textMargin(), textRect(), and KisConfig::useInlineLayerInfoText().

◆ drawThumbnail()

void NodeDelegate::drawThumbnail	(	QPainter *	p,
		const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

private

Definition at line 282 of file NodeDelegate.cpp.

{
    KisNodeViewColorScheme scm;
 
    const qreal devicePixelRatio = p->device()->devicePixelRatioF();
    const int thumbSizeHighRes = d->thumbnailSize*devicePixelRatio;
 
    const qreal oldOpacity = p->opacity(); // remember previous opacity
 
    QImage img = index.data(int(KisNodeModel::BeginThumbnailRole) + thumbSizeHighRes).value<QImage>();
    img.setDevicePixelRatio(devicePixelRatio);
    if (!(option.state & QStyle::State_Enabled)) {
        p->setOpacity(0.35);
    }
 
    QRect fitRect = thumbnailClickRect(option, index);
    // Shrink to icon rect
    fitRect = kisGrowRect(fitRect, -(scm.thumbnailMargin()+scm.border()));
 
    QPoint offset;
    offset.setX((fitRect.width() - img.width()/devicePixelRatio) / 2);
    offset.setY((fitRect.height() - img.height()/devicePixelRatio) / 2);
    offset += fitRect.topLeft();
 
    QBrush brush(d->checkers);
    p->setBrushOrigin(offset);
    QRect imageRectLowRes = QRect(img.rect().topLeft(), img.rect().size()/devicePixelRatio);
    p->fillRect(imageRectLowRes.translated(offset), brush);
 
    p->drawImage(offset, img);
    p->setOpacity(oldOpacity); // restore old opacity
 
    QRect borderRect = kisGrowRect(imageRectLowRes, 1).translated(offset);
    KritaUtils::renderExactRect(p, borderRect, scm.gridColor(option, d->view));
}

References KisNodeModel::BeginThumbnailRole, KisNodeViewColorScheme::border(), NodeDelegate::Private::checkers, d, KisNodeViewColorScheme::gridColor(), kisGrowRect(), p, KritaUtils::renderExactRect(), thumbnailClickRect(), KisNodeViewColorScheme::thumbnailMargin(), NodeDelegate::Private::thumbnailSize, and NodeDelegate::Private::view.

◆ drawVisibilityIcon()

void NodeDelegate::drawVisibilityIcon	(	QPainter *	p,
		const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

private

Definition at line 838 of file NodeDelegate.cpp.

{
    KisNodeViewColorScheme scm;
 
    KisBaseNode::PropertyList props = index.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
    OptionalProperty prop = d->findVisibilityProperty(props);
    if (!prop) return;
 
    QRect fitRect = visibilityClickRect(option, index);
    // Shrink to icon rect
    fitRect = kisGrowRect(fitRect, -(scm.visibilityMargin() + scm.border()));
 
    QIcon icon = prop->state.toBool() ? prop->onIcon : prop->offIcon;
 
    // if we are not showing the layer, make the icon slightly transparent like other inactive icons
    const qreal oldOpacity = p->opacity();
 
    if (!prop->state.toBool()) {
        p->setOpacity(0.35);
    }
 
    QPixmap pixmapIcon(icon.pixmap(scm.visibilitySize(), QIcon::Active));
    p->drawPixmap(fitRect.x(), fitRect.center().y() - scm.visibilitySize() / 2, pixmapIcon);
 
    if (prop->isInStasis) {
        QPainter::CompositionMode prevComposition = p->compositionMode();
        p->setCompositionMode(QPainter::CompositionMode_HardLight);
        pixmapIcon = icon.pixmap(scm.visibilitySize(), QIcon::Active);
        QBitmap mask = pixmapIcon.mask();
        pixmapIcon.fill(d->view->palette().color(QPalette::Highlight));
        pixmapIcon.setMask(mask);
        p->drawPixmap(fitRect.x(), fitRect.center().y() - scm.visibilitySize() / 2, pixmapIcon);
        p->setCompositionMode(prevComposition);
    }
 
    p->setOpacity(oldOpacity);
 
// //     // p->save();
// //     // p->setPen(Qt::blue);
// //     // KritaUtils::renderExactRect(p, visibilityClickRect(option, index));
// //     // p->restore();
}

References KisNodeViewColorScheme::border(), d, NodeDelegate::Private::findVisibilityProperty(), kisGrowRect(), p, KisNodeModel::PropertiesRole, NodeDelegate::Private::view, visibilityClickRect(), KisNodeViewColorScheme::visibilityMargin(), and KisNodeViewColorScheme::visibilitySize().

◆ editorEvent()

bool NodeDelegate::editorEvent	(	QEvent *	event,
		QAbstractItemModel *	model,
		const QStyleOptionViewItem &	option,
		const QModelIndex &	index )

override

Definition at line 1038 of file NodeDelegate.cpp.

{
    if ((event->type() == QEvent::MouseButtonPress || event->type() == QEvent::MouseButtonDblClick)
        && (index.flags() & Qt::ItemIsEnabled))
    {
        QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
 
        const bool leftButton = mouseEvent->buttons() & Qt::LeftButton;
        const bool altButton = mouseEvent->modifiers() & Qt::AltModifier;
 
        if (index.column() == NodeView::VISIBILITY_COL) {
 
            const QRect visibilityRect = visibilityClickRect(option, index);
            const bool visibilityClicked = visibilityRect.isValid() && visibilityRect.contains(mouseEvent->pos());
            if (leftButton && visibilityClicked) {
                KisBaseNode::PropertyList props = index.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
                OptionalProperty clickedProperty = d->findVisibilityProperty(props);
                if (!clickedProperty) return false;
 
                d->toggleProperty(props, clickedProperty, mouseEvent->modifiers(), index);
 
                return true;
            }
            return false;
        } else if (index.column() == NodeView::SELECTED_COL) {
            if (leftButton && option.rect.contains(mouseEvent->pos())) {
                changeSelectionAndCurrentIndex(index);
                return true;
            }
        }
 
        const QRect thumbnailRect = thumbnailClickRect(option, index);
        const bool thumbnailClicked = thumbnailRect.isValid() &&
            thumbnailRect.contains(mouseEvent->pos());
 
        const QRect decorationRect = decorationClickRect(option, index);
        const bool decorationClicked = decorationRect.isValid() &&
            decorationRect.contains(mouseEvent->pos());
 
        const QRect filterRect = filterColorClickRect(option, index);
        const bool filterColorClicked =
            (index.data(KisNodeModel::FilterMaskColorRole).isNull() == false) &&
            filterRect.isValid() &&
            filterRect.contains(mouseEvent->pos());
 
        if (leftButton) {
            if (decorationClicked) {
                bool isExpandable = model->hasChildren(index);
                if (isExpandable) {
                    bool isExpanded = d->view->isExpanded(index);
                    d->view->setExpanded(index, !isExpanded);
                }
                return true;
 
            } else if (thumbnailClicked) {
                bool hasCorrectModifier = false;
                SelectionAction action = SELECTION_REPLACE;
 
                if (mouseEvent->modifiers() == Qt::ControlModifier) {
                    action = SELECTION_REPLACE;
                    hasCorrectModifier = true;
                } else if (mouseEvent->modifiers() == (Qt::ControlModifier | Qt::ShiftModifier)) {
                    action = SELECTION_ADD;
                    hasCorrectModifier = true;
                } else if (mouseEvent->modifiers() == (Qt::ControlModifier | Qt::AltModifier)) {
                    action = SELECTION_SUBTRACT;
                    hasCorrectModifier = true;
                } else if (mouseEvent->modifiers() == (Qt::ControlModifier | Qt::ShiftModifier | Qt::AltModifier)) {
                    action = SELECTION_INTERSECT;
                    hasCorrectModifier = true;
                }
 
                if (hasCorrectModifier) {
                    model->setData(index, QVariant(int(action)), KisNodeModel::SelectOpaqueRole);
                } else {
                    d->view->setCurrentIndex(index);
                }
                return hasCorrectModifier; //If not here then the item is !expanded when reaching return false;
 
            } else if (filterColorClicked) {
                model->setData(index, QVariant() /* unused */, KisNodeModel::FilterMaskPropertiesRole);
                return true;
 
            } else {
                auto clickedProperty = d->propForMousePos(index, mouseEvent->pos(), option);
 
                if (!clickedProperty) {
                    if (altButton) {
                        d->view->setCurrentIndex(index);
                        model->setData(index, true, KisNodeModel::AlternateActiveRole);
 
                        return true;
                    } else if (mouseEvent->modifiers() == Qt::ControlModifier) {
                        // the control modifier shifts the current index as well (even when deselected), so we
                        // handle it manually.
                        changeSelectionAndCurrentIndex(index);
                        return true;
                    }
                    return false;
                }
 
                KisBaseNode::PropertyList props = index.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
                d->toggleProperty(props, &(*clickedProperty), mouseEvent->modifiers(), index);
                return true;
            }
        }
    }
    else if (event->type() == QEvent::ToolTip) {
        if (!KisConfig(true).hidePopups()) {
            QHelpEvent *helpEvent = static_cast<QHelpEvent*>(event);
 
            auto hoveredProperty = d->propForMousePos(index, helpEvent->pos(), option);
            if (hoveredProperty &&
                    (hoveredProperty->id == KisLayerPropertiesIcons::layerError.id() ||
                     hoveredProperty->id == KisLayerPropertiesIcons::layerColorSpaceMismatch.id())) {
                QToolTip::showText(helpEvent->globalPos(), hoveredProperty->state.toString(), d->view);
            } else {
                d->tip.showTip(d->view, helpEvent->pos(), option, index);
            }
        }
        return true;
    } else if (event->type() == QEvent::Leave) {
        d->tip.hide();
    }
 
    return false;
}

References KisNodeModel::AlternateActiveRole, changeSelectionAndCurrentIndex(), d, decorationClickRect(), filterColorClickRect(), KisNodeModel::FilterMaskColorRole, KisNodeModel::FilterMaskPropertiesRole, NodeDelegate::Private::findVisibilityProperty(), KisConfig::hidePopups(), KoID::id(), KisLayerPropertiesIcons::layerColorSpaceMismatch, KisLayerPropertiesIcons::layerError, KisNodeModel::PropertiesRole, NodeDelegate::Private::propForMousePos(), NodeView::SELECTED_COL, SELECTION_ADD, SELECTION_INTERSECT, SELECTION_REPLACE, SELECTION_SUBTRACT, KisNodeModel::SelectOpaqueRole, KoItemToolTip::showTip(), thumbnailClickRect(), NodeDelegate::Private::tip, NodeDelegate::Private::toggleProperty(), NodeDelegate::Private::view, NodeView::VISIBILITY_COL, and visibilityClickRect().

◆ eventFilter()

bool NodeDelegate::eventFilter	(	QObject *	object,
		QEvent *	event )

overrideprotected

Definition at line 1225 of file NodeDelegate.cpp.

{
    switch (event->type()) {
    case QEvent::MouseButtonPress: {
        if (d->edit) {
            QMouseEvent *me = static_cast<QMouseEvent*>(event);
            if (!QRect(d->edit->mapToGlobal(QPoint()), d->edit->size()).contains(me->globalPos())) {
                Q_EMIT commitData(d->edit);
                Q_EMIT closeEditor(d->edit);
            }
        }
    } break;
    case QEvent::KeyPress: {
        QLineEdit *edit = qobject_cast<QLineEdit*>(object);
        if (edit && edit == d->edit) {
            QKeyEvent *ke = static_cast<QKeyEvent*>(event);
            switch (ke->key()) {
            case Qt::Key_Escape:
                Q_EMIT closeEditor(edit);
                return true;
            case Qt::Key_Tab:
                Q_EMIT commitData(edit);
                Q_EMIT closeEditor(edit, EditNextItem);
                return true;
            case Qt::Key_Backtab:
                Q_EMIT commitData(edit);
                Q_EMIT closeEditor(edit, EditPreviousItem);
                return true;
            case Qt::Key_Return:
            case Qt::Key_Enter:
                Q_EMIT commitData(edit);
                Q_EMIT closeEditor(edit);
                return true;
            default: break;
            }
        }
    } break;
    case QEvent::ShortcutOverride : {
        QLineEdit *edit = qobject_cast<QLineEdit*>(object);
        if (edit && edit == d->edit){
            auto* key = static_cast<QKeyEvent*>(event);
            if (key->modifiers() == Qt::NoModifier){
                switch (key->key()){
                case Qt::Key_Escape:
                case Qt::Key_Tab:
                case Qt::Key_Backtab:
                case Qt::Key_Return:
                case Qt::Key_Enter:
                    event->accept();
                    return true;
                default: break;
                }
            }
        }
 
    } break;
    case QEvent::FocusOut : {
        QLineEdit *edit = qobject_cast<QLineEdit*>(object);
        if (edit && edit == d->edit) {
            Q_EMIT commitData(edit);
            Q_EMIT closeEditor(edit);
        }
    }
    default: break;
    }
 
    return QAbstractItemDelegate::eventFilter(object, event);
}

References d, and NodeDelegate::Private::edit.

◆ filterColorClickRect()

QRect NodeDelegate::filterColorClickRect	(	const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

private

Definition at line 1416 of file NodeDelegate.cpp.

{
    KisNodeViewColorScheme scm;
    const QRect icons = iconsRect(option, index);
 
    // Filter masks have two unused properties/icons,
    // and we can use that space to draw the filter's selected color.
 
    QRect rc;
    const int dx = scm.iconSize() + scm.iconMargin();
    if (option.direction == Qt::RightToLeft) {
        // The free space is at the beginning on the left.
        rc.setRect(0, 0, icons.width() - dx, icons.height());
    } else {
        // The free space is at the end on the right.
        rc.setRect(dx, 0, icons.width() - dx, icons.height());
    }
    rc = rc.marginsRemoved(QMargins(8, 10, 8, 10));
 
    rc.translate(icons.x(), icons.y());
 
    return rc;
}

References KisNodeViewColorScheme::iconMargin(), KisNodeViewColorScheme::iconSize(), and iconsRect().

◆ getOptions()

QStyleOptionViewItem NodeDelegate::getOptions	(	const QStyleOptionViewItem &	option,
		const QModelIndex &	index )

staticprivate

Definition at line 1298 of file NodeDelegate.cpp.

{
    QStyleOptionViewItem option = o;
    QVariant v = index.data(Qt::FontRole);
    if (v.isValid()) {
        option.font = v.value<QFont>();
        option.fontMetrics = QFontMetrics(option.font);
    }
    v = index.data(Qt::TextAlignmentRole);
    if (v.isValid())
        option.displayAlignment = QFlag(v.toInt());
    v = index.data(Qt::ForegroundRole);
    if (v.isValid())
        option.palette.setColor(QPalette::Text, v.value<QColor>());
    v = index.data(Qt::BackgroundRole);
    if (v.isValid())
        option.palette.setColor(QPalette::Window, v.value<QColor>());
 
   return option;
}

References v.

◆ iconsRect()

QRect NodeDelegate::iconsRect	(	const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

private

Definition at line 318 of file NodeDelegate.cpp.

{
    KisNodeViewColorScheme scm;
 
    int propCount = d->numProperties(index);
 
    const int iconsWidth =
        propCount * (scm.iconSize() + 2 * scm.iconMargin()) +
        (propCount + 1) * scm.border();
 
    QRect fitRect = QRect(0, 0, iconsWidth, d->rowHeight - scm.border());
    // Move to current index
    fitRect.moveTop(option.rect.topLeft().y());
    // Move to correct location.
    if (option.direction == Qt::RightToLeft) {
        fitRect.moveLeft(option.rect.topLeft().x());
    } else {
        fitRect.moveRight(option.rect.topRight().x());
    }
 
    return fitRect;
}

References KisNodeViewColorScheme::border(), d, KisNodeViewColorScheme::iconMargin(), KisNodeViewColorScheme::iconSize(), NodeDelegate::Private::numProperties(), and NodeDelegate::Private::rowHeight.

◆ paint()

void NodeDelegate::paint	(	QPainter *	painter,
		const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

override

Definition at line 115 of file NodeDelegate.cpp.

{
    p->save();
 
    {
        QStyleOptionViewItem option = getOptions(o, index);
        QStyle *style = option.widget ? option.widget->style() : QApplication::style();
        style->drawPrimitive(QStyle::PE_PanelItemViewItem, &option, p, option.widget);
 
        bool shouldGrayOut = index.data(KisNodeModel::ShouldGrayOutRole).toBool();
        if (shouldGrayOut) {
            option.state &= ~QStyle::State_Enabled;
        }
 
        drawFrame(p, option, index);
 
        if (index.column() == NodeView::SELECTED_COL) {
            drawSelectedButton(p, o, index, style);
        } else if (index.column() == NodeView::VISIBILITY_COL) {
            drawVisibilityIcon(p, option, index); // TODO hide when dragging
        } else {
            p->setFont(option.font);
            drawColorLabel(p, option, index);
            drawThumbnail(p, option, index);
            drawText(p, option, index); // BUG: Creating group moves things around (RTL-layout alignment)
            drawIcons(p, option, index);
            drawDecoration(p, option, index);
            drawExpandButton(p, option, index);
            drawAnimatedDecoration(p, option, index);
 
            drawProgressBar(p, option, index);
        }
    }
    p->restore();
}

References drawAnimatedDecoration(), drawColorLabel(), drawDecoration(), drawExpandButton(), drawFrame(), drawIcons(), drawProgressBar(), drawSelectedButton(), drawText(), drawThumbnail(), drawVisibilityIcon(), getOptions(), p, NodeView::SELECTED_COL, KisNodeModel::ShouldGrayOutRole, and NodeView::VISIBILITY_COL.

◆ resetVisibilityStasis

void NodeDelegate::resetVisibilityStasis ( )

signal

◆ setModelData()

void NodeDelegate::setModelData	(	QWidget *	editor,
		QAbstractItemModel *	model,
		const QModelIndex &	index ) const

override

Definition at line 1201 of file NodeDelegate.cpp.

{
    QLineEdit *edit = qobject_cast<QLineEdit*>(widget);
    Q_ASSERT(edit);
 
    model->setData(index, edit->text(), Qt::DisplayRole);
}

◆ sizeHint()

QSize NodeDelegate::sizeHint	(	const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

override

Definition at line 106 of file NodeDelegate.cpp.

{
    KisNodeViewColorScheme scm;
    if (index.column() == NodeView::VISIBILITY_COL) {
        return QSize(scm.visibilityColumnWidth(), d->rowHeight);
    }
    return QSize(option.rect.width(), d->rowHeight);
}

References d, NodeDelegate::Private::rowHeight, NodeView::VISIBILITY_COL, and KisNodeViewColorScheme::visibilityColumnWidth().

◆ slotConfigChanged

void NodeDelegate::slotConfigChanged ( )

slot

Definition at line 1360 of file NodeDelegate.cpp.

{
    KisConfig cfg(true);
    const int oldHeight = d->rowHeight;
    // cache values that require a config lookup and get used frequently
    d->thumbnailSize = KisNodeViewColorScheme::instance()->thumbnailSize();
    d->thumbnailGeometry = KisNodeViewColorScheme::instance()->relThumbnailRect();
    d->rowHeight = KisNodeViewColorScheme::instance()->rowHeight();
 
    const QColor newCheckersColor1 = cfg.checkersColor1();
    const QColor newCheckersColor2 = cfg.checkersColor2();
 
    // generate the checker backdrop for thumbnails
    const int step = d->thumbnailSize / 6;
    if ((d->checkers.width() != 2 * step) ||
        (d->checkersColor1 != newCheckersColor1) ||
        (d->checkersColor2 != newCheckersColor2)) {
 
        d->checkersColor1 = newCheckersColor1;
        d->checkersColor2 = newCheckersColor2;
        d->checkers = QImage(2 * step, 2 * step, QImage::Format_ARGB32);
 
        QPainter gc(&d->checkers);
        gc.fillRect(QRect(0, 0, step, step), newCheckersColor1);
        gc.fillRect(QRect(step, 0, step, step), newCheckersColor2);
        gc.fillRect(QRect(step, step, step, step), newCheckersColor1);
        gc.fillRect(QRect(0, step, step, step), newCheckersColor2);
    }
 
    if (d->rowHeight != oldHeight) {
        // QAbstractItemView/QTreeView don't even look at the index and redo the whole layout...
        Q_EMIT sizeHintChanged(QModelIndex());
    }
}

References NodeDelegate::Private::checkers, KisConfig::checkersColor1(), NodeDelegate::Private::checkersColor1, KisConfig::checkersColor2(), NodeDelegate::Private::checkersColor2, d, KisNodeViewColorScheme::instance(), KisNodeViewColorScheme::relThumbnailRect(), KisNodeViewColorScheme::rowHeight(), NodeDelegate::Private::rowHeight, NodeDelegate::Private::thumbnailGeometry, KisNodeViewColorScheme::thumbnailSize(), and NodeDelegate::Private::thumbnailSize.

◆ slotResetState

void NodeDelegate::slotResetState ( )

privateslot

Definition at line 1400 of file NodeDelegate.cpp.

                                 {
 
    NodeView *view = d->view;
    QModelIndex root = view->rootIndex();
    int childs = view->model()->rowCount(root);
    if (childs > 0){
        QModelIndex firstChild = view->model()->index(0, 0, root);
        KisBaseNode::PropertyList props = firstChild.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
 
        OptionalProperty visibilityProperty = d->findVisibilityProperty(props);
        if(d->stasisIsDirty(root, visibilityProperty)){ // clean inStasis if mixed!
            d->resetPropertyStateRecursive(root, visibilityProperty);
        }
    }
}

References d, NodeDelegate::Private::findVisibilityProperty(), KisNodeModel::PropertiesRole, NodeDelegate::Private::resetPropertyStateRecursive(), NodeDelegate::Private::stasisIsDirty(), and NodeDelegate::Private::view.

◆ slotUpdateIcon()

void NodeDelegate::slotUpdateIcon ( )

Definition at line 1395 of file NodeDelegate.cpp.

{
   KisLayerPropertiesIcons::instance()->updateIcons();
}

References KisLayerPropertiesIcons::instance(), and KisLayerPropertiesIcons::updateIcons().

◆ textRect()

QRect NodeDelegate::textRect	(	const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

private

Definition at line 341 of file NodeDelegate.cpp.

{
    KisNodeViewColorScheme scm;
 
    static QFont f;
    static int minbearing = 1337 + 666; //can be 0 or negative, 2003 is less likely
    if (minbearing == 2003 || f != option.font) {
        f = option.font; //getting your bearings can be expensive, so we cache them
        minbearing = option.fontMetrics.minLeftBearing() + option.fontMetrics.minRightBearing();
    }
 
    const QRect decoRect = decorationClickRect(option, index);
    const QRect iconRect = iconsRect(option, index);
 
    QRect rc = QRect((option.direction == Qt::RightToLeft) ? iconRect.topRight() : decoRect.topRight(),
                     (option.direction == Qt::RightToLeft) ? decoRect.bottomLeft() : iconRect.bottomLeft());
    rc.adjust(-(scm.border()+(minbearing/2)), 0,
               (scm.border()+(minbearing/2)), 0);
 
    return rc;
}

References KisNodeViewColorScheme::border(), decorationClickRect(), and iconsRect().

◆ thumbnailClickRect()

QRect NodeDelegate::thumbnailClickRect	(	const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

private

Definition at line 264 of file NodeDelegate.cpp.

{
    Q_UNUSED(index);
 
    QRect rc = d->thumbnailGeometry;
 
    // Move to current index
    rc.moveTop(option.rect.topLeft().y());
    // Move to correct location.
    if (option.direction == Qt::RightToLeft) {
        rc.moveRight(option.rect.right());
    } else {
        rc.moveLeft(option.rect.left());
    }
 
    return rc;
}

References d, and NodeDelegate::Private::thumbnailGeometry.

◆ toggleSolo()

void NodeDelegate::toggleSolo ( const QModelIndex & index )

Definition at line 1215 of file NodeDelegate.cpp.

                                                      {
    KisBaseNode::PropertyList props = index.data(KisNodeModel::PropertiesRole).value<KisBaseNode::PropertyList>();
    OptionalProperty visibilityProperty = d->findVisibilityProperty(props);
    d->toggleProperty(props, visibilityProperty, Qt::ShiftModifier, index);
}

References d, NodeDelegate::Private::findVisibilityProperty(), KisNodeModel::PropertiesRole, and NodeDelegate::Private::toggleProperty().

◆ updateEditorGeometry()

void NodeDelegate::updateEditorGeometry	(	QWidget *	editor,
		const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

override

Definition at line 1209 of file NodeDelegate.cpp.

{
    Q_UNUSED(index);
    widget->setGeometry(option.rect);
}

◆ visibilityClickRect()

QRect NodeDelegate::visibilityClickRect	(	const QStyleOptionViewItem &	option,
		const QModelIndex &	index ) const

private

Definition at line 798 of file NodeDelegate.cpp.

{
    Q_UNUSED(index);
    KisNodeViewColorScheme scm;
 
    QRect rc = scm.relVisibilityRect();
    rc.setHeight(d->rowHeight);
 
    // Move to current index
    rc.moveCenter(option.rect.center());
    // Move to correct location.
    if (option.direction == Qt::RightToLeft) {
        rc.moveRight(option.rect.right());
    } else {
        rc.moveLeft(option.rect.left());
    }
 
    return rc;
}

References d, KisNodeViewColorScheme::relVisibilityRect(), and NodeDelegate::Private::rowHeight.

Member Data Documentation

◆ d

Private* const NodeDelegate::d

private

Definition at line 53 of file NodeDelegate.h.

The documentation for this class was generated from the following files:

plugins/dockers/layerdocker/NodeDelegate.h
plugins/dockers/layerdocker/NodeDelegate.cpp

Classes

Public Slots

Signals

Public Member Functions

Protected Member Functions

Private Types

Private Slots

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Model

◆ View

Constructor & Destructor Documentation

◆ NodeDelegate()

◆ ~NodeDelegate()

Member Function Documentation

◆ changeSelectionAndCurrentIndex()

◆ createEditor()

◆ decorationClickRect()

◆ drawAnimatedDecoration()

◆ drawBranches()

◆ drawColorLabel()

◆ drawDecoration()

◆ drawExpandButton()

◆ drawFrame()

◆ drawIcons()

◆ drawProgressBar()

◆ drawSelectedButton()

◆ drawText()

◆ drawThumbnail()

◆ drawVisibilityIcon()

◆ editorEvent()

◆ eventFilter()

◆ filterColorClickRect()

◆ getOptions()

◆ iconsRect()

◆ paint()

◆ resetVisibilityStasis

◆ setModelData()

◆ sizeHint()

◆ slotConfigChanged

◆ slotResetState

◆ slotUpdateIcon()

◆ textRect()

◆ thumbnailClickRect()

◆ toggleSolo()

◆ updateEditorGeometry()

◆ visibilityClickRect()

Member Data Documentation

◆ d