C# Core.Color类代码示例

        /// <summary>
        /// Initializes a new instance of the <see cref="Custom" /> struct with
        /// a default color for each LED.
        /// </summary>
        /// <param name="color">The color to set each LED to initially.</param>
        public Custom(Color color)
        {
            Colors = new Color[Constants.MaxLeds];

            for (var i = 0; i < Colors.Length; i++)
                Colors[i] = color;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="Breathing" /> struct.
 /// </summary>
 /// <param name="led">The LED on which to apply the effect.</param>
 /// <param name="type">The type of breathing effect to create.</param>
 /// <param name="first">The initial <see cref="Color" /> to use.</param>
 /// <param name="second">The second color.</param>
 public Breathing(Led led, BreathingType type, Color first, Color second)
 {
     Led = led;
     Type = type;
     First = first;
     Second = second;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Reactive" /> struct.
 /// </summary>
 /// <param name="duration">Effect duration.</param>
 /// <param name="color">Effect color.</param>
 /// <param name="parameter">Additional effect parameter.</param>
 public Reactive(Duration duration, Color color, int parameter = 0)
 {
     Duration = duration;
     Color = color;
     Parameter = parameter;
     Size = Marshal.SizeOf(typeof(Reactive));
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Breathing" /> struct.
 /// </summary>
 /// <param name="type">The type of breathing effect to create.</param>
 /// <param name="first">Primary effect color.</param>
 /// <param name="second">Secondary effect color.</param>
 /// <param name="parameter">Additional effect parameter to set.</param>
 public Breathing(BreathingType type, Color first, Color second, int parameter = 0)
 {
     Type = type;
     First = first;
     Second = second;
     Parameter = parameter;
     Size = Marshal.SizeOf(typeof(Breathing));
 }

 public AnimatedKey(Key key, Color color)
 {
     this.razerKey = key;
     this.color = color;
     this.red = color.R;
     this.green = color.G;
     this.blue = color.B;
     this.alpha = color.A;
 }

        public void ShouldConstructFromSystemColor()
        {
            var source = System.Drawing.Color.FromArgb(5, 10, 15);
            var coloreColor = new Color(source);

            Assert.AreEqual(source.R, coloreColor.R);
            Assert.AreEqual(source.G, coloreColor.G);
            Assert.AreEqual(source.B, coloreColor.B);
        }

        public void ShouldConstructFromRgb()
        {
            var expected = new Color(0x123456);
            var actual = Color.FromRgb(0x563412);

            Assert.AreEqual(expected.Value, actual.Value);
            Assert.AreEqual(expected.R, actual.R);
            Assert.AreEqual(expected.G, actual.G);
            Assert.AreEqual(expected.B, actual.B);
        }

 public void ShouldConvertRgbBytesCorrectly()
 {
     const uint V = 0x00FFFFFF;
     const byte R = 255;
     const byte G = 255;
     const byte B = 255;
     var c = new Color(R, G, B);
     Assert.AreEqual(c.Value, V);
     Assert.AreEqual(c.R, R);
     Assert.AreEqual(c.G, G);
     Assert.AreEqual(c.B, B);
 }

 public void ShouldConvertRgbDoublesCorrectly()
 {
     const uint V = 0x00FFFFFF;
     const double R = 1.0;
     const double G = 1.0;
     const double B = 1.0;
     const byte Expected = 255;
     var c = new Color(R, G, B);
     Assert.AreEqual(c.Value, V);
     Assert.AreEqual(c.R, Expected);
     Assert.AreEqual(c.G, Expected);
     Assert.AreEqual(c.B, Expected);
 }

        private Color getNewColor(Color color)
        {
            var magicNumber = 255;
            var darkenedColor = darkenColor((int)red, (int)green, (int)blue);
            red = darkenedColor[0];
            green = darkenedColor[1];
            blue = darkenedColor[2];
            //temporarily not touching alpha, as it doesn't work at all.
            //Yet.
            alpha = color.A;

            return new Color(red / magicNumber, green / magicNumber, blue / magicNumber, alpha);
        }

 public void ShouldConvertRgbBytesCorrectly()
 {
     const uint V = 0x8056F5C8;
     const byte R = 200;
     const byte G = 245;
     const byte B = 86;
     const byte A = 128;
     var c = new Color(R, G, B, A);
     Assert.AreEqual(c.Value, V);
     Assert.AreEqual(c.R, R);
     Assert.AreEqual(c.G, G);
     Assert.AreEqual(c.B, B);
     Assert.AreEqual(c.A, A);
 }

 public void ShouldConvertRgbDoublesCorrectly()
 {
     const uint V = 0x7F3D89CC;
     const double R = 0.8;
     const double G = 0.54;
     const double B = 0.24;
     const double A = 0.5;
     const byte ExpectedR = (byte)(R * 255);
     const byte ExpectedG = (byte)(G * 255);
     const byte ExpectedB = (byte)(B * 255);
     const byte ExpectedA = (byte)(A * 255);
     var c = new Color(R, G, B, A);
     Assert.AreEqual(c.Value, V);
     Assert.AreEqual(c.R, ExpectedR);
     Assert.AreEqual(c.G, ExpectedG);
     Assert.AreEqual(c.B, ExpectedB);
     Assert.AreEqual(c.A, ExpectedA);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Breathing" /> struct using
 /// the <see cref="BreathingType.Two" /> breathing type.
 /// </summary>
 /// <param name="first">Initial color.</param>
 /// <param name="second">Second color.</param>
 public Breathing(Color first, Color second)
     : this(BreathingType.Two, first, second)
 {
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Breathing" /> struct.
 /// </summary>
 /// <param name="color">The color to set.</param>
 public Breathing(Color color)
 {
     Color = color;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Static" /> struct.
 /// </summary>
 /// <param name="color">Color to set.</param>
 public Static(Color color)
 {
     Color = color;
 }