tbf/Results/WMeterRsltItemSpec.cs

///
/// Copyright (c) 2013-2017 Sensus Metering Systems
///
using System;
using System.Collections.Generic;
using Config;
using Config.Entities;
using Results.Entities;
using Results.Resources;

namespace Results
{
	public class WMeterRsltItemSpec
	{
		///
		/// Public fields
		///
        public readonly int Uid;
		public readonly string OldUid;
		public readonly string Name;			        /// Name-s of all items must be unique
		public readonly string ToolTipText;				/// Tool-Tip Text
		public readonly Quantity Quantity;				/// Quantity
		public readonly ItemCategory Category;			/// 
        public string Caption;		                    /// Specifies item description to be printed as a caption (in the header, etc.)
        public string TestID;		                    /// Specifies the test
        public Config.Unit Units;	                    /// Specifies units for the output
        public string Format;		                    /// Specifies format for the output
        public string Precision;	                    /// Specifies precision for the output
        public int Width;                               /// Specifies the number of characters of the output, 0 = automatic
        public Config.Entities.Alignment Alignment;     /// Specifies alignment for the output

        public WMeterRsltItemSpec Clone()
        {
			WMeterRsltItemSpec item2 = new WMeterRsltItemSpec((ItemID)Uid, Name, ToolTipText, Quantity, Category, printDlgt);
            item2.Caption = Caption;
            item2.TestID = TestID;
            item2.Units = Units;
            item2.Format = Format;
            item2.Precision = Precision;
            item2.Width = Width;
            item2.Alignment = Alignment;
            return item2;
        }

		///
		/// Function to pick a MeterTestResult field and convert it into a string
		/// 
		public delegate string PrintDlgt(WaterMeter waterMeterResult, string testID, Config.Unit units, string format, string precision);

		private readonly PrintDlgt printDlgt;

		/// <summary> Safe wrapper which replaces null-s by empty strings </summary>
		public string Print(WaterMeter waterMeterResult)
		{
			return Print(waterMeterResult, TestID);
		}
		public string Print(WaterMeter waterMeterResult, string testId)
		{
			string str = printDlgt(waterMeterResult, testId, Units, Format, Precision);
            if (str == null) str = string.Empty;

            if (!string.IsNullOrEmpty(Format))
            {
                str = string.Format(Format, str);
            }

            int len = str.Length;
            if (Width == 0 || len >= Width)
            {
                return str;
            }
            else if (Alignment == Config.Entities.Alignment.Left)
            {
                return str + new string(' ', Width - len);
            }
            else if (Alignment == Config.Entities.Alignment.Right)
            {
                return new string(' ', Width - len) + str;
            }
            else // Alignment.Center or Alignment.Justified
            {
                int nrSpaces = Width - len;
                return new string(' ', nrSpaces / 2) + str + new string(' ', nrSpaces - (nrSpaces / 2));
            }
		}

		///
		/// Public constructor
		///
        public WMeterRsltItemSpec(ItemID itemId, string name, string toolTipText, Quantity quantity, ItemCategory category, PrintDlgt printDlgt)
		{
            Uid = (int)itemId;
			OldUid = itemId.ToString().Replace("__", "/").Replace('_', ' ');
			Name = name;
			ToolTipText = toolTipText;
			Quantity = quantity;
			Category = category;
			this.printDlgt = printDlgt;
		}

		///
		/// Constructor without ToolTip text
		///
		public WMeterRsltItemSpec(ItemID itemId, string name, Quantity quantity, ItemCategory category, PrintDlgt printDlgt)
		{
			Uid = (int)itemId;
			OldUid = itemId.ToString().Replace("__", "/").Replace('_', ' ');
			Name = name;
			ToolTipText = null;
			Quantity = quantity;
			Category = category;
			this.printDlgt = printDlgt;
		}


		/// <summary>
		/// Get precision string
		/// </summary>
		/// <param name="p1">Parameter</param>
		/// <param name="p2">Default value when p1 is empty</param>
		/// <returns>Precision</returns>
		static string GetPr(string p1, string p2)
		{
			return string.IsNullOrEmpty(p1) ? p2 : p1;
		}


		/// Static list of all available items
        public static readonly IList<WMeterRsltItemSpec> AllItems;

