From 6d8c2f0419c2bfe8b299cec81fd90ee9f8e2365e Mon Sep 17 00:00:00 2001 From: tangchao0503 <735056338@qq.com> Date: Sat, 14 Mar 2026 00:38:44 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BC=98=E5=8C=96LayerTree=E7=9A=84=E6=95=B0?= =?UTF-8?q?=E6=8D=AE=E7=BB=93=E6=9E=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- HPPA/HPPA.cpp | 36 +++----------- HPPA/HPPA.h | 2 - HPPA/LayerTree.cpp | 30 +---------- HPPA/LayerTree.h | 31 ++---------- HPPA/LayerTreeGroupNode.cpp | 99 ++++++++++++++++++++++++++++++++++++- HPPA/LayerTreeGroupNode.h | 37 ++++++++++++-- HPPA/LayerTreeLayerNode.cpp | 8 +-- HPPA/LayerTreeLayerNode.h | 14 ++++-- HPPA/LayerTreeModel.cpp | 37 +++++++------- HPPA/LayerTreeModel.h | 4 +- HPPA/LayerTreeNode.cpp | 37 +++++++++++--- HPPA/LayerTreeNode.h | 30 ++++++++++- 12 files changed, 239 insertions(+), 126 deletions(-) diff --git a/HPPA/HPPA.cpp b/HPPA/HPPA.cpp index 22ec195..a98216e 100644 --- a/HPPA/HPPA.cpp +++ b/HPPA/HPPA.cpp @@ -905,7 +905,7 @@ void HPPA::removeLayerByTreeIndex() LayerTreeNode* node = static_cast(currentIndexTmp.internalPointer()); if (!node || node->type() != LayerTreeNode::Type::Layer) return; - auto* layerNode = static_cast(node); + auto* layerNode = static_cast(node); MapLayer* mapLayer = layerNode->mapLayer(); QWidget* layerWidget = nullptr; @@ -957,7 +957,7 @@ void HPPA::removeAllLayersInRasterGroup() if (node->type() != LayerTreeNode::Type::Layer) continue; - auto* layerNode = static_cast(node); + auto* layerNode = static_cast(node); MapLayer* mapLayer = layerNode->mapLayer(); QWidget* layerWidget = nullptr; @@ -1247,9 +1247,9 @@ void HPPA::onStartRecordStep1() else { m_omc->stop(); - m_RecordState -= 1; + m_RecordState -= 1; - ui.action_start_recording->setText(QString::fromLocal8Bit("采集")); + ui.action_start_recording->setText(QString::fromLocal8Bit("采集")); ui.mainToolBar->widgetForAction(ui.action_start_recording)->setStyleSheet("QWidget{background-color:rgb(0,255,0);}"); } return; @@ -1572,7 +1572,7 @@ void HPPA::onOpenImg() RasterLayer* rl = new RasterLayer(baseName, uri); - auto* layerNode = new LayerTreeLayerNode(rl); + auto* layerNode = new LayerTreeLayer(rl); m_LayerTreeModel->addLayer(m_RasterGroup, layerNode); QWidget* mapcavasContainer = onCreateTab(baseName); @@ -1722,26 +1722,6 @@ void HPPA::testImagerStatus() m_TestImagerStausThread->start(); } -void HPPA::onImageFileSaved(QString path, int fileIndex) -{ - // 该槽在 UI 线程中执行（Qt 会使用 queued connection），可以安全操作 model - QFileInfo fi(path); - QString base = fi.completeBaseName(); // 去掉路径与扩展名（例如 tmp_image_0） - - // 将新的 layer 添加到 Raster 分组 - if (!m_LayerTreeModel || !m_RasterGroup) return; - - // layer 名称可根据需要调整，这里用文件名作为图层名 - { - auto* ln = new LayerTreeLayerNode(nullptr); - ln->setName(base); - m_LayerTreeModel->addLayer(m_RasterGroup, ln); - } - - // 可选：展开 TOC 或者做其他 UI 更新（目前不做动画，仅打印日志） - qDebug() << "ImageFileSaved -> add layer:" << base << " index:" << fileIndex; -} - void HPPA::onAutoExposure() { double ReturnedExposureTime = m_Imager->auto_exposure(); @@ -2054,9 +2034,9 @@ void HPPA::onLayerCreatedFromFile(const QString& baseName, const QString& filePa QList mapcavas = mapcavasContainer->findChildren(); mapcavas[0]->setLayers(ml); - auto* layerNode = new LayerTreeLayerNode(ml); + auto* layerNode = new LayerTreeLayer(ml); LayerTreeNode* node = m_LayerTreeModel->addLayer(m_RasterGroup, layerNode); - LayerTreeLayerNode* lnode = dynamic_cast(node); + LayerTreeLayer* lnode = dynamic_cast(node); if (!lnode) return; // layerNode already holds the MapLayer pointer from constructor @@ -2085,7 +2065,7 @@ void HPPA::onLayerTreeSelectionChanged(const QItemSelection& selected, const QIt return; } - auto* layerNode = static_cast(node); + auto* layerNode = static_cast(node); MapLayer* mapLayer = layerNode->mapLayer(); if (!mapLayer || mapLayer->layerType() != MapLayer::LayerType::Raster) { m_ic->setActiveLayer(nullptr); diff --git a/HPPA/HPPA.h b/HPPA/HPPA.h index f027881..b1a7c26 100644 --- a/HPPA/HPPA.h +++ b/HPPA/HPPA.h @@ -341,8 +341,6 @@ public Q_SLOTS: void onCreated3DModelPlantPhenotype(); void onCreated3DModelOneMotor(); - void onImageFileSaved(QString path, int fileIndex); - void onLayerCreatedFromFile(const QString& baseName, const QString& filePath, int fileIndex); void removeLayerByTreeIndex(); void removeAllLayersInRasterGroup(); diff --git a/HPPA/LayerTree.cpp b/HPPA/LayerTree.cpp index 208e066..7499d1a 100644 --- a/HPPA/LayerTree.cpp +++ b/HPPA/LayerTree.cpp @@ -1,39 +1,13 @@ #include "LayerTree.h" -#include "LayerTreeGroupNode.h" LayerTree::LayerTree(QObject* parent) - : QObject(parent) + : LayerTreeGroup("__root__", parent) { - // root Ϊ view ʾ - m_root = new LayerTreeGroupNode("__root__", this); - m_root->setVisible(Qt::Checked); + setVisible(Qt::Checked); } LayerTree::~LayerTree() { - delete m_root; - m_root = nullptr; -} - -LayerTreeNode* LayerTree::root() const -{ - return m_root; -} - -LayerTreeNode* LayerTree::insertNode(LayerTreeNode* parent, int row, LayerTreeNode* node) -{ - if (!node) return nullptr; - if (!parent) parent = m_root; - - if (row < 0) row = parent->childCount(); - parent->insertChild(row, node); - return node; -} - -LayerTreeNode* LayerTree::removeNode(LayerTreeNode* parent, int row) -{ - if (!parent) parent = m_root; - return parent->takeChild(row); } void LayerTree::setChildrenVisible(LayerTreeNode* n, Qt::CheckState state) diff --git a/HPPA/LayerTree.h b/HPPA/LayerTree.h index 41a880d..050a1a4 100644 --- a/HPPA/LayerTree.h +++ b/HPPA/LayerTree.h @@ -1,18 +1,16 @@ #pragma once -#include -#include "LayerTreeNode.h" +#include "LayerTreeGroupNode.h" /** - * LayerTreeĿ¼ - * - root - * - ṩ/Ƴڵ API + * LayerTreeͼڵ + * - ̳ LayerTreeGroupĸڵ * - ṩɼԼ븸ڵ̬µľ̬ * * ע⣺beginInsertRows/endInsertRows Qt Model ֪ͨӦ Model ã * LayerTree ֻάݽṹȷԡ */ -class LayerTree : public QObject +class LayerTree : public LayerTreeGroup { Q_OBJECT public: @@ -22,28 +20,7 @@ public: LayerTree(const LayerTree&) = delete; LayerTree& operator=(const LayerTree&) = delete; - LayerTreeNode* root() const; - - // 룺parent Ϊ nullptr ʾ rootrow=-1 ʾ append - LayerTreeNode* insertNode(LayerTreeNode* parent, int row, LayerTreeNode* node); - - // Ƴ deleteرƳڵ㣨߸ delete ²룩 - LayerTreeNode* removeNode(LayerTreeNode* parent, int row); - // ɼ߼ Model ã static void setChildrenVisible(LayerTreeNode* n, Qt::CheckState state); static void updateParentVisibleFromChildren(LayerTreeNode* parent); - - static inline bool isLayer(LayerTreeNode* node) - { - return node && node->type() == LayerTreeNode::Type::Layer; - } - - static inline bool isGroup(LayerTreeNode* node) - { - return node && node->type() == LayerTreeNode::Type::Group; - } - -private: - LayerTreeNode* m_root = nullptr; // owned }; diff --git a/HPPA/LayerTreeGroupNode.cpp b/HPPA/LayerTreeGroupNode.cpp index 056df55..621da50 100644 --- a/HPPA/LayerTreeGroupNode.cpp +++ b/HPPA/LayerTreeGroupNode.cpp @@ -1,6 +1,103 @@ #include "LayerTreeGroupNode.h" +#include "LayerTreeLayerNode.h" -LayerTreeGroupNode::LayerTreeGroupNode(const QString& name, QObject* parent) +LayerTreeGroup::LayerTreeGroup(const QString& name, QObject* parent) : LayerTreeNode(name, parent) { } + +LayerTreeGroup* LayerTreeGroup::insertGroup(int index, const QString& name) +{ + auto* group = new LayerTreeGroup(name); + insertChildNode(index, group); + return group; +} + +LayerTreeGroup* LayerTreeGroup::addGroup(const QString& name) +{ + return insertGroup(childCount(), name); +} + +LayerTreeLayer* LayerTreeGroup::insertLayer(int index, LayerTreeLayer* layer) +{ + if (!layer) return nullptr; + insertChildNode(index, layer); + return layer; +} + +LayerTreeLayer* LayerTreeGroup::addLayer(LayerTreeLayer* layer) +{ + return insertLayer(childCount(), layer); +} + +void LayerTreeGroup::insertChildNode(int index, LayerTreeNode* node) +{ + insertChild(index, node); +} + +void LayerTreeGroup::addChildNode(LayerTreeNode* node) +{ + appendChild(node); +} + +LayerTreeNode* LayerTreeGroup::removeChildNode(LayerTreeNode* node) +{ + if (!node) return nullptr; + int row = -1; + for (int i = 0; i < childCount(); ++i) + { + if (childAt(i) == node) + { + row = i; + break; + } + } + if (row < 0) return nullptr; + removeChild(row, 1, false); + return node; +} + +LayerTreeLayer* LayerTreeGroup::findLayer(const QString& name) const +{ + const auto layers = findLayers(); + for (auto* l : layers) + { + if (l->name() == name) + return l; + } + return nullptr; +} + +QList LayerTreeGroup::findLayers() const +{ + QList result; + for (int i = 0; i < childCount(); ++i) + { + LayerTreeNode* child = childAt(i); + if (LayerTreeNode::isLayer(child)) + { + result.append(static_cast(child)); + } + else if (LayerTreeNode::isGroup(child)) + { + result.append(static_cast(child)->findLayers()); + } + } + return result; +} + +QList LayerTreeGroup::findGroups() const +{ + QList result; + for (int i = 0; i < childCount(); ++i) + { + LayerTreeNode* child = childAt(i); + if (LayerTreeNode::isGroup(child)) + { + auto* g = static_cast(child); + result.append(g); + result.append(g->findGroups()); + } + } + return result; +} diff --git a/HPPA/LayerTreeGroupNode.h b/HPPA/LayerTreeGroupNode.h index 6b1015a..1e80fa8 100644 --- a/HPPA/LayerTreeGroupNode.h +++ b/HPPA/LayerTreeGroupNode.h @@ -1,15 +1,44 @@ #pragma once #include "LayerTreeNode.h" -/** Group ڵ */ -class LayerTreeGroupNode : public LayerTreeNode +class LayerTreeLayer; + +/** + * LayerTreeGroupͼڵ + * - Ϊ LayerTreeNode + * - ṩͼڵ㣨LayerTreeLayerͼ飨LayerTreeGroupı + */ +class LayerTreeGroup : public LayerTreeNode { Q_OBJECT public: - explicit LayerTreeGroupNode(const QString& name, - QObject* parent = nullptr); + explicit LayerTreeGroup(const QString& name = QString(), + QObject* parent = nullptr); Type type() const override { return Type::Group; } + // + LayerTreeGroup* insertGroup(int index, const QString& name); + LayerTreeGroup* addGroup(const QString& name); + + // ͼڵ + LayerTreeLayer* insertLayer(int index, LayerTreeLayer* layer); + LayerTreeLayer* addLayer(LayerTreeLayer* layer); + + // ڵ + void insertChildNode(int index, LayerTreeNode* node); + void addChildNode(LayerTreeNode* node); + + // Ƴӽڵ㣨 deleteرƳڵ㣩 + LayerTreeNode* removeChildNode(LayerTreeNode* node); + + // + LayerTreeLayer* findLayer(const QString& name) const; + QList findLayers() const; + QList findGroups() const; + // Ժչcollapsed / groupOpacity }; + +// +using LayerTreeGroupNode = LayerTreeGroup; diff --git a/HPPA/LayerTreeLayerNode.cpp b/HPPA/LayerTreeLayerNode.cpp index d85a4f6..16237bc 100644 --- a/HPPA/LayerTreeLayerNode.cpp +++ b/HPPA/LayerTreeLayerNode.cpp @@ -1,22 +1,22 @@ #include "LayerTreeLayerNode.h" -LayerTreeLayerNode::LayerTreeLayerNode(MapLayer* layer, QObject* parent) +LayerTreeLayer::LayerTreeLayer(MapLayer* layer, QObject* parent) : LayerTreeNode(layer ? layer->name() : QString(), parent), m_layer(layer) { } -LayerTreeNode::Type LayerTreeLayerNode::type() const +LayerTreeNode::Type LayerTreeLayer::type() const { return Type::Layer; } // һ MapLayer ָ루ӵУ -void LayerTreeLayerNode::setMapLayer(MapLayer* layer) +void LayerTreeLayer::setMapLayer(MapLayer* layer) { m_layer = layer; } -MapLayer* LayerTreeLayerNode::mapLayer() const +MapLayer* LayerTreeLayer::mapLayer() const { return m_layer; } diff --git a/HPPA/LayerTreeLayerNode.h b/HPPA/LayerTreeLayerNode.h index d95966e..4c70663 100644 --- a/HPPA/LayerTreeLayerNode.h +++ b/HPPA/LayerTreeLayerNode.h @@ -2,16 +2,19 @@ #include "LayerTreeNode.h" #include "MapLayer.h" -/** Layer ڵ */ -class LayerTreeLayerNode : public LayerTreeNode +/** + * LayerTreeLayerͼڵ + * - Ϊ LayerTreeNode + * - һ MapLayer ָ루ӵУ + */ +class LayerTreeLayer : public LayerTreeNode { Q_OBJECT public: - explicit LayerTreeLayerNode(MapLayer* layer, QObject* parent = nullptr); + explicit LayerTreeLayer(MapLayer* layer, QObject* parent = nullptr); Type type() const override; - // һ MapLayer ָ루ӵУ void setMapLayer(MapLayer* layer); MapLayer* mapLayer() const; @@ -20,3 +23,6 @@ private: // չlayerId / pointer / legendItems }; + +// +using LayerTreeLayerNode = LayerTreeLayer; diff --git a/HPPA/LayerTreeModel.cpp b/HPPA/LayerTreeModel.cpp index c848b81..2f010d5 100644 --- a/HPPA/LayerTreeModel.cpp +++ b/HPPA/LayerTreeModel.cpp @@ -28,10 +28,10 @@ QModelIndex LayerTreeModel::index(int row, int column, const QModelIndex& parent QModelIndex LayerTreeModel::parent(const QModelIndex& child) const { LayerTreeNode* node = nodeFromIndex(child); - if (!node || node == m_tree->root()) return {}; + if (!node || node == m_tree) return {}; LayerTreeNode* p = node->parentNode(); - if (!p || p == m_tree->root()) return {}; + if (!p || p == m_tree) return {}; return createIndex(p->rowInParent(), 0, p); } @@ -50,7 +50,7 @@ int LayerTreeModel::columnCount(const QModelIndex&) const QVariant LayerTreeModel::data(const QModelIndex& index, int role) const { LayerTreeNode* n = nodeFromIndex(index); - if (!n || n == m_tree->root()) return {}; + if (!n || n == m_tree) return {}; switch (role) { case Qt::DisplayRole: @@ -59,9 +59,9 @@ QVariant LayerTreeModel::data(const QModelIndex& index, int role) const case Qt::DecorationRole: { auto* tmp = nodeFromIndex(index); - if (LayerTree::isGroup(tmp)) + if (LayerTreeNode::isGroup(tmp)) return QIcon(); - else if (LayerTree::isLayer(tmp)) + else if (LayerTreeNode::isLayer(tmp)) { QString basePath = QCoreApplication::applicationDirPath(); return QIcon(basePath + "/icons/mIconRaster.svg"); @@ -82,7 +82,7 @@ QVariant LayerTreeModel::data(const QModelIndex& index, int role) const bool LayerTreeModel::setData(const QModelIndex& index, const QVariant& value, int role) { LayerTreeNode* n = nodeFromIndex(index); - if (!n || n == m_tree->root()) return false; + if (!n || n == m_tree) return false; if (role == Qt::CheckStateRole) { auto newState = static_cast(value.toInt()); @@ -111,39 +111,39 @@ Qt::ItemFlags LayerTreeModel::flags(const QModelIndex& index) const if (!index.isValid()) return Qt::NoItemFlags; LayerTreeNode* n = nodeFromIndex(index); - if (!n || n == m_tree->root()) return Qt::NoItemFlags; + if (!n || n == m_tree) return Qt::NoItemFlags; return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsUserCheckable; } LayerTreeNode* LayerTreeModel::root() const { - return m_tree->root(); + return m_tree; } LayerTreeNode* LayerTreeModel::addGroup(LayerTreeNode* parent, const QString& name, const QIcon& icon) { - if (!parent) parent = m_tree->root(); + if (!parent) parent = m_tree; const int row = parent->childCount(); beginInsertRows(indexFromNode(parent), row, row); - LayerTreeNode* g = m_tree->insertNode(parent, row, new LayerTreeGroupNode(name)); + LayerTreeNode* g = m_tree->addGroup(name); endInsertRows(); return g; } -LayerTreeNode* LayerTreeModel::addLayer(LayerTreeNode* parent, LayerTreeLayerNode* layerNode, const QIcon& icon) +LayerTreeNode* LayerTreeModel::addLayer(LayerTreeNode* parent, LayerTreeLayer* layerNode, const QIcon& icon) { - if (!parent) parent = m_tree->root(); + if (!parent) parent = m_tree; if (!layerNode) return nullptr; const int row = parent->childCount(); beginInsertRows(indexFromNode(parent), row, row); - LayerTreeNode* l = m_tree->insertNode(parent, row, layerNode); + parent->insertChild(row, layerNode); endInsertRows(); - return l; + return layerNode; } void LayerTreeModel::setCascadeCheckEnabled(bool enabled) @@ -159,11 +159,12 @@ bool LayerTreeModel::cascadeCheckEnabled() const // ʵ֣Ƴӽڵ㲢 model Ϸ begin/endRemoveRows LayerTreeNode* LayerTreeModel::removeNode(LayerTreeNode* parent, int row) { - if (!parent) parent = m_tree->root(); + if (!parent) parent = m_tree; if (row < 0 || row >= parent->childCount()) return nullptr; + LayerTreeNode* removed = parent->childAt(row); beginRemoveRows(indexFromNode(parent), row, row); - LayerTreeNode* removed = m_tree->removeNode(parent, row); + parent->removeChild(row, 1, false); endRemoveRows(); return removed; @@ -171,12 +172,12 @@ LayerTreeNode* LayerTreeModel::removeNode(LayerTreeNode* parent, int row) LayerTreeNode* LayerTreeModel::nodeFromIndex(const QModelIndex& index) const { - if (!index.isValid()) return m_tree->root(); + if (!index.isValid()) return m_tree; return static_cast(index.internalPointer()); } QModelIndex LayerTreeModel::indexFromNode(LayerTreeNode* n) const { - if (!n || n == m_tree->root()) return {}; + if (!n || n == m_tree) return {}; return createIndex(n->rowInParent(), 0, n); } diff --git a/HPPA/LayerTreeModel.h b/HPPA/LayerTreeModel.h index b618298..9d3bf4b 100644 --- a/HPPA/LayerTreeModel.h +++ b/HPPA/LayerTreeModel.h @@ -3,7 +3,7 @@ #include #include "LayerTree.h" -class LayerTreeLayerNode; // forward declare +class LayerTreeLayer; // forward declare /** * LayerTreeModelQt 㣨ٹ @@ -34,7 +34,7 @@ public: LayerTreeNode* root() const; LayerTreeNode* addGroup(LayerTreeNode* parent, const QString& name, const QIcon& icon = QIcon()); - LayerTreeNode* addLayer(LayerTreeNode* parent, LayerTreeLayerNode* layerNode, const QIcon& icon = QIcon()); + LayerTreeNode* addLayer(LayerTreeNode* parent, LayerTreeLayer* layerNode, const QIcon& icon = QIcon()); void setCascadeCheckEnabled(bool enabled); bool cascadeCheckEnabled() const; diff --git a/HPPA/LayerTreeNode.cpp b/HPPA/LayerTreeNode.cpp index 1504104..9f9a48d 100644 --- a/HPPA/LayerTreeNode.cpp +++ b/HPPA/LayerTreeNode.cpp @@ -20,7 +20,11 @@ QString LayerTreeNode::name() const void LayerTreeNode::setName(const QString& name) { - m_name = name; + if (m_name != name) + { + m_name = name; + emit nameChanged(this, name); + } } QIcon LayerTreeNode::icon() const @@ -97,14 +101,35 @@ void LayerTreeNode::insertChild(int row, LayerTreeNode* child) if (row < 0 || row > m_children.size()) row = m_children.size(); + emit willAddChildren(this, row, row); child->setParentNode(this); m_children.insert(row, child); + emit addedChildren(this, row, row); } -LayerTreeNode* LayerTreeNode::takeChild(int row) +void LayerTreeNode::removeChild(int from, int count, bool destroy) { - if (row < 0 || row >= m_children.size()) return nullptr; - LayerTreeNode* taken = m_children.takeAt(row); - if (taken) taken->setParentNode(nullptr); - return taken; + if (from < 0 || count <= 0 || from + count > m_children.size()) return; + + emit willRemoveChildren(this, from, from + count - 1); + + QVector removed; + removed.reserve(count); + for (int i = 0; i < count; ++i) + { + removed.append(m_children.at(from)); + m_children.removeAt(from); + } + + for (LayerTreeNode* node : removed) + { + node->setParentNode(nullptr); + } + + emit removedChildren(this, from, from + count - 1); + + if (destroy) + { + qDeleteAll(removed); + } } diff --git a/HPPA/LayerTreeNode.h b/HPPA/LayerTreeNode.h index 1f0bb64..3385342 100644 --- a/HPPA/LayerTreeNode.h +++ b/HPPA/LayerTreeNode.h @@ -9,9 +9,10 @@ * LayerTreeNodeڵࣨ * - ͨԣ/ͼ/ɼ/ӹϵ * - Group / Layer ڵ̳ͨʵ + * - ṩ/ɾڵź֪ͨ * * ˵ - * - ͬʱάָ롱m_parentNode QObject parentѡ + * - ͬʱά"ָ"m_parentNode QObject parentѡ * - children ɽڵԼвͷţʱ delete children */ class LayerTreeNode : public QObject @@ -50,7 +51,32 @@ public: // ---- structure mutation (used by LayerTree / Model) ---- void appendChild(LayerTreeNode* child); void insertChild(int row, LayerTreeNode* child); - LayerTreeNode* takeChild(int row); // remove but not delete + + // QgsLayerTreeNode::removeChildrenPrivate Ľ + // from: ʼ, count: Ƴ, destroy: true delete Ƴڵ + void removeChild(int from, int count, bool destroy = true); + + // ---- static type helpers ---- + static inline bool isLayer(LayerTreeNode* node) + { + return node && node->type() == LayerTreeNode::Type::Layer; + } + + static inline bool isGroup(LayerTreeNode* node) + { + return node && node->type() == LayerTreeNode::Type::Group; + } + +signals: + // ڲӽڵ֮ǰ/֮󷢳 + void willAddChildren(LayerTreeNode* node, int indexFrom, int indexTo); + void addedChildren(LayerTreeNode* node, int indexFrom, int indexTo); + + // Ƴӽڵ֮ǰ/֮󷢳 + void willRemoveChildren(LayerTreeNode* node, int indexFrom, int indexTo); + void removedChildren(LayerTreeNode* node, int indexFrom, int indexTo); + + void nameChanged(LayerTreeNode* node, const QString& name); protected: void setParentNode(LayerTreeNode* p);