///
/// Copyright (c) 2019 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using log4net;
using Config.Entities;
using Results.Forms;
using TBF.BenchControl.Generic;
using TBF.BenchControl.GenericDevices;
using TBF.Resources;
using TBF.UI.Shared;
using TBF.BenchControl.Output;
using TBF.BenchControl.TestMethods.iPerlCommunication.iPerlHead;

namespace TBF.UI.Bench.TestProfiles
{
	public partial class TestProfileDlg : Form, IParentOfListViewEx
	{
		static readonly ILog log = LogManager.GetLogger(typeof(TestProfileDlg));

		/// Used when re-scaling the dialog: 100% = 96dpi, 125% = 120dpi, 150% = 144dpi
		public readonly int Dpi;

        readonly bool openUnlocked;

		/// <summary>
		/// Profile to be updated by this dialog.
		/// Set by the constructor or updated by the parent after creation and before loading.
		/// </summary>
		public Profile LoadedProfile;
        public int SelectedTestIx;          /// -1 = none, 0 = 1st = top

		IList<string> usedNames;	        /// Already used names

		/// Auxiliary public lists used also by user controls in tab pages
		public IList<BenchControl.Generic.IComponent> TbfComponents;

		bool unlocked;

		public TestProfileDlg()
		{
			/// Detect display setting: 100% = 96dpi, 125% = 120dpi, 150% = 144dpi.
			Dpi = (int)this.CreateGraphics().DpiX;
            openUnlocked = false;

			InitializeComponent();

            /// SharedDlgButtons configuration
            sharedButtons.RequiredGroupMembership = new Users.Entities.GID[] { Users.Entities.GID.MetrologicalAuthority };

            sharedButtons.OptionalButtons = SharedButtons.Buttons.Add | SharedButtons.Buttons.Remove |
											SharedButtons.Buttons.Up | SharedButtons.Buttons.Down;
            sharedButtons.Unlocked += Unlocked;
			sharedButtons.OKClicked += okButton_Click;
			sharedButtons.CancelClicked += cancelButton_Click;
			sharedButtons.AddClicked += addButton_Click;
			sharedButtons.RemoveClicked += removeButton_Click;
			sharedButtons.UpClicked += upButton_Click;
			sharedButtons.DownClicked += downButton_Click;

			/// ListViewEx-es configuration
            metrologyListViewEx.SubItemClicked += new SubItemEventHandler(metrologyListViewEx_SubItemClicked);
            metrologyListViewEx.SubItemRightClicked += new SubItemEventHandler(metrologyListViewEx_SubItemRightClicked);
            metrologyListViewEx.SubItemEndEditing += new SubItemEndEditingEventHandler(metrologyListViewEx_SubItemEndEditing);

            errorFlagsListViewEx.SubItemClicked += new SubItemEventHandler(errorFlagsListViewEx_SubItemClicked);
            errorFlagsListViewEx.SubItemRightClicked += new SubItemEventHandler(errorFlagsListViewEx_SubItemRightClicked);
            errorFlagsListViewEx.SubItemEndEditing += new SubItemEndEditingEventHandler(errorFlagsListViewEx_SubItemEndEditing);

            errorFlags2ListViewEx.SubItemClicked += new SubItemEventHandler(errorFlags2ListViewEx_SubItemClicked);
            errorFlags2ListViewEx.SubItemRightClicked += new SubItemEventHandler(errorFlags2ListViewEx_SubItemRightClicked);
            errorFlags2ListViewEx.SubItemEndEditing += new SubItemEndEditingEventHandler(errorFlags2ListViewEx_SubItemEndEditing);

            SelectedTestIx = -1;
		}

		public TestProfileDlg(Config.Entities.Profile profile, IList<string> usedNames, bool openUnlocked = false)
			: this()
		{
			if (profile == null) throw new ArgumentNullException("profile");

            LoadedProfile = profile;
			this.usedNames = usedNames;
            this.openUnlocked = openUnlocked;

            sharedButtons.RequiredGroupMembership = new Users.Entities.GID[] { Users.Entities.GID.MetrologicalAuthority };
		}

		private void TestProfileDlg_Load(object sender, EventArgs e)
        {
			Localize();

			if (LoadedProfile == null) return;	/// return in case the dialog is open in the designer

            LoadUISettings();

            procNameTextBox.Enabled = false;
            descriptionTextBox.Enabled = false;

            /// Make some controls readonly
            createdByTextBox.ReadOnly = true;
            createdOnTextBox.ReadOnly = true;
            lastChangedByTextBox.ReadOnly = true;
            lastChangedOnTextBox.ReadOnly = true;

            profileTypeRadioButton1.Enabled = false;
            profileTypeRadioButton2.Enabled = false;
            profileTypeRadioButton3.Enabled = false;
            profileTypeRadioButton4.Enabled = false;
            profileTypeRadioButton5.Enabled = false;

            errorCalculationRadioButton1.Enabled = false;
            errorCalculationRadioButton2.Enabled = false;

            /// LisViewEx columns and edit controls for 'Metrology1', 'Metrology2', 'Process' and 'Parameters' tabs
            PrepareMetrologyTab();
            PrepareErrorFlags();
            PrepareErrorFlags2();

            /// Now refresh the content of the dialog
            RefreshGeneralTab();
            RefreshMetrologyTab();
            RefreshErrorFlagsTab();
            RefreshErrorFlags2Tab();

            /// Optionally unlock this dialog
            if (openUnlocked)
            {
                sharedButtons.UnlockButtons();
                Unlocked(sender, e);
            }
        }

		void Localize()
		{
            Text = Strings.Profile;

            generalTabPage.Text = Strings.General;
            metrologyTabPage.Text = Strings.Metrology;
            errorFlagsTabPage.Text = "Error flags";
            errorFlags2TabPage.Text = "Error flags details";
            
            label1.Text = Strings.Procedure_name;
            label12.Text = Strings.Short_description;
            label13.Text = Strings.Created_by;
            label16.Text = Strings.Last_changed_by;
            label14.Text = Strings.Date;
            label15.Text = Strings.Date;
        }

		#region General

		void RefreshGeneralTab()
		{
			procNameTextBox.Text = LoadedProfile.Name;
			Text = string.Format("{0}  {1}  {2}", Strings.Profile, LoadedProfile.ItemNr + 1, LoadedProfile.Name);

			descriptionTextBox.Text = LoadedProfile.Description;
			createdByTextBox.Text = LoadedProfile.CreationUser;
			createdOnTextBox.Text = LoadedProfile.CreationTime.ToString();
			lastChangedByTextBox.Text = LoadedProfile.LastChgUser;
            if (LoadedProfile.LastChgTime > LoadedProfile.CreationTime)
            {
                lastChangedOnTextBox.Text = LoadedProfile.LastChgTime.ToString();
            }

            switch(LoadedProfile.ProfileType)
            {
                default:
                case ProfileType.Q3R:               profileTypeRadioButton1.Checked = true; break;
                case ProfileType.QnClassColdWater:  profileTypeRadioButton2.Checked = true; break;
                case ProfileType.QnClassHotWater:   profileTypeRadioButton3.Checked = true; break;
                case ProfileType.QpQi:              profileTypeRadioButton4.Checked = true; break;
                case ProfileType.Manual:            profileTypeRadioButton5.Checked = true; break;
            }

            switch(LoadedProfile.ErrorLimitType)
            {
                default:
                case ErrorLimitType.Manual:     errorCalculationRadioButton1.Checked = true; break;
                case ErrorLimitType.QpClass:    errorCalculationRadioButton2.Checked = true; break;
            }
		}

