QskTreeNode introduced

src/CMakeLists.txt

@@ -115,6 +115,7 @@ list(APPEND HEADERS
     nodes/QskGraduationNode.h
     nodes/QskGraduationRenderer.h
     nodes/QskGraphicNode.h
+    nodes/QskTreeNode.h
     nodes/QskLinesNode.h
     nodes/QskPaintedNode.h
     nodes/QskPlainTextRenderer.h
@@ -160,6 +161,7 @@ list(APPEND SOURCES
     nodes/QskStrokeNode.cpp
     nodes/QskStippledLineRenderer.cpp
     nodes/QskShapeNode.cpp
+    nodes/QskTreeNode.cpp
     nodes/QskGradientMaterial.cpp
     nodes/QskTextNode.cpp
     nodes/QskTextRenderer.cpp

src/controls/QskControl.cpp

@@ -15,6 +15,7 @@
 #include "QskSkinlet.h"
 #include "QskSkinHintTable.h"
 #include "QskMargins.h"
+#include "QskTreeNode.h"
 
 #include <qlocale.h>
 #include <qvector.h>
@@ -977,7 +978,7 @@ void QskControl::updateItemPolish()
 QSGNode* QskControl::updateItemPaintNode( QSGNode* node )
 {
     if ( node == nullptr )
-        node = new QSGNode;
+        node = new QskTreeNode();
 
     updateNode( node );
     return node;

src/controls/QskQuickItemPrivate.cpp

@@ -4,6 +4,7 @@
  *****************************************************************************/
 
 #include "QskQuickItemPrivate.h"
+#include "QskTreeNode.h"
 #include "QskSetup.h"
 
 static inline void qskSendEventTo( QObject* object, QEvent::Type type )
@@ -240,11 +241,13 @@ void QskQuickItemPrivate::cleanupNodes()
     }
 }
 
+QSGTransformNode* QskQuickItemPrivate::createTransformNode()
+{
+    return new QskItemNode();
+}
+
 /*
     Can we do something useful with overloading:
 
-        - QQuickItemPrivate::createTransformNode
         - QQuickItemPrivate::transformChanged
-
-    TODO ...
  */

src/controls/QskQuickItemPrivate.h

@@ -23,13 +23,13 @@ class QskQuickItemPrivate : public QQuickItemPrivate
 
   public:
     void applyUpdateFlags( QskQuickItem::UpdateFlags );
+    QSGTransformNode* createTransformNode() override;
 
   protected:
     virtual void layoutConstraintChanged();
     virtual void implicitSizeChanged();
 
   private:
-
     void cleanupNodes();
     void mirrorChange() override;
 

src/nodes/QskTreeNode.cpp

@@ -0,0 +1,165 @@
+/******************************************************************************
+ * QSkinny - Copyright (C) 2016 Uwe Rathmann
+ *           SPDX-License-Identifier: BSD-3-Clause
+ *****************************************************************************/
+
+#include "QskTreeNode.h"
+
+static constexpr 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 );
+        }
+    }
+}

src/nodes/QskTreeNode.h

@@ -0,0 +1,63 @@
+/******************************************************************************
+ * QSkinny - Copyright (C) 2016 Uwe Rathmann
+ *           SPDX-License-Identifier: BSD-3-Clause
+ *****************************************************************************/
+
+#ifndef QSK_TREE_NODE_H
+#define QSK_TREE_NODE_H
+
+#include "QskGlobal.h"
+#include <qsgnode.h>
+
+/*
+   Used as paintNode in all QskControls ( see QskControl::updateItemPaintNode )
+ */
+class QSK_EXPORT QskTreeNode final : public QSGNode
+{
+  public:
+    QskTreeNode();
+    virtual ~QskTreeNode();
+
+    void setSubtreeBlocked( bool on, bool notify = true );
+    bool isSubtreeBlocked() const override;
+
+  protected:
+    QskTreeNode( QSGNodePrivate& );
+
+  private:
+    bool m_isBlocked = false;;
+};
+
+QSK_EXPORT QskTreeNode* qskTreeNodeCast( QSGNode* );
+QSK_EXPORT const QskTreeNode* qskTreeNodeCast( const QSGNode* );
+
+/*
+    Used by all QskQuickItem as root node ( = itemNode ) of its subtree
+    ( see qskItemNode in QskQuick.h )
+ */
+class QSK_EXPORT QskItemNode final : public QSGTransformNode
+{
+  public:
+    QskItemNode();
+    virtual ~QskItemNode();
+
+    void setSubtreeBlocked( bool on, bool notify = true );
+    bool isSubtreeBlocked() const override;
+
+  private:
+    bool m_isBlocked = false;;
+};
+
+QSK_EXPORT QskItemNode* qskItemNodeCast( QSGNode* );
+QSK_EXPORT const QskItemNode* qskItemNodeCast( const QSGNode* );
+
+QSK_EXPORT bool qskIsBlockableNode( const QSGNode* );
+QSK_EXPORT bool qskTryBlockNode( QSGNode*, bool on, bool notify = true );
+
+QSK_EXPORT void qskTryBlockTree( QSGNode*, bool on, bool notify = true );
+
+// un/block a node and all its successors in the rendering pipeline
+QSK_EXPORT void qskTryBlockTrailingNodes(
+    QSGNode*, const QSGNode* ancestorNode, bool on, bool notify = true );
+
+#endif