/// <summary>
 /// クラスノードのリフレッシュを行う。
 /// </summary>
 /// <param name="definition">クラス定義のインスタンス。</param>
 private void RefreshClassNode(ClassDefinition definition)
 {
     if (ProjectExplorer != null)
     {
         ProjectExplorer.RefreshClassNode(definition);
     }
 }
示例#2
0
        /// <summary>
        /// コンストラクタ。
        /// </summary>
        /// <param name="node">クラスノードのインスタンス。</param>
        public ClassProperty(ClassTreeNode node)
            : base(node)
        {
            Definition = (ClassDefinition)node.Tag;

            Name = Definition.Name;
            Namespace = Definition.Namespace;
        }
 /// <summary>
 /// コンストラクタ。
 /// </summary>
 /// <param name="message">メッセージプロバイダのインスタンス。</param>
 /// <param name="project">プロジェクト情報のインスタンス。</param>
 /// <param name="definition">クラス定義情報のインスタンス。</param>
 public ClassDefinitionValidator(
     MessageProvider message,
     WarlockProject project,
     ClassDefinition definition)
     : base(message)
 {
     Project = project;
     Definition = definition;
 }
        /// <summary>
        /// 定義情報の更新を行う。
        /// </summary>
        public override bool ApplyData()
        {
            if (!ValidateInput()) return false;

            if (Definition == null)
            {
                Definition = new ClassDefinition();
                Definition.Guid = Project.NewScriptGuid();

                Project.ClassDefinitions.Add(Definition);
            }

            Definition.Name = ctlName.Text;
            Definition.Namespace = ctlNamespace.Text;

            Definition.Extends = (string)ctlExtends.SelectedValue;
            Definition.RequiredIdentifier = ctlRequiredIdentifier.Checked;

            var accessorList = (DataTable)ctlAccessorList.DataSource;
            foreach (var accessor in Definition.Accessors.ToArray())
            {
                Definition.Accessors.Remove(accessor);
            }

            foreach (DataRow row in accessorList.Rows)
            {
                if (IsBlankAccessorRow(row)) continue;
                if (row.Field<dynamic>("Extends") is ClassDefinition) continue;

                var accessor = new AccessorDefinition()
                {
                    Name = row.Field<string>("Name"),
                    DisplayName = row.Field<string>("DisplayName"),
                    ValueType = row.Field<string>("ValueType"),
                    ArrayValue = row.Field<bool?>("ArrayValue") ?? false
                };

                if (String.IsNullOrEmpty(accessor.DisplayName))
                {
                    accessor.DisplayName = accessor.Name;
                }

                Definition.Accessors.Add(accessor);
            }

            if (!InvokeCommand("SaveProject").Parameter["Result"]) return false;

            var ret = base.ApplyData();

            RefreshCaption();

            return ret;
        }
        /// <summary>
        /// 指定したクラス定義に該当するクラス定義エディタを開いているかチェックし、開いているなら該当するクラス定義エディタのインスタンスを返す。
        /// </summary>
        /// <param name="definition">クラス定義のインスタンス。</param>
        /// <returns>指定したクラス定義を使用したクラス定義エディタを開いている場合はクラス定義エディタのインスタンスを返す。</returns>
        private List<ClassDefinitionEditorTab> FindEdittingClassDefinitionEditors(ClassDefinition definition)
        {
            var ret = new List<ClassDefinitionEditorTab>();

            foreach (var editor in MainForm.GetClassDefinitionEditors())
            {
                if (editor.Definition.IsUsingClass(definition, Project))
                {
                    ret.Add(editor);
                }
            }

            return ret;
        }
示例#6
0
        /// <summary>フォームロード時処理</summary>
        private void ClassLinkSettingDialog_Load(object sender, EventArgs e)
        {
            var items = new List<ListItem>();

            items.Add(
                new ListItem()
                {
                    Text = "(なし)",
                    Value = null
                }
            );

            foreach (var definition in Project.ClassDefinitions)
            {
                if (definition.Guid == Definition.Guid || !Project.ExistsClassLink(definition))
                {
                    items.Add(
                        new ListItem()
                        {
                            Text = definition.Name,
                            Value = definition
                        }
                    );

                    if (definition.Guid == Definition.Guid)
                    {
                        LinkageDefinition = definition;
                    }
                }
            }

            ctlLinkageClass.DataSource = items;

            if (LinkageDefinition != null)
            {
                ctlLinkageClass.SelectedValue = LinkageDefinition;
            }
            else
            {
                ctlLinkageClass.SelectedIndex = 0;
            }
        }
示例#7
0
 /// <summary>
 /// ノードにクラス定義の内容を反映する。
 /// </summary>
 /// <param name="definition">クラス定義のインスタンス。</param>
 private void Refresh(ClassDefinition definition)
 {
     Text = definition.FullName;
     Tag = definition;
 }
示例#8
0
        /// <summary>
        /// ノードを生成する。
        /// </summary>
        /// <param name="definition">クラス定義のインスタンス。</param>
        /// <returns>生成したツリーノード。</returns>
        public static ClassTreeNode Create(ClassDefinition definition)
        {
            var ret = new ClassTreeNode();

            ret.ImageKey = "ClassIcon.ico";
            ret.SelectedImageKey = ret.ImageKey;
            ret.Refresh(definition);

            return ret;
        }
