public static S6xFunction GetFixedFunctionTemplate(FixedFunctions fixedFunction)
{
S6xFunction oRes = new S6xFunction();
switch (fixedFunction)
{
case FixedFunctions.FN703:
oRes.ShortLabel = "FN703";
oRes.Label = "ECT/ACT Transfer";
oRes.Comments = oRes.ShortLabel + " - " + oRes.Label;
oRes.Comments += "\r\nInput is a rough high byte only conversion.";
oRes.InputScaleExpression = "X/50";
oRes.InputScalePrecision = 2;
oRes.InputUnits = "Volts";
oRes.OutputScaleExpression = "X*2";
oRes.OutputScalePrecision = 0;
oRes.OutputUnits = "°F";
break;
default:
oRes.ShortLabel = fixedFunction.ToString();
oRes.Label = oRes.ShortLabel;
break;
}
return(oRes);
}
public void Import(S6xFunction s6xFunction, int xlsBaseOffset, SortedList <string, XlsLevel> xlsLevels)
{
PID = s6xFunction.ShortLabel;
Key = s6xFunction.DuplicateNum == 0 ? Key : Key + "_" + s6xFunction.DuplicateNum.ToString();
Title = s6xFunction.Label;
Comments = s6xFunction.Comments;
if (s6xFunction.Category != null && s6xFunction.Category != string.Empty)
{
foreach (XlsLevel xlsLevel in xlsLevels.Values)
{
if (xlsLevel.Label.ToUpper() == s6xFunction.Category.ToUpper())
{
Level = xlsLevel;
break;
}
}
}
if (s6xFunction.Category2 != null && s6xFunction.Category2 != string.Empty)
{
foreach (XlsLevel xlsLevel in xlsLevels.Values)
{
if (xlsLevel.Label.ToUpper() == s6xFunction.Category2.ToUpper())
{
Level2 = xlsLevel;
break;
}
}
}
AddressInt = Tools.xlsAddressFromBinAddress(s6xFunction.AddressBinInt, xlsBaseOffset);
Bytes = s6xFunction.ByteInput ? 1 : 2;
Rows = s6xFunction.RowsNumber;
XSigned = s6xFunction.SignedInput;
XUnits = s6xFunction.InputUnits;
XEquation = s6xFunction.InputScaleExpression.Trim();
XDigits = s6xFunction.InputScalePrecision;
XMin = Tools.getValidMinMax(s6xFunction.InputMin);
XMax = Tools.getValidMinMax(s6xFunction.InputMax);
YSigned = s6xFunction.SignedOutput;
YUnits = s6xFunction.OutputUnits;
YEquation = s6xFunction.OutputScaleExpression.Trim();
YDigits = s6xFunction.OutputScalePrecision;
YMin = Tools.getValidMinMax(s6xFunction.OutputMin);
YMax = Tools.getValidMinMax(s6xFunction.OutputMax);
}
public static void updateFunctionRow(ref SQLite806xDB db806x, ref SADS6x sadS6x, R_SAD806x_Def_Functions rRow, S6xFunction s6xObject)
{
SQLite806xToolsSAD806xV10.updateFunctionRow(ref db806x, ref sadS6x, rRow, s6xObject);
}
public static object addFunctionRow(ref SQLite806xDB db806x, ref SADS6x sadS6x, ref List <R_SAD806x_Def_Functions> rList, S6xFunction s6xObject)
{
return(SQLite806xToolsSAD806xV10.addFunctionRow(ref db806x, ref sadS6x, ref rList, s6xObject));
}
public static void addTableRow(ref SQLite806xDB db806x, ref SADS6x sadS6x, ref List <R_806x_Def_Tables> rList, S6xTable s6xObject)
{
if (db806x == null)
{
return;
}
if (sadS6x == null)
{
return;
}
if (rList == null)
{
return;
}
if (s6xObject == null)
{
return;
}
if (s6xObject.Skip || !s6xObject.Store)
{
return;
}
R_806x_Def_Tables rRow = db806x.newRow <R_806x_Def_Tables>();
rRow.Bank.Value = s6xObject.BankNum;
rRow.Address.Value = s6xObject.AddressInt;
rRow.UniqueAddCode.Value = s6xObject.DuplicateNum;
rRow.Byte.Value = !s6xObject.WordOutput;
rRow.CellsScaleExpression.Value = s6xObject.CellsScaleExpression;
rRow.CellsScalePrecision.Value = s6xObject.CellsScalePrecision;
rRow.CellsUnits.Value = s6xObject.CellsUnits;
rRow.Columns.Value = s6xObject.ColsNumber;
rRow.ColumnsUnits.Value = s6xObject.ColsUnits;
rRow.Comments.Value = s6xObject.Comments;
rRow.Label.Value = s6xObject.Label;
rRow.Rows.Value = s6xObject.RowsNumber;
rRow.RowsUnits.Value = s6xObject.RowsUnits;
rRow.ShortLabel.Value = s6xObject.ShortLabel;
rRow.Signed.Value = s6xObject.SignedOutput;
S6xFunction s6xScaler = null;
if (s6xObject.ColsScalerAddress != null && s6xObject.ColsScalerAddress != string.Empty)
{
s6xScaler = (S6xFunction)sadS6x.slFunctions[s6xObject.ColsScalerAddress];
if (s6xScaler == null)
{
s6xScaler = (S6xFunction)sadS6x.slDupFunctions[s6xObject.ColsScalerAddress];
}
if (s6xScaler != null)
{
rRow.ColumnsScalerBank.Value = s6xScaler.BankNum;
rRow.ColumnsScalerAddress.Value = s6xScaler.AddressInt;
rRow.ColumnsScalerUniqueAddCode.Value = (s6xScaler.DuplicateAddress == null || s6xScaler.DuplicateAddress == string.Empty) ? 0.ToString() : s6xScaler.DuplicateNum.ToString();
}
}
if (s6xObject.RowsScalerAddress != null && s6xObject.RowsScalerAddress != string.Empty)
{
s6xScaler = (S6xFunction)sadS6x.slFunctions[s6xObject.RowsScalerAddress];
if (s6xScaler == null)
{
s6xScaler = (S6xFunction)sadS6x.slDupFunctions[s6xObject.RowsScalerAddress];
}
if (s6xScaler != null)
{
rRow.RowsScalerBank.Value = s6xScaler.BankNum;
rRow.RowsScalerAddress.Value = s6xScaler.AddressInt;
rRow.RowsScalerUniqueAddCode.Value = (s6xScaler.DuplicateAddress == null || s6xScaler.DuplicateAddress == string.Empty) ? 0.ToString() : s6xScaler.DuplicateNum.ToString();
}
}
rList.Add(rRow);
}
public static void addFunctionRow(ref SQLite806xDB db806x, ref SADS6x sadS6x, ref List <R_806x_Def_Functions> rList, S6xFunction s6xObject)
{
if (db806x == null)
{
return;
}
if (sadS6x == null)
{
return;
}
if (rList == null)
{
return;
}
if (s6xObject == null)
{
return;
}
if (s6xObject.Skip || !s6xObject.Store)
{
return;
}
R_806x_Def_Functions rRow = db806x.newRow <R_806x_Def_Functions>();
rRow.Bank.Value = s6xObject.BankNum;
rRow.Address.Value = s6xObject.AddressInt;
rRow.UniqueAddCode.Value = s6xObject.DuplicateNum;
rRow.Byte.Value = s6xObject.ByteInput;
rRow.Comments.Value = s6xObject.Comments;
rRow.InputScaleExpression.Value = s6xObject.InputScaleExpression;
rRow.InputScalePrecision.Value = s6xObject.InputScalePrecision;
rRow.InputSigned.Value = s6xObject.SignedInput;
rRow.InputUnits.Value = s6xObject.InputUnits;
rRow.Label.Value = s6xObject.Label;
rRow.OutputScaleExpression.Value = s6xObject.OutputScaleExpression;
rRow.OutputScalePrecision.Value = s6xObject.OutputScalePrecision;
rRow.OutputSigned.Value = s6xObject.SignedOutput;
rRow.OutputUnits.Value = s6xObject.OutputUnits;
rRow.Rows.Value = s6xObject.RowsNumber;
rRow.ShortLabel.Value = s6xObject.ShortLabel;
rList.Add(rRow);
}
private void calibChart_MouseClick(object sender, MouseEventArgs e)
{
Chart cChart = (Chart)sender;
Axis xAxis = cChart.ChartAreas[0].AxisX;
double pPos = (int)xAxis.PixelPositionToValue(e.Location.X);
foreach (CustomLabel cLabel in xAxis.CustomLabels)
{
if (pPos >= cLabel.FromPosition && pPos <= cLabel.ToPosition)
{
if (cLabel.Tag == null)
{
return;
}
if (cLabel.Tag.GetType() == typeof(S6xTable))
{
try
{
S6xTable s6xTable = (S6xTable)cLabel.Tag;
mainToolTip.SetToolTip((Control)sender, s6xTable.Label + "\r\n" + s6xTable.UniqueAddressHex + "\r\n" + s6xTable.ShortLabel + "\r\n\r\n" + s6xTable.Comments);
if (cChart == calibCurrentChart)
{
S6xNavInfo niMFHeaderCateg = new S6xNavInfo(elemsTreeView.Nodes[S6xNav.getHeaderCategName(S6xNavHeaderCategory.TABLES)]);
if (niMFHeaderCateg.isValid)
{
TreeNode tnMFNode = niMFHeaderCateg.FindElement(s6xTable.UniqueAddress);
if (tnMFNode != null)
{
elemsTreeView.SelectedNode = tnMFNode;
}
tnMFNode = null;
}
niMFHeaderCateg = null;
}
}
catch { }
}
else if (cLabel.Tag.GetType() == typeof(S6xFunction))
{
try
{
S6xFunction s6xFunction = (S6xFunction)cLabel.Tag;
mainToolTip.SetToolTip((Control)sender, s6xFunction.Label + "\r\n" + s6xFunction.UniqueAddressHex + "\r\n" + s6xFunction.ShortLabel + "\r\n\r\n" + s6xFunction.Comments);
if (cChart == calibCurrentChart)
{
S6xNavInfo niMFHeaderCateg = new S6xNavInfo(elemsTreeView.Nodes[S6xNav.getHeaderCategName(S6xNavHeaderCategory.FUNCTIONS)]);
if (niMFHeaderCateg.isValid)
{
TreeNode tnMFNode = niMFHeaderCateg.FindElement(s6xFunction.UniqueAddress);
if (tnMFNode != null)
{
elemsTreeView.SelectedNode = tnMFNode;
}
tnMFNode = null;
}
niMFHeaderCateg = null;
}
}
catch { }
}
return;
}
}
}
public void Import(S6xFunction s6xFunction, int xdfBaseOffset)
{
title = s6xFunction.Label;
description = s6xFunction.Comments;
xdfAxis[0].xdfData.mmedaddress = Tools.xdfAddressFromBinAddress(s6xFunction.AddressBinInt, xdfBaseOffset);
if (s6xFunction.SignedInput)
{
xdfAxis[0].xdfData.mmedtypeflags = "0x03";
}
else
{
xdfAxis[0].xdfData.mmedtypeflags = "0x02";
}
if (s6xFunction.ByteInput)
{
xdfAxis[0].xdfData.mmedelementsizebits = "8";
}
else
{
xdfAxis[0].xdfData.mmedelementsizebits = "16";
}
if (s6xFunction.ByteInput)
{
xdfAxis[0].xdfData.mmedmajorstridebits = "-16";
}
else
{
xdfAxis[0].xdfData.mmedmajorstridebits = "-32";
}
xdfAxis[0].xdfData.mmedcolcount = s6xFunction.RowsNumber.ToString();
xdfAxis[0].units = s6xFunction.InputUnits;
xdfAxis[0].indexcount = s6xFunction.RowsNumber.ToString();
xdfAxis[0].xdfMath.equation = s6xFunction.InputScaleExpression.Trim();
if (s6xFunction.InputScalePrecision >= SADDef.DefaultScaleMinPrecision && s6xFunction.InputScalePrecision <= SADDef.DefaultScaleMaxPrecision)
{
xdfAxis[0].decimalpl = s6xFunction.InputScalePrecision.ToString();
}
if (s6xFunction.ByteInput)
{
xdfAxis[1].xdfData.mmedaddress = Tools.xdfAddressFromBinAddress(s6xFunction.AddressBinInt + 1, xdfBaseOffset); // Based on Input Type
}
else
{
xdfAxis[1].xdfData.mmedaddress = Tools.xdfAddressFromBinAddress(s6xFunction.AddressBinInt + 2, xdfBaseOffset);
}
if (s6xFunction.SignedOutput)
{
xdfAxis[1].xdfData.mmedtypeflags = "0x03";
}
else
{
xdfAxis[1].xdfData.mmedtypeflags = "0x02";
}
if (s6xFunction.ByteOutput)
{
xdfAxis[1].xdfData.mmedelementsizebits = "8";
}
else
{
xdfAxis[1].xdfData.mmedelementsizebits = "16";
}
if (s6xFunction.ByteOutput)
{
xdfAxis[1].xdfData.mmedmajorstridebits = "-16";
}
else
{
xdfAxis[1].xdfData.mmedmajorstridebits = "-32";
}
xdfAxis[1].xdfData.mmedcolcount = s6xFunction.RowsNumber.ToString();
xdfAxis[1].units = s6xFunction.OutputUnits;
xdfAxis[1].indexcount = s6xFunction.RowsNumber.ToString();
xdfAxis[1].xdfMath.equation = s6xFunction.OutputScaleExpression.Trim();
if (s6xFunction.OutputScalePrecision >= SADDef.DefaultScaleMinPrecision && s6xFunction.OutputScalePrecision <= SADDef.DefaultScaleMaxPrecision)
{
xdfAxis[1].decimalpl = s6xFunction.OutputScalePrecision.ToString();
}
}
public XdfFunction(S6xFunction s6xFunction, int xdfBaseOffset)
{
Init();
Import(s6xFunction, xdfBaseOffset);
}
// To be able to show scaled data for tables
public static string[] getTableElemDataScale(ref SADBin sadBin, string scalerUniqueAddress, int stepNumber)
{
string[] scaleResult = null;
S6xFunction s6xScaler = null;
if (sadBin == null)
{
return new string[] { }
}
;
if (stepNumber <= 0)
{
return new string[] { }
}
;
scaleResult = new string[stepNumber];
for (int iStep = 0; iStep < stepNumber; iStep++)
{
scaleResult[iStep] = (iStep + 1).ToString();
}
if (scalerUniqueAddress != null && scalerUniqueAddress != string.Empty)
{
s6xScaler = (S6xFunction)sadBin.S6x.slFunctions[scalerUniqueAddress];
}
if (s6xScaler == null && scalerUniqueAddress != null && scalerUniqueAddress != string.Empty)
{
s6xScaler = (S6xFunction)sadBin.S6x.slDupFunctions[scalerUniqueAddress];
}
if (s6xScaler != null)
{
if (s6xScaler.RowsNumber <= 0)
{
s6xScaler = null;
}
}
if (s6xScaler == null)
{
return(scaleResult);
}
s6xScaler.AddressBinInt = Tools.binAddressCorrected(s6xScaler.BankNum, s6xScaler.AddressInt, ref sadBin, s6xScaler.AddressBinInt);
int iRowSize = 4;
if (s6xScaler.ByteInput)
{
iRowSize--;
}
if (s6xScaler.ByteOutput)
{
iRowSize--;
}
object[] arrRows = new object[s6xScaler.RowsNumber];
string[] arrBytes = sadBin.getBytesArray(s6xScaler.AddressBinInt, iRowSize * s6xScaler.RowsNumber);
bool failedInputScale = false;
bool failedOutputScale = false;
int iAddress = 0;
for (int iRow = 0; iRow < arrRows.Length; iRow++)
{
object[] arrRow = new object[2];
int iValue = 0;
if (s6xScaler.ByteInput)
{
try { iValue = Tools.getByteInt(arrBytes[iAddress], s6xScaler.SignedInput); }
catch { iValue = 0; }
iAddress++;
}
else
{
try { iValue = Tools.getWordInt(arrBytes[iAddress + 1] + arrBytes[iAddress], s6xScaler.SignedInput); }
catch { iValue = 0; }
iAddress += 2;
}
if (failedInputScale)
{
arrRow[0] = iValue;
}
else
{
try { arrRow[0] = Tools.ScaleValue(iValue, s6xScaler.InputScaleExpression, true); }
catch
{
failedInputScale = true;
arrRow[0] = iValue;
}
}
if (s6xScaler.ByteOutput)
{
try { iValue = Tools.getByteInt(arrBytes[iAddress], s6xScaler.SignedOutput); }
catch { iValue = 0; }
iAddress++;
}
else
{
try { iValue = Tools.getWordInt(arrBytes[iAddress + 1] + arrBytes[iAddress], s6xScaler.SignedOutput); }
catch { iValue = 0; }
iAddress += 2;
}
if (failedOutputScale)
{
arrRow[1] = iValue;
}
else
{
try { arrRow[1] = Tools.ScaleValue(iValue, s6xScaler.OutputScaleExpression, true); }
catch
{
failedOutputScale = true;
arrRow[1] = iValue;
}
}
arrRows[iRow] = arrRow;
}
if (failedOutputScale)
{
return(scaleResult);
}
double[] scaleValues = new double[stepNumber];
for (int iStep = 0; iStep < stepNumber; iStep++)
{
scaleResult[iStep] = string.Empty;
scaleValues[iStep] = 0.0;
}
double dMaxIndex = 0.0;
double dMinIndex = double.MaxValue;
double dMaxValue = 0.0;
double dMinValue = 0.0;
for (int iRow = 0; iRow < arrRows.Length; iRow++)
{
double dSc = (double)((object[])arrRows[iRow])[1];
if (dSc >= dMaxIndex)
{
dMaxIndex = dSc;
dMaxValue = (double)((object[])arrRows[iRow])[0];
}
if (dSc <= dMinIndex)
{
dMinIndex = dSc;
dMinValue = (double)((object[])arrRows[iRow])[0];
}
if (dSc == (int)dSc && dSc >= 0 && dSc < stepNumber)
{
scaleValues[(int)dSc] = (double)((object[])arrRows[iRow])[0];
scaleResult[(int)dSc] = string.Format("{0:G}", scaleValues[(int)dSc]);
}
if (dSc <= 0.0)
{
break;
}
}
if (scaleResult[0] == string.Empty)
{
if (dMinIndex > (double)(0) && dMinIndex < (double)(0 + 1))
{
scaleValues[0] = dMinValue;
scaleResult[0] = string.Format("{0:G}", scaleValues[0]);
}
}
if (scaleResult[scaleResult.Length - 1] == string.Empty)
{
if (dMaxIndex > (double)(scaleResult.Length - 1 - 1) && dMinIndex < (double)(scaleResult.Length - 1 + 1))
{
scaleValues[scaleResult.Length - 1] = dMaxValue;
scaleResult[scaleResult.Length - 1] = string.Format("{0:G}", scaleValues[scaleResult.Length - 1]);
}
else if (dMaxIndex > 0.0 && dMaxIndex > dMinIndex)
{
for (int iStep = (int)dMaxIndex; iStep < stepNumber; iStep++)
{
scaleValues[scaleResult.Length - 1] = dMaxValue;
scaleResult[iStep] = string.Format("{0:G}", scaleValues[scaleResult.Length - 1]);
}
}
}
if (scaleResult[0] == string.Empty || scaleResult[scaleResult.Length - 1] == string.Empty)
{
for (int iStep = 0; iStep < stepNumber; iStep++)
{
scaleResult[iStep] = (iStep + 1).ToString();
}
return(scaleResult);
}
int lastStepWithValue = -1;
for (int iStep = 0; iStep < stepNumber; iStep++)
{
if (scaleResult[iStep] == string.Empty)
{
continue;
}
if (lastStepWithValue >= 0 && iStep - lastStepWithValue > 1)
{
double stepGap = (scaleValues[iStep] - scaleValues[lastStepWithValue]) / (iStep - lastStepWithValue);
for (int iStepUpdate = lastStepWithValue + 1; iStepUpdate < iStep; iStepUpdate++)
{
scaleValues[iStepUpdate] = scaleValues[iStepUpdate - 1] + stepGap;
}
}
lastStepWithValue = iStep;
}
// Final Format
bool pureIntFormat = true;
bool lowNumberFormat = true;
for (int iStep = 0; iStep < stepNumber; iStep++)
{
if (scaleValues[iStep] != (int)iStep)
{
pureIntFormat = false;
}
// Thinking about Transfer function on 5v12
if (scaleValues[iStep] > 6.0)
{
lowNumberFormat = false;
}
}
string sFormat = "{0:0}";
if (pureIntFormat || !lowNumberFormat)
{
sFormat = "{0:0}";
}
// New Scale Precision field
if (s6xScaler.InputScalePrecision >= 0 && s6xScaler.InputScalePrecision <= 8)
{
sFormat = "{0:0." + new string('0', s6xScaler.InputScalePrecision) + "}";
}
for (int iStep = 0; iStep < stepNumber; iStep++)
{
scaleResult[iStep] = string.Format(sFormat, scaleValues[iStep]);
}
return(scaleResult);
}
}
}
public static bool showElemData(ref DataGridView elemDataGridView, ref SADBin sadBin, object s6xObject, bool dataDecimal, bool ignoreDefinedConversion, bool dataReversed, RepositoryConversionItem rcOutput, RepositoryConversionItem rcInput)
{
S6xScalar s6xScalar = null;
S6xFunction s6xFunction = null;
S6xTable s6xTable = null;
S6xStructure s6xStruct = null;
DataTable dtTable = null;
Type dataType = null;
string sValue = string.Empty;
int iValue = 0;
int iAddress = 0;
string[] arrBytes = null;
string[] arrCols = null;
object[] arrRows = null;
object[] arrRowsHeaders = null;
object[] arrRow = null;
bool failedScale = false;
int iBfTop = -1;
if (elemDataGridView == null)
{
return(false);
}
if (sadBin == null)
{
return(false);
}
if (s6xObject == null)
{
return(false);
}
if (dataDecimal)
{
dataType = typeof(double);
}
else
{
dataType = typeof(string);
}
elemDataGridView.DataSource = null;
S6xNavHeaderCategory headerCategory = S6xNavHeaderCategory.UNDEFINED;
if (s6xObject.GetType() == typeof(S6xScalar))
{
headerCategory = S6xNavHeaderCategory.SCALARS;
}
else if (s6xObject.GetType() == typeof(S6xFunction))
{
headerCategory = S6xNavHeaderCategory.FUNCTIONS;
}
else if (s6xObject.GetType() == typeof(S6xTable))
{
headerCategory = S6xNavHeaderCategory.TABLES;
}
else if (s6xObject.GetType() == typeof(S6xStructure))
{
headerCategory = S6xNavHeaderCategory.STRUCTURES;
}
switch (headerCategory)
{
case S6xNavHeaderCategory.SCALARS:
s6xScalar = (S6xScalar)s6xObject;
elemDataGridView.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
s6xScalar.AddressBinInt = Tools.binAddressCorrected(s6xScalar.BankNum, s6xScalar.AddressInt, ref sadBin, s6xScalar.AddressBinInt);
if (s6xScalar.isBitFlags)
{
dataType = typeof(string);
arrCols = null;
if (s6xScalar.BitFlags != null)
{
if (s6xScalar.BitFlags.Length > 0)
{
arrCols = new string[s6xScalar.BitFlags.Length + 1];
for (int iCol = 1; iCol < arrCols.Length; iCol++)
{
arrCols[iCol] = s6xScalar.BitFlags[arrCols.Length - iCol - 1].ShortLabel;
}
}
}
// Default BitFlags
if (arrCols == null)
{
iBfTop = 15;
if (s6xScalar.Byte)
{
iBfTop = 7;
}
for (int iBf = iBfTop; iBf >= 0; iBf--)
{
arrCols = new string[iBfTop + 2];
for (int iCol = 1; iCol < arrCols.Length; iCol++)
{
arrCols[iCol] = "B" + iBf.ToString();
}
}
}
// For better output
if (arrCols != null)
{
for (int iCol = 1; iCol < arrCols.Length; iCol++)
{
arrCols[iCol] = OutputTools.GetSpacesCenteredString(arrCols[iCol], 20);
}
}
}
else
{
arrCols = new string[1];
}
if (s6xScalar.Byte)
{
arrCols[0] = "Byte";
arrBytes = sadBin.getBytesArray(s6xScalar.AddressBinInt, 1);
try
{
sValue = arrBytes[0];
iValue = Tools.getByteInt(sValue, s6xScalar.Signed);
}
catch
{
sValue = string.Empty;
iValue = 0;
}
}
else
{
arrCols[0] = "Word";
arrBytes = sadBin.getBytesArray(s6xScalar.AddressBinInt, 2);
try
{
sValue = Tools.LsbFirst(arrBytes);
iValue = Tools.getWordInt(sValue, s6xScalar.Signed);
}
catch
{
sValue = string.Empty;
iValue = 0;
}
}
// For better output
if (arrCols.Length == 1)
{
arrCols[0] = OutputTools.GetSpacesCenteredString(arrCols[0], 100);
}
else
{
arrCols[0] = OutputTools.GetSpacesCenteredString(arrCols[0], 50);
}
arrRow = new object[arrCols.Length];
if (s6xScalar.isBitFlags)
{
BitArray arrBit = new BitArray(new int[] { iValue });
for (int iCol = 1; iCol < arrRow.Length; iCol++)
{
if (arrBit[s6xScalar.BitFlags[arrRow.Length - iCol - 1].Position])
{
arrRow[iCol] = s6xScalar.BitFlags[arrRow.Length - iCol - 1].SetValue;
}
else
{
arrRow[iCol] = s6xScalar.BitFlags[arrRow.Length - iCol - 1].NotSetValue;
}
}
}
if (dataDecimal)
{
if (failedScale)
{
arrRow[0] = iValue;
}
else
{
try
{
if (ignoreDefinedConversion)
{
if (rcOutput == null)
{
arrRow[0] = iValue;
}
else
{
arrRow[0] = Tools.ScaleValue(iValue, rcOutput.InternalFormula, 0, true);
}
}
else
{
if (rcOutput == null)
{
arrRow[0] = Tools.ScaleValue(iValue, s6xScalar.ScaleExpression, s6xScalar.ScalePrecision, true);
}
else
{
arrRow[0] = Tools.ScaleValue(iValue, rcOutput.InternalFormula.ToUpper().Replace("X", "(" + s6xScalar.ScaleExpression + ")"), s6xScalar.ScalePrecision, true);
}
}
}
catch
{
failedScale = true;
arrRow[0] = iValue;
}
}
}
else
{
arrRow[0] = sValue.ToUpper();
}
arrRows = new object[] { arrRow };
s6xScalar = null;
break;
case S6xNavHeaderCategory.FUNCTIONS:
s6xFunction = (S6xFunction)s6xObject;
elemDataGridView.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
s6xFunction.AddressBinInt = Tools.binAddressCorrected(s6xFunction.BankNum, s6xFunction.AddressInt, ref sadBin, s6xFunction.AddressBinInt);
arrCols = new string[2];
arrCols[0] = "Word Input";
iValue = 2;
if (s6xFunction.ByteInput)
{
arrCols[0] = "Byte Input";
iValue--;
}
arrCols[1] = "Word Output";
iValue += 2;
if (s6xFunction.ByteOutput)
{
arrCols[1] = "Byte Output";
iValue--;
}
arrCols[0] = OutputTools.GetSpacesCenteredString(arrCols[0], 50); // For better output
arrCols[1] = OutputTools.GetSpacesCenteredString(arrCols[1], 50); // For better output
if (s6xFunction.RowsNumber <= 0)
{
arrRows = new object[] { };
}
else
{
arrRows = new object[s6xFunction.RowsNumber];
arrBytes = sadBin.getBytesArray(s6xFunction.AddressBinInt, iValue * arrRows.Length);
iAddress = 0;
for (int iRow = 0; iRow < arrRows.Length; iRow++)
{
arrRow = new object[arrCols.Length];
for (int iCol = 0; iCol < arrRow.Length; iCol++)
{
if (iCol % 2 == 0)
{
if (s6xFunction.ByteInput)
{
try
{
sValue = arrBytes[iAddress];
iValue = Tools.getByteInt(sValue, s6xFunction.SignedInput);
}
catch
{
sValue = string.Empty;
iValue = 0;
}
iAddress++;
}
else
{
try
{
sValue = arrBytes[iAddress + 1] + arrBytes[iAddress];
iValue = Tools.getWordInt(sValue, s6xFunction.SignedInput);
}
catch
{
sValue = string.Empty;
iValue = 0;
}
iAddress += 2;
}
if (dataDecimal)
{
if (failedScale)
{
arrRow[iCol] = iValue;
}
else
{
try
{
if (ignoreDefinedConversion)
{
if (rcInput == null)
{
arrRow[iCol] = iValue;
}
else
{
arrRow[iCol] = Tools.ScaleValue(iValue, rcInput.InternalFormula, 0, true);
}
}
else
{
if (rcInput == null)
{
arrRow[iCol] = Tools.ScaleValue(iValue, s6xFunction.InputScaleExpression, s6xFunction.InputScalePrecision, true);
}
else
{
arrRow[iCol] = Tools.ScaleValue(iValue, rcInput.InternalFormula.ToUpper().Replace("X", "(" + s6xFunction.InputScaleExpression + ")"), s6xFunction.InputScalePrecision, true);
}
}
}
catch
{
failedScale = true;
arrRow[iCol] = iValue;
}
}
}
else
{
arrRow[iCol] = sValue.ToUpper();
}
}
else
{
if (s6xFunction.ByteOutput)
{
try
{
sValue = arrBytes[iAddress];
iValue = Tools.getByteInt(sValue, s6xFunction.SignedOutput);
}
catch
{
sValue = string.Empty;
iValue = 0;
}
iAddress++;
}
else
{
try
{
sValue = arrBytes[iAddress + 1] + arrBytes[iAddress];
iValue = Tools.getWordInt(sValue, s6xFunction.SignedOutput);
}
catch
{
sValue = string.Empty;
iValue = 0;
}
iAddress += 2;
}
if (dataDecimal)
{
if (failedScale)
{
arrRow[iCol] = iValue;
}
else
{
try
{
if (ignoreDefinedConversion)
{
if (rcOutput == null)
{
arrRow[iCol] = iValue;
}
else
{
arrRow[iCol] = Tools.ScaleValue(iValue, rcOutput.InternalFormula, 0, true);
}
}
else
{
if (rcOutput == null)
{
arrRow[iCol] = Tools.ScaleValue(iValue, s6xFunction.OutputScaleExpression, s6xFunction.OutputScalePrecision, true);
}
else
{
arrRow[iCol] = Tools.ScaleValue(iValue, rcOutput.InternalFormula.ToUpper().Replace("X", "(" + s6xFunction.OutputScaleExpression + ")"), s6xFunction.OutputScalePrecision, true);
}
}
}
catch
{
failedScale = true;
arrRow[iCol] = iValue;
}
}
}
else
{
arrRow[iCol] = sValue.ToUpper();
}
}
}
arrRows[iRow] = arrRow;
}
}
s6xFunction = null;
break;
case S6xNavHeaderCategory.TABLES:
s6xTable = (S6xTable)s6xObject;
if (s6xTable.ColsNumber <= 0)
{
return(false);
}
elemDataGridView.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
s6xTable.AddressBinInt = Tools.binAddressCorrected(s6xTable.BankNum, s6xTable.AddressInt, ref sadBin, s6xTable.AddressBinInt);
//arrCols = new string[s6xTable.ColsNumber];
//for (int iCol = 0; iCol < arrCols.Length; iCol++) arrCols[iCol] = (iCol + 1).ToString();
arrCols = getTableElemDataScale(ref sadBin, s6xTable.ColsScalerAddress, s6xTable.ColsNumber);
// For better output
if (arrCols != null)
{
for (int iCol = 0; iCol < arrCols.Length; iCol++)
{
arrCols[iCol] = OutputTools.GetSpacesCenteredString(arrCols[iCol], 10);
}
}
if (s6xTable.RowsNumber <= 0)
{
arrRows = new object[] { };
}
else
{
arrRows = new object[s6xTable.RowsNumber];
arrRowsHeaders = getTableElemDataScale(ref sadBin, s6xTable.RowsScalerAddress, s6xTable.RowsNumber);
if (s6xTable.WordOutput)
{
arrBytes = sadBin.getBytesArray(s6xTable.AddressBinInt, arrCols.Length * arrRows.Length * 2);
}
else
{
arrBytes = sadBin.getBytesArray(s6xTable.AddressBinInt, arrCols.Length * arrRows.Length);
}
iAddress = 0;
for (int iRow = 0; iRow < arrRows.Length; iRow++)
{
arrRow = new object[arrCols.Length];
for (int iCol = 0; iCol < arrRow.Length; iCol++)
{
try
{
if (s6xTable.WordOutput)
{
sValue = arrBytes[iAddress + 1] + arrBytes[iAddress];
iValue = Tools.getWordInt(sValue, s6xTable.SignedOutput);
}
else
{
sValue = arrBytes[iAddress];
iValue = Tools.getByteInt(sValue, s6xTable.SignedOutput);
}
}
catch
{
sValue = string.Empty;
iValue = 0;
}
iAddress++;
if (s6xTable.WordOutput)
{
iAddress++;
}
if (dataDecimal)
{
if (failedScale)
{
arrRow[iCol] = iValue;
}
else
{
try
{
if (ignoreDefinedConversion)
{
if (rcOutput == null)
{
arrRow[iCol] = iValue;
}
else
{
arrRow[iCol] = Tools.ScaleValue(iValue, rcOutput.InternalFormula, 0, true);
}
}
else
{
if (rcOutput == null)
{
arrRow[iCol] = Tools.ScaleValue(iValue, s6xTable.CellsScaleExpression, s6xTable.CellsScalePrecision, true);
}
else
{
arrRow[iCol] = Tools.ScaleValue(iValue, rcOutput.InternalFormula.ToUpper().Replace("X", "(" + s6xTable.CellsScaleExpression + ")"), s6xTable.CellsScalePrecision, true);
}
}
}
catch
{
failedScale = true;
arrRow[iCol] = iValue;
}
}
}
else
{
arrRow[iCol] = sValue.ToUpper();
}
}
arrRows[iRow] = arrRow;
}
}
s6xTable = null;
break;
case S6xNavHeaderCategory.STRUCTURES:
s6xStruct = (S6xStructure)s6xObject;
if (s6xStruct.Number <= 0)
{
return(false);
}
s6xStruct.Structure = new Structure(s6xStruct);
if (!s6xStruct.Structure.isValid)
{
return(false);
}
if (s6xStruct.Structure.isEmpty)
{
return(false);
}
elemDataGridView.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
s6xStruct.Structure.AddressBinInt = Tools.binAddressCorrected(s6xStruct.Structure.BankNum, s6xStruct.Structure.AddressInt, ref sadBin, s6xStruct.Structure.AddressBinInt);
arrBytes = sadBin.getBytesArray(s6xStruct.Structure.AddressBinInt, s6xStruct.Structure.MaxSizeSingle * s6xStruct.Number);
s6xStruct.Structure.Read(ref arrBytes, s6xStruct.Number);
arrBytes = null;
arrCols = new string[s6xStruct.Structure.MaxLineItemsNum];
for (int iCol = 0; iCol < arrCols.Length; iCol++)
{
arrCols[iCol] = (iCol + 1).ToString();
}
// For better output
for (int iCol = 0; iCol < arrCols.Length; iCol++)
{
arrCols[iCol] = OutputTools.GetSpacesCenteredString(arrCols[iCol], 10);
}
dataType = typeof(string);
if (s6xStruct.Structure.Lines.Count <= 0)
{
arrRows = new object[] { };
}
else
{
arrRows = new object[s6xStruct.Structure.Lines.Count];
arrRowsHeaders = new object[s6xStruct.Structure.Lines.Count];
int iRow = 0;
foreach (StructureLine structLine in s6xStruct.Structure.Lines)
{
arrRowsHeaders[iRow] = structLine.NumberInStructure.ToString();
arrRow = new object[arrCols.Length];
for (int iCol = 0; iCol < structLine.Items.Count; iCol++)
{
arrRow[iCol] = ((StructureItem)structLine.Items[iCol]).Value(structLine.NumberInStructure);
}
arrRows[iRow] = arrRow;
iRow++;
}
}
s6xStruct = null;
break;
default:
return(false);
}
if (arrCols == null)
{
return(false);
}
if (dataReversed)
{
object[] arrReversedRows = new object[arrRows.Length];
for (int iRow = 0; iRow < arrReversedRows.Length; iRow++)
{
arrReversedRows[arrReversedRows.Length - 1 - iRow] = arrRows[iRow];
}
arrRows = arrReversedRows;
arrReversedRows = null;
if (arrRowsHeaders != null)
{
arrReversedRows = new object[arrRowsHeaders.Length];
for (int iRow = 0; iRow < arrReversedRows.Length; iRow++)
{
arrReversedRows[arrReversedRows.Length - 1 - iRow] = arrRowsHeaders[iRow];
}
arrRowsHeaders = arrReversedRows;
arrReversedRows = null;
}
}
dtTable = new DataTable();
//foreach (string colLabel in arrCols) dtTable.Columns.Add(new DataColumn(colLabel, dataType));
for (int iCol = 0; iCol < arrCols.Length; iCol++)
{
DataColumn dcDC = new DataColumn(iCol.ToString(), dataType);
dcDC.Caption = arrCols[iCol];
dtTable.Columns.Add(dcDC);
}
foreach (object[] oRow in arrRows)
{
dtTable.Rows.Add(oRow);
}
arrRows = null;
elemDataGridView.Tag = new object[] { arrCols, arrRowsHeaders };
// For Speed purpose
elemDataGridView.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.None;
elemDataGridView.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.None;
elemDataGridView.RowHeadersWidthSizeMode = DataGridViewRowHeadersWidthSizeMode.DisableResizing;
try { elemDataGridView.DataSource = dtTable; }
catch { return(false); }
// For Speed purpose
switch (headerCategory)
{
case S6xNavHeaderCategory.SCALARS:
case S6xNavHeaderCategory.FUNCTIONS:
elemDataGridView.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.AllCells;
break;
case S6xNavHeaderCategory.TABLES:
case S6xNavHeaderCategory.STRUCTURES:
//elemDataGridView.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill;
elemDataGridView.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.AllCells;
break;
}
elemDataGridView.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.None;
elemDataGridView.RowHeadersWidthSizeMode = DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders;
dtTable = null;
arrCols = null;
arrRowsHeaders = null;
elemDataGridView.Visible = true;
return(true);
}
