private DataGridLength(double value, DataGridLengthUnitType type) { if (double.IsNaN(value)) { throw DataGridError.DataGrid.ValueCannotBeSetToNAN("value"); } if (double.IsInfinity(value)) { throw DataGridError.DataGrid.ValueCannotBeSetToInfinity("value"); } if (value < 0) { throw DataGridError.DataGrid.ValueMustBeGreaterThanOrEqualTo("value", "value", 0); } if (type != DataGridLengthUnitType.Auto && type != DataGridLengthUnitType.SizeToCells && type != DataGridLengthUnitType.SizeToHeader && // type != DataGridLengthUnitType.Pixel) { throw DataGridError.DataGridLength.InvalidUnitType("type"); } _unitValue = (type == DataGridLengthUnitType.Auto) ? DATAGRIDLENGTH_DefaultValue : value; _unitType = type; }
public ColumnInformation(DataGridColumn column) { Header = column.Header; if (!(column is DataGridTemplateColumn)) { if (column is DataGridComboBoxColumn) { PropertyPath = column.SortMemberPath; } else { PropertyPath = ((Binding)((DataGridBoundColumn)column).Binding).Path.Path; } } else { PropertyPath = column.SortMemberPath; } WidthValue = column.Width.DisplayValue; WidthType = column.Width.UnitType; SortDirection = column.SortDirection; DisplayIndex = column.DisplayIndex; SortMemberPath = column.SortMemberPath; IsVisible = column.IsVisible; }
private void loadPreferences() { userLimit.Text = Properties.Settings.Default.prLimit.ToString(); cbAutoApply.IsChecked = Properties.Settings.Default.prAutoApply; checkAutoselect.IsChecked = Properties.Settings.Default.prAutoRefresh; if (Directory.Exists(Properties.Settings.Default.prWorkspace)) { openFileDialog1.InitialDirectory = Properties.Settings.Default.prWorkspace; saveFileDialog1.InitialDirectory = Properties.Settings.Default.prWorkspace; } switch (Properties.Settings.Default.prFitMethod) { case 0: dataGridLengthUnit = DataGridLengthUnitType.Auto; break; case 1: dataGridLengthUnit = DataGridLengthUnitType.SizeToHeader; break; case 2: dataGridLengthUnit = DataGridLengthUnitType.SizeToCells; break; } }
private void SetAllColumnWidths(DataGrid source, DataGridLengthUnitType lengthType, double minWidth) { for (int i = 0; i < source.Columns.Count; i++) { source.Columns[i].Width = new DataGridLength(1.0, lengthType); source.Columns[i].MinWidth = minWidth; } }
// Token: 0x06004921 RID: 18721 RVA: 0x0014B8A4 File Offset: 0x00149AA4 private static DataGridLength ConvertFromString(string s, CultureInfo cultureInfo) { string text = s.Trim().ToLowerInvariant(); for (int i = 0; i < 3; i++) { string b = DataGridLengthConverter._unitStrings[i]; if (text == b) { return(new DataGridLength(1.0, (DataGridLengthUnitType)i)); } } double value = 0.0; DataGridLengthUnitType dataGridLengthUnitType = DataGridLengthUnitType.Pixel; int length = text.Length; int num = 0; double num2 = 1.0; int num3 = DataGridLengthConverter._unitStrings.Length; for (int j = 3; j < num3; j++) { string text2 = DataGridLengthConverter._unitStrings[j]; if (text.EndsWith(text2, StringComparison.Ordinal)) { num = text2.Length; dataGridLengthUnitType = (DataGridLengthUnitType)j; break; } } if (num == 0) { num3 = DataGridLengthConverter._nonStandardUnitStrings.Length; for (int k = 0; k < num3; k++) { string text3 = DataGridLengthConverter._nonStandardUnitStrings[k]; if (text.EndsWith(text3, StringComparison.Ordinal)) { num = text3.Length; num2 = DataGridLengthConverter._pixelUnitFactors[k]; break; } } } if (length == num) { if (dataGridLengthUnitType == DataGridLengthUnitType.Star) { value = 1.0; } } else { string value2 = text.Substring(0, length - num); value = Convert.ToDouble(value2, cultureInfo) * num2; } return(new DataGridLength(value, dataGridLengthUnitType)); }
private static List <ColumnInfo> LoadColumns(XmlElement parent) { List <ColumnInfo> CInfo = new List <ColumnInfo>(); foreach (XmlElement xNode in parent) { string ColumnHeader = String.Empty; Visibility visibility = Visibility.Visible; int DisplayIndex = 0; double WidthValue = 40.0; DataGridLengthUnitType WidthType = DataGridLengthUnitType.Auto; Style ColStyle = new Style(); string StringFormat = null; foreach (XmlNode childNode in xNode.ChildNodes) { switch (childNode.Name) { case "ColumnHeader": ColumnHeader = childNode.InnerText; break; case "Visibility": Enum.TryParse(childNode.InnerText, out visibility); break; case "DisplayIndex": Int32.TryParse(childNode.InnerText, out DisplayIndex); break; case "WidthValue": Double.TryParse(childNode.InnerText, out WidthValue); break; case "WidthType": Enum.TryParse(childNode.InnerText, out WidthType); break; case "Style": ColStyle = LoadStyle(childNode); break; case "StringFormat": StringFormat = childNode.InnerText; break; } } if (ColumnHeader == String.Empty) { break; } ColumnInfo column = new ColumnInfo(visibility, DisplayIndex, WidthValue, WidthType, ColumnHeader, ColStyle, StringFormat); CInfo.Add(column); } return(CInfo); }
public ColumnInfo(DataGridColumn column) { Header = column.Header; PropertyPath = ((Binding)((DataGridBoundColumn)column).Binding).Path.Path; WidthValue = column.Width.DisplayValue; WidthType = column.Width.UnitType; SortDirection = column.SortDirection; DisplayIndex = column.DisplayIndex; }
public DataGridLengthUnitType WidthType; // Width type (Pixel, Star, Auto...) public ColumnInfo(DataGridColumn column) { Header = column.Header; PropertyPath = column.SortMemberPath; WidthValue = column.Width.DisplayValue; WidthType = column.Width.UnitType; Visibility = column.Visibility; SortDirection = column.SortDirection; DisplayIndex = column.DisplayIndex; }
public static void CreateColumn(DataGrid datagrid, string header, int width = 1, DataGridLengthUnitType type = DataGridLengthUnitType.Star) { var c = new DataGridTextColumn() { Header = header, Binding = new Binding(header), Width = new DataGridLength(width, type) }; datagrid.Columns.Add(c); }
public DataGridTextColumn AddNewTextColumn(string header, string binding, bool isVisible = false, BindingMode mode = BindingMode.OneWay, bool notifyOnTargetUpdated = true, double width = 1.0, DataGridLengthUnitType widthType = DataGridLengthUnitType.Star) { var textColumn = DataGridTextColumn(header, binding, isVisible, mode, notifyOnTargetUpdated, width, widthType); Columns.Add(textColumn); return(textColumn); }
public ColumnInfo(Visibility vis, int dispIdx, double widthVal, DataGridLengthUnitType widthT, string columnHeader, Style colStyle, string colStringFormat) { WidthValue = widthVal; WidthType = widthT; DisplayIndex = dispIdx; Visibility = vis; ColumnHeader = columnHeader; ColStyle = colStyle; StringFormat = colStringFormat; }
public static void LoadDataGridDimensions(this DataGrid grid, string dimensionPrefix) { for (int i = 0; i < grid.Columns.Count; i++) { string dimensionName = $"{dimensionPrefix}_Col{i}"; var colDimensions = CMDataProvider.DataStore.Value.CMDimensionInfos.Value.Get_ForName(dimensionName); if (colDimensions != null) { // Top stores the DataGridLengthUnitType DataGridLengthUnitType glut = (DataGridLengthUnitType)colDimensions.Top; grid.Columns[i].Width = new DataGridLength(colDimensions.Width, glut); } } }
//{ // if (dg.ColumnHeaderStyle == null) // dg.ColumnHeaderStyle = new Style(typeof(DataGridColumnHeader)); // CreateColumnHeaderStyle(dg, colWidthType); //} private static Style CreateColumnHeaderStyle(DataGrid dg, DataGridLengthUnitType colWidthType) { var colHdrStyle = new Style(typeof(DataGridColumnHeader), dg.ColumnHeaderStyle); var ctxMenuKey = $"ctxMenu_{Guid.NewGuid().ToString("N")}"; var ctxMenu = CreateContextMenu(dg, colWidthType); colHdrStyle.Resources.Add(ctxMenuKey, ctxMenu); colHdrStyle.Setters.Add(ContextMenuSetter(ctxMenu)); colHdrStyle.Setters.Add(HorizontalAlignmentSetter); //colHdrStyle.Setters.Add(FontWeightSetter); colHdrStyle.Setters.Add(FontStyleSetter); colHdrStyle.Setters.Add(ForegroundSetter); colHdrStyle.Setters.Add(PaddingSetter); return(colHdrStyle); }
private static ContextMenu CreateContextMenu(DataGrid dg, DataGridLengthUnitType colWidthType) { var cm = new ContextMenu(); foreach (var col in dg.Columns) { var mnu = new MenuItem(); mnu.Header = col.Header; mnu.IsCheckable = true; mnu.IsChecked = col.Visibility == Visibility.Visible; mnu.Click += (s, e) => col.Visibility = mnu.IsChecked ? Visibility.Visible : Visibility.Collapsed; cm.Items.Add(mnu); col.Width = new DataGridLength(0, colWidthType); } return(cm); }
private void SetLengthValue() { DataGridLengthUnitType unitType = (DataGridLengthUnitType)_comboBox.SelectedItem; switch (unitType) { case DataGridLengthUnitType.Auto: // To get around grow only in the designer, set the width to a small value this.SetValueNoCallback(DataGridLengthEditorGrid.ValueProperty, new SSWC.DataGridLength(1)); this.Value = SSWC.DataGridLength.Auto; break; case DataGridLengthUnitType.SizeToCells: // To get around grow only in the designer, set the width to a small value this.SetValueNoCallback(DataGridLengthEditorGrid.ValueProperty, new SSWC.DataGridLength(1)); this.Value = SSWC.DataGridLength.SizeToCells; break; case DataGridLengthUnitType.SizeToHeader: // To get around grow only in the designer, set the width to a small value this.SetValueNoCallback(DataGridLengthEditorGrid.ValueProperty, new SSWC.DataGridLength(1)); this.Value = SSWC.DataGridLength.SizeToHeader; break; default: // Treat it as a Pixel length double pixels; if (double.TryParse(_textBox.Text, out pixels)) { // Store the last good pixel value _lastValidPixelWidth = pixels; this.Value = new SSWC.DataGridLength(pixels); } else { // The user entered something bad so revert to the last good value _textBox.Text = _lastValidPixelWidth.ToString(CultureInfo.InvariantCulture); // The Text binding does not update the Value in this case so set it explicitly this.Value = new SSWC.DataGridLength(_lastValidPixelWidth); } break; } }
/// <summary> /// Initializes to a specified value and unit. /// </summary> /// <param name="value">The value to hold.</param> /// <param name="type">The unit of <c>value</c>.</param> /// <param name="desiredValue"></param> /// <param name="displayValue"></param> /// <remarks> /// <c>value</c> is ignored unless <c>type</c> is /// <c>DataGridLengthUnitType.Pixel</c> or /// <c>DataGridLengthUnitType.Star</c> /// </remarks> /// <exception cref="ArgumentException"> /// If <c>value</c> parameter is <c>double.NaN</c> /// or <c>value</c> parameter is <c>double.NegativeInfinity</c> /// or <c>value</c> parameter is <c>double.PositiveInfinity</c>. /// </exception> public DataGridLength(double value, DataGridLengthUnitType type, double desiredValue, double displayValue) { if (DoubleUtil.IsNaN(value) || Double.IsInfinity(value)) { throw new ArgumentException( SR.Get(SRID.DataGridLength_Infinity), "value"); // value = 100; } if (type != DataGridLengthUnitType.Auto && type != DataGridLengthUnitType.Pixel && type != DataGridLengthUnitType.Star && type != DataGridLengthUnitType.SizeToCells && type != DataGridLengthUnitType.SizeToHeader) { throw new ArgumentException( SR.Get(SRID.DataGridLength_InvalidType), "type"); } if (Double.IsInfinity(desiredValue)) { throw new ArgumentException( SR.Get(SRID.DataGridLength_Infinity), "desiredValue"); } if (Double.IsInfinity(displayValue)) { throw new ArgumentException( SR.Get(SRID.DataGridLength_Infinity), "displayValue"); } _unitValue = (type == DataGridLengthUnitType.Auto) ? AutoValue : value; _unitType = type; _desiredValue = desiredValue; _displayValue = displayValue; }
/// <summary>Initializes a new instance of the <see cref="T:System.Windows.Controls.DataGridLength" /> class with the specified value, unit, desired value, and display value.</summary> /// <param name="value">The requested size of the element.</param> /// <param name="type">The type that is used to determine how the size of the element is calculated.</param> /// <param name="desiredValue">The calculated size needed for the element.</param> /// <param name="displayValue">The allocated size for the element.</param> /// <exception cref="T:System.ArgumentException"> /// <paramref name="value" /> is <see cref="F:System.Double.NaN" />, <see cref="F:System.Double.NegativeInfinity" />, or <see cref="F:System.Double.PositiveInfinity" />.-or- /// <paramref name="type" /> is not <see cref="F:System.Windows.Controls.DataGridLengthUnitType.Auto" />, <see cref="F:System.Windows.Controls.DataGridLengthUnitType.Pixel" />, <see cref="F:System.Windows.Controls.DataGridLengthUnitType.Star" />, <see cref="F:System.Windows.Controls.DataGridLengthUnitType.SizeToCells" />, or <see cref="F:System.Windows.Controls.DataGridLengthUnitType.SizeToHeader" />.-or- /// <paramref name="desiredValue" /> is <see cref="F:System.Double.NegativeInfinity" /> or <see cref="F:System.Double.PositiveInfinity" />.-or- /// <paramref name="displayValue" /> is <see cref="F:System.Double.NegativeInfinity" /> or <see cref="F:System.Double.PositiveInfinity" />.</exception> // Token: 0x06004907 RID: 18695 RVA: 0x0014B360 File Offset: 0x00149560 public DataGridLength(double value, DataGridLengthUnitType type, double desiredValue, double displayValue) { if (DoubleUtil.IsNaN(value) || double.IsInfinity(value)) { throw new ArgumentException(SR.Get("DataGridLength_Infinity"), "value"); } if (type != DataGridLengthUnitType.Auto && type != DataGridLengthUnitType.Pixel && type != DataGridLengthUnitType.Star && type != DataGridLengthUnitType.SizeToCells && type != DataGridLengthUnitType.SizeToHeader) { throw new ArgumentException(SR.Get("DataGridLength_InvalidType"), "type"); } if (double.IsInfinity(desiredValue)) { throw new ArgumentException(SR.Get("DataGridLength_Infinity"), "desiredValue"); } if (double.IsInfinity(displayValue)) { throw new ArgumentException(SR.Get("DataGridLength_Infinity"), "displayValue"); } this._unitValue = ((type == DataGridLengthUnitType.Auto) ? 1.0 : value); this._unitType = type; this._desiredValue = desiredValue; this._displayValue = displayValue; }
/// <summary> /// Helper method which coerces the DesiredValue or DisplayValue /// of the width. /// </summary> private static double CoerceDesiredOrDisplayWidthValue(double widthValue, double memberValue, DataGridLengthUnitType type) { if (DoubleUtil.IsNaN(memberValue)) { if (type == DataGridLengthUnitType.Pixel) { memberValue = widthValue; } else if (type == DataGridLengthUnitType.Auto || type == DataGridLengthUnitType.SizeToCells || type == DataGridLengthUnitType.SizeToHeader) { memberValue = 0d; } } return memberValue; }
/// <summary> /// Initializes to a specified value and unit. /// </summary> /// <param name="value">The value to hold.</param> /// <param name="type">The unit of <c>value</c>.</param> /// <remarks> /// <c>value</c> is ignored unless <c>type</c> is /// <c>DataGridLengthUnitType.Pixel</c> or /// <c>DataGridLengthUnitType.Star</c> /// </remarks> /// <exception cref="ArgumentException"> /// If <c>value</c> parameter is <c>double.NaN</c> /// or <c>value</c> parameter is <c>double.NegativeInfinity</c> /// or <c>value</c> parameter is <c>double.PositiveInfinity</c>. /// </exception> public DataGridLength(double value, DataGridLengthUnitType type) : this(value, type, (type == DataGridLengthUnitType.Pixel ? value : Double.NaN), (type == DataGridLengthUnitType.Pixel ? value : Double.NaN)) { }
private static DataGridTextColumn DataGridTextColumn(string header, string binding, bool isVisible, BindingMode mode, bool notifyOnTargetUpdated, double width, DataGridLengthUnitType widthType) { return(new DataGridTextColumn { Header = header, Width = new DataGridLength(width, widthType), Visibility = isVisible ? Visibility.Visible : Visibility.Hidden, Binding = new Binding(binding) { Mode = mode, NotifyOnTargetUpdated = notifyOnTargetUpdated, }, IsReadOnly = false }); }
/// <summary>Initializes a new instance of the <see cref="T:System.Windows.Controls.DataGridLength" /> class with a specified value and unit.</summary> /// <param name="value">The requested size of the element.</param> /// <param name="type">The type that is used to determine how the size of the element is calculated.</param> /// <exception cref="T:System.ArgumentException"> /// <paramref name="value" /> is <see cref="F:System.Double.NaN" />, <see cref="F:System.Double.NegativeInfinity" />, or <see cref="F:System.Double.PositiveInfinity" />.-or- /// <paramref name="type" /> is not <see cref="F:System.Windows.Controls.DataGridLengthUnitType.Auto" />, <see cref="F:System.Windows.Controls.DataGridLengthUnitType.Pixel" />, <see cref="F:System.Windows.Controls.DataGridLengthUnitType.Star" />, <see cref="F:System.Windows.Controls.DataGridLengthUnitType.SizeToCells" />, or <see cref="F:System.Windows.Controls.DataGridLengthUnitType.SizeToHeader" />.</exception> // Token: 0x06004906 RID: 18694 RVA: 0x0014B335 File Offset: 0x00149535 public DataGridLength(double value, DataGridLengthUnitType type) { this = new DataGridLength(value, type, (type == DataGridLengthUnitType.Pixel) ? value : double.NaN, (type == DataGridLengthUnitType.Pixel) ? value : double.NaN); }
/// <summary> /// Parses a DataGridLength from a string given the CultureInfo. /// </summary> /// <param name="s">String to parse from.</param> /// <param name="cultureInfo">Culture Info.</param> /// <returns>Newly created DataGridLength instance.</returns> /// <remarks> /// Formats: /// "[value][unit]" /// [value] is a double /// [unit] is a string in DataGridLength._unitTypes connected to a DataGridLengthUnitType /// "[value]" /// As above, but the DataGridLengthUnitType is assumed to be DataGridLengthUnitType.Pixel /// "[unit]" /// As above, but the value is assumed to be 1.0 /// This is only acceptable for a subset of DataGridLengthUnitType: Auto /// </remarks> private static DataGridLength ConvertFromString(string s, CultureInfo cultureInfo) { string goodString = s.Trim().ToLowerInvariant(); // Check if the string matches any of the descriptive unit types. // In these cases, there is no need to parse a value. for (int i = 0; i < NumDescriptiveUnits; i++) { string unitString = _unitStrings[i]; if (goodString == unitString) { return(new DataGridLength(1.0, (DataGridLengthUnitType)i)); } } double value = 0.0; DataGridLengthUnitType unit = DataGridLengthUnitType.Pixel; int strLen = goodString.Length; int strLenUnit = 0; double unitFactor = 1.0; // Check if the string contains a non-descriptive unit at the end. int numUnitStrings = _unitStrings.Length; for (int i = NumDescriptiveUnits; i < numUnitStrings; i++) { string unitString = _unitStrings[i]; // Note: This is NOT a culture specific comparison. // This is by design: we want the same unit string table to work across all cultures. if (goodString.EndsWith(unitString, StringComparison.Ordinal)) { strLenUnit = unitString.Length; unit = (DataGridLengthUnitType)i; break; } } // Couldn't match a standard unit type, try a non-standard unit type. if (strLenUnit == 0) { numUnitStrings = _nonStandardUnitStrings.Length; for (int i = 0; i < numUnitStrings; i++) { string unitString = _nonStandardUnitStrings[i]; // Note: This is NOT a culture specific comparison. // This is by design: we want the same unit string table to work across all cultures. if (goodString.EndsWith(unitString, StringComparison.Ordinal)) { strLenUnit = unitString.Length; unitFactor = _pixelUnitFactors[i]; break; } } } // Check if there is a numerical value to parse if (strLen == strLenUnit) { // There is no numerical value to parse if (unit == DataGridLengthUnitType.Star) { // Star's value defaults to 1. Anyone else would be 0. value = 1.0; } } else { // Parse a numerical value Debug.Assert( (unit == DataGridLengthUnitType.Pixel) || DoubleUtil.AreClose(unitFactor, 1.0), "unitFactor should not be other than 1.0 unless the unit type is Pixel."); string valueString = goodString.Substring(0, strLen - strLenUnit); value = Convert.ToDouble(valueString, cultureInfo) * unitFactor; } return(new DataGridLength(value, unit)); }
private static Style CreateColumnHeaderStyle(DataGrid dg, Style columnHeaderStyle, DataGridLengthUnitType colWidthType) { var newStyle = new Style(typeof(DataGridColumnHeader), columnHeaderStyle); var ctxMenuKey = $"ctxMenu_{Guid.NewGuid().ToString("N")}"; var ctxMenu = CreateContextMenu(dg, colWidthType); newStyle.Resources.Add(ctxMenuKey, ctxMenu); newStyle.Setters.Add(ContextMenuSetter(ctxMenu)); return(newStyle); }
// Exceptions: // System.ArgumentException: // value is System.Double.NaN, System.Double.NegativeInfinity, or System.Double.PositiveInfinity.-or-type // is not System.Windows.Controls.DataGridLengthUnitType.Auto, System.Windows.Controls.DataGridLengthUnitType.Pixel, // System.Windows.Controls.DataGridLengthUnitType.Star, System.Windows.Controls.DataGridLengthUnitType.SizeToCells, // or System.Windows.Controls.DataGridLengthUnitType.SizeToHeader. /// <summary> /// Initializes a new instance of the System.Windows.Controls.DataGridLength /// class with a specified value and unit. /// </summary> /// <param name="value">The requested size of the element.</param> /// <param name="type">The type that is used to determine how the size of the element is calculated.</param> public DataGridLength(double value, DataGridLengthUnitType type) { _value = (type == DataGridLengthUnitType.Auto ? 0.0 : value); _type = type; }
/// <summary> /// Attempts to resize the column's width to the desired DisplayValue, but limits the final size /// to the column's minimum and maximum values. If star sizing is being used, then the column /// can only decrease in size by the amount that the columns after it can increase in size. /// Likewise, the column can only increase in size if other columns can spare the width. /// </summary> /// <param name="value">The new Value.</param> /// <param name="unitType">The new UnitType.</param> /// <param name="desiredValue">The new DesiredValue.</param> /// <param name="displayValue">The new DisplayValue.</param> /// <param name="userInitiated">Whether or not this resize was initiated by a user action.</param> internal void Resize(double value, DataGridLengthUnitType unitType, double desiredValue, double displayValue, bool userInitiated) { Debug.Assert(this.OwningGrid != null); double newValue = value; double newDesiredValue = desiredValue; double newDisplayValue = Math.Max(this.ActualMinWidth, Math.Min(this.ActualMaxWidth, displayValue)); DataGridLengthUnitType newUnitType = unitType; int starColumnsCount = 0; double totalDisplayWidth = 0; foreach (DataGridColumn column in this.OwningGrid.ColumnsInternal.GetVisibleColumns()) { column.EnsureWidth(); totalDisplayWidth += column.ActualWidth; starColumnsCount += (column != this && column.Width.IsStar) ? 1 : 0; } bool hasInfiniteAvailableWidth = !this.OwningGrid.RowsPresenterAvailableSize.HasValue || double.IsPositiveInfinity(this.OwningGrid.RowsPresenterAvailableSize.Value.Width); // If we're using star sizing, we can only resize the column as much as the columns to the // right will allow (i.e. until they hit their max or min widths). if (!hasInfiniteAvailableWidth && (starColumnsCount > 0 || (unitType == DataGridLengthUnitType.Star && this.Width.IsStar && userInitiated))) { double limitedDisplayValue = this.Width.DisplayValue; double availableIncrease = Math.Max(0, this.OwningGrid.CellsWidth - totalDisplayWidth); double desiredChange = newDisplayValue - this.Width.DisplayValue; if (desiredChange > availableIncrease) { // The desired change is greater than the amount of available space, // so we need to decrease the widths of columns to the right to make room. desiredChange -= availableIncrease; double actualChange = desiredChange + this.OwningGrid.DecreaseColumnWidths(this.DisplayIndex + 1, -desiredChange, userInitiated); limitedDisplayValue += availableIncrease + actualChange; } else if (desiredChange > 0) { // The desired change is positive but less than the amount of available space, // so there's no need to decrease the widths of columns to the right. limitedDisplayValue += desiredChange; } else { // The desired change is negative, so we need to increase the widths of columns to the right. limitedDisplayValue += desiredChange + this.OwningGrid.IncreaseColumnWidths(this.DisplayIndex + 1, -desiredChange, userInitiated); } if (this.ActualCanUserResize || (this.Width.IsStar && !userInitiated)) { newDisplayValue = limitedDisplayValue; } } if (userInitiated) { newDesiredValue = newDisplayValue; if (!this.Width.IsStar) { this.InheritsWidth = false; newValue = newDisplayValue; newUnitType = DataGridLengthUnitType.Pixel; } else if (starColumnsCount > 0 && !hasInfiniteAvailableWidth) { // Recalculate star weight of this column based on the new desired value this.InheritsWidth = false; newValue = (this.Width.Value * newDisplayValue) / this.ActualWidth; } } DataGridLength oldWidth = this.Width; SetWidthInternalNoCallback(new DataGridLength(Math.Min(double.MaxValue, newValue), newUnitType, newDesiredValue, newDisplayValue)); if (this.Width != oldWidth) { this.OwningGrid.OnColumnWidthChanged(this); } }
public static DataGridTemplateColumn GenTemplateColumnAllText(string strHeader, string strHeaderElement, string strCellElement, double nWidth, DataGridLengthUnitType lenType) { DataGridTemplateColumn item = new DataGridTemplateColumn(); item.Header = strHeader; item.Width = new DataGridLength(nWidth, lenType); item.CanUserReorder = false; item.CanUserResize = false; item.CanUserSort = false; StringBuilder sb = new StringBuilder(); sb.Append("<DataTemplate"); sb.Append(" xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'"); sb.Append(" xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>"); sb.Append(strCellElement); sb.Append("</DataTemplate>"); StringReader reader = new StringReader(sb.ToString()); XmlTextReader xmlReader = new XmlTextReader(reader); item.CellTemplate = (DataTemplate)XamlReader.Load(xmlReader); sb.Clear(); sb.Append("<DataTemplate"); sb.Append(" xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'"); sb.Append(" xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>"); sb.Append(strHeaderElement); sb.Append("</DataTemplate>"); reader = new StringReader(sb.ToString()); xmlReader = new XmlTextReader(reader); item.HeaderTemplate = (DataTemplate)XamlReader.Load(xmlReader); return(item); }
// Exceptions: // System.ArgumentException: // pixels is System.Double.NaN, System.Double.NegativeInfinity, or System.Double.PositiveInfinity. /// <summary> /// Initializes a new instance of the System.Windows.Controls.DataGridLength /// class with an absolute value in pixels. /// </summary> /// <param name="pixels">The absolute pixel value (96 pixels-per-inch) to initialize the length to.</param> public DataGridLength(double pixels) { _value = pixels; _type = DataGridLengthUnitType.Pixel; }
public DataGridLength(double value, DataGridLengthUnitType type, double desiredValue, double displayValue) { Contract.Ensures(!double.IsInfinity(desiredValue)); Contract.Ensures(!double.IsInfinity(displayValue)); Contract.Ensures(!double.IsInfinity(value)); }
public DataGridLength(double value, DataGridLengthUnitType type) { Contract.Ensures(!double.IsInfinity(value)); }
public ColumnInfo(DataGridColumn column) { Header = column.Header; PropertyPath = ((Binding) ((DataGridBoundColumn) column).Binding).Path.Path; WidthValue = column.Width.DisplayValue; WidthType = column.Width.UnitType; SortDirection = column.SortDirection; DisplayIndex = column.DisplayIndex; }
public static void EnableToggledColumns(this DataGrid dg, DataGridLengthUnitType colWidthType = DataGridLengthUnitType.SizeToCells) => dg.ColumnHeaderStyle = CreateColumnHeaderStyle(dg, colWidthType);