camerafeatureview.cpp

BCAM 1394 Driver

        enable = true;
    }

    if ( m_pCamera == NULL )
    {
      ::EnableWindow(GetDlgItem(IDC_EDITVALUEU), enable);
      ::EnableWindow(GetDlgItem(IDC_EDITVALUEV), enable);
      ::EnableWindow(GetDlgItem(IDC_SLIDERU), enable);
      ::EnableWindow(GetDlgItem(IDC_SLIDERV), enable);
    }
    else
    {
        m_EditCtrlU.EnableWindow(enable);
        m_EditCtrlV.EnableWindow(enable);
    }
    ::EnableWindow(GetDlgItem(IDC_STATICNAMEU), enable);
    ::EnableWindow(GetDlgItem(IDC_STATICMINU), enable);
    ::EnableWindow(GetDlgItem(IDC_STATICMAXU), enable);
    ::EnableWindow(GetDlgItem(IDC_STATICNAMEV), enable);
    ::EnableWindow(GetDlgItem(IDC_STATICMINV), enable);
    ::EnableWindow(GetDlgItem(IDC_STATICMAXV), enable);
    return 0;
}

LRESULT CWhiteBalanceView::OnValueChanged(WPARAM uNotifyCode, WPARAM wID, HWND hWndCtrl, BOOL& bHandled)
{
  if ( m_pCamera != NULL )
  {

    int newVal = m_EditCtrlU.GetValue();
    if ( m_pCamera->IsWhiteBalanceSupported() )
      m_pCamera->WhiteBalance.Raw.UBValue.SetAsync(newVal);
    else
      m_pCamera->SetBGain(newVal / 100.0);
    newVal = m_EditCtrlV.GetValue();
    if ( m_pCamera->IsWhiteBalanceSupported() )
      m_pCamera->WhiteBalance.Raw.VRValue.SetAsync(newVal);
    else
      m_pCamera->SetRGain(newVal / 100.0);
  }

  return 0;
}

//////////////////////////////////////////////////////////////////////
// Public member functions
//////////////////////////////////////////////////////////////////////

void CWhiteBalanceView::OnConfigurationChanged(DCSVideoFormat format, DCSVideoMode mode, DCSVideoFrameRate rate, DCSColorCode code)
{
  try
  {
    if ( m_pCamera != NULL ) 
    {
      bool isWhiteBalanceAutoControlSupported = m_pCamera->WhiteBalance.IsSupported() && m_pCamera->WhiteBalance.IsSupported(inqAuto);

      if ( m_pCamera->IsWhiteBalanceSupported() || m_pCamera->IsBayerConversionEnabled()  ) 
      {
        if ( isWhiteBalanceAutoControlSupported )
          m_pCamera->WhiteBalance.AutoMode = false;
        EnableWindow(TRUE);
        RefreshControl();
      }
      else
      {
        EnableWindow(FALSE);
      }
    }
  }
  catch ( BcamException& e)
  {
    EnableWindow(FALSE);
    throw e;
  }
}

//////////////////////////////////////////////////////////////////////
// Protected/ private member functions
//////////////////////////////////////////////////////////////////////

void CWhiteBalanceView::InitControl()
{
  m_EditCtrlU.Attach(this, IDC_EDITVALUEU, IDC_SLIDERU);
  m_EditCtrlU.AttachTextCtrls(IDC_STATICMINU, IDC_STATICMAXU);
  m_EditCtrlV.Attach(this, IDC_EDITVALUEV, IDC_SLIDERV);
  m_EditCtrlV.AttachTextCtrls(IDC_STATICMINV, IDC_STATICMAXV);
  m_EditCtrlU.WantReturn(true);
  m_EditCtrlV.WantReturn(true);
  m_EditCtrlU.PostMsgEnable(true);
  m_EditCtrlV.PostMsgEnable(true);
  m_EditCtrlU.SetKillFocus(true);
  m_EditCtrlV.SetKillFocus(true);
  m_EditCtrlU.LiveUpdateEnable(true);
  m_EditCtrlV.LiveUpdateEnable(true);
}

