// Dlg7kSonarParams.cpp : implementation file
//

#include "stdafx.h"
#include "6046dryend.h"
#include "6046dryendDlg.h"
#include "Dlg7kSonarParams.h"
#include "7kXMLParsor.h"


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

/////////////////////////////////////////////////////////////////////////////
// CDlg7kSonarParams dialog


CDlg7kSonarParams::CDlg7kSonarParams(CWnd* pParent /*=NULL*/)
	: CDialog(CDlg7kSonarParams::IDD, pParent)
{
	//{{AFX_DATA_INIT(CDlg7kSonarParams)
	//}}AFX_DATA_INIT

	m_bPingEnabled = TRUE;
	m_wSysEnum = 0;
	m_dwSysID = 0;

	range = pulse = rate = power = gain = 0;

	m_dMinPower = 0;
	m_dMaxPower = 0;

	m_dMinRange= 0;
	m_dMaxRange= 0;
	m_dMinGain= 0;
	m_dMaxGain= 0;
	m_dMinPower= 0;
	m_dMaxPower= 0;
	m_dPowerRange= 0;
	m_dMinPulseLength= 0;
	m_dMaxPulseLength= 0;
	m_dMaxPingRate= 0;
	m_dMinMaxPingRate= 0;
	m_dMaxMaxPingRate= 0;
	m_fLastSampRate= 0;	
	m_dPowerPercent = 0;
}


void CDlg7kSonarParams::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CDlg7kSonarParams)
	DDX_Control(pDX, IDC_STATIC_GAIN, m_ctrlStaticGain);
	DDX_Control(pDX, IDC_SCROLLBAR_GAIN, m_ctrlScrollBarGain);
	DDX_Control(pDX, IDC_SCROLLBAR_RATE, m_ctrlScrollBarMaxPingRate);
	DDX_Control(pDX, IDC_SCROLLBAR_RANGE, m_ctrlScrollBarRange);
	DDX_Control(pDX, IDC_SCROLLBAR_PULSE, m_ctrlScrollBarPulseLength);
	DDX_Control(pDX, IDC_SCROLLBAR_POWER, m_ctrlScrollBarPower);
	DDX_Control(pDX, IDC_STATIC_RATE, m_ctrlStaticRate);
	DDX_Control(pDX, IDC_STATIC_PULSE, m_ctrlStaticPulse);
	DDX_Control(pDX, IDC_STATIC_RANGE, m_ctrlStaticRange);
	DDX_Control(pDX, IDC_STATIC_POWER, m_ctrlStaticPower);
	DDX_Control(pDX, IDC_CHECK_PING, m_ctrlCheckPing);
	DDX_Control(pDX, IDC_BUTTON_UPDATE, m_ctrlBtnUpdate);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CDlg7kSonarParams, CDialog)
	//{{AFX_MSG_MAP(CDlg7kSonarParams)
	ON_BN_CLICKED(IDC_BUTTON_UPDATE, OnButtonUpdate)
	ON_BN_CLICKED(IDC_CHECK_PING, OnCheckPing)
	ON_WM_HSCROLL()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

double RANGES[] = {5, 7.5, 10, 15, 20, 25, 30, 35, 40, 50, 75, 100, 125, 150, 175, 200, 250, 300, 350, 400, 500, 750, 1000, 1250, 1500.0, 1750.0, 2000.0, 2500.0, 3000.0, 3500.0,
                  4000.0, 4500.0, 5000.0, 5500.0, 6000.0, 6500.0, 7000.0, 7500.0, 10000.0, 12500.0, 15000.0};


/////////////////////////////////////////////////////////////////////////////
// CDlg7kSonarParams message handlers


void CDlg7kSonarParams::SetSensorIndex(UINT index)
{
	m_dSensorIndex = index;
}
	

BOOL CDlg7kSonarParams::PreTranslateMessage(MSG* pMsg) 
{
	if(pMsg->message == WM_KEYDOWN && pMsg->wParam == VK_ESCAPE)
	{
		return TRUE ;
	}
	if(pMsg->message==WM_KEYDOWN && pMsg->wParam==VK_CANCEL)
	{
		return TRUE ;
	}

	m_ToolTips.RelayEvent(pMsg);
	
	return CDialog::PreTranslateMessage(pMsg);
}

