dubey/WindowsXP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
WindowsXP/admin/wmi/wbem/sdk/activex/controls/singlecontainer/hmmvctl.cpp
Tanishq Dubey cb60ae51e5
Initial Commit
2025-04-27 07:49:33 -04:00

2397 lines
58 KiB
C++
Raw Blame History

// Copyright (c) 1997-2001 Microsoft Corporation, All Rights Reserved
//***************************************************************************
//
// (c) 1996, 1997 by Microsoft Corporation
//
// hmmvctl.cpp
//
// This file contains the implementation of the main view container as well
// as the generic view.
//
// a-larryf 17-Sept-96 Created.
//
//***************************************************************************
#include "precomp.h"
#include <initguid.h>
#include <afxcmn.h>
#include "hmmv.h"
#include "HmmvCtl.h"
#include "HmmvPpg.h"
#include "utils.h"
#include "resource.h"
#include "titlebar.h"
#include "globals.h"
#include "filters.h"
#include "mv.h"
#include "vwstack.h"
#include "sv.h"
#include "PolyView.h"
#include "hmomutil.h"
#include "htmlhelp.h"
#include <wbemcli.h>
#include "wbemRegistry.h"
#include "coloredt.h"
#include "DlgHelpBox.h"
#include "DlgExecQuery.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
CGenericViewContext::~CGenericViewContext()
{
if (m_psv!=NULL && m_lContextHandle != NULL) {
m_psv->ReleaseContext(m_lContextHandle);
}
}
#define GENERIC_VIEW_INDEX 0
#define CY_TAB_FONT 15
#define CX_VIEW_DEFAULT_LEFT_MARGIN 8
#define CX_VIEW_DEFAULT_RIGHT_MARGIN 8
#define CY_VIEW_DEFAULT_TOP_MARGIN 8
#define CY_VIEW_DEFAULT_BOTTOM_MARGIN 8
#define CY_TITLE_DEFAULT_TOP_MARGIN 4
IMPLEMENT_DYNCREATE(CWBEMViewContainerCtrl, COleControl)
/////////////////////////////////////////////////////////////////////////////
// Message map
BEGIN_MESSAGE_MAP(CWBEMViewContainerCtrl, COleControl)
ON_WM_CONTEXTMENU()
//{{AFX_MSG_MAP(CWBEMViewContainerCtrl)
ON_WM_SIZE()
ON_WM_CREATE()
ON_WM_DESTROY()
ON_COMMAND(ID_CMD_SHOW_OBJECT_ATTRIBUTES, OnCmdShowObjectAttributes)
ON_WM_SETFOCUS()
ON_WM_KILLFOCUS()
ON_OLEVERB(AFX_IDS_VERB_EDIT, OnEdit)
ON_WM_ERASEBKGND()
//}}AFX_MSG_MAP
ON_OLEVERB(AFX_IDS_VERB_PROPERTIES, OnProperties)
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// Dispatch map
BEGIN_DISPATCH_MAP(CWBEMViewContainerCtrl, COleControl)
//{{AFX_DISPATCH_MAP(CWBEMViewContainerCtrl)
DISP_PROPERTY_NOTIFY(CWBEMViewContainerCtrl, "StatusCode", m_sc, OnStatusCodeChanged, VT_I4)
DISP_PROPERTY_EX(CWBEMViewContainerCtrl, "ObjectPath", GetObjectPath, SetObjectPath, VT_VARIANT)
DISP_PROPERTY_EX(CWBEMViewContainerCtrl, "NameSpace", GetNameSpace, SetNameSpace, VT_BSTR)
DISP_PROPERTY_EX(CWBEMViewContainerCtrl, "StudioModeEnabled", GetStudioModeEnabled, SetStudioModeEnabled, VT_I4)
DISP_PROPERTY_EX(CWBEMViewContainerCtrl, "PropertyFilter", GetPropertyFilter, SetPropertyFilter, VT_I4)
DISP_FUNCTION(CWBEMViewContainerCtrl, "ShowInstances", ShowInstances, VT_EMPTY, VTS_BSTR VTS_VARIANT)
DISP_FUNCTION(CWBEMViewContainerCtrl, "SaveState", SaveState, VT_I4, VTS_I4 VTS_I4)
DISP_FUNCTION(CWBEMViewContainerCtrl, "QueryViewInstances", QueryViewInstances, VT_EMPTY, VTS_BSTR VTS_BSTR VTS_BSTR VTS_BSTR)
DISP_STOCKPROP_READYSTATE()
//}}AFX_DISPATCH_MAP
END_DISPATCH_MAP()
/////////////////////////////////////////////////////////////////////////////
// Event map
BEGIN_EVENT_MAP(CWBEMViewContainerCtrl, COleControl)
//{{AFX_EVENT_MAP(CWBEMViewContainerCtrl)
EVENT_CUSTOM("GetIWbemServices", FireGetIWbemServices, VTS_BSTR VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT)
EVENT_CUSTOM("NOTIFYChangeRootOrNamespace", FireNOTIFYChangeRootOrNamespace, VTS_BSTR VTS_I4 VTS_I4)
EVENT_CUSTOM("RequestUIActive", FireRequestUIActive, VTS_NONE)
EVENT_STOCK_READYSTATECHANGE()
//}}AFX_EVENT_MAP
END_EVENT_MAP()
/////////////////////////////////////////////////////////////////////////////
// Property pages
// TODO: Add more property pages as needed. Remember to increase the count!
BEGIN_PROPPAGEIDS(CWBEMViewContainerCtrl, 1)
PROPPAGEID(CWBEMViewContainerPropPage::guid)
END_PROPPAGEIDS(CWBEMViewContainerCtrl)
/////////////////////////////////////////////////////////////////////////////
// Initialize class factory and guid
IMPLEMENT_OLECREATE_EX(CWBEMViewContainerCtrl, "WBEM.ObjViewerCtrl.1",
0x5b3572ab, 0xd344, 0x11cf, 0x99, 0xcb, 0, 0xc0, 0x4f, 0xd6, 0x44, 0x97)
/////////////////////////////////////////////////////////////////////////////
// Type library ID and version
IMPLEMENT_OLETYPELIB(CWBEMViewContainerCtrl, _tlid, _wVerMajor, _wVerMinor)
/////////////////////////////////////////////////////////////////////////////
// Interface IDs
const IID BASED_CODE IID_DWBEMViewContainer =
{ 0x5b3572a9, 0xd344, 0x11cf, { 0x99, 0xcb, 0, 0xc0, 0x4f, 0xd6, 0x44, 0x97 } };
const IID BASED_CODE IID_DWBEMViewContainerEvents =
{ 0x5b3572aa, 0xd344, 0x11cf, { 0x99, 0xcb, 0, 0xc0, 0x4f, 0xd6, 0x44, 0x97 } };
/////////////////////////////////////////////////////////////////////////////
// Control type information
static const DWORD BASED_CODE _dwWBEMViewContainerOleMisc =
OLEMISC_SIMPLEFRAME |
OLEMISC_ACTIVATEWHENVISIBLE |
OLEMISC_SETCLIENTSITEFIRST |
OLEMISC_INSIDEOUT |
OLEMISC_CANTLINKINSIDE |
OLEMISC_RECOMPOSEONRESIZE;
IMPLEMENT_OLECTLTYPE(CWBEMViewContainerCtrl, IDS_HMMV, _dwWBEMViewContainerOleMisc)
/////////////////////////////////////////////////////////////////////////////
// CWBEMViewContainerCtrl::CWBEMViewContainerCtrlFactory::UpdateRegistry -
// Adds or removes system registry entries for CWBEMViewContainerCtrl
BOOL CWBEMViewContainerCtrl::CWBEMViewContainerCtrlFactory::UpdateRegistry(BOOL bRegister)
{
// TODO: Verify that your control follows apartment-model threading rules.
// Refer to MFC TechNote 64 for more information.
// If your control does not conform to the apartment-model rules, then
// you must modify the code below, changing the 6th parameter from
// afxRegInsertable | afxRegApartmentThreading to 0.
if (bRegister)
return AfxOleRegisterControlClass(
AfxGetInstanceHandle(),
m_clsid,
m_lpszProgID,
IDS_HMMV,
IDB_HMMV,
afxRegInsertable | afxRegApartmentThreading,
_dwWBEMViewContainerOleMisc,
_tlid,
_wVerMajor,
_wVerMinor);
else
return AfxOleUnregisterClass(m_clsid, m_lpszProgID);
}
/////////////////////////////////////////////////////////////////////////////
// CWBEMViewContainerCtrl::CWBEMViewContainerCtrl - Constructor
CWBEMViewContainerCtrl::CWBEMViewContainerCtrl()
{
m_bCreationFinished = FALSE;
InitializeIIDs(&IID_DWBEMViewContainer, &IID_DWBEMViewContainerEvents);
EnableSimpleFrame();
SetModifiedFlag(FALSE);
AfxEnableControlContainer();
m_htmlHelpInst = 0;
m_bDelayToolbarUpdate = FALSE;
m_bInStudioMode = TRUE;
m_bEmptyContainer = TRUE;
m_bSingleViewNeedsRefresh = FALSE;
m_bDidInitialDraw = FALSE;
m_bPathIsClass = TRUE;
m_bObjectIsNewlyCreated = FALSE;
m_bFiredReadyStateChange = FALSE;
m_lPropFilters = (PROPFILTER_SYSTEM | PROPFILTER_INHERITED | PROPFILTER_LOCAL);
// The instance paths from ShowInstances
m_varObjectPath = L"";
m_cxViewLeftMargin = CX_VIEW_DEFAULT_LEFT_MARGIN;
m_cxViewRightMargin = CX_VIEW_DEFAULT_RIGHT_MARGIN;
m_cyViewTopMargin = CY_VIEW_DEFAULT_TOP_MARGIN;
m_cyViewBottomMargin = CY_VIEW_DEFAULT_BOTTOM_MARGIN;
GetViewerFont(m_font, CY_TAB_FONT, FW_NORMAL);
m_pViewStack = new CViewStack(this);
m_pTitleBar = new CTitleBar;
m_pview = new CPolyView(this);
m_pdlgHelpBox = new CDlgHelpBox(this);
m_bDeadObject = FALSE; // An object is dead when a user chooses not to save it
}
/////////////////////////////////////////////////////////////////////////////
// CWBEMViewContainerCtrl::~CWBEMViewContainerCtrl - Destructor
CWBEMViewContainerCtrl::~CWBEMViewContainerCtrl()
{
// These objects should have been freed in CWBEMViewContainerCtrl::OnDestroy
ASSERT(m_pview == NULL);
ASSERT(m_pViewStack == NULL);
ASSERT(m_pTitleBar == NULL);
#ifdef USE_HTML_HELP
if(m_htmlHelpInst)
{
FreeLibrary(m_htmlHelpInst);
m_htmlHelpInst = NULL;
}
#endif //USE_HTML_HELP
}
void CWBEMViewContainerCtrl::DrawBackground(CDC* pdc, const CRect& rcBounds, const CRect& rcInvalid)
{
CBrush brBACKGROUND(GetSysColor(COLOR_BACKGROUND));
CBrush br3DFACE(GetSysColor(COLOR_3DFACE));
pdc->FillRect(rcBounds, &br3DFACE);
}
void CWBEMViewContainerCtrl::CalcViewRect(CRect& rcView)
{
CRect rcClient;
GetClientRect(&rcClient);
rcView.top = rcClient.top + m_pTitleBar->GetDesiredBarHeight() + m_cyViewTopMargin;
rcView.left = rcClient.left + m_cxViewLeftMargin;
rcView.right = rcClient.right - m_cxViewRightMargin;
rcView.bottom = rcClient.bottom - m_cyViewBottomMargin;
}
void CWBEMViewContainerCtrl::CalcTitleRect(CRect& rcTitle)
{
CRect rcClient;
GetClientRect(&rcClient);
rcTitle.top = rcClient.top + CY_TITLE_DEFAULT_TOP_MARGIN;
rcTitle.left = rcClient.left + m_cxViewLeftMargin;
rcTitle.right = rcClient.right - m_cxViewRightMargin;
rcTitle.bottom = rcClient.top + m_pTitleBar->GetDesiredBarHeight();
}
void CWBEMViewContainerCtrl::OnDrawPreCreate(
CDC* pdc,
const CRect& rcBounds,
const CRect& rcInvalid)
{
CBrush brBackground;
brBackground.CreateSolidBrush(::GetSysColor(COLOR_WINDOW));
CBrush brBlack;
brBlack.CreateSolidBrush(::GetSysColor(COLOR_ACTIVEBORDER));
pdc->FillRect(rcInvalid, &brBackground);
CRect rcFrame = rcBounds;
rcFrame.InflateRect(-1, -1);
pdc->FrameRect(rcFrame, &brBlack);
return;
#if 0
// I attempted to draw a small image of the object view so that
// you would see something interesting at design time. However,
// people didn't like it, so I've commented out the code here.
CDC dcMem;
BOOL bDidCreate;
BOOL bDidLoad;
bDidCreate = dcMem.CreateCompatibleDC(pdc);
if (!bDidCreate) {
return;
}
CBitmap bm;
bDidLoad = bm.LoadBitmap(IDB_DESIGN_TIME);
BITMAP bitmap;
bm.GetBitmap(&bitmap);
CBitmap* pbmSave = dcMem.SelectObject(&bm);
int ixDst = 0;
int iyDst = 0;
if (bitmap.bmWidth < rcBounds.Width()) {
ixDst = (rcBounds.Width() - bitmap.bmWidth) / 2;
}
if (bitmap.bmHeight < rcBounds.Height()) {
iyDst = (rcBounds.Height() - bitmap.bmHeight) / 2;
}
pdc->BitBlt(ixDst, iyDst, rcBounds.Width(), rcBounds.Height(), &dcMem, 0, 0, SRCCOPY);
dcMem.SelectObject(pbmSave);
#endif //0
}
/////////////////////////////////////////////////////////////////////////////
// CWBEMViewContainerCtrl::OnDraw - Drawing function
void CWBEMViewContainerCtrl::OnDraw(
CDC* pdc, const CRect& rcBounds, const CRect& rcInvalid)
{
if (!::IsWindow(m_hWnd)) {
OnDrawPreCreate(pdc, rcBounds, rcInvalid);
return;
}
COLORREF clrBack = RGB(0x0ff, 0, 0);
pdc->SetBkColor(clrBack);
DrawBackground(pdc, rcBounds, rcInvalid);
if (!m_bDidInitialDraw) {
m_bDidInitialDraw = TRUE;
if (m_pview->DidCreateWindow()) {
m_pview->ShowSingleView();
m_pTitleBar->NotifyObjectChanged();
}
}
// Redraw the portion of the titlebar that is invalid.
CRect rcTitleBar;
m_pTitleBar->GetWindowRect(rcTitleBar);
ScreenToClient(rcTitleBar);
BOOL bFixTitleBar = rcTitleBar.IntersectRect(&rcInvalid, &rcTitleBar);
if (bFixTitleBar) {
ClientToScreen(rcTitleBar);
m_pTitleBar->ScreenToClient(rcTitleBar);
m_pTitleBar->InvalidateRect(rcTitleBar);
}
CRect rcText = rcBounds;
rcText.bottom = rcText.top + 32;
rcText.top = rcText.top + 6;
rcText.left = rcText.left + 32 + 8 + 5 + 4;
rcText.right = rcText.right - 8;
if (m_pview->DidCreateWindow()) {
BOOL IsShowingMultiview = m_pview->IsShowingMultiview();
BOOL bMultiviewVisible = m_pview->GetMultiView()->IsWindowVisible();
BOOL bSingleviewVisible = m_pview->GetSingleView()->IsWindowVisible();
CRect rcView;
BOOL bFixView;
if (bMultiviewVisible) {
CMultiView* pmv = m_pview->GetMultiView();
pmv->GetWindowRect(rcView);
ScreenToClient(rcView);
bFixView = rcView.IntersectRect(&rcInvalid, &rcView);
if (bFixView) {
ClientToScreen(rcView);
pmv->ScreenToClient(rcView);
pmv->InvalidateRect(rcView);
}
}
if (bSingleviewVisible) {
CSingleView* psv = m_pview->GetSingleView();
psv->GetWindowRect(rcView);
ScreenToClient(rcView);
bFixView = rcView.IntersectRect(&rcInvalid, &rcView);
if (bFixView) {
ClientToScreen(rcView);
psv->ScreenToClient(rcView);
psv->InvalidateRect(rcView);
}
}
// m_pview->RedrawWindow();
}
if (!m_bFiredReadyStateChange) {
m_bFiredReadyStateChange = TRUE;
FireReadyStateChange();
}
}
/////////////////////////////////////////////////////////////////////////////
// CWBEMViewContainerCtrl::DoPropExchange - Persistence support
void CWBEMViewContainerCtrl::DoPropExchange(CPropExchange* pPX)
{
ExchangeVersion(pPX, MAKELONG(_wVerMinor, _wVerMajor));
COleControl::DoPropExchange(pPX);
// TODO: Call PX_ functions for each persistent custom property.
CString sObjectPath;
PX_String(pPX, _T("ObjectPath"), sObjectPath, CString(_T("")));
m_varObjectPath = (const CString&) sObjectPath;
PX_String(pPX, _T("NameSpace"), m_sNameSpace, CString(_T("")));
PX_Bool(pPX, _T("StudioModeEnabled"), m_bInStudioMode, TRUE);
m_pview->SetStudioModeEnabled(m_bInStudioMode);
}
/////////////////////////////////////////////////////////////////////////////
// CWBEMViewContainerCtrl::OnResetState - Reset control to default state
void CWBEMViewContainerCtrl::OnResetState()
{
COleControl::OnResetState(); // Resets defaults found in DoPropExchange
}
/////////////////////////////////////////////////////////////////////////////
// CWBEMViewContainerCtrl message handlers
void CWBEMViewContainerCtrl::DoDataExchange(CDataExchange* pDX)
{
COleControl::DoDataExchange(pDX);
}
LRESULT CWBEMViewContainerCtrl::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
{
return COleControl::WindowProc(message, wParam, lParam);
}
void CWBEMViewContainerCtrl::SetObjectPath(const VARIANT FAR& varObjectPath)
{
BOOL bDelayToolbarUpdateT = m_bDelayToolbarUpdate;
m_bDelayToolbarUpdate = TRUE;
if (!::IsWindow(m_hWnd)) {
m_varObjectPath = varObjectPath;
return;
}
if (!m_pview->DidCreateWindow()) {
return;
}
m_bEmptyContainer = ::IsEmptyString(varObjectPath.bstrVal);
m_pViewStack->UpdateView();
ShowMultiView(FALSE, FALSE);
JumpToObjectPath(varObjectPath.bstrVal, TRUE);
m_bDelayToolbarUpdate = bDelayToolbarUpdateT;
if (!m_bDelayToolbarUpdate) {
m_pTitleBar->Refresh();
}
}
VARIANT CWBEMViewContainerCtrl::GetObjectPath()
{
CSingleView* psv = m_pview->GetSingleView();
long lPos;
lPos = psv->StartObjectEnumeration(OBJECT_CURRENT);
if (lPos >= 0) {
m_varObjectPath = psv->GetObjectPath(lPos);
}
return m_varObjectPath;
}
void CWBEMViewContainerCtrl::Clear(BOOL bRedrawWindow)
{
m_bDeadObject = FALSE; // An object is dead when a user chooses not to save it
if (m_pTitleBar != NULL) {
m_pTitleBar->EnableButton(ID_CMD_SAVE_DATA, FALSE);
m_pTitleBar->EnableButton(ID_CMD_FILTERS, FALSE);
}
m_bObjectIsNewlyCreated = FALSE;
m_sNewInstClassPath.Empty();
if (m_hWnd != NULL) {
m_pview->RefreshView();
SetModifiedFlag(FALSE);
RedrawWindow();
}
else {
SetModifiedFlag(FALSE);
}
}
//**************************************************************
// CWBEMViewContainerCtrl::UpdateCreateDeleteButtonState
//
// Update the "enabled" state of the create and delete buttons to
// reflect the state of the underlying data and selection state.
//
// Parameters:
// None.
//
// Returns:
// Nothing.
//
//**************************************************************
void CWBEMViewContainerCtrl::UpdateCreateDeleteButtonState()
{
if (m_hWnd == NULL || m_pTitleBar==NULL) {
return;
}
BOOL bCanCreateInstance = FALSE;
BOOL bCanDeleteInstance = FALSE;
if (InStudioMode()) {
CSingleView* psv = m_pview->GetSingleView();
bCanCreateInstance = psv->QueryCanCreateInstance();
bCanDeleteInstance = m_pview->QueryCanDeleteInstance();
}
m_pTitleBar->EnableButton(ID_CMD_CREATE_INSTANCE, bCanCreateInstance);
m_pTitleBar->EnableButton(ID_CMD_DELETE_INSTANCE, bCanDeleteInstance);
}
//***********************************************************
// CWBEMViewContainerCtrl::ShowMultiView
//
// Switch to either the multiple instance view or to the current
// single object view depending on the parameter.
//
// Parameters:
// [in] BOOL bShowMultiView
// TRUE to select the MultiView, otherwise FALSE
//
// [in] BOOL bAddToHistory
// TRUE to add any view change to the view history.
//
//
// Returns:
// TRUE if the view switch was OK, FALSE if the user aborted the
// view switch by cancelling a data save, etc.
//
//***********************************************************
BOOL CWBEMViewContainerCtrl::ShowMultiView(BOOL bShowMultiView, BOOL bAddToHistory)
{
if (!::IsWindow(m_hWnd)) {
return FALSE;
}
BOOL bWasShowingMultiView = m_pview->IsShowingMultiview();
if (IsBoolEqual(bShowMultiView, bWasShowingMultiView)) {
// The view is the same, but we may want to add it to the history.
if (bAddToHistory) {
m_pViewStack->PushView();
}
return TRUE;
}
// Show the desired view.
if (bShowMultiView) {
m_pview->ShowMultiView();
}
else {
// If we are flipping from the multiview to an instance, we should check to
// see if the currently selected instance in the multiview matches the
// currently selected instance in the singleview, if not then use the
// path for the currently selected instance in the multiview to select an
// instance in the singleview.
CSingleView* psv = m_pview->GetSingleView();
CMultiView* pmv = m_pview->GetMultiView();
BOOL bIsShowingInstance = psv->IsShowingInstance();
if (!bIsShowingInstance) {
CString sPathSingleview;
SCODE sc = psv->GetCurrentObjectPath(sPathSingleview);
if (!m_bObjectIsNewlyCreated && sPathSingleview.IsEmpty()) {
CString sPathMultiview;
sc = pmv->GetCurrentObjectPath(sPathMultiview);
if (SUCCEEDED(sc)) {
psv->SelectObjectByPath(sPathMultiview);
m_pViewStack->UpdateView();
}
}
}
m_pview->ShowSingleView();
}
BOOL bIsShowingMultiView = m_pview->IsShowingMultiview();
BOOL bDidSwitchView = !IsBoolEqual(bWasShowingMultiView, bIsShowingMultiView);
// If the view was switched, update the toolbar, etc.
if (bDidSwitchView) {
if (bAddToHistory) {
m_pViewStack->PushView();
}
UpdateWindow();
}
return TRUE;
}
//******************************************************************
// CWBEMViewContainerCtrl::JumpToObjectPathFromMultiview
//
//
// Parameters:
// LPCTSTR szPath
// The HMOM object path.
//
// BOOL bSetMultiviewClass
// TRUE to change the class of the instances displayed in
// the multiview.
//
// BOOL bAddToHistory
// TRUE to add this jump to the view history.
//
// Returns:
// SCODE
// S_OK if the jump was completed, a failure code otherwise.
//
//******************************************************************
SCODE CWBEMViewContainerCtrl::JumpToObjectPathFromMultiview(LPCTSTR szPath, BOOL bSetMultiviewClass, BOOL bAddToHistory)
{
SCODE sc;
m_pViewStack->UpdateView();
CBSTR bsPath(szPath);
sc = JumpToObjectPath((BSTR) bsPath, bSetMultiviewClass, bAddToHistory);
if (FAILED(sc)) {
ShowMultiView(TRUE, FALSE);
}
return sc;
}
//******************************************************************
// CWBEMViewContainerCtrl::JumpToObjectPath
//
//
// Parameters:
// BSTR bstrObjectPath
// The HMOM object path.
//
// BOOL bSetMultiviewClass
// TRUE to change the class of the instances displayed in
// the multiview.
//
// BOOL bAddToHistory
// TRUE to add this jump to the view history.
//
// Returns:
// SCODE
// S_OK if the jump was completed, a failure code otherwise.
//
//******************************************************************
SCODE CWBEMViewContainerCtrl::JumpToObjectPath(BSTR bstrObjectPath, BOOL bSetMultiviewClass, BOOL bAddToHistory)
{
SCODE sc;
CString sCurPath;
CSingleView* psv = m_pview->GetSingleView();
long lPos = psv->StartObjectEnumeration(OBJECT_CURRENT);
if (lPos != -1) {
sCurPath = psv->GetObjectPath(lPos);
CBSTR bsCurPath(sCurPath);
if (IsEqualNoCase(bstrObjectPath, (BSTR) bsCurPath)) {
bAddToHistory = FALSE;
}
}
// First check to see if there are any changes and, if so,
// ask the user whether or not he or she wants to save them.
if (!m_bDeadObject) { // An object is dead when a user chooses not to save it
sc = SaveState(TRUE, TRUE);
if (FAILED(sc)) {
return sc;
}
}
sCurPath = bstrObjectPath;
sc = psv->SelectObjectByPath(sCurPath);
if (FAILED(sc)) {
return sc;
}
if (bSetMultiviewClass) {
CMultiView* pmv = m_pview->GetMultiView();
if (::IsEmptyString(bstrObjectPath)) {
pmv->ViewClassInstances((LPCTSTR) "");
}
else {
COleVariant varClass;
sc = ClassFromPath(varClass, bstrObjectPath);
if (SUCCEEDED(sc)) {
CString sClass;
sClass = varClass.bstrVal;
pmv->ViewClassInstances((LPCTSTR) sClass);
}
}
}
m_varObjectPath = bstrObjectPath;
if (bAddToHistory) {
if (*bstrObjectPath != 0) {
m_pViewStack->PushView();
}
}
ShowMultiView(FALSE, FALSE);
UpdateToolbar();
m_bDeadObject = FALSE;
return S_OK;
}
//********************************************************
// CWBEMViewContainerCtrl::OnSize
//
// Handle the WM_SIZE message. This is the main window for
// the control and thus the child windows of this control
// must be resized accordingly.
//
// Parameters:
// See the MFC documentation for OnSize.
//
// Returns:
// Nothing.
//
//*********************************************************
void CWBEMViewContainerCtrl::OnSize(UINT nType, int cx, int cy)
{
COleControl::OnSize(nType, cx, cy);
// If the window size is one pixel or less, IExplore locks up
// if we resize the child windows.
CRect rcView;
CalcViewRect(rcView);
if (!rcView.IsRectEmpty()) {
m_pview->MoveWindow(rcView);
}
if (m_pTitleBar && m_pTitleBar->m_hWnd) {
CRect rcTitle;
CalcTitleRect(rcTitle);
if (!rcTitle.IsRectEmpty()) {
m_pTitleBar->MoveWindow(rcTitle);
}
}
}
//**************************************************************
// CWBEMViewContainerCtrl::SaveState
//
// Save the sate of the generic view.
//
// Parameters:
// [in] long bPromptUser
// TRUE if the user should be prompted as to whether or
// not the state should be saved.
//
// [in] long bUserCanCancel
//
//
// Returns:
// SCODE
// S_OK if the state was saved, WBEM_S_FALSE if the user chose not to
// save the object, and WBEM_S E_FAIL if something went
// wrong or if the user canceled the save.
//
//**************************************************************
long CWBEMViewContainerCtrl::SaveState(long bPromptUser, long bUserCanCancel)
{
UINT nType = bUserCanCancel ? MB_YESNOCANCEL : MB_YESNO;
long lResult;
lResult = PublicSaveState(bPromptUser, nType);
return lResult;
}
long CWBEMViewContainerCtrl::PublicSaveState(BOOL bPromptUser, UINT nType)
{
ASSERT((nType == MB_YESNOCANCEL) || (nType == MB_YESNO) || (nType == MB_OKCANCEL));
// If the current object is not modified, there is nothing to do.
CSingleView* psv = m_pview->GetSingleView();
BOOL bNeedsSave = psv->QueryNeedsSave();
if (!bNeedsSave) {
// Control should never come here.
m_pTitleBar->EnableButton(ID_CMD_SAVE_DATA, FALSE);
return S_OK;
}
if (bPromptUser) {
// Ask the user if a save should be done.
CString sFormat;
sFormat.LoadString(IDS_QUERY_SAVE_CHANGES);
CString sTitle;
sTitle = m_pview->GetObjectTitle(OBJECT_CURRENT);
_stprintf(m_szMessageBuffer, (LPCTSTR) sFormat, (LPCTSTR) sTitle);
nType |= MB_SETFOREGROUND;
int iPromptResult = HmmvMessageBox(this, m_szMessageBuffer, nType);
UpdateWindow();
CBSTR bsEmptyPath(_T(""));
CString sPath;
switch(iPromptResult) {
case IDYES:
break;
case IDNO:
// When an object save is canceled, the user is switching
// to a different object and the current version of the
// object must be discarded in the event that the user
// clicks the "go back" button or flips back to the
// singleview from the multiview.
if (m_pview->IsShowingSingleview()) {
m_bSingleViewNeedsRefresh = TRUE;
}
m_pViewStack->UpdateView();
m_bSingleViewNeedsRefresh = FALSE;
m_bDeadObject = TRUE; // An object is dead when a user chooses not to save it
// If the user says no to a save, discard the object.
m_pview->RefreshView(); // bug#55978
m_pTitleBar->EnableButton(ID_CMD_SAVE_DATA, FALSE);// bug#55978
return WBEM_S_FALSE;
break;
case IDCANCEL:
return E_FAIL;
}
}
SCODE sc;
sc = m_pview->SaveData();
if (FAILED(sc)) {
return sc;
}
// After a successful save, it is necessary to update the
// multiple instance view so that it shows the current property
// values for the object. This is done by telling the multiview
// that the object has been deleted and then created.
CString sObjectPath;
CMultiView* pmv = m_pview->GetMultiView();
sc = psv->GetCurrentObjectPath(sObjectPath);
if (SUCCEEDED(sc)) {
pmv->ExternInstanceDeleted(sObjectPath);
pmv->ExternInstanceCreated(sObjectPath);
}
m_bObjectIsNewlyCreated = FALSE;
m_sNewInstClassPath.Empty();
// m_notify.SendEvent(NOTIFY_OBJECT_SAVE_SUCCESSFUL);
UpdateToolbar();
m_pViewStack->UpdateView();
return S_OK;
}
void CWBEMViewContainerCtrl::UpdateToolbar()
{
if (!m_bDelayToolbarUpdate) {
BOOL bNeedsSave = m_pview->QueryNeedsSave();
SetModifiedFlag(bNeedsSave);
m_pTitleBar->Refresh();
}
}
void CWBEMViewContainerCtrl::NotifyDataChange()
{
BOOL bNeedsSave = m_pview->QueryNeedsSave();
SetModifiedFlag(bNeedsSave);
m_pTitleBar->EnableButton(ID_CMD_SAVE_DATA, bNeedsSave);
}
int CWBEMViewContainerCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (COleControl::OnCreate(lpCreateStruct) == -1)
return -1;
// TODO: Add your specialized creation code here
if (m_hWnd) {
CRect rcTitleBar;
rcTitleBar.SetRectEmpty();
m_pTitleBar->Create(this, WS_VISIBLE | WS_CHILD, rcTitleBar, GenerateWindowID());
m_pTitleBar->EnableButton(ID_CMD_SAVE_DATA, FALSE);
m_pTitleBar->CheckButton(ID_CMD_SWITCH_VIEW, FALSE);
}
CRect rcView;
CalcViewRect(rcView);
BOOL bDidCreate;
bDidCreate = m_pview->Create(rcView);
if (!bDidCreate) {
return FALSE;
}
m_pview->SetFont(m_font);
ShowMultiView(FALSE, FALSE);
if (!m_sNameSpace.IsEmpty()) {
m_pview->SetNamespace(m_sNameSpace);
}
CString sPath;
sPath = m_varObjectPath.bstrVal;
if (!sPath.IsEmpty()) {
JumpToObjectPath(m_varObjectPath.bstrVal, TRUE);
}
m_pTitleBar->EnableButton(ID_CMD_CONTEXT_FORWARD, FALSE);
m_pTitleBar->EnableButton(ID_CMD_CONTEXT_BACK, FALSE);
m_pTitleBar->EnableButton(ID_CMD_CREATE_INSTANCE, FALSE);
m_pTitleBar->EnableButton(ID_CMD_DELETE_INSTANCE, FALSE);
m_pTitleBar->EnableButton(ID_CMD_FILTERS, FALSE);
m_pTitleBar->EnableButton(ID_CMD_SWITCH_VIEW, FALSE);
m_pTitleBar->EnableButton(ID_CMD_QUERY, FALSE);
m_pview->SetEditMode(m_bInStudioMode);
m_bCreationFinished = TRUE;
return 0;
}
void CWBEMViewContainerCtrl::OnDestroy()
{
delete m_pViewStack;
delete m_pview;
delete m_pTitleBar;
delete m_pdlgHelpBox;
m_pViewStack = NULL;
m_pview = NULL;
m_pTitleBar = NULL;
COleControl::OnDestroy();
}
//************************************************************
// CWBEMViewContainerCtrl::MultiViewButtonClicked
//
// This method is called when the multiple-instance view button
// is clicked. When this occurs, switch to the multiple instance
// view.
//
// Parameters:
// None.
//
// Returns:
// Nothing.
//
//*************************************************************
void CWBEMViewContainerCtrl::MultiViewButtonClicked()
{
CWaitCursor wait;
BOOL bSwitchViewChecked = m_pTitleBar->IsButtonChecked(ID_CMD_SWITCH_VIEW);
BOOL bWasShowingSingleView = m_pview->IsShowingSingleview();
BOOL bWasNewlyCreatedInst = FALSE;
CString sClassPath;
CSingleView* psv = m_pview->GetSingleView();
SCODE sc = S_OK;
if (m_pview->IsShowingSingleview()) {
// Save the state only if we are flipping from the
// singleview to the multiview. This prevents a
// the save from being done when a new object is
// pre-selected into the singleview prior to displaying
// it so that things appear quickly.
sc = SaveState(TRUE, TRUE);
if (FAILED(sc)) {
m_pTitleBar->CheckButton(ID_CMD_SWITCH_VIEW, FALSE);
return;
}
else if (sc == WBEM_S_FALSE) {
// The user chose not to save changes when flipping to the
// multiview. This means that we need to reselect the
// current path into the singleview so that we revert back
// to the initial state of the object.
CString sObjectPath;
sObjectPath = m_varObjectPath.bstrVal;
psv->SelectObjectByPath(sObjectPath);
}
if (m_bObjectIsNewlyCreated) {
bWasNewlyCreatedInst = TRUE;
sClassPath = m_sNewInstClassPath;
}
}
ShowMultiView(bSwitchViewChecked, FALSE);
if (bWasShowingSingleView && bWasNewlyCreatedInst) {
if (sc == WBEM_S_FALSE && !sClassPath.IsEmpty()) {
// The user chose not to save the newly created instance, so
// we need to select the class so that when the user sees the
// multiview, the create instance button will be enabled
// if appropriate.
psv->SelectObjectByPath(m_sNewInstClassPath);
m_pViewStack->UpdateView();
m_bObjectIsNewlyCreated = FALSE;
m_sNewInstClassPath.Empty();
}
}
else {
m_pViewStack->PushView();
}
m_pTitleBar->Refresh();
UpdateWindow();
return;
}
//**************************************************************
// CWBEMViewContainerCtrl::ShowInstances
//
// This is the automation interface for specifying a set of instances
// to view. Call this interface to select the multiple instance view
// and load it with a set of instances.
//
// Parameters:
// [in] LPCTSTR pszTitle
// The view title.
//
// const VARIANT FAR& varPathArray
// An variant array containing the HMOM paths to the instances.
//
// Returns:
// Nothing.
//
//****************************************************************
void CWBEMViewContainerCtrl::ShowInstances(LPCTSTR pszTitle, const VARIANT FAR& varPathArray)
{
m_bEmptyContainer = FALSE;
CMultiView* pmv = m_pview->GetMultiView();
try
{
// TODO: Add your dispatch handler code here
if (pmv == NULL) {
// If the multi-view control isn't available, there is nothing
// that can be done here.
ASSERT(FALSE);
}
// Show the MultiView
CWaitCursor wait;
pmv->ViewInstances(pszTitle, varPathArray);
m_pview->ShowMultiView();
if (m_bInStudioMode) {
m_pTitleBar->EnableButton(ID_CMD_SWITCH_VIEW, FALSE);
// We are switching to the multiple instance view, so set the button
// check state to appear as if it is pressed.
m_pTitleBar->CheckButton(ID_CMD_SWITCH_VIEW, TRUE);
}
m_pTitleBar->EnableButton(ID_CMD_FILTERS, FALSE);
m_pTitleBar->NotifyObjectChanged();
m_pview->RedrawWindow();
InvalidateControl();
m_pViewStack->PushView();
}
catch(CException* )
{
}
}
//********************************************************************
// CWBEMViewContainerCtrl::QueryViewInstances
//
//
// Parameters:
// LPCTSTR pszLabel
//
// LPCTSTR pszQueryType
//
// LPCTSTR pszQuery
//
// LPCTSTR pszClass
//
// Returns:
// Nothing.
//
//********************************************************************
void CWBEMViewContainerCtrl::QueryViewInstances(
LPCTSTR pszLabel,
LPCTSTR pszQueryType,
LPCTSTR pszQuery,
LPCTSTR pszClass)
{
try
{
CMultiView* pmv = m_pview->GetMultiView();
if (pmv == NULL || pmv->m_hWnd==NULL) {
// If the multi-view control isn't available, there is nothing
// that can be done here.
ASSERT(FALSE);
}
m_pViewStack->UpdateView();
// First check to see if there are any changes and, if so,
// ask the user whether or not he or she wants to save them.
SCODE sc;
sc = SaveState(TRUE, TRUE);
if (FAILED(sc)) {
return;
}
if (m_pview->IsShowingSingleview() && (sc == WBEM_S_FALSE)) {
m_pview->GetSingleView()->SelectObjectByPath(_T(""));
}
CWaitCursor wait;
COleVariant varTitle;
varTitle = pszLabel;
ASSERT(varTitle.vt == VT_BSTR);
pmv->QueryViewInstances(pszLabel, pszQueryType, pszQuery, pszClass);
m_pview->ShowMultiView();
if (m_bInStudioMode) {
m_pTitleBar->EnableButton(ID_CMD_SWITCH_VIEW, FALSE);
// We are switching to the multiple instance view, so set the button
// check state to appear as if it is pressed.
m_pTitleBar->CheckButton(ID_CMD_SWITCH_VIEW, TRUE);
}
else {
CSingleView* psv = m_pview->GetSingleView();
psv->SelectObjectByPath(_T(""));
}
m_pTitleBar->EnableButton(ID_CMD_FILTERS, FALSE);
m_pTitleBar->NotifyObjectChanged();
// Somehow the singleview is becoming visible when it shouldn't, so show the
// multiview again.
m_pview->ShowMultiView();
// InvalidateControl();
}
catch(CException* )
{
}
}
#if 0
// Disable global context menu per bug #4222
//***************************************************************
// CWBEMViewContainerCtrl::OnContextMenu
//
// This method displays the context menu. It is called from
// PretranslateMessage.
//
// Parameters:
// CWnd* pwnd
// Pointer to the window that the event that triggered the
// menu occurred in.
//
// CPoint ptScreen
// The point, in screen coordinates, where the context menu
// should be displayed.
//
// Returns:
// Nothing.
//
//*****************************************************************
void CWBEMViewContainerCtrl::OnContextMenu(CWnd* pwnd, CPoint ptScreen)
{
// CG: This function was added by the Pop-up Menu component
CPoint ptClient = ptScreen;
ScreenToClient(&ptClient);
// If the mouse was right-clicked outside the client rectangle do nothing.
CRect rcClient;
GetClientRect(rcClient);
if (!rcClient.PtInRect(ptClient)) {
return;
}
// If the mouse was right-clicked over the toolbar buttons, do nothing.
CRect rcTools;
m_pTitleBar->GetToolBarRect(rcTools);
m_pTitleBar->ClientToScreen(rcTools);
if (rcTools.PtInRect(ptScreen)) {
return;
}
CMenu menu;
VERIFY(menu.LoadMenu(CG_IDR_POPUP_HMMV_CTRL));
CMenu* pPopup = menu.GetSubMenu(0);
ASSERT(pPopup != NULL);
pPopup->EnableMenuItem(ID_CMD_SHOW_OBJECT_ATTRIBUTES, MF_ENABLED);
CWnd* pWndPopupOwner = this;
pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, ptScreen.x, ptScreen.y,
pWndPopupOwner);
}
BOOL CWBEMViewContainerCtrl::PreTranslateMessage(MSG* pMsg)
{
BOOL bInvokeContextMenu = FALSE;
// Shift+F10: show pop-up menu.
switch(pMsg->message) {
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
switch(pMsg->wParam) {
case VK_F10:
if ((GetKeyState(VK_SHIFT) & ~1) != 0) {
bInvokeContextMenu = TRUE;
}
break;
case VK_TAB:
// When you see the tab key in your control's pretranslate
// message you know that IE is telling you to go ui active
// and allowing you to give your control focus because the
// user just tabbed into your control. A vb form
// behaves the same way.
SetFocus();
break;
}
break;
case WM_CONTEXTMENU:
bInvokeContextMenu = TRUE;
break;
}
if (bInvokeContextMenu) {
CRect rect;
GetClientRect(rect);
ClientToScreen(rect);
CPoint point = rect.TopLeft();
point.Offset(5, 5);
OnContextMenu(NULL, point);
return TRUE;
}
return COleControl::PreTranslateMessage(pMsg);
}
// End of context menu disabling
#endif //0
void CWBEMViewContainerCtrl::OnCmdShowObjectAttributes()
{
ASSERT(FALSE);
// ShowObjectAttributes();
}
void CWBEMViewContainerCtrl::OnStatusCodeChanged()
{
// TODO: Add notification handler code
SetModifiedFlag();
}
BSTR CWBEMViewContainerCtrl::GetNameSpace()
{
return m_sNameSpace.AllocSysString();
}
void CWBEMViewContainerCtrl::SetNameSpace(LPCTSTR lpszNameSpace)
{
//return; // VBSCRIPT_ERROR
BOOL bDelayToolbarUpdateSave = m_bDelayToolbarUpdate;
m_bDelayToolbarUpdate = TRUE;
m_sNameSpace = lpszNameSpace;
if (!::IsWindow(m_hWnd)) {
return;
}
if (!m_bEmptyContainer) {
m_pViewStack->PushView();
}
delete m_pViewStack;
m_pViewStack = new CViewStack(this);
CDisableViewStack DisableViewStack(m_pViewStack);
m_pview->SetNamespace(lpszNameSpace);
m_varObjectPath = "";
m_bEmptyContainer = TRUE;
ShowMultiView(FALSE, FALSE);
m_pTitleBar->Refresh();
m_bDelayToolbarUpdate = bDelayToolbarUpdateSave;
}
void CWBEMViewContainerCtrl::InvalidateControlRect(CRect* prc)
{
InvalidateControl(prc);
}
DWORD CWBEMViewContainerCtrl::GetActivationPolicy( )
{
return POINTERINACTIVE_ACTIVATEONENTRY |
POINTERINACTIVE_DEACTIVATEONLEAVE |
POINTERINACTIVE_ACTIVATEONDRAG;
}
//***********************************************************
// CWBEMViewContainerCtrl::GetCurrentClass
//
// Get a path to the current class. This is used when
// we need to know what the class is when creating a
// new instance.
//
// Parameters:
// COleVariant& varClass
//
// Returns:
// SCODE
// S_OK if successful, E_FAIL if there is no current class.
//
//**************************************************************
SCODE CWBEMViewContainerCtrl::GetCurrentClass(COleVariant& varClass)
{
CString sPath = m_pview->GetObjectPath(OBJECT_CURRENT);
if (sPath.IsEmpty()) {
return E_FAIL;
}
CBSTR bsPath(sPath);
BSTR bstrPath = (BSTR) bsPath;
SCODE sc = ClassFromPath(varClass, bstrPath);
return sc;
}
//************************************************************
// CWBEMViewContainerCtrl::CreateInstance
//
// Create an instance of the current class.
//
// Parameters:
// None.
//
// Returns:
// Nothing.
//
//*************************************************************
void CWBEMViewContainerCtrl::CreateInstance()
{
if (!InStudioMode()) {
ASSERT(FALSE); // Control should never come here.
return;
}
SCODE sc;
// Save the state of the current object before attempting to
// create a new one. Do nothing if the user cancels the save.
sc = SaveState(TRUE, TRUE);
if (FAILED(sc)) {
return;
}
CSingleView* psv = m_pview->GetSingleView();
BOOL bCanCreateInstance = psv->QueryCanCreateInstance();
if (!bCanCreateInstance) {
ASSERT(FALSE);
return;
}
// When an instance is created, the multiple instance and the custom
// view should be notified so that they can display the correct information.
//
// Maybe I should set a flag to indicate whether or not the new instance
// needs to be passed to the multiple instance view or custom view when
// switching views.
CString sClassPathSave;
sClassPathSave = m_sNewInstClassPath;
sc = psv->GetClassPath(m_sNewInstClassPath);
ASSERT(SUCCEEDED(sc));
sc = psv->CreateInstance(m_sNewInstClassPath);
if (SUCCEEDED(sc)) {
// !!!CR: We need to notify the multiple instance view when
// !!!CR: a new instance has been created, but since the
// !!!CR: instance hasn't been written to the database yet
// !!!CR: there is nothing to notify them of yet.
m_bObjectIsNewlyCreated = TRUE;
ShowMultiView(FALSE, FALSE);
SetModifiedFlag(TRUE);
m_pTitleBar->EnableButton(ID_CMD_SAVE_DATA, TRUE);
m_pTitleBar->Refresh();
UpdateCreateDeleteButtonState();
m_pViewStack->PushView();
}
else {
m_sNewInstClassPath = sClassPathSave;
}
psv->SetFocus();
UpdateWindow();
}
//****************************************************************
// CWBEMViewContainerCtrl::DeleteInstance
//
// Delete the currently selected instance amd coordinate the deletion with
// the child views.
//
// Parameters:
// None.
//
// Returns:
// Nothing.
//
//****************************************************************
void CWBEMViewContainerCtrl::DeleteInstance()
{
if (!InStudioMode()) {
ASSERT(FALSE); // Control should never come here.
return;
}
CMultiView* pmv = m_pview->GetMultiView();
CSingleView* psv = m_pview->GetSingleView();
SCODE sc;
CString sClassPath;
sc = psv->GetClassPath(sClassPath);
if (FAILED(sc)) {
sClassPath.Empty();
}
long lPos;
lPos = pmv->StartObjectEnumeration(OBJECT_CURRENT);
CString sPath;
sPath = m_pview->GetObjectPath(lPos);
CString sTitle;
sTitle = m_pview->GetObjectTitle(lPos);
// Prompt the user to verify that it is OK to delete the
// current object.
CString sFormat;
sFormat.LoadString(IDS_QUERY_DELETE_OBJECT);
CString sCaption;
if (::PathIsClass(sPath)) {
sCaption = _T("Deleting a Class");
}
else {
sCaption = _T("Deleting an Instance");
}
_stprintf(m_szMessageBuffer, (LPCTSTR) sFormat, (LPCTSTR) sTitle);
PreModalDialog( );
CWnd* pwndFocus = GetFocus();
int iMsgBoxStatus = ::MessageBox(m_hWnd, m_szMessageBuffer, (LPCTSTR) _T("Deleting an Instance"), MB_YESNO | MB_SETFOREGROUND | MB_ICONQUESTION);
if (pwndFocus && ::IsWindow(pwndFocus->m_hWnd)) {
pwndFocus->SetFocus();
}
PostModalDialog();
UpdateWindow();
if (iMsgBoxStatus != IDYES) {
return;
}
sc = m_pview->DeleteInstance();
if (FAILED(sc)) {
return;
}
BOOL bDeletedCurrentView = m_pViewStack->PurgeView(sPath);
// Get the current view's concept of the currently selected instance.
// It may be the case that the current view doesn't have any instance
// selected - for example, a class might be selected.
//
// Note that when switching to a view, the single container should enable
// or disable the "delete instance" button depending on whether or not
// that view has a selected instance to delete.
//
// Views should notify the container when the current selection
// changes.
if (bDeletedCurrentView) {
m_pViewStack->RefreshView();
}
else {
if (!m_pview->IsShowingMultiview()) {
if (m_bObjectIsNewlyCreated) {
if (m_pViewStack->CanGoBack()) {
Clear(FALSE);
m_pViewStack->GoBack();
}
else {
Clear();
}
m_pViewStack->TrimStack();
return;
}
}
}
if (SUCCEEDED(sc)) {
// NotifyInstanceDeleted does not work, so instead we just tell
// the multiview control to refresh all of its data.
COleVariant varObjectPath;
varObjectPath = sPath;
NotifyInstanceDeleted(varObjectPath);
if (m_pview->IsShowingMultiview()) {
CSingleView* psv = m_pview->GetSingleView();
sPath = m_pview->GetObjectPath(OBJECT_CURRENT);
psv->SelectObjectByPath(sPath);
m_pViewStack->UpdateView();
}
else {
if (m_pViewStack->CanGoBack()) {
Clear(FALSE);
m_pViewStack->GoBack();
}
else {
Clear();
}
m_pViewStack->TrimStack();
}
}
if (m_pview->IsShowingMultiview()) {
long lPos = pmv->StartObjectEnumeration(OBJECT_FIRST);
if (lPos < 0 && !sClassPath.IsEmpty()) {
// The multiview is empty because we deleted the last item.
// We need to select the class into the singleview so that
// we can still create an instance.
psv->SelectObjectByPath(sClassPath);
ShowMultiView(TRUE, FALSE);
m_pViewStack->UpdateView();
}
}
UpdateToolbar();
}
//*****************************************************************************
// CWBEMViewContainerCtrl::NotifyContainerOfSelectionChange
//
// This method is called when the selection is changed in one of the child views
// and the child view fires this event.
//
// This method is necessary to allow the container to enable or disable the
// "delete instance" button.
//
// Parameters:
// int idView
// The view id so that the container knows whether or not the selection
// changed in the currently active view.
//
// Returns:
// Nothing.
//
//*****************************************************************************
void CWBEMViewContainerCtrl::NotifyContainerOfSelectionChange()
{
}
SCODE CWBEMViewContainerCtrl::ContextForward()
{
if (m_pViewStack->CanGoForward()) {
m_pViewStack->GoForward();
return S_OK;
}
else {
return E_FAIL;
}
}
SCODE CWBEMViewContainerCtrl::ContextBack()
{
if (m_pViewStack->CanGoBack()) {
BOOL bObjectWasNewlyCreated = m_bObjectIsNewlyCreated;
m_pViewStack->GoBack();
if (bObjectWasNewlyCreated) {
// If the object was newly created and the user opted not
// to save it, trim the context stack so that the user
// can't attempt to go back to the object that was discarded.
m_pViewStack->TrimStack();
}
return S_OK;
}
else {
return E_FAIL;
}
}
//***********************************************************************
// CWBEMViewContainerCtrl::QueryCanContextForward
//
// Check to see if it is OK to go forward a step on the view context stack.
// If the current object is modified, an attempt is made to save its state
// before approving the change in view context.
//
// Parameters:
// None.
//
// Returns:
// BOOL
// TRUE if it is OK to go forward to the "next" entry on the view
// stack. FALSE if there is no next entry or the user cancels saving
// the current object if it was modified.
//
//
//************************************************************************
BOOL CWBEMViewContainerCtrl::QueryCanContextForward()
{
SCODE sc;
sc = SaveState(TRUE, TRUE);
if (FAILED(sc)) {
// The user canceled the save, so abort the change of view context.
return FALSE;
}
return m_pViewStack->CanGoForward();
}
//***********************************************************************
// CWBEMViewContainerCtrl::QueryCanContextBack
//
// Check to see if it is OK to go back a step on the view context stack.
// If the current object is modified, an attempt is made to save its state
// before approving the change in view context.
//
// Parameters:
// None.
//
// Returns:
// BOOL
// TRUE if it is OK to go back to the "previous" entry on the view
// stack. FALSE if there is no next entry or the user cancels saving
// the current object if it was modified.
//
//
//************************************************************************
BOOL CWBEMViewContainerCtrl::QueryCanContextBack()
{
SCODE sc;
sc = SaveState(TRUE, TRUE);
if (FAILED(sc)) {
// The user canceled the save, so abort the change of view context.
return FALSE;
}
return m_pViewStack->CanGoBack();
}
long CWBEMViewContainerCtrl::GetStudioModeEnabled()
{
// TODO: Add your property handler here
return m_bInStudioMode;
}
void CWBEMViewContainerCtrl::SetStudioModeEnabled(long bInStudioMode)
{
// SetNotSupported
BOOL bWasInStudioMode = m_bInStudioMode;
m_bInStudioMode = bInStudioMode;
if ((bInStudioMode && !bWasInStudioMode) || (!bInStudioMode && bWasInStudioMode)) {
delete m_pViewStack;
m_pViewStack = new CViewStack(this);
delete m_pview;
m_pview = new CPolyView(this);
m_pview->SetStudioModeEnabled(bInStudioMode);
CRect rcView;
CalcViewRect(rcView);
BOOL bDidCreate;
bDidCreate = m_pview->Create(rcView);
if (!bDidCreate) {
InvalidateControl(); // Must do this!
return;
}
m_pview->SetFont(m_font);
ShowMultiView(FALSE, FALSE);
if (!m_sNameSpace.IsEmpty()) {
m_pview->SetNamespace(m_sNameSpace);
}
if (::IsWindow(m_pTitleBar->m_hWnd)) {
m_pTitleBar->LoadToolBar();
}
}
SetModifiedFlag();
InvalidateControl(); // Must do this!
}
void CWBEMViewContainerCtrl::GetContainerContext(CContainerContext& ctx)
{
ctx.m_bIsShowingMultiView = m_pview->IsShowingMultiview();
ctx.m_bObjectIsNewlyCreated = m_bObjectIsNewlyCreated;
ctx.m_bEmptyContainer = m_bEmptyContainer;
ctx.m_hwndFocus = ::GetFocus();
}
//***********************************************************
// CWBEMViewContainerCtrl::SetContainerContextPrologue
//
// This method is called to begin the restoration of the
// container's view context. It is the first call that is
// made to restore the context.
//
// Parameters:
// [in] CContainerContext& ctx
// The container context that was saved previously.
//
// Returns:
// SCODE
// S_OK if successful, E_FAIL if there was an attempt to
// restore the container to an invalid state. When E_FAIL
// is returned, the CViewStack will remove this context entry
// from the stack.
//
//************************************************************
SCODE CWBEMViewContainerCtrl::SetContainerContextPrologue(CContainerContext& ctx)
{
return S_OK;
}
//***********************************************************
// CWBEMViewContainerCtrl::SetContainerContextEpilogue
//
// This method is called to complete the restoration of the
// container's view context. It is called after SetContainerPrologue
// and the context for the generic view and multiview have been
// restored.
//
// Parameters:
// [in] CContainerContext& ctx
// The container context that was saved previously.
//
// Returns:
// SCODE
// S_OK if successful, E_FAIL if there was an attempt to
// restore the container to an invalid state. When E_FAIL
// is returned, the CViewStack will remove this context entry
// from the stack.
//
//************************************************************
SCODE CWBEMViewContainerCtrl::SetContainerContextEpilogue(CContainerContext& ctx)
{
m_bObjectIsNewlyCreated = ctx.m_bObjectIsNewlyCreated;
m_bEmptyContainer = ctx.m_bEmptyContainer;
m_pTitleBar->Refresh();
if (::IsWindow(ctx.m_hwndFocus) && ::IsWindowVisible(ctx.m_hwndFocus)) {
::SetFocus(ctx.m_hwndFocus);
}
return S_OK;
}
void CWBEMViewContainerCtrl::PushView()
{
m_pViewStack->PushView();
}
void CWBEMViewContainerCtrl::UpdateViewContext()
{
m_pViewStack->UpdateView();
}
DWORD CWBEMViewContainerCtrl::GetControlFlags( )
{
return clipPaintDC;
}
//************************************************************
// CWBEMViewContainerCtrl::SelectView
//
// Select a sub-view.
//
// Parameters:
// long lView
// The view position returned from the view enumerator.
//
// Returns:
// Nothing.
//
//************************************************************
void CWBEMViewContainerCtrl::SelectView(long lPosition)
{
SCODE sc;
long lPositionCurrent = m_pview->StartViewEnumeration(VIEW_CURRENT);
if (lPosition == lPositionCurrent) {
return;
}
sc = m_pview->SelectView(lPosition);
ASSERT(SUCCEEDED(sc));
m_pViewStack->PushView();
UpdateWindow();
}
void CWBEMViewContainerCtrl::PassThroughGetIHmmServices
(LPCTSTR lpctstrNamespace, VARIANT FAR* pvarUpdatePointer, VARIANT FAR* pvarServices, VARIANT FAR* pvarSC, VARIANT FAR* pvarUserCancel)
{
// TODO: Add your dispatch handler code here
FireGetIWbemServices(lpctstrNamespace, pvarUpdatePointer, pvarServices, pvarSC, pvarUserCancel);
}
void CWBEMViewContainerCtrl::RequestUIActive()
{
// TODO: Add your control notification handler code here
if(m_bCreationFinished)
OnActivateInPlace(TRUE,NULL);
FireRequestUIActive();
}
void CWBEMViewContainerCtrl::OnSetFocus(CWnd* pOldWnd)
{
COleControl::OnSetFocus(pOldWnd);
// Next statements are only logic I need to know how to draw myself
// when I lose focus. Your logic may be more complicated.
// You want to activate yourself.
if (!m_bUIActive)
{
m_bUIActive = TRUE;
RequestUIActive();
}
InvalidateControl(); // Must do this!
}
void CWBEMViewContainerCtrl::OnKillFocus(CWnd* pNewWnd)
{
COleControl::OnKillFocus(pNewWnd);
// TODO: Add your message handler code here
// Next statements are only logic I need to know how to draw myself
// when I lose focus. Your logic may be more complicated.
// You want to deactivate yourself.
m_bUIActive = FALSE;
OnActivateInPlace(FALSE,NULL); // Must do this!
InvalidateControl();
}
//**********************************************************
// CWBEMViewContainerCtrl::InvokeHelp
//
// Invoke help for the currently selected object.
//
// Parameters:
// None.
//
// Returns:
// Nothing.
//
//**********************************************************
void CWBEMViewContainerCtrl::OnHelp()
{
COleVariant varObjectPath;
CString sObjectPath;
long lPos;
if (m_pview->IsShowingSingleview()) {
CSingleView* psv = m_pview->GetSingleView();
lPos = psv->StartObjectEnumeration(OBJECT_CURRENT);
if (lPos >= 0) {
varObjectPath = psv->GetObjectPath(lPos);
sObjectPath = varObjectPath.bstrVal;
}
else {
sObjectPath = m_varObjectPath.bstrVal;
}
}
else {
CMultiView* pmv = m_pview->GetMultiView();
lPos = pmv->StartObjectEnumeration(OBJECT_CURRENT);
if (lPos >= 0) {
varObjectPath = pmv->GetObjectPath(lPos);
sObjectPath = varObjectPath.bstrVal;
}
else {
sObjectPath = m_varObjectPath.bstrVal;
}
}
m_pdlgHelpBox->ShowHelpForClass(this, sObjectPath);
}
void CWBEMViewContainerCtrl::InvokeHelp()
{
OnHelp();
return;
}
BOOL CWBEMViewContainerCtrl::Create(LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext)
{
// TODO: Add your specialized code here and/or call the base class
dwStyle |= WS_CLIPCHILDREN;
return CWnd::Create(lpszClassName, lpszWindowName, dwStyle, rect, pParentWnd, nID, pContext);
}
BOOL CWBEMViewContainerCtrl::OnEraseBkgnd(CDC* pDC)
{
CRect rcClient;
GetClientRect(rcClient);
CBrush br(GetSysColor(COLOR_3DFACE));
pDC->FillRect(rcClient, &br);
return TRUE;
// return COleControl::OnEraseBkgnd(pDC);
}
BOOL CWBEMViewContainerCtrl::PreTranslateMessage(MSG* pMsg)
{
// TODO: Add your specialized code here and/or call the base class
switch(pMsg->message) {
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
switch(pMsg->wParam) {
case VK_TAB:
// When you see the tab key in your control's pretranslate
// message you know that IE is telling you to go ui active
// and allowing you to give your control focus because the
// user just tabbed into your control. A vb form
// behaves the same way.
SetFocus();
return FALSE;
break;
}
break;
}
BOOL bDidTranslate;
bDidTranslate = COleControl::PreTranslateMessage(pMsg);
if (bDidTranslate) {
return bDidTranslate;
}
// bug #51022 - Should call PreTranslateMessage, not PreTranslateInput
return COleControl::PreTranslateMessage (pMsg);
}
long CWBEMViewContainerCtrl::GetPropertyFilter()
{
return m_lPropFilters;
}
//**********************************************************
// CWBEMViewContainerCtrl::SetPropertyFilters
//
// Invoke help for the currently selected object.
//
// Parameters:
// [in] lPropFilters
// PROPFILTER_SYSTEM 1
// PROPFILTER_INHERITED 2
// PROPFILTER_LOCAL 4
//
//
// Returns:
// Nothing.
//
//**********************************************************
void CWBEMViewContainerCtrl::SetPropertyFilter(long nNewValue)
{
m_lPropFilters = nNewValue;
if (m_pview != NULL) {
m_pview->SetPropertyFilters(nNewValue);
}
}
CWnd* CWBEMViewContainerCtrl::ReestablishFocus()
{
if (m_pview != NULL) {
CWnd* pwndFocusPrev = m_pview->SetFocus();
return pwndFocusPrev;
}
return NULL;
}
void CWBEMViewContainerCtrl::GetWbemServices(LPCTSTR szNamespace, VARIANT FAR* pvarUpdatePointer, VARIANT FAR* pvarServices, VARIANT FAR* pvarSc, VARIANT FAR* pvarUserCancel)
{
FireGetIWbemServices(szNamespace, pvarUpdatePointer, pvarServices, pvarSc, pvarUserCancel);
}
//**********************************************************
// CWBEMViewContainerCtrl::Query
//
// Display query dialog and run query
//
//
//**********************************************************
void CWBEMViewContainerCtrl::Query() {
// Save the state of the current object before attempting to
// run the query.
CWaitCursor wait;
BOOL bSwitchViewChecked = m_pTitleBar->IsButtonChecked(ID_CMD_SWITCH_VIEW);
BOOL bWasShowingSingleView = m_pview->IsShowingSingleview();
BOOL bWasNewlyCreatedInst = FALSE;
CString sClassPath;
CSingleView* psv = m_pview->GetSingleView();
SCODE sc = S_OK;
if (m_pview->IsShowingSingleview()) {
// Save the state only if we are flipping from the
// singleview to the multiview. This prevents a
// the save from being done when a new object is
// pre-selected into the singleview prior to displaying
// it so that things appear quickly.
sc = SaveState(TRUE, TRUE);
if (FAILED(sc)) {
m_pTitleBar->CheckButton(ID_CMD_SWITCH_VIEW, FALSE);
return;
}
else if (sc == WBEM_S_FALSE) {
// The user chose not to save changes when flipping to the
// multiview. This means that we need to reselect the
// current path into the singleview so that we revert back
// to the initial state of the object.
CString sObjectPath;
sObjectPath = m_varObjectPath.bstrVal;
psv->SelectObjectByPath(sObjectPath);
}
if (m_bObjectIsNewlyCreated) {
bWasNewlyCreatedInst = TRUE;
sClassPath = m_sNewInstClassPath;
}
}
//Now, execute the query
CDlgExecQuery dlg(this);
int iResult = (int) dlg.DoModal();
if (iResult == IDOK) {
CMultiView* pmv = m_pview->GetMultiView();
pmv->QueryViewInstances(dlg.m_sQueryName, _T("WQL"), dlg.m_sQueryString, _T(""));
ShowMultiView(TRUE, TRUE);
}
if (bWasShowingSingleView && bWasNewlyCreatedInst) {
if (sc == WBEM_S_FALSE && !sClassPath.IsEmpty()) {
// The user chose not to save the newly created instance, so
// we need to select the class so that when the user sees the
// multiview, the create instance button will be enabled
// if appropriate.
psv->SelectObjectByPath(m_sNewInstClassPath);
m_pViewStack->UpdateView();
m_bObjectIsNewlyCreated = FALSE;
m_sNewInstClassPath.Empty();
}
}
else {
m_pViewStack->PushView();
}
m_pTitleBar->Refresh();
UpdateWindow();
}
Reference in New Issue View Git Blame Copy Permalink