Filter Library

Camera

Interface Physics

ProgressDlg.cpp

/*
 * ProgressDlg.cpp - progress dialog for computational intensive operations.
 *
 * 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.
 *
 * Authors: M. Seynen (original), Martin J. Moene (complete rewrite)
 *
 * $Id: ProgressDlg.cpp 252 2005-09-19 14:19:24Z moene $
 */

/*
 * included files:
 */

#include "stdafx.h"                     // for common (pre-compiled) headers
//#include <cfl/stdafx.h>                 // for common (pre-compiled) headers
#include <cfl/resource.h>               // for dialog resources
#include <cfl/ProgressDlg.h>            // this class

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

/**
 * our timer event.
 */
const int CProgressDlg::c_nTimerIDEvent = 0x123;

/**
 * (default) constructor.
 */
CProgressDlg::CProgressDlg( CWnd* pParent /*= NULL */ ) :
   CDialog( CProgressDlg::IDD, pParent ),
   m_pThread         ( NULL  ),         // the computation thread
//   m_wndProgress;                     // advanced progress bar from Rogue Wave Objective Toolkit
   m_bInitialized    ( FALSE ),         // set flag after successful OnInitDialog()
   m_bCancel         ( FALSE ),         // Cancel-button or Esc-key pressed flag
   m_bResumed        ( FALSE ),         // computation thread has been resumed flag
   m_nLowerPosition  (   0   ),         // progress bar lower position
   m_nUpperPosition  (   1   ),         // progress bar upper position
   m_nCurrentPosition(   0   )          // progress bar current position
{
//   Q_LOG( _T("CProgressDlg::CProgressDlg()") );

   //{{AFX_DATA_INIT(CProgressDlg)
   //}}AFX_DATA_INIT
}

/**
 * destructor.
 */
CProgressDlg::~CProgressDlg()
{
//   Q_LOG( _T("CProgressDlg::~CProgressDlg()") );
}

/**
 * the thread has informed us that it has been resumed.
 */
BOOL CProgressDlg::IsResumed()
{
   /*
    * simple boolean: we don't use the critical section.
    */
   return m_bResumed;
}

/**
 * Cancel-button or Escape-key pressed (window close message).
 */
BOOL CProgressDlg::IsCanceling()
{
   /*
    * simple boolean: we don't use the critical section.
    */
   return m_bCancel;
}

/**
 * Cancel-button or Esc-key pressed; alias for IsCanceling().
 */
BOOL CProgressDlg::StopRequested()
{
   return IsCanceling();
}

/**
 * set resumed flag.
 */
void CProgressDlg::SetResumed()
{
   /*
    * "produce":
    * simple boolean: we don't use the critical section.
    */
   m_bResumed = TRUE;
}

/**
 * set progress bar range; Note just store, OnTimer updates dialog.
 */
void CProgressDlg::SetRange( int nLower, int nUpper )
{
   /*
    * "produce":
    */
   m_criticalSection.Lock();
   m_nLowerPosition = nLower;
   m_nUpperPosition = nUpper;
   m_criticalSection.Unlock();
}

/**
 * set progress bar position; Note just store, OnTimer updates dialog.
 */
void CProgressDlg::SetPos( int nPos )
{
   /*
    * "produce":
    */
   m_criticalSection.Lock();
   m_nCurrentPosition = nPos;
   m_criticalSection.Unlock();
}

/**
 * set progress dialog message text; Note just store, OnTimer updates dialog.
 */
void CProgressDlg::SetText( LPCTSTR lpcsText )
{
   /*
    * "produce":
    */
   m_criticalSection.Lock();
   m_csMessage = lpcsText;
   m_criticalSection.Unlock();
}

/**
 * close the progress dialog window.
 */
void CProgressDlg::Terminate()
{
   /**
    * give dialog a chance to get initialized and show itself.
    *
    * this only affects computation threads that already have finished before
    * the dialog has been completely initialized.
    */
   while ( !m_bInitialized )
   {
      Sleep( 50 );
   }

   if ( !IsCanceling() )
   {
      ::PostMessage( m_hWnd, WM_CLOSE, 0, 0 );
   }
}

/**
 * show as modal dialog box, resume computation thread.
 */
int CProgressDlg::DoModal( CWinThread *pThread )
{
   /*
    * resume computation thread and show the modal dialog:
    */
   return ResumeComputationThread( pThread )
       && CDialog::DoModal();
}

/**
 * exchange dialog.
 */
