#include "StdAfx.h"
#include "../CHCameraControls/CameraControlInfo.h"
#include "MacroFile.h"

CCameraControlInfo::CCameraControlInfo(int nIndex) : m_nIndex(nIndex)
{
	Reset();
}

CCameraControlInfo::~CCameraControlInfo(void)
{
	Reset();
}

void CCameraControlInfo::Reset()
{
	m_nIndex			= 0;
	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_strExternalPath	= _T("");
	m_strInternalPath	= _T("");
	m_strAlignPath1 = _T("");
	m_strAlignPath2 = _T("");
	m_dwExternalDelayTime = 0;
	m_dwInternalDelayTime = 0;
}


BOOL CCameraControlInfo::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(""));

	strValue = strItemName + _T("_INTERNAL_PATH");
	pFile->GetItem(strValue, m_strInternalPath, _T(""));

	strValue = strItemName + _T("_EXTERNAL_PATH");
	pFile->GetItem(strValue, m_strExternalPath, _T(""));

	strValue = strItemName + _T("_INTERNAL_DELAY");
	pFile->GetItem(strValue, m_dwInternalDelayTime, 0);

	strValue = strItemName + _T("_EXTERNAL_DELAY");
	pFile->GetItem(strValue, m_dwExternalDelayTime, 0);

	return TRUE;
}

BOOL CCameraControlInfo::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);

	strValue = strItemName + _T("_INTERNAL_PATH");
	pFile->SetItem(strValue, m_strInternalPath);

	strValue = strItemName + _T("_EXTERNAL_PATH");
	pFile->SetItem(strValue, m_strExternalPath);

	strValue = strItemName + _T("_INTERNAL_DELAY");
	pFile->SetItem(strValue, m_dwInternalDelayTime);

	strValue = strItemName + _T("_EXTERNAL_DELAY");
	pFile->SetItem(strValue, m_dwExternalDelayTime);

	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 CCameraControlInfo::GetPixelResolution() const
{
	return m_dPixelResolution;
}

double CCameraControlInfo::GetGainRed() const
{
	return m_dGainRed;
}

double CCameraControlInfo::GetGainGreen() const
{
	return m_dGainGreen;
}

double CCameraControlInfo::GetGainBlue() const
{
	return m_dGainBlue;
}

CString CCameraControlInfo::GetFfcFilename() const
{
	return m_strFfcFilename;
}

CString CCameraControlInfo::GetExternalPath() const
{
	return m_strExternalPath;
}

CString CCameraControlInfo::GetInternalPath() const
{
	return m_strInternalPath;
}

CString CCameraControlInfo::GetAlignPath1() const
{
	return m_strAlignPath1;
}


CString CCameraControlInfo::GetAlignPath2() const
{
	return m_strAlignPath2;
}


UINT CCameraControlInfo::GetExternalDelay() const
{
	return m_dwExternalDelayTime;
}

UINT CCameraControlInfo::GetInternalDelay() const
{
	return m_dwInternalDelayTime;
}


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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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


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

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

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

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

void CCameraControlInfo::SetExternalPath(const CString& strFilePath)
{
	m_strExternalPath = strFilePath;
}

void CCameraControlInfo::SetInternalPath(const CString& strFilePath)
{
	m_strInternalPath = strFilePath;
}

void CCameraControlInfo::SetAlignPath1(const CString& strFilePath)
{
	m_strAlignPath1 = strFilePath;
}

void CCameraControlInfo::SetAlignPath2(const CString& strFilePath)
{
	m_strAlignPath2 = strFilePath;
}

void CCameraControlInfo::SetExternalDelay(UINT	dwDelay)
{
	m_dwExternalDelayTime = dwDelay;
}

void CCameraControlInfo::SetInternalDelay(UINT	dwDelay)
{
	m_dwInternalDelayTime = dwDelay;
}