ConfigurationMgr.cs

Go to the documentation of this file.

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

namespace Seci.Managers
{
    public delegate void RemotingEventHandler(String[] vars);

    public static class ConfigurationMgr
    {
        internal static Configuration _currentConfig = new Configuration();
        public static String ConfigName { get { return _currentConfig.ConfigName; } set { _currentConfig.ConfigName = value; } }

        //private static ComponentList _components = new ComponentList();
        public static ComponentList Components { get { return ComponentMgr.Components; } set { ComponentMgr.Components = value; } }

        public static event RemotingEventHandler ConfigChangeRequested;

        public static void CreateNewConfiguration()
        {
            _currentConfig = new Configuration();

        }

        #region Save Config

        public static Boolean SaveConfiguration(Boolean manager, Boolean autoSave)
        {
            Managers.ConfigurationMgr.saveConfig(manager, autoSave);

            Seci.Helpers.MessageLogger.WriteMessage("SeciInterface", "Configuration saved: " + _currentConfig.ConfigName);

            return true;
        }

        private static void saveConfig(Boolean manager, Boolean isAutosave)
        {
            //Sort out filename
            String fileName;

            if (isAutosave)
            {
                //use different name for autosave
                fileName = Status.ConfigDir + "autosave";
            }
            else
            {
                fileName = Status.ConfigDir + _currentConfig.ConfigName;
            }

            //Get the latest panel information for saving.
            _currentConfig.LVPanels = (SerialisableList<LabView.LabViewPanelInfo>)LabView.LabViewApp.GetAllPanelsInfo().Clone();
            //Remove any panels which are part of a component
            for (int i = _currentConfig.LVPanels.Count - 1; i >= 0; --i)
            {
                if (!String.IsNullOrEmpty(_currentConfig.LVPanels[i].OwningComponent))
                {
                    _currentConfig.LVPanels.RemoveAt(i);
                    continue;
                }
            }

            //Take a copy of the graph definitions so they can be restored after saving
            SerialisableList<GraphDefinition> tempGraphs = (SerialisableList<GraphDefinition>)_currentConfig.GraphDefinitions.Clone();
            //Remove any graphs that belong to components
            for (int i = _currentConfig.GraphDefinitions.Count - 1; i >= 0; --i)
            {
                if (!String.IsNullOrEmpty(_currentConfig.GraphDefinitions[i].OwningComponent))
                {
                    _currentConfig.GraphDefinitions.RemoveAt(i);
                }
            }

            //get assoc files info for saving
            _currentConfig.AssociatedFiles = (SerialisableList<Seci.Definitions.AssociatedFile>)AssocFileMgr.AssociatedFiles.Clone();
            //Remove any assocfiles that belong to components
            for (int i = _currentConfig.AssociatedFiles.Count - 1; i >= 0; --i)
            {
                if (!String.IsNullOrEmpty(_currentConfig.AssociatedFiles[i].OwningComponent))
                {
                    _currentConfig.AssociatedFiles.RemoveAt(i);
                }
            }

            //Get the associated files bytes
            for (int i = 0; i < _currentConfig.AssociatedFiles.Count; ++i)
            {
                _currentConfig.AssociatedFiles[i].ConvertFileToByteArray();
            }

            //get exe info for saving
            _currentConfig.Executables = (SerialisableList<Seci.Definitions.Executable>)ExecutableMgr.Executables.Clone();
            //Remove any exes that belong to components
            for (int i = _currentConfig.Executables.Count - 1; i >= 0; --i)
            {
                if (!String.IsNullOrEmpty(_currentConfig.Executables[i].OwningComponent))
                {
                    _currentConfig.Executables.RemoveAt(i);
                }
            }

            //get the latest block info for saving. 
            //Any blocks from a component are automatically ignored when saved
            //see IXmlSerializable Members on BlockDictionary for details
            _currentConfig.Blocks = Managers.BlockMgr.Blocks;
            _currentConfig.Groups = Managers.BlockMgr.Groups;

            //get components info for saving
            _currentConfig.Components = Managers.ComponentMgr.Components;

            //get alerts for saving
            _currentConfig.Alerts = Managers.AlertsMgr.GetAlertsCopyForSaving();

            //Set manager status
            _currentConfig.SavedAsManager = manager;

            //Indicate that it has been saved by new Seci
            _currentConfig.OldSeciFirstTime = false;

            //Saves the current config as xml           
            Helpers.ConfigurationIO.SaveConfig(_currentConfig, isAutosave, fileName);

            //Put the graphs back the way they were
            _currentConfig.GraphDefinitions = tempGraphs;
        }

