/// <summary> /// Takes a string and transforms it into CSS declarations. /// </summary> /// <param name="declarations">The string to parse.</param> /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param> /// <returns>The CSSStyleDeclaration object.</returns> public static CSSStyleDeclaration ParseDeclarations(String declarations, Boolean quirksMode = false) { var decl = new CSSStyleDeclaration(); AppendDeclarations(decl, declarations, quirksMode); return(decl); }
/// <summary> /// Extends the given bag with the set properties of the specified /// styling declaration. /// </summary> /// <param name="bag">The bag to modify.</param> /// <param name="styling">The styling properties to use.</param> /// <param name="priority">Sets the priority of the new properties.</param> public static void ExtendWith(this CssPropertyBag bag, CSSStyleDeclaration styling, Priority priority) { foreach (var property in styling.Declarations) { bag.TryUpdate(property, priority); } }
internal CSSOutlineProperty(CSSStyleDeclaration rule) : base(PropertyNames.Outline, rule, PropertyFlags.Animatable) { _style = Get <CSSOutlineStyleProperty>(); _width = Get <CSSOutlineWidthProperty>(); _color = Get <CSSOutlineColorProperty>(); }
/// <summary> /// CSSStyleDeclaration == CSSDeclarationBlock /// Merge two declaration blocks into one. /// </summary> /// <param name="styleDeclaration"></param> public void merge(CSSStyleDeclaration styleDeclaration) { for (int i = 0; i < styleDeclaration.item.Count(); i++) { updateDeclaration(styleDeclaration.item[i]); } }
internal CSSListStyleProperty(CSSStyleDeclaration rule) : base(PropertyNames.ListStyle, rule, PropertyFlags.Inherited) { _type = Get <CSSListStyleTypeProperty>(); _image = Get <CSSListStyleImageProperty>(); _position = Get <CSSListStylePositionProperty>(); }
internal CSSBorderRightProperty(CSSStyleDeclaration rule) : base(PropertyNames.BorderRight, rule, PropertyFlags.Animatable) { _color = Get <CSSBorderRightColorProperty>(); _style = Get <CSSBorderRightStyleProperty>(); _width = Get <CSSBorderRightWidthProperty>(); }
internal CSSBorderBottomProperty(CSSStyleDeclaration rule) : base(PropertyNames.BorderBottom, rule, PropertyFlags.Animatable) { _color = Get <CSSBorderBottomColorProperty>(); _style = Get <CSSBorderBottomStyleProperty>(); _width = Get <CSSBorderBottomWidthProperty>(); }
public static string serializeDeclarationBlock(CSSStyleDeclaration styleDeclaration) { string cssText = string.Empty; bool first = true; foreach (var item in styleDeclaration.item) { string declarationText = null; if (first) { declarationText = item.propertyname + ": " + item.value; first = false; } else { declarationText = "\r\n" + item.propertyname + ": " + item.value; } if (item.important) { declarationText = declarationText + " !important"; } declarationText = declarationText + ";"; cssText += declarationText; } return(cssText); }
private static CSSRule ParseFontFace(AtRule rule, ref string OriginalCss) { CSSFontFaceRule fontrule = new CSSFontFaceRule(); int startindex = 0; int endindex = 0; int endselectindex = -1; foreach (var item in rule.prelude) { if (startindex == 0) { startindex = item.startindex; } if (item.endindex > endselectindex) { endselectindex = item.endindex; } } CSSStyleDeclaration style = ParseDeclarations(rule.block, ref endindex, ref OriginalCss); fontrule.style = style; fontrule.StartIndex = startindex; fontrule.EndIndex = endindex; fontrule.EndSelectorIndex = endselectindex - fontrule.StartIndex + 1; return(fontrule); }
internal CSSTextDecorationProperty(CSSStyleDeclaration rule) : base(PropertyNames.TextDecoration, rule, PropertyFlags.Animatable) { _color = Get <CSSTextDecorationColorProperty>(); _line = Get <CSSTextDecorationLineProperty>(); _style = Get <CSSTextDecorationStyleProperty>(); }
public void CSSStyleDeclarationEmpty() { var css = new CSSStyleDeclaration(); Assert.AreEqual("", css.CssText); Assert.AreEqual(0, css.Length); }
void Populate(CSSStyleDeclaration declarations) { foreach (var declaration in declarations) { children.Add(new CssRuleViewModel(declaration)); } }
public CSSStyleDeclaration GetStyleDiff(CSSStyleDeclaration style1, CSSStyleDeclaration style2) { var type1 = style1.GetType(); var type2 = style2.GetType(); var fields1 = type1.GetProperties().ToDictionary(x => x.Name, x => x.GetValue(style1)); var fields2 = type2.GetProperties().ToDictionary(x => x.Name, x => x.GetValue(style2)); var resultStyle = style2.Clone() as CSSStyleDeclaration; foreach (var keyValuePair in fields1) { var fieldName = keyValuePair.Key; var fieldValue1 = keyValuePair.Value; var fieldValue2 = fields2[fieldName]; var jt1 = JsonConvert.SerializeObject(fieldValue1); var jt2 = JsonConvert.SerializeObject(fieldValue2); if (jt1 != jt2) { resultStyle.GetType().GetProperty(fieldName).SetValue(resultStyle, fieldValue2); } } return(resultStyle); }
internal CSSColumnRuleProperty(CSSStyleDeclaration rule) : base(PropertyNames.ColumnRule, rule, PropertyFlags.Animatable) { _color = Get <CSSColumnRuleColorProperty>(); _style = Get <CSSColumnRuleStyleProperty>(); _width = Get <CSSColumnRuleWidthProperty>(); }
public void CSSStyleDeclarationUnbound() { var css = new CSSStyleDeclaration(); var text = "background: red; color: black"; css.CssText = text; Assert.AreEqual(text, css.CssText); Assert.AreEqual(2, css.Length); }
internal CSSBorderColorProperty(CSSStyleDeclaration rule) : base(PropertyNames.BorderColor, rule, PropertyFlags.Hashless | PropertyFlags.Animatable) { _top = Get <CSSBorderTopColorProperty>(); _right = Get <CSSBorderRightColorProperty>(); _bottom = Get <CSSBorderBottomColorProperty>(); _left = Get <CSSBorderLeftColorProperty>(); }
internal CSSMarginProperty(CSSStyleDeclaration rule) : base(PropertyNames.Margin, rule) { _top = Get <CSSMarginTopProperty>(); _right = Get <CSSMarginRightProperty>(); _bottom = Get <CSSMarginBottomProperty>(); _left = Get <CSSMarginLeftProperty>(); }
internal CSSBorderStyleProperty(CSSStyleDeclaration rule) : base(PropertyNames.BorderStyle, rule) { _top = Get <CSSBorderTopStyleProperty>(); _right = Get <CSSBorderRightStyleProperty>(); _bottom = Get <CSSBorderBottomStyleProperty>(); _left = Get <CSSBorderLeftStyleProperty>(); }
internal CSSBorderRadiusProperty(CSSStyleDeclaration rule) : base(PropertyNames.BorderRadius, rule, PropertyFlags.Animatable) { _topLeft = Get <CSSBorderTopLeftRadiusProperty>(); _topRight = Get <CSSBorderTopRightRadiusProperty>(); _bottomRight = Get <CSSBorderBottomRightRadiusProperty>(); _bottomLeft = Get <CSSBorderBottomLeftRadiusProperty>(); }
internal CSSPaddingProperty(CSSStyleDeclaration rule) : base(PropertyNames.Padding, rule) { _top = Get <CSSPaddingTopProperty>(); _right = Get <CSSPaddingRightProperty>(); _bottom = Get <CSSPaddingBottomProperty>(); _left = Get <CSSPaddingLeftProperty>(); }
internal CSSTransitionProperty(CSSStyleDeclaration rule) : base(PropertyNames.Transition, rule) { _delay = Get <CSSTransitionDelayProperty>(); _duration = Get <CSSTransitionDurationProperty>(); _timingFunction = Get <CSSTransitionTimingFunctionProperty>(); _property = Get <CSSTransitionPropertyProperty>(); }
internal CSSBorderWidthProperty(CSSStyleDeclaration rule) : base(PropertyNames.BorderWidth, rule, PropertyFlags.Animatable) { _top = Get <CSSBorderTopWidthProperty>(); _right = Get <CSSBorderRightWidthProperty>(); _bottom = Get <CSSBorderBottomWidthProperty>(); _left = Get <CSSBorderLeftWidthProperty>(); }
public static Dictionary <string, CssFieldRef> ExtractAllFields(this CSSStyleDeclaration cssStyleDeclaration) { var fields = new Dictionary <string, CssFieldRef>(); var type = cssStyleDeclaration.GetType(); ExtractAllFields(type, fields); return(fields); }
internal CSSBorderImageProperty(CSSStyleDeclaration rule) : base(PropertyNames.BorderImage, rule) { _outset = Get <CSSBorderImageOutsetProperty>(); _repeat = Get <CSSBorderImageRepeatProperty>(); _slice = Get <CSSBorderImageSliceProperty>(); _source = Get <CSSBorderImageSourceProperty>(); _width = Get <CSSBorderImageWidthProperty>(); }
/// <summary> /// Sanitizes the style. /// </summary> /// <param name="styles">The styles.</param> /// <param name="baseUrl">The base URL.</param> protected void SanitizeStyle(CSSStyleDeclaration styles, string baseUrl) { if (styles == null || !styles.Any()) { return; } var removeStyles = new List <KeyValuePair <string, string> >(); var setStyles = new Dictionary <string, string>(); foreach (var style in styles) { var key = DecodeCss(style.Key); var val = DecodeCss(style.Value); if (!AllowedCssProperties.Contains(key) || CssExpression.IsMatch(val) || DisallowCssPropertyValue.IsMatch(val)) { removeStyles.Add(style); } else { var urls = CssUrl.Matches(val); if (urls.Count > 0) { if (urls.Cast <Match>().Any(m => GetSafeUri(m.Groups[2].Value) == null || SanitizeUrl(m.Groups[2].Value, baseUrl) == null)) { removeStyles.Add(style); } else { var s = CssUrl.Replace(val, m => "url(" + m.Groups[1].Value + SanitizeUrl(m.Groups[2].Value, baseUrl) + m.Groups[3].Value); if (s != val) { if (key != style.Key) { removeStyles.Add(style); } setStyles[key] = s; } } } } } foreach (var style in removeStyles) { RemoveStyle(styles, style); } foreach (var kvp in setStyles) { styles.SetStyle(kvp.Key, kvp.Value); } }
/// <summary> /// Creates a new shorthand property. /// </summary> /// <param name="name">The name of the property.</param> /// <param name="style">The given style set.</param> /// <returns>The created shorthand property.</returns> public static CSSShorthandProperty CreateShorthand(String name, CSSStyleDeclaration style) { ShorthandCreator shorthand; if (shorthands.TryGetValue(name, out shorthand)) { return(shorthand(style)); } return(null); }
CSSProperty IPropertyCreator.Create(String name, CSSStyleDeclaration style) { Func <CSSStyleDeclaration, CSSProperty> creator; if (_creators.TryGetValue(name, out creator)) { return(creator(style)); } return(null); }
internal CSSFontProperty(CSSStyleDeclaration rule) : base(PropertyNames.Font, rule, PropertyFlags.Inherited | PropertyFlags.Animatable) { _style = Get <CSSFontStyleProperty>(); _variant = Get <CSSFontVariantProperty>(); _weight = Get <CSSFontWeightProperty>(); _stretch = Get <CSSFontStretchProperty>(); _size = Get <CSSFontSizeProperty>(); _height = Get <CSSLineHeightProperty>(); _families = Get <CSSFontFamilyProperty>(); }
/// <summary> /// Creates a new longhand property. /// </summary> /// <param name="name">The name of the property.</param> /// <param name="style">The given style set.</param> /// <returns>The created longhand property.</returns> public static CSSProperty CreateLonghand(String name, CSSStyleDeclaration style) { LonghandCreator longhand; var property = style.GetProperty(name); if (property == null && longhands.TryGetValue(name, out longhand)) { property = longhand(style); } return(property); }
/// <summary> /// Takes a string and transforms it into CSS declarations. /// </summary> /// <param name="declarations">The string to parse.</param> /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param> /// <returns>The CSSStyleDeclaration object.</returns> public static CSSStyleDeclaration ParseDeclarations(String declarations, Boolean quirksMode = false) { var parser = new CssParser(declarations); parser.IsQuirksMode = quirksMode; parser.ignore = false; var it = parser.tokenizer.Iterator; var decl = new CSSStyleDeclaration(); parser.AppendDeclarations(it, decl.List); return(decl); }
/// <summary> /// Sanitizes the style. /// </summary> /// <param name="styles">The styles.</param> /// <param name="baseUrl">The base URL.</param> protected void SanitizeStyle(CSSStyleDeclaration styles, string baseUrl) { if (styles == null || !styles.Any()) return; var removeStyles = new List<KeyValuePair<string, string>>(); var setStyles = new Dictionary<string, string>(); foreach (var style in styles) { var key = DecodeCss(style.Key); var val = DecodeCss(style.Value); if (!AllowedCssProperties.Contains(key) || CssExpression.IsMatch(val) || DisallowCssPropertyValue.IsMatch(val)) removeStyles.Add(style); else { var urls = CssUrl.Matches(val); if (urls.Count > 0) { if (urls.Cast<Match>().Any(m => GetSafeUri(m.Groups[1].Value) == null || SanitizeUrl(m.Groups[1].Value, baseUrl) == null)) removeStyles.Add(style); else { var s = CssUrl.Replace(val, m => "url(" + SanitizeUrl(m.Groups[1].Value, baseUrl)); if (s != val) { if (key != style.Key) removeStyles.Add(style); setStyles[key] = s; } } } } } foreach (var style in removeStyles) { RemoveStyle(styles, style); } foreach (var kvp in setStyles) { styles.SetStyle(kvp.Key, kvp.Value); } }
/// <summary> /// Creates a new property. /// </summary> /// <param name="name">The name of the property.</param> /// <param name="style">The given style set.</param> /// <returns>The created property</returns> public static CSSProperty Create(String name, CSSStyleDeclaration style) { Func<CSSProperty> propertyCreator; var property = style != null ? style.Get(name) : null; if (property == null && properties.TryGetValue(name, out propertyCreator)) { property = propertyCreator(); property.Rule = style; } return property; }
void Populate(CSSStyleDeclaration declarations) { foreach (var declaration in declarations) children.Add(new CssRuleViewModel(declaration)); }
/// <summary> /// Creates a new CSS style rule. /// </summary> internal CSSStyleRule() { _type = CssRule.Style; _style = new CSSStyleDeclaration(); }
/// <summary> /// Creates a new @font-face rule. /// </summary> internal CSSFontFaceRule() { style = new CSSStyleDeclaration(); _type = CssRule.FontFace; }
/// <summary> /// Creates a new @keyframe rule. /// </summary> internal CSSKeyframeRule() { _style = new CSSStyleDeclaration(); }
/// <summary> /// Creates a new CSS style rule with the given declaration. /// </summary> /// <param name="style">The declaration to use.</param> internal CSSStyleRule(CSSStyleDeclaration style) { _type = CssRuleType.Style; _style = style; }
/// <summary> /// Creates a new @page rule. /// </summary> internal CSSPageRule() { _style = new CSSStyleDeclaration(); _type = CssRuleType.Page; }
/// <summary> /// Creates a new @font-face rule. /// </summary> internal CSSFontFaceRule() { _cssRules = new CSSStyleDeclaration(); _type = CssRuleType.FontFace; }
/// <summary> /// Takes a string and transforms it into CSS declarations. /// </summary> /// <param name="declarations">The string to parse.</param> /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param> /// <returns>The CSSStyleDeclaration object.</returns> public static CSSStyleDeclaration ParseDeclarations(String declarations, Boolean quirksMode = false) { var parser = new CssParser(declarations); parser.IsQuirksMode = quirksMode; parser.ignore = false; var it = parser.tokenizer.Iterator; var decl = new CSSStyleDeclaration(); parser.AppendDeclarations(it, decl.List); return decl; }