mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1824 lines
58 KiB
1824 lines
58 KiB
// cmponent.cpp : Implementation of CFileMgmtComponent
|
|
|
|
#include "stdafx.h"
|
|
#include "cookie.h"
|
|
#include "safetemp.h"
|
|
|
|
#include "macros.h"
|
|
USE_HANDLE_MACROS("FILEMGMT(cmponent.cpp)")
|
|
|
|
#include "ShrProp.h" // Share Properties Pages
|
|
|
|
#include "FileSvc.h" // FileServiceProvider
|
|
#include "smb.h"
|
|
#include "fpnw.h"
|
|
#include "sfm.h"
|
|
|
|
#include "dataobj.h"
|
|
#include "cmponent.h" // CFileMgmtComponent
|
|
#include "compdata.h" // CFileMgmtComponentData
|
|
#include "stdutils.h" // SynchronousCreateProcess
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
|
|
#include "stdcmpnt.cpp" // CComponent
|
|
|
|
UINT g_aColumns0[2] =
|
|
{IDS_ROOT_NAME, 0};
|
|
UINT g_aColumns1[6] =
|
|
{IDS_SHARES_SHARED_FOLDER, IDS_SHARES_SHARED_PATH, IDS_SHARES_TRANSPORT,
|
|
IDS_SHARES_NUM_SESSIONS, IDS_SHARES_COMMENT, 0};
|
|
UINT g_aColumns2[8] =
|
|
{IDS_CONN_USERNAME, IDS_CONN_COMPUTERNAME, IDS_CONN_TRANSPORT, IDS_CONN_NUM_FILES,
|
|
IDS_CONN_CONNECTED_TIME, IDS_CONN_IDLE_TIME, IDS_CONN_IS_GUEST, 0};
|
|
UINT g_aColumns3[6] =
|
|
{IDS_FILE_FILENAME, IDS_FILE_USERNAME, IDS_FILE_TRANSPORT, IDS_FILE_NUM_LOCKS,
|
|
IDS_FILE_OPEN_MODE, 0};
|
|
UINT g_aColumns4[6] =
|
|
{ IDS_SERVICE_SERVICENAME, IDS_SERVICE_DESCRIPTION, IDS_SERVICE_STATUS,
|
|
IDS_SERVICE_STARTUPTYPE, IDS_SERVICE_SECURITYCONTEXT, 0};
|
|
|
|
UINT* g_Columns[FILEMGMT_NUMTYPES] =
|
|
{ g_aColumns0, // FILEMGMT_ROOT
|
|
g_aColumns1, // FILEMGMT_SHARES
|
|
g_aColumns2, // FILEMGMT_SESSIONS
|
|
g_aColumns3, // FILEMGMT_RESOURCES
|
|
g_aColumns4, // FILEMGMT_SERVICES
|
|
NULL, // FILEMGMT_SHARE
|
|
NULL, // FILEMGMT_SESSION
|
|
NULL, // FILEMGMT_RESOURCE
|
|
NULL // FILEMGMT_SERVICE
|
|
};
|
|
|
|
UINT** g_aColumns = g_Columns;
|
|
/*
|
|
const UINT aColumns[STD_NODETYPE_NUMTYPES][STD_MAX_COLUMNS] =
|
|
{ {IDS_ROOT_NAME, 0,0,0,0,0,0},
|
|
{IDS_SHARES_SHARED_FOLDER, IDS_SHARES_SHARED_PATH, IDS_SHARES_TRANSPORT,
|
|
IDS_SHARES_NUM_SESSIONS, IDS_SHARES_COMMENT, 0,0},
|
|
{IDS_CONN_USERNAME, IDS_CONN_COMPUTERNAME, IDS_CONN_TRANSPORT, IDS_CONN_NUM_FILES,
|
|
IDS_CONN_CONNECTED_TIME, IDS_CONN_IDLE_TIME, IDS_CONN_IS_GUEST},
|
|
{IDS_FILE_FILENAME, IDS_FILE_USERNAME, IDS_FILE_TRANSPORT, IDS_FILE_NUM_LOCKS,
|
|
IDS_FILE_OPEN_MODE, 0,0},
|
|
{ IDS_SERVICE_SERVICENAME, IDS_SERVICE_DESCRIPTION, IDS_SERVICE_STATUS,
|
|
IDS_SERVICE_STARTUPTYPE, IDS_SERVICE_SECURITYCONTEXT, 0,0 },
|
|
{0,0,0,0,0,0},
|
|
{0,0,0,0,0,0},
|
|
{0,0,0,0,0,0},
|
|
{0,0,0,0,0,0}
|
|
};
|
|
*/
|
|
|
|
//
|
|
// CODEWORK this should be in a resource, for example code on loading data resources see
|
|
// D:\nt\private\net\ui\common\src\applib\applib\lbcolw.cxx ReloadColumnWidths()
|
|
// JonN 10/11/96
|
|
//
|
|
|
|
int g_aColumnWidths0[1] = {150};
|
|
int g_aColumnWidths1[5] = {AUTO_WIDTH,120 ,90 ,AUTO_WIDTH,150};
|
|
int g_aColumnWidths2[7] = {100 ,AUTO_WIDTH,90 ,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH};
|
|
int g_aColumnWidths3[5] = {120 ,AUTO_WIDTH,90 ,AUTO_WIDTH,AUTO_WIDTH};
|
|
int g_aColumnWidths4[5] = {130 ,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH};
|
|
int* g_ColumnWidths[FILEMGMT_NUMTYPES] =
|
|
{ g_aColumnWidths0, // FILEMGMT_ROOT
|
|
g_aColumnWidths1, // FILEMGMT_SHARES
|
|
g_aColumnWidths2, // FILEMGMT_SESSIONS
|
|
g_aColumnWidths3, // FILEMGMT_RESOURCES
|
|
g_aColumnWidths4, // FILEMGMT_SERVICES
|
|
NULL, // FILEMGMT_SHARE
|
|
NULL, // FILEMGMT_SESSION
|
|
NULL, // FILEMGMT_RESOURCE
|
|
NULL // FILEMGMT_SERVICE
|
|
};
|
|
int** g_aColumnWidths = g_ColumnWidths;
|
|
/*
|
|
const int aColumnWidths[STD_NODETYPE_NUMTYPES][STD_MAX_COLUMNS] =
|
|
{ {AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH}, // FILEMGMT_ROOT
|
|
{AUTO_WIDTH,120 ,90 ,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH}, // FILEMGMT_SHARES
|
|
{100 ,AUTO_WIDTH,90 ,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH}, // FILEMGMT_SESSIONS
|
|
{120 ,AUTO_WIDTH,90 ,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH}, // FILEMGMT_RESOURCES
|
|
{130 ,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH}, // FILEMGMT_SERVICES
|
|
{AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH}, // FILEMGMT_SHARE
|
|
{AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH}, // FILEMGMT_SESSION
|
|
{AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH}, // FILEMGMT_RESOURCE
|
|
{AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH,AUTO_WIDTH} // FILEMGMT_SERVICE
|
|
};
|
|
*/
|
|
|
|
CString g_cstrClientName;
|
|
CString g_cstrGuest;
|
|
CString g_cstrYes;
|
|
CString g_cstrNo;
|
|
|
|
// Note that m_pFileMgmtData is still NULL during construction
|
|
CFileMgmtComponent::CFileMgmtComponent()
|
|
: m_pControlbar( NULL )
|
|
, m_pSvcMgmtToolbar( NULL )
|
|
, m_pFileMgmtToolbar( NULL )
|
|
, m_pViewedCookie( NULL )
|
|
, m_pSelectedCookie( NULL )
|
|
, m_iSortColumn(0)
|
|
, m_dwSortFlags(0)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
}
|
|
|
|
CFileMgmtComponent::~CFileMgmtComponent()
|
|
{
|
|
TRACE_METHOD(CFileMgmtComponent,ReleaseAll);
|
|
/* now in CFileMgmtComponentData
|
|
if (m_hScManager != NULL)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( )); // required for CWaitCursor
|
|
CWaitCursor wait;
|
|
// Close the service control manager
|
|
(void)::CloseServiceHandle(m_hScManager);
|
|
} // if
|
|
*/
|
|
VERIFY( SUCCEEDED(ReleaseAll()) );
|
|
}
|
|
|
|
HRESULT CFileMgmtComponent::ReleaseAll()
|
|
{
|
|
MFC_TRY;
|
|
|
|
TRACE_METHOD(CFileMgmtComponent,ReleaseAll);
|
|
|
|
if ( NULL != m_pViewedCookie )
|
|
{
|
|
// We did not get an equal number of MMCN_SHOW(1) and
|
|
// MMCN_SHOW(0) notifications
|
|
// CODEWORK should assert here but MMC is currently broken
|
|
// ASSERT(FALSE);
|
|
m_pViewedCookie->ReleaseResultChildren();
|
|
m_pViewedCookie = NULL;
|
|
}
|
|
|
|
// We should get an equal number of MMCN_SELECT(1) and MMCN_SELECT(0) notifications
|
|
// CODEWORK should assert this but MMC is broken ASSERT( NULL == m_pSelectedCookie );
|
|
|
|
SAFE_RELEASE(m_pSvcMgmtToolbar);
|
|
SAFE_RELEASE(m_pFileMgmtToolbar);
|
|
SAFE_RELEASE(m_pControlbar);
|
|
|
|
return CComponent::ReleaseAll();
|
|
|
|
MFC_CATCH;
|
|
}
|
|
|
|
FileServiceProvider* CFileMgmtComponent::GetFileServiceProvider(
|
|
FILEMGMT_TRANSPORT transport )
|
|
{
|
|
return QueryComponentDataRef().GetFileServiceProvider(transport);
|
|
}
|
|
|
|
BOOL CFileMgmtComponent::IsServiceSnapin()
|
|
{
|
|
return QueryComponentDataRef().IsServiceSnapin();
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// IComponent Implementation
|
|
|
|
|
|
HRESULT CFileMgmtComponent::LoadStrings()
|
|
{
|
|
Service_LoadResourceStrings();
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CFileMgmtComponent::LoadColumns( CFileMgmtCookie* pcookie )
|
|
{
|
|
TEST_NONNULL_PTR_PARAM(pcookie);
|
|
|
|
ASSERT(m_pHeader != NULL);
|
|
|
|
#ifdef SNAPIN_PROTOTYPER
|
|
(void)Prototyper_FInsertColumns(pcookie);
|
|
return S_OK;
|
|
#endif
|
|
|
|
if (g_cstrGuest.IsEmpty())
|
|
VERIFY(g_cstrGuest.LoadString(IDS_GUEST));
|
|
if (g_cstrYes.IsEmpty())
|
|
VERIFY(g_cstrYes.LoadString(IDS_YES));
|
|
if (g_cstrNo.IsEmpty())
|
|
VERIFY(g_cstrNo.LoadString(IDS_NO));
|
|
|
|
return LoadColumnsFromArrays( pcookie->QueryObjectType() );
|
|
}
|
|
|
|
// OnPropertyChange() is generated by MMCPropertyChangeNotify( param )
|
|
HRESULT CFileMgmtComponent::OnPropertyChange( LPARAM param )
|
|
{
|
|
LPDATAOBJECT pdataobject = reinterpret_cast<LPDATAOBJECT> (param);
|
|
VERIFY( SUCCEEDED( RefreshAllViews(pdataobject) ) );
|
|
|
|
// The recipient of this notification is required to release the data object
|
|
(void) pdataobject->Release();
|
|
|
|
return S_OK;
|
|
} // CFileMgmtComponent::OnPropertyChange()
|
|
|
|
//
|
|
// In case of multiselect, piDataObject may point to a composite data object (MMC_MS_DO).
|
|
// RefreshAllViewsOnSelectedObject will crack down MMC_MS_DO to retrieve SI_MS_DO, then call
|
|
// RefreshAllViews on one of the selected objects in the internal list.
|
|
//
|
|
HRESULT CFileMgmtComponent::RefreshAllViewsOnSelectedObject(LPDATAOBJECT piDataObject)
|
|
{
|
|
BOOL bMultiSelectObject = IsMultiSelectObject(piDataObject);
|
|
if (!bMultiSelectObject)
|
|
return RefreshAllViews(piDataObject);
|
|
|
|
//
|
|
// piDataObject is the composite data object (MMC_MS_DO) created by MMC.
|
|
// We need to crack it to retrieve the multiselect data object (SI_MS_DO)
|
|
// we provided to MMC in QueryDataObject().
|
|
//
|
|
IDataObject *piSIMSDO = NULL;
|
|
HRESULT hr = GetSnapinMultiSelectDataObject(piDataObject, &piSIMSDO);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CFileMgmtDataObject *pDataObj = NULL;
|
|
hr = ExtractData(piSIMSDO, CFileMgmtDataObject::m_CFInternal, &pDataObj, sizeof(pDataObj));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// get the internal list of data objects of selected items, operate on one of them.
|
|
//
|
|
CDataObjectList* pMultiSelectObjList = pDataObj->GetMultiSelectObjList();
|
|
ASSERT(!pMultiSelectObjList->empty());
|
|
hr = RefreshAllViews(*(pMultiSelectObjList->begin()));
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
// Forces all views of the specified data object to refresh
|
|
HRESULT CFileMgmtComponent::RefreshAllViews( LPDATAOBJECT pDataObject )
|
|
{
|
|
if ( NULL == pDataObject || NULL == m_pConsole )
|
|
{
|
|
ASSERT(FALSE);
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
// This is new code for updating the Service list using a mark-and-sweep algorithm.
|
|
// Eventually this should be applied to all result cookies.
|
|
CCookie* pbasecookie = NULL;
|
|
HRESULT hr = ExtractData(
|
|
pDataObject,
|
|
CDataObject::m_CFRawCookie,
|
|
&pbasecookie,
|
|
sizeof(pbasecookie) );
|
|
RETURN_HR_IF_FAIL; // MMC shouldn't have given me someone else's cookie
|
|
pbasecookie = QueryBaseComponentDataRef().ActiveBaseCookie( pbasecookie );
|
|
CFileMgmtCookie* pUpdatedCookie = dynamic_cast<CFileMgmtCookie*>(pbasecookie);
|
|
RETURN_E_FAIL_IF_NULL(pUpdatedCookie);
|
|
FileMgmtObjectType objTypeForUpdatedCookie = pUpdatedCookie->QueryObjectType();
|
|
if ( FILEMGMT_SERVICE == objTypeForUpdatedCookie )
|
|
{
|
|
if ( NULL == m_pViewedCookie
|
|
|| FILEMGMT_SERVICES != m_pViewedCookie->QueryObjectType()
|
|
)
|
|
{
|
|
return S_OK; // not a service cookie update
|
|
}
|
|
pUpdatedCookie = dynamic_cast<CFileMgmtCookie*>(m_pViewedCookie);
|
|
RETURN_E_FAIL_IF_NULL(pUpdatedCookie);
|
|
objTypeForUpdatedCookie = FILEMGMT_SERVICES;
|
|
}
|
|
if ( FILEMGMT_SERVICES == objTypeForUpdatedCookie )
|
|
{
|
|
CFileMgmtScopeCookie* pScopeCookie = dynamic_cast<CFileMgmtScopeCookie*>(pUpdatedCookie);
|
|
RETURN_E_FAIL_IF_NULL(pScopeCookie);
|
|
|
|
// "Mark" -- Mark all existing list elements as "delete"
|
|
pScopeCookie->MarkResultChildren( NEWRESULTCOOKIE_DELETE );
|
|
|
|
// "Sweep" -- Read the new list. When a new element is the same object
|
|
// as an existing element not yet seen, mark the old element as "old"
|
|
// and update its fields. Otherwise, add it as a "new" element.
|
|
hr = QueryComponentDataRef().Service_PopulateServices(m_pResultData, pScopeCookie);
|
|
RETURN_HR_IF_FAIL;
|
|
|
|
// Refresh all views to conform with the new list.
|
|
hr = m_pConsole->UpdateAllViews( pDataObject, 2L, 0L );
|
|
RETURN_HR_IF_FAIL;
|
|
|
|
// UpdateToolbar if selected
|
|
hr = m_pConsole->UpdateAllViews( pDataObject, 3L, 0L );
|
|
RETURN_HR_IF_FAIL;
|
|
|
|
// Remove items which are still marked "delete".
|
|
pScopeCookie->RemoveMarkedChildren();
|
|
|
|
pScopeCookie->MarkResultChildren( NEWRESULTCOOKIE_OLD );
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// JonN 1/27/00: WinSE 5875: The refresh action is liable to delete pDataObject
|
|
// unless we keep an extra refcount. In practice, this only appears to happen
|
|
// when we delete a share in taskpad view.
|
|
//
|
|
CComPtr<IDataObject> spDataObject = pDataObject;
|
|
|
|
// clear all views of this data
|
|
hr = m_pConsole->UpdateAllViews( pDataObject, 0L, 0L );
|
|
RETURN_HR_IF_FAIL;
|
|
|
|
// reread all views of this data
|
|
hr = m_pConsole->UpdateAllViews( pDataObject, 1L, 0L );
|
|
RETURN_HR_IF_FAIL;
|
|
|
|
// UpdateToolbar if selected
|
|
hr = m_pConsole->UpdateAllViews( pDataObject, 3L, 0L );
|
|
|
|
return hr;
|
|
} // CFileMgmtComponent::RefreshAllViews()
|
|
|
|
// OnViewChange is generated by UpdateAllViews( lpDataObject, data, hint )
|
|
HRESULT CFileMgmtComponent::OnViewChange( LPDATAOBJECT lpDataObject, LPARAM data, LPARAM /*hint*/ )
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
CWaitCursor wait;
|
|
|
|
ASSERT( NULL != lpDataObject );
|
|
|
|
if (NULL == m_pViewedCookie) // skip this component if not being viewed
|
|
return S_OK;
|
|
|
|
CCookie* pbasecookie = NULL;
|
|
HRESULT hr = ExtractData( lpDataObject,
|
|
CDataObject::m_CFRawCookie,
|
|
&pbasecookie,
|
|
sizeof(pbasecookie) );
|
|
|
|
RETURN_HR_IF_FAIL; // MMC shouldn't have given me someone else's cookie
|
|
pbasecookie = QueryBaseComponentDataRef().ActiveBaseCookie( pbasecookie );
|
|
CFileMgmtCookie* pUpdatedCookie = dynamic_cast<CFileMgmtCookie*>(pbasecookie);
|
|
RETURN_E_FAIL_IF_NULL(pUpdatedCookie);
|
|
FileMgmtObjectType objTypeForUpdatedCookie = pUpdatedCookie->QueryObjectType();
|
|
|
|
switch (m_pViewedCookie->QueryObjectType())
|
|
{
|
|
case FILEMGMT_ROOT:
|
|
return S_OK; // there is never any need to refresh this
|
|
case FILEMGMT_RESOURCES:
|
|
if ( FILEMGMT_RESOURCE == objTypeForUpdatedCookie ||
|
|
FILEMGMT_RESOURCES == objTypeForUpdatedCookie)
|
|
break;
|
|
// fall through
|
|
case FILEMGMT_SESSIONS:
|
|
if ( FILEMGMT_SESSION == objTypeForUpdatedCookie ||
|
|
FILEMGMT_SESSIONS == objTypeForUpdatedCookie)
|
|
break;
|
|
// fall through
|
|
case FILEMGMT_SHARES:
|
|
if ( FILEMGMT_SHARE == objTypeForUpdatedCookie ||
|
|
FILEMGMT_SHARES == objTypeForUpdatedCookie)
|
|
break;
|
|
return S_OK;
|
|
case FILEMGMT_SERVICES:
|
|
if ( FILEMGMT_SERVICE == objTypeForUpdatedCookie ||
|
|
FILEMGMT_SERVICES == objTypeForUpdatedCookie)
|
|
break;
|
|
return S_OK;
|
|
case FILEMGMT_SHARE:
|
|
case FILEMGMT_SESSION:
|
|
case FILEMGMT_RESOURCE:
|
|
case FILEMGMT_SERVICE:
|
|
default:
|
|
ASSERT(FALSE); // this shouldn't be possible
|
|
return S_OK;
|
|
}
|
|
|
|
// There should be no need to compare machine name, since these are both from the
|
|
// same instance.
|
|
|
|
if ( 0L == data )
|
|
{
|
|
ASSERT( NULL != m_pResultData );
|
|
VERIFY( SUCCEEDED(m_pResultData->DeleteAllRsltItems()) );
|
|
m_pViewedCookie->ReleaseResultChildren();
|
|
//
|
|
// At this point, m_pViewedCookie is still the viewed cookie for this IComponent
|
|
// but (once this has happened to all of the views) its list of result children
|
|
// is empty and its m_nResultCookiesRefcount is zero. This must be followed
|
|
// promptly with PopulateListbox calls for these views since this is not a good
|
|
// state for the cookie.
|
|
//
|
|
}
|
|
else if ( 1L == data )
|
|
{
|
|
VERIFY( SUCCEEDED(PopulateListbox( m_pViewedCookie )) );
|
|
}
|
|
else if ( 2L == data )
|
|
{
|
|
VERIFY( SUCCEEDED(RefreshNewResultCookies( *m_pViewedCookie )) );
|
|
}
|
|
else if ( 3L == data )
|
|
{
|
|
if (m_pSelectedCookie == pbasecookie)
|
|
UpdateToolbar(lpDataObject, TRUE);
|
|
}
|
|
else
|
|
{
|
|
ASSERT(FALSE);
|
|
}
|
|
|
|
return S_OK;
|
|
} // CFileMgmtComponent::OnViewChange()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
// CFileMgmtComponent::CComponent::OnNotifyRefresh()
|
|
//
|
|
// Virtual function called by CComponent::IComponent::Notify(MMCN_REFRESH)
|
|
// OnNotifyRefresh is generated by enabling the verb MMC_VERB_REFRESH.
|
|
HRESULT CFileMgmtComponent::OnNotifyRefresh( LPDATAOBJECT lpDataObject )
|
|
{
|
|
TRACE0("CFileMgmtComponent::OnNotifyRefresh()\n");
|
|
ASSERT(m_pResultData != NULL);
|
|
if ( !m_pResultData )
|
|
return E_POINTER;
|
|
if ( !m_pViewedCookie )
|
|
{
|
|
ASSERT(FALSE);
|
|
return S_OK;
|
|
}
|
|
|
|
// We used to use the cookie here from lpDataObject. However, if one node
|
|
// is selected and the user right clicks on a different one we an
|
|
// lpDataObject for a node that is not enumerated in the result pane.
|
|
// It results in bizarre behavior. So use the m_pViewedCookie, instead.
|
|
HRESULT hr = S_OK;
|
|
switch (m_pViewedCookie->QueryObjectType())
|
|
{
|
|
case FILEMGMT_SHARES:
|
|
case FILEMGMT_SESSIONS:
|
|
case FILEMGMT_RESOURCES:
|
|
case FILEMGMT_SERVICES:
|
|
(void) RefreshAllViews( lpDataObject );
|
|
break;
|
|
|
|
case FILEMGMT_ROOT:
|
|
case FILEMGMT_SERVICE: // Service was selected
|
|
case FILEMGMT_SHARE: // Share was selected
|
|
case FILEMGMT_SESSION: // Session was selected
|
|
case FILEMGMT_RESOURCE: // Open file was selected
|
|
default:
|
|
// This can happen if you select Shares, then select Shared Folders,
|
|
// then right-click Shares and choose Refresh. JonN 12/7/98
|
|
break; // no need to refresh
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
// CFileMgmtComponent::RefreshNewResultCookies()
|
|
// 12/03/98 JonN Created
|
|
// In the mark-and-sweep refresh algorithm, we have already marked all cookies
|
|
// as "old", "new" or "delete". The view must now be made to conform with the list.
|
|
HRESULT CFileMgmtComponent::RefreshNewResultCookies( CCookie& refparentcookie )
|
|
{
|
|
ASSERT( NULL != m_pResultData );
|
|
|
|
RESULTDATAITEM tRDItem;
|
|
::ZeroMemory( &tRDItem, sizeof(tRDItem) );
|
|
tRDItem.nCol = 0;
|
|
tRDItem.mask = RDI_STR | RDI_IMAGE | RDI_PARAM;
|
|
tRDItem.str = MMC_CALLBACK;
|
|
// CODEWORK should use MMC_ICON_CALLBACK here
|
|
|
|
HRESULT hr = S_OK;
|
|
POSITION pos = refparentcookie.m_listResultCookieBlocks.GetHeadPosition();
|
|
while (NULL != pos)
|
|
{
|
|
CBaseCookieBlock* pblock = refparentcookie.m_listResultCookieBlocks.GetNext( pos );
|
|
ASSERT( NULL != pblock && 1 == pblock->QueryNumCookies() );
|
|
CCookie* pbasecookie = pblock->QueryBaseCookie(0);
|
|
CNewResultCookie* pcookie = dynamic_cast<CNewResultCookie*>(pbasecookie);
|
|
RETURN_E_FAIL_IF_NULL(pcookie);
|
|
if ( pcookie->IsMarkedOld() )
|
|
{
|
|
continue; // Leave this one alone
|
|
}
|
|
else if ( pcookie->IsMarkedNew() )
|
|
{ // This one was just added to the list, add it to the view
|
|
tRDItem.nImage = QueryBaseComponentDataRef().QueryImage( *pbasecookie, FALSE );
|
|
// WARNING cookie cast
|
|
tRDItem.lParam = reinterpret_cast<LPARAM>(pbasecookie);
|
|
hr = m_pResultData->InsertItem(&tRDItem);
|
|
if ( FAILED(hr) )
|
|
{
|
|
ASSERT(FALSE);
|
|
break;
|
|
}
|
|
}
|
|
else if ( pcookie->IsMarkedChanged() )
|
|
{ // This one was already in the list but its fields were altered, update
|
|
HRESULTITEM hItem = 0;
|
|
hr = m_pResultData->FindItemByLParam( reinterpret_cast<LPARAM>(pbasecookie), &hItem );
|
|
if ( FAILED(hr) || 0 == hItem )
|
|
{
|
|
ASSERT(FALSE);
|
|
continue;
|
|
}
|
|
VERIFY( SUCCEEDED(m_pResultData->UpdateItem( hItem )) );
|
|
}
|
|
else
|
|
{ // This one was just marked for deletion, remove it from the view
|
|
// CODEWORK This may be a performance problem when the list is long
|
|
// CODEWORK BryanWal doesn't trust FindItemByLParam! Test carefully!
|
|
ASSERT( pcookie->IsMarkedForDeletion() );
|
|
HRESULTITEM hItem = 0;
|
|
hr = m_pResultData->FindItemByLParam( reinterpret_cast<LPARAM>(pbasecookie), &hItem );
|
|
if ( FAILED(hr) || 0 == hItem )
|
|
{
|
|
ASSERT(FALSE);
|
|
continue;
|
|
}
|
|
VERIFY( SUCCEEDED(m_pResultData->DeleteItem( hItem, 0 )) );
|
|
}
|
|
}
|
|
VERIFY( SUCCEEDED(m_pResultData->Sort( m_iSortColumn , m_dwSortFlags, 0 )) );
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CFileMgmtComponent::OnNotifySelect( LPDATAOBJECT lpDataObject, BOOL fSelected )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BOOL bMultiSelectObject = FALSE;
|
|
|
|
//
|
|
// MMC passes in SI_MS_DO in MMCN_SELECT in case of multiselection.
|
|
//
|
|
CFileMgmtDataObject *pDataObj = NULL;
|
|
hr = ExtractData(lpDataObject, CFileMgmtDataObject::m_CFInternal, &pDataObj, sizeof(pDataObj));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CDataObjectList* pMultiSelectObjList = pDataObj->GetMultiSelectObjList();
|
|
bMultiSelectObject = !(pMultiSelectObjList->empty());
|
|
}
|
|
|
|
//
|
|
// no verbs to add for multi-selected SharedFolders items
|
|
//
|
|
if (!bMultiSelectObject)
|
|
{
|
|
CCookie* pbasecookie = NULL;
|
|
hr = ExtractData( lpDataObject,
|
|
CDataObject::m_CFRawCookie,
|
|
&pbasecookie,
|
|
sizeof(pbasecookie) );
|
|
RETURN_HR_IF_FAIL; // MMC shouldn't have given me someone else's cookie
|
|
pbasecookie = QueryBaseComponentDataRef().ActiveBaseCookie( pbasecookie );
|
|
CFileMgmtCookie* pUpdatedCookie = dynamic_cast<CFileMgmtCookie*>(pbasecookie);
|
|
RETURN_E_FAIL_IF_NULL(pUpdatedCookie);
|
|
|
|
m_pSelectedCookie = (fSelected) ? pUpdatedCookie : NULL;
|
|
|
|
UpdateDefaultVerbs();
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
void CFileMgmtComponent::UpdateDefaultVerbs()
|
|
{
|
|
if (NULL == m_pSelectedCookie)
|
|
return;
|
|
|
|
FileMgmtObjectType objtypeSelected = m_pSelectedCookie->QueryObjectType();
|
|
|
|
if (NULL != m_pViewedCookie)
|
|
{
|
|
BOOL fEnableRefresh = FALSE;
|
|
FileMgmtObjectType objtypeViewed = m_pViewedCookie->QueryObjectType();
|
|
|
|
switch (objtypeViewed)
|
|
{
|
|
case FILEMGMT_SHARES:
|
|
if (FILEMGMT_SHARES == objtypeSelected || FILEMGMT_SHARE == objtypeSelected)
|
|
fEnableRefresh = TRUE;
|
|
break;
|
|
case FILEMGMT_SESSIONS:
|
|
if (FILEMGMT_SESSIONS == objtypeSelected || FILEMGMT_SESSION == objtypeSelected)
|
|
fEnableRefresh = TRUE;
|
|
break;
|
|
case FILEMGMT_RESOURCES:
|
|
if (FILEMGMT_RESOURCES == objtypeSelected || FILEMGMT_RESOURCE == objtypeSelected)
|
|
fEnableRefresh = TRUE;
|
|
break;
|
|
case FILEMGMT_SERVICES:
|
|
if (FILEMGMT_SERVICES == objtypeSelected || FILEMGMT_SERVICE == objtypeSelected)
|
|
fEnableRefresh = TRUE;
|
|
break;
|
|
}
|
|
if (fEnableRefresh)
|
|
{
|
|
// Enable the refresh menuitem
|
|
VERIFY( SUCCEEDED(m_pConsoleVerb->SetVerbState(MMC_VERB_REFRESH, ENABLED, TRUE)) );
|
|
}
|
|
}
|
|
|
|
switch (objtypeSelected)
|
|
{
|
|
case FILEMGMT_SHARE: // Share was selected
|
|
//
|
|
// don't enable Properties on the menu whenever SimpleSharingUI appears in NT Explorer
|
|
//
|
|
if (QueryComponentDataRef().GetIsSimpleUI())
|
|
{
|
|
VERIFY( SUCCEEDED(m_pConsoleVerb->SetDefaultVerb(MMC_VERB_NONE)) );
|
|
break;
|
|
}
|
|
// fall through
|
|
case FILEMGMT_SERVICE: // Service was selected
|
|
// Set the default verb to display the properties of the selected object
|
|
VERIFY( SUCCEEDED(m_pConsoleVerb->SetVerbState(MMC_VERB_PROPERTIES, ENABLED, TRUE)) );
|
|
VERIFY( SUCCEEDED(m_pConsoleVerb->SetDefaultVerb(MMC_VERB_PROPERTIES)) );
|
|
break;
|
|
|
|
case FILEMGMT_SESSION: // Session was selected
|
|
case FILEMGMT_RESOURCE: // Open file was selected
|
|
VERIFY( SUCCEEDED(m_pConsoleVerb->SetDefaultVerb(MMC_VERB_NONE)) );
|
|
break;
|
|
|
|
case FILEMGMT_SHARES:
|
|
case FILEMGMT_SESSIONS:
|
|
case FILEMGMT_RESOURCES:
|
|
case FILEMGMT_SERVICES:
|
|
case FILEMGMT_ROOT: // Root node was selected
|
|
// set the default verb to open/expand the folder
|
|
VERIFY( SUCCEEDED(m_pConsoleVerb->SetDefaultVerb(MMC_VERB_OPEN)) );
|
|
break;
|
|
|
|
default: // shouldn't happen
|
|
ASSERT(FALSE);
|
|
break;
|
|
|
|
} // switch
|
|
|
|
} // CFileMgmtComponent::OnNotifySelect()
|
|
|
|
STDMETHODIMP CFileMgmtComponent::QueryDataObject(MMC_COOKIE cookie, DATA_OBJECT_TYPES type, LPDATAOBJECT* ppDataObject)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
MFC_TRY;
|
|
|
|
//
|
|
// MMC queries us for a multiselect data object (SI_MS_DO) by
|
|
// passing the special cookie in this QueryDataObject call.
|
|
//
|
|
if (IS_SPECIAL_COOKIE(cookie) && MMC_MULTI_SELECT_COOKIE == cookie)
|
|
{
|
|
CComObject<CFileMgmtDataObject>* pDataObject = NULL;
|
|
hr = CComObject<CFileMgmtDataObject>::CreateInstance(&pDataObject);
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = pDataObject->InitMultiSelectDataObjects(QueryComponentDataRef());
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// We create a multiselect data object (SI_MS_DO), which contains
|
|
// an internal list of data objects of selected items.
|
|
//
|
|
RESULTDATAITEM rdi = {0};
|
|
int nIndex = -1;
|
|
do
|
|
{
|
|
ZeroMemory(&rdi, sizeof(RESULTDATAITEM));
|
|
rdi.mask = RDI_STATE;
|
|
rdi.nCol = 0;
|
|
rdi.nIndex = nIndex; // nIndex == -1 to start at first item
|
|
rdi.nState = LVIS_SELECTED; // only interested in selected items
|
|
|
|
hr = m_pResultData->GetNextItem(&rdi);
|
|
if (FAILED(hr))
|
|
break;
|
|
|
|
if (rdi.nIndex != -1)
|
|
{
|
|
//
|
|
// rdi is the RESULTDATAITEM of a selected item. its lParam contains the cookie.
|
|
// Add it to the internal data object list.
|
|
//
|
|
CCookie* pbasecookie = reinterpret_cast<CCookie*>(rdi.lParam);
|
|
CFileMgmtCookie* pUseThisCookie = QueryComponentDataRef().ActiveCookie((CFileMgmtCookie*)pbasecookie);
|
|
pDataObject->AddMultiSelectDataObjects(pUseThisCookie, type);
|
|
}
|
|
|
|
nIndex = rdi.nIndex;
|
|
|
|
} while (-1 != nIndex);
|
|
}
|
|
|
|
//
|
|
// return this SI_MS_DO to MMC
|
|
//
|
|
if (SUCCEEDED(hr))
|
|
hr = pDataObject->QueryInterface(IID_IDataObject, (void **)ppDataObject);
|
|
|
|
if (FAILED(hr))
|
|
delete pDataObject;
|
|
}
|
|
else
|
|
{
|
|
// Delegate it to the IComponentData
|
|
hr = QueryBaseComponentDataRef().QueryDataObject(cookie, type, ppDataObject);
|
|
}
|
|
|
|
MFC_CATCH;
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CFileMgmtComponent::GetResultViewType(MMC_COOKIE cookie,
|
|
BSTR* ppViewType,
|
|
long* pViewOptions)
|
|
{
|
|
*ppViewType = NULL;
|
|
|
|
//
|
|
// we support multiselection in SharedFolders snapin
|
|
//
|
|
CCookie* pbasecookie = reinterpret_cast<CCookie*>(cookie);
|
|
CFileMgmtCookie* pUseThisCookie = QueryComponentDataRef().ActiveCookie((CFileMgmtCookie*)pbasecookie);
|
|
FileMgmtObjectType objecttype = pUseThisCookie->QueryObjectType();
|
|
if ( FILEMGMT_SHARES == objecttype ||
|
|
FILEMGMT_SESSIONS == objecttype ||
|
|
FILEMGMT_RESOURCES == objecttype )
|
|
{
|
|
*pViewOptions = MMC_VIEW_OPTIONS_MULTISELECT;
|
|
} else
|
|
{
|
|
*pViewOptions = MMC_VIEW_OPTIONS_NONE;
|
|
}
|
|
|
|
return S_FALSE;
|
|
}
|
|
|
|
HRESULT CFileMgmtComponent::Show( CCookie* pcookie, LPARAM arg, HSCOPEITEM /*hScopeItem*/ )
|
|
{
|
|
TEST_NONNULL_PTR_PARAM(pcookie);
|
|
|
|
#ifndef SNAPIN_PROTOTYPER
|
|
if ( 0 == arg )
|
|
{
|
|
//
|
|
// This is a Hide notification
|
|
//
|
|
if ( NULL == m_pResultData )
|
|
{
|
|
ASSERT( FALSE );
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
// We should not get a Hide notification if we are not currently showing
|
|
// CODEWORK see 287399: MMC: two MMCN_SHOW(0) notifications
|
|
// ASSERT( (CFileMgmtCookie*)pcookie == m_pViewedCookie );
|
|
if ( (CFileMgmtScopeCookie*)pcookie == m_pViewedCookie )
|
|
{
|
|
//
|
|
// Only delete the cookies if no other views are using them
|
|
//
|
|
pcookie->ReleaseResultChildren();
|
|
|
|
m_pViewedCookie = NULL;
|
|
|
|
UpdateDefaultVerbs();
|
|
}
|
|
|
|
return S_OK;
|
|
} // if
|
|
#else
|
|
CPrototyperScopeCookie* pScopeCookie = (CPrototyperScopeCookie*) pcookie;
|
|
if (pScopeCookie->m_ScopeType == HTML)
|
|
return S_OK;
|
|
#endif // SNAPIN_PROTOTYPER
|
|
|
|
// We should not get a Show notification if we are already showing
|
|
if ( NULL != m_pViewedCookie )
|
|
{
|
|
ASSERT(FALSE);
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// This is a Show notification
|
|
// Build new cookies and insert them into the cookie and the view
|
|
//
|
|
|
|
ASSERT( IsAutonomousObjectType( ((CFileMgmtCookie*)pcookie)->QueryObjectType() ) );
|
|
|
|
m_pViewedCookie = (CFileMgmtScopeCookie*)pcookie;
|
|
|
|
LoadColumns( m_pViewedCookie );
|
|
|
|
UpdateDefaultVerbs();
|
|
|
|
return PopulateListbox( m_pViewedCookie );
|
|
} // CFileMgmtComponent::Show()
|
|
|
|
|
|
HRESULT CFileMgmtComponent::OnNotifyAddImages( LPDATAOBJECT /*lpDataObject*/,
|
|
LPIMAGELIST lpImageList,
|
|
HSCOPEITEM /*hSelectedItem*/ )
|
|
{
|
|
return QueryComponentDataRef().LoadIcons(lpImageList,TRUE);
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
// CODEWORK: Rather than repeating the FPNW calls every time, whether
|
|
// or not the FPNW server is running or even installed, I should
|
|
// remember whether the server is installed. Andy Herron has
|
|
// suggested an API which can determine whether FPNW is installed,
|
|
// but it has two drawbacks:
|
|
// -- It can only determine whether FPNW is installed anywhere on the
|
|
// domain, not on an individual server; and
|
|
// -- The API will fail if called by a non-administrator.
|
|
//
|
|
// JonN 11/1/96
|
|
//
|
|
HRESULT CFileMgmtComponent::PopulateListbox(CFileMgmtScopeCookie* pcookie)
|
|
{
|
|
TEST_NONNULL_PTR_PARAM(pcookie);
|
|
|
|
CWaitCursor cwait;
|
|
|
|
HRESULT hr = S_OK;
|
|
//
|
|
// If this is the second view on the same data, just insert the same cookies
|
|
// which are in the other views
|
|
//
|
|
if ( 1 < pcookie->AddRefResultChildren() )
|
|
{
|
|
hr = InsertResultCookies( *pcookie );
|
|
if ( SUCCEEDED(hr) )
|
|
hr = m_pResultData->Sort( m_iSortColumn , m_dwSortFlags, 0 );
|
|
return hr;
|
|
}
|
|
|
|
INT iTransport;
|
|
switch ( pcookie->QueryObjectType() )
|
|
{
|
|
case FILEMGMT_SHARES:
|
|
for (iTransport = FILEMGMT_FIRST_TRANSPORT;
|
|
iTransport < FILEMGMT_NUM_TRANSPORTS;
|
|
iTransport++)
|
|
{
|
|
hr = GetFileServiceProvider(iTransport)->PopulateShares(m_pResultData,pcookie);
|
|
if( FAILED(hr) )
|
|
return hr;
|
|
}
|
|
break;
|
|
|
|
case FILEMGMT_SESSIONS:
|
|
for (iTransport = FILEMGMT_FIRST_TRANSPORT;
|
|
iTransport < FILEMGMT_NUM_TRANSPORTS;
|
|
iTransport++)
|
|
{
|
|
ASSERT( NULL != m_pResultData ); // otherwise we close all sessions
|
|
hr = GetFileServiceProvider(iTransport)->EnumerateSessions (
|
|
m_pResultData, pcookie, true);
|
|
if( FAILED(hr) )
|
|
return hr;
|
|
}
|
|
break;
|
|
|
|
case FILEMGMT_RESOURCES:
|
|
for (iTransport = FILEMGMT_FIRST_TRANSPORT;
|
|
iTransport < FILEMGMT_NUM_TRANSPORTS;
|
|
iTransport++)
|
|
{
|
|
ASSERT( NULL != m_pResultData ); // otherwise we close all sessions
|
|
hr = GetFileServiceProvider(iTransport)->EnumerateResources(m_pResultData,pcookie);
|
|
if( FAILED(hr) )
|
|
return hr;
|
|
}
|
|
break;
|
|
|
|
case FILEMGMT_SERVICES:
|
|
//
|
|
// JonN 12/03/98 Service_PopulateServices no longer inserts items into the list
|
|
//
|
|
hr = QueryComponentDataRef().Service_PopulateServices(m_pResultData, pcookie);
|
|
if ( SUCCEEDED(hr) )
|
|
hr = InsertResultCookies( *pcookie );
|
|
if( FAILED(hr) )
|
|
return hr;
|
|
|
|
#ifdef SNAPIN_PROTOTYPER
|
|
case FILEMGMT_PROTOTYPER:
|
|
return Prototyper_HrPopulateResultPane(pcookie);
|
|
#endif
|
|
|
|
case FILEMGMT_ROOT:
|
|
// We no longer need to explicitly insert these
|
|
break;
|
|
|
|
default:
|
|
ASSERT( FALSE );
|
|
// fall through
|
|
}
|
|
|
|
return m_pResultData->Sort( m_iSortColumn , m_dwSortFlags, 0 );
|
|
} // CFileMgmtComponent::PopulateListbox()
|
|
|
|
HRESULT CFileMgmtComponent::GetSnapinMultiSelectDataObject(
|
|
LPDATAOBJECT i_pMMCMultiSelectDataObject,
|
|
LPDATAOBJECT *o_ppSnapinMultiSelectDataObject
|
|
)
|
|
{
|
|
if (!i_pMMCMultiSelectDataObject || !o_ppSnapinMultiSelectDataObject)
|
|
return E_INVALIDARG;
|
|
|
|
*o_ppSnapinMultiSelectDataObject = NULL;
|
|
|
|
//
|
|
// i_pMMCMultiSelectDataObject is the composite data object (MMC_MS_DO) created by MMC.
|
|
// We need to crack it to retrieve the multiselect data object (SI_MS_DO)
|
|
// we provided to MMC in QueryDataObject().
|
|
//
|
|
STGMEDIUM stgmedium = {TYMED_HGLOBAL, NULL, NULL};
|
|
FORMATETC formatetc = {CFileMgmtDataObject::m_CFMultiSelectSnapins, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
|
|
HRESULT hr = i_pMMCMultiSelectDataObject->GetData(&formatetc, &stgmedium);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (!stgmedium.hGlobal)
|
|
return E_FAIL;
|
|
|
|
//
|
|
// Locate the SI_MS_DO we have provided to MMC in QueryDataObject().
|
|
//
|
|
SMMCDataObjects *pMMCDO = (SMMCDataObjects*)::GlobalLock(stgmedium.hGlobal);
|
|
|
|
GUID guidSnapin = GUID_NULL;
|
|
VERIFY( SUCCEEDED(QueryComponentDataRef().GetClassID(&guidSnapin)) );
|
|
|
|
for (int i = 0; i < pMMCDO->count; i++)
|
|
{
|
|
GUID guid = GUID_NULL;
|
|
hr = ExtractData(pMMCDO->lpDataObject[i], CFileMgmtDataObject::m_CFSnapInCLSID, &guid, sizeof(GUID));
|
|
if (SUCCEEDED(hr) && guid == guidSnapin)
|
|
{
|
|
//
|
|
// pMMCDO->lpDataObject[i] is the SI_MS_DO we have provided to MMC in QueryDataObject().
|
|
//
|
|
*o_ppSnapinMultiSelectDataObject = pMMCDO->lpDataObject[i];
|
|
(*o_ppSnapinMultiSelectDataObject)->AddRef();
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
::GlobalUnlock(stgmedium.hGlobal);
|
|
::GlobalFree(stgmedium.hGlobal);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// IExtendContextMenu Implementation
|
|
|
|
STDMETHODIMP CFileMgmtComponent::AddMenuItems(
|
|
IDataObject* piDataObject,
|
|
IContextMenuCallback* piCallback,
|
|
long* pInsertionAllowed)
|
|
{
|
|
MFC_TRY;
|
|
|
|
TRACE_METHOD(CFileMgmtComponent,AddMenuItems);
|
|
TEST_NONNULL_PTR_PARAM(piDataObject);
|
|
TEST_NONNULL_PTR_PARAM(piCallback);
|
|
TEST_NONNULL_PTR_PARAM(pInsertionAllowed);
|
|
TRACE( "FileMgmt snapin: extending menu\n" );
|
|
|
|
HRESULT hr = S_OK;
|
|
FileMgmtObjectType objecttype = FILEMGMT_NUMTYPES;
|
|
|
|
//
|
|
// need to find out the object type in case of multiselection
|
|
//
|
|
BOOL bMultiSelectObject = IsMultiSelectObject(piDataObject);
|
|
if (!bMultiSelectObject)
|
|
{
|
|
objecttype = FileMgmtObjectTypeFromIDataObject(piDataObject);
|
|
} else
|
|
{
|
|
//
|
|
// piDataObject is the composite data object (MMC_MS_DO) created by MMC.
|
|
// We need to crack it to retrieve the multiselect data object (SI_MS_DO)
|
|
// we provided to MMC in QueryDataObject().
|
|
//
|
|
IDataObject *piSIMSDO = NULL;
|
|
hr = GetSnapinMultiSelectDataObject(piDataObject, &piSIMSDO);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Note: we assume all multiselected items are of the same type.
|
|
//
|
|
// Now retrieve data type of the currently selected items
|
|
//
|
|
STGMEDIUM stgmedium = {TYMED_HGLOBAL, NULL, NULL};
|
|
FORMATETC formatetc = {CFileMgmtDataObject::m_CFObjectTypesInMultiSelect,
|
|
NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
|
|
hr = piSIMSDO->GetData(&formatetc, &stgmedium);
|
|
if (SUCCEEDED(hr) && stgmedium.hGlobal)
|
|
{
|
|
BYTE* pb = (BYTE*)::GlobalLock(stgmedium.hGlobal);
|
|
|
|
GUID* pguid = (GUID*)(pb + sizeof(DWORD)); // skip the 1st DWORD - count
|
|
objecttype = (FileMgmtObjectType)CheckObjectTypeGUID(pguid);
|
|
|
|
::GlobalUnlock(stgmedium.hGlobal);
|
|
::GlobalFree(stgmedium.hGlobal);
|
|
}
|
|
|
|
piSIMSDO->Release();
|
|
}
|
|
}
|
|
|
|
switch (objecttype)
|
|
{
|
|
case FILEMGMT_SHARE:
|
|
//
|
|
// don't add acl-related menu items whenever SimpleSharingUI appears in NT Explorer
|
|
//
|
|
if (QueryComponentDataRef().GetIsSimpleUI())
|
|
break;
|
|
|
|
if ( CCM_INSERTIONALLOWED_TOP & (*pInsertionAllowed) )
|
|
{
|
|
hr = LoadAndAddMenuItem( piCallback, IDS_DELETE_SHARE_TOP, IDS_DELETE_SHARE_TOP,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP, 0, AfxGetInstanceHandle() );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
if ( CCM_INSERTIONALLOWED_TASK & (*pInsertionAllowed) )
|
|
{
|
|
hr = LoadAndAddMenuItem( piCallback, IDS_DELETE_SHARE_TASK, IDS_DELETE_SHARE_TASK,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TASK, 0, AfxGetInstanceHandle() );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
if ( CCM_INSERTIONALLOWED_NEW & (*pInsertionAllowed) )
|
|
{
|
|
hr = LoadAndAddMenuItem( piCallback, IDS_NEW_SHARE_NEW, IDS_NEW_SHARE_NEW,
|
|
CCM_INSERTIONPOINTID_PRIMARY_NEW, 0, AfxGetInstanceHandle() );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
break;
|
|
|
|
case FILEMGMT_SESSION:
|
|
if ( CCM_INSERTIONALLOWED_TOP & (*pInsertionAllowed) )
|
|
{
|
|
hr = LoadAndAddMenuItem( piCallback, IDS_CLOSE_SESSION_TOP, IDS_CLOSE_SESSION_TOP,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP, 0, AfxGetInstanceHandle() );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
if ( CCM_INSERTIONALLOWED_TASK & (*pInsertionAllowed) )
|
|
{
|
|
hr = LoadAndAddMenuItem( piCallback, IDS_CLOSE_SESSION_TASK, IDS_CLOSE_SESSION_TASK,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TASK, 0, AfxGetInstanceHandle() );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
break;
|
|
|
|
case FILEMGMT_RESOURCE:
|
|
if ( CCM_INSERTIONALLOWED_TOP & (*pInsertionAllowed) )
|
|
{
|
|
hr = LoadAndAddMenuItem( piCallback, IDS_CLOSE_RESOURCE_TOP, IDS_CLOSE_RESOURCE_TOP,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP, 0, AfxGetInstanceHandle() );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
if ( CCM_INSERTIONALLOWED_TASK & (*pInsertionAllowed) )
|
|
{
|
|
hr = LoadAndAddMenuItem( piCallback, IDS_CLOSE_RESOURCE_TASK, IDS_CLOSE_RESOURCE_TASK,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TASK, 0, AfxGetInstanceHandle() );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
break;
|
|
|
|
case FILEMGMT_SERVICE:
|
|
QueryComponentDataRef().Service_FAddMenuItems(piCallback, piDataObject);
|
|
break;
|
|
|
|
#ifdef SNAPIN_PROTOTYPER
|
|
case FILEMGMT_PROTOTYPER_LEAF:
|
|
Prototyper_AddMenuItems(piCallback, piDataObject);
|
|
break;
|
|
#endif // SNAPIN_PROTOTYPER
|
|
|
|
default:
|
|
{
|
|
DATA_OBJECT_TYPES dataobjecttype = CCT_SCOPE;
|
|
hr = ExtractData( piDataObject,
|
|
CFileMgmtDataObject::m_CFDataObjectType,
|
|
&dataobjecttype,
|
|
sizeof(dataobjecttype) );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
|
|
// perhaps this is a scope node in the result pane
|
|
hr = QueryComponentDataRef().DoAddMenuItems( piCallback,
|
|
objecttype,
|
|
dataobjecttype,
|
|
pInsertionAllowed,
|
|
piDataObject );
|
|
}
|
|
break;
|
|
} // switch
|
|
|
|
return hr;
|
|
|
|
MFC_CATCH;
|
|
|
|
} // CFileMgmtComponent::AddMenuItems()
|
|
|
|
STDMETHODIMP CFileMgmtComponent::Command(
|
|
LONG lCommandID,
|
|
IDataObject* piDataObject )
|
|
{
|
|
MFC_TRY;
|
|
|
|
TRACE_METHOD(CFileMgmtComponent,Command);
|
|
TEST_NONNULL_PTR_PARAM(piDataObject);
|
|
TRACE( "CFileMgmtComponent::Command: command %ld selected\n", lCommandID );
|
|
|
|
#ifdef SNAPIN_PROTOTYPER
|
|
Prototyper_ContextMenuCommand(lCommandID, piDataObject);
|
|
return S_OK;
|
|
#endif
|
|
|
|
BOOL fFSMRefresh = FALSE;
|
|
BOOL fSVCRefresh = FALSE;
|
|
switch (lCommandID)
|
|
{
|
|
case IDS_DELETE_SHARE_TASK:
|
|
case IDS_DELETE_SHARE_TOP:
|
|
fFSMRefresh = DeleteShare( piDataObject );
|
|
break;
|
|
case IDS_CLOSE_SESSION_TASK:
|
|
case IDS_CLOSE_SESSION_TOP:
|
|
fFSMRefresh = CloseSession( piDataObject );
|
|
break;
|
|
case IDS_CLOSE_RESOURCE_TASK:
|
|
case IDS_CLOSE_RESOURCE_TOP:
|
|
fFSMRefresh = CloseResource( piDataObject );
|
|
break;
|
|
|
|
case cmServiceStart:
|
|
case cmServiceStop:
|
|
case cmServicePause:
|
|
case cmServiceResume:
|
|
case cmServiceRestart:
|
|
case cmServiceStartTask:
|
|
case cmServiceStopTask:
|
|
case cmServicePauseTask:
|
|
case cmServiceResumeTask:
|
|
case cmServiceRestartTask:
|
|
fSVCRefresh = QueryComponentDataRef().Service_FDispatchMenuCommand(lCommandID, piDataObject);
|
|
break;
|
|
|
|
default:
|
|
return QueryComponentDataRef().Command(lCommandID, piDataObject);
|
|
} // switch
|
|
|
|
if (fFSMRefresh)
|
|
{
|
|
//
|
|
// In case of multiselect, piDataObject may point to a composite data object (MMC_MS_DO).
|
|
// RefreshAllViewsOnSelectedObject will crack down MMC_MS_DO to retrieve SI_MS_DO, then call
|
|
// RefreshAllViews on one of the selected objects in the internal list.
|
|
//
|
|
(void) RefreshAllViewsOnSelectedObject(piDataObject);
|
|
}
|
|
|
|
if (fSVCRefresh)
|
|
{
|
|
(void) RefreshAllViews( piDataObject );
|
|
}
|
|
|
|
return S_OK;
|
|
MFC_CATCH;
|
|
} // CFileMgmtComponent::Command()
|
|
|
|
BOOL CFileMgmtComponent::DeleteShare(LPDATAOBJECT piDataObject)
|
|
{
|
|
ASSERT( piDataObject != NULL );
|
|
|
|
BOOL bMultiSelectObject = IsMultiSelectObject(piDataObject);
|
|
if (!bMultiSelectObject)
|
|
return DeleteThisOneShare(piDataObject, FALSE);
|
|
|
|
BOOL bRefresh = FALSE;
|
|
if (IDYES == DoErrMsgBox(GetActiveWindow(), MB_YESNO, 0, IDS_s_CONFIRM_DELETEMULTISHARES))
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
CWaitCursor wait;
|
|
|
|
//
|
|
// piDataObject is the composite data object (MMC_MS_DO) created by MMC.
|
|
// We need to crack it to retrieve the multiselect data object (SI_MS_DO)
|
|
// we provided to MMC in QueryDataObject().
|
|
//
|
|
IDataObject *piSIMSDO = NULL;
|
|
HRESULT hr = GetSnapinMultiSelectDataObject(piDataObject, &piSIMSDO);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CFileMgmtDataObject *pDataObj = NULL;
|
|
hr = ExtractData(piSIMSDO, CFileMgmtDataObject::m_CFInternal, &pDataObj, sizeof(pDataObj));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// get the internal list of data objects of selected items, operate on each one of them.
|
|
//
|
|
CDataObjectList* pMultiSelectObjList = pDataObj->GetMultiSelectObjList();
|
|
for (CDataObjectList::iterator i = pMultiSelectObjList->begin(); i != pMultiSelectObjList->end(); i++)
|
|
{
|
|
BOOL bDeleted = DeleteThisOneShare(*i, TRUE);
|
|
if (bDeleted)
|
|
bRefresh = TRUE;
|
|
}
|
|
}
|
|
|
|
piSIMSDO->Release();
|
|
}
|
|
}
|
|
|
|
return bRefresh;
|
|
}
|
|
|
|
BOOL CFileMgmtComponent::DeleteThisOneShare(LPDATAOBJECT piDataObject, BOOL bQuietMode)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
ASSERT( piDataObject != NULL );
|
|
#ifdef DEBUG
|
|
{
|
|
FileMgmtObjectType objecttype = FileMgmtObjectTypeFromIDataObject(piDataObject);
|
|
ASSERT(FILEMGMT_SHARE == objecttype);
|
|
}
|
|
#endif
|
|
|
|
CString strServerName;
|
|
HRESULT hr = ExtractString( piDataObject, CFileMgmtDataObject::m_CFMachineName, &strServerName, MAX_PATH );
|
|
RETURN_FALSE_IF_FAIL;
|
|
|
|
CString strShareName;
|
|
hr = ExtractString( piDataObject, CFileMgmtDataObject::m_CFShareName, &strShareName, MAX_PATH );
|
|
RETURN_FALSE_IF_FAIL;
|
|
|
|
FILEMGMT_TRANSPORT transport;
|
|
hr = ExtractData( piDataObject,
|
|
CFileMgmtDataObject::m_CFTransport,
|
|
&transport,
|
|
sizeof(DWORD) );
|
|
RETURN_FALSE_IF_FAIL;
|
|
|
|
BOOL fNetLogonShare = (!lstrcmpi(strShareName, _T("SYSVOL")) || !lstrcmpi(strShareName, _T("NETLOGON")));
|
|
BOOL fIPC = FALSE;
|
|
BOOL fAdminShare = FALSE;
|
|
|
|
if (!fNetLogonShare && transport == FILEMGMT_SMB)
|
|
{
|
|
DWORD dwShareType = 0;
|
|
GetFileServiceProvider(transport)->ReadShareType(strServerName, strShareName, &dwShareType);
|
|
fAdminShare = (dwShareType & STYPE_SPECIAL);
|
|
fIPC = (STYPE_IPC == (dwShareType & STYPE_IPC));
|
|
}
|
|
|
|
if (fIPC)
|
|
{
|
|
DoErrMsgBox(
|
|
GetActiveWindow(),
|
|
MB_OK | MB_ICONEXCLAMATION,
|
|
0,
|
|
IDS_s_DELETE_IPCSHARE
|
|
);
|
|
return FALSE;
|
|
}
|
|
|
|
if ((fNetLogonShare || fAdminShare) &&
|
|
IDYES != DoErrMsgBox(
|
|
GetActiveWindow(),
|
|
MB_YESNO | MB_ICONEXCLAMATION | MB_DEFBUTTON2,
|
|
0,
|
|
(fAdminShare ? IDS_s_CONFIRM_DELETE_ADMINSHARE : IDS_s_CONFIRM_DELETE_NETLOGONSHARE),
|
|
strShareName) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (!bQuietMode &&
|
|
IDYES != DoErrMsgBox(
|
|
GetActiveWindow(),
|
|
MB_YESNO,
|
|
0,
|
|
IDS_s_CONFIRM_DELETESHARE,
|
|
strShareName) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
DWORD retval = 0L;
|
|
switch (transport)
|
|
{
|
|
case FILEMGMT_SMB:
|
|
case FILEMGMT_FPNW:
|
|
case FILEMGMT_SFM:
|
|
if (bQuietMode)
|
|
{
|
|
retval = GetFileServiceProvider(transport)->DeleteShare(strServerName, strShareName);
|
|
} else
|
|
{
|
|
CWaitCursor wait;
|
|
retval = GetFileServiceProvider(transport)->DeleteShare(strServerName, strShareName);
|
|
}
|
|
break;
|
|
default:
|
|
ASSERT(FALSE);
|
|
break;
|
|
}
|
|
if (0L != retval)
|
|
{
|
|
(void) DoErrMsgBox(GetActiveWindow(), MB_OK | MB_ICONSTOP, retval, IDS_POPUP_DELETE_SHARE, strShareName);
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CFileMgmtComponent::CloseSession(LPDATAOBJECT piDataObject)
|
|
{
|
|
ASSERT( piDataObject != NULL );
|
|
|
|
BOOL bMultiSelectObject = IsMultiSelectObject(piDataObject);
|
|
if (!bMultiSelectObject)
|
|
return CloseThisOneSession(piDataObject, FALSE);
|
|
|
|
BOOL bRefresh = FALSE;
|
|
if (IDYES == DoErrMsgBox(GetActiveWindow(), MB_YESNO, 0, IDS_CONFIRM_CLOSEMULTISESSIONS))
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
CWaitCursor wait;
|
|
|
|
//
|
|
// piDataObject is the composite data object (MMC_MS_DO) created by MMC.
|
|
// We need to crack it to retrieve the multiselect data object (SI_MS_DO)
|
|
// we provided to MMC in QueryDataObject().
|
|
//
|
|
IDataObject *piSIMSDO = NULL;
|
|
HRESULT hr = GetSnapinMultiSelectDataObject(piDataObject, &piSIMSDO);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CFileMgmtDataObject *pDataObj = NULL;
|
|
hr = ExtractData(piSIMSDO, CFileMgmtDataObject::m_CFInternal, &pDataObj, sizeof(pDataObj));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// get the internal list of data objects of selected items, operate on each one of them.
|
|
//
|
|
CDataObjectList* pMultiSelectObjList = pDataObj->GetMultiSelectObjList();
|
|
for (CDataObjectList::iterator i = pMultiSelectObjList->begin(); i != pMultiSelectObjList->end(); i++)
|
|
{
|
|
BOOL bDeleted = CloseThisOneSession(*i, TRUE);
|
|
if (bDeleted)
|
|
bRefresh = TRUE;
|
|
}
|
|
}
|
|
|
|
piSIMSDO->Release();
|
|
}
|
|
}
|
|
|
|
return bRefresh;
|
|
}
|
|
|
|
BOOL CFileMgmtComponent::CloseThisOneSession(LPDATAOBJECT piDataObject, BOOL bQuietMode)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
|
|
ASSERT( piDataObject != NULL );
|
|
|
|
CCookie* pbasecookie = NULL;
|
|
FileMgmtObjectType objecttype = FILEMGMT_ROOT;
|
|
HRESULT hr = ExtractBaseCookie( piDataObject, &pbasecookie, &objecttype );
|
|
ASSERT( SUCCEEDED(hr) && NULL != pbasecookie && FILEMGMT_SESSION == objecttype );
|
|
CFileMgmtResultCookie* pcookie = (CFileMgmtResultCookie*)pbasecookie;
|
|
|
|
if ( !bQuietMode && IDYES != DoErrMsgBox(GetActiveWindow(), MB_YESNO, 0, IDS_CONFIRM_CLOSESESSION) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
FILEMGMT_TRANSPORT transport = FILEMGMT_SMB;
|
|
VERIFY( SUCCEEDED( pcookie->GetTransport( &transport ) ) );
|
|
DWORD retval = 0;
|
|
|
|
if (bQuietMode)
|
|
{
|
|
retval = GetFileServiceProvider(transport)->CloseSession( pcookie );
|
|
} else
|
|
{
|
|
CWaitCursor wait;
|
|
retval = GetFileServiceProvider(transport)->CloseSession( pcookie );
|
|
}
|
|
|
|
if (0L != retval)
|
|
{
|
|
(void) DoErrMsgBox(GetActiveWindow(), MB_OK | MB_ICONSTOP, retval, IDS_POPUP_CLOSE_SESSION);
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CFileMgmtComponent::CloseResource(LPDATAOBJECT piDataObject)
|
|
{
|
|
ASSERT( piDataObject != NULL );
|
|
|
|
BOOL bMultiSelectObject = IsMultiSelectObject(piDataObject);
|
|
if (!bMultiSelectObject)
|
|
return CloseThisOneResource(piDataObject, FALSE);
|
|
|
|
BOOL bRefresh = FALSE;
|
|
if (IDYES == DoErrMsgBox(GetActiveWindow(), MB_YESNO, 0, IDS_CONFIRM_CLOSEMULTIRESOURCES))
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
CWaitCursor wait;
|
|
|
|
//
|
|
// piDataObject is the composite data object (MMC_MS_DO) created by MMC.
|
|
// We need to crack it to retrieve the multiselect data object (SI_MS_DO)
|
|
// we provided to MMC in QueryDataObject().
|
|
//
|
|
IDataObject *piSIMSDO = NULL;
|
|
HRESULT hr = GetSnapinMultiSelectDataObject(piDataObject, &piSIMSDO);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CFileMgmtDataObject *pDataObj = NULL;
|
|
hr = ExtractData(piSIMSDO, CFileMgmtDataObject::m_CFInternal, &pDataObj, sizeof(pDataObj));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// get the internal list of data objects of selected items, operate on each one of them.
|
|
//
|
|
CDataObjectList* pMultiSelectObjList = pDataObj->GetMultiSelectObjList();
|
|
for (CDataObjectList::iterator i = pMultiSelectObjList->begin(); i != pMultiSelectObjList->end(); i++)
|
|
{
|
|
BOOL bDeleted = CloseThisOneResource(*i, TRUE);
|
|
if (bDeleted)
|
|
bRefresh = TRUE;
|
|
}
|
|
}
|
|
|
|
piSIMSDO->Release();
|
|
}
|
|
}
|
|
|
|
return bRefresh;
|
|
}
|
|
|
|
BOOL CFileMgmtComponent::CloseThisOneResource(LPDATAOBJECT piDataObject, BOOL bQuietMode)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
|
|
ASSERT( piDataObject != NULL );
|
|
|
|
CCookie* pbasecookie = NULL;
|
|
FileMgmtObjectType objecttype;
|
|
HRESULT hr = ExtractBaseCookie( piDataObject, &pbasecookie, &objecttype );
|
|
ASSERT( SUCCEEDED(hr) && NULL != pbasecookie && FILEMGMT_RESOURCE == objecttype );
|
|
CFileMgmtResultCookie* pcookie = (CFileMgmtResultCookie*)pbasecookie;
|
|
|
|
if ( !bQuietMode && IDYES != DoErrMsgBox(GetActiveWindow(), MB_YESNO, 0, IDS_CONFIRM_CLOSERESOURCE) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
FILEMGMT_TRANSPORT transport = FILEMGMT_SMB;
|
|
VERIFY( SUCCEEDED( pcookie->GetTransport( &transport ) ) );
|
|
DWORD retval = 0;
|
|
|
|
if (bQuietMode)
|
|
{
|
|
retval = GetFileServiceProvider(transport)->CloseResource( pcookie );
|
|
} else
|
|
{
|
|
CWaitCursor wait;
|
|
retval = GetFileServiceProvider(transport)->CloseResource( pcookie );
|
|
}
|
|
|
|
if (0L != retval)
|
|
{
|
|
(void) DoErrMsgBox(GetActiveWindow(), MB_OK | MB_ICONSTOP, retval, IDS_POPUP_CLOSE_RESOURCE);
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
/// IExtendPropertySheet
|
|
|
|
STDMETHODIMP CFileMgmtComponent::QueryPagesFor(LPDATAOBJECT pDataObject)
|
|
{
|
|
MFC_TRY;
|
|
|
|
if (NULL == pDataObject)
|
|
{
|
|
ASSERT(FALSE);
|
|
return E_POINTER;
|
|
}
|
|
|
|
HRESULT hr = S_OK;
|
|
DATA_OBJECT_TYPES dataobjecttype = CCT_SCOPE;
|
|
// extract data from data object
|
|
FileMgmtObjectType objecttype = FileMgmtObjectTypeFromIDataObject(pDataObject);
|
|
hr = ExtractData( pDataObject, CFileMgmtDataObject::m_CFDataObjectType, &dataobjecttype, sizeof(dataobjecttype) );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
ASSERT( CCT_SCOPE == dataobjecttype ||
|
|
CCT_RESULT == dataobjecttype ||
|
|
CCT_SNAPIN_MANAGER == dataobjecttype );
|
|
|
|
// determine if it needs property pages
|
|
switch (objecttype)
|
|
{
|
|
case FILEMGMT_SESSION:
|
|
case FILEMGMT_RESOURCE:
|
|
ASSERT(CCT_SNAPIN_MANAGER != dataobjecttype);
|
|
return S_FALSE;
|
|
case FILEMGMT_SHARE: // now has a property page
|
|
{
|
|
CString strServerName;
|
|
CString strShareName;
|
|
FILEMGMT_TRANSPORT transport;
|
|
hr = ExtractString(pDataObject, CFileMgmtDataObject::m_CFMachineName, &strServerName, MAX_PATH);
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = ExtractString(pDataObject, CFileMgmtDataObject::m_CFShareName, &strShareName, MAX_PATH);
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = ExtractData(pDataObject, CFileMgmtDataObject::m_CFTransport, &transport, sizeof(DWORD));
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CString strDescription;
|
|
CString strPath;
|
|
DWORD dwRet = GetFileServiceProvider(transport)->ReadShareProperties(
|
|
strServerName,
|
|
strShareName,
|
|
NULL, // ppvPropertyBlock
|
|
strDescription,
|
|
strPath,
|
|
NULL, // pfEditDescription
|
|
NULL, // pfEditPath
|
|
NULL // pdwShareType
|
|
);
|
|
if (NERR_Success == dwRet)
|
|
{
|
|
return S_OK; // yes, we have a property page to display
|
|
} else
|
|
{
|
|
DoErrMsgBox(GetActiveWindow(), MB_OK | MB_ICONSTOP, dwRet, IDS_POPUP_QUERY_SHARE, strShareName);
|
|
if ((FILEMGMT_SMB == transport || FILEMGMT_FPNW == transport) && (NERR_NetNameNotFound == dwRet) ||
|
|
(FILEMGMT_SFM == transport) && (AFPERR_VolumeNonExist == dwRet))
|
|
{
|
|
RefreshAllViews(pDataObject);
|
|
}
|
|
}
|
|
}
|
|
|
|
return S_FALSE;
|
|
}
|
|
case FILEMGMT_SERVICE:
|
|
ASSERT(CCT_SNAPIN_MANAGER != dataobjecttype);
|
|
return S_OK;
|
|
#ifdef SNAPIN_PROTOTYPER
|
|
case FILEMGMT_PROTOTYPER_LEAF:
|
|
return S_OK;
|
|
#endif
|
|
default:
|
|
break;
|
|
}
|
|
ASSERT(FALSE);
|
|
return S_FALSE;
|
|
|
|
MFC_CATCH;
|
|
}
|
|
|
|
STDMETHODIMP CFileMgmtComponent::CreatePropertyPages(
|
|
LPPROPERTYSHEETCALLBACK pCallBack,
|
|
LONG_PTR handle, // This handle must be saved in the property page object to notify the parent when modified
|
|
LPDATAOBJECT pDataObject)
|
|
{
|
|
MFC_TRY;
|
|
if (NULL == pCallBack || NULL == pDataObject)
|
|
{
|
|
ASSERT(FALSE);
|
|
return E_POINTER;
|
|
}
|
|
HRESULT hr;
|
|
// extract data from data object
|
|
FileMgmtObjectType objecttype = FileMgmtObjectTypeFromIDataObject(pDataObject);
|
|
DATA_OBJECT_TYPES dataobjecttype = CCT_SCOPE;
|
|
hr = ExtractData( pDataObject, CFileMgmtDataObject::m_CFDataObjectType, &dataobjecttype, sizeof(dataobjecttype) );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
ASSERT( CCT_SCOPE == dataobjecttype ||
|
|
CCT_RESULT == dataobjecttype ||
|
|
CCT_SNAPIN_MANAGER == dataobjecttype );
|
|
|
|
// determine if it needs property pages
|
|
switch (objecttype)
|
|
{
|
|
case FILEMGMT_SHARE:
|
|
{
|
|
CWaitCursor cwait;
|
|
|
|
if (CCT_SNAPIN_MANAGER == dataobjecttype)
|
|
{
|
|
ASSERT(FALSE);
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
FILEMGMT_TRANSPORT transport;
|
|
hr = ExtractData( pDataObject,
|
|
CFileMgmtDataObject::m_CFTransport,
|
|
&transport,
|
|
sizeof(DWORD) );
|
|
if ( FAILED(hr) )
|
|
{
|
|
ASSERT( FALSE );
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
// CODEWORK probably not necessary to split off transport at this point
|
|
GetFileServiceProvider(transport)->DisplayShareProperties(pCallBack, pDataObject, handle);
|
|
return S_OK;
|
|
}
|
|
case FILEMGMT_SESSION:
|
|
case FILEMGMT_RESOURCE:
|
|
ASSERT(FALSE);
|
|
return E_UNEXPECTED;
|
|
case FILEMGMT_SERVICE:
|
|
if (CCT_RESULT != dataobjecttype)
|
|
{
|
|
ASSERT(FALSE);
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
if (!QueryComponentDataRef().Service_FInsertPropertyPages(OUT pCallBack, IN pDataObject, handle))
|
|
{
|
|
// Unable to open the service and query service info
|
|
return S_FALSE;
|
|
}
|
|
return S_OK;
|
|
default:
|
|
break;
|
|
}
|
|
ASSERT(FALSE);
|
|
return S_FALSE;
|
|
|
|
MFC_CATCH;
|
|
}
|
|
|
|
STDMETHODIMP CFileMgmtComponent::Compare(
|
|
LPARAM /*lUserParam*/, MMC_COOKIE cookieA, MMC_COOKIE cookieB, int* pnResult)
|
|
{
|
|
ASSERT(NULL != pnResult);
|
|
// WARNING cookie cast
|
|
CCookie* pBaseCookieA = reinterpret_cast<CCookie*>(cookieA);
|
|
CCookie* pBaseCookieB = reinterpret_cast<CCookie*>(cookieB);
|
|
ASSERT( NULL != pBaseCookieA && NULL != pBaseCookieB );
|
|
CFileMgmtCookie* pCookieA = QueryComponentDataRef().ActiveCookie(
|
|
(CFileMgmtCookie*)pBaseCookieA);
|
|
CFileMgmtCookie* pCookieB = QueryComponentDataRef().ActiveCookie(
|
|
(CFileMgmtCookie*)pBaseCookieB);
|
|
ASSERT( NULL != pCookieA && NULL != pCookieB );
|
|
FileMgmtObjectType objecttypeA = pCookieA->QueryObjectType();
|
|
FileMgmtObjectType objecttypeB = pCookieB->QueryObjectType();
|
|
ASSERT( IsValidObjectType(objecttypeA) && IsValidObjectType(objecttypeB) );
|
|
if (objecttypeA != objecttypeB)
|
|
{
|
|
// assign an arbitrary ordering to cookies with different nodetypes
|
|
*pnResult = ((int)objecttypeA) - ((int)objecttypeB);
|
|
return S_OK;
|
|
}
|
|
|
|
return pCookieA->CompareSimilarCookies( pBaseCookieB, pnResult);
|
|
}
|
|
|
|
|
|
STDMETHODIMP CFileMgmtComponent::GetProperty(
|
|
/* [in] */ LPDATAOBJECT pDataObject,
|
|
/* [in] */ BSTR szPropertyName,
|
|
/* [out] */ BSTR* pbstrProperty)
|
|
{
|
|
if ( IsBadReadPtr(pDataObject,sizeof(*pDataObject))
|
|
|| IsBadStringPtr(szPropertyName,0x7FFFFFFF)
|
|
|| IsBadWritePtr(pbstrProperty,sizeof(*pbstrProperty))
|
|
)
|
|
{
|
|
ASSERT(FALSE);
|
|
return E_POINTER;
|
|
}
|
|
|
|
CCookie* pbasecookie = NULL;
|
|
HRESULT hr = ExtractBaseCookie( pDataObject, &pbasecookie );
|
|
RETURN_HR_IF_FAIL;
|
|
ASSERT(NULL != pbasecookie);
|
|
CFileMgmtCookie* pcookie = (CFileMgmtCookie*)pbasecookie;
|
|
|
|
CString strProperty;
|
|
if (!_wcsicmp(L"CCF_HTML_DETAILS",szPropertyName))
|
|
{
|
|
if (FILEMGMT_SERVICE != pcookie->QueryObjectType())
|
|
return S_FALSE;
|
|
|
|
if (NULL == QueryComponentDataRef().m_hScManager)
|
|
{
|
|
ASSERT(FALSE);
|
|
return S_FALSE;
|
|
}
|
|
|
|
CString strServiceName;
|
|
if (!QueryComponentDataRef().Service_FGetServiceInfoFromIDataObject(
|
|
pDataObject,
|
|
NULL,
|
|
OUT &strServiceName,
|
|
NULL))
|
|
{
|
|
ASSERT(FALSE);
|
|
return S_FALSE;
|
|
}
|
|
|
|
BOOL rgfMenuFlags[iServiceActionMax];
|
|
::ZeroMemory(rgfMenuFlags,sizeof(rgfMenuFlags));
|
|
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState()); // required for CWaitCursor
|
|
CWaitCursor wait;
|
|
if (!Service_FGetServiceButtonStatus( // this will report errors itself
|
|
QueryComponentDataRef().m_hScManager,
|
|
strServiceName,
|
|
OUT rgfMenuFlags,
|
|
NULL, // pdwCurrentState
|
|
TRUE)) // fSilentError
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
|
|
for (INT i = 0; i < iServiceActionMax; i++)
|
|
{
|
|
if (rgfMenuFlags[i])
|
|
{
|
|
CString strTemp;
|
|
VERIFY(strTemp.LoadString(IDS_HTML_DETAILS_START+i));
|
|
strProperty += strTemp;
|
|
}
|
|
}
|
|
}
|
|
else if (!_wcsicmp(L"CCF_DESCRIPTION",szPropertyName))
|
|
{
|
|
hr = pcookie->GetExplorerViewDescription( strProperty );
|
|
}
|
|
else
|
|
{
|
|
return S_FALSE; // unknown strPropertyName
|
|
}
|
|
|
|
*pbstrProperty = ::SysAllocString(strProperty);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
// Virtual function called by CComponent::IComponent::Notify(MMCN_COLUMN_CLICK)
|
|
HRESULT CFileMgmtComponent::OnNotifyColumnClick( LPDATAOBJECT /*lpDataObject*/, LPARAM iColumn, LPARAM uFlags )
|
|
{
|
|
m_iSortColumn = (int)iColumn;
|
|
m_dwSortFlags = (DWORD) uFlags;
|
|
return m_pResultData->Sort ((int)iColumn, (DWORD)uFlags, 0);
|
|
}
|
|
|
|
HRESULT CFileMgmtComponent::OnNotifySnapinHelp (LPDATAOBJECT /*pDataObject*/)
|
|
{
|
|
return ShowHelpTopic( IsServiceSnapin()
|
|
? L"sys_srv_overview.htm"
|
|
: L"file_srv_overview.htm" );
|
|
}
|
|
|