		/// Static constructor that initializes the list of all items
        static WMeterRsltItemSpec()
		{
            AllItems = new List<WMeterRsltItemSpec>();

			AllItems.Add(new WMeterRsltItemSpec(ItemID.String, "String", "", Quantity.String, ItemCategory.Other, (w, t, u, f, p) => f));

            /// Common
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Test_name, Strings.Test, Quantity.String, ItemCategory.TestData, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : w.GetTestRslt(t).Name()));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Procedure_name, Strings.Procedure, Quantity.String, ItemCategory.Other, (w, t, u, f, p) => w.ProcedureName()));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Batch_number, Strings.Batch_nr, Quantity.Number, ItemCategory.Other, (w, t, u, f, p) => w.BatchNr().ToString()));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Test_method, Strings.Test_method + " *", Quantity.String, ItemCategory.TestData, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : w.GetTestRslt(t).Method()));

            ///
            /// Volume
            ///
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Test_volume,       Strings.Test_vol + "()",                                                  Quantity.Volume, ItemCategory.TestData,    (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).TargetVolume()).ToString(GetPr(p, "F1"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Volume,            string.Format("{0} Mt. ()", Strings.VName_Vol), Strings.Tooltip_Vol_Mt,   Quantity.Volume, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetMeterTestRslt(t).VolumeMeter).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Reference_volume,  string.Format("{0} rm ()", Strings.VName_Vol), Strings.Tooltip_Vol_rm,    Quantity.Volume, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetMeterTestRslt(t).VolumeRef).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Volume_main,       string.Format("{0} {1} ()", Strings.VName_Vol, Strings.main),             Quantity.Volume, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t, CompoundMeterId.CompoundMain) == null) ? "" : Config.Units.ConvertTo(u, w.GetMeterTestRslt(t).VolumeMeter).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Volume_aux,        string.Format("{0} {1} ()", Strings.VName_Vol, Strings.aux),              Quantity.Volume, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t, CompoundMeterId.CompoundAux) == null) ? "" : Config.Units.ConvertTo(u, w.GetMeterTestRslt(t).VolumeMeter).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Start_volume,      Strings.Start_volume + "()",                                              Quantity.Volume, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetMeterTestRslt(t).VolumeStart).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Start_volume_main, Strings.Start_volume_main + "()",                                         Quantity.Volume, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t, CompoundMeterId.CompoundMain) == null) ? "" : Config.Units.ConvertTo(u, w.GetMeterTestRslt(t).VolumeStart).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Start_volume_aux,  Strings.Start_volume_aux + "()",                                          Quantity.Volume, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t, CompoundMeterId.CompoundAux) == null) ? "" : Config.Units.ConvertTo(u, w.GetMeterTestRslt(t).VolumeStart).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.End_volume,        Strings.End_volume + "()",                                                Quantity.Volume, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetMeterTestRslt(t).VolumeEnd).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.End_volume_main,   Strings.End_volume_main + "()",                                           Quantity.Volume, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t, CompoundMeterId.CompoundMain) == null) ? "" : Config.Units.ConvertTo(u, w.GetMeterTestRslt(t).VolumeEnd).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.End_volume_aux,    Strings.End_volume_aux + "()",                                            Quantity.Volume, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t, CompoundMeterId.CompoundAux) == null) ? "" : Config.Units.ConvertTo(u, w.GetMeterTestRslt(t).VolumeEnd).ToString(GetPr(p, "F3"))));

			///
			/// Mass
			/// 
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Mass_start_raw, string.Format("{0} ST raw ()", Strings.VName_Mass), Quantity.Mass, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).MassStartRaw).ToString(GetPr(p, "F4"))));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Mass_start,     string.Format("{0} ST ()",     Strings.VName_Mass), Quantity.Mass, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).MassStart).ToString(GetPr(p, "F4"))));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Mass_end_raw,   string.Format("{0} EN raw ()", Strings.VName_Mass), Quantity.Mass, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).MassEndRaw).ToString(GetPr(p, "F4"))));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Mass_end,       string.Format("{0} EN ()",     Strings.VName_Mass), Quantity.Mass, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).MassEnd).ToString(GetPr(p, "F4"))));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Mass,           string.Format("{0} ()",        Strings.VName_Mass), Quantity.Mass, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).MassEnd - w.GetTestRslt(t).MassStart).ToString(GetPr(p, "F4"))));

			///
			/// Density
			/// 
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Density,            Strings.Density + " ()",            Quantity.Density, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : w.GetTestRslt(t).DensityOut.ToString(GetPr(p, "F1"))));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Density_correction, Strings.Density_correction + " ()", Quantity.Density, ItemCategory.TestResult, (w, t, u, f, p) => w.Batch.DensityCorr.ToString(GetPr(p, "F3"))));

			///
            /// Time (duration), date and time 
            ///
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Test_start_time, Strings.T_start + "()", Quantity.DateTime, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : (string.IsNullOrEmpty(f) ? w.GetTestRslt(t).StartTime.ToString() : string.Format(f, w.GetTestRslt(t).StartTime))));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Test_end_time,   Strings.T_end + "()",   Quantity.DateTime, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : (string.IsNullOrEmpty(f) ? w.GetTestRslt(t).EndTime.ToString() : string.Format(f, w.GetTestRslt(t).EndTime))));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Test_time,       Strings.T_s + "()",     Quantity.Time,     ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : w.GetTestRslt(t).TestTime.ToString(GetPr(p, "F2"))));

            ///
            /// Flow
            ///
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_from,      string.Format("{0} {1}", Strings.VName_Flow, Strings.from),             Quantity.Flow, ItemCategory.TestData,    (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : w.GetTestRslt(t).Qfrom().ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_to,        string.Format("{0} {1}", Strings.VName_Flow, Strings.to),               Quantity.Flow, ItemCategory.TestData,    (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : w.GetTestRslt(t).Qto().ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Flow,        string.Format("{0} v r", Strings.VName_Flow), Strings.Tooltip_Q_v_r,    Quantity.Flow, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Utils.DoubleToStr(Config.Units.ConvertTo(u, w.GetTestRslt(t).FlowVolume), 4)));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_rise,      string.Format("{0} {1}", Strings.VName_Flow, Strings.rise),             Quantity.Flow, ItemCategory.MeterResult, (w, t, u, f, p) => (string.IsNullOrEmpty(t) || (w.GetTestRslt(t) != null)) ? ((w.QRise == 0) ? "-" : Utils.DoubleToStr(w.QRise, 4)) : ""));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_fall,		string.Format("{0} {1}", Strings.VName_Flow, Strings.fall),				Quantity.Flow, ItemCategory.MeterResult, (w, t, u, f, p) => (string.IsNullOrEmpty(t) || (w.GetTestRslt(t) != null)) ? ((w.QFall == 0) ? "-" : Utils.DoubleToStr(w.QFall, 4)) : ""));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q_ref_mean,  string.Format("{0} rim ()", Strings.VName_Flow), Strings.Tooltip_Q_rim, Quantity.Flow, ItemCategory.TestResult,  (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Utils.DoubleToStr(Config.Units.ConvertTo(u, w.GetTestRslt(t).FlowMean), 4)));

            ///
            /// Temperature
            ///
            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_up_mean,    string.Format("{0} UP ME ()",  Strings.VName_Temp), Strings.Tooltip_T_up_me,  Quantity.Temperature, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).TempUpMean).ToString(GetPr(p, "F2"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_up_start,   string.Format("{0} UP ST ()",  Strings.VName_Temp), Strings.Tooltip_T_up_st,  Quantity.Temperature, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).TempUpStart).ToString(GetPr(p, "F1"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_up_end,     string.Format("{0} UP EN ()",  Strings.VName_Temp), Strings.Tooltip_T_up_en,  Quantity.Temperature, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).TempUpEnd).ToString(GetPr(p, "F1"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_up_avg,     string.Format("{0} UP avg ()", Strings.VName_Temp), Strings.Tooltip_T_up_avg, Quantity.Temperature, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, (w.GetTestRslt(t).TempUpStart + w.GetTestRslt(t).TempUpEnd) / 2).ToString(GetPr(p, "F1"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_down_mean,  string.Format("{0} DW ME ()",  Strings.VName_Temp), Strings.Tooltip_T_dw_me,  Quantity.Temperature, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).TempDownMean).ToString(GetPr(p, "F2"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_down_start, string.Format("{0} DW ST ()",  Strings.VName_Temp), Strings.Tooltip_T_dw_st,  Quantity.Temperature, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).TempDownStart).ToString(GetPr(p, "F1"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_down_end,   string.Format("{0} DW EN ()",  Strings.VName_Temp), Strings.Tooltip_T_dw_en,  Quantity.Temperature, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).TempDownEnd).ToString(GetPr(p, "F1"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_down_avg,   string.Format("{0} DW avg ()", Strings.VName_Temp), Strings.Tooltip_T_dw_avg, Quantity.Temperature, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, (w.GetTestRslt(t).TempDownStart + w.GetTestRslt(t).TempDownEnd) / 2).ToString(GetPr(p, "F1"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_div,        string.Format("{0} DI ME ()",  Strings.VName_Temp), Strings.Tooltip_T_di_me,  Quantity.Temperature, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).TempDivMean).ToString(GetPr(p, "F2"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_div_start,  string.Format("{0} DI ST ()",  Strings.VName_Temp), Strings.Tooltip_T_di_st,  Quantity.Temperature, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).TempDivStart).ToString(GetPr(p, "F1"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_div_end,    string.Format("{0} DI EN ()",  Strings.VName_Temp), Strings.Tooltip_T_di_en,  Quantity.Temperature, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).TempDivEnd).ToString(GetPr(p, "F1"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_div_avg,    string.Format("{0} DI avg ()", Strings.VName_Temp), Strings.Tooltip_T_di_avg, Quantity.Temperature, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, (w.GetTestRslt(t).TempDivStart + w.GetTestRslt(t).TempDivEnd) / 2).ToString(GetPr(p, "F1"))));
#if HEAT_METERS
            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Hi_mean,  string.Format("{0} hi me", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).Custom1).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Hi_start, string.Format("{0} hi st", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).Custom2).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Hi_end,   string.Format("{0} hi en", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).Custom3).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Hi_avg,   string.Format("{0} hi av", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, (w.GetTestRslt(t).Custom2 + w.GetTestRslt(t).Custom3) / 2).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Lo_mean,  string.Format("{0} lo me", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).Custom6).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Lo_start, string.Format("{0} lo st", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).Custom7).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Lo_end,   string.Format("{0} lo en", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).Custom8).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.T_Lo_avg,   string.Format("{0} lo av", Strings.VName_Temp), Quantity.Temperature, ItemCategory.Other, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, (w.GetTestRslt(t).Custom7 + w.GetTestRslt(t).Custom8) / 2).ToString(GetPr(p, "F3"))));
