DiagramDesigner/source/projectModelDlg.cpp

#include <QMessageBox>
#include <QJsonArray>
#include <QMenu>
#include <QTableWidgetItem>
#include "ui_projectModelDlg.h"
#include "projectModelDlg.h"
#include "dataBase.h"
#include "global.h"
#include "projectTableDelegate.h"
#include "projectModelManager.h"

projectModelDlg::projectModelDlg(QWidget *parent)
    : QDialog(parent)
    , ui(new Ui::projectModelDlg)
    ,_curRow(-1)
{
    ui->setupUi(this);
    this->setWindowFlags(Qt::FramelessWindowHint | windowFlags());
    setWindowModality(Qt::WindowModal);
    initialTypeMap();
    setupUI();
    initial();
}

projectModelDlg::~projectModelDlg()
{
    delete ui;
}

void projectModelDlg::initial()
{
    connect(ui->btn_save,&QPushButton::clicked,this,&projectModelDlg::onSaveClicked);
    connect(ui->btn_cancel,&QPushButton::clicked,this,&projectModelDlg::onCancelClicked);
    connect(ui->btn_apply,&QPushButton::clicked,this,&projectModelDlg::onApplyClicked);
    connect(ui->btn_revoke,&QPushButton::clicked,this,&projectModelDlg::onRevokeClicked);

    connect(ui->tableWidget_model, &QTableWidget::customContextMenuRequested, this, &projectModelDlg::onIndexRbtnClicked);

    connect(ui->btn_new, &QPushButton::clicked, this, &projectModelDlg::addPropertyGroup);
    connect(ui->tableWidget_model, &QTableWidget::itemClicked, this, &projectModelDlg::onTableItemClicked);
    initialModel();
    initialList();
    update();
}

void projectModelDlg::initialModel()
{
    ProjectModelManager::instance().initialModel();
}

void projectModelDlg::initialList()
{
    MapMeta::Iterator iter;
    for(iter = ProjectModelManager::instance().getData().begin();iter != ProjectModelManager::instance().getData().end();++iter)
    {
        MapProject proj = iter.value();
        MapProject::Iterator it;
        for(it = proj.begin();it != proj.end();++it)
        {
            int row = ui->tableWidget_model->rowCount();
            ui->tableWidget_model->insertRow(row);

            // 工程模列（可编辑）
            QTableWidgetItem* projectItem = new QTableWidgetItem(it.key());
            //projectItem->setFlags(projectItem->flags() | Qt::ItemIsEditable);
            ui->tableWidget_model->setItem(row, 0, projectItem);
            projectItem->setData(Qt::UserRole,TS_select);

            // 元模型列（初始化值）
            QTableWidgetItem* metaItem = new QTableWidgetItem(iter.key());
            ui->tableWidget_model->setItem(row, 1, metaItem);

            // 元件类型列（初始提示）
            QString strType = _mapType.key(it->nType);
            QTableWidgetItem* typeItem = new QTableWidgetItem(strType);
            ui->tableWidget_model->setItem(row, 2, typeItem);
        }
    }

}

/*void projectModelDlg::update()
{
    for(MapMeta::Iterator iter = m_mapTotal.begin();iter != m_mapTotal.end();++iter)
    {
        ui->cb_baseModel->addItem(iter.key());
    }
}*/


