// ITPDlg.cpp : Implementation file
//

#include "stdafx.h"
#include "RemoteTest.h"
#include "ITPDlg.h"
#include "Cpcinfo.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


/////////////////////////////////////////////////////////////////////////////
// define

int		nImageSize[ MAX_E_IMAGE_SIZE_ID ][ 2 ] = {
			{ 204, 159 },		// Normal
			{ 412, 318 }		// Expanded
};

/////////////////////////////////////////////////////////////////////////////
// CITPDlg  dialog


CITPDlg::CITPDlg(CVAIBO *vaibo, CWnd* pParent /*=NULL*/)
	: CDialog(CITPDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CITPDlg)
	//}}AFX_DATA_INIT
	m_imageBuf = NULL;
	m_imageBufLen = 0;
	m_vaibo = vaibo;
}


void CITPDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CITPDlg)
	DDX_Control(pDX, IDC_COMBO_RATE, m_skipCombo);
	DDX_Control(pDX, IDC_PROGRESS_PSD, m_psdProgress);
	DDX_Control(pDX, IDC_SLIDER_EXPOSURE, m_sliderExposure);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CITPDlg, CDialog)
	//{{AFX_MSG_MAP(CITPDlg)
	ON_BN_CLICKED(IDC_BTN_PICTURE, OnBtnPicture)
	ON_BN_CLICKED(IDC_BTN_SET, OnBtnSet)
	ON_BN_CLICKED(IDC_BTN_START, OnBtnStart)
	ON_BN_CLICKED(IDC_BTN_STOP, OnBtnStop)
	ON_BN_CLICKED( IDC_RADIO_CAMERA_AUTO, OnRadioCameraAuto )
	ON_BN_CLICKED( IDC_RADIO_CAMERA_MANUAL, OnRadioCameraManual )
	ON_BN_CLICKED( IDC_RADIO_CAMERA_AE_AWB, OnRadioCameraAEAWB )
	ON_BN_CLICKED( IDC_RADIO_SSPEED0, OnRadioSSpeed0 )
	ON_BN_CLICKED( IDC_RADIO_SSPEED1, OnRadioSSpeed1 )
	ON_WM_DESTROY()
	ON_WM_TIMER()
	ON_WM_CLOSE()
	ON_WM_HSCROLL()
	ON_BN_CLICKED(IDC_BTN_SUSRES, OnBtnSusRes)
	ON_BN_CLICKED( IDC_RADIO_NORMAL_SIZE, OnRadioNormalSize )
	ON_BN_CLICKED( IDC_RADIO_EXPANSION_SIZE, OnRadioExpansionSize )
	ON_BN_CLICKED( IDC_RADIO_IMAGE_SIZE1, OnRadioImageSize1 )
	ON_BN_CLICKED( IDC_RADIO_IMAGE_SIZE2, OnRadioImageSize2 )
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CITPDlg message handlers

void CITPDlg::OnOK()
{
	CDialog::OnOK();
}

void CITPDlg::OnBtnSet()
{
	m_skip = m_skipCombo.GetCurSel();
	m_vaibo->SendCmd( APPCMD_IMAGE_SETPARAM, true, CMDSID_SKIPFRAME, m_skip );
}

void CITPDlg::OnBtnStart()
{
	m_vaibo->SendCmd( APPCMD_IMAGE_PLAY );
	SetTimer( 100, 1000/*ms*/, NULL );
	m_playF = TRUE;
}

void CITPDlg::OnBtnStop()
{
	CRect			rect;

	CWnd			*wnd = GetDlgItem(IDC_STATIC_IMAGE);
	wnd->GetWindowRect(&rect);
	this->ScreenToClient(&rect);

	m_playF = FALSE;
	m_vaibo->SendCmd( APPCMD_IMAGE_STOP );
	InvalidateRect( &rect );
	KillTimer( 100 );
}

