LedControlConfig.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Linq;

namespace DirectOutput.LedControl.Loader
{
    public class LedControlConfig
    {
        private int _LedWizNumber = 0;

        public int LedWizNumber
        {
            get { return _LedWizNumber; }
            set { _LedWizNumber = value; }
        }

        public Version MinDOFVersion { get; set; }



        private TableConfigList _TableConfigurations;

        public TableConfigList TableConfigurations
        {
            get { return _TableConfigurations; }
            set { _TableConfigurations = value; }
        }

        private ColorConfigList _ColorConfigurations;

        public ColorConfigList ColorConfigurations
        {
            get { return _ColorConfigurations; }
            set { _ColorConfigurations = value; }
        }


        private FileInfo _LedControlIniFile;

        public FileInfo LedControlIniFile
        {
            get { return _LedControlIniFile; }
            private set { _LedControlIniFile = value; }
        }






        private void ParseLedControlIni(FileInfo LedControlIniFile, bool ThrowExceptions = false)
        {
            string[] ColorStartStrings = { "[Colors DOF]", "[Colors LedWiz]" };
            string[] OutStartStrings = { "[Config DOF]", "[Config outs]" };
            string[] VariableStartStrings = { "[Variables DOF]" };
            string[] VersionStartStrings = { "[version]" };
            string[] TableVariableStartStrings = { "[TableVariables]" }; ;
            string FileData = "";

            #region Read file
            try
            {
                FileData = General.FileReader.ReadFileToString(LedControlIniFile);
            }
            catch (Exception E)
            {
                Log.Exception("Could not read file {0}.".Build(LedControlIniFile), E);
                if (ThrowExceptions)
                {

                    throw new Exception("Could not read file {0}.".Build(LedControlIniFile), E);
                }
            }
            if (FileData.IsNullOrWhiteSpace())
            {
                Log.Warning("File {0} does not contain data.".Build(LedControlIniFile));
                if (ThrowExceptions)
                {
                    throw new Exception("File {0} does not contain data.".Build(LedControlIniFile));
                }
            }
            #endregion

            Dictionary<string, List<string>> Sections = new Dictionary<string, List<String>>();

            #region Read sections

            List<string> SectionData = new List<string>();
            String SectionHeader = null;
            foreach (string RawIniLine in FileData.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries))
            {
                string IniLine = RawIniLine.Trim();
                if (IniLine.Length > 0 && !IniLine.StartsWith("#"))
                {
                    if (IniLine.StartsWith("[") && IniLine.EndsWith("]") && IniLine.Length > 2)
                    {
                        //This is a section header
                        if (!SectionHeader.IsNullOrWhiteSpace())
                        {
                            if (Sections.ContainsKey(SectionHeader))
                            {
                                int Cnt = 2;
                                while (Sections.ContainsKey("{0} {1}".Build(SectionHeader, Cnt)))
                                {
                                    Cnt++;
                                    if (Cnt > 999) { throw new Exception("Section header {0} exists to many times.".Build(SectionHeader)); }
                                }
                                SectionHeader = "{0} {1}".Build(SectionHeader, Cnt);
                            }
                            Sections.Add(SectionHeader, SectionData);
                            SectionData = new List<string>();
                        }
                        SectionHeader = IniLine;
                    }
                    else
                    {
                        //Its a data line
                        SectionData.Add(IniLine);
                    }
                }
            }

            if (!SectionHeader.IsNullOrWhiteSpace())
            {
                if (Sections.ContainsKey(SectionHeader))
                {
                    int Cnt = 2;
                    while (Sections.ContainsKey("{0} {1}".Build(SectionHeader, Cnt)))
                    {
                        Cnt++;
                        if (Cnt > 999) { throw new Exception("Section header {0} exists to many times.".Build(SectionHeader)); }
                    }
                    SectionHeader = "{0} {1}".Build(SectionHeader, Cnt);
                }
                Sections.Add(SectionHeader, SectionData);
                SectionData = new List<string>();
            }
            SectionData = null;
            #endregion

            FileData = null;

            List<string> ColorData = GetSection(Sections, ColorStartStrings);
            List<string> OutData = GetSection(Sections, OutStartStrings);
            List<string> VariableData = GetSection(Sections, VariableStartStrings);
            List<string> VersionData = GetSection(Sections, VersionStartStrings);
            List<string> TableVariableData = GetSection(Sections, TableVariableStartStrings);

            if (VersionData != null && VersionData.Count > 0)
            {
                MinDOFVersion = null;

                string MinDofVersionLine = VersionData.FirstOrDefault(S => S.ToLowerInvariant().StartsWith("mindofversion="));

                if (MinDofVersionLine != null)
                {
                    string MinDofVersionString = MinDofVersionLine.Substring("mindofversion=".Length);

                    try
                    {
                        MinDOFVersion = new Version(MinDofVersionString);
                    }
                    catch (Exception E)
                    {
                        Log.Exception("Could not parse line {1} from file {0}".Build(LedControlIniFile, MinDofVersionLine));
                        MinDOFVersion = null;
                    }

                }
                else
                {
                    Log.Warning("No DOF version information found in file {0}.".Build(LedControlIniFile));
                }

            }
            else
            {
                Log.Warning("No version section found in file {0}.".Build(LedControlIniFile));
            }

            if (ColorData == null)
            {
                Log.Warning("Could not find color definition section in file {0}.".Build(LedControlIniFile));
                if (ThrowExceptions)
                {
                    throw new Exception("Could not find  color definition section in file {0}.".Build(LedControlIniFile));
                }
                return;
            }
            else if (ColorData.Count < 1)
            {
                Log.Warning("File {0} does not contain data in the color definition section.".Build(LedControlIniFile));
                if (ThrowExceptions)
                {
                    throw new Exception("File {0} does not contain data in the color definition section.".Build(LedControlIniFile));
                }
                return;
            }

