#include <kis_node_model.h>

Inheritance diagram for KisNodeModel:

Classes
struct	Private

Public Types
enum	ItemDataRole { ActiveRole = Qt::UserRole + 1 , PropertiesRole , AspectRatioRole , ProgressRole , AlternateActiveRole , ShouldGrayOutRole , ColorLabelIndexRole , DropEnabled , SelectOpaqueRole , DropReasonRole , IsAnimatedRole , InfoTextRole , FilterMaskColorRole , FilterMaskPropertiesRole , LayerColorOverlayColorRole , LayerColorOverlayPropertiesRole , ReservedRole = Qt::UserRole + 99 , BeginThumbnailRole }
	Extensions to Qt::ItemDataRole. More...

Public Slots
void	setShowGlobalSelection (bool value)

Signals
void	sigBeforeBeginRemoveRows (const QModelIndex &parent, int start, int end)

void	toggleIsolateActiveNode ()

Public Member Functions
bool	canDropMimeData (const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) const override

int	columnCount (const QModelIndex &parent=QModelIndex()) const override

QVariant	data (const QModelIndex &index, int role=Qt::DisplayRole) const override

bool	dropMimeData (const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) override

Qt::ItemFlags	flags (const QModelIndex &index) const override

bool	hasDummiesFacade ()

QModelIndex	index (int row, int column, const QModelIndex &parent=QModelIndex()) const override

QModelIndex	indexFromNode (KisNodeSP node) const

	KisNodeModel (QObject *parent, int clonedColumns=0)

QMimeData *	mimeData (const QModelIndexList &indexes) const override

QStringList	mimeTypes () const override

KisNodeSP	nodeFromIndex (const QModelIndex &index) const

QModelIndex	parent (const QModelIndex &index) const override

int	rowCount (const QModelIndex &parent=QModelIndex()) const override

bool	setData (const QModelIndex &index, const QVariant &value, int role=Qt::EditRole) override

void	setDummiesFacade (KisDummiesFacadeBase dummiesFacade, KisImageWSP image, KisShapeController shapeController, KisSelectionActionsAdapter selectionActionsAdapter, KisNodeManager nodeManager)

void	setIdleTaskManager (KisIdleTasksManager *idleTasksManager)

void	setPreferredThumnalSize (int preferredSize) const

bool	showGlobalSelection () const

QModelIndex	sibling (int row, int column, const QModelIndex &idx) const override

Qt::DropActions	supportedDragActions () const override

Qt::DropActions	supportedDropActions () const override

	~KisNodeModel () override

Static Public Member Functions
static bool	belongsToIsolatedGroup (KisImageSP image, KisNodeSP node, KisDummiesFacadeBase *dummiesFacade)

Protected Slots
void	processUpdateQueue ()

void	progressPercentageChanged (int, const KisNodeSP)

void	slotBeginInsertDummy (KisNodeDummy *parent, int index, const QString &metaObjectType)

void	slotBeginRemoveDummy (KisNodeDummy *dummy)

void	slotDummyChanged (KisNodeDummy *dummy)

void	slotEndInsertDummy (KisNodeDummy *dummy)

void	slotEndRemoveDummy ()

void	slotIsolatedModeChanged ()

void	slotLayerThumbnailUpdated (KisNodeSP node)

void	slotNodeDisplayModeChanged (bool showRootNode, bool showGlobalSelectionMask)

Protected Member Functions
virtual KisModelIndexConverterBase *	createIndexConverter ()

KisDummiesFacadeBase *	dummiesFacade () const

KisModelIndexConverterBase *	indexConverter () const

Private Member Functions
bool	belongsToIsolatedGroup (KisNodeSP node) const

void	connectDummies (KisNodeDummy *dummy, bool needConnect)

void	connectDummy (KisNodeDummy *dummy, bool needConnect)

void	regenerateItems (KisNodeDummy *dummy)

void	resetIndexConverter ()

void	setDropEnabled (const QMimeData *data)

void	updateDropEnabled (const QList< KisNodeSP > &nodes, QModelIndex parent=QModelIndex())

Private Attributes
Private *const	m_d

Friends
class	KisModelIndexConverter

class	KisModelIndexConverterShowAll

Detailed Description

KisNodeModel offers a Qt model-view compatible view of the node hierarchy. The KisNodeView displays a thumbnail and a row of icon properties for every document section.

Note that there's a discrepancy between the krita node tree model and the model Qt wants to see: we hide the root node from Qt.

The node model also shows an inverse view of the layer tree: we want the first layer to show up at the bottom.

See also the Qt documentation for QAbstractItemModel. This class extends that interface to provide a name and set of toggle properties (like visible, locked, selected.)

Definition at line 45 of file kis_node_model.h.

Member Enumeration Documentation

◆ ItemDataRole

enum KisNodeModel::ItemDataRole

Extensions to Qt::ItemDataRole.

