tbf/TBF/UI/Procedures/ProcedureDlg.cs

///
/// Copyright (c) 2013-2022 Sensus Slovensko a.s.
///
#if KEMPNO_50 || KRAKOW_50 || TORUN_50 || WARSAW_50 || WARSAW_END
#define SHOW_Q_TG
#endif

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using log4net;
using Common;
using Common.Forms;
using Config.Entities;
using TBF.Rig.Generic;
using TBF.Rig.GenericDevices;
using TBF.Resources;
using TBF.UI.Shared;
using TBF.Rig.TestMethods.iPerlCommunication.iPerlHead;

namespace TBF.UI.Procedures
{
	public partial class ProcedureDlg : Form, IParentOfListViewEx
	{
        public enum Mode
        {
            Unlocked,
            Locked,
            PermanentlyLocked,
        }

		static readonly ILog log = LogManager.GetLogger(typeof(ProcedureDlg));

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

        readonly Mode initialMode;

		/// <summary>
		/// Procedure to be updated by this dialog.
		/// Set by the constructor or updated by the parent after creation and before loading.
		/// </summary>
		public Procedure LoadedProcedure;
        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<Rig.Generic.IComponent> TbfComponents;
		public IList<IValve> Valves;
		public IList<IRegValve> RegulValves;
		public IList<ITestMethod> TestMethods;
		public IList<ITestMethod> UsedTestMethods;
        public IList<ITempControl> TempControllers;
		ComboBox methodCBox;

		/// Auxiliary private lists
		IList<FeedingPath> feedingPaths;
		IList<BenchPath> benchPaths;
		IList<OutputPath> outputPaths;
		IList<MetersPath> metersPaths;
        IList<HeatMetersPath> heatMetersPaths;
        IList<TransitionSequence> transitionSequences;

		IList<TestParamsCtrl> testParamsCtrls;
        IList<IProcParamsCtrl> procedureParamsCtrls;

		bool unlocked;

		ProcedureDlg()
		{
			/// Detect display setting: 100% = 96dpi, 125% = 120dpi, 150% = 144dpi.
			Dpi = (int)this.CreateGraphics().DpiX;
            initialMode = Mode.Locked;

			InitializeComponent();

            /// SharedDlgButtons configuration
            sharedButtons.OptionalButtons = SharedButtons.Buttons.Add |
                                            SharedButtons.Buttons.Remove |
                                            SharedButtons.Buttons.Up |
                                            SharedButtons.Buttons.Down |
                                            SharedButtons.Buttons.Copy;
#if TURA_SPECIAL || TURA_IPERL || TURA_IPERL_NEW
            /// Custom button 'Načítaj testy iPerl z Oracle'
            sharedButtons.OptionalButtons |= SharedButtons.Buttons.Custom1;
            sharedButtons.Custom1Caption = string.Format("Načítaj testy{0}iPerl z Oracle", Environment.NewLine);
            sharedButtons.Custom1Clicked += iPerlWizardButton_Click;
#endif
            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;
            sharedButtons.CopyClicked += copyButton_Click;

			/// ListViewEx-es configuration
            metrology1ListViewEx.SubItemClicked += new SubItemEventHandler(metrology1ListViewEx_SubItemClicked);
            metrology1ListViewEx.SubItemRightClicked += new SubItemEventHandler(metrology1ListViewEx_SubItemRightClicked);
            metrology1ListViewEx.SubItemEndEditing += new SubItemEndEditingEventHandler(metrology1ListViewEx_SubItemEndEditing);

            metrology2ListViewEx.SubItemClicked += new SubItemEventHandler(metrology2ListViewEx_SubItemClicked);
            metrology2ListViewEx.SubItemRightClicked += new SubItemEventHandler(metrology2ListViewEx_SubItemRightClicked);
            metrology2ListViewEx.SubItemEndEditing += new SubItemEndEditingEventHandler(metrology2ListViewEx_SubItemEndEditing);

            processListViewEx.SubItemClicked += new SubItemEventHandler(processListViewEx_SubItemClicked);
            processListViewEx.SubItemRightClicked += new SubItemEventHandler(processListViewEx_SubItemRightClicked);
            processListViewEx.SubItemEndEditing += new SubItemEndEditingEventHandler(processListViewEx_SubItemEndEditing);

            parametersListViewEx.SubItemClicked += new SubItemEventHandler(parametersListViewEx_SubItemClicked);
            parametersListViewEx.SubItemRightClicked += new SubItemEventHandler(parametersListViewEx_SubItemRightClicked);
            parametersListViewEx.SubItemEndEditing += new SubItemEndEditingEventHandler(parametersListViewEx_SubItemEndEditing);

            SelectedTestIx = -1;
		}

		public ProcedureDlg(Procedure procedure, IList<string> usedNames, Mode initialMode, Form parentForm)
			: this()
		{
			if (procedure == null) throw new ArgumentNullException("procedure");

            LoadedProcedure = procedure;
			this.usedNames = usedNames;
            this.initialMode = initialMode;

            /// Dynamic SharedDlgButtons configuration
            sharedButtons.ParentForm = parentForm;

#if KEMPNO_50 || KRAKOW_50 || TORUN_50 || WARSAW_50 || WARSAW_END
            sharedButtons.RequiredGroupMembership = procedure.Protected ? new GID[] { GID.WaterMeterAuthority }
                                                                        : new GID[] { GID.TestingSpecialists, GID.WaterMeterAuthority };
#else
            sharedButtons.RequiredGroupMembership = procedure.Protected ? new GID[] { GID.Metrologists }
                                                                        : new GID[] { GID.TestingSpecialists, GID.Metrologists };
#endif
            if (initialMode == Mode.PermanentlyLocked) sharedButtons.DisableUnlock();

			using (NHibernate.ISession session = TBF.DB.CreateSession(DBKind.Config))
			{
                ///
                /// Prepare a list of components and a list of all valves in the test bench
                ///
                TbfComponents = Rig.TbfComponents.LoadComponentsFromDB(session);
				Valves = Rig.GenericDevices.ValveBase.MasterValves(TbfComponents);
				RegulValves = new List<IRegValve>();
				TestMethods = new List<ITestMethod>();
                TempControllers = new List<ITempControl>();
				dataEntryComboBox.Items.Add("---");
				printer1ComboBox.Items.Add("---");
                printer2ComboBox.Items.Add("---");
                fileWriter1ComboBox.Items.Add("---");
                fileWriter2ComboBox.Items.Add("---");
                fileWriter3ComboBox.Items.Add("---");
                fileWriter4ComboBox.Items.Add("---");
                fileWriter5ComboBox.Items.Add("---");
                eventTrigger1ComboBox.Items.Add("---");
                eventTrigger2ComboBox.Items.Add("---");
                eventTrigger3ComboBox.Items.Add("---");

                foreach (var cmpnt in TbfComponents)
				{
					if (cmpnt is IRegValve) RegulValves.Add(cmpnt as IRegValve);
					if (cmpnt is ITestMethod) TestMethods.Add(cmpnt as ITestMethod);
                    if (cmpnt is ITempControl) TempControllers.Add(cmpnt as ITempControl);
                    if (cmpnt is IDataEntry) dataEntryComboBox.Items.Add(cmpnt.Cfg.Name);
                    if (cmpnt is IResultsPrinter)
                    {
                        printer1ComboBox.Items.Add(cmpnt.Cfg.Name);
                        printer2ComboBox.Items.Add(cmpnt.Cfg.Name);
                    }
                    if (cmpnt is IResultsWriter)
                    {
                        fileWriter1ComboBox.Items.Add(cmpnt.Cfg.Name);
                        fileWriter2ComboBox.Items.Add(cmpnt.Cfg.Name);
                        fileWriter3ComboBox.Items.Add(cmpnt.Cfg.Name);
                        fileWriter4ComboBox.Items.Add(cmpnt.Cfg.Name);
                        fileWriter5ComboBox.Items.Add(cmpnt.Cfg.Name);
                    }
                    if (cmpnt is IEventTrigger)
                    {
                        eventTrigger1ComboBox.Items.Add(cmpnt.Cfg.Name);
                        eventTrigger2ComboBox.Items.Add(cmpnt.Cfg.Name);
                        eventTrigger3ComboBox.Items.Add(cmpnt.Cfg.Name);
                    }
                }

                ///
                /// Loads paths, this must be done before PrepareMetrology12AndProcessTabs() call
                ///
                feedingPaths = session.QueryOver<FeedingPath>().List();
				benchPaths   = session.QueryOver<BenchPath>().List();
				outputPaths  = session.QueryOver<OutputPath>().List();
				metersPaths  = session.QueryOver<MetersPath>().List();
#if HEAT_METERS
                heatMetersPaths = session.QueryOver<HeatMetersPath>().List();
#else
				heatMetersPaths = new List<HeatMetersPath>();
#endif
                transitionSequences = session.QueryOver<TransitionSequence>().List();
			}

			transitionStartComboBox.Items.Add("---");
			transitionEndComboBox.Items.Add("---");
			foreach (var trans in transitionSequences)
			{
				transitionStartComboBox.Items.Add(trans.Name);
				transitionEndComboBox.Items.Add(trans.Name);
			}

			///--------------------------------------------------------------------------------------
			///--------------------------  Tab pages with test parameters  --------------------------
			///--------------------------------------------------------------------------------------

			testParamsCtrls = new List<TestParamsCtrl>();		/// Initialize the list

			///---------------------
			///  Used test methods
			///---------------------

			/// Find all test methods used in this procedure
			UsedTestMethods = new List<ITestMethod>();
			foreach (var test in LoadedProcedure.Tests)
			{
				ITestMethod method = Rig.TbfComponents.FindComponent(test.Method, TbfComponents) as ITestMethod;
				if (method != null && !UsedTestMethods.Contains(method)) UsedTestMethods.Add(method);
			}

			/// Create a tab with a TestParamsCtrl control for each used test method
			foreach (var method in UsedTestMethods)
			{
				if (method.Cfg.GetRuntimeTestParamsProvider() != null)
				{
                    var nwCtrl = new TestParamsCtrl(this, method, true);
                    testParamsCtrls.Add(nwCtrl);

                    TabPage nwTab = new TabPage(method.Cfg.Name);
                    nwTab.Controls.Add(nwCtrl);
                    nwTab.Tag = nwCtrl;
					tabControl.TabPages.Add(nwTab);
				}
			}

			/// Create a control for another component with Test parameters which was not handled yet
			foreach (var cmpnt in TbfComponents)
			{
				if ((cmpnt.Cfg.GetRuntimeTestParamsProvider() != null) && !(cmpnt is ITestMethod))
				{
                    var nwCtrl = new TestParamsCtrl(this, cmpnt, true);
                    testParamsCtrls.Add(nwCtrl);
                    
                    TabPage nwTab = new TabPage(cmpnt.Cfg.Name);
					nwTab.Controls.Add(nwCtrl);
                    nwTab.Tag = nwCtrl;
                    this.tabControl.TabPages.Add(nwTab);
				}
			}

			///--------------------------------------------------------------------------------------
			///-----------------------  Tab pages with procedure parameters  ------------------------
			///--------------------------------------------------------------------------------------

			procedureParamsCtrls = new List<IProcParamsCtrl>();		/// Initialize the list

			///----------------
			///  Water meters
			///----------------

			/// Create a control for the water meters and add it to the list.
			IList<IComponent> waterMeters = new List<IComponent>();
			foreach (var cmpnt in TbfComponents)
			{
				if (cmpnt is IWaterMeter) waterMeters.Add(cmpnt);
			}

			{
                var newCtrl = new ProcedureParamsCtrl(this, waterMeters, false);
                procedureParamsCtrls.Add(newCtrl);
                
                TabPage newTab = new TabPage(Strings.Water_meters);
				newTab.Controls.Add(newCtrl);
                newTab.Tag = newCtrl;
                tabControl.TabPages.Add(newTab);
			}

			///---------------------
			///  Used sensor paths
			///---------------------

			/// Prepare a list of all meters paths used in this procedure (in any test)
			IList<string> usedMPaths = new List<string>();
			foreach (var test in LoadedProcedure.Tests)
			{
				if (test.MetersPath != null && !usedMPaths.Contains(test.MetersPath)) usedMPaths.Add(test.MetersPath);
			}

			/// Create controls for each sensors path used in this procedure.
			/// Initialize it with its components (sensors or cameras) and add it to the list.
			foreach (var usedPathName in usedMPaths)
			{
				MetersPath usedPath = null;
				try { usedPath = metersPaths.First<MetersPath>(x => (x.Name == usedPathName)); }
				catch { }
				if (usedPath != null)
				{
					IList<IComponent> cmpntsInMPath = new List<IComponent>();
					for (int i = 0; i < TBF.Data.WMsCount; i++)
					{
						IComponent sensor = TbfComponents.FirstOrDefault<IComponent>(x => (x.Cfg.Name.Equals(usedPath.GetSensor(i))));
						cmpntsInMPath.Add(sensor);
					}

                    var nwCtrl = new ProcedureParamsCtrl(this, cmpntsInMPath, true);
                    procedureParamsCtrls.Add(nwCtrl);
                    
                    TabPage nwTab = new TabPage(usedPathName);
					nwTab.Controls.Add(nwCtrl);
                    nwTab.Tag = nwCtrl;
                    tabControl.TabPages.Add(nwTab);
				}
			}

			///---------------------
			///  Other components
			///---------------------

			/// Create a control for some other components and add it to the list.
			IList<IComponent> other = new List<IComponent>();
			foreach (var cmpnt in TbfComponents)
			{
                if (!(cmpnt is IRegReader) && !(cmpnt is IWaterMeter) && cmpnt.Cfg.CreateProcParamsProvider() != null)
                {
                    other.Add(cmpnt);
                }
            }

			if (other.Count > 0)
			{
                var newCtrl = new ProcedureParamsMixedCtrl(this, other);
                procedureParamsCtrls.Add(newCtrl);
                
                TabPage newTab = new TabPage("More...");
				newTab.Controls.Add(newCtrl);
                newTab.Tag = newCtrl;
                tabControl.TabPages.Add(newTab);
			}
		}

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

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

            LoadUISettings();

