CL-Softwares
/
DiagramDesigner
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

expand data structure TG-16 in-progress

This commit is contained in:
baiYue 2025-06-13 19:00:05 +08:00
parent 9f38ffd14d
commit 2b4c815b26
48 changed files with 1674 additions and 978 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
common/include/baseProperty.h
View File

@ -5,23 +5,64 @@
#include <QJsonObject>
#include "global.h"
class BaseProperty:public QObject //属性类,存放电路元件属性
class AbstractProperty:public QObject //抽象属性类
{
Q_OBJECT
public:
AbstractProperty(QObject* parent);
virtual ~AbstractProperty();
virtual void setUuid(QUuid id) {uUid = id;}
virtual QUuid uuid() const {return uUid;}
virtual void setTag(QString s){sTag = s;}
virtual QString tag() const {return sTag;}
virtual void setName(QString s){sName = s;}
virtual QString name() const {return sName;}
virtual void setContext(QJsonObject j){jContext = j;}
virtual QJsonObject context() const {return jContext;}
protected:
QUuid uUid;
QString sTag;
QString sName;
QJsonObject jContext; //存放port信息
};
class ModelProperty:public AbstractProperty //模型基类
{
Q_OBJECT
public:
ModelProperty(QObject* parent);
virtual ~ModelProperty();
virtual void setType(int n) {nType = n;}
virtual int type() const {return nType;}
virtual void setModelName(QString sName) {sModelName = sName;}
virtual QString modelName() const {return sModelName;}
virtual void setMetaModelName(QString sName) {sMetaName = sName;}
virtual QString metaModelName() const {return sMetaName;}
virtual void notifyUpdate(){emit updateData();}
signals:
void updateData(); //通知数据拥有者更新
protected:
int nType; //设备类型
QString sModelName; //模型名
QString sMetaName; //元模型名
};
class BaseModelProperty:public ModelProperty //图像基模属性
{
Q_OBJECT
public:
BaseModelProperty(QObject* parent);
virtual ~BaseModelProperty();
};
class BaseProperty:public ModelProperty //图像工程模模属性类,存放电路元件属性
{
Q_OBJECT
public:
BaseProperty(QObject* parent);
virtual ~BaseProperty();
void setUuid(QUuid id) {uUid = id;}
QUuid uuid() const {return uUid;}
void setModelName(QString sName) {sModelName = sName;}
QString modelName() const {return sModelName;}
void setType(int n) {nType = n;}
int type() const {return nType;}
void setTag(QString s){sTag = s;}
QString tag() const {return sTag;}
void setName(QString s){sName = s;}
QString name() const {return sName;}
void setPath(QString s){sPath = s;}
QString path() const {return sPath;}
void setDescription(QString s) {sDescription = s;}
@ -36,8 +77,6 @@ public:
QJsonObject connectedBus() const {return jConnectedBus;}
void setLabel(QJsonObject j){jLabel = j;}
QJsonObject label() const {return jLabel;}
void setContext(QJsonObject j){jContext = j;}
QJsonObject context() const {return jContext;}
void setGrid(const QString& s) {sGrid = s;}
QString grid() const {return sGrid;}
void setZone(const QString& s) {sZone = s;}
@ -49,15 +88,7 @@ public:
bool prepareDelete() const {return _prepareDelete;}
void setDataChanged(bool b) {_dataChanged = b;} //数据变换标签
bool dataChanged() const {return _dataChanged;}
void notifyUpdate(){emit updateData();}
signals:
void updateData(); //通知数据拥有者更新
protected:
QUuid uUid;
QString sModelName; //模型名
int nType; //设备类型
QString sTag;
QString sName;
QString sPath;
QString sDescription;
QString sGrid;
@ -68,7 +99,6 @@ protected:
int nStatus;
QJsonObject jConnectedBus;
QJsonObject jLabel;
QJsonObject jContext; //存放port信息
bool _dataChanged; //数据状态,为真则写入库
bool _prepareDelete; //状态，为真准备删除

130
common/include/global.h
View File

@ -28,7 +28,11 @@ enum GraphicsItemType
GIT_bus = QGraphicsItem::UserType + 50,
GIT_itemRect = QGraphicsItem::UserType + 51,
GIT_itemTri = QGraphicsItem::UserType + 52,
GIT_link= QGraphicsItem::UserType + 53
GIT_link= QGraphicsItem::UserType + 53,
//======================================
GIT_baseBus = QGraphicsItem::UserType + 200,
GIT_baseLine = QGraphicsItem::UserType + 201,
GIT_baseBreaker = QGraphicsItem::UserType + 202
};
enum AbstractItemType //工程模关联的对象类型
@ -37,6 +41,12 @@ enum AbstractItemType //工程模关联的对象类型
AIT_bus
};
enum class ModelFunctionType //模型函数的类型
{
ProjectModel = 0,
BaseModel
};
class corresbondItem //类型关联函数
{
public:
@ -47,7 +57,8 @@ enum DiagramMode //组态图模式
{
DM_edit = 0,
DM_run,
DM_academic
DM_academic,
DM_baseModel
};
enum VariantIcon //变种图
@ -181,6 +192,16 @@ struct projectManager //工程模管理类
QJsonObject checkState; //属性选择状态
};
/*struct baseModelSelectManger
{
int id = 0;
QUuid componentId;
QString componentTag;
int pageId;
int version;
QJsonObject checkState;
};*/
enum projectState
{
Err = -1,
@ -342,6 +363,111 @@ enum class DiagramEditorStructType
};
//==================组态图使用=====================
enum HandleType
{
T_none = 0,
T_resize, //调整大小
T_rotate, //旋转
T_editShape, //编辑形状
T_text, //文本
T_lineIn, //入线口
T_lineOut, //出线口
T_lineInOut //双端线
};
enum HandleTag
{
H_none = 0,
H_leftTop,
H_top,
H_rightTop,
H_right,
H_rightBottom,
H_bottom,
H_leftBottom,
H_left, //8
H_rotate_leftTop,
H_rotate_rightTop,
H_rotate_rightBottom,
H_rotate_leftBottom, //12
H_edit,
H_textCaption = 40, //标题文本
H_textCurrent, //电流
h_textVoltage, //电压
H_connect = 50 //连接操作点从50开始，前面预留
};
enum PortPos
{
P_top = 0,
P_down,
P_left,
P_right
};
struct Connection
{
QUuid nSrcNodeId;
QUuid nSrcPortId;
HandleType srcType;
PortPos srcPos;
QUuid nDestNodeId;
QUuid nDestPortId;
HandleType destType;
PortPos destPos;
Connection()
{
srcType = T_none;
srcPos = P_top;
destType = T_none;
destPos = P_top;
}
Connection(const Connection& obj)
{
nSrcNodeId = obj.nSrcNodeId;
nSrcPortId = obj.nSrcPortId;
srcType = obj.srcType;
srcPos = obj.srcPos;
nDestNodeId = obj.nDestNodeId;
nDestPortId = obj.nDestPortId;
destType = obj.destType;
destPos = obj.destPos;
}
Connection(QUuid nSNI,QUuid nSPI,HandleType sT,PortPos sPOS,QUuid nDNI,QUuid nDPI,HandleType dT,PortPos dPOS)
{
nSrcNodeId = nSNI;
nSrcPortId = nSPI;
srcType = sT;
srcPos = sPOS;
nDestNodeId = nDNI;
nDestPortId = nDPI;
destType = dT;
destPos = dPOS;
}
bool operator==(const Connection& obj)
{
return ((obj.nSrcNodeId == nSrcNodeId)&&(obj.nSrcPortId == nSrcPortId)&&(obj.srcType == srcType)&&(obj.nDestNodeId == nDestNodeId)&&(obj.nDestPortId == nDestPortId)&&(obj.destType == destType));
}
Connection& operator=(const Connection& obj)
{
if(*this == obj)
return *this;
nSrcNodeId = obj.nSrcNodeId;
nSrcPortId = obj.nSrcPortId;
srcType = obj.srcType;
srcPos = obj.srcPos;
nDestNodeId = obj.nDestNodeId;
nDestPortId = obj.nDestPortId;
destType = obj.destType;
destPos = obj.destPos;
return *this;
}
};
// 基础实体类型（电力元素或组态图）
enum class EntityType {
Grid,

36
common/source/baseProperty.cpp
View File

@ -1,10 +1,42 @@
#include "baseProperty.h"
#include "dataManager.h"
/****************************属性****************************/
AbstractProperty::AbstractProperty(QObject* parent)
: QObject(parent)
{
}
AbstractProperty::~AbstractProperty()
{
}
/******************************模型基类*******************************/
ModelProperty::ModelProperty(QObject* parent)
:AbstractProperty(parent)
{
}
ModelProperty::~ModelProperty()
{
}
/*****************************基模*********************************/
BaseModelProperty::BaseModelProperty(QObject* parent)
: ModelProperty(parent)
{
}
BaseModelProperty::~BaseModelProperty()
{
}
/****************************工程模****************************/
BaseProperty::BaseProperty(QObject* parent)
: QObject(parent)
: ModelProperty(parent)
{
nType = 0; //设备类型
bInService = true;

6
diagramCavas/CMakeLists.txt
View File

@ -42,6 +42,9 @@ set(DIAGRAMCAVAS_HEADER_FILES
include/graphicsItem/handleText.h
include/graphicsItem/itemControlHandle.h
include/graphicsItem/itemPort.h
include/baseModelItem/electricBaseModelSvgItem.h
include/baseModelItem/electricBaseModelLineItem.h
include/baseModelItem/electricBaseModelSvgBus.h
include/util/baseSelector.h
include/util/connectingSelector.h
include/util/creatingSelector.h
@ -101,6 +104,9 @@ set(DIAGRAMCAVAS_SOURCE_FILES
source/graphicsItem/handleText.cpp
source/graphicsItem/itemControlHandle.cpp
source/graphicsItem/itemPort.cpp
source/baseModelItem/electricBaseModelSvgItem.cpp
source/baseModelItem/electricBaseModelLineItem.cpp
source/baseModelItem/electricBaseModelSvgBus.cpp
source/util/baseSelector.cpp
source/util/connectingSelector.cpp
source/util/creatingSelector.cpp

39
diagramCavas/include/baseModelItem/electricBaseModelLineItem.h Normal file
View File

@ -0,0 +1,39 @@
#ifndef ELECTRIBASEMODELLINEITEM_H
#define ELECTRIBASEMODELLINEITEM_H
#include <QPainterPath>
#include <QUuid>
#include "graphicsItem/graphicsBaseItem.h"
//基模导线
class ElectricBaseModelLineItem : public GraphicsBaseModelItem
{
public:
ElectricBaseModelLineItem(QGraphicsItem *parent = 0);
virtual ~ElectricBaseModelLineItem();
void setStartPoint(const QPointF& p);
void setEndPoint(const QPointF& p);
QPainterPath getPoints(void) const { return m_points; }
void calculatePath();
void resetCurLine(){_curLine = QPoint();}
void setConnection(Connection con){m_connectState = con;}
Connection getConnection() const {return m_connectState;}
protected:
virtual QPainterPath shape() const override;
virtual QRectF boundingRect() const override;
virtual void paint(QPainter*, const QStyleOptionGraphicsItem*, QWidget*) override;
private:
Connection m_connectState;
QPainterPath m_points;
QPainterPath m_pointsBoundingRect; //包裹点的矩形集合
QList<QPointF> m_lstPoints;
QPoint _curLine; //参数1用点序号表示的当前线段起始点,参数2表示线段方向
};
#endif

22
diagramCavas/include/baseModelItem/electricBaseModelSvgBus.h Normal file
View File

@ -0,0 +1,22 @@
#ifndef ELECTRICBASEMODELSVGBUS_H
#define ELECTRICBASEMODELSVGBUS_H
#include "baseModelItem/electricBaseModelSvgItem.h"
class ElectricBaseModelSvgBus :public ElectricBaseModelSvgItem
{
Q_OBJECT
public:
ElectricBaseModelSvgBus(const QRect &rect, QGraphicsItem *parent = 0);
virtual ~ElectricBaseModelSvgBus();
void addPort();
public:
virtual void updateConnectData();
protected:
virtual void paint(QPainter*, const QStyleOptionGraphicsItem*, QWidget*);
private:
virtual void updateHandles();
};
#endif

27
diagramCavas/include/baseModelItem/electricBaseModelSvgItem.h Normal file
View File

@ -0,0 +1,27 @@
#ifndef ELECTRICBASEMODELSVGITEM_H
#define ELECTRICBASEMODELSVGITEM_H
#include "graphicsItem/graphicsBaseItem.h"
#include <QGraphicsSvgItem>
class ElectricBaseModelSvgItem :public GraphicsBaseModelItem
{
Q_OBJECT
public:
ElectricBaseModelSvgItem(const QRect &rect, bool genNewPort = true,QGraphicsItem *parent = 0); //genNewPort生成新接线点
virtual ~ElectricBaseModelSvgItem();
void updateCoordinate();
void move(const QPointF&);
protected:
virtual QPainterPath shape();
virtual void editShape(int, const QPointF&);
virtual void paint(QPainter*, const QStyleOptionGraphicsItem*, QWidget*);
virtual void loadSvg(const QString&);
protected:
QRectF m_lastBoudingRect; //记录上一时刻的boundingRect
QSvgRenderer* m_pRender;
};
#endif

1
diagramCavas/include/diagramCavas.h
View File

@ -47,6 +47,7 @@ public slots:
void onSignal_deleteDiagram(DiagramInfo);
void onSignal_selectDiagram(DiagramInfo);
void onCreateTestBaseModelDiagram();
/******************************生成组态***********************************/
void onSignal_createEditPanel(QString);
EditPanel* onSignal_addEditPanel(QString);

29
diagramCavas/include/graphicsDataModel/fixedPortsModel.h
View File

@ -10,7 +10,10 @@
class DrawingPanel;
class GraphicsBaseItem;
class GraphicsProjectModelItem;
class GraphicsBaseModelItem;
class BaseProperty;
class BaseModelProperty;
class DesignerScene;
class HttpInterface;
struct Connection;
@ -28,14 +31,14 @@ public:
public:
QMap<QUuid,QPointF> allNodePos() const;
QVector<Connection> allConnections();
QMap<QUuid,GraphicsBaseItem*>& allItems();
bool addNodeItem(QUuid uuid,GraphicsBaseItem*);
QMap<QUuid,GraphicsProjectModelItem*>& allItems();
bool addNodeItem(QUuid uuid,GraphicsProjectModelItem*);
void addNodeItem(QUuid id,/*int type,*/QPointF pos);
QVariant nodeData(QUuid nodeId, NodeRole role) const;
BaseProperty* addNodeData(QUuid id,int type,QString name,QString modelName); //对应component数据，一个data可对应多个item
BaseProperty* addNodeData(QUuid id,int type,QString name,QString modelName); //对应component数据，一个data可对应多个item（id,类型,名称,工程模名）
void loadNodeDataFromDataBase(); //从数据库加载数据
void addConnectLline(QUuid srcId,QUuid destId,QUuid srcPort,QUuid destPort);
void deleteNodeItem(GraphicsBaseItem*);
void deleteNodeItem(GraphicsProjectModelItem*);
//QJsonObject saveNode(QUuid const) const;
void saveNode(int nPageId);
void setScene(DesignerScene* p){_scene = p;}
@ -44,13 +47,21 @@ public:
QPointF getTerminalPos(const QString& sTerminalId); //获取拓扑接线点在当前diagram中的位置
ElectricConnectLineItem* getLineItemById(const QString& terminalId);
void showModelDlg(const QString&,QUuid,GraphicsBaseItem*); //点击时显示指定模型的dlg、指定item的数据(模型名，对象Uuid,触发事件的item)
void showModelDlg(const QString&,QUuid,GraphicsProjectModelItem*); //点击时显示指定模型的dlg、指定item的数据(模型名，对象Uuid,触发事件的item)
void initialPropertyDlg(); //初始化属性设置dlg，每个模型拥各自的dlg
void generatePropertyDlg(const QString&);
ConfigurationDiagram* getTopologyDiagram(); //返回当前组态图的拓扑实体
void createTopoTerminalsByItem(GraphicsBaseItem*); //通过图形对象创建port接线点(新建)
void createTopoTerminalsByData(PowerEntity* pParent,QJsonObject componentCon); //通过componet数据创建port接线点(加载)
bool isItemValid(GraphicsBaseItem*); //判断item是否可以连接
bool isItemValid(GraphicsProjectModelItem*); //判断item是否可以连接
void insertProjectModelName(QString,QString); //插入工程模类型（生成工程模时调用）
/********************baseModel相关**********************/
QMap<QUuid,GraphicsBaseModelItem*>& allBaseItems(); //获取所有基模对象
QVector<Connection> allBaseConnections();
QMap<QUuid,QPointF> allBaseNodePos() const;
BaseModelProperty* addBaseNodeData(QUuid id,int type,QString name,QString metaName); //添加图元基模数据
Q_SIGNALS:
void activatePage(const QString&); //激活当前model所在page
public:
@ -59,13 +70,14 @@ public:
void activateModel() {Q_EMIT activatePage(_pageName);} //发送激活信号(点击)
void startHttpRequest(); //开始请求数据(运行时)
public Q_SLOTS:
void onSignal_ifExits(QUuid id,const QString&,int type,GraphicsBaseItem*); //判断用户输入的名称是否已存在
void onSignal_ifExits(QUuid id,const QString&,int type,GraphicsProjectModelItem*); //判断用户输入的名称是否已存在
void onTimeOut();
void onSignal_GetPointData(QString type,QMap<qint64,double> map);
private:
QMap<QUuid,GraphicsBaseItem*> _nodeItem;
QMap<QUuid,GraphicsProjectModelItem*> _nodeItem; //工程模对象
QMap<QUuid,GraphicsBaseModelItem*> _baseItem; //基模对象
QString _pageName;
DesignerScene* _scene;
@ -73,6 +85,7 @@ private:
HttpInterface* _Interface;
QTimer* _timer;
PowerEntity* _pEntity; //拓扑实体
QMap<QString,QString> _projectModelName; //该图中所有元件对应的工程模类型(todo:扩展为每张图独立的结构体) uuid,工程模名称
QMap<QString,modelStateInfo> _modelStateInfo; //模型结构信息
QMap<QString,modelDataInfo> _modelDataInfo; //模型数据信息

71
diagramCavas/include/graphicsItem/electricConnectLineItem.h
View File

@ -5,70 +5,7 @@
#include <QUuid>
#include "graphicsBaseItem.h"
struct Connection
{
QUuid nSrcNodeId;
QUuid nSrcPortId;
HandleType srcType;
PortPos srcPos;
QUuid nDestNodeId;
QUuid nDestPortId;
HandleType destType;
PortPos destPos;
Connection()
{
srcType = T_none;
srcPos = P_top;
destType = T_none;
destPos = P_top;
}
Connection(const Connection& obj)
{
nSrcNodeId = obj.nSrcNodeId;
nSrcPortId = obj.nSrcPortId;
srcType = obj.srcType;
srcPos = obj.srcPos;
nDestNodeId = obj.nDestNodeId;
nDestPortId = obj.nDestPortId;
destType = obj.destType;
destPos = obj.destPos;
}
Connection(QUuid nSNI,QUuid nSPI,HandleType sT,PortPos sPOS,QUuid nDNI,QUuid nDPI,HandleType dT,PortPos dPOS)
{
nSrcNodeId = nSNI;
nSrcPortId = nSPI;
srcType = sT;
srcPos = sPOS;
nDestNodeId = nDNI;
nDestPortId = nDPI;
destType = dT;
destPos = dPOS;
}
bool operator==(const Connection& obj)
{
return ((obj.nSrcNodeId == nSrcNodeId)&&(obj.nSrcPortId == nSrcPortId)&&(obj.srcType == srcType)&&(obj.nDestNodeId == nDestNodeId)&&(obj.nDestPortId == nDestPortId)&&(obj.destType == destType));
}
Connection& operator=(const Connection& obj)
{
if(*this == obj)
return *this;
nSrcNodeId = obj.nSrcNodeId;
nSrcPortId = obj.nSrcPortId;
srcType = obj.srcType;
srcPos = obj.srcPos;
nDestNodeId = obj.nDestNodeId;
nDestPortId = obj.nDestPortId;
destType = obj.destType;
destPos = obj.destPos;
return *this;
}
};
class ElectricConnectLineItem : public GraphicsBaseItem
class ElectricConnectLineItem : public GraphicsProjectModelItem
{
public:
ElectricConnectLineItem(QGraphicsItem *parent = 0);
@ -80,13 +17,11 @@ public:
void moveLine(QPointF); //鼠标点击拖动
void calculatePath();
bool addConnection();
void resetCurLine(){_curLine = QPoint();}
//void updateConnection(QUuid callerId,QPointF pos); //外部调用的更新函数,id为调用者id
void setConnection(Connection con){m_connectState = con;}
Connection getConnection() const {return m_connectState;}
//QUuid getOppositeId(QUuid); //获取另一端点id
protected:
virtual QPainterPath shape() const override;
virtual QRectF boundingRect() const override;
@ -98,8 +33,6 @@ private:
QList<QPointF> m_lstPoints;
QPoint _curLine; //参数1用点序号表示的当前线段起始点,参数2表示线段方向
//QPointF m_pStart;
//QPointF m_pEnd;
};
#endif

2
diagramCavas/include/graphicsItem/electricSvgItem.h
View File

@ -4,7 +4,7 @@
#include "graphicsBaseItem.h"
#include <QGraphicsSvgItem>
class ElectricSvgItem :public GraphicsBaseItem
class ElectricSvgItem :public GraphicsProjectModelItem
{
Q_OBJECT
public:

77
diagramCavas/include/graphicsItem/graphicsBaseItem.h
View File

@ -436,18 +436,61 @@ protected:
};
class ItemPort;
class BaseProperty;
//class BaseProperty;
class ModelProperty;
class PowerEntity;
typedef AbstractShapeType<QGraphicsItem> AbstractShape;
class GraphicsBaseItem : public QObject, public AbstractShapeType<QGraphicsItem>
class GraphicsBaseItem :public QObject, public AbstractShapeType<QGraphicsItem>
{
Q_OBJECT
public:
public:
GraphicsBaseItem(QGraphicsItem *parent);
virtual ~GraphicsBaseItem();
public:
virtual QUuid itemId() const {return m_itemId;}
virtual void setItemId(QUuid n){m_itemId = n;}
virtual int addPort(PortState typ,QPointF vec,QString id = "",HandleType hType = T_lineInOut,PortPos pos = P_top); //新建,返回-1失败
virtual void setEntity(PowerEntity*); //设置当前图元的拓扑数据
virtual PowerEntity* entity();
virtual void setProperty(ModelProperty* p);
virtual ModelProperty* getProperty() {return _property;}
virtual void updateByProperty(){}; //使用data对象更新自己
virtual void setItemChanged(bool b){_itemChanged = b;}
virtual bool itemChanged() const {return _itemChanged;}
virtual void setItemType(GraphicsItemType type){m_Itemtype = type;}
virtual GraphicsItemType getItemType() const {return m_Itemtype;}
virtual void renderSelectBackground(QPainter*);
virtual ItemPort* getPortById(QString) const;
virtual ItemPort* getPortPtr(int) const;
virtual ItemControlHandle* getHandlePtr(int) const;
virtual QMap<QString,ItemPort*> getPorts() {return m_mapPort;}
public slots:
void onUpdateData(); //data发送的更新通知
protected:
QUuid m_itemId;
GraphicsItemType m_Itemtype;
ModelProperty* _property;
PowerEntity* _pEntity; //图元拓扑
bool _itemChanged; //图元变化标志，判断是否需要保存
QMap<QString,ItemPort*> m_mapPort; //单独存放port
};
class GraphicsBaseModelItem : public GraphicsBaseItem //基模item
{
Q_OBJECT
public:
GraphicsBaseModelItem(QGraphicsItem *parent);
virtual ~GraphicsBaseModelItem();
};
class GraphicsProjectModelItem : public GraphicsBaseItem //工程模item
{
Q_OBJECT
public:
GraphicsProjectModelItem(QGraphicsItem *parent);
virtual ~GraphicsProjectModelItem();
virtual void createOperationCopy();
virtual void removeOperationCopy();
@ -465,53 +508,31 @@ public:
virtual QString getLabelCurrent() const;
virtual void setLabelVoltage(const QString& str); //设置电压标签
virtual QString getLabelVoltage() const;
virtual int addPort(PortState typ,QPointF vec,QString id = "",HandleType hType = T_lineInOut,PortPos pos = P_top); //新建,返回-1失败
//virtual void addPort(PortState typ,int ntagId,QPointF vec); //载入 PortState为P_const时，QPointF中为(0~1，0~1)的相对位置;PortState为p_movable时，QPointF为坐标值
virtual QUuid itemId() const {return m_itemId;}
virtual void setItemId(QUuid n){m_itemId = n;}
virtual void setState(ItemState s){m_state = s;}
virtual void setBeginConnectPos(QPointF p){m_beginConnectPoint = p;}
virtual void setEndConnectPos(QPointF p){m_endConnectPoint = p;}
virtual void setItemType(GraphicsItemType type){m_Itemtype = type;}
virtual GraphicsItemType getItemType() const {return m_Itemtype;}
virtual void setLastPort(int n){_lastPort = n;}
virtual int getLastPort() const {return _lastPort;}
virtual ItemPort* getPortById(QString) const;
virtual ItemPort* getPortPtr(int) const;
virtual ItemControlHandle* getHandlePtr(int) const;
virtual QMap<QString,ItemPort*> getPorts() {return m_mapPort;}
virtual void setProperty(BaseProperty* p);
virtual BaseProperty* getProperty() {return _property;}
virtual void unbindProperty(); //断开图元与数据的绑定
virtual void updateByProperty(); //使用data对象更新自己
virtual void updateConnectData(); //更新连接关系数据
virtual void setItemChanged(bool b){_itemChanged = b;}
virtual bool itemChanged() const {return _itemChanged;}
virtual void setModelName(QString sName){_modelName = sName;}
virtual QString getModelName() const {return _modelName;}
virtual void setEntity(PowerEntity*); //设置当前图元的拓扑数据
virtual PowerEntity* entity();
protected:
virtual QVariant itemChange(QGraphicsItem::GraphicsItemChange, const QVariant&);
virtual void contextMenuEvent(QGraphicsSceneContextMenuEvent*);
signals:
void ifExist(QUuid id,const QString&,int type,GraphicsBaseItem*);
void ifExist(QUuid id,const QString&,int type,GraphicsProjectModelItem*);
public slots:
void onEditNameFinish(const QString&);
void onUpdateData(); //data发送的更新通知
protected:
QUuid m_itemId;
GraphicsItemType m_Itemtype;
ItemState m_state;
QMap<QString,ItemPort*> m_mapPort; //单独存放port
QPointF m_beginConnectPoint;
QPointF m_endConnectPoint;
uint _portId; //port编号
int _lastPort; //最后触碰的port
BaseProperty* _property;
bool _itemChanged; //图元变化标志，判断是否需要保存
QString _modelName; //当前图元使用的模型名，用来在model中检索属性信息
PowerEntity* _pEntity; //图元拓扑
};
#endif

2
diagramCavas/include/graphicsItem/graphicsPolygonItem.h
View File

@ -3,7 +3,7 @@
#include "graphicsBaseItem.h"
class GraphicPolygonItem : public GraphicsBaseItem
class GraphicPolygonItem : public GraphicsProjectModelItem
{
public:
GraphicPolygonItem(QGraphicsItem *parent = 0);

2
diagramCavas/include/graphicsItem/graphicsRectItem.h
View File

@ -3,7 +3,7 @@
#include "graphicsBaseItem.h"
class GraphicsRectItem : public GraphicsBaseItem
class GraphicsRectItem : public GraphicsProjectModelItem
{
public:
GraphicsRectItem(const QRect &rect, bool isRound = false, QGraphicsItem *parent = 0);

43
diagramCavas/include/graphicsItem/itemControlHandle.h
View File

@ -2,48 +2,7 @@
#define ITEMCONTROLHANDLE_H
#include <QGraphicsRectItem>
enum HandleType
{
T_none = 0,
T_resize, //调整大小
T_rotate, //旋转
T_editShape, //编辑形状
T_text, //文本
T_lineIn, //入线口
T_lineOut, //出线口
T_lineInOut //双端线
};
enum HandleTag
{
H_none = 0,
H_leftTop,
H_top,
H_rightTop,
H_right,
H_rightBottom,
H_bottom,
H_leftBottom,
H_left, //8
H_rotate_leftTop,
H_rotate_rightTop,
H_rotate_rightBottom,
H_rotate_leftBottom, //12
H_edit,
H_textCaption = 40, //标题文本
H_textCurrent, //电流
h_textVoltage, //电压
H_connect = 50 //连接操作点从50开始，前面预留
};
enum PortPos
{
P_top = 0,
P_down,
P_left,
P_right
};
#include "global.h"
const int HNDLE_SIZE = 8;

6
diagramCavas/include/itemPropertyDlg.h
View File

@ -11,7 +11,7 @@ QT_BEGIN_NAMESPACE
namespace Ui { class itemPropertyDlg; }
QT_END_NAMESPACE
class GraphicsBaseItem;
class GraphicsProjectModelItem;
struct PropertyInfo
{
@ -36,7 +36,7 @@ public:
void initial();
void loadGroupButton(QMap<QString,groupStateInfo>); //加载属性组列表
void createGroupView(const QString&); //创建属性页
void showDlg(modelDataInfo,QUuid,GraphicsBaseItem*); //显示属性页面
void showDlg(modelDataInfo,QUuid,GraphicsProjectModelItem*); //显示属性页面
signals:
void PropertyChange(const PropertyInfo);
public slots:
@ -55,7 +55,7 @@ private:
QMap<QString,groupStateValue> groupValue_; //属性数据
QUuid curUuid_; //当前显示对象的uuid
QString _curModel; //当前模型名
GraphicsBaseItem* _curItem;
GraphicsProjectModelItem* _curItem;
};
#endif

68
diagramCavas/include/topologyManager.h
View File

@ -18,34 +18,31 @@ public:
static TopologyManager& instance();
// 实体管理
PowerEntity* createEntity(EntityType type,const QString& uuid,const QString& name);
PowerEntity* findEntity(const QString& id) const;
bool deleteEntity(const QString& id);
PowerEntity* createEntity(EntityType type,const QString& uuid,const QString& name,ModelFunctionType tpe = ModelFunctionType::ProjectModel);
PowerEntity* findEntity(const QString& id,ModelFunctionType = ModelFunctionType::ProjectModel) const;
bool deleteEntity(const QString& id,ModelFunctionType = ModelFunctionType::ProjectModel);
// 连接管理
PowerConnection* createConnection(const QString& uuid,const QString& fromTerId, const QString& toTerId,const QString& fromId,const QString& toId);
QList<PowerConnection*> getConnectionsForTerminal(const QString& terminalId) const;
void removeConnection(const QString& connId);
bool validateConnection(const QString& fromTermId, const QString& toTermId) const;
PowerConnection* createConnection(const QString& uuid,const QString& fromTerId, const QString& toTerId,const QString& fromId,const QString& toId,ModelFunctionType tpe = ModelFunctionType::ProjectModel);
QList<PowerConnection*> getConnectionsForTerminal(const QString& terminalId,ModelFunctionType tpe = ModelFunctionType::ProjectModel) const;
void removeConnection(const QString& connId,ModelFunctionType = ModelFunctionType::ProjectModel);
bool validateConnection(const QString& fromTermId, const QString& toTermId,ModelFunctionType = ModelFunctionType::ProjectModel) const;
// 连接查询接口
QList<PowerConnection*> connectionsFrom(const QString& elementId) const;
QList<PowerConnection*> connectionsTo(const QString& elementId) const;
QList<PowerConnection*> getConnectionsFor(const QString& entityId) const;
PowerConnection* connection(const QString& conId) const;
PowerConnection* connection(const QString& fromPin,const QString& toPin);
QHash<QString,PowerConnection*> getAllConnections();
//QList<PowerConnection*> connectionsFrom(const QString& elementId) const;
//QList<PowerConnection*> connectionsTo(const QString& elementId) const;
QList<PowerConnection*> getConnectionsFor(const QString& entityId,ModelFunctionType tpe = ModelFunctionType::ProjectModel) const;
PowerConnection* connection(const QString& conId,ModelFunctionType tpe = ModelFunctionType::ProjectModel) const;
PowerConnection* connection(const QString& fromPin,const QString& toPin,ModelFunctionType tpe = ModelFunctionType::ProjectModel);
QHash<QString,PowerConnection*> getAllConnections(ModelFunctionType tpe = ModelFunctionType::ProjectModel);
//void saveToDB(const QString& path);
//void loadFromDB(const QString& path);
PowerEntity* getEntity(const QString& id) const;
QList<PowerEntity*> findEntitiesByName(const QString& name) const;
PowerEntity* getEntity(const QString& id,ModelFunctionType tpe = ModelFunctionType::ProjectModel) const;
QList<PowerEntity*> findEntitiesByName(const QString& name,ModelFunctionType tpe = ModelFunctionType::ProjectModel) const;
//==========================组态图拓扑相关===================================
PowerEntity* createDiagram(const QString& id,const QString& name); //单独创建组态图
PowerEntity* findDiagram(const QString& id) const;
bool deleteDiagram(const QString& id);
PowerEntity* createDiagram(const QString& id,const QString& name,ModelFunctionType tpe = ModelFunctionType::ProjectModel); //单独创建组态图
PowerEntity* findDiagram(const QString& id,ModelFunctionType tpe = ModelFunctionType::ProjectModel) const;
bool deleteDiagram(const QString& id,ModelFunctionType tpe = ModelFunctionType::ProjectModel);
public:
// 接线点管理
@ -53,12 +50,13 @@ public:
TerminalType type,
const QString& name,
const QPointF& relPos = QPointF(),
const QString& uuid = "");
bool deleteTerminal(const QString& terminalId);
PowerTerminal* getTerminal(const QString& terminalId) const;
QList<PowerTerminal*> getTerminalsForEntity(const QString& entityId) const;
PowerEntity* getEntityByTerminal(const QString& terminalId) const; //返回terminal所在的entity实体
PowerConnection* getConnectionContainsTerminal(const QString& terminalId) const; //返回包含terminal的connection
const QString& uuid = "",
ModelFunctionType tpe = ModelFunctionType::ProjectModel);
bool deleteTerminal(const QString& terminalId,ModelFunctionType tpe = ModelFunctionType::ProjectModel);
PowerTerminal* getTerminal(const QString& terminalId,ModelFunctionType tpe = ModelFunctionType::ProjectModel) const;
QList<PowerTerminal*> getTerminalsForEntity(const QString& entityId,ModelFunctionType tpe = ModelFunctionType::ProjectModel) const;
PowerEntity* getEntityByTerminal(const QString& terminalId,ModelFunctionType tpe = ModelFunctionType::ProjectModel) const; //返回terminal所在的entity实体
PowerConnection* getConnectionContainsTerminal(const QString& terminalId,ModelFunctionType tpe = ModelFunctionType::ProjectModel) const; //返回包含terminal的connection
signals:
void entityCreated(const QString&);
void entityDeleted(const QString&);
@ -70,17 +68,29 @@ private:
~TopologyManager();
void clearAllData();
QHash<QString, PowerEntity*> m_entities; // ID到实体映射
QHash<QString, DiagramContent*> m_views; // 组态图视图存储
//QHash<QString, DiagramContent*> m_views; // 组态图视图存储
QHash<QString, PowerEntity*> m_diagrams; // 组态图拓扑结构
// 连接存储
QHash<QString,PowerConnection*> m_connections;
QMultiHash<QString,PowerConnection*> m_connectionIndex; // 接线点ID到连接的映射
private:
QHash<QString, PowerTerminal*> m_allTerminals; // ID到接线点映射
QHash<QString, QList<PowerTerminal*>> m_terminalsByEntity; // 实体ID到接线点列表
QHash<QString, QSet<QString>> m_entityConnections; // <entityId, Set<connectionId>>
private:
QHash<QString, PowerEntity*> m_baseEntities; // ID到实体映射（基模）
QHash<QString, PowerEntity*> m_baseDiagrams; // 组态图拓扑结构（基模）
// 连接存储
QHash<QString,PowerConnection*> m_baseConnections;
QMultiHash<QString,PowerConnection*> m_baseConnectionIndex; // 接线点ID到连接的映射（基模）
QHash<QString, PowerTerminal*> m_baseAllTerminals; // ID到接线点映射（基模）
QHash<QString, QList<PowerTerminal*>> m_baseTerminalsByEntity; // 实体ID到接线点列表（基模）
QHash<QString, QSet<QString>> m_baseEntityConnections; // <entityId, Set<connectionId>>（基模）
};
#endif

4
diagramCavas/include/util/baseSelector.h
View File

@ -38,9 +38,9 @@ enum OperationMode
OM_linkMove, //连接线移动
};
class GraphicsBaseItem;
class GraphicsProjectModelItem;
using ItemMap = QMap<QString,QMap<QString,GraphicsBaseItem*>>;
using ItemMap = QMap<QString,QMap<QString,GraphicsProjectModelItem*>>;
class BaseSelector : public QObject
{

10
diagramCavas/include/util/connectingSelector.h
View File

@ -11,7 +11,7 @@
#include "baseSelector.h"
class GraphicsBaseItem;
class GraphicsProjectModelItem;
class ConnectingSelector : public BaseSelector
@ -22,16 +22,16 @@ public:
explicit ConnectingSelector(FixedPortsModel* model,QObject *parent = 0);
virtual ~ConnectingSelector();
public:
bool targetCouldConnect(GraphicsBaseItem* p,QPointF pos);
bool targetCouldConnect(GraphicsProjectModelItem* p,QPointF pos);
void setTargetHighLight(bool val); //设置目标高亮
void createConnectLline(GraphicsBaseItem* connecting,GraphicsBaseItem* touched,DesignerScene* scene);
void createConnectLline(GraphicsProjectModelItem* connecting,GraphicsProjectModelItem* touched,DesignerScene* scene);
public:
void mousePressEvent(QGraphicsSceneMouseEvent*, DesignerScene*);
void mouseMoveEvent(QGraphicsSceneMouseEvent*, DesignerScene*);
void mouseReleaseEvent(QGraphicsSceneMouseEvent*, DesignerScene*);
private:
GraphicsBaseItem* m_pConnectingItem;
GraphicsBaseItem* m_pTouchedItem; //连线时接触的对象
GraphicsProjectModelItem* m_pConnectingItem;
GraphicsProjectModelItem* m_pTouchedItem; //连线时接触的对象
bool m_bReadyConnect; //准备连接
};

4
diagramCavas/include/util/creatingSelector.h
View File

@ -19,7 +19,7 @@ enum CreatingMethod
CM_click //单击点选，如多边形、线段等
};
class GraphicsBaseItem;
class GraphicsProjectModelItem;
class DesignerScene;
class CreatingSelector : public BaseSelector
@ -39,7 +39,7 @@ public:
private:
CreatingMethod m_creatingMethod;
modelStateInfo m_creatingItemInfo;
GraphicsBaseItem* m_pCreatingItem;
GraphicsProjectModelItem* m_pCreatingItem;
QPointF m_scalBasePoint;
};

