Пример #1
0
        public void InspectObject(AgentType agentType, string agentFullname, Nodes.Node node)
        {
            _agentFullname = agentFullname;

            preLayout();

            deleteAllRowControls();

            if (agentType != null)
            {
                IList<PropertyDef> properties = agentType.GetProperties();
                foreach (PropertyDef p in properties)
                {
                    addRowControl(p, null);
                }
            }
            else if (node != null)
            {
                List<ParInfo> allPars = node.Pars;
                foreach (ParInfo par in allPars)
                {
                    addRowControl(null, par);
                }
            }

            postLayout();
        }
Пример #2
0
        public MetaMethodDialog(AgentType agent, MethodDef method, MemberType memberType)
        {
            InitializeComponent();

            this.Owner = MainWindow.Instance;

            this.metaMethodPanel.Initialize(true, agent, method, memberType);
        }
Пример #3
0
        public MetaPropertyDialog(bool canBeEdited, AgentType agent, CustomizedStruct customizedStruct, PropertyDef prop, bool canBePar)
        {
            InitializeComponent();

            this.Owner = MainWindow.Instance;

            this.metaPropertyPanel.Initialize(canBeEdited, agent, customizedStruct, prop, canBePar);
        }
Пример #4
0
        internal static void Inspect(AgentType agentType, string agentName, string agentFullName, FrameStatePool.PlanningState nodeState) {
            ParametersDock dock = findParametersDock(agentType, agentName);

            if (dock == null) {
                dock = new ParametersDock();
                dock.Show(MainWindow.Instance.DockPanel, WeifenLuo.WinFormsUI.Docking.DockState.DockBottom);
            }

            dock.InspectObject(agentType, agentName, agentFullName, nodeState);
        }
Пример #5
0
        public override bool ResetMembers(bool check, AgentType agentType, bool clear, MethodDef method = null, PropertyDef property = null)
        {
            bool bReset = false;

            if (this._frames != null)
            {
                bReset |= this._frames.ResetMembers(check, agentType, clear, method, property);
            }

            bReset |= base.ResetMembers(check, agentType, clear, method, property);

            return bReset;
        }
Пример #6
0
        public void Initialize(bool canBeEdit, AgentType agent, CustomizedStruct customizedStruct, PropertyDef prop, bool canBePar)
        {
            Debug.Check(agent != null || customizedStruct != null);

            _initialized = false;
            _isModified = false;
            _isNew = (prop == null);
            _agent = agent;
            _customizedStruct = customizedStruct;
            _originalProperty = prop;

            setTypes();

            if (_isNew)
            {
                this.Text = canBeEdit ? Resources.AddProperty : Resources.ViewProperty;

                if (customizedStruct == null)
                    _property = new PropertyDef(agent, null, agent.AgentTypeName, "", "", "");
                else
                    _property = new PropertyDef(null, null, customizedStruct.Name, "", "", "");
            }
            else
            {
                this.Text = canBeEdit ? Resources.EditProperty : Resources.ViewProperty;

                resetProperty(prop, prop.IsPar);
            }

            this.isStaticCheckBox.Visible = (agent != null);
            this.isPublicCheckBox.Visible = !canBeEdit && (agent != null);
            this.isConstcheckBox.Visible = (agent != null);
            this.customizedCheckBox.Visible = !canBeEdit && !_property.IsInherited;
            this.isLocalCheckBox.Checked = customizedStruct == null && _property.IsPar;
            this.isLocalCheckBox.Visible = canBePar && customizedStruct == null && !_property.IsMember;
            this.nameTextBox.Enabled = canBeEdit;
            this.arrayCheckBox.Enabled = canBeEdit || _property.IsChangeableType;
            this.typeComboBox.Enabled = canBeEdit || _property.IsChangeableType;
            this.isStaticCheckBox.Enabled = canBeEdit;
            this.isConstcheckBox.Enabled = canBeEdit;
            this.dispTextBox.Enabled = canBeEdit;
            this.descTextBox.Enabled = canBeEdit;

            _initialized = true;
        }
Пример #7
0
        public void InspectObject(AgentType agentType, string agentFullname) {
            _agentFullname = agentFullname;

            preLayout();

            deleteAllRowControls();

            if (agentType != null) {
                IList<PropertyDef> properties = agentType.GetProperties();
                foreach(PropertyDef p in properties) {
                    if (!p.IsAddedAutomatically) {
                        addRowControl(p);
                    }
                }
            }

            postLayout();
        }
