Table.cs

Go to the documentation of this file.

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

using DirectOutput.General.BitmapHandling;
using DirectOutput.FX.MatrixFX.BitmapShapes;


namespace DirectOutput.Table
{

    public class Table
    {
        #region Properties
        public TableElementList TableElements { get; set; }

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


        private FastImageList _Bitmaps = new FastImageList();

        [XmlIgnoreAttribute]
        public FastImageList Bitmaps
        {
            get { return _Bitmaps; }
            private set { _Bitmaps = value; }
        }

        private ShapeDefinitions _ShapeDefinitions;

        [XmlIgnore]
        public ShapeDefinitions ShapeDefinitions
        {
            get { return _ShapeDefinitions; }
            set { _ShapeDefinitions = value; }
        }







        #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);
        }


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

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

            FileInfo ShapeDefinitionFile = Pinball.GlobalConfig.GetShapeDefinitionFile();
            if (ShapeDefinitionFile != null && ShapeDefinitionFile.Exists)
            {
                Log.Write("Loading shape definition file: {0}".Build(ShapeDefinitionFile.FullName));
                try
                {
                    ShapeDefinitions = ShapeDefinitions.GetShapeDefinitionsFromShapeDefinitionsXmlFile(ShapeDefinitionFile);
                }
                catch (Exception E)
                {
                    Log.Exception("Loading shape definition file {0} failed.".Build(ShapeDefinitionFile.FullName), E);
                }
                ShapeDefinitions.BitmapFilePattern = new General.FilePattern(ShapeDefinitionFile.FullName.Substring(0, ShapeDefinitionFile.FullName.Length - ShapeDefinitionFile.Extension.Length) + ".png");
            }
            else
            {
                if (ShapeDefinitionFile == null)
                {
                    Log.Warning("Could not determin name of shape definition file");
                }
                else
                {
                    Log.Warning("Shape definition file {0} does not exist");
                }
                ShapeDefinitions = new ShapeDefinitions();
            }

            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();
        }



    }
}