#pragma once

#include <QString>
#include <QVector>
#include <QDebug>
#include <QEvent>
#include <QMutex>
#include <QWaitCondition>
#include <QColor>
#include <QDateTime>
#include <QMetaEnum>

#include <HalconCpp.h>
using namespace HalconCpp;

#include "opencv2/opencv.hpp"
using namespace cv;

class TOOL;
class DllTool;

// 硬件组态的工具分类名字
#define CATEGORY_TOOL_HARDWARE					("硬件工具")


////========================================================
////
////					ENUM
////
////========================================================


/// <summary>
/// 管理系统中所有的枚举类型（逐步添加中，方便使用Q_ENUM管理）
/// </summary>
class VPEnum : public QObject
{
public:

	/// <summary>
	/// 线程的优先级
	/// </summary>
	enum class PRIORITY : short
	{
		IdlePriority,

		LowestPriority,
		LowPriority,
		NormalPriority,
		HighPriority,
		HighestPriority,

		TimeCriticalPriority,

		InheritPriority
	};

	Q_ENUM(PRIORITY);

	/// <summary>
	/// Tool工作状态
	/// </summary>
	enum class EXEC_STATUS : short
	{
		Wait,									// 等待事件中
		Busy,									// 执行中
		Done,									// 执行完毕
		StandBy									// 就绪状态，表示工具尚未执行

	};

	Q_ENUM(EXEC_STATUS)

	/// <summary>
	/// Tool执行的返回值
	/// </summary>
	enum class RETURN_VALUE : short
	{
		Success = 0,							// 工具执行成功
		Error,									// 工具执行错误
		Invalid,								// 工具无效 或被禁用
		Timeout,								// 工具执行超时
		Goto,									// 返回跳转信号
		Abort,									// 2022-9-5 因为各种原因，放弃执行此工具
		None									// 无状态，表示工具尚未执行

	};

	Q_ENUM(RETURN_VALUE)

	/// <summary>
	/// 全局变量的读写模式（仅DB模式使用）
	/// </summary>
	enum class GVL_ACCESS_MODE : short
	{
		All,
		ReadOnly,
		WriteOnly
	};

	Q_ENUM(GVL_ACCESS_MODE)


};

// 基础模式中包括的类型数量
#define GVL_BASIC_TYPE_COUNT			5
// 标准模式中包括的类型数量
#define GVL_STANDARD_TYPE_COUNT			28

/// <summary>
///  数据类型定义
/// </summary>
enum class VALUE_TYPE : short
{
	Type_Bool = 0,						//bool
	Type_Int,							//int
	Type_Float,							//float
	Type_Double,						//double
	Type_String,						//QString
	Type_StdString,						//std::string
	Type_QImage,						//QImage

	Type_Mat,							//Mat
	Type_HTuple,						//HTuple
	Type_HObject,						//HObject
	Type_HImage,						//HImage

	Type_ST_Pos,						//HTuple_Pos
	Type_ST_HomMat2D,					//HTuple_HomMat2D
	Type_ST_Point,						//HTuple_Point
	Type_ST_Line,						//HTuple_Line
	Type_ST_Circle,						//HTuple_Circle
	Type_ST_Disp,						//HTuple_Disp
	Type_ST_Window,						//HTuple_Window
	Type_ST_Ncc_Modle,					//HTuple_Ncc_Modle
	Type_ST_Shape_Modle,				//HTuple_Shape_Modle
	Type_ST_Calibration,				//HTuple_Calibration
	Type_ST_CamParam_PoseCalib,			//HTuple_CamParam_PoseCalib

	Type_pIBaseCamera,					//IBaseCamera*
	Type_pIpImage,						//lpImage*
	Type_pISocket,						//ISocket*
	Type_pArrayIn,						//ArrayIn*
	Type_pArrayOut,						//ArrayOut*
	Type_pArrayRobotPos,				//ArrayRobotPos*

	Control_Base = 100,
	Control_Label,
	Control_Button,
	Control_CheckBox,
	Control_RadioBox,
	Control_Groupbox,
	Control_Image,
	Control_LineEdit,
	Control_Listbox,
	Control_ComboBox,
	Control_Value,
	Control_PieChart,
	Control_CustomPlot,
	Control_Table,
	Control_Result,
	Control_Widget,

	// Type_Event,						// 2022-9-3 废弃，统一到接口的 INF_EVENT 类型中
	Type_Tool,
	Type_Unknown

};


