nmWTAI-Platform/Src/nmNum/nmPlot/nmPlotGraphicBinder.cpp

#include "nmPlotGraphicBinder.h"

#include "nmObjLineFault.h"
#include "nmDataFault.h"
#include "nmObjLineCrack.h"
#include "nmDataFracture.h"
#include "nmDataAnalyzeManager.h"

#include <QMetaObject>

nmPlotGraphicBinder::nmPlotGraphicBinder(nmDataAnalyzeManager* pDataMgr, QObject* parent)
	: QObject(parent)
	, m_pDataMgr(pDataMgr)
{
}

// 用户画完断层后：创建数据对象并建立绑定
void nmPlotGraphicBinder::createFaultForGraphic(nmObjLineFault* pGraphic)
{
	if (!pGraphic || !m_pDataMgr) {
		return;
	}

	// 创建数据对象
	nmDataFault* pData = m_pDataMgr->createFault();

	// 将图元值推入数据
	pData->setFaultName(pGraphic->getName());
	pData->setFaultPoints(pGraphic->getAllValues());

	// 建立信号连接
	_connectFault(pGraphic, pData);

	m_pDataMgr->notifyDataChanged();
}

// 从文件加载：绑定已有数据到已有图元
void nmPlotGraphicBinder::bindFaultToGraphic(nmObjLineFault* pGraphic, nmDataFault* pData)
{
	if (!pGraphic || !pData) {
		return;
	}

	// 将数据值推到图元
	_pushFaultDataToGraphic(pGraphic, pData);

	// 建立信号连接
	_connectFault(pGraphic, pData);
}

// 删除图元：断开连接并移除数据
void nmPlotGraphicBinder::removeFaultBinding(nmObjLineFault* pGraphic)
{
	if (!pGraphic) {
		return;
	}

	// 断开信号
	_disconnectFault(pGraphic);

	// 从数据中心移除
	if (m_mapFaultData.contains(pGraphic)) {
		nmDataFault* pData = m_mapFaultData.value(pGraphic);
		if (pData && m_pDataMgr) {
			m_pDataMgr->removeFaultData(pData);
		}
		m_mapFaultData.remove(pGraphic);
	}
}

nmDataFault* nmPlotGraphicBinder::getFaultDataFor(nmObjLineFault* pGraphic)
{
	return m_mapFaultData.value(pGraphic, nullptr);
}

// 名称同步：检测图元名称与数据名称是否一致，不一致则同步
void nmPlotGraphicBinder::syncFaultName(nmObjLineFault* pGraphic)
{
	if (!pGraphic) return;
	nmDataFault* pData = m_mapFaultData.value(pGraphic, nullptr);
	if (pData && pData->getFaultName() != pGraphic->getName()) {
		pData->setFaultName(pGraphic->getName());
	}
}

// 切换分析时更新绑定的 DataManager
// 旧图元已由 deleteAllPlotObjs 清除，清理残留映射避免悬空指针
void nmPlotGraphicBinder::updateDataMgr(nmDataAnalyzeManager* pDataMgr)
{
	m_mapFaultData.clear();
	m_setBoundGraphics.clear();
	m_mapCrackData.clear();
	m_setBoundCrackGraphics.clear();
	m_pDataMgr = pDataMgr;
}

// 将数据值推到图元本地副本
void nmPlotGraphicBinder::_pushFaultDataToGraphic(nmObjLineFault* pGraphic, nmDataFault* pData)
{
	// 阻断信号，防止推送中触发反向同步
	pGraphic->blockSignals(true);

	pGraphic->setName(pData->getFaultName());

	int flowModel = (pData->getFaultFlowModel().getValue() == tr("Leaky")) ? 0 : 1;
	pGraphic->setFaultFlowModel(flowModel);

	pGraphic->setFaultLeakage(pData->getFaultLeakage().getValue().toDouble());

	pGraphic->blockSignals(false);
}