        public static Boolean OkayToSave(Boolean manager)
        {
            return Helpers.ConfigurationIO.OkayToSave(ConfigName, manager);
        }

        #endregion

        #region Open Config

        public static Boolean OpenConfiguration(String fileName)
        {
            Managers.ConfigurationMgr.openConfig(fileName);

            if (Status.UseDaeMonitorVI)
            {
                Standard.DaeMonitor.Initialise();
            }

            Seci.Helpers.MessageLogger.WriteMessage("SeciInterface", "Configuration opened: " + fileName);

            if (Seci.Definitions.Status.LogToDatabase)
            {
                Seci.Helpers.DatabaseLogger.LogConfigName(fileName.Substring(fileName.LastIndexOf('\\') + 1));

                Seci.Helpers.DatabaseLogger.WriteBlockDetails();
            }

            return true;
        }

        public static void StartVIs()
        {
            for (int i = 0; i < _currentConfig.LVPanels.Count; ++i)
            {
                if (_currentConfig.LVPanels[i].StartRunning)
                {
                    startVI(_currentConfig.LVPanels[i]);
                }
            }
        }

        private static void openConfig(String fileName)
        {
            try
            {
                //Read config file and create new configuration object
                Configuration temp = Helpers.ConfigurationIO.LoadConfig(fileName);

                //copy some stuff from the new config on to current config the rest will be sent to the associated manager
                _currentConfig.ConfigName = temp.ConfigName;
                _currentConfig.GraphDefinitions = temp.GraphDefinitions;

                //Sort out the tabs
                _currentConfig.Tabs = temp.Tabs;
                if (temp.TabOrder != null && temp.TabOrder.Count > 0 && _currentConfig.Tabs.Count == 0)
                {
                    foreach (String tab in temp.TabOrder)
                    {
                        _currentConfig.Tabs.Add(new Tab(tab, true));
                    }
                }

                //Give the alerts to the alerts manager
                AlertsMgr.SetAlerts(temp.Alerts);

                //Set the components
                ConfigurationMgr.Components = temp.Components;

                //Add any component tabs
                AddComponentTabs();

                //Set the blocks
                BlockMgr.SetBlocks(temp.Blocks);

                //Load Executables
                for (int i = 0; i < temp.Executables.Count; ++i)
                {
                    ExecutableMgr.AddExecutable(temp.Executables[i]);
                }

                //Set the assoc files
                for (int i = 0; i < temp.AssociatedFiles.Count; ++i)
                {
                    AssocFileMgr.AddFile(temp.AssociatedFiles[i]);
                    AssocFileMgr.RecreateFile(temp.AssociatedFiles[i]);
                }

                //Load VIs
                loadVIsAndInitialise(temp.LVPanels);
                ConfigurationMgr.LoadComponentsVisExes();

                //Set read types
                for (int i = 0; i < temp.Blocks.Count; ++i)
                {
                    try
                    {
                        temp.Blocks[i].ReadType = LabViewMgr.GetControlType(temp.Blocks[i].ParentVI, temp.Blocks[i].ReadControl);
                    }
                    catch (KeyNotFoundException err)
                    {
                        Helpers.ErrorLogger.SeciError("openConfig", new Exception(temp.Blocks[i].BlockName + "'s read control is invalid"));
                    }
                }

                //Remove blocks associated with VIs that where not loaded
                if (LabView.LabViewApp.VIsNotLoaded != null)
                {
                    foreach (String name in LabView.LabViewApp.VIsNotLoaded)
                    {
                        BlockMgr.Blocks.RemoveByVI(name);
                    }
                }

                //Sort out the block groups
                SerialisableList<BlockGroup> used = new SerialisableList<BlockGroup>();

                if (temp.Blocks != null)
                {
                    for (int i = 0; i < temp.Blocks.Count; ++i)
                    {
                        if (!groupExists(used, temp.Blocks[i].Group))
                        {
                            used.Add(new BlockGroup(temp.Blocks[i].Group));
                        }
                    }
                }

                //If there are no block groups ordering in the configuration then this is the first time this configuration 
                //has been loaded since group ordering was added.
                //So get the groups from the blocks and just use the order they come in.
                if (temp.Groups == null || temp.Groups.Count == 0)
                {
                    temp.Groups = used;
                }
                else
                {
                    //Remove any groups that are not being used
                    for (int i = temp.Groups.Count - 1; i >= 0; --i)
                    {
                        bool found = false;
                        for (int j = 0; j < used.Count; ++j)
                        {
                            if (used[j].Name == temp.Groups[i].Name)
                            {
                                found = true;
                                break;
                            }
                        }

                        if (!found)
                        {
                            temp.Groups.RemoveAt(i);
                        }
                    }
                }

                BlockMgr.Groups = temp.Groups;

                if (temp.OldSeciFirstTime)
                {
                    BlockMgr.SetBlocks(correctOldSeciBlocks(BlockMgr.Blocks));
                }
                else
                {
                    BlockMgr.SetBlocks(BlockMgr.Blocks);
                }

                Seci.Standard.DaeMonitor.WriteBlockList();
            }
            catch (Exception e)
            {
                Helpers.ErrorLogger.SeciError("openConfig", e);
                //throw error up to next level
                throw new ArgumentException(e.Message);
            }
        }

