Esempio n. 1
0
        private void update()
        {
            if (_arrayProperty != null)
            {
                textBox.Text   = DesignerArray.RetrieveDisplayValue(_arrayProperty.ItemList);
                button.Enabled = true;
            }
            else if (_structProperty != null)
            {
                //textBox.Text = "(Multiple properties)";
                MethodDef    method = null;
                Nodes.Action action = this._object as Nodes.Action;

                if (action != null)
                {
                    method = action.Method;
                }

                textBox.Text   = DesignerPropertyUtility.RetrieveDisplayValue(_structProperty.Owner, method, _structProperty.Name, _structProperty.ElmentIndexInArray);
                button.Enabled = true;
            }
            else
            {
                textBox.Text = "null";
                //textBox.Text = DesignerPropertyUtility.RetrieveDisplayValue(_property, null, null);
                button.Enabled = false;
            }
        }
        private void buildPropertyGrid(int selectedIndex = 0)
        {
            propertyGrid.PropertiesVisible(false, false);
            propertyGrid.ClearProperties();

            if (_arrayProperty != null)
            {
                _selectedLabel = null;

                if (_arrayProperty.ItemList.Count > 0)
                {
                    Type editorType = Plugin.InvokeEditorType(_arrayProperty.ItemType);
                    Debug.Check(editorType != null);

                    for (int index = 0; index < _arrayProperty.ItemList.Count; index++)
                    {
                        createArrayPropertyEditor(index, editorType, index == selectedIndex);
                    }

                    propertyGrid.UpdateSizes();
                    propertyGrid.PropertiesVisible(true, false);
                }
            }
            else if (_structProperty != null)
            {
                downButton.Visible   = false;
                upButton.Visible     = false;
                appendButton.Visible = false;
                insertButton.Visible = false;
                removeButton.Visible = false;
                //tableLayoutPanel.SetRowSpan(propertyGrid, tableLayoutPanel.RowCount - 1);
                //tableLayoutPanel.SetColumnSpan(propertyGrid, tableLayoutPanel.ColumnCount);

                Nodes.Action action = this._object as Nodes.Action;

                if (action == null)
                {
                    updateStructProperties(_structProperty.Owner);
                }
                else
                {
                    MethodDef method = action.Method;

                    if (method != null)
                    {
                        this.createParamEditor(_structProperty, action);
                    }
                }
            }
        }
Esempio n. 3
0
        public static bool parseParam(List <Nodes.Node.ErrorCheck> result, DefaultObject node, MethodDef method, MethodDef.Param par, string param)
        {
            string propName = null;

            if (param[0] == '\"')
            {
                param = param.Substring(1, param.Length - 2);
            }
            else if (param[0] == '{')     //struct
            {
                //to set it as action.Method is used in the following parsing
                Nodes.Action action = node as Nodes.Action;

                if (action != null && action.Method == null)
                {
                    action.Method = method;
                }
            }
            else
            {
                string noStaticParam = param.Replace("static ", "");
                int    index         = noStaticParam.IndexOf(" ");

                if (index >= 0)
                {
                    propName = noStaticParam.Substring(index + 1);
                }
            }

            bool bOk = false;

            if (propName != null)
            {
                VariableDef var = setParameter(result, node, propName);

                if (var != null)
                {
                    par.Value = var;
                    bOk       = true;
                }
            }
            else
            {
                bOk = Plugin.InvokeTypeParser(result, par.Type, param,
                                              (object value) => par.Value = value,
                                              node, par.Name);
            }

            return(bOk);
        }
Esempio n. 4
0
        protected override void GenerateMember(Node node, StringWriter stream, string indent)
        {
            base.GenerateMember(node, stream, indent);

            Nodes.Action action = node as Nodes.Action;

            if (action == null)
            {
                return;
            }

            if (action.Method != null && !isNullMethod(action.Method))
            {
                MethodCsExporter.GenerateClassMember(action.Method, stream, indent, "method");
            }
        }
Esempio n. 5
0
        protected override void GenerateConstructor(Node node, StringWriter stream, string indent, string className)
        {
            base.GenerateConstructor(node, stream, indent, className);

            Nodes.Action action = node as Nodes.Action;

            if (action == null)
            {
                return;
            }

            if (action.Method != null)
            {
                MethodCppExporter.GenerateClassConstructor(node, action.Method, stream, indent, "method");
            }
        }
