michal/tbf
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Config.Data --> TBF.Data and TBF.DB, etc.

Browse Source
This commit is contained in:
Milan Hanajik 2021-09-19 22:04:16 +02:00
parent 2cc92f3980
commit bb0361319d
111 changed files with 630 additions and 575 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
Config/Data.cs
View File

@ -15,10 +15,10 @@ namespace Config
public const int HeatMetersCount = 0;
public const int MaxPartNr = 1;
#elif MUNICH
public const int WMsCount = 3;
public const int LineSize = 3;
public const int CompoundWMsCount = 3;
public const int HeatMetersCount = 0;
public const int WMsCount = 3;
public const int LineSize = 3;
public const int CompoundWMsCount = 3;
public const int HeatMetersCount = 0;
public const int MaxPartNr = 3;
#elif MALTA_WSD25
public const int WMsCount = 6;
@ -88,11 +88,6 @@ 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;
public static double RealDensity = 0; /// true water density [kg/m3]
public static double AtTemperature = 0; /// measured at temperature [°C]
public static double Buoyancy = 0;

23
Config/Entities/Test.cs
View File

@ -425,29 +425,6 @@ namespace Config.Entities
return false;
}
/// <summary>
/// Determines whether tests part number is OK.
/// Examples of correct part number are:
/// 1, 2, 12, 21 in case of max. part nr.== 2
/// 1, 2, 3, 4, 12, 13, 14, 23, 24, 34, 123, 124, 134, 234, 1234 in case of max. part nr.== 4
/// </summary>
/// <param name="partNr">Tests par tnumber</param>
/// <returns>true when Part number is OK</returns>
public static bool IsGoodPartNr(int partNr)
{
bool firstDigitIsOK = ((partNr % 10) > 0) && ((partNr % 10) <= Config.Data.MaxPartNr);
bool secondDigitIsOK = (((partNr/10) % 10) > 0) && (((partNr/10) % 10) <= Config.Data.MaxPartNr);
bool thirdDigitIsOK = (((partNr/100) % 10) > 0) && (((partNr/100) % 10) <= Config.Data.MaxPartNr);
bool fourthDigitIsOK = (((partNr/1000) % 10) > 0) && (((partNr/1000) % 10) <= Config.Data.MaxPartNr);
if (firstDigitIsOK && (partNr / 10 == 0)) return true;
if (firstDigitIsOK && secondDigitIsOK && (partNr / 100 == 0)) return true;
if (firstDigitIsOK && secondDigitIsOK && thirdDigitIsOK && (partNr / 1000 == 0)) return true;
if (firstDigitIsOK && secondDigitIsOK && thirdDigitIsOK && fourthDigitIsOK && (partNr / 10000 == 0)) return true;
return false;
}
public override string ToString()
{
string partStr = (Part > 0) ? string.Format(", part {0}", Part) : string.Empty;

45
Config/FluentCommon.cs
View File

@ -14,40 +14,6 @@ namespace Config
{
public static class FluentCommon
{
/// <summary>
/// Session factories for regular sessions.
/// </summary>
public static ISessionFactory[] SessionFactories = new ISessionFactory[(int)Users.Entities.DBKind.Count];
/// <summary>
/// NHibernate session factory (to create the database session 'SessionFactory')
/// </summary>
/// <returns>A database session</returns>
static ISessionFactory CreateSessionFactory(Users.Entities.DBKind database)
{
Users.Entities.DBType dbType;
string connectionString;
switch (database)
{
default:
case Users.Entities.DBKind.Config:
dbType = Data.CurrentBench.ProceduresDBSettings.DbType;
connectionString = Data.CurrentBench.ProceduresDBSettings.ConnectionString;
break;
case Users.Entities.DBKind.Results:
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);
}
/// <summary>
/// NHibernate session factory (to create the database session 'SessionFactory')
/// </summary>
@ -116,17 +82,6 @@ namespace Config
new SchemaExport(config).Create(true, true);
}
/// Create a NHibernate session for the given database
public static ISession CreateSession(Users.Entities.DBKind database)
{
if (database < 0 || database >= Users.Entities.DBKind.Count) return null;
int ix = (int)database;
if (SessionFactories[ix] == null) SessionFactories[ix] = CreateSessionFactory(database);
return SessionFactories[ix].OpenSession();
}
/// <summary>
/// Create an empty users database.
/// Database contains only the user 'admin' and the control board component 'CB'.

4
TBF/BenchControl/DataEntry/Combined/CycleBeginningForm.cs
View File

@ -44,9 +44,9 @@ namespace TBF.BenchControl.DataEntry.Combined
/// Default constructor - Default number of compound water meters
/// </summary>
public CycleBeginningForm()
: this (Config.Data.CompoundWMsCount, false)
: this (TBF.Data.CompoundWMsCount, false)
{
this.WaterMetersCount = Config.Data.CompoundWMsCount;
this.WaterMetersCount = TBF.Data.CompoundWMsCount;
}
/// <summary>

16
TBF/BenchControl/DataEntry/Combined/CycleEndForm.cs
View File

@ -35,10 +35,10 @@ namespace TBF.BenchControl.DataEntry.Combined
InitializeComponent();
ControlBox = false;
MainStateText = new string[Config.Data.CompoundWMsCount];
AuxStateText = new string[Config.Data.CompoundWMsCount];
QRise = new float[Config.Data.CompoundWMsCount];
QFall = new float[Config.Data.CompoundWMsCount];
MainStateText = new string[TBF.Data.CompoundWMsCount];
AuxStateText = new string[TBF.Data.CompoundWMsCount];
QRise = new float[TBF.Data.CompoundWMsCount];
QFall = new float[TBF.Data.CompoundWMsCount];
completed = false;
StartForceCloseHandler();
@ -77,7 +77,7 @@ namespace TBF.BenchControl.DataEntry.Combined
qRise1TextBox.Text = Utils.DoubleToStr(Sequences.SequenceBase.Qrise, 3);
qFall1TextBox.Text = Utils.DoubleToStr(Sequences.SequenceBase.Qfall, 3);
if (Config.Data.CompoundWMsCount >= 2)
if (TBF.Data.CompoundWMsCount >= 2)
{
qRise2TextBox.Text = Utils.DoubleToStr(Sequences.SequenceBase.Qrise, 3);
qFall2TextBox.Text = Utils.DoubleToStr(Sequences.SequenceBase.Qfall, 3);
@ -88,7 +88,7 @@ namespace TBF.BenchControl.DataEntry.Combined
Height = 305;
}
if (Config.Data.CompoundWMsCount >= 3)
if (TBF.Data.CompoundWMsCount >= 3)
{
qRise3TextBox.Text = Utils.DoubleToStr(Sequences.SequenceBase.Qrise, 3);
qFall3TextBox.Text = Utils.DoubleToStr(Sequences.SequenceBase.Qfall, 3);
@ -109,7 +109,7 @@ namespace TBF.BenchControl.DataEntry.Combined
if (Utils.TryParseUFloat(qRise1TextBox.Text, out ftmp)) { QRise[0] = ftmp; } else { allOK = false; }
if (Utils.TryParseUFloat(qFall1TextBox.Text, out ftmp)) { QFall[0] = ftmp; } else { allOK = false; }
if (Config.Data.CompoundWMsCount >= 2)
if (TBF.Data.CompoundWMsCount >= 2)
{
MainStateText[1] = mainState2TextBox.Text;
AuxStateText[1] = auxState2TextBox.Text;
@ -117,7 +117,7 @@ namespace TBF.BenchControl.DataEntry.Combined
if (Utils.TryParseUFloat(qFall2TextBox.Text, out ftmp)) { QFall[1] = ftmp; } else { allOK = false; }
}
if (Config.Data.CompoundWMsCount >= 3)
if (TBF.Data.CompoundWMsCount >= 3)
{
MainStateText[2] = mainState3TextBox.Text;
AuxStateText[2] = auxState3TextBox.Text;

22
TBF/BenchControl/DataEntry/Combined/EntryForm.cs
View File

@ -70,11 +70,11 @@ namespace TBF.BenchControl.DataEntry.Combined
public override void Initialize()
{
disabled = new bool[Config.Data.CompoundWMsCount];
wmStartState = new double[Config.Data.CompoundWMsCount * 2];
wmStartStateStr = new string[Config.Data.CompoundWMsCount * 2];
wmEndState = new double[Config.Data.CompoundWMsCount * 2];
wmCycleEndState = new string[Config.Data.CompoundWMsCount * 2];
disabled = new bool[TBF.Data.CompoundWMsCount];
wmStartState = new double[TBF.Data.CompoundWMsCount * 2];
wmStartStateStr = new string[TBF.Data.CompoundWMsCount * 2];
wmEndState = new double[TBF.Data.CompoundWMsCount * 2];
wmCycleEndState = new string[TBF.Data.CompoundWMsCount * 2];
currentOp = CurrentOp.None;
log.FatalFormat("{0} initialized: {1}", Name, this);
}
@ -123,7 +123,7 @@ namespace TBF.BenchControl.DataEntry.Combined
///
void OpenBeginningDlg(EntryForm myRef)
{
myRef.modelessDlg = new CycleBeginningForm(Config.Data.CompoundWMsCount, myRef.entryFormCfg.RemarkEnabled);
myRef.modelessDlg = new CycleBeginningForm(TBF.Data.CompoundWMsCount, myRef.entryFormCfg.RemarkEnabled);
modelessDlg.Show();
}
///
@ -136,20 +136,20 @@ namespace TBF.BenchControl.DataEntry.Combined
///
void OpenTestStartStatesDlg(EntryForm myRef)
{
myRef.modelessDlg = new TestStartEndForm(Config.Data.CompoundWMsCount, myRef.regReaders, myRef.disabled);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.CompoundWMsCount, myRef.regReaders, myRef.disabled);
modelessDlg.Show();
}
///
void OpenTestEndStatesDlg(EntryForm myRef)
{
string[] mainStartStateStr = new string[Config.Data.CompoundWMsCount];
string[] auxStartStateStr = new string[Config.Data.CompoundWMsCount];
for (int i = 0; i < Config.Data.CompoundWMsCount; i++)
string[] mainStartStateStr = new string[TBF.Data.CompoundWMsCount];
string[] auxStartStateStr = new string[TBF.Data.CompoundWMsCount];
for (int i = 0; i < TBF.Data.CompoundWMsCount; i++)
{
mainStartStateStr[i] = wmStartStateStr[2 * i];
auxStartStateStr[i] = wmStartStateStr[2 * i + 1];
}
myRef.modelessDlg = new TestStartEndForm(Config.Data.CompoundWMsCount, myRef.regReaders, mainStartStateStr, auxStartStateStr, disabled, refVolume, errLimLo, errLimHi);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.CompoundWMsCount, myRef.regReaders, mainStartStateStr, auxStartStateStr, disabled, refVolume, errLimLo, errLimHi);
modelessDlg.Show();
}

4
TBF/BenchControl/DataEntry/Combined/TestStartEndForm.cs
View File

@ -136,9 +136,9 @@ namespace TBF.BenchControl.DataEntry.Combined
/// </summary>
void ShuffleTextBoxes()
{
if (Config.Data.CompoundWMsCount < TextBoxesCount)
if (TBF.Data.CompoundWMsCount < TextBoxesCount)
{
TextBoxesCount = Config.Data.CompoundWMsCount;
TextBoxesCount = TBF.Data.CompoundWMsCount;
}
}

2
TBF/BenchControl/DataEntry/DataStream/CycleBeginningForm.cs
View File

@ -109,7 +109,7 @@ namespace TBF.BenchControl.DataEntry.DataStream
int wmsCount = Math.Min(mefImport.DataStreamIFace.GetMetersCount(), waterMeters.Count);
int right, bottom;
enabledSerialNrBoxes = ShuffleTextBoxes(wmsCount, Config.Data.LineSize, out right, out bottom);
enabledSerialNrBoxes = ShuffleTextBoxes(wmsCount, TBF.Data.LineSize, out right, out bottom);
Height = bottom + 60;
DataStreamsCount = enabledSerialNrBoxes.Count;

16
TBF/BenchControl/DataEntry/DataStream/EntryForm.cs
View File

@ -74,11 +74,11 @@ namespace TBF.BenchControl.DataEntry.DataStream
public override void Initialize()
{
disabled = new bool[Config.Data.WMsCount];
wmStartState = new double[Config.Data.WMsCount];
wmStartStateStr = new string[Config.Data.WMsCount];
wmEndState = new double[Config.Data.WMsCount];
wmCycleEndState = new string[Config.Data.WMsCount];
disabled = new bool[TBF.Data.WMsCount];
wmStartState = new double[TBF.Data.WMsCount];
wmStartStateStr = new string[TBF.Data.WMsCount];
wmEndState = new double[TBF.Data.WMsCount];
wmCycleEndState = new string[TBF.Data.WMsCount];
currentOp = CurrentOp.None;
log.FatalFormat("{0} initialized: {1}", Name, this);
}
@ -133,19 +133,19 @@ namespace TBF.BenchControl.DataEntry.DataStream
///
void OpenEndDlg(EntryForm myRef)
{
myRef.modelessDlg = new CycleEndForm(Config.Data.WMsCount, Config.Data.LineSize);
myRef.modelessDlg = new CycleEndForm(TBF.Data.WMsCount, TBF.Data.LineSize);
modelessDlg.Show();
}
///
void OpenTestStartStatesDlg(EntryForm myRef)
{
myRef.modelessDlg = new TestStartEndForm(Config.Data.WMsCount, myRef.regReaders, myRef.disabled);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.WMsCount, myRef.regReaders, myRef.disabled);
modelessDlg.Show();
}
///
void OpenTestEndStatesDlg(EntryForm myRef)
{
myRef.modelessDlg = new TestStartEndForm(Config.Data.WMsCount, myRef.regReaders, wmStartStateStr, disabled, refVolume, errLimLo, errLimHi);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.WMsCount, myRef.regReaders, wmStartStateStr, disabled, refVolume, errLimLo, errLimHi);
modelessDlg.Show();
}

12
TBF/BenchControl/DataEntry/DataStream/TestStartEndForm.cs
View File

@ -152,18 +152,18 @@ namespace TBF.BenchControl.DataEntry.DataStream
{
if (TextBoxesCount > WaterMetersCount)
{
int nrLines = WaterMetersCount / Config.Data.LineSize;
int nrLines = WaterMetersCount / TBF.Data.LineSize;
int gap = (TextBoxesCount - WaterMetersCount) / nrLines;
int dest = 0;
for (int l = 0; l < nrLines; l++)
{
for (int i = 0; i < Config.Data.LineSize; i++)
for (int i = 0; i < TBF.Data.LineSize; i++)
{
labels[dest] = labels[l * Config.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * Config.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * Config.Data.LineSize + l * gap + i];
exclamations[dest] = exclamations[l * Config.Data.LineSize + l * gap + i];
labels[dest] = labels[l * TBF.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * TBF.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * TBF.Data.LineSize + l * gap + i];
exclamations[dest] = exclamations[l * TBF.Data.LineSize + l * gap + i];
dest++;
}
}

2
TBF/BenchControl/DataEntry/Fewa/CycleBeginningForm.cs
View File

@ -89,7 +89,7 @@ namespace TBF.BenchControl.DataEntry.Fewa
suffixText = new string[WMsCount];
Disabled = new bool[WMsCount];
ShuffleTextBoxes(Config.Data.WMsCount, Config.Data.LineSize);
ShuffleTextBoxes(TBF.Data.WMsCount, TBF.Data.LineSize);
//Height = 147 + WaterMetersCount * 90;
}

18
TBF/BenchControl/DataEntry/Fewa/EntryFormNoStartEnd.cs
View File

@ -70,11 +70,11 @@ namespace TBF.BenchControl.DataEntry.Fewa
public override void Initialize()
{
disabled = new bool[Config.Data.WMsCount];
wmStartState = new double[Config.Data.WMsCount];
wmStartStateStr = new string[Config.Data.WMsCount];
wmEndState = new double[Config.Data.WMsCount];
wmCycleEndState = new string[Config.Data.WMsCount];
disabled = new bool[TBF.Data.WMsCount];
wmStartState = new double[TBF.Data.WMsCount];
wmStartStateStr = new string[TBF.Data.WMsCount];
wmEndState = new double[TBF.Data.WMsCount];
wmCycleEndState = new string[TBF.Data.WMsCount];
currentOp = CurrentOp.None;
log.FatalFormat("{0} initialized: {1}", Name, this);
}
@ -123,25 +123,25 @@ namespace TBF.BenchControl.DataEntry.Fewa
///
void OpenBeginningDlg(EntryFormNoStartEnd myRef)
{
myRef.modelessDlg = new CycleBeginningForm(Config.Data.WMsCount);
myRef.modelessDlg = new CycleBeginningForm(TBF.Data.WMsCount);
modelessDlg.Show();
}
///
void OpenEndDlg(EntryFormNoStartEnd myRef)
{
myRef.modelessDlg = new CycleEndForm(Config.Data.WMsCount, Config.Data.LineSize);
myRef.modelessDlg = new CycleEndForm(TBF.Data.WMsCount, TBF.Data.LineSize);
modelessDlg.Show();
}
///
void OpenTestStartStatesDlg(EntryFormNoStartEnd myRef)
{
myRef.modelessDlg = new TestStartEndForm(Config.Data.WMsCount, myRef.regReaders, myRef.disabled);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.WMsCount, myRef.regReaders, myRef.disabled);
modelessDlg.Show();
}
///
void OpenTestEndStatesDlg(EntryFormNoStartEnd myRef)
{
myRef.modelessDlg = new TestStartEndForm(Config.Data.WMsCount, myRef.regReaders, wmStartStateStr, disabled, refVolume, errLimLo, errLimHi);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.WMsCount, myRef.regReaders, wmStartStateStr, disabled, refVolume, errLimLo, errLimHi);
modelessDlg.Show();
}

