/// <summary>
/// コンストラクタ。
/// </summary>
/// <param name="message">メッセージプロバイダのインスタンス。</param>
/// <param name="project">プロジェクト情報のインスタンス。</param>
public AccessorDefinitionValidator(
MessageProvider message,
WarlockProject project)
: base(message)
{
Project = project;
}
/// <summary>
/// コンストラクタ。
/// </summary>
/// <param name="message">メッセージプロバイダのインスタンス。</param>
/// <param name="project">プロジェクト情報のインスタンス。</param>
public ProjectValidator(
MessageProvider message,
WarlockProject project)
: base(message)
{
Project = project;
}
/// <summary>
/// コンストラクタ。
/// </summary>
/// <param name="node">プロジェクトノードのインスタンス。</param>
public ProjectProperty(ProjectTreeNode node)
: base(node)
{
Project = (WarlockProject)node.Tag;
Name = Project.Name;
ProjectFileName = Path.GetFileName(Project.FileName);
}
/// <summary>
/// コンストラクタ。
/// </summary>
/// <param name="message">メッセージプロバイダのインスタンス。</param>
/// <param name="project">プロジェクト情報のインスタンス。</param>
/// <param name="definition">スクリプト定義情報のインスタンス。</param>
public ScriptDefinitionValidator(
MessageProvider message,
WarlockProject project,
ScriptDefinition definition)
: base(message)
{
Project = project;
Definition = definition;
}
/// <summary>
/// ツリービューをリフレッシュする。
/// </summary>
/// <param name="objectDefinitions">オブジェクト定義の一覧。</param>
/// <param name="objectDefinitionMap">オブジェクト定義のマップ。</param>
public void RefreshTreeView(WarlockProject project)
{
ctlTreeView.Nodes.Clear();
if (project == null) return;
if (project.ObjectDefinitions == null) return;
foreach (var definition in project.ObjectDefinitions)
{
ctlTreeView.Nodes.Add(RubyTreeNode.Create(definition, project.ObjectDefinitionMap));
}
}
/// <summary>
/// ノードを生成する。
/// </summary>
/// <param name="definitions">クラス定義のList。</param>
/// <returns>生成したツリーノード。</returns>
public static ClassRootTreeNode Create(WarlockProject project)
{
var ret = new ClassRootTreeNode()
{
Text = "クラス定義"
};
ret.ImageKey = "ClassRootIcon.ico";
ret.SelectedImageKey = ret.ImageKey;
ret.Tag = project;
ret.Refresh(project.ClassDefinitions);
return ret;
}
/// <summary>
/// ノードを生成する。
/// </summary>
/// <param name="project">スクリプト定義のList。</param>
/// <returns>生成したツリーノード。</returns>
public static ScriptRootTreeNode Create(WarlockProject project)
{
var ret = new ScriptRootTreeNode()
{
Text = "スクリプト"
};
ret.ImageKey = "ScriptRootIcon.ico";
ret.SelectedImageKey = ret.ImageKey;
ret.Tag = project;
ret.Refresh(project.ScriptDefinitions);
return ret;
}
/// <summary>
/// ノードを生成する。
/// </summary>
/// <param name="definitions">データベース定義のList。</param>
/// <returns>生成したツリーノード。</returns>
public static DatabaseRootTreeNode Create(WarlockProject project)
{
var ret = new DatabaseRootTreeNode()
{
Text = "データベース"
};
ret.ImageKey = "DatabaseRootIcon.ico";
ret.SelectedImageKey = ret.ImageKey;
ret.Tag = project;
ret.Refresh(project.DatabaseDefinitions);
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>
/// <param name="project">プロジェクト情報のインスタンス。</param>
/// <param name="file">データベースファイル名。</param>
/// <returns>データベースアイテムのリスト。</returns>
public static List<ListItem> CreateDatabaseItemList(
WarlockProject project,
string file)
{
try
{
var itemDefinition = project.FindDatabaseDefinition(file);
if (itemDefinition == null)
{
return new List<ListItem>();
}
List<dynamic> items = project.LoadDatabase(itemDefinition);
var ret = new List<ListItem>();
foreach (var i in items)
{
DatabaseClassData item = i;
if (item == null) continue;
ret.Add(new ListItem()
{
Text = String.Format(
String.Format(
"{{0:{0}}}:{{1}}",
new String('0', (items.Count - 1).ToString().Length)
),
item.Variables["id"],
item.Variables["name"]
),
Value = item.Variables["id"]
});
}
return ret;
}
catch
{
return new List<ListItem>();
}
}
/// <summary>
/// コンストラクタ。
/// </summary>
/// <param name="node">スクリプトノードのインスタンス。</param>
public ScriptPropartyBase(ScriptTreeNode node)
: base(node)
{
Definition = (ScriptDefinition)node.Tag;
Name = Definition.DisplayName;
Func<TreeNode, ProjectTreeNode> recursive = null;
recursive = (parent) =>
{
if (parent == null) return null;
if (parent is ProjectTreeNode) return (ProjectTreeNode)parent;
return recursive(parent.Parent);
};
var projectNode = recursive(node);
if (projectNode != null)
{
Project = (WarlockProject)projectNode.Tag;
}
}
/// <summary>
/// ノードのドロップ処理を行う。
/// </summary>
/// <param name="dragNode">ドラッグ対象のツリーノード。</param>
/// <param name="project">プロジェクト情報のインスタンス。</param>
public override void Drop(WarlockTreeNode dragNode, WarlockProject project)
{
var scriptNode = (ScriptTreeNode)dragNode;
var dragDefinition = (ScriptDefinition)scriptNode.Tag;
var dropDefinition = (ScriptDefinition)this.Tag;
var dragParentNode = scriptNode.Parent;
var dropParentNode = this.Parent;
scriptNode.Remove();
List<ScriptDefinition> dragParentList;
if (dragParentNode is ScriptRootTreeNode)
{
dragParentList = project.ScriptDefinitions;
}
else if (dragParentNode is ScriptTreeNode)
{
var parentDefinition = (ScriptDefinition)dragParentNode.Tag;
dragParentList = parentDefinition.Children;
}
else
{
throw new NotImplementedException();
}
dragParentList.Remove(dragDefinition);
if (dropDefinition.IsFolder)
{
dropDefinition.Children.Add(dragDefinition);
this.Nodes.Add(scriptNode);
if (!this.IsExpanded) this.Expand();
}
else
{
List<ScriptDefinition> dropParentList;
if (dropParentNode is ScriptRootTreeNode)
{
dropParentList = project.ScriptDefinitions;
}
else if (dropParentNode is ScriptTreeNode)
{
var parentDefinition = (ScriptDefinition)dropParentNode.Tag;
dropParentList = parentDefinition.Children;
}
else
{
throw new NotImplementedException();
}
int i = 0;
for (i = 0; i < dropParentList.Count - 1; i++)
{
if (dropParentList[i] == dropDefinition) break;
}
dropParentList.Insert(i, dragDefinition);
dropParentNode.Nodes.Insert(i, scriptNode);
}
}
/// <summary>
/// プロジェクトを新規作成する。
/// </summary>
/// <param name="fileName">新規作成するプロジェクトのファイル名。</param>
private void CreateProject(string fileName)
{
try
{
if (!CloseProject()) return;
Console.Clear();
Project = new WarlockProject()
{
FileName = fileName
};
Project.Initialize(Console, Settings.Default.AdvancedMode);
Project.Save();
AddRecentPath(fileName);
OnChangeProject();
ShowProjectProperty();
}
catch (Exception ex)
{
ProvideMessage("Default.Exception.Error", "プロジェクトの新規作成", ex.Message);
return;
}
}
/// <summary>
/// XMLNodeをデータにデシリアライズする。
/// </summary>
/// <param name="node">復号対象のXMLノード。</param>
public static WarlockProject DeserializeElement(XmlElement node)
{
if (node.Name != "WarlockProject")
{
throw new FormatException("ルートノードではありません。");
}
var ret = new WarlockProject();
XmlAttribute attr = null;
attr = node.Attributes["Type"];
if (attr == null) throw new FormatException("プロジェクトタイプが見つかりません。");
try
{
ret.ProjectType = EnumExtentions.GetDeserializedValue<WarlockProjectType>(attr.Value);
}
catch (InvalidCastException)
{
throw new FormatException("不正なプロジェクトタイプです。");
}
foreach (XmlNode child in node.ChildNodes)
{
var childElement = child as XmlElement;
if (childElement == null) continue;
switch (childElement.Name)
{
case "Name":
ret.Name = childElement.InnerText;
break;
case "ScriptFileName":
ret.ScriptFileName = childElement.InnerText;
break;
case "DataFolderPath":
ret.DataFolderPath = childElement.InnerText;
break;
case "ScriptFolderPath":
ret.ScriptFolderPath = childElement.InnerText;
break;
case "Classes":
foreach (XmlNode gChild in childElement.ChildNodes)
{
var gChildElement = gChild as XmlElement;
if (gChildElement == null) continue;
ret.ClassDefinitions.Add(ClassDefinition.DeserializeElement(gChildElement));
}
break;
case "Databases":
foreach (XmlNode gChild in childElement.ChildNodes)
{
var gChildElement = gChild as XmlElement;
if (gChildElement == null) continue;
ret.DatabaseDefinitions.Add(DatabaseDefinition.DeserializeElement(gChildElement));
}
break;
case "Scripts":
foreach (XmlNode gChild in childElement.ChildNodes)
{
var gChildElement = gChild as XmlElement;
if (gChildElement == null) continue;
ret.ScriptDefinitions.Add(ScriptDefinition.DeserializeElement(gChildElement));
}
break;
default:
throw new FormatException("未定義のエレメントを検出しました。");
}
}
return ret;
}
/// <summary>
/// コンストラクタ。
/// </summary>
/// <param name="node">スクリプトルートノードのインスタンス。</param>
public ScriptRootProperty(ScriptRootTreeNode node)
: base(node)
{
Project = (WarlockProject)node.Tag;
}
/// <summary>
/// ノードのドロップ処理を行う。
/// </summary>
/// <param name="dragNode">ドラッグ対象のツリーノード。</param>
/// <param name="project">プロジェクト情報のインスタンス。</param>
public virtual void Drop(
WarlockTreeNode dragNode,
WarlockProject project)
{
throw new NotImplementedException();
}
/// <summary>
/// クラス定義をデータベース上で使用しているかチェックする。
/// </summary>
/// <param name="project">プロジェクト情報のインスタンス。</param>
/// <returns>クラス定義をデータベース上で使用している場合はtrue。</returns>
public bool IsUsingDatabase(WarlockProject project)
{
return FindUsingDatabase(project).Count > 0;
}
/// <summary>
/// 継承元のアクセサを含んだアクセサの一覧を取得する。
/// </summary>
/// <returns>継承元のアクセサを含んだアクセサの一覧。</returns>
public List<AccessorDefinition> GetAllAccessors(WarlockProject project)
{
var ret = new List<AccessorDefinition>();
foreach (var extendClass in GetExtendClasses(project))
{
if (extendClass is ClassDefinition)
{
ret.AddRange(((ClassDefinition)extendClass).Accessors);
}
}
return ret;
}
/// <summary>
/// 継承クラスの一覧を取得する。
/// </summary>
/// <param name="project">プロジェクト情報のインスタンス。</param>
/// <returns>継承クラスの一覧。</returns>
public List<dynamic> GetExtendClasses(WarlockProject project)
{
return ClassDefinition.GetExtendClasses(FullName, project);
}
/// <summary>
/// クラス定義を使用しているデータベース定義の一覧を取得する。
/// </summary>
/// <param name="project">プロジェクト定義のインスタンス。</param>
/// <returns>クラス定義を使用しているデータベース定義の一覧。</returns>
public List<DatabaseDefinition> FindUsingDatabase(WarlockProject project)
{
var ret = new List<DatabaseDefinition>();
foreach (var database in project.DatabaseDefinitions)
{
if (database.FindUsingClass(project).Contains(this))
{
ret.Add(database);
}
}
return ret;
}
/// <summary>
/// クラス定義を使用中のクラス定義を取得する。
/// </summary>
/// <param name="project">プロジェクト情報のインスタンス。</param>
/// <returns>クラス定義を使用中のクラス定義の一覧。</returns>
public List<dynamic> FindUsingClass(WarlockProject project)
{
var ret = new List<dynamic>();
var query = from d in project.DatabaseDefinitions
where d.DataClass == FullName
select d;
foreach (var database in query)
{
ret.AddRange(database.FindUsingClass(project));
}
ret.Distinct();
return ret;
}
/// <summary>
/// 継承クラスの一覧を取得する。
/// </summary>
/// <param name="fullName">クラスのフル名。</param>
/// <param name="project">プロジェクト情報のインスタンス。</param>
/// <returns>継承クラスの一覧。</returns>
public static List<dynamic> GetExtendClasses(
string fullName,
WarlockProject project)
{
var ret = new List<dynamic>();
Action<string> recursive = null; recursive = (name) =>
{
var classDefinition = project.FindClassDefinition(name);
if (classDefinition != null)
{
if (ret.Contains(classDefinition))
{
throw new InvalidOperationException("クラス定義の継承に循環参照が存在しています。");
}
ret.Add(classDefinition);
if (!String.IsNullOrEmpty(classDefinition.Extends))
{
recursive(classDefinition.Extends);
}
return;
}
RubyClassDefinition objectDefinition = null;
if (project.ObjectDefinitionMap.ContainsKey(name))
{
objectDefinition = project.ObjectDefinitionMap[name] as RubyClassDefinition;
if (objectDefinition != null)
{
ret.Add(objectDefinition);
if (!String.IsNullOrEmpty(objectDefinition.SuperClassName) && objectDefinition.SuperClassName != "Object")
{
recursive(objectDefinition.SuperClassName);
}
return;
}
}
};
recursive(fullName);
ret.Reverse();
return ret;
}
/// <summary>
/// ノードを生成する。
/// </summary>
/// <param name="project">プロジェクト情報のインスタンス。</param>
/// <returns>生成したツリーノード。</returns>
public static ProjectTreeNode Create(WarlockProject project)
{
var ret = new ProjectTreeNode();
ret.SelectedImageKey = ret.ImageKey;
ret.Refresh(project);
if (project != null)
{
ret.Nodes.Add(ClassRootTreeNode.Create(project));
ret.Nodes.Add(DatabaseRootTreeNode.Create(project));
if (Settings.Default.AdvancedMode)
{
ret.Nodes.Add(ScriptRootTreeNode.Create(project));
}
foreach (TreeNode node in ret.Nodes)
{
node.Expand();
}
ret.Expand();
}
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="project">プロジェクト情報のインスタンス。</param>
public void Refresh(WarlockProject project)
{
Tag = project;
if (project != null)
{
Text = String.Format("{0}({1})", project.Name, project.FileName);
ImageKey = "ProjectIcon.ico";
Enabled = true;
}
else
{
Text = "プロジェクトがロードされていません";
ImageKey = "NullIcon.ico";
Enabled = false;
}
SelectedImageKey = ImageKey;
}
/// <summary>
/// クラス定義を他のクラスで使用しているかチェックする。
/// </summary>
/// <param name="project">プロジェクト情報のインスタンス。</param>
/// <returns>クラス定義を他のクラス上で使用している場合はtrue。</returns>
public bool IsUsingOtherClass(WarlockProject project)
{
foreach (var classDefinition in project.ClassDefinitions)
{
if (this.Equals(classDefinition)) continue;
if (classDefinition.IsUsingClass(this, project)) return true;
}
return false;
}
/// <summary>
/// ノードのドロップ処理を行う。
/// </summary>
/// <param name="dragNode">ドラッグ対象のツリーノード。</param>
/// <param name="project">プロジェクト情報のインスタンス。</param>
public override void Drop(WarlockTreeNode dragNode, WarlockProject project)
{
var scriptNode = (ScriptTreeNode)dragNode;
var dragDefinition = (ScriptDefinition)scriptNode.Tag;
scriptNode.Remove();
project.ScriptDefinitions.Remove(dragDefinition);
project.ScriptDefinitions.Add(dragDefinition);
this.Nodes.Add(scriptNode);
if (!this.IsExpanded) this.Expand();
}
/// <summary>
/// ノードのドロップ処理を行う。
/// </summary>
/// <param name="dragNode">ドラッグ対象のツリーノード。</param>
/// <param name="project">プロジェクト情報のインスタンス。</param>
public override void Drop(WarlockTreeNode dragNode, WarlockProject project)
{
var classNode = (ClassTreeNode)dragNode;
var dragDefinition = (ClassDefinition)classNode.Tag;
var dropDefinition = (ClassDefinition)this.Tag;
classNode.Remove();
project.ClassDefinitions.Remove(dragDefinition);
int i = 0;
for (i = 0; i < project.ClassDefinitions.Count - 1; i++)
{
if (project.ClassDefinitions[i] == dropDefinition) break;
}
project.ClassDefinitions.Insert(i, dragDefinition);
Parent.Nodes.Insert(i, classNode);
}
/// <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);
}
/// <summary>
/// コンストラクタ。
/// </summary>
/// <param name="project">プロジェクト情報のインスタンス。</param>
public RubyHost(WarlockProject project)
{
_Runtime = Ruby.CreateRuntime();
_Errors = new List<WarlockErrorData>();
_Engine = Runtime.GetEngine("rb");
string rgssDefinition = null;
// RGSS定義ソースの実行
switch (project.ProjectType)
{
case WarlockProjectType.Xp:
rgssDefinition = "rpgxp.rb";
break;
case WarlockProjectType.Vx:
rgssDefinition = "rpgvx.rb";
break;
case WarlockProjectType.VxAce:
rgssDefinition = "rpgvxace.rb";
break;
}
if (!String.IsNullOrEmpty(rgssDefinition))
{
var rgssPath = Path.Combine(
Path.GetDirectoryName(Assembly.GetEntryAssembly().Location),
"RGSS",
rgssDefinition
);
if (File.Exists(rgssPath))
{
var rgssSource = Engine.CreateScriptSourceFromFile(rgssPath);
rgssSource.Compile().Execute();
}
}
// 例外からエラーを作成する匿名メソッド
Func<dynamic, Exception, WarlockErrorData> convertError = (definition, ex) => {
var ret = new WarlockErrorData()
{
Type = WarlockErrorType.Error
};
ret.Message = ex.Message;
if (definition is ScriptDefinition)
{
ret.Target = ((ScriptDefinition)definition).DisplayName;
}
else if (definition is ClassDefinition)
{
ret.Target = ((ClassDefinition)definition).FullName;
}
else
{
return ret;
}
try
{
if (ex.Data.Contains(typeof(InterpretedFrameInfo)))
{
InterpretedFrameInfo[] infos = (InterpretedFrameInfo[])ex.Data[typeof(InterpretedFrameInfo)];
DebugInfo info = (
from i in infos
where i.DebugInfo != null
select i.DebugInfo
).FirstOrDefault();
if (info != null)
{
ret.Location = String.Format("{0}, {1}", info.StartLine, info.Index);
}
}
}
catch { }
return ret;
};
foreach (var definition in project.GetAllScripts())
{
if (definition is ScriptDefinition)
{
// インポートしたスクリプトを実行
var castedDefinition = (ScriptDefinition)definition;
if (!castedDefinition.ExecuteTarget) continue;
try
{
Engine.CreateScriptSourceFromFile(
Path.Combine(
project.ScriptFolderFullPath,
castedDefinition.FileName
),
Encoding.UTF8
).Compile().Execute();
}
catch (Exception ex)
{
_Errors.Add(convertError(castedDefinition, ex));
}
}
else if (definition is ClassDefinition)
{
// クラス定義のクラスを実行
var castedDefinition = (ClassDefinition)definition;
try
{
Engine.Execute(castedDefinition.ToScript());
}
catch (Exception ex)
{
_Errors.Add(convertError(castedDefinition, ex));
}
}
else
{
throw new NotImplementedException();
}
}
}