#pragma once

#include "CHCommonClasses/MacroFile.h"

class CCHImageData;

#define MAX_BUFFER_SCAN_COUNT	1

enum	TriggerMode		{ ModeFreeRun = 0, ModeInternal, ModeExternal};
enum	TriggerSource	{ SourceAutomatic = 0, SourceTrigger1, SourceTrigger2 };
enum	FlipMode		{ FlipNone = 0, FlipVertical, FlipHorizontal, FlipBoth, FlipCount };
enum	FrameChannel	{ MonoChannel = 1, BGRChannel = 3};
enum	ImageExtension  { BmpExtension = 0, JpgExtension, ImageExtensionCnt};

// camera interface
interface ICameraControl2Parent
{
	virtual BOOL ICC2P_GetCurrentFrame(int nIndex, int nFrameWidth, int nFrameHeight, int nFrameChannels,  CCHImageData* pImageData) = 0;
	virtual BOOL ICC2P_FrameCaptured(int nIndex, int nFrameIndex, int nFrameCount) = 0;
	virtual BOOL ICC2P_SnapCompleted(int nIndex, int nFrameCount) = 0;
	virtual void ICC2P_DisplayMessage(int nIndex, const TCHAR* lpstrFormat, ...) = 0;
};

class CCameraControlInfo
{
public:
	CCameraControlInfo(int nIndex=0) : m_nIndex(nIndex)	{ Reset(); }
	~CCameraControlInfo(void)							{ Reset(); }
	void Reset()
	{
		m_strName			= _T("");
		m_nLibraryType		= 0;
		m_strConnectionPort	= _T("");

		m_nFlipType			= 0;
		m_nGrabberIndex		= -1;
		m_nChannelIndex		= -1;
		m_nFrameWidth		= 0;
		m_nFrameHeight		= 0;
		m_nFrameChannels	= 0;
		m_nGrabCount		= 0;
		m_nFrameCount		= 0;
		m_nImageBufferCount	= 0;

		m_nAxisDirectionX	= 0;
		m_nAxisDirectionY	= 0;
		m_dPixelResolution	= 1.0;

		m_dGainRed			= 1.0;
		m_dGainGreen		= 1.0;
		m_dGainBlue			= 1.0;

		m_strFfcFilename	= _T("");
		m_strCameraFile		= _T("");
	}


	BOOL LoadInfo(CMacroFile* pFile, const CString& strItemName)
	{
		if (pFile==NULL) return FALSE;

		CString strValue = _T("");

		strValue = strItemName + _T("_INDEX");
		pFile->GetItem(strValue, m_nIndex, 0);

		strValue = strItemName + _T("_NAME");
		pFile->GetItem(strValue, m_strName, _T(""));

		strValue = strItemName + _T("_LIBRARY_TYPE");
		pFile->GetItem(strValue, m_nLibraryType, 0);

		strValue = strItemName + _T("_CONNECT_PORT");
		pFile->GetItem(strValue, m_strConnectionPort, _T(""));

		strValue = strItemName + _T("_FLIP_TYPE");
		pFile->GetItem(strValue, m_nFlipType, 0);

		strValue = strItemName + _T("_GRABBER_INDEX");
		pFile->GetItem(strValue, m_nGrabberIndex, -1);

		strValue = strItemName + _T("_CHANNEL_INDEX");
		pFile->GetItem(strValue, m_nChannelIndex, -1);

		strValue = strItemName + _T("_FRAME_WIDTH");
		pFile->GetItem(strValue, m_nFrameWidth, 0);

		strValue = strItemName + _T("_FRAME_HEIGHT");
		pFile->GetItem(strValue, m_nFrameHeight, 0);

		strValue = strItemName + _T("_FRAME_CHANNELS");
		pFile->GetItem(strValue, m_nFrameChannels, 0);

		strValue = strItemName + _T("_GRAB_COUNT");
		pFile->GetItem(strValue, m_nGrabCount, 0);

		strValue = strItemName + _T("_FRAME_COUNT");
		pFile->GetItem(strValue, m_nFrameCount, 0);

		strValue = strItemName + _T("_IMAGE_BUFFER_COUNT");
		pFile->GetItem(strValue, m_nImageBufferCount, 0);

		strValue = strItemName + _T("_AXIS_DIRECTION_X");
		pFile->GetItem(strValue, m_nAxisDirectionX, 0);

		strValue = strItemName + _T("_AXIS_DIRECTION_Y");
		pFile->GetItem(strValue, m_nAxisDirectionY, 0);

		strValue = strItemName + _T("_PIXEL_RESOLUTION");
		pFile->GetItem(strValue, m_dPixelResolution, 1.0);

		strValue = strItemName + _T("_GAIN_RED");
		pFile->GetItem(strValue, m_dGainRed, 1.0);

		strValue = strItemName + _T("_GAIN_GREEN");
		pFile->GetItem(strValue, m_dGainGreen, 1.0);

		strValue = strItemName + _T("_GAIN_BLUE");
		pFile->GetItem(strValue, m_dGainBlue, 1.0);

		strValue = strItemName + _T("_FFC_FILE_NAME");
		pFile->GetItem(strValue, m_strFfcFilename, _T(""));

		return TRUE;
	}

