private void filterEnums(DesignerEnum enumAtt, string enumName, Type enumtype) {
UIObject uiObject = _object as UIObject;
object[] excludedElements = null;
if (uiObject != null) {
excludedElements = uiObject.GetExcludedEnums(enumAtt);
}
Array list = Enum.GetValues(enumtype);
foreach(object enumVal in list) {
bool excluded = false;
if (excludedElements != null) {
for (int i = 0; i < excludedElements.Length; ++i) {
if (excludedElements[i].Equals(enumVal)) {
excluded = true;
break;
}
}
}
if (!excluded) {
_allValues.Add(enumVal);
if (DesignerEnum.GetDisplayName(enumVal) == enumName) {
_values.Add(enumVal);
comboBox.Items.Add(enumName);
}
}
}
comboBox.Text = enumName;
}
public override void SetVariable(VariableDef variable, object obj)
{
base.SetVariable(variable, obj);
_valueWasAssigned = false;
clear();
if (variable != null)
{
Type enumtype = variable.ValueType;
if (enumtype.IsEnum)
{
Array list = Enum.GetValues(enumtype);
string enumName = DesignerEnum.GetDisplayName(variable.Value);
foreach (object enumVal in list)
{
_allValues.Add(enumVal);
if (DesignerEnum.GetDisplayName(enumVal) == enumName)
{
_values.Add(enumVal);
comboBox.Items.Add(enumName);
}
}
comboBox.Text = enumName;
}
}
_valueWasAssigned = true;
}
private void comboBox_DropDown(object sender, EventArgs e)
{
if (_allValues.Count > 0 && _values.Count != _allValues.Count)
{
_values = _allValues;
if (string.IsNullOrEmpty(comboBox.Text))
{
foreach (object v in _values)
{
string enumName = DesignerEnum.GetDisplayName(v);
if (!comboBox.Items.Contains(enumName))
{
comboBox.Items.Add(enumName);
}
}
}
else
{
int index = -1;
for (int i = 0; i < _values.Count; ++i)
{
string enumName = DesignerEnum.GetDisplayName(_values[i]);
if (comboBox.Text == enumName)
{
index = i;
break;
}
}
if (index > -1)
{
for (int i = index - 1; i >= 0; --i)
{
string enumName = DesignerEnum.GetDisplayName(_values[i]);
if (!comboBox.Items.Contains(enumName))
{
comboBox.Items.Insert(0, enumName);
}
}
for (int i = index + 1; i < _values.Count; ++i)
{
string enumName = DesignerEnum.GetDisplayName(_values[i]);
if (!comboBox.Items.Contains(enumName))
{
comboBox.Items.Add(enumName);
}
}
}
}
}
}
private void comboBox_DrawItem(object sender, DrawItemEventArgs e)
{
if (e.Index < 0)
{
return;
}
e.DrawBackground();
e.Graphics.DrawString(comboBox.Items[e.Index].ToString(), e.Font, System.Drawing.Brushes.LightGray, e.Bounds);
e.DrawFocusRectangle();
this.OnDescriptionChanged(this.DisplayName, DesignerEnum.GetDescription(_values[e.Index]));
}
/// <summary>
/// Get the display string in the editor of the given object.
/// </summary>
/// <param name="obj">The given object.</param>
/// <returns>Returns the string value for displaying the object.</returns>
public static string RetrieveDisplayValue(object obj, object parent = null, string paramName = null, int indexInArray = -1)
{
string str = string.Empty;
if (obj != null)
{
Type type = obj.GetType();
// ISerializableData type
if (obj is ISerializableData)
{
str = ((ISerializableData)obj).GetDisplayValue();
}
// Array type
else if (Plugin.IsArrayType(type))
{
str = DesignerArray.RetrieveDisplayValue(obj);
}
// Struct type
else if (Plugin.IsCustomClassType(type))
{
str = DesignerStruct.RetrieveDisplayValue(obj, parent, paramName, indexInArray);
}
// Enum type
else if (type.IsEnum)
{
str = DesignerEnum.GetDisplayName(obj);
}
// Other types
else
{
str = obj.ToString();
if (Plugin.IsStringType(type))
{
str = string.Format("\"{0}\"", str);
}
else
{
string[] tokens = str.Split(' ');
str = tokens[tokens.Length - 1];
}
}
}
return(str);
}
private void filterEnums(DesignerEnum enumAtt, string enumName, Type enumtype)
{
UIObject uiObject = _object as UIObject;
object[] excludedElements = null;
if (uiObject != null)
{
excludedElements = uiObject.GetExcludedEnums(enumAtt);
}
Array list = Enum.GetValues(enumtype);
foreach (object enumVal in list)
{
bool excluded = false;
if (excludedElements != null)
{
for (int i = 0; i < excludedElements.Length; ++i)
{
if (excludedElements[i].Equals(enumVal))
{
excluded = true;
break;
}
}
}
if (!excluded)
{
_allValues.Add(enumVal);
if (DesignerEnum.GetDisplayName(enumVal) == enumName)
{
_values.Add(enumVal);
comboBox.Items.Add(enumName);
}
}
}
comboBox.Text = enumName;
}
public override void SetVariable(VariableDef variable, object obj)
{
base.SetVariable(variable, obj);
_valueWasAssigned = false;
clear();
if (variable != null)
{
Type enumtype = variable.ValueType;
if (enumtype.IsEnum)
{
string enumName = DesignerEnum.GetDisplayName(variable.Value);
filterEnums(null, enumName, enumtype);
}
}
_valueWasAssigned = true;
}
public override void SetArrayProperty(DesignerArrayPropertyInfo arrayProperty, object obj)
{
base.SetArrayProperty(arrayProperty, obj);
clear();
Array list = Enum.GetValues(arrayProperty.ItemType);
string enumName = DesignerEnum.GetDisplayName(arrayProperty.Value);
foreach (object enumVal in list)
{
_allValues.Add(enumVal);
if (DesignerEnum.GetDisplayName(enumVal) == enumName)
{
_values.Add(enumVal);
comboBox.Items.Add(enumName);
}
}
comboBox.Text = enumName;
}
public override void SetParameter(MethodDef.Param param, object obj, bool bReadonly)
{
base.SetParameter(param, obj, bReadonly);
string enumName = string.Empty;
Type enumtype = null;
DesignerEnum enumAtt = param.Attribute as DesignerEnum;
if (enumAtt != null)
{
enumName = DesignerEnum.GetDisplayName(param.Value);
enumtype = param.Value.GetType();
}
if (enumtype == null)
{
throw new Exception(string.Format(Resources.ExceptionDesignerAttributeExpectedEnum, param.Attribute.DisplayName));
}
clear();
filterEnums(enumAtt, enumName, enumtype);
}
public override void SetProperty(DesignerPropertyInfo property, object obj)
{
base.SetProperty(property, obj);
string enumName = string.Empty;
Type enumtype = null;
DesignerEnum enumAtt = property.Attribute as DesignerEnum;
if (enumAtt != null)
{
enumName = DesignerEnum.GetDisplayName(property.Property.GetValue(obj, null));
enumtype = property.Property.PropertyType;
}
if (enumtype == null)
{
throw new Exception(string.Format(Resources.ExceptionDesignerAttributeExpectedEnum, property.Property.Name));
}
clear();
filterEnums(enumAtt, enumName, enumtype);
}
public override object[] GetExcludedEnums(DesignerEnum enumAttr)
{
if (enumAttr != null && enumAttr.ExcludeTag == "ConditionOperaptor")
{
if (this.Opl != null)
{
if (this.Opl.ValueType != typeof(bool))
{
//and and or are only valid for bool, so to exclude and and or when the type is not bool
object[] excludedOperators = new object[] { OperatorType.And, OperatorType.Or };
return excludedOperators;
}
else if (this.Opl.ValueType == typeof(bool))
{
object[] excludedOperators = new object[] { OperatorType.Greater, OperatorType.GreaterEqual, OperatorType.Less, OperatorType.LessEqual };
return excludedOperators;
}
}
}
return null;
}
public override object[] GetExcludedEnums(DesignerEnum enumAttr)
{
return null;
}
public override object[] GetExcludedEnums(DesignerEnum enumAttr)
{
if (enumAttr != null && enumAttr.ExcludeTag == "ComputeOperaptor")
{
if (this.Opl != null)
{
if (string.IsNullOrEmpty(this.Opl.NativeType))
return null;
bool bIsBool = false;
bool bIsNumber = false;
Type type = Plugin.GetTypeFromName(Plugin.GetNativeTypeName(this.Opl.NativeType)); ;
if (type != null)
{
bIsBool = Plugin.IsBooleanType(type);
bIsNumber = (Plugin.IsIntergerType(type) || Plugin.IsFloatType(type));
}
if (bIsBool || !bIsNumber)
{
//+/-/*// are not valid for bool
object[] excludedOperators = new object[] { ComputeOperator.Add, ComputeOperator.Sub, ComputeOperator.Mul, ComputeOperator.Div };
return excludedOperators;
}
else
{
object[] excludedOperators = new object[] { ComputeOperator.Invalid };
return excludedOperators;
}
}
}
return null;
}
public override object[] GetExcludedEnums(DesignerEnum enumAttr)
{
//List<object> excludedOperatorsResult = new List<object>() { OperatorType.Assignment, OperatorType.In };
List<object> excludedOperatorsResult = new List<object>() { OperatorType.Assignment };
if (enumAttr != null && enumAttr.ExcludeTag == "ConditionOperaptor")
{
if (this.Opl != null)
{
if (this.Opl.ValueType != typeof(bool))
{
//and and or are only valid for bool, so to exclude and and or when the type is not bool
object[] excludedOperators = new object[] { OperatorType.And, OperatorType.Or };
excludedOperatorsResult.AddRange(excludedOperators);
}
else if (this.Opl.ValueType == typeof(bool))
{
object[] excludedOperators = new object[] { OperatorType.Greater, OperatorType.GreaterEqual, OperatorType.Less, OperatorType.LessEqual };
excludedOperatorsResult.AddRange(excludedOperators);
}
}
}
return excludedOperatorsResult.ToArray();
}
public override object[] GetExcludedEnums(DesignerEnum enumAttr)
{
ArrayList enums = new ArrayList();
enums.Add(OperatorTypes.Invalid);
enums.Add(OperatorTypes.Assign);
enums.Add(OperatorTypes.Add);
enums.Add(OperatorTypes.Sub);
enums.Add(OperatorTypes.Mul);
enums.Add(OperatorTypes.Div);
if (enumAttr != null && enumAttr.ExcludeTag == "TransitionOperaptor")
{
if (this.Opl != null && !string.IsNullOrEmpty(this.Opl.NativeType))
{
bool bIsBool = false;
bool bIsNumber = false;
Type type = Plugin.GetTypeFromName(Plugin.GetNativeTypeName(this.Opl.NativeType));
if (type != null)
{
bIsBool = Plugin.IsBooleanType(type);
bIsNumber = (Plugin.IsIntergerType(type) || Plugin.IsFloatType(type));
}
if (bIsBool || !bIsNumber)
{
enums.Add(OperatorTypes.Greater);
enums.Add(OperatorTypes.Less);
enums.Add(OperatorTypes.GreaterEqual);
enums.Add(OperatorTypes.LessEqual);
}
}
}
return enums.ToArray();
}
public override object[] GetExcludedEnums(DesignerEnum enumAttr) {
ArrayList enums = new ArrayList();
enums.Add(OperatorTypes.Invalid);
if (this.Node != null && this.Node.IsFSM)
{
enums.Add(OperatorTypes.Equal);
enums.Add(OperatorTypes.NotEqual);
enums.Add(OperatorTypes.Greater);
enums.Add(OperatorTypes.Less);
enums.Add(OperatorTypes.GreaterEqual);
enums.Add(OperatorTypes.LessEqual);
}
if (enumAttr != null && enumAttr.ExcludeTag == "AttachActionOperaptor") {
if (this.Opl != null && !string.IsNullOrEmpty(this.Opl.NativeType)) {
bool isPropReadonly = false;
if (this.Opl.Var != null && this.Opl.Var.IsProperty && this.Opl.Var.Property != null)
{
isPropReadonly = this.Opl.Var.Property.IsReadonly;
}
bool bIsBool = false;
bool bIsNumber = false;
Type type = Plugin.GetTypeFromName(Plugin.GetNativeTypeName(this.Opl.NativeType));
if (type != null) {
bIsBool = Plugin.IsBooleanType(type);
bIsNumber = (Plugin.IsIntergerType(type) || Plugin.IsFloatType(type));
}
if (bIsBool || !bIsNumber) {
enums.Add(OperatorTypes.Add);
enums.Add(OperatorTypes.Sub);
enums.Add(OperatorTypes.Mul);
enums.Add(OperatorTypes.Div);
enums.Add(OperatorTypes.Greater);
enums.Add(OperatorTypes.Less);
enums.Add(OperatorTypes.GreaterEqual);
enums.Add(OperatorTypes.LessEqual);
}
if (isPropReadonly || this.Opl.IsMethod && this.Opl.Method != null) {
enums.Add(OperatorTypes.Assign);
if (!enums.Contains(OperatorTypes.Add)) {
enums.Add(OperatorTypes.Add);
enums.Add(OperatorTypes.Sub);
enums.Add(OperatorTypes.Mul);
enums.Add(OperatorTypes.Div);
}
}
}
}
return enums.ToArray();
}
public override object[] GetExcludedEnums(DesignerEnum enumAttr) {
if (enumAttr != null && enumAttr.ExcludeTag == "PreconditionFailResult") {
//only success/failture are valid
object[] status = new object[] { EBTStatus.BT_INVALID, EBTStatus.BT_RUNNING};
return status;
}
return null;
}
public virtual object[] GetExcludedEnums(DesignerEnum enumAttr) {
return null;
}
public override object[] GetExcludedEnums(DesignerEnum enumAttr)
{
object[] excludedEnums = base.GetExcludedEnums(enumAttr);
Debug.Check(excludedEnums.Length >= 1 && (OperatorTypes)excludedEnums[0] == OperatorTypes.Invalid);
ArrayList enums = new ArrayList(excludedEnums);
List<OperatorTypes> compareEnums = new List<OperatorTypes> { OperatorTypes.Equal, OperatorTypes.Greater, OperatorTypes.Less, OperatorTypes.GreaterEqual, OperatorTypes.LessEqual, OperatorTypes.NotEqual };
foreach (object e in compareEnums)
{
if (!enums.Contains(e))
enums.Add(e);
}
return enums.ToArray();
}
public override void SetProperty(DesignerPropertyInfo property, object obj)
{
base.SetProperty(property, obj);
string enumName = string.Empty;
Type enumtype = null;
DesignerEnum enumAtt = property.Attribute as DesignerEnum;
if (enumAtt != null)
{
enumName = DesignerEnum.GetDisplayName(property.Property.GetValue(obj, null));
enumtype = property.Property.PropertyType;
}
if (enumtype == null)
{
throw new Exception(string.Format(Resources.ExceptionDesignerAttributeExpectedEnum, property.Property.Name));
}
clear();
Behaviac.Design.Nodes.Node node = obj as Behaviac.Design.Nodes.Node;
Behaviac.Design.Attachments.Attach evt = obj as Behaviac.Design.Attachments.Attach;
object[] excludedElements = null;
if (node != null)
{
excludedElements = node.GetExcludedEnums(enumAtt);
}
else if (evt != null)
{
excludedElements = evt.GetExcludedEnums(enumAtt);
}
Array list = Enum.GetValues(enumtype);
foreach (object enumVal in list)
{
bool excluded = false;
if (excludedElements != null)
{
for (int i = 0; i < excludedElements.Length; ++i)
{
if (excludedElements[i].Equals(enumVal))
{
excluded = true;
break;
}
}
}
if (!excluded)
{
_allValues.Add(enumVal);
if (DesignerEnum.GetDisplayName(enumVal) == enumName)
{
_values.Add(enumVal);
comboBox.Items.Add(enumName);
}
}
}
comboBox.Text = enumName;
}