            /// Enable/disable/show/hide controls in General tab
#if KEMPNO_50 || KRAKOW_50 || TORUN_50 || WARSAW_50 || WARSAW_END
            altProcNameLabel.Visible = true;
            altProcNameTextBox.Visible = true;
            //altProcPeriodLabel.Visible = true;
            //altProcPeriodTextBox.Visible = true;
#endif
            procNameTextBox.Enabled = false;
            descriptionTextBox.Enabled = false;
            watermetersTextBox.Enabled = false;
            protectedCheckBox.Enabled = false;
            mustBeCompleteCheckBox.Enabled = false;
            manualControlDisabledCheckBox.Enabled = false;
            altProcNameTextBox.Enabled = false;
            altProcPeriodTextBox.Enabled = false;
            dataEntryComboBox.Enabled = false;
            transitionStartComboBox.Enabled = false;
            transitionEndComboBox.Enabled = false;
            printer1ComboBox.Enabled = false;
            printer2ComboBox.Enabled = false;
            fileWriter1ComboBox.Enabled = false;
            fileWriter2ComboBox.Enabled = false;
            fileWriter3ComboBox.Enabled = false;
            fileWriter4ComboBox.Enabled = false;
            fileWriter5ComboBox.Enabled = false;
            eventTrigger1ComboBox.Enabled = false;
            eventTrigger2ComboBox.Enabled = false;
            eventTrigger3ComboBox.Enabled = false;
            metersKindRadioButton1.Enabled = false;
            metersKindRadioButton2.Enabled = false;
            metersKindRadioButton3.Enabled = false;
            notesTextBox.Enabled = false;
#if !HEAT_METERS
            metersKindRadioButton3.Visible = false;
#endif
            /// Make some controls readonly
            createdByTextBox.ReadOnly = true;
            createdOnTextBox.ReadOnly = true;
            lastChangedByTextBox.ReadOnly = true;
            lastChangedOnTextBox.ReadOnly = true;

            foreach (var test in LoadedProcedure.Tests)
            {
                test.VolumeUnit = TBF.Rig.Sequences.ProcessData.VolumeUnit;
                test.FlowUnit = TBF.Rig.Sequences.ProcessData.FlowUnit;
                test.MassUnit = TBF.Rig.Sequences.ProcessData.MassUnit;
                test.TempUnit = TBF.Rig.Sequences.ProcessData.TempUnit;
                test.PressUnit = TBF.Rig.Sequences.ProcessData.PressUnit;
                test.LengthUnit = TBF.Rig.Sequences.ProcessData.LengthUnit;
                test.ResetChngdFlags();
            }

            /// History tab
			InitializeHistoryTab();		/// Create ListViewEx columns for 'History of changes'

            /// LisViewEx columns and edit controls for 'Metrology1', 'Metrology2', 'Process' and 'Parameters' tabs
            PrepareMetrology1Tab();
            PrepareMetrology2Tab();
            PrepareProcess();
            PrepareParameters();

            /// Now refresh the content of the dialog
            RefreshGeneralTab();
            RefreshMetrology1Tab();
            RefreshMetrology2Tab();
            RefreshProcessTab();
            RefreshParametersTab();
            
            foreach (var ctrl in testParamsCtrls)
			{
				ctrl.Initialize();
			}
			foreach (var ctrl in procedureParamsCtrls)
			{
				ctrl.Initialize();
			}

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

            ShowNokComponents();
        }

		void Localize()
		{
            Text = Strings.Procedure;

            generalTabPage.Text = Strings.General;
            historyTabPage.Text = Strings.History_of_changes;
            metrology1TabPage.Text = Strings.Metrology + " I.";
            metrology2TabPage.Text = Strings.Metrology + " II.";
            processTabPage.Text = Strings.Process;
            parametersTabPage.Text = Strings.Parameters;
            
            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;
            label18.Text = Strings.Notes;
            watermetersLabel.Text = Strings.Meter_types_tested;
            testProfileLabel.Text = Strings.Test_profiles;
            altProcNameLabel.Text = Strings.Conditions;
            protectedCheckBox.Text = Strings.Protected_procedure;
            mustBeCompleteCheckBox.Text = Strings.All_tests_must_be_completed;
			manualControlDisabledCheckBox.Text = Strings.Manual_control_disabled;
            dataEntryLabel.Text = Strings.Data_entry;
            transitionStartLabel.Text = Strings.Purge_Begin;
            transitionEndLabel.Text = Strings.Purge_End;
            printersLabel.Text = Strings.Printing;
            fileWritersLabel.Text = Strings.Saving_results;
            eventTriggersLabel.Text = Strings.Event_triggers;

			metersKindRadioButton1.Text = Strings.SingleBtnText;
			metersKindRadioButton2.Text = Strings.Compound;
            metersKindRadioButton3.Text = Strings.Heat_meter;
        }

		#region General

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

			descriptionTextBox.Text = LoadedProcedure.Description;
			createdByTextBox.Text = LoadedProcedure.CreationUser;
			createdOnTextBox.Text = LoadedProcedure.CreationTime.ToString();
			lastChangedByTextBox.Text = LoadedProcedure.LastChgUser;
			if (LoadedProcedure.LastChgTime > LoadedProcedure.CreationTime)
			{
				lastChangedOnTextBox.Text = LoadedProcedure.LastChgTime.ToString();
			}
			watermetersTextBox.Text = LoadedProcedure.Watermeters;
            protectedCheckBox.Checked = LoadedProcedure.Protected;
            mustBeCompleteCheckBox.Checked = LoadedProcedure.MustBeComplete;
			manualControlDisabledCheckBox.Checked = LoadedProcedure.ManualCtrlDisabled;
            dataEntryComboBox.Text = string.IsNullOrEmpty(LoadedProcedure.DataEntry) ? "---" : LoadedProcedure.DataEntry;
			transitionStartComboBox.Text = string.IsNullOrEmpty(LoadedProcedure.TransitionStart) ? "---" : LoadedProcedure.TransitionStart;
			transitionEndComboBox.Text = string.IsNullOrEmpty(LoadedProcedure.TransitionEnd) ? "---" : LoadedProcedure.TransitionEnd;

            testProfileTextBox.Text = string.IsNullOrEmpty(LoadedProcedure.AltProcName) ? "---" : LoadedProcedure.AltProcName;
            //altProcNameTextBox.Text = string.IsNullOrEmpty(LoadedProcedure.AltProcName) ? "---" : LoadedProcedure.AltProcName;
            //altProcPeriodTextBox.Text = LoadedProcedure.AltProcPeriod.ToString();

			if (string.IsNullOrEmpty(LoadedProcedure.ResultsPrinter))
			{
				printer1ComboBox.Text = "---";
				printer2ComboBox.Text = "---";
			}
			else
			{
				string[] fields = LoadedProcedure.ResultsPrinter.Split(new char[] { '~' });
				printer1ComboBox.Text = fields[0];
				printer2ComboBox.Text = (fields.Length == 2) ? fields[1] : "---";
			}

            if (string.IsNullOrEmpty(LoadedProcedure.ResultsWriter))
            {
                fileWriter1ComboBox.Text = "---";
                fileWriter2ComboBox.Text = "---";
				fileWriter3ComboBox.Text = "---";
				fileWriter4ComboBox.Text = "---";
                fileWriter5ComboBox.Text = "---";
            }
            else
            {
                string[] fields = LoadedProcedure.ResultsWriter.Split(new char[] { '~' });
                fileWriter1ComboBox.Text = fields[0];
                fileWriter2ComboBox.Text = (fields.Length >= 2) ? fields[1] : "---";
				fileWriter3ComboBox.Text = (fields.Length >= 3) ? fields[2] : "---";
				fileWriter4ComboBox.Text = (fields.Length >= 4) ? fields[3] : "---";
                fileWriter5ComboBox.Text = (fields.Length >= 5) ? fields[4] : "---";
            }

            if (string.IsNullOrEmpty(LoadedProcedure.EventTriggers))
            {
                eventTrigger1ComboBox.Text = "---";
                eventTrigger2ComboBox.Text = "---";
                eventTrigger3ComboBox.Text = "---";
            }
            else
            {
                string[] fields = LoadedProcedure.EventTriggers.Split(new char[] { '~' });
                eventTrigger1ComboBox.Text = fields[0];
                eventTrigger2ComboBox.Text = (fields.Length >= 2) ? fields[1] : "---";
                eventTrigger3ComboBox.Text = (fields.Length >= 3) ? fields[2] : "---";
            }

            metersKindRadioButton1.Checked = (LoadedProcedure.MetersKind == MetersKind.Single
                                                || (LoadedProcedure.MetersKind != MetersKind.Combined && LoadedProcedure.MetersKind != MetersKind.HeatMeter));
			metersKindRadioButton2.Checked = (LoadedProcedure.MetersKind == MetersKind.Combined);
            metersKindRadioButton3.Checked = (LoadedProcedure.MetersKind == MetersKind.HeatMeter);

