tbareditctrlint.cpp

BCAM 1394 Driver

//-----------------------------------------------------------------------------
//  (c) 2002 by Basler Vision Technologies
//  Section:  Vision Components
//  Project:  BCAM
//  $Header: TBarEditCtrlInt.cpp, 3, 02.10.2002 14:31:30, Nebelung, H.$
//-----------------------------------------------------------------------------
/**
\file     TBarEditCtrlInt.cpp
\brief    implementation of the CTBarEditCtrlInt class.
*/
//////////////////////////////////////////////////////////////////////

#include <atlbase.h>
#include <atlapp.h>
extern  CAppModule _Module;
#include <atlwin.h>

#include "ChkRecursion.h"
#include "TBarEditCtrlInt.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction

CTBarEditCtrlInt::CTBarEditCtrlInt(bool bPostMsgEnabled /*= true*/)
: CTBarEditCtrlBase(bPostMsgEnabled)
{
  m_nFormatWidth     = 1;
  m_nFormatPrecision = 1;
  m_pFmtFnc                            = NULL;
  m_nLineSize                              = 0;
  m_nPageSize                              = 0;
}

CTBarEditCtrlInt::~CTBarEditCtrlInt()
{
}

//////////////////////////////////////////////////////////////////////
// 

bool CTBarEditCtrlInt::SetRangeMin(int nRangeMin, bool bRedraw /*= true*/)
{
  return SetRange(nRangeMin, m_nRangeMax, bRedraw);
}

bool CTBarEditCtrlInt::SetRangeMax(int nRangeMax, bool bRedraw /*= true*/)
{
  return SetRange(m_nRangeMin, nRangeMax, bRedraw);
}

bool CTBarEditCtrlInt::SetRange(int nRangeMin, int nRangeMax, bool bRedraw /*= true*/)
{
  if ( nRangeMin >= nRangeMax )
    return false;
  
  m_nRangeMin = nRangeMin;
  m_nRangeMax = nRangeMax;
  
  return UpdateRange(bRedraw);
}

int CTBarEditCtrlInt::GetRangeMin() const
{
  return m_nRangeMin;
}

int CTBarEditCtrlInt::GetRangeMax() const
{
  return m_nRangeMax;
}

void CTBarEditCtrlInt::GetRange(int& nMin, int& nMax) const
{
  nMin = GetRangeMin();
  nMax = GetRangeMax();
}

//////////////////////////////////////////////////////////////////////
// 

bool CTBarEditCtrlInt::UpdateRange(bool bRedraw /*= true*/)
{
  // compute absolute range to determine if scaling is necessary
  m_nRangeAbs      = abs(m_nRangeMin) + abs(m_nRangeMax);
  
  // assume no scaling necessary
  m_nScaleFactor   = 1;
  m_nScaleRangeMin = m_nRangeMin;
  m_nScaleRangeMax = m_nRangeMax;
  
  if ( m_nRangeAbs >= SHRT_MAX )
  {
    __int64 nScaleFactor;
    
    // scaling is necessary
    nScaleFactor   = ((__int64) m_nRangeAbs * 1000) / (SHRT_MAX-1);
    nScaleFactor   = (nScaleFactor + 999) / 1000;
    m_nScaleFactor = (int) nScaleFactor;
    
    if ( m_nRangeAbs % m_nScaleFactor != 0 )
      m_nScaleFactor++;
    
    m_nScaleRangeMin = (m_nRangeMin / m_nScaleFactor) - 1;
    m_nScaleRangeMax = (m_nRangeMax / m_nScaleFactor) + 1;
    
    //              ATLTRACE("CTBarEditCtrlInt::UpdateRangeInt f=%d, min=%d, max=%d\n", m_nScaleFactor, m_nScaleRangeMin, m_nScaleRangeMax);
  }
  
  CTrackBarCtrl::SetRange(m_nScaleRangeMin, m_nScaleRangeMax, bRedraw);
  
  UpdateRangeText();
  
  // update line and page size
  if ( m_nLineSize != 0 )
    SetLineSize(m_nLineSize);
  
  if ( m_nPageSize != 0 )
    SetPageSize(m_nPageSize);
  
  // call impl of parent class (if overridden)
  return NotifyRangeChanged(bRedraw);
}

void CTBarEditCtrlInt::UpdateRangeText()
{
  char    szBuf[256];
  
  FmtValue(szBuf, m_nRangeMin);
  if ( m_ctrlTxtL.IsWindow() )
    m_ctrlTxtL.SetWindowText(szBuf);
  
  FmtValue(szBuf, m_nRangeMax);
  if ( m_ctrlTxtR.IsWindow() )
    m_ctrlTxtR.SetWindowText(szBuf);
}