/// <summary>
/// 数据类型定义
/// 此处对应DataStructure.h中的 VALUE_TYPE 顺序，要确保双方顺序同步
/// </summary>
const static QStringList valueString =
{
	"bool",											// 0
	"int",											// 1
	"float",										// 2
	"double",										// 3
	"QString",										// 4
	"std::string",									// 5
	"QImage",										// 6

	"Mat",											// 7
	"HTuple",										// 8
	"HObject",										// 9
	"HImage",										// 10
	"HPos",											// 11

	"HTuple_HomMat2D",								// 12
	"HTuple_Point",									// 13
	"HTuple_Line",									// 14
	"HTuple_Circle",								// 15
	"HTuple_Disp",									// 16
	"HTuple_Window",								// 17
	"HTuple_Ncc_Modle",								// 18
	"HTuple_Shape_Modle",							// 19
	"HTuple_Calibration",							// 20
	"HTuple_CamParam_PoseCalib",					// 21

	"IBaseCamera*",									// 22
	"lpImage*",										// 23
	"ISocket*",										// 24
	"ArrayIn*",										// 25
	"ArrayOut*",									// 26
	"ArrayRobotPos*",								// 27

	// 28
	"ControlBase",									// 100
	"QLabel",										// 101
	"QPushButton",									// 102
	"QCheckBox",									// 103
	"QRadioButton",									// 104
	"QGroupBox",									// 105
	"QImage",										// 106
	"QLineEdit",									// 107
	"QListWidget",									// 108
	"QComboBox",									// 109
	"ValueControl",									// 110
	"PieChart",										// 111
	"WaveChart",									// 112
	"TableControl",									// 113
	"Result",										// 114
	"QWidget",										// 115

	"QEvent",
	"Tool",
	"Unknown"
};


/// <summary>
/// 输入输出类型
/// </summary>
enum class INF_DIRECTION : short
{
	INF_DIR_IN = 1,												// 输入接口
	INF_DIR_OUT = 2,											// 输出接口
	INF_DIR_BOTH = 3,											// 双向接口（全局变量）
	INF_DIR_UNKNOWN,

};


/// <summary>
/// 端口废弃类型
/// </summary>
enum class INF_DISCARD : short
{
	INF_DEFAULT = 0,												// 默认值（未废弃，正常使用的端口）
	INF_MARK_DELETE = 1,											// 接口被删除
	INF_MARK_DISCARD = 2,											// 接口被标记为废弃
	INF_MARK_CHANGE = 3												// 接口被修改（常因为端口的类型被修改）

};


/// <summary>
/// 工具总体类型（工具、控件或者变量）
/// </summary>
enum class TOOL_TYPE : short
{
	TOOL_TYPE_STANDARD,											// 标准工具
	TOOL_TYPE_PORT_INPUT,										// 输入端口工具
	TOOL_TYPE_PORT_OUTPUT,										// 输出端口工具
	TOOL_TYPE_GLOBAL_VARIABLE,									// 全局变量
	TOOL_TYPE_LOCAL_VARIABLE,									// 局部变量
	TOOL_TYPE_GOTO,												// 跳转工具
	TOOL_TYPE_COMMENT,											// 2022-3-13，注释工具
	TOOL_TYPE_PARALLEL,											// 2022-4-18，并行计算工具
	TOOL_TYPE_FORLOOP,											// 2022-8-21，For循环工具
	TOOL_TYPE_WAIT,												// 2022-9-2，Wait工具
	TOOL_TYPE_UNKNOWN

};


/// <summary>
/// 接口总体类型
/// </summary>
enum class INF_TYPE : short
{
	INF_TYPE_STANDARD,											// 标准接口
	INF_TYPE_VALUE,												// 数值接口（全局变量，局部变量）
	INF_TYPE_CONTROL,											// 控件接口
	INF_TYPE_TOOL,												// 2022-8-21 Tool接口，包括输入和输出两种
	INF_TYPE_EVENT,												// 2021-7-27 增加，Event类型接口
	INF_TYPE_UNKNOWN

};


/// <summary>
/// 值的传递方式
/// </summary>
enum class VALUE_PASS_MODE : short
{
	PASS_BY_VALUE,
	PASS_BY_ADDRESS,
	PASS_BY_UNKNOWN

};


