QskTreeNode.cpp

/******************************************************************************
 * QSkinny - Copyright (C) The authors
 *           SPDX-License-Identifier: BSD-3-Clause
 *****************************************************************************/
 
#include "QskTreeNode.h"
 
static const auto extraFlag =
    static_cast< QSGNode::Flag >( QSGNode::IsVisitableNode << 1 );
 
static inline QSGNode* qskCheckedNode( const QSGNode* node, QSGNode::NodeType type )
{
    return node && ( node->type() == type ) && ( node->flags() & extraFlag )
        ? const_cast< QSGNode* >( node ) : nullptr;
}
 
QskTreeNode::QskTreeNode()
{
    setFlag( extraFlag, true );
}
 
QskTreeNode::QskTreeNode( QSGNodePrivate& d )
    : QSGNode( d, QSGNode::BasicNodeType )
{
    setFlag( extraFlag, true );
}
 
QskTreeNode::~QskTreeNode()
{
}
 
void QskTreeNode::setSubtreeBlocked( bool on, bool notify )
{
    if ( on == m_isBlocked )
        return;
 
    m_isBlocked = on;
 
    if ( notify )
        markDirty( DirtySubtreeBlocked );
}
 
bool QskTreeNode::isSubtreeBlocked() const
{
    return m_isBlocked;
}
 
QskTreeNode* qskTreeNodeCast( QSGNode* node )
{
    return static_cast< QskTreeNode* >(
        qskCheckedNode( node, QSGNode::BasicNodeType ) );
}
 
const QskTreeNode* qskTreeNodeCast( const QSGNode* node )
{
    return static_cast< QskTreeNode* >(
        qskCheckedNode( node, QSGNode::BasicNodeType ) );
}
 
 
// == QskItemNode
 
QskItemNode::QskItemNode()
{
    setFlag( extraFlag, true );
}
 
QskItemNode::~QskItemNode()
{
}
 
void QskItemNode::setSubtreeBlocked( bool on, bool notify )
{
    if ( on == m_isBlocked )
        return;
 
    m_isBlocked = on;
 
    if ( notify )
        markDirty( DirtySubtreeBlocked );
}
 
bool QskItemNode::isSubtreeBlocked() const
{
    return m_isBlocked;
}
 
QskItemNode* qskItemNodeCast( QSGNode* node )
{
    return static_cast< QskItemNode* >(
        qskCheckedNode( node, QSGNode::TransformNodeType ) );
}
 
const QskItemNode* qskItemNodeCast( const QSGNode* node )
{
    return static_cast< QskItemNode* >(
        qskCheckedNode( node, QSGNode::TransformNodeType ) );
}
 
bool qskIsBlockableNode( const QSGNode* node )
{
    switch( node->type() )
    {
        case QSGNode::BasicNodeType:
        case QSGNode::TransformNodeType:
            return node->flags() & extraFlag;
 
        default:
            return false;
    }
}
 
bool qskTryBlockNode( QSGNode* node, bool on, bool notify )
{
    if ( node && ( node->flags() & extraFlag ) )
    {
        if ( node->type() == QSGNode::BasicNodeType )
        {
            static_cast< QskTreeNode* >( node )->setSubtreeBlocked( on, notify );
            return true;
        }
 
        if ( node->type() == QSGNode::TransformNodeType )
        {
            static_cast< QskItemNode* >( node )->setSubtreeBlocked( on, notify );
            return true;
        }
    }
 
    return false;
}
 
void qskTryBlockTree( QSGNode* node, bool on, bool notify )
{
    if ( qskTryBlockNode( node, on, notify ) )
        return;
 
    for ( auto child = node->firstChild();
        child != nullptr; child = child->nextSibling() )
    {
        qskTryBlockTree( child, on, notify );
    }
}
 
void qskTryBlockTrailingNodes(
    QSGNode* node, const QSGNode* ancestorNode, bool on, bool notify )
{
    qskTryBlockTree( node, on, notify );
 
    for ( auto sibling = node->nextSibling();
        sibling != nullptr; sibling = sibling->nextSibling() )
    {
        qskTryBlockTree( sibling, on, notify );
    }
 
    if ( node != ancestorNode )
    {
        if ( auto upperNode = node->parent() )
        {
            upperNode = upperNode->nextSibling();
            if ( upperNode )
                qskTryBlockTrailingNodes( upperNode, ancestorNode, on, notify );
        }
    }
}