UserInterface.xaml.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.ComponentModel;
using System.IO;

namespace SeciUserInterface
{
    public partial class UserInterface : Window
    {
        private SeciControls.BaseDashboardControl _dashboard;
        private static Boolean _manager = false; //Is the manager logged in?
        private Boolean _changesMade = false;    //Unsaved changes?
        private BackgroundWorker _backgroundSave = new BackgroundWorker();
        private BackgroundWorker _backgroundAutoSave = new BackgroundWorker();
        private List<String> _recentConfigs = new List<string>();
        private const int _numberLastConfigs = 3;
        private const String _beamlogTabname = "Beam-Logger";
        private const String _dummyTabname = "secisWonderfulHackTab"; //Name for tab that is used to get cascading right
        private Boolean _closingBecauseLvRunning = false; //this indicates that seci is being closed because LabVIEW is running.
        private List<SeciControls.Graphing.GraphWrapper> _graphs = new List<SeciControls.Graphing.GraphWrapper>();
        private Boolean _userCanSaveConfig = true;
        private Boolean _forceRestart = false;
        private Boolean _lvLost = false;

        private Forms.RunControlViewer _rcv;

        private delegate void UpdateGuiDelegate();
        private delegate void UpdateDashboardDelegate(Boolean timeout);

        private Forms.SeciSplashscreen _splashscreen;

        public UserInterface()
        {
            try
            {
                Seci.Managers.SeciMgr.IsBusy = true;

                //Check to see if Seci died - if so we may want to auto reload the last config
                _forceRestart = !Properties.Settings.Default.CleanKill;

                //On start up set CleanKill to false, it will be changed to true if the user
                //closes Seci.
                Properties.Settings.Default.CleanKill = false;
                Properties.Settings.Default.Save();

                //Set up directories and read app settings
                String exeLocation = System.Reflection.Assembly.GetExecutingAssembly().Location;
                Seci.Managers.SeciMgr.InitialiseSeci(exeLocation.Substring(0, exeLocation.LastIndexOf('\\')));
                ApplicationCommands.New.InputGestures.Clear(); //Disables Ctrl+N for New Command

                InitializeComponent();

                _splashscreen = new Forms.SeciSplashscreen("SECI is loading - please wait", this);
                _splashscreen.Show();

                if (Seci.Definitions.Status.DashboardType == "PERIOD")
                {
                    _dashboard = new SeciControls.PeriodDashboard();
                }
                else if (Seci.Definitions.Status.DashboardType == "PEARL")
                {
                    _dashboard = new SeciControls.PearlDashboard();
                }
                else if (Seci.Definitions.Status.DashboardType == "POLARIS")
                {
                    _dashboard = new SeciControls.PolarisDashboard();
                }
                else
                {
                    _dashboard = new SeciControls.StandardDashboard();
                }

                pnlDashboard.Children.Insert(0, _dashboard);

                //Set up height binding for blocksDisplay
                Binding b = new Binding();
                b.Source = _dashboard;
                b.UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged;
                b.Path = new PropertyPath("ActualHeight");
                this.blocksDisplay.SetBinding(SeciControls.BlockDisplay.HeightProperty, b);

                if (Seci.Definitions.Status.IsMuonInstrument)
                {
                    _dashboard.IsMuon = true;
                }

                //Show version number in title
                this.Title += " (Version " + System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString() + ")";

                if (labViewRunning(_forceRestart || Seci.Definitions.Status.AutoloadLastConfig))
                {
                    //if labview is not killed then just exit
                    _closingBecauseLvRunning = true;
                    Application.Current.Shutdown();
                    return;
                }

                setupEventHandlers();
                setupRecentConfigs();
            }
            catch (Exception err)
            {
                MessageBox.Show("Start up error: " + err.Message);
            }
        }

        private void UserInterface_Loaded(object sender, RoutedEventArgs e)
        {
            if (Seci.Definitions.Status.DelayStartup)
            {
                //Delays startup to allow debugger to be attached
                System.Threading.Thread.Sleep(30000);
            }

            //Adjust the navbar
            StringCollection navbarnames = Properties.Settings.Default.NavBarSettings;
            List<KeyValuePair<String, String>> order = new List<KeyValuePair<String, String>>();
            foreach (String str in navbarnames)
            {
                String[] temp = str.Split('|');
                if (temp.Length == 2)
                {
                    order.Add(new KeyValuePair<string, string>(temp[0].Trim(), temp[1].Trim()));
                }
            }
            navBar.SetButtonOrderAndNames(order);

            navBar.LostTimeVisible = Properties.Settings.Default.LostTimeVisible;
            navBar.VisVisibleForUser = Properties.Settings.Default.VisAvailable;
            navBar.DaeVisibleForUser = Properties.Settings.Default.DaeViAvailable;
            navBar.UserCanEditVISettings = Properties.Settings.Default.UserCanEditVISettings;
            navBar.JournelViewerVisible = Properties.Settings.Default.ShowJournalViewer;
            navBar.SetTabsVisibility(_manager);
            advancedOptions.ShowLostTime = navBar.LostTimeVisible;
            advancedOptions.VisAvailable = navBar.VisVisibleForUser;
            advancedOptions.DaeAvailable = navBar.DaeVisibleForUser;
            advancedOptions.ShowJournalViewer = navBar.JournelViewerVisible;
            advancedOptions.ShowBeamlogger = Properties.Settings.Default.ShowBeamlogger;
            advancedOptions.BigFontsDashboard = Properties.Settings.Default.UseBigFontsDashboard;
            advancedOptions.PlotOnGenieTab = Properties.Settings.Default.GraphsOnGenieTab;
            Seci.Managers.SeciMgr.WebDashboardEnabled = Properties.Settings.Default.WebDashboardEnabled;
            Seci.Managers.SeciMgr.WebDashboardShowTitle = Properties.Settings.Default.WebDashboardShowTitle;
            advancedOptions.ShowWebDashboard = Seci.Managers.SeciMgr.WebDashboardEnabled;
            advancedOptions.WebDashboardShowTitle = Seci.Managers.SeciMgr.WebDashboardShowTitle;
            bugzillaDisplayer.Navigate(new Uri(Seci.Definitions.Status.BugzillaWebpage));

            advancedOptions.PythonAvailable = Seci.Definitions.Status.IsPythonAvailable;

            //Load the phone numbers for the alerts
            Seci.Managers.AlertsMgr.LoadPhoneNumbers();

            if (Seci.Definitions.Status.KillIcpOnExit)
            {
                //Make sure ICP is not running
                Seci.Standard.Dae.KillIcp();

                //Also, kill the ISIS Data Server
                Seci.Standard.Dae.KillIsisDataSvr();
            }

            //Kill any Genie windows left over from a previous Seci session
            if (!String.IsNullOrEmpty(Properties.Settings.Default.ScriptPIDS))
            {
                System.Diagnostics.Process[] procList = System.Diagnostics.Process.GetProcessesByName("tkgenie32");

                if (procList.Length > 0)
                {
                    String[] old_pids = Properties.Settings.Default.ScriptPIDS.Split(';');

                    for (int i = 0; i < old_pids.Length; ++i)
                    {
                        int pid = 0;
                        if (int.TryParse(old_pids[i], out pid))
                        {
                            for (int j = 0; j < procList.Length; ++j)
                            {
                                if (pid == procList[j].Id)
                                {
                                    try
                                    {
                                        procList[j].Kill();
                                    }
                                    catch (Exception err)
                                    {
                                        Seci.Helpers.MessageLogger.WriteMessage("UserInterface_Loaded", "Failed to kill Genie orphan: " + err.Message);
                                    }
                                }
                            }
                        }
                    }
                }
                Properties.Settings.Default.ScriptPIDS = "";
            }
            
            //Start LabVIEW and the standard VIs
            Seci.Managers.SeciMgr.InitialiseLabView(true);
            addBeamloggerTab();
            dae.AddDae();

            if (Seci.Definitions.Status.AutoloadLastConfig && !String.IsNullOrEmpty(Properties.Settings.Default.LastConfig))
            {
                FileInfo fi = new FileInfo(Seci.Definitions.Status.ConfigDir + Properties.Settings.Default.LastConfig);

                if (fi.Exists)
                {
                    //Open last configuration
                    _splashscreen.Close();
                    startTimers();
                    pauseTimers();
                    eventViewer.AddMessage("Seci automatically started with last configuration", false);
                    openConfig(Seci.Definitions.Status.ConfigDir + Properties.Settings.Default.LastConfig, false);
                    Seci.Helpers.MessageLogger.WriteMessage("UserInterface", "Last configuration was loaded automatically");
                    Seci.Managers.SeciMgr.IsBusy = false;
                    return;
                }
            }
            else if (_forceRestart && !String.IsNullOrEmpty(Properties.Settings.Default.LastConfig))
            {
                Seci.Helpers.MessageLogger.WriteMessage("UserInterface", "Seci was not closed properly last time it was running.");
                FileInfo fi = new FileInfo(Seci.Definitions.Status.ConfigDir + Properties.Settings.Default.LastConfig);

                if (fi.Exists)
                {
                    Forms.ReloadDialog dlg = new Forms.ReloadDialog(30);
                    if (dlg.ShowDialog() == true)
                    {
                        _splashscreen.Close();
                        startTimers();
                        pauseTimers();
                        eventViewer.AddMessage("Seci started with last configuration", false);
                        openConfig(Seci.Definitions.Status.ConfigDir + Properties.Settings.Default.LastConfig, false);
                        Seci.Helpers.MessageLogger.WriteMessage("UserInterface", "Last configuration was loaded");
                        Seci.Managers.SeciMgr.IsBusy = false;
                        return;
                    }
                }
            }

            //if (!Properties.Settings.Default.LogBlocks)
            //{
            //    Seci.Managers.BlockMgr.LogValuesEnabled = false;
            //    advancedOptions.LogBlocksEnabled = false;
            //}
            //else
            //{
            //    Seci.Managers.BlockMgr.LogValuesEnabled = true;
            //    advancedOptions.LogBlocksEnabled = true;
            //}

            //Start the update and error timers
            startTimers();

            //Is scripting page visible?
            if (Seci.Definitions.Status.ShowScriptingPage)
            {
                //Open at least one Open Genie terminal
                startOpenGenies();
            }
            else
            {
                navBar.HideScriptingTab();
            }

            eventViewer.AddMessage("Seci started", false);

            _splashscreen.Close();

            updateRecentConfigs("");

            Seci.Managers.SeciMgr.IsBusy = false;
        }

