1755 lines
42 KiB
C++
1755 lines
42 KiB
C++
// ScopePaneItem.cpp : implementation file
|
|
//
|
|
// Copyright (c) 2000 Microsoft Corporation
|
|
//
|
|
// 03/29/00 v-marfin 62478 : Set help topic based on type of object
|
|
// 03/30/00 v-marfin 59644 : Modified prototype of InvokeContextMenu
|
|
// to allow passing to selected item count. Only allow
|
|
// third party menu item (for Troubleshooting) if only 1
|
|
// item is selected.
|
|
// 04/02/00 v-marfin 59643b On creation of new items, show details page first.
|
|
// 04/05/00 v-marfin 62962 Show "details" page on a new creation unless it is
|
|
// a new data group in which case show General first.
|
|
//
|
|
#include "stdafx.h"
|
|
#include "snapin.h"
|
|
#include "ScopePaneItem.h"
|
|
#include "ScopePane.h"
|
|
|
|
#include "RootScopeItem.h"
|
|
#include "AllSystemsScopeItem.h"
|
|
#include "SystemScopeItem.h"
|
|
#include "ActionPolicyScopeItem.h"
|
|
#include "DataGroupScopeItem.h"
|
|
#include "DataElementScopeItem.h"
|
|
#include "RuleScopeItem.h"
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CScopePaneItem
|
|
|
|
IMPLEMENT_DYNCREATE(CScopePaneItem, CCmdTarget)
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Construction/Destruction
|
|
|
|
CScopePaneItem::CScopePaneItem()
|
|
{
|
|
EnableAutomation();
|
|
|
|
m_pScopePane = NULL;
|
|
m_pParent = NULL;
|
|
m_pResultsPaneView = NULL;
|
|
m_hItemHandle = NULL;
|
|
m_lpguidItemType = NULL;
|
|
m_iCurrentIconIndex = -1;
|
|
m_iCurrentOpenIconIndex = -1;
|
|
m_bVisible = true;
|
|
|
|
// To keep the application running as long as an OLE automation
|
|
// object is active, the constructor calls AfxOleLockApp.
|
|
|
|
AfxOleLockApp();
|
|
}
|
|
|
|
CScopePaneItem::~CScopePaneItem()
|
|
{
|
|
Destroy();
|
|
|
|
// To terminate the application when all objects created with
|
|
// with OLE automation, the destructor calls AfxOleUnlockApp.
|
|
|
|
AfxOleUnlockApp();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Create/Destroy
|
|
bool CScopePaneItem::Create(CScopePane* pScopePane, CScopePaneItem* pParentItem)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::Create\n"));
|
|
TRACEARGn(pScopePane);
|
|
TRACEARGn(pParentItem);
|
|
|
|
if( ! GfxCheckObjPtr(pScopePane,CScopePane) )
|
|
{
|
|
TRACE(_T("FAILED : pScopePane is not a valid pointer.\n"));
|
|
return false;
|
|
}
|
|
|
|
if( pParentItem == NULL )
|
|
{
|
|
TRACE(_T("WARNING : pParentItem is a NULL pointer. This is acceptable for the root node only.\n"));
|
|
}
|
|
else if( ! GfxCheckObjPtr(pParentItem,CScopePaneItem) )
|
|
{
|
|
TRACE(_T("FAILED : pParentItem is not a valid pointer.\n"));
|
|
return false;
|
|
}
|
|
|
|
SetScopePane(pScopePane);
|
|
|
|
SetParent(pParentItem);
|
|
|
|
// create the results view
|
|
m_pResultsPaneView = CreateResultsPaneView();
|
|
|
|
if( ! GfxCheckObjPtr(m_pResultsPaneView,CResultsPaneView) )
|
|
{
|
|
TRACE(_T("FAILED : CResultsPaneView::CreateResultsPane returned an invalid pointer.\n"));
|
|
return false;
|
|
}
|
|
|
|
if( ! m_pResultsPaneView->Create(this) )
|
|
{
|
|
TRACE(_T("FAILED : CResultsPaneView::Create failed.\n"));
|
|
return false;
|
|
}
|
|
|
|
m_bVisible = true;
|
|
|
|
return true;
|
|
}
|
|
|
|
void CScopePaneItem::Destroy()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::Destroy\n"));
|
|
|
|
if( m_pScopePane == NULL && m_Children.GetSize() == 0 && m_pResultsPaneView == NULL )
|
|
{
|
|
TRACE(_T("INFO : Destroy has already been called for this item.\n"));
|
|
return;
|
|
}
|
|
|
|
// remove all children from our data structure
|
|
for( int i=0; i < m_Children.GetSize(); i++ )
|
|
{
|
|
m_Children[i]->Destroy();
|
|
delete m_Children[i];
|
|
}
|
|
|
|
m_Children.RemoveAll();
|
|
|
|
DeleteItem();
|
|
|
|
if( m_pResultsPaneView )
|
|
{
|
|
delete m_pResultsPaneView;
|
|
m_pResultsPaneView = NULL;
|
|
}
|
|
|
|
m_pScopePane = NULL;
|
|
m_pParent = NULL;
|
|
m_hItemHandle = NULL;
|
|
m_lpguidItemType = NULL;
|
|
m_iCurrentIconIndex = -1;
|
|
m_iCurrentOpenIconIndex = -1;
|
|
m_saDisplayNames.RemoveAll();
|
|
m_IconResIds.RemoveAll();
|
|
m_OpenIconResIds.RemoveAll();
|
|
m_sHelpTopic.Empty();
|
|
m_bVisible = true;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Scope Pane Members
|
|
|
|
|
|
// v-marfin 59237 :
|
|
// Within this data elements scope, return a unique name if the current name is already used
|
|
CString CScopePaneItem::GetUniqueDisplayName(CString sProposedName)
|
|
{
|
|
int nSize = GetChildCount();
|
|
|
|
// if no entries, use proposed
|
|
if (nSize < 1)
|
|
{
|
|
return sProposedName;
|
|
}
|
|
|
|
CString sName = sProposedName;
|
|
CString sCompare;
|
|
int nSuffix=0;
|
|
|
|
BOOL bContinue=TRUE;
|
|
while (bContinue)
|
|
{
|
|
BOOL bNameAlreadyInUse=FALSE;
|
|
|
|
// scan existing display names
|
|
for (int x=0; x<nSize; x++)
|
|
{
|
|
// Is name already in use?
|
|
CScopePaneItem* pItem = GetChild(x);
|
|
if (!pItem)
|
|
continue;
|
|
|
|
sCompare = pItem->GetDisplayName();
|
|
if (sCompare.CompareNoCase(sName)==0)
|
|
{
|
|
sName.Format(_T("%s %d"),sProposedName,nSuffix++);
|
|
bNameAlreadyInUse=TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (bNameAlreadyInUse)
|
|
continue;
|
|
else
|
|
break;
|
|
}
|
|
|
|
return sName;
|
|
}
|
|
|
|
|
|
CScopePane* CScopePaneItem::GetScopePane() const
|
|
{
|
|
TRACEX(_T("CScopePaneItem::GetScopePane\n"));
|
|
|
|
if( ! GfxCheckObjPtr(m_pScopePane,CScopePane) )
|
|
{
|
|
TRACE(_T("FAILED : m_pScopePane is not a valid pointer.\n"));
|
|
return NULL;
|
|
}
|
|
|
|
return m_pScopePane;
|
|
}
|
|
|
|
void CScopePaneItem::SetScopePane(CScopePane* pScopePane)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::SetScopePane\n"));
|
|
TRACEARGn(pScopePane);
|
|
|
|
if( ! GfxCheckObjPtr(pScopePane,CScopePane) )
|
|
{
|
|
TRACE(_T("FAILED : pScopePane is not a valid pointer.\n"));
|
|
return;
|
|
}
|
|
|
|
m_pScopePane = pScopePane;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Parent Scope Item Members
|
|
|
|
CScopePaneItem* CScopePaneItem::GetParent() const
|
|
{
|
|
TRACEX(_T("CScopePaneItem::GetParent\n"));
|
|
|
|
if( !m_pParent || ! GfxCheckObjPtr(m_pParent,CScopePaneItem) )
|
|
{
|
|
TRACE(_T("WARNING : m_pParent is not a valid pointer.\n"));
|
|
return NULL;
|
|
}
|
|
|
|
return m_pParent;
|
|
}
|
|
|
|
void CScopePaneItem::SetParent(CScopePaneItem* pParentItem)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::SetParent\n"));
|
|
TRACEARGn(pParentItem);
|
|
|
|
if( pParentItem == NULL )
|
|
{
|
|
TRACE(_T("WARNING : pParentItem is NULL. This should only happen for the root node, which has no parent.\n"));
|
|
}
|
|
else if( ! GfxCheckObjPtr(pParentItem,CScopePaneItem) )
|
|
{
|
|
TRACE(_T("FAILED : pParentItem is not a valid pointer.\n"));
|
|
m_pParent = NULL;
|
|
return;
|
|
}
|
|
|
|
m_pParent = pParentItem;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Child Scope Item Members
|
|
|
|
int CScopePaneItem::GetChildCount() const
|
|
{
|
|
TRACEX(_T("CScopePaneItem::GetChildCount\n"));
|
|
|
|
return (int)m_Children.GetSize();
|
|
}
|
|
|
|
CScopePaneItem* CScopePaneItem::GetChild(int iIndex)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::GetChild\n"));
|
|
TRACEARGn(iIndex);
|
|
|
|
if( iIndex >= m_Children.GetSize() || iIndex < 0 )
|
|
{
|
|
TRACE(_T("FAILED : iIndex is out of array bounds.\n"));
|
|
return NULL;
|
|
}
|
|
|
|
return m_Children[iIndex];
|
|
}
|
|
|
|
int CScopePaneItem::AddChild(CScopePaneItem* pChildItem)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::AddChild\n"));
|
|
TRACEARGn(pChildItem);
|
|
|
|
if( ! GfxCheckObjPtr(pChildItem,CScopePaneItem) )
|
|
{
|
|
TRACE(_T("FAILED : pChildItem is not a valid pointer.\n"));
|
|
return -1;
|
|
}
|
|
|
|
for( int i = 0; i < m_Children.GetSize(); i++ )
|
|
{
|
|
if( pChildItem->GetDisplayName().CompareNoCase(m_Children[i]->GetDisplayName()) < 0 )
|
|
{
|
|
m_Children.InsertAt(i,pChildItem);
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return (int)m_Children.Add(pChildItem);
|
|
}
|
|
|
|
void CScopePaneItem::RemoveChild(int iIndex)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::RemoveChild\n"));
|
|
TRACEARGn(iIndex);
|
|
|
|
if( iIndex >= m_Children.GetSize() || iIndex < 0 )
|
|
{
|
|
TRACE(_T("FAILED : iIndex is out of array bounds.\n"));
|
|
return;
|
|
}
|
|
|
|
m_Children.RemoveAt(iIndex);
|
|
}
|
|
|
|
void CScopePaneItem::RemoveChild(CScopePaneItem* pChildItem)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::RemoveChild\n"));
|
|
TRACEARGn(pChildItem);
|
|
|
|
if( ! GfxCheckObjPtr(pChildItem,CScopePaneItem) )
|
|
{
|
|
TRACE(_T("FAILED : pChildItem is not a valid pointer.\n"));
|
|
return;
|
|
}
|
|
|
|
for( int i = 0; i < m_Children.GetSize(); i++ )
|
|
{
|
|
if( m_Children[i] == pChildItem )
|
|
{
|
|
RemoveChild(i);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CScopePaneItem::DestroyChild(CScopePaneItem* pChild)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::DestroyChild\n"));
|
|
TRACEARGn(pChild);
|
|
|
|
if( ! GfxCheckObjPtr(pChild,CScopePaneItem) )
|
|
{
|
|
TRACE(_T("FAILED : pChild is not a valid pointer.\n"));
|
|
return;
|
|
}
|
|
|
|
for( int i = 0; i < m_Children.GetSize(); i++ )
|
|
{
|
|
if( m_Children[i] == pChild )
|
|
{
|
|
RemoveChild(i);
|
|
delete pChild;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
int CScopePaneItem::FindChild(SPIFINDPROC pFindProc, LPARAM param)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::FindChild\n"));
|
|
TRACEARGn(pFindProc);
|
|
|
|
if( ! GfxCheckPtr(pFindProc,SPIFINPROC) )
|
|
{
|
|
TRACE(_T("FAILED : pFindProc is not a valid function pointer.\n"));
|
|
return -1;
|
|
}
|
|
|
|
return pFindProc(m_Children,param);
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Results Pane View Members
|
|
|
|
CResultsPaneView* CScopePaneItem::CreateResultsPaneView()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::CreateResultsPaneView\n"));
|
|
|
|
return new CResultsPaneView;
|
|
}
|
|
|
|
CResultsPaneView* CScopePaneItem::GetResultsPaneView()const
|
|
{
|
|
TRACEX(_T("CScopePaneItem::GetResultsPaneView\n"));
|
|
|
|
if( ! GfxCheckObjPtr(m_pResultsPaneView,CResultsPaneView) )
|
|
{
|
|
TRACE(_T("FAILED : m_pResultsPaneView is not a valid pointer.\n"));
|
|
return NULL;
|
|
}
|
|
|
|
return m_pResultsPaneView;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// MMC-Related Item Members
|
|
|
|
bool CScopePaneItem::InsertItem( int iIndex )
|
|
{
|
|
TRACEX(_T("CScopePaneItem::InsertItem\n"));
|
|
|
|
if( ! GetScopePane() )
|
|
{
|
|
TRACE(_T("FAILED : m_pScopePane is not a valid pointer.\n"));
|
|
return false;
|
|
}
|
|
|
|
if( ! GetParent() )
|
|
{
|
|
TRACE(_T("WARNING : m_pParent is not a valid pointer. This could be the root item.\n"));
|
|
return false;
|
|
}
|
|
|
|
if( m_pParent->GetItemHandle() == NULL )
|
|
{
|
|
TRACE(_T("FAILED : Parent's item handle is NULL!\n"));
|
|
return false;
|
|
}
|
|
|
|
if( GetItemHandle() != NULL )
|
|
{
|
|
TRACE(_T("WARNING : Item already inserted.\n"));
|
|
return false;
|
|
}
|
|
|
|
SCOPEDATAITEM sdi;
|
|
|
|
ZeroMemory(&sdi,sizeof(sdi));
|
|
|
|
if( iIndex > 0 )
|
|
{
|
|
CScopePaneItem* pSiblingItem = m_pParent->GetChild(iIndex-1);
|
|
sdi.mask = SDI_STR |
|
|
SDI_PARAM |
|
|
SDI_IMAGE |
|
|
SDI_OPENIMAGE |
|
|
SDI_PREVIOUS;
|
|
sdi.relativeID = pSiblingItem->GetItemHandle();
|
|
}
|
|
else
|
|
{
|
|
sdi.mask = SDI_STR |
|
|
SDI_PARAM |
|
|
SDI_IMAGE |
|
|
SDI_OPENIMAGE |
|
|
SDI_PARENT;
|
|
sdi.relativeID = m_pParent->GetItemHandle();
|
|
}
|
|
|
|
sdi.nImage = m_pScopePane->AddIcon(GetIconId());
|
|
sdi.nOpenImage = m_pScopePane->AddIcon(GetOpenIconId());
|
|
sdi.displayname = MMC_CALLBACK;
|
|
sdi.lParam = (LPARAM)this; // The cookie is the this pointer
|
|
|
|
LPCONSOLENAMESPACE2 lpNamespace = m_pScopePane->GetConsoleNamespacePtr();
|
|
|
|
if( ! GfxCheckPtr(lpNamespace,IConsoleNameSpace2) )
|
|
{
|
|
TRACE(_T("FAILED : lpNamespace is not a valid pointer.\n"));
|
|
return false;
|
|
}
|
|
|
|
HRESULT hr = lpNamespace->InsertItem( &sdi );
|
|
|
|
if( hr != S_OK )
|
|
{
|
|
TRACE(_T("FAILED : IConsoleNameSpace2::InsertItem failed.\n"));
|
|
TRACE(_T("FAILED : HRESULT=%X\n"),hr);
|
|
}
|
|
|
|
// save off the ID
|
|
m_hItemHandle = sdi.ID;
|
|
|
|
lpNamespace->Release();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CScopePaneItem::DeleteItem()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::DeleteItem\n"));
|
|
|
|
// this function deletes the item and all its children from the mmc namespace ONLY
|
|
|
|
// call Destroy to completely remove this item from MMC and the framework
|
|
|
|
if( ! GetScopePane() )
|
|
{
|
|
TRACE(_T("FAILED : m_pScopePane is not a valid pointer.\n"));
|
|
return false;
|
|
}
|
|
|
|
if( ! GetItemHandle() )
|
|
{
|
|
TRACE(_T("FAILED : GetItemHandle returns NULL.\n"));
|
|
return false;
|
|
}
|
|
|
|
if( IsPropertySheetOpen() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
LPCONSOLENAMESPACE2 lpConsoleNamespace = m_pScopePane->GetConsoleNamespacePtr();
|
|
|
|
if( ! GfxCheckPtr(lpConsoleNamespace,IConsoleNamespace2) )
|
|
{
|
|
TRACE(_T("WARNING : lpConsoleNamespace is not a valid pointer.\n"));
|
|
return false;
|
|
}
|
|
|
|
lpConsoleNamespace->DeleteItem(GetItemHandle(),TRUE);
|
|
lpConsoleNamespace->Release();
|
|
m_hItemHandle = NULL;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CScopePaneItem::SetItem()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::SetItem\n"));
|
|
|
|
if( GetItemHandle() == NULL )
|
|
{
|
|
TRACE(_T("FAILED : Item handle is NULL!\n"));
|
|
return false;
|
|
}
|
|
|
|
if( GetScopePane() == NULL )
|
|
{
|
|
TRACE(_T("FAILED : m_pScopePane is not a valid pointer.\n"));
|
|
return false;
|
|
}
|
|
|
|
LPCONSOLENAMESPACE2 lpNamespace = m_pScopePane->GetConsoleNamespacePtr();
|
|
|
|
if( ! GfxCheckPtr(lpNamespace,IConsoleNameSpace2) )
|
|
{
|
|
TRACE(_T("FAILED : lpNamespace is not a valid pointer.\n"));
|
|
return false;
|
|
}
|
|
|
|
SCOPEDATAITEM sdi;
|
|
ZeroMemory(&sdi,sizeof(sdi));
|
|
|
|
sdi.mask = SDI_PARAM | // lParam is valid
|
|
SDI_IMAGE | // nImage is valid
|
|
SDI_OPENIMAGE; // nOpenImage is valid
|
|
sdi.nImage = m_pScopePane->GetIconIndex(GetIconId());
|
|
sdi.nOpenImage = m_pScopePane->GetIconIndex(GetOpenIconId());
|
|
sdi.lParam = (LPARAM)this; // The cookie is the this pointer
|
|
sdi.ID = GetItemHandle();
|
|
|
|
HRESULT hr = lpNamespace->SetItem( &sdi );
|
|
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
TRACE(_T("FAILED : IConsoleNameSpace2::SetItem failed.\n"));
|
|
lpNamespace->Release();
|
|
return false;
|
|
}
|
|
|
|
lpNamespace->Release();
|
|
|
|
return true;
|
|
}
|
|
|
|
void CScopePaneItem::SelectItem()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::SelectItem\n"));
|
|
|
|
CScopePane* pPane = GetScopePane();
|
|
LPCONSOLE2 lpConsole = pPane->GetConsolePtr();
|
|
lpConsole->SelectScopeItem(GetItemHandle());
|
|
lpConsole->Release();
|
|
}
|
|
|
|
void CScopePaneItem::ExpandItem(BOOL bExpand /* = TRUE*/)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::ExpandItem\n"));
|
|
|
|
CScopePane* pPane = GetScopePane();
|
|
for( int i = 0; i < pPane->GetResultsPaneCount(); i++ )
|
|
{
|
|
LPCONSOLE2 lpConsole = pPane->GetResultsPane(i)->GetConsolePtr();
|
|
HRESULT hr = lpConsole->Expand(GetItemHandle(),bExpand);
|
|
CHECKHRESULT(hr);
|
|
lpConsole->Release();
|
|
}
|
|
}
|
|
|
|
void CScopePaneItem::SortItems()
|
|
{
|
|
if( m_Children.GetSize() == 1 )
|
|
return;
|
|
|
|
bool bSorted = false;
|
|
|
|
bool bDirty = false;
|
|
while( !bSorted )
|
|
{
|
|
bSorted = true;
|
|
for( int i = 0; i < m_Children.GetSize()-1; i++ )
|
|
{
|
|
CScopePaneItem* pItem1 = m_Children[i];
|
|
CScopePaneItem* pItem2 = m_Children[i+1];
|
|
TRACE(_T("%s > %s\n"),pItem1->GetDisplayName(),pItem2->GetDisplayName());
|
|
if( pItem1->GetDisplayName().CompareNoCase(pItem2->GetDisplayName()) > 0 )
|
|
{
|
|
TRACE(_T("Swapping %s with %s.\n"),pItem1->GetDisplayName(),pItem2->GetDisplayName());
|
|
m_Children.SetAt(i,pItem2);
|
|
m_Children.SetAt(i+1,pItem1);
|
|
bSorted = false;
|
|
bDirty = true;
|
|
}
|
|
}
|
|
}
|
|
/*
|
|
if( bDirty )
|
|
{
|
|
LPCONSOLENAMESPACE2 lpNamespace = GetScopePane()->GetConsoleNamespacePtr();
|
|
for( int i = 0; i < m_Children.GetSize(); i++ )
|
|
{
|
|
lpNamespace->DeleteItem(m_Children[i]->GetItemHandle(),1L);
|
|
m_Children[i]->InsertItem(i);
|
|
}
|
|
lpNamespace->Release();
|
|
}
|
|
*/
|
|
}
|
|
|
|
void CScopePaneItem::ShowItem()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::ShowItem\n"));
|
|
|
|
if( m_bVisible )
|
|
{
|
|
TRACE(_T("WARNING : Item is already visible.\n"));
|
|
return;
|
|
}
|
|
|
|
if( ! InsertItem(0) )
|
|
{
|
|
TRACE(_T("FAILED : InsertItem failed.\n"));
|
|
return;
|
|
}
|
|
|
|
m_bVisible = true;
|
|
}
|
|
|
|
void CScopePaneItem::HideItem()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::HideItem\n"));
|
|
|
|
if( !m_bVisible )
|
|
{
|
|
TRACE(_T("WARNING : Item is already hidden.\n"));
|
|
return;
|
|
}
|
|
|
|
if( ! DeleteItem() )
|
|
{
|
|
TRACE(_T("FAILED : DeleteItem failed.\n"));
|
|
}
|
|
|
|
m_bVisible = false;
|
|
}
|
|
|
|
bool CScopePaneItem::IsItemVisible() const
|
|
{
|
|
TRACEX(_T("CScopePaneItem::IsItemVisible\n"));
|
|
|
|
return m_bVisible;
|
|
}
|
|
|
|
HSCOPEITEM CScopePaneItem::GetItemHandle()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::GetItemHandle\n"));
|
|
|
|
return m_hItemHandle;
|
|
}
|
|
|
|
void CScopePaneItem::SetItemHandle(HSCOPEITEM hItem)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::SetItemHandle\n"));
|
|
TRACEARGn(hItem);
|
|
|
|
m_hItemHandle = hItem;
|
|
}
|
|
|
|
LPGUID CScopePaneItem::GetItemType()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::GetItemType\n"));
|
|
|
|
if( ! GfxCheckPtr(m_lpguidItemType,GUID) )
|
|
{
|
|
TRACE(_T("FAILED : m_lpguidItemType is an invalid pointer.\n"));
|
|
return NULL;
|
|
}
|
|
|
|
return m_lpguidItemType;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::WriteExtensionData(LPSTREAM pStream)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::WriteExtensionData\n"));
|
|
TRACEARGn(pStream);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Display Name Members
|
|
|
|
CString CScopePaneItem::GetDisplayName(int nIndex /*= 0*/)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::GetDisplayName\n"));
|
|
TRACEARGn(nIndex);
|
|
|
|
if( nIndex >= m_saDisplayNames.GetSize() || nIndex < 0 )
|
|
{
|
|
TRACE(_T("FAILED : nIndex is out of array bounds.\n"));
|
|
return _T("");
|
|
}
|
|
|
|
return m_saDisplayNames[nIndex];
|
|
}
|
|
|
|
CStringArray& CScopePaneItem::GetDisplayNames()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::GetDisplayNames\n"));
|
|
|
|
return m_saDisplayNames;
|
|
}
|
|
|
|
void CScopePaneItem::SetDisplayName(int nIndex, const CString& sName)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::SetDisplayName\n"));
|
|
TRACEARGn(nIndex);
|
|
|
|
if( nIndex >= m_saDisplayNames.GetSize() || nIndex < 0 )
|
|
{
|
|
TRACE(_T("WARNING : nIndex is out of array bounds. The string will be added to Display Names.\n"));
|
|
m_saDisplayNames.InsertAt(nIndex,sName);
|
|
return;
|
|
}
|
|
|
|
m_saDisplayNames.SetAt(nIndex,sName);
|
|
|
|
}
|
|
|
|
void CScopePaneItem::SetDisplayNames(const CStringArray& saNames)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::SetDisplayNames\n"));
|
|
TRACEARGn(saNames.GetSize());
|
|
|
|
m_saDisplayNames.Copy(saNames);
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Icon Members
|
|
|
|
void CScopePaneItem::SetIconIndex(int iIndex)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::SetIconIndex\n"));
|
|
TRACEARGn(iIndex);
|
|
|
|
if( iIndex >= m_IconResIds.GetSize() || iIndex < 0 )
|
|
{
|
|
TRACE(_T("FAILED : iIndex is out of array bounds.\n"));
|
|
return;
|
|
}
|
|
|
|
m_iCurrentIconIndex = iIndex;
|
|
}
|
|
|
|
int CScopePaneItem::GetIconIndex()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::GetIconIndex\n"));
|
|
|
|
if( m_iCurrentIconIndex >= m_IconResIds.GetSize() || m_iCurrentIconIndex < 0 )
|
|
{
|
|
TRACE(_T("WARNING : m_iCurrentIconIndex is out of array bounds.\n"));
|
|
return -1;
|
|
}
|
|
|
|
return m_iCurrentIconIndex;
|
|
|
|
}
|
|
|
|
UINT CScopePaneItem::GetIconId()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::GetIconId\n"));
|
|
|
|
if( GetIconIndex() == -1 )
|
|
{
|
|
TRACE(_T("FAILED : m_iCurrentIconIndex is out of array bounds.\n"));
|
|
return 0;
|
|
}
|
|
|
|
return m_IconResIds[GetIconIndex()];
|
|
}
|
|
|
|
CUIntArray& CScopePaneItem::GetIconIds()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::GetIconId\n"));
|
|
|
|
return m_IconResIds;
|
|
}
|
|
|
|
void CScopePaneItem::SetOpenIconIndex(int iIndex)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::SetOpenIconIndex\n"));
|
|
TRACEARGn(iIndex);
|
|
|
|
if( iIndex >= m_OpenIconResIds.GetSize() || iIndex < 0 )
|
|
{
|
|
TRACE(_T("FAILED : iIndex is out of array bounds.\n"));
|
|
return;
|
|
}
|
|
|
|
m_iCurrentOpenIconIndex = iIndex;
|
|
}
|
|
|
|
int CScopePaneItem::GetOpenIconIndex()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::GetOpenIconIndex\n"));
|
|
|
|
if( m_iCurrentOpenIconIndex >= m_OpenIconResIds.GetSize() || m_iCurrentOpenIconIndex < 0 )
|
|
{
|
|
TRACE(_T("WARNING : m_iCurrentOpenIconIndex is out of array bounds.\n"));
|
|
return -1;
|
|
}
|
|
|
|
return m_iCurrentOpenIconIndex;
|
|
}
|
|
|
|
UINT CScopePaneItem::GetOpenIconId()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::GetOpenIconId\n"));
|
|
|
|
if( GetOpenIconIndex() == -1 )
|
|
{
|
|
TRACE(_T("FAILED : m_iCurrentOpenIconIndex is out of array bounds.\n"));
|
|
return 0;
|
|
}
|
|
|
|
return m_OpenIconResIds[GetOpenIconIndex()];
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Property Sheet Members
|
|
|
|
bool CScopePaneItem::IsPropertySheetOpen(bool bSearchChildren /*=false*/)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::IsPropertySheetOpen\n"));
|
|
|
|
// this function attempts to bring up an open property sheet for this scope item
|
|
// if it succeeds, then the property sheet is brought to the foreground
|
|
// if it fails, then there are no open property sheets for the scope item
|
|
|
|
if( ! GetScopePane() )
|
|
{
|
|
TRACE(_T("FAILED : m_pScopePane is not a valid pointer.\n"));
|
|
return false;
|
|
}
|
|
|
|
LPCONSOLE2 lpConsole = m_pScopePane->GetConsolePtr();
|
|
|
|
if( ! GfxCheckPtr(lpConsole,IConsole2) )
|
|
{
|
|
TRACE(_T("FAILED : lpConsole is not a valid pointer.\n"));
|
|
return false;
|
|
}
|
|
|
|
// get a reference to the IPropertySheetProvider interface
|
|
LPPROPERTYSHEETPROVIDER lpProvider = NULL;
|
|
|
|
HRESULT hr = lpConsole->QueryInterface(IID_IPropertySheetProvider,(LPVOID*)&lpProvider);
|
|
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
TRACE(_T("IConsole2::QueryInterface failed.\n"));
|
|
lpConsole->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
ASSERT(lpProvider);
|
|
|
|
// create an IDataObject for this scope item
|
|
CSnapinDataObject* pdoNew = NULL;
|
|
pdoNew = new CSnapinDataObject;
|
|
|
|
if( ! GfxCheckObjPtr(pdoNew,CSnapinDataObject) )
|
|
{
|
|
TRACE(_T("FAILED : Out of memory.\n"));
|
|
lpProvider->Release();
|
|
lpConsole->Release();
|
|
return false;
|
|
}
|
|
|
|
LPDATAOBJECT lpDataObject = (LPDATAOBJECT)pdoNew->GetInterface(&IID_IDataObject);
|
|
ASSERT(lpDataObject);
|
|
pdoNew->SetItem(this);
|
|
|
|
for( int i = 0; i < m_pScopePane->GetResultsPaneCount(); i++ )
|
|
{
|
|
CResultsPane* pResultsPane = m_pScopePane->GetResultsPane(i);
|
|
if( GfxCheckObjPtr(pResultsPane,CResultsPane) )
|
|
{
|
|
LPCOMPONENT pComponent = (LPCOMPONENT)pResultsPane->GetInterface(&IID_IComponent);
|
|
hr = lpProvider->FindPropertySheet(MMC_COOKIE(this),pComponent,lpDataObject);
|
|
if( hr == S_OK )
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
lpProvider->Release();
|
|
lpConsole->Release();
|
|
|
|
delete pdoNew;
|
|
|
|
if( hr == S_FALSE || ! CHECKHRESULT(hr) )
|
|
{
|
|
TRACE(_T("INFO : No property sheets were open for this node.\n"));
|
|
if( bSearchChildren ) // search children for open sheets if requested
|
|
{
|
|
for( int k = 0; k < GetChildCount(); k++ )
|
|
{
|
|
if( GetChild(k) && GetChild(k)->IsPropertySheetOpen(true) )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CScopePaneItem::InvokePropertySheet()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::InvokePropertySheet\n"));
|
|
|
|
// this function programmatically invokes a property sheet for a scope pane item
|
|
// see M. Maguire's doc on IAS snapin design for a detailed description on just what
|
|
// is going on here. I cannot claim this as my own. :-)
|
|
|
|
// first see if a property sheet for this item is open already
|
|
// if( IsPropertySheetOpen() )
|
|
// {
|
|
// return true;
|
|
// }
|
|
|
|
if( ! GetScopePane() )
|
|
{
|
|
TRACE(_T("FAILED : m_pScopePane is not a valid pointer.\n"));
|
|
return false;
|
|
}
|
|
|
|
LPCONSOLE2 lpConsole = m_pScopePane->GetConsolePtr();
|
|
|
|
if( ! GfxCheckPtr(lpConsole,IConsole2) )
|
|
{
|
|
TRACE(_T("FAILED : lpConsole is not a valid pointer.\n"));
|
|
return false;
|
|
}
|
|
|
|
// get a reference to the IPropertySheetProvider interface
|
|
LPPROPERTYSHEETPROVIDER lpProvider = NULL;
|
|
|
|
HRESULT hr = lpConsole->QueryInterface(IID_IPropertySheetProvider,(LPVOID*)&lpProvider);
|
|
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
TRACE(_T("IConsole2::QueryInterface failed.\n"));
|
|
lpConsole->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
ASSERT(lpProvider);
|
|
|
|
// create an IDataObject for this scope item
|
|
CSnapinDataObject* pdoNew = NULL;
|
|
pdoNew = new CSnapinDataObject;
|
|
|
|
if( ! GfxCheckObjPtr(pdoNew,CSnapinDataObject) )
|
|
{
|
|
TRACE(_T("FAILED : Out of memory.\n"));
|
|
lpProvider->Release();
|
|
lpConsole->Release();
|
|
return false;
|
|
}
|
|
|
|
LPDATAOBJECT lpDataObject = (LPDATAOBJECT)pdoNew->GetInterface(&IID_IDataObject);
|
|
ASSERT(lpDataObject);
|
|
pdoNew->SetItem(this);
|
|
|
|
hr = lpProvider->CreatePropertySheet(GetDisplayName(),TRUE,MMC_COOKIE(this),lpDataObject,MMC_PSO_HASHELP);
|
|
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
TRACE(_T("FAILED : IPropertySheetProvider::CreatePropertySheet failed.\n"));
|
|
lpProvider->Release();
|
|
lpConsole->Release();
|
|
|
|
delete pdoNew;
|
|
|
|
return false;
|
|
}
|
|
|
|
HWND hWndNotification = NULL;
|
|
HWND hWndMain = NULL;
|
|
|
|
hr = lpConsole->GetMainWindow(&hWndMain);
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
// Release data allocated in CreatePropertySheet
|
|
lpProvider->Show( -1, 0);
|
|
lpProvider->Release();
|
|
lpConsole->Release();
|
|
|
|
delete pdoNew;
|
|
|
|
return false;
|
|
}
|
|
|
|
// Try to get the correct window that notifications should be sent to.
|
|
hWndNotification = FindWindowEx( hWndMain, NULL, _T("MDIClient"), NULL );
|
|
hWndNotification = FindWindowEx( hWndNotification, NULL, _T("MMCChildFrm"), NULL );
|
|
hWndNotification = FindWindowEx( hWndNotification, NULL, _T("MMCView"), NULL );
|
|
|
|
if( hWndNotification == NULL )
|
|
{
|
|
// It was a nice try, but it failed, so we should be able to get by by using the main HWND.
|
|
hWndNotification = hWndMain;
|
|
}
|
|
|
|
LPCOMPONENTDATA lpComponentData = (LPCOMPONENTDATA)m_pScopePane->GetInterface(&IID_IComponentData);
|
|
|
|
hr = lpProvider->AddPrimaryPages(lpComponentData,TRUE,hWndNotification,TRUE);
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
// Release data allocated in CreatePropertySheet
|
|
lpProvider->Show(-1,0);
|
|
lpProvider->Release();
|
|
lpConsole->Release();
|
|
|
|
delete pdoNew;
|
|
|
|
return false;
|
|
}
|
|
|
|
hr = lpProvider->AddExtensionPages();
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
// ISSUE: Should I care if this fails?
|
|
TRACE(_T("WARNING : PROPERTYSHEETPROVIDER::AddExtensionPages failed.\n"));
|
|
|
|
// Release data allocated in CreatePropertySheet
|
|
// lpProvider->Show( -1, 0);
|
|
// lpProvider->Release();
|
|
// lpConsole->Release();
|
|
|
|
// delete pdoNew;
|
|
|
|
// return false;
|
|
}
|
|
|
|
// v-marfin : 62962 Show "details" page on a new creation
|
|
BOOL bIsNewDataGroup = this->IsKindOf(RUNTIME_CLASS(CDataGroupScopeItem));
|
|
int nShowPage = bIsNewDataGroup ? 0 : 1;
|
|
|
|
#ifndef IA64
|
|
hr = lpProvider->Show( (long) hWndMain, nShowPage); //59643b
|
|
#endif // IA64
|
|
|
|
if( ! CHECKHRESULT( hr ) )
|
|
{
|
|
// Release data allocated in CreatePropertySheet
|
|
lpProvider->Show( -1, 0);
|
|
lpProvider->Release();
|
|
lpConsole->Release();
|
|
|
|
delete pdoNew;
|
|
|
|
return false;
|
|
}
|
|
|
|
lpProvider->Release();
|
|
lpConsole->Release();
|
|
lpDataObject->Release();
|
|
|
|
// delete pdoNew;
|
|
|
|
return true;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Context Menu Members
|
|
|
|
// v-marfin 59644 : Modified prototype to allow passing to selected item count.
|
|
// Only allow 3rd party menu item if ony 1 item is selected.
|
|
bool CScopePaneItem::InvokeContextMenu(const CPoint& pt, int iSelectedCount)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::InvokeContextMenu\n"));
|
|
TRACEARGn(pt.x);
|
|
TRACEARGn(pt.y);
|
|
|
|
if( ! GetScopePane() )
|
|
{
|
|
TRACE(_T("FAILED : m_pScopePane is not a valid pointer.\n"));
|
|
return false;
|
|
}
|
|
|
|
LPCONSOLE2 lpConsole = m_pScopePane->GetConsolePtr();
|
|
|
|
if( ! GfxCheckPtr(lpConsole,IConsole2) )
|
|
{
|
|
TRACE(_T("FAILED : lpConsole is not a valid pointer.\n"));
|
|
return false;
|
|
}
|
|
|
|
// get a reference to the IContextMenuProvider interface
|
|
LPCONTEXTMENUPROVIDER lpProvider = NULL;
|
|
|
|
HRESULT hr = lpConsole->QueryInterface(IID_IContextMenuProvider,(LPVOID*)&lpProvider);
|
|
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
TRACE(_T("IConsole2::QueryInterface failed.\n"));
|
|
lpConsole->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
ASSERT(lpProvider);
|
|
|
|
// just in case
|
|
hr = lpProvider->EmptyMenuList();
|
|
|
|
// populate the menu
|
|
CONTEXTMENUITEM cmi;
|
|
CString sResString;
|
|
CString sResString2;
|
|
ZeroMemory(&cmi,sizeof(CONTEXTMENUITEM));
|
|
|
|
// add the top insertion point
|
|
cmi.lCommandID = CCM_INSERTIONPOINTID_PRIMARY_TOP;
|
|
cmi.lInsertionPointID = CCM_INSERTIONPOINTID_ROOT_MENU;
|
|
cmi.fSpecialFlags = CCM_SPECIAL_INSERTION_POINT;
|
|
|
|
hr = lpProvider->AddItem(&cmi);
|
|
|
|
// add new menu and insertion point
|
|
|
|
sResString.LoadString(IDS_STRING_NEW);
|
|
cmi.strName = LPTSTR(LPCTSTR(sResString));
|
|
sResString2.LoadString(IDS_STRING_NEW_DESCRIPTION);
|
|
cmi.strStatusBarText = LPTSTR(LPCTSTR(sResString2));
|
|
cmi.lCommandID = CCM_INSERTIONPOINTID_PRIMARY_NEW;
|
|
cmi.lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_TOP;
|
|
cmi.fFlags = MF_POPUP;
|
|
cmi.fSpecialFlags = CCM_SPECIAL_SUBMENU;
|
|
|
|
hr = lpProvider->AddItem(&cmi);
|
|
|
|
cmi.lCommandID = CCM_INSERTIONPOINTID_PRIMARY_NEW;
|
|
cmi.lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_TOP;
|
|
cmi.fSpecialFlags = CCM_SPECIAL_INSERTION_POINT;
|
|
|
|
hr = lpProvider->AddItem(&cmi);
|
|
|
|
// add task menu and insertion point
|
|
|
|
sResString.LoadString(IDS_STRING_TASK);
|
|
cmi.strName = LPTSTR(LPCTSTR(sResString));
|
|
sResString2.LoadString(IDS_STRING_TASK_DESCRIPTION);
|
|
cmi.strStatusBarText = LPTSTR(LPCTSTR(sResString2));
|
|
cmi.lCommandID = CCM_INSERTIONPOINTID_PRIMARY_TASK;
|
|
cmi.lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_TOP;
|
|
cmi.fFlags = MF_POPUP;
|
|
cmi.fSpecialFlags = CCM_SPECIAL_SUBMENU;
|
|
|
|
hr = lpProvider->AddItem(&cmi);
|
|
|
|
cmi.lCommandID = CCM_INSERTIONPOINTID_PRIMARY_TASK;
|
|
cmi.lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_TOP;
|
|
cmi.fSpecialFlags = CCM_SPECIAL_INSERTION_POINT;
|
|
|
|
hr = lpProvider->AddItem(&cmi);
|
|
|
|
// create an IDataObject for this scope item
|
|
CSnapinDataObject* pdoNew = NULL;
|
|
pdoNew = new CSnapinDataObject;
|
|
|
|
if( ! GfxCheckObjPtr(pdoNew,CSnapinDataObject) )
|
|
{
|
|
TRACE(_T("FAILED : Out of memory.\n"));
|
|
lpProvider->Release();
|
|
lpConsole->Release();
|
|
return false;
|
|
}
|
|
|
|
LPDATAOBJECT lpDataObject = (LPDATAOBJECT)pdoNew->GetInterface(&IID_IDataObject);
|
|
ASSERT(lpDataObject);
|
|
pdoNew->SetItem(this);
|
|
|
|
LPUNKNOWN lpUnknown = (LPUNKNOWN)GetScopePane()->GetInterface(&IID_IExtendContextMenu);
|
|
hr = lpProvider->AddPrimaryExtensionItems(lpUnknown,lpDataObject);
|
|
|
|
// v-marfin 59644 : Only allow 3rd party menu items if only 1 item is selected
|
|
// in the results pane view.
|
|
if (iSelectedCount == 1)
|
|
{
|
|
// add third party insertion points
|
|
cmi.lCommandID = CCM_INSERTIONPOINTID_3RDPARTY_NEW;
|
|
cmi.lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_NEW;
|
|
cmi.fSpecialFlags = CCM_SPECIAL_INSERTION_POINT;
|
|
|
|
hr = lpProvider->AddItem(&cmi);
|
|
|
|
cmi.lCommandID = CCM_INSERTIONPOINTID_3RDPARTY_TASK;
|
|
cmi.lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_TASK;
|
|
cmi.fSpecialFlags = CCM_SPECIAL_INSERTION_POINT;
|
|
|
|
hr = lpProvider->AddItem(&cmi);
|
|
|
|
hr = lpProvider->AddThirdPartyExtensionItems(lpDataObject);
|
|
}
|
|
|
|
HWND hWndMain = NULL;
|
|
|
|
hr = lpConsole->GetMainWindow(&hWndMain);
|
|
|
|
// Try to get the correct window that notifications should be sent to.
|
|
HWND hWndNotification = FindWindowEx( hWndMain, NULL, _T("MDIClient"), NULL );
|
|
hWndNotification = FindWindowEx( hWndNotification, NULL, _T("MMCChildFrm"), NULL );
|
|
hWndNotification = FindWindowEx( hWndNotification, NULL, _T("AfxFrameOrView42u"), NULL );
|
|
if( hWndNotification == NULL )
|
|
{
|
|
// It was a nice try, but it failed, so we should be able to get by by using the main HWND.
|
|
hWndNotification = hWndMain;
|
|
}
|
|
|
|
long lSelected = 0L;
|
|
hr = lpProvider->ShowContextMenu(hWndNotification,pt.x,pt.y,&lSelected);
|
|
|
|
lpProvider->Release();
|
|
lpConsole->Release();
|
|
lpDataObject->Release();
|
|
|
|
return true;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Help Topic
|
|
|
|
CString CScopePaneItem::GetHelpTopic() const
|
|
{
|
|
TRACEX(_T("CScopePaneItem::GetHelpTopic\n"));
|
|
|
|
return m_sHelpTopic;
|
|
}
|
|
|
|
void CScopePaneItem::SetHelpTopic(const CString& sTopic)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::SetHelpTopic\n"));
|
|
TRACEARGs(sTopic);
|
|
|
|
if( sTopic.IsEmpty() )
|
|
{
|
|
TRACE(_T("WARNING : sTopic is an empty string.\n"));
|
|
}
|
|
|
|
m_sHelpTopic = sTopic;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Messaging Members
|
|
|
|
LRESULT CScopePaneItem::MsgProc(UINT msg, WPARAM wparam, LPARAM lparam)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::MsgProc\n"));
|
|
TRACEARGn(msg);
|
|
TRACEARGn(wparam);
|
|
TRACEARGn(lparam);
|
|
|
|
// propagate to all children
|
|
for( int i=0; i < m_Children.GetSize(); i++ )
|
|
{
|
|
// stop if a return value of -1 is given
|
|
if( m_Children[i]->MsgProc(msg,wparam,lparam) == -1L )
|
|
{
|
|
return -1L;
|
|
}
|
|
}
|
|
|
|
return 0L;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// MMC Notify Handlers
|
|
|
|
HRESULT CScopePaneItem::OnActivate(BOOL bActivated)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnActivate\n"));
|
|
TRACEARGn(bActivated);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnAddImages(CResultsPane* pPane)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnAddImages\n"));
|
|
TRACEARGn(pPane);
|
|
|
|
if( ! GfxCheckObjPtr(pPane,CResultsPane) )
|
|
{
|
|
TRACE(_T("FAILED : pPane is not a valid pointer to an object.\n"));
|
|
return E_FAIL;
|
|
}
|
|
|
|
pPane->AddIcon(GetIconId());
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnAddMenuItems(LPCONTEXTMENUCALLBACK piCallback,long __RPC_FAR *pInsertionAllowed)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnAddMenuItems\n"));
|
|
TRACEARGn(piCallback);
|
|
TRACEARGn(pInsertionAllowed);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnBtnClick(MMC_CONSOLE_VERB verb)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnBtnClick\n"));
|
|
TRACEARGn(verb);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnCommand(long lCommandID)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnCommand\n"));
|
|
TRACEARGn(lCommandID);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnContextHelp()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnContextHelp\n"));
|
|
|
|
if( GetScopePane() == NULL )
|
|
{
|
|
TRACE(_T("FAILED : m_pScopePane is not a valid pointer.\n"));
|
|
return E_FAIL;
|
|
}
|
|
|
|
// v-marfin 62478 : Set help topic based on type of object
|
|
//--------------------------------------------------------
|
|
|
|
if (GfxCheckObjPtr(this,CRootScopeItem)) // HealthMonitor level, top level
|
|
{
|
|
m_sHelpTopic = _T("HMon21.chm::/oroot.htm");
|
|
}
|
|
else if (GfxCheckObjPtr(this,CAllSystemsScopeItem)) // All Monitored Computers
|
|
{
|
|
m_sHelpTopic = _T("HMon21.chm::/oallmon.htm");
|
|
}
|
|
else if (GfxCheckObjPtr(this,CSystemScopeItem)) // Monitored Computer
|
|
{
|
|
m_sHelpTopic = _T("HMon21.chm::/ocomp.htm");
|
|
}
|
|
else if (GfxCheckObjPtr(this,CActionPolicyScopeItem)) // Actions
|
|
{
|
|
m_sHelpTopic = _T("HMon21.chm::/oact.htm");
|
|
}
|
|
else if (GfxCheckObjPtr(this,CDataGroupScopeItem)) // Data Group
|
|
{
|
|
m_sHelpTopic = _T("HMon21.chm::/odatagrp.htm");
|
|
}
|
|
else if (GfxCheckObjPtr(this,CDataElementScopeItem)) // Data Collector
|
|
{
|
|
m_sHelpTopic = _T("HMon21.chm::/odatacol.htm");
|
|
}
|
|
else if (GfxCheckObjPtr(this,CRuleScopeItem)) // Threshold
|
|
{
|
|
m_sHelpTopic = _T("HMon21.chm::/othreshold.htm");
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
|
|
|
|
|
|
if( m_sHelpTopic.IsEmpty() )
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
LPCONSOLE2 lpConsole = m_pScopePane->GetConsolePtr();
|
|
|
|
if( ! GfxCheckPtr(lpConsole,IConsole2) )
|
|
{
|
|
TRACE(_T("FAILED : lpConsole is not a valid pointer.\n"));
|
|
return E_FAIL;
|
|
}
|
|
|
|
IDisplayHelp* pidh = NULL;
|
|
HRESULT hr = lpConsole->QueryInterface(IID_IDisplayHelp,(LPVOID*)&pidh);
|
|
|
|
ASSERT(pidh);
|
|
if( pidh == NULL || ! CHECKHRESULT(hr) )
|
|
{
|
|
TRACE(_T("Failed on IConsole2::QI(IID_IDisplayHelp).\n"));
|
|
return hr;
|
|
}
|
|
|
|
LPOLESTR lpCompiledHelpFile = reinterpret_cast<LPOLESTR>(CoTaskMemAlloc((m_sHelpTopic.GetLength() + 1)* sizeof(TCHAR)));
|
|
if( lpCompiledHelpFile == NULL )
|
|
{
|
|
TRACE(_T("FAILED : Out of memory.\n"));
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
_tcscpy(lpCompiledHelpFile, (LPCTSTR)m_sHelpTopic);
|
|
|
|
hr = pidh->ShowTopic(lpCompiledHelpFile);
|
|
|
|
pidh->Release();
|
|
lpConsole->Release();
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnCreatePropertyPages(LPPROPERTYSHEETCALLBACK lpProvider, INT_PTR handle)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnCreatePropertyPages\n"));
|
|
TRACEARGn(lpProvider);
|
|
TRACEARGn(handle);
|
|
|
|
// return S_FALSE to indicate that no property pages will be created
|
|
return S_FALSE;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnCutOrMove()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnCutOrMove\n"));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnDelete(BOOL bConfirm) // v-marfin 60298
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnDelete\n"));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnExpand(BOOL bExpand)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnExpand\n"));
|
|
TRACEARGn(bExpand);
|
|
|
|
if( bExpand )
|
|
{
|
|
// for each child call InsertItem to insert into namespace
|
|
for( int i=0; i < m_Children.GetSize(); i++ )
|
|
{
|
|
if( ! m_Children[i]->InsertItem(i) )
|
|
{
|
|
TRACE(_T("FAILED : CScopePaneItem::InsertItem failed.\n"));
|
|
}
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnGetDisplayInfo(int nColumnIndex, LPTSTR* ppString)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnGetDisplayInfo\n"));
|
|
TRACEARGn(nColumnIndex);
|
|
TRACEARGn(ppString);
|
|
|
|
if( nColumnIndex < 0 || nColumnIndex >= m_saDisplayNames.GetSize() )
|
|
{
|
|
TRACE(_T("FAILED : The column index is out of the display name array bounds"));
|
|
return E_FAIL;
|
|
}
|
|
|
|
*ppString = LPTSTR(LPCTSTR(GetDisplayName(nColumnIndex)));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnGetResultViewType(CString& sViewType,long& lViewOptions)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnGetResultViewType\n"));
|
|
TRACEARGs(sViewType);
|
|
TRACEARGn(lViewOptions);
|
|
|
|
if( ! GetResultsPaneView() )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
return m_pResultsPaneView->OnGetResultViewType(sViewType,lViewOptions);
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnListpad(BOOL bAttachingListCtrl)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnListpad\n"));
|
|
TRACEARGn(bAttachingListCtrl);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnMinimized(BOOL bMinimized)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnMinimized\n"));
|
|
TRACEARGn(bMinimized);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnPaste(LPDATAOBJECT pSelectedItems, LPDATAOBJECT* ppCopiedItems)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnPaste\n"));
|
|
TRACEARGn(pSelectedItems);
|
|
TRACEARGn(ppCopiedItems);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnPropertyChange(LPARAM lParam)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnPropertyChange\n"));
|
|
TRACEARGn(lParam);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnQueryPagesFor()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnQueryPagesFor\n"));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnQueryPaste(LPDATAOBJECT pDataObject)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnQueryPaste\n"));
|
|
TRACEARGn(pDataObject);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnRefresh()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnRefresh\n"));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnRemoveChildren()
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnRemoveChildren\n"));
|
|
|
|
for( int i = 0; i < GetChildCount(); i++ )
|
|
{
|
|
CScopePaneItem* pItem = GetChild(i);
|
|
if( pItem )
|
|
{
|
|
if( ! pItem->DeleteItem() )
|
|
{
|
|
TRACE(_T("WARNING : CScopePaneItem::DeleteItem returns false.\n"));
|
|
}
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnRename(const CString& sNewName)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnRename\n"));
|
|
|
|
SetDisplayName(0,sNewName);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnRestoreView(MMC_RESTORE_VIEW* pRestoreView, BOOL* pbHandled)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnRestoreView\n"));
|
|
TRACEARGn(pRestoreView);
|
|
TRACEARGn(pbHandled);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnSelect(CResultsPane* pPane, BOOL bSelected)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnSelect\n"));
|
|
TRACEARGn(pPane);
|
|
TRACEARGn(bSelected);
|
|
|
|
if( ! GfxCheckObjPtr(pPane,CResultsPane) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
LPCONSOLEVERB lpConsoleVerb = pPane->GetConsoleVerbPtr();
|
|
|
|
HRESULT hr = lpConsoleVerb->SetVerbState( MMC_VERB_REFRESH, ENABLED, TRUE );
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
TRACE(_T("FAILED : IConsoleVerb::SetVerbState failed.\n"));
|
|
lpConsoleVerb->Release();
|
|
return hr;
|
|
}
|
|
|
|
hr = lpConsoleVerb->SetDefaultVerb( MMC_VERB_OPEN );
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
TRACE(_T("FAILED : IConsoleVerb::SetDefaultVerb failed.\n"));
|
|
lpConsoleVerb->Release();
|
|
return hr;
|
|
}
|
|
|
|
lpConsoleVerb->Release();
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CScopePaneItem::OnShow(CResultsPane* pPane, BOOL bSelecting)
|
|
{
|
|
TRACEX(_T("CScopePaneItem::OnShow\n"));
|
|
TRACEARGn(pPane);
|
|
TRACEARGn(bSelecting);
|
|
|
|
// first we need to track scope item selected since MMC does not do this
|
|
CScopePane* pScopePane = GetScopePane();
|
|
|
|
if( ! pScopePane )
|
|
{
|
|
TRACE(_T("FAILED : CScopePaneItem::GetScopePane returns NULL pointer.\n"));
|
|
return E_FAIL;
|
|
}
|
|
|
|
if( ! bSelecting ) // we are being de-selected so tell the scope pane !
|
|
{
|
|
pScopePane->SetSelectedScopeItem(NULL);
|
|
}
|
|
else
|
|
{
|
|
pScopePane->SetSelectedScopeItem(this);
|
|
}
|
|
|
|
if( ! GetResultsPaneView() )
|
|
{
|
|
TRACE(_T("FAILED : m_pResultsPaneView is not a valid pointer.\n"));
|
|
return E_FAIL;
|
|
}
|
|
|
|
return m_pResultsPaneView->OnShow(pPane,bSelecting,GetItemHandle());
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// MFC Operations
|
|
|
|
void CScopePaneItem::OnFinalRelease()
|
|
{
|
|
// When the last reference for an automation object is released
|
|
// OnFinalRelease is called. The base class will automatically
|
|
// deletes the object. Add additional cleanup required for your
|
|
// object before calling the base class.
|
|
|
|
CCmdTarget::OnFinalRelease();
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CScopePaneItem, CCmdTarget)
|
|
//{{AFX_MSG_MAP(CScopePaneItem)
|
|
// NOTE - the ClassWizard will add and remove mapping macros here.
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
BEGIN_DISPATCH_MAP(CScopePaneItem, CCmdTarget)
|
|
//{{AFX_DISPATCH_MAP(CScopePaneItem)
|
|
// NOTE - the ClassWizard will add and remove mapping macros here.
|
|
//}}AFX_DISPATCH_MAP
|
|
END_DISPATCH_MAP()
|
|
|
|
// Note: we add support for IID_IScopePaneItem to support typesafe binding
|
|
// from VBA. This IID must match the GUID that is attached to the
|
|
// dispinterface in the .ODL file.
|
|
|
|
// {7D4A6861-9056-11D2-BD45-0000F87A3912}
|
|
static const IID IID_IScopePaneItem =
|
|
{ 0x7d4a6861, 0x9056, 0x11d2, { 0xbd, 0x45, 0x0, 0x0, 0xf8, 0x7a, 0x39, 0x12 } };
|
|
|
|
BEGIN_INTERFACE_MAP(CScopePaneItem, CCmdTarget)
|
|
INTERFACE_PART(CScopePaneItem, IID_IScopePaneItem, Dispatch)
|
|
END_INTERFACE_MAP()
|
|
|
|
// {7D4A6862-9056-11D2-BD45-0000F87A3912}
|
|
IMPLEMENT_OLECREATE_EX(CScopePaneItem, "SnapIn.ScopePaneItem", 0x7d4a6862, 0x9056, 0x11d2, 0xbd, 0x45, 0x0, 0x0, 0xf8, 0x7a, 0x39, 0x12)
|
|
|
|
BOOL CScopePaneItem::CScopePaneItemFactory::UpdateRegistry(BOOL bRegister)
|
|
{
|
|
if (bRegister)
|
|
return AfxOleRegisterServerClass(m_clsid, m_lpszProgID, m_lpszProgID, m_lpszProgID, OAT_DISPATCH_OBJECT);
|
|
else
|
|
return AfxOleUnregisterClass(m_clsid, m_lpszProgID);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CScopePaneItem message handlers
|