/// <summary>
/// Tool的运行模式
/// </summary>
enum class TOOL_RUN_MODE : short
{
	SINGLE_STEP,							// 单步执行
	STANDALONE,								// 独立运行（仅运行本工具）
	SEQUENTIAL,								// 顺序执行（任务中，或者ExecuteAll执行）
	IN_PARALLEL,							// 在并行工具中执行
	IN_FORLOOP								// 在For工具中执行
};


/// <summary>
/// Task的运行模式
/// </summary>
enum class TASK_RUN_MODE : short
{
	RUN_LOOP,								// 循环执行
	RUN_ONCE,								// 单次执行
	RUN_STOP								// 退出执行
};


// 更新值的工作模式
enum class UPDATE_VALUE_MODE : short
{
	MODE_FROM_TOOL,							// 从Tool接口中更新
	MODE_FROM_VARIABLE,						// 从变量中读取
	MODE_TO_VARIABLE						// 写入到变量中
};


/// <summary>
/// 2022-2-15增加，变量模式（局部变量统一为BASIC模式，全局变量分三种模式）
/// </summary>
enum class GVL_MODE : short
{
	GVL_BASIC,								// 基础模式（基础类型）
	GVL_STANDARD,							// 标准模式（全类型）
	GVL_SYSTEM,								// 系统类型（内置类型，不可编辑）
	GVL_DB,									// 共享内存模式
	GVL_UNKNOWN								// 无效的模式
};




////========================================================
////
////					STRUCT
////
////========================================================



/// <summary>
/// Pou、Tool的运行参数
/// </summary>
typedef struct _tagExecutionParameters
{
	int						nExecTime;					// 执行总时长(ms)
	int						nExecCount;					// 执行次数
	int						nErrorCount;				// 错误次数

	int						nPreDelay;					// 前延时(ms，仅Tool使用)
	int						nPostDelay;					// 后延时(ms)

	VPEnum::EXEC_STATUS		nStatus;					// 工具执行状态
	VPEnum::RETURN_VALUE	nRetValue;					// 工具的执行返回值(默认为未执行状态)

	_tagExecutionParameters()
	{
		this->reset();
	}

	void reset()
	{
		nExecTime = 0;
		nExecCount = 0;
		nErrorCount = 0;

		nPreDelay = 0;
		nPostDelay = 0;

		nRetValue = VPEnum::RETURN_VALUE::None;
		nStatus = VPEnum::EXEC_STATUS::StandBy;
	}

} EXEC_PARAMS;


/// <summary>
/// Task 的运行参数
/// </summary>
typedef struct _tagTaskParameters : public EXEC_PARAMS
{

	bool					bWatchDog;					// 是否启用看门狗（仅Task使用）
	int						nWatchDog;					// 看门狗的设置数值(ms, 仅Task使用)
	VPEnum::PRIORITY		nPriority;					// 优先级
	int						nTriggerFailedCount;		// 触发失败次数

	TASK_RUN_MODE			runMode;					// 运行模式

	_tagTaskParameters()
	{
		bWatchDog = true;
		nWatchDog = 200;

		nPriority = VPEnum::PRIORITY::NormalPriority;

		runMode = TASK_RUN_MODE::RUN_LOOP;
		nPostDelay = 200;

		nTriggerFailedCount = 0;
	}

} TASK_PARAMS;



//============================================================
//
//						Value
//
//============================================================




/// <summary>
/// 接口的值信息
/// </summary>
class VALUE
{
public:

	VALUE()
	{
		type = VALUE_TYPE::Type_Unknown;
		passMode = VALUE_PASS_MODE::PASS_BY_VALUE;
		Ptr = nullptr;
	}

	/// <summary>
	/// 重载 = 
	/// </summary>
	/// <param name="v"></param>
	/// <returns></returns>
	VALUE& operator = (const VALUE& v)
	{
		if (this != &v)
		{
			this->type = v.type;
			this->passMode = v.passMode;
			this->Ptr = v.Ptr;
			// this->strValueString = v.strValueString;

		}

		return *this;
	}

	// 2022-3-25 清空Value
	void clear()
	{
		this->passMode = VALUE_PASS_MODE::PASS_BY_VALUE;
		this->type = VALUE_TYPE::Type_Unknown;
		this->Ptr = nullptr;
	}


public:

	VALUE_TYPE			type;									// 值类型
	VALUE_PASS_MODE		passMode;								// 值的传递方式
	void** Ptr;													// 接口的值指针

};




