Filter Library

Camera

Interface Physics

ControlFilterEdit.cpp

/*
 * ControlFilterEdit.cpp - a filtered edit control.
 *
 * This file is part of the Camera Filter Library.
 * Computer Aided Measurement Environment for Realtime Atomic imaging (Camera)
 *
 * Copyright (C) 2004, Leiden Probe Microscopy.
 * Copyright (C) 2004, Universiteit Leiden.
 *
 * The filtered edit control is based on:
 * CFilterEdit: Use Regular Expressions to Filter Your Input, By Ben Hanson.
 * See http://www.codeproject.com/editctrl/FilterEdit.asp
 *
 * Authors: Martin J. Moene (original)
 *
 * $Id: ControlFilterEdit.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/ControlFilterEdit.h>

IMPLEMENT_DYNAMIC( CFilterEdit, CEdit )

/**
 * destructor.
 */

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

/**
 * (default) constructor.
 */

CFilterEdit::CFilterEdit( const bool bProcessChars/* = true*/ ) :
   m_bProcessChars( bProcessChars ),
   m_bAutoValidate( true  ),
   m_bModal       ( true  ),
   m_bShowInvalid ( true  ),
   m_bSetBkOnError( false ),
   m_bWavyLineOnError ( true ),
   m_bBeepOnInvalid( true  ),
   m_bValid        ( true  ),
   m_bCharValid    ( false ),
   m_bControlDown  ( false ),
   m_crFgOK        ( RGB (  0,   0,   0 ) ),
   m_crBkOK        ( RGB (255, 255, 255 ) ),
   m_crFgError     ( RGB (255, 255, 255 ) ),
   m_crBkError     ( RGB (255,   0 ,  0 ) )
{
   m_brOK.CreateSolidBrush   ( m_crBkOK    );
   m_brError.CreateSolidBrush( m_crBkError );
}

/**
 * validate as the user types (also settable in the constructor).
 */

void CFilterEdit::SetProcessChars( const bool bProcessChars )
{
   m_bProcessChars = bProcessChars;
}

/**
 * check that the entire input is valid when the control loses focus 
 * (bAutoValidate), set focus back to the control if the input is invalid 
 * when the control loses focus (bModal).
 */

void CFilterEdit::SetAutoValidate( const bool bAutoValidate, const bool bModal )
{
   m_bAutoValidate = bAutoValidate;
   m_bModal = bModal;
}

/**
 * show  if the input is invalid (bShowInvalid), via the background color 
 * (bSetBkOnError) and with a wavy line under the text (bWavyLineOnError).
 */

void CFilterEdit::SetShowInvalid (
   const bool bShowInvalid, const bool bSetBkOnError, const bool bWavyLineOnError )
{
   m_bShowInvalid = bShowInvalid;
   m_bSetBkOnError = bSetBkOnError;
   m_bWavyLineOnError = bWavyLineOnError;

   /*
    * Sanity Check: There is no point in setting both error display types 
    * to false if bShowInvalid is true.
    */

   if ( m_bShowInvalid && !m_bSetBkOnError && !m_bWavyLineOnError )
   {
      m_bWavyLineOnError = true;
   }
}

/**
 * beep when the final validation fails (bBeepOnInvalid).
 */

void CFilterEdit::SetBeepOnInvalid( const bool bBeepOnInvalid )
{
   m_bBeepOnInvalid = bBeepOnInvalid;
}

/**
 * set the normal ('OK') background color.
 */

void CFilterEdit::SetBackgroundColourOK( const COLORREF crBkOK )
{
   m_crBkOK = crBkOK;
   m_brOK.DeleteObject ();
   m_brOK.CreateSolidBrush (m_crBkOK);
}

/**
 * set the normal ('OK') foreground color.
 */

void CFilterEdit::SetForegroundColourOK( const COLORREF crFgOK )
{
   m_crFgOK = crFgOK;
}

/**
 * set the error background color.
 */

void CFilterEdit::SetBackgroundColourError( const COLORREF crBkError )
{
   m_crBkError = crBkError;
   m_brError.DeleteObject ();
   m_brError.CreateSolidBrush (m_crBkError);
}

