public override void RecursivelyResolve(Dictionary <string, DataDefinition> local, Dictionary <string, DataDefinition> global, Dictionary <string, Dictionary <string, DataDefinition> > referenceableDefinitions)
{
if (isResolving)
{
return;
}
isResolving = true;
if (Extends != null)
{
StructDefinition def = null;
if (local.ContainsKey(Extends))
{
def = local[Extends] as StructDefinition;
}
if (def == null && global.ContainsKey(Extends))
{
def = global[Extends] as StructDefinition;
}
if (def == null)
{
throw new Exception("The definition '" + Extends + "' this extends could not be found!");
}
Extends = null;
if (def.Extends != null)
{
def.RecursivelyResolve(referenceableDefinitions[def.SrcFile], global, referenceableDefinitions);
}
var newChildren = def.Children.ToList();
for (int i = 0; i < newChildren.Count; i++)
{
var name = newChildren[i].Name.ToLower();
// find index of name in our children
var existing = Children.FirstOrDefault(e => e.Name.ToLower() == name);
if (existing != null)
{
var ourIndex = Children.IndexOf(existing);
Children.Remove(existing);
newChildren[i] = existing;
if (ExtendsAfter == null)
{
// Add all the children in the window to the new children at this index
var ni = ourIndex;
for (; ni < Children.Count; ni++)
{
if (newChildren.Any(e => Children[ni].Name.ToLower() == e.Name.ToLower()))
{
break;
}
var child = Children[ni--];
Children.Remove(child);
newChildren.Insert(++i, child);
}
}
}
}
if (ExtendsAfter == null)
{
// Add the rest
foreach (var child in Children)
{
newChildren.Add(child);
}
}
else
{
var afterEl = newChildren.FirstOrDefault(e => e.Name.ToLower() == ExtendsAfter);
var index = newChildren.Count;
if (afterEl != null)
{
index = newChildren.IndexOf(afterEl) + 1;
}
foreach (var child in Children)
{
newChildren.Insert(index++, child);
}
}
foreach (var att in def.Attributes)
{
Attributes.Add(att);
}
Children = newChildren;
}
foreach (var child in Children)
{
child.RecursivelyResolve(local, global, referenceableDefinitions);
}
}
public static DataDefinition LoadDefinition(XElement element, string forceLoadAs = null)
{
if (element.Name.ToString() == "Const")
{
var constDef = new ConstDefinition();
constDef.Parse(element);
return(constDef);
}
var name = element.Attribute(MetaNS + "RefKey")?.Value.ToString().ToUpper();
if (name == null)
{
name = element.Attribute("RefKey")?.Value.ToString().ToUpper();
}
if (name == null)
{
name = element.Name.ToString().ToUpper();
}
if (name.EndsWith("DEF"))
{
name = name.Substring(0, name.Length - "DEF".Length);
}
if (forceLoadAs != null)
{
name = forceLoadAs.ToUpper();
}
DataDefinition definition = null;
if (name == "STRING")
{
definition = new StringDefinition();
}
else if (name == "MULTILINESTRING")
{
definition = new MultilineStringDefinition();
}
else if (name == "STRUCT")
{
definition = new StructDefinition();
}
else if (name == "REFERENCE")
{
definition = new ReferenceDefinition();
}
else if (name == "COLLECTION")
{
definition = new CollectionDefinition();
}
else if (name == "NUMBER")
{
definition = new NumberDefinition();
}
else if (name == "BOOLEAN")
{
definition = new BooleanDefinition();
}
else if (name == "COLOUR")
{
definition = new ColourDefinition();
}
else if (name == "ENUM")
{
definition = new EnumDefinition();
}
else if (name == "FLAGS")
{
definition = new FlagsDefinition();
}
else if (name == "FILE")
{
definition = new FileDefinition();
}
else if (name == "TREE")
{
definition = new TreeDefinition();
}
else if (name == "VECTOR")
{
definition = new VectorDefinition();
}
else if (name == "TIMELINE")
{
definition = new TimelineDefinition();
}
else if (name == "GRAPHSTRUCT")
{
definition = new GraphStructDefinition();
}
else if (name == "GRAPHCOLLECTION")
{
definition = new GraphCollectionDefinition();
}
else if (name == "GRAPHREFERENCE")
{
definition = new GraphReferenceDefinition();
}
else if (name == "KEYFRAME")
{
definition = new KeyframeDefinition();
}
else if (name == "COMMENT")
{
definition = new CommentDefinition();
}
else if (name == "SKELETALANIMATION")
{
definition = new SkeletalAnimationDefinition();
}
else
{
throw new Exception("Unknown definition type " + name + "!");
}
definition.Name = element.Attribute("Name")?.Value?.ToString();
if (string.IsNullOrWhiteSpace(definition.Name))
{
definition.Name = definition.GetType().ToString().Replace("Definition", "");
}
definition.ToolTip = element.Attribute("ToolTip")?.Value?.ToString();
var col = element.Attribute("TextColour")?.Value?.ToString();
if (col != null)
{
if (Colours.ContainsKey(col))
{
col = Colours[col];
}
definition.TextColour = col;
}
var attEl = element.Element("Attributes");
if (attEl != null)
{
foreach (var att in attEl.Elements())
{
var attDef = LoadDefinition(att);
if (attDef is PrimitiveDataDefinition)
{
definition.Attributes.Add(attDef as PrimitiveDataDefinition);
}
else
{
throw new Exception("Cannot put a non-primitive into attributes!");
}
}
}
definition.IsGlobal = definition.TryParseBool(element, "IsGlobal");
definition.VisibleIf = element.Attribute("VisibleIf")?.Value?.ToString();
definition.SkipIfDefault = definition.TryParseBool(element, "SkipIfDefault", true);
definition.Parse(element);
return(definition);
}