//============================================================
//
//						Interface
//
//============================================================



/// <summary>
/// // 用于存储工具库中的工具接口静态信息
// (设计思路变更：让初始化加载的静态工具信息和加入POU执行的运行时工具信息分开)
/// </summary>
class STATIC_INTERFACE
{
public:

	STATIC_INTERFACE()
	{
		reset();
	}

	void reset()
	{
		strName.clear();

		Direction = INF_DIRECTION::INF_DIR_UNKNOWN;
		Discard = INF_DISCARD::INF_DEFAULT;
		Type = INF_TYPE::INF_TYPE_STANDARD;

		nIndex = -1;

		bEnable = true;
		bDynamic = false;
		bShowName = true;
		// eventTrigger = nullptr;

		value.clear();
	}

public:

	QString					strName;				// 接口名称

	INF_TYPE				Type;					// 接口的类别
	INF_DIRECTION			Direction;				// 接口的输入输出类型	

	INF_DISCARD				Discard;				// 该端口已经废弃的标志
	// （备注：指在dll已经删除的端口，但是为了向下兼容，旧版本依然会加载。功能上会用黑色的端口显示）

	VALUE					value;					// 接口的值信息	

	int						nIndex;					// 接口的序号

	bool					bEnable;				// 是否启用此接口

	bool					bDynamic;				// 是否是动态接口

	bool					bShowName;				// 是否在界面中显示接口名称（Goto的输入接口，以及Start接口等，在界面中是不显示名称的）

};

using DLL_INF = class STATIC_INTERFACE;


/// <summary>
/// 用于存储接口的运行时信息
// 2021-5-20调整，将TOOL和全局变量组整合到一起
// 每一个变量数据就相当于是一个接口
/// </summary>
using GVL = class TOOL;
class ToolEvent;
class _INTERFACE : public STATIC_INTERFACE
{

public:

	_INTERFACE*				pUpLinkInterface;		// 上联的Interface
	QVector<_INTERFACE*>	pDownLinkInterfaces;	// 下联的Interface（下联接口会有多个）

	_INTERFACE*				pBindInterface;			// 绑定的Interface（仅用于Port类型工具）

	QString					strFullName;			// 接口的全名（toolname.interfacename）
	QString					strPropertyName;		// 2022-1-18增加，变量在属性表中的属性名字（仅用于属性表）
	QString					strNameWithType;		// 2021-10-14增加，为了方便在界面中直接显示接口类型，加了一个以<type>为结尾的名字

	bool					bWatch;					// 是否启用变量监控，默认不启用，可在工具中配置默认状态

	QString					strComment;				// 2021-5-20增加，接口的注释信息(仅变量)
	bool					bSerialized;			// 2021-5-20增加，是否进行值序列化(仅变量)
	bool					bShow;					// 2022-2-15增加，是否显示数值（仅变量）

	int						nRefCount;				// 引用计数（接口/变量）

	bool					bDataLink;				// 2021-11-9，是否与Runtime做了数据链接
	QString					valueString;			// 2021-11-9，尝试性增加了本接口的数值字符串为了提高代码效率

	bool					bComplexLinkIndex;		// 2021-12-14，是否被作为复杂控件的索引数值
													// （备注：当索引数值变动时，需要向Runtime推送当前索引所有数据的变动通知）

	VPEnum::GVL_ACCESS_MODE	accessMode;				// 2022-2-26，变量存取权限（仅DB模式全局变量会用到）
	QString					strCommAddress;			// 2022-2-26，通信地址（仅DB模式全局变量会用到）

	ToolEvent*				eventTrigger;			// 2022-9-1，增加变量数值的变动通知（因为增加了变量变动触发Task的动作）

protected:

	// 2022-3-23，防止此指针的错误使用，设置为私有
	// 正确的用法应该是用 realParent() 获取真实的父工具（因为存在接口或者变量绑定到别的Tool中的情况）
	TOOL* pParentTool;			// 从属的工具

};

// 增加一些同名名称
using VARIABLE = class _INTERFACE;

using VARIABLES = QVector<_INTERFACE*>;



//============================================================
//
//							Tool
//
//============================================================



///////////////////////////////////////////////////////////
//	工具基础信息
class TOOL_BASE_INFO
{

public:

	TOOL_TYPE					Type;						// 工具的类型

