async System.Threading.Tasks.Task RemoveInParam(MethodInvokeParameterControl paramNode)
{
// 删除子图中的连线
await RemoveGraphInParam(paramNode);
RemoveChildNode(paramNode);
}
public async System.Threading.Tasks.Task RemoveGraphInParam(MethodInvokeParameterControl ctrl)
{
if (mLinkedNodesContainer == null)
{
await InitializeLinkedNodesContainer();
}
var param = CSParam as MethodInvoke_DelegateControlConstructionParams;
for (int i = param.InParamIndexes.Count - 1; i >= 0; i--)
{
if (param.InParamIndexes[i] == ctrl.Id)
{
var paramIdx = i + param.CustomParamStartIndexInDelegateMethodInfo;
var func = param.DelegateMethodInfo.InParams[paramIdx];
param.DelegateMethodInfo.InParams.RemoveAt(paramIdx);
//for (int nodeIdx = 0; nodeIdx < mLinkedNodesContainer.CtrlNodeList.Count; nodeIdx++)
//{
// var node = mLinkedNodesContainer.CtrlNodeList[nodeIdx] as MethodCustom;
// if (node == null)
// continue;
// await node.OnRemovedInParam(paramIdx, func);
//}
param.InParamIndexes.RemoveAt(i);
param.DelegateMethodInfo._OnRemovedInParam(paramIdx, func);
}
}
}
private void Button_AddPin_Click(object sender, RoutedEventArgs e)
{
var param = CSParam as MethodInvoke_DelegateControlConstructionParams;
if (param.DelegateMethodInfo == null)
{
InitDelegateMethodInfo();
}
var paramInfo = new MethodParamInfoAssist();
paramInfo.FieldDirection = System.CodeDom.FieldDirection.In;
paramInfo.IsParamsArray = false;
paramInfo.ParameterType = typeof(object);
paramInfo.ParamName = "";
param.InputParmas.Add(paramInfo);
var inputParam = new MethodInvokeParameterControl.MethodInvokeParameterConstructionParams()
{
CSType = param.CSType,
HostNodesContainer = param.HostNodesContainer,
ConstructParam = "",
ConstructType = MethodInvokeNode.enParamConstructType.Delegate,
ParamInfo = paramInfo,
};
var child = new MethodInvokeParameterControl(inputParam);
child.RemoveButton.Click += (object removeBtnSender, RoutedEventArgs removeBtnE) =>
{
var noUse = RemoveInParam(child);
};
AddChildNode(child, StackPanel_InputPins);
}
protected void SetParameters(List <MethodParamInfoAssist> paramInfos)
{
if (paramInfos == null)
{
return;
}
mParamsPanel?.Children.Clear();
foreach (var paramInfo in paramInfos)
{
CodeGenerateSystem.Base.BaseNodeControl pc = null;
if (paramInfo.ParameterType.IsSubclassOf(typeof(System.Delegate)))
{
var csParam = new MethodInvoke_DelegateControl.MethodInvoke_DelegateControlConstructionParams()
{
CSType = mCSParam.CSType,
HostNodesContainer = mCSParam.HostNodesContainer,
ConstructParam = this.NodeName,
ConstructType = MethodInvokeNode.enParamConstructType.MethodOverride,
ParamInfo = paramInfo,
};
pc = new MethodInvoke_DelegateControl(csParam);
}
else
{
if (paramInfo.IsParamsArray)
{
var csParam = new ParamParameterControl.ParamParameterConstructionParams()
{
CSType = mCSParam.CSType,
HostNodesContainer = mCSParam.HostNodesContainer,
ConstructParam = "",
ConstructType = MethodInvokeNode.enParamConstructType.MethodOverride,
ParamInfo = paramInfo,
};
pc = new ParamParameterControl(csParam);
}
else
{
var csParam = new MethodInvokeParameterControl.MethodInvokeParameterConstructionParams()
{
CSType = mCSParam.CSType,
HostNodesContainer = mCSParam.HostNodesContainer,
ConstructParam = "",
ConstructType = MethodInvokeNode.enParamConstructType.MethodOverride,
ParamInfo = paramInfo,
};
pc = new MethodInvokeParameterControl(csParam);
}
}
//pc.SetToolTip(EngineNS.Rtti.AttributeHelper.GetCustomAttributePropertyValue(paramInfo, typeof(DescriptionAttribute).FullName, "Description", false));
AddChildNode(pc, mParamsPanel);
}
}
protected void SetParameters(string[] paramInfos, EngineNS.ECSType csType)
{
foreach (var info in paramInfos)
{
var tempSplits = info.Split(':');
if (tempSplits.Length > 2)
{
switch (tempSplits[2])
{
case "Ref":
case "Out":
tempSplits[1] += "&";
break;
}
}
CodeGenerateSystem.Base.BaseNodeControl pc = null;
var type = EngineNS.Rtti.RttiHelper.GetTypeFromSaveString(tempSplits[1]);
if (type != null && type.IsSubclassOf(typeof(System.Delegate)))
{
var csParam = new MethodInvoke_DelegateControl.MethodInvoke_DelegateControlConstructionParams()
{
CSType = csType,
HostNodesContainer = this.HostNodesContainer,
ConstructParam = info + ":" + this.NodeName,
ConstructType = MethodInvokeNode.enParamConstructType.MethodOverride,
};
pc = new MethodInvoke_DelegateControl(csParam);
}
else
{
var csParam = new MethodInvokeParameterControl.MethodInvokeParameterConstructionParams()
{
CSType = csType,
HostNodesContainer = this.HostNodesContainer,
ConstructParam = info,
ConstructType = MethodInvokeNode.enParamConstructType.MethodOverride,
};
pc = new MethodInvokeParameterControl(csParam);
}
AddChildNode(pc, mParamsPanel);
}
}
void OnUpdateChildParamType(MethodInvokeParameterControl ctrl, CodeDomNode.VariableType newType)
{
// 类型改变，重新创建TemplateClass;
var param = CSParam as ReturnCustomConstructParam;
if (param.ShowPropertyType == ReturnCustomConstructParam.enShowPropertyType.ReturnValue)
{
var cpInfos = new List <CodeGenerateSystem.Base.CustomPropertyInfo>(param.MethodInfo.OutParams.Count);
foreach (var methodParam in param.MethodInfo.OutParams)
{
var paramType = methodParam.ParamType.GetActualType();
if (Program.IsTypeValidInPropertyGridShow(paramType))
{
var infoAssist = new MethodParamInfoAssist()
{
FieldDirection = System.CodeDom.FieldDirection.Out,
IsParamsArray = false,
ParameterType = paramType,
ParamName = methodParam.ParamName,
};
var cpInfo = Program.GetFromParamInfo(infoAssist);
cpInfos.Add(cpInfo);
}
}
var tempClass = mTemplateClassInstance;
if (tempClass != null)
{
var oldTempClassType = tempClass.GetType();
CreateTemplateClass(cpInfos);
foreach (var pro in mTemplateClassInstance.GetType().GetProperties())
{
var oldPro = oldTempClassType.GetProperty(pro.Name);
if (oldPro == null || oldPro.PropertyType != pro.PropertyType)
{
continue;
}
pro.SetValue(mTemplateClassInstance, oldPro.GetValue(tempClass));
}
}
}
}
//void ReturnCustom_AddParam(CustomMethodInfo.FunctionParam funcParam)
public async Task OnAddedOutParam(CodeDomNode.CustomMethodInfo.FunctionParam funcParam)
{
await EngineNS.Thread.AsyncDummyClass.DummyFunc();
var csParam = CSParam as ReturnCustomConstructParam;
MethodParamInfoAssist retValue;
if (funcParam.ParamType.Type.IsByRef)
{
var typefullname = funcParam.ParamType.Type.FullName.Substring(0, funcParam.ParamType.Type.FullName.Length - 1);
var type = funcParam.ParamType.Type.Assembly.GetType(typefullname);
//funcParam.ParamType = new VariableType(type, funcParam.ParamType.CSType);
retValue = new MethodParamInfoAssist();
retValue.FieldDirection = System.CodeDom.FieldDirection.Out;
retValue.IsParamsArray = false;
retValue.ParameterType = type;
retValue.ParamName = funcParam.ParamName;
BindingOperations.SetBinding(this, CodeDomNode.CustomMethodInfo.FunctionParam.ParamNameProperty, new Binding("ParamName")
{
Source = retValue, Mode = BindingMode.TwoWay
});
}
else
{
retValue = funcParam.CreateParamInfoAssist(System.CodeDom.FieldDirection.Out);
}
var pm = new MethodInvokeParameterControl.MethodInvokeParameterConstructionParams()
{
CSType = CSParam.CSType,
HostNodesContainer = CSParam.HostNodesContainer,
ConstructParam = "",
ConstructType = MethodInvokeNode.enParamConstructType.ReturnCustom,
ParamInfo = retValue,
};
var pc = new MethodInvokeParameterControl(pm);
funcParam.OnParamTypeChanged -= pc.UpdateParamType;
funcParam.OnParamTypeChanged += pc.UpdateParamType;
pc.OnUpdateParamTypeAction = OnUpdateChildParamType;
AddChildNode(pc, mParamsPanel);
}
public async Task OnInsertOutParam(int index, CodeDomNode.CustomMethodInfo.FunctionParam funcParam)
{
await EngineNS.Thread.AsyncDummyClass.DummyFunc();
var csParam = CSParam as ReturnCustomConstructParam;
var pm = new MethodInvokeParameterControl.MethodInvokeParameterConstructionParams()
{
CSType = CSParam.CSType,
HostNodesContainer = CSParam.HostNodesContainer,
ConstructParam = "",
ConstructType = MethodInvokeNode.enParamConstructType.ReturnCustom,
ParamInfo = funcParam.CreateParamInfoAssist(System.CodeDom.FieldDirection.Out),
};
var pc = new MethodInvokeParameterControl(pm);
funcParam.OnParamTypeChanged -= pc.UpdateParamType;
funcParam.OnParamTypeChanged += pc.UpdateParamType;
pc.OnUpdateParamTypeAction = OnUpdateChildParamType;
InsertChildNode(index, pc, mParamsPanel);
}
public async System.Threading.Tasks.Task AddGraphInParam(MethodInvokeParameterControl ctrl, CodeGenerateSystem.Base.LinkInfo info)
{
if (HostNodesContainer.IsLoading)
{
return;
}
if (mLinkedNodesContainer == null)
{
await InitializeLinkedNodesContainer();
}
var param = CSParam as MethodInvoke_DelegateControlConstructionParams;
var func = new CustomMethodInfo.FunctionParam();
func.HostMethodInfo = param.DelegateMethodInfo;
func.ParamName = info.m_linkFromObjectInfo.HostNodeControl.GCode_GetValueName(info.m_linkFromObjectInfo, null);
func.ParamType = new VariableType(info.m_linkFromObjectInfo.HostNodeControl.GCode_GetType(info.m_linkFromObjectInfo, null), param.CSType);
int insertIndex = -1;
for (int i = 0; i < mChildNodes.Count; i++)
{
if (mChildNodes[i] == ctrl)
{
insertIndex++;
if (insertIndex >= param.InParamIndexes.Count)
{
insertIndex = -1;
param.DelegateMethodInfo.InParams.Add(func);
param.InParamIndexes.Add(ctrl.Id);
param.DelegateMethodInfo._OnAddedInParam(func);
}
else
{
param.DelegateMethodInfo.InParams.Insert(insertIndex, func);
param.InParamIndexes.Insert(insertIndex, ctrl.Id);
param.DelegateMethodInfo._OnInsertInParam(insertIndex, func);
}
break;
}
else
{
insertIndex = param.InParamIndexes.IndexOf(mChildNodes[i].Id);
}
}
//for(int i=0; i< mLinkedNodesContainer.CtrlNodeList.Count; i++)
//{
// var node = mLinkedNodesContainer.CtrlNodeList[i];
// if(node is MethodCustom)
// {
// var methodNode = node as MethodCustom;
// if(insertIndex < 0)
// await methodNode.OnAddedInParam(func);
// else
// {
// await methodNode.OnInsertInParam(insertIndex, func);
// }
// continue;
// }
// //else if(node is ReturnCustom)
// //{
// // var retNode = node as ReturnCustom;
// // retNode.ResetMethodInfo(param.DelegateMethodInfo);
// //}
//}
}
public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(System.CodeDom.CodeTypeDeclaration codeClass, System.CodeDom.CodeStatementCollection codeStatementCollection, CodeGenerateSystem.Base.LinkPinControl element, CodeGenerateSystem.Base.GenerateCodeContext_Method context)
{
MethodInvokeParameterControl retCtrl = null;
Dictionary <CodeGenerateSystem.Base.BaseNodeControl, System.CodeDom.CodeExpression> paramCodeExps = new Dictionary <CodeGenerateSystem.Base.BaseNodeControl, System.CodeDom.CodeExpression>();
var rcParam = CSParam as ReturnCustomConstructParam;
if (rcParam.MethodInfo.IsAsync)
{
// 异步不能有out，只能有一个返回值
if (mChildNodes.Count == 1)
{
retCtrl = mChildNodes[0] as MethodInvokeParameterControl;
}
}
else
{
foreach (var paramNode in mChildNodes)
{
if (paramNode is MethodInvokeParameterControl)
{
var pm = paramNode as MethodInvokeParameterControl;
var param = pm.CSParam as MethodInvokeParameterControl.MethodInvokeParameterConstructionParams;
if (param.ParamInfo.ParamName == "Return")
{
retCtrl = pm;
continue;
}
if (pm.HasLink())
{
await pm.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, pm.ParamPin, context);
var exp = new CodeGenerateSystem.CodeDom.CodeCastExpression(param.ParamInfo.ParameterType, pm.GCode_CodeDom_GetValue(pm.ParamPin, context));
paramCodeExps[paramNode] = exp;
codeStatementCollection.Add(new System.CodeDom.CodeAssignStatement(
new System.CodeDom.CodeVariableReferenceExpression(param.ParamInfo.ParamName),
exp));
}
else if (mTemplateClassInstance != null)
{
var proInfo = mTemplateClassInstance.GetType().GetProperty(param.ParamInfo.ParamName);
object proValue;
if (proInfo == null)
{
proValue = CodeGenerateSystem.Program.GetDefaultValueFromType(param.ParamInfo.ParameterType);
}
else
{
proValue = proInfo.GetValue(mTemplateClassInstance);
}
var valueExp = Program.GetValueCode(codeStatementCollection, param.ParamInfo.ParameterType, proValue);
paramCodeExps[paramNode] = valueExp;
codeStatementCollection.Add(new System.CodeDom.CodeAssignStatement(new System.CodeDom.CodeVariableReferenceExpression(param.ParamInfo.ParamName), valueExp));
}
}
else
{
throw new InvalidOperationException();
}
}
}
if (retCtrl != null)
{
if (retCtrl.HasLink())
{
await retCtrl.GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, retCtrl.ParamPin, context);
}
System.CodeDom.CodeExpression retExp = null;
if (retCtrl.HasLink())
{
var retStatement = new System.CodeDom.CodeMethodReturnStatement();
retExp = retCtrl.GCode_CodeDom_GetValue(retCtrl.ParamPin, context);
paramCodeExps[retCtrl] = retExp;
}
else if (mTemplateClassInstance != null)
{
var param = retCtrl.CSParam as MethodInvokeParameterControl.MethodInvokeParameterConstructionParams;
var proInfo = mTemplateClassInstance.GetType().GetProperty(param.ParamInfo.ParamName);
object proValue;
if (proInfo == null)
{
proValue = CodeGenerateSystem.Program.GetDefaultValueFromType(param.ParamInfo.ParameterType);
}
else
{
proValue = proInfo.GetValue(mTemplateClassInstance);
}
retExp = Program.GetValueCode(codeStatementCollection, param.ParamInfo.ParameterType, proValue);
paramCodeExps[retCtrl] = retExp;
}
#region Debug
var debugCodes = CodeDomNode.BreakPoint.BeginMacrossDebugCodeStatments(codeStatementCollection);
foreach (var paramNode in mChildNodes)
{
if (paramNode is MethodInvokeParameterControl)
{
var pm = paramNode as MethodInvokeParameterControl;
System.CodeDom.CodeExpression exp;
if (paramCodeExps.TryGetValue(paramNode, out exp))
{
CodeDomNode.BreakPoint.GetGatherDataValueCodeStatement(debugCodes, pm.ParamPin.GetLinkPinKeyName(), exp, pm.GCode_GetTypeString(pm.ParamPin, context), context);
}
}
else
{
throw new InvalidOperationException("未实现");
}
}
var breakCondStatement = CodeDomNode.BreakPoint.BreakCodeStatement(codeClass, debugCodes, HostNodesContainer.GUID, Id);
CodeDomNode.BreakPoint.EndMacrossDebugCodeStatements(codeStatementCollection, debugCodes);
#endregion
codeStatementCollection.Add(new System.CodeDom.CodeMethodReturnStatement(retExp));
}
else
{
#region Debug
var debugCodes = CodeDomNode.BreakPoint.BeginMacrossDebugCodeStatments(codeStatementCollection);
var breakCondStatement = CodeDomNode.BreakPoint.BreakCodeStatement(codeClass, debugCodes, HostNodesContainer.GUID, Id);
CodeDomNode.BreakPoint.EndMacrossDebugCodeStatements(codeStatementCollection, debugCodes);
#endregion
codeStatementCollection.Add(new System.CodeDom.CodeMethodReturnStatement());
}
}
// 这里不做参数在PropertyGrid中的显示设置，防止类似Ref参数被无意设置
protected void SetParameters(MethodInfoAssist methodInfo)
{
var cpInfos = new List <CustomPropertyInfo>();
mParamsPanel?.Children.Clear();
var param = CSParam as ReturnConstructParam;
// return
if ((param.MethodInfo.ReturnType != typeof(void)) && (param.MethodInfo.ReturnType != typeof(System.Threading.Tasks.Task)))
{
var csParam = new MethodInvokeParameterControl.MethodInvokeParameterConstructionParams()
{
CSType = CSParam.CSType,
HostNodesContainer = CSParam.HostNodesContainer,
ConstructParam = "",
ConstructType = MethodInvokeNode.enParamConstructType.Return,
ParamInfo = new MethodParamInfoAssist()
{
FieldDirection = System.CodeDom.FieldDirection.Out,
IsParamsArray = false,
ParameterType = param.MethodInfo.ReturnType,
ParamName = "Return",
},
};
var ctrl = new MethodInvokeParameterControl(csParam);
AddChildNode(ctrl, mParamsPanel);
if (Program.IsTypeValidInPropertyGridShow(param.MethodInfo.ReturnType))
{
var cpInfo = Program.GetFromParamInfo(csParam.ParamInfo);
cpInfos.Add(cpInfo);
}
}
foreach (var methodParam in methodInfo.Params)
{
if (methodParam.FieldDirection != System.CodeDom.FieldDirection.Out)
{
continue;
}
CodeGenerateSystem.Base.BaseNodeControl pc = null;
if (methodParam.ParameterType.IsSubclassOf(typeof(System.Delegate)))
{
var csParam = new MethodInvoke_DelegateControl.MethodInvoke_DelegateControlConstructionParams()
{
CSType = CSParam.CSType,
HostNodesContainer = CSParam.HostNodesContainer,
ConstructParam = this.NodeName,
ConstructType = MethodInvokeNode.enParamConstructType.Return,
ParamInfo = methodParam,
};
pc = new MethodInvoke_DelegateControl(csParam);
}
else
{
if (methodParam.IsParamsArray)
{
var csParam = new ParamParameterControl.ParamParameterConstructionParams()
{
CSType = CSParam.CSType,
HostNodesContainer = CSParam.HostNodesContainer,
ConstructParam = "",
ConstructType = MethodInvokeNode.enParamConstructType.Return,
ParamInfo = methodParam,
};
pc = new ParamParameterControl(csParam);
}
else
{
var csParam = new MethodInvokeParameterControl.MethodInvokeParameterConstructionParams()
{
CSType = CSParam.CSType,
HostNodesContainer = CSParam.HostNodesContainer,
ConstructParam = "",
ConstructType = MethodInvokeNode.enParamConstructType.Return,
ParamInfo = methodParam,
};
pc = new MethodInvokeParameterControl(csParam);
if (Program.IsTypeValidInPropertyGridShow(methodParam.ParameterType))
{
var cpInfo = Program.GetFromParamInfo(methodParam);
cpInfos.Add(cpInfo);
}
}
}
AddChildNode(pc, mParamsPanel);
}
CreateTemplateClass(cpInfos);
}
