modif struct svnwindows@3001

1 files changed, 0 insertions, 2026 deletions

diff --git a/Bus/IvyFileMon/DirectoryChanges.cpp b/Bus/IvyFileMon/DirectoryChanges.cpp
deleted file mode 100644
index 10b88b3..0000000
--- a/Bus/IvyFileMon/DirectoryChanges.cpp
+++ /dev/null
@@ -1,2026 +0,0 @@
-// DirectoryChanges.cpp: implementation of the CDirectoryChangeWatcher and CDirectoryChangeHandler classes.

-//

-///////////////////////////////////////////////////////////////////

-///

-

-/***********************************************************

-

-  Author:	Wes Jones wesj@hotmail.com

-

-  File:		DirectoryChanges.cpp

-

-  Latest Changes:

-

-		11/22/2001	--	Fixed bug causing file name's to be truncated if

-						longer than 130 characters. Fixed CFileNotifyInformation::GetFileName()

-						Thanks to Edric(uo_edric@hotmail.com) for pointing this out.

-

-						Added code to enable process privileges when CDirectoryChangeWatcher::WatchDirectory() 

-						is first called.	See docuementation API for ReadDirectoryChangesW() for more information of required privileges.

-						

-						  Currently enables these privileges: (11/22/2001)

-							SE_BACKUP_NAME

-							SE_CHANGE_NOTIFY_NAME 

-							SE_RESTORE_NAME(02/09/2002)

-						Implemented w/ helper class CPrivilegeEnabler.

-

-		11/23/2001		Added classes so that all notifications are handled by the

-						same thread that called CDirectoryChangeWatcher::WatchDirectory(),

-						ie: the main thread.

-						CDirectoryChangeHandler::On_Filexxxx() functions are now called in the 

-						context of the main thread instead of the worker thread.

-

-						This is good for two reasons:

-						1: The worker thread spends less time handling each notification.

-							The worker thread simply passes the notification to the main thread,

-							which does the processing.

-							This means that each file change notification is handled as fast as possible

-							and ReadDirectoryChangesW() can be called again to receive more notifications

-							faster.

-

-						2:	This makes it easier to make an ActiveX or ATL object with this class

-							because the events that are fired, fire in the context of the main thread.

-							The fact that I'm using a worker thread w/ this class is totally 

-							transparent to a client user.

-							If I decide to turn this app into an ActiveX or ATL object

-							I don't have to worry about wierd COM rules and multithreading issues,

-							and neither does the client, be the client a VB app, C++ app, Delphi app, or whatever.

-

-						Implemented with CDelayedDirectoryChangeHandler in DirectoryChangeHandler.h/.cpp

-

-		02/06/2002	  Fixed a bug that would cause an application to hang.

-						If ReadDirectoryChangesW was to fail during normal operation,

-						the short story is that the application would hang

-						when it called CDirectoryChangeWatcher::UnwatchDirectory(const CString & )

-

-						One way to reproduce this behavior on the old code

-						is to watch a directory using a UNC path, and then change the IP

-						address of that machine while the watch was running.  Exitting 

-						the app after this would cause it to hang.

-

-						Steps to reproduce it:

-

-						1) Assume that the computer running the code is

-							named 'ThisComputer' and there is a shared folder named 'FolderName'

-

-

-						2) Start a watch on a folder using a UNC path:  ie: \\ThisComputer\FolderName

-						

-						  eg:	CDirectoryChangeWatcher	watcher;

-							 

-								watcher.WatchDirectory(_T("\\\\ThisComputer\\FolderName",/ * other parameters * /)

-							

-						3)  Change the IP address of 'ThisComputer'

-

-							   ** ReadDirectoryChangesW() will fail some point after this.

-						

-		

-						4)  Exit the application... it may hang.

-

-

-						Anyways, that's what the bug fix is for.

-

-

-		02/06/2002	New side effects for CDirectoryChangeHandler::On_ReadDirectoryChangeError()

-

-					If CDirectoryChangeHandler::On_ReadDirectoryChangeError() is ever executed

-					the directory that you are watching will have been unwatched automatically due

-					to the error condition.

-

-					A call to CDirectoryChangeWatcher::IsWatchingDirectory() will fail because the directory

-					is no longer being watched. You'll need to re-watch that directory.

-

-		02/09/2002	Added a parameter to CDirectoryChangeHandler::On_ReadDirectoryChangeError()

-

-					Added the parameter: const CString & strDirectoryName

-					The new signature is now:

-							virtual void CDirectoryChangeHandler::On_ReadDirectoryChangeError(DWORD dwError, const CString & strDirectoryName);

-

-					This new parameter gives you the name of the directory that the error occurred on.

-

-		04/25/2002  Provided a way to get around the requirement of a message pump.

-					A console app can now use this w/out problems by passing false

-					to the constructor of CDirectoryChangeWatcher. 

-					An app w/ a message pump can also pass false if it so desires w/out problems.

-

-		04/25/2002	Added two new virtual functions to CDirectoryChangeHandler

-

-					Added:

-							On_WatchStarted(DWORD dwError, const CString & strDirectoryName)

-							On_WatchStopped(const CString & strDirectoryName);

-					See header file for details.

-

-		04/27/2002	Added new function to CDirectoryChangeHandler:

-

-					Added virtual bool On_FilterNotification(DWORD dwNotifyAction, LPCTSTR szFileName, LPCTSTR szNewFileName)

-

-					This function is called before any notification function, and allows the 

-					CDirectoryChangeHandler derived class to ignore file notifications 

-					by performing a programmer defined test.

-					By ignore, i mean that 

-						On_FileAdded(), On_FileRemoved(), On_FileModified(), or On_FileNameChanged()

-						will NOT be called if this function returns false.

-

-					The default implementation always returns true, signifying that ALL notifications

-					are to be called.

-

-

-		04/27/2002  Added new Parameters to CDirectoryChangeWatcher::WatchDirectory()

-

-					The new parameters are: 

-										LPCTSTR szIncludeFilter 

-										LPCTSTR szExcludeFilter

-					Both parameters are defaulted to NULL.

-					Signature is now:

-					CDirectoryChangeWatcher::WatchDirectory(const CString & strDirToWatch, 

-															DWORD dwChangesToWatchFor, 

-															CDirectoryChangeHandler * pChangeHandler, 

-															BOOL bWatchSubDirs = FALSE,

-															LPCTSTR szIncludeFilter = NULL,

-															LPCTSTR szExcludeFilter = NULL)

-

-		04/27/2002	Added support for include and exclude filters.

-					These filters allow you to receive notifications for just the files you

-					want... ie: you can specify that you only want to receive notifications

-					for changes to "*.txt" files or some other such file filter.

-

-					NOTE: This feature is implemented w/ the PathMatchSpec() api function

-					which is only available on NT4.0 if Internet Explorer 4.0 or above is installed.

-					See MSDN for PathMatchSpec().  Win2000, and XP do not have to worry about it.

-

-					Filter specifications:

-					   Accepts wild card characters * and ?, just as you're used to for the DOS dir command.

-					   It is possible to specify multiple extenstions in the filter by separating each filter spec

-					   with a semi-colon. 

-					   eg: "*.txt;*.tmp;*.log"  <-- this filter specifies all .txt, .tmp, & .log files

-

-					

-

-					Filters are passed as parameters to CDirectoryChangeWatcher::WatchDirectory()

-

-					NOTE: The filters you specify take precedence over CDirectoryChangeHandler::On_FilterNotification().

-						  This means that if the file name does not pass the filters that you specify

-						  when the watch is started, On_FilterNotification() will not be called.

-						  Filter specifications are case insensitive, ie: ".tmp" and ".TMP" are the same

-

-

-					FILTER TYPES:

-							Include Filter:

-										If you specify an include filter, you are specifying that you

-										only want to receive notifications for specific file types.

-										eg: "*.log" means that you only want notifications for changes 

-											to files w/ an exention of ".log". 

-											Changes to ALL OTHER other file types are ignored.

-										An empty, or not specified include filter means that you want

-										notifications for changes of ALL file types.

-							Exclude filter:

-

-										If you specify an exclude filter, you are specifying that

-										you do not wish to receive notifications for a specific type of file or files.

-										eg: "*.tmp" would mean that you do not want any notifications 

-											regarding files that end w/ ".tmp"

-										An empty, or not specified exclude filter means that

-										you do not wish to exclude any file notifications.

-

-

-

-

-

-		

-					

-************************************************************/

-

-#include "stdafx.h"

-#include "DirectoryChanges.h"

-#include "DelayedDirectoryChangeHandler.h"

-

-#ifdef _DEBUG

-#undef THIS_FILE

-static char THIS_FILE[]=__FILE__;

-#define new DEBUG_NEW

-#endif

-//

-//

-//	Fwd Declares & #define's

-//

-//

-//

-// Helper classes

-class CPrivilegeEnabler;	 //for use w/ enabling process priveledges when this code is first used. It's a singleton.

-

-class CFileNotifyInformation;//helps CDirectoryChangeWatcher class notify CDirectoryChangeHandler class of changes to files. 

-

-class CDelayedDirectoryChangeHandler;	//	Helps all notifications become handled by the main

-										//	thread, or a worker thread depending upon a value passed to the 

-										//	constructor of CDirectoryChangeWatcher.

-										//	

-										//	For notifications to fire in the main thread, your app must have a message pump.

-										//

-										//  The 'main' thread is the one that called CDirectoryChangeWatcher::WatchDirectory()

-

-// Helper functions

-static BOOL	EnablePrivilege(LPCTSTR pszPrivName, BOOL fEnable = TRUE);

-static bool IsDirectory(const CString & strPath);

-/////////////////////////////////////////////////////////////////////

-//	Helper functions.

-BOOL	EnablePrivilege(LPCTSTR pszPrivName, BOOL fEnable /*= TRUE*/) 

-//

-//	I think this code is from a Jeffrey Richter book...

-//

-//	Enables user priviledges to be set for this process.

-//	

-//	Process needs to have access to certain priviledges in order

-//	to use the ReadDirectoryChangesW() API.  See documentation.

-{    

-	BOOL fOk = FALSE;    

-	// Assume function fails    

-	HANDLE hToken;    

-	// Try to open this process's access token    

-	if (OpenProcessToken(GetCurrentProcess(), 		

-					TOKEN_ADJUST_PRIVILEGES, &hToken)) 	

-	{        

-		// privilege        

-		TOKEN_PRIVILEGES tp = { 1 };        

-

-		if( LookupPrivilegeValue(NULL, pszPrivName,  &tp.Privileges[0].Luid) )

-		{

-			tp.Privileges[0].Attributes = fEnable ?  SE_PRIVILEGE_ENABLED : 0;

-

-			AdjustTokenPrivileges(hToken, FALSE, &tp, 			      

-									sizeof(tp), NULL, NULL);

-

-			fOk = (GetLastError() == ERROR_SUCCESS);		

-		}

-		CloseHandle(hToken);	

-	}	

-	return(fOk);

-}

