public static ISelector GetSelector(ExtractBy extractBy)
{
string value = extractBy.Value;
ISelector selector;
switch (extractBy.Type)
{
case ExtractBy.ExtracType.Css:
selector = new CssSelector(value);
break;
case ExtractBy.ExtracType.Regex:
selector = new RegexSelector(value);
break;
case ExtractBy.ExtracType.XPath:
selector = GetXpathSelector(value);
break;
case ExtractBy.ExtracType.JsonPath:
selector = new JsonPathSelector(value);
break;
case ExtractBy.ExtracType.Enviroment:
selector = new EnviromentSelector(value);
break;
default:
selector = GetXpathSelector(value);
break;
}
return(selector);
}
public void DescendantCombinator_WithNesting_Matches()
{
var selector = CssSelector.WithElement("div", null)
.Combine(CssCombinator.Descendant, CssSelector.WithElement("ol", null))
.Combine(CssCombinator.Descendant, CssSelector.WithElement("li", null))
.Combine(CssCombinator.Descendant, CssSelector.WithElement("p", null));
var xdoc = XDocument.Parse(@"
<html>
<head />
<body>
<div id='div00'>
<ol id='ol01'>
<li id='li01'><p id='p01' /></li>
<li id='li02'><p id='p02_1' /><p id='p02_2' /></li>
<li id='li03' />
<li id='li04'><div id='div04'><p id='p04' /></div></li>
<div id='div05'>
<li id='li05'><p id='p05' /></li>
</div>
</ol>
</div>
<ol id='ol02'>
<li id='li06'><p id='p06' /></li>
</ol>
</body>
</html>" );
var matchingElements = Match(xdoc, selector);
Assert.That(matchingElements.Select(e => e.Attribute("id").Value), Is.EquivalentTo(new[] { "p01", "p02_1", "p02_2", "p04", "p05" }));
}
/// <summary>
/// Freezes the current thread until at least one element that matches the query appears in the document.
/// </summary>
/// <param name="doc"></param>
/// <param name="query"></param>
/// <param name="timeout"></param>
/// <returns>Matched elements.</returns>
public static IEnumerable <Element> WaitSelector(this HtmlDocument doc, string query, int timeout = 0)
{
if (timeout == 0)
{
timeout = DefaultTimeout;
}
var selector = new CssSelector(query);
var timespan = 100;
for (int i = 0; i < timeout / timespan; i++)
{
try
{
var elt = selector.Select(doc).ToListOrNull();
if (elt != null)
{
return(elt);
}
}
catch
{
}
Thread.Sleep(timespan);
}
return(selector.Select(doc));
}
protected override string PerformAs(IPerformer actor)
{
var topItem = new CssSelector("#toDoList :first-child", "the top to-do item");
var text = actor.Perform(TheText.Of(topItem));
return(text);
}
public void StripNotPseudoClassContent_ElementWithPseudoClass_ReturnsOriginalSelector()
{
var expected = "li:first-child";
var selector = new CssSelector(expected);
Assert.AreEqual(expected, selector.StripNotPseudoClassContent().ToString());
}
public static ISelector GetSelector(ExtractByAttribute extractBy)
{
var value = extractBy.Value;
ISelector selector = null;
switch (extractBy.Type)
{
case ExtractType.Css:
selector = new CssSelector(value);
break;
case ExtractType.Regex:
selector = new RegexSelector(value);
break;
case ExtractType.XPath:
selector = new XPathSelector(value);
break;
case ExtractType.JsonPath:
selector = new JsonPathSelector(value);
break;
}
return(selector);
}
public void SelectorSequence_WithTwoSelectors_ToString()
{
var selector = CssSelector.WithElement("h1", null)
.Add(CssSelector.WithId("chapter1"));
Assert.That(selector.ToString(), Is.EqualTo("h1#chapter1"));
}
public void SelectorSequence_WithThreeSelectors_Matches()
{
var selector = CssSelector.WithElement("h1", null)
.Add(CssSelector.WithId("chapter1"));
var pseudoClassInfo = Substitute.For <XElementPseudoClassInfo>();
pseudoClassInfo.IsTarget(Arg.Any <XElement>())
.Returns(call => "true".Equals(call.Arg <XElement>().Attribute("istarget")?.Value, StringComparison.OrdinalIgnoreCase));
var xdoc = XDocument.Parse(@"
<html>
<head />
<body>
<p id='chapter1' istarget='true' />
<h1 id='chapter1' istarget='true' />
<h1 id='ch2' istarget='true' />
<h1 id='ch3' />
</body>
</html>" );
var matchingElements = Match(xdoc, selector);
Assert.That(matchingElements.Select(e => e.Name.LocalName + "." + e.Attribute("id").Value), Is.EquivalentTo(new[] { "h1.chapter1" }));
}
protected override void PerformAs(IPerformer actor)
{
// You may need to update the URL based on your test hosting
actor.Perform(OpenTheirBrowserOn.TheUrl("http://localhost/"));
var thePage = new CssSelector("body", "the page");
actor.Perform(Wait.Until(thePage).IsVisible());
}
public void ChildCombinator_WithoutNesting_ToString()
{
var leftSelector = CssSelector.WithElement("h1", null);
var rightSelector = CssSelector.WithElement("em", null);
var selector = leftSelector.Combine(CssCombinator.Child, rightSelector);
Assert.That(selector.ToString(), Is.EqualTo("h1 > em"));
}
/// <summary>
/// 调用此方法通知预热 Jumony for MVC 运行环境。
/// </summary>
public static void WarmUp()
{
if (!_isWarmedUp)
{
CssSelector.WarmUp();
_isWarmedUp = true;
}
}
public void SelectorSequence_WithThreeSelectors_ToString()
{
var selector = CssSelector.WithElement("h1", null)
.Add(CssSelector.WithId("chapter1"))
.Add(CssSelector.WithPseudoClass("target"));
Assert.That(selector.ToString(), Is.EqualTo("h1#chapter1:target"));
}
public void DescendantCombinator_WithNesting_ToString()
{
var selector = CssSelector.WithElement("div", null)
.Combine(CssCombinator.Descendant, CssSelector.WithElement("ol", null))
.Combine(CssCombinator.Descendant, CssSelector.WithElement("li", null))
.Combine(CssCombinator.Descendant, CssSelector.WithElement("p", null));
Assert.That(selector.ToString(), Is.EqualTo("div ol li p"));
}
public void Select(string html, string selector, string expectedIds)
{
var doc = new Document();
doc.Write(html);
var cssSelector = new CssSelector(selector);
var items = cssSelector.Select(doc.DocumentElement).Select(x => x.Id).ToArray();
CollectionAssert.AreEqual(string.IsNullOrEmpty(expectedIds) ? new string[0] : expectedIds.Split(','), items);
}
protected override void PerformAs(IPerformer actor)
{
var newItemTextbox = new CssSelector("#newItemText", "the new-item text box");
actor.Perform(Enter.TheText(item).Into(newItemTextbox));
var theAddButton = new CssSelector("#newItemButton", "the add-item button");
actor.Perform(Click.On(theAddButton));
}
/// <summary>
/// (BNF) selector: any+;
/// </summary>
/// <returns></returns>
private CssSelector ParseSelector()
{
CssSelector selector = new CssSelector();
char ch;
while (this.Read(out ch) && (Char.IsWhiteSpace(ch) || ch == ','))
{
// skip whitespace, and empty selectors
}
// consume property name
switch (ch)
{
case '{':
{
// no more declarations
return(null);
}
//case ':':// pseudoclass
case ';':
case '}':
{
throw new SyntaxError("Invalid chars in selector", this.reader.FilePath, this.reader.Line, this.reader.Column);
}
}
int start = this.Position; // start with current char
while (this.Read(out ch))
{
// continue consuming selector
switch (ch)
{
case ',':
case '{':
{
selector.Value = this.Copy(start);
if (ch == '{')
{
this.PutBack();
}
return(selector);
}
//case ':':// pseudoclass
case ';':
case '}':
{
throw new SyntaxError("Invalid selector", this.reader.FilePath, this.reader.Line, this.reader.Column);
}
}
}
throw new UnexpectedEndOfFile("Unclosed ruleset", this.reader.FilePath, this.reader.Line, this.reader.Column);
}
public void ChildCombinator_WithoutNesting()
{
var leftSelector = CssSelector.WithElement("h1", null);
var rightSelector = CssSelector.WithElement("em", null);
var selector = leftSelector.Combine(CssCombinator.Child, rightSelector);
Assert.Multiple(() =>
{
Assert.That(selector.Subject, Is.SameAs(rightSelector), nameof(selector.Subject));
Assert.That(selector.Specificity, Is.EqualTo(new CssSpecificity(0, 0, 2)), nameof(selector.Specificity));
});
}
public void ElementSelector_ForNameInUnspecifiedNamespace()
{
var selector = CssSelector.WithElement("h1");
Assert.Multiple(() =>
{
Assert.That(selector, Is.InstanceOf <CssSimpleSelector>());
Assert.That(selector.LocalName, Is.EqualTo("h1"), nameof(selector.LocalName));
Assert.That(selector.NamespacePrefix, Is.Null, nameof(selector.NamespacePrefix));
Assert.That(selector.TypeSelector, Is.SameAs(selector), nameof(selector.TypeSelector));
Assert.That(selector.Specificity, Is.EqualTo(new CssSpecificity(0, 0, 1)), nameof(selector.Specificity));
});
}
private ProcessResult ProcessResult(CQ elems, CssSelector selector)
{
var pr = new ProcessResult();
if (elems != null)
{
switch (selector.Type)
{
case CssTypeEnum.InnerHtml:
{
foreach (var ele in elems)
{
pr.Matches.Add(HttpUtility.HtmlDecode(ele.InnerHTML));
}
break;
}
case CssTypeEnum.Text:
{
foreach (var ele in elems)
{
pr.Matches.Add(HttpUtility.HtmlDecode(ele.Cq().Text()));
}
break;
}
case CssTypeEnum.Attr:
{
foreach (var ele in elems)
{
if (!string.IsNullOrEmpty(selector.AttrName))
{
var attr = ele.Attributes.GetAttribute(selector.AttrName);
pr.Matches.Add(HttpUtility.HtmlDecode(attr));
}
}
break;
}
case CssTypeEnum.OutHtml:
{
foreach (var ele in elems)
{
pr.Matches.Add(HttpUtility.HtmlDecode(ele.OuterHTML));
}
break;
}
}
}
return(pr);
}
public void SelectorSequence_WithTwoSelectors()
{
var typeSelector = CssSelector.WithElement("h1");
var extraSelector = CssSelector.WithId("chapter1");
var selector = typeSelector.Add(extraSelector);
Assert.Multiple(() =>
{
Assert.That(selector.TypeSelector, Is.SameAs(typeSelector), nameof(selector.TypeSelector));
Assert.That(selector.OtherSelectors, Is.EquivalentTo(new[] { extraSelector }), nameof(selector.OtherSelectors));
Assert.That(selector.Subject, Is.SameAs(selector), nameof(selector.Subject));
Assert.That(selector.Specificity, Is.EqualTo(new CssSpecificity(1, 0, 1)), nameof(selector.Specificity));
});
}
public void AttributeSelector_ForQualifiedName_WithValueIsLanguageCode()
{
var selector = CssSelector.WithAttribute("href", "x", CssAttributeMatchOperator.LanguageCode, "fr");
Assert.Multiple(() =>
{
Assert.That(selector, Is.InstanceOf <CssSimpleSelector>());
Assert.That(selector.LocalName, Is.EqualTo("href"), nameof(selector.LocalName));
Assert.That(selector.NamespacePrefix, Is.EqualTo("x"), nameof(selector.NamespacePrefix));
Assert.That(selector.MatchOperator, Is.EqualTo(CssAttributeMatchOperator.LanguageCode), nameof(selector.MatchOperator));
Assert.That(selector.MatchOperand, Is.EqualTo("fr"), nameof(selector.MatchOperand));
Assert.That(selector.Specificity, Is.EqualTo(new CssSpecificity(0, 1, 0)), nameof(selector.Specificity));
});
}
public void AttributeSelector_ForNameInAnyNamespace_WithValueContainingWord()
{
var selector = CssSelector.WithAttribute("href", "*", CssAttributeMatchOperator.ContainsWord, "test");
Assert.Multiple(() =>
{
Assert.That(selector, Is.InstanceOf <CssSimpleSelector>());
Assert.That(selector.LocalName, Is.EqualTo("href"), nameof(selector.LocalName));
Assert.That(selector.NamespacePrefix, Is.EqualTo("*"), nameof(selector.NamespacePrefix));
Assert.That(selector.MatchOperator, Is.EqualTo(CssAttributeMatchOperator.ContainsWord), nameof(selector.MatchOperator));
Assert.That(selector.MatchOperand, Is.EqualTo("test"), nameof(selector.MatchOperand));
Assert.That(selector.Specificity, Is.EqualTo(new CssSpecificity(0, 1, 0)), nameof(selector.Specificity));
});
}
public void AttributeSelector_ForNameInUnspecifiedNamespace()
{
var selector = CssSelector.WithAttribute("href");
Assert.Multiple(() =>
{
Assert.That(selector, Is.InstanceOf <CssSimpleSelector>());
Assert.That(selector.LocalName, Is.EqualTo("href"), nameof(selector.LocalName));
Assert.That(selector.NamespacePrefix, Is.Null, nameof(selector.NamespacePrefix));
Assert.That(selector.MatchOperator, Is.EqualTo(CssAttributeMatchOperator.Any), nameof(selector.MatchOperator));
Assert.That(selector.MatchOperand, Is.Null, nameof(selector.MatchOperand));
Assert.That(selector.Specificity, Is.EqualTo(new CssSpecificity(0, 1, 0)), nameof(selector.Specificity));
});
}
public void AttributeSelector_ForNameWithoutNamespace_WithExactValue()
{
var selector = CssSelector.WithAttribute("href", "", CssAttributeMatchOperator.Exact, "#some-target");
Assert.Multiple(() =>
{
Assert.That(selector, Is.InstanceOf <CssSimpleSelector>());
Assert.That(selector.LocalName, Is.EqualTo("href"), nameof(selector.LocalName));
Assert.That(selector.NamespacePrefix, Is.EqualTo(""), nameof(selector.NamespacePrefix));
Assert.That(selector.MatchOperator, Is.EqualTo(CssAttributeMatchOperator.Exact), nameof(selector.MatchOperator));
Assert.That(selector.MatchOperand, Is.EqualTo("#some-target"), nameof(selector.MatchOperand));
Assert.That(selector.Specificity, Is.EqualTo(new CssSpecificity(0, 1, 0)), nameof(selector.Specificity));
});
}
protected override bool CheckNode(HtmlNode node, string parameter)
{
var selectors = CssSelector.Parse(parameter);
var nodes = new[] { node };
foreach (var selector in selectors)
{
if (selector.FilterCore(nodes).Count() == 1)
{
return(false);
}
}
return(true);
}
public void AttributeSelector_ForNameWithoutNamespace_WithAnyValue_Matches()
{
var selector = CssSelector.WithAttribute("href", "");
var xdoc = XDocument.Parse(@"
<html>
<head />
<body>
<a id='anchor1' href='http://some.where.else' />
<a id='anchor2' />
</body>
</html>" );
var matchingElements = Match(xdoc, selector);
Assert.That(matchingElements.Select(e => e.Attribute("id").Value), Is.EquivalentTo(new[] { "anchor1" }));
}
public void AttributeSelector_ForNameWithoutNamespace_WithExactValue_Matches()
{
var selector = CssSelector.WithAttribute("href", "", CssAttributeMatchOperator.Exact, "#another-target");
var xdoc = XDocument.Parse(@"
<html>
<head />
<body>
<a id='anchor1' href='#some-target' />
<a id='anchor2' href='#another-target' />
</body>
</html>" );
var matchingElements = Match(xdoc, selector);
Assert.That(matchingElements.Select(e => e.Attribute("id").Value), Is.EquivalentTo(new[] { "anchor2" }));
}
public static IList <HtmlAgilityPack.HtmlNode> QuerySelectorAll(this IEnumerable <HtmlAgilityPack.HtmlNode> nodes, string cssSelector)
{
if (cssSelector == null)
{
throw new ArgumentNullException("cssSelector");
}
if (cssSelector.Contains(','))
{
var combinedSelectors = cssSelector.Split(',');
var rt = nodes.QuerySelectorAll(combinedSelectors[0]);
foreach (var s in combinedSelectors.Skip(1))
{
foreach (var n in nodes.QuerySelectorAll(s))
{
if (!rt.Contains(n))
{
rt.Add(n);
}
}
}
return(rt);
}
cssSelector = cssSelector.Trim();
var selectors = CssSelector.Parse(cssSelector);
bool allowTraverse = true;
foreach (var selector in selectors)
{
if (allowTraverse && selector.AllowTraverse)
{
nodes = Traverse(nodes);
}
nodes = selector.Filter(nodes);
allowTraverse = selector.AllowTraverse;
}
return(nodes
.Distinct()
.ToList());
}
public override string ToString()
{
if (CssSelector.HasValue())
{
return(CssSelector);
}
else
{
return((!Content.IsNullOrEmpty() ? Content : "")
+ "<" + TagName
+ (!Id.IsNullOrEmpty() ? "#" + Id : "")
+ (!Class.IsNullOrEmpty() ? "." + Class : "")
+ (!Name.IsNullOrEmpty() ? "[Name=" + Name + "]" : "")
+ (!Type.IsNullOrEmpty() ? "[Type=" + Type + "]" : "")
+ ">");
}
}
public void DescendantCombinator_WithNesting()
{
var selector1 = CssSelector.WithElement("div");
var selector2 = CssSelector.WithElement("ol");
var selector3 = CssSelector.WithElement("li");
var selector4 = CssSelector.WithElement("p");
var selector = selector1
.Combine(CssCombinator.Descendant, selector2)
.Combine(CssCombinator.Descendant, selector3)
.Combine(CssCombinator.Descendant, selector4);
Assert.Multiple(() =>
{
Assert.That(selector.Subject, Is.SameAs(selector4), nameof(selector.Subject));
Assert.That(selector.Specificity, Is.EqualTo(new CssSpecificity(0, 0, 4)), nameof(selector.Specificity));
});
}
/// <summary>
/// Exports grid SummaryRow to the specified worksheet.
///
/// </summary>
protected virtual void ExportSummaries(WebDataGrid grid, Worksheet worksheet, ref int rowIndex, int columnOffset, int outlineLevel, bool hidden, string gridCssClass, int firstDataRowIndex)
{
SummaryRow behavior = grid.Behaviors.GetBehavior<SummaryRow>();
int index1 = rowIndex - (grid.ShowFooter ? 2 : 1);
bool renderingResolved = behavior.EnableCompactRenderingResolved;
int summaryNumberVisible = behavior.ColumnSummaries.GetMaxSummaryNumberVisible();
int maxSummaryRows = behavior.ColumnSummaries.GetMaxSummaryRows();
string str1 = string.Empty;
if (this.EnableStylesExport)
str1 = behavior.ResolveCssClass(behavior.SummariesCssClass, 0);
for (int index2 = 0; index2 < maxSummaryRows; ++index2)
{
if ((index2 < summaryNumberVisible || !renderingResolved) && (renderingResolved || behavior.ColumnSummaries.IsVisibleRow(index2)))
{
WorksheetRow worksheetRow = worksheet.Rows[rowIndex];
worksheetRow.OutlineLevel = outlineLevel;
worksheetRow.Hidden = hidden;
int rowIndex1 = rowIndex;
ExcelRowExportingEventArgs e1 = new ExcelRowExportingEventArgs(worksheet, worksheetRow, rowIndex1, columnOffset, outlineLevel, false, false, true);
this.OnRowExporting(e1);
if (!e1.Cancel)
{
int columnIndex = columnOffset;
foreach (ControlDataField summaryCell in (IVisibleItemsEnumerable)grid.Fields)
{
if (!summaryCell.Hidden && !summaryCell.HiddenByParent)
{
WorksheetCell worksheetCell = worksheetRow.Cells[columnIndex];
Summary summaryByOrder = behavior.ColumnSummaries.GetSummaryByOrder(summaryCell.Key, index2);
SummarySetting summarySetting = (SummarySetting)null;
ExcelCellExportingEventArgs e2 = new ExcelCellExportingEventArgs(worksheet, worksheetCell, rowIndex, columnIndex, outlineLevel, false, false, true);
e2.Summary = summaryByOrder;
this.OnCellExporting(e2);
if (e2.Cancel)
{
++columnIndex;
}
else
{
SummaryCellExportingEventArgs e3 = new SummaryCellExportingEventArgs(summaryCell, worksheet, worksheetCell, rowIndex, columnIndex, outlineLevel, false, false, true);
e3.Summary = summaryByOrder;
this.OnSummaryCellExporting(e3);
if (e3.Cancel)
{
++columnIndex;
}
else
{
if (summaryByOrder == null)
{
worksheetCell.Value = (object)behavior.EmptyFooterText;
}
else
{
SummaryRowSetting sumRowSetting = behavior.ColumnSettings[summaryCell.Key];
summarySetting = sumRowSetting != null ? (summaryByOrder.SummaryType == SummaryType.Custom ? sumRowSetting.SummarySettings.CustomSummaryByName(summaryByOrder.CustomSummaryName) : sumRowSetting.SummarySettings[summaryByOrder.SummaryType]) : (SummarySetting)null;
string format1 = summarySetting == null ? (sumRowSetting == null ? behavior.FormatString : sumRowSetting.FormatString) : summarySetting.FormatString;
if (summaryByOrder.SummaryType == SummaryType.Custom)
worksheetCell.Value = (object)string.Format(format1, (object)summaryByOrder.CustomSummaryName, summaryByOrder.Value);
else if (summaryByOrder.SummaryType == SummaryType.Custom)
{
worksheetCell.Value = (object)string.Format(format1, (object)summaryByOrder.CustomSummaryName, summaryByOrder.Value);
}
else
{
List<string> list = (List<string>)null;
string str2 = string.Empty;
string str3;
if (grid is ContainerGrid && ((ContainerGrid)grid).HasChildGrids())
{
list = new List<string>();
for (int index3 = firstDataRowIndex; index3 <= index1; ++index3)
{
if (worksheet.Rows[index3].OutlineLevel == outlineLevel)
list.Add(worksheet.Rows[index3].Cells[columnIndex].ToString(CellReferenceMode.A1, false, true, true));
}
str3 = string.Join(",", list.ToArray());
}
else
str3 = string.Format("{0}:{1}", (object)worksheet.Rows[firstDataRowIndex].Cells[columnIndex].ToString(CellReferenceMode.A1, false, true, true), (object)worksheet.Rows[index1].Cells[columnIndex].ToString(CellReferenceMode.A1, false, true, true));
int num1 = format1.IndexOf("{1");
string format2;
if (num1 > -1)
{
string str4 = "\"" + format1.Substring(0, num1) + "\" & ";
string str5 = format1.Substring(num1);
int num2 = str5.IndexOf("}");
string str6 = str5.Insert(num2 + 1, " & \"") + "\"";
format2 = "=" + str4 + str6;
}
else
format2 = "=\"" + format1 + "\"";
string format3 = string.Format(format2, (object)"{0}", (object)"{1}({3})").Replace("\"\" &", "").Replace("& \"\"", "");
if (summaryByOrder.SummaryType == SummaryType.Count && format3.Contains("{1"))
format3 = format3.Replace("{1}({3})", "{1}({3}) + {2}({3})");
string[] strArray = this.GetExcelFunctionName(summaryByOrder.SummaryType).Split(new char[1]
{
'|'
}, StringSplitOptions.RemoveEmptyEntries);
string str7 = strArray.Length > 1 ? strArray[1] : "";
string str8 = string.Format(format3, (object)behavior.GetCultureInvariantSummaryString(summaryByOrder.SummaryType, summaryByOrder.CustomSummaryName), (object)strArray[0], (object)str7, (object)str3);
if (list != null && (list.Count > 30 || summaryByOrder.SummaryType == SummaryType.Count))
worksheetCell.Value = (object)behavior.GetSummaryValue((GridField)summaryCell, summaryByOrder, behavior.ColumnSummaries[summaryCell.Key], sumRowSetting, false);
else
worksheetCell.ApplyFormula(str8);
}
}
if (this.EnableStylesExport)
{
string classes = str1;
if (summarySetting != null && !string.IsNullOrEmpty(summarySetting.CssClass))
classes = classes + " " + summarySetting.CssClass;
if (summaryByOrder != null && !string.IsNullOrEmpty(summaryByOrder.CssClass))
classes = classes + " " + summaryByOrder.CssClass;
CssSelector selector1 = new CssSelector();
selector1.AddClasses(string.Format("{0} {1}", (object)gridCssClass, (object)classes));
CssStyle styleObject1 = this._currentStyleSheet.GetStyleObject(selector1);
this.ApplyCellFormatFromStyle(worksheetCell.Worksheet.Workbook, worksheetCell.CellFormat, styleObject1, grid);
CssSelector selector2 = new CssSelector();
selector2.AddClasses(classes);
CssStyle styleObject2 = this._currentStyleSheet.GetStyleObject(selector2);
this.ApplyCellBorderFromStyle(worksheetCell.CellFormat, styleObject2);
}
SummaryCellExportedEventArgs e4 = new SummaryCellExportedEventArgs(summaryCell, worksheet, worksheetCell, rowIndex1, columnIndex, outlineLevel, false, false, true);
e4.Summary = summaryByOrder;
this.OnSummaryCellExported(e4);
ExcelCellExportedEventArgs e5 = new ExcelCellExportedEventArgs(worksheet, worksheetCell, rowIndex1, columnIndex, outlineLevel, false, false, true);
e5.Summary = summaryByOrder;
this.OnCellExported(e5);
++columnIndex;
}
}
}
}
++rowIndex;
this.OnRowExported(new ExcelRowExportedEventArgs(worksheet, worksheetRow, rowIndex1, columnOffset, outlineLevel, false, false, true));
}
}
}
}
/// <summary>
/// Exports a grid record item to its corresponding worksheet cell.
///
/// </summary>
protected virtual void ExportCell(GridRecordItem item, WorksheetRow worksheetRow, int rowIndex, int columnIndex, string gridCssClass, string itemCssClass)
{
WorksheetCell worksheetCell = worksheetRow.Cells[columnIndex];
ExcelCellExportingEventArgs e1 = new ExcelCellExportingEventArgs(worksheetRow.Worksheet, worksheetCell, rowIndex, columnIndex, worksheetRow.OutlineLevel, false, false, false);
this.OnCellExporting(e1);
if (e1.Cancel)
return;
GridRecordItemExportingEventArgs e2 = new GridRecordItemExportingEventArgs(item, worksheetRow.Worksheet, worksheetCell, rowIndex, columnIndex, worksheetRow.OutlineLevel, false, false, false);
this.OnGridRecordItemExporting(e2);
if (e2.Cancel)
return;
worksheetCell.Value = !item.HasTemplate ? (!(item.Column is FormattedGridField) || this.DisableCellValueFormatting || string.IsNullOrEmpty(((FormattedGridField)item.Column).DataFormatString) ? item.Value : (object)string.Format(((FormattedGridField)item.Column).DataFormatString, item.Value)) : (object)this.RenderTemplate(item.TemplateContainer);
if (this.EnableStylesExport)
{
if (!string.IsNullOrEmpty(item.CssClass))
itemCssClass = itemCssClass + " " + item.CssClass;
if (!string.IsNullOrEmpty(item.Column.CssClass))
itemCssClass = itemCssClass + " " + item.Column.CssClass;
CssSelector selector1 = new CssSelector();
selector1.AddClasses(string.Format("{0} {1}", (object)gridCssClass, (object)itemCssClass));
CssStyle styleObject1 = this._currentStyleSheet.GetStyleObject(selector1);
this.ApplyCellFormatFromStyle(worksheetCell.Worksheet.Workbook, worksheetCell.CellFormat, styleObject1, (WebDataGrid)item.Row.ControlMain);
CssSelector selector2 = new CssSelector();
selector2.AddClasses(itemCssClass);
CssStyle styleObject2 = this._currentStyleSheet.GetStyleObject(selector2);
this.ApplyCellBorderFromStyle(worksheetCell.CellFormat, styleObject2);
}
if (worksheetCell.Value != null)
{
this.SetColumnWidth(worksheetRow.Worksheet.Columns[columnIndex], worksheetCell);
if (worksheetCell.Value.ToString().Contains(Environment.NewLine))
worksheetCell.CellFormat.WrapText = ExcelDefaultableBoolean.True;
}
this.OnGridRecordItemExported(new GridRecordItemExportedEventArgs(item, worksheetRow.Worksheet, worksheetCell, rowIndex, columnIndex, worksheetRow.OutlineLevel, false, false, false));
this.OnCellExported(new ExcelCellExportedEventArgs(worksheetRow.Worksheet, worksheetCell, rowIndex, columnIndex, worksheetRow.OutlineLevel, false, false, false));
}
/// <summary>
/// Exports set of grouped rows to the specified worksheet.
///
/// </summary>
protected virtual void ExportGroupedRows(GroupedRecordCollection groupedRows, Worksheet worksheet, ref int rowIndex, int columnOffset, bool hasHiddenCols, int outlineLevel, bool hidden)
{
ContainerGrid owner = groupedRows.Owner;
WebHierarchicalDataGrid mainGrid = owner.MainGrid;
string styleClassString1 = mainGrid.RunBot.StyleBot.GetStyleClassString(0, mainGrid.ControlStyle.CssClass);
string styleClassString2 = owner.RunBot.StyleBot.GetStyleClassString(5, owner.ItemCssClass);
string styleClassString3 = owner.RunBot.StyleBot.GetStyleClassString(6, owner.AltItemCssClass);
string styleClassString4 = mainGrid.RunBot.StyleBot.GetStyleClassString(11, owner.Band != null ? owner.Band.GroupingSettings.GroupedRowCssClassResolved : "");
int count = groupedRows.Owner.Fields.Count;
if (hasHiddenCols)
{
foreach (ControlDataField controlDataField in (CollectionBase)groupedRows.Owner.Fields)
{
if (controlDataField.Hidden || controlDataField.HiddenByParent)
--count;
}
}
foreach (GroupedRecord groupedRecord in (CollectionBase)groupedRows)
{
WorksheetRow worksheetRow = worksheet.Rows[rowIndex];
worksheetRow.OutlineLevel = outlineLevel;
worksheetRow.Hidden = hidden;
WorksheetMergedCellsRegion mergedCellsRegion = worksheet.MergedCellsRegions.Add(rowIndex, columnOffset, rowIndex, columnOffset + count - 1);
mergedCellsRegion.Value = (object)groupedRecord.Text;
if (this.EnableStylesExport)
{
CssSelector selector1 = new CssSelector();
selector1.AddClasses(string.Format("{0} {1}", (object)styleClassString1, (object)styleClassString4));
CssStyle styleObject1 = this._currentStyleSheet.GetStyleObject(selector1);
this.ApplyCellFormatFromStyle(worksheet.Workbook, mergedCellsRegion.CellFormat, styleObject1, (WebDataGrid)owner);
CssSelector selector2 = new CssSelector();
selector2.AddClasses(styleClassString4);
CssStyle styleObject2 = this._currentStyleSheet.GetStyleObject(selector2);
this.ApplyCellBorderFromStyle(mergedCellsRegion.CellFormat, styleObject2);
}
++rowIndex;
bool hidden1 = hidden || !groupedRecord.Expanded;
if (groupedRecord.HasChildGroupRows)
{
this.ExportGroupedRows(groupedRecord.ChildGroupRows, worksheet, ref rowIndex, columnOffset, hasHiddenCols, outlineLevel + 1, hidden1);
}
else
{
groupedRecord.Rows.Reset();
while (groupedRecord.Rows.MoveNext())
{
ContainerGridRecord containerGridRecord = (ContainerGridRecord)groupedRecord.Rows.Current;
string itemCssClass = styleClassString2;
if (containerGridRecord.Index % 2 == 1)
itemCssClass = itemCssClass + " " + styleClassString3;
if (!string.IsNullOrEmpty(containerGridRecord.CssClass))
itemCssClass = itemCssClass + " " + containerGridRecord.CssClass;
this.ExportRow((GridRecord)containerGridRecord, worksheet, ref rowIndex, columnOffset, hasHiddenCols, outlineLevel + 1, hidden1, styleClassString1, itemCssClass);
}
}
}
}
public CssRule ReadRuleBlock(CssSelector selector)
{
var rule = new StyleRule(selector);
ReadBlock(rule);
return rule;
}
public void ContainsNotPseudoClass_ElementWithNotPseudoClass_ReturnsTrue()
{
var selector = new CssSelector("li:not(.ignored)");
Assert.IsTrue(selector.HasNotPseudoClass);
}
public void NotPseudoClassContent_ElementWithPseudoClass_ReturnsNull()
{
var selector = new CssSelector("li:first-child");
Assert.IsNull(selector.NotPseudoClassContent);
}
public void NotPseudoClassContent_ElementWithNotPseudoClass_ReturnsContent()
{
var selector = new CssSelector("li:not(.ignored)");
Assert.AreEqual(".ignored", selector.NotPseudoClassContent);
}
public void StripNotPseudoClassContent_ElementWithPseudoClass_ReturnsOriginalSelector()
{
var expected = "li:first-child";
var selector = new CssSelector(expected);
Assert.AreEqual(expected, selector.StripNotPseudoClassContent().ToString());
}
public void StripNotPseudoClassContent_ElementWithNotPseudoClass_ReturnsSelectorWithoutNot()
{
var selector = new CssSelector("li:not(.ignored)");
Assert.AreEqual("li", selector.StripNotPseudoClassContent().ToString());
}
public void ContainsNotPseudoClass_ElementWithPseudoClass_ReturnsFalse()
{
var selector = new CssSelector("li:first-child");
Assert.IsFalse(selector.HasNotPseudoClass);
}
public StyleRule(CssSelector selector)
: base(RuleType.Style)
{
this.selector = selector;
}
/// <summary>
/// (BNF) selector: any+;
/// </summary>
/// <returns></returns>
private CssSelector ParseSelector()
{
CssSelector selector = new CssSelector();
char ch;
while (this.Read(out ch) && (Char.IsWhiteSpace(ch) || ch == ','))
{
// skip whitespace, and empty selectors
}
// consume property name
switch (ch)
{
case '{':
{
// no more declarations
return null;
}
//case ':':// pseudoclass
case ';':
case '}':
{
throw new SyntaxError("Invalid chars in selector", this.reader.FilePath, this.reader.Line, this.reader.Column);
}
}
int start = this.Position;// start with current char
while (this.Read(out ch))
{
// continue consuming selector
switch (ch)
{
case ',':
case '{':
{
selector.Value = this.Copy(start);
if (ch == '{')
{
this.PutBack();
}
return selector;
}
//case ':':// pseudoclass
case ';':
case '}':
{
throw new SyntaxError("Invalid selector", this.reader.FilePath, this.reader.Line, this.reader.Column);
}
}
}
throw new UnexpectedEndOfFile("Unclosed ruleset", this.reader.FilePath, this.reader.Line, this.reader.Column);
}
public void WriteSelector(CssSelector selector)
{
if (selector.Count == 1)
{
writer.Write(selector.ToString());
}
else
{
var i = 0;
foreach (var s in selector)
{
if (i != 0)
{
writer.WriteLine(",");
}
writer.Write(s);
i++;
}
}
}
/// <summary>
/// Exports a grid field caption (header or footer) to the specified worksheet cell.
///
/// </summary>
protected virtual void ExportGridFieldCaption(WebDataGrid grid, GridFieldCaption caption, WorksheetRow wsRow, WorksheetCell wsCell, int rowIndex, int columnIndex, string gridCssClass, string captionRowCssClass, bool isHeader, int rowSpan, int colSpan, int colOffset)
{
WorksheetMergedCellsRegion mergedCellsRegion = rowSpan > 1 || colSpan > 1 ? wsRow.Worksheet.MergedCellsRegions.Add(rowIndex, columnIndex + colOffset, rowIndex + rowSpan - 1, columnIndex + colOffset + colSpan - 1) : (WorksheetMergedCellsRegion)null;
ExcelCellExportingEventArgs e1 = new ExcelCellExportingEventArgs(wsRow.Worksheet, wsCell, rowIndex, columnIndex, wsRow.OutlineLevel, isHeader, !isHeader, false);
this.OnCellExporting(e1);
if (e1.Cancel)
return;
GridFieldCaptionExportingEventArgs e2 = new GridFieldCaptionExportingEventArgs(caption, wsRow.Worksheet, wsCell, rowIndex, columnIndex, wsRow.OutlineLevel, isHeader, !isHeader, false);
this.OnGridFieldCaptionExporting(e2);
if (e2.Cancel)
return;
if (mergedCellsRegion != null)
mergedCellsRegion.Value = (object)caption.Text;
else
wsCell.Value = (object)caption.Text;
if (this.EnableStylesExport)
{
string styleClassString = grid.RunBot.StyleBot.GetStyleClassString((int)caption.Role, caption.CssClassResolved);
if (caption.OwnerField is GroupField && caption.Role == WebDataGridRoles.HeaderCaption)
styleClassString = grid.RunBot.StyleBot.GetStyleClassString(10, styleClassString);
CssSelector selector1 = new CssSelector();
selector1.AddClasses(string.Format("{0} {1} {2}", (object)gridCssClass, (object)captionRowCssClass, (object)styleClassString));
CssStyle styleObject1 = this._currentStyleSheet.GetStyleObject(selector1);
this.ApplyCellFormatFromStyle(wsCell.Worksheet.Workbook, wsCell.CellFormat, styleObject1, grid);
if (mergedCellsRegion != null)
this.ApplyCellFormatFromStyle(mergedCellsRegion.Worksheet.Workbook, mergedCellsRegion.CellFormat, styleObject1, grid);
CssSelector selector2 = new CssSelector();
selector2.AddClasses(styleClassString);
CssStyle styleObject2 = this._currentStyleSheet.GetStyleObject(selector2);
this.ApplyCellBorderFromStyle(wsCell.CellFormat, styleObject2);
if (mergedCellsRegion != null)
this.ApplyCellBorderFromStyle(mergedCellsRegion.CellFormat, styleObject2);
}
if (wsCell.Value != null)
{
this.SetColumnWidth(wsCell.Worksheet.Columns[wsCell.ColumnIndex], wsCell);
if (wsCell.Value.ToString().Contains(Environment.NewLine))
wsCell.CellFormat.WrapText = ExcelDefaultableBoolean.True;
}
if (mergedCellsRegion != null && mergedCellsRegion.Value != null && mergedCellsRegion.Value.ToString().Contains(Environment.NewLine))
mergedCellsRegion.CellFormat.WrapText = ExcelDefaultableBoolean.True;
this.OnGridFieldCaptionExported(new GridFieldCaptionExportedEventArgs(caption, wsRow.Worksheet, wsCell, rowIndex, columnIndex, wsRow.OutlineLevel, isHeader, !isHeader, false));
this.OnCellExported(new ExcelCellExportedEventArgs(wsRow.Worksheet, wsCell, rowIndex, columnIndex, wsRow.OutlineLevel, isHeader, !isHeader, false));
}
