///
/// Copyright (c) 2013-2017 Sensus Metering Systems
///
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using log4net;

using TBF.BenchControl.Generic;
using TBF.BenchControl.GenericDevices;
using Config.Entities;
using TBF.Resources;
using TBF.UiControls;

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

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

		/// <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;

		/// Auxiliary public lists used also by user controls in tab pages
		public IList<BenchControl.Generic.IComponent> TbfComponents;
		public IList<IValve> Valves;
		public IList<IRegulValve> RegulValves;
		public IList<ITestMethod> TestMethods;
		public IList<ITestMethod> UsedTestMethods;
		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<ProcedureParamsCtrl> procedureParamsCtrls;

		bool unlocked;

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

			InitializeComponent();

			/// SharedDlgButtons configuration
			sharedButtons.RequiredGroupMembership = Users.Grp.GID.TestingSpecialists;
			sharedButtons.OptionalButtons = SharedButtons.Buttons.Add | SharedButtons.Buttons.Remove |
											   SharedButtons.Buttons.Up | SharedButtons.Buttons.Down;
			sharedButtons.Unlocked += Unlocked;
			sharedButtons.OKClicked += okButton_Click;
			sharedButtons.CancelClicked += cancelButton_Click;
			sharedButtons.AddClicked += addButton_Click;
			sharedButtons.RemoveClicked += removeButton_Click;
			sharedButtons.UpClicked += upButton_Click;
			sharedButtons.DownClicked += downButton_Click;

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

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

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

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

		public ProcedureDlg(Config.Entities.Procedure procedure)
			: this()
		{
			if (procedure == null) throw new ArgumentNullException("procedure");

			LoadedProcedure = procedure;

			/// Prepare a list of components and a list of all valves in the test bench
			using (NHibernate.ISession session = Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config))
			{
				TbfComponents = BenchControl.TbfComponents.LoadComponentsFromDB(session);
				Valves = BenchControl.GenericDevices.ValveBase.MasterValves(TbfComponents);
				RegulValves = new List<IRegulValve>();
				TestMethods = new List<ITestMethod>();
				dataEntryComboBox.Items.Add("---");
				printer1ComboBox.Items.Add("---");
                printer2ComboBox.Items.Add("---");
                fileWriter1ComboBox.Items.Add("---");
                fileWriter2ComboBox.Items.Add("---");
                fileWriter3ComboBox.Items.Add("---");
                fileWriter4ComboBox.Items.Add("---");
                foreach (var cmpnt in TbfComponents)
				{
					if (cmpnt is IRegulValve) RegulValves.Add(cmpnt as IRegulValve);
					if (cmpnt is ITestMethod) TestMethods.Add(cmpnt as ITestMethod);
					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);
                    }
				}
			}

			/// Loads paths, this must be done before PrepareMetrology12AndProcessTabs() call
			using (NHibernate.ISession session = Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config))
			{
				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 = BenchControl.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.GetTestParams() != null)
				{
					TabPage nwTab = new TabPage(method.Cfg.Name);
					TestParamsCtrl nwCtrl = new TestParamsCtrl(this, method, true);
					testParamsCtrls.Add(nwCtrl);
					nwTab.Controls.Add(nwCtrl);
					this.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.GetTestParams() != null) && !(cmpnt is ITestMethod))
				{
					TabPage nwTab = new TabPage(cmpnt.Cfg.Name);
					TestParamsCtrl nwCtrl = new TestParamsCtrl(this, cmpnt, true);
					testParamsCtrls.Add(nwCtrl);
					nwTab.Controls.Add(nwCtrl);
					this.tabControl.TabPages.Add(nwTab);
				}
			}

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

			procedureParamsCtrls = new List<ProcedureParamsCtrl>();		/// 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);
			}

			{
				TabPage newTab = new TabPage(Strings.Water_meters);
				ProcedureParamsCtrl newCtrl = new ProcedureParamsCtrl(this, waterMeters, false);
				procedureParamsCtrls.Add(newCtrl);
				newTab.Controls.Add(newCtrl);
				this.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 < Config.Data.WMsCount; i++)
					{
						IComponent sensor = TbfComponents.FirstOrDefault<IComponent>(x => (x.Cfg.Name.Equals(usedPath.GetSensor(i))));
						cmpntsInMPath.Add(sensor);
					}

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

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

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

			if (other.Count > 0)
			{
				TabPage newTab = new TabPage(Strings.Other);
				ProcedureParamsCtrl newCtrl = new ProcedureParamsCtrl(this, other, false);
				procedureParamsCtrls.Add(newCtrl);
				newTab.Controls.Add(newCtrl);
				this.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

            TBF.LocalSettings ls = Program.LocalSettings;
            Width  = (ls.OneProcedureDlgWidth > 0)  ? ls.OneProcedureDlgWidth  : 1050;
            Height = (ls.OneProcedureDlgHeight > 0) ? ls.OneProcedureDlgHeight : 420;
            Left   = (ls.OneProcedureDlgLeft != 0)  ? ls.OneProcedureDlgLeft   : 150;
            Top    = (ls.OneProcedureDlgTop != 0)   ? ls.OneProcedureDlgTop    : 150;

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

			/// Create LisViewEx columns and edit controls for 'Metrology1', 'Metrology2' and 'Process' tabs
			PrepareMetrology12AndProcessTabs();

			/// Disable controls in General tab
			procNameTextBox.Enabled = false;
			descriptionTextBox.Enabled = false;
			watermetersTextBox.Enabled = false;
			protocolTitleTextBox.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;
			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;

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

			RefreshAllTabs();
        }

		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;
            protocolTitleLabel.Text = Strings.Protocol_title;
            dataEntryLabel.Text = Strings.Data_entry;
            transitionStartLabel.Text = Strings.Purge_Begin;
            transitionEndLabel.Text = Strings.Purge_End;
            resultsPrinterLabel.Text = Strings.Printing;
            resultsWriterLabel.Text = Strings.Saving_results;

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

        void RefreshAllTabs()
        {
            RefreshGeneralTab();
            RefreshMetrology12AndProcessTabs();
        }


		#region General

		void RefreshGeneralTab()
		{
			procNameTextBox.Text = LoadedProcedure.Name;
			Text = string.Format("{0} '{1}'", Strings.Procedure, 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;
			protocolTitleTextBox.Text = LoadedProcedure.ProtocolTitle;
            dataEntryComboBox.Text = string.IsNullOrEmpty(LoadedProcedure.DataEntry) ? "---" : LoadedProcedure.DataEntry;
			transitionStartComboBox.Text = string.IsNullOrEmpty(LoadedProcedure.TransitionStart) ? "---" : LoadedProcedure.TransitionStart;
			transitionEndComboBox.Text = string.IsNullOrEmpty(LoadedProcedure.TransitionEnd) ? "---" : LoadedProcedure.TransitionEnd;

			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 = "---";
			}
            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] : "---";
			}

            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}'", Strings.Procedure, LoadedProcedure.Name);

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

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

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

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

			if (fileWriter1ComboBox.Items.Contains(fileWriter1ComboBox.Text) &&
				fileWriter2ComboBox.Items.Contains(fileWriter2ComboBox.Text) &&
				fileWriter3ComboBox.Items.Contains(fileWriter3ComboBox.Text) &&
				fileWriter4ComboBox.Items.Contains(fileWriter4ComboBox.Text))
            {
				bool first = true;
				StringBuilder sb = new StringBuilder();
				if (!fileWriter1ComboBox.Text.Equals("---"))
				{
					sb.Append(fileWriter1ComboBox.Text);
                    first = false;
				}
				if (!fileWriter2ComboBox.Text.Equals("---"))
				{
					if (!first) sb.Append("~");
					sb.Append(fileWriter2ComboBox.Text);
                    first = false;
				}
				if (!fileWriter3ComboBox.Text.Equals("---"))
				{
					if (!first) sb.Append("~"); first = false;
					sb.Append(fileWriter3ComboBox.Text);
                    first = false;
				}
				if (!fileWriter4ComboBox.Text.Equals("---"))
				{
					if (!first) sb.Append("~");
					sb.Append(fileWriter4ComboBox.Text);
				}
				LoadedProcedure.ResultsWriter = 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 > 0) ? ls.HistoryColumnWidths[0] : 80);
			historyListViewEx.Columns.Add(Strings.Date_and_time, (ls.HistoryColumnCount > 1) ? ls.HistoryColumnWidths[1] : 120);
			historyListViewEx.Columns.Add(Strings.User, (ls.HistoryColumnCount > 2) ? ls.HistoryColumnWidths[2] : 55);
			historyListViewEx.Columns.Add(Strings.DescriptionColHdr, (ls.HistoryColumnCount > 3) ? ls.HistoryColumnWidths[3] : 300);

			RefreshHistoryTab();
		}

		void RefreshHistoryTab()
		{
			NHibernate.ISession session = Config.FluentCommon.CreateSession(Users.Entities.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.SubItems.Add(p.Revision.ToString());
						item.SubItems.Add(p.LastChgTime.ToString());
						item.SubItems.Add(p.LastChgUser.ToString());
						item.SubItems.Add(p.Description);
						historyListViewEx.Items.Add(item);

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

		void UpdateFromHistoryTab()
		{
			// Do nothing
		}

		#endregion

		#region Metrology1, Metrology2, Process, and Parameters

		void PrepareMetrology12AndProcessTabs()
		{
			PrepareMetrology1Tab();
			PrepareMetrology2Tab();
			PrepareProcess();
			PrepareParameters();
		}

		Control[] metrology1Editors;

		public enum MtrlgyClmn
		{
			Name,
			Part,
			Qfrom,
			Qto,
			Volume,
			TestTime,
			Repeats,
			Emptying,
			Method,
			MtrlgyClmnCount
		}

		void PrepareMetrology1Tab()
		{
			metrology1ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Test_chdr, Width = 70 });
			metrology1ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Part, Width = 40 });
			metrology1ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Q_from_m3h, Width = 80 });
			metrology1ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Q_to_m3h, Width = 80 });
			metrology1ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Volume + " [l]", Width = 70 });
			metrology1ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Test_time_s_chdr, Width = 70 });
			metrology1ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Repeats_nr_chdr, Width = 80 });
			metrology1ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Emptying_chdr, Width = 60 });
			//metrology1ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Zeroing_chdr, Width = 50 });
			metrology1ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Method_chdr, Width = 150 });

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

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

			metrology1Editors = new Control[]
				{
					new TextBox(),  /// Name
					new TextBox(),  /// Part
					new TextBox(),  /// Qfrom
					new TextBox(),  /// Qto
					new TextBox(),  /// Volume
					new TextBox(),  /// Test time
					new TextBox(),  /// Repeats #
					yesNo1CBox,		/// Emptying
					methodCBox,		/// Method
				};

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

		public enum Mtrlgy2Clmn
		{
			Name,
			Part,
			Qfrom,
			Qto,
			ErrLimLo,
			ErrLimHi,
			Uncertainty,
			Filter,
			Publish,
			Evaluate,
			Mtrlgy2ClmnCount
		}

		Control[] metrology2Editors;

		void PrepareMetrology2Tab()
		{
			metrology2ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Test_chdr, Width = 70 });
			metrology2ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Part, Width = 40 });
			metrology2ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Q_from_m3h, Width = 80 });
			metrology2ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Q_to_m3h, Width = 80 });
			metrology2ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Err_limit_neg_pct_chdr, Width = 100 });
			metrology2ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Err_limit_pos_pct_chdr, Width = 100 });
			metrology2ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Uncertainty_pct_chdr, Width = 100 });
			metrology2ListViewEx.Columns.Add(new ColumnHeader { Text = "Filter", Width = 80 });         /// Strings.Tol_red_pct_chdr
			metrology2ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Publish, Width = 100 });
			metrology2ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Evaluate, Width = 100 });
			//metrology2ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Red_type_chdr, Width = 80 });
			//metrology2ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Err_cor_neg_pct_chdr, Width = 90 });
			//metrology2ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Err_cor_pos_pct_chdr, Width = 90 });

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


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

			metrology2Editors = new Control[]
				{
					new TextBox(),      /// Name
					new TextBox(),      /// Part
					new TextBox(),      /// Qfrom
					new TextBox(),      /// Qto
					new TextBox(),      /// Err.Lim. -
					new TextBox(),      /// Err.Lim. +
					new TextBox(),      /// Uncertainty
					new TextBox(),      /// Filter
					publishCBox,		/// Publish
					yesNoCBox,			/// Evaluate
				};

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

		public enum ProcessClmn
		{
			Name,
			Part,
			Qfrom,
			Qto,
			Feeding,
			Bench,
			Output,
			Sensor,
#if HEAT_METERS
            HeatMeterSensors,
#endif
            TrnStart,
			TrnStop,
			ProcessClmnCount
		}

        Control[] processEditors;

		void PrepareProcess()
        {
            processListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Test_chdr, Width = 70 });
			processListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Part, Width = 40 });
			processListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Q_from_m3h, Width = 80 });
            processListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Q_to_m3h, Width = 80 });
            processListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Feeding_chdr, Width = 80 });
            processListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Bench_chdr, Width = 80 });
            processListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Output_chdr, Width = 80 });
            processListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Sensors_chdr, Width = 80 });
