2631 lines
102 KiB
C++
2631 lines
102 KiB
C++
#include "graphicsDataModel/fixedPortsModel.h"
|
||
#include "graphicsItem/graphicsBaseItem.h"
|
||
#include "graphicsItem/electricSvgItemBus.h"
|
||
#include "graphicsItem/electricSvgItemRect.h"
|
||
#include "graphicsItem/electricConnectLineItem.h"
|
||
#include "graphicsItem/electricPortItem.h"
|
||
#include "graphicsItem/electricSvgGroupCT.h"
|
||
#include "graphicsItem/electricSvgGroupPT.h"
|
||
#include "graphicsItem/electricSvgItemDS.h"
|
||
#include "graphicsItem/electricSvgItemES.h"
|
||
#include "graphicsItem/electricSvgItemFES.h"
|
||
#include "graphicsItem/electricSvgItemDTEDS.h"
|
||
#include "graphicsItem/electricSvgItemPI.h"
|
||
#include "graphicsItem/electricSvgItemLA.h"
|
||
#include "graphicsItem/electricSvgItemCableTer.h"
|
||
#include "graphicsItem/electricSvgItemCableEnd.h"
|
||
#include "graphicsItem/electricSvgItem2wTransformer.h"
|
||
#include "graphicsItem/electricSvgItem3wTransformer.h"
|
||
#include "baseModelItem/electricBaseModelLineItem.h"
|
||
#include "baseModelItem/electricBaseModelSvgItem.h"
|
||
#include "baseModelItem/electricBaseModelSvgBus.h"
|
||
#include "baseModelItem/electricBaseModelLineItem.h"
|
||
#include "graphicsItem/electricBayItem.h"
|
||
#include "diagramEditor/diagramEditorBaseBlock.h"
|
||
#include "graphicsItem/electricBayItem.h"
|
||
#include "diagramEditor/editItems.h"
|
||
#include "graphicsItem/itemPort.h"
|
||
#include "designerScene.h"
|
||
#include "dataBase.h"
|
||
#include "httpInterface.h"
|
||
#include "drawingPanel.h"
|
||
#include "itemPropertyDlg.h"
|
||
#include "dataManager.h"
|
||
#include "powerEntity.h"
|
||
#include "topologyManager.h"
|
||
#include "basePropertyManager.h"
|
||
#include "diagramCavas.h"
|
||
#include <QJsonArray>
|
||
#include <QMessageBox>
|
||
#include <QRandomGenerator>
|
||
#include <QJsonDocument>
|
||
#include <QMdiSubWindow>
|
||
#include "baseProperty.h"
|
||
#include "projectModelSetting.h"
|
||
#include "bayManagerDlg.h"
|
||
#include "projectModelManager.h"
|
||
#include "projectIconSetting.h"
|
||
#include "monitorPanel.h"
|
||
#include "designerView.h"
|
||
#include "global.h"
|
||
|
||
bool FixedPortsModel::_dataInitialised = false;
|
||
|
||
FixedPortsModel::FixedPortsModel(PowerEntity* pEntity)
|
||
:_scene(nullptr)
|
||
,_widget(nullptr)
|
||
,_Interface(nullptr)
|
||
,_pEntity(pEntity)
|
||
,m_proModelSettingDlg(nullptr)
|
||
,m_projectIconSettingDlg(nullptr)
|
||
,m_pBayManager(nullptr)
|
||
{
|
||
_cavas = nullptr;
|
||
loadNodeDataFromDataBase();
|
||
_Interface = new HttpInterface(this);
|
||
_timer = new QTimer(this);
|
||
|
||
_modelStateInfo = DataManager::instance().modelState();
|
||
_modelDataInfo = DataManager::instance().modelData();
|
||
initialPropertyDlg();
|
||
connect(_timer,SIGNAL(timeout()),this,SLOT(onTimeOut()));
|
||
connect(_Interface,&HttpInterface::sendPointData,this,&FixedPortsModel::onSignal_GetPointData);
|
||
}
|
||
|
||
FixedPortsModel::~FixedPortsModel()
|
||
{
|
||
|
||
}
|
||
|
||
QMap<QUuid,itemPageInfo> FixedPortsModel::allNodePos() const
|
||
{
|
||
QMap<QUuid,itemPageInfo> map;
|
||
for(auto pItem:_nodeItem)
|
||
{
|
||
if(pItem->getItemType() != GIT_link){
|
||
itemPageInfo info;
|
||
double dWidth = pItem->boundingRect().width();
|
||
double dHeight = pItem->boundingRect().height();
|
||
info.pos = pItem->scenePos()/*+QPointF(dWidth*0.5,dHeight*0.5)*/;
|
||
info.dWidth = dWidth;
|
||
info.dHeight = dHeight;
|
||
info.dRotate = pItem->rotation();
|
||
map.insert(pItem->itemId(),info);
|
||
}
|
||
}
|
||
return map;
|
||
}
|
||
|
||
QVector<ModelProperty*> FixedPortsModel::allConnectionProperty()
|
||
{
|
||
QVector<ModelProperty*> vec;
|
||
for(auto pItem:_nodeItem)
|
||
{
|
||
if(pItem->getItemType() == GIT_link)
|
||
{
|
||
auto pLine = dynamic_cast<ElectricConnectLineItem*>(pItem);
|
||
if(pLine)
|
||
{
|
||
ModelProperty* pPro = pLine->getProperty();
|
||
if(pPro){
|
||
vec.push_back(pPro);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return vec;
|
||
}
|
||
|
||
QMap<QUuid,GraphicsProjectModelItem*>& FixedPortsModel::allItems()
|
||
{
|
||
return _nodeItem;
|
||
}
|
||
|
||
GraphicsProjectModelItem* FixedPortsModel::nodeItem(QUuid uuid)
|
||
{
|
||
return _nodeItem.value(uuid,nullptr);
|
||
}
|
||
|
||
bool FixedPortsModel::addNodeItem(QUuid uuid,GraphicsProjectModelItem* pItem)
|
||
{
|
||
|
||
if(_nodeItem.contains(uuid))
|
||
return false;
|
||
else
|
||
{
|
||
_nodeItem.insert(uuid,pItem);
|
||
connect(pItem,&GraphicsProjectModelItem::ifExist,this,&FixedPortsModel::onSignal_ifExits);
|
||
return true;
|
||
}
|
||
}
|
||
|
||
QString FixedPortsModel::addNodeItem(QUuid id/*,int type*/,QPointF pos,double width,double height,double rotate)
|
||
{
|
||
//todo:load图形时必有拓扑实体，关联到对应的entity
|
||
BaseProperty* pro = nullptr;
|
||
GraphicsProjectModelItem* item = nullptr;
|
||
QMap<QUuid,BaseProperty*> mapData = BasePropertyManager::instance().getEntityData(); //加载的图形必定关联component(todo:完善判断条件，如判断拓扑节点)
|
||
|
||
if(mapData.contains(id))
|
||
{
|
||
pro = mapData.value(id);
|
||
if(pro)
|
||
{
|
||
int type = pro->graphicsType();
|
||
if(type == GIT_link) //连线对象外部处理
|
||
return QString("err");
|
||
QString sMeta = pro->metaModelName();
|
||
QString sProModel = pro->modelName();
|
||
|
||
modelDataInfo mapValue = DataManager::instance().modelData()[sProModel];
|
||
PropertyValueInfo valueInfo; //属性组设置的数据 (ct,pt二次绕组)
|
||
if(mapValue.groupInfo.contains("base_extend"))
|
||
{
|
||
valueInfo = mapValue.groupInfo["base_extend"].mapInfo[id];
|
||
}
|
||
|
||
double dX = 0.0;
|
||
double dY = 0.0;
|
||
if(type == GIT_itemRect)
|
||
{
|
||
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
|
||
QByteArray svg;
|
||
if(model.modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[3].icon;
|
||
}
|
||
else{
|
||
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["cb"];
|
||
}
|
||
|
||
if(width == 0 && height == 0){
|
||
dX = 30;
|
||
dY = 30;
|
||
}
|
||
else{
|
||
dX = width;
|
||
dY = height;
|
||
}
|
||
|
||
auto pCb = new ElectricSvgItemRect(QRect(-dX*0.5, -dY*0.5, dX, dY),false);
|
||
pCb->setItemType(GIT_itemRect);
|
||
pCb->loadSvg(svg);
|
||
item = pCb;
|
||
QJsonArray portArr = pro->context()["port"].toArray();
|
||
addPortsToItem_json(P_const,portArr,item);
|
||
}
|
||
else if(type == GIT_node)
|
||
{
|
||
auto pNode = new ElectricPortItem();
|
||
pNode->setItemType(GIT_node);
|
||
item = pNode;
|
||
|
||
QJsonArray portArr = pro->context()["port"].toArray();
|
||
addPortsToItem_json(p_movable,portArr,item);
|
||
}
|
||
else if(type == GIT_bus)
|
||
{
|
||
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
|
||
QByteArray svg;
|
||
if(model.modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[1].icon;
|
||
}
|
||
else{
|
||
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["bus"];
|
||
}
|
||
|
||
if(width == 0 && height == 0){
|
||
dX = 200;
|
||
dY = 6;
|
||
}
|
||
else{
|
||
dX = width;
|
||
dY = height;
|
||
}
|
||
|
||
auto pBus = new ElectricSvgItemBus(QRect(0, 0, dX, dY));
|
||
pBus->setItemType(GIT_bus);
|
||
pBus->loadSvg(svg);
|
||
item = pBus;
|
||
|
||
QJsonArray portArr = pro->context()["port"].toArray();
|
||
/*for(QJsonValueRef portJson:portArr)
|
||
{
|
||
QJsonObject portObj = portJson.toObject();
|
||
QString portId = portObj["portId"].toString();
|
||
int x = portObj["x"].toInt();
|
||
int y = portObj["y"].toInt();
|
||
item->addPort(p_movable,QPointF(x,y),portId);
|
||
}*/
|
||
addPortsToItem_json(p_movable,portArr,item);
|
||
}
|
||
else if(type == GIT_ctGroup)
|
||
{
|
||
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
|
||
QByteArray svg;
|
||
if(model.modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[5].icon;
|
||
}
|
||
else{
|
||
svg = model.modelSetting.mapSvg.first();
|
||
}
|
||
|
||
if(width == 0 && height == 0){
|
||
dX = 20;
|
||
dY = 20;
|
||
}
|
||
else{
|
||
dX = width;
|
||
dY = height;
|
||
}
|
||
|
||
auto pCt = new ElectricSvgGroupCT(QRect(-dX*0.5, -dY*0.5, dX, dY));
|
||
pCt->updateMapSvg(ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg);
|
||
pCt->setItemType(GIT_ctGroup);
|
||
item = pCt;
|
||
QJsonArray portArr = pro->context()["port"].toArray();
|
||
|
||
addPortsToItem_json(P_const,portArr,item);
|
||
if(!valueInfo.isEmpty()){ //使用设置的绕组数更新自己
|
||
int nCtSize = 0; //ct设置的个数
|
||
int nCtType = 0; //ct类型 1三相0零相
|
||
if(valueInfo.contains("ct_winding")){
|
||
propertyStateInfo val = valueInfo.value("ct_winding");
|
||
|
||
QJsonDocument jsonDocument = QJsonDocument::fromJson(val.defaultValue.toString().toUtf8().data());
|
||
if(!jsonDocument.isNull()){
|
||
QJsonObject obj = jsonDocument.object();
|
||
if(obj.contains("winding")){
|
||
QJsonArray arr = obj["winding"].toArray();
|
||
nCtSize = arr.size();
|
||
}
|
||
}
|
||
}
|
||
if(valueInfo.contains("phase_num")){
|
||
propertyStateInfo val = valueInfo.value("phase_num");
|
||
nCtType = val.defaultValue.toInt();
|
||
}
|
||
|
||
QPair<int,int> pair(nCtType,nCtSize);
|
||
QVariant var = QVariant::fromValue(pair);
|
||
pCt->setupFinish(var);
|
||
}
|
||
|
||
}
|
||
else if(type == GIT_ptGroup)
|
||
{
|
||
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
|
||
QByteArray svg;
|
||
if(model.modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[6].icon;
|
||
}
|
||
else{
|
||
svg = model.modelSetting.mapSvg.first();
|
||
}
|
||
|
||
if(width == 0 && height == 0){
|
||
dX = 50;
|
||
dY = 50;
|
||
}
|
||
else{
|
||
dX = width;
|
||
dY = height;
|
||
}
|
||
|
||
auto pPt = new ElectricSvgGroupPT(QRect(-dX*0.5, -dY*0.5, dX, dY));
|
||
pPt->updateMapSvg(ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg);
|
||
pPt->setItemType(GIT_ptGroup);
|
||
item = pPt;
|
||
QJsonArray portArr = pro->context()["port"].toArray();
|
||
|
||
addPortsToItem_json(P_const,portArr,item);
|
||
if(!valueInfo.isEmpty()){ //使用设置的绕组数更新自己
|
||
QList<int> lst; //二次绕组接法
|
||
if(valueInfo.contains("pt_sec_winding")){
|
||
propertyStateInfo val = valueInfo.value("pt_sec_winding");
|
||
|
||
QJsonDocument jsonDocument = QJsonDocument::fromJson(val.defaultValue.toString().toUtf8().data());
|
||
if(!jsonDocument.isNull()){
|
||
QJsonObject obj = jsonDocument.object();
|
||
QJsonArray arr = obj["winding"].toArray();
|
||
for (QJsonValueRef jsonObj : arr)
|
||
{
|
||
QJsonObject node = jsonObj.toObject();
|
||
QString sWinding = node["windingConnectionMethod"].toString();
|
||
if(sWinding == "Y"){
|
||
lst.append(1);
|
||
}
|
||
else{
|
||
lst.append(0);
|
||
}
|
||
}
|
||
}
|
||
|
||
QVariant var = QVariant::fromValue(lst);
|
||
pPt->setupFinish(var);
|
||
}
|
||
}
|
||
}
|
||
else if(type == GIT_DS)
|
||
{
|
||
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
|
||
QByteArray svg;
|
||
if(model.modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[7].icon;
|
||
}
|
||
else{
|
||
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["ds"];
|
||
}
|
||
|
||
if(width == 0 && height == 0){
|
||
dX = 30;
|
||
dY = 30;
|
||
}
|
||
else{
|
||
dX = width;
|
||
dY = height;
|
||
}
|
||
|
||
auto pDs = new ElectricSvgItemDS(QRect(-dX*0.5, -dY*0.5, dX, dY));
|
||
pDs->setItemType(GIT_DS);
|
||
pDs->loadSvg(svg);
|
||
item = pDs;
|
||
QJsonArray portArr = pro->context()["port"].toArray();
|
||
|
||
addPortsToItem_json(P_const,portArr,item);
|
||
}
|
||
else if(type == GIT_ES)
|
||
{
|
||
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
|
||
QByteArray svg;
|
||
if(model.modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[8].icon;
|
||
}
|
||
else{
|
||
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["es"];
|
||
}
|
||
|
||
if(width == 0 && height == 0){
|
||
dX = 30;
|
||
dY = 60;
|
||
}
|
||
else{
|
||
dX = width;
|
||
dY = height;
|
||
}
|
||
|
||
auto pEs = new ElectricSvgItemES(QRect(-dX*0.5, -dY*0.5, dX, dY));
|
||
pEs->setItemType(GIT_ES);
|
||
pEs->loadSvg(svg);
|
||
item = pEs;
|
||
QJsonArray portArr = pro->context()["port"].toArray();
|
||
|
||
addPortsToItem_json(P_const,portArr,item);
|
||
}
|
||
else if(type == GIT_FES)
|
||
{
|
||
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
|
||
QByteArray svg;
|
||
if(model.modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[9].icon;
|
||
}
|
||
else{
|
||
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["fes"];
|
||
}
|
||
|
||
if(width == 0 && height == 0){
|
||
dX = 30;
|
||
dY = 60;
|
||
}
|
||
else{
|
||
dX = width;
|
||
dY = height;
|
||
}
|
||
|
||
auto pFes = new ElectricSvgItemFES(QRect(-dX*0.5, -dY*0.5, dX, dY));
|
||
pFes->setItemType(GIT_FES);
|
||
pFes->loadSvg(svg);
|
||
item = pFes;
|
||
QJsonArray portArr = pro->context()["port"].toArray();
|
||
|
||
addPortsToItem_json(P_const,portArr,item);
|
||
}
|
||
else if(type == GIT_DTEDS)
|
||
{
|
||
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
|
||
QByteArray svg;
|
||
if(model.modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[10].icon;
|
||
}
|
||
else{
|
||
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["dteds"];
|
||
}
|
||
|
||
if(width == 0 && height == 0){
|
||
dX = 60;
|
||
dY = 30;
|
||
}
|
||
else{
|
||
dX = width;
|
||
dY = height;
|
||
}
|
||
|
||
auto pDteds = new ElectricSvgItemDTEDS(QRect(-dX*0.5, -dY*0.5, dX, dY));
|
||
pDteds->setItemType(GIT_DTEDS);
|
||
pDteds->loadSvg(svg);
|
||
item = pDteds;
|
||
QJsonArray portArr = pro->context()["port"].toArray();
|
||
|
||
addPortsToItem_json(P_const,portArr,item);
|
||
}
|
||
else if(type == GIT_PI)
|
||
{
|
||
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
|
||
QByteArray svg;
|
||
if(model.modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[11].icon;
|
||
}
|
||
else{
|
||
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["potential_indicator"];
|
||
}
|
||
|
||
if(width == 0 && height == 0){
|
||
dX = 30;
|
||
dY = 60;
|
||
}
|
||
else{
|
||
dX = width;
|
||
dY = height;
|
||
}
|
||
|
||
auto pPi = new ElectricSvgItemPI(QRect(-dX*0.5, -dY*0.5, dX, dY));
|
||
pPi->setItemType(GIT_PI);
|
||
pPi->loadSvg(svg);
|
||
item = pPi;
|
||
QJsonArray portArr = pro->context()["port"].toArray();
|
||
|
||
addPortsToItem_json(P_const,portArr,item);
|
||
}
|
||
else if(type == GIT_LA)
|
||
{
|
||
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
|
||
QByteArray svg;
|
||
if(model.modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[12].icon;
|
||
}
|
||
else{
|
||
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["lightning_arrester"];
|
||
}
|
||
|
||
if(width == 0 && height == 0){
|
||
dX = 30;
|
||
dY = 60;
|
||
}
|
||
else{
|
||
dX = width;
|
||
dY = height;
|
||
}
|
||
|
||
auto pLa = new ElectricSvgItemLA(QRect(-dX*0.5, -dY*0.5, dX, dY));
|
||
pLa->setItemType(GIT_LA);
|
||
pLa->loadSvg(svg);
|
||
item = pLa;
|
||
QJsonArray portArr = pro->context()["port"].toArray();
|
||
|
||
addPortsToItem_json(P_const,portArr,item);
|
||
}
|
||
else if(type == GIT_cableTer)
|
||
{
|
||
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
|
||
QByteArray svg;
|
||
if(model.modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[13].icon;
|
||
}
|
||
else{
|
||
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["cable_termination"];
|
||
}
|
||
|
||
if(width == 0 && height == 0){
|
||
dX = 20;
|
||
dY = 20;
|
||
}
|
||
else{
|
||
dX = width;
|
||
dY = height;
|
||
}
|
||
|
||
auto pCt = new ElectricSvgItemCableTer(QRect(-dX*0.5, -dY*0.5, dX, dY));
|
||
pCt->setItemType(GIT_cableTer);
|
||
pCt->loadSvg(svg);
|
||
item = pCt;
|
||
QJsonArray portArr = pro->context()["port"].toArray();
|
||
|
||
addPortsToItem_json(P_const,portArr,item);
|
||
}
|
||
else if(type == GIT_cableEnd)
|
||
{
|
||
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
|
||
QByteArray svg;
|
||
if(model.modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[14].icon;
|
||
}
|
||
else{
|
||
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["cable_end"];
|
||
}
|
||
|
||
if(width == 0 && height == 0){
|
||
dX = 20;
|
||
dY = 20;
|
||
}
|
||
else{
|
||
dX = width;
|
||
dY = height;
|
||
}
|
||
|
||
auto pCe = new ElectricSvgItemCableEnd(QRect(-dX*0.5, -dY*0.5, dX, dY));
|
||
pCe->setItemType(GIT_cableEnd);
|
||
pCe->loadSvg(svg);
|
||
item = pCe;
|
||
QJsonArray portArr = pro->context()["port"].toArray();
|
||
|
||
addPortsToItem_json(P_const,portArr,item);
|
||
}
|
||
else if(type == GIT_2wTransformer)
|
||
{
|
||
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
|
||
QByteArray svg;
|
||
if(model.modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[15].icon;
|
||
}
|
||
else{
|
||
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["transformer_2w"];
|
||
}
|
||
|
||
if(width == 0 && height == 0){
|
||
dX = 100;
|
||
dY = 100;
|
||
}
|
||
else{
|
||
dX = width;
|
||
dY = height;
|
||
}
|
||
|
||
auto p2w = new ElectricSvgItem2wTransformer(QRect(-dX*0.5, -dY*0.5, dX, dY));
|
||
p2w->setItemType(GIT_2wTransformer);
|
||
p2w->loadSvg(svg);
|
||
item = p2w;
|
||
QJsonArray portArr = pro->context()["port"].toArray();
|
||
|
||
addPortsToItem_json(P_const,portArr,item);
|
||
}
|
||
else if(type == GIT_3wTransformer)
|
||
{
|
||
PropertyModel model = ProjectModelManager::instance().getData()[sMeta][sProModel];
|
||
QByteArray svg;
|
||
if(model.modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[15].icon;
|
||
}
|
||
else{
|
||
svg = ProjectModelManager::instance().getData()[sMeta][sProModel].modelSetting.mapUsedSvg["transformer_3w"];
|
||
}
|
||
|
||
if(width == 0 && height == 0){
|
||
dX = 100;
|
||
dY = 100;
|
||
}
|
||
else{
|
||
dX = width;
|
||
dY = height;
|
||
}
|
||
|
||
auto p3w = new ElectricSvgItem3wTransformer(QRect(-dX*0.5, -dY*0.5, dX, dY));
|
||
p3w->setItemType(GIT_3wTransformer);
|
||
p3w->loadSvg(svg);
|
||
item = p3w;
|
||
QJsonArray portArr = pro->context()["port"].toArray();
|
||
|
||
addPortsToItem_json(P_const,portArr,item);
|
||
}
|
||
if(item)
|
||
{
|
||
item->setItemId(id);
|
||
item->editShape(0, pos);
|
||
item->setPos(pos);
|
||
item->setRotation(rotate);
|
||
_scene->addItem(item);
|
||
item->addPoint(pos);
|
||
item->setProperty(pro); //绑定模型
|
||
item->updateByProperty(); //使用模型更新自身
|
||
//QString sModel = _projectModelName.value(id.toString());
|
||
//item->setModelName(sModel);
|
||
_nodeItem.insert(id,item);
|
||
connect(item,&GraphicsProjectModelItem::ifExist,this,&FixedPortsModel::onSignal_ifExits);
|
||
}
|
||
return pro->name();
|
||
}
|
||
}
|
||
return QString("err");
|
||
}
|
||
|
||
BaseProperty* FixedPortsModel::addNodeData(QUuid id,int type,QString name,QString modelName)
|
||
{
|
||
BaseProperty* pData = BasePropertyManager::instance().findEntityData(id); //已存在不不创建
|
||
if(pData != nullptr)
|
||
return pData;
|
||
|
||
VariableProperty* item = new VariableProperty();
|
||
//todo:关联到对应data
|
||
|
||
if(item)
|
||
{
|
||
item->setUuid(id);
|
||
item->setModelName(modelName);
|
||
item->setType(type);
|
||
GraphicsItemType localType = typeToProGraphic[type]; //将通用类型转换为工程模图元
|
||
item->setGraphicsType(localType);
|
||
item->setTag(name);
|
||
item->setName(name);
|
||
item->setDataChanged(true);
|
||
BasePropertyManager::instance().insertEntityData(id,item);
|
||
}
|
||
return item;
|
||
}
|
||
|
||
void FixedPortsModel::loadNodeDataFromDataBase()
|
||
{
|
||
if(!_dataInitialised)
|
||
{
|
||
QList<componentInfo> lst= DataBase::GetInstance()->getAllComponents();
|
||
for(auto &info:lst)
|
||
{
|
||
QString preTag = removeSuffix(info.tag);
|
||
QString prePath = removeSuffix(info.nspath);
|
||
BaseProperty* pData = addNodeData(info.uuid,info.type,info.name,info.modelName);
|
||
pData->setTag(preTag);
|
||
pData->setName(info.name);
|
||
pData->setPath(prePath);
|
||
pData->setDescription(info.description);
|
||
pData->setInService(info.inService);
|
||
pData->setState(info.state);
|
||
pData->setConnectedBus(info.connected_bus);
|
||
pData->setLabel(info.label);
|
||
pData->setContext(info.context);
|
||
pData->setGrid(info.grid);
|
||
pData->setZone(info.zone);
|
||
pData->setStation(info.station);
|
||
pData->setDataChanged(false);
|
||
|
||
QString sMeta = info.context["metaModel"].toString();
|
||
pData->setMetaModelName(sMeta);
|
||
|
||
PowerEntity* pEntity = TopologyManager::instance().createEntity(EntityType::Component,info.uuid.toString(),info.name); //首先load所有data和entity，全局唯一
|
||
if(pEntity){
|
||
createTopoTerminalsByData(pEntity,info.context);
|
||
}
|
||
|
||
QList<MeasurementInfo> lstMeasure = DataBase::GetInstance()->getMeasurement(info.uuid); //添加设备量测
|
||
QMap<QString,MeasurementInfo> mapMeasure;
|
||
for(auto& info:lstMeasure)
|
||
{
|
||
info.tag = removeSuffix(info.tag);
|
||
mapMeasure.insert(info.name,info);
|
||
}
|
||
pData->setMeasurement(mapMeasure);
|
||
}
|
||
|
||
QList<topologicInfo> lstTopo = DataBase::GetInstance()->getAllTopologics();
|
||
for(auto &info:lstTopo)
|
||
{
|
||
QString from_pin = info.context["from_pin"].toString();
|
||
QString to_pin = info.context["to_pin"].toString();
|
||
|
||
TopologyManager::instance().createConnection(QString::number(info.id),from_pin,to_pin,info.uuid_from.toString(),info.uuid_to.toString());
|
||
}
|
||
|
||
QList<bayInfo> lstBay = DataBase::GetInstance()->getAllBay();
|
||
for(auto& bay:lstBay)
|
||
{
|
||
QString showTag = removeSuffix(bay.tag);
|
||
BayProperty* pBay = addBayData(bay.uuid);
|
||
pBay->setName(bay.name);
|
||
pBay->setTag(showTag);
|
||
pBay->setType(bay.type);
|
||
pBay->setLstComponent(bay.components);
|
||
pBay->setVoltage(bay.unom);
|
||
pBay->setFla(bay.fla);
|
||
pBay->setCapacity(bay.capacity);
|
||
pBay->setInService(bay.inService);
|
||
auto fromLst = turnJsonArrToList(bay.fromUuid,"id","ids");
|
||
pBay->setLstFrom(fromLst);
|
||
auto toLst = turnJsonArrToList(bay.toUuid,"id","ids");
|
||
pBay->setLstTo(toLst);
|
||
auto proptecLst = turnJsonArrToList(bay.protect,"id","ids");
|
||
pBay->setLstProtect(proptecLst);
|
||
auto falRecLst = turnJsonArrToList(bay.faultRec,"id","ids");
|
||
pBay->setLstFaultRecord(falRecLst);
|
||
auto dynSenLst = turnJsonArrToList(bay.dynSense,"id","ids");
|
||
pBay->setLstDynSense(dynSenLst);
|
||
auto staLst = turnJsonArrToList(bay.status,"id","ids");
|
||
pBay->setLstStatus(staLst);
|
||
auto insLst = turnJsonArrToList(bay.instruct,"id","ids");
|
||
pBay->setLstInstruct(insLst);
|
||
auto etcLst = turnJsonArrToList(bay.etc,"id","ids");
|
||
pBay->setLstEtc(etcLst);
|
||
}
|
||
_dataInitialised = true;
|
||
}
|
||
else
|
||
{
|
||
//for(auto p:_nodeData)
|
||
{
|
||
int a = 1;
|
||
}
|
||
}
|
||
}
|
||
|
||
QString FixedPortsModel::addConnectLline(QUuid lineId,QUuid srcId,QUuid destId,QUuid srcPort,QUuid destPort)
|
||
{
|
||
GraphicsProjectModelItem* src = _nodeItem[srcId];
|
||
GraphicsProjectModelItem* dest = _nodeItem[destId];
|
||
QMap<QUuid,BaseProperty*> mapData = BasePropertyManager::instance().getEntityData();
|
||
if(mapData.contains(lineId))
|
||
{
|
||
BaseProperty* pPro = mapData.value(lineId);
|
||
if(src && dest && pPro)
|
||
{
|
||
ElectricConnectLineItem* pItem = new ElectricConnectLineItem();
|
||
pItem->setItemId(lineId);
|
||
pItem->setItemType(GIT_link);
|
||
_scene->addItem(pItem);
|
||
|
||
ItemPort* ptSrc = src->getPortById(srcPort.toString());
|
||
HandleType srcType = ptSrc->getType();
|
||
PortPos srcPos = ptSrc->portPos();
|
||
pItem->setStartPoint(ptSrc->scenePos());
|
||
ptSrc->setConnect(pItem);
|
||
|
||
ItemPort* ptDest = nullptr;
|
||
ptDest = dest->getPortById(destPort.toString());
|
||
pItem->setEndPoint(ptDest->scenePos());
|
||
|
||
if(ptDest != nullptr)
|
||
{
|
||
HandleType destType = ptDest->getType();
|
||
PortPos destPos = ptDest->portPos();
|
||
|
||
pItem->calculatePath();
|
||
|
||
pPro->setConnection(Connection(srcId,srcPort,srcType,srcPos,destId,destPort,destType,destPos));
|
||
ptDest->setConnect(pItem);
|
||
|
||
addNodeItem(pItem->itemId(),pItem);
|
||
pItem->setProperty(pPro);
|
||
}
|
||
|
||
return pPro->name();
|
||
}
|
||
}
|
||
return QString("err");
|
||
}
|
||
|
||
void FixedPortsModel::deleteNodeItem(GraphicsProjectModelItem* pItem)
|
||
{
|
||
if(pItem->getItemType() == GIT_link)
|
||
{
|
||
auto pLine = dynamic_cast<ElectricConnectLineItem*>(pItem);
|
||
if(pLine)
|
||
{
|
||
QUuid conId = pLine->itemId();
|
||
TopologyManager::instance().removeConnection(conId.toString());
|
||
|
||
PowerConnection* pCon = TopologyManager::instance().connection(conId.toString());
|
||
if(pCon){
|
||
PowerEntity* itemFrom = TopologyManager::instance().getEntityByTerminal(pCon->fromTerminalId());
|
||
PowerEntity* itemTo = TopologyManager::instance().getEntityByTerminal(pCon->toTerminalId());
|
||
if(itemFrom && itemTo)
|
||
{
|
||
_nodeItem.value(QUuid(itemFrom->id()))->setItemChanged(true);
|
||
_nodeItem.value(QUuid(itemTo->id()))->setItemChanged(true);
|
||
}
|
||
}
|
||
|
||
_nodeItem.take(conId);
|
||
_scene->removeItem(pLine);
|
||
delete pLine;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
QUuid srcId = pItem->itemId();
|
||
QList<PowerConnection*> lstCon = TopologyManager::instance().getConnectionsFor(srcId.toString());
|
||
for(auto &con:lstCon)
|
||
{
|
||
PowerEntity* pFrom = TopologyManager::instance().getEntityByTerminal(con->fromTerminalId());
|
||
PowerEntity* pTo = TopologyManager::instance().getEntityByTerminal(con->toTerminalId());
|
||
if(pFrom && pTo)
|
||
{
|
||
if(srcId.toString() == pFrom->id()) //对象是srcItem
|
||
_nodeItem.value(QUuid(pTo->id()))->setItemChanged(true);
|
||
else //对象是toItem
|
||
_nodeItem.value(QUuid(pFrom->id()))->setItemChanged(true);
|
||
}
|
||
|
||
//TopologyManager::instance().removeConnection(con->id()); //删除entity时会同时删除相关连接，无需手动删除
|
||
}
|
||
TopologyManager::instance().deleteEntity(srcId.toString());
|
||
|
||
pItem->setItemChanged(true);
|
||
_nodeItem.take(srcId);
|
||
_scene->removeItem(pItem);
|
||
delete pItem;
|
||
}
|
||
}
|
||
|
||
void FixedPortsModel::saveNode(int nPageId)
|
||
{
|
||
for(auto& bay:_bayItem)
|
||
{
|
||
AbstractProperty* pro = bay->getProperty(); //间隔
|
||
BayProperty* pBay = dynamic_cast<BayProperty*>(pro);
|
||
if(pBay){
|
||
bool val = DataBase::GetInstance()->ifBayExist(pBay->uuid());
|
||
QString tempTag = pBay->tag()+"_"+_pageName; //tag后加工程名保持全局唯一
|
||
if(!val){
|
||
QJsonObject objFrom = turnListToJson(pBay->getLstFrom(),"id","ids");
|
||
QJsonObject objTo= turnListToJson(pBay->getLstTo(),"id","ids");
|
||
QJsonObject objProtec= turnListToJson(pBay->getLstProtect(),"id","ids");
|
||
QJsonObject objFalRec= turnListToJson(pBay->getLstFaultRecord(),"id","ids");
|
||
QJsonObject objStatus= turnListToJson(pBay->getLstStatus(),"id","ids");
|
||
QJsonObject objDynSen= turnListToJson(pBay->getLstDynSense(),"id","ids");
|
||
QJsonObject objIns= turnListToJson(pBay->getLstInstruct(),"id","ids");
|
||
QJsonObject objEtc= turnListToJson(pBay->getLstEtc(),"id","ids");
|
||
|
||
DataBase::GetInstance()->insertBay(pBay->uuid(),pBay->name(),tempTag,pBay->getType(),pBay->getVoltage(),pBay->getFla(),pBay->getCapacity(),"1",pBay->getInService(),0,"1","1","1",QJsonObject(),objFrom,objTo,objProtec,objFalRec,objStatus,objDynSen,objIns,objEtc,pBay->getLstComponent(),QJsonObject());
|
||
}
|
||
else{
|
||
QJsonObject objFrom = turnListToJson(pBay->getLstFrom(),"id","ids");
|
||
QJsonObject objTo= turnListToJson(pBay->getLstTo(),"id","ids");
|
||
QJsonObject objProtec= turnListToJson(pBay->getLstProtect(),"id","ids");
|
||
QJsonObject objFalRec= turnListToJson(pBay->getLstFaultRecord(),"id","ids");
|
||
QJsonObject objStatus= turnListToJson(pBay->getLstStatus(),"id","ids");
|
||
QJsonObject objDynSen= turnListToJson(pBay->getLstDynSense(),"id","ids");
|
||
QJsonObject objIns= turnListToJson(pBay->getLstInstruct(),"id","ids");
|
||
QJsonObject objEtc= turnListToJson(pBay->getLstEtc(),"id","ids");
|
||
|
||
DataBase::GetInstance()->updateBay(pBay->uuid(),pBay->name(),tempTag,pBay->getVoltage(),pBay->getFla(),pBay->getCapacity(),"",pBay->getInService(),0,QJsonObject(),objFrom,objTo,objProtec,objFalRec,objStatus,objDynSen,objIns,objEtc,pBay->getLstComponent(),QJsonObject());
|
||
}
|
||
}
|
||
}
|
||
|
||
QMap<QUuid,GraphicsProjectModelItem*> mapItems = allItems();
|
||
for(auto& pItem:mapItems)
|
||
{
|
||
BaseProperty* pData = dynamic_cast<BaseProperty*>(pItem->getProperty());
|
||
if(pData){
|
||
Connection con = pData->getConnection();
|
||
QString fromPin = con.nSrcPortId.toString();
|
||
QString toPin = con.nDestPortId.toString();
|
||
QJsonObject context;
|
||
context["from_pin"] = fromPin;
|
||
context["to_pin"] = toPin;
|
||
if(pData->prepareDelete())
|
||
{
|
||
DataBase::GetInstance()->deleteComponent(pData->uuid().toString());
|
||
if(pData->type() == 8){
|
||
PowerConnection* pCon = TopologyManager::instance().connection(fromPin,toPin);
|
||
if(pCon){
|
||
DataBase::GetInstance()->deleteTopologic(con.nSrcPortId,con.nDestPortId);
|
||
TopologyManager::instance().removeConnection(pCon->id());
|
||
}
|
||
}
|
||
continue;
|
||
}
|
||
if(pData->dataChanged())
|
||
{
|
||
pData->setDataChanged(false);
|
||
bool exist = DataBase::GetInstance()->componentExist(pData->uuid().toString());
|
||
VariableProperty* pVariable = dynamic_cast<VariableProperty*>(pData);
|
||
if(pVariable)
|
||
{
|
||
modelDataInfo& dataInfo = pVariable->getPropertyValue();
|
||
if(exist) //已存在更新
|
||
{
|
||
QString tempTag = pData->tag()+"_"+_pageName; //tag后加工程名使得全局唯一
|
||
DataBase::GetInstance()->updateComponent(pData->uuid(),tempTag,pData->name(),pData->context());
|
||
for(auto &val:dataInfo.groupInfo)
|
||
{
|
||
if(val.groupName == "component")
|
||
continue;
|
||
DataBase::GetInstance()->updateDynamicProperty(pData->uuid(),val);
|
||
if(val.mapInfo.contains(pData->uuid())){ //保存时将数据锁复原
|
||
auto& mapPro = val.mapInfo[pData->uuid()];
|
||
for(auto& pro:mapPro)
|
||
{
|
||
pro.lock = false;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
QString tempTag = pData->tag()+"_"+_pageName; //tag后加工程名使得全局唯一
|
||
QString tempPath = pData->path()+"_"+_pageName;
|
||
DataBase::GetInstance()->insertComponent(pData->uuid(),pData->modelName(),tempPath,tempTag,pData->name(),pData->description(),pData->grid(),pData->zone(),pData->station(),pData->type(),true,pData->state(),pData->status(),pData->connectedBus(),pData->label(),pData->context(),1);
|
||
for(auto &val:dataInfo.groupInfo)
|
||
{
|
||
if(val.groupName == "component")
|
||
continue;
|
||
DataBase::GetInstance()->insertDynamicProperty(pData->uuid(),val);
|
||
if(val.mapInfo.contains(pData->uuid())){ //保存时将数据锁复原
|
||
auto& mapPro = val.mapInfo[pData->uuid()];
|
||
for(auto& pro:mapPro)
|
||
{
|
||
pro.lock = false;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
QMap<QString,MeasurementInfo> mapMeasure = pData->getMeasurement(); //量测
|
||
|
||
QList<MeasurementInfo> lstDataBase = DataBase::GetInstance()->getMeasurement(pData->uuid()); //数据库中现有量测
|
||
for(auto& info:mapMeasure)
|
||
{
|
||
int tpe = info.type; //todo:建立类型映射表
|
||
|
||
QJsonObject objDataSource;
|
||
QJsonObject objIoAddress;
|
||
if(info.nSource == 1){ //3611
|
||
objDataSource["type"] = 1;
|
||
objIoAddress["station"] = info.sStation;
|
||
objIoAddress["device"] = info.equipment;
|
||
objIoAddress["channel"] = info.sChannel;
|
||
}
|
||
else if(info.nSource == 2){ //104
|
||
objDataSource["type"] = 2;
|
||
objIoAddress["station"] = info.sStation;
|
||
objIoAddress["packet"] = info.nPacket;
|
||
objIoAddress["offset"] = info.nOffset;
|
||
}
|
||
objDataSource["io_address"] = objIoAddress;
|
||
|
||
QJsonObject objEventPlan;
|
||
QJsonObject objCause;
|
||
QJsonObject objAction;
|
||
QJsonArray arrPara;
|
||
objEventPlan["enable"] = info.bEnable;
|
||
if(tpe == 0){ //遥测
|
||
for(auto iter = info.mapTE.begin();iter != info.mapTE.end();++iter){
|
||
objCause[iter.key()] = iter.value();
|
||
}
|
||
}
|
||
else if(tpe == 1){ //遥信
|
||
objCause["edge"] = info.sEdge;
|
||
}
|
||
objEventPlan["cause"] = objCause;
|
||
|
||
objAction["command"] = info.sCommand;
|
||
for(auto ¶:info.lstParameter){
|
||
arrPara.append(para);
|
||
}
|
||
objAction["parameters"] = arrPara;
|
||
objEventPlan["action"] = objAction;
|
||
|
||
QString tempTag = info.tag+"_"+_pageName; //tag后加工程名，保持全局唯一
|
||
|
||
bool val = DataBase::GetInstance()->ifMeasureExist(info.name,pData->uuid());
|
||
if(val){
|
||
DataBase::GetInstance()->updateMeasurement(info.name,tpe,objDataSource,objEventPlan,info.size,pData->uuid());
|
||
}
|
||
else{
|
||
DataBase::GetInstance()->insertMeasurement(info.name,tempTag,tpe,objDataSource,objEventPlan,info.size,info.bayUuid,info.componentUuid);
|
||
}
|
||
|
||
for(int i = 0;i < lstDataBase.size();++i) //从数据库记录中移除操作过的对象
|
||
{
|
||
if(lstDataBase[i].name == info.name){
|
||
lstDataBase.removeAt(i);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
for(auto& info:lstDataBase) //操作的记录小于数据库中的记录，删除库中多出的记录
|
||
{
|
||
DataBase::GetInstance()->delteMeasurement(info.name,info.componentUuid);
|
||
}
|
||
}
|
||
|
||
if(pData->type() == 8){
|
||
PowerConnection* pCon = TopologyManager::instance().connection(fromPin,toPin);
|
||
if(pCon){
|
||
int id = DataBase::GetInstance()->topologicExist(con.nSrcNodeId,con.nDestNodeId);
|
||
if(id == -1)
|
||
DataBase::GetInstance()->insertTopologic(con.nSrcNodeId,con.nDestNodeId,context,0,"",0);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void FixedPortsModel::onSignal_ifExits(QUuid id,const QString& str,int type,GraphicsProjectModelItem* pitem)
|
||
{
|
||
bool exist = false;
|
||
BaseProperty* pData = nullptr;
|
||
QMap<QUuid,BaseProperty*> mapData = BasePropertyManager::instance().getEntityData();
|
||
for(auto pro:mapData)
|
||
{
|
||
if(pro->tag() == str)
|
||
{
|
||
pData = pro;
|
||
exist = true;
|
||
break;
|
||
}
|
||
}
|
||
if(exist) //已存在，将发出信号的item绑定到此data
|
||
{
|
||
if(_nodeItem.contains(id)) //发出信号对象id与data对象id相同，已绑定,不做响应
|
||
return;
|
||
QMessageBox msgBox;
|
||
msgBox.setText(QString::fromWCharArray(L"提示"));
|
||
msgBox.setInformativeText(QString::fromWCharArray(L"此名称对象已存在,是否使用该对象?"));
|
||
msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
|
||
msgBox.setDefaultButton(QMessageBox::Cancel);
|
||
int ret = msgBox.exec();
|
||
switch (ret) {
|
||
case QMessageBox::Ok:
|
||
{
|
||
//todo:断开原来的连接关系
|
||
pitem->setProperty(pData);
|
||
pitem->setItemId(pData->uuid());
|
||
PowerEntity* pEntity = TopologyManager::instance().findEntity(pData->uuid().toString());
|
||
if(pEntity){
|
||
pitem->setEntity(pEntity); //item对象的逻辑接线点无需重复创建
|
||
}
|
||
_nodeItem.take(id);
|
||
_nodeItem.insert(pData->uuid(),pitem);
|
||
}
|
||
break;
|
||
case QMessageBox::Cancel:
|
||
// Cancel was clicked
|
||
break;
|
||
default:
|
||
// should never be reached
|
||
break;
|
||
}
|
||
}
|
||
else //创建新data并绑定
|
||
{
|
||
BaseProperty* pData = addNodeData(id,type,str,pitem->getModelName());
|
||
if(pData)
|
||
{
|
||
pitem->setProperty(pData);
|
||
pData->setDataChanged(true); //数据状态改变
|
||
}
|
||
|
||
PowerEntity* pEntity = TopologyManager::instance().createEntity(EntityType::Component,id.toString(),str);
|
||
if(pEntity)
|
||
pitem->setEntity(pEntity);
|
||
createTopoTerminalsByItem(pitem); //创建item对象的逻辑接线点
|
||
}
|
||
}
|
||
|
||
|
||
void FixedPortsModel::onTimeOut()
|
||
{
|
||
_Interface->getPointData("i");
|
||
_Interface->getPointData("v");
|
||
}
|
||
|
||
void FixedPortsModel::onSignal_GetPointData(QString type,QMap<qint64,double> map)
|
||
{
|
||
if(map.size() == 1) //实时数据
|
||
{
|
||
double d = map.first();
|
||
|
||
//for(auto pro:_nodeData) //demo版本只有一个数据
|
||
{
|
||
//int t = pro->type();
|
||
//if(t == GIT_itemRect)
|
||
{
|
||
//todo:根据id匹配数据
|
||
/*auto p = dynamic_cast<ElectricSvgItemRect_Property*>(pro);
|
||
if(p)
|
||
{
|
||
p->notifyUpdate(); //通知更新
|
||
}*/
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void FixedPortsModel::onSignal_generateDiagram(const QString& sName)
|
||
{
|
||
QStringList lstInfo;
|
||
for(auto& item:_baseItem){
|
||
BaseModelProperty* pBase = dynamic_cast<BaseModelProperty*>(item->getProperty());
|
||
if(pBase){
|
||
int nType = pBase->type();
|
||
if(nType == 0){ //为节点等无属性对象时跳过(自动赋值modelname)
|
||
pBase->setModelName(pBase->metaModelName());
|
||
continue;
|
||
}
|
||
|
||
QString sModel = pBase->getModelProperty().modelSetting.modelName;
|
||
if(sModel.isEmpty()){
|
||
lstInfo.append(pBase->name());
|
||
}
|
||
}
|
||
}
|
||
if(!lstInfo.isEmpty()){
|
||
QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"%1未设置完毕").arg(lstInfo.join("、")));
|
||
return;
|
||
}
|
||
|
||
QList<GraphicsBaseModelItem*> lst;
|
||
for(auto& item:_baseItem)
|
||
{
|
||
lst.append(item);
|
||
}
|
||
|
||
QList<GraphicsNonStandardItem*> lstBay;
|
||
for(auto& item:_baseBayItem)
|
||
{
|
||
lstBay.append(item);
|
||
}
|
||
generateProjectModel(sName,lst,lstBay);
|
||
}
|
||
|
||
void FixedPortsModel::onSignal_openBayManager()
|
||
{
|
||
if(m_pBayManager == nullptr){
|
||
m_pBayManager = new BayManagerDlg(_widget);
|
||
m_pBayManager->setModelController(this);
|
||
}
|
||
m_pBayManager->showDlg();
|
||
}
|
||
|
||
void FixedPortsModel::startHttpRequest()
|
||
{
|
||
if(_timer)
|
||
{
|
||
_timer->setInterval(1000);
|
||
_timer->start();
|
||
}
|
||
}
|
||
|
||
void FixedPortsModel::addPortsToItem_json(PortState sta,QJsonArray jArr,GraphicsProjectModelItem* pItem)
|
||
{
|
||
for(QJsonValueRef portJson:jArr)
|
||
{
|
||
QJsonObject portObj = portJson.toObject();
|
||
QString portId = portObj["portId"].toString();
|
||
double x = portObj["x"].toDouble();
|
||
double y = portObj["y"].toDouble();
|
||
if(sta == P_const){
|
||
HandleType tye = HandleType(portObj["portType"].toInt());
|
||
PortPos locate = PortPos(portObj["locate"].toInt());
|
||
double ratioX = 0.0;
|
||
double ratioY = 0.0;
|
||
if(portObj.contains("xRatio") || portObj.contains("yRatio")){
|
||
ratioX = portObj["xRatio"].toDouble();
|
||
ratioY = portObj["yRatio"].toDouble();
|
||
}
|
||
pItem->addPort(P_const,QPointF(x,y),portId,tye,locate,ratioX,ratioY);
|
||
}
|
||
else if(sta == p_movable){
|
||
pItem->addPort(p_movable,QPointF(x,y),portId);
|
||
}
|
||
}
|
||
}
|
||
|
||
void FixedPortsModel::autoSetModelName(GraphicsBaseModelItem* pItem)
|
||
{
|
||
ModelProperty* p = pItem->getProperty();
|
||
BaseModelProperty* pro = dynamic_cast<BaseModelProperty*>(p);
|
||
if(pro){
|
||
QString sMeta = pro->metaModelName();
|
||
QString sModel = sMeta+"_"+_pageName;
|
||
bool exist = ProjectModelManager::instance().getData()[sMeta].contains(sModel);
|
||
if(exist){
|
||
pro->setModelName(sModel);
|
||
pro->getModelProperty().modelSetting.modelName = sModel;
|
||
}
|
||
}
|
||
}
|
||
|
||
QString FixedPortsModel::removeSuffix(const QString& str)
|
||
{
|
||
int lastUnderscore = str.lastIndexOf('_');
|
||
if (lastUnderscore == -1) return str; // 没有下划线
|
||
|
||
return str.left(lastUnderscore);
|
||
}
|
||
|
||
ModelProperty* FixedPortsModel::getItemByUid(QList<GraphicsBaseItem*> lst,QUuid uid)
|
||
{
|
||
for(auto& item:lst){
|
||
auto pPro = item->getProperty();
|
||
if(pPro->uuid() == uid){
|
||
return pPro;
|
||
}
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
|
||
QWidget* FixedPortsModel::getTopWidget()
|
||
{
|
||
return dynamic_cast<QWidget*>(_widget);
|
||
}
|
||
|
||
QPointF FixedPortsModel::getTerminalPos(const QString& sTerminalId)
|
||
{
|
||
PowerEntity* pParent = TopologyManager::instance().getEntityByTerminal(sTerminalId);
|
||
if(pParent)
|
||
{
|
||
for(auto &item:_nodeItem)
|
||
{
|
||
if(pParent->id() == item->itemId().toString()) //找到terminal父图元
|
||
{
|
||
for(auto &pPort:item->getPorts())
|
||
{
|
||
if(pPort->getId() == sTerminalId)
|
||
{
|
||
return pPort->scenePos();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return QPointF(0,0);
|
||
}
|
||
|
||
ElectricConnectLineItem* FixedPortsModel::getLineItemById(const QString& terminalId)
|
||
{
|
||
for(auto iter:_nodeItem) //获取id所在的lineitem
|
||
{
|
||
auto item = dynamic_cast<GraphicsProjectModelItem*>(iter);
|
||
if(item)
|
||
{
|
||
if(item->getItemType() == GIT_link)
|
||
{
|
||
PowerConnection* pCon = TopologyManager::instance().getConnectionContainsTerminal(terminalId);
|
||
if(pCon)
|
||
{
|
||
if(item->itemId().toString() == pCon->id())
|
||
return dynamic_cast<ElectricConnectLineItem*>(item);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
void FixedPortsModel::showModelDlg(const QString& sName,QUuid uuid,GraphicsProjectModelItem* pItem)
|
||
{
|
||
modelStateInfo stateInfo = _modelStateInfo[sName];
|
||
ModelDataMap mapData = DataManager::instance().modelData();
|
||
ItemPropertyDlg* pDlg = dynamic_cast<ItemPropertyDlg*>(stateInfo._PropertyDlg);
|
||
if(pDlg)
|
||
{
|
||
pDlg->showDlg(mapData[sName],uuid,pItem);
|
||
}
|
||
else
|
||
qDebug()<<"showModelDlg err";
|
||
}
|
||
|
||
void FixedPortsModel::initialPropertyDlg()
|
||
{
|
||
for(auto &modelInfo:_modelStateInfo)
|
||
{
|
||
if(modelInfo._PropertyDlg == NULL)
|
||
{
|
||
generatePropertyDlg(modelInfo.modelName);
|
||
}
|
||
}
|
||
}
|
||
|
||
void FixedPortsModel::generatePropertyDlg(const QString& sModel)
|
||
{
|
||
modelStateInfo info = _modelStateInfo[sModel];
|
||
if(info._PropertyDlg == NULL)
|
||
{
|
||
ItemPropertyDlg* dlg = new ItemPropertyDlg(_widget);
|
||
if(dlg)
|
||
{
|
||
dlg->setModelController(this);
|
||
dlg->loadGroupButton(info.groupInfo);
|
||
_modelStateInfo[sModel]._PropertyDlg = dlg;
|
||
}
|
||
}
|
||
}
|
||
|
||
ConfigurationDiagram* FixedPortsModel::getTopologyDiagram()
|
||
{
|
||
return dynamic_cast<ConfigurationDiagram*>(_pEntity);
|
||
}
|
||
|
||
void FixedPortsModel::createTopoTerminalsByData(PowerEntity* pParent,QJsonObject componentCon,ModelFunctionType funType)
|
||
{
|
||
QJsonArray portsArray = componentCon["port"].toArray();
|
||
for (QJsonValueRef portJson : portsArray) //每个属性的状态信息
|
||
{
|
||
QJsonObject node = portJson.toObject();
|
||
QString portId = node["portId"].toString();
|
||
int x = node["x"].toInt();
|
||
int y = node["y"].toInt();
|
||
PortPos locate = PortPos(node["locate"].toInt());
|
||
HandleType portType = HandleType(node["portType"].toInt());
|
||
|
||
TerminalType terType;
|
||
switch (portType) {
|
||
case T_lineIn:
|
||
terType = TerminalType::PowerInput;
|
||
break;
|
||
case T_lineOut:
|
||
terType = TerminalType::PowerOutput;
|
||
break;
|
||
case T_lineInOut:
|
||
terType = TerminalType::PowerConnect;
|
||
break;
|
||
case T_newTral:
|
||
terType = TerminalType::NewTral;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
auto pTer = TopologyManager::instance().createTerminal(pParent->id(),terType,"",QPointF(x,y),portId,funType);
|
||
if(pTer)
|
||
pTer->setPortLocate(locate);
|
||
}
|
||
}
|
||
|
||
bool FixedPortsModel::isItemValid(GraphicsProjectModelItem* pItem)
|
||
{
|
||
ModelProperty* pData = pItem->getProperty();
|
||
PowerEntity* pEntity = pItem->entity();
|
||
return (pData != nullptr && pEntity != nullptr)?true:false;
|
||
}
|
||
|
||
|
||
void FixedPortsModel::insertProjectModelName(QString uuid,QString name)
|
||
{
|
||
if(!_projectModelName.contains(uuid))
|
||
_projectModelName.insert(uuid,name);
|
||
}
|
||
|
||
void FixedPortsModel::showProjectIconSettingDlg(GraphicsProjectModelItem* pItem)
|
||
{
|
||
if(m_projectIconSettingDlg == nullptr)
|
||
{
|
||
m_projectIconSettingDlg = new ProjectIconSetting(_widget);
|
||
m_projectIconSettingDlg->setController(this);
|
||
}
|
||
m_projectIconSettingDlg->showDlg(pItem);
|
||
}
|
||
|
||
void FixedPortsModel::updateItemIcon(QString sMeta,QString sModel)
|
||
{
|
||
for(auto &pItem:_nodeItem){
|
||
auto pro = pItem->getProperty();
|
||
QString sMe = pro->metaModelName();
|
||
QString sMo = pro->modelName();
|
||
if(sMeta == sMe && sModel == sMo){
|
||
auto pI = dynamic_cast<ElectricSvgItem*>(pItem);
|
||
auto pG = dynamic_cast<ElectricSvgGroup*>(pItem);
|
||
if(pI){
|
||
pI->updateMapSvg(ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg);
|
||
}
|
||
if(pG){
|
||
pG->updateMapSvg(ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
/*********************baseModel**********************/
|
||
|
||
QMap<QUuid,GraphicsBaseModelItem*>& FixedPortsModel::allBaseItems()
|
||
{
|
||
return _baseItem;
|
||
}
|
||
|
||
QVector<Connection> FixedPortsModel::allBaseConnections()
|
||
{
|
||
QVector<Connection> vec;
|
||
for(auto pItem:_baseItem)
|
||
{
|
||
if(pItem->getItemType() == GIT_baseLine)
|
||
{
|
||
auto pLine = dynamic_cast<ElectricBaseModelLineItem*>(pItem);
|
||
if(pLine)
|
||
{
|
||
vec.push_back(pLine->getProperty()->getConnection());
|
||
}
|
||
}
|
||
}
|
||
return vec;
|
||
}
|
||
|
||
QMap<QUuid,QPointF> FixedPortsModel::allBaseNodePos() const
|
||
{
|
||
QMap<QUuid,QPointF> map;
|
||
for(auto pItem:_baseItem)
|
||
{
|
||
if(pItem->getItemType() != GIT_baseLine)
|
||
map.insert(pItem->itemId(),pItem->pos());
|
||
}
|
||
return map;
|
||
}
|
||
|
||
bool FixedPortsModel::addBaseItem(QUuid uuid,GraphicsBaseModelItem* pItem)
|
||
{
|
||
if(_baseItem.contains(uuid))
|
||
return false;
|
||
else
|
||
{
|
||
_baseItem.insert(uuid,pItem);
|
||
return true;
|
||
}
|
||
}
|
||
|
||
BaseModelProperty* FixedPortsModel::addBaseNodeData(QUuid id,int type,QString name,QString metaName,QString bay)
|
||
{
|
||
BaseModelProperty* pData = BasePropertyManager::instance().findBaseEntityData(id); //已存在不不创建
|
||
if(pData != nullptr)
|
||
return pData;
|
||
|
||
BaseModelProperty* item = new BaseModelProperty(this);
|
||
|
||
if(item)
|
||
{
|
||
item->setUuid(id);
|
||
item->setMetaModelName(metaName);
|
||
item->setType(type);
|
||
item->setTag(name);
|
||
item->setName(name);
|
||
if(!bay.isEmpty())
|
||
item->setBay(bay);
|
||
BasePropertyManager::instance().insertBaseEntityData(id,item);
|
||
}
|
||
return item;
|
||
}
|
||
|
||
void FixedPortsModel::showProjectModelSettingDlg(GraphicsBaseModelItem* srcItem)
|
||
{
|
||
if(m_proModelSettingDlg == nullptr)
|
||
{
|
||
m_proModelSettingDlg = new ProjectModelSetting(_widget);
|
||
m_proModelSettingDlg->setController(this);
|
||
}
|
||
m_proModelSettingDlg->showDlg(srcItem);
|
||
}
|
||
|
||
void FixedPortsModel::generateProjectModel(const QString& sPageName,QList<GraphicsBaseModelItem*> lstItem,QList<GraphicsNonStandardItem*> lstOther)
|
||
{
|
||
DrawingPanel* pProPanel = nullptr;
|
||
if(_cavas){
|
||
DiagramInfo info;
|
||
info.id = QUuid::createUuid();
|
||
info.sName = sPageName;
|
||
info.sTag = sPageName;
|
||
info.sBasePageName = _pageName;
|
||
_cavas->onSignal_createDiagram(info);
|
||
pProPanel = _cavas->getPanel(sPageName);
|
||
}
|
||
|
||
for(auto& pBaseItem:lstItem) //先处理连线，递归处理连线连接的item
|
||
{
|
||
BaseModelProperty* pBase = dynamic_cast<BaseModelProperty*>(pBaseItem->getProperty());
|
||
if(pBase->type() == 8){ //电缆
|
||
//QUuid id = QUuid::createUuid();
|
||
QUuid id = pBase->uuid();
|
||
BaseProperty* pData = pProPanel->getModelController()->addNodeData(id,pBase->type(),pBase->name(),pBase->modelName());
|
||
if(pData)
|
||
{
|
||
pData->setDataChanged(true); //数据状态改变
|
||
addProjectItemByBaseData(pProPanel,pBaseItem,pData);
|
||
}
|
||
}
|
||
}
|
||
|
||
QList<BaseProperty*> lstProData;
|
||
QList<QPair<QString,QUuid>> lstItems;
|
||
QMap<QUuid,GraphicsProjectModelItem*> mapItem = pProPanel->getModelController()->allItems(); //根据item获取data
|
||
for(auto& item:mapItem){
|
||
BaseProperty* pPro = dynamic_cast<BaseProperty*>(item->getProperty());
|
||
if(pPro){
|
||
lstProData.append(pPro);
|
||
lstItems.append(qMakePair(pPro->name(),pPro->uuid()));
|
||
}
|
||
}
|
||
|
||
QList<GraphicsBaseItem*> lstBase;
|
||
for(auto &pItem:lstItem){
|
||
GraphicsBaseItem* p = pItem;
|
||
lstBase.append(p);
|
||
}
|
||
|
||
QList<monitorRelationItem> lstFirst;
|
||
for(auto& pBaseItem:lstItem) //首次循环添加母线及独立设备(变压器等)，更新列表显示使用
|
||
{
|
||
BaseModelProperty* pBase = dynamic_cast<BaseModelProperty*>(pBaseItem->getProperty());
|
||
if(pBase->type() == 1){ //母线添加子间隔
|
||
monitorRelationItem info;
|
||
info.item.nEquipType = pBase->type();
|
||
info.item.nCategory = 0;
|
||
info.item.sName = pBase->name();
|
||
info.item.uid = pBase->uuid();
|
||
|
||
for(auto& subPair:pBase->getSubList()){
|
||
monitorRelationSturctItem subStruct;
|
||
|
||
BayProperty* pTargetBay = nullptr;
|
||
for(auto& pOtherItem:lstOther)
|
||
{
|
||
BayProperty* pBay = dynamic_cast<BayProperty*>(pOtherItem->getProperty());
|
||
if(pBay){
|
||
if(pBay->uuid() == subPair.second){ //从所有间隔中找到sublist中的间隔
|
||
pTargetBay = pBay;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if(pTargetBay){
|
||
subStruct.nEquipType = 0;
|
||
subStruct.nCategory = 1;
|
||
subStruct.sName = pTargetBay->tag();
|
||
subStruct.uid = pTargetBay->uuid();
|
||
info.subList.append(subStruct);
|
||
}
|
||
}
|
||
lstFirst.append(info);
|
||
}
|
||
else if(pBase->type() == 15 || pBase->type() == 16){
|
||
monitorRelationItem info;
|
||
info.item.nEquipType = pBase->type();
|
||
info.item.nCategory = 0;
|
||
info.item.sName = pBase->name();
|
||
info.item.uid = pBase->uuid();
|
||
|
||
for(auto& subPair:pBase->getSubList()){
|
||
monitorRelationSturctItem subStruct;
|
||
auto pPro = getItemByUid(lstBase,subPair.second);
|
||
if(pPro){
|
||
subStruct.nEquipType = pPro->type();
|
||
subStruct.nCategory = 0;
|
||
subStruct.sName = pPro->name();
|
||
subStruct.uid = pPro->uuid();
|
||
info.subList.append(subStruct);
|
||
}
|
||
}
|
||
|
||
lstFirst.append(info);
|
||
}
|
||
}
|
||
emit updateCurrentItems(lstFirst,true);
|
||
|
||
QList<monitorRelationItem> lstSecond;
|
||
for(auto& pBaseItem:lstItem) //二次循环添加间隔内设备(更新列表显示使用)
|
||
{
|
||
BaseModelProperty* pBase = dynamic_cast<BaseModelProperty*>(pBaseItem->getProperty());
|
||
if(pBase->type() != 1 && pBase->type() != 15 && pBase->type() != 16){ //设备添加
|
||
monitorRelationItem info;
|
||
info.item.nEquipType = pBase->type();
|
||
info.item.nCategory = 0;
|
||
info.item.sName = pBase->name();
|
||
info.item.uid = pBase->uuid();
|
||
|
||
BayProperty* pTargetBay = nullptr;
|
||
for(auto& pOtherItem:lstOther)
|
||
{
|
||
BayProperty* pBay = dynamic_cast<BayProperty*>(pOtherItem->getProperty());
|
||
if(pBay){
|
||
if(pBay->tag() == pBase->getBay()){ //将bay添加到parent
|
||
info.parent.nEquipType = 0;
|
||
info.parent.nCategory = 1;
|
||
info.parent.sName = pBay->tag();
|
||
info.parent.uid = pBay->uuid();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
lstSecond.append(info);
|
||
}
|
||
}
|
||
emit updateCurrentItems(lstSecond,false);
|
||
|
||
for(auto& pOtherItem:lstOther)
|
||
{
|
||
BayProperty* pBay = dynamic_cast<BayProperty*>(pOtherItem->getProperty());
|
||
if(pBay){
|
||
BayProperty* pData = pProPanel->getModelController()->generateBayData(pBay,lstProData);
|
||
if(pData)
|
||
{
|
||
pData->setSubList(pBay->getSubList());
|
||
pProPanel->getModelController()->addBayByData(pData);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void FixedPortsModel::onWizardFinished(QMap<QUuid,GraphicsBaseModelItem*> mapItem,QList<EditBaseItem*> mapBlock)
|
||
{
|
||
QMap<QUuid,DiagramEditorItemProperty*> mapEditor = BasePropertyManager::instance().getEditorData();
|
||
for(auto& pro:mapEditor){
|
||
if(BasePropertyManager::instance().findBaseEntityData(pro->uuid()) == nullptr){ //拷贝editor数据到basemodel中
|
||
auto pPro = _widget->getModelController()->addBaseNodeData(pro->uuid(),pro->type(),pro->name(),pro->metaModelName(),pro->getBlock());
|
||
pPro->setConnection(pro->getConnection());
|
||
pPro->setGraphicsType(pro->graphicsType());
|
||
}
|
||
}
|
||
//pPanel->getModelController()->addTestData();
|
||
|
||
for(auto pItem:mapItem){
|
||
auto cloneItem = pItem->clone();
|
||
BaseModelProperty* pPro = BasePropertyManager::instance().findBaseEntityData(cloneItem->itemId());
|
||
if(pPro){
|
||
if(pPro->type() == 1){ //母线
|
||
for(auto item:mapBlock){
|
||
auto p = item->getBlockData(); //获取blockitem对应的data
|
||
if(p->getType() == 1){
|
||
DiagramEditorBusBlock* pBus = dynamic_cast<DiagramEditorBusBlock*>(p.data());
|
||
if(pBus){
|
||
QString sBus = pBus->getName();
|
||
if(sBus == pPro->name())
|
||
pPro->setSubList(pBus->getSubList()); //将子列表转移到item
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if(pPro->type() == 15 || pPro->type() == 16){ //变压器
|
||
for(auto item:mapBlock){
|
||
auto p = item->getBlockData(); //获取blockitem对应的data
|
||
if(p->getType() == 3){
|
||
DiagramEditorTransformerBlock* pTrans = dynamic_cast<DiagramEditorTransformerBlock*>(p.data());
|
||
if(pTrans){
|
||
QString sTrans = pTrans->getName();
|
||
if(sTrans == pPro->name())
|
||
pPro->setSubList(pTrans->getSubList()); //将子列表转移到item
|
||
}
|
||
}
|
||
}
|
||
}
|
||
cloneItem->setProperty(pPro);
|
||
_scene->addItem(cloneItem);
|
||
cloneItem->setPos(pItem->pos());
|
||
addBaseItem(cloneItem->itemId(),cloneItem);
|
||
pPro->setDataChanged(true);
|
||
autoSetModelName(cloneItem);
|
||
|
||
if(pPro->type() != 8){
|
||
PowerEntity* pEntity = TopologyManager::instance().findEntity(pPro->uuid().toString(),ModelFunctionType::BaseModel);
|
||
if(pEntity)
|
||
cloneItem->setEntity(pEntity);
|
||
}
|
||
else
|
||
{
|
||
}
|
||
}
|
||
}
|
||
|
||
QList<QGraphicsItem*> items = _scene->items();
|
||
|
||
if (items.isEmpty()) {
|
||
return; // 没有 items 时返回
|
||
}
|
||
|
||
// 计算所有 items 的联合包围盒
|
||
QRectF totalBoundingRect;
|
||
foreach (QGraphicsItem *item, items) {
|
||
totalBoundingRect |= item->sceneBoundingRect();
|
||
}
|
||
|
||
// 计算中心点
|
||
QPointF center = totalBoundingRect.center();
|
||
//_widget->getView()->centerOn(center);
|
||
|
||
//**************间隔*************
|
||
for(auto item:mapBlock){
|
||
auto p = item->getBlockData(); //获取blockitem对应的data
|
||
if(p->getType() == 2){
|
||
DiagramEditorBayBlock* pBay = dynamic_cast<DiagramEditorBayBlock*>(p.data());
|
||
if(pBay){
|
||
QString sBay = pBay->getName();
|
||
auto bayInfo = pBay->getBayInfo();
|
||
auto mapRoute = bayInfo.mapRoute;
|
||
auto mapCompo = bayInfo.mapComponent;
|
||
|
||
QList<DiagramEditorComponentInfo> lstInfo;
|
||
for(auto& route:mapRoute){ //获取路线中使用的设备
|
||
for(auto& compo:route.lstCompo){
|
||
auto info = mapCompo.value(compo.sName);
|
||
|
||
bool exist = false;
|
||
for(auto& inf:lstInfo){
|
||
if(inf == info){
|
||
exist = true;
|
||
break;
|
||
}
|
||
}
|
||
if(!exist){
|
||
lstInfo.append(info);
|
||
}
|
||
}
|
||
}
|
||
|
||
QList<GraphicsBaseItem*> lst;
|
||
for(auto &inf:lstInfo){
|
||
if(_baseItem.contains(inf.uid))
|
||
lst.append(_baseItem.value(inf.uid));
|
||
}
|
||
QRectF rec = calculateItemsBoundingRect(lst);
|
||
ElectricBayItem* pNew = new ElectricBayItem(rec);
|
||
pNew->setItemType(GIT_bay);
|
||
pNew->setText(sBay);
|
||
QString sType;
|
||
switch (pBay->getBayType()) {
|
||
case BayType::busSectionBay:
|
||
sType = QString("分段间隔");
|
||
break;
|
||
case BayType::busCouplerBay:
|
||
sType = QString("母联间隔");
|
||
break;
|
||
case BayType::ptBay:
|
||
sType = QString("PT间隔");
|
||
break;
|
||
case BayType::incomingBay:
|
||
sType = QString("进线间隔");
|
||
break;
|
||
case BayType::outcomingBay:
|
||
sType = QString("出线间隔");
|
||
break;
|
||
case BayType::compensationBay:
|
||
sType = QString("无功补偿间隔");
|
||
break;
|
||
case BayType::bypassBay:
|
||
sType = QString("旁路间隔");
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
QUuid bayId = pBay->getId();
|
||
BayProperty* pBayData = addBayData(bayId,ModelFunctionType::BaseModel);
|
||
pNew->setProperty(pBayData);
|
||
pBayData->setName(sBay);
|
||
pBayData->setTag(sBay);
|
||
pBayData->setType(sType);
|
||
pBayData->setLstFrom(pBay->getBayInfo().lstFrom);
|
||
pBayData->setLstTo(pBay->getBayInfo().lstTo);
|
||
pBayData->setSubList(pBay->getSubList());
|
||
|
||
for(auto &info:lstInfo){
|
||
pBayData->getLstComponent().append(info.uid);
|
||
}
|
||
|
||
addBayItem(bayId,pNew,ModelFunctionType::BaseModel);
|
||
//pModel->addItemsToBay(lst,pNew);
|
||
_scene->addItem(pNew);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void FixedPortsModel::addProjectItemByBaseData(DrawingPanel* pPanel,GraphicsBaseModelItem* pItem,BaseProperty* pPro)
|
||
{
|
||
BaseModelProperty* pBase = dynamic_cast<BaseModelProperty*>(pItem->getProperty());
|
||
if(pBase){
|
||
if(_baseItem.contains(pBase->uuid())){
|
||
GraphicsProjectModelItem* pProItem = nullptr;
|
||
GraphicsBaseModelItem* pBaseItem = _baseItem.value(pBase->uuid());
|
||
pPro->setSourceItemId(pBaseItem->itemId().toString()); //设置被哪个对象生成
|
||
pPro->setMetaModelName(pBase->metaModelName()); //传递基模名
|
||
pPro->setPath(pBase->getBay());
|
||
pPro->setSubList(pBase->getSubList()); //传递sublist
|
||
pPro->setBay(pBase->getBay());
|
||
|
||
QString sMeta = pBase->metaModelName();
|
||
QString sModel = pBase->modelName();
|
||
int type = pBase->graphicsType();
|
||
if(type == GIT_baseNode)
|
||
{
|
||
auto pNode = new ElectricPortItem();
|
||
pProItem = pNode;
|
||
pProItem->setItemType(GIT_node);
|
||
}
|
||
else if(type == GIT_baseBus)
|
||
{
|
||
QByteArray svg;
|
||
if(pBase->getModelProperty().modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[1].icon;
|
||
}
|
||
else{
|
||
svg = pBase->getModelProperty().modelSetting.mapSvg.first();
|
||
}
|
||
ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg["bus"] = svg; //初始化使用的图标
|
||
QRectF rec = pBaseItem->boundingRect();
|
||
auto pBus = new ElectricSvgItemBus(rec.toRect());
|
||
pBus->updateMapSvg(ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg);
|
||
pBus->loadSvg(svg);
|
||
pProItem = pBus;
|
||
pProItem->setItemType(GIT_bus);
|
||
}
|
||
else if(type == GIT_baseBreaker)
|
||
{
|
||
QByteArray svg;
|
||
if(pBase->getModelProperty().modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[3].icon;
|
||
}
|
||
else{
|
||
svg = pBase->getModelProperty().modelSetting.mapSvg.first();
|
||
}
|
||
ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg["cb"] = svg;
|
||
QRectF rec = pBaseItem->boundingRect();
|
||
auto pBreaker = new ElectricSvgItemRect(rec.toRect());
|
||
pBreaker->updateMapSvg(ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg);
|
||
pBreaker->loadSvg(svg);
|
||
pProItem = pBreaker;
|
||
pProItem->setItemType(GIT_itemRect);
|
||
}
|
||
else if(type == GIT_baseCT)
|
||
{
|
||
QByteArray svg;
|
||
if(pBase->getModelProperty().modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[5].icon;
|
||
}
|
||
else{
|
||
svg = pBase->getModelProperty().modelSetting.mapSvg.first();
|
||
}
|
||
ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg["ct"] = svg;
|
||
ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg["zsct"] = svg;
|
||
QRectF rec = pBaseItem->boundingRect();
|
||
auto pCtGroup = new ElectricSvgGroupCT(rec.toRect());
|
||
pCtGroup->updateMapSvg(ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg);
|
||
pCtGroup->setGroupType(1);
|
||
pCtGroup->setLayout(1);
|
||
pProItem = pCtGroup;
|
||
pProItem->setItemType(GIT_ctGroup);
|
||
}
|
||
else if(type == GIT_basePT)
|
||
{
|
||
QByteArray svg;
|
||
if(pBase->getModelProperty().modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[6].icon;
|
||
}
|
||
else{
|
||
svg = pBase->getModelProperty().modelSetting.mapSvg.first();
|
||
}
|
||
ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg["y"] = svg;
|
||
ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg["z"] = svg;
|
||
QRectF rec = pBaseItem->boundingRect();
|
||
auto pPtGroup = new ElectricSvgGroupPT(rec.toRect());
|
||
pPtGroup->updateMapSvg(ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg);
|
||
pPtGroup->setGroupType(1);
|
||
pPtGroup->setLayout(1);
|
||
pProItem = pPtGroup;
|
||
pProItem->setItemType(GIT_ptGroup);
|
||
}
|
||
else if(type == GIT_baseES)
|
||
{
|
||
QByteArray svg;
|
||
if(pBase->getModelProperty().modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[8].icon;
|
||
}
|
||
else{
|
||
svg = pBase->getModelProperty().modelSetting.mapSvg.first();
|
||
}
|
||
ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg["es"] = svg;
|
||
QRectF rec = pBaseItem->boundingRect();
|
||
auto pEs = new ElectricSvgItemES(rec.toRect());
|
||
pEs->updateMapSvg(ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg);
|
||
pEs->loadSvg(svg);
|
||
pProItem = pEs;
|
||
pProItem->setItemType(GIT_ES);
|
||
}
|
||
else if(type == GIT_baseDS)
|
||
{
|
||
QByteArray svg;
|
||
if(pBase->getModelProperty().modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[7].icon;
|
||
}
|
||
else{
|
||
svg = pBase->getModelProperty().modelSetting.mapSvg.first();
|
||
}
|
||
ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg["ds"] = svg;
|
||
QRectF rec = pBaseItem->boundingRect();
|
||
auto pDs = new ElectricSvgItemDS(rec.toRect());
|
||
pDs->loadSvg(svg);
|
||
pProItem = pDs;
|
||
pProItem->setItemType(GIT_DS);
|
||
}
|
||
else if(type == GIT_baseFES)
|
||
{
|
||
QByteArray svg;
|
||
if(pBase->getModelProperty().modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[9].icon;
|
||
}
|
||
else{
|
||
svg = pBase->getModelProperty().modelSetting.mapSvg.first();
|
||
}
|
||
ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg["fes"] = svg;
|
||
QRectF rec = pBaseItem->boundingRect();
|
||
auto pFes = new ElectricSvgItemFES(rec.toRect());
|
||
pFes->loadSvg(svg);
|
||
pProItem = pFes;
|
||
pProItem->setItemType(GIT_FES);
|
||
}
|
||
else if(type == GIT_baseDTEDS)
|
||
{
|
||
QByteArray svg;
|
||
if(pBase->getModelProperty().modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[10].icon;
|
||
}
|
||
else{
|
||
svg = pBase->getModelProperty().modelSetting.mapSvg.first();
|
||
}
|
||
ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg["dteds"] = svg;
|
||
QRectF rec = pBaseItem->boundingRect();
|
||
auto pDteds = new ElectricSvgItemDTEDS(rec.toRect());
|
||
pDteds->loadSvg(svg);
|
||
pProItem = pDteds;
|
||
pProItem->setItemType(GIT_DTEDS);
|
||
}
|
||
else if(type == GIT_basePI)
|
||
{
|
||
QByteArray svg;
|
||
if(pBase->getModelProperty().modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[11].icon;
|
||
}
|
||
else{
|
||
svg = pBase->getModelProperty().modelSetting.mapSvg.first();
|
||
}
|
||
ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg["potential_indicator"] = svg;
|
||
QRectF rec = pBaseItem->boundingRect();
|
||
auto pPi = new ElectricSvgItemPI(rec.toRect());
|
||
pPi->loadSvg(svg);
|
||
pProItem = pPi;
|
||
pProItem->setItemType(GIT_PI);
|
||
}
|
||
else if(type == GIT_baseLightningArrester)
|
||
{
|
||
QByteArray svg;
|
||
if(pBase->getModelProperty().modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[12].icon;
|
||
}
|
||
else{
|
||
svg = pBase->getModelProperty().modelSetting.mapSvg.first();
|
||
}
|
||
ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg["lightning_arrester"] = svg;
|
||
QRectF rec = pBaseItem->boundingRect();
|
||
auto pLa = new ElectricSvgItemLA(rec.toRect());
|
||
pLa->loadSvg(svg);
|
||
pProItem = pLa;
|
||
pProItem->setItemType(GIT_LA);
|
||
}
|
||
else if(type == GIT_baseCableTer)
|
||
{
|
||
QByteArray svg;
|
||
if(pBase->getModelProperty().modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[13].icon;
|
||
}
|
||
else{
|
||
svg = pBase->getModelProperty().modelSetting.mapSvg.first();
|
||
}
|
||
ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg["cable_termination"] = svg;
|
||
QRectF rec = pBaseItem->boundingRect();
|
||
auto pCt = new ElectricSvgItemCableTer(rec.toRect());
|
||
pCt->loadSvg(svg);
|
||
pProItem = pCt;
|
||
pProItem->setItemType(GIT_cableTer);
|
||
}
|
||
else if(type == GIT_baseCableEnd)
|
||
{
|
||
QByteArray svg;
|
||
if(pBase->getModelProperty().modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[14].icon;
|
||
}
|
||
else{
|
||
svg = pBase->getModelProperty().modelSetting.mapSvg.first();
|
||
}
|
||
ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg["cable_end"] = svg;
|
||
QRectF rec = pBaseItem->boundingRect();
|
||
auto pCe = new ElectricSvgItemCableEnd(rec.toRect());
|
||
pCe->loadSvg(svg);
|
||
pProItem = pCe;
|
||
pProItem->setItemType(GIT_cableEnd);
|
||
}
|
||
else if(type == GIT_base2wTransformer)
|
||
{
|
||
QByteArray svg;
|
||
if(pBase->getModelProperty().modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[15].icon;
|
||
}
|
||
else{
|
||
svg = pBase->getModelProperty().modelSetting.mapSvg.first();
|
||
}
|
||
ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg["transformer_2w"] = svg;
|
||
QRectF rec = pBaseItem->boundingRect();
|
||
auto p2w = new ElectricSvgItem2wTransformer(rec.toRect());
|
||
p2w->loadSvg(svg);
|
||
pProItem = p2w;
|
||
pProItem->setItemType(GIT_2wTransformer);
|
||
}
|
||
else if(type == GIT_base3wTransformer)
|
||
{
|
||
QByteArray svg;
|
||
if(pBase->getModelProperty().modelSetting.mapSvg.isEmpty()){
|
||
svg = DataBase::GetInstance()->ModelType()[16].icon;
|
||
}
|
||
else{
|
||
svg = pBase->getModelProperty().modelSetting.mapSvg.first();
|
||
}
|
||
ProjectModelManager::instance().getData()[sMeta][sModel].modelSetting.mapUsedSvg["transformer_3w"] = svg;
|
||
QRectF rec = pBaseItem->boundingRect();
|
||
auto p3w = new ElectricSvgItem3wTransformer(rec.toRect());
|
||
p3w->loadSvg(svg);
|
||
pProItem = p3w;
|
||
pProItem->setItemType(GIT_3wTransformer);
|
||
}
|
||
else if(type == GIT_baseLine)
|
||
{
|
||
pProItem = new ElectricConnectLineItem();
|
||
pProItem->setItemId(pPro->uuid());
|
||
pProItem->setItemType(GIT_link);
|
||
pPanel->getScene()->addItem(pProItem);
|
||
}
|
||
|
||
if(pBase->graphicsType() != GIT_baseLine) //非连接线对象
|
||
{
|
||
if(pProItem){
|
||
PowerEntity* pEntity = TopologyManager::instance().createEntity(EntityType::Component,pPro->uuid().toString(),pBase->name());
|
||
QList<PowerTerminal*> lstBase = TopologyManager::instance().getTerminalsForEntity(pBase->uuid().toString(),ModelFunctionType::BaseModel); //获取基模的逻辑点
|
||
for(auto& baseTer:lstBase)
|
||
{
|
||
QUuid uid = QUuid::createUuid();
|
||
double dPerX = baseTer->getPerX();
|
||
double dPerY = baseTer->getPerY();
|
||
QPointF pRelaPos = baseTer->relativePosition();
|
||
PowerTerminal* proTer = TopologyManager::instance().createTerminal(pEntity->id(),baseTer->type(),"",pRelaPos,uid.toString(),ModelFunctionType::ProjectModel,dPerX,dPerY);
|
||
proTer->setGenerateBy(baseTer->id());
|
||
if(proTer->type() == TerminalType::PowerConnect)
|
||
{
|
||
pProItem->addPort(p_movable,proTer->relativePosition(),proTer->id());
|
||
ItemPort* pPort = pProItem->getPortById(proTer->id());
|
||
pPort->setSourcePortId(baseTer->id());
|
||
}
|
||
else if(proTer->type() == TerminalType::NewTral){
|
||
pProItem->addPort(P_const,proTer->relativePosition(),proTer->id(),T_newTral,PortPos(baseTer->getPortLocate()));
|
||
ItemPort* pPort = pProItem->getPortById(proTer->id());
|
||
pPort->setSourcePortId(baseTer->id());
|
||
}
|
||
else if(proTer->type() == TerminalType::PowerInput || proTer->type() == TerminalType::PowerOutput)
|
||
{
|
||
HandleType typ;
|
||
if(proTer->type() == TerminalType::PowerInput){
|
||
typ = T_lineIn;
|
||
}
|
||
else{
|
||
typ = T_lineOut;
|
||
}
|
||
QPointF pos = proTer->relativePosition();
|
||
PortPos locate = PortPos(baseTer->getPortLocate());
|
||
pProItem->addPort(P_const,pos,proTer->id(),typ,locate,dPerX,dPerY);
|
||
|
||
ItemPort* pPort = pProItem->getPortById(proTer->id());
|
||
pPort->setSourcePortId(baseTer->id());
|
||
}
|
||
}
|
||
|
||
pProItem->setItemId(QUuid(pEntity->id()));
|
||
pProItem->updateHandles();
|
||
pProItem->setPos(pBaseItem->pos());
|
||
pPanel->getScene()->addItem(pProItem);
|
||
pProItem->setProperty(pPro); //绑定模型
|
||
pProItem->updateByProperty(); //使用模型更新自身
|
||
|
||
pPanel->getModelController()->addNodeItem(QUuid(pEntity->id()),pProItem);
|
||
}
|
||
}
|
||
else //连接线对象
|
||
{
|
||
PowerConnection* pCon = TopologyManager::instance().connection(pBase->uuid().toString(),ModelFunctionType::BaseModel);
|
||
if(pCon){
|
||
//基模connect参数
|
||
QString baseFromComponentId = pCon->fromComponent();
|
||
QString baseToComponentId = pCon->toComponent();
|
||
QString baseFromTerId = pCon->fromTerminalId();
|
||
QString baseToTerId = pCon->toTerminalId();
|
||
|
||
QMap<QUuid,BaseProperty*> mapPro = BasePropertyManager::instance().getEntityData();
|
||
bool proFromExist = false; //工程模from对象是否生成
|
||
bool proToExist = false; //工程模to对象是否生成
|
||
|
||
QString proFromItemId;
|
||
QString proToItemId;
|
||
QString proFromTerId;
|
||
QString proToTerId;
|
||
HandleType proFromType;
|
||
PortPos proFromPos;
|
||
HandleType proToType;
|
||
PortPos proToPos;
|
||
for(auto& pPro:mapPro)
|
||
{
|
||
if(pPro->getSourceItemId() == baseFromComponentId){
|
||
proFromExist = true;
|
||
proFromItemId = pPro->uuid().toString();
|
||
continue;
|
||
}
|
||
if(pPro->getSourceItemId() == baseToComponentId){
|
||
proToExist = true;
|
||
proToItemId = pPro->uuid().toString();
|
||
continue;
|
||
}
|
||
}
|
||
|
||
if(!proFromExist) //工程模from对象未生成
|
||
{
|
||
GraphicsBaseModelItem* pFromItem = _baseItem.value(QUuid(baseFromComponentId));
|
||
QUuid id = QUuid::createUuid();
|
||
BaseProperty* pData = pPanel->getModelController()->addNodeData(id,pFromItem->getProperty()->type(),pFromItem->getProperty()->name(),pFromItem->getProperty()->modelName());
|
||
addProjectItemByBaseData(pPanel,pFromItem,pData);
|
||
proFromItemId = id.toString();
|
||
}
|
||
|
||
if(!proToExist) //工程模to对象未生成
|
||
{
|
||
GraphicsBaseModelItem* pToItem = _baseItem.value(QUuid(baseToComponentId));
|
||
QUuid id = QUuid::createUuid();
|
||
BaseProperty* pData = pPanel->getModelController()->addNodeData(id,pToItem->getProperty()->type(),pToItem->getProperty()->name(),pToItem->getProperty()->modelName());
|
||
addProjectItemByBaseData(pPanel,pToItem,pData);
|
||
proToItemId = id.toString();
|
||
}
|
||
|
||
GraphicsProjectModelItem* proFrom = pPanel->getModelController()->nodeItem(QUuid(proFromItemId));
|
||
GraphicsProjectModelItem* proTo = pPanel->getModelController()->nodeItem(QUuid(proToItemId));
|
||
if(proFrom){
|
||
QMap<QString,ItemPort*> mapFrom = proFrom->getPorts();
|
||
for(auto& port:mapFrom){
|
||
if(port->getSourcePortId() == baseFromTerId){
|
||
proFromTerId = port->getId();
|
||
proFromType = port->getType();
|
||
proFromPos = port->portPos();
|
||
auto pLine = dynamic_cast<ElectricConnectLineItem*>(pProItem);
|
||
if(pLine)
|
||
pLine->setStartPoint(port->scenePos());
|
||
}
|
||
}
|
||
}
|
||
|
||
if(proTo){
|
||
QMap<QString,ItemPort*> mapTo = proTo->getPorts();
|
||
for(auto& port:mapTo){
|
||
if(port->getSourcePortId() == baseToTerId){
|
||
proToTerId = port->getId();
|
||
proToType = port->getType();
|
||
proToPos = port->portPos();
|
||
auto pLine = dynamic_cast<ElectricConnectLineItem*>(pProItem);
|
||
if(pLine)
|
||
pLine->setEndPoint(port->scenePos());
|
||
}
|
||
}
|
||
}
|
||
|
||
PowerConnection* pCon = TopologyManager::instance().createConnection(pPro->uuid().toString(),proFromTerId,proToTerId,proFromItemId,proToItemId);
|
||
auto pLine = dynamic_cast<ElectricConnectLineItem*>(pProItem);
|
||
if(pLine)
|
||
pLine->calculatePath();
|
||
pPanel->getModelController()->addNodeItem(pBase->uuid(),pProItem);
|
||
pProItem->setProperty(pPro);
|
||
pPro->setConnection(Connection(QUuid(proFromItemId),QUuid(proFromTerId),proFromType,proFromPos,QUuid(proToItemId),QUuid(proToTerId),proToType,proToPos));
|
||
}
|
||
}
|
||
|
||
if(pProItem){
|
||
pProItem->setModelName(sModel);
|
||
pProItem->setRotation(pItem->rotation());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void FixedPortsModel::addBayItem(QUuid id,ModelFunctionType tpe)
|
||
{
|
||
if(tpe == ModelFunctionType::BaseModel){
|
||
QMap<QUuid,BayProperty*> mapData = BasePropertyManager::instance().getBaseBayData(); //加载的图形必定关联component(todo:完善判断条件，如判断拓扑节点)
|
||
if(mapData.contains(id))
|
||
{
|
||
BayProperty* pro = mapData.value(id);
|
||
if(pro)
|
||
{
|
||
addBayByData(pro,tpe);
|
||
}
|
||
}
|
||
}
|
||
else if(tpe == ModelFunctionType::ProjectModel)
|
||
{
|
||
QMap<QUuid,BayProperty*> mapData = BasePropertyManager::instance().getBayData(); //加载的图形必定关联component(todo:完善判断条件，如判断拓扑节点)
|
||
if(mapData.contains(id))
|
||
{
|
||
BayProperty* pro = mapData.value(id);
|
||
if(pro)
|
||
{
|
||
addBayByData(pro);
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
bool FixedPortsModel::addBayItem(QUuid id,ElectricBayItem* pBay,ModelFunctionType typ)
|
||
{
|
||
if(typ == ModelFunctionType::BaseModel){
|
||
if(_baseBayItem.contains(id))
|
||
return false;
|
||
else
|
||
{
|
||
_baseBayItem.insert(id,pBay);
|
||
return true;
|
||
}
|
||
}
|
||
else if(typ == ModelFunctionType::ProjectModel){
|
||
if(_bayItem.contains(id))
|
||
return false;
|
||
else
|
||
{
|
||
_bayItem.insert(id,pBay);
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
void FixedPortsModel::addItemsToBay(QList<GraphicsBaseItem*> lstItem,ElectricBayItem* pBay)
|
||
{
|
||
if(pBay == nullptr)
|
||
return;
|
||
BayProperty* proBay = dynamic_cast<BayProperty*>(pBay->getProperty());
|
||
if(proBay){
|
||
for(auto& item:lstItem){
|
||
if(item){
|
||
ModelProperty* p = item->getProperty();
|
||
auto lstCom = proBay->getLstComponent();
|
||
if(!lstCom.contains(p->uuid())){
|
||
proBay->getLstComponent().append(p->uuid());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
BayProperty* FixedPortsModel::addBayData(QUuid uuid,ModelFunctionType typ)
|
||
{
|
||
if(typ == ModelFunctionType::BaseModel){
|
||
BayProperty* pData = BasePropertyManager::instance().findBaseBayData(uuid); //已存在不不创建
|
||
if(pData != nullptr)
|
||
return pData;
|
||
|
||
BayProperty* item = new BayProperty();
|
||
|
||
if(item)
|
||
{
|
||
item->setUuid(uuid);
|
||
BasePropertyManager::instance().insertBaseBayData(uuid,item);
|
||
}
|
||
return item;
|
||
}
|
||
else if(typ == ModelFunctionType::ProjectModel){
|
||
BayProperty* pData = BasePropertyManager::instance().findBayData(uuid); //已存在不不创建
|
||
if(pData != nullptr)
|
||
return pData;
|
||
|
||
BayProperty* item = new BayProperty();
|
||
|
||
if(item)
|
||
{
|
||
item->setUuid(uuid);
|
||
BasePropertyManager::instance().insertBayData(uuid,item);
|
||
}
|
||
return item;
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
QMap<QUuid,ElectricBayItem*>& FixedPortsModel::allBayItem()
|
||
{
|
||
return _bayItem;
|
||
}
|
||
|
||
BayProperty* FixedPortsModel::generateBayData(BayProperty* pData,QList<BaseProperty*> lst)
|
||
{
|
||
BayProperty* p = addBayData(pData->uuid());
|
||
p->setTag(pData->tag());
|
||
p->setName(pData->name());
|
||
p->setType(pData->getType());
|
||
p->setVoltage(pData->getVoltage());
|
||
p->setFla(pData->getFla());
|
||
p->setCapacity(pData->getCapacity());
|
||
p->setInService(pData->getInService());
|
||
QList<QUuid> lstCompo = pData->getLstComponent();
|
||
QList<QUuid> lstNewCompo = getCorrespondId(lstCompo,lst); //将基模component替换为工程模component
|
||
p->setLstComponent(lstNewCompo);
|
||
|
||
QList<QUuid> lstFrom = pData->getLstFrom();
|
||
QList<QUuid> lstNewFrom = getCorrespondId(lstFrom,lst);
|
||
p->setLstFrom(lstNewFrom);
|
||
|
||
QList<QUuid> lstTo = pData->getLstTo();
|
||
QList<QUuid> lstNewTo = getCorrespondId(lstTo,lst);
|
||
p->setLstTo(lstNewTo);
|
||
|
||
QList<QUuid> lstProtect = pData->getLstProtect();
|
||
QList<QUuid> lstNewProtect = getCorrespondId(lstProtect,lst);
|
||
p->setLstProtect(lstNewProtect);
|
||
|
||
QList<QUuid> lstFaultRecord = pData->getLstFaultRecord();
|
||
QList<QUuid> lstNewFaultRecord = getCorrespondId(lstFaultRecord,lst);
|
||
p->setLstFaultRecord(lstNewFaultRecord);
|
||
|
||
QList<QUuid> lstDynSense = pData->getLstDynSense();
|
||
QList<QUuid> lstNewDynSense = getCorrespondId(lstDynSense,lst);
|
||
p->setLstDynSense(lstNewDynSense);
|
||
|
||
QList<QUuid> lstStatus = pData->getLstStatus();
|
||
QList<QUuid> lstNewStatus = getCorrespondId(lstStatus,lst);
|
||
p->setLstStatus(lstNewStatus);
|
||
|
||
QList<QUuid> lstInstruct = pData->getLstInstruct();
|
||
QList<QUuid> lstNewInstruct = getCorrespondId(lstInstruct,lst);
|
||
p->setLstInstruct(lstNewInstruct);
|
||
|
||
QList<QUuid> lstEtc = pData->getLstEtc();
|
||
QList<QUuid> lstNewEtc= getCorrespondId(lstEtc,lst);
|
||
p->setLstEtc(lstNewEtc);
|
||
return p;
|
||
}
|
||
|
||
QList<QUuid> FixedPortsModel::getCorrespondId(QList<QUuid> lstCompo,QList<BaseProperty*> lst)
|
||
{
|
||
QList<QUuid> lstNewCompo;
|
||
for(auto& uuid:lstCompo)
|
||
{
|
||
for(auto& basePro:lst)
|
||
{
|
||
if(basePro->getSourceItemId() == uuid.toString()){ //工程模sourceid等于基模存储的componentid，
|
||
lstNewCompo.append(basePro->uuid());
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return lstNewCompo;
|
||
}
|
||
|
||
QRectF FixedPortsModel::calculateItemsBoundingRect(QList<GraphicsBaseItem*> items)
|
||
{
|
||
if (items.isEmpty())
|
||
return QRectF();
|
||
|
||
// 初始化矩形为第一个item的场景边界矩形
|
||
QRectF boundingRect = items.first()->sceneBoundingRect();
|
||
|
||
// 遍历剩余item，扩展矩形以包含所有item
|
||
for (int i = 1; i < items.size(); ++i) {
|
||
QGraphicsItem* item = items.at(i);
|
||
// 确保item在场景中且有效
|
||
if (item && item->scene()) {
|
||
boundingRect = boundingRect.united(item->sceneBoundingRect());
|
||
}
|
||
}
|
||
return boundingRect.adjusted(-10,-10,10,10);
|
||
}
|
||
|
||
void FixedPortsModel::addBayByData(BayProperty* pData,ModelFunctionType typ)
|
||
{
|
||
if(typ == ModelFunctionType::BaseModel){
|
||
QList<GraphicsBaseItem*> items;
|
||
QList<QUuid> lstCompo = pData->getLstComponent();
|
||
for(auto& id:lstCompo){
|
||
if(_baseItem.contains(id)){
|
||
items.append(_baseItem.value(id));
|
||
}
|
||
}
|
||
|
||
QRectF rec = calculateItemsBoundingRect(items);
|
||
auto pBay = new ElectricBayItem(rec);
|
||
pBay->setItemType(GIT_bay);
|
||
pBay->setProperty(pData);
|
||
pBay->setText(pData->name());
|
||
addBayItem(pData->uuid(),pBay,typ);
|
||
getScene()->addItem(pBay);
|
||
}
|
||
else if(typ == ModelFunctionType::ProjectModel){
|
||
QList<GraphicsBaseItem*> items;
|
||
QList<QUuid> lstCompo = pData->getLstComponent();
|
||
for(auto& id:lstCompo){
|
||
if(_nodeItem.contains(id)){
|
||
items.append(_nodeItem.value(id));
|
||
}
|
||
}
|
||
|
||
QRectF rec = calculateItemsBoundingRect(items);
|
||
auto pBay = new ElectricBayItem(rec);
|
||
pBay->setItemType(GIT_bay);
|
||
pBay->setProperty(pData);
|
||
pBay->setText(pData->name());
|
||
addBayItem(pData->uuid(),pBay);
|
||
getScene()->addItem(pBay);
|
||
}
|
||
}
|
||
|
||
void FixedPortsModel::addTestData()
|
||
{
|
||
QUuid breakerId = QUuid::createUuid();
|
||
ElectricBaseModelSvgItem* pBreaker = new ElectricBaseModelSvgItem(QRect(-15, -15, 30, 30));
|
||
pBreaker->setItemId(breakerId);
|
||
pBreaker->setItemType(GIT_baseBreaker);
|
||
QByteArray byte = DataBase::GetInstance()->ModelType()[3].icon;
|
||
pBreaker->loadSvg(byte);
|
||
PowerEntity* pEntityBreaker = TopologyManager::instance().createEntity(EntityType::Component,breakerId.toString(),"断路器1",ModelFunctionType::BaseModel);
|
||
if(pEntityBreaker)
|
||
pBreaker->setEntity(pEntityBreaker);
|
||
BaseModelProperty* pBreakerData = addBaseNodeData(breakerId,3,"断路器1",DataBase::GetInstance()->ModelType()[3].modelType);
|
||
pBreakerData->setGraphicsType(GIT_baseBreaker);
|
||
if(pBreakerData)
|
||
{
|
||
pBreaker->setProperty(pBreakerData);
|
||
pBreaker->initialPortsByDatabase(3);
|
||
createTopoTerminalsByItem(pBreaker,ModelFunctionType::BaseModel);
|
||
pBreakerData->setDataChanged(true); //数据状态改变
|
||
}
|
||
addBaseItem(breakerId,pBreaker);
|
||
_scene->addItem(pBreaker);
|
||
pBreaker->setPos(QPointF(0,50));
|
||
|
||
|
||
QUuid busId = QUuid::createUuid();
|
||
ElectricBaseModelSvgBus* pBus = new ElectricBaseModelSvgBus(QRect(-200, -3, 400, 6));
|
||
pBus->setItemId(busId);
|
||
pBus->setItemType(GIT_baseBus);
|
||
//pBreaker->initialPortsByDatabase();
|
||
QByteArray byte1 = DataBase::GetInstance()->ModelType()[1].icon;
|
||
pBus->loadSvg(byte1);
|
||
//createTopoTerminalsByItem(pBreaker);
|
||
BaseModelProperty* pBusData = addBaseNodeData(busId,1,"母线1",DataBase::GetInstance()->ModelType()[1].modelType);
|
||
pBusData->setGraphicsType(GIT_baseBus);
|
||
if(pBusData)
|
||
{
|
||
pBus->setProperty(pBusData);
|
||
pBusData->setDataChanged(true); //数据状态改变
|
||
}
|
||
PowerEntity* pEntityBus = TopologyManager::instance().createEntity(EntityType::Component,busId.toString(),"母线1",ModelFunctionType::BaseModel);
|
||
if(pEntityBus)
|
||
pBus->setEntity(pEntityBus);
|
||
addBaseItem(busId,pBus);
|
||
_scene->addItem(pBus);
|
||
pBus->setPos(QPointF(0,150));
|
||
|
||
QUuid lineId = QUuid::createUuid();
|
||
ElectricBaseModelLineItem* pLine = new ElectricBaseModelLineItem();
|
||
pLine->setItemId(lineId);
|
||
pLine->setItemType(GIT_baseLine);
|
||
BaseModelProperty* pLineData = addBaseNodeData(lineId,8,"电缆1",DataBase::GetInstance()->ModelType()[4].modelType);
|
||
pLineData->setGraphicsType(GIT_baseLine);
|
||
if(pLineData)
|
||
{
|
||
pLine->setProperty(pLineData);
|
||
pLineData->setDataChanged(true); //数据状态改变
|
||
}
|
||
addBaseItem(lineId,pLine);
|
||
establishConnection(pBreaker,pBus,pLine,ModelFunctionType::BaseModel);
|
||
_scene->addItem(pLine);
|
||
|
||
QList<GraphicsBaseItem*> lst;
|
||
lst.append(pBreaker);
|
||
QRectF rec = calculateItemsBoundingRect(lst);
|
||
ElectricBayItem* pBay = new ElectricBayItem(rec);
|
||
pBay->setItemType(GIT_bay);
|
||
pBay->setText("间隔1");
|
||
QUuid bayId = QUuid::createUuid();
|
||
BayProperty* pBayData = addBayData(bayId);
|
||
pBay->setProperty(pBayData);
|
||
pBayData->setName("间隔1");
|
||
pBayData->setTag("间隔1");
|
||
pBayData->getLstComponent().append(breakerId);
|
||
addBayItem(bayId,pBay);
|
||
addItemsToBay(lst,pBay);
|
||
_scene->addItem(pBay);
|
||
QString s = pageName();
|
||
int a = 1;
|
||
}
|
||
|
||
QJsonObject FixedPortsModel::turnListToJson(QList<QUuid> lst,QString sInerTag,QString sOutTag)
|
||
{
|
||
QJsonObject o;
|
||
QJsonArray arr;
|
||
if(lst.isEmpty())
|
||
return QJsonObject();
|
||
for(auto id:lst)
|
||
{
|
||
QJsonObject obj;
|
||
obj[sInerTag] = id.toString();
|
||
arr.push_back(obj);
|
||
}
|
||
o[sOutTag] = arr;
|
||
return o;
|
||
}
|
||
|
||
QList<QUuid> FixedPortsModel::turnJsonArrToList(QJsonObject object,QString sInner,QString sOut)
|
||
{
|
||
QJsonArray jsonArray = object[sOut].toArray();
|
||
|
||
QList<QUuid> lst;
|
||
for (QJsonValueRef nodeJson : jsonArray)
|
||
{
|
||
QJsonObject node = nodeJson.toObject();
|
||
QUuid uid = QUuid(node[sInner].toString());
|
||
lst.append(uid);
|
||
}
|
||
return lst;
|
||
}
|
||
|
||
void FixedPortsModel::generateMonitor(QString sPage,QList<QPair<QString,QUuid>> lst)
|
||
{
|
||
MonitorPanel* pPanel = nullptr;
|
||
if(_cavas){
|
||
DiagramInfo info;
|
||
info.id = QUuid::createUuid();
|
||
info.sName = sPage;
|
||
info.sTag = sPage;
|
||
info.sBasePageName = _pageName;
|
||
info.parentId = _pEntity->id();
|
||
_cavas->onSignal_createDiagram(info,DiagramMode::DM_run);
|
||
pPanel = _cavas->getMonitorPanel(sPage);
|
||
|
||
QList<QPair<QString,QUuid>> lstCreated;
|
||
for(auto& pair:lst)
|
||
{
|
||
if(_nodeItem.contains(pair.second)){
|
||
auto pItem = _nodeItem.value(pair.second);
|
||
BaseProperty* pPro = dynamic_cast<BaseProperty*>(pItem->getProperty());
|
||
if(pPro){
|
||
auto pNewItem = pItem->clone();
|
||
if(pPro->type() == 8){
|
||
auto pLine = dynamic_cast<ElectricConnectLineItem*>(pNewItem);
|
||
if(pLine)
|
||
pLine->calculatePath();
|
||
}
|
||
else{
|
||
pNewItem->updateItem();
|
||
}
|
||
|
||
if(pNewItem && pPanel){
|
||
pNewItem->setProperty(pPro);
|
||
pNewItem->updateHandles();
|
||
pNewItem->updateByProperty(); //使用模型更新自身
|
||
pPanel->getModelController()->addNodeItem(pPro->uuid(),pNewItem);
|
||
pPanel->getScene()->addItem(pNewItem); //绑定模型
|
||
|
||
lstCreated.append(qMakePair(pPro->name(),pPro->uuid()));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!pPanel->getScene()->items().isEmpty()) {
|
||
QRectF itemsRect = pPanel->getScene()->itemsBoundingRect();
|
||
itemsRect.adjust(-30, -30, 30, 30);
|
||
auto map = _cavas->getMapMonitor();
|
||
if(map.contains(sPage)){
|
||
auto pSubWin = map.value(sPage).second;
|
||
pSubWin->resize(itemsRect.width(),itemsRect.height());
|
||
}
|
||
//pPanel->getScene()->setSceneRect(itemsRect);
|
||
pPanel->getView()->fitInView(itemsRect, Qt::KeepAspectRatio);
|
||
}
|
||
emit pPanel->getModelController()->monitorCreated(_pageName,qMakePair(sPage,info.id.toUuid()));
|
||
emit pPanel->getModelController()->monitorItems(lstCreated);
|
||
}
|
||
}
|