/**
 * set the error foreground color.
 */

void CFilterEdit::SetForegroundColourError( const COLORREF crFgError )
{
   m_crFgError = crFgError;
}

/**
 * true if last entered character is valid.
 */

bool CFilterEdit::IsValidChar()
{
   return m_bCharValid;
}

/**
 * the entered text, so far.
 */

const CString &CFilterEdit::GetProposedText() const
{
   return m_strProposedText;
}

/**
 * true if the entered text is complete and valid.
 */

bool CFilterEdit::IsValidInput()
{
   CString str;

   GetWindowText (str);

   m_bValid = Check( str );

   Invalidate ();

   if (!m_bValid && m_bBeepOnInvalid)
   {
      ::MessageBeep( MB_ICONEXCLAMATION );
   }

   return m_bValid;
}

/*
 * the message map
 */

BEGIN_MESSAGE_MAP( CFilterEdit, CEdit )
   ON_WM_CHAR()
   ON_WM_KEYDOWN()
   ON_WM_KEYUP()
   ON_WM_CTLCOLOR_REFLECT()
   ON_WM_SETFOCUS()
   ON_WM_KILLFOCUS()
   ON_WM_PAINT()
END_MESSAGE_MAP()

/**
 * true if this character is acceptable at this point.
 */

bool CFilterEdit::ValidateChar( UINT nChar )
{
   int  iStartIndex = -1;
   int  iEndIndex   = -1;
   bool bCharValid  = true;

   GetSel (iStartIndex, iEndIndex);
   GetWindowText (m_strProposedText);

   if ( nChar == VK_BACK )
   {
      if ( iStartIndex == iEndIndex )
      {
         iStartIndex--;
      }

      // remove char
      m_strProposedText.Delete( iStartIndex, iEndIndex - iStartIndex );
      bCharValid = Match( m_strProposedText );
   }
   else
   {
      // haven't reached text limit
      m_strProposedText.Delete( iStartIndex, iEndIndex - iStartIndex );
      m_strProposedText.Insert( iStartIndex, static_cast<TCHAR> (nChar) );
      bCharValid = Match( m_strProposedText );
   }

   return bCharValid;
}

#pragma warning( push )
#pragma warning( disable : 4100 )

/**
 * true if input is complete and valid; override in derived classes.
 */

bool CFilterEdit::Check( const CString &csText )
{
   return true;
}

/**
 * true if partial input is acceptable; override in derived classes.
 */

bool CFilterEdit::Match( const CString &csText )
{
   return true;
}

#pragma warning( pop )

/**
 * restore valid state.
 */

void CFilterEdit::ResetValid ()
{
   if ( !m_bValid )
   {
      m_bValid = true;
      Invalidate();
   }
}

/**
 * handle window message, like cut paste etc.
 */

LRESULT CFilterEdit::WindowProc( UINT message, WPARAM wParam, LPARAM lParam )
{
   bool bExecute    = true;
   bool bResetValid = false;
   LRESULT lResult  = 0;

   if ( m_bProcessChars )
   {
      switch ( message )
      {
         case EM_REPLACESEL:
         {
            int iStartIndex = -1;
            int iEndIndex   = -1;
            CString strReplace;

            GetSel( iStartIndex, iEndIndex );
            strReplace = reinterpret_cast<LPCTSTR>( lParam );
            GetWindowText( m_strProposedText );
            m_strProposedText.Delete( iStartIndex, iEndIndex - iStartIndex );
            m_strProposedText.Insert( iStartIndex, strReplace );
            // Don't set m_bCharValid as OnChar not called
            bExecute    = Match( m_strProposedText );
            bResetValid = bExecute;
            break;
         }
   /*
         case EM_SETLIMITTEXT:
         m_uiMaxChars = static_cast<unsigned int> (wParam);
         break;
   */
         case WM_CLEAR:
            bExecute    = CanDelete();
            bResetValid = bExecute;
            break;

         case WM_CUT:
            bExecute    = CanDelete();
            bResetValid = bExecute;
            break;

         case WM_PASTE:
            bExecute    = CanPaste();
            bResetValid = bExecute;
            break;

         case WM_SETTEXT:
         {
            const TCHAR *psz = reinterpret_cast<const TCHAR *>( lParam );

            bExecute    = Match( psz );
            bResetValid = bExecute;
            break;
         }

         case WM_UNDO:
            bResetValid = true;

         default:
            break;
      }
   }

   if ( bExecute )
   {
      lResult = CEdit::WindowProc( message, wParam, lParam );

      if ( bResetValid )
      {
         ResetValid();
      }
   }

   return lResult;
}