        private static bool groupExists(SerialisableList<BlockGroup> groups, string name)
        {
            for (int i = 0; i < groups.Count; ++i)
            {
                if (groups[i].Name == name)
                {
                    return true;
                }
            }
            return false;
        }

        public static void AddComponentTabs()
        {
            for (int i = 0; i < ComponentMgr.Components.Count; ++i)
            {
                if (ComponentMgr.Components[i].Tabs != null)
                {
                    for (int j = 0; j < ComponentMgr.Components[i].Tabs.Count; ++j)
                    {
                        Boolean tabexists = false;

                        foreach (Tab t in _currentConfig.Tabs)
                        {
                            if (t.Name == ComponentMgr.Components[i].Tabs[j].Name)
                            {
                                tabexists = true;
                                break;
                            }
                        }

                        if (!tabexists)
                        {
                            _currentConfig.Tabs.Add(ComponentMgr.Components[i].Tabs[j]);
                        }
                    }
                }
            }
        }

        private static void loadVIsAndInitialise(SerialisableList<LabView.LabViewPanelInfo> panels)
        {
            FileInfo fi;

            try
            {
                //load VIs in main config
                for (int i = 0; i < panels.Count; ++i)
                {
                    //Create a reference to the panel to load (just to make the code clearer)
                    Seci.LabView.LabViewPanelInfo Panel = panels[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)
                    {
                        LabView.LabViewApp.LoadVI(Panel, true);

                        if (Panel.ShowPanel)
                        {
                            LabView.LabViewApp.ShowVI(Panel.FilePath);
                        }

                        if (Panel.StartRunning)
                        {
                            startVI(Panel);
                        }
                    }
                    else
                    {
                        //Add it to the list of VI's not loaded
                        LabView.LabViewApp.VIsNotLoaded.Add(fi.FullName);
                    }
                }
            }
            catch (Exception e)
            {
                //throw error up to next level
                throw new ArgumentException(e.Message);
            }
        }

        private static void startVI(Seci.LabView.LabViewPanelInfo Panel)
        {
            LabView.LabViewApp.StartVI(Panel.FilePath);

            //Halt if there is a delay requested
            System.Threading.Thread.Sleep(Panel.DelayAfter * 1000);
        }

        #endregion

        #region Close Config

        public static void CloseConfiguration(Boolean killIcp)
        {
            if (!LabView.LabViewApp.IsNull)
            {
                Seci.Helpers.MessageLogger.WriteMessage("SeciInterface", "Configuration closed");

                //Clear messageQ
                Standard.MessageQueue.Messages.Clear();

                //Kill LabVIEW completely
                LabView.LabViewApp.StopLabView();

                if (killIcp)
                {
                    //Kill the Dae
                    Standard.Dae.KillIcp();
                }

                ExecutableMgr.CloseAll();

                BlockMgr.Blocks.Clear();

                BlockMgr.Groups.Clear();

                AssocFileMgr.AssociatedFiles.Clear();

                AlertsMgr.ClearAlerts();

                _currentConfig.TabOrder = new SerialisableList<string>();
                _currentConfig.GraphDefinitions = new SerialisableList<GraphDefinition>();
                _currentConfig.ConfigName = "";

                ComponentMgr.Components.Clear();
            }
        }

        #endregion

        #region Tabs 'n' Graphs

        public static void SetTabOrder(List<String> tabs)
        {
            if (tabs != null)
            {
                _currentConfig.TabOrder = new SerialisableList<string>();
                _currentConfig.TabOrder.AddRange(tabs);
            }
            else
            {
                _currentConfig.TabOrder = null;
            }
        }

        public static List<String> GetTabOrder()
        {
            List<String> temp = new List<string>(_currentConfig.TabOrder.ToArray());
            return temp;
        }

        public static void SetTabs(SerialisableList<Tab> tabs)
        {
            _currentConfig.Tabs = tabs;
        }

        public static SerialisableList<Tab> GetTabs()
        {
            return _currentConfig.Tabs;
        }

        public static void SetTabVisibility(String tabname, Boolean visible)
        {
            foreach (Tab t in _currentConfig.Tabs)
            {
                if (tabname == t.Name)
                {
                    t.VisibleForUser = visible;
                    return;
                }
            }
        }