-

-static bool IsDirectory(const CString & strPath)

-//

-//  Returns: bool

-//		true if strPath is a path to a directory

-//		false otherwise.

-//

-{

-	DWORD dwAttrib	= GetFileAttributes( strPath );

-	return static_cast<bool>( ( dwAttrib != 0xffffffff 

-							&&	(dwAttrib & FILE_ATTRIBUTE_DIRECTORY)) );

-

-		

-}

-///////////////////////////////////////////////

-//Helper class:

-

-class CFileNotifyInformation 

-/*******************************

-

-A Class to more easily traverse the FILE_NOTIFY_INFORMATION records returned 

-by ReadDirectoryChangesW().

-

-FILE_NOTIFY_INFORMATION is defined in Winnt.h as: 

-

- typedef struct _FILE_NOTIFY_INFORMATION {

-    DWORD NextEntryOffset;

-	DWORD Action;

-    DWORD FileNameLength;

-    WCHAR FileName[1];

-} FILE_NOTIFY_INFORMATION, *PFILE_NOTIFY_INFORMATION;	

-

-  ReadDirectoryChangesW basically puts x amount of these records in a 

-  buffer that you specify.

-  The FILE_NOTIFY_INFORMATION structure is a 'dynamically sized' structure (size depends on length

-  of the file name (+ sizeof the DWORDs in the struct))

-

-  Because each structure contains an offset to the 'next' file notification

-  it is basically a singly linked list.  This class treats the structure in that way.

-  

-

-  Sample Usage:

-  BYTE Read_Buffer[ 4096 ];

-

-  ...

-  ReadDirectoryChangesW(...Read_Buffer, 4096,...);

-  ...

-

-  CFileNotifyInformation notify_info( Read_Buffer, 4096);

-  do{

-	    switch( notify_info.GetAction() )

-		{

-		case xx:

-		    notify_info.GetFileName();

-		}

-

-  while( notify_info.GetNextNotifyInformation() );

-  

-********************************/

-{

-public:

-	CFileNotifyInformation( BYTE * lpFileNotifyInfoBuffer, DWORD dwBuffSize)

-	: m_pBuffer( lpFileNotifyInfoBuffer ),

-	  m_dwBufferSize( dwBuffSize )

-	{

-		ASSERT( lpFileNotifyInfoBuffer && dwBuffSize );

-		

-		m_pCurrentRecord = (PFILE_NOTIFY_INFORMATION) m_pBuffer;

-	}

-

-	

-	BOOL GetNextNotifyInformation();

-	

-	BOOL CopyCurrentRecordToBeginningOfBuffer(OUT DWORD & ref_dwSizeOfCurrentRecord);

-

-	DWORD	GetAction() const;//gets the type of file change notifiation

-	CString GetFileName()const;//gets the file name from the FILE_NOTIFY_INFORMATION record

-	CString GetFileNameWithPath(const CString & strRootPath) const;//same as GetFileName() only it prefixes the strRootPath into the file name

-

-	

-protected:

-	BYTE * m_pBuffer;//<--all of the FILE_NOTIFY_INFORMATION records 'live' in the buffer this points to...

-	DWORD  m_dwBufferSize;

-	PFILE_NOTIFY_INFORMATION m_pCurrentRecord;//this points to the current FILE_NOTIFY_INFORMATION record in m_pBuffer

-	

-};

-

-BOOL CFileNotifyInformation::GetNextNotifyInformation()

-/***************

-  Sets the m_pCurrentRecord to the next FILE_NOTIFY_INFORMATION record.

-

-  Even if this return FALSE, (unless m_pCurrentRecord is NULL)

-  m_pCurrentRecord will still point to the last record in the buffer.

-****************/

-{

-	if( m_pCurrentRecord 

-	&&	m_pCurrentRecord->NextEntryOffset != 0UL)//is there another record after this one?

-	{

-		//set the current record to point to the 'next' record

-		PFILE_NOTIFY_INFORMATION pOld = m_pCurrentRecord;

-		m_pCurrentRecord = (PFILE_NOTIFY_INFORMATION) ((LPBYTE)m_pCurrentRecord + m_pCurrentRecord->NextEntryOffset);

-

-		ASSERT( (DWORD)((BYTE*)m_pCurrentRecord - m_pBuffer) < m_dwBufferSize);//make sure we haven't gone too far

-

-		if( (DWORD)((BYTE*)m_pCurrentRecord - m_pBuffer) > m_dwBufferSize )

-		{

-			//we've gone too far.... this data is hosed.

-			//

-			// This sometimes happens if the watched directory becomes deleted... remove the FILE_SHARE_DELETE flag when using CreateFile() to get the handle to the directory...

-			m_pCurrentRecord = pOld;

-		}

-					

-		return (BOOL)(m_pCurrentRecord != pOld);

-	}

-	return FALSE;

-}

-

-BOOL CFileNotifyInformation::CopyCurrentRecordToBeginningOfBuffer(OUT DWORD & ref_dwSizeOfCurrentRecord)

-/*****************************************

-   Copies the FILE_NOTIFY_INFORMATION record to the beginning of the buffer

-   specified in the constructor.

-

-   The size of the current record is returned in DWORD & dwSizeOfCurrentRecord.

-   

-*****************************************/

-{

-	ASSERT( m_pBuffer && m_pCurrentRecord );

-	if( !m_pCurrentRecord ) return FALSE;

-

-	BOOL bRetVal = TRUE;

-

-	//determine the size of the current record.

-	ref_dwSizeOfCurrentRecord = sizeof( FILE_NOTIFY_INFORMATION );

-	//subtract out sizeof FILE_NOTIFY_INFORMATION::FileName[1]

-	WCHAR FileName[1];//same as is defined for FILE_NOTIFY_INFORMATION::FileName

-	UNREFERENCED_PARAMETER(FileName);

-	ref_dwSizeOfCurrentRecord -= sizeof(FileName);   

-	//and replace it w/ value of FILE_NOTIFY_INFORMATION::FileNameLength

-	ref_dwSizeOfCurrentRecord += m_pCurrentRecord->FileNameLength;

-

-	ASSERT( (DWORD)((LPBYTE)m_pCurrentRecord + ref_dwSizeOfCurrentRecord) <= m_dwBufferSize );

-

-	ASSERT( (void*)m_pBuffer != (void*)m_pCurrentRecord );//if this is the case, your buffer is way too small

-	if( (void*)m_pBuffer != (void*) m_pCurrentRecord )

-	{//copy the m_pCurrentRecord to the beginning of m_pBuffer

-		

-		ASSERT( (DWORD)m_pCurrentRecord > (DWORD)m_pBuffer + ref_dwSizeOfCurrentRecord);//will it overlap?

-		__try{

-			memcpy(m_pBuffer, m_pCurrentRecord, ref_dwSizeOfCurrentRecord);

-			bRetVal = TRUE;

-		}

-		__except(EXCEPTION_EXECUTE_HANDLER)

-		{

-			TRACE(_T("EXCEPTION!  CFileNotifyInformation::CopyCurrentRecordToBeginningOfBuffer() -- probably because bytes overlapped in a call to memcpy()"));

-			bRetVal = FALSE;

-		}

-	}

-	//else

-	//there was only one record in this buffer, and m_pCurrentRecord is already at the beginning of the buffer

-	return bRetVal;

-}

-

-DWORD CFileNotifyInformation::GetAction() const

-{ 

-	ASSERT( m_pCurrentRecord );

-	if( m_pCurrentRecord )

-		return m_pCurrentRecord->Action;

-	return 0UL;

-}

-

-CString CFileNotifyInformation::GetFileName() const

-{

-	//

-	//BUG FIX:

-	//		File Name's longer than 130 characters are truncated

-	//

-	//		Thanks Edric @ uo_edric@hotmail.com for pointing this out.

-	if( m_pCurrentRecord )

-	{

-		WCHAR wcFileName[ MAX_PATH + 1] = {0};//L"";

-		memcpy(	wcFileName, 

-				m_pCurrentRecord->FileName, 

-				//min( MAX_PATH, m_pCurrentRecord->FileNameLength) <-- buggy line

-				min( (MAX_PATH * sizeof(WCHAR)), m_pCurrentRecord->FileNameLength));

-		

-

-		return CString( wcFileName );

-	}

-	return CString();

-}		

-

-static inline bool HasTrailingBackslash(const CString & str )

-{

-	if( str.GetLength() > 0 

-	&&	str[ str.GetLength() - 1 ] == _T('\\') )

-		return true;

-	return false;

-}

-CString CFileNotifyInformation::GetFileNameWithPath(const CString & strRootPath) const

-{

-	CString strFileName( strRootPath );

-	//if( strFileName.Right(1) != _T("\\") )

-	if( !HasTrailingBackslash( strRootPath ) )

-		strFileName += _T("\\");

-

-	strFileName += GetFileName();

-	return strFileName;

-}

-/////////////////////////////////////////////////////////////////////////////////

-class CPrivilegeEnabler

-//

-//	Enables privileges for this process

-//	first time CDirectoryChangeWatcher::WatchDirectory() is called.

-//

-//	It's a singleton.

-//

-{

-private:

-	CPrivilegeEnabler();//ctor

-public:

-	~CPrivilegeEnabler(){};

-	

-	static CPrivilegeEnabler & Instance();

-	//friend static CPrivilegeEnabler & Instance();

-};

-

-CPrivilegeEnabler::CPrivilegeEnabler()

-{

-	LPCTSTR arPrivelegeNames[]	=	{

-										SE_BACKUP_NAME, //	these two are required for the FILE_FLAG_BACKUP_SEMANTICS flag used in the call to 

-										SE_RESTORE_NAME,//  CreateFile() to open the directory handle for ReadDirectoryChangesW

-

-										SE_CHANGE_NOTIFY_NAME //just to make sure...it's on by default for all users.

-										//<others here as needed>

-									};

-	for(int i = 0; i < sizeof(arPrivelegeNames) / sizeof(arPrivelegeNames[0]); ++i)

-	{

-		if( !EnablePrivilege(arPrivelegeNames[i], TRUE) )

-		{

-			TRACE(_T("Unable to enable privilege: %s	--	GetLastError(): %d\n"), arPrivelegeNames[i], GetLastError());

-			TRACE(_T("CDirectoryChangeWatcher notifications may not work as intended due to insufficient access rights/process privileges.\n"));

-			TRACE(_T("File: %s Line: %d\n"), _T(__FILE__), __LINE__);

-		}

-	}

-}

-

-CPrivilegeEnabler & CPrivilegeEnabler::Instance()

-{

-	static CPrivilegeEnabler theInstance;//constructs this first time it's called.

-	return theInstance;

-}

