private dfMarkupElement parseElement(Queue <dfMarkupElement> tokens)
{
dfMarkupElement element = tokens.Dequeue();
if (element is dfMarkupString)
{
return(((dfMarkupString)element).SplitWords());
}
dfMarkupTag original = (dfMarkupTag)element;
if (!original.IsClosedTag && !original.IsEndTag)
{
while (tokens.Count > 0)
{
dfMarkupElement node = this.parseElement(tokens);
if (node is dfMarkupTag)
{
dfMarkupTag tag2 = (dfMarkupTag)node;
if (tag2.IsEndTag)
{
if (tag2.TagName == original.TagName)
{
break;
}
return(this.refineTag(original));
}
}
original.AddChildNode(node);
}
}
return(this.refineTag(original));
}
protected internal override void OnMouseUp(dfMouseEventArgs args)
{
base.OnMouseUp(args);
isMouseDown = false;
if (Vector2.Distance(scrollPosition, mouseDownScrollPosition) <= 2)
{
if (hitTestTag(args) == mouseDownTag)
{
var linkTag = mouseDownTag;
while (linkTag != null && !(linkTag is dfMarkupTagAnchor))
{
linkTag = linkTag.Parent as dfMarkupTag;
}
if (linkTag is dfMarkupTagAnchor)
{
Signal("OnLinkClicked", this, linkTag);
if (this.LinkClicked != null)
{
this.LinkClicked(this, linkTag as dfMarkupTagAnchor);
}
}
}
}
mouseDownTag = null;
mouseDownScrollPosition = scrollPosition;
}
private dfMarkupTag refineTag(dfMarkupTag original)
{
if (!original.IsEndTag)
{
if (tagTypes == null)
{
tagTypes = new Dictionary <string, Type>();
foreach (Type type in Assembly.GetExecutingAssembly().GetExportedTypes())
{
if (typeof(dfMarkupTag).IsAssignableFrom(type))
{
object[] customAttributes = type.GetCustomAttributes(typeof(dfMarkupTagInfoAttribute), true);
if ((customAttributes != null) && (customAttributes.Length != 0))
{
for (int i = 0; i < customAttributes.Length; i++)
{
string tagName = ((dfMarkupTagInfoAttribute)customAttributes[i]).TagName;
tagTypes[tagName] = type;
}
}
}
}
}
if (tagTypes.ContainsKey(original.TagName))
{
Type type2 = tagTypes[original.TagName];
object[] args = new object[] { original };
return((dfMarkupTag)Activator.CreateInstance(type2, args));
}
}
return(original);
}
private dfMarkupElement parseElement(Queue <dfMarkupElement> tokens)
{
dfMarkupElement _dfMarkupElement = tokens.Dequeue();
if (_dfMarkupElement is dfMarkupString)
{
return(((dfMarkupString)_dfMarkupElement).SplitWords());
}
dfMarkupTag _dfMarkupTag = (dfMarkupTag)_dfMarkupElement;
if (_dfMarkupTag.IsClosedTag || _dfMarkupTag.IsEndTag)
{
return(this.refineTag(_dfMarkupTag));
}
while (tokens.Count > 0)
{
dfMarkupElement _dfMarkupElement1 = this.parseElement(tokens);
if (_dfMarkupElement1 is dfMarkupTag)
{
dfMarkupTag _dfMarkupTag1 = (dfMarkupTag)_dfMarkupElement1;
if (_dfMarkupTag1.IsEndTag)
{
if (_dfMarkupTag1.TagName != _dfMarkupTag.TagName)
{
return(this.refineTag(_dfMarkupTag));
}
break;
}
}
_dfMarkupTag.AddChildNode(_dfMarkupElement1);
}
return(this.refineTag(_dfMarkupTag));
}
private dfMarkupTag refineTag(dfMarkupTag original)
{
if (original.IsEndTag)
{
return(original);
}
if (dfMarkupParser.tagTypes == null)
{
dfMarkupParser.tagTypes = new Dictionary <string, Type>();
Type[] exportedTypes = Assembly.GetExecutingAssembly().GetExportedTypes();
for (int i = 0; i < (int)exportedTypes.Length; i++)
{
Type type = exportedTypes[i];
if (typeof(dfMarkupTag).IsAssignableFrom(type))
{
object[] customAttributes = type.GetCustomAttributes(typeof(dfMarkupTagInfoAttribute), true);
if (customAttributes != null && (int)customAttributes.Length != 0)
{
for (int j = 0; j < (int)customAttributes.Length; j++)
{
string tagName = ((dfMarkupTagInfoAttribute)customAttributes[j]).TagName;
dfMarkupParser.tagTypes[tagName] = type;
}
}
}
}
}
if (!dfMarkupParser.tagTypes.ContainsKey(original.TagName))
{
return(original);
}
Type item = dfMarkupParser.tagTypes[original.TagName];
return((dfMarkupTag)Activator.CreateInstance(item, new object[] { original }));
}
protected internal override void OnMouseDown(dfMouseEventArgs args)
{
base.OnMouseDown(args);
this.mouseDownTag = this.hitTestTag(args);
this.mouseDownScrollPosition = this.scrollPosition;
this.scrollMomentum = Vector2.zero;
this.touchStartPosition = args.Position;
this.isMouseDown = true;
}
private dfMarkupElement parseTag(System.Text.RegularExpressions.Match tag)
{
var tagName = tag.Groups["tag"].Value.ToLowerInvariant();
if (tag.Value.StartsWith("</"))
{
return(new dfMarkupTag(tagName)
{
IsEndTag = true
});
}
var element = new dfMarkupTag(tagName);
var attributes = tag.Groups["attr"].Value;
var matches = ATTR_PATTERN.Matches(attributes);
for (int i = 0; i < matches.Count; i++)
{
var attrMatch = matches[i];
var key = attrMatch.Groups["key"].Value;
var value = dfMarkupEntity.Replace(attrMatch.Groups["value"].Value);
if (value.StartsWith("\""))
{
value = value.Trim('"');
}
else if (value.StartsWith("'"))
{
value = value.Trim('\'');
}
if (string.IsNullOrEmpty(value))
{
continue;
}
if (key == "style")
{
parseStyleAttribute(element, value);
}
else
{
element.Attributes.Add(new dfMarkupAttribute(key, value));
}
}
if (tag.Value.EndsWith("/>") || tagName == "br" || tagName == "img")
{
element.IsClosedTag = true;
}
return(element);
}
private void parseStyleAttribute(dfMarkupTag element, string text)
{
MatchCollection matchs = STYLE_PATTERN.Matches(text);
for (int i = 0; i < matchs.Count; i++)
{
Match match = matchs[i];
string name = match.Groups["key"].Value.ToLowerInvariant();
string str2 = match.Groups["value"].Value;
element.Attributes.Add(new dfMarkupAttribute(name, str2));
}
}
private void parseStyleAttribute(dfMarkupTag element, string text)
{
MatchCollection matchCollections = dfMarkupParser.STYLE_PATTERN.Matches(text);
for (int i = 0; i < matchCollections.Count; i++)
{
Match item = matchCollections[i];
string lowerInvariant = item.Groups["key"].Value.ToLowerInvariant();
string value = item.Groups["value"].Value;
element.Attributes.Add(new dfMarkupAttribute(lowerInvariant, value));
}
}
private void parseStyleAttribute(dfMarkupTag element, string text)
{
var matches = STYLE_PATTERN.Matches(text);
for (int i = 0; i < matches.Count; i++)
{
var match = matches[i];
var key = match.Groups["key"].Value.ToLowerInvariant();
var value = match.Groups["value"].Value;
element.Attributes.Add(new dfMarkupAttribute(key, value));
}
}
public dfMarkupTag(dfMarkupTag original)
{
this.TagName = original.TagName;
this.Attributes = original.Attributes;
this.IsEndTag = original.IsEndTag;
this.IsClosedTag = original.IsClosedTag;
this.IsInline = original.IsInline;
this.id = original.id;
List<dfMarkupElement> childNodes = original.ChildNodes;
for (int i = 0; i < childNodes.Count; i++)
{
base.AddChildNode(childNodes[i]);
}
}
public dfMarkupTag(dfMarkupTag original)
{
this.TagName = original.TagName;
this.Attributes = original.Attributes;
this.IsEndTag = original.IsEndTag;
this.IsClosedTag = original.IsClosedTag;
this.IsInline = original.IsInline;
this.id = original.id;
List <dfMarkupElement> childNodes = original.ChildNodes;
for (int i = 0; i < childNodes.Count; i++)
{
base.AddChildNode(childNodes[i]);
}
}
public dfMarkupTag(dfMarkupTag original)
{
this.TagName = original.TagName;
this.Attributes = original.Attributes;
this.IsEndTag = original.IsEndTag;
this.IsClosedTag = original.IsClosedTag;
this.IsInline = original.IsInline;
this.id = original.id;
System.Collections.Generic.List <dfMarkupElement> childNodes = original.ChildNodes;
for (int i = 0; i < childNodes.Count; i++)
{
dfMarkupElement node = childNodes[i];
base.AddChildNode(node);
}
}
private dfMarkupElement parseTag(Match tag)
{
string tagName = tag.Groups["tag"].Value.ToLowerInvariant();
if (tag.Value.StartsWith("</"))
{
return(new dfMarkupTag(tagName)
{
IsEndTag = true
});
}
dfMarkupTag element = new dfMarkupTag(tagName);
string input = tag.Groups["attr"].Value;
MatchCollection matchs = ATTR_PATTERN.Matches(input);
for (int i = 0; i < matchs.Count; i++)
{
Match match = matchs[i];
string name = match.Groups["key"].Value;
string str4 = dfMarkupEntity.Replace(match.Groups["value"].Value);
if (str4.StartsWith("\""))
{
char[] trimChars = new char[] { '"' };
str4 = str4.Trim(trimChars);
}
else if (str4.StartsWith("'"))
{
char[] chArray2 = new char[] { '\'' };
str4 = str4.Trim(chArray2);
}
if (!string.IsNullOrEmpty(str4))
{
if (name == "style")
{
this.parseStyleAttribute(element, str4);
}
else
{
element.Attributes.Add(new dfMarkupAttribute(name, str4));
}
}
}
if ((tag.Value.EndsWith("/>") || (tagName == "br")) || (tagName == "img"))
{
element.IsClosedTag = true;
}
return(element);
}
private void releaseMarkupReferences()
{
this.mouseDownTag = null;
if (this.viewportBox != null)
{
this.viewportBox.Release();
}
if (this.elements != null)
{
for (int i = 0; i < this.elements.Count; i++)
{
this.elements[i].Release();
}
this.elements.Release();
}
}
/// <summary>
/// Refines a generic dfMarkupTag instance into a more specific
/// derived class instance, if one can be determined
/// </summary>
/// <param name="original"></param>
/// <returns></returns>
private dfMarkupTag refineTag(dfMarkupTag original)
{
// Don't bother refining end tags, they only exist to indicate
// when we are done parsing/processing a tag that has child
// elements.
if (original.IsEndTag)
{
return(original);
}
if (tagTypes == null)
{
tagTypes = new Dictionary <string, Type>();
var assemblyTypes = getAssemblyTypes();
for (int i = 0; i < assemblyTypes.Length; i++)
{
var type = assemblyTypes[i];
if (!typeof(dfMarkupTag).IsAssignableFrom(type))
{
continue;
}
var attributes = type.GetCustomAttributes(typeof(dfMarkupTagInfoAttribute), true);
if (attributes == null || attributes.Length == 0)
{
continue;
}
for (int x = 0; x < attributes.Length; x++)
{
var tagName = ((dfMarkupTagInfoAttribute)attributes[x]).TagName;
tagTypes[tagName] = type;
}
}
}
if (tagTypes.ContainsKey(original.TagName))
{
var tagType = tagTypes[original.TagName];
return((dfMarkupTag)Activator.CreateInstance(tagType, original));
}
return(original);
}
public dfMarkupTag( dfMarkupTag original )
: base()
{
this.TagName = original.TagName;
this.Attributes = original.Attributes;
this.IsEndTag = original.IsEndTag;
this.IsClosedTag = original.IsClosedTag;
this.IsInline = original.IsInline;
this.id = original.id;
var children = original.ChildNodes;
for( int i = 0; i < children.Count; i++ )
{
var child = children[ i ];
AddChildNode( child );
}
}
private dfMarkupElement parseTag(Match tag)
{
string lowerInvariant = tag.Groups["tag"].Value.ToLowerInvariant();
if (tag.Value.StartsWith("</"))
{
return(new dfMarkupTag(lowerInvariant)
{
IsEndTag = true
});
}
dfMarkupTag _dfMarkupTag = new dfMarkupTag(lowerInvariant);
string value = tag.Groups["attr"].Value;
MatchCollection matchCollections = dfMarkupParser.ATTR_PATTERN.Matches(value);
for (int i = 0; i < matchCollections.Count; i++)
{
Match item = matchCollections[i];
string str = item.Groups["key"].Value;
string str1 = dfMarkupEntity.Replace(item.Groups["value"].Value);
if (str1.StartsWith("\""))
{
str1 = str1.Trim(new char[] { '\"' });
}
else if (str1.StartsWith("'"))
{
str1 = str1.Trim(new char[] { '\'' });
}
if (!string.IsNullOrEmpty(str1))
{
if (str != "style")
{
_dfMarkupTag.Attributes.Add(new dfMarkupAttribute(str, str1));
}
else
{
this.parseStyleAttribute(_dfMarkupTag, str1);
}
}
}
if (tag.Value.EndsWith("/>") || lowerInvariant == "br" || lowerInvariant == "img")
{
_dfMarkupTag.IsClosedTag = true;
}
return(_dfMarkupTag);
}
public dfMarkupTag(dfMarkupTag original)
: base()
{
this.TagName = original.TagName;
this.Attributes = original.Attributes;
this.IsEndTag = original.IsEndTag;
this.IsClosedTag = original.IsClosedTag;
this.IsInline = original.IsInline;
this.id = original.id;
var children = original.ChildNodes;
for (int i = 0; i < children.Count; i++)
{
var child = children[i];
AddChildNode(child);
}
}
protected override void _PerformLayoutImpl(dfMarkupBox container, dfMarkupStyle style)
{
if (base.ChildNodes.Count != 0)
{
style.Align = dfMarkupTextAlign.Left;
dfMarkupBox box = new dfMarkupBox(this, dfMarkupDisplayType.block, style);
container.AddChild(box);
this.calculateBulletWidth(style);
for (int i = 0; i < base.ChildNodes.Count; i++)
{
dfMarkupTag tag = base.ChildNodes[i] as dfMarkupTag;
if ((tag != null) && (tag.TagName == "li"))
{
tag.PerformLayout(box, style);
}
}
box.FitToContents(false);
}
}
protected override void _PerformLayoutImpl(dfMarkupBox container, dfMarkupStyle style)
{
if (base.ChildNodes.Count == 0)
{
return;
}
style.Align = dfMarkupTextAlign.Left;
dfMarkupBox _dfMarkupBox = new dfMarkupBox(this, dfMarkupDisplayType.block, style);
container.AddChild(_dfMarkupBox);
this.calculateBulletWidth(style);
for (int i = 0; i < base.ChildNodes.Count; i++)
{
dfMarkupTag item = base.ChildNodes[i] as dfMarkupTag;
if (item != null && !(item.TagName != "li"))
{
item.PerformLayout(_dfMarkupBox, style);
}
}
_dfMarkupBox.FitToContents(false);
}
private void calculateBulletWidth(dfMarkupStyle style)
{
if (base.TagName == "ul")
{
Vector2 vector = style.Font.MeasureText("•", style.FontSize, style.FontStyle);
this.BulletWidth = Mathf.CeilToInt(vector.x);
}
else
{
int num = 0;
for (int i = 0; i < base.ChildNodes.Count; i++)
{
dfMarkupTag tag = base.ChildNodes[i] as dfMarkupTag;
if ((tag != null) && (tag.TagName == "li"))
{
num++;
}
}
string text = new string('X', num.ToString().Length) + ".";
Vector2 vector2 = style.Font.MeasureText(text, style.FontSize, style.FontStyle);
this.BulletWidth = Mathf.CeilToInt(vector2.x);
}
}
protected internal override void OnMouseUp(dfMouseEventArgs args)
{
base.OnMouseUp(args);
this.isMouseDown = false;
if (Vector2.Distance(this.scrollPosition, this.mouseDownScrollPosition) <= 2f && this.hitTestTag(args) == this.mouseDownTag)
{
dfMarkupTag parent = this.mouseDownTag;
while (parent != null && !(parent is dfMarkupTagAnchor))
{
parent = parent.Parent as dfMarkupTag;
}
if (parent is dfMarkupTagAnchor)
{
base.Signal("OnLinkClicked", new object[] { parent });
if (this.LinkClicked != null)
{
this.LinkClicked(this, parent as dfMarkupTagAnchor);
}
}
}
this.mouseDownTag = null;
this.mouseDownScrollPosition = this.scrollPosition;
}
private void calculateBulletWidth(dfMarkupStyle style)
{
if (base.TagName == "ul")
{
Vector2 vector2 = style.Font.MeasureText("•", style.FontSize, style.FontStyle);
this.BulletWidth = Mathf.CeilToInt(vector2.x);
return;
}
int num = 0;
for (int i = 0; i < base.ChildNodes.Count; i++)
{
dfMarkupTag item = base.ChildNodes[i] as dfMarkupTag;
if (item != null && item.TagName == "li")
{
num++;
}
}
string str = string.Concat(new string('X', num.ToString().Length), ".");
Vector2 vector21 = style.Font.MeasureText(str, style.FontSize, style.FontStyle);
this.BulletWidth = Mathf.CeilToInt(vector21.x);
}
protected internal override void OnMouseUp(dfMouseEventArgs args)
{
base.OnMouseUp(args);
this.isMouseDown = false;
if ((Vector2.Distance(this.scrollPosition, this.mouseDownScrollPosition) <= 2f) && (this.hitTestTag(args) == this.mouseDownTag))
{
dfMarkupTag mouseDownTag = this.mouseDownTag;
while ((mouseDownTag != null) && !(mouseDownTag is dfMarkupTagAnchor))
{
mouseDownTag = mouseDownTag.Parent as dfMarkupTag;
}
if (mouseDownTag is dfMarkupTagAnchor)
{
object[] objArray1 = new object[] { mouseDownTag };
base.Signal("OnLinkClicked", objArray1);
if (this.LinkClicked != null)
{
this.LinkClicked(this, mouseDownTag as dfMarkupTagAnchor);
}
}
}
this.mouseDownTag = null;
this.mouseDownScrollPosition = this.scrollPosition;
}
public dfMarkupTagHeading(dfMarkupTag original) : base(original)
{
}
public dfMarkupTagFont( dfMarkupTag original )
: base(original)
{
}
public dfMarkupTagFont(dfMarkupTag original) : base(original)
{
}
private void releaseMarkupReferences()
{
this.mouseDownTag = null;
if( viewportBox != null )
{
viewportBox.Release();
}
if( elements != null )
{
for( int i = 0; i < elements.Count; i++ )
{
elements[ i ].Release();
}
elements.Release();
}
}
public dfMarkupTagParagraph( dfMarkupTag original )
: base(original)
{
}
public dfMarkupTagItalic( dfMarkupTag original )
: base(original)
{
}
public dfMarkupTagHeading( dfMarkupTag original )
: base(original)
{
}
protected internal override void OnMouseUp(dfMouseEventArgs args)
{
base.OnMouseUp(args);
this.isMouseDown = false;
if (Vector2.Distance(this.scrollPosition, this.mouseDownScrollPosition) <= 2f && this.hitTestTag(args) == this.mouseDownTag)
{
dfMarkupTag parent = this.mouseDownTag;
while (parent != null && !(parent is dfMarkupTagAnchor))
{
parent = parent.Parent as dfMarkupTag;
}
if (parent is dfMarkupTagAnchor)
{
base.Signal("OnLinkClicked", new object[] { parent });
if (this.LinkClicked != null)
{
this.LinkClicked(this, parent as dfMarkupTagAnchor);
}
}
}
this.mouseDownTag = null;
this.mouseDownScrollPosition = this.scrollPosition;
}
protected internal override void OnMouseDown( dfMouseEventArgs args )
{
base.OnMouseDown( args );
this.mouseDownTag = hitTestTag( args );
this.mouseDownScrollPosition = scrollPosition;
scrollMomentum = Vector2.zero;
touchStartPosition = args.Position;
isMouseDown = true;
}
protected internal override void OnMouseUp( dfMouseEventArgs args )
{
base.OnMouseUp( args );
isMouseDown = false;
if( Vector2.Distance( scrollPosition, mouseDownScrollPosition ) <= 2 )
{
if( hitTestTag( args ) == mouseDownTag )
{
var linkTag = mouseDownTag;
while( linkTag != null && !( linkTag is dfMarkupTagAnchor ) )
{
linkTag = linkTag.Parent as dfMarkupTag;
}
if( linkTag is dfMarkupTagAnchor )
{
Signal( "OnLinkClicked", linkTag );
if( this.LinkClicked != null )
{
this.LinkClicked( this, linkTag as dfMarkupTagAnchor );
}
}
}
}
mouseDownTag = null;
mouseDownScrollPosition = scrollPosition;
}
private dfMarkupTag refineTag(dfMarkupTag original)
{
if (original.IsEndTag)
{
return original;
}
if (dfMarkupParser.tagTypes == null)
{
dfMarkupParser.tagTypes = new Dictionary<string, Type>();
Type[] exportedTypes = Assembly.GetExecutingAssembly().GetExportedTypes();
for (int i = 0; i < (int)exportedTypes.Length; i++)
{
Type type = exportedTypes[i];
if (typeof(dfMarkupTag).IsAssignableFrom(type))
{
object[] customAttributes = type.GetCustomAttributes(typeof(dfMarkupTagInfoAttribute), true);
if (customAttributes != null && (int)customAttributes.Length != 0)
{
for (int j = 0; j < (int)customAttributes.Length; j++)
{
string tagName = ((dfMarkupTagInfoAttribute)customAttributes[j]).TagName;
dfMarkupParser.tagTypes[tagName] = type;
}
}
}
}
}
if (!dfMarkupParser.tagTypes.ContainsKey(original.TagName))
{
return original;
}
Type item = dfMarkupParser.tagTypes[original.TagName];
return (dfMarkupTag)Activator.CreateInstance(item, new object[] { original });
}
public dfMarkupTagBold(dfMarkupTag original) : base(original)
{
}
public dfMarkupTagAnchor(dfMarkupTag original) : base(original)
{
}
public dfMarkupTagItalic(dfMarkupTag original) : base(original)
{
}
public dfMarkupTagAnchor( dfMarkupTag original )
: base(original)
{
}
public dfMarkupTagSpan( dfMarkupTag original )
: base(original)
{
}
private dfMarkupElement parseTag(Match tag)
{
string lowerInvariant = tag.Groups["tag"].Value.ToLowerInvariant();
if (tag.Value.StartsWith("</"))
{
return new dfMarkupTag(lowerInvariant)
{
IsEndTag = true
};
}
dfMarkupTag _dfMarkupTag = new dfMarkupTag(lowerInvariant);
string value = tag.Groups["attr"].Value;
MatchCollection matchCollections = dfMarkupParser.ATTR_PATTERN.Matches(value);
for (int i = 0; i < matchCollections.Count; i++)
{
Match item = matchCollections[i];
string str = item.Groups["key"].Value;
string str1 = dfMarkupEntity.Replace(item.Groups["value"].Value);
if (str1.StartsWith("\""))
{
str1 = str1.Trim(new char[] { '\"' });
}
else if (str1.StartsWith("'"))
{
str1 = str1.Trim(new char[] { '\'' });
}
if (!string.IsNullOrEmpty(str1))
{
if (str != "style")
{
_dfMarkupTag.Attributes.Add(new dfMarkupAttribute(str, str1));
}
else
{
this.parseStyleAttribute(_dfMarkupTag, str1);
}
}
}
if (tag.Value.EndsWith("/>") || lowerInvariant == "br" || lowerInvariant == "img")
{
_dfMarkupTag.IsClosedTag = true;
}
return _dfMarkupTag;
}
public dfMarkupTagBold( dfMarkupTag original )
: base(original)
{
}
private void parseStyleAttribute(dfMarkupTag element, string text)
{
MatchCollection matchCollections = dfMarkupParser.STYLE_PATTERN.Matches(text);
for (int i = 0; i < matchCollections.Count; i++)
{
Match item = matchCollections[i];
string lowerInvariant = item.Groups["key"].Value.ToLowerInvariant();
string value = item.Groups["value"].Value;
element.Attributes.Add(new dfMarkupAttribute(lowerInvariant, value));
}
}
public dfMarkupTagParagraph(dfMarkupTag original) : base(original)
{
}
public dfMarkupTagList(dfMarkupTag original) : base(original)
{
}
public dfMarkupTagImg( dfMarkupTag original )
: base(original)
{
this.IsClosedTag = true;
}
private void parseStyleAttribute( dfMarkupTag element, string text )
{
var matches = STYLE_PATTERN.Matches( text );
for( int i = 0; i < matches.Count; i++ )
{
var match = matches[ i ];
var key = match.Groups[ "key" ].Value.ToLowerInvariant();
var value = match.Groups[ "value" ].Value;
element.Attributes.Add( new dfMarkupAttribute( key, value ) );
}
}
public dfMarkupTagListItem( dfMarkupTag original )
: base(original)
{
}
private dfMarkupElement parseTag( Match tag )
{
var tagName = tag.Groups[ "tag" ].Value.ToLowerInvariant();
if( tag.Value.StartsWith( "</" ) )
{
return new dfMarkupTag( tagName ) { IsEndTag = true };
}
var element = new dfMarkupTag( tagName );
var attributes = tag.Groups[ "attr" ].Value;
var matches = ATTR_PATTERN.Matches( attributes );
for( int i = 0; i < matches.Count; i++ )
{
var attrMatch = matches[ i ];
var key = attrMatch.Groups[ "key" ].Value;
var value = dfMarkupEntity.Replace( attrMatch.Groups[ "value" ].Value );
if( value.StartsWith( "\"" ) )
value = value.Trim( '"' );
else if( value.StartsWith( "'" ) )
value = value.Trim( '\'' );
if( string.IsNullOrEmpty( value ) )
continue;
if( key == "style" )
{
parseStyleAttribute( element, value );
}
else
{
element.Attributes.Add( new dfMarkupAttribute( key, value ) );
}
}
if( tag.Value.EndsWith( "/>" ) || tagName == "br" || tagName == "img" )
{
element.IsClosedTag = true;
}
return element;
}
public dfMarkupTagPre( dfMarkupTag original )
: base(original)
{
}
/// <summary>
/// Refines a generic dfMarkupTag instance into a more specific
/// derived class instance, if one can be determined
/// </summary>
/// <param name="original"></param>
/// <returns></returns>
private dfMarkupTag refineTag( dfMarkupTag original )
{
// Don't bother refining end tags, they only exist to indicate
// when we are done parsing/processing a tag that has child
// elements.
if( original.IsEndTag )
return original;
if( tagTypes == null )
{
tagTypes = new Dictionary<string, Type>();
var assemblyTypes = getAssemblyTypes();
for( int i = 0; i < assemblyTypes.Length; i++ )
{
var type = assemblyTypes[ i ];
if( !typeof( dfMarkupTag ).IsAssignableFrom( type ) )
{
continue;
}
var attributes = type.GetCustomAttributes( typeof( dfMarkupTagInfoAttribute ), true );
if( attributes == null || attributes.Length == 0 )
continue;
for( int x = 0; x < attributes.Length; x++ )
{
var tagName = ( (dfMarkupTagInfoAttribute)attributes[ x ] ).TagName;
tagTypes[ tagName ] = type;
}
}
}
if( tagTypes.ContainsKey( original.TagName ) )
{
var tagType = tagTypes[original.TagName];
return (dfMarkupTag)Activator.CreateInstance( tagType, original );
}
return original;
}