	BOOL SaveInfo(CMacroFile* pFile, const CString& strItemName)
	{
		if (pFile==NULL) return FALSE;

		CString strValue = _T("");

		strValue = strItemName + _T("_INDEX");
		pFile->SetItem(strValue, m_nIndex);

		strValue = strItemName + _T("_NAME");
		pFile->SetItem(strValue, m_strName);

		strValue = strItemName + _T("_LIBRARY_TYPE");
		pFile->SetItem(strValue, m_nLibraryType);

		strValue = strItemName + _T("_CONNECT_PORT");
		pFile->SetItem(strValue, m_strConnectionPort);

		strValue = strItemName + _T("_FLIP_TYPE");
		pFile->SetItem(strValue, m_nFlipType);

		strValue = strItemName + _T("_GRABBER_INDEX");
		pFile->SetItem(strValue, m_nGrabberIndex);

		strValue = strItemName + _T("_CHANNEL_INDEX");
		pFile->SetItem(strValue, m_nChannelIndex);

		strValue = strItemName + _T("_FRAME_WIDTH");
		pFile->SetItem(strValue, m_nFrameWidth);

		strValue = strItemName + _T("_FRAME_HEIGHT");
		pFile->SetItem(strValue, m_nFrameHeight);

		strValue = strItemName + _T("_FRAME_CHANNELS");
		pFile->SetItem(strValue, m_nFrameChannels);

		strValue = strItemName + _T("_GRAB_COUNT");
		pFile->SetItem(strValue, m_nGrabCount);

		strValue = strItemName + _T("_FRAME_COUNT");
		pFile->SetItem(strValue, m_nFrameCount);

		strValue = strItemName + _T("_IMAGE_BUFFER_COUNT");
		pFile->SetItem(strValue, m_nImageBufferCount);

		strValue = strItemName + _T("_AXIS_DIRECTION_X");
		pFile->SetItem(strValue, m_nAxisDirectionX);

		strValue = strItemName + _T("_AXIS_DIRECTION_Y");
		pFile->SetItem(strValue, m_nAxisDirectionY);

		strValue = strItemName + _T("_PIXEL_RESOLUTION");
		pFile->SetItem(strValue, m_dPixelResolution);

		strValue = strItemName + _T("_GAIN_RED");
		pFile->SetItem(strValue, m_dGainRed);

		strValue = strItemName + _T("_GAIN_GREEN");
		pFile->SetItem(strValue, m_dGainGreen);

		strValue = strItemName + _T("_GAIN_BLUE");
		pFile->SetItem(strValue, m_dGainBlue);

		strValue = strItemName + _T("_FFC_FILE_NAME");
		pFile->SetItem(strValue, m_strFfcFilename);

		return TRUE;
	}

	// getter
	int	CCameraControlInfo::GetIndex() const
	{
		return m_nIndex;
	}

	CString	CCameraControlInfo::GetName() const
	{
		return m_strName;
	}

	int	CCameraControlInfo::GetLibraryType() const
	{
		return m_nLibraryType;
	}

	CString	CCameraControlInfo::GetConnectionPort() const
	{
		return m_strConnectionPort;
	}

	int	CCameraControlInfo::GetFlipType() const
	{
		return m_nFlipType;
	}

	int	CCameraControlInfo::GetGrabberIndex() const
	{
		return m_nGrabberIndex;
	}

	int	CCameraControlInfo::GetChannelIndex() const
	{
		return m_nChannelIndex;
	}

	int	CCameraControlInfo::GetFrameWidth() const
	{
		return m_nFrameWidth;
	}

	int	CCameraControlInfo::GetFrameHeight() const
	{
		return m_nFrameHeight;
	}

	int	CCameraControlInfo::GetFrameChannels() const
	{
		return m_nFrameChannels;
	}

	int	CCameraControlInfo::GetGrabCount() const
	{
		return m_nGrabCount;
	}

	int	CCameraControlInfo::GetFrameCount() const
	{
		return m_nFrameCount;
	}

	int	CCameraControlInfo::GetImageBufferCount() const
	{
		return m_nImageBufferCount;
	}

