#include "VImageControl.h"
#include "GvlManager.h"
#include "Preferences.h"

// 默认的HObject数量
#define DEFAULT_HOBJECT_COUNT			0
// 默认的HTuple数量
#define DEFAULT_HTUPLE_COUNT			0
// 默认的Display数量
#define DEFAULT_DISPALY_COUNT			0
// 默认的字符串数量
#define DEFAULT_STRING_COUNT			0

VImageControl::VImageControl(
	QWidget* parent,
	const QPoint& pos,
	const QSize& size,
	CONTROL_PROPERTY* pProperty,
	CONTROL_PROPERTY_EX* pPropertyEx,
	bool bStartSaveThread
)
	: HWndUnit(parent)
	, VControlObject(pProperty)
{
	// 设置控件指针
	m_pWidget = this;

	// 设置控件类型
	m_Type = VALUE_TYPE::Control_Image;

	// 备用颜色集合
	m_defaultColors
		<< QColor(0, 176, 180, 128)
		<< QColor(255, 192, 0, 128)
		<< QColor(0, 113, 193, 128)
		<< QColor(72, 103, 149, 128)
		<< QColor(185, 87, 86, 128)
		<< QColor(0, 177, 125, 128)
		<< QColor(214, 77, 84, 128)
		<< QColor(71, 164, 233, 128)
		<< QColor(34, 163, 169, 128)
		<< QColor(40, 45, 48, 128)
		<< QColor(162, 121, 197, 128)
		<< QColor(72, 202, 245, 128)
		<< QColor(0, 150, 121, 128)
		<< QColor(111, 9, 176, 128)
		<< QColor(250, 170, 20, 128);

	// 设置尺寸
	if (size == DEFAULT_CONTROL_SIZE)
	{
		this->resize(DEFAULT_IMAGE_SIZE);
	}
	else
	{
		this->resize(size);
	}

	// 设置中心点坐标
	QPoint tempPos;
	tempPos.setX(pos.x() - width() / 2);
	tempPos.setY(pos.y() - height() / 2);

	// 设置位置
	this->move(tempPos);

	this->setWndTitle(m_Property.m_strText);

	// 初始化扩展属性
	if (pPropertyEx == nullptr)
	{
		// 设置初始化的数量
		this->m_Property.m_nHObjectCount = DEFAULT_HOBJECT_COUNT;
		this->m_Property.m_nHTupleCount = DEFAULT_HTUPLE_COUNT;
		this->m_Property.m_nDisplayCount = DEFAULT_DISPALY_COUNT;
		this->m_Property.m_nStringCount = DEFAULT_STRING_COUNT;

		// 初始化扩展属性
		this->initPropertyEx();

		// 刷新图形
		//this->Refresh();
	}
	else
	{
		this->m_PropertyEx = *pPropertyEx;

		// 刷新图形
		this->Refresh();
	}

	if (bStartSaveThread)
	{
		startSaveThread();
	}
}

VImageControl::~VImageControl()
{
	m_nThreadState = 0;
}


/// <summary>
/// 重绘图像背景，显示默认图片
/// </summary>
/// <param name=""></param>
void VImageControl::paintEvent(QPaintEvent*)
{
	QPainter painter(this);
	painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing);
	QString path = ":/image/Vimage.png";
	QPixmap pixmap = QPixmap(path).scaled(this->size());
	painter.drawImage(QRect(0, 0, this->width(), this->height()), pixmap.toImage());
}


/// <summary>
/// 显示图像
/// </summary>
/// <param name="image"></param>
void VImageControl::ShowImage(HImage image)
{
	HWndUnit::ShowImage(image);
}


/// <summary>
/// 显示Object
/// </summary>
/// <param name="obj"></param>
/// <param name="color"></param>
/// <param name="fTransparency"></param>
/// <param name="nLinsWhite"></param>
void VImageControl::ShowObj(HObject obj, QColor color, int nLineWidth)
{
	Q_UNUSED(nLineWidth);
	Q_UNUSED(color);

	HWndUnit::ShowObj(obj, color, nLineWidth);
}


/// <summary>
/// 显示文字
/// </summary>
/// <param name="msg"></param>
/// <param name="strColor"></param>
/// <param name="nX"></param>
/// <param name="nY"></param>
/// <param name="nSize"></param>
void VImageControl::ShowMsg(HTuple msg, QColor color, QPoint pt, int nSize)
{
	HWndUnit::ShowMsg(msg, color, pt.x(), pt.y(), nSize);
}


/// <summary>
/// 刷新图片显示
/// </summary>
void VImageControl::Refresh()
{
	HWndUnit::Refresh(false);
}


/// <summary>
/// 生成一个随机的HObject供预览使用（暂未使用）
/// </summary>
/// <returns></returns>
HalconCpp::HObject VImageControl::genRandomHObject()
{
	HObject dd;
	GenRectangle1(&dd, 500, 500, 900, 900);

	// GetDebugDataPtr()->addObj(dd, qRgb(255, 255, 0), 0.3);

	return dd;
}


/// <summary>
/// 生成一个随机的Tuple供预览使用（暂未使用）
/// </summary>
/// <returns></returns>
HalconCpp::HTuple VImageControl::genRandomHTuple()
{
	HTuple msg("msg");

	return msg;
}


//==============================================================
//
//						基础属性相关
//
//==============================================================


//void VImageControl::setEnable(const bool enable)
//{
//	if (this->m_Property.m_bEnable != enable)
//	{
//		this->m_Property.m_bEnable = enable;
//		//QRadioButton::setEnabled(enable);
//	}
//}

void VImageControl::setText(const QString& title)
{
	// qDebug() << m_Property.m_strText;

	if (this->m_Property.m_strText != title)
	{
		this->m_Property.m_strText = title;
	}
}


/// <summary>
/// 设置HObject数量
/// </summary>
/// <param name="count"></param>
void VImageControl::setHObjectCount(const int& count)
{
	if (this->m_Property.m_nHObjectCount != count)
	{
		this->m_Property.m_nHObjectCount = count;
	}
}


/// <summary>
/// 获取HObject数量
/// </summary>
/// <returns></returns>
int VImageControl::getHObjectCount()
{
	return this->m_Property.m_nHObjectCount;
}