2
diagramCavas/include/util/editingSelector.h
View File

@ -28,7 +28,7 @@ public:
void mouseReleaseEvent(QGraphicsSceneMouseEvent*, DesignerScene*);
private:
GraphicsBaseItem* m_pEditingItem;
GraphicsProjectModelItem* m_pEditingItem;
};
#endif

2
diagramCavas/include/util/movingSelector.h
View File

@ -18,8 +18,6 @@ class MovingSelector : public BaseSelector
public:
explicit MovingSelector(FixedPortsModel* model,QObject *parent = 0);
virtual ~MovingSelector();
//void updateConnectLine(QList<QGraphicsItem *>);
public:
void mousePressEvent(QGraphicsSceneMouseEvent*, DesignerScene*);
void mouseMoveEvent(QGraphicsSceneMouseEvent*, DesignerScene*);

2
diagramCavas/include/util/subMovingSelector.h
View File

@ -22,7 +22,7 @@ public:
void mouseMoveEvent(QGraphicsSceneMouseEvent*, DesignerScene*);
void mouseReleaseEvent(QGraphicsSceneMouseEvent*, DesignerScene*);
private:
GraphicsBaseItem* m_pParentItem;
GraphicsProjectModelItem* m_pParentItem;
};
#endif

115
diagramCavas/source/baseModelItem/electricBaseModelLineItem.cpp Normal file
View File

