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

1004 lines
24 KiB
C++
Raw Permalink Blame History

// Copyright (c) 1997-2001 Microsoft Corporation, All Rights Reserved
#include "precomp.h"
#ifndef _wbemidl_h
#define _wbemidl_h
#include <wbemidl.h>
#endif //_wbemidl_h
#include "resource.h"
#include "notify.h"
#include "utils.h"
#include "SingleViewCtl.h"
#include "icon.h"
#include "hmomutil.h"
#include "globals.h"
#include "path.h"
#include "ParmGrid.h"
#include "hmmverr.h"
#include "PpgMethodParms.h"
#include "PsMethParms.h"
#include "PpgQualifiers.h"
#include "PsQualifiers.h"
#define CX_COL_PROPKEY 19 // Room for a 16X16 property marker plus a margin of two pixels
#define CX_COL_PROPMARKER 19 // Room for a 16X16 property marker plus a margin of two pixels
#define CX_COL_NAME 180
#define CX_COL_VALUE 180
#define CX_COL_TYPE 115
#define CXMIN_COL_VALUE 50
#define IX_COL_NAME 0
#define IX_COL_TYPE (IX_COL_NAME + CX_COL_NAME)
#define IX_COL_VALUE (IX_COL_TYPE + CX_COL_TYPE)
#define FIRST_SYNTESIZED_PROP_ID 1
#define ADDREF(x) if(x){x->AddRef();}
#define RELEASE(x) if(x){x->Release();x=NULL;}
//--------------------------------------------------------
CParmGrid::CParmGrid(CSingleViewCtrl* psv, CPpgMethodParms *pg)
: CPropGrid(psv, true, false)
{
m_pg = pg;
m_pco = NULL; // the "virtual pco".
}
//--------------------------------------------------------
CParmGrid::~CParmGrid()
{
RELEASE(m_pco);
// NOTE: m_inSig and m_outSig will be released when the sheet
// stores these ptrs back in the method tab's CGridRow.
}
//--------------------------------------------------------
BEGIN_MESSAGE_MAP(CParmGrid, CPropGrid)
//{{AFX_MSG_MAP(CPropGrid)
//}}AFX_MSG_MAP
ON_COMMAND(ID_CMD_SHOW_OBJECT_ATTRIBUTES, OnCmdShowObjectQualifiers)
END_MESSAGE_MAP()
//--------------------------------------------------------
IWbemClassObject* CParmGrid::CurrentObject()
{
// this returns the VIRTUAL pco that the grid can handle.
return m_pco;
}
//--------------------------------------------------------
HRESULT CParmGrid::DoDelete(IWbemClassObject* pco,
BSTR Name)
{
// remember where we are.
int selectedRow = GetSelectedRow();
// delete the property.
HRESULT hr = CPropGrid::DoDelete(pco, Name);
if(SUCCEEDED(hr))
{
// NOTE: zero-based index. And you cant delete the
// blank row which is always last-- so I dont need
// to protect from that.
int lastRow = GetRows() - 1;
// NOTE: 'lastRow' will point to the <blank> row.
// renumber from selectedRow down.
for(int i = selectedRow+1; i <= lastRow; i++)
{
CGridRow *row = &GetRowAt(i);
row->SetCurrMethodID(i-1);
SerializeMethodID(*row);
} //endfor
}
return hr;
}
//--------------------------------------------------------
int CParmGrid::CompareRows(int iRow1, int iRow2, int iSortOrder)
{
CGridCell* cell1 = &GetAt(iRow1, ICOL_PROP_NAME);
CGridCell* cell2 = &GetAt(iRow2, ICOL_PROP_NAME);
COleVariant varName1, varName2;
CIMTYPE cimtype = 0;
cell1->GetValue(varName1, cimtype);
cell2->GetValue(varName2, cimtype);
// if either is <blank>, keep it at the bottom.
if(SysStringLen(V_BSTR(&varName1)) == 0)
return 1;
if(SysStringLen(V_BSTR(&varName2)) == 0)
return -1;
CGridRow& row1 = GetRowAt(iRow1);
CGridRow& row2 = GetRowAt(iRow2);
long ID1 = row1.GetCurrMethodID();
long ID2 = row2.GetCurrMethodID();
// ok-- fair fight then.
// bug#57338 - This sort logic is wrong - you must return 1, 0, -1
if(ID1 > ID2)
return 1;
else if(ID1 < ID2)
return -1;
return 0;
}
//--------------------------------------------------------
void CParmGrid::OnCellContentChange(int iRow, int iCol)
{
CPropGrid::OnCellContentChange(iRow, iCol);
if(m_hWnd == NULL)
{
return;
}
SetModified(TRUE);
m_pg->SetModified(TRUE);
}
//--------------------------------------------------------
BOOL CParmGrid::ValueShouldBeReadOnly(BSTR bstrPropName)
{
return FALSE;
}
//--------------------------------------------------------
int CParmGrid::GetIDQualifier(IWbemClassObject *clsObj,
BSTR varName)
{
int ID = -1; // -1 means its the "ReturnValue" which doesn't have "ID".
COleVariant varID;
IWbemQualifierSet* pqsSrc = NULL;
HRESULT hr = DoGetPropertyQualifierSet(clsObj, varName, &pqsSrc);
// while I'm here... ;)
if(SUCCEEDED(pqsSrc->Get(L"ID", 0, &varID, NULL)))
{
ID = V_I4(&varID);
}
RELEASE(pqsSrc);
return ID;
}
//--------------------------------------------------------
void CParmGrid::LoadGrid(void)
{
HRESULT hr;
CMosNameArray aPropNames;
hr = aPropNames.LoadPropNames(m_pco, NULL, WBEM_FLAG_NONSYSTEM_ONLY, NULL);
if(SUCCEEDED(hr))
{
int nPropNames = aPropNames.GetSize();
for(int iPropName = 0; iPropName < nPropNames; ++iPropName)
{
BSTR bstrPropName = aPropNames[iPropName];
long lRow = GetRows();
InsertRowAt(lRow);
if(SUCCEEDED(hr = LoadProperty(lRow, bstrPropName,
m_bEditValueOnly,
m_pco, PROPFILTER_LOCAL)))
{
CGridRow *newRow = &GetRowAt(lRow);
int ID = GetIDQualifier(m_pco, bstrPropName);
newRow->SetCurrMethodID(ID);
}
else
{
// no redraw.
DeleteRowAt(lRow, false);
}
} //endfor
SortGrid(0, GetRows() -1, 0, false);
} //endif
}
//--------------------------------------------------------
void CParmGrid::Refresh(IWbemClassObject *inSig, IWbemClassObject *outSig)
{
m_bShowingInvalidCellMessage = FALSE;
CDisableModifyCreate DisableModifyCreate(this);
m_bDiscardOldObject = TRUE;
CPropGrid::Empty();
m_bDiscardOldObject = FALSE;
ClearRows();
// make a new virtual pco.
RELEASE(m_pco);
IWbemServices *service = m_psv->GetProvider();
service->GetObject(NULL, 0, 0, &m_pco, 0);
// load inSig into virtual (m_pco).
if(inSig)
{
LoadVirtual(inSig, TRUE);
}
// load outSig into virtual (m_pco).
if(outSig)
{
LoadVirtual(outSig, FALSE);
}
// load virtual pco into grid.
LoadGrid();
int nRows = GetRows();
if(m_psv->ObjectIsClass() && IsInSchemaStudioMode())
{
// When viewing a class,
// Add an empty row at the bottom.
InsertRowAt(nRows);
CGridRow *emptyRow = &GetRowAt(nRows);
emptyRow->SetCurrMethodID(nRows);
}
UpdateScrollRanges();
if(::IsWindow(m_hWnd))
{
UpdateWindow();
}
}
//--------------------------------------------------------
void CParmGrid::LoadVirtual(IWbemClassObject *pco, BOOL bInput)
{
CMosNameArray aPropNames;
SCODE sc;
sc = aPropNames.LoadPropNames(pco, NULL, WBEM_FLAG_NONSYSTEM_ONLY, NULL);
if(SUCCEEDED(sc))
{
int nPropNames = aPropNames.GetSize();
for(int iPropName = 0; iPropName < nPropNames; ++iPropName)
{
BSTR bstrPropName = aPropNames[iPropName];
if (_wcsicmp(bstrPropName, L"ReturnValue") == 0) {
// The return value should not appear in the grid, so skip it.
continue;
}
IWbemQualifierSet* pqs = NULL;
sc = DoGetPropertyQualifierSet(m_pco, bstrPropName, &pqs);
if (SUCCEEDED(sc)) {
COleVariant varTrue;
varTrue.vt = VT_BOOL;
varTrue.boolVal = VARIANT_TRUE;
BOOL bHasInQual = FALSE;
BOOL bHasOutQual = FALSE;
COleVariant var;
// Make sure that the object has appropriate IN/OUT qualifiers.
long lFlavor = 0;
var.Clear();
sc = pqs->Get(L"IN", 0, &var, &lFlavor);
if (SUCCEEDED(sc)) {
if (var.vt == VT_BOOL) {
if (var.boolVal) {
bHasInQual = TRUE;
}
}
}
lFlavor = 0;
var.Clear();
sc = pqs->Get(L"OUT", 0, &var, &lFlavor);
if (SUCCEEDED(sc)) {
if (var.vt == VT_BOOL) {
if (var.boolVal) {
bHasOutQual = TRUE;
}
}
}
if (bInput && !bHasInQual) {
sc = pqs->Put(L"In", &varTrue, NULL);
}
if (!bInput && !bHasOutQual) {
sc = pqs->Put(L"Out", &varTrue, NULL);
}
pqs->Release();
}
if(!PropertyExists(sc, m_pco, bstrPropName))
{
// dont copy the ReturnValue. the page takes care if it.
if (_wcsicmp(bstrPropName, L"ReturnValue") != 0)
{
// first occurence, just copy over.
CopyProperty(pco, bstrPropName, m_pco);
}
}
} //endfor
}
}
//--------------------------------------------------------
SCODE CParmGrid::CopyProperty(IWbemClassObject* pcoSrc, BSTR bstrSrc,
IWbemClassObject* pcoDst)
{
COleVariant varValue;
CIMTYPE cimtypeValue;
SCODE sc = DoGet(pcoSrc, NULL, bstrSrc, 0, &varValue, &cimtypeValue, NULL);
if(FAILED(sc))
{
return E_FAIL;
}
// Copy the property's value, creating the property if it doesn't
// currently exist.
if(::IsClass(pcoDst))
{
sc = DoPut(pcoDst, NULL, bstrSrc, 0,&varValue, cimtypeValue);
}
else
{
sc = DoPut(pcoDst, NULL, bstrSrc, 0,&varValue, 0);
}
if(FAILED(sc))
{
return sc;
}
sc = CopyQualifierSets(pcoSrc, bstrSrc, pcoDst);
return sc;
}
//-------------------------------------------------
SCODE CParmGrid::CopyQualifierSets(IWbemClassObject* pcoSrc, BSTR bstrSrc,
IWbemClassObject* pcoDst)
{
IWbemQualifierSet* pqsSrc = NULL;
SCODE sc = DoGetPropertyQualifierSet(pcoSrc, bstrSrc, &pqsSrc);
if(FAILED(sc))
{
return E_FAIL;
}
IWbemQualifierSet* pqsDst = NULL;
sc = DoGetPropertyQualifierSet(pcoDst, bstrSrc, &pqsDst);
if(FAILED(sc))
{
pqsSrc->Release();
return E_FAIL;
}
HRESULT hr;
hr = pqsSrc->BeginEnumeration(0);
ASSERT(SUCCEEDED(hr));
BSTR bstrName;
COleVariant varValue;
LONG lFlavor;
while (TRUE)
{
bstrName = NULL;
varValue.Clear();
lFlavor = 0;
hr = pqsSrc->Next(0, &bstrName, &varValue, &lFlavor);
if(hr == WBEM_S_NO_MORE_DATA)
{
break;
}
ASSERT(SUCCEEDED(hr));
if(::IsEqualNoCase(bstrName, L"CIMTYPE"))
{
continue;
}
lFlavor &= ~WBEM_FLAVOR_ORIGIN_PROPAGATED;
hr = pqsDst->Put(bstrName, &varValue, lFlavor);
::SysFreeString(bstrName);
ASSERT(SUCCEEDED(hr));
}
RELEASE(pqsSrc);
RELEASE(pqsDst);
return S_OK;
}
//-------------------------------------------------
void CParmGrid::UseSetFromClone(IWbemClassObject* pcoClone)
{
// NOTE: serves the qualifier dlg.
if(m_pco)
{
m_pco->Release();
}
pcoClone->AddRef();
m_pco = pcoClone;
}
//-------------------------------------------------
void CParmGrid::SetPropmarkers(int iRow,
IWbemClassObject* clsObj,
BOOL bRedrawCell)
{
CGridRow& row = GetRowAt(iRow);
CGridCell* pgcFlavor = &GetAt(iRow, ICOL_PROP_FLAVOR);
CGridCell* pgcKey = &GetAt(iRow, ICOL_PROP_KEY);
PropMarker marker;
CGridCell* pgcName = &GetAt(iRow, ICOL_PROP_NAME);
COleVariant varName, varID;
int ID = -1;
CIMTYPE cimtype = 0;
pgcName->GetValue(varName, cimtype);
// what's the mode?
IWbemQualifierSet* pqsSrc = NULL;
HRESULT hr = DoGetPropertyQualifierSet(clsObj, V_BSTR(&varName), &pqsSrc);
if(SUCCEEDED(hr))
{
BOOL itsaIN = SUCCEEDED(pqsSrc->Get(L"In", 0, NULL, NULL));
BOOL itsaOUT = SUCCEEDED(pqsSrc->Get(L"Out", 0, NULL, NULL));
// while I'm here... ;)
if(SUCCEEDED(pqsSrc->Get(L"ID", 0, &varID, NULL)))
{
ID = V_I4(&varID);
row.SetCurrMethodID(ID);
}
RELEASE(pqsSrc);
// which icon?
if(itsaIN && itsaOUT)
{
marker = METHODMARKER_INOUT;
}
else if(itsaIN)
{
marker = METHODMARKER_IN;
}
else if(_wcsicmp(V_BSTR(&varName), L"ReturnValue") == 0)
{
marker = METHODMARKER_RETURN;
// force to the end.
row.SetCurrMethodID(-1);
}
else // must be an simple outy.
{
marker = METHODMARKER_OUT;
}
}
else
{
row.SetCurrMethodID(iRow);
}
// did it actually change?
if(marker != pgcKey->GetPropmarker())
{
pgcKey->SetPropmarker(marker);
RedrawCell(iRow, ICOL_PROP_KEY);
}
BOOL bReadonly = row.IsReadonly();
switch(row.GetFlavor())
{
case WBEM_FLAVOR_ORIGIN_SYSTEM:
marker = PROPMARKER_RSYS;
break;
case WBEM_FLAVOR_ORIGIN_PROPAGATED:
marker = PROPMARKER_RINHERITED;
break;
case WBEM_FLAVOR_ORIGIN_LOCAL:
marker = (bReadonly ? PROPMARKER_RLOCAL:PROPMARKER_LOCAL);
break;
default:
marker = PROPMARKER_LOCAL;
break;
}
if(marker != pgcFlavor->GetPropmarker())
{
pgcFlavor->SetPropmarker(marker);
if(bRedrawCell)
{
RedrawCell(iRow, ICOL_PROP_FLAVOR);
}
}
}
//----------------------------------------------------------------------------
BOOL CParmGrid::OnCellFocusChange(int iRow, int iCol,
int iNextRow, int iNextCol,
BOOL bGotFocus)
{
SCODE sc;
if(!bGotFocus)
{
if(!m_bDiscardOldObject)
{
// The current cell is losing focus, so put the row to the
// database. However, it isn't necessary to save the current
// properties when if the grid is being cleared.
if((m_iCurrentRow != NULL_INDEX) &&
(m_iCurrentCol != NULL_INDEX))
{
sc = SyncCellEditor();
if(FAILED(sc))
{
if(!m_bShowingInvalidCellMessage)
{
m_bShowingInvalidCellMessage = TRUE;
HmmvErrorMsg(IDS_ERR_INVALID_CELL_VALUE, sc,
FALSE, NULL, _T(__FILE__), __LINE__);
m_bShowingInvalidCellMessage = FALSE;
}
return FALSE;
}
COleVariant varName, varQualValue;
CIMTYPE cimtype = 0;
CGridCell* pgcName = &GetAt(m_iCurrentRow, ICOL_PROP_NAME);
pgcName->GetValue(varName, cimtype);
if(_wcsicmp(V_BSTR(&varName), L"ReturnValue") == 0)
{
if(!m_bShowingInvalidCellMessage)
{
m_bShowingInvalidCellMessage = TRUE;
HmmvErrorMsg(IDS_ERR_NO_RETVALS, sc,
FALSE, NULL, _T(__FILE__), __LINE__);
m_bShowingInvalidCellMessage = FALSE;
}
pgcName->SetValue(CELLTYPE_NAME, V_BSTR(&m_varCurrentName), CIM_STRING);
RedrawCell(m_iCurrentRow, ICOL_PROP_NAME);
UpdateWindow();
return FALSE;
}
if(RowWasModified(m_iCurrentRow))
{
sc = PutProperty(m_iCurrentRow, m_pco);
if(FAILED(sc))
return FALSE;
}
// default to out mode?
varQualValue.vt = VT_BOOL;
varQualValue.boolVal = VARIANT_TRUE;
IWbemQualifierSet* pqsSrc = NULL;
HRESULT hr = DoGetPropertyQualifierSet(m_pco, V_BSTR(&varName), &pqsSrc);
if(SUCCEEDED(hr))
{
// hr = pqsSrc->Put(L"OUT", &varQualValue, NULL);
CGridRow *row = &GetRowAt(m_iCurrentRow);
varQualValue = COleVariant((long)row->GetCurrMethodID());
hr = pqsSrc->Put(L"ID", &varQualValue, NULL);
RELEASE(pqsSrc);
}
}
}
m_iCurrentRow = NULL_INDEX;
m_iCurrentCol = NULL_INDEX;
m_varCurrentName = _T("");
}
else
{
m_iCurrentRow = iRow;
m_iCurrentCol = iCol;
if(iRow!=NULL_INDEX)
{
CGridCell* pgcName = &GetAt(iRow, ICOL_PROP_NAME);
CIMTYPE cimtype = 0;
pgcName->GetValue(m_varCurrentName, cimtype);
ASSERT(cimtype == CIM_STRING);
}
// should the up/down btns be available?
if((m_iCurrentCol == NULL_INDEX) &&
(m_iCurrentRow <= GetRows() -2))
{
m_pg->m_IDUp.EnableWindow(true);
m_pg->m_IDDown.EnableWindow(true);
}
else
{
m_pg->m_IDUp.EnableWindow(false);
m_pg->m_IDDown.EnableWindow(false);
}
}
return TRUE;
}
//-------------------------------------------------
void CParmGrid::OnCellClicked(int iRow, int iCol)
{
// suppress the 'deleting key' msg.
if(iCol != ICOL_PROP_KEY)
{
CPropGrid::OnCellClicked(iRow, iCol);
}
}
void CParmGrid::OnRowCreated(int iRow)
{
SCODE sc = PutProperty(iRow);
ASSERT(SUCCEEDED(sc));
COleVariant varName, varQualValue;
CGridCell* pgcName = &GetAt(iRow, ICOL_PROP_NAME);
CIMTYPE cimtype;
pgcName->GetValue(varName, cimtype);
varQualValue.vt = VT_BOOL;
varQualValue.boolVal = VARIANT_TRUE;
IWbemQualifierSet* pqs = NULL;
HRESULT hr = DoGetPropertyQualifierSet(m_pco, V_BSTR(&varName), &pqs);
if(SUCCEEDED(hr))
{
hr = pqs->Put(L"OUT", &varQualValue, NULL);
CGridRow *row = &GetRowAt(iRow);
varQualValue = COleVariant((long)row->GetCurrMethodID());
hr = pqs->Put(L"ID", &varQualValue, NULL);
RELEASE(pqs);
}
}
//-------------------------------------------------
void CParmGrid::SerializeMethodID(CGridRow &row)
{
// get the property name.
CGridCell& pgcName = row[ICOL_PROP_NAME];
COleVariant varPropName;
CIMTYPE cimtype = 0;
pgcName.GetValue(varPropName, cimtype);
// get the qualset.
IWbemQualifierSet* pqsSrc = NULL;
HRESULT hr = DoGetPropertyQualifierSet(m_pco, V_BSTR(&varPropName), &pqsSrc);
if(SUCCEEDED(hr))
{
// poke the m_currID into the qualset.
COleVariant varQualValue((long)row.GetCurrMethodID());
hr = pqsSrc->Put(L"ID", &varQualValue, NULL);
RELEASE(pqsSrc);
}
}
//-------------------------------------------------
void CParmGrid::MoveRowUp(void)
{
int iSelectedRow = GetSelectedRow();
// ASSUMPTION: -1 cuz its zero-based. -2 more cuz I always
// have a "returnValue" and blank. Cant swapRows in execute
// mode which doesn't have the blank row.
int lastGoodRow = GetRows() -2;
// its not one of the last 2 "special" rows and not at the
// top already.
if((iSelectedRow <= lastGoodRow) &&
(iSelectedRow != 0) &&
(iSelectedRow != NULL_INDEX))
{
// ok to swap.
SwapRows(iSelectedRow, iSelectedRow -1);
CGridRow *upperRow = &GetRowAt(iSelectedRow -1);
CGridRow *selRow = &GetRowAt(iSelectedRow);
int upperID = upperRow->GetCurrMethodID();
int selID = selRow->GetCurrMethodID();
selRow->SetCurrMethodID(upperID);
SerializeMethodID(*selRow);
upperRow->SetCurrMethodID(selID);
SerializeMethodID(*upperRow);
}
}
//-------------------------------------------------
void CParmGrid::MoveRowDown(void)
{
int iSelectedRow = GetSelectedRow();
// ASSUMPTION: -1 cuz its zero-based. -2 more cuz I always
// have a "returnValue" and blank. Cant swapRows in execute
// mode.
int lastGoodRow = GetRows() -2;
// its not the lastGoodRow (or the last 2 "special" rows)
if((iSelectedRow < lastGoodRow) &&
(iSelectedRow != NULL_INDEX))
{
// ok to swap.
SwapRows(iSelectedRow, iSelectedRow +1);
CGridRow *selRow = &GetRowAt(iSelectedRow);
CGridRow *lowerRow = &GetRowAt(iSelectedRow +1);
int selID = selRow->GetCurrMethodID();
int lowerID = lowerRow->GetCurrMethodID();
selRow->SetCurrMethodID(lowerID);
SerializeMethodID(*selRow);
lowerRow->SetCurrMethodID(selID);
SerializeMethodID(*lowerRow);
}
}
//-------------------------------------------------
void CParmGrid::Empty(IWbemClassObject *obj)
{
CMosNameArray aPropNames;
HRESULT hr = aPropNames.LoadPropNames(obj, NULL, WBEM_FLAG_NONSYSTEM_ONLY, NULL);
if(SUCCEEDED(hr))
{
int nPropNames = aPropNames.GetSize();
for(int iPropName = 0; iPropName < nPropNames; ++iPropName)
{
BSTR bstrPropName = aPropNames[iPropName];
hr = obj->Delete(bstrPropName);
} //endfor
}
}
//-------------------------------------------------
SCODE CParmGrid::Serialize()
{
CDisableModifyCreate DisableModifyCreate(this);
Empty(m_pg->m_psheet->m_inSig);
Empty(m_pg->m_psheet->m_outSig);
// dump the grid to m_pco.
CPropGrid::Serialize();
// split m_pco into m_inSig and m_outSig.
CMosNameArray aPropNames;
bool gottaIN = false, gottaOUT = false;
SCODE sc = aPropNames.LoadPropNames(m_pco, NULL, WBEM_FLAG_NONSYSTEM_ONLY, NULL);
if(SUCCEEDED(sc))
{
int nPropNames = aPropNames.GetSize();
for(int iPropName = 0; iPropName < nPropNames; ++iPropName)
{
BSTR bstrPropName = aPropNames[iPropName];
// want is it?
IWbemQualifierSet* pqsSrc = NULL;
HRESULT hr = DoGetPropertyQualifierSet(m_pco, bstrPropName, &pqsSrc);
long lFlavor;
COleVariant var;
CString sFormat;
CString sMessage;
CString sPropName;
lFlavor = 0;
var.Clear();
sc = pqsSrc->Get(L"ID", 0, &var, &lFlavor);
if (FAILED(sc)) {
sPropName = bstrPropName;
sFormat.LoadString(IDS_ERR_MISSING_ID_QUAL);
sMessage.Format(sFormat, sPropName);
HmmvErrorMsgStr(sMessage, WBEM_E_INVALID_PARAMETER,
FALSE, NULL, _T(__FILE__), __LINE__);
return WBEM_E_INVALID_PARAMETER;
}
BOOL itsaIN = FALSE;
BOOL itsaOUT = FALSE;
lFlavor = 0;
var.Clear();
sc = pqsSrc->Get(L"IN", 0, &var, &lFlavor);
if (SUCCEEDED(sc)) {
if (var.vt == VT_BOOL) {
if (var.boolVal) {
itsaIN = TRUE;
}
}
}
lFlavor = 0;
var.Clear();
sc = pqsSrc->Get(L"OUT", 0, &var, &lFlavor);
if (SUCCEEDED(sc)) {
if (var.vt == VT_BOOL) {
if (var.boolVal) {
itsaOUT = TRUE;
}
}
}
// who wants it?
if(itsaIN)
{
gottaIN = true;
CopyProperty(m_pco, bstrPropName, m_pg->m_psheet->m_inSig);
}
if(itsaOUT)
{
gottaOUT = true;
CopyProperty(m_pco, bstrPropName, m_pg->m_psheet->m_outSig);
}
RELEASE(pqsSrc);
if (!itsaIN && !itsaOUT) {
sPropName = bstrPropName;
sFormat.LoadString(IDS_NO_INOUT_QUAL);
sMessage.Format(sFormat, sPropName);
HmmvErrorMsgStr(sMessage, WBEM_E_INVALID_PARAMETER,
FALSE, NULL, _T(__FILE__), __LINE__);
return WBEM_E_INVALID_PARAMETER;
}
} //endfor
}
return S_OK;
}
//-------------------------------------------------
void CParmGrid::OnBuildContextMenu(CMenu *pPopup,
int iRow)
{
if(pPopup)
{
UINT editFlags = MF_STRING;
UINT exeFlags = MF_STRING;
// get the REAL one.
IWbemClassObject *pco = CPropGrid::CurrentObject();
pPopup->RemoveMenu(ID_CMD_CREATE_VALUE,
MF_BYCOMMAND);
// change the first item to "method qualifiers...".
CString newName;
newName.LoadString(IDS_PARAM_QUALIFIER);
// it its NOT using this ID...
if(!pPopup->ModifyMenu(ID_CMD_SHOW_PROP_ATTRIBUTES,
MF_BYCOMMAND | MF_STRING,
ID_CMD_SHOW_PROP_ATTRIBUTES,
(LPCTSTR)newName))
{
// then it must be the cell editor menu which uses
// this ID.
pPopup->ModifyMenu(ID_CMD_SHOW_SELECTED_PROP_ATTRIBUTES,
MF_BYCOMMAND | MF_STRING,
ID_CMD_SHOW_SELECTED_PROP_ATTRIBUTES,
(LPCTSTR)newName);
}
pPopup->RemoveMenu(ID_CMD_SHOW_OBJECT_ATTRIBUTES, MF_BYCOMMAND);
CPropGrid::OnBuildContextMenu(pPopup, iRow);
}
}
void CParmGrid::OnBuildContextMenuEmptyRegion(CMenu *pPopup, int iRow)
{
// This virtual method allows derived classes to override the context
// menu that is displayed when the user clicks over an empty part of
// the grid.
// Do nothing, but allow derived classes to override.
pPopup->RemoveMenu(ID_CMD_SHOW_OBJECT_ATTRIBUTES, MF_BYCOMMAND);
// change the first item to "method qualifiers...".
CString newName;
newName.LoadString(IDS_PARAM_QUALIFIER);
// it its NOT using this ID...
if(pPopup->ModifyMenu(ID_CMD_SHOW_PROP_ATTRIBUTES,
MF_BYCOMMAND | MF_STRING,
ID_CMD_SHOW_PROP_ATTRIBUTES,
(LPCTSTR)newName))
{
pPopup->EnableMenuItem(ID_CMD_SHOW_PROP_ATTRIBUTES, MF_DISABLED | MF_GRAYED);
}
else {
// then it must be the cell editor menu which uses
// this ID.
pPopup->ModifyMenu(ID_CMD_SHOW_SELECTED_PROP_ATTRIBUTES,
MF_BYCOMMAND | MF_STRING,
ID_CMD_SHOW_SELECTED_PROP_ATTRIBUTES,
(LPCTSTR)newName);
pPopup->EnableMenuItem(ID_CMD_SHOW_SELECTED_PROP_ATTRIBUTES, MF_DISABLED | MF_GRAYED);
}
}
//*******************************************************************
// CParmGrid::DoEditRowQualifier
//
// Override the qualifier edit method so that we can invoke the proper
// method in the qualifier editor for editing method parameters.
//
// Parameters:
// [in] BSTR bstrPropName
// The name of the property being edited.
//
// [in] BOOL bReadOnly
// TRUE if the property is read only.
//
// [in] IWbemClassObject* pco
// Pointer to the WBEM class object being edited.
//
// Returns:
// int
// Status indicating whether or not the property sheet was canceled.
//
//*************************************************************************
INT_PTR CParmGrid::DoEditRowQualifier(BSTR bstrPropName, BOOL bReadOnly, IWbemClassObject* pco)
{
CPsQualifiers sheet(m_psv, NULL, !HasCol(ICOL_PROP_TYPE), this);
INT_PTR iResult = sheet.EditMethodParamQualifiers(bstrPropName,
ReadOnlyQualifiers(),
pco);
return iResult;
}
Reference in New Issue View Git Blame Copy Permalink