Added actual logic and docs

The-Nutty · The-Nutty · commit 496593befa42 · 2020-04-02T17:48:57.000+01:00
diff --git a/src/AngleSharp.Css/DefaultRenderDevice.cs b/src/AngleSharp.Css/DefaultRenderDevice.cs
@@ -91,9 +91,17 @@ public Int32 ViewPortWidth
             set;
         } = 0;
 
-        //todo
-        public int RenderWidth { get; set; }
-        public int RenderHeight { get; set; }
-        public double FontSize { get; set; }
+        /// <inheritdoc />
+        public Double RenderWidth => ViewPortWidth;
+
+        /// <inheritdoc />
+        public Double RenderHeight => ViewPortHeight;
+
+        /// <inheritdoc />
+        public double FontSize
+        {
+            get;
+            set;
+        } = 16;
     }
-}
+}
diff --git a/src/AngleSharp.Css/Extensions/CssValueExtensions.cs b/src/AngleSharp.Css/Extensions/CssValueExtensions.cs
@@ -40,20 +40,22 @@ public static Double AsDouble(this ICssValue value)
         /// Tries to convert the value to a number of pixels.
         /// </summary>
         /// <param name="value">The value to convert.</param>
+        /// <param name="renderDimensions">the render device used to calculate relative units, can be null if units are absolute.</param>
+        /// <param name="isWidth">If a relative unit is being calculated, true signifies that that unit is width, false height.</param>
         /// <returns>The resulting number.</returns>
