private void typeComboBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (this.GetMetaType() == MetaTypes.Agent)
            {
                if (_customizedAgent == null)
                {
                    _customizedAgent = new AgentType(this.nameTextBox.Text, null, this.dispTextBox.Text, this.descTextBox.Text);
                }
            }
            else if (this.GetMetaType() == MetaTypes.Enum)
            {
                if (_customizedEnum == null)
                {
                    _customizedEnum = new CustomizedEnum(this.nameTextBox.Text, this.dispTextBox.Text, this.descTextBox.Text);
                }
            }
            else if (this.GetMetaType() == MetaTypes.Struct)
            {
                if (_customizedStruct == null)
                {
                    _customizedStruct = new CustomizedStruct(this.nameTextBox.Text, this.dispTextBox.Text, this.descTextBox.Text);
                }
            }

            resetBaseTypes();

            if (_initialized)
            {
                this.IsModified = true;
            }
        }
        public EditEnumMemberDialog(CustomizedEnum customizedEnum, CustomizedEnum.CustomizedEnumMember enumMember)
        {
            InitializeComponent();

            this.Owner = MainWindow.Instance;
            this.Text  = (enumMember == null) ? Resources.AddEnumMember : Resources.EditEnumMember;

            this.editEnumMemberPanel.Initialize(customizedEnum, enumMember);
        }
        public void Initialize(CustomizedEnum customizedEnum, CustomizedEnum.CustomizedEnumMember enumMember)
        {
            _initialized    = false;
            _isModified     = false;
            _customizedEnum = customizedEnum;
            _originalMember = enumMember;
            if (enumMember == null)
            {
                _isNew      = true;
                _enumMember = new CustomizedEnum.CustomizedEnumMember(enumMember);
            }
            else
            {
                _isNew      = false;
                _enumMember = enumMember;
            }

            this.nameTextBox.Text         = _enumMember.Name;
            this.valueNumericUpDown.Value = _enumMember.Value;
            this.dispTextBox.Text         = _enumMember.DisplayName;
            this.descTextBox.Text         = _enumMember.Description;

            _initialized = true;
        }
        public void Initialize(object typeObject)
        {
            _initialized = false;
            _isModified  = false;
            _isNew       = (typeObject == null);
            this.Text    = _isNew ? Resources.AddType : Resources.EditType;

            MetaTypes metaType = MetaTypes.Agent;

            if (typeObject != null)
            {
                if (typeObject is AgentType)
                {
                    metaType         = MetaTypes.Agent;
                    _customizedAgent = typeObject as AgentType;
                }
                else if (typeObject is CustomizedEnum)
                {
                    metaType        = MetaTypes.Enum;
                    _customizedEnum = typeObject as CustomizedEnum;
                }
                else if (typeObject is CustomizedStruct)
                {
                    metaType          = MetaTypes.Struct;
                    _customizedStruct = typeObject as CustomizedStruct;
                }
            }

            this.typeComboBox.Items.Clear();
            this.typeComboBox.Enabled = _isNew;
            foreach (string type in Enum.GetNames(typeof(MetaTypes)))
            {
                this.typeComboBox.Items.Add(type);
            }
            this.typeComboBox.SelectedIndex = (int)metaType;

            if (this.GetMetaType() == MetaTypes.Agent)
            {
                Debug.Check(_customizedAgent != null);

                if (_customizedAgent.Base != null)
                {
                    this.baseComboBox.SelectedText = _customizedAgent.Base.AgentTypeName;
                }

                this.nameTextBox.Text = _customizedAgent.AgentTypeName;
                this.dispTextBox.Text = _customizedAgent.DisplayName;
                this.descTextBox.Text = _customizedAgent.Description;

                this.typeComboBox.Enabled = _customizedAgent.IsCustomized;
                this.nameTextBox.Enabled  = _customizedAgent.IsCustomized;
                this.baseComboBox.Enabled = _customizedAgent.IsCustomized;
                this.dispTextBox.Enabled  = _customizedAgent.IsCustomized;
                this.descTextBox.Enabled  = _customizedAgent.IsCustomized;
            }
            else
            {
                if (this.GetMetaType() == MetaTypes.Enum)
                {
                    Debug.Check(_customizedEnum != null);

                    this.nameTextBox.Text = _customizedEnum.Name;
                    this.dispTextBox.Text = _customizedEnum.DisplayName;
                    this.descTextBox.Text = _customizedEnum.Description;
                }
                else if (this.GetMetaType() == MetaTypes.Struct)
                {
                    Debug.Check(_customizedStruct != null);

                    this.nameTextBox.Text = _customizedStruct.Name;
                    this.dispTextBox.Text = _customizedStruct.DisplayName;
                    this.descTextBox.Text = _customizedStruct.Description;
                }

                this.typeComboBox.Enabled = true;
                this.nameTextBox.Enabled  = true;
                this.baseComboBox.Enabled = true;
                this.dispTextBox.Enabled  = true;
                this.descTextBox.Enabled  = true;
            }

            this.nameTextBox.Focus();
            this.nameTextBox.SelectionStart = this.nameTextBox.TextLength;

            _initialized = true;
        }
