Table.cs

Go to the documentation of this file.

using System;
using System.IO;
using System.Text;
using System.Xml.Serialization;
using DirectOutput.FX;


namespace DirectOutput.Table
{

    public class Table
    {
        #region Properties




        public TableElementList TableElements { get; set; }

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


        #region TableName
        private string _TableName;
        public string TableName
        {
            get { return _TableName; }
            set
            {
                if (_TableName != value)
                {
                    _TableName = value;
                    if (TableNameChanged != null)
                    {
                        TableNameChanged(this, new EventArgs());
                    }
                }
            }
        }
        public event EventHandler<EventArgs> TableNameChanged;
        #endregion

        #region RomName
        private string _RomName;
        [XmlIgnoreAttribute]
        public string RomName
        {
            get { return _RomName; }
            set
            {
                if (_RomName != value)
                {
                    _RomName = value;
                    if (RomNameChanged != null)
                    {
                        RomNameChanged(this, new EventArgs());
                    }
                }
            }
        }
        public event EventHandler<EventArgs> RomNameChanged;
        #endregion

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

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


        private bool _AddLedControlConfig=false;

        public bool AddLedControlConfig
        {
            get { return _AddLedControlConfig; }
            set { _AddLedControlConfig = value; }
        }
        

        private TableConfigSourceEnum _ConfigurationSource=TableConfigSourceEnum.Unknown;

        [XmlIgnoreAttribute]
        public TableConfigSourceEnum ConfigurationSource
        {
            get { return _ConfigurationSource; }
            set { _ConfigurationSource = value; }
        }
        

        

        private EffectList _Effects;
        public EffectList Effects
        {
            get { return _Effects; }
            set { _Effects = value; }
        }

        private AssignedEffectList _AssignedStaticEffects;
        public AssignedEffectList AssignedStaticEffects
        {
            get
            {
                return _AssignedStaticEffects;
            }
            set
            {
                _AssignedStaticEffects = value;
            }
        }

        #endregion




        public void UpdateTableElement(TableElementData Data)
        {
            TableElements.UpdateState(Data.TableElementType, Data.Number, Data.Value);
        }


        public void TriggerStaticEffects()
        {
            AssignedStaticEffects.Trigger(new TableElementData(TableElementTypeEnum.Unknown,0,1));
        }

        public void Init(Pinball Pinball)
        {
            this.Pinball = Pinball;
            Effects.Init(this);

            TableElements.InitAssignedEffects(this);
            AssignedStaticEffects.Init(this);
        }

        public void Finish()
        {
            AssignedStaticEffects.Finish();
            TableElements.FinishAssignedEffects();
            Effects.Finish();
            Pinball = null;
        }


        #region Serialization

        public string GetConfigXml()
        {
            string Xml = "";
            using (MemoryStream ms = new MemoryStream())
            {
                new XmlSerializer(typeof(Table)).Serialize(ms, this);
                ms.Position = 0;

                using (StreamReader sr = new StreamReader(ms, Encoding.Default))
                {
                    Xml = sr.ReadToEnd();
                   
                }
                
            }
            return Xml;
        }


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


        public static Table GetTableFromConfigXmlFile(string FileName)
        {
            string Xml;

            try
            {
                 Xml = General.FileReader.ReadFileToString(FileName);

                

            }
            catch (Exception E)
            {
                Log.Exception("Could not read Table Config file {0}".Build(FileName), E);
                throw new Exception("Could not read Table Config file {0}".Build(FileName), E);
            }
            return GetTableFromConfigXml(Xml);
        }

        public static Table GetTableFromConfigXmlFile(FileInfo TableConfigFile)
        {
            return GetTableFromConfigXmlFile(TableConfigFile.FullName);
        }

        public static Table GetTableFromConfigXml(string ConfigXml)
        {

            try
            {
                byte[] xmlBytes = Encoding.Default.GetBytes(ConfigXml);
                using (MemoryStream ms = new MemoryStream(xmlBytes))
                {
                    Table T = (Table)new XmlSerializer(typeof(Table)).Deserialize(ms);
                    T.ConfigurationSource = TableConfigSourceEnum.TableConfigurationFile;
                    return T;
                }
            }
            catch (Exception E)
            {
                
               Exception Ex= new Exception("Could not deserialize Table config from XML Data",E);
               Ex.Data.Add("XMLData", ConfigXml);
               Log.Exception(Ex);
               throw Ex;
            }
        }
        #endregion



        public Table()
        {
            Effects = new FX.EffectList();
            TableElements = new TableElementList();
            AssignedStaticEffects = new AssignedEffectList();
        }



    }
}