ComponentMgr.cs

Go to the documentation of this file.

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

namespace Seci.Managers
{
    public static class ComponentMgr
    {
        private static ComponentList _components = new ComponentList();
        public static ComponentList Components { get { return _components; } set { _components = value; } }

        public static Boolean AddComponent(String fileName)
        {
            //load a component then add it to the current config
            try
            {
                //Check component has not already been added
                for (int i = 0; i < _components.Count; ++i)
                {
                    if (fileName.ToLower().EndsWith("\\" + _components[i].ConfigName.ToLower()))
                    {
                        return false;
                    }
                }

                //load component and add it to conf
                _components.Add(Helpers.ConfigurationIO.DeserialiseConfig(fileName));

                String compName = _components[_components.Count - 1].ConfigName;

                //Set the owning name of the blocks then add to the block dictionary
                addBlocks(compName);

                //Add groups here! First time the sub-config groups will be added at the end
                //When the main config is saved the order will be saved there
                var comp = _components[_components.Count - 1];
                if (comp.Groups != null)
                {
                    for (int i = 0; i < comp.Groups.Count; ++i)
                    {
                        if (!BlockMgr.BlockGroupExists(comp.Groups[i].Name))
                        {
                            BlockMgr.Groups.Add(new Definitions.BlockGroup(comp.Groups[i].Name));
                        }
                    }
                }
                //If the comp does not contain group list (i.e. it was saved using an older version of seci)
                //then obtain the list from the blocks
                if (comp.Blocks != null)
                {
                    for (int i = 0; i < comp.Blocks.Count; ++i)
                    {
                        if (!BlockMgr.BlockGroupExists(comp.Blocks[i].Group))
                        {
                            BlockMgr.Groups.Add(new Definitions.BlockGroup(comp.Blocks[i].Group));
                        }
                    }
                }

                //Add any component tabs
                ConfigurationMgr.AddComponentTabs();

                //Add the alerts but with owning name set
                AlertsMgr.AddComponentBox(null, _components[compName].Alerts, compName);

                //Load VIs
                loadComponentVIs(compName);

                //Load Executables
                loadComponentExes(compName);

                //Load associated files
                loadAssocFiles(compName);

                //Add graphs
                addGraphs(compName);

                return true;
            }
            catch (Exception e)
            {
                //throw error up to next level
                throw new ArgumentException(e.Message);
            }
        }

        public static Boolean RemoveComponent(String compName)
        {
            try
            {
                for (int i = 0; i < _components.Count; ++i)
                {
                    if (_components[i].ConfigName == compName)
                    {
                        //Stop the updating threads
                        Seci.Managers.SeciMgr.PauseThreads();
                        System.Threading.Thread.Sleep(1000);

                        //Remove any blocks
                        if (BlockMgr.Blocks != null)
                        {
                            for (int j = BlockMgr.Blocks.Count - 1; j >= 0; --j)
                            {
                                if (!String.IsNullOrEmpty(BlockMgr.Blocks[j].OwningComponent) && BlockMgr.Blocks[j].OwningComponent.ToLower() == compName.ToLower())
                                {
                                    BlockMgr.Blocks.Remove(BlockMgr.Blocks[j].BlockName);
                                }
                            }
                        }

                        try
                        {
                            //Need to remove any VIs associated with the component to remove
                            var panels = Seci.Managers.LabViewMgr.GetAllPanelsInfo();

                            for (int j = 0; j < panels.Count; ++j)
                            {
                                //Does not actually close the VIs, they will still be in memory
                                if (panels[j].OwningComponent == compName)
                                {
                                    LabView.LabViewApp.CloseVI(panels[j].FilePath);
                                }
                            }
                        }
                        catch
                        {
                            //throw new Exception("VI");
                        }

                        //remove any executables
                        for (int j = 0; j < _components[i].Executables.Count; ++j)
                        {
                            _components[i].Executables[j].Dispose();
                            ExecutableMgr.RemoveExecutable(_components[i].Executables[j].FilePath);
                        }

                        //remove any assoc files
                        for (int j = 0; j < _components[i].AssociatedFiles.Count; ++j)
                        {
                            AssocFileMgr.RemoveFile(_components[i].AssociatedFiles[j].FileLocation);
                        }

                        //remove any graphs
                        ConfigurationMgr.RemoveComponentGraphs(compName);

                        //Then remove component
                        _components.Remove(_components[i]);

                        //Restart threads
                        Seci.Managers.SeciMgr.ResumeThreads();

                        return true;
                    }
                }
            }
            catch (Exception err)
            {
                Seci.Helpers.ErrorLogger.SeciError("RemoveComponent", err);
            }

            return false;
        }