BOOL CDlg7kSonarParams::OnInitDialog() 
{
	CDialog::OnInitDialog();
	
	m_pConfig = &((CMy6046DryEndApp*)AfxGetApp())->m_SystemConfig;
	m_pMainWnd = (CMy6046DryEndDlg*)AfxGetMainWnd();

	if(!m_ToolTips.Create(this))
	{
		TRACE("FAILED TOOL TIPS\r\n");
	}


	LoadSettings();

	CString temp;
	//New font for current settings
	//this mimics the current 7K UI
	LOGFONT lf;
	CFont newf;
	CFont * f;
	f = m_ctrlStaticRange.GetFont(); //use just one of the controls to get the font info
	f->GetLogFont(&lf);
	lf.lfWeight = 700;
	newf.CreateFontIndirect(&lf);

	m_ctrlStaticRange.SetFont(&newf);
	m_ctrlStaticPower.SetFont(&newf);
	m_ctrlStaticRate.SetFont(&newf);
	m_ctrlStaticPulse.SetFont(&newf);
	m_ctrlStaticGain.SetFont(&newf);

	
	m_ctrlCheckPing.SetShade(SHS_METAL,8,40,18,RGB(0,155,0));
	m_ctrlBtnUpdate.SetShade(SHS_METAL,8,40,6,RGB(55,0,0));

	m_ctrlCheckPing.SetCheck(m_bPingEnabled);
	
	if(m_bPingEnabled)
		m_ctrlCheckPing.SetWindowText("ENABLED");
	else
		m_ctrlCheckPing.SetWindowText("DISABLED");


	//Disable all the sliders until we receive the XML data
	m_ctrlScrollBarMaxPingRate.EnableWindow(FALSE);
	m_ctrlScrollBarRange.EnableWindow(FALSE);
	m_ctrlScrollBarPulseLength.EnableWindow(FALSE);
	m_ctrlScrollBarPower.EnableWindow(FALSE);
	m_ctrlScrollBarGain.EnableWindow(FALSE);
	m_ctrlCheckPing.EnableWindow(FALSE);
	m_ctrlBtnUpdate.EnableWindow(FALSE);
	
	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

void CDlg7kSonarParams::InitControls(void)
{
	C7kXMLParsor *pParsor = (C7kXMLParsor*)&((CMy6046DryEndDlg*)AfxGetMainWnd())->m_xmlParsor;

	//double a,b;

	m_ctrlScrollBarMaxPingRate.EnableWindow(TRUE);
	m_ctrlScrollBarRange.EnableWindow(TRUE);
	m_ctrlScrollBarPulseLength.EnableWindow(TRUE);
	m_ctrlScrollBarPower.EnableWindow(TRUE);
	m_ctrlScrollBarGain.EnableWindow(TRUE);

	pParsor->GetMinRange(&m_dMinRange);
	pParsor->GetMaxRange(&m_dMaxRange);
	pParsor->GetMinGain(&m_dMinGain);
	pParsor->GetMaxGain(&m_dMaxGain);
	pParsor->GetMinPower(&m_dMinPower);
	pParsor->GetMaxPower(&m_dMaxPower);
	pParsor->GetMinPulseLength(&m_dMinPulseLength);
	pParsor->GetMaxPulseLength(&m_dMaxPulseLength);
	pParsor->GetPingRate(&m_dMinMaxPingRate, &m_dMaxMaxPingRate);
	pParsor->GetSampleRate(&m_fLastSampRate);

	//pParsor->GetTxBeamWidth(&m_dMaxTxBeamWidthX, &m_dMinTxBeamWidthX, &a, &b, &m_bTxBeamWidth);
	//pParsor->GetTxBeamSteeringParams((DWORD*)&m_bTxBeamSteer, &m_dMaxTxBeamSteerX, &m_dMinTxBeamSteerX, &a, &b);

	m_dPowerRange = m_dMaxPower - m_dMinPower;


	pParsor->GetDeviceID(&m_dwSysID);
	pParsor->GetEnumerator(&m_wSysEnum);
	pParsor->GetSystemText(m_chSysText, 128);
	pParsor->GetSonarType((DWORD*)&m_bFLS);

  int i, j;
  for(j=0;j<numberof(RANGES);j++)
  {
    if(RANGES[j] > m_dMinRange)
      break;
  }
  j--;
  if(j < 0)
    j = 0;

  for(i=j;i<numberof(RANGES);i++)
  {
    if(RANGES[i] > m_dMaxRange)
      break;
  }


  m_dMinPulseLength = m_dMinPulseLength * 1000000.0; // Adjust decimal point for control.
  m_dMaxPulseLength = m_dMaxPulseLength * 1000000.0; // Adjust decimal point for control.

  m_ctrlScrollBarRange.SetScrollRange(j, i-1);
  
  //m_ctrlScrollBarPower.SetScrollRange(0, (int)floor(m_dMaxPower + 0.001) - (int)floor(m_dMinPower + 0.001) + 1);
  m_ctrlScrollBarPower.SetScrollRange(0, 100);
  
  m_ctrlScrollBarGain.SetScrollRange((int)floor(m_dMinGain + 0.001), (int)floor(m_dMaxGain + 0.001));
  
  m_ctrlScrollBarPulseLength.SetScrollRange((int)floor(m_dMinPulseLength + 0.001), (int)floor(m_dMaxPulseLength + 0.001));
  
  m_ctrlScrollBarMaxPingRate.SetScrollRange(0, (int)floor(m_dMaxMaxPingRate));

  m_ctrlCheckPing.EnableWindow(TRUE);
  m_ctrlBtnUpdate.EnableWindow(TRUE);

  //use last known values to initialize positions
  //UpdateRange(range);
  //UpdatePower(power);
  //UpdateGain(gain);
  //UpdateMaxPingRate(rate);
  //UpdatePulseLength(pulse);

}

void CDlg7kSonarParams::OnCheckPing() 
{
	//if(m_dPowerPercent == 0)
	//{
	//	m_ctrlCheckPing.SetCheck(0);
	//	TRACE("PInjg Disabled");
	//	return;
	//}

	m_bPingEnabled = m_ctrlCheckPing.GetCheck();//!m_bPingEnabled;
	
	if(m_bPingEnabled)
	{
		m_ctrlCheckPing.SetShade(SHS_METAL,8,40,18,RGB(0,155,0));
		m_ctrlCheckPing.SetWindowText("ENABLED");
	}
	else
	{
		m_ctrlCheckPing.SetShade(SHS_METAL,8,40,18,RGB(77,0,0));
		m_ctrlCheckPing.SetWindowText("DISABLED");
	}

}

void CDlg7kSonarParams::OnButtonUpdate() 
{
	CString temp;

	//At this point everything should be in range, so 
	//update it all
	
	m_pMainWnd->RemoteSetRange(m_dSensorIndex, range);
	TRACE("Set Range = %f\r\n", range);
	
	m_pMainWnd->RemoteSetGain(m_dSensorIndex,  gain);
	TRACE("Set Gain = %f\r\n", gain);

	m_pMainWnd->RemoteSetPower(m_dSensorIndex, m_dPowerPercent);	
	TRACE("Set Power = %d\r\n", m_dPowerPercent);
	
	m_pMainWnd->RemoteSetPulseWidth(m_dSensorIndex, pulse);
	TRACE("Set Pulse = %f\r\n", pulse);

	m_pMainWnd->RemoteSetMaxRate(m_dSensorIndex, rate);
	TRACE("Set Rate = %f\r\n", rate);

	BOOL bPingOn = m_ctrlCheckPing.GetCheck();
	m_pMainWnd->RemotePingEnable(m_dSensorIndex, bPingOn);
	m_pConfig->bPingActive = bPingOn;

	SaveSettings();

	m_pMainWnd->RemoteGetCurrentSettings(m_dSensorIndex);

}

void CDlg7kSonarParams::SaveSettings()
{

	//At this point the new values are already loaded into the 
	//config structure, see the Update Function above, so we
	//just open and save and close.

	if(m_pConfig->Open(CSystemConfig::accessWrite))
	{	
		m_pConfig->Save();
		m_pConfig->Close();
	}
}

void CDlg7kSonarParams::LoadSettings()
{
	if(m_pConfig->Open(CSystemConfig::accessRead))
	{	
		m_pConfig->Read();
		m_pConfig->Close();
	}

	
	range		= m_pConfig->range;
	rate		= m_pConfig->rate;
	pulse		= m_pConfig->pulse;
	power		= m_pConfig->power;
	gain		= m_pConfig->gain;
	bPingOn		= m_pConfig->bPingActive;
	m_dwSysID	= m_pConfig->uiSystemID;
	//soundspeed  = m_pConfig->fSoundSpeed;
	
}

void CDlg7kSonarParams::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
{
		// TODO: Add your message handler code here and/or call default
  char buf[128];
//  char record_data[128];
  int min, max, current, increment, size;
  double * values;
  CStatic * st;
  CScrollBar * sb;
  SCROLLINFO  info;
  //float range, power, gain, pulselength, maxpingrate;

	if(*pScrollBar == m_ctrlScrollBarRange)
  {
    sb = &m_ctrlScrollBarRange;
    st = &m_ctrlStaticRange;
    increment = 1;
    values = RANGES;
    
  }
  else if(*pScrollBar == m_ctrlScrollBarPower)
  {
    sb = &m_ctrlScrollBarPower;
    st = &m_ctrlStaticPower;
    increment = 1;
    values = NULL;
  }
  
  else if(*pScrollBar == m_ctrlScrollBarGain)
  {
    sb = &m_ctrlScrollBarGain;
    st = &m_ctrlStaticGain;
    increment = 1;
    values = NULL;
  }
  
  else if(*pScrollBar == m_ctrlScrollBarPulseLength)
  {
    sb = &m_ctrlScrollBarPulseLength;
    st = &m_ctrlStaticPulse;
    increment = 10;
    values = NULL;
  }
  /*else if(*pScrollBar == m_ctrlScrollBarTxBeamWidth)
  {
    sb = &m_ctrlScrollBarTxBeamWidth;
    st = &m_ctrlStaticCurrentTxBeamWidth;
    increment = 1;
	
	switch(m_dwDeviceId)
	{
	case 7150:	{if(m_wEnumerator == 0)
					values = BEAMWIDTH_24K;
				 else 
					values = BEAMWIDTH_12K; 
				 break;}
	case 7111:	{values = BEAMWIDTH_7111;break;}
	default:	{values = BEAMWIDTH_UNKNOWN;break;}
	}
    
  }
  */
  else if(*pScrollBar == m_ctrlScrollBarMaxPingRate)
  {
    sb = &m_ctrlScrollBarMaxPingRate;
    st = &m_ctrlStaticRate;
    increment = 1;
    values = NULL;
  }
  else
    return;
  

  // Get the current position of scroll box.
  current = pScrollBar->GetScrollPos();
  pScrollBar->GetScrollRange(&min, &max);
  pScrollBar->GetScrollInfo(&info, SIF_ALL);
  
  switch(nSBCode)
  {
    case SB_LEFT:         // Scroll to far left.
      current = min;
      break;
    case SB_RIGHT:        // Scroll to far right.
      current = max;
      break;
    case SB_ENDSCROLL:    // End scroll.
      break;
    case SB_LINELEFT:     // Scroll left.
      if (current > min)
        current -= increment;
      break;
    case SB_LINERIGHT:    // Scroll right.
      if (current < max)
        current += increment;
      break;
    case SB_PAGELEFT:     // Scroll one page left.
      current -= increment;
      if (current < min)
        current = min;
      //if (current > min)
      //  current = max(min, current - (int) info.nPage);
      break;
    case SB_PAGERIGHT:    // Scroll one page right.
      current += increment;
      if (current > max)
        current = max;
      //if (current < max)
      // current = min(max, current + (int) info.nPage);
      break;
    case SB_THUMBPOSITION: // Scroll to absolute position. nPos is the position
      current = nPos;      // of the scroll box at the end of the drag operation.
      break;
    case SB_THUMBTRACK:   // Drag scroll box to specified position. nPos is the
      current = nPos;     // position that the scroll box has been dragged to.
      break;
  }

  size = 0;
  
  if(*pScrollBar == m_ctrlScrollBarRange)
  {
    range = (float)values[current];
	m_pConfig->range	= range;
    sprintf(buf, "%.0f m", range);
  }
  else if(*pScrollBar == m_ctrlScrollBarPower)
  {
    if(current == 0)
    {
	  power = 0.0;
	  m_dPowerPercent = 0;
      sprintf(buf, "OFF");
    }
    else
    {
      m_dPowerPercent = current;
	  sprintf(buf, "%.0f %%", m_dPowerPercent);
    }

	m_pConfig->power	= current;

  }
  else if(*pScrollBar == m_ctrlScrollBarGain)
  {
      gain = (float)current;
      sprintf(buf, "%.0lf dB", (double)current);

	  m_pConfig->gain	= gain;
  }
  else if(*pScrollBar == m_ctrlScrollBarPulseLength)
  {
	if(current > m_dMaxPulseLength)
		current = m_dMaxPulseLength;

	if(current < m_dMinPulseLength)
		current = m_dMinPulseLength;

    pulse = (float)current * 0.000001;
    sprintf(buf, "%.3lf ms", (double)current/1000);

	m_pConfig->pulse	= pulse;

  }
/*  else if(*pScrollBar == m_ctrlScrollBarTxBeamWidth)
  {
    *(float*)&record_data[0] = m_dTxBeamWidthZ;
    *(float*)&record_data[4] = values[current] * D2R;

    sprintf(buf, "%.1f°", values[current]);

	CString temp;
	temp.Format("%.1f°", values[0]);
	m_ctrlStaticMinTxBeamWidth.SetWindowText(temp);
	temp.Format("%.1f°", values[3]);
	m_ctrlStaticMaxTxBeamWidth.SetWindowText(temp);
	//temp.Format("%.1f°", values[current]);
	//m_ctrlStaticCurrentTxBeamWidth.SetWindowText(temp);

  }*/
  else if(*pScrollBar == m_ctrlScrollBarMaxPingRate)
  {
    if(!current)
      rate = m_dMinMaxPingRate;
    else
      rate = (float)current;

 	m_pConfig->rate	= rate;

    sprintf(buf, "%.0lf p/s", rate);
  }  

  SaveSettings();
  
  st->SetWindowText(buf);
  pScrollBar->SetScrollPos(current);
  
	
  CDialog::OnHScroll(nSBCode, nPos, pScrollBar);
}


DWORD CDlg7kSonarParams::UpdateRange(float fRange)
{
  char buf[64];

  TRACE("GOT RANGE = %f\r\n", fRange);
  
  for(int i=0;i<numberof(RANGES);i++)
  {
    if(fRange < RANGES[i])
      break;
  }
  
  m_ctrlScrollBarRange.SetScrollPos(i-1);

  sprintf(buf, "%.0f m", fRange);
  m_ctrlStaticRange.SetWindowText(buf);

  range = fRange;

  return 1;
}

DWORD CDlg7kSonarParams::UpdatePower(float fPower)
{
  char buf[64];
   
  double val = fPower - m_dMinPower;
  m_dPowerPercent = floor((val/m_dPowerRange*100.0)+.5);
  
  if(m_dPowerPercent < 1)
  {
    sprintf(buf, "OFF");
	m_dPowerPercent = 0;
    m_ctrlScrollBarPower.SetScrollPos(0);	
  }
  else
  {	
    sprintf(buf, "%.0f %%", m_dPowerPercent);
    m_ctrlScrollBarPower.SetScrollPos((int)floor(m_dPowerPercent));
  }

  m_ctrlStaticPower.SetWindowText(buf);

  TRACE("Power Update = %d\r\n", m_dPowerPercent);

  return 1;
}


DWORD CDlg7kSonarParams::UpdateGain(float fGain)
{
  char buf[64];
  
  sprintf(buf, "%.0lf dB", fGain);
  m_ctrlScrollBarGain.SetScrollPos((int)floor(fGain));
  m_ctrlStaticGain.SetWindowText(buf);

  gain = fGain;
  TRACE("Gain Update = %f\r\n", gain);

  return 1;
}

DWORD CDlg7kSonarParams::UpdatePulseLength(float fPulseLength)
{
  char buf[64];
  float pulselength = fPulseLength * 1000000.0;
  
  sprintf(buf, "%.3lf ms", pulselength/1000);
  m_ctrlScrollBarPulseLength.SetScrollPos((int)floor(pulselength));
  m_ctrlStaticPulse.SetWindowText(buf);

  pulse = fPulseLength;
  TRACE("Pulse Update = %f\r\n", pulse);

  return 1;
}

DWORD CDlg7kSonarParams::UpdateMaxPingRate(float fMaxPingRate)
{
  char buf[64];
  float maxpingrate = fMaxPingRate;
  
  sprintf(buf, "%.0lf p/s", maxpingrate);
  
  if(maxpingrate < 1.0)
    m_ctrlScrollBarMaxPingRate.SetScrollPos(0);
  else
    m_ctrlScrollBarMaxPingRate.SetScrollPos((int)floor(maxpingrate));

  m_ctrlStaticRate.SetWindowText(buf);

  rate = fMaxPingRate;
  TRACE("Max Rate Update = %f\r\n", rate);

  return 1;
}

DWORD CDlg7kSonarParams::UpdatePingState(BOOL state )
{
	bPingOn = state;
	m_ctrlCheckPing.SetCheck(state);
	OnCheckPing();

	return 1;
}