// 建立图元与数据的双向信号连接
void nmPlotGraphicBinder::_connectFault(nmObjLineFault* pGraphic, nmDataFault* pData)
{
	QObject::connect(pGraphic, SIGNAL(sigFlowModelChanged(int)),
	                 this,     SLOT(onGraphicFlowModelChanged(int)));

	QObject::connect(pGraphic, SIGNAL(sigLeakageChanged(double)),
	                 this,     SLOT(onGraphicLeakageChanged(double)));

	QObject::connect(pGraphic, SIGNAL(sigPointsChanged()),
	                 this,     SLOT(onGraphicPointsChanged()));

	QObject::connect(pGraphic, SIGNAL(sigObjVisibleChanged(bool)),
	                 this,     SLOT(onGraphicVisibleChanged(bool)));

	m_mapFaultData[pGraphic] = pData;

	m_setBoundGraphics.insert(pGraphic);

	pGraphic->setGraphicBinder(this);
}

// 断开图元与本 Binder 的所有信号连接
void nmPlotGraphicBinder::_disconnectFault(nmObjLineFault* pGraphic)
{
	QObject::disconnect(pGraphic, SIGNAL(sigFlowModelChanged(int)),
	                    this,     SLOT(onGraphicFlowModelChanged(int)));

	QObject::disconnect(pGraphic, SIGNAL(sigLeakageChanged(double)),
	                    this,     SLOT(onGraphicLeakageChanged(double)));

	QObject::disconnect(pGraphic, SIGNAL(sigPointsChanged()),
	                    this,     SLOT(onGraphicPointsChanged()));

	QObject::disconnect(pGraphic, SIGNAL(sigObjVisibleChanged(bool)),
	                    this,     SLOT(onGraphicVisibleChanged(bool)));

	m_setBoundGraphics.remove(pGraphic);
}

// 图元属性变更 → 同步到数据

// 流动模型变更
void nmPlotGraphicBinder::onGraphicFlowModelChanged(int model)
{
	nmObjLineFault* pGraphic = qobject_cast<nmObjLineFault*>(sender());
	if (!pGraphic) return;

	nmDataFault* pData = m_mapFaultData.value(pGraphic, nullptr);
	if (!pData) return;

	nmDataAttribute attr = pData->getFaultFlowModel();
	attr.setValue(model == 0 ? tr("Leaky") : tr("Composite Limit"));
	pData->setFaultFlowModel(attr);
}

// 渗漏率变更
void nmPlotGraphicBinder::onGraphicLeakageChanged(double leakage)
{
	nmObjLineFault* pGraphic = qobject_cast<nmObjLineFault*>(sender());
	if (!pGraphic) return;

	nmDataFault* pData = m_mapFaultData.value(pGraphic, nullptr);
	if (!pData) return;

	nmDataAttribute attr = pData->getFaultLeakage();
	attr.setValue(leakage);
	pData->setFaultLeakage(attr);
}

// 点坐标变更
void nmPlotGraphicBinder::onGraphicPointsChanged()
{
	nmObjLineFault* pGraphic = qobject_cast<nmObjLineFault*>(sender());
	if (!pGraphic) return;

	nmDataFault* pData = m_mapFaultData.value(pGraphic, nullptr);
	if (!pData) return;

	pData->setFaultPoints(pGraphic->getAllValues());
	pData->setFaultName(pGraphic->getName());

	if (m_pDataMgr) {
		m_pDataMgr->notifyDataChanged();
	}
}

// 可见性变更
void nmPlotGraphicBinder::onGraphicVisibleChanged(bool bVisible)
{
	nmObjLineFault* pGraphic = qobject_cast<nmObjLineFault*>(sender());
	if (!pGraphic) return;

	nmDataFault* pData = m_mapFaultData.value(pGraphic, nullptr);
	if (!pData) return;

	pData->setPlotVisible(bVisible);
}

// 数据变更（预留）
void nmPlotGraphicBinder::onDataChanged()
{
}