void projectModelDlg::onSaveClicked()
{
    if(_curProject.isEmpty())
    {
        QMessageBox::information(NULL, QString::fromWCharArray(L"提示"), QString::fromWCharArray(L"请选择操作的模型"));
    }
    else
    {
        if(ProjectModelManager::instance().getData()[_curMeta][_curProject].nType == 0)
        {
            QMessageBox::information(NULL, QString::fromWCharArray(L"提示"), QString::fromWCharArray(L"请选择工程模类型"));
            return;
        }
        projectState state = couldSave();
        if(state == NotExist)       //目前名称工程模不存在
        {
            PropertyModel proModel = ProjectModelManager::instance().getData()[_curMeta][_curProject];
            if(proModel.formerProject.bChanged)     //工程模改过名
            {
                if(proModel.formerMeta.bChanged)    //元模改过类型
                {
                    QStringList lst = DataBase::GetInstance()->ifModelOccupy(proModel.formerProject.sName);
                    if(!lst.isEmpty()){          //工程模被占用
                        QMessageBox msgBox;
                        msgBox.setText(QString::fromWCharArray(L"工程模将被修改"));
                        QString info = QString::fromWCharArray(L"该工程模已被元件%1使用,是否继续修改?");        //todo:修改工程模后相关处理
                        msgBox.setInformativeText(info);
                        msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::Cancel);
                        msgBox.setDefaultButton(QMessageBox::Cancel);
                        int ret = msgBox.exec();
                        switch (ret) {
                        case QMessageBox::Yes:
                        {
                            bool val = DataBase::GetInstance()->deleteProjectModel(proModel.formerProject.sName);       //删除旧工程模，生成新工程模
                            if(val)
                            {
                                ProjectModelManager::instance().generate(_curMeta,_curProject);
                                setTableItemState(_curRow,TS_select);
                            }
                            break;
                        }
                        case QMessageBox::Cancel:
                            // Cancel was clicked
                            break;
                        default:
                            // should never be reached
                            break;
                        }
                    }
                    else{       //工程模未被使用
                        bool val = DataBase::GetInstance()->deleteProjectModel(proModel.formerProject.sName);       //删除旧工程模，生成新工程模
                        if(val)
                        {
                            ProjectModelManager::instance().generate(_curMeta,_curProject);
                            setTableItemState(_curRow,TS_select);
                        }
                    }
                }
                else    //元模未改类型
                {
                    QMap<QString,QJsonObject> map = DataBase::GetInstance()->getCheckStateFromManager(proModel.formerProject.sName);
                    bool val = ProjectModelManager::instance().ifProjectEqual(_curMeta,_curProject,map);

                    QStringList lst = DataBase::GetInstance()->ifModelOccupy(proModel.formerProject.sName);
                    if(!lst.isEmpty()){          //工程模被使用
                        QMessageBox msgBox;
                        msgBox.setText(QString::fromWCharArray(L"工程模将被修改"));
                        QString info = QString::fromWCharArray(L"该工程模已被元件%1使用,是否继续修改?");        //todo:修改工程模后相关处理
                        msgBox.setInformativeText(info);
                        msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::Cancel);
                        msgBox.setDefaultButton(QMessageBox::Cancel);
                        int ret = msgBox.exec();
                        switch (ret) {
                        case QMessageBox::Yes:
                        {
                            if(val)     //旧工程模和新工程模数据相同，改名
                            {
                                ProjectModelManager::instance().renameProjectModel(_curProject,proModel.dataInfo);
                                ProjectModelManager::instance().updateComponentModelName(proModel.formerProject.sName,_curProject);         //修改component中的模型名
                                setTableItemState(_curRow,TS_select);
                            }
                            else        //不同，先改工程模名称，后修改数据
                            {
                                ProjectModelManager::instance().renameProjectModel(_curProject,proModel.dataInfo);
                                ProjectModelManager::instance().updateComponentModelName(proModel.formerProject.sName,_curProject);          //修改component中的模型名
                                QString sRes = ProjectModelManager::instance().modifyProjectModel(_curMeta,_curProject,map);
                                if(!sRes.isEmpty())
                                {
                                    QMessageBox::information(NULL, QString::fromWCharArray(L"提示"), QString::fromWCharArray(L"修改模型成功"));
                                    setTableItemState(_curRow,TS_select);
                                    emit ProjectModelManager::instance().modelChange();
                                }
                                else
                                {
                                    QMessageBox::information(NULL, QString::fromWCharArray(L"提示"), QString::fromWCharArray(L"修改模型失败"));
                                }
                            }
                            break;
                        }
                        case QMessageBox::Cancel:
                            // Cancel was clicked
                            break;
                        default:
                            // should never be reached
                            break;
                        }
                    }
                    else        //工程模未被使用
                    {
                        if(val)     //旧工程模和新工程模数据相同，改名
                        {
                            ProjectModelManager::instance().renameProjectModel(_curProject,proModel.dataInfo);
                            setTableItemState(_curRow,TS_select);
                        }
                        else        //不同，先改工程模名称，后修改数据
                        {
                            ProjectModelManager::instance().renameProjectModel(_curProject,proModel.dataInfo);
                            QString sRes = ProjectModelManager::instance().modifyProjectModel(_curMeta,_curProject,map);
                            if(!sRes.isEmpty())
                            {
                                QMessageBox::information(NULL, QString::fromWCharArray(L"提示"), QString::fromWCharArray(L"修改模型成功"));
                                setTableItemState(_curRow,TS_select);
                                emit ProjectModelManager::instance().modelChange();
                            }
                            else
                            {
                                QMessageBox::information(NULL, QString::fromWCharArray(L"提示"), QString::fromWCharArray(L"修改模型失败"));
                            }
                        }
                    }
                }
            }
            else        //新建
            {
                ProjectModelManager::instance().generate(_curMeta,_curProject);
                setTableItemState(_curRow,TS_select);
            }
        }
        else if(state == Exist)
        {
            QMessageBox::information(NULL, QString::fromWCharArray(L"提示"), QString::fromWCharArray(L"该模型已经存在"));
        }
        else if(state == Changed)
        {
            QMessageBox msgBox;
            msgBox.setText(QString::fromWCharArray(L"提示"));
            msgBox.setInformativeText(QString::fromWCharArray(L"该模型已存在且与同名模型不一致，是否替换库模型？"));
            msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::Cancel);
            msgBox.setDefaultButton(QMessageBox::Cancel);
            int ret = msgBox.exec();
            if(ret == QMessageBox::Yes)
            {
                PropertyModel proModel = ProjectModelManager::instance().getData()[_curMeta][_curProject];
                if(proModel.formerMeta.bChanged)            //判断元模是否改变,元模变了删除旧工程模，添加新工程模
                {
                    bool val = DataBase::GetInstance()->deleteProjectModel(proModel.formerProject.sName);
                    if(val)
                    {
                        ProjectModelManager::instance().generate(_curMeta,_curProject);
                        setTableItemState(_curRow,TS_select);
                    }
                }
                else        //元模未变直接修改
                {
                    QMap<QString,QJsonObject> mapCheckState = DataBase::GetInstance()->getCheckStateFromManager(_curProject);      //获取选择状态
                    QString sRes = ProjectModelManager::instance().modifyProjectModel(_curMeta,_curProject,mapCheckState);
                    if(!sRes.isEmpty())
                    {
                        QMessageBox::information(NULL, QString::fromWCharArray(L"提示"), QString::fromWCharArray(L"修改模型成功"));
                        setTableItemState(_curRow,TS_select);
                    }
                    else
                    {
                        QMessageBox::information(NULL, QString::fromWCharArray(L"提示"), QString::fromWCharArray(L"修改模型失败"));
                    }
                }
            }
            else if(ret == QMessageBox::Cancel)
            {

            }
        }
    }
}