/**
 * handle delete (Ctrl+X).
 */

bool CFilterEdit::CanDelete()
{
   CString csText;
   int iStartIndex = -1;
   int iEndIndex   = -1;

   GetWindowText( csText );
   GetSel( iStartIndex, iEndIndex );

   if ( iStartIndex == iEndIndex )
   {
      iEndIndex++;
   }

   csText.Delete( iStartIndex, iEndIndex - iStartIndex );

   return Match( csText );
}

/**
 * handle paste (Ctrl+V).
 */

bool CFilterEdit::CanPaste()
{
   bool bSuccess = OpenClipboard () != 0;

   if ( bSuccess )
   {
#ifdef _UNICODE
      HANDLE hClipMem = ::GetClipboardData( CF_UNICODETEXT );
#else
      HANDLE hClipMem = ::GetClipboardData( CF_TEXT );
#endif

      bSuccess = hClipMem != 0;

      if ( bSuccess )
      {
         const TCHAR *lpClipMem = (const TCHAR *) ::GlobalLock( hClipMem );

         bSuccess = lpClipMem != 0;

         if ( bSuccess )
         {
            CString strClipText;
            CString csText;
            int iStartIndex = -1;
            int iEndIndex   = -1;

            strClipText.Format( _T("%s"), lpClipMem );
            GetWindowText( csText );
            GetSel       ( iStartIndex, iEndIndex   );
            csText.Delete( iStartIndex, iEndIndex - iStartIndex );
            csText.Insert( iStartIndex, strClipText );

            if ( csText.GetLength() > static_cast<int>( GetLimitText() ) )
   //         if (csText.GetLength () > static_cast<int> (m_uiMaxChars))
            {
               csText = csText.Left( GetLimitText() );
   //            csText = csText.Left (m_uiMaxChars);
            }

            bSuccess = Match( csText );
            ::GlobalUnlock( hClipMem );
         }
      }

      ::CloseClipboard();
   }

   return bSuccess;
}

/**
 * validate new character (if SetProcessChars(true)) and let it be further processed, unless its invalid.
 */

void CFilterEdit::OnChar( UINT nChar, UINT nRepCnt, UINT nFlags )
{
   m_bCharValid = !m_bProcessChars || ValidateChar( nChar );

   if ( m_bCharValid )
   {
      CEdit::OnChar( nChar, nRepCnt, nFlags );
   }
}

/**
 * handle control-key press (Del, Ctrl+X, Ctrl+V).
 */

void CFilterEdit::OnKeyDown( UINT nChar, UINT nRepCnt, UINT nFlags )
{
   bool bExecute = true;

   ResetValid();

   if ( nChar == VK_CONTROL )
   {
      m_bControlDown = true;
   }
   else if ( nChar == VK_DELETE )
   {
      if ( m_bProcessChars )
      {
         bExecute = CanDelete();
      }
   }
   else if ( ( nChar == 'x' || nChar == 'X' ) && m_bControlDown )
   {
      if ( m_bProcessChars )
      {
         bExecute = CanDelete();

         if ( bExecute )
         {
            // Will handle cut ourselves, so don't pass char on...
            bExecute = false;
            SendMessage( WM_CUT, 0, 0 );
         }
      }
   }
   // Test for Paste keyboard short-cut
   else if ( ( nChar == 'v' || nChar == 'V' ) && m_bControlDown )
   {
      SendMessage( WM_PASTE, 0, 0 );
   }

   if ( bExecute )
   {
      CEdit::OnKeyDown( nChar, nRepCnt, nFlags );
   }
}

/**
 * handle control-key release (Ctrl).
 */