	QString						strPouName;					// 2021.7.4 增加，工具所属的Pou名字(Tool的分组，变量是所在的Gvl的名字)

	QString						strName;					// 工具名称
	QString						strAliasName;				// 曾用名或者别名
	QString						strInstanceName;			// 工具的实例名字
	QString						strCategory;				// 工具所在的集合
	QString						strVersion;					// 工具的版本
	QString						strInfo;					// 工具的Info
	QString						strComment;					// 工具的注释信息
};


///////////////////////////////////////////////////////////
// 用于存储工具库中的工具的静态信息
class TOOL;
class STATIC_TOOL : public TOOL_BASE_INFO
{
public:

	STATIC_TOOL()
	{
		Type = TOOL_TYPE::TOOL_TYPE_UNKNOWN;
	}

	// 2022-10-14，从TOOL中提取基础信息生成STATIC_TOOL（目前用于Undo体系中记录工具原始信息）
	STATIC_TOOL(const TOOL* tool);

	//// 2022-10-1，编写拷贝构造函数，完成工具原始信息的深度拷贝（目前用于Undo结构中）
	//STATIC_TOOL(const STATIC_TOOL& toolInfo);
	//// 2022-10-1，重载 = 运算符，完成工具原始信息的深度拷贝（目前用于Undo结构中）
	//STATIC_TOOL& operator = (const STATIC_TOOL& toolInfo);

public:

	QString						strDllPath;					// 实现本工具的dll

	QVector<STATIC_INTERFACE>	staticInterfaces;			// 接口的静态信息

};

using ToolActivator = QWaitCondition;


///////////////////////////////////////////////////////////
// 用于存储Tool的运行时信息
class TOOL : public TOOL_BASE_INFO
{

public:

	DllTool* pDllPtr;					// 工具Dll运行的实例指针

	TOOL* parentTool;					// 2022-4-18，本工具所属的工具组(目前只有并行工具组)

	QVector<_INTERFACE*>		Interfaces;					// Tool的标准接口

	QVector<_INTERFACE*>		ToolInterfaces;				// 2022-8-21 改动，将Tool接口定义为了数组，方便扩展

	// 目前总共有两个Tool级别接口
#define INF_START				0
#define INF_END					1
#define TOOL_INTERFACE_COUNT	2
#define startInterface			ToolInterfaces[INF_START]
#define endInterface			ToolInterfaces[INF_END]

	// _INTERFACE* pBindInterface;							// Port绑定的源接口的指针(仅Port类型)

#define Variables				Interfaces					// （仅变量类型使用）

	// 工具执行的相关参数
	bool						bEnable;					// 是否启用本工具

	int							nIndex;						// 工具的执行序号

	bool						bEnableBreakPoint;			// 启用断点

	EXEC_PARAMS					execParams;					// 执行参数

	GVL_MODE					gvlMode;					// 全局变量的模式（仅用于变量）

	// DllTool*					pHdwDllPtr;					// 2022-3-2，本DB数据绑定的硬件工具（仅用于DB模式变量）

	QString						strHdwInstName;				// 本DB数据绑定的硬件工具实例名称（仅用于DB模式变量）

	// bool						bParallelized;				// 2022-5-4，是否加入了并行组（2022-8-28去掉，改为运行时实时判定）

	// ToolEvent*					eventTrigger;				// 2022-9-3，Tool也加入了Event触发机制（用于给Wait工具使用）

	QMutex						mutex;						// Tool与Event对应的互斥量，用于等待事件触发
	ToolActivator				activator;					// 2022-9-3，TaskManager中用于触发Tool的事件（目前用于Wait工具）

};

// 变量组
using GVLS = QMap<QString, GVL*>;

//============================================================
//
//					Task、Event
//
//============================================================


/// <summary>
/// ToolEvent中的执行方式
/// </summary>
enum class TOOL_EVENT_TYPE : short
{
	TOOL_TRIGGER,							// 触发执行某个工具
	TASK_TRIGGER,							// 触发执行Task
	//TOOL_TRIGGER_BY_VALUE,					// 按照等于某个值时触发工具
	//TASK_TRIGGER_BY_VALUE					// 按照等于某个值时触发Task（暂未实现）
};


