able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/fs/utils/dfrg/dfrgsnap/dfrgsnapin.cpp

1306 lines
42 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include "stdafx.h"
#include "DfrgSnap.h"
#include "DfrgSnapin.h"
#include "resource.h"
#include "GetDfrgRes.h"
#include "Message.h"
#include "ErrMacro.h"
#include "vString.hpp"
/////////////////////////////////////////////////////////////////////////////
// CDfrgSnapinComponentData
//static const GUID CDfrgSnapinGUID_NODETYPE =
//{ 0xcd83a794, 0x6f75, 0x11d2, { 0xa3, 0x85, 0x0, 0x60, 0x97, 0x72, 0x64, 0x2e } };
static const GUID CDfrgSnapinGUID_NODETYPE =
{ 0x43668e22, 0x2636, 0x11d1, { 0xa1, 0xce, 0x0, 0x80, 0xc8, 0x85, 0x93, 0xa5 } };
const GUID* CDfrgSnapinData::m_NODETYPE = &CDfrgSnapinGUID_NODETYPE;
// original const OLECHAR* CDfrgSnapinData::m_SZNODETYPE = OLESTR("CD83A794-6F75-11D2-A385-00609772642E");
const OLECHAR* CDfrgSnapinData::m_SZNODETYPE = OLESTR("43668E22-2636-11D1-A1CE-0080C88593A5");
const OLECHAR* CDfrgSnapinData::m_SZDISPLAY_NAME = OLESTR("Disk Defragmenter");
const CLSID* CDfrgSnapinData::m_SNAPIN_CLASSID = &CLSID_DfrgSnapin;
//////////////////////////////////////
// New Extension code
static const GUID CDfrgSnapinExtGUID_NODETYPE =
{ 0x476e644a, 0xaaff, 0x11d0, { 0xb9, 0x44, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
const GUID* CDfrgSnapinExtData::m_NODETYPE = &CDfrgSnapinExtGUID_NODETYPE;
const OLECHAR* CDfrgSnapinExtData::m_SZNODETYPE = OLESTR("476e644a-aaff-11d0-b944-00c04fd8d5b0");
//sks bug # 94863, storing text "disk Defragmenter" in the registry. took out the words
//disk defragmenter, because it is loaded from the resources in the override method.
const OLECHAR* CDfrgSnapinExtData::m_SZDISPLAY_NAME = OLESTR("");
const CLSID* CDfrgSnapinExtData::m_SNAPIN_CLASSID = &CLSID_DfrgSnapin;
// New Extension code end
//////////////////////////////////////
HRESULT CDfrgSnapinData::GetScopePaneInfo(SCOPEDATAITEM *pScopeDataItem)
{
//TCHAR szBuf[ 256 ];
//wsprintf( szBuf, _T( "Mask is %d\n" ), pScopeDataItem->mask );
//OutputDebugString( szBuf );
if (pScopeDataItem->mask & SDI_STR)
pScopeDataItem->displayname = m_bstrDisplayName;
if (pScopeDataItem->mask & SDI_IMAGE)
pScopeDataItem->nImage = m_scopeDataItem.nImage;
if (pScopeDataItem->mask & SDI_OPENIMAGE)
pScopeDataItem->nOpenImage = m_scopeDataItem.nOpenImage;
if (pScopeDataItem->mask & SDI_PARAM)
pScopeDataItem->lParam = m_scopeDataItem.lParam;
if (pScopeDataItem->mask & SDI_STATE )
pScopeDataItem->nState = m_scopeDataItem.nState;
// TODO : Add code for SDI_CHILDREN
return S_OK;
}
HRESULT CDfrgSnapinData::GetResultPaneInfo(RESULTDATAITEM *pResultDataItem)
{
//TCHAR szBuf[ 256 ];
//wsprintf( szBuf, _T( "Mask is %d\n" ), pResultDataItem->mask );
//OutputDebugString( szBuf );
if (pResultDataItem->bScopeItem)
{
if (pResultDataItem->mask & RDI_STR)
{
pResultDataItem->str = GetResultPaneColInfo(pResultDataItem->nCol);
}
if (pResultDataItem->mask & RDI_IMAGE)
{
pResultDataItem->nImage = m_scopeDataItem.nImage;
}
if (pResultDataItem->mask & RDI_PARAM)
{
pResultDataItem->lParam = m_scopeDataItem.lParam;
}
return S_OK;
}
if (pResultDataItem->mask & RDI_STR)
{
pResultDataItem->str = GetResultPaneColInfo(pResultDataItem->nCol);
}
if (pResultDataItem->mask & RDI_IMAGE)
{
pResultDataItem->nImage = m_resultDataItem.nImage;
}
if (pResultDataItem->mask & RDI_PARAM)
{
pResultDataItem->lParam = m_resultDataItem.lParam;
}
if (pResultDataItem->mask & RDI_INDEX)
{
pResultDataItem->nIndex = m_resultDataItem.nIndex;
}
return S_OK;
}
HRESULT CDfrgSnapinData::Notify(
MMC_NOTIFY_TYPE event,
LPARAM arg,
LPARAM param,
IComponentData* pComponentData,
IComponent* pComponent,
DATA_OBJECT_TYPES type)
{
// Add code to handle the different notifications.
// Handle MMCN_SHOW and MMCN_EXPAND to enumerate children items.
// In response to MMCN_SHOW you have to enumerate both the scope
// and result pane items.
// For MMCN_EXPAND you only need to enumerate the scope items
// Use IConsoleNameSpace::InsertItem to insert scope pane items
// Use IResultData::InsertItem to insert result pane item.
HRESULT hr = E_NOTIMPL;
_ASSERTE(pComponentData != NULL || pComponent != NULL);
CComPtr<IConsole> spConsole;
CComQIPtr<IHeaderCtrl, &IID_IHeaderCtrl> spHeader;
if (pComponentData != NULL)
spConsole = ((CDfrgSnapin*)pComponentData)->m_spConsole;
else
{
spConsole = ((CDfrgSnapinComponent*)pComponent)->m_spConsole;
spHeader = spConsole;
}
switch (event)
{
case MMCN_SELECT:
{
//
// Always track the last valid component.
//
if ( HIWORD( arg ) == TRUE && pComponent )
m_pComponent = (CDfrgSnapinComponent*) pComponent;
//
// Always track whether or not we're a scope item.
//
m_fScopeItem = LOWORD( arg );
hr = S_OK;
}
break;
case MMCN_RESTORE_VIEW:
{
//
// Determines whether or not the remoted or OCX is displayed.
//
*( (BOOL*)param ) = TRUE;
hr = S_OK;
}
break;
case MMCN_CONTEXTHELP:
{
CComQIPtr<IDisplayHelp,&IID_IDisplayHelp> spHelp = spConsole;
spHelp->ShowTopic( CoTaskDupString( OLESTR( "defrag.chm::/defrag_overview.htm" ) ) );
hr = S_OK;
}
break;
case MMCN_DBLCLICK:
{
hr = S_FALSE;
}
break;
case MMCN_INITOCX:
{
hr = S_OK;
break;
}
case MMCN_SHOW:
{
CComQIPtr<IResultData, &IID_IResultData> spResultData(spConsole);
if(arg == 0)
{
SetActiveControl(FALSE, pComponent );
} else
{
SetActiveControl(TRUE, pComponent );
}
hr = OnShow( arg, spResultData );
break;
}
case MMCN_EXPAND:
{
CComQIPtr<IConsoleNameSpace, &IID_IConsoleNameSpace> spConsoleNameSpace(spConsole);
// TODO : Enumerate scope pane items
hr = S_OK;
break;
}
case MMCN_ADD_IMAGES:
{
// Add Images
IImageList* pImageList = (IImageList*)arg;
hr = E_FAIL;
// Load bitmaps associated with the scope pane
// and add them to the image list
// Loads the default bitmaps generated by the wizard
// Change as required
HBITMAP hBitmap16 = (HBITMAP) LoadImage(
GetDfrgResHandle(), // handle of the instance that contains the image
MAKEINTRESOURCE(IDB_DEFRAGSNAPIN_16), // name or identifier of image
IMAGE_BITMAP, // type of image
0, // desired width
0, // desired height
LR_DEFAULTCOLOR // load flags
);
if (hBitmap16 != NULL)
{
HBITMAP hBitmap32 = (HBITMAP ) LoadImage(
GetDfrgResHandle(),
MAKEINTRESOURCE(IDB_DEFRAGSNAPIN_32), // name or identifier of image
IMAGE_BITMAP, // type of image
0, // desired width
0, // desired height
LR_DEFAULTCOLOR // load flags
);
if (hBitmap32 != NULL)
{
hr = pImageList->ImageListSetStrip((LONG_PTR *)hBitmap16,
(LONG_PTR *)hBitmap32, 0, RGB(255, 255, 255));
if (FAILED(hr))
ATLTRACE(_T("IImageList::ImageListSetStrip failed\n"));
::DeleteObject(hBitmap32);
hBitmap32 = NULL;
}
::DeleteObject(hBitmap16);
hBitmap16 = NULL;
}
break;
}
}
return hr;
}
LPOLESTR CDfrgSnapinData::GetResultPaneColInfo(int nCol)
{
//
// 12/13/99 This method is prototyped to return a pointer to an OLESTR which is
// an OLECHAR array. Since this is a COM interface we should be using
// CoTaskMemAlloc to allocate space for a copy and then copy it in.
// The caller is then expected to free it. However per the MMC PM they are not
// freeing it and probably cannot now or they would break too many snap-ins.
//
// So until they change which will probably be never, I will temporarily just
// copy into a static and return a pointer to it. That way no one gets a
// pointer internal to our snap-in object, and we don't leak either.
//
LPOLESTR pStr = NULL;
static OLECHAR ColumnName[50 + 1];
static OLECHAR ColumnType[50 + 1];
static OLECHAR ColumnDesc[100 + 1];
switch (nCol)
{
case 0:
wcsncpy(ColumnName, m_wstrColumnName, 50);
ColumnName[50] = 0;
pStr = ColumnName;
break;
case 1:
wcsncpy(ColumnType, m_wstrColumnType, 50);
ColumnType[50] = 0;
pStr = ColumnType;
break;
case 2:
wcsncpy(ColumnDesc, m_wstrColumnDesc, 100);
ColumnDesc[100] = 0;
pStr = ColumnDesc;
break;
}
return(pStr);
}
HRESULT CDfrgSnapin::Initialize(LPUNKNOWN pUnknown)
{
HRESULT hr = IComponentDataImpl<CDfrgSnapin, CDfrgSnapinComponent >::Initialize(pUnknown);
if (FAILED(hr))
return hr;
CComPtr<IImageList> spImageList;
if (m_spConsole->QueryScopeImageList(&spImageList) != S_OK)
{
ATLTRACE(_T("IConsole::QueryScopeImageList failed\n"));
return E_UNEXPECTED;
}
// Load bitmaps associated with the scope pane
// and add them to the image list
// Loads the default bitmaps generated by the wizard
// Change as required
m_hBitmap16 = LoadBitmap( GetDfrgResHandle(), MAKEINTRESOURCE(IDB_DEFRAGSNAPIN_16));
if (m_hBitmap16 == NULL)
return S_OK;
m_hBitmap32 = LoadBitmap( GetDfrgResHandle(), MAKEINTRESOURCE(IDB_DEFRAGSNAPIN_32));
if (m_hBitmap32 == NULL) {
::DeleteObject(m_hBitmap16);
m_hBitmap16 = NULL;
return S_OK;
}
if (spImageList->ImageListSetStrip(
(LONG_PTR *)m_hBitmap16,
(LONG_PTR *)m_hBitmap32,
0, RGB(255, 255, 255)) != S_OK)
{
ATLTRACE(_T("IImageList::ImageListSetStrip failed\n"));
::DeleteObject(m_hBitmap16);
m_hBitmap16 = NULL;
::DeleteObject(m_hBitmap32);
m_hBitmap32 = NULL;
return E_UNEXPECTED;
}
::DeleteObject(m_hBitmap16);
m_hBitmap16 = NULL;
::DeleteObject(m_hBitmap32);
m_hBitmap32 = NULL;
return S_OK;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// ESI Code Start
///////////////////////////////////
// IExtendContextMenu::AddMenuItems()
STDMETHODIMP CDfrgSnapinData::AddMenuItems(
LPCONTEXTMENUCALLBACK pContextMenuCallback,
long *pInsertionAllowed,
DATA_OBJECT_TYPES type)
{
Message(TEXT("CDfrgSnapinData::AddMenuItems"), -1, NULL);
HRESULT hr = S_OK;
// Note - snap-ins need to look at the data object and determine
// in what context, menu items need to be added. They must also
// observe the insertion allowed flags to see what items can be
// added.
/* handy comment:
typedef struct _CONTEXTMENUITEM
{
LPWSTR strName;
LPWSTR strStatusBarText;
LONG lCommandID;
LONG lInsertionPointID;
LONG fFlags;
LONG fSpecialFlags;
} CONTEXTMENUITEM;
*/
HINSTANCE hDfrgRes = GetDfrgResHandle();
CONTEXTMENUITEM singleMenuItem;
TCHAR menuText[200];
TCHAR statusBarText[300];
//
// Retrieve the control from the current component.
//
assert( m_pComponent != NULL );
CComPtr<IDispatch> spDispCtl = m_pComponent->GetControl();
singleMenuItem.strName = menuText;
singleMenuItem.strStatusBarText = statusBarText;
singleMenuItem.fFlags = 0;
singleMenuItem.fSpecialFlags = 0;
// Add each of the items to the Action menu
if (*pInsertionAllowed & CCM_INSERTIONALLOWED_TOP) {
// setting for the Action menu
singleMenuItem.lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_TOP;
// get the state of the current engine
BOOL isOkToRun = GetSessionState( spDispCtl, IS_OK_TO_RUN);
if (isOkToRun && m_fScopeItem){
BOOL isEnginePaused = GetSessionState(spDispCtl, IS_ENGINE_PAUSED);
BOOL isEngineRunning = GetSessionState(spDispCtl, IS_ENGINE_RUNNING);
BOOL isVolListLocked = GetSessionState(spDispCtl, IS_VOLLIST_LOCKED);
BOOL isDefragInProcess = GetSessionState(spDispCtl, IS_DEFRAG_IN_PROCESS);
BOOL isReportAvailable = GetSessionState(spDispCtl, IS_REPORT_AVAILABLE);
// get the proper button states
LONG analyzeFlags=0;
LONG defragFlags=0;
LONG pauseFlags=0;
LONG stopFlags=0;
LONG seeReportFlags=0;
if (isVolListLocked){ // turn off all buttons if this volume is locked
analyzeFlags =
defragFlags =
pauseFlags =
stopFlags =
seeReportFlags = MF_DISABLED|MF_GRAYED;
}
else if (isEngineRunning){
analyzeFlags = defragFlags = seeReportFlags = MF_DISABLED|MF_GRAYED;
pauseFlags = stopFlags = MF_ENABLED;
}
else{ // neither defrag nor analyze are not running on any volumes
analyzeFlags = defragFlags = MF_ENABLED;
pauseFlags = stopFlags = MF_DISABLED|MF_GRAYED;
// is the report available for the currently selected volume?
seeReportFlags = isReportAvailable ? MF_ENABLED : MF_DISABLED|MF_GRAYED;
}
// analyze
singleMenuItem.lCommandID = IDM_ANALYZE;
singleMenuItem.fFlags = analyzeFlags;
LoadString(hDfrgRes, IDS_ANALYZE, menuText, sizeof(menuText) / sizeof(TCHAR));
LoadString(hDfrgRes, IDS_ANALYZE_STATUS_BAR, statusBarText, sizeof(statusBarText) / sizeof(TCHAR));
hr = pContextMenuCallback->AddItem(&singleMenuItem);
if (FAILED(hr)) {
Message(TEXT("CComponentDataImpl::AddMenuItems - pContextMenuCallback->AddItem"), hr, NULL);
return hr;
}
// defrag
singleMenuItem.lCommandID = IDM_DEFRAG;
singleMenuItem.fFlags = defragFlags;
LoadString(hDfrgRes, IDS_DEFRAGMENT, menuText, sizeof(menuText) / sizeof(TCHAR));
LoadString(hDfrgRes, IDS_DEFRAG_STATUS_BAR, statusBarText, sizeof(statusBarText) / sizeof(TCHAR));
hr = pContextMenuCallback->AddItem(&singleMenuItem);
if (FAILED(hr)) {
Message(TEXT("CComponentDataImpl::AddMenuItems - pContextMenuCallback->AddItem"), hr, NULL);
return hr;
}
// pause and resume button
singleMenuItem.fFlags = pauseFlags;
if (isEnginePaused) // resume
{
singleMenuItem.lCommandID = IDM_CONTINUE;
LoadString(hDfrgRes, IDS_RESUME, menuText, sizeof(menuText) / sizeof(TCHAR));
LoadString(hDfrgRes, IDS_RESUME_STATUS_BAR, statusBarText, sizeof(statusBarText) / sizeof(TCHAR));
}
else{ // pause button
singleMenuItem.lCommandID = IDM_PAUSE;
LoadString(hDfrgRes, IDS_PAUSE, menuText, sizeof(menuText) / sizeof(TCHAR));
LoadString(hDfrgRes, IDS_PAUSE_STATUS_BAR, statusBarText, sizeof(statusBarText) / sizeof(TCHAR));
}
// add the pause/resume button
hr = pContextMenuCallback->AddItem(&singleMenuItem);
if (FAILED(hr)) {
Message(TEXT("CComponentDataImpl::AddMenuItems - pContextMenuCallback->AddItem"), hr, NULL);
return hr;
}
// stop
singleMenuItem.lCommandID = IDM_STOP;
singleMenuItem.fFlags = stopFlags;
LoadString(hDfrgRes, IDS_STOP, menuText, sizeof(menuText) / sizeof(TCHAR));
LoadString(hDfrgRes, IDS_STOP_STATUS_BAR, statusBarText, sizeof(statusBarText) / sizeof(TCHAR));
hr = pContextMenuCallback->AddItem(&singleMenuItem);
if (FAILED(hr)) {
Message(TEXT("CComponentDataImpl::AddMenuItems - pContextMenuCallback->AddItem"), hr, NULL);
return hr;
}
// See Report
singleMenuItem.lCommandID = IDM_REPORT;
singleMenuItem.fFlags = seeReportFlags;
LoadString(hDfrgRes, IDS_REPORT, menuText, sizeof(menuText) / sizeof(TCHAR));
LoadString(hDfrgRes, IDS_REPORT_STATUS_BAR, statusBarText, sizeof(statusBarText) / sizeof(TCHAR));
hr = pContextMenuCallback->AddItem(&singleMenuItem);
if (FAILED(hr)) {
Message(TEXT("CComponentDataImpl::AddMenuItems - pContextMenuCallback->AddItem"), hr, NULL);
return hr;
}
// spacer
singleMenuItem.fFlags = MF_SEPARATOR;
hr = pContextMenuCallback->AddItem(&singleMenuItem);
if (FAILED(hr)) {
Message(TEXT("CComponentDataImpl::AddMenuItems - pContextMenuCallback->AddItem"), hr, NULL);
return hr;
}
// Refresh the list view
singleMenuItem.lCommandID = IDM_REFRESH;
singleMenuItem.fFlags = MF_ENABLED;
LoadString(hDfrgRes, IDS_REFRESH, menuText, sizeof(menuText) / sizeof(TCHAR));
LoadString(hDfrgRes, IDS_REFRESH_STATUS_BAR, statusBarText, sizeof(statusBarText) / sizeof(TCHAR));
hr = pContextMenuCallback->AddItem(&singleMenuItem);
if (FAILED(hr)) {
Message(TEXT("CComponentDataImpl::AddMenuItems - pContextMenuCallback->AddItem"), hr, NULL);
return hr;
}
}// end of IsOkToRun
}
// add the view items
if (*pInsertionAllowed & CCM_INSERTIONALLOWED_VIEW) {
}
return hr;
}
///////////////////////////////////
// IExtendContextMenu::Command()
STDMETHODIMP CDfrgSnapinData::Command(long lCommandID,
CSnapInObjectRootBase* pObj,
DATA_OBJECT_TYPES type)
{
Message(TEXT("CDfrgSnapinData::Command"), -1, NULL);
// Handle each of the commands.
switch (lCommandID) {
case IDM_ANALYZE:
SendCommand(ID_ANALYZE);
break;
case IDM_DEFRAG:
SendCommand(ID_DEFRAG);
break;
case IDM_CONTINUE:
SendCommand(ID_CONTINUE);
break;
case IDM_PAUSE:
SendCommand(ID_PAUSE);
break;
case IDM_STOP:
SendCommand(ID_STOP);
break;
case IDM_REPORT:
SendCommand(ID_REPORT);
break;
case IDM_REFRESH:
SendCommand(ID_REFRESH);
break;
default:
break;
}
return S_OK;
}
// contructor added by ESI
CDfrgSnapinComponent::CDfrgSnapinComponent()
{
Message(TEXT("CSnapinApp::InitInstance"), -1, NULL);
/*
Message(TEXT("CDefragSnapinComponent::CDefragSnapinComponent"), -1, NULL);
m_pHeader = NULL;
m_pComponentData = NULL;
//m_pToolbar1 = NULL;
//m_pControlbar = NULL;
//m_pbmpToolbar1 = NULL;
m_pConsoleVerb = NULL;
//m_pDfrgCtl = NULL;
*/
m_dwAdvise = 0;
}
CDfrgSnapinComponent::~CDfrgSnapinComponent()
{
Message(TEXT("CSnapinApp::ExitInstance"), -1, NULL);
}
/*
///////////////////////////////////////////////////////////////////////////////////////////////////
// Implementation of IComponent::Notify()
STDMETHODIMP CDfrgSnapinComponent::Notify(
LPDATAOBJECT lpDataObject,
MMC_NOTIFY_TYPE event,
long arg,
long param)
{
long cookie = 0;
HRESULT hr = S_OK;
TCHAR cString[64];
switch(event) {
case MMCN_PROPERTY_CHANGE:
Message(TEXT("CDefragSnapinComponent::Notify - MMCN_PROPERTY_CHANGE"), -1, NULL);
break;
case MMCN_VIEW_CHANGE:
Message(TEXT("CDefragSnapinComponent::Notify - MMCN_VIEW_CHANGE"), -1, NULL);
break;
case MMCN_ACTIVATE:
Message(TEXT("CDefragSnapinComponent::Notify - MMCN_ACTIVATE"), -1, NULL);
//hr = OnActivate(cookie, arg, param);
break;
case MMCN_CLICK:
Message(TEXT("CDefragSnapinComponent::Notify - MMCN_CLICK"), -1, NULL);
break;
case MMCN_DBLCLICK:
Message(TEXT("CDefragSnapinComponent::Notify - MMCN_DBLCLICK"), -1, NULL);
hr = S_FALSE; // false indicates that this is not implemented
break;
case MMCN_ADD_IMAGES:
Message(TEXT("CDefragSnapinComponent::Notify - MMCN_ADD_IMAGES"), -1, NULL);
break;
case MMCN_SHOW:
hr = OnShow(arg);
break;
case MMCN_MINIMIZED:
//hr = OnMinimize(cookie, arg, param);
break;
case MMCN_SELECT:
Message(TEXT("CDefragSnapinComponent::Notify - MMCN_SELECT"), -1, NULL);
// todo HandleStandardVerbs(arg, lpDataObject);
break;
case MMCN_BTN_CLICK:
Message(TEXT("CDefragSnapinComponent::Notify - MMCN_BTN_CLICK"), -1, NULL);
//AfxMessageBox(_T("CDefragSnapinComponent::MMCN_BTN_CLICK"));
break;
case MMCN_INITOCX:
Message(TEXT("CDefragSnapinComponent::Notify - MMCN_INITOCX"), -1, NULL);
break;
// Note - Future expansion of notify types possible
default:
wsprintf(cString, TEXT("event = 0x%x"), event);
Message(TEXT("CDefragSnapinComponent::Notify"), E_UNEXPECTED, cString);
hr = E_UNEXPECTED;
break;
}
return hr;
}
*/
/////////////////////////////////////////////////////
//
// Dispatch interface to the OCX (DfrgCtl) to send commands
//
/////////////////////////////////////////////////////
BOOL CDfrgSnapinData::SendCommand(LPARAM lparamCommand)
{
HRESULT hr;
// Ensure that we have a pointer to the Defrag OCX
if ( m_iDfrgCtlDispatch == NULL ){
Message(TEXT("SendCommand - m_iDfrgCtlDispatch is NULL!"), -1, NULL);
return( FALSE );
}
// get the defragger OCX dispatch interface
CComPtr<IDispatch> pDfrgCtlDispatch = m_iDfrgCtlDispatch;
// get the ID of the "Command" interface
OLECHAR FAR* szMember = TEXT("Command"); // maps this to "put_Command()"
DISPID dispid;
hr = pDfrgCtlDispatch->GetIDsOfNames(
IID_NULL, // Reserved for future use. Must be IID_NULL.
&szMember, // Passed-in array of names to be mapped.
1, // Count of the names to be mapped.
LOCALE_USER_DEFAULT,// The locale context in which to interpret the names.
&dispid); // Caller-allocated array (see help for details)
if (!SUCCEEDED(hr)) {
Message(TEXT("SendCommand - pDfrgCtlDispatch->GetIDsOfNames"), hr, NULL);
return FALSE;
}
DISPID mydispid = DISPID_PROPERTYPUT;
VARIANTARG* pvars = new VARIANTARG;
EF(pvars);
VariantInit(&pvars[0]);
pvars[0].vt = VT_I2;
pvars[0].iVal = (short)lparamCommand;
DISPPARAMS disp = { pvars, &mydispid, 1, 1 };
hr = pDfrgCtlDispatch->Invoke(
dispid, // unique number identifying the method to invoke
IID_NULL, // Reserved. Must be IID_NULL
LOCALE_USER_DEFAULT, // A locale ID
DISPATCH_PROPERTYPUT, // flag indicating the context of the method to invoke
&disp, // A structure with the parameters to pass to the method
NULL, // The result from the calling method
NULL, // returned exception information
NULL); // index indicating the first argument that is in error
delete pvars;
if (!SUCCEEDED(hr)) {
Message(TEXT("SendCommand - pDfrgCtlDispatch->Invoke"), hr, NULL);
return FALSE;
}
return TRUE;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// gets one of the states of the OCX
// see CSnapin.h for definition
///////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CDfrgSnapinData::GetSessionState(LPDISPATCH pdispControl, UINT sessionState)
{
DISPID dispid;
HRESULT hr;
// Ensure that we have a pointer to the Defrag OCX
if ( pdispControl == NULL)
return FALSE;
// get the defragger OCX dispatch interface
CComPtr<IDispatch> pDfrgCtlDispatch = pdispControl;
// array of the interface names
OLECHAR FAR* szMember[DFRG_INTERFACE_COUNT] = {
OLESTR("IsEnginePaused"),
OLESTR("IsEngineRunning"),
OLESTR("IsDefragInProcess"),
OLESTR("IsVolListLocked"),
OLESTR("ReportStatus"),
OLESTR("IsOkToRun")};
hr = pDfrgCtlDispatch->GetIDsOfNames(
IID_NULL, // Reserved for future use. Must be IID_NULL.
&szMember[sessionState], // Passed-in array of names to be mapped.
1/*DFRG_INTERFACE_COUNT*/, // Count of the names to be mapped.
LOCALE_USER_DEFAULT,// The locale context in which to interpret the names.
&dispid); // Caller-allocated array (see help for details)
if (!SUCCEEDED(hr)) {
Message(TEXT("GetSessionState - pDfrgCtlDispatch->GetIDsOfNames"), hr, NULL);
return FALSE;
}
VARIANT varResult;
VariantInit(&varResult);
V_VT(&varResult) = VT_I2;
DISPPARAMS dispparamsNoArgs = {NULL, NULL, 0, 0};
hr = pDfrgCtlDispatch->Invoke(
dispid, // unique number identifying the method to invoke
IID_NULL, // Reserved. Must be IID_NULL
LOCALE_USER_DEFAULT, // A locale ID
DISPATCH_PROPERTYGET, // flag indicating the context of the method to invoke
&dispparamsNoArgs, // A structure with the parameters to pass to the method
&varResult, // The result from the calling method
NULL, // returned exception information
NULL); // index indicating the first argument that is in error
if (!SUCCEEDED(hr)) {
Message(TEXT("IsReportAvailable - pDfrgCtlDispatch->Invoke"), hr, NULL);
return FALSE;
}
return V_BOOL(&varResult);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// gets the current engine state from the OCX
///////////////////////////////////////////////////////////////////////////////////////////////////
short CDfrgSnapinData::GetEngineState(void)
{
// Ensure that we have a pointer to the Defrag OCX
if( m_iDfrgCtlDispatch == NULL )
return FALSE;
// get the defragger OCX dispatch interface
CComPtr<IDispatch> pDfrgCtlDispatch = m_iDfrgCtlDispatch;
// get the ID of the "Command" interface
OLECHAR FAR* szMember = TEXT("EngineState"); // maps this to "get_EngineState()"
DISPID dispid;
HRESULT hr = pDfrgCtlDispatch->GetIDsOfNames(
IID_NULL, // Reserved for future use. Must be IID_NULL.
&szMember, // Passed-in array of names to be mapped.
1, // Count of the names to be mapped.
LOCALE_USER_DEFAULT,// The locale context in which to interpret the names.
&dispid); // Caller-allocated array (see help for details)
if (!SUCCEEDED(hr)) {
Message(TEXT("GetEngineState - pDfrgCtlDispatch->GetIDsOfNames"), hr, NULL);
return 0;
}
VARIANT varResult;
VariantInit(&varResult);
V_VT(&varResult) = VT_I2;
DISPPARAMS dispparamsNoArgs = {NULL, NULL, 0, 0};
hr = pDfrgCtlDispatch->Invoke(
dispid, // unique number identifying the method to invoke
IID_NULL, // Reserved. Must be IID_NULL
LOCALE_USER_DEFAULT, // A locale ID
DISPATCH_PROPERTYGET, // flag indicating the context of the method to invoke
&dispparamsNoArgs, // A structure with the parameters to pass to the method
&varResult, // The result from the calling method
NULL, // returned exception information
NULL); // index indicating the first argument that is in error
if (!SUCCEEDED(hr)) {
Message(TEXT("GetEngineState - pDfrgCtlDispatch->Invoke"), hr, NULL);
return 0;
}
return V_I2(&varResult);
}
//
// Determines if the enumeration is for a remoted machine or not.
//
#ifndef DNS_MAX_NAME_LENGTH
#define DNS_MAX_NAME_LENGTH 255
#endif
bool CDfrgSnapin::IsDataObjectRemoted( IDataObject* pDataObject )
{
bool fRemoted = false;
TCHAR szComputerName[ DNS_MAX_NAME_LENGTH + 1 ];
DWORD dwNameLength = (DNS_MAX_NAME_LENGTH + 1);
TCHAR szDataMachineName[ DNS_MAX_NAME_LENGTH + 1 ];
//
// Get local computer name.
//
GetComputerName(szComputerName, &dwNameLength);
//
// Get the machine name from the given data object.
//
if ( ExtractString( pDataObject, m_ccfRemotedFormat, szDataMachineName, DNS_MAX_NAME_LENGTH + 1 ) )
{
_toupper( szDataMachineName );
//
// Find the start of the server name.
//
LPTSTR pStr = szDataMachineName;
while ( pStr && *pStr == L'\\' )
pStr++;
//
// Compare the server name.
//
if ( pStr && *pStr && wcscmp( pStr, szComputerName ) != 0 )
fRemoted = true;
}
return( fRemoted );
}
//
// Retrieves the value of a given clipboard format from a given data object.
//
bool CDfrgSnapin::ExtractString( IDataObject* pDataObject, unsigned int cfClipFormat, LPTSTR pBuf, DWORD dwMaxLength)
{
USES_CONVERSION;
bool fFound = false;
FORMATETC formatetc = { (CLIPFORMAT) cfClipFormat, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
STGMEDIUM stgmedium = { TYMED_HGLOBAL, NULL };
stgmedium.hGlobal = ::GlobalAlloc( GMEM_SHARE, dwMaxLength * sizeof(TCHAR));
HRESULT hr;
do
{
//
// This is a memory error condition!
//
if ( NULL == stgmedium.hGlobal )
break;
hr = pDataObject->GetDataHere( &formatetc, &stgmedium );
if ( FAILED(hr) )
break;
LPWSTR pszNewData = reinterpret_cast<LPWSTR>( ::GlobalLock( stgmedium.hGlobal ) );
if ( NULL == pszNewData )
break;
pszNewData[ dwMaxLength - 1 ] = L'\0';
_tcscpy( pBuf, OLE2T( pszNewData ) );
fFound = true;
}
while( false );
if ( NULL != stgmedium.hGlobal )
{
GlobalUnlock( stgmedium.hGlobal );
GlobalFree( stgmedium.hGlobal );
}
return( fFound );
}
HRESULT CDfrgSnapinExtData::Notify( MMC_NOTIFY_TYPE event,
LPARAM arg,
LPARAM param,
IComponentData* pComponentData,
IComponent* pComponent,
DATA_OBJECT_TYPES type)
{
// Add code to handle the different notifications.
// Handle MMCN_SHOW and MMCN_EXPAND to enumerate children items.
// In response to MMCN_SHOW you have to enumerate both the scope
// and result pane items.
// For MMCN_EXPAND you only need to enumerate the scope items
// Use IConsoleNameSpace::InsertItem to insert scope pane items
// Use IResultData::InsertItem to insert result pane item.
HRESULT hr = E_NOTIMPL;
bool fRemoted = false;
_ASSERTE( pComponentData != NULL || pComponent != NULL );
CComPtr<IConsole> spConsole;
if ( pComponentData != NULL )
{
CDfrgSnapin* pExt = (CDfrgSnapin*) pComponentData;
spConsole = pExt->m_spConsole;
//
// Determine if we're remoted.
//
fRemoted = pExt->IsRemoted();
}
else
{
spConsole = ( (CDfrgSnapinComponent*) pComponent )->m_spConsole;
}
switch ( event )
{
case MMCN_SHOW:
arg = arg;
hr = S_OK;
break;
case MMCN_EXPAND:
{
if ( arg == TRUE )
{
CComQIPtr<IConsoleNameSpace, &IID_IConsoleNameSpace> spConsoleNameSpace(spConsole);
SCOPEDATAITEM* pScopeData;
//
// Create the node based on whether we're remoted or
// not.
//
m_pNode = new CDfrgSnapinData( fRemoted );
EE(m_pNode);
m_pNode->GetScopeData( &pScopeData );
pScopeData->relativeID = param;
spConsoleNameSpace->InsertItem( pScopeData );
if ( pComponentData )
( (CDfrgSnapin*) pComponentData )->m_pNode = m_pNode;
}
hr = S_OK;
break;
}
case MMCN_REMOVE_CHILDREN:
{
//
// We are not deleting this node since this same pointer is
// stashed in the pComponentData in response to the MMCN_EXPAND
// notification. The destructor of pComponentData deletes the pointer
// to this node.
//
//delete m_pNode;
m_pNode = NULL;
hr = S_OK;
break;
}
case MMCN_ADD_IMAGES:
{
// Add Images
IImageList* pImageList = (IImageList*)arg;
hr = E_FAIL;
// Load bitmaps associated with the scope pane
// and add them to the image list
// Loads the default bitmaps generated by the wizard
// Change as required
HBITMAP hBitmap16 = (HBITMAP) LoadImage(
GetDfrgResHandle(), // handle of the instance that contains the image
MAKEINTRESOURCE(IDB_DEFRAGSNAPIN_16), // name or identifier of image
IMAGE_BITMAP, // type of image
0, // desired width
0, // desired height
LR_DEFAULTCOLOR // load flags
);
if (hBitmap16 != NULL)
{
BITMAP bm;
GetObject( hBitmap16, sizeof( bm ), &bm );
HBITMAP hBitmap32 = (HBITMAP ) LoadImage(
GetDfrgResHandle(),
MAKEINTRESOURCE(IDB_DEFRAGSNAPIN_32), // name or identifier of image
IMAGE_BITMAP, // type of image
0, // desired width
0, // desired height
LR_DEFAULTCOLOR // load flags
);
if (hBitmap32 != NULL)
{
GetObject( hBitmap32, sizeof( bm ), &bm );
hr = pImageList->ImageListSetStrip((LONG_PTR *)hBitmap16,
(LONG_PTR *)hBitmap32, 0, RGB(255, 255, 255));
if (FAILED(hr))
ATLTRACE(_T("IImageList::ImageListSetStrip failed\n"));
::DeleteObject(hBitmap32);
hBitmap32 = NULL;
}
::DeleteObject(hBitmap16);
hBitmap16 = NULL;
}
break;
}
}
return hr;
}
/////////////////////////////////////////////////////////////////////////////////////////////
//
// ESI function called when the snapin changes show state
//
HRESULT CDfrgSnapinData::OnShow(LPARAM isShowing, IResultData* pResults )
{
return S_OK;
}
/////////////////////////////////////////////////////////////////////////////////////////////
//
// instantiates the OCX
//
// implementation of IComponent::GetResultViewType()
STDMETHODIMP CDfrgSnapinData::GetResultViewType(
LPOLESTR* ppViewType,
long* pViewOptions)
{
TCHAR szPath[ _MAX_PATH + 30 ];
Message(TEXT("IComponent::GetResultViewType"), -1, NULL);
*pViewOptions = MMC_VIEW_OPTIONS_NOLISTVIEWS;
// Make sure that we are displaying the OCX?
if ( m_CustomViewID != VIEW_DEFRAG_OCX ) {
return S_FALSE;
}
//
// TLP: Return back a web page if we're remoted.
//
if ( m_fRemoted )
{
TCHAR szModulePath[ _MAX_PATH + 1 ];
//
// Get the HTML embedded in the res file.
//
GetModuleFileName( GetDfrgResHandle(), szModulePath, _MAX_PATH );
//
// Append the necessary decorations for correct access.
//
_tcscpy( szPath, _T( "res://" ) );
_tcscat( szPath, szModulePath );
_tcscat( szPath, _T( "/REMOTED.HTM" ) );
}
else
{
//
// Display the normal OCX.
//
_tcscpy( szPath, szDefragGUID );
}
UINT uiByteLen = (lstrlen(szPath) + 1) * sizeof(OLECHAR);
LPOLESTR psz = (LPOLESTR)::CoTaskMemAlloc(uiByteLen);
if (psz == NULL) {
return S_FALSE;
}
lstrcpy(psz, szPath);
*ppViewType = psz;
return S_OK;
}
void CDfrgSnapinComponent::Advise()
{
if ( m_dwAdvise == 0 )
{
HRESULT hr = AtlAdvise( m_spDisp, this->GetUnknown(), IID_IDfrgEvents, &m_dwAdvise );
_ASSERTE( SUCCEEDED( hr ) );
}
}
void CDfrgSnapinComponent::Unadvise()
{
if ( m_dwAdvise != 0 )
{
HRESULT hr = AtlUnadvise( m_spDisp, IID_IDfrgEvents, m_dwAdvise );
_ASSERTE( SUCCEEDED( hr ) );
m_dwAdvise = 0;
}
}
//
// Overrides the Filldata
//
STDMETHODIMP CDfrgSnapinData::FillData( CLIPFORMAT cf, LPSTREAM pStream )
{
HRESULT hr = DV_E_CLIPFORMAT;
ULONG uWritten;
//
// We need to write out our own member since GetDisplayName() does
// not give us an opportunity override its static implementation by
// ATL.
//
if (cf == m_CCF_NODETYPE) // wants the guid for the node
{
hr = pStream->Write( GetNodeType(), sizeof(GUID), &uWritten);
return hr;
}
if (cf == m_CCF_SZNODETYPE) // string that describes the node (not displayed, used for lookup of the node)
{
hr = pStream->Write( GetSZNodeType(), (lstrlen((LPCTSTR) GetSZNodeType()) + 1 )* sizeof(TCHAR), &uWritten);
return hr;
}
if (cf == m_CCF_DISPLAY_NAME) // displayed in the scope pane to id the node (root only)
{
USES_CONVERSION;
VString vDisplayName(IDS_PRODUCT_NAME, GetDfrgResHandle());
hr = pStream->Write(vDisplayName.GetBuffer(), vDisplayName.GetLength() * sizeof( WCHAR ), &uWritten);
return hr;
}
if (cf == m_CCF_SNAPIN_CLASSID) // guid of the snapin (CLSID)
{
hr = pStream->Write( GetSnapInCLSID(), sizeof(GUID), &uWritten);
return hr;
}
return hr;
}
/*
STDMETHODIMP_(ULONG) CDfrgSnapinData::Release(void)
{
if (InterlockedDecrement(&m_cRef) == 0) {
delete this;
return 0;
}
return m_cRef;
}
STDMETHODIMP CDfrgSnapinData::QueryInterface(REFIID riid, void** ppv)
{
if (ppv == NULL)
return E_INVALIDARG;
// Make sure we are being asked for a DataObject interface.
if ( riid == IID_IUnknown || riid == IID_IDfrgEvents )
{
// If so return a pointer to this interface.
*ppv = (IUnknown *) this;
AddRef();
return S_OK;
}
// No interface.
*ppv = NULL;
return E_NOINTERFACE;
}
*/
//
// Called from the OCX when the status has changed.
//
STDMETHODIMP CDfrgSnapinComponent::StatusChanged( BSTR bszStatus )
{
if (m_spConsole){
CComQIPtr<IConsole2,&IID_IConsole2> pConsole = m_spConsole;
pConsole->SetStatusText( bszStatus );
}
return( S_OK );
}
//
// Called from the OCX when the OK to run property has changed.
//
STDMETHODIMP CDfrgSnapinComponent::IsOKToRun( BOOL bOK )
{
( (CDfrgSnapinData*) m_pComponentData->m_pNode )->SetActiveControl( TRUE, this );
return( S_OK );
}
void CDfrgSnapinData::SetActiveControl( BOOL bActive, IComponent* pComponent )
{
CComPtr<IConsole> spConsole;
spConsole = ((CDfrgSnapinComponent*)pComponent)->m_spConsole;
//
// Always get the ctl dispatch pointer.
//
CComPtr<IUnknown> pUnk;
spConsole->QueryResultView( &pUnk );
CComQIPtr<IDispatch,&IID_IDispatch> pCtl = pUnk;
//
// If this is the first one, then check if we're
// valid. If we are, then assign this conrol to
//
if ( GetSessionState( pCtl, IS_OK_TO_RUN ) == TRUE )
m_iDfrgCtlDispatch = pCtl;
//
// Always attach the control to the component.
//
( (CDfrgSnapinComponent*) pComponent )->SetControl( bActive == TRUE ? (LPDISPATCH) pCtl : (LPDISPATCH) NULL );
}
STDMETHODIMP CDfrgSnapinComponent::AddMenuItems(LPDATAOBJECT pDataObject, LPCONTEXTMENUCALLBACK piCallback,long *pInsertionAllowed)
{
HRESULT hr;
if ( IS_SPECIAL_DATAOBJECT( pDataObject ) )
{
hr = m_pComponentData->m_pNode->AddMenuItems( piCallback, pInsertionAllowed, CCT_RESULT );
}
else
{
hr = IExtendContextMenuImpl<CDfrgSnapin>::AddMenuItems( pDataObject, piCallback, pInsertionAllowed );
}
return( hr );
}
STDMETHODIMP CDfrgSnapinComponent::Command(long lCommandID, LPDATAOBJECT pDataObject)
{
HRESULT hr;
if ( IS_SPECIAL_DATAOBJECT( pDataObject ) )
{
hr = m_pComponentData->m_pNode->Command( lCommandID, this, CCT_RESULT );
}
else
{
hr = IExtendContextMenuImpl<CDfrgSnapin>::Command( lCommandID, pDataObject );
}
return( hr );
}
Reference in a new issue Copy permalink