/// <summary>
/// コンストラクタ。
/// </summary>
/// <param name="message">メッセージプロバイダのインスタンス。</param>
/// <param name="project">プロジェクト情報のインスタンス。</param>
/// <param name="definition">データベース定義情報のインスタンス。</param>
public DatabaseDefinitionValidator(
MessageProvider message,
WarlockProject project,
DatabaseDefinition definition)
: base(message)
{
Project = project;
Definition = definition;
}
/// <summary>
/// 指定したデータベース定義を使用しているクラス定義エディタを開いているかチェックし、開いているなら該当するクラス定義エディタのインスタンスを返す。
/// </summary>
/// <param name="definition">データベース定義のインスタンス。</param>
/// <returns>指定したデータベース定義を使用したクラス定義エディタを開いている場合はクラス定義エディタのインスタンスを返す。</returns>
private List<ClassDefinitionEditorTab> FindEdittingClassDefinitionEditors(DatabaseDefinition definition)
{
var ret = new List<ClassDefinitionEditorTab>();
foreach (var editor in MainForm.GetClassDefinitionEditors())
{
if (editor.Definition.IsUsingDatabase(definition, Project))
{
ret.Add(editor);
}
}
return ret;
}
/// <summary>
/// コンストラクタ。
/// </summary>
/// <param name="node">データベースノードのインスタンス。</param>
public DatabaseProperty(DatabaseTreeNode node)
: base(node)
{
Definition = (DatabaseDefinition)node.Tag;
Name = Definition.Name;
Func<TreeNode, ProjectTreeNode> recursive = null;
recursive = (parent) =>
{
if (parent == null) return null;
if (parent is ProjectTreeNode) return (ProjectTreeNode)parent;
return recursive(parent.Parent);
};
Project = (WarlockProject)recursive(node).Tag;
try
{
var data = Project.LoadDatabase(Definition);
if (data is DatabaseClassData)
{
_DataCount = 1;
}
else if (data is List<dynamic>)
{
_DataCount = (
from d in (List<dynamic>)data
where d != null
select d
).Count();
}
else if (data is Dictionary<dynamic, dynamic>)
{
_DataCount = (
from d in (Dictionary<dynamic, dynamic>)data
where d.Value != null
select d
).Count();
}
}
catch (Exception) { }
}
/// <summary>
/// 定義情報の更新を行う。
/// </summary>
public override bool ApplyData()
{
if (!ValidateInput()) return false;
if (Definition == null)
{
Definition = new DatabaseDefinition();
Project.DatabaseDefinitions.Add(Definition);
}
Definition.Name = ctlName.Text;
Definition.File = ctlFile.Text;
Definition.Mode = (DatabaseMode)ctlMode.SelectedValue;
Definition.Editors.Clear();
Definition.Editors.Add(((PluginListItem)ctlEditorType.SelectedItem).Value);
dynamic selectedDataClass = ctlDataClass.SelectedValue;
if (selectedDataClass == null)
{
Definition.DataClass = null;
}
else if (selectedDataClass is ClassDefinition)
{
Definition.DataClass = ((ClassDefinition)selectedDataClass).FullName;
}
else if (selectedDataClass is RubyClassDefinition)
{
Definition.DataClass = ((RubyClassDefinition)selectedDataClass).FullName;
}
else
{
throw new NotImplementedException();
}
if (!InvokeCommand("SaveProject").Parameter["Result"]) return false;
var ret = base.ApplyData();
RefreshCaption();
return ret;
}
/// <summary>
/// クラス定義をデータベース上で使用しているかチェックする。
/// </summary>
/// <param name="databaseDefinition">データベース定義のインスタンス。</param>
/// <param name="project">プロジェクト情報のインスタンス。</param>
/// <returns>クラス定義をデータベース上で使用している場合はtrue。</returns>
public bool IsUsingDatabase(
DatabaseDefinition databaseDefinition,
WarlockProject project)
{
return FindUsingDatabase(project).Contains(databaseDefinition);
}
/// <summary>
/// データベースにデータをセーブする。
/// </summary>
/// <param name="definition">セーブ対象のデータベース定義。</param>
/// <param name="data">保存対象のデータ。</param>
public void SaveDatabase(
DatabaseDefinition definition,
dynamic data)
{
WarlockDatabase.SaveDatabase(
ScriptHost.Engine,
GetDatabaseFullPath(definition.File),
data,
definition.Mode
);
}
/// <summary>
/// データベースからデータをロードする。
/// </summary>
/// <param name="definition">ロード対象のデータベース定義。</param>
/// <returns>データベースのデータ。</returns>
public dynamic LoadDatabase(DatabaseDefinition definition)
{
return WarlockDatabase.LoadDatabase(
ScriptHost.Engine,
GetDatabaseFullPath(definition.File),
definition.Mode
);
}
/// <summary>
/// XMLNodeをデータにデシリアライズする。
/// </summary>
/// <param name="node">復号対象のXMLノード。</param>
public static DatabaseDefinition DeserializeElement(XmlElement node)
{
var ret = new DatabaseDefinition();
XmlAttribute attr;
if (node.Name != "Database")
{
throw new FormatException("データベース定義ノードではありません。");
}
attr = node.Attributes["File"];
if (attr == null)
{
throw new FormatException("ファイル名が未定義です。");
}
ret.File = attr.Value;
attr = node.Attributes["Name"];
if (attr == null)
{
throw new FormatException("名称が未定義です。");
}
ret.Name = attr.Value;
attr = node.Attributes["Mode"];
if (attr == null)
{
throw new FormatException("データベースモードが未定義です。");
}
else
{
try
{
ret.Mode = EnumExtentions.GetDeserializedValue<DatabaseMode>(attr.Value);
}
catch (InvalidCastException)
{
throw new FormatException("未定義のデータベースモードです。");
}
}
attr = node.Attributes["DataClass"];
if (attr == null)
{
throw new FormatException("データクラスが未定義です。");
}
ret.DataClass = attr.Value;
foreach (XmlNode child in node.ChildNodes)
{
var childElement = child as XmlElement;
if (childElement == null) continue;
switch (childElement.Name)
{
case "Editors":
foreach (XmlNode gChild in childElement.ChildNodes)
{
var gChildElement = gChild as XmlElement;
if (gChildElement == null) continue;
attr = gChildElement.Attributes["Type"];
if (attr == null)
{
throw new FormatException("エディタタイプが未定義です。");
}
ret.Editors.Add(attr.Value);
}
break;
default:
throw new FormatException("未定義のエレメントを検出しました。");
}
}
return ret;
}
/// <summary>
/// データベース定義をデータベース上で使用しているかチェックする。
/// </summary>
/// <param name="databaseDefinition">データベース定義のインスタンス。</param>
/// <param name="project">プロジェクト情報のインスタンス。</param>
/// <returns>データベース定義をデータベース上で使用している場合はtrue。</returns>
public bool IsUsingDatabase(
DatabaseDefinition databaseDefinition,
WarlockProject project)
{
if (this.Equals(databaseDefinition)) return true;
return FindUsingDatabase(project).Contains(databaseDefinition);
}
/// <summary>
/// ノードにデータベース定義の内容を反映する。
/// </summary>
/// <param name="definition">データベース定義のインスタンス。</param>
private void Refresh(DatabaseDefinition definition)
{
Text = definition.Name;
Tag = definition;
}
/// <summary>
/// ノードを生成する。
/// </summary>
/// <param name="definition">データベース定義のインスタンス。</param>
/// <returns>生成したツリーノード。</returns>
public static DatabaseTreeNode Create(DatabaseDefinition definition)
{
var ret = new DatabaseTreeNode();
ret.ImageKey = "DatabaseIcon.ico";
ret.SelectedImageKey = ret.ImageKey;
ret.Refresh(definition);
return ret;
}
/// <summary>
/// すでに開かれているデータベースエディタを検索する。
/// </summary>
/// <param name="definition">定義情報のインスタンス。</param>
/// <param name="parameters">パラメータ。</param>
/// <returns>データベースのエディタが開かれていればエディタのインスタンス。</returns>
private DatabaseEditorTab FindDatabaseEditor(DatabaseDefinition definition)
{
return MainForm.FindDatabaseEditor(definition);
}
/// <summary>
/// データベースエディタをコントローラへ登録し、開く。
/// </summary>
/// <param name="definition">対象定義のインスタンス。</param>
/// <param name="parameters">固有パラメータ。</param>
private void RegisterDatabaseEditor(
DatabaseDefinition definition,
KeyValueMap parameters)
{
var editorType = PluginUtil.GetPluginType(definition.Editors.First());
if (editorType == null)
{
ProvideMessage("Database.Editor.NotFound.Error");
return;
}
DatabaseEditorTab tab = null;
tab = FindDatabaseEditor(definition);
if (tab != null)
{
tab.Activate();
return;
}
tab = (DatabaseEditorTab)editorType.InvokeMember(
null,
BindingFlags.CreateInstance,
null, null, null
);
tab.Project = Project;
tab.Definition = definition;
tab.Parameters = parameters;
tab.FormClosed += DatabaseEditor_FormClosed;
// データベースのロード
var databasePath = Project.GetDatabaseFullPath(definition.File);
if (File.Exists(databasePath))
{
try
{
tab.Data = Project.LoadDatabase(definition);
}
catch (Exception)
{
ProvideMessage("Database.Editor.Data.Load.Error");
tab.DataBroken = true;
}
}
MainForm.ShowContent(tab, DockState.Document);
}
/// <summary>
/// データベースノードのリフレッシュを行う。
/// </summary>
/// <param name="definition">データベース定義のインスタンス。</param>
private void RefreshDatabaseNode(DatabaseDefinition definition)
{
if (ProjectExplorer != null)
{
ProjectExplorer.RefreshDatabaseNode(definition);
}
}
