public override void WriteUnknownTagStart(XamlUnknownTagStartNode xamlUnknownTagStartNode)
{
string localElementFullName = string.Empty;
NamespaceMapEntry[] namespaceMaps = XamlTypeMapper.GetNamespaceMapEntries(xamlUnknownTagStartNode.XmlNamespace);
if (namespaceMaps != null && namespaceMaps.Length == 1 && namespaceMaps[0].LocalAssembly)
{
string ns = namespaceMaps[0].ClrNamespace;
if (!string.IsNullOrEmpty(ns))
{
ns += MarkupCompiler.DOT;
}
localElementFullName = ns + xamlUnknownTagStartNode.Value;
}
if (localElementFullName.Length > 0 && !_pass2)
{
// if local complex property bail out now and handle in 2nd pass when TypInfo is available
int lastIndex = xamlUnknownTagStartNode.Value.LastIndexOf(MarkupCompiler.DOTCHAR);
if (-1 == lastIndex)
{
_compiler.StartElement(ref _class,
_subClass,
ref _classModifier,
null,
localElementFullName);
}
}
else
{
base.WriteUnknownTagStart(xamlUnknownTagStartNode);
}
}
public override void WriteUnknownTagEnd(XamlUnknownTagEndNode xamlUnknownTagEndNode)
{
NamespaceMapEntry[] namespaceMaps = XamlTypeMapper.GetNamespaceMapEntries(xamlUnknownTagEndNode.XmlNamespace);
bool localTag = namespaceMaps != null && namespaceMaps.Length == 1 && namespaceMaps[0].LocalAssembly;
if (localTag && !_pass2)
{
// if local complex property bail out now and handle in 2nd pass when TypInfo is available
int lastIndex = xamlUnknownTagEndNode.LocalName.LastIndexOf(MarkupCompiler.DOTCHAR);
if (-1 == lastIndex)
{
_compiler.EndElement(_pass2);
}
}
else
{
base.WriteUnknownTagEnd(xamlUnknownTagEndNode);
}
}
/// <summary>
/// override of GetElementType
/// </summary>
public override bool GetElementType(
XmlReader xmlReader,
string localName,
string namespaceUri,
ref string assemblyName,
ref string typeFullName,
ref Type baseType,
ref Type serializerType)
{
if (!ProcessedRootElement &&
namespaceUri.Equals(XamlReaderHelper.DefinitionNamespaceURI) &&
(localName.Equals(XamlReaderHelper.DefinitionCodeTag) ||
localName.Equals(XamlReaderHelper.DefinitionXDataTag)))
{
MarkupCompiler.ThrowCompilerException(SRID.DefinitionTagNotAllowedAtRoot,
xmlReader.Prefix,
localName);
}
bool foundElement = base.GetElementType(xmlReader, localName, namespaceUri,
ref assemblyName, ref typeFullName, ref baseType, ref serializerType);
if (!ProcessedRootElement)
{
int count = xmlReader.AttributeCount;
// save reader's position, to be restored later
string attrName = (xmlReader.NodeType == XmlNodeType.Attribute) ? xmlReader.Name : null;
_isRootTag = true;
_class = string.Empty;
_subClass = string.Empty;
ProcessedRootElement = true;
XamlTypeMapper.IsProtectedAttributeAllowed = false;
xmlReader.MoveToFirstAttribute();
while (--count >= 0)
{
string attribNamespaceURI = xmlReader.LookupNamespace(xmlReader.Prefix);
if (attribNamespaceURI != null &&
attribNamespaceURI.Equals(XamlReaderHelper.DefinitionNamespaceURI))
{
MarkupCompiler.DefinitionNSPrefix = xmlReader.Prefix;
if (xmlReader.LocalName == CLASS)
{
_class = xmlReader.Value.Trim();
if (_class == string.Empty)
{
// flag an error for processing later in WriteDefAttribute
_class = MarkupCompiler.DOT;
}
else
{
// flag this so that the Type Mapper can allow protected
// attributes on the markup sub-classed root element only.
XamlTypeMapper.IsProtectedAttributeAllowed = true;
}
}
else if (xmlReader.LocalName == XamlReaderHelper.DefinitionTypeArgs)
{
string genericName = _compiler.GetGenericTypeName(localName, xmlReader.Value);
foundElement = base.GetElementType(xmlReader, genericName, namespaceUri,
ref assemblyName, ref typeFullName, ref baseType, ref serializerType);
if (!foundElement)
{
NamespaceMapEntry[] namespaceMaps = XamlTypeMapper.GetNamespaceMapEntries(namespaceUri);
bool isLocal = namespaceMaps != null && namespaceMaps.Length == 1 && namespaceMaps[0].LocalAssembly;
if (!isLocal)
{
MarkupCompiler.ThrowCompilerException(SRID.UnknownGenericType,
MarkupCompiler.DefinitionNSPrefix,
xmlReader.Value,
localName);
}
}
}
else if (xmlReader.LocalName == SUBCLASS)
{
_subClass = xmlReader.Value.Trim();
if (_subClass == string.Empty)
{
// flag an error for processing later in WriteDefAttribute
_subClass = MarkupCompiler.DOT;
}
else
{
_compiler.ValidateFullSubClassName(ref _subClass);
}
}
else if (xmlReader.LocalName == CLASSMODIFIER)
{
if (!_pass2)
{
_classModifier = xmlReader.Value.Trim();
if (_classModifier == string.Empty)
{
// flag an error for processing later in WriteDefAttribute
_classModifier = MarkupCompiler.DOT;
}
}
else
{
// This direct comparison is ok to do in pass2 as it has already been validated in pass1.
// This is to avoid a costly instantiation of the CodeDomProvider in pass2.
_isInternalRoot = string.Compare("public", xmlReader.Value.Trim(), StringComparison.OrdinalIgnoreCase) != 0;
}
}
}
xmlReader.MoveToNextAttribute();
}
if (namespaceUri.Equals(XamlReaderHelper.DefinitionNamespaceURI))
{
xmlReader.MoveToElement();
}
else
{
if (attrName == null)
{
xmlReader.MoveToFirstAttribute();
}
else
{
xmlReader.MoveToAttribute(attrName);
}
}
}
else if (!_compiler.IsBamlNeeded && !_compiler.ProcessingRootContext && _compiler.IsCompilingEntryPointClass && xmlReader.Depth > 0)
{
if ((!localName.Equals(MarkupCompiler.CODETAG) &&
!localName.Equals(MarkupCompiler.CODETAG + "Extension")) ||
!namespaceUri.Equals(XamlReaderHelper.DefinitionNamespaceURI))
{
_compiler.IsBamlNeeded = true;
}
}
return(foundElement);
}
public override void WriteUnknownAttribute(XamlUnknownAttributeNode xamlUnknownAttributeNode)
{
bool localAttrib = false;
string localTagFullName = string.Empty;
string localAttribName = xamlUnknownAttributeNode.Name;
NamespaceMapEntry[] namespaceMaps = null;
MemberInfo miKnownEvent = null;
if (xamlUnknownAttributeNode.OwnerTypeFullName.Length > 0)
{
// These are attributes on a local tag ...
localTagFullName = xamlUnknownAttributeNode.OwnerTypeFullName;
localAttrib = true;
}
else
{
// These are attributes on a non-local tag ...
namespaceMaps = XamlTypeMapper.GetNamespaceMapEntries(xamlUnknownAttributeNode.XmlNamespace);
localAttrib = namespaceMaps != null && namespaceMaps.Length == 1 && namespaceMaps[0].LocalAssembly;
}
if (localAttrib && !_pass2)
{
// ... and if there are any periods in the attribute name, then ...
int lastIndex = localAttribName.LastIndexOf(MarkupCompiler.DOTCHAR);
if (-1 != lastIndex)
{
// ... these might be attached props or events defined by a locally defined component,
// but being set on this non-local tag.
TypeAndSerializer typeAndSerializer = null;
string ownerTagName = localAttribName.Substring(0, lastIndex);
if (namespaceMaps != null)
{
if (namespaceMaps.Length == 1 && namespaceMaps[0].LocalAssembly)
{
// local prop on a known tag
localTagFullName = namespaceMaps[0].ClrNamespace + MarkupCompiler.DOT + ownerTagName;
}
}
else
{
typeAndSerializer = XamlTypeMapper.GetTypeOnly(xamlUnknownAttributeNode.XmlNamespace,
ownerTagName);
if (typeAndSerializer != null)
{
// known local attribute on a local tag
Type ownerTagType = typeAndSerializer.ObjectType;
localTagFullName = ownerTagType.FullName;
localAttribName = localAttribName.Substring(lastIndex + 1);
// See if attached event first
miKnownEvent = ownerTagType.GetMethod(MarkupCompiler.ADD + localAttribName + MarkupCompiler.HANDLER,
BindingFlags.Public | BindingFlags.Static |
BindingFlags.FlattenHierarchy);
if (miKnownEvent == null)
{
// Not an attached event, so try for a clr event.
miKnownEvent = ownerTagType.GetEvent(localAttribName,
BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy);
}
if (miKnownEvent != null)
{
if (_events == null)
{
_events = new ArrayList();
}
_events.Add(new MarkupCompiler.MarkupEventInfo(xamlUnknownAttributeNode.Value,
localAttribName,
miKnownEvent,
xamlUnknownAttributeNode.LineNumber));
WriteConnectionId();
}
}
else
{
namespaceMaps = XamlTypeMapper.GetNamespaceMapEntries(xamlUnknownAttributeNode.XmlNamespace);
if (namespaceMaps != null && namespaceMaps.Length == 1 && namespaceMaps[0].LocalAssembly)
{
// local prop on local tag
localTagFullName = namespaceMaps[0].ClrNamespace + MarkupCompiler.DOT + ownerTagName;
}
else
{
// unknown prop on local tag -- Error!
localTagFullName = string.Empty;
}
}
}
if (typeAndSerializer == null)
{
localAttribName = localAttribName.Substring(lastIndex + 1);
}
}
// else if it is an unknown non-attached prop on a non-local tag -- instant error!
}
if (localTagFullName.Length > 0 && !_pass2)
{
if (xamlUnknownAttributeNode.AttributeUsage == BamlAttributeUsage.RuntimeName)
{
string attributeValue = xamlUnknownAttributeNode.Value;
Debug.Assert(_name == null && _nameField == null, "Name has already been set");
_nameField = _compiler.AddNameField(attributeValue, xamlUnknownAttributeNode.LineNumber, xamlUnknownAttributeNode.LinePosition);
_name = attributeValue;
if (_nameField != null)
{
WriteConnectionId();
}
}
else if (localAttribName.Equals(STARTUPURI) &&
_compiler.IsCompilingEntryPointClass)
{
// if Application.StartuoUri property then don't bamlize, but gen code since
// this is better for perf as Application is not a DO.
PropertyInfo pi = KnownTypes.Types[(int)KnownElements.Application].GetProperty(localAttribName);
_compiler.AddApplicationProperty(pi,
xamlUnknownAttributeNode.Value,
xamlUnknownAttributeNode.LineNumber);
return;
}
else if (miKnownEvent == null)
{
// This may or may not be a local event, but there is no way to know in Pass1.
// So we prepare for the worst case sceanrio and assume it may be one so that
// the Xaml compiler can generate the CreateDelegate code.
_compiler.HasLocalEvent = true;
}
}
else
{
base.WriteUnknownAttribute(xamlUnknownAttributeNode);
}
_compiler.IsBamlNeeded = true;
}