bool CTBarEditCtrlInt::NotifyRangeChanged(bool bRedraw /*= true*/)
{
  // limit value to range
  if ( LimitValue() && m_bWantReturn )
  {
    m_bOnChange2Parent = m_bOnUpdate2Parent = true;                         // notify parent
    
    // update controls
    UpdateValue();
    UpdateThumb(m_nValue);
    
    return true;
  }
  return false;
}

//////////////////////////////////////////////////////////////////////
// 

/**********
* SetValue - Set the value
*                                              Posting of EN_UPDATE and EN_CHANGE is *forced*, if WantReturn is active
*
* \param               nValue                          the value to set
* \param               bTrackThumb             if true, the thumb position will be set. Is mostly used internal
* \return      true                                    if the given value is out of bounds and is corrected
*/
bool CTBarEditCtrlInt::SetValue(int nValue, bool bTrackThumb /*= true*/)
{
  // force posting EN_UPDATE and EN_CHANGE
  if ( m_bWantReturn )
    m_bOnChange2Parent = m_bOnUpdate2Parent = true;                         // notify parent
  
  return InternalSetValue(nValue, bTrackThumb);
}

/**********
* InternalSetValue - Set the value
*                                                                              Posting of EN_UPDATE and EN_CHANGE is *not* forced, if WantReturn is active
*
* \param               nValue                          the value to set
* \param               bTrackThumb             if true, the thumb position will be set. Is mostly used internal
* \return      true                                    if the given value is out of bounds and is corrected
*/
bool CTBarEditCtrlInt::InternalSetValue(int nValue, bool bTrackThumb /*= true*/)
{
  m_nValue = nValue;
  
  // limit value to range
  bool    bNotChgd = !LimitValue();
  
  // update controls
  UpdateValue();
  UpdateThumb(m_nValue, bTrackThumb);
  
  return bNotChgd;
}

bool CTBarEditCtrlInt::DDXValue(UINT /*nID*/, int &nValue, BOOL bSave, BOOL /* bValidate = false*/)
{
  if ( bSave )
  {
    nValue = GetValue();
    return true;
  }
  
  return SetValue(nValue);
}

bool CTBarEditCtrlInt::DDXValue(UINT /*nID*/, long &nValue, BOOL bSave, BOOL /* bValidate = false*/)
{
  if ( bSave )
  {
    nValue = GetValue();
    return true;
  }
  
  return SetValue(nValue);
}

/**********
* GetValue - Get the value
*/
int CTBarEditCtrlInt::GetValue()
{
  return m_nValue;
}

/**********
* SetLineSize - see MSDN
*/
int CTBarEditCtrlInt::SetLineSize(int nLogSize)
{
  int     nNewSize, nCurSize;
  
  nNewSize                = nLogSize / m_nScaleFactor;
  nCurSize                = CTBarCtrlBase::SetLineSize(nNewSize);
  m_nLineSize     = nLogSize;
  
  return nCurSize * m_nScaleFactor;
}

/**********
* GetLineSize - see MSDN
*/
int CTBarEditCtrlInt::GetLineSize(void)
{
  return CTBarCtrlBase::GetLineSize() * m_nScaleFactor;
}

/**********
* SetPageSize - see MSDN
*/
int CTBarEditCtrlInt::SetPageSize(int nLogSize)
{
  int     nNewSize, nCurSize;
  
  nNewSize                = nLogSize / m_nScaleFactor;
  nCurSize                = CTBarCtrlBase::SetPageSize(nNewSize);
  m_nPageSize     = nLogSize;
  
  return nCurSize * m_nScaleFactor;
}

/**********
* GetPageSize - see MSDN
*/
int CTBarEditCtrlInt::GetPageSize(void)
{
  return CTBarCtrlBase::GetPageSize() * m_nScaleFactor;
}

void CTBarEditCtrlInt::SetPrecision(int nPrecision, int nWidth /*= 0*/)
{
  m_nFormatWidth     = nWidth;
  m_nFormatPrecision = nPrecision;
  
  UpdateRange(true);
  
  UpdateValue();
  UpdateThumb(m_nValue, false);
}

//////////////////////////////////////////////////////////////////////
// 

int     CTBarEditCtrlInt::FmtValue(char *szBuf, int nValue)
{
  int     nCharsPrinted;
  
  if ( m_pFmtFnc != NULL )
    nCharsPrinted = (m_pFmtFnc)(szBuf, nValue, m_nFormatWidth, m_nFormatPrecision);
  else
    nCharsPrinted = sprintf(szBuf, _T("%*d"), m_nFormatWidth, nValue);
  
  return nCharsPrinted;
}

void CTBarEditCtrlInt::UpdateValue()
{
  char    szBuf[128];
  
  FmtValue(szBuf, m_nValue);
  
  if ( CEditCtrlBase::IsWindow() )
    if ( strcmp(m_szWndTxt, szBuf) )
      CEditCtrlBase::SetWindowText(szBuf);
}

