able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/activec/nodemgr/rsltdata.cpp

1231 lines
33 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
//
// Copyright (C) Microsoft Corporation, 1999 - 1999
//
// File: rsltdata.cpp
//
//--------------------------------------------------------------------------
#include "stdafx.h"
#include "menuitem.h" // MENUITEM_BASE_ID
#include "amcmsgid.h"
#include "conview.h"
#include "rsltitem.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::SetResultView
//
// Synopsis: Save the result view ptr.
//
// Arguments: [pUnknown] -
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::SetResultView(LPUNKNOWN pUnknown)
{
DECLARE_SC(sc, _T("CNodeInitObject::SetResultView"));
m_spResultViewUnk = pUnknown;
m_spListViewPrivate = pUnknown;
// If the resultview is reset then reset the desc bar.
if (NULL == pUnknown)
SetDescBarText( L"" );
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::IsResultViewSet
//
// Synopsis: Is the ResultView ptr set (so that conui can query
// before invoking ResultView methods).
//
// Arguments: [pbIsLVSet] - Ptr to BOOL. (TRUE means ResultView is set).
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::IsResultViewSet(BOOL* pbIsLVSet)
{
DECLARE_SC(sc, _T("CNodeInitObject::IsResultViewSet"));
sc = ScCheckPointers(pbIsLVSet);
if (sc)
return sc.ToHr();
*pbIsLVSet = FALSE;
if (m_spListViewPrivate)
*pbIsLVSet = TRUE;
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::SetTaskPadList
//
// Synopsis:
//
// Arguments:
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::SetTaskPadList(LPUNKNOWN pUnknown)
{
DECLARE_SC(sc, _T("CNodeInitObject::SetTaskPadList"));
if (pUnknown == NULL)
{
m_spListViewPrivate = NULL;
}
else
{
if (m_spListViewPrivate == pUnknown)
{
return sc.ToHr();
}
else
{
ASSERT(m_spListViewPrivate == NULL);
m_spListViewPrivate = pUnknown;
}
}
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::QueryResultView
//
// Synopsis: IConsole2 method for snapins to get resultview's IUnknown.
//
// Arguments: [ppUnk] - return IUnknown to snapin.
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::QueryResultView(LPUNKNOWN* ppUnk)
{
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IConsole2::QueryResultView"));
if (!ppUnk)
{
sc = E_INVALIDARG;
TraceSnapinError(_T("Null LPUNKNOWN pointer passed in"), sc);
return sc.ToHr();
}
(*ppUnk) = m_spResultViewUnk;
sc = ScCheckPointers((*ppUnk), E_UNEXPECTED);
if (sc)
return sc.ToHr();
(*ppUnk)->AddRef();
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::MessageBox
//
// Synopsis: IConsole2 member, called by snapin to display a message box.
//
// Arguments: [lpszText] - Text to display.
// [lpszTitle] -
// [fuStyle] -
// [piRetval] -
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::MessageBox(
LPCWSTR lpszText, LPCWSTR lpszTitle, UINT fuStyle, int* piRetval)
{
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IConsole2::MessageBox"));
USES_CONVERSION;
// find the main frame window and use it as the owner of the message box
INT iRetval = ::MessageBox(
GetMainWindow(),
W2CT(lpszText),
W2CT(lpszTitle),
fuStyle );
if (NULL != piRetval)
*piRetval = iRetval;
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::GetListStyle
//
// Synopsis: Get the current list view style.
//
// Arguments: [pStyle] -
//
// Note: IResultDataPrivate member, internal to MMC.
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::GetListStyle(long * pStyle)
{
DECLARE_SC(sc, _T("CNodeInitObject::GetListStyle"));
// must have pStyle
if (!pStyle)
{
sc = E_INVALIDARG;
TraceError(_T("CNodeinitObject::GetListStyle, style ptr passed is NULL"), sc);
return sc.ToHr();
}
if (NULL == m_spListViewPrivate)
{
sc = E_UNEXPECTED;
TraceError(_T("CNodeinitObject::GetListStyle, ListView ptr is NULL"), sc);
return sc.ToHr();
}
*pStyle = m_spListViewPrivate->GetListStyle();
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::SetListStyle
//
// Synopsis: Modify the list view style.
//
// Arguments: [style] -
//
// Note: IResultDataPrivate member, internal to MMC.
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::SetListStyle(long style)
{
DECLARE_SC(sc, _T("CNodeInitObject::SetListStyle"));
if (NULL == m_spListViewPrivate)
{
sc = E_UNEXPECTED;
TraceError(_T("CNodeinitObject::GetListStyle, ListView ptr is NULL"), sc);
return sc.ToHr();
}
sc = m_spListViewPrivate->SetListStyle(style);
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::ModifyItemState
//
// Synopsis: Enables snapin to modify the state of an item.
//
// Arguments: [nIndex] - index of the item to be modified (used only if itemID is 0).
// [itemID] - HRESULTITEM if not virtual-list (Virtual list use above index).
// [uAdd] - States to add.
// [uRemove] - States to be removed.
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::ModifyItemState(int nIndex, HRESULTITEM hri,
UINT uAdd, UINT uRemove)
{
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IResultData::ModifyItemState"));
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
if (sc)
return sc.ToHr();
sc = m_spListViewPrivate->ModifyItemState(nIndex, CResultItem::FromHandle(hri), uAdd, uRemove);
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::ModifyViewStyle
//
// Synopsis: Allows snapin to modify list view style.
//
// Arguments: [add] - Styles to be set.
// [remove] - Styles to be removed.
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::ModifyViewStyle(MMC_RESULT_VIEW_STYLE add,
MMC_RESULT_VIEW_STYLE remove)
{
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IResultData::ModifyViewStyle"));
typedef struct {
MMC_RESULT_VIEW_STYLE mmcFlag;
DWORD lvsFlag;
} FlagMapEntry;
FlagMapEntry flagMap[] =
{
{MMC_SINGLESEL, LVS_SINGLESEL},
{MMC_SHOWSELALWAYS, LVS_SHOWSELALWAYS},
{MMC_NOSORTHEADER, LVS_NOSORTHEADER},
{MMC_ENSUREFOCUSVISIBLE, MMC_LVS_ENSUREFOCUSVISIBLE},
{(MMC_RESULT_VIEW_STYLE)0, 0}
};
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
if (sc)
return sc.ToHr();
// Get the old style.
DWORD dwLVStyle = static_cast<DWORD>(m_spListViewPrivate->GetListStyle());
// convert MMC_ flags to LVS_ flags and apply to current style
for (FlagMapEntry* pMap = flagMap; pMap->mmcFlag; pMap++)
{
if (add & pMap->mmcFlag)
dwLVStyle |= pMap->lvsFlag;
if (remove & pMap->mmcFlag)
dwLVStyle &= ~pMap->lvsFlag;
}
sc = m_spListViewPrivate->SetListStyle(static_cast<long>(dwLVStyle));
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::InsertItem
//
// Synopsis: Insert an item into ListView (IResultData member).
//
// Arguments: [item] -
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::InsertItem(LPRESULTDATAITEM item)
{
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IResultData::InsertItem"));
// MUST have an item structure.
if (!item)
{
sc = E_INVALIDARG;
TraceSnapinError(_T("The LPRESULTDATAITEM ptr passed in is NULL"), sc);
return sc.ToHr();
}
COMPONENTID nID;
GetComponentID(&nID);
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
if (sc)
return sc.ToHr();
CResultItem* pri = NULL;
sc = m_spListViewPrivate->InsertItem(
item->mask & RDI_STR ? item->str : MMCLV_NOPTR,
item->mask & RDI_IMAGE ? item->nImage : MMCLV_NOICON,
item->mask & RDI_PARAM ? item->lParam : MMCLV_NOPARAM,
item->mask & RDI_STATE ? item->nState : MMCLV_NOPARAM,
nID, item->nIndex, pri);
if (sc)
return (sc.ToHr());
if (pri == NULL)
return ((sc = E_UNEXPECTED).ToHr());
item->itemID = CResultItem::ToHandle(pri);
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::DeleteItem
//
// Synopsis: Delete the given item (IResultData member).
//
// Arguments: [itemID] - item identifier.
// [nCol] - column to delete.
//
// Note: nCol must be zero.
//
// Returns: HREsULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::DeleteItem(HRESULTITEM itemID, int nCol)
{
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IResultData::DeleteItem"));
if (nCol != 0)
{
sc = E_INVALIDARG;
TraceSnapinError(_T("Column index must be zero"), sc);
return sc.ToHr();
}
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
if (sc)
return sc.ToHr();
sc = m_spListViewPrivate->DeleteItem ( itemID, nCol);
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::UpdateItem
//
// Synopsis: Redraw the given item.
//
// Arguments: [itemID] - Item identifier.
//
// Returns: SC
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::UpdateItem(HRESULTITEM itemID)
{
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IResultData::UpdateItem"));
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
if (sc)
return sc.ToHr();
sc = m_spListViewPrivate->UpdateItem(itemID);
if (sc)
return sc.ToHr();
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: Sort
//
// Synopsis: IResultData member, snapins can call this to sort the
// result pane items. This calls InternalSort to do sort.
//
// Arguments: [nCol] - Column to be sorted.
// [dwSortOptions] - Sort options.
// [lUserParam] - User (snapin) param.
//
// Returns: HRESULT
//
// History: RaviR Created
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::Sort(int nCol, DWORD dwSortOptions, LPARAM lUserParam)
{
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IResultData::Sort"));
sc = ScCheckPointers(m_spComponent, E_UNEXPECTED);
if (sc)
return sc.ToHr();
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
if (sc)
return sc.ToHr();
int nColumnCnt;
sc = m_spListViewPrivate->GetColumnCount(&nColumnCnt);
if (sc)
return sc.ToHr();
if (nCol < 0 || nCol >= nColumnCnt)
{
sc = E_INVALIDARG;
TraceSnapinError(_T("Column index is invalid"), sc);
return sc.ToHr();
}
sc = InternalSort(nCol, dwSortOptions, lUserParam, FALSE);
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: InternalSort
//
// Synopsis: Private member MMC calls to sort the result pane items.
//
// Arguments: [nCol] - Column to be sorted.
// [dwSortOptions] - Sort options.
// [lUserParam] - User (snapin) param.
// [bColumnClicked] - Is sort due to column click.
//
// Note: If column is clicked the lUserParam will be NULL.
// The sort options is set depending on ascend/descend,
// and cannot include RSI_NOSORTICON as this option is
// only for snapin initiated sort.
//
// Returns: HRESULT
//
// History: RaviR Created
// 07-02-1999 AnandhaG added setsorticon.
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::InternalSort(INT nCol, DWORD dwSortOptions,
LPARAM lUserParam, BOOL bColumnClicked)
{
DECLARE_SC(sc, _T("CNodeInitObject::InternalSort"));
// Save old sort-column to reset its sort icon.
int nOldCol = m_sortParams.nCol;
BOOL bAscending = m_sortParams.bAscending;
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
if (sc)
return sc.ToHr();
// If column is clicked the sortoption and user param are
// already 0. Set only the sortoptions below.
if (bColumnClicked)
{
if(nOldCol != nCol)
bAscending = TRUE;
else
bAscending = !m_sortParams.bAscending;
dwSortOptions |= (bAscending ? 0 : RSI_DESCENDING);
// Notify component of sort parameter change
m_spComponent->Notify(NULL, MMCN_COLUMN_CLICK, nCol,dwSortOptions);
}
bool bIsVirtualList = false;
sc = ScIsVirtualList(bIsVirtualList);
if (sc)
return sc.ToHr();
if ( bIsVirtualList )
{
// see if the snap-in handle owner data methods
IResultOwnerDataPtr pResultOwnerData = m_spComponent;
if (pResultOwnerData != NULL)
{
sc = pResultOwnerData->SortItems(nCol,dwSortOptions,lUserParam );
// if reordering done, save the sort data and repaint the list view.
if (S_OK == sc.ToHr())
{
m_sortParams.nCol = nCol;
m_sortParams.bAscending = !(dwSortOptions & RSI_DESCENDING);
m_sortParams.bSetSortIcon = !(dwSortOptions & RSI_NOSORTICON);
m_sortParams.lpUserParam = lUserParam;
/*
* Bug 414256: We need to save the sort data only if
* it is user initiated sort. Is this user initiated?
*/
m_sortParams.bUserInitiatedSort = bColumnClicked;
sc = m_spListViewPrivate->Repaint(TRUE);
if (sc)
return sc.ToHr();
}
}
else
{
sc = E_UNEXPECTED;
}
}
else
{
// Query for compare interfaces
IResultDataComparePtr spResultCompare = m_spComponent;
IResultDataCompareExPtr spResultCompareEx = m_spComponent;
// Set the sort parameters.
m_sortParams.nCol = nCol;
m_sortParams.bAscending = !(dwSortOptions & RSI_DESCENDING);
m_sortParams.bSetSortIcon = !(dwSortOptions & RSI_NOSORTICON);
m_sortParams.lpUserParam = lUserParam;
m_sortParams.lpResultCompare = spResultCompare;
m_sortParams.lpResultCompareEx = spResultCompareEx;
/*
* Bug 414256: We need to save the sort data only if
* it is user initiated sort. Is this user initiated?
*/
m_sortParams.bUserInitiatedSort = bColumnClicked;
sc = m_spListViewPrivate->Sort(lUserParam, (long*)&m_sortParams);
m_sortParams.lpResultCompare = NULL;
m_sortParams.lpResultCompareEx = NULL;
}
// Set sort icon only if Sort went through.
if (S_OK == sc.ToHr())
{
sc = m_spListViewPrivate->SetColumnSortIcon( m_sortParams.nCol, nOldCol,
m_sortParams.bAscending,
m_sortParams.bSetSortIcon);
}
return sc.ToHr();
}
/***************************************************************************\
*
* METHOD: CNodeInitObject::GetSortDirection
*
* PURPOSE: returns sorting direction
*
* PARAMETERS:
* BOOL* pbAscending - resulting sort column dir
*
* RETURNS:
* SC - result code. S_FALSE ( in combination with -1 col) if no sorting.
*
\***************************************************************************/
STDMETHODIMP CNodeInitObject::GetSortDirection(BOOL* pbAscending)
{
DECLARE_SC(sc, TEXT("CNodeInitObject::GetSortDirection"));
if (pbAscending == NULL)
{
sc = E_INVALIDARG;
return sc.ToHr();
}
*pbAscending = m_sortParams.bAscending;
// If no sorting is performed then return S_FALSE.
sc = m_sortParams.nCol >= 0 ? S_OK : S_FALSE;
return sc.ToHr();
}
/***************************************************************************\
*
* METHOD: CNodeInitObject::GetSortColumn
*
* PURPOSE: returns sorting column
* sort column regardless if the user has initiated the sort or not.
*
* PARAMETERS:
* INT* pnCol - resulting sort column index
*
* RETURNS:
* SC - result code. S_FALSE ( in combination with -1 col) if no sorting.
*
\***************************************************************************/
STDMETHODIMP CNodeInitObject::GetSortColumn(INT* pnCol)
{
DECLARE_SC(sc, TEXT("CNodeInitObject::GetSortColumn"));
if (pnCol == NULL)
{
sc = E_INVALIDARG;
return sc.ToHr();
}
*pnCol = m_sortParams.nCol;
// return code depending if the valid column was got
sc = m_sortParams.nCol >= 0 ? S_OK : S_FALSE;
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::FindItemByLParam
//
// Synopsis: Find the ItemID using the user-param.
//
// Arguments: [lParam] - lParam (RESULTDATAITEM.lParam)
// [pItemID] - return the item-id.
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::FindItemByLParam(LPARAM lParam, HRESULTITEM *pItemID)
{
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IResultData::FindItemByLParam"));
if(!pItemID)
{
sc = E_INVALIDARG;
TraceSnapinError(_T("the HRESULTITEM* ptr is NULL"), sc);
return sc.ToHr();
}
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
if (sc)
return sc.ToHr();
COMPONENTID id;
GetComponentID(&id);
/*
* init the output param
*/
*pItemID = NULL;
CResultItem* pri = NULL;
sc = m_spListViewPrivate->FindItemByLParam (id, lParam, pri);
if (sc == SC(E_FAIL)) // E_FAIL is legal return value.
{
sc.Clear();
return E_FAIL;
}
sc = ScCheckPointers (pri, E_UNEXPECTED);
if (sc)
return (sc.ToHr());
*pItemID = CResultItem::ToHandle(pri);
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::DeleteAllRsltItems
//
// Synopsis: Delete all the result items
//
// Arguments:
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::DeleteAllRsltItems()
{
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IResultData::DeleteAllRsltItems"));
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
if (sc)
return sc.ToHr();
COMPONENTID id;
GetComponentID(&id);
sc = m_spListViewPrivate->DeleteAllItems(id);
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::SetItem
//
// Synopsis: Modify attributes of an item.
//
// Arguments: [item]
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::SetItem(LPRESULTDATAITEM item)
{
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IResultData::SetItem"));
// MUST have an item structure.
if (!item)
{
sc = E_INVALIDARG;
TraceSnapinError(_T("NULL LPRESULTDATAITEM ptr"), sc);
return sc.ToHr();
}
// Cannot set an lParam on a subItem. (thank Win32 for this)
if((item->mask & RDI_PARAM) && (item->nCol != 0))
{
sc = E_INVALIDARG;
TraceSnapinError(_T("Cannot set lParam for subitem"), sc);
return sc.ToHr();
}
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
if (sc)
return sc.ToHr();
COMPONENTID id;
GetComponentID(&id);
CResultItem* pri = CResultItem::FromHandle (item->itemID);
sc = m_spListViewPrivate->SetItem(
item->nIndex,
pri, item->nCol,
item->mask & RDI_STR ? item->str : MMCLV_NOPTR,
item->mask & RDI_IMAGE ? item->nImage : MMCLV_NOICON,
item->mask & RDI_PARAM ? item->lParam : MMCLV_NOPARAM,
item->mask & RDI_STATE ? item->nState : MMCLV_NOPARAM,
id);
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::GetNextItem
//
// Synopsis: Get the next item with specified flag set.
//
// Arguments:
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::GetNextItem(LPRESULTDATAITEM item)
{
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IResultData::GetNextItem"));
if (NULL == item)
{
sc = E_INVALIDARG;
TraceSnapinError(_T("NULL LPRESULTDATAITEM ptr"), sc);
return sc.ToHr();
}
if (NULL == (item->mask & RDI_STATE))
{
sc = E_INVALIDARG;
TraceSnapinError(_T("RDI_STATE mask not set"), sc);
return sc.ToHr();
}
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
if (sc)
return sc.ToHr();
COMPONENTID id;
GetComponentID(&id);
bool bIsVirtualList = false;
sc = ScIsVirtualList(bIsVirtualList);
if (sc)
return sc.ToHr();
HRESULT hr = S_OK;
long nIndex = item->nIndex;
CResultItem* pri = NULL;
// Assume error
item->nIndex = -1;
item->lParam = 0;
while (1)
{
sc = m_spListViewPrivate->GetNextItem (id, nIndex, item->nState,
pri, nIndex);
if (sc.ToHr() != S_OK)
{
break;
}
// Virtual list item, just return the index (lParam is zero).
if (bIsVirtualList)
{
item->nIndex = nIndex;
item->bScopeItem = FALSE;
break;
}
sc = ScCheckPointers (pri, E_FAIL);
if (sc)
break;
// Non-virtual leaf item.
if (pri->GetOwnerID() == id)
{
item->nIndex = nIndex;
item->bScopeItem = FALSE;
item->lParam = pri->GetSnapinData();
break;
}
if (!pri->IsScopeItem())
{
sc = E_UNEXPECTED;
break;
}
// This is a tree item, get the lUserParam.
CNode* pNode = CNode::FromResultItem (pri);
sc = ScCheckPointers(pNode, E_UNEXPECTED);
if (sc)
return sc.ToHr();
if (pNode->IsStaticNode() == TRUE)
break;
CMTNode* pMTNode = pNode->GetMTNode();
sc = ScCheckPointers(pMTNode, E_UNEXPECTED);
if (sc)
return sc.ToHr();
if (pMTNode->GetPrimaryComponentID() == id)
{
item->nIndex = nIndex;
item->bScopeItem = TRUE;
item->lParam = pMTNode->GetUserParam();
break;
}
}
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::GetItem
//
// Synopsis: Get the parameters of an item.
//
// Arguments: [item] - itemID is used to get the item, if itemID = 0,
// then nIndex is used.
//
// Note: For VLists itemID = 0, nIndex is used.
// nCol must be zero.
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::GetItem(LPRESULTDATAITEM item)
{
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IResultData::GetItem"));
// MUST have an item structure.
if (!item)
{
sc = E_INVALIDARG;
TraceSnapinError(_T("NULL LPRESULTDATAITEM ptr."), sc);
return sc.ToHr();
}
COMPONENTID id;
GetComponentID(&id);
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
if (sc)
return sc.ToHr();
CResultItem* pri = NULL;
sc = m_spListViewPrivate->GetItem(
item->nIndex,
pri, item->nCol,
item->mask & RDI_STR ? &item->str : MMCLV_NOPTR,
item->mask & RDI_IMAGE ? &item->nImage : MMCLV_NOPTR,
item->mask & RDI_PARAM ? &item->lParam : MMCLV_NOPTR,
item->mask & RDI_STATE ? &item->nState : MMCLV_NOPTR,
&item->bScopeItem);
if (sc)
return (sc.ToHr());
if (pri == NULL)
return ((sc = E_UNEXPECTED).ToHr());
if (pri->IsScopeItem())
{
item->bScopeItem = TRUE;
// This is a tree item, get the lUserParam.
CNode* pNode = CNode::FromResultItem (pri);
sc = ScCheckPointers(pNode, E_UNEXPECTED);
if (sc)
return sc.ToHr();
// When the static node is visible in result-pane the result pane is
// owned not by that static node's snapin so this is unexpected.
if (pNode->IsStaticNode())
return (sc = E_UNEXPECTED).ToHr();
CMTNode* pMTNode = pNode->GetMTNode();
sc = ScCheckPointers(pMTNode, E_UNEXPECTED);
if (sc)
return sc.ToHr();
if (pMTNode->GetPrimaryComponentID() != id)
return (sc = E_INVALIDARG).ToHr();
if (RDI_PARAM & item->mask)
item->lParam = pMTNode->GetUserParam();
if (RDI_IMAGE & item->mask)
item->nImage = pMTNode->GetImage();
}
item->itemID = CResultItem::ToHandle(pri);
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::SetViewMode
//
// Synopsis: Change the ListView mode (detail...)
//
// Arguments: [nViewMode] - new mode.
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::SetViewMode(LONG nViewMode)
{
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IResultData::SetViewMode"));
if (FALSE == (nViewMode >= 0 && nViewMode <= MMCLV_VIEWSTYLE_FILTERED))
{
sc = E_INVALIDARG;
TraceSnapinError(_T("Invalid view mode"), sc);
return sc.ToHr();
}
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
if (sc)
return sc.ToHr();
sc = m_spListViewPrivate->SetViewMode(nViewMode);
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::Arrange
//
// Synopsis: Arrange the items is LV.
//
// Arguments: [style]
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::Arrange(long style)
{
DECLARE_SC(sc, _T("CNodeInitObject::Arrange"));
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
if (sc)
return sc.ToHr();
sc = m_spListViewPrivate->Arrange(style);
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::GetViewMode
//
// Synopsis: Get the current view mode.
//
// Arguments: [pnViewMode] - view mode [out]
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::GetViewMode(LONG * pnViewMode)
{
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IResultData::GetViewMode"));
if (pnViewMode == MMCLV_NOPTR)
{
sc = E_INVALIDARG;
TraceSnapinError(_T("NULL ViewMode pointer"), sc);
return sc.ToHr();
}
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
if (sc)
return sc.ToHr();
*pnViewMode = m_spListViewPrivate->GetViewMode();
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::ResetResultData
//
// Synopsis: Reset the result view.
//
// Arguments:
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::ResetResultData()
{
DECLARE_SC(sc, _T("CNodeInitObject::ResetResultData"));
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
if (sc)
return sc.ToHr();
// Dont know what this assert means? (AnandhaG).
ASSERT(TVOWNED_MAGICWORD == m_componentID);
sc = m_spListViewPrivate->Reset();
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::SetLoadMode
//
// Synopsis: Used for re-drawing LV/delay sorting.
//
// Note: If ListView setup (snapin is inserting columns/items,
// MMC is applying column/view/sort settings) is going on
// then delay sorting and also turn off drawing.
//
// Arguments:
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::SetLoadMode(BOOL bState)
{
DECLARE_SC(sc, _T("CNodeInitObject::SetLoadMode"));
// Dont know what this assert means? (AnandhaG).
ASSERT(TVOWNED_MAGICWORD == m_componentID);
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
if (sc)
return sc.ToHr();
sc = m_spListViewPrivate->SetLoadMode(bState);
return sc.ToHr();
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::SetDescBarText
//
// Synopsis: Set the desc bar text for ResultPane.
//
// Arguments: [pszDescText]
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::SetDescBarText(LPOLESTR pszDescText)
{
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IResultData::SetDescBarText"));
CConsoleView* pConsoleView = GetConsoleView();
sc = ScCheckPointers(pConsoleView, E_UNEXPECTED);
if (sc)
return sc.ToHr();
// What happens if desc text is NULL?
USES_CONVERSION;
sc = pConsoleView->ScSetDescriptionBarText (W2T (pszDescText));
return (sc.ToHr());
}
//+-------------------------------------------------------------------
//
// Member: CNodeInitObject::SetItemCount
//
// Synopsis: Set the number of items in Virtual List.
//
// Arguments: [nItemCount] - # items.
// [dwOptions] - option flags.
//
// Returns: HRESULT
//
//--------------------------------------------------------------------
STDMETHODIMP CNodeInitObject::SetItemCount(int nItemCount, DWORD dwOptions)
{
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, _T("IResultData::SetItemCount"));
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
if (sc)
return sc.ToHr();
sc = m_spListViewPrivate->SetItemCount(nItemCount, dwOptions);
return sc.ToHr();
}
/*+-------------------------------------------------------------------------*
*
* CNodeInitObject::RenameResultItem
*
* PURPOSE: Places the specified result item into rename mode.
*
* PARAMETERS:
* HRESULTITEM itemID :
*
* RETURNS:
* STDMETHODIMP
*
*+-------------------------------------------------------------------------*/
STDMETHODIMP
CNodeInitObject::RenameResultItem(HRESULTITEM itemID)
{
DECLARE_SC_FOR_PUBLIC_INTERFACE(sc, TEXT("IResultData2::RenameResultItem"));
sc = ScCheckPointers(m_spListViewPrivate, E_UNEXPECTED);
if (sc)
return sc.ToHr();
sc = m_spListViewPrivate->RenameItem(itemID);
if (sc)
return sc.ToHr();
return sc.ToHr();
}
Reference in a new issue Copy permalink