void CProgressDlg::DoDataExchange( CDataExchange* pDX )
{
//   Q_LOG( _T("CProgressDlg::DoDataExchange()") );

   CDialog::DoDataExchange(pDX);

   //{{AFX_DATA_MAP(CProgressDlg)
   //}}AFX_DATA_MAP
}

/**
 * the message map.
 */
BEGIN_MESSAGE_MAP(CProgressDlg, CDialog)
   //{{AFX_MSG_MAP(CProgressDlg)
   ON_WM_TIMER()
   ON_WM_CLOSE()
   ON_BN_CLICKED( IDCANCEL, OnCancel )
   //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/*
 * initialize the dialog.
 */
BOOL CProgressDlg::OnInitDialog()
{
   CDialog::OnInitDialog();

   /*
    * attach this dialog to the Objective Toolkit's advanced progress bar:
    */
   m_wndProgress.AttachProgress( IDC_PROGRESS, this );

   /*
    * attach this dialog to the Objective Toolkit's advanced progress bar:
    */
   (void) CWnd::SetTimer( c_nTimerIDEvent, 50 /* ms */, NULL );

   /*
    * indicate that dialog has been initialized, see also Terminate():
    */
   m_bInitialized = TRUE;

   return TRUE;
}

/**
 * handle cancel message;
 * OnCancel may be called as a result of pressing the Cancel button, of
 * pressing the Esc-key or as a result of sending WM_CLOSE to the dialog.
 */
void CProgressDlg::OnCancel()
{
//  Q_LOG( "CProgressDlg::OnCancel()" );

   /*
    * signal computation thread to stop:
    */
   m_bCancel = TRUE;

   /*
    * wait for computation thread to finish, unless it was not (yet) resumed:
    */
   if ( IsResumed() )
   {
      (void) WaitForSingleObject( m_pThread->m_hThread, INFINITE );
   }

   /*
    * stop the timer:
    */
   (void) CWnd::KillTimer( c_nTimerIDEvent );

//   Q_ASSERT( FALSE != KillTimer( c_nTimerIDEvent ) && "failed to kill progress dialog timer" );

   /*
    * the rest of the work:
    */
   CDialog::OnCancel();
}

/**
 * handle OnClose event.
 */
void CProgressDlg::OnClose()
{
   CDialog::OnCancel();
}

/**
 * handle timer event: update progress dialog.
 */
void CProgressDlg::OnTimer( UINT nIDEvent )
{
   if ( nIDEvent == c_nTimerIDEvent )
   {
      /*
       * "consume":
       */
      m_criticalSection.Lock();

      SetDlgItemText( IDC_PROGRESSTEXT, m_csMessage );
      m_wndProgress.SetRange( m_nLowerPosition, m_nUpperPosition );
      m_wndProgress.SetPos( m_nCurrentPosition );

      m_criticalSection.Unlock();
   }
}

/**
 * resume the given thread.
 */
int CProgressDlg::ResumeComputationThread( CWinThread *pThread )
{
   /*
    * save thread for later use in OnCancel():
    */
   m_pThread = pThread;

   /*
    * resume the computation thread:
    *
    * ResumeThread() returns the thread’s previous suspend count if successful:
    *  0: the current thread was not suspended
    *  1: the thread was suspended, but is now restarted
    * >1: the thread remains suspended.
    * 0xFFFFFFFF: error
    */
   if ( m_pThread->ResumeThread() != 1 )
   {
      LPVOID lpMsgBuf;

      ::FormatMessage(
         FORMAT_MESSAGE_ALLOCATE_BUFFER |
         FORMAT_MESSAGE_FROM_SYSTEM |
         FORMAT_MESSAGE_IGNORE_INSERTS, // source and processing options
         NULL,                          // pointer to  message source
         GetLastError(),                // requested message identifier
         MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), // default language
         (LPTSTR) &lpMsgBuf,            // pointer to message buffer
         0,                             // maximum size of message buffer
         NULL                           // pointer to array of message inserts
      );

      /*
       * log the error and free the buffer:
       */
      Q_LOG( (LPCTSTR) ( CString("ResumeThread: ") + (LPCTSTR) lpMsgBuf ) );
      LocalFree( lpMsgBuf );

      /*
       * inform user:
       */
      ::MessageBox(
         this->m_hWnd,
         _T( "Could not start the computation thread.\n\n"
             "Details have been written to the log file." ),
         _T( "Thread start failure" ),
         MB_ICONSTOP | MB_OK
      );

      /*
       * return error:
       */
      return FALSE;
   }

   /*
    * thread signals via SetResumed() that it has been resumed.
    */
   SetResumed();

   return TRUE;
}

/*
 * end of file
 */

---