        public static List<String> GetNames()
        {
            if (_components != null)
            {
                List<String> names = new List<String>();

                for (int i = 0; i < _components.Count; ++i)
                {
                    names.Add(_components[i].ConfigName);
                }

                return names;
            }

            return null;
        }

        private static void addBlocks(String compName)
        {
            for (int i = 0; i < _components[compName].Blocks.Count; ++i)
            {
                _components[compName].Blocks[i].OwningComponent = _components[_components.Count - 1].ConfigName;
            }
            BlockMgr.Blocks.AddDictionary(_components[compName].Blocks);
            //_components[compName].Blocks = null;
        }

        public static void LoadComponentsVisExes()
        {
            //load VIs and Exes in components
            if (_components != null)
            {
                for (int i = 0; i < _components.Count; ++i)
                {
                    loadComponentVIs(_components[i].ConfigName);
                    loadComponentExes(_components[i].ConfigName);
                    loadAssocFiles(_components[i].ConfigName);
                }
            }
        }

        private static void loadComponentVIs(String compName)
        {
            FileInfo fi;

            for (int i = 0; i < _components[compName].LVPanels.Count; ++i)
            {
                //Create a reference to the panel to load (just to make the code clearer)
                Seci.LabView.LabViewPanelInfo Panel = _components[compName].LVPanels[i];

                //Might be a .llb, check for that
                if (Panel.FilePath.Substring(0, Panel.FilePath.LastIndexOf('\\')).ToLower().EndsWith(".llb"))
                {
                    //It is a .llb, so have to remove the .vi bit when checking the file exists
                    fi = new FileInfo(Panel.FilePath.Substring(0, Panel.FilePath.LastIndexOf('\\')));
                }
                else
                {
                    //It is a .vi
                    fi = new FileInfo(Panel.FilePath);
                }

                if (fi.Exists)
                {

                    Panel.OwningComponent = compName; //Set the name for the owning config
                    if (LabView.LabViewApp.LoadVI(Panel, true))
                    {
                        //Show if necessary
                        if (Panel.ShowPanel)
                        {
                            LabView.LabViewApp.ShowVI(Panel.FilePath);
                        }

                        //Start running if necessary
                        if (Panel.StartRunning)
                        {
                            LabView.LabViewApp.StartVI(Panel.FilePath);
                        }
                    }
                }
            }
        }

        private static void loadComponentExes(String compName)
        {
            for (int i = 0; i < _components[compName].Executables.Count; ++i)
            {
                _components[compName].Executables[i].OwningComponent = compName;
                ExecutableMgr.AddExecutable(_components[compName].Executables[i]);
            }
        }

        private static void loadAssocFiles(String compName)
        {
            for (int i = 0; i < _components[compName].AssociatedFiles.Count; ++i)
            {
                _components[compName].AssociatedFiles[i].OwningComponent = compName;
                AssocFileMgr.AddFile(_components[compName].AssociatedFiles[i]);
                AssocFileMgr.RecreateFile(_components[compName].AssociatedFiles[i]);
            }
        }

        private static void addGraphs(String compName)
        {
            for (int i = 0; i < _components[compName].GraphDefinitions.Count; ++i)
            {
                _components[compName].GraphDefinitions[i].OwningComponent = compName; //Set the name for the owning config
            }

            ConfigurationMgr.AddGraphDefinitions(_components[compName].GraphDefinitions);
        }

        public static void SaveComponent(String compName)
        {
            String fileName = Definitions.Status.ConfigDir + _components[compName].ConfigName;

            //Clear out the owning config for the blocks temporarily
            for (int i = 0; i < _components[compName].Blocks.Count; ++i)
            {
                _components[compName].Blocks[i].OwningComponent = null;
            }

            //Clear out the owning config for the VIs temporarily
            for (int i = 0; i < _components[compName].LVPanels.Count; ++i)
            {
                _components[compName].LVPanels[i].OwningComponent = null;
            }

            //Saves the sub-config as xml           
            Helpers.ConfigurationIO.SaveConfig(_components[compName], false, fileName);

            //Pop the owning config back for the blocks
            for (int i = 0; i < _components[compName].Blocks.Count; ++i)
            {
                _components[compName].Blocks[i].OwningComponent = _components[compName].ConfigName;
            }

            //Pop the owning config back for the VIs
            for (int i = 0; i < _components[compName].LVPanels.Count; ++i)
            {
                _components[compName].LVPanels[i].OwningComponent = _components[compName].ConfigName;
            }
        }

    }
}