private ParseResult ParseLine(int lineNumber, string line)
{
if (line.Length == 0 || line.StartsWith(CommentPrefix))
{
return(ParseResult.Success);
}
ParseData parseData = GetParseData(lineNumber, line);
if (parseData == null)
{
return(ParseResult.Failure.Derive(lineNumber, line, "Invalid syntax"));
}
INodeContainer container = GetContainer(parseData);
if (container == null)
{
return(ParseResult.Failure.Derive(lineNumber, line, String.Format("Unable to get node container for type \"{0}\"", parseData.Type)));
}
if (containers.ContainsKey(container.Index))
{
return(ParseResult.Failure.Derive(lineNumber, line, String.Format("Duplicate index \"{0}\"", container.Index)));
}
containers.Add(container.Index, container);
return(ParseResult.Success);
}
public INodeContainer Get <T>(T node) where T : INode, new()
{
INodeContainer output = PrivateGet(node);
output.Update(null);
return(output);
}
private static IVisualNodeComponentContainer GetComponentByIndex(INodeContainer container, int index)
{
if (index == -1)
{
return(container.Name);
}
return(((IList <IVisualNodeComponentContainer>)container.Fields)[index]);
}
private static void CreateModelDesignStub(INodeContainer factory)
{
BuildError _err = BuildError.DanglingReferenceTarget;
IPropertyInstanceFactory _pr = factory.AddNodeFactory <IPropertyInstanceFactory>();
_pr.SymbolicName = new XmlQualifiedName(string.Format("{0}{1}", _err.Focus.ToString(), m_ErrorNumber++), "http://commsvr.com/OOIUA/SemanticData/UANodeSetValidation");
_pr.AddDescription("en-en", _err.Descriptor);
_pr.AddDisplayName("en-en", string.Format("ERROR{0}", m_ErrorNumber));
}
public TestWorkspaceVisualNode(INodeContainer container,
Guid selectionKind,
string nodeMoniker,
string selectionMoniker)
: base(container)
{
VSSelectionKind = selectionKind;
NodeMoniker = nodeMoniker;
VSSelectionMoniker = selectionMoniker;
}
private void RegisterContainer(INodeContainer container, int index)
{
INodeField newField = Constructor.NodeField(container.NameLabel.LabelText.Value).WithValue("display", ((InputNodeContainer <InputNode>)container).GetValue(null), true);
container.NameLabel.LabelText.OnChange += s =>
{
newField.Name.Value = s;
};
newField.GetValue("display").OnChange += (o) =>
{
((InputNodeContainer <InputNode>)container).SetValue(_scriptInstance, o);
};
AllInputs.Insert(index, newField);
}
/// <summary>
/// Copies the common properties between the <paramref name="sourcePanel"/> and the <paramref name="targetPanel"/>.
/// </summary>
/// <remarks>The children are not copied.</remarks>
/// <param name="nodeContainer">The node container.</param>
/// <param name="sourcePanel">The source panel.</param>
/// <param name="targetPanel">The target panel.</param>
private static void CopyCommonProperties([NotNull] INodeContainer nodeContainer, Panel sourcePanel, Panel targetPanel)
{
var sourceNode = nodeContainer.GetOrCreateNode(sourcePanel);
var targetNode = nodeContainer.GetOrCreateNode(targetPanel);
foreach (var targetChild in targetNode.Members.Where(x => x.Name != nameof(Panel.Children) && x.Name != nameof(UIElement.Id)))
{
var name = targetChild.Name;
var sourceChild = sourceNode.TryGetChild(name);
if (sourceChild != null)
{
targetChild.Update(AssetCloner.Clone(sourceChild.Retrieve()));
}
}
}
public T GetNode <T>(int index) where T : INode <string>
{
if (!containers.ContainsKey(index))
{
return(default(T));
}
INodeContainer container = containers[index];
INode <string> node = container.Node;
if (!typeof(T).IsAssignableFrom(node.GetType()))
{
return(default(T));
}
return((T)node);
}
/// <summary>
/// Copies the common properties between the <paramref name="sourcePanel"/> and the <paramref name="targetPanel"/>.
/// </summary>
/// <remarks>The children are not copied.</remarks>
/// <param name="nodeContainer">The node container.</param>
/// <param name="sourcePanel">The source panel.</param>
/// <param name="targetPanel">The target panel.</param>
private static void CopyCommonProperties([NotNull] INodeContainer nodeContainer, Panel sourcePanel, Panel targetPanel)
{
var sourceNode = nodeContainer.GetOrCreateNode(sourcePanel);
var targetNode = nodeContainer.GetOrCreateNode(targetPanel);
foreach (var targetChild in targetNode.Members.Where(x => x.Name != nameof(Panel.Children) && x.Name != nameof(UIElement.Id) && x.Name != nameof(UIElement.DependencyProperties)))
{
var name = targetChild.Name;
var sourceChild = sourceNode.TryGetChild(name);
if (sourceChild != null)
{
targetChild.Update(AssetCloner.Clone(sourceChild.Retrieve()));
}
}
// Copy the dependency properties, eg. the source panel may be inside a grid and has set grid row/column
sourcePanel.DependencyProperties.CopyTo(targetPanel.DependencyProperties);
}
/// <summary>
/// Enumerate child nodes "Breadth-First".
/// </summary>
/// <param name="root">Parent node.</param>
/// <returns>Yielded nodes.</returns>
public static IEnumerable <INodeAsset> EnumerateNodesBreadthFirst(this INodeContainer root)
{
if (root == null)
{
yield break;
}
var containers = new Stack <INodeAsset>(16);
foreach (var n in root.ChildNodes)
{
containers.Push(n);
}
while (containers.Count > 0)
{
var node = containers.Pop();
yield return(node);
foreach (var n in node.ChildNodes)
{
containers.Push(n);
}
}
}
/// <summary>
/// Enumerate child nodes "Depth-First".
/// </summary>
/// <param name="root">Parent node.</param>
/// <returns>Yielded nodes.</returns>
public static IEnumerable <INodeAsset> EnumerateNodesDepthFirst(this INodeContainer root)
{
if (root == null)
{
yield break;
}
var containers = new Queue <INodeAsset>(16);
foreach (var n in root.ChildNodes)
{
containers.Enqueue(n);
}
while (containers.Count > 0)
{
var node = containers.Dequeue();
yield return(node);
foreach (var n in node.ChildNodes)
{
containers.Enqueue(n);
}
}
}
private static void SetInlineContent(INodeContainer<CommonMark.Inline> owner, Syntax.Inline inl)
{
while (inl != null)
{
CommonMark.Inline result = null;
switch (inl.Tag)
{
case Syntax.InlineTag.String:
result = new Text(inl.Content.Literal); break;
case Syntax.InlineTag.SoftBreak:
result = new Softbreak(); break;
case Syntax.InlineTag.LineBreak:
result = new Linebreak(); break;
case Syntax.InlineTag.Code:
result = new CodeSpan(inl.Content.Literal); break;
case Syntax.InlineTag.RawHtml:
result = new RawHtml(inl.Content.Literal); break;
case Syntax.InlineTag.Entity:
result = new TextEntity(inl.Content.Literal); break;
case Syntax.InlineTag.Emphasis:
result = new Emphasis(); break;
case Syntax.InlineTag.Strong:
result = new Strong(); break;
case Syntax.InlineTag.Link:
result = new Link(); break;
case Syntax.InlineTag.Image:
result = new Image(); break;
default:
throw new Exception("Invalid value for InlineTag");
}
if (result is Linkable)
{
((Linkable)result).Title = inl.Content.Linkable.Title;
((Linkable)result).Url = inl.Content.Linkable.Url;
SetInlineContent((Linkable)result, inl.Content.Linkable.Label);
}
if (result is CommonMark.INodeContainer<CommonMark.Inline>)
SetInlineContent((CommonMark.INodeContainer<CommonMark.Inline>)result, inl.Content.Inlines);
if (result != null)
owner.Append(result);
inl = inl.Next;
}
}
/// <summary>
/// Validates <paramref name="nodeContext" /> and exports it using an object of <see cref="IModelFactory" /> type.
/// </summary>
/// <param name="nodeContext">The node context to be validated and exported.</param>
/// <param name="exportFactory">A model export factory.</param>
/// <param name="parentReference">The reference to parent node.</param>
/// <exception cref="ApplicationException">In {nameof(ValidateExportNode)}</exception>
public void ValidateExportNode(IUANodeBase nodeContext, INodeContainer exportFactory, UAReferenceContext parentReference)
{
Debug.Assert(nodeContext != null, "Validator.ValidateExportNode the argument nodeContext is null.");
//TODO Handle HasComponent ReferenceType errors. #42
if (Object.ReferenceEquals(nodeContext.UANode, null))
{
string _msg = string.Format("The node {0} is undefined", nodeContext.NodeIdContext);
BuildError _be = null;
if (parentReference == null || parentReference.ReferenceKind == ReferenceKindEnum.HasProperty)
{
_be = BuildError.UndefinedHasPropertyTarget;
}
else
{
_be = BuildError.UndefinedHasComponentTarget;
}
TraceMessage _traceMessage = TraceMessage.BuildErrorTraceMessage(_be, _msg);
Log.TraceEvent(_traceMessage);
CreateModelDesignStub(exportFactory);
}
else
{
switch (nodeContext.UANode.NodeClassEnum)
{
case NodeClassEnum.UADataType:
CreateNode <IDataTypeFactory, UADataType>(exportFactory.AddNodeFactory <IDataTypeFactory>, nodeContext, (x, y) => Update(x, y), UpdateType);
break;
case NodeClassEnum.UAMethod:
CreateNode <IMethodInstanceFactory, UAMethod>(exportFactory.AddNodeFactory <IMethodInstanceFactory>, nodeContext, (x, y) => Update(x, y, parentReference), UpdateInstance);
break;
case NodeClassEnum.UAObject:
CreateNode <IObjectInstanceFactory, UAObject>(exportFactory.AddNodeFactory <IObjectInstanceFactory>, nodeContext, (x, y) => Update(x, y), UpdateInstance);
break;
case NodeClassEnum.UAObjectType:
CreateNode <IObjectTypeFactory, UAObjectType>(exportFactory.AddNodeFactory <IObjectTypeFactory>, nodeContext, Update, UpdateType);
break;
case NodeClassEnum.UAReferenceType:
CreateNode <IReferenceTypeFactory, UAReferenceType>(exportFactory.AddNodeFactory <IReferenceTypeFactory>, nodeContext, (x, y) => Update(x, y), UpdateType);
break;
case NodeClassEnum.UAVariable:
if (parentReference.ReferenceKind == ReferenceKindEnum.HasProperty)
{
CreateNode <IPropertyInstanceFactory, UAVariable>(exportFactory.AddNodeFactory <IPropertyInstanceFactory>, nodeContext, (x, y) => Update(x, y, nodeContext, parentReference), UpdateInstance);
}
else
{
CreateNode <IVariableInstanceFactory, UAVariable>(exportFactory.AddNodeFactory <IVariableInstanceFactory>, nodeContext, (x, y) => Update(x, y, nodeContext, parentReference), UpdateInstance);
}
break;
case NodeClassEnum.UAVariableType:
CreateNode <IVariableTypeFactory, UAVariableType>(exportFactory.AddNodeFactory <IVariableTypeFactory>, nodeContext, (x, y) => Update(x, y), UpdateType);
break;
case NodeClassEnum.UAView:
CreateNode <IViewInstanceFactory, UAView>(exportFactory.AddNodeFactory <IViewInstanceFactory>, nodeContext, (x, y) => Update(x, y), UpdateInstance);
break;
case NodeClassEnum.Unknown:
throw new ApplicationException($"In {nameof(ValidateExportNode)} unexpected NodeClass value");
}
}
}
public void SetSourceContainer(INodeContainer container)
{
_nodeList = container.Nodes;
Title = container.Title;
}
public LeafNode(TActionItem action, INodeContainer parent)
: base(action, parent)
{
}
private void ParseNode(Scene scene, INodeContainer parent, XElement node)
{
var n = new Node();
this.ParseIdAndName(node, n);
var mat = this.ParseMatrix(node.Element(this.schema.matrixName));
//TODO: check if transform is in there!
n.Position = new Float3(mat.M03, mat.M13, mat.M23);
//n.Rotation =
var geo = node.Element(this.schema.instanceGeometryName);
if (geo != null)
{
var url = geo.AttributeValue(this.schema.urlName);
string id = url.Substring(1);
n.Mesh = (from g in scene.Geometries where g.Id == id select g).First();
}
else
{
var ctrl = node.Element(this.schema.instanceControllerName);
if (ctrl != null)
{
var url = ctrl.AttributeValue(this.schema.urlName);
string id = url.Substring(1);
var controller = this.collada.Element(this.schema.libraryControllersName).ElementById(id);
url = controller.Element(this.schema.skinName).AttributeValue(this.schema.sourceAttributeName);
id = url.Substring(1);
n.Mesh = (from g in scene.Geometries where g.Id == id select g).First();
}
}
parent.Nodes.Add(n);
}
public GroupNode(TActionItem action, INodeContainer parent)
: base(action, parent)
{
this.Items = new List <Node>();
}
public NodesToOwnerPartVisitor([NotNull] AssetPropertyGraphDefinition propertyGraphDefinition, [NotNull] INodeContainer nodeContainer, object ownerPart)
: base(propertyGraphDefinition)
{
ownerPartNode = (IAssetObjectNode)nodeContainer.GetOrCreateNode(ownerPart);
}
public static IEnumerable <Node> GetLightNodes(this INodeContainer nodeContainer)
{
return(nodeContainer.nodes.Where((x) => x.HasLight()));
}
public static Node Find(this INodeContainer node, string nodePath, NodeFindMethod method)
{
// early exit check against null for passed reference
if (node == null)
{
return(null);
}
nodePath = nodePath.Trim('/');
int sepIndex = nodePath.IndexOf('/');
string curLevel = nodePath;
if (sepIndex != -1)
{
curLevel = nodePath.Substring(0, sepIndex);
nodePath = nodePath.Substring(sepIndex);
}
else
{
nodePath = nodePath.Substring(curLevel.Length);
}
if (node != null && node.nodes != null)
{
if (method == NodeFindMethod.ByName)
{
// check if the path exceeds the current node level
foreach (Node child in node.nodes)
{
if (child.name != null && child.name.Equals(curLevel))
{
if (nodePath.Length > 1)
{
Node result = child.Find(nodePath, method);
if (result != null)
{
return(result);
}
}
return(child);
}
}
}
else
{
// check if the path exceeds the current node level
foreach (Node child in node.nodes)
{
if (child.id != null && child.id.Equals(curLevel))
{
if (nodePath.Length > 1)
{
Node result = child.Find(nodePath, method);
if (result != null)
{
return(result);
}
}
return(child);
}
}
}
}
return(null);
/*
* if (node != null && node.nodes != null)
* // check if the path exceeds the current node level
* foreach (Node child in node.nodes)
* {
* //if (child.name.Equals(curLevel))
* if (child.id.Equals(curLevel)) // changed check against .name to .id
* {
* if (nodePath.Length > 1)
* {
* Node result = child.Find(nodePath);
* if (result != null)
* return result;
* }
* return child;
* }
* }
* return null;
*/
}
private void ParseNodes(Scene scene, INodeContainer parent, IEnumerable<XElement> elements)
{
foreach (var node in elements)
{
this.ParseNode(scene, parent, node);
}
}
/// <summary>
/// Validates <paramref name="nodeContext"/> and exports it using an object of <see cref="IModelFactory"/> type.
/// </summary>
/// <param name="nodeContext">The node context to be validated and exported.</param>
/// <param name="exportFactory">A model export factory.</param>
/// <param name="parentReference">The reference to parent node.</param>
/// <param name="traceEvent">The trace event.</param>
/// <returns>An object of <see cref="INodeFactory"/>.</returns>
internal static void ValidateExportNode(IUANodeBase nodeContext, INodeContainer exportFactory, UAReferenceContext parentReference, Action <TraceMessage> traceEvent)
{
Debug.Assert(nodeContext != null, "Validator.ValidateExportNode the argument nodeContext is null.");
//TODO Handle HasComponent ReferenceType errors. #42
if (nodeContext.UANode == null)
{
string _msg = string.Format("The node {0} is undefined", nodeContext.NodeIdContext);
BuildError _be = null;
if (parentReference == null || parentReference.ReferenceKind == ReferenceKindEnum.HasProperty)
{
_be = BuildError.UndefinedHasPropertyTarget;
}
else
{
_be = BuildError.UndefinedHasComponentTarget;
}
TraceMessage _traceMessage = TraceMessage.BuildErrorTraceMessage(_be, _msg);
traceEvent(_traceMessage);
CreateModelDesignStub(exportFactory);
}
else
{
string nodeType = nodeContext.UANode.GetType().Name;
switch (nodeType)
{
case "UAReferenceType":
CreateNode <IReferenceTypeFactory, UAReferenceType>(exportFactory.AddNodeFactory <IReferenceTypeFactory>, nodeContext, (x, y) => Update(x, y, traceEvent), UpdateType, traceEvent);
break;
case "UADataType":
CreateNode <IDataTypeFactory, UADataType>(exportFactory.AddNodeFactory <IDataTypeFactory>, nodeContext, (x, y) => Update(x, y, nodeContext.UAModelContext, traceEvent), UpdateType, traceEvent);
break;
case "UAVariableType":
CreateNode <IVariableTypeFactory, UAVariableType>(exportFactory.AddNodeFactory <IVariableTypeFactory>, nodeContext, (x, y) => Update(x, y, nodeContext, traceEvent), UpdateType, traceEvent);
break;
case "UAObjectType":
CreateNode <IObjectTypeFactory, UAObjectType>(exportFactory.AddNodeFactory <IObjectTypeFactory>, nodeContext, Update, UpdateType, traceEvent);
break;
case "UAView":
CreateNode <IViewInstanceFactory, UAView>(exportFactory.AddNodeFactory <IViewInstanceFactory>, nodeContext, (x, y) => Update(x, y, traceEvent), UpdateInstance, traceEvent);
break;
case "UAMethod":
CreateNode <IMethodInstanceFactory, UAMethod>(exportFactory.AddNodeFactory <IMethodInstanceFactory>, nodeContext, (x, y) => Update(x, y, nodeContext, parentReference, traceEvent), UpdateInstance, traceEvent);
break;
case "UAVariable":
if (parentReference == null || parentReference.ReferenceKind == ReferenceKindEnum.HasProperty)
{
CreateNode <IPropertyInstanceFactory, UAVariable>(exportFactory.AddNodeFactory <IPropertyInstanceFactory>, nodeContext, (x, y) => Update(x, y, nodeContext, parentReference, traceEvent), UpdateInstance, traceEvent);
}
else
{
CreateNode <IVariableInstanceFactory, UAVariable>(exportFactory.AddNodeFactory <IVariableInstanceFactory>, nodeContext, (x, y) => Update(x, y, nodeContext, parentReference, traceEvent), UpdateInstance, traceEvent);
}
break;
case "UAObject":
CreateNode <IObjectInstanceFactory, UAObject>(exportFactory.AddNodeFactory <IObjectInstanceFactory>, nodeContext, (x, y) => Update(x, y, traceEvent), UpdateInstance, traceEvent);
break;
default:
Debug.Assert(false, "Wrong node type");
break;
}
}
}
public static IEnumerable <Node> GetControllerNodes(this INodeContainer nodeContainer)
{
return(nodeContainer.nodes.Where((x) => x.HasController()));
}
protected Node(TActionItem action, INodeContainer parent)
{
this.Content = action;
this.Parent = parent;
}
/// <summary>
/// Create a new instanse of CTreeNodeCollection assigned to specified owner.
/// </summary>
/// <param name="owner">CTreeNode or CTreeView.</param>
internal CTreeNodeCollection(INodeContainer owner)
{
this.owner = owner;
}
public static IEnumerable <Node> GetGeometryNodes(this INodeContainer nodeContainer)
{
return(nodeContainer.nodes.Where((x) => x.HasGeometry()));
}
public static IEnumerable <Node> GetOtherNodes(this INodeContainer nodeContainer)
{
return(nodeContainer.nodes.Where((x) => !x.HasCamera() && !x.HasController() && !x.HasGeometry() && !x.HasLight()));
}
public NodeContainerAdapter(INodeContainer <TEntity> nodes)
{
_nodes = nodes;
}