        #region NavBar Events

        void navBar_OnExperimentDetailsClicked(object sender, EventArgs e)
        {
            hideMainControls();
            experimentDetails.Visibility = Visibility.Visible;
            userInfo.Update();
            userInfo.Visibility = Visibility.Visible;
            sampleInfo.Update();
            sampleInfo.Visibility = Visibility.Visible;
            beamlineInfo.Update();
            beamlineInfo.Visibility = Visibility.Visible;
        }

        #region LabVIEW

        void navBar_OnVIsClicked(object sender, EventArgs e)
        {
            hideMainControls();
            viTab.Visibility = Visibility.Visible;
        }

        void navBar_OnAddVIClicked(object sender, EventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            try
            {
                Dialogs.VIs.AddVI addVI = new Dialogs.VIs.AddVI();
                if (addVI.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    List<String> vis = Seci.Managers.LabViewMgr.GetListOfVIs(true);

                    //Add and Load the VIs
                    for (int i = 0; i < addVI.VIsToAdd.Count; ++i)
                    {
                        if (!vis.Contains(addVI.VIsToAdd[i].ToLower()))
                        {
                            Seci.Managers.LabViewMgr.AddVI(new Seci.LabView.LabViewPanelInfo(addVI.VIsToAdd[i], true, false));
                            Seci.Managers.LabViewMgr.ShowVI(addVI.VIsToAdd[i]);
                        }
                    }

                    _changesMade = true;
                    _backgroundAutoSave.RunWorkerAsync();
                }
            }
            catch (FileNotFoundException err)
            {
                //    WriteError("AddVI ", err);
                eventViewer.AddMessage("Could not extract information from llb file: " + err.Message, true);
                MessageBox.Show("Could not extract information from llb file! " + err.Message + "!", "Error!", MessageBoxButton.OK, MessageBoxImage.Error);
            }
            catch (Exception err)
            {
                //WriteError("AddVI ", err);
                eventViewer.AddMessage("Could not add VI: " + err.Message, true);
                MessageBox.Show("Could not add VI!", "Error!", MessageBoxButton.OK, MessageBoxImage.Error);
            }
            finally
            {
                Seci.Managers.SeciMgr.IsBusy = false;
            }
        }

        void navBar_OnRemoveVIClicked(object sender, EventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            //Get all the non sub-config VIs
            Seci.SerialisableList<Seci.LabView.LabViewPanelInfo> all = Seci.Managers.LabViewMgr.GetAllPanelsInfo();
            Seci.SerialisableList<Seci.LabView.LabViewPanelInfo> confOnly = new Seci.SerialisableList<Seci.LabView.LabViewPanelInfo>();

            for (int i = 0; i < all.Count; ++i)
            {
                if (String.IsNullOrEmpty(all[i].OwningComponent))
                {
                    confOnly.Add(all[i]);
                }
            }

            Dialogs.VIs.RemoveVI removeVI = new Dialogs.VIs.RemoveVI(confOnly);

            if (removeVI.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                //Remove the vis
                if (removeVI.ToRemove != null)
                {
                    //Remove the VIs
                    for (int i = 0; i < removeVI.ToRemove.Count; ++i)
                    {
                        Seci.SerialisableList<Seci.LabView.LabViewPanelInfo> panels = Seci.Managers.LabViewMgr.GetAllPanelsInfo();

                        //Find out which objects correspond to the names to remove
                        for (int j = 0; j < panels.Count; ++j)
                        {
                            if (panels[j].FilePath == removeVI.ToRemove[i])
                            {
                                //First remove any blocks that correspond to the VI's being removed
                                Seci.Managers.BlockMgr.Blocks.RemoveByVI(removeVI.ToRemove[i]);

                                //Then remove the VI
                                Seci.Managers.LabViewMgr.RemoveVI(removeVI.ToRemove[i]);

                                break;
                            }
                        }
                    }
                }

                //Remove from the tabs
                foreach (string viname in removeVI.ToRemove)
                {
                    viTab.RemoveVi(viname);
                }

                blocksDisplay.SetBlocksToShow(Seci.Managers.BlockMgr.Blocks.GetKeys());
                _changesMade = true;
                _backgroundAutoSave.RunWorkerAsync();
            }

            Seci.Managers.SeciMgr.IsBusy = false;
        }

        void navBar_OnConfigureVIClicked(object sender, EventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            Dialogs.VIs.SetVIProperties props = new Dialogs.VIs.SetVIProperties(Seci.Managers.LabViewMgr.GetAllPanelsInfo(), false);
            if (props.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                //Set visibility
                for (int i = 0; i < props.Panels.Count; ++i)
                {
                    //Show panel or not
                    if (props.Panels[i].ShowPanel)
                    {
                        Seci.Managers.LabViewMgr.ShowVI(props.Panels[i].FilePath);
                    }
                    else
                    {
                        Seci.Managers.LabViewMgr.HideVI(props.Panels[i].FilePath);
                    }
                }

                //Copy back
                Seci.Managers.LabViewMgr.SetPanelsInfo(props.Panels);

                _changesMade = true;
                _backgroundAutoSave.RunWorkerAsync();
            }

            Seci.Managers.SeciMgr.IsBusy = false;
        }

        void navBar_OnEditTabsClicked(object sender, EventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            List<String> nonEdit = new List<string>();
            nonEdit.Add(_beamlogTabname);
            List<String> secret = new List<string>();
            secret.Add(_dummyTabname);

            Dialogs.Tabs.EditTabs tab = new Dialogs.Tabs.EditTabs(ref viTab, nonEdit, secret, Seci.Managers.ConfigurationMgr.GetTabs());
            if (tab.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                _changesMade = true;
                _backgroundAutoSave.RunWorkerAsync();
            }

            Seci.Managers.SeciMgr.IsBusy = false;
        }

        void navBar_OnConfigureBlocksClicked(object sender, EventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            Dialogs.Blocks.ConfigureBlocks confBlocks = new SeciUserInterface.Dialogs.Blocks.ConfigureBlocks();
            confBlocks.BlocksCopy = Seci.Managers.BlockMgr.GetBlocksClone();
            if (confBlocks.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                //Put the changes into the configuration
                //Pause threads and wait a second to give threads fired off time to finish
                Seci.Managers.SeciMgr.PauseThreads();
                System.Threading.Thread.Sleep(1000);

                //Copy updated blocks onto main config blocks
                Seci.Managers.BlockMgr.SetBlocks(confBlocks.BlocksCopy);

                if (Seci.Definitions.Status.UseDaeMonitorVI)
                {
                    Seci.Standard.DaeMonitor.WriteBlockList();
                }

                //Copy the BlockGroups
                Seci.Managers.BlockMgr.ReorderBlockGroups(confBlocks.GroupOrder);

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

                //Set up blocks display
                blocksDisplay.SetBlocksToShow(Seci.Managers.BlockMgr.Blocks.GetKeys());
                if (!_dashboard.IsExpanded())
                {
                    blocksDisplay.Visibility = Visibility.Collapsed;
                }
                _changesMade = true;

                _backgroundAutoSave.RunWorkerAsync();

                if (!Properties.Settings.Default.UsePython)
                {
                    MessageBox.Show("To implement these changes in Open GENIE you will need to type \"GetBlocks\" in the Open GENIE scripting window(s).", "Blocks Changed", MessageBoxButton.OK, MessageBoxImage.Information);
                }
            }

            Seci.Managers.SeciMgr.IsBusy = false;
        }


        void navBar_OnDisplayBlocksClicked(object sender, EventArgs e)
        {
            if (_rcv == null || _rcv.IsDisposed)
            {
                _rcv = new Forms.RunControlViewer();
                _rcv.Show();
            }
            else
            {
                _rcv.Show();
                if (_rcv.WindowState == System.Windows.Forms.FormWindowState.Minimized)
                {
                    _rcv.WindowState = System.Windows.Forms.FormWindowState.Normal;
                }
                _rcv.BringToFront();
            }
        }

        #endregion

        void navBar_OnLostTimeClicked(object sender, EventArgs e)
        {
            hideMainControls();
            lostTime.Visibility = Visibility.Visible;
        }



        void navBar_OnOpenGenieClicked(object sender, EventArgs e)
        {
            hideMainControls();
            OpenGenie1.Visibility = Visibility.Visible;
            if (navBar.TwoGeniesAvailable)
            {
                OpenGenie2.Visibility = Visibility.Visible;
            }

            if (Properties.Settings.Default.GraphsOnGenieTab && _graphs.Count > 0)
            {
                genieGraphPanel.Visibility = Visibility.Visible;
            }
            else
            {
                genieGraphPanel.Visibility = Visibility.Collapsed;
            }

            OpenGenie1.SetFocus();
        }

        void navBar_OnDaeClicked(object sender, EventArgs e)
        {
            hideMainControls();
            dae.Visibility = Visibility.Visible;
        }