bool CTBarEditCtrlInt::LimitValue()
{
  if ( m_nValue < m_nRangeMin )
  {
    m_nValue = m_nRangeMin;
    return true;
  }
  
  if ( m_nValue > m_nRangeMax )
  {
    m_nValue = m_nRangeMax;
    return true;
  }
  
  return false;
}

//////////////////////////////////////////////////////////////////////
// 

void CTBarEditCtrlInt::UndoInput()
{
  int             nValue = 0, nStartPos, nEndPos;
  
  // get current caret position
  CEditCtrlBase::GetSel(nStartPos, nEndPos);
  
  // set last know value
  SetValue(m_nValue);
  
  // restore caret
  CEditCtrlBase::SetSel(nStartPos, nEndPos);
}

bool CTBarEditCtrlInt::UpdateEditText()
{
  static                          int     nRecursivCalls = 0;
  CChkRecursion   cChkRecursion(&nRecursivCalls);
  
  if ( cChkRecursion.Check(2) )
  {
    //              ATLTRACE("CTBarEditCtrlInt::UpdateEditText !!!max. recursion!!!\n");
    return false;
  }
  
  char    szBuf[256];
  int             nValue = 0, nStartPos, nEndPos;
  
  // get current caret position
  CEditCtrlBase::GetSel(nStartPos, nEndPos);
  
  // get current edit text and value
  if ( CEditCtrlBase::GetWindowText(szBuf, sizeof(szBuf)-1) )
  {
    nValue = atoi(szBuf);
    
    // force SetValue(), even if value doesn't differ!
    if ( strcmp(m_szWndTxt, szBuf) )
      m_szWndTxt[0] = '\0';
  }
  
  // if the value has changed...
  // ... reflect value to all associated controls
  // ... reposition the caret
  if ( nValue != m_nValue )
  {
    InternalSetValue(nValue);
    CEditCtrlBase::SetSel(nStartPos, nEndPos);
    return true;
  }
  
  return false;
}

//////////////////////////////////////////////////////////////////////
// 

bool CTBarEditCtrlInt::GoCenterValue()
{
  if ( m_bWantReturn )
    m_bOnChange2Parent = m_bOnUpdate2Parent = true;
  
  return SetValue(m_nRangeMin + (m_nRangeAbs / 2));
}

//////////////////////////////////////////////////////////////////////
// 

LRESULT CTBarEditCtrlInt::HScroll(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
  static  bool    bEventThumbPosition = false;
  int             nThumbPos = (short) HIWORD(wParam);
  
  bHandled           = false;
  m_bOnChange2Parent = false;
  m_bOnUpdate2Parent = false;
  bool notifyParent = false;
  
  switch( LOWORD(wParam) )
  {
  case TB_TOP:
  case TB_BOTTOM:                                 // pos1/home
  case TB_LINEUP:
  case TB_LINEDOWN:                               // cursor up/down
  case TB_PAGEUP:
  case TB_PAGEDOWN:                               // page up/down
    InternalSetValue(CTBarCtrlBase::GetPos() * m_nScaleFactor, false);
    notifyParent = m_bLiveUpdateEnabled;
    break;
  case TB_THUMBPOSITION:  // User has dragged
    bEventThumbPosition = true;
    InternalSetValue(nThumbPos * m_nScaleFactor);
    notifyParent = m_bLiveUpdateEnabled;
    break;
  case TB_THUMBTRACK:                     // User is dragging
    if ( !bEventThumbPosition )
    {
      InternalSetValue(nThumbPos * m_nScaleFactor);
      notifyParent = m_bLiveUpdateEnabled;
    }
    
    bEventThumbPosition = false;
    break;
  case TB_ENDTRACK:                               // end of dragging/moving
    notifyParent = true;
    
    
    break;
  default:
    break;
  }
  
  if ( notifyParent && m_bWantReturn  )
  {
    if ( m_nPostMsgID )
    {
      PostParent(WM_COMMAND, MAKELPARAM(m_nPostMsgID, EN_UPDATE), (LPARAM) m_hEditCtrl);
      PostParent(WM_COMMAND, MAKELPARAM(m_nPostMsgID, EN_CHANGE), (LPARAM) m_hEditCtrl);
    }
    else
    {
      PostParent(WM_COMMAND, MAKELPARAM(m_nEditCtrlID, EN_UPDATE), (LPARAM) m_hEditCtrl);
      PostParent(WM_COMMAND, MAKELPARAM(m_nEditCtrlID, EN_CHANGE), (LPARAM) m_hEditCtrl);
    }
    
    m_bOnChange2Parent = true;
    m_bOnUpdate2Parent = true;
    
  } 
  
  
  
  //      ATLTRACE("CTBarEditCtrlBase::OnHScroll w=%x -> t=%d\n", wParam, nThumbPos);
  return 0;
}