/// <summary>Attempts to find the named tag, returning the global handler if it's found.</summary>
/// <param name="tag">The tag to look for.</param>
/// <returns>The global TagHandler if the tag was found; Null otherwise.</returns>
public static TagHandler GetHandler(string tag)
{
TagHandler handler = null;
Handlers.TryGetValue(tag, out handler);
return(handler);
}
/// <summary>Adds a handler to the set.
/// This is generally done automatically, but you can also add it manually if you wish.</summary>
/// <param name="handler">The handler to add.</param>
/// <returns>True if adding it was successful.</returns>
public static bool AddHandler(TagHandler handler)
{
// Grab the extension:
string extension = handler.TagExtension;
if (extension != null)
{
extension = extension.ToLower() + "-";
}
string[] tags = handler.GetTags();
if (tags == null || tags.Length == 0)
{
return(false);
}
for (int i = 0; i < tags.Length; i++)
{
// Grab the tag name:
string tagName = tags[i].ToLower();
if (extension != null)
{
// Drop it in at the start.
tagName = extension + tagName;
}
TagHandler existingHandler;
// Does it already exist?
if (Handlers.TryGetValue(tagName, out existingHandler))
{
// Yes - compare priorities:
if (handler.Priority < existingHandler.Priority)
{
// We're trying to override with a lower priority.
continue;
}
else
{
// override it!
Handlers[tagName] = handler;
}
}
else
{
// Directly add it in:
Handlers.Add(tagName, handler);
}
}
return(true);
}
/// <summary>Attempts to find the tag with the given name.
/// If it's not found, a default tag which is known to exist can be returned instead.
/// The handler for the found tag is then instanced and the instance is returned.
/// For example, tag "h1" with a default of "span".</summary>
/// <param name="tag">The tag to look for.</param>
/// <param name="defaultTag">If the given tag is not found, this is used instead.</param>
/// <returns>An instance of the tag handler for the tag. Throws an error if tag or defaultTag are not found.</returns>
public static TagHandler GetHandler(string tag, string defaultTag)
{
TagHandler globalHandler = GetHandler(tag);
if (globalHandler == null)
{
globalHandler = GetHandler(defaultTag);
}
return(globalHandler.GetInstance());
}
public override void SetTag(string tag){
base.SetTag(tag);
// Var is our default tag handler:
Handler=TagHandlers.GetHandler("lang-"+Tag,"lang-var");
if(!SelfClosing){
SelfClosing=Handler.SelfClosing();
}
VariableTag varTag=Handler as VariableTag;
if(varTag!=null){
varTag.Element=this;
}
}
public override void SetTag(string tag)
{
base.SetTag(tag);
// Var is our default tag handler:
Handler = TagHandlers.GetHandler("lang-" + Tag, "lang-var");
if (!SelfClosing)
{
SelfClosing = Handler.SelfClosing();
}
VariableTag varTag = Handler as VariableTag;
if (varTag != null)
{
varTag.Element = this;
}
}
/// <summary>Adds a handler to the set.
/// This is generally done automatically, but you can also add it manually if you wish.</summary>
/// <param name="handler">The handler to add.</param>
/// <returns>True if adding it was successful.</returns>
public static bool AddHandler(TagHandler handler){
// Grab the extension:
string extension=handler.TagExtension;
if(extension!=null){
extension=extension.ToLower()+"-";
}
string[] tags=handler.GetTags();
if(tags==null||tags.Length==0){
return false;
}
for(int i=0;i<tags.Length;i++){
// Grab the tag name:
string tagName=tags[i].ToLower();
if(extension!=null){
// Drop it in at the start.
tagName=extension+tagName;
}
TagHandler existingHandler;
// Does it already exist?
if(Handlers.TryGetValue(tagName,out existingHandler)){
// Yes - compare priorities:
if(handler.Priority<existingHandler.Priority){
// We're trying to override with a lower priority.
continue;
}else{
// override it!
Handlers[tagName]=handler;
}
}else{
// Directly add it in:
Handlers.Add(tagName,handler);
}
}
return true;
}
/// <summary>Reads the children for this tag from a lexer.</summary>
/// <param name="lexer"></param>
/// <param name="innerElement">True if we're looking for the closing tag of this element to exit.
/// If its found, this method safely returns. Unbalanced tags will otherwise throw an exception.</param>
/// <param name="literal">Literal is true if the content should be read 'as is', ignoring any tags.</param>
protected void ReadContent(MLLexer lexer, bool innerElement, bool literal)
{
char Peek = lexer.Peek();
string variableString = "";
bool readingVariable = false;
MLTextElement textElement = null;
List <string> variableArguments = null;
System.Text.StringBuilder builder = new System.Text.StringBuilder();
while (Peek != StringReader.NULL)
{
if (readingVariable)
{
lexer.Read();
if (Peek == ';')
{
readingVariable = false;
// First, flush textElement if we're working on one (likely):
if (textElement != null)
{
// Make sure it adds the last word:
textElement.DoneWord(true);
textElement = null;
}
if (builder.Length != 0)
{
// The name is in the builder:
variableString = builder.ToString();
builder.Length = 0;
}
// Check if this string (e.g. &WelcomeMessage;) is provided by the variable set:
// Generate a new variable element:
MLVariableElement varElement = CreateVariableElement();
varElement.SetVariableName(variableString);
if (variableArguments != null)
{
varElement.SetArguments(variableArguments.ToArray());
variableArguments = null;
}
varElement.LoadNow(innerElement);
variableString = "";
}
else if (Peek == '(')
{
// Read runtime argument set. &WelcomeMessage('heya!');
variableString = builder.ToString();
builder.Length = 0;
Peek = lexer.Peek();
variableArguments = new List <string>();
while (Peek != StringReader.NULL)
{
if (Peek == ')')
{
// Add it:
variableArguments.Add(builder.ToString());
builder.Length = 0;
// Read it off:
lexer.Read();
break;
}
else if (Peek == ',')
{
// Done one parameter - onto the next.
variableArguments.Add(builder.ToString());
builder.Length = 0;
}
else if (Peek == '"' || Peek == '\'')
{
// One of our args is a "string".
// Use the string reader of the PropertyTextReader to read it.
PropertyTextReader.ReadString(lexer, builder);
// We don't want to read a char off, so continue here.
// Peek the next one:
Peek = lexer.Peek();
continue;
}
else if (Peek != ' ')
{
// Generall numeric args will fall down here.
// Disallowing spaces means the set can be spaced out like so: (14, 21)
builder.Append(Peek);
}
// Read off the char:
lexer.Read();
// Peek the next one:
Peek = lexer.Peek();
}
}
else
{
builder.Append(Peek);
}
}
else if (!literal && Peek == '<')
{
if (textElement != null)
{
// Make sure it adds the last word:
textElement.DoneWord(true);
textElement = null;
}
// Read off the <.
lexer.Read();
if (lexer.Peek() == '/')
{
// Should be the closure (</tag>) for 'this' element.
// Read off the /:
lexer.Read();
char closePeek = lexer.Peek();
while (closePeek != '>' && closePeek != StringReader.NULL)
{
builder.Append(closePeek);
lexer.Read();
closePeek = lexer.Peek();
}
string tag = builder.ToString();
builder.Length = 0;
if (closePeek == '>')
{
// Read it off:
lexer.Read();
}
if (innerElement && (tag == Tag || tag.ToLower() == Tag))
{
// Closure for this element read off.
// Time to get outta here!
return;
}
else
{
int charNumber;
int line = lexer.GetLineNumber(out charNumber);
throw new Exception("Unbalanced tags detected: " + tag + " is closing " + Tag + " at line " + line + ", character " + charNumber + ". " + lexer.ReadLine(line) + ".");
}
}
else
{
MLElement tag = CreateTagElement(lexer);
TagHandler handler = tag.GetHandler();
if (tag.SelfClosing)
{
tag.OnChildrenLoaded();
handler.OnTagLoaded();
}
else
{
handler.OnParseContent(lexer);
// Read its kids and possibly its ending tag (the true means we're expecting an ending tag):
tag.ReadContent(lexer, true, false);
tag.OnChildrenLoaded();
handler.OnTagLoaded();
}
}
}
else if (!literal && Peek == '&')
{
// E.g. > & etc.
readingVariable = true;
// Read off the &:
lexer.Read();
}
else
{
if (textElement == null)
{
textElement = CreateTextElement();
}
textElement.AddCharacter(lexer.Read());
}
Peek = lexer.Peek();
}
if (textElement != null)
{
textElement.DoneWord(true);
}
}