        void navBar_OnGraphsClicked(object sender, EventArgs e)
        {
            hideMainControls();
            graphPanel.Visibility = Visibility.Visible;
        }

        void navBar_OnSettingsClicked(object sender, EventArgs e)
        {
            hideMainControls();
            IniEditor.Visibility = Visibility.Visible;
        }

        void navBar_OnAdvancedClicked(object sender, EventArgs e)
        {
            hideMainControls();
            advancedOptions.Visibility = Visibility.Visible;
        }

        void navBar_OnJournalViewerClicked(object sender, EventArgs e)
        {
            hideMainControls();
            JournalViewer.Visibility = Visibility.Visible;
        }

        void navBar_OnSystemMessagesClicked(object sender, EventArgs e)
        {
            hideMainControls();
            MessagesPanel.Visibility = Visibility.Visible;
        }

        void navBar_OnBeamStatusClicked(object sender, EventArgs e)
        {
            hideMainControls();
            BeamStatus.Visibility = Visibility.Visible;
        }

        void navBar_OnIsisMessagesClicked(object sender, EventArgs e)
        {
            hideMainControls();
            mcrnews.Visibility = Visibility.Visible;
        }

        void navBar_OnReportProblemClicked(object sender, EventArgs e)
        {
            hideMainControls();
            bugzillaDisplayer.Visibility = Visibility.Visible;
        }

        void navBar_OnHelpClicked(object sender, EventArgs e)
        {
            hideMainControls();
            helpPanel.Visibility = Visibility.Visible;
        }

        void hideMainControls()
        {
            experimentDetails.Visibility = Visibility.Collapsed;
            userInfo.Visibility = Visibility.Collapsed;
            sampleInfo.Visibility = Visibility.Collapsed;
            beamlineInfo.Visibility = Visibility.Collapsed;
            viTab.Visibility = Visibility.Collapsed;
            OpenGenie1.Visibility = Visibility.Collapsed;
            OpenGenie2.Visibility = Visibility.Collapsed;
            dae.Visibility = Visibility.Collapsed;
            advancedOptions.Visibility = Visibility.Collapsed;
            mcrnews.Visibility = Visibility.Collapsed;
            MessagesPanel.Visibility = Visibility.Collapsed;
            graphPanel.Visibility = Visibility.Collapsed;
            BeamStatus.Visibility = Visibility.Collapsed;
            helpPanel.Visibility = Visibility.Collapsed;
            JournalViewer.Visibility = Visibility.Collapsed;
            genieGraphPanel.Visibility = Visibility.Collapsed;
            bugzillaDisplayer.Visibility = Visibility.Collapsed;
            IniEditor.Visibility = Visibility.Collapsed;
            lostTime.Visibility = Visibility.Collapsed;
        }

        #endregion

        #region Timers and Threads

        private void startTimers()
        {
            Seci.Managers.SeciMgr.StartThreads(true, true);
            Seci.Managers.SeciMgr.OnValuesUpdated += new Seci.Managers.SeciMgr.ValuesUpdatedEventHandler(SeciInterface_ValuesUpdated);
            Seci.Managers.SeciMgr.OnNewLVMessage += new EventHandler(SeciInterface_OnNewLVMessage);
            Seci.Managers.SeciMgr.OnLVNotThere += new EventHandler(SeciInterface_OnLVNotThere);
            viTab.StartTimers(Seci.Definitions.Status.ViHostRefreshRate);
        }

        public static void pauseTimers()
        {
            Seci.Managers.SeciMgr.PauseThreads();

            //Wait a second to give threads fired off time to finish
            System.Threading.Thread.Sleep(1000);
        }

        public void resumeTimers()
        {
            Seci.Managers.SeciMgr.ResumeThreads();
            viTab.StartTimers(Seci.Definitions.Status.ViHostRefreshRate);
        }

        private void SeciInterface_ValuesUpdated(Boolean timeout)
        {
            try
            {
                //if (!_closing) //If the form is closing then don't update
                //{
                this.Dispatcher.Invoke(new UpdateDashboardDelegate(UpdateMainGUI), timeout);
                //}
            }
            catch
            {
            }
        }

        private void UpdateMainGUI(Boolean timeout)
        {
            //Update dashboard
            if (!timeout)
            {
                _dashboard.UpdateControl();
            }

            blocksDisplay.UpdateControl();
            if (_graphs != null && _graphs.Count > 0)
            {
                foreach (SeciControls.Graphing.GraphWrapper graph in _graphs)
                {
                    graph.UpdateControl();
                }
            }

            if (!Seci.Managers.BlockMgr.LogValuesEnabled)
            {
                txtWarning.Text = "Warning: Blocks values are not being logged";
                txtWarning.Visibility = System.Windows.Visibility.Visible;
            }
            else
            {
                txtWarning.Visibility = System.Windows.Visibility.Collapsed;
            }
        }

        void SeciInterface_OnNewLVMessage(object sender, EventArgs e)
        {
            try
            {
                //if (!_closing) //If the form is closing then don't update
                //{
                this.Dispatcher.Invoke(new UpdateGuiDelegate(UpdateErrorsGUI), null);
                //}
            }
            catch
            {
                //WriteError("SeciInterface_OnNewLVMessage", err);
            }
        }