/// <summary>
/// 设置HTuple数量
/// </summary>
/// <param name="count"></param>
void VImageControl::setHTupleCount(const int& count)
{
	if (this->m_Property.m_nHTupleCount != count)
	{
		this->m_Property.m_nHTupleCount = count;


	}
}


/// <summary>
/// 获取HTuple数量
/// </summary>
/// <returns></returns>
int VImageControl::getHTupleCount()
{
	return this->m_Property.m_nHTupleCount;
}



/// <summary>
/// 设置Display数量
/// </summary>
/// <param name="count"></param>
void VImageControl::setDisplayCount(const int& count)
{
	if (this->m_Property.m_nDisplayCount != count)
	{
		this->m_Property.m_nDisplayCount = count;
	}
}


/// <summary>
/// 获取HTuple数量
/// </summary>
/// <returns></returns>
int VImageControl::getDisplayCount()
{
	return this->m_Property.m_nDisplayCount;
}


/// <summary>
/// 设置Display数量
/// </summary>
/// <param name="count"></param>
void VImageControl::setStringCount(const int& count)
{
	if (this->m_Property.m_nStringCount != count)
	{
		this->m_Property.m_nStringCount = count;
	}
}


/// <summary>
/// 获取HTuple数量
/// </summary>
/// <returns></returns>
int VImageControl::getStringCount()
{
	return this->m_Property.m_nStringCount;
}


//==============================================================
//
//						扩展属性相关
//
//==============================================================





/// <summary>
/// 初始化扩展属性
/// </summary>
void VImageControl::initPropertyEx()
{
	// 扩展属性的总名称
	m_PropertyEx.m_strTitle = IMAGE_PROPERTY_EX_NAME;

	// 用于触发刷新的数据链接（无默认值）
	m_PropertyEx.m_refreshLink.title = IMAGE_PROPERTY_EX_REFRESHLINK_NAME;
	// 需要强制设置
	m_PropertyEx.m_refreshLink.bForce = true;

	// 图像主数据连接（1个，无默认值）
	m_PropertyEx.m_mainDataLinks.resize(IMAGE_PROPERTY_EX_MAINLINK_COUNT);
	// 图像链接名称
	m_PropertyEx.m_mainDataLinks[0].title = IMAGE_PROPERTY_EX_MAINLINK_NAME;
	// 需要强制设置
	m_PropertyEx.m_mainDataLinks[0].bForce = true;


	// 初始化每一个扩展子属性组（Image控件有两个扩展属性组）

	//----------- HObject分组
	PROPERTY_EX_GROUP group;

	// HObject信息属性
	group.strTitle = IMAGE_PROPERTY_EX_GROUP_NAME;
	group.strRelationKey = IMAGE_OBJ_COUNT_NAME;

	//初始化HObject信息每一个子分组
	for (int i = 0; i < m_Property.m_nHObjectCount; i++)
	{
		PROPERTY_EX_SUBGROUP subGroup;

		this->initSubGroup(subGroup, i, GROUP_INDEX_HOBJECT);

		// 保存子分组
		group.subGroups.push_back(subGroup);
	}

	// 保存本子分组定义信息
	m_PropertyEx.m_groups.push_back(group);


	//----------- HTuple 分组
	PROPERTY_EX_GROUP group2;

	// HObject信息属性分组
	group2.strTitle = IMAGE_PROPERTY_EX_GROUP2_NAME;
	group2.strRelationKey = IMAGE_MSG_COUNT_NAME;

	//初始化HTuple信息每一个子分组
	for (int i = 0; i < m_Property.m_nHTupleCount; i++)
	{
		PROPERTY_EX_SUBGROUP subGroup;

		this->initSubGroup(subGroup, i, GROUP_INDEX_HTUPLE);

		// 保存子分组
		group2.subGroups.push_back(subGroup);
	}

	// 保存本子分组定义信息
	m_PropertyEx.m_groups.push_back(group2);


	//----------- DIsplay 分组
	PROPERTY_EX_GROUP group3;

	// DIsplay信息属性分组
	group3.strTitle = IMAGE_PROPERTY_EX_GROUP3_NAME;
	group3.strRelationKey = IMAGE_DISPLAY_COUNT_NAME;

	//初始化DIsplay信息每一个子分组
	for (int i = 0; i < m_Property.m_nDisplayCount; i++)
	{
		PROPERTY_EX_SUBGROUP subGroup;

		this->initSubGroup(subGroup, i, GROUP_INDEX_DISPLAY);

		// 保存子分组
		group3.subGroups.push_back(subGroup);
	}

	// 保存本子分组定义信息
	m_PropertyEx.m_groups.push_back(group3);


	//----------- 字符串信息
	PROPERTY_EX_GROUP group4;

	// String 信息属性分组
	group4.strTitle = IMAGE_PROPERTY_EX_GROUP4_NAME;
	group4.strRelationKey = IMAGE_STRING_COUNT_NAME;

	//初始化String信息每一个子分组
	for (int i = 0; i < m_Property.m_nStringCount; i++)
	{
		PROPERTY_EX_SUBGROUP subGroup;

		this->initSubGroup(subGroup, i, GROUP_INDEX_STRING);

		// 保存子分组
		group4.subGroups.push_back(subGroup);
	}

	// 保存本子分组定义信息
	m_PropertyEx.m_groups.push_back(group4);


	//----------- 附加信息（配置文件名，文件路径，是否存储，存储模式）
	PROPERTY_EX_GROUP group5;

	// HObject信息属性分组
	group5.strTitle = IMAGE_PROPERTY_EX_GROUP5_NAME;
	group5.strRelationKey = IMAGE_DISPLAY_COUNT_NAME;

	{
		PROPERTY_EX_SUBGROUP subGroup;

		this->initSubGroup(subGroup, 0, GROUP_INDEX_SAVE);

		// 保存子分组
		group5.subGroups.push_back(subGroup);
	}

	// 保存本子分组定义信息
	m_PropertyEx.m_groups.push_back(group5);

	//// 2022-9-11 为刷新链接绑定默认值（系统的执行次数）
	//this->bindDefaultRefreshDataLink();
}


