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

2870 lines
64 KiB
C++
Raw Blame History

// ***************************************************************************
//
// Copyright (c) 1996-2001 Microsoft Corporation, All Rights Reserved
//
// File: NavigatorCtl.cpp
//
// Description:
// This file implements the CNavigatorCtrl ActiveX control class.
// The CNavigatorCtl class is a part of the Instance Navigator OCX, it
// is a subclass of the Mocrosoft COleControl class and performs
// the following functions:
// a.
// b.
// c.
//
// Part of:
// Navigator.ocx
//
// Used by:
//
//
// History:
// Judith Ann Powell 10-08-96 Created.
//
//
// **************************************************************************
// ===========================================================================
//
// Includes
//
// ===========================================================================
// \\PEPPER\root\DEFAULT:Win32ComputerSystem.Name="PEPPER"
#include "precomp.h"
#include <OBJIDL.H>
#include "resource.h"
#include "wbemidl.h"
#include "CInstanceTree.h"
#include "Navigator.h"
#include "CContainedToolBar.h"
#include "Banner.h"
#include "InstanceSearch.h"
#include "AvailClasses.h"
#include "AvailClassEdit.h"
#include "SelectedClasses.h"
#include "SimpleSortedCStringArray.h"
#include "BrowseforInstances.h"
#include "nsentry.h"
#include "InstNavNSEntry.h"
#include "InitNamespaceNSEntry.h"
#include "InitNamespaceDialog.h"
#include "NavigatorCtl.h"
#include "NavigatorPpg.h"
#include "PathDialog.h"
#include "ProgDlg.h"
#include "OLEMSCLient.h"
#include <genlex.h>
#include <opathlex.h>
#include <objpath.h>
// ===========================================================================
//
// Externs
//
// ===========================================================================
extern CNavigatorApp NEAR theApp;
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
// ===========================================================================
//
// Dynamic creation
//
// ===========================================================================
IMPLEMENT_DYNCREATE(CNavigatorCtrl, COleControl)
IMPLEMENT_DYNCREATE (CTreeItemData, CObject)
// ===========================================================================
//
// Message map
//
// ===========================================================================
BEGIN_MESSAGE_MAP(CNavigatorCtrl, COleControl)
//{{AFX_MSG_MAP(CNavigatorCtrl)
ON_WM_CREATE()
ON_WM_SIZE()
ON_WM_DESTROY()
ON_COMMAND(ID_SETROOT, OnSetroot)
ON_UPDATE_COMMAND_UI(ID_SETROOT, OnUpdateSetroot)
ON_COMMAND(ID_POPUP_MULTIINSTANCEVIEWER, OnPopupMultiinstanceviewer)
ON_UPDATE_COMMAND_UI(ID_POPUP_MULTIINSTANCEVIEWER, OnUpdatePopupMultiinstanceviewer)
ON_WM_GETDLGCODE()
ON_COMMAND(ID_POPUP_INSTANCESEARCH, OnPopupInstancesearch)
ON_COMMAND(ID_POPUP_PARENTASSOCIATION, OnPopupParentassociation)
ON_UPDATE_COMMAND_UI(ID_POPUP_PARENTASSOCIATION, OnUpdatePopupParentassociation)
ON_MESSAGE( ID_MULTIINSTANCEVIEW, SendInstancesToMultiInstanceViewer )
ON_MESSAGE( ID_SETTREEROOT , SetNewRoot)
ON_MESSAGE( INIT_TREE_FOR_DRAWING, InitializeTreeForDrawing)
ON_WM_LBUTTONUP()
ON_COMMAND(ID_POPUP_BROWSE, OnPopupBrowse)
ON_UPDATE_COMMAND_UI(ID_POPUP_BROWSE, OnUpdatePopupBrowse)
ON_COMMAND(ID_POPUP_GOTONAMESPACE, OnPopupGotonamespace)
ON_UPDATE_COMMAND_UI(ID_POPUP_GOTONAMESPACE, OnUpdatePopupGotonamespace)
ON_COMMAND(ID_POPUP_REFRESH, OnPopupRefresh)
ON_UPDATE_COMMAND_UI(ID_POPUP_REFRESH, OnUpdatePopupRefresh)
ON_COMMAND(ID_MENUITEMINITIALROOT, OnMenuiteminitialroot)
ON_UPDATE_COMMAND_UI(ID_MENUITEMINITIALROOT, OnUpdateMenuiteminitialroot)
ON_WM_KILLFOCUS()
ON_WM_SETFOCUS()
//}}AFX_MSG_MAP
ON_OLEVERB(AFX_IDS_VERB_EDIT, OnEdit)
ON_OLEVERB(AFX_IDS_VERB_PROPERTIES, OnProperties)
ON_MESSAGE(INITIALIZE_NAMESPACE, InitializeNamespace )
ON_MESSAGE(INVALIDATE_CONTROL, Invalidate)
ON_MESSAGE(REDRAW_CONTROL, RedrawAll)
ON_MESSAGE(SETFOCUS, SetFocus)
ON_MESSAGE(SETFOCUSNSE, SetFocusNSE)
END_MESSAGE_MAP()
// ===========================================================================
//
// Dispatch map
//
// ===========================================================================
BEGIN_DISPATCH_MAP(CNavigatorCtrl, COleControl)
//{{AFX_DISPATCH_MAP(CNavigatorCtrl)
DISP_PROPERTY_EX(CNavigatorCtrl, "NameSpace", GetNameSpace, SetNameSpace, VT_BSTR)
DISP_FUNCTION(CNavigatorCtrl, "OnReadySignal", OnReadySignal, VT_EMPTY, VTS_NONE)
DISP_FUNCTION(CNavigatorCtrl, "ChangeRootOrNamespace", ChangeRootOrNamespace, VT_I4, VTS_BSTR VTS_I4 VTS_I4)
//}}AFX_DISPATCH_MAP
DISP_FUNCTION_ID(CNavigatorCtrl, "AboutBox", DISPID_ABOUTBOX, AboutBox, VT_EMPTY, VTS_NONE)
END_DISPATCH_MAP()
// ===========================================================================
//
// Event map
//
// ===========================================================================
BEGIN_EVENT_MAP(CNavigatorCtrl, COleControl)
//{{AFX_EVENT_MAP(CNavigatorCtrl)
EVENT_CUSTOM("NotifyOpenNameSpace", FireNotifyOpenNameSpace, VTS_BSTR)
EVENT_CUSTOM("ViewObject", FireViewObject, VTS_BSTR)
EVENT_CUSTOM("ViewInstances", FireViewInstances, VTS_BSTR VTS_VARIANT)
EVENT_CUSTOM("QueryViewInstances", FireQueryViewInstances, VTS_BSTR VTS_BSTR VTS_BSTR VTS_BSTR)
EVENT_CUSTOM("GetIWbemServices", FireGetIWbemServices, VTS_BSTR VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT)
//}}AFX_EVENT_MAP
END_EVENT_MAP()
// ===========================================================================
//
// Property Pages
//
// ===========================================================================
BEGIN_PROPPAGEIDS(CNavigatorCtrl, 1)
PROPPAGEID(CNavigatorPropPage::guid)
END_PROPPAGEIDS(CNavigatorCtrl)
// ===========================================================================
//
// Class factory and guid
//
// ===========================================================================
IMPLEMENT_OLECREATE_EX(CNavigatorCtrl, "WBEM.InstNavCtrl.1",
0xc7eadeb3, 0xecab, 0x11cf, 0x8c, 0x9e, 0, 0xaa, 0, 0x6d, 0x1, 0xa)
// ===========================================================================
//
// Type library ID and version
//
// ===========================================================================
IMPLEMENT_OLETYPELIB(CNavigatorCtrl, _tlid, _wVerMajor, _wVerMinor)
// ===========================================================================
//
// Interface IDs
//
// ===========================================================================
const IID BASED_CODE IID_DNavigator =
{ 0xc7eadeb1, 0xecab, 0x11cf, { 0x8c, 0x9e, 0, 0xaa, 0, 0x6d, 0x1, 0xa } };
const IID BASED_CODE IID_DNavigatorEvents =
{ 0xc7eadeb2, 0xecab, 0x11cf, { 0x8c, 0x9e, 0, 0xaa, 0, 0x6d, 0x1, 0xa } };
// ===========================================================================
//
// Control type information
//
// ===========================================================================
static const DWORD BASED_CODE _dwNavigatorOleMisc =
OLEMISC_ACTIVATEWHENVISIBLE |
OLEMISC_SETCLIENTSITEFIRST |
OLEMISC_INSIDEOUT |
OLEMISC_CANTLINKINSIDE |
OLEMISC_RECOMPOSEONRESIZE;
IMPLEMENT_OLECTLTYPE(CNavigatorCtrl, IDS_NAVIGATOR, _dwNavigatorOleMisc)
// ===========================================================================
//
// Control font height
//
// ===========================================================================
#define CY_FONT 15
// ***************************************************************************
//
// CNavigatorCtrl::CNavigatorCtrlFactory::UpdateRegistry
//
// Description:
// Adds or removes system registry entries for CNavigatorCtrl.
//
// Parameters:
// BOOL bRegister Register if TRUE; Unregister if FALSE.
//
// Returns:
// BOOL TRUE on success
// FALSE on failure
//
// Globals accessed:
// NONE
//
// Globals modified:
// NONE
//
// ***************************************************************************
BOOL CNavigatorCtrl::CNavigatorCtrlFactory::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 afxRegInsertable.
if (bRegister)
return AfxOleRegisterControlClass(
AfxGetInstanceHandle(),
m_clsid,
m_lpszProgID,
IDS_NAVIGATOR,
IDB_NAVIGATOR,
afxRegInsertable | afxRegApartmentThreading,
_dwNavigatorOleMisc,
_tlid,
_wVerMajor,
_wVerMinor);
else
return AfxOleUnregisterClass(m_clsid, m_lpszProgID);
}
// ***************************************************************************
//
// CNavigatorCtrl::CNavigatorCtrlFactory::OnCreateObject
//
// Description:
// Called by the framework to create a new object. Override this function to
// create the object from something other than the CRuntimeClass passed to the
// constructor. Stub generated by the OLE control wizard.
//
//
// Parameters:
// NONE
//
// Returns:
// CCmdTarget* Pointer to object created.
//
// Globals accessed:
// NONE
//
// Globals modified:
// NONE
//
// ***************************************************************************
CCmdTarget* CNavigatorCtrl::CNavigatorCtrlFactory::OnCreateObject()
{
return COleObjectFactory::OnCreateObject();
}
// ***************************************************************************
//
// CNavigatorCtrl::CNavigatorCtrl
//
// Description:
// Class constructor.
//
// Parameters:
// NONE
//
// Returns:
// NONE
//
// Globals accessed:
// NONE
//
// Globals modified:
// NONE
//
// ***************************************************************************
CNavigatorCtrl::CNavigatorCtrl()
{
InitializeIIDs(&IID_DNavigator, &IID_DNavigatorEvents);
m_bInit = FALSE;
m_bChildrenCreated = FALSE;
m_pcilImageList = NULL;
m_nOffset = 2;
m_bMetricSet = FALSE;
m_pcbiBrowseDialog = NULL;
m_pProgressDlg = NULL;
m_bDrawAll = FALSE;
m_csBanner = _T("Objects in: ");
m_pctidHit = NULL;
m_pServices = NULL;
m_bFirstDraw = TRUE;
m_pServices = NULL;
m_pAuxServices = NULL;
m_bInOnDraw = FALSE;
m_bUserCancelInitialSystemObject = FALSE;
m_bUserCancel = FALSE;
m_bOpeningNamespace = FALSE;
m_bTreeEmpty = TRUE;
m_csFontName = _T("MS Shell Dlg");
m_nFontHeight = CY_FONT;
m_nFontWeigth = FW_NORMAL;
m_bRefresh = FALSE;
m_bFireEvents = TRUE;
m_bRestoreFocusToTree = TRUE;
m_bReadySignal = FALSE;
AfxEnableControlContainer();
}
// ***************************************************************************
//
// CNavigatorCtrl::~CNavigatorCtrl
//
// Description:
// Class destructor.
//
// Parameters:
// NONE
//
// Returns:
// NONE
//
// Globals accessed:
// NONE
//
// Globals modified:
// NONE
//
// ***************************************************************************
CNavigatorCtrl::~CNavigatorCtrl()
{
delete m_pcbiBrowseDialog;
delete m_pProgressDlg;
if (m_pServices)
{
m_pServices -> Release();
}
if (m_pAuxServices)
{
m_pAuxServices -> Release();
}
m_bInit = FALSE;
m_pcilImageList = NULL;
m_nOffset = 2;
m_bMetricSet = FALSE;
// m_ppdPathDialog = NULL;
m_pctidHit = NULL;
}
// ***************************************************************************
//
// CNavigatorCtrl::OnDraw
//
// Description:
// Drawing member function for screen device.
//
// Parameters:
// CDC *pDC The device context in which the drawing occurs.
// CRect &rcBounds The rectangular area of the control, including the
// border.
// CRect &rcInvalid The rectangular area of the control that is invalid.
//
// Returns:
// void
//
// Globals accessed:
// NONE
//
// Globals modified:
// NONE
//
// ***************************************************************************
void CNavigatorCtrl::OnDraw(
CDC* pdc, const CRect& rcBounds, const CRect& rcInvalid)
{
if (m_bInOnDraw)
{
return;
}
if (GetSafeHwnd()) {
CBrush br3DFACE(GetSysColor(COLOR_3DFACE));
pdc->FillRect(rcBounds, &br3DFACE);
}
pdc -> SetMapMode (MM_TEXT);
pdc -> SetWindowOrg(0,0);
COLORREF dwBackColor = GetSysColor(COLOR_3DFACE);
COLORREF crWhite = RGB(255,255,255);
COLORREF crGray = GetSysColor(COLOR_3DHILIGHT);
COLORREF crDkGray = GetSysColor(COLOR_3DSHADOW);
COLORREF crBlack = GetSysColor(COLOR_WINDOWTEXT);
if (m_bUserCancelInitialSystemObject || m_bUserCancel)
{
m_bUserCancelInitialSystemObject = FALSE;
CRect rcOutline(rcBounds);
rcOutline = m_rTreeRect;
pdc -> Draw3dRect(&rcOutline, crBlack, crGray);
return;
}
m_bInOnDraw = TRUE;
if (!AmbientUserMode() || !GetSafeHwnd())
{
m_bInOnDraw = FALSE;
return;
}
if (m_bDrawAll == FALSE)
{
CRect rcOutline(rcBounds);
rcOutline = m_rBannerRect;
rcOutline = m_rTreeRect;
pdc -> Draw3dRect(&rcOutline, crBlack, crGray);
}
else
{
CFont* pOldFont;
if (m_bFirstDraw)
{
m_bFirstDraw = FALSE;
CWnd::SetFont ( &m_cfFont , FALSE);
pOldFont = pdc -> SelectObject( &m_cfFont );
InitializeChildControlSize(rcBounds.Width(), rcBounds.Height());
}
pOldFont = pdc -> SelectObject( &m_cfFont );
CRect rcOutline(rcBounds);
rcOutline = m_rBannerRect;
rcOutline = m_rTreeRect;
pdc -> Draw3dRect(&rcOutline, crBlack, crGray);
pdc->SelectObject(pOldFont);
m_ctcTree.ShowWindow(SW_SHOW);
m_cbBannerWindow.ShowWindow(SW_SHOW);
}
if (m_ctcTree.GetRootItem() == NULL && !m_bTreeEmpty)
{
PostMessage(INIT_TREE_FOR_DRAWING,0,0);
}
else
{
InitializeTreeForDrawing(TRUE);
}
m_cbBannerWindow.ShowWindow(SW_SHOWNA);
m_ctcTree.ShowWindow(SW_SHOWNA);
if (m_bRefresh)
{
PostMessage(REDRAW_CONTROL,0,0);
}
m_bInOnDraw = FALSE;
}
void CNavigatorCtrl::CreateControlFont()
{
if (!m_bMetricSet) // Create the font used by the control.
{
CDC *pdc = CWnd::GetDC( );
pdc -> SetMapMode (MM_TEXT);
pdc -> SetWindowOrg(0,0);
LOGFONT lfFont;
InitializeLogFont
(lfFont, m_csFontName,m_nFontHeight, m_nFontWeigth);
m_cfFont.CreateFontIndirect(&lfFont);
CWnd::SetFont ( &m_cfFont , FALSE);
CFont* pOldFont = pdc -> SelectObject( &m_cfFont );
pdc->GetTextMetrics(&m_tmFont);
pdc -> SelectObject(pOldFont);
m_bMetricSet = TRUE;
ReleaseDC(pdc);
}
}
void CNavigatorCtrl::InitializeLogFont
(LOGFONT &rlfFont, CString csName, int nHeight, int nWeight)
{
_tcscpy(rlfFont.lfFaceName, (LPCTSTR) csName);
rlfFont.lfWeight = nWeight;
rlfFont.lfHeight = nHeight;
rlfFont.lfWidth = 0;
rlfFont.lfQuality = DEFAULT_QUALITY;
rlfFont.lfPitchAndFamily = DEFAULT_PITCH | FF_SWISS;
rlfFont.lfEscapement = 0;
rlfFont.lfOrientation = 0;
rlfFont.lfWidth = 0;
rlfFont.lfItalic = FALSE;
rlfFont.lfUnderline = FALSE;
rlfFont.lfStrikeOut = FALSE;
rlfFont.lfOutPrecision = OUT_DEFAULT_PRECIS;
rlfFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
}
LRESULT CNavigatorCtrl::InitializeTreeForDrawing(WPARAM wParam, LPARAM lParam)
{
if (!m_ctcTree.GetRootItem() && !m_bTreeEmpty)
{
InitializeTreeForDrawing();
}
else
{
InvalidateControl();
}
return 0;
}
void CNavigatorCtrl::InitializeTreeForDrawing(BOOL bNoTreeRoot)
{
if (!m_bInit)
{
m_bInit = TRUE;
int iReturn;
HICON hIconOpen = theApp.LoadIcon(IDI_ICONOPEN);
HICON hIconClosed = theApp.LoadIcon(IDI_ICONCLOSED);
HICON hIconInstance = theApp.LoadIcon(IDI_ICONINSTANCE);
HICON hIconNEInstance = theApp.LoadIcon(IDI_ICONNEINSTANCE);
HICON hIconGroup = theApp.LoadIcon(IDI_ICONGROUP);
HICON hIconEGroup = theApp.LoadIcon(IDI_ICONEGROUP);
HICON hIconAssocRole = theApp.LoadIcon(IDI_ICONASSOCROLE);
HICON hIconEAssocRole = theApp.LoadIcon(IDI_ICONEASSOCROLE);
HICON hIconAssocInstance = theApp.LoadIcon(IDI_ICONASSOCINSTANCE);
HICON hIconClass = theApp.LoadIcon(IDI_ICONCLASS);
HICON hIconAssocRoleWeak = theApp.LoadIcon(IDI_ICONASSOCROLEWEAK);
HICON hIconAssocRoleWeak2 = theApp.LoadIcon(IDI_ICONASSOCROLEWEAK2);
m_pcilImageList = new CImageList();
m_pcilImageList ->
Create(16, 16, TRUE, IconClass(), IconClass());
iReturn = m_pcilImageList -> Add(hIconInstance);
iReturn = m_pcilImageList -> Add(hIconNEInstance);
iReturn = m_pcilImageList -> Add(hIconGroup);
iReturn = m_pcilImageList -> Add(hIconEGroup);
iReturn = m_pcilImageList -> Add(hIconAssocRole);
iReturn = m_pcilImageList -> Add(hIconEAssocRole);
iReturn = m_pcilImageList -> Add(hIconAssocInstance);
iReturn = m_pcilImageList -> Add(hIconOpen);
iReturn = m_pcilImageList -> Add(hIconClosed);
iReturn = m_pcilImageList -> Add(hIconClass);
iReturn = m_pcilImageList -> Add(hIconAssocRoleWeak);
iReturn = m_pcilImageList -> Add(hIconAssocRoleWeak2);
// This image list is maintained by the ctreectrl.
CImageList *pcilOld = m_ctcTree.CTreeCtrl::SetImageList
(m_pcilImageList,TVSIL_NORMAL);
delete pcilOld;
}
if (!bNoTreeRoot)
{
InitializeTreeRoot();
}
}
void CNavigatorCtrl::InitializeTreeRoot()
{
// Add the root to the tree.
CString csRoot;
IWbemClassObject *pimcoRoot = NULL;
if (m_bOpeningNamespace)
{
return;
}
if (m_csRootPath.GetLength() == 0)
{
csRoot = GetInitialSystemObject();
if (csRoot.GetLength() == 0)
{
m_ctcTree.ResetTree();
InvalidateControl();
}
else
{
m_csRootPath = csRoot;
}
}
else
{
pimcoRoot = GetIWbemObject
(this,m_pServices,
GetCurrentNamespace(),
GetAuxNamespace(),
GetAuxServices(),
m_csRootPath,FALSE);
if (!pimcoRoot)
{
csRoot = GetInitialSystemObject();
if (csRoot.GetLength() == 0)
{
m_ctcTree.ResetTree();
InvalidateControl();
}
else
{
m_csRootPath = GetIWbemFullPath(m_pServices, pimcoRoot);
}
}
}
if (m_csRootPath.GetLength() == 0)
{
m_bDrawAll = TRUE;
InvalidateControl();
return;
}
if (pimcoRoot)
{
pimcoRoot->Release();
}
m_ctcTree.AddInitialObjectInstToTree
(m_csRootPath);
m_bDrawAll = TRUE;
InvalidateControl();
}
CString CNavigatorCtrl::GetInitialSystemObject()
{
if (!m_pcbiBrowseDialog)
{
if (m_pServices == NULL)
{
PostMessage(INITIALIZE_NAMESPACE,0,0);
}
PostMessage(INIT_TREE_FOR_DRAWING,0,0);
InvalidateControl();
return "";
}
else if (m_pcbiBrowseDialog->GetSafeHwnd())
{
return "";
}
else if (!m_pServices)
{
return "";
}
CString csRootObjectPath = _T("NamespaceConfiguration");
CPtrArray *pInstances =
GetInstances(m_pServices, &csRootObjectPath, m_csNameSpace, FALSE, TRUE);
CString csSpecifiedPath;
int i;
for (i = 0; i < pInstances->GetSize(); i++)
{
IWbemClassObject *pObject =
reinterpret_cast<IWbemClassObject *>
(pInstances->GetAt(i));
if (i == 0)
{
CString csProp = _T("BrowserRootPath");
csSpecifiedPath =
GetBSTRProperty
(pObject, &csProp);
}
pObject ->Release();
}
delete pInstances;
if (!csSpecifiedPath.IsEmpty())
{
m_bTreeEmpty = FALSE;
return csSpecifiedPath;
}
CString csDefault = _T("CIM_ComputerSystem");
pInstances =
GetInstances(m_pServices, &csDefault, m_csNameSpace, TRUE, TRUE);
for (i = 0; i < pInstances->GetSize(); i++)
{
IWbemClassObject *pObject =
reinterpret_cast<IWbemClassObject *>
(pInstances->GetAt(i));
if (i == 0)
{
csSpecifiedPath =
GetIWbemFullPath
(m_pServices,pObject);
}
pObject ->Release();
}
delete pInstances;
if (!csSpecifiedPath.IsEmpty())
{
m_bTreeEmpty = FALSE;
SCODE sc = CreateNamespaceConfigClassAndInstance
(m_pServices,&m_csNameSpace, &csSpecifiedPath);
return csSpecifiedPath;
}
PreModalDialog();
m_pcbiBrowseDialog->SetServices(m_pServices);
m_pcbiBrowseDialog->SetTMFont(&m_tmFont);
m_pcbiBrowseDialog->SetParent(this);
m_pcbiBrowseDialog->SetMode(CBrowseforInstances::InitialObject);
m_pcbiBrowseDialog->DoModal();
m_ctcTree.SetFocus();
PostModalDialog();
if (m_pcbiBrowseDialog -> m_csSelectedInstancePath.IsEmpty())
{
m_bTreeEmpty = TRUE;
m_ctcTree.UnCacheTools();
m_ctcTree.ResetTree();
m_bUserCancelInitialSystemObject = TRUE;
InvalidateControl();
return _T("");
}
else
{
csSpecifiedPath =
m_pcbiBrowseDialog -> m_csSelectedInstancePath;
m_bTreeEmpty = FALSE;
SCODE sc = CreateNamespaceConfigClassAndInstance
(m_pServices,&m_csNameSpace, &csSpecifiedPath);
return csSpecifiedPath;
}
}
BOOL CNavigatorCtrl::OpenNameSpace(CString *pcsNameSpace)
{
IWbemServices *pServices = InitServices(pcsNameSpace);
if (pServices)
{
if (m_pServices)
{
m_pServices -> Release();
}
m_pServices = pServices;
m_csNameSpace = *pcsNameSpace;
if (m_bReadySignal)
{
FireNotifyOpenNameSpace(*pcsNameSpace);
}
CString csRoot = GetInitialSystemObject();
SetNewRoot(csRoot);
PostMessage(INVALIDATE_CONTROL,0,0);
return TRUE;
}
else
{
CString csPrompt = _T("Cannot open ") + *pcsNameSpace +
_T(". ");
int nReturn =
MessageBox
(
csPrompt,
_T("Namespace Open Error"),
MB_OK | MB_ICONEXCLAMATION | MB_DEFBUTTON1 |
MB_APPLMODAL);
InvalidateControl();
return FALSE;
}
}
// ***************************************************************************
//
// CNavigatorCtrl::OnDrawMetafile
//
// Description:
// Drawing member function for Metafile device.
//
// Parameters:
// CDC *pDC The device context in which the drawing occurs.
// CRect &rcBounds The rectangular area of the control, including the
// border.
//
// Returns:
// void
//
// Globals accessed:
// NONE
//
// Globals modified:
// NONE
//
// ***************************************************************************
void CNavigatorCtrl::OnDrawMetafile(CDC* pDC, const CRect& rcBounds)
{
CRect rcOutline(rcBounds);
rcOutline.DeflateRect( 1, 1, 1, 1);
pDC-> Rectangle( &rcBounds);
}
// ***************************************************************************
//
// CNavigatorCtrl::DoPropExchange
//
// Description:
// Control property persistence support. Called by the framework when
// loading or storing a control from a persistent storage representation,
// such as a stream or property set.
//
// Parameters:
// CPropExchange* pPX Context of the property exchange, including its
// direction.
//
// Returns:
// void
//
// Globals accessed:
// NONE
//
// Globals modified:
// NONE
//
// ***************************************************************************
void CNavigatorCtrl::DoPropExchange(CPropExchange* pPX)
{
ExchangeVersion(pPX, MAKELONG(_wVerMinor, _wVerMajor));
COleControl::DoPropExchange(pPX);
PX_String(pPX, _T("RootPath"), m_csRootPath, _T(""));
PX_String(pPX, _T("NameSpace"), m_csNameSpace, _T(""));
}
// ***************************************************************************
//
// CNavigatorCtrl::AboutBox
//
// Description:
// Display an "About" box to the user.
//
// Parameters:
// NONE
//
// Returns:
// void
//
// Globals accessed:
// NONE
//
// Globals modified:
// NONE
//
// ***************************************************************************
void CNavigatorCtrl::AboutBox()
{
CDialog dlgAbout(IDD_ABOUTBOX_NAVIGATOR);
dlgAbout.DoModal();
}
LRESULT CNavigatorCtrl::Invalidate(WPARAM, LPARAM)
{
m_cbBannerWindow.Invalidate();
m_cbBannerWindow.PostMessage(WM_PAINT,0,0);
return 0;
}
// ***************************************************************************
//
// CNavigatorCtrl::InitializeNamespace
//
// Description:
// If we are in AmbientUserMode initialize the state of the control.
//
// Parameters:
// NONE
//
// Returns:
// void
//
// Globals accessed:
// NONE
//
// Globals modified:
// NONE
//
// ***************************************************************************
LRESULT CNavigatorCtrl::InitializeNamespace(WPARAM, LPARAM)
{
if (AmbientUserMode( ) && m_bOpeningNamespace == FALSE)
{
int cx;
int cy;
GetControlSize(&cx,&cy);
InitializeChildren(cx,cy);
m_pServices = NULL;
m_bOpeningNamespace = TRUE;
m_bOpeningNamespace = FALSE;
if (m_pServices != NULL)
{
m_pServices->Release();
}
m_pServices = NULL;
m_pServices = InitServices(&m_csNameSpace);
if (m_bUserCancel)
{
InvalidateControl();
return 0;
}
if (!m_pServices)
{
CString csUserMsg;
if (m_sc == 0x8001010e)
{
csUserMsg =
_T("You cannot open another Object Browser window. Please close this web page.");
//ErrorMsg
// (&csUserMsg, S_OK, NULL, TRUE, &csUserMsg, __FILE__, __LINE__ - 10);
CString csTitle = _T("WMI Object Browser");
MessageBox(csUserMsg,csTitle);
return 0;
}
else
{
if (!m_csNameSpace.IsEmpty())
{
csUserMsg =
_T("Cannot open namespace ");
csUserMsg += m_csNameSpace;
ErrorMsg
(&csUserMsg, m_sc, NULL, TRUE, &csUserMsg, __FILE__, __LINE__ - 10);
}
return 0;
}
}
m_cbBannerWindow.OpenNamespace(&m_csNameSpace,TRUE);
if (m_bReadySignal)
{
FireNotifyOpenNameSpace(m_csNameSpace);
}
m_ctcTree.InitTreeState(this);
InvalidateControl();
SetModifiedFlag();
}
return 0;
}
// ***************************************************************************
//
// CNavigatorCtrl::InitializeChildren
//
// Description:
// Initializes the child control (edit, button and tree control) sizes.
//
// Parameters:
// int cx Width
// int cy Height
//
// Returns:
// void
//
// Globals accessed:
// NONE
//
// Globals modified:
// NONE
//
// ***************************************************************************
void CNavigatorCtrl::InitializeChildren(int cx, int cy)
{
if (!m_bChildrenCreated)
{
m_pcbiBrowseDialog = new CBrowseforInstances(this);
m_pProgressDlg = new CProgressDlg;
m_pProgressDlg->SetActiveXParent(this);
SetChildControlGeometry(cx, cy);
m_bChildrenCreated = TRUE;
if (m_ctcTree.Create (TVS_HASLINES| TVS_LINESATROOT,
m_rTree, this , IDC_TREE ) == -1)
return;
m_cbBannerWindow.SetParent(this);
if (m_cbBannerWindow.Create(NULL, _T("BannerCWnd"), WS_CHILD | WS_VISIBLE
,m_rBannerRect, this,
IDC_TOOLBAR) == -1)
{
return;
}
}
}
// ***************************************************************************
//
// CNavigatorCtrl::InitializeChildControlSize
//
// Description:
// Initializes the child control (edit, button and tree control) sizes.
//
// Parameters:
// int cx Width
// int cy Height
//
// Returns:
// void
//
// Globals accessed:
// NONE
//
// Globals modified:
// NONE
//
// ***************************************************************************
void CNavigatorCtrl::InitializeChildControlSize(int cx, int cy)
{
if (!m_bChildrenCreated)
{
m_bChildrenCreated = TRUE;
m_pcbiBrowseDialog = new CBrowseforInstances(this);
m_pProgressDlg = new CProgressDlg;
m_pProgressDlg->SetActiveXParent(this);
if (m_ctcTree.Create (TVS_HASLINES| TVS_LINESATROOT,
m_rTree, this , IDC_TREE ) == -1)
return;
m_cbBannerWindow.SetParent(this);
if (m_cbBannerWindow.Create(NULL, _T("BannerCWnd"), WS_CHILD | WS_VISIBLE
,m_rBannerRect, this,
IDC_TOOLBAR) == -1)
{
return;
}
m_ctcTree.InitTreeState(this);
}
SetChildControlGeometry(cx, cy);
m_cbBannerWindow.MoveWindow(m_rBannerRect);
m_ctcTree.MoveWindow(m_rTree);
}
// ***************************************************************************
//
// CNavigatorCtrl::SetChildControlGeometry
//
// Description:
// Set the geometry of the children controls based upon font size for the
// edit and button controls. Remainder goes to the tree control.
//
// Parameters:
// int cx Width
// int cy Height
//
// Returns:
// void
//
// Globals accessed:
// NONE
//
// Globals modified:
// NONE
//
// ***************************************************************************
void CNavigatorCtrl::SetChildControlGeometry(int cx, int cy)
{
if (cx == 0 && cy == 0)
{
m_rBannerRect = CRect(0, 0, 300, 300);
m_rTreeRect = CRect (0, 0, 0, 0);
m_rTree = CRect(0, 0, 0, 0);
return;
}
CreateControlFont();
int nBannerHeight = (m_tmFont.tmHeight) + 20;
m_rBannerRect = CRect( 0 ,
0 ,
cx ,
nBannerHeight);
m_rTreeRect = CRect ( nSideMargin,
nBannerHeight + m_nOffset,
cx - (nSideMargin + 1) ,
cy - nTopMargin);
m_rTree = CRect( nSideMargin + 1,
nBannerHeight + m_nOffset + 1,
cx - (nSideMargin + 2),
cy - (nTopMargin + 1));
}
void CNavigatorCtrl::SetNewRoot(CString &rcsRoot)
{
if (rcsRoot.GetLength() > 0)
{
CWaitCursor wait;
m_ctcTree.UnCacheTools();
m_ctcTree.ResetTree();
m_ctcTree.AddInitialObjectInstToTree (rcsRoot);
m_csRootPath = rcsRoot;
InvalidateControl();
SetModifiedFlag();
}
}
// ***************************************************************************
//
// CNavigatorCtrl::OnSetRoot
//
// Description:
// Handles the context menu's set root operation.
//
// Parameters:
// NONE
//
// Returns:
// void
//
// Globals accessed:
// NONE
//
// Globals modified:
// NONE
//
// ***************************************************************************
void CNavigatorCtrl::OnSetroot()
{
CWaitCursor wait;
CString csRoot = m_pctidHit -> GetAt(0);
m_ctcTree.UnCacheTools();
m_ctcTree.ResetTree();
m_ctcTree.AddInitialObjectInstToTree (csRoot);
m_csRootPath = csRoot;
InvalidateControl();
SetModifiedFlag();
}
// ***************************************************************************
//
// CNavigatorCtrl::OnUpdateSetroot
//
// Description:
// Enables or disables the context menu's set root item.
//
// Parameters:
// CCmdUI* pCmdUI Pointer to the handler for the menu item.
//
// Returns:
// NONE
//
// Globals accessed:
// NONE
//
// Globals modified:
// NONE
//
// ***************************************************************************
void CNavigatorCtrl::OnUpdateSetroot(CCmdUI* pCmdUI)
{
CString csObject = m_pctidHit ? m_pctidHit->GetAt(0) : _T("");
if (csObject.GetLength() > 0 &&
m_pctidHit -> m_nType == CTreeItemData::ObjectInst)
{
pCmdUI -> Enable( TRUE );
}
else
{
pCmdUI -> Enable( FALSE );
}
}
// ***************************************************************************
//
// CNavigatorCtrl::OnCreate
//
// Description:
// Called by the framework after the window is being created but before
// the window is shown.
//
// Parameters:
// LPCREATESTRUCT lpCreateStruct Pointer to the structure which contains
// default parameters.
//
// Returns:
// BOOL 0 if continue; -1 if the window should be destroyed.
//
// Globals accessed:
// NONE
//
// Globals modified:
// NONE
//
// ***************************************************************************
int CNavigatorCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
lpCreateStruct->style |= WS_CLIPCHILDREN;
if (COleControl::OnCreate(lpCreateStruct) == -1)
return -1;
return 0;
}
// ***************************************************************************
//
// CNavigatorCtrl::OnSize
//
// Description:
// Called by the framework after the window is being resized.
//
// Parameters:
// UINT nType Specifies the type of resizing requested.
// int cx Specifies the new width of the client area.
// int cy Specifies the new height of the client area.
//
// Returns:
// void
//
// Globals accessed:
// NONE
//
// Globals modified:
// NONE
//
// ***************************************************************************
void CNavigatorCtrl::OnSize(UINT nType, int cx, int cy)
{
if (!GetSafeHwnd())
{
return;
}
COleControl::OnSize(nType, cx, cy);
if (!m_bMetricSet) // Create the font used by the control.
{
CreateControlFont();
}
SetChildControlGeometry(cx, cy);
if (!m_bChildrenCreated)
{
m_bChildrenCreated = TRUE;
m_pcbiBrowseDialog = new CBrowseforInstances(this);
m_pProgressDlg = new CProgressDlg;
m_pProgressDlg->SetActiveXParent(this);
if (m_ctcTree.Create (TVS_HASLINES| TVS_LINESATROOT,
m_rTree, this , IDC_TREE ) == -1)
return;
m_cbBannerWindow.SetParent(this);
if (m_cbBannerWindow.Create(NULL, _T("BannerCWnd"), WS_CHILD | WS_VISIBLE
,m_rBannerRect, this,
IDC_TOOLBAR) == -1)
{
return;
}
m_ctcTree.CWnd::SetFont ( &m_cfFont , FALSE);
m_cbBannerWindow.CWnd::SetFont ( &m_cfFont , FALSE);
m_ctcTree.InitTreeState(this);
}
m_cbBannerWindow.MoveWindow(m_rBannerRect,TRUE);
m_ctcTree.MoveWindow(m_rTree,TRUE);
InvalidateControl();
m_bRefresh = TRUE;
// PostMessage(REDRAW_CONTROL,0,0);
}
LRESULT CNavigatorCtrl::RedrawAll(WPARAM, LPARAM)
{
m_cbBannerWindow.UpdateWindow();
m_ctcTree.UpdateWindow();
m_cbBannerWindow.RedrawWindow();
m_ctcTree.RedrawWindow();
if (m_bRefresh)
{
m_bRefresh = FALSE;
}
else
{
m_bRefresh = TRUE;
}
Refresh();
return 0;
}
// ***************************************************************************
//
// CNavigatorCtrl::OnDestroy
//
// Description:
// Called by the framework after the window is removed from the screen but
// before it is destroyed. Deinitialize data that cannot be deinitialized
// in the destructor.
//
// Parameters:
// NONE
//
// Returns:
// void
//
// Globals accessed:
// NONE
//
// Globals modified:
// NONE
//
// ***************************************************************************
void CNavigatorCtrl::OnDestroy()
{
m_ctcTree.ResetTree();
delete m_pcilImageList;
COleControl::OnDestroy();
}
LRESULT CNavigatorCtrl::SendInstancesToMultiInstanceViewer(WPARAM, LPARAM)
{
// CWaitCursor wait;
OnPopupMultiinstanceviewer();
PostMessage(SETFOCUS,0,0);
return 0;
}
LRESULT CNavigatorCtrl::SetNewRoot(WPARAM wParam, LPARAM lParam)
{
IWbemClassObject *pObject =
reinterpret_cast<IWbemClassObject *>(lParam);
CString csPath = GetIWbemFullPath(GetServices(),pObject);
SetNewRoot(csPath);
pObject->Release();
return 0;
}
void CNavigatorCtrl::OnPopupMultiinstanceviewer()
{
if(!m_hHit)
{
return;
}
// 10/08/97 - For now we will send over queries. 10453.
//if (m_pctidHit -> m_nType == CTreeItemData::ObjectGroup &&
// m_ctcTree.GetItemState( m_hHit, TVIF_STATE ) & TVIS_EXPANDEDONCE)
//{
// MultiInstanceViewFromTreeChildren();
//}
//else
if (m_pctidHit -> m_nType == CTreeItemData::ObjectGroup )
{
MultiInstanceViewFromObjectGroup();
}
else if (m_pctidHit -> m_nType == CTreeItemData::AssocRole)
{
MultiInstanceViewFromAssocRole();
}
}
void CNavigatorCtrl::MultiInstanceViewFromTreeChildren()
{
TV_ITEM tvItem;
tvItem.hItem = m_hHit;
tvItem.mask = TVIF_CHILDREN | TVIF_HANDLE;
BOOL bReturn = m_ctcTree.GetItem( &tvItem );
int cChildren = tvItem.mask & TVIF_CHILDREN ? tvItem.cChildren : 0;
if (cChildren == 0)
{
return;
}
cChildren = m_ctcTree.GetNumChildren(m_hHit);
SAFEARRAY *psa;
MakeSafeArray(&psa,VT_BSTR, cChildren + 1);
CString csGroup = m_ctcTree.GetItemText(m_hHit);
PutStringInSafeArray(psa, &csGroup, 0);
HTREEITEM hChild = m_ctcTree.GetChildItem( m_hHit );
CString csPath;
int i = 1;
while (hChild)
{
CTreeItemData *pctidItem =
reinterpret_cast<CTreeItemData *>(m_ctcTree.GetItemData(hChild));
if (pctidItem)
{
CString csItem =
pctidItem -> GetAt(0);
if (csItem.GetLength() > 0)
{
PutStringInSafeArray(psa, &csItem, i++);
}
}
hChild = m_ctcTree.GetNextSiblingItem(hChild);
}
VARIANTARG var;
VariantInit(&var);
var.vt = VT_ARRAY | VT_BSTR;
var.parray = psa;
COleVariant covOut(var);
CString csLabel = m_ctcTree.GetItemText(m_hHit);
csLabel += _T(" Object Group");
if (m_bReadySignal)
{
FireViewInstances((LPCTSTR)csLabel,covOut) ;
}
VariantClear(&var);
}
void CNavigatorCtrl::MultiInstanceViewFromObjectGroup()
{
CString csQuery =
m_ctcTree.GetObjectGroupInstancesQuery(m_hHit, m_pctidHit);
if (csQuery.IsEmpty() || csQuery.GetLength() == 0)
{
return;
}
CString csLabel = m_ctcTree.GetItemText(m_hHit);
//CString csClass = csLabel; 10/08/97 10453. Do not send over class.
CString csClass;
csLabel += _T(" Object Group");
CString csQueryType = _T("WQL");
if (m_bReadySignal)
{
FireQueryViewInstances
((LPCTSTR)csLabel,(LPCTSTR)csQueryType,
(LPCTSTR)csQuery,(LPCTSTR) csClass);
}
}
void CNavigatorCtrl::MultiInstanceViewFromAssocRole()
{
// can use GetObjectClassForRole to get the role's class.
CString csQuery =
m_ctcTree.GetAssocRoleInstancesQuery(m_hHit, m_pctidHit);
CString csAssoc = GetIWbemClass(m_pctidHit -> GetAt(0));
CString csText = m_ctcTree.GetItemText(m_hHit);
int nRoleBegin = csText.Find('.');
CString csRole = csText.Right(csText.GetLength() - (nRoleBegin + 1));
IWbemClassObject *pimcoAssoc = GetIWbemObject
(this,m_pServices,
GetCurrentNamespace(),
GetAuxNamespace(),
GetAuxServices(),
csAssoc,FALSE);
if (csQuery.IsEmpty() || csQuery.GetLength() == 0)
{
return;
}
CString csObjectClassForRole;
if (pimcoAssoc)
{
// 10/08/97 10453. Do not send over class.
//csObjectClassForRole = GetObjectClassForRole(NULL,pimcoAssoc,&csRole);
pimcoAssoc->Release();
}
CString csLabel = m_ctcTree.GetItemText(m_hHit);
CString csClass = csObjectClassForRole;
CString csQueryType = _T("WQL");
if (m_bReadySignal)
{
FireQueryViewInstances
((LPCTSTR)csLabel,(LPCTSTR)csQueryType,
(LPCTSTR)csQuery,
(LPCTSTR) csClass);
}
}
void CNavigatorCtrl::OnUpdatePopupMultiinstanceviewer(CCmdUI* pCmdUI)
{
if (m_pctidHit && m_hHit &&
(m_pctidHit -> m_nType == CTreeItemData::ObjectGroup ||
m_pctidHit -> m_nType == CTreeItemData::AssocRole ))
{
pCmdUI -> Enable( TRUE );
}
else
{
pCmdUI -> Enable( FALSE );
}
}
BSTR CNavigatorCtrl::GetNameSpace()
{
return m_csNameSpace.AllocSysString();
}
void CNavigatorCtrl::SetNameSpace(LPCTSTR lpszNewValue)
{
CString csNameSpace = lpszNewValue;
if (GetSafeHwnd() && AmbientUserMode())
{
SCODE sc = m_cbBannerWindow.OpenNamespace(&csNameSpace,TRUE);
if (sc == S_OK)
{
if (m_pServices != NULL)
{
m_pServices->Release();
m_pServices = NULL;
}
m_pServices = InitServices(&csNameSpace);
if (!m_pServices)
{
CString csUserMsg =
_T("Cannot open namespace ");
csUserMsg += csNameSpace;
ErrorMsg
(&csUserMsg, S_OK, NULL, TRUE, &csUserMsg, __FILE__, __LINE__ - 10);
return;
}
if (m_bFireEvents && m_bReadySignal)
{
FireNotifyOpenNameSpace((LPCTSTR) csNameSpace);
}
m_csNameSpace = csNameSpace;
CString csRootPath = GetInitialSystemObject();
m_csRootPath = csRootPath;
if (m_csRootPath.GetLength() == 0)
{
m_ctcTree.UnCacheTools();
m_ctcTree.ResetTree();
m_bDrawAll = TRUE;
PostMessage(INVALIDATE_CONTROL,0,0);
return;
}
m_ctcTree.UnCacheTools();
m_ctcTree.ResetTree();
m_ctcTree.AddInitialObjectInstToTree
(m_csRootPath,m_bFireEvents);
m_bFireEvents = TRUE;
m_bDrawAll = TRUE;
PostMessage(INVALIDATE_CONTROL,0,0);
SetModifiedFlag();
}
}
else if (!AmbientUserMode())
{
m_csNameSpace = csNameSpace;
SetModifiedFlag();
}
}
UINT CNavigatorCtrl::OnGetDlgCode()
{
// If you're firing KeyPress, prevent the container from
// stealing WM_CHAR.
return COleControl::OnGetDlgCode() | DLGC_WANTALLKEYS ;
}
void CNavigatorCtrl::OnKeyDownEvent(USHORT nChar, USHORT nShiftState)
{
// TODO: Add your specialized code here and/or call the base class
COleControl::OnKeyDownEvent(nChar, nShiftState);
}
BOOL CNavigatorCtrl::PreTranslateMessage(LPMSG lpMsg)
{
BOOL bDidTranslate;
bDidTranslate = COleControl::PreTranslateMessage(lpMsg);
if (bDidTranslate)
{
return bDidTranslate;
}
switch (lpMsg->message)
{
case WM_KEYDOWN:
case WM_KEYUP:
if (lpMsg->wParam == VK_TAB)
{
return FALSE;
}
if (lpMsg->wParam == VK_ESCAPE)
{
TCHAR szClass[40];
CWnd* pWndFocus = GetFocus();
if (pWndFocus != NULL &&
IsChild(pWndFocus) &&
GetClassName(pWndFocus->m_hWnd, szClass, 39) &&
((_tcsicmp(szClass, _T("SysTreeView32")) == 0) ||
(_tcsicmp(szClass, _T("edit")) == 0)))
{
pWndFocus->SendMessage(lpMsg->message, lpMsg->wParam, lpMsg->lParam);
return TRUE;
}
}
if (lpMsg->wParam == VK_RETURN)
{
TCHAR szClass[40];
CWnd* pWndFocus = GetFocus();
if (!pWndFocus)
{
break;
}
CRect crEdit;
CRect crTree;
CRect crIntersect;
pWndFocus->GetWindowRect(&crEdit);
m_ctcTree.GetWindowRect(&crTree);
crEdit.NormalizeRect();
crTree.NormalizeRect();
BOOL bIntersect = crIntersect.IntersectRect(&crEdit,&crTree);
if (bIntersect &&
IsChild(pWndFocus) &&
GetClassName(pWndFocus->m_hWnd, szClass, 39) &&
((_tcsicmp(szClass, _T("SysTreeView32")) == 0) ||
(_tcsicmp(szClass, _T("edit")) == 0)))
{
pWndFocus->SendMessage(lpMsg->message, lpMsg->wParam, lpMsg->lParam);
return TRUE;
}
}
break;
}
return FALSE; // We already did COleControl::PreTranslateMessage
}
void CNavigatorCtrl::OnPopupInstancesearch()
{
}
void CNavigatorCtrl::OnPopupParentassociation()
{
// CWaitCursor wait;
CString csPath = ParentAssociation(m_hHit);
if (csPath.GetLength() > 0 && m_bReadySignal)
{
FireViewObject((LPCTSTR)csPath);
}
}
void CNavigatorCtrl::OnUpdatePopupParentassociation(CCmdUI* pCmdUI)
{
if (m_pctidHit && m_hHit && (m_ctcTree.GetRootItem() != m_hHit) &&
(m_pctidHit -> m_nType == CTreeItemData::ObjectInst ))
{
pCmdUI -> Enable( TRUE );
}
else
{
pCmdUI -> Enable( FALSE );
}
}
CString CNavigatorCtrl::ParentAssociation
(HTREEITEM hItem)
{
CTreeItemData *pctidItem =
reinterpret_cast<CTreeItemData *> (m_ctcTree.GetItemData(hItem));
if (!pctidItem)
{
return _T("");
}
CString csItem = pctidItem -> GetAt(0);
HTREEITEM hParent;
CString csAssoc = m_ctcTree.GetParentAssocFromTree(hItem,hParent);
CTreeItemData *pctidAssoc =
hParent?
reinterpret_cast<CTreeItemData *>(m_ctcTree.GetItemData(hParent)) : NULL;
if (!pctidAssoc)
{
return _T("");
}
CString csAssociatedObjectRole = pctidAssoc-> m_csMyRole;
HTREEITEM hAssociatedObject =
m_ctcTree.GetParentItem(hParent);
CTreeItemData *pctidAssociatedObject =
hAssociatedObject?
reinterpret_cast<CTreeItemData *>
(m_ctcTree.GetItemData(hAssociatedObject)) : NULL;
CString csAssociatedObject =
pctidAssociatedObject -> GetAt(0);
CString csAssocRole = m_ctcTree.GetItemText(hParent);
int nRoleBegin = csAssocRole.Find('.');
csAssoc = csAssocRole.Left(nRoleBegin);
CString csRole = csAssocRole.Right((csAssocRole.GetLength() - nRoleBegin) - 1);
CStringArray *pcsaAssocInstances = GetAssocInstances
(m_pServices, &csItem, &csAssoc, &csRole, m_csNameSpace,
m_csAuxNameSpace, m_pAuxServices, this);
CString csAssocInstReturn;
for (int i = 0; i < pcsaAssocInstances->GetSize(); i++)
{
CString csAssocInst = pcsaAssocInstances->GetAt(i);
CStringArray *pcsaAssocRolesAndPaths =
AssocPathRoleKey(&csAssocInst);
for (int n = 0; n < pcsaAssocRolesAndPaths->GetSize() ; n += 2)
{
CString csTestRole = pcsaAssocRolesAndPaths->GetAt(n);
CString csTestPath = pcsaAssocRolesAndPaths->GetAt(n + 1);
if (csTestRole.CompareNoCase(csAssociatedObjectRole) == 0 &&
csTestPath.CompareNoCase(csAssociatedObject) == 0)
{
csAssocInstReturn = csAssocInst;
break;
}
}
delete pcsaAssocRolesAndPaths;
}
delete pcsaAssocInstances;
return csAssocInstReturn;
}
void CNavigatorCtrl::OnReadySignal()
{
m_bReadySignal = TRUE;
if (m_pServices)
{
SetNameSpace(m_csNameSpace);
return;
}
InitializeNamespace(0,0);
InitializeTreeRoot();
HTREEITEM hItem = m_ctcTree.GetRootItem();
if (hItem)
{
CTreeItemData *pctidItem =
reinterpret_cast <CTreeItemData *> (m_ctcTree.GetItemData(hItem));
CString csPath = pctidItem->GetAt(0);
if (pctidItem && csPath.GetLength() > 0)
{
if (pctidItem -> m_nType == CTreeItemData::ObjectInst && m_bReadySignal)
{
FireViewObject((LPCTSTR)csPath);
}
}
}
}
//***********************************************************
// CComparePaths::CompareNoCase
//
//
// Do a case insensitive comparison of two wide strings. This
// compare works even when one or both of the string pointers are
// NULL. A NULL pointer is taken to be less than any real string,
// even an empty one.
//
// Parameters:
// [in] LPWSTR pws1
// Pointer to the first string. This pointer can be NULL.
//
// [in] LPWSTR pws2
// Pointer to the second string. This pointer can be NULL.
//
// Returns:
// int
// Greater than zero if string1 is greater than string2.
// Zero if the two strings are equal.
// Less than zero if string 1 is less than string2.
//
//**************************************************************
int CComparePaths::CompareNoCase(LPWSTR pws1, LPWSTR pws2)
{
// Handle the case where one, or both of the string pointers are NULL
if (pws1 == NULL) {
if (pws2 == NULL) {
return 0; // Two null strings are equal
}
else {
return -1; // A null string is less than any real string.
}
}
if (pws2 == NULL) {
if (pws1 != NULL) {
return 1; // Any string is greater than a null string.
}
}
ASSERT(pws1 != NULL);
ASSERT(pws2 != NULL);
int iResult;
iResult = _wcsicmp( pws1, pws2);
return iResult;
}
//***************************************************************
// CComparePath::NormalizeKeyArray
//
// The key array is normalized by sorting the KeyRef's by key name.
// After two key arrays are sorted, they can be compared without
// by iterating through the list of keys and comparing corresponding
// array entries rather than trying searching the arrays for corresponding
// key names and then comparing the key values.
//
// Parameters:
// [in, out] ParsedObjectPath& path
// The parsed object path containing the key array to sort.
//
// Returns:
// Nothing. (The key array is sorted as a side effect).
//
//*****************************************************************
void CComparePaths::NormalizeKeyArray(ParsedObjectPath& path)
{
// Do a simple bubble sort where the "KeyRefs" with the smallest
// names are bubbled towards the top and the the KeyRefs with the
// largest names are bubbled toward the bottom.
for (DWORD dwKey1 = 0; dwKey1 < path.m_dwNumKeys; ++dwKey1) {
for (DWORD dwKey2 = dwKey1 + 1; dwKey2 < path.m_dwNumKeys; ++dwKey2) {
ASSERT(path.m_paKeys[dwKey1] != NULL);
KeyRef* pkr1 = path.m_paKeys[dwKey1];
ASSERT(pkr1 != NULL);
ASSERT(path.m_paKeys[dwKey2] != NULL);
KeyRef* pkr2 = path.m_paKeys[dwKey2];
ASSERT(pkr2 != NULL);
int iResult = CompareNoCase(pkr1->m_pName, pkr2->m_pName);
if (iResult > 0) {
// Swap the two keys;
path.m_paKeys[dwKey1] = pkr2;
path.m_paKeys[dwKey2] = pkr2;
}
}
}
}
//***********************************************************************
// CComparePaths::KeyValuesAreEqual
//
// Compare two key values to determine whether or not they are equal.
// To be equal, they must both be of the same type and their values
// must also be equal.
//
// Parameters:
// [in] VARAINT& variant1
// The first key value.
//
// [in] VARIANT& variant2
// The second key value.
//
// Returns:
// TRUE if the two values are the same, FALSE otherwise.
//
//**********************************************************************
BOOL CComparePaths::KeyValuesAreEqual(VARIANT& v1, VARIANT& v2)
{
ASSERT(v1.vt == v2.vt);
ASSERT(v1.vt==VT_BSTR || v1.vt == VT_I4);
ASSERT(v2.vt==VT_BSTR || v2.vt == VT_I4);
// Key values should always be VT_BSTR or VT_I4. We special case these
// two types to be efficient and punt on all the other types.
BOOL bIsEqual;
switch(v1.vt) {
case VT_BSTR:
if (v2.vt == VT_BSTR) {
bIsEqual = IsEqual(v1.bstrVal, v2.bstrVal);
return bIsEqual;
}
else {
return FALSE;
}
break;
case VT_I4:
if (v2.vt == VT_I4) {
bIsEqual = (v1.lVal == v2.lVal);
return bIsEqual;
}
else {
return FALSE;
}
break;
}
ASSERT(FALSE);
COleVariant var1;
COleVariant var2;
var1 = v1;
var2 = v2;
bIsEqual = (var1 == var2);
return bIsEqual;
}
//*******************************************************************
// CComparePaths::PathsRefSameObject
//
// Compare two parsed object paths to determine whether or not they
// they reference the same object. Note that the sever name and namespaces
// are not compared if they are missing from one of the paths.
//
// Parameters:
// [in] ParsedObjectPath* ppath1
// The first parsed path.
//
// [in] ParsedObjectPath* ppath2
// The second parsed path.
//
// Returns:
// BOOL
// TRUE if the two paths reference the same object, FALSE otherwise.
//
//*******************************************************************
BOOL CComparePaths::PathsRefSameObject(
/* in */ ParsedObjectPath* ppath1,
/* in */ ParsedObjectPath* ppath2)
{
if (ppath1 == ppath2) {
return TRUE;
}
if (ppath1==NULL || ppath2==NULL) {
return FALSE;
}
#if 0
// Check to see if a server name is specified for either path
// if so, the server name count is 1, otherwise zero.
UINT iNamespace1 = 0;
if (ppath1->m_pServer!=NULL) {
if (!IsEqual(ppath1->m_pServer, L".")) {
iNamespace1 = 1;
}
}
UINT iNamespace2 = 0;
if (ppath1->m_pServer!=NULL) {
if (!IsEqual(ppath2->m_pServer, L".")) {
iNamespace2 = 1;
}
}
// Relative paths don't specify a server, so we assume that the server
// for a relative path and any other path match and no further comparison is
// necessary.
if (iNamespace1!=0 && iNamespace2!=0) {
if (!IsEqual(ppath1->m_pServer, ppath2->m_pServer)) {
return FALSE;
}
}
// Relative paths don't specify name spaces, so we assume that the name spaces
// for a relative path and any other path match and no further comparison is
// necessary. Of course, this assumes that the namespace for a relative path
// is indeed the same as the other path.
if (ppath1->m_dwNumNamespaces!=0 && ppath2->m_dwNumNamespaces!=0) {
// Check to see if one of the namespaces are different.
if ((ppath1->m_dwNumNamespaces - iNamespace1) != (ppath2->m_dwNumNamespaces - iNamespace2)) {
return FALSE;
}
while((iNamespace1 < ppath1->m_dwNumNamespaces) && (iNamespace2 < ppath2->m_dwNumNamespaces)) {
if (!IsEqual(ppath1->m_paNamespaces[iNamespace1], ppath2->m_paNamespaces[iNamespace2])) {
return FALSE;
}
++iNamespace1;
++iNamespace2;
}
}
#endif //0
// Check to see if the classes are different.
if (!IsEqual(ppath1->m_pClass, ppath2->m_pClass)) {
return FALSE;
}
// Check to see if any of the keys are different.
if (ppath1->m_dwNumKeys != ppath2->m_dwNumKeys) {
return FALSE;
}
KeyRef* pkr1;
KeyRef* pkr2;
// Handle single keys as a special case since "Class="KeyValue"" should
// be identical to "Class.keyName="KeyValue""
if ((ppath1->m_dwNumKeys==1) && (ppath2->m_dwNumKeys==1)) {
pkr1 = ppath1->m_paKeys[0];
pkr2 = ppath2->m_paKeys[0];
if (!IsEqual(pkr1->m_pName, pkr2->m_pName)) {
if (pkr1->m_pName!=NULL && pkr2->m_pName!=NULL) {
return FALSE;
}
}
if (KeyValuesAreEqual(pkr1->m_vValue, pkr2->m_vValue)) {
return TRUE;
}
else {
return FALSE;
}
}
NormalizeKeyArray(*ppath1);
NormalizeKeyArray(*ppath2);
for (DWORD dwKeyIndex = 0; dwKeyIndex < ppath1->m_dwNumKeys; ++dwKeyIndex) {
ASSERT(ppath1->m_paKeys[dwKeyIndex] != NULL);
ASSERT(ppath2->m_paKeys[dwKeyIndex] != NULL);
pkr1 = ppath1->m_paKeys[dwKeyIndex];
pkr2 = ppath2->m_paKeys[dwKeyIndex];
if (!IsEqual(pkr1->m_pName, pkr2->m_pName)) {
return FALSE;
}
if (!KeyValuesAreEqual(pkr1->m_vValue, pkr2->m_vValue)) {
return FALSE;
}
}
return TRUE;
}
//**************************************************************
// CComparePaths::PathsRefSameObject
//
// Check to see if two object paths point to the same object.
//
// Parameters:
// BSTR bstrPath1
// The first object path.
//
// BSTR bstrPath2
// The second object path.
//
// Returns:
// BOOL
// TRUE if the two paths reference the same object in
// the database, FALSE otherwise.
//
//**************************************************************
BOOL CComparePaths::PathsRefSameObject(BSTR bstrPath1, BSTR bstrPath2)
{
CObjectPathParser parser;
ParsedObjectPath* pParsedPath1 = NULL;
ParsedObjectPath* pParsedPath2 = NULL;
int nStatus1;
int nStatus2;
nStatus1 = parser.Parse(bstrPath1, &pParsedPath1);
nStatus2 = parser.Parse(bstrPath2, &pParsedPath2);
BOOL bRefSameObject = FALSE;
if (nStatus1==0 && nStatus2==0) {
bRefSameObject = PathsRefSameObject(pParsedPath1, pParsedPath2);
}
if (pParsedPath1) {
parser.Free(pParsedPath1);
}
if (pParsedPath2) {
parser.Free(pParsedPath2);
}
return bRefSameObject;
}
void CNavigatorCtrl::OnLButtonUp(UINT nFlags, CPoint point)
{
// TODO: Add your message handler code here and/or call default
COleControl::OnLButtonUp(nFlags, point);
}
void CNavigatorCtrl::OnPopupBrowse()
{
// TODO: Add your command handler code here
m_pcbiBrowseDialog->SetServices(m_pServices);
m_pcbiBrowseDialog->SetTMFont(&m_tmFont);
m_pcbiBrowseDialog->SetParent(this);
m_pcbiBrowseDialog->SetMode(CBrowseforInstances::TreeRoot);
m_pcbiBrowseDialog->DoModal();
if (m_bRestoreFocusToTree)
{
m_ctcTree.SetFocus();
}
else
{
m_cbBannerWindow.SetFocus();
}
}
void CNavigatorCtrl::OnUpdatePopupBrowse(CCmdUI* pCmdUI)
{
// TODO: Add your command update UI handler code here
}
long CNavigatorCtrl::ChangeRootOrNamespace
(LPCTSTR lpctstrRootOrNamespace, long lMakeNamespaceCurrent, long lFireEvents)
{
if (!lpctstrRootOrNamespace)
{
return WBEM_E_INVALID_PARAMETER;
}
CString csRootOrNamespace = lpctstrRootOrNamespace;
CString csClass = GetIWbemClass(csRootOrNamespace);
CString csNamespace = GetObjectNamespace(&csRootOrNamespace);
BOOL bPathHasKeys = PathHasKeys(&csRootOrNamespace);
if (lMakeNamespaceCurrent)
{
m_bFireEvents = lFireEvents;
SetNameSpace((LPCTSTR) csNamespace);
return S_OK;
}
else
{
CString csRootPath = csRootOrNamespace;
if (csRootPath.GetLength() == 0)
{
InvalidateControl(); // jpow
return WBEM_E_FAILED;
}
m_csRootPath = csRootPath;
m_ctcTree.UnCacheTools();
m_ctcTree.ResetTree();
m_ctcTree.AddInitialObjectInstToTree
(m_csRootPath, lFireEvents);
m_bDrawAll = TRUE;
InvalidateControl();
return S_OK;
}
}
void CNavigatorCtrl::OnPopupGotonamespace()
{
CString csObject = m_pctidHit ? m_pctidHit->GetAt(0) : _T("");
if (csObject.GetLength() > 0 &&
m_pctidHit -> m_nType == CTreeItemData::ObjectInst)
{
ChangeRootOrNamespace((LPCTSTR) csObject ,TRUE, TRUE) ;
}
}
void CNavigatorCtrl::OnUpdatePopupGotonamespace(CCmdUI* pCmdUI)
{
CString csObject = m_pctidHit ? m_pctidHit->GetAt(0) : _T("");
if (csObject.GetLength() > 0 &&
m_pctidHit -> m_nType == CTreeItemData::ObjectInst &&
ObjectInDifferentNamespace (&m_csNameSpace,&csObject))
{
pCmdUI -> Enable( TRUE );
}
else
{
pCmdUI -> Enable( FALSE );
}
}
void CNavigatorCtrl::OnPopupRefresh()
{
// TODO: Add your command handler code here
CWaitCursor wait;
m_ctcTree.UnCacheTools();
m_ctcTree.m_bReCacheTools = TRUE;
m_ctcTree.Expand(m_hHit,TVE_COLLAPSE);
if (m_ctcTree.ItemHasChildren (m_hHit))
{
HTREEITEM hChild = m_ctcTree.GetChildItem(m_hHit);
while (hChild)
{
m_ctcTree.DeleteTreeItemData(hChild);
HTREEITEM hChildNext = m_ctcTree.GetNextSiblingItem(hChild);
m_ctcTree.DeleteItem( hChild);
hChild = hChildNext;
}
}
TV_INSERTSTRUCT tvstruct;
tvstruct.item.hItem = m_hHit;
tvstruct.item.mask = TVIF_CHILDREN;
tvstruct.item.cChildren = 1;
m_ctcTree.SetItem(&tvstruct.item);
UINT nStateMask = TVIS_EXPANDEDONCE;
UINT uState =
m_ctcTree.GetItemState( m_hHit, nStateMask );
uState = 0;
m_ctcTree.SetItemState(m_hHit, uState, TVIS_EXPANDEDONCE);
InvalidateControl();
SetModifiedFlag();
}
void CNavigatorCtrl::OnUpdatePopupRefresh(CCmdUI* pCmdUI)
{
// TODO: Add your command update UI handler code here
CString csObject = m_pctidHit ? m_pctidHit->GetAt(0) : _T("");
if (csObject.GetLength() > 0 &&
m_pctidHit -> m_nType == CTreeItemData::ObjectInst)
{
if (m_ctcTree.IsTreeItemExpandable(m_hHit))
{
pCmdUI -> Enable( TRUE );
}
else
{
pCmdUI -> Enable( FALSE );
}
}
else
{
pCmdUI -> Enable( FALSE );
}
}
void CNavigatorCtrl::PassThroughGetIWbemServices
(LPCTSTR lpctstrNamespace, VARIANT FAR* pvarUpdatePointer, VARIANT FAR* pvarServices, VARIANT FAR* pvarSC, VARIANT FAR* pvarUserCancel)
{
FireGetIWbemServices
(lpctstrNamespace,
pvarUpdatePointer,
pvarServices,
pvarSC,
pvarUserCancel);
}
IWbemServices *CNavigatorCtrl::InitServices
(CString *pcsNameSpace)
{
CString csObjectPath;
if (pcsNameSpace == NULL || pcsNameSpace->IsEmpty())
{
PreModalDialog();
CInitNamespaceDialog cindInitNamespace;
cindInitNamespace.m_pParent = this;
INT_PTR nReturn = cindInitNamespace.DoModal();
PostModalDialog();
if (nReturn == IDOK)
{
csObjectPath = cindInitNamespace.GetNamespace();
*pcsNameSpace = csObjectPath;
}
else
{
return NULL;
}
}
else
{
csObjectPath = *pcsNameSpace;
}
IWbemServices *pSession = 0;
IWbemServices *pChild = 0;
CString csUser = _T("");
pSession = GetIWbemServices(csObjectPath);
return pSession;
}
IWbemServices *CNavigatorCtrl::GetIWbemServices
(CString &rcsNamespace)
{
IUnknown *pServices = NULL;
BOOL bUpdatePointer= FALSE;
m_sc = S_OK;
m_bUserCancel = FALSE;
VARIANT varUpdatePointer;
VariantInit(&varUpdatePointer);
varUpdatePointer.vt = VT_I4;
if (bUpdatePointer == TRUE)
{
varUpdatePointer.lVal = 1;
}
else
{
varUpdatePointer.lVal = 0;
}
VARIANT varService;
VariantInit(&varService);
VARIANT varSC;
VariantInit(&varSC);
VARIANT varUserCancel;
VariantInit(&varUserCancel);
FireGetIWbemServices
((LPCTSTR)rcsNamespace, &varUpdatePointer, &varService, &varSC,
&varUserCancel);
if (varService.vt & VT_UNKNOWN)
{
pServices = reinterpret_cast<IWbemServices*>(varService.punkVal);
}
varService.punkVal = NULL;
VariantClear(&varService);
if (varSC.vt == VT_I4)
{
m_sc = varSC.lVal;
}
else
{
m_sc = WBEM_E_FAILED;
}
VariantClear(&varSC);
if (varUserCancel.vt == VT_BOOL)
{
m_bUserCancel = varUserCancel.boolVal;
}
VariantClear(&varUserCancel);
VariantClear(&varUpdatePointer);
IWbemServices *pRealServices = NULL;
if (m_sc == S_OK && !m_bUserCancel)
{
pRealServices = reinterpret_cast<IWbemServices *>(pServices);
m_cbBannerWindow.EnableSearchButton(TRUE);
}
return pRealServices;
}
void CNavigatorCtrl::OnResetState()
{
// TODO: Add your specialized code here and/or call the base class
COleControl::OnResetState();
}
void CNavigatorCtrl::OnMenuiteminitialroot()
{
// TODO: Add your command handler code here
CString csObject = m_pctidHit ? m_pctidHit->GetAt(0) : _T("");
BOOL bReturn;
if (csObject.GetLength() > 0)
{
bReturn = UpdateNamespaceConfigInstance
(GetServices(), &csObject, m_csNameSpace);
OnSetroot();
}
}
void CNavigatorCtrl::OnUpdateMenuiteminitialroot(CCmdUI* pCmdUI)
{
CString csObject = m_pctidHit ? m_pctidHit->GetAt(0) : _T("");
if (csObject.GetLength() > 0 &&
m_pctidHit -> m_nType == CTreeItemData::ObjectInst)
{
pCmdUI -> Enable( TRUE );
}
else
{
pCmdUI -> Enable( FALSE );
}
}
void CNavigatorCtrl::SetProgressDlgMessage(CString &csMessage)
{
m_pProgressDlg->SetMessage(csMessage);
}
void CNavigatorCtrl::SetProgressDlgLabel(CString &csLabel)
{
m_pProgressDlg->SetLabel(csLabel);
}
void CNavigatorCtrl::CreateProgressDlgWindow()
{
PreModalDialog();
m_pProgressDlg->Create(this);
}
BOOL CNavigatorCtrl::CheckCancelButtonProgressDlgWindow()
{
if (m_pProgressDlg->GetSafeHwnd())
{
return m_pProgressDlg->CheckCancelButton();
}
return FALSE;
}
void CNavigatorCtrl::UpdateProgressDlgWindowStrings()
{
if (m_pProgressDlg->GetSafeHwnd())
{
m_pProgressDlg->UpdateWindowStrings();
}
}
void CNavigatorCtrl::DestroyProgressDlgWindow(BOOL bSetFocus, BOOL bRedrawControl)
{
if (m_pProgressDlg->GetSafeHwnd())
{
m_pProgressDlg->DestroyWindow();
PostModalDialog();
}
if (bSetFocus)
{
PostMessage(SETFOCUS,0,0);
}
if (bRedrawControl)
{
InvalidateControl();
}
}
void CNavigatorCtrl::PumpMessagesProgressDlgWindow()
{
if (m_pProgressDlg->GetSafeHwnd())
{
m_pProgressDlg->PumpMessages();
}
}
HWND CNavigatorCtrl::GetProgressDlgSafeHwnd()
{
return m_pProgressDlg->GetSafeHwnd();
}
LRESULT CNavigatorCtrl::SetFocus(WPARAM, LPARAM)
{
COleControl::SetFocus();
return 0;
}
CPtrArray *CNavigatorCtrl::SemiSyncEnum
(IEnumWbemClassObject *pEnum, BOOL &bCancel,
HRESULT &hResult, int nRes)
{
if (!pEnum)
return NULL;
CPtrArray *pcpaObjects = new CPtrArray;
IWbemClassObject *pObject = NULL;
ULONG uReturned = 0;
hResult = S_OK;
IWbemClassObject **pimcoInstances = new IWbemClassObject *[nRes];
int i;
for (i = 0; i < nRes; i++)
{
pimcoInstances[i] = NULL;
}
hResult =
pEnum->Next(100,nRes, pimcoInstances, &uReturned);
#ifdef _DEBUG
// afxDump << _T("************* SemiSyncEnum *****************\n*********");
// afxDump << _T("Next uReturned = " ) << uReturned << _T("\n");
CString csAsHex;
csAsHex.Format(_T("0x%x"),hResult);
// afxDump << _T("Next hResult = " ) << csAsHex << _T("\n");
#endif
int cInst = 0;
BOOL bDone = FALSE;
bCancel = FALSE;
while(!bDone && !bCancel &&
(hResult == S_OK || hResult == WBEM_S_TIMEDOUT || uReturned > 0))
{
#pragma warning( disable :4018 )
for (int i = 0; i < uReturned; i++)
#pragma warning( default : 4018 )
{
IWbemClassObject *pTemp = pimcoInstances[i];
if (pTemp)
{
pcpaObjects->Add(reinterpret_cast<void *>(pTemp));
pimcoInstances[i] = NULL;
}
#ifdef _DEBUG
else
{
// afxDump << _T("************* SemiSyncEnum *****************\n*********");
// afxDump << _T("Null pointer returned.\n");
}
#endif
}
bCancel = CheckCancelButtonProgressDlgWindow();
cInst += uReturned;
uReturned = 0;
if (cInst < nRes && ! bCancel)
{
hResult = pEnum->Next
(100,nRes - cInst, pimcoInstances, &uReturned);
#ifdef _DEBUG
// afxDump << _T("************* SemiSyncEnum *****************\n*********");
// afxDump << _T("Next uReturned = " ) << uReturned << _T("\n");
CString csAsHex;
csAsHex.Format(_T("0x%x"),hResult);
// afxDump << _T("Next hResult = " ) << csAsHex << _T("\n");
#endif
}
else
{
if (!bCancel)
{
bDone = TRUE;
}
}
}
delete[]pimcoInstances;
if (bCancel)
{
for (int i = 0; i < pcpaObjects->GetSize(); i++)
{
IWbemClassObject *pObject =
reinterpret_cast<IWbemClassObject *>
(pcpaObjects->GetAt(i));
pObject->Release();
}
pcpaObjects->RemoveAll();
}
return pcpaObjects;
}
void CNavigatorCtrl::OnKillFocus(CWnd* pNewWnd)
{
COleControl::OnKillFocus(pNewWnd);
// TODO: Add your message handler code here
Refresh();
}
void CNavigatorCtrl::OnSetFocus(CWnd* pOldWnd)
{
COleControl::OnSetFocus(pOldWnd);
OnActivateInPlace(TRUE,NULL);
if (m_bRestoreFocusToTree)
{
m_ctcTree.SetFocus();
}
else
{
m_cbBannerWindow.SetFocus();
}
}
LRESULT CNavigatorCtrl::SetFocusNSE(WPARAM, LPARAM)
{
m_cbBannerWindow.m_pnseNameSpace->SetFocus();
return 0;
}
/* EOF: NavigatorCtl.cpp */
Reference in New Issue View Git Blame Copy Permalink