OTS/OTSCPP/OTSRptCalculate/Model/PropParam.cpp

#include "stdafx.h"
#include "PropParam.h"
#include "OTSHelper.h"


namespace OTSMODEL {
	using namespace OTSDATA;
	// constructor
	CPropParam::CPropParam()
	{
		Init();
	}

	// copy constructor
	CPropParam::CPropParam(const CPropParam& a_oSource)
	{
		// can't copy itself
		if (&a_oSource == this)
		{
			return;
		}

		// copy data over
		Duplicate(a_oSource);
	}

	// copy constructor
	CPropParam::CPropParam(CPropParam* a_poSource)
	{
		// input check
		ASSERT(a_poSource);
		if (!a_poSource)
		{
			return;
		}

		// can't copy itself
		if (a_poSource == this)
		{
			return;
		}

		// copy data over
		Duplicate(*a_poSource);
	}

	// =operator	
	CPropParam& CPropParam::operator=(const CPropParam& a_oSource)
	{
		// cleanup
		Cleanup();

		// copy the class data over
		Duplicate(a_oSource);

		// return class
		return *this;
	}

	// ==operator
	BOOL CPropParam::operator==(const CPropParam& a_oSource)
	{
		return FALSE;
	}

	// destructor
	CPropParam::~CPropParam()
	{
		// cleanup
		Cleanup();
	}

	// data source id
	BOOL CPropParam::SetDataSourceList(std::vector<CString> a_listDataSource)
	{
		// data source count is reduced? 
		if (m_listDataSource.size() > a_listDataSource.size())
		{
			// need to check if data source id has to be changed

			// data source count is 0
			if ((int)a_listDataSource.size() == 0)
			{
				// set data source id to -1, no working data source
				m_nDataSourceId = -1;
			}
			// need to set data source id to 0? 
			else if (m_nDataSourceId >= (int)a_listDataSource.size())
			{
				// set data source id to 0, the first data source is the working data source
				m_nDataSourceId = 0;
			}
			else if (m_nDataSourceId == -1 && (int)a_listDataSource.size() > 0)
			{
				// set data source id to 0, the first data source is the working data source
				m_nDataSourceId = 0;
			}
		}

		// set data source count
		m_listDataSource = a_listDataSource;

		// ok, return TRUE
		return TRUE;
	}
	BOOL CPropParam::SetDataSourceId(int a_nDataSourceId)
	{
		// data source id can't be < -1, -1 means no working data source
		if (a_nDataSourceId < -1)
		{
			return FALSE;
		}
		// data source id >= data source count
		else if (a_nDataSourceId >= (int)m_listDataSource.size())
		{
			return FALSE;
		}

		m_nDataSourceId = a_nDataSourceId;

		// ok, return TRUE
		return TRUE;
	}

	// data source type
	BOOL CPropParam::SetDataSourceType(DATA_SOURCE_TYPE a_nDataSourceType)
	{
		// input validation
		if (a_nDataSourceType < DATA_SOURCE_TYPE::MIN && a_nDataSourceType > DATA_SOURCE_TYPE::MAX)
		{
			// invalid input
			return FALSE;
		}

		m_nDataSourceType = a_nDataSourceType;

		// ok, return TRUE
		return TRUE;
	}

	// image display type
	BOOL CPropParam::SetImageDisplayType(IMAGE_DISPLAY_TYPE a_nImageDisplayType)
	{
		// input validation
		if (a_nImageDisplayType < IMAGE_DISPLAY_TYPE::MIN && a_nImageDisplayType > IMAGE_DISPLAY_TYPE::MAX)
		{
			// invalid input
			return FALSE;
		}

		m_nImageDisplayType = a_nImageDisplayType;

		// ok, return TRUE
		return TRUE;
	}

	// image type
	BOOL CPropParam::SetImageType(IMAGE_TYPE a_nImageType)
	{
		// input validation
		if (a_nImageType < IMAGE_TYPE::MIN && a_nImageType > IMAGE_TYPE::MAX)
		{
			// invalid input
			return FALSE;
		}

		m_nImageType = a_nImageType;

		// ok, return TRUE
		return TRUE;
	}

	// measure data type
	BOOL CPropParam::SetMeasureDataType(MEASURE_DATA_TYPE a_nMeasureDataType)
	{
		// input validation
		if (a_nMeasureDataType < MEASURE_DATA_TYPE::MIN && a_nMeasureDataType > MEASURE_DATA_TYPE::MAX)
		{
			// invalid input
			return FALSE;
		}

		m_nMeasureDataType = a_nMeasureDataType;

		// ok, return TRUE
		return TRUE;
	}

