public void DoubleToDataGridLengthConverterConvertBackTest()
{
var cvt = new DoubleToDataGridLengthConverter();
DataGridLength l = DataGridLength.Auto;
double v = (double)cvt.ConvertBack(l, typeof(int), null, System.Globalization.CultureInfo.CurrentCulture);
}
public GittiupDataGrid()
{
// Styles don't automatically apply to subclasses, so we have to force the issue
Style = (Style)FindResource(typeof(DataGrid));
SelectionMode = DataGridSelectionMode.Single;
SelectionUnit = DataGridSelectionUnit.FullRow;
// This is a hack to fix a bug in DataGrid where in many scenarios it fails to accurately calculate
// the width of the columns and gives too much width to * columns. This hack uses the LayoutUpdated
// event to track for the first time when the column's width has changed from the default value of the
// MinWidth. At that point, we can reset the Width to zero and back, and finally the column widths
// will be calculated accurately.
void OnLayoutUpdated(object sender, EventArgs args)
{
foreach (DataGridColumn column in Columns.Where(x => x.Width.IsStar))
{
if (column.ActualWidth != column.MinWidth)
{
DataGridLength width = column.Width;
column.Width = 0;
column.Width = width;
LayoutUpdated -= OnLayoutUpdated;
}
}
}
LayoutUpdated += OnLayoutUpdated;
}
internal static void UpdateGridColumnWidth(DataGridColumn column)
{
DataGridLength newValue = column.Width;
if (column._parent != null && INTERNAL_VisualTreeManager.IsElementInVisualTree(column._parent))
{
GridUnitType newGridUnitType;
switch (newValue.UnitType)
{
case DataGridLengthUnitType.Auto:
newGridUnitType = GridUnitType.Auto;
break;
case DataGridLengthUnitType.Pixel:
newGridUnitType = GridUnitType.Pixel;
break;
case DataGridLengthUnitType.Star:
newGridUnitType = GridUnitType.Star;
break;
//case DataGridLengthUnitType.SizeToCells:
// //todo: probably Auto
// break;
//case DataGridLengthUnitType.SizeToHeader:
// //todo: probably Auto
// break;
default:
newGridUnitType = GridUnitType.Auto;
break;
}
column._gridColumn.Width = new GridLength(newValue.Value, newGridUnitType);
}
}
private static void UpdateColumnWidths(ICollection <DataGridColumn> columns, DataGridLength width)
{
foreach (var column in columns)
{
column.Width = width;
}
}
private void initSignalSourceGrid()
{
this.SignalSourceGrid.Columns.Clear();
DataGridLength length = new DataGridLength(1, DataGridLengthUnitType.Star);
this.SignalSourceGrid.Columns.Add(new DataGridTextColumn()
{
Header = "时段\\日期",
Binding = new Binding("ClinicVistTime.Shift.Name"),
Width = 63,
IsReadOnly = true
//,
//Foreground = Brushes.Blue // 设置该列字体颜色
});
for (int i = 0; i < 7; i++)
{
DateTime tempDate = DateTime.Now.AddDays(i);
this.SignalSourceGrid.Columns.Add(new DataGridTextColumn()
{
Header = tempDate.ToString("yyyy-MM-dd dddd"),
Binding = new Binding("weekStringList[" + (int)tempDate.DayOfWeek + "]"),
Width = length,
IsReadOnly = (tempDate.Date >= DateTime.Now.Date ? false : true)
});
}
}
public static void BuildServiceColumns(BatchLine line, DataGrid grid)
{
if (line == null)
{
return;
}
grid.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto;
foreach (var pair in line.ParsedServiceFields.Where(k => k.Key != "ReportData"))
{
var key = pair.Key;
//todo - хорошо бы вычислять ширину колонок, но непонятно как
//если задать с помощью звезды колонка будет зажата в минимальный размер
//тк все имеющееся пространство уже будет распределено между фиксированными колонками
//var width = new DataGridLength(1, DataGridLengthUnitType.Star);
var width = new DataGridLength(50, DataGridLengthUnitType.Pixel);
grid.Columns.Add(new DataGridTextColumn {
Width = width,
Header = key,
Binding = new Binding(".")
{
Converter = new LambdaConverter <BatchLine>(l => l?.ParsedServiceFields.GetValueOrDefault(key),
o => {
return((o as BatchLineView).BatchLine);
})
}
});
}
}
private void MapSeatData(List <FlightSeatInfo> seatInfos, SeatClass seatClass, DataGrid dataGrid)
{
var seats = seatInfos.Where(s => s.SeatClass == seatClass).FirstOrDefault()?.SeatMatrix;
var dataGridLength = new DataGridLength(seats.Length, DataGridLengthUnitType.Star);
dataGrid.ItemsSource = GenerateDataTableForSeat(seats);
dataGrid.ColumnWidth = dataGridLength;
}
private void RestoreLastColumn()
{
if (lastColumn != null)
{
lastColumn.Width = lastColumnWidthBackup;
lastColumn = null;
lastColumnWidthBackup = default(DataGridLength);
}
}
static public void ColumnResize(this DataGrid dg, string sName, DataGridLength stDGL)
{
DataGridColumn dgcColumn;
if (null != (dgcColumn = dg.ColumnGet(sName)))
{
dgcColumn.Width = stDGL;
}
}
private void AssociatedObjectSizeChanged(object sender, SizeChangedEventArgs e)
{
foreach (DataGridColumn dataGridColumn in AssociatedObject.Columns)
{
DataGridLength dataGridLength = dataGridColumn.Width;
dataGridColumn.ClearValue(DataGridColumn.WidthProperty);
dataGridColumn.Width = dataGridLength;
}
}
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
if (value == null || !(value is GridLength))
{
return(DataGridLength.Auto);
}
var result = new DataGridLength(((GridLength)value).Value);
return(result);
}
public static void RotateButtonImage(Button showId, DataGridLength width)
{
showId.RenderTransformOrigin = new Point(0.5, 0.5);
ScaleTransform flipTrans = new ScaleTransform
{
ScaleX = width.UnitType == DataGridLengthUnitType.SizeToCells ? 1 : -1
};
showId.RenderTransform = flipTrans;
}
public void AdicionarDataGridColumn(string cabecalho, Binding binding, DataGridLength larguraColuna)
{
var dataGridColumn = new DataGridTextColumn
{
Header = cabecalho,
Binding = binding,
Width = larguraColuna
};
ColunasDataGrid.Add(dataGridColumn);
}
public UIGridColumn(string header, string path, string stringFormat,
string tooltip, string tooltipPath, DataGridLength length, bool isRightAligned = false)
{
this.Header = header;
this.Path = path;
this.StringFormat = stringFormat;
this.Tooltip = tooltip;
this.TooltipPath = tooltipPath;
this.Length = length;
this.IsRightAligned = isRightAligned;
}
private void MontarColunasDataGrid()
{
if (DataGrid.Columns.Count != 3)
{
return;
}
var starWidth = new DataGridLength(1.0, DataGridLengthUnitType.Star);
if (!Model.BotaoOpcoes)
{
DataGrid.Columns.RemoveAt(0);
}
if (!Model.BotaoEditar && !Model.BotaoOpcoes)
{
DataGrid.Columns.RemoveAt(0);
}
if (!Model.BotaoEditar && Model.BotaoOpcoes)
{
DataGrid.Columns.RemoveAt(1);
}
if (!Model.BotaoDeletar && Model.BotaoOpcoes && Model.BotaoEditar)
{
DataGrid.Columns.RemoveAt(2);
}
if (!Model.BotaoDeletar && Model.BotaoOpcoes && !Model.BotaoEditar)
{
DataGrid.Columns.RemoveAt(1);
}
if (!Model.BotaoDeletar && !Model.BotaoOpcoes && Model.BotaoEditar)
{
DataGrid.Columns.RemoveAt(1);
}
if (!Model.BotaoDeletar && !Model.BotaoOpcoes && !Model.BotaoEditar)
{
DataGrid.Columns.RemoveAt(0);
}
foreach (var dataGridColumn in Model.ColunasDataGrid)
{
if (dataGridColumn.Width.IsAuto)
{
dataGridColumn.Width = starWidth;
}
DataGrid.Columns.Add(dataGridColumn);
}
}
/// <summary>
/// Set one column width.
/// </summary>
/// <param name="_header">A string param.</param>
/// <param name="_width">A DataGridLength param.</param>
/// <returns>IMyDataGrid</returns>
public IMyDataGrid setOneColumnWidth(string _header, DataGridLength _width)
{
foreach (DataGridColumn column in myDataGrid_dg.Columns)
{
if (_header.Equals(column.Header))
{
column.Width = _width;
}
}
return(this);
}
private void initDateClinicMsgGrid()
{
this.DateClinicMsgGrid.Columns.Clear();
CommClient.WorkType myd = new CommClient.WorkType();
List <CommContracts.WorkType> listOfAllWorkTypes = myd.GetAllWorkType();
DataGridLength length = new DataGridLength(1, DataGridLengthUnitType.Star);
this.DateClinicMsgGrid.Columns.Add(new DataGridTextColumn()
{
Header = "人员",
Binding = new Binding("Name"),
Width = 100,
IsReadOnly = true
//,
//Foreground = Brushes.Blue // 设置该列字体颜色
});
this.DateClinicMsgGrid.Columns.Add(new DataGridTextColumn()
{
Header = "时段",
Binding = new Binding("ShiftName"),
Width = 100,
IsReadOnly = true
//,
//Foreground = Brushes.Blue // 设置该列字体颜色
});
for (int i = 0; i < 7; i++)
{
DateTime tempDate = getMonday(currentManageDate).AddDays(i);
this.DateClinicMsgGrid.Columns.Add(new DataGridComboBoxColumn()
{
Header = tempDate.ToString("yyyy-MM-dd dddd"),
SelectedItemBinding = new Binding("WorkPlanWorkTypeList[" + (int)tempDate.DayOfWeek + "]"),
ItemsSource = listOfAllWorkTypes,
Width = length,
IsReadOnly = (tempDate.Date >= DateTime.Now.Date ? false : true)
});
}
this.DateClinicMsgGrid.Columns.Add(new DataGridTextColumn()
{
Header = "最大工作量",
Binding = new Binding("MaxVistNum"),
Width = 100,
IsReadOnly = false,
Foreground = Brushes.Green // 设置该列字体颜色
});
}
private void AcquireLastColumn()
{
if (!IsEnabled)
{
return;
}
lastColumn = TargetDataGrid.Columns.LastOrDefault();
if (lastColumn != null)
{
lastColumnWidthBackup = lastColumn.Width;
lastColumn.Width = new DataGridLength(100.0, DataGridLengthUnitType.Star);
}
}
private void setColumnsWidth()
{
DataGridLength length1 = new DataGridLength(1, DataGridLengthUnitType.Star);
DataGridLength length1_5 = new DataGridLength(1.5, DataGridLengthUnitType.Star);
DataGridLength length2 = new DataGridLength(2, DataGridLengthUnitType.Star);
DataGridLength length2_5 = new DataGridLength(2.5, DataGridLengthUnitType.Star);
DataGridLength length3 = new DataGridLength(3, DataGridLengthUnitType.Star);
DataGridLength length4 = new DataGridLength(4, DataGridLengthUnitType.Star);
//lastColumn.Width = length;
dataGrid.Columns[0].Width = length2;
dataGrid.Columns[1].Width = length3;
dataGrid.Columns[2].Width = length4;
dataGrid.Columns[3].Width = length1_5;
dataGrid.Columns[4].Width = length2;
dataGrid.Columns[5].Width = length1_5;
dataGrid.Columns[6].Width = length2;
dataGrid.Columns[7].Width = length2;
dataGrid.Columns[8].Width = length2;
dataGrid.Columns[9].Width = length1_5;
dataGrid.Columns[10].Width = length2;
Style styleCenter0 = new Style(typeof(DataGridColumnHeader));
//Style styleRight0 = new Style(typeof(System.Windows.Controls.Datagrid));
Style styleCenter = new Style(typeof(TextBlock));
Style styleRight = new Style(typeof(TextBlock));
Setter setCenter = new Setter(TextBlock.HorizontalAlignmentProperty, System.Windows.HorizontalAlignment.Center);
Setter setRight = new Setter(TextBlock.HorizontalAlignmentProperty, System.Windows.HorizontalAlignment.Right);
//styleRight.Setters.Add(setRight);
Setter setHead = new Setter(DataGridColumnHeader.HorizontalContentAlignmentProperty, System.Windows.HorizontalAlignment.Center);
// Setter setHead1 = new Setter(DataGridColumnHeader., System.Windows.VerticalAlignment.Center);
styleCenter.Setters.Add(setCenter);
styleCenter0.Setters.Add(setHead);
styleRight.Setters.Add(setRight);
// styleRight0.Setters.Add(setHead1);
foreach (DataGridColumn c in dataGrid.Columns)
{
DataGridTextColumn tc = c as DataGridTextColumn;
if (tc.Header.ToString() != "总价" && tc.Header.ToString() != "单价")
{
//tc.HeaderStyle = styleCenter0;
tc.ElementStyle = styleCenter;
}
else
{
tc.ElementStyle = styleRight;
}
tc.HeaderStyle = styleCenter0;
}
}
// Exceptions:
// System.ArgumentNullException:
// value is null.
//
// System.ArgumentException:
// value is not a valid type that can be converted to type System.Windows.Controls.DataGridLength.
/// <summary>
/// Converts the specified object to an instance of the System.Windows.Controls.DataGridLength
/// class.
/// </summary>
/// <param name="context">An object that provides a format context.</param>
/// <param name="culture">The object to use as the current culture.</param>
/// <param name="value">The value to convert.</param>
/// <returns>The converted value.</returns>
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (value == null)
{
throw GetConvertFromException(value);
}
if (value is string)
{
return(DataGridLength.INTERNAL_ConvertFromString((string)value));
}
return(base.ConvertFrom(context, culture, value));
}
private void Button_Print_Click(object sender, RoutedEventArgs e)
{
var printDialog = new PrintDialog();
if (printDialog.ShowDialog() != true)
{
return;
}
var myPanel = new StackPanel {
Orientation = Orientation.Vertical, HorizontalAlignment = HorizontalAlignment.Stretch
};
myPanel.Children.Add(new TextBlock
{
Text = "Статистика по ошибкам",
TextAlignment = TextAlignment.Center,
FontSize = 16,
FontWeight = FontWeights.Bold,
Margin = new Thickness(0, 0, 0, 10)
});
myPanel.Children.Add(new TextBlock
{
Text = string.Format("Госномер: {0}, марка: {1}, модель автомобиля: {2}",
_car.CarModel.CarNumber, _car.CarModel.Mark, _car.CarModel.Model),
TextAlignment = TextAlignment.Center,
FontSize = 14,
Margin = new Thickness(0, 0, 0, 15)
});
var trr = new DataGrid {
AutoGenerateColumns = false, HorizontalAlignment = HorizontalAlignment.Stretch
};
var wd = new DataGridLength(1, DataGridLengthUnitType.Star);
trr.Columns.Add(new DataGridTextColumn {
Header = "Номер ошибки", Binding = new Binding("ID"), Width = wd
});
trr.Columns.Add(new DataGridTextColumn {
Header = "Кол-во", Binding = new Binding("Count"), Width = wd
});
trr.Columns.Add(new DataGridTextColumn {
Header = "Зафикисирована", Binding = new Binding("LastDate"), Width = wd
});
trr.ItemsSource = dtgrdErrorsStat.ItemsSource;
myPanel.Children.Add(trr);
myPanel.Measure(new Size(printDialog.PrintableAreaWidth, printDialog.PrintableAreaHeight));
//myPanel.Arrange(new Rect(new Point(0, 0), myPanel.DesiredSize));
printDialog.PrintVisual(myPanel, "Статистика по ошибкам");
}
public void DoubleToDataGridLengthConverterTest()
{
var cvt = new DoubleToDataGridLengthConverter();
double v = 1000000;
DataGridLength l = (DataGridLength)cvt.Convert(v, typeof(int), null, System.Globalization.CultureInfo.CurrentCulture);
Assert.IsTrue(l.Value == v);
v = 0;
l = (DataGridLength)cvt.Convert(v, typeof(int), null, System.Globalization.CultureInfo.CurrentCulture);
Assert.IsTrue(l.Value == v);
v = -1;
l = (DataGridLength)cvt.Convert(v, typeof(int), null, System.Globalization.CultureInfo.CurrentCulture);
Assert.IsTrue(DataGridLength.Auto == l);
}
/// <summary>
///
/// </summary>
public PropertyGrid()
{
Buttons = new FrameworkElementCollection();
CommandBindings.Add(new CommandBinding(EditCollectionCommand, this.EditCollectionCommand_Executed, this.EditCollectionCommand_CanExecute));
CommandBindings.Add(new CommandBinding(ResetCommand, this.ResetCommand_Executed, this.ResetCommand_CanExecute));
Properties = new PropertyModelCollection();
ListCollectionView = new ListCollectionView(Properties);
PropertyColumnWidth = new DataGridLength(40d, DataGridLengthUnitType.Star);
ValueColumnWidth = new DataGridLength(60d, DataGridLengthUnitType.Star);
InitializeComponent();
Sort();
}
private void dataGrid1_AutoGeneratedColumns(object sender, EventArgs e)
{
var dg = sender as DataGrid;
var first = dg.ItemsSource.Cast <object>().FirstOrDefault() as DynamicObject;
if (first == null)
{
return;
}
var names = first.GetDynamicMemberNames();
DataGridLength len = new DataGridLength(1, DataGridLengthUnitType.Star);
foreach (var name in names)
{
dg.Columns.Add(new DataGridTextColumn {
Header = name, Binding = new Binding(name), Width = len
});
}
}
/// <summary>
/// Doubleの値をDataGridLengthに変換します。-1のときはDataGridLength.Autoに変換します。
/// </summary>
/// <param name="value"></param>
/// <param name="targetType"></param>
/// <param name="parameter"></param>
/// <param name="culture"></param>
/// <returns></returns>
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
DataGridLength l = 0;
if (value != null)
{
string d = value.ToString();
switch (d)
{
case "-1":
l = DataGridLength.Auto;
break;
default:
l = (double)value;
break;
}
}
else
{
throw new ArgumentNullException("value");
}
return(l);
}
public CustomBoundColumn()
{
Width = new DataGridLength(1, DataGridLengthUnitType.Star);
}
private void SetColumnsWidth(DataGridLength p_gridLengthNewValue)
{
foreach (var objCol in dgvVisualizer.Columns)
{
objCol.Width = p_gridLengthNewValue;
}
}
public GenerateOperatorGridColumn()
{
Width = new DataGridLength(1, DataGridLengthUnitType.Star);
}
/// <summary>
/// Measures the children of a <see cref="T:System.Windows.Controls.Primitives.DataGridCellsPresenter"/> to
/// prepare for arranging them during the <see cref="M:System.Windows.FrameworkElement.ArrangeOverride(System.Windows.Size)"/> pass.
/// </summary>
/// <param name="availableSize">
/// The available size that this element can give to child elements. Indicates an upper limit that child elements should not exceed.
/// </param>
/// <returns>
/// The size that the <see cref="T:System.Windows.Controls.Primitives.DataGridCellsPresenter"/> determines it needs during layout, based on its calculations of child object allocated sizes.
/// </returns>
protected override Size MeasureOverride(Size availableSize)
{
if (this.OwningGrid == null)
{
return(base.MeasureOverride(availableSize));
}
bool autoSizeHeight;
double measureHeight;
if (double.IsNaN(this.OwningGrid.RowHeight))
{
// No explicit height values were set so we can autosize
autoSizeHeight = true;
measureHeight = double.PositiveInfinity;
}
else
{
this.DesiredHeight = this.OwningGrid.RowHeight;
measureHeight = this.DesiredHeight;
autoSizeHeight = false;
}
double frozenLeftEdge = 0;
double totalDisplayWidth = 0;
double scrollingLeftEdge = -this.OwningGrid.HorizontalOffset;
this.OwningGrid.ColumnsInternal.EnsureVisibleEdgedColumnsWidth();
DataGridColumn lastVisibleColumn = this.OwningGrid.ColumnsInternal.LastVisibleColumn;
foreach (DataGridColumn column in this.OwningGrid.ColumnsInternal.GetVisibleColumns())
{
DataGridCell cell = this.OwningRow.Cells[column.Index];
// Measure the entire first row to make the horizontal scrollbar more accurate
bool shouldDisplayCell = ShouldDisplayCell(column, frozenLeftEdge, scrollingLeftEdge) || this.OwningRow.Index == 0;
EnsureCellDisplay(cell, shouldDisplayCell);
if (shouldDisplayCell)
{
DataGridLength columnWidth = column.Width;
bool autoGrowWidth = columnWidth.IsSizeToCells || columnWidth.IsAuto;
if (column != lastVisibleColumn)
{
cell.EnsureGridLine(lastVisibleColumn);
}
// If we're not using star sizing or the current column can't be resized,
// then just set the display width according to the column's desired width
if (!this.OwningGrid.UsesStarSizing || (!column.ActualCanUserResize && !column.Width.IsStar))
{
// In the edge-case where we're given infinite width and we have star columns, the
// star columns grow to their predefined limit of 10,000 (or their MaxWidth)
double newDisplayWidth = column.Width.IsStar ?
Math.Min(column.ActualMaxWidth, DataGrid.DATAGRID_maximumStarColumnWidth) :
Math.Max(column.ActualMinWidth, Math.Min(column.ActualMaxWidth, column.Width.DesiredValue));
column.SetWidthDisplayValue(newDisplayWidth);
}
// If we're auto-growing the column based on the cell content, we want to measure it at its maximum value
if (autoGrowWidth)
{
cell.Measure(new Size(column.ActualMaxWidth, measureHeight));
this.OwningGrid.AutoSizeColumn(column, cell.DesiredSize.Width);
column.ComputeLayoutRoundedWidth(totalDisplayWidth);
}
else if (!this.OwningGrid.UsesStarSizing)
{
column.ComputeLayoutRoundedWidth(scrollingLeftEdge);
cell.Measure(new Size(column.LayoutRoundedWidth, measureHeight));
}
// We need to track the largest height in order to auto-size
if (autoSizeHeight)
{
this.DesiredHeight = Math.Max(this.DesiredHeight, cell.DesiredSize.Height);
}
}
if (column.IsFrozen)
{
frozenLeftEdge += column.ActualWidth;
}
scrollingLeftEdge += column.ActualWidth;
totalDisplayWidth += column.ActualWidth;
}
// If we're using star sizing (and we're not waiting for an auto-column to finish growing)
// then we will resize all the columns to fit the available space.
if (this.OwningGrid.UsesStarSizing && !this.OwningGrid.AutoSizingColumns)
{
double adjustment = this.OwningGrid.CellsWidth - totalDisplayWidth;
this.OwningGrid.AdjustColumnWidths(0, adjustment, false);
// Since we didn't know the final widths of the columns until we resized,
// we waited until now to measure each cell
double leftEdge = 0;
foreach (DataGridColumn column in this.OwningGrid.ColumnsInternal.GetVisibleColumns())
{
DataGridCell cell = this.OwningRow.Cells[column.Index];
column.ComputeLayoutRoundedWidth(leftEdge);
cell.Measure(new Size(column.LayoutRoundedWidth, measureHeight));
if (autoSizeHeight)
{
this.DesiredHeight = Math.Max(this.DesiredHeight, cell.DesiredSize.Height);
}
leftEdge += column.ActualWidth;
}
}
// Measure FillerCell, we're doing it unconditionally here because we don't know if we'll need the filler
// column and we don't want to cause another Measure if we do
this.OwningRow.FillerCell.Measure(new Size(double.PositiveInfinity, this.DesiredHeight));
this.OwningGrid.ColumnsInternal.EnsureVisibleEdgedColumnsWidth();
return(new Size(this.OwningGrid.ColumnsInternal.VisibleEdgedColumnsWidth, this.DesiredHeight));
}
/// <summary>
/// Sets the width of the set last column.
/// </summary>
/// <param name="obj">The obj.</param>
/// <param name="value">The value.</param>
public static void SetSetLastColumnWidth(DependencyObject obj, DataGridLength value)
{
obj.SetValue(SetLastColumnWidthProperty, value);
}
static public void ColumnResize(this DataGrid dg, string sName, DataGridLength stDGL)
{
DataGridColumn dgcColumn;
if (null != (dgcColumn = dg.ColumnGet(sName)))
dgcColumn.Width = stDGL;
}
/// <summary>
/// Coerces a DataGridLength to a valid value. If any value components are double.NaN, this method
/// coerces them to a proper initial value. For star columns, the desired width is calculated based
/// on the rest of the star columns. For pixel widths, the desired value is based on the pixel value.
/// For auto widths, the desired value is initialized as the column's minimum width.
/// </summary>
/// <param name="width">The DataGridLength to coerce.</param>
/// <returns>The resultant (coerced) DataGridLength.</returns>
internal DataGridLength CoerceWidth(DataGridLength width)
{
double desiredValue = width.DesiredValue;
if (double.IsNaN(desiredValue))
{
if (width.IsStar && this.OwningGrid != null && this.OwningGrid.ColumnsInternal != null)
{
double totalStarValues = 0;
double totalStarDesiredValues = 0;
double totalNonStarDisplayWidths = 0;
foreach (DataGridColumn column in this.OwningGrid.ColumnsInternal.GetDisplayedColumns(c => c.IsVisible && c != this && !double.IsNaN(c.Width.DesiredValue)))
{
if (column.Width.IsStar)
{
totalStarValues += column.Width.Value;
totalStarDesiredValues += column.Width.DesiredValue;
}
else
{
totalNonStarDisplayWidths += column.ActualWidth;
}
}
if (totalStarValues == 0)
{
// Compute the new star column's desired value based on the available space if there are no other visible star columns
desiredValue = Math.Max(this.ActualMinWidth, this.OwningGrid.CellsWidth - totalNonStarDisplayWidths);
}
else
{
// Otherwise, compute its desired value based on those of other visible star columns
desiredValue = totalStarDesiredValues * width.Value / totalStarValues;
}
}
else if (width.IsAbsolute)
{
desiredValue = width.Value;
}
else
{
desiredValue = this.ActualMinWidth;
}
}
double displayValue = width.DisplayValue;
if (double.IsNaN(displayValue))
{
displayValue = desiredValue;
}
displayValue = Math.Max(this.ActualMinWidth, Math.Min(this.ActualMaxWidth, displayValue));
return new DataGridLength(width.Value, width.UnitType, desiredValue, displayValue);
}
/// <summary>
/// Sets the column's Width directly, without any callback effects.
/// </summary>
/// <param name="width">The new Width.</param>
internal void SetWidthInternalNoCallback(DataGridLength width)
{
_width = width;
}
/// <summary>
/// Converts a DataGridLength instance to a String given the CultureInfo.
/// </summary>
/// <param name="gl">DataGridLength instance to convert.</param>
/// <param name="cultureInfo">The culture to use.</param>
/// <returns>String representation of the object.</returns>
internal static string ConvertToString(DataGridLength length, CultureInfo cultureInfo)
{
switch (length.UnitType)
{
case DataGridLengthUnitType.Auto:
case DataGridLengthUnitType.SizeToCells:
case DataGridLengthUnitType.SizeToHeader:
return length.UnitType.ToString();
// Star has one special case when value is "1.0" in which the value can be dropped.
case DataGridLengthUnitType.Star:
return DoubleUtil.IsOne(length.Value) ? "*" : Convert.ToString(length.Value, cultureInfo) + "*";
// Print out the numeric value. "px" can be omitted.
default:
return Convert.ToString(length.Value, cultureInfo);
}
}
/// <summary>
/// Internal method which sets the column's width
/// without actual redistribution of widths among other
/// columns
/// </summary>
/// <param name="width"></param>
internal void SetWidthInternal(DataGridLength width)
{
bool originalValue = _ignoreRedistributionOnWidthChange;
_ignoreRedistributionOnWidthChange = true;
try
{
Width = width;
}
finally
{
_ignoreRedistributionOnWidthChange = originalValue;
}
}
public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
DataGridLength length = (DataGridLength)value;
return(length.DisplayValue);
}
protected override Size MeasureOverride(Size availableSize)
{
if (this.OwningGrid == null)
{
return(base.MeasureOverride(availableSize));
}
if (!this.OwningGrid.AreColumnHeadersVisible)
{
return(Size.Empty);
}
double height = this.OwningGrid.ColumnHeaderHeight;
bool autoSizeHeight;
if (double.IsNaN(height))
{
// No explicit height values were set so we can autosize
height = 0;
autoSizeHeight = true;
}
else
{
autoSizeHeight = false;
}
DataGridColumn lastVisibleColumn = this.OwningGrid.ColumnsInternal.LastVisibleColumn;
DataGridColumn column = this.OwningGrid.ColumnsInternal.FirstVisibleColumn;
double measureWidth;
while (column != null)
{
DataGridLength columnWidth = column.EffectiveWidth;
measureWidth = columnWidth.IsAbsolute ? column.ActualWidth : column.ActualMaxWidth;
bool autoGrowWidth = columnWidth.IsAuto || columnWidth.IsSizeToHeader;
DataGridColumnHeader columnHeader = column.HeaderCell;
if (column != lastVisibleColumn)
{
columnHeader.UpdateSeparatorVisibility(lastVisibleColumn);
}
columnHeader.Measure(new Size(measureWidth, double.PositiveInfinity));
if (autoSizeHeight)
{
height = Math.Max(height, columnHeader.DesiredSize.Height);
}
if (autoGrowWidth && columnHeader.DesiredSize.Width > column.DesiredWidth)
{
column.DesiredWidth = columnHeader.DesiredSize.Width;
}
column = this.OwningGrid.ColumnsInternal.GetNextVisibleColumn(column);
}
// Add the filler column if it's not represented. We won't know whether we need it or not until Arrange
DataGridFillerColumn fillerColumn = this.OwningGrid.ColumnsInternal.FillerColumn;
if (!fillerColumn.IsRepresented)
{
Debug.Assert(!this.Children.Contains(fillerColumn.HeaderCell));
fillerColumn.HeaderCell.SeparatorVisibility = Visibility.Collapsed;
this.Children.Insert(this.OwningGrid.ColumnsInternal.Count, fillerColumn.HeaderCell);
fillerColumn.IsRepresented = true;
this.OwningGrid.OnFillerColumnRepresentationChanged();
// Optimize for the case where we don't need the filler cell
fillerColumn.HeaderCell.Visibility = Visibility.Collapsed;
}
fillerColumn.HeaderCell.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
return(new Size(this.OwningGrid.ColumnsInternal.VisibleEdgedColumnsWidth, height));
}
/// <summary>
/// Set the column's Width without breaking inheritance.
/// </summary>
/// <param name="width">The new Width.</param>
internal void SetWidthInternal(DataGridLength width)
{
bool originalValue = _settingWidthInternally;
_settingWidthInternally = true;
try
{
this.Width = width;
}
finally
{
_settingWidthInternally = originalValue;
}
}
