1001 lines
32 KiB
C++
1001 lines
32 KiB
C++
#include "graphicsDataModel/fixedPortsModel.h"
|
||
#include "graphicsItem/graphicsBaseItem.h"
|
||
#include "graphicsItem/electricSvgItemBus.h"
|
||
#include "graphicsItem/electricSvgItemRect.h"
|
||
#include "graphicsItem/electricSvgItemTriangle.h"
|
||
#include "graphicsItem/electricConnectLineItem.h"
|
||
#include "baseModelItem/electricBaseModelLineItem.h"
|
||
#include "baseModelItem/electricBaseModelSvgItem.h"
|
||
#include "baseModelItem/electricBaseModelSvgBus.h"
|
||
#include "baseModelItem/electricBaseModelLineItem.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 "baseProperty.h"
|
||
#include "projectModelSetting.h"
|
||
|
||
bool FixedPortsModel::_dataInitialised = false;
|
||
|
||
FixedPortsModel::FixedPortsModel(PowerEntity* pEntity)
|
||
:_scene(nullptr)
|
||
,_widget(nullptr)
|
||
,_Interface(nullptr)
|
||
,_pEntity(pEntity)
|
||
,m_proModelSettingDlg(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,QPointF> FixedPortsModel::allNodePos() const
|
||
{
|
||
QMap<QUuid,QPointF> map;
|
||
for(auto pItem:_nodeItem)
|
||
{
|
||
if(pItem->getItemType() != GIT_link)
|
||
map.insert(pItem->itemId(),pItem->pos());
|
||
}
|
||
return map;
|
||
}
|
||
|
||
QVector<Connection> FixedPortsModel::allConnections()
|
||
{
|
||
QVector<Connection> vec;
|
||
for(auto pItem:_nodeItem)
|
||
{
|
||
if(pItem->getItemType() == GIT_link)
|
||
{
|
||
auto pLine = dynamic_cast<ElectricConnectLineItem*>(pItem);
|
||
if(pLine)
|
||
{
|
||
vec.push_back(pLine->getConnection());
|
||
}
|
||
}
|
||
}
|
||
return vec;
|
||
}
|
||
|
||
QMap<QUuid,GraphicsProjectModelItem*>& FixedPortsModel::allItems()
|
||
{
|
||
return _nodeItem;
|
||
}
|
||
|
||
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;
|
||
}
|
||
}
|
||
|
||
void FixedPortsModel::addNodeItem(QUuid id/*,int type*/,QPointF pos)
|
||
{
|
||
//todo:load图形时必有拓扑实体，关联到对应的entity
|
||
BaseProperty* pro = nullptr;
|
||
GraphicsProjectModelItem* item = nullptr;
|
||
QMap<QUuid,BaseProperty*> mapData = BasePropertyManager::instance().getEntityData(); //加载的图形必定关联component(todo:完善判断条件，如判断拓扑节点)
|
||
if(mapData.contains(id))
|
||
{
|
||
pro = mapData[id];
|
||
if(pro)
|
||
{
|
||
int type = pro->type();
|
||
if(type == GIT_itemTri)
|
||
{
|
||
item = new ElectricSvgItemTriangle(QRect(-15, -15, 30, 30));
|
||
item->setItemType(GIT_itemTri);
|
||
}
|
||
else if(type == GIT_itemRect)
|
||
{
|
||
item = new ElectricSvgItemRect(QRect(-15, -15, 30, 30),false);
|
||
item->setItemType(GIT_itemRect);
|
||
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();
|
||
HandleType tye = HandleType(portObj["portType"].toInt());
|
||
PortPos locate = PortPos(portObj["locate"].toInt());
|
||
item->addPort(P_const,QPointF(x,y),portId,tye,locate);
|
||
}
|
||
}
|
||
else if(type == GIT_bus)
|
||
{
|
||
item = new ElectricSvgItemBus(QRect(-100, -3, 200, 6));
|
||
item->setItemType(GIT_bus);
|
||
|
||
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);
|
||
}
|
||
}
|
||
if(item)
|
||
{
|
||
item->setItemId(id);
|
||
item->editShape(0, pos);
|
||
item->setPos(pos);
|
||
//item->setSelected(true);
|
||
_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);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
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(this);
|
||
//todo:关联到对应data
|
||
|
||
if(item)
|
||
{
|
||
item->setUuid(id);
|
||
item->setModelName(modelName);
|
||
item->setType(type);
|
||
item->setTag(name);
|
||
item->setName(name);
|
||
BasePropertyManager::instance().insertEntityData(id,item);
|
||
}
|
||
return item;
|
||
}
|
||
|
||
void FixedPortsModel::loadNodeDataFromDataBase()
|
||
{
|
||
if(!_dataInitialised)
|
||
{
|
||
QList<componentInfo> lst= DataBase::GetInstance()->getAllComponents();
|
||
for(auto &info:lst)
|
||
{
|
||
BaseProperty* pData = addNodeData(info.uuid,info.type,info.name,info.modelName);
|
||
pData->setTag(info.tag);
|
||
pData->setName(info.name);
|
||
pData->setPath(info.nspath);
|
||
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);
|
||
|
||
PowerEntity* pEntity = TopologyManager::instance().createEntity(EntityType::Component,info.uuid.toString(),info.name); //首先load所有data和entity，全局唯一
|
||
if(pEntity){
|
||
createTopoTerminalsByData(pEntity,info.context);
|
||
}
|
||
}
|
||
|
||
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());
|
||
}
|
||
_dataInitialised = true;
|
||
}
|
||
else
|
||
{
|
||
//for(auto p:_nodeData)
|
||
{
|
||
int a = 1;
|
||
}
|
||
}
|
||
}
|
||
|
||
void FixedPortsModel::addConnectLline(QUuid srcId,QUuid destId,QUuid srcPort,QUuid destPort)
|
||
{
|
||
GraphicsProjectModelItem* src = _nodeItem[srcId];
|
||
GraphicsProjectModelItem* dest = _nodeItem[destId];
|
||
if(src && dest)
|
||
{
|
||
ElectricConnectLineItem* pItem = new ElectricConnectLineItem();
|
||
pItem->setItemId(QUuid::createUuid());
|
||
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(dest->getItemType() == GIT_bus) //母线动态创建port
|
||
{
|
||
ptDest = dest->getPortById(destPort.toString());
|
||
pItem->setEndPoint(ptDest->scenePos());
|
||
}
|
||
else
|
||
{
|
||
ptDest = dest->getPortById(destPort.toString());
|
||
pItem->setEndPoint(ptDest->scenePos());
|
||
}*/
|
||
|
||
if(ptDest != nullptr)
|
||
{
|
||
HandleType destType = ptDest->getType();
|
||
PortPos destPos = ptDest->portPos();
|
||
|
||
pItem->calculatePath();
|
||
pItem->setConnection(Connection(srcId,srcPort,srcType,srcPos,destId,destPort,destType,destPos));
|
||
ptDest->setConnect(pItem);
|
||
|
||
addNodeItem(pItem->itemId(),pItem);
|
||
}
|
||
}
|
||
}
|
||
|
||
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;
|
||
}
|
||
}
|
||
|
||
QVariant FixedPortsModel::nodeData(QUuid nodeId, NodeRole role) const
|
||
{
|
||
QVariant result;
|
||
switch(role)
|
||
{
|
||
case NodeRole::Position:
|
||
result = _nodeItem[nodeId]->pos();
|
||
break;
|
||
}
|
||
|
||
/*auto it = _models.find(nodeId);
|
||
if (it == _models.end())
|
||
return result;
|
||
|
||
auto &model = *it;
|
||
|
||
switch (role) {
|
||
case NodeRole::Type:
|
||
result = model->name();
|
||
break;
|
||
|
||
case NodeRole::Position:
|
||
result = _nodeGeometryData[nodeId].pos;
|
||
break;
|
||
|
||
case NodeRole::Size:
|
||
result = _nodeGeometryData[nodeId].size;
|
||
break;
|
||
|
||
case NodeRole::CaptionVisible:
|
||
result = model->captionVisible();
|
||
break;
|
||
|
||
case NodeRole::Caption:
|
||
result = model->caption();
|
||
break;
|
||
|
||
case NodeRole::Style: {
|
||
//auto style = StyleCollection::nodeStyle();
|
||
//result = style.toJson().toVariantMap();
|
||
} break;
|
||
|
||
case NodeRole::InternalData: {
|
||
QJsonObject nodeJson;
|
||
|
||
//nodeJson["internal-data"] = _models[nodeId]->save();
|
||
|
||
result = nodeJson.toVariantMap();
|
||
break;
|
||
}
|
||
|
||
case NodeRole::InPortCount:
|
||
result = model->nPorts(PortType::In);
|
||
break;
|
||
|
||
case NodeRole::OutPortCount:
|
||
result = model->nPorts(PortType::Out);
|
||
break;
|
||
|
||
case NodeRole::Widget: {
|
||
auto w = model->embeddedWidget();
|
||
result = QVariant::fromValue(w);
|
||
} break;
|
||
}*/
|
||
|
||
return result;
|
||
}
|
||
|
||
/*QJsonObject FixedPortsModel::saveNode(QUuid const nodeId) const
|
||
{
|
||
QJsonObject nodeJson;
|
||
|
||
nodeJson["id"] = nodeId.toString();
|
||
|
||
nodeJson["type"] = _nodeItem[nodeId]->getItemType();
|
||
|
||
{
|
||
QPointF const pos = nodeData(nodeId, NodeRole::Position).value<QPointF>();
|
||
|
||
QJsonObject posJson;
|
||
posJson["x"] = pos.x();
|
||
posJson["y"] = pos.y();
|
||
nodeJson["position"] = posJson;
|
||
}
|
||
|
||
return nodeJson;
|
||
}*/
|
||
|
||
void FixedPortsModel::saveNode(int nPageId)
|
||
{
|
||
QMap<QUuid,BaseProperty*> mapData = BasePropertyManager::instance().getEntityData();
|
||
for(auto &pData:mapData)
|
||
{
|
||
if(pData->prepareDelete())
|
||
{
|
||
DataBase::GetInstance()->deleteComponent(pData->uuid().toString());
|
||
continue;
|
||
}
|
||
if(pData->dataChanged())
|
||
{
|
||
bool exist = DataBase::GetInstance()->componentExist(pData->uuid().toString());
|
||
VariableProperty* pVariable = dynamic_cast<VariableProperty*>(pData);
|
||
if(pVariable)
|
||
{
|
||
modelDataInfo dataInfo = pVariable->getPropertyValue();
|
||
if(exist) //已存在更新
|
||
{
|
||
DataBase::GetInstance()->updateComponent(pData->uuid(),pData->tag(),pData->name(),pData->context());
|
||
for(auto &val:dataInfo.groupInfo)
|
||
{
|
||
DataBase::GetInstance()->updateDynamicProperty(pData->uuid(),val);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
DataBase::GetInstance()->insertComponent(pData->uuid(),pData->modelName(),pData->path(),pData->tag(),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)
|
||
{
|
||
DataBase::GetInstance()->insertDynamicProperty(pData->uuid(),val);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//todo:增加判断，只在设置模式保存连接关系
|
||
QVector<Connection> vecCon = allConnections(); //保存当前页面中的连接关系
|
||
for(auto &con:vecCon)
|
||
{
|
||
QString fromPin = con.nSrcPortId.toString();
|
||
QString toPin = con.nDestPortId.toString();
|
||
QJsonObject context;
|
||
context["from_pin"] = fromPin;
|
||
context["to_pin"] = toPin;
|
||
PowerConnection* pCon = TopologyManager::instance().connection(fromPin,toPin);
|
||
if(pCon)
|
||
{
|
||
DataState state = pCon->state();
|
||
switch (state) {
|
||
case DataState::unchanged:
|
||
break;
|
||
case DataState::prepareDelete:
|
||
DataBase::GetInstance()->deleteTopologic(con.nSrcPortId,con.nDestPortId);
|
||
TopologyManager::instance().removeConnection(pCon->id());
|
||
break;
|
||
case DataState::changed:
|
||
DataBase::GetInstance()->insertTopologic(con.nSrcNodeId,con.nDestNodeId,context,0,"",0);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
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::startHttpRequest()
|
||
{
|
||
if(_timer)
|
||
{
|
||
_timer->setInterval(1000);
|
||
_timer->start();
|
||
}
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
template<typename TypeLine> void FixedPortsModel::establishConnection(GraphicsBaseItem* pSrc,GraphicsBaseItem* pDest,TypeLine* pItem)
|
||
{
|
||
ItemPort* pSrcPort = nullptr;
|
||
ItemPort* pDestPort = nullptr;
|
||
if(pSrc->getItemType() == GIT_baseBus)
|
||
{
|
||
int index = pSrc->addPort(p_movable,pSrc->mapFromScene(calculateBusPortPos(pSrc,pDest)));
|
||
createTopoTerminalsByItem(pSrc,ModelFunctionType::BaseModel);
|
||
pSrcPort = pSrc->getPortPtr(index);
|
||
|
||
QMap<QString,ItemPort*> mapPorts = pDest->getPorts();
|
||
|
||
for(auto& port:mapPorts)
|
||
{
|
||
if(port->getType() == T_lineIn)
|
||
{
|
||
pDestPort = port;
|
||
break;
|
||
}
|
||
}
|
||
|
||
}
|
||
else if(pDest->getItemType() == GIT_baseBus)
|
||
{
|
||
int index = pDest->addPort(p_movable,pDest->mapFromScene(calculateBusPortPos(pDest,pSrc)));
|
||
createTopoTerminalsByItem(pDest,ModelFunctionType::BaseModel);
|
||
pDestPort = pDest->getPortPtr(index);
|
||
|
||
QMap<QString,ItemPort*> mapPorts = pSrc->getPorts();
|
||
|
||
for(auto& port:mapPorts)
|
||
{
|
||
if(port->getType() == T_lineOut)
|
||
{
|
||
pSrcPort = port;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
QMap<QString,ItemPort*> mapSrc = pSrc->getPorts();
|
||
pSrcPort = nullptr;
|
||
for(auto& port:mapSrc)
|
||
{
|
||
if(port->getType() == T_lineOut)
|
||
{
|
||
pSrcPort = port;
|
||
break;
|
||
}
|
||
}
|
||
|
||
QMap<QString,ItemPort*> mapDest = pDest->getPorts();
|
||
pDestPort = nullptr;
|
||
for(auto& port:mapDest)
|
||
{
|
||
if(port->getType() == T_lineIn)
|
||
{
|
||
pDestPort = port;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if(pSrcPort && pDestPort)
|
||
{
|
||
QPointF srcPortPos = pSrcPort->scenePos();
|
||
QPointF destPortPos = pDestPort->scenePos();
|
||
pItem->setStartPoint(srcPortPos);
|
||
pItem->setEndPoint(destPortPos);
|
||
pItem->calculatePath();
|
||
|
||
PowerConnection* pCon = TopologyManager::instance().createConnection(pItem->itemId().toString(),pSrcPort->getId(),pDestPort->getId(),pSrc->itemId().toString(),pDest->itemId().toString(),ModelFunctionType::BaseModel); //创建拓扑连接(逻辑)
|
||
if(pCon)
|
||
pCon->setState(DataState::changed);
|
||
pItem->setConnection(Connection(pSrc->itemId(),QUuid(pSrcPort->getId()),pSrcPort->getType(),pSrcPort->portPos(),pDest->itemId(),QUuid(pDestPort->getId()),pDestPort->getType(),pDestPort->portPos()));
|
||
}
|
||
}
|
||
|
||
QPointF FixedPortsModel::calculateBusPortPos(GraphicsBaseItem* pBus,GraphicsBaseItem* item)
|
||
{
|
||
return QPointF(item->pos().x(),pBus->pos().y());
|
||
}
|
||
|
||
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->loadGroupButton(info.groupInfo);
|
||
_modelStateInfo[sModel]._PropertyDlg = dlg;
|
||
}
|
||
}
|
||
}
|
||
|
||
ConfigurationDiagram* FixedPortsModel::getTopologyDiagram()
|
||
{
|
||
return dynamic_cast<ConfigurationDiagram*>(_pEntity);
|
||
}
|
||
|
||
void FixedPortsModel::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;
|
||
}
|
||
TopologyManager::instance().createTerminal(pEntity->id(),terType,"",port->pos(),port->getId(),funType);
|
||
}
|
||
}
|
||
}
|
||
|
||
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;
|
||
default:
|
||
break;
|
||
}
|
||
TopologyManager::instance().createTerminal(pParent->id(),terType,"",QPointF(x,y),portId,funType);
|
||
}
|
||
}
|
||
|
||
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);
|
||
}
|
||
/*********************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->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)
|
||
{
|
||
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);
|
||
BasePropertyManager::instance().insertBaseEntityData(id,item);
|
||
}
|
||
return item;
|
||
}
|
||
|
||
void FixedPortsModel::showProjectModelSettingDlg(GraphicsBaseModelItem* srcItem)
|
||
{
|
||
if(m_proModelSettingDlg == nullptr)
|
||
{
|
||
m_proModelSettingDlg = new ProjectModelSetting(_widget);
|
||
}
|
||
m_proModelSettingDlg->showDlg(srcItem);
|
||
}
|
||
|
||
void FixedPortsModel::generateProjectModel(const QString& sPageName,QList<BaseModelProperty*> lstData)
|
||
{
|
||
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& pBase:lstData)
|
||
{
|
||
QUuid id = QUuid::createUuid();
|
||
BaseProperty* pData = addNodeData(id,pBase->type(),pBase->name(),pBase->modelName());
|
||
if(pData)
|
||
{
|
||
//pitem->setProperty(pData);
|
||
pData->setDataChanged(true); //数据状态改变
|
||
|
||
PowerEntity* pEntity = TopologyManager::instance().createEntity(EntityType::Component,id.toString(),pBase->name());
|
||
//if(pEntity)
|
||
//pitem->setEntity(pEntity);
|
||
//createTopoTerminalsByItem(pitem); //创建item对象的逻辑接线点
|
||
}
|
||
}
|
||
}
|
||
|
||
void FixedPortsModel::addTestData()
|
||
{
|
||
QUuid breakerId = QUuid::createUuid();
|
||
ElectricBaseModelSvgItem* pBreaker = new ElectricBaseModelSvgItem(QRect(-15, -15, 30, 30));
|
||
pBreaker->setItemId(breakerId);
|
||
pBreaker->setItemType(GIT_baseBreaker);
|
||
pBreaker->setInnerType(3);
|
||
pBreaker->initialPortsByDatabase();
|
||
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);
|
||
createTopoTerminalsByItem(pBreaker,ModelFunctionType::BaseModel);
|
||
BaseModelProperty* pBreakerData = addBaseNodeData(breakerId,3,"断路器1",DataBase::GetInstance()->ModelType()[3].modelType);
|
||
if(pBreakerData)
|
||
{
|
||
pBreaker->setProperty(pBreakerData);
|
||
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);
|
||
pBus->setInnerType(1);
|
||
//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);
|
||
if(pBusData)
|
||
{
|
||
pBus->setProperty(pBusData);
|
||
pBusData->setDataChanged(true); //数据状态改变
|
||
}
|
||
PowerEntity* pEntityBus = TopologyManager::instance().createEntity(EntityType::Component,breakerId.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);
|
||
pLine->setInnerType(4);
|
||
BaseModelProperty* pLineData = addBaseNodeData(lineId,4,"电缆1",DataBase::GetInstance()->ModelType()[4].modelType);
|
||
if(pLineData)
|
||
{
|
||
pLine->setProperty(pLineData);
|
||
pLineData->setDataChanged(true); //数据状态改变
|
||
}
|
||
addBaseItem(lineId,pLine);
|
||
establishConnection(pBreaker,pBus,pLine);
|
||
_scene->addItem(pLine);
|
||
}
|