using System;
using System.Drawing;
using System.Linq;
using System.Globalization;
using System.Windows.Forms;


namespace GenesisZeroFlow
{
    public partial class GenesisZeroFlow : Form
    {
        public void StopMainSequence(String message, MessageBoxIcon icon, CultureInfo culture)
        {
            Display.SetProgressPanel(StatusPanelItems.None);
            Display.AbortButtonEnabled(false);
            Display.SetControlElements(true);
            Display.StatusLabel(PredefinedMessages.PressDetect(culture));
            MessageBox.Show(message, "Form closing", MessageBoxButtons.OK, icon); // "'ZEROFLOW CALIBRATION' sequence stopped"
            Display.SetThermoLabel1("THERMO1");
            Display.SetThermoLabel2("THERMO2");
        }

        public void ZeroFlowCalDetectSetBackColor(Color color)
        {
            GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Detect.BackColor = color;
        }
        public void ZeroFlowCalAmplitudeSetBackColor(Color color)
        {
            GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Amplitude.BackColor = color;
        }
        public void ZeroFlowCalPrepareSetBackColor(Color color)
        {
            GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Prepare.BackColor = color;
        }
        public void ZeroFlowCalOffsetSetBackColor(Color color)
        {
            GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Offset.BackColor = color;
        }
        public void ZeroFlowCalCompletionSetBackColor(Color color)
        {
            GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Completion.BackColor = color;
        }
        public void ZeroFlowCalTempCalSetBackColor(Color color)
        {
            GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_TempCal.BackColor = color;
        }
        public void ZeroFlowCalDetectSetLabelColor(Color color)
        {
            GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Detect.ForeColor = color;
        }
        public void ZeroFlowCalAmplitudeSetLabelColor(Color color)
        {
            GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Amplitude.ForeColor = color;
        }
        public void ZeroFlowCalPrepareSetLabelColor(Color color)
        {
            GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Prepare.ForeColor = color;
        }
        public void ZeroFlowCalOffsetSetLabelColor(Color color)
        {
            GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Offset.ForeColor = color;
        }
        public void ZeroFlowCalCompletionSetLabelColor(Color color)
        {
            GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Completion.ForeColor = color;
        }
        public void ZeroFlowCalTempCalSetLabelColor(Color color)
        {
            GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_TempCal.ForeColor = color;
        }


        public static class PredefinedMessages
        {
            #region Miscellaneous
            public static String StorageFailed(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Speichern fehlgeschlagen";
                else
                    Message = "Storage failed";

                return Message;
            }
            public static String MeterSequenceFailed(String sequenceName, String MeterIndex, CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = $"{sequenceName} fehlgeschlagen bei ZÄHLER{MeterIndex}";
                else
                    Message = $"{sequenceName} failed at METER{MeterIndex}";

                return Message;
            }
            public static String AreYouSure(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Sind Sie sicher?";
                else
                    Message = "Are you sure?";

                return Message;
            }
            public static String PressDetect(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "'DETEKT'-Taste drücken";
                else
                    Message = "Press 'DETECT'";

                return Message;
            }
            public static String WaitDetect(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Warten bis 'DETEKT' beendet";
                else
                    Message = "Wait until 'DETECTION' has finished";

                return Message;
            }
            public static String WaitSeconds(Int32 seconds, CultureInfo culture)
            {
                String Message = String.Empty;
                String Time = seconds.ToString(culture);
                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = $"Wartezeit {Time} Sekunden";
                else
                    Message = $"Wait {Time} seconds";

                return Message;
            }
            public static String DetectFailed(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "'DETEKT' fehlgeschlagen";
                else
                    Message = "'DETECT' failed";

                return Message;
            }
            public static String PressStartOrDetect(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "'START'-Taste drücken oder 'DETEKT' wiederholen";
                else
                    Message = "Press 'START' or repeat 'DETECT'";

                return Message;
            }
            public static String NoMeterSelected(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Keinen ZÄHLER ausgewählt";
                else
                    Message = "No METER selected";

                return Message;
            }
            public static String NoMeterPresent(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Kein ZÄHLER bereit";
                else
                    Message = "No METER present";

                return Message;
            }
            public static String NoThermometerPresent(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Kein THERMOMETER bereit";
                else
                    Message = "No THERMOMETER present";

                return Message;
            }
            public static String WaitUntilTemperatureAcquisitionFinished(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Warten bis Temperaturakquirierung beendet";
                else
                    Message = "Wait until temperature acquisition finished";

                return Message;
            }
            public static String WaitUntilTemperatureCalibrationFinished(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Warten bis Temperaturkalibrierung beendet";
                else
                    Message = "Wait until temperature calibration finished";

                return Message;
            }
            public static String NoThermometerSelected(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Kein Thermometer ausgewählt";
                else
                    Message = "No THERMOMETER selected";

                return Message;
            }
            public static String WaitForStabilization(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Warten bis Werte stabil: ";
                else
                    Message = "Wait for stabilization: ";

                return Message;
            }
            #endregion
            #region Empty pipe mode
            public static String WaitForEmptyPipe(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Warten bis 'EMPTY PIPE'-Modus beendet: ";
                else
                    Message = "Wait for leaving 'EMPTY PIPE' mode: ";

                return Message;
            }
            public static String EmptyPipeFailed(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "'EMPTY PIPE'-check fehlgeschlagen";
                else
                    Message = "'EMPTY PIPE'-check failed";

                return Message;
            }
            #endregion
            #region LOGIN
            public static String WaitUntilLoginFinished(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Warten bis 'LOGIN' beendet";
                else
                    Message = "Wait until 'LOGIN' has finished";

                return Message;
            }
            public static String LoginFailed(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "'LOGIN'-fehlgeschlagen";
                else
                    Message = "'LOGIN'-failed";

                return Message;
            }
            #endregion
            #region PREPARATION
            public static String WaitUntilPreparationFinished(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Warten bis 'RÜSTEN' beendet";
                else
                    Message = "Wait until 'PREPARE' has finished";

                return Message;
            }
            public static String PreparationFailed(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "'RÜSTEN' fehlgeschlagen";
                else
                    Message = "'PREPARE' failed";

                return Message;
            }
            public static String PreparationStopped(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "'RÜSTEN' gestoppt";
                else
                    Message = "'PREPARE' stopped";

                return Message;
            }
            #endregion
            #region AMPLITUDE TEST
            public static String WaitUntilAmplitudeTestFinished(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Warten bis AMPLITUDENTEST beendet";
                else
                    Message = "Wait until AMPLITUDE TEST has finished";

                return Message;
            }
            public static String WaitUntilRegisterWriteFinished(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Warten bis Schreiben auf Register beendet";
                else
                    Message = "Wait until register write has finished";

                return Message;
            }
            public static String WaitUntilRegisterReadFinished(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Warten bis Lesen vom Register beendet";
                else
                    Message = "Wait until register read has finished";

                return Message;
            }
            public static String WaitUntilPercentageSweepFinished(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Warten bis Messung beendet";
                else
                    Message = "Wait for percentage sweep to end:";

                return Message;
            }
            public static String WaitUntilAmplitudeFinished(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Warten bis 'AMPLITUDENTEST' beendet";
                else
                    Message = "Wait until 'AMPLITUDE TEST' has finished";

                return Message;
            }
            public static String AmplitudeFailed(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "'AMPLITUDENTEST' fehlgeschlagen";
                else
                    Message = "'AMPLITUDE TEST' failed";

                return Message;
            }
            public static String AmplitudeStopped(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "'AMPLITUDENTEST' gestoppt";
                else
                    Message = "'AMPLITUDE TEST' stopped";

                return Message;
            }
            #endregion
            #region ZEROFLOW OFFSET TEST
            public static String WaitUntilZeroflowOffsetTestFinished(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Warten bis 'OFFSET TEST' beendet";
                else
                    Message = "Wait until 'OFFSET TEST' has finished";

                return Message;
            }
            public static String ZeroflowOffsetAqqFinished(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Warten bis Datenaufnahme beendet:";
                else
                    Message = "Wait until data aquisition has finished:";

                return Message;
            }
            public static String ZeroflowOffsetTestFailed(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "'ZEROFLOW OFFSET TEST' fehlgeschlagen";
                else
                    Message = "'ZEROFLOW OFFSET TEST' failed";

                return Message;
            }
            public static String ZeroflowOffsetTestStopped(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "'ZEROFLOW OFFSET TEST' gestoppt";
                else
                    Message = "'ZEROFLOW OFFSET TEST' stopped";

                return Message;
            }
            public static String ZeroflowOffsetWaitForSettling(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Beruhigungszeit abwarten: ";
                else
                    Message = "Wait for settling time: ";

                return Message;
            }
            #endregion
            #region TEMPERATURE CALIBRATION
            public static String TempCalFailed(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "TEMPERATUR KALIBRIERUNG fehlgeschlagen bei ZÄHLER";
                else
                    Message = "TEMPERATURE CALIBRATION failed at METER";

                return Message;
            }
            #endregion
            #region COMPLETION
            public static String WaitUntilCompletionFinished(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "Warten bis 'ABSCHLUSS' beendet";
                else
                    Message = "Wait until 'COMPLETION' has finished";

                return Message;
            }
            public static String CompletionStopped(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "'ABSCHLUSS' gestoppt";
                else
                    Message = "'COMPLETION' stopped";

                return Message;
            }
            public static String CompletionFailed(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "'ABSCHLUSS' fehlgeschlagen";
                else
                    Message = "'COMPLETION' failed";

                return Message;
            }
            #endregion
            #region ZEROFLOW CALIBRATION SEQUENCE
            public static String ZeroflowCalibrationSequenceStopped(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "'ZEROFLOW KALIBRIERUNGS'-Sequenz gestoppt";
                else
                    Message = "'ZEROFLOW CALIBRATION' sequence stopped";

                return Message;
            }
            public static String ZeroflowCalibrationSequenceFailed(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "'ZEROFLOW KALIBRIERUNGS'-Sequenz fehlgeschlagen";
                else
                    Message = "'ZEROFLOW CALIBRATION' sequence failed";

                return Message;
            }
            public static String ZeroflowCalibrationSequenceSuccessful(CultureInfo culture)
            {
                String Message = String.Empty;

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                    Message = "'ZEROFLOW KALIBRIERUNGS'-Sequenz erfolgreich";
                else
                    Message = "'ZEROFLOW CALIBRATION' sequence successful";

                return Message;
            }
            #endregion
        }