void CWhiteBalanceView::RefreshControl()
{
  assert ( m_pCamera != NULL );
  unsigned long min; 
  unsigned long max;

  if ( ! m_pCamera->IsWhiteBalanceSupported()  )
  {
    assert(m_pCamera->IsBayerConversionEnabled());
    min = 10;
    max = 500;
  }
  else
  {
    min = m_pCamera->WhiteBalance.Raw.Min();  
    max = m_pCamera->WhiteBalance.Raw.Max();
  }

  m_EditCtrlU.PostMsgEnable(false);
  m_EditCtrlU.SetRange(min, max);

  if ( ! m_pCamera->IsWhiteBalanceSupported() )
  {
    ::SetWindowText(GetDlgItem(IDC_STATICNAMEU), "B");
    m_EditCtrlU.SetValue(m_pCamera->GetBGain() * 100);
  }
  else
  {
    ::SetWindowText(GetDlgItem(IDC_STATICNAMEU), "U");
    m_EditCtrlU.SetValue(m_pCamera->WhiteBalance.Raw.UBValue());
  }
  m_EditCtrlU.PostMsgEnable(true);

  m_EditCtrlV.PostMsgEnable(false);
  m_EditCtrlV.SetRange(min, max);
  if ( ! m_pCamera->IsWhiteBalanceSupported() )
  {
    ::SetWindowText(GetDlgItem(IDC_STATICNAMEV), "R");
    m_EditCtrlV.SetValue(m_pCamera->GetRGain() * 100);
  }
  else
  {
    ::SetWindowText(GetDlgItem(IDC_STATICNAMEV), "V");
     m_EditCtrlV.SetValue(m_pCamera->WhiteBalance.Raw.VRValue());
  }
  m_EditCtrlV.PostMsgEnable(true);
}

void CWhiteBalanceView::SetVRValue(long vr) 
{
  m_EditCtrlV.SetValue(vr);
}

void CWhiteBalanceView::SetUBValue(long ub) 
{
  m_EditCtrlU.SetValue(ub);
}

void CWhiteBalanceView::PostMsgEnable(bool enable)
{
  m_EditCtrlU.PostMsgEnable(enable);
  m_EditCtrlV.PostMsgEnable(enable);
}



//////////////////////////////////////////////////////////////////////
//
// class CBytePerPacketView
//
//

//////////////////////////////////////////////////////////////////////
// Message Handlers
//////////////////////////////////////////////////////////////////////

LRESULT CBytePerPacketView::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
{
  ::SetWindowText(GetDlgItem(IDC_STATICNAME), "Bytes/Pkt" );
  InitControl();
  return 0;
}

LRESULT CBytePerPacketView::OnEnable(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
    BOOL enable = false;
    if ( wParam ) // Window has been enabled
    {
      
      if ( m_pCamera != NULL )
      {
        DCSVideoFormat format;
        m_pCamera->GetVideoMode(&format, NULL, NULL);
        if ( format == DCS_Format7 )
          enable = true;
      }
    }

    if ( m_pCamera == NULL )
    {
      ::EnableWindow(GetDlgItem(IDC_EDITVALUE), enable);
      ::EnableWindow(GetDlgItem(IDC_SLIDER), enable);
    }
    m_EditCtrl.EnableWindow(enable);
    ::EnableWindow(GetDlgItem(IDC_STATICNAME), enable);
    ::EnableWindow(GetDlgItem(IDC_STATICMIN), enable);
    ::EnableWindow(GetDlgItem(IDC_STATICMAX), enable);
    return 0;
}