Esempio n. 6
0
        public static bool parseParam(List <Nodes.Node.ErrorCheck> result, DefaultObject node, MethodDef method, MethodDef.Param par, string param)
        {
            string[] tokens = null;

            if (param[0] == '\"')
            {
                param = param.Substring(1, param.Length - 2);
            }
            else if (param[0] == '{')
            {
                //struct

                //to set it as action.Method is used in the following parsing
                Nodes.Action action = node as Nodes.Action;

                if (action != null)
                {
                    action.Method = method;
                }
            }
            else
            {
                tokens = param.Split(' ');
            }


            bool bOk = false;

            if (tokens != null && tokens.Length > 1)
            {
                //par
                VariableDef var = setParameter(result, node, tokens[tokens.Length - 1]);

                if (var != null)
                {
                    par.Value = var;
                    bOk       = true;
                }
            }
            else
            {
                bOk = Plugin.InvokeTypeParser(result, par.Type, param, (object value) => par.Value = value, node, par.Name);
            }

            return(bOk);
        }
        void createParamEditor(DesignerStructPropertyInfo structParam, Nodes.Action action)
        {
            MethodDef method = action.Method;

            if (method != null)
            {
                List <MethodDef.Param> parameters = method.GetParams(structParam);

                if (parameters != null && parameters.Count > 0)
                {
                    foreach (MethodDef.Param p in parameters)
                    {
                        Type editorType = null;

                        if (structParam.ElmentIndexInArray != -1)
                        {
                            object member = p.Value;
                            editorType = p.Attribute.GetEditorType(member);
                        }
                        else
                        {
                            editorType = typeof(DesignerParameterComboEnumEditor);
                        }

                        string arugmentsName = "    " + p.DisplayName;
                        Label  label         = propertyGrid.AddProperty(arugmentsName, editorType,
                                                                        p.Attribute != null ? p.Attribute.HasFlags(DesignerProperty.DesignerFlags.ReadOnly) : false);
                        label.BackColor   = System.Drawing.Color.FromArgb(((int)(((byte)(56)))), ((int)(((byte)(56)))), ((int)(((byte)(56)))));
                        label.MouseEnter += label_MouseEnter;

                        DesignerPropertyEditor editor = (DesignerPropertyEditor)label.Tag;
                        editor.Enabled = true;
                        //editor.SetRootNode(this._node);
                        editor.SetParameter(p, action, false);
                        editor.MouseEnter += new EventHandler(editor_MouseEnter);
                        editor.ValueWasAssigned();
                        editor.ValueWasChanged += editor_ValueWasChanged;
                    }

                    {
                        propertyGrid.UpdateSizes();
                        propertyGrid.PropertiesVisible(true, true);
                    }
                }
            }
        }
Esempio n. 8
0
        protected override void GenerateConstructor(Node node, StringWriter stream, string indent, string className)
        {
            base.GenerateConstructor(node, stream, indent, className);

            Nodes.Action action = node as Nodes.Action;

            if (action == null)
            {
                return;
            }

            stream.WriteLine("{0}\t\t\tthis.m_resultOption = {1};", indent, getResultOptionStr(action.ResultOption));

            if (action.Method != null && !isNullMethod(action.Method))
            {
                MethodCsExporter.GenerateClassConstructor(node, action.Method, stream, indent, "method");
            }
        }