        public static class Display
        {
            public static void TemperatureField(Boolean[] enable)
            {
                if (enable == null)
                    return;

                if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
                {
                    GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<Boolean[]>)TemperatureField, enable);
                    return;
                }
                else
                {
                    TemperatureField secondForm;
                    using (secondForm = new TemperatureField())
                    {
                        GenesisZeroFlow._GenesisZeroFlow.tab_Maintab.Enabled = false;
                        secondForm.SetMeter1(enable[Constants.Meter1]);
                        secondForm.SetMeter2(enable[Constants.Meter2]);
                        secondForm.SetMeter3(enable[Constants.Meter3]);
                        secondForm.SetMeter4(enable[Constants.Meter4]);
                        secondForm.SetMeter5(enable[Constants.Meter5]);
                        secondForm.SetMeter6(enable[Constants.Meter6]);
                        secondForm.SetMeter7(enable[Constants.Meter7]);
                        secondForm.SetMeter8(enable[Constants.Meter8]);
                        secondForm.SetMeter9(enable[Constants.Meter9]);
                        secondForm.SetMeter10(enable[Constants.Meter10]);
                        GenesisZeroFlow._GenesisZeroFlow.SetWaitForTemperatureField(true);
                        secondForm.Show();
                        while (GenesisZeroFlow._GenesisZeroFlow.WaitForTemperatureField) { Misc.WaitNSeconds(1, true); }
                    }
                }
               

            }
            public static void SetControlText(CultureInfo culture)
            {
                if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
                {
                    GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<CultureInfo>)SetControlText, culture);
                    return;
                }

                if (CultureInfo.Equals(culture, GenesisZeroFlow._GenesisZeroFlow.CultureDe))
                {
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Meter1.Text = "ZÄHLER1";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Meter2.Text = "ZÄHLER2";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Meter3.Text = "ZÄHLER3";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Meter4.Text = "ZÄHLER4";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Meter5.Text = "ZÄHLER5";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Meter6.Text = "ZÄHLER6";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Meter7.Text = "ZÄHLER7";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Meter8.Text = "ZÄHLER8";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Meter9.Text = "ZÄHLER9";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Meter10.Text = "ZÄHLER10";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Detect.Text = "DETEKT";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Prepare.Text = "RÜSTEN";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Amplitude.Text = "AMPLITUDEN\nTEST";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_TempCal.Text = "TEMPERATUR\nKALIBRIERUNG";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Completion.Text = "ABSCHLUSS";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Resttime.Text = "Geschätzte Restzeit ";
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter1.Text = "aktiv";
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter2.Text = "aktiv";
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter3.Text = "aktiv";
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter4.Text = "aktiv";
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter5.Text = "aktiv";
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter6.Text = "aktiv";
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter7.Text = "aktiv";
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter8.Text = "aktiv";
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter9.Text = "aktiv";
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter10.Text = "aktiv";
                    GenesisZeroFlow._GenesisZeroFlow.btn_ZeroFlowCal_Save.Text = "speichern";
                    GenesisZeroFlow._GenesisZeroFlow.btn_ZeroFlowCal_Clear.Text = "löschen";
                    GenesisZeroFlow._GenesisZeroFlow.btn_ZeroFlowCal_Detect.Text = "DETEKT";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Status.Text = "'DETEKT'-Taste drücken";
                }
                else
                {
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Meter1.Text = "METER1";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Meter2.Text = "METER2";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Meter3.Text = "METER3";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Meter4.Text = "METER4";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Meter5.Text = "METER5";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Meter6.Text = "METER6";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Meter7.Text = "METER7";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Meter8.Text = "METER8";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Meter9.Text = "METER9";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Meter10.Text = "METER10";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Detect.Text = "DETECT";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Prepare.Text = "PREPARE";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Amplitude.Text = "AMPLITUDE\nTEST";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_TempCal.Text = "TEMPERATURE\nCALIBRATION";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Completion.Text = "COMPLETION";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Resttime.Text = "Estimated time to finish: ";
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter1.Text = "enable";
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter2.Text = "enable";
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter3.Text = "enable";
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter4.Text = "enable";
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter5.Text = "enable";
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter6.Text = "enable";
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter7.Text = "enable";
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter8.Text = "enable";
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter9.Text = "enable";
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter10.Text = "enable";
                    GenesisZeroFlow._GenesisZeroFlow.btn_ZeroFlowCal_Save.Text = "Save";
                    GenesisZeroFlow._GenesisZeroFlow.btn_ZeroFlowCal_Clear.Text = "Clear";
                    GenesisZeroFlow._GenesisZeroFlow.btn_ZeroFlowCal_Detect.Text = "DETECT";
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Status.Text = "Press 'DETECT'";

                }

            }
            public static void SetControlElements(Boolean enabled)
            {
                if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
                {
                    GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<Boolean>)SetControlElements, enabled);
                    return;
                }
                if (enabled)
                {
                    GenesisZeroFlow._GenesisZeroFlow.lbLanguage.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Bubbles1.Visible = false;
                    GenesisZeroFlow._GenesisZeroFlow.btn_ZeroFlowCal_Detect.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter1.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter2.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter3.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter4.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter5.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter6.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter7.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter8.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter9.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter10.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.gB_Settings_AmplitudeTest.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.gB_Settings_ZeroflowOffsetTest.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.gB_Passwords.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.gB_Settings_Preparation.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.gB_Settings_TemperatureCalibration.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.gB_SettingsTempMonitor.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.btn_ZeroFlowCal_Pdf.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.btn_ZeroFlowCal_Save.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.btn_ZeroFlowCal_Clear.Enabled = true;
                    Display.AbortButtonEnabled(false);
                    GenesisZeroFlow._GenesisZeroFlow.cB_AmplitudeTestEnable.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.cB_TempCalEnable.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowOffsetTestEnable.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.cB_Thermo1.Enabled = true;
                    GenesisZeroFlow._GenesisZeroFlow.cB_Thermo2.Enabled = true;
                }
                else
                {
                    GenesisZeroFlow._GenesisZeroFlow.lbLanguage.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.btn_ZeroFlowCal_Detect.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.btn_ZeroFlowCal_Start.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter1.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter2.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter3.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter4.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter5.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter6.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter7.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter8.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter9.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowCal_EnableMeter10.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.gB_Settings_AmplitudeTest.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.gB_Settings_ZeroflowOffsetTest.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.gB_Passwords.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.gB_Settings_Preparation.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.gB_Settings_TemperatureCalibration.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.btn_ZeroFlowCal_Pdf.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.btn_ZeroFlowCal_Save.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.btn_ZeroFlowCal_Clear.Enabled = false;
                    Display.AbortButtonEnabled(true);
                    GenesisZeroFlow._GenesisZeroFlow.cB_AmplitudeTestEnable.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.cB_TempCalEnable.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.cB_ZeroFlowOffsetTestEnable.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.gB_SettingsTempMonitor.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.cB_Thermo1.Enabled = false;
                    GenesisZeroFlow._GenesisZeroFlow.cB_Thermo2.Enabled = false;
                }
            }
            public static void MeterStatusGreenRed(Boolean[] ok, Boolean[] enable)
            {
                if ((ok == null)||(enable == null))
                    return;

                #region Invoke
                if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
                {
                    GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<Boolean[], Boolean[]>)MeterStatusGreenRed, ok, enable);
                    return;
                }
                #endregion
                #region METER1
                if (enable[Constants.Meter1])
                {
                    if (ok[Constants.CmdMeter1])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter1.BackColor = Color.LightGreen;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter1.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter1.BackColor = Color.LightPink;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter1.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                }
                #endregion
                #region METER2
                if (enable[Constants.Meter2])
                {
                    if (ok[Constants.CmdMeter2])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter2.BackColor = Color.LightGreen;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter2.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter2.BackColor = Color.LightPink;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter2.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                }
                #endregion
                #region METER3
                if (enable[Constants.Meter3])
                {
                    if (ok[Constants.CmdMeter3])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter3.BackColor = Color.LightGreen;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter3.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter3.BackColor = Color.LightPink;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter3.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                }
                #endregion
                #region METER4
                if (enable[Constants.Meter4])
                {
                    if (ok[Constants.CmdMeter4])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter4.BackColor = Color.LightGreen;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter4.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter4.BackColor = Color.LightPink;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter4.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                }
                #endregion
                #region METER5
                if (enable[Constants.Meter5])
                {
                    if (ok[Constants.CmdMeter5])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter5.BackColor = Color.LightGreen;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter5.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter5.BackColor = Color.LightPink;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter5.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                }
                #endregion
                #region METER6
                if (enable[Constants.Meter6])
                {
                    if (ok[Constants.CmdMeter6])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter6.BackColor = Color.LightGreen;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter6.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter6.BackColor = Color.LightPink;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter6.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                }
                #endregion
                #region METER7
                if (enable[Constants.Meter7])
                {
                    if (ok[Constants.CmdMeter7])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter7.BackColor = Color.LightGreen;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter7.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter7.BackColor = Color.LightPink;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter7.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                }
                #endregion
                #region METER8
                if (enable[Constants.Meter8])
                {
                    if (ok[Constants.CmdMeter8])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter8.BackColor = Color.LightGreen;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter8.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter8.BackColor = Color.LightPink;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter8.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                }
                #endregion
                #region METER9
                if (enable[Constants.Meter9])
                {
                    if (ok[Constants.CmdMeter9])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter9.BackColor = Color.LightGreen;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter9.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter9.BackColor = Color.LightPink;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter9.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                }
                #endregion
                #region METER10
                if (enable[Constants.Meter10])
                {
                    if (ok[Constants.CmdMeter10])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter10.BackColor = Color.LightGreen;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter10.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter10.BackColor = Color.LightPink;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter10.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                }
                #endregion
            }
            public static void ThermoStatusGreenRed(Boolean[] ok, Boolean[] enable)
            {
                if ((ok == null) || (enable == null))
                    return;

                #region Invoke
                if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
                {
                    GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<Boolean[], Boolean[]>)ThermoStatusGreenRed, ok, enable);
                    return;
                }
                #endregion
                #region THERMO1
                if (enable[Constants.Thermo1])
                {
                    if (ok[Constants.CmdThermo1])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.pThermo1.BackColor = Color.LightGreen;
                        //GenesisZeroFlow._GenesisZeroFlow.pB_Thermo1.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.pThermo1.BackColor = Color.LightPink;
                        //GenesisZeroFlow._GenesisZeroFlow.pB_Thermo1.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                }
                #endregion
                #region THERMO2
                if (enable[Constants.Thermo2])
                {
                    if (ok[Constants.CmdThermo2])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.pThermo2.BackColor = Color.LightGreen;
                        //GenesisZeroFlow._GenesisZeroFlow.pB_Thermo2.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.pThermo2.BackColor = Color.LightPink;
                        //GenesisZeroFlow._GenesisZeroFlow.pB_Thermo2.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                }
                #endregion
            }
            public static void MeterStatusRedYellow(Boolean[] ok, Boolean[] enable)
            {
                if ((ok == null) || (enable == null))
                    return;

                if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
                {
                    GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<Boolean[], Boolean[]>)MeterStatusRedYellow, ok, enable);
                    return;
                }

                #region METER1
                if (enable[Constants.Meter1])
                {
                    if (ok[Constants.CmdMeter1])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter1.BackColor = Color.LightPink;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter1.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter1.BackColor = Color.Cornsilk;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter1.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region METER2
                if (enable[Constants.Meter2])
                {
                    if (ok[Constants.CmdMeter2])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter2.BackColor = Color.LightPink;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter2.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter2.BackColor = Color.Cornsilk;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter2.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region METER3
                if (enable[Constants.Meter3])
                {
                    if (ok[Constants.CmdMeter3])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter3.BackColor = Color.LightPink;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter3.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter3.BackColor = Color.Cornsilk;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter3.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region METER4
                if (enable[Constants.Meter4])
                {
                    if (ok[Constants.CmdMeter4])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter4.BackColor = Color.LightPink;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter4.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter4.BackColor = Color.Cornsilk;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter4.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region METER5
                if (enable[Constants.Meter5])
                {
                    if (ok[Constants.CmdMeter5])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter5.BackColor = Color.LightPink;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter5.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter5.BackColor = Color.Cornsilk;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter5.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region METER6
                if (enable[Constants.Meter6])
                {
                    if (ok[Constants.CmdMeter6])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter6.BackColor = Color.LightPink;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter6.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter6.BackColor = Color.Cornsilk;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter6.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region METER7
                if (enable[Constants.Meter7])
                {
                    if (ok[Constants.CmdMeter7])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter7.BackColor = Color.LightPink;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter7.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter7.BackColor = Color.Cornsilk;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter7.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region METER8
                if (enable[Constants.Meter8])
                {
                    if (ok[Constants.CmdMeter8])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter8.BackColor = Color.LightPink;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter8.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter8.BackColor = Color.Cornsilk;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter8.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region METER9
                if (enable[Constants.Meter9])
                {
                    if (ok[Constants.CmdMeter9])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter9.BackColor = Color.LightPink;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter9.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter9.BackColor = Color.Cornsilk;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter9.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region METER10
                if (enable[Constants.Meter10])
                {
                    if (ok[Constants.CmdMeter10])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter10.BackColor = Color.LightPink;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter10.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter10.BackColor = Color.Cornsilk;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter10.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region THERMO1
                if (enable[Constants.Thermo1])
                {
                    if (ok[Constants.CmdThermo1])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.pThermo1.BackColor = Color.LightPink;
                        //GenesisZeroFlow._GenesisZeroFlow.pB_Thermo1.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.pThermo1.BackColor = Color.Cornsilk;
                        //GenesisZeroFlow._GenesisZeroFlow.pB_Thermo1.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region THERMO2
                if (enable[Constants.Thermo2])
                {
                    if (ok[Constants.CmdThermo2])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.pThermo2.BackColor = Color.LightPink;
                        //GenesisZeroFlow._GenesisZeroFlow.pB_Thermo2.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.pThermo2.BackColor = Color.Cornsilk;
                        //GenesisZeroFlow._GenesisZeroFlow.pB_Thermo2.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
            }
            public static void MeterStatusGreenYellow(Boolean[] ok, Boolean[] enable)
            {
                if ((ok == null) || (enable == null))
                    return;

                if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
                {
                    GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<Boolean[], Boolean[]>)MeterStatusGreenYellow, ok, enable);
                    return;
                }

                #region METER1
                if (enable[Constants.Meter1])
                {
                    if (ok[Constants.CmdMeter1])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter1.BackColor = Color.LightGreen;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter1.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter1.BackColor = Color.Cornsilk;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter1.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region METER2
                if (enable[Constants.Meter2])
                {
                    if (ok[Constants.CmdMeter2])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter2.BackColor = Color.LightGreen;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter2.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter2.BackColor = Color.Cornsilk;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter2.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region METER3
                if (enable[Constants.Meter3])
                {
                    if (ok[Constants.CmdMeter3])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter3.BackColor = Color.LightGreen;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter3.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter3.BackColor = Color.Cornsilk;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter3.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region METER4
                if (enable[Constants.Meter4])
                {
                    if (ok[Constants.CmdMeter4])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter4.BackColor = Color.LightGreen;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter4.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter4.BackColor = Color.Cornsilk;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter4.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region METER5
                if (enable[Constants.Meter5])
                {
                    if (ok[Constants.CmdMeter5])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter5.BackColor = Color.LightGreen;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter5.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter5.BackColor = Color.Cornsilk;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter5.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region METER6
                if (enable[Constants.Meter6])
                {
                    if (ok[Constants.CmdMeter6])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter6.BackColor = Color.LightGreen;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter6.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter6.BackColor = Color.Cornsilk;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter6.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region METER7
                if (enable[Constants.Meter7])
                {
                    if (ok[Constants.CmdMeter7])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter7.BackColor = Color.LightGreen;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter7.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter7.BackColor = Color.Cornsilk;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter7.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region METER8
                if (enable[Constants.Meter8])
                {
                    if (ok[Constants.CmdMeter8])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter8.BackColor = Color.LightGreen;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter8.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter8.BackColor = Color.Cornsilk;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter8.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region METER9
                if (enable[Constants.Meter9])
                {
                    if (ok[Constants.CmdMeter9])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter9.BackColor = Color.LightGreen;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter9.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter9.BackColor = Color.Cornsilk;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter9.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region METER10
                if (enable[Constants.Meter10])
                {
                    if (ok[Constants.CmdMeter10])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter10.BackColor = Color.LightGreen;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter10.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter10.BackColor = Color.Cornsilk;
                        GenesisZeroFlow._GenesisZeroFlow.pB_Meter10.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region THERMO1
                if (enable[Constants.Thermo1])
                {
                    if (ok[Constants.CmdThermo1])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.pThermo1.BackColor = Color.LightGreen;
                        //GenesisZeroFlow._GenesisZeroFlow.pB_Thermo1.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.pThermo1.BackColor = Color.Cornsilk;
                        //GenesisZeroFlow._GenesisZeroFlow.pB_Thermo1.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
                #region THERMO2
                if (enable[Constants.Thermo2])
                {
                    if (ok[Constants.CmdThermo2])
                    {
                        GenesisZeroFlow._GenesisZeroFlow.pThermo2.BackColor = Color.LightGreen;
                        //GenesisZeroFlow._GenesisZeroFlow.pB_Thermo2.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                    }
                    else
                    {
                        GenesisZeroFlow._GenesisZeroFlow.pThermo2.BackColor = Color.Cornsilk;
                        //GenesisZeroFlow._GenesisZeroFlow.pB_Thermo2.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                    }
                }
                #endregion
            }
            public static void SetProgressPanel(Int32 item)
            {
                if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
                {
                    GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<Int32>)SetProgressPanel, item);
                    return;
                }

                switch (item)
                {
                    case StatusPanelItems.None:
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalDetectSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalPrepareSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalAmplitudeSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalOffsetSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalCompletionSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalTempCalSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalDetectSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalPrepareSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalAmplitudeSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalOffsetSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalCompletionSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalTempCalSetLabelColor(Color.Gray);
                        break;

                    case StatusPanelItems.Detect:
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalDetectSetBackColor(Color.LightGreen);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalPrepareSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalAmplitudeSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalOffsetSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalCompletionSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalTempCalSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalDetectSetLabelColor(Color.Black);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalPrepareSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalAmplitudeSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalOffsetSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalCompletionSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalTempCalSetLabelColor(Color.Gray);
                        break;

                    case StatusPanelItems.Prepare:
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalDetectSetBackColor(Color.LightGreen);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalPrepareSetBackColor(Color.LightGreen);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalAmplitudeSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalOffsetSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalCompletionSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalTempCalSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalDetectSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalPrepareSetLabelColor(Color.Black);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalAmplitudeSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalOffsetSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalCompletionSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalTempCalSetLabelColor(Color.Gray);
                        break;

                    case StatusPanelItems.Amplitude:
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalDetectSetBackColor(Color.LightGreen);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalPrepareSetBackColor(Color.LightGreen);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalAmplitudeSetBackColor(Color.LightGreen);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalOffsetSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalTempCalSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalCompletionSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalDetectSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalPrepareSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalAmplitudeSetLabelColor(Color.Black);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalOffsetSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalTempCalSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalCompletionSetLabelColor(Color.Gray);  
                        break;

                    case StatusPanelItems.Offset:
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalDetectSetBackColor(Color.LightGreen);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalPrepareSetBackColor(Color.LightGreen);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalAmplitudeSetBackColor(Color.LightGreen);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalTempCalSetBackColor(Color.LightGreen);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalOffsetSetBackColor(Color.LightGreen);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalCompletionSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalDetectSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalPrepareSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalAmplitudeSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalOffsetSetLabelColor(Color.Black);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalTempCalSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalCompletionSetLabelColor(Color.Gray);
                        break;

                    case StatusPanelItems.Completion:
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalDetectSetBackColor(Color.LightGreen);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalPrepareSetBackColor(Color.LightGreen);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalAmplitudeSetBackColor(Color.LightGreen);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalOffsetSetBackColor(Color.LightGreen);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalTempCalSetBackColor(Color.LightGreen);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalCompletionSetBackColor(Color.LightGreen);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalDetectSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalPrepareSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalAmplitudeSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalOffsetSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalTempCalSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalCompletionSetLabelColor(Color.Black);
                        break;

                    case StatusPanelItems.TempCal:
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalDetectSetBackColor(Color.LightGreen);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalPrepareSetBackColor(Color.LightGreen);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalAmplitudeSetBackColor(Color.LightGreen);                   
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalTempCalSetBackColor(Color.LightGreen);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalOffsetSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalCompletionSetBackColor(Color.Gainsboro);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalDetectSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalPrepareSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalAmplitudeSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalTempCalSetLabelColor(Color.Black);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalOffsetSetLabelColor(Color.Gray);
                        GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalCompletionSetLabelColor(Color.Gray);
                        break;

                    default:
                        //GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalDetectSetBackColor(Color.Gainsboro);
                        //GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalPrepareSetBackColor(Color.Gainsboro);
                        //GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalAmplitudeSetBackColor(Color.Gainsboro);
                        //GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalOffsetSetBackColor(Color.Gainsboro);
                        //GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalCompletionSetBackColor(Color.Gainsboro);
                        //GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalTempCalSetBackColor(Color.Gainsboro);
                        //GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalDetectSetLabelColor(Color.Gray);
                        //GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalPrepareSetLabelColor(Color.Gray);
                        //GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalAmplitudeSetLabelColor(Color.Gray);
                        //GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalOffsetSetLabelColor(Color.Gray);
                        //GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalCompletionSetLabelColor(Color.Gray);
                        //GenesisZeroFlow._GenesisZeroFlow.ZeroFlowCalTempCalSetLabelColor(Color.Gray);
                        break;

                }

                Misc.WaitNSeconds(2);
                return;
            }   
            public static void ConnectionStatus(Boolean[] ok)
            {
                if (ok == null)
                    return;

                if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
                {
                    GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<Boolean[]>)ConnectionStatus, ok);
                    return;
                }
    
                #region METER1
                if (ok[Constants.CmdMeter1] && ok[Constants.DataMeter1])
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter1.BackColor = Color.LightGreen;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter1.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                }
                else
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter1.BackColor = Color.LightPink;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter1.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                }
                #endregion
                #region METER2
                if (ok[Constants.CmdMeter2] && ok[Constants.DataMeter2])
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter2.BackColor = Color.LightGreen;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter2.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                }
                else
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter2.BackColor = Color.LightPink;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter2.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                }
                #endregion
                #region METER3
                if (ok[Constants.CmdMeter3] && ok[Constants.DataMeter3])
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter3.BackColor = Color.LightGreen;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter3.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                }
                else
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter3.BackColor = Color.LightPink;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter3.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                }
                #endregion
                #region METER4
                if (ok[Constants.CmdMeter4] && ok[Constants.DataMeter4])
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter4.BackColor = Color.LightGreen;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter4.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                }
                else
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter4.BackColor = Color.LightPink;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter4.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                }
                #endregion
                #region METER5
                if (ok[Constants.CmdMeter5] && ok[Constants.DataMeter5])
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter5.BackColor = Color.LightGreen;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter5.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                }
                else
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter5.BackColor = Color.LightPink;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter5.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                }
                #endregion
                #region METER6
                if (ok[Constants.CmdMeter6] && ok[Constants.DataMeter6])
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter6.BackColor = Color.LightGreen;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter6.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                }
                else
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter6.BackColor = Color.LightPink;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter6.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                }
                #endregion
                #region METER7
                if (ok[Constants.CmdMeter7] && ok[Constants.DataMeter7])
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter7.BackColor = Color.LightGreen;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter7.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                }
                else
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter7.BackColor = Color.LightPink;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter7.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                }
                #endregion
                #region METER8
                if (ok[Constants.CmdMeter8] && ok[Constants.DataMeter8])
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter8.BackColor = Color.LightGreen;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter8.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                }
                else
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter8.BackColor = Color.LightPink;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter8.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                }
                #endregion
                #region METER9
                if (ok[Constants.CmdMeter9] && ok[Constants.DataMeter9])
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter9.BackColor = Color.LightGreen;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter9.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                }
                else
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter9.BackColor = Color.LightPink;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter9.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                }
                #endregion
                #region METER10
                if (ok[Constants.CmdMeter10] && ok[Constants.DataMeter10])
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter10.BackColor = Color.LightGreen;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter10.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                }
                else
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter10.BackColor = Color.LightPink;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter10.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                }
                #endregion
            }
            public static void ThermoConnectionStatus(Boolean[] ok)
            {
                if (ok == null)
                    return;

                if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
                {
                    GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<Boolean[]>)ThermoConnectionStatus, ok);
                    return;
                }
                #region THERMO1
                if (ok[Constants.CmdThermo1] && ok[Constants.DataThermo1])
                {
                    GenesisZeroFlow._GenesisZeroFlow.pThermo1.BackColor = Color.LightGreen;
                    //GenesisZeroFlow._GenesisZeroFlow.pB_Thermo1.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                }
                else
                {
                    GenesisZeroFlow._GenesisZeroFlow.pThermo1.BackColor = Color.LightPink;
                    //GenesisZeroFlow._GenesisZeroFlow.pB_Thermo1.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                }
                #endregion
                #region THERMO2
                if (ok[Constants.CmdThermo2] && ok[Constants.DataThermo2])
                {
                    GenesisZeroFlow._GenesisZeroFlow.pThermo2.BackColor = Color.LightGreen;
                    //GenesisZeroFlow._GenesisZeroFlow.pB_Thermo2.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.Image;
                }
                else
                {
                    GenesisZeroFlow._GenesisZeroFlow.pThermo2.BackColor = Color.LightPink;
                    //GenesisZeroFlow._GenesisZeroFlow.pB_Thermo2.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.ErrorImage;
                }
                #endregion
            }
            public static void SetThermoLabel1(String text)
            {
                if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
                {
                    GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<String>)SetThermoLabel1, text);
                    return;
                }

                GenesisZeroFlow._GenesisZeroFlow.l_Thermo1.Text = text;
            }
            public static void SetThermoLabel2(String text)
            {
                if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
                {
                    GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<String>)SetThermoLabel2, text);
                    return;
                }

                GenesisZeroFlow._GenesisZeroFlow.l_Thermo2.Text = text;
            }
            public static void ConnectionStatusReset(Boolean[] reset)
            {
                if (reset == null)
                    return;

                if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
                {
                    GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<Boolean[]>)ConnectionStatusReset, reset);
                    return;
                }
                #region METER1
                if (reset[Constants.Meter1])
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter1.BackColor = Color.Cornsilk;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter1.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                }
                #endregion
                #region METER2
                if (reset[Constants.Meter2])
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter2.BackColor = Color.Cornsilk;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter2.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                }
                #endregion
                #region METER3
                if (reset[Constants.Meter3])
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter3.BackColor = Color.Cornsilk;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter3.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                }
                #endregion
                #region METER4
                if (reset[Constants.Meter4])
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter4.BackColor = Color.Cornsilk;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter4.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                }
                #endregion
                #region METER5
                if (reset[Constants.Meter5])
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter5.BackColor = Color.Cornsilk;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter5.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                }
                #endregion
                #region METER6
                if (reset[Constants.Meter6])
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter6.BackColor = Color.Cornsilk;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter6.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                }
                #endregion
                #region METER7
                if (reset[Constants.Meter7])
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter7.BackColor = Color.Cornsilk;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter7.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                }
                #endregion
                #region METER8
                if (reset[Constants.Meter8])
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter8.BackColor = Color.Cornsilk;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter8.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                }
                #endregion
                #region METER9
                if (reset[Constants.Meter9])
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter9.BackColor = Color.Cornsilk;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter9.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                }
                #endregion
                #region METER10
                if (reset[Constants.Meter10])
                {
                    GenesisZeroFlow._GenesisZeroFlow.p_ZeroFlowCal_Meter10.BackColor = Color.Cornsilk;
                    GenesisZeroFlow._GenesisZeroFlow.pB_Meter10.Image = GenesisZeroFlow._GenesisZeroFlow.pB_AvailableImages.InitialImage;
                }
                #endregion

            }
            public static void ThermoConnectionStatusReset(Boolean[] reset)
            {
                if (reset == null)
                    return;

                if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
                {
                    GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<Boolean[]>)ThermoConnectionStatusReset, reset);
                    return;
                }
       
                #region THERMO1
                if (reset[Constants.Thermo1])
                    GenesisZeroFlow._GenesisZeroFlow.pThermo1.BackColor = Color.Cornsilk;
                #endregion
                #region THERMO2
                if (reset[Constants.Thermo2])
                    GenesisZeroFlow._GenesisZeroFlow.pThermo2.BackColor = Color.Cornsilk;
                #endregion
            }
            public static void DebugMessage(String text, CultureInfo culture)
            {
                // Add line and scroll to caret
                if (!String.IsNullOrEmpty(text))
                {
                    if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
                    {
                        GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<String, CultureInfo>)DebugMessage, text, culture);
                        return;
                    }

                    String Timestamp = DateTime.Now.ToString(Formats.RawDataDateTimeLogString, culture);
                    GenesisZeroFlow._GenesisZeroFlow.rTB_ZeroFlowCal.AppendText($"{Timestamp}\t{text}");
                    GenesisZeroFlow._GenesisZeroFlow.rTB_ZeroFlowCal.ScrollToCaret();
                }
            }
            public static void AbortButtonEnabled(Boolean enabled)
            {
                if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
                {
                    GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<Boolean>)AbortButtonEnabled, enabled);
                    return;
                }

                if (enabled)
                    GenesisZeroFlow._GenesisZeroFlow.btn_ZeroFlowCal_Abort.Enabled = true;
                else
                    GenesisZeroFlow._GenesisZeroFlow.btn_ZeroFlowCal_Abort.Enabled = false;

            }
            public static void EraseLogData(UInt16 meter)
            {
                if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
                {
                    GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<UInt16>)EraseLogData, meter);
                    return;
                }
                GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(meter, String.Empty);
            }
            public static void EraseAmplitudeData(UInt16 meterNumber, UInt16 path)
            {
                if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
                {
                    GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<UInt16, UInt16>)EraseAmplitudeData, meterNumber, path);
                    return;
                }

                GenesisZeroFlow._GenesisZeroFlow.AmpValuesToLog[meterNumber][path] = String.Empty;
            }


            public static void StatusLabel(String debugMessage)
            {
                // Add line and scroll to caret
                if (!String.IsNullOrEmpty(debugMessage))
                {
                    if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
                    {
                        GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<String>)StatusLabel, debugMessage);
                        return;
                    }
                    GenesisZeroFlow._GenesisZeroFlow.l_ZeroFlowCal_Status.Text = debugMessage;
                }
            }
            public static Boolean[] WaitForEmptyPipeModeToLeave(Boolean[] enabled, CultureInfo culture)
            {
                #region Definitions and initializations
                const Int32 WaitingTime = 60;
                Int32 LocalNumberOfPaths = Constants.NumberOfPaths;
                Boolean[] Ok = new Boolean[Constants.NumberOfMeters];
                Double[][] Error = new Double[Constants.NumberOfMeters][];
                for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                {
                    Ok[Meter] = true;
                    Error[Meter] = new Double[LocalNumberOfPaths];
                    for (UInt16 Path = 0; Path < LocalNumberOfPaths; Path++)
                        Error[Meter][Path] = DataError.NoError;
                }
                Boolean PerformWait = false;
                #endregion
                #region CA1062
                if (enabled == null)
                {
                    for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                        Ok[Meter] = false;
                    return Ok;
                }
                #endregion

                for (Int32 i = WaitingTime; i >= 0; i--)
                {
                    PerformWait = false;
                
                    Display.StatusLabel($"{PredefinedMessages.WaitForEmptyPipe(culture)}{i.ToString(culture)}s");
                    Misc.WaitNSeconds(1);

                    #region Get error status
                    for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                    {
                        for(UInt16 Path = Constants.PATH0; Path < LocalNumberOfPaths; Path++)
                            Error[Meter][Path] = GenesisZeroFlow._GenesisZeroFlow.DecodedAllMeters[Meter][Path].Validation;
                    }
                    #endregion
                    #region Check if wait
                    for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                    {
                        if (enabled[Meter])
                        {
                            for (UInt16 Path = Constants.PATH0; Path < LocalNumberOfPaths; Path++)
                            {
                                if (Error[Meter][Path] != DataError.NoError)
                                    PerformWait = true;
                            }
                        }
                    }
                    #endregion
                    #region All OK 
                    if (Boolean.Equals(PerformWait, false))
                    {
                        Display.DebugMessage($"{Constants.TwentySpaces}\tDATA CHANNEL:\t\tLeave empty pipe mode\n", culture);
                        return Ok;
                    }
                    #endregion
                }
                #region Set OK
                for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                {
                    if (enabled[Meter])
                    {
                        for (UInt16 Path = Constants.PATH0; Path < LocalNumberOfPaths; Path++)
                        {
                            if (Error[Meter][Path] != DataError.NoError)
                                Ok[Meter] = false;
                        }
                        if (Boolean.Equals(Ok[Meter], false))
                            Display.DebugMessage($"{Constants.TwentySpaces}\tDATA CHANNEL:\t\tLeave empty pipe mode failed at METER{(Meter + 1).ToString(culture)}\n", culture);
                    }
                }

                #endregion
                return Ok;
            }
            public static void WaitForStabilization(Boolean[] ok, Int32 waitingTime, out Boolean aborted, CultureInfo culture)
            {
                
                aborted = false;
                #region CA1062
                if (ok == null)
                    return;
                #endregion

                Boolean PerformWait = false;

                for (Int32 i = 0; i < ok.Count(); i++)
                {
                    if (ok[i])
                        PerformWait = true;
                }

                if (PerformWait)
                {
                    for (Int32 i = waitingTime; i >= 0; i--)
                    {
                        if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator)
                        {
                            aborted = true;
                            return;
                        }
                        Display.StatusLabel($"{PredefinedMessages.WaitForStabilization(culture)}{i.ToString(culture)}s");
                        Misc.WaitNSeconds(1);
                    }
                }
                
            }
            public static Boolean[] GetSequenceResult(Boolean[] enabled, Boolean[] failed, String name, out Boolean stop, CultureInfo culture)
            {
                #region Definitions and initializations
                stop = false;
                Boolean[] AllOk = new Boolean[enabled.Count()];
                Boolean NoDeviceEnabled = true;
                Boolean AtLeastOneMeterEnabled = false;
                Boolean AtLeastOneThermometerEnabled = false;
                Boolean AllDevicesFailed = true;
                Boolean AllMetersOk = true;
                Boolean AllThermometersFailed = true;
                Boolean AllThermometersOk = true;
                Boolean AllMetersFailed = true;
            
                String MeterSeqSucceeded = String.Empty;
                String MeterSeqFailed = String.Empty;
                String ThermoSeqSucceeded = String.Empty;
                String ThermoSeqFailed = String.Empty;

                for (UInt16 i = 0; i < enabled.Count(); i++)
                    AllOk[i] = false;
                #endregion
                #region No device enabled
                for (UInt16 i = 0; i < enabled.Count(); i++)
                    if (enabled[i])
                        NoDeviceEnabled = false;
                if(NoDeviceEnabled)
                {
                    Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t No device enabled\n", culture);
                    Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t ZEROFLOW CALIBRATION sequence failed\n", culture);
                    Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", culture);
                    
                    stop = true;
                    return AllOk;
                }

                #endregion
                #region At least one METER/ THERMOMETER enabled
                for (UInt16 Meter = 0; Meter < Constants.NumberOfMeters; Meter++)
                    if (enabled[Meter])
                        AtLeastOneMeterEnabled = true;
                for (UInt16 Thermometer = 0; Thermometer < Constants.NumberOfThermometers; Thermometer++)
                    if (enabled[Constants.NumberOfMeters + Thermometer])
                        AtLeastOneThermometerEnabled = true;
                #endregion
                #region All Devices failed
                if (AtLeastOneMeterEnabled | AtLeastOneThermometerEnabled)
                {
                    //AllDevicesFailed = true;
                    for (UInt16 i = 0; i < enabled.Count(); i++)
                        if (enabled[i] & !failed[i])
                            AllDevicesFailed = false;

                    if (AllDevicesFailed)
                    {
                        #region All devices failed
                        stop = true;
                        Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t {name} failed!\n", culture);
                        Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t ZEROFLOW CALIBRATION sequence failed\n", culture);
                        Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", culture);
                        MessageBox.Show(PredefinedMessages.ZeroflowOffsetTestFailed(culture), "Form closing", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    
                        return AllOk;
                        #endregion
                    }
                }
                #endregion
                #region Meter string
                if (AtLeastOneMeterEnabled)
                {
                    for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                    {
                        String MeterIndex = (Meter + 1).ToString(culture);
                        if(enabled[Meter] & !failed[Meter])
                        {
                            if (Meter < enabled.Count() - Constants.NumberOfThermometers - 1)
                                MeterSeqSucceeded = $"{MeterSeqSucceeded}{Constants.Meter}{MeterIndex}; ";
                            else
                                MeterSeqSucceeded = $"{MeterSeqSucceeded}{Constants.Meter}{MeterIndex}";
                            AllOk[Meter] = true;
                        }
                        if (enabled[Meter] & failed[Meter])
                        {
                            if (Meter < enabled.Count() - Constants.NumberOfThermometers - 1)
                                MeterSeqFailed = $"{MeterSeqFailed}{Constants.Meter}{MeterIndex}; ";
                            else
                                MeterSeqFailed = $"{MeterSeqFailed}{Constants.Meter}{MeterIndex}";
                        }
                    }
                }
                else
                {
                    stop = true;
                    Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t No METER enabled\n", culture);
                    Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t ZEROFLOW CALIBRATION sequence failed\n", culture);
                    Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", culture);
     
                    return AllOk;
                }
                #endregion
                #region Thermometer string
                if (AtLeastOneThermometerEnabled)
                {
                    for (UInt16 Thermometer = Constants.Thermo1; Thermometer < Constants.NumberOfThermometers; Thermometer++)
                    {
                        String ThermoIndex = (Thermometer + 1).ToString(culture);
                        if (enabled[Constants.NumberOfMeters + Thermometer] & !failed[Constants.NumberOfMeters + Thermometer])
                        {
                            if (Thermometer < enabled.Count() - Constants.NumberOfMeters - Constants.NumberOfThermometers - 1)
                                ThermoSeqSucceeded = $"{ThermoSeqSucceeded}{Constants.Meter}{ThermoIndex}; ";
                            else
                                MeterSeqSucceeded = $"{ThermoSeqSucceeded}{Constants.Meter}{ThermoIndex}";
                            AllOk[Constants.NumberOfMeters + Thermometer] = true;
                        }
                        if (enabled[Constants.NumberOfMeters + Thermometer] & failed[Constants.NumberOfMeters + Thermometer])
                        {
                            if (Thermometer < enabled.Count() - Constants.NumberOfMeters - Constants.NumberOfThermometers - 1)
                                ThermoSeqFailed = $"{ThermoSeqFailed}{Constants.Thermo}{ThermoIndex}; ";
                            else
                                ThermoSeqFailed = $"{ThermoSeqFailed}{Constants.Thermo}{ThermoIndex}";
                        }
                    }
                }
                #endregion
                #region AllMetersOk/ Failed
                for (UInt16 i = 0; i < Constants.NumberOfMeters; i++)
                {
                    if (enabled[i] && failed[i])                
                        AllMetersOk = false;
                    if (enabled[i] && !failed[i])
                        AllMetersFailed = false;
                }
                #endregion 
                #region AllThermometersMetersOk / failed
                for (UInt16 i = 0; i < Constants.NumberOfThermometers; i++)
                {
                    if (enabled[Constants.NumberOfMeters + i] && failed[Constants.NumberOfMeters + i])
                        AllThermometersOk = false;
                    if (enabled[Constants.NumberOfMeters + i] && !failed[Constants.NumberOfMeters + i])
                        AllThermometersFailed = false;      
                }
                #endregion
                #region Summary METER
                if (AtLeastOneMeterEnabled)
                {
                    #region All METERS FAILED
                    if (AllMetersFailed)
                    {
                        stop = true;
                        Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t SUMMARY: \n", culture);
                        Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t {name} failed at all METERS\n", culture);
                        Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", culture);
                    }
                    #endregion
                    #region All METERS ok
                    if (AllMetersOk)
                    {
                        Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t SUMMARY: \n", culture);
                        Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t {name} successful at all {Constants.Meter}s\n", culture);
                        Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", culture);
                    }
                    #endregion
                    if (!AllMetersOk && !AllMetersFailed)
                    {
                        if (AtLeastOneMeterEnabled)
                        {
                            Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t SUMMARY: \n", culture);
                            if (String.IsNullOrEmpty(MeterSeqFailed))
                                MeterSeqFailed = "None";
                            Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t {name} failed at {MeterSeqFailed}\n", culture);
                            if (String.IsNullOrEmpty(MeterSeqSucceeded))
                                MeterSeqSucceeded = "None";
                            Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t {name} successful at {MeterSeqSucceeded}\n", culture);
                            Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", culture);
                        }
                    }
                }

                #endregion
                #region Summary THERMOMETER
                if (AtLeastOneThermometerEnabled)
                {
                    if (AllThermometersFailed)
                    {
                        stop = true;
                        Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t SUMMARY: \n", culture);
                        Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t {name} failed at all THERMOMETERS\n", culture);
                        Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", culture);
                    }
                    if (AllThermometersOk)
                    {
                        Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t SUMMARY: \n", culture);
                        Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t {name} successful at all THERMOMETERS\n", culture);
                        Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", culture);
                    }
                    if (!AllThermometersOk && !AllThermometersFailed)
                    {
                        if (AtLeastOneThermometerEnabled)
                        {
                            Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t SUMMARY: \n", culture);
                            if (String.IsNullOrEmpty(ThermoSeqFailed))
                                ThermoSeqFailed = "None";
                            Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t {name} failed at {ThermoSeqFailed}\n", culture);
                            if (String.IsNullOrEmpty(ThermoSeqSucceeded))
                                ThermoSeqSucceeded = "None";
                            Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t {name} successful at {ThermoSeqSucceeded}\n", culture);
                            Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", culture);
                        }
                    }
                }

                #endregion
                if (stop)
                {
                    Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t {name} finished\n", culture);
                    Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", culture);
                    Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t ZEROFLOW CALIBRATION sequence failed\n", culture);
                    Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", culture);
                }

                return AllOk;
            }

            public static void PictureBoxVisble(PictureBox pBBubbles1, Boolean b)
            {
                if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
                {
                    GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<PictureBox,Boolean>)PictureBoxVisble, pBBubbles1, b);
                    return;
                }

                pBBubbles1.Enabled = b;
            }
        }
    }
}