		void UpdateFromGeneralTab()
		{
			LoadedProfile.Name = procNameTextBox.Text;
            Text = string.Format("{0}  {1}  {2}", Strings.Profile, LoadedProfile.ItemNr + 1, LoadedProfile.Name);

			LoadedProfile.Description = descriptionTextBox.Text;

            LoadedProfile.ProfileType =  profileTypeRadioButton1.Checked ? ProfileType.Q3R :
                                        (profileTypeRadioButton2.Checked ? ProfileType.QnClassColdWater :
                                        (profileTypeRadioButton3.Checked ? ProfileType.QnClassHotWater :
                                        (profileTypeRadioButton4.Checked ? ProfileType.QpQi
                                                                         : ProfileType.Manual)));

            LoadedProfile.ErrorLimitType = errorCalculationRadioButton1.Checked ? ErrorLimitType.Manual
                                                                                : ErrorLimitType.QpClass;
        }

		#endregion

        #region Metrology

        Control[] metrologyEditors;

		public enum MtrlgyClmn
		{
			Name,
            Part,
            CoefQfrom,
			CoefQto,
			ErrLimLo,
			ErrLimHi,
            TempLimLo,
            TempLimHi,
            PressLimLo,
			PressLimHi,
            Publish,
            Evaluate,
            ColumnsCount
		}

		void PrepareMetrologyTab()
		{
            ListViewEx lv = metrologyListViewEx;
			lv.Columns.Add(new ColumnHeader { Text = Strings.Test_chdr, Width = 70 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.Part, Width = 40 });
            lv.Columns.Add(new ColumnHeader { Text = string.Format("Coef. {0}", Strings.Q_from), Width = 80 });
			lv.Columns.Add(new ColumnHeader { Text = string.Format("Coef. {0}", Strings.Q_to), Width = 80 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.Err_limit_neg_pct_chdr, Width = 80 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.Err_limit_pos_pct_chdr, Width = 80 });
            lv.Columns.Add(new ColumnHeader { Text = string.Format("{0} [°C]", Strings.Temp_lim_lo_chdr), Width = 100 });
            lv.Columns.Add(new ColumnHeader { Text = string.Format("{0} [°C]", Strings.Temp_lim_hi_chdr), Width = 100 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.Press_lim_lo_chdr, Width = 80 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.Press_lim_hi_chdr, Width = 80 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.Publish, Width = 80 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.Evaluate, Width = 80 });

            ComboBox publishCBox = new ComboBox();   /// control for Publish
            for (Config.Entities.Publish pb = 0; pb < Config.Entities.Publish.Count; pb++)
            {
                publishCBox.Items.Add(pb.ToDescription());
            }

            ComboBox yesNoCBox = new ComboBox();   /// control for Evaluate
            yesNoCBox.Items.Add(Strings.yes);
            yesNoCBox.Items.Add(Strings.no);

			metrologyEditors = new Control[]
				{
					new TextBox(),  /// Name
					new TextBox(),  /// Part
					new TextBox(),  /// CoefQfrom
					new TextBox(),  /// CoefQto
					new TextBox(),  /// Err.Lim. -
					new TextBox(),  /// Err.Lim. +
					new TextBox(),  /// Temp.Lim. -
					new TextBox(),  /// Temp.Lim. +
					new TextBox(),  /// Press.Lim. -
					new TextBox(),  /// Press.Lim. +
					publishCBox,	/// Publish
					yesNoCBox,		/// Evaluate
				};

			foreach (var ctrl in metrologyEditors)
			{
				metrologyTabPage.Controls.Add(ctrl);
			}
		}

        void RefreshMetrologyTab()
        {
            metrologyListViewEx.Items.Clear();
            foreach (var test in LoadedProfile.Tests) AddToMetrologyTab(test);

            if (0 <= SelectedTestIx && SelectedTestIx < metrologyListViewEx.Items.Count)
            {
                metrologyListViewEx.Items[SelectedTestIx].Selected = true;
            }
        }

        void AddToMetrologyTab(PTest pTest)
        {
            ///
            /// Metrology 1 item with subitems
            ///
            ListViewItem lvi = new ListViewItem(pTest.Name);
            lvi.Tag = pTest;
            lvi.SubItems.Add((pTest.Part == 0) ? "-" : pTest.Part.ToString());
            lvi.SubItems.Add(pTest.CoefQfrom.ToString());
            lvi.SubItems.Add(pTest.CoefQto.ToString());
            if (LoadedProfile.ProfileType != ProfileType.QpQi)
            {
                lvi.SubItems.Add(pTest.ErrLimLo.ToString());
                lvi.SubItems.Add(pTest.ErrLimHi.ToString());
            }
            else
            {
                lvi.SubItems.Add(Strings.calculated);
                lvi.SubItems.Add(Strings.calculated);
            }
            lvi.SubItems.Add(pTest.TempLimLo.ToString());
            lvi.SubItems.Add(pTest.TempLimHi.ToString());
            lvi.SubItems.Add(pTest.PressLimLo.ToString());
            lvi.SubItems.Add(pTest.PressLimHi.ToString());
            lvi.SubItems.Add(((Config.Entities.Publish)pTest.Publish).ToDescription());
            lvi.SubItems.Add(pTest.Evaluate ? Strings.yes : Strings.no);

            metrologyListViewEx.Items.Add(lvi);
        }

