private bool AddStreamNodeToTree(StreamNode Stream, string[] Filter, TreeNode ParentTreeNode, bool bExpandAll)
{
TreeNode StreamTreeNode = new TreeNode(Stream.Record.Name);
StreamTreeNode.ImageIndex = 0;
StreamTreeNode.SelectedImageIndex = 0;
StreamTreeNode.Tag = Stream;
ParentTreeNode.Nodes.Add(StreamTreeNode);
if (Stream.Record.Identifier == SelectedStream && IncludeNodeInFilter(Stream, Filter))
{
StreamsTreeView.SelectedNode = StreamTreeNode;
}
bool bExpand = bExpandAll;
foreach (StreamNode ChildNode in Stream.ChildNodes)
{
bExpand |= AddStreamNodeToTree(ChildNode, Filter, StreamTreeNode, bExpandAll);
}
if (bExpand)
{
StreamTreeNode.Expand();
}
return(bExpand || (SelectedStream == Stream.Record.Identifier));
}
public ExpressionNode BuildExpression(bool enableValidation)
{
ExpressionNode pathRoot = null;
ExpressionNode path = null;
foreach (var element in _elements)
{
ExpressionNode node = null;
switch (element)
{
case NotExpressionPathElement _:
node = new LogicalNotNode();
break;
case PropertyElement prop:
node = new PropertyAccessorNode(prop.Property.Name, enableValidation, new PropertyInfoAccessorPlugin(prop.Property, prop.AccessorFactory));
break;
case ArrayElementPathElement arr:
node = new PropertyAccessorNode(CommonPropertyNames.IndexerName, enableValidation, new ArrayElementPlugin(arr.Indices, arr.ElementType));
break;
case VisualAncestorPathElement visualAncestor:
node = new FindVisualAncestorNode(visualAncestor.AncestorType, visualAncestor.Level);
break;
case AncestorPathElement ancestor:
node = new FindAncestorNode(ancestor.AncestorType, ancestor.Level);
break;
case SelfPathElement _:
node = new SelfNode();
break;
case ElementNameElement name:
node = new ElementNameNode(name.NameScope, name.Name);
break;
case IStronglyTypedStreamElement stream:
node = new StreamNode(stream.CreatePlugin());
break;
case ITypeCastElement typeCast:
node = new StrongTypeCastNode(typeCast.Type, typeCast.Cast);
break;
default:
throw new InvalidOperationException($"Unknown binding path element type {element.GetType().FullName}");
}
path = pathRoot is null ? (pathRoot = node) : path.Next = node;
}
return(pathRoot ?? new EmptyExpressionNode());
}
private string GetSelectedStream()
{
string NewSelectedStream = null;
if (StreamsTreeView.SelectedNode != null)
{
StreamNode StreamNode = (StreamNode)StreamsTreeView.SelectedNode.Tag;
if (StreamNode != null)
{
NewSelectedStream = StreamNode.Record.Identifier;
}
}
return(NewSelectedStream);
}
private bool TryFilterTree(StreamNode Node, string[] Filter, out StreamNode NewNode)
{
StreamNode FilteredNode = new StreamNode(Node.Record);
foreach (StreamNode ChildNode in Node.ChildNodes)
{
StreamNode FilteredChildNode;
if (TryFilterTree(ChildNode, Filter, out FilteredChildNode))
{
FilteredNode.ChildNodes.Add(FilteredChildNode);
}
}
if (FilteredNode.ChildNodes.Count > 0 || IncludeNodeInFilter(FilteredNode, Filter))
{
NewNode = FilteredNode;
return(true);
}
else
{
NewNode = null;
return(false);
}
}
public (ExpressionNode?Node, SourceMode Mode) Parse(ref CharacterReader r)
{
ExpressionNode?rootNode = null;
ExpressionNode?node = null;
var(astNodes, mode) = BindingExpressionGrammar.Parse(ref r);
foreach (var astNode in astNodes)
{
ExpressionNode?nextNode = null;
switch (astNode)
{
case BindingExpressionGrammar.EmptyExpressionNode _:
nextNode = new EmptyExpressionNode();
break;
case BindingExpressionGrammar.NotNode _:
nextNode = new LogicalNotNode();
break;
case BindingExpressionGrammar.StreamNode _:
nextNode = new StreamNode();
break;
case BindingExpressionGrammar.PropertyNameNode propName:
nextNode = new PropertyAccessorNode(propName.PropertyName, _enableValidation);
break;
case BindingExpressionGrammar.IndexerNode indexer:
nextNode = new StringIndexerNode(indexer.Arguments);
break;
case BindingExpressionGrammar.AttachedPropertyNameNode attachedProp:
nextNode = ParseAttachedProperty(attachedProp);
break;
case BindingExpressionGrammar.SelfNode _:
nextNode = new SelfNode();
break;
case BindingExpressionGrammar.AncestorNode ancestor:
nextNode = ParseFindAncestor(ancestor);
break;
case BindingExpressionGrammar.NameNode elementName:
nextNode = new ElementNameNode(_nameScope ?? throw new NotSupportedException("Invalid element name binding with null name scope!"), elementName.Name);
break;
case BindingExpressionGrammar.TypeCastNode typeCast:
nextNode = ParseTypeCastNode(typeCast);
break;
}
if (node is null)
{
rootNode = node = nextNode;
}
else
{
node.Next = nextNode;
node = nextNode;
}
}
return(rootNode, mode);
}
private void PopulateTree()
{
StreamsTreeView.BeginUpdate();
StreamsTreeView.Nodes.Clear();
string[] Filter = FilterTextBox.Text.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
List <StreamDepot> FilteredDepots = Depots;
if (Filter.Length > 0)
{
FilteredDepots = new List <StreamDepot>();
foreach (StreamDepot Depot in Depots)
{
StreamDepot FilteredDepot = new StreamDepot(Depot.Name);
foreach (StreamNode RootNode in Depot.RootNodes)
{
StreamNode FilteredRootNode;
if (TryFilterTree(RootNode, Filter, out FilteredRootNode))
{
FilteredDepot.RootNodes.Add(FilteredRootNode);
}
}
if (FilteredDepot.RootNodes.Count > 0)
{
FilteredDepots.Add(FilteredDepot);
}
}
}
bool bExpandAll = Filter.Length > 0;
foreach (StreamDepot Depot in FilteredDepots)
{
TreeNode DepotTreeNode = new TreeNode(Depot.Name);
DepotTreeNode.ImageIndex = 1;
DepotTreeNode.SelectedImageIndex = 1;
StreamsTreeView.Nodes.Add(DepotTreeNode);
bool bExpand = bExpandAll;
foreach (StreamNode RootNode in Depot.RootNodes)
{
bExpand |= AddStreamNodeToTree(RootNode, Filter, DepotTreeNode, bExpandAll);
}
if (bExpand)
{
DepotTreeNode.Expand();
}
}
if (StreamsTreeView.SelectedNode == null && Filter.Length > 0 && StreamsTreeView.Nodes.Count > 0)
{
for (TreeNode Node = StreamsTreeView.Nodes[0];; Node = Node.Nodes[0])
{
StreamNode Stream = Node.Tag as StreamNode;
if (Stream != null && IncludeNodeInFilter(Stream, Filter))
{
StreamsTreeView.SelectedNode = Node;
break;
}
if (Node.Nodes.Count == 0)
{
break;
}
}
}
if (StreamsTreeView.SelectedNode != null)
{
StreamsTreeView.SelectedNode.EnsureVisible();
}
else if (StreamsTreeView.Nodes.Count > 0)
{
StreamsTreeView.Nodes[0].EnsureVisible();
}
StreamsTreeView.EndUpdate();
UpdateOkButton();
}
private bool IncludeNodeInFilter(StreamNode Node, string[] Filter)
{
return(Filter.All(x => Node.Record.Identifier.IndexOf(x, StringComparison.InvariantCultureIgnoreCase) != -1 || Node.Record.Name.IndexOf(x, StringComparison.InvariantCultureIgnoreCase) != -1));
}
