using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Globalization;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Net;
using System.Drawing.Printing;
using System.Diagnostics;
using System.Media;
using System.IO;
using System.Text.RegularExpressions;
using Ui.GenesisZeroFlow;

namespace Ui.GenesisZeroFlow
{
    public partial class MainWindows : Form
    {

        #region Global parameters
        private List<double>[][] AmplitudeValuesPositive = new List<double>[Constants.Core.NumberOfMeters][];
        private List<double>[][] AmplitudeValuesNegative { get; set; } = new List<double>[Constants.Core.NumberOfMeters][];
        public List<double>[][] TotalTimeOfFlightAverage { get; set; } = new List<double>[Constants.Core.NumberOfMeters][];
        private List<double>[][] DeltaTimeOfFlightAverage = new List<double>[Constants.Core.NumberOfMeters][];
        public string[] DataToLog { get; set; } = new string[Constants.Core.NumberOfMeters];
        public string[][] NumbersToLog = new string[Constants.Core.NumberOfMeters][];

        public bool[][] NewDataFlagZeroFlowTest = new bool[Constants.Core.NumberOfMeters][];
        public bool[] LoggingFlagZeroFlowTest = new bool[Constants.Core.NumberOfMeters];
        public bool[] CalculationFlagZeroFlowTest = new bool[Constants.Core.NumberOfMeters];
        public string[] LoggingPathZeroFlowTest = new string[Constants.Core.NumberOfMeters];
        private int[][] BadDataCounterZeroFlowTest = new int[Constants.Core.NumberOfMeters][];
        private int[][] LineCounterZeroFlowTest = new int[Constants.Core.NumberOfMeters][];

        public bool[][] NewDataFlagAmplitudeTest = new bool[Constants.Core.NumberOfMeters][];
        public bool[] StartLoggingFlagAmplitudeTest = new bool[Constants.Core.NumberOfMeters];
        public bool[] LoggingFlagAmplitudeTest = new bool[Constants.Core.NumberOfMeters];
        public string[] LoggingPathAmplitudeTest = new string[Constants.Core.NumberOfMeters];
        public int[][] LineCounterAmplitudeTest = new int[Constants.Core.NumberOfMeters][];


        public bool FirstTime = false;
        public bool AbortFlag = false;
        public bool WaitForTemperatureField = false;
        bool[] SerialPortOpenFlag = new bool[20] { false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false };
        #endregion
        #region register read back
        public int[][] ToFTempOffset = new int[Constants.Core.NumberOfMeters][];
        public int[][] ZeroFlowOffset = new int[Constants.Core.NumberOfMeters][];
        public int[][] FirstHitPercentage = new int[Constants.Core.NumberOfMeters][];
        public int[][] CalFactor = new int[Constants.Core.NumberOfMeters][];
        #endregion


        #region Decoded data parameters
        #region Mean values
        #endregion
        #endregion
        #region Serial port parameters
        List<byte>[] RxStringCmd = new List<byte>[Ui.GenesisZeroFlow.Constants.Core.NumberOfMeters];
        string[] RxStringData = new string[Ui.GenesisZeroFlow.Constants.Core.NumberOfMeters];
        #endregion
        #region Others
        // Declare the PrintDocument object.

