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()); }
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; }