refactor: replace private access hacks with accessor pattern

Remove all '#define private/protected public' hacks and replace them with a
proper C++ template-based private accessor pattern using explicit template
instantiation (friend injection trick), mirroring the approach used in
linuxdeepin/treeland#875.

Adds src/util/dprivateaccessor_p.h with Accessor/AccessorImpl templates and
D_DECLARE_PRIVATE_MEMBER, D_PRIVATE_MEMBER macros. All helpers live at global
scope so ADL correctly resolves the friend-injected get() function.

Author: zccrs

src/private/dbackdropnode.cpp

@@ -1,17 +1,14 @@
-// SPDX-FileCopyrightText: 2024 UnionTech Software Technology Co., Ltd.
+// SPDX-FileCopyrightText: 2024 - 2026 UnionTech Software Technology Co., Ltd.
 //
 // SPDX-License-Identifier: LGPL-3.0-or-later
 
 #include <QDebug>
-#define protected public
-#define private public
 #include <rhi/qrhi.h>
 #include <private/qsgrenderer_p.h>
-#undef protected
-#undef private
 
 #include "dbackdropnode_p.h"
 #include "dqmlglobalobject_p.h"
+#include "util/dprivateaccessor_p.h"
 
 #include <QQuickItem>
 #include <QRunnable>
@@ -34,6 +31,10 @@
 
 #include <algorithm>
 
+#ifndef QT_NO_OPENGL
+D_DECLARE_PRIVATE_MEMBER(QRhi_d_tag, QRhi, d, QRhiImplementation*);
+#endif
+
 DQUICK_BEGIN_NAMESPACE
 
 class Q_DECL_HIDDEN DataManagerBase : public QObject
@@ -360,7 +361,7 @@ class Q_DECL_HIDDEN RhiManager : public DataManager<RhiManager, void>
         QRhiGles2 *gles2Rhi = nullptr;
         if (forceSurface) {
             Q_ASSERT(rhi()->backend() == QRhi::OpenGLES2);
-            gles2Rhi = static_cast<QRhiGles2*>(rhi()->d);
+            gles2Rhi = static_cast<QRhiGles2*>(D_PRIVATE_MEMBER(*rhi(), QRhi_d_tag{}));
             fallbackSurface = gles2Rhi->fallbackSurface;
             gles2Rhi->fallbackSurface = forceSurface;
         }
@@ -383,17 +384,14 @@ class Q_DECL_HIDDEN RhiManager : public DataManager<RhiManager, void>
         oldCB = dc->currentFrameCommandBuffer();
         context->prepareSync(renderer->devicePixelRatio(), cb, graphicsConfiguration());
 