void projectModelDlg::onCancelClicked()
{
    hide();
}

void projectModelDlg::onApplyClicked()
{
    MapMeta::Iterator iter = ProjectModelManager::instance().getData().find(_curMeta);
    if(iter != ProjectModelManager::instance().getData().end())
    {
        MapProject project = iter.value();
        MapProject::Iterator it= project.find(_curProject);
        if(it != project.end())
        {
            MapProperty property = it.value().mapProperty;
            QModelIndex selected = ui->treeView_base->currentIndex();
            QStandardItem* pItem = it->pBase->itemFromIndex(selected);

            if(pItem)
            {
                int nLevel = getLevel(pItem);
                if(nLevel != 1)     //不是二级节点就返回
                    return;
                else{
                    QString strGroup = pItem->parent()->text();
                    //QStandardItem* item = it->pBase->takeItem(selected.row());
                    QStandardItem *parentItem = pItem->parent();
                    if (parentItem) {
                        parentItem->takeRow(pItem->row());
                    }

                    QList<QStandardItem*> groupItem = it->pSelect->findItems(strGroup);
                    if(groupItem.isEmpty())         //已选对象中是否存在该组，没有则添加
                    {
                        QStandardItem* pGroup = new QStandardItem(strGroup);
                        it->pSelect->appendRow(pGroup);
                        pGroup->appendRow(pItem);
                    }
                    else{
                        QStandardItem* pGroup = groupItem[0];
                        pGroup->appendRow(pItem);
                    }

                    //it->pBase->removeRow(selected.row());

                    ProjectModelManager::instance().getData()[_curMeta][_curProject].mapProperty[strGroup].mCheckState[pItem->text()].checkState = true;           //选择状态设为1
                }
            }
        }
    }

    ui->treeView_sub->expandAll();
}