-//

-//

-//

-///////////////////////////////////////////////////////////

-

-	

-//

-//

-//////////////////////////////////////////////////////////////////////

-// Construction/Destruction

-//////////////////////////////////////////////////////////////////////

-CDirectoryChangeHandler::CDirectoryChangeHandler()

-: m_nRefCnt( 1 ),

-  m_pDirChangeWatcher( NULL ),

-  m_nWatcherRefCnt( 0L )

-{

-}

-

-CDirectoryChangeHandler::~CDirectoryChangeHandler()

-{

-	UnwatchDirectory();

-}

-

-long CDirectoryChangeHandler::AddRef()

-{ 

-	return InterlockedIncrement(&m_nRefCnt);	

-}

-

-long CDirectoryChangeHandler::Release()

-{  

-	long nRefCnt = -1;

-	if( (nRefCnt = InterlockedDecrement(&m_nRefCnt)) == 0 )

-		delete this;

-	return nRefCnt;

-}

-long CDirectoryChangeHandler::CurRefCnt()const 

-{ 

-	return m_nRefCnt;

-}

-

-BOOL CDirectoryChangeHandler::UnwatchDirectory()

-{

-	CSingleLock lock(&m_csWatcher, TRUE);	

-	ASSERT( lock.IsLocked() );

-	

-	if( m_pDirChangeWatcher )

-		return m_pDirChangeWatcher->UnwatchDirectory( this );

-	return TRUE;

-}

-

-long  CDirectoryChangeHandler::ReferencesWatcher(CDirectoryChangeWatcher * pDirChangeWatcher)

-{

-	ASSERT( pDirChangeWatcher );

-	CSingleLock lock(&m_csWatcher, TRUE);

-	if( m_pDirChangeWatcher 

-	&&  m_pDirChangeWatcher != pDirChangeWatcher )

-	{

-		TRACE(_T("CDirectoryChangeHandler...is becoming used by a different CDirectoryChangeWatcher!\n"));

-		TRACE(_T("Directories being handled by this object will now be unwatched.\nThis object is now being used to ")

-			  _T("handle changes to a directory watched by different CDirectoryChangeWatcher object, probably on a different directory"));

-		

-		if( UnwatchDirectory() )

-		{

-			m_pDirChangeWatcher = pDirChangeWatcher;

-			m_nWatcherRefCnt = 1; //when this reaches 0, set m_pDirChangeWatcher to NULL

-			return m_nWatcherRefCnt;

-		}

-		else

-		{

-			ASSERT( FALSE );//shouldn't get here!

-		}

-	}

-	else

-	{

-		ASSERT( !m_pDirChangeWatcher || m_pDirChangeWatcher == pDirChangeWatcher );

-		

-		m_pDirChangeWatcher = pDirChangeWatcher;	

-		

-		if( m_pDirChangeWatcher )

-			return InterlockedIncrement(&m_nWatcherRefCnt);

-		

-	}

-	return m_nWatcherRefCnt;

-}

-

-long CDirectoryChangeHandler::ReleaseReferenceToWatcher(CDirectoryChangeWatcher * pDirChangeWatcher)

-{

-	ASSERT( m_pDirChangeWatcher == pDirChangeWatcher );

-	CSingleLock lock(&m_csWatcher, TRUE);

-	long nRef;

-	if( (nRef = InterlockedDecrement(&m_nWatcherRefCnt)) <= 0L )

-	{

-		m_pDirChangeWatcher = NULL; //Setting this to NULL so that this->UnwatchDirectory() which is called in the dtor

-									//won't call m_pDirChangeWatcher->UnwatchDirecotry(this).

-									//m_pDirChangeWatcher may point to a destructed object depending on how

-									//these classes are being used.

-		m_nWatcherRefCnt = 0L;

-	}

-	return nRef;

-}

-

-//

-//

-//	Default implmentations for CDirectoryChangeHandler's virtual functions.

-//

-//

-void CDirectoryChangeHandler::On_FileAdded(const CString & strFileName)

-{ 

-	TRACE(_T("The following file was added: %s\n"), strFileName);

-}

-

-void CDirectoryChangeHandler::On_FileRemoved(const CString & strFileName)

-{

-	TRACE(_T("The following file was removed: %s\n"), strFileName);

-}

-

-void CDirectoryChangeHandler::On_FileModified(const CString & strFileName)

-{

-	TRACE(_T("The following file was modified: %s\n"), strFileName);

-}

-

-void CDirectoryChangeHandler::On_FileNameChanged(const CString & strOldFileName, const CString & strNewFileName)

-{

-	TRACE(_T("The file %s was RENAMED to %s\n"), strOldFileName, strNewFileName);

-}

-void CDirectoryChangeHandler::On_ReadDirectoryChangesError(DWORD dwError, const CString & strDirectoryName)

-{

-	TRACE(_T("WARNING!!!!!\n") );

-	TRACE(_T("An error has occurred on a watched directory!\n"));

-	TRACE(_T("This directory has become unwatched! -- %s \n"), strDirectoryName);

-	TRACE(_T("ReadDirectoryChangesW has failed! %d"), dwError);

-	ASSERT( FALSE );//you should override this function no matter what. an error will occur someday.

-}

-

-void CDirectoryChangeHandler::On_WatchStarted(DWORD dwError, const CString & strDirectoryName)

-{	

-	if( dwError == 0 )

-		TRACE(_T("A watch has begun on the following directory: %s\n"), strDirectoryName);

-	else

-		TRACE(_T("A watch failed to start on the following directory: (Error: %d) %s\n"),dwError, strDirectoryName);

-}

-

-void CDirectoryChangeHandler::On_WatchStopped(const CString & strDirectoryName)

-{

-	TRACE(_T("The watch on the following directory has stopped: %s\n"), strDirectoryName);

-}

-

-bool CDirectoryChangeHandler::On_FilterNotification(DWORD /*dwNotifyAction*/, LPCTSTR /*szFileName*/, LPCTSTR /*szNewFileName*/)

-//

-//	bool On_FilterNotification(DWORD dwNotifyAction, LPCTSTR szFileName, LPCTSTR szNewFileName);

-//

-//	This function gives your class a chance to filter unwanted notifications.

-//

-//	PARAMETERS: 

-//			DWORD	dwNotifyAction	-- specifies the event to filter

-//			LPCTSTR szFileName		-- specifies the name of the file for the event.

-//			LPCTSTR szNewFileName	-- specifies the new file name of a file that has been renamed.

-//

-//	RETURN VALUE:

-//			return true from this function, and you will receive the notification.

-//			return false from this function, and your class will NOT receive the notification.

-//

-//	Valid values of dwNotifyAction:

-//		FILE_ACTION_ADDED			-- On_FileAdded() is about to be called.

-//		FILE_ACTION_REMOVED			-- On_FileRemoved() is about to be called.

-//		FILE_ACTION_MODIFIED		-- On_FileModified() is about to be called.

-//		FILE_ACTION_RENAMED_OLD_NAME-- On_FileNameChanged() is about to be call.

-//

-//	  

-//	NOTE:  When the value of dwNotifyAction is FILE_ACTION_RENAMED_OLD_NAME,

-//			szFileName will be the old name of the file, and szNewFileName will

-//			be the new name of the renamed file.

-//

-//  The default implementation always returns true, indicating that all notifications will 

-//	be sent.

-//	

-{

-	return true;

-}

-

-void CDirectoryChangeHandler::SetChangedDirectoryName(const CString & strChangedDirName)

-{

-	m_strChangedDirectoryName = strChangedDirName;

-}

-////////////////////////////////////////////////////////////////////

-////////////////////////////////////////////////////////////////////

-

-CDirectoryChangeWatcher::CDirectoryChangeWatcher(bool bAppHasGUI /*= true*/, DWORD dwFilterFlags/*=FILTERS_CHECK_FILE_NAME_ONLY*/)

-: m_hCompPort( NULL )

- ,m_hThread( NULL )

- ,m_dwThreadID( 0UL )

- ,m_bAppHasGUI( bAppHasGUI )

- ,m_dwFilterFlags( dwFilterFlags == 0? FILTERS_DEFAULT_BEHAVIOR : dwFilterFlags)

-{

-	//NOTE:  

-	//	The bAppHasGUI variable indicates that you have a message pump associated

-	//	with the main thread(or the thread that first calls CDirectoryChangeWatcher::WatchDirectory() ).

-	//	Directory change notifications are dispatched to your main thread.

-	//	

-	//	If your app doesn't have a gui, then pass false.  Doing so causes a worker thread

-	//	to be created that implements a message pump where it dispatches/executes the notifications.

-	//  It's ok to pass false even if your app does have a GUI.

-	//	Passing false is required for Console applications, or applications without a message pump.

-	//	Note that notifications are fired in a worker thread.

-	//

-

-	//NOTE:

-	//

-	//

-}

-

-CDirectoryChangeWatcher::~CDirectoryChangeWatcher()

-{

-

-	UnwatchAllDirectories();

-

-	if( m_hCompPort )

-	{

-		CloseHandle( m_hCompPort );

-		m_hCompPort = NULL;

-	}

-}

-

-DWORD CDirectoryChangeWatcher::SetFilterFlags(DWORD dwFilterFlags)

-//

-//	SetFilterFlags()

-//	

-//	sets filter behavior for directories watched AFTER this function has been called.

-//

-//

-//

-{

-	DWORD dwOld = m_dwFilterFlags;

-	m_dwFilterFlags = dwFilterFlags;

-	if( m_dwFilterFlags == 0 )

-		m_dwFilterFlags = FILTERS_DEFAULT_BEHAVIOR;//the default.

-	return dwOld;

-}

-

-BOOL CDirectoryChangeWatcher::IsWatchingDirectory(const CString & strDirName)const

-/*********************************************

-  Determines whether or not a directory is being watched

-

-  be carefull that you have the same name path name, including the backslash

-  as was used in the call to WatchDirectory().

-

-	  ie:	

-			"C:\\Temp"

-		is different than

-			"C:\\Temp\\"

-**********************************************/

-{

-	CSingleLock lock( const_cast<CCriticalSection*>(&m_csDirWatchInfo), TRUE);

-	ASSERT( lock.IsLocked() );

-	int i;

-	if( GetDirWatchInfo(strDirName, i) )

-		return TRUE;

-	return FALSE;

-}

-

-int	CDirectoryChangeWatcher::NumWatchedDirectories()const

-{

-	CSingleLock lock(const_cast<CCriticalSection*>(&m_csDirWatchInfo), TRUE);

-	ASSERT( lock.IsLocked() );

-	int nCnt(0),max = m_DirectoriesToWatch.GetSize();

-	for(int i(0); i < max; ++i)

-	{

-		if( m_DirectoriesToWatch[i] != NULL )//array may contain NULL elements.

-			nCnt++;

-	}

-

-	return nCnt;

-}