/// <summary>
/// 初始化扩展属性组
/// </summary>
/// <param name="subGroup"></param>
/// <param name="nIndex"></param>
/// <param name="nSubGroupID"></param>
void VImageControl::initSubGroup(PROPERTY_EX_SUBGROUP& subGroup, int nIndex, int nSubGroupID)
{
	switch (nSubGroupID)
	{
	case GROUP_INDEX_HOBJECT:
		this->initSubGroupHObject(subGroup, nIndex);
		break;
	case GROUP_INDEX_HTUPLE:
		this->initSubGroupHTuple(subGroup, nIndex);
		break;
	case GROUP_INDEX_DISPLAY:
		this->initSubGroupDisplay(subGroup, nIndex);
		break;
	case GROUP_INDEX_STRING:
		this->initSubGroupString(subGroup, nIndex);
		break;
	case GROUP_INDEX_SAVE:
		this->initSubGroupSave(subGroup, nIndex);
		break;
	default:
		break;
	}
}


/// <summary>
/// 初始化一个扩展属性组
/// </summary>
/// <param name="subItem"></param>
/// <param name="nIndex"></param>
void VImageControl::initSubGroupHObject(PROPERTY_EX_SUBGROUP& subGroup, int nIndex)
{
	QString idx = QString::number(nIndex + 1);

	// 子分组名称
	subGroup.strTitle = IMAGE_PROPERTY_EX_SUBGROUP_NAME + idx;

	// 图层链接
	DataLink dataLink1;
	dataLink1.title = IMAGE_PROPERTY_EX_LINK1_NAME + idx;
	// 强制链接
	dataLink1.bForce = true;
	subGroup.dataLinks.push_back(dataLink1);
	// 状态链接
	DataLink dataLink2;
	dataLink2.title = IMAGE_PROPERTY_EX_LINK2_NAME + idx;
	// 默认值（int, 0）
	dataLink2.defaultValue = g_pGvlManager->getDefaultValueByName(DEFAULT_VALUE_0);
	subGroup.dataLinks.push_back(dataLink2);

	// 杂项

	// HObject颜色名称
	subGroup.strColorName = IMAGE_PROPERTY_EX_HOBJECT_COLOR_NAME + idx;
	// 按顺序给一个默认值（可能会越界）
	if (nIndex < m_defaultColors.size())
	{
		subGroup.color = m_defaultColors.at(nIndex);
	}
	else
	{
		subGroup.color = m_defaultColors.at(nIndex - m_defaultColors.size());
	}

	//// HObject透明度
	//subGroup.strTranspName = IMAGE_PROPERTY_EX_TRANSP_NAME + idx;
	//subGroup.fTransparency = 0.0;

	// HObject 线宽
	subGroup.strLineWidthName = IMAGE_PROPERTY_EX_LINEWIDTH_NAME + idx;
	subGroup.nLineWidth = IMAGE_DEFAULT_LINEWIDTH;
}


/// <summary>
/// 初始化一个扩展属性组2
/// </summary>
/// <param name="subItem"></param>
/// <param name="nIndex"></param>
void VImageControl::initSubGroupHTuple(PROPERTY_EX_SUBGROUP& subGroup, int nIndex)
{
	QString idx = QString::number(nIndex + 1);

	// 子分组名称
	subGroup.strTitle = IMAGE_PROPERTY_EX_SUBGROUP2_NAME + idx;

	// 文本链接
	DataLink dataLink1;
	dataLink1.title = IMAGE_PROPERTY_EX_LINK3_NAME + idx;
	// 默认值（QString,""）
	dataLink1.defaultValue = g_pGvlManager->getDefaultValueByName(DEFAULT_VALUE_0);
	subGroup.dataLinks.push_back(dataLink1);
	// 状态链接
	DataLink dataLink2;
	dataLink2.title = IMAGE_PROPERTY_EX_LINK4_NAME + idx;
	// 默认值（int, 0）
	dataLink2.defaultValue = g_pGvlManager->getDefaultValueByName(DEFAULT_VALUE_0);
	subGroup.dataLinks.push_back(dataLink2);

	// 杂项

	// HTuple 颜色名称
	subGroup.strColorName = IMAGE_PROPERTY_EX_HTUPLE_COLOR_NAME + idx;
	// 按顺序给一个默认值（可能会越界）
	if (nIndex < m_defaultColors.size())
	{
		subGroup.color = m_defaultColors.at(nIndex);
	}
	else
	{
		subGroup.color = m_defaultColors.at(nIndex - m_defaultColors.size());
	}

	// HTuple 坐标值（数据链接暂未启用）
	subGroup.strPtName = IMAGE_PROPERTY_EX_HTUPLE_PT_NAME + idx;
	subGroup.pt = QPoint(IMAGE_DEFAULT_X, IMAGE_DEFAULT_Y);
	//// HTuple 坐标数据链接
	//subGroup.dataLinkPoint.title = IMAGE_PROPERTY_EX_HTUPLE_PT_NAME + idx;

	// HTuple 尺寸
	subGroup.strSize = IMAGE_PROPERTY_EX_HTUPLE_SIZE_NAME + idx;
	subGroup.nSize = IMAGE_DEFAULT_SIZE;

	//// 图层链接名称
	//subGroup.dataLink.title = IMAGE_PROPERTY_EX_LINK2_NAME + idx;
}


/// <summary>
/// 初始化一个扩展属性组3
/// </summary>
/// <param name="subItem"></param>
/// <param name="nIndex"></param>
void VImageControl::initSubGroupDisplay(PROPERTY_EX_SUBGROUP& subGroup, int nIndex)
{
	QString idx = QString::number(nIndex + 1);

	// 子分组名称
	subGroup.strTitle = IMAGE_PROPERTY_EX_SUBGROUP3_NAME + idx;

	// DIsplay 链接
	DataLink dataLink1;
	dataLink1.title = IMAGE_PROPERTY_EX_LINK5_NAME + idx;
	// 强制链接
	dataLink1.bForce = true;
	subGroup.dataLinks.push_back(dataLink1);

	// 杂项

	// HObject颜色名称
	subGroup.strColorName = IMAGE_PROPERTY_EX_DISPLAY_COLOR_NAME + idx;
	// 按顺序给一个默认值（可能会越界）
	if (nIndex < m_defaultColors.size())
	{
		subGroup.color = m_defaultColors.at(nIndex);
	}
	else
	{
		subGroup.color = m_defaultColors.at(nIndex - m_defaultColors.size());
	}

}


