Filter Library

Camera

Interface Physics

ControlNumSpinCtrl.cpp

/*
 * ControlNumSpinCtrl.cpp - a spin control for real numbers.
 *
 * This file is part of the Camera Filter Library.
 * Computer Aided Measurement Environment for Realtime Atomic imaging (Camera)
 *
 * Copyright (C) 2004-2005, Leiden Probe Microscopy.
 * Copyright (C) 2004-2005, Universiteit Leiden.
 *
 * This spin control is based on:
 * CNumSpinCtrl - a simple numeric spin control, By Damir Valiulin
 * See http://www.codeproject.com/miscctrl/numspinctrl.asp
 *
 * Authors: Martin J. Moene (original)
 *
 * $Id: ControlNumSpinCtrl.cpp 150 2005-04-25 09:02:30Z moene $
 */

#include "stdafx.h"                     // for common (pre-compiled) headers
//#include <cfl/stdafx.h>                 // for common (pre-compiled) headers
#include <cfl/ControlNumSpinCtrl.h>     // header

#pragma warning( push, 3 )              // header file limits requires warning level 3

#include <cmath>                        // for fabs() etc.
#include <limits>                       // for numeric_limits<>

#pragma warning( pop )

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

#define EPSILON std::numeric_limits<double>::epsilon()

IMPLEMENT_DYNAMIC( CNumSpinCtrl, CSpinButtonCtrl )

/**
 * destructor.
 */

CNumSpinCtrl::~CNumSpinCtrl()
{
   ; // do nothing
}

/**
 * default constructor.
 */

CNumSpinCtrl::CNumSpinCtrl() :
   m_Delta ( 1 ),
   m_MinVal( 0 ),
   m_MaxVal( 100 ),
   m_IntRange( 100 ),
   m_csFormat( _T( "%g" ) )
{
   ; // do nothing
}

/**
 * obtain the lower and higher limits and the delta value.
 */

void CNumSpinCtrl::GetRangeAndDelta( real_type& lower, real_type& upper, real_type& delta )
{
   lower = m_MinVal;
   upper = m_MaxVal;
   delta = m_Delta;
}

/**
 * set the lower and higher limits and the delta value.
 */

void CNumSpinCtrl::SetRangeAndDelta( real_type lower, real_type upper, real_type delta )
{
   m_MinVal = lower;
   m_MaxVal = upper;
   m_Delta  = delta;

   // reversed min/max is not implemented, although it's probably easy:

   if ( Q_INVALID( m_MaxVal < m_MinVal && "m_MaxVal < m_MinVal" ) )
   {
      return;
   }

   // avoid division by zero:

   if ( m_Delta == 0.0 )
   {
      return;
   }

   // Figure out the integer range to use, so that acceleration can work properly:

   double range = fabs( ( m_MaxVal - m_MinVal ) / m_Delta );

   if ( range > static_cast<double>( UD_MAXVAL ) )
   {
      m_IntRange = UD_MAXVAL;
   }
   else
   {
      m_IntRange = static_cast<int>( range );
   }

   CSpinButtonCtrl::SetRange32( 0, m_IntRange );

   // Set integer position:

   SetIntPos( GetPos() );
}

/**
 * set the new position.
 */

void CNumSpinCtrl::SetPos( double val )
{
   if ( val < m_MinVal || val > m_MaxVal )
   {
      return;
   }

   SetValueForBuddy( val );
   SetIntPos       ( val );
}

/**
 * the current position.
 */

double CNumSpinCtrl::GetPos()
{
   CWnd* pEdit = GetBuddy();

   if ( Q_INVALID( NULL == pEdit && "GetPos: Auto buddy is unset" ) )
   {
      return 0.0;
   }

   double val = ::strtod( c_str_ptr( *pEdit ), NULL );

   if ( val < m_MinVal )
   {
      return m_MinVal;
   }
   else if ( val > m_MaxVal )
   {
      return m_MaxVal;

   }

   return val;
}

/**
 * set the printf-like format string (NULL yields "%g").
 */

void CNumSpinCtrl::SetFormat( LPCTSTR lpszFormatString /* = NULL */ )
{
   if ( lpszFormatString == NULL )
   {
      m_csFormat.Empty ();
   }
   else
   {
      m_csFormat = lpszFormatString;
   }
}

/**
 *  focus this control and select its contents.
 */

void CNumSpinCtrl::Select()
{
   CEdit* pEdit = static_cast<CEdit*>( GetBuddy() );

   if ( Q_INVALID( NULL == pEdit && "Select: Auto buddy is unset" ) )
   {
      return;
   }

   pEdit->SetFocus();
   pEdit->SetSel( 0, -1 );
}