Beispiel #5
0
        private void ExportCustomizedTypes(string agentFolder)
        {
            if (CustomizedTypeManager.Instance.Enums.Count > 0 || CustomizedTypeManager.Instance.Structs.Count > 0)
            {
                string   filename    = Path.Combine(agentFolder, "customizedtypes.cs");
                Encoding utf8WithBom = new UTF8Encoding(true);

                using (StreamWriter file = new StreamWriter(filename, false, utf8WithBom))
                {
                    // write comments
                    file.WriteLine("// ---------------------------------------------------------------------");
                    file.WriteLine("// This file is auto-generated by behaviac designer, so please don't modify it by yourself!");
                    file.WriteLine("// ---------------------------------------------------------------------\n");

                    file.WriteLine("using System.Collections;");
                    file.WriteLine("using System.Collections.Generic;");
                    file.WriteLine();

                    //file.WriteLine("namespace behaviac");
                    //file.WriteLine("{");

                    file.WriteLine("// -------------------");
                    file.WriteLine("// Customized enums");
                    file.WriteLine("// -------------------\n");

                    for (int e = 0; e < CustomizedTypeManager.Instance.Enums.Count; ++e)
                    {
                        if (e > 0)
                        {
                            file.WriteLine();
                        }

                        CustomizedEnum customizedEnum = CustomizedTypeManager.Instance.Enums[e];
                        file.WriteLine("[behaviac.TypeMetaInfo(\"{0}\", \"{1}\")]", customizedEnum.DisplayName, customizedEnum.Description);

                        file.WriteLine("public enum {0}", customizedEnum.Name);
                        file.WriteLine("{");

                        for (int m = 0; m < customizedEnum.Members.Count; ++m)
                        {
                            if (m > 0)
                            {
                                file.WriteLine();
                            }

                            CustomizedEnum.CustomizedEnumMember member = customizedEnum.Members[m];
                            if (member.DisplayName != member.Name || !string.IsNullOrEmpty(member.Description))
                            {
                                file.WriteLine("\t[behaviac.MemberMetaInfo(\"{0}\", \"{1}\")]", member.DisplayName, member.Description);
                            }

                            if (member.Value >= 0)
                            {
                                file.WriteLine("\t{0} = {1},", member.Name, member.Value);
                            }
                            else
                            {
                                file.WriteLine("\t{0},", member.Name);
                            }
                        }

                        file.WriteLine("}");
                    }

                    if (CustomizedTypeManager.Instance.Enums.Count > 0)
                    {
                        file.WriteLine();
                    }

                    file.WriteLine("// -------------------");
                    file.WriteLine("// Customized structs");
                    file.WriteLine("// -------------------\n");

                    for (int s = 0; s < CustomizedTypeManager.Instance.Structs.Count; s++)
                    {
                        if (s > 0)
                        {
                            file.WriteLine();
                        }

                        CustomizedStruct customizedStruct = CustomizedTypeManager.Instance.Structs[s];
                        file.WriteLine("[behaviac.TypeMetaInfo(\"{0}\", \"{1}\")]", customizedStruct.DisplayName, customizedStruct.Description);

                        file.WriteLine("public struct {0}", customizedStruct.Name);
                        file.WriteLine("{");

                        for (int m = 0; m < customizedStruct.Properties.Count; ++m)
                        {
                            if (m > 0)
                            {
                                file.WriteLine();
                            }

                            PropertyDef member = customizedStruct.Properties[m];
                            if (member.DisplayName != member.Name || !string.IsNullOrEmpty(member.BasicDescription))
                            {
                                file.WriteLine("\t[behaviac.MemberMetaInfo(\"{0}\", \"{1}\")]", member.DisplayName, member.BasicDescription);
                            }

                            file.WriteLine("\tpublic {0} {1};", DataCsExporter.GetGeneratedNativeType(member.NativeType), member.BasicName);
                        }

                        file.WriteLine("}");
                    }

                    //file.WriteLine("}");
                }
            }
        }