#if HEAT_METERS
            processListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Heat_meter_sensors, Width = 110 });
#endif
			processListViewEx.Columns.Add(new ColumnHeader { Text = Strings.TransitionStart_chdr, Width = 100 });
			processListViewEx.Columns.Add(new ColumnHeader { Text = Strings.TransitionEnd_chdr, Width = 100 });

            processEditors = new Control[]
				{
					new TextBox(),      /// Name
					new TextBox(),      /// Part
					new TextBox(),      /// Qfrom
					new TextBox(),      /// Qto
					new ComboBox(),     /// Feeding
					new ComboBox(),     /// Table
					new ComboBox(),     /// Output
					new ComboBox(),     /// Meters
#if HEAT_METERS
					new ComboBox(),     /// Heat meters
#endif
					new ComboBox(),     /// TransitionStart
					new ComboBox(),     /// TransitionEnd
				};

			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.TrnStop]).Items.Add("---");
            foreach (var trans in transitionSequences)
			{
				((ComboBox)processEditors[(int)ProcessClmn.TrnStart]).Items.Add(trans.Name);
				((ComboBox)processEditors[(int)ProcessClmn.TrnStop]).Items.Add(trans.Name);
			}

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

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

		Control[] parametersEditors;

		void PrepareParameters()
		{
			parametersListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Test_chdr, Width = 70 });
			parametersListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Part, Width = 40 });
			parametersListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Q_from_m3h, Width = 80 });
			parametersListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Q_to_m3h, Width = 80 });
			parametersListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Pump_power_pct, Width = 90 });
            parametersListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Mass_repeats, Width = 90 });
