AddEditBlock.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace SeciUserInterface.Dialogs.Blocks
{

    public partial class AddEditBlock : Form
    {
        public Seci.Definitions.BlockInfo Block;
        public Seci.BlockDictionary Dictionary;
        public Boolean IsComponent = false;
        private Boolean _isEdit;

        public AddEditBlock()
        {
            InitializeComponent();
        }

        private void AddBlock_Load(object sender, EventArgs e)
        {
            try
            {
                if (Block == null)
                {
                    _isEdit = false;

                    //Add
                    fillInVIs();
                    txtLower.Text = "-Infinity";
                    txtUpper.Text = "Infinity";
                    comFormatting.SelectedIndex = 0;
                }
                else
                {
                    _isEdit = true;
                    this.Text = "SECI - Edit Block";

                    //Edit
                    fillInVIs();
                    txtBlockName.Text = Block.BlockName;
                    txtUnits.Text = Block.BlockUnits;
                    txtAlias.Text = Block.Alias;

                    txtLogRate.Text = Block.LoggingRate.ToString();

                    comVI.SelectedItem = Block.ParentVI.ToLower();
                    comRead.SelectedItem = Block.ReadControl;

                    chkEnabled.Checked = Block.BlockEnabled;
                    chkVisible.Checked = Block.Visible;

                    if (Block.ApplyFormatting)
                    {
                        comFormatting.SelectedIndex = 0;
                    }
                    else if (Block.ApplyFixedFormatting)
                    {
                        comFormatting.SelectedIndex = 1;
                    }
                    else
                    {
                        comFormatting.SelectedIndex = 2;
                    }

                    txtDecPlaces.Text = Block.NumberDecimalPlaces.ToString();

                    //Logging
                    if (Block.LogValueToFile)
                    {
                        radLog.Checked = true;
                        if (Block.LogChangesTolerance)
                        {
                            chkOnlyIfChanged.Checked = true;
                            txtLogTolerance.Text = Block.Tolerance.ToString();
                        }
                        else
                        {
                            chkOnlyIfChanged.Checked = false;
                        }

                        if (Block.LogChangesOnly)
                        {
                            radOnlyChangesTol.Checked = true;
                            txtTolerance.Text = Block.Tolerance.ToString();
                        }
                    }
                    else
                    {
                        //No logging
                        radNoLogging.Checked = true;
                    }

                    chkLogToSingleFile.Checked = Block.LogToSharedFile;

                    if (Block.WriteControl != null)
                    {
                        comWrite.SelectedItem = Block.WriteControl;
                    }

                    if (Block.GoButton != null)
                    {
                        comGo.SelectedItem = Block.GoButton;
                    }

                    if (Block.WaitForControl != null)
                    {
                        comWaitfor.SelectedItem = Block.WaitForControl;
                    }

                    //if (Block.UnderRunControl)
                    //{
                    chkRuncontrol.Checked = Block.UnderRunControl; //true;
                    Seci.Definitions.ControlType type = Seci.Managers.LabViewMgr.GetControlType(comVI.SelectedItem.ToString(), comRead.SelectedItem.ToString());
                    if (type == Seci.Definitions.ControlType.BOOLEAN || type == Seci.Definitions.ControlType.STRING)
                    {
                        txtRCValue.Text = Block.RunControlValue;
                    }
                    else
                    {
                        txtUpper.Text = Block.UpperLimit.ToString();
                        txtLower.Text = Block.LowerLimit.ToString();
                    }
                    //}

                    chkSaveSettings.Checked = Block.SaveSettings;

                    if (IsComponent)
                    {
                        txtBlockName.ReadOnly = true;
                    }
                }

                if (Seci.Definitions.Status.LogAllBlocksToSingleFile)
                {
                    chkLogToSingleFile.Checked = true;
                    chkLogToSingleFile.Enabled = false;
                }

            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
            }
        }

        private void fillInVIs()
        {
            //Get list of VI's
            Seci.SerialisableList<Seci.LabView.LabViewPanelInfo> panels = Seci.Managers.LabViewMgr.GetAllPanelsInfo();

            for (int i = 0; i < panels.Count; ++i)
            {
                comVI.Items.Add(panels[i].FilePath.ToLower());
            }

            //Add DAE
            comVI.Items.Add(Seci.Standard.Dae.FilePath.ToLower());

            //Add Beam Logger
            comVI.Items.Add(Seci.Standard.BeamLogger.FilePath.ToLower());
        }

        private void fillInControls(String VIname)
        {
            try
            {
                String[] controls = Seci.Managers.LabViewMgr.GetVIControls(VIname).ToArray();
                //Read
                comRead.Items.Clear();
                comRead.Items.AddRange(controls);
                comRead.SelectedIndex = -1;

                //Write
                comWrite.Items.Clear();
                comWrite.Items.AddRange(controls);
                comWrite.SelectedIndex = -1;

                //Go
                comGo.Items.Clear();
                comGo.Items.AddRange(controls);
                comGo.SelectedIndex = -1;

                //Waitfor
                comWaitfor.Items.Clear();
                comWaitfor.Items.AddRange(controls);
                comWaitfor.SelectedIndex = -1;
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
            }
        }

        private void comVI_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (comVI.SelectedIndex != -1)
            {
                fillInControls(comVI.SelectedItem.ToString());
            }
        }

        private void btnClearWrite_Click(object sender, EventArgs e)
        {
            comWrite.SelectedIndex = -1;
        }

        private void btnClearGo_Click(object sender, EventArgs e)
        {
            comGo.SelectedIndex = -1;
        }

        private void btnClearWaitfor_Click(object sender, EventArgs e)
        {
            comWaitfor.SelectedIndex = -1;
        }

        private void btnOK_Click(object sender, EventArgs e)
        {
            //Check that the required options are chosen
            if (checkFilledOutCorrectly())
            {
                Seci.Definitions.BlockInfo newBlock = new Seci.Definitions.BlockInfo();

                //Always present
                newBlock.BlockName = txtBlockName.Text;
                newBlock.BlockUnits = txtUnits.Text;
                newBlock.ParentVI = comVI.SelectedItem.ToString();
                newBlock.Alias = txtAlias.Text;

                newBlock.ReadControl = comRead.SelectedItem.ToString();
                newBlock.LoggingRate = Convert.ToSingle(txtLogRate.Text);

                newBlock.BlockEnabled = chkEnabled.Checked;
                newBlock.Visible = chkVisible.Checked;

                if (comFormatting.SelectedIndex == 0)
                {
                    newBlock.ApplyFormatting = true;
                    newBlock.ApplyFixedFormatting = false;
                    newBlock.NumberDecimalPlaces = Int32.Parse(txtDecPlaces.Text);
                }
                else if (comFormatting.SelectedIndex == 1)
                {
                    newBlock.ApplyFormatting = false;
                    newBlock.ApplyFixedFormatting = true;
                    newBlock.NumberDecimalPlaces = Int32.Parse(txtDecPlaces.Text);
                }
                else
                {
                    newBlock.ApplyFormatting = false;
                    newBlock.ApplyFixedFormatting = false;
                    newBlock.NumberDecimalPlaces = Int32.Parse(txtDecPlaces.Text);
                }

                newBlock.ReadType = Seci.Managers.LabViewMgr.GetControlType(comVI.SelectedItem.ToString(), comRead.SelectedItem.ToString());

                //Logging
                newBlock.LoggingRate = Convert.ToSingle(txtLogRate.Text);

                if (radLog.Checked)
                {
                    newBlock.LogValueToFile = true;
                    if (chkOnlyIfChanged.Checked == true)
                    {
                        newBlock.LogChangesTolerance = true;
                        newBlock.Tolerance = Convert.ToDouble(txtLogTolerance.Text);
                        newBlock.LogChangesOnly = false;
                    }
                    else
                    {
                        newBlock.LogChangesTolerance = false;
                        newBlock.LogChangesOnly = false;
                    }
                }
                else if (radOnlyChangesTol.Checked)
                {
                    newBlock.LogValueToFile = true;
                    newBlock.LogChangesTolerance = true;
                    newBlock.LogChangesOnly = true;
                    newBlock.Tolerance = Convert.ToDouble(txtTolerance.Text);
                }
                else
                {
                    //No logging
                    newBlock.LogChangesOnly = false;
                    newBlock.LogValueToFile = false;
                    newBlock.LogChangesTolerance = false;
                    newBlock.Tolerance = 0.0;
                }

                if (newBlock.ReadType == Seci.Definitions.ControlType.NUMERIC)
                {
                    newBlock.SetRunControlLimits(chkRuncontrol.Checked, Convert.ToDouble(txtLower.Text), Convert.ToDouble(txtUpper.Text));
                }
                else if (newBlock.ReadType == Seci.Definitions.ControlType.BOOLEAN || newBlock.ReadType == Seci.Definitions.ControlType.STRING)
                {
                    newBlock.SetRunControlLimits(chkRuncontrol.Checked, txtRCValue.Text);
                }
                else
                {
                    newBlock.SetRunControlLimits(chkRuncontrol.Checked, Convert.ToDouble(txtLower.Text), Convert.ToDouble(txtUpper.Text));
                }

                newBlock.SaveSettings = chkSaveSettings.Checked;

                newBlock.LogToSharedFile = chkLogToSingleFile.Checked;

                if (_isEdit)
                {
                    //Copy the group
                    newBlock.Group = Block.Group;
                }

                if (comWrite.SelectedIndex != -1)
                {
                    newBlock.WriteControl = comWrite.SelectedItem.ToString();
                }

                if (comGo.SelectedIndex != -1)
                {
                    newBlock.GoButton = comGo.SelectedItem.ToString();
                }

                if (comWaitfor.SelectedIndex != -1)
                {
                    newBlock.WaitForControl = comWaitfor.SelectedItem.ToString();
                }

                if (!_isEdit)
                {
                    try
                    {
                        if (newBlock.BlockName.ToLower() == Seci.Definitions.Status.StatusBlockName.ToLower())
                        {
                            MessageBox.Show("Block name is reserved. Please, modify the Block name.", "Block name is not valid", MessageBoxButtons.OK, MessageBoxIcon.Error);
                            return;
                        }

                        if (Dictionary.Contains(newBlock.BlockName))
                        {
                            MessageBox.Show("Block name already exists. Please, modify the Block name.", "Block name is not unique", MessageBoxButtons.OK, MessageBoxIcon.Error);
                            return;
                        }

                        if (!String.IsNullOrEmpty(newBlock.Alias) && !Dictionary.IsAliasUnique(newBlock.Alias))
                        {
                            MessageBox.Show("Alias is not unique. Please, modify the alias.", "Alias is not unique", MessageBoxButtons.OK, MessageBoxIcon.Error);
                            return;
                        }

                        //Add to tempblocks
                        Dictionary.Add(newBlock.BlockName, newBlock);
                    }
                    catch (Exception err)
                    {
                        MessageBox.Show(err.Message, "Error!", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        return;
                    }
                }
                else
                {
                    //Replace the old block - remove then add (in the same place) because the name may have changed
                    //which would change the key
                    try
                    {
                        //Copy over the owning sub-config
                        newBlock.OwningComponent = Block.OwningComponent;
                        Dictionary.Replace(Block.BlockName, newBlock.BlockName, newBlock);
                    }
                    catch (Exception err)
                    {
                        MessageBox.Show(err.Message, "Error!", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        return;
                    }
                }

                DialogResult = DialogResult.OK;
                Close();
            }

        }

        private Boolean checkFilledOutCorrectly()
        {
            List<String> filledList = checkFilledOutandValid();

            if (filledList.Count > 0)
            {
                String message = "The following entries are invalid:";

                for (int i = 0; i < filledList.Count; ++i)
                {
                    message = message + Environment.NewLine + filledList[i];
                }

                MessageBox.Show(message, "Invalid Entries!", MessageBoxButtons.OK, MessageBoxIcon.Warning);

                return false;
            }
            else
            {
                return true;
            }

        }

        private List<String> checkFilledOutandValid()
        {
            List<String> list = new List<String>();

            Double dummy; //Used for testing for valid doubles

            if (txtBlockName.Text == "")
            {
                list.Add(" - No block name entered.");
            }

            if (comVI.SelectedIndex == -1)
            {
                list.Add(" - No VI selected.");
            }

            if (comRead.SelectedIndex == -1)
            {
                list.Add(" - No read control selected.");
            }

            if (chkRuncontrol.Checked)
            {
                Seci.Definitions.ControlType type = Seci.Managers.LabViewMgr.GetControlType(comVI.SelectedItem.ToString(), comRead.SelectedItem.ToString());
                if (type == Seci.Definitions.ControlType.BOOLEAN || type == Seci.Definitions.ControlType.STRING)
                {
                    if (txtRCValue.Text.Trim() == "")
                    {
                        list.Add(" - No value entered for run-control.");
                    }
                }
                else
                {
                    if (txtUpper.Text.Trim() == "")
                    {
                        list.Add(" - No upper limit entered for run-control.");
                    }
                    else
                    {
                        txtUpper.Text = ConfigureBlocks.CheckForInfinity(txtUpper.Text);

                        if (!Double.TryParse(txtUpper.Text, out dummy))
                        {
                            list.Add(" - upper limit value not valid.");
                        }
                    }

                    if (txtLower.Text.Trim() == "")
                    {
                        list.Add(" - No lower limit entered for run-control.");
                    }
                    else
                    {
                        txtLower.Text = ConfigureBlocks.CheckForInfinity(txtLower.Text);

                        if (!Double.TryParse(txtLower.Text, out dummy))
                        {
                            list.Add(" - lower limit value not valid.");
                        }
                    }
                }
            }
            else
            {
                if ((txtUpper.Text == "") || (!Double.TryParse(txtUpper.Text, out dummy)))
                {
                    txtUpper.Text = "0";
                }

                if ((txtLower.Text == "") || (!Double.TryParse(txtLower.Text, out dummy)))
                {
                    txtLower.Text = "0";
                }
            }

            if (radLog.Checked)
            {

                if (txtLogRate.Text == "")
                {
                    list.Add(" - No log rate entered.");
                }
                else
                {
                    if (!Double.TryParse(txtLogRate.Text, out dummy))
                    {
                        list.Add(" - log-rate value not valid.");
                    }
                    else
                    {
                        if (dummy < 5)
                        {
                            list.Add(" - log-rate value must be 5 seconds or higher.");
                        }
                    }
                }
            }
            else if (radOnlyChangesTol.Checked)
            {
                if (txtTolerance.Text == "")
                {
                    list.Add(" - No tolerance entered.");
                }
                else
                {
                    if (!Double.TryParse(txtTolerance.Text, out dummy))
                    {
                        list.Add(" - tolerance value not valid.");
                    }
                }
            }

            int decplaces;

            if (!int.TryParse(txtDecPlaces.Text, out decplaces) || decplaces < 0)
            {
                list.Add(" - number of decimal places not valid.");
            }

            return list;
        }

        //Check that key presses are numeric
        private void NumericOnly_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (!isNumeric(e))
            {
                e.Handled = true;
            }
        }

        //Check that key presses are numeric or letter or underscore
        //Anything else may cause a problem with Open GENIE
        private void isCharValid_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (!isCharValid(e))
            {
                e.Handled = true;
            }
        }

        private Boolean isNumeric(KeyPressEventArgs e)
        {
            // \b is backspace/delete
            if (Char.IsDigit(e.KeyChar) || e.KeyChar == '.' || e.KeyChar == '\b')
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        private Boolean isCharValid(KeyPressEventArgs e)
        {
            // \b is backspace/delete
            if (Char.IsLetterOrDigit(e.KeyChar) || e.KeyChar == '_' || e.KeyChar == '\b')
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        private void chkRuncontrol_CheckedChanged(object sender, EventArgs e)
        {
            if (chkRuncontrol.Checked)
            {
                txtUpper.Enabled = true;
                txtLower.Enabled = true;
                txtRCValue.Enabled = true;
            }
            else
            {
                txtUpper.Enabled = false;
                txtLower.Enabled = false;
                txtRCValue.Enabled = false;
            }
        }

        private void radLog_CheckedChanged(object sender, EventArgs e)
        {
            chkOnlyIfChanged.Enabled = radLog.Checked;
            txtLogRate.Enabled = radLog.Checked;
            txtLogTolerance.Enabled = radLog.Checked && chkOnlyIfChanged.Checked;
        }

        private void chkOnlyIfChanged_CheckedChanged(object sender, EventArgs e)
        {
            txtLogTolerance.Enabled = chkOnlyIfChanged.Checked;
        }

        private void radOnlyChangesTol_CheckedChanged(object sender, EventArgs e)
        {
            txtTolerance.Enabled = radOnlyChangesTol.Checked;
        }

        private void comRead_SelectedIndexChanged(object sender, EventArgs e)
        {
            Seci.Definitions.ControlType type = Seci.Managers.LabViewMgr.GetControlType(comVI.SelectedItem.ToString(), comRead.SelectedItem.ToString());

            if (type == Seci.Definitions.ControlType.NUMERIC)
            {
                txtUpper.Visible = true;
                txtLower.Visible = true;
                lblRCLower.Visible = true;
                lblRCUpper.Visible = true;
                lblRCValue.Visible = false;
                txtRCValue.Visible = false;
            }
            else if (type == Seci.Definitions.ControlType.STRING || type == Seci.Definitions.ControlType.BOOLEAN)
            {
                txtUpper.Visible = false;
                txtLower.Visible = false;
                lblRCLower.Visible = false;
                lblRCUpper.Visible = false;
                lblRCValue.Visible = true;
                txtRCValue.Visible = true;
            }
            else
            {
                txtUpper.Visible = true;
                txtLower.Visible = true;
                lblRCLower.Visible = true;
                lblRCUpper.Visible = true;
                lblRCValue.Visible = false;
                txtRCValue.Visible = false;
            }
        }
    }
}