DiagramDesigner/diagramCavas/source/graphicsDataModel/diagramEditorModel.cpp

#include "graphicsDataModel/diagramEditorModel.h"
#include "basePropertyManager.h"
#include "baseProperty.h"
#include "powerEntity.h"
#include "graphicsItem/graphicsBaseItem.h"
#include "powerTerminal.h"
#include "graphicsItem/itemPort.h"
#include "topologyManager.h"
#include "baseModelItem/electricBaseModelSvgItem.h"
#include "dataBase.h"
#include "diagramEditor/editScene.h"
#include "baseModelItem/electricBaseModelPortItem.h"
#include "baseModelItem/electricBaseModelSvgBus.h"
#include "baseModelItem/electricBaseModelLineItem.h"

DiagramEditorModel::DiagramEditorModel()
    :_pCurBayRoute(nullptr)
    ,_pCurBayComponent(nullptr)
    ,_pCurPreviewScene(nullptr)
{

}

DiagramEditorModel::~DiagramEditorModel()
{

}

bool DiagramEditorModel::addTempPreviewItem(QUuid uuid,GraphicsBaseModelItem* pItem)
{
    if(_tempItem.contains(uuid))
        return false;
    else
    {
        _tempItem.insert(uuid,pItem);
        return true;
    }
}

DiagramEditorItemProperty* DiagramEditorModel::addTempPreviewData(QUuid id,int type,QString name,QString metaName,QString sBlock)
{
    DiagramEditorItemProperty* pData = BasePropertyManager::instance().findTempEditorData(id);       //已存在不不创建
    if(pData != nullptr)
        return pData;

    DiagramEditorItemProperty* itemData = new DiagramEditorItemProperty(this);

    if(itemData)
    {
        itemData->setUuid(id);
        itemData->setMetaModelName(metaName);
        itemData->setType(type);
        itemData->setTag(name);
        itemData->setName(name);
        if(!sBlock.isEmpty())
            itemData->setBlock(sBlock);
        BasePropertyManager::instance().insertTempEditorData(id,itemData);
    }
    return itemData;
}

void DiagramEditorModel::createTopoTerminalsByItem(GraphicsBaseItem* pItem,ModelFunctionType funType)
{
    PowerEntity* pEntity = pItem->entity();

    if(pEntity)
    {
        QMap<QString,ItemPort*> mapPorts = pItem->getPorts();     //创建实体port对应的拓扑port
        for(auto &port:mapPorts)
        {
            TerminalType terType;

            HandleType tpe = port->getType();
            switch (tpe) {
            case T_lineIn:
                terType = TerminalType::PowerInput;
                break;
            case T_lineOut:
                terType = TerminalType::PowerOutput;
                break;
            case T_lineInOut:
                terType = TerminalType::PowerConnect;
                break;
            default:
                break;
            }
            QPointF f = port->pos();
            TopologyManager::instance().createTerminal(pEntity->id(),terType,"",port->pos(),port->getId(),funType);
        }
    }
}

void DiagramEditorModel::generateTempBay()
{
    int rowCount = _pCurBayRoute->rowCount();
    for(int i = 0;i < rowCount;++i){
        QStandardItem *itemComps = _pCurBayRoute->item(i, 1);
        QString sComps = itemComps->text();
        QStringList lst = sComps.split(",");
        for(auto& name:lst){            //第一次循环生成item
            QStandardItem* pItem = getNameItem(name);
            if(pItem){
                QModelIndex index = pItem->index();
                QModelIndex indexCate = index.sibling(index.row(),0);
                QModelIndex indexType = index.sibling(index.row(),2);
                if(!pItem->data(Qt::UserRole+4).isValid()){     //未初始化，新建item
                    pItem->setData(1,Qt::UserRole+4);
                    int nCate = indexCate.data(Qt::UserRole+1).toInt();       //0设备1连接
                    int nType = indexType.data(Qt::UserRole+1).toInt();
                    int nDir = pItem->data().toInt();
                    int nRotate = 0;
                    if(pItem->data(Qt::UserRole+5).isValid())
                        nRotate = pItem->data(Qt::UserRole+5).toInt();
                    QPoint pos = pItem->data(Qt::UserRole+2).toPoint();
                    QUuid uid = pItem->data(Qt::UserRole+3).toUuid();
                    if(!_tempItem.contains(uid))
                        generateTempComponent(uid,name,nCate,nType,pos,nRotate);
                }
            }
        }

        if(lst.size() > 1){
            for(int i = 0;i < lst.size() -1;++i){
                QStandardItem* pItemFirst = getNameItem(lst[i]);
                QStandardItem* pItemSecond = getNameItem(lst[i+1]);

                if(pItemFirst && pItemSecond){
                    QUuid uid1 = pItemFirst->data(Qt::UserRole+3).toUuid();
                    QUuid uid2 = pItemSecond->data(Qt::UserRole+3).toUuid();

                    if(_tempItem.contains(uid1) && _tempItem.contains(uid2)){
                        GraphicsBaseModelItem* p1 = _tempItem.value(uid1);
                        GraphicsBaseModelItem* p2 = _tempItem.value(uid2);
                        auto pLineData = TopologyManager::instance().ifConnection(uid1.toString(),uid2.toString());     //判断两个item是否有连接
                        if(pLineData != nullptr){
                            if(!_tempItem.contains(QUuid(pLineData->id()))){        //connectdata已存在，item未绘制
                                auto pLine = generateTempLine(QUuid(pLineData->id()),"");   //重新绘制
                                if(pLine)
                                    establishConnection(p1,p2,pLine,ModelFunctionType::BaseModel);
                            }
                            else{      //已绘制，略过
                            }
                        }
                        else{       //connectdata不存在，新建
                            auto pLine = generateTempLine(QUuid::createUuid(),"");
                            if(pLine)
                                establishConnection(p1,p2,pLine,ModelFunctionType::BaseModel);
                        }
                    }
                }
            }
        }
    }
}