@ -0,0 +1,115 @@
#include "baseModelItem/electricBaseModelLineItem.h"
#include <QGraphicsScene>
#include <QPainter>
#include <QStyleOptionGraphicsItem>
ElectricBaseModelLineItem::ElectricBaseModelLineItem(QGraphicsItem *parent)
: GraphicsBaseModelItem(parent)
{
m_boundingRect = QRectF();
m_pen = QPen(Qt::black);
m_brush = QBrush(Qt::NoBrush);
setHandleVisible(false);
setFunctionHandleIfShow(false);
setFunctionHandleEnaable(false);
m_lstPoints.push_back(QPointF()); //起点
m_lstPoints.push_back(QPointF()); //终点
_curLine = QPoint();
}
ElectricBaseModelLineItem::~ElectricBaseModelLineItem()
{
}
void ElectricBaseModelLineItem::setStartPoint(const QPointF& p)
{
int n = m_lstPoints.size();
if(n)
{
if(n >2)
{
if(m_lstPoints[0].x() == m_lstPoints[1].x()) //相邻点在垂直方向，水平移动,否则垂直移动
{
m_lstPoints[1].setX(p.x());
}
else
{
m_lstPoints[1].setY(p.y());
}
}
m_lstPoints[0] = p;
}
}
void ElectricBaseModelLineItem::setEndPoint(const QPointF& p)
{
int n = m_lstPoints.size();
if(n)
{
if(n >2)
{
if(m_lstPoints[n-1].x() == m_lstPoints[n-2].x()) //相邻点在垂直方向，水平移动,否则垂直移动
{
m_lstPoints[n-2].setX(p.x());
}
else
{
m_lstPoints[n-2].setY(p.y());
}
}
m_lstPoints[n-1] = p;
}
}
QPainterPath ElectricBaseModelLineItem::shape() const
{
QPainterPath path;
//path.addPath(m_points);
path.addPath(m_pointsBoundingRect);
return path;
}
QRectF ElectricBaseModelLineItem::boundingRect() const
{
return m_boundingRect;
}
void ElectricBaseModelLineItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
{
if (option->state & QStyle::State_Selected)
{
painter->setPen(Qt::red);
}
else
{
painter->setPen(m_pen);
}
painter->setBrush(m_brush);
painter->drawPath(m_points);
}
void ElectricBaseModelLineItem::calculatePath()
{
int n = m_lstPoints.size();
prepareGeometryChange();
m_points.clear();
m_pointsBoundingRect.clear();
if(m_lstPoints.size() == 2 && (m_lstPoints.first().x() != m_lstPoints.last().x()) && (m_lstPoints.first().y() != m_lstPoints.last().y()))
{
if(m_lstPoints.first().y() < m_lstPoints.last().y())
m_lstPoints.insert(1,QPointF(m_lstPoints.first().x(),m_lstPoints.last().y()));
else
m_lstPoints.insert(1,QPointF(m_lstPoints.last().x(),m_lstPoints.first().y()));
}
m_points.moveTo(m_lstPoints.first());
QPointF pLast = m_lstPoints.first();
for(int i = 1;i <m_lstPoints.size();++i)
{
m_points.lineTo(m_lstPoints[i]);
m_pointsBoundingRect.addRect(QRectF(QPointF(pLast.x()-1,pLast.y()-1),QPointF(m_lstPoints[i].x()+1,m_lstPoints[i].y()+1)));
pLast = m_lstPoints[i];
}
m_boundingRect = m_points.boundingRect();
}

