public void EqualsTest()
{
var a = new ColumnSize
{
ColumnName = "ColumnName",
ColumnOrdinal = 1,
Size = 100
};
var b = new ColumnSize
{
ColumnName = "ColumnName2",
ColumnOrdinal = 2,
Size = 110
};
var c = new ColumnSize
{
ColumnName = "ColumnName",
ColumnOrdinal = 1,
Size = 100
};
Assert.IsFalse(a.Equals(null));
Assert.IsFalse(a.Equals(b));
Assert.IsFalse(b.Equals(c));
Assert.IsTrue(a.Equals(c));
Assert.IsTrue(c.Equals(a));
}
protected override void RegisterClasses()
{
ClassMapper
.If(() => ColumnSize.Class(ClassProvider), () => ColumnSize != null);
base.RegisterClasses();
}
public string[,] GetData()
{
double eps = 1e-10;
double lineNB = (DataLength - 2 - (ColumnNB + 1) * 32) * 1.0 / (ColumnSize.Sum() + 1);
if (lineNB - Math.Floor(lineNB) > eps)
{
throw new Exception("cdb format incorrect!");
}
string[,] datavalue = new string[(int)lineNB, ColumnNB];
int index = (ColumnNB + 1) * 32 + 1;
for (int i = 0; i < (int)lineNB; i++)
{
index++;
for (int j = 0; j < ColumnNB; j++)
{
datavalue[i, j] = Data.Substring(index, ColumnSize[j]).Replace("\0", " ").Trim();
index += ColumnSize[j];
}
}
return(datavalue);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="index">Column index</param>
/// <param name="name">The column name</param>
/// <param name="columnSize">Column size</param>
/// <param name="offset">Offset of column</param>
/// <param name="size">Size of column</param>
public ColumnInfo(byte index, string name, ColumnSize columnSize, byte offset, byte size) {
this.index = index;
this.name = name;
this.columnSize = columnSize;
this.offset = offset;
this.size = size;
}
private void TestColumnSizes(IColumn parent, ColumnSize expected1, ColumnSize expected2)
{
ColumnContainer target = new ColumnContainer(parent);
Assert.AreEqual(2, target.Columns.Count, "Container should start with two columns");
Assert.AreEqual(expected1, target.Columns[0].Size, "Column 1 was not the correct size for start of " + parent.ToString());
Assert.AreEqual(expected2, target.Columns[1].Size, "Column 2 was not the correct size for start of " + parent.ToString());
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="index">Column index</param>
/// <param name="name">The column name</param>
/// <param name="columnSize">Column size</param>
/// <param name="offset">Offset of column</param>
/// <param name="size">Size of column</param>
public ColumnInfo(byte index, string name, ColumnSize columnSize, byte offset, byte size)
{
this.index = index;
this.name = name;
this.columnSize = columnSize;
this.offset = offset;
this.size = size;
}
private void SetColumnsWidth()
{
ColumnSize columnSize = GetColumnSize();
for (int i = 0; i < _dgvCar.Columns.Count; i++)
{
_dgvCar.Columns[i].Width = columnSize.GetSize(i);
}
}
public Column(string header, string bindingExpression, ColumnType type = ColumnType.Text, ColumnSize size = ColumnSize.Undefined, int?width = null, int?maxWidth = null)
{
Header = header;
BindingExpression = bindingExpression;
Type = type;
Size = size;
Width = width;
MaxWidth = maxWidth;
}
public void Add(ColumnSize columnSize)
{
if (list.Exists(item => item == columnSize))
{
return;
}
list.Add(columnSize);
}
protected override void loadFromSql()
{
DataTable dt = _provider.Select("ColumnSize");
foreach (DataRow row in dt.Rows)
{
ColumnSize columnSize = new ColumnSize(row);
Add(columnSize);
}
}
protected override void BuildClasses(ClassBuilder builder)
{
if (!IsFields && ColumnSize != null)
{
builder.Append(ClassProvider.FieldColumn());
builder.Append(ColumnSize.Class(ClassProvider));
}
base.BuildClasses(builder);
}
private void BuildContainerClasses(ClassBuilder builder)
{
builder.Append("ant-col");
builder.Append("ant-form-item-label");
if (ColumnSize != null)
{
builder.Append(ColumnSize.Class(ClassProvider));
}
}
public override string ToString()
{
string text = string.Format("{0}, {1}", ColumnName, (ColumnType == null) ? "null" : ColumnType.ToString());
if (ColumnSize != 0)
{
text += ", " + ColumnSize.ToString();
}
return(text);
}
public override int GetHashCode()
{
int result = ProviderType != null?ProviderType.GetHashCode() : 0;
result = 29 * result + (DataTypeName != null ? DataTypeName.GetHashCode() : 0);
result = 29 * result + NumericPrecision.GetHashCode();
result = 29 * result + NumericScale.GetHashCode();
result = 29 * result + ColumnSize.GetHashCode();
result = 29 * result + IsLong.GetHashCode();
return(result);
}
private void ThenColumnShouldBe(string name, DataType dataType, ColumnSize size, Identity identity, string description)
{
ThenColumnShouldBe(name, dataType, null, null as string, description);
Assert.That(_column.Size, Is.Not.Null);
Assert.That(_column.Size.ToString(), Is.EqualTo(size.ToString()));
Assert.That(_column.Identity.Seed, Is.EqualTo(identity.Seed));
Assert.That(_column.Identity.Increment, Is.EqualTo(identity.Increment));
Assert.That(_column.Identity.NotForReplication, Is.EqualTo(identity.NotForReplication));
Assert.That(_column.Identity.ToString(), Is.EqualTo(identity.ToString()));
var expectedDefinition = $"[{name}] {dataType.ToString().ToLowerInvariant()}{size} {identity}";
Assert.That(_column.GetColumnDefinition(true), Is.EqualTo(expectedDefinition));
}
public ColumnSize MinimumSize()
{
ColumnSize result = ColumnSize.Size1;
foreach (IContentPart p in _Parts)
{
if (p.MinimumSize() > result)
{
result = p.MinimumSize();
}
}
return(result);
}
public void CloneTest()
{
var a = new ColumnSize
{
ColumnName = "ColumnName",
ColumnOrdinal = 1,
Size = 100
};
var b = a.Clone();
Assert.AreNotSame(a, b);
Assert.AreEqual(a.ColumnName, b.ColumnName);
Assert.AreEqual(a.ColumnOrdinal, b.ColumnOrdinal);
Assert.AreEqual(a.Size, b.Size);
}
int GetSize(ColumnSize columnSize) {
if (ColumnSize.Module <= columnSize && columnSize <= ColumnSize.GenericParamConstraint) {
int table = (int)(columnSize - ColumnSize.Module);
return rowCounts[table] > 0xFFFF ? 4 : 2;
}
else if (ColumnSize.TypeDefOrRef <= columnSize && columnSize <= ColumnSize.TypeOrMethodDef) {
CodedToken info;
switch (columnSize) {
case ColumnSize.TypeDefOrRef: info = CodedToken.TypeDefOrRef; break;
case ColumnSize.HasConstant: info = CodedToken.HasConstant; break;
case ColumnSize.HasCustomAttribute: info = CodedToken.HasCustomAttribute; break;
case ColumnSize.HasFieldMarshal: info = CodedToken.HasFieldMarshal; break;
case ColumnSize.HasDeclSecurity: info = CodedToken.HasDeclSecurity; break;
case ColumnSize.MemberRefParent: info = CodedToken.MemberRefParent; break;
case ColumnSize.HasSemantic: info = CodedToken.HasSemantic; break;
case ColumnSize.MethodDefOrRef: info = CodedToken.MethodDefOrRef; break;
case ColumnSize.MemberForwarded: info = CodedToken.MemberForwarded; break;
case ColumnSize.Implementation: info = CodedToken.Implementation; break;
case ColumnSize.CustomAttributeType:info = CodedToken.CustomAttributeType; break;
case ColumnSize.ResolutionScope: info = CodedToken.ResolutionScope; break;
case ColumnSize.TypeOrMethodDef: info = CodedToken.TypeOrMethodDef; break;
default: throw new InvalidOperationException(string.Format("Invalid ColumnSize: {0}", columnSize));
}
uint maxRows = 0;
foreach (var tableType in info.TableTypes) {
var tableRows = rowCounts[(int)tableType];
if (tableRows > maxRows)
maxRows = tableRows;
}
// Can't overflow since maxRows <= 0x00FFFFFF and info.Bits < 8
uint finalRows = maxRows << info.Bits;
return finalRows > 0xFFFF ? 4 : 2;
}
else {
switch (columnSize) {
case ColumnSize.Byte: return 1;
case ColumnSize.Int16: return 2;
case ColumnSize.UInt16: return 2;
case ColumnSize.Int32: return 4;
case ColumnSize.UInt32: return 4;
case ColumnSize.Strings:return bigStrings ? 4 : 2;
case ColumnSize.GUID: return bigGuid ? 4 : 2;
case ColumnSize.Blob: return bigBlob ? 4 : 2;
}
}
throw new InvalidOperationException(string.Format("Invalid ColumnSize: {0}", columnSize));
}
private void ThenColumnShouldBe(string name, DataType dataType, ColumnSize size, Nullable nullable, string defaultExpression, string defaultConstraintName, string description)
{
ThenColumnShouldBe(name, dataType, defaultExpression, defaultConstraintName, description);
var sizeClause = "";
if (size == null)
{
if (dataType.ToString().Contains("Var"))
{
Assert.That(_column.Size, Is.Not.Null);
Assert.That(_column.Size.GetType(), Is.EqualTo(typeof(CharacterLength)));
Assert.That(_column.Size.Value, Is.EqualTo(CharacterLength.Max));
Assert.That(_column.Size.ToString(), Is.EqualTo("(max)"));
sizeClause = "(max)";
}
else
{
Assert.That(_column.Size, Is.Null);
}
}
else
{
Assert.That(_column.Size, Is.Not.Null);
Assert.That(_column.Size.Value, Is.EqualTo(size.Value));
Assert.That(_column.Size.ToString(), Is.EqualTo(size.ToString()));
sizeClause = size.ToString();
}
Assert.That(_column.Nullable, Is.EqualTo(nullable));
var notNullClause = ConvertToNotNullClause(nullable);
var sparseClause = ConvertToSparseClause(nullable);
var defaultClause = ConvertToDefaultClause(defaultExpression, defaultConstraintName, true);
var fileStreamClause = "";
if (_column.FileStream)
{
// ReSharper disable once StringLiteralTypo
fileStreamClause = " filestream";
}
var expectedDefinition =
$"[{name}] {dataType.ToString().ToLowerInvariant()}{sizeClause}{fileStreamClause}{notNullClause}{defaultClause}{sparseClause}";
Assert.That(_column.GetColumnDefinition(true), Is.EqualTo(expectedDefinition));
}
private string GetSqlDataType()
{
// If the column size = 2147483647, set it to a varchar(MAX), else just set it to the size
var columnSizeString = ColumnSize.ToString() == 2147483647.ToString() ? "MAX" : ColumnSize.ToString();
string sqlDataType = DataTypeName.ToUpper();
if (DataTypeName.ToUpper().Contains("CHAR"))
{
sqlDataType = $"{DataTypeName.ToUpper()}({columnSizeString})";
}
else if (DataTypeName.ToUpper().Equals("DECIMAL") || DataTypeName.ToUpper().Equals("NUMERIC"))
{
sqlDataType = $"{DataTypeName.ToUpper()}({NumericPrecision},{NumericScale})";
}
return(sqlDataType);
}
public bool ResizeColumn(int columnIndex, ColumnSize size)
{
// Can't set size when we only have one column, It's always size 12
if (_Columns.Count == 1)
{
return(false);
}
// We have to reserve a size of 1 for each existing column other than the one
// we're attempting to resize. This keeps the columns filling up parent size
int maxSize = (int)_ParentSize - (_Columns.Count - 1);
if ((int)size > maxSize)
{
return(false);
}
// Find the Column
Column col = FindColumn(columnIndex);
if (col == null)
{
return(false);
}
// Save old size for rollback
ColumnSize oldSize = col.Size;
// Resize
col.Size = size;
// Adjust the others so that we're always valid (column sizes = parent size)
bool WasAdjusted = AdjustColumnsToFitParentSize();
// If adjustment failed, rollback
if (WasAdjusted == false)
{
col.Size = oldSize;
return(false);
}
return(true);
}
///// <summary>
///// Bootstrap 5 doesn't have "form-group" any more so all fields are without marging by default.
///// With this I am defining the default marging if it is undefined. This is per bootstrap 5 documentation.
///// </summary>
//private static readonly IFluentSpacing DefaultMargin = Blazorise.Margin.Is3.FromBottom;
#endregion
#region Methods
protected override void BuildClasses(ClassBuilder builder)
{
//if ( Margin == null )
//{
// builder.Append( DefaultMargin.Class( ClassProvider ) );
//}
if (IsFields && ColumnSize == null)
{
builder.Append(ClassProvider.FieldColumn());
}
if (ColumnSize != null)
{
builder.Append(ColumnSize.Class(ClassProvider));
}
base.BuildClasses(builder);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="index">Column index</param>
/// <param name="name">The column name</param>
/// <param name="columnSize">Column size</param>
/// <param name="offset">Offset of column</param>
/// <param name="size">Size of column</param>
public ColumnInfo(int index, string name, ColumnSize columnSize, int offset = 0, int size = 0)
{
if (index < 0)
{
throw new ArgumentOutOfRangeException(nameof(index));
}
if (offset < 0)
{
throw new ArgumentOutOfRangeException(nameof(offset));
}
if (size < 0)
{
throw new ArgumentOutOfRangeException(nameof(size));
}
Index = index;
Name = name ?? throw new ArgumentNullException(nameof(name));
ColumnSize = columnSize;
Offset = offset;
Size = size;
}
protected virtual void ProcessOffsetClass(TagHelperOutput output, ColumnSize size, string breakpoint)
{
if (size == ColumnSize.Undefined)
{
return;
}
var classString = "offset" + breakpoint;
if (size == ColumnSize._)
{
classString += "-0";
}
else
{
classString += "-" + size.ToString("D");
}
output.Attributes.AddClass(classString);
}
public void CopyToTest()
{
var a = new ColumnSize
{
ColumnName = "ColumnName",
ColumnOrdinal = 1,
Size = 100
};
var b = new ColumnSize
{
ColumnName = "ColumnName2",
ColumnOrdinal = 2,
Size = 110
};
a.CopyTo(b);
Assert.AreEqual(a.ColumnName, b.ColumnName);
Assert.AreEqual(a.ColumnOrdinal, b.ColumnOrdinal);
Assert.AreEqual(a.Size, b.Size);
Assert.AreEqual(a.Size, b.Size);
}
public void DeserializeFromXml(string xml)
{
XmlDocument xdoc = new XmlDocument();
xdoc.LoadXml(xml);
XmlNode sizeNode = xdoc.SelectSingleNode("/part/size");
{
string sizetest = sizeNode.InnerText;
ColumnSize sizeout = ColumnSize.Size1;
if (Enum.TryParse <ColumnSize>(sizetest, out sizeout))
{
this.Size = sizeout;
}
}
XmlNode gutterNode = xdoc.SelectSingleNode("/part/nogutter");
if (gutterNode != null)
{
bool gutterout = false;
if (bool.TryParse(gutterNode.InnerText, out gutterout))
{
this.NoGutter = gutterout;
}
}
this.Parts.Clear();
XmlNodeList partNodes = xdoc.SelectNodes("/part/parts/part");
if (partNodes != null)
{
foreach (XmlNode node in partNodes)
{
ImportPart(node.OuterXml);
}
}
}
public static void SaveColumnSizes(Grid grid)
{
Logger.Debug("Storing column values for grid ", LogSource.Layout, grid.Name);
for (int i = 0; i < grid.ColumnDefinitions.Count; i++)
{
string key = String.Format("/Settings/GridColumnSize/{0}/{1}", grid.Name, i);
Logger.Debug("\tColumn {0} has Width {1}", LogSource.Layout, i, grid.ColumnDefinitions[i].Width);
ColumnSize size = new ColumnSize { Width = grid.ColumnDefinitions[i].Width.ToString() };
if (grid.ColumnDefinitions[i].Width.Value == 0)
{
size.IsCollapsed = true;
size.PreviousWidth = GetPreviousGridLength(grid.ColumnDefinitions[i]).ToString();
}
// Watch the ToString call here, if you save a reference to the Width property, the value
// will default to Auto during application shutdown because another Save call is triggered.
ClientState.Current.Context.SaveSetting(key, size);
}
}
int GetSize(ColumnSize columnSize, IList <uint> rowCounts)
{
if (ColumnSize.Module <= columnSize && columnSize <= ColumnSize.CustomDebugInformation)
{
int table = (int)(columnSize - ColumnSize.Module);
uint count = table >= rowCounts.Count ? 0 : rowCounts[table];
return(forceAllBig || count > 0xFFFF ? 4 : 2);
}
else if (ColumnSize.TypeDefOrRef <= columnSize && columnSize <= ColumnSize.HasCustomDebugInformation)
{
var info = columnSize switch {
ColumnSize.TypeDefOrRef => CodedToken.TypeDefOrRef,
ColumnSize.HasConstant => CodedToken.HasConstant,
ColumnSize.HasCustomAttribute => CodedToken.HasCustomAttribute,
ColumnSize.HasFieldMarshal => CodedToken.HasFieldMarshal,
ColumnSize.HasDeclSecurity => CodedToken.HasDeclSecurity,
ColumnSize.MemberRefParent => CodedToken.MemberRefParent,
ColumnSize.HasSemantic => CodedToken.HasSemantic,
ColumnSize.MethodDefOrRef => CodedToken.MethodDefOrRef,
ColumnSize.MemberForwarded => CodedToken.MemberForwarded,
ColumnSize.Implementation => CodedToken.Implementation,
ColumnSize.CustomAttributeType => CodedToken.CustomAttributeType,
ColumnSize.ResolutionScope => CodedToken.ResolutionScope,
ColumnSize.TypeOrMethodDef => CodedToken.TypeOrMethodDef,
ColumnSize.HasCustomDebugInformation => CodedToken.HasCustomDebugInformation,
_ => throw new InvalidOperationException($"Invalid ColumnSize: {columnSize}"),
};
uint maxRows = 0;
foreach (var tableType in info.TableTypes)
{
int index = (int)tableType;
var tableRows = index >= rowCounts.Count ? 0 : rowCounts[index];
if (tableRows > maxRows)
{
maxRows = tableRows;
}
}
// Can't overflow since maxRows <= 0x00FFFFFF and info.Bits < 8
uint finalRows = maxRows << info.Bits;
return(forceAllBig || finalRows > 0xFFFF ? 4 : 2);
}
else
{
switch (columnSize)
{
case ColumnSize.Byte: return(1);
case ColumnSize.Int16: return(2);
case ColumnSize.UInt16: return(2);
case ColumnSize.Int32: return(4);
case ColumnSize.UInt32: return(4);
case ColumnSize.Strings: return(forceAllBig || bigStrings ? 4 : 2);
case ColumnSize.GUID: return(forceAllBig || bigGuid ? 4 : 2);
case ColumnSize.Blob: return(forceAllBig || bigBlob ? 4 : 2);
}
}
throw new InvalidOperationException($"Invalid ColumnSize: {columnSize}");
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="index">Column index</param>
/// <param name="name">The column name</param>
/// <param name="columnSize">Column size</param>
public ColumnInfo(byte index, string name, ColumnSize columnSize) {
this.index = index;
this.name = name;
this.columnSize = columnSize;
}
int GetSize(ColumnSize columnSize)
{
Debug2.Assert(!(rowCounts is null));
if (ColumnSize.Module <= columnSize && columnSize <= ColumnSize.CustomDebugInformation)
{
int table = (int)(columnSize - ColumnSize.Module);
uint count = table >= rowCounts.Length ? 0 : rowCounts[table];
return(count > 0xFFFF ? 4 : 2);
}
else if (ColumnSize.TypeDefOrRef <= columnSize && columnSize <= ColumnSize.HasCustomDebugInformation)
{
CodedToken info;
switch (columnSize)
{
case ColumnSize.TypeDefOrRef: info = CodedToken.TypeDefOrRef; break;
case ColumnSize.HasConstant: info = CodedToken.HasConstant; break;
case ColumnSize.HasCustomAttribute: info = CodedToken.HasCustomAttribute; break;
case ColumnSize.HasFieldMarshal: info = CodedToken.HasFieldMarshal; break;
case ColumnSize.HasDeclSecurity: info = CodedToken.HasDeclSecurity; break;
case ColumnSize.MemberRefParent: info = CodedToken.MemberRefParent; break;
case ColumnSize.HasSemantic: info = CodedToken.HasSemantic; break;
case ColumnSize.MethodDefOrRef: info = CodedToken.MethodDefOrRef; break;
case ColumnSize.MemberForwarded: info = CodedToken.MemberForwarded; break;
case ColumnSize.Implementation: info = CodedToken.Implementation; break;
case ColumnSize.CustomAttributeType: info = CodedToken.CustomAttributeType; break;
case ColumnSize.ResolutionScope: info = CodedToken.ResolutionScope; break;
case ColumnSize.TypeOrMethodDef: info = CodedToken.TypeOrMethodDef; break;
case ColumnSize.HasCustomDebugInformation: info = CodedToken.HasCustomDebugInformation; break;
default: throw new InvalidOperationException($"Invalid ColumnSize: {columnSize}");
}
uint maxRows = 0;
foreach (var tableType in info.TableTypes)
{
int index = (int)tableType;
var tableRows = index >= rowCounts.Length ? 0 : rowCounts[index];
if (tableRows > maxRows)
{
maxRows = tableRows;
}
}
// Can't overflow since maxRows <= 0x00FFFFFF and info.Bits < 8
uint finalRows = maxRows << info.Bits;
return(finalRows > 0xFFFF ? 4 : 2);
}
else
{
switch (columnSize)
{
case ColumnSize.Byte: return(1);
case ColumnSize.Int16: return(2);
case ColumnSize.UInt16: return(2);
case ColumnSize.Int32: return(4);
case ColumnSize.UInt32: return(4);
case ColumnSize.Strings: return(bigStrings ? 4 : 2);
case ColumnSize.GUID: return(bigGuid ? 4 : 2);
case ColumnSize.Blob: return(bigBlob ? 4 : 2);
}
}
throw new InvalidOperationException($"Invalid ColumnSize: {columnSize}");
}
public bool ResizeColumn(int columnIndex, ColumnSize size)
{
// Can't set size when we only have one column, It's always size 12
if (_Columns.Count == 1)
{
return false;
}
// We have to reserve a size of 1 for each existing column other than the one
// we're attempting to resize. This keeps the columns filling up parent size
int maxSize = (int)_ParentSize - (_Columns.Count - 1);
if ((int)size > maxSize) return false;
// Find the Column
Column col = FindColumn(columnIndex);
if (col == null) return false;
// Save old size for rollback
ColumnSize oldSize = col.Size;
// Resize
col.Size = size;
// Adjust the others so that we're always valid (column sizes = parent size)
bool WasAdjusted = AdjustColumnsToFitParentSize();
// If adjustment failed, rollback
if (WasAdjusted == false)
{
col.Size = oldSize;
return false;
}
return true;
}
private void ThenColumnShouldBe(string name, DataType dataType, ColumnSize size, bool filestream,
Nullable nullable, string defaultExpression, string defaultConstraintName, string description)
{
Assert.That(_column.FileStream, Is.EqualTo(filestream));
ThenColumnShouldBe(name, dataType, size, nullable, defaultExpression, defaultConstraintName, description);
}
private int GetSize(ColumnSize columnSize)
{
if (ColumnSize.Module <= columnSize && columnSize <= ColumnSize.GenericParamConstraint)
{
int table = columnSize - ColumnSize.Module;
return(rowCounts[table] > 0xFFFF ? 4 : 2);
}
if (ColumnSize.TypeDefOrRef <= columnSize && columnSize <= ColumnSize.TypeOrMethodDef)
{
CodedToken info;
switch (columnSize)
{
case ColumnSize.TypeDefOrRef:
info = CodedToken.TypeDefOrRef;
break;
case ColumnSize.HasConstant:
info = CodedToken.HasConstant;
break;
case ColumnSize.HasCustomAttribute:
info = CodedToken.HasCustomAttribute;
break;
case ColumnSize.HasFieldMarshal:
info = CodedToken.HasFieldMarshal;
break;
case ColumnSize.HasDeclSecurity:
info = CodedToken.HasDeclSecurity;
break;
case ColumnSize.MemberRefParent:
info = CodedToken.MemberRefParent;
break;
case ColumnSize.HasSemantic:
info = CodedToken.HasSemantic;
break;
case ColumnSize.MethodDefOrRef:
info = CodedToken.MethodDefOrRef;
break;
case ColumnSize.MemberForwarded:
info = CodedToken.MemberForwarded;
break;
case ColumnSize.Implementation:
info = CodedToken.Implementation;
break;
case ColumnSize.CustomAttributeType:
info = CodedToken.CustomAttributeType;
break;
case ColumnSize.ResolutionScope:
info = CodedToken.ResolutionScope;
break;
case ColumnSize.TypeOrMethodDef:
info = CodedToken.TypeOrMethodDef;
break;
default: throw new InvalidOperationException(string.Format("Invalid ColumnSize: {0}", columnSize));
}
uint maxRows = 0;
foreach (var tableType in info.TableTypes)
{
var tableRows = rowCounts[(int)tableType];
if (tableRows > maxRows)
{
maxRows = tableRows;
}
}
// Can't overflow since maxRows <= 0x00FFFFFF and info.Bits < 8
var finalRows = maxRows << info.Bits;
return(finalRows > 0xFFFF ? 4 : 2);
}
switch (columnSize)
{
case ColumnSize.Byte: return(1);
case ColumnSize.Int16: return(2);
case ColumnSize.UInt16: return(2);
case ColumnSize.Int32: return(4);
case ColumnSize.UInt32: return(4);
case ColumnSize.Strings: return(bigStrings ? 4 : 2);
case ColumnSize.GUID: return(bigGuid ? 4 : 2);
case ColumnSize.Blob: return(bigBlob ? 4 : 2);
}
throw new InvalidOperationException(string.Format("Invalid ColumnSize: {0}", columnSize));
}
static ContextMenuStrip GetContextMenu(MDTableHeapView view, MDRowModel row, IMetaData metadata, ColumnSize size)
{
ContextMenuStrip ctxMenu;
if (ColumnSize.Module <= size && size <= ColumnSize.GenericParamConstraint)
{
Table targetTable = (Table)(size - ColumnSize.Module);
ctxMenu = CreateMDTokenContextMenu(view, targetTable);
}
else if (ColumnSize.TypeDefOrRef <= size && size <= ColumnSize.TypeOrMethodDef)
{
CodedToken info;
switch (size)
{
case ColumnSize.TypeDefOrRef:
info = CodedToken.TypeDefOrRef;
break;
case ColumnSize.HasConstant:
info = CodedToken.HasConstant;
break;
case ColumnSize.HasCustomAttribute:
info = CodedToken.HasCustomAttribute;
break;
case ColumnSize.HasFieldMarshal:
info = CodedToken.HasFieldMarshal;
break;
case ColumnSize.HasDeclSecurity:
info = CodedToken.HasDeclSecurity;
break;
case ColumnSize.MemberRefParent:
info = CodedToken.MemberRefParent;
break;
case ColumnSize.HasSemantic:
info = CodedToken.HasSemantic;
break;
case ColumnSize.MethodDefOrRef:
info = CodedToken.MethodDefOrRef;
break;
case ColumnSize.MemberForwarded:
info = CodedToken.MemberForwarded;
break;
case ColumnSize.Implementation:
info = CodedToken.Implementation;
break;
case ColumnSize.CustomAttributeType:
info = CodedToken.CustomAttributeType;
break;
case ColumnSize.ResolutionScope:
info = CodedToken.ResolutionScope;
break;
case ColumnSize.TypeOrMethodDef:
info = CodedToken.TypeOrMethodDef;
break;
default:
throw new InvalidOperationException(string.Format("Invalid ColumnSize: {0}", size));
}
ctxMenu = CreateCodedTokenContextMenu(view, info);
}
else if (size == ColumnSize.Strings)
{
ctxMenu = CreateStreamContextMenu(view, metadata, metadata.StringsStream);
}
else if (size == ColumnSize.Blob)
{
ctxMenu = CreateStreamContextMenu(view, metadata, metadata.BlobStream);
}
else if (size == ColumnSize.GUID)
{
ctxMenu = CreateStreamContextMenu(view, metadata, metadata.GuidStream);
}
else
{
ctxMenu = null;
}
return(ctxMenu);
}
static ContextMenuStrip GetContextMenu(MDTableHeapView view, MDRowModel row, IMetaData metadata, ColumnSize size) {
ContextMenuStrip ctxMenu;
if (ColumnSize.Module <= size && size <= ColumnSize.GenericParamConstraint) {
Table targetTable = (Table)(size - ColumnSize.Module);
ctxMenu = CreateMDTokenContextMenu(view, targetTable);
}
else if (ColumnSize.TypeDefOrRef <= size && size <= ColumnSize.TypeOrMethodDef) {
CodedToken info;
switch (size) {
case ColumnSize.TypeDefOrRef:
info = CodedToken.TypeDefOrRef;
break;
case ColumnSize.HasConstant:
info = CodedToken.HasConstant;
break;
case ColumnSize.HasCustomAttribute:
info = CodedToken.HasCustomAttribute;
break;
case ColumnSize.HasFieldMarshal:
info = CodedToken.HasFieldMarshal;
break;
case ColumnSize.HasDeclSecurity:
info = CodedToken.HasDeclSecurity;
break;
case ColumnSize.MemberRefParent:
info = CodedToken.MemberRefParent;
break;
case ColumnSize.HasSemantic:
info = CodedToken.HasSemantic;
break;
case ColumnSize.MethodDefOrRef:
info = CodedToken.MethodDefOrRef;
break;
case ColumnSize.MemberForwarded:
info = CodedToken.MemberForwarded;
break;
case ColumnSize.Implementation:
info = CodedToken.Implementation;
break;
case ColumnSize.CustomAttributeType:
info = CodedToken.CustomAttributeType;
break;
case ColumnSize.ResolutionScope:
info = CodedToken.ResolutionScope;
break;
case ColumnSize.TypeOrMethodDef:
info = CodedToken.TypeOrMethodDef;
break;
default:
throw new InvalidOperationException(string.Format("Invalid ColumnSize: {0}", size));
}
ctxMenu = CreateCodedTokenContextMenu(view, info);
}
else if (size == ColumnSize.Strings) {
ctxMenu = CreateStreamContextMenu(view, metadata, metadata.StringsStream);
}
else if (size == ColumnSize.Blob) {
ctxMenu = CreateStreamContextMenu(view, metadata, metadata.BlobStream);
}
else if (size == ColumnSize.GUID) {
ctxMenu = CreateStreamContextMenu(view, metadata, metadata.GuidStream);
}
else
ctxMenu = null;
return ctxMenu;
}
void UpdateColumnWidths(ColumnSize ColumnSize, OLVColumn Column)
{
if (Column.Width != ColumnSize.Width) Column.Width = ColumnSize.Width;
if (Column.MinimumWidth != ColumnSize.MinimumWidth) Column.MinimumWidth = ColumnSize.MinimumWidth;
if (Column.MaximumWidth != ColumnSize.MaximumWidth) Column.MaximumWidth = ColumnSize.MaximumWidth;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="index">Column index</param>
/// <param name="name">The column name</param>
/// <param name="columnSize">Column size</param>
public ColumnInfo(byte index, string name, ColumnSize columnSize)
{
this.index = index;
this.name = name;
this.columnSize = columnSize;
}
private void TestColumnSizes(IColumn parent, ColumnSize expected1, ColumnSize expected2)
{
ColumnContainer target = new ColumnContainer(parent);
Assert.AreEqual(2, target.Columns.Count, "Container should start with two columns");
Assert.AreEqual(expected1, target.Columns[0].Size, "Column 1 was not the correct size for start of " + parent.ToString());
Assert.AreEqual(expected2, target.Columns[1].Size, "Column 2 was not the correct size for start of " + parent.ToString());
}