/// <summary>
/// 工具中的事件接口类型
/// </summary>
class ToolEvent : public QEvent
{
public:
	ToolEvent() :
		// QEvent((QEvent::Type)QEvent::registerEventType(QEvent::User + genRandNumber(0, 60000)));
		// 此处似乎不需要随机生成ID，系统会从MaxUser开始自动往下分配
		QEvent((QEvent::Type)QEvent::registerEventType())
	{
		m_exType = TOOL_EVENT_TYPE::TASK_TRIGGER;
	}

	// QEvent((QEvent::Type)QEvent::registerEventType(QEvent::User + genRandNumber(0, 60000)));
	// 此处似乎不需要随机生成ID，系统会从MaxUser开始自动往下分配
	// 这个ID号是
	ToolEvent(const QString& strGroupName, const QString& strName, TOOL_EVENT_TYPE type) :
		QEvent((QEvent::Type)QEvent::registerEventType())
	{
		setName(strGroupName, strName);

		m_exType = type;
	}

	~ToolEvent() {};

	// 设定Event的名字(Tool.Interface的全名以及GroupName)
	void setName(const QString& strGroupName, const QString& strName)
	{
		this->m_strGroupName = strGroupName;
		this->m_strEventName = strName;
	}

	// 设定Event的GroupName（默认都是 HARDWARE_GROUP_NAME，以防万一需要扩展，还是保存一下 ）

	// 获取Event的名字
	QString name() const
	{
		return m_strEventName;
	}

	// 获取GroupName
	QString groupName() const
	{
		return m_strGroupName;
	}

	void setExType(TOOL_EVENT_TYPE type)
	{
		m_exType = type;
	}

	TOOL_EVENT_TYPE getExType() const
	{
		return m_exType;
	}

	// 2022-9-25 为了实现等于某个值的事件触发增加
	VALUE			m_triggerValue;

protected:

	QString			m_strEventName;

	QString			m_strGroupName;

	TOOL_EVENT_TYPE m_exType = TOOL_EVENT_TYPE::TASK_TRIGGER;

public:

	// 事件携带的返回值
	VPEnum::RETURN_VALUE ret = VPEnum::RETURN_VALUE::Success;
};

// 设置别名
using TaskActivator = QWaitCondition;
using EVENT_ID = QEvent::Type;



/// <summary>
/// 用于UI、Runtime和Dll同步的消息
/// </summary>
enum class UI_SYNC_MSG : short
{
	EDIT_TEXT_CHANGED,
	COMBO_SEL_CHANGED,
	LIST_SEL_CHANGED,
	CHECKBOX_CHANGED,
	RADIOBOX_CHANGED,
	VALUE_CHANGED,
	UNKNOWN_MSG

};


/// <summary>
/// 控件到Runtime的同步事件(每次仅一个控件同步)
/// </summary>
#define CONTROL_EVENT_TYPEID						QEvent::Type::User + 10
class SyncControlEvent : public QEvent
{
public:

	SyncControlEvent() :
		QEvent(eventType())
	{

	}

	~SyncControlEvent() {};

	static Type eventType()
	{
		// 创建事件Type
		if (m_EventType == QEvent::None)
		{
			m_EventType = (QEvent::Type)QEvent::registerEventType(CONTROL_EVENT_TYPEID);
		}


		return m_EventType;
	}

	// 待同步的控件句柄
	QWidget* m_pSrcControl = nullptr;

	// 待同步的控件事件类型
	UI_SYNC_MSG				m_SyncMsg = UI_SYNC_MSG::UNKNOWN_MSG;

private:

	static Type m_EventType;
};


/// <summary>
/// 数值到Runtime的同步事件（WindowRuntime用）
/// 同时也作为动态接口到Pou的同步事件（UiManager用）
/// 同时也作为全局变量在表格中的变动通知（GvlManager用）
/// </summary>
#define VALUE_EVENT_TYPEID							QEvent::Type::User + 11
class SyncValueEvent : public QEvent
{
public:

	SyncValueEvent() :
		QEvent(eventType())
	{

	}

	~SyncValueEvent() {};

	static Type eventType()
	{
		// 创建事件Type
		if (m_EventType == QEvent::None)
		{
			m_EventType = (QEvent::Type)QEvent::registerEventType(VALUE_EVENT_TYPEID);
		}


		return m_EventType;
	}

	// 待同步数据项
	void addSyncValue(VARIABLE* val)
	{
		m_SyncValues.push_back(val);
	}

	QList<VARIABLE*> getSyncValues() const
	{
		return m_SyncValues;
	}