void projectModelDlg::onRevokeClicked()
{
    QStringList lstPub = ProjectModelManager::instance().getPublicGroupList();
    MapMeta::Iterator iter = ProjectModelManager::instance().getData().find(_curMeta);
    if(iter != ProjectModelManager::instance().getData().end())
    {
        MapProject project = iter.value();
        MapProject::Iterator it= project.find(_curProject);
        if(it != project.end())
        {
            MapProperty property = it.value().mapProperty;
            QModelIndex selected = ui->treeView_sub->currentIndex();
            QStandardItem* pItem = it->pSelect->itemFromIndex(selected);

            if(pItem)
            {
                if(lstPub.contains(pItem->parent()->text())){
                    QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"公共属性无法编辑"));
                    return;
                }
                int nLevel = getLevel(pItem);
                if(nLevel != 1)     //不是二级节点就返回
                    return;
                else{
                    QString strGroup = pItem->parent()->text();
                    //QStandardItem* item = it->pBase->takeItem(selected.row());
                    QStandardItem *parentItem = pItem->parent();
                    if (parentItem) {
                        parentItem->takeRow(pItem->row());
                        if(!parentItem->hasChildren()){
                            it->pSelect->takeRow(parentItem->row());
                        }
                    }

                    QList<QStandardItem*> groupItem = it->pBase->findItems(strGroup);
                    if(groupItem.isEmpty())         //已选对象中是否存在该组，没有则添加
                    {
                        QStandardItem* pGroup = new QStandardItem(strGroup);
                        it->pBase->appendRow(pGroup);
                        pGroup->appendRow(pItem);
                    }
                    else{
                        QStandardItem* pGroup = groupItem[0];
                        pGroup->appendRow(pItem);
                    }

                    //it->pSelect->removeRow(selected.row());

                    ProjectModelManager::instance().getData()[_curMeta][_curProject].mapProperty[strGroup].mCheckState[pItem->text()].checkState = false;           //选择状态设为1
                }
            }
        }
    }

    ui->treeView_base->expandAll();
}


void projectModelDlg::onIndexRbtnClicked(const QPoint &pos)
{
    // 获取当前点击的位置对应的索引
    QModelIndex index = ui->tableWidget_model->indexAt(pos);
    if (!index.isValid()) {
        return; // 如果点击的是空白区域，直接返回
    }

    // 如果是第二级节点，创建右键菜单
    QMenu menu;
    QAction *deleteAction = new QAction("删除模型", this);
    menu.addAction(deleteAction);

    // 连接删除菜单项的触发信号与槽函数
    connect(deleteAction, &QAction::triggered, this, &projectModelDlg::onDeleteProjectClicked);

    // 在点击位置显示菜单
    menu.exec(ui->tableWidget_model->mapToGlobal(pos));
}