-

-DWORD CDirectoryChangeWatcher::WatchDirectory(const CString & strDirToWatch, 

-									   DWORD dwChangesToWatchFor, 

-									   CDirectoryChangeHandler * pChangeHandler,

-									   BOOL bWatchSubDirs /*=FALSE*/,

-									   LPCTSTR szIncludeFilter /*=NULL*/,

-									   LPCTSTR szExcludeFilter /*=NULL*/

-									   )

-/*************************************************************

-FUNCTION:	WatchDirectory(const CString & strDirToWatch,   --the name of the directory to watch

-						   DWORD dwChangesToWatchFor, --the changes to watch for see dsk docs..for ReadDirectoryChangesW

-						   CDirectoryChangeHandler * pChangeHandler -- handles changes in specified directory

-						   BOOL bWatchSubDirs      --specified to watch sub directories of the directory that you want to watch

-						   )

-

-PARAMETERS:

-		const CString & strDirToWatch -- specifies the path of the directory to watch.

-		DWORD dwChangesToWatchFor	-- specifies flags to be passed to ReadDirectoryChangesW()

-		CDirectoryChangeHandler *	-- ptr to an object which will handle notifications of file changes.

-		BOOL bWatchSubDirs			-- specifies to watch subdirectories.

-		LPCTSTR szIncludeFilter		-- A file pattern string for files that you wish to receive notifications

-									   for. See Remarks.

-		LPCTSTR szExcludeFilter		-- A file pattern string for files that you do not wish to receive notifications for. See Remarks

-

-	Starts watching the specified directory(and optionally subdirectories) for the specified changes

-

-	When specified changes take place the appropriate CDirectoryChangeHandler::On_Filexxx() function is called.

-

-	dwChangesToWatchFor can be a combination of the following flags, and changes map out to the 

-	following functions:

-	FILE_NOTIFY_CHANGE_FILE_NAME    -- CDirectoryChangeHandler::On_FileAdded()

-									   CDirectoryChangeHandler::On_FileNameChanged, 

-									   CDirectoryChangeHandler::On_FileRemoved

-	FILE_NOTIFY_CHANGE_DIR_NAME     -- CDirectoryChangeHandler::On_FileNameAdded(), 

-									   CDirectoryChangeHandler::On_FileRemoved

-	FILE_NOTIFY_CHANGE_ATTRIBUTES   -- CDirectoryChangeHandler::On_FileModified

-	FILE_NOTIFY_CHANGE_SIZE         -- CDirectoryChangeHandler::On_FileModified

-	FILE_NOTIFY_CHANGE_LAST_WRITE   -- CDirectoryChangeHandler::On_FileModified

-	FILE_NOTIFY_CHANGE_LAST_ACCESS  -- CDirectoryChangeHandler::On_FileModified

-	FILE_NOTIFY_CHANGE_CREATION     -- CDirectoryChangeHandler::On_FileModified

-	FILE_NOTIFY_CHANGE_SECURITY     -- CDirectoryChangeHandler::On_FileModified?

-	

-

-	Returns ERROR_SUCCESS if the directory will be watched, 

-	or a windows error code if the directory couldn't be watched.

-	The error code will most likely be related to a call to CreateFile(), or 

-	from the initial call to ReadDirectoryChangesW().  It's also possible to get an

-	error code related to being unable to create an io completion port or being unable 

-	to start the worker thread.

-

-	This function will fail if the directory to be watched resides on a 

-	computer that is not a Windows NT/2000/XP machine.

-

-

-	You can only have one watch specified at a time for any particular directory.

-	Calling this function with the same directory name will cause the directory to be 

-	unwatched, and then watched again(w/ the new parameters that have been passed in).  

-

-**************************************************************/

-{

-	ASSERT( dwChangesToWatchFor != 0);

-

-	if( strDirToWatch.IsEmpty()

-	||  dwChangesToWatchFor == 0 

-	||  pChangeHandler == NULL )

-	{

-		TRACE(_T("ERROR: You've passed invalid parameters to CDirectoryChangeWatcher::WatchDirectory()\n"));

-		::SetLastError(ERROR_INVALID_PARAMETER);

-		return ERROR_INVALID_PARAMETER;

-	}

-

-	

-	//double check that it's really a directory

-	if( !IsDirectory( strDirToWatch ) )

-	{

-		TRACE(_T("ERROR: CDirectoryChangeWatcher::WatchDirectory() -- %s is not a directory!\n"), strDirToWatch);

-		::SetLastError(ERROR_BAD_PATHNAME);

-		return ERROR_BAD_PATHNAME;

-	}

-

-	//double check that this directory is not already being watched....

-	//if it is, then unwatch it before restarting it...

-	if( IsWatchingDirectory( strDirToWatch) )

-	{

-		VERIFY( 

-			UnwatchDirectory( strDirToWatch ) 

-			);

-	}

-	//

-	//

-	//	Reference this singleton so that privileges for this process are enabled 

-	//	so that it has required permissions to use the ReadDirectoryChangesW API, etc.

-	//

-	CPrivilegeEnabler::Instance();

-	//

-	//open the directory to watch....

-	HANDLE hDir = CreateFile(strDirToWatch, 

-								FILE_LIST_DIRECTORY, 

-								FILE_SHARE_READ | FILE_SHARE_WRITE ,//| FILE_SHARE_DELETE, <-- removing FILE_SHARE_DELETE prevents the user or someone else from renaming or deleting the watched directory. This is a good thing to prevent.

-								NULL, //security attributes

-								OPEN_EXISTING,

-								FILE_FLAG_BACKUP_SEMANTICS | //<- the required priviliges for this flag are: SE_BACKUP_NAME and SE_RESTORE_NAME.  CPrivilegeEnabler takes care of that.

-                                FILE_FLAG_OVERLAPPED, //OVERLAPPED!

-								NULL);

-	if( hDir == INVALID_HANDLE_VALUE )

-	{

-		DWORD dwError = GetLastError();

-		TRACE(_T("CDirectoryChangeWatcher::WatchDirectory() -- Couldn't open directory for monitoring. %d\n"), dwError);

-		::SetLastError(dwError);//who knows if TRACE will cause GetLastError() to return success...probably won't, but set it manually just for fun.

-		return dwError;

-	}

-	//opened the dir!

-	

-	CDirWatchInfo * pDirInfo = new CDirWatchInfo( hDir, strDirToWatch, pChangeHandler, dwChangesToWatchFor, bWatchSubDirs, m_bAppHasGUI, szIncludeFilter, szExcludeFilter, m_dwFilterFlags);

-	if( !pDirInfo )

-	{

-		TRACE(_T("WARNING: Couldn't allocate a new CDirWatchInfo() object --- File: %s Line: %d\n"), _T( __FILE__ ), __LINE__);

-		CloseHandle( hDir );

-		::SetLastError(ERROR_OUTOFMEMORY);

-		return ERROR_OUTOFMEMORY;

-	}

-	

-	//create a IO completion port/or associate this key with

-	//the existing IO completion port

-	m_hCompPort = CreateIoCompletionPort(hDir, 

-										m_hCompPort, //if m_hCompPort is NULL, hDir is associated with a NEW completion port,

-													 //if m_hCompPort is NON-NULL, hDir is associated with the existing completion port that the handle m_hCompPort references

-										(DWORD)pDirInfo, //the completion 'key'... this ptr is returned from GetQueuedCompletionStatus() when one of the events in the dwChangesToWatchFor filter takes place

-										0);

-	if( m_hCompPort == NULL )

-	{

-		TRACE(_T("ERROR -- Unable to create I/O Completion port! GetLastError(): %d File: %s Line: %d"), GetLastError(), _T( __FILE__ ), __LINE__ );

-		DWORD dwError = GetLastError();

-		pDirInfo->DeleteSelf( NULL );

-		::SetLastError(dwError);//who knows what the last error will be after i call pDirInfo->DeleteSelf(), so set it just to make sure

-		return dwError;

-	}

-	else

-	{//completion port created/directory associated w/ it successfully

-

-		//if the thread isn't running start it....

-		//when the thread starts, it will call ReadDirectoryChangesW and wait 

-		//for changes to take place

-		if( m_hThread == NULL )

-		{

-			//start the thread

-			CWinThread * pThread = AfxBeginThread(MonitorDirectoryChanges, this);

-			if( !pThread )

-			{//couldn't create the thread!

-				TRACE(_T("CDirectoryChangeWatcher::WatchDirectory()-- AfxBeginThread failed!\n"));

-				pDirInfo->DeleteSelf( NULL );

-				return (GetLastError() == ERROR_SUCCESS)? ERROR_MAX_THRDS_REACHED : GetLastError();

-			}

-			else

-			{

-				m_hThread	 = pThread->m_hThread;

-				m_dwThreadID = pThread->m_nThreadID;

-				pThread->m_bAutoDelete = TRUE;//pThread is deleted when thread ends....it's TRUE by default(for CWinThread ptrs returned by AfxBeginThread(threadproc, void*)), but just makin sure.

-				

-			}

-		}

-		if( m_hThread != NULL )

-		{//thread is running, 

-			//signal the thread to issue the initial call to

-			//ReadDirectoryChangesW()

-		   DWORD dwStarted = pDirInfo->StartMonitor( m_hCompPort );

-

-		   if( dwStarted != ERROR_SUCCESS )

-		   {//there was a problem!

-			   TRACE(_T("Unable to watch directory: %s -- GetLastError(): %d\n"), dwStarted);

-			   pDirInfo->DeleteSelf( NULL );

-				::SetLastError(dwStarted);//I think this'll set the Err object in a VB app.....

-			   return dwStarted;

-		   }

-		   else

-		   {//ReadDirectoryChangesW was successfull!

-				//add the directory info to the first empty slot in the array

-

-				//associate the pChangeHandler with this object

-				pChangeHandler->ReferencesWatcher( this );//reference is removed when directory is unwatched.

-				//CDirWatchInfo::DeleteSelf() must now be called w/ this CDirectoryChangeWatcher pointer becuse

-				//of a reference count

-

-				//save the CDirWatchInfo* so I'll be able to use it later.

-				VERIFY( AddToWatchInfo( pDirInfo ) );

-				SetLastError(dwStarted);

-				return dwStarted;

-		   }

-

-		}

-		else

-		{

-			ASSERT(FALSE);//control path shouldn't get here

-			::SetLastError(ERROR_MAX_THRDS_REACHED);

-			return ERROR_MAX_THRDS_REACHED;

-		}

-		

-	}

-	ASSERT( FALSE );//shouldn't get here.

-}

-

-BOOL CDirectoryChangeWatcher::UnwatchAllDirectories()