/// <summary>
/// 初始化一个扩展属性组4
/// </summary>
/// <param name="subItem"></param>
/// <param name="nIndex"></param>
void VImageControl::initSubGroupString(PROPERTY_EX_SUBGROUP& subGroup, int nIndex)
{
	QString idx = QString::number(nIndex + 1);

	// 子分组名称
	subGroup.strTitle = IMAGE_PROPERTY_EX_SUBGROUP4_NAME + idx;

	// String 链接
	DataLink dataLink1;
	dataLink1.title = IMAGE_PROPERTY_EX_LINK6_NAME + idx;
	// 强制链接
	dataLink1.bForce = true;
	subGroup.dataLinks.push_back(dataLink1);

	// 杂项

	// String颜色名称
	subGroup.strColorName = IMAGE_PROPERTY_EX_STRING_COLOR_NAME + idx;
	// 按顺序给一个默认值（可能会越界）
	if (nIndex < m_defaultColors.size())
	{
		subGroup.color = m_defaultColors.at(nIndex);
	}
	else
	{
		subGroup.color = m_defaultColors.at(nIndex - m_defaultColors.size());
	}


	// String 坐标值（数据链接暂未启用）
	subGroup.strPtName = IMAGE_PROPERTY_EX_STRING_PT_NAME + idx;
	subGroup.pt = QPoint(IMAGE_DEFAULT_X, IMAGE_DEFAULT_Y);
	//// HTuple 坐标数据链接
	//subGroup.dataLinkPoint.title = IMAGE_PROPERTY_EX_HTUPLE_PT_NAME + idx;

	// HTuple 尺寸
	subGroup.strSize = IMAGE_PROPERTY_EX_STRING_SIZE_NAME + idx;
	subGroup.nSize = IMAGE_DEFAULT_SIZE;
}


/// <summary>
/// 初始化一个扩展属性组5
/// </summary>
/// <param name="subItem"></param>
/// <param name="nIndex"></param>
void VImageControl::initSubGroupSave(PROPERTY_EX_SUBGROUP& subGroup, int nIndex)
{
	QString idx = QString::number(nIndex + 1);

	// 子分组名称
	subGroup.strTitle = IMAGE_PROPERTY_EX_SUBGROUP5_NAME;

	// 文件名称 链接
	DataLink dataLink1;
	dataLink1.title = IMAGE_PROPERTY_EX_LINK7_NAME;
	// 非强制链接的需要给默认值
	dataLink1.defaultValue = g_pGvlManager->getDefaultValueByName(DEFAULT_VALUE_NULLSTRING);
	subGroup.dataLinks.push_back(dataLink1);

	// 文件路径 链接
	DataLink dataLink2;
	dataLink2.title = IMAGE_PROPERTY_EX_LINK8_NAME;
	// 非强制链接的需要给默认值
	dataLink2.defaultValue = g_pGvlManager->getDefaultValueByName(DEFAULT_VALUE_NULLSTRING);
	subGroup.dataLinks.push_back(dataLink2);

	// 状态 链接
	DataLink dataLink3;
	dataLink3.title = IMAGE_PROPERTY_EX_LINK9_NAME;
	// 非强制链接的需要给默认值
	dataLink3.defaultValue = g_pGvlManager->getDefaultValueByName(DEFAULT_VALUE_NULLSTRING);
	subGroup.dataLinks.push_back(dataLink3);

	// 杂项 (在杂项级别，或者和存储相关下面，
	//  1 添加两个复选框，启用存图，启用转储) 
	//  2 添加一个下拉列表，选择寸图模式（按日期存储，按序号存储，自定义存储）

	// 启用保存原图
	subGroup.strSaveImage = IMAGE_PROPERTY_EX_SACVE_IMG_NAME;
	subGroup.bEnSaveImage = false;

	// 启用截图
	subGroup.strDumpWindow = IMAGE_PROPERTY_EX_SAVE_DUMP_NAME;
	subGroup.bEnDumpWindow = false;

	// 启用状态判断
	subGroup.strExecuteState = IMAGE_PROPERTY_EX_EXE_STATE_NAME;
	subGroup.bEnExecuteState = false;

	// 存储模式
	subGroup.strSaveMode = IMAGE_PROPERTY_EX_SAVE_MODE_NAME;
	subGroup.nSaveMode = 0;

	// 缓冲区大小
	subGroup.strBufferSize = IMAGE_PROPERTY_EX_BUFFER_SIZE_NAME;
	subGroup.nBufferSize = 100;

	// 空闲时间
	subGroup.strFreeTime = IMAGE_PROPERTY_EX_FREE_TIME_NAME;
	subGroup.nFreeTime = 100;
}