Esempio n. 9
0
        public static MethodDef parseMethodString(NodeTag.DefaultObject node, AgentType agentType, MethodType methodType, string str)
        {
            try
            {
                if (agentType != null)
                {
                    int pos = str.IndexOf('(');
                    if (pos < 0)
                    {
                        return(null);
                    }

                    string ownerName  = agentType.ToString();
                    int    pointIndex = str.IndexOf('.');
                    if (pointIndex > -1 && pointIndex < pos)
                    {
                        ownerName = str.Substring(0, pointIndex);
                        str       = str.Substring(pointIndex + 1, str.Length - pointIndex - 1);
                        agentType = Plugin.GetInstanceAgentType(ownerName, agentType);
                        //if (agentType == node.Behavior.AgentType)
                        //    ownerName = VariableDef.kSelf;
                        pos = str.IndexOf('(');
                    }

                    IList <MethodDef> actions    = agentType.GetMethods(methodType);
                    string            actionName = str.Substring(0, pos);
                    foreach (MethodDef actionTypeIt in actions)
                    {
                        if (actionTypeIt.Name == actionName
#if BEHAVIAC_NAMESPACE_FIX
                            || actionTypeIt.Name.EndsWith(actionName)
#endif
                            )
                        {
                            MethodDef method = new MethodDef(actionTypeIt);
                            method.Owner = ownerName;

                            List <string> paras = parseParams(str.Substring(pos + 1, str.Length - pos - 2));
                            //Debug.Check((paras.Count == actionTypeIt.Params.Count));

                            //if (paras.Count == actionTypeIt.Params.Count)
                            {
                                for (int i = 0; i < paras.Count; ++i)
                                {
                                    string   param  = paras[i];
                                    string[] tokens = null;
                                    if (param[0] == '\"')
                                    {
                                        param = param.Substring(1, param.Length - 2);
                                    }
                                    else if (param[0] == '{')
                                    {
                                        //struct

                                        //to set it as action.Method is used in the following parsing
                                        Nodes.Action action = node as Nodes.Action;
                                        if (action != null)
                                        {
                                            action.Method = method;
                                        }
                                    }
                                    else
                                    {
                                        tokens = param.Split(' ');
                                    }

                                    if (i < method.Params.Count)
                                    {
                                        MethodDef.Param par = method.Params[i];

                                        if (tokens != null && tokens.Length > 1)
                                        {
                                            //par
                                            VariableDef var = setParameter(node, tokens[tokens.Length - 1]);
                                            if (var != null)
                                            {
                                                par.Value = var;
                                            }
                                            //else
                                            //    throw new Exception(string.Format(Resources.ExceptionDesignerAttributeIllegalFloatValue, str));
                                        }
                                        else
                                        {
                                            bool bOk = Plugin.InvokeTypeParser(par.Type, param, (object value) => par.Value = value, node, par.Name);
                                            if (!bOk)
                                            {
                                                throw new Exception(string.Format(Resources.ExceptionDesignerAttributeIllegalFloatValue, str));
                                            }
                                        }
                                    }
                                    else
                                    {
                                        break;
                                    }
                                }
                            }

                            return(method);
                        }
                    }
                }
            }
            catch (Exception)
            {
                System.Windows.Forms.MessageBox.Show(str, Resources.LoadError, System.Windows.Forms.MessageBoxButtons.OK);
            }

            return(null);
        }