#if STABLE_MASS_EXTRAS
			parametersListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Mass_spread_kg, Width = 110 });
            parametersListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Mass_method, Width = 90 });
#endif
            parametersListViewEx.Columns.Add(new ColumnHeader { Text = Strings.TimePump2StartV_chdr, Width = 70 });
			parametersListViewEx.Columns.Add(new ColumnHeader { Text = Strings.TimeBeforeSettingFlow, Width = 70 });
			parametersListViewEx.Columns.Add(new ColumnHeader { Text = Strings.TimeFlow2Start_chdr, Width = 70 });
			parametersListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Time2MassMsrmt_chdr, Width = 70 });

            parametersEditors = new Control[]
				{
					new TextBox(),      /// Name
					new TextBox(),      /// Part
					new TextBox(),      /// Qfrom
					new TextBox(),      /// Qto
					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 RefreshMetrology12AndProcessTabs()
		{
			metrology1ListViewEx.Items.Clear();
			metrology2ListViewEx.Items.Clear();
			processListViewEx.Items.Clear();
			parametersListViewEx.Items.Clear();
			foreach (var test in LoadedProcedure.Tests) AddToMetrology12AndProcessTab(test);

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

        void AddToMetrology12AndProcessTab(Test test)
        {
			///
			/// Common subitems
			/// 
            ListViewItem lviMetrlg1 = new ListViewItem(test.Name);		///
            ListViewItem lviMetrlg2 = new ListViewItem(test.Name);		/// Name
            ListViewItem lviProcess = new ListViewItem(test.Name);		///
			ListViewItem lviParameters = new ListViewItem(test.Name);	///
			lviMetrlg1.Tag = test;
            lviMetrlg2.Tag = test;
            lviProcess.Tag = test;
			lviParameters.Tag = test;

			lviMetrlg1.SubItems.Add((test.Part == 0) ? "-" : test.Part.ToString());		///
			lviMetrlg2.SubItems.Add((test.Part == 0) ? "-" : test.Part.ToString());		/// Part
			lviProcess.SubItems.Add((test.Part == 0) ? "-" : test.Part.ToString());		///
			lviParameters.SubItems.Add((test.Part == 0) ? "-" : test.Part.ToString());  ///

            lviMetrlg1.SubItems.Add(test.Qfrom.ToString());         ///
            lviMetrlg2.SubItems.Add(test.Qfrom.ToString());         /// Q_from
            lviProcess.SubItems.Add(test.Qfrom.ToString());         ///
			lviParameters.SubItems.Add(test.Qfrom.ToString());		///

            lviMetrlg1.SubItems.Add(test.Qto.ToString());           ///
            lviMetrlg2.SubItems.Add(test.Qto.ToString());           /// Q_to
			lviProcess.SubItems.Add(test.Qto.ToString());			///
			lviParameters.SubItems.Add(test.Qto.ToString());		///

			///
			/// Metrology 1 subitems Volume, ...
			/// 
            lviMetrlg1.SubItems.Add(test.Volume.ToString()); 
            lviMetrlg1.SubItems.Add(test.TstTime.ToString());
            lviMetrlg1.SubItems.Add(test.Repeats.ToString());
            lviMetrlg1.SubItems.Add(test.Draining ? Strings.yes : Strings.no);
            //lviMetrlg1.SubItems.Add(test.Zeroing ? Strings.yes : Strings.no);
			lviMetrlg1.SubItems.Add((test.Method != null) ? test.Method.ToString() : string.Empty);

			metrology1ListViewEx.Items.Add(lviMetrlg1);

			///
			/// Metrology 2 subitems ErrLimLo, ...
			/// 
			lviMetrlg2.SubItems.Add(test.ErrLimLo.ToString());
            lviMetrlg2.SubItems.Add(test.ErrLimHi.ToString());
			lviMetrlg2.SubItems.Add(test.Uncertainty.ToString());
			lviMetrlg2.SubItems.Add(test.TolerRed.ToString());
			lviMetrlg2.SubItems.Add(((Config.Entities.Publish)test.Publish).ToDescription());
			lviMetrlg2.SubItems.Add(test.Evaluate ? Strings.yes : Strings.no);

			metrology2ListViewEx.Items.Add(lviMetrlg2);

			///
			/// Process subitems FeedingPath, ...
			/// 
			lviProcess.SubItems.Add(test.FeedingPath);
            lviProcess.SubItems.Add(test.BenchPath);
            lviProcess.SubItems.Add(test.OutputPath);
            lviProcess.SubItems.Add(test.MetersPath);
#if HEAT_METERS
            lviProcess.SubItems.Add(test.HeatMetersPath);
#endif
			lviProcess.SubItems.Add(string.IsNullOrEmpty(test.RelTransBefore) ? "---" : test.RelTransBefore);
			lviProcess.SubItems.Add(string.IsNullOrEmpty(test.TransitionAfter) ? "---" : test.TransitionAfter);

            processListViewEx.Items.Add(lviProcess);

			///
			/// Process subitems FeedingPath, ...
			/// 
			lviParameters.SubItems.Add(test.PumpPower.ToString("F1"));
            lviParameters.SubItems.Add((test.MassRepeats < 4 ? 5 : test.MassRepeats).ToString());
#if STABLE_MASS_EXTRAS
			lviParameters.SubItems.Add(test.MassSpread.ToString("F4"));
            lviParameters.SubItems.Add(test.MassMethod.ToDescription());
#endif
			lviParameters.SubItems.Add(test.TimePump2StartV.ToString());
			lviParameters.SubItems.Add(test.TimeBeforeFlow.ToString());
			lviParameters.SubItems.Add(test.TimeFlow2Mass.ToString());
			lviParameters.SubItems.Add(test.TimeStop2Mass.ToString());

			parametersListViewEx.Items.Add(lviParameters);
		}

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

                entity.Name = lvi.Text;

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

                float tmp;
				if (Utils.TryParseUFloat(lvi.SubItems[(int)MtrlgyClmn.Qfrom].Text,   out tmp)) entity.Qfrom = tmp;
				if (Utils.TryParseUFloat(lvi.SubItems[(int)MtrlgyClmn.Qto].Text,     out tmp)) entity.Qto = tmp;
				if (Utils.TryParseUFloat(lvi.SubItems[(int)MtrlgyClmn.Volume].Text,  out tmp)) entity.Volume = tmp;
				if (Utils.TryParseUFloat(lvi.SubItems[(int)MtrlgyClmn.TestTime].Text,out tmp)) entity.TstTime = tmp;

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

				if (lvi.SubItems[(int)MtrlgyClmn.Emptying].Text.Equals(Strings.yes)) entity.Draining = true;
				else if (lvi.SubItems[(int)MtrlgyClmn.Emptying].Text.Equals(Strings.no)) entity.Draining = false;


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

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

                entity.Name = lvi.Text;

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

                float tmp;
				if (Utils.TryParseSFloat(lvi.SubItems[(int)Mtrlgy2Clmn.ErrLimLo].Text, out tmp)) entity.ErrLimLo = tmp;
				if (Utils.TryParseSFloat(lvi.SubItems[(int)Mtrlgy2Clmn.ErrLimHi].Text, out tmp)) entity.ErrLimHi = tmp;
				if (Utils.TryParseUFloat(lvi.SubItems[(int)Mtrlgy2Clmn.Uncertainty].Text, out tmp)) entity.Uncertainty = tmp;
				if (Utils.TryParseUFloat(lvi.SubItems[(int)Mtrlgy2Clmn.Filter].Text, out tmp)) entity.TolerRed = (double)tmp;
				
				for (Config.Entities.Publish pb = 0; pb < Config.Entities.Publish.Count; pb++)
				{
                    if (lvi.SubItems[(int)Mtrlgy2Clmn.Publish].Text.Equals(pb.ToDescription()))
					{
						entity.Publish = (sbyte)pb;
						break;
					}
				}

				if (lvi.SubItems[(int)Mtrlgy2Clmn.Evaluate].Text.Equals(Strings.yes)) entity.Evaluate = true;
				else if (lvi.SubItems[(int)Mtrlgy2Clmn.Evaluate].Text.Equals(Strings.no)) entity.Evaluate = false;
			}
        }

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

                entity.Name = lvi.Text;

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

				if ((processEditors[(int)ProcessClmn.Feeding] as ComboBox).Items.Contains(lvi.SubItems[(int)ProcessClmn.Feeding].Text))
				{
					entity.FeedingPath = lvi.SubItems[(int)ProcessClmn.Feeding].Text;
				}
				if ((processEditors[(int)ProcessClmn.Bench] as ComboBox).Items.Contains(lvi.SubItems[(int)ProcessClmn.Bench].Text))
				{
					entity.BenchPath = lvi.SubItems[(int)ProcessClmn.Bench].Text;
				}
				if ((processEditors[(int)ProcessClmn.Output] as ComboBox).Items.Contains(lvi.SubItems[(int)ProcessClmn.Output].Text))
				{
					entity.OutputPath = lvi.SubItems[(int)ProcessClmn.Output].Text;
				}
				if ((processEditors[(int)ProcessClmn.Sensor] as ComboBox).Items.Contains(lvi.SubItems[(int)ProcessClmn.Sensor].Text))
				{
					entity.MetersPath = lvi.SubItems[(int)ProcessClmn.Sensor].Text;
				}
