/// <summary>
/// 创建关系处理程序
/// </summary>
/// <param name="relative">关系</param>
/// <param name="leftSelector">左选择器</param>
/// <returns>关系处理程序</returns>
private RelativeHandler CreateRelativeHandler(string relative, ICssSelector leftSelector)
{
if (relative == null)
{
return(element => leftSelector.IsEligible(element));
}
else if (Relative == ">")
{
return(element => leftSelector.IsEligible(element.Parent()));
}
else if (Relative == "")
{
return(element => element.Ancestors().Any(e => leftSelector.IsEligible(e)));
}
else if (Relative == "+")
{
return(element => leftSelector.IsEligible(element.PreviousElement()));
}
else if (Relative == "~")
{
return(element => element.SiblingsBeforeSelf().Any(e => leftSelector.IsEligible(e)));
}
throw new NotSupportedException("不支持的关系运算符");
}
public CssRuleSet(ICssSelector selector, IList <CssDeclaration> normalDeclarations, IList <CssDeclaration> importantDeclarations
)
{
this.selector = selector;
this.normalDeclarations = normalDeclarations;
this.importantDeclarations = importantDeclarations;
}
/// <summary>
/// 创建选择器
/// </summary>
/// <param name="expression">选择器表达式</param>
/// <returns>选择器实例</returns>
public static ICssSelector Create(string expression)
{
if (selectorCache.ContainsKey(expression))
{
return(selectorCache[expression]);
}
var match = casecadingSelectorRegex.Match(expression);
if (!match.Success)
{
throw new FormatException();
}
ICssSelector selector = CssElementSelector.Create(match.Groups["leftSelector"].Value);
foreach (var extraCapture in match.Groups["extra"].Captures.Cast <Capture>())
{
var relative = extraCapture.FindCaptures(match.Groups["relative"]).Single().Value.Trim();
var rightSelector = extraCapture.FindCaptures(match.Groups["rightSelector"]).Single().Value.Trim();
selector = new CssCasecadingSelector(selector, relative, CssElementSelector.Create(rightSelector));
}
lock ( _cacheSync )
{
selectorCache[expression] = selector;
}
return(selector);
}
public static ICssElementMatcher BuildMatcher(this ICssSelector selector, IXmlNamespaceResolver namespaceResolver = null)
{
var builder = new CssElementMatcherBuilderVisitor(namespaceResolver);
selector.Apply(builder);
return(builder.Matcher);
}
public Enumerator(ICssSelector selector, IEnumerator <T> enumerator)
{
coreSelector = selector;
coreEnumerator = enumerator;
Trace.Write("Selector", string.Format(CultureInfo.InvariantCulture, "Begin Enumerate Search \"{0}\"", coreSelector.ToString()));
}
/// <summary>
/// Creates a new
/// <see cref="CssRuleSet"/>
/// from selector and raw list of declarations.
/// </summary>
/// <remarks>
/// Creates a new
/// <see cref="CssRuleSet"/>
/// from selector and raw list of declarations.
/// The declarations are split into normal and important under the hood.
/// To construct the
/// <see cref="CssRuleSet"/>
/// instance from normal and important declarations, see
/// <see cref="CssRuleSet(iText.StyledXmlParser.Css.Selector.ICssSelector, System.Collections.Generic.IList{E}, System.Collections.Generic.IList{E})
/// "/>
/// </remarks>
/// <param name="selector">the CSS selector</param>
/// <param name="declarations">the CSS declarations</param>
public CssRuleSet(ICssSelector selector, IList <CssDeclaration> declarations)
{
this.selector = selector;
this.normalDeclarations = new List <CssDeclaration>();
this.importantDeclarations = new List <CssDeclaration>();
SplitDeclarationsIntoNormalAndImportant(declarations, normalDeclarations, importantDeclarations);
}
/// <summary>
/// 创建 jQuery 对象
/// </summary>
/// <param name="selector">选择器</param>
/// <param name="scope">范畴限定</param>
public jQuery(string selector, IHtmlContainer scope)
{
_selectorExpression = selector;
_scope = scope;
_selector = CssParser.Create(scope, selector);
_elements = _selector.Filter(_scope.Descendants());
}
/// <summary>
/// 创建现有 CSS 选择器的自动缓存包装
/// </summary>
/// <param name="selector">已有的 CSS 选择器</param>
/// <returns>对已有选择器的自动缓存的包装</returns>
public static ICssSelector CreateCacheableWrapper( ICssSelector selector )
{
var cacheable = selector as CssCacheableSelector;
if ( cacheable == null )
cacheable = new CacheableCssSelectorWrapper( selector );
return cacheable;
}
/// <summary>
/// 使用选择器从元素集中筛选出符合选择器要求的元素
/// </summary>
/// <param name="source">源元素集</param>
/// <param name="selector">选择器</param>
/// <returns>筛选结果</returns>
public static IEnumerable<IHtmlElement> FilterBy( this IEnumerable<IHtmlElement> source, ICssSelector selector )
{
if ( source == null )
return null;
if ( selector == null )
return source;
return source.Where( selector.IsEligible );
}
/// <summary>
/// 创建 CSS 层叠选择器对象
/// </summary>
/// <param name="relativeSelector">关系选择器</param>
/// <param name="lastSelector">附加的最后一个选择器</param>
public CssCasecadingSelector( CssRelativeSelector relativeSelector, ICssSelector lastSelector )
{
if ( relativeSelector == null )
throw new ArgumentNullException( "relativeSelector" );
if ( lastSelector == null )
throw new ArgumentNullException( "lastSelector" );
RelativeSelector = relativeSelector;
LastSelector = lastSelector;
}
public static ICssSelector CreateCacheableWrapper(ICssSelector selector)
{
var cacheable = selector as CssCacheableSelector;
if (cacheable == null)
{
cacheable = new CacheableCssSelectorWrapper(selector);
}
return(cacheable);
}
protected override bool IsEligible(ICssSelector leftSelector, IHtmlElement element)
{
var restrict = leftSelector as ContainerRestrict;
if (restrict != null)
{
return(restrict.RestrictContainer.Nodes().Contains(element));
}
return(leftSelector.IsEligibleBuffered(element.Parent()));
}
/// <summary>
/// 派生类重写此方法确定指定元素是否需要重写渲染规则
/// </summary>
/// <param name="element">要检测的元素</param>
/// <returns>是否需要使用自定义渲染规则</returns>
protected virtual bool IsEligible( IHtmlElement element )
{
if ( CssSelector == null )
return false;
if ( _selectorExpression == CssSelector )
return _selectorCache.IsEligible( element );
_selectorExpression = CssSelector;
_selectorCache = CssParser.ParseSelector( CssSelector );
return _selectorCache.IsEligible( element );
}
public IEnumerable <INativeElement> GetElementsWithQuerySelector(ICssSelector selector, DomContainer domContainer)
{
domContainer.RunScript(new ScriptLoader().GetSizzleInstallScript());
var command = string.Format("window.Sizzle('{0}', {1})", selector.Selector(true), containerReference);
var ffElements = GetElementArrayEnumerator(command);
foreach (var ffElement in ffElements)
{
yield return(ffElement);
}
}
/// <summary>
/// 使用选择器从元素集中筛选出符合选择器要求的元素
/// </summary>
/// <param name="selector">选择器</param>
/// <param name="source">源元素集</param>
/// <returns>筛选结果</returns>
public static IEnumerable <IHtmlElement> Filter(this ICssSelector selector, IEnumerable <IHtmlElement> source)
{
if (selector == null)
{
throw new ArgumentNullException("selector");
}
if (source == null)
{
return(null);
}
return(source.Where(selector.IsEligible));
}
/// <summary>
/// 创建范畴限定选择器
/// </summary>
/// <param name="selector">选择器</param>
/// <param name="scope">范畴限定，上溯时不超出此范畴</param>
/// <returns>>带范畴限定的层叠选择器</returns>
public static ICssSelector Create(ICssSelector selector, IHtmlContainer scope)
{
if (selector == null)
{
throw new ArgumentNullException("selector");
}
if (scope == null)
{
return(selector);
}
return(new CssCasecadingSelector(new CssScopeRestrictionSelector(scope), null, selector));
}
protected override bool IsEligible(ICssSelector leftSelector, IHtmlElement element)
{
var restrict = leftSelector as ContainerRestrict;
if (restrict != null)
{
return(element.IsDescendantOf(restrict.RestrictContainer));
}
var parant = element.Parent();
//如果父级元素符合左选择器，或者父级元素符合本选择器。
return(leftSelector.IsEligibleBuffered(parant) || this.IsEligibleBuffered(parant));
}
/// <summary>
/// 创建 CSS 层叠选择器对象
/// </summary>
/// <param name="relativeSelector">关系选择器</param>
/// <param name="lastSelector">附加的最后一个选择器</param>
public CssCasecadingSelector(CssRelativeSelector relativeSelector, ICssSelector lastSelector)
{
if (relativeSelector == null)
{
throw new ArgumentNullException("relativeSelector");
}
if (lastSelector == null)
{
throw new ArgumentNullException("lastSelector");
}
RelativeSelector = relativeSelector;
LastSelector = lastSelector;
}
public IEnumerable <INativeElement> GetElementsWithQuerySelector(ICssSelector selector, DomContainer domContainer)
{
var container = "document";
if (_element != null)
{
var elementTag = new ElementTag(_element.TagName);
if (elementTag.Equals(new ElementTag("frame")) || elementTag.Equals(new ElementTag("iframe")))
{
var frameHierarchy = _element.GetAttributeValue("data-watinFrameHierarchy");
container = frameHierarchy + ".document";
}
else
{
var document = _element.AsHtmlElement.document;
var result = new Expando(document).GetValue <string>("___WATINFRAMEHIERARCHY");
container = "";
if (result != null)
{
container = result;
}
if (!string.IsNullOrEmpty(container))
{
container += ".";
}
container += _element.GetJavaScriptElementReference();
}
}
else
{
//container = CreateArray();
}
domContainer.RunScript(new ScriptLoader().GetSizzleInstallScript());
var code = string.Format("document.___WATINRESULT = Sizzle('{0}', {1});", selector.Selector(true), container);
domContainer.RunScript(code);
return(new JScriptElementArrayEnumerator((IEDocument)domContainer.NativeDocument, "___WATINRESULT"));
}
/// <summary>
/// 检查元素是否符合指定选择器要求，并缓存结果于元素当前文档版本
/// </summary>
/// <param name="selector">选择器</param>
/// <param name="element">元素</param>
/// <returns>是否符合选择器要求</returns>
public static bool IsEligibleBuffered(this ICssSelector selector, IHtmlElement element)
{
if (selector == null)
{
throw new ArgumentNullException("selector");
}
if (element == null)
{
return(selector.IsEligible(element));
}
var cacheContainer = element.Document as IVersionCacheContainer;
if (cacheContainer == null)
{
return(selector.IsEligible(element));
}
lock (cacheContainer.SyncRoot)
{
var cache = cacheContainer.CurrenctVersionCache[selector] as Dictionary <IHtmlElement, bool>;
if (cache != null)
{
bool result;
if (cache.TryGetValue(element, out result))
{
return(result);
}
}
else
{
cacheContainer.CurrenctVersionCache[selector] = cache = new Dictionary <IHtmlElement, bool>();
}
return(cache[element] = selector.IsEligible(element));
}
}
public IEnumerable<INativeElement> GetElementsWithQuerySelector(ICssSelector selector, DomContainer domContainer)
{
var container = "document";
if (_element != null)
{
var elementTag = new ElementTag(_element.TagName);
if (elementTag.Equals(new ElementTag("frame")) || elementTag.Equals(new ElementTag("iframe")))
{
var frameHierarchy = _element.GetAttributeValue("data-watinFrameHierarchy");
container = frameHierarchy + ".document";
}
else
{
var document = _element.AsHtmlElement.document;
var result = new Expando(document).GetValue<string>("___WATINFRAMEHIERARCHY");
container = "";
if (result != null)
container = result;
if (!string.IsNullOrEmpty(container))
container += ".";
container += _element.GetJavaScriptElementReference();
}
}
else
{
//container = CreateArray();
}
domContainer.RunScript(new ScriptLoader().GetSizzleInstallScript());
var code = string.Format("document.___WATINRESULT = Sizzle('{0}', {1});", selector.Selector(true), container);
domContainer.RunScript(code);
return new JScriptElementArrayEnumerator((IEDocument) domContainer.NativeDocument, "___WATINRESULT");
}
/// <summary>
/// 创建层叠选择器
/// </summary>
/// <param name="leftSelector">左选择器</param>
/// <param name="relative">关系选择符</param>
/// <param name="rightSelector">右选择器</param>
public CssCasecadingSelector(ICssSelector leftSelector, string relative, ICssSelector rightSelector)
{
if (rightSelector == null)
{
throw new ArgumentNullException("rightSelector");
}
if (leftSelector == null)
{
throw new ArgumentNullException("leftSelector");
}
_right = rightSelector;
if (relative != null)
{
_relative = relative.Trim();
}
_left = leftSelector;
_relativeHandler = CreateRelativeHandler(relative, _left);
}
/// <summary>
/// 创建层叠选择器实例
/// </summary>
/// <param name="leftSelector">左选择器</param>
/// <param name="combinator">结合符</param>
/// <param name="rightSelector">右选择器</param>
public static CssCasecadingSelector Create(ICssSelector leftSelector, char combinator, ICssSelector rightSelector)
{
if (leftSelector == null)
{
throw new ArgumentNullException("leftSelector");
}
if (rightSelector == null)
{
throw new ArgumentNullException("rightSelector");
}
var relativeSelctor = CreateRelativeSelector(leftSelector, combinator);
var casecadingSelector = rightSelector as CssCasecadingSelector;
if (casecadingSelector != null)
{
return(Combine(relativeSelctor, casecadingSelector));
}
return(new CssCasecadingSelector(relativeSelctor, rightSelector));
}
/// <summary>
/// 创建层叠选择器
/// </summary>
/// <param name="relativeSelector">前置关系选择器</param>
/// <param name="selector">右选择器</param>
/// <returns></returns>
public static ICssSelector Create(CssRelativeSelector relativeSelector, ICssSelector selector)
{
if (relativeSelector == null)
{
throw new ArgumentNullException("relativeSelector");
}
if (selector == null)
{
throw new ArgumentNullException("selector");
}
var elementSelector = selector as CssElementSelector;
if (elementSelector != null)
{
return(new CssCasecadingSelector(relativeSelector, elementSelector));
}
var casecadingSelector = selector as CssCasecadingSelector;
if (casecadingSelector != null)
{
return(Combine(relativeSelector, casecadingSelector));
}
var multipleSelector = selector as CssMultipleSelector;
if (multipleSelector != null)
{
return(CssMultipleSelector.Combine(relativeSelector, multipleSelector));
}
throw new NotSupportedException();
}
/// <summary>
/// 创建关系选择器
/// </summary>
/// <param name="leftSelector">左选择器</param>
/// <param name="combanitor">关系结合符</param>
/// <returns>关系选择器</returns>
private static CssRelativeSelector CreateRelativeSelector(ICssSelector leftSelector, char combanitor)
{
if (combanitor == '>')
{
return(new CssParentRelativeSelector(leftSelector));
}
else if (combanitor == ' ')
{
return(new CssAncetorRelativeSelector(leftSelector));
}
else if (combanitor == '+')
{
return(new CssPreviousRelativeSelector(leftSelector));
}
else if (combanitor == '~')
{
return(new CssSiblingsRelativeSelector(leftSelector));
}
throw new NotSupportedException("不支持的关系运算符");
}
protected override bool IsEligible( ICssSelector leftSelector, IHtmlElement element )
{
var restrict = leftSelector as ContainerRestrict;
if ( restrict != null )
return restrict.RestrictContainer.Nodes().Contains( element );
return leftSelector.IsEligibleBuffered( element.Parent() );
}
private IEnumerable <XElement> Match(XDocument xdoc, ICssSelector selector)
{
var matcher = selector.BuildMatcher(_namespaceManager);
return(xdoc.Descendants().Where(e => matcher.Matches(new XElementInfo(e))));
}
/// <summary>
/// 创建层叠选择器
/// </summary>
/// <param name="relativeSelector">前置关系选择器</param>
/// <param name="selector">右选择器</param>
/// <returns></returns>
public static ICssSelector Create( CssRelativeSelector relativeSelector, ICssSelector selector )
{
if ( relativeSelector == null )
throw new ArgumentNullException( "relativeSelector" );
if ( selector == null )
throw new ArgumentNullException( "selector" );
var elementSelector = selector as CssElementSelector;
if ( elementSelector != null )
return new CssCasecadingSelector( relativeSelector, elementSelector );
var casecadingSelector = selector as CssCasecadingSelector;
if ( casecadingSelector != null )
return Combine( relativeSelector, casecadingSelector );
var multipleSelector = selector as CssMultipleSelector;
if ( multipleSelector != null )
return CssMultipleSelector.Combine( relativeSelector, multipleSelector );
throw new NotSupportedException();
}
public IEnumerable <INativeElement> GetElementsWithQuerySelector(ICssSelector selector, DomContainer domContainer)
{
return(FindElements(By.CssSelector(selector.Selector(false))));
}
/// <summary>
/// 使用选择器从元素集中筛选出符合选择器要求的元素
/// </summary>
/// <param name="source">源元素集</param>
/// <param name="selector">选择器</param>
/// <returns>筛选结果</returns>
public static IEnumerable <IHtmlElement> FilterBy(this IEnumerable <IHtmlElement> source, ICssSelector selector)
{
if (source == null)
{
return(null);
}
if (selector == null)
{
return(source);
}
return(source.Where(selector.IsEligible));
}
/// <summary>
/// 使用选择器从元素集中筛选出符合选择器要求的元素
/// </summary>
/// <param name="selector">选择器</param>
/// <param name="source">源元素集</param>
/// <returns>筛选结果</returns>
public static IEnumerable <IHtmlElement> Filter(this ICssSelector selector, IEnumerable <IHtmlElement> source)
{
return(source.Where(e => selector.IsEligible(e)));
}
internal CssPseudoClassNotSelectorItem(ICssSelector argumentsSelector)
: base(CommonCssConstants.NOT, argumentsSelector.ToString())
{
this.argumentsSelector = argumentsSelector;
}
protected override bool IsEligible( ICssSelector leftSelector, IHtmlElement element )
{
var restrict = leftSelector as ContainerRestrict;
if ( restrict != null )
return element.IsDescendantOf( restrict.RestrictContainer );
var parant = element.Parent();
//如果父级元素符合左选择器，或者父级元素符合本选择器。
return leftSelector.IsEligibleBuffered( parant ) || this.IsEligibleBuffered( parant );
}
/// <summary>
/// Creates a new
/// <see cref="CssPageMarginBoxSelector"/>
/// instance.
/// </summary>
/// <param name="pageMarginBoxName">the page margin box name</param>
/// <param name="pageSelector">the page selector</param>
public CssPageMarginBoxSelector(String pageMarginBoxName, ICssSelector pageSelector)
{
this.pageMarginBoxName = pageMarginBoxName;
this.pageSelector = pageSelector;
}
/// <summary> /// 检查元素是否符合选择器 /// </summary> /// <param name="leftSelector">左选择器</param> /// <param name="element">要检验的元素</param> /// <returns>是否符合选择器</returns> protected abstract bool IsEligible( ICssSelector leftSelector, IHtmlElement element );
public CacheableCssSelectorWrapper( ICssSelector selector )
{
_selector = selector;
}
public IEnumerable <Element> FindElementsUsingQuerySelector(ICssSelector selector)
{
var nativeElementCollection2 = (INativeElementCollection2)GetNativeElementCollection();
return(WrapMatchingElements(nativeElementCollection2.GetElementsWithQuerySelector(selector, domContainer)));
}
/// <summary>
/// 创建层叠选择器实例
/// </summary>
/// <param name="leftSelector">左选择器</param>
/// <param name="combinator">结合符</param>
/// <param name="rightSelector">右选择器</param>
public static CssCasecadingSelector Create( ICssSelector leftSelector, char combinator, ICssSelector rightSelector )
{
if ( leftSelector == null )
throw new ArgumentNullException( "leftSelector" );
if ( rightSelector == null )
throw new ArgumentNullException( "rightSelector" );
var relativeSelctor = CreateRelativeSelector( leftSelector, combinator );
var casecadingSelector = rightSelector as CssCasecadingSelector;
if ( casecadingSelector != null )
return Combine( relativeSelctor, casecadingSelector );
return new CssCasecadingSelector( relativeSelctor, rightSelector );
}
public CssParentRelativeSelector( ICssSelector leftSelector )
: base(leftSelector)
{
}
/// <summary>
/// Creates a new
/// <see cref="CssNonStandardRuleSet"/>
/// instance.
/// </summary>
/// <param name="selector">the selector</param>
/// <param name="declarations">the declarations</param>
public CssNonStandardRuleSet(ICssSelector selector, IList <CssDeclaration> declarations)
: base(selector, declarations)
{
}
public IEnumerable<INativeElement> GetElementsWithQuerySelector(ICssSelector selector, WatiN.Core.DomContainer domContainer)
{
throw new NotImplementedException();
}
public IEnumerable<INativeElement> GetElementsWithQuerySelector(ICssSelector selector, DomContainer domContainer)
{
return FindElements(By.CssSelector(selector.Selector(false)));
}
public CacheableCssSelectorWrapper(ICssSelector selector)
{
_selector = selector;
}
protected override bool IsEligible( ICssSelector leftSelector, IHtmlElement element )
{
var previous = element.PreviousElement();
return leftSelector.IsEligibleBuffered( previous ) || this.IsEligibleBuffered( previous );
}
public virtual void DefaultVisit(ICssSelector selector)
{
}
public CssSiblingsRelativeSelector( ICssSelector leftSelector )
: base(leftSelector)
{
}
public CssAncetorRelativeSelector( ICssSelector leftSelector )
: base(leftSelector)
{
}
protected override bool IsEligible( ICssSelector leftSelector, IHtmlElement element )
{
return leftSelector.IsEligibleBuffered( element.PreviousElement() );
}
public CssPreviousRelativeSelector( ICssSelector leftSelector )
: base(leftSelector)
{
}
/// <summary>
/// 创建 CssRelativeSelector 对象
/// </summary>
/// <param name="leftSelector"></param>
protected CssRelativeSelector( ICssSelector leftSelector )
{
LeftSelector = leftSelector;
}
public IEnumerable<INativeElement> GetElementsWithQuerySelector(ICssSelector selector, DomContainer domContainer)
{
domContainer.RunScript(new ScriptLoader().GetSizzleInstallScript());
var command = string.Format("window.Sizzle('{0}', {1})", selector.Selector(true), containerReference);
var ffElements = GetElementArrayEnumerator(command);
foreach (var ffElement in ffElements)
{
yield return ffElement;
}
}
/// <summary>
/// 创建关系选择器
/// </summary>
/// <param name="leftSelector">左选择器</param>
/// <param name="combanitor">关系结合符</param>
/// <returns>关系选择器</returns>
private static CssRelativeSelector CreateRelativeSelector( ICssSelector leftSelector, char combanitor )
{
if ( combanitor == '>' )
return new CssParentRelativeSelector( leftSelector );
else if ( combanitor == ' ' )
return new CssAncetorRelativeSelector( leftSelector );
else if ( combanitor == '+' )
return new CssPreviousRelativeSelector( leftSelector );
else if ( combanitor == '~' )
return new CssSiblingsRelativeSelector( leftSelector );
throw new NotSupportedException( "不支持的关系运算符" );
}
