www.pudn.com > daothreadfix.zip > MultiDaoRecordSet.cpp

// MultiDaoRecordSet.cpp : implementation file 
// 
 
#define MULTIDAORECORDSET_CPP 
 
#include "stdafx.h" 
#include "MultiDaoRecordSet.h" 
 
#include "daothread.h" 
 
#include "mainfrm.h" 
 
#ifdef _DEBUG 
#define new DEBUG_NEW 
#undef THIS_FILE 
static char THIS_FILE[] = __FILE__; 
#endif 
 
///////////////////////////////////////////////////////////////////////////// 
// CMultiDaoRecordSet 
 
IMPLEMENT_DYNAMIC(CMultiDaoRecordSet, CDaoRecordset) 
 
CMultiDaoRecordSet::CMultiDaoRecordSet(CDaoDatabase* pdb) 
	: CDaoRecordset(pdb) 
{ 
	//{{AFX_FIELD_INIT(CMultiDaoRecordSet) 
	//}}AFX_FIELD_INIT 
	m_nDefaultType = dbOpenDynaset; 
} 
 
//jtm 
//thread safe destructor.... 
CMultiDaoRecordSet::~CMultiDaoRecordSet() 
{ 
	if (IsOpen()) 
		Close(); 
 
	// Clean up database if necessary 
	if (m_pDatabase != NULL && (m_nStatus & AFX_DAO_IMPLICIT_DB)) 
	{ 
		m_pDatabase->Close(); 
		delete m_pDatabase; 
		m_pDatabase = NULL; 
	} 
} 
 
 
 
CString CMultiDaoRecordSet::GetDefaultDBName() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	return "TEST.mdb"; 
} 
 
///////////////////////////////////////////////////////////////////////////// 
// CMultiDaoRecordSet diagnostics 
 
 
//jtm 
//multi thread safe functoins 
void CMultiDaoRecordSet::Open(int nOpenType,	LPCTSTR lpszSQL, int nOptions) 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		CDaoRecordset::Open(nOpenType, lpszSQL, nOptions); 
	} 
	else 
	{ 
		pParam1 = (void *)&nOpenType; 
		pParam2 = (void *)lpszSQL; 
		pParam3 = (void *)&nOptions; 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			AfxGetMainWnd()->SendMessage(WM_MULTIDAOMESSAGE, MultiDaoOpen, (LPARAM)this); 
		} 
	} 
} 
 
void CMultiDaoRecordSet::Close() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		CDaoRecordset::Close(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			AfxGetMainWnd()->SendMessage(WM_MULTIDAOMESSAGE, MultiDaoClose, (LPARAM)this); 
		} 
	} 
} 
 
BOOL CMultiDaoRecordSet::IsOpen() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		return CDaoRecordset::IsOpen(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			return (BOOL)AfxGetMainWnd()-> 
				SendMessage(WM_MULTIDAOMESSAGE, MultiDaoIsOpen, (LPARAM)this); 
		} 
		else 
		{ 
			TRACE("Is Open Called After App Closed"); 
			return FALSE; 
		} 
	} 
} 
 
BOOL CMultiDaoRecordSet::IsBOF() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		return CDaoRecordset::IsBOF(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			return (BOOL)AfxGetMainWnd()-> 
				SendMessage(WM_MULTIDAOMESSAGE, MultiDaoIsBOF, (LPARAM)this); 
		} 
		else 
		{ 
			TRACE("IsBOF called after app closed."); 
			return FALSE; 
		} 
	} 
} 
 
BOOL CMultiDaoRecordSet::IsEOF() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		return CDaoRecordset::IsEOF(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			return (BOOL)AfxGetMainWnd()-> 
				SendMessage(WM_MULTIDAOMESSAGE, MultiDaoIsEOF, (LPARAM)this); 
		} 
		else 
		{ 
			TRACE("IsEOF Called After app closed"); 
			return FALSE; 
		} 
	} 
} 
 
