Prepared computation model

Author: FlorianRappl

src/AngleSharp.Css.Tests/Extensions/Nesting.cs

@@ -22,7 +22,7 @@ public void SimpleSelectorNestingImplicit()
             var element = document.QuerySelector(".bar");
             var style = window.GetComputedStyle(element);
 
-            Assert.AreEqual("1.4rem", style.GetFontSize());
+            Assert.AreEqual("22.4px", style.GetFontSize());
         }
 
         [Test]
@@ -39,7 +39,7 @@ public void SimpleSelectorNestingExplicit()
             var element = document.QuerySelector(".bar");
             var style = window.GetComputedStyle(element);
 
-            Assert.AreEqual("1.4rem", style.GetFontSize());
+            Assert.AreEqual("22.4px", style.GetFontSize());
         }
 
         [Test]
@@ -60,7 +60,7 @@ public void SimpleSelectorNestingOverwritten()
             var element = document.QuerySelector(".bar");
             var style = window.GetComputedStyle(element);
 
-            Assert.AreEqual("1.4rem", style.GetFontSize());
+            Assert.AreEqual("22.4px", style.GetFontSize());
         }
 
         [Test]

src/AngleSharp.Css/Declarations/ContentDeclaration.cs

@@ -8,6 +8,7 @@ namespace AngleSharp.Css.Declarations
     using AngleSharp.Text;
     using System;
     using System.Collections.Generic;
+    using System.Linq;
 
     static class ContentDeclaration
     {
@@ -21,7 +22,7 @@ static class ContentDeclaration
 
         sealed class ContentValueConverter : IValueConverter
         {
-            private static readonly Dictionary<String, IContentMode> ContentModes = new(StringComparer.OrdinalIgnoreCase)
+            private static readonly Dictionary<String, ContentMode> ContentModes = new(StringComparer.OrdinalIgnoreCase)
             {
                 { CssKeywords.OpenQuote, new OpenQuoteContentMode() },
                 { CssKeywords.NoOpenQuote, new NoOpenQuoteContentMode() },
@@ -117,86 +118,86 @@ public ContentValue(ICssValue[] modes)
                 }
 
                 public String CssText => _modes.Length == 0 ? CssKeywords.None : _modes.Join(" ");
+
+                public ICssValue Compute(ICssComputeContext context)
+                {
+                    var modes = _modes.Select(mode => mode.Compute(context)).ToArray();
+                    return new ContentValue(modes);
+                }
             }
 
-            private interface IContentMode : ICssValue
+            private abstract class ContentMode : ICssValue
             {
-                String Stringify(IElement element);
+                public String CssText => GetCssText();
+
+                public abstract String Stringify(IElement element);
+
+                public abstract String GetCssText();
+
+                ICssValue ICssValue.Compute(ICssComputeContext context)
+                {
+                    return this;
+                }
             }
 
             /// <summary>
             /// Computes to none for the :before and :after pseudo-elements.
             /// </summary>
-            private sealed class NormalContentMode : IContentMode
+            private sealed class NormalContentMode : ContentMode
             {
-                public String CssText => CssKeywords.Normal;
+                public override String GetCssText() => CssKeywords.Normal;
 
-                public String Stringify(IElement element)
-                {
-                    return String.Empty;
-                }
+                public override String Stringify(IElement element) => String.Empty;
             }
 
             /// <summary>
             /// The value is replaced by the open quote string from the quotes
             /// property.
             /// </summary>
-            private sealed class OpenQuoteContentMode : IContentMode
+            private sealed class OpenQuoteContentMode : ContentMode
             {
-                public String CssText => CssKeywords.OpenQuote;
+                public override String GetCssText() => CssKeywords.OpenQuote;
 
-                public String Stringify(IElement element)
-                {
-                    return String.Empty;
-                }
+                public override String Stringify(IElement element) => String.Empty;
             }
 
             /// <summary>
             /// The value is replaced by the close string from the quotes
             /// property.
             /// </summary>
-            private sealed class CloseQuoteContentMode : IContentMode
+            private sealed class CloseQuoteContentMode : ContentMode
             {
-                public String CssText => CssKeywords.CloseQuote;
+                public override String GetCssText() => CssKeywords.CloseQuote;
 
-                public String Stringify(IElement element)
-                {
-                    return String.Empty;
-                }
+                public override String Stringify(IElement element) => String.Empty;
             }
 
             /// <summary>
             /// Introduces no content, but increments the level of nesting for
             /// quotes.
             /// </summary>
-            private sealed class NoOpenQuoteContentMode : IContentMode
+            private sealed class NoOpenQuoteContentMode : ContentMode
             {
-                public String CssText => CssKeywords.NoOpenQuote;
+                public override String GetCssText() => CssKeywords.NoOpenQuote;
 
-                public String Stringify(IElement element)
-                {
-                    return String.Empty;
-                }
+                public override String Stringify(IElement element) => String.Empty;
             }
 
             /// <summary>
             /// Introduces no content, but decrements the level of nesting for
             /// quotes.
             /// </summary>
-            private sealed class NoCloseQuoteContentMode : IContentMode
+            private sealed class NoCloseQuoteContentMode : ContentMode
             {
-                public String CssText => CssKeywords.NoCloseQuote;
+                public override String GetCssText() => CssKeywords.NoCloseQuote;
 
-                public String Stringify(IElement element)
-                {
-                    return String.Empty;
-                }
+                public override String Stringify(IElement element) => String.Empty;
             }
 
             /// <summary>
             /// Text content.
             /// </summary>
-            private sealed class TextContentMode : IContentMode
+            private sealed class TextContentMode : ContentMode
             {
                 private readonly String _text;
 
@@ -205,20 +206,17 @@ public TextContentMode(String text)
                     _text = text;
                 }
 
-                public String CssText => _text.CssString();
+                public override String GetCssText() => _text.CssString();
 
-                public String Stringify(IElement element)
-                {
-                    return _text;
-                }
+                public override String Stringify(IElement element) => _text;
             }
 
             /// <summary>
             /// The generated text is the value of all counters with the given name
             /// in scope at this pseudo-element, from outermost to innermost
             /// separated by the specified string.
             /// </summary>