        void UpdateFromMetrologyTab()
        {
            for (int i = 0; i < metrologyListViewEx.Items.Count; i++)
            {
                try
                {
                    ListViewItem lvi = metrologyListViewEx.Items[i];
                    PTest entity = (PTest)lvi.Tag;

                    entity.Name = lvi.Text;
                    entity.ItemNr = i;

                    int part = entity.Part;
                    if (lvi.SubItems[(int)MtrlgyClmn.Part].Text.Equals("-"))
                    {
                        entity.Part = 0;
                    }
                    else if (int.TryParse(lvi.SubItems[(int)MtrlgyClmn.Part].Text, out part))
                    {
                        entity.Part = part;
                    }

                    entity.CoefQfrom = Utils.ParseUDouble(lvi.SubItems[(int)MtrlgyClmn.CoefQfrom].Text);
				    entity.CoefQto = Utils.ParseUDouble(lvi.SubItems[(int)MtrlgyClmn.CoefQto].Text);
                    if (LoadedProfile.ProfileType != ProfileType.QpQi)
                    {
                        entity.ErrLimLo = Utils.ParseSDouble(lvi.SubItems[(int)MtrlgyClmn.ErrLimLo].Text);
                        entity.ErrLimHi = Utils.ParseSDouble(lvi.SubItems[(int)MtrlgyClmn.ErrLimHi].Text);
                    }
                    else
                    {
                        entity.ErrLimLo = +1.0;
                        entity.ErrLimHi = -1.0;
                    }
                    entity.TempLimLo = Utils.ParseUDouble(lvi.SubItems[(int)MtrlgyClmn.TempLimLo].Text);
                    entity.TempLimHi = Utils.ParseUDouble(lvi.SubItems[(int)MtrlgyClmn.TempLimHi].Text);
                    entity.PressLimLo = Utils.ParseUDouble(lvi.SubItems[(int)MtrlgyClmn.PressLimLo].Text);
                    entity.PressLimHi = Utils.ParseUDouble(lvi.SubItems[(int)MtrlgyClmn.PressLimHi].Text);

                    entity.Evaluate = lvi.SubItems[(int)MtrlgyClmn.Evaluate].Text.Equals(Strings.yes);

                    for (Config.Entities.Publish pb = 0; pb < Config.Entities.Publish.Count; pb++)
                    {
                        if (lvi.SubItems[(int)MtrlgyClmn.Publish].Text.Equals(pb.ToDescription()))
                        {
                            entity.Publish = (sbyte)pb;
                            break;
                        }
                    }
                }
                catch (Exception exc)
                {
                    MessageBox.Show(string.Format("Unexpected problem: {0}", exc.Message));
                }
            }
        }

        private void metrologyListViewEx_SubItemClicked(object sender, SubItemEventArgs e)
        {
            if (LoadedProfile.ProfileType == ProfileType.QpQi &&
                ((e.SubItem == (int)MtrlgyClmn.ErrLimLo) || (e.SubItem == (int)MtrlgyClmn.ErrLimHi)))
            {
                return;         /// Prevent editing calculated error limits
            }

            if (unlocked && (e.SubItem < (int)MtrlgyClmn.ColumnsCount))
			{
				metrologyListViewEx.StartEditing(metrologyEditors[e.SubItem], e.Item, e.SubItem);
			}
        }

        void metrologyListViewEx_SubItemRightClicked(object sender, SubItemEventArgs e)
        {
            if (!unlocked || e.SubItem >= (int)MtrlgyClmn.ColumnsCount) return;

            if (DialogResult.Yes == MessageBox.Show(Strings.Do_you_want_to_copy_this_value_to_all_cells_below_this_cell,
                                                    Strings.Confirmation, MessageBoxButtons.YesNo, MessageBoxIcon.Question))
            {
                int columnNr = e.SubItem;
                string value = null;
                System.Drawing.Color backColor = System.Drawing.Color.White;
                foreach (ListViewItem item in metrologyListViewEx.Items)
                {
                    if (value != null && item.SubItems.Count > columnNr)
                    {
                        item.SubItems[columnNr].Text = value;
                        item.SubItems[columnNr].BackColor = backColor;
                    }
                    else if (item == e.Item)
                    {
                        value = item.SubItems[columnNr].Text;
                        backColor = item.SubItems[columnNr].BackColor;
                    }
                }
            }
        }

        private void metrologyListViewEx_SubItemEndEditing(object sender, SubItemEndEditingEventArgs e)
        {
            if (e.SubItem == (int)MtrlgyClmn.Name)
            {
                if (!Utils.IsGoodFName(e.DisplayText))
                {
                    e.DisplayText = e.Item.SubItems[e.SubItem].Text;
                    e.Cancel = true;
                    return;								/// NOK
                }
            }

            int idummy;
            if (e.SubItem == (int)MtrlgyClmn.Part)
            {
                if (e.DisplayText.Equals("-")) return;	/// OK
                if (!int.TryParse(e.DisplayText, out idummy) || !Test.IsGoodPartNr(idummy))
                {
                    e.DisplayText = e.Item.SubItems[e.SubItem].Text;
                    e.Cancel = true;
                    return;								/// NOK
                }
            }

            double dummy;
            if ((e.SubItem == (int)MtrlgyClmn.CoefQfrom  && !Utils.TryParseUDouble(e.DisplayText, out dummy)) ||
                (e.SubItem == (int)MtrlgyClmn.CoefQto && !Utils.TryParseUDouble(e.DisplayText, out dummy)) ||
                (e.SubItem == (int)MtrlgyClmn.ErrLimLo && !Utils.TryParseSDouble(e.DisplayText, out dummy)) ||
                (e.SubItem == (int)MtrlgyClmn.ErrLimHi && !Utils.TryParseSDouble(e.DisplayText, out dummy)) ||
                (e.SubItem == (int)MtrlgyClmn.TempLimLo && !Utils.TryParseUDouble(e.DisplayText, out dummy)) ||
                (e.SubItem == (int)MtrlgyClmn.TempLimHi && !Utils.TryParseUDouble(e.DisplayText, out dummy)) ||
                (e.SubItem == (int)MtrlgyClmn.PressLimLo && !Utils.TryParseUDouble(e.DisplayText, out dummy)) ||
                (e.SubItem == (int)MtrlgyClmn.PressLimHi && !Utils.TryParseUDouble(e.DisplayText, out dummy)))
            {
                /// Cannot parse => revert content of the cell
                e.DisplayText = e.Item.SubItems[e.SubItem].Text;
                e.Cancel = true;
                return;
            }

            /// Combo boxes
            if ((e.SubItem == (int)MtrlgyClmn.Publish) || (e.SubItem == (int)MtrlgyClmn.Evaluate))
            {
                if (!(metrologyEditors[e.SubItem] as ComboBox).Items.Contains(e.DisplayText))
                {
                    e.DisplayText = e.Item.SubItems[e.SubItem].Text;
                    e.Cancel = true;
                    return;
                }
            }
        }

        #endregion

        #region Error flags

        public enum ErrorFlagsClmn
		{
			Name,
            E1,
            E2,
            E3,
            E4,
            E5,
            E6,
            E7,
            E8,
            E9,
            E10,
            E11,
            E12,
            E13,
            E14,
            E15,
            E16,
            E21,
			ColumnsCount
		}

		Control[] errorFlagsEditors;

		void PrepareErrorFlags()
		{
            ListViewEx lv = errorFlagsListViewEx;
            errorFlagsEditors = new Control[(int)ErrorFlagsClmn.ColumnsCount];
            int ix = 0;

			lv.Columns.Add(new ColumnHeader { Text = Strings.Test_chdr, Width = 70 });
            errorFlagsEditors[ix++] = new TextBox();    /// Name

            string[] ecka = new string[] { "E1", "E2", "E3", "E4", "E5", "E6", "E7", "E8", "E9", "E10", "E11", "E12", "E13", "E14", "E15", "E16", "E21" };
            for (var e = ErrorFlagsClmn.E1; e <= ErrorFlagsClmn.E21; e++)
            {
                /// Column header
                lv.Columns.Add(new ColumnHeader { Text = e.ToString(), Width = 50 });

                /// Edit control
                ComboBox cb = new ComboBox();
                for (ErrorFlagsMode efm = 0; efm < ErrorFlagsMode.Count; efm++) cb.Items.Add(efm.ToDescription());
                errorFlagsEditors[ix++] = cb;
            }
			
            foreach (var ctrl in errorFlagsEditors) errorFlagsTabPage.Controls.Add(ctrl);
		}

