OTS/OTS_GB/OTSInterface/OTSImgScanPrmClr.cpp

#include "stdafx.h"
#include "OTSImgScanPrmClr.h"

namespace OTSINTERFACE {

	COTSImgScanPrmClr::COTSImgScanPrmClr()
	{
		m_LpScanParam = new COTSImageScanParamPtr(new COTSImageScanParam());
	}

	COTSImgScanPrmClr::COTSImgScanPrmClr(COTSImageScanParam* a_pScanParam)				// copy constructor
	{
		ASSERT(a_pScanParam);
		if (!a_pScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSImgScanPrmClr: Generate ImgScanParam pointer failed."));
			return;
		}

		m_LpScanParam = new COTSImageScanParamPtr(new COTSImageScanParam(a_pScanParam));
	}

	COTSImgScanPrmClr::COTSImgScanPrmClr(COTSImageScanParamPtr a_pScanParam)					// copy constructor
	{
		ASSERT(a_pScanParam);
		if (!a_pScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSImgScanPrmClr: invalid pointer"));
			return;
		}
		
			m_LpScanParam = new COTSImageScanParamPtr(a_pScanParam);
		

	}

	COTSImageScanParamPtr COTSImgScanPrmClr::GetImgScanPrmPtr()
	{
		return *m_LpScanParam;
	}

	COTSImgScanPrmClr::!COTSImgScanPrmClr()
	{
		if (m_LpScanParam != nullptr)
		{
			delete m_LpScanParam;
			m_LpScanParam = nullptr;
		}
	}
	COTSImgScanPrmClr::~COTSImgScanPrmClr()
	{
		if (m_LpScanParam != nullptr)
		{
			delete m_LpScanParam;
			m_LpScanParam = nullptr;
		}
	}

	int COTSImgScanPrmClr::GetStopMode()
	{
		return (int)m_LpScanParam->get()->GetStopMode();
	}

	void COTSImgScanPrmClr::SetStopMode(int a_nStopMode)
	{
		m_LpScanParam->get()->SetStopMode((OTS_MEASURE_STOP_MODE)a_nStopMode);
	}