-            private sealed class CounterContentMode : IContentMode
+            private sealed class CounterContentMode : ContentMode
             {
                 private readonly CounterDefinition _counter;
 
@@ -227,19 +225,16 @@ public CounterContentMode(CounterDefinition counter)
                     _counter = counter;
                 }
 
-                public String CssText => _counter.CssText;
+                public override String GetCssText() => _counter.CssText;
 
-                public String Stringify(IElement element)
-                {
-                    return String.Empty;
-                }
+                public override String Stringify(IElement element) => String.Empty;
             }
 
             /// <summary>
             /// Returns the value of the element's attribute X as a string. If
             /// there is no attribute X, an empty string is returned.
             /// </summary>
-            private sealed class AttributeContentMode : IContentMode
+            private sealed class AttributeContentMode : ContentMode
             {
                 private readonly String _attribute;
 
@@ -248,20 +243,17 @@ public AttributeContentMode(String attribute)
                     _attribute = attribute;
                 }
 
-                public String CssText => FunctionNames.Attr.CssFunction(_attribute);
+                public override String GetCssText() => FunctionNames.Attr.CssFunction(_attribute);
 
-                public String Stringify(IElement element)
-                {
-                    return element.GetAttribute(_attribute) ?? String.Empty;
-                }
+                public override String Stringify(IElement element) => element.GetAttribute(_attribute) ?? String.Empty;
             }
 
             /// <summary>
             /// The value is a URI that designates an external resource (such as an
             /// image). If the resource or image can't be displayed, it is either
             /// ignored or some placeholder shows up.
             /// </summary>
-            private sealed class UrlContentMode : IContentMode
+            private sealed class UrlContentMode : ContentMode
             {
                 private readonly CssUrlValue _url;
 
@@ -270,12 +262,9 @@ public UrlContentMode(CssUrlValue url)
                     _url = url;
                 }
 
-                public String CssText => _url.CssText;
+                public override String GetCssText() => _url.CssText;
 
