// 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 "PpgQualifiers.h"
#include "PsQualifiers.h"
#include "SingleViewCtl.h"
#include "icon.h"
#include "hmomutil.h"
#include "globals.h"
#include "path.h"
#include "Methods.h"
#include "hmmverr.h"

#include "PpgMethodParms.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

BEGIN_MESSAGE_MAP(CMethodGrid, CPropGrid)
	//{{AFX_MSG_MAP(CPropGrid)
	//}}AFX_MSG_MAP
	ON_COMMAND(ID_CMD_SHOW_METHOD_PARMS, OnCmdShowMethodParms)
	ON_COMMAND(ID_CMD_EXE_METHOD, OnCmdExeMethod)
END_MESSAGE_MAP()

//#include "DlgArray.h"

//***************************************************************
// CMethodGrid::CMethodGrid
//
// Construct the methods grid.
//
// Parameters:
//	    CSingleViewCtrl* psv
//			Backpointer to the main control.
//
// Returns:
//		Nothing.
//
//**************************************************************
CMethodGrid::CMethodGrid(CSingleViewCtrl* psv)
				: CPropGrid(psv, false)
{
	m_renameInSig = NULL;
	m_renameOutSig = NULL;
}

//**************************************************************
// CMethodGrid::~CMethodGrid
//
// Destructor for the property grid.
//
// Parameters:
//		None.
//
// Returns:
//		Nothing.
//
//***************************************************************
CMethodGrid::~CMethodGrid()
{
}

//--------------------------------------------------------
bool CMethodGrid::HasCol(int icol)
{
	switch(icol)
	{
	case ICOL_PROP_NAME:
	case ICOL_PROP_KEY:
	case ICOL_PROP_FLAVOR:
		return true;

	default:
		return false;
	}
}

//--------------------------------------------------------
IWbemClassObject* CMethodGrid::CurrentObject()
{
	IWbemClassObject* pco = CPropGrid::CurrentObject();

	if(pco == NULL)
		return NULL;

	// NOTE: methods only exist on the class.
	// if this is an instance, switch to its class.
	if(!::IsClass(pco))
	{
		VARIANT varVal;

		IWbemServices *service = m_psv->GetProvider();
		if (service == NULL) {
			return NULL;
		}

		if(SUCCEEDED(pco->Get((BSTR)L"__CLASS", 0,
								&varVal, NULL, NULL)))
		{
			// BIG NOTE: GetObject(4rd parm) has to point to
			// a NULL. If it doesn't, that ptr will be released
			// cuz COM figures you're getting rid of a copy of
			// that ptr. Since pco is copy
			pco = NULL;

			if(FAILED(service->GetObject(V_BSTR(&varVal), 0L, //WBEM_FLAG_USE_AMENDED_QUALIFIERS,
											NULL, &pco, NULL)))
			{
				// couldnt find the class definition.
				return NULL;
			}
		}
	}

	return pco;
}

//************************************************************
// The default column widths.  Note that the width of some columns
// may be computed at runtime and that the default value may not
// be used.
#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 CXMIN_COL_NAME 50

BOOL CMethodGrid::Create(CRect& rc, CWnd* pwndParent, UINT nId, BOOL bVisible)
{
	// Set the column widths of those columns who's width is computed from
	// the client rectangle instead of using the default width.  For the
	// properties grid, only the "Value" column width is computed.


	int cxClient = rc.Width() - GetRowHandleWidth();
	int cxCol = CXMIN_COL_NAME;
	if (cxClient > IX_COL_NAME )
	{
		cxCol = cxClient - CX_COL_NAME;
	}
	SetColumnWidth(ICOL_PROP_NAME, cxCol, FALSE);
	BOOL bDidCreate = CGrid::Create(rc, pwndParent, nId, bVisible);
	if (bDidCreate)
	{
		m_psv->GetGlobalNotify()->AddClient((CNotifyClient*) this);
	}

	return bDidCreate;
}