/// <summary>
/// 重绘图像（图像+图层+文本）
/// </summary>
void VImageControl::redraw()
{
	if (!m_Image.IsInitialized())
	{
		return;
	}

	// 首先显示图形
	ShowImage(m_Image);

	// HOBject
	for (int i = 0; i < this->m_HObjects.size(); i++)
	{
		if (m_HObjects[i].IsInitialized())
		{
			if (m_HObjectsStatus[i] == 2)
			{
				ShowObj(
					m_HObjects[i],
					qRgb(255, 0, 0),
					m_PropertyEx.m_groups[GROUP_INDEX_HOBJECT].subGroups[i].nLineWidth
				);
			}
			else
			{
				ShowObj(
					m_HObjects[i],
					m_PropertyEx.m_groups[GROUP_INDEX_HOBJECT].subGroups[i].color,
					m_PropertyEx.m_groups[GROUP_INDEX_HOBJECT].subGroups[i].nLineWidth
				);
			}
		}
	}

	// HTuple
	for (int i = 0; i < this->m_HTuples.size(); i++)
	{
		if (m_HTuplesStatus[i] == 2)
		{
			ShowMsg(
				m_HTuples[i],
				qRgb(255, 0, 0),
				m_PropertyEx.m_groups[GROUP_INDEX_HTUPLE].subGroups[i].pt,
				m_PropertyEx.m_groups[GROUP_INDEX_HTUPLE].subGroups[i].nSize
			);
		}
		else
		{
			ShowMsg(
				m_HTuples[i],
				m_PropertyEx.m_groups[GROUP_INDEX_HTUPLE].subGroups[i].color,
				m_PropertyEx.m_groups[GROUP_INDEX_HTUPLE].subGroups[i].pt,
				m_PropertyEx.m_groups[GROUP_INDEX_HTUPLE].subGroups[i].nSize
			);
		}
	}


	// Dsiplay
	for (int i = 0; i < this->m_Dsiplays.size(); i++)
	{
		if (m_Dsiplays[i].IsInitialized())
		{
			ShowObj(
				m_Dsiplays[i],
				m_PropertyEx.m_groups[GROUP_INDEX_DISPLAY].subGroups[i].color,
				1
			);
		}
	}

	// String
	for (int i = 0; i < this->m_String.size(); i++)
	{
		if (!m_String[i].isEmpty())
		{
			ShowMsg(
				m_String[i].toStdString().c_str(),
				m_PropertyEx.m_groups[GROUP_INDEX_STRING].subGroups[i].color,
				m_PropertyEx.m_groups[GROUP_INDEX_STRING].subGroups[i].pt,
				m_PropertyEx.m_groups[GROUP_INDEX_STRING].subGroups[i].nSize
			);
		}
	}


	Refresh();

	if (m_PropertyEx.m_groups.size() <= GROUP_INDEX_SAVE)
	{
		return;
	}

	bool bEnSaveImage = m_PropertyEx.m_groups[GROUP_INDEX_SAVE].subGroups[0].bEnSaveImage;
	if (bEnSaveImage)
	{
		int nBufferSize = m_PropertyEx.m_groups[GROUP_INDEX_SAVE].subGroups[0].nBufferSize;
		if (m_SaveImages.size() < nBufferSize)
		{
			SAVE_IMG SaveImg;
			SaveImg.hoImage = m_Image;

			QHalconWindow* pHalconWindow = getHWndCtrl();
			if (pHalconWindow != nullptr)
			{
				SaveImg.hvWindow = pHalconWindow->getWindowID();
			}
			SaveImg.strFileName = m_strFileName;
			SaveImg.strFilePath = m_strFilePath;
			SaveImg.nExecuteState = m_nExecuteState;

			SaveImg.bEnSaveImage = m_PropertyEx.m_groups[GROUP_INDEX_SAVE].subGroups[0].bEnSaveImage;
			SaveImg.bEnSaveDumpWindow = m_PropertyEx.m_groups[GROUP_INDEX_SAVE].subGroups[0].bEnDumpWindow;
			SaveImg.bEnExecuteState = m_PropertyEx.m_groups[GROUP_INDEX_SAVE].subGroups[0].bEnExecuteState;

			SaveImg.nSaveMode = m_PropertyEx.m_groups[GROUP_INDEX_SAVE].subGroups[0].nSaveMode;
			SaveImg.nBufferSize = m_PropertyEx.m_groups[GROUP_INDEX_SAVE].subGroups[0].nBufferSize;
			SaveImg.nFreeTime = m_PropertyEx.m_groups[GROUP_INDEX_SAVE].subGroups[0].nFreeTime;

			m_SaveImages.push_back(SaveImg);
		}

	}
}


/// <summary>
/// 调整块属性数量（虚函数）
/// </summary>
/// <param name="fixCount"></param>
void VImageControl::updateExPropertyCount(const int fixCount, const QString& strPropName)
{
	// 获取属性的当前数量
	int curCount = this->getExPropertyCountByName(strPropName);
	// 子分组编号
	int curGroup = this->getGroupIDByName(strPropName);

	// 检查有效性
	if (curGroup < 0)
	{
		qDebug() << "[Error] VImageControl::updateExPropertyCount - nGroupID in invalid: " << curGroup;

		return;
	}

	// 如果需要增加
	if (fixCount > 0)
	{
		int nEnd = curCount + fixCount;

		for (int i = curCount; i < nEnd; i++)
		{
			PROPERTY_EX_SUBGROUP subItem;

			this->initSubGroup(subItem, i, curGroup);

			m_PropertyEx.m_groups[curGroup].subGroups.push_back(subItem);

		}
	}

	// 如果需要减少
	else if (fixCount < 0)
	{
		for (int i = 0; i < qAbs(fixCount); i++)
		{
			// 去掉对应的数据结构信息
			m_PropertyEx.m_groups[curGroup].subGroups.pop_back();

			//// TODO：如果实现了预览的话，这里需要实时去掉预览数值
			//if (groupID == HOBJECT_SUBGROUP_INDEX)
			//{
			//	m_HObjects.pop_back();
			//}
			//else if (groupID == HTUPLE_SUBGROUP_INDEX)
			//{

			//	m_HTuples.pop_back();
			//}
		}
	}


}


