tbf/TestBenchFramework/ProcedureDlg.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using log4net;

using TBF.BenchControl.Generic;
using TBF.BenchControl.GenericDevices;
using TBF.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 Entities.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<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 = Grp.GID.Metrologists;
			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 SubItemEventHandler(metrology1ListViewEx_SubItemClicked);
			metrology1ListViewEx.SubItemEndEditing += new SubItemEndEditingEventHandler(metrology1ListViewEx_SubItemEndEditing);

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

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

		public ProcedureDlg(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 = FluentCommon.CreateSession(Database.Bench))
			{
				TbfComponents = BenchControl.TbfComponents.LoadComponentsFromDB(session);
				Valves = BenchControl.GenericDevices.ValveBase.MasterValves(TbfComponents);
				RegulValves = new List<IRegulValve>();
				TestMethods = new List<ITestMethod>();
                dataEntryComboBox.Items.Add("---");
                resultsPrinterComboBox.Items.Add("---");
                resultsWriterComboBox.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) resultsPrinterComboBox.Items.Add(cmpnt.Cfg.Name);
					if (cmpnt is IResultsWriter) resultsWriterComboBox.Items.Add(cmpnt.Cfg.Name);
				}
			}

			/// Loads paths, this must be done before PrepareMetrology12AndProcessTabs() call
			using (NHibernate.ISession session = FluentCommon.CreateSession(Database.Procedures))
			{
				feedingPaths = session.CreateQuery("FROM FeedingPath").List<Entities.FeedingPath>();
				benchPaths = session.CreateQuery("FROM BenchPath").List<Entities.BenchPath>();
				outputPaths = session.CreateQuery("FROM OutputPath").List<Entities.OutputPath>();
				metersPaths = session.CreateQuery("FROM MetersPath").List<Entities.MetersPath>();
				transitionSequences = session.CreateQuery("FROM TransitionSequence").List<Entities.TransitionSequence>();
			}

            transitionStartComboBox.Items.Add("---");
            transitionEndComboBox.Items.Add("---");
			foreach (var trans in transitionSequences)
			{
				transitionStartComboBox.Items.Add(trans.Name);
				transitionEndComboBox.Items.Add(trans.Name);
			}
				
			/// 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
			testParamsCtrls = new List<TestParamsCtrl>();
			foreach (var method in UsedTestMethods)
			{
				if (method.Cfg.GetTestParams() != null)
				{
					TabPage nwTab = new TabPage(method.Cfg.Name);
					TestParamsCtrl testParamsCtrl = new TestParamsCtrl(this, method, true);
					testParamsCtrls.Add(testParamsCtrl);
					nwTab.Controls.Add(testParamsCtrl);
					this.tabControl.TabPages.Add(nwTab);
				}
			}

			/// 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 an empty list of ProcedureParamsCtrl controls.
			procedureParamsCtrls = new List<ProcedureParamsCtrl>();

			/// 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 procedureParamsCtrl = new ProcedureParamsCtrl(this, waterMeters, false);
			procedureParamsCtrls.Add(procedureParamsCtrl);
			newTab.Controls.Add(procedureParamsCtrl);
			this.tabControl.TabPages.Add(newTab);

			/// 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)
			{
				Entities.MetersPath usedPath = null;
				try { usedPath = metersPaths.First<Entities.MetersPath>(x => (x.Name == usedPathName)); }
				catch { }
				if (usedPath != null)
				{
					IList<IComponent> cmpntsInMPath = new List<IComponent>();
					for (int i = 0; i < Program.WMsCount; i++)
					{
						IComponent sensor = TbfComponents.FirstOrDefault<IComponent>(x => (x.Cfg.Name.Equals(usedPath.GetSensor(i))));
						cmpntsInMPath.Add(sensor);
					}

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

			/// Create a control for the printed protocol.
			IComponent printer = BenchControl.TbfComponents.FindComponent(LoadedProcedure.ResultsPrinter, TbfComponents);
			if (printer != null)
			{
				IList<IComponent> printers = new List<IComponent>();
				printers.Add(printer);
				newTab = new TabPage(Strings.Printer);
				procedureParamsCtrl = new ProcedureParamsCtrl(this, printers, false);
				procedureParamsCtrls.Add(procedureParamsCtrl);
				newTab.Controls.Add(procedureParamsCtrl);
				this.tabControl.TabPages.Add(newTab);
			}

            /// 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))
                {
                    newTab = new TabPage(cmpnt.Cfg.Name);
                    TestParamsCtrl testParamsCtrl = new TestParamsCtrl(this, cmpnt, true);
                    testParamsCtrls.Add(testParamsCtrl);
                    newTab.Controls.Add(testParamsCtrl);
                    this.tabControl.TabPages.Add(newTab);
                }
            }
		}

		private void ProcedureDlg_Load(object sender, EventArgs e)
        {
			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;

			/// 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;
			dataEntryComboBox.Enabled = false;
            metersKindRadioButton1.Enabled = false;
            metersKindRadioButton2.Enabled = false;
            resultsPrinterComboBox.Enabled = false;
			resultsWriterComboBox.Enabled = false;
			transitionStartComboBox.Enabled = false;
			transitionEndComboBox.Enabled = false;
			notesTextBox.Enabled = false;

			/// 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 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.ToShortDateString();
			lastChangedByTextBox.Text = LoadedProcedure.LastChgUser;
			if (LoadedProcedure.LastChgTime > LoadedProcedure.CreationTime)
			{
				lastChangedOnTextBox.Text = LoadedProcedure.LastChgTime.ToShortDateString();
			}
            metersKindRadioButton1.Checked = (LoadedProcedure.MetersKind == MetersKind.Single);
            metersKindRadioButton2.Checked = (LoadedProcedure.MetersKind == MetersKind.Combined);
            notesTextBox.Text = LoadedProcedure.LongDescription;
            dataEntryComboBox.Text = string.IsNullOrEmpty(LoadedProcedure.DataEntry) ? "---" : LoadedProcedure.DataEntry;
            resultsPrinterComboBox.Text = string.IsNullOrEmpty(LoadedProcedure.ResultsPrinter) ? "---" : LoadedProcedure.ResultsPrinter;
            resultsWriterComboBox.Text = string.IsNullOrEmpty(LoadedProcedure.ResultsWriter) ? "---" : LoadedProcedure.ResultsWriter;
            transitionStartComboBox.Text = string.IsNullOrEmpty(LoadedProcedure.TransitionStart) ? "---" : LoadedProcedure.TransitionStart;
            transitionEndComboBox.Text   = string.IsNullOrEmpty(LoadedProcedure.TransitionEnd)   ? "---" : LoadedProcedure.TransitionEnd;
		}

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

			LoadedProcedure.Description = descriptionTextBox.Text;
			LoadedProcedure.LastChgUser = User.CurrentUser.Name;
			LoadedProcedure.LastChgTime = DateTime.Now;
			LoadedProcedure.LongDescription = notesTextBox.Text;
			LoadedProcedure.Watermeters = watermetersTextBox.Text;
            LoadedProcedure.MetersKind = (metersKindRadioButton1.Checked ? MetersKind.Single : MetersKind.Combined);

			if (dataEntryComboBox.Items.Contains(dataEntryComboBox.Text))
            {
                LoadedProcedure.DataEntry = dataEntryComboBox.Text.Equals("---") ? string.Empty : dataEntryComboBox.Text;
            }
			if (resultsPrinterComboBox.Items.Contains(resultsPrinterComboBox.Text))
            {
                LoadedProcedure.ResultsPrinter = resultsPrinterComboBox.Text.Equals("---") ? string.Empty : resultsPrinterComboBox.Text;
            }
			if (resultsWriterComboBox.Items.Contains(resultsWriterComboBox.Text))
            {
                LoadedProcedure.ResultsWriter = resultsWriterComboBox.Text.Equals("---") ? string.Empty : resultsWriterComboBox.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;
            }
		}

		#endregion

        #region Metrology12 and Process

        Control[] metrology1Editors;
        Control[] metrology2Editors;
        Control[] processEditors;

        void PrepareMetrology12AndProcessTabs()
        {
            metrology1ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Test_chdr, Width = 70 });
            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_ltr_chdr, 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.Time2MassMsrmt_chdr, Width = 70 });
            metrology1ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Method_chdr, Width = 150 });
			//metrology1ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Q_set_method_chdr, Width = 100 });
			//metrology1ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Method1_chdr, Width = 100 });
			//metrology1ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Method2_chdr, Width = 110 });

            metrology2ListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Test_chdr, Width = 70 });
            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 = "Filter", Width = 80 });         /// Strings.Tol_red_pct_chdr
            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 });

            processListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Test_chdr, Width = 70 });
            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 = 90 });
            processListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Bench_chdr, Width = 90 });
            processListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Output_chdr, Width = 90 });
            processListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Sensors_chdr, Width = 90 });
			processListViewEx.Columns.Add(new ColumnHeader { Text = Strings.TransitionStart_chdr, Width = 100 });
			processListViewEx.Columns.Add(new ColumnHeader { Text = Strings.TransitionEnd_chdr, Width = 100 });

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

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

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

			//ComboBox qmethod = new ComboBox();
			//for (Entities.QSetMethod method = 0; method < Entities.QSetMethod.Count; method++) qmethod.Items.Add(method.ToString());
			//ComboBox method1 = new ComboBox();
			//for (Entities.TestMethod method = 0; method < Entities.TestMethod.Count; method++) method1.Items.Add(method.ToString());
			//ComboBox method2 = new ComboBox();
			//for (Entities.TestMethod2 method = 0; method < Entities.TestMethod2.Count; method++) method2.Items.Add(method.ToString());

			metrology1Editors = new Control[]
				{
					new TextBox(),  /// 0 test name
					new TextBox(),  /// 1 Qfrom
					new TextBox(),  /// 2 Qto
					new TextBox(),  /// 3 Volume
					new TextBox(),  /// 4 Test time
					new TextBox(),  /// 5 Repeats #
					yesNo1CBox,		/// 6 Emptying
					new TextBox(),	/// 7 Time2MassMsrmt
					methodCBox,
				};

            metrology2Editors = new Control[]
            {
                new TextBox(),      /// 0 test name
                new TextBox(),      /// 1 Qfrom
                new TextBox(),      /// 2 Qto
                new TextBox(),      /// 3 Err.Lim. -
                new TextBox(),      /// 4 Err.Lim. +
                new TextBox(),      /// 5 Tol.Red.
                new ComboBox(),     /// 6 Red.Type
            };

            processEditors = new Control[]
            {
                new TextBox(),      /// 0 test name
                new TextBox(),      /// 1 Qfrom
                new TextBox(),      /// 2 Qto
                new ComboBox(),     /// 3 Feeding
                new ComboBox(),     /// 4 Table
                new ComboBox(),     /// 5 Output
                new ComboBox(),     /// 6 Meters
                new ComboBox(),     /// 7 TransitionStart
                new ComboBox(),     /// 8 TransitionEnd
            };

            foreach (var ctrl in metrology1Editors) metrology1TabPage.Controls.Add(ctrl);
            foreach (var ctrl in metrology2Editors) metrology2TabPage.Controls.Add(ctrl);
            foreach (var ctrl in processEditors) processTabPage.Controls.Add(ctrl);

            foreach (var path in feedingPaths) ((ComboBox)processEditors[3]).Items.Add(path.Name);
            foreach (var path in benchPaths) ((ComboBox)processEditors[4]).Items.Add(path.Name);
            foreach (var path in outputPaths) ((ComboBox)processEditors[5]).Items.Add(path.Name);
            foreach (var path in metersPaths) ((ComboBox)processEditors[6]).Items.Add(path.Name);

            ((ComboBox)processEditors[7]).Items.Add("---");
            ((ComboBox)processEditors[8]).Items.Add("---");
            foreach (var trans in transitionSequences)
			{
				((ComboBox)processEditors[7]).Items.Add(trans.Name);
				((ComboBox)processEditors[8]).Items.Add(trans.Name);
			}
		}

		void RefreshMetrology12AndProcessTabs()
		{
			metrology1ListViewEx.Items.Clear();
			metrology2ListViewEx.Items.Clear();
			processListViewEx.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)
        {
            ListViewItem lviMetrlg1 = new ListViewItem(test.Name);  ///
            ListViewItem lviMetrlg2 = new ListViewItem(test.Name);  /// SubItem 0
            ListViewItem lviProcess = new ListViewItem(test.Name);  ///
            lviMetrlg1.Tag = test;
            lviMetrlg2.Tag = test;
            lviProcess.Tag = test;

            lviMetrlg1.SubItems.Add(test.Qfrom.ToString());         ///
            lviMetrlg2.SubItems.Add(test.Qfrom.ToString());         /// SubItem 1
            lviProcess.SubItems.Add(test.Qfrom.ToString());         ///

            lviMetrlg1.SubItems.Add(test.Qto.ToString());           ///
            lviMetrlg2.SubItems.Add(test.Qto.ToString());           /// SubItem 2
            lviProcess.SubItems.Add(test.Qto.ToString());           ///

            lviMetrlg1.SubItems.Add(test.Volume.ToString());                    /// SubItem 3
            lviMetrlg1.SubItems.Add(test.TstTime.ToString());                   /// SubItem 4
            lviMetrlg1.SubItems.Add(test.Repeats.ToString());                   /// SubItem 5
            lviMetrlg1.SubItems.Add(test.Emptying ? Strings.yes : Strings.no);  /// SubItem 6
            //lviMetrlg1.SubItems.Add(test.Zeroing ? Strings.yes : Strings.no);   /// SubItem 7
            lviMetrlg1.SubItems.Add(test.Time2MassMsrmt.ToString());            /// SubItem 7
			lviMetrlg1.SubItems.Add((test.Method != null) ? test.Method.ToString() : string.Empty);     /// SubItem 8

            lviMetrlg2.SubItems.Add(test.ErrLimLo.ToString());      /// SubItem 3
            lviMetrlg2.SubItems.Add(test.ErrLimHi.ToString());      /// SubItem 4
            lviMetrlg2.SubItems.Add(test.TolerRed.ToString());      /// SubItem 5
            lviMetrlg2.SubItems.Add(test.RedType.ToString());       /// SubItem 6

            lviProcess.SubItems.Add(test.FeedingPath);              /// SubItem 3
            lviProcess.SubItems.Add(test.BenchPath);                /// SubItem 4
            lviProcess.SubItems.Add(test.OutputPath);               /// SubItem 5
            lviProcess.SubItems.Add(test.MetersPath);               /// SubItem 6
			lviProcess.SubItems.Add(string.IsNullOrEmpty(test.TransitionStart) ? "---" : test.TransitionStart);  /// SubItem 7
            lviProcess.SubItems.Add(string.IsNullOrEmpty(test.TransitionEnd)   ? "---" : test.TransitionEnd);    /// SubItem 8

            metrology1ListViewEx.Items.Add(lviMetrlg1);
            metrology2ListViewEx.Items.Add(lviMetrlg2);
            processListViewEx.Items.Add(lviProcess);
		}

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

                float Qfrom;
				bool allOk = Utils.TryParseUFloat(lvi.SubItems[1].Text, out Qfrom);
                entity.Qfrom = Qfrom;

                float Qto;
				allOk &= Utils.TryParseUFloat(lvi.SubItems[2].Text, out Qto); 
                entity.Qto = Qto;

                float volume;
				allOk &= Utils.TryParseUFloat(lvi.SubItems[3].Text, out volume); 
                entity.Volume = volume;

                float testTime;
				allOk &= Utils.TryParseUFloat(lvi.SubItems[4].Text, out testTime);
                entity.TstTime = testTime;

				int repeats;
				allOk &= int.TryParse(lvi.SubItems[5].Text, out repeats);
				entity.Repeats = repeats;

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

				//if (lvi.SubItems[7].Text.Equals(Strings.yes)) entity.Zeroing = true;
				//else if (lvi.SubItems[7].Text.Equals(Strings.no)) entity.Zeroing = false;

                int time2MassMsrmt;
                allOk &= int.TryParse(lvi.SubItems[7].Text, out time2MassMsrmt);
                entity.Time2MassMsrmt = time2MassMsrmt;

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

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

                float Qfrom;
				bool allOk = Utils.TryParseUFloat(lvi.SubItems[1].Text, out Qfrom);
				entity.Qfrom = Qfrom;

                float Qto;
				allOk &= Utils.TryParseUFloat(lvi.SubItems[2].Text, out Qto);
				entity.Qto = Qto;

                float errLimLo;
				allOk &= Utils.TryParseSFloat(lvi.SubItems[3].Text, out errLimLo); 
                entity.ErrLimLo = errLimLo;

                float errLimHi;
				allOk &= Utils.TryParseSFloat(lvi.SubItems[4].Text, out errLimHi);
				entity.ErrLimHi = errLimHi;

                float filter;
                allOk &= Utils.TryParseUFloat(lvi.SubItems[5].Text, out filter);
                entity.TolerRed = (double)filter;
            }
        }

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

				float Qfrom;
				bool allOk = Utils.TryParseUFloat(lvi.SubItems[1].Text, out Qfrom);
				entity.Qfrom = Qfrom;

				float Qto;
				allOk &= Utils.TryParseUFloat(lvi.SubItems[2].Text, out Qto);
				entity.Qto = Qto;

				if ((processEditors[3] as ComboBox).Items.Contains(lvi.SubItems[3].Text)) entity.FeedingPath= lvi.SubItems[3].Text;
				if ((processEditors[4] as ComboBox).Items.Contains(lvi.SubItems[4].Text)) entity.BenchPath  = lvi.SubItems[4].Text;
				if ((processEditors[5] as ComboBox).Items.Contains(lvi.SubItems[5].Text)) entity.OutputPath = lvi.SubItems[5].Text;
				if ((processEditors[6] as ComboBox).Items.Contains(lvi.SubItems[6].Text)) entity.MetersPath = lvi.SubItems[6].Text;
                if ((processEditors[7] as ComboBox).Items.Contains(lvi.SubItems[7].Text))
                {
                    entity.TransitionStart = lvi.SubItems[7].Text.Equals("---") ? string.Empty : lvi.SubItems[7].Text;
                }
                if ((processEditors[8] as ComboBox).Items.Contains(lvi.SubItems[8].Text))
                {
                    entity.TransitionEnd = lvi.SubItems[8].Text.Equals("---") ? string.Empty : lvi.SubItems[8].Text;
                }
			}
        }

        private void metrology1ListViewEx_SubItemClicked(object sender, SubItemEventArgs e)
        {
            if (!unlocked || e.SubItem >= metrology1Editors.Length) return;
            metrology1ListViewEx.StartEditing(metrology1Editors[e.SubItem], e.Item, e.SubItem);
        }

        private void metrology1ListViewEx_SubItemEndEditing(object sender, SubItemEndEditingEventArgs e)
        {
			if (e.SubItem != 1 && e.SubItem != 2 && e.SubItem != 3 && e.SubItem != 4) 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 == 1 && Utils.TryParseUFloat(e.DisplayText, out Qfrom))
			{
				allOk &= Utils.TryParseUFloat(e.Item.SubItems[2].Text, out Qto);
				allOk &= Utils.TryParseUFloat(e.Item.SubItems[3].Text, out volume);
				if (allOk) calculateTime = true;
			}
			else if (e.SubItem == 2 && Utils.TryParseUFloat(e.DisplayText, out Qto))
			{
				allOk &= Utils.TryParseUFloat(e.Item.SubItems[1].Text, out Qfrom);
				allOk &= Utils.TryParseUFloat(e.Item.SubItems[3].Text, out volume);
				if (allOk) calculateTime = true;
			}
			else if (e.SubItem == 3 && Utils.TryParseUFloat(e.DisplayText, out volume))
			{
				allOk &= Utils.TryParseUFloat(e.Item.SubItems[1].Text, out Qfrom);
				allOk &= Utils.TryParseUFloat(e.Item.SubItems[2].Text, out Qto);
				if (allOk) calculateTime = true;
			}
			else if (e.SubItem == 4 && Utils.TryParseUFloat(e.DisplayText, out testTime))
			{
				allOk &= Utils.TryParseUFloat(e.Item.SubItems[1].Text, out Qfrom);
				allOk &= Utils.TryParseUFloat(e.Item.SubItems[2].Text, out Qto);
				if (allOk) calculateVolume = true;
			}

			float Qave_lps = (Qfrom + Qto) / 7.2f;
			if (calculateTime)
			{
				testTime = volume / Qave_lps;
				e.Item.SubItems[4].Text = testTime.ToString();
			}
			else if (calculateVolume)
			{
				volume = testTime * Qave_lps;
				e.Item.SubItems[3].Text = volume.ToString();
			}
			else
			{
				e.DisplayText = e.Item.SubItems[e.SubItem].Text;
				e.Cancel = true;
			}
        }

        private void metrology2ListViewEx_SubItemClicked(object sender, SubItemEventArgs e)
        {
			if (!unlocked || e.SubItem >= metrology2Editors.Length) return;
            metrology2ListViewEx.StartEditing(metrology2Editors[e.SubItem], e.Item, e.SubItem);
        }

        private void metrology2ListViewEx_SubItemEndEditing(object sender, SubItemEndEditingEventArgs e)
        {
        }

        private void processListViewEx_SubItemClicked(object sender, SubItemEventArgs e)
        {
			if (!unlocked || e.SubItem >= processEditors.Length) return;
            processListViewEx.StartEditing(processEditors[e.SubItem], e.Item, e.SubItem);
        }

        private void processListViewEx_SubItemEndEditing(object sender, SubItemEndEditingEventArgs e)
        {
			if ((e.SubItem == 3 && !(processEditors[3] as ComboBox).Items.Contains(e.DisplayText)) ||
				(e.SubItem == 4 && !(processEditors[4] as ComboBox).Items.Contains(e.DisplayText)) ||
				(e.SubItem == 5 && !(processEditors[5] as ComboBox).Items.Contains(e.DisplayText)) ||
				(e.SubItem == 6 && !(processEditors[6] as ComboBox).Items.Contains(e.DisplayText)) ||
				(e.SubItem == 7 && !(processEditors[7] as ComboBox).Items.Contains(e.DisplayText)) ||
				(e.SubItem == 8 && !(processEditors[8] as ComboBox).Items.Contains(e.DisplayText)))
			{
				e.DisplayText = e.Item.SubItems[e.SubItem].Text;
				e.Cancel = true;
			}
		}

        #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;
			dataEntryComboBox.Enabled = true;
            metersKindRadioButton1.Enabled = true;
            metersKindRadioButton2.Enabled = true;
            resultsPrinterComboBox.Enabled = true;
			resultsWriterComboBox.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;
				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;
            }

			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,
            PurgeStart,
            PurgeEnd
        }

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

            selectedTab = (ProcedureTabs)tabControl.SelectedIndex;

			sharedButtons.SetEnabled(SharedButtons.Buttons.Add,
									 selectedTab == ProcedureTabs.Metrology1 ||
									 selectedTab == ProcedureTabs.Metrology2 ||
									 selectedTab == ProcedureTabs.Process    ||
									 selectedTab == ProcedureTabs.PurgeStart ||
									 selectedTab == ProcedureTabs.PurgeEnd);
 
			//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)
        {
			ListViewEx listViewEx;

			switch (selectedTab)
            {
				case ProcedureTabs.Metrology1:	listViewEx = metrology1ListViewEx; break;
				case ProcedureTabs.Metrology2:	listViewEx = metrology2ListViewEx; break;
				case ProcedureTabs.Process:		listViewEx = processListViewEx; 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);

			/// Run a create new test wizard
			TestWizard.FlowSelection flowDlg = new TestWizard.FlowSelection(test);
			TestWizard.MethodSelection methodDlg = new TestWizard.MethodSelection(test, TestMethods, metersPaths);
			TestWizard.VolumeAndErrorSelection volumeDlg = new TestWizard.VolumeAndErrorSelection(test);
			//TestWizard.SensorsSelection sensorsDlg = new TestWizard.SensorsSelection(test);

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

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

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

			/// Set few other parameters
			test.Repeats = 1;
			test.TolerRed = 0.2f;

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

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

				default: return;
            }

			/// Check the selected index validity
			if (listViewEx.SelectedItems.Count != 1) return;
			int removeItemNr = listViewEx.SelectedIndices[0];
			
			/// Remove the selected test
			Entities.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;

				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)
			Entities.Test test1 = LoadedProcedure.Tests[ix - 1];
			Entities.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)
		{
			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;

				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)
			Entities.Test test1 = LoadedProcedure.Tests[ix];
			Entities.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)
		{
			ListViewEx listViewEx = sender as 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);
			}
		}
	}
}