public override void SetPar(ParInfo par, object obj)
{
if (_par != null)
{
_par.ParameterSet -= parameter_ParameterSet;
}
base.SetPar(par, obj);
if (_par != null)
{
_par.ParameterSet -= parameter_ParameterSet;
_par.ParameterSet += parameter_ParameterSet;
Size size = this.Size;
this.propertyEditor = CreateEditor(_par.Type);
if (this.propertyEditor != null)
{
this.propertyEditor.SetPar(_par, obj);
this.propertyEditor.ValueWasAssigned();
this.ValueWasAssigned();
this.propertyEditor.ValueWasChanged += editor_ValueWasChanged;
this.propertyEditor.MouseEnter += propertyEditor_MouseEnter;
this.Size = size;
}
}
}
static private void WriteParString(BsonSerializer file, string valueName, ParInfo par)
{
string parStr = par.DefaultValue;
//file.WriteAttribute(valueName, parStr);
file.WriteString(parStr);
}
public override void SetPar(ParInfo par, object obj)
{
if (_par != null)
_par.ParameterSet -= parameter_ParameterSet;
base.SetPar(par, obj);
if (_par != null)
{
_par.ParameterSet -= parameter_ParameterSet;
_par.ParameterSet += parameter_ParameterSet;
Size size = this.Size;
this.propertyEditor = CreateEditor(_par.Type);
if (this.propertyEditor != null)
{
this.propertyEditor.SetPar(_par, obj);
this.propertyEditor.ValueWasAssigned();
this.ValueWasAssigned();
this.propertyEditor.ValueWasChanged += editor_ValueWasChanged;
this.propertyEditor.MouseEnter += propertyEditor_MouseEnter;
this.Size = size;
}
}
}
public virtual void SetPar(ParInfo par, object obj)
{
_par = par;
_object = obj;
SetVariable(par.Variable, obj);
}
public override void SetPar(ParInfo par, object obj)
{
base.SetPar(par, obj);
if (par != null && par.Variable != null)
setProperty(par.Variable.Value, par.Name, false, obj);
else
update();
}
public override void SetPar(ParInfo par, object obj)
{
base.SetPar(par, obj);
if (_object != null && _object is Event)
{
Event e = _object as Event;
_method = e.EventName;
setComboBox();
}
}
private void LoadParameters(XmlNode xmlNode, Nodes.Node node, List <ParInfo> pars)
{
pars.Clear();
if (xmlNode != null)
{
foreach (XmlNode child in xmlNode.ChildNodes)
{
try
{
if (child.Attributes["Name"] != null && child.Attributes["Type"] != null)
{
ParInfo par = new ParInfo(node);
par.Name = child.Attributes["Name"].Value;
if (string.IsNullOrEmpty(par.Name))
{
continue;
}
par.TypeName = Plugin.GetFullTypeName(child.Attributes["Type"].Value);
if (string.IsNullOrEmpty(par.TypeName))
{
continue;
}
if (child.Attributes["EventParam"] != null)
{
par.EventParam = child.Attributes["EventParam"].Value;
}
if (child.Attributes["Desc"] != null)
{
par.Description = child.Attributes["Desc"].Value;
}
Type valueType = Plugin.GetType(par.TypeName);
string defaultValue = child.Attributes["DefaultValue"].Value;
par.Variable = new VariableDef(null);
Plugin.InvokeTypeParser(valueType, defaultValue, (object value) => par.Variable.Value = value, node);
pars.Add(par);
}
}
catch (Exception e)
{
MessageBox.Show(e.Message, Resources.LoadError, MessageBoxButtons.OK);
}
}
}
}
public override void SetPar(ParInfo par, object obj)
{
Debug.Check(par != null);
base.SetPar(par, obj);
this.typeComboBox.Items.Clear();
this.typeComboBox.Items.Add(VariableDef.kConst);
this.typeComboBox.Items.Add(VariableDef.kEvent);
this.typeComboBox.SelectedIndex = getComboIndex();
//createEditor(getValueType());
}
public void SetParameter(ParInfo parameter, Nodes.Node node) {
_parameter = parameter;
_node = node;
typeComboBox.Width = flowLayoutPanel.Width * 2 / 5;
typeComboBox.Items.Clear();
foreach(Type key in Plugin.TypeHandlers.Keys) {
typeComboBox.Items.Add(Plugin.GetNativeTypeName(key.Name));
}
typeComboBox.Text = parameter.TypeName;
}
public override void SetPar(ParInfo par, object obj)
{
Debug.Check(par != null);
base.SetPar(par, obj);
this.typeComboBox.Items.Clear();
this.typeComboBox.Items.Add(VariableDef.kConst);
this.typeComboBox.Items.Add(VariableDef.kEvent);
this.typeComboBox.SelectedIndex = getComboIndex();
//createEditor(getValueType());
}
public override void SetPar(ParInfo par, object obj)
{
base.SetPar(par, obj);
if (par != null && par.Variable != null)
{
setProperty(par.Variable.Value, par.Name, false, obj);
}
else
{
update();
}
}
static private void WriteParValue(BsonSerializer file, string valueName, ParInfo par)
{
string parStr = par.DefaultValue;
object v = null;
Type valueType = par.Type;
if (valueType != null && Plugin.InvokeTypeParser(valueType, parStr, (object value) => v = value, null))
{
//file.WriteAttribute(valueName, v);
file.Write(v);
}
}
private void ExportPar(XmlWriter file, ParInfo par, bool bExportValue)
{
file.WriteStartElement("par");
file.WriteAttributeString("name", par.BasicName);
file.WriteAttributeString("type", par.NativeType);
if (bExportValue)
{
file.WriteAttributeString("value", par.DefaultValue);
}
file.WriteEndElement();
}
public override void OnPropertyValueChanged(DesignerPropertyInfo property)
{
if (property.Property.Name == "Prototype")
{
List <ParInfo> pars = ((Behavior)(this.Behavior)).LocalVars;
bool bLoop = true;
//remove old added local variables
while (bLoop)
{
int index = pars.FindIndex((p) => p.Name.IndexOf(LOCAL_TASK_PARAM_PRE) != -1);
if (index != -1)
{
pars.RemoveAt(index);
}
else
{
bLoop = false;
}
}
for (int i = 0; i < this._task.Params.Count; ++i)
{
var param = this._task.Params[i];
string par_name = string.Format("{0}{1}", LOCAL_TASK_PARAM_PRE, i);
ParInfo par = new ParInfo(this, this.Behavior != null ? this.Behavior.AgentType : null);
par.IsAddedAutomatically = true;
par.Name = par_name;
par.DisplayName = param.DisplayName;
par.TypeName = param.Type.FullName;
par.Variable = new VariableDef(param.Value);
par.Description = param.Description;
par.Display = false;
pars.Add(par);
}
this.Behavior.AgentType.ClearPars();
this.Behavior.AgentType.AddPars(pars);
if (Plugin.UpdateMetaStoreHandler != null)
{
Plugin.UpdateMetaStoreHandler(null);
}
}
}
public void SetParameter(ParInfo parameter, Nodes.Node node)
{
_parameter = parameter;
_node = node;
typeComboBox.Width = flowLayoutPanel.Width * 2 / 5;
typeComboBox.Items.Clear();
foreach (Type key in Plugin.TypeHandlers.Keys)
{
typeComboBox.Items.Add(Plugin.GetNativeTypeName(key.Name));
}
typeComboBox.Text = parameter.TypeName;
}
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();
ParInfo par = _pars[e.Index];
string description = !string.IsNullOrEmpty(par.Description) ? par.Description : par.ToString();
this.OnDescriptionChanged(Resources.CategoryPar, description);
}
public override void SetVariable(VariableDef value, object obj)
{
base.SetVariable(value, obj);
string selectionName = "";
if (value != null)
{
ParInfo par = value.Value as ParInfo;
if (par != null)
{
selectionName = par.Name;
}
}
setComboBox(selectionName);
}
private bool ClearValueIfChanged(MethodDef.Param param)
{
bool bSet = true;
if (param.ListParam != null)
{
Type itemType = MethodDef.Param.GetListParamItemType(param);
if (param.Value is VariableDef)
{
VariableDef var = param.Value as VariableDef;
if (var.ValueType != itemType)
{
//type changed, to clear the old one
bSet = false;
param.Value = null;
}
}
else if (param.Value is PropertyDef)
{
PropertyDef var = param.Value as PropertyDef;
if (var.Type != itemType)
{
//type changed, to clear the old one
bSet = false;
param.Value = null;
}
}
else if (param.Value is ParInfo)
{
ParInfo var = param.Value as ParInfo;
if (var.Type != itemType)
{
//type changed, to clear the old one
bSet = false;
param.Value = null;
}
}
}
return(bSet);
}
protected override void GenerateMethod(Node node, StreamWriter stream, string indent)
{
base.GenerateMethod(node, stream, indent);
Assignment assignment = node as Assignment;
Debug.Check(assignment != null);
stream.WriteLine("{0}\t\tvirtual EBTStatus update_impl(Agent* pAgent, EBTStatus childStatus)", indent);
stream.WriteLine("{0}\t\t{{", indent);
stream.WriteLine("{0}\t\t\tBEHAVIAC_UNUSED_VAR(pAgent);", indent);
stream.WriteLine("{0}\t\t\tBEHAVIAC_UNUSED_VAR(childStatus);", indent);
stream.WriteLine("{0}\t\t\tEBTStatus result = BT_SUCCESS;", indent);
if (assignment.Opl != null && assignment.Opr != null)
{
if (assignment.Opl.IsPar)
{
ParInfo par = assignment.Opl.Value as ParInfo;
if (par != null)
{
RightValueCppExporter.GenerateCode(assignment.Opr, stream, indent + "\t\t\t", assignment.Opr.NativeType, "opr", "opr");
uint id = Behaviac.Design.CRC32.CalcCRC(par.Name);
stream.WriteLine("{0}\t\t\tBEHAVIAC_ASSERT(behaviac::MakeVariableId(\"{1}\") == {2}u);", indent, par.Name, id);
stream.WriteLine("{0}\t\t\tpAgent->SetVariable(\"{1}\", opr, {2}u);", indent, par.Name, id);
}
}
else
{
string opl = VariableCppExporter.GenerateCode(assignment.Opl, stream, indent + "\t\t\t", string.Empty, string.Empty, "opl");
RightValueCppExporter.GenerateCode(assignment.Opr, stream, indent + "\t\t\t", assignment.Opr.NativeType, "opr", "opr");
stream.WriteLine("{0}\t\t\t{1} = opr;", indent, opl);
VariableCppExporter.PostGenerateCode(assignment.Opl, stream, indent + "\t\t\t", assignment.Opl.NativeType, "opl", string.Empty);
}
if (assignment.Opr.IsMethod)
{
RightValueCppExporter.PostGenerateCode(assignment.Opr, stream, indent + "\t\t\t", assignment.Opr.NativeType, "opr", string.Empty);
}
}
stream.WriteLine("{0}\t\t\treturn result;", indent);
stream.WriteLine("{0}\t\t}}", indent);
}
private void ExportPars(XmlWriter file, Behavior behavior)
{
if (behavior.LocalVars.Count == 0)
{
return;
}
file.WriteStartElement("pars");
for (int i = 0; i < behavior.LocalVars.Count; ++i)
{
ParInfo par = behavior.LocalVars[i];
ExportPar(file, par, true);
}
file.WriteEndElement();
}
private void ExportPar(BsonSerializer file, ParInfo par, bool bExportValue)
{
file.WriteStartElement("par");
file.WriteString(par.BasicName);
file.WriteString(par.NativeType);
if (bExportValue)
{
file.WriteString(par.DefaultValue);
}
else
{
file.WriteString("");
}
file.WriteEndElement();
}
protected override void GenerateMethod(Node node, StreamWriter stream, string indent)
{
base.GenerateMethod(node, stream, indent);
Assignment assignment = node as Assignment;
Debug.Check(assignment != null);
stream.WriteLine("{0}\t\tprotected override EBTStatus update_impl(behaviac.Agent pAgent, behaviac.EBTStatus childStatus)", indent);
stream.WriteLine("{0}\t\t{{", indent);
stream.WriteLine("{0}\t\t\tEBTStatus result = EBTStatus.BT_SUCCESS;", indent);
if (assignment.Opl != null && assignment.Opr != null)
{
if (assignment.Opl.IsPar)
{
ParInfo par = assignment.Opl.Value as ParInfo;
if (par != null)
{
RightValueCsExporter.GenerateCode(assignment.Opr, stream, indent + "\t\t\t", assignment.Opr.NativeType.Replace("::", "."), "opr", "opr");
uint id = Behaviac.Design.CRC32.CalcCRC(par.Name);
string typename = DataCsExporter.GetGeneratedNativeType(par.NativeType);
stream.WriteLine("{0}\t\t\tDebug.Check(behaviac.Utils.MakeVariableId(\"{1}\") == {2}u);", indent, par.Name, id);
stream.WriteLine("{0}\t\t\tpAgent.SetVariable<{1}>(\"{2}\", opr, {3}u);", indent, typename, par.Name, id);
}
}
else
{
Debug.Check(assignment.Opl.IsProperty);
RightValueCsExporter.GenerateCode(assignment.Opr, stream, indent + "\t\t\t", assignment.Opr.NativeType.Replace("::", "."), "opr", "opr");
//VariableCsExporter.GenerateCode(assignment.Opl, stream, indent + "\t\t\t", string.Empty, string.Empty, "opl", "opr");
VariableCsExporter.PostGenerateCode(assignment.Opl, stream, indent + "\t\t\t", assignment.Opl.NativeType.Replace("::", "."), "opl", string.Empty, null, "", "opr");
}
if (assignment.Opr.IsMethod)
{
RightValueCsExporter.PostGenerateCode(assignment.Opr, stream, indent + "\t\t\t", assignment.Opr.NativeType.Replace("::", "."), "opr", string.Empty);
}
}
stream.WriteLine("{0}\t\t\treturn result;", indent);
stream.WriteLine("{0}\t\t}}", indent);
}
private void ExportPars(BsonSerializer file, Behavior behavior)
{
if (behavior.LocalVars.Count == 0)
{
return;
}
file.WriteStartElement("pars");
for (int i = 0; i < behavior.LocalVars.Count; ++i)
{
ParInfo par = behavior.LocalVars[i];
if (par.Display)
{
ExportPar(file, par, true);
}
}
file.WriteEndElement();
}
private void ExportPar(XmlWriter file, ParInfo par, bool bExportValue)
{
file.WriteStartElement("par");
file.WriteAttributeString("name", par.BasicName);
file.WriteAttributeString("type", par.NativeType);
if (bExportValue)
{
file.WriteAttributeString("value", par.DefaultValue);
}
//if (!string.IsNullOrEmpty(par.EventParam))
//{
// file.WriteAttributeString("eventParam", par.EventParam);
//}
//file.WriteAttributeString("member", "false");
//if (par.AgentType != null)
// file.WriteAttributeString("agent", par.AgentType.AgentTypeName);
file.WriteEndElement();
}
private void ExportPars(XmlWriter file, Behavior behavior)
{
if (behavior.LocalVars.Count == 0)
{
return;
}
file.WriteStartElement("pars");
for (int i = 0; i < behavior.LocalVars.Count; ++i)
{
ParInfo par = behavior.LocalVars[i];
//for node, only display pars are exported
//if (bIsBehaviorRoot || par.Display)
{
ExportPar(file, par, true);
}
}
file.WriteEndElement();
}
protected override void CloneProperties(Node newnode)
{
base.CloneProperties(newnode);
ReferencedBehavior refbehav = (ReferencedBehavior)newnode;
refbehav.Label = Label;
if (_referencedBehavior != null)
{
refbehav._referencedBehavior = _referencedBehavior;
refbehav._genericChildren = refbehav._referencedBehavior.GenericChildren;
refbehav._children.SetConnector(refbehav._genericChildren);
}
// Clone the Pars.
Nodes.Node clone = (Nodes.Node)refbehav;
clone.Pars.Clear();
foreach (ParInfo par in this.Pars)
{
ParInfo clonePar = par.Clone();
clone.Pars.Add(clonePar);
}
}
public void CollectTaskPars(ref List <ParInfo> pars)
{
if (this._task != null)
{
for (int i = 0; i < this._task.Params.Count; ++i)
{
var param = this._task.Params[i];
string par_name = string.Format("{0}{1}", LOCAL_TASK_PARAM_PRE, i);
ParInfo par = new ParInfo(this, this.Behavior != null ? this.Behavior.AgentType : null);
par.IsAddedAutomatically = true;
par.Name = par_name;
par.DisplayName = param.DisplayName;
par.TypeName = param.Type.FullName;
par.Variable = new VariableDef(param.Value);
par.Description = param.Description;
par.Display = false;
pars.Add(par);
}
}
}
private void setEditor(DesignerPropertyEditor editor, DesignerPropertyInfo prop, object obj, bool isConst, bool isPar, bool isFunction)
{
if (editor != null)
{
editor.SetRootNode(this._root);
object propertyMember = prop.Property.GetValue(obj, null);
VariableDef var = propertyMember as VariableDef;
RightValueDef varRV = propertyMember as RightValueDef;
DesignerPropertyEnum enumAtt = prop.Attribute as DesignerPropertyEnum;
DesignerRightValueEnum enumAttRV = prop.Attribute as DesignerRightValueEnum;
if (isConst)
{
Type dependVarType = getDependedPropertyType(prop, obj);
if (dependVarType == null)
{
dependVarType = getPropertyType(prop, obj, VariableDef.kConst);
}
Debug.Check(dependVarType != null);
object defaultValue = Plugin.DefaultValue(dependVarType);
Debug.Check(defaultValue != null);
if (var == null)
{
var = new VariableDef(defaultValue);
}
if (var.Value == null || var.Value.GetType() != defaultValue.GetType())
{
var.Value = defaultValue;
}
var.ValueClass = VariableDef.kConst;
if (enumAttRV == null)
{
prop.Property.SetValue(obj, var, null);
editor.SetVariable(var, obj);
if (enumAtt != null)
{
editor.SetRange(enumAtt.MinValue, enumAtt.MaxValue);
}
}
else
{
if (varRV == null || varRV.Var == null || varRV.ValueClass != var.ValueClass || varRV.ValueType != var.GetValueType())
{
varRV = new RightValueDef(var);
}
prop.Property.SetValue(obj, varRV, null);
editor.SetVariable(varRV.Var, obj);
}
}
else if (isPar)
{
Type dependVarType = getDependedPropertyType(prop, obj);
//if (dependVarType == null)
// dependVarType = getPropertyType(prop, obj, VariableDef.kPar);
if (dependVarType == null)
{
dependVarType = prop.Attribute.FilterType;
}
object defaultValue = Plugin.DefaultValue((var != null) ? var.GetValueType() : dependVarType);
if (varRV == null || varRV.ValueClass != VariableDef.kPar)
{
if (var == null)
{
ParInfo par = new ParInfo(obj as Nodes.Node);
par.Variable = new VariableDef(defaultValue);
var = new VariableDef(par);
}
if (var.Value == null)
{
ParInfo par = new ParInfo(obj as Nodes.Node);
par.Variable = new VariableDef(defaultValue);
var.Value = par;
}
var.ValueClass = VariableDef.kPar;
}
editor.FilterType = dependVarType;
if (enumAttRV == null)
{
prop.Property.SetValue(obj, var, null);
editor.SetVariable(var, obj);
}
else
{
if (var != null &&
(varRV == null || varRV.Var == null ||
(varRV.ValueClass != var.ValueClass || (var.GetValueType() != null && varRV.ValueType != var.GetValueType())
)
)
)
{
varRV = new RightValueDef(var);
}
prop.Property.SetValue(obj, varRV, null);
editor.SetVariable(varRV.Var, obj);
}
}
else
{
// VariableDef
if (enumAttRV == null)
{
if (var == null)
{
var = new VariableDef(null);
prop.Property.SetValue(obj, var, null);
}
if (var != null && typeComboBox.SelectedIndex > -1)
{
var.ValueClass = _currentNames[typeComboBox.SelectedIndex];
}
}
// RightValueDef
else
{
if (varRV == null)
{
varRV = new RightValueDef(var);
prop.Property.SetValue(obj, varRV, null);
}
if (typeComboBox.SelectedIndex > -1)
{
varRV.ValueClass = _currentNames[typeComboBox.SelectedIndex];
}
}
editor.ValueType = prop.Attribute.ValueType;
editor.SetProperty(prop, obj);
}
editor.ValueWasAssigned();
}
}
static private void WriteParString(BsonSerializer file, string valueName, ParInfo par) {
string parStr = par.DefaultValue;
//file.WriteAttribute(valueName, parStr);
file.WriteString(parStr);
}
private void parameter_ParameterSet(Nodes.Node node, ParInfo par)
{
SetPar(par, node);
}
private void setEditor(DesignerPropertyEditor editor, string valueType)
{
if (editor == null)
{
return;
}
if (valueType == VariableDef.kConst)
{
if (_param.Value != null && (_param.Value is VariableDef || _param.Value is PropertyDef || _param.Value is ParInfo))
{
if (!(_param.IsFromStruct))
{
_param.Value = Plugin.DefaultValue(_param.Type);
}
else
{
if (_param.Value is VariableDef)
{
VariableDef v = _param.Value as VariableDef;
_param.Value = Plugin.DefaultValue(v.GetValueType());
}
else if (_param.Value is ParInfo)
{
ParInfo v = _param.Value as ParInfo;
_param.Value = Plugin.DefaultValue(v.Variable.GetValueType());
}
}
}
}
else
{
DesignerPropertyEnumEditor propertyEnumEditor = editor as DesignerPropertyEnumEditor;
if (_param.Value is VariableDef)
{
VariableDef v = _param.Value as VariableDef;
if (v.ValueClass != valueType)
{
Type t1 = v.GetValueType() != null?v.GetValueType() : _param.Type;
object dv = Plugin.DefaultValue(t1);
_param.Value = new VariableDef(dv, valueType);
}
propertyEnumEditor.FilterType = (v.GetValueType() != null ? v.GetValueType() : _param.Type);
}
else if (_param.Value is ParInfo)
{
ParInfo v = _param.Value as ParInfo;
if (v.Variable.ValueClass != valueType)
{
object dv = Plugin.DefaultValue(v.Variable.GetValueType());
_param.Value = new VariableDef(dv, valueType);
}
propertyEnumEditor.FilterType = v.Variable.GetValueType();
}
else
{
_param.Value = new VariableDef(_param.Value, valueType);
propertyEnumEditor.FilterType = _param.Type;
}
}
editor.SetParameter(_param, _object, false);
editor.ValueWasAssigned();
editor.ValueWasChanged += editor_ValueWasChanged;
}
private static void WriteParValue(BsonSerializer file, string valueName, ParInfo par)
{
string parStr = par.DefaultValue;
object v = null;
Type valueType = par.Type;
if (valueType != null && Plugin.InvokeTypeParser(valueType, parStr, (object value) => v = value, null))
{
//file.WriteAttribute(valueName, v);
file.Write(v);
}
}
protected override void GenerateMethod(Node node, StreamWriter stream, string indent)
{
base.GenerateMethod(node, stream, indent);
Compute compute = node as Compute;
Debug.Check(compute != null);
stream.WriteLine("{0}\t\tprotected override EBTStatus update_impl(behaviac.Agent pAgent, behaviac.EBTStatus childStatus)", indent);
stream.WriteLine("{0}\t\t{{", indent);
stream.WriteLine("{0}\t\t\tEBTStatus result = EBTStatus.BT_SUCCESS;", indent);
if (compute.Opl != null && compute.Opr1 != null && compute.Opr2 != null)
{
RightValueCsExporter.GenerateCode(compute.Opr1, stream, indent + "\t\t\t", compute.Opr1.NativeType, "opr1", "opr1");
RightValueCsExporter.GenerateCode(compute.Opr2, stream, indent + "\t\t\t", compute.Opr2.NativeType, "opr2", "opr2");
string oprStr = string.Empty;
switch (compute.Operator)
{
case ComputeOperator.Add:
oprStr = "opr1 + opr2";
break;
case ComputeOperator.Sub:
oprStr = "opr1 - opr2";
break;
case ComputeOperator.Mul:
oprStr = "opr1 * opr2";
break;
case ComputeOperator.Div:
oprStr = "opr1 / opr2";
break;
default:
Debug.Check(false, "The operator is wrong!");
break;
}
string basicType = DataCsExporter.GetGeneratedNativeType(compute.Opl.NativeType);
stream.WriteLine("{0}\t\t\t{1} opr = ({1})({2});", indent, basicType, oprStr);
if (compute.Opl.IsPar)
{
ParInfo par = compute.Opl.Value as ParInfo;
if (par != null)
{
uint id = Behaviac.Design.CRC32.CalcCRC(par.Name);
stream.WriteLine("{0}\t\t\tDebug.Check(behaviac.Utils.MakeVariableId(\"{1}\") == {2}u);", indent, par.Name, id);
stream.WriteLine("{0}\t\t\tpAgent.SetVariable(\"{1}\", opr, {2}u);", indent, par.Name, id);
}
}
else
{
//VariableCsExporter.GenerateCode(compute.Opl, stream, indent + "\t\t\t", string.Empty, string.Empty, "opl", "opr");
VariableCsExporter.PostGenerateCode(compute.Opl, stream, indent + "\t\t\t", compute.Opl.NativeType, "opl", string.Empty, null, "", "opr");
}
if (compute.Opr1.IsMethod)
{
RightValueCsExporter.PostGenerateCode(compute.Opr1, stream, indent + "\t\t\t", compute.Opr1.NativeType, "opr1", string.Empty);
}
if (compute.Opr2.IsMethod)
{
RightValueCsExporter.PostGenerateCode(compute.Opr2, stream, indent + "\t\t\t", compute.Opr2.NativeType, "opr2", string.Empty);
}
}
stream.WriteLine("{0}\t\t\treturn result;", indent);
stream.WriteLine("{0}\t\t}}", indent);
}
private void LoadParameters(XmlNode xmlNode, Nodes.Node node, List<ParInfo> pars)
{
pars.Clear();
if (xmlNode != null)
{
foreach (XmlNode child in xmlNode.ChildNodes)
{
try
{
if (child.Attributes["Name"] != null && child.Attributes["Type"] != null)
{
ParInfo par = new ParInfo(node);
par.Name = child.Attributes["Name"].Value;
if (string.IsNullOrEmpty(par.Name))
continue;
par.TypeName = Plugin.GetFullTypeName(child.Attributes["Type"].Value);
if (string.IsNullOrEmpty(par.TypeName))
continue;
if (child.Attributes["EventParam"] != null)
par.EventParam = child.Attributes["EventParam"].Value;
if (child.Attributes["Desc"] != null)
par.Description = child.Attributes["Desc"].Value;
Type valueType = Plugin.GetType(par.TypeName);
string defaultValue = child.Attributes["DefaultValue"].Value;
par.Variable = new VariableDef(null);
Plugin.InvokeTypeParser(valueType, defaultValue, (object value) => par.Variable.Value = value, node);
pars.Add(par);
}
}
catch(Exception e)
{
MessageBox.Show(e.Message, Resources.LoadError, MessageBoxButtons.OK);
}
}
}
}
private void ExportPar(BsonSerializer file, ParInfo par, bool bExportValue) {
file.WriteStartElement("par");
file.WriteString(par.BasicName);
file.WriteString(par.NativeType);
if (bExportValue) {
file.WriteString(par.DefaultValue);
} else {
file.WriteString("");
}
file.WriteEndElement();
}
static private void WritePar(BsonSerializer file, string valueName, ParInfo par) {
//WriteParValue(file, valueName, par);
WriteParString(file, valueName, par);
}
static private void WritePar(BsonSerializer file, string valueName, ParInfo par)
{
//WriteParValue(file, valueName, par);
WriteParString(file, valueName, par);
}
private void setEditor(DesignerPropertyEditor editor, string valueType)
{
if (editor == null)
return;
if (valueType == VariableDef.kConst)
{
if (_param.Value != null && (_param.Value is VariableDef || _param.Value is PropertyDef || _param.Value is ParInfo))
{
if (!(_param.IsFromStruct))
{
_param.Value = Plugin.DefaultValue(_param.Type);
}
else
{
if (_param.Value is VariableDef)
{
VariableDef v = _param.Value as VariableDef;
_param.Value = Plugin.DefaultValue(v.GetValueType());
}
else if (_param.Value is ParInfo)
{
ParInfo v = _param.Value as ParInfo;
_param.Value = Plugin.DefaultValue(v.Variable.GetValueType());
}
}
}
}
else if (valueType == VariableDef.kPar)
{
if (_param.IsFromStruct)
{
if (!(_param.Value is ParInfo) && !(_param.Value is VariableDef))
{
ParInfo par = new ParInfo(this._root);
par.Name = _param.Attribute.DisplayName;
par.TypeName = _param.Type.FullName;
par.Variable = new VariableDef(_param.Value, VariableDef.kPar);
_param.Value = par;
}
else
{
if (_param.Value is VariableDef)
{
VariableDef v = _param.Value as VariableDef;
if (v.ValueClass != valueType)
{
Type t1 = v.GetValueType() != null ? v.GetValueType() : _param.Type;
object dv = Plugin.DefaultValue(t1);
_param.Value = new VariableDef(dv, valueType);
}
}
}
}
}
else
{
if (!_param.IsFromStruct)
{
if (valueType == VariableDef.kSelf)
{
DesignerPropertyEnumEditor propertyEnumEditor = editor as DesignerPropertyEnumEditor;
propertyEnumEditor.GlobalType = null;
propertyEnumEditor.FilterType = _param.Type;
}
else
{
DesignerPropertyEnumEditor propertyEnumEditor = editor as DesignerPropertyEnumEditor;
propertyEnumEditor.GlobalType = valueType;
propertyEnumEditor.FilterType = _param.Type;
}
}
else
{
DesignerPropertyEnumEditor propertyEnumEditor = editor as DesignerPropertyEnumEditor;
if (valueType == VariableDef.kSelf)
{
propertyEnumEditor.GlobalType = null;
}
else
{
propertyEnumEditor.GlobalType = valueType;
}
if (_param.Value is VariableDef)
{
VariableDef v = _param.Value as VariableDef;
if (v.ValueClass != valueType)
{
Type t1 = v.GetValueType() != null ? v.GetValueType() : _param.Type;
object dv = Plugin.DefaultValue(t1);
_param.Value = new VariableDef(dv, valueType);
}
propertyEnumEditor.FilterType = (v.GetValueType() != null ? v.GetValueType() : _param.Type);
}
else if (_param.Value is ParInfo)
{
ParInfo v = _param.Value as ParInfo;
if (v.Variable.ValueClass != valueType)
{
object dv = Plugin.DefaultValue(v.Variable.GetValueType());
_param.Value = new VariableDef(dv, valueType);
}
propertyEnumEditor.FilterType = v.Variable.GetValueType();
}
else
{
_param.Value = new VariableDef(_param.Value, valueType);
propertyEnumEditor.FilterType = _param.Type;
}
}
}
editor.SetParameter(_param, _object);
editor.ValueWasAssigned();
editor.ValueWasChanged += editor_ValueWasChanged;
}
private void LoadParameters(List<Nodes.Node.ErrorCheck> result, XmlNode xmlNode, Nodes.Node node, List<ParInfo> pars)
{
if (pars != null) {
pars.Clear();
}
if (xmlNode != null) {
foreach(XmlNode child in xmlNode.ChildNodes) {
try {
if (child.Attributes["Name"] != null && child.Attributes["Type"] != null) {
ParInfo par = new ParInfo(node, node.Behavior.AgentType);
par.Name = child.Attributes["Name"].Value;
if (string.IsNullOrEmpty(par.Name))
{ continue; }
par.TypeName = Plugin.GetFullTypeName(child.Attributes["Type"].Value);
if (string.IsNullOrEmpty(par.TypeName))
{ continue; }
if (par.TypeName == "Behaviac.Design.llong")
par.NativeType = "llong";
else if (par.TypeName == "Behaviac.Design.ullong")
par.NativeType = "ullong";
if (child.Attributes["EventParam"] != null)
{ par.EventParam = child.Attributes["EventParam"].Value; }
if (child.Attributes["DisplayName"] != null)
{ par.DisplayName = child.Attributes["DisplayName"].Value; }
if (child.Attributes["Desc"] != null)
{ par.BasicDescription = child.Attributes["Desc"].Value; }
Type valueType = Plugin.GetType(par.TypeName);
string defaultValue = child.Attributes["DefaultValue"].Value;
par.Display = child.Attributes["Display"] != null ? child.Attributes["Display"].Value.ToLower() == "true" : true;
par.Variable = new VariableDef(null);
Plugin.InvokeTypeParser(result, valueType, defaultValue, (object value) => par.Variable.Value = value, node);
if (pars != null) {
pars.Add(par);
}
}
} catch (Exception e) {
MessageBox.Show(e.Message, Resources.LoadError, MessageBoxButtons.OK);
}
}
}
}
private void setEditor(DesignerPropertyEditor editor, DesignerPropertyInfo prop, object obj, bool isConst, bool isPar, bool isFunction)
{
if (editor != null)
{
editor.SetRootNode(this._root);
object propertyMember = prop.Property.GetValue(obj, null);
VariableDef var = propertyMember as VariableDef;
RightValueDef varRV = propertyMember as RightValueDef;
DesignerPropertyEnum enumAtt = prop.Attribute as DesignerPropertyEnum;
DesignerRightValueEnum enumAttRV = prop.Attribute as DesignerRightValueEnum;
if (isConst)
{
Type dependVarType = getDependedPropertyType(prop, obj);
if (dependVarType == null)
{
dependVarType = getPropertyType(prop, obj, VariableDef.kConst);
}
Debug.Check(dependVarType != null);
object defaultValue = Plugin.DefaultValue(dependVarType);
Debug.Check(defaultValue != null);
if (var == null)
{
var = new VariableDef(defaultValue);
}
if (var.Value == null || var.Value.GetType() != defaultValue.GetType())
var.Value = defaultValue;
var.ValueClass = VariableDef.kConst;
if (enumAttRV == null)
{
prop.Property.SetValue(obj, var, null);
editor.SetVariable(var, obj);
if (enumAtt != null)
editor.SetRange(enumAtt.MinValue, enumAtt.MaxValue);
}
else
{
if (varRV == null || varRV.Var == null || varRV.ValueClass != var.ValueClass || varRV.ValueType != var.GetValueType())
{
varRV = new RightValueDef(var);
}
prop.Property.SetValue(obj, varRV, null);
editor.SetVariable(varRV.Var, obj);
}
}
else if (isPar)
{
Type dependVarType = getDependedPropertyType(prop, obj);
//if (dependVarType == null)
// dependVarType = getPropertyType(prop, obj, VariableDef.kPar);
if (dependVarType == null)
dependVarType = prop.Attribute.FilterType;
object defaultValue = Plugin.DefaultValue((var != null) ? var.GetValueType() : dependVarType);
if (varRV == null || varRV.ValueClass != VariableDef.kPar)
{
if (var == null)
{
ParInfo par = new ParInfo(obj as Nodes.Node);
par.Variable = new VariableDef(defaultValue);
var = new VariableDef(par);
}
if (var.Value == null)
{
ParInfo par = new ParInfo(obj as Nodes.Node);
par.Variable = new VariableDef(defaultValue);
var.Value = par;
}
var.ValueClass = VariableDef.kPar;
}
editor.FilterType = dependVarType;
if (enumAttRV == null)
{
prop.Property.SetValue(obj, var, null);
editor.SetVariable(var, obj);
}
else
{
if (var != null &&
(varRV == null || varRV.Var == null ||
(varRV.ValueClass != var.ValueClass || (var.GetValueType() != null && varRV.ValueType != var.GetValueType())
)
)
)
{
varRV = new RightValueDef(var);
}
prop.Property.SetValue(obj, varRV, null);
editor.SetVariable(varRV.Var, obj);
}
}
else
{
// VariableDef
if (enumAttRV == null)
{
if (var == null)
{
var = new VariableDef(null);
prop.Property.SetValue(obj, var, null);
}
if (var != null && typeComboBox.SelectedIndex > -1)
var.ValueClass = _currentNames[typeComboBox.SelectedIndex];
}
// RightValueDef
else
{
if (varRV == null)
{
varRV = new RightValueDef(var);
prop.Property.SetValue(obj, varRV, null);
}
if (typeComboBox.SelectedIndex > -1)
varRV.ValueClass = _currentNames[typeComboBox.SelectedIndex];
}
editor.ValueType = prop.Attribute.ValueType;
editor.SetProperty(prop, obj);
}
editor.ValueWasAssigned();
}
}
private void LoadParameters(List <Nodes.Node.ErrorCheck> result, XmlNode xmlNode, Nodes.Node node, List <ParInfo> pars)
{
if (pars != null)
{
pars.Clear();
}
if (xmlNode != null)
{
foreach (XmlNode child in xmlNode.ChildNodes)
{
try {
if (child.Attributes["Name"] != null && child.Attributes["Type"] != null)
{
ParInfo par = new ParInfo(node, node.Behavior.AgentType);
par.Name = child.Attributes["Name"].Value;
if (string.IsNullOrEmpty(par.Name))
{
continue;
}
par.TypeName = Plugin.GetFullTypeName(child.Attributes["Type"].Value);
if (string.IsNullOrEmpty(par.TypeName))
{
continue;
}
if (par.TypeName == "Behaviac.Design.llong")
{
par.NativeType = "llong";
}
else if (par.TypeName == "Behaviac.Design.ullong")
{
par.NativeType = "ullong";
}
if (child.Attributes["EventParam"] != null)
{
par.EventParam = child.Attributes["EventParam"].Value;
}
if (child.Attributes["DisplayName"] != null)
{
par.DisplayName = child.Attributes["DisplayName"].Value;
}
if (child.Attributes["Desc"] != null)
{
par.BasicDescription = child.Attributes["Desc"].Value;
}
Type valueType = Plugin.GetType(par.TypeName);
string defaultValue = child.Attributes["DefaultValue"].Value;
par.Display = child.Attributes["Display"] != null ? child.Attributes["Display"].Value.ToLower() == "true" : true;
par.Variable = new VariableDef(null);
Plugin.InvokeTypeParser(result, valueType, defaultValue, (object value) => par.Variable.Value = value, node);
if (pars != null)
{
pars.Add(par);
}
}
} catch (Exception e) {
MessageBox.Show(e.Message, Resources.LoadError, MessageBoxButtons.OK);
}
}
}
}
public virtual void SetPar(ParInfo par, object obj)
{
_par = par;
_object = obj;
SetVariable(par.Variable, obj);
}
private void ExportPar(XmlWriter file, ParInfo par, bool bExportValue) {
file.WriteStartElement("par");
file.WriteAttributeString("name", par.BasicName);
file.WriteAttributeString("type", par.NativeType);
if (bExportValue) {
file.WriteAttributeString("value", par.DefaultValue);
}
//if (!string.IsNullOrEmpty(par.EventParam))
//{
// file.WriteAttributeString("eventParam", par.EventParam);
//}
//file.WriteAttributeString("member", "false");
//if (par.AgentType != null)
// file.WriteAttributeString("agent", par.AgentType.AgentTypeName);
file.WriteEndElement();
}
private void ExportPar(XmlWriter file, ParInfo par, bool bExportValue)
{
file.WriteStartElement("par");
file.WriteAttributeString("name", par.BasicName);
file.WriteAttributeString("type", par.NativeType);
if (bExportValue)
{
file.WriteAttributeString("value", par.DefaultValue);
}
file.WriteEndElement();
}
public override void SetPar(ParInfo par, object obj)
{
base.SetPar(par, obj);
}
private void setEditor(DesignerPropertyEditor editor, string valueType)
{
if (editor == null)
{
return;
}
Type filterTypeCandidate = null;
if (valueType == VariableDef.kConst)
{
if (_param.Value != null && (_param.Value is VariableDef || _param.Value is PropertyDef || _param.Value is ParInfo))
{
if (!(_param.IsFromStruct))
{
_param.Value = Plugin.DefaultValue(_param.Type);
}
else
{
if (_param.Value is VariableDef)
{
VariableDef v = _param.Value as VariableDef;
_param.Value = Plugin.DefaultValue(v.ValueType);
}
else if (_param.Value is ParInfo)
{
ParInfo v = _param.Value as ParInfo;
_param.Value = Plugin.DefaultValue(v.Variable.ValueType);
}
}
}
}
else
{
if (_param.Value is VariableDef)
{
VariableDef v = _param.Value as VariableDef;
filterTypeCandidate = v.ValueType;
if (v.ValueClass != valueType)
{
Type t1 = v.ValueType != null ? v.ValueType : _param.Type;
object dv = Plugin.DefaultValue(t1);
_param.Value = new VariableDef(dv, valueType);
}
}
else if (_param.Value is ParInfo)
{
ParInfo v = _param.Value as ParInfo;
filterTypeCandidate = v.Variable.ValueType;
if (v.Variable.ValueClass != valueType)
{
object dv = Plugin.DefaultValue(v.Variable.ValueType);
_param.Value = new VariableDef(dv, valueType);
}
}
else
{
_param.Value = new VariableDef(_param.Value, valueType);
filterTypeCandidate = _param.Type;
}
}
this.SetFilterType(editor, filterTypeCandidate);
SetupCastSettings(_object);
editor.SetParameter(_param, _object, false);
editor.ValueWasAssigned();
editor.ValueWasChanged += editor_ValueWasChanged;
}
public override void SetPar(ParInfo par, object obj) {
base.SetPar(par, obj);
}