        // private System.Drawing.Printing.PrintDocument docToPrint =
        //    new System.Drawing.Printing.PrintDocument();
        #endregion
        #region Initializations
        public GenesisZeroFlow()
        {

            #region Initialize component
            InitializeComponent();
            _GenesisZeroFlow = this;
            #endregion
            #region Initialize serial data list
            for (UInt16 Meter = 0; Meter < Constants.Core.NumberOfMeters; Meter++)
                RxStringCmd[Meter] = new List<byte>();
            #endregion

        }
        #endregion
        // #region Control elements
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2211:NonConstantFieldsShouldNotBeVisible")]
        public static GenesisZeroFlow _GenesisZeroFlow;
        private void Form1_FormOpening(Object sender, System.EventArgs e)
        {

            this.rTB_ZeroFlowCal.AutoSize = true;
            this.rTB_forDebugging.AutoSize = true;
            Display.AbortButtonEnabled(false);

            for (int i = 0; i < Ui.GenesisZeroFlow.Constants.Core.NumberOfMeters; i++)
            {
                NewDataFlagAmplitudeTest[i] = new bool[Ui.GenesisZeroFlow.Constants.Core.NumberOfMeters];
                TotalTimeOfFlightAverage[i] = new List<double>[Ui.GenesisZeroFlow.Constants.Core.NumberOfPaths];
                DeltaTimeOfFlightAverage[i] = new List<double>[Ui.GenesisZeroFlow.Constants.Core.NumberOfPaths];
                NewDataFlagZeroFlowTest[i] = new bool[Ui.GenesisZeroFlow.Constants.Core.NumberOfMeters];
                AmplitudeValuesPositive[i] = new List<double>[Ui.GenesisZeroFlow.Constants.Core.NumberOfPaths];
                AmplitudeValuesNegative[i] = new List<double>[Ui.GenesisZeroFlow.Constants.Core.NumberOfPaths];
                BadDataCounterZeroFlowTest[i] = new int[Ui.GenesisZeroFlow.Constants.Core.NumberOfMeters];
                LineCounterZeroFlowTest[i] = new int[Ui.GenesisZeroFlow.Constants.Core.NumberOfMeters];
                LineCounterAmplitudeTest[i] = new int[Ui.GenesisZeroFlow.Constants.Core.NumberOfMeters];
                ToFTempOffset[i] = new int[Ui.GenesisZeroFlow.Constants.Core.NumberOfPaths];
                ZeroFlowOffset[i] = new int[Ui.GenesisZeroFlow.Constants.Core.NumberOfPaths];
                FirstHitPercentage[i] = new int[Ui.GenesisZeroFlow.Constants.Core.NumberOfPaths];
                CalFactor[i] = new int[Ui.GenesisZeroFlow.Constants.Core.NumberOfPaths];
                CalculationFlagZeroFlowTest[i] = false;
                LoggingFlagZeroFlowTest[i] = false;
                LoggingPathZeroFlowTest[i] = string.Empty;
                StartLoggingFlagAmplitudeTest[i] = false;
                LoggingFlagAmplitudeTest[i] = false;
                NumbersToLog[i] = new string[Ui.GenesisZeroFlow.Constants.Core.NumberOfPaths];
            }


            for (int i = 0; i < Ui.GenesisZeroFlow.Constants.Core.NumberOfMeters; i++)
            {
                for (int j = 0; j < Ui.GenesisZeroFlow.Constants.Core.NumberOfPaths; j++)
                {
                    NewDataFlagAmplitudeTest[i][j] = new bool();
                    TotalTimeOfFlightAverage[i][j] = new List<double>();
                    DeltaTimeOfFlightAverage[i][j] = new List<double>();
                    NewDataFlagZeroFlowTest[i][j] = new bool();
                    AmplitudeValuesPositive[i][j] = new List<double>();
                    AmplitudeValuesNegative[i][j] = new List<double>();
                    BadDataCounterZeroFlowTest[i][j] = new int();
                    LineCounterZeroFlowTest[i][j] = new int();
                    LineCounterAmplitudeTest[i][j] = new int();
                    ToFTempOffset[i][j] = new int();
                    ZeroFlowOffset[i][j] = new int();
                    FirstHitPercentage[i][j] = new int();
                    CalFactor[i][j] = new int();

                }
            }
            #region Set initial images
            pB_ZeroFlowCal_Meter1.Image = pB_ZeroFlowCal_Meter1.InitialImage;
            pB_ZeroFlowCal_Meter2.Image = pB_ZeroFlowCal_Meter2.InitialImage;
            pB_ZeroFlowCal_Meter3.Image = pB_ZeroFlowCal_Meter3.InitialImage;
            pB_ZeroFlowCal_Meter4.Image = pB_ZeroFlowCal_Meter4.InitialImage;
            pB_ZeroFlowCal_Meter5.Image = pB_ZeroFlowCal_Meter5.InitialImage;
            pB_ZeroFlowCal_Meter6.Image = pB_ZeroFlowCal_Meter6.InitialImage;
            pB_ZeroFlowCal_Meter7.Image = pB_ZeroFlowCal_Meter7.InitialImage;
            pB_ZeroFlowCal_Meter8.Image = pB_ZeroFlowCal_Meter8.InitialImage;
            pB_ZeroFlowCal_Meter9.Image = pB_ZeroFlowCal_Meter9.InitialImage;
            pB_ZeroFlowCal_Meter10.Image = pB_ZeroFlowCal_Meter10.InitialImage;
            #endregion

            #region Set default culture
            CultureInfo culture = CultureInfo.CreateSpecificCulture("en-US");
            CultureInfo.DefaultThreadCurrentCulture = culture;
            CultureInfo.DefaultThreadCurrentUICulture = culture;
            #endregion
            #region Get date
            rTB_ReportEnterDate.Text = DateTime.Now.ToString(Formats.ReportDateTimeTitleString, culture);
            #endregion
            #region Set default tab
            tab_Maintab.TabPages.Remove(tab_Report);
            tab_Maintab.SelectedTab = tab_ZeroFlowCal;
            #endregion
            #region Tooltips
            #region Definitions and initializations
            ToolTip ToolTip1 = new ToolTip();
            #endregion
            #region Tool tip settings
            ToolTip1.AutoPopDelay = 5000;
            ToolTip1.InitialDelay = 100;
            ToolTip1.ReshowDelay = 500;
            ToolTip1.ShowAlways = true;
            #endregion
            #region Tool tip implementation
            #region Form1 Tool tips
            ToolTip1.SetToolTip(this.pB_Logo1, "www.sensus.com");
            #endregion
            #region Settings tool tips
            ToolTip1.SetToolTip(this.btn_ZeroFlowCal_Start, "Start sequence");
            ToolTip1.SetToolTip(this.rTB_PasswordMeter1, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot.");
            ToolTip1.SetToolTip(this.rTB_PasswordMeter2, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot.");
            ToolTip1.SetToolTip(this.rTB_PasswordMeter3, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot.");
            ToolTip1.SetToolTip(this.rTB_PasswordMeter4, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot.");
            ToolTip1.SetToolTip(this.rTB_PasswordMeter5, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot.");
            ToolTip1.SetToolTip(this.rTB_PasswordMeter6, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot.");
            ToolTip1.SetToolTip(this.rTB_PasswordMeter7, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot.");
            ToolTip1.SetToolTip(this.rTB_PasswordMeter8, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot.");
            ToolTip1.SetToolTip(this.rTB_PasswordMeter9, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot.");
            ToolTip1.SetToolTip(this.rTB_PasswordMeter10, "Enter hexadecimal password string!\nSkeleton key is send out on DATA\nCHANNEL after reboot.");
            ToolTip1.SetToolTip(this.nUD_Settings_AmplitudeTestLowerLimit, "Lower limit for calculated optimal point");
            ToolTip1.SetToolTip(this.nUD_Settings_AmplitudeTestUpperLimit, "Upper limit for calculated optimal point");
            ToolTip1.SetToolTip(this.nUD_PercentageStart, "Start value for percentage register sweep");
            ToolTip1.SetToolTip(this.nUD_PercentageStop, "Stop value for percentage register sweep");
            #endregion
            #endregion
            #endregion
            #region Application settings
            System.Diagnostics.Process.GetCurrentProcess().PriorityClass = System.Diagnostics.ProcessPriorityClass.RealTime;
            System.Runtime.GCSettings.LatencyMode = System.Runtime.GCLatencyMode.SustainedLowLatency;
            //System.Runtime.GCSettings.LatencyMode = System.Runtime.GCLatencyMode.LowLatency;
            //StartUpDisable = false; // to suppress checked change event of check boxes for switching between single and mass logging during start up
            #endregion

        }
        private void Form1_FormClosing(Object sender, FormClosingEventArgs e)
        {
            #region Definitions and initializations
            DateTime time = new DateTime();
            time = DateTime.Now;
            string TimeForHeader = time.ToString(Formats.RawDataDateTimeLogString, GlobalCulture);
            string TimeForFilename = time.ToString(Formats.LogFileDateTimeString, GlobalCulture);
            string Username = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
            string ClosingPath = DataLogging.DefaultPath + "GenesisZeroFlow_EventLogging_" + TimeForFilename + ".txt";
            string Header = "Filename = " + Path.GetFileName(ClosingPath) + "; User = " + Username + "; Date/Time = " + TimeForHeader + "\n";
            string Data = rTB_ZeroFlowCal.Text;
            #endregion
            #region Logfile
            Logging.WriteToFile(Header + Data, ClosingPath);
            #endregion

            Environment.Exit(0);
        }
        private void btn_ZeroFlowCal_Detect_Click(object sender, EventArgs e)
        {
            #region Definitions and initializations
            bool[] EnableOpening = new bool[Constants.Core.NumberOfMeters];
            bool[] OK = new bool[2 * Constants.Core.NumberOfMeters];
            bool[] SetToUnknownStatus = new bool[Constants.Core.NumberOfMeters];

            EnableOpening[Constants.Core.Meter1] = cB_ZeroFlowCal_EnableMeter1.Checked;
            EnableOpening[Constants.Core.Meter2] = cB_ZeroFlowCal_EnableMeter2.Checked;
            EnableOpening[Constants.Core.Meter3] = cB_ZeroFlowCal_EnableMeter3.Checked;
            EnableOpening[Constants.Core.Meter4] = cB_ZeroFlowCal_EnableMeter4.Checked;
            EnableOpening[Constants.Core.Meter5] = cB_ZeroFlowCal_EnableMeter5.Checked;
            EnableOpening[Constants.Core.Meter6] = cB_ZeroFlowCal_EnableMeter6.Checked;
            EnableOpening[Constants.Core.Meter7] = cB_ZeroFlowCal_EnableMeter7.Checked;
            EnableOpening[Constants.Core.Meter8] = cB_ZeroFlowCal_EnableMeter8.Checked;
            EnableOpening[Constants.Core.Meter9] = cB_ZeroFlowCal_EnableMeter9.Checked;
            EnableOpening[Constants.Core.Meter10] = cB_ZeroFlowCal_EnableMeter10.Checked;
            btn_ZeroFlowCal_Start.Enabled = false;
            Display.DebugCrcIndicatorVisible(false);
            AbortFlag = false;
            #endregion
            #region Bubbles
            pB_Bubbles1.Visible = true;
            #endregion


            if (LoginSequences.CheckIfNoMeterSelected(EnableOpening))
            {
                MessageBox.Show("No METER selected", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
                Display.StatusLabel("Press 'DETECT'");
                SetControlElements(true);
                return;
            }

            SetToUnknownStatus[Constants.Core.Meter1] = !cB_ZeroFlowCal_EnableMeter1.Checked;
            SetToUnknownStatus[Constants.Core.Meter2] = !cB_ZeroFlowCal_EnableMeter2.Checked;
            SetToUnknownStatus[Constants.Core.Meter3] = !cB_ZeroFlowCal_EnableMeter3.Checked;
            SetToUnknownStatus[Constants.Core.Meter4] = !cB_ZeroFlowCal_EnableMeter4.Checked;
            SetToUnknownStatus[Constants.Core.Meter5] = !cB_ZeroFlowCal_EnableMeter5.Checked;
            SetToUnknownStatus[Constants.Core.Meter6] = !cB_ZeroFlowCal_EnableMeter6.Checked;
            SetToUnknownStatus[Constants.Core.Meter7] = !cB_ZeroFlowCal_EnableMeter7.Checked;
            SetToUnknownStatus[Constants.Core.Meter8] = !cB_ZeroFlowCal_EnableMeter8.Checked;
            SetToUnknownStatus[Constants.Core.Meter9] = !cB_ZeroFlowCal_EnableMeter9.Checked;
            SetToUnknownStatus[Constants.Core.Meter10] = !cB_ZeroFlowCal_EnableMeter10.Checked;

            #region Visual indication 'PREPARE'
            string[] ListOfComports = SerialConfigGetReadSettings.PortNames();
            Display.SetProgressPanel(StatusPanelItems.Detect);
            Display.StatusLabel("Wait until DETECTION has finished");
            OK = DetectionSequence(EnableOpening);
            Display.ConnectionStatus(OK);
            SerialPortOpenFlag = OK;
            Display.ConnectionStatusReset(SetToUnknownStatus);
            #endregion

            Display.StatusLabel("Press 'START' or repeat 'DETECT'");
            btn_ZeroFlowCal_Start.Enabled = true;
            pB_Bubbles1.Visible = false;

        }
        private void SetControlElements(bool enabled)
        {
            if (enabled)
            {
                pB_Bubbles1.Visible = false;
                btn_ZeroFlowCal_Detect.Enabled = true;
                cB_ZeroFlowCal_EnableMeter1.Enabled = true;
                cB_ZeroFlowCal_EnableMeter2.Enabled = true;
                cB_ZeroFlowCal_EnableMeter3.Enabled = true;
                cB_ZeroFlowCal_EnableMeter4.Enabled = true;
                cB_ZeroFlowCal_EnableMeter5.Enabled = true;
                cB_ZeroFlowCal_EnableMeter6.Enabled = true;
                cB_ZeroFlowCal_EnableMeter7.Enabled = true;
                cB_ZeroFlowCal_EnableMeter8.Enabled = true;
                cB_ZeroFlowCal_EnableMeter9.Enabled = true;
                cB_ZeroFlowCal_EnableMeter10.Enabled = true;
                gB_Settings_AmplitudeTest.Enabled = true;
                gB_Settings_ZeroflowOffsetTest.Enabled = true;
                gB_Passwords.Enabled = true;
                gB_Settings_Preparation.Enabled = true;
                gB_Settings_TemperatureCalibration.Enabled = true;
                btn_ZeroFlowCal_Pdf.Enabled = true;
                btn_ZeroFlowCal_Save.Enabled = true;
                btn_ZeroFlowCal_Clear.Enabled = true;
                Display.AbortButtonEnabled(false);
                cB_AmplitudeTestEnable.Enabled = true;
                cB_TempCalEnable.Enabled = true;
                cB_ZeroFlowOffsetTestEnable.Enabled = true;

            }
            else
            {
                btn_ZeroFlowCal_Detect.Enabled = false;
                btn_ZeroFlowCal_Start.Enabled = false;
                cB_ZeroFlowCal_EnableMeter1.Enabled = false;
                cB_ZeroFlowCal_EnableMeter2.Enabled = false;
                cB_ZeroFlowCal_EnableMeter3.Enabled = false;
                cB_ZeroFlowCal_EnableMeter4.Enabled = false;
                cB_ZeroFlowCal_EnableMeter5.Enabled = false;
                cB_ZeroFlowCal_EnableMeter6.Enabled = false;
                cB_ZeroFlowCal_EnableMeter7.Enabled = false;
                cB_ZeroFlowCal_EnableMeter8.Enabled = false;
                cB_ZeroFlowCal_EnableMeter9.Enabled = false;
                cB_ZeroFlowCal_EnableMeter10.Enabled = false;
                gB_Settings_AmplitudeTest.Enabled = false;
                gB_Settings_ZeroflowOffsetTest.Enabled = false;
                gB_Passwords.Enabled = false;
                gB_Settings_Preparation.Enabled = false;
                gB_Settings_TemperatureCalibration.Enabled = false;
                btn_ZeroFlowCal_Pdf.Enabled = false;
                btn_ZeroFlowCal_Save.Enabled = false;
                btn_ZeroFlowCal_Clear.Enabled = false;
                Display.AbortButtonEnabled(true);
                cB_AmplitudeTestEnable.Enabled = false;
                cB_TempCalEnable.Enabled = false;
                cB_ZeroFlowOffsetTestEnable.Enabled = false;

            }
        }
        private void btn_ZeroFlowCal_Start_Click(object sender, EventArgs e)
        {
            pB_Bubbles1.Visible = true;

            #region Definitions and initializations
            const int DefaultNumberOfTrials = 15;


            System.IO.Ports.SerialPort[] ArrayOfSerialPorts = SerialConfigComportsToArray();

            string[] Password = new string[Constants.Core.NumberOfMeters];
            bool[] LoginEnable = new bool[Constants.Core.NumberOfMeters];
            bool[] PreparationEnable = new bool[Constants.Core.NumberOfMeters];
            bool[] AmplitudeEnable = new bool[Constants.Core.NumberOfMeters];
            bool[] ZeroFlowOffsetEnable = new bool[Constants.Core.NumberOfMeters];
            bool[] TempCalEnable = new bool[Constants.Core.NumberOfMeters];
            bool[] CompletionEnable = new bool[Constants.Core.NumberOfMeters];
            bool[] LoginFailed = new bool[Constants.Core.NumberOfMeters];
            bool[] PreparationFailed = new bool[Constants.Core.NumberOfMeters];
            bool[] AmplitudeFailed = new bool[Constants.Core.NumberOfMeters];
            bool[] ZeroFlowOffsetFailed = new bool[Constants.Core.NumberOfMeters];
            bool[] TempCalFailed = new bool[Constants.Core.NumberOfMeters];
            bool[] CompletionFailed = new bool[Constants.Core.NumberOfMeters];
            bool[] OK = new bool[Constants.Core.NumberOfMeters];
            bool[] EmptyPipeCheckEnable = new bool[Constants.Core.NumberOfMeters];
            bool[] EmptyPipeCheckFailed = new bool[Constants.Core.NumberOfMeters];
            bool[] MeterSelected = new bool[Constants.Core.NumberOfMeters];
            MeterSelected[Constants.Core.Meter1] = cB_ZeroFlowCal_EnableMeter1.Checked;
            MeterSelected[Constants.Core.Meter2] = cB_ZeroFlowCal_EnableMeter2.Checked;
            MeterSelected[Constants.Core.Meter3] = cB_ZeroFlowCal_EnableMeter3.Checked;
            MeterSelected[Constants.Core.Meter4] = cB_ZeroFlowCal_EnableMeter4.Checked;
            MeterSelected[Constants.Core.Meter5] = cB_ZeroFlowCal_EnableMeter5.Checked;
            MeterSelected[Constants.Core.Meter6] = cB_ZeroFlowCal_EnableMeter6.Checked;
            MeterSelected[Constants.Core.Meter7] = cB_ZeroFlowCal_EnableMeter7.Checked;
            MeterSelected[Constants.Core.Meter8] = cB_ZeroFlowCal_EnableMeter8.Checked;
            MeterSelected[Constants.Core.Meter9] = cB_ZeroFlowCal_EnableMeter9.Checked;
            MeterSelected[Constants.Core.Meter10] = cB_ZeroFlowCal_EnableMeter10.Checked;
            bool StopSequence = false;

            for (int Meter = 0; Meter < Constants.Core.NumberOfMeters; Meter++)
            {
                Password[Meter] = String.Empty;
                LoginEnable[Meter] = SerialPortOpenFlag[Meter] & SerialPortOpenFlag[Meter + Constants.Core.NumberOfMeters] & MeterSelected[Meter];
                PreparationEnable[Meter] = false;
                LoginFailed[Meter] = false;
                PreparationFailed[Meter] = false;
                AmplitudeFailed[Meter] = false;
                ZeroFlowOffsetFailed[Meter] = false;
                AmplitudeFailed[Meter] = false;
                CompletionFailed[Meter] = false;
                OK[Meter] = false;
                EmptyPipeCheckEnable[Meter] = false;
                EmptyPipeCheckFailed[Meter] = false;
            }
            #endregion


            #region Login
            AbortFlag = false;
            SetControlElements(false);
            Display.DebugCrcIndicatorVisible(false);
            Display.SetProgressPanel(StatusPanelItems.Prepare);

            if (LoginSequences.CheckIfNoMeterSelected(MeterSelected))
            {
                MessageBox.Show("No METER selected", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
                Display.StatusLabel("Press 'DETECT'");
                SetControlElements(true);

                return;
            }

            if (!LoginSequences.CheckIfPortFlagsValid(MeterSelected, SerialPortOpenFlag))
            {
                Display.StatusLabel("Press 'DETECT'");
                Display.AbortButtonEnabled(false);
                MessageBox.Show("Please repeat 'DETECT'", "Bad operation", MessageBoxButtons.OK, MessageBoxIcon.Error);
                SetControlElements(true);

                return;
            }
            #endregion
            #region Password check
            Display.StatusLabel("Wait until LOGIN has finished");
            if (LoginEnable[Constants.Core.Meter1])
            {
                if (Misc.OnlyHexInString(rTB_PasswordMeter1.Text) && (rTB_PasswordMeter1.Text.Count() == rTB_PasswordMeter1.MaxLength))
                    Password[Constants.Core.Meter1] = rTB_PasswordMeter1.Text;
                else
                {
                    Display.StatusLabel("Press 'DETECT'");
                    Display.SetProgressPanel(StatusPanelItems.None);
                    Display.AbortButtonEnabled(false);
                    MessageBox.Show("PASSWORD invalid at METER1", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    SetControlElements(true);

                    return;
                }
            }
            if (LoginEnable[Constants.Core.Meter2])
            {
                if (Misc.OnlyHexInString(rTB_PasswordMeter2.Text) && (rTB_PasswordMeter2.Text.Count() == rTB_PasswordMeter2.MaxLength))
                    Password[Constants.Core.Meter2] = rTB_PasswordMeter2.Text;
                else
                {
                    Display.StatusLabel("Press 'DETECT'");
                    Display.SetProgressPanel(StatusPanelItems.None);
                    Display.AbortButtonEnabled(false);
                    MessageBox.Show("PASSWORD invalid at METER2", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    SetControlElements(true);

                    return;
                }
            }
            if (LoginEnable[Constants.Core.Meter3])
            {
                if (Misc.OnlyHexInString(rTB_PasswordMeter3.Text) && (rTB_PasswordMeter3.Text.Count() == rTB_PasswordMeter3.MaxLength))
                    Password[Constants.Core.Meter3] = rTB_PasswordMeter3.Text;
                else
                {
                    Display.StatusLabel("Press 'DETECT'");
                    Display.SetProgressPanel(StatusPanelItems.None);
                    Display.AbortButtonEnabled(false);
                    MessageBox.Show("PASSWORD invalid at METER3", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    SetControlElements(true);

                    return;
                }
            }
            if (LoginEnable[Constants.Core.Meter4])
            {
                if (Misc.OnlyHexInString(rTB_PasswordMeter4.Text) && (rTB_PasswordMeter4.Text.Count() == rTB_PasswordMeter4.MaxLength))
                    Password[Constants.Core.Meter4] = rTB_PasswordMeter4.Text;
                else
                {
                    Display.StatusLabel("Press 'DETECT'");
                    Display.SetProgressPanel(StatusPanelItems.None);
                    Display.AbortButtonEnabled(false);
                    MessageBox.Show("PASSWORD invalid at METER4", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    SetControlElements(true);

                    return;
                }
            }
            if (LoginEnable[Constants.Core.Meter5])
            {
                if (Misc.OnlyHexInString(rTB_PasswordMeter5.Text) && (rTB_PasswordMeter5.Text.Count() == rTB_PasswordMeter5.MaxLength))
                    Password[Constants.Core.Meter5] = rTB_PasswordMeter5.Text;
                else
                {
                    Display.StatusLabel("Press 'DETECT'");
                    Display.SetProgressPanel(StatusPanelItems.None);
                    Display.AbortButtonEnabled(false);
                    MessageBox.Show("PASSWORD invalid at METER5", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    SetControlElements(true);

                    return;
                }
            }
            if (LoginEnable[Constants.Core.Meter6])
            {
                if (Misc.OnlyHexInString(rTB_PasswordMeter6.Text) && (rTB_PasswordMeter6.Text.Count() == rTB_PasswordMeter6.MaxLength))
                    Password[Constants.Core.Meter6] = rTB_PasswordMeter6.Text;
                else
                {
                    Display.StatusLabel("Press 'DETECT'");
                    Display.SetProgressPanel(StatusPanelItems.None);
                    Display.AbortButtonEnabled(false);
                    MessageBox.Show("PASSWORD invalid at METER6", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    SetControlElements(true);

                    return;
                }
            }
            if (LoginEnable[Constants.Core.Meter7])
            {
                if (Misc.OnlyHexInString(rTB_PasswordMeter7.Text) && (rTB_PasswordMeter7.Text.Count() == rTB_PasswordMeter7.MaxLength))
                    Password[Constants.Core.Meter7] = rTB_PasswordMeter7.Text;
                else
                {

                    Display.StatusLabel("Press 'DETECT'");
                    Display.SetProgressPanel(StatusPanelItems.None);
                    Display.AbortButtonEnabled(false);
                    MessageBox.Show("PASSWORD invalid at METER7", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    SetControlElements(true);

                    return;
                }
            }
            if (LoginEnable[Constants.Core.Meter8])
            {
                if (Misc.OnlyHexInString(rTB_PasswordMeter8.Text) && (rTB_PasswordMeter8.Text.Count() == rTB_PasswordMeter8.MaxLength))
                    Password[Constants.Core.Meter8] = rTB_PasswordMeter8.Text;
                else
                {
                    Display.StatusLabel("Press 'DETECT'");
                    Display.SetProgressPanel(StatusPanelItems.None);
                    Display.AbortButtonEnabled(false);
                    MessageBox.Show("PASSWORD invalid at METER8", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    SetControlElements(true);

                    return;
                }
            }
            if (LoginEnable[Constants.Core.Meter9])
            {
                if (Misc.OnlyHexInString(rTB_PasswordMeter9.Text) && (rTB_PasswordMeter9.Text.Count() == rTB_PasswordMeter9.MaxLength))
                    Password[Constants.Core.Meter9] = rTB_PasswordMeter9.Text;
                else
                {
                    Display.StatusLabel("Press 'DETECT'");
                    Display.SetProgressPanel(StatusPanelItems.None);
                    Display.AbortButtonEnabled(false);
                    MessageBox.Show("PASSWORD invalid at METER9", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    SetControlElements(true);

                    return;
                }
            }
            if (LoginEnable[Constants.Core.Meter10])
            {
                if (Misc.OnlyHexInString(rTB_PasswordMeter10.Text) && (rTB_PasswordMeter10.Text.Count() == rTB_PasswordMeter10.MaxLength))
                    Password[Constants.Core.Meter10] = rTB_PasswordMeter10.Text;
                else
                {

                    Display.StatusLabel("Press 'DETECT'");
                    Display.SetProgressPanel(StatusPanelItems.None);
                    Display.AbortButtonEnabled(false);
                    MessageBox.Show("PASSWORD invalid at METER10", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    SetControlElements(true);

                    return;
                }
            }
            #endregion
            #region Login
            //Login:
            bool Aborted = false;
            LoginFailed = LoginSequences.Total(LoginEnable, ArrayOfSerialPorts, ref CommandInterfaceTotal, Password, DefaultNumberOfTrials, out Aborted);
            pB_Bubbles1.Visible = false;
            OK = DisplayGetSequenceResult(LoginEnable, LoginFailed, "LOGIN sequence", out StopSequence, Aborted);
            Display.MeterStatusGreenRed(OK, LoginEnable);
            if (StopSequence)
            {
                Display.SetProgressPanel(StatusPanelItems.None);
                GenesisZeroFlow.Display.AbortButtonEnabled(false);
                CloseComportsSequence();
                SetControlElements(true);
                return;
            }
            #endregion
            //goto skippreperation;
            #region Preparation
            //Preparation:
            if (GenesisZeroFlow._GenesisZeroFlow.AbortFlag == false)
            {
                PreparationEnable = OK;
                Display.SetProgressPanel(StatusPanelItems.Prepare);
                Display.DebugMessage("APPLICATION:\t\t PREPARATION sequence started\n");
                Display.StatusLabel("Wait until PREPARATION has finished");
            }
            else
            {
                Display.DebugMessage("APPLICATION:\t\t PREPARATION sequence aborted\n");
                Display.DebugMessage(Debugmessages.Line);
                Display.StatusLabel("Press 'DETECT'");
                Display.DebugCrcIndicatorVisible(false);
                Display.AbortButtonEnabled(false);
                CloseComportsSequence();
                MessageBox.Show("ZEROFLOW CALIBRATION sequence aborted", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
                SetControlElements(true);

                return;
            }
            PreparationFailed = PreparationSequences.Total(PreparationEnable, ArrayOfSerialPorts, CommandInterfaceTotal, Password, DefaultNumberOfTrials, out Aborted, GlobalCulture);
            OK = DisplayGetSequenceResult(PreparationEnable, PreparationFailed, "PREPARATION sequence", out StopSequence, Aborted);
            Display.MeterStatusGreenRed(OK, PreparationEnable);
            if (StopSequence)
            {
                Display.SetProgressPanel(StatusPanelItems.None);
                Display.DebugCrcIndicatorVisible(false);
                Display.AbortButtonEnabled(false);
                CloseComportsSequence();
                SetControlElements(true);

                return;
            }
            #region Empty pipe mode check
            Display.DebugMessage("APPLICATION:\t\t EMPTY PIPE CHECK sequence started\n");
            EmptyPipeCheckEnable = OK;
            EmptyPipeCheckFailed = EmptyPipeCheckSequence(EmptyPipeCheckEnable, out Aborted);
            OK = DisplayGetSequenceResult(EmptyPipeCheckEnable, EmptyPipeCheckFailed, "EMPTY PIPE CHECK sequence", out StopSequence, Aborted);
            Display.MeterStatusGreenRed(OK, LoginEnable);
            if (StopSequence)
            {
                Display.SetProgressPanel(StatusPanelItems.None);
                Display.DebugCrcIndicatorVisible(false);
                Display.AbortButtonEnabled(false);
                CloseComportsSequence();
                SetControlElements(true);

                return;
            }
            Display.ShowResultStatus("EMPTY PIPE CHECK: ", OK);
            #endregion
            #region Wait for two minutes
            Display.WaitForStabilization(OK, StopSequence, (int)nUD_Settings_Preparation_StabiTime.Value, out Aborted);
            OK = DisplayGetSequenceResult(EmptyPipeCheckEnable, EmptyPipeCheckFailed, "WAIT FOR STABILIZATION sequence", out StopSequence, Aborted);
            Display.MeterStatusGreenRed(OK, LoginEnable);
            if (StopSequence)
            {
                Display.SetProgressPanel(StatusPanelItems.None);
                Display.DebugCrcIndicatorVisible(false);
                Display.AbortButtonEnabled(false);
                CloseComportsSequence();
                SetControlElements(true);
                return;
            }
            #endregion
            #endregion
            #region Bubbles
            pB_Bubbles1.Visible = true;
            Misc.WaitNSeconds(1);
            pB_Bubbles1.Visible = false;
            #endregion
            #region Skip amplitude test (Don't care that 'goto' is not MISRA compliant)
            if (!cB_AmplitudeTestEnable.Checked)
                goto ZeroFlowOffsetTest;
            #endregion
            #region Amplitude test
            //Amptest:
            if (GenesisZeroFlow._GenesisZeroFlow.AbortFlag == false)
            {
                AmplitudeEnable = OK;
                Display.SetProgressPanel(StatusPanelItems.Amplitude);
                Display.DebugMessage("APPLICATION:\t\t AMPLITUDE TEST sequence started\n");
                Display.StatusLabel("Wait until AMPLITUDE TEST has finished");
                Display.ShowResultStatus("Enable AMPLITUDE TEST sequence", AmplitudeEnable);
                Display.DebugCrcIndicatorVisible(true);
            }
            else
            {
                Display.DebugCrcIndicatorVisible(false);
                Display.StatusLabel("Press 'DETECT'");
                Display.DebugMessage("APPLICATION:\t\t ZEROFLOW CALIBRATION sequence aborted\n");
                Display.DebugMessage(Debugmessages.Line);
                Display.AbortButtonEnabled(false);
                CloseComportsSequence();
                MessageBox.Show("ZEROFLOW CALIBRATION sequence aborted", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
                SetControlElements(true);

                return;
            }
            AmplitudeFailed = AmplitudeSequences.Total(AmplitudeEnable, ArrayOfSerialPorts, CommandInterfaceTotal, Password, DefaultNumberOfTrials, (int)nUD_PercentageStart.Value, (int)nUD_PercentageStop.Value, (int)nUD_Settings_AmplitudeTestLowerLimit.Value, (int)nUD_Settings_AmplitudeTestUpperLimit.Value, (int)nUD_Settings_AmplitudeTestMinDistance.Value, out Aborted);
            Display.ShowResultStatus("AMPLITUDE TEST failed: ", AmplitudeFailed);

            OK = DisplayGetSequenceResult(AmplitudeEnable, AmplitudeFailed, "AMPLITUDE TEST sequence", out StopSequence, Aborted);
            Display.MeterStatusGreenRed(OK, AmplitudeEnable);
            if (StopSequence)
            {
                Display.SetProgressPanel(StatusPanelItems.None);
                Display.DebugCrcIndicatorVisible(false);
                Display.AbortButtonEnabled(false);
                CloseComportsSequence();
                SetControlElements(true);

                return;
            }
            #endregion
            #region Zero flow offset tests
            #region Skip Offset test (Don't care that 'goto' is not MISRA compliant)
            ZeroFlowOffsetTest:
            if (!cB_ZeroFlowOffsetTestEnable.Checked)
                goto Tempcal;
            #endregion
            if (GenesisZeroFlow._GenesisZeroFlow.AbortFlag == false)
            {
                ZeroFlowOffsetEnable = OK;
                Display.ShowResultStatus("Zeroflow offset test enable = ", ZeroFlowOffsetEnable);
                Display.SetProgressPanel(StatusPanelItems.Offset);
                Display.DebugMessage("APPLICATION:\t\t ZEROFLOW OFFSET TEST sequence started\n");
                Display.StatusLabel("Wait until ZEROFLOW OFFSET TEST has finished");
            }
            else
            {
                Display.StatusLabel("Press 'DETECT'");
                Display.DebugCrcIndicatorVisible(false);
                Display.AbortButtonEnabled(false);
                CloseComportsSequence();
                MessageBox.Show("ZEROFLOW CALIBRATION sequence aborted", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
                SetControlElements(true);

                return;
            }
            ZeroFlowOffsetFailed = ZeroOffsetSequences.Total(ZeroFlowOffsetEnable, ArrayOfSerialPorts, CommandInterfaceTotal, Password, DefaultNumberOfTrials, (int)nUD_Settings_ZeroflowOffsetTestSettlingTime.Value, (Int16)nUD_Settings_ZeroflowOffsetTestLowerLimit.Value, (Int16)nUD_Settings_ZeroflowOffsetTestUpperLimit.Value, (int)nUD_Settings_ZeroflowOffsetTestOffsetLimit.Value, (int)nUD_Settings_ZeroflowOffsetTestNumberOfLines.Value, out Aborted, GlobalCulture);
            OK = DisplayGetSequenceResult(ZeroFlowOffsetEnable, ZeroFlowOffsetFailed, "ZEROFLOW OFFSET TEST sequence", out StopSequence, Aborted);
            Display.MeterStatusGreenRed(OK, ZeroFlowOffsetEnable);
            if (StopSequence)
            {
                Display.SetProgressPanel(StatusPanelItems.None);
                Display.DebugCrcIndicatorVisible(false);
                Display.AbortButtonEnabled(false);
                CloseComportsSequence();
                SetControlElements(true);

                return;
            }
            #endregion
            #region Bubbles
            pB_Bubbles1.Visible = true;
            Misc.WaitNSeconds(1);
            pB_Bubbles1.Visible = false;
            #endregion
            #region Temperature calibration
            #region Skip temperature calibration (Hello Mr. Reviewer, don't care that 'goto' is not MISRA compliant!)
            Tempcal:
            if (!cB_TempCalEnable.Checked)
                goto Completion;
            #endregion

            if (GenesisZeroFlow._GenesisZeroFlow.AbortFlag == false)
            {

                TempCalEnable = OK;
                Display.SetProgressPanel(StatusPanelItems.TempCal);
                Display.DebugMessage("APPLICATION:\t\t TEMPERATURE CALIBRATION sequence started\n");
                Display.StatusLabel("Wait until TEMPERATURE CALIBRATION has finished");
                Display.ShowResultStatus("Enable TEMPERATURE CALIBRATION sequence", TempCalEnable);
                Display.DebugCrcIndicatorVisible(true);
                Display.TemperatureField();
                while (WaitForTemperatureField) { Misc.WaitNSeconds(1); }

            }
            else
            {
                Display.DebugCrcIndicatorVisible(false);
                Display.StatusLabel("Press 'DETECT'");
                Display.DebugMessage("APPLICATION:\t\t ZEROFLOW CALIBRATION sequence aborted\n");
                Display.DebugMessage(Debugmessages.Line);
                Display.AbortButtonEnabled(false);
                CloseComportsSequence();
                MessageBox.Show("ZEROFLOW CALIBRATION sequence aborted", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
                SetControlElements(true);

                return;
            }

            TempCalFailed = TempCalibrationSequences.Total(TempCalEnable, ArrayOfSerialPorts, CommandInterfaceTotal, Password, DefaultNumberOfTrials, out Aborted);
            Display.ShowResultStatus("TEMPERATURE CALIBRATION failed: ", TempCalFailed);

            OK = DisplayGetSequenceResult(TempCalEnable, TempCalFailed, "TEMPERATURE CALIBRATION sequence", out StopSequence, Aborted);
            Display.MeterStatusGreenRed(OK, TempCalEnable);
            if (StopSequence)
            {
                Display.SetProgressPanel(StatusPanelItems.None);
                Display.DebugCrcIndicatorVisible(false);
                Display.AbortButtonEnabled(false);
                CloseComportsSequence();
                SetControlElements(true);

                return;
            }
            #endregion
            #region Bubbles
            pB_Bubbles1.Visible = true;
            Misc.WaitNSeconds(1);
            pB_Bubbles1.Visible = false;
            #endregion
            #region Completion
            Completion:
            if (GenesisZeroFlow._GenesisZeroFlow.AbortFlag == false)
            {
                CompletionEnable = OK;
                Display.ShowResultStatus("CompletionEnable = ", CompletionEnable);
                Display.SetProgressPanel(StatusPanelItems.Completion);
                Display.DebugMessage("APPLICATION:\t\t COMPLETION sequence started\n");
                Display.StatusLabel("Wait until COMPLETION has finished");
                Display.DebugCrcIndicatorVisible(false);

            }
            else
            {
                Display.DebugMessage("APPLICATION:\t\t ZEROFLOW CALIBRATION sequence aborted\n");
                Display.DebugMessage(Debugmessages.Line);
                Display.StatusLabel("Press 'DETECT'");
                Display.DebugCrcIndicatorVisible(false);
                Display.AbortButtonEnabled(false);
                CloseComportsSequence();
                MessageBox.Show("ZEROFLOW CALIBRATION sequence aborted", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
                SetControlElements(true);

                return;
            }
            CompletionFailed = CompletionSequences.Total(CompletionEnable, ArrayOfSerialPorts, CommandInterfaceTotal, Password, DefaultNumberOfTrials, out Aborted);
            OK = DisplayGetSequenceResult(CompletionEnable, CompletionFailed, "COMPLETION sequence", out StopSequence, Aborted);
            Display.MeterStatusGreenRed(OK, CompletionEnable);
            if (StopSequence)
            {
                Display.SetProgressPanel(StatusPanelItems.None);
                Display.StatusLabel("Press 'DETECT'");
                Display.DebugCrcIndicatorVisible(false);
                Display.DebugMessage("APPLICATION:\t\t ZEROFLOW CALIBRATION sequence failed\n");
                Display.DebugMessage(Debugmessages.Line);
                Display.AbortButtonEnabled(false);
                CloseComportsSequence();
                MessageBox.Show("ZEROFLOW CALIBRATION sequence failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
                SetControlElements(true);

                return;
            }

            Display.DebugMessage("APPLICATION:\t\t ZEROFLOW CALIBRATION sequence succesful\n");
            Display.DebugMessage(Debugmessages.Line);
            Display.AbortButtonEnabled(false);
            CloseComportsSequence();
            MessageBox.Show("ZEROFLOW CALIBRATION sequence successful", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Information);
            Display.StatusLabel("Press 'DETECT'");
            SetControlElements(true);
            #endregion
            #region Bubbles
            pB_Bubbles1.Visible = true;
            Misc.WaitNSeconds(1);
            pB_Bubbles1.Visible = false;
            #endregion
        }
        private void btn_ZeroFlowCal_Abort_Click(object sender, EventArgs e)
        {
            DialogResult AskForActions = DialogResult.None;

            Display.AbortButtonEnabled(false);
            AskForActions = MessageBox.Show("Are you sure?", "Form closing", MessageBoxButtons.OKCancel, MessageBoxIcon.Error);
            if (AskForActions == DialogResult.OK)
            {
                AbortFlag = true;
            }
            else
            {
                AbortFlag = false;
                Display.AbortButtonEnabled(true);
            }
        }
        private void btn_ZeroFlowCal_Clear_Click(object sender, EventArgs e)
        {
            #region Bubbles
            pB_Bubbles1.Visible = true;
            Misc.WaitNSeconds(1);
            pB_Bubbles1.Visible = false;
            #endregion
            rTB_ZeroFlowCal.Clear();
        }
        private void btn_ZeroFlowCal_Save_Click(object sender, EventArgs e)
        {
            #region Definitions and initializations
            string SaveDataPathRaw = string.Empty;
            bool RawDialogOK = false;
            string Username = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
            string ClosingPath = DataLogging.DefaultPath;// + "GenesisZeroFlow_EventLogging_" + TimeForFilename + ".txt";
            string TimeForHeader = string.Empty;

            #endregion
            #region Bubbles
            pB_Bubbles1.Visible = true;
            Misc.WaitNSeconds(1);
            pB_Bubbles1.Visible = false;
            #endregion
            #region Logfile
            try
            {
                RawDialogOK = Files.SaveFiledialogTxt("txt", out SaveDataPathRaw, ClosingPath, out TimeForHeader);
                if (RawDialogOK)
                {
                    string Data = rTB_ZeroFlowCal.Text;
                    string Header = "Filename = " + Path.GetFileName(SaveDataPathRaw) + "; User = " + Username + "; Date/Time = " + TimeForHeader + "; SW-version: " + l_Version.Text + "\n";
                    Logging.WriteToFile(Header + Data, SaveDataPathRaw);
                }
            }
            catch (Exception ex)
            {
                ErrorLog.Log(LogErrReason.Exeption, "btn_ZeroFlowCal_Save_Click() failed", "0x" + ex.HResult.ToString("X", GlobalCulture), string.Empty);
                MessageBox.Show("Log file storage failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            #endregion
        }
        private void btn_ZeroFlowCal_Pdf_Click(object sender, EventArgs e)
        {
            #region Definitions and initializations
            string SaveDataPathPdf = string.Empty;
            bool RawDialogOK = false;
            string Username = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
            string ClosingPath = DataLogging.DefaultPath;
            string TimeForHeader = string.Empty;
            XImage Logo = pB_Logo1.Image;
            PdfDocument LogReport = new PdfDocument();
            LogReport.Info.Title = "GENESIS Zeroflow calibration tool logfile";
            LogReport.Info.Author = Username;
            #endregion
            #region Bubbles
            pB_Bubbles1.Visible = true;
            Misc.WaitNSeconds(1);
            pB_Bubbles1.Visible = false;
            #endregion
            #region Logfile
            try
            {
                RawDialogOK = Files.SaveFiledialogPdf(out SaveDataPathPdf, ClosingPath, out TimeForHeader);
                if (RawDialogOK)
                {
                    string Data = rTB_ZeroFlowCal.Text;
                    string Header = "Filename = " + Path.GetFileName(SaveDataPathPdf) + ";\nUser = " + Username + ";\nDate/Time = " + TimeForHeader + "\nSW-version: " + l_Version.Text + "\n\n";
                    ReportPages.Logfile(Header + Data, LogReport, Logo);
                    Files.SavePdf(LogReport, SaveDataPathPdf);
                }
            }
            catch (Exception ex)
            {
                ErrorLog.Log(LogErrReason.Exeption, "btn_ZeroFlowCal_Pdf_Click() failed", "0x" + ex.HResult.ToString("X", GlobalCulture), string.Empty);
                MessageBox.Show("PDF log file storage failed", "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }


        }
        #endregion


        public void EnableMaintab()
        {
            tab_Maintab.Enabled = true;
        }

        public List<double>[] GetAmplitudeValuesPositive(int meterNumber)
        {
            List<double>[] data = new List<double>[Constants.Core.NumberOfPaths];
            data = AmplitudeValuesPositive[meterNumber];

            return data;
        }
        public void ClearAmplitudeValuesPositive(int meterNumber)
        {

            if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
            {
                GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<int>)ClearAmplitudeValuesPositive, meterNumber);
                return;
            }

            AmplitudeValuesPositive[meterNumber][Constants.Core.PATH0].Clear();
            AmplitudeValuesPositive[meterNumber][Constants.Core.PATH1].Clear();
            AmplitudeValuesPositive[meterNumber][Constants.Core.PATH2].Clear();
            // Display.DebugMessage("Positive Amplitudenwerte = " + AmplitudeValuesPositive[meterNumber][Constants.Core.PATH0].Count().ToString(culture) + "\n");

        }
        public void ClearAmplitudeValuesNegative(int meterNumber)
        {

            if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
            {
                GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<int>)ClearAmplitudeValuesNegative, meterNumber);
                return;
            }

            AmplitudeValuesNegative[meterNumber][Constants.Core.PATH0].Clear();
            AmplitudeValuesNegative[meterNumber][Constants.Core.PATH1].Clear();
            AmplitudeValuesNegative[meterNumber][Constants.Core.PATH2].Clear();
            // Display.DebugMessage("Negative Amplitudenwerte = " + AmplitudeValuesNegative[meterNumber][Constants.Core.PATH0].Count().ToString(culture) + "\n");

        }
        public List<double>[] GetAmplitudeValuesNegative(int meterNumber)
        {
            List<double>[] data = new List<double>[Constants.Core.NumberOfPaths];


            data = AmplitudeValuesNegative[meterNumber];

            return data;
        }
        public void ClearBadDataCounter(int meterNumber)
        {

            if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
            {
                GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<int>)ClearBadDataCounter, meterNumber);
                return;
            }

            BadDataCounterZeroFlowTest[meterNumber][Constants.Core.PATH0] = 0;
            BadDataCounterZeroFlowTest[meterNumber][Constants.Core.PATH1] = 0;
            BadDataCounterZeroFlowTest[meterNumber][Constants.Core.PATH2] = 0;
            // Display.DebugMessage("Schlechtdatenzaehler = " + BadDataCounterZeroFlowTest[meterNumber][Constants.Core.PATH0] +  "\n");

        }
        public int[] GetBadDataCounter(int meterNumber)
        {
            int[] BadData = new int[Constants.Core.NumberOfPaths];


            BadData[Constants.Core.PATH0] = BadDataCounterZeroFlowTest[meterNumber][Constants.Core.PATH0];
            BadData[Constants.Core.PATH1] = BadDataCounterZeroFlowTest[meterNumber][Constants.Core.PATH1];
            BadData[Constants.Core.PATH2] = BadDataCounterZeroFlowTest[meterNumber][Constants.Core.PATH2];

            return BadData;
        }
        public void ClearLineCounterZeroFlow(int meterNumber)
        {

            if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
            {
                GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<int>)ClearLineCounterZeroFlow, meterNumber);
                return;
            }

            LineCounterZeroFlowTest[meterNumber][Constants.Core.PATH0] = 0;
            LineCounterZeroFlowTest[meterNumber][Constants.Core.PATH1] = 0;
            LineCounterZeroFlowTest[meterNumber][Constants.Core.PATH2] = 0;
            // Display.DebugMessage("Linienzähler = " + LineCounterZeroFlowTest[meterNumber][Constants.Core.PATH0] + "\n");

        }
        public int[] GetLineCounterZeroFlow(int meterNumber)
        {
            int[] Linecounter = new int[Constants.Core.NumberOfPaths];


            Linecounter[Constants.Core.PATH0] = LineCounterZeroFlowTest[meterNumber][Constants.Core.PATH0];
            Linecounter[Constants.Core.PATH1] = LineCounterZeroFlowTest[meterNumber][Constants.Core.PATH1];
            Linecounter[Constants.Core.PATH2] = LineCounterZeroFlowTest[meterNumber][Constants.Core.PATH2];

            return Linecounter;
        }
        public void ClearDeltaTimeOfFlightAverage(int meterNumber)
        {

            if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
            {
                GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<int>)ClearDeltaTimeOfFlightAverage, meterNumber);
                return;
            }

            DeltaTimeOfFlightAverage[meterNumber][Constants.Core.PATH0].Clear();
            DeltaTimeOfFlightAverage[meterNumber][Constants.Core.PATH1].Clear();
            DeltaTimeOfFlightAverage[meterNumber][Constants.Core.PATH2].Clear();
            // Display.DebugMessage("Delta time of flight durchschnitt = " + DeltaTimeOfFlightAverage[meterNumber][Constants.Core.PATH0].Count().ToString(GlobalCulture) + "\n");

        }

        public List<double>[] GetDeltaTimeOfFlightAverage(int meterNumber)
        {
            List<double>[] Data = new List<double>[Constants.Core.NumberOfPaths];


            Data = DeltaTimeOfFlightAverage[meterNumber];


            return Data;
        }


    }

}