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 <QJsonObject>
#include "global.h" #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 Q_OBJECT
public: public:
BaseProperty(QObject* parent); BaseProperty(QObject* parent);
virtual ~BaseProperty(); 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;} void setPath(QString s){sPath = s;}
QString path() const {return sPath;} QString path() const {return sPath;}
void setDescription(QString s) {sDescription = s;} void setDescription(QString s) {sDescription = s;}
@ -36,8 +77,6 @@ public:
QJsonObject connectedBus() const {return jConnectedBus;} QJsonObject connectedBus() const {return jConnectedBus;}
void setLabel(QJsonObject j){jLabel = j;} void setLabel(QJsonObject j){jLabel = j;}
QJsonObject label() const {return jLabel;} QJsonObject label() const {return jLabel;}
void setContext(QJsonObject j){jContext = j;}
QJsonObject context() const {return jContext;}
void setGrid(const QString& s) {sGrid = s;} void setGrid(const QString& s) {sGrid = s;}
QString grid() const {return sGrid;} QString grid() const {return sGrid;}
void setZone(const QString& s) {sZone = s;} void setZone(const QString& s) {sZone = s;}
@ -49,15 +88,7 @@ public:
bool prepareDelete() const {return _prepareDelete;} bool prepareDelete() const {return _prepareDelete;}
void setDataChanged(bool b) {_dataChanged = b;} //数据变换标签 void setDataChanged(bool b) {_dataChanged = b;} //数据变换标签
bool dataChanged() const {return _dataChanged;} bool dataChanged() const {return _dataChanged;}
void notifyUpdate(){emit updateData();}
signals:
void updateData(); //通知数据拥有者更新
protected: protected:
QUuid uUid;
QString sModelName; //模型名
int nType; //设备类型
QString sTag;
QString sName;
QString sPath; QString sPath;
QString sDescription; QString sDescription;
QString sGrid; QString sGrid;
@ -68,7 +99,6 @@ protected:
int nStatus; int nStatus;
QJsonObject jConnectedBus; QJsonObject jConnectedBus;
QJsonObject jLabel; QJsonObject jLabel;
QJsonObject jContext; //存放port信息
bool _dataChanged; //数据状态,为真则写入库 bool _dataChanged; //数据状态,为真则写入库
bool _prepareDelete; //状态，为真准备删除 bool _prepareDelete; //状态，为真准备删除

130
common/include/global.h
View File