#endif

            ///
            /// Pressure
            ///
            AllItems.Add(new WMeterRsltItemSpec(ItemID.P_up,          string.Format("{0} UP ME ()",  Strings.VName_Press), Strings.Tooltip_P_up_me,  Quantity.Pressure, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).PressUpMean).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.P_up_start,    string.Format("{0} UP ST ()",  Strings.VName_Press), Strings.Tooltip_P_up_st,  Quantity.Pressure, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).PressUpStart).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.P_up_end,      string.Format("{0} UP EN ()",  Strings.VName_Press), Strings.Tooltip_P_up_en,  Quantity.Pressure, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).PressUpEnd).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.P_up_avg,      string.Format("{0} UP avg ()", Strings.VName_Press), Strings.Tooltip_P_up_avg, Quantity.Pressure, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, (w.GetTestRslt(t).PressUpStart + w.GetTestRslt(t).PressUpEnd) / 2).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.P_down,        string.Format("{0} DW ME ()",  Strings.VName_Press), Strings.Tooltip_P_dw_me,  Quantity.Pressure, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).PressDownMean).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.P_down_start,  string.Format("{0} DW ST ()",  Strings.VName_Press), Strings.Tooltip_P_dw_st,  Quantity.Pressure, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).PressDownStart).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.P_down_end,    string.Format("{0} DW EN ()",  Strings.VName_Press), Strings.Tooltip_P_dw_en,  Quantity.Pressure, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).PressDownEnd).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.P_down_avg,    string.Format("{0} DW avg ()", Strings.VName_Press), Strings.Tooltip_P_dw_avg, Quantity.Pressure, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, (w.GetTestRslt(t).PressDownStart + w.GetTestRslt(t).PressDownEnd) / 2).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.P_delta_mean,  string.Format("{0} DE ME ()",  Strings.VName_Press), Strings.Tooltip_P_de_me,  Quantity.Pressure, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).PressDeltaMean).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.P_delta_start, string.Format("{0} DE ST ()",  Strings.VName_Press), Strings.Tooltip_P_de_st,  Quantity.Pressure, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).PressDeltaStart).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.P_delta_end,   string.Format("{0} DE EN ()",  Strings.VName_Press), Strings.Tooltip_P_de_en,  Quantity.Pressure, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).PressDeltaEnd).ToString(GetPr(p, "F3"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.P_delta_avg,   string.Format("{0} DE avg ()", Strings.VName_Press), Strings.Tooltip_P_de_avg, Quantity.Pressure, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, (w.GetTestRslt(t).PressDeltaStart + w.GetTestRslt(t).PressDeltaEnd) / 2).ToString(GetPr(p, "F3"))));

            ///
            /// Ambient temperature/pressure/humidity/Buoyancy
            ///
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Ambient_temperature, string.Format("{0} Amb M", Strings.VName_Temp),  Strings.Tooltip_T_Amb_M,  Quantity.Temperature, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? Config.Units.ConvertTo(u, w.Batch.AmbTempMean()).ToString(GetPr(p, "F1")) : Config.Units.ConvertTo(u, w.GetTestRslt(t).AmbTempMean).ToString(GetPr(p, "F1"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Ambient_pressure,    string.Format("{0} Amb M", Strings.VName_Press), Strings.Tooltip_P_Amb_M,  Quantity.Pressure,    ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? Config.Units.ConvertTo(u, w.Batch.AmbPressMean()).ToString(GetPr(p, "F0")) : Config.Units.ConvertTo(u, w.GetTestRslt(t).AmbPressMean).ToString(GetPr(p, "F0"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Ambient_humidity,    string.Format("{0} Amb M", Strings.VName_Humi),  Strings.Tooltip_Hu_Amb_M, Quantity.Humidity,    ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? Config.Units.ConvertTo(u, w.Batch.AmbHumiMean()).ToString(GetPr(p, "F1")) : Config.Units.ConvertTo(u, w.GetTestRslt(t).AmbHumiMean).ToString(GetPr(p, "F1"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Buoyancy, "Buoyancy ()", Quantity.Number, ItemCategory.TestResult, (w, t, u, f, p) => string.IsNullOrEmpty(t) ? w.Batch.Buoyancy().ToString(GetPr(p, "F5")) : ((w.GetTestRslt(t) != null) ? w.GetTestRslt(t).Buoyancy.ToString(GetPr(p, "F5")) : "")));

            ///
            /// Error
            ///
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Error_limit_Lo,  Strings.ErrLimLo + "()",    Quantity.Error, ItemCategory.TestData, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).ErrLimLo()).ToString(GetPr(p, "F1"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Error_limit_Hi,  Strings.ErrLimHi + "()",    Quantity.Error, ItemCategory.TestData, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).ErrLimHi()).ToString(GetPr(p, "F1"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Uncertainty,     Strings.Uncertainty + "()", Quantity.Error, ItemCategory.TestData, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : w.GetTestRslt(t).Uncertainty().ToString(GetPr(p, "F2"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Reference_error, string.Format("{0} rel.ref. ()", Strings.VName_Error), Strings.Tooltip_E_rel_ref, Quantity.Error, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetTestRslt(t).ErrorMaster).ToString(GetPr(p, "F3"))));
#if TURA_IPERL || TURA_SPECIAL 
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Error, string.Format("{0} rel. ()", Strings.VName_Error), Strings.Tooltip_E_rel, Quantity.Error, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null) ? "0" : Config.Units.ConvertTo(u, w.GetMeterTestRslt(t).Error).ToString(GetPr(p, "F2"))));
#else
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Error, string.Format("{0} rel. ()", Strings.VName_Error), Strings.Tooltip_E_rel, Quantity.Error, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null) ? "" : Config.Units.ConvertTo(u, w.GetMeterTestRslt(t).Error).ToString(GetPr(p, "F2"))));
#endif
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Passed, Strings.Result, Quantity.Boolean, ItemCategory.MeterResult, (w, t, u, f, p) => string.IsNullOrEmpty(t) ? w.PassedColorStr() : ((w.GetMeterTestRslt(t) == null) ? "" : w.GetMeterTestRslt(t).PassedColorStr())));

            ///
            /// Water meter info
            ///
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Watermeter_type, Strings.WM_Type, Quantity.String, ItemCategory.MeterData, (w, t, u, f, p) => w.WaterMeterData.ProductName));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Producer, Strings.Producer, Quantity.String, ItemCategory.MeterData, (w, t, u, f, p) => w.WaterMeterData.Producer));

			AllItems.Add(new WMeterRsltItemSpec(ItemID.DN, "DN", Quantity.Length, ItemCategory.MeterData, (w, t, u, f, p) => string.IsNullOrEmpty(p) ? Config.Units.ConvertTo(u, w.WaterMeterData.DN).ToString()
                                                                                                                                                     : Config.Units.ConvertTo(u, w.WaterMeterData.DN).ToString(p)));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.L, "L", Quantity.Length, ItemCategory.MeterData, (w, t, u, f, p) => string.IsNullOrEmpty(p) ? Config.Units.ConvertTo(u, w.WaterMeterData.L).ToString()
                                                                                                                                                   : Config.Units.ConvertTo(u, w.WaterMeterData.L).ToString(p)));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Mounting, Strings.Mounting, Quantity.String, ItemCategory.MeterData, (w, t, u, f, p) => w.WaterMeterData.Mounting.ToDescription()));

			AllItems.Add(new WMeterRsltItemSpec(ItemID.Q4, "Q4_Qmax", Quantity.Flow, ItemCategory.MeterData, (w, t, u, f, p) => string.IsNullOrEmpty(p) ? Config.Units.ConvertTo(u, w.WaterMeterData.Q4_Qmax).ToString()
                                                                                                                                                        : Config.Units.ConvertTo(u, w.WaterMeterData.Q4_Qmax).ToString(p)));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Q3, "Q3_Qn", Quantity.Flow, ItemCategory.MeterData, (w, t, u, f, p) => string.IsNullOrEmpty(p) ? Config.Units.ConvertTo(u, w.WaterMeterData.Q3_Qn).ToString()
                                                                                                                                                      : Config.Units.ConvertTo(u, w.WaterMeterData.Q3_Qn).ToString(p)));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Q2, "Q2_Qt", Quantity.Flow, ItemCategory.MeterData, (w, t, u, f, p) => string.IsNullOrEmpty(p) ? Config.Units.ConvertTo(u, w.WaterMeterData.Q2_Qt).ToString()
                                                                                                                                                      : Config.Units.ConvertTo(u, w.WaterMeterData.Q2_Qt).ToString(p)));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Q1, "Q1_Qmin", Quantity.Flow, ItemCategory.MeterData, (w, t, u, f, p) => string.IsNullOrEmpty(p) ? Config.Units.ConvertTo(u, w.WaterMeterData.Q1_Qmin).ToString()
                                                                                                                                                        : Config.Units.ConvertTo(u, w.WaterMeterData.Q1_Qmin).ToString(p)));

			AllItems.Add(new WMeterRsltItemSpec(ItemID.Metrological_class, Strings.MClass, Quantity.String, ItemCategory.MeterData, (w, t, u, f, p) => w.WaterMeterData.MetrologicalClass));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Temperature_class, "Temperature class", Quantity.String, ItemCategory.MeterData, (w, t, u, f, p) => w.WaterMeterData.TemperatureClass.ToDescription()));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Pressure_loss_class, "Pressure loss class", Quantity.String, ItemCategory.MeterData, (w, t, u, f, p) => w.WaterMeterData.PressureLossClass.ToDescription()));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Max_admissible_pressure, "Max. admissible pressure", Quantity.String, ItemCategory.MeterData, (w, t, u, f, p) => w.WaterMeterData.MaxAdmissiblePressure.ToDescription()));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Flow_profile_sensitivity_class, "Flow profile sensitivity class", Quantity.String, ItemCategory.MeterData, (w, t, u, f, p) => w.WaterMeterData.FlowProfileSensitivityClass.ToDescription()));

			AllItems.Add(new WMeterRsltItemSpec(ItemID.Approval_info, Strings.Approval, Quantity.String, ItemCategory.MeterData, (w, t, u, f, p) => w.WaterMeterData.ApprovalInfo));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Certificate, "Certificate", Quantity.String, ItemCategory.MeterData, (w, t, u, f, p) => w.WaterMeterData.Certificate));

			AllItems.Add(new WMeterRsltItemSpec(ItemID.Pulses_per_liter, Strings.PulsesLiter, Quantity.PulsePerLtr, ItemCategory.MeterData, (w, t, u, f, p) => string.IsNullOrEmpty(p) ? w.WaterMeterData.PulsesPerLtr.ToString()
																																													   : w.WaterMeterData.PulsesPerLtr.ToString(p)));

			AllItems.Add(new WMeterRsltItemSpec(ItemID.Text1, "Text1", Quantity.String, ItemCategory.Other, (w, t, u, f, p) => w.WaterMeterData.Text1));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Text2, "Text2", Quantity.String, ItemCategory.Other, (w, t, u, f, p) => w.WaterMeterData.Text2));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Text3, "Text3", Quantity.String, ItemCategory.Other, (w, t, u, f, p) => w.WaterMeterData.Text3));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Text4, "Text4", Quantity.String, ItemCategory.Other, (w, t, u, f, p) => w.WaterMeterData.Text4));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Text5, "Text5", Quantity.String, ItemCategory.Other, (w, t, u, f, p) => w.WaterMeterData.Text5));

            /// Water meters results
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Serial_Nr, Strings.sn, Strings.Tooltip_sn, Quantity.String, ItemCategory.MeterResult, (w, t, u, f, p) => w.SerialNr));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Purchase_order, Strings.PO, Quantity.String, ItemCategory.Other, (w, t, u, f, p) => w.PurchaseOrder));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Year_of_production, Strings.Year, Quantity.Number, ItemCategory.Other, (w, t, u, f, p) => w.YearOfProduction.ToString()));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.WM_Position, Strings.Pos, Quantity.Number, ItemCategory.Other, (w, t, u, f, p) => w.WMPosition.ToString()));

            /// Water meters results (single)
			AllItems.Add(new WMeterRsltItemSpec(ItemID.End_state, Strings.End_state, Quantity.String, ItemCategory.MeterResult, (w, t, u, f, p) => w.EndState));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Pulses, Strings.Pulses + "()", Quantity.Number, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null) ? "" : w.GetMeterTestRslt(t).PulsesMeter.ToString()));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Pulses__liter, Strings.PulsesLiter + "()", Quantity.PulsePerLtr, ItemCategory.Other, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null) ? "" : (string.IsNullOrEmpty(p) ? w.GetMeterTestRslt(t).PulsesPerLiter.ToString()
																																																							   : w.GetMeterTestRslt(t).PulsesPerLiter.ToString(p))));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Reference_pulses, Strings.RefPulses + "()", Quantity.Number, ItemCategory.Other, (w, t, u, f, p) => (w.GetMeterTestRslt(t) == null) ? "" : w.GetMeterTestRslt(t).PulsesMaster.ToString()));

			/// Water meters results (combined)
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Error_main, Strings.Err_main + "()", Quantity.Error, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t, CompoundMeterId.CompoundMain) == null) ? "" : (string.IsNullOrEmpty(p) ? w.GetMeterTestRslt(t, CompoundMeterId.CompoundMain).Error.ToString()																																																													   : w.GetMeterTestRslt(t, CompoundMeterId.CompoundMain).Error.ToString(p))));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Error_aux, Strings.Err_aux + "()", Quantity.Error, ItemCategory.MeterResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t, CompoundMeterId.CompoundAux) == null) ? "" : (string.IsNullOrEmpty(p) ? w.GetMeterTestRslt(t, CompoundMeterId.CompoundAux).Error.ToString()
																																																												    : w.GetMeterTestRslt(t, CompoundMeterId.CompoundAux).Error.ToString(p))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Serial_Nr_main, string.Format("{0} {1}", Strings.sn, Strings.main), Strings.Tooltip_sn_main, Quantity.String, ItemCategory.MeterResult, (w, t, u, f, p) => w.SerialNr));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Serial_Nr_aux, string.Format("{0} {1}", Strings.sn, Strings.aux), Strings.Tooltip_sn_aux, Quantity.String, ItemCategory.MeterResult, (w, t, u, f, p) => w.SerialNrAux));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.End_state_main, Strings.EndState_main, Quantity.String, ItemCategory.MeterResult, (w, t, u, f, p) => w.EndState));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.End_state_aux, Strings.EndState_aux, Quantity.String, ItemCategory.MeterResult, (w, t, u, f, p) => w.EndStateAux));

            /// Batch info
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Test_bench_ID, Strings.Bench, Quantity.String, ItemCategory.Other, (w, t, u, f, p) => w.Batch.TestBenchId.ToString()));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Program_version, Strings.Ver, Quantity.String, ItemCategory.Other, (w, t, u, f, p) => w.Batch.ProgramVersion));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.User_nr, Strings.User_nr, Quantity.Number, ItemCategory.Other, (w, t, u, f, p) => w.Batch.UserNumber.ToString()));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.User_name, Strings.User, Quantity.String, ItemCategory.Other, (w, t, u, f, p) => Users.Entities.User.EncodedStrToUserName(w.Batch.UserName)));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.User_description, Strings.User_description, Quantity.String, ItemCategory.Other, (w, t, u, f, p) => Users.Entities.User.EncodedStrToFullName(w.Batch.UserName)));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Legalizator, Strings.Legalizator, Quantity.String, ItemCategory.Other, (w, t, u, f, p) => Users.Entities.User.EncodedStrToLegalizator(w.Batch.UserName)));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Watermeters, Strings.WMs, Quantity.String, ItemCategory.Other, (w, t, u, f, p) => w.Batch.WatermetersStr));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Protocol_title, Strings.Protocol, Quantity.String, ItemCategory.Other, (w, t, u, f, p) => w.Batch.ProtocolTitle));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Batch_start_time, Strings.Start, Quantity.DateTime, ItemCategory.Other, (w, t, u, f, p) => string.IsNullOrEmpty(f) ? w.Batch.StartTime.ToString() : string.Format(f, w.Batch.StartTime)));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Batch_end_time, Strings.End, Quantity.DateTime, ItemCategory.Other, (w, t, u, f, p) => string.IsNullOrEmpty(f) ? w.Batch.EndTime.ToString() : string.Format(f, w.Batch.EndTime)));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Lite_per_pulse_Read, "1 / PlsPerLtr_Read", Quantity.PulsePerLtr, ItemCategory.Other, (w, t, u, f, p) => string.IsNullOrEmpty(p) ? ((w.WaterMeterData.PulsesPerLtr != 0) ? 1 / w.WaterMeterData.PulsesPerLtr : 0).ToString()
                                                                                                                                                   : ((w.WaterMeterData.PulsesPerLtr != 0) ? 1 / w.WaterMeterData.PulsesPerLtr : 0).ToString(p)));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Passed_meters_count, Strings.Passed_meters_count, Quantity.Number, ItemCategory.Other, (w, t, u, f, p) => w.Batch.PassedMetersCount().ToString()));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Failed_meters_count, Strings.Failed_meters_count, Quantity.Number, ItemCategory.Other, (w, t, u, f, p) => w.Batch.FailedMetersCount().ToString()));

            /// Extra water meter data
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Result_code, Strings.Result_code, Quantity.Number, ItemCategory.MeterResult, (w, t, u, f, p) => string.IsNullOrEmpty(f) ? w.ResultCode.ToString() : string.Format(f, w.ResultCode)));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Remark, Strings.Remark, Quantity.String, ItemCategory.TestResult, (w, t, u, f, p) => w.Batch.Remark));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Meter_type, Strings.Meter_type, Quantity.String, ItemCategory.Other, (w, t, u, f, p) => w.WaterMeterData.Compound ? Strings.Compound : (w.WaterMeterData.HeatMeter ? Strings.Heat_meter : Strings.Single)));

