windows-server-2003/admin/snapin/mtfrmwk/treedat_.cpp

//+-------------------------------------------------------------------------
//
//  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++)
    {
      // szBuffer is defined statically as part of the MENUDATARES structure with size of MAX_CONTEXT_MENU_STRLEN*2
        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++)
    {
      // szBuffer is defined statically as part of the RESULT_HEADERMAP structure with size of MAX_RESULT_HEADER_STRLEN
        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;
              
           // REVIEWED-2002/03/08-JeffJon-This is an acceptable usage

           ::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);
}

////////////////////////////////////////////////////////////////////////
// CNodeList

INT_PTR CNodeList::GetVisibleCount()
{
   INT_PTR result = 0;

   POSITION pos = GetHeadPosition();
   while (pos)
   {
      CTreeNode* pNode = GetNext(pos);
      if (pNode &&
          pNode->IsVisible())
      {
         ++result;
      }
   }

   return result;
}

////////////////////////////////////////////////////////////////////////
// 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);
    // NOTICE-2002/04/22-artm : using _wcsicoll() here is okay since GetDisplayName() never
    // returns NULL (underlying implementation is a CString object).
    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();

   // REVIEWED-2002/03/08-JeffJon-Squatting isn't an issue here because this is not a
   // named event

   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"));

    // NTRAID#NTBUG9-662019-2002/07/17-artm
    try
    {
        while (m_pQueryObj->Enumerate());

        // before exiting, have to make sure there are no items in the queue
        if (!IsQueueEmpty())
            VERIFY(PostHaveData());
    }
    catch (CMemoryException *exc)
    {
        // Tell the user about the error.
        exc->ReportError();
        exc->Delete();

        PostError(ERROR_OUTOFMEMORY);

        exit(-1);
    }

    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)));
}




///////////////////////////////////////////////////////////////////////////////