            notesTextBox.Text = LoadedProcedure.LongDescription;
		}

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

			LoadedProcedure.Description = descriptionTextBox.Text;
			LoadedProcedure.Watermeters = watermetersTextBox.Text;

            LoadedProcedure.Protected = protectedCheckBox.Checked;
            LoadedProcedure.MustBeComplete = mustBeCompleteCheckBox.Checked;
			LoadedProcedure.ManualCtrlDisabled = manualControlDisabledCheckBox.Checked;

            //LoadedProcedure.AltProcName = altProcNameTextBox.Text.Equals("---") ? string.Empty : altProcNameTextBox.Text;
            //int itmp;
            //if (int.TryParse(altProcPeriodTextBox.Text, out itmp) && itmp >= 0) { LoadedProcedure.AltProcPeriod = itmp; }

			if (transitionStartComboBox.Items.Contains(transitionStartComboBox.Text))
			{
				LoadedProcedure.TransitionStart = transitionStartComboBox.Text.Equals("---") ? string.Empty : transitionStartComboBox.Text;
			}
			if (transitionEndComboBox.Items.Contains(transitionEndComboBox.Text))
			{
				LoadedProcedure.TransitionEnd = transitionEndComboBox.Text.Equals("---") ? string.Empty : transitionEndComboBox.Text;
			}
			if (dataEntryComboBox.Items.Contains(dataEntryComboBox.Text))
            {
                LoadedProcedure.DataEntry = dataEntryComboBox.Text.Equals("---") ? string.Empty : dataEntryComboBox.Text;
            }

            ///
            /// Printers
            ///
			if (printer1ComboBox.Items.Contains(printer1ComboBox.Text) && printer2ComboBox.Items.Contains(printer2ComboBox.Text))
			{
				bool pr = !printer1ComboBox.Text.Equals("---");
				bool pr2 = !printer2ComboBox.Text.Equals("---") && !printer2ComboBox.Text.Equals(printer1ComboBox.Text);

				if (!pr && !pr2) LoadedProcedure.ResultsPrinter = string.Empty;
				else if (pr && !pr2) LoadedProcedure.ResultsPrinter = printer1ComboBox.Text;
				else if (!pr && pr2) LoadedProcedure.ResultsPrinter = printer2ComboBox.Text;
				else LoadedProcedure.ResultsPrinter = printer1ComboBox.Text + '~' + printer2ComboBox.Text;
			}

            ///
            /// File writers
            ///
            if (fileWriter1ComboBox.Items.Contains(fileWriter1ComboBox.Text) &&
                fileWriter2ComboBox.Items.Contains(fileWriter2ComboBox.Text) &&
                fileWriter3ComboBox.Items.Contains(fileWriter3ComboBox.Text) &&
                fileWriter4ComboBox.Items.Contains(fileWriter4ComboBox.Text) &&
                fileWriter5ComboBox.Items.Contains(fileWriter5ComboBox.Text))
            {
                bool first = true;
                StringBuilder sb = new StringBuilder();
                if (!fileWriter1ComboBox.Text.Equals("---"))
                {
                    sb.Append(fileWriter1ComboBox.Text);
                    first = false;
                }
                
                if (!fileWriter2ComboBox.Text.Equals("---") && !fileWriter2ComboBox.Text.Equals(fileWriter1ComboBox.Text))
                {
                    if (!first) sb.Append("~");
                    sb.Append(fileWriter2ComboBox.Text);
                    first = false;
                }
                
                if (!fileWriter3ComboBox.Text.Equals("---") && !fileWriter3ComboBox.Text.Equals(fileWriter1ComboBox.Text)
                                                            && !fileWriter3ComboBox.Text.Equals(fileWriter2ComboBox.Text))
                {
                    if (!first) sb.Append("~");
                    sb.Append(fileWriter3ComboBox.Text);
                    first = false;
                }
                
                if (!fileWriter4ComboBox.Text.Equals("---") && !fileWriter4ComboBox.Text.Equals(fileWriter1ComboBox.Text)
                                                            && !fileWriter4ComboBox.Text.Equals(fileWriter2ComboBox.Text)
                                                            && !fileWriter4ComboBox.Text.Equals(fileWriter3ComboBox.Text))
                {
                    if (!first) sb.Append("~");
                    sb.Append(fileWriter4ComboBox.Text);
                    first = false;
                }
                
                if (!fileWriter5ComboBox.Text.Equals("---") && !fileWriter5ComboBox.Text.Equals(fileWriter1ComboBox.Text)
                                                            && !fileWriter5ComboBox.Text.Equals(fileWriter2ComboBox.Text)
                                                            && !fileWriter5ComboBox.Text.Equals(fileWriter3ComboBox.Text)
                                                            && !fileWriter5ComboBox.Text.Equals(fileWriter4ComboBox.Text))
                {
                    if (!first) sb.Append("~");
                    sb.Append(fileWriter5ComboBox.Text);
                    first = false;
                }

                LoadedProcedure.ResultsWriter = sb.ToString();
            }

            ///
            /// Event triggers
            /// 
			if (eventTrigger1ComboBox.Items.Contains(eventTrigger1ComboBox.Text) &&
				eventTrigger2ComboBox.Items.Contains(eventTrigger2ComboBox.Text) &&
				eventTrigger3ComboBox.Items.Contains(eventTrigger3ComboBox.Text))
            {
				bool first = true;
				StringBuilder sb = new StringBuilder();
				if (!eventTrigger1ComboBox.Text.Equals("---"))
				{
					sb.Append(eventTrigger1ComboBox.Text);
                    first = false;
				}
				if (!eventTrigger2ComboBox.Text.Equals("---") && !eventTrigger2ComboBox.Text.Equals(eventTrigger1ComboBox.Text))
				{
					if (!first) sb.Append("~");
					sb.Append(eventTrigger2ComboBox.Text);
                    first = false;
				}
				if (!eventTrigger3ComboBox.Text.Equals("---") && !eventTrigger3ComboBox.Text.Equals(eventTrigger1ComboBox.Text)
															  && !eventTrigger3ComboBox.Text.Equals(eventTrigger2ComboBox.Text))
				{
					if (!first) sb.Append("~");
					sb.Append(eventTrigger3ComboBox.Text);
                    first = false;
				}
				LoadedProcedure.EventTriggers = sb.ToString();
            }

			LoadedProcedure.MetersKind = (metersKindRadioButton1.Checked ? MetersKind.Single
                                                                         : (metersKindRadioButton2.Checked ? MetersKind.Combined
                                                                                                           : MetersKind.HeatMeter));
			LoadedProcedure.LongDescription = notesTextBox.Text;
		}

		#endregion

		#region History

		void InitializeHistoryTab()
		{
			TBF.LocalSettings ls = Program.LocalSettings;

			historyListViewEx.Columns.Add(Strings.Name,              (ls.HistoryColumnCount > 0) ? ls.HistoryColumnWidths[0] : 80);
			historyListViewEx.Columns.Add(Strings.Revision,          (ls.HistoryColumnCount > 1) ? ls.HistoryColumnWidths[1] : 80);
			historyListViewEx.Columns.Add(Strings.Date_and_time,     (ls.HistoryColumnCount > 2) ? ls.HistoryColumnWidths[2] : 120);
			historyListViewEx.Columns.Add(Strings.User,              (ls.HistoryColumnCount > 3) ? ls.HistoryColumnWidths[3] : 55);
			historyListViewEx.Columns.Add(Strings.DescriptionColHdr, (ls.HistoryColumnCount > 4) ? ls.HistoryColumnWidths[4] : 150);
            historyListViewEx.Columns.Add(Strings.Other,             (ls.HistoryColumnCount > 5) ? ls.HistoryColumnWidths[5] : 150);

			RefreshHistoryTab();
		}

		void RefreshHistoryTab()
		{
			NHibernate.ISession session = TBF.DB.CreateSession(DBKind.Config);
			IList<Procedure> procedures = session
                .QueryOver<Procedure>()
                .Where(x => x.ProcedureState == ProcedureState.History)
				.List();

			int predecessorId = LoadedProcedure.PredecessorId;

			IList<Procedure> oneProcedure = session
                .QueryOver<Procedure>()
                .Where(x => (x.ProcedureState == ProcedureState.Active))
                .And(x => (x.Id == predecessorId))
				.List();

			if (oneProcedure.Count == 1)
			{
				predecessorId = oneProcedure[0].PredecessorId;
			}
			else
			{
				return;
			}

			while (predecessorId != 0)
			{
				bool found = false;
				foreach (var p in procedures)
				{
					if (p.Id == predecessorId)
					{
						found = true;
						ListViewItem item = new ListViewItem(p.Name);
                        item.Tag = p;
						item.SubItems.Add(p.Revision.ToString());
						item.SubItems.Add(p.LastChgTime.ToString());
						item.SubItems.Add(p.LastChgUser.ToString());
						item.SubItems.Add(p.Description);
                        
                        string other = string.Empty;
                        //if ((p.Watermeters != null) && (p.Watermeters.Count > 0) && (p.Watermeters[0] != null)) other = p.Watermeters[0];
                        item.SubItems.Add(other);
                        
                        historyListViewEx.Items.Add(item);

						predecessorId = p.PredecessorId;	/// Iterate
						break;
					}
				}
				if (!found) break;
			}
		}

		void UpdateFromHistoryTab()
		{
			// Do nothing
		}

		#endregion

        #region Metrology1

        Control[] metrology1Editors;

		public enum MtrlgyClmn
		{
			Name,
			Part,
#if SHOW_Q_TG
            Qtg,
#endif
            Qfrom,
			Qto,
            FlowUnit,
			Volume,
            VolumeUnit,
			TestTime,
			ErrLimLo,
			ErrLimHi,
            Uncertainty,
            Repeats,
            Method,
			ColumnsCount
		}

		void PrepareMetrology1Tab()
		{
            ListViewEx lv = metrology1ListViewEx;
			lv.Columns.Add(new ColumnHeader { Text = Strings.Test_chdr, Width = 70 });
			lv.Columns.Add(new ColumnHeader { Text = Strings.Part, Width = 40 });
#if SHOW_Q_TG
            lv.Columns.Add(new ColumnHeader { Text = Strings.Q_tg, Width = 80 });
#endif
            lv.Columns.Add(new ColumnHeader { Text = Strings.Q_from, Width = 80 });
			lv.Columns.Add(new ColumnHeader { Text = Strings.Q_to, Width = 80 });
            lv.Columns.Add(new ColumnHeader { Text = "Unit", Width = 50 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.Volume, Width = 70 });
            lv.Columns.Add(new ColumnHeader { Text = "Unit", Width = 50 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.Test_time_s_chdr, Width = 70 });
			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 = Strings.Uncertainty_pct_chdr, Width = 90 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.Repeats_nr_chdr, Width = 90 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.Method_chdr, Width = 200 });

			methodCBox = new ComboBox();
			foreach (var m in TestMethods) methodCBox.Items.Add(m.Cfg.Name);

            var flowUnitBox = new ComboBox();
            var volUnitBox = new ComboBox();
            for (Unit u = 0; u < Unit.Count; u++)
            {
                if (Units.IsFlow(u)) flowUnitBox.Items.Add(u.ToDescription());
                if (Units.IsVolume(u)) volUnitBox.Items.Add(u.ToDescription());
            }

			metrology1Editors = new Control[]
				{
					new TextBox(),  /// Name
					new TextBox(),  /// Part
#if SHOW_Q_TG
					new TextBox(),  /// Qtg
#endif
					new TextBox(),  /// Qfrom
					new TextBox(),  /// Qto
                    flowUnitBox,
					new TextBox(),  /// Volume
                    volUnitBox,
					new TextBox(),  /// Test time
					new TextBox(),  /// Err.Lim. -
					new TextBox(),  /// Err.Lim. +
					new TextBox(),  /// Uncertainty
					new TextBox(),  /// Repeats count
					methodCBox,		/// Method
				};

			foreach (var ctrl in metrology1Editors)
			{
				metrology1TabPage.Controls.Add(ctrl);
			}
        }


        void RefreshMetrology1Tab()
        {
            metrology1ListViewEx.Items.Clear();
            foreach (var test in LoadedProcedure.Tests)
            {
                AddToMetrology1Tab(test);
            }

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

        void AddToMetrology1Tab(Test test)
        {
            ///
            /// Metrology 1 item with subitems
            ///
            ListViewItem lvi = new ListViewItem(test.Name);					            /// Name
            lvi.Tag = test;
            lvi.SubItems.Add((test.Part == 0) ? "-" : test.Part.ToString());	        /// Part
#if SHOW_Q_TG
            lvi.SubItems.Add(Units.ConvertTo(test.FlowUnit, test.Qtg).ToString());	    /// Q_tg (target flow)
#endif
            lvi.SubItems.Add(Units.ConvertTo(test.FlowUnit, test.Qfrom).ToString());    /// Q_from
            lvi.SubItems.Add(Units.ConvertTo(test.FlowUnit, test.Qto).ToString());	    /// Q_to
            lvi.SubItems.Add(test.FlowUnit.ToDescription());
            lvi.SubItems.Add(Units.ConvertTo(test.VolumeUnit, test.Volume).ToString());	/// Volume
            lvi.SubItems.Add(test.VolumeUnit.ToDescription());
            lvi.SubItems.Add(test.TestTime.ToString());
            lvi.SubItems.Add(test.ErrLimLo.ToString());
            lvi.SubItems.Add(test.ErrLimHi.ToString());
            lvi.SubItems.Add(test.Uncertainty.ToString());
            lvi.SubItems.Add(test.Repeats.ToString());
            lvi.SubItems.Add((test.Method != null) ? test.Method.ToString() : string.Empty);

            test.ResetChngdFlags();

            metrology1ListViewEx.Items.Add(lvi);
        }

        void UpdateFromMetrology1Tab()
        {
            for (int i = 0; i < metrology1ListViewEx.Items.Count; i++)
            {
                ListViewItem lvi = metrology1ListViewEx.Items[i];
                Test test = (Test)lvi.Tag;

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

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

                int itmp;
                float tmp;
                double dtmp;
#if SHOW_Q_TG
                if (test.QtgTextChngd && Utils.TryParseUDouble(lvi.SubItems[(int)MtrlgyClmn.Qtg].Text, out dtmp))
                    test.Qtg = (float)Units.ConvertFrom(test.FlowUnit, dtmp);
#endif
                if (test.QfromTextChngd && Utils.TryParseUDouble(lvi.SubItems[(int)MtrlgyClmn.Qfrom].Text, out dtmp))
                    test.Qfrom = (float)Units.ConvertFrom(test.FlowUnit, dtmp);

                if (test.QtoTextChngd && Utils.TryParseUDouble(lvi.SubItems[(int)MtrlgyClmn.Qto].Text, out dtmp))
                    test.Qto = (float)Units.ConvertFrom(test.FlowUnit, dtmp);

                if (test.VolumeTextChngd && Utils.TryParseUDouble(lvi.SubItems[(int)MtrlgyClmn.Volume].Text, out dtmp))
                    test.Volume = (float)Units.ConvertFrom(test.VolumeUnit, dtmp);
				
                if (Utils.TryParseUFloat(lvi.SubItems[(int)MtrlgyClmn.TestTime].Text, out tmp)) test.TestTime = tmp;
				
                if (Utils.TryParseSFloat(lvi.SubItems[(int)MtrlgyClmn.ErrLimLo].Text, out tmp)) test.ErrLimLo = tmp;
				if (Utils.TryParseSFloat(lvi.SubItems[(int)MtrlgyClmn.ErrLimHi].Text, out tmp)) test.ErrLimHi = tmp;
                if (Utils.TryParseUFloat(lvi.SubItems[(int)MtrlgyClmn.Uncertainty].Text, out tmp)) test.Uncertainty = tmp;

                if (int.TryParse(lvi.SubItems[(int)MtrlgyClmn.Repeats].Text, out itmp)) test.Repeats = itmp;

				if (methodCBox.Items.Contains(lvi.SubItems[(int)MtrlgyClmn.Method].Text))
				{
					test.Method = lvi.SubItems[(int)MtrlgyClmn.Method].Text;
				}
			}
        }

        private void metrology1ListViewEx_SubItemClicked(object sender, SubItemEventArgs e)
        {
            MtrlgyClmn column = (MtrlgyClmn)e.SubItem;

#if SHOW_Q_TG
            if (e.SubItem == (int)MtrlgyClmn.Qtg) return;
#endif
            /// Unit change is allowed when locked
            if ((column != MtrlgyClmn.FlowUnit && column != MtrlgyClmn.VolumeUnit) &&
                (!unlocked || column >= MtrlgyClmn.ColumnsCount))
            {
                return;
            }

            MtrlgyClmn[] protectedColumns = new MtrlgyClmn[]
                {
                    MtrlgyClmn.Name,
                    MtrlgyClmn.Qfrom, MtrlgyClmn.Qto,
                    MtrlgyClmn.ErrLimLo, MtrlgyClmn.ErrLimHi,
                };
            if (((e.Item.Tag as Test).Profile >= TestProfile.Protected) && protectedColumns.Contains<MtrlgyClmn>(column)) return;

    		metrology1ListViewEx.StartEditing(metrology1Editors[e.SubItem], e.Item, e.SubItem);
        }

        void metrology1ListViewEx_SubItemRightClicked(object sender, SubItemEventArgs e)
        {
#if SHOW_Q_TG
            if (e.SubItem == (int)MtrlgyClmn.Qtg) return;
#endif
            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 metrology1ListViewEx.Items)
                {
                    if (value != null && item.SubItems.Count > columnNr)
                    {
                        /// This item is below e.Item
                        item.SubItems[columnNr].Text = value;
                        item.SubItems[columnNr].BackColor = backColor;

                        switch ((MtrlgyClmn)columnNr)
                        {
                            case MtrlgyClmn.FlowUnit:   UpdateFlow(item, Units.FromDescription(value)); break;
                            case MtrlgyClmn.VolumeUnit: UpdateVolume(item, Units.FromDescription(value)); break;
                        }
                    }
                    else if (item == e.Item)
                    {
                        /// Set 'value' to the value to be copied
                        value = item.SubItems[columnNr].Text;
                        backColor = item.SubItems[columnNr].BackColor;
                    }
                }
            }
        }

        private void metrology1ListViewEx_SubItemEndEditing(object sender, SubItemEndEditingEventArgs e)
        {
            Test test = e.Item.Tag as Test;
            MtrlgyClmn column = (MtrlgyClmn)e.SubItem;
            Unit newUnit;
            int dummy;
            float fdummy;

            switch (column)
            {
                case MtrlgyClmn.Name:
                    if (Utils.IsGoodFName(e.DisplayText)) return;   /// OK
                    break;

                case MtrlgyClmn.Part:
                    if (e.DisplayText.Equals("-")) return;	        /// OK
                    if (int.TryParse(e.DisplayText, out dummy) && Data.IsGoodPartNr(dummy)) return; /// OK
                    break;

#if SHOW_Q_TG
                case MtrlgyClmn.Qtg:
                    if (Utils.TryParseUFloat(e.DisplayText, out fdummy))
                    {
                        if (e.DisplayText != e.Item.SubItems[e.SubItem].Text) test.QtgTextChngd = true;
                        return;                                     /// OK
                    }
                    break;
#endif
                case MtrlgyClmn.ErrLimLo:
                case MtrlgyClmn.ErrLimHi:
                    if (Utils.TryParseSFloat(e.DisplayText, out fdummy)) return;
                    break;

                case MtrlgyClmn.Uncertainty:
                    if (Utils.TryParseUFloat(e.DisplayText, out fdummy)) return;
                    break;

                case MtrlgyClmn.Repeats:
                    if (int.TryParse(e.DisplayText, out dummy)) return; /// OK
                    break;

                case MtrlgyClmn.FlowUnit:
                    newUnit = Units.FromDescription(e.DisplayText);
                    if (!Units.IsFlow(newUnit)) break;
                    UpdateFlow(e.Item, newUnit);
                    return; 

                case MtrlgyClmn.VolumeUnit:
                    newUnit = Units.FromDescription(e.DisplayText);
                    if (!Units.IsVolume(newUnit)) break;
                    UpdateVolume(e.Item, newUnit);
                    return;

                case MtrlgyClmn.Method:
                    if (methodCBox.Items.Contains(e.DisplayText)) return;
                    break;

                case MtrlgyClmn.Qfrom:
                case MtrlgyClmn.Qto:
                case MtrlgyClmn.Volume:
                case MtrlgyClmn.TestTime:

                    if (e.DisplayText == e.Item.SubItems[e.SubItem].Text) return;   /// Nothing changed

                    float qFrom = 1.0f;
                    float qTo = 1.0f;
                    float volume = 0.0f;
                    float testTime = 0.0f;

                    bool calculateVolume = false;
                    bool calculateTime = false;
                    bool allOk = true;

                    if (column == MtrlgyClmn.Qfrom && Utils.TryParseUFloat(e.DisplayText, out qFrom))
                    {
                        allOk &= Utils.TryParseUFloat(e.Item.SubItems[(int)MtrlgyClmn.Qto].Text, out qTo);
                        allOk &= Utils.TryParseUFloat(e.Item.SubItems[(int)MtrlgyClmn.Volume].Text, out volume);
                        if (allOk)
                        {
                            test.QfromTextChngd = true;
                            calculateTime = true;
                        }
                    }
                    else if (column == MtrlgyClmn.Qto && Utils.TryParseUFloat(e.DisplayText, out qTo))
                    {
                        allOk &= Utils.TryParseUFloat(e.Item.SubItems[(int)MtrlgyClmn.Qfrom].Text, out qFrom);
                        allOk &= Utils.TryParseUFloat(e.Item.SubItems[(int)MtrlgyClmn.Volume].Text, out volume);
                        if (allOk)
                        {
                            test.QtoTextChngd = true;
                            calculateTime = true;
                        }
                    }
                    else if (column == MtrlgyClmn.Volume && Utils.TryParseUFloat(e.DisplayText, out volume))
                    {
                        allOk &= Utils.TryParseUFloat(e.Item.SubItems[(int)MtrlgyClmn.Qfrom].Text, out qFrom);
                        allOk &= Utils.TryParseUFloat(e.Item.SubItems[(int)MtrlgyClmn.Qto].Text, out qTo);
                        if (allOk)
                        {
                            test.VolumeTextChngd = true;
                            calculateTime = true;
                        }
                    }
                    else if (column == MtrlgyClmn.TestTime && Utils.TryParseUFloat(e.DisplayText, out testTime))
                    {
                        allOk &= Utils.TryParseUFloat(e.Item.SubItems[(int)MtrlgyClmn.Qfrom].Text, out qFrom);
                        allOk &= Utils.TryParseUFloat(e.Item.SubItems[(int)MtrlgyClmn.Qto].Text, out qTo);
                        if (allOk)
                        {
                            calculateVolume = true;
                        }
                    }

                    float qAveLps = Units.ConvertFrom(test.FlowUnit, qFrom + qTo) / 7.2f;

                    if (calculateTime)
                    {
                        float volumeLtr = Units.ConvertFrom(test.VolumeUnit, volume);
                        testTime = volumeLtr / qAveLps;
                        e.Item.SubItems[(int)MtrlgyClmn.TestTime].Text = testTime.ToString();
                        return;
                    }
                    else if (calculateVolume)
                    {
                        var volumeLtr = testTime * qAveLps;
                        e.Item.SubItems[(int)MtrlgyClmn.Volume].Text = Units.ConvertTo(test.VolumeUnit, volumeLtr).ToString();
                        test.VolumeTextChngd = true;
                        return;
                    }
                    else
                    {
                        break;  /// NOK - Restore original value
                    }
            }

            /// Display text was not OK, revert to the original one
            e.DisplayText = e.Item.SubItems[e.SubItem].Text;
            e.Cancel = true;
            return;
        }

        void UpdateFlow(ListViewItem item, Unit newUnit)
        {
            Test test = item.Tag as Test;
            if (test == null || !Units.IsFlow(newUnit) || newUnit == test.FlowUnit) return;
            Unit oriUnit = test.FlowUnit;
            test.FlowUnit = newUnit;

            int ix = (int)MtrlgyClmn.Qfrom;
            double flowM3ph = Units.ConvertFrom(oriUnit, Utils.ParseUDouble(item.SubItems[ix].Text));
            item.SubItems[ix].Text = Units.ConvertTo(newUnit, test.QfromTextChngd ? flowM3ph : test.Qfrom).ToString();

            ix = (int)MtrlgyClmn.Qto;
            flowM3ph = Units.ConvertFrom(oriUnit, Utils.ParseUDouble(item.SubItems[ix].Text));
            item.SubItems[ix].Text = Units.ConvertTo(newUnit, test.QtoTextChngd ? flowM3ph : test.Qto).ToString();
#if SHOW_Q_TG
            ix = (int)MtrlgyClmn.Qtg;
            flowM3ph = Units.ConvertFrom(oriUnit, Utils.ParseUDouble(item.SubItems[ix].Text));
            item.SubItems[ix].Text = Units.ConvertTo(newUnit, test.QtgTextChngd ? flowM3ph : test.Qtg).ToString();
#endif
        }

        void UpdateVolume(ListViewItem item, Unit newUnit)
        {
            Test test = item.Tag as Test;
            if (test == null || !Units.IsVolume(newUnit) || newUnit == test.VolumeUnit) return;
            Unit oriUnit = test.VolumeUnit;
            test.VolumeUnit = newUnit;

            int ix = (int)MtrlgyClmn.Volume;
            double volumeLtr = Units.ConvertFrom(oriUnit, Utils.ParseUDouble(item.SubItems[ix].Text));
            item.SubItems[ix].Text = Units.ConvertTo(newUnit, test.VolumeTextChngd ? volumeLtr : test.Volume).ToString();
        }

        void UpdateTemperature(ListViewItem item, Unit newUnit)
        {
            Test test = item.Tag as Test;
            if (test == null || !Units.IsTemperature(newUnit) || newUnit == test.TempUnit) return;
            Unit oriUnit = test.TempUnit;
            test.TempUnit = newUnit;

            int ix = (int)Mtrlgy2Clmn.TempLimLo;
            double tempC = Units.ConvertFrom(oriUnit, Utils.ParseUDouble(item.SubItems[ix].Text));
            item.SubItems[ix].Text = Units.ConvertTo(newUnit, test.TempLimLoTextChngd ? tempC : test.TempLimLo).ToString();

            ix = (int)Mtrlgy2Clmn.TempLimHi;
            tempC = Units.ConvertFrom(oriUnit, Utils.ParseUDouble(item.SubItems[ix].Text));
            item.SubItems[ix].Text = Units.ConvertTo(newUnit, test.TempLimHiTextChngd ? tempC : test.TempLimHi).ToString();
        }

        #endregion

        #region Metrology2

		public enum Mtrlgy2Clmn
		{
			Name,
			Part,
            TempLimLo,
            TempLimHi,
            TempUnit,
            TempControl,
			ShortPulses,
			Publish,
			Evaluate,
#if ORACLE_DB
            OraId,
            OraIdRepetM,
            OraDesig,
            RawDataId,
            RawDataIdRepetM,
            RawDataDesig,
#endif
            ColumnsCount
		}

		Control[] metrology2Editors;

		void PrepareMetrology2Tab()
		{
            ListViewEx lv = metrology2ListViewEx;
			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 = Strings.Temp_lim_lo_chdr, Width = 100 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.Temp_lim_hi_chdr, Width = 100 });
            lv.Columns.Add(new ColumnHeader { Text = "Unit", Width = 50 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.Control_water_temp_chdr, Width = 110 });
			lv.Columns.Add(new ColumnHeader { Text = Strings.Short_pulses, Width = 100 });          /// Strings.Tol_red_pct_chdr
			lv.Columns.Add(new ColumnHeader { Text = Strings.Publish, Width = 80 });
			lv.Columns.Add(new ColumnHeader { Text = Strings.Evaluate, Width = 80 });
