public void Animate(System.Windows.Media.Brush Before, System.Windows.Media.Brush After, double Duration, FrameworkElement Item, PropertyPath Property) { this.af = After; this.Property = Property; item = Item; Storyboard.Children.Clear(); if (Before.GetType() == typeof(SolidColorBrush)) { Color be = ((SolidColorBrush)Before).Color; Color af = ((SolidColorBrush)After).Color; Animation.From = be; Animation.To = af; Animation.Duration = TimeSpan.FromMilliseconds(Duration); Animation.FillBehavior = FillBehavior.Stop; Storyboard.SetTargetProperty(Animation, Property); Storyboard.Children.Add(Animation); Storyboard.Begin(Item, true); } if (Before.GetType() == typeof(LinearGradientBrush)) { LinearGradientBrush be = (LinearGradientBrush)Before; LinearGradientBrush af = (LinearGradientBrush)After; for (int i = 0; be.GradientStops.Count > i; i++) { ColorAnimation CA = new ColorAnimation(); CA.From = be.GradientStops[i].Color; CA.To = af.GradientStops[i].Color; CA.Duration = TimeSpan.FromMilliseconds(Duration); CA.FillBehavior = FillBehavior.Stop; Storyboard.SetTargetProperty(CA, Property); Storyboard.Children.Add(CA); } Storyboard.Begin(); } }
/// <summary>背景色から問題を確認</summary> /// <param name="b">Background(Brush)を想定</param> /// <returns>結果:true = 問題なし、false = 問題あり</returns> public static bool CheckErrorAtBgBrush(Brush b) { SolidColorBrush scb = new SolidColorBrush(Colors.Red); if (b.GetType() == scb.GetType()) { if (((SolidColorBrush)b).Color == scb.Color) { return false; } else { return true; } } else { return true; } }
public static bool AreBrushesEqual(Brush first, Brush second) { // If the default comparison is true, that's good enough. if (object.Equals(first, second)) { return true; } if (first.GetType().Name == "SolidColorBrush") { // Do a field by field comparison if they're not the same reference SolidColorBrush firstSolidColorBrush = first as SolidColorBrush; if (firstSolidColorBrush != null) { SolidColorBrush secondSolidColorBrush = second as SolidColorBrush; if (secondSolidColorBrush != null) { return object.Equals(firstSolidColorBrush.Color, secondSolidColorBrush.Color); } } } else { // Do a field by field comparison if they're not the same reference LinearGradientBrush firstLinearColorBrush = first as LinearGradientBrush; if (firstLinearColorBrush != null) { LinearGradientBrush secondLinearColorBrush = second as LinearGradientBrush; if (secondLinearColorBrush != null) { Boolean stop1 = object.Equals(firstLinearColorBrush.GradientStops[0].Color, secondLinearColorBrush.GradientStops[0].Color); Boolean stop2 = object.Equals(firstLinearColorBrush.GradientStops[1].Color, secondLinearColorBrush.GradientStops[1].Color); return object.Equals(stop1, stop2); } } } return false; }
public static Color ExtractColor(Brush brush) { if (brush is SolidColorBrush) { return ((SolidColorBrush)brush).Color; } else if (brush is GradientBrush) { GradientBrush brushCast = (GradientBrush)brush; Color average = AverageColors(brushCast.GradientStops.Select(o => o.Color)); if (brushCast.Opacity.IsNearZero()) { return Color.FromArgb(0, average.R, average.G, average.B); } else if (brushCast.Opacity.IsNearValue(1)) { return average; } else { double opacity = average.A / 255d; opacity *= brushCast.Opacity; return Color.FromArgb((opacity * 255d).ToByte_Round(), average.R, average.G, average.B); } } else { throw new ArgumentException("Unsupported brush type: " + brush.GetType().ToString()); } }
public static void SetForeground(this HtmlStyleDictionary style, Brush foreground, IHtmlValueConverter converter) { if (foreground == null) { style.ClearValue("color"); } else if (foreground is SolidColorBrush) { style.SetValue("color", converter.ToColorString((SolidColorBrush)foreground)); } else { throw new Granular.Exception("A \"{0}\" foreground brush is not supported", foreground.GetType()); } }
private static void SwapColorsWithoutCloning(Brush brush, ColorCallback colorCallback) { if (brush != null) { SolidColorBrush brush2 = brush as SolidColorBrush; if (brush2 != null) { brush2.Color = colorCallback(brush2.Color); } else { GradientBrush brush3 = brush as GradientBrush; if (brush3 == null) { DrawingBrush brush4 = brush as DrawingBrush; if (brush4 != null) { SwapColorsWithoutCloning(brush4.Drawing, colorCallback); } else { ImageBrush brush5 = brush as ImageBrush; if (brush5 != null) { brush5.ImageSource = SwapColorsWithoutCloningIfPossible(brush5.ImageSource, colorCallback); } else if (!(brush is VisualBrush)) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "UnexpectedBrushType", new object[] { brush.GetType().Name })); } } } else { foreach (GradientStop stop in brush3.GradientStops) { stop.Color = colorCallback(stop.Color); } } } } }
/// <summary> /// Verifies if the given brush is the same as the otherBrush. /// </summary> /// <param name="brush">Brush</param> /// <param name="otherBrush">Brush</param> /// <returns>true if yes, otherwise false</returns> public static bool IsEqualTo(this Brush brush, Brush otherBrush) { if (brush.GetType() != otherBrush.GetType()) return false; if (ReferenceEquals(brush, otherBrush)) return true; // Are both instances of SolidColorBrush var solidBrushA = brush as SolidColorBrush; var solidBrushB = otherBrush as SolidColorBrush; if ((solidBrushA != null) && (solidBrushB != null)) { return (solidBrushA.Color == solidBrushB.Color) && solidBrushA.Opacity.IsCloseTo(solidBrushB.Opacity); } // Are both instances of LinearGradientBrush var linGradBrushA = brush as LinearGradientBrush; var linGradBrushB = otherBrush as LinearGradientBrush; if ((linGradBrushA != null) && (linGradBrushB != null)) { var result = (linGradBrushA.ColorInterpolationMode == linGradBrushB.ColorInterpolationMode) && (linGradBrushA.EndPoint == linGradBrushB.EndPoint) && (linGradBrushA.MappingMode == linGradBrushB.MappingMode) && linGradBrushA.Opacity.IsCloseTo(linGradBrushB.Opacity) && (linGradBrushA.StartPoint == linGradBrushB.StartPoint) && (linGradBrushA.SpreadMethod == linGradBrushB.SpreadMethod) && (linGradBrushA.GradientStops.Count == linGradBrushB.GradientStops.Count); if (!result) return false; for (var i = 0; i < linGradBrushA.GradientStops.Count; i++) { result = (linGradBrushA.GradientStops[i].Color == linGradBrushB.GradientStops[i].Color) && linGradBrushA.GradientStops[i].Offset.IsCloseTo(linGradBrushB.GradientStops[i].Offset); if (!result) break; } return result; } // Are both instances of RadialGradientBrush var radGradBrushA = brush as RadialGradientBrush; var radGradBrushB = otherBrush as RadialGradientBrush; if ((radGradBrushA != null) && (radGradBrushB != null)) { var result = (radGradBrushA.ColorInterpolationMode == radGradBrushB.ColorInterpolationMode) && (radGradBrushA.GradientOrigin == radGradBrushB.GradientOrigin) && (radGradBrushA.MappingMode == radGradBrushB.MappingMode) && radGradBrushA.Opacity.IsCloseTo(radGradBrushB.Opacity) && radGradBrushA.RadiusX.IsCloseTo(radGradBrushB.RadiusX) && radGradBrushA.RadiusY.IsCloseTo(radGradBrushB.RadiusY) && (radGradBrushA.SpreadMethod == radGradBrushB.SpreadMethod) && (radGradBrushA.GradientStops.Count == radGradBrushB.GradientStops.Count); if (!result) return false; for (var i = 0; i < radGradBrushA.GradientStops.Count; i++) { result = (radGradBrushA.GradientStops[i].Color == radGradBrushB.GradientStops[i].Color) && radGradBrushA.GradientStops[i].Offset.IsCloseTo(radGradBrushB.GradientStops[i].Offset); if (!result) break; } return result; } // Are both instances of ImageBrush var imgBrushA = brush as ImageBrush; var imgBrushB = otherBrush as ImageBrush; if ((imgBrushA != null) && (imgBrushB != null)) { var result = (imgBrushA.AlignmentX == imgBrushB.AlignmentX) && (imgBrushA.AlignmentY == imgBrushB.AlignmentY) && imgBrushA.Opacity.IsCloseTo(imgBrushB.Opacity) && (imgBrushA.Stretch == imgBrushB.Stretch) && (imgBrushA.TileMode == imgBrushB.TileMode) && (imgBrushA.Viewbox == imgBrushB.Viewbox) && (imgBrushA.ViewboxUnits == imgBrushB.ViewboxUnits) && (imgBrushA.Viewport == imgBrushB.Viewport) && (imgBrushA.ViewportUnits == imgBrushB.ViewportUnits) && (imgBrushA.ImageSource == imgBrushB.ImageSource); return result; } return false; }
/// <summary> /// Get 3dBrush with or without lighting for bubble /// </summary> internal static Brush Get3DBrushLighting(Brush solidColorBrush, Boolean lightingEnabled) { if (solidColorBrush.GetType().Equals(typeof(SolidColorBrush))) { Color color = (solidColorBrush as SolidColorBrush).Color; RadialGradientBrush rgb = new RadialGradientBrush() { Center = new Point(0.3, 0.3), RadiusX = 0.93, RadiusY = 1, GradientOrigin = new Point(0.2, 0.2) }; if (color == Colors.Black) { if(lightingEnabled) rgb.GradientStops.Add(new GradientStop() { Color = Colors.White, Offset = 0 }); rgb.GradientStops.Add(new GradientStop() { Color = Colors.Gray, Offset = 0.1 }); rgb.GradientStops.Add(new GradientStop() { Color = Colors.Black, Offset = 1 }); } else { Color darkerColor = Graphics.GetDarkerColor(color, 0.2); if (lightingEnabled) rgb.GradientStops.Add(new GradientStop() { Color = Colors.White, Offset = 0 }); rgb.GradientStops.Add(new GradientStop() { Color = color, Offset = 0.1 }); rgb.GradientStops.Add(new GradientStop() { Color = darkerColor, Offset = 1 }); } return rgb; } else return solidColorBrush; }
/// <summary> /// Creates and returns a top face brush /// </summary> /// <param name="brush">Brush</param> /// <returns>Brush</returns> internal static Brush GetTopFaceBrush(Brush brush) { if (brush != null) { if (typeof(SolidColorBrush).Equals(brush.GetType())) { SolidColorBrush solidBrush = brush as SolidColorBrush; if(_3dLightingTopBrushs.ContainsKey(solidBrush.Color)) return _3dLightingTopBrushs[solidBrush.Color]; else { List<Color> colors = new List<Color>(); List<Double> stops = new List<Double>(); colors.Add(Graphics.GetDarkerColor(solidBrush.Color, 0.85)); stops.Add(0); colors.Add(Graphics.GetLighterColor(solidBrush.Color, 0.35)); stops.Add(1); brush = Graphics.CreateLinearGradientBrush(-45, new Point(0, 0.5), new Point(1, 0.5), colors, stops); _3dLightingTopBrushs.Add(solidBrush.Color, brush); return brush; } } else if (brush is GradientBrush) { GradientBrush gradBrush = brush as GradientBrush; List<Color> colors = new List<Color>(); List<Double> stops = new List<Double>(); foreach (GradientStop gradStop in gradBrush.GradientStops) { colors.Add(Graphics.GetLighterColor(gradStop.Color, 0.85)); stops.Add(gradStop.Offset); } if (brush is LinearGradientBrush) return Graphics.CreateLinearGradientBrush(-45, new Point(-0.5, 1.5), new Point(0.5, 0), colors, stops); else return Graphics.CreateRadialGradientBrush(colors, stops); } else { return brush; } } else return null; }
/// <summary> /// Creates and returns bevel top brush /// </summary> /// <param name="brush">Brush</param> /// <param name="angle">Angle</param> /// <returns>Brush</returns> internal static Brush GetBevelTopBrush(Brush brush, Double angle) { if (brush != null) { if (typeof(SolidColorBrush).Equals(brush.GetType())) { SolidColorBrush solidBrush = brush as SolidColorBrush; Double r, g, b; List<Color> colors = new List<Color>(); List<Double> stops = new List<Double>(); r = ((double)solidBrush.Color.R / (double)255) * 0.9999; g = ((double)solidBrush.Color.G / (double)255) * 0.9999; b = ((double)solidBrush.Color.B / (double)255) * 0.9999; colors.Add(Graphics.GetLighterColor(solidBrush.Color, 0.99)); stops.Add(0); colors.Add(Graphics.GetLighterColor(solidBrush.Color, 1 - r, 1 - g, 1 - b)); stops.Add(0.2); colors.Add(Graphics.GetLighterColor(solidBrush.Color, 1 - r, 1 - g, 1 - b)); stops.Add(0.6); colors.Add(Graphics.GetLighterColor(solidBrush.Color, 0.99)); stops.Add(1); return Graphics.CreateLinearGradientBrush(angle, new Point(0, 0.5), new Point(1, 0.5), colors, stops); } else { return brush; } } else return null; }
/// <summary> /// Creates and returns a brush intensity /// </summary> /// <param name="brush">Brush</param> /// <returns>Double</returns> public static Double GetBrushIntensity(Brush brush) { Color color = new Color(); Double intensity = 0; if (brush == null) return 1; if (brush.GetType().Name == "SolidColorBrush") { color = (brush as SolidColorBrush).Color; intensity = (Double)(color.R + color.G + color.B) / (3 * 255); } else if (brush.GetType().Name == "LinearGradientBrush" || brush.GetType().Name == "RadialGradientBrush") { foreach (GradientStop grad in (brush as GradientBrush).GradientStops) { color = grad.Color; intensity += (Double)(color.R + color.G + color.B) / (3 * 255); } intensity /= (brush as GradientBrush).GradientStops.Count; } else { intensity = 1; } return intensity; }
/// <summary> /// Creates and returns a Back face brush /// </summary> /// <param name="brush">Brush</param> /// <returns>Brush</returns> internal static Brush GetFrontFaceBrush(Brush brush) { if (brush != null) { if (typeof(SolidColorBrush).Equals(brush.GetType())) { SolidColorBrush solidBrush = brush as SolidColorBrush; if (_3dLightingFrontBrushs.ContainsKey(solidBrush.Color)) return _3dLightingFrontBrushs[solidBrush.Color]; else { List<Color> colors = new List<Color>(); List<Double> stops = new List<Double>(); colors.Add(Graphics.GetDarkerColor(solidBrush.Color, 0.65)); stops.Add(0); colors.Add(Graphics.GetLighterColor(solidBrush.Color, 0.55)); stops.Add(1); brush = Graphics.CreateLinearGradientBrush(-90, new Point(0, 0.5), new Point(1, 0.5), colors, stops); _3dLightingFrontBrushs.Add(solidBrush.Color, brush); return brush; } } else { return brush; } } else return null; }
/// <summary> /// Creates and returns a Back face brush /// </summary> /// <param name="brush">Brush</param> /// <returns>Brush</returns> internal static Brush GetFrontFaceBrush(Brush brush) { if (brush != null) { if (typeof(SolidColorBrush).Equals(brush.GetType())) { SolidColorBrush solidBrush = brush as SolidColorBrush; if (_3dLightingFrontBrushs.ContainsKey(solidBrush.Color)) { #if WPF if (System.Threading.Thread.CurrentThread.IsBackground) { brush = GetFrontFaceGradientBrush(solidBrush); if (_3dLightingFrontBrushs.ContainsKey(solidBrush.Color)) _3dLightingFrontBrushs[solidBrush.Color] = brush; else _3dLightingFrontBrushs.Add(solidBrush.Color, brush); return brush; } #endif return _3dLightingFrontBrushs[solidBrush.Color]; } else { brush = GetFrontFaceGradientBrush(solidBrush); _3dLightingFrontBrushs.Add(solidBrush.Color, brush); return brush; } } else { return brush; } } else return null; }
/// <summary> /// Creates and returns a right face brush /// </summary> /// <param name="brush">Brush</param> /// <returns>Brush</returns> internal static Brush GetRightFaceBrush(Brush brush) { if (brush != null) { if (typeof(SolidColorBrush).Equals(brush.GetType())) { SolidColorBrush solidBrush = brush as SolidColorBrush; if (_3dLightingRightBrushs.ContainsKey(solidBrush.Color)) { #if WPF if (System.Threading.Thread.CurrentThread.IsBackground) { brush = GetRightFaceGradientBrush(solidBrush); if (_3dLightingRightBrushs.ContainsKey(solidBrush.Color)) _3dLightingRightBrushs[solidBrush.Color] = brush; else _3dLightingRightBrushs.Add(solidBrush.Color, brush); return brush; } #endif return _3dLightingRightBrushs[solidBrush.Color]; } else { brush = GetRightFaceGradientBrush(solidBrush); _3dLightingRightBrushs.Add(solidBrush.Color, brush); return brush; } } else if (brush is GradientBrush) { GradientBrush gradBrush = brush as GradientBrush; List<Color> colors = new List<Color>(); List<Double> stops = new List<Double>(); foreach (GradientStop gradStop in gradBrush.GradientStops) { colors.Add(Graphics.GetDarkerColor(gradStop.Color, 0.75)); stops.Add(gradStop.Offset); } if (brush is LinearGradientBrush) return Graphics.CreateLinearGradientBrush(0, new Point(0, 1), new Point(1, 0), colors, stops); else return Graphics.CreateRadialGradientBrush(colors, stops); } else { return brush; } } else return null; }
/// <summary> /// Returns curved bevel brush /// </summary> /// <param name="brush">Brush</param> /// <param name="angle">Angle as Double</param> /// <param name="shade">Shade as DoubleCollection</param> /// <param name="offset">Offset as DoubleCollection</param> /// <returns>Brush</returns> internal static Brush GetCurvedBevelBrush(Brush brush, Double angle, DoubleCollection shade, DoubleCollection offset) { if (typeof(SolidColorBrush).Equals(brush.GetType())) { SolidColorBrush solidBrush = brush as SolidColorBrush; List<Color> colors = new List<Color>(); List<Double> stops = new List<double>(); for (Int32 i = 0; i < shade.Count; i++) { Color newShade = (shade[i] < 0 ? Graphics.GetDarkerColor(solidBrush.Color, Math.Abs(shade[i])) : Graphics.GetLighterColor(solidBrush.Color, Math.Abs(shade[i]))); colors.Add(newShade); } for (Int32 i = 0; i < offset.Count; i++) { stops.Add(offset[i]); } return Graphics.CreateLinearGradientBrush(angle, new Point(0, 0.5), new Point(1, 0.5), colors, stops); } else { return brush; } }
/// <summary> /// Get darker color for Radar series /// </summary> /// <param name="seriesColor"></param> /// <returns></returns> private static Brush GetDarkerColor(Brush seriesColor) { if (seriesColor != null && seriesColor.GetType().Equals(typeof(SolidColorBrush))) { Double intensity = Graphics.GetBrushIntensity(seriesColor); Color color = Graphics.GetDarkerColor(Color.FromArgb((Byte)255, (seriesColor as SolidColorBrush).Color.R, (seriesColor as SolidColorBrush).Color.G, (seriesColor as SolidColorBrush).Color.B), intensity); Brush newBrush = Graphics.CreateSolidColorBrush(color); return newBrush; } else return seriesColor; }
private static string MapBrush(string attribute, Brush brush) { var scb = brush as SolidColorBrush; if (scb == null) { throw new NotSupportedException("Brush not supported:" + brush.GetType().FullName); } var color = scb.Color; return MapColor(attribute, color); }
public static string ToImageString(this IHtmlValueConverter converter, Brush brush) { if (brush is LinearGradientBrush) { return converter.ToImageString((LinearGradientBrush)brush); } if (brush is RadialGradientBrush) { return converter.ToImageString((RadialGradientBrush)brush); } if (brush is ImageBrush) { return converter.ToImageString((ImageBrush)brush); } throw new Granular.Exception("Unexpected brush type \"{0}\"", brush.GetType()); }