//-----------------------------------------------
HRESULT CMethodGrid::DoGet(IWbemClassObject* pco,
							CGridRow *row,
							BSTR Name,
							long lFlags,
							VARIANT *pVal,
							CIMTYPE *pType,
							long *plFlavor)
{
	HRESULT retval = 0;
	if (pco == NULL)
	{
		ASSERT(FALSE);
		return E_FAIL;
	}
	else
	{
		IWbemClassObject *pInSignature;
        IWbemClassObject *pOutSignature;

		retval = pco->GetMethod(Name, lFlags,
								&pInSignature,
								&pOutSignature);

		// write the signatures to the backing store.
		if(row)
		{
			row->SetMethodSignatures(pInSignature, pOutSignature);
		}
		else // cant store in the row, must be that rename scenario.
		{
			m_renameInSig = pInSignature;
			m_renameOutSig = pOutSignature;
		}
		return retval;
	}
}

//-----------------------------------------------
HRESULT CMethodGrid::DoPut(IWbemClassObject* pco,
							CGridRow *row,
							BSTR Name,
							long lFlags,
							VARIANT *pVal,
							CIMTYPE Type)
{
	HRESULT hr = S_OK;

	if(pco == NULL)
	{
		ASSERT(FALSE);
		return E_FAIL;
	}
	else
	{
		// get the signatures.
		IWbemClassObject *pInSignature = NULL;
        IWbemClassObject *pOutSignature = NULL;

		if(row)
		{
			row->GetMethodSignatures(&pInSignature, &pOutSignature);
		}
		else // cant get from the row, must be that rename scenario.
		{
			pInSignature = m_renameInSig;
			pOutSignature = m_renameOutSig;
		}

		hr = pco->PutMethod(Name,lFlags,
							pInSignature,
							pOutSignature);

		// clean it up.
		pInSignature = NULL;
		pOutSignature = NULL;
	}
	return hr;
}

//-----------------------------------------------
HRESULT CMethodGrid::DoDelete(IWbemClassObject* pco,
							BSTR Name)
{
	if (pco == NULL)
	{
		ASSERT(FALSE);
		return E_FAIL;
	}
	else
	{
		return pco->DeleteMethod(Name);
	}
}

//-----------------------------------------------
HRESULT CMethodGrid::DoGetPropertyQualifierSet(IWbemClassObject* pco,
												BSTR pProperty,
												IWbemQualifierSet **ppQualSet)
{
	if (pco == NULL)
	{
		ASSERT(FALSE);
		return E_FAIL;
	}
	else
	{
		return pco->GetMethodQualifierSet(pProperty, ppQualSet);
	}
}

//-----------------------------------------------
#define QUAL_STATIC 1
#define QUAL_IMPLEMENTED 2

void CMethodGrid::CheckQualifierSettings(IWbemClassObject *pco,
										 BSTR varMethName,
										 BYTE *retval,
										 bool *foundImp, bool *foundStatic)
{
	// get the method's qualifiers at this level.
	HRESULT hr = 0;
	IWbemQualifierSet *pqs = NULL;
	COleVariant qual;
	//VariantInit(&qual);

	hr = DoGetPropertyQualifierSet(pco, varMethName, &pqs);
	if(SUCCEEDED(hr))
	{
		// check for 'IMPLEMENTED'
		if(!(*foundImp) &&
			SUCCEEDED(pqs->Get(L"IMPLEMENTED", 0, &qual, NULL)) &&
			V_BOOL(&qual) == VARIANT_TRUE)
		{
			*retval |= QUAL_IMPLEMENTED;
			*foundImp = true; // just need one.
		}
	//	VariantClear(&qual);

		// check for 'DISABLED'
		if(!(*foundImp) &&
			SUCCEEDED(pqs->Get(L"DISABLED", 0, &qual, NULL)) &&
			V_BOOL(&qual) == VARIANT_TRUE)
		{
			// leave QUAL_IMPLEMENTED cleared.
			*foundImp = true;    // just need one.
		}
	//	VariantClear(&qual);

		// check for 'STATIC'
		if(!(*foundStatic) &&
			SUCCEEDED(pqs->Get(L"STATIC", 0, &qual, NULL)) &&
			V_BOOL(&qual) == VARIANT_TRUE)
		{
			*retval |= QUAL_STATIC;
			*foundStatic = true;
		}
	//	VariantClear(&qual);

		if(pqs)
		{
			pqs->Release();
			pqs = NULL;
		}
	} //endif DoGetPropertyQualifierSet()
}

