public static Border CreateBlockBox(FrameworkElement child, double width, double height, double x, double y, Color backgroundColor)
        {
            var border = new Border()
            {
                BorderThickness = new Thickness(1, 1, 1, 1),
                BorderBrush = Brushes.Silver,
                Background = new SolidColorBrush(backgroundColor),

                Width = width,
                Height = height,
                Margin = new Thickness(x, y, 0, 0),
                Child = child
            };

            border.MouseEnter += (s, e) =>
            {
                border.Width = Math.Max(width, child.ActualWidth);
                border.Height = Math.Max(height, child.ActualHeight);
                Panel parent = (Panel)border.Parent;
                border.TopMost();
            };

            border.MouseLeave += (s, e) =>
            {
                border.Width = width;
                border.Height = height;
            };

            return border;
        }

 public CellColorActionViewModel(string name, string description, char code, Color backgroundColor)
 {
     Name = name;
     Description = description;
     Code = code;
     BackgroundBrush = new SolidColorBrush(backgroundColor);
 }

 public static IColorSequence Dipolar(Color negativeColor, Color positiveColor, int halfStepCount)
 {
     return new Ir1ColorSequence(
             new ColorSequenceImpl(positiveColor.LessFadingSpread(halfStepCount)),
             new ColorSequenceImpl(negativeColor.LessFadingSpread(halfStepCount))
         );
 }

        /// <summary>Creates a gradient brush with the given colors flowing in the specified direction.</summary>
        /// <param name="direction">The direction of the gradient.</param>
        /// <param name="start">The starting color.</param>
        /// <param name="end">The ending color.</param>
        public static LinearGradientBrush ToGradient(this Direction direction, Color start, Color end)
        {
            // Create the brush.
            var brush = new LinearGradientBrush();
            switch (direction)
            {
                case Direction.Down:
                case Direction.Up:
                    brush.StartPoint = new Point(0.5, 0);
                    brush.EndPoint = new Point(0.5, 1);
                    break;
                case Direction.Right:
                case Direction.Left:
                    brush.StartPoint = new Point(0, 0.5);
                    brush.EndPoint = new Point(1, 0.5);
                    break;
            }

            // Configure colors.
            var gradientStart = new GradientStop { Color = start };
            var gradientEnd = new GradientStop { Color = end };

            gradientStart.Offset = direction == Direction.Up || direction == Direction.Left ? 1 : 0;
            gradientEnd.Offset = direction == Direction.Down || direction == Direction.Right ? 1 : 0;

            // Insert colors.
            brush.GradientStops.Add(gradientStart);
            brush.GradientStops.Add(gradientEnd);

            // Finish up.
            return brush;
            
        }

 public CustomStartEndLineStyle(PointSymbolType startType, Color startColor, int startSize,
                                PointSymbolType endType, Color endColor, int endSize,
                                Color lineColor, float lineSize)
     : this(new PointStyle(startType, new GeoSolidBrush(GeoColor.FromArgb(startColor.A, startColor.R, startColor.G, startColor.B)), startSize),
            new PointStyle(endType, new GeoSolidBrush(GeoColor.FromArgb(endColor.A, endColor.R, endColor.G, endColor.B)), endSize),
            new LineStyle(new GeoPen(GeoColor.FromArgb(lineColor.A, lineColor.R, lineColor.G, lineColor.B), lineSize)))
 { }

 public AdministrationViewModel(ICustomAppearanceManager appearanceManager, IAppSettings appSettings)
 {
     this.appearanceManager = appearanceManager;
     this.appSettings = appSettings;
     selectedAccentColor = appearanceManager.AccentColor;
     selectedTextColor = appearanceManager.TextColor;
 }

 public LogFile(string path, Color color, string timestampPattern, LogOffset offset)
 {
     Path = path;
     Color = color;
     TimestampPattern = timestampPattern;
     Offset = offset;
 }

        public AlternatingListBoxBackground(Color color1, Color color2)
        {
            var setter = new Setter();
            setter.Property = ListBoxItem.BackgroundProperty;
            setter.Value = new SolidColorBrush(color1);

            var trigger = new Trigger();
            trigger.Property = ItemsControl.AlternationIndexProperty;
            trigger.Value = 0;
            trigger.Setters.Add(setter);

            var setter2 = new Setter();
            setter2.Property = ListBoxItem.BackgroundProperty;
            setter2.Value = new SolidColorBrush(color2);

            var trigger2 = new Trigger();
            trigger2.Property = ItemsControl.AlternationIndexProperty;
            trigger2.Value = 1;
            trigger2.Setters.Add(setter2);

            var listBoxStyle = new Style(typeof(ListBoxItem));
            listBoxStyle.Triggers.Add(trigger);
            listBoxStyle.Triggers.Add(trigger2);

            _listBoxStyle = listBoxStyle;
        }

 public ColorRange(Color lowColor, Color highColor, float lowHeight, float highHeight)
 {
     LowColor = lowColor;
     HighColor = highColor;
     LowHeight = lowHeight;
     HighHeight = highHeight;
 }

 public Dijkstra(Color main, Color temp, Color search, Color next)
 {
     mainColor=new SolidColorBrush(main);
     tempColor=new SolidColorBrush(temp);
     nextColor=new SolidColorBrush(next);
     searchColor=new SolidColorBrush(search);
 }

    } // DrawingToMediaColor()

    /// <summary>
    /// Converts a System.Windows.Media.Color value to a
    /// System.Drawing.Color value.
    /// </summary>
    /// <param name="color">A System.Windows.Media.Color value.</param>
    /// <returns>A System.Drawing.Color value.</returns>
    public static System.Drawing.Color MediaToDrawingColor(Color color)
    {
      System.Drawing.Color colorNew = System.Drawing.Color.FromArgb(
        color.A, color.R, color.G, color.B);
      
      return colorNew;
    } // MediaToDrawingColor()

 /// <summary>
 /// Initializes a new instance of the <see cref="Color"/> class.
 /// </summary>
 /// <param name="mediaColor">The color.</param>
 /// <param name="invariantName">The culture-insensitive name of the color. (Optional.)</param>
 /// <param name="name">The localized friendly name of the color. (Optional.)</param>
 /// <param name="isBuiltIn">A value indicating whether this color is defined in the assembly. (Optional.)</param>
 public Color(System.Windows.Media.Color mediaColor, string invariantName = null, string name = null, bool isBuiltIn = false)
 {
     this.name = name;
     this.identifier = isBuiltIn ? ("resource:" + invariantName) : ("color:" + mediaColor);
     this.isBuiltIn = isBuiltIn;
     this.mediaColor = mediaColor;
 }

 public static IZ1BrushSequence DualBrushes(Color positiveColor, Color negativeColor, int steps)
 {
     return new Z1BrushSequence(
         positiveBrushes: positiveColor.FadingSpread(steps + 1).ToBrushes(),
         negativeBrushes: negativeColor.FadingSpread(steps + 1).ToBrushes()
     );
 }

 public CleanCodeRank(Color color, string name)
 {
     Color = new SolidColorBrush(color);
     Name = "  " + name;
     Principles = new ObservableCollection<CleanCodePrinciple>();
     Practices = new ObservableCollection<CleanCodePractice>();
 }

 public ErrorTextMarker(int startOffset, int length, string message, Color markerColor)
 {
     StartOffset = startOffset;
     Length = length;
     Message = message;
     MarkerColor = markerColor;
 }

        public void ReplaceColors_ReplacesBackgroundColorsCorrectly()
        {
            // Arrange
            var oldColor = new Color {A = 255, R = 255, G = 0, B = 0};
            var newColor = new Color {A = 255, R = 0, G = 255, B = 100};

            var testInputReplaceColors = new ReplaceColorsParameterSet
            {
                OldBackgroundColor = oldColor,
                NewBackgroundColor = newColor,
                ReplaceBackgroundColor = true
            };

            var testInputBlock1 = new ItemFilterBlock();
            testInputBlock1.BlockItems.Add(new BackgroundColorBlockItem(new Color {A = 255, R = 255, G = 0, B = 0}));
            var testInputBlock2 = new ItemFilterBlock();
            testInputBlock2.BlockItems.Add(new BackgroundColorBlockItem(new Color { A = 255, R = 255, G = 1, B = 0 }));
            var testInputBlock3 = new ItemFilterBlock();
            testInputBlock3.BlockItems.Add(new BackgroundColorBlockItem(new Color { A = 255, R = 255, G = 0, B = 0 }));

            var script = new ItemFilterScript();

            script.ItemFilterBlocks.Add(testInputBlock1);
            script.ItemFilterBlocks.Add(testInputBlock2);
            script.ItemFilterBlocks.Add(testInputBlock3);

            // Act
            script.ReplaceColors(testInputReplaceColors);

            // Assert
            Assert.AreEqual(newColor, testInputBlock1.BlockItems.OfType<BackgroundColorBlockItem>().First().Color);
            Assert.AreNotEqual(newColor, testInputBlock2.BlockItems.OfType<BackgroundColorBlockItem>().First().Color);
            Assert.AreEqual(newColor, testInputBlock3.BlockItems.OfType<BackgroundColorBlockItem>().First().Color);
        }

 public Prim(Color init, Color edgefinal, Color edgetemp, Color nodefinal)
 {
     initColor = new SolidColorBrush(init);
     edgeFinalColor = new SolidColorBrush(edgefinal);
     edgeTempColor = new SolidColorBrush(edgetemp);
     nodeFinalColor = new SolidColorBrush(nodefinal);
 }

        /// <summary>
        /// Bilinear interpolation of ARGB values.
        /// </summary>
        /// <param name="x">The X interpolation parameter 0..1</param>
        /// <param name="y">The y interpolation parameter 0..1</param>
        /// <param name="nw"></param>
        /// <param name="ne"></param>
        /// <param name="sw"></param>
        /// <param name="se"></param>
        /// <returns>The interpolated value.</returns>
        public static Color BilinearInterpolate(double x, double y, Color nw, Color ne, Color sw, Color se)
        {
            double cx = 1.0 - x;
            double cy = 1.0 - y;

            //nw = ColorUtility.PreMultiplyAlpha(nw);
            //ne = ColorUtility.PreMultiplyAlpha(ne);
            //sw = ColorUtility.PreMultiplyAlpha(sw);
            //se = ColorUtility.PreMultiplyAlpha(se);

            double m0 = cx * nw.A + x * ne.A;
            double m1 = cx * sw.A + x * se.A;
            byte a = (byte)(cy * m0 + y * m1);

            m0 = cx * nw.R + x * ne.R;
            m1 = cx * sw.R + x * se.R;
            byte r = (byte)(cy * m0 + y * m1);

            m0 = cx * nw.G + x * ne.G;
            m1 = cx * sw.G + x * se.G;
            byte g = (byte)(cy * m0 + y * m1);

            m0 = cx * nw.B + x * ne.B;
            m1 = cx * sw.B + x * se.B;
            byte b = (byte)(cy * m0 + y * m1);

            Color result = Color.FromArgb(a, r, g, b);
            //result = ColorUtility.UnPreMultiplyAlpha(result);
            return result;
        }

 public TileProperty(int id, string name, Color color, bool isFramed = false)
 {
     _color = color;
     _id = id;
     _name = name;
     _isFramed = isFramed;
 }

 public override TileStyle GetStyle(Color tileColor, Color fontColor)
 {
     var style = GetDefaultStyle();
     style.Font.Color = new SolidColorBrush(fontColor);
     style.Shape.Fill = new SolidColorBrush(tileColor);
     return style;
 }