void	CITPDlg::ResizeImageSize()
{
	#define		NUM_BTN		( 31 )
	int		nControlID[ NUM_BTN ] = {

				IDC_EDIT_RATE,
				IDC_COMBO_RATE,
				IDC_BTN_SET,
				IDC_BTN_START,
				IDC_BTN_STOP,
				IDC_BTN_SUSRES,
				IDC_BTN_PICTURE,

				IDC_PROGRESS_PSD,

				IDC_RADIO_CAMERA_AUTO,
				IDC_RADIO_CAMERA_MANUAL,
				IDC_RADIO_CAMERA_AE_AWB,
				IDC_RADIO_SSPEED0,
				IDC_RADIO_SSPEED1,
				IDC_EDIT_EXPOSURE,
				IDC_SLIDER_EXPOSURE,

				IDC_RADIO_IMAGE_SIZE1,
				IDC_RADIO_IMAGE_SIZE2,
				IDC_RADIO_NORMAL_SIZE,
				IDC_RADIO_EXPANSION_SIZE,

				IDOK,

				IDC_STATIC_1,
				IDC_STATIC_2,
				IDC_STATIC_3,
				IDC_STATIC_4,
				IDC_STATIC_5,
				IDC_STATIC_6,
				IDC_STATIC_7,
				IDC_STATIC_8,
				IDC_STATIC_9,
				IDC_STATIC_IMAGE_SIZE,
				IDC_STATIC_VIEW_SIZE,
	};

	// Find a new image size.
	int		nNewViewWidth = nImageSize[ m_nImageSizeID ][ 0 ];
	int		nNewViewHeight = nImageSize[ m_nImageSizeID ][ 1 ];
	if ( m_isExpansion ) {
		if ( m_nImageSizeID == E_IMAGE_SIZE_ID_0 ) {
			nNewViewWidth *= 2;		// Two times
			nNewViewHeight *= 2;
		}
		else {
			nNewViewWidth = nNewViewWidth * 3 / 2;		// 1.5 times
			nNewViewHeight = nNewViewHeight * 3 / 2;
		}
	}

	// Find the difference.
	int		nAddWidth = nNewViewWidth - m_nViewWidth;
	int		nAddHeight = nNewViewHeight - m_nViewHeight;


	// Current size
	CRect	rect;
	GetWindowRect( &rect );
	CWnd	*wnd = GetDlgItem( IDC_STATIC_IMAGE );

	// Rearrange the screen
	SetWindowPos( NULL, 0, 0, rect.Width() + nAddWidth, rect.Height() + nAddHeight,
                  SWP_NOMOVE | SWP_NOOWNERZORDER );
	wnd->SetWindowPos( NULL, 0, 0, nNewViewWidth, nNewViewHeight,
                       SWP_NOMOVE | SWP_NOZORDER | SWP_NOOWNERZORDER );
	for ( int i = 0; i < NUM_BTN; i++ ) {
		CWnd*	wndControl = GetDlgItem( nControlID[ i ] );
		CRect	rectControl;
		wndControl->GetWindowRect( &rectControl );
		ScreenToClient( rectControl );
		wndControl->SetWindowPos( NULL, rectControl.left + nAddWidth,
                                  rectControl.top + nAddHeight, rectControl.Width(),
                                  rectControl.Height(),
                                  SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER );
	}

	Invalidate();
	UpdateWindow();

	// Change the screen size
	m_nViewWidth  = nNewViewWidth;
	m_nViewHeight = nNewViewHeight;

}

void	CITPDlg::OnRadioImageSize1()
{
	if ( m_vaibo ) {
		m_vaibo->SendCmd( APPCMD_IMAGE_SETPARAM, true, CMDSID_PROFILE, IMAGE_PROFILE_MID );
	}

	if ( m_nImageSizeID != E_IMAGE_SIZE_ID_0 ) {
		m_nImageSizeID = E_IMAGE_SIZE_ID_0;
		ResizeImageSize();
	}
}

void	CITPDlg::OnRadioImageSize2()
{
	if ( m_vaibo ) {
		m_vaibo->SendCmd( APPCMD_IMAGE_SETPARAM, true, CMDSID_PROFILE, IMAGE_PROFILE_HIGH );
	}

	if ( m_nImageSizeID != E_IMAGE_SIZE_ID_1 ) {
		m_nImageSizeID = E_IMAGE_SIZE_ID_1;
		ResizeImageSize();
	}
}

