AnalogAlphaToy.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DirectOutput.Cab.Out;
using DirectOutput.General;
using System.Xml.Serialization;
using DirectOutput.General.Analog;

namespace DirectOutput.Cab.Toys.Layer
{
    public class AnalogAlphaToy : ToyBaseUpdatable, IAnalogAlphaToy, ISingleOutputToy
    {

        [XmlIgnore]
        public LayerDictionary<AnalogAlpha> Layers { get; private set; }

        protected int GetResultingValue()
        {
            if (Layers.Count > 0)
            {
                float Value = 0;

                foreach (KeyValuePair<int, AnalogAlpha> KV in Layers)
                {
                    int Alpha = KV.Value.Alpha;
                    if (Alpha != 0)
                    {
                        Value = AlphaMappingTable.AlphaMapping[255 - Alpha, (int)Value] + AlphaMappingTable.AlphaMapping[Alpha, KV.Value.Value];
                    }
                }

                return (int)Value;
            }
            else
            {
                return 0;
            }
        }


        #region Outputs

        [XmlIgnore]
        protected IOutput Output;


        public string OutputName { get; set; }


        #endregion

        #region Fading curve
        private string _FadingCurveName = "Linear";
        [XmlIgnore]
        protected Curve FadingCurve = null;

        public string FadingCurveName
        {
            get { return _FadingCurveName; }
            set { _FadingCurveName = value; }
        }

        private void InitFadingCurve(Cabinet Cabinet)
        {
            if (Cabinet.Curves.Contains(FadingCurveName))
            {
                FadingCurve = Cabinet.Curves[FadingCurveName];
            }
            else if (!FadingCurveName.IsNullOrWhiteSpace())
            {
                if (Enum.GetNames(typeof(Curve.CurveTypeEnum)).Contains(FadingCurveName))
                {
                    Curve.CurveTypeEnum T = Curve.CurveTypeEnum.Linear;
                    Enum.TryParse(FadingCurveName, out T);
                    FadingCurve = new Curve(T);
                }
                else
                {
                    FadingCurve = new Curve(Curve.CurveTypeEnum.Linear) { Name = FadingCurveName };
                    Cabinet.Curves.Add(FadingCurveName);
                }
            }
            else
            {
                FadingCurve = new Curve(Curve.CurveTypeEnum.Linear);
            }

        }
        #endregion



        [XmlIgnore]
        protected Cabinet Cabinet;


        public override void Init(Cabinet Cabinet)
        {
            this.Cabinet = Cabinet;
            InitOutputs(Cabinet);
            InitFadingCurve(Cabinet);
        }

        private void InitOutputs(Cabinet Cabinet)
        {
            if (Cabinet.Outputs.Contains(OutputName))
            {
                Output = Cabinet.Outputs[OutputName];
            }
            else
            {
                Output = null;
            }
        }




        public override void UpdateOutputs()
        {
            if (Output != null)
            {
       
                Output.Value = FadingCurve.MapValue(GetResultingValue());
            }
        }


        public override void Finish()
        {
            Reset();
            Output = null;
            Cabinet = null;
            base.Finish();
        }

        public override void Reset()
        {
            Layers.Clear();
            if (Output != null)
            {
                Output.Value = 0;
            }
        }

        public AnalogAlphaToy()
        {
            Layers = new LayerDictionary<AnalogAlpha>();
        }
    }
}