LRESULT CBytePerPacketView::OnValueChanged(WPARAM uNotifyCode, WPARAM wID, HWND hWndCtrl, BOOL& bHandled)
{
  if ( m_pCamera == NULL )
    return 0;

  int bpp = m_EditCtrl.GetValue();

  if ( bpp % m_Inc )
  {
    bpp = __max ( m_Inc * ( bpp / m_Inc ), m_Inc);
    m_EditCtrl.SetValue(bpp);  // this will cause a further call to OnValueChanged
    return 0;
  }
  
  DCSVideoFormat format;
  DCSVideoMode mode;
  m_pCamera->GetVideoMode(&format, &mode, NULL);
  assert ( format == DCS_Format7 );

  if ( m_pCamera->ReconfigurationRequest() )
  {
    m_pCamera->FormatSeven[mode].BytePerPacket = m_EditCtrl.GetValue();
    // ensure, that the camera has accepted our value. If not, update the edit control
    unsigned long read = m_pCamera->FormatSeven[mode].BytePerPacket();
    if ( read != m_EditCtrl.GetValue() )
    {
      m_EditCtrl.PostMsgEnable(false);
      m_EditCtrl.SetValue(read);
      m_EditCtrl.PostMsgEnable(true);
    }
    m_pCamera->ConfigurationChanged();
  }
  return 0;
}

//////////////////////////////////////////////////////////////////////
// Public member functions
//////////////////////////////////////////////////////////////////////


void CBytePerPacketView::OnConfigurationChanged(DCSVideoFormat format, DCSVideoMode mode, DCSVideoFrameRate rate, DCSColorCode code)
{
  if ( m_pCamera != NULL )
  {
    if ( DCS_Format7 == format )
    {
      EnableWindow(TRUE);
      RefreshControl();
    }
    else
    {
      EnableWindow(FALSE);
    }
  }
}

//////////////////////////////////////////////////////////////////////
// Protected/ private member functions
//////////////////////////////////////////////////////////////////////

void CBytePerPacketView::InitControl()
{
  m_EditCtrl.Attach(this, IDC_EDITVALUE, IDC_SLIDER);
  m_EditCtrl.WantReturn(true);
  m_EditCtrl.SetKillFocus(true);
  m_EditCtrl.LiveUpdateEnable(false);
  m_EditCtrl.AttachTextCtrls(IDC_STATICMIN, IDC_STATICMAX);
  m_EditCtrl.PostMsgEnable(true);
}

void CBytePerPacketView::RefreshControl()
{
  assert ( m_pCamera != NULL );

  DCSVideoFormat format;
  DCSVideoMode mode;
  m_pCamera->GetVideoMode(&format, &mode, NULL);
  assert ( DCS_Format7 == format );

  m_EditCtrl.PostMsgEnable(false);
  m_Inc = lcm(m_pCamera->FormatSeven[mode].BytePerPacket.Inc(), 4);
  m_EditCtrl.SetLineSize(m_Inc);
  m_Max =  m_Inc * ( m_pCamera->FormatSeven[mode].BytePerPacket.Max() / m_Inc );
  assert ( m_Max >= m_Inc );

  // our cameras don't allow more than 4095 packets per frame. -> calculate according minimum
  m_Min = m_Inc * ( ( ( (m_pCamera->FormatSeven[mode].BytePerFrame() + 4094 ) / 4095) + m_Inc - 1 ) / m_Inc );
  m_Min = __max( m_Min, m_Inc);

  m_EditCtrl.SetRange(m_Min, m_Max);

  int bpp = m_pCamera->FormatSeven[mode].BytePerPacket();
  if ( bpp > m_Max ) 
  {
    bpp = m_Max / m_Inc;
    m_pCamera->FormatSeven[mode].BytePerPacket = bpp;
  }
  else if ( bpp < m_Min )
  {
    bpp = __max( m_Inc,  m_Min );
    m_pCamera->FormatSeven[mode].BytePerPacket = bpp;
  }
  else if ( bpp % m_Inc )
  {
    bpp = __max( m_Min, ( bpp / m_Inc ) * m_Inc );
    m_pCamera->FormatSeven[mode].BytePerPacket = bpp;
  }
  m_EditCtrl.SetValue( bpp );
  m_EditCtrl.PostMsgEnable(true);
}