        void RefreshErrorFlagsTab()
        {
            errorFlagsListViewEx.Items.Clear();
            foreach (var test in LoadedProfile.Tests) AddToErrorFlagsTab(test);

            if (0 <= SelectedTestIx && SelectedTestIx < errorFlagsListViewEx.Items.Count)
            {
                errorFlagsListViewEx.Items[SelectedTestIx].Selected = true;
            }
        }

        void AddToErrorFlagsTab(PTest pTest)
        {
            ListViewItem lvi = new ListViewItem(pTest.Name);
            lvi.Tag = pTest;
            lvi.SubItems.Add(SByte2String(pTest.E1));
            lvi.SubItems.Add(SByte2String(pTest.E2));
            lvi.SubItems.Add(SByte2String(pTest.E3));
            lvi.SubItems.Add(SByte2String(pTest.E4));
            lvi.SubItems.Add(SByte2String(pTest.E5));
            lvi.SubItems.Add(SByte2String(pTest.E6));
            lvi.SubItems.Add(SByte2String(pTest.E7));
            lvi.SubItems.Add(SByte2String(pTest.E8));
            lvi.SubItems.Add(SByte2String(pTest.E9));
            lvi.SubItems.Add(SByte2String(pTest.E10));
            lvi.SubItems.Add(SByte2String(pTest.E11));
            lvi.SubItems.Add(SByte2String(pTest.E12));
            lvi.SubItems.Add(SByte2String(pTest.E13));
            lvi.SubItems.Add(SByte2String(pTest.E14));
            lvi.SubItems.Add(SByte2String(pTest.E15));
            lvi.SubItems.Add(SByte2String(pTest.E16));
            lvi.SubItems.Add(SByte2String(pTest.E21));

			errorFlagsListViewEx.Items.Add(lvi);
		}

		void UpdateFromErrorFlagsTab()
		{
			for (int i = 0; i < errorFlagsListViewEx.Items.Count; i++)
			{
				ListViewItem lvi = errorFlagsListViewEx.Items[i];
				PTest entity = (PTest)lvi.Tag;

				entity.Name = lvi.Text;
                entity.ItemNr = i;

                entity.E1 = String2SByte(lvi.SubItems[(int)ErrorFlagsClmn.E1].Text);
                entity.E2 = String2SByte(lvi.SubItems[(int)ErrorFlagsClmn.E2].Text);
                entity.E3 = String2SByte(lvi.SubItems[(int)ErrorFlagsClmn.E3].Text);
                entity.E4 = String2SByte(lvi.SubItems[(int)ErrorFlagsClmn.E4].Text);
                entity.E5 = String2SByte(lvi.SubItems[(int)ErrorFlagsClmn.E5].Text);
                entity.E6 = String2SByte(lvi.SubItems[(int)ErrorFlagsClmn.E6].Text);
                entity.E7 = String2SByte(lvi.SubItems[(int)ErrorFlagsClmn.E7].Text);
                entity.E8 = String2SByte(lvi.SubItems[(int)ErrorFlagsClmn.E8].Text);
                entity.E9 = String2SByte(lvi.SubItems[(int)ErrorFlagsClmn.E9].Text);
                entity.E10 = String2SByte(lvi.SubItems[(int)ErrorFlagsClmn.E10].Text);
                entity.E11 = String2SByte(lvi.SubItems[(int)ErrorFlagsClmn.E11].Text);
                entity.E12 = String2SByte(lvi.SubItems[(int)ErrorFlagsClmn.E12].Text);
                entity.E13 = String2SByte(lvi.SubItems[(int)ErrorFlagsClmn.E13].Text);
                entity.E14 = String2SByte(lvi.SubItems[(int)ErrorFlagsClmn.E14].Text);
                entity.E15 = String2SByte(lvi.SubItems[(int)ErrorFlagsClmn.E15].Text);
                entity.E16 = String2SByte(lvi.SubItems[(int)ErrorFlagsClmn.E16].Text);
                entity.E21 = String2SByte(lvi.SubItems[(int)ErrorFlagsClmn.E21].Text);
			}
		}

        private void errorFlagsListViewEx_SubItemClicked(object sender, SubItemEventArgs e)
        {
            if (!unlocked || e.SubItem >= (int)ErrorFlagsClmn.ColumnsCount)
            {
                return;
            }

            errorFlagsListViewEx.StartEditing(errorFlagsEditors[e.SubItem], e.Item, e.SubItem);
        }

        void errorFlagsListViewEx_SubItemRightClicked(object sender, SubItemEventArgs e)
        {
            if (!unlocked || e.SubItem >= (int)ErrorFlagsClmn.ColumnsCount)
            {
                return;
            }

            if (DialogResult.Yes == MessageBox.Show(Strings.Do_you_want_to_copy_this_value_to_all_cells_below_this_cell,
                                                    Strings.Confirmation, MessageBoxButtons.YesNo, MessageBoxIcon.Question))
            {
                int columnNr = e.SubItem;
                string value = null;
                System.Drawing.Color backColor = System.Drawing.Color.White;
                foreach (ListViewItem item in errorFlagsListViewEx.Items)
                {
                    if (value != null && item.SubItems.Count > columnNr)
                    {
                        item.SubItems[columnNr].Text = value;
                        item.SubItems[columnNr].BackColor = backColor;
                    }
                    else if (item == e.Item)
                    {
                        value = item.SubItems[columnNr].Text;
                        backColor = item.SubItems[columnNr].BackColor;
                    }
                }
            }
        }

        private void errorFlagsListViewEx_SubItemEndEditing(object sender, SubItemEndEditingEventArgs e)
        {
            if (e.SubItem == (int)ErrorFlagsClmn.Name)
            {
                if (!Utils.IsGoodFName(e.DisplayText))
                {
                    e.DisplayText = e.Item.SubItems[e.SubItem].Text;
                    e.Cancel = true;
                    return;								/// NOK
                }
            }

            sbyte dummy;
            if ((e.SubItem >= (int)ErrorFlagsClmn.E1) && (e.SubItem <= (int)ErrorFlagsClmn.E21) && !IsValidEFlagsMode(e.DisplayText, out dummy))
            {
                e.DisplayText = e.Item.SubItems[e.SubItem].Text;
                e.Cancel = true;
                return;								    /// NOK
            }
        }

        #endregion

        #region Error flags 2