Esempio n. 10
0
        protected override void GenerateMethod(Node node, StringWriter stream, string indent)
        {
            base.GenerateMethod(node, stream, indent);

            Nodes.Action action = node as Nodes.Action;

            if (action == null)
            {
                return;
            }

            stream.WriteLine("{0}\t\tprotected override EBTStatus update_impl(behaviac.Agent pAgent, behaviac.EBTStatus childStatus)", indent);
            stream.WriteLine("{0}\t\t{{", indent);

            string resultStatus = getResultOptionStr(action.ResultOption);

            if (action.Method != null && !isNullMethod(action.Method))
            {
                string nativeReturnType = DataCsExporter.GetGeneratedNativeType(action.Method.NativeReturnType);
                string method           = MethodCsExporter.GenerateCode(node, action.Method, stream, indent + "\t\t\t", string.Empty, string.Empty, "method");

                if ("behaviac.EBTStatus" == nativeReturnType)
                {
                    resultStatus = "result";

                    stream.WriteLine("{0}\t\t\t{1} result = {2};", indent, nativeReturnType, method);
                    MethodCsExporter.PostGenerateCode(action.Method, stream, indent + "\t\t\t", string.Empty, string.Empty, "method");
                }
                else
                {
                    if (("void" == nativeReturnType) || (EBTStatus.BT_INVALID != action.ResultOption) || action.ResultFunctor == null)
                    {
                        stream.WriteLine("{0}\t\t\t{1};", indent, method);
                    }
                    else
                    {
                        stream.WriteLine("{0}\t\t\t{1} result = {2};", indent, nativeReturnType, method);
                    }

                    MethodCsExporter.PostGenerateCode(action.Method, stream, indent + "\t\t\t", string.Empty, string.Empty, "method");

                    if (EBTStatus.BT_INVALID != action.ResultOption)
                    {
                        resultStatus = getResultOptionStr(action.ResultOption);
                    }
                    else if (Plugin.IsMatchedStatusMethod(action.Method, action.ResultFunctor))
                    {
                        if ("void" == nativeReturnType)
                        {
                            resultStatus = MethodCsExporter.GenerateCode(node, action.ResultFunctor, stream, indent + "\t\t\t", string.Empty, string.Empty, "functor");
                        }
                        else
                        {
                            string agentName = "pAgent";

                            if (action.ResultFunctor.Owner != VariableDef.kSelf &&
                                (!action.ResultFunctor.IsPublic || !action.ResultFunctor.IsStatic))
                            {
                                string instanceName = action.ResultFunctor.Owner.Replace("::", ".");
                                agentName = "pAgent_functor";

                                stream.WriteLine("{0}behaviac.Agent {1} = behaviac.Utils.GetParentAgent(pAgent, \"{2}\");", indent, agentName, instanceName);
                                //stream.WriteLine("{0}Debug.Check(!System.Object.ReferenceEquals({1}, null) || Utils.IsStaticClass(\"{2}\"));", indent, agentName, instanceName);
                            }

                            if (action.ResultFunctor.IsPublic)
                            {
                                string className = action.ResultFunctor.ClassName.Replace("::", ".");

                                if (action.ResultFunctor.IsStatic)
                                {
                                    resultStatus = string.Format("{0}.{1}(result)", className, action.ResultFunctor.BasicName);
                                }
                                else
                                {
                                    resultStatus = string.Format("(({0}){1}).{2}(result)", className, agentName, action.ResultFunctor.BasicName);
                                }
                            }
                            else
                            {
                                resultStatus = string.Format("AgentMetaVisitor.ExecuteMethod({0}, \"{1}\", new object[] {{ result }})", agentName, action.ResultFunctor.BasicName);
                            }
                        }

                        resultStatus = string.Format("(EBTStatus){0}", resultStatus);
                    }
                }
            }

            stream.WriteLine("{0}\t\t\treturn {1};", indent, resultStatus);
            stream.WriteLine("{0}\t\t}}", indent);
        }
Esempio n. 11
0
 protected override bool ShouldGenerateClass(Node node)
 {
     Nodes.Action action = node as Nodes.Action;
     return(action != null);
 }
Esempio n. 12
0
        private static void parseStringValue(List <Nodes.Node.ErrorCheck> result, DefaultObject node, object obj, Type type, string paramName, string str, int startIndex, int endIndex)
        {
            string propertyName  = string.Empty;
            string propertyValue = string.Empty;

            try {
                if (startIndex >= endIndex)
                {
                    return;
                }

                if (!string.IsNullOrEmpty(str))
                {
                    if (startIndex < str.Length && str[startIndex] == '{')
                    {
                        startIndex++;

                        if (endIndex < str.Length && str[endIndex] == '}')
                        {
                            endIndex--;
                        }
                    }
                }

                int valueIndex = getProperty(str, startIndex, endIndex, out propertyName, out propertyValue);

                //if (propertyName == "code")
                //{
                //    Debug.Check(true);
                //}

                if (valueIndex >= 0)
                {
                    Debug.Check(!string.IsNullOrEmpty(propertyName));

                    DesignerPropertyInfo property;

                    if (getPropertyInfo(type, propertyName, out property))
                    {
                        // Primitive type
                        if (string.IsNullOrEmpty(propertyValue) || propertyValue[0] != '{')
                        {
                            MethodDef.Param parParam = null;
                            Nodes.Action    action   = node as Nodes.Action;

                            if (action != null)
                            {
                                MethodDef method = action.Method;

                                if (method != null)
                                {
                                    string pn = "";
                                    if (paramName == null)
                                    {
                                        pn = propertyName;
                                    }

                                    parParam = method.GetParam(pn, type, obj, property);
                                }
                            }

                            bool     bParamFromStruct = false;
                            string[] tokens           = Plugin.Split(propertyValue, ' ');

                            if (tokens != null && tokens.Length > 1)
                            {
                                //par
                                if (parParam != null)
                                {
                                    int propertyNameIndex = 1;

                                    if (tokens.Length == 2)
                                    {
                                        propertyNameIndex = 1;
                                    }
                                    else if (tokens.Length == 3)
                                    {
                                        Debug.Check(tokens[0] == "static");
                                        propertyNameIndex = 2;
                                    }
                                    else
                                    {
                                        Debug.Check(false);
                                    }

                                    parParam.Value   = DesignerMethodEnum.setParameter(result, node, tokens[propertyNameIndex]);
                                    bParamFromStruct = true;
                                }
                            }

                            if (!bParamFromStruct)
                            {
                                property.SetValueFromString(result, obj, propertyValue, node);

                                if (parParam != null && parParam.Value == null)
                                {
                                    parParam.Value = property.GetValue(obj);
                                }
                            }
                        }

                        // Struct type
                        else
                        {
                            object member = property.GetValue(obj);
                            Debug.Check(member != null);

                            string structStr = str.Substring(valueIndex + 1, propertyValue.Length - 2);
                            parseStringValue(result, node, member, member.GetType(), paramName, structStr, 0, structStr.Length - 1);
                        }
                    }

                    // Parse next property
                    parseStringValue(result, node, obj, type, paramName, str, valueIndex + propertyValue.Length + 1, str.Length - 1);
                }
            } catch (Exception ex) {
                string msg = string.Format("{0}\n{1}:{2}", ex.Message, propertyName, propertyValue);
                MessageBox.Show(msg, Resources.LoadError, MessageBoxButtons.OK);
            }
        }