	void setSyncValues(const QList<VARIABLE*>& listInf)
	{
		m_SyncValues = listInf;
	}

private:

	static Type m_EventType;

	// Value（一个或多个）
	QList<VARIABLE*>			m_SyncValues;
};


/// <summary>
/// 硬件数值接口到Runtime的同步事件
/// </summary>
#define HDVALUE_EVENT_TYPEID						QEvent::Type::User + 12
class SyncHdValueEvent : public QEvent
{
public:

	SyncHdValueEvent() :
		QEvent(eventType())
	{

	}

	~SyncHdValueEvent() {};

	// 设定Event的 GroupName
	void setGroupName(const QString& strGroupName)
	{
		this->m_strGroupName = strGroupName;
	}

	// 获取GroupName
	QString groupName() const
	{
		return m_strGroupName;
	}


	static Type eventType()
	{
		// 创建事件Type
		if (m_EventType == QEvent::None)
		{
			m_EventType = (QEvent::Type)QEvent::registerEventType(HDVALUE_EVENT_TYPEID);
		}

		return m_EventType;
	}

	// 需要同步的硬件接口信息

	// 第一种同步方式，按实例名和接口名同步
	QString		m_strInstanceName;				// 实例名称
	QString		m_strInfName;					// 接口名称

	// 第二种同步方式：直接按数值指针同步
	void* m_pSrcValue = nullptr;			// 接口数值指针
protected:

	QString			m_strGroupName;

private:

	static Type m_EventType;

};


/// <summary>
/// 动态接口到Pou的同步事件
/// </summary>
#define DLLINF_EVENT_TYPEID							QEvent::Type::User + 13
class SyncInterfaceEvent : public QEvent
{
public:

	SyncInterfaceEvent() :
		QEvent(eventType())
	{

	}

	~SyncInterfaceEvent() {};

	static Type eventType()
	{
		// 创建事件Type
		if (m_EventType == QEvent::None)
		{
			m_EventType = (QEvent::Type)QEvent::registerEventType(DLLINF_EVENT_TYPEID);
		}

		return m_EventType;
	}

	// 待同步动态接口
	void addSyncInterface(const DLL_INF val)
	{
		m_SyncDllInfs.push_back(val);
	}

	QList<DLL_INF> getSyncInterfaces() const
	{
		return m_SyncDllInfs;
	}

	void setSyncValues(const QList<DLL_INF> listInf)
	{
		m_SyncDllInfs = listInf;
	}

	// 待同步接口的工具实例名称
	QString					m_strInstanceName;

	// true 是增加， false 是删除
	bool					m_bAdd = true;

	// 执行结果
	bool					m_bSuccess = false;
	// 原因（如果出错）
	QString					m_strReason;

private:

	static Type m_EventType;

	// Interface（一个或多个）
	QList<DLL_INF>			m_SyncDllInfs;
};


typedef struct _tagDisplay
{

public:

	HObject					ho_Obj;
	QColor					Color;
	double					fTransparency;
	int						nLinsWhite;

public:

	_tagDisplay()
	{
		nLinsWhite = 0;
		fTransparency = 0;
	}


	_tagDisplay(HObject obj, QColor color = qRgb(255, 0, 0), double fTransparency = 0.0, int nLinsWhite = 1)
	{
		this->ho_Obj = obj;
		this->Color = color;
		this->fTransparency = fTransparency;
		this->nLinsWhite = nLinsWhite;
	}


	void setObject(HObject obj, QColor color = qRgb(255, 0, 0), double fTransparency = 0.0, int nLinsWhite = 1)
	{
		this->ho_Obj = obj;
		this->Color = color;
		this->fTransparency = fTransparency;
		this->nLinsWhite = nLinsWhite;
	}


	void Clear()
	{
		this->ho_Obj.Clear();
		this->Color = qRgb(255, 0, 0);
		this->fTransparency = 0.0;
		this->nLinsWhite = 1;
	}


	_tagDisplay& operator =(const _tagDisplay& disp)
	{
		if (this != &disp)
		{
			this->ho_Obj = disp.ho_Obj;
			this->Color = disp.Color;
			this->fTransparency = disp.fTransparency;
			this->nLinsWhite = disp.nLinsWhite;
		}
		return *this;
	}

}  ST_Display;