-{

-	

-	//unwatch all of the watched directories

-	//delete all of the CDirWatchInfo objects,

-	//kill off the worker thread

-	if( m_hThread != NULL )

-	{

-		ASSERT( m_hCompPort != NULL );

-		

-		CSingleLock lock( &m_csDirWatchInfo, TRUE);

-		ASSERT( lock.IsLocked() );

-

-		CDirWatchInfo * pDirInfo;

-		//Unwatch each of the watched directories

-		//and delete the CDirWatchInfo associated w/ that directory...

-		int max = m_DirectoriesToWatch.GetSize();

-		for(int i = 0; i < max; ++i)

-		{

-			if( (pDirInfo = m_DirectoriesToWatch[i]) != NULL )

-			{

-				VERIFY( pDirInfo->UnwatchDirectory( m_hCompPort ) );

-

-				m_DirectoriesToWatch.SetAt(i, NULL)	;

-				pDirInfo->DeleteSelf(this);

-			}

-			

-		}

-		m_DirectoriesToWatch.RemoveAll();

-		//kill off the thread

-		PostQueuedCompletionStatus(m_hCompPort, 0, 0, NULL);//The thread will catch this and exit the thread

-		//wait for it to exit

-		WaitForSingleObject(m_hThread, INFINITE);

-		//CloseHandle( m_hThread );//Since thread was started w/ AfxBeginThread() this handle is closed automatically, closing it again will raise an exception

-		m_hThread = NULL;

-		m_dwThreadID = 0UL;		

-

-		//close the completion port...

-		CloseHandle( m_hCompPort );

-		m_hCompPort = NULL;

-

-

-		return TRUE;

-	}

-	else

-	{

-#ifdef _DEBUG

-		//make sure that there aren't any 

-		//CDirWatchInfo objects laying around... they should have all been destroyed 

-		//and removed from the array m_DirectoriesToWatch

-		if( m_DirectoriesToWatch.GetSize() > 0 )

-		{

-			for(int i = 0; i < m_DirectoriesToWatch.GetSize(); ++i)

-			{

-				ASSERT( m_DirectoriesToWatch[i] == NULL );

-			}

-		}

-#endif

-	}

-	return FALSE;

-}

-

-BOOL CDirectoryChangeWatcher::UnwatchDirectory(const CString & strDirToStopWatching)

-/***************************************************************

-FUNCTION:	UnwatchDirectory(const CString & strDirToStopWatching -- if this directory is being watched, the watch is stopped

-

-****************************************************************/

-{

-	BOOL bRetVal = FALSE;

-

-

-

-	if( m_hCompPort != NULL )//The io completion port must be open

-	{

-		ASSERT( !strDirToStopWatching.IsEmpty() );

-		

-		CSingleLock lock(&m_csDirWatchInfo, TRUE);

-		ASSERT( lock.IsLocked() );	

-		int nIdx = -1;

-		CDirWatchInfo * pDirInfo = GetDirWatchInfo(strDirToStopWatching, nIdx);

-		if( pDirInfo != NULL

-		&&	nIdx != -1 )

-		{

-

-			//stop watching this directory

-			VERIFY( pDirInfo->UnwatchDirectory( m_hCompPort ) );

-

-			//cleanup the object used to watch the directory

-			m_DirectoriesToWatch.SetAt(nIdx, NULL);

-			pDirInfo->DeleteSelf(this);

-			bRetVal = TRUE;

-		}

-	}

-

-	return bRetVal;

-}

-

-BOOL CDirectoryChangeWatcher::UnwatchDirectory(CDirectoryChangeHandler * pChangeHandler)

-/************************************

-

-  This function is called from the dtor of CDirectoryChangeHandler automatically,

-  but may also be called by a programmer because it's public...

-  

-  A single CDirectoryChangeHandler may be used for any number of watched directories.

-

-  Unwatch any directories that may be using this 

-  CDirectoryChangeHandler * pChangeHandler to handle changes to a watched directory...

-  

-  The CDirWatchInfo::m_pChangeHandler member of objects in the m_DirectoriesToWatch

-  array will == pChangeHandler if that handler is being used to handle changes to a directory....

-************************************/

-{

-	ASSERT( pChangeHandler );

-

-	CSingleLock lock(&m_csDirWatchInfo, TRUE);

-	

-	ASSERT( lock.IsLocked() );

-	

-	int nUnwatched = 0;

-	int nIdx = -1;

-	CDirWatchInfo * pDirInfo;

-	//

-	//	go through and unwatch any directory that is 

-	//	that is using this pChangeHandler as it's file change notification handler.

-	//

-	while( (pDirInfo = GetDirWatchInfo( pChangeHandler, nIdx )) != NULL )

-	{

-		VERIFY( pDirInfo->UnwatchDirectory( m_hCompPort ) );

-

-		nUnwatched++;

-		m_DirectoriesToWatch.SetAt(nIdx, NULL);

-		pDirInfo->DeleteSelf(this);	

-	}

-	return (BOOL)(nUnwatched != 0);

-}

-

-BOOL CDirectoryChangeWatcher::UnwatchDirectoryBecauseOfError(CDirWatchInfo * pWatchInfo)

-//

-//	Called in the worker thread in the case that ReadDirectoryChangesW() fails

-//	during normal operation. One way to force this to happen is to watch a folder

-//	using a UNC path and changing that computer's IP address.

-//	

-{

-	ASSERT( pWatchInfo );

-	ASSERT( m_dwThreadID == GetCurrentThreadId() );//this should be called from the worker thread only.

-	BOOL bRetVal = FALSE;

-	if( pWatchInfo )

-	{

-		CSingleLock lock(&m_csDirWatchInfo, TRUE);

-		

-		ASSERT( lock.IsLocked() );

-		int nIdx = -1;

-		if( GetDirWatchInfo(pWatchInfo, nIdx) == pWatchInfo )

-		{

-			// we are actually watching this....

-

-			//

-			//	Remove this CDirWatchInfo object from the list of watched directories.

-			//

-			m_DirectoriesToWatch.SetAt(nIdx, NULL);//mark the space as free for the next watch...

-

-			//

-			//	and delete it...

-			//

-

-			pWatchInfo->DeleteSelf(this);

-		

-		}

-

-	}

-	return bRetVal;

-}

-

-int	CDirectoryChangeWatcher::AddToWatchInfo(CDirectoryChangeWatcher::CDirWatchInfo * pWatchInfo)

-//

-//	

-//	To add the CDirWatchInfo  * to an array.

-//	The array is used to keep track of which directories 

-//	are being watched.

-//

-//	Add the ptr to the first non-null slot in the array.

-{

-	CSingleLock lock( &m_csDirWatchInfo, TRUE);

-	ASSERT( lock.IsLocked() );

-	

-	//first try to add it to the first empty slot in m_DirectoriesToWatch

-	int max = m_DirectoriesToWatch.GetSize();

-	for(int i = 0; i < max; ++i)

-	{

-		if( m_DirectoriesToWatch[i] == NULL )

-		{

-			m_DirectoriesToWatch[i] = pWatchInfo;

-			break;

-		}

-	}

-	if( i == max )

-	{

-		// there where no empty slots, add it to the end of the array

-		try{

-			i = m_DirectoriesToWatch.Add( pWatchInfo );

-		}

-		catch(CMemoryException * e){

-			e->ReportError();

-			e->Delete();//??? delete this? I thought CMemoryException objects where pre allocated in mfc? -- sample code in msdn does, so will i

-			i = -1;

-		}

-	}

-

-	return (BOOL)(i != -1);

-}

-

-//

-//	functions for retrieving the directory watch info based on different parameters

-//

-CDirectoryChangeWatcher::CDirWatchInfo * CDirectoryChangeWatcher::GetDirWatchInfo(const CString & strDirName, int & ref_nIdx)const

-{

-	if( strDirName.IsEmpty() )// can't be watching a directory if it's you don't pass in the name of it...

-		return FALSE;		  //

-	

-	CSingleLock lock(const_cast<CCriticalSection*>(&m_csDirWatchInfo), TRUE);

-

-	int max = m_DirectoriesToWatch.GetSize();

-	CDirWatchInfo * p = NULL;

-	for(int i = 0; i < max; ++i )

-	{

-		if( (p = m_DirectoriesToWatch[i]) != NULL

-		&&	p->m_strDirName.CompareNoCase( strDirName ) == 0 )

-		{

-			ref_nIdx = i;

-			return p;

-		}

-	}

-			

-	return NULL;//NOT FOUND

-}

-

-CDirectoryChangeWatcher::CDirWatchInfo * CDirectoryChangeWatcher::GetDirWatchInfo(CDirectoryChangeWatcher::CDirWatchInfo * pWatchInfo, int & ref_nIdx)const

-{

-	ASSERT( pWatchInfo != NULL );

-

-	CSingleLock lock( const_cast<CCriticalSection*>(&m_csDirWatchInfo), TRUE);

-	int i(0), max = m_DirectoriesToWatch.GetSize();

-	CDirWatchInfo * p;

-	for(; i < max; ++i)

-	{

-		if( (p = m_DirectoriesToWatch[i]) != NULL

-		&&	 p == pWatchInfo )

-		{

-			ref_nIdx = i;

-			return p;

-		}

-	}

-	return NULL;//NOT FOUND

-}

-

-CDirectoryChangeWatcher::CDirWatchInfo * CDirectoryChangeWatcher::GetDirWatchInfo(CDirectoryChangeHandler * pChangeHandler, int & ref_nIdx)const

-{

-	ASSERT( pChangeHandler != NULL );

-	CSingleLock lock( const_cast<CCriticalSection*>(&m_csDirWatchInfo), TRUE);

-	int i(0),max = m_DirectoriesToWatch.GetSize();

-	CDirWatchInfo * p;

-	for( ; i < max; ++i)

-	{

-		if( (p = m_DirectoriesToWatch[i]) != NULL

-		&&	p->GetRealChangeHandler() == pChangeHandler )

-		{

-			ref_nIdx = i;

-			return p;

-		}

-	}

-	return NULL;//NOT FOUND

-}

-

-long CDirectoryChangeWatcher::ReleaseReferenceToWatcher(CDirectoryChangeHandler * pChangeHandler)

-{

-	ASSERT( pChangeHandler );

-	return pChangeHandler->ReleaseReferenceToWatcher(this);

-}

-

-CDirectoryChangeWatcher::CDirWatchInfo::CDirWatchInfo(HANDLE hDir, 

-													  const CString & strDirectoryName, 

-													  CDirectoryChangeHandler * pChangeHandler,

-													  DWORD dwChangeFilter, 

-													  BOOL bWatchSubDir,

-													  bool bAppHasGUI,

-													  LPCTSTR szIncludeFilter,

-													  LPCTSTR szExcludeFilter,

-													  DWORD dwFilterFlags)

- :	m_pChangeHandler( NULL ), 