        public enum ErrorFlags2Clmn
        {
            Name,
            Delta_Q_pct,
            Delta_T,
            Delta_Tup_Tdn,
            TestTime_min,
            TestTime_max,
            AmbTemp_min,
            AmbTemp_max,            
            Coef_E9,
            Coef_E10,
            Coef_E11,
            Coef_E12,
            Offset_E9,
            Offset_E12,
            ColumnsCount
        }

        Control[] errorFlags2Editors;

        void PrepareErrorFlags2()
        {
            string[] paramNames = new string[]
                {
                    Strings.Test_chdr,
			        "Delta Q [%]",
			        "Delta T [°C]",
			        "max. Abs(Tup - Tdn) [°C]",
			        string.Format("min. {0}", Strings.Test_time_s_chdr),
			        string.Format("max. {0}", Strings.Test_time_s_chdr),
			        string.Format("min. {0} [°C]", Strings.Air_temperature),
			        string.Format("max. {0} [°C]", Strings.Air_temperature),
			        "Coef.E9",
			        "Coef.E10",
			        "Coef.E11",
			        "Coef.E12",
                    "Offset E9 [s]",
                    "Offset E12 [s]",
                };

            /// Compare ErrorFlags2Clmn with paramNames array. Return on mismatch
            if ((int)ErrorFlags2Clmn.ColumnsCount != paramNames.Length) return;

            ListViewEx lv = errorFlags2ListViewEx;
            errorFlags2Editors = new Control[(int)ErrorFlags2Clmn.ColumnsCount];
            int ix = 0;

            for (int i = 0; i < paramNames.Length; i++)
            {
                lv.Columns.Add(new ColumnHeader { Text = paramNames[i], Width = 70 });  /// Column header

                Control ctrl;
                errorFlags2Editors[ix++] = ctrl = new TextBox();                        /// Edit control
                errorFlags2TabPage.Controls.Add(ctrl);
            }
        }

        void RefreshErrorFlags2Tab()
        {
            errorFlags2ListViewEx.Items.Clear();
            foreach (var test in LoadedProfile.Tests) AddToErrorFlags2Tab(test);

            if (0 <= SelectedTestIx && SelectedTestIx < errorFlags2ListViewEx.Items.Count)
            {
                errorFlags2ListViewEx.Items[SelectedTestIx].Selected = true;
            }
        }

        void AddToErrorFlags2Tab(PTest pTest)
        {
            ListViewItem lvi = new ListViewItem(pTest.Name);
            lvi.Tag = pTest;
            lvi.SubItems.Add(pTest.Delta_Q_pct.ToString());
            lvi.SubItems.Add(pTest.Delta_T.ToString());
            lvi.SubItems.Add(pTest.Delta_Tup_Tdn.ToString());
            lvi.SubItems.Add(pTest.TestTime_min.ToString());
            lvi.SubItems.Add(pTest.TestTime_max.ToString());
            lvi.SubItems.Add(pTest.AmbTemp_min.ToString());
            lvi.SubItems.Add(pTest.AmbTemp_max.ToString());
            lvi.SubItems.Add(pTest.Coef_E9.ToString());
            lvi.SubItems.Add(pTest.Coef_E10.ToString());
            lvi.SubItems.Add(pTest.Coef_E11.ToString());
            lvi.SubItems.Add(pTest.Coef_E12.ToString());
            lvi.SubItems.Add(pTest.Offset_E9.ToString());
            lvi.SubItems.Add(pTest.Offset_E12.ToString());

            errorFlags2ListViewEx.Items.Add(lvi);
        }

        void UpdateFromErrorFlags2Tab()
        {
            for (int i = 0; i < errorFlags2ListViewEx.Items.Count; i++)
            {
                ListViewItem lvi = errorFlags2ListViewEx.Items[i];
                PTest entity = (PTest)lvi.Tag;

                entity.Name = lvi.Text;
                entity.ItemNr = i;

                int j = 1;
                entity.Delta_Q_pct = Utils.ParseUDouble(lvi.SubItems[j++].Text);
                entity.Delta_T = Utils.ParseUDouble(lvi.SubItems[j++].Text);
                entity.Delta_Tup_Tdn = Utils.ParseUDouble(lvi.SubItems[j++].Text);
                entity.TestTime_min = Utils.ParseUDouble(lvi.SubItems[j++].Text);
                entity.TestTime_max = Utils.ParseUDouble(lvi.SubItems[j++].Text);
                entity.AmbTemp_min = Utils.ParseUDouble(lvi.SubItems[j++].Text);
                entity.AmbTemp_max = Utils.ParseUDouble(lvi.SubItems[j++].Text);
                entity.Coef_E9 = Utils.ParseUDouble(lvi.SubItems[j++].Text);
                entity.Coef_E10 = Utils.ParseUDouble(lvi.SubItems[j++].Text);
                entity.Coef_E11 = Utils.ParseUDouble(lvi.SubItems[j++].Text);
                entity.Coef_E12 = Utils.ParseUDouble(lvi.SubItems[j++].Text);
                entity.Offset_E9 = Utils.ParseUDouble(lvi.SubItems[j++].Text);
                entity.Offset_E12 = Utils.ParseUDouble(lvi.SubItems[j++].Text);
            }
        }

        private void errorFlags2ListViewEx_SubItemClicked(object sender, SubItemEventArgs e)
        {
            if (!unlocked || e.SubItem >= (int)ErrorFlags2Clmn.ColumnsCount)
            {
                return;
            }

            errorFlags2ListViewEx.StartEditing(errorFlags2Editors[e.SubItem], e.Item, e.SubItem);
        }

        void errorFlags2ListViewEx_SubItemRightClicked(object sender, SubItemEventArgs e)
        {
            if (!unlocked || e.SubItem >= (int)ErrorFlags2Clmn.ColumnsCount)
            {
                return;
            }

            if (DialogResult.Yes == MessageBox.Show(Strings.Do_you_want_to_copy_this_value_to_all_cells_below_this_cell,
                                                    Strings.Confirmation, MessageBoxButtons.YesNo, MessageBoxIcon.Question))
            {
                int columnNr = e.SubItem;
                string value = null;
                System.Drawing.Color backColor = System.Drawing.Color.White;
                foreach (ListViewItem item in errorFlags2ListViewEx.Items)
                {
                    if (value != null && item.SubItems.Count > columnNr)
                    {
                        item.SubItems[columnNr].Text = value;
                        item.SubItems[columnNr].BackColor = backColor;
                    }
                    else if (item == e.Item)
                    {
                        value = item.SubItems[columnNr].Text;
                        backColor = item.SubItems[columnNr].BackColor;
                    }
                }
            }
        }