//---------------------------------------------------------------------
BYTE CMethodGrid::GetQualifierSettings(int iRow, IWbemClassObject *pco)
{
	// start with all the bits cleared, the logic with only SET the flags
	// when the right qualifier is found.
	BYTE retval = 0;
	bool foundImp = false, foundStatic = false;
	bool fakeClass = false;

	// get the class if this isa instance.
	IWbemClassObject *pClass = NULL;

	// if from a class....
	if(::IsClass(pco))
	{
		// use it
		pClass = pco;
	}
	else
	{
		// get the associated class.
		pClass = CurrentObject();
		fakeClass = true;
	}


	HRESULT hr;

	// get method name.
	CGridCell& gcName = GetAt(iRow, ICOL_PROP_NAME);
	COleVariant varMethName;
	CIMTYPE cimtype = 0;
	gcName.GetValue(varMethName, cimtype);

	CheckQualifierSettings(pClass, V_BSTR(&varMethName),
							&retval, &foundImp, &foundStatic);


	// Wasn't local... get __DERIVATION list
	COleVariant vClassList;   // VT_ARRAY | VT_BSTR

	if(!foundImp && !foundStatic &&
		SUCCEEDED(hr = pClass->Get(L"__DERIVATION", 0, &vClassList, NULL, NULL)) &&
		(V_VT(&vClassList) & VT_ARRAY) )
	{
		// safearray stuff.
		SAFEARRAY *classList = NULL;
		IWbemServices *service = m_psv->GetProvider();

		if(service == NULL)
		{
			return 0;
		}

		// cast to safe array.
		classList = V_ARRAY(&vClassList);

		IWbemClassObject *pco1 = NULL;
		LONG lLowerBound;
		LONG lUpperBound;
		hr = SafeArrayGetLBound(classList, 1, &lLowerBound);
		hr = SafeArrayGetUBound(classList, 1, &lUpperBound);

		// walk DOWN the derivation list until we find the the two flags
		// we want.
		for(LONG lIndex = lLowerBound;
					((lIndex <= lUpperBound) &&
					  !foundImp &&
					  !foundStatic);
								++lIndex)
		{
			BSTR bstrSrc;
			hr = SafeArrayGetElement(classList, &lIndex, &bstrSrc);

			//get each object.
			if(SUCCEEDED(service->GetObject(bstrSrc, WBEM_FLAG_USE_AMENDED_QUALIFIERS,
											NULL, &pco1, NULL)))
			{
				CheckQualifierSettings(pco1, V_BSTR(&varMethName),
										&retval, &foundImp, &foundStatic);
				pco1->Release();
				pco1 = NULL;

			} // endif GetObject

		} //endfor

	} // endif pco->Get(__DERIVATION)

	// if we got our own pClass, clean it up.
	if(fakeClass && pClass)
	{
		pClass->Release();
		pClass = NULL;
	}

	return retval;
}

//-------------------------------------------------
void CMethodGrid::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_METH_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->AppendMenu(MF_SEPARATOR);

		BYTE qualFlags = GetQualifierSettings(iRow, pco);

		// if from a class...
		if(::IsClass(pco))
		{
			// and its not static or not implemented...
			if((!(qualFlags & QUAL_STATIC)) ||
			   (!(qualFlags & QUAL_IMPLEMENTED)))
			{
				// dont execute it.
				exeFlags |= MF_GRAYED;
			}
			// but editting is ok.
		}
		else	// from an instance...
		{
			// but not implemented (or explicitly disabled)...
			if(!(qualFlags & QUAL_IMPLEMENTED))
			{
				// dont execute
				exeFlags |= MF_GRAYED;
			}

			// cant edit parms.
			editFlags |= MF_GRAYED;
		}

		TCHAR buf[64];
		memset(buf, 0, 64);

		if(LoadString(AfxGetInstanceHandle(),
						ID_CMD_SHOW_METHOD_PARMS,
						buf, 64))
		{
			pPopup->AppendMenu(editFlags,
								ID_CMD_SHOW_METHOD_PARMS,
								buf);
		}

		memset(buf, 0, 64);
		if(LoadString(AfxGetInstanceHandle(),
						ID_CMD_EXE_METHOD,
						buf, 64))
		{
			pPopup->AppendMenu(exeFlags,
								ID_CMD_EXE_METHOD,
								buf);
		}
	}

	BOOL bDidRemove;
	bDidRemove = pPopup->RemoveMenu(ID_CMD_GOTO_OBJECT, MF_BYCOMMAND);

}




