735 lines
18 KiB
C#
735 lines
18 KiB
C#
namespace Microsoft.VSDesigner.WMI
|
|
{
|
|
using System;
|
|
using System.ComponentModel;
|
|
//using System.Core;
|
|
using System.Windows.Forms;
|
|
using System.Runtime.InteropServices;
|
|
using System.Drawing;
|
|
using System.Management;
|
|
using System.Collections;
|
|
using System.Data;
|
|
|
|
internal enum ComparisonOperators
|
|
{
|
|
Equals = 0,
|
|
NotEquals,
|
|
LessThan,
|
|
LessThanOrEquals,
|
|
GreaterThan,
|
|
GreaterThanOrEquals
|
|
}
|
|
|
|
|
|
|
|
internal class WMIObjectPropertyTable : DataTable
|
|
{
|
|
private void InitializeComponent ()
|
|
{
|
|
}
|
|
|
|
private ManagementBaseObject mgmtObj = null;
|
|
|
|
private PropertyFilters propFilters = new PropertyFilters(false, false);
|
|
private GridMode gridMode = GridMode.ViewMode;
|
|
|
|
private DataColumn propOrigin = null;
|
|
private DataColumn propIsKey = null;
|
|
|
|
private DataColumn propNameColumn = null;
|
|
private DataColumn propTypeColumn = null;
|
|
private DataColumn propValueColumn = null;
|
|
|
|
private DataColumn propDescrColumn = null;
|
|
private DataColumn operatorColumn = null;
|
|
|
|
private DataColumn selectionBoxColumn = null;
|
|
|
|
private bool showOperators = false;
|
|
private bool showOrigin = false;
|
|
private bool showKeys = false;
|
|
private bool showSelectionBoxes = false;
|
|
private bool showValues = true;
|
|
private bool expandEmbedded = false;
|
|
private bool showEmbeddedObjValue = true; //NOTE: this overrides showValues
|
|
|
|
private Hashtable rowPropertyMap = new Hashtable(50);
|
|
|
|
public WMIObjectPropertyTable(ManagementBaseObject mgmtObjIn,
|
|
PropertyFilters propFiltersIn,
|
|
GridMode gridModeIn,
|
|
bool showOperatorsIn,
|
|
bool showOriginIn,
|
|
bool showKeysIn,
|
|
bool showSelectionBoxesIn,
|
|
bool showValuesIn,
|
|
bool expandEmbeddedIn,
|
|
bool showEmbeddedObjValueIn)
|
|
{
|
|
try
|
|
{
|
|
|
|
if (mgmtObjIn == null)
|
|
{
|
|
throw (new ArgumentNullException("mgmtObjIn"));
|
|
}
|
|
|
|
mgmtObj = mgmtObjIn;
|
|
propFilters = propFiltersIn;
|
|
gridMode = gridModeIn;
|
|
|
|
showOperators = showOperatorsIn;
|
|
showOrigin = showOriginIn;
|
|
showKeys = showKeysIn;
|
|
showSelectionBoxes = showSelectionBoxesIn;
|
|
showValues = showValuesIn;
|
|
expandEmbedded = expandEmbeddedIn;
|
|
showEmbeddedObjValue = showEmbeddedObjValueIn;
|
|
|
|
Initialize();
|
|
}
|
|
|
|
catch (Exception exc)
|
|
{
|
|
MessageBox.Show(WMISys.GetString("WMISE_Exception", exc.Message, exc.StackTrace));
|
|
}
|
|
}
|
|
|
|
|
|
public ManagementBaseObject WMIObject
|
|
{
|
|
get
|
|
{
|
|
return mgmtObj;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates and adds to grid a single row corresponding to a single property. Can be called recursively for embedded
|
|
/// objects.
|
|
/// </summary>
|
|
/// <param name="prop"> </param>
|
|
/// <param name="namePrefix">This is used for embedded objects, so that the propertyof an embedded object
|
|
/// appears to have name of form "Parent.Child" </param>
|
|
private DataRow CreatePropertyRow( Property prop, string namePrefix)
|
|
{
|
|
if (prop == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
if (propFilters.HideInherited && !prop.IsLocal)
|
|
{
|
|
return null; //skip this property
|
|
}
|
|
|
|
|
|
DataRow propRow = NewRow();
|
|
propRow[propNameColumn] = namePrefix + prop.Name;
|
|
|
|
propRow[propTypeColumn] = CimTypeMapper.ToString(prop.Type);
|
|
|
|
if (showOperators)
|
|
{
|
|
//TODO: initialize drop-down. How: in Beta2, a DataGridColumnStyle derived class
|
|
//can be added, DataGridComboBoxColumn. Ask urtuser if they are planning to
|
|
//to add one themselves
|
|
|
|
propRow[operatorColumn] = string.Empty;
|
|
}
|
|
|
|
if (prop.Type == CimType.Object)
|
|
{
|
|
if ((showValues || showEmbeddedObjValue)
|
|
&& prop.Value is ManagementBaseObject)
|
|
{
|
|
if (showOperators)
|
|
{
|
|
propRow[operatorColumn] = "ISA";
|
|
}
|
|
propRow[propValueColumn] = ((ManagementBaseObject)prop.Value).SystemProperties["__CLASS"].Value.ToString();
|
|
}
|
|
else
|
|
{
|
|
propRow[propValueColumn] = string.Empty;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (showValues)
|
|
{
|
|
propRow[propValueColumn] = prop.Value;
|
|
}
|
|
else
|
|
{
|
|
propRow[propValueColumn] = string.Empty;
|
|
}
|
|
}
|
|
//propRow[propDescrColumn] = WmiHelper.GetPropertyDescription(prop, wmiObj);
|
|
|
|
|
|
//set property origin column
|
|
|
|
if (showOrigin)
|
|
{
|
|
if (prop.IsLocal)
|
|
{
|
|
propRow[propOrigin] = true;
|
|
}
|
|
else
|
|
{
|
|
propRow[propOrigin] = false;
|
|
}
|
|
}
|
|
|
|
if (showKeys)
|
|
{
|
|
propRow[propIsKey] = WmiHelper.IsKeyProperty(prop);
|
|
}
|
|
|
|
//grey selectionBoxColumn for expanded embedded object properties:
|
|
if (propRow[propNameColumn].ToString().IndexOf(".") > 0)
|
|
{
|
|
//NOTE: this doesn't work!!! is there a way to disable input on an individual cell?
|
|
propRow.SetUnspecified(selectionBoxColumn);
|
|
}
|
|
|
|
|
|
Rows.Add (propRow);
|
|
|
|
if (prop.Type == CimType.Object && expandEmbedded)
|
|
{
|
|
if (prop.Value != null && prop.Value is ManagementBaseObject)
|
|
{
|
|
ManagementBaseObject embeddedObj = (ManagementBaseObject)prop.Value;
|
|
foreach (Property embeddedProp in embeddedObj.Properties)
|
|
{
|
|
CreatePropertyRow(embeddedProp, prop.Name + ".");
|
|
}
|
|
}
|
|
}
|
|
|
|
rowPropertyMap.Add(propRow, prop);
|
|
|
|
return propRow;
|
|
|
|
}
|
|
|
|
|
|
private void Initialize ()
|
|
{
|
|
try
|
|
{
|
|
|
|
try
|
|
{
|
|
this.TableName = mgmtObj.ClassPath.ClassName;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//if mgmtObj is a newly created instance of an abstract class,
|
|
//ClassPath will be unavailable. Don't set TableName in this case.
|
|
}
|
|
|
|
propNameColumn = new DataColumn (WMISys.GetString("WMISE_PropTable_ColumnName"));
|
|
|
|
//propNameColumn.AllowNull = false;
|
|
propNameColumn.Unique = true;
|
|
propNameColumn.DataType = typeof(string);
|
|
|
|
propTypeColumn = new DataColumn (WMISys.GetString("WMISE_PropTable_ColumnType"));
|
|
//propTypeColumn.AllowNull = false;
|
|
propTypeColumn.DataType = typeof(string);
|
|
|
|
propValueColumn = new DataColumn (WMISys.GetString("WMISE_PropTable_ColumnValue"));
|
|
propValueColumn.DefaultValue = null;
|
|
|
|
propDescrColumn = new DataColumn(WMISys.GetString("WMISE_PropTable_ColumnDescription"));
|
|
propDescrColumn.ReadOnly = true;
|
|
propDescrColumn.DefaultValue = string.Empty;
|
|
propDescrColumn.DataType = typeof(string);
|
|
|
|
if (showOperators)
|
|
{
|
|
operatorColumn = new DataColumn(WMISys.GetString("WMISE_PropTable_ColumnComparison"),
|
|
typeof(/*ComparisonOperators*/ string));
|
|
operatorColumn.DefaultValue = string.Empty;
|
|
operatorColumn.DataType = typeof(string);
|
|
operatorColumn.ReadOnly = false;
|
|
}
|
|
|
|
/*
|
|
ValueEditor dropDownEditor = new ValueEditor();
|
|
dropDownEditor.Style = ValueEditorStyles.DropdownArrow;
|
|
operatorColumn.DataValueEditorType = dropDownEditor.GetType();
|
|
*/
|
|
|
|
|
|
if (showKeys)
|
|
{
|
|
propIsKey = new DataColumn (WMISys.GetString("WMISE_PropTable_ColumnIsKey"), typeof(Boolean));
|
|
//propIsKey.AllowNull = false;
|
|
propIsKey.DefaultValue = false;
|
|
}
|
|
|
|
if (showOrigin)
|
|
{
|
|
propOrigin = new DataColumn (WMISys.GetString("WMISE_PropTable_ColumnIsLocal"), typeof(Boolean));
|
|
//propOrigin.AllowNull = false;
|
|
propOrigin.DefaultValue = true;
|
|
}
|
|
|
|
if (showSelectionBoxes)
|
|
{
|
|
selectionBoxColumn = new DataColumn(WMISys.GetString("WMISE_PropertyInResultset"),
|
|
typeof (bool));
|
|
//selectionBoxColumn.AllowNull = false;
|
|
selectionBoxColumn.DefaultValue = true;
|
|
}
|
|
|
|
//set read/write permissions on columns
|
|
//Note that DefaultView takes care of the rest of the restrictions
|
|
//(see below)
|
|
if (gridMode == GridMode.EditMode ||
|
|
gridMode == GridMode.LocalEditMode)
|
|
{
|
|
propNameColumn.ReadOnly = true;
|
|
propTypeColumn.ReadOnly = true;
|
|
propValueColumn.ReadOnly = false;
|
|
|
|
if (showOrigin)
|
|
{
|
|
propOrigin.ReadOnly = true;
|
|
}
|
|
if (showKeys)
|
|
{
|
|
propIsKey.ReadOnly = true;
|
|
}
|
|
}
|
|
|
|
if (gridMode == GridMode.DesignMode && showOrigin)
|
|
{
|
|
propOrigin.ReadOnly = true;
|
|
}
|
|
|
|
Columns.Add(propNameColumn);
|
|
Columns.Add(propTypeColumn);
|
|
if (showOperators)
|
|
{
|
|
//operatorColumn.DataValueEditorType = typeof(OperatroDataColumnEditor);
|
|
operatorColumn.ReadOnly = false;
|
|
Columns.Add(operatorColumn);
|
|
}
|
|
|
|
Columns.Add(propValueColumn);
|
|
//Columns.Add(propDescrColumn);
|
|
|
|
if (showOrigin)
|
|
{
|
|
Columns.Add(propOrigin);
|
|
}
|
|
if (showKeys)
|
|
{
|
|
Columns.Add(propIsKey);
|
|
}
|
|
if (showSelectionBoxes)
|
|
{
|
|
Columns.Add (selectionBoxColumn);
|
|
}
|
|
|
|
|
|
foreach (Property prop in mgmtObj.Properties)
|
|
{
|
|
CreatePropertyRow(prop, string.Empty);
|
|
}
|
|
//Add system properties here (if PropertyFilters.ShowAll)
|
|
if (!propFilters.HideSystem)
|
|
{
|
|
foreach (Property sysProp in mgmtObj.SystemProperties)
|
|
{
|
|
CreatePropertyRow(sysProp, string.Empty);
|
|
|
|
}
|
|
}
|
|
|
|
this.CaseSensitive = false;
|
|
this.RowChanged += new DataRowChangeEventHandler(this.RowChangedEventHandler);
|
|
this.RowChanging += new DataRowChangeEventHandler(this.RowChangingEventHandler);
|
|
|
|
|
|
DataView view = this.DefaultView;
|
|
switch (gridMode)
|
|
{
|
|
case (GridMode.ViewMode):
|
|
{
|
|
view.AllowEdit = false; //wmi raid 2866?
|
|
view.AllowDelete = false;
|
|
view.AllowNew = false;
|
|
break;
|
|
}
|
|
case (GridMode.EditMode):
|
|
{
|
|
view.AllowEdit = true;
|
|
view.AllowDelete = false;
|
|
view.AllowNew = false;
|
|
break;
|
|
}
|
|
case (GridMode.LocalEditMode) :
|
|
{
|
|
view.AllowEdit = true;
|
|
view.AllowDelete = false;
|
|
view.AllowNew = false;
|
|
break;
|
|
}
|
|
case (GridMode.DesignMode):
|
|
{
|
|
view.AllowEdit = true;
|
|
view.AllowDelete = true;
|
|
view.AllowNew = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
catch (Exception exc)
|
|
{
|
|
MessageBox.Show(WMISys.GetString("WMISE_Exception", exc.Message, exc.StackTrace));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
protected void RowChangedEventHandler(object sender,
|
|
DataRowChangeEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
|
|
DataRow RowAffected = e.Row;
|
|
switch (e.Action)
|
|
{
|
|
case(DataRowAction.Add):
|
|
{
|
|
/*
|
|
MessageBox.Show("Cannot Add Rows. Deleting...");
|
|
RowAffected.Delete();
|
|
*/
|
|
break;
|
|
|
|
}
|
|
case(DataRowAction.Change):
|
|
{
|
|
DataRow row = e.Row;
|
|
|
|
if (gridMode == GridMode.EditMode)
|
|
{
|
|
//this can only be value change
|
|
Property propAffected = (Property)this.rowPropertyMap[row];
|
|
|
|
Object newValue = WmiHelper.GetTypedObjectFromString(propAffected.Type,
|
|
row[propValueColumn].ToString());
|
|
|
|
|
|
propAffected.Value = newValue;
|
|
|
|
}
|
|
|
|
//possibly handle other modes here
|
|
|
|
break;
|
|
}
|
|
case(DataRowAction.Commit):
|
|
{
|
|
//MessageBox.Show("DataRowAction.Commit");
|
|
break;
|
|
}
|
|
case(DataRowAction.Delete):
|
|
{
|
|
MessageBox.Show("Cannot delete nodes.Adding back...");
|
|
RowAffected.CancelEdit();
|
|
break;
|
|
}
|
|
case(DataRowAction.Nothing):
|
|
{
|
|
MessageBox.Show("DataRowAction.Nothing");
|
|
break;
|
|
}
|
|
case(DataRowAction.Rollback):
|
|
{
|
|
MessageBox.Show("DataRowAction.Rollback");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
MessageBox.Show(WMISys.GetString("WMISE_Exception", exc.Message, exc.StackTrace));
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
protected void RowChangingEventHandler(object sender,
|
|
DataRowChangeEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
|
|
DataRow row = e.Row;
|
|
switch (e.Action)
|
|
{
|
|
case(DataRowAction.Add):
|
|
{
|
|
//throw (new Exception("Cannot add rows"));
|
|
break;
|
|
|
|
}
|
|
case(DataRowAction.Change):
|
|
{
|
|
//if this is an object, datetime, enum or ref property changing,
|
|
//bring up custom UI for editing these!!!!
|
|
if (gridMode == GridMode.EditMode)
|
|
{
|
|
//this can only be value change
|
|
Property propAffected = (Property)this.rowPropertyMap[row]; //mgmtObj.Properties[row[propNameColumn].ToString()];
|
|
|
|
if (propAffected.Type == CimType.Object)
|
|
{
|
|
////MessageBox.Show("should bring up custom type editor for objects");
|
|
}
|
|
|
|
if (propAffected.Type == CimType.Reference)
|
|
{
|
|
//MessageBox.Show("should bring up custom type editor for refs");
|
|
}
|
|
|
|
if (propAffected.Type == CimType.DateTime)
|
|
{
|
|
//MessageBox.Show("should bring up custom type editor for datetime");
|
|
}
|
|
|
|
if (WmiHelper.IsValueMap(propAffected))
|
|
{
|
|
//MessageBox.Show("should bring up custom type editor for enums");
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
case(DataRowAction.Commit):
|
|
{
|
|
//MessageBox.Show("DataRowAction.Commit");
|
|
break;
|
|
}
|
|
case(DataRowAction.Delete):
|
|
{
|
|
throw (new Exception("Cannot delete rows"));
|
|
}
|
|
case(DataRowAction.Nothing):
|
|
{
|
|
MessageBox.Show("DataRowAction.Nothing");
|
|
break;
|
|
}
|
|
case(DataRowAction.Rollback):
|
|
{
|
|
MessageBox.Show("DataRowAction.Rollback");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
MessageBox.Show(WMISys.GetString("WMISE_Exception", exc.Message, exc.StackTrace));
|
|
throw(exc);
|
|
}
|
|
}
|
|
|
|
internal void SetPropertyValue (int rowNum, String val)
|
|
{
|
|
try
|
|
{
|
|
|
|
DataRow row = this.Rows[rowNum];
|
|
|
|
Property propAffected = (Property)this.rowPropertyMap[row]; //mgmtObj.Properties[row[propNameColumn].ToString()];
|
|
|
|
Object newValue = WmiHelper.GetTypedObjectFromString(propAffected.Type,
|
|
val);
|
|
|
|
propAffected.Value = newValue;
|
|
|
|
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
MessageBox.Show(WMISys.GetString("WMISE_Exception", exc.Message, exc.StackTrace));
|
|
throw (exc);
|
|
}
|
|
}
|
|
|
|
public string WhereClause
|
|
{
|
|
get
|
|
{
|
|
if (!showOperators || Rows.Count == 0)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
const String strWhere = " WHERE ";
|
|
const String strAnd = " AND ";
|
|
|
|
String clause = strWhere;
|
|
for (int i = 0; i < Rows.Count; i++)
|
|
{
|
|
DataRow curRow = Rows[i];
|
|
|
|
Property curProp = (Property)rowPropertyMap[curRow]; //mgmtObj.Properties[curRow[propNameColumn].ToString()];
|
|
|
|
if (curRow[propValueColumn].ToString() == "")
|
|
{
|
|
continue;
|
|
}
|
|
|
|
clause += curRow[propNameColumn] + " " +
|
|
curRow[operatorColumn] + " ";
|
|
|
|
//if the property is a string, datetime or object,
|
|
//put quotes around the value
|
|
if (curProp.Type == CimType.DateTime ||
|
|
curProp.Type == CimType.Object ||
|
|
curProp.Type == CimType.String) //any others?
|
|
{
|
|
clause += "\"" + curRow[propValueColumn] + "\"" + strAnd;
|
|
}
|
|
else
|
|
{
|
|
clause += curRow[propValueColumn] + strAnd;
|
|
}
|
|
}
|
|
|
|
if (clause == strWhere)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
//get rid of the last " AND "
|
|
if (clause.Substring (clause.Length - strAnd.Length, strAnd.Length) == strAnd)
|
|
{
|
|
clause = clause.Substring(0, clause.Length - strAnd.Length);
|
|
}
|
|
|
|
return clause;
|
|
}
|
|
|
|
}
|
|
|
|
public void AddSystemProperties()
|
|
{
|
|
if (!propFilters.HideSystem)
|
|
{
|
|
//already there
|
|
return;
|
|
}
|
|
propFilters.HideSystem = false;
|
|
|
|
foreach (Property sysProp in mgmtObj.SystemProperties)
|
|
{
|
|
CreatePropertyRow(sysProp, string.Empty);
|
|
}
|
|
}
|
|
|
|
public void RemoveSystemProperties()
|
|
{
|
|
if (propFilters.HideSystem)
|
|
{
|
|
//already not there
|
|
return;
|
|
}
|
|
propFilters.HideSystem = true;
|
|
|
|
ArrayList forRemoval = new ArrayList(this.Rows.Count);
|
|
|
|
foreach (DataRow thisRow in this.Rows)
|
|
{
|
|
if (thisRow[propNameColumn].ToString().StartsWith("__"))
|
|
{
|
|
forRemoval.Add(thisRow);
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < forRemoval.Count; i++)
|
|
{
|
|
this.Rows.Remove((DataRow)forRemoval[i]);
|
|
this.rowPropertyMap.Remove((DataRow)forRemoval[i]);
|
|
}
|
|
|
|
}
|
|
|
|
public void AddInheritedProperties()
|
|
{
|
|
if (!propFilters.HideInherited)
|
|
{
|
|
//already there
|
|
return;
|
|
}
|
|
|
|
propFilters.HideInherited = false;
|
|
|
|
foreach (Property curProp in mgmtObj.Properties)
|
|
{
|
|
if (!curProp.IsLocal)
|
|
{
|
|
CreatePropertyRow(curProp, string.Empty);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public void RemoveInheritedProperties()
|
|
{
|
|
|
|
if (propFilters.HideInherited)
|
|
{
|
|
//already not there
|
|
return;
|
|
}
|
|
|
|
propFilters.HideInherited = true;
|
|
|
|
ArrayList forRemoval = new ArrayList(this.Rows.Count);
|
|
|
|
foreach (DataRow thisRow in this.Rows)
|
|
{
|
|
//special-case expanded embedded properties
|
|
//if a property name contains a dot, that means
|
|
//this is an expanded embedded property name
|
|
if (thisRow[propNameColumn].ToString().IndexOf(".") >= 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
Property curProp = (Property)this.rowPropertyMap[thisRow]; //mgmtObj.Properties[thisRow[propNameColumn].ToString()];
|
|
if (!curProp.IsLocal)
|
|
{
|
|
forRemoval.Add(thisRow);
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < forRemoval.Count; i++)
|
|
{
|
|
this.Rows.Remove((DataRow)forRemoval[i]);
|
|
this.rowPropertyMap.Remove((DataRow)forRemoval[i]);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|