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; }
/// <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 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; }
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(); }