mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1120 lines
25 KiB
1120 lines
25 KiB
/*++
|
|
|
|
Copyright (C) 1997-2001 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
Abstract:
|
|
|
|
History:
|
|
|
|
--*/
|
|
|
|
// OpView.cpp : implementation of the COpView class
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "WMITest.h"
|
|
|
|
#include "MainFrm.h"
|
|
#include "WMITestDoc.h"
|
|
#include "OpView.h"
|
|
#include "ObjVw.h"
|
|
#include "DelDlg.h"
|
|
#include "PropsPg.H"
|
|
#include "PropQualsPg.h"
|
|
#include "MethodsPg.h"
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COpView
|
|
|
|
IMPLEMENT_DYNCREATE(COpView, CTreeView)
|
|
|
|
BEGIN_MESSAGE_MAP(COpView, CTreeView)
|
|
//{{AFX_MSG_MAP(COpView)
|
|
ON_WM_SIZE()
|
|
ON_NOTIFY_REFLECT(NM_DBLCLK, OnDblclk)
|
|
ON_NOTIFY_REFLECT(TVN_SELCHANGED, OnSelChanged)
|
|
ON_NOTIFY_REFLECT(NM_RCLICK, OnRclick)
|
|
ON_COMMAND(ID_DELETE, OnDelete)
|
|
ON_UPDATE_COMMAND_UI(ID_DELETE, OnUpdateDelete)
|
|
ON_COMMAND(ID_MODIFY, OnModify)
|
|
ON_UPDATE_COMMAND_UI(ID_MODIFY, OnUpdateModify)
|
|
ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
|
|
ON_WM_DESTROY()
|
|
ON_UPDATE_COMMAND_UI(ID_EDIT_COPY, OnUpdateEditCopy)
|
|
//}}AFX_MSG_MAP
|
|
ON_MESSAGE(WM_OBJ_INDICATE, OnObjIndicate)
|
|
ON_MESSAGE(WM_OP_STATUS, OnOpStatus)
|
|
END_MESSAGE_MAP()
|
|
|
|
// Global used by sinks.
|
|
COpView *g_pOpView;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COpView construction/destruction
|
|
|
|
COpView::COpView() :
|
|
m_pTree(NULL),
|
|
m_hitemRoot(NULL)
|
|
{
|
|
g_pOpView = this;
|
|
}
|
|
|
|
COpView::~COpView()
|
|
{
|
|
}
|
|
|
|
BOOL COpView::PreCreateWindow(CREATESTRUCT& cs)
|
|
{
|
|
cs.style |= WS_CHILD | WS_VISIBLE | TVS_HASLINES | TVS_HASBUTTONS |
|
|
TVS_SHOWSELALWAYS; //TVS_EDITLABELS |
|
|
|
|
return CTreeView::PreCreateWindow(cs);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COpView drawing
|
|
|
|
void COpView::OnInitialUpdate()
|
|
{
|
|
CTreeView::OnInitialUpdate();
|
|
|
|
m_pTree->SetImageList(&((CMainFrame *) GetParentFrame())->m_imageList,
|
|
TVSIL_NORMAL);
|
|
|
|
if (!m_hitemRoot)
|
|
m_hitemRoot = m_pTree->InsertItem(_T(""), IMAGE_ROOT, IMAGE_ROOT);
|
|
|
|
GetDocument()->m_pOpView = this;
|
|
|
|
UpdateRootText();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COpView diagnostics
|
|
|
|
#ifdef _DEBUG
|
|
void COpView::AssertValid() const
|
|
{
|
|
CTreeView::AssertValid();
|
|
}
|
|
|
|
void COpView::Dump(CDumpContext& dc) const
|
|
{
|
|
CTreeView::Dump(dc);
|
|
}
|
|
|
|
CWMITestDoc* COpView::GetDocument() // non-debug version is inline
|
|
{
|
|
ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CWMITestDoc)));
|
|
return (CWMITestDoc*)m_pDocument;
|
|
}
|
|
#endif //_DEBUG
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COpView message handlers
|
|
|
|
void COpView::OnSize(UINT nType, int cx, int cy)
|
|
{
|
|
CTreeView::OnSize(nType, cx, cy);
|
|
|
|
if (!m_pTree)
|
|
m_pTree = &GetTreeCtrl();
|
|
}
|
|
|
|
LRESULT COpView::OnObjIndicate(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
COpWrap *pWrap = (COpWrap*) wParam;
|
|
CObjInfo *pInfo = (CObjInfo*) lParam;
|
|
|
|
if (!pWrap->IsObject())
|
|
{
|
|
AddOpItemChild(
|
|
pInfo,
|
|
pWrap->m_item,
|
|
pInfo->GetImage(),
|
|
pInfo->GetObjText());
|
|
}
|
|
else
|
|
{
|
|
// This just simulates a selection since the object has already been
|
|
// added.
|
|
if (pWrap->m_item == m_pTree->GetSelectedItem())
|
|
GetDocument()->UpdateAllViews(this, HINT_OP_SEL,
|
|
(CObject*) pWrap->m_item);
|
|
}
|
|
|
|
if (pWrap->m_item == m_pTree->GetSelectedItem())
|
|
UpdateStatusText();
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT COpView::OnOpStatus(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
COpWrap *pWrap = (COpWrap*) wParam;
|
|
int iImage = pWrap->GetImage();
|
|
|
|
GetDocument()->DecBusyOps();
|
|
|
|
// Update in case it's changed.
|
|
m_pTree->SetItemImage(pWrap->m_item, iImage, iImage);
|
|
|
|
if (pWrap->m_item == m_pTree->GetSelectedItem())
|
|
UpdateStatusText();
|
|
|
|
return 0;
|
|
}
|
|
|
|
void COpView::AddOpItem(WMI_OP_TYPE type, LPCTSTR szText, BOOL bOption)
|
|
{
|
|
AddOpItem(new COpWrap(type, szText, bOption));
|
|
}
|
|
|
|
void COpView::AddOpItem(COpWrap *pWrap)
|
|
{
|
|
CString strCaption = pWrap->GetCaption();
|
|
int iImage = pWrap->GetImage();
|
|
BOOL bExpand = m_pTree->GetChildItem(m_hitemRoot) == NULL;
|
|
|
|
pWrap->m_item = m_pTree->InsertItem(strCaption, iImage, iImage,
|
|
m_hitemRoot);
|
|
m_pTree->SetItemData(pWrap->m_item, (DWORD_PTR) pWrap);
|
|
|
|
RefreshItem(pWrap);
|
|
|
|
if (bExpand)
|
|
m_pTree->Expand(m_hitemRoot, TVE_EXPAND);
|
|
|
|
m_pTree->SelectItem(pWrap->m_item);
|
|
|
|
GetDocument()->SetModifiedFlag(TRUE);
|
|
}
|
|
|
|
void COpView::AddOpItemChild(
|
|
CObjInfo *pInfo,
|
|
HTREEITEM hParent,
|
|
int iImage,
|
|
LPCTSTR szText)
|
|
{
|
|
BOOL bUpdateCaption = !m_pTree->ItemHasChildren(hParent);
|
|
HTREEITEM hChild = m_pTree->InsertItem(szText, iImage, iImage, hParent);
|
|
|
|
// If this is the first child added see if the caption has been
|
|
// updated.
|
|
if (bUpdateCaption)
|
|
{
|
|
COpWrap *pWrap = (COpWrap*) m_pTree->GetItemData(hParent);
|
|
|
|
m_pTree->SetItemText(pWrap->m_item, pWrap->GetCaption());
|
|
}
|
|
|
|
if (hParent == m_pTree->GetSelectedItem())
|
|
UpdateStatusText();
|
|
|
|
m_pTree->SetItemData(hChild, (DWORD_PTR) pInfo);
|
|
|
|
GetDocument()->UpdateAllViews(this, HINT_NEW_CHILD, (CObject*) hChild);
|
|
}
|
|
|
|
void COpView::FlushItems()
|
|
{
|
|
HTREEITEM hitemParent;
|
|
|
|
if (!m_hitemRoot)
|
|
m_hitemRoot = m_pTree->InsertItem(_T(""), IMAGE_ROOT, IMAGE_ROOT);
|
|
|
|
while ((hitemParent = m_pTree->GetChildItem(m_hitemRoot)) != NULL)
|
|
{
|
|
RemoveItemFromTree(hitemParent, TRUE);
|
|
}
|
|
}
|
|
|
|
void COpView::RemoveChildrenFromTree(HTREEITEM item, BOOL bDoRemove)
|
|
{
|
|
COpWrap *pWrap = GetCurrentOp();
|
|
|
|
if (pWrap && pWrap->m_item == item)
|
|
GetDocument()->m_pObjView->Flush();
|
|
|
|
HTREEITEM hitemChild;
|
|
|
|
while ((hitemChild = m_pTree->GetChildItem(item)) != NULL)
|
|
{
|
|
RemoveNonOpObjectFromTree(hitemChild);
|
|
}
|
|
}
|
|
|
|
void COpView::RemoveNonOpObjectFromTree(HTREEITEM hitem)
|
|
{
|
|
ASSERT(!IsOp(hitem));
|
|
|
|
CObjInfo *pInfo = (CObjInfo*) m_pTree->GetItemData(hitem);
|
|
|
|
ASSERT(pInfo != NULL);
|
|
|
|
m_pTree->DeleteItem(hitem);
|
|
|
|
delete pInfo;
|
|
}
|
|
|
|
void COpView::RemoveItemFromTree(HTREEITEM item, BOOL bNoWMIRemove)
|
|
{
|
|
if (!bNoWMIRemove && IsObjDeleteable(item))
|
|
{
|
|
CDelDlg dlg;
|
|
|
|
dlg.m_bDelFromWMI = theApp.m_bDelFromWMI;
|
|
|
|
if (dlg.DoModal() == IDOK)
|
|
{
|
|
theApp.m_bDelFromWMI = dlg.m_bDelFromWMI;
|
|
|
|
if (dlg.m_bDelFromWMI)
|
|
{
|
|
CObjInfo *pObj = GetObjInfo(item);
|
|
HRESULT hr;
|
|
IWbemCallResultPtr pResult;
|
|
|
|
if (pObj->IsInstance())
|
|
{
|
|
CString strPath;
|
|
|
|
strPath = pObj->GetStringPropValue(L"__RELPATH");
|
|
|
|
hr =
|
|
GetDocument()->m_pNamespace->DeleteInstance(
|
|
_bstr_t(strPath),
|
|
0,
|
|
NULL,
|
|
&pResult);
|
|
}
|
|
else
|
|
{
|
|
CString strClass;
|
|
|
|
strClass = pObj->GetStringPropValue(L"__CLASS");
|
|
|
|
hr =
|
|
GetDocument()->m_pNamespace->DeleteClass(
|
|
_bstr_t(strClass),
|
|
0,
|
|
NULL,
|
|
&pResult);
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
//CWMITestDoc::DisplayWMIErrorBox(hr, pResult);
|
|
CWMITestDoc::DisplayWMIErrorBox(hr);
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
// Get out if the user canceled the dialog.
|
|
return;
|
|
}
|
|
|
|
if (IsOp(item))
|
|
{
|
|
RemoveChildrenFromTree(item, TRUE);
|
|
|
|
COpWrap *pWrap = (COpWrap*) m_pTree->GetItemData(item);
|
|
pWrap->CancelOp(GetDocument()->m_pNamespace);
|
|
m_pTree->DeleteItem(item);
|
|
|
|
delete pWrap;
|
|
}
|
|
else
|
|
{
|
|
HTREEITEM itemParent = m_pTree->GetParentItem(item);
|
|
|
|
RemoveNonOpObjectFromTree(item);
|
|
|
|
UpdateItem(itemParent);
|
|
}
|
|
}
|
|
|
|
void COpView::UpdateRootText()
|
|
{
|
|
CString strText;
|
|
|
|
if (GetDocument()->m_pNamespace)
|
|
strText = GetDocument()->m_strNamespace;
|
|
else
|
|
strText.LoadString(IDS_NOT_CONNECTED);
|
|
|
|
m_pTree->SetItemText(m_hitemRoot, strText);
|
|
|
|
UpdateStatusText();
|
|
}
|
|
|
|
|
|
void COpView::OnDblclk(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
CPoint curPoint;
|
|
|
|
GetCursorPos(&curPoint);
|
|
ScreenToClient(&curPoint);
|
|
|
|
HTREEITEM hItem = m_pTree->HitTest(curPoint);
|
|
|
|
*pResult = 0;
|
|
|
|
// Only do something if we really selected an item.
|
|
if (hItem)
|
|
{
|
|
m_pTree->SelectItem(hItem);
|
|
|
|
if (hItem == m_hitemRoot)
|
|
{
|
|
GetDocument()->DoConnectDlg();
|
|
*pResult = 1;
|
|
}
|
|
else
|
|
OnModify();
|
|
}
|
|
|
|
}
|
|
|
|
void COpView::UpdateCurrentItem()
|
|
{
|
|
HTREEITEM hitem = m_pTree->GetSelectedItem();
|
|
|
|
if (hitem)
|
|
UpdateItem(hitem);
|
|
}
|
|
|
|
void COpView::UpdateItem(HTREEITEM hitem)
|
|
{
|
|
long iHint;
|
|
|
|
if (IsRoot(hitem))
|
|
iHint = HINT_ROOT_SEL;
|
|
else if (IsOp(hitem))
|
|
iHint = HINT_OP_SEL;
|
|
else
|
|
iHint = HINT_OBJ_SEL;
|
|
|
|
GetDocument()->UpdateAllViews(this, iHint, (CObject*) hitem);
|
|
}
|
|
|
|
void COpView::OnSelChanged(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
NM_TREEVIEW *pNMTreeView = (NM_TREEVIEW*)pNMHDR;
|
|
|
|
if ((pNMTreeView->itemNew.state & TVIS_SELECTED))
|
|
{
|
|
UpdateItem(pNMTreeView->itemNew.hItem);
|
|
}
|
|
|
|
UpdateStatusText();
|
|
|
|
*pResult = 0;
|
|
}
|
|
|
|
void COpView::RefreshObject(CObjInfo *pInfo)
|
|
{
|
|
}
|
|
|
|
void COpView::RefreshItem(HTREEITEM hitem)
|
|
{
|
|
RefreshItem((COpWrap*) m_pTree->GetItemData(hitem));
|
|
}
|
|
|
|
|
|
void COpView::RefreshItem(COpWrap *pWrap)
|
|
{
|
|
pWrap->CancelOp(GetDocument()->m_pNamespace);
|
|
pWrap->m_listObj.RemoveAll();
|
|
RemoveChildrenFromTree(pWrap->m_item, TRUE);
|
|
|
|
GetDocument()->IncBusyOps();
|
|
|
|
pWrap->Execute(GetDocument()->m_pNamespace);
|
|
|
|
int iImage = pWrap->GetImage();
|
|
|
|
m_pTree->SetItemImage(pWrap->m_item, iImage, iImage);
|
|
}
|
|
|
|
void COpView::RefreshItems()
|
|
{
|
|
for (HTREEITEM hitemOp = m_pTree->GetChildItem(m_hitemRoot);
|
|
hitemOp != NULL;
|
|
hitemOp = m_pTree->GetNextSiblingItem(hitemOp))
|
|
{
|
|
RefreshItem(hitemOp);
|
|
}
|
|
}
|
|
|
|
COpWrap *COpView::GetCurrentOp()
|
|
{
|
|
HTREEITEM hitemCurrent = m_pTree->GetSelectedItem();
|
|
COpWrap *pWrap = NULL;
|
|
|
|
if (hitemCurrent && (IsOp(hitemCurrent) ||
|
|
IsOp(hitemCurrent = m_pTree->GetParentItem(hitemCurrent))))
|
|
pWrap = (COpWrap*) m_pTree->GetItemData(hitemCurrent);
|
|
|
|
return pWrap;
|
|
}
|
|
|
|
CObjInfo *COpView::GetCurrentObj()
|
|
{
|
|
HTREEITEM hitemCurrent = m_pTree->GetSelectedItem();
|
|
CObjInfo *pObj = NULL;
|
|
|
|
if (hitemCurrent && !IsRoot(hitemCurrent))
|
|
{
|
|
if (IsOp(hitemCurrent))
|
|
{
|
|
COpWrap *pWrap;
|
|
|
|
pWrap = (COpWrap*) m_pTree->GetItemData(hitemCurrent);
|
|
if (pWrap->IsObject())
|
|
pObj = pWrap->GetObjInfo();
|
|
}
|
|
else
|
|
pObj = (CObjInfo*) m_pTree->GetItemData(hitemCurrent);
|
|
}
|
|
|
|
return pObj;
|
|
}
|
|
|
|
void COpView::DoPopupMenu(UINT nMenuID)
|
|
{
|
|
CMenu popMenu;
|
|
|
|
popMenu.LoadMenu(nMenuID);
|
|
|
|
CPoint posMouse;
|
|
GetCursorPos(&posMouse);
|
|
|
|
CWnd* pWndPopupOwner = this;
|
|
while (pWndPopupOwner->GetStyle() & WS_CHILD)
|
|
pWndPopupOwner = pWndPopupOwner->GetParent();
|
|
|
|
popMenu.GetSubMenu(0)->TrackPopupMenu(0,posMouse.x,posMouse.y,pWndPopupOwner);
|
|
}
|
|
|
|
|
|
void COpView::OnRclick(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
CPoint curPoint;
|
|
|
|
GetCursorPos(&curPoint);
|
|
ScreenToClient(&curPoint);
|
|
|
|
HTREEITEM hItem = m_pTree->HitTest(curPoint);
|
|
|
|
// Only do something if we really selected an item.
|
|
if (hItem)
|
|
{
|
|
m_pTree->SelectItem(hItem);
|
|
DoContextMenuForItem(hItem);
|
|
}
|
|
|
|
*pResult = 0;
|
|
}
|
|
|
|
void COpView::DoContextMenuForItem(HTREEITEM hItem)
|
|
{
|
|
if (hItem == m_hitemRoot)
|
|
DoPopupMenu(IDR_NAMESPACE);
|
|
else if (IsOp(hItem))
|
|
{
|
|
COpWrap *pWrap = (COpWrap*) m_pTree->GetItemData(hItem);
|
|
|
|
if (FAILED(pWrap->m_hr))
|
|
DoPopupMenu(IDR_BAD_OP);
|
|
else
|
|
{
|
|
if (!pWrap->IsObject())
|
|
DoPopupMenu(IDR_OP);
|
|
else
|
|
{
|
|
if (pWrap->HoldsObjects())
|
|
DoPopupMenu(IDR_INST);
|
|
else
|
|
DoPopupMenu(IDR_CLASS);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
HTREEITEM hitemParent = m_pTree->GetParentItem(hItem);
|
|
COpWrap *pWrap = (COpWrap*) m_pTree->GetItemData(hitemParent);
|
|
|
|
if (pWrap->HoldsObjects())
|
|
DoPopupMenu(IDR_INST);
|
|
else
|
|
DoPopupMenu(IDR_CLASS);
|
|
}
|
|
}
|
|
|
|
int COpView::GetChildCount(HTREEITEM hitem)
|
|
{
|
|
int nCount = 0;
|
|
|
|
for (HTREEITEM hitemOp = m_pTree->GetChildItem(m_hitemRoot);
|
|
hitemOp != NULL;
|
|
hitemOp = m_pTree->GetNextSiblingItem(hitemOp))
|
|
{
|
|
nCount++;
|
|
}
|
|
|
|
return nCount;
|
|
}
|
|
|
|
int COpView::GetOpCount()
|
|
{
|
|
return GetChildCount(m_hitemRoot);
|
|
}
|
|
|
|
BOOL COpView::IsObj(HTREEITEM hitem)
|
|
{
|
|
return GetObjInfo(hitem) != NULL;
|
|
}
|
|
|
|
CObjInfo *COpView::GetObjInfo(HTREEITEM hitem)
|
|
{
|
|
if (IsRoot(hitem))
|
|
return NULL;
|
|
|
|
BOOL bIsOp = IsOp(hitem);
|
|
|
|
if (bIsOp)
|
|
{
|
|
COpWrap *pWrap = (COpWrap*) m_pTree->GetItemData(hitem);
|
|
|
|
if (pWrap->IsObject())
|
|
return pWrap->GetObjInfo();
|
|
else
|
|
return NULL;
|
|
}
|
|
else
|
|
return (CObjInfo*) m_pTree->GetItemData(hitem);
|
|
}
|
|
|
|
void COpView::UpdateCurrentObject(BOOL bReloadProps)
|
|
{
|
|
HTREEITEM hitem = m_pTree->GetSelectedItem();
|
|
|
|
if (!IsObj(hitem))
|
|
hitem = GetDocument()->m_pObjView->GetSelectedItem();
|
|
|
|
if (IsObj(hitem))
|
|
{
|
|
if (bReloadProps)
|
|
{
|
|
CObjInfo *pObj = (CObjInfo*) GetObjInfo(hitem);
|
|
COpWrap *pOp = (COpWrap*) GetCurrentOp();
|
|
|
|
pOp->RefreshPropInfo(pObj);
|
|
|
|
// Update the icon.
|
|
int iImage = pObj->GetImage();
|
|
|
|
m_pTree->SetItemImage(hitem, iImage, iImage);
|
|
|
|
// Update the text.
|
|
m_pTree->SetItemText(hitem,
|
|
pObj == &pOp->m_objInfo ? pOp->GetCaption() : pObj->GetObjText());
|
|
}
|
|
|
|
}
|
|
|
|
UpdateItem(m_pTree->GetSelectedItem());
|
|
}
|
|
|
|
void COpView::UpdateStatusText()
|
|
{
|
|
HTREEITEM hitem = m_pTree->GetSelectedItem();
|
|
CString strText;
|
|
|
|
|
|
if (IsRoot(hitem))
|
|
{
|
|
if (GetDocument()->m_pNamespace)
|
|
strText.Format(IDS_ROOT_STATUS, (LPCTSTR) GetDocument()->m_strNamespace);
|
|
else
|
|
strText.LoadString(IDS_NOT_CONNECTED);
|
|
}
|
|
else if (IsOp(hitem))
|
|
{
|
|
COpWrap *pWrap = (COpWrap*) m_pTree->GetItemData(hitem);
|
|
|
|
if (SUCCEEDED(pWrap->m_hr))
|
|
{
|
|
strText.Format(
|
|
pWrap->HoldsObjects() ? IDS_OBJ_COUNT : IDS_CLASS_COUNT,
|
|
pWrap->GetObjCount());
|
|
}
|
|
else
|
|
strText = pWrap->m_strErrorText;
|
|
}
|
|
|
|
((CMainFrame *) GetParentFrame())->SetStatusText(strText);
|
|
}
|
|
|
|
BOOL COpView::GetSelectedObjPath(CString &strPath)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
CObjInfo *pInfo = GetCurrentObj();
|
|
|
|
if (pInfo)
|
|
{
|
|
strPath = pInfo->GetStringPropValue(L"__RELPATH");
|
|
bRet = !strPath.IsEmpty();
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
BOOL COpView::GetSelectedClass(CString &strClass)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
CObjInfo *pInfo = GetCurrentObj();
|
|
|
|
if (pInfo)
|
|
{
|
|
strClass = pInfo->GetStringPropValue(L"__CLASS");
|
|
bRet = TRUE;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
void COpView::OnDelete()
|
|
{
|
|
HTREEITEM hitem = m_pTree->GetSelectedItem();
|
|
|
|
if (hitem != NULL && !IsRoot(hitem))
|
|
{
|
|
RemoveItemFromTree(hitem, FALSE);
|
|
GetDocument()->SetModifiedFlag(TRUE);
|
|
}
|
|
}
|
|
|
|
void COpView::OnUpdateDelete(CCmdUI* pCmdUI)
|
|
{
|
|
HTREEITEM hitem = m_pTree->GetSelectedItem();
|
|
|
|
pCmdUI->Enable(hitem != NULL && !IsRoot(hitem));
|
|
}
|
|
|
|
BOOL COpView::IsObjDeleteable(HTREEITEM hitem)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
|
|
if (IsObj(hitem))
|
|
{
|
|
if (IsOp(hitem))
|
|
{
|
|
COpWrap *pWrap = (COpWrap*) m_pTree->GetItemData(hitem);
|
|
|
|
bRet = SUCCEEDED(pWrap->m_hr) &&
|
|
pWrap->m_type != WMI_CREATE_CLASS &&
|
|
pWrap->m_type != WMI_CREATE_OBJ;
|
|
}
|
|
else
|
|
bRet = TRUE;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
void COpView::EditObj(CObjInfo *pInfo)
|
|
{
|
|
CPropertySheet sheet(pInfo->IsInstance() ? IDS_EDIT_INST : IDS_EDIT_CLASS);
|
|
CPropsPg pgProps;
|
|
CPropQualsPg pgQuals;
|
|
CMethodsPg pgMethods;
|
|
IWbemClassObjectPtr
|
|
pOrigObj;
|
|
|
|
pInfo->m_pObj->Clone(&pOrigObj);
|
|
|
|
pgProps.m_pNamespace = GetDocument()->m_pNamespace;
|
|
pgProps.m_pObj = pInfo;
|
|
|
|
pgQuals.m_pObj = pInfo->m_pObj;
|
|
pgQuals.m_bIsInstance = pInfo->IsInstance();
|
|
pgQuals.m_mode = CPropQualsPg::QMODE_CLASS;
|
|
|
|
sheet.AddPage(&pgProps);
|
|
sheet.AddPage(&pgQuals);
|
|
|
|
if (!pInfo->IsInstance())
|
|
{
|
|
pgMethods.m_pObj = pInfo->m_pObj;
|
|
|
|
sheet.AddPage(&pgMethods);
|
|
}
|
|
|
|
sheet.DoModal();
|
|
|
|
if (pInfo->m_pObj->CompareTo(WBEM_COMPARISON_INCLUDE_ALL, pOrigObj) ==
|
|
WBEM_S_DIFFERENT)
|
|
{
|
|
pInfo->SetModified(TRUE);
|
|
UpdateCurrentObject(TRUE);
|
|
}
|
|
}
|
|
|
|
void COpView::OnModify()
|
|
{
|
|
CObjInfo *pInfo = GetCurrentObj();
|
|
|
|
if (pInfo && pInfo->m_pObj != NULL)
|
|
EditObj(pInfo);
|
|
else
|
|
{
|
|
COpWrap *pOp = GetCurrentOp();
|
|
|
|
if (pOp && pOp->m_pErrorObj != NULL)
|
|
CWMITestDoc::DisplayWMIErrorDetails(pOp->m_pErrorObj);
|
|
}
|
|
}
|
|
|
|
void COpView::OnUpdateModify(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->Enable(GetCurrentObj() != NULL);
|
|
}
|
|
|
|
void COpView::ExportItemToFile(LPCTSTR szFilename, HTREEITEM hitem,
|
|
BOOL bShowSystem, BOOL bTranslate)
|
|
{
|
|
// Open the file. If this fails, an exception will fire that MFC will
|
|
// handle for us.
|
|
CStdioFile file(szFilename,
|
|
CFile::modeCreate | CFile::modeWrite | CFile::typeText);
|
|
|
|
// Add the namespace.
|
|
CString strNamespace;
|
|
|
|
strNamespace.Format("<%s>\n", GetDocument()->m_strNamespace);
|
|
|
|
file.WriteString(strNamespace);
|
|
|
|
ExportItem(&file, hitem, bShowSystem, bTranslate);
|
|
}
|
|
|
|
void COpView::ExportItem(CStdioFile *pFile, HTREEITEM hitem,
|
|
BOOL bShowSystem, BOOL bTranslate)
|
|
{
|
|
CObjInfo *pObj = GetObjInfo(hitem);
|
|
|
|
if (pObj)
|
|
pObj->Export(pFile, bShowSystem, bTranslate, 0);
|
|
else
|
|
{
|
|
for (HTREEITEM hitemChild = m_pTree->GetChildItem(hitem);
|
|
hitemChild != NULL;
|
|
hitemChild = m_pTree->GetNextSiblingItem(hitemChild))
|
|
{
|
|
ExportItem(pFile, hitemChild, bShowSystem, bTranslate);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
DWORD WINAPI SetClipboardThreadProc(COleDataSource *pSrc)
|
|
{
|
|
OleInitialize(NULL);
|
|
|
|
pSrc->SetClipboard();
|
|
|
|
BOOL bRet;
|
|
|
|
bRet = IsClipboardFormatAvailable(CF_TEXT);
|
|
bRet = IsClipboardFormatAvailable(CF_UNICODETEXT);
|
|
|
|
OpenClipboard(NULL);
|
|
|
|
// HANDLE hRet = GetClipboardData(CF_TEXT);
|
|
// LPSTR szText = (LPSTR) GlobalLock((HGLOBAL) hRet);
|
|
|
|
// GlobalUnlock((HGLOBAL) hRet);
|
|
|
|
CloseClipboard();
|
|
|
|
OleUninitialize();
|
|
|
|
return 0;
|
|
}
|
|
|
|
DWORD WINAPI COpView::CopyThreadProc(COpView *pThis)
|
|
{
|
|
OleInitialize(NULL);
|
|
|
|
pThis->CopyToClipboard();
|
|
|
|
OleUninitialize();
|
|
|
|
return 0;
|
|
}
|
|
|
|
void COpView::DoThreadedCopy()
|
|
{
|
|
HANDLE hThread;
|
|
DWORD dwID;
|
|
|
|
hThread =
|
|
CreateThread(
|
|
NULL,
|
|
0,
|
|
(LPTHREAD_START_ROUTINE) CopyThreadProc,
|
|
this,
|
|
0,
|
|
&dwID);
|
|
|
|
//WaitForSingleObject(hThread, INFINITE);
|
|
|
|
CloseHandle(hThread);
|
|
}
|
|
*/
|
|
|
|
void COpView::OnEditCopy()
|
|
{
|
|
CopyToClipboard();
|
|
//DoThreadedCopy();
|
|
}
|
|
|
|
#define NO_DATA_SRC
|
|
|
|
void COpView::CopyToClipboard()
|
|
{
|
|
COpList list;
|
|
|
|
BuildSelectedOpList(list);
|
|
|
|
if (list.GetCount())
|
|
{
|
|
// Ole will kill this variable when it's done.
|
|
//COleDataSource *pSrc = new COleDataSource;
|
|
|
|
//DoCopy(pSrc, list);
|
|
DoCopy(list);
|
|
|
|
#ifndef NO_DATA_SRC
|
|
#if 1
|
|
pSrc->SetClipboard();
|
|
#else
|
|
HANDLE hThread;
|
|
DWORD dwID;
|
|
|
|
hThread =
|
|
CreateThread(
|
|
NULL,
|
|
0,
|
|
(LPTHREAD_START_ROUTINE) SetClipboardThreadProc,
|
|
pSrc,
|
|
0,
|
|
&dwID);
|
|
|
|
WaitForSingleObject(hThread, INFINITE);
|
|
|
|
CloseHandle(hThread);
|
|
#endif
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void COpView::BuildSelectedOpList(COpList &list)
|
|
{
|
|
HTREEITEM hitem = m_pTree->GetSelectedItem();
|
|
|
|
list.RemoveAll();
|
|
|
|
if (hitem == m_hitemRoot)
|
|
{
|
|
for (HTREEITEM hitemOp = m_pTree->GetChildItem(m_hitemRoot);
|
|
hitemOp != NULL;
|
|
hitemOp = m_pTree->GetNextSiblingItem(hitemOp))
|
|
{
|
|
COpWrap *pWrap = (COpWrap*) m_pTree->GetItemData(hitemOp);
|
|
|
|
list.AddTail(*pWrap);
|
|
}
|
|
}
|
|
else if (IsOp(hitem))
|
|
{
|
|
COpWrap *pWrap = (COpWrap*) m_pTree->GetItemData(hitem);
|
|
|
|
list.AddTail(*pWrap);
|
|
}
|
|
else
|
|
{
|
|
ASSERT(IsObj(hitem));
|
|
|
|
CObjInfo *pObj = GetObjInfo(hitem);
|
|
CString strRelpath = pObj->GetStringPropValue(L"__RELPATH");
|
|
|
|
if (!strRelpath.IsEmpty())
|
|
{
|
|
BOOL bIsClass = strRelpath.Find('=') == -1;
|
|
COpWrap wrap(bIsClass ? WMI_GET_CLASS : WMI_GET_OBJ, strRelpath);
|
|
|
|
list.AddTail(wrap);
|
|
}
|
|
}
|
|
}
|
|
|
|
void COpView::DoCopy(COpList &list)
|
|
{
|
|
CMemFile memNative,
|
|
memText;
|
|
CArchive arcNative(&memNative, CArchive::store),
|
|
arcText(&memText, CArchive::store);
|
|
POSITION pos = list.GetHeadPosition();
|
|
BOOL bFirst = TRUE;
|
|
|
|
// Save off the count into the archive.
|
|
arcNative << (int) list.GetCount();
|
|
|
|
while (pos)
|
|
{
|
|
COpWrap &op = list.GetNext(pos);
|
|
|
|
// Save off the option wrapper into the native archive.
|
|
op.Serialize(arcNative);
|
|
|
|
// Add a new-line if we've already done an item.
|
|
if (bFirst)
|
|
bFirst = FALSE;
|
|
else
|
|
arcText.Write("\n", sizeof("\n") - 1);
|
|
|
|
// Add the option text into the text archive.
|
|
arcText.Write((LPCTSTR) op.m_strOpText, op.m_strOpText.GetLength());
|
|
}
|
|
|
|
// Add the null character.
|
|
arcText.Write("", 1);
|
|
|
|
arcNative.Close();
|
|
arcText.Close();
|
|
|
|
#ifdef NO_DATA_SRC
|
|
BOOL bRet = ::OpenClipboard(NULL);
|
|
#endif
|
|
|
|
// Save off the native archive contents.
|
|
DWORD dwSize = memNative.GetLength();
|
|
HGLOBAL pGlobBuffer = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, dwSize),
|
|
pArcBuffer = memNative.Detach();
|
|
|
|
memcpy(GlobalLock(pGlobBuffer), pArcBuffer, dwSize);
|
|
GlobalUnlock(pGlobBuffer);
|
|
free(pArcBuffer);
|
|
|
|
#ifdef NO_DATA_SRC
|
|
SetClipboardData(GetDocument()->m_cfOps, (HGLOBAL) pGlobBuffer);
|
|
#else
|
|
pSrc->CacheGlobalData(GetDocument()->m_cfOps, (HGLOBAL) pGlobBuffer);
|
|
#endif
|
|
|
|
|
|
// Save off the text archive contents.
|
|
dwSize = memText.GetLength();
|
|
pGlobBuffer = (LPBYTE) GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, dwSize);
|
|
pArcBuffer = memText.Detach();
|
|
|
|
// Turn the text into Unicode.
|
|
_bstr_t strText = (LPSTR) pArcBuffer;
|
|
|
|
memcpy(GlobalLock(pGlobBuffer), pArcBuffer, dwSize);
|
|
GlobalUnlock(pGlobBuffer);
|
|
free(pArcBuffer);
|
|
|
|
#ifdef NO_DATA_SRC
|
|
SetClipboardData(CF_TEXT, (HGLOBAL) pGlobBuffer);
|
|
#else
|
|
pSrc->CacheGlobalData(CF_TEXT, (HGLOBAL) pGlobBuffer);
|
|
#endif
|
|
|
|
|
|
pGlobBuffer = (LPBYTE) GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, dwSize * 2);
|
|
LPBYTE pBuffer = (LPBYTE) GlobalLock(pGlobBuffer);
|
|
memcpy(pBuffer, (LPCWSTR) strText, dwSize * 2);
|
|
GlobalUnlock(pGlobBuffer);
|
|
|
|
#ifdef NO_DATA_SRC
|
|
SetClipboardData(CF_UNICODETEXT, (HGLOBAL) pGlobBuffer);
|
|
#else
|
|
pSrc->CacheGlobalData(CF_UNICODETEXT, (HGLOBAL) pGlobBuffer);
|
|
#endif
|
|
|
|
#ifdef NO_DATA_SRC
|
|
::CloseClipboard();
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
void COpView::SerializeForClipboard(CArchive &arcNative, CArchive &arcText,
|
|
CLIPFORMAT *pFormat)
|
|
{
|
|
HTREEITEM hitem = m_pTree->GetSelectedItem();
|
|
|
|
if (hitem == m_hitemRoot)
|
|
{
|
|
int nCount = GetOpCount();
|
|
|
|
archive << nCount;
|
|
|
|
for (HTREEITEM hitemOp = m_pTree->GetChildItem(m_hitemRoot);
|
|
hitemOp != NULL;
|
|
hitemOp = m_pTree->GetNextSiblingItem(hitemOp))
|
|
{
|
|
COpWrap *pWrap = (COpWrap*) m_pTree->GetItemData(hitemOp);
|
|
|
|
m_pWrap->Serialize(arcNative);
|
|
}
|
|
|
|
*pFormat = GetDocument()->m_cfOps;
|
|
}
|
|
else if (IsOp(hitem))
|
|
{
|
|
int nCount = 1;
|
|
COpWrap *pWrap = (COpWrap*) m_pTree->GetItemData(hitem);
|
|
|
|
archive << nCount;
|
|
pWrap->Serialize(arcNative);
|
|
*pFormat = GetDocument()->m_cfOps;
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
ASSERT(IsObj(hitem));
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void COpView::SerializeTreeItem(HTREEITEM item, CArchive &arcNative, CArchive &arcText)
|
|
{
|
|
}
|
|
*/
|
|
|
|
BOOL COpView::CanCopy()
|
|
{
|
|
return m_pTree->GetSelectedItem() != NULL;
|
|
}
|
|
|
|
void COpView::OnUpdateEditCopy(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->Enable(CanCopy());
|
|
}
|