	bool COTSImgScanPrmClr::GetShowStopMode()
	{
		if (m_LpScanParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowStopMode: invalid pointer"));
			return false;
		}
		COTSImageScanParamPtr pImgScanParam = GetImgScanPrmPtr();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowStopMode: invalid pointer"));
			return false;
		}
		bool ImgScanParam = pImgScanParam->GetShowStopMode();
		return ImgScanParam;
	}
	void COTSImgScanPrmClr::SetShowStopMode(bool a_bShowStopMode)
	{
		if (m_LpScanParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowStopMode: invalid pointer"));
			return;
		}
		COTSImageScanParamPtr pImgScanParam = GetImgScanPrmPtr();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowStopMode: invalid pointer"));
			return;
		}
		pImgScanParam->SetShowStopMode(a_bShowStopMode);
	}

	int COTSImgScanPrmClr::GetStopParamMeasTime()
	{
		if (m_LpScanParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetStopParamMeasTime: invalid pointer"));
			return -1;
		}
		COTSImageScanParamPtr pImgScanParam = GetImgScanPrmPtr();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetStopParamMeasTime: invalid pointer"));
			return -1;
		}
		int ImgScanParam = pImgScanParam->GetStopParamMeasTime();
		return ImgScanParam;
	}

	void COTSImgScanPrmClr::SetStopParamMeasTime(int a_nStopParamMeasTime)
	{
		if (m_LpScanParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetStopParamMeasTime: invalid pointer"));
			return;
		}
		COTSImageScanParamPtr pImgScanParam = GetImgScanPrmPtr();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetStopParamMeasTime: invalid pointer"));
			return;
		}
		pImgScanParam->SetStopParamMeasTime(a_nStopParamMeasTime);
	}

	bool COTSImgScanPrmClr::GetShowMeasTime()
	{
		if (m_LpScanParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowStopMode: invalid pointer"));
			return false;
		}
		COTSImageScanParamPtr pImgScanParam = GetImgScanPrmPtr();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowStopMode: invalid pointer"));
			return false;
		}
		bool ImgScanParam = pImgScanParam->GetShowMeasTime();
		return ImgScanParam;
	}
	void COTSImgScanPrmClr::SetShowMeasTime(bool a_bShowMeasTime)
	{
		if (m_LpScanParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowMeasTime: invalid pointer"));
			return;
		}
		COTSImageScanParamPtr pImgScanParam = GetImgScanPrmPtr();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowMeasTime: invalid pointer"));
			return;
		}
		pImgScanParam->SetShowMeasTime(a_bShowMeasTime);
	}

	int COTSImgScanPrmClr::GetStopParamFields()
	{
		if (m_LpScanParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetStopParamFields: invalid pointer"));
			return -1;
		}
		COTSImageScanParamPtr pImgScanParam = GetImgScanPrmPtr();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetStopParamFields: invalid pointer"));
			return -1;
		}
		int ImgScanParam = pImgScanParam->GetStopParamFields();
		return ImgScanParam;
	}

	void COTSImgScanPrmClr::SetStopParamFields(int a_nStopParamFields)
	{
		if (m_LpScanParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetStopParamFields: invalid pointer"));
			return;
		}
		COTSImageScanParamPtr pImgScanParam = GetImgScanPrmPtr();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetStopParamFields: invalid pointer"));
			return;
		}
		pImgScanParam->SetStopParamFields(a_nStopParamFields);
	}

	bool COTSImgScanPrmClr::GetShowParamFields()
	{
		if (m_LpScanParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowParamFields: invalid pointer"));
			return false;
		}
		COTSImageScanParamPtr pImgScanParam = GetImgScanPrmPtr();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowParamFields: invalid pointer"));
			return false;
		}
		bool ImgScanParam = pImgScanParam->GetShowParamFields();
		return ImgScanParam;
	}
	void COTSImgScanPrmClr::SetShowParamFields(bool a_bValue)
	{
		if (m_LpScanParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowParamFields: invalid pointer"));
			return;
		}
		COTSImageScanParamPtr pImgScanParam = GetImgScanPrmPtr();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowParamFields: invalid pointer"));
			return;
		}
		pImgScanParam->SetShowParamFields(a_bValue);
	}

	int COTSImgScanPrmClr::GetStopParamParticles()
	{
		if (m_LpScanParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetStopParamParticles: invalid pointer"));
			return -1;
		}
		COTSImageScanParamPtr pImgScanParam = GetImgScanPrmPtr();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetStopParamParticles: invalid pointer"));
			return -1;
		}
		int ImgScanParam = pImgScanParam->GetStopParamParticles();
		return ImgScanParam;
	}

	void COTSImgScanPrmClr::SetStopParamParticles(int a_nStopParamParticles)
	{
		if (m_LpScanParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetStopParamParticles: invalid pointer"));
			return;
		}
		COTSImageScanParamPtr pImgScanParam = GetImgScanPrmPtr();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetStopParamParticles: invalid pointer"));
			return;
		}
		pImgScanParam->SetStopParamParticles(a_nStopParamParticles);
	}

	bool COTSImgScanPrmClr::GetShowParticles()
	{
		if (m_LpScanParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowParticles: invalid pointer"));
			return false;
		}
		COTSImageScanParamPtr pImgScanParam = GetImgScanPrmPtr();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowParticles: invalid pointer"));
			return false;
		}
		bool ImgScanParam = pImgScanParam->GetShowParticles();
		return ImgScanParam;
	}
	void COTSImgScanPrmClr::SetShowParticles(bool a_bValue)
	{
		if (m_LpScanParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowParticles: invalid pointer"));
			return;
		}
		COTSImageScanParamPtr pImgScanParam = GetImgScanPrmPtr();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowParticles: invalid pointer"));
			return;
		}
		pImgScanParam->SetShowParticles(a_bValue);
	}

	int COTSImgScanPrmClr::GetStartImageMode()
	{
		return (int)m_LpScanParam->get()->GetStartImageMode();
	}

	void COTSImgScanPrmClr::SetStartImageMode(int a_nSatrtImageMode)
	{
		m_LpScanParam->get()->SetStartImageMode((OTS_GET_IMAGE_MODE)a_nSatrtImageMode);
	}

	bool COTSImgScanPrmClr::GetShowStartImageMode()
	{
		if (m_LpScanParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowStartImageMode: invalid pointer"));
			return false;
		}
		COTSImageScanParamPtr pImgScanParam = GetImgScanPrmPtr();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowStartImageMode: invalid pointer"));
			return false;
		}
		bool ImgScanParam = pImgScanParam->GetShowStartImageMode();
		return ImgScanParam;
	}
	void COTSImgScanPrmClr::SetShowStartImageMode(bool a_bValue)
	{
		if (m_LpScanParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowStaa_bValuertImageMode: invalid pointer"));
			return;
		}
		COTSImageScanParamPtr pImgScanParam = GetImgScanPrmPtr();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowStartImageMode: invalid pointer"));
			return;
		}
		pImgScanParam->SetShowStartImageMode(a_bValue);
	}

	int COTSImgScanPrmClr::GetImagePixelSize()
	{
		return (int)m_LpScanParam->get()->GetImagePixelSize();
	}

	void COTSImgScanPrmClr::SetImagePixelSize(int a_nImagePixelSize)
	{
		m_LpScanParam->get()->SetImagePixelSize((OTS_FIVE_TIES_OPTIONS)a_nImagePixelSize);
	}

	bool COTSImgScanPrmClr::GetShowPixelSize()
	{
		if (m_LpScanParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowPixelSize: invalid pointer"));
			return false;
		}
		COTSImageScanParamPtr pImgScanParam = GetImgScanPrmPtr();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowPixelSize: invalid pointer"));
			return false;
		}
		bool ImgScanParam = pImgScanParam->GetShowPixelSize();
		return ImgScanParam;
	}
	void COTSImgScanPrmClr::SetShowPixelSize(bool a_bValue)
	{
		if (m_LpScanParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowPixelSize: invalid pointer"));
			return;
		}
		COTSImageScanParamPtr pImgScanParam = GetImgScanPrmPtr();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowPixelSize: invalid pointer"));
			return;
		}
		pImgScanParam->SetShowPixelSize(a_bValue);
	}

	int COTSImgScanPrmClr::GetScanImageSpeed()
	{
		return (int)m_LpScanParam->get()->GetScanImageSpeed();		
	}

	void COTSImgScanPrmClr::SetScanImageSpeed(int  a_nScanImageSpeed)
	{
		m_LpScanParam->get()->SetScanImageSpeed((OTS_THREE_TIES_OPTIONS)a_nScanImageSpeed);		
	}

	bool COTSImgScanPrmClr::GetShowImageSpeed()
	{
		if (m_LpScanParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowImageSpeed: invalid pointer"));
			return false;
		}
		COTSImageScanParamPtr pImgScanParam = GetImgScanPrmPtr();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetShowImageSpeed: invalid pointer"));
			return false;
		}
		bool ImgScanParam = pImgScanParam->GetShowImageSpeed();
		return ImgScanParam;
	}
	void COTSImgScanPrmClr::SetShowImageSpeed(bool a_bValue)
	{
		if (m_LpScanParam == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowImageSpeed: invalid pointer"));
			return;
		}
		COTSImageScanParamPtr pImgScanParam = GetImgScanPrmPtr();
		ASSERT(pImgScanParam);
		if (!pImgScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetShowImageSpeed: invalid pointer"));
			return;
		}
		pImgScanParam->SetShowImageSpeed(a_bValue);
	}


}