        void SeciInterface_OnLVNotThere(object sender, EventArgs e)
        {
            if (!_lvLost)
            {
                _lvLost = true;
                this.Dispatcher.Invoke(new UpdateGuiDelegate(showWarning), null);
                MessageBox.Show("Seci has lost connection to LabVIEW - this probably means LabVIEW has a very serious problem", "SECI - LabVIEW connection lost", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        private void showWarning()
        {
            txtWarning.Text = "Seci has lost connection to LabVIEW - this probably means LabVIEW has a very serious problem";
            txtWarning.Visibility = System.Windows.Visibility.Visible;
        }

        private void UpdateErrorsGUI()
        {
            //Get the messages
            Seci.SerialisableList<Seci.Standard.MessageInfo> errorMessages = Seci.Standard.MessageQueue.Messages;

            if (errorMessages != null)
            {
                int numErrors = 0;
                int numQuestions = 0;

                //Check for questions and errors
                for (int i = 0; i < errorMessages.Count; ++i)
                {
                    if (errorMessages[i].WaitForResponse)
                    {
                        ++numQuestions;
                    }
                    else
                    {
                        ++numErrors;
                    }
                }

                //Update navbar
                navBar.SetErrorCounter(numErrors, numQuestions);
                //Display the messages
                errorViewer.AddMessages(errorMessages);
            }
        }

        #endregion

        #region Closing

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            if (!_closingBecauseLvRunning)
            {
                if (_manager && Seci.Managers.AssocFileMgr.AnyModificationsToParFiles())
                {
                    if (MessageBox.Show("At least one TPAR or MPAR has been modified, to make the changes permanent the configuration must be saved. Are you sure you still wish to close SECI?", "Unsaved Changes!", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.No)
                    {
                        e.Cancel = true;
                        Seci.Managers.SeciMgr.IsBusy = false;
                        return;
                    }
                }

                if (_changesMade || Seci.Managers.AssocFileMgr.AnyModifications())
                {
                    if (MessageBox.Show("There are unsaved changes to the configuration. Are you sure you wish to close SECI?", "Unsaved Changes!", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.No)
                    {
                        e.Cancel = true;
                        Seci.Managers.SeciMgr.IsBusy = false;
                        return;
                    }
                }
                else
                {
                    if (MessageBox.Show("Close SECI?", "Close?", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.No)
                    {
                        e.Cancel = true;
                        Seci.Managers.SeciMgr.IsBusy = false;
                        return;
                    }
                }

                //Stop updating
                pauseTimers();

                System.Threading.Thread.Sleep(1000);

                //Close the configuration
                Seci.Managers.ConfigurationMgr.CloseConfiguration(Seci.Definitions.Status.KillIcpOnExit);
                Seci.Managers.SeciMgr.CloseSeci();

                //Update the app settings
                saveSettings();

                helpPanel.Dispose();

                Seci.Helpers.MessageLogger.WriteMessage("SeciGui", "User closed SECI");
            }
        }

        private void saveSettings()
        {
            Properties.Settings.Default.CleanKill = true;
            Properties.Settings.Default.VisAvailable = navBar.VisVisibleForUser;
            Properties.Settings.Default.DaeViAvailable = navBar.DaeVisibleForUser;
            Properties.Settings.Default.UserCanEditVISettings = navBar.UserCanEditVISettings;
            Properties.Settings.Default.UsePython = (bool)advancedOptions.UsePython;
            Properties.Settings.Default.UseTwoGenies = navBar.TwoGeniesAvailable;
            Properties.Settings.Default.ShowJournalViewer = navBar.JournelViewerVisible;
            Properties.Settings.Default.ShowBeamlogger = (bool)advancedOptions.ShowBeamlogger;
            Properties.Settings.Default.UseBigFontsDashboard = (bool)advancedOptions.BigFontsDashboard;
            Properties.Settings.Default.WebDashboardEnabled = Seci.Managers.SeciMgr.WebDashboardEnabled;
            Properties.Settings.Default.WebDashboardShowTitle = Seci.Managers.SeciMgr.WebDashboardShowTitle;
            Properties.Settings.Default.LogBlocks = Seci.Managers.BlockMgr.LogValuesEnabled;
            Properties.Settings.Default.LostTimeVisible = navBar.LostTimeVisible;
            Properties.Settings.Default.Save();
        }

        #endregion

        #region File

        private void menuNewCommand(object sender, RoutedEventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            if (okayToCloseConfig())
            {
                _splashscreen = new Forms.SeciSplashscreen("Creating a new Configuration", this);
                _splashscreen.Show();
                RestartSeci();

                txtConfig.Text = "None";

                Seci.Managers.ConfigurationMgr.CreateNewConfiguration();
                //Add the beam logger tab if it has not already been added
                if (Seci.Managers.ConfigurationMgr.GetTabs().Count == 0)
                {
                    Seci.Managers.ConfigurationMgr.GetTabs().Add(new Seci.Definitions.Tab(_beamlogTabname, (bool)advancedOptions.ShowBeamlogger));
                }

                //Pause a couple seconds to make sure VIs have loaded
                System.Threading.Thread.Sleep(2000);

                //Is scripting page visible?
                if (Seci.Definitions.Status.ShowScriptingPage)
                {
                    //Open at least one Open Genie terminal
                    startOpenGenies();
                }
                else
                {
                    navBar.HideScriptingTab();
                }

                eventViewer.AddMessage("New configuration selected", false);
                cascadeTabs();

                //Restart timers
                resumeTimers();
                _splashscreen.Close();
            }

            Seci.Managers.SeciMgr.IsBusy = false;
        }

        private void menuOpenCommand(object sender, RoutedEventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            if (okayToCloseConfig())
            {
                System.Windows.Forms.OpenFileDialog openFileDialog1 = new System.Windows.Forms.OpenFileDialog();
                openFileDialog1.InitialDirectory = Seci.Definitions.Status.ConfigDir;
                openFileDialog1.Filter = "SECI Configuration|*.conf|SECI Sub-Configuration|*.comp";

                if (openFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    openConfig(openFileDialog1.FileName, true);
                }
            }

            Seci.Managers.SeciMgr.IsBusy = false;
        }

        private void menuSaveCommand(object sender, RoutedEventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            if (!_userCanSaveConfig && !_manager)
            {
                MessageBox.Show("Sorry, you do not have permission to save configurations.", "Cannot save", MessageBoxButton.OK, MessageBoxImage.Exclamation);
            }
            else
            {
                if (String.IsNullOrEmpty(Seci.Managers.ConfigurationMgr.ConfigName))
                {
                    //Use saveAs instead
                    menuSaveAsCommand(sender, e);
                }
                else
                {
                    doSave(false, Seci.Managers.ConfigurationMgr.ConfigName);
                }
            }

            Seci.Managers.SeciMgr.IsBusy = false;
        }

        private void menuSaveAsCommand(object sender, RoutedEventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            if (!_userCanSaveConfig && !_manager)
            {
                MessageBox.Show("Sorry, you do not have permission to save configurations.", "Cannot save", MessageBoxButton.OK, MessageBoxImage.Exclamation);
            }
            else
            {
                System.Windows.Forms.SaveFileDialog saveFileDialog1 = new System.Windows.Forms.SaveFileDialog();
                saveFileDialog1.InitialDirectory = Seci.Definitions.Status.ConfigDir;

                if (Seci.Managers.ComponentMgr.GetNames() != null && Seci.Managers.ComponentMgr.GetNames().Count > 0)
                {
                    //Save as a configuration only
                    saveFileDialog1.Filter = "SECI Configuration|*.conf";
                }
                else
                {
                    //Save as a configuration or component
                    saveFileDialog1.Filter = "SECI Configuration|*.conf|SECI Sub-configuration|*.comp";
                }

                //Save it
                if (saveFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    doSave(true, saveFileDialog1.FileName);
                }
            }

            Seci.Managers.SeciMgr.IsBusy = false;
        }

        private void menuExitCommand(object sender, RoutedEventArgs e)
        {
            this.Close();
        }

        private void startOpenGenies()
        {
            //Restart Open Genie(s)
            if (Seci.Definitions.Status.IsPythonAvailable && Properties.Settings.Default.UsePython)
            {
                advancedOptions.UsePython = true;
                setToPython();
            }
            else
            {
                setToGenie();
            }

            OpenGenie1.StartProcess();
            if (navBar.TwoGeniesAvailable || Properties.Settings.Default.UseTwoGenies)
            {
                navBar.TwoGeniesAvailable = true;
                advancedOptions.TwoGeniesAvailable = true;
                OpenGenie2.StartProcess();
            }

            saveScriptingPids();
        }

        private void saveScriptingPids()
        {
            List<int> pids = new List<int>();
            pids.Add(OpenGenie1.GetPID());

            if (navBar.TwoGeniesAvailable || Properties.Settings.Default.UseTwoGenies)
            {
                pids.Add(OpenGenie2.GetPID());
            }

            //Get the PIDs and save them
            String sPids = "";
            foreach (int p in pids)
            {
                sPids += p.ToString() + ";";
            }

            Properties.Settings.Default.ScriptPIDS = sPids.Substring(0, sPids.Length - 1);
            Properties.Settings.Default.Save();
        }

        private void setToPython()
        {
            OpenGenie1.UsePython(true);
            OpenGenie2.UsePython(true);
            OpenGenie1.SetLinkMessage("Start Python");
            OpenGenie2.SetLinkMessage("Start Python");
            OpenGenie1.Initialise(Seci.Definitions.Status.PythonPath, Seci.Definitions.Status.PythonArgs);
            OpenGenie2.Initialise(Seci.Definitions.Status.PythonPath, Seci.Definitions.Status.PythonArgs);
        }

        private void setToGenie()
        {
            OpenGenie1.UsePython(false);
            OpenGenie2.UsePython(false);
            OpenGenie1.SetLinkMessage("Start Open Genie");
            OpenGenie2.SetLinkMessage("Start Open Genie");
            OpenGenie1.Initialise(Seci.Definitions.Status.OpenGenieLocation, "");
            OpenGenie2.Initialise(Seci.Definitions.Status.OpenGenieLocation, "");
        }

        private void RestartSeci()
        {
            //Pause updating and error timers
            pauseTimers();
            Seci.Managers.SeciMgr.ClearDatabaseQueues();

            //Clear layout
            blocksDisplay.SetBlocksToShow(null);
            viTab.RemoveAllTabs();
            dae.RemoveDae();
            deleteGraphs();
            IniEditor.ClearFiles();
            IniEditor.Visibility = Visibility.Collapsed;
            navBar.SettingsVisible = false;
            navBar.GraphsAvailable = false;
            navBar.SetTabsVisibility(_manager);

            //Close current config
            Seci.Managers.ConfigurationMgr.CloseConfiguration(Seci.Definitions.Status.KillIcpOnConfigChange);

            //Needs a few seconds to let everything close (see Ticket #78)
            System.Threading.Thread.Sleep(10000);

            //Close Open Genie(s)
            OpenGenie1.KillProcess();
            if (navBar.TwoGeniesAvailable)
            {
                OpenGenie2.KillProcess();
            }

            //Clear LV messages
            errorViewer.ClearMessages();
            navBar.SetErrorCounter(0, 0);

            //And reinitialise LabVIEW
            Seci.Managers.SeciMgr.InitialiseLabView(true);
            addBeamloggerTab();
            dae.AddDae();

            _changesMade = false;
        }

        private Boolean okayToCloseConfig()
        {
            if (_changesMade || Seci.Managers.AssocFileMgr.AnyModifications())
            {
                if (MessageBox.Show("There are unsaved changes to the current configuration - are you sure you wish to close it?", "Unsaved Changes!", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.No)
                {
                    return false;
                }
            }

            return true;
        }

        //For some reason labview will not move the vi on the last tab to the correct
        //position. So, to get round this we add a dummy tab as the last tab and hide it.
        //Though this is far from elegant it works well.
        //We use the sample parameters vi, but it could be any of the standard VIs.
        private void cascadeTabs()
        {
            if (viTab.AddDummyTab(_dummyTabname))
            {
                viTab.AddVi(_dummyTabname, Seci.Standard.SampleParameters.FilePath);
            }
            viTab.CascadeAllTabs();
        }

        private void openConfig(String filepath, Boolean restartSeci)
        {
            _splashscreen = new Forms.SeciSplashscreen("Opening Configuration", this);
            _splashscreen.Show();

            if (restartSeci)
            {
                RestartSeci();
            }

            try
            {
                Seci.Managers.ConfigurationMgr.OpenConfiguration(filepath);
                eventViewer.AddMessage("Configuration opened: " + Seci.Managers.ConfigurationMgr.ConfigName, false);
            }
            catch (Exception err)
            {
                _splashscreen.Close();

                MessageBox.Show("Failed to open configuration" + Environment.NewLine + err.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                eventViewer.AddMessage("Failed to open configuration: " + filepath, false);
                Seci.Helpers.MessageLogger.WriteMessage("openConfig", "Failed to open configuration: " + err.Message);

                _splashscreen = new Forms.SeciSplashscreen("Resetting SECI", this);
                _splashscreen.Show();
                RestartSeci();
            }

            setupTabs();

            //Is scripting page visible?
            if (Seci.Definitions.Status.ShowScriptingPage)
            {
                //Open at least one Open Genie terminal
                startOpenGenies();
            }
            else
            {
                navBar.HideScriptingTab();
            }

            blocksDisplay.SetBlocksToShow(Seci.Managers.BlockMgr.Blocks.GetKeys());
            txtConfig.Text = Seci.Managers.ConfigurationMgr.ConfigName;

            //Set up graphs
            setupGraphs(Seci.Managers.ConfigurationMgr.GetGraphDefinitions());

            //If muon load any tpar or mpar files
            setupIniFiles(true);

            List<String> visNotLoaded = Seci.Managers.LabViewMgr.GetVIsNotLoaded();

            if (visNotLoaded != null && visNotLoaded.Count > 0)
            {
                String message = "The following VIs were not loaded and their associated Blocks were removed:" + Environment.NewLine;
                foreach (String name in visNotLoaded)
                {
                    message += "        " + name + Environment.NewLine;
                }

                eventViewer.AddMessage(message.Trim(), false);
            }

            resumeTimers();

            updateRecentConfigs(Seci.Managers.ConfigurationMgr.ConfigName);

            //Cascade the tabs they will be moved to the correct position later
            cascadeTabs();

            //Set tab visibility if user
            SetViTabsVisibility();

            _splashscreen.Close();
        }

        private void setupIniFiles(Boolean clear)
        {
            if (Seci.Definitions.Status.IsMuonInstrument)
            {
                if (clear)
                {
                    IniEditor.ClearFiles();
                }

                List<String> par_files = new List<string>();
                foreach (String file in Seci.Managers.AssocFileMgr.GetListOfAsscFiles(true))
                {
                    if (file.ToLower().EndsWith(".tpar") || file.ToLower().EndsWith(".mpar"))
                    {
                        par_files.Add(file);
                    }
                }

                if (par_files.Count > 0)
                {
                    IniEditor.LoadFiles(par_files);
                    navBar.SettingsVisible = true;
                    navBar.SetTabsVisibility(_manager);
                }
            }
        }

        private void setupTabs()
        {
            Seci.SerialisableList<Seci.LabView.LabViewPanelInfo> panels = Seci.Managers.LabViewMgr.GetAllPanelsInfo();

            for (int i = 0; i < panels.Count; ++i)
            {
                if (!String.IsNullOrEmpty(panels[i].Group))
                {
                    viTab.AddTab(panels[i].Group);
                    if (panels[i].Bounds != null)
                    {
                        if (!viTab.DoesTabContainsVi(panels[i].Group, panels[i].FilePath))
                        {
                            viTab.AddVi(panels[i].Group, panels[i].FilePath, panels[i].Bounds[0], panels[i].Bounds[1]);
                        }
                    }
                    else
                    {
                        viTab.AddVi(panels[i].Group, panels[i].FilePath);
                    }
                }
            }

            Seci.SerialisableList<Seci.Definitions.Tab> tabs_conf = Seci.Managers.ConfigurationMgr.GetTabs();

            //Remove any duplicates
            for (int i = 0; i < tabs_conf.Count; ++i)
            {
                for (int j = tabs_conf.Count - 1; j > i; --j)
                {
                    if (tabs_conf[i].Name == tabs_conf[j].Name)
                    {
                        tabs_conf.RemoveAt(j);
                    }
                }
            }

            List<String> tabs = viTab.GetTabNames(true);
            for (int i = tabs_conf.Count - 1; i >= 0; --i)
            {
                if (!tabs.Contains(tabs_conf[i].Name))
                {
                    tabs_conf.RemoveAt(i);
                }
            }

            //Set tab order and show beamlogger tab by default
            viTab.SetTabOrder(tabs_conf);
            viTab.SelectTab(_beamlogTabname);
        }

        private void doSave(Boolean isNewFile, String fullFileName)
        {
            String fileName;

            //Set config name
            fileName = fullFileName.Substring(fullFileName.LastIndexOf("\\") + 1);

            if (isNewFile && !fullFileName.StartsWith(Seci.Definitions.Status.ConfigDir))
            {
                MessageBox.Show("Configurations and components must be saved in the Configurations directory", "Trying to Save in wrong location");
                return;
            }

            String oldName = Seci.Managers.ConfigurationMgr.ConfigName;
            Seci.Managers.ConfigurationMgr.ConfigName = fileName;

            //Populate tab order list
            List<String> tabs = viTab.GetTabNames(false);
            tabs.Remove(_dummyTabname);
            Seci.Managers.ConfigurationMgr.SetTabOrder(null);

            //Populate configurations graph definitions
            Seci.Managers.ConfigurationMgr.SetGraphDefinitions(getDefinitions());

            //Check user has permission to save
            Boolean okayToSave = Seci.Managers.ConfigurationMgr.OkayToSave(_manager);

            if (fileName.ToLower().EndsWith(".comp") && Seci.Managers.ComponentMgr.GetNames().Count > 0)
            {
                MessageBox.Show("This configuration contains at least one component, so it cannot be saved as a component");
            }

            //Check user has permission to save
            if (okayToSave)
            {
                //Call background save
                txtStatus.Text = "Saving...";

                try
                {
                    _backgroundSave.RunWorkerAsync();
                }
                catch (Exception err)
                {
                    Seci.Managers.ConfigurationMgr.ConfigName = oldName;
                    eventViewer.AddMessage("Failed to save configuration: " + err.Message, true);
                    //WriteError("saveConfig ", err);
                }
                txtConfig.Text = Seci.Managers.ConfigurationMgr.ConfigName;
                updateRecentConfigs(txtConfig.Text);
            }
            else
            {
                Seci.Managers.ConfigurationMgr.ConfigName = oldName;
                MessageBox.Show("Sorry, you must be logged in with the manager account to overwrite this configuration!", "Cannot Overwrite!", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        void backgroundSave_DoWork(object sender, DoWorkEventArgs e)
        {
            Seci.Managers.ConfigurationMgr.SaveConfiguration(_manager, false);
        }

        void backgroundSave_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            txtStatus.Text = "";
            eventViewer.AddMessage("Configuration saved: " + Seci.Managers.ConfigurationMgr.ConfigName, false);
            _changesMade = false;
        }

        void backgroundAutoSave_DoWork(object sender, DoWorkEventArgs e)
        {
            //Always do auto save as manager
            Seci.Managers.ConfigurationMgr.SaveConfiguration(true, true);
        }

        #endregion

        #region Manager

        private void menuMgrLogin_Click(object sender, RoutedEventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            Dialogs.Manager.ManagerLogin login = new Dialogs.Manager.ManagerLogin();

            if (login.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                _manager = true;
                fileMenu.LogInEnabled = false;
                fileMenu.LogOutEnabled = true;
                navBar.SetTabsVisibility(_manager);

                if (!navBar.VisVisibleForUser)
                {
                    showNonTabbedVis();
                }

                //Show all VI tabs
                SetViTabsVisibility();
            }

            Seci.Managers.SeciMgr.IsBusy = false;
        }

        private void SetViTabsVisibility()
        {
            bool anyVisible = false;

            foreach (var tab in Seci.Managers.ConfigurationMgr.GetTabs())
            {
                if (tab.VisibleForUser || _manager)
                {
                    viTab.UnhideTab(tab.Name);
                    anyVisible = true;
                }
                else
                {
                    viTab.HideTab(tab.Name);
                }
            }

            if (!anyVisible)
            {
                viTab.SelectTab(-1);
            }
            else
            {
                viTab.SetToFirstVisible();
            }
        }

        private void menuMgrLogout_Click(object sender, RoutedEventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            _manager = false;
            fileMenu.LogInEnabled = true;
            fileMenu.LogOutEnabled = false;
            navBar.SetTabsVisibility(_manager);
            hideMainControls();
            navBar.DeselectSelectedItem();

            if (!navBar.VisVisibleForUser)
            {
                hideNonTabbedVis();
            }
            else
            {
                showNonTabbedVis();
            }

            //Hide any VI tabs that should be hidden
            SetViTabsVisibility();

            Seci.Managers.SeciMgr.IsBusy = false;
        }

        void hideNonTabbedVis()
        {
            Seci.SerialisableList<Seci.LabView.LabViewPanelInfo> vis = getLooseVis();

            for (int i = 0; i < vis.Count; ++i)
            {
                Seci.Managers.LabViewMgr.HideVI(vis[i].FilePath);
            }
        }

        void showNonTabbedVis()
        {
            Seci.SerialisableList<Seci.LabView.LabViewPanelInfo> vis = getLooseVis();

            for (int i = 0; i < vis.Count; ++i)
            {
                //Show panel or not
                if (vis[i].ShowPanel)
                {
                    Seci.Managers.LabViewMgr.ShowVI(vis[i].FilePath);
                }
                else
                {
                    Seci.Managers.LabViewMgr.HideVI(vis[i].FilePath);
                }
            }
        }

        private Seci.SerialisableList<Seci.LabView.LabViewPanelInfo> getLooseVis()
        {
            Seci.SerialisableList<Seci.LabView.LabViewPanelInfo> vis = Seci.Managers.LabViewMgr.GetAllPanelsInfo();
            List<String> visInTabs = viTab.GetAllVisInTabs();

            List<String> tohide = new List<String>();

            for (int i = 0; i < vis.Count; ++i)
            {
                if (!vis[i].ShowPanel || visInTabs.Contains(vis[i].FilePath))
                {
                    //Do nothing
                }
                else
                {
                    tohide.Add(vis[i].FilePath);

                }
            }
            return vis;
        }

        #endregion

        #region User Info

        void userInfo_OnEditUsersClicked(object sender, EventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            if (!_manager)
            {
                MessageBox.Show("You must be logged in with the Manager account to perform this action.", "Unauthorised", MessageBoxButton.OK, MessageBoxImage.Stop);
            }
            else
            {
                SeciControls.EditUsers editUsers = new SeciControls.EditUsers();
                editUsers.oldUsers = Seci.Standard.UserDetails.GetUsers();

                if (editUsers.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    try
                    {
                        Seci.Standard.UserDetails.SetUsers(editUsers.newUsers);
                        System.Threading.Thread.Sleep(600);
                    }
                    catch
                    {
                    }

                    userInfo.Update();
                }
            }

            Seci.Managers.SeciMgr.IsBusy = false;
        }

        #endregion

        #region Advanced Options

        private void advancedOptions_OnCheckStatusChanged(object sender, EventArgs e)
        {
            CheckBox chk = sender as CheckBox;
            if (chk.IsChecked == true)
            {
                navBar.DaeVisibleForUser = true;
            }
            else
            {
                navBar.DaeVisibleForUser = false;
            }
        }

        void advancedOptions_OnVisAvailableCheckChanged(object sender, EventArgs e)
        {
            CheckBox chk = sender as CheckBox;
            if (chk.IsChecked == true)
            {
                navBar.VisVisibleForUser = true;
            }
            else
            {
                navBar.VisVisibleForUser = false;
            }
        }

        void advancedOptions_OnUserCanSaveCheckChanged(object sender, EventArgs e)
        {
            CheckBox chk = sender as CheckBox;
            if (chk.IsChecked == true)
            {
                _userCanSaveConfig = true;
            }
            else
            {
                _userCanSaveConfig = false;
            }
        }

        void advancedOptions_OnModifyVisCheckChanged(object sender, EventArgs e)
        {
            CheckBox chk = sender as CheckBox;
            if (chk.IsChecked == true)
            {
                navBar.UserCanEditVISettings = true;
            }
            else
            {
                navBar.UserCanEditVISettings = false;
            }
        }

        void advancedOptions_OnAddExeClicked(object sender, EventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            Dialogs.Exes.AddExe add = new SeciUserInterface.Dialogs.Exes.AddExe();
            if (add.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                _changesMade = true;
                _backgroundAutoSave.RunWorkerAsync();
            }

            Seci.Managers.SeciMgr.IsBusy = false;
        }

        void advancedOptions_OnRemoveExeClicked(object sender, EventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            Dialogs.Exes.RemoveExe remove = new SeciUserInterface.Dialogs.Exes.RemoveExe();
            if (remove.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                _changesMade = true;
                _backgroundAutoSave.RunWorkerAsync();
            }

            Seci.Managers.SeciMgr.IsBusy = false;
        }

        void advancedOptions_OnAddAssocFileClicked(object sender, EventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            Dialogs.AssocFiles.AddFile add = new Dialogs.AssocFiles.AddFile();
            if (add.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                _changesMade = true;
                setupIniFiles(false);
                _backgroundAutoSave.RunWorkerAsync();
            }

            Seci.Managers.SeciMgr.IsBusy = false;
        }

        void advancedOptions_OnRemoveAssocFileClicked(object sender, EventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            Dialogs.AssocFiles.RemoveFile remove = new Dialogs.AssocFiles.RemoveFile();
            if (remove.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                _changesMade = true;
                _backgroundAutoSave.RunWorkerAsync();
            }

            Seci.Managers.SeciMgr.IsBusy = false;
        }

        void advancedOptions_OnConfigureGraphsClicked(object sender, EventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            Dialogs.Graphs.ConfigureGraphs conf;

            if (Properties.Settings.Default.GraphsOnGenieTab)
            {
                conf = new SeciUserInterface.Dialogs.Graphs.ConfigureGraphs(Seci.Definitions.Status.MaxNumberGenieGraphs);
            }
            else
            {
                conf = new SeciUserInterface.Dialogs.Graphs.ConfigureGraphs(Seci.Definitions.Status.MaxNumberGraphs);
            }
            conf.Graphs = getDefinitions();
            if (conf.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                setDefinitions(conf.Graphs);
                setupGraphs(conf.Graphs);
            }

            Seci.Managers.SeciMgr.IsBusy = false;
        }

        void advancedOptions_OnConfigAlertsClicked(object sender, EventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            Dialogs.Alerts.ConfigureAlertSystem alerts = new Dialogs.Alerts.ConfigureAlertSystem();
            alerts.Alerts = Seci.Managers.AlertsMgr.GetAlertsCopy();
            alerts.PhoneNumbers = Seci.Managers.AlertsMgr.GetPhoneNumbersCopy();

            if (alerts.ShowDialog() == true)
            {
                Seci.Managers.AlertsMgr.SetAlerts(alerts.Alerts);
                Seci.Managers.AlertsMgr.SetPhoneNumbers(alerts.PhoneNumbers);
                Seci.Managers.AlertsMgr.SavePhoneNumbers();
            }

            Seci.Managers.SeciMgr.IsBusy = false;
        }

        void advancedOptions_OnHideTabsClicked(object sender, EventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            Dialogs.Tabs.HideTabs hide = new Dialogs.Tabs.HideTabs(Seci.Managers.ConfigurationMgr.GetTabs());
            hide.Owner = this;
            hide.ShowDialog();

            Seci.Managers.SeciMgr.IsBusy = false;
        }

        void advancedOptions_OnShowLostTimeCheckChanged(object sender, EventArgs e)
        {
            CheckBox chk = sender as CheckBox;
            if (chk.IsChecked == true)
            {
                navBar.LostTimeVisible = true;
            }
            else
            {
                navBar.LostTimeVisible = false;
            }

            navBar.SetTabsVisibility(_manager);
        }

        void advancedOptions_OnPlotOnGenieTabCheckChanged(object sender, EventArgs e)
        {
            CheckBox chk = sender as CheckBox;
            if (chk.IsChecked == true)
            {
                Properties.Settings.Default.GraphsOnGenieTab = true;
            }
            else
            {
                Properties.Settings.Default.GraphsOnGenieTab = false;
            }
            setupGraphs(Seci.Managers.ConfigurationMgr.GetGraphDefinitions());
        }

        void advancedOptions_OnAddSubConfigClicked(object sender, EventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            System.Windows.Forms.OpenFileDialog openFileDialog1 = new System.Windows.Forms.OpenFileDialog();
            openFileDialog1.InitialDirectory = Seci.Definitions.Status.ConfigDir;
            openFileDialog1.Filter = "SECI Sub-Configuration|*.comp";

            if (openFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                _splashscreen = new Forms.SeciSplashscreen("Adding Sub-Configuration - please wait", this);
                _splashscreen.Show();

                pauseTimers();

                if (Seci.Managers.ComponentMgr.AddComponent(openFileDialog1.FileName))
                {
                    blocksDisplay.SetBlocksToShow(Seci.Managers.BlockMgr.Blocks.GetKeys());
                    setupTabs();
                    cascadeTabs();
                    setupGraphs(Seci.Managers.ConfigurationMgr.GetGraphDefinitions());
                    eventViewer.AddMessage("Component Added: " + openFileDialog1.FileName.Substring(openFileDialog1.FileName.LastIndexOf("\\") + 1), false);

                    //May need to update block list for Genie
                    if (Seci.Definitions.Status.UseDaeMonitorVI)
                    {
                        Seci.Standard.DaeMonitor.WriteBlockList();
                    }

                    _changesMade = true;
                }

                resumeTimers();

                _splashscreen.Close();
            }
            Seci.Managers.SeciMgr.IsBusy = false;
        }

        void advancedOptions_OnRemoveSubConfigClicked(object sender, EventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            Dialogs.SubConfigs.RemoveSubConfig remove = new SeciUserInterface.Dialogs.SubConfigs.RemoveSubConfig();
            if (remove.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                _splashscreen = new Forms.SeciSplashscreen("Removing Sub-Configuration(s) - please wait", this);
                _splashscreen.Show();

                if (remove.toRemove.Count > 0)
                {
                    pauseTimers();

                    foreach (String name in remove.toRemove)
                    {
                        removeSubConfig(name);
                        eventViewer.AddMessage("Component Removed: " + name, false);
                    }

                    //May need to update block list for Genie
                    if (Seci.Definitions.Status.UseDaeMonitorVI)
                    {
                        Seci.Standard.DaeMonitor.WriteBlockList();
                    }

                    resumeTimers();
                    _changesMade = true;
                    _backgroundAutoSave.RunWorkerAsync();
                }

                _splashscreen.Close();
            }

            Seci.Managers.SeciMgr.IsBusy = false;
        }

        void advancedOptions_OnEditSubConfigClicked(object sender, EventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            if (Seci.Standard.Dae.RunStatus != "SETUP")
            {
                MessageBox.Show("Sub-Configurations can only be edited when in SETUP", "SECI - Not in SETUP");
            }
            else
            {
                if (Seci.Managers.ComponentMgr.Components.Count > 0)
                {
                    Dialogs.SubConfigs.SelectSubConfig select = new Dialogs.SubConfigs.SelectSubConfig();
                    select.Owner = this;

                    if (select.ShowDialog() == true)
                    {
                        _splashscreen = new Forms.SeciSplashscreen("Reloading Sub-Configuration(s) - please wait", this);
                        _splashscreen.Show();

                        //Pause threads and reload component
                        pauseTimers();

                        removeSubConfig(select.ComponentName);

                        Seci.Managers.ComponentMgr.AddComponent(Seci.Definitions.Status.ConfigDir + select.ComponentName);

                        blocksDisplay.SetBlocksToShow(Seci.Managers.BlockMgr.Blocks.GetKeys());
                        setupTabs();
                        cascadeTabs();
                        setupGraphs(Seci.Managers.ConfigurationMgr.GetGraphDefinitions());

                        //May need to update block list for Genie
                        if (Seci.Definitions.Status.UseDaeMonitorVI)
                        {
                            Seci.Standard.DaeMonitor.WriteBlockList();
                        }

                        resumeTimers();
                        _changesMade = false;
                        _splashscreen.Close();
                    }
                }
                else
                {
                    MessageBox.Show("No sub-configurations in the current configuration", "SECI - No Sub-Configurations");
                }
            }
            Seci.Managers.SeciMgr.IsBusy = false;
        }

        void advancedOptions_OnUsePythonChanged(object sender, EventArgs e)
        {
            CheckBox chk = sender as CheckBox;
            if (chk.IsChecked == true)
            {
                setToPython();
            }
            else
            {
                setToGenie();
            }
        }

        void advancedOptions_OnTwoGeniesCheckChanged(object sender, EventArgs e)
        {
            CheckBox chk = sender as CheckBox;
            if (chk.IsChecked == true)
            {
                navBar.TwoGeniesAvailable = true;
            }
            else
            {
                navBar.TwoGeniesAvailable = false;
            }
        }

        void advancedOptions_OnShowBeamloggerCheckChanged(object sender, EventArgs e)
        {
            CheckBox chk = sender as CheckBox;
            setBeamloggerTabVisibility(chk.IsChecked);
        }

        void advancedOptions_OnBigFontsDashboardCheckChanged(object sender, EventArgs e)
        {
            CheckBox chk = sender as CheckBox;
            if (chk.IsChecked == true)
            {
                SeciControls.StandardDashboard.SetIsBigFonts(_dashboard, true);
                SeciControls.BlockDisplay.SetIsBigFonts(blocksDisplay, true);
            }
            else
            {
                SeciControls.StandardDashboard.SetIsBigFonts(_dashboard, false);
                SeciControls.BlockDisplay.SetIsBigFonts(blocksDisplay, false);
            }
        }

        void advancedOptions_OnJournelViewerCheckChanged(object sender, EventArgs e)
        {
            CheckBox chk = sender as CheckBox;
            if (chk.IsChecked == true)
            {
                navBar.JournelViewerVisible = true;
                navBar.SetTabsVisibility(_manager);
            }
            else
            {
                navBar.JournelViewerVisible = false;
                navBar.SetTabsVisibility(_manager);
            }
        }

        void advancedOptions_OnWebDashboardEnabledCheckChanged(object sender, EventArgs e)
        {
            CheckBox chk = sender as CheckBox;
            if (chk.IsChecked == true)
            {
                Seci.Managers.SeciMgr.WebDashboardEnabled = true;
            }
            else
            {
                Seci.Managers.SeciMgr.WebDashboardEnabled = false;
            }
        }

        void advancedOptions_OnWebDashboardShowTitleCheckChanged(object sender, EventArgs e)
        {
            CheckBox chk = sender as CheckBox;
            if (chk.IsChecked == true)
            {
                Seci.Managers.SeciMgr.WebDashboardShowTitle = true;
            }
            else
            {
                Seci.Managers.SeciMgr.WebDashboardShowTitle = false;
            }
        }

        void removeSubConfig(String name)
        {
            Seci.Managers.ComponentMgr.RemoveComponent(name);
            blocksDisplay.SetBlocksToShow(Seci.Managers.BlockMgr.Blocks.GetKeys());
            viTab.RemoveAllTabs();
            addBeamloggerTab();
            setupTabs();
            cascadeTabs();
            setupGraphs(Seci.Managers.ConfigurationMgr.GetGraphDefinitions());
        }

        private void addBeamloggerTab()
        {
            //Add the tab
            if (!viTab.GetAllVisInTabs().Contains(_beamlogTabname))
            {
                viTab.AddTab(_beamlogTabname);
            }

            Seci.Managers.ConfigurationMgr.GetTabs().Add(new Seci.Definitions.Tab(_beamlogTabname, true));

            //Add the vi
            Seci.Standard.BeamLogger.ShowVi();
            viTab.AddVi(_beamlogTabname, Seci.Standard.BeamLogger.FilePath);
            cascadeTabs();

            setBeamloggerTabVisibility(true);
        }

        private void setBeamloggerTabVisibility(Boolean? visible)
        {
            if (visible == true)
            {
                viTab.UnhideTab(_beamlogTabname);
                viTab.SelectTab(0);
                Seci.Managers.ConfigurationMgr.SetTabVisibility(_beamlogTabname, true);
            }
            else
            {
                viTab.HideTab(_beamlogTabname);
                viTab.SelectTab(-1);
                Seci.Managers.ConfigurationMgr.SetTabVisibility(_beamlogTabname, false);
            }
        }

        #endregion

        #region Recent Configs Stuff

        private void setupRecentConfigs()
        {
            String raw = Properties.Settings.Default.RecentConfigs;

            if (!String.IsNullOrEmpty(raw))
            {
                if (raw.EndsWith(";"))
                {
                    raw = raw.Substring(0, raw.Length - 1);
                }

                String[] confs = raw.Split(';');
                _recentConfigs = new List<string>(confs);
            }
            updateRecentConfigsMenu();
        }

        private void updateRecentConfigs(String config)
        {
            Properties.Settings.Default.LastConfig = config;

            if (config != "")
            {
                if (!_recentConfigs.Contains(config))
                {
                    _recentConfigs.Insert(0, config);
                }
                else
                {
                    _recentConfigs.Remove(config);
                    _recentConfigs.Insert(0, config);
                }

                while (_recentConfigs.Count > _numberLastConfigs)
                {
                    _recentConfigs.RemoveAt(_recentConfigs.Count - 1);
                }

                updateRecentConfigsMenu();

                String confs = "";

                for (int i = 0; i < _numberLastConfigs; ++i)
                {
                    if (_recentConfigs != null && i < _recentConfigs.Count)
                    {
                        if (_recentConfigs[i] != "")
                        {
                            confs += _recentConfigs[i] + ";";
                        }
                    }
                }

                Properties.Settings.Default.RecentConfigs = confs;
            }
            Properties.Settings.Default.Save();
        }

        private void updateRecentConfigsMenu()
        {
            List<String> recent = new List<string>();

            for (int i = 0; i < _recentConfigs.Count; ++i)
            {
                if (i >= _numberLastConfigs)
                {
                    break;
                }

                if (!String.IsNullOrEmpty(_recentConfigs[i]))
                {
                    recent.Add(_recentConfigs[i]);
                }
            }

            fileMenu.SetLastConfigs(recent);
        }

        void OnRecentConfig_Click(object sender, RoutedEventArgs e)
        {
            Seci.Managers.SeciMgr.IsBusy = true;

            System.Windows.Forms.ToolStripMenuItem temp = sender as System.Windows.Forms.ToolStripMenuItem;

            foreach (String filepath in _recentConfigs)
            {
                if (filepath.EndsWith(temp.Text.ToString()))
                {
                    //Check conf exists
                    FileInfo fi = new FileInfo(Seci.Definitions.Status.ConfigDir + filepath);
                    if (fi.Exists)
                    {
                        openConfig(Seci.Definitions.Status.ConfigDir + filepath, true);
                        break;
                    }
                    else
                    {
                        MessageBox.Show("File does not exist, it probably has been deleted for some reason", "SECI - File Not Found");
                        //Remove it from the list
                        _recentConfigs.Remove(filepath);
                        updateRecentConfigsMenu();
                        break;
                    }
                }
            }

            Seci.Managers.SeciMgr.IsBusy = false;
        }

        #endregion

        #region Graphing

        private void setupGraphs(List<Seci.Definitions.GraphDefinition> graphs)
        {
            deleteGraphs();

            if (graphs != null && graphs.Count > 0)
            {
                navBar.GraphsAvailable = !Properties.Settings.Default.GraphsOnGenieTab;
                setupGraphPanel(graphs.Count);

                foreach (Seci.Definitions.GraphDefinition def in graphs)
                {
                    SeciControls.Graphing.GraphWrapper temp = new SeciControls.Graphing.GraphWrapper();
                    temp.SetupGraph(def);
                    _graphs.Add(temp);

                    if (Properties.Settings.Default.GraphsOnGenieTab)
                    {
                        if (genieGraphPanel.Children.Count < Seci.Definitions.Status.MaxNumberGenieGraphs)
                        {
                            genieGraphPanel.Children.Add(temp);
                        }
                        else
                        {
                            int max = Seci.Definitions.Status.MaxNumberGenieGraphs;
                            eventViewer.AddMessage("The number of graphs exceeds the maximum allowed (" + max
                                + "). Only the first " + max + " will be shown.", false);
                            break;
                        }
                    }
                    else
                    {
                        graphPanel.Children.Add(temp);
                    }
                }
            }
            else
            {
                navBar.GraphsAvailable = false;
            }

            navBar.SetTabsVisibility(_manager);
        }

        private void deleteGraphs()
        {
            _graphs.Clear();
            if (Properties.Settings.Default.GraphsOnGenieTab)
            {
                genieGraphPanel.Children.Clear();
            }
            else
            {
                graphPanel.Children.Clear();
            }
        }

        private void setupGraphPanel(int numGraphs)
        {
            if (Properties.Settings.Default.GraphsOnGenieTab)
            {
                genieGraphPanel.Children.Clear();

                //Limit to two columns max
                if (numGraphs == 1)
                {
                    genieGraphPanel.Columns = 1;
                }
                else
                {
                    genieGraphPanel.Columns = 2;
                }

                if (numGraphs % 2 == 0)
                {
                    genieGraphPanel.Rows = numGraphs / 2 - 1;
                }
                else
                {
                    genieGraphPanel.Rows = numGraphs / 2;
                }
            }
            else
            {
                graphPanel.Children.Clear();

                //Limit to two columns max
                if (numGraphs == 1)
                {
                    graphPanel.Columns = 1;
                }
                else
                {
                    graphPanel.Columns = 2;
                }


                if (numGraphs == 2)
                {
                    graphPanel.Rows = 2;
                }
                else if (numGraphs % 2 == 0)
                {
                    graphPanel.Rows = numGraphs / 2;
                }
                else
                {
                    graphPanel.Rows = numGraphs / 2 + 1;
                }
            }
        }

        private List<Seci.Definitions.GraphDefinition> getDefinitions()
        {
            return Seci.Managers.ConfigurationMgr.GetGraphDefinitions();
        }


        private void setDefinitions(List<Seci.Definitions.GraphDefinition> graphs)
        {
            Seci.Managers.ConfigurationMgr.SetGraphDefinitions(graphs);
        }

        #endregion

        private void setupEventHandlers()
        {
            //Background save
            _backgroundSave.DoWork += new DoWorkEventHandler(backgroundSave_DoWork);
            _backgroundSave.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundSave_RunWorkerCompleted);

            //Background autosave
            _backgroundAutoSave.DoWork += new DoWorkEventHandler(backgroundAutoSave_DoWork);

            //Experiment Details Tab
            navBar.OnExperimentDetailsClicked += new EventHandler(navBar_OnExperimentDetailsClicked);

            //Vi Tab
            navBar.OnVIsClicked += new EventHandler(navBar_OnVIsClicked);
            navBar.OnAddVIClicked += new EventHandler(navBar_OnAddVIClicked);
            navBar.OnRemoveVIClicked += new EventHandler(navBar_OnRemoveVIClicked);
            navBar.OnConfigureVIClicked += new EventHandler(navBar_OnConfigureVIClicked);
            navBar.OnEditTabsClicked += new EventHandler(navBar_OnEditTabsClicked);
            navBar.OnConfigureBlocksClicked += new EventHandler(navBar_OnConfigureBlocksClicked);
            navBar.OnDisplayBlocksClicked += new EventHandler(navBar_OnDisplayBlocksClicked);
            navBar.OnLostTimeClicked += new EventHandler(navBar_OnLostTimeClicked);

            //Open Genie Tab
            navBar.OnOpenGenieClicked += new EventHandler(navBar_OnOpenGenieClicked);

            //Dae Tab
            navBar.OnDaeClicked += new EventHandler(navBar_OnDaeClicked);

            //Graphs Tab
            navBar.OnGraphsClicked += new EventHandler(navBar_OnGraphsClicked);
            Seci.Managers.SeciMgr.ClearGraphRequested += new Seci.Managers.SeciMgr.RemotingEventHandler(SeciMgr_ClearGraphRequested);

            //Settings Tab
            navBar.OnSettingsClicked += new EventHandler(navBar_OnSettingsClicked);

            //Advanced Options Tab
            navBar.OnAdvancedClicked += new EventHandler(navBar_OnAdvancedClicked);

            //Journal Viewer Tab
            navBar.OnJournalViewerClicked += new EventHandler(navBar_OnJournalViewerClicked);

            //System Messages Tab
            navBar.OnSystemMessagesClicked += new EventHandler(navBar_OnSystemMessagesClicked);

            //Beam Status Tab
            navBar.OnBeamStatusClicked += new EventHandler(navBar_OnBeamStatusClicked);

            //Isis Messages Tab
            navBar.OnIsisMessagesClicked += new EventHandler(navBar_OnIsisMessagesClicked);

            //Report a Problem Tab
            navBar.OnReportProblemClicked += new EventHandler(navBar_OnReportProblemClicked);

            //Help Tab
            navBar.OnHelpClicked += new EventHandler(navBar_OnHelpClicked);

            //User Info
            userInfo.OnEditUsersClicked += new EventHandler(userInfo_OnEditUsersClicked);

            //Expand and collapse dashboard
            _dashboard.OnExpanded += new RoutedEventHandler(dashboard_OnExpanded);
            _dashboard.OnUnexpanded += new RoutedEventHandler(dashboard_OnCollapsed);

            //Scripting windows relaunched
            OpenGenie1.OnNewScriptingProcessStarted += new EventHandler(OpenGenie_OnNewScriptingProcessStarted);
            OpenGenie2.OnNewScriptingProcessStarted += new EventHandler(OpenGenie_OnNewScriptingProcessStarted);

            //Change configuration requested
            Seci.Managers.ConfigurationMgr.ConfigChangeRequested += new Seci.Managers.RemotingEventHandler(ConfigurationMgr_ConfigChangeRequested);

            advancedOptions.OnDaeAvailableCheckChanged += new EventHandler(advancedOptions_OnCheckStatusChanged);
            advancedOptions.OnVisAvailableCheckChanged += new EventHandler(advancedOptions_OnVisAvailableCheckChanged);
            advancedOptions.OnModifyVisCheckChanged += new EventHandler(advancedOptions_OnModifyVisCheckChanged);
            advancedOptions.OnUserCanSaveCheckChanged += new EventHandler(advancedOptions_OnUserCanSaveCheckChanged);
            advancedOptions.OnAddExeClicked += new EventHandler(advancedOptions_OnAddExeClicked);
            advancedOptions.OnRemoveExeClicked += new EventHandler(advancedOptions_OnRemoveExeClicked);
            advancedOptions.OnConfigureGraphsClicked += new EventHandler(advancedOptions_OnConfigureGraphsClicked);
            advancedOptions.OnUsePythonChanged += new EventHandler(advancedOptions_OnUsePythonChanged);
            advancedOptions.OnTwoGeniesCheckChanged += new EventHandler(advancedOptions_OnTwoGeniesCheckChanged);
            advancedOptions.OnShowBeamloggerCheckChanged += new EventHandler(advancedOptions_OnShowBeamloggerCheckChanged);
            advancedOptions.OnBigFontsDashboardCheckChanged += new EventHandler(advancedOptions_OnBigFontsDashboardCheckChanged);
            advancedOptions.OnJournelViewerCheckChanged += new EventHandler(advancedOptions_OnJournelViewerCheckChanged);
            advancedOptions.OnWebDashboardEnabledCheckChanged += new EventHandler(advancedOptions_OnWebDashboardEnabledCheckChanged);
            advancedOptions.OnWebDashboardShowTitleCheckChanged += new EventHandler(advancedOptions_OnWebDashboardShowTitleCheckChanged);
            advancedOptions.OnAddAssocFileClicked += new EventHandler(advancedOptions_OnAddAssocFileClicked);
            advancedOptions.OnRemoveAssocFileClicked += new EventHandler(advancedOptions_OnRemoveAssocFileClicked);
            advancedOptions.OnAddSubConfigClicked += new EventHandler(advancedOptions_OnAddSubConfigClicked);
            advancedOptions.OnRemoveSubConfigClicked += new EventHandler(advancedOptions_OnRemoveSubConfigClicked);
            advancedOptions.OnEditSubConfigClicked += new EventHandler(advancedOptions_OnEditSubConfigClicked);
            advancedOptions.OnPlotOnGenieTabCheckChanged += new EventHandler(advancedOptions_OnPlotOnGenieTabCheckChanged);
            advancedOptions.OnConfigAlertsClicked += new EventHandler(advancedOptions_OnConfigAlertsClicked);
            advancedOptions.OnHideTabsClicked += new EventHandler(advancedOptions_OnHideTabsClicked);
            advancedOptions.OnShowLostTimeCheckChanged += new EventHandler(advancedOptions_OnShowLostTimeCheckChanged);
            //advancedOptions.OnLogBlocksCheckChanged += new EventHandler(advancedOptions_OnLogBlocksCheckChanged);

            errorViewer.OnQuestionAsked += new SeciControls.MessagesWrapper.QuestionHandler(pauseTimers);
            errorViewer.OnQuestionAnswered += new SeciControls.MessagesWrapper.QuestionHandler(resumeTimers);

            SeciControls.EventViewer.OnError += new SeciControls.EventViewer.SeciErrorHandler(EventViewer_OnError);
        }

        void OpenGenie_OnNewScriptingProcessStarted(object sender, EventArgs e)
        {
            //Update the saved PIDs
            saveScriptingPids();
        }

        void ConfigurationMgr_ConfigChangeRequested(string[] vars)
        {
            if (vars != null && vars.Length == 1)
            {
                Action action = delegate()
                {
                    Seci.Managers.SeciMgr.IsBusy = true;
                    openConfig(vars[0], true);
                    Seci.Managers.SeciMgr.IsBusy = false;
                };

                this.Dispatcher.Invoke(action);
            }
        }

        void SeciMgr_ClearGraphRequested(string[] vars)
        {
            this.Dispatcher.Invoke(new UpdateGuiDelegate(clearGraphs), null);
        }

        void clearGraphs()
        {
            foreach (SeciControls.Graphing.GraphWrapper graph in _graphs)
            {
                graph.ClearGraphPoints();
            }
        }

        void dashboard_OnCollapsed(object sender, EventArgs e)
        {
            blocksDisplay.Visibility = Visibility.Collapsed;
        }

        void dashboard_OnExpanded(object sender, EventArgs e)
        {
            blocksDisplay.Visibility = Visibility.Visible;
        }

        private void EventViewer_OnError(string message)
        {
            MessageBox.Show(message, "Seci Error", MessageBoxButton.OK, MessageBoxImage.Error);
        }

        private Boolean labViewRunning(Boolean force)
        {
            System.Diagnostics.Process[] procList;

            procList = System.Diagnostics.Process.GetProcessesByName("LabView");

            if (procList.GetLength(0) > 0)
            {
                _splashscreen.Hide();
                if (force || MessageBox.Show("It appears that LabVIEW is running - SECI cannot start if LabVIEW is already running.\n\nWould you like SECI to close LabVIEW and continue loading? \n\nNote: any unsaved changes to VI's will be lost.", "LabVIEW Running!", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes)
                {
                    try
                    {
                        Seci.Helpers.MessageLogger.WriteMessage("UserInterface", "User chose to close LabVIEW");
                        procList[0].Kill();
                        _splashscreen.Show();
                        return false;
                    }
                    catch
                    {
                    }
                }
                else
                {
                    return true;
                }
            }

            return false;
        }
    }
}