Cabinet.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Serialization;
using System.Reflection;
using System.IO;
using DirectOutput.FX;
using DirectOutput.Cab.Out.LW;
using DirectOutput.Cab.Toys;
using DirectOutput.Cab.Out;
using DirectOutput.Cab.Toys.LWEquivalent;
using DirectOutput.Cab.Color;


namespace DirectOutput.Cab
{
    public class Cabinet
    {
        public void AutoConfig()
        {
            Log.Write("Cabinet auto configuration started");

            General.TypeList Types = new General.TypeList(AppDomain.CurrentDomain.GetAssemblies().ToList().SelectMany(s => s.GetTypes()).Where(p => typeof(IAutoConfigOutputController).IsAssignableFrom(p) && !p.IsAbstract));
            foreach (Type T in Types)
            {
                IAutoConfigOutputController AutoConfig = (IAutoConfigOutputController)Activator.CreateInstance(T);
                AutoConfig.AutoConfig(this);
            }



            Log.Write("Cabinet auto configuration finished");
        }



        #region Properties






        [XmlIgnore]
        public Pinball Pinball { get; private set; }

        [XmlElementAttribute(Order = 1)]
        public string Name { get; set; }

        [XmlIgnoreAttribute]
        public string CabinetConfigurationFilename { get; set; }

        private Toys.ToyList _Toys;

        [XmlElementAttribute(Order = 3)]
        public DirectOutput.Cab.Toys.ToyList Toys
        {
            get { return _Toys; }
            set { _Toys = value; }

        }






        private DirectOutput.Cab.Color.ColorList _Colors;

        [XmlElementAttribute(Order = 4)]
        public DirectOutput.Cab.Color.ColorList Colors
        {
            get { return _Colors; }
            set { _Colors = value; }
        }


        private bool _AutoConfigEnabled=true;
        [XmlElementAttribute(Order = 5)]
        public bool AutoConfigEnabled
        {
            get { return _AutoConfigEnabled; }
            set { _AutoConfigEnabled = value; }
        }
        

        private CabinetOutputList _Outputs;
        [XmlIgnoreAttribute]
        public CabinetOutputList Outputs
        {
            get
            {
                return _Outputs;

            }
        }

        private Out.OutputControllerList _OutputControllers;

        [XmlElementAttribute(Order = 2)]
        public Out.OutputControllerList OutputControllers
        {
            get { return _OutputControllers; }
            set { _OutputControllers = value; }
        }
        #endregion

        #region Serialization

        public string GetConfigXml()
        {
            string Xml = "";
            using (MemoryStream ms = new MemoryStream())
            {
                new XmlSerializer(typeof(Cabinet)).Serialize(ms, this);
                ms.Position = 0;
                using (StreamReader sr = new StreamReader(ms, Encoding.Default))
                {
                    Xml = sr.ReadToEnd();
                    sr.Dispose();
                }
            }

            return Xml;
        }


        public void SaveConfigXmlFile(string FileName)
        {
            GetConfigXml().WriteToFile(FileName);
        }


        public static Cabinet GetCabinetFromConfigXmlFile(string FileName)
        {
            string Xml;
            try
            {
                Xml = General.FileReader.ReadFileToString(FileName);
            }
            catch (Exception E)
            {
                Log.Exception("Could not load cabinet config from {0}.".Build(FileName), E);
                throw new Exception("Could not read cabinet config file {0}.".Build(FileName), E);
            }

            return GetCabinetFromConfigXml(Xml);
        }


        public static bool TestCabinetConfigXmlFile(string FileName)
        {
            Cabinet C = null;
            try
            {
                C = GetCabinetFromConfigXmlFile(FileName);
            }
            catch
            {
                return false;
            }
            return C != null;

        }

        public static Cabinet GetCabinetFromConfigXmlFile(FileInfo CabinetConfigFile)
        {
            return GetCabinetFromConfigXmlFile(CabinetConfigFile.FullName);
        }

        public static Cabinet GetCabinetFromConfigXml(string ConfigXml)
        {
            byte[] xmlBytes = Encoding.Default.GetBytes(ConfigXml);
            using (MemoryStream ms = new MemoryStream(xmlBytes))
            {
                try
                {
                    return (Cabinet)new XmlSerializer(typeof(Cabinet)).Deserialize(ms);
                }
                catch (Exception E)
                {
                    
                    Exception Ex = new Exception("Could not deserialize the cabinet config from XML data.", E);
                    Ex.Data.Add("XML Data", ConfigXml);
                    Log.Exception("Could not load cabinet config from XML data.", Ex);
                    throw Ex;
                }
            }
        }
        #endregion


        public void Init(Pinball Pinball)
        {
            Log.Write("Initializing cabinet");
            this.Pinball = Pinball;
            OutputControllers.Init(this);
            Toys.Init(this);
    
            Log.Write("Cabinet initialized");
        }


        public void Update()
        {
            Toys.UpdateOutputs();
            OutputControllers.Update();
        }



        public void Finish()
        {
            Log.Write("Finishing cabinet");

            Toys.Finish();
            OutputControllers.Finish();
            Log.Write("Cabinet finished");
        }



        #region Constructor



        public Cabinet()
        {
            _OutputControllers = new Out.OutputControllerList();
            _Outputs = new CabinetOutputList(this);
            _Toys = new Toys.ToyList();
            _Colors = new ColorList();
        }
        #endregion

    }
}