You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
418 lines
10 KiB
418 lines
10 KiB
//////////////////////////////////////////////////////////////////////////////
|
|
/*++
|
|
|
|
Copyright (C) Microsoft Corporation, 1997 - 1999
|
|
|
|
Module Name:
|
|
|
|
DialogWithWorkerThread.h
|
|
|
|
Abstract:
|
|
|
|
Header file for a template class which manages a dialog that will run in the main
|
|
context of the MMC thread. This dialog will spawn off a worker thread
|
|
that will communicate with the main mmc thread via MMC's window
|
|
message pump associated with the dialog.
|
|
|
|
This is an inline template class and there is no .cpp file.
|
|
|
|
Author:
|
|
|
|
Michael A. Maguire 02/28/98
|
|
|
|
Revision History:
|
|
mmaguire 02/28/98 - created
|
|
|
|
|
|
--*/
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
#if !defined(_IAS_DIALOG_WITH_WORKER_THREAD_H_)
|
|
#define _IAS_DIALOG_WITH_WORKER_THREAD_H_
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// BEGIN INCLUDES
|
|
//
|
|
// where we can find what this class derives from:
|
|
//
|
|
#include "Dialog.h"
|
|
//
|
|
//
|
|
// where we can find what this class has or uses:
|
|
//
|
|
#include <process.h>
|
|
//
|
|
// END INCLUDES
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
typedef
|
|
enum _TAG_WORKER_THREAD_STATUS
|
|
{
|
|
WORKER_THREAD_NEVER_STARTED = 0,
|
|
WORKER_THREAD_STARTING,
|
|
WORKER_THREAD_STARTED,
|
|
WORKER_THREAD_START_FAILED,
|
|
WORKER_THREAD_ACTION_INTERRUPTED,
|
|
WORKER_THREAD_FINISHED
|
|
} WORKER_THREAD_STATUS;
|
|
|
|
|
|
// This should be a safe private window message to pass.
|
|
#define WORKER_THREAD_MESSAGE ((WM_USER) + 100)
|
|
|
|
|
|
template <class T>
|
|
class CDialogWithWorkerThread : public CDialogImpl<T>
|
|
{
|
|
|
|
public:
|
|
|
|
// In your derived class, declare the ID of the dialog resource
|
|
// you want for this class in the following manner.
|
|
// An enum must be used here because the correct value of
|
|
// IDD must be initialized before the base class's constructor is called.
|
|
|
|
// enum { IDD = IDD_CONNECT_TO_MACHINE };
|
|
|
|
|
|
BEGIN_MSG_MAP(CDialogWithWorkerThread<T>)
|
|
MESSAGE_HANDLER(WORKER_THREAD_MESSAGE, OnReceiveThreadMessage)
|
|
END_MSG_MAP()
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/*++
|
|
|
|
CDialogWithWorkerThread()
|
|
|
|
Constructor
|
|
|
|
--*/
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
CDialogWithWorkerThread()
|
|
{
|
|
ATLTRACE(_T("# CDialogWithWorkerThread::CDialogWithWorkerThread\n"));
|
|
|
|
|
|
m_wtsWorkerThreadStatus = WORKER_THREAD_NEVER_STARTED ;
|
|
m_ulWorkerThread = NULL;
|
|
m_lRefCount = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/*++
|
|
|
|
~CDialogWithWorkerThread( void )
|
|
|
|
Destructor
|
|
|
|
--*/
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
~CDialogWithWorkerThread( void )
|
|
{
|
|
ATLTRACE(_T("# CDialogWithWorkerThread::~CDialogWithWorkerThread\n"));
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
/*++
|
|
|
|
AddRef
|
|
|
|
COM-style lifetime management.
|
|
|
|
--*/
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
LONG AddRef( void )
|
|
{
|
|
ATLTRACE(_T("# CDialogWithWorkerThread::AddRef\n"));
|
|
|
|
return InterlockedIncrement( &m_lRefCount );
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
/*++
|
|
|
|
Release
|
|
|
|
COM-style lifetime management.
|
|
|
|
--*/
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
LONG Release( BOOL bOwner = TRUE )
|
|
{
|
|
ATLTRACE(_T("# CDialogWithWorkerThread::Release\n"));
|
|
|
|
LONG lRefCount;
|
|
|
|
|
|
if( bOwner && m_hWnd != NULL )
|
|
{
|
|
//
|
|
// Only the thread which created the window managed by this class
|
|
// should call DestroyWindow.
|
|
// Release() with bOwner == TRUE means the owning thread is
|
|
// calling release.
|
|
//
|
|
DestroyWindow();
|
|
}
|
|
|
|
|
|
lRefCount = InterlockedDecrement( &m_lRefCount );
|
|
|
|
|
|
if( lRefCount == 0)
|
|
{
|
|
T * pT = static_cast<T*>(this);
|
|
|
|
delete pT;
|
|
return 0;
|
|
}
|
|
|
|
return lRefCount;
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/*++
|
|
|
|
CDialogWithWorkerThread::StartWorkerThread
|
|
|
|
Instructs this class to create and start the worker thread.
|
|
|
|
You should not need to override this in your derived class.
|
|
|
|
If the worker thread has already been previously started, this function
|
|
will do nothing, and return S_FALSE.
|
|
|
|
--*/
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
HRESULT StartWorkerThread( void )
|
|
{
|
|
ATLTRACE(_T("# CDialogWithWorkerThread::StartWorkerThread\n"));
|
|
|
|
|
|
// Check for preconditions:
|
|
// None.
|
|
|
|
|
|
// Make sure the worker thread isn't already trying to do its job.
|
|
|
|
if( WORKER_THREAD_NEVER_STARTED == m_wtsWorkerThreadStatus
|
|
|| WORKER_THREAD_START_FAILED == m_wtsWorkerThreadStatus
|
|
|| WORKER_THREAD_ACTION_INTERRUPTED == m_wtsWorkerThreadStatus
|
|
|| WORKER_THREAD_FINISHED == m_wtsWorkerThreadStatus
|
|
)
|
|
{
|
|
|
|
// We create a new thread.
|
|
m_wtsWorkerThreadStatus = WORKER_THREAD_STARTING;
|
|
|
|
// Don't use CreateThread if you are using the C Run-Time -- use _beginthread instead.
|
|
// m_hWorkerThread = CreateThread(
|
|
// NULL // pointer to thread security attributes
|
|
// , 0 // initial thread stack size, in bytes
|
|
// , WorkerThreadFunc // pointer to thread function
|
|
// , (LPVOID) this // argument for new thread
|
|
// , 0 // creation flags
|
|
// , &dwThreadId // pointer to returned thread identifier
|
|
// );
|
|
|
|
|
|
m_ulWorkerThread = _beginthread(
|
|
WorkerThreadFunc // pointer to thread function
|
|
, 0 // stack size
|
|
, (void *) this // argument for new thread
|
|
);
|
|
|
|
|
|
if( -1 == m_ulWorkerThread )
|
|
{
|
|
m_wtsWorkerThreadStatus = WORKER_THREAD_START_FAILED;
|
|
return E_FAIL; // ISSUE: better return code?
|
|
}
|
|
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
else
|
|
{
|
|
// Worker thread already in progress.
|
|
return S_FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
/*++
|
|
|
|
GetWorkerThreadStatus
|
|
|
|
--*/
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
WORKER_THREAD_STATUS GetWorkerThreadStatus( void )
|
|
{
|
|
ATLTRACE(_T("# CDialogWithWorkerThread::GetWorkerThreadStatus\n"));
|
|
|
|
return m_wtsWorkerThreadStatus;
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
/*++
|
|
|
|
DoWorkerThreadAction
|
|
|
|
This is called by the worker thread. Override in your derived class and
|
|
perform the actions you want your worker thread to do.
|
|
|
|
--*/
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
virtual DWORD DoWorkerThreadAction()
|
|
{
|
|
ATLTRACE(_T("# CDialogWithWorkerThread::StartWorkerThread -- override in your derived class\n"));
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
/*++
|
|
|
|
PostMessageToMainThread
|
|
|
|
Use this from your worker thread (i.e. within your DoWorkerThreadAction method)
|
|
to pass a message back to the main MMC thread. What you send in wParam and lParam
|
|
will be passed to your OnReceiveThreadMessage method.
|
|
|
|
You should have no need to override this.
|
|
|
|
--*/
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
BOOL PostMessageToMainThread( WPARAM wParam, LPARAM lParam )
|
|
{
|
|
ATLTRACE(_T("# CDialogWithWorkerThread::PostMessageToMainThread\n"));
|
|
|
|
// Check to make sure that this window still exists.
|
|
if( !::IsWindow(m_hWnd) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
return( PostMessage( WORKER_THREAD_MESSAGE, wParam, lParam) );
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
/*++
|
|
|
|
CDialogWithWorkerThread::OnReceiveThreadMessage
|
|
|
|
This is the sink for messages sent to the main thread from the worker thread.
|
|
|
|
Since messages are received here through the Windows message pump, your
|
|
worker thread can pass messages that will be received and processed within
|
|
the main MMC context. So do anything you need to do with MMC interface pointers
|
|
here.
|
|
|
|
Override in your derived class and process any messages your worker thread might send.
|
|
|
|
--*/
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
virtual LRESULT OnReceiveThreadMessage(
|
|
UINT uMsg
|
|
, WPARAM wParam
|
|
, LPARAM lParam
|
|
, BOOL& bHandled
|
|
)
|
|
{
|
|
ATLTRACE(_T("# CDialogWithWorkerThread::OnReceiveThreadMessage\n"));
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
WORKER_THREAD_STATUS m_wtsWorkerThreadStatus;
|
|
|
|
|
|
private:
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
/*++
|
|
|
|
WorkerThreadFunc
|
|
|
|
You should not need to override this function. It is passed to the
|
|
thread creation API call as the thread start procedure in StartWorkerThread.
|
|
|
|
It is passed a pointer to 'this' of this class, which it casts and calls
|
|
DoWorkerThreadAction on. Override DoWorkerThreadAction in your derived class.
|
|
|
|
--*/
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Use of _beginthread instead of CreateThread requires different declaration.
|
|
// static DWORD WINAPI WorkerThreadFunc( LPVOID lpvThreadParm )
|
|
static void _cdecl WorkerThreadFunc( LPVOID lpvThreadParm )
|
|
{
|
|
ATLTRACE(_T("# WorkerThreadFunc -- no need to override.\n"));
|
|
|
|
// Check for preconditions:
|
|
_ASSERTE( lpvThreadParm != NULL );
|
|
|
|
|
|
DWORD dwReturnValue;
|
|
|
|
// The lpvThreadParm we were passed will be a pointer to 'this' for T.
|
|
T * pT = static_cast<T*>(lpvThreadParm);
|
|
|
|
pT->AddRef();
|
|
dwReturnValue = pT->DoWorkerThreadAction();
|
|
|
|
// Call Release with bOwner = FALSE -- we are not the owning thread.
|
|
pT->Release(FALSE);
|
|
|
|
// This is bad -- we don't want to clobber whatever value the DoWorkerThreadAction
|
|
// assigned to m_wtsWorkerThreadStatus -- it is reponsible for saying whether the
|
|
// task was finished properly.
|
|
// pT->m_wtsWorkerThreadStatus = WORKER_THREAD_FINISHED;
|
|
|
|
// Use of _beginthread instead of CreateThread requires different declaration.
|
|
// return dwReturnValue;
|
|
}
|
|
|
|
|
|
unsigned long m_ulWorkerThread;
|
|
|
|
LONG m_lRefCount;
|
|
|
|
|
|
};
|
|
|
|
|
|
#endif // _IAS_DIALOG_WITH_WORKER_THREAD_H_
|