typedef struct _tagMessage
{

public:

	HTuple					hv_Msg;
	int						nX;
	int						nY;
	int						nMsgSize;
	QColor					Color;


public:
	_tagMessage()
	{
		Clear();
	}


	_tagMessage(HTuple hvMsg, QColor color = qRgb(255, 0, 0), int nX = 10, int nY = 10, int nMsgSize = 10)
	{
		this->hv_Msg = hvMsg;
		this->Color = color;
		this->nX = nX;
		this->nY = nY;
		this->nMsgSize = nMsgSize;
	}


	void setMsg(HTuple hvMsg, QColor color = qRgb(255, 0, 0), int nX = 10, int nY = 10, int nMsgSize = 10)
	{
		this->hv_Msg = hvMsg;
		this->Color = color;
		this->nX = nX;
		this->nY = nY;
		this->nMsgSize = nMsgSize;
	}


	void Clear()
	{
		hv_Msg.Clear();
		this->Color = qRgb(255, 0, 0);
		this->nX = 10;
		this->nY = 10;
		this->nMsgSize = 10;
	}


	_tagMessage& operator =(const _tagMessage& msg)
	{
		if (this != &msg)
		{
			this->hv_Msg = msg.hv_Msg;
			this->Color = msg.Color;
			this->nX = msg.nX;
			this->nY = msg.nY;
			this->nMsgSize = msg.nMsgSize;
		}
		return *this;
	}



}ST_Message;


typedef struct _tagDebugLog
{

public:

	QString				strName;
	QString				strLog;


public:

	_tagDebugLog()
	{
		Clear();
	}


	_tagDebugLog(QString strName, QString strLog)
	{
		this->strName = strName;
		this->strLog = strLog;
	}


	void Clear()
	{
		this->strName = "";
		this->strLog = "";
	}


	_tagDebugLog& operator =(const _tagDebugLog& log)
	{
		if (this != &log)
		{
			this->strName = log.strName;
			this->strLog = log.strLog;
		}
		return *this;
	}

}ST_DebugLog;


/// <summary>
/// 用于Debug输出的结构体
/// </summary>
typedef struct _tagDebugData
{

public:

	_tagDebugData()
	{
		Clear();
	}


	void Clear()
	{
		listDisplay.clear();
		listMessage.clear();
		listDebugLog.clear();
	}


	void addImage(HImage img)
	{
		ho_Image = img;
	}


	void addObj(HObject obj, QColor color = qRgb(255, 0, 0), double fTransparency = 0.0, int nLinsWhite = 1)
	{
		ST_Display disp(obj, color, fTransparency, nLinsWhite);
		listDisplay.push_back(disp);

	}


	void addMsg(HTuple hvMsg, QColor color = qRgb(255, 0, 0), int nX = 10, int nY = 10, int nMsgSize = 10)
	{
		ST_Message msg(hvMsg, color, nX, nY, nMsgSize);
		listMessage.push_back(msg);
	}


	void addLog(QString strName = "NULL", QString strLog = "Log")
	{
		ST_DebugLog debuglog(strName, strLog);
		listDebugLog.push_back(debuglog);
	}


	_tagDebugData& operator =(const _tagDebugData& data)
	{
		if (this != &data)
		{
			this->ho_Image = data.ho_Image;
			this->listDisplay = data.listDisplay;
			this->listMessage = data.listMessage;
			this->listDebugLog = data.listDebugLog;
		}
		return *this;
	}


	HImage getImage()
	{
		return ho_Image;
	}


	ST_Display getDisplay(int index)
	{
		ST_Display disp;
		if ((index >= 0) && (index < listDisplay.size()))
		{
			disp = listDisplay[index];
		}
		return disp;
	}


	ST_Message getMessage(int index)
	{
		ST_Message msg;
		if ((index >= 0) && (index < listMessage.size()))
		{
			msg = listMessage[index];
		}
		return msg;
	}


	ST_DebugLog getDebugLog(int index)
	{
		ST_DebugLog log;
		if ((index >= 0) && (index < listDebugLog.size()))
		{
			log = listDebugLog[index];
		}
		return log;
	}


	int getDisplaySize()
	{
		return listDisplay.size();
	}


	int getMessageSize()
	{
		return listMessage.size();
	}


	int getDebugLogSize()
	{
		return listDebugLog.size();
	}

protected:
	HImage						ho_Image;

	QList<ST_Display>			listDisplay;
	QList<ST_Message>			listMessage;
	QList<ST_DebugLog>			listDebugLog;

} DebugData;