/// <summary>
/// 修改扩展属性（虚函数）
/// </summary>
/// <param name="strValueTitle"></param>
/// <param name="newValue"></param>
void VImageControl::changeExProperties(QString strValueTitle, const QVariant& newValue)
{
	// 获取修改属性项的索引值
	int nIndex = this->indexOfProperty(strValueTitle);

	// 如果改变了线宽
	if (strValueTitle.contains(IMAGE_PROPERTY_EX_LINEWIDTH_NAME))
	{
		// 刷新线宽
		this->updateLineWidth(newValue.toInt(), nIndex);
	}
	// 如果改变了图层颜色
	else if (strValueTitle.contains(IMAGE_PROPERTY_EX_HOBJECT_COLOR_NAME))
	{
		// 更新图层颜色
		this->updateHObjectColor(newValue.value<QColor>(), nIndex);
	}
	// 如果改变了文本颜色
	else if (strValueTitle.contains(IMAGE_PROPERTY_EX_HTUPLE_COLOR_NAME))
	{
		// 更新文本颜色
		this->updateHTupleColor(newValue.value<QColor>(), nIndex);
	}
	// 如果改变了显示颜色
	else if (strValueTitle.contains(IMAGE_PROPERTY_EX_DISPLAY_COLOR_NAME))
	{
		// 更新文本颜色
		this->updateDisplayColor(newValue.value<QColor>(), nIndex);
	}
	// 如果改变了字符颜色
	else if (strValueTitle.contains(IMAGE_PROPERTY_EX_STRING_COLOR_NAME))
	{
		// 更新字符颜色
		this->updateStringColor(newValue.value<QColor>(), nIndex);
	}
	// 如果改变了文本坐标
	else if (strValueTitle.contains(IMAGE_PROPERTY_EX_HTUPLE_PT_NAME))
	{
		// 更新文本颜色
		this->updateHTuplePt(newValue.toPoint(), nIndex);
	}
	// 如果改变了文本尺寸
	else if (strValueTitle.contains(IMAGE_PROPERTY_EX_HTUPLE_SIZE_NAME))
	{
		// 刷新线宽
		this->updateHTupleSize(newValue.toInt(), nIndex);
	}
	// 如果改变了字符坐标
	else if (strValueTitle.contains(IMAGE_PROPERTY_EX_STRING_PT_NAME))
	{
		// 更新字符颜色
		this->updateStringPt(newValue.toPoint(), nIndex);
	}
	// 如果改变了字符尺寸
	else if (strValueTitle.contains(IMAGE_PROPERTY_EX_STRING_SIZE_NAME))
	{
		// 刷新线宽
		this->updateStringSize(newValue.toInt(), nIndex);
	}
	// 如果改变 存图选项
	else if (strValueTitle.contains(IMAGE_PROPERTY_EX_SACVE_IMG_NAME))
	{
		// 刷新是否启用存图
		this->updateSaveImage(newValue.toBool());
	}
	// 如果改变了 转储选项
	else if (strValueTitle.contains(IMAGE_PROPERTY_EX_SAVE_DUMP_NAME))
	{
		// 刷新是否启用转储窗口
		this->updateDumpWindow(newValue.toBool());
	}
	// 如果改变了 转储选项
	else if (strValueTitle.contains(IMAGE_PROPERTY_EX_EXE_STATE_NAME))
	{
		// 刷新是否启用转储窗口
		this->updateExeState(newValue.toBool());
	}
	// 如果改变了 存储模式
	else if (strValueTitle.contains(IMAGE_PROPERTY_EX_SAVE_MODE_NAME))
	{
		// 刷新 存储模式
		this->updateSaveMode(newValue.toInt());
	}
	// 如果改变了缓冲区大小
	else if (strValueTitle.contains(IMAGE_PROPERTY_EX_BUFFER_SIZE_NAME))
	{
		// 刷新 缓冲区大小
		this->updateBufferSize(newValue.toInt());
	}
	// 如果改变了 空闲时间
	else if (strValueTitle.contains(IMAGE_PROPERTY_EX_FREE_TIME_NAME))
	{
		// 刷新 空闲时间
		this->updateFreeTime(newValue.toInt());
	}

	// 2022-2-10 此处数据链接也会触发到这里，但是数据链接不需要再这里更新
	else
	{
		qDebug() << "[Ignore]: VImageControl::changeExProperties - strValueTitle:" << strValueTitle;
	}
}


/// <summary>
/// 更新图像数据
/// </summary>
/// <param name="vars"></param>
void VImageControl::updateImageFromVariables(const RUNTIME_SYNC_VARS& sync_vars)
{
	try
	{
		// 按照数量重置一下数组空间
		if (m_PropertyEx.m_groups[GROUP_INDEX_HOBJECT].subGroups.size() != m_HObjects.size())
		{
			m_HObjects.clear();
			m_HObjects.resize(m_PropertyEx.m_groups[GROUP_INDEX_HOBJECT].subGroups.size());
		}

		if (m_PropertyEx.m_groups[GROUP_INDEX_HOBJECT].subGroups.size() != m_HObjectsStatus.size())
		{
			m_HObjectsStatus.clear();
			m_HObjectsStatus.resize(m_PropertyEx.m_groups[GROUP_INDEX_HOBJECT].subGroups.size());
		}

		if (m_PropertyEx.m_groups[GROUP_INDEX_HTUPLE].subGroups.size() != m_HTuples.size())
		{
			m_HTuples.clear();
			m_HTuples.resize(m_PropertyEx.m_groups[GROUP_INDEX_HTUPLE].subGroups.size());
		}

		if (m_PropertyEx.m_groups[GROUP_INDEX_HTUPLE].subGroups.size() != m_HTuplesStatus.size())
		{
			m_HTuplesStatus.clear();
			m_HTuplesStatus.resize(m_PropertyEx.m_groups[GROUP_INDEX_HTUPLE].subGroups.size());
		}

		if (m_PropertyEx.m_groups[GROUP_INDEX_DISPLAY].subGroups.size() != m_Dsiplays.size())
		{
			m_Dsiplays.clear();
			m_Dsiplays.resize(m_PropertyEx.m_groups[GROUP_INDEX_DISPLAY].subGroups.size());
		}

		if (m_PropertyEx.m_groups[GROUP_INDEX_STRING].subGroups.size() != m_String.size())
		{
			m_String.clear();
			m_String.resize(m_PropertyEx.m_groups[GROUP_INDEX_STRING].subGroups.size());
		}
		
		// 从连接中获取每一个数值执行更新
		for (const auto sync_var : sync_vars)
		{
			QString strPropName = sync_var.strPropertyName;
			// qDebug() << strPropName;

			// 图像链接
			if (strPropName == IMAGE_PROPERTY_EX_MAINLINK_NAME)
			{
				m_Image = *(HImage*)sync_var.pVariable->getValuePtr();
			}
			// HObject
			else if (strPropName.contains(IMAGE_PROPERTY_EX_LINK1_NAME))
			{
				HObject obj = *(HObject*)sync_var.pVariable->getValuePtr();
				int nIndex = strPropName.remove(IMAGE_PROPERTY_EX_LINK1_NAME).toInt() - 1;

				m_HObjects[nIndex] = obj;
			}
			// 图层状态
			else if (strPropName.contains(IMAGE_PROPERTY_EX_LINK2_NAME))
			{
				int nStatus = *(int*)sync_var.pVariable->getValuePtr();
				int nIndex = strPropName.remove(IMAGE_PROPERTY_EX_LINK2_NAME).toInt() - 1;

				m_HObjectsStatus[nIndex] = nStatus;
			}
			// HTuple
			else if (strPropName.contains(IMAGE_PROPERTY_EX_LINK3_NAME))
			{
				try
				{
					HTuple obj = *(HTuple*)sync_var.pVariable->getValuePtr();
					int nIndex = strPropName.remove(IMAGE_PROPERTY_EX_LINK3_NAME).toInt() - 1;

					m_HTuples[nIndex] = obj;
				}
				catch (...)
				{
					qWarning() << "updateImageFromVariables -----> add HTuple Error";
				}
			}
			// 文本状态
			else if (strPropName.contains(IMAGE_PROPERTY_EX_LINK4_NAME))
			{
				int nStatus = *(int*)sync_var.pVariable->getValuePtr();
				int nIndex = strPropName.remove(IMAGE_PROPERTY_EX_LINK4_NAME).toInt() - 1;

				m_HTuplesStatus[nIndex] = nStatus;
			}

			// Display
			else if (strPropName.contains(IMAGE_PROPERTY_EX_LINK5_NAME))
			{
				HObject obj = *(HObject*)sync_var.pVariable->getValuePtr();
				int nIndex = strPropName.remove(IMAGE_PROPERTY_EX_LINK5_NAME).toInt() - 1;

				m_Dsiplays[nIndex] = obj;
			}

			// String
			else if (strPropName.contains(IMAGE_PROPERTY_EX_LINK6_NAME))
			{
				QString str = sync_var.pVariable->getValueString();
				int nIndex = strPropName.remove(IMAGE_PROPERTY_EX_LINK6_NAME).toInt() - 1;

				m_String[nIndex] = str;
			}

			// FileName
			else if (strPropName.contains(IMAGE_PROPERTY_EX_LINK7_NAME))
			{
				m_strFileName = *(QString*)sync_var.pVariable->getValuePtr();
			}

			// FIlePath
			else if (strPropName.contains(IMAGE_PROPERTY_EX_LINK8_NAME))
			{
				m_strFilePath = *(QString*)sync_var.pVariable->getValuePtr();
			}

			// 执行状态
			else if (strPropName.contains(IMAGE_PROPERTY_EX_LINK9_NAME))
			{
				m_nExecuteState = *(int*)sync_var.pVariable->getValuePtr();
			}

		}

		// 更新完后，刷新图像
		this->redraw();


	}
	catch (...)
	{
		qWarning() << "updateImageFromVariables Error";
	}

}


