able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/snapin/mtfrmwk/treedat_.cpp

1039 lines
27 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
//
// Copyright (C) Microsoft Corporation, 1998 - 1999
//
// File: treedat_.cpp
//
//--------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
// Miscellanea
LPCWSTR g_lpszNullString = L"\0";
///////////////////////////////////////////////////////////////////////
// Global Helper functions
BOOL LoadContextMenuResources(MENUMAP* pMenuMap)
{
HINSTANCE hInstance = _Module.GetModuleInstance();
for (int i = 0; pMenuMap->ctxMenu[i].strName; i++)
{
if (0 == ::LoadString(hInstance, pMenuMap->dataRes[i].uResID, pMenuMap->dataRes[i].szBuffer, MAX_CONTEXT_MENU_STRLEN*2))
return FALSE;
pMenuMap->ctxMenu[i].strName = pMenuMap->dataRes[i].szBuffer;
for (WCHAR* pCh = pMenuMap->dataRes[i].szBuffer; (*pCh) != NULL; pCh++)
{
if ( (*pCh) == L'\n')
{
pMenuMap->ctxMenu[i].strStatusBarText = (pCh+1);
(*pCh) = NULL;
break;
}
}
}
return TRUE;
}
BOOL LoadResultHeaderResources(RESULT_HEADERMAP* pHeaderMap, int nCols)
{
HINSTANCE hInstance = _Module.GetModuleInstance();
for ( int i = 0; i < nCols ; i++)
{
if ( 0 == ::LoadString(hInstance, pHeaderMap[i].uResID, pHeaderMap[i].szBuffer, MAX_RESULT_HEADER_STRLEN))
return TRUE;
}
return TRUE;
}
////////////////////////////////////////////////////////////////////////
// CTreeNode
BEGIN_TOOLBAR_MAP(CTreeNode)
END_TOOLBAR_MAP()
BOOL CTreeNode::HasContainer(CContainerNode* pContainerNode)
{
if (m_pContainer == NULL)
return FALSE; // root
if (m_pContainer == pContainerNode)
return TRUE; // got it
return m_pContainer->HasContainer(pContainerNode);
}
HRESULT CTreeNode::GetResultViewType(CComponentDataObject* pComponentData,
LPOLESTR* ppViewType,
long* pViewOptions)
{
if (pComponentData->IsMultiSelect())
{
*pViewOptions = MMC_VIEW_OPTIONS_MULTISELECT;
}
else
{
*pViewOptions = MMC_VIEW_OPTIONS_NONE;
}
*ppViewType = NULL;
return S_FALSE;
}
void CTreeNode::Show(BOOL bShow, CComponentDataObject* pComponentData)
{
if (bShow)
{
ASSERT(m_dwNodeFlags & TN_FLAG_HIDDEN); // must be currently hidden
SetFlagsDown(TN_FLAG_HIDDEN,FALSE); // mark it visible
VERIFY(SUCCEEDED(pComponentData->AddNode(this)));
}
else
{
ASSERT(!(m_dwNodeFlags & TN_FLAG_HIDDEN)); // must be currently visible
SetFlagsDown(TN_FLAG_HIDDEN,TRUE); // mark it hidden
VERIFY(SUCCEEDED(pComponentData->DeleteNode(this)));
if (IsContainer())
{
((CContainerNode*)this)->RemoveAllChildrenFromList();
((CContainerNode*)this)->MarkEnumerated(FALSE);
}
}
}
void CTreeNode::SetFlagsDown(DWORD dwNodeFlags, BOOL bSet)
{
if (bSet)
m_dwNodeFlags |= dwNodeFlags;
else
m_dwNodeFlags &= ~dwNodeFlags;
}
void CTreeNode::SetFlagsUp(DWORD dwNodeFlags, BOOL bSet)
{
if (bSet)
m_dwNodeFlags |= dwNodeFlags;
else
m_dwNodeFlags &= ~dwNodeFlags;
if (m_pContainer != NULL)
{
ASSERT(m_pContainer != this);
m_pContainer->SetFlagsUp(dwNodeFlags, bSet);
}
}
//
// Property Page methods
//
void CTreeNode::ShowPageForNode(CComponentDataObject* pComponentDataObject)
{
ASSERT(pComponentDataObject != NULL);
pComponentDataObject->GetPropertyPageHolderTable()->BroadcastSelectPage(this, -1);
}
BOOL CTreeNode::HasPropertyPages(DATA_OBJECT_TYPES,
BOOL* pbHideVerb,
CNodeList*)
{
*pbHideVerb = TRUE;
return FALSE;
}
//
// Menu Item methods
//
HRESULT CTreeNode::OnAddMenuItems(IContextMenuCallback2* pContextMenuCallback2,
DATA_OBJECT_TYPES type,
long *pInsertionAllowed,
CNodeList* pNodeList)
{
HRESULT hr = S_OK;
LPCONTEXTMENUITEM2 pContextMenuItem = NULL;
if (pNodeList->GetCount() == 1) // single selection
{
pContextMenuItem = OnGetContextMenuItemTable();
if (pContextMenuItem == NULL)
return hr;
//
// Loop through and add each of the menu items
//
for (LPCONTEXTMENUITEM2 m = pContextMenuItem; m->strName; m++)
{
if (
( (*pInsertionAllowed & CCM_INSERTIONALLOWED_NEW) &&
(m->lInsertionPointID == CCM_INSERTIONPOINTID_PRIMARY_NEW) ) ||
( (*pInsertionAllowed & CCM_INSERTIONALLOWED_TASK) &&
(m->lInsertionPointID == CCM_INSERTIONPOINTID_PRIMARY_TASK) ) ||
( (*pInsertionAllowed & CCM_INSERTIONALLOWED_VIEW) &&
(m->lInsertionPointID == CCM_INSERTIONPOINTID_PRIMARY_VIEW) ) ||
( (*pInsertionAllowed & CCM_INSERTIONALLOWED_TOP) &&
(m->lInsertionPointID == CCM_INSERTIONPOINTID_PRIMARY_TOP) )
)
{
// make a temporary copy that can be modified
CONTEXTMENUITEM2 tempItem;
::memcpy(&tempItem, m, sizeof(CONTEXTMENUITEM2));
if (OnAddMenuItem(&tempItem, pInsertionAllowed))
{
hr = pContextMenuCallback2->AddItem(&tempItem);
if (FAILED(hr))
break;
}
}
}
}
else if (pNodeList->GetCount() > 1) // multiple selection
{
hr = OnAddMenuItemsMultipleSelect(pContextMenuCallback2,
type,
pInsertionAllowed,
pNodeList);
}
return hr;
}
BOOL CTreeNode::OnSetRenameVerbState(DATA_OBJECT_TYPES,
BOOL* pbHide,
CNodeList*)
{
*pbHide = TRUE;
return FALSE;
}
BOOL CTreeNode::OnSetDeleteVerbState(DATA_OBJECT_TYPES,
BOOL* pbHide,
CNodeList*)
{
*pbHide = TRUE;
return FALSE;
}
BOOL CTreeNode::OnSetRefreshVerbState(DATA_OBJECT_TYPES,
BOOL* pbHide,
CNodeList*)
{
*pbHide = TRUE;
return FALSE;
}
BOOL CTreeNode::OnSetCutVerbState(DATA_OBJECT_TYPES,
BOOL* pbHide,
CNodeList*)
{
*pbHide = TRUE;
return FALSE;
}
BOOL CTreeNode::OnSetCopyVerbState(DATA_OBJECT_TYPES,
BOOL* pbHide,
CNodeList*)
{
*pbHide = TRUE;
return FALSE;
}
BOOL CTreeNode::OnSetPasteVerbState(DATA_OBJECT_TYPES,
BOOL* pbHide,
CNodeList*)
{
*pbHide = TRUE;
return FALSE;
}
BOOL CTreeNode::OnSetPrintVerbState(DATA_OBJECT_TYPES,
BOOL* pbHide,
CNodeList*)
{
*pbHide = TRUE;
return FALSE;
}
MMC_CONSOLE_VERB CTreeNode::GetDefaultVerb(DATA_OBJECT_TYPES type,
CNodeList* pNodeList)
{
ASSERT((type == CCT_SCOPE) || (type == CCT_RESULT));
if (type == CCT_SCOPE)
return MMC_VERB_OPEN;
BOOL bHideVerbDummy;
if (HasPropertyPages(type, &bHideVerbDummy, pNodeList))
return MMC_VERB_PROPERTIES;
return MMC_VERB_NONE;
}
void CTreeNode::OnSetVerbState(LPCONSOLEVERB pConsoleVerb,
DATA_OBJECT_TYPES type,
CNodeList* pNodeList)
{
//
// Use the virtual functions to get the verb state
//
BOOL bHideCut;
BOOL bCanCut = OnSetCutVerbState(type, &bHideCut, pNodeList);
pConsoleVerb->SetVerbState(MMC_VERB_CUT, HIDDEN, bHideCut);
pConsoleVerb->SetVerbState(MMC_VERB_CUT, ENABLED, bCanCut);
BOOL bHideCopy;
BOOL bCanCopy = OnSetCopyVerbState(type, &bHideCopy, pNodeList);
pConsoleVerb->SetVerbState(MMC_VERB_COPY, HIDDEN, bHideCopy);
pConsoleVerb->SetVerbState(MMC_VERB_COPY, ENABLED, bCanCopy);
BOOL bHidePaste;
BOOL bCanPaste = OnSetPasteVerbState(type, &bHidePaste, pNodeList);
pConsoleVerb->SetVerbState(MMC_VERB_PASTE, HIDDEN, bHidePaste);
pConsoleVerb->SetVerbState(MMC_VERB_PASTE, ENABLED, bCanPaste);
BOOL bHidePrint;
BOOL bCanPrint = OnSetPrintVerbState(type, &bHidePrint, pNodeList);
pConsoleVerb->SetVerbState(MMC_VERB_PRINT, HIDDEN, bHidePrint);
pConsoleVerb->SetVerbState(MMC_VERB_PRINT, ENABLED, bCanPrint);
BOOL bHideRename;
BOOL bCanRename = OnSetRenameVerbState(type, &bHideRename, pNodeList);
pConsoleVerb->SetVerbState(MMC_VERB_RENAME, HIDDEN, bHideRename);
pConsoleVerb->SetVerbState(MMC_VERB_RENAME, ENABLED, bCanRename);
// MMC_VERB_PROPERTIES
BOOL bHideProperties;
BOOL bHasProperties = HasPropertyPages(type, &bHideProperties, pNodeList);
pConsoleVerb->SetVerbState(MMC_VERB_PROPERTIES, ENABLED, bHasProperties);
pConsoleVerb->SetVerbState(MMC_VERB_PROPERTIES, HIDDEN, bHideProperties);
// MMC_VERB_DELETE
BOOL bHideDelete;
BOOL bCanDelete = OnSetDeleteVerbState(type, &bHideDelete, pNodeList);
pConsoleVerb->SetVerbState(MMC_VERB_DELETE, ENABLED, bCanDelete);
pConsoleVerb->SetVerbState(MMC_VERB_DELETE, HIDDEN, bHideDelete);
// MMC_VERB_REFRESH
BOOL bHideRefresh;
BOOL bCanRefresh = OnSetRefreshVerbState(type, &bHideRefresh, pNodeList);
pConsoleVerb->SetVerbState(MMC_VERB_REFRESH, ENABLED, bCanRefresh);
pConsoleVerb->SetVerbState(MMC_VERB_REFRESH, HIDDEN, bHideRefresh);
}
HRESULT CTreeNode::OnSetToolbarVerbState(IToolbar*,
CNodeList*)
{
HRESULT hr = S_OK;
//
// Set the button state for each button on the toolbar using
// hr = pToolbar->SetButtonState(event, MMC_BUTTON_STATE, bState);
//
return hr;
}
void CTreeNode::DeleteHelper(CComponentDataObject* pComponentData)
{
ASSERT(pComponentData != NULL);
ASSERT(m_pContainer != NULL);
ASSERT((CTreeNode*)m_pContainer != this);
CContainerNode* pCont = m_pContainer;
VERIFY(m_pContainer->RemoveChildFromList(this));
ASSERT(m_pContainer == NULL);
m_pContainer = pCont; // not in the container's list of children, but still needed
// remove from UI only if the container is visible
if (pCont->IsVisible())
VERIFY(SUCCEEDED(pComponentData->DeleteNode(this))); // remove from the UI
}
void CTreeNode::IncrementSheetLockCount()
{
++m_nSheetLockCount;
if (m_pContainer != NULL)
m_pContainer->IncrementSheetLockCount();
}
void CTreeNode::DecrementSheetLockCount()
{
--m_nSheetLockCount;
if (m_pContainer != NULL)
m_pContainer->DecrementSheetLockCount();
}
void CTreeNode::OnPropertyChange(CComponentDataObject* pComponentData,
BOOL, long changeMask)
{
// function called when the PPHolder successfully updated the node
ASSERT(pComponentData != NULL);
VERIFY(SUCCEEDED(pComponentData->ChangeNode(this, changeMask)));
}
void CTreeNode::OnCreateSheet()
{
++m_nSheetCount;
IncrementSheetLockCount();
SetFlagsUp(TN_FLAG_HAS_SHEET, TRUE);
}
void CTreeNode::OnDeleteSheet()
{
DecrementSheetLockCount();
--m_nSheetCount;
SetFlagsUp(TN_FLAG_HAS_SHEET,FALSE);
}
////////////////////////////////////////////////////////////////////////
// CContainerNode
void CContainerNode::IncrementThreadLockCount()
{
++m_nThreadLockCount;
if (m_pContainer != NULL)
m_pContainer->IncrementThreadLockCount();
}
void CContainerNode::DecrementThreadLockCount()
{
--m_nThreadLockCount;
if (m_pContainer != NULL)
m_pContainer->DecrementThreadLockCount();
}
BOOL CContainerNode::OnRefresh(CComponentDataObject* pComponentData,
CNodeList* pNodeList)
{
BOOL bRet = TRUE;
if (pNodeList->GetCount() == 1) // single selection
{
if (IsSheetLocked())
{
if (!CanCloseSheets())
return FALSE;
pComponentData->GetPropertyPageHolderTable()->DeleteSheetsOfNode(this);
}
ASSERT(!IsSheetLocked());
RemoveAllChildrenHelper(pComponentData);
ASSERT(!HasChildren());
OnEnumerate(pComponentData);
AddCurrentChildrenToUI(pComponentData);
MarkEnumerated();
}
else // multiple selection
{
POSITION pos = pNodeList->GetHeadPosition();
while (pos != NULL)
{
CTreeNode* pNode = pNodeList->GetNext(pos);
ASSERT(pNode != NULL);
//
// Have each node refresh itself
//
CNodeList nodeList;
nodeList.AddTail(pNode);
if (!pNode->OnRefresh(pComponentData, &nodeList))
{
bRet = FALSE;
}
}
}
return bRet;
}
BOOL CContainerNode::RemoveChildFromList(CTreeNode* p)
{
if (p->IsContainer())
{
if (m_containerChildList.RemoveNode(p))
{
p->m_pContainer = NULL;
return TRUE;
}
}
else
{
if (m_leafChildList.RemoveNode(p))
{
p->m_pContainer = NULL;
return TRUE;
}
}
return FALSE;
}
void CContainerNode::RemoveAllChildrenHelper(CComponentDataObject* pComponentData)
{
ASSERT(pComponentData != NULL);
// remove from the UI
VERIFY(SUCCEEDED(pComponentData->RemoveAllChildren(this)));
// remove from memory, recursively from the bottom
RemoveAllChildrenFromList();
}
void CContainerNode::AddCurrentChildrenToUI(CComponentDataObject* pComponentData)
{
POSITION pos;
//
// Add leaves
//
for( pos = m_leafChildList.GetHeadPosition(); pos != NULL; )
{
CTreeNode* pCurrentChild = m_leafChildList.GetNext(pos);
VERIFY(SUCCEEDED(pComponentData->AddNode(pCurrentChild)));
}
//
// Add Containers
//
for( pos = m_containerChildList.GetHeadPosition(); pos != NULL; )
{
CTreeNode* pCurrentChild = m_containerChildList.GetNext(pos);
VERIFY(SUCCEEDED(pComponentData->AddNode(pCurrentChild)));
}
}
void CContainerNode::SetFlagsDown(DWORD dwNodeFlags, BOOL bSet)
{
CTreeNode::SetFlagsDown(dwNodeFlags,bSet);
// scan the list of children
POSITION pos;
for( pos = m_containerChildList.GetHeadPosition(); pos != NULL; )
{
CTreeNode* pCurrentChild = m_containerChildList.GetNext(pos);
pCurrentChild->SetFlagsDown(dwNodeFlags,bSet);
}
for( pos = m_leafChildList.GetHeadPosition(); pos != NULL; )
{
CTreeNode* pCurrentChild = m_leafChildList.GetNext(pos);
pCurrentChild->SetFlagsDown(dwNodeFlags,bSet);
}
}
void CContainerNode::SetFlagsOnNonContainers(DWORD dwNodeFlags, BOOL bSet)
{
// do not set on urselves, we are a container
// scan the list of children
POSITION pos;
for( pos = m_leafChildList.GetHeadPosition(); pos != NULL; )
{
CTreeNode* pCurrentChild = m_leafChildList.GetNext(pos);
pCurrentChild->SetFlagsDown(dwNodeFlags,bSet);
}
for (pos = m_containerChildList.GetHeadPosition(); pos != NULL; )
{
CTreeNode* pCurrentChild = m_containerChildList.GetNext(pos);
((CContainerNode*)pCurrentChild)->SetFlagsOnNonContainers(dwNodeFlags,bSet);
}
}
BOOL CContainerNode::AddChildToList(CTreeNode* p)
{
BOOL bRet = FALSE;
p->m_pContainer = this;
if (p->IsContainer())
{
bRet = NULL != m_containerChildList.AddTail(p);
}
else
{
bRet = NULL != m_leafChildList.AddTail(p);
}
return bRet;
}
BOOL CContainerNode::FindChild(CTreeNode* pNode, CTreeNode** ppContainer)
{
*ppContainer = NULL;
if (pNode == NULL)
return FALSE; // no sense in continuing
if (pNode == this)
{
*ppContainer = m_pContainer;
return TRUE; // the node is ourselves
}
//
// If we are looking for a leaf node search the list of leaves first
//
if (!pNode->IsContainer())
{
POSITION pos;
for (pos = m_leafChildList.GetHeadPosition(); pos != NULL; )
{
CLeafNode* pCurrentLeafNode = (CLeafNode*)m_leafChildList.GetNext(pos);
ASSERT(pCurrentLeafNode != NULL);
if (pCurrentLeafNode == pNode)
{
*ppContainer = this;
return TRUE;
}
}
}
//
// scan and recurse the containers if necessary
//
POSITION contPos;
for( contPos = m_containerChildList.GetHeadPosition(); contPos != NULL; )
{
CContainerNode* pCurrentChild = (CContainerNode*)m_containerChildList.GetNext(contPos);
ASSERT(pCurrentChild != NULL);
if (pCurrentChild == pNode)
{
*ppContainer = this;
return TRUE; // we directly contain the node
}
//
// if the current node is a container, look inside it
//
if (pCurrentChild->FindChild(pNode,ppContainer))
{
return TRUE; // got it in the recursion
}
}
return FALSE; // not found
}
BOOL CContainerNode::AddChildToListAndUI(CTreeNode* pChildToAdd, CComponentDataObject* pComponentData)
{
ASSERT(pComponentData != NULL);
VERIFY(AddChildToList(pChildToAdd)); // at the end of the list of children
ASSERT(pChildToAdd->GetContainer() == this); // inserted underneath
// add to UI only if currently visible and already expanded
if (!IsVisible() || !IsExpanded())
return TRUE;
return SUCCEEDED(pComponentData->AddNode(pChildToAdd)); // add to the UI
}
BOOL CContainerNode::AddChildToListAndUISorted(CTreeNode* pChildToAdd, CComponentDataObject* pComponentData)
{
ASSERT(pComponentData != NULL);
VERIFY(AddChildToListSorted(pChildToAdd, pComponentData));
ASSERT(pChildToAdd->GetContainer() == this); // inserted underneath
// add to UI only if currently visible and already expanded
if (!IsVisible() || !IsExpanded())
return TRUE;
return SUCCEEDED(pComponentData->AddNodeSorted(pChildToAdd)); // add to the UI
}
BOOL CContainerNode::AddChildToListSorted(CTreeNode* p, CComponentDataObject*)
{
//
// Containers will be sorted with respect to containers and leaves will be
// sorted with respect to leaves but they won't be intermingled.
//
p->m_pContainer = this;
CNodeList* pChildNodeList = NULL;
if (p->IsContainer())
{
pChildNodeList = &m_containerChildList;
}
else
{
pChildNodeList = &m_leafChildList;
}
//
// Find the position to insert the node in the list in sorted order
//
POSITION pos = pChildNodeList->GetHeadPosition();
while (pos != NULL)
{
CTreeNode* pNodeInList = pChildNodeList->GetAt(pos);
if (_wcsicoll(p->GetDisplayName(), pNodeInList->GetDisplayName()) < 0)
{
break;
}
pChildNodeList->GetNext(pos);
}
if (pos == NULL)
{
return NULL != pChildNodeList->AddTail(p);
}
return NULL != pChildNodeList->InsertBefore(pos, p);
}
void CContainerNode::RemoveAllChildrenFromList()
{
RemoveAllContainersFromList();
RemoveAllLeavesFromList();
}
int CContainerNode::Compare(CTreeNode* pNodeA, CTreeNode* pNodeB, int nCol, LPARAM)
{
// default sorting behavior
LPCTSTR lpszA = pNodeA->GetString(nCol);
LPCTSTR lpszB = pNodeB->GetString(nCol);
// cannot process NULL strings, have to use ""
ASSERT(lpszA != NULL);
ASSERT(lpszB != NULL);
return _tcsicoll( (lpszA != NULL) ? lpszA : g_lpszNullString, (lpszB != NULL) ? lpszB : g_lpszNullString);
}
void CContainerNode::ForceEnumeration(CComponentDataObject* pComponentData)
{
if (IsEnumerated())
return;
OnEnumerate(pComponentData);
MarkEnumerated();
}
void CContainerNode::MarkEnumerated(BOOL bEnum)
{
ASSERT(IsContainer());
if (bEnum)
m_dwNodeFlags |= TN_FLAG_CONTAINER_ENUM;
else
m_dwNodeFlags &= ~TN_FLAG_CONTAINER_ENUM;
}
void CContainerNode::MarkEnumeratedAndLoaded(CComponentDataObject* pComponentData)
{
MarkEnumerated();
OnChangeState(pComponentData); // move to loading
OnChangeState(pComponentData); // move to loaded
}
/////////////////////////////////////////////////////////////////////////////
// CBackgroundThread
CBackgroundThread::CBackgroundThread()
{
m_pQueryObj = NULL;
m_bAutoDelete = FALSE;
m_bAbandoned = FALSE;
m_pContNode = NULL;
m_hEventHandle = NULL;
ExceptionPropagatingInitializeCriticalSection(&m_cs);
m_nQueueCountMax = 10;
}
CBackgroundThread::~CBackgroundThread()
{
TRACE(_T("CBackgroundThread::~CBackgroundThread()\n"));
ASSERT(IsAbandoned() || IsQueueEmpty());
::DeleteCriticalSection(&m_cs);
if (m_hEventHandle != NULL)
{
VERIFY(::CloseHandle(m_hEventHandle));
m_hEventHandle = NULL;
}
if (m_pQueryObj != NULL)
{
delete m_pQueryObj;
m_pQueryObj = NULL;
}
}
void CBackgroundThread::SetQueryObj(CQueryObj* pQueryObj)
{
ASSERT(pQueryObj != NULL);
m_pQueryObj = pQueryObj;
m_pQueryObj->SetThread(this);
}
BOOL CBackgroundThread::Start(CMTContainerNode* pNode, CComponentDataObject* pComponentData)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
ASSERT(m_pContNode == NULL);
m_pContNode = pNode;
m_hHiddenWnd = pComponentData->GetHiddenWindow();
ASSERT(m_hEventHandle == NULL); // cannot call start twice or reuse the same C++ object
m_hEventHandle = ::CreateEvent(NULL,TRUE /*bManualReset*/,FALSE /*signalled*/, NULL);
if (m_hEventHandle == NULL)
return FALSE;
return CreateThread();
}
int CBackgroundThread::Run()
{
ASSERT(m_pContNode != NULL);
ASSERT(m_pQueryObj != NULL);
TRACE(_T("CBackgroundThread::Run() started\n"));
while (m_pQueryObj->Enumerate());
// before exiting, have to make sure there are no items in the queue
if (!IsQueueEmpty())
VERIFY(PostHaveData());
VERIFY(PostExiting());
// wait for the main thread to acknowledge the exiting message
WaitForExitAcknowledge();
ASSERT(IsAbandoned() || IsQueueEmpty()); // we cannot lose items in the queue
TRACE(_T("CBackgroundThread::Run() terminated\n"));
return 0;
}
void CBackgroundThread::Abandon()
{
Lock();
TRACE(_T("CBackgroundThread::Abandon()\n"));
m_bAutoDelete = TRUE;
m_bAbandoned = TRUE;
Unlock();
VERIFY(0 != ::SetEvent(m_hEventHandle));
}
BOOL CBackgroundThread::IsAbandoned()
{
Lock();
BOOL b = m_bAbandoned;
Unlock();
return b;
}
BOOL CBackgroundThread::OnAddToQueue(INT_PTR nCount)
{
BOOL bPostedMessage = FALSE;
if (nCount >= m_nQueueCountMax)
{
VERIFY(PostHaveData());
bPostedMessage = TRUE;
}
return bPostedMessage;
}
CObjBase* CBackgroundThread::RemoveFromQueue()
{
Lock();
ASSERT(m_pQueryObj != NULL);
CObjBaseList* pQueue = m_pQueryObj->GetQueue();
CObjBase* p = pQueue->IsEmpty() ? NULL : pQueue->RemoveHead();
Unlock();
return p;
}
BOOL CBackgroundThread::IsQueueEmpty()
{
Lock();
ASSERT(m_pQueryObj != NULL);
CObjBaseList* pQueue = m_pQueryObj->GetQueue();
BOOL bRes = pQueue->IsEmpty();
Unlock();
return bRes;
}
BOOL CBackgroundThread::PostHaveData()
{
return PostMessageToComponentDataRaw(CHiddenWnd::s_NodeThreadHaveDataNotificationMessage,
(WPARAM)m_pContNode, (LPARAM)0);
}
BOOL CBackgroundThread::PostError(DWORD dwErr)
{
return PostMessageToComponentDataRaw(CHiddenWnd::s_NodeThreadErrorNotificationMessage,
(WPARAM)m_pContNode, (LPARAM)dwErr);
}
BOOL CBackgroundThread::PostExiting()
{
return PostMessageToComponentDataRaw(CHiddenWnd::s_NodeThreadExitingNotificationMessage,
(WPARAM)m_pContNode, (LPARAM)0);
}
BOOL CBackgroundThread::PostMessageToComponentDataRaw(UINT Msg, WPARAM wParam, LPARAM lParam)
{
BOOL b = IsAbandoned();
if (b)
{
return TRUE; // no need to post
}
ASSERT(m_pContNode != NULL);
ASSERT(m_hHiddenWnd != NULL);
ASSERT(::IsWindow(m_hHiddenWnd));
return ::PostMessage(m_hHiddenWnd, Msg, wParam, lParam);
}
void CBackgroundThread::WaitForExitAcknowledge()
{
VERIFY(WAIT_OBJECT_0 == ::WaitForSingleObject(m_hEventHandle,INFINITE));
}
////////////////////////////////////////////////////////////////////////
// CMTContainerNode
CMTContainerNode::~CMTContainerNode()
{
ASSERT(m_pThread == NULL);
}
BOOL CMTContainerNode::OnEnumerate(CComponentDataObject* pComponentData, BOOL bAsync)
{
OnChangeState(pComponentData);
VERIFY(StartBackgroundThread(pComponentData, bAsync));
return FALSE; // children not added, the thread will add them later
}
BOOL CMTContainerNode::OnRefresh(CComponentDataObject* pComponentData,
CNodeList* pNodeList)
{
BOOL bRet = TRUE;
if (pNodeList->GetCount() == 1) // single selection
{
BOOL bLocked = IsThreadLocked();
ASSERT(!bLocked); // cannot do refresh on locked node, the UI should prevent this
if (bLocked)
return FALSE;
if (IsSheetLocked())
{
if (!CanCloseSheets())
{
pComponentData->GetPropertyPageHolderTable()->BroadcastSelectPage(this, -1);
return FALSE;
}
pComponentData->GetPropertyPageHolderTable()->DeleteSheetsOfNode(this);
}
ASSERT(!IsSheetLocked());
RemoveAllChildrenHelper(pComponentData);
ASSERT(!HasChildren());
OnEnumerate(pComponentData); // will spawn a thread to do enumeration
MarkEnumerated();
}
else // multiple selection
{
POSITION pos = pNodeList->GetHeadPosition();
while (pos != NULL)
{
CTreeNode* pNode = pNodeList->GetNext(pos);
ASSERT(pNode != NULL);
CNodeList nodeList;
nodeList.AddTail(pNode);
if (!pNode->OnRefresh(pComponentData, &nodeList))
{
bRet = FALSE;
}
}
}
return TRUE;
}
void CMTContainerNode::AbandonThread(CComponentDataObject* pComponentData)
{
if(m_pThread == NULL) // nothing running
return;
m_pThread->Abandon();
m_pThread = NULL;
pComponentData->GetRunningThreadTable()->Remove(this);
}
BOOL CMTContainerNode::StartBackgroundThread(CComponentDataObject* pComponentData, BOOL bAsync)
{
ASSERT(m_pThread == NULL); // nothing running
// notify the UI to change icon, if needed
VERIFY(SUCCEEDED(pComponentData->ChangeNode(this, CHANGE_RESULT_ITEM_ICON)));
m_pThread = CreateThreadObject();
ASSERT(m_pThread != NULL);
m_pThread->SetQueryObj(OnCreateQuery());
BOOL bRes = m_pThread->Start(this, pComponentData);
if (bRes)
{
pComponentData->GetRunningThreadTable()->Add(this);
// we need to call UpdateVerbState() because the lock count changed
// by adding the node from the running thread table
VERIFY(SUCCEEDED(pComponentData->UpdateVerbState(this)));
}
//
// If we don't want this call to be asynchronous then we have to wait for
// the thread to finish
//
if (!bAsync)
{
pComponentData->WaitForThreadExitMessage(this);
}
return bRes;
}
void CMTContainerNode::OnThreadHaveDataNotification(CComponentDataObject* pComponentDataObject)
{
ASSERT(m_pThread != NULL);
ASSERT(IsThreadLocked());
// do data transfer from thread queue
CObjBase* p = m_pThread->RemoveFromQueue();
while (p)
{
// add new node to the list of children and propagate to the UI
OnHaveData(p,pComponentDataObject);
p = m_pThread->RemoveFromQueue();
}
}
void CMTContainerNode::OnThreadErrorNotification(DWORD dwErr, CComponentDataObject*)
{
ASSERT(m_pThread != NULL);
ASSERT(IsThreadLocked());
OnError(dwErr);
}
void CMTContainerNode::OnThreadExitingNotification(CComponentDataObject* pComponentDataObject)
{
ASSERT(m_pThread != NULL);
ASSERT(IsThreadLocked());
#if (TRUE)
// let the thread know it can shut down
m_pThread->AcknowledgeExiting();
VERIFY(WAIT_OBJECT_0 == ::WaitForSingleObject(m_pThread->m_hThread,INFINITE));
OnChangeState(pComponentDataObject);
delete m_pThread;
m_pThread = NULL;
pComponentDataObject->GetRunningThreadTable()->Remove(this);
// we need to call UpdateVerbState() because the lock count changed
// by removing the node from the running thread table
VERIFY(SUCCEEDED(pComponentDataObject->UpdateVerbState(this)));
TRACE(_T("OnThreadExitingNotification()\n"));
#else // maybe better way of doing it???
// we are going to detach from the thread, so make copies of variables
HANDLE hThread = m_pThread->m_hThread;
CBackgroundThread* pThread = m_pThread;
AbandonThread(pComponentDataObject); // sets m_pThread = NULL
// acknowledge to thread
pThread->AcknowledgeExiting();
VERIFY(WAIT_OBJECT_0 == ::WaitForSingleObject(hThread,INFINITE));
OnChangeState(pComponentDataObject);
#endif
VERIFY(SUCCEEDED(pComponentDataObject->SortResultPane(this)));
}
///////////////////////////////////////////////////////////////////////////////
Reference in a new issue Copy permalink