void	CITPDlg::OnRadioNormalSize()
{
	if ( m_isExpansion ) {
		m_isExpansion = false;
		ResizeImageSize();
	}
}

void	CITPDlg::OnRadioExpansionSize()
{
	if ( !m_isExpansion ) {
		m_isExpansion = true;
		ResizeImageSize();
	}
}

void CITPDlg::OnDestroy()
{
	CDialog::OnDestroy();

	if ( m_imageBuf ) free( m_imageBuf );
}

BOOL CITPDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	// ERS-7
	if ( m_vaibo->GetRobotDesign() == DESIGN_ERS7 ) {
		m_psdProgress.SetRange( 0, 150 );
	}
	// Other robot design
	else {
		m_psdProgress.SetRange( 0, 90 );
	}

	radioSSpeed0().SetCheck( BST_CHECKED );
	m_sliderExposure.SetRange( CAMERA_EXPOSURE_MIN, CAMERA_EXPOSURE_MAX );
	m_sliderExposure.SetPos( CAMERA_EXPOSURE_DEFAULT );
	m_sliderExposure.SetTicFreq( 2 );		// Interval
	CString		strExposure;
	strExposure.Format( "%d", m_sliderExposure.GetPos() );
	editExposure().SetWindowText( strExposure );


	m_isExpansion = false;	// Expanded flag
	m_nImageSizeID = E_IMAGE_SIZE_ID_0;
	m_nViewWidth = nImageSize[ m_nImageSizeID ][ 0 ];
	m_nViewHeight = nImageSize[ m_nImageSizeID ][ 1 ];

	CWnd	*wnd = GetDlgItem( IDC_STATIC_IMAGE );
    // Set ERS-7 camera size
	wnd->SetWindowPos( NULL, 0, 0, m_nViewWidth, m_nViewHeight,
                       SWP_NOMOVE | SWP_NOOWNERZORDER );
	radioImageSize1().SetCheck( BST_CHECKED );
	radioViewSizeNormal().SetCheck( BST_CHECKED );

	SetTimer(27, 2000, NULL);

	return TRUE;   // return TRUE  unless you set the focus to a control
}

void CITPDlg::OnTimer(UINT nIDEvent)
{
	if ( nIDEvent == 27) {
		CWnd *wnd = GetDlgItem(IDC_STATIC_IMAGE);
		CWnd *wnd2 = this;
		m_vaibo->ImageSetWindowHandle(
            ::GetDlgItem(::FindWindow(NULL, _T("ImageTP")),
                         IDC_STATIC_IMAGE), ::FindWindow(NULL, _T("ImageTP")));
		KillTimer(27);
	}
	if ( nIDEvent == 100 ) {
		m_frameRate = m_vaibo->ImageGetFrameRate();
		SetDlgItemInt( IDC_EDIT_RATE, m_frameRate );
		m_frameRate = 0;
	}

	CDialog::OnTimer(nIDEvent);
}

void CITPDlg::OnClose()
{
	if ( m_playF ) {
		KillTimer( 100 );
	}

	CDialog::OnClose();
}

void CITPDlg::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
	if ( ( CSliderCtrl* )pScrollBar == &m_sliderExposure ) {
		int			nExposure = m_sliderExposure.GetPos();
		CString		strExposure;
		strExposure.Format( "%d", nExposure );
		editExposure().SetWindowText( strExposure );
		// If manual mode
		if ( radioCameraManual().GetCheck() == BST_CHECKED ) {
			// Change exposure
			if ( m_vaibo->CameraSetParamExposure( nExposure ) ) {
				// Normal termination
			}
			else {
				// Erase value because it is an unknown condition.
				editExposure().SetWindowText( "" );
			}
		}
	}

	CDialog::OnHScroll(nSBCode, nPos, pScrollBar);
}