// ============ 裂缝绑定 ============

// 用户画完裂缝后：创建数据对象并建立绑定
void nmPlotGraphicBinder::createCrackForGraphic(nmObjLineCrack* pGraphic)
{
	if (!pGraphic || !m_pDataMgr) {
		return;
	}

	// 创建数据对象
	nmDataFracture* pData = m_pDataMgr->createFracture();

	// 将图元值推入数据
	pData->setFractureName(pGraphic->getName());
	pData->setFracturePoints(pGraphic->getAllValues());

	// 建立信号连接
	_connectCrack(pGraphic, pData);

	m_pDataMgr->notifyDataChanged();
}

// 从文件加载：绑定已有裂缝数据到已有图元
void nmPlotGraphicBinder::bindCrackToGraphic(nmObjLineCrack* pGraphic, nmDataFracture* pData)
{
	if (!pGraphic || !pData) {
		return;
	}

	// 将数据值推到图元
	_pushCrackDataToGraphic(pGraphic, pData);

	// 建立信号连接
	_connectCrack(pGraphic, pData);
}

// 删除裂缝图元：断开连接并移除数据
void nmPlotGraphicBinder::removeCrackBinding(nmObjLineCrack* pGraphic)
{
	if (!pGraphic) {
		return;
	}

	// 断开信号
	_disconnectCrack(pGraphic);

	// 从数据中心移除
	if (m_mapCrackData.contains(pGraphic)) {
		nmDataFracture* pData = m_mapCrackData.value(pGraphic);
		if (pData && m_pDataMgr) {
			m_pDataMgr->removeFractureData(pData);
		}
		m_mapCrackData.remove(pGraphic);
	}
}

nmDataFracture* nmPlotGraphicBinder::getCrackDataFor(nmObjLineCrack* pGraphic)
{
	return m_mapCrackData.value(pGraphic, nullptr);
}

// 名称同步：检测图元名称与数据名称是否一致，不一致则同步
void nmPlotGraphicBinder::syncCrackName(nmObjLineCrack* pGraphic)
{
	if (!pGraphic) return;
	nmDataFracture* pData = m_mapCrackData.value(pGraphic, nullptr);
	if (pData && pData->getFractureName() != pGraphic->getName()) {
		pData->setFractureName(pGraphic->getName());
	}
}

// 将裂缝数据值推到图元本地副本
void nmPlotGraphicBinder::_pushCrackDataToGraphic(nmObjLineCrack* pGraphic, nmDataFracture* pData)
{
	// 阻断信号，防止推送中触发反向同步
	pGraphic->blockSignals(true);

	pGraphic->setName(pData->getFractureName());

	int flowModel = (pData->getFractureFlowModel().getValue() == tr("Infinite Conductivity")) ? 0 : 1;
	pGraphic->setCrackFlowModel(flowModel);

	pGraphic->setCrackDfc(pData->getFractureDfc().getValue().toDouble());
	pGraphic->setCrackDw(pData->getFractureDw().getValue().toDouble());

	pGraphic->blockSignals(false);
}

// 建立裂缝图元与数据的双向信号连接
void nmPlotGraphicBinder::_connectCrack(nmObjLineCrack* pGraphic, nmDataFracture* pData)
{
	QObject::connect(pGraphic, SIGNAL(sigFlowModelChanged(int)),
	                 this,     SLOT(onGraphicCrackFlowModelChanged(int)));

	QObject::connect(pGraphic, SIGNAL(sigDfcChanged(double)),
	                 this,     SLOT(onGraphicCrackDfcChanged(double)));

	QObject::connect(pGraphic, SIGNAL(sigDwChanged(double)),
	                 this,     SLOT(onGraphicCrackDwChanged(double)));

	QObject::connect(pGraphic, SIGNAL(sigPointsChanged()),
	                 this,     SLOT(onGraphicCrackPointsChanged()));

	QObject::connect(pGraphic, SIGNAL(sigObjVisibleChanged(bool)),
	                 this,     SLOT(onGraphicCrackVisibleChanged(bool)));

	m_mapCrackData[pGraphic] = pData;

	m_setBoundCrackGraphics.insert(pGraphic);

	pGraphic->setGraphicBinder(this);
}