58
diagramCavas/source/baseModelItem/electricBaseModelSvgBus.cpp Normal file
View File

@ -0,0 +1,58 @@
#include "baseModelItem/electricBaseModelSvgBus.h"
#include "graphicsItem/itemPort.h"
#include "baseProperty.h"
#include <QPainter>
#include <QStyleOption>
#include <QJsonArray>
ElectricBaseModelSvgBus::ElectricBaseModelSvgBus(const QRect &rect, QGraphicsItem *parent)
: ElectricBaseModelSvgItem(rect,parent)
{
loadSvg(":/images/element/svg_bus.svg");
setHandleIfShow(H_textCaption,false);
setHandleVisible(false);
setFunctionHandleIfShow(false);
setFunctionHandleEnaable(false);
setHandleEnaable(H_right,true);
setHandleEnaable(H_left,true);
}
ElectricBaseModelSvgBus::~ElectricBaseModelSvgBus()
{
}
void ElectricBaseModelSvgBus::updateHandles()
{
ElectricBaseModelSvgItem::updateHandles();
}
void ElectricBaseModelSvgBus::updateConnectData()
{
QJsonObject obj;
QJsonArray arr;
if(_property)
{
for(auto ptr:m_mapPort)
{
//if(ptr->connected())
{
QJsonObject port;
port["portId"] = ptr->getId();
auto pLine = ptr->getConnectPtr();
port["x"] = ptr->pos().x();
port["y"] = ptr->pos().y();
port["portType"] = ptr->getType();
arr.push_back(port);
}
}
obj["port"] = arr;
_property->setContext(obj);
}
}
void ElectricBaseModelSvgBus::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
{
ElectricBaseModelSvgItem::paint(painter,option,widget);
}

83
diagramCavas/source/baseModelItem/electricBaseModelSvgItem.cpp Normal file
View File

@ -0,0 +1,83 @@
#include "baseModelItem/electricBaseModelSvgItem.h"
#include "graphicsItem/itemControlHandle.h"
#include <QPainter>
#include <QStyleOption>
#include <QSvgRenderer>
#include <QDebug>
ElectricBaseModelSvgItem::ElectricBaseModelSvgItem(const QRect &rect, bool autoGenPort,QGraphicsItem *parent)
: GraphicsBaseModelItem(parent),m_pRender(nullptr)
{
m_lastBoudingRect = rect;
m_boundingRect = rect;
m_dWidth = rect.width();
m_dHeight = rect.height();
}
ElectricBaseModelSvgItem::~ElectricBaseModelSvgItem()
{
}
QPainterPath ElectricBaseModelSvgItem::shape()
{
QPainterPath path;
double dHandleX = 0.0;
double dHandleY = 0.0;
path.addRect(m_boundingRect);
return path;
}
void ElectricBaseModelSvgItem::updateCoordinate() //当执行了resie和editShape函数后，boundingRect发生了变换，需要将item的原点(以中心点为原点)校准至boundingRect.center()
{
if (!parentItem())
{
QPointF pt1, pt2, delta;
pt1 = mapToScene(QPointF(0, 0));
pt2 = mapToScene(m_boundingRect.center());
delta = pt1 - pt2;
prepareGeometryChange();
//将boundingRect设置成中心点和原点（也是默认变换原点），这样三点重合，有助于简化计算
m_boundingRect = QRectF(-m_dWidth / 2, -m_dHeight / 2, m_dWidth, m_dHeight);
//setTransformOriginPoint(m_boundingRect.center()); //变换中心默认为item的(0,0)点，所以不执行这句话也没有问题
//更新bouondingRect后重回会显示位置会有变化，需要做对应的移动
moveBy(-delta.x(), -delta.y());
updateHandles();
}
m_lastBoudingRect = m_boundingRect;
}
void ElectricBaseModelSvgItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
{
if(m_pRender)
{
m_pRender->render(painter,m_boundingRect);
}
painter->setPen(m_pen);
painter->setBrush(m_brush);
if (option->state & QStyle::State_Selected) //是选中状态,绘制选中框
{
renderSelectBackground(painter);
}
}
void ElectricBaseModelSvgItem::loadSvg(const QString& str)
{
m_pRender = new QSvgRenderer(str);
}
void ElectricBaseModelSvgItem::move(const QPointF& point)
{
moveBy(point.x(), point.y());
}
void ElectricBaseModelSvgItem::editShape(int nHandle,const QPointF& ptMouse)
{
prepareGeometryChange();
updateHandles();
}

2
diagramCavas/source/designerScene.cpp
View File

@ -1,8 +1,6 @@
#include "designerScene.h"
#include "util/selectorManager.h"
#include "graphicsItem/graphicsItemGroup.h"
#include "graphicsItem/electricConnectLineItem.h"
#include "graphicsItem/itemPort.h"
#include "drawingPanel.h"
#include "global.h"

24
diagramCavas/source/diagramCavas.cpp
View File

@ -51,6 +51,11 @@ void DiagramCavas::onSignal_addDrawingPanel(PowerEntity* pItem,DiagramMode mode)
FixedPortsModel* pModel = pPanel->getModel();
connect(pModel,&FixedPortsModel::activatePage,this,&DiagramCavas::onSignal_activatePage);
connect(pPanel,&DrawingPanel::panelDelete,this,&DiagramCavas::onSignal_panelDelete);
if(mode == DM_baseModel)
{
}
}
void DiagramCavas::onSignal_addGraphicsItem(modelStateInfo& info)
@ -93,7 +98,7 @@ void DiagramCavas::onSignal_savePage()
switch (ret) {
case QMessageBox::Save: //todo:已存在更新
{
QMap<QUuid,GraphicsBaseItem*> map = pPanel->getModel()->allItems();
QMap<QUuid,GraphicsProjectModelItem*> map = pPanel->getModel()->allItems();
for(auto pItem:map)
{
if(pItem->itemChanged())
@ -119,6 +124,10 @@ void DiagramCavas::onSignal_savePage()
break;
}
}
else if(pPanel->getMode() == DM_baseModel)
{
}
}
}
@ -317,6 +326,19 @@ void DiagramCavas::removePanel(PowerEntity* pEntity)
}
}
void DiagramCavas::onCreateTestBaseModelDiagram()
{
PowerEntity* pEntity;
QUuid id = QUuid::createUuid();
pEntity = TopologyManager::instance().findDiagram(id.toString());
if(!pEntity) //不存在创建
{
pEntity = TopologyManager::instance().createDiagram(id.toString(),"测试1");
onSignal_addDrawingPanel(pEntity,DM_baseModel);
}
}
/*******************************************************/
void DiagramCavas::onSignal_createEditPanel(QString sName)

15
diagramCavas/source/drawingPanel.cpp
View File

@ -94,8 +94,10 @@ SelectorManager* DrawingPanel::selectorManager() const
void DrawingPanel::closeEvent(QCloseEvent *closeEvent)
{
if(getMode() == DM_edit)
{
bool changed = false;
QMap<QUuid,GraphicsBaseItem*> map = _pModel->allItems();
QMap<QUuid,GraphicsProjectModelItem*> map = _pModel->allItems();
if(_pModel)
{
for(auto pItem:map)
@ -143,13 +145,12 @@ void DrawingPanel::closeEvent(QCloseEvent *closeEvent)
break;
}
}
/*for(auto pItem:map) //删除图元前先解绑
{
pItem->unbindProperty();
}*/
emit panelDelete(_name);
//closeEvent->ignore();
//hide();
}
else if(getMode() == DM_baseModel)
{
}
}
void DrawingPanel::onSignal_addGraphicsItem(modelStateInfo& info)

140
diagramCavas/source/graphicsDataModel/fixedPortsModel.cpp
View File