        private void errorFlags2ListViewEx_SubItemEndEditing(object sender, SubItemEndEditingEventArgs e)
        {
            if (e.SubItem == (int)ErrorFlags2Clmn.Name)
            {
                if (!Utils.IsGoodFName(e.DisplayText))
                {
                    e.DisplayText = e.Item.SubItems[e.SubItem].Text;
                    e.Cancel = true;
                    return;								/// NOK
                }
            }

            double dummy;
            if ((e.SubItem >= 1) && (e.SubItem < (int)ErrorFlags2Clmn.ColumnsCount) && !Utils.TryParseUDouble(e.DisplayText, out dummy))
            {
                e.DisplayText = e.Item.SubItems[e.SubItem].Text;
                e.Cancel = true;
                return;								    /// NOK
            }
        }

        #endregion


		void RefreshMetrologyAndErrorFlagsTabs()
		{
            RefreshMetrologyTab();
            RefreshErrorFlagsTab();
            RefreshErrorFlags2Tab();
        }


		private void Unlocked(object sender, EventArgs e)
		{
			unlocked = true;
            //if (testParamsCtrls != null) foreach (var ctrl in testParamsCtrls) ctrl.Unlock();
            //if (procedureParamsCtrls != null) foreach (var ctrl in procedureParamsCtrls) ctrl.Unlock();			

			procNameTextBox.Enabled = true;
			descriptionTextBox.Enabled = true;
            profileTypeRadioButton1.Enabled = true;
            profileTypeRadioButton2.Enabled = true;

            profileTypeRadioButton1.Enabled = true;
            profileTypeRadioButton2.Enabled = true;
            profileTypeRadioButton3.Enabled = true;
            profileTypeRadioButton4.Enabled = true;
            profileTypeRadioButton5.Enabled = true;

            errorCalculationRadioButton1.Enabled = true;
            errorCalculationRadioButton2.Enabled = true;

            ListViewEx listViewEx = null;
			switch (selectedTab)
			{
				case TestProfileTabs.Metrology:     listViewEx = metrologyListViewEx;  break;
				case TestProfileTabs.ErrorFlags:    listViewEx = errorFlagsListViewEx;  break;
                case TestProfileTabs.ErrorFlags2:   listViewEx = errorFlags2ListViewEx; break;
            }

            if ((listViewEx != null) && (listViewEx.SelectedItems.Count == 1))
			{
				int ix = listViewEx.SelectedIndices[0];
				listViewEx.Focus();
				listViewEx.Items[ix].Selected = true;
				listViewEx.Items[ix].EnsureVisible();
			}
		}

		private void okButton_Click(object sender, EventArgs e)
		{
            switch (selectedTab)
            {
                case TestProfileTabs.General:       UpdateFromGeneralTab();		break;
                case TestProfileTabs.Metrology:     UpdateFromMetrologyTab();	break;
				case TestProfileTabs.ErrorFlags:	UpdateFromErrorFlagsTab();	break;
                case TestProfileTabs.ErrorFlags2:   UpdateFromErrorFlags2Tab(); break;
            }

            //foreach (var ctrl in testParamsCtrls)      if (!ctrl.UpdateAll()) MessageBox.Show(string.Format(Strings.Error_saving_parameters_of_0, ctrl.Name));
            //foreach (var ctrl in procedureParamsCtrls) if (!ctrl.UpdateAll()) MessageBox.Show(string.Format(Strings.Error_saving_parameters_of_0, ctrl.Name));

			if (usedNames != null && usedNames.Contains(LoadedProfile.Name.ToLower()))
			{
				MessageBox.Show(string.Format("There is already a procedure named '{0}'.{1}Choose another name please.", LoadedProfile.Name, Environment.NewLine),
											  Strings.Warning,
											  MessageBoxButtons.OK,
											  MessageBoxIcon.Exclamation);
				return;
			}

            SaveUISettings();
            DialogResult = DialogResult.OK;
			Close();
			return;
		}

		private void cancelButton_Click(object sender, EventArgs e)
		{
            SaveUISettings();
            DialogResult = DialogResult.Cancel;
			Close();
			return;
		}

        private void SaveUISettings()
        {
            /// Obtain ProcedureDlg dimensions, etc.
            bool isMaximized = (WindowState == FormWindowState.Maximized);
            int left = (WindowState == FormWindowState.Normal) ? Location.X : RestoreBounds.Left;
            int top = (WindowState == FormWindowState.Normal) ? Location.Y : RestoreBounds.Top;
            int width = (WindowState == FormWindowState.Normal) ? Size.Width : RestoreBounds.Width;
            int height = (WindowState == FormWindowState.Normal) ? Size.Height : RestoreBounds.Height;

            LocalSettings ls = Program.LocalSettings;

            if (ls != null && (ls.OneProcedureDlgMaximized != isMaximized ||
                               ls.OneProcedureDlgLeft != left ||
                               ls.OneProcedureDlgTop != top ||
                               ls.OneProcedureDlgWidth != width ||
                               ls.OneProcedureDlgHeight != height))
            {
                /// At least one ProcedureDlg dimension differs => Update local settings and save them
                ls.OneProcedureDlgMaximized = isMaximized;
                ls.OneProcedureDlgLeft = left;
                ls.OneProcedureDlgTop = top;
                ls.OneProcedureDlgWidth = width;
                ls.OneProcedureDlgHeight = height;
                ls.Save();
            }
        }

        private void LoadUISettings()
        {
            TBF.LocalSettings ls = Program.LocalSettings;
            WindowState = (ls.OneProcedureDlgMaximized ? FormWindowState.Maximized : FormWindowState.Normal);
            Width  = (ls.OneProcedureDlgWidth > 0)  ? ls.OneProcedureDlgWidth  : 800;
            Height = (ls.OneProcedureDlgHeight > 0) ? ls.OneProcedureDlgHeight : 420;
            Left   = (ls.OneProcedureDlgLeft != 0)  ? ls.OneProcedureDlgLeft   : 150;
            Top    = (ls.OneProcedureDlgTop != 0)   ? ls.OneProcedureDlgTop    : 150;
        }

        #region Tab switching

		enum TestProfileTabs
		{
			General,
			Metrology,
			ErrorFlags,
            ErrorFlags2,
		}

        TestProfileTabs selectedTab = TestProfileTabs.General;

