mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
847 lines
25 KiB
847 lines
25 KiB
/*======================================================================================//
|
|
| Process Control //
|
|
| //
|
|
|Copyright (c) 1998 Sequent Computer Systems, Incorporated. All rights reserved. //
|
|
| //
|
|
|File Name: ComponentData.cpp //
|
|
| //
|
|
|Description: //
|
|
| //
|
|
|Created: Paul Skoglund 07-1998 //
|
|
| //
|
|
|Rev History: //
|
|
| //
|
|
|=======================================================================================*/
|
|
#include "StdAfx.h"
|
|
#include "ProcCon.h"
|
|
#include "Component.h"
|
|
|
|
#include "DataObj.h"
|
|
|
|
#include "BaseNode.h"
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CComponentData - This class is the interface to handle anything to do
|
|
// with the scope pane. MMC calls the IComponent interfaces.
|
|
// This class keeps a few pointers to interfaces that MMC
|
|
// implements.
|
|
|
|
CComponentData::CComponentData() : m_Initialized(FALSE)
|
|
{
|
|
ATLTRACE( _T("ComponentData::ComponentData()\n") );
|
|
m_ipConsoleNameSpace2 = NULL;
|
|
m_ipConsole2 = NULL;
|
|
m_hbmpSNodes16 = NULL;
|
|
m_hbmpSNodes32 = NULL;
|
|
m_ipScopeImage = NULL;
|
|
|
|
m_hWatermark1 = NULL;
|
|
m_hHeader1 = NULL;
|
|
|
|
#if USE_WIZARD97_WATERMARKS
|
|
// Load the bitmaps for property sheet watermark and headers
|
|
m_hWatermark1 = ::LoadBitmap(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDB_WATERMARK1));
|
|
ASSERT( m_hWatermark1 );
|
|
#endif
|
|
#if USE_WIZARD97_HEADERS
|
|
m_hHeader1 = ::LoadBitmap(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDB_HEADER1));
|
|
ASSERT( m_hHeader1 );
|
|
#endif
|
|
|
|
// this needs to be dynamic/per instance because our snap-in can be added multiple times to the same console
|
|
m_ptrRootNode = new CRootFolder();
|
|
}
|
|
|
|
CComponentData::~CComponentData()
|
|
{
|
|
// We release the cached interface pointers in Destroy()
|
|
ATLTRACE( _T("ComponentData::~ComponentData()\n") );
|
|
|
|
SAFE_RELEASE( m_ptrRootNode );
|
|
|
|
if( NULL != m_hWatermark1 )
|
|
::DeleteObject( m_hWatermark1 );
|
|
|
|
if( NULL != m_hHeader1 )
|
|
::DeleteObject( m_hHeader1);
|
|
|
|
ATLTRACE( _T("ComponentData::~ComponentData() The End\n\n") );
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// IComponentData methods
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
// We get here only once, when the user clicks on the snapin.
|
|
//
|
|
// This method should not change as we progress through further steps.
|
|
// Here we get a chance to get pointer to some interfaces MMC provides.
|
|
// We QueryInterface for pointers to the name space and console, which
|
|
// we cache in local variables
|
|
// The other task to acomplish here is the adding of a bitmap that contains
|
|
// the icons to be used in the scope pane.
|
|
//
|
|
STDMETHODIMP CComponentData::Initialize
|
|
(
|
|
LPUNKNOWN pUnknown // [in] Pointer to the IConsole’s IUnknown interface
|
|
)
|
|
{
|
|
ATLTRACE( _T("ComponentData::Initialize()\n") );
|
|
ASSERT( NULL != pUnknown );
|
|
|
|
if (!m_ptrRootNode)
|
|
{
|
|
ATLTRACE( _T(" ComponentData::Initialize() Failed - no root node!\n"));
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
ATLTRACE( _T(" RootFolder <%s>\n"), m_ptrRootNode->GetNodeName() );
|
|
|
|
// MMC should only call ::Initialize once!
|
|
ASSERT( NULL == m_ipConsoleNameSpace2 );
|
|
|
|
if (!pUnknown)
|
|
return E_UNEXPECTED;
|
|
|
|
HRESULT hr;
|
|
|
|
hr = pUnknown->QueryInterface(IID_IConsoleNameSpace2, (VOID**)(&m_ipConsoleNameSpace2));
|
|
ASSERT( S_OK == hr );
|
|
|
|
hr = pUnknown->QueryInterface(IID_IConsole2, (VOID**)(&m_ipConsole2));
|
|
ASSERT( S_OK == hr );
|
|
|
|
if (m_ipConsole2)
|
|
{
|
|
hr = m_ipConsole2->QueryScopeImageList(&m_ipScopeImage);
|
|
ASSERT( S_OK == hr );
|
|
}
|
|
|
|
// Load the bitmaps from the dll
|
|
m_hbmpSNodes16 = LoadBitmap(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDB_NODES_16x16));
|
|
ASSERT( NULL != m_hbmpSNodes16 );
|
|
|
|
m_hbmpSNodes32 = LoadBitmap(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDB_NODES_32x32));
|
|
ASSERT( NULL != m_hbmpSNodes32 );
|
|
|
|
// Set the images
|
|
if (m_ipScopeImage)
|
|
{
|
|
hr = m_ipScopeImage->ImageListSetStrip( (LONG_PTR *) m_hbmpSNodes16,
|
|
(LONG_PTR *) m_hbmpSNodes32,
|
|
0,
|
|
RGB(255, 0, 255)
|
|
);
|
|
ASSERT( S_OK == hr );
|
|
}
|
|
|
|
if (hr == S_OK && m_ipConsoleNameSpace2 && m_ipConsole2 && m_ipScopeImage && m_hbmpSNodes16 && m_hbmpSNodes32)
|
|
m_Initialized = TRUE;
|
|
else if (hr == S_OK)
|
|
hr = E_UNEXPECTED;
|
|
|
|
ATLTRACE( _T(" ComponentData::Initialize() <%s>\n"), m_Initialized ? _T("Succeeded") : _T("Failed"));
|
|
|
|
m_ptrRootNode->SetConsoleInterface(m_ipConsole2);
|
|
|
|
return S_OK;
|
|
|
|
} // end Initialize()
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Release interfaces and clean up objects which allocated memory
|
|
//
|
|
STDMETHODIMP CComponentData::Destroy()
|
|
{
|
|
ATLTRACE( _T("ComponentData::Destroy()\n") );
|
|
|
|
if (m_ptrRootNode)
|
|
m_ptrRootNode->SetConsoleInterface(NULL);
|
|
|
|
// Free interfaces
|
|
SAFE_RELEASE(m_ipConsoleNameSpace2);
|
|
SAFE_RELEASE(m_ipConsole2);
|
|
SAFE_RELEASE(m_ipScopeImage);
|
|
|
|
VERIFY( ::DeleteObject( m_hbmpSNodes16 ) );
|
|
VERIFY( ::DeleteObject( m_hbmpSNodes32 ) );
|
|
|
|
return S_OK;
|
|
|
|
} // end Destroy()
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Come in here once right after Initialize. MMC wants a pointer to the
|
|
// IComponent interface.
|
|
//
|
|
STDMETHODIMP CComponentData::CreateComponent
|
|
(
|
|
LPCOMPONENT* ppComponent // [out] Pointer to the location that stores
|
|
) // the newly created pointer to IComponent
|
|
{
|
|
ATLTRACE( _T("ComponentData::CreateComponent()\n") );
|
|
|
|
if (!m_Initialized)
|
|
return E_UNEXPECTED;
|
|
|
|
ASSERT( NULL != ppComponent );
|
|
|
|
CComObject<CComponent>* pObject;
|
|
CComObject<CComponent>::CreateInstance( &pObject );
|
|
|
|
ASSERT( NULL != pObject );
|
|
if (!pObject)
|
|
return E_UNEXPECTED;
|
|
|
|
pObject->SetComponentData( this );
|
|
|
|
return pObject->QueryInterface( IID_IComponent, reinterpret_cast<void**>(ppComponent) );
|
|
} // end CreateComponent()
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
STDMETHODIMP CComponentData::Notify
|
|
(
|
|
LPDATAOBJECT ipDataObject, // [in] Points to the selected data object
|
|
MMC_NOTIFY_TYPE Event, // [in] Identifies action taken by user.
|
|
LPARAM Arg, // [in] Depends on the notification type
|
|
LPARAM Param // [in] Depends on the notification type
|
|
)
|
|
{
|
|
ATLTRACE( _T("ComponentData::Notify %p 0x%X %p %p\n"), ipDataObject, Event, Arg, Param );
|
|
|
|
HRESULT hr = S_FALSE;
|
|
|
|
switch( Event )
|
|
{
|
|
// documented IComponentData::Notify Event
|
|
case MMCN_EXPAND:
|
|
{
|
|
CBaseNode *pNode = ExtractBaseObject(ipDataObject);
|
|
if (pNode)
|
|
{
|
|
ATLTRACE(_T("ComponentData::Notify MMCN_EXPAND (%s) %s \n"), ((BOOL) Arg) ? _T("expand") : _T("collapse"), pNode->GetNodeName());
|
|
hr = pNode->OnExpand( (BOOL) Arg, Param, m_ipConsoleNameSpace2 );
|
|
}
|
|
else
|
|
{
|
|
ATLTRACE(_T("ComponentData::Notify MMCN_EXPAND (%s)\n"), ((BOOL) Arg) ? _T("expand") : _T("collapse"));
|
|
static UINT s_cfMachineName = ::RegisterClipboardFormat(_T("MMC_SNAPIN_MACHINE_NAME"));
|
|
|
|
FORMATETC fmt = { (CLIPFORMAT) s_cfMachineName, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
|
|
STGMEDIUM stgmedium = { TYMED_HGLOBAL, NULL };
|
|
|
|
stgmedium.hGlobal = GlobalAlloc( GMEM_SHARE, SNAPIN_MAX_COMPUTERNAME_LENGTH + 1 );
|
|
if (stgmedium.hGlobal)
|
|
{
|
|
if (S_OK == ipDataObject->GetDataHere(&fmt, &stgmedium) &&
|
|
m_ptrRootNode)
|
|
{
|
|
m_ptrRootNode->SetComputerName((TCHAR *)stgmedium.hGlobal);
|
|
hr = m_ptrRootNode->OnParentExpand( (BOOL) Arg, Param, m_ipConsoleNameSpace2 );
|
|
}
|
|
GlobalFree(stgmedium.hGlobal);
|
|
}
|
|
/*
|
|
HRESULT res = ipDataObject->QueryGetData(&fmt);
|
|
ATLTRACE(_T(" QueryData 0x%p\n"), res);
|
|
if (res == S_OK)
|
|
{
|
|
int x = 9;
|
|
}
|
|
|
|
IEnumFORMATETC *ipEnumFORMATETC = 0;
|
|
HRESULT res = ipDataObject->EnumFormatEtc(DATADIR_GET, &ipEnumFORMATETC);
|
|
if (res == S_OK && ipEnumFORMATETC)
|
|
{
|
|
ULONG out = 0;
|
|
FORMATETC aFormat;
|
|
res = ipEnumFORMATETC->Next(1, &aFormat, &out);
|
|
while (res == S_OK && out == 1)
|
|
{
|
|
const CLIPFORMAT cf = aFormat.cfFormat;
|
|
out = 0;
|
|
_TCHAR szFormatName[246];
|
|
if (!GetClipboardFormatName(cf, szFormatName, ARRAY_SIZE(szFormatName)))
|
|
_tcscpy(szFormatName, _T("Unknown format") );
|
|
ATLTRACE(_T(" %s\n"), szFormatName);
|
|
res = ipEnumFORMATETC->Next(1, &aFormat, &out);
|
|
}
|
|
ipEnumFORMATETC->Release();
|
|
}
|
|
*/
|
|
}
|
|
}
|
|
break;
|
|
|
|
// documented IComponentData::Notify Event (documented under Event but not Notify method)
|
|
case MMCN_REMOVE_CHILDREN:
|
|
{
|
|
CBaseNode *pNode = ExtractBaseObject(ipDataObject);
|
|
if (pNode) // it "our" node call the specific handler
|
|
{
|
|
ATLTRACE(_T("ComponentData::Notify MMCN_REMOVE_CHILDREN %s\n"), pNode->GetNodeName());
|
|
hr = pNode->OnRemoveChildren( Arg );
|
|
}
|
|
else if (m_ptrRootNode) // extension--the data object is "our" parent
|
|
{
|
|
ATLTRACE(_T("ComponentData::Notify MMCN_REMOVE_CHILDREN -- extension\n"));
|
|
hr = m_ptrRootNode->OnParentRemoveChildren( Arg );
|
|
}
|
|
else
|
|
{
|
|
ATLTRACE(_T("ComponentData::Notify MMCN_REMOVE_CHILDREN -- unexpected\n"));
|
|
hr = E_UNEXPECTED;
|
|
}
|
|
}
|
|
break;
|
|
|
|
// documented IComponentData::Notify Event
|
|
case MMCN_PROPERTY_CHANGE:
|
|
ATLTRACE(_T("ComponentData::Notify MMCN_PROPERTY_CHANGE \n"));
|
|
hr = OnPropertyChange( (BOOL) Arg, Param);
|
|
break;
|
|
|
|
case MMCN_HELP:
|
|
// supposively NOT USED by MMC
|
|
ATLTRACE( _T("ComponentData::Notify MMCN_HELP unimplemented\n") );
|
|
hr = S_FALSE;
|
|
break;
|
|
|
|
case MMCN_SNAPINHELP:
|
|
ATLTRACE( _T("ComponentData::Notify MMCN_SNAPINHELP unimplemented\n") );
|
|
hr = S_FALSE;
|
|
break;
|
|
|
|
case MMCN_CONTEXTHELP:
|
|
ATLTRACE( _T("ComponentData::Notify MMCN_CONTEXTHELP unimplemented\n") );
|
|
hr = S_FALSE;
|
|
break;
|
|
|
|
case MMCN_EXPANDSYNC:
|
|
{
|
|
CBaseNode *pNode = ExtractBaseObject(ipDataObject);
|
|
ASSERT(pNode);
|
|
if (!pNode)
|
|
return E_UNEXPECTED;
|
|
ATLTRACE( _T("ComponentData::Notify MMCN_EXPANDSYNC %s unimplemented\n"), pNode->GetNodeName() );
|
|
MMC_EXPANDSYNC_STRUCT *info = (MMC_EXPANDSYNC_STRUCT *) Param;
|
|
hr = S_FALSE;
|
|
}
|
|
break;
|
|
|
|
case MMCN_DELETE: // - shouldn't see
|
|
ATLTRACE( _T("ComponentData::Notify MMCN_DELETE unimplemented\n") );
|
|
hr = S_FALSE;
|
|
break;
|
|
|
|
/*
|
|
// not seeing any of the NOTIFY events below/add as needed
|
|
|
|
// NOT documented as a IComponentData::Notify Event
|
|
case MMCN_REFRESH:
|
|
ATLTRACE( _T("ComponentData::Notify MMCN_REFRESH unimplemented\n") );
|
|
break;
|
|
|
|
// CCF_SNAPIN_PRELOADS format specific
|
|
case MMCN_PRELOAD:
|
|
ATLTRACE( _T("ComponentData::Notify MMCN_PRELAOD unimplemented\n") );
|
|
break;
|
|
|
|
// documented IComponentData::Notify Event
|
|
case MMCN_RENAME: // - shouldn't see
|
|
ATLTRACE( _T("ComponentData::Notify MMCN_RENAME unimplemented\n") );
|
|
hr = S_FALSE;
|
|
break;
|
|
|
|
case MMCN_DELETE: // - shouldn't see
|
|
ATLTRACE( _T("ComponentData::Notify MMCN_DELETE unimplemented\n") );
|
|
hr = S_FALSE;
|
|
break;
|
|
|
|
case MMCN_BTN_CLICK:
|
|
case MMCN_CONTEXTHELP:
|
|
case MMCN_CUTORMOVE:
|
|
case MMCN_QUERY_PASTE:
|
|
case MMCN_PASTE:
|
|
case MMCN_PRINT:
|
|
*/
|
|
|
|
default:
|
|
ATLTRACE(_T("ComponentData::NOTIFY unhandled notify event 0x%X\n"), Event);
|
|
hr = S_FALSE;
|
|
break;
|
|
}
|
|
return hr;
|
|
|
|
} // end Notify()
|
|
|
|
//---------------------------------------------------------------------------
|
|
// MMCN_PROPERTY_CHANGE notification
|
|
//
|
|
HRESULT CComponentData::OnPropertyChange
|
|
(
|
|
BOOL bScopeItem,
|
|
LPARAM Param
|
|
)
|
|
{
|
|
if (!bScopeItem)
|
|
{
|
|
ASSERT(FALSE); // what is this path being used by?
|
|
return S_OK;
|
|
}
|
|
|
|
PROPERTY_CHANGE_HDR *pUpdate = reinterpret_cast<PROPERTY_CHANGE_HDR*>(Param);
|
|
|
|
if (pUpdate)
|
|
{
|
|
if (pUpdate->pFolder && pUpdate->bScopeItem)
|
|
pUpdate->pFolder->OnPropertyChange(pUpdate, m_ipConsole2);
|
|
|
|
pUpdate = FreePropChangeInfo(pUpdate);
|
|
}
|
|
|
|
return S_OK;
|
|
|
|
} // end OnPropertyChange()
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// This is where MMC asks us to provide IDataObjects for every node in the
|
|
// scope pane. We have to QI the object so it gets AddRef'd. The node
|
|
// manager handles deleting the objects.
|
|
//
|
|
STDMETHODIMP CComponentData::QueryDataObject
|
|
(
|
|
MMC_COOKIE Cookie, // [in] Data object's unique identifier
|
|
DATA_OBJECT_TYPES Context, // [in] Data object's type
|
|
LPDATAOBJECT* ppDataObject // [out] Points to the returned data object
|
|
)
|
|
{
|
|
// check for magic multi-select cookie
|
|
if (IS_SPECIAL_COOKIE(Cookie) )
|
|
{
|
|
if (Cookie == MMC_MULTI_SELECT_COOKIE)
|
|
ATLTRACE( _T("ComponentData::QueryDataObject: MMC_MULTI_SELECT_COOKIE unimplemented\n") );
|
|
else
|
|
ATLTRACE( _T("ComponentData::QueryDataObject: special cookie 0x%X unimplemented\n"), Cookie );
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
ATLTRACE( _T("ComponentData::QueryDataObject\n") );
|
|
|
|
ASSERT( CCT_SCOPE == Context || // Must have a context
|
|
CCT_RESULT == Context || // we understand
|
|
CCT_SNAPIN_MANAGER == Context
|
|
);
|
|
|
|
if (CCT_SNAPIN_MANAGER == Context ||
|
|
CCT_SCOPE == Context)
|
|
{
|
|
|
|
CComObject<CDataObject>* pDataObj;
|
|
CComObject<CDataObject>::CreateInstance( &pDataObj );
|
|
if( ! pDataObj ) // DataObject was not created
|
|
{
|
|
ASSERT(pDataObj);
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
CBaseNode *pFolder;
|
|
|
|
if (Cookie == NULL)
|
|
{
|
|
ASSERT(m_ptrRootNode);
|
|
pFolder = m_ptrRootNode;
|
|
}
|
|
else
|
|
{
|
|
pFolder = reinterpret_cast<CBaseNode *> (Cookie);
|
|
}
|
|
|
|
// ATLTRACE( _T("%s-ComponentData::QueryDataObject: %s\n"), pFolder->GetNodeName(), (Context == CCT_SCOPE) ? _T("CCT_SCOPE") : _T("CCT_SNAPIN_MANAGER") );
|
|
|
|
pDataObj->SetDataObject( Context, pFolder );
|
|
|
|
HRESULT hr = pDataObj->QueryInterface( IID_IDataObject,
|
|
reinterpret_cast<void**>(ppDataObject)
|
|
);
|
|
|
|
return hr;
|
|
|
|
}
|
|
else if (CCT_RESULT == Context)
|
|
{
|
|
// ATLTRACE( _T("ComponentData::QueryDataObject: CCT_RESULT unsupported\n") );
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
// CCT_UNINITIALIZED
|
|
// ATLTRACE( _T("ComponentData::QueryDataObject: unsupported Context\n") );
|
|
return E_UNEXPECTED;
|
|
} // end QueryDataObject()
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// This is where we provide strings for nodes in the scope pane.
|
|
// MMC handles the root node string.
|
|
//
|
|
STDMETHODIMP CComponentData::GetDisplayInfo
|
|
(
|
|
LPSCOPEDATAITEM pItem // [in, out] Points to a SCOPEDATAITEM struct
|
|
)
|
|
{
|
|
ASSERT( NULL != pItem );
|
|
HRESULT hr = S_OK;
|
|
|
|
if (!pItem->mask) // doesn't need anything
|
|
return S_OK;
|
|
|
|
// the SDI_PARAM flag does not have to be set on input to indicate that the LPARAM is valid
|
|
//if (! (pItem->mask & SDI_PARAM) )
|
|
// return E_UNEXPECTED;
|
|
|
|
//ASSERT( pItem->lParam);
|
|
// get object from SCOPEITEM's lParam
|
|
|
|
CBaseNode *pTmp = NULL;
|
|
|
|
if (pItem->lParam)
|
|
pTmp = reinterpret_cast<CBaseNode *>(pItem->lParam);
|
|
else
|
|
pTmp = dynamic_cast<CBaseNode *>(m_ptrRootNode);
|
|
|
|
// this should never be called with the root node,
|
|
// all scope items with lParam pointer to object derived from CBaseNode
|
|
if (!pTmp)
|
|
return E_UNEXPECTED;
|
|
|
|
if ( pItem->mask & SDI_STR ) // wants the display name
|
|
{
|
|
pItem->displayname = const_cast<LPOLESTR>( pTmp->GetNodeName() );
|
|
}
|
|
if (pItem->mask & SDI_IMAGE)
|
|
{
|
|
pItem->nImage = pTmp->sImage();
|
|
}
|
|
if (pItem->mask & SDI_OPENIMAGE)
|
|
{
|
|
pItem->nOpenImage = pTmp->sOpenImage();
|
|
}
|
|
|
|
return hr;
|
|
|
|
} // end GetDisplayInfo()
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
STDMETHODIMP CComponentData::CompareObjects
|
|
(
|
|
LPDATAOBJECT ipDataObjectA, // [in] First data object to compare
|
|
LPDATAOBJECT ipDataObjectB // [in] Second data object to compare
|
|
)
|
|
{
|
|
CBaseNode *pdoA;
|
|
CBaseNode *pdoB;
|
|
|
|
pdoA = ExtractBaseObject( ipDataObjectA );
|
|
pdoB = ExtractBaseObject( ipDataObjectB );
|
|
|
|
ASSERT( pdoA || pdoB );
|
|
|
|
// If extraction failed for one of them, then that one is foreign and
|
|
// can't be equal to the other one. (Or else ExtractOwnDataObject
|
|
// returned NULL because it ran out of memory, but the most conservative
|
|
// thing to do in that case is say they're not equal.)
|
|
if( !pdoA || !pdoB )
|
|
{
|
|
ATLTRACE(_T("ComponentData::CompareObjects() - FALSE one or both objects not recognized\n") );
|
|
return S_FALSE;
|
|
}
|
|
|
|
// If they have "our" same node type
|
|
if( pdoA->GetNodeType() == pdoB->GetNodeType() )
|
|
{
|
|
ATLTRACE(_T("ComponentData::CompareObjects() - TRUE\n") );
|
|
return S_OK;
|
|
}
|
|
|
|
ATLTRACE(_T("ComponentData::CompareObjects() - FALSE\n") );
|
|
return S_FALSE;
|
|
|
|
} // end CompareObjects()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// IExtendContextMenu method implementations
|
|
//
|
|
STDMETHODIMP CComponentData::AddMenuItems
|
|
(
|
|
LPDATAOBJECT ipDataObject, // [in] Points to data object
|
|
LPCONTEXTMENUCALLBACK piCallback, // [in] Pointer to IContextMenuCallback
|
|
long* pInsertionAllowed // [in,out] Insertion flags
|
|
)
|
|
{
|
|
ASSERT( NULL != ipDataObject );
|
|
HRESULT hr = S_OK;
|
|
|
|
if (IsMMCMultiSelectDataObject(ipDataObject))
|
|
return E_UNEXPECTED;
|
|
|
|
CBaseNode *pNode = ExtractBaseObject( ipDataObject );
|
|
|
|
if (!pNode)
|
|
return E_UNEXPECTED;
|
|
|
|
return pNode->AddMenuItems(piCallback, pInsertionAllowed);
|
|
|
|
} // end AddMenuItems()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// IExtendContextMenu method implementations
|
|
//
|
|
STDMETHODIMP CComponentData::Command
|
|
(
|
|
long nCommandID, // [in] Command to handle
|
|
LPDATAOBJECT ipDataObject // [in] Points to data object
|
|
)
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
|
|
CDataObject *pDO = ExtractOwnDataObject( ipDataObject );
|
|
CBaseNode *pNode = ExtractBaseObject( ipDataObject );
|
|
ASSERT(pDO);
|
|
if (!pDO || !pNode)
|
|
return hr;
|
|
|
|
// $$ not a desireable action to take but if this isn't done
|
|
// the context menu for a node can be operated on, and the result pane doesn't reflect the
|
|
// changes because the scope node selection wasn't changed when the context menu is obtained for
|
|
// a different node.
|
|
// i.e.
|
|
// Processes scope node is selected,
|
|
// right click on root node get a context menu (for the root node) and connect to a different computer
|
|
// the system still shows the processes scope node selected and the result pane shows the
|
|
// list of processes on the machine previously connected!
|
|
m_ipConsole2->SelectScopeItem(pNode->GetID());
|
|
|
|
/*
|
|
{
|
|
ATLTRACE( _T("Attempt patch of framework!\n"));
|
|
//OnShow(ipDataObject, TRUE, pNode->GetID());
|
|
m_ipConsole2->SelectScopeItem(pNode->GetID());
|
|
}
|
|
*/
|
|
|
|
CJobItemFolder *pJobItemFolder = dynamic_cast<CJobItemFolder *> (pNode);
|
|
|
|
if (pJobItemFolder)
|
|
hr = pJobItemFolder->OnMenuCommand(m_ipConsole2, m_ipConsoleNameSpace2, nCommandID );
|
|
else
|
|
hr = pNode->OnMenuCommand(m_ipConsole2, nCommandID );
|
|
if (hr == S_OK)
|
|
return hr;
|
|
|
|
ATLTRACE(_T("ComponentData::Command - unrecognized or failed command %d\n"), nCommandID);
|
|
|
|
return hr;
|
|
|
|
} // end Command()
|
|
|
|
|
|
STDMETHODIMP CComponentData::GetWatermarks
|
|
(
|
|
LPDATAOBJECT ipDataObject,
|
|
HBITMAP *lphWatermark,
|
|
HBITMAP * lphHeader,
|
|
HPALETTE * lphPalette,
|
|
BOOL* bStretch
|
|
)
|
|
{
|
|
// invoked during addition of snapin
|
|
// may be called prior to Initialize() method like
|
|
// IComponentData::QueryDataObject() with CCT_SNAPIN_MANAGER context
|
|
|
|
// note this may return NULL handles for watermark and header...this is suppose to be OK
|
|
// see use of USE_WIZARD97_ precompiled headers
|
|
|
|
// 10/8/1998 with MMC 1.1 RC4
|
|
// MMC is calling this method with lphWatermark equal to IDataObject address
|
|
// if we store anything at the addresss we corrupt the IDataObject,
|
|
// MMC then calls another method with corrupt IDataObject (CreatePropertyPages()) and boom
|
|
// access violation!
|
|
// report to Microsoft Derek Jacoby (10/8/1998)
|
|
//
|
|
// 10/10/1998 Derek Jacoby
|
|
// informed me the interface method has changed and now
|
|
// includes an addition parameter....
|
|
|
|
CDataObject *pDO = ExtractOwnDataObject( ipDataObject );
|
|
CBaseNode *pNode = ExtractBaseObject( ipDataObject);
|
|
|
|
if (pDO && pNode)
|
|
{
|
|
ATLTRACE(_T("ComponentData::GetWatermarks() %s\n"), pNode->GetNodeName());
|
|
*lphWatermark = m_hWatermark1;
|
|
*lphHeader = m_hHeader1;
|
|
*lphPalette = NULL;
|
|
*bStretch = TRUE;
|
|
return S_OK;
|
|
}
|
|
|
|
ATLTRACE(_T("ComponentData::GetWatermarks() %s\n"), _T("Unrecognized IDataObject"));
|
|
return S_FALSE;
|
|
} // end GetWatermarks()
|
|
|
|
STDMETHODIMP CComponentData::QueryPagesFor
|
|
(
|
|
LPDATAOBJECT ipDataObject
|
|
)
|
|
{
|
|
CDataObject *pDO = ExtractOwnDataObject( ipDataObject );
|
|
CBaseNode *pNode = ExtractBaseObject( ipDataObject);
|
|
|
|
if (pDO && pDO->IsResultItem() )
|
|
{
|
|
ASSERT(FALSE); // WHY HERE?, why didn't Component::QueryPagesFor get asked?
|
|
}
|
|
|
|
if (pDO && pNode && !pDO->IsResultItem())
|
|
{
|
|
ATLTRACE(_T("ComponentData::QueryPagesFor() %s\n"), pNode->GetNodeName());
|
|
return pNode->QueryPagesFor();
|
|
}
|
|
|
|
ATLTRACE(_T("ComponentData::QueryPagesFor() %s\n"), _T("Unrecognized IDataObject"));
|
|
return S_FALSE;
|
|
}
|
|
|
|
STDMETHODIMP CComponentData::CreatePropertyPages
|
|
(
|
|
LPPROPERTYSHEETCALLBACK lpProvider,
|
|
LONG_PTR handle,
|
|
LPDATAOBJECT ipDataObject
|
|
)
|
|
{
|
|
ASSERT( NULL != lpProvider );
|
|
|
|
CDataObject *pDO = ExtractOwnDataObject( ipDataObject );
|
|
CBaseNode *pNode = ExtractBaseObject( ipDataObject);
|
|
|
|
if (pDO && pDO->IsResultItem() )
|
|
{
|
|
ASSERT(FALSE); // WHY HERE?
|
|
}
|
|
|
|
if (pDO && pNode && !pDO->IsResultItem())
|
|
{
|
|
ATLTRACE(_T("ComponentData::CreatePropertyPages() %s\n"), pNode->GetNodeName());
|
|
return pNode->OnCreatePropertyPages(lpProvider, handle, pDO->GetContext());
|
|
}
|
|
|
|
ATLTRACE(_T("ComponentData::CreatePropertyPages() %s\n"), _T("Unrecognized IDataObject"));
|
|
return S_FALSE;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// IStream implementation
|
|
//
|
|
STDMETHODIMP CComponentData::GetClassID(CLSID *pClassID)
|
|
{
|
|
ATLTRACE(_T("ComponentData::GetClassID()\n"));
|
|
*pClassID = CLSID_ComponentData;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CComponentData::IsDirty()
|
|
{
|
|
ATLTRACE(_T("ComponentData::IsDirty()\n"));
|
|
|
|
HRESULT hr = S_FALSE; // default to no changes...
|
|
if (m_ptrRootNode)
|
|
hr = m_ptrRootNode->IsDirty();
|
|
|
|
ATLTRACE(_T(" ComponentData::IsDirty() %s\n"), (hr == S_OK ? _T("Dirty") : _T("No Changes")));
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CComponentData::Load(IStream *pStm)
|
|
{
|
|
ATLTRACE(_T("\nComponentData::Load()\n"));
|
|
|
|
if (m_ptrRootNode)
|
|
return m_ptrRootNode->Load(pStm);
|
|
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
STDMETHODIMP CComponentData::Save(IStream *pStm, BOOL fClearDirty)
|
|
{
|
|
ATLTRACE(_T("\nComponentData::Save()\n"));
|
|
|
|
if (m_ptrRootNode)
|
|
return m_ptrRootNode->Save(pStm, fClearDirty);
|
|
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
STDMETHODIMP CComponentData::GetSizeMax(ULARGE_INTEGER *pcbSize)
|
|
{
|
|
ATLTRACE(_T("ComponentData::GetSizeMax()\n"));
|
|
|
|
if (m_ptrRootNode)
|
|
return m_ptrRootNode->GetSizeMax(pcbSize);
|
|
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// ISnapinHelp2
|
|
//
|
|
|
|
STDMETHODIMP CComponentData::GetHelpTopic(LPOLESTR *lpCompiledHelpFile)
|
|
{
|
|
ATLTRACE(_T("ComponentData::GetHelpTopic()\n"));
|
|
|
|
if (!lpCompiledHelpFile)
|
|
return E_POINTER;
|
|
|
|
*lpCompiledHelpFile = reinterpret_cast<LPOLESTR> (CoTaskMemAlloc(_MAX_PATH * sizeof(TCHAR)));
|
|
if (!*lpCompiledHelpFile)
|
|
return E_OUTOFMEMORY;
|
|
|
|
DWORD len = ExpandEnvironmentStrings(HELP_FilePath, *lpCompiledHelpFile, _MAX_PATH);
|
|
if (len && len <= _MAX_PATH)
|
|
return S_OK;
|
|
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
STDMETHODIMP CComponentData::GetLinkedTopics(LPOLESTR *lpCompiledHelpFiles)
|
|
{
|
|
ATLTRACE(_T("ComponentData::GetLinkedTopics()\n"));
|
|
|
|
if (!lpCompiledHelpFiles)
|
|
return E_POINTER;
|
|
|
|
*lpCompiledHelpFiles = reinterpret_cast<LPOLESTR> (CoTaskMemAlloc(_MAX_PATH * sizeof(TCHAR)));
|
|
if (!*lpCompiledHelpFiles)
|
|
return E_OUTOFMEMORY;
|
|
|
|
DWORD len = ExpandEnvironmentStrings(HELP_LinkedFilePaths, *lpCompiledHelpFiles, _MAX_PATH);
|
|
if (len && len <= _MAX_PATH)
|
|
return S_OK;
|
|
|
|
return E_UNEXPECTED;
|
|
}
|
|
|