XamlNamespace ParseNamespace(string xmlNamespace)
{
string name = xmlNamespace;
Debug.Assert(name.StartsWith("clr-namespace:", StringComparison.Ordinal));
name = name.Substring("clr-namespace:".Length);
string namespaceName, assembly;
int pos = name.IndexOf(';');
if (pos < 0)
{
namespaceName = name;
assembly = "";
}
else
{
namespaceName = name.Substring(0, pos);
name = name.Substring(pos + 1).Trim();
if (!name.StartsWith("assembly=", StringComparison.Ordinal))
{
throw new XamlLoadException("Expected: 'assembly='");
}
assembly = name.Substring("assembly=".Length);
}
XamlNamespace ns = new XamlNamespace(xmlNamespace);
Assembly asm = LoadAssembly(assembly);
if (asm != null)
{
AddMappingToNamespace(ns, new AssemblyNamespaceMapping(asm, namespaceName));
}
return(ns);
}
private void ScanAssemblies(IEnumerable <Assembly> assemblies)
{
foreach (var assembly in assemblies)
{
var namespaces = assembly.GetCustomAttributes <XmlnsDefinitionAttribute>()
.Select(x => new { x.XmlNamespace, x.ClrNamespace })
.GroupBy(x => x.XmlNamespace);
foreach (var nsa in namespaces)
{
var xamlNamespace = _namespaces.FirstOrDefault(x => x.Name == nsa.Key);
if (xamlNamespace == null)
{
xamlNamespace = new XamlNamespace(nsa.Key);
_namespaces.Add(xamlNamespace);
}
var clrNamespaces = nsa.Select(x => x.ClrNamespace);
xamlNamespace.Addresses.Add(new ConfiguredAssemblyWithNamespaces(assembly, clrNamespaces));
}
_scanned.Add(assembly);
}
}
private static XamlNamespaceRegistry CreateXamlNamespaceRegistry()
{
var xamlNamespaceRegistry = new XamlNamespaceRegistry();
var forcedAssemblies = new[]
{
typeof(Control),
typeof(Style)
}.Select(t => t.GetTypeInfo().Assembly);
foreach (var nsa in
forcedAssemblies
.Concat(PerspexLocator.Current.GetService <IPclPlatformWrapper>().GetLoadedAssemblies())
.Distinct()
.SelectMany(asm
=> asm.GetCustomAttributes <XmlnsDefinitionAttribute>().Select(attr => new { asm, attr }))
.GroupBy(entry => entry.attr.XmlNamespace))
{
var def = XamlNamespace.Map(nsa.Key)
.With(nsa.GroupBy(x => x.asm).Select(
a => Route.Assembly(a.Key)
.WithNamespaces(a.Select(entry => entry.attr.ClrNamespace).ToList())
));
xamlNamespaceRegistry.AddNamespace(def);
}
xamlNamespaceRegistry.RegisterPrefix(new PrefixRegistration(string.Empty, PerspexNs));
return(xamlNamespaceRegistry);
}
void AddMappingToNamespace(XamlNamespace ns, AssemblyNamespaceMapping mapping)
{
ns.ClrNamespaces.Add(mapping);
List <string> xmlNamespaceList;
if (reverseDictList.TryGetValue(mapping, out xmlNamespaceList))
{
if (!xmlNamespaceList.Contains(ns.XmlNamespace))
{
xmlNamespaceList.Add(ns.XmlNamespace);
}
}
else
{
reverseDictList.Add(mapping, new List <string>()
{
ns.XmlNamespace
});
}
string xmlNamespace;
if (reverseDict.TryGetValue(mapping, out xmlNamespace))
{
if (xmlNamespace == XamlConstants.PresentationNamespace)
{
return;
}
}
reverseDict[mapping] = ns.XmlNamespace;
}
public void ParentPrefixesAreAvailableInChild()
{
var type = typeof(TextBlock);
var assembly = type.GetTypeInfo().Assembly;
var xamlNamespaces = XamlNamespace.Map("root").With(Route.Assembly(assembly).WithNamespaces(type.Namespace));
var prefixAnnotator = new PrefixAnnotator();
var sut = new PrefixedTypeResolver(prefixAnnotator, new TypeDirectory(new[] { xamlNamespaces }));
var childNode = new ConstructionNode(typeof(TextBlock));
var root = new ConstructionNode(typeof(Window))
{
Assignments = new List <MemberAssignment>()
{
new MemberAssignment()
{
Member = Member.FromStandard <Window>(window => window.Content),
Children = new[] { childNode, }
}
},
};
prefixAnnotator.Annotate(root, new List <PrefixDeclaration>()
{
new PrefixDeclaration(string.Empty, "root")
});
sut.Root = root;
var buttonType = sut.GetTypeByPrefix(childNode, "Button");
Assert.Equal(typeof(Button), buttonType);
}
private ITypeDirectory CreateSut()
{
var type = typeof(TextBlock);
var assembly = type.GetTypeInfo().Assembly;
var xamlNamespaces = XamlNamespace.Map("root").With(Route.Assembly(assembly).WithNamespaces(type.Namespace));
return(new TypeDirectory(new[] { xamlNamespaces }));
}
internal XamlNamespace Clone()
{
XamlNamespace copy = new XamlNamespace(this.XmlNamespacePrefix, this.XmlNamespace);
// AssemblyNamespaceMapping is immutable
copy.ClrNamespaces.AddRange(this.ClrNamespaces);
return(copy);
}
public static void FillFromAttributes(this INamespaceRegistry nsReg, IEnumerable <Assembly> assemblies)
{
var namespaces = XamlNamespace.DefinedInAssemblies(assemblies);
foreach (var xamlNamespace in namespaces)
{
nsReg.AddNamespace(xamlNamespace);
}
}
public void Initialize()
{
type = typeof(DummyClass);
registry = new XamlNamespaceRegistry();
registry.RegisterPrefix(new PrefixRegistration("my", "target"));
clrNamespace = $"clr-namespace:{type.Namespace};Assembly={type.GetTypeInfo().Assembly}";
registry.RegisterPrefix(new PrefixRegistration("clr", clrNamespace));
registry.AddNamespace(
XamlNamespace.Map("target")
.With(new[] { Route.Assembly(type.Assembly).WithNamespaces(new[] { type.Namespace }) }));
}
private ITypeDirectory GetTypeDirectory()
{
var configuredAssemblyWithNamespaces = Route
.Assembly(typeof(Window).Assembly)
.WithNamespaces("System.Windows", "System.Windows.Controls");
var xamlNamespace = XamlNamespace
.Map("root")
.With(configuredAssemblyWithNamespaces);
return(new TypeDirectory(new[] { xamlNamespace }));
}
private static TypeDirectory GetTypeDirectory()
{
var type = typeof(TextBlock);
var typeAnother = typeof(CustomControl);
var assembly = type.GetTypeInfo().Assembly;
var nsAnother = XamlNamespace.Map("another").With(Route.Assembly(assembly).WithNamespaces(typeAnother.Namespace));
var newTypeDirectory = new TypeDirectory(new[] { nsAnother });
return(newTypeDirectory);
}
protected internal virtual XamlType GetXamlType(string xamlNamespace, string name, params XamlType[] typeArguments)
{
if (xamlNamespace == null)
{
throw new ArgumentNullException("xamlNamespace");
}
if (name == null)
{
throw new ArgumentNullException("name");
}
if (typeArguments != null)
{
foreach (XamlType type in typeArguments)
{
if (type == null)
{
throw new ArgumentException(System.Xaml.SR.Get("CollectionCannotContainNulls", new object[] { "typeArguments" }));
}
if (type.UnderlyingType == null)
{
return(null);
}
}
}
XamlType xamlType = null;
if ((typeArguments == null) || (typeArguments.Length == 0))
{
xamlType = XamlLanguage.LookupXamlType(xamlNamespace, name);
if (xamlType != null)
{
if (this.FullyQualifyAssemblyNamesInClrNamespaces)
{
xamlType = this.GetXamlType(xamlType.UnderlyingType);
}
return(xamlType);
}
}
XamlNamespace namespace2 = this.GetXamlNamespace(xamlNamespace);
int revisionNumber = namespace2.RevisionNumber;
xamlType = namespace2.GetXamlType(name, typeArguments);
if ((xamlType == null) && !namespace2.IsClrNamespace)
{
this.UpdateXmlNsInfo();
if (namespace2.RevisionNumber > revisionNumber)
{
xamlType = namespace2.GetXamlType(name, typeArguments);
}
}
return(xamlType);
}
void AddMappingToNamespace(XamlNamespace ns, AssemblyNamespaceMapping mapping)
{
ns.ClrNamespaces.Add(mapping);
string xmlNamespace;
if (reverseDict.TryGetValue(mapping, out xmlNamespace))
{
if (xmlNamespace == XamlConstants.PresentationNamespace)
{
return;
}
}
reverseDict[mapping] = ns.XmlNamespace;
}
private ITypeDirectory RegisterTypeLocation()
{
var type = typeof(Page);
var ass = type.GetTypeInfo().Assembly;
var xamlNamespace = XamlNamespace
.Map("root")
.With(
Route
.Assembly(ass)
.WithNamespaces(type.Namespace),
Route
.Assembly(typeof(OmniDataTemplate).GetTypeInfo().Assembly)
.WithNamespaces(typeof(OmniDataTemplate).Namespace));
return(new TypeDirectory(new[] { xamlNamespace }));
}
public XamlTypeRepositoryTests()
{
nsRegistryMock = new Mock <IXamlNamespaceRegistry>();
var type = typeof(DummyClass);
var fullyConfiguredMapping = XamlNamespace
.Map("root")
.With(new[] { Route.Assembly(type.Assembly).WithNamespaces(new[] { type.Namespace }) });
nsRegistryMock.Setup(registry => registry.GetNamespace("root"))
.Returns(fullyConfiguredMapping);
nsRegistryMock.Setup(registry => registry.GetNamespace("clr-namespace:DummyNamespace;Assembly=DummyAssembly"))
.Returns(new ClrNamespace(type.Assembly, type.Namespace));
}
public static XamlNamespace Parse(string xamlNamespaceText)
{
// Declare local variables
XamlNamespace xamlNamespace = new XamlNamespace();
if (xamlNamespaceText.StartsWith("xmlns"))
{
// Read and set the prefix
xamlNamespace.Prefix = xamlNamespaceText.Substring(0, xamlNamespaceText.IndexOf("=")).Replace("xmlns", "").Trim(':');
if (xamlNamespaceText.Contains(";assembly="))
{
// Read the assembly and remove it from xamlNamespaceText
string assembly = xamlNamespaceText.Substring(xamlNamespaceText.IndexOf(";assembly=")).Trim('"');
xamlNamespaceText = xamlNamespaceText.Replace(assembly, "");
// Set the assembly
xamlNamespace.Assembly = assembly.Replace(";assembly=", "");
}
if (xamlNamespaceText.Contains("clr-namespace:"))
{
// Read the clr namespace and remove it from xamlNamespaceText
string clrNameSpace = xamlNamespaceText.Substring(xamlNamespaceText.IndexOf("clr-namespace:")).Trim('"');
xamlNamespaceText = xamlNamespaceText.Replace(clrNameSpace, "");
// Set the clr and xml namespaces
xamlNamespace.ClrNamespace = clrNameSpace.Replace("clr-namespace:", "");
xamlNamespace.XmlNamespace = clrNameSpace;
// If the assembly was not previously set, set it to the clr namespace
if (string.IsNullOrWhiteSpace(xamlNamespace.Assembly))
{
xamlNamespace.Assembly = xamlNamespace.ClrNamespace;
}
}
else
{
// Read and set the xaml namespace
xamlNamespace.XmlNamespace = xamlNamespaceText.Substring(xamlNamespaceText.IndexOf("=")).Trim('=', '"');
}
}
// Return the xaml namespace
return(xamlNamespace);
}
private IEnumerable <XamlNamespace> GetNamespaces(IEnumerable <Assembly> assemblies)
{
var routes = from a in assemblies
let attributes = a.GetCustomAttributes <Tizen.NUI.XmlnsDefinitionAttribute>()
from byNamespace in attributes.GroupBy(arg => arg.XmlNamespace)
let name = byNamespace.Key
let clrNamespaces = byNamespace.Select(arg => arg.ClrNamespace)
let configuredAssemblyWithNamespaces = Route.Assembly(a).WithNamespaces(clrNamespaces.ToArray())
select new { Ns = name, configuredAssemblyWithNamespaces };
var nss = from route in routes
group route by route.Ns
into g
let ns = g.Select(arg => arg.configuredAssemblyWithNamespaces).ToArray()
select XamlNamespace.Map(g.Key).With(ns);
return(nss);
}
private static XamlNamespaceRegistry CreateXamlNamespaceRegistry()
{
var xamlNamespaceRegistry = new XamlNamespaceRegistry();
var rootType = typeof(DummyClass);
var anotherType = typeof(Foreigner);
var definitionForRoot = XamlNamespace
.Map("root")
.With(
new[]
{
Route.Assembly(rootType.GetTypeInfo().Assembly)
.WithNamespaces(
new[]
{
rootType.Namespace,
typeof(Window).Namespace,
})
});
var definitionForAnother = XamlNamespace
.Map("another")
.With(
new[]
{
Route.Assembly(anotherType.GetTypeInfo().Assembly)
.WithNamespaces(new[] { anotherType.Namespace })
});
foreach (var ns in new List <XamlNamespace> {
definitionForRoot, definitionForAnother
})
{
xamlNamespaceRegistry.AddNamespace(ns);
}
xamlNamespaceRegistry.RegisterPrefix(new PrefixRegistration("", "root"));
xamlNamespaceRegistry.RegisterPrefix(new PrefixRegistration("x", "another"));
return(xamlNamespaceRegistry);
}
protected static ParseResult ParseResult(string xaml)
{
var ass = Assembly.Load(new AssemblyName("OmniXaml.Tests"));
var namespaces = new[]
{
XamlNamespace.Map("root").With(Route.Assembly(ass).WithNamespaces("OmniXaml.Tests.Model")),
XamlNamespace.Map("custom").With(Route.Assembly(ass).WithNamespaces("OmniXaml.Tests.Model.Custom")),
};
var directory = new TypeDirectory(namespaces);
var resolver = new XmlTypeXmlTypeResolver(directory);
var sut = new XamlToTreeParser(new AttributeBasedMetadataProvider(), new[] { new InlineParser(resolver) }, resolver);
var prefixAnnotator = new PrefixAnnotator();
var tree = sut.Parse(xaml, prefixAnnotator);
return(tree);
}
private XamlNamespace GetXamlNamespace(string xmlns)
{
XamlNamespace namespace2 = null;
string str;
string str2;
if (this.NamespaceByUriList.TryGetValue(xmlns, out namespace2))
{
return(namespace2);
}
if (ClrNamespaceUriParser.TryParseUri(xmlns, out str, out str2))
{
namespace2 = new XamlNamespace(this, str, str2);
}
else
{
namespace2 = new XamlNamespace(this);
}
return(TryAdd <string, XamlNamespace>(this.NamespaceByUriList, xmlns, namespace2));
}
private static XamlNamespaceRegistry CreateXamlNamespaceRegistry()
{
var xamlNamespaceRegistry = new XamlNamespaceRegistry();
var rootType = typeof(Control);
var bindingType = typeof(BindingExtension);
var templateType = typeof(XamlDataTemplate);
var definitionForRoot = XamlNamespace
.Map(PerspexNs)
.With(
new[]
{
Route.Assembly(rootType.GetTypeInfo().Assembly).WithNamespaces(
new[]
{
rootType.Namespace
}),
Route.Assembly(bindingType.GetTypeInfo().Assembly).WithNamespaces(
new[]
{
bindingType.Namespace,
}),
Route.Assembly(templateType.GetTypeInfo().Assembly).WithNamespaces(
new[]
{
templateType.Namespace,
})
});
foreach (var ns in new List <XamlNamespace> {
definitionForRoot
})
{
xamlNamespaceRegistry.AddNamespace(ns);
}
xamlNamespaceRegistry.RegisterPrefix(new PrefixRegistration(string.Empty, PerspexNs));
return(xamlNamespaceRegistry);
}
private static NamespaceRegistry CreateXamlNamespaceRegistry()
{
var xamlNamespaceRegistry = new NamespaceRegistry();
var windowType = typeof(Window);
var textBlockType = typeof(TextBlock);
var toggleButtonType = typeof(ToggleButton);
var rotateTransformType = typeof(RotateTransform);
var bindingType = typeof(BindingExtension);
var rootNs = XamlNamespace.Map(WpfRootNs)
.With(
new[]
{
Route.Assembly(bindingType.Assembly).WithNamespaces(
new[] { bindingType.Namespace }),
Route.Assembly(rotateTransformType.Assembly).WithNamespaces(
new[] { rotateTransformType.Namespace }),
Route.Assembly(bindingType.Assembly).WithNamespaces(
new[] { bindingType.Namespace }),
Route.Assembly(windowType.Assembly).WithNamespaces(
new[]
{
windowType.Namespace,
textBlockType.Namespace,
toggleButtonType.Namespace
})
});
foreach (var ns in new List <XamlNamespace> {
rootNs
})
{
xamlNamespaceRegistry.AddNamespace(ns);
}
xamlNamespaceRegistry.RegisterPrefix(new PrefixRegistration("", WpfRootNs));
return(xamlNamespaceRegistry);
}
public void AddNamespace(XamlNamespace xamlNamespace)
{
xamlNamespaces.Add(xamlNamespace);
}
public void AddNamespace(XamlNamespace xamlNamespace)
{
NamespaceRegistry.AddNamespace(xamlNamespace);
}
public void AddNamespace(XamlNamespace xamlNamespace)
{
inner.AddNamespace(xamlNamespace);
}
public void AddNamespace(XamlNamespace xamlNamespace)
{
nsRegistry.AddNamespace(xamlNamespace);
}
public void AddNamespace(XamlNamespace xamlNamespace)
{
xamlNamespaces.Add(xamlNamespace);
}