-	m_hDir(hDir),

-	m_dwChangeFilter( dwChangeFilter ),

-	m_bWatchSubDir( bWatchSubDir ),

-	m_strDirName( strDirectoryName ),

-	m_dwBufLength(0),

-	m_dwReadDirError(ERROR_SUCCESS),

-	m_StartStopEvent(FALSE, TRUE), //NOT SIGNALLED, MANUAL RESET

-	m_RunningState( RUNNING_STATE_NOT_SET )

-{ 

-	

-	ASSERT( hDir != INVALID_HANDLE_VALUE 

-		&& !strDirectoryName.IsEmpty() );

-	

-	//

-	//	This object 'decorates' the pChangeHandler passed in

-	//	so that notifications fire in the context a thread other than

-	//	CDirectoryChangeWatcher::MonitorDirectoryChanges()

-	//

-	//	Supports the include and exclude filters

-	//

-	//

-	m_pChangeHandler = new CDelayedDirectoryChangeHandler( pChangeHandler, bAppHasGUI, szIncludeFilter, szExcludeFilter, dwFilterFlags );

-	if( m_pChangeHandler ) 

-		m_pChangeHandler->SetPartialPathOffset( m_strDirName );//to support FILTERS_CHECK_PARTIAL_PATH..this won't change for the duration of the watch, so set it once... HERE!

-	ASSERT( m_pChangeHandler );

-

-	ASSERT( GetChangeHandler() );

-	ASSERT( GetRealChangeHandler() );

-	if( GetRealChangeHandler() )

-		GetRealChangeHandler()->AddRef();

-	

-	memset(&m_Overlapped, 0, sizeof(m_Overlapped));

-	//memset(m_Buffer, 0, sizeof(m_Buffer));

-}

-

-CDirectoryChangeWatcher::CDirWatchInfo::~CDirWatchInfo()

-{

-	if( GetChangeHandler() )

-	{//If this call to CDirectoryChangeHandler::Release() causes m_pChangeHandler to delete itself,

-		//the dtor for CDirectoryChangeHandler will call CDirectoryChangeWatcher::UnwatchDirectory( CDirectoryChangeHandler * ),

-		//which will make try to delete this object again.

-		//if m_pChangeHandler is NULL, it won't try to delete this object again...

-		CDirectoryChangeHandler * pTmp = SetRealDirectoryChangeHandler( NULL );

-		if( pTmp )

-			pTmp->Release();

-		else{

-			ASSERT( FALSE );

-		}

-	}

-	

-	CloseDirectoryHandle();

-

-	delete m_pChangeHandler;

-	m_pChangeHandler = NULL;

-	

-}

-void CDirectoryChangeWatcher::CDirWatchInfo::DeleteSelf(CDirectoryChangeWatcher * pWatcher)

-//

-//	There's a reason for this function!

-//

-//	the dtor is private to enforce that it is used.

-//

-//

-//	pWatcher can be NULL only if CDirecotryChangeHandler::ReferencesWatcher() has NOT been called.

-//	ie: in certain sections of WatchDirectory() it's ok to pass this w/ NULL, but no where else.

-//

-{

-	//ASSERT( pWatcher != NULL );

-

-

-	ASSERT( GetRealChangeHandler() );

-	if( pWatcher )

-	{

-	//

-	//

-	//	Before this object is deleted, the CDirectoryChangeHandler object

-	//	needs to release it's reference count to the CDirectoryChangeWatcher object.

-	//	I might forget to do this since I getting rid of CDirWatchInfo objects

-	//	in more than one place...hence the reason for this function.

-	//

-		pWatcher->ReleaseReferenceToWatcher( GetRealChangeHandler() );

-	}

-	

-	delete this;

-}

-

-CDelayedDirectoryChangeHandler* CDirectoryChangeWatcher::CDirWatchInfo::GetChangeHandler() const 

-{ 

-	return m_pChangeHandler; 

-}

-

-CDirectoryChangeHandler * CDirectoryChangeWatcher::CDirWatchInfo::GetRealChangeHandler() const

-//

-//	The 'real' change handler is the CDirectoryChangeHandler object 

-//	passed to CDirectoryChangeWatcher::WatchDirectory() -- this is the object

-//	that really handles the changes.

-//

-{	

-	ASSERT( m_pChangeHandler ); 

-	return m_pChangeHandler->GetRealChangeHandler(); 

-}

-

-CDirectoryChangeHandler * CDirectoryChangeWatcher::CDirWatchInfo::SetRealDirectoryChangeHandler(CDirectoryChangeHandler * pChangeHandler)

-//

-//	Allows you to switch out, at run time, which object really handles the change notifications.

-//

-{

-	CDirectoryChangeHandler * pOld = GetRealChangeHandler();

-	m_pChangeHandler->GetRealChangeHandler() = pChangeHandler; 

-	return pOld;

-}

-

-BOOL CDirectoryChangeWatcher::CDirWatchInfo::CloseDirectoryHandle()

-//

-//	Closes the directory handle that was opened in CDirectoryChangeWatcher::WatchDirecotry()

-//

-//

-{

-	BOOL b = TRUE;

-	if( m_hDir != INVALID_HANDLE_VALUE )

-	{

-		b = CloseHandle(m_hDir);

-		m_hDir = INVALID_HANDLE_VALUE;

-	}

-	return b;

-}

-

-DWORD CDirectoryChangeWatcher::CDirWatchInfo::StartMonitor(HANDLE hCompPort)

-/*********************************************

-  Sets the running state of the object to perform the initial call to ReadDirectoryChangesW()

-  , wakes up the thread waiting on GetQueuedCompletionStatus()

-  and waits for an event to be set before returning....

-

-  The return value is either ERROR_SUCCESS if ReadDirectoryChangesW is successfull,

-  or is the value of GetLastError() for when ReadDirectoryChangesW() failed.

-**********************************************/

-{

-	ASSERT( hCompPort );

-

-	//Guard the properties of this object 

-	VERIFY( LockProperties() );

-	

-

-		

-	m_RunningState = RUNNING_STATE_START_MONITORING;//set the state member to indicate that the object is to START monitoring the specified directory

-	PostQueuedCompletionStatus(hCompPort, sizeof(this), (DWORD)this, &m_Overlapped);//make the thread waiting on GetQueuedCompletionStatus() wake up

-

-	VERIFY( UnlockProperties() );//unlock this object so that the thread can get at them...

-

-	//wait for signal that the initial call 

-	//to ReadDirectoryChanges has been made

-	DWORD dwWait = 0;

-	do{

-		dwWait = WaitForSingleObject(m_StartStopEvent, 10 * 1000);

-		if( dwWait != WAIT_OBJECT_0 )

-		{

-			//

-			//	shouldn't ever see this one....but just in case you do, notify me of the problem wesj@hotmail.com.

-			//

-			TRACE(_T("WARNING! Possible lockup detected. FILE: %s Line: %d\n"), _T( __FILE__ ), __LINE__);

-		}

-	} while( dwWait != WAIT_OBJECT_0 );

-

-	ASSERT( dwWait == WAIT_OBJECT_0 );

-	m_StartStopEvent.ResetEvent();

-	

-	return m_dwReadDirError;//This value is set in the worker thread when it first calls ReadDirectoryChangesW().

-}

-

-BOOL CDirectoryChangeWatcher::CDirWatchInfo::UnwatchDirectory(HANDLE hCompPort)

-/*******************************************

-

-    Sets the running state of the object to stop monitoring a directory,

-	Causes the worker thread to wake up and to stop monitoring the dierctory

-	

-********************************************/

-{

-	ASSERT( hCompPort );

-	//

-	// Signal that the worker thread is to stop watching the directory

-	//

-	if( SignalShutdown(hCompPort) )

-	{

-		//and wait for the thread to signal that it has shutdown

-		return WaitForShutdown();

-

-	}

-	return FALSE;

-}

-

-BOOL CDirectoryChangeWatcher::CDirWatchInfo::SignalShutdown( HANDLE hCompPort )

-//added to fix a bug -- this will be called normally by UnwatchDirectory(HANDLE)

-//						and abnormally by the worker thread in the case that ReadDirectoryChangesW fails -- see code.

-//

-//	Signals the worker thread(via the I/O completion port) that it is to stop watching the 

-//	directory for this object, and then returns.

-//

-{

-	BOOL bRetVal = FALSE;

-	ASSERT( hCompPort );

-	ASSERT( m_hDir != INVALID_HANDLE_VALUE );

-	//Lock the properties so that they aren't modified by another thread

-	VERIFY( LockProperties() ); //unlikey to fail...

-		

-	//set the state member to indicate that the object is to stop monitoring the 

-	//directory that this CDirWatchInfo is responsible for...

-	m_RunningState = CDirectoryChangeWatcher::CDirWatchInfo::RUNNING_STATE_STOP;

-	//put this object in the I/O completion port... GetQueuedCompletionStatus() will return it inside the worker thread.

-	bRetVal = PostQueuedCompletionStatus(hCompPort, sizeof(CDirWatchInfo*), (DWORD)this, &m_Overlapped);

-

-	if( !bRetVal )

-	{

-		TRACE(_T("PostQueuedCompletionStatus() failed! GetLastError(): %d\n"), GetLastError());

-	}

-	VERIFY( UnlockProperties() );

-	

-	return bRetVal;

-}

-

-BOOL CDirectoryChangeWatcher::CDirWatchInfo::WaitForShutdown()

-//

-//	This is to be called some time after SignalShutdown().

-//	

-//

-{

-	ASSERT_VALID(&m_StartStopEvent);

-	

-	//Wait for the Worker thread to indicate that the watch has been stopped

-	DWORD dwWait;

-	bool bWMQuitReceived = false;

-	do{

-		dwWait	= MsgWaitForMultipleObjects(1, &m_StartStopEvent.m_hObject, FALSE, 5000, QS_ALLINPUT);//wait five seconds

-		switch( dwWait )

-		{

-		case WAIT_OBJECT_0:

-			//handle became signalled!

-			break;

-		case WAIT_OBJECT_0 + 1:

-			{

-				//This thread awoke due to sent/posted message

-				//process the message Q

-				//

-				//	There is a message in this thread's queue, so 

-				//	MsgWaitForMultipleObjects returned.

-				//	Process those messages, and wait again.

-

-				MSG msg;

-				while( PeekMessage(&msg, NULL, 0,0, PM_REMOVE ) ) 

-				{

-					if( msg.message != WM_QUIT)

-					{

-						TranslateMessage(&msg);

-						DispatchMessage(&msg);

-					}

-					else

-					{

-						/****

-						This appears to be causing quite a lot of pain, to quote Mustafa.

-

-						//it's the WM_QUIT message, put it back in the Q and

-						// exit this function

-						PostMessage(msg.hwnd, msg.message, msg.wParam, msg.lParam );

-						bWMQuitReceived = true;

-

-						****/

-						break;

-					}

-				}

-			}break;

-		case WAIT_TIMEOUT:

-			{

-				TRACE(_T("WARNING: Possible Deadlock detected! ThreadID: %d File: %s Line: %d\n"), GetCurrentThreadId(), _T(__FILE__), __LINE__);

-			}break;

-		}//end switch(dwWait)

-	}while( dwWait != WAIT_OBJECT_0 && !bWMQuitReceived );

-		

-	

-	

-	ASSERT( dwWait == WAIT_OBJECT_0 || bWMQuitReceived);

-

-	m_StartStopEvent.ResetEvent();

-	

-	return (BOOL) (dwWait == WAIT_OBJECT_0 || bWMQuitReceived);

-}