Enumerator
ActiveRole	Whether the section is the active one.
PropertiesRole	A list of properties the part has.
AspectRatioRole	The aspect ratio of the section as a floating point value: width divided by height.
ProgressRole	Use to communicate a progress report to the section delegate on an action (a value of -1 or a QVariant() disable the progress bar.
AlternateActiveRole	Special activation role which is emitted when the user Alt-clicks on a section The item is first activated with ActiveRole, then a separate AlternateActiveRole comes
ShouldGrayOutRole
ColorLabelIndexRole
DropEnabled
SelectOpaqueRole
DropReasonRole
IsAnimatedRole
InfoTextRole
FilterMaskColorRole
FilterMaskPropertiesRole
LayerColorOverlayColorRole
LayerColorOverlayPropertiesRole
ReservedRole	This is to ensure that we can extend the data role in the future, since it's not possible to add a role after BeginThumbnailRole (due to "Hack")
BeginThumbnailRole	For values of BeginThumbnailRole or higher, a thumbnail of the layer of which neither dimension is larger than (int) value - (int) BeginThumbnailRole. This is a hack to work around the fact that Interview doesn't have a nice way to request thumbnails of arbitrary size.

Definition at line 52 of file kis_node_model.h.

    {
        ActiveRole = Qt::UserRole + 1,
 
        PropertiesRole,
 
        AspectRatioRole,
 
        ProgressRole,
 
        AlternateActiveRole,
 
        // When a layer is not (recursively) visible, then it should be grayed out
        ShouldGrayOutRole,
 
        // An index of a color label associated with the node
        ColorLabelIndexRole,
 
        // Instruct this model to update all its items' Qt::ItemIsDropEnabled flags in order to
        // reflect if the item allows an "onto" drop of the given QMimeData*.
        DropEnabled,
 
        // Instructs the model to activate "select opaque" action,
        // the selection action (of type SelectionAction) value
        // is passed via QVariant as integer
        SelectOpaqueRole,
 
        // Returns a text explaining why the node has been excluded from
        // projection rendering. If the node is not excluded, then empty
        // string is returned
        DropReasonRole,
 
        // Let's the model quickly determine whether a layer has any
        // animated content attached to it.
        IsAnimatedRole,
 
        // Returns a string with layer opacity and blending mode information;
        // content depends on style setting.
        InfoTextRole,
 
        // If the item is a filter mask that has a "color" property,
        // returns that mask's color. Otherwise, returns a null variant.
        FilterMaskColorRole,
 
        // If the item is a filter mask, shows that mask's properties dialog.
        FilterMaskPropertiesRole,
 
        // If the item is a layer that has a color overlay filter mask,
        // returns that mask's color. Otherwise, returns a null variant.
        LayerColorOverlayColorRole,
 
        // If the item is a layer that has a color overlay filter mask,
        // shows that mask's properties dialog.
        LayerColorOverlayPropertiesRole,
 
        ReservedRole = Qt::UserRole + 99,
 
        BeginThumbnailRole
    };

Constructor & Destructor Documentation

◆ KisNodeModel()

KisNodeModel::KisNodeModel	(	QObject *	parent,
		int	clonedColumns = 0 )

explicit

Definition at line 85 of file kis_node_model.cpp.

        : QAbstractItemModel(parent)
        , m_d(new Private)
{
    m_d->dummyColumns = qMax(0, clonedColumns);
    connect(&m_d->updateCompressor, SIGNAL(timeout()), SLOT(processUpdateQueue()));
    connect(&m_d->thumbnalCache, SIGNAL(sigLayerThumbnailUpdated(KisNodeSP)), SLOT(slotLayerThumbnailUpdated(KisNodeSP)));
}

References connect(), KisNodeModel::Private::dummyColumns, m_d, processUpdateQueue(), slotLayerThumbnailUpdated(), KisNodeModel::Private::thumbnalCache, and KisNodeModel::Private::updateCompressor.

◆ ~KisNodeModel()

KisNodeModel::~KisNodeModel ( )

override

Definition at line 94 of file kis_node_model.cpp.

{
    delete m_d->indexConverter;
    delete m_d;
}

References KisNodeModel::Private::indexConverter, and m_d.

Member Function Documentation

◆ belongsToIsolatedGroup() [1/2]

bool KisNodeModel::belongsToIsolatedGroup	(	KisImageSP	image,
		KisNodeSP	node,
		KisDummiesFacadeBase *	dummiesFacade )

static

Definition at line 119 of file kis_node_model.cpp.

{
    KisNodeSP isolatedRoot = image->isolationRootNode();
    if (!isolatedRoot) return true;
 
    KisNodeDummy *isolatedRootDummy =
        dummiesFacade->dummyForNode(isolatedRoot);
    KisNodeDummy *dummy =
        dummiesFacade->dummyForNode(node);
 
    while (dummy) {
        if (dummy == isolatedRootDummy) {
            return true;
        }
        dummy = dummy->parent();
    }
 
    return false;
}

References dummiesFacade(), KisDummiesFacadeBase::dummyForNode(), KisImage::isolationRootNode(), and KisNodeDummy::parent().

◆ belongsToIsolatedGroup() [2/2]

bool KisNodeModel::belongsToIsolatedGroup ( KisNodeSP node ) const

private

Definition at line 139 of file kis_node_model.cpp.

{
    return belongsToIsolatedGroup(m_d->image, node, m_d->dummiesFacade);
}

References belongsToIsolatedGroup(), KisNodeModel::Private::dummiesFacade, KisNodeModel::Private::image, and m_d.

◆ canDropMimeData()

bool KisNodeModel::canDropMimeData	(	const QMimeData *	data,
		Qt::DropAction	action,
		int	row,
		int	column,
		const QModelIndex &	parent ) const

override

Definition at line 852 of file kis_node_model.cpp.

                                                                                                                                   {
    if (parent.isValid()) {
        // drop occurred on an item. always return true as returning false will mess up
        // QT5's drag handling (see KisNodeModel::setDropEnabled).
        return true;
    } else {
        return QAbstractItemModel::canDropMimeData(data, action, row, column, parent);
    }
}

References data(), and parent().

◆ columnCount()

int KisNodeModel::columnCount ( const QModelIndex & parent = QModelIndex() ) const

override

Definition at line 478 of file kis_node_model.cpp.

{
    if (parent.column() > 0) {
        return 0;
    }
    return 1 + m_d->dummyColumns;
}

References KisNodeModel::Private::dummyColumns, m_d, and parent().

◆ connectDummies()

void KisNodeModel::connectDummies	(	KisNodeDummy *	dummy,
		bool	needConnect )

private

Definition at line 265 of file kis_node_model.cpp.

{
    connectDummy(dummy, needConnect);
 
    dummy = dummy->firstChild();
    while(dummy) {
        connectDummies(dummy, needConnect);
        dummy = dummy->nextSibling();
    }
}

References connectDummies(), connectDummy(), KisNodeDummy::firstChild(), and KisNodeDummy::nextSibling().

◆ connectDummy()

void KisNodeModel::connectDummy	(	KisNodeDummy *	dummy,
		bool	needConnect )

private

Definition at line 247 of file kis_node_model.cpp.

{
    KisNodeSP node = dummy->node();
    if (!node) {
        qWarning() << "Dummy node has no node!" << dummy << dummy->node();
        return;
    }
    KisNodeProgressProxy *progressProxy = node->nodeProgressProxy();
    if(progressProxy) {
        if(needConnect) {
            connect(progressProxy, SIGNAL(percentageChanged(int,KisNodeSP)),
                    SLOT(progressPercentageChanged(int,KisNodeSP)));
        } else {
            progressProxy->disconnect(this);
        }
    }
}

References connect(), KisNodeDummy::node(), KisNode::nodeProgressProxy, and progressPercentageChanged().

◆ createIndexConverter()

KisModelIndexConverterBase * KisNodeModel::createIndexConverter ( )

protectedvirtual

Definition at line 154 of file kis_node_model.cpp.

{
    if(m_d->showRootLayer) {
        return new KisModelIndexConverterShowAll(m_d->dummiesFacade, this);
    } else {
        return new KisModelIndexConverter(m_d->dummiesFacade, this, m_d->showGlobalSelection);
    }
}

References KisNodeModel::Private::dummiesFacade, KisModelIndexConverter, KisModelIndexConverterShowAll, m_d, KisNodeModel::Private::showGlobalSelection, and KisNodeModel::Private::showRootLayer.

◆ data()

QVariant KisNodeModel::data	(	const QModelIndex &	index,
		int	role = Qt::DisplayRole ) const

override

The dummies are removed from the model asynchronously to the image operations, therefore we should make sure that node->graphListener() is still valid and this node is still present in the node graph.

WARNING: there is still a possible theoretical race condition if the node is removed from the image right here. We consider that as "improbable" atm.

Definition at line 515 of file kis_node_model.cpp.

{
    if (!m_d->dummiesFacade || !index.isValid() || !m_d->image.isValid()) return QVariant();
 
    KisNodeSP node = nodeFromIndex(index);
 
    switch (role) {
    case Qt::DisplayRole: return node->name();
    case Qt::DecorationRole: return node->icon();
    case Qt::EditRole: return node->name();
    case Qt::SizeHintRole: return m_d->image->size(); // FIXME
    case Qt::ForegroundRole:
        return belongsToIsolatedGroup(node) &&
            !node->projectionLeaf()->isDroppedNode() ? QVariant() : QVariant(QColor(Qt::gray));
    case Qt::FontRole: {
        QFont baseFont;
        if (node->projectionLeaf()->isDroppedNode()) {
            baseFont.setStrikeOut(true);
        }
        if (m_d->activeNodeIndex == index) {
            baseFont.setBold(true);
        }
        return baseFont;
    }
    case KisNodeModel::PropertiesRole: return QVariant::fromValue(node->sectionModelProperties());
    case KisNodeModel::AspectRatioRole: return double(m_d->image->width()) / m_d->image->height();
    case KisNodeModel::ProgressRole: {
        KisNodeProgressProxy *proxy = node->nodeProgressProxy();
        return proxy ? proxy->percentage() : -1;
    }
    case KisNodeModel::ActiveRole: {
        return m_d->activeNodeIndex == index;
    }
    case KisNodeModel::ShouldGrayOutRole: {
        return !node->visible(true);
    }
    case KisNodeModel::ColorLabelIndexRole: {
        return node->colorLabelIndex();
    }
    case KisNodeModel::DropReasonRole: {
        QString result;
        KisProjectionLeaf::NodeDropReason reason = node->projectionLeaf()->dropReason();
 
        if (reason == KisProjectionLeaf::DropPassThroughMask) {
            result = i18nc("@info:tooltip", "Disabled: masks on pass-through groups are not supported!");
        } else if (reason == KisProjectionLeaf::DropPassThroughClone) {
            result = i18nc("@info:tooltip", "Disabled: cloning pass-through groups is not supported!");
        }
 
        return result;
    }
    case KisNodeModel::IsAnimatedRole: {
        return node->isAnimated();
    }
    case KisNodeModel::InfoTextRole: {
        // These layer types' opacity and blending modes cannot be changed,
        // so there's little point in showing them
        if (node->inherits("KisFilterMask") ||
            node->inherits("KisTransparencyMask") ||
            node->inherits("KisTransformMask") ||
            node->inherits("KisSelectionMask")) {
            return "";
        }
        const KisConfig::LayerInfoTextStyle infoTextStyle = KisConfig(true).layerInfoTextStyle();
        const int opacity = round(node->opacity() * 100.0 / 255);
        const QString opacityString = QString::number(opacity);
        const QString compositeOpId = node->compositeOpId();
        QString compositeOpDesc = "null";
        // make sure the compositeOp exists to avoid crashing on specific layer undo
        if (node->compositeOp()) {
            compositeOpDesc = node->compositeOp()->description();
        }
        QString defaultOpId = COMPOSITE_OVER;   // "normal";
        if (node->inherits("KisAdjustmentLayer")) {
            defaultOpId = COMPOSITE_COPY;
        }
        else if (node->inherits("KisColorizeMask")) {
            defaultOpId = COMPOSITE_BEHIND;
        }
        QString infoText = "";
        if (infoTextStyle == KisConfig::LayerInfoTextStyle::INFOTEXT_DETAILED ||
                !(opacity == 100 && compositeOpId == defaultOpId)) {
            if (infoTextStyle == KisConfig::LayerInfoTextStyle::INFOTEXT_SIMPLE) {
                if (opacity == 100) {
                    return QString(compositeOpDesc);
                }
                if (compositeOpId == defaultOpId) {
                    return i18nc("%1 is the percent value, % is the percent sign", "%1%", opacityString);
                }
            }
            infoText = i18nc("%1 is the percent value, % is the percent sign", "%1% %2", opacityString, compositeOpDesc);
        }
        return infoText;
    }
    case FilterMaskColorRole: {
        if (node->inherits("KisFilterMask")) {
            KisFilterMaskSP mask = qobject_cast<KisFilterMask*>(node.data());
            // The main use case is "fastcoloroverlay" filter, to display its color in the UI.
            if (mask->filter()->hasProperty("color")) {
                return mask->filter()->getColor("color").toQColor();
            }
        }
        return QVariant();
    }
    case LayerColorOverlayColorRole: {
        if (node->inherits("KisLayer")) {
            KisLayerSP layer = qobject_cast<KisLayer*>(node.data());
            KisFilterMaskSP mask = layer->colorOverlayMask();
            if (mask && mask->filter()->hasProperty("color")) {
                return mask->filter()->getColor("color").toQColor();
            }
        }
        return QVariant();
    }
    default:
 
        if (role >= int(KisNodeModel::BeginThumbnailRole) &&
            belongsToIsolatedGroup(node) &&
            node->graphListener()) {
 
            const int maxSize = role - int(KisNodeModel::BeginThumbnailRole);
 
            if (maxSize == m_d->thumbnalCache.maxSize()) {
                return m_d->thumbnalCache.thumbnail(node);
            } else {
                return node->createThumbnail(maxSize, maxSize, Qt::KeepAspectRatio);
            }
        } else {
            return QVariant();
        }
    }
 
    return QVariant();
}

References KisNodeModel::Private::activeNodeIndex, ActiveRole, AspectRatioRole, BeginThumbnailRole, belongsToIsolatedGroup(), KisBaseNode::colorLabelIndex(), ColorLabelIndexRole, KisLayer::colorOverlayMask(), COMPOSITE_BEHIND, COMPOSITE_COPY, COMPOSITE_OVER, KisBaseNode::compositeOp, KisBaseNode::compositeOpId(), KisBaseNode::createThumbnail(), KisSharedPtr< T >::data(), KisProjectionLeaf::DropPassThroughClone, KisProjectionLeaf::DropPassThroughMask, DropReasonRole, KisNodeModel::Private::dummiesFacade, FilterMaskColorRole, KisNode::graphListener, KisImage::height(), KisBaseNode::icon(), KisNodeModel::Private::image, index(), KisConfig::INFOTEXT_DETAILED, KisConfig::INFOTEXT_SIMPLE, InfoTextRole, KisBaseNode::isAnimated(), IsAnimatedRole, KisWeakSharedPtr< T >::isValid(), LayerColorOverlayColorRole, KisConfig::layerInfoTextStyle(), m_d, KisLayerThumbnailCache::maxSize(), KisBaseNode::name(), nodeFromIndex(), KisNode::nodeProgressProxy, KisBaseNode::opacity(), KisNodeProgressProxy::percentage, ProgressRole, KisNode::projectionLeaf, PropertiesRole, KisBaseNode::sectionModelProperties(), ShouldGrayOutRole, KisImage::size(), KisLayerThumbnailCache::thumbnail(), KisNodeModel::Private::thumbnalCache, KisBaseNode::visible(), and KisImage::width().

◆ dropMimeData()

bool KisNodeModel::dropMimeData	(	const QMimeData *	data,
		Qt::DropAction	action,
		int	row,
		int	column,
		const QModelIndex &	parent )

override

Definition at line 823 of file kis_node_model.cpp.

{
    Q_UNUSED(column);
 
    bool copyNode = (action == Qt::CopyAction);
 
    KisNodeDummy *parentDummy = 0;
    KisNodeDummy *aboveThisDummy = 0;
 
    parentDummy = parent.isValid() ?
        m_d->indexConverter->dummyFromIndex(parent) :
        m_d->dummiesFacade->rootDummy();
 
    if (row == -1) {
        aboveThisDummy = parent.isValid() ? parentDummy->lastChild() : 0;
    }
    else {
        aboveThisDummy = row < m_d->indexConverter->rowCount(parent) ? m_d->indexConverter->dummyFromRow(row, parent) : 0;
    }
 
    return KisMimeData::insertMimeLayers(data,
                                         m_d->image,
                                         m_d->shapeController,
                                         parentDummy,
                                         aboveThisDummy,
                                         copyNode,
                                         m_d->nodeInsertionAdapter);
}

References data(), KisNodeModel::Private::dummiesFacade, KisModelIndexConverterBase::dummyFromIndex(), KisModelIndexConverterBase::dummyFromRow(), KisNodeModel::Private::image, KisNodeModel::Private::indexConverter, KisMimeData::insertMimeLayers(), KisNodeDummy::lastChild(), m_d, KisNodeModel::Private::nodeInsertionAdapter, parent(), KisModelIndexConverterBase::rowCount(), and KisNodeModel::Private::shapeController.

◆ dummiesFacade()

KisDummiesFacadeBase * KisNodeModel::dummiesFacade ( ) const

protected

Definition at line 242 of file kis_node_model.cpp.

{
    return m_d->dummiesFacade;
}

References KisNodeModel::Private::dummiesFacade, and m_d.

◆ flags()

Qt::ItemFlags KisNodeModel::flags ( const QModelIndex & index ) const

override

Definition at line 660 of file kis_node_model.cpp.

{
    if(!m_d->dummiesFacade || !index.isValid()) return Qt::ItemIsDropEnabled;
 
    Qt::ItemFlags flags = Qt::ItemIsEnabled | Qt::ItemIsEditable;
    // currently dummy columns are neither selectable nor drag&drop enabled
    if (index.column() == 0) {
        flags |=  Qt::ItemIsDragEnabled | Qt::ItemIsSelectable;
        if (m_d->dropEnabled.contains(index.internalId())) {
            flags |= Qt::ItemIsDropEnabled;
        }
 
    }
 
    return flags;
}

References KisNodeModel::Private::dropEnabled, KisNodeModel::Private::dummiesFacade, flags(), index(), and m_d.

◆ hasDummiesFacade()

bool KisNodeModel::hasDummiesFacade ( )

Definition at line 788 of file kis_node_model.cpp.

{
    return m_d->dummiesFacade != 0;
}

References KisNodeModel::Private::dummiesFacade, and m_d.

◆ index()

QModelIndex KisNodeModel::index	(	int	row,
		int	column,
		const QModelIndex &	parent = QModelIndex() ) const

override

Definition at line 451 of file kis_node_model.cpp.

{
    if(!m_d->dummiesFacade || !hasIndex(row, col, parent)) return QModelIndex();
 
    QModelIndex itemIndex;
 
    KisNodeDummy *dummy = m_d->indexConverter->dummyFromRow(row, parent);
    if(dummy) {
        itemIndex = m_d->indexConverter->indexFromDummy(dummy);
    }
 
    if (itemIndex.isValid() && itemIndex.column() != col) {
        itemIndex = createIndex(itemIndex.row(), col, itemIndex.internalPointer());
    }
 
    return itemIndex;
}

References KisNodeModel::Private::dummiesFacade, KisModelIndexConverterBase::dummyFromRow(), KisNodeModel::Private::indexConverter, KisModelIndexConverterBase::indexFromDummy(), m_d, and parent().

◆ indexConverter()

KisModelIndexConverterBase * KisNodeModel::indexConverter ( ) const

protected

Definition at line 237 of file kis_node_model.cpp.

{
    return m_d->indexConverter;
}

References KisNodeModel::Private::indexConverter, and m_d.

◆ indexFromNode()

QModelIndex KisNodeModel::indexFromNode ( KisNodeSP node ) const

Definition at line 111 of file kis_node_model.cpp.

{
    KisNodeDummy *dummy = m_d->dummiesFacade->dummyForNode(node);
    if(dummy)
        return m_d->indexConverter->indexFromDummy(dummy);
    return QModelIndex();
}

References KisNodeModel::Private::dummiesFacade, KisNodeModel::Private::indexConverter, KisModelIndexConverterBase::indexFromDummy(), and m_d.

◆ mimeData()

QMimeData * KisNodeModel::mimeData ( const QModelIndexList & indexes ) const

override

Definition at line 803 of file kis_node_model.cpp.

{
    bool hasLockedLayer = false;
    KisNodeList nodes;
    Q_FOREACH (const QModelIndex &idx, indexes) {
        // Although clone columns should not be selectable, make sure we only use column 0,
        // because nodeFromIndex doesn't like duplicate list entries.
        if (idx.column() != 0) {
            continue;
        }
 
        KisNodeSP node = nodeFromIndex(idx);
 
        nodes << node;
        hasLockedLayer |= !node->isEditable(false);
    }
 
    return KisMimeData::mimeForLayers(nodes, m_d->image, hasLockedLayer);
}

References KisNodeModel::Private::image, KisBaseNode::isEditable(), m_d, KisMimeData::mimeForLayers(), and nodeFromIndex().

◆ mimeTypes()

QStringList KisNodeModel::mimeTypes ( ) const

override

Definition at line 793 of file kis_node_model.cpp.

{
    QStringList types;
    types << QLatin1String("application/x-krita-node-internal-pointer");
    types << QLatin1String("application/x-qt-image");
    types << QLatin1String("application/x-color");
    types << QLatin1String("krita/x-colorsetentry");
    return types;
}

◆ nodeFromIndex()

KisNodeSP KisNodeModel::nodeFromIndex ( const QModelIndex & index ) const

Definition at line 100 of file kis_node_model.cpp.

{
    Q_ASSERT(index.isValid());
 
    KisNodeDummy *dummy = m_d->indexConverter->dummyFromIndex(index);
    if (dummy) {
        return dummy->node();
    }
    return 0;
}

References KisModelIndexConverterBase::dummyFromIndex(), index(), KisNodeModel::Private::indexConverter, m_d, and KisNodeDummy::node().

◆ parent()

QModelIndex KisNodeModel::parent ( const QModelIndex & index ) const

override

Definition at line 486 of file kis_node_model.cpp.

{
    if(!m_d->dummiesFacade || !index.isValid()) return QModelIndex();
 
    KisNodeDummy *dummy = m_d->indexConverter->dummyFromIndex(index);
    KisNodeDummy *parentDummy = dummy->parent();
 
    QModelIndex parentIndex;
 
    if(parentDummy) {
        parentIndex = m_d->indexConverter->indexFromDummy(parentDummy);
    }
 
    return parentIndex;
}

References KisNodeModel::Private::dummiesFacade, KisModelIndexConverterBase::dummyFromIndex(), index(), KisNodeModel::Private::indexConverter, KisModelIndexConverterBase::indexFromDummy(), m_d, and KisNodeDummy::parent().

◆ processUpdateQueue

void KisNodeModel::processUpdateQueue ( )

protectedslot

Definition at line 435 of file kis_node_model.cpp.

{
    QSet<QModelIndex> indexes;
 
    Q_FOREACH (KisNodeDummy *dummy, m_d->updateQueue) {
        QModelIndex index = m_d->indexConverter->indexFromDummy(dummy);
        addChangedIndex(index, &indexes);
    }
 
    Q_FOREACH (const QModelIndex &index, indexes) {
        Q_EMIT dataChanged(index.siblingAtColumn(0), index.siblingAtColumn(m_d->dummyColumns));
    }
 
    m_d->updateQueue.clear();
}

References addChangedIndex(), KisNodeModel::Private::dummyColumns, index(), KisNodeModel::Private::indexConverter, KisModelIndexConverterBase::indexFromDummy(), m_d, and KisNodeModel::Private::updateQueue.

◆ progressPercentageChanged

void KisNodeModel::progressPercentageChanged	(	int	,
		const KisNodeSP	node )

protectedslot

Definition at line 216 of file kis_node_model.cpp.

{
    if(!m_d->dummiesFacade) return;
 
    // Need to check here as the node might already be removed, but there might
    // still be some signals arriving from another thread
    if (m_d->dummiesFacade->hasDummyForNode(node)) {
        QModelIndex index = indexFromNode(node);
 
        Q_EMIT dataChanged(index, index);
    }
}

References KisNodeModel::Private::dummiesFacade, index(), indexFromNode(), and m_d.

◆ regenerateItems()

void KisNodeModel::regenerateItems ( KisNodeDummy * dummy )

private

Definition at line 163 of file kis_node_model.cpp.

{
    const QModelIndex &index = m_d->indexConverter->indexFromDummy(dummy);
    Q_EMIT dataChanged(index.siblingAtColumn(0), index.siblingAtColumn(m_d->dummyColumns));
 
    dummy = dummy->firstChild();
    while (dummy) {
        regenerateItems(dummy);
        dummy = dummy->nextSibling();
    }
}

References KisNodeModel::Private::dummyColumns, KisNodeDummy::firstChild(), index(), KisNodeModel::Private::indexConverter, KisModelIndexConverterBase::indexFromDummy(), m_d, KisNodeDummy::nextSibling(), and regenerateItems().

◆ resetIndexConverter()

void KisNodeModel::resetIndexConverter ( )

private

Definition at line 144 of file kis_node_model.cpp.

{
    delete m_d->indexConverter;
    m_d->indexConverter = 0;
 
    if(m_d->dummiesFacade) {
        m_d->indexConverter = createIndexConverter();
    }
}

References createIndexConverter(), KisNodeModel::Private::dummiesFacade, KisNodeModel::Private::indexConverter, and m_d.

◆ rowCount()

int KisNodeModel::rowCount ( const QModelIndex & parent = QModelIndex() ) const

override

Definition at line 469 of file kis_node_model.cpp.

{
    if(!m_d->dummiesFacade) return 0;
    if (parent.column() > 0) {
        return 0;
    }
    return m_d->indexConverter->rowCount(parent);
}

References KisNodeModel::Private::dummiesFacade, KisNodeModel::Private::indexConverter, m_d, parent(), and KisModelIndexConverterBase::rowCount().

◆ setData()

bool KisNodeModel::setData	(	const QModelIndex &	index,
		const QVariant &	value,
		int	role = Qt::EditRole )

override

Definition at line 677 of file kis_node_model.cpp.

{
    if (role == KisNodeModel::DropEnabled) {
        const QMimeData *mimeData = static_cast<const QMimeData*>(value.value<void*>());
        setDropEnabled(mimeData);
        return true;
    }
 
    if (role == KisNodeModel::ActiveRole || role == KisNodeModel::AlternateActiveRole) {
        QModelIndex parentIndex;
        if (!index.isValid() && m_d->parentOfRemovedNode && m_d->dummiesFacade && m_d->indexConverter) {
            parentIndex = m_d->indexConverter->indexFromDummy(m_d->parentOfRemovedNode);
            m_d->parentOfRemovedNode = 0;
        }
 
        KisNodeSP activatedNode;
 
        if (index.isValid() && value.toBool()) {
            activatedNode = nodeFromIndex(index);
        }
        else if (parentIndex.isValid() && value.toBool()) {
            activatedNode = nodeFromIndex(parentIndex);
        }
        else {
            activatedNode = 0;
        }
 
        QModelIndex newActiveNode = activatedNode ? indexFromNode(activatedNode) : QModelIndex();
        if (role == KisNodeModel::ActiveRole && value.toBool() &&
            m_d->activeNodeIndex == newActiveNode) {
 
            return true;
        }
 
        m_d->activeNodeIndex = newActiveNode;
 
        if (m_d->nodeSelectionAdapter) {
            m_d->nodeSelectionAdapter->setActiveNode(activatedNode);
        }
 
        if (role == KisNodeModel::AlternateActiveRole) {
            Q_EMIT toggleIsolateActiveNode();
        }
 
        Q_EMIT dataChanged(index.siblingAtColumn(0), index.siblingAtColumn(m_d->dummyColumns));
        return true;
    }
 
    if(!m_d->dummiesFacade || !index.isValid()) return false;
 
    bool result = true;
    bool shouldUpdate = true;
    bool shouldUpdateRecursively = false;
    KisNodeSP node = nodeFromIndex(index);
 
    switch (role) {
    case Qt::DisplayRole:
    case Qt::EditRole:
        m_d->nodeManager->setNodeName(node, value.toString());
        break;
    case KisNodeModel::PropertiesRole:
        {
            // don't record undo/redo for visibility, locked or alpha locked changes
            KisBaseNode::PropertyList proplist = value.value<KisBaseNode::PropertyList>();
            m_d->nodeManager->trySetNodeProperties(node, m_d->image, proplist);
            shouldUpdateRecursively = true;
 
            break;
        }
    case KisNodeModel::SelectOpaqueRole:
        if (node && m_d->selectionActionsAdapter) {
            SelectionAction action = SelectionAction(value.toInt());
            m_d->selectionActionsAdapter->selectOpaqueOnNode(node, action);
        }
        shouldUpdate = false;
        break;
    case FilterMaskPropertiesRole:
        m_d->nodeManager->nodePropertiesIgnoreSelection(node);
        break;
    case LayerColorOverlayPropertiesRole:
        m_d->nodeManager->colorOverlayMaskProperties(node);
        break;
    default:
        result = false;
    }
 
    if (result && shouldUpdate) {
        if (shouldUpdateRecursively) {
            QSet<QModelIndex> indexes;
            addChangedIndex(index, &indexes);
            Q_FOREACH (const QModelIndex &idx, indexes) {
                Q_EMIT dataChanged(idx.siblingAtColumn(0), idx.siblingAtColumn(m_d->dummyColumns));
            }
        } else {
            Q_EMIT dataChanged(index.siblingAtColumn(0), index.siblingAtColumn(m_d->dummyColumns));
        }
    }
 
    return result;
}

◆ setDropEnabled()

void KisNodeModel::setDropEnabled ( const QMimeData * data )

private

Definition at line 862 of file kis_node_model.cpp.

                                                       {
    // what happens here should really happen in KisNodeModel::canDropMimeData(), but QT5
    // will mess up if an item's Qt::ItemIsDropEnabled does not match what is returned by
    // canDropMimeData; specifically, if we set the flag, but decide in canDropMimeData()
    // later on that an "onto" drag is not allowed, QT will display an drop indicator for
    // insertion, but not perform any drop when the mouse is released.
 
    // the only robust implementation seems to set all flags correctly, which is done here.
 
    bool copyNode = false;
    KisNodeList nodes = KisMimeData::loadNodesFast(data, m_d->image, m_d->shapeController, copyNode);
    m_d->dropEnabled.clear();
    updateDropEnabled(nodes);
}

References data(), KisNodeModel::Private::dropEnabled, KisNodeModel::Private::image, KisMimeData::loadNodesFast(), m_d, KisNodeModel::Private::shapeController, and updateDropEnabled().

◆ setDummiesFacade()

void KisNodeModel::setDummiesFacade	(	KisDummiesFacadeBase *	dummiesFacade,
		KisImageWSP	image,
		KisShapeController *	shapeController,
		KisSelectionActionsAdapter *	selectionActionsAdapter,
		KisNodeManager *	nodeManager )

Definition at line 276 of file kis_node_model.cpp.

{
    QPointer<KisDummiesFacadeBase> oldDummiesFacade(m_d->dummiesFacade);
    KisShapeController  *oldShapeController = m_d->shapeController;
 
    m_d->shapeController = shapeController;
    m_d->nodeManager = nodeManager;
    m_d->nodeSelectionAdapter = nodeManager ? nodeManager->nodeSelectionAdapter() : nullptr;
    m_d->nodeInsertionAdapter = nodeManager ? nodeManager->nodeInsertionAdapter() : nullptr;
    m_d->selectionActionsAdapter = selectionActionsAdapter;
 
    m_d->nodeDisplayModeAdapterConnections.clear();
    m_d->nodeDisplayModeAdapter = nodeManager ? nodeManager->nodeDisplayModeAdapter() : nullptr;
    if (m_d->nodeDisplayModeAdapter) {
        m_d->nodeDisplayModeAdapterConnections.addConnection(
            m_d->nodeDisplayModeAdapter, SIGNAL(sigNodeDisplayModeChanged(bool,bool)),
            this, SLOT(slotNodeDisplayModeChanged(bool,bool)));
 
        // cold initialization
        m_d->showGlobalSelection = m_d->nodeDisplayModeAdapter->showGlobalSelectionMask();
        m_d->showRootLayer = false;
    }
 
    if (oldDummiesFacade && m_d->image) {
        m_d->image->disconnect(this);
        oldDummiesFacade->disconnect(this);
        KisNodeDummy *oldRootDummy = m_d->dummiesFacade->rootDummy();
        if (oldRootDummy) {
            connectDummies(oldRootDummy, false);
        }
    }
 
    m_d->image = image;
    m_d->dummiesFacade = dummiesFacade;
    m_d->parentOfRemovedNode = 0;
    m_d->thumbnalCache.setImage(image);
    resetIndexConverter();
 
    if (m_d->dummiesFacade) {
        KisNodeDummy *rootDummy = m_d->dummiesFacade->rootDummy();
        if (rootDummy) {
            connectDummies(rootDummy, true);
        }
 
        connect(m_d->dummiesFacade, SIGNAL(sigBeginInsertDummy(KisNodeDummy*,int,QString)),
                SLOT(slotBeginInsertDummy(KisNodeDummy*,int,QString)));
        connect(m_d->dummiesFacade, SIGNAL(sigEndInsertDummy(KisNodeDummy*)),
                SLOT(slotEndInsertDummy(KisNodeDummy*)));
        connect(m_d->dummiesFacade, SIGNAL(sigBeginRemoveDummy(KisNodeDummy*)),
                SLOT(slotBeginRemoveDummy(KisNodeDummy*)));
        connect(m_d->dummiesFacade, SIGNAL(sigEndRemoveDummy()),
                SLOT(slotEndRemoveDummy()));
 
        connect(m_d->dummiesFacade, SIGNAL(sigDummyChanged(KisNodeDummy*)),
                SLOT(slotDummyChanged(KisNodeDummy*)));
 
        if (m_d->image.isValid()) {
            connect(m_d->image, SIGNAL(sigIsolatedModeChanged()), SLOT(slotIsolatedModeChanged()));
        }
    }
 
    if (m_d->dummiesFacade != oldDummiesFacade || m_d->shapeController != oldShapeController) {
        beginResetModel();
        endResetModel();
    }
}

◆ setIdleTaskManager()

void KisNodeModel::setIdleTaskManager ( KisIdleTasksManager * idleTasksManager )

Definition at line 347 of file kis_node_model.cpp.

{
    m_d->thumbnalCache.setIdleTaskManager(idleTasksManager);
}

References m_d, KisLayerThumbnailCache::setIdleTaskManager(), and KisNodeModel::Private::thumbnalCache.

◆ setPreferredThumnalSize()

void KisNodeModel::setPreferredThumnalSize ( int preferredSize ) const

Definition at line 190 of file kis_node_model.cpp.

{
    m_d->thumbnalCache.setMaxSize(preferredSize);
}

References m_d, KisLayerThumbnailCache::setMaxSize(), and KisNodeModel::Private::thumbnalCache.

◆ setShowGlobalSelection

void KisNodeModel::setShowGlobalSelection ( bool value )

slot

Definition at line 195 of file kis_node_model.cpp.

{
    if (m_d->nodeDisplayModeAdapter) {
        m_d->nodeDisplayModeAdapter->setShowGlobalSelectionMask(value);
    }
}

References m_d, KisNodeModel::Private::nodeDisplayModeAdapter, KisNodeDisplayModeAdapter::setShowGlobalSelectionMask(), and value().

◆ showGlobalSelection()

bool KisNodeModel::showGlobalSelection ( ) const

Definition at line 183 of file kis_node_model.cpp.

{
    return m_d->nodeDisplayModeAdapter ?
        m_d->nodeDisplayModeAdapter->showGlobalSelectionMask() :
        false;
}

References m_d, KisNodeModel::Private::nodeDisplayModeAdapter, and KisNodeDisplayModeAdapter::showGlobalSelectionMask().

◆ sibling()

QModelIndex KisNodeModel::sibling	(	int	row,
		int	column,
		const QModelIndex &	idx ) const

override

Definition at line 502 of file kis_node_model.cpp.

{
    // if it's just a different clone column, there's no need to lookup anything
    if (row == idx.row()) {
        if (column == idx.column()) {
            return idx;
        }
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(idx.model() == this, QModelIndex());
        return createIndex(row, column, idx.internalPointer());
    }
    return index(row, column, parent(idx));
}

References index(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and parent().

◆ sigBeforeBeginRemoveRows

void KisNodeModel::sigBeforeBeginRemoveRows	(	const QModelIndex &	parent,
		int	start,
		int	end )

signal

◆ slotBeginInsertDummy

void KisNodeModel::slotBeginInsertDummy	(	KisNodeDummy *	parent,
		int	index,
		const QString &	metaObjectType )

protectedslot

Definition at line 352 of file kis_node_model.cpp.

{
    int row = 0;
    QModelIndex parentIndex;
 
    bool willAdd =
        m_d->indexConverter->indexFromAddedDummy(parent, index,
                                                 metaObjectType,
                                                 parentIndex, row);
 
    if(willAdd) {
        beginInsertRows(parentIndex, row, row);
        m_d->needFinishInsertRows = true;
    }
}

References index(), KisNodeModel::Private::indexConverter, KisModelIndexConverterBase::indexFromAddedDummy(), m_d, KisNodeModel::Private::needFinishInsertRows, and parent().

◆ slotBeginRemoveDummy

void KisNodeModel::slotBeginRemoveDummy ( KisNodeDummy * dummy )

protectedslot

Definition at line 379 of file kis_node_model.cpp.

{
    if (!dummy) return;
 
    // FIXME: is it really what we want?
    m_d->updateCompressor.stop();
    m_d->updateQueue.clear();
 
    m_d->parentOfRemovedNode = dummy->parent();
 
    QModelIndex parentIndex;
    if (m_d->parentOfRemovedNode) {
        parentIndex = m_d->indexConverter->indexFromDummy(m_d->parentOfRemovedNode);
    }
 
    QModelIndex itemIndex = m_d->indexConverter->indexFromDummy(dummy);
 
    if (itemIndex.isValid()) {
        connectDummy(dummy, false);
        Q_EMIT sigBeforeBeginRemoveRows(parentIndex, itemIndex.row(), itemIndex.row());
        beginRemoveRows(parentIndex, itemIndex.row(), itemIndex.row());
        m_d->needFinishRemoveRows = true;
    }
 
    m_d->thumbnalCache.notifyNodeRemoved(dummy->node());
}

References connectDummy(), KisNodeModel::Private::indexConverter, KisModelIndexConverterBase::indexFromDummy(), m_d, KisNodeModel::Private::needFinishRemoveRows, KisNodeDummy::node(), KisLayerThumbnailCache::notifyNodeRemoved(), KisNodeDummy::parent(), KisNodeModel::Private::parentOfRemovedNode, sigBeforeBeginRemoveRows(), KisSignalCompressor::stop(), KisNodeModel::Private::thumbnalCache, KisNodeModel::Private::updateCompressor, and KisNodeModel::Private::updateQueue.

◆ slotDummyChanged

void KisNodeModel::slotDummyChanged ( KisNodeDummy * dummy )

protectedslot

Definition at line 414 of file kis_node_model.cpp.

{
    if (!m_d->updateQueue.contains(dummy)) {
        m_d->updateQueue.append(dummy);
    }
    m_d->updateCompressor.start();
}

References m_d, KisSignalCompressor::start(), KisNodeModel::Private::updateCompressor, and KisNodeModel::Private::updateQueue.

◆ slotEndInsertDummy

void KisNodeModel::slotEndInsertDummy ( KisNodeDummy * dummy )

protectedslot

Definition at line 368 of file kis_node_model.cpp.

{
    if(m_d->needFinishInsertRows) {
        connectDummy(dummy, true);
        endInsertRows();
        m_d->needFinishInsertRows = false;
    }
 
    m_d->thumbnalCache.notifyNodeAdded(dummy->node());
}

References connectDummy(), m_d, KisNodeModel::Private::needFinishInsertRows, KisNodeDummy::node(), KisLayerThumbnailCache::notifyNodeAdded(), and KisNodeModel::Private::thumbnalCache.

◆ slotEndRemoveDummy

void KisNodeModel::slotEndRemoveDummy ( )

protectedslot

Definition at line 406 of file kis_node_model.cpp.

{
    if(m_d->needFinishRemoveRows) {
        endRemoveRows();
        m_d->needFinishRemoveRows = false;
    }
}

References m_d, and KisNodeModel::Private::needFinishRemoveRows.

◆ slotIsolatedModeChanged

void KisNodeModel::slotIsolatedModeChanged ( )

protectedslot

Definition at line 175 of file kis_node_model.cpp.

{
    KisNodeDummy *rootDummy = m_d->dummiesFacade->rootDummy();
    if (!rootDummy) return;
 
    regenerateItems(rootDummy);
}

References KisNodeModel::Private::dummiesFacade, m_d, and regenerateItems().

◆ slotLayerThumbnailUpdated

void KisNodeModel::slotLayerThumbnailUpdated ( KisNodeSP node )

protectedslot

Definition at line 229 of file kis_node_model.cpp.

{
    QModelIndex index = indexFromNode(node);
    if (!index.isValid()) return;
 
    Q_EMIT dataChanged(index, index);
}

References index(), and indexFromNode().

◆ slotNodeDisplayModeChanged

void KisNodeModel::slotNodeDisplayModeChanged	(	bool	showRootNode,
		bool	showGlobalSelectionMask )

protectedslot

Definition at line 202 of file kis_node_model.cpp.

{
    const bool oldShowRootLayer = m_d->showRootLayer;
    const bool oldShowGlobalSelection = m_d->showGlobalSelection;
    m_d->showRootLayer = showRootNode;
    m_d->showGlobalSelection = showGlobalSelectionMask;
 
    if (m_d->showRootLayer != oldShowRootLayer || m_d->showGlobalSelection != oldShowGlobalSelection) {
        resetIndexConverter();
        beginResetModel();
        endResetModel();
    }
}

References m_d, resetIndexConverter(), KisNodeModel::Private::showGlobalSelection, and KisNodeModel::Private::showRootLayer.

◆ supportedDragActions()

Qt::DropActions KisNodeModel::supportedDragActions ( ) const

override

Definition at line 778 of file kis_node_model.cpp.

{
    return Qt::CopyAction | Qt::MoveAction;
}

◆ supportedDropActions()

Qt::DropActions KisNodeModel::supportedDropActions ( ) const

override

Definition at line 783 of file kis_node_model.cpp.

{
    return Qt::MoveAction | Qt::CopyAction;
}

◆ toggleIsolateActiveNode

void KisNodeModel::toggleIsolateActiveNode ( )

signal

◆ updateDropEnabled()

void KisNodeModel::updateDropEnabled	(	const QList< KisNodeSP > &	nodes,
		QModelIndex	parent = QModelIndex() )

private

Definition at line 877 of file kis_node_model.cpp.

                                                                                      {
    for (int r = 0; r < rowCount(parent); r++) {
        QModelIndex idx = index(r, 0, parent);
 
        KisNodeSP target = nodeFromIndex(idx);
 
        bool dropEnabled = true;
        Q_FOREACH (const KisNodeSP &node, nodes) {
            if (!target->allowAsChild(node) || !target->isEditable(false)) {
                dropEnabled = false;
                break;
            }
        }
        if (dropEnabled) {
            m_d->dropEnabled.insert(idx.internalId());
        }
        Q_EMIT dataChanged(idx, idx); // indicate to QT that flags() have changed
 
        if (hasChildren(idx)) {
            updateDropEnabled(nodes, idx);
        }
    }
}

References KisNodeModel::Private::dropEnabled, index(), m_d, nodeFromIndex(), parent(), rowCount(), target(), and updateDropEnabled().

Friends And Related Symbol Documentation

◆ KisModelIndexConverter

friend class KisModelIndexConverter

friend

Definition at line 192 of file kis_node_model.h.

◆ KisModelIndexConverterShowAll

friend class KisModelIndexConverterShowAll

friend

Definition at line 193 of file kis_node_model.h.

Member Data Documentation

◆ m_d

Private* const KisNodeModel::m_d

private

Definition at line 209 of file kis_node_model.h.

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

libs/ui/kis_node_model.h
libs/ui/kis_node_model.cpp

Classes

Public Types

Public Slots

Signals

Public Member Functions

Static Public Member Functions

Protected Slots

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ ItemDataRole

Constructor & Destructor Documentation

◆ KisNodeModel()

◆ ~KisNodeModel()

Member Function Documentation

◆ belongsToIsolatedGroup() [1/2]

◆ belongsToIsolatedGroup() [2/2]

◆ canDropMimeData()

◆ columnCount()

◆ connectDummies()

◆ connectDummy()

◆ createIndexConverter()

◆ data()

◆ dropMimeData()

◆ dummiesFacade()

◆ flags()

◆ hasDummiesFacade()

◆ index()

◆ indexConverter()

◆ indexFromNode()

◆ mimeData()

◆ mimeTypes()

◆ nodeFromIndex()

◆ parent()

◆ processUpdateQueue

◆ progressPercentageChanged

◆ regenerateItems()

◆ resetIndexConverter()

◆ rowCount()

◆ setData()

◆ setDropEnabled()

◆ setDummiesFacade()

◆ setIdleTaskManager()

◆ setPreferredThumnalSize()

◆ setShowGlobalSelection

◆ showGlobalSelection()

◆ sibling()

◆ sigBeforeBeginRemoveRows

◆ slotBeginInsertDummy

◆ slotBeginRemoveDummy

◆ slotDummyChanged

◆ slotEndInsertDummy

◆ slotEndRemoveDummy

◆ slotIsolatedModeChanged

◆ slotLayerThumbnailUpdated

◆ slotNodeDisplayModeChanged

◆ supportedDragActions()

◆ supportedDropActions()

◆ toggleIsolateActiveNode

◆ updateDropEnabled()

Friends And Related Symbol Documentation

◆ KisModelIndexConverter

◆ KisModelIndexConverterShowAll

Member Data Documentation

◆ m_d