void CMethodGrid::ModifyCellEditContextMenu(int iRow, int iCol, CMenu& menu)
{

	CMenu* pPopup = menu.GetSubMenu(0);
	ASSERT(pPopup != NULL);

	BOOL bDidRemove = FALSE;
	bDidRemove = pPopup->RemoveMenu(ID_CMD_GOTO_OBJECT, MF_BYCOMMAND);

	// bug#55134
	// It appears that the following two commands do not belong on the context
	// menu when looking at methods.  Therefore, we always remove them for the
	// CMethodGrid
	pPopup->RemoveMenu( ID_CMD_SET_CELL_TO_NULL, MF_BYCOMMAND);
	pPopup->RemoveMenu(ID_CMD_CREATE_VALUE, MF_BYCOMMAND);

	// bug#55569
	// change the "property qualifiers" item to "method qualifiers...".
	CString newName;
	newName.LoadString(IDS_METH_QUALIFIER);

	if(!pPopup->ModifyMenu(ID_CMD_SHOW_SELECTED_PROP_ATTRIBUTES,
						MF_BYCOMMAND | MF_STRING,
						ID_CMD_SHOW_SELECTED_PROP_ATTRIBUTES,
						(LPCTSTR)newName))
	{
		ASSERT(FALSE);
	}



#if 0
	if (iRow == IndexOfEmptyRow()) {
		pPopup->EnableMenuItem(ID_CMD_SHOW_SELECTED_PROP_ATTRIBUTES, MF_DISABLED | MF_GRAYED);
		pPopup->RemoveMenu( ID_CMD_SET_CELL_TO_NULL, MF_BYCOMMAND);
		pPopup->RemoveMenu(ID_CMD_GOTO_OBJECT, MF_BYCOMMAND);

        // store for the cmd handlers.
    	m_curRow = &GetRowAt(iRow);
    	OnBuildContextMenu(pPopup, iRow);
		return;
	}




	BOOL bIsSystemProperty = FALSE;
	COleVariant varPropName;
	CIMTYPE cimtype = 0;

	CGridCell& gc = GetAt(iRow, ICOL_PROP_NAME);
	gc.GetValue(varPropName, cimtype);

	BOOL bCanShowPropQualifiers = TRUE;
	if (iRow == IndexOfEmptyRow()) {
		bCanShowPropQualifiers = FALSE;
	}
	else
	{
		if (cimtype != CIM_STRING || varPropName.vt != VT_BSTR)
		{
			bCanShowPropQualifiers = FALSE;
		}
		else
		{
			if (IsSystemProperty(varPropName.bstrVal))
			{
				bCanShowPropQualifiers = FALSE;
			}
		}
	}

	pPopup->EnableMenuItem(ID_CMD_SHOW_SELECTED_PROP_ATTRIBUTES, bCanShowPropQualifiers ? MF_ENABLED : MF_DISABLED | MF_GRAYED);

	SetMenuDefaultItem(pPopup->GetSafeHmenu(),
						ID_CMD_SHOW_SELECTED_PROP_ATTRIBUTES,
						FALSE);

	CGridCell *gcValue = NULL;
	if(HasCol(ICOL_PROP_VALUE))
	{
		gcValue = &GetAt(iRow, ICOL_PROP_VALUE);
		BOOL bCanCreateObject = gcValue->IsObject() && gcValue->IsNull();
		BOOL bCanCreateArray = gcValue->IsArray() && gcValue->IsNull();
		BOOL bIsReadonly = gcValue->IsReadonly();

		if(gcValue && (bIsReadonly || !(bCanCreateObject || bCanCreateArray)))
		{
			pPopup->RemoveMenu(ID_CMD_CREATE_VALUE, MF_BYCOMMAND);
		}
	}
	else
	{
		pPopup->RemoveMenu(ID_CMD_CREATE_VALUE, MF_BYCOMMAND);
	}



	if (iCol != ICOL_PROP_VALUE)
	{
		pPopup->RemoveMenu( ID_CMD_SET_CELL_TO_NULL, MF_BYCOMMAND);
	}
	else
	{
		BOOL bCanSetToNull = TRUE;
		CGridCell& gc = GetAt(iRow, iCol);
		DWORD dwFlags = gc.GetFlags();
		if ((dwFlags & CELLFLAG_READONLY)  || (dwFlags & CELLFLAG_NOTNULL))
		{
			bCanSetToNull = FALSE;
		}
		if (gc.IsNull()) {
			bCanSetToNull = FALSE;
		}

		pPopup->EnableMenuItem(ID_CMD_SET_CELL_TO_NULL, bCanSetToNull ? MF_ENABLED : MF_DISABLED | MF_GRAYED);
	}

	// store for the cmd handlers.
	m_curRow = &GetRowAt(iRow);
	OnBuildContextMenu(pPopup, iRow);
#endif //0

}




