/*++ Copyright (C) 1996-2001 Microsoft Corporation Module Name: OBJEDIT.CPP Abstract: WBEMTEST object editor classes. History: a-raymcc 12-Jun-96 Created. --*/ #include "precomp.h" #include #include "wbemqual.h" #include "resource.h" #include "resrc1.h" #include "objedit.h" #include "wbemtest.h" //#include #include "textconv.h" #include #include "bstring.h" #include "WT_wstring.h" #include "method.h" #include // following were changed due to very large SNMP properties #define LARGE_BUF 2096 #define IDC_CLASS IDC_SUPERCLASS #define IDC_REFERENCES IDC_DERIVED #define IDC_ASSOCIATIONS IDC_INSTANCES extern DWORD gdwAuthLevel; extern DWORD gdwImpLevel; extern BSTR gpPrincipal; extern COAUTHIDENTITY* gpAuthIdentity; char *ValidQualifierTypes[] = { "CIM_SINT32", "CIM_STRING", "CIM_BOOLEAN", "CIM_REAL64" }; void CopyQualifierSet(IWbemQualifierSet* pDest, IWbemQualifierSet* pSrc, HWND hDlg) { pSrc->BeginEnumeration(0); BSTR strName = NULL; VARIANT vVal; VariantInit(&vVal); long lFlavor; while(pSrc->Next(0, &strName, &vVal, &lFlavor) == S_OK) { if(!wbem_wcsicmp(strName, L"cimtype") && !wbem_wcsicmp(V_BSTR(&vVal), L"sint32")) continue; SCODE hres = pDest->Put(strName, &vVal, lFlavor); if(FAILED(hres)) { FormatError(hres, hDlg); } } } const int nNumValidQualifierTypes = sizeof(ValidQualifierTypes) / sizeof(char *); LPSTR TypeToString(CVar *p) { return TypeToString(p->GetOleType()); } LPSTR LPWSTRToLPSTR(LPWSTR pWStr) { static char buf[TEMP_BUF]; wcstombs(buf, pWStr, TEMP_BUF); buf[TEMP_BUF-1] = '\0'; return buf; } LPSTR CTestQualifierToString(CTestQualifier *pQualifier) { int requiredLength = 0; char * typeString = 0; char * valueString = 0; char * returnString; int nameLength = 0; if (pQualifier->m_pName) { nameLength = wcslen(pQualifier->m_pName)+1; requiredLength += 2*nameLength; } if (pQualifier->m_pValue) { typeString = TypeToString(pQualifier->m_pValue); valueString = ValueToNewString(pQualifier->m_pValue); requiredLength += strlen(typeString)+strlen(valueString)+2; //2 tabs // null is nameLength } returnString = new char[requiredLength]; if (returnString == 0) { delete[] valueString; return 0; } if (pQualifier->m_pName) { wcstombs(returnString, pQualifier->m_pName, nameLength*2); } if (pQualifier->m_pValue) { strcat(returnString, "\t"); strcat(returnString, typeString); strcat(returnString, "\t"); strcat(returnString, valueString); delete[] valueString; } return returnString; } BOOL CTestQualifierEditor::Verify() { // Get the Qualifier name. // ======================= char NameBuf[TEMP_BUF]; char buf[TEMP_BUF]; if (GetWindowText(m_hQualifierName, NameBuf, TEMP_BUF) == 0) { MessageBox(IDS_INVALID_QUALIFIER_NAME, IDS_ERROR, MB_OK); return FALSE; } StripTrailingWs(NameBuf); delete m_pTarget->m_pName; WString Tmp(NameBuf); m_pTarget->m_pName = new wchar_t[wcslen(Tmp) + 1]; wcscpy(m_pTarget->m_pName, Tmp); // Get the Qualifier flavor. // ========================= m_pTarget->m_lType = 0; if (SendMessage(m_hRadioPropClass, BM_GETCHECK, 0, 0) == BST_CHECKED) m_pTarget->m_lType |= WBEM_FLAVOR_FLAG_PROPAGATE_TO_DERIVED_CLASS; if (SendMessage(m_hRadioPropInst, BM_GETCHECK, 0, 0) == BST_CHECKED) m_pTarget->m_lType |= WBEM_FLAVOR_FLAG_PROPAGATE_TO_INSTANCE; if (SendMessage(m_hRadioOverride, BM_GETCHECK, 0, 0) == BST_UNCHECKED) m_pTarget->m_lType |= WBEM_FLAVOR_NOT_OVERRIDABLE; if (SendMessage(m_hRadioAmended, BM_GETCHECK, 0, 0) == BST_CHECKED) m_pTarget->m_lType |= WBEM_FLAVOR_AMENDED; // NOTE: do not retrieve origin! // Get the type string. // ==================== LRESULT nIndex = SendMessage(m_hQualifierType, CB_GETCURSEL, 0, 0); if (SendMessage(m_hQualifierType, CB_GETLBTEXT, nIndex, LPARAM(buf)) == CB_ERR) { MessageBox(IDS_INVALID_QUALIFIER_TYPE, IDS_ERROR, MB_OK); return FALSE; } // Convert type string to a type. // ============================== int nType = StringToType(buf); if (nType == 0) { MessageBox(IDS_INVALID_QUALIFIER_TYPE, IDS_ERROR, MB_OK); return FALSE; } if(GetCheck(IDC_ARRAY) == BST_CHECKED) nType |= VT_ARRAY; // Get the value. // ============== if (m_pTarget->m_pValue) { m_pTarget->m_pValue->Empty(); m_pTarget->m_pValue->SetAsNull(); } CVar *pTemp = 0; if (GetWindowText(m_hQualifierVal, buf, TEMP_BUF)) { StripTrailingWs(buf); pTemp = StringToValue(buf, nType); } else // Value is NULL { pTemp = new CVar; } if (pTemp) { if (m_pTarget->m_pValue) { *m_pTarget->m_pValue = *pTemp; delete pTemp; } else m_pTarget->m_pValue = pTemp; } else { MessageBox(IDS_INVALID_VALUE, IDS_ERROR, MB_OK); return FALSE; } return TRUE; } BOOL CTestQualifierEditor::OnInitDialog() { CenterOnParent(); m_hQualifierName = GetDlgItem(IDC_ATTRIB_NAME); m_hQualifierVal = GetDlgItem(IDC_ATTRIB_VALUE); m_hQualifierType = GetDlgItem(IDC_ATTRIB_TYPE); m_hRadioPropInst = GetDlgItem(IDC_PROP_INST); m_hRadioPropClass = GetDlgItem(IDC_PROP_CLASS); m_hRadioOverride = GetDlgItem(IDC_OVERRIDE); m_hRadioPropagated = GetDlgItem(IDC_PROPAGATED); m_hRadioAmended = GetDlgItem(IDC_AMENDED); SendMessage(m_hRadioPropInst, BM_SETCHECK, (m_pTarget->m_lType & WBEM_FLAVOR_FLAG_PROPAGATE_TO_INSTANCE)?BST_CHECKED:BST_UNCHECKED, 0); SendMessage(m_hRadioPropClass, BM_SETCHECK, (m_pTarget->m_lType & WBEM_FLAVOR_FLAG_PROPAGATE_TO_DERIVED_CLASS)?BST_CHECKED:BST_UNCHECKED, 0); SendMessage(m_hRadioOverride, BM_SETCHECK, (m_pTarget->m_lType & WBEM_FLAVOR_NOT_OVERRIDABLE)?BST_UNCHECKED:BST_CHECKED, 0); SendMessage(m_hRadioPropagated, BM_SETCHECK, (m_pTarget->m_lType & WBEM_FLAVOR_ORIGIN_PROPAGATED)?BST_CHECKED:BST_UNCHECKED, 0); SendMessage(m_hRadioAmended, BM_SETCHECK, (m_pTarget->m_lType & WBEM_FLAVOR_AMENDED)?BST_CHECKED:BST_UNCHECKED, 0); EnableWindow(m_hRadioPropagated, FALSE); // Default property name. // ====================== if (m_pTarget->m_pName) SetWindowText(m_hQualifierName, LPWSTRToLPSTR(m_pTarget->m_pName)); // Populate the combo box with the valid Qualifier types // ====================================================== for (int i = 0; i < nNumValidQualifierTypes; i++) SendMessage(m_hQualifierType, CB_ADDSTRING, 0, LPARAM(ValidQualifierTypes[i])); // If a type is assigned, select it. // ================================= if (m_pTarget->m_pValue) { long lType = m_pTarget->m_pValue->GetOleType(); LPSTR pTypeStr = TypeToString(lType & ~VT_ARRAY); SendMessage(m_hQualifierType, CB_SELECTSTRING, WPARAM(-1), LPARAM(pTypeStr)); // Set the array bit // ================= SetCheck(IDC_ARRAY, ((lType & VT_ARRAY) ? BST_CHECKED : BST_UNCHECKED)); } // Else select VT_BSTR by default. // =============================== else { SendMessage(m_hQualifierType, CB_SELECTSTRING, WPARAM(-1), LPARAM("CIM_STRING")); } // If a value is assigned, initialize it. // ====================================== if (m_pTarget->m_pValue) { LPSTR pVal = ValueToNewString(m_pTarget->m_pValue); SetWindowText(m_hQualifierVal, pVal); delete[] pVal; } // If editing, don't allow the user to change // the Qualifier name or type. // ========================================== if (m_bEditing) { EnableWindow(m_hQualifierName, FALSE); } return TRUE; } CTestQualifierEditor::CTestQualifierEditor( HWND hParent, CTestQualifier *pTarget, BOOL bEditing ) : CWbemDialog(IDD_ATTRIB_EDITOR, hParent) { m_pTarget = pTarget; m_bEditing = bEditing; } INT_PTR CTestQualifierEditor::Edit() { return Run(); } CEmbeddedObjectListEditor::CEmbeddedObjectListEditor(HWND hParent, LONG lGenFlags, LONG lQryFlags, LPCWSTR wszPropName, CVarVector* pVarVector) : CQueryResultDlg(hParent, lGenFlags, lQryFlags), m_wsPropName((LPWSTR)wszPropName) { m_pVarVector = pVarVector; for(int i = 0; i < pVarVector->Size(); i++) { CVar vTemp; pVarVector->FillCVarAt( i, vTemp ); IWbemClassObject* pObj = (IWbemClassObject*) vTemp.GetEmbeddedObject(); m_InternalArray.Add(pObj); // Verify the object pointer if ( NULL != pObj ) { pObj->Release(); } } } CEmbeddedObjectListEditor::~CEmbeddedObjectListEditor() { // Prevent object release --- we don't own them. // ============================================= } BOOL CEmbeddedObjectListEditor::OnInitDialog() { char szBuffer[1000]; char szFormat[104]; if(LoadString(GetModuleHandle(NULL), IDS_EMBEDDED_ARRAY, szFormat, 104)) { sprintf(szBuffer, szFormat, (LPWSTR)m_wsPropName); SetTitle(szBuffer); } else SetTitle("Embedded array"); BOOL bRet = CQueryResultDlg::OnInitDialog(); SetComplete(WBEM_S_NO_ERROR, NULL, NULL); return bRet; } BOOL CEmbeddedObjectListEditor::Verify() { // First AddRef all elements - this is so we don't release objects // out from underneath ourselves. for(int i = 0; i < m_InternalArray.Size(); i++) { IWbemClassObject* pObj = (IWbemClassObject*)m_InternalArray[i]; if ( NULL != pObj ) { pObj->AddRef(); } } // Now axe the elements in the Vector while(m_pVarVector->Size()) m_pVarVector->RemoveAt(0); // First AddRef all elements - this is so we don't release objects // out from underneath ourselves. for(int i = 0; i < m_InternalArray.Size(); i++) { IWbemClassObject* pObj = (IWbemClassObject*)m_InternalArray[i]; CVar v; v.SetEmbeddedObject((I_EMBEDDED_OBJECT*)pObj); m_pVarVector->Add( v ); } return TRUE; } IWbemClassObject* CEmbeddedObjectListEditor::AddNewElement() { return _CreateInstance(m_hDlg, m_lGenFlags, m_lSync, m_lTimeout); } BOOL CEmbeddedObjectListEditor::DeleteListElement(int nSel) { return TRUE; } //*************************************************************************** // // class CTestPropertyEditor // //*************************************************************************** class CTestPropertyEditor : public CWbemDialog { CTestProperty *m_pTarget; BOOL m_bEditOnly; BOOL m_bInstance; LONG m_lGenFlags; // generic WBEM_FLAG_ .. flags LONG m_lSync; // sync, async, semisync LONG m_lTimeout; // used for semisync // Control handles. // ================ HWND m_hPropName; HWND m_hPropType; HWND m_hValue; HWND m_hQualifierList; public: CTestPropertyEditor(HWND hParent, LONG lGenFlags, BOOL bEditOnly, LONG lSync, CTestProperty *pProp, BOOL bInstance, LONG lTimeout); INT_PTR Edit(); BOOL OnInitDialog(); BOOL Verify(); BOOL OnCommand(WORD wCode, WORD wID); BOOL OnDoubleClick(int nID); BOOL OnSelChange(int nID); void Refresh(); void OnAddQualifier(); void OnDelQualifier(); void OnEditQualifier(); void OnKey(); void OnIndexed(); void OnNotNull(); void ViewEmbedding(); void OnValueNull(); void OnValueNotNull(); void OnArray(); int RemoveSysQuals(); void SetSystemCheck(int nID); }; void CTestPropertyEditor::OnAddQualifier() { CTestQualifier att; att.m_lType = WBEM_FLAVOR_FLAG_PROPAGATE_TO_INSTANCE | WBEM_FLAVOR_FLAG_PROPAGATE_TO_DERIVED_CLASS; CTestQualifierEditor ed(m_hDlg, &att, FALSE); INT_PTR nRes = ed.Edit(); if ((nRes == IDCANCEL) || (nRes == 0)) return; // If here, the Qualifier is being added. // ====================================== IWbemQualifierSet* pQualifierSet = m_pTarget->m_pQualifiers; VARIANT *p = att.m_pValue->GetNewVariant(); HRESULT hres = pQualifierSet->Put(att.m_pName, p, att.m_lType); if(FAILED(hres)) { FormatError(hres, m_hDlg); } VariantClear(p); Refresh(); } void CTestPropertyEditor::SetSystemCheck(int nID) { SetCheck(IDC_KEY, BST_UNCHECKED); SetCheck(IDC_INDEXED, BST_UNCHECKED); SetCheck(IDC_NOT_NULL, BST_UNCHECKED); SetCheck(IDC_NORMAL, BST_UNCHECKED); SetCheck(nID, BST_CHECKED); } int CTestPropertyEditor::RemoveSysQuals() { IWbemQualifierSet* pSet = m_pTarget->m_pQualifiers; HRESULT hres; hres = pSet->Delete(L"key"); if(FAILED(hres) && hres != WBEM_E_NOT_FOUND) { SetSystemCheck(IDC_KEY); return IDC_KEY; } hres = pSet->Delete(L"indexed"); if(FAILED(hres) && hres != WBEM_E_NOT_FOUND) { SetSystemCheck(IDC_INDEXED); return IDC_INDEXED; } hres = pSet->Delete(L"not_null"); if(FAILED(hres) && hres != WBEM_E_NOT_FOUND) { SetSystemCheck(IDC_NOT_NULL); return IDC_NOT_NULL; } return 0; } void CTestPropertyEditor::OnIndexed() { IWbemQualifierSet* pQualifierSet = m_pTarget->m_pQualifiers; int nRes = RemoveSysQuals(); if(nRes != 0) { MessageBox(IDS_CANNOT_CHANGE_SYSTEM_QUALS, IDS_ERROR, MB_OK); return; } VARIANT v; V_VT(&v) = VT_BOOL; V_BOOL(&v) = VARIANT_TRUE; HRESULT hres = pQualifierSet->Put(L"indexed", &v, WBEM_FLAVOR_FLAG_PROPAGATE_TO_INSTANCE | WBEM_FLAVOR_FLAG_PROPAGATE_TO_DERIVED_CLASS); if(FAILED(hres)) { MessageBox(IDS_MAY_NOT_SPECIFY_INDEXED, IDS_ERROR, MB_OK | MB_ICONSTOP); SetSystemCheck(IDC_NORMAL); } } void CTestPropertyEditor::OnKey() { IWbemQualifierSet* pQualifierSet = m_pTarget->m_pQualifiers; int nRes = RemoveSysQuals(); if(nRes != 0) { MessageBox(IDS_CANNOT_CHANGE_SYSTEM_QUALS, IDS_ERROR, MB_OK); return; } VARIANT v; V_VT(&v) = VT_BOOL; V_BOOL(&v) = VARIANT_TRUE; HRESULT hres = pQualifierSet->Put(L"key", &v, WBEM_FLAVOR_FLAG_PROPAGATE_TO_INSTANCE | WBEM_FLAVOR_FLAG_PROPAGATE_TO_DERIVED_CLASS); if(FAILED(hres) && hres == WBEM_E_CANNOT_BE_KEY) { MessageBox(IDS_MAY_NOT_SPECIFY_KEY, IDS_ERROR, MB_OK | MB_ICONSTOP); SetSystemCheck(IDC_NORMAL); } } void CTestPropertyEditor::OnNotNull() { IWbemQualifierSet* pQualifierSet = m_pTarget->m_pQualifiers; int nRes = RemoveSysQuals(); if(nRes != 0) { MessageBox(IDS_CANNOT_CHANGE_SYSTEM_QUALS, IDS_ERROR, MB_OK); return; } VARIANT v; V_VT(&v) = VT_BOOL; V_BOOL(&v) = VARIANT_TRUE; HRESULT hres = pQualifierSet->Put(L"not_null", &v, WBEM_FLAVOR_FLAG_PROPAGATE_TO_INSTANCE | WBEM_FLAVOR_FLAG_PROPAGATE_TO_DERIVED_CLASS); if(FAILED(hres)) { MessageBox(IDS_MAY_NOT_SPECIFY_NOT_NULL, IDS_ERROR, MB_OK | MB_ICONSTOP); SetSystemCheck(IDC_NORMAL); } } void CTestPropertyEditor::OnEditQualifier() { // See if anything is selected. // ============================ LRESULT nSel = SendMessage(m_hQualifierList, LB_GETCURSEL, 0, 0); if (nSel == LB_ERR) return; char buf[TEMP_BUF]; *buf = 0; SendMessage(m_hQualifierList, LB_GETTEXT, nSel, LPARAM(buf)); if (*buf == 0) return; // At this point, the text of the selected Qualifier is in . // ============================================================== char name[TEMP_BUF]; *name = 0; if (sscanf(buf, "%[^\t\0]", name) == EOF) return; if (*name == 0) return; WString WName = name; // Find the Qualifier in question. // =============================== VARIANT v; VariantInit(&v); LONG lType = 0; IWbemQualifierSet* pQualifierSet = m_pTarget->m_pQualifiers; CBString bsWName(WName); SCODE res = pQualifierSet->Get(bsWName.GetString(), 0, &v, &lType); if (res != 0) { MessageBox(IDS_QUALIFIER_NOT_FOUND, IDS_CRITICAL_ERROR, MB_OK); return; } // If here, convert temporarily to a CTestQualifier object for the duration of // the edit. // ==================================================================== CVar *pNewVal = new CVar; pNewVal->SetVariant(&v); VariantClear(&v); CTestQualifier att; att.m_pValue = pNewVal; att.m_pName = new wchar_t[wcslen(WName) + 1]; wcscpy(att.m_pName, WName); att.m_lType = lType; CTestQualifierEditor ed(m_hDlg, &att, TRUE); INT_PTR nRes = ed.Edit(); if ((nRes == IDCANCEL) || (nRes == 0)) { return; } // If here, the Qualifier is being added. // ====================================== VARIANT *p = att.m_pValue->GetNewVariant(); CBString bsName(att.m_pName); res = pQualifierSet->Put(bsName.GetString(), p, att.m_lType); if(FAILED(res)) { FormatError(res, m_hDlg); } VariantClear(p); Refresh(); } //ok void CTestPropertyEditor::OnDelQualifier() { // See if anything is selected. // ============================ LRESULT nSel = SendMessage(m_hQualifierList, LB_GETCURSEL, 0, 0); if (nSel == LB_ERR) return; char buf[TEMP_BUF]; *buf = 0; SendMessage(m_hQualifierList, LB_GETTEXT, nSel, LPARAM(buf)); if (*buf == 0) return; // At this point, the text of the selected Qualifier is in . // ============================================================== char name[TEMP_BUF]; *name = 0; if (sscanf(buf, "%[^\t\0]", name) == EOF) return; if (*name == 0) return; WString WName = name; // Remove the Qualifier. // ===================== IWbemQualifierSet *pQualifierSet = m_pTarget->m_pQualifiers; CBString bsName(WName); HRESULT hres = pQualifierSet->Delete(bsName.GetString()); if(FAILED(hres) || hres != 0) { FormatError(hres, m_hDlg); } Refresh(); } void CTestPropertyEditor::Refresh() { // Zap the current contents. // ========================= SendMessage(m_hQualifierList, LB_RESETCONTENT, 0, 0); SetCheck(IDC_KEY, BST_UNCHECKED); SetCheck(IDC_INDEXED, BST_UNCHECKED); SetCheck(IDC_NOT_NULL, BST_UNCHECKED); SetCheck(IDC_NORMAL, BST_CHECKED); // Fill in the Qualifier list. // =========================== IWbemQualifierSet *pQualifiers = m_pTarget->m_pQualifiers; if(pQualifiers == NULL) { EnableWindow(m_hQualifierList, FALSE); EnableWindow(GetDlgItem(IDC_KEY), FALSE); EnableWindow(GetDlgItem(IDC_INDEXED), FALSE); EnableWindow(GetDlgItem(IDC_NOT_NULL), FALSE); EnableWindow(GetDlgItem(IDC_NORMAL), FALSE); EnableWindow(GetDlgItem(IDC_ADD_ATTRIB), FALSE); EnableWindow(GetDlgItem(IDC_EDIT_ATTRIB), FALSE); EnableWindow(GetDlgItem(IDC_DELETE_ATTRIB), FALSE); EnableWindow(GetDlgItem(IDC_STATIC_QUAL), FALSE); } if (pQualifiers) { pQualifiers->BeginEnumeration(0); BSTR strName = NULL; long lFlavor; VARIANT vVal; VariantInit(&vVal); while(pQualifiers->Next(0, &strName, &vVal, &lFlavor) == S_OK) { if(!wbem_wcsicmp(strName, L"key")) { SetSystemCheck(IDC_KEY); SysFreeString(strName); strName = NULL; continue; } else if(!wbem_wcsicmp(strName, L"indexed")) { if(GetCheck(IDC_KEY) == BST_UNCHECKED) { SetSystemCheck(IDC_INDEXED); } SysFreeString(strName); strName = NULL; continue; } else if(!wbem_wcsicmp(strName, L"not_null")) { if(GetCheck(IDC_KEY) == BST_UNCHECKED && GetCheck(IDC_INDEXED) == BST_UNCHECKED) { SetSystemCheck(IDC_NOT_NULL); } SysFreeString(strName); strName = NULL; continue; } CTestQualifier A; A.m_pName = new wchar_t[wcslen(strName) + 1]; wcscpy(A.m_pName, strName); A.m_pValue = new CVar(&vVal); A.m_lType = lFlavor; // Build list box string. // ====================== const char * stringValue = CTestQualifierToString(&A); SendMessage(m_hQualifierList, LB_ADDSTRING, 0,LPARAM(stringValue)); delete[] stringValue; VariantClear(&vVal); SysFreeString(strName); strName = NULL; } pQualifiers->EndEnumeration(); VariantClear(&vVal); } } BOOL CTestPropertyEditor::OnDoubleClick(int nID) { if(nID == IDC_ATTRIB_LIST) { OnEditQualifier(); return TRUE; } return FALSE; } BOOL CTestPropertyEditor::OnSelChange(int nID) { if(nID == IDC_TYPE_LIST) { char* pszType = GetCBCurSelString(IDC_TYPE_LIST); BOOL bArray = (GetCheck(IDC_ARRAY) == BST_CHECKED); m_pTarget->m_lType = StringToType(pszType); if(bArray) m_pTarget->m_lType |= VT_ARRAY; if((m_pTarget->m_lType & ~VT_ARRAY) == VT_EMBEDDED_OBJECT) { ShowWindow(GetDlgItem(IDC_EMBEDDING), SW_SHOW); } else { ShowWindow(GetDlgItem(IDC_EMBEDDING), SW_HIDE); } delete [] pszType; } return TRUE; } BOOL CTestPropertyEditor::OnCommand(WORD wCode, WORD wID) { switch(wID) { case IDC_EDIT_ATTRIB: OnEditQualifier(); return TRUE; case IDC_ADD_ATTRIB: OnAddQualifier(); return TRUE; case IDC_DELETE_ATTRIB: OnDelQualifier(); return TRUE; case IDC_KEY: if(wCode == BN_CLICKED) OnKey(); return TRUE; case IDC_INDEXED: if(wCode == BN_CLICKED) OnIndexed(); return TRUE; case IDC_NOT_NULL: if(wCode == BN_CLICKED) OnNotNull(); return TRUE; case IDC_NORMAL: if(wCode == BN_CLICKED) RemoveSysQuals(); return TRUE; case IDC_VALUE_NULL: OnValueNull(); return TRUE; case IDC_VALUE_NOT_NULL: OnValueNotNull(); return TRUE; case IDC_EMBEDDING: ViewEmbedding(); return TRUE; case IDC_ARRAY: OnArray(); return TRUE; } return TRUE; } void CTestPropertyEditor::OnArray() { if(GetCheck(IDC_ARRAY) == BST_CHECKED) m_pTarget->m_lType |= VT_ARRAY; else m_pTarget->m_lType &= ~VT_ARRAY; } void CTestPropertyEditor::OnValueNull() { if((m_pTarget->m_lType & ~VT_ARRAY) == VT_EMBEDDED_OBJECT) { if(MessageBox(IDS_SAVE_EMBEDDING, IDS_WARNING, MB_ICONQUESTION | MB_YESNO) == IDYES) { SetCheck(IDC_VALUE_NULL, BST_UNCHECKED); SetCheck(IDC_VALUE_NOT_NULL, BST_CHECKED); return; } else { delete m_pTarget->m_pValue; m_pTarget->m_pValue = NULL; SetDlgItemText(IDC_VALUE, ""); } } EnableWindow(m_hValue, FALSE); EnableWindow(GetDlgItem(IDC_EMBEDDING), FALSE); } void CTestPropertyEditor::OnValueNotNull() { if((m_pTarget->m_lType & ~VT_ARRAY) != VT_EMBEDDED_OBJECT) { EnableWindow(m_hValue, TRUE); } EnableWindow(GetDlgItem(IDC_EMBEDDING), TRUE); } BOOL CTestPropertyEditor::OnInitDialog() { ShowWindow(GetDlgItem(IDC_EMBEDDING), SW_HIDE); CenterOnParent(); m_hPropName = GetDlgItem(IDC_PROPNAME); m_hPropType = GetDlgItem(IDC_TYPE_LIST); m_hValue = GetDlgItem(IDC_VALUE); m_hQualifierList = GetDlgItem(IDC_ATTRIB_LIST); LONG Tabs[] = { 80, 140, 170 }; int TabCount = 3; SendMessage(m_hQualifierList, LB_SETTABSTOPS, (WPARAM) TabCount, (LPARAM) Tabs); // Populate the combo box with the valid prop types // ================================================ for (int i = 0; i < g_nNumValidPropTypes; i++) SendMessage(m_hPropType, CB_ADDSTRING, 0, LPARAM(g_aValidPropTypes[i])); SendMessage(m_hPropType, CB_SELECTSTRING, WPARAM(-1), LPARAM("CIM_STRING")); // Now initialize the controls with the contents of the // current object, if any. // ==================================================== if (m_pTarget->m_pName) { SetWindowText(m_hPropName, LPWSTRToLPSTR(m_pTarget->m_pName)); } if(m_pTarget->m_pClass) { SetDlgItemText(IDC_ORIGIN, LPWSTRToLPSTR(m_pTarget->m_pClass)); } // If the value is available, set the text and select. // =================================================== if (m_pTarget->m_pValue) { LPSTR pTypeStr = TypeToString(m_pTarget->m_lType & ~VT_ARRAY); SendMessage(m_hPropType, CB_SELECTSTRING, WPARAM(-1), LPARAM(pTypeStr)); if(m_pTarget->m_lType & VT_ARRAY) SetCheck(IDC_ARRAY, BST_CHECKED); else SetCheck(IDC_ARRAY, BST_UNCHECKED); if((m_pTarget->m_lType & ~VT_ARRAY) == VT_EMBEDDED_OBJECT) { ShowWindow(GetDlgItem(IDC_EMBEDDING), SW_SHOW); } if(m_pTarget->m_pValue->IsNull()) { SetCheck(IDC_VALUE_NULL, BST_CHECKED); EnableWindow(m_hValue, FALSE); EnableWindow(GetDlgItem(IDC_EMBEDDING), FALSE); } else { SetCheck(IDC_VALUE_NOT_NULL, BST_CHECKED); LPSTR pValStr = ValueToNewString(m_pTarget->m_pValue, m_pTarget->m_lType); SetWindowText(m_hValue, pValStr); delete [] pValStr; EnableWindow(m_hValue, strstr(pTypeStr, "VT_EMBEDDED_OBJECT") == NULL); } } else { SetCheck(IDC_VALUE_NULL, BST_CHECKED); SendMessage(m_hPropType, CB_SELECTSTRING, WPARAM(-1), LPARAM("VT_BSTR")); EnableWindow(m_hValue, FALSE); EnableWindow(GetDlgItem(IDC_EMBEDDING), FALSE); } // Refresh the Qualifiers. // ======================= Refresh(); // If editing, don't allow type/name change. // ========================================= if (m_bEditOnly) { EnableWindow(m_hPropName, FALSE); EnableWindow(m_hPropType, FALSE); } if(m_bInstance) { EnableWindow(GetDlgItem(IDC_KEY), FALSE); EnableWindow(GetDlgItem(IDC_INDEXED), FALSE); EnableWindow(GetDlgItem(IDC_NOT_NULL), FALSE); EnableWindow(GetDlgItem(IDC_NORMAL), FALSE); } return TRUE; } void CTestPropertyEditor::ViewEmbedding() { if(m_pTarget->m_lType == VT_EMBEDDED_OBJECT) { if(m_pTarget->m_pValue != NULL && m_pTarget->m_pValue->GetType() != VT_EMBEDDED_OBJECT) { delete m_pTarget->m_pValue; m_pTarget->m_pValue = NULL; } if(m_pTarget->m_pValue == NULL) { m_pTarget->m_pValue = new CVar; m_pTarget->m_pValue->SetEmbeddedObject(NULL); } IWbemClassObject* pCurrentEmbed = (IWbemClassObject*)m_pTarget->m_pValue->GetEmbeddedObject(); IWbemClassObject* pEmbed; if(pCurrentEmbed == NULL) { pEmbed = PreCreateInstance(m_hDlg, m_lGenFlags, m_lSync, m_lTimeout); if(pEmbed == NULL) return; } else { pCurrentEmbed->Clone(&pEmbed); pCurrentEmbed->Release(); } CObjectEditor ed(m_hDlg, m_lGenFlags, CObjectEditor::readwrite, m_lSync, pEmbed, m_lTimeout); if(ed.Edit() == IDOK) { m_pTarget->m_pValue->SetEmbeddedObject(pEmbed); SetDlgItemText(IDC_VALUE, ""); } pEmbed->Release(); } else if(m_pTarget->m_lType == (VT_EMBEDDED_OBJECT | VT_ARRAY)) { if(m_pTarget->m_pValue != NULL && m_pTarget->m_pValue->GetType() != VT_EX_CVARVECTOR) { delete m_pTarget->m_pValue; m_pTarget->m_pValue = NULL; } if(m_pTarget->m_pValue == NULL) { m_pTarget->m_pValue = new CVar; CVarVector* pvv = new CVarVector(VT_EMBEDDED_OBJECT); m_pTarget->m_pValue->SetVarVector(pvv, TRUE); } CVarVector* pCurrentEmbed = m_pTarget->m_pValue->GetVarVector(); CEmbeddedObjectListEditor ed(m_hDlg, m_lGenFlags, 0, m_pTarget->m_pName, pCurrentEmbed); // Pass on invocation method (sync, async..) related settings for use // by any further operations (editing/deleting/etc. of an instance). ed.SetCallMethod(m_lSync); ed.SetTimeout(m_lTimeout); ed.Run(); SetDlgItemText(IDC_VALUE, ""); } else { ShowWindow(GetDlgItem(IDC_EMBEDDING), SW_HIDE); } } BOOL CTestPropertyEditor::Verify() { // Buffer is used for property name, value string (which can be long if an array), and type string). // Find the largest of the three for buffer length (TEMP_BUF size is used for type). int buflen = max(max(GetWindowTextLength(m_hPropName), GetWindowTextLength(m_hValue)) + 1, TEMP_BUF); char* buf = new char[buflen]; // Verify that name is present. // ============================ if (GetWindowText(m_hPropName, buf, buflen) == 0) { MessageBox(IDS_NO_PROPERTY_NAME, IDS_ERROR, MB_OK); delete [] buf; return FALSE; } StripTrailingWs(buf); WString Name = buf; if (m_pTarget->m_pName) delete m_pTarget->m_pName; m_pTarget->m_pName = new wchar_t[wcslen(Name) + 1]; wcscpy(m_pTarget->m_pName, Name); // Get the type. // ============= LRESULT nIndex = SendMessage(m_hPropType, CB_GETCURSEL, 0, 0); if (SendMessage(m_hPropType, CB_GETLBTEXT, nIndex, LPARAM(buf)) == CB_ERR) { MessageBox(IDS_INVALID_PROPERTY_TYPE, IDS_ERROR, MB_OK); delete [] buf; return FALSE; } // Convert type string to a type. // ============================== int nType = StringToType(buf); if(GetCheck(IDC_ARRAY) == BST_CHECKED) nType |= VT_ARRAY; if (nType == 0) { MessageBox(IDS_INVALID_PROPERTY_TYPE, IDS_ERROR, MB_OK); delete [] buf; return FALSE; } m_pTarget->m_lType = nType; // Verify that Value is present. // ============================= CVar *p; if(GetCheck(IDC_VALUE_NULL) == BST_CHECKED) { p = new CVar; p->SetAsNull(); } else { *buf = 0; GetWindowText(m_hValue, buf, buflen); StripTrailingWs(buf); // Convert value string to the correct value. // ========================================== if((nType & ~VT_ARRAY) != VT_EMBEDDED_OBJECT) { p = StringToValue(buf, nType); } else { // otherwise already there p = m_pTarget->m_pValue; } } if (!p) { MessageBox(IDS_INVALID_PROPERTY_VALUE, IDS_ERROR, MB_OK); delete [] buf; return FALSE; } if(m_pTarget->m_pValue != p) { if (m_pTarget->m_pValue) delete m_pTarget->m_pValue; m_pTarget->m_pValue = p; } delete [] buf; return TRUE; } CTestPropertyEditor::CTestPropertyEditor(HWND hParent, LONG lGenFlags, BOOL bEditOnly, LONG lSync, CTestProperty* pProp, BOOL bInstance, LONG lTimeout) : CWbemDialog(IDD_PROPERTY_EDITOR, hParent) { m_pTarget = pProp; m_lGenFlags = lGenFlags; m_bEditOnly = bEditOnly; m_lSync = lSync; m_bInstance = bInstance; m_lTimeout = lTimeout; } INT_PTR CTestPropertyEditor::Edit() { return Run(); } void CObjectEditor::OnAddQualifier() { CTestQualifier att; att.m_lType = WBEM_FLAVOR_FLAG_PROPAGATE_TO_INSTANCE | WBEM_FLAVOR_FLAG_PROPAGATE_TO_DERIVED_CLASS; CTestQualifierEditor ed(m_hDlg, &att, FALSE); INT_PTR nRes = ed.Edit(); if ((nRes == IDCANCEL) || (nRes == 0)) return; // If here, the Qualifier is being added. // ====================================== IWbemQualifierSet* pQualifierSet = 0; m_pObj->GetQualifierSet(&pQualifierSet); VARIANT *p = att.m_pValue->GetNewVariant(); CBString bsName(att.m_pName); /* DWORD dwFlavor = WBEM_FLAVOR_FLAG_PROPAGATE_TO_INSTANCE | WBEM_FLAVOR_FLAG_PROPAGATE_TO_DERIVED_CLASS; */ HRESULT hres = pQualifierSet->Put(bsName.GetString(), p, att.m_lType); if(FAILED(hres)) { FormatError(hres, m_hDlg); } VariantClear(p); pQualifierSet->Release(); Refresh(); } void CObjectEditor::OnEditQualifier() { // See if anything is selected. // ============================ LRESULT nSel = SendMessage(m_hQualifierList, LB_GETCURSEL, 0, 0); if (nSel == LB_ERR) return; int sizeRequired = SendMessage(m_hQualifierList, LB_GETTEXTLEN, nSel, 0); wmilib::auto_buffer buf(new char[sizeRequired+1]); if (buf.get() == 0) return; *buf = 0; SendMessage(m_hQualifierList, LB_GETTEXT, nSel, LPARAM(buf.get())); if (*buf == 0) return; // At this point, the text of the selected Qualifier is in . // ============================================================== char name[TEMP_BUF]; *name = 0; if (sscanf(buf.get(), "%[^\t\0]", name) == EOF) return; if (*name == 0) return; WString WName = name; // Find the Qualifier in question. // =============================== IWbemQualifierSet* pQualifierSet = 0; VARIANT v; VariantInit(&v); LONG lType = 0; m_pObj->GetQualifierSet(&pQualifierSet); SCODE res = pQualifierSet->Get(WName, 0, &v, &lType); if (res != 0) { MessageBox(IDS_QUALIFIER_NOT_FOUND, IDS_CRITICAL_ERROR, MB_OK); pQualifierSet->Release(); return; } // If here, convert temporarily to a CTestQualifier object for the duration of // the edit. // ==================================================================== CVar *pNewVal = new CVar; pNewVal->SetVariant(&v); VariantClear(&v); CTestQualifier att; att.m_pValue = pNewVal; att.m_pName = new wchar_t[wcslen(WName) + 1]; wcscpy(att.m_pName, WName); att.m_lType = lType; CTestQualifierEditor ed(m_hDlg, &att, TRUE); INT_PTR nRes = ed.Edit(); if ((nRes == IDCANCEL) || (nRes == 0)) { pQualifierSet->Release(); return; } // If here, the Qualifier is being added. // ====================================== m_pObj->GetQualifierSet(&pQualifierSet); VARIANT *p = att.m_pValue->GetNewVariant(); CBString bsName(att.m_pName); res = pQualifierSet->Put(bsName.GetString(), p, att.m_lType); if(FAILED(res)) { FormatError(res, m_hDlg); } VariantClear(p); pQualifierSet->Release(); Refresh(); } // // // Called when deleting an Qualifier on the object itself. // void CObjectEditor::OnDelQualifier() { // See if anything is selected. // ============================ LRESULT nSel = SendMessage(m_hQualifierList, LB_GETCURSEL, 0, 0); if (nSel == LB_ERR) return; char buf[TEMP_BUF]; *buf = 0; SendMessage(m_hQualifierList, LB_GETTEXT, nSel, LPARAM(buf)); if (*buf == 0) return; // At this point, the text of the selected Qualifier is in . // ============================================================== char name[TEMP_BUF]; *name = 0; if (sscanf(buf, "%[^\t\0]", name) == EOF) return; if (*name == 0) return; WString WName = name; // Remove the Qualifier. // ===================== IWbemQualifierSet *pQualifierSet; m_pObj->GetQualifierSet(&pQualifierSet); HRESULT hres = pQualifierSet->Delete(WName); if(FAILED(hres) || hres != 0) { FormatError(hres, m_hDlg); } pQualifierSet->Release(); Refresh(); } void CObjectEditor::OnAddProp() { HRESULT hres; // Add a dummy property for now // ============================ VARIANT v; VariantInit(&v); V_VT(&v) = VT_I4; V_I4(&v) = 1; CBString bsTemp(L"DUMMY_PROPERTY__D"); if(FAILED(m_pObj->Put(bsTemp.GetString(), 0, &v, 0))) { MessageBox(NULL, IDS_CANNOT_ADD_PROPERTIES, IDS_ERROR, MB_OK|MB_ICONSTOP); return; } IWbemQualifierSet* pQualifierSet; m_pObj->GetPropertyQualifierSet(bsTemp.GetString(), &pQualifierSet); // Create CTestProperty with the dummy attr set for now // ================================================ CTestProperty prop(pQualifierSet); VariantClear(&v); hres = m_pObj->Get(L"__CLASS", 0, &v, NULL, NULL); if (hres != S_OK || V_VT(&v) != VT_BSTR ) { prop.m_pClass = new wchar_t[wcslen(L"Unknown") + 1]; wcscpy(prop.m_pClass, L"Unknown"); } else { prop.m_pClass = new wchar_t[wcslen(V_BSTR(&v)) + 1]; wcscpy(prop.m_pClass, V_BSTR(&v)); VariantClear(&v); } CTestPropertyEditor ed(m_hDlg, m_lGenFlags, FALSE, m_lSync, &prop, FALSE, m_lTimeout); INT_PTR nRes = ed.Edit(); if ((nRes == IDCANCEL) || (nRes == 0)) { pQualifierSet->Release(); m_pObj->Delete(bsTemp.GetString()); return; } // Set the property // ================ VARIANT* pVariant = prop.m_pValue->GetNewVariant(); bsTemp = prop.m_pName; VARTYPE vtType; if(m_bClass) { vtType = (VARTYPE)prop.m_lType; } else { vtType = 0; } hres = m_pObj->Put(bsTemp.GetString(), 0, pVariant, vtType); VariantClear(pVariant); if(FAILED(hres)) { FormatError(hres, m_hDlg); return; } // Copy the Qualifiers // =================== IWbemQualifierSet* pRealQualifierSet; bsTemp = prop.m_pName; m_pObj->GetPropertyQualifierSet(bsTemp.GetString(), &pRealQualifierSet); CopyQualifierSet(pRealQualifierSet, pQualifierSet, m_hDlg); pQualifierSet->EndEnumeration(); pQualifierSet->Release(); pRealQualifierSet->Release(); bsTemp = L"DUMMY_PROPERTY__D"; m_pObj->Delete(bsTemp.GetString()); Refresh(); } void CObjectEditor::OnEditProp() { // Find out which property is selected. // ==================================== LRESULT nIndex = SendMessage(m_hPropList, LB_GETCURSEL, 0, 0); if (nIndex == LB_ERR) return; char buf[TEMP_BUF]; *buf = 0; SendMessage(m_hPropList, LB_GETTEXT, nIndex, LPARAM(buf)); if (*buf == 0) return; // Scan out the property name. // =========================== char name[TEMP_BUF]; *name = 0; if (sscanf(buf, "%[^\t\0]", name) == EOF) return; if (*name == 0) return; WString wsName = name; // Get the property value from the object // ====================================== VARIANT vVal; CIMTYPE ctType; m_pObj->Get((LPWSTR)wsName, 0, &vVal, &ctType, NULL); // Create a CTestProperty from it // ========================== IWbemQualifierSet* pQualifierSet = 0; SCODE sc = m_pObj->GetPropertyQualifierSet((LPWSTR)wsName, &pQualifierSet); CTestProperty Copy(pQualifierSet); if (pQualifierSet) pQualifierSet->Release(); Copy.m_pName = new wchar_t[wcslen(wsName) + 1]; wcscpy(Copy.m_pName, wsName); Copy.m_pValue = new CVar(&vVal); Copy.m_lType = ctType; // Note that GetPropertyOrigin can fail for objects returned by Projection // Queries, so we need to be careful with strClass. BSTR strClass = NULL; m_pObj->GetPropertyOrigin((LPWSTR)wsName, &strClass); if ( NULL != strClass ) { Copy.m_pClass = new wchar_t[wcslen(strClass)+1]; wcscpy(Copy.m_pClass, strClass); SysFreeString(strClass); } // Edit it. // ========= CTestPropertyEditor ed(m_hDlg, m_lGenFlags, TRUE, m_lSync, &Copy, !m_bClass, m_lTimeout); INT_PTR nRes = ed.Edit(); if ((nRes == IDCANCEL) || (nRes == 0)) return; // If here, we must replace the info for the property. // =================================================== VARIANT* pVariant = Copy.m_pValue->GetNewVariant(); if(m_bClass && V_VT(pVariant) == VT_NULL) ctType = (VARTYPE)Copy.m_lType; else ctType = 0; sc = m_pObj->Put(Copy.m_pName, 0, pVariant, ctType); VariantClear(pVariant); if(FAILED(sc)) { FormatError(sc, m_hDlg); } Refresh(); } void CObjectEditor::OnDelProp() { // Find out which property is selected. // ==================================== LRESULT nIndex = SendMessage(m_hPropList, LB_GETCURSEL, 0, 0); if (nIndex == LB_ERR) return; char buf[TEMP_BUF]; *buf = 0; SendMessage(m_hPropList, LB_GETTEXT, nIndex, LPARAM(buf)); if (*buf == 0) return; // Scan out the property name. // =========================== char name[TEMP_BUF]; *name = 0; if (sscanf(buf, "%[^\t\0]", name) == EOF) return; if (*name == 0) return; WString WName = name; if(FAILED(m_pObj->Delete(LPWSTR(WName)))) { MessageBox(NULL, IDS_CANNOT_EDIT_PROPERTY, IDS_ERROR, MB_OK|MB_ICONSTOP); return; } Refresh(); } class CMofViewer : public CWbemDialog { BSTR m_strText; public: CMofViewer(HWND hParent, BSTR strText) : CWbemDialog(IDD_MOF, hParent), m_strText(strText) {} BOOL OnInitDialog(); }; BOOL CMofViewer::OnInitDialog() { int iSize = wcslen(m_strText)*2+1; char* szText = new char[iSize]; wcstombs(szText, m_strText, iSize); char* szText1 = new char[strlen(szText)*2+1]; char* pc = szText; char* pc1 = szText1; while(*pc) { if(*pc == '\n') { *(pc1++) = '\r'; } *(pc1++) = *(pc++); } *pc1 = 0; SetDlgItemText(IDC_MOF, szText1); delete [] szText; return TRUE; } void CObjectEditor::OnShowMof() { BSTR strText; HRESULT hres = m_pObj->GetObjectText(0, &strText); if(FAILED(hres)) { MessageBox(IDS_MOF_FAILED, IDS_ERROR, MB_OK); } else { CMofViewer mv(m_hDlg, strText); mv.Run(); } } void CObjectEditor::OnRefreshObject() { #if 0 BSTR strText; HRESULT res; // Asynchronous if (m_lSync & ASYNC) { MessageBox(IDS_ASYNC_NOT_SUPPORTED, IDS_ERROR, MB_OK); return; } else if (m_lSync & SEMISYNC) { IWbemCallResultEx* pCallRes = NULL; CHourGlass hg; res = g_pServicesEx->RefreshObject(&m_pObj, m_lGenFlags | WBEM_FLAG_RETURN_IMMEDIATELY, g_Context, &pCallRes); if (SUCCEEDED(res)) { LONG lStatus; SetInterfaceSecurityEx(pCallRes, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel); while ((res = pCallRes->GetCallStatus(m_lTimeout, &lStatus)) == WBEM_S_TIMEDOUT) { // wait } if (res == WBEM_S_NO_ERROR) { res = (HRESULT)lStatus; // lStatus is the final result of the above IWbemServices::PutClass call } pCallRes->Release(); } } // Synchronous else { CHourGlass hg; res = g_pServicesEx->RefreshObject(&m_pObj, m_lGenFlags , g_Context, NULL); } HRESULT hres = g_pServicesEx->RefreshObject(&m_pObj, 0, NULL, NULL ); if(FAILED(hres)) { FormatError(hres, m_hDlg, NULL); } else Refresh(); #endif HRESULT res; if (m_pObj) { VARIANT Var; VariantInit(&Var); res = m_pObj->Get(L"__RELPATH",0,&Var,NULL,NULL); if (SUCCEEDED(res)) { if (VT_BSTR == V_VT(&Var)) { IWbemClassObject * pObj = NULL; res = g_pNamespace->GetObject(V_BSTR(&Var), m_lGenFlags , g_Context, &pObj, NULL); if (SUCCEEDED(res)) { m_pObj->Release(); m_pObj = pObj; } else { FormatError(res, m_hDlg, NULL); } } else { FormatError(WBEM_E_INVALID_OBJECT, m_hDlg, NULL); } } else { FormatError(res, m_hDlg, NULL); } VariantClear(&Var); } } BOOL CObjectEditor::OnInitDialog() { CenterOnParent(); m_hPropList = GetDlgItem(IDC_PROP_LIST); m_hQualifierList = GetDlgItem(IDC_ATTRIB_LIST); m_hMethodList = GetDlgItem(IDC_METHOD_LIST); // Set tabs in the property list box. // ================================== LONG Tabs[] = { 80, 140, 170 }; int TabCount = 3; SendMessage(m_hPropList, LB_SETTABSTOPS, (WPARAM) TabCount, (LPARAM) Tabs); SendMessage(m_hPropList, LB_SETHORIZONTALEXTENT, 1000, 0); SendMessage(m_hQualifierList, LB_SETTABSTOPS, (WPARAM) TabCount, (LPARAM) Tabs); SendMessage(m_hQualifierList, LB_SETHORIZONTALEXTENT, 1000, 0); SendMessage(m_hMethodList, LB_SETTABSTOPS, (WPARAM) TabCount, (LPARAM) Tabs); SendMessage(m_hMethodList, LB_SETHORIZONTALEXTENT, 1000, 0); if (m_dwEditMode == readonly) { EnableWindow(GetDlgItem(IDOK), FALSE); } if (m_bClass) { SetCheck(IDC_UPDATE_NORMAL, TRUE); SetCheck(IDC_UPDATE_COMPATIBLE, TRUE); } else { SetCheck(IDC_UPDATE_NORMAL, TRUE); EnableWindow(GetDlgItem(IDC_UPDATE_COMPATIBLE), FALSE); EnableWindow(GetDlgItem(IDC_UPDATE_SAFE), FALSE); EnableWindow(GetDlgItem(IDC_UPDATE_FORCE), FALSE); } Refresh(); return TRUE; } BOOL CObjectEditor::OnDoubleClick(int nID) { if(nID == IDC_ATTRIB_LIST) { OnEditQualifier(); return TRUE; } else if(nID == IDC_PROP_LIST) { OnEditProp(); return TRUE; } else if(nID == IDC_METHOD_LIST) { OnEditMethod(); return TRUE; } else return FALSE; } BOOL CObjectEditor::OnCommand(WORD wCode, WORD wID) { switch(wID) { case IDC_EDIT_ATTRIB: OnEditQualifier(); return TRUE; case IDC_ADD_ATTRIB: OnAddQualifier(); return TRUE; case IDC_DELETE_ATTRIB: OnDelQualifier(); return TRUE; case IDC_SHOW_MOF: OnShowMof(); return TRUE; case IDC_ADD_PROP: OnAddProp(); return TRUE; case IDC_EDIT_PROP: OnEditProp(); return TRUE; case IDC_DELETE_PROP: OnDelProp(); return TRUE; case IDC_ADD_METHOD: OnAddMethod(); return TRUE; case IDC_EDIT_METHOD: OnEditMethod(); return TRUE; case IDC_DELETE_METHOD: OnDelMethod(); return TRUE; case IDC_REFRESH_OBJECT: OnRefreshObject(); return TRUE; case IDC_SUPERCLASS: if(m_bClass) OnSuperclass(); else OnClass(); return TRUE; case IDC_DERIVED: if(m_bClass) OnDerived(); else OnRefs(); return TRUE; case IDC_INSTANCES: if(m_bClass) OnInstances(); else OnAssocs(); return TRUE; case IDC_HIDE_SYSTEM: OnHideSystem(); return TRUE; case IDC_HIDE_DERIVED: OnHideDerived(); return TRUE; } return FALSE; } void CObjectEditor::OnSuperclass() { // Get the superclass // ================== VARIANT v; VariantInit(&v); if(FAILED(m_pObj->Get(L"__SUPERCLASS", 0, &v, NULL, NULL)) || V_VT(&v) != VT_BSTR) { MessageBox(IDS_NO_SUPERCLASS, IDS_ERROR, MB_OK); return; } ShowClass(m_hDlg, m_lGenFlags, V_BSTR(&v), m_lSync, m_pOwner, m_lTimeout); } void CObjectEditor::OnClass() { // Get the class // ============= VARIANT v; VariantInit(&v); if(FAILED(m_pObj->Get(L"__CLASS", 0, &v, NULL, NULL))) { MessageBox(IDS_CRITICAL_ERROR, IDS_ERROR, MB_OK); return; } ShowClass(m_hDlg, m_lGenFlags, V_BSTR(&v), m_lSync, m_pOwner, m_lTimeout); } void CObjectEditor::OnDerived() { // Get the children // ================ VARIANT v; VariantInit(&v); if(FAILED(m_pObj->Get(L"__CLASS", 0, &v, NULL, NULL)) || SysStringLen(V_BSTR(&v)) == 0) { MessageBox(IDS_INCOMPLETE_CLASS, IDS_ERROR, MB_OK); return; } ShowClasses(m_hDlg, m_lGenFlags, WBEM_FLAG_SHALLOW, V_BSTR(&v), m_lSync, m_pOwner, m_lTimeout, m_nBatch); } void CObjectEditor::OnInstances() { // Get the instances // ================ VARIANT v; VariantInit(&v); if(FAILED(m_pObj->Get(L"__CLASS", 0, &v, NULL, NULL)) || SysStringLen(V_BSTR(&v)) == 0) { MessageBox(IDS_INCOMPLETE_CLASS, IDS_ERROR, MB_OK); return; } ShowInstances(m_hDlg, m_lGenFlags, WBEM_FLAG_SHALLOW, V_BSTR(&v), m_lSync, m_pOwner, m_lTimeout, m_nBatch); } void CObjectEditor::OnRefs() { CQueryResultDlg* pResDlg = new CQueryResultDlg(m_hDlg, m_lGenFlags, WBEM_FLAG_DEEP); // Pass on invocation method (sync, async..) and related settings for this // query and by any further operations (editing/deleting/etc. of an instance). pResDlg->SetCallMethod(m_lSync); pResDlg->SetTimeout(m_lTimeout); pResDlg->SetBatchCount(m_nBatch); VARIANT v; VariantInit(&v); if(FAILED(m_pObj->Get(L"__RELPATH", 0, &v, NULL, NULL)) || V_VT(&v) != VT_BSTR) { MessageBox(IDS_UNREFERENCABLE_OBJECT, IDS_ERROR, MB_OK); delete pResDlg; return; } WCHAR* wszQuery = new WCHAR[wcslen(V_BSTR(&v))+100]; swprintf(wszQuery, L"references of {%s}", V_BSTR(&v)); // Actual query, dont internationalize char szTitle[1000]; char szFormat[104]; char* pTitle = NULL; if(LoadString(GetModuleHandle(NULL), IDS_REFERENCES_OF, szFormat, 104)) { sprintf(szTitle, szFormat, V_BSTR(&v)); pTitle = szTitle; } if(_ExecQuery(m_hDlg, m_lGenFlags, WBEM_FLAG_DEEP, wszQuery, L"WQL", m_lSync, pResDlg, pTitle, m_lTimeout, m_nBatch)) { pResDlg->RunDetached(m_pOwner); } else { delete pResDlg; } delete [] wszQuery; } void CObjectEditor::OnAssocs() { CQueryResultDlg* pResDlg = new CQueryResultDlg(m_hDlg, m_lGenFlags, WBEM_FLAG_DEEP); // Pass on invocation method (sync, async..) and related settings for this // query and by any further operations (editing/deleting/etc. of an instance). pResDlg->SetCallMethod(m_lSync); pResDlg->SetTimeout(m_lTimeout); pResDlg->SetBatchCount(m_nBatch); VARIANT v; VariantInit(&v); if(FAILED(m_pObj->Get(L"__RELPATH", 0, &v, NULL, NULL)) || V_VT(&v) != VT_BSTR) { MessageBox(IDS_UNREFERENCABLE_OBJECT, IDS_ERROR, MB_OK); delete pResDlg; return; } WCHAR* wszQuery = new WCHAR[wcslen(V_BSTR(&v))+100]; swprintf(wszQuery, L"associators of {%s}", V_BSTR(&v)); // Actual query, dont internationalize char szTitle[1000]; char szFormat[104]; char* pTitle = NULL; if(LoadString(GetModuleHandle(NULL), IDS_ASSOCIATORS_OF, szFormat, 104)) { sprintf(szTitle, szFormat, V_BSTR(&v)); pTitle = szTitle; } if(_ExecQuery(m_hDlg, m_lGenFlags, WBEM_FLAG_DEEP, wszQuery, L"WQL", m_lSync, pResDlg, pTitle, m_lTimeout, m_nBatch)) { pResDlg->RunDetached(m_pOwner); } else { delete pResDlg; } delete [] wszQuery; } BOOL CObjectEditor::mstatic_bHideSystemDefault = FALSE; void CObjectEditor::OnHideSystem() { m_bHideSystem = (GetCheck(IDC_HIDE_SYSTEM) == BST_CHECKED); mstatic_bHideSystemDefault = m_bHideSystem; Refresh(); } void CObjectEditor::OnHideDerived() { m_bHideDerived = (GetCheck(IDC_HIDE_DERIVED) == BST_CHECKED); Refresh(); } void CObjectEditor::Refresh() { // Zap the current contents. // ========================= SendMessage(m_hPropList, LB_RESETCONTENT, 0, 0); SendMessage(m_hQualifierList, LB_RESETCONTENT, 0, 0); SendMessage(m_hMethodList, LB_RESETCONTENT, 0, 0); // Set the title to relpath // ======================== char buf[TEMP_BUF]; char szFormat[1024]; VARIANT v; VariantInit(&v); HRESULT hres = m_pObj->Get(L"__RELPATH", 0, &v, NULL, NULL); if(FAILED(hres) || V_VT(&v) == VT_NULL) { hres = m_pObj->Get(L"__CLASS", 0, &v, NULL, NULL); if(FAILED(hres) || V_VT(&v) == VT_NULL) { hres = m_pObj->Get(L"__SUPERCLASS", 0, &v, NULL, NULL); if(FAILED(hres) || V_VT(&v) != VT_BSTR) { LoadString(GetModuleHandle(NULL), IDS_NEW_TOP_LEVEL_CLASS, buf, TEMP_BUF); } else { LoadString(GetModuleHandle(NULL), IDS_NEW_CHILD_OF, szFormat, 1024); _snprintf(buf, sizeof(buf)/sizeof(buf[0]), szFormat, V_BSTR(&v)); } } else { LoadString(GetModuleHandle(NULL), IDS_INSTANCE_OF, szFormat, 1024); _snprintf(buf, sizeof(buf)/sizeof(buf[0]), szFormat, V_BSTR(&v)); } } else { LoadString(GetModuleHandle(NULL), IDS_OBJECT_EDITOR_FOR, szFormat, 1024); _snprintf(buf, sizeof(buf)/sizeof(buf[0]), szFormat, V_BSTR(&v)); } buf[sizeof(buf)-1] = '\0'; VariantClear(&v); SetWindowText(m_hDlg, buf); // Fill in the property list. // ========================== LONG lConFlags = 0; // condition flags (i.e., WBEM_CONDITION_FLAG_TYPE) if(m_bHideDerived) lConFlags = WBEM_FLAG_LOCAL_ONLY; else if(m_bHideSystem) lConFlags = WBEM_FLAG_NONSYSTEM_ONLY; m_pObj->BeginEnumeration(lConFlags); BSTR Name = NULL; CIMTYPE ctType; while (m_pObj->Next(0, &Name, &v, &ctType, NULL) == WBEM_S_NO_ERROR) { char buf2[TEMP_BUF]; CVar value(&v); LPSTR TypeString = TypeToString(ctType); LPSTR ValueString = ValueToNewString(&value, ctType); if(strlen(ValueString) > 100) { ValueString[100] = 0; } sprintf(buf2, "%S\t%s\t%s", Name, TypeString, ValueString); delete [] ValueString; SendMessage(m_hPropList, LB_ADDSTRING, 0, LPARAM(buf2)); VariantClear(&v); } m_pObj->EndEnumeration(); // Fill in the Qualifier list. // =========================== IWbemQualifierSet *pQualifiers = NULL; hres = m_pObj->GetQualifierSet(&pQualifiers); if(SUCCEEDED(hres)) { pQualifiers->BeginEnumeration(0); BSTR strName = NULL; VARIANT vVal; VariantInit(&vVal); long lFlavor; while(pQualifiers->Next(0, &strName, &vVal, &lFlavor) == S_OK) { CTestQualifier A; A.m_pName = new wchar_t[wcslen(strName)+1]; wcscpy(A.m_pName, strName); A.m_pValue = new CVar(&vVal); A.m_lType = lFlavor; // Build list box string. // ====================== const char * stringValue = CTestQualifierToString(&A); SendMessage(m_hQualifierList, LB_ADDSTRING, 0, LPARAM(stringValue)); delete [] stringValue; } pQualifiers->EndEnumeration(); pQualifiers->Release(); } else EnableWindow(m_hQualifierList, FALSE); // Fill in the methods m_pObj->BeginMethodEnumeration(0); while (m_pObj->NextMethod(0, &Name, NULL, NULL) == WBEM_S_NO_ERROR) { char buf3[TEMP_BUF]; wcstombs(buf3, Name, TEMP_BUF); buf3[TEMP_BUF-1] = '\0'; SendMessage(m_hMethodList, LB_ADDSTRING, 0, LPARAM(buf3)); VariantClear(&v); } m_pObj->EndMethodEnumeration(); // Configure the buttons // ===================== ConfigureButtons(); } void CObjectEditor::ConfigureButtons() { VARIANT v; VariantInit(&v); if(m_bClass) { // Configure for class // =================== if(FAILED(m_pObj->Get(L"__SUPERCLASS", 0, &v, NULL, NULL)) || V_VT(&v) != VT_BSTR) { EnableWindow(GetDlgItem(IDC_SUPERCLASS), FALSE); } else { VariantClear(&v); EnableWindow(GetDlgItem(IDC_SUPERCLASS), TRUE); } } else { // Configure for instance // ====================== SetDlgItemText(IDC_CLASS, IDS_CLASS); SetDlgItemText(IDC_REFERENCES, IDS_REFERENCES); SetDlgItemText(IDC_ASSOCIATIONS, IDS_ASSOCIATORS); EnableWindow(GetDlgItem(IDC_KEY), FALSE); EnableWindow(GetDlgItem(IDC_INDEXED), FALSE); } if(m_bNoMethods || !m_bClass) { EnableWindow(GetDlgItem(IDC_ADD_METHOD), FALSE); EnableWindow(GetDlgItem(IDC_EDIT_METHOD), FALSE); EnableWindow(GetDlgItem(IDC_DELETE_METHOD), FALSE); } SetCheck(IDC_HIDE_SYSTEM, m_bHideSystem?BST_CHECKED:BST_UNCHECKED); SetCheck(IDC_HIDE_DERIVED, m_bHideDerived?BST_CHECKED:BST_UNCHECKED); EnableWindow(GetDlgItem(IDC_HIDE_SYSTEM), !m_bHideDerived); if(m_dwEditMode == foreign) { EnableWindow(GetDlgItem(IDC_CLASS), FALSE); EnableWindow(GetDlgItem(IDC_REFERENCES), FALSE); EnableWindow(GetDlgItem(IDC_ASSOCIATIONS), FALSE); EnableWindow(GetDlgItem(IDOK), FALSE); } } CObjectEditor::CObjectEditor(HWND hParent, LONG lGenFlags, DWORD dwEditMode, LONG lSync, IWbemClassObject *pObj, LONG lTimeout, ULONG nBatch) : CWbemDialog(IDD_OBJECT_EDITOR, hParent) { m_pObj = pObj; pObj->AddRef(); m_dwEditMode = dwEditMode; m_bHideSystem = mstatic_bHideSystemDefault; m_bHideDerived = FALSE; m_bNoMethods = dwEditMode & nomethods; m_lGenFlags = lGenFlags; // generic flags (i.e., WBEM_GENERIC_FLAG_TYPE) m_lSync = lSync; // sync, async, semisync m_lTimeout = lTimeout; // used in semisync only m_nBatch = nBatch; // used in semisync and sync enumerations VARIANT v; VariantInit(&v); m_pObj->Get(L"__GENUS", 0, &v, NULL, NULL); m_bClass = (V_I4(&v) == WBEM_GENUS_CLASS); m_bResultingObj = NULL; } CObjectEditor::~CObjectEditor() { m_pObj->Release(); } INT_PTR CObjectEditor::Edit() { return Run(); } BOOL CObjectEditor::OnOK() { if(m_bResultingObj) { //We need to extract the flag values... LONG lChgFlags = 0; // change flags (i.e., WBEM_CHANGE_FLAG_TYPE) if (GetCheck(IDC_UPDATE_NORMAL)) lChgFlags |= WBEM_FLAG_CREATE_OR_UPDATE; if (GetCheck(IDC_UPDATE_CREATE)) lChgFlags |= WBEM_FLAG_CREATE_ONLY; if (GetCheck(IDC_UPDATE_UPDATE)) lChgFlags |= WBEM_FLAG_UPDATE_ONLY; if (GetCheck(IDC_UPDATE_COMPATIBLE)) lChgFlags |= WBEM_FLAG_UPDATE_COMPATIBLE; if (GetCheck(IDC_UPDATE_SAFE)) lChgFlags |= WBEM_FLAG_UPDATE_SAFE_MODE; if (GetCheck(IDC_UPDATE_FORCE)) lChgFlags |= WBEM_FLAG_UPDATE_FORCE_MODE; if (!ResultingObject(m_pObj, lChgFlags)) return TRUE; } return CBasicWbemDialog::OnOK(); } void CObjectEditor::RunDetached(CRefCountable* pOwner) { m_bResultingObj = TRUE; SetOwner(pOwner); SetDeleteOnClose(); Create(FALSE); } BOOL CObjectEditor::ResultingObject(IWbemClassObject* pObj, LONG lChgFlags) { BOOL bRes; if(m_bClass) bRes = _PutClass(m_hDlg, m_lGenFlags, lChgFlags, m_lSync, pObj, m_lTimeout); else bRes = _PutInstance(m_hDlg, m_lGenFlags, lChgFlags, m_lSync, pObj, m_lTimeout); return bRes; } void CObjectEditor::OnAddMethod() { // Add a dummy property for now // ============================ SCODE hres; VARIANT v; v.vt = VT_BSTR; IWbemClassObject * pIn = NULL; IWbemClassObject * pOut = NULL; SCODE sc; CBString bsParm(L"__PARAMETERS"); sc = g_pNamespace->GetObject(bsParm.GetString(), m_lGenFlags, g_Context, &pIn, NULL); sc = g_pNamespace->GetObject(bsParm.GetString(), m_lGenFlags, g_Context, &pOut, NULL); CBString bsTemp(L"__CLASS"); v.bstrVal = SysAllocString(L"InArgs"); sc = pIn->Put(bsTemp.GetString(), 0, &v, 0); SysFreeString(v.bstrVal); v.bstrVal = SysAllocString(L"OutArgs"); sc = pOut->Put(bsTemp.GetString(), 0, &v, 0); SysFreeString(v.bstrVal); bsTemp = L"DUMMY_METHOD__D"; if(FAILED(m_pObj->PutMethod(bsTemp.GetString(), 0, NULL, NULL))) { MessageBox(NULL, IDS_CANNOT_EDIT_METHOD, IDS_ERROR, MB_OK|MB_ICONSTOP); return; } IWbemQualifierSet* pQualifierSet; m_pObj->GetMethodQualifierSet(bsTemp.GetString(), &pQualifierSet); // Create CTestMethod with the dummy attr set for now // ================================================= CTestMethod method(pQualifierSet, pIn, pOut, FALSE, FALSE); m_pObj->Get(L"__CLASS", 0, &v, NULL, NULL); method.m_pClass = new wchar_t[wcslen(V_BSTR(&v)) + 1]; wcscpy(method.m_pClass, V_BSTR(&v)); VariantClear(&v); CMethodEditor ed(m_hDlg, &method, FALSE, FALSE); INT_PTR nRes = ed.Edit(); if ((nRes == IDCANCEL) || (nRes == 0)) { pQualifierSet->Release(); goto DeleteDummy; } // Set the method // ================ bsTemp = method.m_pName; hres = m_pObj->PutMethod(bsTemp.GetString(), 0, (method.m_bEnableInputArgs) ? method.m_pInArgs: NULL, (method.m_bEnableOutputArgs) ? method.m_pOutArgs : NULL); if(FAILED(hres)) { FormatError(hres, m_hDlg, NULL); goto DeleteDummy; } // Copy the Qualifiers // =================== IWbemQualifierSet* pRealQualifierSet; m_pObj->GetMethodQualifierSet(bsTemp.GetString(), &pRealQualifierSet); CopyQualifierSet(pRealQualifierSet, pQualifierSet, m_hDlg); pQualifierSet->EndEnumeration(); pQualifierSet->Release(); pRealQualifierSet->Release(); DeleteDummy: bsTemp = L"DUMMY_METHOD__D"; m_pObj->DeleteMethod(bsTemp.GetString()); Refresh(); return; } void CObjectEditor::OnEditMethod() { SCODE sc; IWbemClassObject * pIn = NULL; IWbemClassObject * pOut = NULL; // Find out which property is selected. // ==================================== LRESULT nIndex = SendMessage(m_hMethodList, LB_GETCURSEL, 0, 0); if (nIndex == LB_ERR) return; char buf[TEMP_BUF]; *buf = 0; SendMessage(m_hMethodList, LB_GETTEXT, nIndex, LPARAM(buf)); if (*buf == 0) return; WString wsName = buf; CBString bsTemp(L"__CLASS"); // Get the property value from the object // ====================================== m_pObj->GetMethod((LPWSTR)wsName, 0, &pIn, &pOut); // Create a CTestMethod from it // ========================== IWbemQualifierSet* pQualifierSet = 0; sc = m_pObj->GetMethodQualifierSet((LPWSTR)wsName, &pQualifierSet); IWbemClassObject * pTempIn = pIn; IWbemClassObject * pTempOut = pOut; VARIANT v; v.vt = VT_BSTR; // If the current methods lacks an input or output object, then just create a // temporary one in case the user decides to start using the input or output object. if(pTempIn == NULL) { CBString bsParm(L"__PARAMETERS"); sc = g_pNamespace->GetObject(bsParm.GetString(), m_lGenFlags, g_Context, &pTempIn, NULL); v.bstrVal = SysAllocString(L"InArgs"); sc = pTempIn->Put(bsTemp.GetString(), 0, &v, 0); SysFreeString(v.bstrVal); } if(pTempOut == NULL) { CBString bsParm(L"__PARAMETERS"); sc = g_pNamespace->GetObject(bsParm.GetString(), m_lGenFlags, g_Context, &pTempOut, NULL); v.bstrVal = SysAllocString(L"OutArgs"); sc = pTempOut->Put(bsTemp.GetString(), 0, &v, 0); SysFreeString(v.bstrVal); } CTestMethod Copy(pQualifierSet, pTempIn, pTempOut, pIn != NULL, pOut != NULL); if (pQualifierSet) pQualifierSet->Release(); Copy.m_pName = new wchar_t[wcslen(wsName) + 1]; wcscpy(Copy.m_pName, wsName); BSTR strClass; m_pObj->GetMethodOrigin((LPWSTR)wsName, &strClass); Copy.m_pClass = new wchar_t[wcslen(strClass) + 1]; wcscpy(Copy.m_pClass, strClass); SysFreeString(strClass); // Edit it. // ========= CMethodEditor ed(m_hDlg, &Copy, TRUE, !m_bClass); INT_PTR nRes = ed.Edit(); if ((nRes == IDCANCEL) || (nRes == 0)) return; // If here, we must replace the info for the property. // =================================================== sc = m_pObj->PutMethod(Copy.m_pName, 0, (Copy.m_bEnableInputArgs) ? Copy.m_pInArgs : NULL, (Copy.m_bEnableOutputArgs) ? Copy.m_pOutArgs : NULL); if(FAILED(sc)) { FormatError(sc, m_hDlg); } Refresh(); } void CObjectEditor::OnDelMethod() { // Find out which property is selected. // ==================================== LRESULT nIndex = SendMessage(m_hMethodList, LB_GETCURSEL, 0, 0); if (nIndex == LB_ERR) return; char buf[TEMP_BUF]; *buf = 0; SendMessage(m_hMethodList, LB_GETTEXT, nIndex, LPARAM(buf)); if (*buf == 0) return; WString WName = buf; if(FAILED(m_pObj->DeleteMethod(LPWSTR(WName)))) { MessageBox(NULL, IDS_CANNOT_EDIT_METHOD, IDS_ERROR, MB_OK|MB_ICONSTOP); return; } Refresh(); }