void CFilterEdit::OnKeyUp( UINT nChar, UINT nRepCnt, UINT nFlags )
{
   if ( nChar == VK_CONTROL )
   {
      m_bControlDown = false;
   }

   CEdit::OnKeyUp( nChar, nRepCnt, nFlags );
}

/**
 * handle the ON_WM_CTLCOLOR_REFLECT message.
 */

HBRUSH CFilterEdit::CtlColor( CDC *pDC, UINT /* nCtlColor */ )
{
   /*
    * See MSDN TN062: Message Reflection for Windows Controls
    */

   HBRUSH hbr = m_brOK;

   /*
    * If m_bSetBkOnError is not set, then use the 'OK' colours to draw anyway.
    */

   if ( m_bValid || !m_bSetBkOnError )
   {
      pDC->SetBkColor  ( m_crBkOK );
      pDC->SetTextColor( m_crFgOK );
   }
   else if ( m_bShowInvalid && m_bSetBkOnError )
   {
      /*
       * If m_bSetBkOnError is set, then change all the colours.
       */

      hbr = m_brError;
      pDC->SetBkColor  ( m_crBkError );
      pDC->SetTextColor( m_crFgError );
   }

   return hbr;
}

/**
 * handle set focus message.
 */

void CFilterEdit::OnSetFocus( CWnd *pOldWnd )
{
   CEdit::OnSetFocus( pOldWnd );
}

/**
 * validate on kill focus message.
 */

void CFilterEdit::OnKillFocus( CWnd *pNewWnd )
{
   bool bValid = true;

   if ( m_bAutoValidate )
   {
      /*
       * Don't beep on exit...
       */

      if ( pNewWnd && pNewWnd != GetParent() && pNewWnd->GetDlgCtrlID() != IDCANCEL )
      {
         bValid = IsValidInput();
      }
      else
      {
         bValid = true;
      }
   }

   if ( bValid || !m_bModal )
   {
      CEdit::OnKillFocus( pNewWnd );
   }
   else
   {
      SetFocus();
   }
}

/**
 * handle paint message.
 */

void CFilterEdit::OnPaint()
{
   CClientDC dc (this);

   //  This stops the control from going grey
   Default();

   if ( !m_bValid && m_bShowInvalid && m_bWavyLineOnError )
   {
      CFont *pFont = GetFont();
      CPen  *pPen  = dc.GetCurrentPen();

      LOGPEN  lp;
      CPen    MyPen;
      CRect   rect;
      CString csText;
      CSize   size;
      int iX = 0;
      const int iIncrement = 2;

      // We must use the correct font when using GetTextExtent..!

      dc.SelectObject( pFont );

      // We have to create a new pen to set a new colour...

      pPen->GetLogPen( &lp );
      lp.lopnColor = m_bSetBkOnError ? m_crFgError : m_crBkError;
      MyPen.CreatePenIndirect( &lp );
      dc.SelectObject( &MyPen );

      // Get the rect for the entire edit control

      GetRect      ( &rect  );
      GetWindowText( csText );

      // This part deals with the *displayed* Text Extent

      size = dc.GetTextExtent( csText.Mid( CharFromPos( CPoint( rect.left + 1, rect.top ) ) ) );

      // Check for case of empty string
      if ( size.cx == 0 )
         size.cx = iIncrement * 3;
      // Dont draw off the end of the edit control
      else if ( size.cx > rect.right )
         size.cx = rect.right;

      // Starting x co-ordinate to start drawing from

      iX = rect.left;

      // Start at the bottom left of the edit control

      dc.MoveTo( rect.left, rect.bottom );

      // Draw the wavy line like in Microsoft Word

      while ( iX < size.cx + rect.left )
      {
         iX += iIncrement;

         if ( iX > size.cx + rect.left )
            break;

         dc.LineTo( iX, rect.bottom + iIncrement );
         iX += iIncrement;

         if ( iX > size.cx + rect.left )
            break;

         dc.LineTo( iX, rect.bottom );
      }
   }

   // Do not call CEdit::OnPaint() for painting messages
}

/*
 * end of file
 */

---