void projectModelDlg::onDeleteProjectClicked()
{
    // 获取当前选中的索引
    QModelIndexList selectedIndexes = ui->tableWidget_model->selectionModel()->selectedRows();
    if (selectedIndexes.isEmpty()) {
        return; // 没有选中任何行
    }

    // 获取当前选中的第一项索引
    QModelIndex index = selectedIndexes.first();

    // 确保索引有效
    if (!index.isValid()) {
        return;
    }

    int currentRow = ui->tableWidget_model->currentRow();
    if (currentRow == -1) {
        return;  // 没有选中行
    }
    QString strProj = ui->tableWidget_model->item(currentRow, 0)->text();
    QString strMeta = ui->tableWidget_model->item(currentRow, 1)->text();

    _curProject = strProj;
    _curMeta = strMeta;

    // 删除当前选中的项

    QStringList lst = DataBase::GetInstance()->ifModelOccupy(_curProject);
    QString info = QString::fromWCharArray(L"删除后不可恢复,是否删除？");
    if(!lst.empty())        //非空，被占用
    {
        info = QString::fromWCharArray(L"工程模被%1元件使用中,是否继续删除？").arg(lst.join(","));
    }
    QMessageBox msgBox;
    msgBox.setText(QString::fromWCharArray(L"工程模将被删除"));
    msgBox.setInformativeText(info);
    msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::Cancel);
    msgBox.setDefaultButton(QMessageBox::Cancel);
    int ret = msgBox.exec();
    switch (ret) {
    case QMessageBox::Yes:
    {
        int role = index.data(Qt::UserRole).toInt();
        if(role != TS_create)       //create状态的数据未创建数据库
        {
            bool val = DataBase::GetInstance()->deleteProjectModel(_curProject);
        }

        removeProjectData(_curMeta,_curProject,role);

        ui->tableWidget_model->removeRow(currentRow);
        _curMeta = "";
        _curProject = "";
        //QMessageBox::information(NULL, QString::fromWCharArray(L"提示"), QString::fromWCharArray(L"删除失败"));
        break;
    }
    case QMessageBox::Cancel:
        // Cancel was clicked
        break;
    default:
        // should never be reached
        break;
    }
}

void projectModelDlg::addPropertyGroup()
{
    int state = getModelEditState();
    if(state & TS_create)
    {
        QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"请先完成编辑"));
        return;
    }
    int row = ui->tableWidget_model->rowCount();
    ui->tableWidget_model->insertRow(row);

    // 工程模列（可编辑）
    QTableWidgetItem* projectItem = new QTableWidgetItem("未命名");
    //projectItem->setFlags(projectItem->flags() | Qt::ItemIsEditable);
    ui->tableWidget_model->setItem(row, 0, projectItem);
    projectItem->setData(Qt::UserRole,TS_create);

    // 元模型列（初始化值）
    QTableWidgetItem* metaItem = new QTableWidgetItem("未关联");
    ui->tableWidget_model->setItem(row, 1, metaItem);

    // 元件类型列（初始提示）
    QTableWidgetItem* typeItem = new QTableWidgetItem("未选择");
    ui->tableWidget_model->setItem(row, 2, typeItem);

    ui->tableWidget_model->selectRow(row);

    PropertyModel pm;
    pm.pBase = new QStandardItemModel(this);
    pm.pSelect = new QStandardItemModel(this);
    _curModel = pm;
}