	// calculate table type
	BOOL CPropParam::SetCalTableType(CALCULATE_TABLE_TYPE a_nCalTableType)
	{
		// input validation
		if (a_nCalTableType < CALCULATE_TABLE_TYPE::MIN && a_nCalTableType > CALCULATE_TABLE_TYPE::MAX)
		{
			// invalid input
			return FALSE;
		}

		m_nCalTableType = a_nCalTableType;

		// ok, return TRUE
		return TRUE;
	}

	// calculate chart type
	BOOL CPropParam::SetCalChartType(CALCULATE_CHART_TYPE a_nCalChartType)
	{
		// input validation
		if (a_nCalChartType < CALCULATE_CHART_TYPE::MIN && a_nCalChartType > CALCULATE_CHART_TYPE::MAX)
		{
			// invalid input
			return FALSE;
		}

		m_nCalChartType = a_nCalChartType;

		// ok, return TRUE
		return TRUE;
	}

	// particle type
	BOOL CPropParam::SetPartType(PARTICLE_TYPE a_nPartType)
	{
		// input validation
		if (a_nPartType < PARTICLE_TYPE::MIN && a_nPartType > PARTICLE_TYPE::MAX)
		{
			// invalid input
			return FALSE;
		}

		m_nPartType = a_nPartType;

		// ok, return TRUE
		return TRUE;
	}

	

	

	// grain size min
	BOOL CPropParam::SetGrainSizeMin(double a_dGrainSizeMin)
	{
		// grain size min can't be < 0
		if (a_dGrainSizeMin<0)
		{
			return FALSE;
		}

		m_dGrainSizeMin = a_dGrainSizeMin;
		NormalizeGrainSizeValue();

		// ok, return TRUE
		return TRUE;
	}

	// grain size max
	BOOL CPropParam::SetGrainSizeMax(double a_dGrainSizeMax)
	{
		// grain size max can't be < 0
		if ( a_dGrainSizeMax < 0)
		{
			return FALSE;
		}
		if (a_dGrainSizeMax > 0) 
		{
			m_dGrainSizeMax = a_dGrainSizeMax;
		}

		m_dGrainSizeMax = a_dGrainSizeMax;

		// ok, return TRUE
		return TRUE;
	}