BOOL CMultiDaoRecordSet::IsDeleted() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		return CDaoRecordset::IsDeleted(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			return (BOOL)AfxGetMainWnd()-> 
				SendMessage(WM_MULTIDAOMESSAGE, MultiDaoIsDeleted, (LPARAM)this); 
		} 
		else 
		{ 
			TRACE("IsDeleted called after app closed"); 
			return FALSE; 
		} 
	} 
} 
 
BOOL CMultiDaoRecordSet::IsFieldDirty(void* pv) 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		return CDaoRecordset::IsFieldDirty(pv); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			pParam1 = pv; 
			return (BOOL)AfxGetMainWnd()-> 
				SendMessage(WM_MULTIDAOMESSAGE, MultiDaoIsFieldDirty, (LPARAM)this); 
		} 
		else 
		{ 
			TRACE("IsFieldDirty  called after app closed"); 
			return FALSE; 
		} 
	} 
} 
 
BOOL CMultiDaoRecordSet::IsFieldNull(void* pv) 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		return CDaoRecordset::IsFieldNull(pv); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			pParam1 = pv; 
			return (BOOL)AfxGetMainWnd()-> 
				SendMessage(WM_MULTIDAOMESSAGE, MultiDaoIsFieldNull, (LPARAM)this); 
		} 
		else 
		{ 
			TRACE("IsFieldNull called after app closed"); 
			return FALSE; 
		} 
	} 
} 
 
BOOL CMultiDaoRecordSet::IsFieldNullable(void* pv) 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		return CDaoRecordset::IsFieldNullable(pv); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			pParam1 = pv; 
			return (BOOL)AfxGetMainWnd()-> 
				SendMessage(WM_MULTIDAOMESSAGE, MultiDaoIsFieldNullable, (LPARAM)this); 
		} 
		else 
		{ 
			TRACE("IsFieldNullable called after app closed"); 
			return FALSE; 
		} 
	} 
} 
 
CString CMultiDaoRecordSet::GetName() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		return CDaoRecordset::GetName(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			return (CString)*(CString *)AfxGetMainWnd()-> 
				SendMessage(WM_MULTIDAOMESSAGE, MultiDaoGetName, (LPARAM)this); 
		} 
		else 
		{ 
			TRACE("Get Name called after app closed"); 
			return "ERROR"; 
		} 
	} 
} 
 
short CMultiDaoRecordSet::GetType() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		return CDaoRecordset::GetType(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			return (short)AfxGetMainWnd()-> 
				SendMessage(WM_MULTIDAOMESSAGE, MultiDaoGetType, (LPARAM)this); 
		} 
		else 
		{ 
			TRACE("GetType called after app closed"); 
			return 0; 
		} 
	} 
} 
 
short CMultiDaoRecordSet::GetEditMode() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		return CDaoRecordset::GetEditMode(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			return (short)AfxGetMainWnd()-> 
				SendMessage(WM_MULTIDAOMESSAGE, MultiDaoGetEditMode, (LPARAM)this); 
		} 
		else 
		{ 
			TRACE("GetEditMode called after app closed"); 
			return 0; 
		} 
	} 
} 
 
CString CMultiDaoRecordSet::GetSQL() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		return CDaoRecordset::GetSQL(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			return (CString)*(CString *)AfxGetMainWnd()-> 
				SendMessage(WM_MULTIDAOMESSAGE, MultiDaoGetSQL, (LPARAM)this); 
		} 
		else 
		{ 
			TRACE("GetSQL called after app closed"); 
			return "ERROR"; 
		} 
	} 
} 
 