        public static void SwapTabs(String name1, String name2)
        {
            //Swap over the config tabs
            int selected = -1;
            int toreplace = -1;
            for (int i = 0; i < _currentConfig.Tabs.Count; ++i)
            {
                if (_currentConfig.Tabs[i].Name == name1)
                {
                    selected = i;
                }

                if (_currentConfig.Tabs[i].Name == name2)
                {
                    toreplace = i;
                }
            }

            if (toreplace != -1 && selected != -1)
            {
                Tab temp = _currentConfig.Tabs[selected];
                _currentConfig.Tabs[selected] = new Seci.Definitions.Tab(_currentConfig.Tabs[toreplace].Name, _currentConfig.Tabs[toreplace].VisibleForUser);
                _currentConfig.Tabs[toreplace] = temp;
            }
        }

        public static void SetGraphDefinitions(List<GraphDefinition> graphs)
        {
            if (graphs != null)
            {
                _currentConfig.GraphDefinitions = new SerialisableList<GraphDefinition>();
                _currentConfig.GraphDefinitions.AddRange(graphs);
            }
        }

        internal static void AddGraphDefinitions(SerialisableList<GraphDefinition> graphs)
        {
            if (graphs != null)
            {
                if (_currentConfig.GraphDefinitions == null)
                {
                    _currentConfig.GraphDefinitions = new SerialisableList<GraphDefinition>();
                }

                //Only add graphs is the max number is not exceeded
                for (int i = 0; i < graphs.Count; ++i)
                {
                    _currentConfig.GraphDefinitions.Add(graphs[i]);

                    if (_currentConfig.GraphDefinitions.Count >= Status.MaxNumberGraphs)
                    {
                        break;
                    }
                }
            }
        }

        public static List<GraphDefinition> GetGraphDefinitions()
        {
            List<GraphDefinition> temp = new List<GraphDefinition>(_currentConfig.GraphDefinitions.ToArray());
            return temp;
        }

        internal static void RemoveComponentGraphs(String compName)
        {
            if (_currentConfig.GraphDefinitions != null)
            {
                for (int i = _currentConfig.GraphDefinitions.Count - 1; i >= 0; --i)
                {
                    if (!String.IsNullOrEmpty(_currentConfig.GraphDefinitions[i].OwningComponent) && _currentConfig.GraphDefinitions[i].OwningComponent.ToLower() == compName.ToLower())
                    {
                        _currentConfig.GraphDefinitions.RemoveAt(i);
                    }
                }
            }
        }

        #endregion

        #region Old Seci Corrections

        private static BlockDictionary correctOldSeciBlocks(BlockDictionary blocks)
        {
            //This is to allow configs from old seci to work
            //Can be removed after old SECI has been completely removed
            for (int i = 0; i < blocks.Count; ++i)
            {
                blocks[i] = correctOldSeciBlock(blocks[i]);
            }

            return blocks;
        }

        internal static BlockInfo correctOldSeciBlock(BlockInfo block)
        {
            try
            {
                return LabView.LabViewApp.GetCorrectBlockDetails(block);
            }
            catch
            {
                return block;
            }
        }

        #endregion

        public static int[] GetConfigPanelPosition(String filename, Boolean getPrevPosition)
        {
            SerialisableList<LabView.LabViewPanelInfo> panels = LabViewMgr.GetAllPanelsInfo();

            foreach (LabView.LabViewPanelInfo panel in panels)
            {
                if (panel.FilePath == filename)
                {
                    if (getPrevPosition && panel.OldBounds != null)
                    {
                        return panel.OldBounds;
                    }
                    return panel.Bounds;
                }
            }

            return null;
        }

        public static void SetConfigPanelPosition(String filename, int x, int y)
        {
            SerialisableList<LabView.LabViewPanelInfo> panels = LabViewMgr.GetAllPanelsInfo();

            foreach (LabView.LabViewPanelInfo panel in panels)
            {
                if (panel.FilePath == filename)
                {
                    panel.OldBounds = panel.Bounds;
                    panel.Bounds = new int[] { x, y };
                    return;
                }
            }
        }

        internal static int RemoteConfigurationChange(String configName)
        {
            String fileName = Status.ConfigDir + configName;

            //Check config exists
            FileInfo fi = new FileInfo(fileName);

            if (!fi.Exists)
            {
                return 1;
            }

            if (ConfigChangeRequested != null)
            {
                String[] vars = { fileName };

                //Bubble this up to the GUI
                ConfigChangeRequested(vars);

                return 0;
            }

            return 2;
        }

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

    }
}