void DiagramEditorModel::generateTempComponent(QUuid uid,QString sName,int nCategory,int nType,QPoint pos,int nRotate)
{
    GraphicsBaseModelItem*  pItem = nullptr;
    if(nCategory == 0)
    {
        QByteArray byte;
        if(nType == 1){     //母线
            byte = DataBase::GetInstance()->ModelType()[nType].icon;
            auto pBus = new ElectricBaseModelSvgBus(QRect(-200, -3, 400, 6));
            pBus->loadSvg(byte);
            pItem = pBus;
            pItem->setItemType(GIT_baseBus);
        }
        else if(nType == 2){        //异步电动机
        }
        else if(nType == 3){        //断路器
            byte = DataBase::GetInstance()->ModelType()[nType].icon;            //注意modelType表与componentType表不一致！
            auto pBreaker = new ElectricBaseModelSvgItem(QRect(-15, -15, 30, 30));
            pBreaker->loadSvg(byte);
            pItem = pBreaker;
            pItem->setItemType(GIT_baseBreaker);
            pItem->initialPortsByDatabase(3);
        }
        else if(nType == 4){        //电缆
        }
        else if(nType == 5){        //电流互感器
            byte = DataBase::GetInstance()->ModelType()[nType].icon;            //注意modelType表与componentType表不一致！
            auto pBreaker = new ElectricBaseModelSvgItem(QRect(-10, -10, 20, 20));
            pBreaker->loadSvg(byte);
            pItem = pBreaker;
            pItem->setItemType(GIT_baseCT);
            pItem->initialPortsByDatabase(4);
        }
        else if(nType == 6){        //电压互感器
            byte = DataBase::GetInstance()->ModelType()[nType].icon;            //注意modelType表与componentType表不一致！
            auto pBreaker = new ElectricBaseModelSvgItem(QRect(-25, -25, 50, 50));
            pBreaker->loadSvg(byte);
            pItem = pBreaker;
            pItem->setItemType(GIT_basePT);
            pItem->initialPortsByDatabase(5);
        }
        else if(nType == 7){        //隔离开关
            byte = DataBase::GetInstance()->ModelType()[nType].icon;            //注意modelType表与componentType表不一致！
            auto pBreaker = new ElectricBaseModelSvgItem(QRect(-15, -15, 30, 30));
            pBreaker->loadSvg(byte);
            pItem = pBreaker;
            pItem->setItemType(GIT_baseDS);
            pItem->initialPortsByDatabase(9);
        }
        else if(nType == 8){        //接地开关
        }
        else if(nType == 9){        //快速接地开关
        }
        else if(nType == 10){       //双掷接地隔离开关
        }
        else if(nType == 11){       //带电指示器
        }
        else if(nType == 12){       //避雷器
        }
        else if(nType == 13){       //电缆出线套筒
        }
        else if(nType == 14){       //电缆端
        }
    }
    else if(nCategory == 1){
        if(nType == 1){     //节点
            pItem = new ElectricBaseModelPortItem();
            pItem->setItemType(GIT_baseNode);
        }
    }

    if(pItem){
        pItem->setItemId(uid);
        pItem->setRotation(nRotate);
        PowerEntity* pEntityData = TopologyManager::instance().createEntity(EntityType::Component,uid.toString(),sName,ModelFunctionType::BlockEditorModel);
        if(pEntityData)
            pItem->setEntity(pEntityData);
        DiagramEditorItemProperty* pData = nullptr;
        if(nCategory == 1){
           pData = addTempPreviewData(uid,0,sName,"node");
        }
        else if(nCategory == 0){        //设备
            pData = addTempPreviewData(uid,nType,sName,DataBase::GetInstance()->ModelType()[nType].modelType);
            pData->setGraphicsType(pItem->getItemType());
        }
        if(pData)
        {
            pItem->setProperty(pData);
            createTopoTerminalsByItem(pItem,ModelFunctionType::BlockEditorModel);
            pData->setDataChanged(true);        //数据状态改变
        }
        addTempPreviewItem(uid,pItem);
        _pCurPreviewScene->addItem(pItem);
        pItem->setPos(pos);
    }
}

ElectricBaseModelLineItem* DiagramEditorModel::generateTempLine(QUuid uid,QString sName)
{
    ElectricBaseModelLineItem* pLine = new ElectricBaseModelLineItem();
    pLine->setItemId(uid);
    pLine->setItemType(GIT_baseLine);
    DiagramEditorItemProperty* pData = addTempPreviewData(uid,8,sName,DataBase::GetInstance()->ModelType()[4].modelType);
    pData->setGraphicsType(GIT_baseLine);
    if(pData)
    {
        pLine->setProperty(pData);
        pData->setDataChanged(true);        //数据状态改变
    }
    addTempPreviewItem(uid,pLine);
    //establishConnection(pBreaker,pBus,pLine,ModelFunctionType::BaseModel);
    _pCurPreviewScene->addItem(pLine);
    return pLine;
}

void DiagramEditorModel::clearCurPreview()
{
    if(_pCurPreviewScene)
        _pCurPreviewScene->clear();
}

QStandardItem* DiagramEditorModel::getNameItem(const QString& sName)
{
    int nRowCount = _pCurBayComponent->rowCount();
    for(int i = 0;i < nRowCount;++i){
        QStandardItem *itemName = _pCurBayComponent->item(i, 1);
        if(sName == itemName->text()){
            return itemName;
        }
    }
    return nullptr;
}