void projectModelDlg::onTableItemClicked(QTableWidgetItem *item)
{
    // 获取选中行的索引
    int row = item->row();
    _curRow = row;
    QString strProj = ui->tableWidget_model->item(row, 0)->text();
    QString strMeta = ui->tableWidget_model->item(row, 1)->text();

    QTableWidgetItem *firstColumnItem = ui->tableWidget_model->item(row,0);
    if(firstColumnItem)
    {
        TableItemState state = TableItemState(firstColumnItem->data(Qt::UserRole).toInt());
        if(state == TS_create)
        {
            int col = item->column();
            if(col == TD_ProjectModel)                //工程模输入框，不做特殊处理
            {
                if(strProj != "未命名")
                {
                    _curProject = strProj;
                }
                if(strMeta != "未选择")
                {
                    _curMeta = strMeta;
                }
                return;
            }
            else if(col == TD_MetaModel)            //元模选择
            {
                if(strProj == "未命名")
                {
                    QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"工程模未命名"));
                    return;
                }
                else
                {
                    _curProject = strProj;
                }
                if(strMeta != "未选择")
                {
                    QString sMeta = ui->tableWidget_model->item(row, 1)->data(Qt::EditRole+1).toString();
                    _curMeta = sMeta;
                }
            }
            else if(col == TD_ComponentType)            //类型选择
            {
                if(strMeta == "未选择")
                {
                    QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"元模未选择"));
                    return;
                }
            }
        }
        else if(state == TS_select)
        {
            /*if(_curProject == strProj)      //点击当前的返回
            {
                return;
            }*/
            ui->treeView_base->setModel(nullptr);
            ui->treeView_sub->setModel(nullptr);

            MapMeta::Iterator it;
            for(it = ProjectModelManager::instance().getData().begin();it != ProjectModelManager::instance().getData().end();++it)
            {
                MapProject proj = it.value();
                MapProject::Iterator iter;
                for(iter = proj.begin();iter != proj.end();++iter)
                {
                    if(iter.key() == strProj)
                    {
                        ui->treeView_base->setModel(iter->pBase);
                        ui->treeView_sub->setModel(iter->pSelect);
                        ui->treeView_base->expandAll();
                        ui->treeView_sub->expandAll();
                        _curMeta = it.key();
                        _curProject = strProj;
                        return;
                    }
                }
            }
        }
        else if(state == TS_edit)
        {
            /*if(_curProject == strProj)      //点击当前的返回
            {
                return;
            }*/
            ui->treeView_base->setModel(nullptr);
            ui->treeView_sub->setModel(nullptr);

            MapMeta::Iterator it;
            for(it = ProjectModelManager::instance().getData().begin();it != ProjectModelManager::instance().getData().end();++it)
            {
                MapProject proj = it.value();
                MapProject::Iterator iter;
                for(iter = proj.begin();iter != proj.end();++iter)
                {
                    if(iter.key() == strProj)
                    {
                        ui->treeView_base->setModel(iter->pBase);
                        ui->treeView_sub->setModel(iter->pSelect);
                        ui->treeView_base->expandAll();
                        ui->treeView_sub->expandAll();
                        _curMeta = it.key();
                        _curProject = strProj;
                        return;
                    }
                }
            }
        }
    }
}