Пример #8
0
        private static void LoadCustomMembers(List<Nodes.Node.ErrorCheck> result, XmlNode rootNode)
        {
            if (rootNode == null)
            { return; }

            // Set the default base agent.
            if (Plugin.AgentTypes.Count == 0) {
                AgentType agent = new AgentType(typeof(Agent), "Agent", false, "Agent", "");
                Plugin.AgentTypes.Add(agent);
            }

            foreach(XmlNode xmlNode in rootNode.ChildNodes) {
                if (xmlNode.Name == "agent") {
                    string agentName = GetAttribute(xmlNode, "type");
                    string agentBase = GetAttribute(xmlNode, "base");
                    int baseIndex = -1;

                    for (int i = 0; i < Plugin.AgentTypes.Count; ++i) {
                        if (Plugin.AgentTypes[i].AgentTypeName == agentBase) {
                            baseIndex = i;
                            break;
                        }
                    }

                    string agentDisp = GetAttribute(xmlNode, "disp");
                    string agentDesc = GetAttribute(xmlNode, "desc");

                    if (string.IsNullOrEmpty(agentDisp))
                    { agentDisp = agentName; }

                    AgentType agent = Plugin.GetAgentType(agentName);

                    if (agent == null) {
                        agent = new AgentType(agentName, (baseIndex > -1) ? Plugin.AgentTypes[baseIndex] : null, agentDisp, agentDesc);
                        Plugin.AgentTypes.Add(agent);
                    }

                    foreach(XmlNode bbNode in xmlNode) {
                        if (bbNode.Name == "properties") {
                            foreach(XmlNode propNode in bbNode) {
                                if (propNode.Name == "property") {
                                    string propName = GetAttribute(propNode, "name");

                                    string isStatic = GetAttribute(propNode, "static");
                                    bool bStatic = false;

                                    if (!string.IsNullOrEmpty(isStatic) && isStatic == "true")
                                    { bStatic = true; }

                                    string isPublic = GetAttribute(propNode, "public");
                                    bool bPublic = false;

                                    if (string.IsNullOrEmpty(isPublic) || isPublic == "true")
                                    { bPublic = true; }

                                    string isReadonly = GetAttribute(propNode, "readonly");
                                    bool bReadonly = false;

                                    if (!string.IsNullOrEmpty(isReadonly) && isReadonly == "true")
                                    { bReadonly = true; }

                                    string propType = GetAttribute(propNode, "type");
                                    Type type = Plugin.GetTypeFromName(propType);

                                    string classname = GetAttribute(propNode, "classname");

                                    if (string.IsNullOrEmpty(classname))
                                    { classname = agent.AgentTypeName; }

                                    string propDisp = GetAttribute(propNode, "disp");

                                    if (string.IsNullOrEmpty(propDisp))
                                    { propDisp = propName; }

                                    string propDesc = GetAttribute(propNode, "desc");

                                    PropertyDef prop = new PropertyDef(agent, type, classname, propName, propDisp, propDesc);
                                    prop.IsStatic = bStatic;
                                    prop.IsPublic = bPublic;
                                    prop.IsReadonly = bReadonly;

                                    string defaultValue = GetAttribute(propNode, "defaultvalue");

                                    if (!string.IsNullOrEmpty(defaultValue)) {
                                        prop.Variable = new VariableDef(null);
                                        Plugin.InvokeTypeParser(result, type, defaultValue, (object value) => prop.Variable.Value = value, null);
                                    }

                                    agent.AddProperty(prop);
                                }
                            }

                        } else if (bbNode.Name == "methods") {
                            foreach(XmlNode methodNode in bbNode) {
                                if (methodNode.Name == "method") {
                                    string methodName = GetAttribute(methodNode, "name");
                                    Type returnType = Plugin.GetTypeFromName(GetAttribute(methodNode, "returntype"));

                                    string isStatic = GetAttribute(methodNode, "static");
                                    bool bStatic = false;

                                    if (!string.IsNullOrEmpty(isStatic) && isStatic == "true")
                                    { bStatic = true; }

                                    string isPublic = GetAttribute(methodNode, "public");
                                    bool bPublic = false;

                                    if (string.IsNullOrEmpty(isPublic) || isPublic == "true")
                                    { bPublic = true; }

                                    string classname = GetAttribute(methodNode, "classname");

                                    if (string.IsNullOrEmpty(classname))
                                    { classname = agent.AgentTypeName; }

                                    string methodDisp = GetAttribute(methodNode, "disp");

                                    if (string.IsNullOrEmpty(methodDisp))
                                    { methodDisp = methodName; }

                                    string methodDesc = GetAttribute(methodNode, "desc");

                                    bool istask = (GetAttribute(methodNode, "istask") == "true");
                                    //bool isevent = (GetAttribute(methodNode, "isevent") == "true");

                                    MemberType memberType = MemberType.Method;

                                    if (istask) {
                                        memberType = MemberType.Task;
                                    }

                                    methodName = string.Format("{0}::{1}", agent.AgentTypeName, methodName);

                                    MethodDef method = new MethodDef(agent, memberType, classname, methodName, methodDisp, methodDesc, "", returnType);
                                    method.IsStatic = bStatic;
                                    method.IsPublic = bPublic;

                                    agent.AddMethod(method);

                                    foreach(XmlNode paramNode in methodNode) {
                                        string paramName = GetAttribute(paramNode, "name");
                                        Type paramType = Plugin.GetTypeFromName(GetAttribute(paramNode, "type"));
                                        bool isOut = (GetAttribute(paramNode, "isout") == "true");
                                        bool isRef = (GetAttribute(paramNode, "isref") == "true");
                                        string nativeType = Plugin.GetNativeTypeName(paramType);

                                        string paramDisp = GetAttribute(paramNode, "disp");

                                        if (string.IsNullOrEmpty(paramDisp))
                                        { paramDisp = paramName; }

                                        string paramDesc = GetAttribute(paramNode, "desc");

                                        MethodDef.Param param = new MethodDef.Param(paramName, paramType, nativeType, paramDisp, paramDesc);
                                        param.IsOut = isOut;
                                        param.IsRef = isRef;

                                        method.Params.Add(param);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Пример #9
0
        private void agentTypeChanged(AgentType agentType) {
            //CheckErrors(_rootNode.RootBehavior, true);

            //PropertiesDock.UpdatePropertyGrids();

            this.Redraw();
        }
Пример #10
0
 public MethodDef(AgentType agentType, MemberType memberType, bool isChangeableType, bool isPublic, bool isStatic, string classname, string owner, string name, string displayName, string description, string nativeReturnType, Type returnType, bool isActionMethodOnly, List<Param> pars)
 {
     _agentType = agentType;
     _isChangeableType = isChangeableType;
     _isPublic = isPublic;
     _isStatic = isStatic;
     _classname = classname;
     _owner = owner;
     _name = name;
     _displayName = displayName;
     _description = description;
     _nativeReturnType = string.IsNullOrEmpty(nativeReturnType) ? Plugin.GetNativeTypeName(returnType) : nativeReturnType;
     _returnType = returnType;
     _isActionMethodOnly = isActionMethodOnly;
     _params = pars;
     _memberType = memberType;
     _isCustomized = (memberType == Design.MemberType.Task);
 }
Пример #11
0
        public bool ResetMembers(bool check, AgentType agentType, bool clear, MethodDef method, PropertyDef property)
        {
            if (this.IsMethod && this.Method != null)
            {
                if (method != null && method.OldName == this.Method.Name)
                {
                    if (!check)
                    {
                        if (clear || this.Method.ShouldBeCleared(agentType))
                        { this.m_method = null; }

                        else
                        { this.Method.CopyFrom(method); }
                    }

                    return true;
                }

                return this.Method.ResetMembers(check, agentType, clear, method, property);

            }
            else if (this.Var != null)
            {
                return this.Var.ResetMembers(check, agentType, clear, property);
            }

            return false;
        }
Пример #12
0
        public bool ResetMembers(bool check, AgentType agentType, bool clear, PropertyDef property)
        {
            if (property != null && this._property != null &&
                (property.OldName == this._property.Name ||
                 !property.IsArrayElement && this._property.IsArrayElement &&
                 (property.OldName + "[]") == this._property.Name))
            {
                if (!check)
                {
                    if (clear || this._property.ShouldBeCleared(agentType))
                    {
                        this._property = null;

                    }
                    else
                    {
                        bool isArrayElement = this._property.IsArrayElement;

                        this._property.CopyFrom(property);

                        if (isArrayElement)
                        { this._property.SetArrayElement(property); }
                    }
                }

                return true;
            }

            return false;
        }
Пример #13
0
 public bool ShouldBeCleared(AgentType agentType)
 {
     return (this.Owner == VariableDef.kSelf &&
             !Plugin.IsAgentDerived(this.AgentType.AgentTypeName, agentType.AgentTypeName));
 }
Пример #14
0
 // Meta Property
 public PropertyDef(AgentType agentType, FieldInfo pi, bool isChangeableType, bool isStatic, bool isPublic, bool isProperty, bool isReadonly, string classname, string owner, string name, string nativeType, string displayName, string description)
 {
     _agentType = agentType;
     _propertyInfo = pi;
     _isChangeableType = isChangeableType;
     _isStatic = isStatic;
     _isPublic = isPublic;
     _isProperty = isProperty;
     _isReadonly = isReadonly;
     _classname = classname;
     _owner = owner;
     _name = name;
     _nativeType = nativeType;
     _displayName = displayName;
     _description = description;
 }
Пример #15
0
        public override bool ResetMembers(bool check, AgentType agentType, bool clear, MethodDef method = null, PropertyDef property = null) {
            bool bReset = false;

            if (this._task != null && method != null && this._task.Name == method.OldName) {
                if (method != null && this._task.Name == method.OldName &&
                    (clear || this._task.ShouldBeCleared(agentType))) {
                    bReset = true;

                    if (!check)
                    { this._task = null; }

                } else {
                    bReset |= this._task.ResetMembers(check, agentType, clear, method, property);
                }
            }

            bReset |= base.ResetMembers(check, agentType, clear, method, property);

            return bReset;
        }
Пример #16
0
        private void setText(AgentType agentType, string agentName) {
            // Par
            if (agentType == null) {
                Text = TabText = string.IsNullOrEmpty(agentName) ? Resources.Pars : string.Format(Resources.ParsOf, agentName);
            }

            // Global
            else if (Plugin.IsGlobalInstanceAgentType(agentType)) {
                Text = TabText = string.Format(Resources.PropertiesOf, agentType.ToString());
            }

            // Agent
            else {
                Text = TabText = string.Format(Resources.PropertiesOf + "::{1}", agentType.ToString(), agentName);
            }
        }
Пример #17
0
 public void InspectObject(AgentType agentType, string agentFullName) {
     this.parametersPanel.InspectObject(agentType, agentFullName);
 }
Пример #18
0
        private void InspectObject(AgentType agentType, string agentName, string agentFullName, FrameStatePool.PlanningState nodeState) {
            Nodes.Node node = null;

            if (agentType == null && !string.IsNullOrEmpty(agentFullName)) {
                int frame = AgentDataPool.CurrentFrame > -1 ? AgentDataPool.CurrentFrame : 0;
                string behaviorFilename = FrameStatePool.GetBehaviorFilename(agentFullName, frame);
                List<string> transitionIds = FrameStatePool.GetHighlightTransitionIds(agentFullName, frame, behaviorFilename);
                List<string> highlightNodeIds = FrameStatePool.GetHighlightNodeIds(agentFullName, frame, behaviorFilename);
                List<string> updatedNodeIds = FrameStatePool.GetUpdatedNodeIds(agentFullName, frame, behaviorFilename);
                Dictionary<string, FrameStatePool.NodeProfileInfos.ProfileInfo> profileInfos = FrameStatePool.GetProfileInfos(frame, behaviorFilename);

                BehaviorNode behavior = UIUtilities.ShowBehaviorTree(agentFullName, frame, transitionIds, highlightNodeIds, updatedNodeIds, HighlightBreakPoint.Instance, profileInfos);
                node = behavior as Nodes.Node;
            }

            _agentType = agentType;
            _agentName = agentName;

            Hide();

            setText(agentType, agentName);

            if (nodeState != null) {
                foreach(string agentFullName1 in nodeState._agents.Keys) {
                    string[] tokens = agentFullName1.Split('#');
                    Debug.Check(tokens.Length == 2);
                    string at = tokens[0];
                    string an = tokens[1];

                    AgentType agentType1 = Plugin.GetAgentType(at);

                    ParametersDock dock = findParametersDock(agentType1, an);
                    dock.InspectObject(agentType1, agentFullName1);

                    dock.setProperty(nodeState, agentFullName1);
                }

            } else if (AgentDataPool.CurrentFrame > -1 && !string.IsNullOrEmpty(agentName)) {
                ParametersDock dock = findParametersDock(agentType, agentName);
                dock.InspectObject(agentType, agentFullName);

                List<AgentDataPool.ValueMark> valueSet = AgentDataPool.GetValidValues(agentType, agentFullName, AgentDataPool.CurrentFrame);
                foreach(AgentDataPool.ValueMark value in valueSet) {
                    dock.setProperty(value.Name, value.Value);
                }
            }

            lostAnyFocus();
            Show();
        }
Пример #19
0
        public bool ResetMembers(bool check, AgentType agentType, bool clear, MethodDef method, PropertyDef property)
        {
            bool bReset = false;

            if (method != null)
            {
                if (method.OldName == this.Name)
                {
                    bReset = true;

                    if (!check)
                    {
                        this.CopyFrom(method);
                    }
                }

            }
            else if (property != null)
            {
                foreach (MethodDef.Param param in this.Params)
                {
                    if (param.Value is VariableDef)
                    {
                        VariableDef var = param.Value as VariableDef;
                        bReset |= var.ResetMembers(check, agentType, clear, property);

                    }
                    else if (param.Value is ParInfo)
                    {
                        ParInfo par = param.Value as ParInfo;

                        if (property.IsPar && (property.OldName == par.Name ||
                        !property.IsArrayElement && par.IsArrayElement && (property.OldName + "[]") == par.Name))
                        {
                            if (clear || this.ShouldBeCleared(agentType))
                            {
                                bReset = true;

                                if (!check)
                                { param.Value = Plugin.DefaultValue(param.Type); }

                            }
                            else
                            {
                                bReset = true;

                                if (!check)
                                {
                                    bool isArrayElement = par.IsArrayElement;

                                    par.CopyFrom(property);

                                    if (isArrayElement)
                                    { par.SetArrayElement(property); }
                                }
                            }
                        }
                    }
                }
            }

            return bReset;
        }
Пример #20
0
        private static ParametersDock findParametersDock(AgentType agentType, string agentName) {
            foreach(ParametersDock dock in _parameterDocks) {
                if (dock.AgentType == agentType && (string.IsNullOrEmpty(dock.AgentName) || dock.AgentName == agentName)) {
                    return dock;
                }
            }

            return null;
        }
Пример #21
0
 // Customized Property
 public PropertyDef(AgentType agentType, Type type, string classname, string name, string displayName, string description)
 {
     _agentType = agentType;
     _propertyInfo = null;
     _type = type;
     _isChangeableType = false;
     _isStatic = false;
     _isPublic = true;
     _isProperty = false;
     _classname = classname;
     _owner = VariableDef.kSelf;
     _name = name;
     _nativeType = Plugin.GetNativeTypeName(type);
     _displayName = displayName;
     _description = description;
 }
Пример #22
0
        public override bool ResetMembers(bool check, AgentType agentType, bool clear, MethodDef method = null, PropertyDef property = null) {
            bool bReset = false;

            if (this.Opl != null) {
                bReset |= this.Opl.ResetMembers(check, agentType, clear, method, property);
            }

            if (this.Opr1 != null) {
                bReset |= this.Opr1.ResetMembers(check, agentType, clear, method, property);
            }

            if (this.Opr2 != null) {
                bReset |= this.Opr2.ResetMembers(check, agentType, clear, method, property);
            }

            bReset |= base.ResetMembers(check, agentType, clear, method, property);

            if (!check && bReset) {
                OnPropertyValueChanged(false);
            }

            return bReset;
        }
Пример #23
0
        public bool ShouldBeCleared(AgentType agentType)
        {
            if (this.IsProperty && this.Property != null)
            { return this.Property.ShouldBeCleared(agentType); }

            return false;
        }
Пример #24
0
        private void updateParameters(AgentType agentType, string agentName, int frame)
        {
            if (string.IsNullOrEmpty(agentName)) {
                return;
            }

            string typeName = (agentType == null) ? agentName : agentType.ToString();
            string agentFullname = (agentType == null) ? agentName : agentType.ToString() + "#" + agentName;
            List<AgentDataPool.ValueMark> values = AgentDataPool.GetValidValues(agentType, agentFullname, frame);
            foreach(AgentDataPool.ValueMark value in values) {
                ParametersDock.SetProperty(typeName, agentName, value.Name, value.Value);
            }
        }
Пример #25
0
        public bool ShouldBeCleared(AgentType agentType)
        {
            if (this.IsMethod && this.Method != null)
            { return this.Method.ShouldBeCleared(agentType); }

            if (this.Var != null)
            { return this.Var.ShouldBeCleared(agentType); }

            return false;
        }
Пример #26
0
 private void resetMembersInWorkspace(AgentType agentType, bool clear, MethodDef method, PropertyDef property)
 {
     foreach(Nodes.BehaviorNode behavior in getAllBehaviors(property)) {
         if (behavior != null && behavior is Nodes.Node) {
             bool bReset = ((Nodes.Node)behavior).ResetMembers(false, agentType, clear, method, property);
             if (bReset)
                 UndoManager.Save(behavior);
         }
     }
 }
Пример #27
0
 public ParInfo(Nodes.Node node, AgentType agent)
     : base(agent, null, (agent != null) ? agent.AgentTypeName : "", "", "", "")
 {
     _node = node;
 }
Пример #28
0
        private void typeListBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            this.addMemberButton.Enabled = true;
            this.removeTypeButton.Enabled = false;

            int typeIndex = this.typeListBox.SelectedIndex;
            if (typeIndex >= 0)
            {
                _previousSelectedMemberIndex = -1;
                if (_previousSelectedTypeIndex != typeIndex)
                {
                    apply(false, _previousSelectedTypeIndex, -1, false);

                    _previousSelectedTypeIndex = typeIndex;
                }

                this.removeTypeButton.Enabled = true;

                this.instanceComboBox.Items.Clear();

                if (this.typeListBox.SelectedIndex < Plugin.AgentTypes.Count) {
                    _lastAgent = Plugin.AgentTypes[this.typeListBox.SelectedIndex];

                    AgentType currentViewAgentType = getCurrentViewAgentType();

                    // set all instance names
                    if (currentViewAgentType != null && currentViewAgentType == _lastAgent) {
                        this.instanceComboBox.Items.Add(VariableDef.kSelf);
                    }

                    foreach(Plugin.InstanceName_t instanceName in Plugin.InstanceNames) {
                        if (instanceName.agentType_ == _lastAgent && _lastAgent != currentViewAgentType) {
                            this.instanceComboBox.Items.Add(instanceName.displayName_);
                        }
                    }

                    if (this.instanceComboBox.Items.Count > 0) {
                        this.instanceComboBox.SelectedIndex = 0;
                    }

                    if (!Plugin.AgentTypes[this.typeListBox.SelectedIndex].IsCustomized) {
                        this.removeTypeButton.Enabled = false;
                    }
                }

                this.metaTypePanel.Initialize(this.getSelectedType());

                setMembers();

                if (this.typeListBox.SelectedIndex == 0) {
                    this.addMemberButton.Enabled = false;
                }
            }

            if (this._metaPropertyPanel != null)
            {
                this._metaPropertyPanel.Hide();
            }
            if (this._metaMethodPanel != null)
            {
                this._metaMethodPanel.Hide();
            }
            if (this._editEnumMemberPanel != null)
            {
                this._editEnumMemberPanel.Hide();
            }
            initMetaPanel();
        }
Пример #29
0
 // Customized Method
 public MethodDef(AgentType agentType, MemberType memberType, string classname, string name, string displayName, string description, string nativeReturnType, Type returnType)
 {
     _agentType = agentType;
     _isChangeableType = false;
     _isCustomized = true;
     _memberType = memberType;
     _isPublic = true;
     _isStatic = false;
     _classname = classname;
     _owner = classname;
     _name = name;
     _displayName = displayName;
     _description = description;
     _nativeReturnType = string.IsNullOrEmpty(nativeReturnType) ? Plugin.GetNativeTypeName(returnType) : nativeReturnType;
     _returnType = returnType;
     _isActionMethodOnly = false;
 }
Пример #30
0
        private bool checkMembersInWorkspace(AgentType agentType, bool clear, MethodDef method, PropertyDef property)
        {
            foreach(Nodes.BehaviorNode behavior in getAllBehaviors(property)) {
                if (behavior != null && behavior is Nodes.Node) {
                    bool bReset = ((Nodes.Node)behavior).ResetMembers(true, agentType, clear, method, property);
                    if (bReset)
                        return DialogResult.Yes == MessageBox.Show(Resources.ModifyMemberWarning, Resources.Warning, MessageBoxButtons.YesNo);
                }
            }

            return true;
        }