/// <summary>
/// 更新图层线宽
/// </summary>
/// <param name="lineWidth"></param>
/// <param name="index"></param>
void VImageControl::updateLineWidth(const int lineWidth, const int index)
{
	int& nWidth = m_PropertyEx.m_groups[GROUP_INDEX_HOBJECT].subGroups[index].nLineWidth;

	if (nWidth != lineWidth)
	{
		nWidth = lineWidth;

		// TODO：刷新预览

	}

	qDebug() << "VImageControl::updateLineWidth - update ["
		<< m_PropertyEx.m_groups[GROUP_INDEX_HOBJECT].subGroups[index].strLineWidthName
		<< "] to [" << lineWidth << "]";

}


/// <summary>
/// 更新图层颜色
/// </summary>
/// <param name="newColor"></param>
/// <param name="index"></param>
void VImageControl::updateHObjectColor(const QColor newColor, const int index)
{
	QColor& color = m_PropertyEx.m_groups[GROUP_INDEX_HOBJECT].subGroups[index].color;

	if (color != newColor)
	{
		color = newColor;

		// TODO：刷新预览

	}

	qDebug() << "VImageControl::updateHObjectColor - update ["
		<< m_PropertyEx.m_groups[GROUP_INDEX_HOBJECT].subGroups[index].strColorName
		<< "] to [" << newColor << "]";
}


/// <summary>
/// 更新文本颜色
/// </summary>
/// <param name="newColor"></param>
/// <param name="index"></param>
void VImageControl::updateHTupleColor(const QColor newColor, const int index)
{
	QColor& color = m_PropertyEx.m_groups[GROUP_INDEX_HTUPLE].subGroups[index].color;

	if (color != newColor)
	{
		color = newColor;

		// TODO：刷新预览

	}

	qDebug() << "VImageControl::updateHTupleColor - update ["
		<< m_PropertyEx.m_groups[GROUP_INDEX_HTUPLE].subGroups[index].strColorName
		<< "] to [" << newColor << "]";
}


/// <summary>
/// 更新显示颜色
/// </summary>
/// <param name="newColor"></param>
/// <param name="index"></param>
void VImageControl::updateDisplayColor(const QColor newColor, const int index)
{
	QColor& color = m_PropertyEx.m_groups[GROUP_INDEX_DISPLAY].subGroups[index].color;

	if (color != newColor)
	{
		color = newColor;

		// TODO：刷新预览

	}

	qDebug() << "VImageControl::updateHObjectColor - update ["
		<< m_PropertyEx.m_groups[GROUP_INDEX_DISPLAY].subGroups[index].strColorName
		<< "] to [" << newColor << "]";
}


/// <summary>
/// 更新文本颜色
/// </summary>
/// <param name="newColor"></param>
/// <param name="index"></param>
void VImageControl::updateStringColor(const QColor newColor, const int index)
{
	QColor& color = m_PropertyEx.m_groups[GROUP_INDEX_STRING].subGroups[index].color;

	if (color != newColor)
	{
		color = newColor;

		// TODO：刷新预览

	}

	qDebug() << "VImageControl::updateStringColor - update ["
		<< m_PropertyEx.m_groups[GROUP_INDEX_STRING].subGroups[index].strColorName
		<< "] to [" << newColor << "]";
}


/// <summary>
/// 更新文本坐标
/// </summary>
/// <param name="pt"></param>
/// <param name="index"></param>
void VImageControl::updateHTuplePt(const QPoint newPt, const int index)
{
	QPoint& pt = m_PropertyEx.m_groups[GROUP_INDEX_HTUPLE].subGroups[index].pt;

	if (pt != newPt)
	{
		pt = newPt;

		// TODO：刷新预览

	}

	qDebug() << "VImageControl::updateHTuplePt - update ["
		<< m_PropertyEx.m_groups[GROUP_INDEX_HTUPLE].subGroups[index].strPtName
		<< "] to [" << newPt << "]";
}


/// <summary>
/// 更新文本尺寸
/// </summary>
/// <param name="size"></param>
/// <param name="index"></param>
void VImageControl::updateHTupleSize(const int newSize, const int index)
{
	int& size = m_PropertyEx.m_groups[GROUP_INDEX_HTUPLE].subGroups[index].nSize;

	if (size != newSize)
	{
		size = newSize;

		// TODO：刷新预览

	}

	qDebug() << "VImageControl::updateHTuplePt - update ["
		<< m_PropertyEx.m_groups[GROUP_INDEX_HTUPLE].subGroups[index].nSize
		<< "] to [" << newSize << "]";
}


