553 lines
20 KiB
C++
553 lines
20 KiB
C++
//____________________________________________________________________________
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1996 - 1999
|
|
//
|
|
// File: Node.h
|
|
//
|
|
// Contents:
|
|
//
|
|
// Classes:
|
|
//
|
|
// Functions:
|
|
//
|
|
// History: 9/16/1996 RaviR Created
|
|
//
|
|
//____________________________________________________________________________
|
|
|
|
#ifndef _MMC_NODE_H_
|
|
#define _MMC_NODE_H_
|
|
#pragma once
|
|
|
|
#include "amcmsgid.h"
|
|
#include "refcount.h" // for CRefCountedObject
|
|
|
|
// A vector of strings to store column names
|
|
typedef std::vector<tstring> TStringVector;
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Classes declared in this file
|
|
|
|
class CComponent;
|
|
class CDataNotifyInfo;
|
|
|
|
class CNode;
|
|
class CSnapInNode;
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Forward declarations
|
|
class CConsoleTaskpad;
|
|
class CResultItem;
|
|
class CResultViewType;
|
|
class CMMCClipBoardDataObject;
|
|
class CViewSettingsPersistor;
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Class declarations
|
|
|
|
//____________________________________________________________________________
|
|
//
|
|
// class: CComponent
|
|
//____________________________________________________________________________
|
|
//
|
|
|
|
class CComponent
|
|
{
|
|
DECLARE_NOT_COPIABLE (CComponent);
|
|
DECLARE_NOT_ASSIGNABLE(CComponent);
|
|
public:
|
|
// Constructor & Destructor
|
|
CComponent(CSnapIn * pSnapIn);
|
|
virtual ~CComponent();
|
|
|
|
// Attributes
|
|
const CLSID& GetCLSID() const
|
|
{
|
|
if (m_spSnapIn == NULL)
|
|
return (GUID_NULL);
|
|
|
|
return m_spSnapIn->GetSnapInCLSID();
|
|
}
|
|
|
|
CSnapIn* GetSnapIn(void) const
|
|
{
|
|
return m_spSnapIn;
|
|
}
|
|
|
|
IComponent* GetIComponent(void) const
|
|
{
|
|
return m_spIComponent;
|
|
}
|
|
|
|
IFramePrivate* GetIFramePrivate(void) const
|
|
{
|
|
return m_spIFrame;
|
|
}
|
|
|
|
IImageListPrivate* GetIImageListPrivate(void) const
|
|
{
|
|
return m_spIRsltImageList;
|
|
}
|
|
|
|
// Operations
|
|
// Initialization
|
|
HRESULT Init(IComponentData* pIComponentData, HMTNODE hMTNode, HNODE lNode,
|
|
COMPONENTID nComponentID, int viewID);
|
|
|
|
BOOL IsInitialized()
|
|
{
|
|
return (m_spIFrame != NULL);
|
|
}
|
|
|
|
LPUNKNOWN GetUnknownToLoad(void) const
|
|
{
|
|
return m_spIComponent;
|
|
}
|
|
|
|
// IComponent interface methods
|
|
HRESULT Initialize(LPCONSOLE lpConsole);
|
|
HRESULT Notify(LPDATAOBJECT lpDataObject, MMC_NOTIFY_TYPE event, LONG_PTR arg, LPARAM param);
|
|
HRESULT Destroy(MMC_COOKIE cookie);
|
|
HRESULT QueryDataObject(MMC_COOKIE cookie, DATA_OBJECT_TYPES type,
|
|
LPDATAOBJECT* ppDataObject);
|
|
HRESULT GetResultViewType(MMC_COOKIE cookie, LPOLESTR* ppszViewType, long* pViewOptions);
|
|
HRESULT GetDisplayInfo(RESULTDATAITEM* pResultDataItem);
|
|
|
|
// IComponent2 helper
|
|
SC ScQueryDispatch(MMC_COOKIE cookie, DATA_OBJECT_TYPES type, PPDISPATCH ppSelectedObject);
|
|
|
|
void SetComponentID(COMPONENTID nID)
|
|
{
|
|
ASSERT(nID < 1000);
|
|
m_ComponentID = nID;
|
|
}
|
|
|
|
COMPONENTID GetComponentID(void) const
|
|
{
|
|
return m_ComponentID;
|
|
}
|
|
|
|
void ResetComponentID(COMPONENTID id)
|
|
{
|
|
m_spIFrame->SetComponentID(m_ComponentID = id);
|
|
}
|
|
|
|
SC ScResetConsoleVerbStates ();
|
|
|
|
// loaded from stream/storage; initailized with the new one; or does not need initialization
|
|
bool IsIComponentInitialized()
|
|
{
|
|
return m_bIComponentInitialized;
|
|
}
|
|
|
|
// loaded from stream/storage; initailized with the new one; or does not need initialization
|
|
void SetIComponentInitialized()
|
|
{
|
|
m_bIComponentInitialized = true;
|
|
}
|
|
|
|
private:
|
|
// Implementation
|
|
CSnapInPtr m_spSnapIn;
|
|
|
|
IComponentPtr m_spIComponent;
|
|
IFramePrivatePtr m_spIFrame;
|
|
IImageListPrivatePtr m_spIRsltImageList;
|
|
|
|
COMPONENTID m_ComponentID;
|
|
bool m_bIComponentInitialized;
|
|
|
|
// Helper methods
|
|
void Construct(CSnapIn * pSnapIn, CComponent* pComponent);
|
|
|
|
}; // class CComponent
|
|
|
|
class CComponentPtrArray : public CArray<CComponent*, CComponent*>
|
|
{
|
|
public:
|
|
void AddComponent(CComponent* pCC)
|
|
{
|
|
for (int i = GetUpperBound(); i >= 0; --i)
|
|
{
|
|
if (GetAt(i) == pCC)
|
|
return;
|
|
}
|
|
|
|
Add(pCC);
|
|
}
|
|
};
|
|
|
|
|
|
//____________________________________________________________________________
|
|
//
|
|
// class: CNode
|
|
//
|
|
// PURPOSE: Each master tree node class (ie CMTxxx) has a matching CNode-derived
|
|
// class. The CNode-derived class objects encapsulate the view-dependent
|
|
// settings of the CMTNode derived object.
|
|
//
|
|
//____________________________________________________________________________
|
|
//
|
|
|
|
class CNode
|
|
{
|
|
DECLARE_NOT_ASSIGNABLE(CNode);
|
|
|
|
// Constructor & Destructor
|
|
protected:
|
|
// only from CSnapInNode
|
|
CNode(CMTNode * pMTNode, CViewData* pViewData, bool fRootNode, bool fStaticNode);
|
|
public:
|
|
CNode(CMTNode * pMTNode, CViewData* pViewData, bool fRootNode);
|
|
CNode(const CNode& other);
|
|
virtual ~CNode();
|
|
|
|
// converters
|
|
static CNode* FromHandle (HNODE hNode);
|
|
static CNode* FromResultItem (CResultItem* pri);
|
|
static HNODE ToHandle (const CNode* pNode);
|
|
|
|
// Attributes
|
|
CViewData* GetViewData(void)const {ASSERT(m_pViewData != NULL); return m_pViewData;}
|
|
int GetViewID(void) {ASSERT(m_pViewData != NULL);return m_pViewData->GetViewID();}
|
|
virtual UINT GetResultImage() {return m_pMTNode->GetImage();}
|
|
void SetDisplayName(LPCTSTR pName){m_pMTNode->SetDisplayName(pName);}
|
|
void SetResultItem(HRESULTITEM hri){m_hri = hri;}
|
|
long GetOwnerID(void) const{return m_pMTNode->GetOwnerID();}
|
|
|
|
void ResetFlags();
|
|
void SetExpandedAtLeastOnce();
|
|
BOOL WasExpandedAtLeastOnce();
|
|
void SetExpandedVisually(bool bExpanded);
|
|
bool WasExpandedVisually(void);
|
|
bool AllowNewWindowFromHere() const { return (m_pMTNode->AllowNewWindowFromHere()); }
|
|
|
|
tstring GetDisplayName(){return m_pMTNode->GetDisplayName();}
|
|
CMTNode* GetMTNode() const {return m_pMTNode;}
|
|
HRESULTITEM GetResultItem() const {return m_hri;}
|
|
virtual BOOL NeedsViewToBePersisted(void){return FALSE;}
|
|
|
|
virtual CComponent* GetComponent(COMPONENTID nID);
|
|
CComponent* GetPrimaryComponent(void);
|
|
HRESULT InitComponents();
|
|
|
|
// Overridables
|
|
SC ScGetResultPane(CResultViewType &rvt, GUID *pGuidTaskpadID);
|
|
BOOL IsDynamicNode() const {return !IsStaticNode();}
|
|
BOOL IsStaticNode() const {return (m_fStaticNode);}
|
|
|
|
BOOL IsConsoleRoot(){return (GetMTNode()->Parent() == NULL);}
|
|
BOOL IsRootNode() const {return m_fRootNode;}
|
|
virtual LPUNKNOWN GetControl(CLSID& clsid);
|
|
virtual LPUNKNOWN GetControl(LPUNKNOWN pUnkOCX);
|
|
|
|
virtual void SetControl(CLSID& clsid, IUnknown* pUnknown);
|
|
virtual void SetControl(LPUNKNOWN pUnkOCX, IUnknown* pUnknown);
|
|
|
|
CSnapIn* GetPrimarySnapIn(void) {return GetPrimaryComponent()->GetSnapIn();}
|
|
BOOL IsInitialized(void) {return !m_bInitComponents;}
|
|
IUnknown* GetControlbarsCache(void)
|
|
{return m_pViewData->GetControlbarsCache();}
|
|
|
|
HRESULT OnSelect(LPUNKNOWN lpView, BOOL bSelect, BOOL bResultPaneIsWeb);
|
|
HRESULT OnScopeSelect(bool bSelect, SELECTIONINFO* pSelInfo);
|
|
HRESULT OnListPad(LONG_PTR arg, LPARAM param);
|
|
HRESULT IsTargetNode(CNode *pNodeTest) {return E_FAIL;} // do not change.
|
|
HRESULT OnExpand(bool fExpand);
|
|
HRESULT OnGetPrimaryTask(IExtendTaskPad **ppExtendTaskPad);
|
|
IFramePrivate * GetIFramePrivate();
|
|
HRESULT GetTaskEnumerator(LPOLESTR pszTaskGroup, IEnumTASK** ppEnumTask);
|
|
HRESULT GetListPadInfo(IExtendTaskPad* pExtendTaskPad, LPOLESTR szTaskGroup,
|
|
MMC_ILISTPAD_INFO* pIListPadInfo);
|
|
void ResetControlbars(BOOL bSelect, SELECTIONINFO* pSelInfo);
|
|
|
|
void ResetVerbSets(BOOL bSelect, SELECTIONINFO* pSelInfo);
|
|
HRESULT GetDataInfo(BOOL bSelect, SELECTIONINFO* pSelInfo, CDataNotifyInfo* pDNI);
|
|
SC ScInitializeVerbs (bool bSelect, SELECTIONINFO* pSelInfo);
|
|
|
|
void OnTaskNotify(LONG_PTR arg, LPARAM param);
|
|
virtual void OnWebContextMenu() {};
|
|
LPARAM GetUserParam(void);
|
|
HRESULT GetDispInfoForListItem(LV_ITEMW* plvi);
|
|
HRESULT GetDispInfo(LV_ITEMW* plvi);
|
|
|
|
HRESULT OnColumnClicked(LONG_PTR nCol);
|
|
HRESULT OnInitOCX(IUnknown* pUnk);
|
|
HRESULT OnCacheHint(int nStartIndex, int nEndIndex);
|
|
|
|
HRESULT SendShowEvent(BOOL bSelect);
|
|
|
|
HRESULT OnColumnsChange(CColumnInfoList& colInfoList);
|
|
SC ScSetViewExtension(GUID *pGuidViewId, bool bUseDefaultTaskpad, bool bSetViewSettingsDirty);
|
|
SC ScGetDataObject(bool bScopePane, LPARAM lResultItemCookie, bool& bScopeItem, LPDATAOBJECT* ppDataObject, CComponent **ppCComponent = NULL);
|
|
SC ScGetPropertyFromINodeProperties(LPDATAOBJECT pDataObject, BOOL bForScopeItem, LPARAM resultItemParam, BSTR bstrPropertyName, PBSTR pbstrPropertyValue);
|
|
SC ScExecuteShellCommand(BSTR Command, BSTR Directory, BSTR Parameters, BSTR WindowState);
|
|
SC ScGetDropTargetDataObject(bool bScope, LPARAM lResultItemCookie, LPDATAOBJECT *ppDataObject);
|
|
|
|
CSnapInNode* GetStaticParent(void);
|
|
HRESULT QueryDataObject(DATA_OBJECT_TYPES type, LPDATAOBJECT* ppdtobj);
|
|
HRESULT GetNodeType(GUID* pGuid);
|
|
SC ScSetupTaskpad(GUID *pGuidTaskpadID);
|
|
HRESULT RestoreSort(INT nCol, DWORD dwSortOptions);
|
|
SC ScRestoreSortFromPersistedData();
|
|
SC ScSaveSortData (int nCol, DWORD dwOptions);
|
|
SC ScGetSnapinAndColumnDataID(GUID& snapinGuid, CXMLAutoBinary& columnID);
|
|
SC ScRestoreResultView(const CResultViewType& rvt);
|
|
SC ScRestoreViewMode();
|
|
SC ScSaveColumnInfoList(CColumnInfoList& columnInfoList);
|
|
const CLSID& GetPrimarySnapInCLSID(void);
|
|
HRESULT ExtractColumnConfigID(IDataObject* pDataObj, HGLOBAL& phGlobal);
|
|
CLIPFORMAT GetColumnConfigIDCF();
|
|
|
|
void SetPrimaryComponent(CComponent* p) { ASSERT(m_pPrimaryComponent == NULL); m_pPrimaryComponent = p; }
|
|
|
|
SC ScGetCurrentColumnData( CColumnInfoList& columnInfoList, TStringVector& strColNames);
|
|
SC ScShowColumn(int iColIndex, bool bShow);
|
|
SC ScSetUpdatedColumnData( CColumnInfoList& oldColumnInfoList, CColumnInfoList& newColumnInfoList);
|
|
SC ScGetSortColumn(int *piSortCol);
|
|
SC ScSetSortColumn(int iSortCol, bool bAscending);
|
|
SC ScGetViewExtensions(CViewExtInsertIterator it);
|
|
|
|
HRESULT ShowStandardListView();
|
|
HRESULT OnActvate(LONG_PTR lActivate);
|
|
HRESULT OnMinimize(LONG_PTR fMinimized);
|
|
|
|
void Reset();
|
|
void SetInitComponents(BOOL b) { m_bInitComponents = b; }
|
|
void OnColumns();
|
|
|
|
/***************************************************************************\
|
|
*
|
|
* CLASS: CDataObjectCleanup
|
|
*
|
|
* PURPOSE: Groups methods to register/trigger data object clenup when
|
|
* CNode, which data is put to data object goes away
|
|
*
|
|
* USAGE: Used from CMMCClipBoardDataObject to register nodes put to it
|
|
* And used from ~CNode to trigger the cleanup
|
|
*
|
|
\***************************************************************************/
|
|
class CDataObjectCleanup
|
|
{
|
|
public:
|
|
static SC ScRegisterNode(CNode *pNode, CMMCClipBoardDataObject *pObject);
|
|
static SC ScUnadviseDataObject(CMMCClipBoardDataObject *pObject, bool bForceDataObjectCleanup = true);
|
|
static SC ScUnadviseNode(CNode *pNode);
|
|
|
|
// mapping CNode to data object which contains it's data
|
|
typedef std::multimap<CNode *, CMMCClipBoardDataObject *> CMapOfNodes;
|
|
|
|
private:
|
|
static CMapOfNodes s_mapOfNodes;
|
|
};
|
|
|
|
// CViewSettingsPersistor's persistence interfaces.
|
|
static SC ScQueryViewSettingsPersistor(IPersistStream **ppStream);
|
|
static SC ScQueryViewSettingsPersistor(CXMLObject **ppXMLObject);
|
|
static SC ScOnDocumentClosing();
|
|
static SC ScDeleteViewSettings(int nVieWID);
|
|
static SC ScSetFavoriteViewSettings (int nViewID, const CBookmark& bookmark, const CViewSettings& viewSettings);
|
|
|
|
SC ScSetViewMode (ULONG ulViewMode);
|
|
SC ScSetTaskpadID(const GUID& guidTaskpad, bool bSetDirty);
|
|
|
|
// Implementation
|
|
private:
|
|
HRESULT DeepNotify (MMC_NOTIFY_TYPE event, LONG_PTR arg, LPARAM param);
|
|
SC ScInitializeViewExtension(const CLSID& clsid, CViewData *pViewData);
|
|
|
|
void CommonConstruct();
|
|
|
|
// Get & Set persisted ViewSettings data.
|
|
SC ScGetTaskpadID(GUID& guidTaskpad);
|
|
SC ScGetConsoleTaskpad (const GUID& guidTaskpad, CConsoleTaskpad **ppTaskpad);
|
|
|
|
SC ScGetViewMode (ULONG& ulViewMode);
|
|
|
|
SC ScGetResultViewType (CResultViewType& rvt);
|
|
SC ScSetResultViewType (const CResultViewType& rvt);
|
|
|
|
private:
|
|
CMTNode* const m_pMTNode; // ptr back to the master node.
|
|
HRESULTITEM m_hri; // this node's result item handle
|
|
CViewData* m_pViewData;
|
|
DWORD m_dwFlags;
|
|
|
|
enum
|
|
{
|
|
flag_expanded_at_least_once = 0x00000001,
|
|
flag_expanded_visually = 0x00000002,
|
|
};
|
|
|
|
CComponent* m_pPrimaryComponent;
|
|
bool m_bInitComponents : 1;
|
|
const bool m_fRootNode : 1;
|
|
const bool m_fStaticNode : 1;
|
|
|
|
static CComObject<CViewSettingsPersistor>* m_pViewSettingsPersistor;
|
|
};
|
|
|
|
|
|
//____________________________________________________________________________
|
|
//
|
|
// class: COCX
|
|
//
|
|
// Purpose: Store the IUnknown ptr of OCX wrapper and an identifier for
|
|
// the OCX. The identifier may be CLSID of the OCX or
|
|
// the IUnknown ptr of the OCX.
|
|
//
|
|
// In essence a OCXWrapper can be saved using CLSID of OCX as
|
|
// the key (IComponent::GetResultViewType) or IUnknown* of OCX
|
|
// as the key (IComponent2::GetResultViewType2).
|
|
//
|
|
// Therefore we have overloaded version of SetControl below.
|
|
//
|
|
//____________________________________________________________________________
|
|
//
|
|
|
|
class COCX
|
|
{
|
|
public:
|
|
// Constructor & Destructor
|
|
COCX(void);
|
|
~COCX(void);
|
|
|
|
// Attributes
|
|
void SetControl(CLSID& clsid, IUnknown* pUnknown);
|
|
BOOL IsControlCLSID(CLSID clsid) { return IsEqualCLSID(clsid, m_clsid); }
|
|
IUnknown* GetControlUnknown() { return m_spOCXWrapperUnknown;}
|
|
|
|
void SetControl(LPUNKNOWN pUnkOCX, LPUNKNOWN pUnkOCXWrapper);
|
|
|
|
//
|
|
// Compare the IUnknown given and the one stored.
|
|
//
|
|
bool IsSameOCXIUnknowns(IUnknown *pOtherOCXUnknown) { return m_spOCXUnknown.IsEqualObject(pOtherOCXUnknown);}
|
|
|
|
// Implementation
|
|
private:
|
|
|
|
// Only one of CLSID or m_spOCXUnknown is valid, see class purpose for details.
|
|
CLSID m_clsid;
|
|
CComPtr<IUnknown> m_spOCXUnknown;
|
|
|
|
CComPtr<IUnknown> m_spOCXWrapperUnknown;
|
|
|
|
}; // COCX
|
|
|
|
|
|
//____________________________________________________________________________
|
|
//
|
|
// class: CSnapInNode
|
|
//____________________________________________________________________________
|
|
//
|
|
|
|
class CSnapInNode : public CNode
|
|
{
|
|
public:
|
|
// Constructor & Destructor
|
|
CSnapInNode(CMTSnapInNode* pMTNode, CViewData* pViewData, bool fRootNode);
|
|
CSnapInNode(const CSnapInNode& other);
|
|
~CSnapInNode();
|
|
|
|
// Attributes
|
|
virtual UINT GetResultImage();
|
|
virtual BOOL NeedsViewToBePersisted(void) { return TRUE; }
|
|
|
|
virtual void SetControl(CLSID& clsid, IUnknown* pUnknown);
|
|
virtual LPUNKNOWN GetControl(CLSID& clsid);
|
|
void CloseControls() { GetOCXArray().RemoveAll(); }
|
|
virtual void SetControl(LPUNKNOWN pUnkOCX, IUnknown* pUnknown);
|
|
virtual LPUNKNOWN GetControl(LPUNKNOWN pUnkOCX);
|
|
|
|
CComponentArray& GetComponentArray(void) { return m_spData->GetComponentArray(); }
|
|
|
|
|
|
// Operations
|
|
// User interactions
|
|
BOOL Activate(LPUNKNOWN pUnkResultsPane);
|
|
BOOL DeActivate(HNODE hNode);
|
|
BOOL Show(HNODE hNode);
|
|
void Reset();
|
|
|
|
int GetNumberOfComponents()
|
|
{
|
|
return GetComponentArray().size();
|
|
}
|
|
|
|
void AddComponentToArray(CComponent* pCC);
|
|
CComponent* CreateComponent(CSnapIn* pSnapIn, int nID);
|
|
CComponent* GetComponent(const CLSID& clsid);
|
|
virtual CComponent* GetComponent(COMPONENTID nID);
|
|
void DeleteComponent(COMPONENTID nID)
|
|
{
|
|
ASSERT(nID >= 0);
|
|
int iMax = GetComponentArray().size() -1;
|
|
ASSERT(nID <= iMax);
|
|
|
|
if (nID < iMax)
|
|
{
|
|
delete GetComponentArray()[nID];
|
|
GetComponentArray()[nID] = GetComponentArray()[iMax];
|
|
GetComponentArray()[iMax] = 0;
|
|
GetComponentArray()[iMax]->ResetComponentID(nID);
|
|
}
|
|
GetComponentArray().resize(iMax);
|
|
}
|
|
|
|
void SetResultImageList (IImageListPrivate* pImageList) { m_spData->SetImageList(pImageList); }
|
|
|
|
// Implementation
|
|
private:
|
|
class CDataImpl
|
|
{
|
|
public:
|
|
CDataImpl() :
|
|
m_pImageList(NULL)
|
|
{}
|
|
|
|
~CDataImpl()
|
|
{
|
|
Reset();
|
|
}
|
|
|
|
void Reset()
|
|
{
|
|
for (int i=0; i < m_ComponentArray.size(); i++)
|
|
delete m_ComponentArray[i];
|
|
|
|
m_ComponentArray.clear();
|
|
}
|
|
|
|
private:
|
|
IImageListPrivate* m_pImageList; // result image list
|
|
|
|
// Components array.
|
|
CComponentArray m_ComponentArray;
|
|
CArray<COCX, COCX&> m_rgOCX;
|
|
|
|
public:
|
|
void SetImageList(IImageListPrivate *pImageList)
|
|
{m_pImageList = pImageList;}
|
|
IImageListPrivate * GetImageList() {return m_pImageList;}
|
|
CComponentArray & GetComponentArray(){return m_ComponentArray;}
|
|
CArray<COCX, COCX&> & GetOCXArray() {return m_rgOCX;}
|
|
|
|
}; // CSnapInNode::CDataImpl
|
|
|
|
typedef CRefCountedObject<CDataImpl> CData;
|
|
CData::SmartPtr m_spData;
|
|
|
|
IImageListPrivate * GetImageList() {return m_spData->GetImageList();}
|
|
CArray<COCX, COCX&> & GetOCXArray() {return m_spData->GetOCXArray();}
|
|
|
|
}; // CSnapInNode
|
|
|
|
|
|
#include "node.inl"
|
|
|
|
#endif // _MMC_NODE_H_
|