	// size calculation method type
	BOOL CPropParam::SetSizeCalMethodType(SIZE_CAL_METHOD_TYPE a_nSizeCalMethodType)
	{
		// input validation
		if (a_nSizeCalMethodType < SIZE_CAL_METHOD_TYPE::MIN && a_nSizeCalMethodType > SIZE_CAL_METHOD_TYPE::MAX)
		{
			// invalid input
			return FALSE;
		}

		m_nSizeCalMethodType = a_nSizeCalMethodType;

		// ok, return TRUE
		return TRUE;
	}

	
	// combo data
	BOOL CPropParam::GetPropComboData(OTS_RETORT_PROP_GRID_ITEMS a_nId, int& a_nValue)
	{
		switch (a_nId)
		{
			case OTS_RETORT_PROP_GRID_ITEMS::DATA_SOURCE:
			{
				a_nValue = GetDataSourceId();
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::DATA_SOURCE_TYPE:
			{
				a_nValue = (int)GetDataSourceType();
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::IMAGE_TYPE:
			{
				a_nValue = (int)GetImageType();
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::IMAGE_DISPLAY_TYPE:
			{
				a_nValue = (int)GetImageDisplayType();
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::MEASURE_DATA_TYPE:
			{
				a_nValue = (int)GetMeasureDataType();
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::CALCULATE_TABLE_TYPE:
			{
				a_nValue = (int)GetCalTableType();
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::CALCULATE_CHART_TYPE:
			{
				a_nValue = (int)GetCalChartType();
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::PARTICLE_TYPE:
			{
				a_nValue = (int)GetPartType();
			}
			break;

	

			case OTS_RETORT_PROP_GRID_ITEMS::SIZE_CAL_METHOD_TYPE:
			{
				a_nValue = (int)GetSizeCalMethodType();
			}
			break;

			default:
			{
				// something wrong
				return FALSE;
			}
		}

		// ok, return TRUE
		return TRUE;
	}
	BOOL CPropParam::SetPropComboData(OTS_RETORT_PROP_GRID_ITEMS a_nId, int a_nValue)
	{
		switch (a_nId)
		{
			case OTS_RETORT_PROP_GRID_ITEMS::DATA_SOURCE:
			{
				return SetDataSourceId(a_nValue);
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::DATA_SOURCE_TYPE:
			{
				return SetDataSourceType((DATA_SOURCE_TYPE)a_nValue);
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::IMAGE_TYPE:
			{
				return SetImageType((IMAGE_TYPE)a_nValue);
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::IMAGE_DISPLAY_TYPE:
			{
				 return SetImageDisplayType((IMAGE_DISPLAY_TYPE)a_nValue);
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::MEASURE_DATA_TYPE:
			{
				 return SetMeasureDataType((MEASURE_DATA_TYPE)a_nValue);
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::CALCULATE_TABLE_TYPE:
			{
				return SetCalTableType((CALCULATE_TABLE_TYPE)a_nValue);
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::CALCULATE_CHART_TYPE:
			{
				return SetCalChartType((CALCULATE_CHART_TYPE)a_nValue);
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::PARTICLE_TYPE:
			{
				return SetPartType((PARTICLE_TYPE)a_nValue);
			}
			break;

			

			case OTS_RETORT_PROP_GRID_ITEMS::SIZE_CAL_METHOD_TYPE:
			{
				return SetSizeCalMethodType((SIZE_CAL_METHOD_TYPE)a_nValue);
			}
			break;
			
			default:
			{
				// something wrong
				return FALSE;
			}
		}

		// ok, return TRUE
		return TRUE;
	}
	

	// double data 
	BOOL CPropParam::GetPropDoubleData(OTS_RETORT_PROP_GRID_ITEMS a_nId, double& a_dValue)
	{
		switch (a_nId)
		{
			case OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_MIN:
			{
				a_dValue = GetGrainSizeMin();
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_MAX:
			{
				a_dValue = GetGrainSizeMax();
			}
			break;

			default:
			{
				// something wrong
				return FALSE;
			}
		}

		// ok, return TRUE
		return TRUE;
	}
	BOOL CPropParam::SetPropDoubleData(OTS_RETORT_PROP_GRID_ITEMS a_nId, double a_dValue)
	{
		switch (a_nId)
		{
			case OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_MIN:
			{
				return SetGrainSizeMin(a_dValue);
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_MAX:
			{
				return SetGrainSizeMax(a_dValue);
			}
			break;

			default:
			{
				// something wrong
				return FALSE;
			}
		}

		// ok, return TRUE
		return TRUE;
	}

	// get related property item
	BOOL CPropParam::GetRelatedPropItem(OTS_RETORT_PROP_GRID_ITEMS a_nId, OTS_RETORT_PROP_GRID_ITEMS& a_nRelatedPropId)
	{
		switch (a_nId)
		{
			case OTS_RETORT_PROP_GRID_ITEMS::DATA_SOURCE:
			{
				return FALSE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::DATA_SOURCE_TYPE:
			{
				return FALSE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::IMAGE_TYPE:
			{
				return FALSE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::IMAGE_DISPLAY_TYPE:
			{
				return FALSE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::MEASURE_DATA_TYPE:
			{
				return FALSE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::CALCULATE_TABLE_TYPE:
			{
				return FALSE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::CALCULATE_CHART_TYPE:
			{
				return FALSE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::PARTICLE_TYPE:
			{
				return FALSE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::STD_ID:
			{
				return FALSE;
			}
			break;
			
			case OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_CLASS_TABLE:
			{
				a_nRelatedPropId = OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_CLASS;
				return TRUE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_CLASS:
			{
				a_nRelatedPropId = OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_MAX;
				return TRUE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_MIN:
			{
				a_nRelatedPropId = OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_MAX;
				return TRUE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_MAX:
			{
				a_nRelatedPropId = OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_MIN;
				return TRUE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::SIZE_CAL_METHOD_TYPE:
			{
				return FALSE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::TRIO_CHART_TYPE:
			{
				return FALSE;
			}
			break;

			default:
			{
				return FALSE;
			}
			break;
		}

		// ok, return TRUE
		return TRUE;
	}
	BOOL CPropParam::UpdateAll(OTS_RETORT_PROP_GRID_ITEMS a_nId)
	{
		switch (a_nId)
		{
			case OTS_RETORT_PROP_GRID_ITEMS::DATA_SOURCE:
			{
				return FALSE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::DATA_SOURCE_TYPE:
			{
				return FALSE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::IMAGE_TYPE:
			{
				return FALSE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::IMAGE_DISPLAY_TYPE:
			{
				return FALSE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::MEASURE_DATA_TYPE:
			{
				return TRUE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::CALCULATE_TABLE_TYPE:
			{
				return TRUE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::CALCULATE_CHART_TYPE:
			{
				return TRUE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::PARTICLE_TYPE:
			{
				return FALSE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::STD_ID:
			{
				return FALSE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_CLASS_TABLE:
			{
				return FALSE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_CLASS:
			{
				return TRUE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_MIN:
			{
				return FALSE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_MAX:
			{
				return FALSE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::SIZE_CAL_METHOD_TYPE:
			{
				return FALSE;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::TRIO_CHART_TYPE:
			{
				return FALSE;
			}
			break;

			default:
			{
				return FALSE;
			}
			break;
		}

		// ok, return TRUE
		return TRUE;
	}

	CPropItemPtr CPropParam::GetPropItemById(OTS_RETORT_PROP_GRID_ITEMS a_nId)
	{
		CPropItemPtr pPropItem = nullptr;

		auto itr = std::find_if(m_listPropItems.begin(), m_listPropItems.end(), [a_nId](CPropItemPtr& poPropItem) { return poPropItem->GetReportItemId() == a_nId; });
		if (itr != m_listPropItems.end())
		{
			// found the property item
			pPropItem = *itr;
		}

		return pPropItem;
	}

	

	// cleanup 
	void CPropParam::Cleanup()
	{
		// need to do nothing at the moment
	}

	// initialization
	void CPropParam::Init()
	{
		m_nType = RETORT_PROP_GRID_PARAM_TYPE::MIN;
		m_listPropItems.clear();
		m_listDataSource.clear();
		m_nDataSourceId = -1;
		m_nDataSourceType = DATA_SOURCE_TYPE::ALL;
		m_nImageDisplayType = IMAGE_DISPLAY_TYPE::GENERAL;
		m_nImageType = IMAGE_TYPE::BSE;
		m_nMeasureDataType = MEASURE_DATA_TYPE::ALL_PARTICLE;
		m_nCalTableType = CALCULATE_TABLE_TYPE::MEASURE_INFO;
		m_nCalChartType = CALCULATE_CHART_TYPE::COMMON_FIVE;
		m_nPartType = PARTICLE_TYPE::ALL ;
		
		m_dGrainSizeMin = 0.0;
		m_dGrainSizeMax = 0.0;
		m_nSizeCalMethodType = SIZE_CAL_METHOD_TYPE::LENGTH;
		m_strTrioChartName = _T("");
			
	}

	// duplication 
	void CPropParam::Duplicate(const CPropParam& a_oSource)
	{
		// initialization
		Init();

		m_nType = a_oSource.m_nType;

		// copy data over
		m_listPropItems.clear();
		for (auto pPropItem : a_oSource.m_listPropItems)
		{
			CPropItemPtr pPropItemNew = CPropItemPtr(new CPropItem(pPropItem.get()));
			m_listPropItems.push_back(pPropItemNew);
		}
		m_listDataSource.clear();
		for (auto strDataSource : a_oSource.m_listDataSource)
		{
			CString strDataSourceNew = strDataSource;
			m_listDataSource.push_back(strDataSourceNew);
		}
		m_nDataSourceId = a_oSource.m_nDataSourceId;
		m_nDataSourceType = a_oSource.m_nDataSourceType;
		m_nImageDisplayType = a_oSource.m_nImageDisplayType;
		m_nImageType = a_oSource.m_nImageType;
		m_nMeasureDataType = a_oSource.m_nMeasureDataType;
		m_nCalTableType = a_oSource.m_nCalTableType;
		m_nCalChartType = a_oSource.m_nCalChartType;
		m_nPartType = a_oSource.m_nPartType;		
		m_dGrainSizeMin = a_oSource.m_dGrainSizeMin;
		m_dGrainSizeMax = a_oSource.m_dGrainSizeMax;
		m_nSizeCalMethodType = a_oSource.m_nSizeCalMethodType;
		m_strTrioChartName = a_oSource.m_strTrioChartName;
		m_TrioChartType = a_oSource.m_TrioChartType;
	}

	// Normalize grain size values
	void CPropParam::NormalizeGrainSizeValue()
	{		
		double dMin = min(m_dGrainSizeMin, m_dGrainSizeMax);
		double dMax = max(m_dGrainSizeMin, m_dGrainSizeMax);
		m_dGrainSizeMin = dMin;
		m_dGrainSizeMax = dMax;
	}
	//set TopName
	BOOL CPropParam::SetTopName(CString a_TopName)
	{
		if (a_TopName.IsEmpty())
		{
			return FALSE;
		}
		m_TopName = a_TopName;
		return TRUE;
	}
	//set LeftName
	BOOL CPropParam::SetLeftName(CString a_LeftName)
	{
		if (a_LeftName.IsEmpty())
		{
			return FALSE;
		}
		m_LeftName = a_LeftName;
		return TRUE;
	}
	//set RightName
	BOOL CPropParam::SetRightName(CString a_RightName)
	{
		if (a_RightName.IsEmpty())
		{
			return FALSE;
		}
		m_RightName = a_RightName;
		return TRUE;
	}
	//set Top ElementName List
	BOOL CPropParam::SetTopElementName(std::vector<CString> a_listTopElementName)
	{
		if (a_listTopElementName.size() > 0)
		{
			m_listTopElementName = a_listTopElementName;
			return TRUE;
		}
		return FALSE;
	}
	//set Left ElementName List
	BOOL CPropParam::SetLeftElementName(std::vector<CString> a_listLeftElementName)
	{
		if (a_listLeftElementName.size() > 0)
		{
			m_listLeftElementName = a_listLeftElementName;
			return TRUE;
		}
		return FALSE;
	}
	//set Right ElementName List
	BOOL CPropParam::SetRightElementName(std::vector<CString> a_listRightElementName)
	{
		if (a_listRightElementName.size() > 0)
		{
			m_listRightElementName = a_listRightElementName;
			return TRUE;
		}
		return FALSE;
	}

	// CPropParamImage

	// constructor
	CPropParamImage::CPropParamImage()
	{
		Init();
	}

	// copy constructor
	CPropParamImage::CPropParamImage(const CPropParamImage& a_oSource)
	{
		// can't copy itself
		if (&a_oSource == this)
		{
			return;
		}

		// copy data over
		Duplicate(a_oSource);
	}

	// copy constructor
	CPropParamImage::CPropParamImage(CPropParamImage* a_poSource)
	{
		// input check
		ASSERT(a_poSource);
		if (!a_poSource)
		{
			return;
		}

		// can't copy itself
		if (a_poSource == this)
		{
			return;
		}

		// copy data over
		Duplicate(*a_poSource);
	}

	// =operator	
	CPropParamImage& CPropParamImage::operator=(const CPropParamImage& a_oSource)
	{
		// cleanup
		Cleanup();

		// copy the class data over
		Duplicate(a_oSource);

		// return class
		return *this;
	}

	// ==operator
	BOOL CPropParamImage::operator==(const CPropParamImage& a_oSource)
	{
		return FALSE;
	}

	// destructor
	CPropParamImage::~CPropParamImage()
	{
		// cleanup
		Cleanup();
	}
	// property items list
	void CPropParamImage::SetPropertyItems()
	{
		// clear property items list
		m_listPropItems.clear();

		// property item
		CPropItemPtr poPropItem;

		// data source
		poPropItem = CPropItemPtr(new CPropItem());
		poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::DATA_SOURCE, OTS_ITEM_TYPES::COMBO, FALSE);
		m_listPropItems.push_back(poPropItem);

		// image type
		poPropItem = CPropItemPtr(new CPropItem());
		poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::IMAGE_TYPE, OTS_ITEM_TYPES::COMBO, FALSE);
		m_listPropItems.push_back(poPropItem);

		// image display type
		poPropItem = CPropItemPtr(new CPropItem());
		poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::IMAGE_DISPLAY_TYPE, OTS_ITEM_TYPES::COMBO, FALSE);
		m_listPropItems.push_back(poPropItem);

		// measure data type
		if (m_nImageDisplayType == IMAGE_DISPLAY_TYPE::GENERAL) 
		{
			// general image

			poPropItem = CPropItemPtr(new CPropItem());
			poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::PARTICLE_TYPE, OTS_ITEM_TYPES::COMBO, FALSE);
			m_listPropItems.push_back(poPropItem);

	

			poPropItem = CPropItemPtr(new CPropItem());
			poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_CLASS_TABLE, OTS_ITEM_TYPES::COMBO, FALSE);
			m_listPropItems.push_back(poPropItem);

			poPropItem = CPropItemPtr(new CPropItem());
			poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_CLASS, OTS_ITEM_TYPES::COMBO, FALSE);
			m_listPropItems.push_back(poPropItem);

			if (m_nSizeItemId == (int)SIZE_CLASS_DEFUALT::USER_DEFINDED)
			{
				poPropItem = CPropItemPtr(new CPropItem());
				poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_MIN, OTS_ITEM_TYPES::DOUBLE, FALSE);
				m_listPropItems.push_back(poPropItem);

				poPropItem = CPropItemPtr(new CPropItem());
				poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_MAX, OTS_ITEM_TYPES::DOUBLE, FALSE);
				m_listPropItems.push_back(poPropItem);
			}
			else if(m_nSizeItemId > (int)SIZE_CLASS_DEFUALT::USER_DEFINDED)
			{
				poPropItem = CPropItemPtr(new CPropItem());
				poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_MIN, OTS_ITEM_TYPES::DOUBLE, TRUE);
				m_listPropItems.push_back(poPropItem);

				poPropItem = CPropItemPtr(new CPropItem());
				poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_MAX, OTS_ITEM_TYPES::DOUBLE, TRUE);
				m_listPropItems.push_back(poPropItem);
			}
			//暂时去掉颗粒尺寸计算方法选项
			poPropItem = CPropItemPtr(new CPropItem());
			poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::SIZE_CAL_METHOD_TYPE, OTS_ITEM_TYPES::COMBO, FALSE);
			//poPropItem->SetReadOnly(TRUE);
			m_listPropItems.push_back(poPropItem);
		}
		else 
		{
			// particle grid

			poPropItem = CPropItemPtr(new CPropItem());
			poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::MEASURE_DATA_TYPE, OTS_ITEM_TYPES::COMBO, FALSE);
			m_listPropItems.push_back(poPropItem);

			if (m_nMeasureDataType == MEASURE_DATA_TYPE::PARTICALE_SIZE_DISTRIBUTION)
			{
				poPropItem = CPropItemPtr(new CPropItem());
				poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_CLASS_TABLE, OTS_ITEM_TYPES::COMBO, FALSE);
				m_listPropItems.push_back(poPropItem);

				poPropItem = CPropItemPtr(new CPropItem());
				poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_CLASS, OTS_ITEM_TYPES::COMBO, FALSE);
				m_listPropItems.push_back(poPropItem);

				if (m_nSizeItemId == (int)SIZE_CLASS_DEFUALT::USER_DEFINDED)
				{
					poPropItem = CPropItemPtr(new CPropItem());
					poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_MIN, OTS_ITEM_TYPES::DOUBLE, FALSE);
					m_listPropItems.push_back(poPropItem);

					poPropItem = CPropItemPtr(new CPropItem());
					poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_MAX, OTS_ITEM_TYPES::DOUBLE, FALSE);
					m_listPropItems.push_back(poPropItem);
				}
				else if (m_nSizeItemId > (int)SIZE_CLASS_DEFUALT::USER_DEFINDED)
				{
					poPropItem = CPropItemPtr(new CPropItem());
					poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_MIN, OTS_ITEM_TYPES::DOUBLE, TRUE);
					m_listPropItems.push_back(poPropItem);

					poPropItem = CPropItemPtr(new CPropItem());
					poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_MAX, OTS_ITEM_TYPES::DOUBLE, TRUE);
					m_listPropItems.push_back(poPropItem);
				}
				

				poPropItem = CPropItemPtr(new CPropItem());
				poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::SIZE_CAL_METHOD_TYPE, OTS_ITEM_TYPES::COMBO, FALSE);
				m_listPropItems.push_back(poPropItem);
			}
		}
	}

	// protected

	// cleanup 
	void CPropParamImage::Cleanup()
	{
		// need to do nothing at the moment
	}

	// initialization
	void CPropParamImage::Init()
	{
		CPropParam::Init();
		m_nType = RETORT_PROP_GRID_PARAM_TYPE::IMAGE;
	}

	// duplication 
	void CPropParamImage::Duplicate(const CPropParamImage& a_oSource)
	{
		// initialization
		Init();

		// copy data over
		m_nType = a_oSource.m_nType;

		// copy data over
		m_listPropItems.clear();
		for (auto pPropItem : a_oSource.m_listPropItems)
		{
			CPropItemPtr pPropItemNew = CPropItemPtr(new CPropItem(pPropItem.get()));
			m_listPropItems.push_back(pPropItemNew);
		}
		m_listDataSource.clear();
		for (auto strDataSource : a_oSource.m_listDataSource)
		{
			CString strDataSourceNew = strDataSource;
			m_listDataSource.push_back(strDataSourceNew);
		}
		m_nDataSourceId = a_oSource.m_nDataSourceId;
		m_nDataSourceType = a_oSource.m_nDataSourceType;
		m_nImageDisplayType = a_oSource.m_nImageDisplayType;
		m_nImageType = a_oSource.m_nImageType;
		m_nMeasureDataType = a_oSource.m_nMeasureDataType;
		m_nCalTableType = a_oSource.m_nCalTableType;
		m_nCalChartType = a_oSource.m_nCalChartType;
		m_nPartType = a_oSource.m_nPartType;

		m_dGrainSizeMin = a_oSource.m_dGrainSizeMin;
		m_dGrainSizeMax = a_oSource.m_dGrainSizeMax;
		m_nSizeCalMethodType = a_oSource.m_nSizeCalMethodType;
		m_strTrioChartName = a_oSource.m_strTrioChartName;
		m_TrioChartType = a_oSource.m_TrioChartType;
	}

	// constructor
	CPropParamGrid::CPropParamGrid()
	{
		Init();
	}

	// copy constructor
	CPropParamGrid::CPropParamGrid(const CPropParamGrid& a_oSource)
	{
		// can't copy itself
		if (&a_oSource == this)
		{
			return;
		}

		// copy data over
		Duplicate(a_oSource);
	}

	// copy constructor
	CPropParamGrid::CPropParamGrid(CPropParamGrid* a_poSource)
	{
		// input check
		ASSERT(a_poSource);
		if (!a_poSource)
		{
			return;
		}

		// can't copy itself
		if (a_poSource == this)
		{
			return;
		}

		// copy data over
		Duplicate(*a_poSource);
	}

	// =operator	
	CPropParamGrid& CPropParamGrid::operator=(const CPropParamGrid& a_oSource)
	{
		// cleanup
		Cleanup();

		// copy the class data over
		Duplicate(a_oSource);

		// return class
		return *this;
	}

	// ==operator
	BOOL CPropParamGrid::operator==(const CPropParamGrid& a_oSource)
	{
		return FALSE;
	}

	// destructor
	CPropParamGrid::~CPropParamGrid()
	{
		// cleanup
		Cleanup();
	}

	// property items list
	void CPropParamGrid::SetPropertyItems()
	{
		// clear property items list
		m_listPropItems.clear();

		// property item
		CPropItemPtr poPropItem;

		// data source
		poPropItem = CPropItemPtr(new CPropItem());
		poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::DATA_SOURCE, OTS_ITEM_TYPES::COMBO, FALSE);
		m_listPropItems.push_back(poPropItem);

		// data source type
		poPropItem = CPropItemPtr(new CPropItem());
		poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::DATA_SOURCE_TYPE, OTS_ITEM_TYPES::COMBO, FALSE);
		m_listPropItems.push_back(poPropItem);

		// cal data table type
		poPropItem = CPropItemPtr(new CPropItem());
		poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::CALCULATE_TABLE_TYPE, OTS_ITEM_TYPES::COMBO, FALSE);
		m_listPropItems.push_back(poPropItem);

		//element comp
		if (m_nCalTableType == CALCULATE_TABLE_TYPE::PARTICALE_COMP)
		{
			poPropItem = CPropItemPtr(new CPropItem());
			poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::SIZE_CAL_METHOD_TYPE, OTS_ITEM_TYPES::COMBO, FALSE);
			m_listPropItems.push_back(poPropItem);
		}

		// size calculation method type
		if (m_nCalTableType == CALCULATE_TABLE_TYPE::PARTICALE_SIZE_DISTRIBUTION)
		{
			poPropItem = CPropItemPtr(new CPropItem());
			poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_CLASS_TABLE, OTS_ITEM_TYPES::COMBO, FALSE);
			m_listPropItems.push_back(poPropItem);

		
			//暂时去掉颗粒尺寸计算方法和尺寸表计算方法选项
			//----------------------------------------
			poPropItem = CPropItemPtr(new CPropItem());
			poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::SIZE_CAL_METHOD_TYPE, OTS_ITEM_TYPES::COMBO, FALSE);
			m_listPropItems.push_back(poPropItem);

			//------------------------------------------
		}
	}

	// protected

	// cleanup 
	void CPropParamGrid::Cleanup()
	{
		// need to do nothing at the moment
	}

	// initialization
	void CPropParamGrid::Init()
	{
		CPropParam::Init();
		m_nType = RETORT_PROP_GRID_PARAM_TYPE::TABLE;		
	}

	// duplication 
	void CPropParamGrid::Duplicate(const CPropParamGrid& a_oSource)
	{
		// initialization
		Init();

		// copy data over
		m_nType = a_oSource.m_nType;

		// copy data over
		m_listPropItems.clear();
		for (auto pPropItem : a_oSource.m_listPropItems)
		{
			CPropItemPtr pPropItemNew = CPropItemPtr(new CPropItem(pPropItem.get()));
			m_listPropItems.push_back(pPropItemNew);
		}
		m_listDataSource.clear();
		for (auto strDataSource : a_oSource.m_listDataSource)
		{
			CString strDataSourceNew = strDataSource;
			m_listDataSource.push_back(strDataSourceNew);
		}
		m_nDataSourceId = a_oSource.m_nDataSourceId;
		m_nDataSourceType = a_oSource.m_nDataSourceType;
		m_nImageDisplayType = a_oSource.m_nImageDisplayType;
		m_nImageType = a_oSource.m_nImageType;
		m_nMeasureDataType = a_oSource.m_nMeasureDataType;
		m_nCalTableType = a_oSource.m_nCalTableType;
		m_nCalChartType = a_oSource.m_nCalChartType;
		m_nPartType = a_oSource.m_nPartType;	
		m_dGrainSizeMin = a_oSource.m_dGrainSizeMin;
		m_dGrainSizeMax = a_oSource.m_dGrainSizeMax;
		m_nSizeCalMethodType = a_oSource.m_nSizeCalMethodType;
		m_strTrioChartName = a_oSource.m_strTrioChartName;
		m_TrioChartType = a_oSource.m_TrioChartType;
	}

	// constructor
	CPropParamChart::CPropParamChart()
	{
		Init();		
	}

	// copy constructor
	CPropParamChart::CPropParamChart(const CPropParamChart& a_oSource)
	{
		// can't copy itself
		if (&a_oSource == this)
		{
			return;
		}

		// copy data over
		Duplicate(a_oSource);
	}

	// copy constructor
	CPropParamChart::CPropParamChart(CPropParamChart* a_poSource)
	{
		// input check
		ASSERT(a_poSource);
		if (!a_poSource)
		{
			return;
		}

		// can't copy itself
		if (a_poSource == this)
		{
			return;
		}

		// copy data over
		Duplicate(*a_poSource);
	}

	// =operator	
	CPropParamChart& CPropParamChart::operator=(const CPropParamChart& a_oSource)
	{
		// cleanup
		Cleanup();

		// copy the class data over
		Duplicate(a_oSource);

		// return class
		return *this;
	}

	// ==operator
	BOOL CPropParamChart::operator==(const CPropParamChart& a_oSource)
	{
		return FALSE;
	}

	// destructor
	CPropParamChart::~CPropParamChart()
	{
		// cleanup
		Cleanup();
	}

	// property items list
	void CPropParamChart::SetPropertyItems()
	{
		// clear property items list
		m_listPropItems.clear();

		// property item
		CPropItemPtr poPropItem;

		// data source
		poPropItem = CPropItemPtr(new CPropItem());
		poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::DATA_SOURCE, OTS_ITEM_TYPES::COMBO, FALSE);
		m_listPropItems.push_back(poPropItem);

		// data source type
		poPropItem = CPropItemPtr(new CPropItem());
		poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::DATA_SOURCE_TYPE, OTS_ITEM_TYPES::COMBO, FALSE);
		m_listPropItems.push_back(poPropItem);

		// cal data chart type
		poPropItem = CPropItemPtr(new CPropItem());
		poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::CALCULATE_CHART_TYPE, OTS_ITEM_TYPES::COMBO, FALSE);
		m_listPropItems.push_back(poPropItem);


		
		// size calculation method type
		if (m_nCalChartType == CALCULATE_CHART_TYPE::PARTICALE_SIZE_DISTRIBUTION)
		{
			poPropItem = CPropItemPtr(new CPropItem());
			poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::STD_ID, OTS_ITEM_TYPES::COMBO, FALSE);
			m_listPropItems.push_back(poPropItem);

			poPropItem = CPropItemPtr(new CPropItem());
			poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_CLASS_TABLE, OTS_ITEM_TYPES::COMBO, FALSE);
			m_listPropItems.push_back(poPropItem);

			
			//暂时去掉尺寸计算法选项和尺寸表计算法选项
			poPropItem = CPropItemPtr(new CPropItem());
			poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::SIZE_CAL_METHOD_TYPE, OTS_ITEM_TYPES::COMBO, FALSE);
			m_listPropItems.push_back(poPropItem);

		}

		

		// trio chart type
		if (m_nCalChartType == CALCULATE_CHART_TYPE::TRIO_CHART)
		{
			poPropItem = CPropItemPtr(new CPropItem());
			poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::TRIO_CHART_TYPE, OTS_ITEM_TYPES::COMBO, FALSE);
			m_listPropItems.push_back(poPropItem);

			poPropItem = CPropItemPtr(new CPropItem());
			poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_CLASS_TABLE, OTS_ITEM_TYPES::COMBO, FALSE);
			m_listPropItems.push_back(poPropItem);

			poPropItem = CPropItemPtr(new CPropItem());
			poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::SIZE_CAL_METHOD_TYPE, OTS_ITEM_TYPES::COMBO, FALSE);
			m_listPropItems.push_back(poPropItem);
		}
	}

	// protected

	// cleanup 
	void CPropParamChart::Cleanup()
	{
		// need to do nothing at the moment
	}

	// initialization
	void CPropParamChart::Init()
	{
		CPropParam::Init();
		m_nType = RETORT_PROP_GRID_PARAM_TYPE::CHART;
	}

	// duplication 
	void CPropParamChart::Duplicate(const CPropParamChart& a_oSource)
	{
		// initialization
		Init();

		// copy data over
		m_nType = a_oSource.m_nType;

		// copy data over
		m_listPropItems.clear();
		for (auto pPropItem : a_oSource.m_listPropItems)
		{
			CPropItemPtr pPropItemNew = CPropItemPtr(new CPropItem(pPropItem.get()));
			m_listPropItems.push_back(pPropItemNew);
		}
		m_listDataSource.clear();
		for (auto strDataSource : a_oSource.m_listDataSource)
		{
			CString strDataSourceNew = strDataSource;
			m_listDataSource.push_back(strDataSourceNew);
		}
		m_nDataSourceId = a_oSource.m_nDataSourceId;
		m_nDataSourceType = a_oSource.m_nDataSourceType;
		m_nImageDisplayType = a_oSource.m_nImageDisplayType;
		m_nImageType = a_oSource.m_nImageType;
		m_nMeasureDataType = a_oSource.m_nMeasureDataType;
		m_nCalTableType = a_oSource.m_nCalTableType;
		m_nCalChartType = a_oSource.m_nCalChartType;
		m_nPartType = a_oSource.m_nPartType;
		m_dGrainSizeMin = a_oSource.m_dGrainSizeMin;
		m_dGrainSizeMax = a_oSource.m_dGrainSizeMax;
		m_nSizeCalMethodType = a_oSource.m_nSizeCalMethodType;
		m_strTrioChartName = a_oSource.m_strTrioChartName;
		m_TrioChartType = a_oSource.m_TrioChartType;
	}

}