//+------------------------------------------------------------------------- // // 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(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(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(); }