@ -28,7 +28,11 @@ enum GraphicsItemType
GIT_bus = QGraphicsItem::UserType + 50, GIT_bus = QGraphicsItem::UserType + 50,
GIT_itemRect = QGraphicsItem::UserType + 51, GIT_itemRect = QGraphicsItem::UserType + 51,
GIT_itemTri = QGraphicsItem::UserType + 52, 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 //工程模关联的对象类型 enum AbstractItemType //工程模关联的对象类型
@ -37,6 +41,12 @@ enum AbstractItemType //工程模关联的对象类型
AIT_bus AIT_bus
}; };
enum class ModelFunctionType //模型函数的类型
{
ProjectModel = 0,
BaseModel
};
class corresbondItem //类型关联函数 class corresbondItem //类型关联函数
{ {
public: public:
@ -47,7 +57,8 @@ enum DiagramMode //组态图模式
{ {
DM_edit = 0, DM_edit = 0,
DM_run, DM_run,
DM_academic DM_academic,
DM_baseModel
}; };
enum VariantIcon //变种图 enum VariantIcon //变种图
@ -181,6 +192,16 @@ struct projectManager //工程模管理类
QJsonObject checkState; //属性选择状态 QJsonObject checkState; //属性选择状态
}; };
/*struct baseModelSelectManger
{
int id = 0;
QUuid componentId;
QString componentTag;
int pageId;
int version;
QJsonObject checkState;
};*/
enum projectState enum projectState
{ {
Err = -1, 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 { enum class EntityType {
Grid, Grid,

36
common/source/baseProperty.cpp
View File

@ -1,10 +1,42 @@
#include "baseProperty.h" #include "baseProperty.h"
#include "dataManager.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) BaseProperty::BaseProperty(QObject* parent)
: QObject(parent) : ModelProperty(parent)
{ {
nType = 0; //设备类型 nType = 0; //设备类型
bInService = true; bInService = true;

6
diagramCavas/CMakeLists.txt
View File

@ -42,6 +42,9 @@ set(DIAGRAMCAVAS_HEADER_FILES
include/graphicsItem/handleText.h include/graphicsItem/handleText.h
include/graphicsItem/itemControlHandle.h include/graphicsItem/itemControlHandle.h
include/graphicsItem/itemPort.h include/graphicsItem/itemPort.h
include/baseModelItem/electricBaseModelSvgItem.h
include/baseModelItem/electricBaseModelLineItem.h
include/baseModelItem/electricBaseModelSvgBus.h
include/util/baseSelector.h include/util/baseSelector.h
include/util/connectingSelector.h include/util/connectingSelector.h
include/util/creatingSelector.h include/util/creatingSelector.h
@ -101,6 +104,9 @@ set(DIAGRAMCAVAS_SOURCE_FILES
source/graphicsItem/handleText.cpp source/graphicsItem/handleText.cpp
source/graphicsItem/itemControlHandle.cpp source/graphicsItem/itemControlHandle.cpp
source/graphicsItem/itemPort.cpp source/graphicsItem/itemPort.cpp
source/baseModelItem/electricBaseModelSvgItem.cpp
source/baseModelItem/electricBaseModelLineItem.cpp
source/baseModelItem/electricBaseModelSvgBus.cpp
source/util/baseSelector.cpp source/util/baseSelector.cpp
source/util/connectingSelector.cpp source/util/connectingSelector.cpp
source/util/creatingSelector.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_deleteDiagram(DiagramInfo);
void onSignal_selectDiagram(DiagramInfo); void onSignal_selectDiagram(DiagramInfo);
void onCreateTestBaseModelDiagram();
/******************************生成组态***********************************/ /******************************生成组态***********************************/
void onSignal_createEditPanel(QString); void onSignal_createEditPanel(QString);
EditPanel* onSignal_addEditPanel(QString); EditPanel* onSignal_addEditPanel(QString);

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

@ -10,7 +10,10 @@
class DrawingPanel; class DrawingPanel;
class GraphicsBaseItem; class GraphicsBaseItem;
class GraphicsProjectModelItem;
class GraphicsBaseModelItem;
class BaseProperty; class BaseProperty;
class BaseModelProperty;
class DesignerScene; class DesignerScene;
class HttpInterface; class HttpInterface;
struct Connection; struct Connection;
@ -28,14 +31,14 @@ public:
public: public:
QMap<QUuid,QPointF> allNodePos() const; QMap<QUuid,QPointF> allNodePos() const;
QVector<Connection> allConnections(); QVector<Connection> allConnections();
QMap<QUuid,GraphicsBaseItem*>& allItems(); QMap<QUuid,GraphicsProjectModelItem*>& allItems();
bool addNodeItem(QUuid uuid,GraphicsBaseItem*); bool addNodeItem(QUuid uuid,GraphicsProjectModelItem*);
void addNodeItem(QUuid id,/*int type,*/QPointF pos); void addNodeItem(QUuid id,/*int type,*/QPointF pos);
QVariant nodeData(QUuid nodeId, NodeRole role) const; 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 loadNodeDataFromDataBase(); //从数据库加载数据
void addConnectLline(QUuid srcId,QUuid destId,QUuid srcPort,QUuid destPort); void addConnectLline(QUuid srcId,QUuid destId,QUuid srcPort,QUuid destPort);
void deleteNodeItem(GraphicsBaseItem*); void deleteNodeItem(GraphicsProjectModelItem*);
//QJsonObject saveNode(QUuid const) const; //QJsonObject saveNode(QUuid const) const;
void saveNode(int nPageId); void saveNode(int nPageId);
void setScene(DesignerScene* p){_scene = p;} void setScene(DesignerScene* p){_scene = p;}
@ -44,13 +47,21 @@ public:
QPointF getTerminalPos(const QString& sTerminalId); //获取拓扑接线点在当前diagram中的位置 QPointF getTerminalPos(const QString& sTerminalId); //获取拓扑接线点在当前diagram中的位置
ElectricConnectLineItem* getLineItemById(const QString& terminalId); 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 initialPropertyDlg(); //初始化属性设置dlg，每个模型拥各自的dlg
void generatePropertyDlg(const QString&); void generatePropertyDlg(const QString&);
ConfigurationDiagram* getTopologyDiagram(); //返回当前组态图的拓扑实体 ConfigurationDiagram* getTopologyDiagram(); //返回当前组态图的拓扑实体
void createTopoTerminalsByItem(GraphicsBaseItem*); //通过图形对象创建port接线点(新建) void createTopoTerminalsByItem(GraphicsBaseItem*); //通过图形对象创建port接线点(新建)
void createTopoTerminalsByData(PowerEntity* pParent,QJsonObject componentCon); //通过componet数据创建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: Q_SIGNALS:
void activatePage(const QString&); //激活当前model所在page void activatePage(const QString&); //激活当前model所在page
public: public:
@ -59,13 +70,14 @@ public:
void activateModel() {Q_EMIT activatePage(_pageName);} //发送激活信号(点击) void activateModel() {Q_EMIT activatePage(_pageName);} //发送激活信号(点击)
void startHttpRequest(); //开始请求数据(运行时) void startHttpRequest(); //开始请求数据(运行时)
public Q_SLOTS: 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 onTimeOut();
void onSignal_GetPointData(QString type,QMap<qint64,double> map); void onSignal_GetPointData(QString type,QMap<qint64,double> map);
private: private:
QMap<QUuid,GraphicsBaseItem*> _nodeItem; QMap<QUuid,GraphicsProjectModelItem*> _nodeItem; //工程模对象
QMap<QUuid,GraphicsBaseModelItem*> _baseItem; //基模对象
QString _pageName; QString _pageName;
DesignerScene* _scene; DesignerScene* _scene;
@ -73,6 +85,7 @@ private:
HttpInterface* _Interface; HttpInterface* _Interface;
QTimer* _timer; QTimer* _timer;
PowerEntity* _pEntity; //拓扑实体 PowerEntity* _pEntity; //拓扑实体
QMap<QString,QString> _projectModelName; //该图中所有元件对应的工程模类型(todo:扩展为每张图独立的结构体) uuid,工程模名称
QMap<QString,modelStateInfo> _modelStateInfo; //模型结构信息 QMap<QString,modelStateInfo> _modelStateInfo; //模型结构信息
QMap<QString,modelDataInfo> _modelDataInfo; //模型数据信息 QMap<QString,modelDataInfo> _modelDataInfo; //模型数据信息

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

@ -5,70 +5,7 @@
#include <QUuid> #include <QUuid>
#include "graphicsBaseItem.h" #include "graphicsBaseItem.h"
struct Connection class ElectricConnectLineItem : public GraphicsProjectModelItem
{
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
{ {
public: public:
ElectricConnectLineItem(QGraphicsItem *parent = 0); ElectricConnectLineItem(QGraphicsItem *parent = 0);
@ -80,13 +17,11 @@ public:
void moveLine(QPointF); //鼠标点击拖动 void moveLine(QPointF); //鼠标点击拖动
void calculatePath(); void calculatePath();
bool addConnection();
void resetCurLine(){_curLine = QPoint();} void resetCurLine(){_curLine = QPoint();}
//void updateConnection(QUuid callerId,QPointF pos); //外部调用的更新函数,id为调用者id
void setConnection(Connection con){m_connectState = con;} void setConnection(Connection con){m_connectState = con;}
Connection getConnection() const {return m_connectState;} Connection getConnection() const {return m_connectState;}
//QUuid getOppositeId(QUuid); //获取另一端点id
protected: protected:
virtual QPainterPath shape() const override; virtual QPainterPath shape() const override;
virtual QRectF boundingRect() const override; virtual QRectF boundingRect() const override;
@ -98,8 +33,6 @@ private:
QList<QPointF> m_lstPoints; QList<QPointF> m_lstPoints;
QPoint _curLine; //参数1用点序号表示的当前线段起始点,参数2表示线段方向 QPoint _curLine; //参数1用点序号表示的当前线段起始点,参数2表示线段方向
//QPointF m_pStart;
//QPointF m_pEnd;
}; };
#endif #endif

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

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

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

@ -436,18 +436,61 @@ protected:
}; };
class ItemPort; class ItemPort;
class BaseProperty; //class BaseProperty;
class ModelProperty;
class PowerEntity; class PowerEntity;
typedef AbstractShapeType<QGraphicsItem> AbstractShape; typedef AbstractShapeType<QGraphicsItem> AbstractShape;
class GraphicsBaseItem : public QObject, public AbstractShapeType<QGraphicsItem> class GraphicsBaseItem :public QObject, public AbstractShapeType<QGraphicsItem>
{ {
Q_OBJECT Q_OBJECT
public:
public:
GraphicsBaseItem(QGraphicsItem *parent); GraphicsBaseItem(QGraphicsItem *parent);
virtual ~GraphicsBaseItem(); 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 createOperationCopy();
virtual void removeOperationCopy(); virtual void removeOperationCopy();
@ -465,53 +508,31 @@ public:
virtual QString getLabelCurrent() const; virtual QString getLabelCurrent() const;
virtual void setLabelVoltage(const QString& str); //设置电压标签 virtual void setLabelVoltage(const QString& str); //设置电压标签
virtual QString getLabelVoltage() const; 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 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 setState(ItemState s){m_state = s;}
virtual void setBeginConnectPos(QPointF p){m_beginConnectPoint = p;} virtual void setBeginConnectPos(QPointF p){m_beginConnectPoint = p;}
virtual void setEndConnectPos(QPointF p){m_endConnectPoint = 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 void setLastPort(int n){_lastPort = n;}
virtual int getLastPort() const {return _lastPort;} 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 unbindProperty(); //断开图元与数据的绑定
virtual void updateByProperty(); //使用data对象更新自己 virtual void updateByProperty(); //使用data对象更新自己
virtual void updateConnectData(); //更新连接关系数据 virtual void updateConnectData(); //更新连接关系数据
virtual void setItemChanged(bool b){_itemChanged = b;}
virtual bool itemChanged() const {return _itemChanged;}
virtual void setModelName(QString sName){_modelName = sName;} virtual void setModelName(QString sName){_modelName = sName;}
virtual QString getModelName() const {return _modelName;} virtual QString getModelName() const {return _modelName;}
virtual void setEntity(PowerEntity*); //设置当前图元的拓扑数据
virtual PowerEntity* entity();
protected: protected:
virtual QVariant itemChange(QGraphicsItem::GraphicsItemChange, const QVariant&); virtual QVariant itemChange(QGraphicsItem::GraphicsItemChange, const QVariant&);
virtual void contextMenuEvent(QGraphicsSceneContextMenuEvent*); virtual void contextMenuEvent(QGraphicsSceneContextMenuEvent*);
signals: signals:
void ifExist(QUuid id,const QString&,int type,GraphicsBaseItem*); void ifExist(QUuid id,const QString&,int type,GraphicsProjectModelItem*);
public slots: public slots:
void onEditNameFinish(const QString&); void onEditNameFinish(const QString&);
void onUpdateData(); //data发送的更新通知
protected: protected:
QUuid m_itemId;
GraphicsItemType m_Itemtype;
ItemState m_state; ItemState m_state;
QMap<QString,ItemPort*> m_mapPort; //单独存放port
QPointF m_beginConnectPoint; QPointF m_beginConnectPoint;
QPointF m_endConnectPoint; QPointF m_endConnectPoint;
uint _portId; //port编号
int _lastPort; //最后触碰的port int _lastPort; //最后触碰的port
BaseProperty* _property;
bool _itemChanged; //图元变化标志，判断是否需要保存
QString _modelName; //当前图元使用的模型名，用来在model中检索属性信息 QString _modelName; //当前图元使用的模型名，用来在model中检索属性信息
PowerEntity* _pEntity; //图元拓扑
}; };
#endif #endif

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

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

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

@ -3,7 +3,7 @@
#include "graphicsBaseItem.h" #include "graphicsBaseItem.h"
class GraphicsRectItem : public GraphicsBaseItem class GraphicsRectItem : public GraphicsProjectModelItem
{ {
public: public:
GraphicsRectItem(const QRect &rect, bool isRound = false, QGraphicsItem *parent = 0); 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 #define ITEMCONTROLHANDLE_H
#include <QGraphicsRectItem> #include <QGraphicsRectItem>
#include "global.h"
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
};
const int HNDLE_SIZE = 8; const int HNDLE_SIZE = 8;

6
diagramCavas/include/itemPropertyDlg.h
View File

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

68
diagramCavas/include/topologyManager.h
View File

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

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

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

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

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

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

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

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

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

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

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

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

@ -22,7 +22,7 @@ public:
void mouseMoveEvent(QGraphicsSceneMouseEvent*, DesignerScene*); void mouseMoveEvent(QGraphicsSceneMouseEvent*, DesignerScene*);
void mouseReleaseEvent(QGraphicsSceneMouseEvent*, DesignerScene*); void mouseReleaseEvent(QGraphicsSceneMouseEvent*, DesignerScene*);
private: private:
GraphicsBaseItem* m_pParentItem; GraphicsProjectModelItem* m_pParentItem;
}; };
#endif #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 "designerScene.h"
#include "util/selectorManager.h" #include "util/selectorManager.h"
#include "graphicsItem/graphicsItemGroup.h" #include "graphicsItem/graphicsItemGroup.h"
#include "graphicsItem/electricConnectLineItem.h"
#include "graphicsItem/itemPort.h"
#include "drawingPanel.h" #include "drawingPanel.h"
#include "global.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(); FixedPortsModel* pModel = pPanel->getModel();
connect(pModel,&FixedPortsModel::activatePage,this,&DiagramCavas::onSignal_activatePage); connect(pModel,&FixedPortsModel::activatePage,this,&DiagramCavas::onSignal_activatePage);
connect(pPanel,&DrawingPanel::panelDelete,this,&DiagramCavas::onSignal_panelDelete); connect(pPanel,&DrawingPanel::panelDelete,this,&DiagramCavas::onSignal_panelDelete);
if(mode == DM_baseModel)
{
}
} }
void DiagramCavas::onSignal_addGraphicsItem(modelStateInfo& info) void DiagramCavas::onSignal_addGraphicsItem(modelStateInfo& info)
@ -93,7 +98,7 @@ void DiagramCavas::onSignal_savePage()
switch (ret) { switch (ret) {
case QMessageBox::Save: //todo:已存在更新 case QMessageBox::Save: //todo:已存在更新
{ {
QMap<QUuid,GraphicsBaseItem*> map = pPanel->getModel()->allItems(); QMap<QUuid,GraphicsProjectModelItem*> map = pPanel->getModel()->allItems();
for(auto pItem:map) for(auto pItem:map)
{ {
if(pItem->itemChanged()) if(pItem->itemChanged())
@ -119,6 +124,10 @@ void DiagramCavas::onSignal_savePage()
break; 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) void DiagramCavas::onSignal_createEditPanel(QString sName)

89
diagramCavas/source/drawingPanel.cpp
View File

@ -94,62 +94,63 @@ SelectorManager* DrawingPanel::selectorManager() const
void DrawingPanel::closeEvent(QCloseEvent *closeEvent) void DrawingPanel::closeEvent(QCloseEvent *closeEvent)
{ {
bool changed = false; if(getMode() == DM_edit)
QMap<QUuid,GraphicsBaseItem*> map = _pModel->allItems();
if(_pModel)
{ {
for(auto pItem:map) bool changed = false;
{ QMap<QUuid,GraphicsProjectModelItem*> map = _pModel->allItems();
if(pItem->itemChanged()) if(_pModel)
{
changed = true;
break;
}
}
}
if(changed)
{
QMessageBox msgBox;
msgBox.setText(QString::fromWCharArray(L"提示"));
msgBox.setInformativeText(QString::fromWCharArray(L"保存修改内容?"));
msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
msgBox.setDefaultButton(QMessageBox::Cancel);
int ret = msgBox.exec();
switch (ret) {
case QMessageBox::Ok:
{ {
for(auto pItem:map) for(auto pItem:map)
{ {
if(pItem->itemChanged()) if(pItem->itemChanged())
pItem->updateConnectData(); {
changed = true;
break;
}
} }
if(DataBase::GetInstance()->getPageIdByName(_name) == -1) //不存在，创建
DataBase::GetInstance()->insertPage(_name,_name,QJsonObject(),getDiagramInfo(),QString("page"),1);
else
DataBase::GetInstance()->updatePage(_name,_name,getDiagramInfo());
int pageId = DataBase::GetInstance()->getPageIdByName(_name);
saveNodes(pageId);
//todo:同步图形数据到数据对象，保存到服务器
} }
break;
case QMessageBox::Cancel: if(changed)
{ {
//todo:取消保存，删除panel QMessageBox msgBox;
} msgBox.setText(QString::fromWCharArray(L"提示"));
break; msgBox.setInformativeText(QString::fromWCharArray(L"保存修改内容?"));
default: msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
// should never be reached msgBox.setDefaultButton(QMessageBox::Cancel);
int ret = msgBox.exec();
switch (ret) {
case QMessageBox::Ok:
{
for(auto pItem:map)
{
if(pItem->itemChanged())
pItem->updateConnectData();
}
if(DataBase::GetInstance()->getPageIdByName(_name) == -1) //不存在，创建
DataBase::GetInstance()->insertPage(_name,_name,QJsonObject(),getDiagramInfo(),QString("page"),1);
else
DataBase::GetInstance()->updatePage(_name,_name,getDiagramInfo());
int pageId = DataBase::GetInstance()->getPageIdByName(_name);
saveNodes(pageId);
//todo:同步图形数据到数据对象，保存到服务器
}
break; break;
case QMessageBox::Cancel:
{
//todo:取消保存，删除panel
}
break;
default:
// should never be reached
break;
}
} }
emit panelDelete(_name);
} }
/*for(auto pItem:map) //删除图元前先解绑 else if(getMode() == DM_baseModel)
{ {
pItem->unbindProperty();
}*/ }
emit panelDelete(_name);
//closeEvent->ignore();
//hide();
} }
void DrawingPanel::onSignal_addGraphicsItem(modelStateInfo& info) void DrawingPanel::onSignal_addGraphicsItem(modelStateInfo& info)

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

@ -4,6 +4,7 @@
#include "graphicsItem/electricSvgItemRect.h" #include "graphicsItem/electricSvgItemRect.h"
#include "graphicsItem/electricSvgItemTriangle.h" #include "graphicsItem/electricSvgItemTriangle.h"
#include "graphicsItem/electricConnectLineItem.h" #include "graphicsItem/electricConnectLineItem.h"
#include "baseModelItem/electricBaseModelLineItem.h"
#include "graphicsItem/itemPort.h" #include "graphicsItem/itemPort.h"
#include "designerScene.h" #include "designerScene.h"
#include "dataBase.h" #include "dataBase.h"
@ -70,12 +71,12 @@ QVector<Connection> FixedPortsModel::allConnections()
return vec; return vec;
} }
QMap<QUuid,GraphicsBaseItem*>& FixedPortsModel::allItems() QMap<QUuid,GraphicsProjectModelItem*>& FixedPortsModel::allItems()
{ {
return _nodeItem; return _nodeItem;
} }
bool FixedPortsModel::addNodeItem(QUuid uuid,GraphicsBaseItem* pItem) bool FixedPortsModel::addNodeItem(QUuid uuid,GraphicsProjectModelItem* pItem)
{ {
if(_nodeItem.contains(uuid)) if(_nodeItem.contains(uuid))
@ -83,7 +84,7 @@ bool FixedPortsModel::addNodeItem(QUuid uuid,GraphicsBaseItem* pItem)
else else
{ {
_nodeItem.insert(uuid,pItem); _nodeItem.insert(uuid,pItem);
connect(pItem,&GraphicsBaseItem::ifExist,this,&FixedPortsModel::onSignal_ifExits); connect(pItem,&GraphicsProjectModelItem::ifExist,this,&FixedPortsModel::onSignal_ifExits);
return true; return true;
} }
} }
@ -92,7 +93,7 @@ void FixedPortsModel::addNodeItem(QUuid id/*,int type*/,QPointF pos)
{ {
//todo:load图形时必有拓扑实体，关联到对应的entity //todo:load图形时必有拓扑实体，关联到对应的entity
BaseProperty* pro = nullptr; BaseProperty* pro = nullptr;
GraphicsBaseItem* item = nullptr; GraphicsProjectModelItem* item = nullptr;
QMap<QUuid,BaseProperty*> mapData = BasePropertyManager::instance().getEntityData(); //加载的图形必定关联component(todo:完善判断条件，如判断拓扑节点) QMap<QUuid,BaseProperty*> mapData = BasePropertyManager::instance().getEntityData(); //加载的图形必定关联component(todo:完善判断条件，如判断拓扑节点)
if(mapData.contains(id)) if(mapData.contains(id))
{ {
@ -146,9 +147,10 @@ void FixedPortsModel::addNodeItem(QUuid id/*,int type*/,QPointF pos)
item->addPoint(pos); item->addPoint(pos);
item->setProperty(pro); //绑定模型 item->setProperty(pro); //绑定模型
item->updateByProperty(); //使用模型更新自身 item->updateByProperty(); //使用模型更新自身
item->setModelName(pro->modelName()); QString sModel = _projectModelName.value(id.toString());
item->setModelName(sModel);
_nodeItem.insert(id,item); _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) void FixedPortsModel::addConnectLline(QUuid srcId,QUuid destId,QUuid srcPort,QUuid destPort)
{ {
GraphicsBaseItem* src = _nodeItem[srcId]; GraphicsProjectModelItem* src = _nodeItem[srcId];
GraphicsBaseItem* dest = _nodeItem[destId]; GraphicsProjectModelItem* dest = _nodeItem[destId];
if(src && dest) if(src && dest)
{ {
ElectricConnectLineItem* pItem = new ElectricConnectLineItem(); 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) if(pItem->getItemType() == GIT_link)
{ {
auto pLine = dynamic_cast<ElectricConnectLineItem*>(pItem); auto pLine = dynamic_cast<ElectricConnectLineItem*>(pItem);
if(pLine) 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(); QUuid conId = pLine->itemId();
TopologyManager::instance().removeConnection(conId.toString()); TopologyManager::instance().removeConnection(conId.toString());
@ -316,31 +294,6 @@ void FixedPortsModel::deleteNodeItem(GraphicsBaseItem* pItem)
} }
else 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(); QUuid srcId = pItem->itemId();
QList<PowerConnection*> lstCon = TopologyManager::instance().getConnectionsFor(srcId.toString()); QList<PowerConnection*> lstCon = TopologyManager::instance().getConnectionsFor(srcId.toString());
for(auto &con:lstCon) 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; bool exist = false;
BaseProperty* pData = nullptr; BaseProperty* pData = nullptr;
@ -649,7 +602,7 @@ ElectricConnectLineItem* FixedPortsModel::getLineItemById(const QString& termina
{ {
for(auto iter:_nodeItem) //获取id所在的lineitem for(auto iter:_nodeItem) //获取id所在的lineitem
{ {
auto item = dynamic_cast<GraphicsBaseItem*>(iter); auto item = dynamic_cast<GraphicsProjectModelItem*>(iter);
if(item) if(item)
{ {
if(item->getItemType() == GIT_link) if(item->getItemType() == GIT_link)
@ -666,7 +619,7 @@ ElectricConnectLineItem* FixedPortsModel::getLineItemById(const QString& termina
return nullptr; 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]; modelStateInfo stateInfo = _modelStateInfo[sName];
ModelDataMap mapData = DataManager::instance().modelData(); 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(); PowerEntity* pEntity = pItem->entity();
return (pData != nullptr && pEntity != nullptr)?true:false; 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 <QPainter>
#include <QStyleOptionGraphicsItem> #include <QStyleOptionGraphicsItem>
ElectricConnectLineItem::ElectricConnectLineItem(QGraphicsItem *parent) ElectricConnectLineItem::ElectricConnectLineItem(QGraphicsItem *parent)
: GraphicsBaseItem(parent) : GraphicsProjectModelItem(parent)
{ {
m_boundingRect = QRectF(); m_boundingRect = QRectF();
m_pen = QPen(Qt::black); m_pen = QPen(Qt::black);
@ -375,23 +374,3 @@ void ElectricConnectLineItem::calculatePath()
} }
m_boundingRect = m_points.boundingRect(); 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> #include <QDebug>
ElectricSvgItem::ElectricSvgItem(const QRect &rect, bool autoGenPort,QGraphicsItem *parent) ElectricSvgItem::ElectricSvgItem(const QRect &rect, bool autoGenPort,QGraphicsItem *parent)
: GraphicsBaseItem(parent),m_pRender(nullptr) : GraphicsProjectModelItem(parent),m_pRender(nullptr)
{ {
m_lastBoudingRect = rect; m_lastBoudingRect = rect;
m_boundingRect = rect; m_boundingRect = rect;
@ -72,41 +72,7 @@ void ElectricSvgItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* o
if (option->state & QStyle::State_Selected) //是选中状态,绘制选中框 if (option->state & QStyle::State_Selected) //是选中状态,绘制选中框
{ {
int nPenWidth = 1; renderSelectBackground(painter);
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);
} }
} }

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

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

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

@ -2,10 +2,10 @@
#include "graphicsItem/handleRect.h" #include "graphicsItem/handleRect.h"
#include "graphicsItem/handleText.h" #include "graphicsItem/handleText.h"
#include "graphicsItem/itemPort.h" #include "graphicsItem/itemPort.h"
#include "graphicsItem/electricConnectLineItem.h"
#include "baseProperty.h" #include "baseProperty.h"
#include <QGraphicsScene> #include <QGraphicsScene>
#include <QJsonArray> #include <QJsonArray>
#include <QPainter>
GraphicsBaseItem::GraphicsBaseItem(QGraphicsItem *parent) GraphicsBaseItem::GraphicsBaseItem(QGraphicsItem *parent)
@ -14,53 +14,8 @@ GraphicsBaseItem::GraphicsBaseItem(QGraphicsItem *parent)
,_pEntity(nullptr) ,_pEntity(nullptr)
{ {
m_type = T_item; m_type = T_item;
_portId = 1;
_lastPort = -1;
_itemChanged = false; _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::ItemIsSelectable, true);
setFlag(QGraphicsItem::ItemSendsGeometryChanges, true); setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
setAcceptHoverEvents(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 GraphicsBaseItem::addPort(PortState typ,QPointF vec,QString id,HandleType hType,PortPos pos)
{ {
int ntagId = -1; int ntagId = -1;
@ -227,20 +61,58 @@ int GraphicsBaseItem::addPort(PortState typ,QPointF vec,QString id,HandleType hT
return ntagId; return ntagId;
} }
/*void GraphicsBaseItem::addPort(PortState typ,int ntagId,QPointF vec) void GraphicsBaseItem::setEntity(PowerEntity* pEntity)
{ {
if(typ == p_movable) _pEntity = pEntity;
{ }
ItemPort* pPort = new ItemPort(this);
pPort->setType(T_lineInOut);
pPort->setTag(ntagId);
m_vecHanle.insert(ntagId,pPort);
pPort->setPos(vec);
pPort->setParent(this);
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 ItemPort* GraphicsBaseItem::getPortById(QString id) const
{ {
@ -275,7 +147,192 @@ ItemControlHandle* GraphicsBaseItem::getHandlePtr(int n) const
return nullptr; 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) if(_property)
{ {
@ -283,23 +340,13 @@ void GraphicsBaseItem::updateByProperty()
} }
} }
void GraphicsBaseItem::setProperty(BaseProperty* p) void GraphicsProjectModelItem::unbindProperty()
{
if(_property) //已经有对象
{
disconnect(_property,&BaseProperty::updateData,this,&GraphicsBaseItem::onUpdateData); //断开老数据
}
connect(p,&BaseProperty::updateData,this,&GraphicsBaseItem::onUpdateData);
_property = p;
}
void GraphicsBaseItem::unbindProperty()
{ {
_property = nullptr; _property = nullptr;
} }
void GraphicsBaseItem::updateConnectData() void GraphicsProjectModelItem::updateConnectData()
{ {
QJsonObject obj; QJsonObject obj;
QJsonArray arr; 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); 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 else
{ {
GraphicsBaseItem *baseItem = qgraphicsitem_cast<GraphicsBaseItem*>(item); GraphicsProjectModelItem *baseItem = qgraphicsitem_cast<GraphicsProjectModelItem*>(item);
if (baseItem) if (baseItem)
baseItem->syncRotationDataFromParent(data); baseItem->syncRotationDataFromParent(data);
} }
@ -193,7 +193,7 @@ void GraphicsItemGroup::resize(int nHandle,double dSX, double dSY, const QPointF
//调用该组内所有item(过滤handle)相关函数 //调用该组内所有item(过滤handle)相关函数
foreach (QGraphicsItem *item, childItems()) foreach (QGraphicsItem *item, childItems())
{ {
GraphicsBaseItem *baseItem = qgraphicsitem_cast<GraphicsBaseItem*>(item); GraphicsProjectModelItem *baseItem = qgraphicsitem_cast<GraphicsProjectModelItem*>(item);
if (baseItem && !qgraphicsitem_cast<ItemControlHandle*>(baseItem)) if (baseItem && !qgraphicsitem_cast<ItemControlHandle*>(baseItem))
{ {
baseItem->resize(nHandle, dSX, dSY, baseItem->mapFromParent(basePoint)); baseItem->resize(nHandle, dSX, dSY, baseItem->mapFromParent(basePoint));
@ -246,7 +246,7 @@ void GraphicsItemGroup::removeOperationCopy()
// } // }
// else // else
{ {
GraphicsBaseItem *baseItem = qgraphicsitem_cast<GraphicsBaseItem*>(item); GraphicsProjectModelItem *baseItem = qgraphicsitem_cast<GraphicsProjectModelItem*>(item);
if (baseItem) if (baseItem)
baseItem->syncRotationDataFromParent(dAngle); baseItem->syncRotationDataFromParent(dAngle);
} }

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

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

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

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

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

@ -1,5 +1,4 @@
#include "graphicsItem/itemControlHandle.h" #include "graphicsItem/itemControlHandle.h"
#include "graphicsItem/graphicsBaseItem.h"
#include <QPainter> #include <QPainter>
ItemControlHandle::ItemControlHandle(QGraphicsItem *parent) 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); 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; groupValue_ = dataInfo.groupInfo;
curUuid_ = uuid; curUuid_ = uuid;

878
diagramCavas/source/topologyManager.cpp
View File

@ -31,423 +31,619 @@ void TopologyManager::clearAllData()
m_allTerminals.clear(); //端点由父亲entity释放 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)
{ {
PowerEntity* entity = nullptr; if(funType == ModelFunctionType::ProjectModel)
switch(type) {
case EntityType::ConfigurationDiagram:
entity = new ConfigurationDiagram(uuid,name);
break;
case EntityType::Grid:
case EntityType::Zone:
case EntityType::Station:
entity = new PowerDivision(type, uuid,name);
default:
entity = new PowerComponent(type, uuid,name);
}
m_entities.insert(entity->id(), entity);
emit entityCreated(entity->id()); // 发送信号通知
return entity;
}
PowerEntity* TopologyManager::findEntity(const QString& id) const
{
return m_entities.value(id, nullptr); // 避免异常的安全查询
}
bool TopologyManager::deleteEntity(const QString& id)
{
if (!m_entities.contains(id)) return false;
PowerEntity* entity = m_entities[id];
// 步骤1：删除所有相关连接
auto relatedConns = getConnectionsFor(id);
for (auto conn : relatedConns) {
removeConnection(conn->id());
}
// 步骤2：从父节点移除（防止悬空指针）
if (PowerEntity* parent = entity->parent()) {
parent->removeChild(entity);
}
// 步骤3：递归删除子实体
auto children = entity->children();
for (auto child : children) {
deleteEntity(child->id()); // 递归删除
}
// 步骤4：从哈希表移除并释放内存
m_entities.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)
{
// 验证有效性
if (!m_allTerminals.contains(fromTerId) ||
!m_allTerminals.contains(toTerId) ||
fromTerId == toTerId)
{ {
qWarning() << "Invalid connection endpoints"; PowerEntity* entity = nullptr;
return nullptr; switch(type) {
} case EntityType::Grid:
case EntityType::Zone:
// 防止重复连接 case EntityType::Station:
foreach (auto conn, m_connections) { entity = new PowerDivision(type, uuid,name);
if (conn->fromTerminalId() == fromTerId && default:
conn->toTerminalId() == toTerId) entity = new PowerComponent(type, uuid,name);
{
return conn; // 返回已存在的连接
} }
m_entities.insert(entity->id(), entity);
emit entityCreated(entity->id()); // 发送信号通知
return entity;
} }
else if(funType == ModelFunctionType::BaseModel)
// 创建新连接
PowerConnection* conn = new PowerConnection(connId,fromTerId, toTerId,fromId,toId);
m_connections[connId] = conn;
// 更新索引
m_connectionIndex.insert(fromTerId, conn);
m_connectionIndex.insert(toTerId, conn);
emit connectionCreated(connId);
return conn;
}
QList<PowerConnection*> TopologyManager::getConnectionsForTerminal(const QString& terminalId) const
{
return m_connectionIndex.values(terminalId);
}
void TopologyManager::removeConnection(const QString& connId)
{
if (!m_connections.contains(connId)) return;
PowerConnection* conn = m_connections[connId];
// 更新索引
m_connectionIndex.remove(conn->fromTerminalId(), conn);
m_connectionIndex.remove(conn->toTerminalId(), conn);
// 清理内存
m_connections.remove(connId);
delete conn;
emit connectionRemoved(connId);
}
bool TopologyManager::validateConnection(const QString& fromTermId, const QString& toTermId) const
{
PowerTerminal* fromTerm = getTerminal(fromTermId);
PowerTerminal* toTerm = getTerminal(toTermId);
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;
}
int a =1;
// 禁止自连接
return (fromTerm->parentEntityId() != toTerm->parentEntityId());
}
// 连接查询接口
QList<PowerConnection*> TopologyManager::connectionsFrom(const QString& elementId) const
{
QList<PowerConnection*> res;
/*QList<PowerConnection*> lst = m_connectionIndex.values(elementId);
for(auto &val:lst)
{ {
if(val->fromTerminalId() == elementId) PowerEntity* entity = nullptr;
res.append(val); entity = new PowerComponent(type, uuid,name);
}*/
return res;
}
QList<PowerConnection*> TopologyManager::connectionsTo(const QString& elementId) const m_baseEntities.insert(entity->id(), entity);
{ emit entityCreated(entity->id()); // 发送信号通知
QList<PowerConnection*> res; return entity;
/*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*> lst;
QList<PowerTerminal*> lstTerminal = getTerminalsForEntity(entityId);
for(auto &terminal:lstTerminal)
{
PowerConnection* con = getConnectionContainsTerminal(terminal->id());
if(con)
lst.append(con);
}
return lst;
}
PowerConnection* TopologyManager::connection(const QString& conId) const
{
return m_connections.value(conId,nullptr);
}
PowerConnection* TopologyManager::connection(const QString& fromPin,const QString& toPin)
{
for(auto &con:m_connections)
{
if(con->fromTerminalId() == fromPin && con->toTerminalId() == toPin)
return con;
} }
return nullptr; return nullptr;
} }
QHash<QString,PowerConnection*> TopologyManager::getAllConnections() PowerEntity* TopologyManager::findEntity(const QString& id,ModelFunctionType funType) const
{ {
return m_connections; if(funType == ModelFunctionType::ProjectModel)
return m_entities.value(id, nullptr); // 避免异常的安全查询
else if(funType == ModelFunctionType::BaseModel)
return m_baseEntities.value(id, nullptr);
} }
/*void TopologyManager::saveToDB(const QString& path) bool TopologyManager::deleteEntity(const QString& id,ModelFunctionType funType)
{ {
QJsonObject root; if(funType == ModelFunctionType::ProjectModel)
{
if (!m_entities.contains(id)) return false;
// 序列化实体（含接线点） PowerEntity* entity = m_entities[id];
QJsonArray entities;
foreach (auto entity, m_entities) {
QJsonObject entObj = entity->toJson();
QJsonArray terminalsArray; // 步骤1：删除所有相关连接
foreach (auto term, entity->terminals()) { auto relatedConns = getConnectionsFor(id);
terminalsArray.append(term->toJson());
for (auto conn : relatedConns) {
removeConnection(conn->id());
} }
entObj["terminals"] = terminalsArray;
entities.append(entObj); // 步骤2：从父节点移除（防止悬空指针）
if (PowerEntity* parent = entity->parent()) {
parent->removeChild(entity);
}
// 步骤3：递归删除子实体
auto children = entity->children();
for (auto child : children) {
deleteEntity(child->id()); // 递归删除
}
// 步骤4：从哈希表移除并释放内存
m_entities.remove(id);
delete entity; // 触发PowerEntity析构函数
emit entityDeleted(id);
return true;
} }
root["entities"] = entities; else if(funType == ModelFunctionType::BaseModel)
{
if (!m_baseEntities.contains(id)) return false;
PowerEntity* entity = m_baseEntities[id];
QJsonArray connectionsArray; // 步骤1：删除所有相关连接
for (auto conn : m_connections) auto relatedConns = getConnectionsFor(id,funType);
connectionsArray.append(conn->toJson()); for (auto conn : relatedConns) {
root["connections"] = connectionsArray; removeConnection(conn->id(),funType);
}
//todo:写入到数据库 // 步骤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,ModelFunctionType funType)
{
PowerConnection* conn = nullptr;
if(funType == ModelFunctionType::ProjectModel)
{
// 验证有效性
if (!m_allTerminals.contains(fromTerId) ||
!m_allTerminals.contains(toTerId) ||
fromTerId == toTerId)
{
qWarning() << "Invalid connection endpoints";
return nullptr;
}
// 防止重复连接
foreach (auto conn, m_connections) {
if (conn->fromTerminalId() == fromTerId &&
conn->toTerminalId() == toTerId)
{
return conn; // 返回已存在的连接
}
}
// 创建新连接
conn = new PowerConnection(connId,fromTerId, toTerId,fromId,toId);
m_connections[connId] = conn;
// 更新索引
m_connectionIndex.insert(fromTerId, conn);
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,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,ModelFunctionType funType)
{
if(funType == ModelFunctionType::ProjectModel){
if (!m_connections.contains(connId)) return;
PowerConnection* conn = m_connections[connId];
// 更新索引
m_connectionIndex.remove(conn->fromTerminalId(), conn);
m_connectionIndex.remove(conn->toTerminalId(), conn);
// 清理内存
m_connections.remove(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,ModelFunctionType funType) const
{
if(funType == ModelFunctionType::ProjectModel){
PowerTerminal* fromTerm = getTerminal(fromTermId);
PowerTerminal* toTerm = getTerminal(toTermId);
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());
}
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*> res;
QList<PowerConnection*> lst = m_connectionIndex.values(elementId);
for(auto &val:lst)
{
if(val->fromTerminalId() == elementId)
res.append(val);
}
return res;
}*/ }*/
/*void TopologyManager::loadFromDB(const QString& path) /*QList<PowerConnection*> TopologyManager::connectionsTo(const QString& elementId) const
{ {
//todo::将读到的字为json QList<PowerConnection*> res;
QString strJson; QList<PowerConnection*> lst = m_connectionIndex.values(elementId);
QJsonDocument doc = QJsonDocument::fromJson(strJson.toLocal8Bit()); for(auto &val:lst)
QJsonObject root = doc.object(); {
if(val->toTerminalId() == elementId)
res.append(val);
}
return res;
}*/
clearAllData(); // 清除现有数据 QList<PowerConnection*> TopologyManager::getConnectionsFor(const QString& entityId,ModelFunctionType funType) const
{
// 阶段1：创建所有实体 QList<PowerConnection*> lst;
QHash<QString, QStringList> pendingChildren; if(funType == ModelFunctionType::ProjectModel)
{
QJsonArray entities = root["entities"].toArray(); QList<PowerTerminal*> lstTerminal = getTerminalsForEntity(entityId);
foreach (QJsonValue entVal, entities) { for(auto &terminal:lstTerminal)
QJsonObject entObj = entVal.toObject(); {
PowerConnection* con = getConnectionContainsTerminal(terminal->id());
// 创建实体 if(con)
EntityType type = static_cast<EntityType>(entObj["type"].toInt()); lst.append(con);
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);
} }
}
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,ModelFunctionType funType) const
pendingChildren[id] = entObj["children"].toVariant().toStringList(); {
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,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;
}
} }
// 阶段2：建立父子关系 return nullptr;
QHashIterator<QString, QStringList> it(pendingChildren); }
while (it.hasNext()) {
it.next();
PowerEntity* parent = getEntity(it.key());
if (!parent) continue;
foreach (QString childId, it.value()) { QHash<QString,PowerConnection*> TopologyManager::getAllConnections(ModelFunctionType funType)
if (PowerEntity* child = getEntity(childId)) { {
parent->addChild(child); if(funType == ModelFunctionType::ProjectModel)
return m_connections;
else if(funType == ModelFunctionType::BaseModel)
return m_baseConnections;
}
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,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){
// 阶段3：创建连接 foreach (auto entity, m_baseEntities) {
QJsonArray connections = root["connections"].toArray(); if (entity->name() == name) {
foreach (QJsonValue connVal, connections) { results.append(entity);
QJsonObject connObj = connVal.toObject(); }
createConnection(
connObj["id"].toString(),
connObj["from"].toString(),
connObj["to"].toString()
);
}
}*/
PowerEntity* TopologyManager::getEntity(const QString& id) const
{
auto it = m_entities.find(id);
return (it != m_entities.end()) ? it.value() : nullptr;
}
QList<PowerEntity*> TopologyManager::findEntitiesByName(const QString& name) const
{
QList<PowerEntity*> results;
foreach (auto entity, m_entities) {
if (entity->name() == name) {
results.append(entity);
} }
} }
return results; 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; PowerEntity* entity = nullptr;
if(!m_diagrams.contains(id)) if(funType == ModelFunctionType::ProjectModel){
{ if(!m_diagrams.contains(id))
entity = new ConfigurationDiagram(id,name); {
m_diagrams.insert(entity->id(), entity); 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; return entity;
} }
PowerEntity* TopologyManager::findDiagram(const QString& id) const PowerEntity* TopologyManager::findDiagram(const QString& id,ModelFunctionType funType) const
{ {
return m_diagrams.value(id, nullptr); // 避免异常的安全查询 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 (!m_diagrams.contains(id)) return false; if(funType == ModelFunctionType::ProjectModel){
if (!m_diagrams.contains(id)) return false;
PowerEntity* entity = m_diagrams[id]; PowerEntity* entity = m_diagrams[id];
// 步骤2：从父节点移除（防止悬空指针） // 步骤2：从父节点移除（防止悬空指针）
if (PowerEntity* parent = entity->parent()) { if (PowerEntity* parent = entity->parent()) {
parent->removeChild(entity); parent->removeChild(entity);
}
// 步骤3：递归删除子实体
auto children = entity->children();
for (auto child : children) {
deleteDiagram(child->id()); // 递归删除
}
// 步骤4：从哈希表移除并释放内存
m_diagrams.remove(id);
delete entity; // 触发析构函数
return true;
} }
else if(funType == ModelFunctionType::BaseModel){
if (!m_baseDiagrams.contains(id)) return false;
// 步骤3：递归删除子实体 PowerEntity* entity = m_baseDiagrams[id];
auto children = entity->children();
for (auto child : children) { // 步骤2：从父节点移除（防止悬空指针）
deleteDiagram(child->id()); // 递归删除 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;
} }
// 步骤4：从哈希表移除并释放内存
m_diagrams.remove(id);
delete entity; // 触发析构函数
return true;
} }
PowerTerminal* TopologyManager::createTerminal(const QString& parentEntityId, PowerTerminal* TopologyManager::createTerminal(const QString& parentEntityId,
TerminalType type, TerminalType type,
const QString& name, const QString& name,
const QPointF& relPos, const QPointF& relPos,
const QString& uuid) { const QString& uuid,
if (!m_entities.contains(parentEntityId)) return nullptr; ModelFunctionType funType) {
if(funType == ModelFunctionType::ProjectModel){
if (!m_entities.contains(parentEntityId)) return nullptr;
PowerTerminal* term = new PowerTerminal(parentEntityId, type, name, relPos, uuid); PowerTerminal* term = new PowerTerminal(parentEntityId, type, name, relPos, uuid);
m_allTerminals[term->id()] = term; m_allTerminals[term->id()] = term;
m_terminalsByEntity[parentEntityId].append(term); m_terminalsByEntity[parentEntityId].append(term);
// 关联到父实体 // 关联到父实体
if (PowerEntity* parent = getEntity(parentEntityId)) { if (PowerEntity* parent = getEntity(parentEntityId)) {
parent->addTerminal(term); parent->addTerminal(term);
}
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,ModelFunctionType funType) {
if(funType == ModelFunctionType::ProjectModel){
if (!m_allTerminals.contains(terminalId)) return false;
PowerTerminal* term = m_allTerminals[terminalId];
QString parentId = term->parentEntityId();
// 从父实体移除
if (PowerEntity* parent = getEntity(parentId)) {
parent->removeTerminal(terminalId);
}
// 清理全局存储
m_terminalsByEntity[parentId].removeAll(term);
m_allTerminals.remove(terminalId);
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;
} }
return term;
} }
bool TopologyManager::deleteTerminal(const QString& terminalId) { PowerTerminal* TopologyManager::getTerminal(const QString& terminalId,ModelFunctionType funType) const
if (!m_allTerminals.contains(terminalId)) return false; {
if(funType == ModelFunctionType::ProjectModel){
PowerTerminal* term = m_allTerminals[terminalId]; auto it = m_allTerminals.find(terminalId);
QString parentId = term->parentEntityId(); return (it != m_allTerminals.end()) ? it.value() : nullptr;
// 从父实体移除
if (PowerEntity* parent = getEntity(parentId)) {
parent->removeTerminal(terminalId);
} }
else if(funType == ModelFunctionType::BaseModel){
// 清理全局存储 auto it = m_baseAllTerminals.find(terminalId);
m_terminalsByEntity[parentId].removeAll(term); return (it != m_baseAllTerminals.end()) ? it.value() : nullptr;
m_allTerminals.remove(terminalId); }
//delete term; //在parent中已经delete return nullptr;
return true;
} }
PowerTerminal* TopologyManager::getTerminal(const QString& terminalId) 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,ModelFunctionType funType) const
{ {
auto it = m_allTerminals.find(terminalId); if(funType == ModelFunctionType::ProjectModel){
return (it != m_allTerminals.end()) ? it.value() : nullptr; QHash<QString, QList<PowerTerminal*>>::ConstIterator iter;
} for(iter = m_terminalsByEntity.begin();iter != m_terminalsByEntity.end();++iter)
QList<PowerTerminal*> TopologyManager::getTerminalsForEntity(const QString& entityId) const {
return m_terminalsByEntity.value(entityId);
}
PowerEntity* TopologyManager::getEntityByTerminal(const QString& terminalId) const
{
QHash<QString, QList<PowerTerminal*>>::ConstIterator iter;
for(iter = m_terminalsByEntity.begin();iter != m_terminalsByEntity.end();++iter)
{
for(auto &terminal:iter.value())
{ {
if(terminal->id() == terminalId) for(auto &terminal:iter.value())
{ {
return m_entities[iter.key()]; if(terminal->id() == terminalId)
{
return m_entities[iter.key()];
}
}
}
}
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,ModelFunctionType funType) const
{
if(funType == ModelFunctionType::ProjectModel){
for(auto &con:m_connections)
{
if(con->fromTerminalId() == terminalId || con->toTerminalId() == terminalId)
{
return con;
}
}
}
else if(funType == ModelFunctionType::BaseModel){
for(auto &con:m_baseConnections)
{
if(con->fromTerminalId() == terminalId || con->toTerminalId() == terminalId)
{
return con;
} }
} }
} }
return nullptr; return nullptr;
} }
PowerConnection* TopologyManager::getConnectionContainsTerminal(const QString& terminalId) const
{
for(auto &con:m_connections)
{
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(); QList<QGraphicsItem *> items = scene->selectedItems();
if (items.count() == 1) //只有一个选中 if (items.count() == 1) //只有一个选中
{ {
GraphicsBaseItem* item = qgraphicsitem_cast<GraphicsBaseItem*>(items.first()); GraphicsProjectModelItem* item = qgraphicsitem_cast<GraphicsProjectModelItem*>(items.first());
if(item) if(item)
{ {
GraphicsItemType tpe = item->getItemType(); GraphicsItemType tpe = item->getItemType();
@ -116,7 +116,7 @@ void BaseSelector::mousePressEvent(QGraphicsSceneMouseEvent* event, DesignerScen
ItemControlHandle* pHandle = qgraphicsitem_cast<ItemControlHandle*>(items.first()); ItemControlHandle* pHandle = qgraphicsitem_cast<ItemControlHandle*>(items.first());
if(pHandle) if(pHandle)
{ {
//GraphicsBaseItem* item = pHandle->getParentPtr(); //GraphicsProjectModelItem* item = pHandle->getParentPtr();
ms_nDragHandle = pHandle->getTag(); ms_nDragHandle = pHandle->getTag();
//ms_nDragHandle = item->collidesWithHandle(event->scenePos()); //ms_nDragHandle = item->collidesWithHandle(event->scenePos());
if(ms_nDragHandle >= H_textCaption && ms_nDragHandle < H_connect) //移动文本 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++) 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(); GraphicsItemType tpe = item->getItemType();
if(tpe == GIT_link) if(tpe == GIT_link)
continue; continue;
@ -370,7 +370,7 @@ void BaseSelector::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event, Design
} }
else if(items.count() == 1) //不是文字节点 else if(items.count() == 1) //不是文字节点
{ {
GraphicsBaseItem* item = qgraphicsitem_cast<GraphicsBaseItem*>(items.first()); GraphicsProjectModelItem* item = qgraphicsitem_cast<GraphicsProjectModelItem*>(items.first());
if(item) if(item)
{ {
GraphicsItemType tpe = item->getItemType(); GraphicsItemType tpe = item->getItemType();
@ -410,7 +410,7 @@ void BaseSelector::dropEvent(QGraphicsSceneDragDropEvent *event, DesignerScene*)
event->acceptProposedAction(); event->acceptProposedAction();
//根据data数据新增拖拽的item //根据data数据新增拖拽的item
QMap<QUuid,GraphicsBaseItem*> items = _model->allItems(); QMap<QUuid,GraphicsProjectModelItem*> items = _model->allItems();
if(items.contains(QUuid(uuid))){ if(items.contains(QUuid(uuid))){
QMessageBox::information(NULL, QString::fromWCharArray(L"提示"), QString::fromWCharArray(L"此对象在当前页已存在")); QMessageBox::information(NULL, QString::fromWCharArray(L"提示"), QString::fromWCharArray(L"此对象在当前页已存在"));
return; return;
@ -437,7 +437,7 @@ void BaseSelector::contextMenuEvent(QGraphicsSceneContextMenuEvent *event,Design
return; return;
else if(listItem.count() == 1) else if(listItem.count() == 1)
{ {
GraphicsBaseItem* item = qgraphicsitem_cast<GraphicsBaseItem*>(listItem.first()); GraphicsProjectModelItem* item = qgraphicsitem_cast<GraphicsProjectModelItem*>(listItem.first());
if(item) if(item)
{ {
GraphicsItemType tpe = item->getItemType(); GraphicsItemType tpe = item->getItemType();
@ -464,7 +464,7 @@ void BaseSelector::updateConnectLineByTopology(QList<QGraphicsItem *> lst)
{ {
for(auto iter:lst) //更新连接线 for(auto iter:lst) //更新连接线
{ {
auto item = dynamic_cast<GraphicsBaseItem*>(iter); auto item = dynamic_cast<GraphicsProjectModelItem*>(iter);
if(item) if(item)
{ {
if(item->getItemType() != GIT_link) //获取非电缆对象 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(); GraphicsItemType iType = p->getItemType();
if(iType == GIT_bus) 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)) { if (!_model->isItemValid(connectingItem) || !_model->isItemValid(touchedItem)) {
QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"请先完成设备命名")); QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"请先完成设备命名"));
@ -153,7 +153,7 @@ void ConnectingSelector::mouseMoveEvent(QGraphicsSceneMouseEvent* event, Designe
QList<QGraphicsItem *> items = scene->selectedItems(); QList<QGraphicsItem *> items = scene->selectedItems();
if (items.count() == 1) if (items.count() == 1)
{ {
GraphicsBaseItem* item = qgraphicsitem_cast<GraphicsBaseItem*>(items.first()); GraphicsProjectModelItem* item = qgraphicsitem_cast<GraphicsProjectModelItem*>(items.first());
if(item) if(item)
{ {
if(ms_nDragHandle >= H_connect) //操作的是port端点 if(ms_nDragHandle >= H_connect) //操作的是port端点
@ -184,7 +184,7 @@ void ConnectingSelector::mouseMoveEvent(QGraphicsSceneMouseEvent* event, Designe
QList<QGraphicsItem *> items = scene->items(ms_ptMouseLast); QList<QGraphicsItem *> items = scene->items(ms_ptMouseLast);
if (items.count() == 1) if (items.count() == 1)
{ {
GraphicsBaseItem* item = dynamic_cast<GraphicsBaseItem*>(items.first()); GraphicsProjectModelItem* item = dynamic_cast<GraphicsProjectModelItem*>(items.first());
if(item) if(item)
{ {
QUuid n1 = item->itemId(); QUuid n1 = item->itemId();

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

@ -4,8 +4,6 @@
#include "graphicsItem/electricSvgItemBus.h" #include "graphicsItem/electricSvgItemBus.h"
#include "graphicsItem/electricSvgItemRect.h" #include "graphicsItem/electricSvgItemRect.h"
#include "graphicsItem/electricSvgItemTriangle.h" #include "graphicsItem/electricSvgItemTriangle.h"
#include "graphicsItem/itemPort.h"
#include "topologyManager.h"
#include "global.h" #include "global.h"
#include <QGraphicsSceneMouseEvent> #include <QGraphicsSceneMouseEvent>
#include <QGraphicsView> #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(); QList<QGraphicsItem *> items = scene->selectedItems();
if (items.count() == 1) if (items.count() == 1)
{ {
GraphicsBaseItem* item = qgraphicsitem_cast<GraphicsBaseItem*>(items.first()); GraphicsProjectModelItem* item = qgraphicsitem_cast<GraphicsProjectModelItem*>(items.first());
if(item) if(item)
{ {
if(ms_nDragHandle > H_left) if(ms_nDragHandle > H_left)
@ -40,7 +40,7 @@ void EditingSelector::mouseReleaseEvent(QGraphicsSceneMouseEvent* event, Designe
QList<QGraphicsItem *> items = scene->selectedItems(); QList<QGraphicsItem *> items = scene->selectedItems();
if (items.count() == 1) if (items.count() == 1)
{ {
GraphicsBaseItem* item = qgraphicsitem_cast<GraphicsBaseItem*>(items.first()); GraphicsProjectModelItem* item = qgraphicsitem_cast<GraphicsProjectModelItem*>(items.first());
if(item && ms_ptMouseLast != ms_ptMouseDown) if(item && ms_ptMouseLast != ms_ptMouseDown)
{ {
item->updateCoordinate(); item->updateCoordinate();

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

@ -45,7 +45,7 @@ void MovingSelector::mouseReleaseEvent(QGraphicsSceneMouseEvent* event, Designer
if(item) if(item)
item->removeOperationCopy(); item->removeOperationCopy();
} }
//updateConnectLine(items);
updateConnectLineByTopology(items); updateConnectLineByTopology(items);
setCursor(scene, Qt::ArrowCursor); setCursor(scene, Qt::ArrowCursor);
@ -53,26 +53,4 @@ void MovingSelector::mouseReleaseEvent(QGraphicsSceneMouseEvent* event, Designer
emit setWorkingSelector(ST_base); 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()); ItemControlHandle* pHandle = qgraphicsitem_cast<ItemControlHandle*>(items.first());
if(pHandle) if(pHandle)
{ {
GraphicsBaseItem* item = pHandle->getParentPtr(); GraphicsProjectModelItem* item = dynamic_cast<GraphicsProjectModelItem*>(pHandle->getParentPtr());
if(item) if(item)
{ {
if(ms_nDragHandle >= H_textCaption && ms_nDragHandle < H_connect) //移动文本 if(ms_nDragHandle >= H_textCaption && ms_nDragHandle < H_connect) //移动文本

9
diagramUtils/include/basePropertyManager.h
View File

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