#if ORACLE_DB
            lv.Columns.Add(new ColumnHeader { Text = "Ora Id", Width = 45 });
            lv.Columns.Add(new ColumnHeader { Text = "+ (m) * repet.#", Width = 80 });
            lv.Columns.Add(new ColumnHeader { Text = "Ora name", Width = 70 });
            lv.Columns.Add(new ColumnHeader { Text = "Raw data Id", Width = 70 });
            lv.Columns.Add(new ColumnHeader { Text = "+ (m) * repet.#", Width = 80 });
            lv.Columns.Add(new ColumnHeader { Text = "Raw data name", Width = 95 });
#endif

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

            ComboBox tempUnitBox = new ComboBox();
            for (Common.Unit u = 0; u < Common.Unit.Count; u++)
            {
                if (Units.IsTemperature(u)) tempUnitBox.Items.Add(u.ToDescription());
            }

            ComboBox tempControlBox = new ComboBox();   /// control for Control water temp.
            tempControlBox.Items.Add("---");
            foreach (var tc in TempControllers) tempControlBox.Items.Add(tc.Name);

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

			metrology2Editors = new Control[]
				{
					new TextBox(),      /// Name
					new TextBox(),      /// Part
					new TextBox(),      /// Temp.Lim. -
					new TextBox(),      /// Temp.Lim. +
                    tempUnitBox,
					tempControlBox,     /// Water temp. control
					new TextBox(),      /// Short pulses
					publishCBox,		/// Publish
					yesNo3CBox,			/// Evaluate
#if ORACLE_DB
					new TextBox(),      /// Ora Id
					new TextBox(),      /// Ora Id repet multi
					new TextBox(),      /// Ora name
					new TextBox(),      /// Raw data Id
					new TextBox(),      /// Raw data Id repet multi
					new TextBox(),      /// Raw data name
#endif
                };

			foreach (var ctrl in metrology2Editors)
			{
				metrology2TabPage.Controls.Add(ctrl);
			}
		}

        void RefreshMetrology2Tab()
        {
            metrology2ListViewEx.Items.Clear();
            foreach (var test in LoadedProcedure.Tests) AddToMetrology2Tab(test);

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

        void AddToMetrology2Tab(Test test)
        {
            ///
            /// Metrology 2 item with subitems
            ///
            ListViewItem lvi = new ListViewItem(test.Name);						/// Name
            lvi.Tag = test;
            lvi.SubItems.Add((test.Part == 0) ? "-" : test.Part.ToString());	/// Part
            lvi.SubItems.Add(Units.ConvertTo(test.TempUnit, test.TempLimLo).ToString());
            lvi.SubItems.Add(Units.ConvertTo(test.TempUnit, test.TempLimHi).ToString());
            lvi.SubItems.Add(test.TempUnit.ToDescription());
            lvi.SubItems.Add(string.IsNullOrEmpty(test.TempControl) ? "---" : test.TempControl);
            lvi.SubItems.Add(test.ShortPulses.ToString());
            lvi.SubItems.Add(((Publish)test.Publish).ToDescription());
            lvi.SubItems.Add(test.DoEvaluate ? Strings.yes : Strings.no);
#if ORACLE_DB
            lvi.SubItems.Add(test.OraId.ToString());
            lvi.SubItems.Add(test.OraIdRepetMulti.ToString());
            lvi.SubItems.Add((test.OraDesignation != null) ? test.OraDesignation : string.Empty);
            lvi.SubItems.Add(test.RawDataId.ToString());
            lvi.SubItems.Add(test.RawDataIdRepetMulti.ToString());
            lvi.SubItems.Add((test.RawDataDesignation != null) ? test.RawDataDesignation : string.Empty);
#endif
            metrology2ListViewEx.Items.Add(lvi);
        }

        void UpdateFromMetrology2Tab()
        {
            double dtmp;

            for (int i = 0; i < metrology2ListViewEx.Items.Count; i++)
            {
                try
                {
                    ListViewItem lvi = metrology2ListViewEx.Items[i];
                    Test entity = (Test)lvi.Tag;
                    entity.ItemNr = i;
                    entity.Name = lvi.SubItems[(int)Mtrlgy2Clmn.Name].Text;
                    entity.Part = lvi.SubItems[(int)Mtrlgy2Clmn.Part].Text.Equals("-") ? 0 : int.Parse(lvi.SubItems[(int)Mtrlgy2Clmn.Part].Text);
                    entity.TempControl = lvi.SubItems[(int)Mtrlgy2Clmn.TempControl].Text.Equals("---")
                                          ? string.Empty
                                          : lvi.SubItems[(int)Mtrlgy2Clmn.TempControl].Text;
                    entity.ShortPulses = (double)Utils.ParseUFloat(lvi.SubItems[(int)Mtrlgy2Clmn.ShortPulses].Text);
                    entity.DoEvaluate = lvi.SubItems[(int)Mtrlgy2Clmn.Evaluate].Text.Equals(Strings.yes);

                    if (entity.TempLimLoTextChngd && Utils.TryParseUDouble(lvi.SubItems[(int)Mtrlgy2Clmn.TempLimLo].Text, out dtmp))
                        entity.TempLimLo = (float)Units.ConvertFrom(entity.TempUnit, dtmp);

                    if (entity.TempLimHiTextChngd && Utils.TryParseUDouble(lvi.SubItems[(int)Mtrlgy2Clmn.TempLimHi].Text, out dtmp))
                        entity.TempLimHi = (float)Units.ConvertFrom(entity.TempUnit, dtmp);

                    for (Publish pb = 0; pb < Publish.Count; pb++)
                    {
                        if (lvi.SubItems[(int)Mtrlgy2Clmn.Publish].Text.Equals(pb.ToDescription()))
                        {
                            entity.Publish = (sbyte)pb;
                            break;
                        }
                    }
#if ORACLE_DB
                    entity.OraId = int.Parse(lvi.SubItems[(int)Mtrlgy2Clmn.OraId].Text);
                    entity.OraIdRepetMulti = int.Parse(lvi.SubItems[(int)Mtrlgy2Clmn.OraId].Text);
                    entity.OraDesignation = lvi.SubItems[(int)Mtrlgy2Clmn.OraDesig].Text;
                    entity.RawDataId = int.Parse(lvi.SubItems[(int)Mtrlgy2Clmn.RawDataId].Text);
                    entity.RawDataIdRepetMulti = int.Parse(lvi.SubItems[(int)Mtrlgy2Clmn.RawDataId].Text);
                    entity.RawDataDesignation = lvi.SubItems[(int)Mtrlgy2Clmn.RawDataDesig].Text;
#endif
                }
                catch (Exception exc)
                {
                    MessageBox.Show(string.Format("Unexpected problem: {0}", exc.Message));
                }
			}
        }

        private void metrology2ListViewEx_SubItemClicked(object sender, SubItemEventArgs e)
        {
            Mtrlgy2Clmn column = (Mtrlgy2Clmn)e.SubItem;
            
            /// Unit change is allowed when locked
            if (column != Mtrlgy2Clmn.TempUnit && (!unlocked || column >= Mtrlgy2Clmn.ColumnsCount))
            {
                return;
            }

            Mtrlgy2Clmn[] protectedColumns = new Mtrlgy2Clmn[]
                {
                    Mtrlgy2Clmn.Name,
                    Mtrlgy2Clmn.TempLimLo, Mtrlgy2Clmn.TempLimHi,
                    Mtrlgy2Clmn.Publish, Mtrlgy2Clmn.Evaluate
                };
            if (((e.Item.Tag as Test).Profile >= TestProfile.Protected) && protectedColumns.Contains<Mtrlgy2Clmn>((Mtrlgy2Clmn)e.SubItem)) return;

            metrology2ListViewEx.StartEditing(metrology2Editors[e.SubItem], e.Item, e.SubItem);
        }

        void metrology2ListViewEx_SubItemRightClicked(object sender, SubItemEventArgs e)
        {
            if (!unlocked || e.SubItem >= (int)Mtrlgy2Clmn.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 metrology2ListViewEx.Items)
                {
                    if (value != null && item.SubItems.Count > columnNr)
                    {
                        item.SubItems[columnNr].Text = value;
                        item.SubItems[columnNr].BackColor = backColor;

                        if (columnNr == (int)Mtrlgy2Clmn.TempUnit) UpdateTemperature(item, Units.FromDescription(value));
                    }
                    else if (item == e.Item)
                    {
                        value = item.SubItems[columnNr].Text;
                        backColor = item.SubItems[columnNr].BackColor;
                    }
                }
            }
        }

        private void metrology2ListViewEx_SubItemEndEditing(object sender, SubItemEndEditingEventArgs e)
        {
            Test test = e.Item.Tag as Test;
            Mtrlgy2Clmn column = (Mtrlgy2Clmn)e.SubItem;
            Unit newUnit;
            int dummy;
            float fdummy;

            switch (column)
            {
                case Mtrlgy2Clmn.Name:
                    if (Utils.IsGoodFName(e.DisplayText)) return;   /// OK
                    break;

                case Mtrlgy2Clmn.Part:
                {
                    if (e.DisplayText.Equals("-")) return;	/// OK
                    if (int.TryParse(e.DisplayText, out dummy) && Data.IsGoodPartNr(dummy)) return;   /// OK
                    break;
                }

                case Mtrlgy2Clmn.TempLimLo:
                    if (Utils.TryParseUFloat(e.DisplayText, out fdummy))
                    {
                        if (e.DisplayText != e.Item.SubItems[e.SubItem].Text) test.TempLimLoTextChngd = true;
                        return;                                     /// OK
                    }
                    break;

                case Mtrlgy2Clmn.TempLimHi:
                    if (Utils.TryParseUFloat(e.DisplayText, out fdummy))
                    {
                        if (e.DisplayText != e.Item.SubItems[e.SubItem].Text) test.TempLimHiTextChngd = true;
                        return;                                     /// OK
                    }
                    break;

                case Mtrlgy2Clmn.TempUnit:
                    newUnit = Units.FromDescription(e.DisplayText);
                    if (!Units.IsTemperature(newUnit)) break;
                    UpdateTemperature(e.Item, newUnit);
                    return;

                case Mtrlgy2Clmn.ShortPulses:
                    if (Utils.TryParseUFloat(e.DisplayText, out fdummy)) return;
                    break;

                case Mtrlgy2Clmn.TempControl:
                case Mtrlgy2Clmn.Publish:
                case Mtrlgy2Clmn.Evaluate:
                    /// Combo boxes
                    if ((metrology2Editors[e.SubItem] as ComboBox).Items.Contains(e.DisplayText)) return;   /// OK
                    break;
#if ORACLE_DB
                case Mtrlgy2Clmn.OraId:
                case Mtrlgy2Clmn.OraIdRepetM:
                case Mtrlgy2Clmn.RawDataId:
                case Mtrlgy2Clmn.RawDataIdRepetM:
                    if (int.TryParse(e.DisplayText, out dummy)) return;   /// OK
                    break;

                case Mtrlgy2Clmn.OraDesig:
                case Mtrlgy2Clmn.RawDataDesig:
                    return;                         /// Always OK
#endif
            }

            /// Display text was not OK, revert to the original one
            e.DisplayText = e.Item.SubItems[e.SubItem].Text;
            e.Cancel = true;
            return;
        }

        #endregion

        #region Process

        public enum ProcessClmn
		{
			Name,
			Part,
            DrainingBefore,
            DrainingAfter,
			Feeding,
			Bench,
			Output,
			Sensor,
#if HEAT_METERS
            HeatMeterSensors,
#endif
            TrnStart,
            TrnBetween,
			TrnStop,
			ColumnsCount
		}

        Control[] processEditors;

		void PrepareProcess()
        {
            ListViewEx lv = processListViewEx;
			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 = Strings.Draining_before, Width = 90 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.Draining_after, Width = 90 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.Feeding_chdr, Width = 80 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.Bench_chdr, Width = 80 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.Output_chdr, Width = 80 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.Sensors_chdr, Width = 80 });