#if HEAT_METERS
                if ((processEditors[(int)ProcessClmn.HeatMeterSensors] as ComboBox).Items.Contains(lvi.SubItems[(int)ProcessClmn.HeatMeterSensors].Text))
                {
                    entity.HeatMetersPath = lvi.SubItems[(int)ProcessClmn.HeatMeterSensors].Text;
                }
#endif
				if ((processEditors[(int)ProcessClmn.TrnStart] as ComboBox).Items.Contains(lvi.SubItems[(int)ProcessClmn.TrnStart].Text))
                {
					entity.RelTransBefore = lvi.SubItems[(int)ProcessClmn.TrnStart].Text.Equals("---") ? string.Empty : lvi.SubItems[(int)ProcessClmn.TrnStart].Text;
                }
				if ((processEditors[(int)ProcessClmn.TrnStop] as ComboBox).Items.Contains(lvi.SubItems[(int)ProcessClmn.TrnStop].Text))
                {
					entity.TransitionAfter = lvi.SubItems[(int)ProcessClmn.TrnStop].Text.Equals("---") ? string.Empty : lvi.SubItems[(int)ProcessClmn.TrnStop].Text;
                }
			}
        }

		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;

				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 metrology1ListViewEx_SubItemClicked(object sender, Results.Forms.SubItemEventArgs e)
        {
			if (unlocked && (e.SubItem < (int)MtrlgyClmn.MtrlgyClmnCount))
			{
				metrology1ListViewEx.StartEditing(metrology1Editors[e.SubItem], e.Item, e.SubItem);
			}
        }

		void metrology1ListViewEx_SubItemRightClicked(object sender, Results.Forms.SubItemEventArgs e)
        {
            if (!unlocked || e.SubItem >= (int)MtrlgyClmn.MtrlgyClmnCount) 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)
                    {
                        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 metrology1ListViewEx_SubItemEndEditing(object sender, Results.Forms.SubItemEndEditingEventArgs e)
        {
			int dummy;
			if (e.SubItem == (int)MtrlgyClmn.Part)
			{
				if (e.DisplayText.Equals("-")) return;	/// OK
                if (!int.TryParse(e.DisplayText, out dummy) || dummy < 1 || dummy > Config.Data.MaxPartNr)
				{
					e.DisplayText = e.Item.SubItems[e.SubItem].Text;
					e.Cancel = true;
					return;								/// NOK
				}
			}

			if ((e.SubItem == (int)MtrlgyClmn.Repeats) && !int.TryParse(e.DisplayText, out dummy))
			{
				e.DisplayText = e.Item.SubItems[e.SubItem].Text;
				e.Cancel = true;
				return;
			}

			if ((e.SubItem == (int)MtrlgyClmn.Emptying) && !(metrology1Editors[(int)MtrlgyClmn.Emptying] as ComboBox).Items.Contains(e.DisplayText))
			{
				e.DisplayText = e.Item.SubItems[e.SubItem].Text;
				e.Cancel = true;
				return;
			}

			if ((e.SubItem != (int)MtrlgyClmn.Qfrom) &&
				(e.SubItem != (int)MtrlgyClmn.Qto)    &&
				(e.SubItem != (int)MtrlgyClmn.Volume) &&
				(e.SubItem != (int)MtrlgyClmn.TestTime))
			{
				return;
			}

            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 ((e.SubItem == (int)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) calculateTime = true;
			}
			else if ((e.SubItem == (int)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) calculateTime = true;
			}
			else if ((e.SubItem == (int)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) calculateTime = true;
			}
			else if ((e.SubItem == (int)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 Qave_lps = (Qfrom + Qto) / 7.2f;
			if (calculateTime)
			{
				testTime = volume / Qave_lps;
				e.Item.SubItems[(int)MtrlgyClmn.TestTime].Text = testTime.ToString();
			}
			else if (calculateVolume)
			{
				volume = testTime * Qave_lps;
				e.Item.SubItems[(int)MtrlgyClmn.Volume].Text = volume.ToString();
			}
			else
			{
				e.DisplayText = e.Item.SubItems[e.SubItem].Text;
				e.Cancel = true;
			}
        }

		private void metrology2ListViewEx_SubItemClicked(object sender, Results.Forms.SubItemEventArgs e)
        {
            if (!unlocked ||
                e.SubItem == (int)Mtrlgy2Clmn.Qfrom ||
                e.SubItem == (int)Mtrlgy2Clmn.Qto   ||
                e.SubItem >= (int)Mtrlgy2Clmn.Mtrlgy2ClmnCount)
            {
                return;
            }

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

		void metrology2ListViewEx_SubItemRightClicked(object sender, Results.Forms.SubItemEventArgs e)
        {
            if (!unlocked ||
                e.SubItem == (int)Mtrlgy2Clmn.Qfrom ||
                e.SubItem == (int)Mtrlgy2Clmn.Qto   ||
                e.SubItem >= (int)Mtrlgy2Clmn.Mtrlgy2ClmnCount)
            {
                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;
                    }
                    else if (item == e.Item)
                    {
                        value = item.SubItems[columnNr].Text;
                        backColor = item.SubItems[columnNr].BackColor;
                    }
                }
            }
        }

		private void metrology2ListViewEx_SubItemEndEditing(object sender, Results.Forms.SubItemEndEditingEventArgs e)
        {
			int dummy;
			if (e.SubItem == (int)Mtrlgy2Clmn.Part)
			{
				if (e.DisplayText.Equals("-")) return;	/// OK
				if (!int.TryParse(e.DisplayText, out dummy) || dummy < 1 || dummy > Config.Data.MaxPartNr)
				{
					e.DisplayText = e.Item.SubItems[e.SubItem].Text;
					e.Cancel = true;
					return;								/// NOK
				}
			}
			if (e.SubItem == (int)Mtrlgy2Clmn.Publish)
			{
				for (Config.Entities.Publish pb = 0; pb < Config.Entities.Publish.Count; pb++)
				{
					if (e.DisplayText.Equals(pb.ToDescription())) return;
				}
				e.DisplayText = e.Item.SubItems[e.SubItem].Text;
				e.Cancel = true;
				return;								/// NOK
			}
		}

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

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

		void processListViewEx_SubItemRightClicked(object sender, Results.Forms.SubItemEventArgs e)
        {
            if (!unlocked ||
                e.SubItem == (int)ProcessClmn.Qfrom ||
                e.SubItem == (int)ProcessClmn.Qto ||
                e.SubItem >= (int)ProcessClmn.ProcessClmnCount)
            {
                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, Results.Forms.SubItemEndEditingEventArgs e)
        {
			int dummy;
			if (e.SubItem == (int)ProcessClmn.Part)
			{
				if (e.DisplayText.Equals("-")) return;	/// OK
				if (!int.TryParse(e.DisplayText, out dummy) || dummy < 1 || dummy > 3)
				{
					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.TrnStop) && !(processEditors[(int)ProcessClmn.TrnStop] as ComboBox).Items.Contains(e.DisplayText)))
			{
				e.DisplayText = e.Item.SubItems[e.SubItem].Text;
				e.Cancel = true;
			}
		}

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

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

		void parametersListViewEx_SubItemRightClicked(object sender, Results.Forms.SubItemEventArgs e)
        {
            if (!unlocked ||
                e.SubItem == (int)ParametersClmn.Qfrom ||
                e.SubItem == (int)ParametersClmn.Qto ||
                e.SubItem >= (int)ParametersClmn.ParametersClmnCount)
            {
                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, Results.Forms.SubItemEndEditingEventArgs e)
		{
			int dummy;
			if (e.SubItem == (int)ParametersClmn.Part)
			{
				if (e.DisplayText.Equals("-")) return;	/// OK
				if (!int.TryParse(e.DisplayText, out dummy) || dummy < 1 || dummy > 3)
				{
					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


		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;
			protocolTitleTextBox.Enabled = true;
			dataEntryComboBox.Enabled = true;
            metersKindRadioButton1.Enabled = true;
            metersKindRadioButton2.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;
            transitionStartComboBox.Enabled = true;
			transitionEndComboBox.Enabled = true;
			notesTextBox.Enabled = true;

			Results.Forms.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) ctrl.UpdateAll();
			foreach (var ctrl in procedureParamsCtrls) ctrl.UpdateAll();

            Program.LocalSettings.OneProcedureDlgLeft = Location.X;
            Program.LocalSettings.OneProcedureDlgTop = Location.Y;
            Program.LocalSettings.OneProcedureDlgWidth = Size.Width;
            Program.LocalSettings.OneProcedureDlgHeight = Size.Height;
            Program.LocalSettings.Save();

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

		private void cancelButton_Click(object sender, EventArgs e)
		{
            Program.LocalSettings.OneProcedureDlgLeft = Location.X;
            Program.LocalSettings.OneProcedureDlgTop = Location.Y;
            Program.LocalSettings.OneProcedureDlgWidth = Size.Width;
            Program.LocalSettings.OneProcedureDlgHeight = Size.Height;
            Program.LocalSettings.Save();

            DialogResult = DialogResult.Cancel;
			Close();
			return;
		}

        #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;

			sharedButtons.SetEnabled(SharedButtons.Buttons.Add,
									 selectedTab == ProcedureTabs.Metrology1 ||
									 selectedTab == ProcedureTabs.Metrology2 ||
									 selectedTab == ProcedureTabs.Process    ||
									 selectedTab == ProcedureTabs.Parameters);
 
			//bool removeBtnEnabled = (selectedTab != ProcedureTabs.General &&
			//                        selectedTab != ProcedureTabs.History &&
			//                        selectedTab != ProcedureTabs.Calibration);

			sharedButtons.DisableButtons(SharedButtons.Buttons.Remove);

            RefreshAllTabs();
        }

        #endregion

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

        private void addButton_Click(object sender, EventArgs e)
        {
			Results.Forms.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;
			}

			/// Add a test
			Test test = new Test(newName, listViewEx.Items.Count, LoadedProcedure);
			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);
			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);
			roiData.Calculate();
			test.Qfrom = (float)(roiData.Q * 0.95);
			test.Qto = (float)(roiData.Q * 1.05);
			//test.

		methodLabel:

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

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

			if (selectedMethod is TBF.BenchControl.TestMethods.OuterLoop.Start.Component
				 || selectedMethod is TBF.BenchControl.TestMethods.OuterLoop.End.Component)
			{
				test.Publish = (sbyte)Publish.Never;
				test.Evaluate = false;
				goto done;
			}
			if (selectedMethod is BenchControl.TestMethods.PMaxTest.TestMethod) goto pressure_label;
			if (selectedMethod is BenchControl.TestMethods.LeakTest.TestMethod) goto pressure_label;
#if HEAT_METERS
			if (selectedMethod.CanTest(MetersKind.HeatMeter)) goto heat_meters_label;
#endif
			if (!(selectedMethod is BenchControl.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;
			}

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

			if (selectedMethod is BenchControl.TestMethods.RoiDetection.RoiDetection)
			{
				goto select_paths;
			}

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

		select_paths:

			/// 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))
				{
					test.FeedingPath = path.Name;
					break;
				}
			}
			foreach (var path in benchPaths)
			{
				if ((path.Qfrom <= Qaver) && (Qaver <= path.Qto))
				{
					test.BenchPath = path.Name;
					break;
				}
			}
			foreach (var path in outputPaths)
			{
				if ((path.Qfrom <= Qaver) && (Qaver <= path.Qto))
				{
					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);
			AddToMetrology12AndProcessTab(test);
			foreach (var ctrl in testParamsCtrls)
			{
				ctrl.AddOne(test);
			}

			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)
        {
			Results.Forms.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];
			
			/// 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)
		{
			Results.Forms.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);

			RefreshMetrology12AndProcessTabs();

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

		private void downButton_Click(object sender, EventArgs e)
		{
			Results.Forms.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);

			RefreshMetrology12AndProcessTabs();

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

        #endregion

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

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

		/// <summary>
		/// Common part for three xxxListViewEx_SelectedIndexChanged event handlers
		/// </summary>
		/// <param name="listViewEx"></param>
		void SelectedIndexChanged(object sender, EventArgs e)
		{
			Results.Forms.ListViewEx listViewEx = sender as Results.Forms.ListViewEx;
			if (listViewEx.SelectedItems.Count != 1)
			{
				UpdateButtonStates(SharedButtons.SelectedItemPos.None);
			}
			else if (listViewEx.Items.Count == 1)
			{
				UpdateButtonStates(SharedButtons.SelectedItemPos.FirstAndLast);
			}
			else if (listViewEx.SelectedIndices[0] == 0)
			{
				UpdateButtonStates(SharedButtons.SelectedItemPos.First);
			}
			else if (listViewEx.SelectedIndices[0] == (listViewEx.Items.Count - 1))
			{
				UpdateButtonStates(SharedButtons.SelectedItemPos.Last);
			}
			else
			{
				UpdateButtonStates(SharedButtons.SelectedItemPos.Middle);
			}
		}

		/// <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 AddProcessDataToRoiComponents(Config.Entities.Procedure procedure, string sensorsPathName, TestWizard.RoiData roiData)
		{
			/// Create controls for each sensors path used in this procedure.
			/// Initialize it with its components (sensors or cameras) and add it to the list.
			try
			{
				MetersPath sensorsPath = metersPaths.First<MetersPath>(x => (x.Name == sensorsPathName));

				if (sensorsPath != null)
				{
					IList<IComponent> cmpntsInMPath = new List<IComponent>();
					for (int i = 0; i < Config.Data.WMsCount; i++)
					{
						IComponent sensor = TbfComponents.FirstOrDefault<IComponent>(x => (x.Cfg.Name.Equals(sensorsPath.GetSensor(i))));
						cmpntsInMPath.Add(sensor);
					}

					foreach (var cmpnt in cmpntsInMPath)
					{
						if (cmpnt != null && (cmpnt.Cfg.GetProcedureParams() != null))
						{
							IParamsProvider procedureParams = cmpnt.Cfg.CreateProcedureParams(procedure);
							BenchControl.Network.Camera.Roi.ProcedureParams roiParams = procedureParams as BenchControl.Network.Camera.Roi.ProcedureParams;
							if (roiParams != null)
							{
								roiParams.PulsesPerLtr = (float)roiData.PulsesPerLiter;
								roiParams.DetectionImagesCount = roiData.N;
								roiParams.DetectionPeriod1 = roiData.P1;
								roiParams.DetectionPeriod2 = roiData.P2;
								roiParams.RoiParams = roiData.GetRoiParams();
							}
						}
					}
				}
			}
			catch
			{
			}
		}

	}
}