// 断开裂缝图元与本 Binder 的所有信号连接
void nmPlotGraphicBinder::_disconnectCrack(nmObjLineCrack* pGraphic)
{
	QObject::disconnect(pGraphic, SIGNAL(sigFlowModelChanged(int)),
	                    this,     SLOT(onGraphicCrackFlowModelChanged(int)));

	QObject::disconnect(pGraphic, SIGNAL(sigDfcChanged(double)),
	                    this,     SLOT(onGraphicCrackDfcChanged(double)));

	QObject::disconnect(pGraphic, SIGNAL(sigDwChanged(double)),
	                    this,     SLOT(onGraphicCrackDwChanged(double)));

	QObject::disconnect(pGraphic, SIGNAL(sigPointsChanged()),
	                    this,     SLOT(onGraphicCrackPointsChanged()));

	QObject::disconnect(pGraphic, SIGNAL(sigObjVisibleChanged(bool)),
	                    this,     SLOT(onGraphicCrackVisibleChanged(bool)));

	m_setBoundCrackGraphics.remove(pGraphic);
}

// 裂缝流动模型变更
void nmPlotGraphicBinder::onGraphicCrackFlowModelChanged(int model)
{
	nmObjLineCrack* pGraphic = qobject_cast<nmObjLineCrack*>(sender());
	if (!pGraphic) return;

	nmDataFracture* pData = m_mapCrackData.value(pGraphic, nullptr);
	if (!pData) return;

	nmDataAttribute attr = pData->getFractureFlowModel();
	attr.setValue(model == 0 ? tr("Infinite Conductivity") : tr("Finite Conductivity"));
	pData->setFractureFlowModel(attr);
}

// 裂缝导流能力变更
void nmPlotGraphicBinder::onGraphicCrackDfcChanged(double dfc)
{
	nmObjLineCrack* pGraphic = qobject_cast<nmObjLineCrack*>(sender());
	if (!pGraphic) return;

	nmDataFracture* pData = m_mapCrackData.value(pGraphic, nullptr);
	if (!pData) return;

	nmDataAttribute attr = pData->getFractureDfc();
	attr.setValue(dfc);
	pData->setFractureDfc(attr);
}

// 裂缝储能比变更
void nmPlotGraphicBinder::onGraphicCrackDwChanged(double dw)
{
	nmObjLineCrack* pGraphic = qobject_cast<nmObjLineCrack*>(sender());
	if (!pGraphic) return;

	nmDataFracture* pData = m_mapCrackData.value(pGraphic, nullptr);
	if (!pData) return;

	nmDataAttribute attr = pData->getFractureDw();
	attr.setValue(dw);
	pData->setFractureDw(attr);
}

// 裂缝点坐标变更
void nmPlotGraphicBinder::onGraphicCrackPointsChanged()
{
	nmObjLineCrack* pGraphic = qobject_cast<nmObjLineCrack*>(sender());
	if (!pGraphic) return;

	nmDataFracture* pData = m_mapCrackData.value(pGraphic, nullptr);
	if (!pData) return;

	pData->setFracturePoints(pGraphic->getAllValues());
	pData->setFractureName(pGraphic->getName());

	if (m_pDataMgr) {
		m_pDataMgr->notifyDataChanged();
	}
}

// 裂缝可见性变更
void nmPlotGraphicBinder::onGraphicCrackVisibleChanged(bool bVisible)
{
	nmObjLineCrack* pGraphic = qobject_cast<nmObjLineCrack*>(sender());
	if (!pGraphic) return;

	nmDataFracture* pData = m_mapCrackData.value(pGraphic, nullptr);
	if (!pData) return;

	pData->setPlotVisible(bVisible);
}