Reconfigured for Munich, with camera, w/o graphs.

.gitignore

@@ -4,14 +4,18 @@ DeviceTest/bin/
 DeviceTest/obj/
 Dirichlet.Numerics/bin
 Dirichlet.Numerics/obj
+GemCard/bin
+GemCard/obj
 GraphLib/bin
 GraphLib/obj
+MonitoringDB/bin
+MonitoringDB/obj
 Results/bin/
 Results/obj/
 ResultsBrowser/bin/
 ResultsBrowser/obj/
-TestBenchFramework/bin/
-TestBenchFramework/obj/
+TBF/bin/
+TBF/obj/
 TBFSetup/Debug/
 TBFSetup/Release/
 Users/bin/

Config/Config.csproj

@@ -18,7 +18,7 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>TRACE;DEBUG;MUNICH</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;MUNICH;LANG_DE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
@@ -28,7 +28,7 @@
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE;MUNICH</DefineConstants>
+    <DefineConstants>TRACE;MUNICH;LANG_DE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
@@ -77,6 +77,7 @@
     <Compile Include="Entities\IHasItemNr.cs" />
     <Compile Include="Entities\IHasName.cs" />
     <Compile Include="Entities\IHasValves.cs" />
+    <Compile Include="Entities\IParamsProvider.cs" />
     <Compile Include="Entities\MeasurementCorrection.cs" />
     <Compile Include="Entities\MetersPath.cs" />
     <Compile Include="Entities\OutputPath.cs" />
@@ -91,6 +92,7 @@
     <Compile Include="Entities\Watermeter.cs" />
     <Compile Include="Entities\WMType.cs" />
     <Compile Include="FluentCommon.cs" />
+    <Compile Include="Formulas.cs" />
     <Compile Include="Mappings\BenchPathMap.cs" />
     <Compile Include="Mappings\ComponentMap.cs" />
     <Compile Include="Mappings\ComponentProcedureMap.cs" />
@@ -117,6 +119,7 @@
       <DependentUpon>Strings.resx</DependentUpon>
     </Compile>
     <Compile Include="Units.cs" />
+    <Compile Include="Utils.cs" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Resources\Strings.cs.resx" />

Config/Data.cs

@@ -14,7 +14,7 @@ namespace Config
 		public const int CompoundWMsCount = 1;
 		public const int HeatMetersCount = 0;
         public const int MaxPartNr = 3;
-#elif DN100 || BADGER_VELKA_TRAT
+#elif DN100 || BADGER_STREDNA_TRAT || BADGER_VELKA_TRAT
 		public const int WMsCount = 3;
 		public const int LineSize = 3;
 		public const int CompoundWMsCount = 1;
@@ -32,7 +32,7 @@ namespace Config
 		public const int CompoundWMsCount = 1;
 		public const int HeatMetersCount = 0;
         public const int MaxPartNr = 1;
-#elif TORUN_PT50_2015 || CEVAK_PT40_272 || MURES_PT40 || FUZHOU_40 || PETERSBURG_50 || KEMPNO_50 || BAHRAIN_50 || KRAKOW_50
+#elif TORUN_PT50_2015 || CEVAK_PT40_272 || MURES_PT40 || FUZHOU_40 || PETERSBURG_50 || KEMPNO_50 || BAHRAIN_50 || KRAKOW_50 || JUZNA_AFRIKA_50 || ZAMBIA
         public const int WMsCount = 20;
 		public const int LineSize = 10;
 		public const int CompoundWMsCount = 1;
@@ -50,8 +50,8 @@ namespace Config
 		public const int CompoundWMsCount = 1;
 		public const int HeatMetersCount = 0;
         public const int MaxPartNr = WMsCount / LineSize;
-#elif TURA_SPECIAL
-		public const int WMsCount = 6;
+#elif TURA_SPECIAL || SENTEC
+        public const int WMsCount = 6;
 		public const int LineSize = 6;
 		public const int CompoundWMsCount = 1;
 		public const int HeatMetersCount = 0;
@@ -76,7 +76,7 @@ namespace Config
         public const int MaxPartNr = WMsCount / LineSize;
 #endif
 
-		///
+        ///
 		/// Database related: This object reference is set after a successful user login
 		///
 		public static DatabaseSettings CurrentBench;

Config/Entities/Component.cs

@@ -3,6 +3,8 @@
 ///
 using System;
 using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
 
 namespace Config.Entities
 {
@@ -22,6 +24,8 @@ namespace Config.Entities
 
 		public Component()
 		{
+            Name = string.Empty;
+            ClassName = string.Empty;
 			Corrections = new List<MeasurementCorrection>();
 		}
 
@@ -53,6 +57,59 @@ namespace Config.Entities
 			return result;
 		}
 
+        public virtual void Export(StreamWriter output)
+        {
+            output.WriteLine(Name);
+            output.WriteLine(ClassName);
+            output.WriteLine(ParentName);
+            output.WriteLine(Mode.ToString());
+            output.WriteLine(Logging.ToString());
+            output.Write(Parameters);
+
+            output.Close();
+        }
+
+        public static Component Import(StreamReader input)
+        {
+            Component result = new Component();
+
+            result.Name = input.ReadLine();
+            result.ClassName = input.ReadLine();
+            result.ParentName = input.ReadLine();
+
+            string line = input.ReadLine();
+            if (line.Equals(DebugMode.DetectedOff.ToString())) result.Mode = DebugMode.DetectedOff;
+            else if (line.Equals(DebugMode.DetectedOn.ToString())) result.Mode = DebugMode.DetectedOn;
+            else if (line.Equals(DebugMode.Normal.ToString())) result.Mode = DebugMode.Normal;
+            else if (line.Equals(DebugMode.AutoDetect.ToString())) result.Mode = DebugMode.AutoDetect;
+            else if (line.Equals(DebugMode.FailureDuringOperation.ToString())) result.Mode = DebugMode.FailureDuringOperation;
+            else if (line.Equals(DebugMode.Off.ToString())) result.Mode = DebugMode.Off;
+            else if (line.Equals(DebugMode.Record.ToString())) result.Mode = DebugMode.Record;
+            else if (line.Equals(DebugMode.Reply.ToString())) result.Mode = DebugMode.Reply;
+            else if (line.Equals(DebugMode.Simulate.ToString())) result.Mode = DebugMode.Simulate;
+            else if (line.Equals(DebugMode.Inherit.ToString())) result.Mode = DebugMode.Inherit;
+
+            line = input.ReadLine();
+            if (line.Equals(LogLevel.Off.ToString())) result.Logging = LogLevel.Off;
+            else if (line.Equals(LogLevel.Fatal.ToString())) result.Logging = LogLevel.Fatal;
+            else if (line.Equals(LogLevel.Error.ToString())) result.Logging = LogLevel.Error;
+            else if (line.Equals(LogLevel.Warn.ToString())) result.Logging = LogLevel.Warn;
+            else if (line.Equals(LogLevel.Info.ToString())) result.Logging = LogLevel.Info;
+            else if (line.Equals(LogLevel.Debug.ToString())) result.Logging = LogLevel.Debug;
+            else if (line.Equals(LogLevel.All.ToString())) result.Logging = LogLevel.All;
+
+            result.Parameters = string.Empty;
+            line = input.ReadLine();
+            while (line != null)
+            {
+                result.Parameters += line;
+                result.Parameters += Environment.NewLine;
+                line = input.ReadLine();
+            }
+
+            return result;
+        }
+
 		public virtual string ToString(string indent)
 		{
 			string result = string.Empty;
@@ -70,5 +127,10 @@ namespace Config.Entities
 
 			return result;
 		}
+
+        public override string ToString()
+        {
+            return string.Format("{0} ({1})", Name, ClassName);
+        }
 	}
 }

Config/Entities/ComponentProcedure.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2017 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
 using System;
 using System.IO;
@@ -13,13 +13,25 @@ namespace Config.Entities
 		public virtual string Parameters { get; set; }
 		public virtual Procedure Procedure { get; set; }
 
+        IParamsProvider paramsProvider;
+        /// 
+        public virtual IParamsProvider GetParamsProvider() { return paramsProvider; }
+        public virtual void SetParamsProvider(IParamsProvider paramsProvider) { this.paramsProvider = paramsProvider; }
+
+
+        protected ComponentProcedure() { }
+
+        public ComponentProcedure(string name, string parameters, Procedure procedure)
+        {
+            this.CmpntName = name;
+            this.Parameters = parameters;
+            this.Procedure = procedure;
+        }
+
+
 		public virtual ComponentProcedure Clone(Procedure newProcedure)
 		{
-			ComponentProcedure result = new ComponentProcedure();
-			result.CmpntName = CmpntName;
-			result.Parameters = Parameters;
-            result.Procedure = newProcedure;
-			return result;
+            return new ComponentProcedure(CmpntName, Parameters, newProcedure);
 		}
 
         public virtual void Export(StreamWriter output)
@@ -34,11 +46,16 @@ namespace Config.Entities
 
             if (string.IsNullOrEmpty(firstLine)) return null;
 
-            ComponentProcedure result = new ComponentProcedure();
-            result.CmpntName = firstLine;
-            result.Parameters = input.ReadLine().Replace("~", Environment.NewLine);
-            result.Procedure = newProcedure;
-            return result;
+            try
+            {
+                string cmptnName = firstLine;
+                string parameters = input.ReadLine().Replace("~", Environment.NewLine);
+                return new ComponentProcedure(cmptnName, parameters, newProcedure);
+            }
+            catch (Exception)
+            {
+                return null;
+            }
         }
 	}
 }

Config/Entities/ComponentTest.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2017 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
 using System;
 using System.IO;
@@ -13,13 +13,25 @@ namespace Config.Entities
 		public virtual string Parameters { get; set; }
 		public virtual Test Test { get; set; }
 
+        IParamsProvider paramsProvider;
+        /// 
+        public virtual IParamsProvider GetParamsProvider() { return paramsProvider; }
+        public virtual void SetParamsProvider(IParamsProvider paramsProvider) { this.paramsProvider = paramsProvider; }
+
+
+        protected ComponentTest() { }
+
+        public ComponentTest(string name, string parameters, Test test)
+        {
+            this.CmpntName = name;
+            this.Parameters = parameters;
+            this.Test = test;
+        }
+
+
 		public virtual ComponentTest Clone()
 		{
-			ComponentTest result = new ComponentTest();
-			result.CmpntName = CmpntName;
-			result.Parameters = Parameters;
-			result.Test = Test;
-			return result;
+            return new ComponentTest(CmpntName, Parameters, Test);
 		}
 
         public virtual void Export(StreamWriter output)
@@ -34,11 +46,16 @@ namespace Config.Entities
 
             if (string.IsNullOrEmpty(firstLine)) return null;
 
-            ComponentTest result = new ComponentTest();
-            result.CmpntName = firstLine;
-            result.Parameters = input.ReadLine().Replace("~", Environment.NewLine);
-            result.Test = newTest;
-            return result;
+            try
+            {
+                string cmptnName = firstLine;
+                string parameters = input.ReadLine().Replace("~", Environment.NewLine);
+                return new ComponentTest(cmptnName, parameters, newTest);
+            }
+            catch (Exception)
+            {
+                return null;
+            }
         }
     }
 }

Config/Entities/Enums.cs

@@ -38,7 +38,45 @@ namespace Config.Entities
         }
     }
 
-	public enum ProcedureState
+    /// <summary>
+    /// Flags returned by each device configuration control Verify(...) function.
+    /// </summary>
+    public enum CfgUpdateFlags
+    {
+        None = 0,
+        Error = 0x1,			/// Some settings in the user control are invalid and cannot be set
+        Warning = 0x02,			/// Some settings in the user control are suspicious, can be set after user confirmation
+        RestartRqrd = 0x04,		/// TBF program restart is required to apply all changed parameters
+        AnyChange = 0x08,		/// At least one parameter have changed
+        VolatileChange = 0x10,
+        InvokeCfgChange = 0x20,	/// Invoke CfgChange handler of the component 
+    }
+
+    public enum RemoteDBUse
+    {
+        [Description("Local DB only")]          LocalDBOnly,
+        [Description("Remote DB only")]         RemoteDBOnly,
+        [Description("Both DB-s, local 1st")]   BothDBsLocalFirst,
+        [Description("Both DB-s, remote 1st")]  BothDBsRemoteFirst,
+        Count,
+    }
+
+    /// <summary>
+    /// Contains a procedure name and a database specification (local/remote).
+    /// </summary>
+    public class ProcedureInfo
+    {
+        public readonly string Name;
+        public readonly Users.Entities.DBKind DBKind;
+
+        public ProcedureInfo(string name, Users.Entities.DBKind dbKind)
+        {
+            Name = name;
+            DBKind = dbKind;
+        }
+    }
+
+    public enum ProcedureState
 	{
 		Active,
 		History,
@@ -80,9 +118,17 @@ namespace Config.Entities
 
 	public enum Medium
 	{
-        [Description("")]  NotSpecified,
-		ColdWater,
-		HotWater,
+        [Description("")]       NotSpecified,
+#if LANG_PL
+        [Description("zimna")]  ColdWater,
+        [Description("ciepła")] HotWater,
+#elif LANG_IT
+        [Description("freddo")] ColdWater,
+        [Description("caldo")]  HotWater,
+#else
+		[Description("cold")]   ColdWater,
+		[Description("hot")]    HotWater,
+#endif
         Count
     }
 
@@ -156,6 +202,17 @@ namespace Config.Entities
         Count
     }
 
+    /// <summary> Register reader type </summary>
+    public enum RegisterReaderType
+    {
+        Unknown,
+        Pulses,         /// Sick, optical and similar
+        Camera,         /// CLP1611
+        DataStream,     /// iPerl
+        Manual,         /// Entered by human via form (also from camera images)
+        Count
+    }
+
 	/// <summary> Transition step is finished when this condition is fulfilled </summary>
 	public enum StepCondition
 	{
@@ -374,6 +431,22 @@ namespace Config.Entities
         Count
     }
 
+    public enum VertAlignment
+    {
+        [Description("Top")]        Top,
+        [Description("Middle")]     Middle,
+        [Description("Bottom")]     Bottom,
+    }
+
+    public enum TableForm
+    {
+        None,
+        Rows,
+        Columns,
+        ColumnsPL,
+        Count,
+    }
+
 	public enum ImageRotation
 	{
 		[Description("0 deg")]		None,

Config/Entities/IParamsProvider.cs

@@ -1,10 +1,19 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
-namespace TBF.BenchControl.Generic
+using System;
+using System.Collections.Generic;
+using System.Xml.Serialization;
+
+namespace Config.Entities
 {
 	public interface IParamsProvider
 	{
+        /// <summary>
+        /// Get XML Serializer
+        /// </summary>
+        XmlSerializer GetSerializer();
+
 		string ComponentName { get; }
 
 		/// <summary>
@@ -13,13 +22,19 @@ namespace TBF.BenchControl.Generic
 		int ParamsCount();
 
 		/// <summary>
-		/// Parameter names
+		/// Returns a parameter name
 		/// </summary>
 		/// <param name="ix">Zero based index of the parameter</param>
 		string ParamName(int ix);
 
+        /// <summary>
+        /// Returns a list of possible values of one parameter (ComboBox when editing) or null (Textbox when editing).
+        /// </summary>
+        /// <param name="ix">Zero based index of the parameter</param>
+        IList<string> ParamValues(int ix);
+
 		/// <summary>
-		/// Parameter values in string form
+		/// Returns a parameter value in the string form
 		/// </summary>
 		/// <param name="ix">Zero based index of the parameter</param>
 		string ToString(int ix);
@@ -43,9 +58,9 @@ namespace TBF.BenchControl.Generic
 		/// </summary>
 		/// <param name="ix">Zero based index of the parameter</param>
 		/// <param name="strValue">String representation of the parameter</param>
-		void UpdateParam(int ix, string strValue);
+        CfgUpdateFlags UpdateParam(int ix, string strValue);
 
-		void UpdateDbEntity();
+		void UpdateEmbeddedDbEntity();
 
         /// <summary>
         /// Creates an object copy

Config/Entities/MeasurementCorrection.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
 using System;
 
@@ -8,7 +8,15 @@ namespace Config.Entities
 	public class MeasurementCorrection
 	{
 		public virtual int Id { get; protected set; }
+        public virtual int RangeIx { get; set; }        /// 0..5
 		public virtual float Measurement { get; set; }
 		public virtual float Correction { get; set; }
+
+        public MeasurementCorrection() { }
+
+        public MeasurementCorrection(int rangeIx)
+        {
+            RangeIx = rangeIx;
+        }
 	}
 }

Config/Entities/Procedure.cs

@@ -225,6 +225,15 @@ namespace Config.Entities
             return diff.ToString();
         }
 
+        public virtual ComponentProcedure GetProcedureParamsEntity(string cmpntName)
+        {
+            foreach (var procPrms in MoreParams)
+            {
+                if (procPrms.CmpntName == cmpntName) return procPrms;
+            }
+            return null;
+        }
+
 		public override string ToString()
 		{
 			return string.Format("{0}, rev.{1}", Name, Revision);

Config/Entities/Test.cs

@@ -301,6 +301,15 @@ namespace Config.Entities
             return diff.ToString();
         }
 
+        public virtual ComponentTest GetTestParamsEntity(string cmpntName)
+        {
+            foreach (var tstPrms in MoreParams)
+            {
+                if (tstPrms.CmpntName == cmpntName) return tstPrms;
+            }
+            return null;
+        }
+
         public virtual float GetErrLimLo(float flow)
         {
             if (ErrLimLo <= ErrLimHi)

Config/FluentCommon.cs

@@ -39,7 +39,11 @@ namespace Config
 					dbType = Data.CurrentBench.WaterMetersDBSettings.DbType;
 					connectionString = Data.CurrentBench.WaterMetersDBSettings.ConnectionString;
                     break;
-			}
+                case Users.Entities.DBKind.RemoteConfig:
+                    dbType = Data.CurrentBench.UsersDBSettings.DbType;
+                    connectionString = Data.CurrentBench.UsersDBSettings.ConnectionString;
+                    break;
+            }
 
             return CreateSessionFactory(database, dbType, connectionString, false);
 		}
@@ -69,6 +73,7 @@ namespace Config
                 {
                     default:
 					case Users.Entities.DBKind.Config:
+                    case Users.Entities.DBKind.RemoteConfig:
                         cfg = cfg.Mappings(m => m.FluentMappings.AddFromAssemblyOf<Data>());
                         break;
                     case Users.Entities.DBKind.Results:

Config/Formulas.cs

@@ -1,11 +1,11 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
 using log4net;
 
-namespace TBF.BenchControl
+namespace Config
 {
     public static class Formulas
     {
@@ -83,19 +83,50 @@ namespace TBF.BenchControl
 				 0.191203,
 				 0.049025,
 			};
+        }
 
+        /// <summary>
+        /// Calculate density of distilled water from temperature
+        /// </summary>
+        /// <param name="t">ITS-90 temperature in [°C]</param>
+        /// <returns>Density in [kg/m3]</returns>
+        public static double DistilledWaterDensityFromTemp(double t)
+        {
+            if (t <= 40)
+            {
+                const double c0 = 999.839564;
+                const double c1 = 0.067998613;
+                const double c2 = -0.0091101468;
+                const double c3 = 0.00010058299;
+                const double c4 = -0.0000011275659;
+                const double c5 = 6.5985371e-09;
+
+                return ((((c5 * t + c4) * t + c3) * t + c2) * t + c1) * t + c0;
+            }
+            else
+            {
+                const double a0 = 9.9983952E2;
+                const double a1 = 1.6952577E1;
+                const double a2 = -7.9905127E-3;
+                const double a3 = -4.6241757E-5;
+                const double a4 = 1.0584601E-7;
+                const double a5 = -2.8103006E-10;
+                const double b = 1.6887236E-2;
+
+                return (((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t + a0) / (1.0 + b * t);
+            }
         }
 
 		/// <summary>
-		/// Calculate density of distilled water from temperature
+		/// Calculate density of distilled water from temperature (obsolete)
 		/// </summary>
-		/// <param name="t">Temperature in [°C]</param>
+		/// <param name="t">IPTS-68 temperature in [°C]</param>
 		/// <returns>Density in [kg/m3]</returns>
-        public static double DistilledWaterDensityFromTemp(double t)
+        public static double DistilledWaterDensityFromTempIPTS68(double t)
         {
             const double a0 = 999.842594;
             const double a1 = 0.06793952;
-            const double a2 = -0.00909529;
+            const double a2 = -0.009095290;
             const double a3 = 0.0001001685;
             const double a4 = -0.000001120083;
             const double a5 = 6.536332e-09;
@@ -122,12 +153,29 @@ namespace TBF.BenchControl
 		/// </summary>
 		/// <param name="t">Temperature in [°C]</param>
 		/// <returns>Density in [kg/m3]</returns>
-		public static double WaterDensityFromTemp(double t)
+		public static double WaterDensityFromTemp(double t, double realDensity, double atTemperature)
 		{
-			return DistilledWaterDensityFromTemp(t) +
-					DensityCorrection(Program.LocalSettings.RealDensity, Program.LocalSettings.AtTemperature);
+            return DistilledWaterDensityFromTemp(t) + DensityCorrection(realDensity, atTemperature);
 		}
 
+        /// <summary>
+        /// Calculate corrected (real) water density from temperature
+        /// </summary>
+        /// <param name="t">Temperature in [°C]</param>
+        /// <returns>Density in [kg/m3]</returns>
+        public static double WaterDensityFromTempPress(double temp, double pressure, double realDensity, double atTemperature)
+        {
+            double x0 = 5.08821E-10;
+            double x1 = 1.2639418;
+            double x2 = 0.2660269;
+            double x3 = 0.3734838;
+            double x4 = 2.0205242;
+            double theta = temp / 100.0;
+            double B = x0 * (((x3 * theta + x2) * theta + x1) * theta + 1) / (1 + x4 * theta);
+
+            return WaterDensityFromTemp(temp, realDensity, atTemperature) * (1 + B * Config.Units.ConvertTo(Config.Unit.Pa, pressure));
+        }
+
 
 		public static float AirDensityFromAmbientVales(float tempC, float pressureBar, float humiPct)
 		{
@@ -214,6 +262,20 @@ namespace TBF.BenchControl
 		}
 
 
+        /// <summary>
+        /// Converts a measurement error to a correction (used when preparing correction tables).
+        /// </summary>
+        /// <param name="measuredValue">Measured value (in arbitrary units)</param>
+        /// <param name="error">Measurement error in %</param>
+        /// <returns>Correction in the same units as the measured value</returns>
+        public static double CorrectionFromError(double measuredValue, double error)
+        {
+            double trueValue = measuredValue / (1 + error/100);
+            double correction = trueValue - measuredValue;
+            return correction;
+        }
+
+
         /// <summary>
         /// Calculates the heat coefficient for water
         /// </summary>

Config/Mappings/MeasurementCorrectionMap.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
 using FluentNHibernate.Mapping;
 using Config.Entities;
@@ -11,6 +11,7 @@ namespace Config.Mappings
 		public MeasurementCorrectionMap()
 		{
 			Id(x => x.Id);
+            Map(x => x.RangeIx);
 			Map(x => x.Measurement);
 			Map(x => x.Correction);
 		}

Config/Properties/AssemblyInfo.cs

@@ -10,7 +10,7 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("Sensus")]
 [assembly: AssemblyProduct("Config")]
-[assembly: AssemblyCopyright("Copyright ©  2013 - 2016 Sensus Slovensko a.s.")]
+[assembly: AssemblyCopyright("Copyright ©  2013 - 2018 Sensus Slovensko a.s.")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
@@ -32,5 +32,5 @@ using System.Runtime.InteropServices;
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("2.17.742.0")]
-[assembly: AssemblyFileVersion("2.17.742.0")]
+[assembly: AssemblyVersion("2.18.928.0")]
+[assembly: AssemblyFileVersion("2.18.928.0")]

Config/Units.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2016-2017 Sensus Slovensko a.s.
+/// Copyright (c) 2016-2018 Sensus Slovensko a.s.
 ///
 using System;
 using System.Reflection;
@@ -11,6 +11,12 @@ namespace Config
     {
 		[Description("---")]		None,
 
+        [Description("imp.")]       pulse,
+#if LANG_PL
+        [Description("stopień")]    degree,
+#else
+        [Description("degree")]     degree,
+#endif
         [Description("l")]          l,          /// * 1 liter
         [Description("dm3")]        dm3,        ///   1 dm3 = 1 liter
         [Description("m3")]         m3,         ///   1000 l
@@ -30,7 +36,7 @@ namespace Config
         [Description("hr")]         hour,       ///   1 hour = 60 min = 3600 s
         [Description("ms")]         ms,         ///   1 ms = 0.001 s
 
-        [Description("°C")]         C,          /// * degree Celsius
+		[Description("°C")]         C,          /// * degree Celsius (°C)
         [Description("°F")]         F,          ///   degree Fahrenheit
         [Description("K")]          K,          ///   degree Kelvin
 
@@ -62,9 +68,28 @@ namespace Config
         [Description("kWh")]        kWh,		///   1 kWh = 3600000 J
         [Description("MWh")]        MWh,		///   1 MWh = 3600000000 J
 
+#if LANG_PL
+        [Description("imp/l")]       ppl,		/// * 1 pulse/l
+        [Description("imp/dm3")]     ppdm3,		/// * 1 pulse/dm3
+        [Description("stopień/l")]   degpl,		/// * 1 degree/l
+        [Description("stopień/dm3")] degpdm3,	/// * 1 degree/dm3
+        [Description("l/imp")]       lpp,		/// * 1 l/pulse
+        [Description("dm3/imp")]     dm3pp,		/// * 1 dm3/pulse
+        [Description("l/stopień")]   lpdeg,		/// * 1 l/degree
+        [Description("dm3/stopień")] dm3pdeg,	/// * 1 dm3/degree
+#else
         [Description("pulse/l")]    ppl,		/// * 1 pulse/l
-                                                /// 
+        [Description("pulse/dm3")]  ppdm3,		/// * 1 pulse/dm3
+        [Description("degree/l")]   degpl,		/// * 1 degree/l
+        [Description("degree/dm3")] degpdm3,	/// * 1 degree/dm3
+        [Description("l/pulse")]    lpp,		/// * 1 l/pulse
+        [Description("dm3/pulse")]  dm3pp,		/// * 1 dm3/pulse
+        [Description("l/degree")]   lpdeg,		/// * 1 l/degree
+        [Description("dm3/degree")] dm3pdeg,	/// * 1 dm3/degree
+#endif
+        /// 
         [Description("pulse/kWh")]  ppkWh,		/// * 1 pulse/kWh
+        [Description("kWh/pulse")]  kWhpp,		/// * 1 kWh/pulse
                                                 
         Count
     }
@@ -84,6 +109,7 @@ namespace Config
 		[Description("Länge")]				Length,
 		[Description("Dichte")]				Density,
 		[Description("Energie")]			Energy,
+		[Description("Impulse")]			Pulses,
         [Description("Impulse/l")]			PulsePerLtr,
         [Description("Impulse/kWh")]		PulsePerKWh,
 
@@ -93,7 +119,7 @@ namespace Config
         [Description("Boolean")]			Boolean,
         [Description("Datum und Uhrzeit")]  DateTime,
 #elif LANG_PL
-		[Description("Objętość")]			Volume,
+        [Description("Objętość")]			Volume,
 		[Description("Przepływ")]           Flow,
 		[Description("Masa")]				Mass,
         [Description("Czas")]				Time,
@@ -104,6 +130,7 @@ namespace Config
 		[Description("Długość")]			Length,
 		[Description("Gęstość")]			Density,
 		[Description("Energia")]			Energy,
+        [Description("Impulsy")]            Pulses,
         [Description("Impulsy/litr")]       PulsePerLtr,
         [Description("Impulsy/kWh")]		PulsePerKWh,
 
@@ -124,6 +151,7 @@ namespace Config
 		[Description("Délka")]				Length,
 		[Description("Hustota")]			Density,
 		[Description("Energie")]			Energy,
+		[Description("Pulzy")]				Pulses,
         [Description("Pulzy/litr")]			PulsePerLtr,
         [Description("Pulzy/kWh")]			PulsePerKWh,
 
@@ -132,8 +160,29 @@ namespace Config
         [Description("Text")]				String,
         [Description("Boolean")]			Boolean,
         [Description("Datum a čas")]		DateTime,
-#else
+#elif LANG_IT
 		[Description("Volume")]				Volume,
+		[Description("Flusso")]				Flow,
+		[Description("Massa")]              Mass,
+        [Description("Tempo")]				Time,
+        [Description("Temperatura")]	    Temperature,
+		[Description("Pressione")]			Pressure,
+        [Description("Umidità")]			Humidity,
+        [Description("Errore")]				Error,
+		[Description("Lungezza")]			Length,
+		[Description("Densità")]			Density,
+		[Description("Energia")]			Energy,
+		[Description("Impulso")]			Pulses,
+        [Description("Impulso/litro")]		PulsePerLtr,
+        [Description("Impulso/kWh")]		PulsePerKWh,
+
+        /// Quantities without units and conversions
+        [Description("Numero")]				Number,
+        [Description("Stringa")]			String,
+        [Description("Boolean")]			Boolean,
+        [Description("Data e ora")]		    DateTime,
+#else
+        [Description("Volume")]				Volume,
 		[Description("Flow")]				Flow,
 		[Description("Mass")]				Mass,
         [Description("Time")]				Time,
@@ -144,6 +193,7 @@ namespace Config
 		[Description("Length")]				Length,
 		[Description("Density")]			Density,
 		[Description("Energy")]				Energy,
+		[Description("Pulses")]				Pulses,
         [Description("Pulses/liter")]		PulsePerLtr,
         [Description("Pulses/kWh")]			PulsePerKWh,
 
@@ -153,7 +203,7 @@ namespace Config
         [Description("Boolean")]			Boolean,
         [Description("Date and time")]		DateTime,
 #endif
-		Count,
+        Count,
 	}
 
     public static class Units
@@ -178,6 +228,10 @@ namespace Config
 		{
             switch (units)
             {
+                case Unit.pulse:
+                case Unit.degree:
+                    return Config.Quantity.Pulses;
+
                 case Unit.l:
                 case Unit.dm3:
                 case Unit.m3:
@@ -241,9 +295,17 @@ namespace Config
                     return Config.Quantity.Energy;
 
                 case Unit.ppl:
+                case Unit.ppdm3:
+                case Unit.degpl:
+                case Unit.degpdm3:
+                case Unit.lpp:
+                case Unit.dm3pp:
+                case Unit.lpdeg:
+                case Unit.dm3pdeg:
                     return Config.Quantity.PulsePerLtr;
 
                 case Unit.ppkWh:
+                case Unit.kWhpp:
                     return Config.Quantity.PulsePerKWh;
 
                 default:
@@ -262,6 +324,7 @@ namespace Config
 		public static bool IsLength(Unit units) { return IsQuantity(units, Config.Quantity.Length); }
 		public static bool IsDensity(Unit units) { return IsQuantity(units, Config.Quantity.Density); }
 		public static bool IsEnergy(Unit units) { return IsQuantity(units, Config.Quantity.Energy); }
+        public static bool IsPulses(Unit units) { return IsQuantity(units, Config.Quantity.Pulses); }
         public static bool IsPulsePerLtr(Unit units) { return IsQuantity(units, Config.Quantity.PulsePerLtr); }
         public static bool IsPulsePerKWh(Unit units) { return IsQuantity(units, Config.Quantity.PulsePerKWh); }
 
@@ -293,8 +356,8 @@ namespace Config
                 case Unit.hour:     return v / 3600;
                 case Unit.ms:       return 1000 * v;
 
-                /// Temperature: internal representation in degree C 
-                case Unit.C:        return v;               /// degree Celsius
+				/// Temperature: internal representation in °C
+				case Unit.C:        return v;               /// degree Celsius (°C)
                 case Unit.F:        return 1.8 * v + 32;    /// degree Fahrenheit
                 case Unit.K:        return v + 273.15;      /// degree Kelvin
 
@@ -329,7 +392,13 @@ namespace Config
 				case Unit.kWh:      return v / 3600000.0;   /// 1 kWh = 3600000 J
                 case Unit.MWh:      return v / 3600000000.0;/// 1 MWh = 3600000000 J
 
-                default: return v;
+                case Unit.kWhpp:
+                case Unit.lpp:
+                case Unit.dm3pp:
+                case Unit.lpdeg:
+                case Unit.dm3pdeg:  return ((v <= float.Epsilon) ? 0 : 1 / v);
+
+                default:            return v;
             }
         }
 
@@ -360,8 +429,8 @@ namespace Config
                 case Unit.hour:     return 3600 * v;
                 case Unit.ms:       return v / 1000;
 
-                /// Temperature: internal representation in degree C 
-                case Unit.C:        return v;               /// degree Celsius
+				/// Temperature: internal representation in °C
+				case Unit.C:        return v;               /// degree Celsius (°C)
                 case Unit.F:        return 5 * (v-32) / 9;  /// degree Fahrenheit
                 case Unit.K:        return v - 273.15;      /// degree Kelvin
 
@@ -396,7 +465,13 @@ namespace Config
 				case Unit.kWh:		return 3600000 * v;     /// 1 kWh = 3600000 J
                 case Unit.MWh:      return 3600000000 * v;  /// 1 kWh = 3600000000 J
 
-                default: return v;
+                case Unit.kWhpp:
+                case Unit.lpp:
+                case Unit.dm3pp:
+                case Unit.lpdeg:
+                case Unit.dm3pdeg:  return ((v == 0) ? 0 : 1 / v);
+
+                default:            return v;
             }
         }
 	}

Config/Utils.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Config
+{
+    public static class Utils
+    {
+        public static string SignificantDigitsToFmt(double value, int sigDigits)
+        {
+            if (sigDigits == 5)
+            {
+                if (value >= 9999.5 || value < -9999.5) return "F0";
+                else if (value >= 999.95 || value < -999.95) return "F1";
+                else if (value >= 99.995 || value < -99.995) return "F2";
+                else if (value >= 9.9995 || value < -9.9995) return "F3";
+                else if (value >= 0.99995 || value < -0.99995) return "F4";
+                else if (value >= 0.099995 || value < -0.099995) return "F5";
+                else if (value >= 0.0099995 || value < -0.0099995) return "F6";
+                else if (value >= 0.00099995 || value < -0.00099995) return "F7";
+                else if (value >= 0.000099995 || value < -0.000099995) return "F8";
+                else return "F9";
+            }
+            else if (sigDigits == 4)
+            {
+                if (value >= 999.5 || value < -999.5) return "F0";
+                else if (value >= 99.95 || value < -99.95) return "F1";
+                else if (value >= 9.995 || value < -9.995) return "F2";
+                else if (value >= 0.9995 || value < -0.9995) return "F3";
+                else if (value >= 0.09995 || value < -0.09995) return "F4";
+                else if (value >= 0.009995 || value < -0.009995) return "F5";
+                else if (value >= 0.0009995 || value < -0.0009995) return "F6";
+                else if (value >= 0.00009995 || value < -0.00009995) return "F7";
+                else return "F8";
+            }
+            else if (sigDigits == 3)
+            {
+                if (value >= 99.5 || value < -99.5) return "F0";
+                else if (value >= 9.95 || value < -9.95) return "F1";
+                else if (value >= 0.995 || value < -0.995) return "F2";
+                else if (value >= 0.0995 || value < -0.0995) return "F3";
+                else if (value >= 0.00995 || value < -0.00995) return "F4";
+                else if (value >= 0.000995 || value < -0.000995) return "F5";
+                else if (value >= 0.0000995 || value < -0.0000995) return "F6";
+                else return "F7";
+            }
+            else if (sigDigits == 2)
+            {
+                if (value >= 9.5 || value < -9.5) return "F0";
+                else if (value >= 0.95 || value < -0.95) return "F1";
+                else if (value >= 0.095 || value < -0.095) return "F2";
+                else if (value >= 0.0095 || value < -0.0095) return "F3";
+                else if (value >= 0.00095 || value < -0.00095) return "F4";
+                else if (value >= 0.000095 || value < -0.000095) return "F5";
+                else return "F6";
+            }
+            else /// if (sigDigits == 1)
+            {
+                if (value >= 0.95 || value < -0.95) return "F0";
+                else if (value >= 0.095 || value < -0.095) return "F1";
+                else if (value >= 0.0095 || value < -0.0095) return "F2";
+                else if (value >= 0.00095 || value < -0.00095) return "F3";
+                else if (value >= 0.000095 || value < -0.000095) return "F4";
+                else return "F5";
+            }
+        }
+    }
+}

DeviceTest/DeviceTest.csproj

@@ -92,7 +92,7 @@
       <Project>{743DF7DB-C7B6-42EB-986D-0F485E5588E4}</Project>
       <Name>Config</Name>
     </ProjectReference>
-    <ProjectReference Include="..\TestBenchFramework\TBF.csproj">
+    <ProjectReference Include="..\TBF\TBF.csproj">
       <Project>{8648FD92-CDA1-4C3A-B5F9-FE547CE1FA48}</Project>
       <Name>TBF</Name>
     </ProjectReference>

DeviceTest/DeviceTestDlg.cs

@@ -68,10 +68,10 @@ namespace DeviceTest
         public DeviceTestDlg()
         {
             InitializeComponent();
-            compClasses = new List<string>();
 			radioButton0.Checked = true;
 			stopButton.Enabled = false;
-			
+
+			compClasses = new List<string>();
 			foreach (var componentFactory in TbfComponents.Factories)
             {
                 compClasses.Add(componentFactory.ClassName);

GemCard/APDUCommand.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Text;
+
+namespace GemCard
+{
+	/// <summary>
+	/// This class represents a command APDU
+	/// </summary>
+	public	class	APDUCommand
+	{
+		/// <summary>
+        /// Minimun size of an APDU command in bytes
+		/// </summary>
+		public const int APDU_MIN_LENGTH = 4;
+
+        public byte Class;      /// Class byte
+        public byte Ins;        /// Instruction byte
+        public byte P1;         /// Parameter P1 byte
+        public byte P2;         /// Parameter P2 byte
+        public byte[] Data;     /// Data to send to the card if any, null if no data to send
+        public byte Le;	        /// Number of data expected, 0 if none
+
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <param name="bCla">Class byte</param>
+		/// <param name="bIns">Instruction byte</param>
+		/// <param name="bP1">Parameter P1 byte</param>
+		/// <param name="bP2">Parameter P2 byte</param>
+		/// <param name="baData">Data to send to the card if any, null if no data to send</param>
+		/// <param name="bLe">Number of data expected, 0 if none</param>
+		public APDUCommand(byte bCla, byte bIns, byte bP1, byte bP2, byte[] baData, byte bLe)
+		{
+            this.Class = bCla;
+            this.Ins = bIns;
+            this.P1 = bP1;
+            this.P2 = bP2;
+            this.Data = baData;
+            this.Le = bLe;
+		}
+
+
+		/// <summary>
+		/// Update the current APDU with selected parameters
+		/// </summary>
+		/// <param name="apduParam">APDU parameters</param>
+		public void Update(APDUParam apduParam)
+		{
+			if (apduParam.UseData)    Data = apduParam.Data;
+			if (apduParam.UseLe)      Le   = apduParam.Le;
+			if (apduParam.UseP1)      P1   = apduParam.P1;
+			if (apduParam.UseP2)      P2   = apduParam.P2;
+            if (apduParam.UseChannel) Class += apduParam.Channel;
+        }
+
+        /// <summary>
+        /// Overrides the ToString method to format to a string the APDUCommand object
+        /// </summary>
+        /// <returns></returns>
+        public override string ToString()
+        {
+            string strData = null;
+            byte bLc = 0;
+            byte bP3 = Le;    
+
+            if (Data != null)
+            {
+                StringBuilder sData = new StringBuilder(Data.Length * 2);
+                for (int nI = 0; nI < Data.Length; nI++)
+                {
+                    sData.AppendFormat("{0:X02}", Data[nI]);
+                }
+
+                strData = "Data=" + sData.ToString();
+                bLc = (byte) Data.Length;
+                bP3 = bLc;
+            }
+            
+            //string strApdu = string.Format("Class={0:X02} Ins={1:X02} P1={2:X02} P2={3:X02} Le={4:X02} Lc={5:X02} ",
+                //m_bCla, m_bIns, m_bP1, m_bP2, m_bLe, bLc);
+            StringBuilder strApdu = new StringBuilder();
+
+            strApdu.AppendFormat("Class={0:X02} Ins={1:X02} P1={2:X02} P2={3:X02} P3={4:X02} ",
+                Class, Ins, P1, P2, bP3);
+
+            if (Data != null)
+            {
+                strApdu.Append(strData);
+            }
+
+            return strApdu.ToString();
+        }
+    }
+}

GemCard/APDUParam.cs

@@ -0,0 +1,147 @@
+using System;
+
+namespace GemCard
+{
+    /// <summary>
+    /// This class is used to update a set of parameters of an APDUCommand object
+    /// </summary>
+    public class APDUParam
+    {
+        byte bClass;
+        byte bChannel;
+        byte bP2;
+        byte bP1;
+
+        byte[] baData;
+        short nLe;
+
+        bool fUseP1;
+        bool fUseP2;
+        bool fChannel;
+        bool fData;
+        bool fClass;
+        bool fLe;
+
+        /// <summary>
+        /// Resets the current instance, all flags are set to false
+        /// </summary>
+        public void Reset()
+        {
+            bClass = 0;
+            bChannel = 0;
+            bP2 = 0;
+            bP1 = 0;
+
+            baData = null;
+            nLe = -1;
+
+            fUseP1 = false;
+            fUseP2 = false;
+            fChannel = false;
+            fData = false;
+            fClass = false;
+            fLe = false;
+        }
+
+        #region Constructors
+
+        public APDUParam()
+        {
+            Reset();
+        }
+
+        /// <summary>
+        /// Copy constructor (used for cloning)
+        /// </summary>
+        /// <param name="param"></param>
+        public APDUParam(APDUParam param)
+        {
+            // Copy field
+            if (param.baData != null)
+            {
+                param.baData.CopyTo(baData, 0);
+            }
+
+            this.bClass = param.bClass;
+            this.bChannel = param.bChannel;
+            this.bP1 = param.bP1;
+            this.bP2 = param.bP2;
+            this.nLe = param.nLe;
+
+            // Copy flags field
+            this.fChannel = param.fChannel;
+            this.fClass = param.fClass;
+            this.fData = param.fData;
+            this.fLe = param.fLe;
+            this.fUseP1 = param.fUseP1;
+            this.fUseP2 = param.fUseP2;
+        }
+
+        public APDUParam(byte bClass, byte bP1, byte bP2, byte[] baData, short nLe)
+        {
+            this.Class = bClass;
+            this.P1 = bP1;
+            this.P2 = bP2;
+            this.Data = baData;
+            this.Le = (byte)nLe;
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Clones the current APDUParam instance
+        /// </summary>
+        /// <returns></returns>
+        public APDUParam Clone()
+        {
+            return new APDUParam(this);
+        }
+
+        #region Properties
+
+        public bool UseClass { get { return fClass; } }
+        public bool UseChannel { get { return fChannel; } }
+        public bool UseLe { get { return fLe; } }
+        public bool UseData { get { return fData; } }
+        public bool UseP1 { get { return fUseP1; } }
+        public bool UseP2 { get { return fUseP2; } }
+
+        public byte P1
+        {
+            get { return bP1; }
+            set { bP1 = value; fUseP1 = true; }
+        }
+
+        public byte P2
+        {
+            get { return bP2; }
+            set { bP2 = value; fUseP2 = true; }
+        }
+
+        public byte[] Data
+        {
+            get { return baData; }
+            set { baData = value; fData = true; }
+        }
+
+        public byte Le
+        {
+            get { return (byte)nLe; }
+            set { nLe = value; fLe = true; }
+        }
+
+        public byte Channel
+        {
+            get { return bChannel; }
+            set { bChannel = value; fChannel = true; }
+        }
+
+        public byte Class
+        {
+            get { return bClass; }
+            set { bClass = value; fClass = true; }
+        }
+
+        #endregion
+    }
+}

GemCard/APDUResponse.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Text;
+
+namespace GemCard
+{
+	/// <summary>
+	/// This class represents the APDU response sent by the card
+	/// </summary>
+	public class APDUResponse
+	{
+		/// <summary>
+		///	Status bytes length
+		/// </summary>
+		public const int SW_LENGTH = 2;
+
+        /// <summary>
+        /// Response data. Contains the data sent by the card minus the 2 status bytes (SW1, SW2)
+        /// null if no data were sent by the card
+        /// </summary>
+        public byte[] Data;
+        public byte SW1;
+        public byte SW2;
+
+        /// <summary>
+        /// Status get property
+        /// </summary>
+        public ushort Status
+        {
+            get { return (ushort)(((short)SW1 << 8) + (short)SW2); }
+        }
+
+		/// <summary>
+		/// Constructor from the byte data sent back by the card
+		/// </summary>
+		/// <param name="baData">Buffer of data from the card</param>
+		public APDUResponse(byte[] baData)
+		{
+			if (baData.Length > SW_LENGTH)
+			{
+				Data = new byte[baData.Length - SW_LENGTH];
+
+                for (int nI = 0; nI < baData.Length - SW_LENGTH; nI++)
+                {
+                    this.Data[nI] = baData[nI];
+                }
+			}
+
+            this.SW1 = baData[baData.Length - 2];
+            this.SW2 = baData[baData.Length - 1];
+		}
+
+        /// <summary>
+        /// Overrides the ToString method to format to a string the APDUResponse object
+        /// </summary>
+        /// <returns></returns>
+        public override string ToString()
+        {
+            if (Data != null)
+            {
+                StringBuilder sData = new StringBuilder(Data.Length * 2);
+                for (int nI = 0; nI < Data.Length; nI++)
+                {
+                    sData.AppendFormat("{0:X02}", Data[nI]);
+                }
+
+                return sData.ToString();
+            }
+            else
+            {
+                return string.Empty;
+            }
+        }
+	}
+}

GemCard/AssemblyInfo.cs

@@ -0,0 +1,58 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+//
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+//
+[assembly: AssemblyTitle("")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("")]
+[assembly: AssemblyCopyright("")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]		
+
+//
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+
+[assembly: AssemblyVersion("1.0.*")]
+
+//
+// In order to sign your assembly you must specify a key to use. Refer to the 
+// Microsoft .NET Framework documentation for more information on assembly signing.
+//
+// Use the attributes below to control which key is used for signing. 
+//
+// Notes: 
+//   (*) If no key is specified, the assembly is not signed.
+//   (*) KeyName refers to a key that has been installed in the Crypto Service
+//       Provider (CSP) on your machine. KeyFile refers to a file which contains
+//       a key.
+//   (*) If the KeyFile and the KeyName values are both specified, the 
+//       following processing occurs:
+//       (1) If the KeyName can be found in the CSP, that key is used.
+//       (2) If the KeyName does not exist and the KeyFile does exist, the key 
+//           in the KeyFile is installed into the CSP and used.
+//   (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
+//       When specifying the KeyFile, the location of the KeyFile should be
+//       relative to the project output directory which is
+//       %Project Directory%\obj\<configuration>. For example, if your KeyFile is
+//       located in the project directory, you would specify the AssemblyKeyFile 
+//       attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
+//   (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
+//       documentation for more information on this.
+//
+[assembly: AssemblyDelaySign(false)]
+[assembly: AssemblyKeyFile("")]
+[assembly: AssemblyKeyName("")]

GemCard/CardBase.cs

@@ -0,0 +1,162 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+
+namespace GemCard 
+{
+    /// <summary>
+    /// Values for AttrId of SCardGetAttrib
+    /// </summary>
+    public class SCARD_ATTR_VALUE
+    {
+        private const uint 
+            SCARD_CLASS_COMMUNICATIONS = 2,
+            SCARD_CLASS_PROTOCOL = 3,
+            SCARD_CLASS_MECHANICAL = 6,
+            SCARD_CLASS_VENDOR_DEFINED = 7,
+            SCARD_CLASS_IFD_PROTOCOL = 8,
+            SCARD_CLASS_ICC_STATE = 9,
+            SCARD_CLASS_SYSTEM = 0x7fff;
+
+        private static UInt32 SCardAttrValue(UInt32 attrClass, UInt32 val)
+        {
+            return (attrClass << 16) | val;
+        }
+
+        public static UInt32 CHANNEL_ID { get { return SCardAttrValue(SCARD_CLASS_COMMUNICATIONS, 0x0110); } }
+
+        public static UInt32 CHARACTERISTICS { get { return SCardAttrValue(SCARD_CLASS_MECHANICAL, 0x0150); } }
+
+        public static UInt32 CURRENT_PROTOCOL_TYPE { get { return SCardAttrValue(SCARD_CLASS_IFD_PROTOCOL, 0x0201); } }
+
+        public static UInt32 DEVICE_UNIT { get { return SCardAttrValue(SCARD_CLASS_SYSTEM, 0x0001); } }
+        public static UInt32 DEVICE_FRIENDLY_NAME { get { return SCardAttrValue(SCARD_CLASS_SYSTEM, 0x0003); } }
+        public UInt32 DEVICE_SYSTEM_NAME { get { return SCardAttrValue(SCARD_CLASS_SYSTEM, 0x0004); } }
+
+        public static UInt32 ICC_PRESENCE { get { return SCardAttrValue(SCARD_CLASS_ICC_STATE, 0x0300); } }
+        public static UInt32 ICC_INTERFACE_STATUS { get { return SCardAttrValue(SCARD_CLASS_ICC_STATE, 0x0301); } }
+        public static UInt32 ATR_STRING { get { return SCardAttrValue(SCARD_CLASS_ICC_STATE, 0x0303); } }
+        public static UInt32 ICC_TYPE_PER_ATR { get { return SCardAttrValue(SCARD_CLASS_ICC_STATE, 0x0304); } }
+
+        public static UInt32 PROTOCOL_TYPES { get { return SCardAttrValue(SCARD_CLASS_PROTOCOL, 0x0120); } }
+
+        public static UInt32 VENDOR_NAME { get { return SCardAttrValue(SCARD_CLASS_VENDOR_DEFINED, 0x0100); } }
+        public static UInt32 VENDOR_IFD_TYPE { get { return SCardAttrValue(SCARD_CLASS_VENDOR_DEFINED, 0x0101); } }
+        public static UInt32 VENDOR_IFD_VERSION { get { return SCardAttrValue(SCARD_CLASS_VENDOR_DEFINED, 0x0102); } }
+        public static UInt32 VENDOR_IFD_SERIAL_NO { get { return SCardAttrValue(SCARD_CLASS_VENDOR_DEFINED, 0x0103); } }
+    }
+
+    /// <summary>
+    /// Abstract class that adds a basic event management to the ICard interface. 
+    /// </summary>
+    abstract public class CardBase : ICard
+    {
+        protected const uint INFINITE = 0xFFFFFFFF;
+        protected const uint WAIT_TIME = 250;
+
+        protected bool m_bRunCardDetection = true;
+        protected Thread m_thread = null;
+
+        /// <summary>
+        /// Event handler for the card insertion
+        /// </summary>
+        public event EventHandler<CardInsertedEventArgs> OnCardInserted = null;
+
+        /// <summary>
+        /// Event handler for the card removal
+        /// </summary>
+        public event EventHandler<CardRemovedEventArgs> OnCardRemoved = null;
+
+        ~CardBase()
+        {
+            // Stop any eventual card detection thread
+            StopCardEvents();
+        }
+
+        #region Abstract method that implement the ICard interface
+        abstract public string[] ListReaders();
+        abstract public void Connect(string Reader, SHARE ShareMode, PROTOCOL PreferredProtocols);
+        abstract public void Disconnect(DISCONNECT Disposition);
+        abstract public APDUResponse Transmit(APDUCommand ApduCmd);
+        abstract public void BeginTransaction();
+        abstract public void EndTransaction(DISCONNECT Disposition);
+        abstract public byte[] GetAttribute(UInt32 AttribId);
+        #endregion
+
+        /// <summary>
+        /// This method should start a thread that checks for card insertion or removal
+        /// </summary>
+        /// <param name="Reader"></param>
+        public void StartCardEvents(string Reader)
+        {
+            if (m_thread == null)
+            {
+                m_bRunCardDetection = true;
+
+                m_thread = new Thread(new ParameterizedThreadStart(RunCardDetection));
+                m_thread.Start(Reader);
+            }
+        }
+
+        /// <summary>
+        /// Stops the card events thread
+        /// </summary>
+        public void StopCardEvents()
+        {
+            if (m_thread != null)
+            {
+                int
+                    nTimeOut = 10,
+                    nCount = 0;
+                bool m_bStop = false;
+                m_bRunCardDetection = false;
+
+                do
+                {
+                    if (nCount > nTimeOut)
+                    {
+                        m_thread.Abort();
+                        break;
+                    }
+
+                    if (m_thread.ThreadState == ThreadState.Aborted)
+                        m_bStop = true;
+
+                    if (m_thread.ThreadState == ThreadState.Stopped)
+                        m_bStop = true;
+
+                    Thread.Sleep(200);
+                    ++nCount;           // Manage time out
+                }
+                while (!m_bStop);
+
+                m_thread = null;
+            }
+        }
+
+        /// <summary>
+        /// This function must implement a card detection mechanism.
+        /// 
+        /// When card insertion is detected, it must call the method CardInserted()
+        /// When card removal is detected, it must call the method CardRemoved()
+        /// 
+        /// </summary>
+        /// <param name="Reader">Name of the reader to scan for card event</param>
+        abstract protected void RunCardDetection(object Reader);
+
+        #region Event methods
+
+        protected void CardInserted(object sender, CardInsertedEventArgs args)
+        {
+            if (OnCardInserted != null) OnCardInserted(sender, args);
+        }
+
+        protected void CardRemoved(object sender, CardRemovedEventArgs args)
+        {
+            if (OnCardRemoved != null) OnCardRemoved(sender, args);
+        }
+
+        #endregion
+    }
+}

GemCard/CardCOM.cs

@@ -0,0 +1,173 @@
+using System;
+using System.Runtime.InteropServices;
+using SCARDSSPLib;
+using GemCardExLib;
+
+namespace GemCard
+{
+	/// <summary>
+	/// Implements the ICard interface using the SCard COM objects from Microsoft and SCardDatabaseEx object
+	/// for the ListReaders function.
+	/// </summary>
+	public class CardCOM : CardBase
+	{
+		private ISCard	m_itfCard = null;
+
+		/// <summary>
+		/// Default constructor
+		/// </summary>
+		public CardCOM()
+		{
+			// Create the SCard object
+			m_itfCard = new CSCardClass();
+		}
+
+		#region ICard Members
+
+		/// <summary>
+		/// Wraps the PCSC function
+		/// LONG SCardListReaders(SCARDCONTEXT hContext, 
+		///		LPCTSTR mszGroups, 
+		///		LPTSTR mszReaders, 
+		///		LPDWORD pcchReaders 
+		///	);
+		/// </summary>
+		/// <returns>A string array of the readers</returns>
+		public	override string[]	ListReaders()
+		{
+			ISCardDatabaseEx itfCardBase = new SCardDatabaseEx();
+
+			return (string[]) itfCardBase.ListReaders();
+		}
+
+		/// <summary>
+		///  Wraps the PCSC function
+		///  LONG SCardConnect(
+		///		IN SCARDCONTEXT hContext,
+		///		IN LPCTSTR szReader,
+		///		IN DWORD dwShareMode,
+		///		IN DWORD dwPreferredProtocols,
+		///		OUT LPSCARDHANDLE phCard,
+		///		OUT LPDWORD pdwActiveProtocol
+		///	);
+		/// </summary>
+		/// <param name="Reader"></param>
+		/// <param name="ShareMode"></param>
+		/// <param name="PreferredProtocols"></param>
+		public override void Connect(string Reader, SHARE ShareMode, PROTOCOL PreferredProtocols)
+		{
+			// Calls AttachReader to connect to the card
+			m_itfCard.AttachByReader(Reader, (SCARD_SHARE_MODES) ShareMode, (SCARD_PROTOCOLS) PreferredProtocols);
+		}
+
+		/// <summary>
+		/// Wraps the PCSC function
+		///	LONG SCardDisconnect(
+		///		IN SCARDHANDLE hCard,
+		///		IN DWORD dwDisposition
+		///	);
+		/// </summary>
+		/// <param name="Disposition"></param>
+		public override void Disconnect(DISCONNECT Disposition)
+		{
+			// Off the connection with the card
+			m_itfCard.Detach((SCARD_DISPOSITIONS) Disposition);
+		}
+
+		/// <summary>
+		/// Wraps the PCSC function
+		/// LONG SCardTransmit(
+		///		SCARDHANDLE hCard,
+		///		LPCSCARD_I0_REQUEST pioSendPci,
+		///		LPCBYTE pbSendBuffer,
+		///		DWORD cbSendLength,
+		///		LPSCARD_IO_REQUEST pioRecvPci,
+		///		LPBYTE pbRecvBuffer,
+		///		LPDWORD pcbRecvLength
+		///	);
+		/// </summary>
+		/// <param name="ApduCmd">APDUCommand object with the APDU to send to the card</param>
+		/// <returns>An APDUResponse object with the response from the card</returns>
+		public override APDUResponse Transmit(APDUCommand ApduCmd)
+		{
+			CSCardCmd	itfCmd = new CSCardCmdClass();
+			CByteBuffer	itfData = new CByteBufferClass();
+			int	nLe = ApduCmd.Le;
+
+			if (ApduCmd.Data == null)
+			{
+				itfData.SetSize(0);
+			}
+			else
+			{
+				int nWrite = 0;
+
+				itfData.SetSize(ApduCmd.Data.Length);
+				itfData.Write(ref ApduCmd.Data[0], ApduCmd.Data.Length, ref nWrite);
+			}
+
+			// Build the APDU command
+			itfCmd.BuildCmd(ApduCmd.Class, ApduCmd.Ins, ApduCmd.P1, ApduCmd.P2, itfData, ref nLe);
+
+			// Send the command
+			m_itfCard.Transaction(ref itfCmd);
+
+			// Analyse the response
+			int nRead = 0;
+			byte[]	pbResp = new byte[itfCmd.ApduReplyLength];
+
+			itfCmd.ApduReply.Read(ref pbResp[0], itfCmd.ApduReplyLength, ref nRead);
+
+			return new APDUResponse(pbResp);
+		}
+
+        /// <summary>
+        /// Wraps the PSCS function
+        /// LONG SCardBeginTransaction(
+        ///     SCARDHANDLE hCard
+        //  );
+        /// This function is not supported in the COM implementation
+        /// </summary>
+        public override void BeginTransaction()
+        {
+            throw new NotImplementedException("BeginTransaction is not supported in the COM implementation");
+        }
+
+        /// <summary>
+        /// Wraps the PCSC function
+        /// LONG SCardEndTransaction(
+        ///     SCARDHANDLE hCard,
+        ///     DWORD dwDisposition
+        /// );
+        /// This function is not supported in the COM implementation
+        /// </summary>
+        /// <param name="Disposition">A value from DISCONNECT enum</param>
+        public override void EndTransaction(DISCONNECT Disposition)
+        {
+            throw new NotImplementedException("EndTransaction is not supported in the COM implementation");
+        }
+
+        /// <summary>
+        /// Gets the attributes of the card
+        /// </summary>
+        /// <param name="AttribId">Identifier for the Attribute to get</param>
+        /// <returns>Attribute content</returns>
+        public override byte[] GetAttribute(UInt32 AttribId)
+        {
+            throw new NotImplementedException();
+        }
+        #endregion
+
+        /// <summary>
+        /// This function must implement a card detection mechanism.
+        /// 
+        /// When card insertion is detected, it must call the method CardInserted()
+        /// When card removal is detected, it must call the method CardRemoved()
+        /// 
+        /// </summary>
+        protected override void RunCardDetection(object Reader)
+        {
+            throw new Exception("The method or operation is not implemented.");
+        }
+	}
+}

GemCard/CardInsertedEventArgs.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace GemCard
+{
+    public class CardInsertedEventArgs : EventArgs
+    {
+        public CardInsertedEventArgs() { }
+    }
+}

GemCard/CardNative.cs

@@ -0,0 +1,620 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+
+namespace GemCard
+{
+    /// <summary>
+    /// CARD_STATE enumeration, used by the PC/SC function SCardGetStatusChanged
+    /// </summary>
+    enum CARD_STATE
+    {
+        UNAWARE = 0x00000000,
+        IGNORE = 0x00000001,
+        CHANGED = 0x00000002,
+        UNKNOWN = 0x00000004,
+        UNAVAILABLE = 0x00000008,
+        EMPTY = 0x00000010,
+        PRESENT = 0x00000020,
+        ATRMATCH = 0x00000040,
+        EXCLUSIVE = 0x00000080,
+        INUSE = 0x00000100,
+        MUTE = 0x00000200,
+        UNPOWERED = 0x00000400
+    }
+
+	/// <summary>
+	/// Wraps the SCARD_IO_STRUCTURE
+    ///  
+	/// </summary>
+	[StructLayout(LayoutKind.Sequential)]
+	public struct	SCard_IO_Request
+	{
+		public UInt32	m_dwProtocol;
+		public UInt32	m_cbPciLength;
+	}
+
+
+    /// <summary>
+    /// Wraps theSCARD_READERSTATE structure of PC/SC
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
+    public struct SCard_ReaderState
+    {
+        public string m_szReader;
+        public IntPtr m_pvUserData;
+        public UInt32 m_dwCurrentState;
+        public UInt32 m_dwEventState;
+        public UInt32 m_cbAtr;
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst=32)]
+        public byte[] m_rgbAtr;
+    }
+
+	/// <summary>
+	/// Implementation of ICard using native (P/Invoke) interoperability for PC/SC
+	/// </summary>
+	public class CardNative : CardBase
+	{
+		private	UInt32	m_hContext = 0;
+		private	UInt32	m_hCard = 0;
+		private	UInt32	m_nProtocol = (uint) PROTOCOL.T0;
+		private	int	m_nLastError = 0;
+
+		#region PCSC_FUNCTIONS
+        /// <summary>
+        /// Native SCardGetStatusChanged from winscard.dll
+        /// </summary>
+        /// <param name="hContext"></param>
+        /// <param name="dwTimeout"></param>
+        /// <param name="rgReaderStates"></param>
+        /// <param name="cReaders"></param>
+        /// <returns></returns>
+        [DllImport("winscard.dll", SetLastError = true)]
+        internal static extern int SCardGetStatusChange(UInt32 hContext,
+            UInt32 dwTimeout,
+            [In,Out] SCard_ReaderState[] rgReaderStates,
+            UInt32 cReaders);
+
+		/// <summary>
+		/// Native SCardListReaders function from winscard.dll
+		/// </summary>
+		/// <param name="hContext"></param>
+		/// <param name="mszGroups"></param>
+		/// <param name="mszReaders"></param>
+		/// <param name="pcchReaders"></param>
+		/// <returns></returns>
+		[DllImport("winscard.dll", SetLastError=true)]
+		internal static extern int SCardListReaders(UInt32 hContext,
+			[MarshalAs(UnmanagedType.LPTStr)] string mszGroups,
+			IntPtr mszReaders,
+			out UInt32	pcchReaders);
+
+		/// <summary>
+		/// Native SCardEstablishContext function from winscard.dll
+		/// </summary>
+		/// <param name="dwScope"></param>
+		/// <param name="pvReserved1"></param>
+		/// <param name="pvReserved2"></param>
+		/// <param name="phContext"></param>
+		/// <returns></returns>
+		[DllImport("winscard.dll", SetLastError=true)]
+		internal	static	extern	int	SCardEstablishContext(UInt32 dwScope,
+			IntPtr pvReserved1,
+			IntPtr pvReserved2,
+			IntPtr phContext);
+
+		/// <summary>
+		/// Native SCardReleaseContext function from winscard.dll
+		/// </summary>
+		/// <param name="hContext"></param>
+		/// <returns></returns>
+		[DllImport("winscard.dll", SetLastError=true)]
+		internal static extern	int	SCardReleaseContext(UInt32 hContext);
+
+		/// <summary>
+		/// Native SCardConnect function from winscard.dll
+		/// </summary>
+		/// <param name="hContext"></param>
+		/// <param name="szReader"></param>
+		/// <param name="dwShareMode"></param>
+		/// <param name="dwPreferredProtocols"></param>
+		/// <param name="phCard"></param>
+		/// <param name="pdwActiveProtocol"></param>
+		/// <returns></returns>
+		[DllImport("winscard.dll", SetLastError=true, CharSet=CharSet.Auto)]
+		internal static	extern	int	SCardConnect(UInt32 hContext,
+			[MarshalAs(UnmanagedType.LPTStr)] string szReader,
+			UInt32	dwShareMode, 
+			UInt32	dwPreferredProtocols,
+			IntPtr	phCard, 
+			IntPtr	pdwActiveProtocol);
+
+		/// <summary>
+		/// Native SCardDisconnect function from winscard.dll
+		/// </summary>
+		/// <param name="hCard"></param>
+		/// <param name="dwDisposition"></param>
+		/// <returns></returns>
+		[DllImport("winscard.dll", SetLastError=true)]
+		internal static extern	int	SCardDisconnect(UInt32 hCard,
+			UInt32 dwDisposition);
+
+		/// <summary>
+		/// Native SCardTransmit function from winscard.dll
+		/// </summary>
+		/// <param name="hCard"></param>
+		/// <param name="pioSendPci"></param>
+		/// <param name="pbSendBuffer"></param>
+		/// <param name="cbSendLength"></param>
+		/// <param name="pioRecvPci"></param>
+		/// <param name="pbRecvBuffer"></param>
+		/// <param name="pcbRecvLength"></param>
+		/// <returns></returns>
+		[DllImport("winscard.dll", SetLastError=true)]
+		internal static extern	int	SCardTransmit(UInt32 hCard,
+			[In] ref SCard_IO_Request pioSendPci,
+			byte[] pbSendBuffer,
+			UInt32 cbSendLength,
+			IntPtr pioRecvPci,
+			[Out] byte[] pbRecvBuffer,
+			out UInt32 pcbRecvLength
+			);
+
+        /// <summary>
+        /// Native SCardBeginTransaction function of winscard.dll
+        /// </summary>
+        /// <param name="hContext"></param>
+        /// <returns></returns>
+        [DllImport("winscard.dll", SetLastError = true)]
+        internal static extern int SCardBeginTransaction(UInt32 hContext);
+
+        /// <summary>
+        /// Native SCardEndTransaction function of winscard.dll
+        /// </summary>
+        /// <param name="hContext"></param>
+        /// <returns></returns>
+        [DllImport("winscard.dll", SetLastError = true)]
+        internal static extern int SCardEndTransaction(UInt32 hContext, UInt32 dwDisposition);
+
+        [DllImport("winscard.dll", SetLastError = true)]
+        internal static extern int SCardGetAttrib(UInt32 hCard,
+            UInt32 dwAttribId,
+            [Out] byte[] pbAttr,
+            out UInt32 pcbAttrLen);
+
+        #endregion
+
+		/// <summary>
+		/// Default constructor
+		/// </summary>
+		public CardNative()
+		{
+		}
+
+		/// <summary>
+		/// Object destruction
+		/// </summary>
+		~CardNative()
+		{
+			Disconnect(DISCONNECT.Unpower);
+
+			ReleaseContext();
+		}
+
+		#region ICard Members
+
+		/// <summary>
+		/// Wraps the PCSC function
+		/// LONG SCardListReaders(SCARDCONTEXT hContext, 
+		///		LPCTSTR mszGroups, 
+		///		LPTSTR mszReaders, 
+		///		LPDWORD pcchReaders 
+		///	);
+		/// </summary>
+		/// <returns>A string array of the readers</returns>
+		public	override string[]	ListReaders()
+		{
+			EstablishContext(SCOPE.User);
+
+			string[]	sListReaders = null;
+			UInt32	pchReaders = 0;
+			IntPtr	szListReaders = IntPtr.Zero;
+
+			m_nLastError = SCardListReaders(m_hContext, null, szListReaders, out pchReaders);
+			if (m_nLastError == 0)
+			{
+				szListReaders = Marshal.AllocHGlobal((int) pchReaders);
+				m_nLastError = SCardListReaders(m_hContext, null, szListReaders, out pchReaders);
+				if (m_nLastError == 0)
+				{
+					char[] caReadersData = new char[pchReaders];
+					int	nbReaders = 0;
+					for (int nI = 0; nI < pchReaders; nI++)
+					{
+						caReadersData[nI] = (char) Marshal.ReadByte(szListReaders, nI);
+
+						if (caReadersData[nI] == 0)
+							nbReaders++;
+					}
+
+					// Remove last 0
+					--nbReaders;
+
+					if (nbReaders != 0)
+					{
+						sListReaders = new string[nbReaders];
+						char[] caReader = new char[pchReaders];
+						int	nIdx = 0;
+						int	nIdy = 0;
+						int	nIdz = 0;
+						// Get the nJ string from the multi-string
+
+						while(nIdx < pchReaders - 1)
+						{
+							caReader[nIdy] = caReadersData[nIdx];
+							if (caReader[nIdy] == 0)
+							{
+								sListReaders[nIdz] = new string(caReader, 0, nIdy);
+								++nIdz;
+								nIdy = 0;
+								caReader = new char[pchReaders];
+							}
+							else
+								++nIdy;
+
+							++nIdx;
+						}
+					}
+
+				}
+
+				Marshal.FreeHGlobal(szListReaders);
+			}
+
+			ReleaseContext();
+
+			return sListReaders;
+		}
+
+		/// <summary>
+		/// Wraps the PCSC function 
+		/// LONG SCardEstablishContext(
+		///		IN DWORD dwScope,
+		///		IN LPCVOID pvReserved1,
+		///		IN LPCVOID pvReserved2,
+		///		OUT LPSCARDCONTEXT phContext
+		///	);
+		/// </summary>
+		/// <param name="Scope"></param>
+		public void EstablishContext(SCOPE Scope)
+		{
+			IntPtr	hContext = Marshal.AllocHGlobal(Marshal.SizeOf(m_hContext));
+
+			m_nLastError = SCardEstablishContext((uint) Scope, IntPtr.Zero, IntPtr.Zero, hContext);
+			if (m_nLastError != 0)
+			{
+				string msg = "SCardEstablishContext error: " + m_nLastError;
+
+				Marshal.FreeHGlobal(hContext);
+				throw new Exception(msg);
+			}
+
+			m_hContext = (uint) Marshal.ReadInt32(hContext);
+
+			Marshal.FreeHGlobal(hContext);
+		}
+
+
+		/// <summary>
+		/// Wraps the PCSC function
+		/// LONG SCardReleaseContext(
+		///		IN SCARDCONTEXT hContext
+		///	);
+		/// </summary>
+		public void ReleaseContext()
+		{
+			if (m_hContext != 0)
+			{
+				m_nLastError = SCardReleaseContext(m_hContext);
+
+				if (m_nLastError != 0)
+				{
+					string	msg = "SCardReleaseContext error: " + m_nLastError;
+					throw new Exception(msg);
+				}
+
+				m_hContext = 0;
+			}
+		}
+
+		/// <summary>
+		///  Wraps the PCSC function
+		///  LONG SCardConnect(
+		///		IN SCARDCONTEXT hContext,
+		///		IN LPCTSTR szReader,
+		///		IN DWORD dwShareMode,
+		///		IN DWORD dwPreferredProtocols,
+		///		OUT LPSCARDHANDLE phCard,
+		///		OUT LPDWORD pdwActiveProtocol
+		///	);
+		/// </summary>
+		/// <param name="Reader"></param>
+		/// <param name="ShareMode"></param>
+		/// <param name="PreferredProtocols"></param>
+		public override void Connect(string Reader, SHARE ShareMode, PROTOCOL PreferredProtocols)
+		{
+			EstablishContext(SCOPE.User);
+
+			IntPtr	hCard = Marshal.AllocHGlobal(Marshal.SizeOf(m_hCard));
+			IntPtr	pProtocol = Marshal.AllocHGlobal(Marshal.SizeOf(m_nProtocol));
+
+			m_nLastError = SCardConnect(m_hContext, 
+				Reader, 
+				(uint) ShareMode, 
+				(uint) PreferredProtocols, 
+				hCard,
+				pProtocol);
+
+			if (m_nLastError != 0)
+			{
+				string msg = "SCardConnect error: " + m_nLastError;
+
+				Marshal.FreeHGlobal(hCard);
+				Marshal.FreeHGlobal(pProtocol);
+				throw new Exception(msg);
+			}
+
+			m_hCard = (uint) Marshal.ReadInt32(hCard);
+			m_nProtocol = (uint) Marshal.ReadInt32(pProtocol);
+
+			Marshal.FreeHGlobal(hCard);
+			Marshal.FreeHGlobal(pProtocol);
+		}
+
+		/// <summary>
+		/// Wraps the PCSC function
+		///	LONG SCardDisconnect(
+		///		IN SCARDHANDLE hCard,
+		///		IN DWORD dwDisposition
+		///	);
+		/// </summary>
+		/// <param name="Disposition"></param>
+		public override void Disconnect(DISCONNECT Disposition)
+		{
+			if (m_hCard != 0)
+			{
+				m_nLastError = SCardDisconnect(m_hCard, (uint) Disposition);
+				m_hCard = 0;
+
+				if (m_nLastError != 0)
+				{
+					string msg = "SCardDisconnect error: " + m_nLastError;
+					throw new Exception(msg);
+				}
+
+				ReleaseContext();
+			}
+		}
+
+		/// <summary>
+		/// Wraps the PCSC function
+		/// LONG SCardTransmit(
+		///		SCARDHANDLE hCard,
+		///		LPCSCARD_I0_REQUEST pioSendPci,
+		///		LPCBYTE pbSendBuffer,
+		///		DWORD cbSendLength,
+		///		LPSCARD_IO_REQUEST pioRecvPci,
+		///		LPBYTE pbRecvBuffer,
+		///		LPDWORD pcbRecvLength
+		///	);
+		/// </summary>
+		/// <param name="ApduCmd">APDUCommand object with the APDU to send to the card</param>
+		/// <returns>An APDUResponse object with the response from the card</returns>
+		public override APDUResponse Transmit(APDUCommand ApduCmd)
+		{
+			uint	RecvLength = (uint) (ApduCmd.Le + APDUResponse.SW_LENGTH);
+			byte[]	ApduBuffer = null;
+			byte[]	ApduResponse = new byte[ApduCmd.Le + APDUResponse.SW_LENGTH];
+			SCard_IO_Request	ioRequest = new SCard_IO_Request();
+			ioRequest.m_dwProtocol = m_nProtocol;
+			ioRequest.m_cbPciLength = 8;
+
+			// Build the command APDU
+			if (ApduCmd.Data == null)
+			{
+				ApduBuffer = new byte[APDUCommand.APDU_MIN_LENGTH + ((ApduCmd.Le != 0) ? 1 : 0)];
+
+				if (ApduCmd.Le != 0)
+					ApduBuffer[4] = (byte) ApduCmd.Le;
+			}
+			else
+			{
+				ApduBuffer = new byte[APDUCommand.APDU_MIN_LENGTH + 1 + ApduCmd.Data.Length];
+
+				for (int nI = 0; nI < ApduCmd.Data.Length; nI++)
+					ApduBuffer[APDUCommand.APDU_MIN_LENGTH + 1 + nI] = ApduCmd.Data[nI];
+
+				ApduBuffer[APDUCommand.APDU_MIN_LENGTH] = (byte) ApduCmd.Data.Length;
+			}
+
+			ApduBuffer[0] = ApduCmd.Class;
+			ApduBuffer[1] = ApduCmd.Ins;
+			ApduBuffer[2] = ApduCmd.P1;
+			ApduBuffer[3] = ApduCmd.P2;
+
+			m_nLastError = SCardTransmit(m_hCard, ref ioRequest, ApduBuffer, (uint) ApduBuffer.Length, IntPtr.Zero, ApduResponse, out RecvLength); 
+			if (m_nLastError != 0)
+			{
+				string msg = "SCardTransmit error: " + m_nLastError;
+				throw new Exception(msg);
+			}
+			
+			byte[] ApduData = new byte[RecvLength];
+
+			for (int nI = 0; nI < RecvLength; nI++)
+				ApduData[nI] = ApduResponse[nI];
+
+			return new APDUResponse(ApduData);
+		}
+
+
+        /// <summary>
+        /// Wraps the PSCS function
+        /// LONG SCardBeginTransaction(
+        ///     SCARDHANDLE hCard
+        //  );
+        /// </summary>
+        public override void BeginTransaction()
+        {
+            if (m_hCard != 0)
+            {
+                m_nLastError = SCardBeginTransaction(m_hCard);
+                if (m_nLastError != 0)
+                {
+                    string msg = "SCardBeginTransaction error: " + m_nLastError;
+                    throw new Exception(msg);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Wraps the PCSC function
+        /// LONG SCardEndTransaction(
+        ///     SCARDHANDLE hCard,
+        ///     DWORD dwDisposition
+        /// );
+        /// </summary>
+        /// <param name="Disposition">A value from DISCONNECT enum</param>
+        public override void EndTransaction(DISCONNECT Disposition)
+        {
+            if (m_hCard != 0)
+            {
+                m_nLastError = SCardEndTransaction(m_hCard, (UInt32)Disposition);
+                if (m_nLastError != 0)
+                {
+                    string msg = "SCardEndTransaction error: " + m_nLastError;
+                    throw new Exception(msg);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the attributes of the card
+        /// </summary>
+        /// <param name="AttribId">Identifier for the Attribute to get</param>
+        /// <returns>Attribute content</returns>
+        public override byte[] GetAttribute(UInt32 AttribId)
+        {
+            byte[] attr = null;
+            UInt32 attrLen = 0;
+
+            m_nLastError = SCardGetAttrib(m_hCard, AttribId, attr, out attrLen);
+            if (m_nLastError == 0)
+            {
+                if (attrLen != 0)
+                {
+                    attr = new byte[attrLen];
+                    m_nLastError = SCardGetAttrib(m_hCard, AttribId, attr, out attrLen);
+                    if (m_nLastError != 0)
+                    {
+                        string msg = "SCardGetAttr error: " + m_nLastError;
+                        throw new Exception(msg);
+                    }
+                }
+            }
+            else
+            {
+                string msg = "SCardGetAttr error: " + m_nLastError;
+                throw new Exception(msg);
+            }
+
+            return attr;
+        }
+        #endregion
+
+        /// <summary>
+        /// This function must implement a card detection mechanism.
+        /// 
+        /// When card insertion is detected, it must call the method CardInserted()
+        /// When card removal is detected, it must call the method CardRemoved()
+        /// 
+        /// </summary>
+        protected override void RunCardDetection(object Reader)
+        {
+            bool bFirstLoop = true;
+            UInt32 hContext = 0;    // Local context
+            IntPtr phContext;
+
+            phContext = Marshal.AllocHGlobal(Marshal.SizeOf(hContext));
+
+            if (SCardEstablishContext((uint) SCOPE.User, IntPtr.Zero, IntPtr.Zero, phContext) == 0)
+            {
+                hContext = (uint)Marshal.ReadInt32(phContext);
+                Marshal.FreeHGlobal(phContext);
+
+                UInt32 nbReaders = 1;
+                SCard_ReaderState[] readerState = new SCard_ReaderState[nbReaders];
+
+                readerState[0].m_dwCurrentState = (UInt32) CARD_STATE.UNAWARE;
+                readerState[0].m_szReader = (string)Reader;
+
+                UInt32 eventState;
+                UInt32 currentState = readerState[0].m_dwCurrentState;
+
+                // Card detection loop
+                do
+                {
+                    if (SCardGetStatusChange(hContext, WAIT_TIME
+                        , readerState, nbReaders) == 0)
+                    {
+                        eventState = readerState[0].m_dwEventState;
+                        currentState = readerState[0].m_dwCurrentState;
+
+                        // Check state
+                        if (((eventState & (uint) CARD_STATE.CHANGED) == (uint) CARD_STATE.CHANGED) && !bFirstLoop)    
+                        {
+                            // State has changed
+                            if ((eventState & (uint) CARD_STATE.EMPTY) == (uint) CARD_STATE.EMPTY)
+                            {
+                                // There is no card, card has been removed -> Fire CardRemoved event
+                                CardRemoved(this, new CardRemovedEventArgs());
+                            }
+
+                            if (((eventState & (uint)CARD_STATE.PRESENT) == (uint)CARD_STATE.PRESENT) && 
+                                ((eventState & (uint) CARD_STATE.PRESENT) != (currentState & (uint) CARD_STATE.PRESENT)))
+                            {
+                                // There is a card in the reader -> Fire CardInserted event
+                                CardInserted(this, new CardInsertedEventArgs());
+                            }
+
+                            if ((eventState & (uint) CARD_STATE.ATRMATCH) == (uint) CARD_STATE.ATRMATCH)
+                            {
+                                // There is a card in the reader and it matches the ATR we were expecting-> Fire CardInserted event
+                                CardInserted(this, new CardInsertedEventArgs());
+                            }
+                        }
+
+                        // The current stateis now the event state
+                        readerState[0].m_dwCurrentState = eventState;
+
+                        bFirstLoop = false;
+                    }
+
+                    Thread.Sleep(100);
+
+                    if (m_bRunCardDetection == false)
+                        break;
+                }
+                while (true);    // Exit on request
+            }
+            else
+            {
+                Marshal.FreeHGlobal(phContext);
+                throw new Exception("PC/SC error");
+            }
+
+            SCardReleaseContext(hContext);
+        }
+	}
+}

GemCard/CardRemovedEventArgs.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace GemCard
+{
+    public class CardRemovedEventArgs : EventArgs
+    {
+        public CardRemovedEventArgs() { }
+    }
+}

GemCard/GemCard.csproj

@@ -0,0 +1,194 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
+  <PropertyGroup>
+    <ProjectType>Local</ProjectType>
+    <ProductVersion>8.0.50727</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{8B10D15A-39DE-4B56-8DD1-710C1EB3A697}</ProjectGuid>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ApplicationIcon>
+    </ApplicationIcon>
+    <AssemblyKeyContainerName>
+    </AssemblyKeyContainerName>
+    <AssemblyName>GemCard</AssemblyName>
+    <AssemblyOriginatorKeyFile>
+    </AssemblyOriginatorKeyFile>
+    <DefaultClientScript>JScript</DefaultClientScript>
+    <DefaultHTMLPageLayout>Grid</DefaultHTMLPageLayout>
+    <DefaultTargetSchema>IE50</DefaultTargetSchema>
+    <DelaySign>false</DelaySign>
+    <OutputType>Library</OutputType>
+    <RootNamespace>GemCard</RootNamespace>
+    <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>
+    <StartupObject>
+    </StartupObject>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <UpgradeBackupLocation>
+    </UpgradeBackupLocation>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <OutputPath>bin\Debug\</OutputPath>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <BaseAddress>285212672</BaseAddress>
+    <CheckForOverflowUnderflow>false</CheckForOverflowUnderflow>
+    <ConfigurationOverrideFile>
+    </ConfigurationOverrideFile>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DocumentationFile>
+    </DocumentationFile>
+    <DebugSymbols>true</DebugSymbols>
+    <FileAlignment>4096</FileAlignment>
+    <NoStdLib>false</NoStdLib>
+    <NoWarn>
+    </NoWarn>
+    <Optimize>false</Optimize>
+    <RegisterForComInterop>false</RegisterForComInterop>
+    <RemoveIntegerChecks>false</RemoveIntegerChecks>
+    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <OutputPath>bin\Release\</OutputPath>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <BaseAddress>285212672</BaseAddress>
+    <CheckForOverflowUnderflow>false</CheckForOverflowUnderflow>
+    <ConfigurationOverrideFile>
+    </ConfigurationOverrideFile>
+    <DefineConstants>TRACE</DefineConstants>
+    <DocumentationFile>
+    </DocumentationFile>
+    <DebugSymbols>false</DebugSymbols>
+    <FileAlignment>4096</FileAlignment>
+    <NoStdLib>false</NoStdLib>
+    <NoWarn>
+    </NoWarn>
+    <Optimize>true</Optimize>
+    <RegisterForComInterop>false</RegisterForComInterop>
+    <RemoveIntegerChecks>false</RemoveIntegerChecks>
+    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x86\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <BaseAddress>285212672</BaseAddress>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <FileAlignment>4096</FileAlignment>
+    <PlatformTarget>x86</PlatformTarget>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
+    <CodeAnalysisFailOnMissingRules>false</CodeAnalysisFailOnMissingRules>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <BaseAddress>285212672</BaseAddress>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <Optimize>true</Optimize>
+    <FileAlignment>4096</FileAlignment>
+    <PlatformTarget>x86</PlatformTarget>
+    <CodeAnalysisIgnoreBuiltInRuleSets>false</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisIgnoreBuiltInRules>false</CodeAnalysisIgnoreBuiltInRules>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System">
+      <Name>System</Name>
+    </Reference>
+    <Reference Include="System.Data">
+      <Name>System.Data</Name>
+    </Reference>
+    <Reference Include="System.Xml">
+      <Name>System.XML</Name>
+    </Reference>
+    <COMReference Include="GemCardExLib">
+      <Guid>{F1FF634B-BEDF-461C-A409-5B88E05F5117}</Guid>
+      <VersionMajor>1</VersionMajor>
+      <VersionMinor>0</VersionMinor>
+      <Lcid>0</Lcid>
+      <WrapperTool>tlbimp</WrapperTool>
+      <Isolated>False</Isolated>
+    </COMReference>
+    <COMReference Include="SCARDSSPLib">
+      <Guid>{82C38704-19F1-11D3-A11F-00C04F79F800}</Guid>
+      <VersionMajor>1</VersionMajor>
+      <VersionMinor>0</VersionMinor>
+      <Lcid>0</Lcid>
+      <WrapperTool>tlbimp</WrapperTool>
+    </COMReference>
+    <COMReference Include="stdole">
+      <Guid>{00020430-0000-0000-C000-000000000046}</Guid>
+      <VersionMajor>2</VersionMajor>
+      <VersionMinor>0</VersionMinor>
+      <Lcid>0</Lcid>
+      <WrapperTool>primary</WrapperTool>
+      <Isolated>False</Isolated>
+    </COMReference>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="APDUCommand.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="APDUParam.cs" />
+    <Compile Include="APDUResponse.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="AssemblyInfo.cs" />
+    <Compile Include="CardBase.cs" />
+    <Compile Include="CardInsertedEventArgs.cs" />
+    <Compile Include="CardNative.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="CardRemovedEventArgs.cs" />
+    <Compile Include="ICard.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="SmartCardException.cs">
+      <SubType>Code</SubType>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
+      <Visible>False</Visible>
+      <ProductName>Windows Installer 3.1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent>
+    </PreBuildEvent>
+    <PostBuildEvent>
+    </PostBuildEvent>
+  </PropertyGroup>
+</Project>

GemCard/GemCard.csproj.user

@@ -0,0 +1,70 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <LastOpenVersion>8.0.50215</LastOpenVersion>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ReferencePath>
+    </ReferencePath>
+    <CopyProjectDestinationFolder>
+    </CopyProjectDestinationFolder>
+    <CopyProjectUncPath>
+    </CopyProjectUncPath>
+    <CopyProjectOption>0</CopyProjectOption>
+    <ProjectView>ProjectFiles</ProjectView>
+    <ProjectTrust>0</ProjectTrust>
+    <PublishUrlHistory />
+    <InstallUrlHistory />
+    <SupportUrlHistory />
+    <UpdateUrlHistory />
+    <BootstrapperUrlHistory />
+    <ErrorReportUrlHistory />
+    <FallbackCulture>en-US</FallbackCulture>
+    <VerifyUploadedFiles>false</VerifyUploadedFiles>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <EnableASPDebugging>false</EnableASPDebugging>
+    <EnableASPXDebugging>false</EnableASPXDebugging>
+    <EnableUnmanagedDebugging>false</EnableUnmanagedDebugging>
+    <EnableSQLServerDebugging>false</EnableSQLServerDebugging>
+    <RemoteDebugEnabled>false</RemoteDebugEnabled>
+    <RemoteDebugMachine>
+    </RemoteDebugMachine>
+    <StartAction>Project</StartAction>
+    <StartArguments>
+    </StartArguments>
+    <StartPage>
+    </StartPage>
+    <StartProgram>
+    </StartProgram>
+    <StartURL>
+    </StartURL>
+    <StartWorkingDirectory>
+    </StartWorkingDirectory>
+    <StartWithIE>true</StartWithIE>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <EnableASPDebugging>false</EnableASPDebugging>
+    <EnableASPXDebugging>false</EnableASPXDebugging>
+    <EnableUnmanagedDebugging>false</EnableUnmanagedDebugging>
+    <EnableSQLServerDebugging>false</EnableSQLServerDebugging>
+    <RemoteDebugEnabled>false</RemoteDebugEnabled>
+    <RemoteDebugMachine>
+    </RemoteDebugMachine>
+    <StartAction>Project</StartAction>
+    <StartArguments>
+    </StartArguments>
+    <StartPage>
+    </StartPage>
+    <StartProgram>
+    </StartProgram>
+    <StartURL>
+    </StartURL>
+    <StartWorkingDirectory>
+    </StartWorkingDirectory>
+    <StartWithIE>false</StartWithIE>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <StartWithIE>true</StartWithIE>
+  </PropertyGroup>
+</Project>

GemCard/ICard.cs

@@ -0,0 +1,149 @@
+using System;
+
+namespace GemCard
+{
+	/// <summary>
+	/// This interface gives access to the basic card functions. It must be implemented by a class.
+	/// </summary>
+	public interface	ICard
+	{
+		/// <summary>
+		/// Wraps the PCSC funciton
+		/// LONG SCardListReaders(SCARDCONTEXT hContext, 
+		///		LPCTSTR mszGroups, 
+		///		LPTSTR mszReaders, 
+		///		LPDWORD pcchReaders 
+		///	);
+		/// </summary>
+		/// <returns>A string array of the readers</returns>
+		string[] ListReaders();
+
+		/// <summary>
+		///  Wraps the PCSC function
+		///  LONG SCardConnect(
+		///		IN SCARDCONTEXT hContext,
+		///		IN LPCTSTR szReader,
+		///		IN DWORD dwShareMode,
+		///		IN DWORD dwPreferredProtocols,
+		///		OUT LPSCARDHANDLE phCard,
+		///		OUT LPDWORD pdwActiveProtocol
+		///	);
+		/// </summary>
+		/// <param name="Reader"></param>
+		/// <param name="ShareMode"></param>
+		/// <param name="PreferredProtocols"></param>
+		void Connect(string Reader, SHARE ShareMode, PROTOCOL PreferredProtocols);
+
+		/// <summary>
+		/// Wraps the PCSC function
+		///	LONG SCardDisconnect(
+		///		IN SCARDHANDLE hCard,
+		///		IN DWORD dwDisposition
+		///	);
+		/// </summary>
+		/// <param name="Disposition"></param>
+		void Disconnect(DISCONNECT Disposition);
+
+		/// <summary>
+		/// Wraps the PCSC function
+		/// LONG SCardTransmit(
+		///		SCARDHANDLE hCard,
+		///		LPCSCARD_I0_REQUEST pioSendPci,
+		///		LPCBYTE pbSendBuffer,
+		///		DWORD cbSendLength,
+		///		LPSCARD_IO_REQUEST pioRecvPci,
+		///		LPBYTE pbRecvBuffer,
+		///		LPDWORD pcbRecvLength
+		///	);
+		/// </summary>
+		/// <param name="ApduCmd">APDUCommand object with the APDU to send to the card</param>
+		/// <returns>An APDUResponse object with the response from the card</returns>
+		APDUResponse Transmit(APDUCommand ApduCmd);
+
+        /// <summary>
+        /// Wraps the PSCS function
+        /// LONG SCardBeginTransaction(
+        ///     SCARDHANDLE hCard
+        //  );
+        /// </summary>
+        void BeginTransaction();
+
+        /// <summary>
+        /// Wraps the PCSC function
+        /// LONG SCardEndTransaction(
+        ///     SCARDHANDLE hCard,
+        ///     DWORD dwDisposition
+        /// );
+        /// </summary>
+        void EndTransaction(DISCONNECT Disposition);
+
+        /// <summary>
+        /// Gets the attributes of the card
+        /// </summary>
+        /// <param name="AttribId">Identifier for the Attribute to get</param>
+        /// <returns>Attribute content</returns>
+        byte[] GetAttribute(UInt32 AttribId);
+	}
+
+	/// <summary>
+	/// SCOPE context
+	/// </summary>
+	public enum SCOPE
+	{
+		/// <summary>
+		/// The context is a user context, and any database operations are performed within the
+		/// domain of the user.
+		/// </summary>
+		User,		
+
+		/// <summary>
+		/// The context is that of the current terminal, and any database operations are performed
+		/// within the domain of that terminal.  (The calling application must have appropriate
+		/// access permissions for any database actions.)
+		/// </summary>
+		Terminal,	
+
+		/// <summary>
+		/// The context is the system context, and any database operations are performed within the
+		/// domain of the system.  (The calling application must have appropriate access
+		/// permissions for any database actions.)
+		/// </summary>
+		System	
+	}
+
+	/// <summary>
+	/// SHARE mode enumeration
+	/// </summary>
+	public enum SHARE
+	{
+        Exclusive = 1,	/// This app. is not willing to share this card with other applications.
+        Shared,			/// This app. is willing to share this card with other applications.
+        Direct, 		/// This app. demands direct control of the reader, so it is not available to other applications.
+	}
+
+
+	/// <summary>
+	/// PROTOCOL enumeration
+	/// </summary>
+	public enum PROTOCOL
+	{
+        Undefined = 0x00000000,	                    /// There is no active protocol.
+        T0        = 0x00000001,	                    /// T=0 is the active protocol.
+        T1        = 0x00000002,	                    /// T=1 is the active protocol.
+        T0orT1    = T0 | T1,                        /// T=1 or T=0 can be the active protocol
+        Raw       = 0x00010000,                     /// Raw is the active protocol.
+		Default   = unchecked ((int) 0x80000000),   /// Use implicit PTS.
+	}
+
+
+	/// <summary>
+	/// DISCONNECT action enumeration
+	/// </summary>
+	public enum DISCONNECT
+	{
+        Leave,		/// Don't do anything special on close
+        Reset,		/// Reset the card on close
+        Unpower,	/// Power down the card on close
+        Eject,	    /// Eject(!) the card on close
+	}
+}

GemCard/SmartCardException.cs

@@ -0,0 +1,40 @@
+using System;
+
+namespace GemCard
+{
+	/// <summary>
+	///  Smart card exceptions
+	/// </summary>
+	public class SmartCardException : Exception
+	{
+
+		public SmartCardException() : base("Smart card exception")
+		{
+		}
+
+		public SmartCardException(string Message) : base(Message)
+		{
+		}
+	}
+
+
+    public class ApduCommandException : Exception
+    {
+		public const	string
+			NotValidDocument = "The file is not a valid APDU command document",
+			NoSuchCommand = "No such APDU command in the document",
+            ParamLeFormat = "Le parameter format is not correct",
+            ParamP3Format = "P3 parameter format is not correct",
+            NoSuchSequence = "No such APDU sequence in the document", 
+            MissingApduOrCommand = "An Apdu or a Sequence is missing in this Sequence";
+            
+		public ApduCommandException() : base("APDU command exception")
+		{
+		}
+
+		public ApduCommandException(string Message) : base(Message)
+		{
+		}
+
+    }
+}

GraphLib/DataSource.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Text;
 using System.Runtime.Serialization;
 using System.Runtime.Serialization.Formatters.Binary;
@@ -159,7 +160,46 @@ namespace GraphLib
         {           
             grid_off_y = off_y;
         }
-      
+
+
+		/// <summary>
+		/// Load Samples from a file. Returns loaded points count.
+		/// </summary>
+		/// <param name="pathName">File pathname</param>
+		/// <returns>Loaded points count</returns>
+		public int LoadSamples(string pathName, out float yMin, out float yMax)
+		{
+			yMin = float.MaxValue;
+			yMax = float.MinValue;
+			try
+			{
+				Int64 size = new FileInfo(pathName).Length;
+				if ((size % 8) != 0) return 0;
+				int samplesCount = (int)(size / 8L) - 1;
+				if (samplesCount <= 0) return 0;
+
+				PointF[] newSamples = new PointF[samplesCount];
+				using (BinaryReader reader = new BinaryReader(File.Open(pathName, FileMode.Open)))
+				{
+					for (int i = 0; i < samplesCount; i++)
+					{
+						newSamples[i].X = reader.ReadSingle();
+						newSamples[i].Y = reader.ReadSingle();
+					}
+					yMin = reader.ReadSingle();
+					yMax = reader.ReadSingle();
+				}
+
+				Samples = newSamples;
+				return samplesCount;
+			}
+			catch (Exception exc)
+			{
+				return 0;
+			}
+		}
+
+
         [Category("Properties")] // Take this out, and you will soon have problems with serialization;
         [DefaultValue(typeof(string), "")]
         [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]

GraphLib/GraphLib.csproj

@@ -75,7 +75,6 @@
       <DesignTime>True</DesignTime>
       <DependentUpon>Resources.resx</DependentUpon>
     </Compile>
-    <Compile Include="PrecisionTimer.cs" />
     <Compile Include="Utils.cs" />
   </ItemGroup>
   <ItemGroup>

GraphLib/PlotterDisplayEx.cs

@@ -43,11 +43,6 @@ namespace GraphLib
         PlotterGraphSelectCurvesForm GraphPropertiesForm = null;
         PrintPreviewForm printPreviewForm = null;
 
-        private PrecisionTimer.Timer mTimer = null;
-        private float play_speed = 0.5f;
-        private float play_speed_max = 10f;
-        private float play_speed_min = 0.5f;
-
         private bool paused = false;
         private bool isRunning = false;
 
@@ -58,11 +53,6 @@ namespace GraphLib
         public PlotterDisplayEx()
         {
             InitializeComponent();
-            mTimer = new PrecisionTimer.Timer();
-            mTimer.Period = 50;                         // 20 fps
-            mTimer.Tick += new EventHandler(OnTimerTick);
-            play_speed = 0.5f; // 20x10 = 200 values per second == sample frequency     
-            mTimer.Start();
             isRunning = false;
         }
        
@@ -192,85 +182,10 @@ namespace GraphLib
 
         protected override void Dispose(bool disposing)
         {
-            paused = true;
-
-            if (mTimer.IsRunning)
-            {
-                mTimer.Stop();
-                mTimer.Dispose();
-            }
-            
+            paused = true;            
             base.Dispose(disposing);
         }
 
-        public void Start()
-        {
-            if (isRunning == false && paused == false)
-            {
-                gPane.starting_idx = 0;
-                paused = false;
-                isRunning = true;
-               // mTimer.Start();                
-                tb1.Buttons[0].ImageIndex = 2;                
-            }
-            else
-            {
-                if (paused == false)
-                {
-                    //mTimer.Stop();
-                    paused = true;
-                }
-                else
-                {
-                   // mTimer.Start();
-                    paused = false;
-                }
-
-                if (paused)
-                {
-                    
-                    tb1.Buttons[0].ImageIndex = 0;  
-                }
-                else
-                {
-                   
-                    tb1.Buttons[0].ImageIndex = 2;  
-                }
-            }
-        }
-
-        public void Stop()
-        {
-            if (isRunning)
-            {
-               // mTimer.Stop();
-                isRunning = false;
-                paused = false;
-                hScrollBar1.Value = 0;
-                tb1.Buttons[0].ImageIndex = 0;
-            }
-        }
-
-       
-        private void tb1_ButtonClick(object sender, ToolBarButtonClickEventArgs e)
-        {
-            bool pushed = e.Button.Pushed;
-            switch (e.Button.Tag.ToString().ToLower())
-            {
-                case "play":
-
-                    Start();
-                      
-                    break;
-
-                case "stop":
-
-                    Stop();
-                   
-                    break;       
-            }
-        }
-
         private void SetPlayPanelVisible()
         {
             panel1.Visible = true;          
@@ -317,27 +232,6 @@ namespace GraphLib
             {
             }
         }
-
-        private void UpdatePlayback()
-        {
-            if (!paused && isRunning == true)
-            {
-                try
-                {
-                    gPane.starting_idx += play_speed;
-                    UpdateScrollBar();
-                    gPane.Invalidate();
-                }
-                catch { }
-            }
-        }
-
-        private void OnTimerTick(object sender, EventArgs e)
-        {
-            UpdateControl();
-
-            UpdatePlayback();
-        }
         
         private void UpdateScrollBar()
         {
@@ -374,7 +268,14 @@ namespace GraphLib
             if (gPane.Sources.Count > 0)
             {
                 int val = hScrollBar1.Value;
-                gPane.starting_idx = (int)(gPane.Sources[0].Length * (float)val / 10000.0f);
+
+                int maxLen = 0;
+                foreach (var s in DataSources)
+                {
+                    if (s.Length > maxLen) maxLen = s.Length;
+                }
+
+                gPane.starting_idx = (int)(maxLen * (float)val / 10000.0f);
                 gPane.Invalidate();
             }
         }

GraphLib/PlotterDisplayEx.designer.cs

@@ -56,7 +56,7 @@ namespace GraphLib
 			this.tb1.ShowToolTips = true;
 			this.tb1.Size = new System.Drawing.Size(80, 26);
 			this.tb1.TabIndex = 1;
-			this.tb1.ButtonClick += new System.Windows.Forms.ToolBarButtonClickEventHandler(this.tb1_ButtonClick);
+			this.tb1.Visible = false;
 			// 
 			// tbbSave
 			// 

GraphLib/PlotterDisplayEx.resx

@@ -125,64 +125,64 @@
         AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w
         LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACZTeXN0
         ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAACI
-        DgAAAk1TRnQBSQFMAgEBBAEAAQwBAAEMAQABEAEAARABAAT/ASEBAAj/AUIBTQE2BwABNgMAASgDAAFA
-        AwABIAMAAQEBAAEgBgABIP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8AKgADAQECwAABtwGV
-        AVAB/QHKAZgBWgH/AcoBlwFaAf8BygGXAVoB/wHKAZcBWgH/AcoBlwFZAf8ByQGXAVkB/wHJAZcBWQH/
-        AcoBmAFaAf8BtwGUAVAB/RQAAxQBHAMRARcDAgEDrAADTgGZA10B0gNNAf8BxwGVAVYB/wH5AfcB9gH/
+        DgAAAk1TRnQBSQFMAgEBBAEAARQBAAEUAQABEAEAARABAAT/ASEBAAj/AUIBTQE2BwABNgMAASgDAAFA
+        AwABIAMAAQEBAAEgBgABIP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8AKgADAQECwAABtgGV
+        AU8B/QHKAZgBWQH/AcoBlwFZAf8BygGXAVkB/wHKAZcBWQH/AcoBlwFYAf8ByQGXAVgB/wHJAZcBWAH/
+        AcoBmAFZAf8BtgGUAU8B/RQAAxQBHAMRARcDAgEDrAADTgGZA10B0gNMAf8BxwGVAVUB/wH5AfcB9gH/
         AfkB8QHsAf8B+QHxAesB/wH4AfAB6QH/AfcB7QHmAf8B9AHqAeEB/wHyAegB3gH/AfoB+AH2Af8BxwGU
-        AVYB/wMZAf8DWAHRA0QBeggAAxUBHQFiAlgB6QM6AWEDDQESAwABASwAAxsBJgMbASYDGwEmAxsBJgMb
+        AVUB/wMYAf8DWAHRA0QBeggAAxUBHQFiAlgB6QM6AWEDDQESAwABASwAAxsBJgMbASYDGwEmAxsBJgMb
         ASYDGwEmAxsBJgMbASYDGwEmAxsBJgMbASYDGwEmEAADGwEmAxsBJgMbASYDGwEmAxsBJgMbASYDGwEm
-        AxsBJgMbASYDGwEmAxsBJgMbASYIAANVAf0DpwH/A7UB/wOBAf8BrwGsAaoB/wHFAcABvQH/AcUBwAG9
-        Af8BxQHAAb0B/wHFAcABvQH/AcUBwAG9Af8BxQHAAb0B/wGtAaoBqAH/AyEB/wO1Af8DmwH/AxgB/wgA
-        AxUBHQNNAfoBOwIrAfwDXwHgAysBQgMNARIoAAMbASYDKwH8AYACgQH/AYACgQH/AYACgQH/AYACgQH/
+        AxsBJgMbASYDGwEmAxsBJgMbASYIAANUAf0DpwH/A7UB/wOBAf8BrwGsAaoB/wHFAcABvQH/AcUBwAG9
+        Af8BxQHAAb0B/wHFAcABvQH/AcUBwAG9Af8BxQHAAb0B/wGtAaoBqAH/AyAB/wO1Af8DmwH/AxcB/wgA
+        AxUBHQNNAfoBOgIrAfwDXwHgAysBQgMNARIoAAMbASYDKwH8AYACgQH/AYACgQH/AYACgQH/AYACgQH/
         AYACgQH/AYACgQH/AYACgQH/AYACgQH/AYACgQH/AxsBJhAAAxsBJgMrAfwBgAKBAf8BgAKBAf8BgAKB
-        Af8DIwE0AxsBJgMrAfwBgAKBAf8BgAKBAf8BgAKBAf8DIwE0CAADZQH/A7UB/wO1Af8DlQH/A4EB/wOB
-        Af8DbgH/A2MB/wNWAf8DRwH/AzgB/wM3Af8DYwH/A7UB/wO1Af8DGgH/CAADFQEdAV8CSgH7AfkB+gH5
+        Af8DIwE0AxsBJgMrAfwBgAKBAf8BgAKBAf8BgAKBAf8DIwE0CAADZAH/A7UB/wO1Af8DlQH/A4EB/wOB
+        Af8DbQH/A2IB/wNVAf8DRgH/AzcB/wM2Af8DYgH/A7UB/wO1Af8DGQH/CAADFQEdAV8CSgH7AfkB+gH5
         Af8DfwH+AV8BUwFSAfsDVQGyAx0BKgMIAQsgAAMbASYDQAH9IP8DQAH9AxsBJgMAAQEMAAMbASYDQAH9
-        AfwB/QH8Bf8DQAH9AxsBJgMbASYDQAH9AfwB/QH8Bf8DQAH9AxsBJgMAAQEEAANqAf8DuwH/A7sB/wON
-        Af8D1AH/A7kB/wO5Af8DuQH/A7kB/wO5Af8DuQH/A9MB/wODAf8DuwH/A7sB/wMfAf8IAAMVAR0DKwH8
-        AfoC+wH/AfUC9gH/AfkC+gH/ATwBLwEuAfwBbQJRAfcDQgF2AxYBHgMFAQcYAAMbASYDQAH9BP8B1QHb
+        AfwB/QH8Bf8DQAH9AxsBJgMbASYDQAH9AfwB/QH8Bf8DQAH9AxsBJgMAAQEEAANpAf8DuwH/A7sB/wON
+        Af8D1AH/A7kB/wO5Af8DuQH/A7kB/wO5Af8DuQH/A9MB/wODAf8DuwH/A7sB/wMeAf8IAAMVAR0DKwH8
+        AfoC+wH/AfUC9gH/AfkC+gH/ATsBLgEtAfwBbQJRAfcDQgF2AxYBHgMFAQcYAAMbASYDQAH9BP8B1QHb
         AdgB/wHUAdsB1wH/AdQB2wHYAf8B0wHbAdcB/wHRAdkB1QH/Ac8B1wHTBf8DQAH9AxsBJgMBAQIMAAMb
         ASYDQAH9AeIB5QHkAf8B2AHfAdwB/wNAAf0DGwEmAxsBJgNAAf0D8wH/AfcB+AH3Af8DQAH9AxsBJgMB
-        AQIEAANvAf8D1wH/A9cB/wOXAf8D2AH/A78B/wO/Af8DvwH/A78B/wO/Af8DvwH/A9cB/wOOAf8D1wH/
-        A9cB/wM0Af8IAAMWAR4DKwH8A/sB/wHTAdoB1wH/AdoB3wHcAf8B9gH3AfYB/wHyAvMB/wE7AisB/AFg
+        AQIEAANuAf8D1wH/A9cB/wOXAf8D2AH/A78B/wO/Af8DvwH/A78B/wO/Af8DvwH/A9cB/wOOAf8D1wH/
+        A9cB/wMzAf8IAAMWAR4DKwH8A/sB/wHTAdoB1wH/AdoB3wHcAf8B9gH3AfYB/wHyAvMB/wE6AisB/AFg
         AlkB6wMzAVMDEgEZAwQBBRAAAxsBJgNAAf0E/wHaAeAB3QH/AdsB4QHeAf8B3QHiAeAB/wHdAeIB4AH/
         AdsB4QHeAf8B2AHeAdsF/wNAAf0DGwEmAwEBAgwAAxsBJgNAAf0B4gHmAeQB/wHcAeIB3wH/A0AB/QMb
-        ASYDGwEmA0AB/QHvAfEB8AH/AfAB8wHxAf8DQAH9AxsBJgMBAQIEAANzAf8D+QH/A/kB/wOrAf8D3wH/
-        A8sB/wPLAf8DywH/A8sB/wPLAf8DywH/A98B/wOjAf8D+QH/A/kB/wNWAf8IAAMWAR4DKwH8A/sB/wHf
+        ASYDGwEmA0AB/QHvAfEB8AH/AfAB8wHxAf8DQAH9AxsBJgMBAQIEAANyAf8D+QH/A/kB/wOrAf8D3wH/
+        A8sB/wPLAf8DywH/A8sB/wPLAf8DywH/A98B/wOjAf8D+QH/A/kB/wNVAf8IAAMWAR4DKwH8A/sB/wHf
         AeQB4QH/Ad4B4wHhAf8B3gHjAeAB/wHjAecB5QH/AfQC9QH/A38B/gGRAkAB/QNWAbYDJgE5AxABFQwA
         AxsBJgNAAf0E/wHdAeMB4AH/AeEB5gHjAf8B5AHpAecB/wHmAeoB6AH/AeUB6QHnAf8B4gHnAeQF/wNA
         Af0DGwEmAwEBAgwAAxsBJgNAAf0B5AHoAeUB/wHeAeMB4QH/A0AB/QMbASYDGwEmA0AB/QHsAe8B7gH/
         AecB6wHpAf8DQAH9AxsBJgMBAQIEAANqAfkD/AH/A/wB/wPLAf8D8gH/A/IB/wPyAf8D8gH/A/IB/wPy
         Af8D8gH/A/IB/wPGAf8D/AH/A/wB/wNwAf4IAAMWAR4DKwH8A/sB/wHqAe4B7AH/AewB7wHuAf8B7AHv
-        Ae4B/wHrAe4B7QH/AekB7AHrAf8DfwH+ATsCKwH8AVgCVgG7Ax0BKgMGAQgMAAMbASYDQAH9BP8B3wHk
+        Ae4B/wHrAe4B7QH/AekB7AHrAf8DfwH+AToCKwH8AVgCVgG7Ax0BKgMGAQgMAAMbASYDQAH9BP8B3wHk
         AeEB/wHkAekB5gH/AeoB7QHrAf8B7gHxAe8B/wHvAfEB8AH/AewB7wHuBf8DQAH9AxsBJgMBAQIMAAMb
         ASYDQAH9AesB7QHsAf8B3QHjAeAB/wNAAf0DGwEmAxsBJgNAAf0B7QHwAe8B/wHfAeQB4QH/A0AB/QMb
-        ASYDAQECBAADXQTSAf8D6AH/A3IB/wNyAf8DcgH/A3IB/wNyAf8DcgH/A3IB/wNyAf8DcgH/A3IB/wPo
+        ASYDAQECBAADXQTSAf8D6AH/A3EB/wNxAf8DcQH/A3EB/wNxAf8DcQH/A3EB/wNxAf8DcQH/A3EB/wPo
         Af8DxAH/A1wB3AgAAxYBHgMrAfwD+wH/AfUC9gH/AfoB+wH6Af8D+QH/Ad0C3gH/AWoCRwH5A10B7QE6
         AjkBYAMNAREUAAMbASYDQAH9BP8B3AHiAd8B/wHkAegB5gH/AesB7gHtAf8B8gH0AfMB/wH3AvgB/wH2
         AfgB9wX/A0AB/QMbASYDAQECDAADGwEmA0AB/QHyAfQB8wH/AdoB3wHdAf8DQAH9AxsBJgMcASgDQAH9
-        AfMB9QH0Af8B1gHdAdkB/wNAAf0DGwEmAwEBAgQAAy0BRQOaAf8DzAH/AccBiwFDAf8B+QH0Ae0B/wH+
-        AegB2AH/Af4B6AHXAf8B/QHlAdMB/wH8AeQB0QH/AfoB4AHHAf8B+QHdAcMB/wH6AfQB7QH/AccBhQE/
-        Af8DwwH/A2kB/wMtAUUIAAMWAR4DKwH8A/sB/wHwAfMB8gH/AeYC6AH/A00B+gFiAlIB9AFRAk8BpQMU
+        AfMB9QH0Af8B1gHdAdkB/wNAAf0DGwEmAwEBAgQAAy0BRQOaAf8DzAH/AccBiwFCAf8B+QH0Ae0B/wH+
+        AegB2AH/Af4B6AHXAf8B/QHlAdMB/wH8AeQB0QH/AfoB4AHHAf8B+QHdAcMB/wH6AfQB7QH/AccBhQE+
+        Af8DwwH/A2gB/wMtAUUIAAMWAR4DKwH8A/sB/wHwAfMB8gH/AeYC6AH/A00B+gFiAlIB9AFRAk8BpQMU
         ARwDAAEBGAADGwEmA0AB/QT/AdgB3wHcAf8B4AHlAeMB/wHoAesB6gH/Ae8B8gHwAf8B9wH4AfcB/wP9
         Bf8DQAH9AxsBJgMBAQIMAAMbASYDQAH9A/wB/wHVAdsB2AH/A0AB/QMbASYDHAEoA0AB/QP8Af8B0gHa
-        AdYB/wNAAf0DGwEmAwEBAggAAzsBYwNrAfMBxQGJAUEB/wH5AfQB7wH/Af4B5wHXAf8B/QHnAdUB/wH8
-        AeYB0gH/AfsB4QHMAf8B+AHcAcIB/wH2AdoBvQH/AfoB9AHvAf8BxAGDAT0B/wNdAfMDOwFjDAADFgEe
-        AysB/AP7Af8BPwIzAfwDTQH6AVoCVwG9AxgBIgMCAQMgAAMbASYDQAH9IP8DQAH9AxsBJgMBAQIMAAMb
-        ASYDQAH9CP8DQAH9AxsBJgMcASgDQAH9CP8DQAH9AxsBJgMBAQIMAAMHAQkBmgF9AUcC+QH0AfAB/wH8
-        AeYB0wH/Af0B5wHTAf8B+wHjAc0B/wH6AeAByAH/AfUB1gG7Af8B8wHUAbUB/wH4AfQB8AH/AZkBagFH
-        AfkDBwEJEAADFgEeA0AB/QFbAjIB+wFgAlwB1AMjATMDBwEKKAADGwEmAysB/AEqAS4BLAH/ASoBLgEs
-        Af8BKgEuASwB/wEqAS4BLAH/ASoBLgEsAf8BKgEuASwB/wEqAS4BLAH/ASoBLgEsAf8BKgEuASwB/wMb
-        ASYDAQECDAADGwEmAWMBVwFVAf4BKgEuASwB/wEqAS4BLAH/ASoBLgEsAf8DGwEmAxwBKAFjAVcBVQH+
-        ASoBLgEsAf8BKgEuASwB/wEqAS4BLAH/AxsBJgMBAQIQAAGWAX0BUQH3AfkB9QHxAf8B/AHjAc8B/wH8
-        AeQBzwH/AfoB4QHKAf8B+QHdAcQB/wH0AekB3wH/AfcB8gHsAf8B9QHvAekB/wGbAWABRQH7FAADFgEf
+        AdYB/wNAAf0DGwEmAwEBAggAAzsBYwNqAfMBxQGJAUAB/wH5AfQB7wH/Af4B5wHXAf8B/QHnAdUB/wH8
+        AeYB0gH/AfsB4QHMAf8B+AHcAcIB/wH2AdoBvQH/AfoB9AHvAf8BxAGDATwB/wNdAfMDOwFjDAADFgEe
+        AysB/AP7Af8BPgIyAfwDTQH6AVoCVwG9AxgBIgMCAQMgAAMbASYDQAH9IP8DQAH9AxsBJgMBAQIMAAMb
+        ASYDQAH9CP8DQAH9AxsBJgMcASgDQAH9CP8DQAH9AxsBJgMBAQIMAAMHAQkBlgF6AUcC+QH0AfAB/wH8
+        AeYB0wH/Af0B5wHTAf8B+wHjAc0B/wH6AeAByAH/AfUB1gG7Af8B8wHUAbUB/wH4AfQB8AH/AZUBagFH
+        AfkDBwEJEAADFgEeA0AB/QFbAjIB+wFgAlwB1AMjATMDBwEKKAADGwEmAysB/AEpAS0BKwH/ASkBLQEr
+        Af8BKQEtASsB/wEpAS0BKwH/ASkBLQErAf8BKQEtASsB/wEpAS0BKwH/ASkBLQErAf8BKQEtASsB/wMb
+        ASYDAQECDAADGwEmAWMBVwFVAf4BKQEtASsB/wEpAS0BKwH/ASkBLQErAf8DGwEmAxwBKAFjAVcBVQH+
+        ASkBLQErAf8BKQEtASsB/wEpAS0BKwH/AxsBJgMBAQIQAAGSAXoBUQH3AfkB9QHxAf8B/AHjAc8B/wH8
+        AeQBzwH/AfoB4QHKAf8B+QHdAcQB/wH0AekB3wH/AfcB8gHsAf8B9QHvAekB/wGZAV8BRQH7FAADFgEf
         AV4CWgHYAygBPQMNAREwAAMbASYDGwEmAxsBJgMbASYDGwEmAxsBJgMbASYDGwEmAxsBJgMbASYDGwEm
         AxsBJgMAAQEMAAMbASYDGwEmAxsBJgMbASYDGwEmAxsBJgMbASYDGwEmAxsBJgMbASYDGwEmAxsBJgMA
-        AQEQAAGNAW0BSQH2AfkB9QHxAf8B/AHjAc0B/wH7AeMBzQH/AfkB4AHIAf8B+AHcAcIB/wH9AfsB+AH/
-        AfwB5gHNAf8B4gG2AYQB/wJUAVIBphQAAxYBHwMRARcDAgEDuAABoAF2AU0B+gH3AfIB7AH/AfgB9AHu
-        Af8B+AHzAe0B/wH4AfMB7QH/AfgB8gHsAf8B8gHmAdcB/wHiAbIBcgH/AZMBcwFiAfYDBQEHFAADAwEE
-        wAADOgFgAlgBVgG7AbMBfwFPAf4ByAGMAUQB/wGWAYABUQH3AZYBgAFRAfcBsAF/AUwB/gNOAZQUAAFC
+        AQEQAAGJAWoBSQH2AfkB9QHxAf8B/AHjAc0B/wH7AeMBzQH/AfkB4AHIAf8B+AHcAcIB/wH9AfsB+AH/
+        AfwB5gHNAf8B4gG2AYQB/wJUAVIBphQAAxYBHwMRARcDAgEDuAABngF1AU0B+gH3AfIB7AH/AfgB9AHu
+        Af8B+AHzAe0B/wH4AfMB7QH/AfgB8gHsAf8B8gHmAdcB/wHiAbIBcQH/AZABcQFiAfYDBQEHFAADAwEE
+        wAADOgFgAlgBVgG7AbEBfwFPAf4ByAGMAUMB/wGSAX8BUQH3AZIBfwFRAfcBrgF/AUwB/gNOAZQUAAFC
         AU0BPgcAAT4DAAEoAwABQAMAASADAAEBAQABAQYAAQEWAAP/gQAB3wX/AeABBwHHBf8CAAHBAf8BwAED
         AcABAwIAAcAB/wHAAQMBwAEDAgABwAE/AcABAQHAAQECAAHAAQ8BwAEBAcABAQIAAcABAwHAAQEBwAEB
         AgABwAEBAcABAQHAAQECAAHAAQEBwAEBAcABAQIAAcABBwHAAQEBwAEBAgABwAEPAcABAQHAAQEBgAEB

GraphLib/PlotterGraphPaneEx.cs

@@ -84,7 +84,7 @@ namespace GraphLib
         
         public float CurXD1 = 0;
 
-        public float grid_distance_x = 200;       // grid distance in samples ( draw a vertical line every 200 samples )
+        public float grid_distance_x = 60;  // grid distance in samples ( draw a vertical line every 60 samples )
         public float grid_off_x = 0;
         public float GraphCaptionLineHeight = 28;
 
@@ -452,7 +452,7 @@ namespace GraphLib
                     
                     if (layout == LayoutMode.NORMAL)
                     {
-                        DrawGraphCaption(CurGraphics, source, marker_pos, CurOffX + CurGraphIdx * (10 + yLabelAreaWidth), curOffY);
+                        DrawGraphCaption(CurGraphics, source, marker_pos, CurOffX + CurGraphIdx * (50 + yLabelAreaWidth) + (CurGraphIdx==0 ? 0 : 50), curOffY);
 
                         if (CurGraphIdx == 0)
                         {
@@ -600,7 +600,7 @@ namespace GraphLib
 
                     List<int> marker_pos = DrawGraphCurve(CurGraphics, source, CurOffX, curOffY + GraphCaptionLineHeight / 2);
 
-                    DrawGraphCaption(CurGraphics, source, marker_pos, CurOffX + CurGraphIdx * (10 + yLabelAreaWidth), pad_top);
+                    DrawGraphCaption(CurGraphics, source, marker_pos, CurOffX + CurGraphIdx * (50 + yLabelAreaWidth) + (CurGraphIdx == 0 ? 0 : 50), pad_top);
                   
                     DrawYLabels(CurGraphics, source, marker_pos, CurOffX, curOffY);
 
@@ -776,12 +776,15 @@ namespace GraphLib
 						float y0 = (float)(source.grid_off_y * source.CurGraphHeight / source.DY + source.off_Y);
 
 						// draw horizontal zero grid lines
-						g.DrawLine(p2, new Point((int)CurrOffX, (int)(CurOffY + y0 + 0.5f)), new Point((int)(CurrOffX + source.CurGraphWidth + 0.5f), (int)(CurOffY + y0 + 0.5f)));
+						if (0 >= source.YD0 && 0 <= source.YD1)
+						{
+							g.DrawLine(p2, new Point((int)CurrOffX, (int)(CurOffY + y0 + 0.5f)), new Point((int)(CurrOffX + source.CurGraphWidth + 0.5f), (int)(CurOffY + y0 + 0.5f)));
+						}
 
 						// draw horizontal grid lines
-						for (Idx = (int)(source.grid_off_y);Idx > (int)(source.YD0 ); Idx -= (int)source.grid_distance_y)
+						for (float idy = source.grid_off_y; idy > source.YD0; idy -= source.grid_distance_y)
 						{
-							float y = (float)(Idx * source.CurGraphHeight) / source.DY + source.off_Y;
+							float y = (idy * source.CurGraphHeight) / source.DY + source.off_Y;
 
 							if (y >= 0 && y < source.CurGraphHeight)
 							{
@@ -792,9 +795,9 @@ namespace GraphLib
 						}
 
 						// draw horizontal grid lines
-						for (Idx = (int)(source.grid_off_y); Idx < (int)(source.YD1  ); Idx += (int)source.grid_distance_y)
+						for (float idy = source.grid_off_y; idy < source.YD1; idy += source.grid_distance_y)
 						{
-							float y = (float)Idx * source.CurGraphHeight / source.DY + source.off_Y;
+							float y = (idy * source.CurGraphHeight) / source.DY + source.off_Y;
 
 							if (y >= 0 && y < source.CurGraphHeight)
 							{
@@ -968,71 +971,58 @@ namespace GraphLib
                 using (Pen pen = new Pen(b))
                 {
                     pen.DashPattern = new float[] { 2, 2 };
+
+					float GridDistY = source.grid_distance_y;
+					///
+					if (source.AutoScaleY)
+					{
+						// calculate a matching grid distance                            
+						GridDistY = -Utilities.MostSignificantDigit(source.DY);
+
+						if (GridDistY == 0)
+						{
+							GridDistY = source.grid_distance_y;
+						}
+					}
                      
                     // draw labels for horizontal lines
                     if (source.DY != 0)
                     {
-                        float Idx = 0;
+						float y0 = (float)(source.grid_off_y * source.CurGraphHeight / source.DY + source.off_Y);
+						if (y0 >= 0 && y0 < source.CurGraphHeight)
+						{
+							String value = (source.OnRenderYAxisLabel == null) ? "0" : source.OnRenderYAxisLabel(source, 0);
+							SizeF dim = g.MeasureString(value, legendFont);
+							g.DrawString(value, legendFont, b, new PointF((int)offset_x - dim.Width, (int)(offset_y + y0 + 0.5f + dim.Height / 2)));
+						}
 
-                        float y0 = (float)(source.grid_off_y * source.CurGraphHeight / source.DY + source.off_Y);
-
-                        String value = "" + Idx;
-
-                        if (source.OnRenderYAxisLabel != null)
-                        {
-                            value = source.OnRenderYAxisLabel(source, Idx);
-                        }
-
-                        SizeF dim = g.MeasureString(value, legendFont);
-                        g.DrawString(value, legendFont, b, new PointF((int)offset_x - dim.Width, (int)(offset_y + y0 + 0.5f + dim.Height / 2)));
-
-                        float GridDistY = source.grid_distance_y;
-
-                        if (source.AutoScaleY)
-                        {
-                            // calculate a matching grid distance                            
-                            GridDistY = - Utilities.MostSignificantDigit(source.DY );
-
-                            if (GridDistY == 0)
-                            {
-                                GridDistY =  source.grid_distance_y;
-                                 
-                            }
-                        }
-
-                        for (Idx =  (source.grid_off_y); Idx >  (source.Cur_YD0); Idx -=  GridDistY)
+						for (float Idx = source.grid_off_y; Idx > source.YD0; Idx -= GridDistY)
                         {
                             if (Idx != 0)
                             {
-                                float y1 = (float)((Idx) * source.CurGraphHeight) / source.DY + source.off_Y;
+                                float y1 = (float)(Idx * source.CurGraphHeight) / source.DY + source.off_Y;
 
-                                value = "" + (Idx);
-
-                                if (source.OnRenderYAxisLabel != null)
-                                {
-                                    value = source.OnRenderYAxisLabel(source, Idx);
-                                }
-
-                                dim = g.MeasureString(value, legendFont);
-                                g.DrawString(value, legendFont, b, new PointF((int)offset_x - dim.Width, (int)(offset_y + y1 + 0.5f + dim.Height / 2)));                                
+								if (y1 >= 0 && y1 < source.CurGraphHeight)
+								{
+									string value = (source.OnRenderYAxisLabel == null) ? Idx.ToString() : source.OnRenderYAxisLabel(source, Idx);
+									SizeF dim = g.MeasureString(value, legendFont);
+									g.DrawString(value, legendFont, b, new PointF((int)offset_x - dim.Width, (int)(offset_y + y1 + 0.5f + dim.Height / 2)));
+								}
                             }
                         }
 
-                        for (Idx =  (source.grid_off_y); Idx <  (source.Cur_YD1); Idx +=  GridDistY)
+						for (float Idx = source.grid_off_y; Idx < source.YD1; Idx += GridDistY)
                         {
                             if (Idx != 0)
                             {
-                                float y2 = (float)((Idx) * source.CurGraphHeight) / source.DY + source.off_Y;
+                                float y2 = (float)(Idx * source.CurGraphHeight) / source.DY + source.off_Y;
 
-                                value = "" + (Idx);
-
-                                if (source.OnRenderYAxisLabel != null)
-                                {
-                                    value = source.OnRenderYAxisLabel(source, Idx);
-                                }                               
-
-                                dim = g.MeasureString(value, legendFont);
-                                g.DrawString(value, legendFont, b, new PointF((int)offset_x - dim.Width, (int)(offset_y + y2 + 0.5f + dim.Height / 2)));
+								if (y2 >= 0 && y2 < source.CurGraphHeight)
+								{
+									string value = (source.OnRenderYAxisLabel == null) ? Idx.ToString() : source.OnRenderYAxisLabel(source, Idx);
+									SizeF dim = g.MeasureString(value, legendFont);
+									g.DrawString(value, legendFont, b, new PointF((int)offset_x - dim.Width, (int)(offset_y + y2 + 0.5f + dim.Height / 2)));
+								}
                             }
                         }                             
                     }

GraphLib/PrecisionTimer.cs

@@ -1,490 +0,0 @@
-using System;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-
-#region License
-
-/*  
- * Based on the work of  Leslie Sanford  
- */
-
-#endregion
-
-
-namespace PrecisionTimer
-{    
-    public enum Mode
-    {        
-        OneShot,        
-        Periodic
-    };
-    
-    [StructLayout(LayoutKind.Sequential)]
-    public struct TimerCaps
-    {       
-        public int periodMin;       
-        public int periodMax;
-    }
-
-    
-    public sealed class Timer : IComponent
-    {       
-        private delegate void TimeProc(int id, int msg, int user, int param1, int param2);
-
-        private delegate void EventRaiser(EventArgs e);
-            
-        [DllImport("winmm.dll")]
-        private static extern int timeGetDevCaps(ref TimerCaps caps,
-                                                 int sizeOfTimerCaps);
-
-        [DllImport("winmm.dll")]
-        private static extern int timeSetEvent(int delay, 
-                                               int resolution,
-                                               TimeProc proc, 
-                                               int user, 
-                                               int mode);
-
-        [DllImport("winmm.dll")]
-        private static extern int timeKillEvent(int id);
-
-        private const int TIMERR_NOERROR = 0;
-        
-        private int timerID;
-
-        private volatile Mode mode;
-        
-        private volatile int period;
-
-        private volatile int resolution;        
-        
-        private TimeProc timeProcPeriodic;
-
-        private TimeProc timeProcOneShot;
-
-        private EventRaiser tickRaiser;
-
-        private bool running = false;
-
-        private volatile bool disposed = false;
-
-        private ISynchronizeInvoke synchronizingObject = null;
-
-        private ISite site = null;
-
-        private static TimerCaps caps;      
-         
-        public event EventHandler Started;
-         
-        public event EventHandler Stopped;
-         
-        public event EventHandler Tick;
-         
-        static Timer()
-        {
-            // Get multimedia timer capabilities.
-            timeGetDevCaps(ref caps, Marshal.SizeOf(caps));
-        }
-
-        
-        public Timer(IContainer container)
-        {
-            
-            container.Add(this);
-
-            Initialize();
-        }
-
-         
-        public Timer()
-        {
-            Initialize();
-        }
-
-        ~Timer()
-        {
-            if(IsRunning)
-            {
-                // Stop and destroy timer.
-                timeKillEvent(timerID);
-            }
-        }
-
-        private void Initialize()
-        {
-            this.mode = Mode.Periodic;
-            this.period = Capabilities.periodMin;
-            this.resolution = 1;
-
-            running = false;
-
-            timeProcPeriodic = new TimeProc(TimerPeriodicEventCallback);
-            timeProcOneShot = new TimeProc(TimerOneShotEventCallback);
-            tickRaiser = new EventRaiser(OnTick);
-        }
-
-        
-        public void Start()
-        {
-            
-            if(disposed)
-            {
-                throw new ObjectDisposedException("Timer");
-            }
- 
-            if(IsRunning)
-            {
-                return;
-            }
-           
-            if(Mode == Mode.Periodic)
-            {
-                 timerID = timeSetEvent(Period, Resolution, timeProcPeriodic, 0, (int)Mode);
-            }
-            else
-            {
-                  timerID = timeSetEvent(Period, Resolution, timeProcOneShot, 0, (int)Mode);
-            }
-
-            if(timerID != 0)
-            {
-                running = true;
-
-                if(SynchronizingObject != null && SynchronizingObject.InvokeRequired)
-                {
-                    SynchronizingObject.BeginInvoke(
-                        new EventRaiser(OnStarted), 
-                        new object[] { EventArgs.Empty });
-                }
-                else
-                {
-                    OnStarted(EventArgs.Empty);
-                }                
-            }
-            else
-            {
-                throw new TimerException("Unable to start timer.");
-            }
-        }
-
-        
-        public void Stop()
-        {
-            
-            if(disposed)
-            {
-                throw new ObjectDisposedException("Timer");
-            }
-                        
-            if(!running)
-            {
-                return;
-            }
-
-                       
-            int result = timeKillEvent(timerID);
-
-            Debug.Assert(result == TIMERR_NOERROR);
-
-            running = false;
-
-            if(SynchronizingObject != null && SynchronizingObject.InvokeRequired)
-            {
-                SynchronizingObject.BeginInvoke(
-                    new EventRaiser(OnStopped), 
-                    new object[] { EventArgs.Empty });
-            }
-            else
-            {
-                OnStopped(EventArgs.Empty);
-            }
-        }        
-
-         
-        private void TimerPeriodicEventCallback(int id, int msg, int user, int param1, int param2)
-        {
-            if(synchronizingObject != null)
-            {
-                synchronizingObject.BeginInvoke(tickRaiser, new object[] { EventArgs.Empty });
-            }
-            else
-            {
-                OnTick(EventArgs.Empty);
-            }
-        }
-      
-        private void TimerOneShotEventCallback(int id, int msg, int user, int param1, int param2)
-        {
-            if(synchronizingObject != null)
-            {
-                synchronizingObject.BeginInvoke(tickRaiser, new object[] { EventArgs.Empty });
-                Stop();
-            }
-            else
-            {
-                OnTick(EventArgs.Empty);
-                Stop();
-            }
-        }
-
-        
-       
-        // Raises the Disposed event.
-        private void OnDisposed(EventArgs e)
-        {
-            EventHandler handler = Disposed;
-
-            if(handler != null)
-            {
-                handler(this, e);
-            }
-        }
-
-        // Raises the Started event.
-        private void OnStarted(EventArgs e)
-        {
-            EventHandler handler = Started;
-
-            if(handler != null)
-            {
-                handler(this, e);
-            }
-        }
-
-        // Raises the Stopped event.
-        private void OnStopped(EventArgs e)
-        {
-            EventHandler handler = Stopped;
-
-            if(handler != null)
-            {
-                handler(this, e);
-            }
-        }
-
-        // Raises the Tick event.
-        private void OnTick(EventArgs e)
-        {
-            EventHandler handler = Tick;
-
-            if(handler != null)
-            {
-                handler(this, e);
-            }
-        }
-
-      
-       
-       
-
-        /// <summary>
-        /// Gets or sets the object used to marshal event-handler calls.
-        /// </summary>
-        public ISynchronizeInvoke SynchronizingObject
-        {
-            get
-            {
-                #region Require
-
-                if(disposed)
-                {
-                    throw new ObjectDisposedException("Timer");
-                }
-
-                #endregion
-
-                return synchronizingObject;
-            }
-            set
-            {
-                #region Require
-
-                if(disposed)
-                {
-                    throw new ObjectDisposedException("Timer");
-                }
-
-                #endregion
-
-                synchronizingObject = value;
-            }
-        }
-
-         
-        public int Period
-        {
-            get
-            {
-                #region Require
-
-                if(disposed)
-                {
-                    throw new ObjectDisposedException("Timer");
-                }
-
-                #endregion
-
-                return period;
-            }
-            set
-            {
-                #region Require
-
-                if(disposed)
-                {
-                    throw new ObjectDisposedException("Timer");
-                }
-                else if(value < Capabilities.periodMin || value > Capabilities.periodMax)
-                {
-                    throw new ArgumentOutOfRangeException("Period", value,
-                        "Multimedia Timer period out of range.");
-                }
-
-                #endregion
-
-                period = value;
-
-                if(IsRunning)
-                {
-                    Stop();
-                    Start();
-                }
-            }
-        }
-
-       
-        public int Resolution
-        {
-            get
-            {
-                
-                if(disposed)
-                {
-                    throw new ObjectDisposedException("Timer");
-                }
-                
-                return resolution;
-            }
-            set
-            {               
-                if(disposed)
-                {
-                    throw new ObjectDisposedException("Timer");
-                }
-                else if(value < 0)
-                {
-                    throw new ArgumentOutOfRangeException("Resolution", value,
-                        "timer resolution out of range.");
-                }
-
-                resolution = value;
-
-                if(IsRunning)
-                {
-                    Stop();
-                    Start();
-                }
-            }
-        }
-        
-        public Mode Mode
-        {
-            get
-            {
-                
-                if(disposed)
-                {
-                    throw new ObjectDisposedException("Timer");
-                }
-
-                
-                return mode;
-            }
-            set
-            {
-               
-                if(disposed)
-                {
-                    throw new ObjectDisposedException("Timer");
-                }
-
-                 
-                mode = value;
-
-                if(IsRunning)
-                {
-                    Stop();
-                    Start();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Gets a value indicating whether the Timer is running.
-        /// </summary>
-        public bool IsRunning
-        {
-            get
-            {
-                return running;
-            }
-        }
-
-        /// <summary>
-        /// Gets the timer capabilities.
-        /// </summary>
-        public static TimerCaps Capabilities
-        {
-            get
-            {
-                return caps;
-            }
-        }
-
-      
-      
-      
-        public event System.EventHandler Disposed;
-
-        public ISite Site
-        {
-            get
-            {
-                return site;
-            }
-            set
-            {
-                site = value;
-            }
-        }
-
-       
-        public void Dispose()
-        {
-            
-            if(disposed)
-            {
-                return;
-            }
-            
-            if(IsRunning)
-            {
-                Stop();
-            }
-
-            disposed = true;
-
-            OnDisposed(EventArgs.Empty);
-        }
-
-        
-    }
-
-    
-    public class TimerException : ApplicationException
-    {       
-        public TimerException(string message) : base(message)
-        {
-        }
-    }
-}

MonitoringDB/Entities/Part.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+
+namespace MonitoringDB.Entities
+{
+    public class Part
+    {
+        public virtual int Id { get; protected set; }
+        public virtual string Name { get; set; }
+        public virtual string OraDBType { get; set; }
+        public virtual string Description { get; set; }
+		public virtual CodeType CodeType { get; set; }
+        public virtual CodeForm CodeForm { get; set; }
+		public virtual CodeLocation CodeLocation { get; set; }
+		public virtual LifetimeManagement LifetimeManagement { get; set; }
+		public virtual int StepNumber { get; set; }
+
+		public virtual Process Process { get; set; }
+		public virtual Workstep Workstep { get; set; }
+
+
+		protected Part()
+		{
+            Name = string.Empty;
+            Description = string.Empty;
+        }
+
+		/// <summary>
+		/// Constructor used when the part is added to a process
+		/// </summary>
+		/// <param name="name"></param>
+		/// <param name="codeType"></param>
+		/// <param name="codeForm"></param>
+		/// <param name="process"></param>
+		public Part(string name, Process process, CodeType codeType, CodeForm codeForm, CodeLocation codeLocation)
+		{
+            Name = name;
+            OraDBType = string.Empty;
+			Description = string.Empty;
+			CodeType = codeType;
+			CodeForm = codeForm;
+			CodeLocation = codeLocation;
+			StepNumber = 0;
+
+			Process = process;
+			Workstep = null;
+		}
+
+        /// <summary>
+        /// Create a copy of a part (1) belongig to another process, (2) not assigned to any workstep yet.
+        /// </summary>
+        /// <param name="process">Process owning the cloned part</param>
+        /// <returns>Cloned part</returns>
+		public virtual Part Clone(Process owningProcess)
+		{
+			Part rslt = new Part(Name, owningProcess, CodeType, CodeForm, CodeLocation);
+            rslt.OraDBType = OraDBType;
+            rslt.Description = Description;
+			rslt.LifetimeManagement = LifetimeManagement;
+			return rslt;
+		}
+
+		public override string ToString()
+		{
+            return string.Format("{0} step={1} ({2})", Name, StepNumber, Description);
+		}
+    }
+}

MonitoringDB/Entities/Process.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+
+namespace MonitoringDB.Entities
+{
+    public class Process
+    {
+        public virtual int Id { get; protected set; }
+        public virtual int ItemNr { get; set; }
+        public virtual string Name { get; set; }
+		public virtual string Description { get; set; }
+		public virtual ReleaseStatus ReleaseStatus { get; set; }
+		public virtual DateTime TimeStamp { get; set; }
+		public virtual string UserName { get; set; }
+
+		public virtual IList<Part> Parts { get; set; }
+		public virtual IList<Workstep> Worksteps { get; set; }
+
+		/// <summary>
+		/// Default (private) constructor inicializing lists
+		/// </summary>
+		protected Process()
+		{
+			Parts = new List<Part>();
+			Worksteps = new List<Workstep>();
+		}
+
+		/// <summary>
+		/// Constructor used when this process is created
+		/// </summary>
+		/// <param name="name"></param>
+		public Process(string name)
+			: this()
+		{
+			Name = name;
+			Description = string.Empty;
+			ReleaseStatus = ReleaseStatus.In_preparation;
+			TimeStamp = DateTime.Now;
+			UserName = "admin";
+		}
+
+        /// <summary>
+        /// Create a copy of a process with a new name
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+		public virtual Process Clone(string name)
+		{
+			Process rslt = new Process(name);
+			rslt.Description = Description;
+
+			foreach (var part in Parts) rslt.Parts.Add(part.Clone(rslt));
+			foreach (var workstep in Worksteps) rslt.Worksteps.Add(workstep.Clone(rslt));
+
+			return rslt;
+		}
+
+		public override string ToString()
+		{
+			return string.Format("{0} '{1}' ({2}) {3} {4}",
+								 ItemNr,
+								 Name,
+								 TimeStamp.Date.ToShortDateString(),
+								 (Description == null) ? string.Empty : Description,
+								 ReleaseStatus);
+		}
+    }
+}

MonitoringDB/Entities/Record.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+
+namespace MonitoringDB.Entities
+{
+    public class Record
+    {
+        public virtual int Id { get; protected set; }
+        public virtual string Code { get; set; }
+		public virtual DateTime TimeStamp { get; set; }
+
+		public virtual Part Part { get; set; }
+		public virtual ReferenceRecord ReferenceRecord { get; set; }
+
+
+		protected Record()
+		{
+		}
+
+		/// <summary>
+		/// Constructor used when a part barcode is scanned
+		/// </summary>
+		/// <param name="partId">Part</param>
+		/// <param name="referenceRecordId">Reference record</param>
+		/// <param name="code">Scanned barcode</param>
+		public Record(Part part, ReferenceRecord referenceRecord, string code)
+		{
+			Part = part;
+			ReferenceRecord = referenceRecord;
+			Code = code;
+			TimeStamp = DateTime.Now;
+		}
+
+        /// <summary>
+        /// Create a copy of a process with a new name
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public virtual Record Clone(Process newProcess, ReferenceRecord newRR)
+        {
+            Part newPart = null;
+            foreach (var pt in newProcess.Parts)
+            {
+                if (Part.Name == pt.Name)
+                {
+                    newPart = pt;
+                    break;
+                }
+            }
+            Record rslt = new Record(newPart, newRR, Code);
+            rslt.TimeStamp = TimeStamp;
+
+            return rslt;
+        }
+
+		public override string ToString()
+		{
+            return string.Format("code={0}  part={1}  description='{2}'", Code, Part.Name, Part.Description);
+		}
+	}
+}

MonitoringDB/Entities/ReferenceRecord.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+
+namespace MonitoringDB.Entities
+{
+    public class ReferenceRecord
+    {
+        public virtual int Id { get; protected set; }
+		public virtual string Code { get; set; }
+		public virtual DateTime TimeStamp { get; set; }
+		public virtual string UserName { get; set; }
+		public virtual string Workplace { get; set; }
+		public virtual int Result { get; set; }			/// 0 = No error (OK), >0 = Error code
+
+		public virtual Process Process { get; set; }
+		public virtual Workstep Workstep { get; set; }
+		public virtual IList<Record> Records { get; set; }
+
+
+		/// <summary>
+		/// Default (private) constructor inicializing lists
+		/// </summary>
+		protected ReferenceRecord()
+		{
+			Records = new List<Record>();
+		}
+
+		/// <summary>
+		/// Constructor used when reference barcode is scanned
+		/// </summary>
+		/// <param name="process">Process</param>
+		/// <param name="workstep">Workstep</param>
+		/// <param name="code">Scanned barcode</param>
+		public ReferenceRecord(Process process, Workstep workstep, string code,
+							   string userName, string workplace, int result)
+		{
+			Process = process;
+			Workstep = workstep;
+			Code = code;
+			TimeStamp = DateTime.Now;
+			UserName = userName;
+			Workplace = workplace;
+			Result = result;
+        }
+
+        /// <summary>
+        /// Create a copy of a process with a new name
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public virtual ReferenceRecord Clone(Process newProcess)
+        {
+            Workstep newWorkstep = null;
+            foreach (var ws in newProcess.Worksteps)
+            {
+                if (Workstep.Name == ws.Name)
+                {
+                    newWorkstep = ws;
+                    break;
+                }
+            }
+
+            ReferenceRecord rslt = new ReferenceRecord(newProcess, newWorkstep,
+                                                       Code, UserName, Workplace, Result);
+            rslt.TimeStamp = TimeStamp;
+
+            rslt.Records = new List<Record>();
+            foreach (var record in Records)
+            {
+                rslt.Records.Add(record.Clone(newProcess, rslt));
+            }
+
+            return rslt;
+        }
+
+		public override string ToString()
+		{
+            return string.Format("code={0}  part={1}  description='{2}'  step='{3}'  workplace='{4}'  user={5}  time={6:dd.MM.yyyy HH:mm:ss}",
+                                 (Code != null) ? Code : "<none>",
+                                 Workstep.ReferencePart.Name,
+                                 Workstep.ReferencePart.Description,
+                                 Workstep.Name,
+                                 Workplace,
+                                 UserName,
+                                 TimeStamp);
+		}
+    }
+}

MonitoringDB/Entities/Workstep.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+
+namespace MonitoringDB.Entities
+{
+    public class Workstep
+    {
+        public virtual int Id { get; protected set; }
+        public virtual int WorkstepNr { get; set; }
+        public virtual string Name { get; set; }
+		public virtual string Description { get; set; }
+        public virtual int CheckPartNr { get; set; }
+        public virtual bool AllowRepairs { get; set; }
+
+		public virtual Process Process { get; set; }
+		public virtual Part ReferencePart { get; set; }
+		public virtual IList<Part> Parts { get; set; }
+
+
+		/// <summary>
+		/// Default (private) constructor inicializing a list
+		/// </summary>
+		protected Workstep()
+		{
+			Parts = new List<Part>();
+		}
+
+		/// <summary>
+		/// Constructor used when this workstep is added to a process
+		/// </summary>
+		/// <param name="name">Workstep name</param>
+		/// <param name="process">Process to be referenced</param>
+		public Workstep(int workstepNr, string name, Process process)
+			: this()
+		{
+            WorkstepNr = workstepNr;
+			Name = name;
+			Description = string.Empty;
+            CheckPartNr = 0;
+            AllowRepairs = false;
+			Process = process;
+			ReferencePart = null;
+		}
+
+		public virtual Workstep Clone(Process owningProcess)
+		{
+			Workstep rslt = new Workstep(WorkstepNr, Name, owningProcess);
+			rslt.Description = Description;
+            rslt.CheckPartNr = CheckPartNr;
+            rslt.AllowRepairs = AllowRepairs;
+
+			if (ReferencePart != null)
+			{
+				foreach (var p in owningProcess.Parts)
+				{
+					if (p.Name == ReferencePart.Name) rslt.ReferencePart = p;
+				}
+			}
+
+			foreach (var srcP in Parts)
+			{
+				foreach (var p in owningProcess.Parts)
+				{
+					if (p.Name == srcP.Name)
+					{
+						rslt.Parts.Add(p);
+						p.StepNumber = srcP.StepNumber;
+						p.Workstep = rslt;
+					}
+				}
+			}
+
+			return rslt;
+		}
+
+		public override string ToString()
+		{
+			//return string.Format("{0} {1} ({2}) Ref: {3}", WorkstepNr, Name, Description, (ReferencePart != null) ? ReferencePart.Name : "none");
+            return string.Format("{0}: {1}", WorkstepNr, Name);
+        }
+    }
+}

MonitoringDB/Enums.cs

@@ -0,0 +1,94 @@
+namespace MonitoringDB
+{
+    public enum CodeType
+    {
+        UniqueNr,
+        FlowtubeNr,                 /// prvé 3 znaky sa zhodujú s poslednými 3 znakmi názvu
+        FlowtubeNrLU,               /// začiatok kódu sa zhoduje s názvom
+        BatchNr,
+        BatchNrContainingPartName,
+        DateMMYY,
+		QualityCheck,
+    }
+
+    public enum CodeForm
+    {
+        Barcode,
+        QRCode,
+		Keyboard,
+		OkNok,
+    }
+
+	public enum CodeLocation
+	{
+		OnPart,
+		OnPallet,
+	}
+
+	public enum LifetimeManagement
+	{
+		None,
+		OneYear,
+		Count,
+	}
+
+	public enum ReleaseStatus
+	{
+		In_preparation,
+		Released,
+		ReleasedActive,
+		Deactivated,
+		Count,
+	}
+
+	public enum Mode
+	{
+		Debug,			// Debug mode - no Oracle database used
+		Test,			// Test database used
+		Production,		// Production database used
+		Count,
+	}
+
+    public enum LoginLevel
+    {
+        None,
+        TeamLeader,
+        Administrator,
+        MH,
+        Count,
+    }
+
+    public enum ItemSpecID
+    {
+        RefRecordID = 0,
+
+        TimeStamp,
+        Workstep,
+        Workplace,
+        UserName,
+        Barcode,
+        PartBarcode,
+
+        TimeStamp2,
+        Workstep2,
+        Workplace2,
+        UserName2,
+        Barcode2,
+        PartBarcode2,
+
+        SerialNr,
+        PurchaseOrder,
+        TestResult,
+        MaxPruefindex,
+        
+        Process,
+    }
+
+    public enum ItemSpecCaps
+    {
+        None = 0,
+        ReferenceRecord = 1,
+        AssociatedRecord = 2,
+        OracleQuery = 4,
+    }
+}

MonitoringDB/FluentNH.cs

@@ -0,0 +1,212 @@
+using System;
+using System.Collections.Generic;
+using FluentNHibernate.Cfg;
+using FluentNHibernate.Cfg.Db;
+using NHibernate;
+using NHibernate.Cfg;
+using NHibernate.Tool.hbm2ddl;
+
+namespace MonitoringDB
+{
+    public static class FluentNH
+    {
+		/// <summary>
+		/// Current session factory for the last used connection string or null
+		/// </summary>
+		public static ISessionFactory SessionFactory;
+
+
+        /// <summary> Connection string for all sessions </summary>
+        static string connectionString;
+        /// 
+        public static string ConnectionString
+        {
+            get { return connectionString; }
+            set
+            {
+                if (value != connectionString)
+                {
+                    connectionString = value;
+                    SessionFactory = null;          /// Clear SessionFactory on connection string change
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// NHibernate session factory (to create the database session 'SessionFactory')
+        /// </summary>
+        /// <returns>A database session</returns>
+		static ISessionFactory CreateSessionFactory()
+        {
+			return CreateSessionFactory(false);
+		}
+
+        /// <summary>
+        /// NHibernate session factory (to create the database session 'SessionFactory')
+        /// </summary>
+        /// <returns>A database session</returns>
+		public static ISessionFactory CreateSessionFactory(bool createDB)
+        {
+			FluentConfiguration cfg = Fluently
+				.Configure()
+				.Database(MySQLConfiguration.Standard.ConnectionString(connectionString))
+				.Mappings(m => m.FluentMappings.AddFromAssemblyOf<Entities.Process>());
+
+			if (createDB)
+            {
+                return cfg.ExposeConfiguration(BuildSchemaCreate).BuildSessionFactory();
+            }
+            else
+            {
+                return cfg.ExposeConfiguration(BuildSchema).BuildSessionFactory();
+            }
+        }
+
+        public delegate void BuildSchemaDlgt(Configuration config);
+
+        public static void BuildSchema(Configuration config)
+        {
+            /// This NHibernate tool takes a configuration (with mapping info in)
+            /// and exports a database schema from it
+            new SchemaExport(config).SetOutputFile("db_schema");
+        }
+
+        static void BuildSchemaCreate(Configuration config)
+        {
+            /// This NHibernate tool takes a configuration (with mapping info in)
+            /// and exports a database schema from it
+            new SchemaExport(config).Create(true, true);
+        }
+
+		/// Create a NHibernate session for the given database
+		public static ISession CreateSession(string connectionString)
+		{
+            ConnectionString = connectionString;    /// Clears session factory on connction string change
+
+			if (SessionFactory == null)
+                SessionFactory = CreateSessionFactory();
+
+			return SessionFactory.OpenSession();
+		}
+
+
+        /// <summary>
+        /// Create an empty database.
+		/// Database contains only the user 'admin' and the control board component 'CB'.
+        /// </summary>
+        /// <param name="dbType">DBType.SQLite or DBType.MySql</param>
+        /// <param name="connectionString">Connection string</param>
+        /// <returns>true=success, false=error</returns>
+        public static bool CreateEmptyDB(string connectionString)
+        {
+            ConnectionString = connectionString;
+
+			ISessionFactory sessionFactory = CreateSessionFactory(true);
+            if (sessionFactory == null) return false;
+
+            /// Populate the database
+            using (var session = sessionFactory.OpenSession())
+            {
+				//using (var transaction = session.BeginTransaction())
+				//{
+				//    var part1 = new MonitoringDB.Entities.Part("flow tube", CodeType.UniqueNr, CodeForm.QRCode, 0);
+				//    session.SaveOrUpdate(part1);
+				//    transaction.Commit();
+				//}
+            }
+
+            return true;
+        }
+
+
+		public static IList<WMPart> FindWMParts(string pcbNumber, string connString)
+		{
+			IList<WMPart> foundParts = new List<WMPart>();				/// initially empty
+
+			if (string.IsNullOrEmpty(pcbNumber)) return foundParts;		/// return an empty list
+
+			try
+			{
+				ISession session = CreateSession(connString);
+
+				IList<Entities.ReferenceRecord> referenceRecords = session
+					.QueryOver<Entities.ReferenceRecord>()
+					.Where(x => (x.Code == pcbNumber))
+					.OrderBy(x => x.TimeStamp).Desc
+					.List<Entities.ReferenceRecord>();
+
+				if (referenceRecords.Count == 0) return foundParts;
+
+				foundParts.Add(new WMPart(referenceRecords[0]));
+				Entities.Process process = referenceRecords[0].Process;
+				///
+				foreach (var refR in referenceRecords)
+				{
+					if (process != refR.Process)
+					{
+						continue;	/// skip records obtained by another process
+					}
+
+					IList<Entities.Record> relatedRecords = session
+						.QueryOver<Entities.Record>()
+						.Where(x => (x.ReferenceRecord == refR))
+						.List<Entities.Record>();
+
+
+					foreach (var relR in relatedRecords)
+					{
+						foundParts.Add(new WMPart(relR));
+						foreach (var ws in process.Worksteps)
+						{
+							if (ws.ReferencePart == relR.Part)
+							{
+								FindWMPartsRecursively(process, ws.ReferencePart, relR.Code, session, ref foundParts);
+							}
+						}
+					}
+				}
+			}
+			catch
+			{
+			}
+
+			return foundParts;
+		}
+
+
+		static void FindWMPartsRecursively(Entities.Process process, Entities.Part refPart, string code, ISession session, ref IList<WMPart> foundParts)
+		{
+			IList<Entities.ReferenceRecord> referenceRecords = session
+				.QueryOver<Entities.ReferenceRecord>()
+				.Where(x => (x.Workstep.ReferencePart == refPart))
+				.Where(x => (x.Code == code))
+				.OrderBy(x => x.TimeStamp).Desc
+				.List<Entities.ReferenceRecord>();
+
+			if (referenceRecords.Count == 0) return;
+
+			foreach (var refR in referenceRecords)
+			{
+				IList<Entities.Record> relatedRecords = session
+					.QueryOver<Entities.Record>()
+					.Where(x => (x.ReferenceRecord == refR))
+					.List<Entities.Record>();
+
+
+				foreach (var relR in relatedRecords)
+				{
+					foundParts.Add(new WMPart(relR));
+
+					foreach (var ws in process.Worksteps)
+					{
+						if (ws.ReferencePart == relR.Part)
+						{
+							FindWMPartsRecursively(process, ws.ReferencePart, relR.Code, session, ref foundParts);
+						}
+					}
+				}
+			}
+		}
+    }
+}

MonitoringDB/Forms/ListViewEx.cs

@@ -0,0 +1,456 @@
+///
+/// Copyright (c) 2016 Sensus Metering Systems
+///
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Data;
+using System.Windows.Forms;
+using System.Runtime.InteropServices;
+
+namespace MonitoringDB.Forms
+{
+	/// <summary>
+	/// Event Handler for SubItem events
+	/// </summary>
+	public delegate void SubItemEventHandler(object sender, SubItemEventArgs e);
+	/// <summary>
+	/// Event Handler for SubItemEndEditing events
+	/// </summary>
+	public delegate void SubItemEndEditingEventHandler(object sender, SubItemEndEditingEventArgs e);
+
+
+	///	<summary>
+	///	Inherited ListView to allow in-place editing of subitems
+	///	</summary>
+	public class ListViewEx	: System.Windows.Forms.ListView
+	{
+		#region Interop structs, imports and constants
+		/// <summary>
+		/// MessageHeader for WM_NOTIFY
+		/// </summary>
+		private struct NMHDR 
+		{ 
+#pragma warning disable
+			public IntPtr hwndFrom; 
+			public Int32  idFrom; 
+			public Int32  code;
+#pragma warning restore
+        }
+
+
+		[DllImport("user32.dll")]
+		private	static extern IntPtr SendMessage(IntPtr hWnd, int msg,	IntPtr wPar, IntPtr	lPar);
+		[DllImport("user32.dll", CharSet=CharSet.Ansi)]
+		private	static extern IntPtr SendMessage(IntPtr	hWnd, int msg, int len,	ref	int	[] order);
+
+		// ListView messages
+		private const int LVM_FIRST					= 0x1000;
+		private const int LVM_GETCOLUMNORDERARRAY	= (LVM_FIRST + 59);
+
+		// Windows Messages that will abort editing
+		private	const int WM_HSCROLL = 0x114;
+		private	const int WM_VSCROLL = 0x115;
+		private const int WM_SIZE	 = 0x05;
+		private const int WM_NOTIFY	 = 0x4E;
+
+		private const int HDN_FIRST = -300;
+		private const int HDN_BEGINDRAG = (HDN_FIRST-10);
+		private const int HDN_ITEMCHANGINGA = (HDN_FIRST-0);
+		private const int HDN_ITEMCHANGINGW = (HDN_FIRST-20);
+		#endregion
+
+		///	<summary>
+		///	Required designer variable.
+		///	</summary>
+		private	System.ComponentModel.Container	components = null;
+
+		public event SubItemEventHandler SubItemClicked;
+		public event SubItemEventHandler SubItemBeginEditing;
+		public event SubItemEndEditingEventHandler SubItemEndEditing;
+
+		public ListViewEx()
+		{
+			// This	call is	required by	the	Windows.Forms Form Designer.
+			InitializeComponent();
+
+			base.FullRowSelect = true;
+			base.View = View.Details;
+			base.AllowColumnReorder = true;
+		}
+
+		///	<summary>
+		///	Clean up any resources being used.
+		///	</summary>
+		protected override void	Dispose( bool disposing	)
+		{
+			if(	disposing )
+			{
+				if(	components != null )
+					components.Dispose();
+			}
+			base.Dispose( disposing	);
+		}
+
+		#region Component	Designer generated code
+		///	<summary>
+		///	Required method	for	Designer support - do not modify 
+		///	the	contents of	this method	with the code editor.
+		///	</summary>
+		private	void InitializeComponent()
+		{
+			components = new System.ComponentModel.Container();
+		}
+	  #endregion
+
+		private bool _doubleClickActivation = false;
+		/// <summary>
+		/// Is a double click required to start editing a cell?
+		/// </summary>
+		public bool DoubleClickActivation
+		{
+			get {  return _doubleClickActivation; }
+			set { _doubleClickActivation = value; }    
+		}
+
+
+		/// <summary>
+		/// Retrieve the order in which columns appear
+		/// </summary>
+		/// <returns>Current display order of column indices</returns>
+		public int[] GetColumnOrder()
+		{
+			IntPtr lPar	= Marshal.AllocHGlobal(Marshal.SizeOf(typeof(int)) * Columns.Count);
+
+			IntPtr res = SendMessage(Handle, LVM_GETCOLUMNORDERARRAY, new IntPtr(Columns.Count), lPar);
+			if (res.ToInt32() == 0)	// Something went wrong
+			{
+				Marshal.FreeHGlobal(lPar);
+				return null;
+			}
+
+			int	[] order = new int[Columns.Count];
+			Marshal.Copy(lPar, order, 0, Columns.Count);
+
+			Marshal.FreeHGlobal(lPar);
+
+			return order;
+		}
+
+
+		/// <summary>
+		/// Find ListViewItem and SubItem Index at position (x,y)
+		/// </summary>
+		/// <param name="x">relative to ListView</param>
+		/// <param name="y">relative to ListView</param>
+		/// <param name="item">Item at position (x,y)</param>
+		/// <returns>SubItem index</returns>
+		public int GetSubItemAt(int x, int y, out ListViewItem item)
+		{
+			item = this.GetItemAt(x, y);
+		
+			if (item !=	null)
+			{
+				int[] order = GetColumnOrder();
+				Rectangle lviBounds;
+				int	subItemX;
+
+				lviBounds =	item.GetBounds(ItemBoundsPortion.Entire);
+				subItemX = lviBounds.Left;
+				for (int i=0; i<order.Length; i++)
+				{
+					ColumnHeader h = this.Columns[order[i]];
+					if (x <	subItemX+h.Width)
+					{
+						return h.Index;
+					}
+					subItemX += h.Width;
+				}
+			}
+			
+			return -1;
+		}
+
+
+		/// <summary>
+		/// Get bounds for a SubItem
+		/// </summary>
+		/// <param name="Item">Target ListViewItem</param>
+		/// <param name="SubItem">Target SubItem index</param>
+		/// <returns>Bounds of SubItem (relative to ListView)</returns>
+		public Rectangle GetSubItemBounds(ListViewItem Item, int SubItem)
+		{
+			int[] order = GetColumnOrder();
+
+			Rectangle subItemRect = Rectangle.Empty;
+			if (SubItem >= order.Length)
+				throw new IndexOutOfRangeException("SubItem "+SubItem+" out of range");
+
+			if (Item == null)
+				throw new ArgumentNullException("Item");
+			
+			Rectangle lviBounds = Item.GetBounds(ItemBoundsPortion.Entire);
+			int	subItemX = lviBounds.Left;
+
+			ColumnHeader col;
+			int i;
+			for (i=0; i<order.Length; i++)
+			{
+				col = this.Columns[order[i]];
+				if (col.Index == SubItem)
+					break;
+				subItemX += col.Width;
+			} 
+			subItemRect	= new Rectangle(subItemX, lviBounds.Top, this.Columns[order[i]].Width, lviBounds.Height);
+			return subItemRect;
+		}
+
+
+		protected override void	WndProc(ref	Message	msg)
+		{
+			switch (msg.Msg)
+			{
+				// Look	for	WM_VSCROLL,WM_HSCROLL or WM_SIZE messages.
+				case WM_VSCROLL:
+				case WM_HSCROLL:
+				case WM_SIZE:
+					EndEditing(false);
+					break;
+				case WM_NOTIFY:
+					// Look for WM_NOTIFY of events that might also change the
+					// editor's position/size: Column reordering or resizing
+					NMHDR h = (NMHDR)Marshal.PtrToStructure(msg.LParam, typeof(NMHDR));
+					if (h.code == HDN_BEGINDRAG ||
+						h.code == HDN_ITEMCHANGINGA ||
+						h.code == HDN_ITEMCHANGINGW)
+						EndEditing(false);
+					break;
+			}
+
+			base.WndProc(ref msg);
+		}
+
+
+		#region Initialize editing depending of DoubleClickActivation property
+		protected override void OnMouseUp(System.Windows.Forms.MouseEventArgs e)
+		{
+			base.OnMouseUp(e);
+
+			if (DoubleClickActivation)
+			{
+				return;
+			} 
+
+			EditSubitemAt(new Point(e.X, e.Y));
+		}
+		
+		protected override void OnDoubleClick(EventArgs e)
+		{
+			base.OnDoubleClick (e);
+
+			if (!DoubleClickActivation)
+			{
+				return;
+			} 
+
+			Point pt = this.PointToClient(Cursor.Position);
+		
+			EditSubitemAt(pt);
+		}
+
+		///<summary>
+		/// Fire SubItemClicked
+		///</summary>
+		///<param name="p">Point of click/doubleclick</param>
+		private void EditSubitemAt(Point p)
+		{
+			ListViewItem item;
+			int idx = GetSubItemAt(p.X, p.Y, out item);
+			if (idx >= 0)
+			{
+				OnSubItemClicked(new SubItemEventArgs(item, idx));
+			}
+		}
+
+		#endregion
+
+		#region In-place editing functions
+		// The control performing the actual editing
+		private Control _editingControl;
+		// The LVI being edited
+		private ListViewItem _editItem;
+		// The SubItem being edited
+		private int _editSubItem;
+
+		protected void OnSubItemBeginEditing(SubItemEventArgs e)
+		{
+			if (SubItemBeginEditing != null) SubItemBeginEditing(this, e);
+		}
+
+		protected void OnSubItemEndEditing(SubItemEndEditingEventArgs e)
+		{
+			if (SubItemEndEditing != null) SubItemEndEditing(this, e);
+		}
+
+		protected void OnSubItemClicked(SubItemEventArgs e)
+		{
+			if (SubItemClicked != null) SubItemClicked(this, e);
+		}
+
+
+		/// <summary>
+		/// Begin in-place editing of given cell
+		/// </summary>
+		/// <param name="c">Control used as cell editor</param>
+		/// <param name="Item">ListViewItem to edit</param>
+		/// <param name="SubItem">SubItem index to edit</param>
+		public void StartEditing(Control c, ListViewItem Item, int SubItem)
+		{
+			OnSubItemBeginEditing(new SubItemEventArgs(Item, SubItem));
+
+			Rectangle rcSubItem = GetSubItemBounds(Item, SubItem);
+
+			if (rcSubItem.X < 0)
+			{
+				// Left edge of SubItem not visible - adjust rectangle position and width
+				rcSubItem.Width += rcSubItem.X;
+				rcSubItem.X=0;
+			}
+			if (rcSubItem.X+rcSubItem.Width > this.Width)
+			{
+				// Right edge of SubItem not visible - adjust rectangle width
+				rcSubItem.Width = this.Width-rcSubItem.Left;
+			}
+
+			// Subitem bounds are relative to the location of the ListView!
+			rcSubItem.Offset(Left, Top);
+
+			// In case the editing control and the listview are on different parents,
+			// account for different origins
+			Point origin = new Point(0,0);
+			Point lvOrigin  = this.Parent.PointToScreen(origin);
+			Point ctlOrigin  = c.Parent.PointToScreen(origin);
+
+			rcSubItem.Offset(lvOrigin.X-ctlOrigin.X, lvOrigin.Y-ctlOrigin.Y);
+
+			// Position and show editor
+			c.Bounds = rcSubItem;
+			c.Text = Item.SubItems[SubItem].Text;
+			c.Visible = true;
+			c.BringToFront();
+			c.Focus();
+
+			_editingControl = c;
+			_editingControl.Leave += new EventHandler(_editControl_Leave);
+			_editingControl.KeyPress += new KeyPressEventHandler(_editControl_KeyPress);
+
+			_editItem = Item;
+			_editSubItem = SubItem;
+		}
+
+
+		private void _editControl_Leave(object sender, EventArgs e)
+		{
+			// cell editor losing focus
+			EndEditing(true);
+		}
+
+		private void _editControl_KeyPress(object sender, System.Windows.Forms.KeyPressEventArgs e)
+		{
+			switch (e.KeyChar)
+			{
+				case (char)(int)Keys.Escape:
+				{
+					EndEditing(false);
+					break;
+				}
+
+				case (char)(int)Keys.Enter:
+				{  
+					EndEditing(true);
+					break;
+				}
+			}
+		}
+
+		/// <summary>
+		/// Accept or discard current value of cell editor control
+		/// </summary>
+		/// <param name="AcceptChanges">Use the _editingControl's Text as new SubItem text or discard changes?</param>
+		public void EndEditing(bool AcceptChanges)
+		{
+			if (_editingControl == null)
+				return;
+
+			SubItemEndEditingEventArgs e = new SubItemEndEditingEventArgs(
+				_editItem,		// The item being edited
+				_editSubItem,	// The subitem index being edited
+				AcceptChanges ?
+					_editingControl.Text :	// Use editControl text if changes are accepted
+					_editItem.SubItems[_editSubItem].Text,	// or the original subitem's text, if changes are discarded
+				!AcceptChanges	// Cancel?
+			);
+
+			OnSubItemEndEditing(e);
+
+			_editItem.SubItems[_editSubItem].Text = e.DisplayText;
+
+			_editingControl.Leave -= new EventHandler(_editControl_Leave);
+			_editingControl.KeyPress -= new KeyPressEventHandler(_editControl_KeyPress);
+
+			_editingControl.Visible = false;
+
+			_editingControl = null;
+			_editItem = null;
+			_editSubItem = -1;
+		}
+		#endregion
+	}
+
+	
+	/// <summary>
+	/// Event Args for SubItemClicked event
+	/// </summary>
+	public class SubItemEventArgs : EventArgs
+	{
+        int subItem = -1;     /// Sub-item index
+        ListViewItem item = null;
+
+        public int SubItem { get { return subItem; } }
+        public ListViewItem Item { get { return item; } }
+
+        public SubItemEventArgs(ListViewItem item, int subItem)
+		{
+			this.subItem = subItem;
+			this.item = item;
+		}
+	}
+
+
+	/// <summary>
+	/// Event Args for SubItemEndEditingClicked event
+	/// </summary>
+	public class SubItemEndEditingEventArgs : SubItemEventArgs
+	{
+		string displayText = string.Empty;
+		bool cancel = true;
+
+		public SubItemEndEditingEventArgs(ListViewItem item, int subItem, string displayText, bool cancel) :
+			base(item, subItem)
+		{
+			this.displayText = displayText;
+			this.cancel = cancel;
+		}
+		public string DisplayText
+		{
+			get { return displayText; }
+			set { displayText = value; }
+		}
+		public bool Cancel
+		{
+			get { return cancel; }
+			set { cancel = value; }
+		}
+	}
+}

MonitoringDB/Forms/ListViewEx.resx

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<root>
+	<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+		<xsd:element name="root" msdata:IsDataSet="true">
+			<xsd:complexType>
+				<xsd:choice maxOccurs="unbounded">
+					<xsd:element name="data">
+						<xsd:complexType>
+							<xsd:sequence>
+								<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+								<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+							</xsd:sequence>
+							<xsd:attribute name="name" type="xsd:string" />
+							<xsd:attribute name="type" type="xsd:string" />
+							<xsd:attribute name="mimetype" type="xsd:string" />
+						</xsd:complexType>
+					</xsd:element>
+					<xsd:element name="resheader">
+						<xsd:complexType>
+							<xsd:sequence>
+								<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+							</xsd:sequence>
+							<xsd:attribute name="name" type="xsd:string" use="required" />
+						</xsd:complexType>
+					</xsd:element>
+				</xsd:choice>
+			</xsd:complexType>
+		</xsd:element>
+	</xsd:schema>
+	<resheader name="ResMimeType">
+		<value>text/microsoft-resx</value>
+	</resheader>
+	<resheader name="Version">
+		<value>1.0.0.0</value>
+	</resheader>
+	<resheader name="Reader">
+		<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=1.0.3102.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+	</resheader>
+	<resheader name="Writer">
+		<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=1.0.3102.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+	</resheader>
+</root>

MonitoringDB/Forms/ModelessForm.Designer.cs

@@ -0,0 +1,64 @@
+namespace MonitoringDB.Forms
+{
+    partial class ModelessForm
+    {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            this.label1 = new System.Windows.Forms.Label();
+            this.SuspendLayout();
+            // 
+            // label1
+            // 
+            this.label1.AutoSize = true;
+            this.label1.Location = new System.Drawing.Point(47, 29);
+            this.label1.Name = "label1";
+            this.label1.Size = new System.Drawing.Size(35, 13);
+            this.label1.TabIndex = 0;
+            this.label1.Text = "label1";
+            // 
+            // ModelessForm
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(191, 56);
+            this.Controls.Add(this.label1);
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
+            this.Name = "ModelessForm";
+            this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide;
+            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
+            this.Text = "ModelessForm";
+            this.Load += new System.EventHandler(this.ModelessForm_Load);
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.Label label1;
+    }
+}

MonitoringDB/Forms/ModelessForm.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace MonitoringDB.Forms
+{
+    public partial class ModelessForm : Form
+    {
+        /// <summary>
+        /// Called from the state machine when an operation forces a modeless dialog close.
+        /// </summary>
+        public static void CloseForm()
+        {
+            if (CloseFormHandler == null) return;
+            try { CloseFormHandler(null, null); }
+            catch (Exception) { }
+        }
+        public static event EventHandler<EventArgs> CloseFormHandler;
+
+        void OnCloseForm(object sender, EventArgs args)
+        {
+            DialogResult = DialogResult.Cancel;
+            Close();
+        }
+
+
+        public string Title;
+        public string Message;
+        public Color BackgroundColor;
+        public Color TextColor;
+        public Font TextFont;
+        public string FontFamily;
+        public int FontSize;
+        public FontStyle FontStyle;
+
+
+        /// <summary>
+        /// Constructor to be used by the application
+        /// </summary>
+        /// <param name="title">Window title</param>
+        /// <param name="message">Displayed message</param>
+        public ModelessForm()
+        {
+            InitializeComponent();
+            ControlBox = false;
+
+            CloseFormHandler += delegate(object sender, EventArgs args)
+            {
+                if (InvokeRequired) { Invoke(new EventHandler<EventArgs>(OnCloseForm), sender, args); }
+                else OnCloseForm(sender, args);
+            };
+        }
+
+        private void ModelessForm_Load(object sender, EventArgs e)
+        {
+            if (Title != null) Text = Title;
+            if (Message != null) label1.Text = Message;
+            if (BackgroundColor != null) BackColor = BackgroundColor;
+            if (TextColor != null) ForeColor = TextColor;
+            if (FontFamily != null) label1.Font = new Font(FontFamily, FontSize, FontStyle);
+
+            float textWidth = Graphics.FromImage(new Bitmap(1, 1)).MeasureString(label1.Text, label1.Font).Width;
+            float textHeight = Graphics.FromImage(new Bitmap(1, 1)).MeasureString(label1.Text, label1.Font).Height;
+            Width = (int)textWidth + 120;		/// Form width calculated from the text width
+            Height += (int)textHeight;		    /// Form height calculated from the text height
+        }
+    }
+}

MonitoringDB/Forms/ResultsConfigDlg.cs

@@ -0,0 +1,299 @@
+///
+/// Copyright (c) 2016 Sensus Metering Systems
+///
+using System;
+using System.Collections.Generic;
+using System.Windows.Forms;
+using log4net;
+using MonitoringDB.Entities;
+using MonitoringDB.Resources;
+
+namespace MonitoringDB.Forms
+{
+	public partial class ResultsConfigDlg : Form
+	{
+        /// <summary>
+        /// ListViewEx columns
+        /// </summary>
+        enum Column
+        {
+            Item,
+            Caption,
+            Format,
+            Precision,
+            Width,
+            Count,
+        }
+        Control[] editors;
+        
+
+        public IList<ItemSpec> AvailableItems;
+        public IList<ItemSpec> SelectedItems;
+
+
+		public bool Compound;			/// false = single meter items, true = combined meter items
+
+		public ResultsConfigDlg()
+		{
+			InitializeComponent();
+		}
+
+		void Localize()
+		{
+			Text = Strings.Configuration;
+			availableResultsLabel.Text = Strings.Available_results;
+			selectedResultsLabel.Text = Strings.Selected_results;
+			addButton.Text = Strings.Add;
+			removeButton.Text = Strings.Remove;
+			removeAllButton.Text = Strings.Remove_all;
+			okButton.Text = Strings.OkBtnText;
+			cancelButton.Text = Strings.CancelBtnText;
+            upButton.Text = Strings.UpBtnText;
+            downButton.Text = Strings.DownBtnText;
+		}
+
+		void ResultsConfig_Load(object sender, EventArgs e)
+		{
+			Localize();
+
+            /// Add columns to ListViewEx
+            selectedResultsListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Item, Width = 120 });
+            selectedResultsListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Caption });
+            selectedResultsListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Format });
+            selectedResultsListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Precision });
+            selectedResultsListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Width });
+
+            editors = new Control[]
+                {
+                    null,
+                    new TextBox(),
+                    new TextBox(),
+                    new TextBox(),
+                    new TextBox(),
+                };
+            foreach (var edi in editors)
+            {
+                if (edi != null)
+                {
+                    edi.Visible = false;
+                    Controls.Add(edi);
+                }
+            }
+
+            selectedResultsListViewEx.SubItemClicked += new SubItemEventHandler(selectedResultsListViewEx_SubItemClicked);
+            selectedResultsListViewEx.SubItemEndEditing += new SubItemEndEditingEventHandler(selectedResultsListViewEx_SubItemEndEditing);
+			
+            RedrawAvailable();
+			RedrawSelected();
+		}
+
+        void selectedResultsListViewEx_SubItemClicked(object sender, SubItemEventArgs e)
+        {
+            if ((e.SubItem > 0) && (e.SubItem < (int)Column.Count))
+            {
+                selectedResultsListViewEx.StartEditing(editors[e.SubItem], e.Item, e.SubItem);
+            }
+        }
+
+        void selectedResultsListViewEx_SubItemEndEditing(object sender, SubItemEndEditingEventArgs e)
+        {
+            ListViewItem lvi = e.Item;
+            ItemSpec item = lvi.Tag as ItemSpec;
+
+            switch ((Column)e.SubItem)
+            {
+                case Column.Caption:    item.Caption = e.DisplayText;   return;
+                case Column.Format:     item.Format = e.DisplayText;    return;
+                case Column.Precision:  item.Precision = e.DisplayText; return;
+                                    
+                case Column.Width:
+                    {
+                        int width;
+                        if (Int32.TryParse(editors[e.SubItem].Text, out width) && width >= 0)
+                        {
+                            item.Width = width;
+                            return;     /// OK
+                        }
+                        break;          /// Error
+                    }
+                default:
+                    return;             /// OK
+            }
+
+            e.DisplayText = e.Item.SubItems[e.SubItem].Text;
+            e.Cancel = true;
+            return;
+        }
+
+		/// <summary>
+		/// Redraw selected items (right hand side)
+		/// </summary>
+		void RedrawAvailable()
+		{
+			availableResultsListBox.Items.Clear();
+            AvailableItems = new List<ItemSpec>();
+            foreach (var item in ItemSpec.AllItems)
+			{
+				AvailableItems.Add(item);
+				availableResultsListBox.Items.Add(item.Name);
+			}
+		}
+
+		/// <summary>
+		/// Redraw selected items (right hand side)
+		/// </summary>
+		void RedrawSelected()
+		{
+			selectedResultsListViewEx.Items.Clear();
+			foreach (var item in SelectedItems)
+			{
+                ListViewItem lvi = new ListViewItem(item.Name);                                     /// Item
+                lvi.Tag = item;
+                lvi.SubItems.Add(item.Caption);                                                     /// Header
+                lvi.SubItems.Add(item.Format);                                                      /// Format
+                lvi.SubItems.Add(item.Precision);                                                   /// Precision
+                lvi.SubItems.Add(item.Width.ToString());                                            /// Width
+
+				selectedResultsListViewEx.Items.Add(lvi);
+			}
+		}
+
+        void UpdateSelectedFromView()
+        {
+        }
+
+		void availableResultsListBox_DoubleClick(object sender, EventArgs e)
+		{
+			/// Double click works when just one item is selected
+			if (availableResultsListBox.SelectedIndices.Count == 1)
+			{
+				var oriItem = AvailableItems[availableResultsListBox.SelectedIndices[0]];
+                SelectedItems.Add(oriItem.Clone());
+				RedrawAvailable();
+				RedrawSelected();
+
+                /// Select the last item
+                selectedResultsListViewEx.Focus();
+                selectedResultsListViewEx.Items[SelectedItems.Count - 1].Selected = true;
+                selectedResultsListViewEx.Items[SelectedItems.Count - 1].EnsureVisible();
+            }
+		}
+
+		void addButton_Click(object sender, EventArgs e)
+		{
+			/// Append at the end, this code supports multiple selected items,
+			/// although ListBox control settings may limit the max.number of selected items to one.
+
+			for (int i = availableResultsListBox.SelectedIndices.Count - 1; i >= 0; i--)
+			{
+                var oriItem = AvailableItems[availableResultsListBox.SelectedIndices[i]];
+                SelectedItems.Add(oriItem.Clone());
+			}
+			RedrawAvailable();
+			RedrawSelected();
+
+            /// Select the last item
+            selectedResultsListViewEx.Focus();
+            selectedResultsListViewEx.Items[SelectedItems.Count - 1].Selected = true;
+            selectedResultsListViewEx.Items[SelectedItems.Count - 1].EnsureVisible();
+        }
+
+		private void selectedResultsListBox_DoubleClick(object sender, EventArgs e)
+		{
+			/// Double click works when just one item is selected
+
+			if (selectedResultsListViewEx.SelectedIndices.Count == 1)
+			{
+				SelectedItems.RemoveAt(selectedResultsListViewEx.SelectedIndices[0]);
+				RedrawAvailable();
+				RedrawSelected();
+			}
+		}
+
+		void removeButton_Click(object sender, EventArgs e)
+		{
+			/// Remove from the list (the last selected item first so that the indexes are not affected)
+
+			for (int i = selectedResultsListViewEx.SelectedIndices.Count - 1; i >= 0; i--)
+			{
+				SelectedItems.RemoveAt(selectedResultsListViewEx.SelectedIndices[i]);
+			}
+			RedrawAvailable();
+			RedrawSelected();
+		}
+
+		void removeAllButton_Click(object sender, EventArgs e)
+		{
+			/// Remove all items from 'Selected' list
+
+			SelectedItems.Clear();
+			RedrawAvailable();
+			RedrawSelected();
+		}
+
+		void okButton_Click(object sender, EventArgs e)
+		{
+            DialogResult = DialogResult.OK;
+			Close();
+		}
+
+        private void ResultsConfigDlg_KeyPress(object sender, KeyPressEventArgs e)
+        {
+            e.Handled = true;
+        }
+
+        private void upButton_Click(object sender, EventArgs e)
+        {
+            if (selectedResultsListViewEx.SelectedIndices.Count != 1) return;
+
+            int selIdx = selectedResultsListViewEx.SelectedIndices[0];
+            if (selIdx == 0)
+            {
+                /// Cannot move up
+                selectedResultsListViewEx.Focus();
+                selectedResultsListViewEx.Items[0].Selected = true;
+                return;
+            }
+
+            ItemSpec tmp = SelectedItems[selIdx - 1];
+            SelectedItems[selIdx - 1] = SelectedItems[selIdx];
+            SelectedItems[selIdx] = tmp;
+
+            RedrawSelected();
+
+            selectedResultsListViewEx.Focus();
+            selectedResultsListViewEx.Items[selIdx - 1].Selected = true;
+            selectedResultsListViewEx.Items[selIdx - 1].EnsureVisible();
+        }
+
+        private void downButton_Click(object sender, EventArgs e)
+        {
+            if (selectedResultsListViewEx.SelectedIndices.Count != 1) return;
+
+            int selIdx = selectedResultsListViewEx.SelectedIndices[0];
+            if (selIdx == SelectedItems.Count - 1)
+            {
+                /// Cannot move down
+                selectedResultsListViewEx.Focus();
+                selectedResultsListViewEx.Items[SelectedItems.Count - 1].Selected = true;
+                return;
+            }
+
+            ItemSpec tmp = SelectedItems[selIdx + 1];
+            SelectedItems[selIdx + 1] = SelectedItems[selIdx];
+            SelectedItems[selIdx] = tmp;
+            
+            RedrawSelected();
+
+            selectedResultsListViewEx.Focus();
+            selectedResultsListViewEx.Items[selIdx + 1].Selected = true;
+            selectedResultsListViewEx.Items[selIdx + 1].EnsureVisible();
+        }
+
+        private void cancelButton_Click(object sender, EventArgs e)
+        {
+            DialogResult = DialogResult.Cancel;
+            Close();
+        }
+	}
+}

MonitoringDB/Forms/ResultsConfigDlg.designer.cs

@@ -0,0 +1,201 @@
+///
+/// Copyright (c) 2016 Sensus Metering Systems
+///
+namespace MonitoringDB.Forms
+{
+	partial class ResultsConfigDlg
+	{
+		/// <summary>
+		/// Required designer variable.
+		/// </summary>
+		private System.ComponentModel.IContainer components = null;
+
+		/// <summary>
+		/// Clean up any resources being used.
+		/// </summary>
+		/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+		protected override void Dispose(bool disposing)
+		{
+			if (disposing && (components != null))
+			{
+				components.Dispose();
+			}
+			base.Dispose(disposing);
+		}
+
+		#region Windows Form Designer generated code
+
+		/// <summary>
+		/// Required method for Designer support - do not modify
+		/// the contents of this method with the code editor.
+		/// </summary>
+		private void InitializeComponent()
+		{
+            this.okButton = new System.Windows.Forms.Button();
+            this.cancelButton = new System.Windows.Forms.Button();
+            this.availableResultsListBox = new System.Windows.Forms.ListBox();
+            this.availableResultsLabel = new System.Windows.Forms.Label();
+            this.selectedResultsLabel = new System.Windows.Forms.Label();
+            this.removeAllButton = new System.Windows.Forms.Button();
+            this.removeButton = new System.Windows.Forms.Button();
+            this.addButton = new System.Windows.Forms.Button();
+            this.selectedResultsListViewEx = new MonitoringDB.Forms.ListViewEx();
+            this.upButton = new System.Windows.Forms.Button();
+            this.downButton = new System.Windows.Forms.Button();
+            this.SuspendLayout();
+            // 
+            // okButton
+            // 
+            this.okButton.Location = new System.Drawing.Point(344, 401);
+            this.okButton.Name = "okButton";
+            this.okButton.Size = new System.Drawing.Size(104, 30);
+            this.okButton.TabIndex = 4;
+            this.okButton.Text = "OK";
+            this.okButton.UseVisualStyleBackColor = true;
+            this.okButton.Click += new System.EventHandler(this.okButton_Click);
+            // 
+            // cancelButton
+            // 
+            this.cancelButton.DialogResult = System.Windows.Forms.DialogResult.Cancel;
+            this.cancelButton.Location = new System.Drawing.Point(465, 401);
+            this.cancelButton.Name = "cancelButton";
+            this.cancelButton.Size = new System.Drawing.Size(104, 30);
+            this.cancelButton.TabIndex = 5;
+            this.cancelButton.Text = "Cancel";
+            this.cancelButton.UseVisualStyleBackColor = true;
+            this.cancelButton.Click += new System.EventHandler(this.cancelButton_Click);
+            // 
+            // availableResultsListBox
+            // 
+            this.availableResultsListBox.FormattingEnabled = true;
+            this.availableResultsListBox.Location = new System.Drawing.Point(12, 31);
+            this.availableResultsListBox.Name = "availableResultsListBox";
+            this.availableResultsListBox.Size = new System.Drawing.Size(162, 355);
+            this.availableResultsListBox.TabIndex = 6;
+            this.availableResultsListBox.DoubleClick += new System.EventHandler(this.availableResultsListBox_DoubleClick);
+            // 
+            // availableResultsLabel
+            // 
+            this.availableResultsLabel.AutoSize = true;
+            this.availableResultsLabel.Location = new System.Drawing.Point(12, 9);
+            this.availableResultsLabel.Name = "availableResultsLabel";
+            this.availableResultsLabel.Size = new System.Drawing.Size(86, 13);
+            this.availableResultsLabel.TabIndex = 8;
+            this.availableResultsLabel.Text = "Available results:";
+            // 
+            // selectedResultsLabel
+            // 
+            this.selectedResultsLabel.AutoSize = true;
+            this.selectedResultsLabel.Location = new System.Drawing.Point(284, 9);
+            this.selectedResultsLabel.Name = "selectedResultsLabel";
+            this.selectedResultsLabel.Size = new System.Drawing.Size(85, 13);
+            this.selectedResultsLabel.TabIndex = 9;
+            this.selectedResultsLabel.Text = "Selected results:";
+            // 
+            // removeAllButton
+            // 
+            this.removeAllButton.Location = new System.Drawing.Point(184, 144);
+            this.removeAllButton.Name = "removeAllButton";
+            this.removeAllButton.Size = new System.Drawing.Size(94, 30);
+            this.removeAllButton.TabIndex = 46;
+            this.removeAllButton.Text = "<< R&emove all";
+            this.removeAllButton.UseVisualStyleBackColor = true;
+            this.removeAllButton.Click += new System.EventHandler(this.removeAllButton_Click);
+            // 
+            // removeButton
+            // 
+            this.removeButton.Location = new System.Drawing.Point(184, 109);
+            this.removeButton.Name = "removeButton";
+            this.removeButton.Size = new System.Drawing.Size(93, 30);
+            this.removeButton.TabIndex = 45;
+            this.removeButton.Text = "< &Remove";
+            this.removeButton.UseVisualStyleBackColor = true;
+            this.removeButton.Click += new System.EventHandler(this.removeButton_Click);
+            // 
+            // addButton
+            // 
+            this.addButton.Location = new System.Drawing.Point(184, 74);
+            this.addButton.Name = "addButton";
+            this.addButton.Size = new System.Drawing.Size(93, 30);
+            this.addButton.TabIndex = 44;
+            this.addButton.Text = "&Add >";
+            this.addButton.UseVisualStyleBackColor = true;
+            this.addButton.Click += new System.EventHandler(this.addButton_Click);
+            // 
+            // selectedResultsListViewEx
+            // 
+            this.selectedResultsListViewEx.AllowColumnReorder = true;
+            this.selectedResultsListViewEx.DoubleClickActivation = false;
+            this.selectedResultsListViewEx.FullRowSelect = true;
+            this.selectedResultsListViewEx.Location = new System.Drawing.Point(287, 31);
+            this.selectedResultsListViewEx.Name = "selectedResultsListViewEx";
+            this.selectedResultsListViewEx.Size = new System.Drawing.Size(594, 355);
+            this.selectedResultsListViewEx.TabIndex = 47;
+            this.selectedResultsListViewEx.UseCompatibleStateImageBehavior = false;
+            this.selectedResultsListViewEx.View = System.Windows.Forms.View.Details;
+            this.selectedResultsListViewEx.SubItemClicked += new MonitoringDB.Forms.SubItemEventHandler(this.selectedResultsListViewEx_SubItemClicked);
+            this.selectedResultsListViewEx.SubItemEndEditing += new MonitoringDB.Forms.SubItemEndEditingEventHandler(this.selectedResultsListViewEx_SubItemEndEditing);
+            // 
+            // upButton
+            // 
+            this.upButton.Location = new System.Drawing.Point(184, 236);
+            this.upButton.Name = "upButton";
+            this.upButton.Size = new System.Drawing.Size(93, 30);
+            this.upButton.TabIndex = 48;
+            this.upButton.Text = "Up";
+            this.upButton.UseVisualStyleBackColor = true;
+            this.upButton.Click += new System.EventHandler(this.upButton_Click);
+            // 
+            // downButton
+            // 
+            this.downButton.Location = new System.Drawing.Point(184, 272);
+            this.downButton.Name = "downButton";
+            this.downButton.Size = new System.Drawing.Size(93, 30);
+            this.downButton.TabIndex = 49;
+            this.downButton.Text = "Down";
+            this.downButton.UseVisualStyleBackColor = true;
+            this.downButton.Click += new System.EventHandler(this.downButton_Click);
+            // 
+            // ResultsConfigDlg
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(893, 445);
+            this.Controls.Add(this.downButton);
+            this.Controls.Add(this.upButton);
+            this.Controls.Add(this.selectedResultsListViewEx);
+            this.Controls.Add(this.removeAllButton);
+            this.Controls.Add(this.removeButton);
+            this.Controls.Add(this.addButton);
+            this.Controls.Add(this.selectedResultsLabel);
+            this.Controls.Add(this.availableResultsLabel);
+            this.Controls.Add(this.availableResultsListBox);
+            this.Controls.Add(this.cancelButton);
+            this.Controls.Add(this.okButton);
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
+            this.Name = "ResultsConfigDlg";
+            this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide;
+            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
+            this.Text = "ResultsConfig";
+            this.Load += new System.EventHandler(this.ResultsConfig_Load);
+            this.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.ResultsConfigDlg_KeyPress);
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+		}
+
+		#endregion
+
+		private System.Windows.Forms.Button okButton;
+		private System.Windows.Forms.Button cancelButton;
+        private System.Windows.Forms.ListBox availableResultsListBox;
+		private System.Windows.Forms.Label availableResultsLabel;
+		private System.Windows.Forms.Label selectedResultsLabel;
+		private System.Windows.Forms.Button removeAllButton;
+		private System.Windows.Forms.Button removeButton;
+		private System.Windows.Forms.Button addButton;
+        private ListViewEx selectedResultsListViewEx;
+        private System.Windows.Forms.Button upButton;
+        private System.Windows.Forms.Button downButton;
+	}
+}

MonitoringDB/Forms/SettingsDlg.Designer.cs

@@ -0,0 +1,263 @@
+namespace MonitoringDB.Forms
+{
+	partial class SettingsDlg
+	{
+		/// <summary>
+		/// Required designer variable.
+		/// </summary>
+		private System.ComponentModel.IContainer components = null;
+
+		/// <summary>
+		/// Clean up any resources being used.
+		/// </summary>
+		/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+		protected override void Dispose(bool disposing)
+		{
+			if (disposing && (components != null))
+			{
+				components.Dispose();
+			}
+			base.Dispose(disposing);
+		}
+
+		#region Windows Form Designer generated code
+
+		/// <summary>
+		/// Required method for Designer support - do not modify
+		/// the contents of this method with the code editor.
+		/// </summary>
+		private void InitializeComponent()
+		{
+            this.groupBox1 = new System.Windows.Forms.GroupBox();
+            this.connectionStringTextBox = new System.Windows.Forms.TextBox();
+            this.groupBox2 = new System.Windows.Forms.GroupBox();
+            this.radioButton2 = new System.Windows.Forms.RadioButton();
+            this.radioButton1 = new System.Windows.Forms.RadioButton();
+            this.groupBox3 = new System.Windows.Forms.GroupBox();
+            this.workplaceNameTextBox = new System.Windows.Forms.TextBox();
+            this.saveButton = new System.Windows.Forms.Button();
+            this.cancelButton = new System.Windows.Forms.Button();
+            this.groupBox4 = new System.Windows.Forms.GroupBox();
+            this.extraBatteryLifetimeTextBox = new System.Windows.Forms.TextBox();
+            this.oracleGroupBox = new System.Windows.Forms.GroupBox();
+            this.checkPcbIsInOracleCheckBox = new System.Windows.Forms.CheckBox();
+            this.oracleBatteryCheckBox = new System.Windows.Forms.CheckBox();
+            this.groupBox5 = new System.Windows.Forms.GroupBox();
+            this.usersDBConnStringTextBox = new System.Windows.Forms.TextBox();
+            this.groupBox1.SuspendLayout();
+            this.groupBox2.SuspendLayout();
+            this.groupBox3.SuspendLayout();
+            this.groupBox4.SuspendLayout();
+            this.oracleGroupBox.SuspendLayout();
+            this.groupBox5.SuspendLayout();
+            this.SuspendLayout();
+            // 
+            // groupBox1
+            // 
+            this.groupBox1.Controls.Add(this.connectionStringTextBox);
+            this.groupBox1.Location = new System.Drawing.Point(12, 69);
+            this.groupBox1.Name = "groupBox1";
+            this.groupBox1.Size = new System.Drawing.Size(622, 50);
+            this.groupBox1.TabIndex = 1;
+            this.groupBox1.TabStop = false;
+            this.groupBox1.Text = "Connection string pre záznamy z výroby";
+            // 
+            // connectionStringTextBox
+            // 
+            this.connectionStringTextBox.Location = new System.Drawing.Point(17, 18);
+            this.connectionStringTextBox.Name = "connectionStringTextBox";
+            this.connectionStringTextBox.Size = new System.Drawing.Size(586, 20);
+            this.connectionStringTextBox.TabIndex = 0;
+            // 
+            // groupBox2
+            // 
+            this.groupBox2.Controls.Add(this.radioButton2);
+            this.groupBox2.Controls.Add(this.radioButton1);
+            this.groupBox2.Location = new System.Drawing.Point(12, 250);
+            this.groupBox2.Name = "groupBox2";
+            this.groupBox2.Size = new System.Drawing.Size(268, 70);
+            this.groupBox2.TabIndex = 4;
+            this.groupBox2.TabStop = false;
+            this.groupBox2.Text = "Režim činnosti";
+            // 
+            // radioButton2
+            // 
+            this.radioButton2.AutoSize = true;
+            this.radioButton2.Location = new System.Drawing.Point(101, 41);
+            this.radioButton2.Name = "radioButton2";
+            this.radioButton2.Size = new System.Drawing.Size(58, 17);
+            this.radioButton2.TabIndex = 1;
+            this.radioButton2.TabStop = true;
+            this.radioButton2.Text = "Výroba";
+            this.radioButton2.UseVisualStyleBackColor = true;
+            // 
+            // radioButton1
+            // 
+            this.radioButton1.AutoSize = true;
+            this.radioButton1.Location = new System.Drawing.Point(101, 20);
+            this.radioButton1.Name = "radioButton1";
+            this.radioButton1.Size = new System.Drawing.Size(46, 17);
+            this.radioButton1.TabIndex = 0;
+            this.radioButton1.TabStop = true;
+            this.radioButton1.Text = "Test";
+            this.radioButton1.UseVisualStyleBackColor = true;
+            // 
+            // groupBox3
+            // 
+            this.groupBox3.Controls.Add(this.workplaceNameTextBox);
+            this.groupBox3.Location = new System.Drawing.Point(12, 12);
+            this.groupBox3.Name = "groupBox3";
+            this.groupBox3.Size = new System.Drawing.Size(622, 50);
+            this.groupBox3.TabIndex = 0;
+            this.groupBox3.TabStop = false;
+            this.groupBox3.Text = "Meno pracoviska";
+            // 
+            // workplaceNameTextBox
+            // 
+            this.workplaceNameTextBox.Location = new System.Drawing.Point(17, 18);
+            this.workplaceNameTextBox.Name = "workplaceNameTextBox";
+            this.workplaceNameTextBox.Size = new System.Drawing.Size(586, 20);
+            this.workplaceNameTextBox.TabIndex = 0;
+            // 
+            // saveButton
+            // 
+            this.saveButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+            this.saveButton.Location = new System.Drawing.Point(348, 270);
+            this.saveButton.Name = "saveButton";
+            this.saveButton.Size = new System.Drawing.Size(104, 42);
+            this.saveButton.TabIndex = 6;
+            this.saveButton.Text = "Uložiť";
+            this.saveButton.UseVisualStyleBackColor = true;
+            this.saveButton.Click += new System.EventHandler(this.saveButton_Click);
+            // 
+            // cancelButton
+            // 
+            this.cancelButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+            this.cancelButton.Location = new System.Drawing.Point(488, 270);
+            this.cancelButton.Name = "cancelButton";
+            this.cancelButton.Size = new System.Drawing.Size(104, 42);
+            this.cancelButton.TabIndex = 7;
+            this.cancelButton.Text = "Zrušiť";
+            this.cancelButton.UseVisualStyleBackColor = true;
+            this.cancelButton.Click += new System.EventHandler(this.cancelButton_Click);
+            // 
+            // groupBox4
+            // 
+            this.groupBox4.Controls.Add(this.extraBatteryLifetimeTextBox);
+            this.groupBox4.Location = new System.Drawing.Point(12, 182);
+            this.groupBox4.Name = "groupBox4";
+            this.groupBox4.Size = new System.Drawing.Size(268, 62);
+            this.groupBox4.TabIndex = 3;
+            this.groupBox4.TabStop = false;
+            this.groupBox4.Text = "Predĺženie životnosti baterky v mesiacoch";
+            // 
+            // extraBatteryLifetimeTextBox
+            // 
+            this.extraBatteryLifetimeTextBox.Location = new System.Drawing.Point(17, 25);
+            this.extraBatteryLifetimeTextBox.Name = "extraBatteryLifetimeTextBox";
+            this.extraBatteryLifetimeTextBox.Size = new System.Drawing.Size(230, 20);
+            this.extraBatteryLifetimeTextBox.TabIndex = 0;
+            // 
+            // oracleGroupBox
+            // 
+            this.oracleGroupBox.Controls.Add(this.checkPcbIsInOracleCheckBox);
+            this.oracleGroupBox.Controls.Add(this.oracleBatteryCheckBox);
+            this.oracleGroupBox.Location = new System.Drawing.Point(297, 182);
+            this.oracleGroupBox.Name = "oracleGroupBox";
+            this.oracleGroupBox.Size = new System.Drawing.Size(337, 74);
+            this.oracleGroupBox.TabIndex = 5;
+            this.oracleGroupBox.TabStop = false;
+            this.oracleGroupBox.Text = "Oracle";
+            this.oracleGroupBox.Visible = false;
+            // 
+            // checkPcbIsInOracleCheckBox
+            // 
+            this.checkPcbIsInOracleCheckBox.AutoSize = true;
+            this.checkPcbIsInOracleCheckBox.Location = new System.Drawing.Point(18, 45);
+            this.checkPcbIsInOracleCheckBox.Name = "checkPcbIsInOracleCheckBox";
+            this.checkPcbIsInOracleCheckBox.Size = new System.Drawing.Size(213, 17);
+            this.checkPcbIsInOracleCheckBox.TabIndex = 0;
+            this.checkPcbIsInOracleCheckBox.Text = "Skontrolovať či PCB už bola overovaná";
+            this.checkPcbIsInOracleCheckBox.UseVisualStyleBackColor = true;
+            // 
+            // oracleBatteryCheckBox
+            // 
+            this.oracleBatteryCheckBox.AutoSize = true;
+            this.oracleBatteryCheckBox.Location = new System.Drawing.Point(18, 19);
+            this.oracleBatteryCheckBox.Name = "oracleBatteryCheckBox";
+            this.oracleBatteryCheckBox.Size = new System.Drawing.Size(193, 17);
+            this.oracleBatteryCheckBox.TabIndex = 0;
+            this.oracleBatteryCheckBox.Text = "Uložiť informácie o batérii do Oracle";
+            this.oracleBatteryCheckBox.UseVisualStyleBackColor = true;
+            // 
+            // groupBox5
+            // 
+            this.groupBox5.Controls.Add(this.usersDBConnStringTextBox);
+            this.groupBox5.Location = new System.Drawing.Point(12, 125);
+            this.groupBox5.Name = "groupBox5";
+            this.groupBox5.Size = new System.Drawing.Size(622, 50);
+            this.groupBox5.TabIndex = 2;
+            this.groupBox5.TabStop = false;
+            this.groupBox5.Text = "Connection string pre centrálnu databázu používateľov";
+            // 
+            // usersDBConnStringTextBox
+            // 
+            this.usersDBConnStringTextBox.Location = new System.Drawing.Point(17, 18);
+            this.usersDBConnStringTextBox.Name = "usersDBConnStringTextBox";
+            this.usersDBConnStringTextBox.Size = new System.Drawing.Size(586, 20);
+            this.usersDBConnStringTextBox.TabIndex = 0;
+            // 
+            // SettingsDlg
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(648, 333);
+            this.Controls.Add(this.groupBox5);
+            this.Controls.Add(this.oracleGroupBox);
+            this.Controls.Add(this.groupBox4);
+            this.Controls.Add(this.cancelButton);
+            this.Controls.Add(this.saveButton);
+            this.Controls.Add(this.groupBox3);
+            this.Controls.Add(this.groupBox2);
+            this.Controls.Add(this.groupBox1);
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
+            this.MaximizeBox = false;
+            this.Name = "SettingsDlg";
+            this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide;
+            this.Text = "SettingsDlg";
+            this.groupBox1.ResumeLayout(false);
+            this.groupBox1.PerformLayout();
+            this.groupBox2.ResumeLayout(false);
+            this.groupBox2.PerformLayout();
+            this.groupBox3.ResumeLayout(false);
+            this.groupBox3.PerformLayout();
+            this.groupBox4.ResumeLayout(false);
+            this.groupBox4.PerformLayout();
+            this.oracleGroupBox.ResumeLayout(false);
+            this.oracleGroupBox.PerformLayout();
+            this.groupBox5.ResumeLayout(false);
+            this.groupBox5.PerformLayout();
+            this.ResumeLayout(false);
+
+		}
+
+		#endregion
+
+		private System.Windows.Forms.GroupBox groupBox1;
+		private System.Windows.Forms.TextBox connectionStringTextBox;
+		private System.Windows.Forms.GroupBox groupBox2;
+		private System.Windows.Forms.GroupBox groupBox3;
+		private System.Windows.Forms.TextBox workplaceNameTextBox;
+		private System.Windows.Forms.Button saveButton;
+		private System.Windows.Forms.Button cancelButton;
+		private System.Windows.Forms.RadioButton radioButton2;
+		private System.Windows.Forms.RadioButton radioButton1;
+        private System.Windows.Forms.GroupBox groupBox4;
+        private System.Windows.Forms.TextBox extraBatteryLifetimeTextBox;
+        private System.Windows.Forms.GroupBox oracleGroupBox;
+        private System.Windows.Forms.CheckBox oracleBatteryCheckBox;
+        private System.Windows.Forms.CheckBox checkPcbIsInOracleCheckBox;
+        private System.Windows.Forms.GroupBox groupBox5;
+        private System.Windows.Forms.TextBox usersDBConnStringTextBox;
+	}
+}

MonitoringDB/Forms/SettingsDlg.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Windows.Forms;
+
+namespace MonitoringDB.Forms
+{
+	public partial class SettingsDlg : Form
+	{
+		public string WorkplaceName
+		{
+			set { workplaceNameTextBox.Text = value; }
+			get { return workplaceNameTextBox.Text; }
+		}
+
+		public string ConnectionString
+		{
+			set { connectionStringTextBox.Text = value; }
+			get { return connectionStringTextBox.Text; }
+		}
+
+        public string UsersDBConnString
+        {
+            set { usersDBConnStringTextBox.Text = value; }
+            get { return usersDBConnStringTextBox.Text; }
+        }
+
+        public bool OracleBattery
+        {
+            set { oracleBatteryCheckBox.Checked = value; }
+            get { return oracleBatteryCheckBox.Checked; }
+        }
+
+        public bool CheckPcbIsInOracle
+        {
+            set { checkPcbIsInOracleCheckBox.Checked = value; }
+            get { return checkPcbIsInOracleCheckBox.Checked; }
+        }
+
+        public int ExtraBatterLifetime
+        {
+            get
+            {
+                int extraLifetime;
+                if (int.TryParse(extraBatteryLifetimeTextBox.Text, out extraLifetime) && extraLifetime >= 0) return extraLifetime;
+                return 0;
+            }
+        }
+
+        public MonitoringDB.Mode Mode
+		{
+			set
+			{
+                radioButton1.Checked = (value == MonitoringDB.Mode.Test);
+                radioButton2.Checked = (value == MonitoringDB.Mode.Production);
+			}
+			get
+			{
+                return radioButton1.Checked ? MonitoringDB.Mode.Test : MonitoringDB.Mode.Production;
+			}
+		}
+
+        /// <summary>
+        /// Basic configuration dialog
+        /// </summary>
+        /// <param name="isWorkplace">false = Konfiguracia pracovisk, true = Pracovisko</param>
+		public SettingsDlg(bool isWorkplace)
+		{
+			InitializeComponent();
+            if (isWorkplace)
+            {
+                oracleGroupBox.Visible = true;
+            }
+            extraBatteryLifetimeTextBox.Text = "0";
+		}
+
+		private void saveButton_Click(object sender, EventArgs e)
+		{
+			DialogResult = DialogResult.OK;
+			Close();
+		}
+
+		private void cancelButton_Click(object sender, EventArgs e)
+		{
+			DialogResult = DialogResult.Cancel;
+			Close();
+		}
+	}
+}

MonitoringDB/Forms/TrivialLoginDlg.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Windows.Forms;
+
+namespace MonitoringDB.Forms
+{
+	public partial class TrivialLoginDlg : Form
+	{
+        public LoginLevel LoginLevel;
+
+        public TrivialLoginDlg()
+		{
+			InitializeComponent();
+            LoginLevel = LoginLevel.None;
+		}
+
+		private void okButton_Click(object sender, EventArgs e)
+		{
+			if (passwordTextBox.Text.ToLower().Equals("barcode"))
+			{
+                LoginLevel = LoginLevel.Administrator;
+				DialogResult = DialogResult.OK;
+				Close();
+			}
+            else if (passwordTextBox.Text.ToLower().Equals("teamleader"))
+            {
+                LoginLevel = LoginLevel.TeamLeader;
+                DialogResult = DialogResult.OK;
+                Close();
+            }
+            else if (passwordTextBox.Text.ToLower().Equals("kremik"))
+            {
+                LoginLevel = LoginLevel.MH;
+                DialogResult = DialogResult.OK;
+                Close();
+            }
+            else
+			{
+				DialogResult = DialogResult.Cancel;
+				Close();
+			}
+		}
+
+		private void cancelButton_Click(object sender, EventArgs e)
+		{
+			DialogResult = DialogResult.Cancel;
+			Close();
+		}
+	}
+}

MonitoringDB/Forms/TrivialLoginDlg.designer.cs

@@ -0,0 +1,105 @@
+namespace MonitoringDB.Forms
+{
+	partial class TrivialLoginDlg
+	{
+		/// <summary>
+		/// Required designer variable.
+		/// </summary>
+		private System.ComponentModel.IContainer components = null;
+
+		/// <summary>
+		/// Clean up any resources being used.
+		/// </summary>
+		/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+		protected override void Dispose(bool disposing)
+		{
+			if (disposing && (components != null))
+			{
+				components.Dispose();
+			}
+			base.Dispose(disposing);
+		}
+
+		#region Windows Form Designer generated code
+
+		/// <summary>
+		/// Required method for Designer support - do not modify
+		/// the contents of this method with the code editor.
+		/// </summary>
+		private void InitializeComponent()
+		{
+			this.passwordGroupBox = new System.Windows.Forms.GroupBox();
+			this.passwordTextBox = new System.Windows.Forms.TextBox();
+			this.okButton = new System.Windows.Forms.Button();
+			this.cancelButton = new System.Windows.Forms.Button();
+			this.passwordGroupBox.SuspendLayout();
+			this.SuspendLayout();
+			// 
+			// passwordGroupBox
+			// 
+			this.passwordGroupBox.Controls.Add(this.passwordTextBox);
+			this.passwordGroupBox.Location = new System.Drawing.Point(12, 10);
+			this.passwordGroupBox.Name = "passwordGroupBox";
+			this.passwordGroupBox.Size = new System.Drawing.Size(200, 49);
+			this.passwordGroupBox.TabIndex = 0;
+			this.passwordGroupBox.TabStop = false;
+			this.passwordGroupBox.Text = "Heslo";
+			// 
+			// passwordTextBox
+			// 
+			this.passwordTextBox.Location = new System.Drawing.Point(51, 18);
+			this.passwordTextBox.Name = "passwordTextBox";
+			this.passwordTextBox.PasswordChar = '*';
+			this.passwordTextBox.Size = new System.Drawing.Size(100, 20);
+			this.passwordTextBox.TabIndex = 0;
+			// 
+			// okButton
+			// 
+			this.okButton.Location = new System.Drawing.Point(237, 18);
+			this.okButton.Name = "okButton";
+			this.okButton.Size = new System.Drawing.Size(75, 39);
+			this.okButton.TabIndex = 1;
+			this.okButton.Text = "OK";
+			this.okButton.UseVisualStyleBackColor = true;
+			this.okButton.Click += new System.EventHandler(this.okButton_Click);
+			// 
+			// cancelButton
+			// 
+			this.cancelButton.DialogResult = System.Windows.Forms.DialogResult.Cancel;
+			this.cancelButton.Location = new System.Drawing.Point(330, 18);
+			this.cancelButton.Name = "cancelButton";
+			this.cancelButton.Size = new System.Drawing.Size(75, 39);
+			this.cancelButton.TabIndex = 2;
+			this.cancelButton.Text = "Cancel";
+			this.cancelButton.UseVisualStyleBackColor = true;
+			this.cancelButton.Click += new System.EventHandler(this.cancelButton_Click);
+			// 
+			// LoginDlg
+			// 
+			this.AcceptButton = this.okButton;
+			this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+			this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+			this.CancelButton = this.cancelButton;
+			this.ClientSize = new System.Drawing.Size(426, 73);
+			this.Controls.Add(this.cancelButton);
+			this.Controls.Add(this.okButton);
+			this.Controls.Add(this.passwordGroupBox);
+			this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
+			this.MaximizeBox = false;
+			this.MinimizeBox = false;
+			this.Name = "LoginDlg";
+			this.Text = "LoginDlg";
+			this.passwordGroupBox.ResumeLayout(false);
+			this.passwordGroupBox.PerformLayout();
+			this.ResumeLayout(false);
+
+		}
+
+		#endregion
+
+		private System.Windows.Forms.GroupBox passwordGroupBox;
+		private System.Windows.Forms.TextBox passwordTextBox;
+		private System.Windows.Forms.Button okButton;
+		private System.Windows.Forms.Button cancelButton;
+	}
+}

MonitoringDB/ItemSpec.cs

@@ -0,0 +1,306 @@
+///
+/// Copyright (c) 2016-2017 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections.Generic;
+using MonitoringDB.Entities;
+using MonitoringDB.Resources;
+using NHibernate;
+using NHibernate.Criterion;
+
+namespace MonitoringDB
+{
+	public class ItemSpec
+	{
+        ///
+        /// Function delegate to pick a reference record and convert it to a string
+        /// 
+        public delegate string PrintDlgt(object x, string format, string precision, int width);
+
+        ///
+		/// Public fields
+		///
+        public readonly ItemSpecID Uid;         /// Unique Uid used to distinguish items
+        public readonly string Name;	        /// Name that can be localized to identify the item in a list
+        public readonly PrintDlgt PrintFn;      /// Function used to convert the result to a text
+                                                
+        public string Caption;	                /// User defined text printed in the column header
+        public string Format;                   /// Specifies the text generation
+        public string Precision;                /// Specifies the text generation
+        public int Width;                       /// Specifies the text generation
+
+        readonly ItemSpecCaps itemSpecCaps;
+
+        /// <summary> Public parameterless constructor </summary>
+        public ItemSpec()
+        {
+        }
+
+        /// <summary> Constructor to specify all items </summary>
+        public ItemSpec(ItemSpecID uid, string name, PrintDlgt printFn, ItemSpecCaps itemSpecCaps)
+		{
+            Uid = uid;
+            Name = name;
+            PrintFn = printFn;
+            this.itemSpecCaps = itemSpecCaps;
+            ///
+            Caption = name;
+            Format = "{0}";
+            Precision = string.Empty;
+            Width = 0;
+		}
+
+        /// <summary> Copy constructor </summary>
+        public ItemSpec Clone()
+        {
+            ItemSpec newItem = new ItemSpec(Uid, Name, PrintFn, itemSpecCaps);
+            newItem.Caption = Caption;
+            newItem.Format = Format;
+            newItem.Precision = Precision;
+            newItem.Width = Width;
+            return newItem;
+        }
+
+
+        /// <summary> Safe wrapper which replaces null-s by empty strings </summary>
+        public string Print(object x)
+        {
+            string str = PrintFn(x, Format, Precision, Width);
+            return (str == null) ? string.Empty : str;
+        }
+
+
+        /// <summary> Similar to Print(), in addition embeds text into "" </summary>
+        public string Export(object x)
+        {
+            string str = PrintFn(x, Format, Precision, Width);
+            if (str == null) str = string.Empty;
+
+            if (Uid == ItemSpecID.Barcode || Uid == ItemSpecID.PartBarcode || Uid == ItemSpecID.SerialNr || Uid == ItemSpecID.PurchaseOrder)
+            {
+                return string.Format("=\"{0}\"", str);
+            }
+            return str;
+        }
+
+
+		/// Static list of all available items
+		public static readonly IList<ItemSpec> AllItems;
+
+        ///
+		/// Static constructor that initializes the list of all items
+        ///
+		static ItemSpec()
+		{
+			AllItems = new List<ItemSpec>();
+
+            AllItems.Add(new ItemSpec(ItemSpecID.RefRecordID,   Strings.RefRecordID,    (x, f, p, w) => ((int)x).ToString(), ItemSpecCaps.ReferenceRecord));
+            
+            AllItems.Add(new ItemSpec(ItemSpecID.TimeStamp,     Strings.Time_stamp,     (x, f, p, w) => string.IsNullOrEmpty(f) ? ((DateTime)x).ToString() : string.Format(f, (DateTime)x), ItemSpecCaps.ReferenceRecord));
+            AllItems.Add(new ItemSpec(ItemSpecID.Workstep,      Strings.Workstep,       (x, f, p, w) => string.IsNullOrEmpty(f) ? ((Workstep)x).Name : string.Format(f, ((Workstep)x).Name), ItemSpecCaps.ReferenceRecord));
+            AllItems.Add(new ItemSpec(ItemSpecID.Workplace,     Strings.Workplace,      (x, f, p, w) => string.IsNullOrEmpty(f) ? (string)x : string.Format(f, x), ItemSpecCaps.ReferenceRecord));
+            AllItems.Add(new ItemSpec(ItemSpecID.UserName,      Strings.User_name,      (x, f, p, w) => string.IsNullOrEmpty(f) ? (string)x : string.Format(f, x), ItemSpecCaps.ReferenceRecord));
+            AllItems.Add(new ItemSpec(ItemSpecID.Barcode,       Strings.Barcode,        (x, f, p, w) => string.IsNullOrEmpty(f) ? (string)x : string.Format(f, x), ItemSpecCaps.ReferenceRecord));
+            AllItems.Add(new ItemSpec(ItemSpecID.PartBarcode,   Strings.Part_barcode,   (x, f, p, w) => string.IsNullOrEmpty(f) ? (string)x : string.Format(f, x), ItemSpecCaps.ReferenceRecord | ItemSpecCaps.AssociatedRecord));
+            
+            AllItems.Add(new ItemSpec(ItemSpecID.TimeStamp2,    Strings.Time_stamp+"2", (x, f, p, w) => string.IsNullOrEmpty(f) ? ((DateTime)x).ToString() : string.Format(f, (DateTime)x), ItemSpecCaps.ReferenceRecord));
+            AllItems.Add(new ItemSpec(ItemSpecID.Workstep2,     Strings.Workstep+"2",   (x, f, p, w) => string.IsNullOrEmpty(f) ? ((Workstep)x).Name : string.Format(f, ((Workstep)x).Name), ItemSpecCaps.ReferenceRecord));
+            AllItems.Add(new ItemSpec(ItemSpecID.Workplace2,    Strings.Workplace+"2",  (x, f, p, w) => string.IsNullOrEmpty(f) ? (string)x : string.Format(f, x), ItemSpecCaps.ReferenceRecord));
+            AllItems.Add(new ItemSpec(ItemSpecID.UserName2,     Strings.User_name+"2",  (x, f, p, w) => string.IsNullOrEmpty(f) ? (string)x : string.Format(f, x), ItemSpecCaps.ReferenceRecord));
+            AllItems.Add(new ItemSpec(ItemSpecID.Barcode2,      Strings.Barcode+"2",    (x, f, p, w) => string.IsNullOrEmpty(f) ? (string)x : string.Format(f, x), ItemSpecCaps.ReferenceRecord));
+            AllItems.Add(new ItemSpec(ItemSpecID.PartBarcode2,  Strings.Part_barcode+"2",(x, f, p, w)=> string.IsNullOrEmpty(f) ? (string)x : string.Format(f, x), ItemSpecCaps.ReferenceRecord | ItemSpecCaps.AssociatedRecord));
+            
+            AllItems.Add(new ItemSpec(ItemSpecID.SerialNr,      Strings.Serial_nr,      (x, f, p, w) => x as string, ItemSpecCaps.ReferenceRecord | ItemSpecCaps.OracleQuery));
+            AllItems.Add(new ItemSpec(ItemSpecID.PurchaseOrder, Strings.Purchase_order, (x, f, p, w) => x as string, ItemSpecCaps.ReferenceRecord | ItemSpecCaps.OracleQuery));
+			AllItems.Add(new ItemSpec(ItemSpecID.TestResult,	Strings.Test_result,	(x, f, p, w) => x as string, ItemSpecCaps.ReferenceRecord | ItemSpecCaps.OracleQuery));
+            AllItems.Add(new ItemSpec(ItemSpecID.MaxPruefindex, Strings.Max_pruefindex, (x, f, p, w) => x as string, ItemSpecCaps.ReferenceRecord | ItemSpecCaps.OracleQuery));
+            
+            AllItems.Add(new ItemSpec(ItemSpecID.Process,       Strings.Process,        (x, f, p, w) => string.IsNullOrEmpty(f) ? ((Process)x).Name : string.Format(f, ((Process)x).Name), ItemSpecCaps.ReferenceRecord));
+        }
+
+        public PropertyProjection GetProperty(ReferenceRecord refRecord, Record record)
+        {
+            switch (Uid)
+            {
+                case ItemSpecID.RefRecordID:    return Projections.Property(() => refRecord.Id);
+                
+                case ItemSpecID.TimeStamp:      return Projections.Property(() => refRecord.TimeStamp);
+                case ItemSpecID.Workstep:       return Projections.Property(() => refRecord.Workstep);
+                case ItemSpecID.Workplace:      return Projections.Property(() => refRecord.Workplace);
+                case ItemSpecID.UserName:       return Projections.Property(() => refRecord.UserName);
+                case ItemSpecID.Barcode:        return Projections.Property(() => refRecord.Code);
+                case ItemSpecID.PartBarcode:    return Projections.Property(() => record.Code);
+
+                case ItemSpecID.TimeStamp2:     return null;
+                case ItemSpecID.Workstep2:      return null;
+                case ItemSpecID.Workplace2:     return null;
+                case ItemSpecID.UserName2:      return null;
+                case ItemSpecID.Barcode2:       return null;
+                case ItemSpecID.PartBarcode2:   return null;
+
+                case ItemSpecID.SerialNr:       return null;
+                case ItemSpecID.PurchaseOrder:  return null;
+				case ItemSpecID.TestResult:     return null;
+                case ItemSpecID.MaxPruefindex:  return null;
+                
+                case ItemSpecID.Process:        return Projections.Property(() => refRecord.Process);
+                
+                default: return null;
+            }
+        }
+
+        public PropertyProjection GetProperty2(ReferenceRecord refRecord2, Record record2)
+        {
+            switch (Uid)
+            {
+                case ItemSpecID.RefRecordID:    return null;
+
+                case ItemSpecID.TimeStamp:      return null;
+                case ItemSpecID.Workstep:       return null;
+                case ItemSpecID.Workplace:      return null;
+                case ItemSpecID.UserName:       return null;
+                case ItemSpecID.Barcode:        return null;
+                case ItemSpecID.PartBarcode:    return null;
+
+                case ItemSpecID.TimeStamp2:     return Projections.Property(() => refRecord2.TimeStamp);
+                case ItemSpecID.Workstep2:      return Projections.Property(() => refRecord2.Workstep);
+                case ItemSpecID.Workplace2:     return Projections.Property(() => refRecord2.Workplace);
+                case ItemSpecID.UserName2:      return Projections.Property(() => refRecord2.UserName);
+                case ItemSpecID.Barcode2:       return Projections.Property(() => refRecord2.Code);
+                case ItemSpecID.PartBarcode2:   return Projections.Property(() => record2.Code);
+
+                case ItemSpecID.SerialNr:       return null;
+                case ItemSpecID.PurchaseOrder:  return null;
+                case ItemSpecID.TestResult:     return null;
+                case ItemSpecID.MaxPruefindex:  return null;
+
+                case ItemSpecID.Process:        return Projections.Property(() => refRecord2.Process);
+
+                default: return null;
+            }
+        }
+
+        public ItemSpecCaps GetCaps()
+        {
+            return itemSpecCaps;
+        }
+
+
+        public static ItemSpec GetItem(ItemSpecID id)
+        {
+            foreach (var item in AllItems)
+                if (item.Uid == id)
+                    return item.Clone();
+
+            return null;
+        }
+
+        public static ItemSpec GetItem(string uidName)
+        {
+            foreach (var item in AllItems)
+                if (item.Uid.ToString() == uidName)
+                    return item.Clone();
+
+            return null;
+        }
+
+
+        public static ProjectionList GetProjections(IList<ItemSpec> items, ReferenceRecord refRecord, Record record)
+        {
+            ProjectionList projections = Projections.ProjectionList();
+            foreach (var item in items)
+            {
+                PropertyProjection projection = item.GetProperty(refRecord, record);
+                if (projection != null)
+                    projections.Add(projection);
+            }
+
+            return projections;
+        }
+
+        public static IList<object[]> Expand(IList<object[]> data, IList<ItemSpec> items)
+        {
+            if (data.Count == 0) return data;
+
+            int iSize = data[0].Length;
+            int oSize = items.Count;
+            for (int i = 0; i < data.Count; i++)
+            {
+                object[] inArr = data[i];
+
+                object[] outArr = new object[oSize];
+                int srcIx = 0;
+                for (int dstIx = 0; dstIx < oSize; dstIx++)
+                {
+                    outArr[dstIx] = ((items[dstIx].GetCaps() & ItemSpecCaps.OracleQuery) == ItemSpecCaps.OracleQuery) ? string.Empty : inArr[srcIx++];
+                }
+
+                data[i] = outArr;
+            }
+
+            return data;
+        }
+
+
+        //static string GetPartCode(ReferenceRecord refRecord, string partName)
+        //{
+        //    if (refRecord != null && refRecord.Records != null)
+        //    {
+        //        foreach (var record in refRecord.Records)
+        //        {
+        //            if (record.Part.Name.Equals(partName))
+        //            {
+        //                return record.Code;
+        //            }
+        //        }
+        //    }
+
+        //    return string.Empty;
+        //}
+
+		public static string[] ToStrArray(IList<ItemSpec> 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}",
+                                          items[i].Uid,
+                                          items[i].Caption,
+                                          items[i].Format,
+                                          items[i].Precision,
+                                          items[i].Width);
+            }
+			return result;
+		}
+
+		public static IList<ItemSpec> FromStrArray(string[] strArray)
+		{
+			IList<ItemSpec> result = new List<ItemSpec>();
+            if (strArray != null)
+			{
+				for (int i = 0; i < strArray.Length; i++)
+				{
+                    string[] field = strArray[i].Split(new char[] { '~' });
+                    try
+                    {
+                        ItemSpec item = GetItem(field[0]);
+                        item.Caption = field[1];
+                        item.Format = field[2];
+                        item.Precision = field[3];
+                        item.Width = int.Parse(field[4]);
+
+                        result.Add(item);
+                    }
+                    catch
+                    {
+                        ItemSpec item = GetItem(ItemSpecID.RefRecordID);
+                        item.Format = string.Format("Parse error: {0}", strArray[i]);
+                        result.Add(item);
+                    }
+                }
+			}
+			return result;
+		}
+    }
+}

MonitoringDB/Mappings/PartMap.cs

@@ -0,0 +1,23 @@
+using FluentNHibernate.Mapping;
+
+namespace MonitoringDB.Mappings
+{
+    class PartMap : ClassMap<Entities.Part>
+    {
+        public PartMap()
+        {
+            Id(x => x.Id);
+            Map(x => x.Name);
+            Map(x => x.OraDBType);
+            Map(x => x.Description);
+			Map(x => x.CodeType);
+            Map(x => x.CodeForm);
+			Map(x => x.CodeLocation);
+			Map(x => x.LifetimeManagement);
+			Map(x => x.StepNumber);
+
+			References(x => x.Process);
+			References(x => x.Workstep);
+		}
+    }
+}

MonitoringDB/Mappings/ProcessMap.cs

@@ -0,0 +1,25 @@
+using FluentNHibernate.Mapping;
+
+namespace MonitoringDB.Mappings
+{
+    class ProcessMap : ClassMap<Entities.Process>
+    {
+        public ProcessMap()
+        {
+            Id(x => x.Id);
+            Map(x => x.ItemNr);
+            Map(x => x.Name);
+			Map(x => x.Description);
+			Map(x => x.ReleaseStatus);
+			Map(x => x.TimeStamp);
+			Map(x => x.UserName);
+
+			HasMany(x => x.Parts)
+				.OrderBy("Name")
+				.Cascade.All();
+			HasMany(x => x.Worksteps)
+				.OrderBy("WorkstepNr")
+				.Cascade.All();
+		}
+    }
+}

MonitoringDB/Mappings/RecordMap.cs

@@ -0,0 +1,17 @@
+using FluentNHibernate.Mapping;
+
+namespace MonitoringDB.Mappings
+{
+    class RecordMap : ClassMap<Entities.Record>
+    {
+        public RecordMap()
+        {
+            Id(x => x.Id);
+			Map(x => x.Code);
+			Map(x => x.TimeStamp);
+
+			References(x => x.Part);
+			References(x => x.ReferenceRecord);
+		}
+    }
+}

MonitoringDB/Mappings/ReferenceRecordMap.cs

@@ -0,0 +1,22 @@
+using FluentNHibernate.Mapping;
+
+namespace MonitoringDB.Mappings
+{
+    class ReferenceRecordMap : ClassMap<Entities.ReferenceRecord>
+    {
+        public ReferenceRecordMap()
+        {
+            Id(x => x.Id);
+			Map(x => x.Code);
+			Map(x => x.TimeStamp);
+			Map(x => x.UserName);
+			Map(x => x.Workplace);
+			Map(x => x.Result);
+
+			References(x => x.Process);
+			References(x => x.Workstep);
+			HasMany(x => x.Records)
+				.Cascade.All();
+		}
+    }
+}

MonitoringDB/Mappings/WorkstepMap.cs

@@ -0,0 +1,23 @@
+using FluentNHibernate.Mapping;
+
+namespace MonitoringDB.Mappings
+{
+    class WorkstepMap : ClassMap<Entities.Workstep>
+    {
+        public WorkstepMap()
+        {
+            Id(x => x.Id);
+            Map(x => x.WorkstepNr);
+            Map(x => x.Name);
+			Map(x => x.Description);
+            Map(x => x.CheckPartNr);
+            Map(x => x.AllowRepairs);
+
+			References(x => x.Process);
+			References(x => x.ReferencePart);
+			HasMany(x => x.Parts)
+				.OrderBy("StepNumber")
+				.Cascade.All();
+		}
+    }
+}

MonitoringDB/MonitoringDB.csproj

@@ -0,0 +1,157 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{EFEC8A31-3022-4DA7-A8F6-16D30A94C3FF}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>MonitoringDB</RootNamespace>
+    <AssemblyName>MonitoringDB</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="FluentNHibernate, Version=2.0.3.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\FluentNHibernate.2.0.3.0\lib\net40\FluentNHibernate.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Iesi.Collections, Version=4.0.0.0, Culture=neutral, PublicKeyToken=aa95f207798dfdb4, processorArchitecture=MSIL">
+      <HintPath>..\packages\Iesi.Collections.4.0.0.4000\lib\net40\Iesi.Collections.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="log4net">
+      <HintPath>..\packages\log4net.2.0.2\lib\net40-full\log4net.dll</HintPath>
+    </Reference>
+    <Reference Include="MySql.Data, Version=6.6.5.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\MySql.Data.6.6.5\lib\net40\MySql.Data.dll</HintPath>
+    </Reference>
+    <Reference Include="NHibernate, Version=4.0.0.4000, Culture=neutral, PublicKeyToken=aa95f207798dfdb4, processorArchitecture=MSIL">
+      <HintPath>..\packages\NHibernate.4.0.4.4000\lib\net40\NHibernate.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Forms\ListViewEx.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Forms\TrivialLoginDlg.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="Forms\TrivialLoginDlg.designer.cs">
+      <DependentUpon>TrivialLoginDlg.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Forms\ModelessForm.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="Forms\ModelessForm.designer.cs">
+      <DependentUpon>ModelessForm.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Forms\ResultsConfigDlg.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="Forms\ResultsConfigDlg.designer.cs">
+      <DependentUpon>ResultsConfigDlg.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Forms\SettingsDlg.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="Forms\SettingsDlg.designer.cs">
+      <DependentUpon>SettingsDlg.cs</DependentUpon>
+    </Compile>
+    <Compile Include="ItemSpec.cs" />
+    <Compile Include="QuitAppException.cs" />
+    <Compile Include="Resources\Strings.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Strings.resx</DependentUpon>
+    </Compile>
+    <Compile Include="ScanVerificationInfo.cs" />
+    <Compile Include="SerializableDictionary.cs" />
+    <Compile Include="WMPart.cs" />
+    <Compile Include="Entities\Part.cs" />
+    <Compile Include="Entities\Process.cs" />
+    <Compile Include="Entities\Record.cs" />
+    <Compile Include="Entities\ReferenceRecord.cs" />
+    <Compile Include="Entities\Workstep.cs" />
+    <Compile Include="Enums.cs" />
+    <Compile Include="FluentNH.cs" />
+    <Compile Include="Mappings\PartMap.cs" />
+    <Compile Include="Mappings\ProcessMap.cs" />
+    <Compile Include="Mappings\RecordMap.cs" />
+    <Compile Include="Mappings\ReferenceRecordMap.cs" />
+    <Compile Include="Mappings\WorkstepMap.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Properties\Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="Forms\ListViewEx.resx">
+      <DependentUpon>ListViewEx.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Forms\TrivialLoginDlg.resx">
+      <DependentUpon>TrivialLoginDlg.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Forms\ModelessForm.resx">
+      <DependentUpon>ModelessForm.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Forms\ResultsConfigDlg.resx">
+      <DependentUpon>ResultsConfigDlg.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Forms\SettingsDlg.resx">
+      <DependentUpon>SettingsDlg.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Resources\Strings.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Strings.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="app.config" />
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

MonitoringDB/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Common")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Common")]
+[assembly: AssemblyCopyright("Copyright ©  2015-2017")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("b182c80f-8670-40ab-ad26-6fb8de86552e")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.5.57.0")]
+[assembly: AssemblyFileVersion("1.5.57.0")]

MonitoringDB/Properties/Resources.Designer.cs

@@ -0,0 +1,63 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace MonitoringDB.Properties {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resources {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("MonitoringDB.Properties.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+    }
+}

MonitoringDB/QuitAppException.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace MonitoringDB
+{
+    public class QuitAppException : Exception
+    {
+        public QuitAppException(string message)
+            : base(message)
+        {
+        }
+    }
+}

MonitoringDB/Resources/Strings.Designer.cs

@@ -0,0 +1,333 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace MonitoringDB.Resources {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Strings {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Strings() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("MonitoringDB.Resources.Strings", typeof(Strings).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Add  &gt;.
+        /// </summary>
+        internal static string Add {
+            get {
+                return ResourceManager.GetString("Add", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Available results.
+        /// </summary>
+        internal static string Available_results {
+            get {
+                return ResourceManager.GetString("Available_results", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Barcode.
+        /// </summary>
+        internal static string Barcode {
+            get {
+                return ResourceManager.GetString("Barcode", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Cancel.
+        /// </summary>
+        internal static string CancelBtnText {
+            get {
+                return ResourceManager.GetString("CancelBtnText", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Caption.
+        /// </summary>
+        internal static string Caption {
+            get {
+                return ResourceManager.GetString("Caption", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Configuration.
+        /// </summary>
+        internal static string Configuration {
+            get {
+                return ResourceManager.GetString("Configuration", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Down.
+        /// </summary>
+        internal static string DownBtnText {
+            get {
+                return ResourceManager.GetString("DownBtnText", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Format.
+        /// </summary>
+        internal static string Format {
+            get {
+                return ResourceManager.GetString("Format", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Item.
+        /// </summary>
+        internal static string Item {
+            get {
+                return ResourceManager.GetString("Item", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Max. prüfindex.
+        /// </summary>
+        internal static string Max_pruefindex {
+            get {
+                return ResourceManager.GetString("Max_pruefindex", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to OK.
+        /// </summary>
+        internal static string OkBtnText {
+            get {
+                return ResourceManager.GetString("OkBtnText", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Another part barcode.
+        /// </summary>
+        internal static string Part_barcode {
+            get {
+                return ResourceManager.GetString("Part_barcode", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Precision.
+        /// </summary>
+        internal static string Precision {
+            get {
+                return ResourceManager.GetString("Precision", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Process.
+        /// </summary>
+        internal static string Process {
+            get {
+                return ResourceManager.GetString("Process", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Purchase order.
+        /// </summary>
+        internal static string Purchase_order {
+            get {
+                return ResourceManager.GetString("Purchase_order", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Record ID.
+        /// </summary>
+        internal static string RefRecordID {
+            get {
+                return ResourceManager.GetString("RefRecordID", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to &lt;  Remove.
+        /// </summary>
+        internal static string Remove {
+            get {
+                return ResourceManager.GetString("Remove", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Remove all.
+        /// </summary>
+        internal static string Remove_all {
+            get {
+                return ResourceManager.GetString("Remove_all", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Selected results.
+        /// </summary>
+        internal static string Selected_results {
+            get {
+                return ResourceManager.GetString("Selected_results", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Serial nr..
+        /// </summary>
+        internal static string Serial_nr {
+            get {
+                return ResourceManager.GetString("Serial_nr", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Serial_number.
+        /// </summary>
+        internal static string Serial_number {
+            get {
+                return ResourceManager.GetString("Serial_number", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Summary.
+        /// </summary>
+        internal static string Summary {
+            get {
+                return ResourceManager.GetString("Summary", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Test result.
+        /// </summary>
+        internal static string Test_result {
+            get {
+                return ResourceManager.GetString("Test_result", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Text.
+        /// </summary>
+        internal static string Text {
+            get {
+                return ResourceManager.GetString("Text", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Time stamp.
+        /// </summary>
+        internal static string Time_stamp {
+            get {
+                return ResourceManager.GetString("Time_stamp", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Up.
+        /// </summary>
+        internal static string UpBtnText {
+            get {
+                return ResourceManager.GetString("UpBtnText", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to User name.
+        /// </summary>
+        internal static string User_name {
+            get {
+                return ResourceManager.GetString("User_name", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Width.
+        /// </summary>
+        internal static string Width {
+            get {
+                return ResourceManager.GetString("Width", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Workplace.
+        /// </summary>
+        internal static string Workplace {
+            get {
+                return ResourceManager.GetString("Workplace", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Workstep.
+        /// </summary>
+        internal static string Workstep {
+            get {
+                return ResourceManager.GetString("Workstep", resourceCulture);
+            }
+        }
+    }
+}

MonitoringDB/Resources/Strings.resx

@@ -117,136 +117,94 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
-  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
-  <data name="button1.Font" type="System.Drawing.Font, System.Drawing">
-    <value>Microsoft Sans Serif, 8.25pt</value>
+  <data name="Add" xml:space="preserve">
+    <value>Add  &gt;</value>
   </data>
-  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
-  <data name="button1.ImeMode" type="System.Windows.Forms.ImeMode, System.Windows.Forms">
-    <value>NoControl</value>
+  <data name="Available_results" xml:space="preserve">
+    <value>Available results</value>
   </data>
-  <data name="button1.Location" type="System.Drawing.Point, System.Drawing">
-    <value>12, 34</value>
+  <data name="Barcode" xml:space="preserve">
+    <value>Barcode</value>
   </data>
-  <data name="button1.Margin" type="System.Windows.Forms.Padding, System.Windows.Forms">
-    <value>2, 2, 2, 2</value>
+  <data name="CancelBtnText" xml:space="preserve">
+    <value>Cancel</value>
   </data>
-  <data name="button1.Size" type="System.Drawing.Size, System.Drawing">
-    <value>42, 30</value>
+  <data name="Caption" xml:space="preserve">
+    <value>Caption</value>
   </data>
-  <assembly alias="mscorlib" name="mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
-  <data name="button1.TabIndex" type="System.Int32, mscorlib">
-    <value>1</value>
+  <data name="Configuration" xml:space="preserve">
+    <value>Configuration</value>
   </data>
-  <data name="button1.Text" xml:space="preserve">
-    <value>&amp;Btn1</value>
+  <data name="DownBtnText" xml:space="preserve">
+    <value>Down</value>
   </data>
-  <data name="&gt;&gt;button1.Name" xml:space="preserve">
-    <value>button1</value>
+  <data name="Format" xml:space="preserve">
+    <value>Format</value>
   </data>
-  <data name="&gt;&gt;button1.Type" xml:space="preserve">
-    <value>System.Windows.Forms.Button, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  <data name="Item" xml:space="preserve">
+    <value>Item</value>
   </data>
-  <data name="&gt;&gt;button1.Parent" xml:space="preserve">
-    <value>splitContainer.Panel1</value>
+  <data name="Max_pruefindex" xml:space="preserve">
+    <value>Max. prüfindex</value>
   </data>
-  <data name="&gt;&gt;button1.ZOrder" xml:space="preserve">
-    <value>0</value>
+  <data name="OkBtnText" xml:space="preserve">
+    <value>OK</value>
   </data>
-  <data name="splitContainer.Dock" type="System.Windows.Forms.DockStyle, System.Windows.Forms">
-    <value>Fill</value>
+  <data name="Part_barcode" xml:space="preserve">
+    <value>Another part barcode</value>
   </data>
-  <data name="splitContainer.IsSplitterFixed" type="System.Boolean, mscorlib">
-    <value>True</value>
+  <data name="Precision" xml:space="preserve">
+    <value>Precision</value>
   </data>
-  <data name="splitContainer.Location" type="System.Drawing.Point, System.Drawing">
-    <value>0, 0</value>
+  <data name="Process" xml:space="preserve">
+    <value>Process</value>
   </data>
-  <data name="&gt;&gt;splitContainer.Panel1.Name" xml:space="preserve">
-    <value>splitContainer.Panel1</value>
+  <data name="Purchase_order" xml:space="preserve">
+    <value>Purchase order</value>
   </data>
-  <data name="&gt;&gt;splitContainer.Panel1.Type" xml:space="preserve">
-    <value>System.Windows.Forms.SplitterPanel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  <data name="RefRecordID" xml:space="preserve">
+    <value>Record ID</value>
   </data>
-  <data name="&gt;&gt;splitContainer.Panel1.Parent" xml:space="preserve">
-    <value>splitContainer</value>
+  <data name="Remove" xml:space="preserve">
+    <value>&lt;  Remove</value>
   </data>
-  <data name="&gt;&gt;splitContainer.Panel1.ZOrder" xml:space="preserve">
-    <value>0</value>
+  <data name="Remove_all" xml:space="preserve">
+    <value>Remove all</value>
   </data>
-  <data name="plotterDisplayEx.Dock" type="System.Windows.Forms.DockStyle, System.Windows.Forms">
-    <value>Fill</value>
+  <data name="Selected_results" xml:space="preserve">
+    <value>Selected results</value>
   </data>
-  <data name="plotterDisplayEx.Location" type="System.Drawing.Point, System.Drawing">
-    <value>0, 0</value>
+  <data name="Serial_nr" xml:space="preserve">
+    <value>Serial nr.</value>
   </data>
-  <data name="plotterDisplayEx.Size" type="System.Drawing.Size, System.Drawing">
-    <value>896, 689</value>
+  <data name="Serial_number" xml:space="preserve">
+    <value>Serial_number</value>
   </data>
-  <data name="plotterDisplayEx.TabIndex" type="System.Int32, mscorlib">
-    <value>0</value>
+  <data name="Summary" xml:space="preserve">
+    <value>Summary</value>
   </data>
-  <data name="&gt;&gt;plotterDisplayEx.Name" xml:space="preserve">
-    <value>plotterDisplayEx</value>
+  <data name="Test_result" xml:space="preserve">
+    <value>Test result</value>
   </data>
-  <data name="&gt;&gt;plotterDisplayEx.Type" xml:space="preserve">
-    <value>GraphLib.PlotterDisplayEx, GraphLib, Version=1.0.0.1, Culture=neutral, PublicKeyToken=null</value>
+  <data name="Text" xml:space="preserve">
+    <value>Text</value>
   </data>
-  <data name="&gt;&gt;plotterDisplayEx.Parent" xml:space="preserve">
-    <value>splitContainer.Panel2</value>
+  <data name="Time_stamp" xml:space="preserve">
+    <value>Time stamp</value>
   </data>
-  <data name="&gt;&gt;plotterDisplayEx.ZOrder" xml:space="preserve">
-    <value>0</value>
+  <data name="UpBtnText" xml:space="preserve">
+    <value>Up</value>
   </data>
-  <data name="&gt;&gt;splitContainer.Panel2.Name" xml:space="preserve">
-    <value>splitContainer.Panel2</value>
+  <data name="User_name" xml:space="preserve">
+    <value>User name</value>
   </data>
-  <data name="&gt;&gt;splitContainer.Panel2.Type" xml:space="preserve">
-    <value>System.Windows.Forms.SplitterPanel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  <data name="Width" xml:space="preserve">
+    <value>Width</value>
   </data>
-  <data name="&gt;&gt;splitContainer.Panel2.Parent" xml:space="preserve">
-    <value>splitContainer</value>
+  <data name="Workplace" xml:space="preserve">
+    <value>Workplace</value>
   </data>
-  <data name="&gt;&gt;splitContainer.Panel2.ZOrder" xml:space="preserve">
-    <value>1</value>
-  </data>
-  <data name="splitContainer.Size" type="System.Drawing.Size, System.Drawing">
-    <value>965, 689</value>
-  </data>
-  <data name="splitContainer.SplitterDistance" type="System.Int32, mscorlib">
-    <value>65</value>
-  </data>
-  <data name="splitContainer.TabIndex" type="System.Int32, mscorlib">
-    <value>2</value>
-  </data>
-  <data name="&gt;&gt;splitContainer.Name" xml:space="preserve">
-    <value>splitContainer</value>
-  </data>
-  <data name="&gt;&gt;splitContainer.Type" xml:space="preserve">
-    <value>System.Windows.Forms.SplitContainer, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </data>
-  <data name="&gt;&gt;splitContainer.Parent" xml:space="preserve">
-    <value>$this</value>
-  </data>
-  <data name="&gt;&gt;splitContainer.ZOrder" xml:space="preserve">
-    <value>0</value>
-  </data>
-  <metadata name="$this.Localizable" type="System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>True</value>
-  </metadata>
-  <data name="$this.AutoScaleDimensions" type="System.Drawing.SizeF, System.Drawing">
-    <value>6, 13</value>
-  </data>
-  <data name="$this.Font" type="System.Drawing.Font, System.Drawing">
-    <value>Microsoft Sans Serif, 8.25pt</value>
-  </data>
-  <data name="$this.Size" type="System.Drawing.Size, System.Drawing">
-    <value>965, 689</value>
-  </data>
-  <data name="&gt;&gt;$this.Name" xml:space="preserve">
-    <value>GraphsTabPageCtrl</value>
-  </data>
-  <data name="&gt;&gt;$this.Type" xml:space="preserve">
-    <value>System.Windows.Forms.UserControl, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  <data name="Workstep" xml:space="preserve">
+    <value>Workstep</value>
   </data>
 </root>

MonitoringDB/ScanVerificationInfo.cs

@@ -0,0 +1,25 @@
+using MonitoringDB.Entities;
+
+namespace MonitoringDB
+{
+    public class ScanVerificationInfo
+    {
+        public Workstep Workstep;           /// null = verification is disabled
+        public bool VerifyReferencePart;    /// true = verify current workstep ReferencePart with another part
+                                            /// false = verify Part from current workstep parts with ReferencePart of another Workstep
+        public Part Part;                   /// Applicable when VerifyReferencePart == false
+
+        /// Constructor that disables verification
+        public ScanVerificationInfo()
+        {
+            Workstep = null;
+        }
+
+        public ScanVerificationInfo(Workstep workstep, bool verifyReferencePart, Part part)
+        {
+            Workstep = workstep;
+            VerifyReferencePart = verifyReferencePart;
+            Part = part;
+        }
+    }
+}

MonitoringDB/SerializableDictionary.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.Xml.Serialization;
+
+namespace MonitoringDB
+{
+    [XmlRoot("dictionary")]
+    public class SerializableDictionary<TKey, TValue>
+        : Dictionary<TKey, TValue>, IXmlSerializable
+    {
+        public System.Xml.Schema.XmlSchema GetSchema()
+        {
+            return null;
+        }
+
+        public void ReadXml(System.Xml.XmlReader reader)
+        {
+            XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
+            XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
+
+            bool wasEmpty = reader.IsEmptyElement;
+            reader.Read();
+
+            if (wasEmpty)
+                return;
+
+            while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
+            {
+                reader.ReadStartElement("item");
+
+                reader.ReadStartElement("key");
+                TKey key = (TKey)keySerializer.Deserialize(reader);
+                reader.ReadEndElement();
+
+                reader.ReadStartElement("value");
+                TValue value = (TValue)valueSerializer.Deserialize(reader);
+                reader.ReadEndElement();
+
+                this.Add(key, value);
+
+                reader.ReadEndElement();
+                reader.MoveToContent();
+            }
+            reader.ReadEndElement();
+        }
+
+        public void WriteXml(System.Xml.XmlWriter writer)
+        {
+            XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
+            XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
+
+            foreach (TKey key in this.Keys)
+            {
+                writer.WriteStartElement("item");
+
+                writer.WriteStartElement("key");
+                keySerializer.Serialize(writer, key);
+                writer.WriteEndElement();
+
+                writer.WriteStartElement("value");
+                TValue value = this[key];
+                valueSerializer.Serialize(writer, value);
+                writer.WriteEndElement();
+
+                writer.WriteEndElement();
+            }
+        }
+    }
+}

MonitoringDB/WMPart.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using MonitoringDB.Entities;
+
+namespace MonitoringDB
+{
+	public class WMPart
+	{
+		public string Name;
+        public Process Process;
+        public string OraDBType;
+        public string Description;
+		public string Code;
+		public DateTime TimeStamp;
+		public CodeType CodeType;
+		public CodeForm CodeForm;
+		public CodeLocation CodeLocation;
+		public string UserName;
+		public string Workplace;
+
+		public WMPart(ReferenceRecord rr)
+		{
+			Name = rr.Workstep.ReferencePart.Name;
+            Process = rr.Process;
+            OraDBType = rr.Workstep.ReferencePart.OraDBType;
+            Description = rr.Workstep.ReferencePart.Description;
+			Code = rr.Code;
+			TimeStamp = rr.TimeStamp;
+			CodeType = rr.Workstep.ReferencePart.CodeType;
+			CodeForm = rr.Workstep.ReferencePart.CodeForm;
+			CodeLocation = rr.Workstep.ReferencePart.CodeLocation;
+			UserName = rr.UserName;
+			Workplace = rr.Workplace;
+		}
+
+		public WMPart(Record r)
+		{
+			Name = r.Part.Name;
+            Process = r.Part.Process;
+            OraDBType = r.Part.OraDBType;
+			Description = r.Part.Description;
+			Code = r.Code;
+			TimeStamp = r.TimeStamp;
+			CodeType = r.Part.CodeType;
+			CodeForm = r.Part.CodeForm;
+			CodeLocation = r.Part.CodeLocation;
+			UserName = r.ReferenceRecord.UserName;
+			Workplace = r.ReferenceRecord.Workplace;
+		}
+	}
+}

MonitoringDB/app.config

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="NHibernate" publicKeyToken="aa95f207798dfdb4" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.0.4000" newVersion="4.0.0.4000" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Iesi.Collections" publicKeyToken="aa95f207798dfdb4" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.0.0" newVersion="4.0.0.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+</configuration>

MonitoringDB/packages.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="FluentNHibernate" version="2.0.3.0" targetFramework="net40" />
+  <package id="Iesi.Collections" version="4.0.0.4000" targetFramework="net40" />
+  <package id="NHibernate" version="4.0.4.4000" targetFramework="net40" />
+</packages>

Results/DB.cs

@@ -21,12 +21,19 @@ namespace Results
 		public static ISessionFactory SessionFactory;
 
 		/// <summary> Connection string for all sessions </summary>
-		private static string connectionString;
+		static string connectionString;
 		/// 
 		public static string ConnectionString
 		{
 			get { return connectionString; }
-			set { connectionString = value; SessionFactory = null; }
+            set
+            {
+                if (value != connectionString)
+                {
+                    connectionString = value;
+                    SessionFactory = null;          /// Clear SessionFactory on connection string change
+                }
+            }
 		}
 
 		/// <summary> Database type (MySQL or SQLite) for all sessions </summary>
@@ -289,13 +296,13 @@ namespace Results
 			ISession session = DB.CreateSession();
 			if (session == null) return null;
 
-			TestDataList = session.QueryOver<TestData>().List();
-			ComponentsList = session.QueryOver<Components>().List();
-			WaterMeterDataList = session.QueryOver<WaterMeterData>().List();
-
 			try
 			{
-				batches = session.QueryOver<Batch>()
+                TestDataList = session.QueryOver<TestData>().List();
+                ComponentsList = session.QueryOver<Components>().List();
+                WaterMeterDataList = session.QueryOver<WaterMeterData>().List();
+
+                batches = session.QueryOver<Batch>()
 								 .Where(x => (x.BatchNr == batchNr))
 								 .List();
 
@@ -308,14 +315,14 @@ namespace Results
                                                .Where(x => (x.Batch.Id == batch.Id))
                                                .List();
                 }
-			}
+
+                return (batches.Count > 0) ? batches[0] : null;
+            }
 			catch (Exception exc)
 			{
 				log.FatalFormat("Cannot load batch #{0}: {1}", batchNr, exc.Message);
 				return null;
 			}
-
-			return (batches.Count > 0) ? batches[0] : null;
 		}
 	}
 }

Results/Entities/Batch.cs

@@ -107,13 +107,61 @@ namespace Results.Entities
             return (timeSum == 0) ? 0 : (sum / timeSum);
         }
 
-        public virtual double AmbTempStart() { return (TestRslts.Count > 0) ? TestRslts[0].AmbTempStart : 0; }
-        public virtual double AmbPressStart() { return (TestRslts.Count > 0) ? TestRslts[0].AmbPressStart : 0; }
-        public virtual double AmbHumiStart() { return (TestRslts.Count > 0) ? TestRslts[0].AmbHumiStart : 0; }
+        public virtual double AmbTempStart()
+        {
+            for (int i = 0; i < TestRslts.Count; i++)
+            {
+                if (TestRslts[i].Publish() == Config.Entities.Publish.Always)
+                    return TestRslts[i].AmbTempStart;
+            }
+            return 0;
+        }
+        public virtual double AmbPressStart()
+        {
+            for (int i = 0; i < TestRslts.Count; i++)
+            {
+                if (TestRslts[i].Publish() == Config.Entities.Publish.Always)
+                    return TestRslts[i].AmbPressStart;
+            }
+            return 0;
+        }
+        public virtual double AmbHumiStart()
+        {
+            for (int i = 0; i < TestRslts.Count; i++)
+            {
+                if (TestRslts[i].Publish() == Config.Entities.Publish.Always)
+                    return TestRslts[i].AmbHumiStart;
+            }
+            return 0;
+        }
 
-        public virtual double AmbTempEnd() { return (TestRslts.Count > 0) ? TestRslts[TestRslts.Count - 1].AmbTempEnd : 0; }
-        public virtual double AmbPressEnd() { return (TestRslts.Count > 0) ? TestRslts[TestRslts.Count - 1].AmbPressEnd : 0; }
-        public virtual double AmbHumiEnd() { return (TestRslts.Count > 0) ? TestRslts[TestRslts.Count - 1].AmbHumiEnd : 0; }
+        public virtual double AmbTempEnd()
+        {
+            for (int i = TestRslts.Count - 1; i >= 0; i++)
+            {
+                if (TestRslts[i].Publish() == Config.Entities.Publish.Always)
+                    return TestRslts[i].AmbTempEnd;
+            }
+            return 0;
+        }
+        public virtual double AmbPressEnd()
+        {
+            for (int i = TestRslts.Count - 1; i >= 0; i++)
+            {
+                if (TestRslts[i].Publish() == Config.Entities.Publish.Always)
+                    return TestRslts[i].AmbPressEnd;
+            }
+            return 0;
+        }
+        public virtual double AmbHumiEnd()
+        {
+            for (int i = TestRslts.Count - 1; i >= 0; i++)
+            {
+                if (TestRslts[i].Publish() == Config.Entities.Publish.Always)
+                    return TestRslts[i].AmbHumiEnd;
+            }
+            return 0;
+        }
 
         public virtual double Buoyancy()
         {

Results/Entities/MeterTestRslt.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2016 Sensus Metering Systems
+/// Copyright (c) 2013-2018 Sensus Slovensko a.s.
 ///
 using System;
 
@@ -10,6 +10,8 @@ namespace Results.Entities
         public virtual int Id { get; protected set; }
 
 		public virtual byte   CompoundMeterId { get; set; }		/// 0=single, 1=compound/main, 2=compound/aux., 3=compound/overal, 4=heat meter volume, 5=heat meter energy
+        public virtual int    RegReaderType   { get; set; }     /// Not mapped to the DB, does not depent on localisation and customer
+                                                                
 		public virtual double PulsesMeter     { get; set; }		/// # of water meter or heat meter pulses
 		public virtual double PulsesMaster	  { get; set; }		/// # of reference flowmeter pulses (gated by this water meter pulses)
         public virtual double PulsesPerLiter  { get; set; }		/// [l ^ -1], in case of heat meters (CompoundMeterId==5) pulses per kWh in [kWh ^ -1]
@@ -38,7 +40,7 @@ namespace Results.Entities
 		public virtual double   FlowMass()    { return TestRslt.FlowMass; }			/// [kg/h]
 		public virtual double   FlowVolume()  { return TestRslt.FlowVolume; }		/// [m3/h]
 		public virtual double   ErrorMaster() { return TestRslt.ErrorMaster; }		/// [%]
-		public virtual double   DensityOut()  { return TestRslt.DensityOut; }
+		public virtual double   DensityLine() { return TestRslt.DensityLine; }
 		public virtual Components Components(){ return TestRslt.Components; }
 		/// 
 		public virtual TestData TestData()    { return TestRslt.TestData; }
@@ -73,6 +75,11 @@ namespace Results.Entities
 					(CompoundMeterId == (byte)Config.Entities.CompoundMeterId.HeatMeterEnergy);
 		}
 
+        public virtual bool IsPulses() { return (RegReaderType == (int)Config.Entities.RegisterReaderType.Pulses || RegReaderType == (int)Config.Entities.RegisterReaderType.Unknown); }
+        public virtual bool IsCamera() { return (RegReaderType == (int)Config.Entities.RegisterReaderType.Camera); }
+        public virtual bool IsDataStream() { return (RegReaderType == (int)Config.Entities.RegisterReaderType.DataStream); }
+        public virtual bool IsManual() { return (RegReaderType == (int)Config.Entities.RegisterReaderType.Manual); }
+
 		public virtual string PassedColorStr()
         {
             return Utils.PassedColorStr(Passed, Evaluate());
@@ -96,6 +103,8 @@ namespace Results.Entities
         {
             if (src == null) return;
 
+            CompoundMeterId = src.CompoundMeterId;
+            RegReaderType = src.RegReaderType;
 		    PulsesMeter = src.PulsesMeter;
 		    PulsesMaster = src.PulsesMaster;
             PulsesPerLiter = src.PulsesPerLiter;

Results/Entities/TestRslt.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2015-2017 Sensus Metering Systems
+/// Copyright (c) 2015-2018 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
@@ -14,24 +14,26 @@ namespace Results.Entities
 		public virtual Batch Batch { get; set; }
 		public virtual TestData TestData { get; set; }
 		public virtual Components Components { get; set; }
-		public virtual int Part { get; set; }
+        public virtual int Part { get; set; }
 		public virtual int RepetitionNr { get; set; }       /// Repetition number from the set of repeated tests (1...)
+        public virtual string MethodClass { get; set; }     /// Not mapped to the DB, does not depent on localisation and customer
 
 		/// Main results
 		public virtual bool TestDone { get; set; }
-		public virtual string Remark { get; set; }
+        public virtual string Remark { get; set; }
 		public virtual DateTime StartTime { get; set; }     /// Date and time of the test start
 		public virtual DateTime EndTime { get; set; }       /// Date and time of the test end
 		public virtual int FlowSetTime { get; set; }        /// [s]     Measurement time in seconds
 		public virtual double TestTime { get; set; }        /// [s]     Measurement time in seconds
 		public virtual double PulsesMaster { get; set; }
-		public virtual double ConstMaster { get; set; }     /// [pls/l] Pulses per liter master flow meter
-		public virtual double MassStartRaw { get; set; }	/// [kg]
+        public virtual double ConstMasterRaw { get; set; }  /// [l/pls] Liters per pulse of the master flow meter uncorrected
+        public virtual double ConstMaster { get; set; }     /// [l/pls] Liters per pulse of the master flow meter
+        public virtual double MassStartRaw { get; set; }	/// [kg]
 		public virtual double MassStart { get; set; }		/// [kg]
 		public virtual double MassEndRaw { get; set; }		/// [kg]
 		public virtual double MassEnd { get; set; }			/// [kg]
 		public virtual double DensityIn { get; set; }		/// [kg/m3]
-		public virtual double DensityOut { get; set; }		/// [kg/m3]
+		public virtual double DensityLine { get; set; }		/// [kg/m3]
 		public virtual double DensityDiv { get; set; }		/// [kg/m3]
 		public virtual double Buoyancy { get; set; }
 		public virtual double FlowMass { get; set; }        /// [kg/h] calculated from conventional true value
@@ -109,7 +111,7 @@ namespace Results.Entities
         public virtual float FlowMax { get; set; }			/// [m3/h] 
 
         public virtual float Custom1  { get; set; }			/// [°C] T ref hi mean
-		public virtual float Custom2  { get; set; }			/// [°C] T ref hi start			
+		public virtual float Custom2  { get; set; }			/// [°C] T ref hi start
 		public virtual float Custom3  { get; set; }			/// [°C] T ref hi end
 		public virtual float Custom4  { get; set; }			/// [°C] T ref hi min
 		public virtual float Custom5  { get; set; }			/// [°C] T ref hi max
@@ -127,6 +129,10 @@ namespace Results.Entities
 		public virtual double TargetVolume() { return TestData.TargetVolume; }
 		public virtual double TargetTime()	 { return TestData.TargetTime; }
 		public virtual string Method()		 { return TestData.Method; }
+        public virtual bool IsRelErrTest()   { return (MethodClass != null) ? (MethodClass.Contains("FixedStart") || MethodClass.Contains("FlyingStart") || MethodClass.Contains("CombinedWithDetection")) : true; }
+        public virtual bool IsPMaxTest()     { return (MethodClass != null) ? (MethodClass.Contains("PMaxTest") || MethodClass.Contains("LeakTest")) : true; }
+        public virtual bool IsStartStop()    { return (MethodClass != null) ? MethodClass.Contains("FixedStart") : true; }
+        public virtual bool IsDiverter()     { return (MethodClass != null) ? (MethodClass.Contains("FlyingStart") && MethodClass.Contains("MassColl")) : true; }
 
 		public virtual double ErrLimLo()
         {
@@ -203,20 +209,22 @@ namespace Results.Entities
 		    Components = src.Components;    /// ???
 		    Part = src.Part;
 		    RepetitionNr = src.RepetitionNr;
-			TestDone = src.TestDone;
+            MethodClass = src.MethodClass;
+            TestDone = src.TestDone;
 			Remark = src.Remark;
 		    StartTime = src.StartTime;
 		    EndTime = src.EndTime;
 		    FlowSetTime = src.FlowSetTime;
 		    TestTime = src.TestTime;
 		    PulsesMaster = src.PulsesMaster;
+            ConstMasterRaw = src.ConstMasterRaw;
 		    ConstMaster = src.ConstMaster;
 		    MassStartRaw = src.MassStartRaw;
 		    MassStart = src.MassStart;
 		    MassEndRaw = src.MassEndRaw;
 		    MassEnd = src.MassEnd;
 		    DensityIn = src.DensityIn;
-		    DensityOut = src.DensityOut;
+		    DensityLine = src.DensityLine;
 		    DensityDiv = src.DensityDiv;
 		    Buoyancy = src.Buoyancy;
 		    FlowMass = src.FlowMass;
@@ -300,7 +308,12 @@ namespace Results.Entities
         /// <summary> Wrapper </summary>
         public virtual string ErrorFlagsStr()
         {
-            return Utils.ErrorFlagsStr(ErrorFlags);
+            string eFlags = Utils.ErrorFlagsStr(ErrorFlags);
+#if LANG_PL
+            return string.IsNullOrEmpty(eFlags) ? "brak" : eFlags;
+#else
+            return eFlags;
+#endif
         }
 
         public override string ToString()
@@ -313,7 +326,7 @@ namespace Results.Entities
 			return string.Format("TestRslt: Part={0} RepetitionNr={1} TestDone={2} Remark={3} StartTime={4} EndTime={5} FlowSetTime={6} TestTime={7} PulsesMaster={8} ConstMaster={9} MassStartRaw={10} MassStart={11} MassEndRaw={12} MassEnd={13} DensityIn={14} DensityOut={15} DensityDiv={16} Buoyancy={17} FlowMass={18} FlowVolume={19} VolumeCTV={20} VolumeMaster={21} ErrorMaster={22} DiverterStart={85} DiverterEnd={86} ErrorFlags={23} ErrorFlagsMd={24} AmbTempMean={25} AmbTempStart={26} AmbTempEnd={27} AmbTempMin={28} AmbTempMax={29} AmbPressMean={30} AmbPressStart={31} AmbPressEnd={32} AmbPressMin={33}  AmbPressMax={34} AmbHumiMean={35} AmbHumiStart={36} AmbHumiEnd={37} AmbHumiMin={38} AmbHumiMax={39} PressUpMean={40} PressUpStart={41} PressUpEnd={42} PressUpMin={43} PressUpMax={44} PressDownMean={45} PressDownStart={46} PressDownEnd={47} PressDownMin={48} PressDownMax={49} PressDeltaMean={50} PressDeltaStart={51} PressDeltaEnd={52} PressDeltaMin={53} PressDeltaMax={54} TempUpMean={55} TempUpStart={56} TempUpEnd={57} TempUpMin={58} TempUpMax={59} TempDownMean={60} TempDownStart={61} TempDownEnd={62} TempDownMin={63} TempDownMax={64} TempDivMean={65} TempDivStart={66} TempDivEnd={67} TempDivMin={68} TempDivMax={69} FlowMean={70} FlowStart={71} FlowEnd={72} FlowMin={73} FlowMax={74} Custom1={75} Custom2={76} Custom3={77} Custom4={78} Custom5={79} Custom6={80} Custom7={81} Custom8={82} Custom9={83} Custom10={84}", 
 								Part, RepetitionNr, TestDone, Remark, StartTime, EndTime, FlowSetTime, TestTime,
 								PulsesMaster, ConstMaster, MassStartRaw, MassStart, MassEndRaw, MassEnd,
-								DensityIn, DensityOut, DensityDiv, Buoyancy, FlowMass, FlowVolume,
+								DensityIn, DensityLine, DensityDiv, Buoyancy, FlowMass, FlowVolume,
 								VolumeCTV, VolumeMaster, ErrorMaster, ErrorFlags, ErrorFlagsMd, 
 								AmbTempMean, AmbTempStart, AmbTempEnd, AmbTempMin, AmbTempMax,
 								AmbPressMean, AmbPressStart, AmbPressEnd, AmbPressMin, AmbPressMax,

Results/Entities/WaterMeter.cs

@@ -130,10 +130,48 @@ namespace Results.Entities
             return (errorFlagsMode != ErrorFlagsMode.Off) ? (eFlagsFromTests | ErrorFlags) : 0;
         }
 
-        public virtual string ErrorFlagstStr()
+        /// <summary>
+        /// Convert combined errorFlags of all tests to string
+        /// </summary>
+        /// <returns>ErrorFlags string</returns>
+        public virtual string ErrorFlagsStr()
         {
             ErrorFlagsMode errorFlagsMode;
-            return Utils.ErrorFlagsStr(ErrorFlagsFromTestsAndWM(out errorFlagsMode));
+            string eFlags = Utils.ErrorFlagsStr(ErrorFlagsFromTestsAndWM(out errorFlagsMode));
+#if LANG_PL
+            return string.IsNullOrEmpty(eFlags) ? "brak" : eFlags;
+#else
+            return eFlags;
+#endif      
+        }
+
+        public virtual string PassedOrErrorFlagsStr()
+        {
+            ErrorFlagsMode errorFlagsMode;
+            string eFlags = Utils.ErrorFlagsStr(ErrorFlagsFromTestsAndWM(out errorFlagsMode));
+            return string.IsNullOrEmpty(eFlags) ? (WaterMeterData.Text4 + PassedColorStr()) : eFlags;
+        }
+
+        /// <summary>
+        /// Convert failed tests and combined errorFlags of all tests to string
+        /// </summary>
+        /// <returns>ErrorFlagsEx string</returns>
+        public virtual string ErrorFlagsStrEx()
+        {
+            StringBuilder errFlgsStr = new StringBuilder();
+            foreach (var mtr in MeterTestRslts)
+            {
+                if (mtr.Evaluate() && mtr.TestDone && !mtr.Passed)
+                {
+                    errFlgsStr.Append(mtr.Name());
+                    errFlgsStr.Append(" ");
+                }
+            }
+
+            ErrorFlagsMode errorFlagsMode;
+            errFlgsStr.Append(Utils.ErrorFlagsStr(ErrorFlagsFromTestsAndWM(out errorFlagsMode)));
+
+            return errFlgsStr.ToString();
         }
 
         public virtual bool  PassedFromTests()
@@ -177,6 +215,8 @@ namespace Results.Entities
         }
 
 
+
+
 		///
 		/// Not mapped to the database
 		///

Results/Entities/WaterMeterData.cs

@@ -41,6 +41,8 @@ namespace Results.Entities
         public virtual string MetrologicalClassAux { get; set; }
         public virtual string ApprovalInfoAux { get; set; }
 
+        public virtual Config.Entities.Medium Medium { get; set; }
+
         public virtual string Text1 { get; set; }
         public virtual string Text2 { get; set; }
         public virtual string Text3 { get; set; }
@@ -96,6 +98,8 @@ namespace Results.Entities
             if (MetrologicalClassAux != wmd.MetrologicalClassAux) return false;
             if (ApprovalInfoAux != wmd.ApprovalInfoAux) return false;
 
+            if (Medium != wmd.Medium) return false;
+
             if (Text1 != wmd.Text1) return false;
             if (Text2 != wmd.Text2) return false;
             if (Text3 != wmd.Text3) return false;

Results/Forms/BatchResultsDlg.cs

@@ -150,17 +150,17 @@ namespace Results.Forms
                 {
                     if (results.WaterMeters[i] != null && !results.WaterMeters[i].Disabled)
                     {
-                        if (TestsArrangement == TestsArrangement.Rows)
+                        ListView lview = (TestsArrangement == TestsArrangement.Rows)
+                                       ? GetResultsTestsAreRows(results.WaterMeters[i], i + 1)
+                                       : GetResultsTestsAreColumns(results.WaterMeters[i], i + 1);
+                        if (lview != null)
                         {
-                            ListView lview = GetResultsTestsAreRows(results.WaterMeters[i], i + 1);
-                            if (first) { firstListView = lview; first = false; }
-                            if (lview != null) flowLayoutPanel.Controls.Add(lview);
-                        }
-                        else
-                        {
-                            ListView lview = GetResultsTestsAreColumns(results.WaterMeters[i], i + 1);
-                            if (first) { firstListView = lview; first = false; }
-                            if (lview != null) flowLayoutPanel.Controls.Add(lview);
+                            flowLayoutPanel.Controls.Add(lview);
+                            if (first)
+                            {
+                                firstListView = lview;
+                                first = false;
+                            }
                         }
                     }
                 }
@@ -318,7 +318,7 @@ namespace Results.Forms
                     if (mtr != null && mtr.IsPilotRslt() && mtr.TestDone && mtr.Publish() != Config.Entities.Publish.Never &&
 																			mtr.Publish() != Config.Entities.Publish.Internal)
                     {
-                        string str = items[i].Print(wMtr, mtr.Name());
+                        string str = item.Print(wMtr, mtr.Name());
 
                         string[] texts = str.Split(new char[] { '|' });
                         if (texts.Length == 1)

Results/ItemID.cs

@@ -56,7 +56,7 @@ namespace Results
         Flow_profile_sensitivity_class, /// 46
         Approval_info,                  /// 47
         Certificate,                    /// 48
-        Pulses_per_liter,               /// 49
+        Pulses_per_liter,               /// 49  Water meter constant (water meter data, not used in calculations)
         Text1,                          /// 50
         Text2,                          /// 51
         Text3,                          /// 52
@@ -68,8 +68,8 @@ namespace Results
         WM_Position,                    /// 58
         End_state,                      /// 59
         Pulses,                         /// 60
-        Pulses__liter,                  /// 61
-        Reference_pulses,               /// 62
+        Pulse__liter,                   /// 61  Water meter constant (pulses per liter) specific for one test
+        Reference_pulses_ni,            /// 62  Reference pulses gated for specific meter (synchro method)
         Reference_energy,				/// 63
         Test_bench_ID,                  /// 64
         Program_version,                /// 65
@@ -211,6 +211,46 @@ namespace Results
 
         Formatted_WM_ID,                /// 184, Formated WM ID string:
                                         ///      {0}=start DateTime {1}-end DateTime, {2}=batch nr., {3}=wm pos.(1..max), {4}=s/n string
+        E21,							/// 185
+
+        T_line_mean,					/// 186
+        T_line_start,					/// 187
+        T_line_end,						/// 188
+        T_line_avg,						/// 189
+        T_line_min,					    /// 190
+        T_line_max,					    /// 191
+
+        ErrorFlagsEx,                   /// 192
+        RhoDistilledWtrAtMeLineTemp,    /// 193
+        ConstMaster,                    /// 194
+        Reference_pulses,               /// 195  Reference pulses not gated
+        spare,
+        Separator,                      /// 197
+        Test_time_ni,                   /// 198  Test time for a specific meter (gated in case of a synchro method OR a difference of 2 time stamps)
+        PMax_test_time,                 /// 199  Pressure test time
+        Start_valve_open_time,          /// 200
+        Start_valve_close_time,         /// 201
+        Qc,                             /// 202  Flow for a water meter
+        Degree__liter,                  /// 203  Water meter constant (degree per liter) specific for one test with camera
+        Camera_angle,                   /// 204
+        Camera_angle_start,             /// 205
+        Camera_angle_end,               /// 206
+
+        P_delta_mean_per_mtr,               /// 207
+        P_delta_mean_from_up_down,          /// 208
+        P_delta_mean_from_up_down_per_mtr,  /// 209
+        Timestamp_start,                    /// 210
+        Timestamp_end,                      /// 211
+        P_PMax_test_mean,                   /// 212  PMax test pressure mean of (Pup + Pdown)/2
+
+        Medium,                         /// 213  Woda zimna/ciepla
+
+        Flow_ctv,                       /// 214
+        Flow_ctv_min,                   /// 215
+        Flow_ctv_max,                   /// 216
+        Flow_ctv_start,                 /// 217
+        Flow_ctv_end,                   /// 218
+        ConstMasterRaw,                 /// 219  ConstMaster (like 194) uncorrected
 
         Count,
     }

Results/ItemSpec.cs

@@ -1,244 +0,0 @@
-///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
-///
-using System;
-using System.Collections.Generic;
-using Results.Entities;
-using Results.Resources;
-
-namespace Results
-{
-	public class ItemSpec
-	{
-		///
-		/// Public fields
-		///
-		public readonly string Name;			/// Name-s of all items must be unique
-		public readonly string ClmnHeaderText;	/// Text printed in the column header
-
-
-		///
-		/// Function to pick a MeterTestResult field and convert it into a string
-		/// 
-		public delegate string PrintDlgt(MeterTestRslt meterTestRslt);
-
-		///
-		/// Function to pick a MeterTestResult field and convert it into a string
-		///
-		public delegate string PrintCompoundDlgt(MeterTestRslt mainMtrTestResult,
-												 MeterTestRslt auxMtrTestResult,
-												 MeterTestRslt compoundMtrTestResult);
-
-		///
-		/// Function to pick a MeterTestResult field and convert it into a string
-		///
-		public delegate string PrintHeatMeterDlgt(MeterTestRslt volumeTestResult,
-												  MeterTestRslt energyTestResult);
-
-		private readonly PrintDlgt printDlgt;
-		private readonly PrintCompoundDlgt printCompoundDlgt;
-		private readonly PrintHeatMeterDlgt printHeatMeterDlgt;
-
-		public bool CanPrintSingle        { get { return (printDlgt != null); } }
-		public bool CanPrintCompoundMeter { get { return (printCompoundDlgt != null); } }
-		public bool CanPrintHeatMeter     { get { return (printHeatMeterDlgt != null); } }
-
-		/// <summary> Safe wrapper which replaces null-s by empty strings </summary>
-		public string Print(MeterTestRslt meterTestRslt)
-		{
-            string str = null;
-            if (printDlgt != null) str = printDlgt(meterTestRslt);
-			return (str == null) ? string.Empty : str;
-		}
-
-		/// <summary> Safe wrapper which replaces null-s by empty strings </summary>
-		public string PrintCombined(MeterTestRslt mainMtrTestResult,
-									MeterTestRslt auxMtrTestResult,
-									MeterTestRslt compoundMtrTestResult)
-		{
-            string str = null;
-            if (printCompoundDlgt != null) str = printCompoundDlgt(mainMtrTestResult, auxMtrTestResult, compoundMtrTestResult);
-			return (str == null) ? string.Empty : str;
-		}
-
-		/// <summary> Safe wrapper which replaces null-s by empty strings </summary>
-		public string PrintHeatMeter(MeterTestRslt volumeTestResult,
-									 MeterTestRslt energyTestResult)
-		{
-            string str = null;
-            if (printHeatMeterDlgt != null) str = printHeatMeterDlgt(volumeTestResult, energyTestResult);
-			return (str == null) ? string.Empty : str;
-		}
-
-
-		///
-		/// Public constructor
-		///
-		public ItemSpec(string name, string clmnHeaderText, PrintDlgt printDlgt, PrintCompoundDlgt printCombinedDlgt, PrintHeatMeterDlgt printHeatMeterDlgt)
-		{
-			Name = name;
-			ClmnHeaderText = clmnHeaderText;
-			this.printDlgt = printDlgt;
-			this.printCompoundDlgt = printCombinedDlgt;
-			this.printHeatMeterDlgt = printHeatMeterDlgt;
-		}
-
-
-		/// Static list of all available items
-		public static readonly IList<ItemSpec> AllItems;
-
-		/// Static constructor that initializes the list of all items
-		static ItemSpec()
-		{
-			AllItems = new List<ItemSpec>();
-
-			/// Common
-		
-			//AllItems.Add(new ResultItemSpec("Bench ID",   "Bench ID",              x => x.BenchID,                                (x, y, z) => x.BenchID));
-			AllItems.Add(new ItemSpec("Test name", Strings.Test, x => x.Name(), (x, y, z) => z.Name(), (x, z) => z.Name()));
-			AllItems.Add(new ItemSpec("Procedure name", Strings.Procedure, x => x.ProcedureName(), (x, y, z) => z.ProcedureName(), (x, z) => z.ProcedureName()));
-			AllItems.Add(new ItemSpec("Batch number", Strings.Batch_nr, x => x.BatchNr().ToString(), (x, y, z) => z.BatchNr().ToString(), (x, z) => z.BatchNr().ToString()));
-			AllItems.Add(new ItemSpec("Test method", Strings.Test_method, x => x.Method(), (x, y, z) => z.Method(), (x, z) => z.Method()));
-			AllItems.Add(new ItemSpec("Density", Strings.Density, x => x.DensityOut().ToString("F1"), (x, y, z) => z.DensityOut().ToString("F1"), (x, z) => z.DensityOut().ToString("F1")));	/// [kg/m3]
-
-			/// Target values
-			AllItems.Add(new ItemSpec("Q from", Strings.Q_from + " [m3/h]", x => x.Qfrom().ToString("F3"), (x, y, z) => z.Qfrom().ToString("F3"), (x, z) => z.Qfrom().ToString("F3")));
-			AllItems.Add(new ItemSpec("Q to", Strings.Q_to + " [m3/h]", x => x.Qto().ToString("F3"), (x, y, z) => z.Qto().ToString("F3"), (x, z) => z.Qto().ToString("F3")));
-			AllItems.Add(new ItemSpec("Test volume", Strings.Test_vol + " [l]", x => x.TargetVolume().ToString("F1"), (x, y, z) => z.TargetVolume().ToString("F1"), (x, z) => z.TargetVolume().ToString("F1")));
-			AllItems.Add(new ItemSpec("Error limit Lo", Strings.ErrLimLo + " [%]", x => x.ErrLimLo().ToString("F1"), (x, y, z) => z.ErrLimLo().ToString("F1"), (x, z) => z.ErrLimLo().ToString("F1")));
-			AllItems.Add(new ItemSpec("Error limit Hi", Strings.ErrLimHi + " [%]", x => x.ErrLimHi().ToString("F1"), (x, y, z) => z.ErrLimHi().ToString("F1"), (x, z) => z.ErrLimHi().ToString("F1")));
-			AllItems.Add(new ItemSpec("Uncertainty", Strings.Uncertainty + " [%]", x => x.Uncertainty().ToString("F2"), (x, y, z) => z.Uncertainty().ToString("F2"), (x, z) => z.Uncertainty().ToString("F2")));
-
-			/// Test results
-			AllItems.Add(new ItemSpec("Test start time", Strings.T_start, x => x.StartTime().ToShortTimeString(), (x, y, z) => z.StartTime().ToShortTimeString(), (x, z) => z.StartTime().ToShortTimeString()));
-			AllItems.Add(new ItemSpec("Test end time", Strings.T_end, x => x.EndTime().ToShortTimeString(), (x, y, z) => z.EndTime().ToShortTimeString(), (x, z) => z.EndTime().ToShortTimeString()));
-			AllItems.Add(new ItemSpec("Test time", Strings.T_s, x => x.TestTime.ToString("F2"), (x, y, z) => z.TestTime.ToString("F2"), (x, z) => z.TestTime.ToString("F2")));
-			AllItems.Add(new ItemSpec("Flow", Strings.Flow + " [m3/h]", x => Utils.DoubleToStr(x.FlowVolume(), 4), (x, y, z) => Utils.DoubleToStr(z.FlowVolume(), 4), (x, z) => Utils.DoubleToStr(x.FlowVolume(), 4)));
-			AllItems.Add(new ItemSpec("T in", Strings.T_in + " [°C]", x => x.TestRslt.TempUpMean.ToString("F2"), (x, y, z) => z.TestRslt.TempUpMean.ToString("F2"), (x, z) => z.TestRslt.TempUpMean.ToString("F2")));
-			AllItems.Add(new ItemSpec("T out", Strings.T_out + " [°C]", x => x.TestRslt.TempDownMean.ToString("F2"), (x, y, z) => z.TestRslt.TempDownMean.ToString("F2"), (x, z) => z.TestRslt.TempDownMean.ToString("F2")));
-			AllItems.Add(new ItemSpec("T div", Strings.T_div + " [°C]", x => x.TestRslt.TempDivMean.ToString("F2"), (x, y, z) => z.TestRslt.TempDivMean.ToString("F2"), (x, z) => z.TestRslt.TempDivMean.ToString("F2")));
-			AllItems.Add(new ItemSpec("P up", Strings.P_up + " [kPa]", x => (100 * x.TestRslt.PressUpMean).ToString("F3"), (x, y, z) => z.TestRslt.PressUpMean.ToString("F3"), (x, z) => z.TestRslt.PressUpMean.ToString("F3")));
-			AllItems.Add(new ItemSpec("P up start", Strings.P_up_start + " [kPa]", x => (100 * x.TestRslt.PressUpStart).ToString("F3"), (x, y, z) => z.TestRslt.PressUpStart.ToString("F3"), (x, z) => z.TestRslt.PressUpStart.ToString("F3")));
-			AllItems.Add(new ItemSpec("P up end", Strings.P_up_end + " [kPa]", x => (100 * x.TestRslt.PressUpEnd).ToString("F3"), (x, y, z) => z.TestRslt.PressUpEnd.ToString("F3"), (x, z) => z.TestRslt.PressUpEnd.ToString("F3")));
-			AllItems.Add(new ItemSpec("P down", Strings.P_dn + " [kPa]", x => (100 * x.TestRslt.PressDownMean).ToString("F3"), (x, y, z) => z.TestRslt.PressDownMean.ToString("F3"), (x, z) => z.TestRslt.PressDownMean.ToString("F3")));
-			AllItems.Add(new ItemSpec("P down start", Strings.P_dn_start + " [kPa]", x => (100 * x.TestRslt.PressDownStart).ToString("F3"), (x, y, z) => z.TestRslt.PressDownStart.ToString("F3"), (x, z) => z.TestRslt.PressDownStart.ToString("F3")));
-			AllItems.Add(new ItemSpec("P down end", Strings.P_dn_end + " [kPa]", x => (100 * x.TestRslt.PressDownEnd).ToString("F3"), (x, y, z) => z.TestRslt.PressDownEnd.ToString("F3"), (x, z) => z.TestRslt.PressDownEnd.ToString("F3")));
-			AllItems.Add(new ItemSpec("P delta", Strings.P_delta + " [kPa]", x => (100 * x.TestRslt.PressDeltaMean).ToString("F3"), (x, y, z) => z.TestRslt.PressDeltaMean.ToString("F3"), (x, z) => z.TestRslt.PressDeltaMean.ToString("F3")));
-			AllItems.Add(new ItemSpec("P delta start", Strings.P_delta_start + " [kPa]", x => (100 * x.TestRslt.PressDeltaStart).ToString("F3"), (x, y, z) => z.TestRslt.PressDeltaStart.ToString("F3"), (x, z) => z.TestRslt.PressDeltaStart.ToString("F3")));
-			AllItems.Add(new ItemSpec("P delta end", Strings.P_delta_end + " [kPa]", x => (100 * x.TestRslt.PressDeltaEnd).ToString("F3"), (x, y, z) => z.TestRslt.PressDeltaEnd.ToString("F3"), (x, z) => z.TestRslt.PressDeltaEnd.ToString("F3")));
-			AllItems.Add(new ItemSpec("Reference error", Strings.ErrRef + " [%]", x => x.TestRslt.ErrorMaster.ToString("F3"), (x, y, z) => z.TestRslt.ErrorMaster.ToString("F3"), (x, z) => z.TestRslt.ErrorMaster.ToString("F3")));
-			AllItems.Add(new ItemSpec("Ambient temperature", Strings.T_amb + " [°C]", x => x.TestRslt.AmbTempMean.ToString("F1"), (x, y, z) => z.TestRslt.AmbTempMean.ToString("F1"), (x, z) => z.TestRslt.AmbTempMean.ToString("F1")));
-			AllItems.Add(new ItemSpec("Ambient pressure", Strings.P_amb + " [mbar]", x => (1000 * x.TestRslt.AmbPressMean).ToString("F0"), (x, y, z) => (1000 * z.TestRslt.AmbPressMean).ToString("F0"), (x, z) => (1000 * z.TestRslt.AmbPressMean).ToString("F0")));
-			AllItems.Add(new ItemSpec("Ambient humidity", Strings.H_amb + " [%]", x => x.TestRslt.AmbHumiMean.ToString("F1"), (x, y, z) => z.TestRslt.AmbHumiMean.ToString("F1"), (x, z) => z.TestRslt.AmbHumiMean.ToString("F1")));
-
-			/// Single and combined meter results
-			AllItems.Add(new ItemSpec("Start volume", Strings.Start_volume + " [l]",  x => x.VolumeStart.ToString("F3"), (x, y, z) => z.VolumeStart.ToString("F3"), (x, z) => z.VolumeStart.ToString("F3")));
-			AllItems.Add(new ItemSpec("End volume", Strings.End_volume + " [l]", x => x.VolumeEnd.ToString("F3"), (x, y, z) => z.VolumeEnd.ToString("F3"), (x, z) => z.VolumeEnd.ToString("F3")));
-			AllItems.Add(new ItemSpec("Volume", Strings.Volume + " [l]", x => x.VolumeMeter.ToString("F3"), (x, y, z) => z.VolumeMeter.ToString("F3"), (x, z) => x.VolumeMeter.ToString("F3")));
-			AllItems.Add(new ItemSpec("Reference volume", Strings.VolRef + " [l]", x => x.VolumeRef.ToString("F3"), (x, y, z) => z.VolumeRef.ToString("F3"), (x, z) => x.VolumeRef.ToString("F3")));
-			AllItems.Add(new ItemSpec("Error", Strings.Error + " [%]", x => x.Error.ToString("F2"), (x, y, z) => z.Error.ToString("F2"), null));
-			AllItems.Add(new ItemSpec("Passed", Strings.Result, x => x.PassedColorStr(), (x, y, z) => z.PassedColorStr(), null));
-			AllItems.Add(new ItemSpec("Volume Error", "Volume Error" + " [%]", null, null, (x, z) => x.Error.ToString("F2")));
-			AllItems.Add(new ItemSpec("Volume Passed", "Volume Passed", null, null, (x, z) => x.PassedColorStr()));
-			AllItems.Add(new ItemSpec("Energy Error", "Energy Error" + " [%]", null, null, (x, z) => z.Error.ToString("F2")));
-			AllItems.Add(new ItemSpec("Energy Passed", "Energy Passed", null, null, (x, z) => z.PassedColorStr()));
-
-            /// Water meter info
-			AllItems.Add(new ItemSpec("Watermeter type", Strings.WM_Type, x => x.WaterMeterData().ProductName, (x, y, z) => z.WaterMeterData().ProductName, (x, z) => z.WaterMeterData().ProductName));
-			AllItems.Add(new ItemSpec("Producer", Strings.Producer, x => x.WaterMeterData().Producer, (x, y, z) => z.WaterMeterData().Producer, (x, z) => z.WaterMeterData().Producer));
-			AllItems.Add(new ItemSpec("Metrological class", Strings.MClass, x => x.WaterMeterData().MetrologicalClass, (x, y, z) => z.WaterMeterData().MetrologicalClass, (x, z) => z.WaterMeterData().MetrologicalClass));
-			AllItems.Add(new ItemSpec("Approval info", Strings.Approval, x => x.WaterMeterData().ApprovalInfo, (x, y, z) => z.WaterMeterData().ApprovalInfo, (x, z) => z.WaterMeterData().ApprovalInfo));
-			AllItems.Add(new ItemSpec("Q4", "Q4 [m3/h]", x => x.WaterMeterData().Q4_Qmax.ToString(), (x, y, z) => z.WaterMeterData().Q4_Qmax.ToString(), null));
-			AllItems.Add(new ItemSpec("Q3", "Q3 [m3/h]", x => x.WaterMeterData().Q3_Qn.ToString(), (x, y, z) => z.WaterMeterData().Q3_Qn.ToString(), null));
-			AllItems.Add(new ItemSpec("Q2", "Q2 [m3/h]", x => x.WaterMeterData().Q2_Qt.ToString(), (x, y, z) => z.WaterMeterData().Q2_Qt.ToString(), null));
-			AllItems.Add(new ItemSpec("Q1", "Q1 [m3/h]", x => x.WaterMeterData().Q1_Qmin.ToString(), (x, y, z) => z.WaterMeterData().Q1_Qmin.ToString(), null));
-			AllItems.Add(new ItemSpec("Qmax", "Qmax [m3/h]", x => x.WaterMeterData().Q4_Qmax.ToString(), (x, y, z) => z.WaterMeterData().Q4_Qmax.ToString(), null));
-			AllItems.Add(new ItemSpec("Qn", "Qn [m3/h]", x => x.WaterMeterData().Q3_Qn.ToString(), (x, y, z) => z.WaterMeterData().Q3_Qn.ToString(), null));
-			AllItems.Add(new ItemSpec("Qt", "Qt [m3/h]", x => x.WaterMeterData().Q2_Qt.ToString(), (x, y, z) => z.WaterMeterData().Q2_Qt.ToString(), null));
-			AllItems.Add(new ItemSpec("Qmin", "Qmin [m3/h]", x => x.WaterMeterData().Q1_Qmin.ToString(), (x, y, z) => z.WaterMeterData().Q1_Qmin.ToString(), null));
-
-            /// Water meters results
-			AllItems.Add(new ItemSpec("Serial Nr", Strings.sn, x => x.WaterMeter.SerialNr, (x, y, z) => z.WaterMeter.SerialNr, (x, z) => z.WaterMeter.SerialNr));
-			AllItems.Add(new ItemSpec("Purchase order", Strings.PO, x => x.WaterMeter.PurchaseOrder, (x, y, z) => z.WaterMeter.PurchaseOrder, (x, z) => z.WaterMeter.PurchaseOrder));
-			AllItems.Add(new ItemSpec("Year of production", Strings.Year, x => x.WaterMeter.YearOfProduction.ToString(), (x, y, z) => z.WaterMeter.YearOfProduction.ToString(), (x, z) => z.WaterMeter.YearOfProduction.ToString()));
-			AllItems.Add(new ItemSpec("WM Position", Strings.Pos, x => x.WaterMeter.WMPosition.ToString(), (x, y, z) => z.WaterMeter.WMPosition.ToString(), (x, z) => z.WaterMeter.WMPosition.ToString()));
-
-            /// Water meters results (single)
-            AllItems.Add(new ItemSpec("End state",          Strings.End_state,      x => x.EndState(),                              null, null));
-			AllItems.Add(new ItemSpec("Pulses",				Strings.Pulses,		    x => x.PulsesMeter.ToString(),		            null, null));
-            AllItems.Add(new ItemSpec("Pulses/liter",		Strings.PulsesLiter,    x => x.PulsesPerLiter.ToString(),	            null, null));
-			AllItems.Add(new ItemSpec("Reference pulses",	Strings.RefPulses,	    x => x.PulsesMaster.ToString(),		            null, null));
-
-            /// Water meters results (combined)
-            AllItems.Add(new ItemSpec("Q rise",             Strings.Q_rise + " [m3/h]", null, (x, y, z) => (z.QRise() == 0) ? "-" : Utils.DoubleToStr(z.QRise(), 4), null));
-			AllItems.Add(new ItemSpec("Q fall",             Strings.Q_fall + " [m3/h]", null, (x, y, z) => (z.QFall() == 0) ? "-" : Utils.DoubleToStr(z.QFall(), 4), null));
-			AllItems.Add(new ItemSpec("Error large WM",     Strings.Err_main + " [%]", null, (x, y, z) => x.Error.ToString("F2"), null));
-			AllItems.Add(new ItemSpec("Error small WM",     Strings.Err_aux + " [%]", null, (x, y, z) => y.Error.ToString("F2"), null));
-			AllItems.Add(new ItemSpec("Serial Nr large WM", Strings.sn_main, null, (x, y, z) => x.SerialNr(), null));
-			AllItems.Add(new ItemSpec("Serial Nr small WM", Strings.sn_aux, null, (x, y, z) => y.SerialNr(), null));
-			AllItems.Add(new ItemSpec("End state large WM", Strings.EndState_main, null, (x, y, z) => x.EndState(), null));
-			AllItems.Add(new ItemSpec("End state small WM", Strings.EndState_aux, null, (x, y, z) => y.EndState(), null));
-			AllItems.Add(new ItemSpec("Start volume main",  Strings.Start_volume_main + " [l]",x => x.VolumeMeter.ToString("F3"), (x, y, z) => x.VolumeStart.ToString("F3"), null));
-			AllItems.Add(new ItemSpec("End volume main",    Strings.End_volume_main + " [l]",  x => x.VolumeMeter.ToString("F3"), (x, y, z) => x.VolumeEnd.ToString("F3"),   null));
-			AllItems.Add(new ItemSpec("Volume main",        Strings.Volume_main + " [l]",      x => x.VolumeMeter.ToString("F3"), (x, y, z) => x.VolumeMeter.ToString("F3"), null));
-			AllItems.Add(new ItemSpec("Start volume aux",   Strings.Start_volume_aux + " [l]", x => x.VolumeMeter.ToString("F3"), (x, y, z) => y.VolumeStart.ToString("F3"), null));
-			AllItems.Add(new ItemSpec("End volume aux",     Strings.End_volume_aux + " [l]",   x => x.VolumeMeter.ToString("F3"), (x, y, z) => y.VolumeEnd.ToString("F3"),   null));
-			AllItems.Add(new ItemSpec("Volume aux",         Strings.Volume_aux + " [l]",       x => x.VolumeMeter.ToString("F3"), (x, y, z) => y.VolumeMeter.ToString("F3"), null));
-
-            /// Batch info
-            AllItems.Add(new ItemSpec("Batch number",       Strings.Batch_nr,       x => x.Batch().BatchNr.ToString(),              (x, y, z) => x.Batch().BatchNr.ToString(),            (x, z) => x.Batch().BatchNr.ToString()));
-            AllItems.Add(new ItemSpec("Test bench ID",      Strings.Bench,          x => x.Batch().TestBenchId.ToString(),          (x, y, z) => x.Batch().TestBenchId.ToString(),	      (x, z) => x.Batch().TestBenchId.ToString()));
-            AllItems.Add(new ItemSpec("Program version",    Strings.Ver,            x => x.Batch().ProgramVersion,                  (x, y, z) => x.Batch().ProgramVersion,			      (x, z) => x.Batch().ProgramVersion));
-            AllItems.Add(new ItemSpec("User name",          Strings.User,           x => x.Batch().UserName,                        (x, y, z) => x.Batch().UserName,					  (x, z) => x.Batch().UserName));
-            AllItems.Add(new ItemSpec("User nr.",           Strings.User_nr,        x => x.Batch().UserNumber.ToString(),           (x, y, z) => x.Batch().UserNumber.ToString(),		  (x, z) => x.Batch().UserNumber.ToString()));
-            AllItems.Add(new ItemSpec("Procedure name",     Strings.Procedure,      x => x.Batch().ProcedureName,                   (x, y, z) => x.Batch().ProcedureName,				  (x, z) => x.Batch().ProcedureName));
-            AllItems.Add(new ItemSpec("Watermeters",        Strings.WMs,            x => x.Batch().WatermetersStr,                  (x, y, z) => x.Batch().WatermetersStr,			      (x, z) => x.Batch().WatermetersStr));
-            AllItems.Add(new ItemSpec("Protocol title",     Strings.Protocol,       x => x.Batch().ProtocolTitle,                   (x, y, z) => x.Batch().ProtocolTitle,				  (x, z) => x.Batch().ProtocolTitle));
-            AllItems.Add(new ItemSpec("Batch start time",   Strings.Start,          x => x.Batch().StartTime.ToShortTimeString(),   (x, y, z) => x.Batch().StartTime.ToShortTimeString(), (x, z) => x.Batch().StartTime.ToShortTimeString()));
-            AllItems.Add(new ItemSpec("Batch end time",     Strings.End,            x => x.Batch().EndTime.ToShortTimeString(),     (x, y, z) => x.Batch().EndTime.ToShortTimeString(),   (x, z) => x.Batch().EndTime.ToShortTimeString()));
-
-            /// Heat meters results
-			AllItems.Add(new ItemSpec("Energy",				Strings.Energy,			null, null,	(x, z) => z.VolumeMeter.ToString()));
-            AllItems.Add(new ItemSpec("Reference energy",	Strings.Energy_ref,		null, null,	(x, z) => z.VolumeRef.ToString()));
-            AllItems.Add(new ItemSpec("Temp hi me",         "T hi me",              null, null, (x, z) => z.TestRslt.Custom1.ToString("F3")));
-            AllItems.Add(new ItemSpec("Temp hi st",         "T hi st",              null, null, (x, z) => z.TestRslt.Custom2.ToString("F3")));
-            AllItems.Add(new ItemSpec("Temp hi en",         "T hi en",              null, null, (x, z) => z.TestRslt.Custom3.ToString("F3")));
-            AllItems.Add(new ItemSpec("Temp hi av",         "T hi av",              null, null, (x, z) => ((z.TestRslt.Custom2 + z.TestRslt.Custom3) / 2).ToString("F3")));
-            AllItems.Add(new ItemSpec("Temp lo me",         "T lo me",              null, null, (x, z) => z.TestRslt.Custom6.ToString("F3")));
-            AllItems.Add(new ItemSpec("Temp lo st",         "T lo st",              null, null, (x, z) => z.TestRslt.Custom7.ToString("F3")));
-            AllItems.Add(new ItemSpec("Temp lo en",         "T lo en",              null, null, (x, z) => z.TestRslt.Custom8.ToString("F3")));
-            AllItems.Add(new ItemSpec("Temp lo av",         "T lo av",              null, null, (x, z) => ((z.TestRslt.Custom7 + z.TestRslt.Custom8) / 2).ToString("F3")));
-
-			AllItems.Add(new ItemSpec("Start mass", Strings.Start_mass + " [kg]",	x => x.TestRslt.MassStart.ToString("F4"),	(x, y, z) => z.TestRslt.MassStart.ToString("F4"),	(x, z) => z.TestRslt.MassStart.ToString("F4")));
-			AllItems.Add(new ItemSpec("End mass",	Strings.End_mass + " [kg]",		x => x.TestRslt.MassEnd.ToString("F4"),		(x, y, z) => z.TestRslt.MassEnd.ToString("F4"),		(x, z) => z.TestRslt.MassEnd.ToString("F4")));
-		}
-
-		public static ItemSpec GetItem(string name)
-		{
-			foreach (var item in AllItems) if (item.Name.Equals(name)) return item;
-			return null;
-		}
-
-		public static string[] ToStrArray(IList<ItemSpec> items)
-		{
-			int count = (items != null) ? items.Count : 0;
-			string[] result = new string[count];
-			for (int i = 0; i < count; i++) result[i] = items[i].Name;
-			return result;
-		}
-
-		public static IList<ItemSpec> FromStrArray(string[] strArray)
-		{
-			IList<ItemSpec> result = new List<ItemSpec>();
-			if (strArray != null)
-			{
-				for (int i = 0; i < strArray.Length; i++)
-				{
-					ItemSpec item = GetItem(strArray[i]);
-					if (item != null) result.Add(item);
-				}
-			}
-			return result;
-		}
-    }
-}

Results/Mappings/TestRsltMap.cs

@@ -32,7 +32,7 @@ namespace Results.Mappings
 			Map(x => x.MassEndRaw);
 			Map(x => x.MassEnd);
 			Map(x => x.DensityIn);
-			Map(x => x.DensityOut);
+            Map(x => x.DensityLine).Column("DensityOut");
 			Map(x => x.DensityDiv);
 			Map(x => x.Buoyancy);
 			Map(x => x.FlowMass);

Results/Output/Printers/Cevak/PrintDocumentCevak.cs

@@ -1,446 +0,0 @@
-///
-/// Copyright (c) 2013-2016 Sensus Metering Systems
-///
-using System;
-using System.Collections.Generic;
-using System.Drawing;
-using System.Drawing.Printing;
-using System.IO;
-using Config.Entities;
-using Results.Resources;
-
-namespace Results.Output.Printers.Cevak
-{
-	enum DocumentSection
-	{
-		FirstPage,
-		OtherPages,
-		Appendix1,
-		Appendix2,
-		Count,
-	}
-
-	public class PrintDocumentCevak : PrintDocument
-	{
-		const string FontFamilyName = "Arial";  //"Times New Roman";
-
-		const int SpacingOne = 18;
-		const int SpacingOneAndHalf = (3 * SpacingOne) / 2;
-
-		readonly int topMargin;
-		readonly int bottomMargin;
-		readonly int leftMargin;
-		readonly int TitleX;
-		readonly int TitleY;			/// Depends on the size of the header
-		readonly int HdrTop;			/// = TitleY + 60
-		readonly int BodyTop;			/// = HdrTop + 160
-
-		/// Size of the printed area without margins, after taking into account 'pageOrientation'
-		int printHeight;
-		int printWidth;
-
-		/// <summary>
-		/// Property variable for the Font the user wishes to use
-		/// </summary>
-		Font font;
-		Font boldFont;
-		Font titleFont;
-
-		///
-		/// Data to print
-		///
-		Results.Entities.Batch batch;
-
-		string testBenchName;
-		string address1;
-
-
-		///
-		/// Items to print
-		///
-        readonly IList<Results.ItemSpec> rsltItems;
-
-		///
-		/// Layout and status
-		///
-		DocumentSection documentSection;
-
-		int nrWMsOnFirstPage;
-		int nrWMsOnNextPage;
-		int nextWMNr;				/// nr. of watermeter to be printed as the first one on the next page
-		int nrPages;
-		int pageNr;					/// Page number to be printed at the bottom of the page
-
-		/// <summary>
-		/// Constructor
-		/// </summary>
-		/// <param name="textToPrint">Text to be printed</param>
-		public PrintDocumentCevak(Results.Entities.Batch batch,
-								  PageOrientation pageOrientation,
-								  int topMargin, int bottomMargin, int leftMargin,
-								  string testBenchName, string address1)
-		{
-			this.batch = batch;
-
-			DefaultPageSettings.Landscape = (pageOrientation == PageOrientation.Landscape);
-
-			this.topMargin = topMargin;
-			this.bottomMargin = bottomMargin;
-			this.leftMargin = leftMargin;
-
-			this.testBenchName = testBenchName;
-			this.address1 = address1;
-
-			TitleX = leftMargin;
-			TitleY = topMargin;				/// Depends on the size of the header
-			HdrTop = TitleY + 60;
-			BodyTop = HdrTop + 250;
-
-			rsltItems = Results.ItemSpec.FromStrArray(new string[] { 
-				"Test name",
-				"Volume",
-                "Reference volume",
-				"Test time",
-				"Flow",
-				"Error",
-				"Passed",
-				//"Reference error",        // ?
-				});
-
-			/// Set print area size and margins (in dots using 100 dpi)
-			if (DefaultPageSettings.Landscape)
-			{
-				printHeight = base.DefaultPageSettings.PaperSize.Width - topMargin - bottomMargin;
-				printWidth = base.DefaultPageSettings.PaperSize.Height - leftMargin - leftMargin;
-			}
-			else
-			{
-				printHeight = base.DefaultPageSettings.PaperSize.Height - topMargin - bottomMargin;
-				printWidth = base.DefaultPageSettings.PaperSize.Width - leftMargin - leftMargin;
-			}
-
-
-			int testsCount = 0;
-			foreach (var mtr in batch.WaterMeters[0].MeterTestRslts)
-			{
-				if (mtr.Publish() == Config.Entities.Publish.Always) testsCount++;
-			}
-
-			if (batch.WaterMeters[0].Compound()) testsCount /= 3;
-
-			int wmSectionHeight = (testsCount + 4) * SpacingOne;
-
-			nrWMsOnFirstPage = (printHeight - BodyTop + TitleY - 2 * SpacingOne) / wmSectionHeight;
-			nrWMsOnNextPage = (printHeight - 2 * SpacingOne) / wmSectionHeight;
-            nrWMsOnNextPage = Math.Max(nrWMsOnNextPage, 1); /// Prevent division by zero if there are too many WM tests
-
-			nrPages = 1 + (batch.WaterMeters.Count - nrWMsOnFirstPage + nrWMsOnNextPage - 1) / nrWMsOnNextPage;
-
-			pageNr = 1;
-			nextWMNr = 0;
-			documentSection = DocumentSection.FirstPage;
-		}
-
-		/// <summary>
-		/// Override the default onbeginPrint method of the PrintDocument Object
-		/// </summary>
-		/// <param name=e></param>
-		/// <remarks></remarks>
-		protected override void OnBeginPrint(System.Drawing.Printing.PrintEventArgs e)
-		{
-			base.OnBeginPrint(e);
-
-			if (font == null) { font = new Font(FontFamilyName, 10, FontStyle.Regular); }
-			if (boldFont == null) { boldFont = new Font(FontFamilyName, 10, FontStyle.Bold); }
-			if (titleFont == null) { titleFont = new Font(FontFamilyName, 18, FontStyle.Bold); }
-		}
-
-		/// <summary>
-		/// Override the default OnPrintPage method of the PrintDocument.
-		/// </summary>
-		/// <param name=e></param>
-		/// <remarks>This provides the print logic for our document</remarks>
-		protected override void OnPrintPage(System.Drawing.Printing.PrintPageEventArgs e)
-		{
-			/// Run base code
-			base.OnPrintPage(e);
-
-			/// Use the StringFormat class for the text layout of our document
-			StringFormat format = new StringFormat(StringFormatFlags.LineLimit);
-
-
-			if (documentSection != DocumentSection.OtherPages)
-			{
-				///----------
-				///  Header
-				///----------
-				if (documentSection == DocumentSection.FirstPage)
-				{
-					RectangleF printArea = new RectangleF(TitleX, TitleY, printWidth, 40);
-					e.Graphics.DrawString(batch.ProtocolTitle, titleFont, Brushes.Black, printArea);
-				}
-				else
-				{
-					PrintAt(e, TitleX, TitleY, batch.ProtocolTitle);
-				}
-
-				string[] leftColumn = new string[]
-				{
-					"Protokol č.: ",
-					"Zákazník: ",
-					"Datum a čas: ",
-					"Procedura: ",
-					"Popis procedury: ",
-					"Typ vodoměru: ",
-					"Zkoušející: ",
-					"Název zkušební stanice: ",
-					"Zkušební SW, č. verze: ",
-					"Metodika: ", /// BenchAdresa 1
-                    //"Okolní teplota: ",       // Disabled, see email dated 25.11.2016
-                    //"Okolní tlak: ",
-                    //"Relativní vlhkost: ",
-				};
-
-				string[] rightColumn = new string[]
-				{
-					batch.BatchNr.ToString(),
-					batch.WaterMeters[0].PurchaseOrder,
-					//batch.EndTime.ToShortDateString() + "  " + batch.EndTime.ToShortTimeString(),
-					string.Format("{0}.{1}.{2}  {3}:{4}", batch.EndTime.Year.ToString("D4"),
-														  batch.EndTime.Month.ToString("D2"),
-														  batch.EndTime.Day.ToString("D2"),
-														  batch.EndTime.Hour.ToString("D2"),
-														  batch.EndTime.Minute.ToString("D2")),
-					string.IsNullOrEmpty(batch.ProcedureName) ? "" : batch.ProcedureName,
-					string.IsNullOrEmpty(batch.ProcedureDescription) ? "" : batch.ProcedureDescription,
-					string.IsNullOrEmpty(batch.WatermetersStr) ? "" : batch.WatermetersStr,
-					string.IsNullOrEmpty(batch.UserName) ? "" : batch.UserName,
-					string.IsNullOrEmpty(testBenchName) ? "" : testBenchName,
-					string.Format("Test Bench Framework ver.{0}", batch.ProgramVersion),
-					string.IsNullOrEmpty(address1) ? "" : address1,
-                    //batch.AmbientTempAve().ToString("F1") + " °C",       // Disabled, see email dated 25.11.2016
-                    //Config.Units.ConvertTo(Config.Unit.mbar, batch.AmbientPressAve()).ToString("F0") + " mbar",
-                    //batch.AmbientHumiAve().ToString("F0") + " %",
-				};
-
-				/// Determine max. left column width in characters
-				int maxLen = 0;
-				foreach (var s in leftColumn) if (s.Length > maxLen) maxLen = s.Length;
-
-				/// Write aligned columns
-				for (int i = 0; i < Math.Min(leftColumn.Length, rightColumn.Length); i++)
-				{
-					PrintAt(e, leftMargin, HdrTop + SpacingOne * i, leftColumn[i]);
-					PrintAt(e, 300, HdrTop + SpacingOne * i, rightColumn[i]);
-				}
-			}
-
-			if (documentSection == DocumentSection.FirstPage || documentSection == DocumentSection.OtherPages)
-			{
-				///--------
-				///  Body
-				///--------
-
-				/// This variable represents the top coordinate of the area where WM results are printed
-				/// and it is updated (increased by) the value returned by PrintWM() - the section size. 
-				int nextWmTop = (pageNr == 1) ? BodyTop : TitleY;
-
-				int nrWMsOnPage = (pageNr == 1) ? nrWMsOnFirstPage : nrWMsOnNextPage;
-
-				for (int wmNr = nextWMNr; wmNr < Math.Min(nextWMNr + nrWMsOnPage, batch.WaterMeters.Count); wmNr++)	/// wmNr is 0-based
-				{
-					int wmPosition = true ? batch.WaterMeters[wmNr].WMPosition : (wmNr + 1);
-					nextWmTop += PrintWM(e, batch.WaterMeters[wmNr], wmPosition, nextWmTop);
-				}
-
-				nextWMNr += nrWMsOnPage;
-				e.HasMorePages = true;
-				if (nextWMNr < batch.WaterMeters.Count)
-				{
-					documentSection = DocumentSection.OtherPages;
-				}
-				else
-				{
-					documentSection = DocumentSection.Appendix1;
-				}
-
-				///----------
-				///  Footer
-				///----------
-				string footerText = string.Format("{0} {1}/{2}", Strings.Page, pageNr++, nrPages);
-				int footerWidth = (int)e.Graphics.MeasureString(footerText, font).Width;
-				PrintAt(e, leftMargin + (printWidth - footerWidth) / 2, topMargin + printHeight - SpacingOne, footerText);
-			}
-			else
-			{
-				///-------------------------------
-				///  List of passed water meters
-				///-------------------------------
-
-				int nextWmTop = BodyTop;
-
-				foreach (var wm in batch.WaterMeters)
-				{
-					if (wm.Passed)
-					{
-						PrintAt(e, leftMargin, nextWmTop, string.Format("Vodoměr {0}:  s/n {1}", wm.WMPosition, wm.SerialNr));
-						nextWmTop += SpacingOne;
-					}
-				}
-
-				if (documentSection == DocumentSection.Appendix1)
-				{
-					documentSection = DocumentSection.Appendix2;
-					e.HasMorePages = true;
-				}
-				else
-				{
-					e.HasMorePages = false;
-				}
-			}
-		}
-
-
-		/// <summary>
-		/// Print one water meter results
-		/// </summary>
-		/// <param name="wm">Water meter</param>
-		/// <param name="printedWMNr">Number of the water meter printed</param>
-		/// <param name="top">Top coordinate of watermeter data</param>
-		/// <returns>The height of the printed section</returns>
-		int PrintWM(System.Drawing.Printing.PrintPageEventArgs e,
-					Results.Entities.WaterMeter wm, int printedWMNr, int top)
-		{
-			/// Determin column widths
-			float[] columnPos = new float[rsltItems.Count + 1];
-			columnPos[0] = (float)leftMargin;
-
-			for (int i = 0; i < rsltItems.Count; i++)
-			{
-				float columnWidth = e.Graphics.MeasureString(rsltItems[i].ClmnHeaderText, font).Width;
-				foreach (var mtr in wm.MeterTestRslts)
-				{
-					string itemText;
-
-					if (!wm.Compound())
-					{
-						itemText = rsltItems[i].Print(mtr);
-					}
-					else if (mtr.CompoundMeterId == (byte)CompoundMeterId.Compound)
-					{
-						Results.Entities.MeterTestRslt mainMtr = wm.GetMeterTestRslt(mtr.Name(), CompoundMeterId.CompoundMain);
-						Results.Entities.MeterTestRslt auxMtr = wm.GetMeterTestRslt(mtr.Name(), CompoundMeterId.CompoundAux);
-						itemText = rsltItems[i].PrintCombined(mainMtr, auxMtr, mtr);
-					}
-					else
-					{
-						continue;
-					}
-
-					/// Strip color information
-					string[] texts = itemText.Split(new char[] { '|' });
-					if (texts.Length == 2) { itemText = texts[0]; }
-
-					float width = e.Graphics.MeasureString(itemText, font).Width;
-					if (width > columnWidth) columnWidth = width;
-				}
-				columnPos[i + 1] = columnPos[i] + columnWidth + 20.0f;
-			}
-			int tableLeftX = (int)columnPos[0];
-			int tableRightX = (int)columnPos[rsltItems.Count] - 20;
-
-			string wmText = string.Format("Vodoměr {0}", printedWMNr);
-			PrintAt(e, leftMargin, top, wmText);
-			if (!string.IsNullOrEmpty(wm.SerialNr))
-			{
-				PrintAt(e, leftMargin + (int)e.Graphics.MeasureString(wmText, font).Width, top,
-						string.Format("  s/n = {0}", wm.SerialNr));
-			}
-
-			/// Horizontal line
-			int horY = top + 25;
-			e.Graphics.DrawLine(new Pen(Color.Black, 2), new Point(tableLeftX, horY), new Point(tableRightX, horY));
-
-			for (int i = 0; i < rsltItems.Count; i++)
-			{
-				PrintAt(e, (int)columnPos[i], top + 27, rsltItems[i].ClmnHeaderText);
-			}
-
-			/// Horizontal line
-			horY = top + 27 + SpacingOne;
-			e.Graphics.DrawLine(new Pen(Color.Black, 2), new Point(tableLeftX, horY), new Point(tableRightX, horY));
-
-			int testsCount = 0;
-			foreach (var mtr in wm.MeterTestRslts)
-			{
-				if (mtr.Publish() == Config.Entities.Publish.Always)
-				{
-					testsCount++;
-					for (int i = 0; i < rsltItems.Count; i++)
-					{
-						string itemText;
-
-						if (!wm.Compound())
-						{
-							/// Single water meter
-							itemText = rsltItems[i].Print(mtr);
-						}
-						else if (mtr.CompoundMeterId == (byte)CompoundMeterId.Compound)
-						{
-							Results.Entities.MeterTestRslt mainMtr = wm.GetMeterTestRslt(mtr.Name(), CompoundMeterId.CompoundMain);
-							Results.Entities.MeterTestRslt auxMtr = wm.GetMeterTestRslt(mtr.Name(), CompoundMeterId.CompoundMain);
-							itemText = rsltItems[i].PrintCombined(mainMtr, auxMtr, mtr);
-						}
-						else
-						{
-							continue;
-						}
-
-						/// Strip color information
-						string[] texts = itemText.Split(new char[] { '|' });
-						if (texts.Length == 2)
-						{
-							itemText = texts[0];
-							Color color = texts[1].Equals("Green") ? Color.Green : (texts[1].Equals("Red") ? Color.Red : Color.White);
-							/// TODO: How to print colors?
-						}
-
-						PrintAt(e, (int)columnPos[i], top + 30 + SpacingOne * testsCount, itemText);
-					}
-				}
-			}
-
-			/// Horizontal line
-			horY = top + 30 + SpacingOne * (testsCount + 1);
-			e.Graphics.DrawLine(new Pen(Color.Black, 2), new Point(tableLeftX, horY), new Point(tableRightX, horY));
-
-			return (testsCount + 4) * SpacingOne;
-		}
-
-
-		void PrintAt(System.Drawing.Printing.PrintPageEventArgs e, Point p, string text)
-		{
-			PrintAt(e, p.X, p.Y, text);
-		}
-
-
-		void PrintAt(System.Drawing.Printing.PrintPageEventArgs e, int x, int y, string text)
-		{
-			RectangleF printArea = new RectangleF(x, y, 667, SpacingOne);
-			e.Graphics.DrawString(text, this.font, Brushes.Black, printArea);
-		}
-
-
-		void PrintBoldAt(System.Drawing.Printing.PrintPageEventArgs e, Point p, string text)
-		{
-			PrintBoldAt(e, p.X, p.Y, text);
-		}
-
-
-		void PrintBoldAt(System.Drawing.Printing.PrintPageEventArgs e, int x, int y, string text)
-		{
-			RectangleF printArea = new RectangleF(x, y, 667, SpacingOne);
-			e.Graphics.DrawString(text, this.boldFont, Brushes.Black, printArea);
-		}
-	}
-}

Results/Output/Printers/Enhanced/EnhancedPrintDocument.cs

@@ -44,6 +44,8 @@ namespace Results.Output.Printers.Enhanced
         Font font;
         Font footerFont;
 
+        TableStyle style;
+
 		///
 		/// Data to print
 		///
@@ -75,7 +77,7 @@ namespace Results.Output.Printers.Enhanced
 		/// <param name="textToPrint">Text to be printed</param>
 		public EnhancedPrintDocument(Results.Entities.Batch batch, EnhancedPrinterCfg cfg, string documentName)
 		{
-			this.batch = batch;
+            this.batch = batch;
 			this.cfg = cfg;
             DocumentName = documentName;
 
@@ -94,7 +96,20 @@ namespace Results.Output.Printers.Enhanced
 			font = new Font((cfg.BodyFntFml != null ? cfg.BodyFntFml : "Arial"), (cfg.BodyFntSz > 0 ? cfg.BodyFntSz : 10), (FontStyle)cfg.BodyFntSty);
             footerFont = new Font((cfg.FooterFntFml != null ? cfg.FooterFntFml : "Arial"), (cfg.FooterFntSz > 0 ? cfg.FooterFntSz : 10), (FontStyle)cfg.FooterFntSty);
 
-			/// Set print area size and margins (in dots using 100 dpi)
+            /// Table style of one water meter table where tests are rows
+            style = new TableStyle
+            {
+                Font = font,
+                HeaderFont = headerFont,
+                MarginX = 5,
+                MarginY = 3,
+                LineWidth = 1,
+                TopHeadersCount = 1,
+                HorizLines = TableLines.FirstSecondAndLast,
+                VertLines = TableLines.All
+            };
+
+            /// Set print area size and margins (in dots using 100 dpi)
 			DefaultPageSettings.Landscape = (cfg.PageOrientation == PageOrientation.Landscape);
 			///
 			if (DefaultPageSettings.Landscape)
@@ -108,39 +123,15 @@ namespace Results.Output.Printers.Enhanced
 				printWidth = base.DefaultPageSettings.PaperSize.Width - leftMargin - leftMargin;
 			}
 
-			SpacingOne = System.Windows.Forms.TextRenderer.MeasureText("Abcgq", font).Height;
-			SpacingOneAndHalf = (3 * SpacingOne) / 2;
-			SpacingOne4Header = System.Windows.Forms.TextRenderer.MeasureText("Abcgq", headerFont).Height;
-			SpacingOneAndHalf4Header = (3 * SpacingOne4Header) / 2;
+            /// Document outline preliminary calculations
+            SpacingOne = System.Windows.Forms.TextRenderer.MeasureText("Abcgq", font).Height;
+            SpacingOneAndHalf = (3 * SpacingOne) / 2;
+            SpacingOne4Header = System.Windows.Forms.TextRenderer.MeasureText("Abcgq", headerFont).Height;
+            SpacingOneAndHalf4Header = (3 * SpacingOne4Header) / 2;
             SpacingOne4Footer = System.Windows.Forms.TextRenderer.MeasureText("Abcgq", footerFont).Height;
 
-			/// Calculate the tests count
-			int testsCount = 0;
-			if (batch.WaterMeters.Count > 0)
-			{
-				foreach (var mtr in batch.WaterMeters[0].MeterTestRslts)
-				{
-					if (mtr.Publish() == Config.Entities.Publish.Always && mtr.IsPilotRslt()) testsCount++;
-				}
-			}
-
-			/// Prepare document outline
-			TitleX = cfg.LeftMargin;
-			TitleY = cfg.TopMargin;
-
-			titleHeight = System.Windows.Forms.TextRenderer.MeasureText(header, titleFont).Height;
-			CommonTop = TitleY + titleHeight + SpacingOne4Header;
-
-			commonHeight = commonItems.Count * SpacingOne;
-			BodyTop = CommonTop + commonHeight + SpacingOne4Header;
-
-			int wmSectionHeight = (testsCount + 1) * SpacingOne + 3 * SpacingOne4Header;
-
-			nrWMsOnFirstPage = (printHeight - BodyTop + TitleY - 2 * SpacingOne) / wmSectionHeight;
-			nrWMsOnNextPage = (printHeight - 2 * SpacingOne) / wmSectionHeight;
-			nrWMsOnNextPage = Math.Max(nrWMsOnNextPage, 1); /// Prevent division by zero if there are too many WM tests
-
-			nrPages = 1 + (batch.WaterMeters.Count - nrWMsOnFirstPage + nrWMsOnNextPage - 1) / nrWMsOnNextPage;
+            TitleX = cfg.LeftMargin;
+            TitleY = cfg.TopMargin;
 
 			pageNr = 1;
 			nextWMNr = 0;
@@ -183,7 +174,27 @@ namespace Results.Output.Printers.Enhanced
 
 			if (pageNr == 1)
 			{
-				///----------
+                ///----------
+                /// Prepare document outline
+                ///----------
+                titleHeight = System.Windows.Forms.TextRenderer.MeasureText(header, titleFont).Height;
+                CommonTop = TitleY + titleHeight + SpacingOne4Header;
+
+                commonHeight = commonItems.Count * SpacingOne;
+                BodyTop = CommonTop + commonHeight + SpacingOne4Header;
+
+                Table table0 = Table.Create_TestsAreRows(batch.WaterMeters[0], testItems, style);
+                SizeF tableSize = table0.Measure(e);
+                int wmSectionHeight = (int)tableSize.Height + 3 * SpacingOne4Header;
+
+                nrWMsOnFirstPage = (printHeight - BodyTop + TitleY - 2 * SpacingOne) / wmSectionHeight;
+                nrWMsOnNextPage = (printHeight - 2 * SpacingOne) / wmSectionHeight;
+                nrWMsOnNextPage = Math.Max(nrWMsOnNextPage, 1); /// Prevent division by zero if there are too many WM tests
+
+                nrPages = 1 + (batch.WaterMeters.Count - nrWMsOnFirstPage + nrWMsOnNextPage - 1) / nrWMsOnNextPage;
+                
+
+                ///----------
 				///  Title
 				///----------
 				RectangleF printArea = new RectangleF(TitleX, TitleY, printWidth, titleHeight);
@@ -228,8 +239,7 @@ namespace Results.Output.Printers.Enhanced
 			for (int wmNr = nextWMNr; wmNr < Math.Min(nextWMNr + nrWMsOnPage, batch.WaterMeters.Count); wmNr++)	/// wmNr is 0-based
 			{
 				int wmPosition = true ? batch.WaterMeters[wmNr].WMPosition : (wmNr + 1);
-                int sectionHght = PrintWM(e, batch.WaterMeters[wmNr], wmPosition, nextWmTop);
-                nextWmTop += sectionHght;
+                nextWmTop = (int)PrintWM(e, batch.WaterMeters[wmNr], wmPosition, nextWmTop) + SpacingOneAndHalf4Header;
 			}
 
 			nextWMNr += nrWMsOnPage;
@@ -254,88 +264,21 @@ namespace Results.Output.Printers.Enhanced
 		/// <param name="printedWMNr">Number of the water meter printed</param>
 		/// <param name="top">Top coordinate of watermeter data</param>
 		/// <returns>The height of the printed section</returns>
-		int PrintWM(System.Drawing.Printing.PrintPageEventArgs e,
+		float PrintWM(System.Drawing.Printing.PrintPageEventArgs e,
 					Results.Entities.WaterMeter wm, int printedWMNr, int top)
 		{
-			/// Determin column widths
-			float[] columnPos = new float[testItems.Count + 1];
-			columnPos[0] = (float)leftMargin;
+            /// Print the water meter number and the serial number
+            string wmText = string.Format("{0} {1}", Strings.Water_Meter, printedWMNr);
+            PrintHeaderAt(e, leftMargin, top, wmText);
+            if (!string.IsNullOrEmpty(wm.SerialNr))
+            {
+                PrintHeaderAt(e, leftMargin + (int)e.Graphics.MeasureString(wmText, headerFont).Width, top,
+                        string.Format("  {0} = {1}", Strings.sn, wm.SerialNr));
+            }
 
-			for (int i = 0; i < testItems.Count; i++)
-			{
-				float columnWidth = e.Graphics.MeasureString(testItems[i].Caption, headerFont).Width;
-				foreach (var mtr in wm.MeterTestRslts)
-				{
-                    if (mtr != null && mtr.IsPilotRslt() && mtr.Publish() == Config.Entities.Publish.Always)
-                    {
-                        string itemText = testItems[i].Print(wm, mtr.Name());
+            Table table = Table.Create_TestsAreRows(wm, testItems, style);
 
-                        /// Strip color information
-                        string[] texts = itemText.Split(new char[] { '|' });
-                        if (texts.Length == 2) { itemText = texts[0]; }
-
-                        float width = e.Graphics.MeasureString(itemText, font).Width;
-                        if (width > columnWidth) columnWidth = width;
-                    }
-				}
-				columnPos[i + 1] = columnPos[i] + columnWidth + 20.0f;
-			}
-			int tableLeftX = (int)columnPos[0];
-			int tableRightX = (int)columnPos[testItems.Count] - 20;
-
-			string wmText = string.Format("{0} {1}", Strings.Water_Meter, printedWMNr);
-			PrintHeaderAt(e, leftMargin, top, wmText);
-			if (!string.IsNullOrEmpty(wm.SerialNr))
-			{
-				PrintHeaderAt(e, leftMargin + (int)e.Graphics.MeasureString(wmText, headerFont).Width, top,
-						string.Format("  {0} = {1}", Strings.sn, wm.SerialNr));
-			}
-
-			/// Horizontal line
-			int horY = top + SpacingOneAndHalf4Header;
-			e.Graphics.DrawLine(new Pen(Color.Black, 2), new Point(tableLeftX, horY), new Point(tableRightX, horY));
-
-			for (int i = 0; i < testItems.Count; i++)
-			{
-				PrintHeaderAt(e, (int)columnPos[i], top + (int)(1.6 * SpacingOne4Header), testItems[i].Caption);
-			}
-
-			/// Horizontal line
-			horY = top + (int)(2.8 * SpacingOne4Header);
-			e.Graphics.DrawLine(new Pen(Color.Black, 2), new Point(tableLeftX, horY), new Point(tableRightX, horY));
-
-			int testsCount = 0;
-			foreach (var mtr in wm.MeterTestRslts)
-			{
-				if ((mtr != null) && (mtr.Publish() == Config.Entities.Publish.Always))
-				{
-                    WMeterRsltItemSpec.TableRowNr = ++testsCount;
-
-                    for (int i = 0; i < testItems.Count; i++)
-					{
-                        WMeterRsltItemSpec.TableColumnNr = i + 1;
-
-                        string itemText = testItems[i].Print(wm, mtr.Name());
-
-						/// Strip color information
-						string[] texts = itemText.Split(new char[] { '|' });
-						if (texts.Length == 2)
-						{
-							itemText = texts[0];
-							Color color = texts[1].Equals("Green") ? Color.Green : (texts[1].Equals("Red") ? Color.Red : Color.White);
-							/// TODO: How to print colors?
-						}
-
-						PrintAt(e, (int)columnPos[i], top + 2 * SpacingOne4Header + SpacingOne * testsCount, itemText);
-					}
-				}
-			}
-
-			/// Horizontal line
-			horY = top + 2 * SpacingOneAndHalf4Header + SpacingOne * testsCount;
-			e.Graphics.DrawLine(new Pen(Color.Black, 2), new Point(tableLeftX, horY), new Point(tableRightX, horY));
-
-			return (testsCount + 1) * SpacingOne + 3 * SpacingOne4Header;
+            return table.Draw(e, leftMargin, top + SpacingOneAndHalf4Header);
 		}
 
 

Results/Output/Printers/OnePerMeter/OnePerMeterPrintDocument.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2017 Sensus Metering Systems
+/// Copyright (c) 2017-2018 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
@@ -11,7 +11,7 @@ using Results.Resources;
 
 namespace Results.Output.Printers.OnePerMeter
 {
-	public class OnePerMeterPrintDocument : PrintDocument
+	public class OnePerMeterPrintDocument : PrintersCommon
 	{
         const float GapBetweenTableColumns = 10;
         const float GapBetweenCommonColumns = 10;
@@ -29,11 +29,7 @@ namespace Results.Output.Printers.OnePerMeter
 		readonly int spacingOne;
 		readonly int spacingOne4Header;
 		
-		float commonTop;			/// = TitleY + 60
-		float bodyTop;			/// = HdrTop + 160
-										/// 
-		float titleHeight;
-		float commonHeight;
+        float titleHeight;
 
 		/// <summary>
 		/// Property variable for the Font the user wishes to use
@@ -54,9 +50,14 @@ namespace Results.Output.Printers.OnePerMeter
 		/// Items to print
 		///
         string header;
-        IList<WMeterRsltItemSpec> commonItems;
+        IList<WMeterRsltItemSpec> commonItems1;
+        IList<WMeterRsltItemSpec> commonItems2;
+        IList<WMeterRsltItemSpec> commonItems3;
         IList<WMeterRsltItemSpec> testItems;
         IList<WMeterRsltItemSpec> testItems2;
+        IList<WMeterRsltItemSpec> belowItems1;
+        IList<WMeterRsltItemSpec> belowItems2;
+        IList<WMeterRsltItemSpec> belowItems3;
         string footer;
 
 		int nrPages;
@@ -78,9 +79,14 @@ namespace Results.Output.Printers.OnePerMeter
 			leftMargin = cfg.LeftMargin;
 
 			header = string.IsNullOrEmpty(cfg.Header) ? string.Empty : cfg.Header.Replace("~", Environment.NewLine);
-			commonItems = Results.WMeterRsltItemSpec.FromStrArray(cfg.CommonItems);
-			testItems = Results.WMeterRsltItemSpec.FromStrArray(cfg.TestItems);		    /// TestID info will be overwritten later on
+			commonItems1 = Results.WMeterRsltItemSpec.FromStrArray(cfg.CommonItems1);
+            commonItems2 = Results.WMeterRsltItemSpec.FromStrArray(cfg.CommonItems2);
+            commonItems3 = Results.WMeterRsltItemSpec.FromStrArray(cfg.CommonItems3);
+            testItems = Results.WMeterRsltItemSpec.FromStrArray(cfg.TestItems);		    /// TestID info will be overwritten later on
             testItems2 = Results.WMeterRsltItemSpec.FromStrArray(cfg.TestItems2);	    /// TestID info will be overwritten later on
+            belowItems1 = Results.WMeterRsltItemSpec.FromStrArray(cfg.BelowItems1);
+            belowItems2 = Results.WMeterRsltItemSpec.FromStrArray(cfg.BelowItems2);
+            belowItems3 = Results.WMeterRsltItemSpec.FromStrArray(cfg.BelowItems3);
             footer = string.IsNullOrEmpty(cfg.Footer) ? string.Empty : cfg.Footer.Replace("~", Environment.NewLine);
 
 			/// Initialize fonts
@@ -146,8 +152,12 @@ namespace Results.Output.Printers.OnePerMeter
                 }
             }
 
+            float tableTop = cfg.TopMargin;
+
             if (pageNr == 1)
             {
+                /// First page
+
                 ///
                 ///  Print water meter picture
                 ///
@@ -161,99 +171,167 @@ namespace Results.Output.Printers.OnePerMeter
                     catch (Exception) { }       /// Cope with situations when file is missing or is not correct
                 }
 
-                titleHeight = System.Windows.Forms.TextRenderer.MeasureText(header, titleFont).Height;
-                commonTop = TitleY + titleHeight + spacingOne4Header;
-
-                commonHeight = commonItems.Count * spacingOne;
-                bodyTop = commonTop + commonHeight + spacingOne4Header;
-
 				///
 				///  Title
 				///
 				RectangleF printArea = new RectangleF(TitleX, TitleY, printWidth, titleHeight);
 				e.Graphics.DrawString(header, titleFont, Brushes.Black, printArea);
-	
-	            ///
-	            ///  Common items
-	            ///
-	            string[] leftColumn = new string[commonItems.Count];
-	            string[] rightColumn = new string[commonItems.Count];
-	
-	            int cnt = 0;
-	            foreach (var v in commonItems)
-	            {
-	                leftColumn[cnt] = v.Caption;
-	                rightColumn[cnt] = (batch.WaterMeters.Count > 0) ? v.Print(batch.WaterMeters[0]) : string.Empty;
-	                cnt++;
-	            }
-	
-				/// Determine left column width
-                float maxWidth = 0;
-                foreach (var str in leftColumn)
-                {
-                    float width = e.Graphics.MeasureString(str, font).Width;
-                    if (width > maxWidth) maxWidth = width;
-                }
-	
-				/// Write aligned columns
-				for (int i = 0; i < Math.Min(leftColumn.Length, rightColumn.Length); i++)
-				{
-                    PrintAt(e, leftMargin, commonTop + spacingOne * i, maxWidth, leftColumn[i], font, Alignment.Left);
-                    PrintAt(e, leftMargin + maxWidth + GapBetweenCommonColumns, commonTop + spacingOne * i, 0, rightColumn[i], font, Alignment.Left);
-				}
-			}
 
-			///
-			///  Body
-			///
-            if (pageNr == 1)
-            {
-                string[] tableHeader;
-                IList<string[]> tableRows;
-                Alignment[] itemAlignment;
+                titleHeight = System.Windows.Forms.TextRenderer.MeasureText(header, titleFont).Height;
+                float commonTop = TitleY + titleHeight;
 
-                ///
-                /// Prepare table content: tableHeader + tableRows + itemAlignment
-                ///
-                if (cfg.TestsAreRows)
-                {
-                    GetContentTestsAreRows(wm, testItems, out tableHeader, out tableRows, out itemAlignment);
-                }
-                else
-                {
-                    GetContentTestsAreColumns(wm, testItems, out tableHeader, out tableRows, out itemAlignment);
-                }
+                ///----------------
+                ///  Common items
+                ///----------------
+                commonTop += spacingOne4Header;     /// Space above common part
+                float leftMarginCommon1 = leftMargin + printWidth * 0.01f * cfg.ColW0Pct;
+                float leftMarginCommon2 = leftMargin + printWidth * 0.01f * (cfg.ColW0Pct + cfg.ColW1Pct);
+                float leftMarginCommon3 = leftMargin + printWidth * 0.01f * (cfg.ColW0Pct + cfg.ColW1Pct + cfg.ColW2Pct);
 
-                DrawTable(e, (float)leftMargin, bodyTop, tableHeader, tableRows, itemAlignment);
+                Alignment[] horizAlgn = new Alignment[] { Alignment.Left, Alignment.Left };
+                VertAlignment[] vertAlgn = new VertAlignment[] { VertAlignment.Top, VertAlignment.Top };
+                TableStyle commonTableStyle = new TableStyle { Font = font, MarginX = 5, MarginY = 3 };
+
+                Table table1 = new Table(2) { Style = commonTableStyle };
+                foreach (var item in commonItems1)
+                {
+                    string[] row = new string[] { item.Caption, item.Print(wm).Split(new char[] { '|' })[0] };
+                    table1.AddRow(row, horizAlgn, vertAlgn);
+                }
+                float bodyTop1 = table1.Draw(e, leftMarginCommon1, commonTop);
+
+
+                table1 = new Table(2) { Style = commonTableStyle };
+                foreach (var item in commonItems2)
+                {
+                    string[] row = new string[] { item.Caption, item.Print(wm).Split(new char[] { '|' })[0] };
+                    table1.AddRow(row, horizAlgn, vertAlgn);
+                }
+                float bodyTop2 = table1.Draw(e, leftMarginCommon2, commonTop);
+
+
+                table1 = new Table(2) { Style = commonTableStyle };
+                foreach (var item in commonItems3)
+                {
+                    string[] row = new string[] { item.Caption, item.Print(wm).Split(new char[] { '|' })[0] };
+                    table1.AddRow(row, horizAlgn, vertAlgn);
+                }
+                float bodyTop3 = table1.Draw(e, leftMarginCommon3, commonTop);
+
+                float bodyTop12 = (bodyTop1 > bodyTop2) ? bodyTop1 : bodyTop2;
+                tableTop = (bodyTop12 > bodyTop3) ? bodyTop12 : bodyTop3;            /// Max. of all three bodyTop-s
+                tableTop += spacingOne4Header;                                       /// Space between the common part and the table
             }
-            else
+
+
+            ///
+            /// Draw table (on the 1st, as well as on the 2nd page)
+            ///
+            float belowTop;
+            TableStyle style;
+            Table table;
+            switch (cfg.Form)
             {
-                string[] tableHeader;
-                IList<string[]> tableRows;
-                Alignment[] itemAlignment;
+                default:
+                case TableForm.Rows:
 
-                ///
-                /// Prepare table content: tableHeader + tableRows + itemAlignment
-                ///
-                if (cfg.TestsAreRows2)
-                {
-                    GetContentTestsAreRows(wm, testItems2, out tableHeader, out tableRows, out itemAlignment);
-                }
-                else
-                {
-                    GetContentTestsAreColumns(wm, testItems2, out tableHeader, out tableRows, out itemAlignment);
-                }
+                    style = new TableStyle
+                    {
+                        Font = font,
+                        HeaderFont = headerFont,
+                        MarginX = 5,
+                        MarginY = 3,
+                        LineWidth = 1,
+                        TopHeadersCount = 1,
+                        HorizLines = TableLines.All,
+                        VertLines = TableLines.All
+                    };
+                    table = Table.Create_TestsAreRows(wm, (pageNr == 1) ? testItems : testItems2, style);
+                    break;
 
-                DrawTable(e, (float)leftMargin, (float)topMargin, tableHeader, tableRows, itemAlignment);
+                case TableForm.Columns:
+
+                    style = new TableStyle
+                    {
+                        Font = font,
+                        HeaderFont = headerFont,
+                        MarginX = 5,
+                        MarginY = 3,
+                        LineWidth = 1,
+                        LeftHeadersCount = 1,
+                        HorizLines = TableLines.FirstSecondAndLast,
+                        VertLines = TableLines.All
+                    };
+                    table = Table.Create_TestsAreColumns(wm, (pageNr == 1) ? testItems : testItems2, style);
+                    break;
+
+                case TableForm.ColumnsPL:
+
+                    style = new TableStyle
+                    {
+                        Font = font,
+                        HeaderFont = headerFont,
+                        MarginX = 5,
+                        MarginY = 3,
+                        LineWidth = 1,
+                        TopHeadersCount = 1,
+                        HorizLines = TableLines.FirstSecondAndLast,
+                        VertLines = TableLines.All
+                    };
+                    table = Table.Create_TestsAreColumnsPL(wm, (pageNr == 1) ? testItems : testItems2, style);
+                    break;
             }
 
+            SizeF size = table.Measure(e);
+            float tableLeft = (float)leftMargin + ((float)printWidth - size.Width) / 2;
+            belowTop = table.Draw(e, tableLeft, tableTop);
+
             if (pageNr == nrPages)
 			{
-				///
+                ///----------------
+                ///  Common items
+                ///----------------
+                belowTop += spacingOne4Header;      /// Space between the table and the bottom common part
+                float leftMarginBelow1 = leftMargin + printWidth * 0.01f * cfg.BelowW0Pct;
+                float leftMarginBelow2 = leftMargin + printWidth * 0.01f * (cfg.BelowW0Pct + cfg.BelowW1Pct);
+                float leftMarginBelow3 = leftMargin + printWidth * 0.01f * (cfg.BelowW0Pct + cfg.BelowW1Pct + cfg.BelowW2Pct);
+
+                Alignment[] horizAlgn = new Alignment[] { Alignment.Left, Alignment.Left };
+                VertAlignment[] vertAlgn = new VertAlignment[] { VertAlignment.Top, VertAlignment.Top };
+                TableStyle commonTableStyle = new TableStyle { Font = font, MarginX = 5, MarginY = 3 };
+
+                Table table2 = new Table(2) { Style = commonTableStyle };
+                foreach (var item in belowItems1)
+                {
+                    string[] row = new string[] { item.Caption, item.Print(wm).Split(new char[] { '|' })[0] };
+                    table2.AddRow(row, horizAlgn, vertAlgn);
+                }
+                table2.Draw(e, leftMarginBelow1, belowTop);
+
+
+                table2 = new Table(2) { Style = commonTableStyle };
+                foreach (var item in belowItems2)
+                {
+                    string[] row = new string[] { item.Caption, item.Print(wm).Split(new char[] { '|' })[0] };
+                    table2.AddRow(row, horizAlgn, vertAlgn);
+                }
+                table2.Draw(e, leftMarginBelow2, belowTop);
+
+
+                table2 = new Table(2) { Style = commonTableStyle };
+                foreach (var item in belowItems3)
+                {
+                    string[] row = new string[] { item.Caption, item.Print(wm).Split(new char[] { '|' })[0] };
+                    table2.AddRow(row, horizAlgn, vertAlgn);
+                }
+                table2.Draw(e, leftMarginBelow3, belowTop);
+                
+
+                ///
                 ///  Footer on the last page
 				///
                 float footerWidth = e.Graphics.MeasureString(footer, footerFont).Width;
-                PrintAt(e, leftMargin, topMargin + printHeight - 2 * spacingOne, 0, footer, footerFont, Alignment.Left);
+                PrintAt(e, footer, footerFont, leftMargin, topMargin + printHeight - 2 * spacingOne, 0, 0, Alignment.Left, VertAlignment.Top);
             }
 
             ///
@@ -261,217 +339,11 @@ namespace Results.Output.Printers.OnePerMeter
             ///
             string pageNrText = string.Format("{0} {1}/{2}", Strings.Page, pageNr, nrPages);
             float pageNrWidth = e.Graphics.MeasureString(pageNrText, font).Width;
-            PrintAt(e, leftMargin + (printWidth - pageNrWidth) / 2, topMargin + printHeight - spacingOne, 0, pageNrText, font, Alignment.Left);
+            PrintAt(e, pageNrText, font, leftMargin + (printWidth - pageNrWidth) / 2, topMargin + printHeight - spacingOne, 0, 0, Alignment.Left, VertAlignment.Top);
 
             e.HasMorePages = !(pageNr == nrPages);
 
             pageNr++;
 		}
-
-
-        void GetContentTestsAreRows(Results.Entities.WaterMeter wm, IList<WMeterRsltItemSpec> items, out string[] tableHeader, out IList<string[]> tableRows, out Alignment[] itemAlignment)
-        {
-            int tableColumnsCount = items.Count;
-
-            tableRows = new List<string[]>();
-            tableHeader = new string[tableColumnsCount];
-            itemAlignment = new Alignment[tableColumnsCount];
-
-            for (int i = 0; i < tableColumnsCount; i++)
-            {
-                tableHeader[i] = items[i].Caption;
-                itemAlignment[i] = items[i].Alignment;
-            }
-
-            WMeterRsltItemSpec.TableRowNr = 0;
-            foreach (var mtr in wm.MeterTestRslts)
-            {
-                if (mtr != null && mtr.IsPilotRslt() && mtr.Publish() == Config.Entities.Publish.Always)
-                {
-                    string[] oneTableRow = new string[tableColumnsCount];
-                    WMeterRsltItemSpec.TableRowNr++;
-
-                    for (int i = 0; i < tableColumnsCount; i++)
-                    {
-                        WMeterRsltItemSpec.TableColumnNr = i + 1;
-                        oneTableRow[i] = items[i].Print(wm, mtr.Name()).Split(new char[] { '|' })[0];
-                    }
-
-                    tableRows.Add(oneTableRow);
-                }
-            }
-        }
-
-
-        void GetContentTestsAreColumns(Results.Entities.WaterMeter wm, IList<WMeterRsltItemSpec> items, out string[] tableHeader, out IList<string[]> tableRows, out Alignment[] itemAlignment)
-        {
-            int tableColumnsCount = 1;
-            foreach (var mtr in wm.MeterTestRslts)
-            {
-                if (mtr != null && mtr.IsPilotRslt() && mtr.Publish() == Config.Entities.Publish.Always)
-                {
-                    tableColumnsCount++;
-                }
-            }
-
-            tableRows = new List<string[]>();
-            tableHeader = new string[tableColumnsCount];
-            itemAlignment = new Alignment[tableColumnsCount];
-            
-            tableHeader[0] = string.Empty;
-            itemAlignment[0] = Alignment.Left;
-            int columnsCount = 1;
-            foreach (var mtr in wm.MeterTestRslts)
-            {
-                if (mtr != null && mtr.IsPilotRslt() && mtr.Publish() == Config.Entities.Publish.Always)
-                {
-                    tableHeader[columnsCount] = mtr.Name();
-                    itemAlignment[columnsCount] = Alignment.Left;
-                    columnsCount++;
-                }
-            }
-            
-            WMeterRsltItemSpec.TableRowNr = 0;
-            for (int i = 0; i < items.Count; i++)
-            {
-                string[] oneTableRow = new string[tableColumnsCount];
-                WMeterRsltItemSpec.TableRowNr++;
-
-                oneTableRow[0] = items[i].Caption;
-
-                WMeterRsltItemSpec.TableColumnNr = 1;
-                foreach (var mtr in wm.MeterTestRslts)
-                {
-                    if (mtr != null && mtr.IsPilotRslt() && mtr.Publish() == Config.Entities.Publish.Always)
-                    {
-                        /// Strip color information
-                        oneTableRow[WMeterRsltItemSpec.TableColumnNr] =
-                            items[i].Print(wm, mtr.Name()).Split(new char[] { '|' })[0];
-                        WMeterRsltItemSpec.TableColumnNr++;
-                    }
-                }
-
-                tableRows.Add(oneTableRow);
-            }
-        }
-
-
-        float DrawTable(System.Drawing.Printing.PrintPageEventArgs e, float left, float top, string[] header, IList<string[]> rows, Alignment[] alignment)
-        {
-            int tblColumnsCount = header.Length;
-
-            float[] columnWidth = new float[tblColumnsCount];
-            float[] columnPos = new float[tblColumnsCount + 1];
-            columnPos[0] = left;
-
-            ///
-            /// Measure table column widths and header height
-            /// 
-            float headerHeight = 0;
-            for (int i = 0; i < tblColumnsCount; i++)
-            {
-                SizeF size = e.Graphics.MeasureString(header[i], headerFont);
-                columnWidth[i] = (int)(size.Width + 0.99f);
-                if (size.Height > headerHeight) headerHeight = (int)(size.Height + 0.99f);
-
-                foreach (var tableRow in rows)
-                {
-                    int width = (int)(e.Graphics.MeasureString(tableRow[i], font).Width + 0.99f);
-                    if (width > columnWidth[i]) columnWidth[i] = width;
-                }
-                columnPos[i + 1] = columnPos[i] + columnWidth[i] + GapBetweenTableColumns;
-            }
-
-            float tableLeftX = columnPos[0];
-            float tableRightX = columnPos[tblColumnsCount] - GapBetweenTableColumns;
-
-            /// Horizontal line
-            float horY = top + 1.5f * spacingOne4Header;
-            e.Graphics.DrawLine(new Pen(Color.Black, 2), new PointF(tableLeftX, horY), new PointF(tableRightX, horY));
-
-            ///
-            /// Draw table header
-            ///
-            for (int i = 0; i < tblColumnsCount; i++)
-            {
-                PrintAt(e, columnPos[i],
-                           top + 1.7f * spacingOne4Header,
-                           columnWidth[i],
-                           header[i],
-                           headerFont,
-                           Alignment.Center);
-            }
-            /// Horizontal line
-            horY = top + 2.1f * spacingOne4Header + headerHeight;
-            e.Graphics.DrawLine(new Pen(Color.Black, 2), new PointF(tableLeftX, horY), new PointF(tableRightX, horY));
-
-            ///
-            /// Draw table body
-            ///
-            int rowsCount = 0;
-            foreach (var oneTableRow in rows)
-            {
-                for (int i = 0; i < tblColumnsCount; i++)
-                {
-                    PrintAt(e, columnPos[i],
-                               horY + 0.2f * spacingOne4Header + spacingOne * rowsCount,
-                               columnWidth[i],
-                               oneTableRow[i],
-                               font,
-                               alignment[i]);
-                }
-                rowsCount++;
-            }
-
-            /// Horizontal line
-            horY = horY + spacingOne * rowsCount + (3 * spacingOne4Header / 10);
-            e.Graphics.DrawLine(new Pen(Color.Black, 2), new PointF(tableLeftX, horY), new PointF(tableRightX, horY));
-
-            return horY - top + spacingOne;
-        }
-
-
-        static Font lastFont = null;
-        static float lastSpacing = 0;
-
-        SizeF Measure(System.Drawing.Printing.PrintPageEventArgs e, string paragraph, Font font)
-        {
-            if (font != lastFont)
-            {
-                lastFont = font;
-                lastSpacing = e.Graphics.MeasureString("Abcgq", font).Height;
-            }
-
-            string[] lines = paragraph.Split(new char[] { '~' });
-            float width = 0;
-            foreach (var line in lines)
-            {
-                float lineWid = e.Graphics.MeasureString(line, font).Width;
-                if (lineWid > width) width = lineWid;
-            }
-
-            return new SizeF(width, 0.8f * lines.Length * lastSpacing + 0.2f);
-        }
-
-
-        void PrintAt(System.Drawing.Printing.PrintPageEventArgs e, float x, float y, float width, string paragraph, Font font, Alignment alignment)
-        {
-            SizeF size = Measure(e, paragraph, font);
-
-            string[] lines = paragraph.Split(new char[] { '~' });
-            foreach (var line in lines)
-            {
-                float xx;
-                switch (alignment)
-                {
-                    default:
-                    case Alignment.Left: xx = x; break;
-                    case Alignment.Center: xx = x + (width - e.Graphics.MeasureString(line, font).Width) / 2; break;
-                    case Alignment.Right: xx = x + width - e.Graphics.MeasureString(line, font).Width; break;
-                }
-                e.Graphics.DrawString(line, font, Brushes.Black, new PointF(xx, y));
-                y += 0.8f * lastSpacing;
-            }
-        }
     }
 }

Results/Output/Printers/OnePerMeter/OnePerMeterPrinterCfg.cs

@@ -27,12 +27,24 @@ namespace Results.Output.Printers.OnePerMeter
         public bool SupressPrinting;		/// Bypass printing when true
 		public System.Globalization.CultureInfo CultureInfo;
         public string Header;				/// =Title
-        public string[] CommonItems;
-		public string[] TestItems;
+        public int ColW0Pct;
+        public int ColW1Pct;
+        public int ColW2Pct;
+        public string[] CommonItems1;
+        public string[] CommonItems2;
+        public string[] CommonItems3;
+        public Config.Entities.TableForm Form;
+        public string[] TestItems;
+        public Config.Entities.TableForm Form2;
         public string[] TestItems2;
-		public string Footer;
+        public int BelowW0Pct;
+        public int BelowW1Pct;
+        public int BelowW2Pct;
+        public string[] BelowItems1;
+        public string[] BelowItems2;
+        public string[] BelowItems3;
+        public string Footer;
         public bool TestsAreRows;
-        public bool TestsAreRows2;
         public string ImgFullPathName;
         public int ImgLeft;
         public int ImgTop;

Results/Output/Printers/PrintersCommon.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Drawing.Printing;
+using Config.Entities;
+
+namespace Results.Output.Printers
+{
+    public class PrintersCommon : PrintDocument
+    {
+        static Font lastFont = null;
+        static float lastSpacing = 0;
+
+        /// <summary>
+        /// Measure the size of a paragraph of text, lines are separated by '~'.
+        /// </summary>
+        /// <param name="e">PrintPageEventArgs</param>
+        /// <param name="text">Text, lines are separated by '~'</param>
+        /// <param name="font">Font</param>
+        /// <returns>Size of the paragraph of text</returns>
+        public static SizeF Measure(System.Drawing.Printing.PrintPageEventArgs e, string text, Font font)
+        {
+            if (font != lastFont)
+            {
+                lastFont = font;
+                lastSpacing = e.Graphics.MeasureString("Abcgq", font).Height;
+            }
+
+            string[] lines = text.Split(new char[] { '~' });
+            float width = 0;
+            foreach (var line in lines)
+            {
+                float lineWid = e.Graphics.MeasureString(line, font).Width;
+                if (lineWid > width) width = lineWid;
+            }
+
+            return new SizeF(width, 0.8f * lines.Length * lastSpacing + 0.2f);
+        }
+
+        /// <summary>
+        /// Print a paragraph of text, lines are separated by '~'.
+        /// </summary>
+        /// <param name="e">PrintPageEventArgs</param>
+        /// <param name="text">Text, lines are separated by '~'</param>
+        /// <param name="font">Font</param>
+        /// <param name="x">Position x</param>
+        /// <param name="y">Position y</param>
+        /// <param name="width">Width (required when alignment=Alignment.Center or alignment=Aligmenr.Right</param>
+        /// <param name="height">Height, 0 = no vertical centering</param>
+        /// <param name="horizAlignment">Horizontal alignment</param>
+        /// <param name="vertAlignment">Vertical alignment</param>
+        public static void PrintAt(System.Drawing.Printing.PrintPageEventArgs e, string text, Font font,
+                                   float x, float y, float width, float height,
+                                   Alignment horizAlignment, VertAlignment vertAlignment)
+        {
+            SizeF size = PrintersCommon.Measure(e, text, font);
+
+            string[] lines = text.Split(new char[] { '~' });
+
+            if (height <= size.Height) vertAlignment = VertAlignment.Top;
+            float y0;
+            switch (vertAlignment)
+            {
+                default:
+                case VertAlignment.Top:     y0 = y; break;
+                case VertAlignment.Middle:  y0 = y + (height - size.Height) / 2; break;
+                case VertAlignment.Bottom:  y0 = y + (height - size.Height); break;
+            }
+                     
+            foreach (var line in lines)
+            {
+                float x0;
+                switch (horizAlignment)
+                {
+                    default:
+                    case Alignment.Left:    x0 = x; break;
+                    case Alignment.Center:  x0 = x + (width - e.Graphics.MeasureString(line, font).Width) / 2; break;
+                    case Alignment.Right:   x0 = x + width - e.Graphics.MeasureString(line, font).Width; break;
+                }
+                e.Graphics.DrawString(line, font, Brushes.Black, new PointF(x0, y0));
+                y0 += 0.8f * lastSpacing;
+            }
+        }
+    }
+}

Results/Output/Printers/Table.cs

@@ -0,0 +1,413 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Drawing.Printing;
+using Config.Entities;
+
+namespace Results.Output.Printers
+{
+    public enum TableLines
+    {
+        None,
+        FirstAndLast,
+        FirstSecondAndLast,
+        All,
+    }
+
+    public class TableStyle
+    {
+        public float MarginX;
+        public float MarginY;
+        public Font Font;
+        public Font HeaderFont;
+        public int TopHeadersCount;
+        public int LeftHeadersCount;
+        public float LineWidth;
+        public TableLines HorizLines;
+        public TableLines VertLines;
+    }
+
+    public class Table
+    {
+        public readonly int ColumnsCount;
+        public int RowsCount { get { return Rows.Count; } }
+
+        public readonly IList<string[]> Rows;
+        public readonly IList<Alignment[]> HorizAlignments;
+        public readonly IList<VertAlignment[]> VertAlignments;
+        public TableStyle Style;
+
+
+        public Table(int columnsCount)
+        {
+            ColumnsCount = columnsCount;
+
+            Rows = new List<string[]>();
+            HorizAlignments = new List<Alignment[]>();
+            VertAlignments = new List<VertAlignment[]>();
+            Style = new TableStyle();
+        }
+
+
+        public void AddRow(string[] texts, Alignment[] horizAlignment, VertAlignment[] vertAlignemnt)
+        {
+            Rows.Add(texts);
+            HorizAlignments.Add(horizAlignment);
+            VertAlignments.Add(vertAlignemnt);
+        }
+
+
+        public SizeF Measure(System.Drawing.Printing.PrintPageEventArgs e)
+        {
+            SizeF retVal = new SizeF(0, 0);
+            if (RowsCount == 0) return retVal;
+
+            float[] columnWidth = new float[ColumnsCount];
+            float[] rowHeight = new float[RowsCount];
+
+            ///
+            /// Measure table column widths and header height
+            /// 
+            for (int colIx = 0; colIx < ColumnsCount; colIx++)
+            {
+                for (int rowIx = 0; rowIx < RowsCount; rowIx++)
+                {
+                    if (Rows[rowIx] == null)
+                    {
+                        /// Separator row -> do nothing
+                    }
+                    else
+                    {
+                        bool isHeader = (colIx < Style.LeftHeadersCount) || (rowIx < Style.TopHeadersCount);
+                        SizeF size = PrintersCommon.Measure(e, Rows[rowIx][colIx], isHeader ? Style.HeaderFont : Style.Font);
+                        if (size.Width > columnWidth[colIx]) columnWidth[colIx] = size.Width;
+                        if (size.Height > rowHeight[rowIx]) rowHeight[rowIx] = size.Height;
+                    }
+                }
+
+                bool hasLineToTheLeft = (Style.VertLines == TableLines.All)
+                                     || ((Style.VertLines == TableLines.FirstAndLast) && (colIx == 0))
+                                     || ((Style.VertLines == TableLines.FirstSecondAndLast) && (colIx <= 1));
+
+                retVal.Width += columnWidth[colIx] + (hasLineToTheLeft ? (Style.LineWidth + Style.MarginX) : 0) + Style.MarginX;
+            }
+            for (int rowIx = 0; rowIx < RowsCount; rowIx++)
+            {
+                if (Rows[rowIx] == null)
+                {
+                    /// Separator row -> do nothing
+                }
+                else
+                {
+                    bool hasLineAbove = (Style.HorizLines == TableLines.All)
+                                     || ((Style.HorizLines == TableLines.FirstAndLast) && (rowIx == 0))
+                                     || ((Style.HorizLines == TableLines.FirstSecondAndLast) && (rowIx <= 1))
+                                     || ((rowIx >= 1) && (Rows[rowIx - 1] == null));
+
+                    retVal.Height += rowHeight[rowIx] + (hasLineAbove ? (Style.LineWidth + Style.MarginY) : 0) + Style.MarginY;
+                }
+            }
+
+            if (Style.VertLines == TableLines.None) retVal.Width -= Style.MarginX;
+            if (Style.HorizLines == TableLines.None) retVal.Height -= Style.MarginY;
+
+            return retVal;
+        }
+
+
+        public float Draw(System.Drawing.Printing.PrintPageEventArgs e, float left, float top)
+        {
+            if (RowsCount == 0) return top;
+
+            int tblColumnsCount = Rows[0].Length;
+            
+            float[] columnWidth = new float[tblColumnsCount];
+            float[] columnPos = new float[tblColumnsCount];
+            float[] vertLinePos = new float[tblColumnsCount + 1];
+
+            float[] rowHeight = new float[RowsCount];
+            float[] rowPos = new float[RowsCount];
+            float[] horizLinePos = new float[RowsCount + 1];
+
+            ///
+            /// Measure table column widths and header height
+            /// 
+            vertLinePos[0] = left;
+            horizLinePos[0] = top;
+            for (int colIx = 0; colIx < tblColumnsCount; colIx++)
+            {
+                for (int rowIx = 0; rowIx < RowsCount; rowIx++)
+                {
+                    if (Rows[rowIx] != null)
+                    {
+                        /// In not a separator line
+                        bool isHeader = (colIx < Style.LeftHeadersCount) || (rowIx < Style.TopHeadersCount);
+                        SizeF size = PrintersCommon.Measure(e, Rows[rowIx][colIx], isHeader ? Style.HeaderFont : Style.Font);
+                        if (size.Width > columnWidth[colIx]) columnWidth[colIx] = size.Width;
+                        if (size.Height > rowHeight[rowIx]) rowHeight[rowIx] = size.Height;
+                    }
+                    else
+                    {
+                        /// Separator line -> do nothing                        
+                        rowHeight[rowIx] = 0;
+                    }
+                }
+
+                bool hasLineToTheLeft = (Style.VertLines == TableLines.All)
+                                     || ((Style.VertLines == TableLines.FirstAndLast) && (colIx == 0))
+                                     || ((Style.VertLines == TableLines.FirstSecondAndLast) && (colIx <= 1));
+
+                columnPos[colIx] = vertLinePos[colIx] + (hasLineToTheLeft ? (Style.LineWidth + Style.MarginX) : 0);
+                vertLinePos[colIx + 1] = columnPos[colIx] + columnWidth[colIx] + Style.MarginX;
+            }
+            for (int rowIx = 0; rowIx < RowsCount; rowIx++)
+            {
+                if (Rows[rowIx] != null)
+                {
+                    /// In not a separator line
+                    bool hasLineAbove = (Style.HorizLines == TableLines.All)
+                                     || ((Style.HorizLines == TableLines.FirstAndLast) && (rowIx == 0))
+                                     || ((Style.HorizLines == TableLines.FirstSecondAndLast) && (rowIx <= 1))
+                                     || ((rowIx >= 1) && (Rows[rowIx - 1] == null));
+
+                    rowPos[rowIx] = horizLinePos[rowIx] + (hasLineAbove ? Style.MarginY : 0);
+                    horizLinePos[rowIx + 1] = rowPos[rowIx] + rowHeight[rowIx] + Style.LineWidth + Style.MarginY;
+                }
+                else if (rowIx > 0)
+                {
+                    /// Separator line
+                    rowPos[rowIx] = rowPos[rowIx - 1];
+                    horizLinePos[rowIx + 1] = horizLinePos[rowIx];
+                }
+            }
+
+            /// Horizontal lines
+            float tableLeftX = left;
+            float tableRightX = vertLinePos[tblColumnsCount] + Style.LineWidth;
+            if (Style.HorizLines != TableLines.None)
+            {
+                for (int rowIx = 0; rowIx <= RowsCount; rowIx++)
+                {
+                    if (Style.HorizLines == TableLines.All || rowIx == 0
+                                                           || rowIx == RowsCount
+                                                           || (Style.HorizLines == TableLines.FirstSecondAndLast && rowIx == 1)
+                                                           || ((rowIx >= 1) && (Rows[rowIx - 1] == null)))
+                    {
+                        e.Graphics.DrawLine(new Pen(Color.Black, Style.LineWidth), new PointF(tableLeftX, horizLinePos[rowIx] + Style.LineWidth / 2), new PointF(tableRightX, horizLinePos[rowIx] + Style.LineWidth / 2));
+                    }
+                }
+            }
+
+            /// Vertical lines
+            float tableTopY = top;
+            float tableBottomY = horizLinePos[RowsCount] + Style.LineWidth;
+            if (Style.VertLines != TableLines.None)
+            {
+                for (int colIx = 0; colIx <= tblColumnsCount; colIx++)
+                {
+                    if (Style.VertLines == TableLines.All || colIx == 0 || colIx == ColumnsCount || (Style.VertLines == TableLines.FirstSecondAndLast && colIx == 1))
+                    {
+                        e.Graphics.DrawLine(new Pen(Color.Black, Style.LineWidth), new PointF(vertLinePos[colIx] + Style.LineWidth / 2, tableTopY), new PointF(vertLinePos[colIx] + Style.LineWidth / 2, tableBottomY));
+                    }
+                }
+            }
+
+            ///
+            /// Draw table body
+            ///
+            for (int rowIndex = 0; rowIndex < RowsCount; rowIndex++)
+            {
+                string[] oneTableRow = Rows[rowIndex];
+                if (oneTableRow != null)
+                {
+                    Alignment[] horizAlignment = HorizAlignments[(RowsCount > rowIndex) ? rowIndex : 0];
+                    VertAlignment[] vertAlignment = VertAlignments[(RowsCount > rowIndex) ? rowIndex : 0];
+                    for (int colIndex = 0; colIndex < tblColumnsCount; colIndex++)
+                    {
+                        bool isHeader = (colIndex < Style.LeftHeadersCount) || (rowIndex < Style.TopHeadersCount);
+                        PrintersCommon.PrintAt(e, oneTableRow[colIndex],
+                                                  isHeader ? Style.HeaderFont : Style.Font,
+                                                  columnPos[colIndex],
+                                                  rowPos[rowIndex],
+                                                  columnWidth[colIndex],
+                                                  rowHeight[rowIndex],
+                                                  horizAlignment[colIndex],
+                                                  vertAlignment[colIndex]);
+                    }
+                }
+            }
+
+            return tableBottomY;
+        }
+
+
+        public static Table Create_TestsAreRows(Results.Entities.WaterMeter wm, IList<WMeterRsltItemSpec> items, TableStyle style)
+        {
+            /// Top row contains column captions
+
+            Table table = new Table(items.Count);
+            table.Style = style;
+
+            string[] tableHeader = new string[table.ColumnsCount];
+            Alignment[] horizAlignment = new Alignment[table.ColumnsCount];
+            VertAlignment[] vertAlignment = new VertAlignment[table.ColumnsCount];
+            for (int i = 0; i < table.ColumnsCount; i++)
+            {
+                tableHeader[i] = items[i].Caption;
+                horizAlignment[i] = Alignment.Center;
+                vertAlignment[i] = VertAlignment.Middle;
+            }
+            table.AddRow(tableHeader, horizAlignment, vertAlignment);
+
+            WMeterRsltItemSpec.TableRowNr = 1;
+            foreach (var mtr in wm.MeterTestRslts)
+            {
+                if (mtr != null && mtr.IsPilotRslt() && mtr.Publish() == Config.Entities.Publish.Always)
+                {
+                    string[] oneTableRow = new string[table.ColumnsCount];
+                    horizAlignment = new Alignment[table.ColumnsCount];
+                    vertAlignment = new VertAlignment[table.ColumnsCount];
+
+                    for (int i = 0; i < table.ColumnsCount; i++)
+                    {
+                        WMeterRsltItemSpec.TableColumnNr = i + 1;
+                        oneTableRow[i] = items[i].Print(wm, mtr.Name()).Split(new char[] { '|' })[0];
+                        horizAlignment[i] = items[i].Alignment;
+                        vertAlignment[i] = VertAlignment.Middle;
+                    }
+
+                    table.AddRow(oneTableRow, horizAlignment, vertAlignment);
+
+                    WMeterRsltItemSpec.TableRowNr++;
+                }
+            }
+
+            return table;
+        }
+
+
+        public static Table Create_TestsAreColumns(Results.Entities.WaterMeter wm, IList<WMeterRsltItemSpec> items, TableStyle style)
+        {
+            /// Left column contains row captions
+
+            ///
+            /// Calculate columns count
+            ///
+            int columnsCount = 1;          /// Left column contains item caption                         
+            foreach (var mtr in wm.MeterTestRslts)
+            {
+                if (mtr != null && mtr.IsPilotRslt() && mtr.Publish() == Config.Entities.Publish.Always)
+                {
+                    columnsCount++;        /// One additional column for each test to be published
+                }
+            }
+
+            Table table = new Table(columnsCount);
+            table.Style = style;
+
+            ///
+            /// Table content
+            ///
+            WMeterRsltItemSpec.TableRowNr = 1;
+            for (int i = 0; i < items.Count; i++)
+            {
+                string[] oneTableRow = new string[columnsCount];
+                Alignment[] horizAlignment = new Alignment[columnsCount];
+                VertAlignment[] vertAlignment = new VertAlignment[columnsCount];
+
+                oneTableRow[0] = items[i].Caption;
+                horizAlignment[0] = Alignment.Center;
+                vertAlignment[0] = VertAlignment.Middle;
+
+                WMeterRsltItemSpec.TableColumnNr = 1;
+                foreach (var mtr in wm.MeterTestRslts)
+                {
+                    if (mtr != null && mtr.IsPilotRslt() && mtr.Publish() == Config.Entities.Publish.Always)
+                    {
+                        /// Strip color information
+                        oneTableRow[WMeterRsltItemSpec.TableColumnNr] =
+                            items[i].Print(wm, mtr.Name()).Split(new char[] { '|' })[0];
+                        horizAlignment[WMeterRsltItemSpec.TableColumnNr] = items[i].Alignment;
+                        vertAlignment[WMeterRsltItemSpec.TableColumnNr] = VertAlignment.Middle;
+
+                        WMeterRsltItemSpec.TableColumnNr++;
+                    }
+                }
+
+                table.AddRow(oneTableRow, horizAlignment, vertAlignment);
+
+                WMeterRsltItemSpec.TableRowNr++;
+            }
+
+            return table;
+        }
+
+
+        public static Table Create_TestsAreColumnsPL(Results.Entities.WaterMeter wm, IList<WMeterRsltItemSpec> items, TableStyle style)
+        {
+            /// Left column contains row captions
+
+            ///
+            /// Calculate columns count
+            ///
+            int columnsCount = 2;          /// Left two columns contain item caption and units
+            foreach (var mtr in wm.MeterTestRslts)
+            {
+                if (mtr != null && mtr.IsPilotRslt() && mtr.Publish() == Config.Entities.Publish.Always)
+                {
+                    columnsCount++;        /// One additional column for each test to be published
+                }
+            }
+
+            Table table = new Table(columnsCount);
+            table.Style = style;
+
+            ///
+            /// Table content
+            ///
+            WMeterRsltItemSpec.TableRowNr = 1;
+            for (int i = 0; i < items.Count; i++)
+            {
+                if (items[i].Uid == (int)ItemID.Separator)
+                {
+                    table.AddRow(null, null, null);     /// 'separator' row
+                }
+                else
+                {
+                    string[] oneTableRow = new string[columnsCount];
+                    Alignment[] horizAlignment = new Alignment[columnsCount];
+                    VertAlignment[] vertAlignment = new VertAlignment[columnsCount];
+
+                    oneTableRow[0] = items[i].Caption;
+                    horizAlignment[0] = Alignment.Center;
+                    vertAlignment[0] = VertAlignment.Middle;
+
+                    oneTableRow[1] = (i == 0) ? "Jednostka" : items[i].Units.ToDescription();
+                    horizAlignment[1] = Alignment.Center;
+                    vertAlignment[1] = VertAlignment.Middle;
+
+                    WMeterRsltItemSpec.TableColumnNr = 1;
+                    foreach (var mtr in wm.MeterTestRslts)
+                    {
+                        if (mtr != null && mtr.IsPilotRslt() && mtr.Publish() == Config.Entities.Publish.Always)
+                        {
+                            int colIx = WMeterRsltItemSpec.TableColumnNr + 1;
+
+                            /// Strip color information
+                            oneTableRow[colIx] = items[i].Print(wm, mtr.Name()).Split(new char[] { '|' })[0];
+                            horizAlignment[colIx] = items[i].Alignment;
+                            vertAlignment[colIx] = VertAlignment.Middle;
+
+                            WMeterRsltItemSpec.TableColumnNr++;
+                        }
+                    }
+
+                    table.AddRow(oneTableRow, horizAlignment, vertAlignment);
+                }
+                WMeterRsltItemSpec.TableRowNr++;
+            }
+
+            return table;
+        }
+    }
+}

Results/Properties/AssemblyInfo.cs

@@ -10,7 +10,7 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("Sensus")]
 [assembly: AssemblyProduct("Results")]
-[assembly: AssemblyCopyright("Copyright © 2013 - 2017 Sensus Slovensko, a.s.")]
+[assembly: AssemblyCopyright("Copyright © 2013 - 2018 Sensus Slovensko, a.s.")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
@@ -32,5 +32,5 @@ using System.Runtime.InteropServices;
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("2.17.762.0")]
-[assembly: AssemblyFileVersion("2.17.762.0")]
+[assembly: AssemblyVersion("2.18.918.0")]
+[assembly: AssemblyFileVersion("2.18.918.0")]

Results/Resources/Strings.Designer.cs

@@ -1303,7 +1303,7 @@ namespace Results.Resources {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Flow calculated from conventional true volume and the time.
+        ///   Looks up a localized string similar to Flow measured by the reference flow meter.
         /// </summary>
         internal static string Tooltip_Q_v_r {
             get {
@@ -1411,7 +1411,7 @@ namespace Results.Resources {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Temperature at the diverter at start of the test – first 4 measurements from the start.
+        ///   Looks up a localized string similar to Temperature at the diverter at start of the test – first 4 measurements after the start.
         /// </summary>
         internal static string Tooltip_T_di_st {
             get {
@@ -1474,7 +1474,7 @@ namespace Results.Resources {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Temperature at the outlet at start of the test – first 4 measurements from the start.
+        ///   Looks up a localized string similar to Temperature at the outlet at start of the test – first 4 measurements after the start.
         /// </summary>
         internal static string Tooltip_T_dw_st {
             get {
@@ -1482,6 +1482,69 @@ namespace Results.Resources {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Actual temperature in the line.
+        /// </summary>
+        internal static string Tooltip_T_ln_ac {
+            get {
+                return ResourceManager.GetString("Tooltip_T_ln_ac", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Average temperature in the line during a test.
+        /// </summary>
+        internal static string Tooltip_T_ln_avg {
+            get {
+                return ResourceManager.GetString("Tooltip_T_ln_avg", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Temperature in the line at end of the test – last 4 measurement before the end.
+        /// </summary>
+        internal static string Tooltip_T_ln_en {
+            get {
+                return ResourceManager.GetString("Tooltip_T_ln_en", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Maximum temperature in the line during the test.
+        /// </summary>
+        internal static string Tooltip_T_ln_max {
+            get {
+                return ResourceManager.GetString("Tooltip_T_ln_max", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Mean temperature in the line during a test.
+        /// </summary>
+        internal static string Tooltip_T_ln_me {
+            get {
+                return ResourceManager.GetString("Tooltip_T_ln_me", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Minimum temperature in the line during the test.
+        /// </summary>
+        internal static string Tooltip_T_ln_min {
+            get {
+                return ResourceManager.GetString("Tooltip_T_ln_min", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Temperature in the line at start of the test – first 4 measurements after the start.
+        /// </summary>
+        internal static string Tooltip_T_ln_st {
+            get {
+                return ResourceManager.GetString("Tooltip_T_ln_st", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Temperature of water sample at water density calibration.
         /// </summary>
@@ -1546,7 +1609,7 @@ namespace Results.Resources {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Temperature at the inlet at start of the test – first 4 measurements from the start.
+        ///   Looks up a localized string similar to Temperature at the inlet at start of the test – first 4 measurements after the start.
         /// </summary>
         internal static string Tooltip_T_up_st {
             get {
@@ -1581,6 +1644,15 @@ namespace Results.Resources {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Unit.
+        /// </summary>
+        internal static string Unit {
+            get {
+                return ResourceManager.GetString("Unit", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Units.
         /// </summary>

Results/Resources/Strings.cs.resx

@@ -210,4 +210,7 @@
   <data name="to" xml:space="preserve">
     <value>do</value>
   </data>
+  <data name="Unit" xml:space="preserve">
+    <value>Jednotka</value>
+  </data>
 </root>

Results/Resources/Strings.pl.resx

@@ -438,4 +438,7 @@
   <data name="to" xml:space="preserve">
     <value>do</value>
   </data>
+  <data name="Unit" xml:space="preserve">
+    <value>Jednostka</value>
+  </data>
 </root>

Results/Resources/Strings.resx

@@ -514,7 +514,7 @@
     <value>Flow obtained from the master meter - mean</value>
   </data>
   <data name="Tooltip_Q_v_r" xml:space="preserve">
-    <value>Flow calculated from conventional true volume and the time</value>
+    <value>Flow measured by the reference flow meter</value>
   </data>
   <data name="Tooltip_T_di_ac" xml:space="preserve">
     <value>Actual temperature at the diverter</value>
@@ -529,7 +529,7 @@
     <value>Mean temperature at diverter</value>
   </data>
   <data name="Tooltip_T_di_st" xml:space="preserve">
-    <value>Temperature at the diverter at start of the test – first 4 measurements from the start</value>
+    <value>Temperature at the diverter at start of the test – first 4 measurements after the start</value>
   </data>
   <data name="Tooltip_T_dw_ac" xml:space="preserve">
     <value>Actual temperature at the outlet</value>
@@ -544,7 +544,7 @@
     <value>Mean temperature at outlet</value>
   </data>
   <data name="Tooltip_T_dw_st" xml:space="preserve">
-    <value>Temperature at the outlet at start of the test – first 4 measurements from the start</value>
+    <value>Temperature at the outlet at start of the test – first 4 measurements after the start</value>
   </data>
   <data name="Tooltip_T_up_ac" xml:space="preserve">
     <value>Actual temperature at the inlet</value>
@@ -559,7 +559,7 @@
     <value>Mean temperature at inlet during a test</value>
   </data>
   <data name="Tooltip_T_up_st" xml:space="preserve">
-    <value>Temperature at the inlet at start of the test – first 4 measurements from the start</value>
+    <value>Temperature at the inlet at start of the test – first 4 measurements after the start</value>
   </data>
   <data name="aux" xml:space="preserve">
     <value>aux.</value>
@@ -699,4 +699,28 @@
   <data name="Tooltip_T_rho_0" xml:space="preserve">
     <value>Temperature of water sample at water density calibration</value>
   </data>
+  <data name="Tooltip_T_ln_ac" xml:space="preserve">
+    <value>Actual temperature in the line</value>
+  </data>
+  <data name="Tooltip_T_ln_avg" xml:space="preserve">
+    <value>Average temperature in the line during a test</value>
+  </data>
+  <data name="Tooltip_T_ln_en" xml:space="preserve">
+    <value>Temperature in the line at end of the test – last 4 measurement before the end</value>
+  </data>
+  <data name="Tooltip_T_ln_max" xml:space="preserve">
+    <value>Maximum temperature in the line during the test</value>
+  </data>
+  <data name="Tooltip_T_ln_me" xml:space="preserve">
+    <value>Mean temperature in the line during a test</value>
+  </data>
+  <data name="Tooltip_T_ln_min" xml:space="preserve">
+    <value>Minimum temperature in the line during the test</value>
+  </data>
+  <data name="Tooltip_T_ln_st" xml:space="preserve">
+    <value>Temperature in the line at start of the test – first 4 measurements after the start</value>
+  </data>
+  <data name="Unit" xml:space="preserve">
+    <value>Unit</value>
+  </data>
 </root>

Results/Results.csproj

@@ -18,7 +18,7 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>TRACE;DEBUG;MUNICH</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;MUNICH;LANG_DE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <PlatformTarget>x86</PlatformTarget>
@@ -27,7 +27,7 @@
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE;MUNICH</DefineConstants>
+    <DefineConstants>TRACE;MUNICH;LANG_DE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
@@ -97,13 +97,13 @@
     <Compile Include="Mappings\TestRsltMap.cs" />
     <Compile Include="Mappings\WaterMeterDataMap.cs" />
     <Compile Include="Mappings\WaterMeterMap.cs" />
-    <Compile Include="Output\Printers\Cevak\PrintDocumentCevak.cs">
-      <SubType>Component</SubType>
-    </Compile>
     <Compile Include="Output\Printers\Enhanced\EnhancedPrintDocument.cs">
       <SubType>Component</SubType>
     </Compile>
     <Compile Include="Output\Printers\Enhanced\EnhancedPrinterCfg.cs" />
+    <Compile Include="Output\Printers\PrintersCommon.cs">
+      <SubType>Component</SubType>
+    </Compile>
     <Compile Include="Output\Printers\Munich\MunichPrintDocument.cs">
       <SubType>Component</SubType>
     </Compile>
@@ -111,12 +111,12 @@
       <SubType>Component</SubType>
     </Compile>
     <Compile Include="Output\Printers\OnePerMeter\OnePerMeterPrinterCfg.cs" />
+    <Compile Include="Output\Printers\Table.cs" />
     <Compile Include="Output\Printers\Zapiska\ZapiskaPrintDocument.cs">
       <SubType>Component</SubType>
     </Compile>
     <Compile Include="Output\Printers\Zapiska\ZapiskaPrinterCfg.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="ItemSpec.cs" />
     <Compile Include="Properties\Resources.Designer.cs">
       <AutoGen>True</AutoGen>
       <DesignTime>True</DesignTime>