maui-linux/Xamarin.Forms.Xaml/ExpandMarkupsVisitor.cs

186 строки
5.6 KiB
C#

using System;
using System.Collections.Generic;
using System.Xml;
using Xamarin.Forms.Xaml.Internals;
namespace Xamarin.Forms.Xaml
{
internal class ExpandMarkupsVisitor : IXamlNodeVisitor
{
public ExpandMarkupsVisitor(HydratationContext context)
{
Context = context;
}
public static readonly IList<XmlName> Skips = new List<XmlName>
{
XmlName.xKey,
XmlName.xTypeArguments,
XmlName.xFactoryMethod,
XmlName.xName,
XmlName.xDataType
};
Dictionary<INode, object> Values
{
get { return Context.Values; }
}
HydratationContext Context { get; }
public TreeVisitingMode VisitingMode => TreeVisitingMode.BottomUp;
public bool StopOnDataTemplate => false;
public bool StopOnResourceDictionary => false;
public bool VisitNodeOnDataTemplate => true;
public void Visit(ValueNode node, INode parentNode)
{
}
public void Visit(MarkupNode markupnode, INode parentNode)
{
var parentElement = parentNode as IElementNode;
XmlName propertyName;
if (!ApplyPropertiesVisitor.TryGetPropertyName(markupnode, parentNode, out propertyName))
return;
if (Skips.Contains(propertyName))
return;
if (parentElement.SkipProperties.Contains(propertyName))
return;
var markupString = markupnode.MarkupString;
var node =
ParseExpression(ref markupString, markupnode.NamespaceResolver, markupnode, markupnode, parentNode) as IElementNode;
if (node != null)
{
((IElementNode)parentNode).Properties[propertyName] = node;
node.Parent = parentNode;
}
}
public void Visit(ElementNode node, INode parentNode)
{
}
public void Visit(RootNode node, INode parentNode)
{
}
public void Visit(ListNode node, INode parentNode)
{
}
INode ParseExpression(ref string expression, IXmlNamespaceResolver nsResolver, IXmlLineInfo xmlLineInfo, INode node,
INode parentNode)
{
if (expression.StartsWith("{}", StringComparison.Ordinal))
return new ValueNode(expression.Substring(2), null);
if (expression[expression.Length - 1] != '}')
throw new Exception("Expression must end with '}'");
int len;
string match;
if (!MarkupExpressionParser.MatchMarkup(out match, expression, out len))
throw new Exception();
expression = expression.Substring(len).TrimStart();
if (expression.Length == 0)
throw new Exception("Expression did not end in '}'");
var serviceProvider = new XamlServiceProvider(node, Context);
serviceProvider.Add(typeof (IXmlNamespaceResolver), nsResolver);
return new MarkupExpansionParser().Parse(match, ref expression, serviceProvider);
}
public class MarkupExpansionParser : MarkupExpressionParser, IExpressionParser<INode>
{
IElementNode node;
object IExpressionParser.Parse(string match, ref string remaining, IServiceProvider serviceProvider)
{
return Parse(match, ref remaining, serviceProvider);
}
public INode Parse(string match, ref string remaining, IServiceProvider serviceProvider)
{
var nsResolver = serviceProvider.GetService(typeof (IXmlNamespaceResolver)) as IXmlNamespaceResolver;
if (nsResolver == null)
throw new ArgumentException();
IXmlLineInfo xmlLineInfo = null;
var xmlLineInfoProvider = serviceProvider.GetService(typeof (IXmlLineInfoProvider)) as IXmlLineInfoProvider;
if (xmlLineInfoProvider != null)
xmlLineInfo = xmlLineInfoProvider.XmlLineInfo;
var split = match.Split(':');
if (split.Length > 2)
throw new ArgumentException();
string prefix; //, name;
if (split.Length == 2)
{
prefix = split[0];
// name = split [1];
}
else
{
prefix = "";
// name = split [0];
}
Type type;
var typeResolver = serviceProvider.GetService(typeof (IXamlTypeResolver)) as IXamlTypeResolver;
if (typeResolver == null)
type = null;
else
{
//The order of lookup is to look for the Extension-suffixed class name first and then look for the class name without the Extension suffix.
if (!typeResolver.TryResolve(match + "Extension", out type) && !typeResolver.TryResolve(match, out type))
{
var lineInfoProvider = serviceProvider.GetService(typeof (IXmlLineInfoProvider)) as IXmlLineInfoProvider;
var lineInfo = (lineInfoProvider != null) ? lineInfoProvider.XmlLineInfo : new XmlLineInfo();
throw new XamlParseException(String.Format("MarkupExtension not found for {0}", match), lineInfo);
}
}
var namespaceuri = nsResolver.LookupNamespace(prefix) ?? "";
var xmltype = new XmlType(namespaceuri, type.Name, null);
if (type == null)
throw new NotSupportedException();
node = xmlLineInfo == null
? new ElementNode(xmltype, null, nsResolver)
: new ElementNode(xmltype, null, nsResolver, xmlLineInfo.LineNumber, xmlLineInfo.LinePosition);
if (remaining.StartsWith("}", StringComparison.Ordinal))
{
remaining = remaining.Substring(1);
return node;
}
char next;
string piece;
while ((piece = GetNextPiece(ref remaining, out next)) != null)
HandleProperty(piece, serviceProvider, ref remaining, next != '=');
return node;
}
protected override void SetPropertyValue(string prop, string strValue, object value, IServiceProvider serviceProvider)
{
var nsResolver = serviceProvider.GetService(typeof (IXmlNamespaceResolver)) as IXmlNamespaceResolver;
var childnode = value as INode ?? new ValueNode(strValue, nsResolver);
childnode.Parent = node;
if (prop != null)
{
var name = new XmlName(node.NamespaceURI, prop);
node.Properties[name] = childnode;
}
else //ContentProperty
node.CollectionItems.Add(childnode);
}
}
}
}