-

-

-UINT CDirectoryChangeWatcher::MonitorDirectoryChanges(LPVOID lpvThis)

-/********************************************

-   The worker thread function which monitors directory changes....

-********************************************/

-{

-    DWORD numBytes;

-

-    CDirWatchInfo * pdi;

-    LPOVERLAPPED lpOverlapped;

-    

-	CDirectoryChangeWatcher * pThis = reinterpret_cast<CDirectoryChangeWatcher*>(lpvThis);

-	ASSERT( pThis );

-

-	pThis->On_ThreadInitialize();

-

-

-    do

-    {

-        // Retrieve the directory info for this directory

-        // through the io port's completion key

-        if( !GetQueuedCompletionStatus( pThis->m_hCompPort,

-                                   &numBytes,

-                                   (LPDWORD) &pdi,//<-- completion Key

-                                   &lpOverlapped,

-                                   INFINITE) )

-		{//The io completion request failed...

-		 //probably because the handle to the directory that

-		 //was used in a call to ReadDirectoryChangesW has been closed.

-

-			//

-			//	calling pdi->CloseDirectoryHandle() will cause GetQueuedCompletionStatus() to return false.

-			//  

-			//

-			if( !pdi 

-			|| ( pdi && AfxIsValidAddress(pdi, sizeof(CDirectoryChangeWatcher::CDirWatchInfo)))

-					 &&  pdi->m_hDir != INVALID_HANDLE_VALUE //the directory handle is still open! (we expect this when after we close the directory handle )

-			  )

-			{

-#ifdef _DEBUG

-			TRACE(_T("GetQueuedCompletionStatus() returned FALSE\nGetLastError(): %d Completion Key: %p lpOverlapped: %p\n"), GetLastError(), pdi, lpOverlapped);

-			MessageBeep( static_cast<UINT>(-1) );

-#endif

-			}

-		}

-		

-		if ( pdi )//pdi will be null if I call PostQueuedCompletionStatus(m_hCompPort, 0,0,NULL);

-        {

-			//

-			//	The following check to AfxIsValidAddress() should go off in the case

-			//	that I have deleted this CDirWatchInfo object, but it was still in 

-			//	"in the Queue" of the i/o completion port from a previous overlapped operation.

-			//

-			ASSERT( AfxIsValidAddress(pdi, 

-					sizeof(CDirectoryChangeWatcher::CDirWatchInfo)) );

-			/***********************************

-			The CDirWatchInfo::m_RunningState is pretty much the only member

-			of CDirWatchInfo that can be modified from the other thread.

-			The functions StartMonitor() and UnwatchDirecotry() are the functions that 

-			can modify that variable.

-

-			So that I'm sure that I'm getting the right value, 

-			I'm using a critical section to guard against another thread modyfying it when I want

-			to read it...

-			

-			************************************/

-			bool bObjectShouldBeOk = true;

-			try{

-			    VERIFY( pdi->LockProperties() );//don't give the main thread a chance to change this object

-			}

-			catch(...){

-				//any sort of exception here indicates I've

-				//got a hosed object.

-				TRACE(_T("CDirectoryChangeWatcher::MonitorDirectoryChanges() -- pdi->LockProperties() raised an exception!\n"));

-				bObjectShouldBeOk = false;

-			}

-			if( bObjectShouldBeOk )

-			{

-										    //while we're working with this object...

-

-				CDirWatchInfo::eRunningState Run_State = pdi->m_RunningState ;

-				

-				VERIFY( pdi->UnlockProperties() );//let another thread back at the properties...

-				/***********************************

-				 Unlock it so that there isn't a DEADLOCK if 

-				 somebody tries to call a function which will 

-				 cause CDirWatchInfo::UnwatchDirectory() to be called

-				 from within the context of this thread (eg: a function called because of

-				 the handler for one of the CDirectoryChangeHandler::On_Filexxx() functions)

-		

-				************************************/

-				

-				ASSERT( pdi->GetChangeHandler() );

-				switch( Run_State )

-				{

-				case CDirWatchInfo::RUNNING_STATE_START_MONITORING:

-					{

-						//Issue the initial call to ReadDirectoryChangesW()

-						

-						if( !ReadDirectoryChangesW( pdi->m_hDir,

-											pdi->m_Buffer,//<--FILE_NOTIFY_INFORMATION records are put into this buffer

-											READ_DIR_CHANGE_BUFFER_SIZE,

-											pdi->m_bWatchSubDir,

-											pdi->m_dwChangeFilter,

-											&pdi->m_dwBufLength,//this var not set when using asynchronous mechanisms...

-											&pdi->m_Overlapped,

-											NULL) )//no completion routine!

-						{

-							pdi->m_dwReadDirError = GetLastError();

-							if( pdi->GetChangeHandler() )

-								pdi->GetChangeHandler()->On_WatchStarted(pdi->m_dwReadDirError, pdi->m_strDirName);

-						}

-						else

-						{//read directory changes was successful!

-						 //allow it to run normally

-							pdi->m_RunningState = CDirWatchInfo::RUNNING_STATE_NORMAL;

-							pdi->m_dwReadDirError = ERROR_SUCCESS;

-							if( pdi->GetChangeHandler() )

-								pdi->GetChangeHandler()->On_WatchStarted(ERROR_SUCCESS, pdi->m_strDirName );

-						}

-						pdi->m_StartStopEvent.SetEvent();//signall that the ReadDirectoryChangesW has been called

-														 //check CDirWatchInfo::m_dwReadDirError to see whether or not ReadDirectoryChangesW succeeded...

-

-						//

-						//	note that pdi->m_dwReadDirError is the value returned by WatchDirectory()

-						//

-						

-		

-					}break;

-				case CDirWatchInfo::RUNNING_STATE_STOP:

-					{

-						//We want to shut down the monitoring of the directory

-						//that pdi is managing...

-						

-						if( pdi->m_hDir != INVALID_HANDLE_VALUE )

-						{

-						 //Since I've previously called ReadDirectoryChangesW() asynchronously, I am waiting

-						 //for it to return via GetQueuedCompletionStatus().  When I close the

-						 //handle that ReadDirectoryChangesW() is waiting on, it will

-						 //cause GetQueuedCompletionStatus() to return again with this pdi object....

-						 // Close the handle, and then wait for the call to GetQueuedCompletionStatus()

-						 //to return again by breaking out of the switch, and letting GetQueuedCompletionStatus()

-						 //get called again

-							pdi->CloseDirectoryHandle();

-							pdi->m_RunningState = CDirWatchInfo::RUNNING_STATE_STOP_STEP2;//back up step...GetQueuedCompletionStatus() will still need to return from the last time that ReadDirectoryChangesW() was called.....

-

-						 //

-						 //	The watch has been stopped, tell the client about it

-						 //						if( pdi->GetChangeHandler() )

-							pdi->GetChangeHandler()->On_WatchStopped( pdi->m_strDirName );

-						}

-						else

-						{

-							//either we weren't watching this direcotry in the first place,

-							//or we've already stopped monitoring it....

-							pdi->m_StartStopEvent.SetEvent();//set the event that ReadDirectoryChangesW has returned and no further calls to it will be made...

-						}

-						

-					

-					}break;

-				case CDirWatchInfo::RUNNING_STATE_STOP_STEP2:

-					{

-

-						//GetQueuedCompletionStatus() has returned from the last

-						//time that ReadDirectoryChangesW was called...

-						//Using CloseHandle() on the directory handle used by

-						//ReadDirectoryChangesW will cause it to return via GetQueuedCompletionStatus()....

-						if( pdi->m_hDir == INVALID_HANDLE_VALUE )

-							pdi->m_StartStopEvent.SetEvent();//signal that no further calls to ReadDirectoryChangesW will be made

-															 //and this pdi can be deleted 

-						else

-						{//for some reason, the handle is still open..

-												

-							pdi->CloseDirectoryHandle();

-

-							//wait for GetQueuedCompletionStatus() to return this pdi object again

-

-

-						}

-		

-					}break;

-															

-				case CDirWatchInfo::RUNNING_STATE_NORMAL:

-					{

-						

-						if( pdi->GetChangeHandler() )

-							pdi->GetChangeHandler()->SetChangedDirectoryName( pdi->m_strDirName );

-		

-						DWORD dwReadBuffer_Offset = 0UL;

-

-						//process the FILE_NOTIFY_INFORMATION records:

-						CFileNotifyInformation notify_info( (LPBYTE)pdi->m_Buffer, READ_DIR_CHANGE_BUFFER_SIZE);

-

-						pThis->ProcessChangeNotifications(notify_info, pdi, dwReadBuffer_Offset);

-		

-

-						//	Changes have been processed,

-						//	Reissue the watch command

-						//

-						if( !ReadDirectoryChangesW( pdi->m_hDir,

-											  pdi->m_Buffer + dwReadBuffer_Offset,//<--FILE_NOTIFY_INFORMATION records are put into this buffer 

-								              READ_DIR_CHANGE_BUFFER_SIZE - dwReadBuffer_Offset,

-											  pdi->m_bWatchSubDir,

-										      pdi->m_dwChangeFilter,

-											  &pdi->m_dwBufLength,//this var not set when using asynchronous mechanisms...

-											&pdi->m_Overlapped,

-											NULL) )//no completion routine!

-						{

-							//

-							//	NOTE:  

-							//		In this case the thread will not wake up for 

-							//		this pdi object because it is no longer associated w/

-							//		the I/O completion port...there will be no more outstanding calls to ReadDirectoryChangesW

-							//		so I have to skip the normal shutdown routines(normal being what happens when CDirectoryChangeWatcher::UnwatchDirectory() is called.

-							//		and close this up, & cause it to be freed.

-							//

-							TRACE(_T("WARNING: ReadDirectoryChangesW has failed during normal operations...failed on directory: %s\n"), pdi->m_strDirName);

-

-							ASSERT( pThis );

-							//

-							//	To help insure that this has been unwatched by the time

-							//	the main thread processes the On_ReadDirectoryChangesError() notification

-							//	bump the thread priority up temporarily.  The reason this works is because the notification

-							//	is really posted to another thread's message queue,...by setting this thread's priority

-							//	to highest, this thread will get to shutdown the watch by the time the other thread has a chance

-							//	to handle it. *note* not technically guaranteed 100% to be the case, but in practice it'll work.

-							int nOldThreadPriority = GetThreadPriority( GetCurrentThread() );

-							SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);							

-

-							//

-							//	Notify the client object....(a CDirectoryChangeHandler derived class)

-							//

-							try{

-								pdi->m_dwReadDirError = GetLastError();

-								pdi->GetChangeHandler()->On_ReadDirectoryChangesError( pdi->m_dwReadDirError, pdi->m_strDirName );

-

-

-								//Do the shutdown

-								pThis->UnwatchDirectoryBecauseOfError( pdi );

-								//pdi = NULL; <-- DO NOT set this to NULL, it will cause this worker thread to exit.

-								//pdi is INVALID at this point!!

-							}

-							catch(...)

-							{

-								//just in case of exception, this thread will be set back to 

-								//normal priority.

-							}

-							//

-							//	Set the thread priority back to normal.

-							//

-							SetThreadPriority(GetCurrentThread(), nOldThreadPriority);

-													

-						}

-						else

-						{//success, continue as normal

-							pdi->m_dwReadDirError = ERROR_SUCCESS;

-						}

-					}break;

-				default:

-					TRACE(_T("MonitorDirectoryChanges() -- how did I get here?\n"));

-					break;//how did I get here?

-				}//end switch( pdi->m_RunningState )

-		

-		

-		

-			}//end if( bObjectShouldBeOk )

-        }//end if( pdi )

-    } while( pdi );