//-------------------------------------------------
void CMethodGrid::OnCmdShowMethodParms()
{
	BSTR methName;
	COleVariant varName;
	CIMTYPE cimtype = 0;
	int iRow = m_curRow->GetRow();
	CGridCell* nameCell = &GetAt(iRow, ICOL_PROP_NAME);
	nameCell->GetValue(varName, cimtype);
	methName = V_BSTR(&varName);

	// NOTE: m_curRow was set during context menu contruction.
	m_psv->ShowMethodParms(m_curRow, methName, true);
}

//-------------------------------------------------
void CMethodGrid::OnCmdExeMethod()
{
	BSTR methName;
	COleVariant varName;
	CIMTYPE cimtype = 0;
	int iRow = m_curRow->GetRow();
	CGridCell* nameCell = &GetAt(iRow, ICOL_PROP_NAME);
	nameCell->GetValue(varName, cimtype);
	methName = V_BSTR(&varName);

	// NOTE: m_curRow was set during context menu contruction.
	m_psv->ShowMethodParms(m_curRow, methName, false);
}

//-------------------------------------------------
void CMethodGrid::Refresh()
{
	m_bShowingInvalidCellMessage = FALSE;

	CDisableModifyCreate  DisableModifyCreate(this);

	m_bDiscardOldObject = TRUE;
	Empty();
	m_bDiscardOldObject = FALSE;

	// Load the properties of the new object.
	IWbemClassObject* pco = CurrentObject();
	if (pco == NULL)
	{
		return;
	}

	HRESULT hr = 0;
	SCODE sc = 0;

	ClearRows();

	BOOL bEditValueOnly = CanEditValuesOnly();


	if(SUCCEEDED(hr = pco->BeginMethodEnumeration(0)))
	{
		IWbemClassObject *inSig = 0, *outSig = 0;
		BSTR bstrPropname;

		while((hr = pco->NextMethod(0, &bstrPropname, &inSig, &outSig)) != WBEM_S_NO_MORE_DATA)
		{
			long lRow = GetRows();
			InsertRowAt(lRow);

			if(SUCCEEDED(sc = LoadProperty(lRow, bstrPropname, bEditValueOnly, pco)))
			{
				CGridRow& row = GetRowAt(lRow);

				// write the signatures to the backing store.
				row.SetMethodSignatures(inSig, outSig);
			}

			if (FAILED(sc))
			{
				DeleteRowAt(lRow);
			}

			SysFreeString(bstrPropname);

		} //endwhile

		pco->EndMethodEnumeration();

	} //endif BeginMethodEnumeration()



	int nRows = GetRows();
	if (m_psv->ObjectIsClass() && IsInSchemaStudioMode())
	{
		// When viewing a class,
		// Add an empty row at the bottom.
		InsertRowAt(nRows);
	}

	if (nRows > 0)
	{
		SortGrid(0, nRows - 1, ICOL_PROP_NAME);
	}

	UpdateScrollRanges();
	UpdateWindow();
}

