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

1755 lines
41 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
// 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
Reference in a new issue Copy permalink