Пример #1
0
        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);
        }
Пример #2
0
        //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);
        }
Пример #3
0
        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));
                    }
                }
            }
        }
Пример #4
0
        // 这里不做参数在PropertyGrid中的显示设置,防止类似Ref参数被无意设置
        void SetParameters(CustomMethodInfo methodInfo)
        {
            var param = CSParam as ReturnCustomConstructParam;

            //param.MethodInfo.OnAddedOutParam -= ReturnCustom_AddParam;
            //param.MethodInfo.OnAddedOutParam += ReturnCustom_AddParam;
            //param.MethodInfo.OnRemovedOutParam -= ReturnCustom_RemoveParam;
            //param.MethodInfo.OnRemovedOutParam += ReturnCustom_RemoveParam;
            //param.MethodInfo.AddOutParamOperation(this);

            param.MethodInfo.AddOutParamOperation(this);

            var cpInfos = new List <CodeGenerateSystem.Base.CustomPropertyInfo>(methodInfo.OutParams.Count);

            mParamsPanel?.Children.Clear();
            foreach (var methodParam in 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);
                }

                //ReturnCustom_AddParam(methodParam);
                var noUse = OnAddedOutParam(methodParam);
            }

            if (param.ShowPropertyType == ReturnCustomConstructParam.enShowPropertyType.ReturnValue)
            {
                CreateTemplateClass(cpInfos);
            }
        }