/// <summary>
/// 更新在字符坐标
/// </summary>
/// <param name="pt"></param>
/// <param name="index"></param>
void VImageControl::updateStringPt(const QPoint newPt, const int index)
{
	QPoint& pt = m_PropertyEx.m_groups[GROUP_INDEX_STRING].subGroups[index].pt;

	if (pt != newPt)
	{
		pt = newPt;

		// TODO：刷新预览

	}

	qDebug() << "VImageControl::updateStringPt - update ["
		<< m_PropertyEx.m_groups[GROUP_INDEX_HTUPLE].subGroups[index].strPtName
		<< "] to [" << newPt << "]";
}


/// <summary>
/// 更新字符尺寸
/// </summary>
/// <param name="size"></param>
/// <param name="index"></param>
void VImageControl::updateStringSize(const int newSize, const int index)
{
	int& size = m_PropertyEx.m_groups[GROUP_INDEX_STRING].subGroups[index].nSize;

	if (size != newSize)
	{
		size = newSize;

		// TODO：刷新预览

	}

	qDebug() << "VImageControl::updateStringPt - update ["
		<< m_PropertyEx.m_groups[GROUP_INDEX_HTUPLE].subGroups[index].nSize
		<< "] to [" << newSize << "]";
}


/// <summary>
/// 更新是否存图
/// </summary>
/// <param name="bEnable"></param>
void VImageControl::updateSaveImage(const bool bNewEnable)
{
	bool& bEn = m_PropertyEx.m_groups[GROUP_INDEX_SAVE].subGroups[0].bEnSaveImage;

	if (bEn != bNewEnable)
	{
		bEn = bNewEnable;

		// TODO：刷新预览

	}
}


/// <summary>
/// 更新是否转储窗口
/// </summary>
/// <param name="bEnable"></param>
void VImageControl::updateDumpWindow(const bool bNewEnable)
{
	bool& bEn = m_PropertyEx.m_groups[GROUP_INDEX_SAVE].subGroups[0].bEnDumpWindow;

	if (bEn != bNewEnable)
	{
		bEn = bNewEnable;

		// TODO：刷新预览

	}
}


/// <summary>
/// 更新是否转储窗口
/// </summary>
/// <param name="bEnable"></param>
void VImageControl::updateExeState(const bool bNewEnable)
{
	bool& bEn = m_PropertyEx.m_groups[GROUP_INDEX_SAVE].subGroups[0].bEnExecuteState;

	if (bEn != bNewEnable)
	{
		bEn = bNewEnable;

		// TODO：刷新预览

	}
}


/// <summary>
/// 更新存储模式
/// </summary>
/// <param name="nMode"></param>
void VImageControl::updateSaveMode(const int nNewValue)
{
	int& nValue = m_PropertyEx.m_groups[GROUP_INDEX_SAVE].subGroups[0].nSaveMode;

	if (nValue != nNewValue)
	{
		nValue = nNewValue;

		// TODO：刷新预览

	}
}


/// <summary>
/// 更新 缓冲区大小
/// </summary>
/// <param name="nMode"></param>
void VImageControl::updateBufferSize(const int nNewValue)
{
	int& nValue = m_PropertyEx.m_groups[GROUP_INDEX_SAVE].subGroups[0].nBufferSize;

	if (nValue != nNewValue)
	{
		nValue = nNewValue;

		// TODO：刷新预览

	};
}


/// <summary>
/// 更新空闲时间
/// </summary>
/// <param name="nMode"></param>
void VImageControl::updateFreeTime(const int nNewValue)
{
	int& nValue = m_PropertyEx.m_groups[GROUP_INDEX_SAVE].subGroups[0].nFreeTime;

	if (nValue != nNewValue)
	{
		nValue = nNewValue;

		// TODO：刷新预览

	};
}


/// <summary>
/// 启动 存储线程
/// </summary>
void VImageControl::startSaveThread()
{
	m_nThreadState = 1;

	// 启动线程
	m_SaveThreadPool.start(
		new _SaveThread(this)
	);
}



//============================================================
//
//					Save 线程
//
//============================================================

/// <summary>
/// 线程函数
/// </summary>
void _SaveThread::run()
{
	// 调用函数执行任务
	while (m_pImageControl->m_nThreadState)
	{

		if (m_pImageControl->m_SaveImages.size() > 0)
		{
			SAVE_IMG SaveImage = m_pImageControl->m_SaveImages[0];

			QString strProjectPath = thePrefs.m_strProjectPath;
			QString strImagePath = strProjectPath + "//Image";
			// TODO: 在此处根据不同的模式，生成对应的路径（此处不管本地有没有改路径的文件夹，但是需要确保路径是合法的）
			// TODO: 如无特别情况，图像日志都会生成在工程目录下
			if (SaveImage.bEnSaveDumpWindow)
			{
				try
				{
					DumpWindowImage(&SaveImage.hoDumpWindow, SaveImage.hvWindow);
				}
				catch (...) {}
			}

			switch (SaveImage.nSaveMode)
			{
			case 0:// 序号模式 （0001 - 999 的自增序号）
			{
				qDebug() << SaveImage.bEnSaveImage;
				qDebug() << SaveImage.bEnSaveDumpWindow;
				qDebug() << SaveImage.bEnExecuteState;

				qDebug() << SaveImage.nSaveMode;
				qDebug() << SaveImage.nBufferSize;
				qDebug() << SaveImage.nFreeTime;

			}
			break;
			case 1:// 日期模式
			{

			}
			break;
			case 2:// 链接模式（根据链接进来的文本，生成路径）
			{

			}
			break;
			default:
				break;
			}

			// TODO:在此根据上面生成的合法路径，去写文件。写文件的过程中，如果发现目录不存在，需要创建改目录

			qDebug() << "Save Image ok  FilePath: " << strImagePath;

			Utility::qSleep(SaveImage.nFreeTime);
			m_pImageControl->m_SaveImages.remove(0);
		}
		else
		{
			Utility::qSleep(1000);
		}

	}
	return;
}