-                public String Stringify(IElement element)
-                {
-                    return String.Empty;
-                }
+                public override String Stringify(IElement element) => String.Empty;
             }
         }
     }

src/AngleSharp.Css/Dom/ICssProperty.cs

@@ -1,6 +1,7 @@
 namespace AngleSharp.Css.Dom
 {
     using AngleSharp.Attributes;
+    using AngleSharp.Css.Values;
     using System;
 
     /// <summary>
@@ -61,8 +62,8 @@ public interface ICssProperty : IStyleFormattable
         /// <summary>
         /// Creates a computed version of the property.
         /// </summary>
-        /// <param name="device">The device to compute for.</param>
+        /// <param name="context">The context to compute for.</param>
         /// <returns>The computed version of the property if uncomputed, otherwise the same.</returns>
-        ICssProperty Compute(IRenderDevice device);
+        ICssProperty Compute(ICssComputeContext context);
     }
 }

src/AngleSharp.Css/Dom/ICssValue.cs

@@ -1,6 +1,7 @@
 namespace AngleSharp.Css.Dom
 {
     using System;
+    using AngleSharp.Css.Values;
 
     /// <summary>
     /// Represents a value of a CSS property.
@@ -11,5 +12,12 @@ public interface ICssValue
         /// The text representation of the value.
         /// </summary>
         String CssText { get; }
+
+        /// <summary>
+        /// Computes the current value using the given context.
+        /// </summary>
+        /// <param name="context">The used compute context.</param>
+        /// <returns>The computed value or the original value, if already computed.</returns>
+        ICssValue Compute(ICssComputeContext context);
     }
 }

src/AngleSharp.Css/Dom/Internal/CssProperty.cs

@@ -89,13 +89,13 @@ public Boolean IsImportant
 
         #region Methods
 
-        public ICssProperty Compute(IRenderDevice device)
+        public ICssProperty Compute(ICssComputeContext context)
         {
-            if (_value is Length length && length.Type != Length.Unit.Px)
+            var computedValue = _value?.Compute(context);
+
+            if (computedValue != _value)
             {
-                var px = length.ToPixel(device);
-                var value = new Length(px, Length.Unit.Px);
-                return new CssProperty(_name, _converter, _flags, value, _important);
+                return new CssProperty(_name, _converter, _flags, computedValue, _important);
             }
 
             return this;

src/AngleSharp.Css/Dom/Internal/CssStyleDeclaration.cs

@@ -32,11 +32,6 @@ sealed class CssStyleDeclaration : ICssStyleDeclaration
 
         #region ctor
 
-        public CssStyleDeclaration()
-            : this(default(IBrowsingContext))
-        {            
-        }
-
         public CssStyleDeclaration(IBrowsingContext context)
         {
             _declarations = new List<ICssProperty>();

src/AngleSharp.Css/Extensions/CssOmExtensions.cs

@@ -1,6 +1,7 @@
 namespace AngleSharp.Css.Dom
 {
     using AngleSharp.Css.Parser;
+    using AngleSharp.Css.Values;
     using AngleSharp.Text;
     using System;
     using System.Linq;
@@ -66,18 +67,18 @@ public static ICssValue GetValueOf(this ICssStyleRule rule, String propertyName)
         }
 
         /// <summary>
-        /// Computes the values with knowledge of the device.
+        /// Computes the declarations using the given compute context.
         /// </summary>
         /// <param name="style">The base (raw) style.</param>
-        /// <param name="device">The device to use for the calculation.</param>
+        /// <param name="context">The context to use for the calculation.</param>
         /// <returns>A new style declaration with the existing or computed values.</returns>
-        public static ICssStyleDeclaration Compute(this ICssStyleDeclaration style, IRenderDevice device)
+        public static ICssStyleDeclaration Compute(this ICssStyleDeclaration style, ICssComputeContext context)
         {
-            var computedStyle = new CssStyleDeclaration();
+            var computedStyle = new CssStyleDeclaration(context.Context);
 
             foreach (var property in style)
             {
-                computedStyle.AddProperty(property.Compute(device));
+                computedStyle.AddProperty(property.Compute(context));
             }
 
             return computedStyle;