        private void tabControl_SelectedIndexChanged(object sender, EventArgs e)
        {
            switch (selectedTab)
            {
                case TestProfileTabs.General:
                    UpdateFromGeneralTab();
                    break;
                case TestProfileTabs.Metrology:
                    UpdateFromMetrologyTab();
                    break;
				case TestProfileTabs.ErrorFlags:
                    UpdateFromErrorFlagsTab();
                    break;
                case TestProfileTabs.ErrorFlags2:
                    UpdateFromErrorFlags2Tab();
                    break;
            }

            selectedTab = (TestProfileTabs)tabControl.SelectedIndex;
            bool isMetrologyOrErrorFlags = selectedTab == TestProfileTabs.Metrology ||
                                           selectedTab == TestProfileTabs.ErrorFlags ||
                                           selectedTab == TestProfileTabs.ErrorFlags2;

            if (isMetrologyOrErrorFlags)
            {
                sharedButtons.EnableButtons(SharedButtons.Buttons.Add);
            }
            else
            {
                sharedButtons.DisableButtons(SharedButtons.Buttons.Add);
            }
 
			//bool removeBtnEnabled = (selectedTab != TestProfileTabs.General);

			sharedButtons.DisableButtons(SharedButtons.Buttons.Remove);

            ListViewEx lv = null;
            ///
            switch (selectedTab)
            {
                case TestProfileTabs.General:
                    RefreshGeneralTab();
                    break;

                case TestProfileTabs.Metrology:
                    RefreshMetrologyTab();
                    lv = metrologyListViewEx;                   /// ListVIewEx for test selection
                    break;

                case TestProfileTabs.ErrorFlags:
                    RefreshErrorFlagsTab();
                    lv = errorFlagsListViewEx;                  /// ListVIewEx for test selection
                    break;

                case TestProfileTabs.ErrorFlags2:
                    RefreshErrorFlags2Tab();
                    lv = errorFlags2ListViewEx;                 /// ListVIewEx for test selection
                    break;

                default:
    				UpdateButtonStates(SharedButtons.SelectedItemPos.None);
                    break;
            }

            ///
            /// Highlight the selected test
            /// 
            if ((lv != null) && (0 <= SelectedTestIx) && (SelectedTestIx < lv.Items.Count))
            {
                lv.Focus();
                lv.Items[SelectedTestIx].Selected = true;
                lv.Items[SelectedTestIx].EnsureVisible();
            }
        }

        #endregion

        #region 'Add', 'Remove', 'Up' and 'Down'

        private void addButton_Click(object sender, EventArgs e)
        {
            ListViewEx listViewEx;
            switch (selectedTab)
            {
                case TestProfileTabs.Metrology: listViewEx = metrologyListViewEx; break;
                case TestProfileTabs.ErrorFlags: listViewEx = errorFlagsListViewEx; break;
                case TestProfileTabs.ErrorFlags2: listViewEx = errorFlags2ListViewEx; break;
                default: return;
            }

            ///
            /// Find an unused test name
            ///
            string newName;
            for (int nameId = 1; true; nameId++)
            {
                if (nameId >= 5 || (nameId >= 4 && LoadedProfile.ProfileType == ProfileType.QpQi) || LoadedProfile.ProfileType == ProfileType.Manual)
                {
                    newName = Strings.New_test_name + nameId.ToString();
                }
                else
                {
                    switch (LoadedProfile.ProfileType)
                    {
                        default:
                        case ProfileType.Q3R:
                            newName = string.Format("Q{0}", 5 - nameId);
                            break;

                        case ProfileType.QnClassColdWater:
                        case ProfileType.QnClassHotWater:
                            newName = (nameId == 1) ? "Qmax" : (nameId == 2) ? "Qn" : (nameId == 3) ? "Qt" : "Qmin";
                            break;

                        case ProfileType.QpQi:
                            newName = (nameId == 1) ? "qp" : (nameId == 2) ? "0,1qp" : "qi";
                            break;
                    }
                }

                bool notUsed = true;
                foreach (var t in LoadedProfile.Tests) if (t.Name.Equals(newName)) notUsed = false;
                if (notUsed) break;
            }

            ///
            /// Add a profile test
            ///
            int count = listViewEx.Items.Count;
            PTest ptest = new PTest(newName, count, LoadedProfile);

            ///
            /// Upper and lower limits of flow
            ///
            switch (LoadedProfile.ProfileType)
            {
                case ProfileType.Q3R: 
                case ProfileType.QnClassColdWater:
                case ProfileType.QnClassHotWater:
                    switch (count)
                    {
                        case 0:
                        case 1:
                            ptest.CoefQfrom = 0.9;
                            ptest.CoefQto = 1.0;
                            break;
                        default:
                            ptest.CoefQfrom = 1.0;
                            ptest.CoefQto = 1.1;
                            break;
                    }
                    break;

                case ProfileType.QpQi:
                    switch (count)
                    {
                        case 0:
                            ptest.CoefQfrom = 0.9;
                            ptest.CoefQto = 1.0;
                            break;
                        default:
                            ptest.CoefQfrom = 1.0;
                            ptest.CoefQto = 1.1;
                            break;
                    }
                    break;
            }

            ///
            /// Upper and lower limits of relative error
            ///
            switch (LoadedProfile.ProfileType)
            {
                case ProfileType.Q3R: 
                case ProfileType.QnClassColdWater:
                    switch (count)
                    {
                        case 3:
                            ptest.ErrLimLo = -5.0;
                            ptest.ErrLimHi = 5.0;
                            break;
                        default:
                            ptest.ErrLimLo = -2.0;
                            ptest.ErrLimHi = 2.0;
                            break;
                    }
                    break;

                case ProfileType.QnClassHotWater:
                    switch (count)
                    {
                        case 3:
                            ptest.ErrLimLo = -5.0;
                            ptest.ErrLimHi = 5.0;
                            break;
                        default:
                            ptest.ErrLimLo = -3.0;
                            ptest.ErrLimHi = 3.0;
                            break;
                    }
                    break;
            }

            LoadedProfile.Tests.Add(ptest);
            AddToMetrologyTab(ptest);
            AddToErrorFlagsTab(ptest);

            if (listViewEx != null)
            {
                listViewEx.Focus();
                listViewEx.SelectedItems.Clear();
                listViewEx.Items[listViewEx.Items.Count - 1].Selected = true;
                listViewEx.Items[listViewEx.Items.Count - 1].EnsureVisible();
            }
        }

        private void removeButton_Click(object sender, EventArgs e)
        {
            ListViewEx listViewEx;

            switch (selectedTab)
            {
				case TestProfileTabs.Metrology:
					UpdateFromMetrologyTab();
					listViewEx = metrologyListViewEx;
					break;

				case TestProfileTabs.ErrorFlags:
					UpdateFromErrorFlagsTab();
					listViewEx = errorFlagsListViewEx;
					break;

                case TestProfileTabs.ErrorFlags2:
                    UpdateFromErrorFlags2Tab();
                    listViewEx = errorFlags2ListViewEx;
                    break;

				default: return;
            }

			/// Check the selected index validity
            if (listViewEx.SelectedItems.Count != 1) return;

			int removeItemNr = listViewEx.SelectedIndices[0];
			
			/// Remove the selected test
			PTest toBeDeleted = LoadedProfile.Tests[removeItemNr];
			LoadedProfile.Tests.Remove(toBeDeleted);
			for (int i = removeItemNr; i < LoadedProfile.Tests.Count; i++) LoadedProfile.Tests[i].ItemNr--;

			RefreshMetrologyAndErrorFlagsTabs();

			if (removeItemNr < listViewEx.Items.Count)
			{
				listViewEx.Focus();
				listViewEx.Items[removeItemNr].Selected = true;
				listViewEx.Items[removeItemNr].EnsureVisible();
			}
			else
			{
				UpdateButtonStates(SharedButtons.SelectedItemPos.None);
			}
		}