COleVariant CMultiDaoRecordSet::GetLastModifiedBookmark() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		return CDaoRecordset::GetLastModifiedBookmark(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			return (COleVariant)AfxGetMainWnd()-> 
				SendMessage(WM_MULTIDAOMESSAGE, MultiDaoGetLastModifiedBookmark, (LPARAM)this); 
		} 
		else 
		{ 
			TRACE("GetLastModifiedBookmark called after app closed"); 
			COleVariant cv; 
			return cv; //????what to do???? 
		} 
	} 
} 
 
long CMultiDaoRecordSet::GetRecordCount() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		return CDaoRecordset::GetRecordCount(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			return (long)AfxGetMainWnd()-> 
				SendMessage(WM_MULTIDAOMESSAGE, MultiDaoGetRecordCount, (LPARAM)this); 
		} 
		else 
		{ 
			TRACE("GetRecordCount called after app closed"); 
			return 0; 
		} 
	} 
} 
 
void CMultiDaoRecordSet::MoveNext() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		CDaoRecordset::MoveNext(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			AfxGetMainWnd()->SendMessage(WM_MULTIDAOMESSAGE, MultiDaoMoveNext,  
				(LPARAM)this); 
		} 
	} 
} 
 
void CMultiDaoRecordSet::MovePrev() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		CDaoRecordset::MovePrev(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			AfxGetMainWnd()->SendMessage(WM_MULTIDAOMESSAGE, MultiDaoMovePrev,  
				(LPARAM)this); 
		} 
	} 
} 
 
void CMultiDaoRecordSet::MoveFirst() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		CDaoRecordset::MoveFirst(); 
	} 
	else 
	{ 
				if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			AfxGetMainWnd()->SendMessage(WM_MULTIDAOMESSAGE, MultiDaoMoveFirst,  
				(LPARAM)this); 
		} 
	} 
} 
 
void CMultiDaoRecordSet::MoveLast() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		CDaoRecordset::MoveLast(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			AfxGetMainWnd()->SendMessage(WM_MULTIDAOMESSAGE, MultiDaoMoveLast,  
			(LPARAM)this); 
		} 
	} 
} 
 
void CMultiDaoRecordSet::Move(long lRows) 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		CDaoRecordset::Move(lRows); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			pParam1 = (void *)&lRows; 
			AfxGetMainWnd()->SendMessage(WM_MULTIDAOMESSAGE, MultiDaoMove,  
				(LPARAM)this); 
		} 
	} 
} 
 
BOOL CMultiDaoRecordSet::FindNext(LPCTSTR lpszFilter) 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		return CDaoRecordset::FindNext(lpszFilter); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			pParam1 = (void *)lpszFilter; 
			return (BOOL)AfxGetMainWnd()->SendMessage(WM_MULTIDAOMESSAGE, MultiDaoFindNext,  
				(LPARAM)this); 
		} 
		else 
		{ 
			TRACE("FindNext called after app closed"); 
			return FALSE; 
		} 
	} 
} 
 
BOOL CMultiDaoRecordSet::FindPrev(LPCTSTR lpszFilter) 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		return CDaoRecordset::FindPrev(lpszFilter); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			pParam1 = (void *)lpszFilter; 
			return (BOOL)AfxGetMainWnd()->SendMessage(WM_MULTIDAOMESSAGE, MultiDaoFindPrev,  
				(LPARAM)this); 
		} 
		else 
		{ 
			TRACE("Find Prev called after app closed"); 
			return FALSE; 
		} 
	} 
} 
 
BOOL CMultiDaoRecordSet::FindFirst(LPCTSTR lpszFilter) 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		return CDaoRecordset::FindFirst(lpszFilter); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			pParam1 = (void *)lpszFilter; 
			return (BOOL)AfxGetMainWnd()->SendMessage(WM_MULTIDAOMESSAGE, MultiDaoFindFirst,  
				(LPARAM)this); 
		} 
		else 
		{ 
			TRACE("FindFirst called after app closed"); 
			return FALSE; 
		} 
	} 
} 
 
