/// <summary>Expensive operation, if the table contains a lot of entries</summary>
public bool ChangeColumnSortType(int columnIndex, TableValueType columnType, TableValueSortType currentSorting, TableValueSortType nextSorting)
{
if (!_ColumnSortingSupported)
{
throw new InvalidOperationException("Cannot sort this table model because it was constructed with columnSortingSupported = false");
}
// No comparer means changing sort type is not possible
IComparer comparer;
if (!_MapValueTypeToComparer.TryGetValue(columnType, out comparer))
{
return(false);
}
// Sort them
if (currentSorting == TableValueSortType.NONE)
{
bool asc = nextSorting == TableValueSortType.ASCENDING;
SortTuplesListIfSupported(new TupleComparerWrapper(comparer, asc, columnIndex));
}
else
{
// No sorting needed, just reversing the list, which is faster
ReverseTuplesListIfSupported();
}
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <param name="scanlines"></param>
/// <param name="values"></param>
public HDMATableEntry(TableValueType type, byte scanlines, params byte[] values)
{
if (type == TableValueType.End && (scanlines != 0 || values.Length != 0))
{
throw EndValueException;
}
if (type == TableValueType.Single && scanlines <= 0x80)
{
throw SingleScanlinesExcpetion;
}
else if (type == TableValueType.Single && values.Length != (scanlines - 0x80))
{
throw SingleMismatchException;
}
/*if (scanlines == 0)
* {
* ValueType = TableValueType.End;
* _scanlines = 0;
* _values = new byte[0];
* return;
* }*/
_scanlines = scanlines;
ValueType = type;
Values = values;
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
public HDMATableEntry(TableValueType type)
{
ValueType = type;
switch (type)
{
case TableValueType.End:
Scanlines = 0;
Values = new byte[0];
break;
case TableValueType.db:
Scanlines = 1;
Values = new byte[] { 0 };
break;
case TableValueType.dw:
Scanlines = 1;
Values = new byte[] { 0, 0 };
break;
case TableValueType.dl:
Scanlines = 1;
Values = new byte[] { 0, 0, 0 };
break;
case TableValueType.Single:
Scanlines = 0x81;
Values = new byte[] { 0 };
break;
default:
throw new NotImplementedException("Enum type: " + type.ToString() + " not recognized");
}
}
/// <summary>
/// Creates an ASM conform string for an table entry from the stored values.
/// </summary>
/// <param name="type">Which format to use for the table.</param>
/// <returns>The combined string of thr values</returns>
public virtual string ToString(TableValueType type)
{
if (type == TableValueType.End || type == TableValueType.Single)
{
throw new ASMException(type + " can only be used on HDMATableEntry's");
}
if (Values.Length % (int)type != 0)
{
throw new ASMException("Unmatching value count for the use of " + type);
}
string whole = type.ToString() + " ";
for (int i = 0; i < Values.Length; i += (int)type)
{
string one = "";
for (int j = i; (j - i) < (int)type && j < Values.Length; j++)
{
one = Values[j].ToString("X2") + one;
}
whole += "$" + one + ", ";
}
return(whole.Substring(0, whole.Length - 2));
}
bool IsStringInputType(TableValueType type)
{
return(type == TableValueType.STRING ||
type == TableValueType.INT ||
type == TableValueType.LONG_INT ||
type == TableValueType.FLOAT ||
type == TableValueType.DOUBLE);
}
public BasicColumnInfo(string name, TableValueType valueType, Type enumValueType = null)
{
ValueType = valueType;
EnumValueType = enumValueType;
// Setting it last, so the display name will be reconstructed using the other properties
Name = name;
}
protected BaseExpressionBuilderModel(ILayer layer, string expression, bool query = true, TableValueType outputType = TableValueType.Boolean)
{
if (layer == null)
{
throw new ArgumentNullException("layer");
}
Layer = layer;
Expression = expression;
IsQuery = query;
OutputType = outputType;
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public string ToString(TableValueType type)
{
if (Values.Length == 0)
{
return("db $" + Scanlines.ToString("X2"));
}
string str = "db $" + Scanlines.ToString("X2") + " : ";
ASMTableEntry vals = new ASMTableEntry(this.Values);
return(str + vals.ToString(type));
}
public static string ConstructColumnDisplayName(string name, TableValueType valueType, Type enumValueType = null)
{
string innerStr;
if (valueType == TableValueType.ENUMERATION)
{
innerStr = "ENUM <i>" + (enumValueType == null ? "<Unknown>" : enumValueType.Name) + "</i>";
}
else
{
innerStr = valueType.ToString();
}
return(name + "\n<color=#00000070><size=12>" + innerStr + "</size></color>");
}
public ExpressionBuilderModel(ILayer layer, string expression, TableValueType outputType)
: base(layer, expression, false, outputType)
{
}
internal static bool ShowExpressionBuilder(IAppContext context, ILayer layer, IWin32Window parent, ref string expression, TableValueType outputType)
{
var model = new ExpressionBuilderModel(layer, expression, outputType);
bool result = context.Container.Run <ExpressionBuilderPresenter, ExpressionBuilderModel>(model, parent);
if (result)
{
expression = model.Expression;
}
return(result);
}
private string peekTableValues(int ind, PcmFile peekPCM)
{
string retVal = "";
try
{
if (peekPCM.tableDatas[ind].Rows == 1 && peekPCM.tableDatas[ind].Columns == 1)
{
double curVal = getValue(peekPCM.buf, (uint)(peekPCM.tableDatas[ind].addrInt + peekPCM.tableDatas[ind].Offset), peekPCM.tableDatas[ind], 0, peekPCM);
UInt64 rawVal = (UInt64)getRawValue(peekPCM.buf, (uint)(peekPCM.tableDatas[ind].addrInt + peekPCM.tableDatas[ind].Offset), peekPCM.tableDatas[ind], 0);
string valTxt = curVal.ToString();
string unitTxt = " " + peekPCM.tableDatas[ind].Units;
string maskTxt = "";
TableValueType vt = getValueType(peekPCM.tableDatas[ind]);
if (vt == TableValueType.boolean)
{
if (peekPCM.tableDatas[ind].BitMask != null && peekPCM.tableDatas[ind].BitMask.Length > 0)
{
unitTxt = "";
UInt64 maskVal = Convert.ToUInt64(peekPCM.tableDatas[ind].BitMask.Replace("0x", ""), 16);
if ((rawVal & maskVal) == maskVal)
{
valTxt = "Set";
}
else
{
valTxt = "Unset";
}
string maskBits = Convert.ToString((Int64)maskVal, 2);
int bit = -1;
for (int i = 0; 1 <= maskBits.Length; i++)
{
if (((maskVal & (UInt64)(1 << i)) != 0))
{
bit = i + 1;
break;
}
}
if (bit > -1)
{
string rawBinVal = Convert.ToString((Int64)rawVal, 2);
rawBinVal = rawBinVal.PadLeft(getBits(peekPCM.tableDatas[ind].DataType), '0');
maskTxt = " [" + rawBinVal + "], bit $" + bit.ToString();
}
}
else
{
unitTxt = ", Unset/Set";
if (curVal > 0)
{
valTxt = "Set, " + valTxt;
}
else
{
valTxt = "Unset, " + valTxt;
}
}
}
else if (vt == TableValueType.selection)
{
Dictionary <double, string> possibleVals = parseEnumHeaders(peekPCM.tableDatas[ind].Values.Replace("Enum: ", ""));
if (possibleVals.ContainsKey(curVal))
{
unitTxt = " (" + possibleVals[curVal] + ")";
}
else
{
unitTxt = " (Out of range)";
}
}
string formatStr = "X" + (getElementSize(peekPCM.tableDatas[ind].DataType) * 2).ToString();
retVal = valTxt + unitTxt + " [" + rawVal.ToString(formatStr) + "]" + maskTxt;
//txtResult.AppendText(Environment.NewLine);
}
else
{
string tblData = ""; //"Current values: " + Environment.NewLine;
uint addr = (uint)(peekPCM.tableDatas[ind].addrInt + peekPCM.tableDatas[ind].Offset);
if (peekPCM.tableDatas[ind].RowMajor)
{
for (int r = 0; r < peekPCM.tableDatas[ind].Rows; r++)
{
for (int c = 0; c < peekPCM.tableDatas[ind].Columns; c++)
{
double curVal = getValue(peekPCM.buf, addr, peekPCM.tableDatas[ind], 0, peekPCM);
addr += (uint)getElementSize(peekPCM.tableDatas[ind].DataType);
tblData += "[" + curVal.ToString("#0.0") + "]";
}
tblData += Environment.NewLine;
}
}
else
{
List <string> tblRows = new List <string>();
for (int r = 0; r < peekPCM.tableDatas[ind].Rows; r++)
{
tblRows.Add("");
}
for (int c = 0; c < peekPCM.tableDatas[ind].Columns; c++)
{
for (int r = 0; r < peekPCM.tableDatas[ind].Rows; r++)
{
double curVal = getValue(peekPCM.buf, addr, peekPCM.tableDatas[ind], 0, peekPCM);
addr += (uint)getElementSize(peekPCM.tableDatas[ind].DataType);
tblRows[r] += "[" + curVal.ToString("#0.0") + "]";
}
}
for (int r = 0; r < peekPCM.tableDatas[ind].Rows; r++)
{
tblData += tblRows[r] + Environment.NewLine;
}
}
retVal = tblData;
}
}
catch (Exception ex)
{
LoggerBold(ex.Message);
}
return(retVal);
}
public bool TestExpression(string expression, TableValueType returnType, out string errorString)
{
errorString = string.Empty;
return(_table.TestExpression(expression, (tkValueType)returnType, ref errorString));
}
//TTuple CreateEmptyTuple()
//{
// return TableViewUtil.CreateTupleWithEmptyValues<TTuple>(Columns.ColumnsCount);
//}
public bool ChangeColumnSortType(int columnIndex, TableValueType columnType, TableValueSortType currentSorting, TableValueSortType nextSorting)
{
throw new NotSupportedException();
}