		private void upButton_Click(object sender, EventArgs e)
		{
            ListViewEx listViewEx;

			switch (selectedTab)
			{
				case TestProfileTabs.Metrology:
					UpdateFromMetrologyTab();
					listViewEx = metrologyListViewEx;
					break;

				case TestProfileTabs.ErrorFlags:
					UpdateFromErrorFlagsTab();
					listViewEx = errorFlagsListViewEx;
					break;

                case TestProfileTabs.ErrorFlags2:
                    UpdateFromErrorFlags2Tab();
                    listViewEx = errorFlags2ListViewEx;
                    break;

				default: return;
			}

			/// Check the selected index validity
			if (listViewEx.SelectedItems.Count != 1) return;

			int ix = listViewEx.SelectedIndices[0];
			if (ix <= 0 || ix >= listViewEx.Items.Count) return;

			/// Swap two items (move the selected item up)
			PTest test1 = LoadedProfile.Tests[ix - 1];
			PTest test2 = LoadedProfile.Tests[ix];
			test1.ItemNr++;
			test2.ItemNr--;
			LoadedProfile.Tests.RemoveAt(ix);
			LoadedProfile.Tests.Insert(ix - 1, test2);

            if (SelectedTestIx >= 1) SelectedTestIx--;

			RefreshMetrologyAndErrorFlagsTabs();

			listViewEx.Focus();
			listViewEx.Items[ix - 1].Selected = true;
			listViewEx.Items[ix - 1].EnsureVisible();
		}

		private void downButton_Click(object sender, EventArgs e)
		{
            ListViewEx listViewEx;

			switch (selectedTab)
			{
				case TestProfileTabs.Metrology:
					UpdateFromMetrologyTab();
					listViewEx = metrologyListViewEx;
					break;

				case TestProfileTabs.ErrorFlags:
					UpdateFromErrorFlagsTab();
					listViewEx = errorFlagsListViewEx;
					break;

                case TestProfileTabs.ErrorFlags2:
                    UpdateFromErrorFlags2Tab();
                    listViewEx = errorFlags2ListViewEx;
                    break;

				default: return;
			}

            /// Check the selected index validity
            if (listViewEx.SelectedItems.Count != 1) return;

			int ix = listViewEx.SelectedIndices[0];
			if (ix < 0 || ix >= listViewEx.Items.Count - 1) return;

			/// Swap two items (move the selected item down)
			PTest test1 = LoadedProfile.Tests[ix];
			PTest test2 = LoadedProfile.Tests[ix + 1];
			test1.ItemNr++;
			test2.ItemNr--;
			LoadedProfile.Tests.RemoveAt(ix + 1);
			LoadedProfile.Tests.Insert(ix, test2);

            if ((SelectedTestIx >= 0) && (SelectedTestIx < listViewEx.Items.Count - 1)) SelectedTestIx++;

			RefreshMetrologyAndErrorFlagsTabs();

			listViewEx.Focus();
			listViewEx.Items[ix + 1].Selected = true;
			listViewEx.Items[ix + 1].EnsureVisible();
		}

        #endregion

		private void metrologyListViewEx_SelectedIndexChanged(object sender, EventArgs e) { SelectedIndexChanged(sender, e); }
        private void errorFlagsListViewEx_SelectedIndexChanged(object sender, EventArgs e) { SelectedIndexChanged(sender, e); }
        private void errorFlags2ListViewEx_SelectedIndexChanged(object sender, EventArgs e) { SelectedIndexChanged(sender, e); }

		/// <summary>
		/// Common part for four xxxListViewEx_SelectedIndexChanged event handlers
		/// </summary>
		void SelectedIndexChanged(object sender, EventArgs e)
		{
            ListViewEx listViewEx = sender as ListViewEx;
            if ((listViewEx == null) || (listViewEx.SelectedItems.Count != 1))
			{
				UpdateButtonStates(SharedButtons.SelectedItemPos.None);
                SelectedTestIx = -1;
                return;
			}

            SelectedTestIx = listViewEx.SelectedIndices[0];

			if (listViewEx.Items.Count == 1)
			{
				UpdateButtonStates(SharedButtons.SelectedItemPos.FirstAndLast);
			}
            else if (SelectedTestIx == 0)
			{
				UpdateButtonStates(SharedButtons.SelectedItemPos.First);
			}
            else if (SelectedTestIx == (listViewEx.Items.Count - 1))
			{
				UpdateButtonStates(SharedButtons.SelectedItemPos.Last);
			}
			else
			{
				UpdateButtonStates(SharedButtons.SelectedItemPos.Middle);
			}
		}

        public void UpdateButtonStates(SharedButtons.SelectedItemPos selectedItemPos)
        {
            if (selectedItemPos == SharedButtons.SelectedItemPos.None)
            {
                sharedButtons.DisableButtons(SharedButtons.Buttons.Remove | SharedButtons.Buttons.Up | SharedButtons.Buttons.Down);
            }
            else if (selectedItemPos == SharedButtons.SelectedItemPos.First)
            {
                sharedButtons.EnableButtons(SharedButtons.Buttons.Remove | SharedButtons.Buttons.Down);
                sharedButtons.DisableButtons(SharedButtons.Buttons.Up);
            }
            else if (selectedItemPos == SharedButtons.SelectedItemPos.Last)
            {
                sharedButtons.EnableButtons(SharedButtons.Buttons.Remove | SharedButtons.Buttons.Up);
                sharedButtons.DisableButtons(SharedButtons.Buttons.Down);
            }
            else if (selectedItemPos == SharedButtons.SelectedItemPos.FirstAndLast)
            {
                sharedButtons.EnableButtons(SharedButtons.Buttons.Remove);
                sharedButtons.DisableButtons(SharedButtons.Buttons.Up | SharedButtons.Buttons.Down);
            }
            else
            {
                sharedButtons.EnableButtons(SharedButtons.Buttons.Remove | SharedButtons.Buttons.Up | SharedButtons.Buttons.Down);
            }
        }


        ///
        /// ErrorFlagsMode related conversions
        ///

        string SByte2String(SByte e)
        {
            return ((ErrorFlagsMode) e).ToDescription();
        }

        bool IsValidEFlagsMode(string str, out sbyte eflags)
        {
            for (ErrorFlagsMode e = 0; e < ErrorFlagsMode.Count; e++)
            {
                if (e.ToDescription() == str)
                {
                    eflags = (sbyte)e;
                    return true;
                }
            }

            eflags = 0;
            return false;
        }

        bool IsValidEFlagsMode(string str, out ErrorFlagsMode eflags)
        {
            for (ErrorFlagsMode e = 0; e < ErrorFlagsMode.Count; e++)
            {
                if (e.ToDescription() == str)
                {
                    eflags = e;
                    return true;
                }
            }

            eflags = 0;
            return false;
        }

        sbyte String2SByte(string str)
        {
            for (ErrorFlagsMode e = 0; e < ErrorFlagsMode.Count; e++)
            {
                if (e.ToDescription() == str) return (sbyte)e;
            }
            return 0;
        }
    }
}