/**
 * allow other necessary subclassing to occur before the window is subclassed.
 */

void CNumSpinCtrl::PreSubclassWindow()
{
   CSpinButtonCtrl::PreSubclassWindow();
   InitSpinCtrl();
}

/**
 * check that Set-Buddy-Integer is unset and set the control's range via SetRangeAndDelta().
 */

void CNumSpinCtrl::InitSpinCtrl()
{
   // require Set-Buddy-Integer unset, otherwise control won't work properly!

   // ModifyStyle (UDS_SETBUDDYINT, UDS_ARROWKEYS); // doesn't work

   if ( Q_INVALID( 0 != ( GetStyle () & UDS_SETBUDDYINT ) && "require Set-Buddy-Integer unset" ) )
   {
      return;
   }

   // set default values:

   SetRangeAndDelta( m_MinVal, m_MaxVal, m_Delta );
}

/**
 * set the underlying SpinButtonCtrl's position.
 */

void CNumSpinCtrl::SetIntPos( real_type pos )
{
   // avoid division by zero:

   if ( m_MaxVal == m_MinVal )
   {
      return;
   }

   int int_pos;

   if ( pos < m_MinVal )
   {
      int_pos = 0;
   }
   else if ( pos > m_MaxVal )
   {
      int_pos = m_IntRange;
   }
   else
   {
      // where in the range is current position?

      double pos_in_range = ( pos - m_MinVal ) / ( m_MaxVal - m_MinVal );

      int_pos = static_cast<int>( m_IntRange * pos_in_range + 0.5 );
   }

   CSpinButtonCtrl::SetPos( int_pos );
}

/**
 * set the contents of the buddy edit control.
 */

void CNumSpinCtrl::SetValueForBuddy( real_type val )
{
   CWnd* pEdit = GetBuddy();

   if ( Q_INVALID( NULL == pEdit && "SetValueForBuddy: Auto buddy is unset" ) )
   {
      return;
   }

   CString str;
   if ( m_csFormat.IsEmpty() )
   {
      str.Format( _T( "%g" ), val );
   }
   else
   {
      str.Format( m_csFormat, val );
   }

   pEdit->SetWindowText( str );
}

/*
 * the message map
 */

BEGIN_MESSAGE_MAP(CNumSpinCtrl, CSpinButtonCtrl)
   //{{AFX_MSG_MAP(CNumSpinCtrl)
   ON_WM_CREATE()
   ON_NOTIFY_REFLECT_EX(UDN_DELTAPOS, OnDeltapos)
   //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/**
 * handle create message, calls InitSpinCtrl().
 */

int CNumSpinCtrl::OnCreate( LPCREATESTRUCT lpCreateStruct )
{
   if ( -1 == CSpinButtonCtrl::OnCreate(lpCreateStruct) )
   {
      return -1;
   }

   InitSpinCtrl();

   return 0;
}

/**
 * handle position-change message, set buddy contents via SetValueForBuddy().
 */

BOOL CNumSpinCtrl::OnDeltapos( NMHDR* pNMHDR, LRESULT* pResult )
{
   NM_UPDOWN* pUD = (NM_UPDOWN*)pNMHDR;

   double val = GetPos() + m_Delta * pUD->iDelta;

   const bool can_wrap = ( UDS_WRAP & GetStyle() );

   /*
    * spin up or down:
    */

   if ( pUD->iDelta < 0 )               // spin down
   {
      double abs_eps = fabs( EPSILON * max( val, m_MinVal ) );

      if ( abs_eps < EPSILON )
      {
         abs_eps = EPSILON;
      }

      if ( m_MinVal - val > abs_eps )
      {
         if ( can_wrap )
         {
            val = m_MaxVal;
         }
         else
         {
            val = m_MinVal;
         }
      }
   }
   else                                 // spin up
   {
      double abs_eps = fabs( EPSILON * max( val, m_MaxVal ) );

      if ( abs_eps < EPSILON )
      {
         abs_eps = EPSILON;
      }

      if ( val - m_MaxVal > abs_eps )
      {
         if ( can_wrap )
         {
            val = m_MinVal;
         }
         else
         {
            val = m_MaxVal;
         }
      }
   }

   SetValueForBuddy( val );

   // pass back Ok and let parent process this notification too:

   *pResult = 0;

   return FALSE;
}

/*
 * end of file
 */

---