Esempio n. 13
0
        protected override void GenerateMethod(Node node, StringWriter stream, string indent)
        {
            base.GenerateMethod(node, stream, indent);

            Nodes.Action action = node as Nodes.Action;

            if (action == null)
            {
                return;
            }

            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);

            string resultStatus = "BT_SUCCESS";

            if (action.Method != null)
            {
                string method = MethodCppExporter.GenerateCode(node, action.Method, stream, indent + "\t\t\t", string.Empty, string.Empty, "method");

                if ("behaviac::EBTStatus" == action.Method.NativeReturnType)
                {
                    stream.WriteLine("{0}\t\t\t{1} result = {2};", indent, action.Method.NativeReturnType, method);
                    resultStatus = "result";

                    MethodCppExporter.PostGenerateCode(action.Method, stream, indent + "\t\t\t", string.Empty, string.Empty, "method");
                }
                else
                {
                    if (("void" == action.Method.NativeReturnType) || (EBTStatus.BT_INVALID != action.ResultOption) || action.ResultFunctor == null)
                    {
                        stream.WriteLine("{0}\t\t\t{1};", indent, method);
                    }
                    else
                    {
                        stream.WriteLine("{0}\t\t\t{1} result = {2};", indent, action.Method.NativeReturnType, method);
                    }

                    MethodCppExporter.PostGenerateCode(action.Method, stream, indent + "\t\t\t", string.Empty, string.Empty, "method");

                    if (EBTStatus.BT_INVALID != action.ResultOption)
                    {
                        resultStatus = action.ResultOption.ToString();
                    }
                    else if (Plugin.IsMatchedStatusMethod(action.Method, action.ResultFunctor))
                    {
                        if ("void" == action.Method.NativeReturnType)
                        {
                            resultStatus = MethodCppExporter.GenerateCode(node, action.ResultFunctor, stream, indent + "\t\t\t", string.Empty, string.Empty, "functor");
                        }
                        else
                        {
                            string agentName = "pAgent";

                            if (action.ResultFunctor.Owner != VariableDef.kSelf)
                            {
                                agentName = "pAgent_functor";

                                stream.WriteLine("{0}Agent* {1} = Agent::GetInstance(pAgent, \"{2}\");", indent, agentName, action.ResultFunctor.Owner);
                                stream.WriteLine("{0}BEHAVIAC_ASSERT({1});", indent, agentName);
                            }

                            resultStatus = string.Format("(({0}*){1})->{2}(result)", action.ResultFunctor.ClassName, agentName, action.ResultFunctor.Name);
                        }
                    }
                }
            }

            stream.WriteLine("{0}\t\t\treturn {1};", indent, resultStatus);
            stream.WriteLine("{0}\t\t}}", indent);
        }