-        renderer->m_is_rendering = true;
-        renderer->preprocess();
+        renderer->prepareSceneInline();
 
         return true;
     }
 
     bool render(qreal oldDPR, QRhiCommandBuffer* &oldCB) {
-        Q_ASSERT(renderer->m_is_rendering);
-        renderer->render();
-        renderer->m_is_rendering = false;
-        renderer->m_changed_emitted = false;
+        renderer->renderSceneInline();
+        renderer->clearChangedFlag();
 
         context->prepareSync(oldDPR, oldCB, graphicsConfiguration());
 

src/private/dqmlglobalobject.cpp

@@ -2,12 +2,11 @@
 //
 // SPDX-License-Identifier: LGPL-3.0-or-later
 
-#define private public
 #include <QSGNode>
-#undef private
 
 #include "dqmlglobalobject_p.h"
 #include "dqmlglobalobject_p_p.h"
+#include "util/dprivateaccessor_p.h"
 #include "dquickcontrolpalette_p.h"
 #include "dquickdciicon_p.h"
 #include "dquickimageprovider_p.h"
@@ -36,6 +35,11 @@
 
 DGUI_USE_NAMESPACE
 
+D_DECLARE_PRIVATE_MEMBER(QSGNode_m_subtreeRenderableCount_tag, QSGNode, m_subtreeRenderableCount, int);
+D_DECLARE_PRIVATE_MEMBER(QSGNode_m_firstChild_tag, QSGNode, m_firstChild, QSGNode *);
+D_DECLARE_PRIVATE_MEMBER(QSGNode_m_lastChild_tag, QSGNode, m_lastChild, QSGNode *);
+D_DECLARE_PRIVATE_MEMBER(QSGNode_m_parent_tag, QSGNode, m_parent, QSGNode *);
+
 DQUICK_BEGIN_NAMESPACE
 
 // ###(zccrs): The offset must greater than QColor::Spec
@@ -550,22 +554,22 @@ QSGRootNode *DQMLGlobalObject::getRootNode(QQuickItem *item)
 
 int &DQMLGlobalObject::QSGNode_subtreeRenderableCount(QSGNode *node)
 {
-    return node->m_subtreeRenderableCount;
+    return D_PRIVATE_MEMBER(*node, QSGNode_m_subtreeRenderableCount_tag{});
 }
 
 QSGNode *&DQMLGlobalObject::QSGNode_firstChild(QSGNode *node)
 {
-    return node->m_firstChild;
+    return D_PRIVATE_MEMBER(*node, QSGNode_m_firstChild_tag{});
 }
 
 QSGNode *&DQMLGlobalObject::QSGNode_lastChild(QSGNode *node)
 {
-    return node->m_lastChild;
+    return D_PRIVATE_MEMBER(*node, QSGNode_m_lastChild_tag{});
 }
 
 QSGNode *&DQMLGlobalObject::QSGNode_parent(QSGNode *node)
 {
-    return node->m_parent;
+    return D_PRIVATE_MEMBER(*node, QSGNode_m_parent_tag{});
 }
 #endif
 

src/util/dprivateaccessor_p.h

@@ -0,0 +1,72 @@
+// SPDX-FileCopyrightText: 2026 UnionTech Software Technology Co., Ltd.
+//
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#pragma once
+
+#include <QtCore/qcompilerdetection.h>
+
+// Private member accessor using the explicit template instantiation technique.
+//
+// C++ Standard [temp.explicit]/12 states:
+// "The usual access checking rules do not apply to names used to
+// specify explicit instantiation definitions."
+//
+// This allows passing pointers to private/protected data members and
+// member functions as template arguments in explicit instantiations,
+// bypassing normal access control — without modifying the class definition
+// and without the UB caused by "#define private public".
+//
+// NOTE: These helper structs must be in the SAME namespace as the Tag structs
+// (global namespace, since the macros expand at file scope). If they were in a
+// sub-namespace, the friend definition would create a different function than
+// the friend declaration in the Tag struct, causing undefined-reference errors.
+
+QT_WARNING_PUSH
+QT_WARNING_DISABLE_GCC("-Wnon-template-friend")
+
+template<typename Tag>
+struct DtkDeclarativePrivateAccessor
+{
+    using MemberPtr = typename Tag::MemberPtr;
+    friend MemberPtr get(Tag) noexcept;
+};
+
+template<typename Tag, typename Tag::MemberPtr Ptr>
+struct DtkDeclarativePrivateAccessorImpl : DtkDeclarativePrivateAccessor<Tag>
+{
+    friend typename Tag::MemberPtr get(Tag) noexcept { return Ptr; }
+};
+
+QT_WARNING_POP
+
+#define D_DECLARE_PRIVATE_MEMBER(TagName, ClassName, Member, MemberType) \
+    struct TagName { \
+        using MemberPtr = MemberType ClassName::*; \
+        friend MemberPtr get(TagName) noexcept; \
+    }; \
+    template struct DtkDeclarativePrivateAccessorImpl<TagName, &ClassName::Member>
+
+#define D_DECLARE_PRIVATE_METHOD(TagName, ClassName, MethodName, RetType, ...) \
+    struct TagName { \
+        using MemberPtr = RetType (ClassName::*)(__VA_ARGS__); \
+        friend MemberPtr get(TagName) noexcept; \
+    }; \
+    template struct DtkDeclarativePrivateAccessorImpl<TagName, &ClassName::MethodName>
+
+#define D_DECLARE_PRIVATE_CONST_METHOD(TagName, ClassName, MethodName, RetType, ...) \
+    struct TagName { \
+        using MemberPtr = RetType (ClassName::*)(__VA_ARGS__) const; \
+        friend MemberPtr get(TagName) noexcept; \
+    }; \
+    template struct DtkDeclarativePrivateAccessorImpl<TagName, &ClassName::MethodName>
+
+// Trampoline: ensures get(tag) is called from a context with no class-scope
+// get() member that might suppress ADL (C++ [basic.lookup.argdep] para 3).
+namespace dtk_private_detail {
+    template<typename Tag>
+    inline typename Tag::MemberPtr access(Tag t) noexcept { return get(t); }
+}
+
+#define D_PRIVATE_MEMBER(obj, tag) ((obj).*dtk_private_detail::access(tag))
+#define D_PRIVATE_CALL(obj, tag, ...) ((obj).*dtk_private_detail::access(tag))(__VA_ARGS__)