-        public static Double AsPx(this ICssValue value, IRenderDimensions renderDimensions)
+        public static Double AsPx(this ICssValue value, IRenderDimensions renderDimensions, Boolean isWidth = true)
         {
             if (value is Length length && length.Type != Length.Unit.None)
             {
-                return length.ToPixel(renderDimensions);
+                return length.ToPixel(renderDimensions, isWidth);
             }
             else if (value is ICssMultipleValue multiple && multiple.Count == 1)
             {
-                return multiple[0].AsPx(renderDimensions);
+                return multiple[0].AsPx(renderDimensions, isWidth);
             }
             else if (value is ICssSpecialValue special && special.Value != null)
             {
-                return special.Value.AsPx(renderDimensions);
+                return special.Value.AsPx(renderDimensions, isWidth);
             }
 
             return 0.0;
@@ -201,20 +203,21 @@ public static String AsUrl(this ICssValue value)
         /// Tries to convert the value to a transformation matrix.
         /// </summary>
         /// <param name="value">The value to convert.</param>
+        /// <param name="renderDimensions">the render device used to calculate relative units, can be null if units are absolute.</param>
         /// <returns>The resulting matrix.</returns>
-        public static TransformMatrix AsMatrix(this ICssValue value, IRenderDimensions dimensions)
+        public static TransformMatrix AsMatrix(this ICssValue value, IRenderDimensions renderDimensions)
         {
             if (value is ICssTransformFunctionValue res)
             {
-                return res.ComputeMatrix(dimensions);
+                return res.ComputeMatrix(renderDimensions);
             }
             else if (value is ICssMultipleValue multiple && multiple.Count == 1)
             {
-                return multiple[0].AsMatrix(dimensions);
+                return multiple[0].AsMatrix(renderDimensions);
             }
             else if (value is ICssSpecialValue special && special.Value != null)
             {
-                return special.Value.AsMatrix(dimensions);
+                return special.Value.AsMatrix(renderDimensions);
             }
 
             return null;
diff --git a/src/AngleSharp.Css/FeatureValidators/AspectRatioFeatureValidator.cs b/src/AngleSharp.Css/FeatureValidators/AspectRatioFeatureValidator.cs
@@ -7,14 +7,14 @@ namespace AngleSharp.Css.FeatureValidators
 
     sealed class AspectRatioFeatureValidator : IFeatureValidator
     {
-        public Boolean Validate(IMediaFeature feature, IRenderDevice device)
+        public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)
         {
             var ratio = RatioConverter.Convert(feature.Value);
 
             if (ratio != null)
             {
                 var desired = ratio.AsDouble();
-                var available = device.ViewPortWidth / (Double)device.ViewPortHeight;
+                var available = renderDevice.ViewPortWidth / (Double)renderDevice.ViewPortHeight;
 
                 if (feature.IsMaximum)
                 {
diff --git a/src/AngleSharp.Css/FeatureValidators/ColorFeatureValidator.cs b/src/AngleSharp.Css/FeatureValidators/ColorFeatureValidator.cs
@@ -8,7 +8,7 @@ namespace AngleSharp.Css.FeatureValidators
 
     sealed class ColorFeatureValidator : IFeatureValidator
     {
-        public Boolean Validate(IMediaFeature feature, IRenderDevice device)
+        public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)
         {
             var defaultValue = new Length(1.0, Length.Unit.None);
             var converter = feature.IsMinimum || feature.IsMaximum ? PositiveIntegerConverter : PositiveIntegerConverter.Option(defaultValue);
@@ -17,7 +17,7 @@ public Boolean Validate(IMediaFeature feature, IRenderDevice device)
             if (color != null)
             {
                 var desired = color.AsInt32();
-                var available = Math.Pow(device.ColorBits, 2);
+                var available = Math.Pow(renderDevice.ColorBits, 2);
 
                 if (feature.IsMaximum)
                 {
diff --git a/src/AngleSharp.Css/FeatureValidators/ColorIndexFeatureValidator.cs b/src/AngleSharp.Css/FeatureValidators/ColorIndexFeatureValidator.cs
@@ -8,7 +8,7 @@ namespace AngleSharp.Css.FeatureValidators
 
     sealed class ColorIndexFeatureValidator : IFeatureValidator
     {
-        public Boolean Validate(IMediaFeature feature, IRenderDevice device)
+        public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)
         {
             var defaultValue = new Length(1.0, Length.Unit.None);
             var converter = feature.IsMinimum || feature.IsMaximum ? NaturalIntegerConverter : NaturalIntegerConverter.Option(defaultValue);
@@ -17,7 +17,7 @@ public Boolean Validate(IMediaFeature feature, IRenderDevice device)
             if (index != null)
             {
                 var desired = index.AsInt32();
-                var available = device.ColorBits;
+                var available = renderDevice.ColorBits;
 
                 if (feature.IsMaximum)
                 {
diff --git a/src/AngleSharp.Css/FeatureValidators/DeviceAspectRatioFeatureValidator.cs b/src/AngleSharp.Css/FeatureValidators/DeviceAspectRatioFeatureValidator.cs
@@ -7,14 +7,14 @@ namespace AngleSharp.Css.FeatureValidators
 
     sealed class DeviceAspectRatioFeatureValidator : IFeatureValidator
     {
-        public Boolean Validate(IMediaFeature feature, IRenderDevice device)
+        public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)
         {
             var ratio = RatioConverter.Convert(feature.Value);
 
             if (ratio != null)
             {
                 var desired = ratio.AsDouble();
-                var available = device.DeviceWidth / (Double)device.DeviceHeight;
+                var available = renderDevice.DeviceWidth / (Double)renderDevice.DeviceHeight;
 
                 if (feature.IsMaximum)
                 {
diff --git a/src/AngleSharp.Css/FeatureValidators/DeviceHeightFeatureValidator.cs b/src/AngleSharp.Css/FeatureValidators/DeviceHeightFeatureValidator.cs
@@ -7,14 +7,14 @@ namespace AngleSharp.Css.FeatureValidators
 
     sealed class DeviceHeightFeatureValidator : IFeatureValidator
     {
-        public Boolean Validate(IMediaFeature feature, IRenderDevice device)
+        public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)
         {
             var length = LengthConverter.Convert(feature.Value);
 
             if (length != null)
             {
-                var desired = length.AsPx(device);
-                var available = (Double)device.DeviceHeight;
+                var desired = length.AsPx(renderDevice, false);
+                var available = (Double)renderDevice.DeviceHeight;
 
                 if (feature.IsMaximum)
                 {
diff --git a/src/AngleSharp.Css/FeatureValidators/DevicePixelRatioFeatureValidator.cs b/src/AngleSharp.Css/FeatureValidators/DevicePixelRatioFeatureValidator.cs
@@ -7,14 +7,14 @@ namespace AngleSharp.Css.FeatureValidators
 
     sealed class DevicePixelRatioFeatureValidator : IFeatureValidator
     {
-        public Boolean Validate(IMediaFeature feature, IRenderDevice device)
+        public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)
         {
             var value = NaturalNumberConverter.Convert(feature.Value);
 
             if (value != null)
             {
                 var desired = value.AsDouble();
-                var available = device.Resolution / 96f;
+                var available = renderDevice.Resolution / 96f;
 
                 if (feature.IsMaximum)
                 {
diff --git a/src/AngleSharp.Css/FeatureValidators/DeviceWidthFeatureValidator.cs b/src/AngleSharp.Css/FeatureValidators/DeviceWidthFeatureValidator.cs
@@ -7,14 +7,14 @@ namespace AngleSharp.Css.FeatureValidators
 
     sealed class DeviceWidthFeatureValidator : IFeatureValidator
     {
-        public Boolean Validate(IMediaFeature feature, IRenderDevice device)
+        public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)
         {
             var length = LengthConverter.Convert(feature.Value);
 
             if (length != null)
             {
-                var desired = length.AsPx(device);
-                var available = (Double)device.DeviceWidth;
+                var desired = length.AsPx(renderDevice, true);
+                var available = (Double)renderDevice.DeviceWidth;
 
                 if (feature.IsMaximum)
                 {
diff --git a/src/AngleSharp.Css/FeatureValidators/GridFeatureValidator.cs b/src/AngleSharp.Css/FeatureValidators/GridFeatureValidator.cs
@@ -7,14 +7,14 @@ namespace AngleSharp.Css.FeatureValidators
 
     sealed class GridFeatureValidator : IFeatureValidator
     {
-        public Boolean Validate(IMediaFeature feature, IRenderDevice device)
+        public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)
         {
             var grid = BinaryConverter.Convert(feature.Value);
 
             if (grid != null)
             {
                 var desired = grid.AsBoolean();
-                var available = device.IsGrid;
+                var available = renderDevice.IsGrid;
                 return desired == available;
             }
 
diff --git a/src/AngleSharp.Css/FeatureValidators/HeightFeatureValidator.cs b/src/AngleSharp.Css/FeatureValidators/HeightFeatureValidator.cs
@@ -7,14 +7,14 @@ namespace AngleSharp.Css.FeatureValidators
 
     sealed class HeightFeatureValidator : IFeatureValidator
     {
-        public Boolean Validate(IMediaFeature feature, IRenderDevice device)
+        public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)
         {
             var length = LengthConverter.Convert(feature.Value);
 
             if (length != null)
             {
-                var desired = length.AsPx(device);
-                var available = (Double)device.ViewPortHeight;
+                var desired = length.AsPx(renderDevice, false);
+                var available = (Double)renderDevice.ViewPortHeight;
 
                 if (feature.IsMaximum)
                 {
diff --git a/src/AngleSharp.Css/FeatureValidators/HoverFeatureValidator.cs b/src/AngleSharp.Css/FeatureValidators/HoverFeatureValidator.cs
@@ -7,7 +7,7 @@ namespace AngleSharp.Css.FeatureValidators
 
     sealed class HoverFeatureValidator : IFeatureValidator
     {
-        public Boolean Validate(IMediaFeature feature, IRenderDevice device)
+        public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)
         {
             var hover = HoverAbilityConverter.Convert(feature.Value);
 
diff --git a/src/AngleSharp.Css/FeatureValidators/MonochromeFeatureValidator.cs b/src/AngleSharp.Css/FeatureValidators/MonochromeFeatureValidator.cs
@@ -8,7 +8,7 @@ namespace AngleSharp.Css.FeatureValidators
 
     sealed class MonochromeFeatureValidator : IFeatureValidator
     {
-        public Boolean Validate(IMediaFeature feature, IRenderDevice device)
+        public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)
         {
             var defaultValue = new Length(1.0, Length.Unit.None);
             var converter = feature.IsMinimum || feature.IsMaximum ? NaturalIntegerConverter : NaturalIntegerConverter.Option(defaultValue);
@@ -17,7 +17,7 @@ public Boolean Validate(IMediaFeature feature, IRenderDevice device)
             if (index != null)
             {
                 var desired = index.AsInt32();
-                var available = device.MonochromeBits;
+                var available = renderDevice.MonochromeBits;
 
                 if (feature.IsMaximum)
                 {
diff --git a/src/AngleSharp.Css/FeatureValidators/OrientationFeatureValidator.cs b/src/AngleSharp.Css/FeatureValidators/OrientationFeatureValidator.cs
@@ -7,14 +7,14 @@ namespace AngleSharp.Css.FeatureValidators
 
     sealed class OrientationFeatureValidator : IFeatureValidator
     {
-        public Boolean Validate(IMediaFeature feature, IRenderDevice device)
+        public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)
         {
             var portrait = OrientationModeConverter.Convert(feature.Value);
 
             if (portrait != null)
             {
                 var desired = portrait.Is(CssKeywords.Portrait);
-                var available = device.DeviceHeight >= device.DeviceWidth;
+                var available = renderDevice.DeviceHeight >= renderDevice.DeviceWidth;
                 return desired == available;
             }
 
diff --git a/src/AngleSharp.Css/FeatureValidators/PointerFeatureValidator.cs b/src/AngleSharp.Css/FeatureValidators/PointerFeatureValidator.cs
@@ -7,7 +7,7 @@ namespace AngleSharp.Css.FeatureValidators
 
     sealed class PointerFeatureValidator : IFeatureValidator
     {
-        public Boolean Validate(IMediaFeature feature, IRenderDevice device)
+        public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)
         {
             var accuracy = PointerAccuracyConverter.Convert(feature.Value);
 
diff --git a/src/AngleSharp.Css/FeatureValidators/ResolutionFeatureValidator.cs b/src/AngleSharp.Css/FeatureValidators/ResolutionFeatureValidator.cs
@@ -7,14 +7,14 @@ namespace AngleSharp.Css.FeatureValidators
 
     sealed class ResolutionFeatureValidator : IFeatureValidator
     {
-        public Boolean Validate(IMediaFeature feature, IRenderDevice device)
+        public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)
         {
             var res = ResolutionConverter.Convert(feature.Value);
 
             if (res != null)
             {
                 var desired = res.AsInt32();
-                var available = device.Resolution;
+                var available = renderDevice.Resolution;
 
                 if (feature.IsMaximum)
                 {
diff --git a/src/AngleSharp.Css/FeatureValidators/ScanFeatureValidator.cs b/src/AngleSharp.Css/FeatureValidators/ScanFeatureValidator.cs
@@ -7,14 +7,14 @@ namespace AngleSharp.Css.FeatureValidators
 
     sealed class ScanFeatureValidator : IFeatureValidator
     {
-        public Boolean Validate(IMediaFeature feature, IRenderDevice device)
+        public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)
         {
             var interlace = ScanModeConverter.Convert(feature.Value);
 
             if (interlace != null)
             {
                 var desired = interlace.Is(CssKeywords.Interlace);
-                var available = device.IsInterlaced;
+                var available = renderDevice.IsInterlaced;
                 return desired == available;
             }
 
diff --git a/src/AngleSharp.Css/FeatureValidators/ScriptingFeatureValidator.cs b/src/AngleSharp.Css/FeatureValidators/ScriptingFeatureValidator.cs
@@ -7,7 +7,7 @@ namespace AngleSharp.Css.FeatureValidators
 
     sealed class ScriptingFeatureValidator : IFeatureValidator
     {
-        public Boolean Validate(IMediaFeature feature, IRenderDevice device)
+        public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)
         {
             var state = ScriptingStateConverter.Convert(feature.Value);
 
@@ -16,9 +16,9 @@ public Boolean Validate(IMediaFeature feature, IRenderDevice device)
                 var available = ScriptingState.None;
                 var desired = state.AsEnum<ScriptingState>();
 
-                if (device.IsScripting)
+                if (renderDevice.IsScripting)
                 {
-                    available = device.Category == DeviceCategory.Screen ? ScriptingState.Enabled : ScriptingState.InitialOnly;
+                    available = renderDevice.Category == DeviceCategory.Screen ? ScriptingState.Enabled : ScriptingState.InitialOnly;
                 }
 
                 return desired == available;
diff --git a/src/AngleSharp.Css/FeatureValidators/UnknownFeatureValidator.cs b/src/AngleSharp.Css/FeatureValidators/UnknownFeatureValidator.cs
@@ -5,7 +5,7 @@ namespace AngleSharp.Css.FeatureValidators
 
     sealed class UnknownFeatureValidator : IFeatureValidator
     {
-        public Boolean Validate(IMediaFeature feature, IRenderDevice device)
+        public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)
         {
             return true;
         }
diff --git a/src/AngleSharp.Css/FeatureValidators/UpdateFrequencyFeatureValidator.cs b/src/AngleSharp.Css/FeatureValidators/UpdateFrequencyFeatureValidator.cs
@@ -7,14 +7,14 @@ namespace AngleSharp.Css.FeatureValidators
 
     sealed class UpdateFrequencyFeatureValidator : IFeatureValidator
     {
-        public Boolean Validate(IMediaFeature feature, IRenderDevice device)
+        public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)
         {
             var frequency = UpdateFrequencyConverter.Convert(feature.Value);
 
             if (frequency != null)
             {
                 var desired = frequency.AsEnum<UpdateFrequency>();
-                var available = device.Frequency;
+                var available = renderDevice.Frequency;
 
                 if (available >= 30)
                 {
diff --git a/src/AngleSharp.Css/FeatureValidators/WidthFeatureValidator.cs b/src/AngleSharp.Css/FeatureValidators/WidthFeatureValidator.cs
@@ -7,14 +7,14 @@ namespace AngleSharp.Css.FeatureValidators
 
     sealed class WidthFeatureValidator : IFeatureValidator
     {
-        public Boolean Validate(IMediaFeature feature, IRenderDevice device)
+        public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)
         {
             var length = LengthConverter.Convert(feature.Value);
 
             if (length != null)
             {
-                var desired = length.AsPx(device);
-                var available = (Double)device.ViewPortWidth;
+                var desired = length.AsPx(renderDevice, true);
+                var available = (Double)renderDevice.ViewPortWidth;
 
                 if (feature.IsMaximum)
                 {
diff --git a/src/AngleSharp.Css/IFeatureValidator.cs b/src/AngleSharp.Css/IFeatureValidator.cs
@@ -12,8 +12,8 @@ public interface IFeatureValidator
         /// Validates the given media feature against the given device.
         /// </summary>
         /// <param name="feature">The feature to examine.</param>
-        /// <param name="device">The device to use as basis.</param>
+        /// <param name="renderDevice">The device to use as basis.</param>
         /// <returns>True if the feature is present, otherwise false.</returns>
-        Boolean Validate(IMediaFeature feature, IRenderDevice device);
+        Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice);
     }
 }
diff --git a/src/AngleSharp.Css/IRenderDimensions.cs b/src/AngleSharp.Css/IRenderDimensions.cs
diff --git a/src/AngleSharp.Css/Values/Functions/CssTranslateValue.cs b/src/AngleSharp.Css/Values/Functions/CssTranslateValue.cs
diff --git a/src/AngleSharp.Css/Values/Primitives/Length.cs b/src/AngleSharp.Css/Values/Primitives/Length.cs

Original file line number	Diff line number	Diff line change
`@@ -40,20 +40,22 @@ public static Double AsDouble(this ICssValue value)`
`40`	`40`	`/// Tries to convert the value to a number of pixels.`
`41`	`41`	`/// </summary>`
`42`	`42`	`/// <param name="value">The value to convert.</param>`
	`43`	`+ /// <param name="renderDimensions">the render device used to calculate relative units, can be null if units are absolute.</param>`
	`44`	`+ /// <param name="isWidth">If a relative unit is being calculated, true signifies that that unit is width, false height.</param>`
`43`	`45`	`/// <returns>The resulting number.</returns>`
`44`		`- public static Double AsPx(this ICssValue value, IRenderDimensions renderDimensions)`
	`46`	`+ public static Double AsPx(this ICssValue value, IRenderDimensions renderDimensions, Boolean isWidth = true)`
`45`	`47`	`{`
`46`	`48`	`if (value is Length length && length.Type != Length.Unit.None)`
`47`	`49`	`{`
`48`		`- return length.ToPixel(renderDimensions);`
	`50`	`+ return length.ToPixel(renderDimensions, isWidth);`
`49`	`51`	`}`
`50`	`52`	`else if (value is ICssMultipleValue multiple && multiple.Count == 1)`
`51`	`53`	`{`
`52`		`- return multiple[0].AsPx(renderDimensions);`
	`54`	`+ return multiple[0].AsPx(renderDimensions, isWidth);`
`53`	`55`	`}`
`54`	`56`	`else if (value is ICssSpecialValue special && special.Value != null)`
`55`	`57`	`{`
`56`		`- return special.Value.AsPx(renderDimensions);`
	`58`	`+ return special.Value.AsPx(renderDimensions, isWidth);`
`57`	`59`	`}`
`58`	`60`
`59`	`61`	`return 0.0;`
`@@ -201,20 +203,21 @@ public static String AsUrl(this ICssValue value)`
`201`	`203`	`/// Tries to convert the value to a transformation matrix.`
`202`	`204`	`/// </summary>`
`203`	`205`	`/// <param name="value">The value to convert.</param>`
	`206`	`+ /// <param name="renderDimensions">the render device used to calculate relative units, can be null if units are absolute.</param>`
`204`	`207`	`/// <returns>The resulting matrix.</returns>`
`205`		`- public static TransformMatrix AsMatrix(this ICssValue value, IRenderDimensions dimensions)`
	`208`	`+ public static TransformMatrix AsMatrix(this ICssValue value, IRenderDimensions renderDimensions)`
`206`	`209`	`{`
`207`	`210`	`if (value is ICssTransformFunctionValue res)`
`208`	`211`	`{`
`209`		`- return res.ComputeMatrix(dimensions);`
	`212`	`+ return res.ComputeMatrix(renderDimensions);`
`210`	`213`	`}`
`211`	`214`	`else if (value is ICssMultipleValue multiple && multiple.Count == 1)`
`212`	`215`	`{`
`213`		`- return multiple[0].AsMatrix(dimensions);`
	`216`	`+ return multiple[0].AsMatrix(renderDimensions);`
`214`	`217`	`}`
`215`	`218`	`else if (value is ICssSpecialValue special && special.Value != null)`
`216`	`219`	`{`
`217`		`- return special.Value.AsMatrix(dimensions);`
	`220`	`+ return special.Value.AsMatrix(renderDimensions);`
`218`	`221`	`}`
`219`	`222`
`220`	`223`	`return null;`
Original file line number	Diff line number	Diff line change
`@@ -7,14 +7,14 @@ namespace AngleSharp.Css.FeatureValidators`
`7`	`7`
`8`	`8`	`sealed class AspectRatioFeatureValidator : IFeatureValidator`
`9`	`9`	`{`
`10`		`- public Boolean Validate(IMediaFeature feature, IRenderDevice device)`
	`10`	`+ public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)`
`11`	`11`	`{`
`12`	`12`	`var ratio = RatioConverter.Convert(feature.Value);`
`13`	`13`
`14`	`14`	`if (ratio != null)`
`15`	`15`	`{`
`16`	`16`	`var desired = ratio.AsDouble();`
`17`		`- var available = device.ViewPortWidth / (Double)device.ViewPortHeight;`
	`17`	`+ var available = renderDevice.ViewPortWidth / (Double)renderDevice.ViewPortHeight;`
`18`	`18`
`19`	`19`	`if (feature.IsMaximum)`
`20`	`20`	`{`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ namespace AngleSharp.Css.FeatureValidators`
`8`	`8`
`9`	`9`	`sealed class ColorFeatureValidator : IFeatureValidator`
`10`	`10`	`{`
`11`		`- public Boolean Validate(IMediaFeature feature, IRenderDevice device)`
	`11`	`+ public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)`
`12`	`12`	`{`
`13`	`13`	`var defaultValue = new Length(1.0, Length.Unit.None);`
`14`	`14`	`var converter = feature.IsMinimum \|\| feature.IsMaximum ? PositiveIntegerConverter : PositiveIntegerConverter.Option(defaultValue);`
`@@ -17,7 +17,7 @@ public Boolean Validate(IMediaFeature feature, IRenderDevice device)`
`17`	`17`	`if (color != null)`
`18`	`18`	`{`
`19`	`19`	`var desired = color.AsInt32();`
`20`		`- var available = Math.Pow(device.ColorBits, 2);`
	`20`	`+ var available = Math.Pow(renderDevice.ColorBits, 2);`
`21`	`21`
`22`	`22`	`if (feature.IsMaximum)`
`23`	`23`	`{`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ namespace AngleSharp.Css.FeatureValidators`
`8`	`8`
`9`	`9`	`sealed class ColorIndexFeatureValidator : IFeatureValidator`
`10`	`10`	`{`
`11`		`- public Boolean Validate(IMediaFeature feature, IRenderDevice device)`
	`11`	`+ public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)`
`12`	`12`	`{`
`13`	`13`	`var defaultValue = new Length(1.0, Length.Unit.None);`
`14`	`14`	`var converter = feature.IsMinimum \|\| feature.IsMaximum ? NaturalIntegerConverter : NaturalIntegerConverter.Option(defaultValue);`
`@@ -17,7 +17,7 @@ public Boolean Validate(IMediaFeature feature, IRenderDevice device)`
`17`	`17`	`if (index != null)`
`18`	`18`	`{`
`19`	`19`	`var desired = index.AsInt32();`
`20`		`- var available = device.ColorBits;`
	`20`	`+ var available = renderDevice.ColorBits;`
`21`	`21`
`22`	`22`	`if (feature.IsMaximum)`
`23`	`23`	`{`
Original file line number	Diff line number	Diff line change
`@@ -7,14 +7,14 @@ namespace AngleSharp.Css.FeatureValidators`
`7`	`7`
`8`	`8`	`sealed class DeviceAspectRatioFeatureValidator : IFeatureValidator`
`9`	`9`	`{`
`10`		`- public Boolean Validate(IMediaFeature feature, IRenderDevice device)`
	`10`	`+ public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)`
`11`	`11`	`{`
`12`	`12`	`var ratio = RatioConverter.Convert(feature.Value);`
`13`	`13`
`14`	`14`	`if (ratio != null)`
`15`	`15`	`{`
`16`	`16`	`var desired = ratio.AsDouble();`
`17`		`- var available = device.DeviceWidth / (Double)device.DeviceHeight;`
	`17`	`+ var available = renderDevice.DeviceWidth / (Double)renderDevice.DeviceHeight;`
`18`	`18`
`19`	`19`	`if (feature.IsMaximum)`
`20`	`20`	`{`
Original file line number	Diff line number	Diff line change
`@@ -7,14 +7,14 @@ namespace AngleSharp.Css.FeatureValidators`
`7`	`7`
`8`	`8`	`sealed class DeviceHeightFeatureValidator : IFeatureValidator`
`9`	`9`	`{`
`10`		`- public Boolean Validate(IMediaFeature feature, IRenderDevice device)`
	`10`	`+ public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)`
`11`	`11`	`{`
`12`	`12`	`var length = LengthConverter.Convert(feature.Value);`
`13`	`13`
`14`	`14`	`if (length != null)`
`15`	`15`	`{`
`16`		`- var desired = length.AsPx(device);`
`17`		`- var available = (Double)device.DeviceHeight;`
	`16`	`+ var desired = length.AsPx(renderDevice, false);`
	`17`	`+ var available = (Double)renderDevice.DeviceHeight;`
`18`	`18`
`19`	`19`	`if (feature.IsMaximum)`
`20`	`20`	`{`
Original file line number	Diff line number	Diff line change
`@@ -7,14 +7,14 @@ namespace AngleSharp.Css.FeatureValidators`
`7`	`7`
`8`	`8`	`sealed class DevicePixelRatioFeatureValidator : IFeatureValidator`
`9`	`9`	`{`
`10`		`- public Boolean Validate(IMediaFeature feature, IRenderDevice device)`
	`10`	`+ public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)`
`11`	`11`	`{`
`12`	`12`	`var value = NaturalNumberConverter.Convert(feature.Value);`
`13`	`13`
`14`	`14`	`if (value != null)`
`15`	`15`	`{`
`16`	`16`	`var desired = value.AsDouble();`
`17`		`- var available = device.Resolution / 96f;`
	`17`	`+ var available = renderDevice.Resolution / 96f;`
`18`	`18`
`19`	`19`	`if (feature.IsMaximum)`
`20`	`20`	`{`
Original file line number	Diff line number	Diff line change
`@@ -7,14 +7,14 @@ namespace AngleSharp.Css.FeatureValidators`
`7`	`7`
`8`	`8`	`sealed class DeviceWidthFeatureValidator : IFeatureValidator`
`9`	`9`	`{`
`10`		`- public Boolean Validate(IMediaFeature feature, IRenderDevice device)`
	`10`	`+ public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)`
`11`	`11`	`{`
`12`	`12`	`var length = LengthConverter.Convert(feature.Value);`
`13`	`13`
`14`	`14`	`if (length != null)`
`15`	`15`	`{`
`16`		`- var desired = length.AsPx(device);`
`17`		`- var available = (Double)device.DeviceWidth;`
	`16`	`+ var desired = length.AsPx(renderDevice, true);`
	`17`	`+ var available = (Double)renderDevice.DeviceWidth;`
`18`	`18`
`19`	`19`	`if (feature.IsMaximum)`
`20`	`20`	`{`
Original file line number	Diff line number	Diff line change
`@@ -7,14 +7,14 @@ namespace AngleSharp.Css.FeatureValidators`
`7`	`7`
`8`	`8`	`sealed class GridFeatureValidator : IFeatureValidator`
`9`	`9`	`{`
`10`		`- public Boolean Validate(IMediaFeature feature, IRenderDevice device)`
	`10`	`+ public Boolean Validate(IMediaFeature feature, IRenderDevice renderDevice)`
`11`	`11`	`{`
`12`	`12`	`var grid = BinaryConverter.Convert(feature.Value);`
`13`	`13`
`14`	`14`	`if (grid != null)`
`15`	`15`	`{`
`16`	`16`	`var desired = grid.AsBoolean();`
`17`		`- var available = device.IsGrid;`
	`17`	`+ var available = renderDevice.IsGrid;`
`18`	`18`	`return desired == available;`
`19`	`19`	`}`
`20`	`20`