/// <summary>
/// Returns a literal object for the text between HtmlStart (the last position of the end of a
/// tag) and the current position. If !AllowLiterals then it's wrapped in a span.
/// </summary>
///
/// <param name="factory">
/// The HTML factory to operate against
/// </param>
/// <param name="literal">
/// [out] The literal.
/// </param>
///
/// <returns>
/// true if it succeeds, false if it fails.
/// </returns>
public bool TryGetLiteral(HtmlElementFactory factory, out IDomObject literal)
{
if (Pos <= HtmlStart)
{
literal = null;
return(false);
}
// There's plain text -return it as a literal.
DomText lit;
switch (InsertionMode)
{
case InsertionMode.Invalid:
lit = new DomInvalidElement();
break;
case InsertionMode.Text:
InsertionMode = InsertionMode.Default;
lit = new DomInnerText();
break;
default:
lit = new DomText();
break;
}
literal = lit;
//if (factory.IsBound)
//{
// lit.SetTextIndex(factory.Document, factory.Document.DocumentIndex.TokenizeString(HtmlStart, Pos - HtmlStart));
//}
//else
//{
string text = factory.Html.SubstringBetween(HtmlStart, Pos);
literal.NodeValue = HtmlData.HtmlDecode(text);
//}
if (WrapLiterals)
{
DomElement wrapper = DomElement.Create("span");
wrapper.AppendChildUnsafe(literal);
literal = wrapper;
}
if (Parent != null)
{
((DomElement)Parent.Element).AppendChildUnsafe(literal);
Reset();
return(false);
}
else
{
TokenizerState = TokenizerState.Finished;
return(true);
}
}
public void Create_Elements()
{
var el = DomElement.Create("div");
el.ClassName = "content";
var div = CQ.Create(Objects.Enumerate(el));
Assert.AreEqual(divDom, div.Render());
}
/// <summary>
/// Create a new element.
/// </summary>
///
/// <param name="ns">
/// The namespace.
/// </param>
/// <param name="name">
/// The node name.
/// </param>
/// <param name="attributes">
/// The attributes.
/// </param>
///
/// <returns>
/// The new element.
/// </returns>
override protected DomObject CreateElement(string ns, string name, HtmlAttributes attributes)
{
// ns is not used
DomElement rv = DomElement.Create(name);
for (int i = 0; i < attributes.Length; i++)
{
string attributeName = AttributeName(attributes.GetLocalName(i), attributes.GetURI(i));
rv.SetAttribute(attributeName, attributes.GetValue(i));
//if (attributes.GetType(i) == "ID")
//{
//rv.setIdAttributeNS(null, attributes.GetLocalName(i), true); // FIXME
//}
}
return(rv);
}
/// <summary>
/// Creates the root HTML element.
/// </summary>
///
/// <param name="attributes">
/// The attributes.
/// </param>
///
/// <returns>
/// The new HTML element.
/// </returns>
override protected DomObject CreateHtmlElementSetAsRoot(HtmlAttributes attributes)
{
if (!isFragment)
{
DomElement rv = DomElement.Create("html");
for (int i = 0; i < attributes.Length; i++)
{
string attributeName = AttributeName(attributes.GetLocalName(i), attributes.GetURI(i));
rv.SetAttribute(attributeName, attributes.GetValue(i));
}
Document.AppendChildUnsafe(rv);
return(rv);
}
else
{
return(Document);
}
}
/// <summary>
/// Add a new parent of type tagId. In other words, wrap the current element in a new element.
/// </summary>
///
/// <param name="tagId">
/// The token for the tag to add
/// </param>
/// <param name="pos">
/// The index position for the iteration data
/// </param>
///
/// <returns>
/// The iteration data representing the current element (replaces the
/// </returns>
public IterationData AddNewParent(ushort tagId, int pos)
{
Element = DomElement.Create(tagId);
((DomElement)Parent.Element).ChildNodesInternal.AddAlways(Element);
return(AddNewChild(pos));
}
/// <summary>
/// Parse the HTML, and return it, based on options set.
/// </summary>
///
/// <returns>
/// An enumerator of the top-level elements.
/// </returns>
protected IEnumerable <IDomObject> ParseImplementation()
{
int pos = 0;
Stack <IterationData> stack = new Stack <IterationData>();
while (pos <= EndPos)
{
IterationData current = new IterationData();
if (WrapRootTextNodes)
{
current.WrapLiterals = true;
}
current.Reset(pos);
stack.Push(current);
while (stack.Count != 0)
{
current = stack.Pop();
while (current.TokenizerState != TokenizerState.Finished && current.Pos <= EndPos)
{
char c = Html[current.Pos];
switch (current.TokenizerState)
{
case TokenizerState.Default:
if (current.FindNextTag(Html))
{
// even if we fell through from ReadTextOnly (e.g. was never closed), we should proceeed to finish
current.TokenizerState = TokenizerState.TagStart;
}
break;
case TokenizerState.TagStart:
IDomObject literal;
if (current.TryGetLiteral(this, out literal))
{
yield return(literal);
}
int tagStartPos = current.Pos;
string newTag = current.GetTagOpener(Html);
if (newTag == String.Empty)
{
// It's a tag closer. Make sure it's the right one.
current.Pos = tagStartPos + 1;
ushort closeTagId = HtmlData.Tokenize(current.GetCloseTag(Html));
// Ignore empty tags, or closing tags found when no parent is open
bool isProperClose = closeTagId == current.ParentTagID();
if (closeTagId == 0)
{
// ignore empty tags
continue;
}
else
{
// locate match for this closer up the heirarchy
IterationData actualParent = null;
if (!isProperClose)
{
actualParent = current.Parent;
while (actualParent != null && actualParent.Element.NodeNameID != closeTagId)
{
actualParent = actualParent.Parent;
}
}
// if no matching close tag was found up the tree, ignore it
// otherwise always close this and repeat at the same position until the match is found
if (!isProperClose && actualParent == null)
{
current.InsertionMode = InsertionMode.Invalid;
continue;
}
}
// element is closed
if (current.Parent.Parent == null)
{
yield return(current.Parent.Element);
}
current.TokenizerState = TokenizerState.Finished;
if (isProperClose)
{
current.Parent.Reset(current.Pos);
}
else
{
current.Parent.Reset(tagStartPos);
}
// already been returned before we added the children
continue;
}
else if (newTag[0] == '!')
{
IDomSpecialElement specialElement = null;
string newTagUpper = newTag.ToUpper();
if (newTagUpper.StartsWith("!DOCTYPE"))
{
specialElement = new DomDocumentType();
current.Element = specialElement;
}
else if (newTagUpper.StartsWith("