示例#9
0
 /// <summary>
 /// クラス定義をクラス上で使用しているかチェックする。
 /// </summary>
 /// <param name="databaseDefinition">データベース定義のインスタンス。</param>
 /// <param name="project">プロジェクト情報のインスタンス。</param>
 /// <returns>クラス定義をクラス上で使用している場合はtrue。</returns>
 public bool IsUsingClass(
     ClassDefinition classDefinition,
     WarlockProject project)
 {
     return FindUsingClass(project).Contains(classDefinition);
 }
示例#10
0
        /// <summary>
        /// XMLNodeをデータにデシリアライズする。
        /// </summary>
        /// <param name="node">復号対象のXMLノード。</param>
        public static ClassDefinition DeserializeElement(XmlElement node)
        {
            var ret = new ClassDefinition();
            XmlAttribute attr;

            if (node.Name != "Class")
            {
                throw new FormatException("クラス定義ノードではありません。");
            }

            attr = node.Attributes["Guid"];
            if (attr == null)
            {
                throw new FormatException("IDが未定義です。");
            }
            ret.Guid = int.Parse(attr.Value);

            attr = node.Attributes["Name"];
            if (attr == null)
            {
                throw new FormatException("名称が未定義です。");
            }
            ret.Name = attr.Value;

            attr = node.Attributes["Namespace"];
            if (attr != null)
            {
                ret.Namespace = attr.Value;
            }

            attr = node.Attributes["Extends"];
            if (attr != null)
            {
                ret.Extends = attr.Value;
            }

            attr = node.Attributes["RequiredIdentifier"];
            if (attr != null)
            {
                ret.RequiredIdentifier = bool.Parse(attr.Value);
            }

            foreach (XmlNode child in node.ChildNodes)
            {
                var childElement = child as XmlElement;
                if (childElement == null) continue;

                switch (childElement.Name)
                {
                    case "Accessors":
                        foreach (XmlNode gChild in childElement.ChildNodes)
                        {
                            var gChildElement = gChild as XmlElement;
                            if (gChildElement == null) continue;

                            ret.Accessors.Add(AccessorDefinition.DeserializeElement(gChildElement));
                        }

                        break;
                    default:
                        throw new FormatException("未定義のエレメントを検出しました。");
                }
            }

            return ret;
        }
示例#11
0
 /// <summary>
 /// クラス定義にスクリプト定義とのリンクが存在するかチェックする。
 /// </summary>
 /// <param name="classDefinition">クラス定義のインスタンス。</param>
 /// <returns></returns>
 public bool ExistsClassLink(ClassDefinition classDefinition)
 {
     return (
         from d in GetScriptDefinitionList()
         where d.Guid == classDefinition.Guid
         select d
     ).Count() > 0;
 }
        /// <summary>ロードイベントsummary>
        private void DefaultDatabaseEditorTab_Load(object sender, EventArgs e)
        {
            InvokeCommand(
                "LoadMessage",
                new KeyValueMap()
                {
                    {"Xml", Resources.MessageResource}
                }
            );

            ClassDefinition = Project.FindClassDefinition(Definition.DataClass);
            if (ClassDefinition == null)
            {
                LoadError = "Plugins.DefaultEditor.DataClass.NotFound.Error";
                DialogResult = DialogResult.Abort;

                return;
            }

            Text = Definition.Name;

            SetupEditors();

            switch (Definition.Mode)
            {
                case DatabaseMode.Single:
                    ctlDataListArea.Visible = false;
                    LoadEditorValues(SingleData);

                    break;
                case DatabaseMode.Array:
                    ctlDataListArea.Visible = true;
                    if (ArrayDatas.Count == 0)
                    {
                        ArrayDatas.Add(null);
                        for (int i = 0; i < InitialArraySize; i++)
                        {
                            var data = CreateClassData();
                            data.Variables["id"] = i + 1;

                            ArrayDatas.Add(data);
                        }
                    }
                    RefreshDataListItems();
                    ctlDataList.SelectedIndex = 0;

                    break;
                default:
                    LoadError = "Plugins.DefaultEditor.Mode.Invalid.Error";
                    DialogResult = DialogResult.Abort;

                    return;
            }

            AddChangeHandlers();
        }
示例#13
0
        /// <summary>
        /// クラスデータを生成する。
        /// </summary>
        /// <param name="classDefinition">クラス定義のインスタンス。</param>
        /// <returns>初期値が設定されたクラスデータ。</returns>
        protected DatabaseClassData CreateClassData(ClassDefinition classDefinition)
        {
            if (classDefinition == null)
            {
                return null;
            }

            var ret = new DatabaseClassData()
            {
                ClassName = classDefinition.FullName
            };

            foreach (var accessor in classDefinition.Accessors)
            {
                dynamic value = null;

                if (!accessor.ArrayValue)
                {
                    switch (accessor.ValueType)
                    {
                        case "*String":
                        case "*MultiLineString":
                            value = "";

                            break;
                        case "*Integer":
                            value = 0;

                            break;
                        case "*Float":
                            value = 0F;

                            break;
                        case "*Boolean":
                            value = false;

                            break;
                        default:
                            value = 0;

                            break;
                    }
                }
                else
                {
                    value = new List<dynamic>();
                }

                ret.Variables.Add(String.Format("{0}", accessor.Name), value);
            }

            return ret;
        }