            if (OutData == null)
            {
                Log.Warning("Could not find table config section in file {0}.".Build(LedControlIniFile));
                if (ThrowExceptions)
                {
                    throw new Exception("Could not find table config section section in file {1}.".Build(LedControlIniFile));
                }
                return;
            }
            else if (OutData.Count < 1)
            {
                Log.Warning("File {0} does not contain data in the table config section.".Build(LedControlIniFile));
                if (ThrowExceptions)
                {
                    throw new Exception("File {0} does not contain data in the table config section".Build(LedControlIniFile));
                }
                return;
            }

            if (VariableData != null)
            {
                ResolveVariables(OutData, VariableData);
            }

            if (TableVariableData != null)
            {
                ResolveTableVariables(OutData, TableVariableData);
            }



            ColorConfigurations.ParseLedControlData(ColorData, ThrowExceptions);

            TableConfigurations.ParseLedcontrolData(OutData, ThrowExceptions);

            //ResolveOutputNumbers();
            ResolveRGBColors();

            this.LedControlIniFile = LedControlIniFile;
        }

        private List<string> GetSection(Dictionary<string, List<string>> Sections, IEnumerable<string> SectionStartStrings)
        {
            foreach (string StartString in SectionStartStrings)
            {
                if (Sections.ContainsKey(StartString))
                {
                    return Sections[StartString];
                }
            }

            return null;
        }


        private void ResolveTableVariables(List<String> DataToResolve, List<string> VariableData)
        {

            TableVariablesDictionary VD = new TableVariablesDictionary(VariableData);


            for (int i = 0; i < DataToResolve.Count - 1; i++)
            {
                string D = DataToResolve[i].Trim();
                bool Updated = false;
                if (!D.IsNullOrWhiteSpace())
                {
                    int TP = D.IndexOf(",");
                    if (TP > 0)
                    {
                        string TableName = D.Substring(0, TP).Trim();
                        if (VD.ContainsKey(TableName))
                        {
                            foreach (KeyValuePair<string, string> KV in VD[TableName])
                            {
                                string N = KV.Key;
                                if (!N.StartsWith("@")) N = "@" + N;
                                if (!N.EndsWith("@")) N += "@";
                                D = D.Replace(N, KV.Value);
                                Updated = true;
                            }
                        }
                    }

                }
                if (Updated)
                {
                    DataToResolve[i] = D;
                   
                }
            }

        }


        private void ResolveVariables(List<String> DataToResolve, List<string> VariableData)
        {
            VariablesDictionary VD = new VariablesDictionary(VariableData);
            foreach (KeyValuePair<string, string> KV in VD)
            {
                string N = KV.Key;
                if (!N.StartsWith("@")) N = "@" + N;
                if (!N.EndsWith("@")) N += "@";

                for (int i = 0; i < DataToResolve.Count - 1; i++)
                {
                    DataToResolve[i] = DataToResolve[i].Replace(N, KV.Value);
                }
            }

        }

        private void ResolveRGBColors()
        {

            foreach (TableConfig TC in TableConfigurations)
            {
                foreach (TableConfigColumn C in TC.Columns)
                {
                    foreach (TableConfigSetting S in C)
                    {
                        if (ColorConfigurations.Contains(S.ColorName))
                        {
                            S.ColorConfig = ColorConfigurations[S.ColorName];

                        }
                    }
                }
            }
        }


        //private void ResolveOutputNumbers()
        //{
        //    //Get the number of required outputs per column
        //    Dictionary<int, int> RequiredOutputs = new Dictionary<int, int>();
        //    foreach (TableConfig TC in TableConfigurations)
        //    {
        //        TC.Columns.Sort();
        //        foreach (TableConfigColumn C in TC.Columns)
        //        {
        //            foreach (TableConfigSetting S in C)
        //            {
        //                int Cnt = (S.OutputType == OutputTypeEnum.RGBOutput ? 3 : 1);
        //                if (RequiredOutputs.ContainsKey(C.Number))
        //                {

        //                    if (RequiredOutputs[C.Number] < Cnt)
        //                    {
        //                        RequiredOutputs[C.Number] = Cnt;
        //                    }
        //                }
        //                else
        //                {
        //                    RequiredOutputs.Add(C.Number, Cnt);
        //                }
        //            }

        //        }

        //    }


        //    //Dump();
        //}


        //private void Dump()
        //{
        //    string A = "";
        //    foreach (TableConfig TC in TableConfigurations)
        //    {
        //        A+="Cols: {0:##}, ".Build( TC.Columns.Count);
        //        foreach (TableConfigColumn C in TC.Columns)
        //        {
        //            A+="({0:00} {1} {2:00})".Build( C.Number, C.RequiredOutputCount, C.FirstOutputNumber);
        //        }
        //        A += "\n";
        //    }
        //    A.WriteToFile("c:\\parseresult.txt");

        //}



        public LedControlConfig()
        {
            this.TableConfigurations = new TableConfigList();
            this.ColorConfigurations = new ColorConfigList();
        }

        public LedControlConfig(string LedControlIniFilename, int LedWizNumber, bool ThrowExceptions = false)
            : this()
        {
            ParseLedControlIni(new FileInfo(LedControlIniFilename), ThrowExceptions);
            this.LedWizNumber = LedWizNumber;
        }

        public LedControlConfig(FileInfo LedControlIniFile, int LedWizNumber, bool ThrowExceptions = false)
            : this()
        {
            ParseLedControlIni(LedControlIniFile, ThrowExceptions);
            this.LedWizNumber = LedWizNumber;
        }

    }
}