#if HEAT_METERS
            lv.Columns.Add(new ColumnHeader { Text = Strings.Heat_meter_sensors, Width = 110 });
#endif
			lv.Columns.Add(new ColumnHeader { Text = Strings.TransitionStart_chdr, Width = 100 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.TransitionBetween_chdr, Width = 100 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.TransitionEnd_chdr, Width = 100 });

            ComboBox yesNo1CBox = new ComboBox();   /// control for Draining before test
            yesNo1CBox.Items.Add(Strings.yes);
            yesNo1CBox.Items.Add(Strings.no);

            ComboBox yesNo2CBox = new ComboBox();   /// control for Draining after test
            yesNo2CBox.Items.Add(Strings.yes);
            yesNo2CBox.Items.Add(Strings.no);

            processEditors = new Control[]
				{
					new TextBox(),      /// Name
					new TextBox(),      /// Part
                    yesNo1CBox,
                    yesNo2CBox,
					new ComboBox(),     /// Feeding
					new ComboBox(),     /// Table
					new ComboBox(),     /// Output
					new ComboBox(),     /// Meters
#if HEAT_METERS
					new ComboBox(),     /// Heat meters
#endif
					new ComboBox(),     /// Transition-Start
					new ComboBox(),     /// Transition-Between
					new ComboBox(),     /// Transition-End
				};

			foreach (var path in feedingPaths) ((ComboBox)processEditors[(int)ProcessClmn.Feeding]).Items.Add(path.Name);
			foreach (var path in benchPaths) ((ComboBox)processEditors[(int)ProcessClmn.Bench]).Items.Add(path.Name);
            foreach (var path in outputPaths)  ((ComboBox)processEditors[(int)ProcessClmn.Output]).Items.Add(path.Name);
            foreach (var path in metersPaths)  ((ComboBox)processEditors[(int)ProcessClmn.Sensor]).Items.Add(path.Name);
#if HEAT_METERS
            foreach (var path in heatMetersPaths) ((ComboBox)processEditors[(int)ProcessClmn.HeatMeterSensors]).Items.Add(path.Name);
