internal CssDeclarationRule(ICssStyleSheet owner, CssRuleType type, String name, HashSet <String> contained)
: base(owner, type)
{
_declarations = new List <ICssProperty>();
_contained = contained;
_name = name;
}
/// <summary>
/// Sets a new default stylesheet defined by the provided string.
/// </summary>
/// <param name="sourceCode">The source for a new base stylesheet.</param>
/// <returns>The CSSOM of the parsed source.</returns>
public ICssStyleSheet SetDefault(String sourceCode)
{
var parser = new CssParser(_options, Configuration.Default);
var sheet = parser.ParseStylesheet(sourceCode);
_default = sheet;
return sheet;
}
public ICssRule CreateRule(ICssStyleSheet sheet, CssToken token)
{
switch (token.Type)
{
case CssTokenType.AtKeyword:
return(CreateAtRule(sheet, token));
case CssTokenType.CurlyBracketOpen:
RaiseErrorOccurred(CssParseError.InvalidBlockStart, token.Position);
JumpToRuleEnd(ref token);
return(null);
case CssTokenType.String:
case CssTokenType.Url:
case CssTokenType.CurlyBracketClose:
case CssTokenType.RoundBracketClose:
case CssTokenType.SquareBracketClose:
RaiseErrorOccurred(CssParseError.InvalidToken, token.Position);
JumpToRuleEnd(ref token);
return(null);
default:
return(CreateStyleRule(sheet, token));
}
}
protected override void ReplaceWith(ICssRule rule)
{
var newRule = rule as CssImportRule;
_href = newRule._href;
_media.Import(newRule._media);
_styleSheet = newRule._styleSheet;
}
protected override void ReplaceWith(ICssRule rule)
{
var newRule = rule as CssImportRule;
_href = newRule._href;
_media.Import(newRule._media);
_styleSheet = newRule._styleSheet;
}
/// <summary>
/// Sets a new default stylesheet defined by the provided string.
/// </summary>
/// <param name="sourceCode">The source for a new base stylesheet.</param>
/// <returns>The CSSOM of the parsed source.</returns>
public ICssStyleSheet SetDefault(String sourceCode)
{
var parser = new CssParser(_options);
var source = new TextSource(sourceCode);
var sheet = new CssStyleSheet(parser, default(String), default(ICssStyleSheet));
_default = Parse(parser, sheet, source).Result;
return _default;
}
/// <summary>
/// Sets a new default stylesheet defined by the provided string.
/// </summary>
/// <param name="sourceCode">The source for a new base stylesheet.</param>
/// <returns>The CSSOM of the parsed source.</returns>
public ICssStyleSheet SetDefault(String sourceCode)
{
var parser = new CssParser(_options, Configuration.Default);
var sheet = parser.ParseStylesheet(sourceCode);
_default = sheet;
return(sheet);
}
protected override void ReplaceWith(ICssRule rule)
{
var newRule = (ICssImportRule)rule;
_media.Replace(newRule.Media);
_href = newRule.Href;
_styleSheet = newRule.Sheet;
}
/// <summary>
/// Sets a new default stylesheet defined by the provided string.
/// </summary>
/// <param name="sourceCode">The source for a new base stylesheet.</param>
/// <returns>The CSSOM of the parsed source.</returns>
public ICssStyleSheet SetDefault(String sourceCode)
{
var parser = new CssParser(_options);
var source = new TextSource(sourceCode);
var sheet = new CssStyleSheet(parser, default(String), default(ICssStyleSheet));
_default = Parse(parser, sheet, source).Result;
return(_default);
}
internal void Add(CssRule rule, ICssStyleSheet owner, ICssRule parent)
{
if (rule != null)
{
_rules.Add(rule);
rule.Owner = owner;
rule.Parent = parent;
}
}
/// <summary>
/// Applies a CSS stylesheet to the current App
/// <para xml:lang="es">
/// Aplica una hoja de estilo css para la aplicacion actual.
/// </para>
/// </summary>
/// <param name="styleSheet">A list of css rules to be applied to the current running App
/// <para xml:lang="es">Una lista de reglas css que se aplicaran a la aplicacion actual en ejecucion.</para>
/// </param>
public static void ParseStyleRules(string styleSheet)
{
CssParser parser = new CssParser();
ICssStyleSheet cssStylesSheet = parser.ParseStylesheet(styleSheet);
//get only the rules that are actually styles
foreach (ICssStyleRule rule in cssStylesSheet.Rules.Where(rule => rule.Type == CssRuleType.Style))
{
ParsedStyleRules.Add(rule);
}
}
internal void Import(CssRuleList rules, ICssStyleSheet owner, ICssRule parent)
{
while (rules._rules.Count > 0)
{
var newRule = rules._rules[0];
rules._rules.RemoveAt(0);
newRule.Parent = parent;
newRule.Owner = owner;
_rules.Add(newRule);
}
}
private static Boolean IsRecursion(ICssStyleSheet sheet, Url url)
{
var href = url.Href;
while (sheet != null && !sheet.Href.Is(href))
{
sheet = sheet.Parent;
}
return(sheet != null);
}
internal void Insert(CssRule value, Int32 index, ICssStyleSheet owner, ICssRule parent)
{
if (value == null)
throw new DomException(DomError.Syntax);
else if (value.Type == CssRuleType.Charset)
throw new DomException(DomError.Syntax);
else if (index > _rules.Count)
throw new DomException(DomError.IndexSizeError);
else if (value.Type == CssRuleType.Namespace && _rules.Any(m => (m.Type != CssRuleType.Import && m.Type != CssRuleType.Charset && m.Type != CssRuleType.Namespace)))
throw new DomException(DomError.InvalidState);
_rules.Insert(index, value);
value.Owner = owner;
value.Parent = parent;
}
/// <summary>Gets the string representation of a CSS style sheet.</summary>
/// <param name="styleSheet">The CSS style sheet to stringify.</param>
/// <param name="isMainStyleSheet">If the style sheet is the one scanned,
/// use <c>false</c> if it is an imported style sheet.</param>
/// <returns>A CSS style sheet as string.</returns>
private string StringifyStyleSheet(ICssStyleSheet styleSheet, bool isMainStyleSheet = true)
{
var stringWriter = new StringWriter();
styleSheet.ToCss(stringWriter, new CssStyleFormatter());
string result = stringWriter.GetStringBuilder().ToString();
if (policy.EmbedsStyleSheets && isMainStyleSheet)
{
foreach (KeyValuePair <string, ICssStyleSheet> imported in ScannedImportedStyleSheets)
{
result = result.Replace(imported.Key, StringifyStyleSheet(imported.Value, isMainStyleSheet: false));
}
}
return(result);
}
/// <summary>Scans a CSS style sheet and returns a clean output removing invalid rules or properties.</summary>
/// <param name="styleSheet">The CSS style sheet to scan.</param>
/// <returns>A clean CSS style sheet as string.</returns>
private void ScanStyleSheet(ICssStyleSheet styleSheet)
{
var i = 0;
while (i < styleSheet.Rules.Length)
{
ICssRule rule = styleSheet.Rules[i];
if (!ScanStyleRule(rule))
{
AddError(Constants.ERROR_CSS_RULE_NOTALLOWED, rule.CssText);
styleSheet.RemoveAt(i); // Deletes rule in-place (length is dynamic), counter must not be incremented.
}
else
{
i++;
}
}
}
/// <summary>
/// 过滤规则
/// </summary>
/// <param name="cssStyleSheet"></param>
/// <returns></returns>
protected virtual string Filters(ICssStyleSheet cssStyleSheet)
{
if (cssStyleSheet == null || cssStyleSheet.Rules.Length == 0)
{
return(string.Empty);
}
for (var i = 0; i < cssStyleSheet.Rules.Length;)
{
ICssRule rule = cssStyleSheet.Rules[i];
if (!Validate(rule))
{
cssStyleSheet.RemoveAt(i);
}
else
{
i++;
}
}
return(cssStyleSheet.ToCss());
}
private CssUnknownRule CreateUnknownAtRule(ICssStyleSheet sheet, CssToken current)
{
var token = NextToken();
while (token.IsNot(CssTokenType.CurlyBracketOpen, CssTokenType.Semicolon, CssTokenType.EndOfFile))
{
token = NextToken();
}
if (token.Type == CssTokenType.CurlyBracketOpen)
{
var curly = 1;
do
{
token = NextToken();
switch (token.Type)
{
case CssTokenType.CurlyBracketOpen:
curly++;
break;
case CssTokenType.CurlyBracketClose:
curly--;
break;
case CssTokenType.EndOfFile:
curly = 0;
break;
}
}while (curly != 0);
}
var range = new TextRange(current.Position, token.Position);
return(new CssUnknownRule(sheet, current.Data, new TextView(sheet.Source, range)));
}
internal CssKeyframesRule(ICssStyleSheet owner)
: base(owner, CssRuleType.Keyframes)
{
}
internal void Add(CssRule value, ICssStyleSheet owner, ICssRule parent)
{
_rules.Add(value);
value.Owner = owner;
value.Parent = parent;
}
internal CssStyleSheet(CssParser parser, String url, ICssStyleSheet parent)
: this(parser, url, parent?.OwnerNode)
{
_parent = parent;
}
/// <summary>
/// Creates a new event for starting CSS parsing.
/// </summary>
/// <param name="styleSheet">The sheet to be filled.</param>
/// <param name="completed">Determines if parsing is done.</param>
public CssParseEvent(ICssStyleSheet styleSheet, Boolean completed)
: base(completed ? EventNames.Parsed : EventNames.Parsing)
{
StyleSheet = styleSheet;
}
/// <summary>
/// Creates a new event for starting CSS parsing.
/// </summary>
/// <param name="styleSheet">The sheet to be filled.</param>
public CssParseStartEvent(ICssStyleSheet styleSheet)
{
StyleSheet = styleSheet;
}
/// <summary>
/// Creates a new event for starting CSS parsing.
/// </summary>
/// <param name="styleSheet">The sheet to be filled.</param>
/// <param name="completed">Determines if parsing is done.</param>
public CssParseEvent(ICssStyleSheet styleSheet, Boolean completed)
: base(completed ? EventNames.ParseEnd : EventNames.ParseStart)
{
StyleSheet = styleSheet;
}
private async Task <ICssStyleSheet> ParseChildStyleSheetAsync(IDownload download, ICssStyleSheet parent, CancellationToken cancel)
{
using (var response = await download.Task.ConfigureAwait(false))
{
var url = response.Address?.Href;
var source = new TextSource(response.Content);
var sheet = new CssStyleSheet(_context, source)
{
IsDisabled = false,
Href = url
};
sheet.SetParent(parent);
return(await ParseStylesheetAsync(sheet, cancel).ConfigureAwait(false));
}
}
internal CssCharsetRule(ICssStyleSheet sheet)
: base(sheet, CssRuleType.Charset)
{
_charSet = String.Empty;
}
internal CssRule(ICssStyleSheet owner, CssRuleType type)
{
_owner = owner;
_type = type;
}
internal CssStyleSheet(CssParser parser, String url, ICssStyleSheet parent)
: this(parser, url, parent?.OwnerNode)
{
_parent = parent;
}
internal CssImportRule(ICssStyleSheet owner)
: base(owner, CssRuleType.Import)
{
_media = new MediaList(owner.Context);
}
internal CssDocumentRule(ICssStyleSheet owner)
: base(owner, CssRuleType.Document)
{
_conditions = new DocumentFunctions();
}
private ICssRule CreateAtRule(ICssStyleSheet sheet, CssToken token)
{
if (token.Data.Is(RuleNames.Media))
{
var rule = new CssMediaRule(sheet);
return(CreateMedia(rule, token));
}
else if (token.Data.Is(RuleNames.FontFace))
{
var rule = new CssFontFaceRule(sheet);
return(CreateFontFace(rule, token));
}
else if (token.Data.Is(RuleNames.Keyframes))
{
var rule = new CssKeyframesRule(sheet);
return(CreateKeyframes(rule, token));
}
else if (token.Data.Is(RuleNames.Import))
{
var rule = new CssImportRule(sheet);
return(CreateImport(rule, token));
}
else if (token.Data.Is(RuleNames.Charset))
{
var rule = new CssCharsetRule(sheet);
return(CreateCharset(rule, token));
}
else if (token.Data.Is(RuleNames.Namespace))
{
var rule = new CssNamespaceRule(sheet);
return(CreateNamespace(rule, token));
}
else if (token.Data.Is(RuleNames.Page))
{
var rule = new CssPageRule(sheet);
return(CreatePage(rule, token));
}
else if (token.Data.Is(RuleNames.Supports))
{
var rule = new CssSupportsRule(sheet);
return(CreateSupports(rule, token));
}
else if (token.Data.Is(RuleNames.ViewPort))
{
var rule = new CssViewportRule(sheet);
return(CreateViewport(rule, token));
}
else if (token.Data.Is(RuleNames.Document))
{
var rule = new CssDocumentRule(sheet);
return(CreateDocument(rule, token));
}
else if (_options.IsIncludingUnknownRules)
{
return(CreateUnknownAtRule(sheet, token));
}
RaiseErrorOccurred(CssParseError.UnknownAtRule, token.Position);
JumpToRuleEnd(ref token);
return(null);
}
private ICssRule CreateStyleRule(ICssStyleSheet sheet, CssToken token)
{
var rule = new CssStyleRule(sheet);
return(CreateStyle(rule, token));
}
internal CssSupportsRule(ICssStyleSheet owner)
: base(owner, CssRuleType.Supports)
{
}
public void SetParent(ICssRule rule)
{
_parent = rule;
_owner = rule?.Owner;
}
internal void Add(CssRule value, ICssStyleSheet owner, ICssRule parent)
{
_rules.Add(value);
value.Owner = owner;
value.Parent = parent;
}
public void SetOwner(ICssStyleSheet sheet)
{
_parent = null;
_owner = sheet;
}
internal CssStyleSheet(CssParser parser, String url, ICssStyleSheet parent)
: this(parser, url, parent != null ? parent.OwnerNode : null)
{
_parent = parent;
}
internal CssGroupingRule(ICssStyleSheet owner, CssRuleType type)
: base(owner, type)
{
_rules = new CssRuleList();
}