@ -4,6 +4,7 @@
#include "graphicsItem/electricSvgItemRect.h"
#include "graphicsItem/electricSvgItemTriangle.h"
#include "graphicsItem/electricConnectLineItem.h"
#include "baseModelItem/electricBaseModelLineItem.h"
#include "graphicsItem/itemPort.h"
#include "designerScene.h"
#include "dataBase.h"
@ -70,12 +71,12 @@ QVector<Connection> FixedPortsModel::allConnections()
return vec;
}
QMap<QUuid,GraphicsBaseItem*>& FixedPortsModel::allItems()
QMap<QUuid,GraphicsProjectModelItem*>& FixedPortsModel::allItems()
{
return _nodeItem;
}
bool FixedPortsModel::addNodeItem(QUuid uuid,GraphicsBaseItem* pItem)
bool FixedPortsModel::addNodeItem(QUuid uuid,GraphicsProjectModelItem* pItem)
{
if(_nodeItem.contains(uuid))
@ -83,7 +84,7 @@ bool FixedPortsModel::addNodeItem(QUuid uuid,GraphicsBaseItem* pItem)
else
{
_nodeItem.insert(uuid,pItem);
connect(pItem,&GraphicsBaseItem::ifExist,this,&FixedPortsModel::onSignal_ifExits);
connect(pItem,&GraphicsProjectModelItem::ifExist,this,&FixedPortsModel::onSignal_ifExits);
return true;
}
}
@ -92,7 +93,7 @@ void FixedPortsModel::addNodeItem(QUuid id/*,int type*/,QPointF pos)
{
//todo:load图形时必有拓扑实体，关联到对应的entity
BaseProperty* pro = nullptr;
GraphicsBaseItem* item = nullptr;
GraphicsProjectModelItem* item = nullptr;
QMap<QUuid,BaseProperty*> mapData = BasePropertyManager::instance().getEntityData(); //加载的图形必定关联component(todo:完善判断条件，如判断拓扑节点)
if(mapData.contains(id))
{
@ -146,9 +147,10 @@ void FixedPortsModel::addNodeItem(QUuid id/*,int type*/,QPointF pos)
item->addPoint(pos);
item->setProperty(pro); //绑定模型
item->updateByProperty(); //使用模型更新自身
item->setModelName(pro->modelName());
QString sModel = _projectModelName.value(id.toString());
item->setModelName(sModel);
_nodeItem.insert(id,item);
connect(item,&GraphicsBaseItem::ifExist,this,&FixedPortsModel::onSignal_ifExits);
connect(item,&GraphicsProjectModelItem::ifExist,this,&FixedPortsModel::onSignal_ifExits);
}
}
}
@ -221,8 +223,8 @@ void FixedPortsModel::loadNodeDataFromDataBase()
void FixedPortsModel::addConnectLline(QUuid srcId,QUuid destId,QUuid srcPort,QUuid destPort)
{
GraphicsBaseItem* src = _nodeItem[srcId];
GraphicsBaseItem* dest = _nodeItem[destId];
GraphicsProjectModelItem* src = _nodeItem[srcId];
GraphicsProjectModelItem* dest = _nodeItem[destId];
if(src && dest)
{
ElectricConnectLineItem* pItem = new ElectricConnectLineItem();
@ -264,37 +266,13 @@ void FixedPortsModel::addConnectLline(QUuid srcId,QUuid destId,QUuid srcPort,QUu
}
}
void FixedPortsModel::deleteNodeItem(GraphicsBaseItem* pItem)
void FixedPortsModel::deleteNodeItem(GraphicsProjectModelItem* pItem)
{
if(pItem->getItemType() == GIT_link)
{
auto pLine = dynamic_cast<ElectricConnectLineItem*>(pItem);
if(pLine)
{
/*Connection con = pLine->getConnection();
GraphicsBaseItem* srcItem = _nodeItem[con.nSrcNodeId];
if(srcItem)
{
ItemPort* ptSrc = srcItem->getPortPtr(con.nSrcPort);
ptSrc->disConnect();
srcItem->setItemChanged(true);
//srcItem->updateConnectData();
}
GraphicsBaseItem* destItem = _nodeItem[con.nDestNodeId];
if(destItem)
{
ItemPort* ptDest = pItem->getPortPtr(con.nDestPort);
ptDest->disConnect();
destItem->setItemChanged(true);
//destItem->updateConnectData();
}
QUuid lineId = pLine->itemId();
_nodeItem.take(lineId);
_scene->removeItem(pLine);
delete pLine;*/
QUuid conId = pLine->itemId();
TopologyManager::instance().removeConnection(conId.toString());
@ -316,31 +294,6 @@ void FixedPortsModel::deleteNodeItem(GraphicsBaseItem* pItem)
}
else
{
/*QMap<QString,ItemPort*> ports = pItem->getPorts();
for(auto port:ports)
{
if(port->connected())
{
ElectricConnectLineItem* pLine = port->getConnectPtr();
Connection con = pLine->getConnection();
QUuid oppositeId = pLine->getOppositeId(pItem->itemId());
int oppositePort = (con.nSrcNodeId==pItem->itemId())?con.nDestPort:con.nSrcPort; //取另一端点序号
GraphicsBaseItem* oppositeItem = _nodeItem[oppositeId];
if(oppositeItem)
{
ItemPort* ptOppo = oppositeItem->getPortPtr(oppositePort);
ptOppo->disConnect();
oppositeItem->setItemChanged(true);
}
QUuid lineId = pLine->itemId();
_nodeItem.take(lineId);
_scene->removeItem(pLine);
delete pLine;
port->disConnect();
}
}*/
QUuid srcId = pItem->itemId();
QList<PowerConnection*> lstCon = TopologyManager::instance().getConnectionsFor(srcId.toString());
for(auto &con:lstCon)
@ -518,7 +471,7 @@ void FixedPortsModel::saveNode(int nPageId)
}
}
void FixedPortsModel::onSignal_ifExits(QUuid id,const QString& str,int type,GraphicsBaseItem* pitem)
void FixedPortsModel::onSignal_ifExits(QUuid id,const QString& str,int type,GraphicsProjectModelItem* pitem)
{
bool exist = false;
BaseProperty* pData = nullptr;
@ -649,7 +602,7 @@ ElectricConnectLineItem* FixedPortsModel::getLineItemById(const QString& termina
{
for(auto iter:_nodeItem) //获取id所在的lineitem
{
auto item = dynamic_cast<GraphicsBaseItem*>(iter);
auto item = dynamic_cast<GraphicsProjectModelItem*>(iter);
if(item)
{
if(item->getItemType() == GIT_link)
@ -666,7 +619,7 @@ ElectricConnectLineItem* FixedPortsModel::getLineItemById(const QString& termina
return nullptr;
}
void FixedPortsModel::showModelDlg(const QString& sName,QUuid uuid,GraphicsBaseItem* pItem)
void FixedPortsModel::showModelDlg(const QString& sName,QUuid uuid,GraphicsProjectModelItem* pItem)
{
modelStateInfo stateInfo = _modelStateInfo[sName];
ModelDataMap mapData = DataManager::instance().modelData();
@ -769,9 +722,70 @@ void FixedPortsModel::createTopoTerminalsByData(PowerEntity* pParent,QJsonObject
}
}
bool FixedPortsModel::isItemValid(GraphicsBaseItem* pItem)
bool FixedPortsModel::isItemValid(GraphicsProjectModelItem* pItem)
{
BaseProperty* pData = pItem->getProperty();
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;
}
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;
}

23
diagramCavas/source/graphicsItem/electricConnectLineItem.cpp
View File

@ -3,9 +3,8 @@
#include <QPainter>
#include <QStyleOptionGraphicsItem>
ElectricConnectLineItem::ElectricConnectLineItem(QGraphicsItem *parent)
: GraphicsBaseItem(parent)
: GraphicsProjectModelItem(parent)
{
m_boundingRect = QRectF();
m_pen = QPen(Qt::black);
@ -375,23 +374,3 @@ void ElectricConnectLineItem::calculatePath()
}
m_boundingRect = m_points.boundingRect();
}
/*void ElectricConnectLineItem::updateConnection(QUuid callerId,QPointF pos)
{
//qDebug()<<pos;
if(callerId == m_connectState.nSrcNodeId)
setStartPoint(pos);
else if(callerId == m_connectState.nDestNodeId)
setEndPoint(pos);
else
qDebug()<<"ConnectLine update err";
calculatePath();
}*/
/*QUuid ElectricConnectLineItem::getOppositeId(QUuid id)
{
if(id == m_connectState.nSrcNodeId)
return m_connectState.nDestNodeId;
else
return m_connectState.nSrcNodeId;
}*/

38
diagramCavas/source/graphicsItem/electricSvgItem.cpp
View File

@ -7,7 +7,7 @@
#include <QDebug>
ElectricSvgItem::ElectricSvgItem(const QRect &rect, bool autoGenPort,QGraphicsItem *parent)
: GraphicsBaseItem(parent),m_pRender(nullptr)
: GraphicsProjectModelItem(parent),m_pRender(nullptr)
{
m_lastBoudingRect = rect;
m_boundingRect = rect;
@ -72,41 +72,7 @@ void ElectricSvgItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* o
if (option->state & QStyle::State_Selected) //是选中状态,绘制选中框
{
int nPenWidth = 1;
painter->setPen(QPen(QColor(135,206,235,180))); //蓝色的外框
painter->setBrush(QBrush(QColor(135,206,235,180)));
double dx = m_boundingRect_selected.x();
double dy = m_boundingRect_selected.y();
double dWidth = m_boundingRect_selected.width();
double dHeight = m_boundingRect_selected.height();
//画弧线0度是3点钟方向
if(dWidth > dHeight)
{
painter->drawRect(m_boundingRect_selected);
painter->drawChord(dx-dHeight*0.5,dy,dHeight,dHeight,90*16,180*16);
painter->drawChord(dx+dWidth-dHeight*0.5,dy,dHeight,dHeight,(-90)*16,180*16);
}
else if(dWidth < dHeight)
{
painter->drawRect(m_boundingRect_selected);
painter->drawChord(dx,dy-dWidth*0.5,dWidth,dWidth,0*16,180*16);
painter->drawChord(dx,dy+dHeight-dWidth*0.5,dWidth,dWidth,180*16,180*16);
//painter->drawChord(dx+dWidth-dHeight*0.5,dy,dHeight,dHeight,(-90)*16,180*16);
}
else
{
painter->drawEllipse(QPointF(dx+dWidth*0.5,dy+dHeight*0.5),dHeight*0.5,dHeight*0.5);
}
//绘制变换原点
QPointF originPoint = transformOriginPoint();
//qDebug() << "originPoint:" << originPoint;
painter->setBrush(Qt::red);
painter->drawEllipse(originPoint, 4, 4);
renderSelectBackground(painter);
}
}

4
diagramCavas/source/graphicsItem/electricSvgItemTriangle.cpp
View File

@ -14,7 +14,7 @@ ElectricSvgItemTriangle::ElectricSvgItemTriangle(const QRect &rect, QGraphicsIte
setFunctionHandleEnaable(false);
//入线口
ItemPort* pHandle1 = new ItemPort(this);
/*ItemPort* pHandle1 = new ItemPort(this);
pHandle1->setType(T_lineOut);
pHandle1->setTag(H_connect);
pHandle1->setPortPos(P_top);
@ -40,7 +40,7 @@ ElectricSvgItemTriangle::ElectricSvgItemTriangle(const QRect &rect, QGraphicsIte
m_mapPort.insert(QString::number(_portId++),pHandle1);
m_mapPort.insert(QString::number(_portId++),pHandle2);
m_mapPort.insert(QString::number(_portId++),pHandle3);
m_mapPort.insert(QString::number(_portId++),pHandle3);*/
}
ElectricSvgItemTriangle::~ElectricSvgItemTriangle()

435
diagramCavas/source/graphicsItem/graphicsBaseItem.cpp
View File

@ -2,10 +2,10 @@
#include "graphicsItem/handleRect.h"
#include "graphicsItem/handleText.h"
#include "graphicsItem/itemPort.h"
#include "graphicsItem/electricConnectLineItem.h"
#include "baseProperty.h"
#include <QGraphicsScene>
#include <QJsonArray>
#include <QPainter>
GraphicsBaseItem::GraphicsBaseItem(QGraphicsItem *parent)
@ -14,53 +14,8 @@ GraphicsBaseItem::GraphicsBaseItem(QGraphicsItem *parent)
,_pEntity(nullptr)
{
m_type = T_item;
_portId = 1;
_lastPort = -1;
_itemChanged = false;
//初始化缩放操作用的handle
//m_vecHanle.reserve(H_left);
for(int i = H_leftTop; i <= H_left; i++)
{
ItemControlHandle* pHandle = new HandleRect(this);
pHandle->setType(T_resize);
pHandle->setTag(i);
m_vecHanle.insert(i-1,pHandle);
}
for(int i = H_rotate_leftTop; i <= H_rotate_leftBottom; i++)
{
ItemControlHandle* pHandle = new HandleRect(this);
pHandle->setType(T_rotate);
pHandle->setTag(i);
m_vecHanle.insert(i-1,pHandle);
}
HandleText* pHandle = new HandleText(this);
pHandle->setType(T_text);
pHandle->setTag(H_textCaption);
pHandle->setText(QString("uname"));
pHandle->setPos(30,-30);
pHandle->setParent(this);
m_vecHanle.insert(H_textCaption,pHandle);
connect(pHandle,&HandleText::editFinish,this,&GraphicsBaseItem::onEditNameFinish);
HandleText* pCurrent = new HandleText(this); //电流
pCurrent->setEditable(false);
pCurrent->setType(T_text);
pCurrent->setTag(H_textCurrent);
pCurrent->setText(QString("I:"));
pCurrent->setPos(-30,-30);
pCurrent->setParent(this);
m_vecHanle.insert(H_textCurrent,pCurrent);
HandleText* pVoltage = new HandleText(this); //电压
pVoltage->setType(T_text);
pVoltage->setTag(h_textVoltage);
pVoltage->setText(QString("V:"));
pVoltage->setPos(-30,30);
pVoltage->setParent(this);
m_vecHanle.insert(h_textVoltage,pVoltage);
setFlag(QGraphicsItem::ItemIsMovable, true);
setFlag(QGraphicsItem::ItemIsSelectable, true);
setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
setAcceptHoverEvents(true);
@ -71,127 +26,6 @@ GraphicsBaseItem::~GraphicsBaseItem()
}
void GraphicsBaseItem::createOperationCopy()
{
m_pOperationCopy = new QGraphicsPathItem(this->shape());
m_pOperationCopy->setPen(Qt::DashLine);
m_pOperationCopy->setPos(this->pos());
m_pOperationCopy->setTransformOriginPoint(this->transformOriginPoint());
m_pOperationCopy->setTransform(this->transform());
m_pOperationCopy->setRotation(this->rotation());
m_pOperationCopy->setScale(this->scale());
m_pOperationCopy->setZValue(this->zValue());
QGraphicsScene* scene = this->scene();
if(scene && m_pOperationCopy)
{
scene->addItem(m_pOperationCopy);
m_movingIniPos = this->pos();
}
}
void GraphicsBaseItem::removeOperationCopy()
{
QGraphicsScene* scene = this->scene();
if(scene && m_pOperationCopy)
{
if(this->pos() != m_pOperationCopy->pos())
this->setPos(m_pOperationCopy->pos()); //本体移动到副本的位置
if(this->rotation() != m_pOperationCopy->rotation())
this->setRotation(m_pOperationCopy->rotation()); //本体旋转至副本的角度
scene->removeItem(m_pOperationCopy);
delete m_pOperationCopy;
m_pOperationCopy = nullptr;
}
}
void GraphicsBaseItem::moveOperationCopy(const QPointF& distance)
{
if(m_pOperationCopy)
m_pOperationCopy->setPos(m_movingIniPos + distance);
}
void GraphicsBaseItem::rotateOperationCopy(const double& dAngle)
{
if(m_pOperationCopy)
m_pOperationCopy->setRotation(dAngle);
}
void GraphicsBaseItem::syncRotationDataFromParent(const double& data)
{
//m_dSyncRotationByParent = rotation() + data;
m_dSyncRotationByParent += data;
//让角度保持在正负180的区间，也就是上下两个半圈，这样易于象限判断
if (m_dSyncRotationByParent > 180)
m_dSyncRotationByParent -= 360;
if (m_dSyncRotationByParent < -180)
m_dSyncRotationByParent += 360;
}
QVariant GraphicsBaseItem::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant& value)
{
if (change == QGraphicsItem::ItemSelectedHasChanged)
{
QGraphicsItemGroup *group = dynamic_cast<QGraphicsItemGroup *>(parentItem());
if(!group)
setHandleVisible(value.toBool());
//setFunctionHandleVisible(false);
else //在某一组群中，由组群展示是否选中，自身不做展示
{
setSelected(false);
return QVariant::fromValue<bool>(false);
}
}
return QGraphicsItem::itemChange(change, value);
}
void GraphicsBaseItem::contextMenuEvent(QGraphicsSceneContextMenuEvent* event)
{
Q_UNUSED(event);
}
void GraphicsBaseItem::setEntity(PowerEntity* pEntity)
{
_pEntity = pEntity;
}
PowerEntity* GraphicsBaseItem::entity()
{
return _pEntity;
}
void GraphicsBaseItem::setLabelTag(const QString& name)
{
m_vecHanle[H_textCaption]->setText(name);
}
QString GraphicsBaseItem::getLabelTag() const
{
return m_vecHanle[H_textCaption]->getText();
}
void GraphicsBaseItem::setLabelCurrent(const QString& str)
{
m_vecHanle[H_textCurrent]->setText(str);
}
QString GraphicsBaseItem::getLabelCurrent() const
{
return m_vecHanle[H_textCurrent]->getText();
}
void GraphicsBaseItem::setLabelVoltage(const QString& str)
{
m_vecHanle[h_textVoltage]->setText(str);
}
QString GraphicsBaseItem::getLabelVoltage() const
{
return m_vecHanle[h_textVoltage]->getText();
}
int GraphicsBaseItem::addPort(PortState typ,QPointF vec,QString id,HandleType hType,PortPos pos)
{
int ntagId = -1;
@ -227,20 +61,58 @@ int GraphicsBaseItem::addPort(PortState typ,QPointF vec,QString id,HandleType hT
return ntagId;
}
/*void GraphicsBaseItem::addPort(PortState typ,int ntagId,QPointF vec)
void GraphicsBaseItem::setEntity(PowerEntity* pEntity)
{
if(typ == p_movable)
{
ItemPort* pPort = new ItemPort(this);
pPort->setType(T_lineInOut);
pPort->setTag(ntagId);
m_vecHanle.insert(ntagId,pPort);
pPort->setPos(vec);
pPort->setParent(this);
_pEntity = pEntity;
}
m_mapPort.insert(QString::number(_portId++),pPort);
PowerEntity* GraphicsBaseItem::entity()
{
return _pEntity;
}
void GraphicsBaseItem::setProperty(ModelProperty* p)
{
if(_property) //已经有对象
{
disconnect(_property,&ModelProperty::updateData,this,&GraphicsBaseItem::onUpdateData); //断开老数据
}
}*/
connect(p,&ModelProperty::updateData,this,&GraphicsBaseItem::onUpdateData);
_property = p;
}
void GraphicsBaseItem::renderSelectBackground(QPainter* painter)
{
int nPenWidth = 1;
painter->setPen(QPen(QColor(135,206,235,180))); //蓝色的外框
painter->setBrush(QBrush(QColor(135,206,235,180)));
double dx = m_boundingRect_selected.x();
double dy = m_boundingRect_selected.y();
double dWidth = m_boundingRect_selected.width();
double dHeight = m_boundingRect_selected.height();
//画弧线0度是3点钟方向
if(dWidth > dHeight)
{
painter->drawRect(m_boundingRect_selected);
painter->drawChord(dx-dHeight*0.5,dy,dHeight,dHeight,90*16,180*16);
painter->drawChord(dx+dWidth-dHeight*0.5,dy,dHeight,dHeight,(-90)*16,180*16);
}
else if(dWidth < dHeight)
{
painter->drawRect(m_boundingRect_selected);
painter->drawChord(dx,dy-dWidth*0.5,dWidth,dWidth,0*16,180*16);
painter->drawChord(dx,dy+dHeight-dWidth*0.5,dWidth,dWidth,180*16,180*16);
//painter->drawChord(dx+dWidth-dHeight*0.5,dy,dHeight,dHeight,(-90)*16,180*16);
}
else
{
painter->drawEllipse(QPointF(dx+dWidth*0.5,dy+dHeight*0.5),dHeight*0.5,dHeight*0.5);
}
}
ItemPort* GraphicsBaseItem::getPortById(QString id) const
{
@ -275,7 +147,192 @@ ItemControlHandle* GraphicsBaseItem::getHandlePtr(int n) const
return nullptr;
}
void GraphicsBaseItem::updateByProperty()
void GraphicsBaseItem::onUpdateData()
{
updateByProperty();
}
/********************************基模****************************************/
GraphicsBaseModelItem::GraphicsBaseModelItem(QGraphicsItem *parent)
:GraphicsBaseItem(parent)
{
}
GraphicsBaseModelItem::~GraphicsBaseModelItem()
{
}
/********************************工程模**************************************/
GraphicsProjectModelItem::GraphicsProjectModelItem(QGraphicsItem *parent)
:GraphicsBaseItem(parent)
{
_lastPort = -1;
//初始化缩放操作用的handle
//m_vecHanle.reserve(H_left);
for(int i = H_leftTop; i <= H_left; i++)
{
ItemControlHandle* pHandle = new HandleRect(this);
pHandle->setType(T_resize);
pHandle->setTag(i);
m_vecHanle.insert(i-1,pHandle);
}
for(int i = H_rotate_leftTop; i <= H_rotate_leftBottom; i++)
{
ItemControlHandle* pHandle = new HandleRect(this);
pHandle->setType(T_rotate);
pHandle->setTag(i);
m_vecHanle.insert(i-1,pHandle);
}
HandleText* pHandle = new HandleText(this);
pHandle->setType(T_text);
pHandle->setTag(H_textCaption);
pHandle->setText(QString("uname"));
pHandle->setPos(30,-30);
pHandle->setParent(this);
m_vecHanle.insert(H_textCaption,pHandle);
connect(pHandle,&HandleText::editFinish,this,&GraphicsProjectModelItem::onEditNameFinish);
HandleText* pCurrent = new HandleText(this); //电流
pCurrent->setEditable(false);
pCurrent->setType(T_text);
pCurrent->setTag(H_textCurrent);
pCurrent->setText(QString("I:"));
pCurrent->setPos(-30,-30);
pCurrent->setParent(this);
m_vecHanle.insert(H_textCurrent,pCurrent);
HandleText* pVoltage = new HandleText(this); //电压
pVoltage->setType(T_text);
pVoltage->setTag(h_textVoltage);
pVoltage->setText(QString("V:"));
pVoltage->setPos(-30,30);
pVoltage->setParent(this);
m_vecHanle.insert(h_textVoltage,pVoltage);
setFlag(QGraphicsItem::ItemIsMovable, true);
setFlag(QGraphicsItem::ItemIsSelectable, true);
setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
}
GraphicsProjectModelItem::~GraphicsProjectModelItem()
{
}
void GraphicsProjectModelItem::createOperationCopy()
{
m_pOperationCopy = new QGraphicsPathItem(this->shape());
m_pOperationCopy->setPen(Qt::DashLine);
m_pOperationCopy->setPos(this->pos());
m_pOperationCopy->setTransformOriginPoint(this->transformOriginPoint());
m_pOperationCopy->setTransform(this->transform());
m_pOperationCopy->setRotation(this->rotation());
m_pOperationCopy->setScale(this->scale());
m_pOperationCopy->setZValue(this->zValue());
QGraphicsScene* scene = this->scene();
if(scene && m_pOperationCopy)
{
scene->addItem(m_pOperationCopy);
m_movingIniPos = this->pos();
}
}
void GraphicsProjectModelItem::removeOperationCopy()
{
QGraphicsScene* scene = this->scene();
if(scene && m_pOperationCopy)
{
if(this->pos() != m_pOperationCopy->pos())
this->setPos(m_pOperationCopy->pos()); //本体移动到副本的位置
if(this->rotation() != m_pOperationCopy->rotation())
this->setRotation(m_pOperationCopy->rotation()); //本体旋转至副本的角度
scene->removeItem(m_pOperationCopy);
delete m_pOperationCopy;
m_pOperationCopy = nullptr;
}
}
void GraphicsProjectModelItem::moveOperationCopy(const QPointF& distance)
{
if(m_pOperationCopy)
m_pOperationCopy->setPos(m_movingIniPos + distance);
}
void GraphicsProjectModelItem::rotateOperationCopy(const double& dAngle)
{
if(m_pOperationCopy)
m_pOperationCopy->setRotation(dAngle);
}
void GraphicsProjectModelItem::syncRotationDataFromParent(const double& data)
{
//m_dSyncRotationByParent = rotation() + data;
m_dSyncRotationByParent += data;
//让角度保持在正负180的区间，也就是上下两个半圈，这样易于象限判断
if (m_dSyncRotationByParent > 180)
m_dSyncRotationByParent -= 360;
if (m_dSyncRotationByParent < -180)
m_dSyncRotationByParent += 360;
}
QVariant GraphicsProjectModelItem::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant& value)
{
if (change == QGraphicsItem::ItemSelectedHasChanged)
{
QGraphicsItemGroup *group = dynamic_cast<QGraphicsItemGroup *>(parentItem());
if(!group)
setHandleVisible(value.toBool());
//setFunctionHandleVisible(false);
else //在某一组群中，由组群展示是否选中，自身不做展示
{
setSelected(false);
return QVariant::fromValue<bool>(false);
}
}
return QGraphicsItem::itemChange(change, value);
}
void GraphicsProjectModelItem::contextMenuEvent(QGraphicsSceneContextMenuEvent* event)
{
Q_UNUSED(event);
}
void GraphicsProjectModelItem::setLabelTag(const QString& name)
{
m_vecHanle[H_textCaption]->setText(name);
}
QString GraphicsProjectModelItem::getLabelTag() const
{
return m_vecHanle[H_textCaption]->getText();
}
void GraphicsProjectModelItem::setLabelCurrent(const QString& str)
{
m_vecHanle[H_textCurrent]->setText(str);
}
QString GraphicsProjectModelItem::getLabelCurrent() const
{
return m_vecHanle[H_textCurrent]->getText();
}
void GraphicsProjectModelItem::setLabelVoltage(const QString& str)
{
m_vecHanle[h_textVoltage]->setText(str);
}
QString GraphicsProjectModelItem::getLabelVoltage() const
{
return m_vecHanle[h_textVoltage]->getText();
}
void GraphicsProjectModelItem::updateByProperty()
{
if(_property)
{
@ -283,23 +340,13 @@ void GraphicsBaseItem::updateByProperty()
}
}
void GraphicsBaseItem::setProperty(BaseProperty* p)
{
if(_property) //已经有对象
{
disconnect(_property,&BaseProperty::updateData,this,&GraphicsBaseItem::onUpdateData); //断开老数据
}
connect(p,&BaseProperty::updateData,this,&GraphicsBaseItem::onUpdateData);
_property = p;
}
void GraphicsBaseItem::unbindProperty()
void GraphicsProjectModelItem::unbindProperty()
{
_property = nullptr;
}
void GraphicsBaseItem::updateConnectData()
void GraphicsProjectModelItem::updateConnectData()
{
QJsonObject obj;
QJsonArray arr;
@ -325,12 +372,8 @@ void GraphicsBaseItem::updateConnectData()
}
}
void GraphicsBaseItem::onEditNameFinish(const QString& str)
void GraphicsProjectModelItem::onEditNameFinish(const QString& str)
{
emit ifExist(m_itemId,str,m_Itemtype,this);
}
void GraphicsBaseItem::onUpdateData()
{
updateByProperty();
}

6
diagramCavas/source/graphicsItem/graphicsItemGroup.cpp
View File

@ -111,7 +111,7 @@ void GraphicsItemGroup::syncRotationDataFromParent(const double& data)
}
else
{
GraphicsBaseItem *baseItem = qgraphicsitem_cast<GraphicsBaseItem*>(item);
GraphicsProjectModelItem *baseItem = qgraphicsitem_cast<GraphicsProjectModelItem*>(item);
if (baseItem)
baseItem->syncRotationDataFromParent(data);
}
@ -193,7 +193,7 @@ void GraphicsItemGroup::resize(int nHandle,double dSX, double dSY, const QPointF
//调用该组内所有item(过滤handle)相关函数
foreach (QGraphicsItem *item, childItems())
{
GraphicsBaseItem *baseItem = qgraphicsitem_cast<GraphicsBaseItem*>(item);
GraphicsProjectModelItem *baseItem = qgraphicsitem_cast<GraphicsProjectModelItem*>(item);
if (baseItem && !qgraphicsitem_cast<ItemControlHandle*>(baseItem))
{
baseItem->resize(nHandle, dSX, dSY, baseItem->mapFromParent(basePoint));
@ -246,7 +246,7 @@ void GraphicsItemGroup::removeOperationCopy()
// }
// else
{
GraphicsBaseItem *baseItem = qgraphicsitem_cast<GraphicsBaseItem*>(item);
GraphicsProjectModelItem *baseItem = qgraphicsitem_cast<GraphicsProjectModelItem*>(item);
if (baseItem)
baseItem->syncRotationDataFromParent(dAngle);
}

4
diagramCavas/source/graphicsItem/graphicsPolygonItem.cpp
View File

@ -5,7 +5,7 @@
#include <QStyleOption>
GraphicPolygonItem::GraphicPolygonItem(QGraphicsItem *parent)
: GraphicsBaseItem(parent)
: GraphicsProjectModelItem(parent)
{
m_pen = QPen(Qt::black);
m_brush = QBrush(Qt::NoBrush);
@ -32,7 +32,7 @@ QRectF GraphicPolygonItem::boundingRect()
void GraphicPolygonItem::updateHandles()
{
GraphicsBaseItem::updateHandles();
GraphicsProjectModelItem::updateHandles();
for(int i = 0; i < m_points.size(); i++)
{
if(m_vecHanle.contains(H_edit + i -1))

4
diagramCavas/source/graphicsItem/graphicsRectItem.cpp
View File

@ -5,7 +5,7 @@
#include <QStyleOption>
GraphicsRectItem::GraphicsRectItem(const QRect &rect, bool isRound, QGraphicsItem *parent)
: GraphicsBaseItem(parent), m_bIsRound(isRound), m_dRatioX(1 / 10.0), m_dRatioY(1 / 10.0)
: GraphicsProjectModelItem(parent), m_bIsRound(isRound), m_dRatioX(1 / 10.0), m_dRatioY(1 / 10.0)
{
m_pen = QPen(Qt::black);
m_brush = QBrush(Qt::NoBrush);
@ -54,7 +54,7 @@ QPainterPath GraphicsRectItem::shape()
void GraphicsRectItem::updateHandles()
{
GraphicsBaseItem::updateHandles();
GraphicsProjectModelItem::updateHandles();
if(m_bIsRound && m_vecHanle.size() == H_edit + 1)
{
const QRectF& boundingRect = this->boundingRect();

1
diagramCavas/source/graphicsItem/itemControlHandle.cpp
View File

@ -1,5 +1,4 @@
#include "graphicsItem/itemControlHandle.h"
#include "graphicsItem/graphicsBaseItem.h"
#include <QPainter>
ItemControlHandle::ItemControlHandle(QGraphicsItem *parent)

2
diagramCavas/source/itemPropertyDlg.cpp
View File

@ -148,7 +148,7 @@ void ItemPropertyDlg::createGroupView(const QString& str)
ui->stackedWidget->addWidget(contentDlg);
}
void ItemPropertyDlg::showDlg(modelDataInfo dataInfo,QUuid uuid,GraphicsBaseItem* pItem)
void ItemPropertyDlg::showDlg(modelDataInfo dataInfo,QUuid uuid,GraphicsProjectModelItem* pItem)
{
groupValue_ = dataInfo.groupInfo;
curUuid_ = uuid;

440
diagramCavas/source/topologyManager.cpp
View File

@ -31,13 +31,12 @@ void TopologyManager::clearAllData()
m_allTerminals.clear(); //端点由父亲entity释放
}
PowerEntity* TopologyManager::createEntity(EntityType type,const QString& uuid, const QString& name)
PowerEntity* TopologyManager::createEntity(EntityType type,const QString& uuid, const QString& name,ModelFunctionType funType)
{
if(funType == ModelFunctionType::ProjectModel)
{
PowerEntity* entity = nullptr;
switch(type) {
case EntityType::ConfigurationDiagram:
entity = new ConfigurationDiagram(uuid,name);
break;
case EntityType::Grid:
case EntityType::Zone:
case EntityType::Station:
@ -49,15 +48,31 @@ PowerEntity* TopologyManager::createEntity(EntityType type,const QString& uuid,
m_entities.insert(entity->id(), entity);
emit entityCreated(entity->id()); // 发送信号通知
return entity;
}
else if(funType == ModelFunctionType::BaseModel)
{
PowerEntity* entity = nullptr;
entity = new PowerComponent(type, uuid,name);
m_baseEntities.insert(entity->id(), entity);
emit entityCreated(entity->id()); // 发送信号通知
return entity;
}
return nullptr;
}
PowerEntity* TopologyManager::findEntity(const QString& id) const
PowerEntity* TopologyManager::findEntity(const QString& id,ModelFunctionType funType) const
{
if(funType == ModelFunctionType::ProjectModel)
return m_entities.value(id, nullptr); // 避免异常的安全查询
else if(funType == ModelFunctionType::BaseModel)
return m_baseEntities.value(id, nullptr);
}
bool TopologyManager::deleteEntity(const QString& id)
bool TopologyManager::deleteEntity(const QString& id,ModelFunctionType funType)
{
if(funType == ModelFunctionType::ProjectModel)
{
if (!m_entities.contains(id)) return false;
PowerEntity* entity = m_entities[id];
@ -86,11 +101,44 @@ bool TopologyManager::deleteEntity(const QString& id)
emit entityDeleted(id);
return true;
}
else if(funType == ModelFunctionType::BaseModel)
{
if (!m_baseEntities.contains(id)) return false;
PowerEntity* entity = m_baseEntities[id];
// 步骤1：删除所有相关连接
auto relatedConns = getConnectionsFor(id,funType);
for (auto conn : relatedConns) {
removeConnection(conn->id(),funType);
}
// 步骤2：从父节点移除（防止悬空指针）
if (PowerEntity* parent = entity->parent()) {
parent->removeChild(entity);
}
// 步骤3：递归删除子实体
auto children = entity->children();
for (auto child : children) {
deleteEntity(child->id(),funType); // 递归删除
}
// 步骤4：从哈希表移除并释放内存
m_baseEntities.remove(id);
delete entity; // 触发PowerEntity析构函数
emit entityDeleted(id);
return true;
}
}
PowerConnection* TopologyManager::createConnection(const QString& connId,const QString& fromTerId, const QString& toTerId,const QString& fromId,const QString& toId)
PowerConnection* TopologyManager::createConnection(const QString& connId,const QString& fromTerId, const QString& toTerId,const QString& fromId,const QString& toId,ModelFunctionType funType)
{
PowerConnection* conn = nullptr;
if(funType == ModelFunctionType::ProjectModel)
{
// 验证有效性
if (!m_allTerminals.contains(fromTerId) ||
!m_allTerminals.contains(toTerId) ||
@ -110,7 +158,7 @@ PowerConnection* TopologyManager::createConnection(const QString& connId,const Q
}
// 创建新连接
PowerConnection* conn = new PowerConnection(connId,fromTerId, toTerId,fromId,toId);
conn = new PowerConnection(connId,fromTerId, toTerId,fromId,toId);
m_connections[connId] = conn;
// 更新索引
@ -118,16 +166,51 @@ PowerConnection* TopologyManager::createConnection(const QString& connId,const Q
m_connectionIndex.insert(toTerId, conn);
emit connectionCreated(connId);
}
else if(funType == ModelFunctionType::BaseModel)
{
// 验证有效性
if (!m_baseAllTerminals.contains(fromTerId) ||
!m_baseAllTerminals.contains(toTerId) ||
fromTerId == toTerId)
{
qWarning() << "Invalid connection endpoints";
return nullptr;
}
// 防止重复连接
foreach (auto conn, m_baseConnections) {
if (conn->fromTerminalId() == fromTerId &&
conn->toTerminalId() == toTerId)
{
return conn; // 返回已存在的连接
}
}
// 创建新连接
conn = new PowerConnection(connId,fromTerId, toTerId,fromId,toId);
m_baseConnections[connId] = conn;
// 更新索引
m_baseConnectionIndex.insert(fromTerId, conn);
m_baseConnectionIndex.insert(toTerId, conn);
emit connectionCreated(connId);
}
return conn;
}
QList<PowerConnection*> TopologyManager::getConnectionsForTerminal(const QString& terminalId) const
QList<PowerConnection*> TopologyManager::getConnectionsForTerminal(const QString& terminalId,ModelFunctionType funType) const
{
if(funType == ModelFunctionType::ProjectModel)
return m_connectionIndex.values(terminalId);
else if(funType == ModelFunctionType::BaseModel)
return m_baseConnectionIndex.values(terminalId);
}
void TopologyManager::removeConnection(const QString& connId)
void TopologyManager::removeConnection(const QString& connId,ModelFunctionType funType)
{
if(funType == ModelFunctionType::ProjectModel){
if (!m_connections.contains(connId)) return;
PowerConnection* conn = m_connections[connId];
@ -141,10 +224,27 @@ void TopologyManager::removeConnection(const QString& connId)
delete conn;
emit connectionRemoved(connId);
}
else if(funType == ModelFunctionType::BaseModel){
if (!m_baseConnections.contains(connId)) return;
PowerConnection* conn = m_baseConnections[connId];
// 更新索引
m_baseConnectionIndex.remove(conn->fromTerminalId(), conn);
m_baseConnectionIndex.remove(conn->toTerminalId(), conn);
// 清理内存
m_baseConnections.remove(connId);
delete conn;
emit connectionRemoved(connId);
}
}
bool TopologyManager::validateConnection(const QString& fromTermId, const QString& toTermId) const
bool TopologyManager::validateConnection(const QString& fromTermId, const QString& toTermId,ModelFunctionType funType) const
{
if(funType == ModelFunctionType::ProjectModel){
PowerTerminal* fromTerm = getTerminal(fromTermId);
PowerTerminal* toTerm = getTerminal(toTermId);
@ -167,39 +267,67 @@ bool TopologyManager::validateConnection(const QString& fromTermId, const QStrin
return false;
}
int a =1;
// 禁止自连接
return (fromTerm->parentEntityId() != toTerm->parentEntityId());
}
else if(funType == ModelFunctionType::BaseModel){
PowerTerminal* fromTerm = getTerminal(fromTermId,funType);
PowerTerminal* toTerm = getTerminal(toTermId,funType);
if (!fromTerm || !toTerm) return false;
// 类型兼容性检查（示例规则）
switch(fromTerm->type()) {
case TerminalType::PowerOutput:
if (toTerm->type() != TerminalType::PowerInput && toTerm->type() != TerminalType::PowerConnect) return false;
break;
case TerminalType::PowerInput:
if (toTerm->type() != TerminalType::PowerOutput && toTerm->type() != TerminalType::PowerConnect) return false;
break;
case TerminalType::PowerConnect:
break;
case TerminalType::ControlSignal:
if (toTerm->type() != TerminalType::ControlSignal) return false;
break;
default:
return false;
}
// 禁止自连接
return (fromTerm->parentEntityId() != toTerm->parentEntityId());
}
}
// 连接查询接口
QList<PowerConnection*> TopologyManager::connectionsFrom(const QString& elementId) const
/*QList<PowerConnection*> TopologyManager::connectionsFrom(const QString& elementId) const
{
QList<PowerConnection*> res;
/*QList<PowerConnection*> lst = m_connectionIndex.values(elementId);
QList<PowerConnection*> lst = m_connectionIndex.values(elementId);
for(auto &val:lst)
{
if(val->fromTerminalId() == elementId)
res.append(val);
}*/
}
return res;
}
}*/
QList<PowerConnection*> TopologyManager::connectionsTo(const QString& elementId) const
/*QList<PowerConnection*> TopologyManager::connectionsTo(const QString& elementId) const
{
QList<PowerConnection*> res;
/*QList<PowerConnection*> lst = m_connectionIndex.values(elementId);
QList<PowerConnection*> lst = m_connectionIndex.values(elementId);
for(auto &val:lst)
{
if(val->toTerminalId() == elementId)
res.append(val);
}*/
}
return res;
}
}*/
QList<PowerConnection*> TopologyManager::getConnectionsFor(const QString& entityId) const
QList<PowerConnection*> TopologyManager::getConnectionsFor(const QString& entityId,ModelFunctionType funType) const
{
QList<PowerConnection*> lst;
if(funType == ModelFunctionType::ProjectModel)
{
QList<PowerTerminal*> lstTerminal = getTerminalsForEntity(entityId);
for(auto &terminal:lstTerminal)
{
@ -207,152 +335,124 @@ QList<PowerConnection*> TopologyManager::getConnectionsFor(const QString& entity
if(con)
lst.append(con);
}
}
else if(funType == ModelFunctionType::BaseModel)
{
QList<PowerTerminal*> lstTerminal = getTerminalsForEntity(entityId,funType);
for(auto &terminal:lstTerminal)
{
PowerConnection* con = getConnectionContainsTerminal(terminal->id(),funType);
if(con)
lst.append(con);
}
}
return lst;
}
PowerConnection* TopologyManager::connection(const QString& conId) const
PowerConnection* TopologyManager::connection(const QString& conId,ModelFunctionType funType) const
{
if(funType == ModelFunctionType::ProjectModel)
return m_connections.value(conId,nullptr);
else if(funType == ModelFunctionType::BaseModel)
return m_baseConnections.value(conId,nullptr);
return nullptr;
}
PowerConnection* TopologyManager::connection(const QString& fromPin,const QString& toPin)
PowerConnection* TopologyManager::connection(const QString& fromPin,const QString& toPin,ModelFunctionType funType)
{
if(funType == ModelFunctionType::ProjectModel){
for(auto &con:m_connections)
{
if(con->fromTerminalId() == fromPin && con->toTerminalId() == toPin)
return con;
}
}
else if(funType == ModelFunctionType::BaseModel){
for(auto &con:m_baseConnections)
{
if(con->fromTerminalId() == fromPin && con->toTerminalId() == toPin)
return con;
}
}
return nullptr;
}
QHash<QString,PowerConnection*> TopologyManager::getAllConnections()
QHash<QString,PowerConnection*> TopologyManager::getAllConnections(ModelFunctionType funType)
{
if(funType == ModelFunctionType::ProjectModel)
return m_connections;
else if(funType == ModelFunctionType::BaseModel)
return m_baseConnections;
}
/*void TopologyManager::saveToDB(const QString& path)
{
QJsonObject root;
// 序列化实体（含接线点）
QJsonArray entities;
foreach (auto entity, m_entities) {
QJsonObject entObj = entity->toJson();
QJsonArray terminalsArray;
foreach (auto term, entity->terminals()) {
terminalsArray.append(term->toJson());
}
entObj["terminals"] = terminalsArray;
entities.append(entObj);
}
root["entities"] = entities;
QJsonArray connectionsArray;
for (auto conn : m_connections)
connectionsArray.append(conn->toJson());
root["connections"] = connectionsArray;
//todo:写入到数据库
}*/
/*void TopologyManager::loadFromDB(const QString& path)
{
//todo::将读到的字为json
QString strJson;
QJsonDocument doc = QJsonDocument::fromJson(strJson.toLocal8Bit());
QJsonObject root = doc.object();
clearAllData(); // 清除现有数据
// 阶段1：创建所有实体
QHash<QString, QStringList> pendingChildren;
QJsonArray entities = root["entities"].toArray();
foreach (QJsonValue entVal, entities) {
QJsonObject entObj = entVal.toObject();
// 创建实体
EntityType type = static_cast<EntityType>(entObj["type"].toInt());
QString id = entObj["id"].toString();
QString name = entObj["name"].toString();
PowerEntity* entity = createEntity(type, id, name);
foreach (auto termJson, entObj["terminals"].toArray()) {
PowerTerminal* term = PowerTerminal::fromJson(termJson.toObject(), entity);
m_allTerminals[term->id()] = term;
m_terminalsByEntity[entity->id()].append(term);
}
// 记录待处理的子关系
pendingChildren[id] = entObj["children"].toVariant().toStringList();
}
// 阶段2：建立父子关系
QHashIterator<QString, QStringList> it(pendingChildren);
while (it.hasNext()) {
it.next();
PowerEntity* parent = getEntity(it.key());
if (!parent) continue;
foreach (QString childId, it.value()) {
if (PowerEntity* child = getEntity(childId)) {
parent->addChild(child);
}
}
}
// 阶段3：创建连接
QJsonArray connections = root["connections"].toArray();
foreach (QJsonValue connVal, connections) {
QJsonObject connObj = connVal.toObject();
createConnection(
connObj["id"].toString(),
connObj["from"].toString(),
connObj["to"].toString()
);
}
}*/
PowerEntity* TopologyManager::getEntity(const QString& id) const
PowerEntity* TopologyManager::getEntity(const QString& id,ModelFunctionType funType) const
{
if(funType == ModelFunctionType::ProjectModel){
auto it = m_entities.find(id);
return (it != m_entities.end()) ? it.value() : nullptr;
}
else if(funType == ModelFunctionType::BaseModel){
auto it = m_baseEntities.find(id);
return (it != m_baseEntities.end()) ? it.value() : nullptr;
}
return nullptr;
}
QList<PowerEntity*> TopologyManager::findEntitiesByName(const QString& name) const
QList<PowerEntity*> TopologyManager::findEntitiesByName(const QString& name,ModelFunctionType funType) const
{
QList<PowerEntity*> results;
if(funType == ModelFunctionType::ProjectModel){
foreach (auto entity, m_entities) {
if (entity->name() == name) {
results.append(entity);
}
}
}
else if(funType == ModelFunctionType::BaseModel){
foreach (auto entity, m_baseEntities) {
if (entity->name() == name) {
results.append(entity);
}
}
}
return results;
}
PowerEntity* TopologyManager::createDiagram(const QString& id,const QString& name)
PowerEntity* TopologyManager::createDiagram(const QString& id,const QString& name,ModelFunctionType funType)
{
PowerEntity* entity = nullptr;
if(funType == ModelFunctionType::ProjectModel){
if(!m_diagrams.contains(id))
{
entity = new ConfigurationDiagram(id,name);
m_diagrams.insert(entity->id(), entity);
}
}
else if(funType == ModelFunctionType::BaseModel){
if(!m_baseDiagrams.contains(id))
{
entity = new ConfigurationDiagram(id,name);
m_baseDiagrams.insert(entity->id(), entity);
}
}
return entity;
}
PowerEntity* TopologyManager::findDiagram(const QString& id) const
PowerEntity* TopologyManager::findDiagram(const QString& id,ModelFunctionType funType) const
{
if(funType == ModelFunctionType::ProjectModel)
return m_diagrams.value(id, nullptr); // 避免异常的安全查询
else if(funType == ModelFunctionType::BaseModel)
return m_baseDiagrams.value(id, nullptr);
return nullptr;
}
bool TopologyManager::deleteDiagram(const QString& id)
bool TopologyManager::deleteDiagram(const QString& id,ModelFunctionType funType)
{
if(funType == ModelFunctionType::ProjectModel){
if (!m_diagrams.contains(id)) return false;
PowerEntity* entity = m_diagrams[id];
@ -374,13 +474,38 @@ bool TopologyManager::deleteDiagram(const QString& id)
delete entity; // 触发析构函数
return true;
}
else if(funType == ModelFunctionType::BaseModel){
if (!m_baseDiagrams.contains(id)) return false;
PowerEntity* entity = m_baseDiagrams[id];
// 步骤2：从父节点移除（防止悬空指针）
if (PowerEntity* parent = entity->parent()) {
parent->removeChild(entity);
}
// 步骤3：递归删除子实体
auto children = entity->children();
for (auto child : children) {
deleteDiagram(child->id(),funType); // 递归删除
}
// 步骤4：从哈希表移除并释放内存
m_baseDiagrams.remove(id);
delete entity; // 触发析构函数
return true;
}
}
PowerTerminal* TopologyManager::createTerminal(const QString& parentEntityId,
TerminalType type,
const QString& name,
const QPointF& relPos,
const QString& uuid) {
const QString& uuid,
ModelFunctionType funType) {
if(funType == ModelFunctionType::ProjectModel){
if (!m_entities.contains(parentEntityId)) return nullptr;
PowerTerminal* term = new PowerTerminal(parentEntityId, type, name, relPos, uuid);
@ -393,9 +518,25 @@ PowerTerminal* TopologyManager::createTerminal(const QString& parentEntityId,
}
return term;
}
else if(funType == ModelFunctionType::BaseModel){
if (!m_baseEntities.contains(parentEntityId)) return nullptr;
PowerTerminal* term = new PowerTerminal(parentEntityId, type, name, relPos, uuid);
m_baseAllTerminals[term->id()] = term;
m_baseTerminalsByEntity[parentEntityId].append(term);
// 关联到父实体
if (PowerEntity* parent = getEntity(parentEntityId,funType)) {
parent->addTerminal(term);
}
return term;
}
}
bool TopologyManager::deleteTerminal(const QString& terminalId) {
bool TopologyManager::deleteTerminal(const QString& terminalId,ModelFunctionType funType) {
if(funType == ModelFunctionType::ProjectModel){
if (!m_allTerminals.contains(terminalId)) return false;
PowerTerminal* term = m_allTerminals[terminalId];
@ -409,23 +550,52 @@ bool TopologyManager::deleteTerminal(const QString& terminalId) {
// 清理全局存储
m_terminalsByEntity[parentId].removeAll(term);
m_allTerminals.remove(terminalId);
//delete term; //在parent中已经delete
return true;
}
else if(funType == ModelFunctionType::BaseModel){
if (!m_baseAllTerminals.contains(terminalId)) return false;
PowerTerminal* term = m_baseAllTerminals[terminalId];
QString parentId = term->parentEntityId();
// 从父实体移除
if (PowerEntity* parent = getEntity(parentId,funType)) {
parent->removeTerminal(terminalId);
}
// 清理全局存储
m_baseTerminalsByEntity[parentId].removeAll(term);
m_baseAllTerminals.remove(terminalId);
return true;
}
}
PowerTerminal* TopologyManager::getTerminal(const QString& terminalId) const
PowerTerminal* TopologyManager::getTerminal(const QString& terminalId,ModelFunctionType funType) const
{
if(funType == ModelFunctionType::ProjectModel){
auto it = m_allTerminals.find(terminalId);
return (it != m_allTerminals.end()) ? it.value() : nullptr;
}
else if(funType == ModelFunctionType::BaseModel){
auto it = m_baseAllTerminals.find(terminalId);
return (it != m_baseAllTerminals.end()) ? it.value() : nullptr;
}
return nullptr;
}
QList<PowerTerminal*> TopologyManager::getTerminalsForEntity(const QString& entityId) const {
QList<PowerTerminal*> TopologyManager::getTerminalsForEntity(const QString& entityId,ModelFunctionType funType) const {
if(funType == ModelFunctionType::ProjectModel)
return m_terminalsByEntity.value(entityId);
else if(funType == ModelFunctionType::BaseModel)
return m_baseTerminalsByEntity.value(entityId);
}
PowerEntity* TopologyManager::getEntityByTerminal(const QString& terminalId) const
PowerEntity* TopologyManager::getEntityByTerminal(const QString& terminalId,ModelFunctionType funType) const
{
if(funType == ModelFunctionType::ProjectModel){
QHash<QString, QList<PowerTerminal*>>::ConstIterator iter;
for(iter = m_terminalsByEntity.begin();iter != m_terminalsByEntity.end();++iter)
{
@ -437,11 +607,27 @@ PowerEntity* TopologyManager::getEntityByTerminal(const QString& terminalId) con
}
}
}
}
else if(funType == ModelFunctionType::BaseModel){
QHash<QString, QList<PowerTerminal*>>::ConstIterator iter;
for(iter = m_baseTerminalsByEntity.begin();iter != m_baseTerminalsByEntity.end();++iter)
{
for(auto &terminal:iter.value())
{
if(terminal->id() == terminalId)
{
return m_baseEntities[iter.key()];
}
}
}
}
return nullptr;
}
PowerConnection* TopologyManager::getConnectionContainsTerminal(const QString& terminalId) const
PowerConnection* TopologyManager::getConnectionContainsTerminal(const QString& terminalId,ModelFunctionType funType) const
{
if(funType == ModelFunctionType::ProjectModel){
for(auto &con:m_connections)
{
if(con->fromTerminalId() == terminalId || con->toTerminalId() == terminalId)
@ -449,5 +635,15 @@ PowerConnection* TopologyManager::getConnectionContainsTerminal(const QString& t
return con;
}
}
}
else if(funType == ModelFunctionType::BaseModel){
for(auto &con:m_baseConnections)
{
if(con->fromTerminalId() == terminalId || con->toTerminalId() == terminalId)
{
return con;
}
}
}
return nullptr;
}

14
diagramCavas/source/util/baseSelector.cpp
View File

@ -47,7 +47,7 @@ void BaseSelector::mousePressEvent(QGraphicsSceneMouseEvent* event, DesignerScen
QList<QGraphicsItem *> items = scene->selectedItems();
if (items.count() == 1) //只有一个选中
{
GraphicsBaseItem* item = qgraphicsitem_cast<GraphicsBaseItem*>(items.first());
GraphicsProjectModelItem* item = qgraphicsitem_cast<GraphicsProjectModelItem*>(items.first());
if(item)
{
GraphicsItemType tpe = item->getItemType();
@ -116,7 +116,7 @@ void BaseSelector::mousePressEvent(QGraphicsSceneMouseEvent* event, DesignerScen
ItemControlHandle* pHandle = qgraphicsitem_cast<ItemControlHandle*>(items.first());
if(pHandle)
{
//GraphicsBaseItem* item = pHandle->getParentPtr();
//GraphicsProjectModelItem* item = pHandle->getParentPtr();
ms_nDragHandle = pHandle->getTag();
//ms_nDragHandle = item->collidesWithHandle(event->scenePos());
if(ms_nDragHandle >= H_textCaption && ms_nDragHandle < H_connect) //移动文本
@ -134,7 +134,7 @@ void BaseSelector::mousePressEvent(QGraphicsSceneMouseEvent* event, DesignerScen
for(int n = 0; n < items.size(); n++)
{
//创建副本
GraphicsBaseItem* item = qgraphicsitem_cast<GraphicsBaseItem*>(items.at(n));
GraphicsProjectModelItem* item = qgraphicsitem_cast<GraphicsProjectModelItem*>(items.at(n));
GraphicsItemType tpe = item->getItemType();
if(tpe == GIT_link)
continue;
@ -370,7 +370,7 @@ void BaseSelector::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event, Design
}
else if(items.count() == 1) //不是文字节点
{
GraphicsBaseItem* item = qgraphicsitem_cast<GraphicsBaseItem*>(items.first());
GraphicsProjectModelItem* item = qgraphicsitem_cast<GraphicsProjectModelItem*>(items.first());
if(item)
{
GraphicsItemType tpe = item->getItemType();
@ -410,7 +410,7 @@ void BaseSelector::dropEvent(QGraphicsSceneDragDropEvent *event, DesignerScene*)
event->acceptProposedAction();
//根据data数据新增拖拽的item
QMap<QUuid,GraphicsBaseItem*> items = _model->allItems();
QMap<QUuid,GraphicsProjectModelItem*> items = _model->allItems();
if(items.contains(QUuid(uuid))){
QMessageBox::information(NULL, QString::fromWCharArray(L"提示"), QString::fromWCharArray(L"此对象在当前页已存在"));
return;
@ -437,7 +437,7 @@ void BaseSelector::contextMenuEvent(QGraphicsSceneContextMenuEvent *event,Design
return;
else if(listItem.count() == 1)
{
GraphicsBaseItem* item = qgraphicsitem_cast<GraphicsBaseItem*>(listItem.first());
GraphicsProjectModelItem* item = qgraphicsitem_cast<GraphicsProjectModelItem*>(listItem.first());
if(item)
{
GraphicsItemType tpe = item->getItemType();
@ -464,7 +464,7 @@ void BaseSelector::updateConnectLineByTopology(QList<QGraphicsItem *> lst)
{
for(auto iter:lst) //更新连接线
{
auto item = dynamic_cast<GraphicsBaseItem*>(iter);
auto item = dynamic_cast<GraphicsProjectModelItem*>(iter);
if(item)
{
if(item->getItemType() != GIT_link) //获取非电缆对象

8
diagramCavas/source/util/connectingSelector.cpp
View File

@ -27,7 +27,7 @@ void ConnectingSelector::mousePressEvent(QGraphicsSceneMouseEvent* event, Design
}
bool ConnectingSelector::targetCouldConnect(GraphicsBaseItem* p,QPointF pos)
bool ConnectingSelector::targetCouldConnect(GraphicsProjectModelItem* p,QPointF pos)
{
GraphicsItemType iType = p->getItemType();
if(iType == GIT_bus)
@ -88,7 +88,7 @@ void ConnectingSelector::setTargetHighLight(bool val)
}
}
void ConnectingSelector::createConnectLline(GraphicsBaseItem* connectingItem,GraphicsBaseItem* touchedItem,DesignerScene* scene)
void ConnectingSelector::createConnectLline(GraphicsProjectModelItem* connectingItem,GraphicsProjectModelItem* touchedItem,DesignerScene* scene)
{
if (!_model->isItemValid(connectingItem) || !_model->isItemValid(touchedItem)) {
QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"请先完成设备命名"));
@ -153,7 +153,7 @@ void ConnectingSelector::mouseMoveEvent(QGraphicsSceneMouseEvent* event, Designe
QList<QGraphicsItem *> items = scene->selectedItems();
if (items.count() == 1)
{
GraphicsBaseItem* item = qgraphicsitem_cast<GraphicsBaseItem*>(items.first());
GraphicsProjectModelItem* item = qgraphicsitem_cast<GraphicsProjectModelItem*>(items.first());
if(item)
{
if(ms_nDragHandle >= H_connect) //操作的是port端点
@ -184,7 +184,7 @@ void ConnectingSelector::mouseMoveEvent(QGraphicsSceneMouseEvent* event, Designe
QList<QGraphicsItem *> items = scene->items(ms_ptMouseLast);
if (items.count() == 1)
{
GraphicsBaseItem* item = dynamic_cast<GraphicsBaseItem*>(items.first());
GraphicsProjectModelItem* item = dynamic_cast<GraphicsProjectModelItem*>(items.first());
if(item)
{
QUuid n1 = item->itemId();

2
diagramCavas/source/util/creatingSelector.cpp
View File

@ -4,8 +4,6 @@
#include "graphicsItem/electricSvgItemBus.h"
#include "graphicsItem/electricSvgItemRect.h"
#include "graphicsItem/electricSvgItemTriangle.h"
#include "graphicsItem/itemPort.h"
#include "topologyManager.h"
#include "global.h"
#include <QGraphicsSceneMouseEvent>
#include <QGraphicsView>

4
diagramCavas/source/util/editingSelector.cpp
View File

@ -24,7 +24,7 @@ void EditingSelector::mouseMoveEvent(QGraphicsSceneMouseEvent* event, DesignerSc
QList<QGraphicsItem *> items = scene->selectedItems();
if (items.count() == 1)
{
GraphicsBaseItem* item = qgraphicsitem_cast<GraphicsBaseItem*>(items.first());
GraphicsProjectModelItem* item = qgraphicsitem_cast<GraphicsProjectModelItem*>(items.first());
if(item)
{
if(ms_nDragHandle > H_left)
@ -40,7 +40,7 @@ void EditingSelector::mouseReleaseEvent(QGraphicsSceneMouseEvent* event, Designe
QList<QGraphicsItem *> items = scene->selectedItems();
if (items.count() == 1)
{
GraphicsBaseItem* item = qgraphicsitem_cast<GraphicsBaseItem*>(items.first());
GraphicsProjectModelItem* item = qgraphicsitem_cast<GraphicsProjectModelItem*>(items.first());
if(item && ms_ptMouseLast != ms_ptMouseDown)
{
item->updateCoordinate();

24
diagramCavas/source/util/movingSelector.cpp
View File

@ -45,7 +45,7 @@ void MovingSelector::mouseReleaseEvent(QGraphicsSceneMouseEvent* event, Designer
if(item)
item->removeOperationCopy();
}
//updateConnectLine(items);
updateConnectLineByTopology(items);
setCursor(scene, Qt::ArrowCursor);
@ -53,26 +53,4 @@ void MovingSelector::mouseReleaseEvent(QGraphicsSceneMouseEvent* event, Designer
emit setWorkingSelector(ST_base);
}
/*void MovingSelector::updateConnectLine(QList<QGraphicsItem *> lst)
{
for(auto iter:lst) //更新连接线
{
auto item = dynamic_cast<GraphicsBaseItem*>(iter);
if(item)
{
if(item->getItemType() != GIT_link)
{
QUuid nId = item->itemId();
for(auto pPort:item->getPorts())
{
if(pPort->connected())
{
auto pConnect = pPort->getConnectPtr();
pConnect->updateConnection(nId,pPort->scenePos());
}
}
}
}
}
}*/

2
diagramCavas/source/util/subMovingSelector.cpp
View File

@ -33,7 +33,7 @@ void SubMovingSelector::mouseMoveEvent(QGraphicsSceneMouseEvent* event, Designer
ItemControlHandle* pHandle = qgraphicsitem_cast<ItemControlHandle*>(items.first());
if(pHandle)
{
GraphicsBaseItem* item = pHandle->getParentPtr();
GraphicsProjectModelItem* item = dynamic_cast<GraphicsProjectModelItem*>(pHandle->getParentPtr());
if(item)
{
if(ms_nDragHandle >= H_textCaption && ms_nDragHandle < H_connect) //移动文本

9
diagramUtils/include/basePropertyManager.h
View File

@ -7,6 +7,7 @@
/****元件属性数据管理类*****/
class BaseProperty;
class BaseModelProperty;
class DIAGRAM_DESIGNER_PUBLIC BasePropertyManager : public QObject
{
@ -23,12 +24,18 @@ public:
BaseProperty* findEntityData(QUuid);
void deleteEntityData(QUuid);
QMap<QUuid,BaseProperty*> getEntityData() const;
void insertBaseEntityData(QUuid,BaseModelProperty*);
BaseModelProperty* findBaseEntityData(QUuid);
void deleteBaseEntityData(QUuid);
QMap<QUuid,BaseModelProperty*> getBaseEntityData() const;
signals:
void dataCreated(QString uuid);
void dataChanged(QString uuid);
public slots:
void onDataDelete(QString uuid);
private:
QMap<QUuid,BaseProperty*> m_entityData; //每个实例化元件的唯一数据
QMap<QUuid,BaseProperty*> m_entityData; //工程模实例化元件的唯一数据
QMap<QUuid,BaseModelProperty*> m_baseEntityData; //基模实例元件数据
};
#endif // BASEPROPERTYMANAGER_H

22
diagramUtils/source/basePropertyManager.cpp
View File

@ -47,3 +47,25 @@ void BasePropertyManager::onDataDelete(QString uuid)
{
}
/***************************基模数据******************************/
void BasePropertyManager::insertBaseEntityData(QUuid uid,BaseModelProperty* p)
{
if(!m_baseEntityData.contains(uid))
m_baseEntityData.insert(uid,p);
}
BaseModelProperty* BasePropertyManager::findBaseEntityData(QUuid uid)
{
return m_baseEntityData.value(uid,nullptr);
}
void BasePropertyManager::deleteBaseEntityData(QUuid uid)
{
BaseModelProperty* pData = m_baseEntityData.value(uid,nullptr);
if(pData)
delete pData;
}
QMap<QUuid,BaseModelProperty*> BasePropertyManager::getBaseEntityData() const
{
return m_baseEntityData;
}