1575 lines
34 KiB
C++
1575 lines
34 KiB
C++
// ScopePane.cpp : implementation file
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "ScopePane.h"
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CScopePane
|
|
|
|
IMPLEMENT_DYNCREATE(CScopePane, CCmdTarget)
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Construction/Destruction
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
CScopePane::CScopePane()
|
|
{
|
|
EnableAutomation();
|
|
|
|
m_pRootItem = NULL;
|
|
m_pMsgHook = NULL;
|
|
m_pIConsoleNamespace = NULL;
|
|
m_pIConsole = NULL;
|
|
m_pIImageList = NULL;
|
|
m_pSelectedScopeItem = NULL;
|
|
|
|
// To keep the application running as long as an OLE automation
|
|
// object is active, the constructor calls AfxOleLockApp.
|
|
|
|
AfxOleLockApp();
|
|
|
|
}
|
|
|
|
CScopePane::~CScopePane()
|
|
{
|
|
// To terminate the application when all objects created with
|
|
// with OLE automation, the destructor calls AfxOleUnlockApp.
|
|
|
|
AfxOleUnlockApp();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Creation/Destruction Overrideable Members
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
bool CScopePane::OnCreate()
|
|
{
|
|
TRACEX(_T("CScopePane::OnCreate\n"));
|
|
|
|
if( ! GetRootScopeItem() )
|
|
{
|
|
TRACE(_T("FAILED : The pointer to the root item is invalid.\n"));
|
|
return false;
|
|
}
|
|
|
|
if( ! m_pRootItem->Create(this,NULL) )
|
|
{
|
|
TRACE(_T("CRootScopeItem::Create failed.\n"));
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
LPCOMPONENT CScopePane::OnCreateComponent()
|
|
{
|
|
TRACEX(_T("CScopePane::OnCreateComponent\n"));
|
|
|
|
CResultsPane* pNewPane = new CResultsPane;
|
|
|
|
if( ! CHECKOBJPTR(pNewPane,RUNTIME_CLASS(CResultsPane),sizeof(CResultsPane)) )
|
|
{
|
|
TRACE(_T("FAILED : Out of memory.\n"));
|
|
return NULL;
|
|
}
|
|
|
|
pNewPane->SetOwnerScopePane(this);
|
|
|
|
int iIndex = AddResultsPane(pNewPane);
|
|
|
|
ASSERT(iIndex != -1);
|
|
|
|
LPCOMPONENT pComponent = (LPCOMPONENT)pNewPane->GetInterface(&IID_IComponent);
|
|
|
|
if( ! CHECKPTR(pComponent,sizeof(IComponent)) )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
return pComponent;
|
|
}
|
|
|
|
bool CScopePane::OnDestroy()
|
|
{
|
|
TRACEX(_T("CScopePane::OnDestroy\n"));
|
|
|
|
|
|
|
|
// unhook the window first
|
|
UnhookWindow();
|
|
|
|
if( m_pMsgHook )
|
|
{
|
|
delete m_pMsgHook;
|
|
m_pMsgHook = NULL;
|
|
}
|
|
|
|
// delete the root scope pane item
|
|
CScopePaneItem* pRootItem = GetRootScopeItem();
|
|
|
|
if( pRootItem )
|
|
{
|
|
delete pRootItem;
|
|
m_pRootItem = NULL;
|
|
}
|
|
|
|
// Release all the interfaces queried for
|
|
|
|
if( m_pIConsole )
|
|
{
|
|
m_pIConsole->Release();
|
|
m_pIConsole = NULL;
|
|
}
|
|
|
|
if( m_pIConsoleNamespace )
|
|
{
|
|
m_pIConsoleNamespace->Release();
|
|
m_pIConsoleNamespace = NULL;
|
|
}
|
|
|
|
if( m_pIImageList )
|
|
{
|
|
m_pIImageList->Release();
|
|
m_pIImageList = NULL;
|
|
}
|
|
|
|
// empty Result Panes array
|
|
|
|
for( int i = GetResultsPaneCount()-1; i >= 0; i-- )
|
|
{
|
|
RemoveResultsPane(i);
|
|
}
|
|
|
|
m_pSelectedScopeItem = NULL;
|
|
|
|
return true;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Root Scope Pane Item Members
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
CScopePaneItem* CScopePane::CreateRootScopeItem()
|
|
{
|
|
TRACEX(_T("CScopePane::CreateRootScopeItem\n"));
|
|
|
|
return NULL;
|
|
}
|
|
|
|
CScopePaneItem* CScopePane::GetRootScopeItem()
|
|
{
|
|
TRACEX(_T("CScopePane::GetRootScopeItem\n"));
|
|
|
|
if( ! CHECKOBJPTR(m_pRootItem,RUNTIME_CLASS(CScopePaneItem),sizeof(CScopePaneItem)) )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
return m_pRootItem;
|
|
}
|
|
|
|
void CScopePane::SetRootScopeItem(CScopePaneItem* pRootItem)
|
|
{
|
|
TRACEX(_T("CScopePane::GetRootScopeItem\n"));
|
|
|
|
if( ! CHECKOBJPTR(pRootItem,RUNTIME_CLASS(CScopePaneItem),sizeof(CScopePaneItem)) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_pRootItem = pRootItem;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// MMC Frame Window Message Hook Members
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
bool CScopePane::HookWindow()
|
|
{
|
|
TRACEX(_T("CScopePane::HookWindow\n"));
|
|
|
|
if( m_pMsgHook == NULL )
|
|
{
|
|
m_pMsgHook = new CMmcMsgHook;
|
|
}
|
|
|
|
if( ! CHECKOBJPTR(m_pMsgHook,RUNTIME_CLASS(CMmcMsgHook),sizeof(CMmcMsgHook)) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
HWND hMMCMainWnd = NULL;
|
|
LPCONSOLE2 lpConsole = GetConsolePtr();
|
|
|
|
if( lpConsole == NULL )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
lpConsole->GetMainWindow(&hMMCMainWnd);
|
|
|
|
m_pMsgHook->Init(GetRootScopeItem(),hMMCMainWnd);
|
|
|
|
lpConsole->Release();
|
|
|
|
return true;
|
|
}
|
|
|
|
void CScopePane::UnhookWindow()
|
|
{
|
|
TRACEX(_T("CScopePane::UnhookWindow\n"));
|
|
|
|
if( ! CHECKOBJPTR(m_pMsgHook,RUNTIME_CLASS(CMmcMsgHook),sizeof(CMmcMsgHook)) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_pMsgHook->HookWindow(NULL);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// MMC Interface Members
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
LPCONSOLENAMESPACE2 CScopePane::GetConsoleNamespacePtr()
|
|
{
|
|
TRACEX(_T("CScopePane::GetConsoleNamespacePtr\n"));
|
|
|
|
if( ! CHECKPTR(m_pIConsoleNamespace,sizeof(IConsoleNameSpace2)) )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
m_pIConsoleNamespace->AddRef();
|
|
|
|
return m_pIConsoleNamespace;
|
|
}
|
|
|
|
LPCONSOLE2 CScopePane::GetConsolePtr()
|
|
{
|
|
TRACEX(_T("CScopePane::GetConsolePtr\n"));
|
|
|
|
if( ! CHECKPTR(m_pIConsole,sizeof(IConsole2)) )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
m_pIConsole->AddRef();
|
|
|
|
return m_pIConsole;
|
|
}
|
|
|
|
LPIMAGELIST CScopePane::GetImageListPtr()
|
|
{
|
|
TRACEX(_T("CScopePane::GetImageListPtr\n"));
|
|
|
|
if( ! CHECKPTR(m_pIImageList,sizeof(IImageList)) )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
m_pIImageList->AddRef();
|
|
|
|
return m_pIImageList;
|
|
}
|
|
|
|
LPUNKNOWN CScopePane::GetCustomOcxPtr()
|
|
{
|
|
TRACEX(_T("CScopePane::GetCustomOcxPtr\n"));
|
|
|
|
LPCONSOLE2 pIConsole = GetConsolePtr();
|
|
|
|
if( ! CHECKPTR(pIConsole,sizeof(IConsole)) )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
LPUNKNOWN pIUnknown = NULL;
|
|
HRESULT hr = pIConsole->QueryResultView(&pIUnknown);
|
|
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
pIConsole->Release();
|
|
|
|
return pIUnknown;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// MMC Scope Pane Helper Members
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
CScopePaneItem* CScopePane::GetSelectedScopeItem()
|
|
{
|
|
TRACEX(_T("CScopePane::GetSelectedScopeItem\n"));
|
|
|
|
if( ! m_pSelectedScopeItem )
|
|
{
|
|
TRACE(_T("WARNING : Selected Scope Item is NULL.\n"));
|
|
return NULL;
|
|
}
|
|
|
|
if( ! GfxCheckObjPtr(m_pSelectedScopeItem,CScopePaneItem) )
|
|
{
|
|
TRACE(_T("FAILED : m_pSelectedScopeItem is not valid.\n"));
|
|
return NULL;
|
|
}
|
|
|
|
return m_pSelectedScopeItem;
|
|
}
|
|
|
|
void CScopePane::SetSelectedScopeItem(CScopePaneItem* pItem)
|
|
{
|
|
TRACEX(_T("CScopePane::SetSelectedScopeItem\n"));
|
|
TRACEARGn(pItem);
|
|
|
|
if( ! pItem )
|
|
{
|
|
m_pSelectedScopeItem = NULL;
|
|
return;
|
|
}
|
|
|
|
if( ! GfxCheckObjPtr(pItem,CScopePaneItem) )
|
|
{
|
|
TRACE(_T("FAILED : pItem pointer is invalid.\n"));
|
|
return;
|
|
}
|
|
|
|
m_pSelectedScopeItem = pItem;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Scope Item Icon Management
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
int CScopePane::AddIcon(UINT nIconResID)
|
|
{
|
|
TRACEX(_T("CScopePane::AddIcon\n"));
|
|
TRACEARGn(nIconResID);
|
|
|
|
if( ! CHECKPTR(m_pIImageList,sizeof(IImageList)) )
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
int nIconIndex = GetIconIndex(nIconResID);
|
|
|
|
if( nIconIndex != -1 )
|
|
{
|
|
return nIconIndex;
|
|
}
|
|
|
|
// load icon
|
|
HICON hIcon = AfxGetApp()->LoadIcon(nIconResID);
|
|
if( hIcon == NULL )
|
|
{
|
|
TRACE(_T("FAILED : Icon with resid=%d not found"),nIconResID);
|
|
return -1;
|
|
}
|
|
|
|
nIconIndex = GetIconCount();
|
|
|
|
// insert icon into image list
|
|
#ifndef IA64
|
|
if( ! CHECKHRESULT(m_pIImageList->ImageListSetIcon((long*)hIcon, nIconIndex)) )
|
|
{
|
|
return -1;
|
|
}
|
|
#endif // IA64
|
|
|
|
// add resid and index to map
|
|
m_IconMap.SetAt(nIconResID,nIconIndex);
|
|
|
|
// return index of newly inserted image
|
|
return nIconIndex;
|
|
}
|
|
|
|
int CScopePane::GetIconIndex(UINT nIconResID)
|
|
{
|
|
TRACEX(_T("CScopePane::GetIconIndex\n"));
|
|
TRACEARGn(nIconResID);
|
|
|
|
if( ! CHECKPTR(m_pIImageList,sizeof(IImageList)) )
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
// check map for an existing id
|
|
int nIconIndex = -1;
|
|
|
|
if( m_IconMap.Lookup(nIconResID,nIconIndex) )
|
|
{
|
|
// if exists, return index
|
|
return nIconIndex;
|
|
}
|
|
|
|
TRACE(_T("FAILED : Icon could not be found with Resource id=%d\n"),nIconResID);
|
|
|
|
return -1;
|
|
}
|
|
|
|
int CScopePane::GetIconCount()
|
|
{
|
|
TRACEX(_T("CScopePane::GetIconCount\n"));
|
|
|
|
return (int)m_IconMap.GetCount();
|
|
}
|
|
|
|
void CScopePane::RemoveAllIcons()
|
|
{
|
|
TRACEX(_T("CScopePane::RemoveAllIcons\n"));
|
|
|
|
m_IconMap.RemoveAll();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Results Pane Members
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
int CScopePane::GetResultsPaneCount() const
|
|
{
|
|
TRACEX(_T("CScopePane::GetResultsPaneCount\n"));
|
|
|
|
return (int)m_ResultsPanes.GetSize();
|
|
}
|
|
|
|
CResultsPane* CScopePane::GetResultsPane(int iIndex)
|
|
{
|
|
TRACEX(_T("CScopePane::GetResultsPaneCount\n"));
|
|
TRACEARGn(iIndex);
|
|
|
|
if( iIndex >= m_ResultsPanes.GetSize() || iIndex < 0 )
|
|
{
|
|
TRACE(_T("FAILED : Requested ResultPane is out of array bounds\n"));
|
|
return NULL;
|
|
}
|
|
|
|
CResultsPane* pPane = m_ResultsPanes[iIndex];
|
|
|
|
if( ! CHECKOBJPTR(pPane,RUNTIME_CLASS(CResultsPane),sizeof(CResultsPane)) )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
return pPane;
|
|
}
|
|
|
|
int CScopePane::AddResultsPane(CResultsPane* pPane)
|
|
{
|
|
TRACEX(_T("CScopePane::AddResultsPane\n"));
|
|
TRACEARGn(pPane);
|
|
|
|
if( ! CHECKOBJPTR(pPane,RUNTIME_CLASS(CResultsPane),sizeof(CResultsPane)) )
|
|
{
|
|
TRACE(_T("FAILED : pPane pointer is invalid.\n"));
|
|
return -1;
|
|
}
|
|
|
|
pPane->ExternalAddRef();
|
|
|
|
return (int)m_ResultsPanes.Add(pPane);
|
|
}
|
|
|
|
void CScopePane::RemoveResultsPane(int iIndex)
|
|
{
|
|
TRACEX(_T("CScopePane::RemoveResultsPane\n"));
|
|
TRACEARGn(iIndex);
|
|
|
|
if( iIndex >= m_ResultsPanes.GetSize() || iIndex < 0 )
|
|
{
|
|
TRACE(_T("FAILED : Requested ResultPane is out of array bounds\n"));
|
|
return;
|
|
}
|
|
|
|
CResultsPane* pPane = m_ResultsPanes[iIndex];
|
|
|
|
m_ResultsPanes.RemoveAt(iIndex);
|
|
|
|
pPane->ExternalRelease();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Serialization
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
bool CScopePane::OnLoad(CArchive& ar)
|
|
{
|
|
TRACEX(_T("CScopePane::OnLoad\n"));
|
|
ASSERT(ar.IsLoading());
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CScopePane::OnSave(CArchive& ar)
|
|
{
|
|
TRACEX(_T("CScopePane::OnSave\n"));
|
|
ASSERT(ar.IsStoring());
|
|
return true;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// MMC Help
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
bool CScopePane::ShowTopic(const CString& sHelpTopic)
|
|
{
|
|
TRACEX(_T("CScopePane::ShowTopic\n"));
|
|
|
|
if( sHelpTopic.IsEmpty() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if( ! m_pIConsole )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
IDisplayHelp* pIDisplayHelp = NULL;
|
|
HRESULT hr = m_pIConsole->QueryInterface(IID_IDisplayHelp,(LPVOID*)&pIDisplayHelp);
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
CString sHTMLHelpTopic = AfxGetApp()->m_pszHelpFilePath;
|
|
sHTMLHelpTopic = sHTMLHelpTopic + _T("::") + sHelpTopic;
|
|
LPOLESTR lpCompiledHelpTopic = reinterpret_cast<LPOLESTR>(CoTaskMemAlloc((sHTMLHelpTopic.GetLength() + 1)* sizeof(wchar_t)));
|
|
if(lpCompiledHelpTopic == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
_tcscpy(lpCompiledHelpTopic, (LPCTSTR)sHTMLHelpTopic);
|
|
|
|
hr = pIDisplayHelp->ShowTopic(lpCompiledHelpTopic);
|
|
pIDisplayHelp->Release();
|
|
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// MFC Operations
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
void CScopePane::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(CScopePane, CCmdTarget)
|
|
//{{AFX_MSG_MAP(CScopePane)
|
|
// NOTE - the ClassWizard will add and remove mapping macros here.
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
BEGIN_DISPATCH_MAP(CScopePane, CCmdTarget)
|
|
//{{AFX_DISPATCH_MAP(CScopePane)
|
|
// NOTE - the ClassWizard will add and remove mapping macros here.
|
|
//}}AFX_DISPATCH_MAP
|
|
END_DISPATCH_MAP()
|
|
|
|
// Note: we add support for IID_IScopePane to support typesafe binding
|
|
// from VBA. This IID must match the GUID that is attached to the
|
|
// dispinterface in the .ODL file.
|
|
|
|
// {7D4A6858-9056-11D2-BD45-0000F87A3912}
|
|
static const IID IID_IScopePane =
|
|
{ 0x7d4a6858, 0x9056, 0x11d2, { 0xbd, 0x45, 0x0, 0x0, 0xf8, 0x7a, 0x39, 0x12 } };
|
|
|
|
BEGIN_INTERFACE_MAP(CScopePane, CCmdTarget)
|
|
INTERFACE_PART(CScopePane, IID_IScopePane, Dispatch)
|
|
INTERFACE_PART(CScopePane, IID_IComponentData, ComponentData)
|
|
INTERFACE_PART(CScopePane, IID_IPersistStream, PersistStream)
|
|
INTERFACE_PART(CScopePane, IID_IExtendContextMenu, ExtendContextMenu)
|
|
INTERFACE_PART(CScopePane, IID_IExtendPropertySheet2, ExtendPropertySheet2)
|
|
INTERFACE_PART(CScopePane, IID_ISnapinHelp, SnapinHelp)
|
|
END_INTERFACE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// IComponentData Interface Part
|
|
|
|
ULONG FAR EXPORT CScopePane::XComponentData::AddRef()
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ComponentData)
|
|
return pThis->ExternalAddRef();
|
|
}
|
|
|
|
ULONG FAR EXPORT CScopePane::XComponentData::Release()
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ComponentData)
|
|
return pThis->ExternalRelease();
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XComponentData::QueryInterface(REFIID iid, void FAR* FAR* ppvObj)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ComponentData)
|
|
return (HRESULT)pThis->ExternalQueryInterface(&iid, ppvObj);
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XComponentData::Initialize(
|
|
/* [in] */ LPUNKNOWN pUnknown)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ComponentData)
|
|
|
|
TRACEX(_T("CScopePane::XComponentData::Initialize\n"));
|
|
TRACEARGn(pUnknown);
|
|
|
|
if( ! CHECKPTR(pUnknown,sizeof(IUnknown)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
// MMC should only call ::Initialize once! But you know those MMC clowns...
|
|
ASSERT( pThis->m_pIConsoleNamespace == NULL );
|
|
if( pThis->m_pIConsoleNamespace != NULL )
|
|
{
|
|
TRACE(_T("FAILED : IComponentData::Initialize has already been called. Returning with Error.\n"));
|
|
return E_FAIL;
|
|
}
|
|
|
|
// Get pointer to name space interface
|
|
hr = pUnknown->QueryInterface(IID_IConsoleNameSpace2, (LPVOID*)(&pThis->m_pIConsoleNamespace));
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
TRACE(_T("FAILED : pUnknown->QueryInterface for IID_IConsoleNameSpace2 failed.\n"));
|
|
return hr;
|
|
}
|
|
|
|
// Get pointer to console interface
|
|
hr = pUnknown->QueryInterface(IID_IConsole2, (LPVOID*)(&pThis->m_pIConsole));
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
TRACE(_T("FAILED : pUnknown->QueryInterface for IID_IConsole2 failed.\n"));
|
|
return hr;
|
|
}
|
|
|
|
// Query for the Scope Pane ImageList Interface
|
|
pThis->m_pIImageList = NULL;
|
|
hr = pThis->m_pIConsole->QueryScopeImageList(&(pThis->m_pIImageList));
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
TRACE(_T("pUnknown->QueryScopeImageList failed.\n"));
|
|
return hr;
|
|
}
|
|
|
|
// Call OnCreate for derived classes. Base class implementation creates a new root scope pane item.
|
|
if( ! pThis->OnCreate() )
|
|
{
|
|
TRACE(_T("FAILED : CScopePane::OnCreate failed.\n"));
|
|
return E_FAIL;
|
|
}
|
|
|
|
// Hook the MMC top level window to intercept any window messages of interest
|
|
if( ! pThis->HookWindow() )
|
|
{
|
|
TRACE(_T("FAILED : Unable to hook MMC main window\n"));
|
|
return E_FAIL;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XComponentData::CreateComponent(
|
|
/* [out] */ LPCOMPONENT __RPC_FAR *ppComponent)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ComponentData)
|
|
|
|
TRACEX(_T("CScopePane::XComponentData::CreateComponent\n"));
|
|
TRACEARGn(ppComponent);
|
|
|
|
*ppComponent = pThis->OnCreateComponent();
|
|
|
|
if( ! CHECKPTR(*ppComponent,sizeof(IComponent)) )
|
|
{
|
|
TRACE(_T("FAILED : OnCreateComponent returns invalid pointer.\n"));
|
|
return E_FAIL;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XComponentData::Notify(
|
|
/* [in] */ LPDATAOBJECT lpDataObject,
|
|
/* [in] */ MMC_NOTIFY_TYPE event,
|
|
/* [in] */ LPARAM arg,
|
|
/* [in] */ LPARAM param)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ComponentData)
|
|
|
|
TRACEX(_T("CScopePane::XComponentData::Notify\n"));
|
|
TRACEARGn(lpDataObject);
|
|
TRACEARGn(event);
|
|
TRACEARGn(arg);
|
|
TRACEARGn(param);
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
switch( event )
|
|
{
|
|
case MMCN_BTN_CLICK: // toolbar button clicked
|
|
{
|
|
TRACE(_T("MMCN_BTN_CLICK received.\n"));
|
|
|
|
CSnapinDataObject* psdo = CSnapinDataObject::GetSnapinDataObject(lpDataObject);
|
|
|
|
if( ! CHECKOBJPTR(psdo,RUNTIME_CLASS(CSnapinDataObject),sizeof(CSnapinDataObject)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
if( psdo->GetItemType() == CCT_SCOPE )
|
|
{
|
|
CScopePaneItem* pItem = NULL;
|
|
if( ! psdo->GetItem(pItem) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ASSERT(pItem);
|
|
|
|
hr = pItem->OnBtnClick((MMC_CONSOLE_VERB)arg);
|
|
}
|
|
else if( psdo->GetItemType() == CCT_RESULT )
|
|
{
|
|
CResultsPaneItem* pItem = NULL;
|
|
if( ! psdo->GetItem(pItem) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ASSERT(pItem);
|
|
|
|
CResultsPaneView* pView = pItem->GetOwnerResultsView();
|
|
|
|
if( ! CHECKOBJPTR(pView,RUNTIME_CLASS(CResultsPaneView),sizeof(CResultsPaneView)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ASSERT(pView);
|
|
|
|
hr = pView->OnBtnClick(pItem,(MMC_CONSOLE_VERB)arg);
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case MMCN_CONTEXTHELP: // F1, Help Menu Item or Help Button selected
|
|
{
|
|
TRACE(_T("MMCN_CONTEXTHELP received.\n"));
|
|
|
|
CSnapinDataObject* psdo = CSnapinDataObject::GetSnapinDataObject(lpDataObject);
|
|
|
|
if( ! CHECKOBJPTR(psdo,RUNTIME_CLASS(CSnapinDataObject),sizeof(CSnapinDataObject)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
if( psdo->GetItemType() == CCT_SCOPE )
|
|
{
|
|
CScopePaneItem* pItem = NULL;
|
|
if( ! psdo->GetItem(pItem) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ASSERT(pItem);
|
|
|
|
hr = pItem->OnContextHelp();
|
|
}
|
|
else if( psdo->GetItemType() == CCT_RESULT )
|
|
{
|
|
CResultsPaneItem* pItem = NULL;
|
|
if( ! psdo->GetItem(pItem) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ASSERT(pItem);
|
|
|
|
CResultsPaneView* pView = pItem->GetOwnerResultsView();
|
|
|
|
if( ! CHECKOBJPTR(pView,RUNTIME_CLASS(CResultsPaneView),sizeof(CResultsPaneView)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ASSERT(pView);
|
|
|
|
hr = pView->OnContextHelp(pItem);
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case MMCN_DELETE: // delete selected
|
|
{
|
|
TRACE(_T("MMCN_DELETE received.\n"));
|
|
|
|
CSnapinDataObject* psdo = CSnapinDataObject::GetSnapinDataObject(lpDataObject);
|
|
|
|
if( ! CHECKOBJPTR(psdo,RUNTIME_CLASS(CSnapinDataObject),sizeof(CSnapinDataObject)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
if( psdo->GetItemType() == CCT_SCOPE )
|
|
{
|
|
CScopePaneItem* pItem = NULL;
|
|
if( ! psdo->GetItem(pItem) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ASSERT(pItem);
|
|
|
|
hr = pItem->OnDelete();
|
|
}
|
|
else if( psdo->GetItemType() == CCT_RESULT )
|
|
{
|
|
CResultsPaneItem* pItem = NULL;
|
|
if( ! psdo->GetItem(pItem) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ASSERT(pItem);
|
|
|
|
CResultsPaneView* pView = pItem->GetOwnerResultsView();
|
|
|
|
if( ! CHECKOBJPTR(pView,RUNTIME_CLASS(CResultsPaneView),sizeof(CResultsPaneView)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ASSERT(pView);
|
|
|
|
hr = pView->OnDelete(pItem);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case MMCN_EXPAND: // user clicks on a previously unexpanded node
|
|
{
|
|
TRACE(_T("MMCN_EXPAND received.\n"));
|
|
|
|
CSnapinDataObject* psdo = CSnapinDataObject::GetSnapinDataObject(lpDataObject);
|
|
|
|
if( ! CHECKOBJPTR(psdo,RUNTIME_CLASS(CSnapinDataObject),sizeof(CSnapinDataObject)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
if( psdo->GetItemType() == CCT_SCOPE )
|
|
{
|
|
CScopePaneItem* pItem = NULL;
|
|
if( ! psdo->GetItem(pItem) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ASSERT(pItem);
|
|
|
|
if( pItem == pThis->GetRootScopeItem() )
|
|
{
|
|
pItem->SetItemHandle((HSCOPEITEM)param);
|
|
}
|
|
|
|
hr = pItem->OnExpand((BOOL)arg);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case MMCN_PRELOAD:
|
|
{
|
|
TRACE(_T("MMCN_PRELOAD received.\n"));
|
|
TRACE(_T("MMCN_PRELOAD not implemented.\n"));
|
|
}
|
|
break;
|
|
|
|
case MMCN_PRINT:
|
|
{
|
|
TRACE(_T("MMCN_PRINT received.\n"));
|
|
TRACE(_T("MMCN_PRINT not implemented.\n"));
|
|
}
|
|
break;
|
|
|
|
case MMCN_PROPERTY_CHANGE:
|
|
{
|
|
TRACE(_T("MMCN_PROPERTY_CHANGE received.\n"));
|
|
TRACE(_T("MMCN_PROPERTY_CHANGE not implemented.\n"));
|
|
}
|
|
break;
|
|
|
|
case MMCN_REFRESH:
|
|
{
|
|
TRACE(_T("MMCN_REFRESH received.\n"));
|
|
|
|
CSnapinDataObject* psdo = CSnapinDataObject::GetSnapinDataObject(lpDataObject);
|
|
|
|
if( ! CHECKOBJPTR(psdo,RUNTIME_CLASS(CSnapinDataObject),sizeof(CSnapinDataObject)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
if( psdo->GetItemType() == CCT_SCOPE )
|
|
{
|
|
CScopePaneItem* pItem = NULL;
|
|
if( ! psdo->GetItem(pItem) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ASSERT(pItem);
|
|
|
|
hr = pItem->OnRefresh();
|
|
}
|
|
else if( psdo->GetItemType() == CCT_RESULT )
|
|
{
|
|
CResultsPaneItem* pItem = NULL;
|
|
if( ! psdo->GetItem(pItem) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ASSERT(pItem);
|
|
|
|
CResultsPaneView* pView = pItem->GetOwnerResultsView();
|
|
|
|
if( ! CHECKOBJPTR(pView,RUNTIME_CLASS(CResultsPaneView),sizeof(CResultsPaneView)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ASSERT(pView);
|
|
|
|
hr = pView->OnRefresh();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case MMCN_REMOVE_CHILDREN:
|
|
{
|
|
TRACE(_T("MMCN_REMOVE_CHILDREN received.\n"));
|
|
|
|
CSnapinDataObject* psdo = CSnapinDataObject::GetSnapinDataObject(lpDataObject);
|
|
|
|
if( ! CHECKOBJPTR(psdo,RUNTIME_CLASS(CSnapinDataObject),sizeof(CSnapinDataObject)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
if( psdo->GetItemType() == CCT_SCOPE )
|
|
{
|
|
CScopePaneItem* pItem = NULL;
|
|
if( ! psdo->GetItem(pItem) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ASSERT(pItem);
|
|
|
|
hr = pItem->OnRemoveChildren();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case MMCN_RENAME:
|
|
{
|
|
TRACE(_T("MMCN_RENAME received.\n"));
|
|
|
|
CSnapinDataObject* psdo = CSnapinDataObject::GetSnapinDataObject(lpDataObject);
|
|
|
|
if( ! CHECKOBJPTR(psdo,RUNTIME_CLASS(CSnapinDataObject),sizeof(CSnapinDataObject)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
if( psdo->GetItemType() == CCT_SCOPE )
|
|
{
|
|
CScopePaneItem* pItem = NULL;
|
|
if( ! psdo->GetItem(pItem) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ASSERT(pItem);
|
|
|
|
CString sNewName = (LPOLESTR)param;
|
|
|
|
hr = pItem->OnRename(sNewName);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XComponentData::Destroy(void)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ComponentData)
|
|
|
|
TRACEX(_T("CScopePane::XComponentData::Destroy\n"));
|
|
|
|
if( ! pThis->OnDestroy() )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XComponentData::QueryDataObject(
|
|
/* [in] */ MMC_COOKIE cookie,
|
|
/* [in] */ DATA_OBJECT_TYPES type,
|
|
/* [out] */ LPDATAOBJECT __RPC_FAR *ppDataObject)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ComponentData)
|
|
|
|
TRACEX(_T("CScopePane::XComponentData::QueryDataObject\n"));
|
|
TRACEARGn(cookie);
|
|
TRACEARGn(type);
|
|
TRACEARGn(ppDataObject);
|
|
|
|
HRESULT hr = S_OK;
|
|
CSnapinDataObject* pdoNew = NULL;
|
|
|
|
pdoNew = new CSnapinDataObject;
|
|
|
|
if( ! pdoNew )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
*ppDataObject = NULL;
|
|
TRACE(_T("Out of memory.\n"));
|
|
return hr;
|
|
}
|
|
|
|
*ppDataObject = (LPDATAOBJECT)pdoNew->GetInterface(&IID_IDataObject);
|
|
|
|
if( ! CHECKOBJPTR(pdoNew,RUNTIME_CLASS(CSnapinDataObject),sizeof(CSnapinDataObject)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
if( cookie )
|
|
{
|
|
CScopePaneItem* pItem = (CScopePaneItem*)cookie;
|
|
if( ! CHECKOBJPTR(pItem,RUNTIME_CLASS(CScopePaneItem),sizeof(CScopePaneItem)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
pdoNew->SetItem(pItem);
|
|
|
|
ASSERT(pdoNew->GetItemType() == CCT_SCOPE);
|
|
}
|
|
else // In this case the node is our root scope item, and was placed there for us by MMC.
|
|
{
|
|
pdoNew->SetItem( pThis->GetRootScopeItem() );
|
|
|
|
ASSERT(pdoNew->GetItemType() == CCT_SCOPE);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XComponentData::GetDisplayInfo(
|
|
/* [out][in] */ SCOPEDATAITEM __RPC_FAR *pScopeDataItem)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ComponentData)
|
|
|
|
TRACEX(_T("CScopePane::XComponentData::GetDisplayInfo\n"));
|
|
TRACEARGn(pScopeDataItem);
|
|
|
|
if( ! CHECKPTR(pScopeDataItem,sizeof(SCOPEDATAITEM)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
CScopePaneItem* pItem = NULL;
|
|
|
|
if( pScopeDataItem->lParam == 0L ) // cookie is NULL for Root Item
|
|
{
|
|
pItem = pThis->GetRootScopeItem();
|
|
}
|
|
else
|
|
{
|
|
pItem = (CScopePaneItem*)pScopeDataItem->lParam;
|
|
}
|
|
|
|
if( ! CHECKOBJPTR(pItem,RUNTIME_CLASS(CScopePaneItem),sizeof(CScopePaneItem)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
if( pScopeDataItem->mask & SDI_STR )
|
|
{
|
|
pScopeDataItem->displayname = (LPTSTR)(LPCTSTR)pItem->GetDisplayName();
|
|
}
|
|
|
|
if( pScopeDataItem->mask & SDI_IMAGE )
|
|
{
|
|
pScopeDataItem->nImage = pThis->AddIcon(pItem->GetIconId());
|
|
}
|
|
|
|
if( pScopeDataItem->mask & SDI_OPENIMAGE )
|
|
{
|
|
pScopeDataItem->nOpenImage = pThis->AddIcon(pItem->GetOpenIconId());
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XComponentData::CompareObjects(
|
|
/* [in] */ LPDATAOBJECT lpDataObjectA,
|
|
/* [in] */ LPDATAOBJECT lpDataObjectB)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ComponentData)
|
|
|
|
TRACEX(_T("CScopePane::XComponentData::CompareObjects\n"));
|
|
TRACEARGn(lpDataObjectA);
|
|
TRACEARGn(lpDataObjectB);
|
|
|
|
CSnapinDataObject* psmdo1 = CSnapinDataObject::GetSnapinDataObject(lpDataObjectA);
|
|
if( psmdo1 == NULL )
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
|
|
CSnapinDataObject* psmdo2 = CSnapinDataObject::GetSnapinDataObject(lpDataObjectB);
|
|
if( psmdo2 == NULL )
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
|
|
if( psmdo1->GetCookie() != psmdo2->GetCookie() )
|
|
return S_FALSE;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// IComponentData Interface Part
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// IPersistStream Interface Part
|
|
|
|
ULONG FAR EXPORT CScopePane::XPersistStream::AddRef()
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, PersistStream)
|
|
return pThis->ExternalAddRef();
|
|
}
|
|
|
|
ULONG FAR EXPORT CScopePane::XPersistStream::Release()
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, PersistStream)
|
|
return pThis->ExternalRelease();
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XPersistStream::QueryInterface(REFIID iid, void FAR* FAR* ppvObj)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, PersistStream)
|
|
return (HRESULT)pThis->ExternalQueryInterface(&iid, ppvObj);
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XPersistStream::GetClassID(
|
|
/* [out] */ CLSID __RPC_FAR *pClassID)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, PersistStream)
|
|
|
|
TRACEX(_T("CScopePane::XPersistStream::GetClassID\n"));
|
|
TRACEARGn(pClassID);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XPersistStream::IsDirty( void)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, PersistStream)
|
|
|
|
TRACEX(_T("CScopePane::XPersistStream::IsDirty\n"));
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XPersistStream::Load(
|
|
/* [unique][in] */ IStream __RPC_FAR *pStm)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, PersistStream)
|
|
|
|
TRACEX(_T("CScopePane::XPersistStream::Load\n"));
|
|
TRACEARGn(pStm);
|
|
|
|
COleStreamFile file;
|
|
file.Attach(pStm);
|
|
CArchive ar(&file,CArchive::load);
|
|
bool bResult = pThis->OnLoad(ar);
|
|
|
|
return bResult ? S_OK : E_FAIL;
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XPersistStream::Save(
|
|
/* [unique][in] */ IStream __RPC_FAR *pStm,
|
|
/* [in] */ BOOL fClearDirty)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, PersistStream)
|
|
|
|
TRACEX(_T("CScopePane::XPersistStream::Save\n"));
|
|
TRACEARGn(pStm);
|
|
TRACEARGn(fClearDirty);
|
|
|
|
COleStreamFile file;
|
|
file.Attach(pStm);
|
|
CArchive ar(&file,CArchive::store);
|
|
bool bResult = pThis->OnSave(ar);
|
|
|
|
return bResult ? S_OK : E_FAIL;
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XPersistStream::GetSizeMax(
|
|
/* [out] */ ULARGE_INTEGER __RPC_FAR *pcbSize)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, PersistStream)
|
|
|
|
TRACEX(_T("CScopePane::XPersistStream::GetSizeMax\n"));
|
|
TRACEARGn(pcbSize);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
// IPersistStream Interface Part
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// IExtendContextMenu Interface Part
|
|
|
|
ULONG FAR EXPORT CScopePane::XExtendContextMenu::AddRef()
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ExtendContextMenu)
|
|
return pThis->ExternalAddRef();
|
|
}
|
|
|
|
ULONG FAR EXPORT CScopePane::XExtendContextMenu::Release()
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ExtendContextMenu)
|
|
return pThis->ExternalRelease();
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XExtendContextMenu::QueryInterface(REFIID iid, void FAR* FAR* ppvObj)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ExtendContextMenu)
|
|
return (HRESULT)pThis->ExternalQueryInterface(&iid, ppvObj);
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XExtendContextMenu::AddMenuItems(
|
|
/* [in] */ LPDATAOBJECT piDataObject,
|
|
/* [in] */ LPCONTEXTMENUCALLBACK piCallback,
|
|
/* [out][in] */ long __RPC_FAR *pInsertionAllowed)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ExtendContextMenu)
|
|
|
|
TRACEX(_T("CScopePane::XExtendContextMenu::AddMenuItems\n"));
|
|
TRACEARGn(piDataObject);
|
|
TRACEARGn(piCallback);
|
|
TRACEARGn(pInsertionAllowed);
|
|
|
|
HRESULT hr = S_OK;
|
|
CSnapinDataObject* psdo = CSnapinDataObject::GetSnapinDataObject(piDataObject);
|
|
if( ! CHECKOBJPTR(psdo, RUNTIME_CLASS(CSnapinDataObject), sizeof(CSnapinDataObject)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
DATA_OBJECT_TYPES type = psdo->GetItemType();
|
|
if( type == CCT_SCOPE )
|
|
{
|
|
CScopePaneItem* pItem = NULL;
|
|
if( ! psdo->GetItem(pItem) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ASSERT(pItem);
|
|
|
|
hr = pItem->OnAddMenuItems(piCallback,pInsertionAllowed);
|
|
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
TRACE(_T("CScopePaneItem::OnAddMenuItems failed!\n"));
|
|
}
|
|
}
|
|
else if( type == CCT_RESULT )
|
|
{
|
|
CResultsPaneItem* pItem = NULL;
|
|
if( ! psdo->GetItem(pItem) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ASSERT(pItem);
|
|
|
|
CResultsPaneView* pView = pItem->GetOwnerResultsView();
|
|
|
|
if( ! CHECKOBJPTR(pView,RUNTIME_CLASS(CResultsPaneView),sizeof(CResultsPaneView)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
hr = pView->OnAddMenuItems(pItem,piCallback,pInsertionAllowed);
|
|
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
TRACE(_T("CResultsPaneView::OnAddMenuItems failed!\n"));
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XExtendContextMenu::Command(
|
|
/* [in] */ long lCommandID,
|
|
/* [in] */ LPDATAOBJECT piDataObject)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ExtendContextMenu)
|
|
|
|
TRACEX(_T("CScopePane::XExtendContextMenu::Command\n"));
|
|
TRACEARGn(lCommandID);
|
|
TRACEARGn(piDataObject);
|
|
|
|
HRESULT hr = S_OK;
|
|
CSnapinDataObject* psdo = CSnapinDataObject::GetSnapinDataObject(piDataObject);
|
|
if( ! CHECKOBJPTR(psdo, RUNTIME_CLASS(CSnapinDataObject), sizeof(CSnapinDataObject)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
DATA_OBJECT_TYPES type = psdo->GetItemType();
|
|
if( type == CCT_SCOPE )
|
|
{
|
|
CScopePaneItem* pItem = NULL;
|
|
if( ! psdo->GetItem(pItem) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ASSERT(pItem);
|
|
|
|
hr = pItem->OnCommand(lCommandID);
|
|
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
TRACE(_T("CScopePaneItem::OnCommand failed!\n"));
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
// IExtendContextMenu Interface Part
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// IExtendPropertySheet2 Interface Part
|
|
|
|
ULONG FAR EXPORT CScopePane::XExtendPropertySheet2::AddRef()
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ExtendPropertySheet2)
|
|
return pThis->ExternalAddRef();
|
|
}
|
|
|
|
ULONG FAR EXPORT CScopePane::XExtendPropertySheet2::Release()
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ExtendPropertySheet2)
|
|
return pThis->ExternalRelease();
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XExtendPropertySheet2::QueryInterface(REFIID iid, void FAR* FAR* ppvObj)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ExtendPropertySheet2)
|
|
return (HRESULT)pThis->ExternalQueryInterface(&iid, ppvObj);
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XExtendPropertySheet2::CreatePropertyPages(
|
|
/* [in] */ LPPROPERTYSHEETCALLBACK lpProvider,
|
|
/* [in] */ LONG_PTR handle,
|
|
/* [in] */ LPDATAOBJECT lpIDataObject)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ExtendPropertySheet2)
|
|
|
|
TRACEX(_T("CScopePane::XExtendPropertySheet2::CreatePropertyPages\n"));
|
|
TRACEARGn(lpProvider);
|
|
TRACEARGn(handle);
|
|
TRACEARGn(lpIDataObject);
|
|
|
|
HRESULT hr = S_FALSE;
|
|
CSnapinDataObject* psdo = CSnapinDataObject::GetSnapinDataObject(lpIDataObject);
|
|
if( ! CHECKOBJPTR(psdo, RUNTIME_CLASS(CSnapinDataObject), sizeof(CSnapinDataObject)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
DATA_OBJECT_TYPES type = psdo->GetItemType();
|
|
|
|
if( type == CCT_SCOPE )
|
|
{
|
|
CScopePaneItem* pItem = NULL;
|
|
|
|
if( ! psdo->GetItem(pItem) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ASSERT(pItem);
|
|
ASSERT_VALID(pItem);
|
|
|
|
hr = pItem->OnCreatePropertyPages(lpProvider,handle);
|
|
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
TRACE(_T("CScopePaneItem::OnCreatePropertyPages failed!\n"));
|
|
}
|
|
}
|
|
else if( type == CCT_RESULT )
|
|
{
|
|
CResultsPaneItem* pItem = NULL;
|
|
|
|
if( ! psdo->GetItem(pItem) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
ASSERT(pItem);
|
|
ASSERT_VALID(pItem);
|
|
|
|
CResultsPaneView* pView = pItem->GetOwnerResultsView();
|
|
|
|
if( ! CHECKOBJPTR(pView,RUNTIME_CLASS(CResultsPaneView),sizeof(CResultsPaneView)) )
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
hr = pView->OnCreatePropertyPages(pItem,lpProvider,handle);
|
|
if( ! CHECKHRESULT(hr) )
|
|
{
|
|
TRACE(_T("CResultsPaneView::OnCreatePropertyPages failed!\n"));
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XExtendPropertySheet2::QueryPagesFor(
|
|
/* [in] */ LPDATAOBJECT lpDataObject)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ExtendPropertySheet2)
|
|
|
|
TRACEX(_T("CScopePane::XExtendPropertySheet2::QueryPagesFor\n"));
|
|
TRACEARGn(lpDataObject);
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XExtendPropertySheet2::GetWatermarks(
|
|
/* [in] */ LPDATAOBJECT lpIDataObject,
|
|
/* [out] */ HBITMAP __RPC_FAR *lphWatermark,
|
|
/* [out] */ HBITMAP __RPC_FAR *lphHeader,
|
|
/* [out] */ HPALETTE __RPC_FAR *lphPalette,
|
|
/* [out] */ BOOL __RPC_FAR *bStretch)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, ExtendPropertySheet2)
|
|
|
|
TRACEX(_T("CScopePane::XExtendPropertySheet2::GetWatermarks\n"));
|
|
TRACEARGn(lpIDataObject);
|
|
TRACEARGn(lphWatermark);
|
|
TRACEARGn(lphHeader);
|
|
TRACEARGn(lphPalette);
|
|
TRACEARGn(bStretch);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// IExtendPropertySheet2 Interface Part
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// ISnapinHelp Interface Part
|
|
|
|
ULONG FAR EXPORT CScopePane::XSnapinHelp::AddRef()
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, SnapinHelp)
|
|
return pThis->ExternalAddRef();
|
|
}
|
|
|
|
ULONG FAR EXPORT CScopePane::XSnapinHelp::Release()
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, SnapinHelp)
|
|
return pThis->ExternalRelease();
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XSnapinHelp::QueryInterface(REFIID iid, void FAR* FAR* ppvObj)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, SnapinHelp)
|
|
return (HRESULT)pThis->ExternalQueryInterface(&iid, ppvObj);
|
|
}
|
|
|
|
HRESULT FAR EXPORT CScopePane::XSnapinHelp::GetHelpTopic(
|
|
/* [out] */ LPOLESTR __RPC_FAR *lpCompiledHelpFile)
|
|
{
|
|
METHOD_PROLOGUE(CScopePane, SnapinHelp)
|
|
|
|
TRACEX(_T("CScopePane::XSnapinHelp::GetHelpTopic\n"));
|
|
TRACEARGn(lpCompiledHelpFile);
|
|
|
|
CString sHTMLHelpFilePath = AfxGetApp()->m_pszHelpFilePath;
|
|
*lpCompiledHelpFile = reinterpret_cast<LPOLESTR>(CoTaskMemAlloc((sHTMLHelpFilePath.GetLength() + 1)* sizeof(wchar_t)));
|
|
if (*lpCompiledHelpFile == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
_tcscpy(*lpCompiledHelpFile, (LPCTSTR)sHTMLHelpFilePath);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// ISnapinHelp Interface Part
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CScopePane message handlers
|
|
|
|
|