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.
1866 lines
50 KiB
1866 lines
50 KiB
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (C) Microsoft Corporation, 1999 - 1999
|
|
//
|
|
// File: nodeinit.cpp
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
// NodeInit.cpp : Implementation of CNodeMgrApp and DLL registration.
|
|
|
|
#include "stdafx.h"
|
|
|
|
#include "menuitem.h" // MENUITEM_BASE_ID
|
|
#include "scopimag.h"
|
|
#include <bitmap.h>
|
|
#include "NodeMgr.h"
|
|
#include "amcmsgid.h"
|
|
#include "scopndcb.h"
|
|
#include "conframe.h"
|
|
#include "conview.h"
|
|
#include "constatbar.h"
|
|
#include "util.h"
|
|
#include "helpdoc.h"
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
DEBUG_DECLARE_INSTANCE_COUNTER(CNodeInitObject);
|
|
|
|
IScopeTreePtr CNodeInitObject::m_spScopeTree = NULL;
|
|
// NTRAID#NTBUG9-461280-03-SEP-2002-jrowlett
|
|
// delimit chm urls with "::" instead of "::/"
|
|
#define TOPIC_DELIMITER _T("::")
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
|
|
STDMETHODIMP CNodeInitObject::InterfaceSupportsErrorInfo(REFIID riid)
|
|
{
|
|
if (riid == IID_IConsole)
|
|
return S_OK;
|
|
return S_FALSE;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// IFramePrivate implementation
|
|
|
|
|
|
CNodeInitObject::CNodeInitObject()
|
|
{
|
|
Construct();
|
|
}
|
|
|
|
CNodeInitObject::~CNodeInitObject()
|
|
{
|
|
DEBUG_DECREMENT_INSTANCE_COUNTER(CNodeInitObject);
|
|
TRACE_DESTRUCTOR (CNodeInitObject);
|
|
Destruct();
|
|
}
|
|
|
|
void CNodeInitObject::Construct()
|
|
{
|
|
DEBUG_INCREMENT_INSTANCE_COUNTER(CNodeInitObject);
|
|
TRACE_CONSTRUCTOR (CNodeInitObject);
|
|
|
|
m_pLVImage = NULL;
|
|
m_pTVImage = NULL;
|
|
m_pToolbar = NULL;
|
|
m_pImageListPriv = NULL;
|
|
m_componentID = -1;
|
|
|
|
m_pMTNode = NULL;
|
|
m_pNode = NULL;
|
|
m_bExtension = FALSE;
|
|
|
|
m_spComponent = NULL;
|
|
m_spConsoleVerb = NULL;
|
|
|
|
m_sortParams.bAscending = TRUE;
|
|
m_sortParams.nCol = -1;
|
|
m_sortParams.lpResultCompare = NULL;
|
|
m_sortParams.lpResultCompareEx = NULL;
|
|
m_sortParams.lpUserParam = NULL;
|
|
|
|
// IContextMenuProvider attributes
|
|
VERIFY(SUCCEEDED(EmptyMenuList()));
|
|
}
|
|
|
|
void CNodeInitObject::Destruct()
|
|
{
|
|
// Release all interfaces from the snap-in
|
|
SAFE_RELEASE(m_pLVImage);
|
|
SAFE_RELEASE(m_pTVImage);
|
|
SAFE_RELEASE(m_pToolbar);
|
|
SAFE_RELEASE(m_pImageListPriv);
|
|
|
|
// IContextMenuProvider attributes
|
|
VERIFY( SUCCEEDED(EmptyMenuList()) );
|
|
}
|
|
|
|
|
|
STDMETHODIMP CNodeInitObject::ResetSortParameters()
|
|
{
|
|
m_sortParams.nCol = -1;
|
|
return (S_OK);
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::SetHeader
|
|
//
|
|
// Synopsis: This method is obsolete in MMC1.2
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Note: Should be called by IComponent object.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::SetHeader(IHeaderCtrl* pHeader)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IConsole2::SetHeader"));
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::SetToolbar
|
|
//
|
|
// Synopsis: The toolbar interface used by IComponent.
|
|
//
|
|
// Arguments: [pToolbar]
|
|
//
|
|
// Note: Should be called by IComponent object.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::SetToolbar(IToolbar* pToolbar)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IConsole2::SetToolbar"));
|
|
|
|
if (GetComponent() == NULL)
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
TraceSnapinError(_T("This method is valid for IConsole of IComponent"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
// Release the OLD one
|
|
SAFE_RELEASE(m_pToolbar);
|
|
|
|
if (pToolbar != NULL)
|
|
{
|
|
m_pToolbar = pToolbar;
|
|
m_pToolbar->AddRef();
|
|
}
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::QueryScopeImageList
|
|
//
|
|
// Synopsis: Get scope-pane's image list.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::QueryScopeImageList(LPIMAGELIST* ppImageList)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IConsole2::QueryScopeImageList"));
|
|
|
|
if (ppImageList == NULL)
|
|
{
|
|
sc = E_INVALIDARG;
|
|
TraceSnapinError(_T("NULL LPIMAGELIST ptr"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
sc = ScCheckPointers(m_pImageListPriv, E_FAIL);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
*ppImageList = (IImageList*)m_pImageListPriv;
|
|
m_pImageListPriv->AddRef();
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::CreateScopeImageList
|
|
//
|
|
// Synopsis: Create the ScopeImage list.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::CreateScopeImageList(REFCLSID refClsidSnapIn)
|
|
{
|
|
DECLARE_SC(sc, _T("CNodeInitObject::CreateScopeImageList"));
|
|
|
|
if (m_pImageListPriv != NULL)
|
|
return sc.ToHr(); // Already exists.
|
|
|
|
try
|
|
{
|
|
CScopeTree* pScopeTree =
|
|
dynamic_cast<CScopeTree*>((IScopeTree*)m_spScopeTree);
|
|
|
|
sc = ScCheckPointers(pScopeTree, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
CSnapInImageList *psiil =
|
|
new CSnapInImageList(pScopeTree->GetImageCache(),
|
|
refClsidSnapIn);
|
|
|
|
m_pImageListPriv = (LPIMAGELISTPRIVATE)psiil;
|
|
}
|
|
catch( std::bad_alloc )
|
|
{
|
|
sc = E_OUTOFMEMORY;
|
|
}
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::QueryResultImageList
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: SC
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::QueryResultImageList(LPIMAGELIST *ppImageList)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IConsole2::QueryResultImageList"));
|
|
|
|
LPCONSOLE pConsole = (LPCONSOLE)this;
|
|
sc = ScCheckPointers(pConsole, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
sc = pConsole->QueryInterface(IID_IImageList, (void**)ppImageList);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::UpdateAllViews
|
|
//
|
|
// Synopsis: Update all the views.
|
|
//
|
|
// Arguments: [lpDataObject] -
|
|
// [data]
|
|
// [hint]
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::UpdateAllViews(LPDATAOBJECT lpDataObject,
|
|
LPARAM data, LONG_PTR hint)
|
|
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IConsole2::UpdateAllViews"));
|
|
|
|
COMPONENTID id;
|
|
GetComponentID(&id);
|
|
|
|
sc = ScCheckPointers(m_pMTNode, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
CMTSnapInNode* pMTSINode = m_pMTNode->GetStaticParent();
|
|
|
|
sc = ScCheckPointers(pMTSINode, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
CNodeList& nodes = pMTSINode->GetNodeList();
|
|
POSITION pos = nodes.GetHeadPosition();
|
|
|
|
while (pos)
|
|
{
|
|
CSnapInNode* pSINode = dynamic_cast<CSnapInNode*>(nodes.GetNext(pos));
|
|
|
|
sc = ScCheckPointers(pSINode, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
CComponent* pCC = pSINode->GetComponent(id);
|
|
sc = ScCheckPointers(pCC, E_UNEXPECTED);
|
|
if (sc)
|
|
{
|
|
sc.TraceAndClear();
|
|
continue;
|
|
}
|
|
|
|
pCC->Notify(lpDataObject, MMCN_VIEW_CHANGE, data, hint);
|
|
}
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::InsertColumn
|
|
//
|
|
// Synopsis: Insert a column is ListView.
|
|
//
|
|
// Arguments: [nCol] - Column index.
|
|
// [lpszTitle] - Name of the column.
|
|
// [nFormat] - Column style.
|
|
// [nWidth] - Column width.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::InsertColumn(int nCol, LPCWSTR lpszTitle, int nFormat, int nWidth)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IHeaderCtrl2::InsertColumn"));
|
|
|
|
if (nCol < 0)
|
|
{
|
|
sc = E_INVALIDARG;
|
|
TraceSnapinError(_T("Column index is negative"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
if (!lpszTitle || !*lpszTitle)
|
|
{
|
|
sc = E_INVALIDARG;
|
|
TraceSnapinError(_T("Column name is NULL"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
if (nCol == 0 && nFormat != LVCFMT_LEFT)
|
|
{
|
|
sc = E_INVALIDARG;
|
|
TraceSnapinError(_T("Column zero must be LVCFMT_LEFT"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
if (nFormat != LVCFMT_LEFT && nFormat != LVCFMT_CENTER && nFormat != LVCFMT_RIGHT)
|
|
{
|
|
sc = E_INVALIDARG;
|
|
TraceSnapinError(_T("Unknown format for the Column"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
// Cannot hide column 0.
|
|
if ( (0 == nCol) && (HIDE_COLUMN == nWidth))
|
|
nWidth = AUTO_WIDTH;
|
|
|
|
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
// Insert the column into the listview
|
|
sc = m_spListViewPrivate->InsertColumn(nCol, lpszTitle, nFormat, nWidth);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::DeleteColumn
|
|
//
|
|
// Synopsis: Delete a column
|
|
//
|
|
// Arguments: [nCol] - column index.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::DeleteColumn(int nCol)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IHeaderCtrl2::DeleteColumn"));
|
|
|
|
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
sc = m_spListViewPrivate->DeleteColumn(nCol);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::SetColumnText
|
|
//
|
|
// Synopsis: Modify column text.
|
|
//
|
|
// Arguments: [title] - new name.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::SetColumnText(int nCol, LPCWSTR title)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IHeaderCtrl2::SetColumnText"));
|
|
|
|
if (!title || !*title)
|
|
{
|
|
sc = E_INVALIDARG;
|
|
TraceSnapinError(_T("NULL column text"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
sc = m_spListViewPrivate->SetColumn(nCol, title, MMCLV_NOPARAM, MMCLV_NOPARAM);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::GetColumnText
|
|
//
|
|
// Synopsis: Get the name of a column.
|
|
//
|
|
// Arguments: [nCol] - Index of Column whose name is sought.
|
|
// [pText] - Name.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::GetColumnText(int nCol, LPWSTR* pText)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IHeaderCtrl2::GetColumnText"));
|
|
|
|
if (pText == NULL)
|
|
{
|
|
sc = E_INVALIDARG;
|
|
TraceSnapinError(_T("NULL text ptr"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
sc = m_spListViewPrivate->GetColumn(nCol, pText, MMCLV_NOPTR, MMCLV_NOPTR);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::SetColumnWidth
|
|
//
|
|
// Synopsis: Change width of a column
|
|
//
|
|
// Arguments: [nCol] - Column index.
|
|
// [nWidth] - new width.
|
|
//
|
|
// Returns: SC
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::SetColumnWidth(int nCol, int nWidth)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IHeaderCtrl2::SetColumnWidth"));
|
|
|
|
if (nCol < 0)
|
|
{
|
|
sc = E_INVALIDARG;
|
|
TraceSnapinError(_T("Negative column index"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
// job on parameter checking nWidth
|
|
if (nWidth < 0 && ( (nWidth != MMCLV_AUTO) && (nWidth != HIDE_COLUMN) ) )
|
|
{
|
|
sc = E_INVALIDARG;
|
|
TraceSnapinError(_T("Invalid column width"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
// Cannot hide column 0.
|
|
if ( (0 == nCol) && (HIDE_COLUMN == nWidth))
|
|
nWidth = AUTO_WIDTH;
|
|
|
|
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
sc = m_spListViewPrivate->SetColumn(nCol, MMCLV_NOPTR, MMCLV_NOPARAM, nWidth);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::GetColumnWidth
|
|
//
|
|
// Synopsis: Get width of a column.
|
|
//
|
|
// Arguments: [nCol] - col index.
|
|
// [pWidth] - width.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::GetColumnWidth(int nCol, int* pWidth)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IHeaderCtrl2::GetColumnWidth"));
|
|
|
|
if (nCol < 0 )
|
|
{
|
|
sc = E_INVALIDARG;
|
|
TraceSnapinError(_T("Negative column index"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
if (pWidth == NULL)
|
|
{
|
|
sc = E_POINTER;
|
|
TraceSnapinError(_T("NULL width pointer"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
sc = m_spListViewPrivate->GetColumn(nCol, MMCLV_NOPTR, MMCLV_NOPTR, pWidth);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::GetColumnCount
|
|
//
|
|
// Synopsis: Returns the number of columns in listview.
|
|
//
|
|
// Arguments: [pnCol] - [out param], number of cols.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::GetColumnCount (INT* pnCol)
|
|
{
|
|
DECLARE_SC(sc, _T("CNodeInitObject::GetColumnCount"));
|
|
sc = ScCheckPointers(pnCol);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
sc = m_spListViewPrivate->GetColumnCount(pnCol);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
return (sc.ToHr());
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::GetColumnInfoList
|
|
//
|
|
// Synopsis: Get the CColumnInfoList for current list-view headers.
|
|
//
|
|
// Arguments: [pColumnsList] - [out param], ptr to CColumnInfoList.
|
|
//
|
|
// Returns: SC
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::GetColumnInfoList (CColumnInfoList *pColumnsList)
|
|
{
|
|
DECLARE_SC(sc, _T("CNodeInitObject::GetColumnInfoList"));
|
|
sc = ScCheckPointers(pColumnsList);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
sc = m_spListViewPrivate->GetColumnInfoList(pColumnsList);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
return (sc.ToHr());
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::ModifyColumns
|
|
//
|
|
// Synopsis: Modify the columns with given data.
|
|
//
|
|
// Arguments: [columnsList] -
|
|
//
|
|
// Returns: SC
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::ModifyColumns (const CColumnInfoList& columnsList)
|
|
{
|
|
DECLARE_SC(sc, _T("CNodeInitObject::ModifyColumns"));
|
|
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
sc = m_spListViewPrivate->ModifyColumns(columnsList);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
return (sc.ToHr());
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::GetDefaultColumnInfoList
|
|
//
|
|
// Synopsis: Get the original column settings supplied by the snapin.
|
|
//
|
|
// Arguments: [columnsList] - [out] the column settings
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::GetDefaultColumnInfoList (CColumnInfoList& columnsList)
|
|
{
|
|
DECLARE_SC(sc, _T("CNodeInitObject::RestoreDefaultColumnSettings"));
|
|
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
sc = m_spListViewPrivate->GetDefaultColumnInfoList(columnsList);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
return (sc.ToHr());
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::ImageListSetIcon
|
|
//
|
|
// Synopsis: Set an icon in imagelist.
|
|
//
|
|
// Arguments: [pIcon] - HICON ptr.
|
|
// [nLoc] - index of this item.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::ImageListSetIcon(PLONG_PTR pIcon, LONG nLoc)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IImageList::ImageListSetIcon"));
|
|
|
|
if (!pIcon)
|
|
{
|
|
sc = E_INVALIDARG;
|
|
TraceSnapinError(_T("NULL pIcon ptr"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
if(nLoc < 0)
|
|
{
|
|
sc = E_INVALIDARG;
|
|
TraceSnapinError(_T("Negative index"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
COMPONENTID id;
|
|
GetComponentID(&id);
|
|
|
|
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
sc = m_spListViewPrivate->SetIcon(id, reinterpret_cast<HICON>(pIcon), nLoc);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::ImageListSetStrip
|
|
//
|
|
// Synopsis: Add strip of icons to image list.
|
|
//
|
|
// Arguments: [pBMapSm] - Ptr to HBITMAP of 16x16.
|
|
// [pBMapLg] - Ptr to HBITMAP of 32x32.
|
|
// [nStartLoc] - Start index.
|
|
// [cMask] - mask.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::ImageListSetStrip (
|
|
PLONG_PTR pBMapSm,
|
|
PLONG_PTR pBMapLg,
|
|
LONG nStartLoc,
|
|
COLORREF cMask)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IImageList::ImageListSetStrip"));
|
|
|
|
HBITMAP hbmSmall = (HBITMAP) pBMapSm;
|
|
HBITMAP hbmLarge = (HBITMAP) pBMapLg;
|
|
|
|
/*
|
|
* valid start index?
|
|
*/
|
|
if (nStartLoc < 0)
|
|
{
|
|
sc = E_INVALIDARG;
|
|
TraceSnapinError (_T("Negative start index"), sc);
|
|
return (sc.ToHr());
|
|
}
|
|
|
|
/*
|
|
* valid bitmaps?
|
|
*/
|
|
sc = ScCheckPointers (hbmSmall, hbmLarge);
|
|
if (sc)
|
|
{
|
|
TraceSnapinError (_T("Invalid bitmap"), sc);
|
|
return (sc.ToHr());
|
|
}
|
|
|
|
BITMAP bmSmall;
|
|
if (!GetObject (hbmSmall, sizeof(BITMAP), &bmSmall))
|
|
{
|
|
sc.FromLastError();
|
|
TraceSnapinError (_T("Invalid Small bitmap object"), sc);
|
|
return (sc.ToHr());
|
|
}
|
|
|
|
BITMAP bmLarge;
|
|
if (!GetObject (hbmLarge, sizeof(BITMAP), &bmLarge))
|
|
{
|
|
sc.FromLastError();
|
|
TraceSnapinError (_T("Invalid Large bitmap object"), sc);
|
|
return (sc.ToHr());
|
|
}
|
|
|
|
/*
|
|
* are the small and large bitmaps of the integral dimensions,
|
|
* and do they have the same number of images?
|
|
*/
|
|
if ( (bmSmall.bmHeight != 16) || (bmLarge.bmHeight != 32) ||
|
|
(bmSmall.bmWidth % 16) || (bmLarge.bmWidth % 32) ||
|
|
((bmSmall.bmWidth / 16) != (bmLarge.bmWidth / 32)))
|
|
{
|
|
sc = E_INVALIDARG;
|
|
TraceSnapinError (_T("Invalid Bitmap size"), sc);
|
|
return (sc.ToHr());
|
|
}
|
|
|
|
COMPONENTID id;
|
|
GetComponentID(&id);
|
|
|
|
/*
|
|
* m_spListViewPrivate == NULL is unexpected, however because we send
|
|
* MMCN_ADD_IMAGES when the result pane is an OCX (see CNode::OnSelect),
|
|
* this function often gets called when m_spListViewPrivate == NULL.
|
|
* Tracing this failure would be too noisy, since most OCX-based snap-ins
|
|
* would trigger it, so we'll return E_UNEXPECTED here without tracing.
|
|
* This is equivalent to MMC 1.2 behavior.
|
|
*/
|
|
if (m_spListViewPrivate == NULL)
|
|
return (E_UNEXPECTED);
|
|
|
|
/*
|
|
* add them to the imagelist
|
|
*/
|
|
sc = m_spListViewPrivate->SetImageStrip (id, hbmSmall, hbmLarge, nStartLoc, cMask);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::MapRsltImage
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::MapRsltImage(COMPONENTID id, int nSnapinIndex, int *pnConsoleIndex)
|
|
{
|
|
DECLARE_SC(sc, _T("CNodeInitObject::MapRsltImage"));
|
|
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
// Ret val can be E_, no need to check.
|
|
sc = m_spListViewPrivate->MapImage(id, nSnapinIndex, pnConsoleIndex);
|
|
HRESULT hr = sc.ToHr();
|
|
sc.Clear();
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::UnmapRsltImage
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::UnmapRsltImage(COMPONENTID id, int nConsoleIndex, int *pnSnapinIndex)
|
|
{
|
|
DECLARE_SC(sc, _T("CNodeInitObject::UnmapRsltImage"));
|
|
return (sc = E_NOTIMPL).ToHr(); // not needed now
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::SetChangeTimeOut
|
|
//
|
|
// Synopsis: Change timeout interval for filter attributes.
|
|
//
|
|
// Arguments: [uTimeout] - timeout
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::SetChangeTimeOut(unsigned long uTimeout)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IHeaderCtrl2::SetChangeTimeOut"));
|
|
|
|
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
sc = m_spListViewPrivate->SetChangeTimeOut(uTimeout);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::SetColumnFilter
|
|
//
|
|
// Synopsis: Set filter for a column.
|
|
//
|
|
// Arguments: [nColumn] - Column index.
|
|
// [dwType] - Filter type.
|
|
// [pFilterData] - Filter data.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::SetColumnFilter(UINT nColumn, DWORD dwType, MMC_FILTERDATA* pFilterData)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IHeaderCtrl2::SetColumnFilter"));
|
|
|
|
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
sc = m_spListViewPrivate->SetColumnFilter(nColumn, dwType, pFilterData);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::GetColumnFilter
|
|
//
|
|
// Synopsis: Get filter data.
|
|
//
|
|
// Arguments: [nColumn] - Column index.
|
|
// [pdwType] - Filter type.
|
|
// [pFilterData] - Filter data.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::GetColumnFilter(UINT nColumn, LPDWORD pdwType, MMC_FILTERDATA* pFilterData)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IHeaderCtrl2::GetColumnFilter"));
|
|
|
|
if (pdwType == NULL)
|
|
{
|
|
sc = E_POINTER;
|
|
TraceSnapinError(_T("NULL filtertype ptr"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
if (NULL == pFilterData)
|
|
{
|
|
sc = E_POINTER;
|
|
TraceSnapinError(_T("NULL FilterData ptr"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
sc = m_spListViewPrivate->GetColumnFilter(nColumn, pdwType, pFilterData);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::ShowTopic
|
|
//
|
|
// Synopsis: Display specified help topic.
|
|
//
|
|
// Arguments: [pszHelpTopic]
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::ShowTopic(LPOLESTR pszHelpTopic)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IDisplayHelp::ShowTopic"));
|
|
|
|
// Get the AMCView window
|
|
CConsoleView* pConsoleView = GetConsoleView();
|
|
sc = ScCheckPointers(pConsoleView, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
|
|
/*
|
|
* first MUI localize the help topic if possible so it matches what we have in the collection
|
|
*
|
|
*/
|
|
|
|
//NOTE: WTL::CString may throw exceptions; the following code matches exception handling behavior of CHelpDoc,
|
|
//which is to just let exceptions bubble up
|
|
|
|
USES_CONVERSION;
|
|
WTL::CString strPathTopic = W2T(pszHelpTopic);
|
|
|
|
//the topic will be passed in formed like: "WINDOWS\help\sys_srv.chm::/sys_srv_overview.htm"
|
|
//parse off the path and topic, which is delimited by "::"
|
|
int iDelim = strPathTopic.Find(TOPIC_DELIMITER);
|
|
if (iDelim == -1)
|
|
{
|
|
//invalid format
|
|
sc = E_INVALIDARG;
|
|
TraceSnapinError(_T("ShowTopic - Malformed help topic"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
//pass the path to CHelpDoc::ScRedirectHelpFile, which will localize it if possible
|
|
WTL::CString strPath = strPathTopic.Left(iDelim);
|
|
WTL::CString strTopic = strPathTopic.Mid(iDelim + sizeof(TOPIC_DELIMITER)/sizeof(TOPIC_DELIMITER[0]) - 1);
|
|
|
|
//langID is an out param; we aren't concerned with the results of it here
|
|
LANGID langID;
|
|
//ScRedirectHelpFile will convert strPath to localized path if possible
|
|
sc = CHelpDoc::ScRedirectHelpFile(strPath, langID);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
//build the help topic back up
|
|
strPathTopic.Format(_T("%s") TOPIC_DELIMITER _T("%s"),strPath, strTopic);
|
|
|
|
sc = pConsoleView->ScShowSnapinHelpTopic ( (LPCTSTR)strPathTopic);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::AddExtension
|
|
//
|
|
// Synopsis: Add a dynamic extension snapin to given HSCOPEITEM.
|
|
//
|
|
// Arguments: [hItem] -
|
|
// [lpclsid] - CLSID of snapin to be added.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::AddExtension(HSCOPEITEM hItem, LPCLSID lpclsid)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IConsoleNameSpace2::AddExtension"));
|
|
|
|
COMPONENTID nID;
|
|
GetComponentID(&nID);
|
|
|
|
if (nID == -1)
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
return sc.ToHr();
|
|
}
|
|
|
|
if (lpclsid == NULL)
|
|
{
|
|
sc = E_POINTER;
|
|
TraceSnapinError(_T("NULL LPCLSID ptr"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
CMTNode *pMTNode = CMTNode::FromScopeItem (hItem);
|
|
|
|
if (pMTNode == NULL)
|
|
{
|
|
sc = E_INVALIDARG;
|
|
TraceSnapinError(_T("Invalid hItem"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
// Can not add extensions to other components' nodes
|
|
// Do we need to protect TV owned nodes that do not represent this snapin?
|
|
if (pMTNode->GetOwnerID() != nID && pMTNode->GetOwnerID() != TVOWNED_MAGICWORD)
|
|
{
|
|
sc = E_INVALIDARG;
|
|
return sc.ToHr();
|
|
}
|
|
|
|
sc = pMTNode->AddExtension(lpclsid);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Private methods
|
|
|
|
HRESULT CNodeInitObject::CheckArgument(VARIANT* pArg)
|
|
{
|
|
if (pArg == NULL)
|
|
return E_POINTER;
|
|
|
|
// VT_NULL is acceptable
|
|
if (pArg->vt == VT_NULL)
|
|
return S_OK;
|
|
|
|
// VT_UNKNOWN with a valid pointer is acceptable
|
|
if (pArg->punkVal != NULL)
|
|
{
|
|
if (pArg->vt == VT_UNKNOWN)
|
|
return S_OK;
|
|
else
|
|
return E_INVALIDARG;
|
|
}
|
|
else
|
|
{
|
|
return E_POINTER;
|
|
}
|
|
|
|
// any other VT type is unacceptable
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
//
|
|
//
|
|
//
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
STDMETHODIMP CNodeInitObject::QueryScopeTree(IScopeTree** ppScopeTree)
|
|
{
|
|
|
|
ASSERT(ppScopeTree != NULL);
|
|
|
|
if (ppScopeTree == NULL)
|
|
return E_POINTER;
|
|
|
|
ASSERT(m_spScopeTree != NULL);
|
|
if (m_spScopeTree == NULL)
|
|
return E_UNEXPECTED;
|
|
|
|
*ppScopeTree = m_spScopeTree;
|
|
(*ppScopeTree)->AddRef();
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
STDMETHODIMP CNodeInitObject::SetScopeTree(IScopeTree* pScopeTree)
|
|
{
|
|
|
|
m_spScopeTree = pScopeTree;
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
HRESULT CNodeInitObject::GetSnapInAndNodeType(LPDATAOBJECT pDataObject,
|
|
CSnapIn** ppSnapIn, GUID* pguidObjectType)
|
|
{
|
|
ASSERT(pDataObject != NULL);
|
|
ASSERT(ppSnapIn != NULL);
|
|
ASSERT(pguidObjectType != NULL);
|
|
|
|
|
|
CLSID clsidSnapin;
|
|
HRESULT hr = ExtractSnapInCLSID(pDataObject, &clsidSnapin);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
CSnapIn* pSnapIn = NULL;
|
|
SC sc = theApp.GetSnapInsCache()->ScGetSnapIn(clsidSnapin, &pSnapIn);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
// else
|
|
ASSERT(pSnapIn != NULL);
|
|
*ppSnapIn = pSnapIn;
|
|
|
|
hr = ExtractObjectTypeGUID(pDataObject, pguidObjectType);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::SelectScopeItem
|
|
//
|
|
// Synopsis: Select given scope-item.
|
|
//
|
|
// Arguments: [hScopeItem]
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::SelectScopeItem(HSCOPEITEM hScopeItem)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IConsole2::SelectScopeItem"));
|
|
|
|
CViewData* pVD = (NULL == m_pNode ) ? NULL : m_pNode->GetViewData();
|
|
|
|
CMTNode* pMTNode = CMTNode::FromScopeItem (hScopeItem);
|
|
|
|
sc = ScCheckPointers(pMTNode);
|
|
if (sc)
|
|
{
|
|
//bad handle passed in
|
|
return sc.ToHr();
|
|
}
|
|
|
|
MTNODEID id = pMTNode->GetID();
|
|
|
|
// If the currently selected node is same as the node being
|
|
// asked to be selected, there is high probability that the
|
|
// snapin is trying to change the view.
|
|
// So set the viewchanging flag.
|
|
CNode* pSelNode = (NULL == pVD) ? NULL : pVD->GetSelectedNode();
|
|
CMTNode* pSelMTNode = (NULL == pSelNode) ? NULL : pSelNode->GetMTNode();
|
|
|
|
if (pVD && pSelMTNode && (pSelMTNode == pMTNode) )
|
|
{
|
|
pVD->SetSnapinChangingView();
|
|
}
|
|
|
|
// Get the AMCView window
|
|
CConsoleView* pConsoleView = GetConsoleView();
|
|
|
|
sc = ScCheckPointers(pConsoleView, E_UNEXPECTED);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
CConsoleView::ViewPane ePane = pConsoleView->GetFocusedPane ();
|
|
sc = pConsoleView->ScSelectNode (id);
|
|
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
// ePane == ePane_None means active view is unknown
|
|
if (ePane != CConsoleView::ePane_None)
|
|
pConsoleView->ScSetFocusToPane (ePane);
|
|
|
|
|
|
// Always reset the view changing flag.
|
|
if (pVD)
|
|
{
|
|
pVD->ResetSnapinChangingView();
|
|
}
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::QueryConsoleVerb
|
|
//
|
|
// Synopsis: Get the IConsoleVerb for setting standard verbs.
|
|
//
|
|
// Arguments: [ppConsoleVerb]
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::QueryConsoleVerb(LPCONSOLEVERB* ppConsoleVerb)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IConsole2::QueryConsoleVerb"));
|
|
|
|
if (ppConsoleVerb == NULL)
|
|
{
|
|
sc = E_POINTER;
|
|
TraceSnapinError(_T("NULL LPCONSOLEVERB ptr"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
if (m_pNode == NULL)
|
|
{
|
|
sc = E_FAIL;
|
|
TraceSnapinError(_T("You can query console verb only from the IConsole associated with IComponents"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
if (m_spConsoleVerb == NULL)
|
|
{
|
|
// Create new CConsoleVerbImpl.
|
|
CComObject<CConsoleVerbImpl>* pVerb;
|
|
sc = CComObject<CConsoleVerbImpl>::CreateInstance(&pVerb);
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
if (NULL == pVerb)
|
|
{
|
|
sc = E_OUTOFMEMORY;
|
|
return sc.ToHr();
|
|
}
|
|
|
|
CViewData* pViewData = m_pNode->GetViewData();
|
|
if (NULL == pViewData)
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
return sc.ToHr();
|
|
}
|
|
|
|
pVerb->SetVerbSet(m_pNode->GetViewData()->GetVerbSet());
|
|
|
|
m_spConsoleVerb = pVerb;
|
|
if (NULL == m_spConsoleVerb)
|
|
{
|
|
sc = E_NOINTERFACE;
|
|
return sc.ToHr();
|
|
}
|
|
|
|
}
|
|
|
|
*ppConsoleVerb = (IConsoleVerb*)m_spConsoleVerb;
|
|
(*ppConsoleVerb)->AddRef();
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::NewWindow
|
|
//
|
|
// Synopsis: Create a new window from given node.
|
|
//
|
|
// Arguments: [hScopeItem] - Root of new window.
|
|
// [lOptions] - New window options.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::NewWindow(HSCOPEITEM hScopeItem, unsigned long lOptions)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IConsole2::NewWindow"));
|
|
|
|
if (!hScopeItem)
|
|
{
|
|
sc = E_INVALIDARG;
|
|
TraceSnapinError(_T("NULL HSCOPEITEM"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
CConsoleFrame* pFrame = GetConsoleFrame();
|
|
if (pFrame == NULL)
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
return sc.ToHr();
|
|
}
|
|
|
|
CMTNode* pMTNode = CMTNode::FromScopeItem (hScopeItem);
|
|
if (NULL == pMTNode)
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
return sc.ToHr();
|
|
}
|
|
|
|
CreateNewViewStruct cnvs;
|
|
cnvs.idRootNode = pMTNode->GetID();
|
|
cnvs.lWindowOptions = lOptions;
|
|
cnvs.fVisible = true;
|
|
|
|
sc = pFrame->ScCreateNewView(&cnvs).ToHr();
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::Expand
|
|
//
|
|
// Synopsis: Visually expand or collapse an item.
|
|
//
|
|
// Arguments: [hScopeItem] - Item to be expanded/collapsed.
|
|
// [bExpand] - Expand/Collapse.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::Expand( HSCOPEITEM hScopeItem, BOOL bExpand)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IConsole2::Expand"));
|
|
|
|
if (m_pNode == NULL || m_pNode->GetViewData() == NULL)
|
|
{
|
|
sc = E_FAIL;
|
|
return sc.ToHr();
|
|
}
|
|
|
|
long id = 0;
|
|
|
|
CMTNode* pMTNode = CMTNode::FromScopeItem (hScopeItem);
|
|
if (pMTNode == NULL)
|
|
{
|
|
sc = E_INVALIDARG;
|
|
TraceSnapinError(_T("NULL HSCOPEITEM"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
id = pMTNode->GetID();
|
|
|
|
{
|
|
/*
|
|
* tell this node's view to expand the node (use only this node's
|
|
* view, don't default to the active view if we have no node)
|
|
*/
|
|
CConsoleView* pConsoleView = GetConsoleView (false);
|
|
if (pConsoleView == NULL)
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
return sc.ToHr();
|
|
}
|
|
|
|
sc = pConsoleView->ScExpandNode (id, bExpand, true);
|
|
}
|
|
|
|
return (sc.ToHr());
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::IsTaskpadViewPreferred
|
|
//
|
|
// Synopsis: Obsolete method.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::IsTaskpadViewPreferred()
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IConsole2::IsTaskpadViewPreferred"));
|
|
|
|
/*
|
|
* taskpads always "preferred"
|
|
*/
|
|
return sc.ToHr();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::SetStatusText
|
|
//
|
|
// Synopsis: Change status bar text.
|
|
//
|
|
// Arguments: [pszStatusBarText]
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::SetStatusText (LPOLESTR pszStatusBarText)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IConsole2::SetStatusText"));
|
|
|
|
if (m_pMTNode == NULL)
|
|
{
|
|
sc = E_FAIL;
|
|
return sc.ToHr();
|
|
}
|
|
|
|
if (m_pNode == NULL)
|
|
{
|
|
sc = E_FAIL;
|
|
return sc.ToHr();
|
|
}
|
|
|
|
CViewData* pViewData = m_pNode->GetViewData();
|
|
if (NULL == pViewData)
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
return sc.ToHr();
|
|
}
|
|
|
|
CNode* pSelectedNode = pViewData->GetSelectedNode();
|
|
|
|
if (pSelectedNode == NULL)
|
|
{
|
|
sc = E_FAIL;
|
|
return sc.ToHr();
|
|
}
|
|
|
|
CMTNode* pMTSelectedNode = pSelectedNode->GetMTNode();
|
|
if (NULL == pMTSelectedNode)
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
return sc.ToHr();
|
|
}
|
|
|
|
/*
|
|
* fail if not from the selected node's branch of the scope tree
|
|
*/
|
|
if (m_pMTNode->GetStaticParent() != pMTSelectedNode->GetStaticParent())
|
|
{
|
|
sc = E_FAIL;
|
|
return sc.ToHr();
|
|
}
|
|
|
|
COMPONENTID nOwnerID = pSelectedNode->GetOwnerID();
|
|
COMPONENTID nID;
|
|
GetComponentID(&nID);
|
|
|
|
/*
|
|
* fail if not either the selected component or the static node
|
|
*/
|
|
if (!((nOwnerID == nID) || ((nOwnerID == TVOWNED_MAGICWORD) && (nID == 0))))
|
|
{
|
|
sc = E_FAIL;
|
|
return sc.ToHr();
|
|
}
|
|
|
|
CConsoleStatusBar* pStatusBar = pViewData->GetStatusBar();
|
|
|
|
if (pStatusBar == NULL)
|
|
{
|
|
sc = E_FAIL;
|
|
return sc.ToHr();
|
|
}
|
|
|
|
USES_CONVERSION;
|
|
sc = pStatusBar->ScSetStatusText (W2CT (pszStatusBarText));
|
|
|
|
return (sc.ToHr());
|
|
}
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
*
|
|
* CNodeInitObject::RenameScopeItem
|
|
*
|
|
* PURPOSE: Puts the specified scope item into rename mode.
|
|
*
|
|
* PARAMETERS:
|
|
* HSCOPEITEM hScopeItem :
|
|
*
|
|
* RETURNS:
|
|
* STDMETHODIMP
|
|
*
|
|
*+-------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
CNodeInitObject::RenameScopeItem(HSCOPEITEM hScopeItem)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, TEXT("IConsole3::RenameScopeItem"));
|
|
|
|
CMTNode* pMTNode = CMTNode::FromScopeItem (hScopeItem);
|
|
if (pMTNode == NULL)
|
|
{
|
|
sc = E_INVALIDARG;
|
|
TraceSnapinError(_T("NULL HSCOPEITEM"), sc);
|
|
return sc.ToHr();
|
|
}
|
|
|
|
// get the console view object
|
|
CConsoleView* pConsoleView = GetConsoleView (true); // default to the active view if m_pNode == NULL
|
|
if (pConsoleView == NULL)
|
|
return (sc = E_UNEXPECTED).ToHr();
|
|
|
|
sc = pConsoleView->ScRenameScopeNode(CMTNode::ToHandle(pMTNode) /*convert to HMTNODE*/);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CNodeInitObject::GetStatusBar
|
|
*
|
|
* Returns the status bar interface for the CNodeInitObject.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
CConsoleStatusBar* CNodeInitObject::GetStatusBar(
|
|
bool fDefaultToActive /* =true */) const
|
|
{
|
|
CConsoleStatusBar* pStatusBar = NULL;
|
|
|
|
/*
|
|
* if we have a node, get the status bar from its view data
|
|
*/
|
|
if (m_pNode != NULL)
|
|
{
|
|
ASSERT (m_pNode->GetViewData() != NULL);
|
|
pStatusBar = m_pNode->GetViewData()->GetStatusBar();
|
|
}
|
|
|
|
/*
|
|
* if we don't have a status bar yet, ask the main frame which one to use
|
|
*/
|
|
if ((pStatusBar == NULL) && fDefaultToActive)
|
|
{
|
|
CConsoleFrame* pFrame = GetConsoleFrame();
|
|
ASSERT (pFrame != NULL);
|
|
|
|
if (pFrame != NULL)
|
|
pFrame->ScGetActiveStatusBar(pStatusBar);
|
|
}
|
|
|
|
return (pStatusBar);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CNodeInitObject::GetConsoleView
|
|
*
|
|
* Returns the status bar interface for the CNodeInitObject.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
CConsoleView* CNodeInitObject::GetConsoleView (
|
|
bool fDefaultToActive /* =true */) const
|
|
{
|
|
CConsoleView* pConsoleView = NULL;
|
|
|
|
/*
|
|
* if we have a node, get the console view from its view data
|
|
*/
|
|
if (m_pNode != NULL)
|
|
{
|
|
ASSERT (m_pNode->GetViewData() != NULL);
|
|
pConsoleView = m_pNode->GetViewData()->GetConsoleView();
|
|
}
|
|
|
|
/*
|
|
* if we don't have a console view yet and we want to default to the
|
|
* active view, ask the main frame which one to use
|
|
*/
|
|
if ((pConsoleView == NULL) && fDefaultToActive)
|
|
{
|
|
CConsoleFrame* pFrame = GetConsoleFrame();
|
|
ASSERT (pFrame != NULL);
|
|
|
|
if (pFrame != NULL)
|
|
pFrame->ScGetActiveConsoleView (pConsoleView);
|
|
}
|
|
|
|
return (pConsoleView);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CNodeInitObject::GetConsoleFrame
|
|
*
|
|
* Returns the CConsoleFrame interface for the console.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
CConsoleFrame* CNodeInitObject::GetConsoleFrame() const
|
|
{
|
|
CConsoleFrame* pFrame = NULL;
|
|
CScopeTree* pTree = dynamic_cast<CScopeTree*>(m_spScopeTree.GetInterfacePtr());
|
|
ASSERT (pTree != NULL);
|
|
|
|
if (pTree != NULL)
|
|
pFrame = pTree->GetConsoleFrame();
|
|
|
|
return (pFrame);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* STRING_TABLE_FORWARDER_PROLOG
|
|
*
|
|
* Standard prolog code for IStringTable forwarder functions.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
#define STRING_TABLE_FORWARDER_PROLOG(clsid, pSTP) \
|
|
CLSID clsid; \
|
|
VERIFY (SUCCEEDED (GetSnapinCLSID (clsid))); \
|
|
\
|
|
IStringTablePrivate* pSTP = CScopeTree::GetStringTable(); \
|
|
\
|
|
if (pSTP == NULL) \
|
|
return (E_FAIL); \
|
|
else \
|
|
(void) 0
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::AddString
|
|
//
|
|
// Synopsis: Add a string to the string table.
|
|
//
|
|
// Arguments: [pszAdd] - string to add
|
|
// [pID] - ret, string id.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::AddString (
|
|
LPCOLESTR pszAdd,
|
|
MMC_STRING_ID* pID)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IStringTable::AddString"));
|
|
|
|
STRING_TABLE_FORWARDER_PROLOG (clsid, pStringTablePrivate);
|
|
sc = pStringTablePrivate->AddString (pszAdd, pID, &clsid);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::GetString
|
|
//
|
|
// Synopsis: Get the string represented by given id.
|
|
//
|
|
// Arguments: [id]
|
|
// [cchBuffer] - Size of buffer.
|
|
// [lpBuffer]
|
|
// [pchchOut]
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::GetString (
|
|
MMC_STRING_ID id,
|
|
ULONG cchBuffer,
|
|
LPOLESTR lpBuffer,
|
|
ULONG* pcchOut)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IStringTable::GetString"));
|
|
|
|
STRING_TABLE_FORWARDER_PROLOG (clsid, pStringTablePrivate);
|
|
sc = pStringTablePrivate->GetString (id, cchBuffer, lpBuffer, pcchOut, &clsid);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::GetStringLength
|
|
//
|
|
// Synopsis: Get the length of string represented by given string id.
|
|
//
|
|
// Arguments: [id] - string id.
|
|
// [pcchString] - ret ptr to len.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::GetStringLength (
|
|
MMC_STRING_ID id,
|
|
ULONG* pcchString)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IStringTable::GetStringLength"));
|
|
|
|
STRING_TABLE_FORWARDER_PROLOG (clsid, pStringTablePrivate);
|
|
sc = pStringTablePrivate->GetStringLength (id, pcchString, &clsid);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::DeleteString
|
|
//
|
|
// Synopsis: Delete the string represented by given string id.
|
|
//
|
|
// Arguments: [id]
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::DeleteString (
|
|
MMC_STRING_ID id)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IStringTable::DeleteString"));
|
|
|
|
STRING_TABLE_FORWARDER_PROLOG (clsid, pStringTablePrivate);
|
|
sc = pStringTablePrivate->DeleteString (id, &clsid);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::DeleteAllStrings
|
|
//
|
|
// Synopsis: Delete all strings (for this snapin).
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::DeleteAllStrings ()
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IStringTable::DeleteAllStrings"));
|
|
|
|
STRING_TABLE_FORWARDER_PROLOG (clsid, pStringTablePrivate);
|
|
sc = pStringTablePrivate->DeleteAllStrings (&clsid);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::FindString
|
|
//
|
|
// Synopsis: Find if given string exists, if so ret its string-id.
|
|
//
|
|
// Arguments: [pszFind] - string to find.
|
|
// [pID] - string id (retval).
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::FindString (
|
|
LPCOLESTR pszFind,
|
|
MMC_STRING_ID* pID)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IStringTable::FindString"));
|
|
|
|
STRING_TABLE_FORWARDER_PROLOG (clsid, pStringTablePrivate);
|
|
sc = pStringTablePrivate->FindString (pszFind, pID, &clsid);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CNodeInitObject::Enumerate
|
|
//
|
|
// Synopsis: Get an enumerator to (this snapins) string table.
|
|
//
|
|
// Arguments: [ppEnum]
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDMETHODIMP CNodeInitObject::Enumerate (
|
|
IEnumString** ppEnum)
|
|
{
|
|
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IStringTable::Enumerate"));
|
|
|
|
STRING_TABLE_FORWARDER_PROLOG (clsid, pStringTablePrivate);
|
|
sc = pStringTablePrivate->Enumerate (ppEnum, &clsid);
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CNodeInitObject::GetSnapinCLSID
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
HRESULT CNodeInitObject::GetSnapinCLSID (CLSID& clsid) const
|
|
{
|
|
SC sc; // We do not want to break if this function returns failure
|
|
// so we do not use DECLARE_SC.
|
|
|
|
ASSERT (!IsBadWritePtr (&clsid, sizeof (CLSID)));
|
|
|
|
if (NULL == m_pMTNode)
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
return sc.ToHr();
|
|
}
|
|
|
|
CSnapIn* pSnapin = m_pMTNode->GetPrimarySnapIn();
|
|
|
|
if (NULL == pSnapin)
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
return sc.ToHr();
|
|
}
|
|
|
|
clsid = pSnapin->GetSnapInCLSID();
|
|
|
|
return sc.ToHr();
|
|
}
|
|
|
|
/***************************************************************************\
|
|
*
|
|
* METHOD: CNodeInitObject::ReleaseCachedOleObjects
|
|
*
|
|
* PURPOSE: Releases cached OLE objects. Calls are made from CONUI
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
* RETURNS:
|
|
* SC - result code
|
|
*
|
|
\***************************************************************************/
|
|
HRESULT CNodeInitObject::ReleaseCachedOleObjects()
|
|
{
|
|
DECLARE_SC(sc, TEXT("CNodeInitObject::GetSnapinCLSID"));
|
|
|
|
sc = COleCacheCleanupManager::ScReleaseCachedOleObjects();
|
|
if (sc)
|
|
return sc.ToHr();
|
|
|
|
return sc.ToHr();
|
|
}
|