//*********************************************************************
SCODE CMethodGrid::LoadProperty(const LONG lRowDst,
								BSTR bstrPropName,
								BOOL bEditValueOnly,
								IWbemClassObject *clsObj)
{
	IWbemClassObject* pco;
	if(clsObj == NULL)
	{
		pco = CurrentObject();
	}
	else
	{
		pco = clsObj;
	}

	if (pco == NULL)
	{
		ASSERT(FALSE);
		return E_FAIL;
	}

	SCODE sc;
	ASSERT(bstrPropName != NULL);
	if (bstrPropName == NULL)
	{
		return E_FAIL;
	}

	long lFlavor = 0;
	CGridRow& row = GetRowAt(lRowDst);


	sc = DoGet(pco, (CGridRow *)&row, bstrPropName, 0, NULL, NULL, &lFlavor);
	if (sc != WBEM_S_NO_ERROR)
	{
		ASSERT(FAILED(sc));
		if (FAILED(sc))
		{
			CString sName = bstrPropName;

			CString sFormat;
			sFormat.LoadString(IDS_ERR_PROPERTY_GET_FAILED);
			LPTSTR pszMessage = m_psv->MessageBuffer();
#ifdef _UNICODE
			swprintf(pszMessage, (LPCTSTR) sFormat, (LPCTSTR) sName);
#else
			sprintf(pszMessage, (LPCTSTR) sFormat, (LPCTSTR) sName);
#endif //_UNICODE

			HmmvErrorMsgStr(pszMessage,  sc,   FALSE,  NULL, _T(__FILE__),  __LINE__);
			return E_FAIL;
		}
	}


	// Use the filter flags to filter out any properties
	// that should not be displayed.  Returning a failure
	// code will prevent the property from being added to
	// the grid.
	long lPropFilter = m_psv->GetPropertyFilter();
	BOOL bIsSystemProperty = FALSE;
	switch(lFlavor)
	{
	case WBEM_FLAVOR_ORIGIN_SYSTEM:
		if (!(lPropFilter & PROPFILTER_SYSTEM))
		{
			return E_FAIL;
		}

		// Only the value of a system property can be edited.
		bIsSystemProperty = TRUE;
		break;
	case WBEM_FLAVOR_ORIGIN_PROPAGATED:
		if (!(lPropFilter & PROPFILTER_INHERITED))
		{
			return E_FAIL;
		}
		break;
	}

	CGridCell* pgcName;
	CGridCell* pgcFlavor;
	CGridCell* pgcKey;


	pgcKey = &GetAt(lRowDst, ICOL_PROP_KEY);
	pgcFlavor = &GetAt(lRowDst, ICOL_PROP_FLAVOR);
	pgcName = &GetAt(lRowDst, ICOL_PROP_NAME);

	pgcKey->SetType(CELLTYPE_PROPMARKER);
	pgcFlavor->SetType(CELLTYPE_PROPMARKER);


	pgcName->SetValue(CELLTYPE_NAME, bstrPropName, CIM_STRING);
	pgcName->SetTagValue(CELL_TAG_EXISTS_IN_DATABASE);
	pgcName->SetFlags(CELLFLAG_READONLY, bEditValueOnly ? CELLFLAG_READONLY : 0);

	row.SetFlavor(lFlavor);

	// When editing a class, it is possible to have a property that
	// is marked read-only and still be able to edit the value.
	// Thus, we want the property marker to show up as read-only
	// even though it may be possible to edit the value while editing
	// a class.
	BOOL bReadonlyTemp = PropertyIsReadOnly(pco, bstrPropName);
	row.SetReadonly(bReadonlyTemp);
	row.SetModified(FALSE);

	SetPropmarkers(lRowDst, pco);

	return S_OK;
}