void projectModelDlg::onDelegateFinishEdit(const QModelIndex &index, const QString &value)
{
    int row = index.row();
    QTableWidgetItem *firstColumnItem = ui->tableWidget_model->item(row, 0);
    if(firstColumnItem)
    {
        TableItemState state = TableItemState(firstColumnItem->data(Qt::UserRole).toInt());
        if(state == TS_create)
        {
            int col = index.column();
            if(col == TD_ProjectModel)
            {
                if(ProjectModelManager::instance().ifProjectExsit(value))
                {
                    QMessageBox::information(NULL, QString::fromWCharArray(L"提示"), QString::fromWCharArray(L"模型名已存在"));
                    QTableWidgetItem* pItem = ui->tableWidget_model->item(index.row(),index.column());
                    if(pItem)
                        pItem->setText(QString::fromWCharArray(L"未命名"));
                    return;
                }
                if(ProjectModelManager::instance().getData().contains(_curMeta))       //判断元模存在
                {
                    if(ProjectModelManager::instance().getData()[_curMeta].contains(_curProject))      //已经存在
                    {
                        if(_curProject == value)        //工程模名称未变
                            return;
                        else{               //工程模名称变化，更新存储
                            PropertyModel proModel = ProjectModelManager::instance().getData()[_curMeta].take(_curProject);
                            ProjectModelManager::instance().getData()[_curMeta].insert(value,proModel);
                            _curProject = value;
                        }
                    }
                    else{       //新建
                        _curProject = value;
                    }
                }
                else
                {
                    _curProject = value;
                }
            }
            else if(col == TD_MetaModel)
            {
                if(ProjectModelManager::instance().getData().contains(_curMeta))       //判断元模存在
                {
                    if(ProjectModelManager::instance().getData()[_curMeta].contains(_curProject))      //工程模已经存在
                    {
                        if(_curMeta == value)        //选择相同元模
                            return;
                        else{                           //元模变化，删除旧model
                            PropertyModel proModel = ProjectModelManager::instance().getData()[_curMeta].take(_curProject);        //从结构中取出
                            ui->treeView_base->setModel(nullptr);
                            ui->treeView_sub->setModel(nullptr);
                            delete proModel.pBase;                  //置空旧model
                            delete proModel.pSelect;
                            proModel.pBase = new QStandardItemModel(this);
                            proModel.pSelect = new QStandardItemModel(this);
                            proModel.mapProperty = ProjectModelManager::instance().addNewProject(value,_curProject,proModel);      //挂接新元模数据
                            ProjectModelManager::instance().getData()[value].insert(_curProject,proModel);             //插入到新位置
                            ui->treeView_base->setModel(proModel.pBase);
                            ui->treeView_sub->setModel(proModel.pSelect);
                            ui->treeView_base->expandAll();
                            ui->treeView_sub->expandAll();
                            _curMeta = value;
                        }
                    }
                    else        //新建
                    {
                        _curModel.mapProperty = ProjectModelManager::instance().addNewProject(value,_curProject,_curModel);     //新建(不添加到队列
                        ProjectModelManager::instance().getData()[value].insert(_curProject,_curModel);     //添加

                        ui->treeView_base->setModel(nullptr);
                        ui->treeView_sub->setModel(nullptr);
                        ui->treeView_base->setModel(_curModel.pBase);
                        ui->treeView_sub->setModel(_curModel.pSelect);
                        ui->treeView_base->expandAll();
                        ui->treeView_sub->expandAll();
                        _curMeta = value;
                    }
                }
                else
                {
                    _curModel.mapProperty = ProjectModelManager::instance().addNewProject(value,_curProject,_curModel);
                    ProjectModelManager::instance().getData()[value].insert(_curProject,_curModel);

                    ui->treeView_base->setModel(nullptr);
                    ui->treeView_sub->setModel(nullptr);
                    ui->treeView_base->setModel(_curModel.pBase);
                    ui->treeView_sub->setModel(_curModel.pSelect);
                    ui->treeView_base->expandAll();
                    ui->treeView_sub->expandAll();
                    _curMeta = value;
                }
            }
            else if(col == TD_ComponentType)
            {
                ProjectModelManager::instance().getData()[_curMeta][_curProject].nType = _mapType.value(value);
                firstColumnItem->setData(Qt::UserRole,TS_edit);
            }
        }
        else if(state == TS_select || state == TS_edit)
        {
            int col = index.column();
            if(col == TD_ProjectModel)
            {
                if(ProjectModelManager::instance().getData()[_curMeta].contains(_curProject))      //已经存在
                {
                    if(_curProject == value)        //工程模名称未变
                        return;
                    else{               //工程模名称变化，更新存储
                        PropertyModel proModel = ProjectModelManager::instance().getData()[_curMeta].take(_curProject);
                        if(!proModel.formerProject.sName.isEmpty())     //曾用工程模名不为空
                            proModel.formerProject.bChanged = true;
                        ProjectModelManager::instance().getData()[_curMeta].insert(value,proModel);
                        _curProject = value;
                        firstColumnItem->setData(Qt::UserRole,TS_edit);
                    }
                }
            }
            else if(col == TD_MetaModel)
            {
                if(ProjectModelManager::instance().getData()[_curMeta].contains(_curProject))      //已经存在
                {
                    if(_curMeta == value)        //选择相同元模
                        return;
                    else{                           //元模变化，删除旧model
                        PropertyModel proModel = ProjectModelManager::instance().getData()[_curMeta].take(_curProject);        //从结构中取出
                        if(!proModel.formerMeta.sName.isEmpty())        //曾用元模名不为空
                            proModel.formerMeta.bChanged = true;
                        ui->treeView_base->setModel(nullptr);
                        ui->treeView_sub->setModel(nullptr);
                        delete proModel.pBase;                  //置空旧model
                        delete proModel.pSelect;
                        proModel.pBase = new QStandardItemModel(this);
                        proModel.pSelect = new QStandardItemModel(this);
                        proModel.mapProperty = ProjectModelManager::instance().addNewProject(value,_curProject,proModel);      //挂接新元模数据
                        ProjectModelManager::instance().getData()[value].insert(_curProject,proModel);             //插入到新位置
                        ui->treeView_base->setModel(proModel.pBase);
                        ui->treeView_sub->setModel(proModel.pSelect);
                        ui->treeView_base->expandAll();
                        ui->treeView_sub->expandAll();
                        _curMeta = value;
                        firstColumnItem->setData(Qt::UserRole,TS_edit);
                    }
                }
            }
            else if(col == TD_ComponentType)
            {
                ProjectModelManager::instance().getData()[_curMeta][_curProject].nType = _mapType.value(value);
                firstColumnItem->setData(Qt::UserRole,TS_edit);
            }
        }
    }
}

