Filter Library

Camera

Interface Physics

ScanFilter.cpp

/*
 * ScanFilter.cpp - scan filter base class.
 *
 * 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.
 *
 * Authors: M. Seynen (original), Martin J. Moene
 *
 * $Id: ScanFilter.cpp 190 2005-05-04 15:08:00Z moene $
 */

#include "stdafx.h"                     // for common (pre-compiled) headers
//#include <cfl/stdafx.h>                 // for common (pre-compiled) headers
#include <cfl/resource.h>               // for messages and other resources

#include <Camera/InterfaceDll.h>        // Camera--Filter Library interface
#include <cfl/ScanBaseBuffer.h>         // for class CScanBaseBuffer
#include <cfl/ScanFilter.h>             // header

#include <cfl/FilterDlg.h>              // for class CFilterDlg

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

LPCTSTR CScanFilter::m_lpcsFilterName = _T("BASECLASS");
                                        // this filter's short name
LPCTSTR CScanFilter::m_lpcsShortFilterName = CScanFilter::m_lpcsFilterName;

IMPLEMENT_SERIAL( CScanFilter, CObject, 0 )

/**
 * a non-intersecting rectangle.
 */
const CRect CScanFilter::NonIntersectingRect = CRect( -1, -1, -2, -2 );

/*
 * default constructor.
 */
CScanFilter::CScanFilter() :
   m_pDlg        ( NULL ),
   m_lpsbIn      ( NULL ),
   m_lpsbOut     ( NULL ),
   m_csFilterName( m_lpcsFilterName )
//   m_bInEditModeless( false )                 // FIXME: kan bee removed
{
   ; // do nothing
}

/*
 * destructor; clean-up the dialog if it exists.
 */
CScanFilter::~CScanFilter()
{
   if ( m_pDlg )
   {
      m_pDlg->DestroyWindow();
      delete m_pDlg; m_pDlg = 0;
   }
}

/*
 * default is to not support partial data; override if filter does support it.
 */
BOOL CScanFilter::CanDoPartialData() const
{
   return FALSE;
}

/**
 * default is to support a dialog; override if filter does not support it.
 */
BOOL CScanFilter::CanDoDialogEntry() const
{
   return TRUE;
}

/**
 * default is to not support dragging; override if filter does support it.
 */
DragSupportType CScanFilter::SupportDragInput() const
{
   return SFDS_NONE;
}

/*
 * default is to not require a rectangular) selection before applying filter;
 * override if filter does require it.
 */
BOOL CScanFilter::NeedRectSelection() const
{
   return FALSE;
}

/*
 * the name of this filter.
 */
LPCTSTR CScanFilter::GetFilterName() const
{
   return m_csFilterName;
}

#pragma warning( push )
#pragma warning( disable : 4100 )       // unreferenced formal parameter

/*
 * set the rectangular drag area for given L2R or R2L part of frame; override
 * for filters that support dragging.
 */
void CScanFilter::SetDragInput( BOOL bL2R, CRect rcIn )
{
   return;
}

/*
 * default is one input buffer; override of filter uses more.
 */
CScanFilter::SizeType CScanFilter::GetNrOfInBuffers() const
{
   return 1;
}

/*
 * provide the input buffer for the given index.
 */
CScanBaseBuffer *CScanFilter::GetInputBuffer( UINT nNr )
{
   Q_ASSERT(  nNr == 0 && "buffernr. can only be zero" );

   return m_lpsbIn;
}

/*
 * set the input buffer for the given index.
 */
void CScanFilter::SetInputBuffer( UINT nNr, CScanBaseBuffer *lpsbIn )
{
   Q_ASSERT(  nNr == 0      && "input buffer nr. can only be zero" );
   Q_ASSERT( NULL != lpsbIn && "valid buffer required"             );

   m_lpsbIn = lpsbIn;
}

/*
 * default is one output buffer; override of filter uses more.
 */
CScanFilter::SizeType CScanFilter::GetNrOfOutBuffers() const
{
   return 1;
}

/*
 * provide the output buffer for the given index.
 */
CScanBaseBuffer *CScanFilter::GetOutputBuffer( UINT nNr )
{
   return m_lpsbOut;
}

/*
 * set the output buffer for the given index.
 */
void CScanFilter::SetOutputBuffer( UINT nNr, CScanBaseBuffer *lpsbOut )
{
   Q_ASSERT(  nNr == 0       && "output buffer nr. can only be zero" );
   Q_ASSERT( NULL != lpsbOut && "valid buffer required"              );

   m_lpsbOut = lpsbOut;
}

/*
 * true if a dialog is present
 */
bool CScanFilter::IsInteractive() const
{
   return NULL != m_pDlg;
}

/*
 * configure filter with default setting or with settings as saved from the
 * last invocation (e.g. from registry).
 */
void CScanFilter::ReadFilterSettings ()
{
   ; // do nothing
}

/*
 * save filter settings e.g. for use with the filterlist window (e.g. via registry).
 */
void CScanFilter::WriteFilterSettings () const
{
   ; // do nothing
}

/*
 * baseclass can't do this. It should be handled by the derived class.
 * Make sure your filter handles these functions.
 */
LPCTSTR CScanFilter::GetParameters() const
{
   Q_ASSERT( 0 && "CScanFilter::GetParameters() must be overridden" );
   return NULL;
}

/*
 * baseclass can't do this. It should be handled by the derived class.
 * Make sure your filter handles these functions.
 */
BOOL CScanFilter::SetParameters( LPCTSTR lpParameters )
{
   Q_ASSERT( 0 && "CScanFilter::SetParameters() must be overridden" );
   return FALSE;
}

/*
 * start filter dialog, allow for user input but do not perform filter operations;
 * default implementation: return FALSE.
 */
BOOL CScanFilter::EditModeless( CWnd* pParentWnd )
{
   return FALSE;
}

/*
 * start filter dialog, allow for user input and perform filter operations;
 * default implementation: return FALSE.
 */
BOOL CScanFilter::RunModeless( CWnd* pParentWnd, CDocument* pDoc )
{
   return FALSE;
}

#pragma warning( pop )

/*
 * perform the filter operation without user interaction; also used to process
 * series of buffers.
 */
BOOL CScanFilter::Apply()
{
   Q_ASSERT( NULL != m_lpsbIn  && "CScanFilter::Apply(): valid input buffer required" );
   Q_ASSERT( NULL != m_lpsbOut && "CScanFilter::Apply(): valid output buffer required" );

//    /*
//     * default Filter behavior is a simple copy function: the scan data is not copied!
//     * copying of the latter should be done in the derived class.
//     */
//
//    m_lpsbOut->CreateOutputBufferFor( *m_lpsbIn );
//    m_lpsbOut->m_dwParameterMask  = 0;                           // Recalculate all temp variables

   return TRUE;
}

/*
 * save or restore filter from archive.
 */
void CScanFilter::Serialize( CArchive& ar )
{
   CObject::Serialize( ar );

   if( ar.IsStoring() )
   {
   }
   else
   {
   }
};

/*
 * end of file
 */

---