12
TBF/BenchControl/DataEntry/Fewa/TestStartEndForm.cs
View File

@ -152,18 +152,18 @@ namespace TBF.BenchControl.DataEntry.Fewa
{
if (TextBoxesCount > WMsCount)
{
int nrLines = WMsCount / Config.Data.LineSize;
int nrLines = WMsCount / TBF.Data.LineSize;
int gap = (TextBoxesCount - WMsCount) / nrLines;
int dest = 0;
for (int l = 0; l < nrLines; l++)
{
for (int i = 0; i < Config.Data.LineSize; i++)
for (int i = 0; i < TBF.Data.LineSize; i++)
{
labels[dest] = labels[l * Config.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * Config.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * Config.Data.LineSize + l * gap + i];
exclamations[dest] = exclamations[l * Config.Data.LineSize + l * gap + i];
labels[dest] = labels[l * TBF.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * TBF.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * TBF.Data.LineSize + l * gap + i];
exclamations[dest] = exclamations[l * TBF.Data.LineSize + l * gap + i];
dest++;
}
}

2
TBF/BenchControl/DataEntry/HeatMeters12/CycleBeginningForm.cs
View File

@ -87,7 +87,7 @@ namespace TBF.BenchControl.DataEntry.HeatMeters12
SNText = new string[WaterMetersCount];
Disabled = new bool[WaterMetersCount];
ShuffleTextBoxes(Config.Data.WMsCount, Config.Data.LineSize);
ShuffleTextBoxes(TBF.Data.WMsCount, TBF.Data.LineSize);
foreach (var wm in waterMeters) if (wm != null) wm.Passed = wm.PassedFromTests();

22
TBF/BenchControl/DataEntry/HeatMeters12/EntryForm.cs
View File

@ -82,14 +82,14 @@ namespace TBF.BenchControl.DataEntry.HeatMeters12
public override void Initialize()
{
disabled = new bool[Config.Data.HeatMetersCount];
wmStartState = new double[Config.Data.HeatMetersCount];
wmStartStateStr = new string[Config.Data.HeatMetersCount];
wmEndState = new double[Config.Data.HeatMetersCount];
energyStartState = new double[Config.Data.HeatMetersCount];
energyStartStateStr = new string[Config.Data.HeatMetersCount];
energyEndState = new double[Config.Data.HeatMetersCount];
wmCycleEndState = new string[Config.Data.HeatMetersCount];
disabled = new bool[TBF.Data.HeatMetersCount];
wmStartState = new double[TBF.Data.HeatMetersCount];
wmStartStateStr = new string[TBF.Data.HeatMetersCount];
wmEndState = new double[TBF.Data.HeatMetersCount];
energyStartState = new double[TBF.Data.HeatMetersCount];
energyStartStateStr = new string[TBF.Data.HeatMetersCount];
energyEndState = new double[TBF.Data.HeatMetersCount];
wmCycleEndState = new string[TBF.Data.HeatMetersCount];
currentOp = CurrentOp.None;
log.FatalFormat("{0} initialized: {1}", Name, this);
}
@ -242,7 +242,7 @@ namespace TBF.BenchControl.DataEntry.HeatMeters12
else if (entryFormCfg.ShowCycleEndForm && currentOp == CurrentOp.ShowFormAtCycleEnd)
{
CycleEndForm dlg = (modelessDlg as CycleEndForm);
int count = Math.Min(waterMeters.Count, Config.Data.HeatMetersCount);
int count = Math.Min(waterMeters.Count, TBF.Data.HeatMetersCount);
if ((dlg != null) && (count > dlg.WaterMetersCount)) count = dlg.WaterMetersCount;
for (int i = 0; i < count; i++)
@ -260,7 +260,7 @@ namespace TBF.BenchControl.DataEntry.HeatMeters12
TestStartEndForm dlg = (modelessDlg as TestStartEndForm);
if (dlg != null)
{
for (int i = 0; i < Math.Min(waterMeters.Count, Config.Data.HeatMetersCount); i++)
for (int i = 0; i < Math.Min(waterMeters.Count, TBF.Data.HeatMetersCount); i++)
{
wmStartState[i] = dlg.WMStartState[i];
wmStartStateStr[i] = dlg.WMStartStateStr[i];
@ -275,7 +275,7 @@ namespace TBF.BenchControl.DataEntry.HeatMeters12
TestStartEndForm dlg = (modelessDlg as TestStartEndForm);
if (dlg != null)
{
for (int i = 0; i < Math.Min(waterMeters.Count, Config.Data.HeatMetersCount); i++)
for (int i = 0; i < Math.Min(waterMeters.Count, TBF.Data.HeatMetersCount); i++)
{
wmEndState[i] = dlg.WMEndState[i];
energyEndState[i] = dlg.EnergyEndState[i];

22
TBF/BenchControl/DataEntry/HeatMeters12/TestStartEndForm.cs
View File

@ -177,26 +177,26 @@ namespace TBF.BenchControl.DataEntry.HeatMeters12
/// </summary>
void ShuffleTextBoxes()
{
if (Config.Data.HeatMetersCount < TextBoxesCount)
if (TBF.Data.HeatMetersCount < TextBoxesCount)
{
int nrLines = Math.Max(1, Config.Data.HeatMetersCount / Config.Data.LineSize);
int gap = (TextBoxesCount - Config.Data.HeatMetersCount) / nrLines;
int nrLines = Math.Max(1, TBF.Data.HeatMetersCount / TBF.Data.LineSize);
int gap = (TextBoxesCount - TBF.Data.HeatMetersCount) / nrLines;
int dest = 0;
for (int l = 0; l < nrLines; l++)
{
for (int i = 0; i < Config.Data.LineSize; i++)
for (int i = 0; i < TBF.Data.LineSize; i++)
{
labels[dest] = labels[l * Config.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * Config.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * Config.Data.LineSize + l * gap + i];
energyLabels[dest] = energyLabels[l * Config.Data.LineSize + l * gap + i];
energyStartTextBoxes[dest] = energyStartTextBoxes[l * Config.Data.LineSize + l * gap + i];
energyEndTextBoxes[dest] = energyEndTextBoxes[l * Config.Data.LineSize + l * gap + i];
labels[dest] = labels[l * TBF.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * TBF.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * TBF.Data.LineSize + l * gap + i];
energyLabels[dest] = energyLabels[l * TBF.Data.LineSize + l * gap + i];
energyStartTextBoxes[dest] = energyStartTextBoxes[l * TBF.Data.LineSize + l * gap + i];
energyEndTextBoxes[dest] = energyEndTextBoxes[l * TBF.Data.LineSize + l * gap + i];
dest++;
}
}
TextBoxesCount = Config.Data.HeatMetersCount;
TextBoxesCount = TBF.Data.HeatMetersCount;
}
}

2
TBF/BenchControl/DataEntry/HeatMeters6/CycleBeginningForm.cs
View File

@ -80,7 +80,7 @@ namespace TBF.BenchControl.DataEntry.HeatMeters6
SNText = new string[WaterMetersCount];
Disabled = new bool[WaterMetersCount];
ShuffleTextBoxes(Config.Data.WMsCount, Config.Data.LineSize);
ShuffleTextBoxes(TBF.Data.WMsCount, TBF.Data.LineSize);
foreach (var wm in waterMeters) if (wm != null) wm.Passed = wm.PassedFromTests();

22
TBF/BenchControl/DataEntry/HeatMeters6/EntryForm.cs
View File

@ -82,14 +82,14 @@ namespace TBF.BenchControl.DataEntry.HeatMeters6
public override void Initialize()
{
disabled = new bool[Config.Data.HeatMetersCount];
wmStartState = new double[Config.Data.HeatMetersCount];
wmStartStateStr = new string[Config.Data.HeatMetersCount];
wmEndState = new double[Config.Data.HeatMetersCount];
energyStartState = new double[Config.Data.HeatMetersCount];
energyStartStateStr = new string[Config.Data.HeatMetersCount];
energyEndState = new double[Config.Data.HeatMetersCount];
wmCycleEndState = new string[Config.Data.HeatMetersCount];
disabled = new bool[TBF.Data.HeatMetersCount];
wmStartState = new double[TBF.Data.HeatMetersCount];
wmStartStateStr = new string[TBF.Data.HeatMetersCount];
wmEndState = new double[TBF.Data.HeatMetersCount];
energyStartState = new double[TBF.Data.HeatMetersCount];
energyStartStateStr = new string[TBF.Data.HeatMetersCount];
energyEndState = new double[TBF.Data.HeatMetersCount];
wmCycleEndState = new string[TBF.Data.HeatMetersCount];
currentOp = CurrentOp.None;
log.FatalFormat("{0} initialized: {1}", Name, this);
}
@ -241,7 +241,7 @@ namespace TBF.BenchControl.DataEntry.HeatMeters6
else if (entryFormCfg.ShowCycleEndForm && currentOp == CurrentOp.ShowFormAtCycleEnd)
{
CycleEndForm dlg = (modelessDlg as CycleEndForm);
int count = Math.Min(waterMeters.Count, Config.Data.HeatMetersCount);
int count = Math.Min(waterMeters.Count, TBF.Data.HeatMetersCount);
if ((dlg != null) && (count > dlg.WaterMetersCount)) count = dlg.WaterMetersCount;
for (int i = 0; i < count; i++)
@ -259,7 +259,7 @@ namespace TBF.BenchControl.DataEntry.HeatMeters6
TestStartEndForm dlg = (modelessDlg as TestStartEndForm);
if (dlg != null)
{
for (int i = 0; i < Math.Min(waterMeters.Count, Config.Data.HeatMetersCount); i++)
for (int i = 0; i < Math.Min(waterMeters.Count, TBF.Data.HeatMetersCount); i++)
{
wmStartState[i] = dlg.WMStartState[i];
wmStartStateStr[i] = dlg.WMStartStateStr[i];
@ -274,7 +274,7 @@ namespace TBF.BenchControl.DataEntry.HeatMeters6
TestStartEndForm dlg = (modelessDlg as TestStartEndForm);
if (dlg != null)
{
for (int i = 0; i < Math.Min(waterMeters.Count, Config.Data.HeatMetersCount); i++)
for (int i = 0; i < Math.Min(waterMeters.Count, TBF.Data.HeatMetersCount); i++)
{
wmEndState[i] = dlg.WMEndState[i];
energyEndState[i] = dlg.EnergyEndState[i];

22
TBF/BenchControl/DataEntry/HeatMeters6/TestStartEndForm.cs
View File

@ -169,26 +169,26 @@ namespace TBF.BenchControl.DataEntry.HeatMeters6
/// </summary>
void ShuffleTextBoxes()
{
if (Config.Data.HeatMetersCount < TextBoxesCount)
if (TBF.Data.HeatMetersCount < TextBoxesCount)
{
int nrLines = Math.Max(1, Config.Data.HeatMetersCount / Config.Data.LineSize);
int gap = (TextBoxesCount - Config.Data.HeatMetersCount) / nrLines;
int nrLines = Math.Max(1, TBF.Data.HeatMetersCount / TBF.Data.LineSize);
int gap = (TextBoxesCount - TBF.Data.HeatMetersCount) / nrLines;
int dest = 0;
for (int l = 0; l < nrLines; l++)
{
for (int i = 0; i < Config.Data.LineSize; i++)
for (int i = 0; i < TBF.Data.LineSize; i++)
{
labels[dest] = labels[l * Config.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * Config.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * Config.Data.LineSize + l * gap + i];
energyLabels[dest] = energyLabels[l * Config.Data.LineSize + l * gap + i];
energyStartTextBoxes[dest] = energyStartTextBoxes[l * Config.Data.LineSize + l * gap + i];
energyEndTextBoxes[dest] = energyEndTextBoxes[l * Config.Data.LineSize + l * gap + i];
labels[dest] = labels[l * TBF.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * TBF.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * TBF.Data.LineSize + l * gap + i];
energyLabels[dest] = energyLabels[l * TBF.Data.LineSize + l * gap + i];
energyStartTextBoxes[dest] = energyStartTextBoxes[l * TBF.Data.LineSize + l * gap + i];
energyEndTextBoxes[dest] = energyEndTextBoxes[l * TBF.Data.LineSize + l * gap + i];
dest++;
}
}
TextBoxesCount = Config.Data.HeatMetersCount;
TextBoxesCount = TBF.Data.HeatMetersCount;
}
}

12
TBF/BenchControl/DataEntry/Munich/CycleBeginningForm.cs
View File

@ -27,8 +27,8 @@ namespace TBF.BenchControl.DataEntry.Munich
InitializeComponent();
ControlBox = false;
MainSNText = new string[Config.Data.CompoundWMsCount];
AuxSNText = new string[Config.Data.CompoundWMsCount];
MainSNText = new string[TBF.Data.CompoundWMsCount];
AuxSNText = new string[TBF.Data.CompoundWMsCount];
completed = false;
StartForceCloseHandler();
@ -38,12 +38,12 @@ namespace TBF.BenchControl.DataEntry.Munich
{
Localize();
if (Config.Data.CompoundWMsCount < 2)
if (TBF.Data.CompoundWMsCount < 2)
{
groupBox2.Visible = groupBox3.Visible = false;
Height = 200;
}
else if (Config.Data.CompoundWMsCount < 3)
else if (TBF.Data.CompoundWMsCount < 3)
{
groupBox3.Visible = false;
Height = 355;
@ -73,13 +73,13 @@ namespace TBF.BenchControl.DataEntry.Munich
MainSNText[0] = mainSN1TextBox.Text;
AuxSNText[0] = auxSN1TextBox.Text;
if (Config.Data.CompoundWMsCount >= 2)
if (TBF.Data.CompoundWMsCount >= 2)
{
MainSNText[1] = mainSN2TextBox.Text;
AuxSNText[1] = auxSN2TextBox.Text;
}
if (Config.Data.CompoundWMsCount >= 3)
if (TBF.Data.CompoundWMsCount >= 3)
{
MainSNText[2] = mainSN3TextBox.Text;
AuxSNText[2] = auxSN3TextBox.Text;

14
TBF/BenchControl/DataEntry/Munich/CycleEndForm.cs
View File

@ -37,11 +37,11 @@ namespace TBF.BenchControl.DataEntry.Munich
InitializeComponent();
ControlBox = false;
MainStateText = new string[Config.Data.CompoundWMsCount];
AuxStateText = new string[Config.Data.CompoundWMsCount];
QRise = new float[Config.Data.CompoundWMsCount];
QFall = new float[Config.Data.CompoundWMsCount];
YearOfProduction = new int[Config.Data.CompoundWMsCount];
MainStateText = new string[TBF.Data.CompoundWMsCount];
AuxStateText = new string[TBF.Data.CompoundWMsCount];
QRise = new float[TBF.Data.CompoundWMsCount];
QFall = new float[TBF.Data.CompoundWMsCount];
YearOfProduction = new int[TBF.Data.CompoundWMsCount];
completed = false;
StartForceCloseHandler();
@ -132,7 +132,7 @@ namespace TBF.BenchControl.DataEntry.Munich
YearOfProduction[0] = year;
}
if (Config.Data.CompoundWMsCount >= 2)
if (TBF.Data.CompoundWMsCount >= 2)
{
MainStateText[1] = mainState2TextBox.Text;
AuxStateText[1] = auxState2TextBox.Text;
@ -144,7 +144,7 @@ namespace TBF.BenchControl.DataEntry.Munich
}
}
if (Config.Data.CompoundWMsCount >= 3)
if (TBF.Data.CompoundWMsCount >= 3)
{
MainStateText[2] = mainState3TextBox.Text;
AuxStateText[2] = auxState3TextBox.Text;

6
TBF/BenchControl/DataEntry/Munich/EntryForm.cs
View File

@ -65,8 +65,8 @@ namespace TBF.BenchControl.DataEntry.Munich
public override void Initialize()
{
serialNr = new string[Config.Data.CompoundWMsCount];
wmEndState = new string[Config.Data.CompoundWMsCount];
serialNr = new string[TBF.Data.CompoundWMsCount];
wmEndState = new string[TBF.Data.CompoundWMsCount];
currentOp = CurrentOp.None;
log.FatalFormat("{0} initialized: {1}", Name, this);
}
@ -141,7 +141,7 @@ namespace TBF.BenchControl.DataEntry.Munich
if (!resultSaved) /// This is to save the result only once
{
int count = Math.Min(3, Math.Min(wMeters.Count, Config.Data.CompoundWMsCount));
int count = Math.Min(3, Math.Min(wMeters.Count, TBF.Data.CompoundWMsCount));
if (modelessDlg is CycleBeginningForm)
{
if (count >= 1 && wMeters[0] != null) wMeters[0].SerialNr = (modelessDlg as CycleBeginningForm).MainSNText[0];

2
TBF/BenchControl/DataEntry/Munich3/CycleBeginningForm.cs
View File

@ -41,7 +41,7 @@ namespace TBF.BenchControl.DataEntry.Munich3
/// <summary> Parameterless constructor for all watermeters </summary>
public CycleBeginningForm()
: this(Config.Data.WMsCount)
: this(TBF.Data.WMsCount)
{
}

18
TBF/BenchControl/DataEntry/Munich3/EntryForm.cs
View File

@ -74,12 +74,12 @@ namespace TBF.BenchControl.DataEntry.Munich3
public override void Initialize()
{
serialNr = new string[Config.Data.WMsCount];
disabled = new bool[Config.Data.WMsCount];
wmStartState = new double[Config.Data.WMsCount];
wmStartStateStr = new string[Config.Data.WMsCount];
wmEndState = new double[Config.Data.WMsCount];
wmCycleEndState = new string[Config.Data.WMsCount];
serialNr = new string[TBF.Data.WMsCount];
disabled = new bool[TBF.Data.WMsCount];
wmStartState = new double[TBF.Data.WMsCount];
wmStartStateStr = new string[TBF.Data.WMsCount];
wmEndState = new double[TBF.Data.WMsCount];
wmCycleEndState = new string[TBF.Data.WMsCount];
currentOp = CurrentOp.None;
log.FatalFormat("{0} initialized: {1}", Name, this);
}
@ -128,13 +128,13 @@ namespace TBF.BenchControl.DataEntry.Munich3
///
void OpenBeginningDlg(EntryForm myRef)
{
myRef.modelessDlg = new CycleBeginningForm(Config.Data.WMsCount);
myRef.modelessDlg = new CycleBeginningForm(TBF.Data.WMsCount);
modelessDlg.Show();
}
///
void OpenEndDlg(EntryForm myRef)
{
CycleEndForm endForm = new CycleEndForm(Config.Data.WMsCount);
CycleEndForm endForm = new CycleEndForm(TBF.Data.WMsCount);
endForm.ProtocolName1 = entryFormCfg.ProtocolTitle1;
endForm.ProtocolName2 = entryFormCfg.ProtocolTitle2;
endForm.ProtocolName3 = entryFormCfg.ProtocolTitle3;
@ -151,7 +151,7 @@ namespace TBF.BenchControl.DataEntry.Munich3
///
void OpenTestEndStatesDlg(EntryForm myRef)
{
myRef.modelessDlg = new TestStartEndForm(Config.Data.WMsCount, myRef.regReaders, wmStartStateStr, disabled, refVolume, errLimLo, errLimHi);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.WMsCount, myRef.regReaders, wmStartStateStr, disabled, refVolume, errLimLo, errLimHi);
modelessDlg.Show();
}

14
TBF/BenchControl/DataEntry/S620/EntryForm.cs
View File

@ -75,11 +75,11 @@ namespace TBF.BenchControl.DataEntry.S620
public override void Initialize()
{
disabled = new bool[Config.Data.WMsCount];
wmStartState = new double[Config.Data.WMsCount];
wmStartStateStr = new string[Config.Data.WMsCount];
wmEndState = new double[Config.Data.WMsCount];
wmCycleEndState = new string[Config.Data.WMsCount];
disabled = new bool[TBF.Data.WMsCount];
wmStartState = new double[TBF.Data.WMsCount];
wmStartStateStr = new string[TBF.Data.WMsCount];
wmEndState = new double[TBF.Data.WMsCount];
wmCycleEndState = new string[TBF.Data.WMsCount];
currentOp = CurrentOp.None;
log.FatalFormat("{0} initialized: {1}", Name, this);
}
@ -154,13 +154,13 @@ namespace TBF.BenchControl.DataEntry.S620
///
void OpenTestStartStatesDlg(EntryForm myRef)
{
myRef.modelessDlg = new TestStartEndForm(Config.Data.WMsCount, myRef.regReaders, disabled);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.WMsCount, myRef.regReaders, disabled);
modelessDlg.Show();
}
///
void OpenTestEndStatesDlg(EntryForm myRef)
{
myRef.modelessDlg = new TestStartEndForm(Config.Data.WMsCount, myRef.regReaders, wmStartStateStr, disabled, refVolume, errLimLo, errLimHi);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.WMsCount, myRef.regReaders, wmStartStateStr, disabled, refVolume, errLimLo, errLimHi);
modelessDlg.Show();
}

2
TBF/BenchControl/DataEntry/S620/FormForMechanicalMeters.cs
View File

@ -180,7 +180,7 @@ namespace TBF.BenchControl.DataEntry.S620
completeSerialNr = new string[wmsCount];
disabled = new bool[wmsCount];
ShuffleTextBoxes(wmsCount, Config.Data.LineSize);
ShuffleTextBoxes(wmsCount, TBF.Data.LineSize);
}
/// <summary>

12
TBF/BenchControl/DataEntry/S620/FormForMechanicalMetersWithTracing.cs
View File

@ -3,15 +3,15 @@
///
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;
using log4net;
using NHibernate;
using Oracle.DataAccess.Client;
using TracingDB;
using TracingDB.Entities;
using TBF.BenchControl.Sequences;
using TBF.Resources;
using Oracle.DataAccess.Client;
using TracingDB.Entities;
using NHibernate;
using TracingDB;
using System.Drawing;
namespace TBF.BenchControl.DataEntry.S620
{
@ -743,7 +743,7 @@ namespace TBF.BenchControl.DataEntry.S620
refRecord.Records.Add(new Record(palety[i].Part, refRecord, palety[i].ScannedCode));
}
DB.SaveRecords(dbSession, refRecord);
TracingDB.DB.SaveRecords(dbSession, refRecord);
}
}

12
TBF/BenchControl/DataEntry/S620/TestStartEndForm.cs
View File

@ -160,18 +160,18 @@ namespace TBF.BenchControl.DataEntry.S620
{
if (TextBoxesCount > WaterMetersCount)
{
int nrLines = WaterMetersCount / Config.Data.LineSize;
int nrLines = WaterMetersCount / TBF.Data.LineSize;
int gap = (TextBoxesCount - WaterMetersCount) / nrLines;
int dest = 0;
for (int l = 0; l < nrLines; l++)
{
for (int i = 0; i < Config.Data.LineSize; i++)
for (int i = 0; i < TBF.Data.LineSize; i++)
{
labels[dest] = labels[l * Config.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * Config.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * Config.Data.LineSize + l * gap + i];
exclamations[dest] = exclamations[l * Config.Data.LineSize + l * gap + i];
labels[dest] = labels[l * TBF.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * TBF.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * TBF.Data.LineSize + l * gap + i];
exclamations[dest] = exclamations[l * TBF.Data.LineSize + l * gap + i];
dest++;
}
}

2
TBF/BenchControl/DataEntry/Single/CycleBeginningForm.cs
View File

@ -77,7 +77,7 @@ namespace TBF.BenchControl.DataEntry.Single
SNText = new string[WaterMetersCount];
Disabled = new bool[WaterMetersCount];
ShuffleTextBoxes(Config.Data.WMsCount, Config.Data.LineSize);
ShuffleTextBoxes(TBF.Data.WMsCount, TBF.Data.LineSize);
//Height = 147 + WaterMetersCount * 90;
}

18
TBF/BenchControl/DataEntry/Single/EntryFormNoStartEnd.cs
View File

@ -70,11 +70,11 @@ namespace TBF.BenchControl.DataEntry.Single
public override void Initialize()
{
disabled = new bool[Config.Data.WMsCount];
wmStartState = new double[Config.Data.WMsCount];
wmStartStateStr = new string[Config.Data.WMsCount];
wmEndState = new double[Config.Data.WMsCount];
wmCycleEndState = new string[Config.Data.WMsCount];
disabled = new bool[TBF.Data.WMsCount];
wmStartState = new double[TBF.Data.WMsCount];
wmStartStateStr = new string[TBF.Data.WMsCount];
wmEndState = new double[TBF.Data.WMsCount];
wmCycleEndState = new string[TBF.Data.WMsCount];
currentOp = CurrentOp.None;
log.FatalFormat("{0} initialized: {1}", Name, this);
}
@ -123,25 +123,25 @@ namespace TBF.BenchControl.DataEntry.Single
///
void OpenBeginningDlg(EntryFormNoStartEnd myRef)
{
myRef.modelessDlg = new CycleBeginningForm(Config.Data.WMsCount);
myRef.modelessDlg = new CycleBeginningForm(TBF.Data.WMsCount);
modelessDlg.Show();
}
///
void OpenEndDlg(EntryFormNoStartEnd myRef)
{
myRef.modelessDlg = new CycleEndForm(Config.Data.WMsCount, Config.Data.LineSize);
myRef.modelessDlg = new CycleEndForm(TBF.Data.WMsCount, TBF.Data.LineSize);
modelessDlg.Show();
}
///
void OpenTestStartStatesDlg(EntryFormNoStartEnd myRef)
{
myRef.modelessDlg = new TestStartEndForm(Config.Data.WMsCount, Config.Data.LineSize, myRef.regReaders, myRef.disabled);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.WMsCount, TBF.Data.LineSize, myRef.regReaders, myRef.disabled);
modelessDlg.Show();
}
///
void OpenTestEndStatesDlg(EntryFormNoStartEnd myRef)
{
myRef.modelessDlg = new TestStartEndForm(Config.Data.WMsCount, Config.Data.LineSize, myRef.regReaders, wmStartStateStr, disabled, refVolume, errLimLo, errLimHi);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.WMsCount, TBF.Data.LineSize, myRef.regReaders, wmStartStateStr, disabled, refVolume, errLimLo, errLimHi);
modelessDlg.Show();
}

2
TBF/BenchControl/DataEntry/Standard12/CycleBeginningForm.cs
View File

@ -89,7 +89,7 @@ namespace TBF.BenchControl.DataEntry.Standard12
SNText = new string[WaterMetersCount];
Disabled = new bool[WaterMetersCount];
ShuffleTextBoxes(Config.Data.WMsCount, Config.Data.LineSize);
ShuffleTextBoxes(TBF.Data.WMsCount, TBF.Data.LineSize);
foreach (var wm in waterMeters) if (wm != null) wm.Passed = wm.PassedFromTests();

16
TBF/BenchControl/DataEntry/Standard12/EntryFormNoStartEnd.cs
View File

@ -70,11 +70,11 @@ namespace TBF.BenchControl.DataEntry.Standard12
public override void Initialize()
{
disabled = new bool[Config.Data.WMsCount];
wmStartState = new double[Config.Data.WMsCount];
wmStartStateStr = new string[Config.Data.WMsCount];
wmEndState = new double[Config.Data.WMsCount];
wmCycleEndState = new string[Config.Data.WMsCount];
disabled = new bool[TBF.Data.WMsCount];
wmStartState = new double[TBF.Data.WMsCount];
wmStartStateStr = new string[TBF.Data.WMsCount];
wmEndState = new double[TBF.Data.WMsCount];
wmCycleEndState = new string[TBF.Data.WMsCount];
currentOp = CurrentOp.None;
log.FatalFormat("{0} initialized: {1}", Name, this);
}
@ -129,19 +129,19 @@ namespace TBF.BenchControl.DataEntry.Standard12
///
void OpenEndDlg(EntryFormNoStartEnd myRef)
{
myRef.modelessDlg = new CycleEndForm(Config.Data.WMsCount);
myRef.modelessDlg = new CycleEndForm(TBF.Data.WMsCount);
modelessDlg.Show();
}
///
void OpenTestStartStatesDlg(EntryFormNoStartEnd myRef)
{
myRef.modelessDlg = new TestStartEndForm(Config.Data.WMsCount, myRef.regReaders, disabled);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.WMsCount, myRef.regReaders, disabled);
modelessDlg.Show();
}
///
void OpenTestEndStatesDlg(EntryFormNoStartEnd myRef)
{
myRef.modelessDlg = new TestStartEndForm(Config.Data.WMsCount, myRef.regReaders, wmStartStateStr, disabled, refVolume, errLimLo, errLimHi);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.WMsCount, myRef.regReaders, wmStartStateStr, disabled, refVolume, errLimLo, errLimHi);
modelessDlg.Show();
}

10
TBF/BenchControl/DataEntry/Standard12/TestStartEndForm.cs
View File

@ -135,17 +135,17 @@ namespace TBF.BenchControl.DataEntry.Standard12
{
if (TextBoxesCount > WaterMetersCount)
{
int nrLines = WaterMetersCount / Config.Data.LineSize;
int nrLines = WaterMetersCount / TBF.Data.LineSize;
int gap = (TextBoxesCount - WaterMetersCount) / nrLines;
int dest = 0;
for (int l = 0; l < nrLines; l++)
{
for (int i = 0; i < Config.Data.LineSize; i++)
for (int i = 0; i < TBF.Data.LineSize; i++)
{
labels[dest] = labels[l * Config.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * Config.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * Config.Data.LineSize + l * gap + i];
labels[dest] = labels[l * TBF.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * TBF.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * TBF.Data.LineSize + l * gap + i];
dest++;
}
}

20
TBF/BenchControl/DataEntry/Standard24/AdvancedFixedStartTestForm.cs
View File

@ -149,25 +149,25 @@ namespace TBF.BenchControl.DataEntry.Standard24
/// </summary>
void ShuffleTextBoxes()
{
if (Config.Data.WMsCount < TextBoxesCount)
if (TBF.Data.WMsCount < TextBoxesCount)
{
int nrLines = Config.Data.WMsCount / Config.Data.LineSize;
int gap = (TextBoxesCount - Config.Data.WMsCount) / nrLines;
int nrLines = TBF.Data.WMsCount / TBF.Data.LineSize;
int gap = (TextBoxesCount - TBF.Data.WMsCount) / nrLines;
int dest = 0;
for (int l = 0; l < nrLines; l++)
{
for (int i = 0; i < Config.Data.LineSize; i++)
for (int i = 0; i < TBF.Data.LineSize; i++)
{
labels[dest] = labels[l * Config.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * Config.Data.LineSize + l * gap + i];
mid1TextBoxes[dest] = mid1TextBoxes[l * Config.Data.LineSize + l * gap + i];
mid2TextBoxes[dest] = mid2TextBoxes[l * Config.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * Config.Data.LineSize + l * gap + i];
labels[dest] = labels[l * TBF.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * TBF.Data.LineSize + l * gap + i];
mid1TextBoxes[dest] = mid1TextBoxes[l * TBF.Data.LineSize + l * gap + i];
mid2TextBoxes[dest] = mid2TextBoxes[l * TBF.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * TBF.Data.LineSize + l * gap + i];
dest++;
}
}
TextBoxesCount = Config.Data.WMsCount;
TextBoxesCount = TBF.Data.WMsCount;
}
}

2
TBF/BenchControl/DataEntry/Standard24/CycleBeginningForm.cs
View File

@ -77,7 +77,7 @@ namespace TBF.BenchControl.DataEntry.Standard24
SNText = new string[WaterMetersCount];
Disabled = new bool[WaterMetersCount];
ShuffleTextBoxes(Config.Data.WMsCount, Config.Data.LineSize);
ShuffleTextBoxes(TBF.Data.WMsCount, TBF.Data.LineSize);
//Height = 147 + WaterMetersCount * 90;
}

18
TBF/BenchControl/DataEntry/Standard24/EntryFormNoStartEnd.cs
View File

@ -70,11 +70,11 @@ namespace TBF.BenchControl.DataEntry.Standard24
public override void Initialize()
{
disabled = new bool[Config.Data.WMsCount];
wmStartState = new double[Config.Data.WMsCount];
wmStartStateStr = new string[Config.Data.WMsCount];
wmEndState = new double[Config.Data.WMsCount];
wmCycleEndState = new string[Config.Data.WMsCount];
disabled = new bool[TBF.Data.WMsCount];
wmStartState = new double[TBF.Data.WMsCount];
wmStartStateStr = new string[TBF.Data.WMsCount];
wmEndState = new double[TBF.Data.WMsCount];
wmCycleEndState = new string[TBF.Data.WMsCount];
currentOp = CurrentOp.None;
log.FatalFormat("{0} initialized: {1}", Name, this);
}
@ -123,25 +123,25 @@ namespace TBF.BenchControl.DataEntry.Standard24
///
void OpenBeginningDlg(EntryFormNoStartEnd myRef)
{
myRef.modelessDlg = new CycleBeginningForm(Config.Data.WMsCount);
myRef.modelessDlg = new CycleBeginningForm(TBF.Data.WMsCount);
modelessDlg.Show();
}
///
void OpenEndDlg(EntryFormNoStartEnd myRef)
{
myRef.modelessDlg = new CycleEndForm(Config.Data.WMsCount, Config.Data.LineSize);
myRef.modelessDlg = new CycleEndForm(TBF.Data.WMsCount, TBF.Data.LineSize);
modelessDlg.Show();
}
///
void OpenTestStartStatesDlg(EntryFormNoStartEnd myRef)
{
myRef.modelessDlg = new TestStartEndForm(Config.Data.WMsCount, myRef.regReaders, myRef.disabled);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.WMsCount, myRef.regReaders, myRef.disabled);
modelessDlg.Show();
}
///
void OpenTestEndStatesDlg(EntryFormNoStartEnd myRef)
{
myRef.modelessDlg = new TestStartEndForm(Config.Data.WMsCount, myRef.regReaders, wmStartStateStr, disabled, refVolume, errLimLo, errLimHi);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.WMsCount, myRef.regReaders, wmStartStateStr, disabled, refVolume, errLimLo, errLimHi);
modelessDlg.Show();
}

12
TBF/BenchControl/DataEntry/Standard24/TestStartEndForm.cs
View File

@ -152,18 +152,18 @@ namespace TBF.BenchControl.DataEntry.Standard24
{
if (TextBoxesCount > WaterMetersCount)
{
int nrLines = WaterMetersCount / Config.Data.LineSize;
int nrLines = WaterMetersCount / TBF.Data.LineSize;
int gap = (TextBoxesCount - WaterMetersCount) / nrLines;
int dest = 0;
for (int l = 0; l < nrLines; l++)
{
for (int i = 0; i < Config.Data.LineSize; i++)
for (int i = 0; i < TBF.Data.LineSize; i++)
{
labels[dest] = labels[l * Config.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * Config.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * Config.Data.LineSize + l * gap + i];
exclamations[dest] = exclamations[l * Config.Data.LineSize + l * gap + i];
labels[dest] = labels[l * TBF.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * TBF.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * TBF.Data.LineSize + l * gap + i];
exclamations[dest] = exclamations[l * TBF.Data.LineSize + l * gap + i];
dest++;
}
}

2
TBF/BenchControl/DataEntry/Standard48/CycleBeginningForm.cs
View File

@ -81,7 +81,7 @@ namespace TBF.BenchControl.DataEntry.Standard48
SNText = new string[WaterMetersCount];
Disabled = new bool[WaterMetersCount];
ShuffleTextBoxes(Config.Data.WMsCount, Config.Data.LineSize);
ShuffleTextBoxes(TBF.Data.WMsCount, TBF.Data.LineSize);
//Height = 147 + WaterMetersCount * 90;
}

18
TBF/BenchControl/DataEntry/Standard48/EntryFormNoStartEnd.cs
View File

@ -70,11 +70,11 @@ namespace TBF.BenchControl.DataEntry.Standard48
public override void Initialize()
{
disabled = new bool[Config.Data.WMsCount];
wmStartState = new double[Config.Data.WMsCount];
wmStartStateStr = new string[Config.Data.WMsCount];
wmEndState = new double[Config.Data.WMsCount];
wmCycleEndState = new string[Config.Data.WMsCount];
disabled = new bool[TBF.Data.WMsCount];
wmStartState = new double[TBF.Data.WMsCount];
wmStartStateStr = new string[TBF.Data.WMsCount];
wmEndState = new double[TBF.Data.WMsCount];
wmCycleEndState = new string[TBF.Data.WMsCount];
currentOp = CurrentOp.None;
log.FatalFormat("{0} initialized: {1}", Name, this);
}
@ -123,25 +123,25 @@ namespace TBF.BenchControl.DataEntry.Standard48
///
void OpenBeginningDlg(EntryFormNoStartEnd myRef)
{
myRef.modelessDlg = new CycleBeginningForm(Config.Data.WMsCount);
myRef.modelessDlg = new CycleBeginningForm(TBF.Data.WMsCount);
modelessDlg.Show();
}
///
void OpenEndDlg(EntryFormNoStartEnd myRef)
{
myRef.modelessDlg = new CycleEndForm(Config.Data.WMsCount);
myRef.modelessDlg = new CycleEndForm(TBF.Data.WMsCount);
modelessDlg.Show();
}
///
void OpenTestStartStatesDlg(EntryFormNoStartEnd myRef)
{
myRef.modelessDlg = new TestStartEndForm(Config.Data.WMsCount, myRef.regReaders, disabled);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.WMsCount, myRef.regReaders, disabled);
modelessDlg.Show();
}
///
void OpenTestEndStatesDlg(EntryFormNoStartEnd myRef)
{
myRef.modelessDlg = new TestStartEndForm(Config.Data.WMsCount, myRef.regReaders, wmStartStateStr, disabled, refVolume, errLimLo, errLimHi);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.WMsCount, myRef.regReaders, wmStartStateStr, disabled, refVolume, errLimLo, errLimHi);
modelessDlg.Show();
}

12
TBF/BenchControl/DataEntry/Standard48/TestStartEndForm.cs
View File

@ -160,18 +160,18 @@ namespace TBF.BenchControl.DataEntry.Standard48
{
if (TextBoxesCount > WaterMetersCount)
{
int nrLines = WaterMetersCount / Config.Data.LineSize;
int nrLines = WaterMetersCount / TBF.Data.LineSize;
int gap = (TextBoxesCount - WaterMetersCount) / nrLines;
int dest = 0;
for (int l = 0; l < nrLines; l++)
{
for (int i = 0; i < Config.Data.LineSize; i++)
for (int i = 0; i < TBF.Data.LineSize; i++)
{
labels[dest] = labels[l * Config.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * Config.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * Config.Data.LineSize + l * gap + i];
exclamations[dest] = exclamations[l * Config.Data.LineSize + l * gap + i];
labels[dest] = labels[l * TBF.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * TBF.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * TBF.Data.LineSize + l * gap + i];
exclamations[dest] = exclamations[l * TBF.Data.LineSize + l * gap + i];
dest++;
}
}

2
TBF/BenchControl/DataEntry/Standard6/CycleBeginningForm.cs
View File

@ -60,7 +60,7 @@ namespace TBF.BenchControl.DataEntry.Standard6
/// <summary> Parameterless constructor for all watermeters </summary>
public CycleBeginningForm()
: this(Config.Data.WMsCount, false)
: this(TBF.Data.WMsCount, false)
{
}

8
TBF/BenchControl/DataEntry/Standard6/EntryFormNoStartEnd.cs
View File

@ -67,10 +67,10 @@ namespace TBF.BenchControl.DataEntry.Standard6
public override void Initialize()
{
disabled = new bool[Config.Data.WMsCount];
wmStartState = new double[Config.Data.WMsCount];
wmStartStateStr = new string[Config.Data.WMsCount];
wmEndState = new double[Config.Data.WMsCount];
disabled = new bool[TBF.Data.WMsCount];
wmStartState = new double[TBF.Data.WMsCount];
wmStartStateStr = new string[TBF.Data.WMsCount];
wmEndState = new double[TBF.Data.WMsCount];
currentOp = CurrentOp.None;
log.FatalFormat("{0} initialized: {1}", Name, this);
}

2
TBF/BenchControl/DataEntry/Standard6/TestStartEndForm.cs
View File

@ -87,7 +87,7 @@ namespace TBF.BenchControl.DataEntry.Standard6
/// <summary> Parameterless constructor for all watermeters </summary>
public TestStartEndForm()
: this(Config.Data.WMsCount, null, null)
: this(TBF.Data.WMsCount, null, null)
{
}

4
TBF/BenchControl/DataEntry/StandardCamera/CycleBeginningForm.cs
View File

@ -77,8 +77,8 @@ namespace TBF.BenchControl.DataEntry.StandardCamera
SNText = new string[WaterMetersCount];
Disabled = new bool[WaterMetersCount];
int lineSize = (WaterMetersCount <= 6) ? WaterMetersCount : Config.Data.LineSize;
ShuffleTextBoxes(Config.Data.WMsCount, lineSize);
int lineSize = (WaterMetersCount <= 6) ? WaterMetersCount : TBF.Data.LineSize;
ShuffleTextBoxes(TBF.Data.WMsCount, lineSize);
if (hideOrder) orderGroupBox.Visible = false;

22
TBF/BenchControl/DataEntry/StandardCamera/EntryForm.cs
View File

@ -120,11 +120,11 @@ namespace TBF.BenchControl.DataEntry.StandardCamera
public override void Initialize()
{
disabled = new bool[Config.Data.WMsCount];
wmStartState = new double[Config.Data.WMsCount];
wmStartStateStr = new string[Config.Data.WMsCount];
wmEndState = new double[Config.Data.WMsCount];
wmCycleEndState = new string[Config.Data.WMsCount];
disabled = new bool[TBF.Data.WMsCount];
wmStartState = new double[TBF.Data.WMsCount];
wmStartStateStr = new string[TBF.Data.WMsCount];
wmEndState = new double[TBF.Data.WMsCount];
wmCycleEndState = new string[TBF.Data.WMsCount];
currentOp = CurrentOp.None;
log.FatalFormat("{0} initialized: {1}", Name, this);
}
@ -185,7 +185,7 @@ namespace TBF.BenchControl.DataEntry.StandardCamera
///
void OpenBeginningDlg(EntryForm myRef)
{
myRef.modelessDlg = new CycleBeginningForm(Config.Data.WMsCount, entryFormCfg.HideOrder);
myRef.modelessDlg = new CycleBeginningForm(TBF.Data.WMsCount, entryFormCfg.HideOrder);
modelessDlg.Show();
}
///
@ -196,7 +196,7 @@ namespace TBF.BenchControl.DataEntry.StandardCamera
!string.IsNullOrEmpty(entryFormCfg.ProtocolTitle3) ||
!string.IsNullOrEmpty(entryFormCfg.ProtocolTitle4))
{
myRef.modelessDlg = new CycleEndFormMunich(Config.Data.WMsCount);
myRef.modelessDlg = new CycleEndFormMunich(TBF.Data.WMsCount);
(myRef.modelessDlg as CycleEndFormMunich).ProtocolName1 = entryFormCfg.ProtocolTitle1;
(myRef.modelessDlg as CycleEndFormMunich).ProtocolName2 = entryFormCfg.ProtocolTitle2;
(myRef.modelessDlg as CycleEndFormMunich).ProtocolName3 = entryFormCfg.ProtocolTitle3;
@ -204,7 +204,7 @@ namespace TBF.BenchControl.DataEntry.StandardCamera
}
else
{
myRef.modelessDlg = new CycleEndForm(Config.Data.WMsCount, Config.Data.LineSize);
myRef.modelessDlg = new CycleEndForm(TBF.Data.WMsCount, TBF.Data.LineSize);
}
myRef.modelessDlg.Show();
@ -212,19 +212,19 @@ namespace TBF.BenchControl.DataEntry.StandardCamera
///
void OpenTestStartStatesDlg(EntryForm myRef)
{
myRef.modelessDlg = new TestStartEndForm(Config.Data.WMsCount, myRef.regReaders, startImages, disabled);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.WMsCount, myRef.regReaders, startImages, disabled);
modelessDlg.Show();
}
///
void OpenTestEndStatesDlg(EntryForm myRef)
{
myRef.modelessDlg = new TestStartEndForm(Config.Data.WMsCount, myRef.regReaders, endImages, wmStartState, wmStartStateStr, disabled, refVolume, errLimLo, errLimHi);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.WMsCount, myRef.regReaders, endImages, wmStartState, wmStartStateStr, disabled, refVolume, errLimLo, errLimHi);
modelessDlg.Show();
}
///
void OpenDeferredTestEvalDlg(EntryForm myRef)
{
myRef.modelessDlg = new TestStartEndForm(Config.Data.WMsCount, myRef.regReaders, startImages, endImages, disabled, refVolume, errLimLo, errLimHi);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.WMsCount, myRef.regReaders, startImages, endImages, disabled, refVolume, errLimLo, errLimHi);
modelessDlg.Show();
}

12
TBF/BenchControl/DataEntry/StandardCamera/TestStartEndForm.cs
View File

@ -154,8 +154,8 @@ namespace TBF.BenchControl.DataEntry.StandardCamera
this.endImages = new string[waterMetersCount];
/// For large benches with WaterMetersCount LE 6 is Config.Data.LineSize==1 (compound meters)
int lineSize = (WaterMetersCount <= 6) ? WaterMetersCount : Config.Data.LineSize;
/// For large benches with WaterMetersCount LE 6 is TBF.Data.LineSize==1 (compound meters)
int lineSize = (WaterMetersCount <= 6) ? WaterMetersCount : TBF.Data.LineSize;
DeterminePhysPosWMPos(TextBoxesCount, WaterMetersCount, lineSize, out phys2wm, out wm2phys);
@ -200,8 +200,8 @@ namespace TBF.BenchControl.DataEntry.StandardCamera
this.startImages = new string[waterMetersCount];
/// For large benches with WaterMetersCount LE 6 is Config.Data.LineSize==1 (compound meters)
int lineSize = (WaterMetersCount <= 6) ? WaterMetersCount : Config.Data.LineSize;
/// For large benches with WaterMetersCount LE 6 is TBF.Data.LineSize==1 (compound meters)
int lineSize = (WaterMetersCount <= 6) ? WaterMetersCount : TBF.Data.LineSize;
DeterminePhysPosWMPos(TextBoxesCount, WaterMetersCount, lineSize, out phys2wm, out wm2phys);
@ -232,8 +232,8 @@ namespace TBF.BenchControl.DataEntry.StandardCamera
this.warningLimLo = 2 * errLimLo;
this.warningLimHi = 2 * errLimHi;
/// For large benches with WaterMetersCount LE 6 is Config.Data.LineSize==1 (compound meters)
int lineSize = (WaterMetersCount <= 6) ? WaterMetersCount : Config.Data.LineSize;
/// For large benches with WaterMetersCount LE 6 is TBF.Data.LineSize==1 (compound meters)
int lineSize = (WaterMetersCount <= 6) ? WaterMetersCount : TBF.Data.LineSize;
DeterminePhysPosWMPos(TextBoxesCount, WaterMetersCount, lineSize, out phys2wm, out wm2phys);

6
TBF/BenchControl/DataEntry/WMStates/EntryForm.cs
View File

@ -72,7 +72,7 @@ namespace TBF.BenchControl.DataEntry.WMStates
public override void Initialize()
{
wmStartState = new double[Config.Data.WMsCount];
wmStartState = new double[TBF.Data.WMsCount];
currentOp = CurrentOp.None;
log.FatalFormat("{0} initialized: {1}", Name, this);
}
@ -119,13 +119,13 @@ namespace TBF.BenchControl.DataEntry.WMStates
///
void OpenWMSNsAndStatesDlg(EntryForm myRef)
{
myRef.modelessDlg = new WMSNsAndStatesForm(Config.Data.WMsCount);
myRef.modelessDlg = new WMSNsAndStatesForm(TBF.Data.WMsCount);
modelessDlg.Show();
}
///
void OpenWMStatesDlg(EntryForm myRef)
{
myRef.modelessDlg = new WMStatesForm(Config.Data.WMsCount);
myRef.modelessDlg = new WMStatesForm(TBF.Data.WMsCount);
modelessDlg.Show();
}

2
TBF/BenchControl/DataEntry/WMStates/WMSNsAndStatesForm.cs
View File

@ -46,7 +46,7 @@ namespace TBF.BenchControl.DataEntry.WMStates
/// <summary> Parameterless constructor for 3 watermeters </summary>
public WMSNsAndStatesForm()
: this(Config.Data.WMsCount)
: this(TBF.Data.WMsCount)
{
}

2
TBF/BenchControl/DataEntry/WMStates/WMStatesForm.cs
View File

@ -40,7 +40,7 @@ namespace TBF.BenchControl.DataEntry.WMStates
/// <summary> Parameterless constructor for 3 watermeters </summary>
public WMStatesForm()
: this(Config.Data.WMsCount)
: this(TBF.Data.WMsCount)
{
}

14
TBF/BenchControl/DataEntry/iPerl/EntryForm.cs
View File

@ -69,11 +69,11 @@ namespace TBF.BenchControl.DataEntry.iPerl
public override void Initialize()
{
disabled = new bool[Config.Data.WMsCount];
wmStartState = new double[Config.Data.WMsCount];
wmStartStateStr = new string[Config.Data.WMsCount];
wmEndState = new double[Config.Data.WMsCount];
wmCycleEndState = new string[Config.Data.WMsCount];
disabled = new bool[TBF.Data.WMsCount];
wmStartState = new double[TBF.Data.WMsCount];
wmStartStateStr = new string[TBF.Data.WMsCount];
wmEndState = new double[TBF.Data.WMsCount];
wmCycleEndState = new string[TBF.Data.WMsCount];
currentOp = CurrentOp.None;
log.FatalFormat("{0} initialized: {1}", Name, this);
}
@ -113,7 +113,7 @@ namespace TBF.BenchControl.DataEntry.iPerl
///
void OpenBeginningDlg(EntryForm myRef)
{
myRef.modelessDlg = new CycleBeginningForm(Config.Data.WMsCount, myRef.entryFormCfg.ReversedDirection);
myRef.modelessDlg = new CycleBeginningForm(TBF.Data.WMsCount, myRef.entryFormCfg.ReversedDirection);
modelessDlg.Show();
}
///
@ -125,7 +125,7 @@ namespace TBF.BenchControl.DataEntry.iPerl
///
void OpenTestEndStatesDlg(EntryForm myRef)
{
myRef.modelessDlg = new TestStartEndForm(Config.Data.WMsCount, myRef.regReaders, wmStartStateStr, disabled, refVolume, errLimLo, errLimHi);
myRef.modelessDlg = new TestStartEndForm(TBF.Data.WMsCount, myRef.regReaders, wmStartStateStr, disabled, refVolume, errLimLo, errLimHi);
modelessDlg.Show();
}

16
TBF/BenchControl/DataEntry/iPerl/TestStartEndForm.cs
View File

@ -140,23 +140,23 @@ namespace TBF.BenchControl.DataEntry.iPerl
/// </summary>
void ShuffleTextBoxes()
{
if (Config.Data.WMsCount < TextBoxesCount)
if (TBF.Data.WMsCount < TextBoxesCount)
{
int nrLines = Config.Data.WMsCount / Config.Data.LineSize;
int gap = (TextBoxesCount - Config.Data.WMsCount) / nrLines;
int nrLines = TBF.Data.WMsCount / TBF.Data.LineSize;
int gap = (TextBoxesCount - TBF.Data.WMsCount) / nrLines;
int dest = 0;
for (int l = 0; l < nrLines; l++)
{
for (int i = 0; i < Config.Data.LineSize; i++)
for (int i = 0; i < TBF.Data.LineSize; i++)
{
labels[dest] = labels[l * Config.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * Config.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * Config.Data.LineSize + l * gap + i];
labels[dest] = labels[l * TBF.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * TBF.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * TBF.Data.LineSize + l * gap + i];
dest++;
}
}
TextBoxesCount = Config.Data.WMsCount;
TextBoxesCount = TBF.Data.WMsCount;
}
}

14
TBF/BenchControl/Elde/ControlComSim.cs
View File

@ -21,7 +21,7 @@ namespace TBF.BenchControl.Elde
public double ReferenceFreq { get { return referenceFreq; } }
public double ReferenceFreqs(int i) { return 0; }
int[] etPulses = new int[Config.Data.WMsCount + 1];
int[] etPulses = new int[TBF.Data.WMsCount + 1];
public int EtPulses(int wmNr1)
{
return etPulses[wmNr1];
@ -31,16 +31,16 @@ namespace TBF.BenchControl.Elde
public int EtPulses2 { get { return 0; } }
public int EtPulses3 { get { return 0; } }
double[] errFactor = new double[Config.Data.WMsCount + 1]; /// Internal
double[] wMeterPulsesF = new double[Config.Data.WMsCount + 1]; /// Internal
double[] errFactor = new double[TBF.Data.WMsCount + 1]; /// Internal
double[] wMeterPulsesF = new double[TBF.Data.WMsCount + 1]; /// Internal
UInt16[] wMeterPulses = new UInt16[Config.Data.WMsCount + 1]; /// Rounded from wMeterPulsesF
UInt16[] wMeterPulses = new UInt16[TBF.Data.WMsCount + 1]; /// Rounded from wMeterPulsesF
public UInt16 WMeterPulses(int wmNr1)
{
return wMeterPulses[wmNr1];
}
int[] wMeterReference = new int[Config.Data.WMsCount + 1];
int[] wMeterReference = new int[TBF.Data.WMsCount + 1];
public int WMeterReference(int wmNr1)
{
return wMeterReference[wmNr1];
@ -321,7 +321,7 @@ namespace TBF.BenchControl.Elde
double pwFactor = 1.0;
/// Increment reference flow meters
for (int i = 0; i <= Config.Data.WMsCount; i++)
for (int i = 0; i <= TBF.Data.WMsCount; i++)
{
etPulses[i] += (int)referenceFreq;
if (etPulses[i] > totalRefPulses)
@ -334,7 +334,7 @@ namespace TBF.BenchControl.Elde
/// Increment water meters
double flowLtrPerSec = TestBenchSim.GetSimFlow() / 1800.0;
for (int i = 1; i <= Config.Data.WMsCount; i++)
for (int i = 1; i <= TBF.Data.WMsCount; i++)
{
float wmPulsesPerLiter = 0;
if ((BenchControl.Sequences.ProcessData.RegisterReaders[i - 1] != null) &&

4
TBF/BenchControl/MetersPath.cs
View File

@ -17,13 +17,13 @@ namespace TBF.BenchControl
{
ItemNr = itemNr;
Name = name;
RegisterReaders = new IRegReader[Config.Data.WMsCount];
RegisterReaders = new IRegReader[TBF.Data.WMsCount];
}
public MetersPath(Config.Entities.MetersPath entity, IList<BenchControl.Generic.IComponent> components)
: this(entity.Name, entity.ItemNr)
{
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
RegisterReaders[i] = (IRegReader)TbfComponents.FindComponent(entity.GetSensor(i), components);
}

2
TBF/BenchControl/Output/DB/SaveDiverterCorrections/SaveDiverterCorr.cs
View File

@ -199,7 +199,7 @@ namespace TBF.BenchControl.Output.DB.SaveDiverterCorrections
ITransaction transaction = null;
try
{
ISession session = Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config);
ISession session = TBF.DB.CreateSession(Users.Entities.DBKind.Config);
transaction = session.BeginTransaction();
for (int div = 1; div <= myCfg.DivertersCount(); div++)

2
TBF/BenchControl/Output/DB/SaveFlowmeterCorrections/SaveFlowmeterCorr.cs
View File

@ -206,7 +206,7 @@ namespace TBF.BenchControl.Output.DB.SaveFlowmeterCorrections
ITransaction transaction = null;
try
{
ISession session = Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config);
ISession session = TBF.DB.CreateSession(Users.Entities.DBKind.Config);
transaction = session.BeginTransaction();
for (int fmtr = 1; fmtr <= myCfg.FlowmetersCount(); fmtr++)

2
TBF/BenchControl/RegisterReaders/DataStream/Reader/Reader.cs
View File

@ -61,7 +61,7 @@ namespace TBF.BenchControl.RegisterReaders.DataStream.Reader
if (DebugLevel == DebugMode.Normal)
{
if (Position < 1 || Position > Math.Min(Config.Data.WMsCount, mefImport.DataStreamIFace.GetMetersCount()))
if (Position < 1 || Position > Math.Min(TBF.Data.WMsCount, mefImport.DataStreamIFace.GetMetersCount()))
{
throw new ArgumentException("Position is out of range");
}

4
TBF/BenchControl/RegisterReaders/DataStream/Reader/ReaderCfg.cs
View File

@ -63,7 +63,7 @@ namespace TBF.BenchControl.RegisterReaders.DataStream.Reader
{
case 0:
IList<string> retv = new List<string>();
for (int j = 1; j <= Config.Data.WMsCount; j++) retv.Add(j.ToString());
for (int j = 1; j <= TBF.Data.WMsCount; j++) retv.Add(j.ToString());
return retv;
default:
return null;
@ -101,7 +101,7 @@ namespace TBF.BenchControl.RegisterReaders.DataStream.Reader
switch (i)
{
case 0:
if (int.TryParse(strValue, out idummy) && idummy > 0 && idummy <= Config.Data.WMsCount) return true;
if (int.TryParse(strValue, out idummy) && idummy > 0 && idummy <= TBF.Data.WMsCount) return true;
break;
default:
message = "Invalid index";

2
TBF/BenchControl/RegisterReaders/KPackE/DataEntryForRadio/CycleBeginningForm.cs
View File

@ -81,7 +81,7 @@ namespace TBF.BenchControl.RegisterReaders.KPackE.DataEntryForRadio
SNText = new string[WaterMetersCount];
Disabled = new bool[WaterMetersCount];
ShuffleTextBoxes(Config.Data.WMsCount, Config.Data.LineSize);
ShuffleTextBoxes(TBF.Data.WMsCount, TBF.Data.LineSize);
//Height = 147 + WaterMetersCount * 90;
}

12
TBF/BenchControl/RegisterReaders/KPackE/DataEntryForRadio/EntryForm.cs
View File

@ -76,11 +76,11 @@ namespace TBF.BenchControl.RegisterReaders.KPackE.DataEntryForRadio
if (radio == null) throw new Exception("Cannot find Radio");
radio.EntryForm = this;
disabled = new bool[Config.Data.WMsCount];
wmStartState = new double[Config.Data.WMsCount];
wmStartStateStr = new string[Config.Data.WMsCount];
wmEndState = new double[Config.Data.WMsCount];
wmCycleEndState = new string[Config.Data.WMsCount];
disabled = new bool[TBF.Data.WMsCount];
wmStartState = new double[TBF.Data.WMsCount];
wmStartStateStr = new string[TBF.Data.WMsCount];
wmEndState = new double[TBF.Data.WMsCount];
wmCycleEndState = new string[TBF.Data.WMsCount];
currentOp = CurrentOp.None;
log.FatalFormat("{0} initialized: {1}", Name, this);
@ -121,7 +121,7 @@ namespace TBF.BenchControl.RegisterReaders.KPackE.DataEntryForRadio
///
void OpenBeginningDlg(EntryForm myRef)
{
myRef.modelessDlg = new CycleBeginningForm(Config.Data.WMsCount);
myRef.modelessDlg = new CycleBeginningForm(TBF.Data.WMsCount);
modelessDlg.Show();
}
///

12
TBF/BenchControl/RegisterReaders/KPackE/DataEntryForRadio/TestStartEndForm.cs
View File

@ -163,18 +163,18 @@ namespace TBF.BenchControl.RegisterReaders.KPackE.DataEntryForRadio
{
if (TextBoxesCount > WaterMetersCount)
{
int nrLines = WaterMetersCount / Config.Data.LineSize;
int nrLines = WaterMetersCount / TBF.Data.LineSize;
int gap = (TextBoxesCount - WaterMetersCount) / nrLines;
int dest = 0;
for (int l = 0; l < nrLines; l++)
{
for (int i = 0; i < Config.Data.LineSize; i++)
for (int i = 0; i < TBF.Data.LineSize; i++)
{
labels[dest] = labels[l * Config.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * Config.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * Config.Data.LineSize + l * gap + i];
exclamations[dest] = exclamations[l * Config.Data.LineSize + l * gap + i];
labels[dest] = labels[l * TBF.Data.LineSize + l * gap + i];
startTextBoxes[dest] = startTextBoxes[l * TBF.Data.LineSize + l * gap + i];
endTextBoxes[dest] = endTextBoxes[l * TBF.Data.LineSize + l * gap + i];
exclamations[dest] = exclamations[l * TBF.Data.LineSize + l * gap + i];
dest++;
}
}

6
TBF/BenchControl/Sequences/MainSeq.cs
View File

@ -225,7 +225,7 @@ namespace TBF.BenchControl.Sequences
try
{
using (ISession localSession = Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config))
using (ISession localSession = TBF.DB.CreateSession(Users.Entities.DBKind.Config))
{
StateMachine.LoadPathsAndTransitions(localSession);
}
@ -238,7 +238,7 @@ namespace TBF.BenchControl.Sequences
/// User has chosen to restore an interrupted session and necessary conditions are met
/// TODO: Repeate twice for Users.Entities.DBKind.Config and Users.Entities.DBKind.RemoteConfig
using (ISession remoteOrLocalSession = Config.FluentCommon.CreateSession(isRemoteIntProc ?
using (ISession remoteOrLocalSession = TBF.DB.CreateSession(isRemoteIntProc ?
Users.Entities.DBKind.RemoteConfig :
Users.Entities.DBKind.Config))
{
@ -268,7 +268,7 @@ namespace TBF.BenchControl.Sequences
}
/// TODO: Repeate twice for Users.Entities.DBKind.Config and Users.Entities.DBKind.RemoteConfig
using (ISession remoteOrLocalSession = Config.FluentCommon.CreateSession(Bridge.SelectedProcedure.IsRemote ?
using (ISession remoteOrLocalSession = TBF.DB.CreateSession(Bridge.SelectedProcedure.IsRemote ?
Users.Entities.DBKind.RemoteConfig :
Users.Entities.DBKind.Config))
{

2
TBF/BenchControl/Sequences/MainSeqUtils.cs
View File

@ -560,7 +560,7 @@ namespace TBF.BenchControl.Sequences
bool compound = (StateMachine.Procedure.MetersKind == MetersKind.Combined);
bool heatMeters = (StateMachine.Procedure.MetersKind == MetersKind.HeatMeter);
int waterMetersCount = Math.Min(WaterMeters.Count, heatMeters ? Config.Data.HeatMetersCount : (compound ? Config.Data.CompoundWMsCount : Config.Data.WMsCount));
int waterMetersCount = Math.Min(WaterMeters.Count, heatMeters ? TBF.Data.HeatMetersCount : (compound ? TBF.Data.CompoundWMsCount : TBF.Data.WMsCount));
///
Results.Entities.WaterMeterData[] waterMeterData = new Results.Entities.WaterMeterData[waterMetersCount];
///

16
TBF/BenchControl/Sequences/ProcessData.cs
View File

@ -24,10 +24,10 @@ namespace TBF.BenchControl.Sequences
///
/// Safe wrappers
///
public static int WMsCount { get { return Config.Data.WMsCount; } }
public static int LinesCount { get { return Config.Data.WMsCount / Config.Data.LineSize; } }
public static int LineSize { get { return Config.Data.LineSize; } }
public static int CompoundWMsCount { get { return Config.Data.CompoundWMsCount; } }
public static int WMsCount { get { return TBF.Data.WMsCount; } }
public static int LinesCount { get { return TBF.Data.WMsCount / TBF.Data.LineSize; } }
public static int LineSize { get { return TBF.Data.LineSize; } }
public static int CompoundWMsCount { get { return TBF.Data.CompoundWMsCount; } }
///
/// State variables to be saved after each completed test
@ -46,10 +46,10 @@ namespace TBF.BenchControl.Sequences
static ProcessData()
{
///
/// RegisterReaders should never be null, RegisterReader.Length should be Config.Data.WMsCount
/// RegisterReader[i] where i = 0..Config.Data.WMsCount-1 may be null and should always be tested
/// RegisterReaders should never be null, RegisterReader.Length should be TBF.Data.WMsCount
/// RegisterReader[i] where i = 0..TBF.Data.WMsCount-1 may be null and should always be tested
///
RegisterReaders = new IRegReader[Config.Data.WMsCount];
RegisterReaders = new IRegReader[TBF.Data.WMsCount];
IsQ2PreCorrectionCalculated = false;
CalculatedQ2PreCorrectionLR = 0;
CalculatedQ2PreCorrectionRL = 0;
@ -220,7 +220,7 @@ namespace TBF.BenchControl.Sequences
/// </summary>
protected void ClearProcessValues()
{
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
if (RegisterReaders[i] != null) RegisterReaders[i].Clear();
}

8
TBF/BenchControl/StateMachine.cs
View File

@ -214,7 +214,7 @@ namespace TBF.BenchControl
{
/// Load the list of components (entities) from the database.
/// Then create the components (derived from IComponent).
components = BenchControl.TbfComponents.LoadComponentsFromDB(Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config));
components = BenchControl.TbfComponents.LoadComponentsFromDB(TBF.DB.CreateSession(Users.Entities.DBKind.Config));
MasterValves = GenericDevices.ValveBase.MasterValves(components);
CoupledValves = GenericDevices.ValveBase.CoupledValves(components);
ExtendedValves = GenericDevices.ValveBase.ExtendedValves(components);
@ -430,7 +430,7 @@ namespace TBF.BenchControl
try
{
ISession remoteSession = Config.FluentCommon.CreateSession(Users.Entities.DBKind.RemoteConfig);
ISession remoteSession = TBF.DB.CreateSession(Users.Entities.DBKind.RemoteConfig);
remoteFeedingPaths = remoteSession.QueryOver<Config.Entities.FeedingPath>().List();
remoteBenchPaths = remoteSession.QueryOver<Config.Entities.BenchPath>().List();
remoteOutputPaths = remoteSession.QueryOver<Config.Entities.OutputPath>().List();
@ -443,7 +443,7 @@ namespace TBF.BenchControl
return false;
}
ISession localSession = Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config);
ISession localSession = TBF.DB.CreateSession(Users.Entities.DBKind.Config);
var localFeedingPaths = localSession.QueryOver<Config.Entities.FeedingPath>().List();
var localBenchPaths = localSession.QueryOver<Config.Entities.BenchPath>().List();
var localOutputPaths = localSession.QueryOver<Config.Entities.OutputPath>().List();
@ -720,7 +720,7 @@ namespace TBF.BenchControl
}
if (pmtrs != null)
{
int count = Math.Min(Config.Data.WMsCount, pmtrs.RegisterReaders.Length);
int count = Math.Min(TBF.Data.WMsCount, pmtrs.RegisterReaders.Length);
for (int i = 0; i < count; i++)
{
if ((pmtrs.RegisterReaders[i] != null) &&

6
TBF/BenchControl/TestMethods/Adjustment/AdjustmentSeq.cs
View File

@ -26,15 +26,15 @@ namespace TBF.BenchControl.TestMethods.Adjustment
{
#pragma warning disable 162 /// Disables 'Unreachable code detected' warning
if (Config.Data.WMsCount > 24)
if (TBF.Data.WMsCount > 24)
{
myRef.modelessDlg = new WMErrorsForm48(waterMeters);
}
else if (Config.Data.WMsCount > 12)
else if (TBF.Data.WMsCount > 12)
{
myRef.modelessDlg = new WMErrorsForm24(waterMeters);
}
else if (Config.Data.WMsCount > 6)
else if (TBF.Data.WMsCount > 6)
{
myRef.modelessDlg = new WMErrorsForm12(waterMeters);
}

2
TBF/BenchControl/TestMethods/Adjustment/WMErrorsForm.cs
View File

@ -45,7 +45,7 @@ namespace TBF.BenchControl.TestMethods.Adjustment
public WMErrorsForm(IList<GenericDevices.IWaterMeter> waterMeters)
: this()
{
waterMetersCount = Math.Min(Config.Data.WMsCount, waterMeters.Count);
waterMetersCount = Math.Min(TBF.Data.WMsCount, waterMeters.Count);
rects = new Rectangle[waterMetersCount];
for (int i = 0; i < waterMetersCount; i++) rects[i] = new Rectangle(385, 30 + 90 * i, 324, 57);

4
TBF/BenchControl/TestMethods/Adjustment/WMErrorsForm12.cs
View File

@ -92,9 +92,9 @@ namespace TBF.BenchControl.TestMethods.Adjustment
public WMErrorsForm12(IList<GenericDevices.IWaterMeter> waterMeters)
: this()
{
waterMetersCount = Math.Min(Config.Data.WMsCount, waterMeters.Count);
waterMetersCount = Math.Min(TBF.Data.WMsCount, waterMeters.Count);
ShuffleTextBoxes(waterMetersCount, Config.Data.LineSize);
ShuffleTextBoxes(waterMetersCount, TBF.Data.LineSize);
disabled = new bool[waterMetersCount];
for (int i = 0; i < waterMetersCount; i++)

4
TBF/BenchControl/TestMethods/Adjustment/WMErrorsForm24.cs
View File

@ -96,9 +96,9 @@ namespace TBF.BenchControl.TestMethods.Adjustment
public WMErrorsForm24(IList<GenericDevices.IWaterMeter> waterMeters)
: this()
{
waterMetersCount = Math.Min(Config.Data.WMsCount, waterMeters.Count);
waterMetersCount = Math.Min(TBF.Data.WMsCount, waterMeters.Count);
ShuffleTextBoxes(waterMetersCount, Config.Data.LineSize);
ShuffleTextBoxes(waterMetersCount, TBF.Data.LineSize);
disabled = new bool[waterMetersCount];
for (int i = 0; i < waterMetersCount; i++)

4
TBF/BenchControl/TestMethods/Adjustment/WMErrorsForm48.cs
View File

@ -104,9 +104,9 @@ namespace TBF.BenchControl.TestMethods.Adjustment
public WMErrorsForm48(IList<GenericDevices.IWaterMeter> waterMeters)
: this()
{
waterMetersCount = Math.Min(Config.Data.WMsCount, waterMeters.Count);
waterMetersCount = Math.Min(TBF.Data.WMsCount, waterMeters.Count);
ShuffleTextBoxes(waterMetersCount, Config.Data.LineSize);
ShuffleTextBoxes(waterMetersCount, TBF.Data.LineSize);
disabled = new bool[waterMetersCount];
for (int i = 0; i < waterMetersCount; i++)

10
TBF/BenchControl/TestMethods/CombinedWithDetection/CombinedWithDetectionSeq.cs
View File

@ -56,9 +56,9 @@ namespace TBF.BenchControl.TestMethods.CombinedWithDetection
return new List<Event> { Event.ConfigurationError };
}
if (test.Part < 0 || test.Part > Config.Data.CompoundWMsCount)
if (test.Part < 0 || test.Part > TBF.Data.CompoundWMsCount)
{
UiBridge.Bridge.OnError(this, string.Format("Test 'Part' should be '-' or 1 .. {0}", Config.Data.CompoundWMsCount));
UiBridge.Bridge.OnError(this, string.Format("Test 'Part' should be '-' or 1 .. {0}", TBF.Data.CompoundWMsCount));
return new List<Event> { Event.ConfigurationError };
}
@ -102,7 +102,7 @@ namespace TBF.BenchControl.TestMethods.CombinedWithDetection
float switchTimeEnd = 0.001f; /// in seconds, original vale is 1 ms
/// Specific for combined meters
int[] lastWMPulses = new int[2 * Config.Data.CompoundWMsCount];
int[] lastWMPulses = new int[2 * TBF.Data.CompoundWMsCount];
//--------------------------------
State.Create(string.Format("{0}({1}) : Stop diverter gate etc", test.Method, test.Name))
@ -317,7 +317,7 @@ namespace TBF.BenchControl.TestMethods.CombinedWithDetection
///
/// Last pulses are kept to calculate differences
for (int i = 0; i < 2 * Config.Data.CompoundWMsCount; i++) lastWMPulses[i] = RegisterReaders[i].WMPulses;
for (int i = 0; i < 2 * TBF.Data.CompoundWMsCount; i++) lastWMPulses[i] = RegisterReaders[i].WMPulses;
/// Shift data in the detection buffers
for (int i = DetectionBufferSize - 2; i >= 0; i--)
@ -566,7 +566,7 @@ namespace TBF.BenchControl.TestMethods.CombinedWithDetection
UpdateAllStatistics(StateMachine.Time);
/// TODO: Reimplement
//for (int i = 0; i < Config.Data.CompoundWMsCount; i++)
//for (int i = 0; i < TBF.Data.CompoundWMsCount; i++)
//{
// data.TestResult.CombinedMeters[i].VolumeMeter = data.TestResult.Meters[2 * i].VolumeMeter
// + data.TestResult.Meters[2 * i + 1].VolumeMeter;

12
TBF/BenchControl/TestMethods/DiverterTest/DiverterTestSeq.cs
View File

@ -430,10 +430,10 @@ namespace TBF.BenchControl.TestMethods.DiverterTest
///
/// Initialize cumulated reference and water metert pulses
///
int[] cumulativeEtPulses = new int[Config.Data.WMsCount + 1]; /// 0 .. Config.Data.WMsCount
int[] cumulativeWMPulses = new int[Config.Data.WMsCount + 1]; /// 1 .. Config.Data.WMsCount
double[] cumulativeTestTime = new double[Config.Data.WMsCount + 1]; /// 0 .. Config.Data.WMsCount
for (int i = 0; i <= Config.Data.WMsCount; i++)
int[] cumulativeEtPulses = new int[TBF.Data.WMsCount + 1]; /// 0 .. TBF.Data.WMsCount
int[] cumulativeWMPulses = new int[TBF.Data.WMsCount + 1]; /// 1 .. TBF.Data.WMsCount
double[] cumulativeTestTime = new double[TBF.Data.WMsCount + 1]; /// 0 .. TBF.Data.WMsCount
for (int i = 0; i <= TBF.Data.WMsCount; i++)
{
cumulativeEtPulses[i] = 0;
if (i > 0) cumulativeWMPulses[i] = 0;
@ -547,7 +547,7 @@ namespace TBF.BenchControl.TestMethods.DiverterTest
/// Accumulate partial pulses
cumulativeEtPulses[0] += cBrd.EtPulses(0);
cumulativeTestTime[0] += cBrd.TTime;
for (int i = 1; i <= Config.Data.WMsCount; i++)
for (int i = 1; i <= TBF.Data.WMsCount; i++)
{
cumulativeEtPulses[i] += cBrd.EtPulses(i);
cumulativeWMPulses[i] += cBrd.WMeterPulses(i);
@ -667,7 +667,7 @@ namespace TBF.BenchControl.TestMethods.DiverterTest
///
cumulativeEtPulses[0] += cBrd.EtPulses(0);
cumulativeTestTime[0] += cBrd.TTime;
for (int i = 1; i <= Config.Data.WMsCount; i++)
for (int i = 1; i <= TBF.Data.WMsCount; i++)
{
cumulativeEtPulses[i] += cBrd.EtPulses(i);
cumulativeWMPulses[i] += cBrd.WMeterPulses(i);

2
TBF/BenchControl/TestMethods/Endurance/CycleDlg.cs
View File

@ -62,7 +62,7 @@ namespace TBF.BenchControl.TestMethods.Endurance
seqStepsCtrl = new CycleStepsCtrl() as ITabWithListViewEx;
/// Prepare a list of valves for the endurance test
TbfComponents = BenchControl.TbfComponents.LoadComponentsFromDB(Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config));
TbfComponents = BenchControl.TbfComponents.LoadComponentsFromDB(TBF.DB.CreateSession(Users.Entities.DBKind.Config));
Valves = new List<IValve>();
for (int bitNr = 0; bitNr < 8; bitNr++)
{

10
TBF/BenchControl/TestMethods/FixedStart/FixedStartSeq.cs
View File

@ -431,7 +431,7 @@ namespace TBF.BenchControl.TestMethods.FixedStart
if (heatMetersTestParams != null)
{
for (int i = 0; i < Config.Data.HeatMetersCount; i++)
for (int i = 0; i < TBF.Data.HeatMetersCount; i++)
{
BenchControl.Elde.FixedStartRegisterReader.RegisterReader volumeRegisterReader =
sensPath.RegisterReaders[2 * i] as BenchControl.Elde.FixedStartRegisterReader.RegisterReader;
@ -448,7 +448,7 @@ namespace TBF.BenchControl.TestMethods.FixedStart
}
else
{
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
GenericDevices.IRegReader rr = sensPath.RegisterReaders[i];
@ -575,7 +575,7 @@ namespace TBF.BenchControl.TestMethods.FixedStart
if (compound)
{
/// TODO: Reimplement for combined meters
//for (int i = 0; i < Config.Data.CompoundWMsCount; i++)
//for (int i = 0; i < TBF.Data.CompoundWMsCount; i++)
//{
// data.TestResult.CombinedMeters[i].VolumeMeter = data.TestResult.Meters[2 * i].VolumeMeter
// + data.TestResult.Meters[2 * i + 1].VolumeMeter;
@ -716,7 +716,7 @@ namespace TBF.BenchControl.TestMethods.FixedStart
if (heatMetersTestParams != null)
{
for (int i = 0; i < Config.Data.HeatMetersCount; i++)
for (int i = 0; i < TBF.Data.HeatMetersCount; i++)
{
BenchControl.Elde.FixedStartRegisterReader.RegisterReader volumeRegisterReader =
sensPath.RegisterReaders[2 * i] as BenchControl.Elde.FixedStartRegisterReader.RegisterReader;
@ -733,7 +733,7 @@ namespace TBF.BenchControl.TestMethods.FixedStart
}
else
{
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
GenericDevices.IRegReader rr = sensPath.RegisterReaders[i];

4
TBF/BenchControl/TestMethods/FixedStartAdvanced/FixedStartAdvancedSeq.cs
View File

@ -320,7 +320,7 @@ namespace TBF.BenchControl.TestMethods.FixedStartAdvanced
}
while (!e.Contains(Event.ModelessFormClosed));
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
BenchControl.Elde.FixedStartRegisterReader.RegisterReader registerReader =
sensPath.RegisterReaders[i] as BenchControl.Elde.FixedStartRegisterReader.RegisterReader;
@ -544,7 +544,7 @@ namespace TBF.BenchControl.TestMethods.FixedStartAdvanced
while (!e.Contains(Event.ModelessFormClosed));
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
BenchControl.Elde.FixedStartRegisterReader.RegisterReader registerReader =
sensPath.RegisterReaders[i] as BenchControl.Elde.FixedStartRegisterReader.RegisterReader;

4
TBF/BenchControl/TestMethods/FixedStartDeferredEval/FixedStartDeferredEvalSeq.cs
View File

@ -612,7 +612,7 @@ namespace TBF.BenchControl.TestMethods.FixedStartDeferredEval
if (compound)
{
/// TODO: Reimplement for combined meters
//for (int i = 0; i < Config.Data.CompoundWMsCount; i++)
//for (int i = 0; i < TBF.Data.CompoundWMsCount; i++)
//{
// data.TestResult.CombinedMeters[i].VolumeMeter = data.TestResult.Meters[2 * i].VolumeMeter
// + data.TestResult.Meters[2 * i + 1].VolumeMeter;
@ -904,7 +904,7 @@ namespace TBF.BenchControl.TestMethods.FixedStartDeferredEval
/// Update register reader star and end-volumes from data entry forms
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
GenericDevices.IRegReader r = sensPath.RegisterReaders[i];
BenchControl.Network.Camera.RoiForFixedStart.Roi rr = r as BenchControl.Network.Camera.RoiForFixedStart.Roi;

4
TBF/BenchControl/TestMethods/FixedStartMassCollDeferredEval/FixedStartMassCollDeferredEvalSeq.cs
View File

@ -716,7 +716,7 @@ namespace TBF.BenchControl.TestMethods.FixedStartMassCollDeferredEval
if (compound)
{
/// TODO: Reimplement for combined meters
//for (int i = 0; i < Config.Data.CompoundWMsCount; i++)
//for (int i = 0; i < TBF.Data.CompoundWMsCount; i++)
//{
// data.TestResult.CombinedMeters[i].VolumeMeter = data.TestResult.Meters[2 * i].VolumeMeter
// + data.TestResult.Meters[2 * i + 1].VolumeMeter;
@ -1050,7 +1050,7 @@ namespace TBF.BenchControl.TestMethods.FixedStartMassCollDeferredEval
/// Update register reader star and end-volumes from data entry forms
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
GenericDevices.IRegReader r = sensPath.RegisterReaders[i];
BenchControl.Network.Camera.RoiForFixedStart.Roi rr = r as BenchControl.Network.Camera.RoiForFixedStart.Roi;

10
TBF/BenchControl/TestMethods/FixedStartMassCollection/FixedStartMassCollectionSeq.cs
View File

@ -551,7 +551,7 @@ namespace TBF.BenchControl.TestMethods.FixedStartMassCollection
if (heatMetersTestParams != null)
{
for (int i = 0; i < Config.Data.HeatMetersCount; i++)
for (int i = 0; i < TBF.Data.HeatMetersCount; i++)
{
BenchControl.Elde.FixedStartRegisterReader.RegisterReader volumeRegisterReader =
sensPath.RegisterReaders[2 * i] as BenchControl.Elde.FixedStartRegisterReader.RegisterReader;
@ -568,7 +568,7 @@ namespace TBF.BenchControl.TestMethods.FixedStartMassCollection
}
else
{
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
GenericDevices.IRegReader rr = sensPath.RegisterReaders[i];
@ -689,7 +689,7 @@ namespace TBF.BenchControl.TestMethods.FixedStartMassCollection
if (compound)
{
/// TODO: Reimplement for combined meters
//for (int i = 0; i < Config.Data.CompoundWMsCount; i++)
//for (int i = 0; i < TBF.Data.CompoundWMsCount; i++)
//{
// data.TestResult.CombinedMeters[i].VolumeMeter = data.TestResult.Meters[2 * i].VolumeMeter
// + data.TestResult.Meters[2 * i + 1].VolumeMeter;
@ -890,7 +890,7 @@ namespace TBF.BenchControl.TestMethods.FixedStartMassCollection
if (heatMetersTestParams != null)
{
for (int i = 0; i < Config.Data.HeatMetersCount; i++)
for (int i = 0; i < TBF.Data.HeatMetersCount; i++)
{
BenchControl.Elde.FixedStartRegisterReader.RegisterReader volumeRegisterReader =
sensPath.RegisterReaders[2 * i] as BenchControl.Elde.FixedStartRegisterReader.RegisterReader;
@ -907,7 +907,7 @@ namespace TBF.BenchControl.TestMethods.FixedStartMassCollection
}
else
{
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
GenericDevices.IRegReader rr = sensPath.RegisterReaders[i];

6
TBF/BenchControl/TestMethods/FixedStartTankCollection/FixedStartTankCollectionSeq.cs
View File

@ -393,7 +393,7 @@ namespace TBF.BenchControl.TestMethods.FixedStartTankCollection
}
while (!e.Contains(Event.ModelessFormClosed));
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
GenericDevices.IRegReader rr = sensPath.RegisterReaders[i];
@ -511,7 +511,7 @@ namespace TBF.BenchControl.TestMethods.FixedStartTankCollection
if (compoundTestParams != null)
{
/// TODO: Reimplement for combined meters
//for (int i = 0; i < Config.Data.CompoundWMsCount; i++)
//for (int i = 0; i < TBF.Data.CompoundWMsCount; i++)
//{
// data.TestResult.CombinedMeters[i].VolumeMeter = data.TestResult.Meters[2 * i].VolumeMeter
// + data.TestResult.Meters[2 * i + 1].VolumeMeter;
@ -653,7 +653,7 @@ namespace TBF.BenchControl.TestMethods.FixedStartTankCollection
while (!e.Contains(Event.ModelessFormClosed));
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
GenericDevices.IRegReader rr = sensPath.RegisterReaders[i];

4
TBF/BenchControl/TestMethods/PulsesTest/PulsesTestSeq.cs
View File

@ -26,11 +26,11 @@ namespace TBF.BenchControl.TestMethods.PulsesTest
{
#pragma warning disable 162 /// Disables 'Unreachable code detected' warning
if (Config.Data.WMsCount > 12)
if (TBF.Data.WMsCount > 12)
{
myRef.modelessDlg = new WMPulsesForm24(waterMeters);
}
else if (Config.Data.WMsCount > 6)
else if (TBF.Data.WMsCount > 6)
{
myRef.modelessDlg = new WMPulsesForm12(waterMeters);
}

2
TBF/BenchControl/TestMethods/PulsesTest/WMPulsesForm12.cs
View File

@ -94,7 +94,7 @@ namespace TBF.BenchControl.TestMethods.PulsesTest
{
waterMetersCount = waterMeters.Count;
ShuffleTextBoxes(waterMetersCount, Config.Data.LineSize);
ShuffleTextBoxes(waterMetersCount, TBF.Data.LineSize);
disabled = new bool[waterMetersCount];
for (int i = 0; i < waterMetersCount; i++) disabled[i] = waterMeters[i].Disabled;

2
TBF/BenchControl/TestMethods/PulsesTest/WMPulsesForm24.cs
View File

@ -100,7 +100,7 @@ namespace TBF.BenchControl.TestMethods.PulsesTest
{
waterMetersCount = waterMeters.Count;
ShuffleTextBoxes(waterMetersCount, Config.Data.LineSize);
ShuffleTextBoxes(waterMetersCount, TBF.Data.LineSize);
disabled = new bool[waterMetersCount];
pulsesCount = new double[waterMetersCount];

2
TBF/BenchControl/TestMethods/PulsesTestManual/ManualPulsesForm12.cs
View File

@ -79,7 +79,7 @@ namespace TBF.BenchControl.TestMethods.PulsesTestManual
{
waterMetersCount = waterMeters.Count;
ShuffleTextBoxes(waterMetersCount, Config.Data.LineSize);
ShuffleTextBoxes(waterMetersCount, TBF.Data.LineSize);
disabled = new bool[waterMetersCount];
passed = new bool[waterMetersCount];

2
TBF/BenchControl/TestMethods/PulsesTestManual/ManualPulsesForm24.cs
View File

@ -86,7 +86,7 @@ namespace TBF.BenchControl.TestMethods.PulsesTestManual
{
waterMetersCount = waterMeters.Count;
ShuffleTextBoxes(waterMetersCount, Config.Data.LineSize);
ShuffleTextBoxes(waterMetersCount, TBF.Data.LineSize);
disabled = new bool[waterMetersCount];
passed = new bool[waterMetersCount];

4
TBF/BenchControl/TestMethods/PulsesTestManual/PulsesTestManualSeq.cs
View File

@ -26,11 +26,11 @@ namespace TBF.BenchControl.TestMethods.PulsesTestManual
{
#pragma warning disable 162 /// Disables 'Unreachable code detected' warning
if (Config.Data.WMsCount > 12)
if (TBF.Data.WMsCount > 12)
{
myRef.modelessDlg = new ManualPulsesForm24(waterMeters);
}
else if (Config.Data.WMsCount > 6)
else if (TBF.Data.WMsCount > 6)
{
myRef.modelessDlg = new ManualPulsesForm12(waterMeters);
}

22
TBF/BenchControl/TestMethods/SensitivityTest/SensitivityTestSeq.cs
View File

@ -98,7 +98,7 @@ namespace TBF.BenchControl.TestMethods.SensitivityTest
/// This is to calculate increments of WM pulses
int[] lastWMPulses = new int[Config.Data.WMsCount];
int[] lastWMPulses = new int[TBF.Data.WMsCount];
//--------------------------------
State.Create(string.Format("{0}({1}) : stopTest diverter gate etc", test.Method, test.Name))
@ -242,11 +242,11 @@ namespace TBF.BenchControl.TestMethods.SensitivityTest
/// Allocate detection buffers
double[] flowsForDetection = new double[DetectionBufferSize];
double[,] pulseFreqsForDetection = new double[Config.Data.WMsCount, DetectionBufferSize];
double[,] pulseFreqsForDetection = new double[TBF.Data.WMsCount, DetectionBufferSize];
/// Current values
flowsForDetection[0] = RefFlow.Val;
for (int i = 0; i < Config.Data.WMsCount; i++) pulseFreqsForDetection[i, 0] = 0;
for (int i = 0; i < TBF.Data.WMsCount; i++) pulseFreqsForDetection[i, 0] = 0;
int startTime = StateMachine.Time;
int lastTime = StateMachine.Time;
@ -254,8 +254,8 @@ namespace TBF.BenchControl.TestMethods.SensitivityTest
float rvPulse = (testParams.TargetQ > (test.Qfrom + test.Qto) / 2.0f) ? 0.05f : -0.05f; // rise or fall?
rvPulse *= (100.0f * testParams.RateOfChange);
bool[] detected = new bool[Config.Data.WMsCount];
double[] detectedFlow = new double[Config.Data.WMsCount];
bool[] detected = new bool[TBF.Data.WMsCount];
double[] detectedFlow = new double[TBF.Data.WMsCount];
for (int i = 0; i < detectedFlow.Length; i++)
{
detected[i] = false;
@ -287,7 +287,7 @@ namespace TBF.BenchControl.TestMethods.SensitivityTest
{
/// Last pulses are kept to calculate differences
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
if (RegisterReaders[i] != null) lastWMPulses[i] = RegisterReaders[i].WMPulses;
}
@ -296,7 +296,7 @@ namespace TBF.BenchControl.TestMethods.SensitivityTest
for (int j = DetectionBufferSize - 2; j >= 0; j--)
{
flowsForDetection[j + 1] = flowsForDetection[j];
for (int i = 0; i < Config.Data.WMsCount; i++) pulseFreqsForDetection[i, j+1] = pulseFreqsForDetection[i, j];
for (int i = 0; i < TBF.Data.WMsCount; i++) pulseFreqsForDetection[i, j+1] = pulseFreqsForDetection[i, j];
}
switch (ReadRegistersTempPressAmbient(measureOperations, false))
@ -307,7 +307,7 @@ namespace TBF.BenchControl.TestMethods.SensitivityTest
/// TODO: !!! The following can only be done for compound meters
flowsForDetection[0] = cBrd.ReferenceFreq * outPath.FlowMeter.NominalFlow / 2000.0f;
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
double diff = (RegisterReaders[i] != null) ? (RegisterReaders[i].WMPulses - lastWMPulses[i]) : 0;
pulseFreqsForDetection[i, 0] = diff / (double)(StateMachine.Time - lastTime);
@ -348,7 +348,7 @@ namespace TBF.BenchControl.TestMethods.SensitivityTest
// aveFlowBefore.ToString("F2"),
// aveFlowAfter.ToString("F2")));
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
if ((BatchRslts.Batch.WaterMeters[i] != null) && !BatchRslts.Batch.WaterMeters[i].Disabled && (RegisterReaders[i] != null) && !detected[i])
{
@ -399,7 +399,7 @@ namespace TBF.BenchControl.TestMethods.SensitivityTest
}
allDetected = true;
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
if ((BatchRslts.Batch.WaterMeters[i] != null) && !BatchRslts.Batch.WaterMeters[i].Disabled && (RegisterReaders[i] != null) && !detected[i]) allDetected = false;
}
@ -408,7 +408,7 @@ namespace TBF.BenchControl.TestMethods.SensitivityTest
}
while (!allDetected && !targetReached);
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
//UiBridge.Bridge.OnEvent(this, string.Format("detected flow[{0}]={1}\r\n", i+1, detectedFlow[i].ToString("F4")));
}

14
TBF/BenchControl/Various/StatisticsMonitoring/ProcessStatistics.cs
View File

@ -110,9 +110,9 @@ namespace TBF.BenchControl.Various.StatisticsMonitoring
int completeBatchesProcessed = 0;
int[] usages = new int[Config.Data.WMsCount];
int[] failures = new int[Config.Data.WMsCount];
for (int i = 0; i < Config.Data.WMsCount; i++) usages[i] = failures[i] = 0;
int[] usages = new int[TBF.Data.WMsCount];
int[] failures = new int[TBF.Data.WMsCount];
for (int i = 0; i < TBF.Data.WMsCount; i++) usages[i] = failures[i] = 0;
///
/// Read results of recent batches (up to 'MaxBatches')
@ -140,7 +140,7 @@ namespace TBF.BenchControl.Various.StatisticsMonitoring
foreach (var wm in batches[0].WaterMeters)
{
int i = wm.WMPosition - 1;
if (0 <= i && i < Config.Data.WMsCount && usages[i] < RequiredUsages && !wm.Disabled && wm.CompletedFromTests())
if (0 <= i && i < TBF.Data.WMsCount && usages[i] < RequiredUsages && !wm.Disabled && wm.CompletedFromTests())
{
isACompleteBatch = true;
usages[i]++;
@ -149,7 +149,7 @@ namespace TBF.BenchControl.Various.StatisticsMonitoring
}
usagesMin = int.MaxValue;
for (int i = 0; i < Config.Data.WMsCount; i++) if (usagesMin > usages[i]) usagesMin = usages[i];
for (int i = 0; i < TBF.Data.WMsCount; i++) if (usagesMin > usages[i]) usagesMin = usages[i];
if (isACompleteBatch) completeBatchesProcessed++;
}
@ -164,7 +164,7 @@ namespace TBF.BenchControl.Various.StatisticsMonitoring
/// Find out whether at lest one event needs to be triggered
///
bool doTriggerEvents = false;
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
if ((usages[i] > 0) && (iperlHeadFailureRateThreshold > 0) && (float)failures[i] / (float)usages[i] >= iperlHeadFailureRateThreshold)
{
@ -183,7 +183,7 @@ namespace TBF.BenchControl.Various.StatisticsMonitoring
ISession session = Events.DB.CreateSession();
Events.DB.LoadSubscribers(session);
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
if ((usages[i] > 0) && (iperlHeadFailureRateThreshold > 0) && (float)failures[i] / (float)usages[i] >= iperlHeadFailureRateThreshold)
{

66
TBF/DB.cs Normal file
View File

@ -0,0 +1,66 @@
///
/// Copyright (c) 2021 Sensus Slovensko a.s.
///
using System;
using NHibernate;
using Config;
using Users.Entities;
namespace TBF
{
public class DB
{
///
/// Database related: This object reference is set after a successful user login
///
public static DatabaseSettings CurrentBench;
/// <summary>
/// Session factories for regular sessions.
/// </summary>
public static ISessionFactory[] SessionFactories = new ISessionFactory[(int)DBKind.Count];
/// Create a NHibernate session for the given database
public static ISession CreateSession(DBKind database)
{
if (database < 0 || database >= DBKind.Count) return null;
int ix = (int)database;
if (SessionFactories[ix] == null)
{
SessionFactories[ix] = CreateSessionFactory(database);
}
return SessionFactories[ix].OpenSession();
}
/// <summary>
/// NHibernate session factory (to create the database session 'SessionFactory')
/// </summary>
/// <returns>A database session</returns>
static ISessionFactory CreateSessionFactory(DBKind database)
{
DBType dbType;
string connectionString;
switch (database)
{
default:
case DBKind.Config:
dbType = CurrentBench.ProceduresDBSettings.DbType;
connectionString = CurrentBench.ProceduresDBSettings.ConnectionString;
break;
case DBKind.Results:
dbType = CurrentBench.WaterMetersDBSettings.DbType;
connectionString = CurrentBench.WaterMetersDBSettings.ConnectionString;
break;
case DBKind.RemoteConfig:
dbType = CurrentBench.UsersDBSettings.DbType;
connectionString = CurrentBench.UsersDBSettings.ConnectionString;
break;
}
return Config.FluentCommon.CreateSessionFactory(database, dbType, connectionString, false);
}
}
}

58
TBF/Data.cs Normal file
View File

@ -0,0 +1,58 @@
///
/// Copyright (c) 2021 Sensus Slovensko a.s.
///
using System;
namespace TBF
{
public class Data
{
public static int WMsCount;
public static int LineSize;
public static int CompoundWMsCount;
public static int HeatMetersCount;
public static int MaxPartNr;
static Data()
{
/// Default values applied when there is no BanchInfo component
WMsCount = 20;
LineSize = 10;
CompoundWMsCount = 1;
HeatMetersCount = 0;
MaxPartNr = WMsCount / LineSize;
}
public static void SetData()
{
WMsCount = Config.Data.WMsCount;
CompoundWMsCount = Config.Data.CompoundWMsCount;
LineSize = Config.Data.LineSize;
HeatMetersCount = Config.Data.HeatMetersCount;
MaxPartNr = Config.Data.MaxPartNr;
}
/// <summary>
/// Determines whether tests part number is OK.
/// Examples of correct part number are:
/// 1, 2, 12, 21 in case of max. part nr.== 2
/// 1, 2, 3, 4, 12, 13, 14, 23, 24, 34, 123, 124, 134, 234, 1234 in case of max. part nr.== 4
/// </summary>
/// <param name="partNr">Tests par tnumber</param>
/// <returns>true when Part number is OK</returns>
public static bool IsGoodPartNr(int partNr)
{
bool firstDigitIsOK = ((partNr % 10) > 0) && ((partNr % 10) <= MaxPartNr);
bool secondDigitIsOK = (((partNr / 10) % 10) > 0) && (((partNr / 10) % 10) <= MaxPartNr);
bool thirdDigitIsOK = (((partNr / 100) % 10) > 0) && (((partNr / 100) % 10) <= MaxPartNr);
bool fourthDigitIsOK = (((partNr / 1000) % 10) > 0) && (((partNr / 1000) % 10) <= MaxPartNr);
if (firstDigitIsOK && (partNr / 10 == 0)) return true;
if (firstDigitIsOK && secondDigitIsOK && (partNr / 100 == 0)) return true;
if (firstDigitIsOK && secondDigitIsOK && thirdDigitIsOK && (partNr / 1000 == 0)) return true;
if (firstDigitIsOK && secondDigitIsOK && thirdDigitIsOK && fourthDigitIsOK && (partNr / 10000 == 0)) return true;
return false;
}
}
}

22
TBF/Program.cs
View File

@ -349,18 +349,18 @@ namespace TBF
/// Copy the selected bench settings to CurrentBench.
/// Clone() guarantees that current bench settings wont be modified
/// when user modifies the database settings in DatabaseSettingsDlg.
Config.Data.CurrentBench = (Config.DatabaseSettings)LocalSettings.TestBenches[i].Clone();
Results.DB.DbType = Config.Data.CurrentBench.WaterMetersDBSettings.DbType;
Results.DB.ConnectionString = Config.Data.CurrentBench.WaterMetersDBSettings.ConnectionString;
TBF.DB.CurrentBench = (Config.DatabaseSettings)LocalSettings.TestBenches[i].Clone();
Results.DB.DbType = TBF.DB.CurrentBench.WaterMetersDBSettings.DbType;
Results.DB.ConnectionString = TBF.DB.CurrentBench.WaterMetersDBSettings.ConnectionString;
/// Save the selection to local settings
LocalSettings.LastBenchName = Config.Data.CurrentBench.BenchName;
LocalSettings.LastBenchName = TBF.DB.CurrentBench.BenchName;
///
/// Connect to Config database.
/// This triggers an exception in case user is a power user and there is no Config database.
///
IList<Procedure> listOfProcedures = Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config)
IList<Procedure> listOfProcedures = TBF.DB.CreateSession(Users.Entities.DBKind.Config)
.QueryOver<Procedure>()
.Where(x => (x.ProcedureState == ProcedureState.Active))
.And(x => (x.Name == LocalSettings.LastProcedureName))
@ -371,7 +371,7 @@ namespace TBF
///
Results.DB.LoadSharedData();
int maxBatchNr = Results.DB.GetMaxSavedBatchNr();
if (!Config.Data.CurrentBench.IsRealBench || Program.LocalSettings.BatchNr <= maxBatchNr)
if (!TBF.DB.CurrentBench.IsRealBench || Program.LocalSettings.BatchNr <= maxBatchNr)
{
log.FatalFormat("Max. BatchNr in DB = {0}, LocalSettings.BatchNr = {1}", maxBatchNr, Program.LocalSettings.BatchNr);
Program.LocalSettings.BatchNr = maxBatchNr + 1;
@ -382,11 +382,11 @@ namespace TBF
///
/// Connect to Events database (if any) and load recent events from this test bench.
///
if (Config.Data.CurrentBench.EventsDBSettings.DbType != Users.Entities.DBType.None &&
!string.IsNullOrEmpty(Config.Data.CurrentBench.EventsDBSettings.ConnectionString))
if (TBF.DB.CurrentBench.EventsDBSettings.DbType != Users.Entities.DBType.None &&
!string.IsNullOrEmpty(TBF.DB.CurrentBench.EventsDBSettings.ConnectionString))
{
Events.DB.DbType = (Events.Entities.DBType)Config.Data.CurrentBench.EventsDBSettings.DbType;
Events.DB.ConnectionString = Config.Data.CurrentBench.EventsDBSettings.ConnectionString;
Events.DB.DbType = (Events.Entities.DBType)TBF.DB.CurrentBench.EventsDBSettings.DbType;
Events.DB.ConnectionString = TBF.DB.CurrentBench.EventsDBSettings.ConnectionString;
Events.DB.LoadRecentEvents(Events.DB.CreateSession(), loginDlgBench.BenchName, 7); /// Last 7 days
}
@ -446,7 +446,7 @@ namespace TBF
///
if (LocalSettings.LastProcedureName != null)
{
IList<Procedure> listOfProcedures = Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config)
IList<Procedure> listOfProcedures = TBF.DB.CreateSession(Users.Entities.DBKind.Config)
.QueryOver<Procedure>()
.Where(x => (x.ProcedureState == ProcedureState.Active))
.And(x => (x.Name == LocalSettings.LastProcedureName))

2
TBF/TBF.csproj
View File

@ -2063,6 +2063,8 @@
<Compile Include="Boxes\FloatBox.cs" />
<Compile Include="Boxes\IBox.cs" />
<Compile Include="Boxes\IntBox.cs" />
<Compile Include="Data.cs" />
<Compile Include="DB.cs" />
<Compile Include="Resources\Strings.cs.Designer.cs">
<AutoGen>True</AutoGen>
<DesignTime>True</DesignTime>

2
TBF/UI/Bench/Components/ComponentsManagerDlg.cs
View File

@ -119,7 +119,7 @@ namespace TBF.UI.Bench.Components
sharedButtons.DisableButtons(SharedButtons.Buttons.Remove | SharedButtons.Buttons.Edit);
session = Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config);
session = TBF.DB.CreateSession(Users.Entities.DBKind.Config);
cmpntEntities = session.QueryOver<Component>()
.OrderBy(x => x.ItemNr).Asc
.List<Component>();

2
TBF/UI/Bench/Metrology/MetrologyDlg.cs
View File

@ -51,7 +51,7 @@ namespace TBF.UI.Bench.Metrology
int platinumTempMetersCount = 0;
int evaporationsCount = 0;
session = Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config);
session = TBF.DB.CreateSession(Users.Entities.DBKind.Config);
cmpntEntities = session.QueryOver<Component>()
.OrderBy(x => x. ItemNr).Asc
.List();

4
TBF/UI/Bench/Paths/PathsDlg.cs
View File

@ -67,7 +67,7 @@ namespace TBF.UI.Bench.Paths
/// Load the list of components from the database
try
{
TbfComponents = BenchControl.TbfComponents.LoadComponentsFromDB(Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config));
TbfComponents = BenchControl.TbfComponents.LoadComponentsFromDB(TBF.DB.CreateSession(Users.Entities.DBKind.Config));
}
catch
{
@ -99,7 +99,7 @@ namespace TBF.UI.Bench.Paths
}
/// Create the database session for paths
Session = Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config);
Session = TBF.DB.CreateSession(Users.Entities.DBKind.Config);
Procedures = Session.QueryOver<Procedure>().List();
Tests = Session.QueryOver<Test>().List();

10
TBF/UI/Bench/Paths/PathsMetersCtrl.cs
View File

@ -64,18 +64,18 @@ namespace TBF.UI.Bench.Paths
TBF.LocalSettings ls = Program.LocalSettings;
Columns.Add(Strings.Name, (ls.MetersColumnCount > 0) ? ls.MetersColumnWidths[0] : 60 * parent.Dpi / Constants.Dpi100pct);
int clmn = (int)Column.FixedColumnsCount;
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
Columns.Add(string.Format("{0} {1}", Strings.Sensor, i + 1), (ls.MetersColumnCount > clmn) ? ls.MetersColumnWidths[clmn] : 50 * parent.Dpi / Constants.Dpi100pct);
clmn++;
}
/// Editors
editors = new Control[fixedColumnsCount + Config.Data.WMsCount];
editors = new Control[fixedColumnsCount + TBF.Data.WMsCount];
///
editors[(int)Column.Name] = new TextBox(); /// Name
/// Prepare valve combo-boxes (max. 64 valves)
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
ComboBox cb = new ComboBox();
foreach (var rr in readers) cb.Items.Add(rr.Cfg.Name);
@ -134,7 +134,7 @@ namespace TBF.UI.Bench.Paths
ListViewItem lvi = new ListViewItem(entity.Name);
for (int i = 0; i < Config.Data.WMsCount; i++)
for (int i = 0; i < TBF.Data.WMsCount; i++)
{
if (path.RegisterReaders != null && path.RegisterReaders[i] != null)
{
@ -157,7 +157,7 @@ namespace TBF.UI.Bench.Paths
entity.Name = lvi.Text;
for (int j = 0; j < Config.Data.WMsCount; j++)
for (int j = 0; j < TBF.Data.WMsCount; j++)
{
entity.SetSensor(j, lvi.SubItems[fixedColumnsCount + j].Text);
}

2
TBF/UI/Bench/TestProfiles/TestProfileDlg.cs
View File

@ -428,7 +428,7 @@ namespace TBF.UI.Bench.TestProfiles
if (e.SubItem == (int)MtrlgyClmn.Part)
{
if (e.DisplayText.Equals("-")) return; /// OK
if (!int.TryParse(e.DisplayText, out idummy) || !Test.IsGoodPartNr(idummy))
if (!int.TryParse(e.DisplayText, out idummy) || !Data.IsGoodPartNr(idummy))
{
e.DisplayText = e.Item.SubItems[e.SubItem].Text;
e.Cancel = true;

2
TBF/UI/Bench/TestProfiles/TestProfilesCtrl.cs
View File

@ -51,7 +51,7 @@ namespace TBF.UI.Bench.TestProfiles
{
if (Parent == null) return;
session = Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config);
session = TBF.DB.CreateSession(Users.Entities.DBKind.Config);
this.parent = parent;
this.parentControl = parentControl;

2
TBF/UI/Bench/Transitions/TransitionsDlg.cs
View File

@ -90,7 +90,7 @@ namespace TBF.UI.Bench.Transitions
seqStepsCtrls = new List<ITabWithListViewEx>();
/// Open the database
Session = Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config);
Session = TBF.DB.CreateSession(Users.Entities.DBKind.Config);
/// Prepare a list of components and a list of all valves in the test bench
TbfComponents = BenchControl.TbfComponents.LoadComponentsFromDB(Session);

2
TBF/UI/Bench/Uncertainties/UncertaintiesDlg.cs
View File

@ -54,7 +54,7 @@ namespace TBF.UI.Bench.Uncertainties
int tempMetersCount = 0;
int evaporationsCount = 0;
session = Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config);
session = TBF.DB.CreateSession(Users.Entities.DBKind.Config);
cmpntEntities = session.QueryOver<Component>()
.OrderBy(x => x. ItemNr).Asc
.List();

10
TBF/UI/Calendar/CalendarTabPageCtrl.cs
View File

@ -67,7 +67,7 @@ namespace TBF.UI.Calendar
try
{
/// Read custom events from the database
ISession session = Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config);
ISession session = TBF.DB.CreateSession(Users.Entities.DBKind.Config);
customEvents = session.QueryOver<CustomEvent>().List();
TripplicateShiftCustomEvents(customEvents);
@ -159,7 +159,7 @@ namespace TBF.UI.Calendar
try
{
var session = (parentSession != null) ? parentSession : Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config);
var session = (parentSession != null) ? parentSession : TBF.DB.CreateSession(Users.Entities.DBKind.Config);
var customEvents = (customEventsFromDB != null) ? customEventsFromDB : session.QueryOver<CustomEvent>() .List();
for (int i = customEvents.Count - 1; i >= 0; i--)
@ -235,7 +235,7 @@ namespace TBF.UI.Calendar
try
{
ISession session = Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config);
ISession session = TBF.DB.CreateSession(Users.Entities.DBKind.Config);
var customEventsFromDB = session.QueryOver<CustomEvent>().List();
for (int i = customEventsFromDB.Count - 1; i >= 0; i--)
@ -321,7 +321,7 @@ namespace TBF.UI.Calendar
{
try
{
ISession session = Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config);
ISession session = TBF.DB.CreateSession(Users.Entities.DBKind.Config);
session.SaveOrUpdate(dlg.NewEvent as CustomEvent);
session.Flush();
@ -357,7 +357,7 @@ namespace TBF.UI.Calendar
try
{
/// Re-read selected custom event from the database
ISession session = Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config);
ISession session = TBF.DB.CreateSession(Users.Entities.DBKind.Config);
var cEvents = session.QueryOver<CustomEvent>()
.Where(x => (x.Id == evnt.Id))
.List();

19
TBF/UI/MainWnd.cs
View File

@ -1,5 +1,5 @@
///
/// Copyright (c) 2013-2020 Sensus Slovensko a.s.
/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
@ -94,8 +94,8 @@ namespace TBF.UI
Text = string.Format("Test Bench Framework ver. {0} - {1}{2}",
Program.Version,
Config.Data.CurrentBench.BenchName,
Config.Data.CurrentBench.IsRealBench ? "" : Strings._offline);
TBF.DB.CurrentBench.BenchName,
TBF.DB.CurrentBench.IsRealBench ? "" : Strings._offline);
///
/// Customize menu items
///
@ -124,7 +124,8 @@ namespace TBF.UI
IsShutdownDisabled = true;
IsShutdownPCAfterClosingTbf = false;
BenchControl.StateMachine.MachineState = Config.Data.CurrentBench.IsRealBench ? BenchControl.MachineState.StartingUp : BenchControl.MachineState.Disabled;
BenchControl.StateMachine.MachineState = TBF.DB.CurrentBench.IsRealBench ? BenchControl.MachineState.StartingUp : BenchControl.MachineState.Disabled;
TBF.Data.SetData();
///
if (BenchControl.StateMachine.MachineState == BenchControl.MachineState.StartingUp)
{
@ -504,8 +505,8 @@ namespace TBF.UI
private void usersTSMItem_Click(object s, EventArgs e)
{
Users.DB.ConnectionString = Config.Data.CurrentBench.ProceduresDBSettings.ConnectionString;
Users.DB.DbType = Config.Data.CurrentBench.ProceduresDBSettings.DbType;
Users.DB.ConnectionString = TBF.DB.CurrentBench.ProceduresDBSettings.ConnectionString;
Users.DB.DbType = TBF.DB.CurrentBench.ProceduresDBSettings.DbType;
#if TURA_IPERL || TURA_IPERL_NEW || TURA_SPECIAL
Users.Forms.UserManagementDlg dlg = new Users.Forms.UserManagementDlg(Users.DB.CreateSession(), true);
string connStr = Users.DB.ConnectionString;
@ -592,7 +593,7 @@ namespace TBF.UI
for (int i = 0; i < dBase.Length; i++)
{
IList<Procedure> procedures = Config.FluentCommon.CreateSession(dBase[i])
IList<Procedure> procedures = TBF.DB.CreateSession(dBase[i])
.QueryOver<Procedure>()
.Where(x => (x.ProcedureState == ProcedureState.Active))
.OrderBy(x => x.ItemNr).Asc
@ -864,7 +865,7 @@ namespace TBF.UI
/// </summary>
void BackupConfiguration()
{
string connectionString = Config.Data.CurrentBench.ProceduresDBSettings.ConnectionString;
string connectionString = TBF.DB.CurrentBench.ProceduresDBSettings.ConnectionString;
string server = Config.Utils.GetDBServer(connectionString);
if ((server != "localhost") && (server != "127.0.0.1"))
@ -896,7 +897,7 @@ namespace TBF.UI
/// </summary>
void BackupResults()
{
string connectionString = Config.Data.CurrentBench.WaterMetersDBSettings.ConnectionString;
string connectionString = TBF.DB.CurrentBench.WaterMetersDBSettings.ConnectionString;
string server = Config.Utils.GetDBServer(connectionString);
if ((server != "localhost") && (server != "127.0.0.1"))

Some files were not shown because too many files have changed in this diff Show More