QString projectModelDlg::getProjectName() const
{
    return _curProject;
}

QString projectModelDlg::getMetaName() const
{
    return _curMeta;
}

//=============================================================================

void projectModelDlg::removeProjectData(const QString& sMeta,const QString& sProject,int role)
{
    if(role == TS_create && !ProjectModelManager::instance().getData().contains(sMeta)){   //创建且未加入到管理
        delete _curModel.pBase;
        delete _curModel.pSelect;
    }
    else{
        ProjectModelManager::instance().deleteData(sMeta,sProject);
    }
}

void projectModelDlg::setupUI()
{
    QStringList headerText;
    headerText<<"工程模"<<"元模型"<<"元件类型";
    ui->tableWidget_model->setContextMenuPolicy(Qt::CustomContextMenu);
    ui->tableWidget_model->setSelectionMode(QAbstractItemView::SingleSelection);
    ui->tableWidget_model->setSelectionBehavior(QAbstractItemView::SelectRows);
    ui->tableWidget_model->setColumnCount(headerText.count());
    ui->tableWidget_model->setHorizontalHeaderLabels(headerText);
    ui->tableWidget_model->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);

    // 设置列代理
    ProjectTableDelegate* delegate = new ProjectTableDelegate(this);
    ui->tableWidget_model->setItemDelegate(delegate);

    connect(delegate,&ProjectTableDelegate::editingFinished,this,&projectModelDlg::onDelegateFinishEdit);
}

void projectModelDlg::initialTypeMap()
{
    _mapType.insert(QString::fromWCharArray(L"断路器"),1);
    _mapType.insert(QString::fromWCharArray(L"母线"),2);
    _mapType.insert(QString::fromWCharArray(L"异步电动机"),3);
}


projectState projectModelDlg::couldSave()
{
    QMap<QString,QJsonObject> map = DataBase::GetInstance()->getCheckStateFromManager(_curProject);
    if(map.isEmpty())
    {
        return NotExist;
    }
    else
    {
        bool val = ProjectModelManager::instance().ifProjectEqual(_curMeta,_curProject,map);
        if(val){
            return Exist;
        }
        else{
            return Changed;
        }
    }
}

void projectModelDlg::setTableItemState(int row,TableItemState state)
{
    QTableWidgetItem *item = ui->tableWidget_model->item(row, 0);
    if(item)
    {
        item->setData(Qt::UserRole,state);
    }
}

int projectModelDlg::getModelEditState()
{
    int res = 0;
    int totalRows = ui->tableWidget_model->rowCount();

    // 遍历每一行
    for (int row = 0; row < totalRows; ++row) {
        // 获取当前行第一列（列索引 0）的 QTableWidgetItem
        QTableWidgetItem *item = ui->tableWidget_model->item(row, 0);

        // 检查项是否存在
        if (item != nullptr) {
            int role = item->data(Qt::UserRole).toInt();
            res |= role;
        }
    }
    return res;
}