-

-	pThis->On_ThreadExit();

-	return 0; //thread is ending

-}

-

-void CDirectoryChangeWatcher::ProcessChangeNotifications(IN CFileNotifyInformation & notify_info, 

-														 IN CDirectoryChangeWatcher::CDirWatchInfo * pdi,

-														 OUT DWORD & ref_dwReadBuffer_Offset//used in case ...see case for FILE_ACTION_RENAMED_OLD_NAME

-														 )

-/////////////////////////////////////////////////////////////

-//

-//	Processes the change notifications and dispatches the handling of the 

-//	notifications to the CDirectoryChangeHandler object passed to WatchDirectory()

-//

-/////////////////////////////////////////////////////////////

-{

-	//

-	//	Sanity check...

-	//	this function should only be called by the worker thread.

-	//	

-	ASSERT( m_dwThreadID == GetCurrentThreadId() );

-

-	//	Validate parameters...

-	//	

-	ASSERT( pdi );

-	ASSERT( AfxIsValidAddress(pdi, sizeof(CDirectoryChangeWatcher::CDirWatchInfo) ) );

-

-	if( !pdi || !AfxIsValidAddress(pdi, sizeof(CDirectoryChangeWatcher::CDirWatchInfo)) )

-	{

-		TRACE(_T("Invalid arguments to CDirectoryChangeWatcher::ProcessChangeNotifications() -- pdi is invalid!\n"));

-		TRACE(_T("File: %s Line: %d"), _T( __FILE__ ), __LINE__ );

-		return;

-	}

-

-

-

-	DWORD dwLastAction = 0;

-	ref_dwReadBuffer_Offset = 0UL;

-	

-

-	CDirectoryChangeHandler * pChangeHandler = pdi->GetChangeHandler();

-	//CDelayedDirectoryChangeHandler * pChangeHandler = pdi->GetChangeHandler();

-	ASSERT( pChangeHandler );

-	ASSERT( AfxIsValidAddress(pChangeHandler, sizeof(CDirectoryChangeHandler)) );

-	//ASSERT( AfxIsValidAddress(pChangeHandler, sizeof(CDelayedDirectoryChangeHandler)) );

-	if( !pChangeHandler )

-	{

-		TRACE(_T("CDirectoryChangeWatcher::ProcessChangeNotifications() Unable to continue, pdi->GetChangeHandler() returned NULL!\n"));

-		TRACE(_T("File: %s  Line: %d\n"), _T( __FILE__ ), __LINE__ );

-		return;

-	}

-

-

-	//

-	//	go through and process the notifications contained in the

-	//	CFileChangeNotification object( CFileChangeNotification is a wrapper for the FILE_NOTIFY_INFORMATION structure

-	//									returned by ReadDirectoryChangesW)

-	//

-    do

-	{

-		//The FileName member of the FILE_NOTIFY_INFORMATION

-		//structure contains the NAME of the file RELATIVE to the 

-		//directory that is being watched...

-		//ie, if watching C:\Temp and the file C:\Temp\MyFile.txt is changed,

-		//the file name will be "MyFile.txt"

-		//If watching C:\Temp, AND you're also watching subdirectories

-		//and the file C:\Temp\OtherFolder\MyOtherFile.txt is modified,

-		//the file name will be "OtherFolder\MyOtherFile.txt

-

-		//The CDirectoryChangeHandler::On_Filexxx() functions will receive the name of the file

-		//which includes the full path to the directory being watched

-		

-		

-		//	

-		//	See what the change was

-		//

-		

-		switch( notify_info.GetAction() )

-		{

-		case FILE_ACTION_ADDED:		// a file was added!

-	

-			pChangeHandler->On_FileAdded( notify_info.GetFileNameWithPath( pdi->m_strDirName ) ); break;

-

-		case FILE_ACTION_REMOVED:	//a file was removed

-		

-			pChangeHandler->On_FileRemoved( notify_info.GetFileNameWithPath( pdi->m_strDirName ) ); break;

-

-		case FILE_ACTION_MODIFIED:

-			//a file was changed

-			//pdi->m_pChangeHandler->On_FileModified( strLastFileName ); break;

-			pChangeHandler->On_FileModified( notify_info.GetFileNameWithPath( pdi->m_strDirName ) ); break;

-

-		case FILE_ACTION_RENAMED_OLD_NAME:

-			{//a file name has changed, and this is the OLD name

-			 //This record is followed by another one w/

-			 //the action set to FILE_ACTION_RENAMED_NEW_NAME (contains the new name of the file

-

-				CString strOldFileName = notify_info.GetFileNameWithPath( pdi->m_strDirName );

-

-				

-				if( notify_info.GetNextNotifyInformation() )

-				{//there is another PFILE_NOTIFY_INFORMATION record following the one we're working on now...

-				 //it will be the record for the FILE_ACTION_RENAMED_NEW_NAME record

-			

-

-					ASSERT( notify_info.GetAction() == FILE_ACTION_RENAMED_NEW_NAME );//making sure that the next record after the OLD_NAME record is the NEW_NAME record

-

-					//get the new file name

-					CString strNewFileName = notify_info.GetFileNameWithPath( pdi->m_strDirName );

-

-					pChangeHandler->On_FileNameChanged( strOldFileName, strNewFileName);

-				}

-				else

-				{

-					//this OLD_NAME was the last record returned by ReadDirectoryChangesW

-					//I will have to call ReadDirectoryChangesW again so that I will get 

-					//the record for FILE_ACTION_RENAMED_NEW_NAME

-

-					//Adjust an offset so that when I call ReadDirectoryChangesW again,

-					//the FILE_NOTIFY_INFORMATION will be placed after 

-					//the record that we are currently working on.

-

-					/***************

-					Let's say that 200 files all had their names changed at about the same time

-					There will be 400 FILE_NOTIFY_INFORMATION records (one for OLD_NAME and one for NEW_NAME for EACH file which had it's name changed)

-					that ReadDirectoryChangesW will have to report to

-					me.   There might not be enough room in the buffer

-					and the last record that we DID get was an OLD_NAME record,

-					I will need to call ReadDirectoryChangesW again so that I will get the NEW_NAME 

-					record.    This way I'll always have to strOldFileName and strNewFileName to pass

-					to CDirectoryChangeHandler::On_FileRenamed().

-

-				   After ReadDirecotryChangesW has filled out our buffer with

-				   FILE_NOTIFY_INFORMATION records,

-				   our read buffer would look something like this:

-																						 End Of Buffer

-																							  |

-																							 \-/	

-					|_________________________________________________________________________

-					|																		  |

-					|file1 OLD name record|file1 NEW name record|...|fileX+1 OLD_name record| |(the record we want would be here, but we've ran out of room, so we adjust an offset and call ReadDirecotryChangesW again to get it) 

-					|_________________________________________________________________________|

-

-					Since the record I need is still waiting to be returned to me,

-					and I need the current 'OLD_NAME' record,

-					I'm copying the current FILE_NOTIFY_INFORMATION record 

-					to the beginning of the buffer used by ReadDirectoryChangesW()

-					and I adjust the offset into the read buffer so the the NEW_NAME record

-					will be placed into the buffer after the OLD_NAME record now at the beginning of the buffer.

-

-					Before we call ReadDirecotryChangesW again,

-					modify the buffer to contain the current OLD_NAME record...

-

-					|_______________________________________________________

-					|														|

-					|fileX old name record(saved)|<this is now garbage>.....|

-					|_______________________________________________________|

-											 	 /-\

-												  |

-											 Offset for Read

-					Re-issue the watch command to get the rest of the records...

-

-					ReadDirectoryChangesW(..., pBuffer + (an Offset),

-

-					After GetQueuedCompletionStatus() returns, 

-					our buffer will look like this:

-

-					|__________________________________________________________________________________________________________

-					|																										   |

-					|fileX old name record(saved)|fileX new name record(the record we've been waiting for)| <other records>... |

-					|__________________________________________________________________________________________________________|

-

-					Then I'll be able to know that a file name was changed

-					and I will have the OLD and the NEW name of the file to pass to CDirectoryChangeHandler::On_FileNameChanged

-

-					****************/

-					//NOTE that this case has never happened to me in my testing

-					//so I can only hope that the code works correctly.

-					//It would be a good idea to set a breakpoint on this line of code:

-					VERIFY( notify_info.CopyCurrentRecordToBeginningOfBuffer( ref_dwReadBuffer_Offset ) );

-					

-

-				}

-				break;

-			}

-		case FILE_ACTION_RENAMED_NEW_NAME:

-			{

-				//This should have been handled in FILE_ACTION_RENAMED_OLD_NAME

-				ASSERT( dwLastAction == FILE_ACTION_RENAMED_OLD_NAME );

-				ASSERT( FALSE );//this shouldn't get here

-			}

-		

-		default:

-			TRACE(_T("CDirectoryChangeWatcher::ProcessChangeNotifications() -- unknown FILE_ACTION_ value! : %d\n"), notify_info.GetAction() );

-			break;//unknown action

-		}

-

-		dwLastAction = notify_info.GetAction();

-		

-    

-	} while( notify_info.GetNextNotifyInformation() );

-}
\ No newline at end of file