protected virtual bool HasRelCanonicalPointingToDifferentUrl(IDomElement e, string orginalUrl)
{
return e.HasAttribute("rel") && !string.IsNullOrWhiteSpace(e.Attributes["rel"]) &&
string.Equals(e.Attributes["rel"], "canonical", StringComparison.OrdinalIgnoreCase) &&
e.HasAttribute("href") && !string.IsNullOrWhiteSpace(e.Attributes["href"]) &&
!string.Equals(e.Attributes["href"], orginalUrl, StringComparison.OrdinalIgnoreCase);
}
private static bool ElementIsItselfHidden(IDomElement el)
{
if (el.NodeNameID == HtmlData.tagINPUT && el.Type == "hidden")
{
return true;
}
if (el.HasStyles)
{
if (el.Style["display"] == "none" || el.Style.NumberPart("opacity") == 0)
{
return true;
}
double? wid = el.Style.NumberPart("width");
double? height = el.Style.NumberPart("height");
if (wid == 0 || height == 0)
{
return true;
}
}
string widthAttr, heightAttr;
widthAttr = el.GetAttribute("width");
heightAttr = el.GetAttribute("height");
return widthAttr == "0" || heightAttr == "0";
}
public override MatchResult Match <TDependencyObject>(StyleSheet styleSheet, ref IDomElement <TDependencyObject> domElement, SelectorMatcher[] fragments, ref int currentIndex)
{
var tagName = domElement.TagName;
var namespaceUri = domElement.AssemblyQualifiedNamespaceName;
return(domElement.Parent?.ChildNodes
.Where(x => x.TagName == tagName && x.AssemblyQualifiedNamespaceName == namespaceUri)
.Count() == 1 ? MatchResult.Success : MatchResult.ItemFailed);
}
/// <summary>
/// Has "rel" canonical pointing To different url
/// </summary>
/// <param name="element"></param>
/// <param name="orginalUrl"></param>
/// <returns></returns>
protected virtual bool HasRelCanonicalPointingToDifferentUrl(IDomElement element, string orginalUrl)
{
return(element.HasAttribute(Rel) &&
!string.IsNullOrWhiteSpace(element.Attributes[Rel]) &&
string.Equals(element.Attributes[Rel], Canonical, StringComparison.OrdinalIgnoreCase) &&
element.HasAttribute(Href) &&
!string.IsNullOrWhiteSpace(element.Attributes[Href]) &&
!string.Equals(element.Attributes[Href], orginalUrl, StringComparison.OrdinalIgnoreCase));
}
public HtmlOptionsCollection(IDomElement parent)
{
if (parent.NodeNameID != HtmlData.tagOPTION)
{
throw new ArgumentException("The parent node for an HtmlOptionsCollection must be an Option node.");
}
Parent = (IDomElementSelect)parent;
}
private bool IsValidOGNode(IDomElement elem)
{
if (!elem.HasAttribute("property"))
{
return(false);
}
return(elem.GetAttribute("property").StartsWith("og:"));
}
/// <summary>
/// Parses the key/value pair from a node, and adds them to the result.
/// </summary>
/// <param name="elem">Element to get info from.</param>
/// <param name="res">Result object to extract data to.</param>
private void AddDataToResult(IDomElement elem, OpenGraphData res)
{
var key = ParseKeyFromNode(elem);
if (!res.ContainsKey(key))
{
res.Add(key, ParseValueFromNode(elem));
}
}
public void Add()
{
Assert.AreEqual(jQuery("#sndp").Add("#en").Add("#sap").Get(), q("sndp", "en", "sap"), "Check elements from document");
Assert.AreEqual(jQuery("#sndp").Add(jQuery("#en")[0]).Add(jQuery("#sap")).Get(), q("sndp", "en", "sap"), "Check elements from document");
// We no longer support .Add(form.elements), unfortunately.
// There is no way, in browsers, to reliably determine the difference
// between form.elements and form - and doing .Add(form) and having it
// add the form elements is way to unexpected, so this gets the boot.
// ok( jQuery([]).Add(jQuery("#form")[0].elements).Length >= 13, "Check elements from array" );
// For the time being, we're discontinuing support for jQuery(form.elements) since it's ambiguous in IE
// use jQuery([]).Add(form.elements) instead.
//Assert.AreEqual(jQuery([]).Add(jQuery("#form")[0].elements).Length, jQuery(jQuery("#form")[0].elements).Length, "Array in constructor must equals array in add()" );
//TODO: It would be nice to have a ParentNode exist & be typed to 11 for disconnected nodes. However this creates some complexity
//b/c we still need to keep the nodes conceptually bound to another domain. I think that we may want a special "disconnected" heirarchy
//within and IDomRoot. For now just compare to null instead.
var divs = jQuery("<div/>").Add("#sndp");
//Assert.IsTrue( (int)divs[0].ParentNode.NodeType ==11, "Make sure the first element is still the disconnected node." );
Assert.IsTrue(divs[0].ParentNode == null, "Make sure the first element is still the disconnected node.");
divs = jQuery("<div>test</div>").Add("#sndp");
//Assert.AreEqual((int)divs[0].ParentNode.NodeType, 11, "Make sure the first element is still the disconnected node." );
Assert.AreEqual(divs[0].ParentNode, null, "Make sure the first element is still the disconnected node.");
divs = jQuery("#sndp").Add("<div/>");
Assert.IsTrue(divs[1].ParentNode == null, "Make sure the first element is still the disconnected node.");
var tmp = jQuery("<div/>");
var x = CQ.Create().Add(jQuery("<p id='x1'>xxx</p>").AppendTo(tmp)).Add(jQuery("<p id='x2'>xxx</p>").AppendTo(tmp));
Assert.AreEqual(x[0].Id, "x1", "Check on-the-fly element1");
Assert.AreEqual(x[1].Id, "x2", "Check on-the-fly element2");
x = CQ.Create().Add(jQuery("<p id='x1'>xxx</p>").AppendTo(tmp)[0]).Add(jQuery("<p id='x2'>xxx</p>").AppendTo(tmp)[0]);
Assert.AreEqual(x[0].Id, "x1", "Check on-the-fly element1");
Assert.AreEqual(x[1].Id, "x2", "Check on-the-fly element2");
x = CQ.Create().Add(jQuery("<p id='x1'>xxx</p>")).Add(jQuery("<p id='x2'>xxx</p>"));
Assert.AreEqual(x[0].Id, "x1", "Check on-the-fly element1");
Assert.AreEqual(x[1].Id, "x2", "Check on-the-fly element2");
x = CQ.Create().Add("<p id='x1'>xxx</p>").Add("<p id='x2'>xxx</p>");
Assert.AreEqual(x[0].Id, "x1", "Check on-the-fly element1");
Assert.AreEqual(x[1].Id, "x2", "Check on-the-fly element2");
IDomElement notDefined = null;
Assert.AreEqual(CQ.Create().Add(notDefined).Length, 0, "Check that undefined adds nothing");
Assert.AreEqual(CQ.Create().Add(document.GetElementById("form")).Length, 1, "Add a form");
Assert.AreEqual(CQ.Create().Add(document.GetElementById("select1")).Length, 1, "Add a select");
}
/// <summary>
/// Return the last child of the parent
/// </summary>
///
/// <param name="element">
/// The parent element.
/// </param>
///
/// <returns>
/// A sequence of children that match.
/// </returns>
public override IEnumerable <IDomObject> ChildMatches(IDomContainer element)
{
IDomElement child = element.LastElementChild;
if (child != null)
{
yield return(child);
}
}
/// <summary>
/// Creates an HTMLOptionsCollection from the children of a Select element.
/// </summary>
///
/// <exception cref="ArgumentException">
/// Thrown when one or more arguments have unsupported or illegal values.
/// </exception>
///
/// <param name="parent">
/// The parent element for this collection.
/// </param>
public HTMLOptionsCollection(IDomElement parent)
{
if (parent.NodeNameID != HtmlData.tagSELECT)
{
throw new ArgumentException("The parent node for an HtmlOptionsCollection must be a SELECT node.");
}
Parent = (IHTMLSelectElement)parent;
}
public HtmlOptionsCollection(IDomElement parent)
{
if (parent.NodeNameID != HtmlData.tagOPTION)
{
throw new ArgumentException("The parent node for an HtmlOptionsCollection must be an Option node.");
}
Parent = (IDomElementSelect)parent;
}
public string LookupPrefix(IDomElement <UIElement> dependencyObject, string namespaceUri)
{
if (prefixToNamespaceUri.Any(x => x.Value == namespaceUri))
{
return(prefixToNamespaceUri.FirstOrDefault(x => x.Value == namespaceUri).Key);
}
return(null);
}
public string LookupNamespaceUri(IDomElement <UIElement> dependencyObject, string prefix)
{
if (prefixToNamespaceUri.ContainsKey(prefix))
{
return(prefixToNamespaceUri[prefix]);
}
return(null);
}
/// <summary>
/// Creates an HTMLOptionsCollection from the children of a Select element.
/// </summary>
///
/// <exception cref="ArgumentException">
/// Thrown when one or more arguments have unsupported or illegal values.
/// </exception>
///
/// <param name="parent">
/// The parent element for this collection.
/// </param>
public HTMLOptionsCollection(IDomElement parent)
{
if (parent.NodeNameID != HtmlData.tagSELECT)
{
throw new ArgumentException("The parent node for an HtmlOptionsCollection must be a SELECT node.");
}
Parent = (IHTMLSelectElement)parent;
}
private void SetCurrentStyleSheet(IDomElement <UIElement, PropertyInfo> domElement, StyleSheet styleSheet)
{
domElement.StyleInfo.CurrentStyleSheet = styleSheet;
domElement.StyleInfo.DoMatchCheck = SelectorType.LogicalTree | SelectorType.VisualTree;
foreach (var child in domElement.ChildNodes)
{
SetCurrentStyleSheet(child, styleSheet);
}
}
public ElementCollectionBase(IDomElement <TDependencyObject> node, ITreeNodeProvider <TDependencyObject> treeNodeProvider)
{
this.treeNodeProvider = treeNodeProvider;
var children = GetChildren(node.Element)
.Select(x => CreateElement(x, node))
.ToList();
this.AddRange(children);
}
public virtual void RemoveValue()
{
IDomElement domElement = DomElement;
IList <IDomElement> childElements = domElement.ChildElements;
foreach (IDomElement childElement in childElements)
{
domElement.RemoveChild(childElement);
}
}
/// <summary>
/// Sets a child text for this element, using the text node type appropriate for this element's type
/// </summary>
///
/// <param name="el">
/// The element to add text to
/// </param>
/// <param name="text">
/// The text.
/// </param>
private void SetChildText(IDomElement el, string text)
{
if (el.ChildrenAllowed)
{
el.ChildNodes.Clear();
IDomText textEl = new DomText(text);
el.ChildNodes.Add(textEl);
}
}
public void MatchesSizzleSelect()
{
var opt = document.GetElementById("option1a");
opt.SetAttribute("test", "");
Assert.IsTrue(match(opt, "[id*=option1][type!=checkbox]"), "Attribute Is Not Equal Matches");
Assert.IsTrue(match(opt, "[id*=option1]"), "Attribute With No Quotes Contains Matches");
Assert.IsTrue(match(opt, "[test=]"), "Attribute With No Quotes No Content Matches");
Assert.IsTrue(!match(opt, "[test^='']"), "Attribute with empty string value does not match startsWith selector (^=)");
Assert.IsTrue(match(opt, "[id=option1a]"), "Attribute With No Quotes Equals Matches");
Assert.IsTrue(match(document.GetElementById("simon1"), "a[href*=#]"), "Attribute With No Quotes Href Contains Matches");
t("Empty values", "#select1 option[value='']", Arrays.String("option1a"));
t("Empty values", "#select1 option[value!='']", Arrays.String("option1b", "option1c", "option1d"));
t("Select options via :selected", "#select1 option:selected", Arrays.String("option1a"));
t("Select options via :selected", "#select2 option:selected", Arrays.String("option2d"));
t("Select options via :selected", "#select3 option:selected", Arrays.String("option3b", "option3c"));
t("Grouped Form Elements", "input[name='foo[bar]']", Arrays.String("hidden2"));
//Uncomment if the boolHook is removed
// [CsQuery] checked should match the selector after checked is set to true
IDomElement check2 = document.GetElementById("check2");
check2.Checked = true;
// the sizzle test said assert.AreNotEqual
Assert.IsTrue(match(check2, "[checked]"), "Dynamic boolean attributes match when they should with Sizzle.matches (#11115)");
//Make sure attribute value quoting works correctly. See: #6093
var attrbad = jQuery("<input type=\"hidden\" value=\"2\" name=\"foo.baz\" id=\"attrbad1\"/><input type=\"hidden\" value=\"2\" name=\"foo[baz]\" id=\"attrbad2\"/>")
.AppendTo("body");
t("Find escaped attribute value", "input[name=foo\\.baz]", Arrays.String("attrbad1"));
t("Find escaped attribute value", "input[name=foo\\[baz\\]]", Arrays.String("attrbad2"));
t("input[type=text]", "#form input[type=text]", Arrays.String("text1", "text2", "hidden2", "name"));
t("input[type=search]", "#form input[type=search]", Arrays.String("search"));
attrbad.Remove();
// #6428
t("Find escaped attribute value", "#form input[name=foo\\[bar\\]]", Arrays.String("hidden2"));
//#3279
var div = document.CreateElement("div");
div.InnerHTML = "<div id='foo' xml:test='something'></div>";
CollectionAssert.AreEqual(Sizzle["[xml\\:test]", div], Arrays.Create <IDomObject>(div.FirstChild), "Finding by attribute with escaped characters.");
div = null;
}
public static BindingPropertyBinderAction CreateBinderAction(string actionType, IDomElement parentElement, string selector, string attribute)
{
if (attribute == null)
{
return Activator.CreateInstance(Assembly.GetCallingAssembly().GetType("actionType"), new object[] { parentElement, selector }) as BindingPropertyBinderAction;
}
else
{
return Activator.CreateInstance(Assembly.GetCallingAssembly().GetType("actionType"), new object[] { parentElement, selector, attribute }) as BindingPropertyBinderAction;
}
}
public void SetDomElement(BindableObject obj, IDomElement <BindableObject> value, SelectorType selectorType)
{
if (selectorType == SelectorType.LogicalTree)
{
Css.SetDomElement(obj, value);
}
else
{
Css.SetDomElement(obj, value);
}
}
public static BindingPropertyBinderAction CreateBinderAction(Type actionType, IDomElement parentElement, string selector, string attribute)
{
if (attribute == null)
{
return Activator.CreateInstance(actionType, new object[] { parentElement, selector }) as BindingPropertyBinderAction;
}
else
{
return Activator.CreateInstance(actionType, new object[] { parentElement, selector, attribute }) as BindingPropertyBinderAction;
}
}
public override bool IsCorrectTreeNode(IDomElement <DependencyObject> node)
{
if (selectorType == SelectorType.LogicalTree)
{
return(logicalTreeNodeProvider.IsCorrectTreeNode(node));
}
else
{
return(visualTreeNodeProvider.IsCorrectTreeNode(node));
}
}
/// <summary>
/// Determine if an element matches a position-type filter
/// </summary>
/// <param name="elm"></param>
/// <param name="selector"></param>
/// <returns></returns>
protected IEnumerable <IDomObject> GetDomPositionMatches(IDomElement elm, Selector selector)
{
if (selector.PositionType == PositionType.NthChild)
{
return(NthChildMatcher.GetMatchingChildren(elm, selector.Criteria));
}
else
{
return(GetSimpleDomPostionMatches(elm, selector.PositionType));
}
}
public void SetDomElement(DependencyObject obj, IDomElement <DependencyObject> value, SelectorType selectorType)
{
if (selectorType == SelectorType.LogicalTree)
{
Css.SetDomElement(obj, value);
}
else
{
Css.SetVisualDomElement(obj, value);
}
}
/// <summary>
/// Enumerates only the IDomElements in the sequence provided. Any other elemnent types are excluded..
/// </summary>
///
/// <param name="objects">
/// The objects.
/// </param>
///
/// <returns>
/// An enumerator that allows foreach to be used to process only elements in this collection.
/// </returns>
protected IEnumerable <IDomElement> OnlyElements(IEnumerable <IDomObject> objects)
{
foreach (var item in objects)
{
IDomElement el = item as IDomElement;
if (el != null)
{
yield return(el);
}
}
}
private StyleSheet GetStyleSheet(IDomElement <TDependencyObject> domElement)
{
var element = GetStyleSheetHolder(domElement)?.Element;
if (element == null)
{
return(null);
}
return(dependencyPropertyService.GetStyleSheet(element));
}
public override MatchResult Match <TDependencyObject>(StyleSheet styleSheet, ref IDomElement <TDependencyObject> domElement, SelectorMatcher[] fragments, ref int currentIndex)
{
if (initializedWith != styleSheet)
{
Initialize(styleSheet);
}
var isMatch = domElement.TagName == TagName && (Alias == "*" || domElement.AssemblyQualifiedNamespaceName == NamespaceUri);
return(isMatch ? MatchResult.Success : MatchResult.ItemFailed);
}
protected internal override bool IsCorrectTreeNode(IDomElement <DependencyObject> node)
{
if (currentSelectorType == SelectorType.LogicalTree)
{
return(logicalTreeNodeProvider.IsCorrectTreeNode(node));
}
else
{
return(visualTreeNodeProvider.IsCorrectTreeNode(node));
}
}
//TODO 入口 IModelElementInstance解析
/// <summary>
/// Returns the <seealso cref="ModelElementInstanceImpl ModelElement"/> for a DOM element.
/// If the model element does not yet exist, it is created and linked to the DOM.
/// </summary>
/// <param name="domElement"> the child element to create a new <seealso cref="ModelElementInstanceImpl ModelElement"/> for </param>
/// <returns> the child model element </returns>
public static IModelElementInstance GetModelElement(IDomElement domElement, IModelInstance modelInstance)
{
IModelElementInstance modelElement = domElement.ModelElementInstance;
if (modelElement == null)
{
IModelElementType modelType = GetModelElement(domElement, modelInstance, domElement.NamespaceUri);
modelElement = ((ModelElementTypeImpl)modelType).NewInstance(modelInstance, domElement);
domElement.ModelElementInstance = modelElement;
}
return(modelElement);
}
/// <summary>
/// Insert content, specified by the parameter, to the end of each element in the set of matched
/// elements.
/// </summary>
///
/// <param name="func">
/// A delegate to a function that returns an IDomElement to insert at the end of each element in
/// the set of matched elements. Receives the index position of the element in the set and the
/// old HTML value of the element as arguments. Within the function, this refers to the current
/// element in the set.
/// </param>
///
/// <returns>
/// The current CQ object.
/// </returns>
///
/// <url>
/// http://api.jquery.com/append/
/// </url>
public CQ Append(Func <int, string, IDomElement> func)
{
int index = 0;
foreach (IDomElement obj in Elements)
{
IDomElement clientValue = func(index, obj.InnerHTML);
obj.Cq().Append(clientValue);
index++;
}
return(this);
}
private IDomElement <TDependencyObject> GetStyleSheetHolder(IDomElement <TDependencyObject> domElement)
{
var current = domElement;
while (current != null &&
dependencyPropertyService.GetStyleSheet(current.Element) == null)
{
current = current.Parent;
}
return(current);
}
private static StyleUpdateInfo GetNewStyleUpdateInfo(IDomElement <TDependencyObject, TDependencyProperty> domElement,
IDependencyPropertyService <TDependencyObject, TStyle, TDependencyProperty> dependencyPropertyService,
INativeStyleService <TStyle, TDependencyObject, TDependencyProperty> nativeStyleService)
{
var initialStyle = nativeStyleService.GetStyle(domElement.Element);
return(new StyleUpdateInfo
{
MatchedType = domElement.Element.GetType(),
InitialStyle = initialStyle
});
}
private void Visit(IDomElement element, UserDefinedClass currentClass, bool isNew, bool isRoot, bool metaExists)
{
if (element.HasElements) // if element has child elements
{
if (!isRoot) // if this is not the root element
{
var property = element.CreateProperty(_repository);
currentClass.AddProperty(property, isNew, metaExists);
}
currentClass = _repository.GetOrAdd(element.GetDomPath(_factory), out isNew);
isRoot = element.ActsAsRootElement;
foreach (var childElement in element.Elements)
{
Visit(childElement, currentClass, isNew, isRoot, metaExists);
}
foreach (var orphanedProperty in
currentClass.Properties.Where(
property => metaExists && !element.ActsAsRootElement && element.Elements.All(childElement => !property.DomPath.Equals(childElement.GetDomPath(_factory)))))
{
// If there's a property that exists, but isn't present in our element's children, it should be nullable.
orphanedProperty.MakeNullable();
}
}
else // if element has no child elements
{
if (isRoot) // if this is the root element
{
// Make sure a class exists for the root element, no matter what.
_repository.GetOrAdd(element.GetDomPath(_factory));
}
else
{
var property = element.CreateProperty(_repository);
currentClass.AddProperty(property, isNew, metaExists);
}
if (metaExists)
{
// If we're refining, and this element has no children, there is a
// possibility that it had previous contained children. Make those
// children nullable.
currentClass = _repository.GetOrAdd(element.GetDomPath(_factory));
foreach (var property in currentClass.Properties)
{
property.MakeNullable();
}
}
}
}
private void Visit(IDomElement element, UserDefinedClass currentClass, bool isNew, bool isRoot, bool metaExists)
{
if (element.HasElements) // if element has child elements
{
if (!isRoot) // if this is not the root element
{
var property = element.CreateProperty(_repository);
currentClass.AddProperty(property, isNew, metaExists);
}
currentClass = _repository.GetOrAdd(element.GetDomPath(_factory), out isNew);
isRoot = element.ActsAsRootElement;
foreach (var childElement in element.Elements)
{
Visit(childElement, currentClass, isNew, isRoot, metaExists);
}
foreach (var orphanedProperty in
currentClass.Properties.Where(
property => metaExists && !element.ActsAsRootElement && element.Elements.All(childElement => !property.DomPath.Equals(childElement.GetDomPath(_factory)))))
{
// If there's a property that exists, but isn't present in our element's children, it should be nullable.
orphanedProperty.MakeNullable();
}
}
else // if element has no child elements
{
if (isRoot) // if this is the root element
{
// Make sure a class exists for the root element, no matter what.
_repository.GetOrAdd(element.GetDomPath(_factory));
}
else
{
var property = element.CreateProperty(_repository);
currentClass.AddProperty(property, isNew, metaExists);
}
if (metaExists)
{
// If we're refining, and this element has no children, there is a
// possibility that it had previous contained children. Make those
// children nullable.
currentClass = _repository.GetOrAdd(element.GetDomPath(_factory));
foreach (var property in currentClass.Properties)
{
property.MakeNullable();
}
}
}
}
private StyleSheet GetStyleSheetFromTree(IDomElement <TDependencyObject, TDependencyProperty> domElement)
{
var current = domElement;
StyleSheet styleSheet = null;
while (current != null &&
(styleSheet = dependencyPropertyService.GetStyleSheet(current.Element)) == null)
{
current = current.Parent;
}
return(styleSheet);
}
public override MatchResult Match <TDependencyObject>(StyleSheet styleSheet, ref IDomElement <TDependencyObject> domElement, SelectorMatcher[] fragments, ref int currentIndex)
{
if (string.IsNullOrWhiteSpace(Text))
{
return(MatchResult.ItemFailed);
}
var thisPosition = domElement.Parent?.ChildNodes.IndexOf(domElement) ?? -1;
thisPosition++;
return(CalcIsNth(factor, distance, ref thisPosition) ? MatchResult.Success : MatchResult.ItemFailed);
}
public TwitterWall(string screenName, int maxItems)
{
_screenName = screenName;
_maxItems = maxItems;
_tweets = new List<ISearchResultTweet>();
_index = new Dictionary<int, ISearchResultTweet>();
_container = DomManager.Document.GetElementById("twitter-wall-container");
_toMeSearchParameters = "&callback=" + ToMeCallback + "&count=" + maxItems;
_toMeSearchUrl = SearchUrl + "?q=to:" + _screenName + _toMeSearchParameters;
_fromMeSearchParameters = "&callback=" + FromMeCallback + "&count=" + maxItems;
_fromMeSearchUrl = SearchUrl + "?q=from:" + _screenName + _fromMeSearchParameters;
}
/// <summary>
/// Returns the form data of the provided form.
/// </summary>
/// <param name="form">The form.</param>
/// <param name="submitter">The validated submitter element.</param>
/// <param name="implicitSubmission">
/// Whether or not to use implicit submission. Implicit submission takes precedence over
/// the provided submitter.
/// </param>
/// <returns>A lazy list of form field data.</returns>
public static IEnumerable<NameValueType> GetNameValueTypes(IHTMLFormElement form, IDomElement submitter, bool implicitSubmission)
{
// ensure the submitter node is valid
if (submitter != null && !IsValidSubmitter(form, submitter))
{
throw new ArgumentException("The provided submitter node is not a button or does not belong to the provided form.");
}
// find the first valid submitter if we are doing implicit submission
if (implicitSubmission)
{
submitter = form
.Document
.GetDescendentElements()
.FirstOrDefault(e => IsValidSubmitter(form, e));
}
return GetNameValueTypes(form, submitter).ToArray();
}
/// <summary>
/// Returns the form data of the provided form.
/// </summary>
/// <param name="form">The form.</param>
/// <param name="submitter">The validated submitter element.</param>
/// <returns>A lazy list of form field data.</returns>
private static IEnumerable<NameValueType> GetNameValueTypes(IHTMLFormElement form, IDomElement submitter)
{
// walk the form fields
foreach (IDomElement e in form.Document.GetDescendentElements().Where(e => !IsExcludedFromDataSet(form, e, submitter)))
{
// TODO: handle dirname
// TODO: handle file uploads
// TODO: handle plugin objects
// TODO: handle keygen
if (e is IHTMLInputElement && e.Type == "image")
{
string name = e.GetAttribute("name", string.Empty);
if (name != string.Empty)
{
name += ".";
}
yield return new NameValueType(name + "x", "0", e.Type);
yield return new NameValueType(name + "y", "0", e.Type);
}
else if (e is IHTMLSelectElement)
{
foreach (NameValueType pair in GetOptionKeyValueTuples(e as IHTMLSelectElement))
{
yield return pair;
}
}
else if (e is IHTMLInputElement && (e.Type == "checkbox" || e.Type == "radio"))
{
yield return new NameValueType(e.Name, e.GetAttribute("value", "on"), e.Type);
}
else if (e is IHTMLTextAreaElement)
{
// TODO: handle textarea properly
yield return new NameValueType(e.Name, WebUtility.HtmlDecode(e.Value), e.Type);
}
else
{
yield return new NameValueType(e.Name, e.GetAttribute("value", string.Empty), e.Type);
}
}
}
private void BuildUI()
{
_processViewerArea = DomManager.Document.GetElementById("process-viewer-area");
_mainTable = DomManager.CreateElement("table");
_mainTable.SetAttribute("cellspacing", "2");
_mainTable.SetAttribute("cellpadding", "2");
IDomElement tr = DomManager.CreateElement("tr");
tr.SetAttribute("valign", "top");
IDomElement td = DomManager.CreateElement("td");
IDomElement sipTableHeader = DomManager.CreateElement("span");
sipTableHeader.InnerHtml = "Processes:<br />----------------------------------------<br />";
td.AppendChild(sipTableHeader);
IDomElement sipTable = BuildSIPTable();
_sipTableBody = DomManager.CreateElement("tbody");
sipTable.AppendChild(_sipTableBody);
td.AppendChild(sipTable);
tr.AppendChild(td);
td = DomManager.CreateElement("td");
IDomElement threadTableHeader = DomManager.CreateElement("span");
threadTableHeader.InnerHtml = "Threads:<br />---------------------------------------------------------------<br />";
td.AppendChild(threadTableHeader);
IDomElement threadTable = BuildThreadTable();
_threadTableBody = DomManager.CreateElement("tbody");
threadTable.AppendChild(_threadTableBody);
td.AppendChild(threadTable);
tr.AppendChild(td);
_mainTable.AppendChild(tr);
_processViewerArea.AppendChild(DomManager.CreateElement("br"));
_lastUpdatedElement = DomManager.CreateElement("span");
_processViewerArea.AppendChild(_lastUpdatedElement);
_processViewerArea.AppendChild(DomManager.CreateElement("br"));
_processViewerArea.AppendChild(_mainTable);
}
public IEnumerable<IDomObject> GetMatchingChildren(IDomElement obj)
{
if (!obj.HasChildren)
{
yield break;
}
else if (IsJustNumber)
{
int index = 1;
IDomElement child = obj.FirstChild.NodeType == NodeType.ELEMENT_NODE ?
(IDomElement)obj.FirstChild :
obj.FirstChild.NextElementSibling;
while (index++ < MatchOnlyIndex && child != null)
{
child = child.NextElementSibling;
}
if (child != null)
{
yield return child;
}
else
{
yield break;
}
}
else
{
int index = 1;
UpdateCacheInfo(obj.ChildNodes.Count);
foreach (var child in obj.ChildElements)
{
if (cacheInfo.MatchingIndices.Contains(index))
{
yield return child;
}
index++;
}
}
}
/// <summary>
/// Test whether a single element matches a specific attribute selector.
/// </summary>
///
/// <param name="element">
/// The element to test.
/// </param>
/// <param name="selector">
/// The selector.
/// </param>
///
/// <returns>
/// true if the element matches, false if not.
/// </returns>
public static bool Matches(IDomElement element, SelectorClause selector)
{
string value;
bool match = ((DomElement)element).TryGetAttributeForMatching(selector.AttributeNameTokenID,out value);
if (!match)
{
switch (selector.AttributeSelectorType)
{
case AttributeSelectorType.Exists:
return false;
case AttributeSelectorType.NotEquals:
case AttributeSelectorType.NotExists:
return true;
default:
return false;
}
}
else
{
// bool isCaseSensitive = HtmlData.
switch (selector.AttributeSelectorType)
{
case AttributeSelectorType.Exists:
return true;
case AttributeSelectorType.Equals:
return selector.AttributeValue.Equals(value,selector.AttributeValueStringComparison);
case AttributeSelectorType.StartsWith:
return value != null &&
value.Length >= selector.AttributeValue.Length &&
value.Substring(0, selector.AttributeValue.Length)
.Equals(selector.AttributeValue, selector.AttributeValueStringComparison);
case AttributeSelectorType.Contains:
return value != null && value.IndexOf(selector.AttributeValue,
selector.AttributeValueStringComparison)>=0;
case AttributeSelectorType.ContainsWord:
return value != null && ContainsWord(value, selector.AttributeValue,
selector.AttributeValueStringComparer);
case AttributeSelectorType.NotEquals:
return !selector.AttributeValue
.Equals(value, selector.AttributeValueStringComparison);
case AttributeSelectorType.NotExists:
return false;
case AttributeSelectorType.EndsWith:
int len = selector.AttributeValue.Length;
return value != null && value.Length >= len &&
value.Substring(value.Length - len)
.Equals(selector.AttributeValue,
selector.AttributeValueStringComparison);
case AttributeSelectorType.StartsWithOrHyphen:
if (value == null)
{
return false;
}
int dashPos = value.IndexOf("-");
string beforeDash = value;
if (dashPos >= 0)
{
// match a dash that's included in the match attribute according to common browser behavior
beforeDash = value.Substring(0, dashPos);
}
return selector.AttributeValue.Equals(beforeDash,selector.AttributeValueStringComparison) ||
selector.AttributeValue.Equals(value,selector.AttributeValueStringComparison);
default:
throw new InvalidOperationException("No AttributeSelectorType set");
}
}
}
private bool HasRelNoFollow(IDomElement e)
{
return _isRespectAnchorRelNoFollowEnabled && (e.HasAttribute("rel") && e.GetAttribute("rel").ToLower().Trim() == "nofollow");
}
/// <summary>
/// Constructor.
/// </summary>
///
/// <param name="ownerNode">
/// The node that owns this item.
/// </param>
public CSSStyleSheet(IDomElement ownerNode)
{
OwnerNode = ownerNode;
}
/// <summary>
/// Determines whether an element is excluded from a form data set.
/// </summary>
/// <param name="form"></param>
/// <param name="e"></param>
/// <param name="submitter"></param>
/// <returns></returns>
private static bool IsExcludedFromDataSet(IHTMLFormElement form, IDomElement e, IDomElement submitter)
{
var submittable = e as IFormSubmittableElement;
if (submittable == null || submittable.Form != form)
{
return true;
}
return (e.GetAncestors().Any(a => a.NodeName == "DATALIST")) ||
(e.Disabled) ||
(IsButton(e) && e != submitter) ||
(e is IHTMLInputElement && e.Type == "checkbox" && !e.Checked) ||
(e is IHTMLInputElement && e.Type == "radio" && !e.Checked) ||
(e.Name.IsNullOrEmpty() && !(e is IHTMLInputElement && e.Type == "image")) ||
(e.NodeName == "OBJECT");
}
/// <summary>
/// Return true if an element matches a specific filter.
/// </summary>
///
/// <param name="element">
/// The element to test
/// </param>
/// <param name="selector">
/// A selector clause
/// </param>
///
/// <returns>
/// true if matches pseudo class, false if not.matches the selector, false if not
/// </returns>
protected bool MatchesPseudoClass(IDomElement element, SelectorClause selector)
{
return ((IPseudoSelectorChild)selector.PseudoSelector).Matches(element);
}
/// <summary>
/// Ouptuts the deepest-nested object, it's root element from the list of elements passed, and
/// returns the depth, given a structure. Helper method for Wrap.
/// </summary>
///
/// <param name="elements">
/// The sequence to analyze
/// </param>
/// <param name="element">
/// [ouy] The innermost element container
/// </param>
/// <param name="rootElement">
/// [out] The root element.
/// </param>
///
/// <returns>
/// The innermost container.
/// </returns>
protected int GetInnermostContainer(IEnumerable<IDomElement> elements,
out IDomElement element,
out IDomElement rootElement)
{
int depth = 0;
element = null;
rootElement = null;
foreach (IDomElement el in elements)
{
if (el.HasChildren)
{
IDomElement innerEl;
IDomElement root;
int innerDepth = GetInnermostContainer(el.ChildElements,
out innerEl,
out root);
if (innerDepth > depth)
{
depth = innerDepth + 1;
element = innerEl;
rootElement = el;
}
}
if (depth == 0)
{
depth = 1;
element = el;
rootElement = el;
}
}
return depth;
}
/// <summary>
/// Implementation for Children. The bool part of the tuple indicates if the element inherits a
/// "disabled" property.
/// </summary>
///
/// <param name="parent">
/// The parent element for this collection.
/// </param>
///
/// <returns>
/// An enumerator that allows foreach to be used to process children in this collection.
/// </returns>
private IEnumerable<OptionElement> Children(IDomElement parent)
{
return Children(parent, false);
}
public ValuePropertyBinderAction(IDomElement parentElement, string selector) : base(parentElement, selector)
{
}
protected virtual bool HasRelNoFollow(IDomElement e)
{
return _config.IsRespectAnchorRelNoFollowEnabled && (e.HasAttribute("rel") && e.GetAttribute("rel").ToLower().Trim() == "nofollow");
}
/// <summary>
/// Return true if an object matches a specific selector. If the selector has a desecendant or child traversal type, it must also
/// match the specificed depth.
/// </summary>
/// <param name="selector">The jQuery/CSS selector</param>
/// <param name="obj">The target object</param>
/// <param name="depth">The depth at which the target must appear for descendant or child selectors</param>
/// <returns></returns>
protected bool Matches(SelectorClause selector, IDomElement obj, int depth)
{
switch (selector.TraversalType)
{
case TraversalType.Child:
if (selector.ChildDepth != depth)
{
return false;
}
break;
case TraversalType.Descendent:
// Special case because this code is jacked up: when only "AttributeValue" it's ALWAYS a filter, it means
// the AttributeExists was handled previously by the index.
// This engine at some point should be reworked so that the "And" combinator is just a subselector, this logic has
// become too brittle.
if (depth == 0)
{
return false;
}
break;
}
if (selector.SelectorType.HasFlag(SelectorType.All))
{
return true;
}
if (selector.SelectorType.HasFlag(SelectorType.PseudoClass))
{
return MatchesPseudoClass(obj, selector);
}
if (obj.NodeType != NodeType.ELEMENT_NODE)
{
return false;
}
// Check each selector from easier/more specific to harder. e.g. ID is going to eliminate a lot of things.
if (selector.SelectorType.HasFlag(SelectorType.ID) &&
selector.ID != obj.Id)
{
return false;
}
if (selector.SelectorType.HasFlag(SelectorType.Class) &&
!obj.HasClass(selector.Class))
{
return false;
}
if (selector.SelectorType.HasFlag(SelectorType.Tag) &&
!String.Equals(obj.NodeName, selector.Tag, StringComparison.CurrentCultureIgnoreCase))
{
return false;
}
if ((selector.SelectorType & SelectorType.AttributeValue)>0)
{
return AttributeSelectors.Matches((IDomElement)obj,selector);
}
if (selector.SelectorType == SelectorType.None)
{
return false;
}
return true;
}
public void Visit(IDomElement element, bool metaExists)
{
bool isNew;
_repository.GetOrAdd(element.GetDomPath(_factory), out isNew);
Visit(element, null, isNew, true, metaExists);
}
/// <summary>
/// Return all child elements matching a DOM-position type selector
/// </summary>
/// <param name="elm"></param>
/// <param name="selector"></param>
/// <returns></returns>
protected IEnumerable<IDomObject> GetPseudoClassMatches(IDomElement elm, SelectorClause selector)
{
IEnumerable<IDomObject> results;
results = ((IPseudoSelectorChild)selector.PseudoSelector).ChildMatches(elm);
foreach (var item in results)
{
yield return item;
}
// Traverse children if needed
if (selector.TraversalType == TraversalType.Descendent ||
selector.TraversalType == TraversalType.All)
{
foreach (var child in elm.ChildElements)
{
foreach (var item in GetPseudoClassMatches(child, selector))
{
yield return item;
}
}
}
}
private static bool TryLoadDocument(string arg, IFactory factory, out IDomElement domElement, out DocumentType documentType)
{
try
{
var xDocument = XDocument.Load(arg);
domElement = factory.CreateXmlDomElement(xDocument.Root);
documentType = DocumentType.Xml;
return true;
}
catch
{
try
{
JToken jToken;
using (var streamReader = new StreamReader(arg))
{
using (var jsonReader = new JsonTextReader(streamReader))
{
jToken = JToken.Load(jsonReader);
}
}
domElement = factory.CreateJsonDomElement(jToken);
documentType = DocumentType.Json;
return true;
}
catch
{
domElement = null;
documentType = DocumentType.Invalid;
return false;
}
}
}
/// <summary>
/// Determines whether the provided element is a valid submitter of the provided form.
/// </summary>
/// <param name="form">The form to test.</param>
/// <param name="e">The element to test.</param>
/// <returns>True if the provided element is a valid submitter of the provided for. False otherwise.</returns>
private static bool IsValidSubmitter(IHTMLFormElement form, IDomElement e)
{
var formElement = e as IFormSubmittableElement;
if (formElement != null)
{
return IsButton(e) && formElement.Form == form;
}
return false;
}
private IEnumerable<OptionElement> Children(IDomElement parent, bool disabled)
{
foreach (var item in parent.ChildElements)
{
switch (item.NodeNameID)
{
case HtmlData.tagOPTION:
yield return new OptionElement
{
Element = (DomElement)item,
Disabled = disabled || item.HasAttribute("disabled")
};
break;
case HtmlData.tagOPTGROUP:
foreach (var child in Children(item, disabled || item.HasAttribute("disabled")))
{
yield return child;
}
break;
}
}
}
private static bool TryParseDocument(string arg, IFactory factory, out IDomElement domElement, out DocumentType documentType)
{
try
{
var xDocument = XDocument.Parse(arg);
domElement = factory.CreateXmlDomElement(xDocument.Root);
documentType = DocumentType.Xml;
return true;
}
catch
{
try
{
var jToken = JToken.Parse(arg);
domElement = factory.CreateJsonDomElement(jToken);
documentType = DocumentType.Json;
return true;
}
catch
{
domElement = null;
documentType = DocumentType.Invalid;
return false;
}
}
}
protected string WriteDOMObject(IDomElement obj)
{
string result = "";
foreach (var kvp in obj.Attributes)
{
if (kvp.Value != null)
{
result += kvp.Key + "=" + kvp.Value + ",";
}
else
{
result += kvp.Value + ",";
}
}
result += "InnerHtml=" + obj.InnerHTML;
return result;
}
/// <summary>
/// Deals with tbody as the target of appends
/// </summary>
/// <param name="apparentTarget"></param>
/// <returns></returns>
protected IDomElement getTrueTarget(IDomElement target)
{
//Special handling for tables: make sure we add to the TBODY
IDomElement element = target;
if (target.NodeName == "table")
{
bool addBody = false;
if (target.HasChildren)
{
IDomElement body = target.ChildElements.FirstOrDefault(item => item.NodeName == "tbody");
if (body != null) {
element = body;
}
else if (target.FirstElementChild == null)
{
// Add a body if there are no elements in this table yet
addBody = true;
}
// default = leave it alone, they've already added elements. don't worry whether it's valid or not,
// assume they know what they're doing.
}
else
{
addBody = true;
}
if (addBody)
{
element = Document.CreateElement("tbody");
target.AppendChild(element);
}
}
return element;
}