#endif

            ((ComboBox)processEditors[(int)ProcessClmn.TrnStart]).Items.Add("---");
            ((ComboBox)processEditors[(int)ProcessClmn.TrnBetween]).Items.Add("---");
            ((ComboBox)processEditors[(int)ProcessClmn.TrnStop]).Items.Add("---");
            foreach (var trans in transitionSequences)
			{
				((ComboBox)processEditors[(int)ProcessClmn.TrnStart]).Items.Add(trans.Name);
                ((ComboBox)processEditors[(int)ProcessClmn.TrnBetween]).Items.Add(trans.Name);
                ((ComboBox)processEditors[(int)ProcessClmn.TrnStop]).Items.Add(trans.Name);
			}

			foreach (var ctrl in processEditors)
			{
				processTabPage.Controls.Add(ctrl);
			}
		}

        void RefreshProcessTab()
        {
            processListViewEx.Items.Clear();
            foreach (var test in LoadedProcedure.Tests) AddToProcessTab(test);

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

        void AddToProcessTab(Test test)
        {
            ITestMethod tm = TBF.Rig.TbfComponents.FindComponent(test.Method, TbfComponents) as ITestMethod;
            bool isNotAHydroTest = (tm != null) && !tm.DoTransitions();

            ///
            /// Process item with subitems
            ///
            ListViewItem lvi = new ListViewItem(test.Name);						    /// Name
            lvi.Tag = test;
            lvi.SubItems.Add((test.Part == 0) ? "-" : test.Part.ToString());	    /// Part

            if (isNotAHydroTest)
            {
                lvi.SubItems.Add(string.Empty);     /// Draining before test N/A
                lvi.SubItems.Add(string.Empty);     /// Draining after test N/A
                lvi.SubItems.Add(string.Empty);     /// FeedingPath N/A
                lvi.SubItems.Add(string.Empty);     /// BenchPath N/A
                lvi.SubItems.Add(string.Empty);     /// OutputPath N/A
#if HEAT_METERS
                lvi.SubItems.Add(test.HeatMetersPath);
#endif
                lvi.SubItems.Add(test.MetersPath);
                lvi.SubItems.Add(string.Empty);     /// RelTransBefore N/A
                lvi.SubItems.Add(string.Empty);     /// RelTransBetween N/A
                lvi.SubItems.Add(string.Empty);     /// TransitionAfter N/A
            }
            else
            {
                lvi.SubItems.Add(test.DoDraining ? Strings.yes : Strings.no);       /// Draining before test
                lvi.SubItems.Add(test.DoDrainingAfter ? Strings.yes : Strings.no);  /// Draining after test
                lvi.SubItems.Add(test.FeedingPath);
                lvi.SubItems.Add(test.BenchPath);
                lvi.SubItems.Add(test.OutputPath);
#if HEAT_METERS
                lvi.SubItems.Add(test.HeatMetersPath);
#endif
                lvi.SubItems.Add(test.MetersPath);
                lvi.SubItems.Add(string.IsNullOrEmpty(test.TransBefore) ? "---" : test.TransBefore);
                lvi.SubItems.Add(string.IsNullOrEmpty(test.TransBetween) ? "---" : test.TransBetween);
                lvi.SubItems.Add(string.IsNullOrEmpty(test.TransAfter) ? "---" : test.TransAfter);
            }

            processListViewEx.Items.Add(lvi);
        }

        void UpdateFromProcessTab()
        {
            for (int i = 0; i < processListViewEx.Items.Count; i++)
            {
                ListViewItem lvi = processListViewEx.Items[i];
                Test test = (Test)lvi.Tag;

                ITestMethod tm = TBF.Rig.TbfComponents.FindComponent(test.Method, TbfComponents) as ITestMethod;
                bool isNotAHydroTest = (tm != null) && !tm.DoTransitions();

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

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

                int column;
                string subItemText;
                if (!isNotAHydroTest)
                {
                    /// Is a hydraulical test or test.Method component == null
                    test.DoDraining = lvi.SubItems[(int)ProcessClmn.DrainingBefore].Text.Equals(Strings.yes);
                    test.DoDrainingAfter = lvi.SubItems[(int)ProcessClmn.DrainingAfter].Text.Equals(Strings.yes);

                    column = (int)ProcessClmn.Feeding;
                    subItemText = lvi.SubItems[column].Text;
                    if (string.IsNullOrEmpty(subItemText) || (processEditors[column] as ComboBox).Items.Contains(subItemText))
                    {
                        test.FeedingPath = subItemText;
                    }

                    column = (int)ProcessClmn.Bench;
                    subItemText = lvi.SubItems[column].Text;
                    if (string.IsNullOrEmpty(subItemText) || (processEditors[column] as ComboBox).Items.Contains(subItemText))
                    {
                        test.BenchPath = subItemText;
                    }

                    column = (int)ProcessClmn.Output;
                    subItemText = lvi.SubItems[column].Text;
                    if (string.IsNullOrEmpty(subItemText) || (processEditors[column] as ComboBox).Items.Contains(subItemText))
                    {
                        test.OutputPath = subItemText;
                    }

                    column = (int)ProcessClmn.TrnStart;
                    subItemText = lvi.SubItems[column].Text;
                    if (string.IsNullOrEmpty(subItemText) || (processEditors[column] as ComboBox).Items.Contains(subItemText))
                    {
                        test.TransBefore = (string.IsNullOrEmpty(subItemText) || subItemText.Equals("---")) ? string.Empty : subItemText;
                    }

                    column = (int)ProcessClmn.TrnBetween;
                    subItemText = lvi.SubItems[column].Text;
                    if (string.IsNullOrEmpty(subItemText) || (processEditors[column] as ComboBox).Items.Contains(subItemText))
                    {
                        test.TransBetween = (string.IsNullOrEmpty(subItemText) || subItemText.Equals("---")) ? string.Empty : subItemText;
                    }

                    column = (int)ProcessClmn.TrnStop;
                    subItemText = lvi.SubItems[column].Text;
                    if (string.IsNullOrEmpty(subItemText) || (processEditors[column] as ComboBox).Items.Contains(subItemText))
                    {
                        test.TransAfter = (string.IsNullOrEmpty(subItemText) || subItemText.Equals("---")) ? string.Empty : subItemText;
                    }
                }

                column = (int)ProcessClmn.Sensor;
                subItemText = lvi.SubItems[column].Text;
                if ((processEditors[column] as ComboBox).Items.Contains(subItemText))
                {
                    test.MetersPath = subItemText;
                }
#if HEAT_METERS
                if ((processEditors[(int)ProcessClmn.HeatMeterSensors] as ComboBox).Items.Contains(lvi.SubItems[(int)ProcessClmn.HeatMeterSensors].Text))
                {
                    test.HeatMetersPath = lvi.SubItems[(int)ProcessClmn.HeatMeterSensors].Text;
                }
#endif
			}
        }

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

            ProcessClmn[] protectedColumns = new ProcessClmn[] { ProcessClmn.Name };
            if (((e.Item.Tag as Test).Profile >= TestProfile.Protected) && protectedColumns.Contains<ProcessClmn>((ProcessClmn)e.SubItem)) return;

            ITestMethod tm = TBF.Rig.TbfComponents.FindComponent((e.Item.Tag as Test).Method, TbfComponents) as ITestMethod;
            bool isNotAHydroTest = (tm != null) && !tm.DoTransitions();

            if (isNotAHydroTest && ((e.SubItem == (int)ProcessClmn.DrainingBefore) ||
                                    (e.SubItem == (int)ProcessClmn.DrainingAfter) ||
                                    (e.SubItem == (int)ProcessClmn.Feeding) ||
                                    (e.SubItem == (int)ProcessClmn.Bench) || 
                                    (e.SubItem == (int)ProcessClmn.Output) ||
                                    (e.SubItem == (int)ProcessClmn.TrnStart) ||
                                    (e.SubItem == (int)ProcessClmn.TrnBetween) ||
                                    (e.SubItem == (int)ProcessClmn.TrnStop)))
            {
                return;     /// Prevent editing these cells
            }

            processListViewEx.StartEditing(processEditors[e.SubItem], e.Item, e.SubItem);
        }

        void processListViewEx_SubItemRightClicked(object sender, SubItemEventArgs e)
        {
            if (!unlocked || e.SubItem >= (int)ProcessClmn.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 processListViewEx.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 processListViewEx_SubItemEndEditing(object sender, SubItemEndEditingEventArgs e)
        {
            if (e.SubItem == (int)ProcessClmn.Name)
            {
                if (!Utils.IsGoodFName(e.DisplayText))
                {
                    e.DisplayText = e.Item.SubItems[e.SubItem].Text;
                    e.Cancel = true;
                    return;								/// NOK
                }
            }

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

            if ((e.SubItem == (int)ProcessClmn.DrainingBefore) && !(processEditors[(int)ProcessClmn.DrainingBefore] as ComboBox).Items.Contains(e.DisplayText))
            {
                e.DisplayText = e.Item.SubItems[e.SubItem].Text;
                e.Cancel = true;
                return;								    /// NOK
            }

            if ((e.SubItem == (int)ProcessClmn.DrainingAfter) && !(processEditors[(int)ProcessClmn.DrainingAfter] as ComboBox).Items.Contains(e.DisplayText))
            {
                e.DisplayText = e.Item.SubItems[e.SubItem].Text;
                e.Cancel = true;
                return;								    /// NOK
            }

            if (((e.SubItem == (int)ProcessClmn.Feeding) && !(processEditors[(int)ProcessClmn.Feeding] as ComboBox).Items.Contains(e.DisplayText)) ||
                ((e.SubItem == (int)ProcessClmn.Bench) && !(processEditors[(int)ProcessClmn.Bench] as ComboBox).Items.Contains(e.DisplayText)) ||
                ((e.SubItem == (int)ProcessClmn.Output) && !(processEditors[(int)ProcessClmn.Output] as ComboBox).Items.Contains(e.DisplayText)) ||
                ((e.SubItem == (int)ProcessClmn.Sensor) && !(processEditors[(int)ProcessClmn.Sensor] as ComboBox).Items.Contains(e.DisplayText)) ||
                ((e.SubItem == (int)ProcessClmn.TrnStart) && !(processEditors[(int)ProcessClmn.TrnStart] as ComboBox).Items.Contains(e.DisplayText)) ||
                ((e.SubItem == (int)ProcessClmn.TrnBetween) && !(processEditors[(int)ProcessClmn.TrnBetween] as ComboBox).Items.Contains(e.DisplayText)) ||
                ((e.SubItem == (int)ProcessClmn.TrnStop) && !(processEditors[(int)ProcessClmn.TrnStop] as ComboBox).Items.Contains(e.DisplayText)))
            {
                e.DisplayText = e.Item.SubItems[e.SubItem].Text;
                e.Cancel = true;
            }
        }

        #endregion

        #region Parameters

        public enum ParametersClmn
		{
			Name,
			Part,
			PumpPower,
            MassRepeats,
#if STABLE_MASS_EXTRAS
			MassSpread,
            MassMethod,
#endif
			Time_Pump2StartV,
			Time_BeforeFlow,
			Time_Flow2Mass,
			Time_Stop2Mass,
			ColumnsCount
		}

		Control[] parametersEditors;

		void PrepareParameters()
		{
            ListViewEx lv = parametersListViewEx;
			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 = Strings.Pump_power_pct, Width = 90 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.Mass_repeats, Width = 90 });
#if STABLE_MASS_EXTRAS
			lv.Columns.Add(new ColumnHeader { Text = Strings.Mass_spread_kg, Width = 110 });
            lv.Columns.Add(new ColumnHeader { Text = Strings.Mass_method, Width = 90 });
#endif
            lv.Columns.Add(new ColumnHeader { Text = Strings.TimePump2StartV_chdr, Width = 70 });
			lv.Columns.Add(new ColumnHeader { Text = Strings.TimeBeforeSettingFlow, Width = 70 });
			lv.Columns.Add(new ColumnHeader { Text = Strings.TimeFlow2Start_chdr, Width = 70 });
			lv.Columns.Add(new ColumnHeader { Text = Strings.Time2MassMsrmt_chdr, Width = 70 });

            parametersEditors = new Control[]
				{
					new TextBox(),      /// Name
					new TextBox(),      /// Part
					new ComboBox(),     /// PumpPower
					new TextBox(),		/// MassRepeats
#if STABLE_MASS_EXTRAS										
					new TextBox(),		/// MassSpread
					new ComboBox(),		/// MassMethod
#endif
					new TextBox(),		/// Time_Pump2StartV
					new TextBox(),		/// Time_BeforeFlow
					new TextBox(),		/// Time_Flow2Mass
					new TextBox(),		/// Time_Stop2Mass
				};

			((ComboBox)parametersEditors[(int)ParametersClmn.PumpPower]).Items.Add("0");
			((ComboBox)parametersEditors[(int)ParametersClmn.PumpPower]).Items.Add("30");
			((ComboBox)parametersEditors[(int)ParametersClmn.PumpPower]).Items.Add("40");
			((ComboBox)parametersEditors[(int)ParametersClmn.PumpPower]).Items.Add("50");
			((ComboBox)parametersEditors[(int)ParametersClmn.PumpPower]).Items.Add("60");
			((ComboBox)parametersEditors[(int)ParametersClmn.PumpPower]).Items.Add("70");
			((ComboBox)parametersEditors[(int)ParametersClmn.PumpPower]).Items.Add("75");
			((ComboBox)parametersEditors[(int)ParametersClmn.PumpPower]).Items.Add("80");
			((ComboBox)parametersEditors[(int)ParametersClmn.PumpPower]).Items.Add("85");
			((ComboBox)parametersEditors[(int)ParametersClmn.PumpPower]).Items.Add("90");
			((ComboBox)parametersEditors[(int)ParametersClmn.PumpPower]).Items.Add("92");
			((ComboBox)parametersEditors[(int)ParametersClmn.PumpPower]).Items.Add("94");
			((ComboBox)parametersEditors[(int)ParametersClmn.PumpPower]).Items.Add("96");
			((ComboBox)parametersEditors[(int)ParametersClmn.PumpPower]).Items.Add("98");
			((ComboBox)parametersEditors[(int)ParametersClmn.PumpPower]).Items.Add("100");
#if STABLE_MASS_EXTRAS
			for (MassMethod mm = 0; mm < MassMethod.Count; mm++)
			{
				((ComboBox)parametersEditors[(int)ParametersClmn.MassMethod]).Items.Add(mm.ToDescription());
			}
#endif
			foreach (var ctrl in parametersEditors)
			{
				parametersTabPage.Controls.Add(ctrl);
			}
		}

        void RefreshParametersTab()
        {
            parametersListViewEx.Items.Clear();
            foreach (var test in LoadedProcedure.Tests) AddToParametersTab(test);

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

        void AddToParametersTab(Test test)
        {
			///
			/// Parameters item with subitems
			/// 
            ListViewItem lvi = new ListViewItem(test.Name);	/// Name
            lvi.Tag = test;
            lvi.SubItems.Add((test.Part == 0) ? "-" : test.Part.ToString());  ///
			lvi.SubItems.Add(test.PumpPower.ToString("F1"));
            lvi.SubItems.Add((test.MassRepeats < 4 ? 5 : test.MassRepeats).ToString());
#if STABLE_MASS_EXTRAS
			lvi.SubItems.Add(test.MassSpread.ToString("F4"));
			lvi.SubItems.Add(test.MassMethod.ToDescription());
#endif
			lvi.SubItems.Add(test.TimePump2StartV.ToString());
			lvi.SubItems.Add(test.TimeBeforeFlow.ToString());
			lvi.SubItems.Add(test.TimeFlow2Mass.ToString());
			lvi.SubItems.Add(test.TimeStop2Mass.ToString());

			parametersListViewEx.Items.Add(lvi);
		}

		void UpdateFromParametersTab()
		{
			for (int i = 0; i < parametersListViewEx.Items.Count; i++)
			{
				ListViewItem lvi = parametersListViewEx.Items[i];
				Test entity = (Test)lvi.Tag;

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

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

				float powerPct;
				if (Utils.TryParseUFloat(lvi.SubItems[(int)ParametersClmn.PumpPower].Text, out powerPct) && powerPct >= 0 && powerPct <= 100.0f)
				{
					entity.PumpPower = powerPct;
				}

				entity.MassRepeats = int.Parse(lvi.SubItems[(int)ParametersClmn.MassRepeats].Text);

#if STABLE_MASS_EXTRAS
				float massSpread;
                if (Utils.TryParseUFloat(lvi.SubItems[(int)ParametersClmn.MassSpread].Text, out massSpread) && massSpread >= 0)
                {
                    entity.MassSpread = massSpread;
                }

				for (MassMethod mm = 0; mm < MassMethod.Count; mm++)
				{
					if (mm.ToDescription().Equals(lvi.SubItems[(int)ParametersClmn.MassMethod].Text)) entity.MassMethod = mm;
				}
#endif
				int itmp;
				if (int.TryParse(lvi.SubItems[(int)ParametersClmn.Time_Pump2StartV].Text, out itmp)) entity.TimePump2StartV = itmp;
				if (int.TryParse(lvi.SubItems[(int)ParametersClmn.Time_BeforeFlow].Text, out itmp)) entity.TimeBeforeFlow = itmp;
				if (int.TryParse(lvi.SubItems[(int)ParametersClmn.Time_Flow2Mass].Text, out itmp)) entity.TimeFlow2Mass = itmp;
				if (int.TryParse(lvi.SubItems[(int)ParametersClmn.Time_Stop2Mass].Text, out itmp)) entity.TimeStop2Mass = itmp;
			}
		}

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

            ProcessClmn[] protectedColumns = new ProcessClmn[] { ProcessClmn.Name };
            if (((e.Item.Tag as Test).Profile >= TestProfile.Protected) && protectedColumns.Contains<ProcessClmn>((ProcessClmn)e.SubItem)) return;

            parametersListViewEx.StartEditing(parametersEditors[e.SubItem], e.Item, e.SubItem);
        }

        void parametersListViewEx_SubItemRightClicked(object sender, SubItemEventArgs e)
        {
            if (!unlocked || e.SubItem >= (int)ParametersClmn.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 parametersListViewEx.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 parametersListViewEx_SubItemEndEditing(object sender, SubItemEndEditingEventArgs e)
        {
            if (e.SubItem == (int)ParametersClmn.Name)
            {
                if (!Utils.IsGoodFName(e.DisplayText))
                {
                    e.DisplayText = e.Item.SubItems[e.SubItem].Text;
                    e.Cancel = true;
                    return;								/// NOK
                }
            }

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

            float powerPct;
            if ((e.SubItem == (int)ParametersClmn.PumpPower) &&
                (!Utils.TryParseUFloat(e.DisplayText, out powerPct) || powerPct < 0 || powerPct > 100.0f))
            {
                e.DisplayText = e.Item.SubItems[e.SubItem].Text;
                e.Cancel = true;
            }

            int itmp;
            if ((e.SubItem == (int)ParametersClmn.Time_Pump2StartV) &&
                (!int.TryParse(e.DisplayText, out itmp) || itmp < 0 || itmp > 300))
            {
                e.DisplayText = e.Item.SubItems[e.SubItem].Text;
                e.Cancel = true;
            }
            if ((e.SubItem == (int)ParametersClmn.Time_BeforeFlow) &&
                (!int.TryParse(e.DisplayText, out itmp) || itmp < 0 || itmp > 300))
            {
                e.DisplayText = e.Item.SubItems[e.SubItem].Text;
                e.Cancel = true;
            }
            if ((e.SubItem == (int)ParametersClmn.Time_Flow2Mass) &&
                (!int.TryParse(e.DisplayText, out itmp) || itmp < 0 || itmp > 300))
            {
                e.DisplayText = e.Item.SubItems[e.SubItem].Text;
                e.Cancel = true;
            }
            if ((e.SubItem == (int)ParametersClmn.Time_Stop2Mass) &&
                (!int.TryParse(e.DisplayText, out itmp) || itmp < 0 || itmp > 300))
            {
                e.DisplayText = e.Item.SubItems[e.SubItem].Text;
                e.Cancel = true;
            }
            if ((e.SubItem == (int)ParametersClmn.MassRepeats) &&
                (!int.TryParse(e.DisplayText, out itmp) || itmp < 4 || itmp > 100))
            {
                e.DisplayText = e.Item.SubItems[e.SubItem].Text;
                e.Cancel = true;
            }

#if STABLE_MASS_EXTRAS
			if ((e.SubItem == (int)ParametersClmn.MassSpread) && !Utils.TryParseUFloat(e.DisplayText, out powerPct))
			{
				e.DisplayText = e.Item.SubItems[e.SubItem].Text;
				e.Cancel = true;
			}

			if (e.SubItem == (int)ParametersClmn.MassMethod)
			{
				bool mmIsOk = false;
				for (MassMethod mm = 0; mm < MassMethod.Count; mm++)
				{
					if (mm.ToDescription().Equals(e.DisplayText))
					{
						mmIsOk = true;
						break;
					}
				}
				if (!mmIsOk)
				{
					e.DisplayText = e.Item.SubItems[e.SubItem].Text;
					e.Cancel = true;
				}
			}
#endif
        }

        #endregion


		void RefreshMetrology12AndProcessTabs()
		{
            RefreshMetrology1Tab();
            RefreshMetrology2Tab();
            RefreshProcessTab();
            RefreshParametersTab();
        }

        void RefreshOtherTabs()
        {
            foreach (var ctrl in testParamsCtrls) ctrl.RedrawAll();
            foreach (var ctrl in procedureParamsCtrls) ctrl.RedrawAll();
        }


		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;
			watermetersTextBox.Enabled = true;
            protectedCheckBox.Enabled = Users.CurrentUser.IsMemberOf(GID.Metrologists);
            mustBeCompleteCheckBox.Enabled = true;
			manualControlDisabledCheckBox.Enabled = true;
			dataEntryComboBox.Enabled = true;
            metersKindRadioButton1.Enabled = true;
            metersKindRadioButton2.Enabled = true;
            altProcNameTextBox.Enabled = true;
            altProcPeriodTextBox.Enabled = true;
#if HEAT_METERS
            metersKindRadioButton3.Enabled = true;
#endif
            printer1ComboBox.Enabled = true;
            printer2ComboBox.Enabled = true;
            fileWriter1ComboBox.Enabled = true;
            fileWriter2ComboBox.Enabled = true;
            fileWriter3ComboBox.Enabled = true;
            fileWriter4ComboBox.Enabled = true;
            fileWriter5ComboBox.Enabled = true;
            eventTrigger1ComboBox.Enabled = true;
            eventTrigger2ComboBox.Enabled = true;
            eventTrigger3ComboBox.Enabled = true;
            transitionStartComboBox.Enabled = true;
			transitionEndComboBox.Enabled = true;
			notesTextBox.Enabled = true;

            ListViewEx listViewEx;

			switch (selectedTab)
			{
				case ProcedureTabs.Metrology1:
					listViewEx = metrology1ListViewEx;
					break;
				case ProcedureTabs.Metrology2:
					listViewEx = metrology2ListViewEx;
					break;
				case ProcedureTabs.Process:
					listViewEx = processListViewEx;
					break;
				case ProcedureTabs.Parameters:
					listViewEx = parametersListViewEx;
					break;
				default:
					return;
			}

			if (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 ProcedureTabs.General:     UpdateFromGeneralTab();		break;
                case ProcedureTabs.Metrology1:  UpdateFromMetrology1Tab();	break;
                case ProcedureTabs.Metrology2:  UpdateFromMetrology2Tab();	break;
                case ProcedureTabs.Process:     UpdateFromProcessTab();		break;
				case ProcedureTabs.Parameters:	UpdateFromParametersTab();	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(LoadedProcedure.Name.ToLower()))
			{
				MessageBox.Show(string.Format("There is already a procedure named '{0}'.{1}Choose another name please.", LoadedProcedure.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 ProcedureTabs
		{
			General,
			History,
			Metrology1,
			Metrology2,
			Process,
			Parameters,
		}

        ProcedureTabs selectedTab = ProcedureTabs.General;

        private void tabControl_SelectedIndexChanged(object sender, EventArgs e)
        {
            switch (selectedTab)
            {
                case ProcedureTabs.General:
                    UpdateFromGeneralTab();
                    break;
                case ProcedureTabs.Metrology1:
                    UpdateFromMetrology1Tab();
                    break;
                case ProcedureTabs.Metrology2:
                    UpdateFromMetrology2Tab();
                    break;
                case ProcedureTabs.Process:
                    UpdateFromProcessTab();
                    break;
				case ProcedureTabs.Parameters:
                    UpdateFromParametersTab();
                    break;
            }

            selectedTab = (ProcedureTabs)tabControl.SelectedIndex;
            bool isMetr12ProcOrParams = selectedTab == ProcedureTabs.Metrology1 ||
									    selectedTab == ProcedureTabs.Metrology2 ||
									    selectedTab == ProcedureTabs.Process    ||
									    selectedTab == ProcedureTabs.Parameters;

            if (isMetr12ProcOrParams)
            {
                sharedButtons.EnableButtons(SharedButtons.Buttons.Add);
            }
            else
            {
                sharedButtons.DisableButtons(SharedButtons.Buttons.Add);
            }
 
			//bool removeBtnEnabled = (selectedTab != ProcedureTabs.General &&
			//                        selectedTab != ProcedureTabs.History &&
			//                        selectedTab != ProcedureTabs.Calibration);

			sharedButtons.DisableButtons(SharedButtons.Buttons.Remove);

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

                case ProcedureTabs.Metrology1:
                    RefreshMetrology1Tab();
                    lv = metrology1ListViewEx;                  /// ListVIewEx for test selection
                    break;

                case ProcedureTabs.Metrology2:
                    RefreshMetrology2Tab();
                    lv = metrology2ListViewEx;                  /// ListVIewEx for test selection
                    break;

                case ProcedureTabs.Process:
                    RefreshProcessTab();
                    lv = processListViewEx;                     /// ListVIewEx for test selection
                    break;

                case ProcedureTabs.Parameters:
                    RefreshParametersTab();
                    lv = parametersListViewEx;                  /// ListVIewEx for test selection
                    break;

                default:
                    object ctrl = tabControl.SelectedTab.Tag;
                    if (ctrl is TestParamsCtrl)
                    {
                        (ctrl as TestParamsCtrl).RedrawAll();
                        lv = (ctrl as TestParamsCtrl).LVEx;     /// ListVIewEx for test selection
                    }
                    else if (ctrl is ProcedureParamsCtrl)
                    {
                        (ctrl as ProcedureParamsCtrl).RedrawAll();
                    }
    				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 ProcedureTabs.Metrology1:	listViewEx = metrology1ListViewEx; break;
				case ProcedureTabs.Metrology2:	listViewEx = metrology2ListViewEx; break;
				case ProcedureTabs.Process:		listViewEx = processListViewEx;    break;
				case ProcedureTabs.Parameters:	listViewEx = parametersListViewEx; break;
				default:                        return;
			}

			/// Find an unused test name
			string newName;
			for (int nameId = 1; true; nameId++)
			{
				newName = Strings.New_test_name + nameId.ToString();
				bool notUsed = true;
				foreach (var t in LoadedProcedure.Tests) if (t.Name.Equals(newName)) notUsed = false;
				if (notUsed) break;
			}

            /// Find possible selector values.
            /// Empty string or null (which is permitted) is not part of list 'selectorValues'
            IList<string> selectorValues = new List<string>();
            foreach (var fp in feedingPaths)
            {
                if (!string.IsNullOrEmpty(fp.Selector) && !selectorValues.Contains(fp.Selector)) selectorValues.Add(fp.Selector);
            }
            foreach (var bp in benchPaths)
            {
                if (!string.IsNullOrEmpty(bp.Selector) && !selectorValues.Contains(bp.Selector)) selectorValues.Add(bp.Selector);
            }
            foreach (var op in outputPaths)
            {
                if (!string.IsNullOrEmpty(op.Selector) && !selectorValues.Contains(op.Selector)) selectorValues.Add(op.Selector);
            }

			/// Add a test
			Test test = new Test(newName, listViewEx.Items.Count, LoadedProcedure);

            IBenchInfo benchInfo = TBF.Rig.Sequences.ProcessData.BenchInfo;
            test.VolumeUnit = (benchInfo != null) ? benchInfo.VolumeUnit : Unit.l;
            test.FlowUnit   = (benchInfo != null) ? benchInfo.FlowUnit   : Unit.m3ph;
            test.MassUnit   = (benchInfo != null) ? benchInfo.MassUnit   : Unit.kg;
            test.TempUnit   = (benchInfo != null) ? benchInfo.TempUnit   : Unit.C;
            test.PressUnit  = (benchInfo != null) ? benchInfo.PressUnit  : Unit.bar;
            test.LengthUnit = (benchInfo != null) ? benchInfo.LengthUnit : Unit.mm;

            TestWizard.RoiData roiData = new TestWizard.RoiData();

			/// Run a create new test wizard
			TestWizard.MethodSelection methodDlg = new TestWizard.MethodSelection(true, false, test, TestMethods);
            TestWizard.FlowSelection flowDlg = new TestWizard.FlowSelection(false, false, test, metersPaths, selectorValues);
			TestWizard.VolumeAndErrorSelection volumeDlg = new TestWizard.VolumeAndErrorSelection(false, true, test);
			TestWizard.PressureSelection pressureDlg = new TestWizard.PressureSelection(false, true, test);
			TestWizard.HeatMetersSelection heatMetersDlg = new TestWizard.HeatMetersSelection(false, false, test);
			TestWizard.Roi1 roi1Dlg = new TestWizard.Roi1(false, false, roiData);
			TestWizard.Roi2 roi2Dlg = new TestWizard.Roi2(false, false, roiData);
			TestWizard.Roi3 roi3Dlg = new TestWizard.Roi3(false, false, roiData);
			//test.

		methodLabel:

			switch (methodDlg.ShowDialog())
			{
				case DialogResult.Cancel: return;
			}

			ITestMethod selectedMethod = TestMethods.FirstOrDefault<ITestMethod>(x => x.Name.Equals(test.Method));

			if (selectedMethod is TBF.Rig.TestMethods.OuterLoop.Start.Component
				 || selectedMethod is TBF.Rig.TestMethods.OuterLoop.End.Component)
			{
				test.Publish = (sbyte)Publish.Never;
				test.DoEvaluate = false;
				goto done;
			}
			if (selectedMethod is Rig.TestMethods.PMaxTest.TestMethod) goto pressure_label;
			if (selectedMethod is Rig.TestMethods.LeakTest.TestMethod) goto pressure_label;
#if HEAT_METERS
			if (selectedMethod.CanTest(MetersKind.HeatMeter)) goto heat_meters_label;
#endif
			if (!(selectedMethod is Rig.TestMethods.RoiDetection.RoiDetection)) goto flowLabel;

		roi_detection_label_1:
			switch (roi1Dlg.ShowDialog())
			{
				case DialogResult.Cancel: return;
				case DialogResult.Retry: goto methodLabel;
			}

		roi_detection_label_2:
		    switch (roi2Dlg.ShowDialog())
			{
				case DialogResult.Cancel: return;
				case DialogResult.Retry: goto roi_detection_label_1;
			}

			switch (roi3Dlg.ShowDialog())
			{
				case DialogResult.Cancel: return;
				case DialogResult.Retry: goto roi_detection_label_2;
			}

            /// Pre-calculate additional data and flow for ROI detection
            roiData.Calculate();
            test.Qfrom = (float)(roiData.Q * 0.95);
            test.Qto = (float)(roiData.Q * 1.05);

		flowLabel:
			switch (flowDlg.ShowDialog())
			{
				case DialogResult.Cancel: return;
				case DialogResult.Retry: goto methodLabel;
			}

			if (selectedMethod is Rig.TestMethods.RoiDetection.RoiDetection)
			{
				AddProcedureParamsToRoiComponents(LoadedProcedure, test.MetersPath, roiData);
				goto select_paths;
			}

			switch (volumeDlg.ShowDialog())
			{
				case DialogResult.Cancel: return;
				case DialogResult.Retry: goto flowLabel;
			}

		select_paths:

            string selector = flowDlg.Selector;

			/// Depending on the chosen Q select the paths
			float Qaver = (test.Qfrom + test.Qto) / 2.0f;
			foreach (var path in feedingPaths)
			{
                if ((path.Qfrom <= Qaver) && (Qaver <= path.Qto) &&
                    (string.IsNullOrEmpty(selector) || string.IsNullOrEmpty(path.Selector) || path.Selector == selector))
				{
					test.FeedingPath = path.Name;
					break;
				}
			}
			foreach (var path in benchPaths)
			{
                if ((path.Qfrom <= Qaver) && (Qaver <= path.Qto) &&
                    (string.IsNullOrEmpty(selector) || string.IsNullOrEmpty(path.Selector) || path.Selector == selector))
				{
					test.BenchPath = path.Name;
					break;
				}
			}
			foreach (var path in outputPaths)
			{
                if ((path.Qfrom <= Qaver) && (Qaver <= path.Qto) &&
                    (string.IsNullOrEmpty(selector) || string.IsNullOrEmpty(path.Selector) || path.Selector == selector))
				{
					test.OutputPath = path.Name;
					break;
				}
			}

			goto done;
		
#if HEAT_METERS
		heat_meters_label:

			DialogResult dr = heatMetersDlg.ShowDialog();
			switch (dr)
			{
				case DialogResult.Cancel: return;
				case DialogResult.Retry: goto methodLabel;
			}
			goto flowLabel;
#endif

		pressure_label:

			switch (pressureDlg.ShowDialog())
			{
				case DialogResult.Cancel: return;
				case DialogResult.Retry: goto methodLabel;
			}

		done:

			LoadedProcedure.Tests.Add(test);
            ///
			AddToMetrology1Tab(test);
			AddToMetrology2Tab(test);
			AddToProcessTab(test);
			AddToParametersTab(test);
			foreach (var ctrl in testParamsCtrls) ctrl.AddOne(test);

            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 ProcedureTabs.Metrology1:
					UpdateFromMetrology1Tab();
					listViewEx = metrology1ListViewEx;
					break;

                case ProcedureTabs.Metrology2:
					UpdateFromMetrology2Tab();
					listViewEx = metrology2ListViewEx;
					break;

                case ProcedureTabs.Process:
					UpdateFromProcessTab();
					listViewEx = processListViewEx;
					break;

				case ProcedureTabs.Parameters:
					UpdateFromParametersTab();
					listViewEx = parametersListViewEx;
					break;

				default: return;
            }

			/// Check the selected index validity
			if (listViewEx.SelectedItems.Count != 1) return;
			int removeItemNr = listViewEx.SelectedIndices[0];

            if (LoadedProcedure.Tests[removeItemNr].Profile >= TestProfile.Protected)
            {
                MessageBox.Show("This test is protected and cannot be deleted.");
                return;
            }

			/// Remove the selected test
			Test toBeDeleted = LoadedProcedure.Tests[removeItemNr];
			LoadedProcedure.Tests.Remove(toBeDeleted);
			for (int i = removeItemNr; i < LoadedProcedure.Tests.Count; i++) LoadedProcedure.Tests[i].ItemNr--;

			RefreshMetrology12AndProcessTabs();
			foreach (var ctrl in testParamsCtrls) ctrl.RedrawAll();

			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 ProcedureTabs.Metrology1:
					UpdateFromMetrology1Tab();
					listViewEx = metrology1ListViewEx;
					break;

				case ProcedureTabs.Metrology2:
					UpdateFromMetrology2Tab();
					listViewEx = metrology2ListViewEx;
					break;

				case ProcedureTabs.Process:
					UpdateFromProcessTab();
					listViewEx = processListViewEx;
					break;

				case ProcedureTabs.Parameters:
					UpdateFromParametersTab();
					listViewEx = parametersListViewEx;
					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)
			Test test1 = LoadedProcedure.Tests[ix - 1];
			Test test2 = LoadedProcedure.Tests[ix];
			test1.ItemNr++;
			test2.ItemNr--;
			LoadedProcedure.Tests.RemoveAt(ix);
			LoadedProcedure.Tests.Insert(ix - 1, test2);

            if (SelectedTestIx >= 1) SelectedTestIx--;

			RefreshMetrology12AndProcessTabs();

			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 ProcedureTabs.Metrology1:
					UpdateFromMetrology1Tab();
					listViewEx = metrology1ListViewEx;
					break;

				case ProcedureTabs.Metrology2:
					UpdateFromMetrology2Tab();
					listViewEx = metrology2ListViewEx;
					break;

				case ProcedureTabs.Process:
					UpdateFromProcessTab();
					listViewEx = processListViewEx;
					break;

				case ProcedureTabs.Parameters:
					UpdateFromParametersTab();
					listViewEx = parametersListViewEx;
					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)
			Test test1 = LoadedProcedure.Tests[ix];
			Test test2 = LoadedProcedure.Tests[ix + 1];
			test1.ItemNr++;
			test2.ItemNr--;
			LoadedProcedure.Tests.RemoveAt(ix + 1);
			LoadedProcedure.Tests.Insert(ix, test2);

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

			RefreshMetrology12AndProcessTabs();

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

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

            switch (selectedTab)
            {
                case ProcedureTabs.Metrology1:
                    UpdateFromMetrology1Tab();
                    listViewEx = metrology1ListViewEx;
                    break;

                case ProcedureTabs.Metrology2:
                    UpdateFromMetrology2Tab();
                    listViewEx = metrology2ListViewEx;
                    break;

                case ProcedureTabs.Process:
                    UpdateFromProcessTab();
                    listViewEx = processListViewEx;
                    break;

                case ProcedureTabs.Parameters:
                    UpdateFromParametersTab();
                    listViewEx = parametersListViewEx;
                    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;

            Test selectedTest = LoadedProcedure.Tests[ix];

            /// Add a copy of the selected test
            Test newTest = selectedTest.Clone();
            newTest.ItemNr = listViewEx.Items.Count;
            newTest.Name = selectedTest.Name + " copy";

            LoadedProcedure.Tests.Add(newTest);
            ///
            AddToMetrology1Tab(newTest);
            AddToMetrology2Tab(newTest);
            AddToProcessTab(newTest);
            AddToParametersTab(newTest);
            foreach (var ctrl in testParamsCtrls) ctrl.AddOne(newTest);

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

        #endregion

		private void metrology1ListViewEx_SelectedIndexChanged(object sender, EventArgs e) { SelectedIndexChanged(sender, e); }
		private void metrology2ListViewEx_SelectedIndexChanged(object sender, EventArgs e) { SelectedIndexChanged(sender, e); }
		private void processListViewEx_SelectedIndexChanged(object sender, EventArgs e)    { SelectedIndexChanged(sender, e); }
        private void parametersListViewEx_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);
            }
        }

		/// <summary>
		/// Adds ROI data/process data prepared by the wizard to ROI-components in the selected sensors path
		/// </summary>
		/// <param name="procedure">Loaded procedure</param>
		/// <param name="sensorsPath">Selected sensors path</param>
		/// <param name="roiData">ROI data</param>
		void AddProcedureParamsToRoiComponents(Procedure procedure, string sensorsPathName, TestWizard.RoiData roiData)
		{
			IList<IComponent> cmpntsInSensPath = new List<IComponent>();

			MetersPath sensorsPath = metersPaths.FirstOrDefault<MetersPath>(x => (x.Name == sensorsPathName));
			if (sensorsPath != null)
			{
				for (int i = 0; i < TBF.Data.WMsCount; i++)
				{
					IComponent sensor = TbfComponents.FirstOrDefault<IComponent>(x => (x.Cfg.Name.Equals(sensorsPath.GetSensor(i))));
					cmpntsInSensPath.Add(sensor);
				}
			}

			foreach (var cmpnt in cmpntsInSensPath)
			{
				if (cmpnt != null && (cmpnt.Cfg is Rig.Network.Camera.Roi.RoiCfg))
				{
					Rig.Network.Camera.Roi.ProcedureParams roiParams =
						new Rig.Network.Camera.Roi.ProcedureParams()
						{
							PulsesPerLtr = (float)roiData.PulsesPerLiter,
							DetectionImagesCount = roiData.N,
							DetectionPeriod1 = roiData.P1,
							DetectionPeriod2 = roiData.P2,
							RoiParams = roiData.GetRoiParams()
						};
					roiParams.FromDbEntity(cmpnt.Name, LoadedProcedure);
				}
			}
		}

        /// <summary>
        /// Queries an Oracle database and loads ... array/list
        /// </summary>
        private void iPerlWizardButton_Click(object sender, EventArgs e)
        {
            ListViewEx listViewEx = null;
            switch (selectedTab)
            {
                case ProcedureTabs.General:
                    UpdateFromGeneralTab();
                    break;

                case ProcedureTabs.History:
                    UpdateFromHistoryTab();
                    break;

                case ProcedureTabs.Metrology1:
                    listViewEx = metrology1ListViewEx;
                    UpdateFromMetrology1Tab();
                    break;

                case ProcedureTabs.Metrology2:
                    listViewEx = metrology2ListViewEx;
                    UpdateFromMetrology2Tab();
                    break;

                case ProcedureTabs.Process:
                    listViewEx = processListViewEx;
                    UpdateFromProcessTab();
                    break;

                case ProcedureTabs.Parameters:
                    listViewEx = parametersListViewEx;
                    UpdateFromParametersTab();
                    break;

                default:
                    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));
                    break;
            }

            using (NHibernate.ISession session = TBF.DB.CreateSession(DBKind.Config))
			{
                IList<Test> testsToBeUpdated = new List<Test>();

                foreach (var test in LoadedProcedure.Tests)
                {
                    foreach (var testMethod in TestMethods)
                    {
                        if (testMethod.Name == test.Method && testMethod.ClassName == "TestMethods.Dummy")
                        {
                            testsToBeUpdated.Add(test);
                            break;
                        }
                    }
                }

                if (testsToBeUpdated.Count == 0)
                {
                    MessageBox.Show("There are no tests to be updated");
                    return;
                }

                /// Run a wizard
                TestWizard.OracleWZTypSelection oracleDlg = new TestWizard.OracleWZTypSelection(LoadedProcedure, TestMethods);
                TestWizard.ConfirmUpdatingTests confirmationDlg = new TestWizard.ConfirmUpdatingTests(LoadedProcedure, TestMethods);
                Form[] forms = new Form[] { oracleDlg, confirmationDlg };

                int step = 0;    /// 1st step
                while ((step >= 0) && (step < forms.Length))
                {
                    switch (forms[step].ShowDialog())
                    {
                        case DialogResult.OK:
                            /// Next
                            step++;
                            break;

                        case DialogResult.Retry:
                            /// Back
                            step--;
                            break;

                        case DialogResult.Cancel:
                        default:
                            return;
                    }
                }

                if (step == forms.Length)
                {
                    ///
                    /// Update tests
                    ///
                    foreach (var ti in oracleDlg.SelectedTestInfos)
                    {
                        foreach (var test in testsToBeUpdated)
                        {
                            if (ti.TestName == test.Name)
                            {
                                ///
                                /// Update this test with information obtained from Oracle
                                ///
                                double qfrom, qto;
                                switch (ti.Range)
                                {
                                    case Results.Output.Range.R90_100:
                                        qfrom = 0.9 * ti.Flow;
                                        qto = ti.Flow;
                                        break;

                                    case Results.Output.Range.R95_105:
                                        qfrom = 0.95 * ti.Flow;
                                        qto = 1.05 * ti.Flow;
                                        break;

                                    case Results.Output.Range.R100_110:
                                        qfrom = ti.Flow;
                                        qto = 1.1 * ti.Flow;
                                        break;

                                    default:
                                        qfrom = qto = ti.Flow;
                                        break;
                                }

                                double volume = ti.TestTime * (qfrom + qto) / 7.2;

                                test.Qfrom = (float)qfrom;
                                test.Qto = (float)qto;
                                test.TestTime = (float)ti.TestTime;
                                test.Volume = (float)volume;
                                test.ErrLimLo = (float)(ti.ErrLimLoFromDB - ti.Uncertainty);
                                test.ErrLimHi = (float)(ti.ErrLimHiFromDB + ti.Uncertainty);
                                test.Uncertainty = (float)ti.Uncertainty;
                                test.Method = ti.TestMethod;
                            }
                        }
                    }

                    ///
                    /// Update iPerls and water meters
                    ///
                    foreach (var ppCtrl in procedureParamsCtrls)
                    {
                        foreach (var pp in ppCtrl.CmpntsParams)
                        {
                            var ihpp = pp as TBF.Rig.TestMethods.iPerlCommunication.iPerlHead.ProcParams;
                            if (ihpp != null)
                            {
                                ihpp.WMType_ID = oracleDlg.WMTypeId;
                                ihpp.MeterType = oracleDlg.MeterType;
                            }

                            var wmpp = pp as TBF.Rig.WaterMeters.WaterMeter.ProcParams;
                            if (wmpp != null)
                            {
                                wmpp.MetrologicalClass = oracleDlg.MetrolKlasse;
                                wmpp.ApprovalInfo = oracleDlg.Zulasszeichen;
                                wmpp.Qn = (float)oracleDlg.Q3;

                                switch (oracleDlg.MeterType)
                                {
                                    case MeterType.DN15:       wmpp.DN = 15.0F; break;
                                    case MeterType.DN20:       wmpp.DN = 20.0F; break;
                                    case MeterType.DN25:       wmpp.DN = 25.0F; break;
                                    case MeterType.DN25_Q3_10: wmpp.DN = 25.0F; break;
                                    case MeterType.DN32:       wmpp.DN = 32.0F; break;
                                    case MeterType.DN40:       wmpp.DN = 40.0F; break;
                                    default:
                                    case MeterType.AutoDetect: wmpp.DN = 0; break;
                                }
                            }
                        }
                    }
                    
                    RefreshMetrology12AndProcessTabs();
                    RefreshOtherTabs();

                    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 historyListViewEx_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            if (historyListViewEx.SelectedIndices.Count != 1) return;
            ListViewItem lvi = historyListViewEx.SelectedItems[0];

            if (lvi.Tag is Procedure)
            {
                (new ProcedureDlg(lvi.Tag as Procedure, new List<string>(), ProcedureDlg.Mode.PermanentlyLocked, sharedButtons.ParentForm)).ShowDialog();
            }
        }

        private void dataEntryComboBox_SelectedIndexChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void transitionStartComboBox_SelectedIndexChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void transitionEndComboBox_SelectedIndexChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void printer1ComboBox_SelectedIndexChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void printer2ComboBox_SelectedIndexChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void fileWriter1ComboBox_SelectedIndexChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void fileWriter2ComboBox_SelectedIndexChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void fileWriter3ComboBox_SelectedIndexChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void fileWriter4ComboBox_SelectedIndexChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void fileWriter5ComboBox_SelectedIndexChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void eventTrigger1ComboBox_SelectedIndexChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void eventTrigger2ComboBox_SelectedIndexChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void eventTrigger3ComboBox_SelectedIndexChanged(object sender, EventArgs e) { ShowNokComponents(); }

        private void dataEntryComboBox_TextChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void transitionStartComboBox_TextChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void transitionEndComboBox_TextChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void printer1ComboBox_TextChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void printer2ComboBox_TextChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void fileWriter1ComboBox_TextChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void fileWriter2ComboBox_TextChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void fileWriter3ComboBox_TextChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void fileWriter4ComboBox_TextChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void fileWriter5ComboBox_TextChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void eventTrigger1ComboBox_TextChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void eventTrigger2ComboBox_TextChanged(object sender, EventArgs e) { ShowNokComponents(); }
        private void eventTrigger3ComboBox_TextChanged(object sender, EventArgs e) { ShowNokComponents(); }

        void ShowNokComponents()
        {
            dataEntryNokLabel.Visible = !dataEntryComboBox.Items.Contains(dataEntryComboBox.Text);
            transitionStartNokLabel.Visible = !transitionStartComboBox.Items.Contains(transitionStartComboBox.Text);
            transitionEndNokLabel.Visible = !transitionEndComboBox.Items.Contains(transitionEndComboBox.Text);
            printer1NokLabel.Visible = !printer1ComboBox.Items.Contains(printer1ComboBox.Text);
            printer2NokLabel.Visible = !printer2ComboBox.Items.Contains(printer2ComboBox.Text);
            fileWriter1NokLabel.Visible = !fileWriter1ComboBox.Items.Contains(fileWriter1ComboBox.Text);
            fileWriter2NokLabel.Visible = !fileWriter2ComboBox.Items.Contains(fileWriter2ComboBox.Text);
            fileWriter3NokLabel.Visible = !fileWriter3ComboBox.Items.Contains(fileWriter3ComboBox.Text);
            fileWriter4NokLabel.Visible = !fileWriter4ComboBox.Items.Contains(fileWriter4ComboBox.Text);
            fileWriter5NokLabel.Visible = !fileWriter5ComboBox.Items.Contains(fileWriter5ComboBox.Text);
            eventTrigger1NokLabel.Visible = !eventTrigger1ComboBox.Items.Contains(eventTrigger1ComboBox.Text);
            eventTrigger2NokLabel.Visible = !eventTrigger2ComboBox.Items.Contains(eventTrigger2ComboBox.Text);
            eventTrigger3NokLabel.Visible = !eventTrigger3ComboBox.Items.Contains(eventTrigger3ComboBox.Text);
        }
    }
}