BOOL CMultiDaoRecordSet::FindLast(LPCTSTR lpszFilter) 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		return CDaoRecordset::FindLast(lpszFilter); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			pParam1 = (void *)lpszFilter; 
			return (BOOL)AfxGetMainWnd()->SendMessage(WM_MULTIDAOMESSAGE, MultiDaoFindLast,  
				(LPARAM)this); 
		} 
		else 
		{ 
			TRACE("FindLast called after app closed"); 
			return FALSE; 
		} 
	} 
	return FALSE; 
} 
 
BOOL CMultiDaoRecordSet::Find(long lFindType, LPCTSTR lpszFilter) 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		return CDaoRecordset::Find(lFindType, lpszFilter); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			pParam1 = (void *)&lFindType; 
			pParam2 = (void *)lpszFilter; 
			return (BOOL)AfxGetMainWnd()->SendMessage(WM_MULTIDAOMESSAGE, MultiDaoFind,  
				(LPARAM)this); 
		} 
		else 
		{ 
			TRACE("Find called after app closed"); 
			return FALSE; 
		} 
	} 
} 
 
COleVariant CMultiDaoRecordSet::GetBookmark() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		return CDaoRecordset::GetBookmark(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			return AfxGetMainWnd()->SendMessage(WM_MULTIDAOMESSAGE, MultiDaoGetBookmark,  
				(LPARAM)this); 
		} 
		else 
		{ 
			TRACE("GetBookMark called after app closed"); 
			COleVariant cv; 
			return cv; //??not sure what to do here...?? 
		} 
	} 
} 
 
void CMultiDaoRecordSet::SetBookmark(COleVariant varBookmark)			 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		CDaoRecordset::SetBookmark(varBookmark); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			pParam1 = (void *)&varBookmark; 
			AfxGetMainWnd()->SendMessage(WM_MULTIDAOMESSAGE, MultiDaoSetBookmark,  
				(LPARAM)this); 
		} 
	} 
} 
 
void CMultiDaoRecordSet::AddNew() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		CDaoRecordset::AddNew(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			AfxGetMainWnd()->SendMessage(WM_MULTIDAOMESSAGE, MultiDaoAddNew,  
				(LPARAM)this); 
		} 
	} 
} 
 
void CMultiDaoRecordSet::Edit() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		CDaoRecordset::Edit(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			AfxGetMainWnd()->SendMessage(WM_MULTIDAOMESSAGE, MultiDaoEdit,  
				(LPARAM)this); 
		} 
	} 
} 
 
void CMultiDaoRecordSet::Update() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		CDaoRecordset::Update(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			AfxGetMainWnd()->SendMessage(WM_MULTIDAOMESSAGE, MultiDaoUpdate,  
				(LPARAM)this); 
		} 
	} 
} 
 
void CMultiDaoRecordSet::Delete() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		CDaoRecordset::Delete(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			AfxGetMainWnd()->SendMessage(WM_MULTIDAOMESSAGE, MultiDaoDelete,  
				(LPARAM)this); 
		} 
	} 
} 
 
void CMultiDaoRecordSet::CancelUpdate()	 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		CDaoRecordset::CancelUpdate(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			AfxGetMainWnd()->SendMessage(WM_MULTIDAOMESSAGE, MultiDaoCancelUpdate,  
				(LPARAM)this); 
		} 
	} 
} 
 
void CMultiDaoRecordSet::Requery() 
{ 
	CDAOTHREADApp *pApp = ((CDAOTHREADApp *)AfxGetApp());							 
	if (pApp->pGUIThread == AfxGetThread()) 
	{ 
		CDaoRecordset::Requery(); 
	} 
	else 
	{ 
		if (IsWindow(AfxGetMainWnd()->GetSafeHwnd())) 
		{ 
			AfxGetMainWnd()->SendMessage(WM_MULTIDAOMESSAGE, MultiDaoRequery,  
				(LPARAM)this); 
		} 
	} 
}