#include "stdafx.h"
#include "PropParam.h"
#include "OTSHelper.h"
#include "OTSDATAresource.h"
#include "PartSizeFileMgr.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;
	}

	// STD index
	BOOL CPropParam::SetWorkingSTDLib(CPartSTDDataPtr a_pWorkingSTDLib)
	{
		// working std lib changed?
		if (*(a_pWorkingSTDLib.get()) == *(m_pWorkingSTDLib.get()))
		{
			// no change, get out
			return FALSE;
		}

		// new working std lib is a nullptr
		if (!a_pWorkingSTDLib)
		{
			// set  working std lib to a nullptr
			m_pWorkingSTDLib = nullptr;

			// STD index to -1, no STD selected
			m_nSTDId = -1;

			// get out
			return FALSE;
		}		

		//m_pWorkingSTDLib = CPartSTDDataPtr(new CPartSTDData(*a_pWorkingSTDLib.get()));
		m_pWorkingSTDLib = a_pWorkingSTDLib;
		if (m_pWorkingSTDLib->GetSTDItemsList().empty())
		{
			// STD index to -1, no STD selected
			m_nSTDId = -1;
		}
		else
		{
			// STD index to 0, first item is selected
			m_nSTDId = 0;
		}

		return true;
	}
	BOOL CPropParam::SetSTDId(int a_nSTDId)
	{
		// error, STD index can't be < -1, -1 means no working data source
		if (a_nSTDId < -1)
		{
			return FALSE;
		}

		// cal std id max value
		int nSTDIdMax = (int)STD_ID_DEFUALT::MAX + 1;
		if (!m_pWorkingSTDLib)
		{
			nSTDIdMax += (int)m_pWorkingSTDLib->GetSTDItemsList().size();
		}

		// error, a_nSTDId >= STD std max
		if( a_nSTDId >= nSTDIdMax)
		{
			return FALSE;
		}

		m_nSTDId = a_nSTDId;

		// ok, return TRUE
		return TRUE;
	}
	CPartSizeFilePtr CPropParam::GetWorkingSizeFile()
	{
		CPartSizeFileList pList = this->GetSizeFileList();
		return pList[this->GetSizeClassTableId()];
	}
	CPartSizeFileList CPropParam::GetSizeFileList()
	{
		CPartSizeFileList plist;
		std::vector<CString> listPartSizeFileName;
		CString strFolderName = this->GetSizeClassFileFolder();
		// get file list
		if (!COTSHelper::GetFileNameList(strFolderName, PART_SIZE_FILE_EXT, listPartSizeFileName))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPartSizeFileList::There is no %s file in the folder %s"), PART_SIZE_FILE_EXT, strFolderName);
			return plist;
		}

		//before the user choose one part size file, always should be null.
		int nPos = -1;
		// get folder's name.
		CPartSizeFileMgrPtr pPartSizeFileMnr = CPartSizeFileMgrPtr(new CPartSizeFileMgr());
		
			// read file name
		
		int index = -1;
		for (auto sFileName : listPartSizeFileName)
		{
			index++;
			// read the file		
			CString sPathName = strFolderName + sFileName;
			if (!pPartSizeFileMnr->Load(sPathName))
			{
				LogTrace(__FILE__, __LINE__, _T("GetPartSizeFileList::There is no %s in the folder %s"), sFileName, strFolderName);
				return plist;
			}

			// get part size from file
			CPartSizeFilePtr pPartSizeFile = pPartSizeFileMnr->GetPartSizeFile();
			ASSERT(pPartSizeFile);
			//listPartSizeName.push_back(sName);
			plist.push_back(pPartSizeFile);
		}
		return plist;
	}

	BOOL CPropParam::SetWorkingSizeFile(CPartSizeFilePtr a_pWorkingSizeFile)
	{
		// new size class table is a nullptr
		if (!a_pWorkingSizeFile)
		{
			// set working size class table to a nullptr
			m_pWorkingSizeFile = nullptr;

			// set size class to -1, no size class selected
			m_nSizeItemId = -1;

			// get out
			return FALSE;
		}
		
		// working size class table changed?
		if (*(a_pWorkingSizeFile.get()) == *(m_pWorkingSizeFile.get()))
		{
			// no change, get out
			return TRUE;
		}

		m_pWorkingSizeFile = CPartSizeFilePtr(new CPartSizeFile(*a_pWorkingSizeFile.get()));
		if (m_pWorkingSizeFile->GetPartSizeList().empty())
		{   
			// set size class to -1, no size class selected
			m_nSizeItemId = -1;
		}
		else
		{
			// set size class to 0, the first item is selected
			m_nSizeItemId = 0;
		}

		return TRUE;
	}
	BOOL CPropParam::SetSizeItemId(int a_nSizeClassId)
	{
		 //error, size class id can't be < -1, -1 means no size class selected
		if (a_nSizeClassId < -1)
		{
			return FALSE;
		}

		// cal size class id max value
		int nSizeClassIdMax = (int)SIZE_CLASS_DEFUALT::MAX + 1;
		
		ASSERT(m_pWorkingSizeFile);
		if (!m_pWorkingSizeFile)
		{
			return FALSE;
		}

		if (m_pWorkingSizeFile)
		{
			nSizeClassIdMax += (int)m_pWorkingSizeFile->GetPartSizeList().size();
		}

		// error, nSizeClassIdMax >= size class id max value
		if (a_nSizeClassId >= nSizeClassIdMax)
		{
			return FALSE;
		}

		m_nSizeItemId = a_nSizeClassId;

		// set size max and min
		if (m_nSizeItemId < ((int)SIZE_CLASS_DEFUALT::MAX + 1))
		{
			// grain size min
			m_dGrainSizeMin = 0;

			// grain size max
			m_dGrainSizeMax = 0;
		}
		else
		{
			CPartSizeItemPtr pSizeItem = m_pWorkingSizeFile->GetPartSizeList()[m_nSizeItemId - 2];
			ASSERT(pSizeItem);
			if (!pSizeItem)
			{
				// grain size min
				m_dGrainSizeMin = 0;

				// grain size max
				m_dGrainSizeMax = 0;

				return FALSE;
			}

			CDoubleRangePtr pDoubleRange = pSizeItem->GetSizeLevel();
			ASSERT(pDoubleRange);
			if (!pDoubleRange)
			{
				// grain size min
				m_dGrainSizeMin = 0;

				// grain size max
				m_dGrainSizeMax = 0;
				return FALSE;
			}
			m_dGrainSizeMax = pDoubleRange->GetEnd();
			m_dGrainSizeMin = pDoubleRange->GetStart();

			NormalizeGrainSizeValue();
			
		}

		// ok, return TRUE
		return TRUE;
	}
	BOOL CPropParam::SetSizeClassTableId(int a_nSizeClassTableId)
	{
	
		m_nSizeClassTableId = a_nSizeClassTableId;
		CString strFolderName = this->GetSizeClassFileFolder();

	

		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;
	}

	// trio chart name
	BOOL CPropParam::SetTrioChartName(CString a_strTrioChartName)
	{
		// input validation
		a_strTrioChartName.Trim();
		if (a_strTrioChartName.IsEmpty())
		{
			return FALSE;
		}

		m_strTrioChartName = a_strTrioChartName;

		// ok, return TRUE
		return TRUE;
	}
	// trio chart name
	BOOL CPropParam::SetTrioChartType(int a_TrioChartType)
	{
		

		m_TrioChartType = a_TrioChartType;

		// 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::STD_ID:
			{
				a_nValue = GetSTDId();
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_CLASS:
			{
				a_nValue = GetSizeItemId();
			}
			break;
			case OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_CLASS_TABLE:
			{
				a_nValue = GetSizeClassTableId();
			}
			break;
			case OTS_RETORT_PROP_GRID_ITEMS::TRIO_CHART_TYPE:
			{
				a_nValue = this->GetTrioChartType();
			}
			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::STD_ID:
			{
				return SetSTDId(a_nValue);
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_CLASS:
			{
				return SetSizeItemId(a_nValue);
			}
			break;
			case OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_CLASS_TABLE:
			{
				return SetSizeClassTableId(a_nValue);
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::SIZE_CAL_METHOD_TYPE:
			{
				return SetSizeCalMethodType((SIZE_CAL_METHOD_TYPE)a_nValue);
			}
			break;
			case OTS_RETORT_PROP_GRID_ITEMS::TRIO_CHART_TYPE:
			{
				return this->SetTrioChartType(a_nValue);
			}
			break;

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

		// ok, return TRUE
		return TRUE;
	}
	BOOL CPropParam::GetPropComboStrings(OTS_RETORT_PROP_GRID_ITEMS a_nId, std::vector<CString>& a_listComboStrings)
	{
		a_listComboStrings.clear();
		switch (a_nId)
		{
			case OTS_RETORT_PROP_GRID_ITEMS::DATA_SOURCE:
			{
				a_listComboStrings = m_listDataSource;
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::DATA_SOURCE_TYPE:
			{
				LoadComboBoxString(a_listComboStrings, (UINT)IDS_DATA_SOUCE_TYPE_FIRST, (int)(DATA_SOURCE_TYPE::MAX) - (int)(DATA_SOURCE_TYPE::MIN) + 1);
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::IMAGE_TYPE:
			{
				LoadComboBoxString(a_listComboStrings, (UINT)IDS_IMAGE_TYPE_FIRST, (int)(IMAGE_TYPE::MAX) - (int)(IMAGE_TYPE::MIN) + 1);
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::IMAGE_DISPLAY_TYPE:
			{
				LoadComboBoxString(a_listComboStrings, (UINT)IDS_IMAGE_DISPLAY_TYPE_FIRST, (int)(IMAGE_DISPLAY_TYPE::MAX) - (int)(IMAGE_DISPLAY_TYPE::MIN) + 1);
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::MEASURE_DATA_TYPE:
			{
				LoadComboBoxString(a_listComboStrings, (UINT)IDS_MEASURE_DATA_TYPE_FIRST, (int)(MEASURE_DATA_TYPE::MAX) - (int)(MEASURE_DATA_TYPE::MIN) + 1);
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::CALCULATE_TABLE_TYPE:
			{
				LoadComboBoxString(a_listComboStrings, (UINT)IDS_CALCULATE_TABLE_TYPE_FIRST, (int)(CALCULATE_TABLE_TYPE::MAX) - (int)(CALCULATE_TABLE_TYPE::MIN) + 1);
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::CALCULATE_CHART_TYPE:
			{
				LoadComboBoxString(a_listComboStrings, (UINT)IDS_CALCULATE_CHART_TYPE_FIRST, (int)(CALCULATE_CHART_TYPE::MAX) - (int)(CALCULATE_CHART_TYPE::MIN) + 1);
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::PARTICLE_TYPE:
			{
				LoadComboBoxString(a_listComboStrings, (UINT)IDS_PARTICLE_TYPE_FIRST, (int)(PARTICLE_TYPE::MAX) - (int)(PARTICLE_TYPE::MIN) + 1);
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::TRIO_CHART_TYPE:
			{
				//LoadComboBoxString(a_listComboStrings, (UINT)IDS_TRIANTEMPLATE_TYPE_FIRST, 8);
				//2019-12-20 modify, using tri template file
				CTriTempItemList lsCtriTempItemList = m_CTriTempFilePtr->GetTriTempItemList();
				for (int i = 0; i < lsCtriTempItemList.size(); i++)
				{
					a_listComboStrings.push_back(lsCtriTempItemList[i]->GetTemplateName());
				}
			}
			break;
			case OTS_RETORT_PROP_GRID_ITEMS::STD_ID:
			{
				LoadComboBoxString(a_listComboStrings, (UINT)IDS_STD_ID_DEFUALT_FIRST, (int)(STD_ID_DEFUALT::MAX) - (int)(STD_ID_DEFUALT::MIN) + 1);
				if (m_pWorkingSTDLib)
				{
					CSTDItemsList& listSTDs = m_pWorkingSTDLib->GetSTDItemsList();
					for (auto pSTD : listSTDs)
					{
						CString strSTDName = pSTD->GetName();
						a_listComboStrings.push_back(strSTDName);
					}
				}
			}
			break;		

			case OTS_RETORT_PROP_GRID_ITEMS::ANALY_PARTICLE_TYPE:
			{
				//加载只有该测量结果分析出的颗粒类型
				//CReportProjFileMgr crpfm;

				//COTSParticleList listParticleAll = crpfm.GetAnalysisParticleList("");
				//CReportProjFileMgr
				//CReportProjFileMgr::GetAnalysisParticleList
				//m_pReportProjFile->get
				

			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_CLASS:
			{
				LoadComboBoxString(a_listComboStrings, (UINT)IDS_SIZE_CLASS_DEFUALT_FIRST, (int)(SIZE_CLASS_DEFUALT::MAX) - (int)(SIZE_CLASS_DEFUALT::MIN) + 1);
				if (m_pWorkingSizeFile)
				{
					auto pList = GetSizeFileList();
					m_pWorkingSizeFile = pList[m_nSizeClassTableId];
					CPartSizeItemList listSizeItem = m_pWorkingSizeFile->GetPartSizeList();
					for (auto pItem : listSizeItem)
					{
						CString strValue = pItem->GetName();
						a_listComboStrings.push_back(strValue);
					}
				}

			}
			break;
			case OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_CLASS_TABLE:
			{
				a_listComboStrings.clear();
				CPartSizeFileList pList = this->GetSizeFileList();
				
				int nPos = -1;

				for (auto sFile : pList)
				{
					
					
				
						CString sName = sFile->GetName();
						a_listComboStrings.push_back(sName);
					
				}
			
				return TRUE;

			}
			//break;
			case OTS_RETORT_PROP_GRID_ITEMS::SIZE_CAL_METHOD_TYPE:
			{
				LoadComboBoxString(a_listComboStrings, (UINT)IDS_SIZE_CAL_METHOD_TYPE_FIRST, (int)(SIZE_CAL_METHOD_TYPE::MAX) - (int)(SIZE_CAL_METHOD_TYPE::MIN) + 1);
			}
			break;

			case OTS_RETORT_PROP_GRID_ITEMS::SIZE_GRID_CAL_METHOD_TYPE:
			{
				LoadComboBoxString(a_listComboStrings, (UINT)IDS_SIZE_GRID_CAL_METHOD_TYPE_FIRST, (int)(SIZE_GRID_CAL_METHOD_TYPE::MAX) - (int)(SIZE_GRID_CAL_METHOD_TYPE::MIN) + 1);
			}
			break;
			
		
			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;
	}

	// string data 
	BOOL CPropParam::GetPropStringData(OTS_RETORT_PROP_GRID_ITEMS a_nId, CString& a_strValue)
	{
		switch (a_nId)
		{
			case OTS_RETORT_PROP_GRID_ITEMS::TRIO_CHART_TYPE:
			{
				a_strValue = GetTrioChartName();
			}
			break;

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

		// ok, return TRUE
		return TRUE;
	}
	BOOL CPropParam::SetPropStringData(OTS_RETORT_PROP_GRID_ITEMS a_nId, CString a_strValue)
	{
		switch (a_nId)
		{
			case OTS_RETORT_PROP_GRID_ITEMS::TRIO_CHART_TYPE:
			{
				return SetTrioChartName(a_strValue);
			}
			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;
	}

	CString CPropParam::GetItemValueStr(OTS_RETORT_PROP_GRID_ITEMS a_nId)
	{
		CString valStr = "";	
		CPropItemPtr itm = GetPropItemById(a_nId);
		switch (itm->GetTypeId())
		{
			case OTS_ITEM_TYPES::DOUBLE:
				{
					DOUBLE dVal = 0;
					if (GetPropDoubleData(a_nId, dVal))
					{

						valStr.Format(_T("%.2f"), dVal);//点后面几个0就保留几位                                                                          
					}

				}
				break;
			case OTS_ITEM_TYPES::STRING:
				{
					CString StrVal = "";
					if (GetPropStringData(a_nId, StrVal))
					{
						valStr = StrVal;
					}

				}
				break;
			case OTS_ITEM_TYPES::COMBO:
				{
					std::vector <CString> StrVal;
					if (GetPropComboStrings(a_nId, StrVal))
					{
						int index = 0;
						GetPropComboData(a_nId, index);
						if (index > (int)StrVal.size() || index<0)
						{
							valStr = StrVal[0];
							break;
						}
						valStr = StrVal[index];
					}

				}
				break;			
			default:
				break;
		}
		return valStr;
	}	

	// protected

	// 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_pWorkingSTDLib = CPartSTDDataPtr(new CPartSTDData());
		m_CTriTempFilePtr = CTriTempFilePtr(new CTriTempFile());
		m_nSTDId = -1;

		m_pWorkingSizeFile = CPartSizeFilePtr(new CPartSizeFile());
		m_nSizeItemId = -1;
		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_pWorkingSTDLib = CPartSTDDataPtr(new CPartSTDData(a_oSource.m_pWorkingSTDLib.get()));
		m_CTriTempFilePtr = CTriTempFilePtr(new CTriTempFile(a_oSource.m_CTriTempFilePtr.get()));
		m_nSTDId = a_oSource.m_nSTDId;
		m_pWorkingSizeFile = CPartSizeFilePtr(new CPartSizeFile(a_oSource.m_pWorkingSizeFile.get()));
		m_nSizeItemId = a_oSource.m_nSizeItemId;
		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;
	}

	// load combo box string
	void CPropParam::LoadComboBoxString(std::vector<CString>& a_listStrings, UINT a_nFirstStringID, int a_nCount)
	{
		//AFX_MANAGE_STATE(AfxGetStaticModuleState());
	
		for (int i = 0; i < a_nCount;  i++)
		{
			
			CString& str=MultiLang::GetInstance ().GetCStringByKey (a_nFirstStringID + i);
			a_listStrings.push_back(str);
		}
	}

	// 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);

			//测试去除后显示
			//if (m_nPartType == PARTICLE_TYPE::ANALYSISED)
			//{
			//	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::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_pWorkingSTDLib = CPartSTDDataPtr(new CPartSTDData(a_oSource.m_pWorkingSTDLib.get()));
		m_nSTDId = a_oSource.m_nSTDId;
		m_pWorkingSizeFile = CPartSizeFilePtr(new CPartSizeFile(a_oSource.m_pWorkingSizeFile.get()));
		m_nSizeItemId = a_oSource.m_nSizeItemId;
		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::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);

			//poPropItem = CPropItemPtr(new CPropItem());
			//poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::SIZE_GRID_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_pWorkingSTDLib = CPartSTDDataPtr(new CPartSTDData(a_oSource.m_pWorkingSTDLib.get()));
		m_nSTDId = a_oSource.m_nSTDId;
		m_pWorkingSizeFile = CPartSizeFilePtr(new CPartSizeFile(a_oSource.m_pWorkingSizeFile.get()));
		m_nSizeItemId = a_oSource.m_nSizeItemId;
		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);

		////element comp
		//if (m_nCalChartType == CALCULATE_CHART_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_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::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);

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

		//去除，颗粒成份图中，颗粒类型列表信息
		//if (m_nCalChartType == CALCULATE_CHART_TYPE::ELEMENT_COMP)
		//{
		//	poPropItem = CPropItemPtr(new CPropItem());
		//	poPropItem->SetReportParameter(OTS_RETORT_PROP_GRID_ITEMS::STD_ID, 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_pWorkingSTDLib = CPartSTDDataPtr(new CPartSTDData(a_oSource.m_pWorkingSTDLib.get()));
		m_nSTDId = a_oSource.m_nSTDId;
		m_pWorkingSizeFile = CPartSizeFilePtr(new CPartSizeFile(a_oSource.m_pWorkingSizeFile.get()));
		m_nSizeItemId = a_oSource.m_nSizeItemId;
		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;
	}

}