#if HEAT_METERS
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Energy,              Strings.Energy + "()",      Quantity.Energy,        ItemCategory.Other,	(w, t, u, f, p) => (w.GetMeterTestRslt(t, Config.Entities.CompoundMeterId.HeatMeterEnergy) == null) ? "" : Config.Units.ConvertTo(u, w.GetMeterTestRslt(t, Config.Entities.CompoundMeterId.HeatMeterEnergy).VolumeMeter).ToString(GetPr(p, "F1"))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Reference_energy,    Strings.Energy_ref + "()",  Quantity.Energy,        ItemCategory.Other,	(w, t, u, f, p) => (w.GetMeterTestRslt(t, Config.Entities.CompoundMeterId.HeatMeterEnergy) == null) ? "" : Config.Units.ConvertTo(u, w.GetMeterTestRslt(t, Config.Entities.CompoundMeterId.HeatMeterEnergy).VolumeRef).ToString(GetPr(p, "F1"))));
#endif

#if IPERL
            AllItems.Add(new WMeterRsltItemSpec(ItemID.OrigCalibFactor, "iPerl OrigCalibFactor", Quantity.Number, ItemCategory.MeterResult, (w, t, u, f, p) => (w.OrigCalibFactor.ToString())));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.CalibFactor, "iPerl CalibFactor", Quantity.Number, ItemCategory.MeterResult, (w, t, u, f, p) => (w.CalibFactor.ToString())));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q2ErrWOCorrection, "iPerl Q2ErrWOCorrection", Quantity.Error, ItemCategory.MeterResult, (w, t, u, f, p) => (w.Q2ErrWOCorrection.ToString(GetPr(p, "F2")))));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q2CorrectionDone, "iPerl Q2CorrectionDone", Quantity.Boolean, ItemCategory.MeterResult, (w, t, u, f, p) => (w.Q2CorrectionDone ? "yes" : "no")));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q2CorrRFlow, "iPerl Q2CorrRFlow", Quantity.Number, ItemCategory.MeterResult, (w, t, u, f, p) => (w.Q2CorrRFlow.ToString())));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q2CorrLFlow, "iPerl Q2CorrLFlow", Quantity.Number, ItemCategory.MeterResult, (w, t, u, f, p) => (w.Q2CorrLFlow.ToString())));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.Q2CorrFlowRight, "iPerl Q2CorrFlowRight", Quantity.Volume, ItemCategory.MeterResult, (w, t, u, f, p) => (w.Q2CorrFlowRight.ToString())));
            AllItems.Add(new WMeterRsltItemSpec(ItemID.FW_Version, "iPerl FW version", Quantity.String, ItemCategory.MeterResult, (w, t, u, f, p) => (w.FWVersion)));