	int	CCameraControlInfo::GetAxisDirectionX() const
	{
		return m_nAxisDirectionX;
	}

	int	CCameraControlInfo::GetAxisDirectionY() const
	{
		return m_nAxisDirectionY;
	}

	double GetPixelResolution() const
	{
		return m_dPixelResolution;
	}

	double GetGainRed() const
	{
		return m_dGainRed;
	}

	double GetGainGreen() const
	{
		return m_dGainGreen;
	}

	double GetGainBlue() const
	{
		return m_dGainBlue;
	}

	CString GetFfcFilename() const
	{
		return m_strFfcFilename;
	}

	CString GetCameraFile() const
	{
		return m_strCameraFile;
	}

	// setter
	void SetIndex(int nIndex)
	{
		m_nIndex = nIndex;
	}

	void SetName(const CString& strName)
	{
		m_strName = strName;
	}

	void SetLibraryType(int nType)
	{
		m_nLibraryType = nType;
	}

	void SetConnectionPort(const CString& strPort)
	{
		m_strConnectionPort = strPort;
	}

	void SetFlipType(int nType)
	{
		m_nFlipType = nType;
	}

	void SetGrabberIndex(int nIndex)
	{
		m_nGrabberIndex = nIndex;
	}

	void SetChannelIndex(int nIndex)
	{
		m_nChannelIndex = nIndex;
	}

	void SetFrameWidth(int nWidth)
	{
		m_nFrameWidth = nWidth;
	}

	void SetFrameHeight(int nHeight)
	{
		m_nFrameHeight = nHeight;
	}

	void SetFrameChannels(int nChannels)
	{
		m_nFrameChannels = nChannels;
	}

	void SetGrabCount(int nCount)
	{
		m_nGrabCount = nCount;
	}

	void SetFrameCount(int nCount)
	{
		m_nFrameCount = nCount;
	}

	void SetImageBufferCount(int nCount)
	{
		m_nImageBufferCount = nCount;
	}


	void SetAxisDirectionX(int nDir)
	{
		m_nAxisDirectionX = nDir;
	}

	void SetAxisDirectionY(int nDir)
	{
		m_nAxisDirectionY = nDir;
	}

	void SetPixelResolution(double dRes)
	{
		m_dPixelResolution = dRes;
	}

	void SetGainRed(double dGain)
	{
		m_dGainRed = dGain;
	}

	void SetGainGreen(double dGain)
	{
		m_dGainGreen = dGain;
	}

	void SetGainBlue(double dGain)
	{
		m_dGainBlue = dGain;
	}

	void SetFfcFilename(const CString& strFilename)
	{
		m_strFfcFilename = strFilename;
	}

	void SetCameraFile(const CString& strCameraFile)
	{
		m_strCameraFile = strCameraFile;
	}
		
protected:
	int			m_nIndex;					// À妽º
	CString		m_strName;					//Ä«¸Þ¶ó À̸§
	
	int			m_nLibraryType;				// ¶óÀ̺귯¸® ŸÀÔ
	CString		m_strConnectionPort;		// ¿¬°á Æ÷Æ®

	int			m_nFlipType;				//Ä«¸Þ¶ó FLIP ŸÀÔ
	int			m_nGrabberIndex;			//Ä«¸Þ¶ó ±×·¡¹ö À妽º
	int			m_nChannelIndex;			//Ä«¸Þ¶ó ä³Î À妽º
	int			m_nFrameWidth;				//Ä«¸Þ¶ó ÇÁ·¹ÀÓ ³ÐÀÌ
	int			m_nFrameHeight;				//Ä«¸Þ¶ó ÇÁ·¹ÀÓ ³ôÀÌ
	int			m_nFrameChannels;			//Ä«¸Þ¶ó ä³Î ¼ö
	int			m_nGrabCount;				//±×·¦ÆÛ¹ö¼ö
	int			m_nFrameCount;				//Ä«¸Þ¶ó ÇÁ·¹ÀÓ °³¼ö
	int			m_nImageBufferCount;		//À̹ÌÁö ¹öÆÛ °³¼ö
	
	int			m_nAxisDirectionX;			//Ä«¸Þ¶ó XÃà ¹æÇâ
	int			m_nAxisDirectionY;			//Ä«¸Þ¶ó YÃà ¹æÇâ
	double		m_dPixelResolution;			//Ä«¸Þ¶ó ÇØ»óµµ
	
	double		m_dGainRed;					//Ä«¸Þ¶ó Gain
	double		m_dGainGreen;				//Ä«¸Þ¶ó Gain
	double		m_dGainBlue;				//Ä«¸Þ¶ó Gain	

	CString		m_strFfcFilename;			//FFC Image
	CString		m_strCameraFile;
};