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.
2351 lines
62 KiB
2351 lines
62 KiB
/* CompData.cpp : Implementation of the ComponentData (namespace items) for
|
|
* the MSInfo Snapin.
|
|
*
|
|
* Copyright (c) 1998-1999 Microsoft Corporation
|
|
*
|
|
* History: a-jsari 8/27/97 Initial version
|
|
*/
|
|
|
|
#include "StdAfx.h"
|
|
#include <Commdlg.h>
|
|
#include <iostream.h>
|
|
#include <atlbase.h>
|
|
#include <htmlhelp.h>
|
|
|
|
#ifndef IDB_16x16
|
|
#include "Resource.h"
|
|
#endif // IDB_16x16
|
|
#include "resrc1.h"
|
|
|
|
#include "DataObj.h"
|
|
#include "CompData.h"
|
|
#include "DataSrc.h"
|
|
#include "SysInfo.h"
|
|
#include "ViewObj.h"
|
|
#include "Dialogs.h"
|
|
#include "chooser.h"
|
|
|
|
static LPCTSTR cszViewKey = _T("Software\\Microsoft\\MSInfo");
|
|
static LPCTSTR cszViewValue = _T("View");
|
|
static LPCTSTR cszBasicValue = _T("basic");
|
|
static LPCTSTR cszAdvancedValue = _T("advanced");
|
|
|
|
/*
|
|
* CSystemInfoScope - Trivial constructor. Make sure all of our
|
|
* essential pointers start NULL.
|
|
*
|
|
* History: a-jsari 8/27/97 Initial version
|
|
*/
|
|
CSystemInfoScope::CSystemInfoScope()
|
|
:m_pScope(NULL),
|
|
m_pConsole(NULL),
|
|
m_pSource(NULL),
|
|
m_bIsDirty(FALSE),
|
|
m_bInitializedCD(FALSE),
|
|
m_fViewUninitialized(FALSE),
|
|
m_prdSave(NULL),
|
|
m_prdOpen(NULL),
|
|
m_prdReport(NULL),
|
|
m_pthdFind(NULL),
|
|
m_BasicFlags(0L),
|
|
m_AdvancedFlags(MF_CHECKED),
|
|
m_pwConsole(NULL),
|
|
m_pmapCategories(NULL),
|
|
m_pstrMachineName(new CString),
|
|
m_pstrOverrideName(new CString),
|
|
m_pstrCategory(NULL),
|
|
m_RootCookie(0),
|
|
m_fSelectCategory(FALSE),
|
|
m_pSetSourceSource(NULL),
|
|
m_fSetSourcePreLaunch(FALSE),
|
|
m_pViewCABTool(NULL),
|
|
m_pSaveUnknown(NULL),
|
|
m_fInternalDelete(FALSE),
|
|
m_pLastSystemInfo(NULL)
|
|
{
|
|
#ifdef _DEBUG
|
|
m_bDestroyedCD = true;
|
|
#endif // _DEBUG
|
|
}
|
|
|
|
/*
|
|
* ~CSystemInfoScope - Never called. Don't use.
|
|
*
|
|
* History: a-jsari 8/27/97 Initial version
|
|
*/
|
|
CSystemInfoScope::~CSystemInfoScope()
|
|
{
|
|
#ifdef _DEBUG
|
|
if (m_bInitializedCD)
|
|
ASSERT(m_pScope == NULL);
|
|
ASSERT(m_pConsole == NULL);
|
|
ASSERT(m_bDestroyedCD);
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* InitializeDialogs - Pre-create our Dialog pointers to speed their loading when
|
|
* they are needed.
|
|
*
|
|
* History: a-jsari 11/28/97 Moved from Initialize
|
|
*/
|
|
inline HRESULT CSystemInfoScope::InitializeDialogs()
|
|
{
|
|
HWND hWindow;
|
|
|
|
ASSERT(m_pConsole != NULL);
|
|
HRESULT hr = m_pConsole->GetMainWindow(&hWindow);
|
|
ASSERT(hr == S_OK);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
ASSERT(m_prdReport == NULL);
|
|
m_prdReport = new CMSInfoReportDialog(hWindow);
|
|
ASSERT(m_prdReport != NULL);
|
|
if (m_prdReport == NULL) ::AfxThrowMemoryException();
|
|
|
|
m_prdSave = new CMSInfoSaveDialog(hWindow);
|
|
ASSERT(m_prdSave != NULL);
|
|
if (m_prdSave == NULL) ::AfxThrowMemoryException();
|
|
|
|
m_prdOpen = new CMSInfoOpenDialog(hWindow);
|
|
ASSERT(m_prdOpen != NULL);
|
|
if (m_prdOpen == NULL) ::AfxThrowMemoryException();
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
* FindWindowProc - The window proc for the hidden window that will allow us to
|
|
* call find from the Find Dialog Thread.
|
|
*
|
|
* History: a-jsari 2/6/98 Initial version
|
|
*/
|
|
static LRESULT CALLBACK FindWindowProc(HWND, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
// ASSERT(uMsg == CFindDialog::WM_MSINFO_FIND);
|
|
// Only process our specific message.
|
|
if (uMsg == CFindDialog::WM_MSINFO_FIND)
|
|
reinterpret_cast<CSystemInfoScope *>(wParam)->ExecuteFind((long)lParam);
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* InitializeInternal - Because MMC never calls our destructor, we are leaking
|
|
* memory in our member classes. To fix this, allocate them on the heap
|
|
* and delete them in our Destroy method.
|
|
*
|
|
* History: a-jsari 12/30/97 Initial version
|
|
*/
|
|
inline HRESULT CSystemInfoScope::InitializeInternal()
|
|
{
|
|
AFX_MANAGE_STATE(::AfxGetStaticModuleState());
|
|
|
|
m_pmapCategories = new CScopeItemMap;
|
|
ASSERT(m_pmapCategories != NULL);
|
|
if (m_pmapCategories == NULL) ::AfxThrowMemoryException();
|
|
|
|
CString strClassName;
|
|
CString strWindowName;
|
|
HWND hwndParent;
|
|
CREATESTRUCT csFind;
|
|
|
|
VERIFY(strClassName.LoadString(IDS_FINDCLASS));
|
|
VERIFY(strWindowName.LoadString(IDS_FINDWINDOWNAME));
|
|
|
|
WNDCLASSEX wceFind;
|
|
::memset(&wceFind, 0, sizeof(wceFind));
|
|
wceFind.cbSize = sizeof(wceFind);
|
|
wceFind.style = CS_CLASSDC;
|
|
wceFind.lpfnWndProc = FindWindowProc;
|
|
wceFind.hInstance = ::AfxGetInstanceHandle();
|
|
wceFind.lpszClassName = (LPCTSTR)strClassName;
|
|
|
|
::RegisterClassEx(&wceFind);
|
|
pConsole()->GetMainWindow(&hwndParent);
|
|
m_hwndFind = ::CreateWindow(strClassName, strWindowName, WS_CHILD,
|
|
0, 0, 0, 0, hwndParent, NULL, wceFind.hInstance, &csFind);
|
|
ASSERT(m_hwndFind != NULL);
|
|
return S_OK;
|
|
}
|
|
|
|
/*
|
|
* SkipSpaces - Advance the pointer passed in beyond all spaces.
|
|
*
|
|
* History: a-jsari 11/28/97 Initial version
|
|
*/
|
|
inline void SkipSpaces(LPTSTR &pszString)
|
|
{
|
|
while (_istspace(*pszString)) ++pszString;
|
|
}
|
|
|
|
/*
|
|
* GetValue - Save the value (of the form '= Value' out of pszString into
|
|
* szValue.
|
|
*
|
|
* History: a-jsari 11/28/97 Initial version
|
|
*/
|
|
static inline BOOL GetValue(LPTSTR &pszString, LPTSTR szValue)
|
|
{
|
|
SkipSpaces(pszString);
|
|
//if (*pszString++ != (TCHAR)'=')
|
|
// return FALSE;
|
|
|
|
if (*pszString == (TCHAR)'=')
|
|
pszString++;
|
|
|
|
SkipSpaces(pszString);
|
|
if (*pszString == (TCHAR)'"') {
|
|
|
|
++pszString;
|
|
do {
|
|
*szValue = *pszString;
|
|
if (*szValue++ == 0)
|
|
return FALSE;
|
|
} while ((*pszString++ != '"'));
|
|
|
|
*--szValue = (TCHAR)0;
|
|
} else {
|
|
do {
|
|
*szValue++ = *pszString;
|
|
if (*pszString == 0)
|
|
return TRUE;
|
|
} while (!::_istspace(*pszString++));
|
|
*--szValue = (TCHAR)0;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* DisplayHelp - Show the help information for MSInfo
|
|
*
|
|
* History: a-jsari 11/28/97 Initial version
|
|
*/
|
|
static inline void DisplayHelp(LPTSTR /* szHelp */)
|
|
{
|
|
AFX_MANAGE_STATE(::AfxGetStaticModuleState());
|
|
|
|
CString strHelpFile;
|
|
VERIFY(strHelpFile.LoadString(IDS_HELPFILE));
|
|
::HtmlHelp(/* HWND */ NULL, strHelpFile, HH_DISPLAY_TOPIC, 0);
|
|
}
|
|
|
|
/*
|
|
* ProcessCommandLine - Grab all of the essential values out of our command
|
|
* line.
|
|
*
|
|
* History: a-jsari 11/28/97 Initial version
|
|
*/
|
|
HRESULT CSystemInfoScope::ProcessCommandLine()
|
|
{
|
|
const int VALUE_SIZE = 256;
|
|
LPTSTR szCommands = ::GetCommandLine();
|
|
LPTSTR pszCurrent = szCommands;
|
|
TCHAR szValueBuffer[VALUE_SIZE];
|
|
int iFirst;
|
|
|
|
if (pszCurrent == NULL) return E_FAIL;
|
|
while (TRUE) {
|
|
iFirst = _tcscspn(pszCurrent, _T(" \t"));
|
|
|
|
// If our match is \0, we have reached the end of the string.
|
|
if (pszCurrent[iFirst] == (TCHAR)'\0') break;
|
|
|
|
pszCurrent += iFirst;
|
|
++pszCurrent;
|
|
SkipSpaces(pszCurrent);
|
|
|
|
// Not a command line switch, check the next parameter.
|
|
if (!(*pszCurrent == (TCHAR)'/' || *pszCurrent == (TCHAR)'-'))
|
|
continue;
|
|
else
|
|
++pszCurrent;
|
|
|
|
// We are processing the computer flag.
|
|
if (_tcsnicmp(pszCurrent, _T("computer"), 8) == 0)
|
|
{
|
|
pszCurrent += 8;
|
|
if (GetValue(pszCurrent, szValueBuffer) == TRUE)
|
|
m_strDeferredMachine = szValueBuffer;
|
|
}
|
|
|
|
// After this point, all flags are msinfo specific.
|
|
if (_tcsnicmp(pszCurrent, _T("msinfo"), 6) != 0) continue;
|
|
pszCurrent += 6; // pszCurrent += strlen("msinfo");
|
|
|
|
if (*pszCurrent == (TCHAR)'?'
|
|
|| _tcsnicmp(pszCurrent, _T("_help"), 5) == 0) {
|
|
LPTSTR pszValue;
|
|
if (GetValue(pszCurrent, szValueBuffer) == TRUE) {
|
|
pszValue = szValueBuffer;
|
|
} else {
|
|
// No value for help switch, back up to the previous space, unless we're
|
|
// at the end of the string.
|
|
if (*pszCurrent != 0)
|
|
do --pszCurrent; while (!::_istspace(*pszCurrent));
|
|
pszValue = NULL;
|
|
}
|
|
DisplayHelp(pszValue);
|
|
continue;
|
|
}
|
|
|
|
if (_tcsnicmp(pszCurrent, _T("_category"), 9) == 0) {
|
|
pszCurrent += 9;
|
|
if (GetValue(pszCurrent, szValueBuffer) == TRUE) {
|
|
// -1 parameter means select no result pane item.
|
|
m_pstrCategory = new CString(szValueBuffer);
|
|
// SelectItem(szValueBuffer, -1);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (_tcsnicmp(pszCurrent, _T("_file"), 5) == 0)
|
|
{
|
|
pszCurrent += 5;
|
|
if (GetValue(pszCurrent, szValueBuffer) == TRUE)
|
|
m_strDeferredLoad = szValueBuffer;
|
|
continue;
|
|
}
|
|
|
|
if (_tcsnicmp(pszCurrent, _T("_showcategories"), 15) == 0)
|
|
{
|
|
pszCurrent += 15;
|
|
if (GetValue(pszCurrent, szValueBuffer) == TRUE)
|
|
m_strDeferredCategories = szValueBuffer;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/*
|
|
* Initialize - Called from MMC; we Initialize all of our relevant pointers
|
|
* using QueryInterface and set the IConsole ImageList.
|
|
*
|
|
* History: a-jsari 8/27/97 Initial version
|
|
*/
|
|
|
|
STDMETHODIMP CSystemInfoScope::Initialize(LPUNKNOWN pUnknown)
|
|
{
|
|
ASSERT(pUnknown != NULL);
|
|
TRACE(_T("CSystemInfoScope::Initialize\n"));
|
|
|
|
HRESULT hr;
|
|
|
|
do {
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
// MMC should only call ::Initialize once!
|
|
ASSERT(m_pScope == NULL);
|
|
|
|
hr = pUnknown->QueryInterface(IID_IConsoleNameSpace, reinterpret_cast<void **>(&m_pScope));
|
|
|
|
ASSERT(hr == S_OK);
|
|
if (FAILED(hr))
|
|
break;
|
|
|
|
ASSERT(m_pConsole == NULL);
|
|
hr = pUnknown->QueryInterface(IID_IConsole, reinterpret_cast<void **>(&m_pConsole));
|
|
ASSERT(hr == S_OK);
|
|
if (FAILED(hr))
|
|
break;
|
|
|
|
if (m_pSaveUnknown == NULL) // check this out, reversed
|
|
{
|
|
// We are reinitializing, so don't do the image list code again.
|
|
|
|
::CBitmap bmp16x16;
|
|
::CBitmap bmp32x32;
|
|
LPIMAGELIST lpScopeImage;
|
|
|
|
hr = m_pConsole->QueryScopeImageList(&lpScopeImage);
|
|
ASSERT(hr == S_OK);
|
|
if (FAILED(hr))
|
|
break;
|
|
|
|
VERIFY(bmp16x16.LoadBitmap(IDB_16x16));
|
|
VERIFY(bmp32x32.LoadBitmap(IDB_32x32));
|
|
|
|
hr = lpScopeImage->ImageListSetStrip(
|
|
reinterpret_cast<LONG_PTR *>(static_cast<HBITMAP>(bmp16x16)),
|
|
reinterpret_cast<LONG_PTR *>(static_cast<HBITMAP>(bmp32x32)),
|
|
0, RGB(255,0,255));
|
|
|
|
(void)lpScopeImage->Release();
|
|
|
|
ASSERT(hr == S_OK);
|
|
if (FAILED(hr))
|
|
break;
|
|
|
|
// This is also a fine place to add the log entry for starting MSInfo,
|
|
// so it won't be repeated when we reinitialize.
|
|
|
|
if (msiLog.IsLogging())
|
|
msiLog.WriteLog(CMSInfoLog::BASIC, _T("START MSInfo\r\n"));
|
|
}
|
|
|
|
hr = InitializeDialogs();
|
|
if (FAILED(hr)) break;
|
|
|
|
hr = InitializeInternal();
|
|
if (FAILED(hr)) break;
|
|
|
|
hr = ProcessCommandLine();
|
|
|
|
} while (FALSE);
|
|
|
|
if (FAILED(hr)) {
|
|
SAFE_RELEASE(m_pScope);
|
|
SAFE_RELEASE(m_pConsole);
|
|
}
|
|
else {
|
|
m_bInitializedCD = true;
|
|
}
|
|
|
|
#ifdef _DEBUG
|
|
m_bDestroyedCD = false;
|
|
#endif
|
|
// Note that MMC does not permit us to fail return from Initialize,
|
|
// so we always return S_OK, whether or not our Initialization is
|
|
// successful.
|
|
return S_OK;
|
|
}
|
|
|
|
/*
|
|
* InitializeView - Read the current user's view information from the registry
|
|
*
|
|
* History: a-jsari 12/3/97 Initial version.
|
|
*/
|
|
HRESULT CSystemInfoScope::InitializeView()
|
|
{
|
|
CRegKey crkView;
|
|
long lResult;
|
|
TCHAR szBuffer[1024];
|
|
DWORD dwSize;
|
|
|
|
lResult = crkView.Open(HKEY_CURRENT_USER, cszViewKey);
|
|
if (lResult == ERROR_SUCCESS) {
|
|
dwSize = sizeof(szBuffer);
|
|
lResult = crkView.QueryValue(szBuffer, cszViewValue, &dwSize);
|
|
}
|
|
if (lResult != ERROR_SUCCESS)
|
|
// Default to basic view.
|
|
SetView(BASIC, TRUE);
|
|
else {
|
|
if (::_tcscmp(szBuffer, cszBasicValue) == 0)
|
|
SetView(BASIC, FALSE);
|
|
else if (::_tcscmp(szBuffer, cszAdvancedValue) == 0)
|
|
SetView(ADVANCED, FALSE);
|
|
else {
|
|
ASSERT(FALSE);
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CSystemInfoScope::MessageBox( CString strText)
|
|
{
|
|
CString strTitle;
|
|
strTitle.LoadString( IDS_DESCRIPTION);
|
|
int nRC;
|
|
|
|
return pConsole()->MessageBox( strText, strTitle, MB_OK, &nRC);
|
|
}
|
|
|
|
/*
|
|
* InitializeSource - Perform any initialization which may fail.
|
|
*
|
|
* History: a-jsari 12/3/97 Initial version.
|
|
*/
|
|
HRESULT CSystemInfoScope::InitializeSource()
|
|
{
|
|
AFX_MANAGE_STATE(::AfxGetStaticModuleState());
|
|
CWaitCursor DoWaitCursor;
|
|
|
|
try {
|
|
// m_pSource will exist if we were loaded from a stream.
|
|
if (m_pSource == NULL) {
|
|
m_bInitializedCD = true;
|
|
// Initialize WBEM with the machine name.
|
|
// Deleted in either SetView or Destroy
|
|
m_pSource = new CWBEMDataSource(MachineName());
|
|
}
|
|
}
|
|
catch (CUserException *) {
|
|
CString strLocalConnect;
|
|
|
|
VERIFY(strLocalConnect.LoadString(IDS_LOCAL_CONNECT));
|
|
MessageBox((LPCTSTR)strLocalConnect);
|
|
|
|
try {
|
|
(*m_pstrMachineName) = _T("");
|
|
m_pSource = new CWBEMDataSource(NULL);
|
|
}
|
|
catch (CUserException *) {
|
|
m_bInitializedCD = false;
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
m_fViewUninitialized = TRUE;
|
|
InitializeView();
|
|
return S_OK;
|
|
}
|
|
|
|
/*
|
|
* DestroyInternal - Delete all of our internal pointers. This method of dealing
|
|
* with pointers is required because MMC never calls our object's destructor.
|
|
*
|
|
* History: a-jsari 12/30/97 Initial version
|
|
*/
|
|
void CSystemInfoScope::DestroyInternal()
|
|
{
|
|
// AFX_MANAGE_STATE(::AfxGetStaticModuleState());
|
|
|
|
if (pSource() && pSource()->GetType() == CDataSource::GATHERER)
|
|
{
|
|
CWBEMDataSource * pWBEMSource = reinterpret_cast<CWBEMDataSource *>(pSource());
|
|
if (pWBEMSource && pWBEMSource->m_pThreadRefresh)
|
|
pWBEMSource->m_pThreadRefresh->CancelRefresh(FALSE);
|
|
}
|
|
|
|
// If there is a find thread, it will take care of getting rid of the window.
|
|
// Otherwise, we must destroy it here. Fixes bug 395091.
|
|
|
|
if (m_pthdFind)
|
|
dynamic_cast<CFindThread *>(m_pthdFind)->RemoteQuit();
|
|
else
|
|
::DestroyWindow(m_hwndFind);
|
|
|
|
if (m_pSource) { delete m_pSource; m_pSource = NULL; }
|
|
if (m_prdSave) { delete m_prdSave; m_prdSave = NULL; }
|
|
if (m_prdOpen) { delete m_prdOpen; m_prdOpen = NULL; }
|
|
if (m_prdReport) { delete m_prdReport; m_prdReport = NULL; }
|
|
if (m_pstrMachineName) { delete m_pstrMachineName; m_pstrMachineName = NULL; }
|
|
if (m_pstrOverrideName) { delete m_pstrOverrideName; m_pstrOverrideName = NULL; }
|
|
if (m_pmapCategories) { delete m_pmapCategories; m_pmapCategories = NULL; }
|
|
if (m_pViewCABTool) { delete m_pViewCABTool; m_pViewCABTool = NULL; }
|
|
}
|
|
|
|
/*
|
|
* CreateComponent - Create the IComponent interface object (the CSystemInfo
|
|
* object in this framework) and attach myself (the IComponentData
|
|
* interface object) to it. Return the QueryInterfaced IComponent
|
|
* pointer in ppComponent.
|
|
*
|
|
* History: a-jsari 8/27/97 Initial version
|
|
*/
|
|
STDMETHODIMP CSystemInfoScope::CreateComponent(LPCOMPONENT *ppComponent)
|
|
{
|
|
ASSERT(ppComponent != NULL);
|
|
TRACE(_T("CSystemInfoScope::CreateComponent\n"));
|
|
|
|
#if 0
|
|
if (m_bInitializedCD == false) {
|
|
*ppComponent = NULL;
|
|
return S_OK;
|
|
}
|
|
#endif
|
|
|
|
CComObject<CSystemInfo> *pObject;
|
|
|
|
CComObject<CSystemInfo>::CreateInstance(&pObject);
|
|
ASSERT(pObject != NULL);
|
|
|
|
if(NULL == pObject)
|
|
return E_OUTOFMEMORY;
|
|
|
|
m_pLastSystemInfo = pObject;
|
|
|
|
//Store IComponentData
|
|
HRESULT hr;
|
|
hr = pObject->SetIComponentData(this);
|
|
ASSERT(hr == S_OK);
|
|
if (FAILED(hr)) {
|
|
return hr;
|
|
}
|
|
|
|
return pObject->QueryInterface(IID_IComponent, reinterpret_cast<void **>(ppComponent));
|
|
}
|
|
|
|
/*
|
|
* PreUIInit - Make any changes required just before the UI initializes.
|
|
*
|
|
* History: a-jsari 3/6/98 Initial version
|
|
*/
|
|
HRESULT CSystemInfoScope::PreUIInit()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (m_pSource == NULL) {
|
|
hr = InitializeSource();
|
|
} else {
|
|
hr = InitializeView();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
* PostUIInit - Do all initialization which can only occur after the result
|
|
* pane UI
|
|
*
|
|
* History: a-jsari 3/6/98 Initial version
|
|
*/
|
|
void CSystemInfoScope::PostUIInit()
|
|
{
|
|
if (!m_strDeferredLoad.IsEmpty() || !m_strDeferredMachine.IsEmpty())
|
|
{
|
|
// Instead of doing a "SetSource(m_pSource, FALSE)", which deletes the
|
|
// tree, all we need to do here is rename the root node to match the
|
|
// opened file. A non-empty m_strDeferredLoad indicates this is necessary.
|
|
// (Or a non empty deferred machine change.)
|
|
|
|
m_strDeferredLoad.Empty();
|
|
m_strDeferredMachine.Empty();
|
|
|
|
SCOPEDATAITEM sdiRoot;
|
|
CString strNodeName;
|
|
HSCOPEITEM hsiRoot;
|
|
HRESULT hr;
|
|
|
|
if (m_pmapCategories->ScopeFromView(NULL, hsiRoot))
|
|
{
|
|
::memset(&sdiRoot, 0, sizeof(sdiRoot));
|
|
|
|
sdiRoot.ID = hsiRoot;
|
|
sdiRoot.mask = SDI_STR;
|
|
hr = pScope()->GetItem(&sdiRoot);
|
|
ASSERT(SUCCEEDED(hr));
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
m_pSource->GetNodeName(strNodeName);
|
|
sdiRoot.displayname = T2OLE(const_cast<LPTSTR>((LPCTSTR)strNodeName));
|
|
hr = pScope()->SetItem(&sdiRoot);
|
|
ASSERT(SUCCEEDED(hr));
|
|
}
|
|
}
|
|
}
|
|
|
|
// This is the first point at which we can set UI values.
|
|
if (m_fViewUninitialized && m_fSelectCategory) {
|
|
m_fViewUninitialized = FALSE;
|
|
|
|
SetSource(m_pSource, FALSE);
|
|
}
|
|
if (m_pstrCategory != NULL && m_fSelectCategory) {
|
|
// Before the SelectItem call to prevent recursion.
|
|
m_fSelectCategory = FALSE;
|
|
SelectItem(*m_pstrCategory);
|
|
delete m_pstrCategory;
|
|
m_pstrCategory = NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Notify - Handle any MSInfo namespace node events posted by MMC.
|
|
*
|
|
* History: a-jsari 8/27/97 Initial version
|
|
*/
|
|
|
|
STDMETHODIMP CSystemInfoScope::Notify(LPDATAOBJECT pDataObject, MMC_NOTIFY_TYPE event, LPARAM arg, LPARAM param)
|
|
{
|
|
TRACE(_T("CSystemInfoScope::Notify (DataObject, %lx, %p, %p)\n"), event, arg, param);
|
|
HRESULT hr;
|
|
|
|
if (m_bInitializedCD == false)
|
|
return S_OK;
|
|
|
|
switch(event)
|
|
{
|
|
case MMCN_EXPAND:
|
|
if (m_pSaveUnknown)
|
|
{
|
|
m_pstrMachineName = new CString;
|
|
m_pstrOverrideName = new CString;
|
|
Initialize(m_pSaveUnknown);
|
|
m_pSaveUnknown = NULL;
|
|
}
|
|
|
|
hr = PreUIInit();
|
|
if (FAILED(hr)) break;
|
|
hr = OnExpand(pDataObject, arg, param);
|
|
PostUIInit();
|
|
break;
|
|
|
|
case MMCN_REMOVE_CHILDREN:
|
|
// Sometimes we make an internal call which causes this notification to be
|
|
// sent, but we don't want to process it the same way.
|
|
|
|
if (!m_fInternalDelete)
|
|
{
|
|
m_pSaveUnknown = m_pScope;
|
|
|
|
DestroyInternal();
|
|
SAFE_RELEASE(m_pScope);
|
|
SAFE_RELEASE(m_pConsole);
|
|
|
|
m_pScope = NULL;
|
|
m_pConsole = NULL;
|
|
m_pSource = NULL;
|
|
m_prdSave = NULL;
|
|
m_prdOpen = NULL;
|
|
m_prdReport = NULL;
|
|
m_pstrMachineName = NULL;
|
|
m_pstrOverrideName = NULL;
|
|
m_pmapCategories = NULL;
|
|
}
|
|
|
|
hr = S_OK;
|
|
break;
|
|
|
|
case MMCN_PROPERTY_CHANGE:
|
|
hr = OnProperties(param);
|
|
break;
|
|
|
|
case MMCN_EXPANDSYNC:
|
|
break;
|
|
|
|
default:
|
|
ASSERT(FALSE);
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
* Destroy - Release all of our Initialized pointers.
|
|
*
|
|
* History: a-jsari 8/27/97 Initial version
|
|
*/
|
|
STDMETHODIMP CSystemInfoScope::Destroy()
|
|
{
|
|
TRACE(L"CSystemInfoScope::Destroy\n");
|
|
|
|
if (m_pwConsole != NULL) {
|
|
m_pwConsole->Detach();
|
|
delete m_pwConsole;
|
|
}
|
|
|
|
#if FALSE
|
|
#ifdef _DEBUG
|
|
m_bDestroyedCD = true;
|
|
#endif
|
|
#if 0
|
|
if (m_bInitializedCD == FALSE) return S_OK;
|
|
#endif
|
|
|
|
DestroyInternal();
|
|
SAFE_RELEASE(m_pScope);
|
|
SAFE_RELEASE(m_pConsole);
|
|
#endif
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/*
|
|
* QueryDataObject - Return the DataObject referred to by the cookie
|
|
* and type.
|
|
*
|
|
* History: a-jsari 8/27/97 Initial version
|
|
*/
|
|
STDMETHODIMP CSystemInfoScope::QueryDataObject(MMC_COOKIE cookie, DATA_OBJECT_TYPES type,
|
|
LPDATAOBJECT *ppDataObject)
|
|
{
|
|
TRACE(_T("CSystemInfoScope::QueryDataObject (%lx, %x, DataObject)\n"), cookie, type);
|
|
|
|
return CDataObject::CreateDataObject(cookie, type, this, ppDataObject);
|
|
}
|
|
|
|
/*
|
|
* CompareObjects - Compare two objects to see if they are equivalent.
|
|
*
|
|
* History: a-jsari 8/27/97 Initial version
|
|
*/
|
|
STDMETHODIMP CSystemInfoScope::CompareObjects(LPDATAOBJECT lpDataObjectA, LPDATAOBJECT lpDataObjectB)
|
|
{
|
|
TRACE(_T("CSystemInfoScope::CompareObjects\n"));
|
|
return CDataObject::CompareObjects(lpDataObjectA, lpDataObjectB);
|
|
}
|
|
|
|
/*
|
|
* GetDisplayInfo - Returns display information for this node in the scope pane.
|
|
*
|
|
* History: a-jsari 8/27/97 Initial version
|
|
*/
|
|
STDMETHODIMP CSystemInfoScope::GetDisplayInfo(SCOPEDATAITEM *pScopeDataItem)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
#if 0
|
|
TRACE(_T("CSystemInfoScope::GetDisplayInfo\n"));
|
|
#endif
|
|
ASSERT(pScopeDataItem != NULL);
|
|
if (pScopeDataItem == NULL) return E_POINTER;
|
|
|
|
ASSERT(pScopeDataItem->mask & SDI_STR);
|
|
if (pScopeDataItem->mask & SDI_STR) {
|
|
CViewObject *pDataCategory = reinterpret_cast<CViewObject *>(pScopeDataItem->lParam);
|
|
pScopeDataItem->displayname = T2OLE(const_cast<LPTSTR>(pDataCategory->GetTextItem()));
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/*
|
|
* AddToMenu - Add an item to a menu. This method assumes that the calling
|
|
* function has called AFX_MANAGE_STATE(AfxGetStaticModuleState()) prior
|
|
* to calling this function.
|
|
*
|
|
* History: a-jsari 9/15/97 Initial version
|
|
*/
|
|
HRESULT CSystemInfoScope::AddToMenu(LPCONTEXTMENUCALLBACK lpCallback, long lNameResource,
|
|
long lStatusResource, long lCommandID, long lInsertionPoint, long fFlags)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
CONTEXTMENUITEM cmiMenuItem = { NULL, NULL, lCommandID,
|
|
lInsertionPoint, fFlags, 0L};
|
|
CString szResourceName;
|
|
CString szResourceStatus;
|
|
|
|
// FIX: Make these resources load only once.
|
|
VERIFY(szResourceName.LoadString(lNameResource));
|
|
VERIFY(szResourceStatus.LoadString(lStatusResource));
|
|
cmiMenuItem.strName = WSTR_FROM_CSTRING(szResourceName);
|
|
cmiMenuItem.strStatusBarText = WSTR_FROM_CSTRING(szResourceStatus);
|
|
HRESULT hr = lpCallback->AddItem(&cmiMenuItem);
|
|
ASSERT(hr == S_OK);
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
* AddMenuItems - Add the "Save Report" and "Save System Information" items to
|
|
* the context menu.
|
|
*
|
|
* History: a-jsari 9/15/97 Initial version
|
|
*/
|
|
extern BOOL fCABOpened;
|
|
|
|
STDMETHODIMP CSystemInfoScope::AddMenuItems(LPDATAOBJECT lpDataObject,
|
|
LPCONTEXTMENUCALLBACK lpCallback, long *pInsertionAllowed)
|
|
{
|
|
TRACE(_T("CSystemInfoScope::AddMenuItems\n"));
|
|
ASSERT(lpDataObject != NULL);
|
|
ASSERT(lpCallback != NULL);
|
|
ASSERT(pInsertionAllowed != NULL);
|
|
if (lpDataObject == NULL || lpCallback == NULL || pInsertionAllowed == NULL)
|
|
return E_POINTER;
|
|
|
|
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.
|
|
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
// CHECK: Will this ever work differently for multiselect?
|
|
|
|
do {
|
|
// Save Report and Save File are both task items and context items.
|
|
if (*pInsertionAllowed & CCM_INSERTIONALLOWED_TOP) {
|
|
hr = AddToTopMenu(lpCallback, IDS_SAVEREPORTMENUNAME, IDS_SAVEREPORTSTATUS, IDM_SAVEREPORT);
|
|
if (FAILED(hr)) break;
|
|
hr = AddToTopMenu(lpCallback, IDS_SAVEFILEMENUNAME, IDS_SAVEFILESTATUS, IDM_SAVEFILE);
|
|
if (FAILED(hr)) break;
|
|
hr = AddToTopMenu(lpCallback, IDS_FINDMENUNAME, IDS_FINDSTATUS, IDM_FIND);
|
|
if (FAILED(hr)) break;
|
|
}
|
|
|
|
if (*pInsertionAllowed & CCM_INSERTIONALLOWED_TASK) {
|
|
|
|
hr = AddToTaskMenu(lpCallback, IDS_FINDMENUNAME, IDS_FINDSTATUS, IDM_TASK_FIND);
|
|
if (FAILED(hr)) break;
|
|
|
|
// Don't add the Open File menu item for Extension snap-ins.
|
|
|
|
if (IsPrimaryImpl())
|
|
{
|
|
hr = AddToTaskMenu(lpCallback, IDS_OPENFILEMENUNAME, IDS_OPENFILESTATUS, IDM_TASK_OPENFILE);
|
|
if (FAILED(hr))
|
|
break;
|
|
|
|
CDataSource * pCurrentSource = pSource();
|
|
if (pCurrentSource && pCurrentSource->GetType() != CDataSource::GATHERER)
|
|
hr = AddToTaskMenu(lpCallback, IDS_CLOSEFILEMENUNAME, IDS_CLOSEFILEMENUSTATUS, IDM_TASK_CLOSE);
|
|
else
|
|
hr = AddToMenu(lpCallback, IDS_CLOSEFILEMENUNAME, IDS_CLOSEFILEMENUSTATUS, IDM_TASK_CLOSE, CCM_INSERTIONPOINTID_PRIMARY_TASK, MF_GRAYED);
|
|
|
|
if (FAILED(hr))
|
|
break;
|
|
}
|
|
|
|
hr = AddToTaskMenu(lpCallback, IDS_SAVEFILEMENUNAME, IDS_SAVEFILESTATUS, IDM_TASK_SAVEFILE);
|
|
if (FAILED(hr)) break;
|
|
hr = AddToTaskMenu(lpCallback, IDS_SAVEREPORTMENUNAME, IDS_SAVEREPORTSTATUS, IDM_TASK_SAVEREPORT);
|
|
if (FAILED(hr)) break;
|
|
|
|
// If a CAB file has been opened, add the view CAB contents menu item. Also
|
|
// take this opportunity to create the tool to view the CAB contents, if it
|
|
// has not already been created.
|
|
|
|
if (fCABOpened)
|
|
{
|
|
if (m_pViewCABTool == NULL)
|
|
m_pViewCABTool = new CCabTool(this);
|
|
|
|
if (m_pViewCABTool != NULL)
|
|
{
|
|
hr = AddToTaskMenu(lpCallback, IDS_CAB_NAME, IDS_CAB_DESCRIPTION, IDM_TASK_VIEWCAB);
|
|
if (FAILED(hr)) break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (*pInsertionAllowed & CCM_INSERTIONALLOWED_VIEW) {
|
|
hr = AddToViewMenu(lpCallback, IDS_ADVANCEDVIEWNAME, IDS_ADVANCEDSTATUS, IDM_VIEW_ADVANCED,
|
|
m_AdvancedFlags);
|
|
if (FAILED(hr)) break;
|
|
hr = AddToViewMenu(lpCallback, IDS_BASICVIEWNAME, IDS_BASICSTATUS, IDM_VIEW_BASIC, m_BasicFlags);
|
|
if (FAILED(hr)) break;
|
|
}
|
|
|
|
} while (FALSE);
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
* DisplayFileError - Show a message box with an error message taken from
|
|
* the exception thrown.
|
|
*
|
|
* History: a-jsari 2/13/98 Initial version
|
|
*/
|
|
static inline void DisplayError(HRESULT hr, const CString &strFileName)
|
|
{
|
|
AFX_MANAGE_STATE(::AfxGetStaticModuleState());
|
|
|
|
USES_CONVERSION;
|
|
CString strFileError, strTitle;
|
|
switch (hr) {
|
|
case STG_E_PATHNOTFOUND:
|
|
strFileError.Format(IDS_BAD_PATH, (LPCTSTR)strFileName);
|
|
break;
|
|
case STG_E_TOOMANYOPENFILES:
|
|
VERIFY(strFileError.LoadString(IDS_TOOMANYOPENFILES));
|
|
break;
|
|
case STG_E_ACCESSDENIED:
|
|
strFileError.Format(IDS_ACCESS_DENIED, (LPCTSTR)strFileName);
|
|
break;
|
|
case STG_E_SHAREVIOLATION:
|
|
strFileError.Format(IDS_SHARING_VIOLATION, (LPCTSTR)strFileName);
|
|
break;
|
|
case STG_E_WRITEFAULT:
|
|
VERIFY(strFileError.LoadString(IDS_HARDIO));
|
|
break;
|
|
case STG_E_MEDIUMFULL:
|
|
strFileError.Format(IDS_DISK_FULL, (LPCTSTR)strFileName);
|
|
break;
|
|
default:
|
|
VERIFY(strFileError.LoadString(IDS_UNKNOWN_FILE));
|
|
break;
|
|
}
|
|
strTitle.LoadString(IDS_DESCRIPTION);
|
|
::MessageBox( ::AfxGetMainWnd()->GetSafeHwnd(), strFileError, strTitle, MB_OK);
|
|
}
|
|
|
|
/*
|
|
* SaveReport - Create the save report save file dialog and save the selected file.
|
|
*
|
|
* History: a-jsari 12/8/97 Initial version
|
|
*/
|
|
void CSystemInfoScope::SaveReport()
|
|
{
|
|
if (m_prdReport->DoModal() == IDOK) {
|
|
CWaitCursor DoWaitCursor;
|
|
|
|
if (m_pLastSystemInfo)
|
|
m_pLastSystemInfo->SetStatusText(IDS_REFRESHING_MSG);
|
|
|
|
HRESULT hr = pSource()->ReportWrite(m_prdReport->GetPathName(), m_pfLast);
|
|
|
|
if (m_pLastSystemInfo)
|
|
m_pLastSystemInfo->SetStatusText(_T(""));
|
|
|
|
if (FAILED(hr)) {
|
|
::DisplayError(hr, m_prdReport->GetPathName());
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* SaveFile - Create the save file dialog and save the selected file.
|
|
*
|
|
* History: a-jsari 12/8/97 Initial version
|
|
*/
|
|
void CSystemInfoScope::SaveFile()
|
|
{
|
|
if (m_prdSave->DoModal() == IDOK)
|
|
{
|
|
CWaitCursor DoWaitCursor;
|
|
|
|
if (m_pLastSystemInfo)
|
|
m_pLastSystemInfo->SetStatusText(IDS_REFRESHING_MSG);
|
|
|
|
HRESULT hr = pSource()->SaveFile(m_prdSave->GetPathName());
|
|
|
|
if (m_pLastSystemInfo)
|
|
m_pLastSystemInfo->SetStatusText(_T(""));
|
|
|
|
if (FAILED(hr))
|
|
::DisplayError(hr, m_prdSave->GetPathName());
|
|
}
|
|
}
|
|
|
|
/*
|
|
* PrintReport - Create the print dialog and do the print.
|
|
*
|
|
* History: a-jsari 12/8/97 Initial version
|
|
*/
|
|
void CSystemInfoScope::PrintReport()
|
|
{
|
|
HWND hWindow;
|
|
|
|
ASSERT(m_pConsole != NULL);
|
|
HRESULT hr = m_pConsole->GetMainWindow(&hWindow);
|
|
ASSERT(hr == S_OK);
|
|
if (FAILED(hr))
|
|
return;
|
|
|
|
CMSInfoPrintDialog * prdPrint = new CMSInfoPrintDialog(hWindow);
|
|
ASSERT(prdPrint != NULL);
|
|
if (prdPrint == NULL)
|
|
::AfxThrowMemoryException();
|
|
|
|
prdPrint->m_pd.nToPage = prdPrint->m_pd.nFromPage = prdPrint->m_pd.nMinPage = 1;
|
|
prdPrint->m_pd.nMaxPage = 1000;
|
|
|
|
if (prdPrint->DoModal() == IDOK)
|
|
{
|
|
CWaitCursor DoWaitCursor;
|
|
|
|
pSource()->RefreshPrintData(prdPrint, m_pfLast);
|
|
pSource()->PrintReport(prdPrint, m_pfLast);
|
|
}
|
|
|
|
delete prdPrint;
|
|
}
|
|
|
|
/*
|
|
* DoFind - Display the Find dialog
|
|
*
|
|
* History: a-jsari 12/8/97 Initial version.
|
|
*/
|
|
void CSystemInfoScope::DoFind()
|
|
{
|
|
const UINT STACK_SIZE_PARENT = 0;
|
|
// const DWORD FLAGS_IMMEDIATE_START = 0;
|
|
const LPSECURITY_ATTRIBUTES NO_ATTRIBUTES = NULL;
|
|
|
|
if (m_pthdFind == NULL)
|
|
{
|
|
m_pthdFind = dynamic_cast<CFindThread *>(::AfxBeginThread(RUNTIME_CLASS(CFindThread),
|
|
THREAD_PRIORITY_NORMAL, STACK_SIZE_PARENT, CREATE_SUSPENDED, NO_ATTRIBUTES));
|
|
m_pthdFind->SetScope(this);
|
|
|
|
HWND hwndMMC;
|
|
if (pConsole() == NULL || FAILED(pConsole()->GetMainWindow(&hwndMMC)))
|
|
hwndMMC = NULL;
|
|
|
|
m_pthdFind->SetParent(m_hwndFind, hwndMMC);
|
|
m_pthdFind->ResumeThread();
|
|
}
|
|
else
|
|
m_pthdFind->Activate();
|
|
}
|
|
|
|
/*
|
|
* ExecuteFind - This function is actually called via a hook into
|
|
* MMC's main window's WindowProc, by a message posted by
|
|
* CFindThread's Find button function..
|
|
*
|
|
* The Refresh and Find functions may be interrupted by the Find
|
|
* window's UI thread, and m_pthdFind may be deleted while this
|
|
* function is executing.
|
|
*
|
|
* Instead of taking parameters, this function calls back to our
|
|
* existing find thread to get its search string and last
|
|
* search string. This simplifies the PostMessage call, but
|
|
* would need to change if we ever decide to have multiple
|
|
* find windows per IComponentData...unlikely.
|
|
*
|
|
* History: a-jsari 1/22/98 Initial version.
|
|
*/
|
|
void CSystemInfoScope::ExecuteFind(long lFindState)
|
|
{
|
|
AFX_MANAGE_STATE(::AfxGetStaticModuleState());
|
|
|
|
CWaitCursor DoWaitCursor; // Display the hourglass
|
|
|
|
CString strFindData; // Our current search string.
|
|
// The restricted context within which our search occurs.
|
|
static CFolder *pfContext;
|
|
|
|
// Check m_pthdFind since there's a remote possibility of thread pointer
|
|
// invalidation (by the user closing the Find dialog while the
|
|
// find is running).
|
|
if (m_pthdFind == NULL)
|
|
return;
|
|
strFindData = m_pthdFind->FindString();
|
|
|
|
CDataSource *pdsSearch = pSource();
|
|
do {
|
|
if ((lFindState & CDataSource::FIND_OPTION_REPEAT_SEARCH) == 0)
|
|
{
|
|
// Only refresh the first time we search for a given string.
|
|
// Also, only refresh if we are searching more than category names.
|
|
|
|
BOOL fRefreshResult = TRUE;
|
|
if ((lFindState & CDataSource::FIND_OPTION_CATEGORY_ONLY) == 0)
|
|
{
|
|
// If we are only searching in one category, only refresh that
|
|
// category.
|
|
|
|
if ((lFindState & CDataSource::FIND_OPTION_ONE_CATEGORY) != 0)
|
|
{
|
|
if (pdsSearch->GetType() == CDataSource::GATHERER)
|
|
{
|
|
CWBEMDataSource * pWBEMSource = reinterpret_cast<CWBEMDataSource *>(pSource());
|
|
if (pWBEMSource && pWBEMSource->m_pThreadRefresh)
|
|
pWBEMSource->m_pThreadRefresh->RefreshFolder(m_pfLast, TRUE, FALSE);
|
|
}
|
|
}
|
|
else
|
|
fRefreshResult = pdsSearch->Refresh(TRUE);
|
|
}
|
|
|
|
if (!fRefreshResult)
|
|
{
|
|
if (m_pthdFind != NULL)
|
|
m_pthdFind->ResetSearch();
|
|
break;
|
|
}
|
|
|
|
// Set our context the first time we start a restricted search.
|
|
if ((lFindState & CDataSource::FIND_OPTION_ONE_CATEGORY) != 0)
|
|
pfContext = m_pfLast;
|
|
else
|
|
pfContext = NULL;
|
|
}
|
|
else if ((lFindState & CDataSource::FIND_OPTION_ONE_CATEGORY) != 0)
|
|
{
|
|
// If we set a restricted search inside an already started search
|
|
// restrict our context.
|
|
// CHECK: iDepth???
|
|
if (pfContext == NULL)
|
|
pfContext = m_pfLast;
|
|
}
|
|
if (pdsSearch->Find(strFindData, lFindState) == FALSE) {
|
|
// Failed find means no match or halted execution.
|
|
|
|
// If the user stoppped the find, no message necessary.
|
|
if (!pdsSearch->FindStopped()) {
|
|
|
|
CString strError; // Error display
|
|
CString strTitle; // Error title.
|
|
int nReturn;
|
|
|
|
// Test the thread because the find window might vanish in the middle
|
|
// of our find operation.
|
|
if (m_pthdFind != NULL)
|
|
m_pthdFind->FindComplete();
|
|
if (m_pthdFind != NULL)
|
|
m_pthdFind->ResetSearch();
|
|
|
|
// If we're repeating a search, no more matches otherwise, not found.
|
|
if ((lFindState & CDataSource::FIND_OPTION_REPEAT_SEARCH) == 0) {
|
|
strError.Format(IDS_DATANOTFOUND, (LPCTSTR)strFindData);
|
|
} else
|
|
strError.Format(IDS_NOMOREMATCHES, (LPCTSTR)strFindData);
|
|
VERIFY(strTitle.LoadString(IDS_FIND_TITLE));
|
|
pConsole()->MessageBox((LPCTSTR)strError, (LPCTSTR)strTitle,
|
|
MB_TOPMOST|MB_SETFOREGROUND, &nReturn);
|
|
|
|
// If we are restricting our search, reset the selected folder to the
|
|
// beginning of our restricted search.
|
|
if ((lFindState & CDataSource::FIND_OPTION_ONE_CATEGORY) != 0)
|
|
SetSelectedFolder(pfContext);
|
|
// We've already completed the find, don't drop out.
|
|
return;
|
|
}
|
|
} else {
|
|
SelectItem(pdsSearch->m_strPath, pdsSearch->m_iLine);
|
|
}
|
|
} while (FALSE);
|
|
// The find window might vanish in the middle of our find operation.
|
|
if (m_pthdFind != NULL)
|
|
m_pthdFind->FindComplete();
|
|
}
|
|
|
|
/*
|
|
* MainThreadStopFind - Stops a find operation running in an alternate thread.
|
|
*
|
|
* History: a-jsari 1/22/98 Initial version.
|
|
*/
|
|
void CSystemInfoScope::StopFind()
|
|
{
|
|
// This will be called by an alternate UI thread.
|
|
pSource()->StopSearch();
|
|
}
|
|
|
|
/*
|
|
* Refresh - Refresh the data, and redraw the current node if applicable.
|
|
*
|
|
* History: a-jsari 2/25/98 Initial version
|
|
*/
|
|
void CSystemInfoScope::Refresh(CFolder * pfSelected, CSystemInfo * pSystemInfo)
|
|
{
|
|
CWaitCursor DoWaitCursor;
|
|
|
|
if (pfSelected && pSource() && pSource()->GetType() == CDataSource::GATHERER)
|
|
{
|
|
CWBEMDataSource * pWBEMSource = reinterpret_cast<CWBEMDataSource *>(pSource());
|
|
if (pWBEMSource && pWBEMSource->m_pThreadRefresh)
|
|
{
|
|
if (pSystemInfo)
|
|
pWBEMSource->m_pThreadRefresh->RefreshFolderAsync(pfSelected, pSystemInfo, TRUE, FALSE);
|
|
else
|
|
pWBEMSource->m_pThreadRefresh->RefreshFolder(pfSelected, TRUE, FALSE);
|
|
}
|
|
}
|
|
else
|
|
pSource()->Refresh();
|
|
|
|
if (pfSelected != NULL)
|
|
{
|
|
CString strName;
|
|
int nLine = 0;
|
|
pfSelected->InternalName(strName);
|
|
SelectItem(strName, nLine);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* CloseFindWindow - Function to be called when the find window closes.
|
|
*
|
|
* History: a-jsari 1/22/97 Initial version.
|
|
*/
|
|
void CSystemInfoScope::CloseFindWindow()
|
|
{
|
|
// Don't delete m_pthdFind; it will delete itself.
|
|
m_pthdFind = NULL;
|
|
}
|
|
|
|
/*
|
|
* OpenFile - Create the open file file dialog and open the resultant file
|
|
*
|
|
* History: a-jsari 12/8/97 Initial version
|
|
*/
|
|
void CSystemInfoScope::OpenFile()
|
|
{
|
|
const long DONT_USE_LAST_FOLDER = 1;
|
|
|
|
if (m_prdOpen->DoModal() == IDOK)
|
|
{
|
|
CWaitCursor DoWaitCursor;
|
|
CDataSource *pSource = NULL;
|
|
|
|
try
|
|
{
|
|
pSource = CBufferDataSource::CreateDataSourceFromFile(m_prdOpen->GetPathName());
|
|
}
|
|
catch (...)
|
|
{
|
|
delete pSource;
|
|
pSource = NULL;
|
|
}
|
|
|
|
if (pSource != NULL)
|
|
{
|
|
SetSource(pSource);
|
|
InitializeView();
|
|
}
|
|
|
|
pConsole()->UpdateAllViews(0, DONT_USE_LAST_FOLDER, 0L);
|
|
|
|
// Reset the selected folder (it's no longer valid with the new tree).
|
|
|
|
SetSelectedFolder(NULL);
|
|
|
|
HSCOPEITEM hsiNode = NULL;
|
|
if (m_pmapCategories && m_pmapCategories->ScopeFromView(NULL, hsiNode))
|
|
pConsole()->SelectScopeItem(hsiNode);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Close the currently opened file.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CSystemInfoScope::CloseFile()
|
|
{
|
|
CDataSource * pDataSource = pSource();
|
|
if (pDataSource && pDataSource->GetType() == CDataSource::GATHERER)
|
|
return;
|
|
|
|
try
|
|
{
|
|
(*m_pstrMachineName) = _T("");
|
|
pDataSource = new CWBEMDataSource(NULL);
|
|
}
|
|
catch (CUserException *)
|
|
{
|
|
m_bInitializedCD = false;
|
|
return;
|
|
}
|
|
|
|
if (pDataSource != NULL)
|
|
{
|
|
SetSource(pDataSource);
|
|
InitializeView();
|
|
}
|
|
|
|
const long DONT_USE_LAST_FOLDER = 1;
|
|
pConsole()->UpdateAllViews(0, DONT_USE_LAST_FOLDER, 0L);
|
|
|
|
// Reset the selected folder (it's no longer valid with the new tree).
|
|
|
|
SetSelectedFolder(NULL);
|
|
}
|
|
|
|
/*
|
|
* Command - Call the function represented by nCommandID.
|
|
*
|
|
* History: a-jsari 9/15/97 Initial version
|
|
*
|
|
* Note: This function currently takes no notice of the context represented
|
|
* by pdoContext.
|
|
*/
|
|
STDMETHODIMP CSystemInfoScope::Command(long nCommandID, LPDATAOBJECT)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
TRACE(_T("CSystemInfoScope::Command(%lx)\n"), nCommandID);
|
|
AFX_MANAGE_STATE(::AfxGetStaticModuleState());
|
|
|
|
// For any of these commands, we want to cancel an async category refresh
|
|
// is there is one in progress.
|
|
|
|
if (pSource() && pSource()->GetType() == CDataSource::GATHERER)
|
|
{
|
|
CWBEMDataSource * pWBEMSource = reinterpret_cast<CWBEMDataSource *>(pSource());
|
|
if (pWBEMSource && pWBEMSource->m_pThreadRefresh)
|
|
{
|
|
CWaitCursor waitcursor;
|
|
pWBEMSource->m_pThreadRefresh->WaitForRefresh();
|
|
}
|
|
}
|
|
|
|
try {
|
|
switch (nCommandID) {
|
|
case IDM_SAVEREPORT:
|
|
case IDM_TASK_SAVEREPORT:
|
|
if (msiLog.IsLogging())
|
|
msiLog.WriteLog(CMSInfoLog::MENU, _T("MENU \"Save As Text\"\r\n"));
|
|
SaveReport();
|
|
break;
|
|
|
|
case IDM_SAVEFILE:
|
|
case IDM_TASK_SAVEFILE:
|
|
if (msiLog.IsLogging())
|
|
msiLog.WriteLog(CMSInfoLog::MENU, _T("MENU \"Save NFO\"\r\n"));
|
|
SaveFile();
|
|
break;
|
|
|
|
case IDM_TASK_FIND:
|
|
case IDM_FIND:
|
|
if (msiLog.IsLogging())
|
|
msiLog.WriteLog(CMSInfoLog::MENU, _T("MENU \"Find\"\r\n"));
|
|
DoFind();
|
|
break;
|
|
|
|
case IDM_TASK_OPENFILE:
|
|
if (msiLog.IsLogging())
|
|
msiLog.WriteLog(CMSInfoLog::MENU, _T("MENU \"Open NFO\"\r\n"));
|
|
OpenFile();
|
|
break;
|
|
|
|
case IDM_TASK_VIEWCAB:
|
|
if (msiLog.IsLogging())
|
|
msiLog.WriteLog(CMSInfoLog::MENU, _T("MENU \"View CAB\"\r\n"));
|
|
if (m_pViewCABTool)
|
|
m_pViewCABTool->RunTool();
|
|
break;
|
|
|
|
case IDM_VIEW_ADVANCED:
|
|
if (msiLog.IsLogging())
|
|
msiLog.WriteLog(CMSInfoLog::MENU, _T("MENU \"Set View ADVANCED\"\r\n"));
|
|
SetView(ADVANCED, TRUE);
|
|
break;
|
|
|
|
case IDM_VIEW_BASIC:
|
|
if (msiLog.IsLogging())
|
|
msiLog.WriteLog(CMSInfoLog::MENU, _T("MENU \"Set View BASIC\"\r\n"));
|
|
SetView(BASIC, TRUE);
|
|
break;
|
|
|
|
case IDM_TASK_CLOSE:
|
|
if (msiLog.IsLogging())
|
|
msiLog.WriteLog(CMSInfoLog::MENU, _T("MENU \"Close NFO\"\r\n"));
|
|
CloseFile();
|
|
break;
|
|
|
|
case ~0:
|
|
// We get this result when we back arrow on the taskpad.
|
|
break;
|
|
|
|
default:
|
|
ASSERT(FALSE);
|
|
break;
|
|
}
|
|
}
|
|
catch (...) {
|
|
ASSERT(FALSE);
|
|
hr = HRESULT_FROM_WIN32(::GetLastError());
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
* CreatePropertyPages - Create an instance of our property pages and attach them
|
|
* to MMC's property sheet.
|
|
*
|
|
* History: a-jsari 9/17/97 Initial version
|
|
*/
|
|
STDMETHODIMP CSystemInfoScope::CreatePropertyPages(LPPROPERTYSHEETCALLBACK pProvider,
|
|
LONG_PTR handle, LPDATAOBJECT pDataObject)
|
|
{
|
|
ASSERT(pProvider != NULL);
|
|
ASSERT(pDataObject != NULL);
|
|
|
|
TRACE(_T("CSystemInfoScope::CreatePropertyPages\n"));
|
|
if (pProvider == NULL || pDataObject == NULL) return E_INVALIDARG;
|
|
|
|
// Special code goes here if we're used as an extension.
|
|
HRESULT hResult;
|
|
|
|
do {
|
|
CChooseMachinePropPage *pPropChoose;
|
|
HPROPSHEETPAGE hGeneralPage;
|
|
BOOL fOverride;
|
|
|
|
AFX_MANAGE_STATE(::AfxGetStaticModuleState());
|
|
|
|
// Deleted automatically.
|
|
pPropChoose = new CChooseMachinePropPage(IDD_CHOOSER_CHOOSE_MACHINE);
|
|
|
|
if (pPropChoose == NULL) {
|
|
::MMCFreeNotifyHandle(handle);
|
|
::AfxThrowMemoryException();
|
|
}
|
|
|
|
// Save the current machine name, in case the one selected in the property
|
|
// page is not any good.
|
|
|
|
m_strLastMachineName = *m_pstrMachineName;
|
|
|
|
pPropChoose->SetHandle(handle);
|
|
pPropChoose->SetOutputBuffers(m_pstrMachineName, &fOverride, m_pstrOverrideName);
|
|
|
|
hGeneralPage = ::CreatePropertySheetPage(&pPropChoose->m_psp);
|
|
if (!hGeneralPage) {
|
|
hResult = E_FAIL;
|
|
break;
|
|
}
|
|
|
|
hResult = pProvider->AddPage(hGeneralPage);
|
|
ASSERT(SUCCEEDED(hResult));
|
|
|
|
} while (FALSE);
|
|
|
|
if (FAILED(hResult)) return hResult;
|
|
return S_OK;
|
|
}
|
|
|
|
/*
|
|
* QueryPagesFor - Return S_OK, informing MMC that we have property sheets available.
|
|
*
|
|
* History: a-jsari 9/17/97 Initial version
|
|
*/
|
|
STDMETHODIMP CSystemInfoScope::QueryPagesFor(LPDATAOBJECT pDataObject)
|
|
{
|
|
TRACE(_T("CSystemInfoScope::QueryPagesFor\n"));
|
|
ASSERT(pDataObject != NULL);
|
|
|
|
if (pDataObject == NULL) return E_POINTER;
|
|
|
|
// If we are being loaded as an extension, don't display property pages.
|
|
// We do this because the base snap-in is responsible for the connected
|
|
// machine, not us.
|
|
if (!IsPrimaryImpl()) return S_FALSE;
|
|
|
|
#if 0
|
|
// Not sure why I did this.
|
|
// If the machine name is already set, don't display the property page.
|
|
if (m_pstrMachineName && m_pstrMachineName->GetLength() > 0) return S_FALSE;
|
|
#endif
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/*
|
|
* Load - Load our state from the stream provided.
|
|
*
|
|
* History: a-jsari 11/5/97 Initial version
|
|
*/
|
|
STDMETHODIMP CSystemInfoScope::Load(IStream *pStm)
|
|
{
|
|
CDataSource *pSource;
|
|
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
TRACE(_T("CSystemInfoScope::Load\n"));
|
|
ASSERT(pStm != NULL);
|
|
if (pStm == NULL) return E_POINTER;
|
|
ClearDirty();
|
|
// If our command-line parameters have specified a source, don't replace it.
|
|
|
|
if (!m_fViewUninitialized)
|
|
{
|
|
if (m_strDeferredLoad.IsEmpty())
|
|
pSource = CDataSource::CreateFromIStream(pStm);
|
|
else
|
|
{
|
|
pSource = CBufferDataSource::CreateDataSourceFromFile(m_strDeferredLoad);
|
|
if (pSource)
|
|
{
|
|
const long DONT_USE_LAST_FOLDER = 1;
|
|
SetSource(pSource, TRUE);
|
|
pConsole()->UpdateAllViews(0, DONT_USE_LAST_FOLDER, 0L);
|
|
SetSelectedFolder(NULL);
|
|
return S_OK;
|
|
}
|
|
else
|
|
m_strDeferredLoad.Empty();
|
|
}
|
|
|
|
if (pSource == NULL)
|
|
InitializeSource();
|
|
else
|
|
{
|
|
if (!m_strDeferredCategories.IsEmpty())
|
|
pSource->SetCategories(m_strDeferredCategories);
|
|
|
|
SetSource(pSource, TRUE);
|
|
|
|
if (!m_strDeferredMachine.IsEmpty())
|
|
SetMachine(m_strDeferredMachine);
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
/*
|
|
* Save - Save our state to the stream provided.
|
|
*
|
|
* History: a-jsari 11/5/97 Initial version
|
|
*/
|
|
STDMETHODIMP CSystemInfoScope::Save(IStream *pStm, BOOL fClearDirty)
|
|
{
|
|
TRACE(_T("CSystemInfoScope::Save\n"));
|
|
ASSERT(pStm != NULL);
|
|
if (pStm == NULL) return E_POINTER;
|
|
|
|
if (fClearDirty)
|
|
ClearDirty();
|
|
|
|
HRESULT hResult = S_OK;
|
|
|
|
// If there is a source, let it save its state to the stream. Otherwise,
|
|
// save the state for the default source (GATHERER with no machine name).
|
|
|
|
if (m_pSource)
|
|
hResult = m_pSource->Save(pStm);
|
|
else
|
|
{
|
|
unsigned wValue;
|
|
ULONG cWrite;
|
|
|
|
wValue = CDataSource::GATHERER;
|
|
hResult = pStm->Write(&wValue, sizeof(wValue), &cWrite);
|
|
if (SUCCEEDED(hResult))
|
|
{
|
|
wValue = 0;
|
|
hResult = pStm->Write(&wValue, sizeof(wValue), &cWrite);
|
|
}
|
|
}
|
|
|
|
return hResult;
|
|
}
|
|
|
|
/*
|
|
* IsDirty - Return our Dirty status, to see if a save would be beneficial.
|
|
*
|
|
* History: a-jsari 11/5/97 Initial version
|
|
*/
|
|
STDMETHODIMP CSystemInfoScope::IsDirty()
|
|
{
|
|
TRACE(_T("CSystemInfoScope::IsDirty\n"));
|
|
return ObjectIsDirty() ? S_OK : S_FALSE;
|
|
}
|
|
|
|
/*
|
|
* GetClassID - Return our Component Object Class ID.
|
|
*
|
|
* History: a-jsari 11/5/97 Initial version
|
|
*/
|
|
STDMETHODIMP CSystemInfoScope::GetClassID(CLSID *pClassID)
|
|
{
|
|
TRACE(_T("CSystemInfoScope::GetClassID\n"));
|
|
ASSERT(pClassID != NULL);
|
|
if (pClassID == NULL) return E_POINTER;
|
|
*pClassID = GetCoClassID();
|
|
return S_OK;
|
|
}
|
|
|
|
/*
|
|
* GetSizeMax - Return the maximum size consumed in a stream by our
|
|
* persistance.
|
|
*
|
|
* History: a-jsari 11/5/97 Initial version
|
|
*/
|
|
STDMETHODIMP CSystemInfoScope::GetSizeMax(ULARGE_INTEGER *pcbSize)
|
|
{
|
|
TRACE(_T("CSystemInfoScope::GetSizeMax\n"));
|
|
ASSERT(pcbSize != NULL);
|
|
if (pcbSize == NULL) return E_POINTER;
|
|
pcbSize->LowPart = 2 * sizeof(unsigned) + MAX_PATH;
|
|
pcbSize->HighPart = 0;
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Implementation of GetHelpTopic, which supplies the location of our help
|
|
// file to MMC for merging into the combined help. Adapted from example in
|
|
// the MMC help file.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CSystemInfoScope::GetHelpTopic(LPOLESTR* lpCompiledHelpFile)
|
|
{
|
|
if (lpCompiledHelpFile == NULL)
|
|
return E_POINTER;
|
|
|
|
// Get the name of our help file, and prepend the help directory.
|
|
// Actually, although the MMC documentation said that a full path is
|
|
// required, we can just put the file name, since it is being stored in
|
|
// the system help directory (HTMLHelp will find it there).
|
|
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
CString strHelp;
|
|
strHelp.LoadString(IDS_MSINFO_HELP_FILE);
|
|
|
|
// NOTE: It looks like HTMLHelp has been changed, and will not locate
|
|
// the help file in the standard help directory. So we'll need to get
|
|
// the full path to the help file. (JCM, 7/1/98)
|
|
|
|
TCHAR szFilePath[MAX_PATH];
|
|
DWORD dwCnt = ExpandEnvironmentStrings(CString(_T("%WINDIR%\\help\\")) + strHelp, szFilePath, MAX_PATH);
|
|
ASSERT(dwCnt != 0);
|
|
if (dwCnt != 0) strHelp = szFilePath;
|
|
|
|
// Allocate the string to hold the help file path. MMC will be responsible
|
|
// for deallocating this buffer later.
|
|
|
|
*lpCompiledHelpFile = reinterpret_cast<LPOLESTR>(CoTaskMemAlloc((strHelp.GetLength() + 1)* sizeof(wchar_t)));
|
|
if (*lpCompiledHelpFile == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
// Copy from the path string to the buffer and return success.
|
|
|
|
USES_CONVERSION;
|
|
wcscpy(*lpCompiledHelpFile, T2OLE((LPTSTR)(LPCTSTR)strHelp));
|
|
return S_OK;
|
|
}
|
|
|
|
/*
|
|
* SetMachine - Set our internal machine name.
|
|
*
|
|
* History: a-jsari 1/16/98 Initial version.
|
|
*/
|
|
BOOL CSystemInfoScope::SetMachine(const CString &strMachine)
|
|
{
|
|
BOOL fReturn = FALSE;
|
|
|
|
*m_pstrMachineName = strMachine;
|
|
ASSERT(pSource() != NULL);
|
|
if (pSource() && pSource()->GetType() == CDataSource::GATHERER)
|
|
{
|
|
// Changing the machine name is only meaningful if we are connected to a WBEM
|
|
// data source.
|
|
|
|
CWBEMDataSource * pWBEMSource = reinterpret_cast<CWBEMDataSource *>(pSource());
|
|
|
|
fReturn = pWBEMSource->SetMachineName(*m_pstrMachineName);
|
|
if (fReturn)
|
|
{
|
|
// If we succeeded, reset the root node text. Also, there's a hack in place
|
|
// to keep SetSource from running twice during initialization. Which requires
|
|
// another hack here to make it run - change the flag it uses to keep track
|
|
// of the last call so that this call is different. I hate this.
|
|
|
|
m_fSetSourcePreLaunch = TRUE;
|
|
SetSource(pSource(), FALSE);
|
|
}
|
|
else {
|
|
}
|
|
}
|
|
return fReturn;
|
|
}
|
|
|
|
/*
|
|
* SetView - Set the view on the data.
|
|
*
|
|
* History: a-jsari 12/3/97 Initial version.
|
|
*/
|
|
void CSystemInfoScope::SetView(enum DataComplexity Complexity, BOOL fViewInitialized)
|
|
{
|
|
CDataSource *pDataSource = pSource();
|
|
switch (Complexity) {
|
|
case BASIC:
|
|
m_BasicFlags = MF_CHECKED;
|
|
m_AdvancedFlags = 0L;
|
|
break;
|
|
case ADVANCED:
|
|
m_BasicFlags = 0L;
|
|
m_AdvancedFlags = MF_CHECKED;
|
|
break;
|
|
}
|
|
if (pDataSource != NULL)
|
|
VERIFY(pDataSource->SetDataComplexity(Complexity));
|
|
if (fViewInitialized) {
|
|
CRegKey crkView;
|
|
long lResult;
|
|
|
|
pConsole()->UpdateAllViews(NULL, 0, 0);
|
|
lResult = crkView.Create(HKEY_CURRENT_USER, cszViewKey);
|
|
if (lResult != ERROR_SUCCESS) return;
|
|
switch (Complexity) {
|
|
case ADVANCED:
|
|
lResult = crkView.SetValue(cszAdvancedValue, cszViewValue);
|
|
break;
|
|
case BASIC:
|
|
lResult = crkView.SetValue(cszBasicValue, cszViewValue);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* SetSource - Remove the old data source, and replace it with a new one.
|
|
*
|
|
* History: a-jsari 9/25/97 Initial version.
|
|
*/
|
|
|
|
void CSystemInfoScope::SetSource(CDataSource *pNewSource, BOOL fPreLaunch)
|
|
{
|
|
HSCOPEITEM hsiRoot;
|
|
HRESULT hr;
|
|
BOOL fUIOK = FALSE;
|
|
|
|
// We have some variables in this class to make sure that SetSource
|
|
// isn't called twice during initialization with the same parameters.
|
|
|
|
if (m_pSetSourceSource == pNewSource && m_fSetSourcePreLaunch == fPreLaunch)
|
|
return;
|
|
m_pSetSourceSource = pNewSource;
|
|
m_fSetSourcePreLaunch = fPreLaunch;
|
|
|
|
// If fPreLaunch is TRUE, we have not yet created our UI items.
|
|
if (fPreLaunch == FALSE) {
|
|
if (m_pmapCategories == NULL)
|
|
m_pmapCategories = new CScopeItemMap;
|
|
|
|
// Select the root node so we can remove all its children.
|
|
if (m_pmapCategories && !m_pmapCategories->ScopeFromView(NULL, hsiRoot))
|
|
return;
|
|
hr = pConsole()->SelectScopeItem(hsiRoot);
|
|
ASSERT(SUCCEEDED(hr));
|
|
if (FAILED(hr)) return;
|
|
|
|
// Before we delete the item, we want to make sure that it's actually
|
|
// been added. Try a call to GetItem to make sure it's there.
|
|
|
|
SCOPEDATAITEM item; item.mask = SDI_CHILDREN; item.ID = hsiRoot;
|
|
fUIOK = SUCCEEDED(pScope()->GetItem(&item));
|
|
|
|
if (fUIOK)
|
|
{
|
|
m_fInternalDelete = TRUE;
|
|
hr = pScope()->DeleteItem(hsiRoot, FALSE);
|
|
m_fInternalDelete = FALSE;
|
|
|
|
if (pSource() && pSource()->GetType() == CDataSource::GATHERER)
|
|
((CWBEMDataSource *) pSource())->ResetCategoryRefresh();
|
|
|
|
ASSERT(SUCCEEDED(hr));
|
|
if (FAILED(hr)) return;
|
|
|
|
if (m_pSaveUnknown)
|
|
{
|
|
m_pstrMachineName = new CString;
|
|
m_pstrOverrideName = new CString;
|
|
Initialize(m_pSaveUnknown);
|
|
m_pSaveUnknown = NULL;
|
|
}
|
|
}
|
|
|
|
// Remove our memory of data items.
|
|
|
|
m_pmapCategories->Clear();
|
|
}
|
|
// Don't delete our pointer if we are resetting the same pointer.
|
|
if (m_pSource != pNewSource) {
|
|
if (!m_pSource)
|
|
m_pSource = pNewSource;
|
|
else {
|
|
DataComplexity Complexity;
|
|
Complexity = m_pSource->m_Complexity;
|
|
|
|
delete m_pSource;
|
|
m_pSource = pNewSource;
|
|
m_pSource->SetDataComplexity(Complexity);
|
|
}
|
|
}
|
|
if (fPreLaunch == FALSE) {
|
|
CFolder *pFolder;
|
|
SCOPEDATAITEM sdiRoot;
|
|
CString strNodeName;
|
|
|
|
USES_CONVERSION;
|
|
::memset(&sdiRoot, 0, sizeof(sdiRoot));
|
|
// Identify the node.
|
|
sdiRoot.ID = hsiRoot;
|
|
sdiRoot.mask = SDI_STR;
|
|
m_pSource->GetNodeName(strNodeName);
|
|
sdiRoot.displayname = T2OLE(const_cast<LPTSTR>((LPCTSTR)strNodeName));
|
|
hr = pScope()->SetItem(&sdiRoot);
|
|
ASSERT(SUCCEEDED(hr));
|
|
hr = AddRoot(hsiRoot, &pFolder);
|
|
ASSERT(SUCCEEDED(hr));
|
|
if (FAILED(hr)) return;
|
|
|
|
if (fUIOK)
|
|
{
|
|
hr = ScopeEnumerate(hsiRoot, pFolder);
|
|
ASSERT(SUCCEEDED(hr));
|
|
if (FAILED(hr)) return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* AddRoot - Insert a CCategoryObject of the root folder into our Category map.
|
|
*
|
|
* History: a-jsari 11/20/97 Initial version
|
|
*/
|
|
HRESULT CSystemInfoScope::AddRoot(HSCOPEITEM hsiRoot, CFolder **ppFolder)
|
|
{
|
|
ASSERT(ppFolder != NULL);
|
|
(*ppFolder) = pRootCategory();
|
|
ASSERT(*ppFolder != NULL);
|
|
if (*ppFolder == NULL) return E_FAIL;
|
|
// This object gets deleted in the mapCategories destructor
|
|
CViewObject *pvoData = new CCategoryObject(*ppFolder);
|
|
if (pvoData == NULL) ::AfxThrowMemoryException();
|
|
m_pmapCategories->InsertRoot(pvoData, hsiRoot);
|
|
return S_OK;
|
|
}
|
|
|
|
/*
|
|
* GetNamedChildFolder - Update strCategory to add the next backslash-
|
|
* delimited path element from strPath.
|
|
*
|
|
* History: a-jsari 12/17/97 Initial version
|
|
*/
|
|
static inline void GetNamedChildFolder(
|
|
CString &strCategory,
|
|
const CString &strPath)
|
|
{
|
|
int iString;
|
|
CString strSubCategory;
|
|
CString strName;
|
|
|
|
// Remove the Category prefix from the path
|
|
iString = strPath.Find(strCategory);
|
|
ASSERT(iString == 0);
|
|
strSubCategory = strPath.Mid(iString + strCategory.GetLength() + 1);
|
|
|
|
// Remove the trailing categories
|
|
// (We'll deal with your rebel friends soon enough).
|
|
iString = strSubCategory.Find((TCHAR) '\\');
|
|
if (iString != -1)
|
|
strSubCategory = strSubCategory.Left(iString);
|
|
|
|
// Update the category to add the current category
|
|
strCategory += _T("\\");
|
|
strCategory += strSubCategory;
|
|
|
|
#if 0
|
|
// Turned out not to need this code.
|
|
// Find the Sub-folder with the name of the Sub-category.
|
|
pfNext = pfNext->GetChildNode();
|
|
do {
|
|
pfNext->GetName(szName);
|
|
if (szName == szSubCategory) break;
|
|
pfNext = pfNext->GetNextNode();
|
|
} while (pfNext != NULL);
|
|
ASSERT(pfNext != NULL);
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// If were are currently refreshing, hang here until it's done.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CSystemInfoScope::WaitForRefresh()
|
|
{
|
|
if (pSource() && pSource()->GetType() == CDataSource::GATHERER)
|
|
{
|
|
CWBEMDataSource * pWBEMSource = reinterpret_cast<CWBEMDataSource *>(pSource());
|
|
if (pWBEMSource && pWBEMSource->m_pThreadRefresh)
|
|
pWBEMSource->m_pThreadRefresh->WaitForRefresh();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Is an asynchronous refresh currently in progress?
|
|
//-----------------------------------------------------------------------------
|
|
|
|
BOOL CSystemInfoScope::InRefresh()
|
|
{
|
|
if (pSource() && pSource()->GetType() == CDataSource::GATHERER)
|
|
{
|
|
CWBEMDataSource * pWBEMSource = reinterpret_cast<CWBEMDataSource *>(pSource());
|
|
if (pWBEMSource && pWBEMSource->m_pThreadRefresh)
|
|
return pWBEMSource->m_pThreadRefresh->IsRefreshing();
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* SelectItem - Select the item pointed to by szPath
|
|
*
|
|
* History: a-jsari 12/11/97 Initial version
|
|
*/
|
|
BOOL CSystemInfoScope::SelectItem(const CString &strPath, int iLine)
|
|
{
|
|
HSCOPEITEM hsiNode;
|
|
HRESULT hr;
|
|
|
|
// Get the named node from our internal list.
|
|
if (m_pmapCategories->ScopeFromName(strPath, hsiNode)) {
|
|
CFolder *pFolder = m_pmapCategories->CategoryFromScope(hsiNode);
|
|
pFolder->SetSelectedItem(iLine);
|
|
hr = pConsole()->SelectScopeItem(hsiNode);
|
|
ASSERT(hr == S_OK);
|
|
|
|
if (m_pLastSystemInfo)
|
|
m_pLastSystemInfo->SelectLine(iLine);
|
|
|
|
if (FAILED(hr)) return FALSE;
|
|
} else {
|
|
|
|
CString strCategory = strPath;
|
|
int iEnumerations = 0;
|
|
int iString;
|
|
|
|
// If the category isn't in our list, we need to enumerate all nodes
|
|
// leading up to it.
|
|
while (!m_pmapCategories->ScopeFromName(strCategory, hsiNode)) {
|
|
++iEnumerations;
|
|
// Strip the last Category off the Path.
|
|
iString = strCategory.ReverseFind((TCHAR) '\\');
|
|
if (iString == -1) {
|
|
// If this fails, no nodes have been yet enumerated.
|
|
if (!m_pmapCategories->ScopeFromName(_T(""), hsiNode)) {
|
|
// --iEnumerations;
|
|
break;
|
|
}
|
|
} else {
|
|
strCategory = strCategory.Left(iString);
|
|
}
|
|
}
|
|
|
|
HRESULT hr;
|
|
// Enumerate all unenumerated nodes.
|
|
#if 0
|
|
// Commented out because InsertItem in ScopeEnumerate fails inexplicably.
|
|
CFolder *pfCurrent = pmapCategories->CategoryFromScope(hsiNode);
|
|
#endif
|
|
while (iEnumerations--) {
|
|
#if 0
|
|
hr = ScopeEnumerate(hsiNode, pfCurrent);
|
|
#else
|
|
hr = pConsole()->SelectScopeItem(hsiNode);
|
|
#endif
|
|
ASSERT(hr == S_OK);
|
|
if (FAILED(hr)) return FALSE;
|
|
GetNamedChildFolder(strCategory, strPath);
|
|
if (!m_pmapCategories->ScopeFromName(strCategory, hsiNode))
|
|
// The scope item we are searching for cannot be enumerated (The
|
|
// attempt to do so in SelectScopeItem has failed.) This can happen
|
|
// when we are connected to a remote computer which can't be accessed.
|
|
return FALSE;
|
|
}
|
|
CFolder *pFolder = m_pmapCategories->CategoryFromScope(hsiNode);
|
|
// Using this method of selecting a line because MMC won't
|
|
// just allow me to call GetItem.
|
|
pFolder->SetSelectedItem(iLine);
|
|
hr = pConsole()->SelectScopeItem(hsiNode);
|
|
|
|
if (m_pLastSystemInfo)
|
|
m_pLastSystemInfo->SelectLine(iLine);
|
|
|
|
ASSERT(hr == S_OK);
|
|
if (FAILED(hr)) return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* ScopeEnumerate - Insert all categories of the given pFolder as namespace children
|
|
* of hsiNode.
|
|
*
|
|
* History: a-jsari 11/20/97 Initial version
|
|
*/
|
|
|
|
HRESULT CSystemInfoScope::ScopeEnumerate(HSCOPEITEM hsiNode, CFolder *pFolder)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
ASSERT(pFolder);
|
|
if (pFolder == NULL)
|
|
return hr;
|
|
|
|
SCOPEDATAITEM sdiNode;
|
|
sdiNode.mask = SDI_STR | SDI_PARAM | SDI_PARENT;
|
|
sdiNode.displayname = MMC_CALLBACK;
|
|
sdiNode.relativeID = hsiNode;
|
|
|
|
// If GetChildNode returned a NULL pointer, and this is the root node,
|
|
// then some sort of error must have occurred.
|
|
|
|
CFolder * pfolIterator = pFolder->GetChildNode();
|
|
if (pfolIterator == NULL && pFolder->GetParentNode() == NULL)
|
|
{
|
|
AFX_MANAGE_STATE(::AfxGetStaticModuleState());
|
|
|
|
if (m_pSource && m_pSource->GetType() == CDataSource::GATHERER)
|
|
if (((CWBEMDataSource *)m_pSource)->m_pGatherer)
|
|
{
|
|
DWORD dwError = ((CWBEMDataSource *)m_pSource)->m_pGatherer->GetLastError();
|
|
if (dwError)
|
|
DisplayGatherError(dwError, (LPCTSTR)((CWBEMDataSource *)m_pSource)->m_strMachineName);
|
|
}
|
|
}
|
|
|
|
while (pfolIterator)
|
|
{
|
|
// This object gets deleted inthe mapCategories destructor.
|
|
|
|
CViewObject * pCategory = new CCategoryObject(pfolIterator);
|
|
ASSERT(pCategory != NULL);
|
|
if (pCategory == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
// If there are no children, modify the node we're inserting so
|
|
// we don't get a '+' sign next to the folder.
|
|
|
|
if (pfolIterator->GetChildNode() == NULL)
|
|
{
|
|
sdiNode.cChildren = 0;
|
|
sdiNode.mask |= SDI_CHILDREN;
|
|
}
|
|
else
|
|
{
|
|
sdiNode.cChildren = 1;
|
|
sdiNode.mask &= ~SDI_CHILDREN;
|
|
}
|
|
|
|
sdiNode.lParam = reinterpret_cast<LPARAM>(pCategory);
|
|
hr = pScope()->InsertItem(&sdiNode);
|
|
ASSERT(hr == S_OK);
|
|
if (FAILED(hr))
|
|
{
|
|
delete pCategory;
|
|
break;
|
|
}
|
|
|
|
pfolIterator->m_hsi = sdiNode.ID;
|
|
m_pmapCategories->Insert(pCategory, sdiNode.ID);
|
|
pfolIterator = pfolIterator->GetNextNode();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
* AddExtensionRoot - If the snapin is loaded as an extension, create the root node.
|
|
*
|
|
* History: a-jsari 1/6/97 Initial version
|
|
*/
|
|
HRESULT CSystemInfoScope::AddExtensionRoot(HSCOPEITEM &hsiNode, CFolder **pFolder)
|
|
{
|
|
SCOPEDATAITEM sdiNode;
|
|
HRESULT hrReturn;
|
|
CViewObject *pView;
|
|
|
|
::memset(&sdiNode, 0, sizeof(sdiNode));
|
|
sdiNode.mask = SDI_STR | SDI_PARAM | SDI_PARENT | SDI_IMAGE | SDI_OPENIMAGE;
|
|
sdiNode.nImage = 0;
|
|
sdiNode.nOpenImage = 0;
|
|
sdiNode.displayname = MMC_CALLBACK;
|
|
sdiNode.relativeID = hsiNode;
|
|
|
|
pView = new CExtensionRootObject(pRootCategory());
|
|
ASSERT(pView != NULL);
|
|
if (pView == NULL) ::AfxThrowMemoryException();
|
|
m_RootCookie = sdiNode.lParam = reinterpret_cast<LPARAM>(pView);
|
|
hrReturn = pScope()->InsertItem(&sdiNode);
|
|
hsiNode = sdiNode.ID;
|
|
m_pmapCategories->InsertRoot(pView, hsiNode);
|
|
*pFolder = pRootCategory();
|
|
return hrReturn;
|
|
}
|
|
|
|
/*
|
|
* OnExpand - If fExpand is TRUE, expand the item pointed to by pDataObject,
|
|
* otherwise contract it. If expanding, enumerate children.
|
|
*
|
|
* History: a-jsari 9/25/97 Initial version
|
|
*/
|
|
|
|
HRESULT CSystemInfoScope::OnExpand(LPDATAOBJECT pDataObject, LPARAM fExpand, HSCOPEITEM hsiNode)
|
|
{
|
|
CFolder *pfolSelection;
|
|
HRESULT hr;
|
|
|
|
// Log the expand event, so we know that the user clicked on a node.
|
|
|
|
if (msiLog.IsLogging(CMSInfoLog::CATEGORY))
|
|
{
|
|
CFolder * pFolder = m_pmapCategories->CategoryFromScope(hsiNode);
|
|
if (pFolder)
|
|
{
|
|
CString strName;
|
|
if (pFolder->GetName(strName))
|
|
msiLog.WriteLog(CMSInfoLog::CATEGORY, _T("CATEGORY \"%s\"\r\n"), strName);
|
|
}
|
|
}
|
|
|
|
// We have nothing to do if we are contracting a node.
|
|
// This never happens.
|
|
if (fExpand == 0) return S_OK;
|
|
|
|
// If our initialization failed, exit.
|
|
if (!m_bInitializedCD) return S_OK;
|
|
// Look up the CViewObject in our internal table based on our hsiNode value,
|
|
// and
|
|
// CHECK: Consider the memory leak potential in this map.
|
|
if ((pfolSelection = m_pmapCategories->CategoryFromScope(hsiNode)) == NULL) {
|
|
// If the expanded node isn't in our internal hash table, we should
|
|
// be looking at the root node, so get it.
|
|
if (IsPrimaryImpl() == FALSE) {
|
|
// If we are an extension . . .
|
|
FORMATETC fmtMachine = {
|
|
(CLIPFORMAT) CDataObject::m_cfMachineName,
|
|
NULL,
|
|
DVASPECT_CONTENT,
|
|
TYMED_HGLOBAL
|
|
};
|
|
STGMEDIUM stgMachine;
|
|
|
|
stgMachine.tymed = TYMED_HGLOBAL;
|
|
stgMachine.hGlobal = ::GlobalAlloc(GMEM_MOVEABLE, (MAX_PATH + 1)* sizeof(WCHAR));
|
|
stgMachine.pUnkForRelease = NULL;
|
|
|
|
// Only look externally for the machine when we are an extension.
|
|
hr = pDataObject->GetDataHere(&fmtMachine, &stgMachine);
|
|
if (hr == S_OK) {
|
|
USES_CONVERSION;
|
|
CString strMachine = W2T((LPWSTR)::GlobalLock(stgMachine.hGlobal));
|
|
::GlobalUnlock(stgMachine.hGlobal);
|
|
HGLOBAL hGlobal = ::GlobalFree(stgMachine.hGlobal);
|
|
ASSERT(hGlobal == NULL);
|
|
SetMachine(strMachine);
|
|
} else
|
|
ASSERT(hr == DV_E_FORMATETC);
|
|
hr = AddExtensionRoot(hsiNode, &pfolSelection);
|
|
ASSERT(SUCCEEDED(hr));
|
|
return hr;
|
|
} else {
|
|
hr = AddRoot(hsiNode, &pfolSelection);
|
|
ASSERT(SUCCEEDED(hr));
|
|
if (FAILED(hr)) return hr;
|
|
}
|
|
}
|
|
return ScopeEnumerate(hsiNode, pfolSelection);
|
|
}
|
|
|
|
/*
|
|
* OnProperties - Called when a property value changes.
|
|
*
|
|
* History: a-jsari 9/25/97 Initial version.
|
|
*/
|
|
HRESULT CSystemInfoScope::OnProperties(LPARAM)
|
|
{
|
|
DWORD dwError = 0;
|
|
|
|
AFX_MANAGE_STATE(::AfxGetStaticModuleState());
|
|
|
|
if (m_pSource && m_pSource->GetType() == CDataSource::GATHERER)
|
|
{
|
|
CWBEMDataSource * pWBEMSource = reinterpret_cast<CWBEMDataSource *>(pSource());
|
|
if (pWBEMSource && pWBEMSource->m_pThreadRefresh)
|
|
pWBEMSource->m_pThreadRefresh->CancelRefresh();
|
|
|
|
if (m_strLastMachineName.CompareNoCase((LPCTSTR) *m_pstrMachineName) != 0)
|
|
{
|
|
// Try to connect to the new machine. If the connection fails, display
|
|
// an appropriate error message and restore the machine name to the
|
|
// original string.
|
|
|
|
if (((CWBEMDataSource *)m_pSource)->m_pGatherer->SetConnect(*m_pstrMachineName))
|
|
{
|
|
if (NULL == ((CWBEMDataSource *)m_pSource)->m_pGatherer->GetProvider())
|
|
dwError = ((CWBEMDataSource *)m_pSource)->m_pGatherer->GetLastError();
|
|
}
|
|
else
|
|
dwError = ((CWBEMDataSource *)m_pSource)->m_pGatherer->GetLastError();
|
|
|
|
if (dwError)
|
|
{
|
|
// Display the error, and reset the machine name and the data source
|
|
// to the previous known good name.
|
|
|
|
DisplayGatherError(dwError, (LPCTSTR) *m_pstrMachineName);
|
|
*m_pstrMachineName = m_strLastMachineName;
|
|
((CWBEMDataSource *)m_pSource)->m_pGatherer->SetConnect(*m_pstrMachineName);
|
|
((CWBEMDataSource *)m_pSource)->m_pGatherer->GetProvider();
|
|
RefreshAsync(m_pfLast, m_pLastSystemInfo, FALSE);
|
|
}
|
|
else
|
|
{
|
|
if (pSource() != NULL)
|
|
SetMachine(*m_pstrMachineName);
|
|
}
|
|
}
|
|
|
|
// This doesn't really seem necessary...
|
|
// if (m_pfLast && pConsole())
|
|
// pConsole()->SelectScopeItem(m_pfLast->m_hsi);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// DisplayGatherError
|
|
//
|
|
// There are multiple places we need to display a connection error to the user,
|
|
// so the functionality is gathered here.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CSystemInfoScope::DisplayGatherError(DWORD dwError, LPCTSTR szMachineName)
|
|
{
|
|
CString strMachine, strErrorMessage;
|
|
|
|
if (!dwError)
|
|
return;
|
|
|
|
if (szMachineName)
|
|
strMachine = CString(szMachineName);
|
|
|
|
AFX_MANAGE_STATE(::AfxGetStaticModuleState());
|
|
|
|
if (strMachine.IsEmpty())
|
|
strMachine.LoadString(IDS_LOCALCOMPLABEL);
|
|
|
|
switch (dwError)
|
|
{
|
|
case GATH_ERR_ALLOCATIONFAILED:
|
|
case GATH_ERR_NOWBEMOUTOFMEM:
|
|
strErrorMessage.LoadString(IDS_OUTOFMEMERROR);
|
|
break;
|
|
case GATH_ERR_NOWBEMLOCATOR:
|
|
strErrorMessage.LoadString(IDS_NOLOCATOR);
|
|
break;
|
|
case GATH_ERR_NOWBEMCONNECT:
|
|
strErrorMessage.Format(IDS_NOGATHERER, strMachine);
|
|
break;
|
|
case GATH_ERR_NOWBEMACCESSDENIED:
|
|
strErrorMessage.Format(IDS_GATHERACCESS, strMachine);
|
|
break;
|
|
case GATH_ERR_NOWBEMBADSERVER:
|
|
strErrorMessage.Format(IDS_BADSERVER, strMachine);
|
|
break;
|
|
case GATH_ERR_NOWBEMNETWORKFAILURE:
|
|
strErrorMessage.Format(IDS_NETWORKERROR, strMachine);
|
|
break;
|
|
case GATH_ERR_BADCATEGORYID:
|
|
strErrorMessage.LoadString(IDS_UNEXPECTED);
|
|
break;
|
|
default:
|
|
ASSERT(FALSE);
|
|
strErrorMessage.LoadString(IDS_UNEXPECTED);
|
|
break;
|
|
}
|
|
|
|
MessageBox(strErrorMessage);
|
|
}
|
|
|
|
/*
|
|
* MachineName - Return the current connected machine as a LPCSTR.
|
|
*
|
|
* History: a-jsari 11/12/97 Initial version.
|
|
*/
|
|
LPCTSTR CSystemInfoScope::MachineName() const
|
|
{
|
|
if (m_pstrMachineName == NULL || m_pstrMachineName->GetLength() == 0) return NULL;
|
|
return (LPCTSTR)(*m_pstrMachineName)+2; // +2 to skip over the initial "\\"
|
|
}
|
|
|
|
/*
|
|
* SetSelectedFolder - Remember the last selected folder for context-
|
|
* sensitive operations (i.e. Print, Report, Find)
|
|
*
|
|
* History: a-jsari 2/12/98 Initial version
|
|
*/
|
|
void CSystemInfoScope::SetSelectedFolder(CFolder *pFolder)
|
|
{
|
|
m_pfLast = pFolder;
|
|
if (pSource() != NULL)
|
|
pSource()->SetLastFolder(pFolder);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Start an async refresh of the specified folder.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CSystemInfoScope::RefreshAsync(CFolder * pFolder, CSystemInfo * pSystemInfo, BOOL fSoftRefresh)
|
|
{
|
|
if (pSource() && pSource()->GetType() == CDataSource::GATHERER)
|
|
{
|
|
CWBEMDataSource * pWBEMSource = reinterpret_cast<CWBEMDataSource *>(pSource());
|
|
if (pWBEMSource && pWBEMSource->m_pThreadRefresh)
|
|
pWBEMSource->m_pThreadRefresh->RefreshFolderAsync(pFolder, pSystemInfo, FALSE, fSoftRefresh);
|
|
}
|
|
}
|