#endif
			AllItems.Add(new WMeterRsltItemSpec(ItemID.TestDone, Strings.Test_done + "()", Quantity.Boolean, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) != null && w.GetMeterTestRslt(t).TestDone) ? Strings.Yes : Strings.No));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.TestPassed, Strings.Test_passed + "()", Quantity.Boolean, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetMeterTestRslt(t) != null && w.GetMeterTestRslt(t).Passed) ? Strings.Yes : Strings.No));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.ErrorFlags, Strings.Error_flags + "()", Quantity.String, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) != null) ? w.GetTestRslt(t).ErrorFlagsStr() : w.ErrorFlagstStr()));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.E1,  "E1 ()",  Quantity.Boolean, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) != null && (w.GetTestRslt(t).ErrorFlags & 0x0001) != 0) ? Strings.Yes : Strings.No));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.E2,  "E2 ()",  Quantity.Boolean, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) != null && (w.GetTestRslt(t).ErrorFlags & 0x0002) != 0) ? Strings.Yes : Strings.No));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.E3,  "E3 ()",  Quantity.Boolean, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) != null && (w.GetTestRslt(t).ErrorFlags & 0x0004) != 0) ? Strings.Yes : Strings.No));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.E4,  "E4 ()",  Quantity.Boolean, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) != null && (w.GetTestRslt(t).ErrorFlags & 0x0008) != 0) ? Strings.Yes : Strings.No));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.E5,  "E5 ()",  Quantity.Boolean, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) != null && (w.GetTestRslt(t).ErrorFlags & 0x0010) != 0) ? Strings.Yes : Strings.No));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.E6,  "E6 ()",  Quantity.Boolean, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) != null && (w.GetTestRslt(t).ErrorFlags & 0x0020) != 0) ? Strings.Yes : Strings.No));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.E7,  "E7 ()",  Quantity.Boolean, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) != null && (w.GetTestRslt(t).ErrorFlags & 0x0040) != 0) ? Strings.Yes : Strings.No));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.E8,  "E8 ()",  Quantity.Boolean, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) != null && (w.GetTestRslt(t).ErrorFlags & 0x0080) != 0) ? Strings.Yes : Strings.No));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.E9,  "E9 ()",  Quantity.Boolean, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) != null && (w.GetTestRslt(t).ErrorFlags & 0x0100) != 0) ? Strings.Yes : Strings.No));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.E10, "E10 ()", Quantity.Boolean, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) != null && (w.GetTestRslt(t).ErrorFlags & 0x0200) != 0) ? Strings.Yes : Strings.No));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.E11, "E11 ()", Quantity.Boolean, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) != null && (w.GetTestRslt(t).ErrorFlags & 0x0400) != 0) ? Strings.Yes : Strings.No));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.E12, "E12 ()", Quantity.Boolean, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) != null && (w.GetTestRslt(t).ErrorFlags & 0x0800) != 0) ? Strings.Yes : Strings.No));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.E13, "E13 ()", Quantity.Boolean, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) != null && (w.GetTestRslt(t).ErrorFlags & 0x1000) != 0) ? Strings.Yes : Strings.No));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.E14, "E14 ()", Quantity.Boolean, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) != null && (w.GetTestRslt(t).ErrorFlags & 0x2000) != 0) ? Strings.Yes : Strings.No));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.E15, "E15 ()", Quantity.Boolean, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) != null && (w.GetTestRslt(t).ErrorFlags & 0x4000) != 0) ? Strings.Yes : Strings.No));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.E16, "E16 ()", Quantity.Boolean, ItemCategory.TestResult, (w, t, u, f, p) => (w.GetTestRslt(t) != null && (w.GetTestRslt(t).ErrorFlags & 0x8000) != 0) ? Strings.Yes : Strings.No));

			AllItems.Add(new WMeterRsltItemSpec(ItemID.Table_row_nr, "Table row #", Quantity.Number, ItemCategory.Other, (w, t, u, f, p) => string.IsNullOrEmpty(f) ? TableRowNr.ToString() : string.Format(f, TableRowNr)));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.Table_column_nr, "Table column #", Quantity.Number, ItemCategory.Other, (w, t, u, f, p) => string.IsNullOrEmpty(f) ? TableColumnNr.ToString() : string.Format(f, TableColumnNr)));
			AllItems.Add(new WMeterRsltItemSpec(ItemID.WMRemark, string.Format("{0} {1}", Strings.Water_Meter, Strings.Remark), Quantity.String, ItemCategory.MeterResult, (w, t, u, f, p) => w.Remark));
		}

		/// To be updated by Output.FileWriter or Output.Printer
		public static int TableRowNr;
		public static int TableColumnNr;

        /// <summary>
        /// Converts a list of 'Output item specifications' to a string array
        /// </summary>
        /// <param name="items"></param>
        /// <returns></returns>
        public static string[] ToStrArray(IList<WMeterRsltItemSpec> items)
		{
			int count = (items != null) ? items.Count : 0;
			string[] result = new string[count];
            for (int i = 0; i < count; i++)
            {
                result[i] = string.Format("{0}~{1}~{2}~{3}~{4}~{5}~{6}~{7}",
                                          items[i].Uid,
                                          items[i].Caption,
                                          items[i].TestID,
                                          items[i].Units,
                                          items[i].Format,
                                          items[i].Precision,
                                          items[i].Width,
										  items[i].Alignment);
            }
			return result;
		}

        /// <summary>
        /// Converts a string array to a list of 'Output item specifications'
        /// </summary>
        /// <param name="strArray"></param>
        /// <returns></returns>
        public static IList<WMeterRsltItemSpec> FromStrArray(string[] strArray)
		{
            IList<WMeterRsltItemSpec> result = new List<WMeterRsltItemSpec>();

			if (strArray != null)
			{
				for (int i = 0; i < strArray.Length; i++)
				{
					try
					{
                        WMeterRsltItemSpec item;
                        string[] field = strArray[i].Split(new char[] { '~' });

                        if (!strArray[i].Contains("~"))
						{
							///
							/// Old style results item specification -> convert it
							/// 
							bool added = false;
							foreach (var it in AllItems)
							{
								if (strArray[i].Equals(it.OldUid))
								{
									item = it.Clone();
									item.Caption = item.Name.Replace("()", "").Replace(" *", "");
									item.Units = 0;			/// use default units
									item.Format = null;		/// the same like format string "{0}"
									item.Precision = null;
									item.Width = 0;			/// do not ad any extra spaces
									item.Alignment = Alignment.Left;
									result.Add(item);
									added = true;
									break;
								}
							}
							if (!added)
							{
								item = GetItem(0);
								item.Caption = "Prs.Err.";
								item.Format = string.Format("Parse error: {0}", strArray[i]);
								result.Add(item);
							}
						}
                        else if ((item = GetItem(int.Parse(field[0]))) != null)
                        {
							///
							/// Load the new style results item specification
							/// 
							item.Caption = field[1];
							item.TestID = field[2];
							item.Units = 0;
							for (Config.Unit u = 0; u < Config.Unit.Count; u++)
							{
								if (u.ToString().Equals(field[3])) { item.Units = u; break; }
							}
							item.Format = field[4];
							item.Precision = field[5];
							item.Width = int.Parse(field[6]);
							item.Alignment = 0;
							for (Config.Entities.Alignment a = 0; a < Config.Entities.Alignment.Count; a++)
							{
								if (a.ToString().Equals(field[7])) { item.Alignment = a; break; }
							}

							result.Add(item);
						}
                        else
                        {
                            ///
                            /// Create an item with parse error information
                            /// 
                            WMeterRsltItemSpec item2 = GetItem(0);
                            item2.Caption = "Prs.Err.";
                            item2.Format = string.Format("Parse error: {0}", strArray[i]);
                            result.Add(item2);
                        }
					}
					catch
					{
						WMeterRsltItemSpec item = GetItem(0);
						item.Caption = "Prs.Err.";
						item.Format = string.Format("Parse error: {0}", strArray[i]);
						result.Add(item);
					}
				}
			}
			return result;
		}


        public static WMeterRsltItemSpec GetItem(int uid)
        {
            foreach (var item in AllItems)
            {
                if (item.Uid == uid) return item.Clone();
            }
            return null;
        }


        public static WMeterRsltItemSpec GetItem(ItemID itemId)
        {
            return GetItem((int)itemId);
        }
    }
}