如何在Qt中创建部分可编辑的树模型

#include <QAbstractItemModel>
#include <QObject>

class TreeItem : public QObject
{
    Q_OBJECT
public:
    explicit TreeItem(const QString& data, TreeItem* parent = nullptr)
        : QObject(parent), m_data(data), m_parent(parent)
    {}
    
    ~TreeItem()
    {
        qDeleteAll(m_children);
    }
    
    void appendChild(TreeItem* child)
    {
        m_children.append(child);
    }
    
    TreeItem* child(int row)
    {
        return m_children.value(row);
    }
    
    int childCount() const
    {
        return m_children.count();
    }
    
    int row() const
    {
        if (m_parent)
            return m_parent->m_children.indexOf(const_cast<TreeItem*>(this));
        
        return 0;
    }
    
    QVariant data() const
    {
        return m_data;
    }
    
private:
    QString m_data;
    TreeItem* m_parent;
    QList<TreeItem*> m_children;
};

class CustomTreeModel : public QAbstractItemModel
{
    Q_OBJECT
public:
    explicit CustomTreeModel(QObject* parent = nullptr)
        : QAbstractItemModel(parent)
    {
        // 创建根节点和子节点
        TreeItem* rootItem = new TreeItem("Root");
        TreeItem* childItem1 = new TreeItem("Child 1", rootItem);
        TreeItem* childItem2 = new TreeItem("Child 2", rootItem);
        TreeItem* grandchildItem1 = new TreeItem("Grandchild 1", childItem2);
        
        // 将子节点添加到根节点
        rootItem->appendChild(childItem1);
        rootItem->appendChild(childItem2);
        childItem2->appendChild(grandchildItem1);
        
        m_rootItem = rootItem;
    }
    
    ~CustomTreeModel()
    {
        delete m_rootItem;
    }
    
    QModelIndex index(int row, int column, const QModelIndex& parent) const override
    {
        if (!hasIndex(row, column, parent))
            return QModelIndex();
        
        TreeItem* parentItem = getItem(parent);
        TreeItem* childItem = parentItem->child(row);
        
        if (childItem)
            return createIndex(row, column, childItem);
        else
            return QModelIndex();
    }
    
    QModelIndex parent(const QModelIndex& index) const override
    {
        if (!index.isValid())
            return QModelIndex();
        
        TreeItem* childItem = getItem(index);
        TreeItem* parentItem = childItem->parent();
        
        if (parentItem == m_rootItem)
            return QModelIndex();
        
        return createIndex(parentItem->row(), 0, parentItem);
    }
    
    int rowCount(const QModelIndex& parent = QModelIndex()) const override
    {
        TreeItem* parentItem = getItem(parent);
        
        return parentItem->childCount();
    }
    
    int columnCount(const QModelIndex& parent = QModelIndex()) const override
    {
        Q_UNUSED(parent);
        
        return 1; // 此处只有一列，可以根据实际需要调整
    }
    
    QVariant data(const QModelIndex& index, int role) const override
    {
        if (!index.isValid())
            return QVariant();
        
        if (role != Qt::DisplayRole && role != Qt::EditRole)
            return QVariant();
        
        TreeItem* item = getItem(index);
        
        return item->data();
    }
    
    bool setData(const QModelIndex& index, const QVariant& value, int role) override
    {
        if (role != Qt::EditRole)
            return false;
        
        TreeItem* item = getItem(index);
        
        if (item->data() != value) {
            // 根据实际情况进行数据验证和更新
            
            // 更新数据
            item->setData(value);
            
            // 发送数据更新信号
            emit dataChanged(index, index, QVector<int>() << role);
            
            return true;
        }
        
        return false;
    }
    
    Qt::ItemFlags flags(const QModelIndex& index) const override
    {
        Qt::ItemFlags defaultFlags = QAbstractItemModel::flags(index);
        
        if (index.isValid())
            return defaultFlags | Qt::ItemIsEditable;
        
        return defaultFlags;
    }
    
private:
    TreeItem* getItem(const QModelIndex& index) const
    {
        if (index.isValid()) {
            TreeItem* item = static_cast<TreeItem*>(index.internalPointer());
            
            if (item)
                return item;
        }
        
        return m_rootItem;
    }
    
    TreeItem* m_rootItem;
};