void CITPDlg::SetPSDValue(int numOfData, SensorRec *pRecArray)
{
	int		i;

	for ( i = 0; i < numOfData; i++ ) {
		// ERS-7
		if ( m_vaibo->GetRobotDesign() == DESIGN_ERS7 ) {
			if ( pRecArray[i].sensorID == PSDWithXY_FN ) {
				m_psdProgress.SetPos( pRecArray[i].value / 10000 );
			}
		}
		// Other robot design
		else {
			if ( pRecArray[i].sensorID == PSDWithXY ) {
				m_psdProgress.SetPos( pRecArray[i].value / 10000 );
			}
		}
	}
}


// Automatic camera control mode.
void	CITPDlg::OnRadioCameraAuto()
{
	// Automatic setting of the camera mode
	if ( m_vaibo->CameraSetModeDefault() ) {
		// Normal termination
	}
	else {
		// Uncheck, because of an unknown condition.
		radioCameraAuto().SetCheck( BST_UNCHECKED );
	}
}

// Manual camera control mode.
void	CITPDlg::OnRadioCameraManual()
{
	// Get shutter speed.
	int		nSSpeed = CAMERA_SHUTTERSPEED_DEFAULT;
	if ( radioSSpeed0().GetCheck() == BST_CHECKED ) {
		nSSpeed = CAMERA_SHUTTERSPEED_PER_10MS;	// Shutter speed 1/100[sec] = 10[ms]
	}
	else if ( radioSSpeed1().GetCheck() == BST_CHECKED ) {
		nSSpeed = CAMERA_SHUTTERSPEED_PER_20MS;	// Shutter speed 1/ 50[sec] = 20[ms]
	}

	// Get exposure.
	int		nExposure = m_sliderExposure.GetPos();

	// Manually set the camera mode parameters
	if ( m_vaibo->CameraSetModeManual( nSSpeed, nExposure ) ) {
		// Normal termination
	}
	else {
		// Uncheck, because of an unknown condition.
		radioCameraManual().SetCheck( BST_UNCHECKED );
	}
}

// AE/AWB camera control mode
void	CITPDlg::OnRadioCameraAEAWB()
{
	// AE (Auto Exposure) and AWB (Auto White Balance)
	if ( m_vaibo->CameraSetModeAEAWB() ) {
		// Normal termination
	}
	else {
		// Uncheck, because of an unknown condition.
		radioCameraAEAWB().SetCheck( BST_UNCHECKED );
	}
}

// Change shutter speed to 1/100 sec
void	CITPDlg::OnRadioSSpeed0()
{
	// If manual mode
	if ( radioCameraManual().GetCheck() == BST_CHECKED ) {

		// Manually set the camera parameter (shutter speed)
		if ( m_vaibo->CameraSetParamShutterSpeed( CAMERA_SHUTTERSPEED_PER_10MS ) ) {
			// Normal termination
		}
		else {
		// Uncheck, because of an unknown condition.
			radioSSpeed0().SetCheck( BST_UNCHECKED );
		}
	}
}

// Change shutter speed to 1/50 sec
void	CITPDlg::OnRadioSSpeed1()
{
	// if manual mode
	if ( radioCameraManual().GetCheck() == BST_CHECKED ) {

		// Manually set the camera parameter (shutter speed)
		if ( m_vaibo->CameraSetParamShutterSpeed( CAMERA_SHUTTERSPEED_PER_20MS ) ) {
			// Normal termination
		}
		else {
		// Uncheck, because of an unknown condition.
			radioSSpeed1().SetCheck( BST_UNCHECKED );
		}
	}
}

void	CITPDlg::OnBtnPicture()
{
	CString strFile;
	CFileDialog	dlg(FALSE, "BMP", NULL, OFN_FILEMUSTEXIST, NULL, this );
	if ( dlg.DoModal() == IDOK ) {
		strFile = dlg.GetPathName();
		m_vaibo->ImageOutputCaptureData(strFile);
	}
}

void CITPDlg::OnBtnSusRes()
{
	if (m_playF) {
		GetDlgItem(IDC_BTN_SUSRES)->SetWindowText( "Play" );
		m_vaibo->ImagePause();
		m_playF = FALSE;
	} else {
		GetDlgItem(IDC_BTN_SUSRES)->SetWindowText( "Pause" );
		m_vaibo->ImageResume();
		m_playF = TRUE;
	}
}