make TextOptions and ShapeOptions composed rather than inherited.

Author: tocsoft

src/ImageSharp.Drawing/Processing/Processors/Drawing/FillRegionProcessor{TPixel}.cs

@@ -30,13 +30,13 @@ public FillRegionProcessor(Configuration configuration, FillRegionProcessor defi
         protected override void OnFrameApply(ImageFrame<TPixel> source)
         {
             Configuration configuration = this.Configuration;
-            ShapeGraphicsOptions shapeOptions = this.definition.Options;
-            GraphicsOptions forApplicator = (GraphicsOptions)shapeOptions;
+            ShapeOptions shapeOptions = this.definition.Options.ShapeOptions;
+            GraphicsOptions graphicsOptions = this.definition.Options.GraphicsOptions;
             IBrush brush = this.definition.Brush;
             Region region = this.definition.Region;
             Rectangle rect = region.Bounds;
 
-            bool isSolidBrushWithoutBlending = IsSolidBrushWithoutBlending(forApplicator, this.definition.Brush, out SolidBrush solidBrush);
+            bool isSolidBrushWithoutBlending = IsSolidBrushWithoutBlending(graphicsOptions, this.definition.Brush, out SolidBrush solidBrush);
             TPixel solidBrushColor = isSolidBrushWithoutBlending ? solidBrush.Color.ToPixel<TPixel>() : default;
 
             // Align start/end positions.
@@ -62,17 +62,17 @@ protected override void OnFrameApply(ImageFrame<TPixel> source)
             // and this can cause missed fills when not using antialiasing.so we offset the pixel grid by 0.5 in the x & y direction thus causing the#
             // region to align with the pixel grid.
             float offset = 0.5f;
-            if (shapeOptions.Antialias)
+            if (graphicsOptions.Antialias)
             {
                 offset = 0f; // we are antialiasing skip offsetting as real antialiasing should take care of offset.
-                subpixelCount = shapeOptions.AntialiasSubpixelDepth;
+                subpixelCount = graphicsOptions.AntialiasSubpixelDepth;
                 if (subpixelCount < 4)
                 {
                     subpixelCount = 4;
                 }
             }
 
-            using (BrushApplicator<TPixel> applicator = brush.CreateApplicator(configuration, forApplicator, source, rect))
+            using (BrushApplicator<TPixel> applicator = brush.CreateApplicator(configuration, graphicsOptions, source, rect))
             {
                 int scanlineWidth = maxX - minX;
                 MemoryAllocator allocator = this.Configuration.MemoryAllocator;
@@ -143,7 +143,7 @@ protected override void OnFrameApply(ImageFrame<TPixel> source)
 
                         if (scanlineDirty)
                         {
-                            if (!shapeOptions.Antialias)
+                            if (!graphicsOptions.Antialias)
                             {
                                 bool hasOnes = false;
                                 bool hasZeros = false;

src/ImageSharp.Drawing/Processing/Processors/Text/DrawTextProcessor{TPixel}.cs

@@ -46,20 +46,20 @@ protected override void BeforeImageApply()
             base.BeforeImageApply();
 
             // do everything at the image level as we are delegating the processing down to other processors
-            var style = new RendererOptions(this.Font, this.Options.DpiX, this.Options.DpiY, this.Location)
+            var style = new RendererOptions(this.Font, this.Options.TextOptions.DpiX, this.Options.TextOptions.DpiY, this.Location)
             {
-                ApplyKerning = this.Options.ApplyKerning,
-                TabWidth = this.Options.TabWidth,
-                WrappingWidth = this.Options.WrapTextWidth,
-                HorizontalAlignment = this.Options.HorizontalAlignment,
-                VerticalAlignment = this.Options.VerticalAlignment,
-                FallbackFontFamilies = this.Options.FallbackFonts,
-                ColorFontSupport = this.definition.Options.RenderColorFonts ? ColorFontSupport.MicrosoftColrFormat : ColorFontSupport.None,
+                ApplyKerning = this.Options.TextOptions.ApplyKerning,
+                TabWidth = this.Options.TextOptions.TabWidth,
+                WrappingWidth = this.Options.TextOptions.WrapTextWidth,
+                HorizontalAlignment = this.Options.TextOptions.HorizontalAlignment,
+                VerticalAlignment = this.Options.TextOptions.VerticalAlignment,
+                FallbackFontFamilies = this.Options.TextOptions.FallbackFonts,
+                ColorFontSupport = this.definition.Options.TextOptions.RenderColorFonts ? ColorFontSupport.MicrosoftColrFormat : ColorFontSupport.None,
             };
 
             this.textRenderer = new CachingGlyphRenderer(this.Configuration.MemoryAllocator, this.Text.Length, this.Pen, this.Brush != null);
 
-            this.textRenderer.Options = (GraphicsOptions)this.Options;
+            this.textRenderer.Options = this.Options.GraphicsOptions;
             var renderer = new TextRenderer(this.textRenderer);
             renderer.RenderText(this.Text, style);
         }

src/ImageSharp.Drawing/Processing/ShapeGraphicOptionsDefaultsExtensions.cs

@@ -17,11 +17,11 @@ public static class ShapeGraphicOptionsDefaultsExtensions
         /// <param name="context">The image processing context to store default against.</param>
         /// <param name="optionsBuilder">The action to update instance of the default options used.</param>
         /// <returns>The passed in <paramref name="context"/> to allow chaining.</returns>
-        public static IImageProcessingContext SetShapeGraphicsOptions(this IImageProcessingContext context, Action<ShapeGraphicsOptions> optionsBuilder)
+        public static IImageProcessingContext SetShapeOptions(this IImageProcessingContext context, Action<ShapeOptions> optionsBuilder)
         {
-            var cloned = context.GetShapeGraphicsOptions().DeepClone();
+            var cloned = context.GetShapeOptions().DeepClone();
             optionsBuilder(cloned);
-            context.Properties[typeof(ShapeGraphicsOptions)] = cloned;
+            context.Properties[typeof(ShapeOptions)] = cloned;
             return context;
         }
 
@@ -30,11 +30,11 @@ public static IImageProcessingContext SetShapeGraphicsOptions(this IImageProcess
         /// </summary>
         /// <param name="configuration">The configuration to store default against.</param>
         /// <param name="optionsBuilder">The default options to use.</param>
-        public static void SetShapeGraphicsOptions(this Configuration configuration, Action<ShapeGraphicsOptions> optionsBuilder)
+        public static void SetShapeOptions(this Configuration configuration, Action<ShapeOptions> optionsBuilder)
         {
-            var cloned = configuration.GetShapeGraphicsOptions().DeepClone();
+            var cloned = configuration.GetShapeOptions().DeepClone();
             optionsBuilder(cloned);
-            configuration.Properties[typeof(ShapeGraphicsOptions)] = cloned;
+            configuration.Properties[typeof(ShapeOptions)] = cloned;
         }
 
         /// <summary>
@@ -43,9 +43,9 @@ public static void SetShapeGraphicsOptions(this Configuration configuration, Act
         /// <param name="context">The image processing context to store default against.</param>
         /// <param name="options">The default options to use.</param>
         /// <returns>The passed in <paramref name="context"/> to allow chaining.</returns>
-        public static IImageProcessingContext SetShapeGraphicsOptions(this IImageProcessingContext context, ShapeGraphicsOptions options)
+        public static IImageProcessingContext SetShapeOptions(this IImageProcessingContext context, ShapeOptions options)
         {
-            context.Properties[typeof(ShapeGraphicsOptions)] = options;
+            context.Properties[typeof(ShapeOptions)] = options;
             return context;
         }
 
@@ -54,9 +54,9 @@ public static IImageProcessingContext SetShapeGraphicsOptions(this IImageProcess
         /// </summary>
         /// <param name="configuration">The configuration to store default against.</param>
         /// <param name="options">The default options to use.</param>
-        public static void SetShapeGraphicsOptions(this Configuration configuration, ShapeGraphicsOptions options)
+        public static void SetShapeOptions(this Configuration configuration, ShapeOptions options)
         {
-            configuration.Properties[typeof(ShapeGraphicsOptions)] = options;
+            configuration.Properties[typeof(ShapeOptions)] = options;
         }
 
         /// <summary>
@@ -65,13 +65,21 @@ public static void SetShapeGraphicsOptions(this Configuration configuration, Sha
         /// <param name="context">The image processing context to retrieve defaults from.</param>
         /// <returns>The globaly configued default options.</returns>
         public static ShapeGraphicsOptions GetShapeGraphicsOptions(this IImageProcessingContext context)
+            => new ShapeGraphicsOptions(context.GetGraphicsOptions(), context.GetShapeOptions());
+
+        /// <summary>
+        /// Gets the default shape processing options against the image processing context.
+        /// </summary>
+        /// <param name="context">The image processing context to retrieve defaults from.</param>
+        /// <returns>The globaly configued default options.</returns>
+        public static ShapeOptions GetShapeOptions(this IImageProcessingContext context)
         {
-            if (context.Properties.TryGetValue(typeof(ShapeGraphicsOptions), out var options) && options is ShapeGraphicsOptions go)
+            if (context.Properties.TryGetValue(typeof(ShapeOptions), out var options) && options is ShapeOptions go)
             {
                 return go;
             }
 
-            var configOptions = context.Configuration.GetShapeGraphicsOptions();
+            var configOptions = context.Configuration.GetShapeOptions();
 
             // do not cache the fall back to config into the the processing context
             // in case someone want to change the value on the config and expects it re trflow thru
@@ -83,17 +91,17 @@ public static ShapeGraphicsOptions GetShapeGraphicsOptions(this IImageProcessing
         /// </summary>
         /// <param name="configuration">The configuration to retrieve defaults from.</param>
         /// <returns>The globaly configued default options.</returns>
-        public static ShapeGraphicsOptions GetShapeGraphicsOptions(this Configuration configuration)
+        public static ShapeOptions GetShapeOptions(this Configuration configuration)
         {
-            if (configuration.Properties.TryGetValue(typeof(ShapeGraphicsOptions), out var options) && options is ShapeGraphicsOptions go)
+            if (configuration.Properties.TryGetValue(typeof(ShapeOptions), out var options) && options is ShapeOptions go)
             {
                 return go;
             }
 
-            var configOptions = new ShapeGraphicsOptions(configuration.GetGraphicsOptions());
+            var configOptions = new ShapeOptions();
 
             // capture the fallback so the same instance will always be returned in case its mutated
-            configuration.Properties[typeof(ShapeGraphicsOptions)] = configOptions;
+            configuration.Properties[typeof(ShapeOptions)] = configOptions;
             return configOptions;
         }
     }

src/ImageSharp.Drawing/Processing/ShapeGraphicsOptions.cs

@@ -10,131 +10,57 @@ namespace SixLabors.ImageSharp.Drawing.Processing
     /// <summary>
     /// Options for influencing the drawing functions.
     /// </summary>
-    public class ShapeGraphicsOptions : IDeepCloneable<ShapeGraphicsOptions>
+    public class ShapeGraphicsOptions
     {
-        private int antialiasSubpixelDepth = 16;
-        private float blendPercentage = 1F;
+        private GraphicsOptions graphicsOptions;
+        private ShapeOptions shapeOptions;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ShapeGraphicsOptions"/> class.
         /// </summary>
         public ShapeGraphicsOptions()
         {
+            this.graphicsOptions = new GraphicsOptions();
+            this.shapeOptions = new ShapeOptions();
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ShapeGraphicsOptions"/> class.
         /// </summary>
-        /// <param name="source">The source to clone from.</param>
-        public ShapeGraphicsOptions(GraphicsOptions source)
+        /// <param name="graphicsOptions">The graphic options to use</param>
+        /// <param name="shapeOptions">The text options to use</param>
+        public ShapeGraphicsOptions(GraphicsOptions graphicsOptions, ShapeOptions shapeOptions)
         {
-            this.AlphaCompositionMode = source.AlphaCompositionMode;
-            this.Antialias = source.Antialias;
-            this.AntialiasSubpixelDepth = source.AntialiasSubpixelDepth;
-            this.BlendPercentage = source.BlendPercentage;
-            this.ColorBlendingMode = source.ColorBlendingMode;
+            Guard.NotNull(graphicsOptions, nameof(graphicsOptions));
+            Guard.NotNull(shapeOptions, nameof(shapeOptions));
+            this.graphicsOptions = graphicsOptions;
+            this.shapeOptions = shapeOptions;
         }
 
-        private ShapeGraphicsOptions(ShapeGraphicsOptions source)
-        {
-            this.AlphaCompositionMode = source.AlphaCompositionMode;
-            this.Antialias = source.Antialias;
-            this.AntialiasSubpixelDepth = source.AntialiasSubpixelDepth;
-            this.BlendPercentage = source.BlendPercentage;
-            this.ColorBlendingMode = source.ColorBlendingMode;
-            this.IntersectionRule = source.IntersectionRule;
-        }
-
-        /// <summary>
-        /// Gets or sets a value indicating whether antialiasing should be applied.
-        /// Defaults to true.
-        /// </summary>
-        public IntersectionRule IntersectionRule { get; set; } = IntersectionRule.OddEven;
-
-        /// <summary>
-        /// Gets or sets a value indicating whether antialiasing should be applied.
-        /// Defaults to true.
-        /// </summary>
-        public bool Antialias { get; set; } = true;
-
         /// <summary>
-        /// Gets or sets a value indicating the number of subpixels to use while rendering with antialiasing enabled.
+        /// Gets or sets the Graphics Options.
         /// </summary>
-        public int AntialiasSubpixelDepth
+        public GraphicsOptions GraphicsOptions
         {
-            get
-            {
-                return this.antialiasSubpixelDepth;
-            }
-
+            get => this.graphicsOptions;
             set
             {
-                Guard.MustBeGreaterThanOrEqualTo(value, 0, nameof(this.AntialiasSubpixelDepth));
-                this.antialiasSubpixelDepth = value;
+                Guard.NotNull(value, nameof(this.GraphicsOptions));
+                this.graphicsOptions = value;
             }
         }
 
         /// <summary>
-        /// Gets or sets a value indicating the blending percentage to apply to the drawing operation.
+        /// Gets or sets the Text Options.
         /// </summary>
-        public float BlendPercentage
+        public ShapeOptions ShapeOptions
         {
-            get
-            {
-                return this.blendPercentage;
-            }
-
+            get => this.shapeOptions;
             set
             {
-                Guard.MustBeBetweenOrEqualTo(value, 0, 1F, nameof(this.BlendPercentage));
-                this.blendPercentage = value;
+                Guard.NotNull(value, nameof(this.ShapeOptions));
+                this.shapeOptions = value;
             }
         }
-
-        /// <summary>
-        /// Gets or sets a value indicating the color blending percentage to apply to the drawing operation.
-        /// Defaults to <see cref= "PixelColorBlendingMode.Normal" />.
-        /// </summary>
-        public PixelColorBlendingMode ColorBlendingMode { get; set; } = PixelColorBlendingMode.Normal;
-
-        /// <summary>
-        /// Gets or sets a value indicating the color blending percentage to apply to the drawing operation
-        /// Defaults to <see cref= "PixelAlphaCompositionMode.SrcOver" />.
-        /// </summary>
-        public PixelAlphaCompositionMode AlphaCompositionMode { get; set; } = PixelAlphaCompositionMode.SrcOver;
-
-        /// <summary>
-        /// Performs an implicit conversion from <see cref="GraphicsOptions"/> to <see cref="TextGraphicsOptions"/>.
-        /// </summary>
-        /// <param name="options">The options.</param>
-        /// <returns>
-        /// The result of the conversion.
-        /// </returns>
-        public static implicit operator ShapeGraphicsOptions(GraphicsOptions options)
-        {
-            return new ShapeGraphicsOptions(options);
-        }
-
-        /// <summary>
-        /// Performs an explicit conversion from <see cref="TextGraphicsOptions"/> to <see cref="GraphicsOptions"/>.
-        /// </summary>
-        /// <param name="options">The options.</param>
-        /// <returns>
-        /// The result of the conversion.
-        /// </returns>
-        public static explicit operator GraphicsOptions(ShapeGraphicsOptions options)
-        {
-            return new GraphicsOptions()
-            {
-                Antialias = options.Antialias,
-                AntialiasSubpixelDepth = options.AntialiasSubpixelDepth,
-                ColorBlendingMode = options.ColorBlendingMode,
-                AlphaCompositionMode = options.AlphaCompositionMode,
-                BlendPercentage = options.BlendPercentage
-            };
-        }
-
-        /// <inheritdoc/>
-        public ShapeGraphicsOptions DeepClone() => new ShapeGraphicsOptions(this);
     }
 }

src/ImageSharp.Drawing/Processing/ShapeOptions.cs

@@ -0,0 +1,32 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Drawing.Processing
+{
+    /// <summary>
+    /// Options for influencing the drawing functions.
+    /// </summary>
+    public class ShapeOptions : IDeepCloneable<ShapeOptions>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ShapeOptions"/> class.
+        /// </summary>
+        public ShapeOptions()
+        {
+        }
+
+        private ShapeOptions(ShapeOptions source)
+        {
+            this.IntersectionRule = source.IntersectionRule;
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether antialiasing should be applied.
+        /// Defaults to true.
+        /// </summary>
+        public IntersectionRule IntersectionRule { get; set; } = IntersectionRule.OddEven;
+
+        /// <inheritdoc/>
+        public ShapeOptions DeepClone() => new ShapeOptions(this);
+    }
+}