private void UpdateVisualBrush()
{
if (_referenceHeader != null && _visualBrushCanvas != null)
{
VisualBrush visualBrush = new VisualBrush(_referenceHeader);
visualBrush.ViewboxUnits = BrushMappingMode.Absolute;
double width = Width;
if (DoubleUtil.IsNaN(width))
{
width = _referenceHeader.ActualWidth;
}
else
{
width = width - GetVisualCanvasMarginX();
}
double height = Height;
if (DoubleUtil.IsNaN(height))
{
height = _referenceHeader.ActualHeight;
}
else
{
height = height - GetVisualCanvasMarginY();
}
Vector offset = VisualTreeHelper.GetOffset(_referenceHeader);
visualBrush.Viewbox = new Rect(offset.X, offset.Y, width, height);
_visualBrushCanvas.Background = visualBrush;
}
}
// Token: 0x060048D3 RID: 18643 RVA: 0x0014A864 File Offset: 0x00148A64
public static void OnColumnWidthChanged(IProvideDataGridColumn cell, DependencyPropertyChangedEventArgs e)
{
UIElement uielement = (UIElement)cell;
DataGridColumn column = cell.Column;
bool flag = cell is DataGridColumnHeader;
if (column != null)
{
DataGridLength width = column.Width;
if (width.IsAuto || (!flag && width.IsSizeToCells) || (flag && width.IsSizeToHeader))
{
DataGridLength dataGridLength = (DataGridLength)e.OldValue;
double num;
if (dataGridLength.UnitType != width.UnitType)
{
double constraintWidth = column.GetConstraintWidth(flag);
if (!DoubleUtil.AreClose(uielement.DesiredSize.Width, constraintWidth))
{
uielement.InvalidateMeasure();
uielement.Measure(new Size(constraintWidth, double.PositiveInfinity));
}
num = uielement.DesiredSize.Width;
}
else
{
num = dataGridLength.DesiredValue;
}
if (DoubleUtil.IsNaN(width.DesiredValue) || DoubleUtil.LessThan(width.DesiredValue, num))
{
column.SetWidthInternal(new DataGridLength(width.Value, width.UnitType, num, width.DisplayValue));
}
}
}
}
/// <summary>
/// Overloaded operator, compares 2 DataGridLength's.
/// </summary>
/// <param name="gl1">first DataGridLength to compare.</param>
/// <param name="gl2">second DataGridLength to compare.</param>
/// <returns>true if specified DataGridLengths have same value
/// and unit type.</returns>
public static bool operator ==(DataGridLength gl1, DataGridLength gl2)
{
return(gl1.UnitType == gl2.UnitType &&
gl1.Value == gl2.Value &&
((gl1.DesiredValue == gl2.DesiredValue) || (DoubleUtil.IsNaN(gl1.DesiredValue) && DoubleUtil.IsNaN(gl2.DesiredValue))) &&
((gl1.DisplayValue == gl2.DisplayValue) || (DoubleUtil.IsNaN(gl1.DisplayValue) && DoubleUtil.IsNaN(gl2.DisplayValue))));
}
/// <summary>
/// Overloaded operator, compares 2 DataGridLength's.
/// </summary>
/// <param name="gl1">first DataGridLength to compare.</param>
/// <param name="gl2">second DataGridLength to compare.</param>
/// <returns>true if specified DataGridLengths have either different value or
/// unit type.</returns>
public static bool operator !=(DataGridLength gl1, DataGridLength gl2)
{
return(gl1.UnitType != gl2.UnitType ||
gl1.Value != gl2.Value ||
((gl1.DesiredValue != gl2.DesiredValue) && !(DoubleUtil.IsNaN(gl1.DesiredValue) && DoubleUtil.IsNaN(gl2.DesiredValue))) ||
((gl1.DisplayValue != gl2.DisplayValue) && !(DoubleUtil.IsNaN(gl1.DisplayValue) && DoubleUtil.IsNaN(gl2.DisplayValue))));
}
/// <summary>
/// <see cref="FrameworkElement.MeasureOverride"/>
/// </summary>
protected override Size MeasureOverride(Size constraint)
{
UVSize curLineSize = new UVSize(Orientation);
UVSize panelSize = new UVSize(Orientation);
UVSize uvConstraint = new UVSize(Orientation, constraint.Width, constraint.Height);
double itemWidth = ItemWidth;
double itemHeight = ItemHeight;
bool itemWidthSet = !DoubleUtil.IsNaN(itemWidth);
bool itemHeightSet = !DoubleUtil.IsNaN(itemHeight);
Size childConstraint = new Size(
(itemWidthSet ? itemWidth : constraint.Width),
(itemHeightSet ? itemHeight : constraint.Height));
UIElementCollection children = InternalChildren;
for (int i = 0, count = children.Count; i < count; i++)
{
UIElement child = children[i] as UIElement;
if (child == null)
{
continue;
}
//Flow passes its own constrint to children
child.Measure(childConstraint);
//this is the size of the child in UV space
UVSize sz = new UVSize(
Orientation,
(itemWidthSet ? itemWidth : child.DesiredSize.Width),
(itemHeightSet ? itemHeight : child.DesiredSize.Height));
if (DoubleUtil.GreaterThan(curLineSize.U + sz.U, uvConstraint.U)) //need to switch to another line
{
panelSize.U = Math.Max(curLineSize.U, panelSize.U);
panelSize.V += curLineSize.V;
curLineSize = sz;
if (DoubleUtil.GreaterThan(sz.U, uvConstraint.U)) //the element is wider then the constrint - give it a separate line
{
panelSize.U = Math.Max(sz.U, panelSize.U);
panelSize.V += sz.V;
curLineSize = new UVSize(Orientation);
}
}
else //continue to accumulate a line
{
curLineSize.U += sz.U;
curLineSize.V = Math.Max(sz.V, curLineSize.V);
}
}
//the last line size, if any should be added
panelSize.U = Math.Max(curLineSize.U, panelSize.U);
panelSize.V += curLineSize.V;
//go from UV space to W/H space
return(new Size(panelSize.Width, panelSize.Height));
}
/// <summary>
/// <see cref="FrameworkElement.ArrangeOverride"/>
/// </summary>
protected override Size ArrangeOverride(Size finalSize)
{
int firstInLine = 0;
double itemWidth = ItemWidth;
double itemHeight = ItemHeight;
double accumulatedV = 0;
double itemU = (Orientation == Orientation.Horizontal ? itemWidth : itemHeight);
UVSize curLineSize = new UVSize(Orientation);
UVSize uvFinalSize = new UVSize(Orientation, finalSize.Width, finalSize.Height);
bool itemWidthSet = !DoubleUtil.IsNaN(itemWidth);
bool itemHeightSet = !DoubleUtil.IsNaN(itemHeight);
bool useItemU = (Orientation == Orientation.Horizontal ? itemWidthSet : itemHeightSet);
UIElementCollection children = InternalChildren;
for (int i = 0, count = children.Count; i < count; i++)
{
UIElement child = children[i] as UIElement;
if (child == null)
{
continue;
}
UVSize sz = new UVSize(
Orientation,
(itemWidthSet ? itemWidth : child.DesiredSize.Width),
(itemHeightSet ? itemHeight : child.DesiredSize.Height));
if (DoubleUtil.GreaterThan(curLineSize.U + sz.U, uvFinalSize.U)) //need to switch to another line
{
arrangeLine(accumulatedV, curLineSize.V, firstInLine, i, useItemU, itemU);
accumulatedV += curLineSize.V;
curLineSize = sz;
if (DoubleUtil.GreaterThan(sz.U, uvFinalSize.U)) //the element is wider then the constraint - give it a separate line
{
//switch to next line which only contain one element
arrangeLine(accumulatedV, sz.V, i, ++i, useItemU, itemU);
accumulatedV += sz.V;
curLineSize = new UVSize(Orientation);
}
firstInLine = i;
}
else //continue to accumulate a line
{
curLineSize.U += sz.U;
curLineSize.V = Math.Max(sz.V, curLineSize.V);
}
}
//arrange the last line, if any
if (firstInLine < children.Count)
{
arrangeLine(accumulatedV, curLineSize.V, firstInLine, children.Count, useItemU, itemU);
}
return(finalSize);
}
/// <summary>Converts the specified object to an instance of the <see cref="T: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>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="value" /> is <see langword="null" />.</exception>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="value" /> is not a valid type that can be converted to type <see cref="T:System.Windows.Controls.DataGridLength" />.</exception>
// Token: 0x0600491E RID: 18718 RVA: 0x0014B6F4 File Offset: 0x001498F4
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (value != null)
{
string text = value as string;
if (text != null)
{
return(DataGridLengthConverter.ConvertFromString(text, culture));
}
double num = Convert.ToDouble(value, culture);
DataGridLengthUnitType type;
if (DoubleUtil.IsNaN(num))
{
num = 1.0;
type = DataGridLengthUnitType.Auto;
}
else
{
type = DataGridLengthUnitType.Pixel;
}
if (!double.IsInfinity(num))
{
return(new DataGridLength(num, type));
}
}
throw base.GetConvertFromException(value);
}
// Token: 0x0600487D RID: 18557 RVA: 0x00149A20 File Offset: 0x00147C20
private void UpdateVisualBrush()
{
if (this._referenceHeader != null && this._visualBrushCanvas != null)
{
VisualBrush visualBrush = new VisualBrush(this._referenceHeader);
visualBrush.ViewboxUnits = BrushMappingMode.Absolute;
double num = base.Width;
if (DoubleUtil.IsNaN(num))
{
num = this._referenceHeader.ActualWidth;
}
else
{
num -= this.GetVisualCanvasMarginX();
}
double num2 = base.Height;
if (DoubleUtil.IsNaN(num2))
{
num2 = this._referenceHeader.ActualHeight;
}
else
{
num2 -= this.GetVisualCanvasMarginY();
}
Vector offset = VisualTreeHelper.GetOffset(this._referenceHeader);
visualBrush.Viewbox = new Rect(offset.X, offset.Y, num, num2);
this._visualBrushCanvas.Background = visualBrush;
}
}
static internal double ValidateInputOffset(double offset, string parameterName)
{
if (DoubleUtil.IsNaN(offset))
{
throw new ArgumentOutOfRangeException(parameterName, SR.Get(SRID.ScrollViewer_CannotBeNaN, parameterName));
}
return(Math.Max(0.0, offset));
}
/// <summary>
/// Canvas computes a position for each of its children taking into account their margin and
/// attached Canvas properties: Top, Left.
///
/// Canvas will also arrange each of its children.
/// </summary>
/// <param name="arrangeSize">Size that Canvas will assume to position children.</param>
protected override Size ArrangeOverride(Size arrangeSize)
{
//Canvas arranges children at their DesiredSize.
//This means that Margin on children is actually respected and added
//to the size of layout partition for a child.
//Therefore, is Margin is 10 and Left is 20, the child's ink will start at 30.
foreach (UIElement child in InternalChildren)
{
if (child == null)
{
continue;
}
double x = 0;
double y = 0;
//Compute offset of the child:
//If Left is specified, then Right is ignored
//If Left is not specified, then Right is used
//If both are not there, then 0
double left = GetLeft(child);
if (!DoubleUtil.IsNaN(left))
{
x = left;
}
else
{
double right = GetRight(child);
if (!DoubleUtil.IsNaN(right))
{
x = arrangeSize.Width - child.DesiredSize.Width - right;
}
}
double top = GetTop(child);
if (!DoubleUtil.IsNaN(top))
{
y = top;
}
else
{
double bottom = GetBottom(child);
if (!DoubleUtil.IsNaN(bottom))
{
y = arrangeSize.Height - child.DesiredSize.Height - bottom;
}
}
child.Arrange(new Rect(new Point(x, y), child.DesiredSize));
}
return(arrangeSize);
}
// Token: 0x0600486E RID: 18542 RVA: 0x0014974C File Offset: 0x0014794C
private static object OnCoerceWidth(DependencyObject d, object baseValue)
{
double value = (double)baseValue;
if (DoubleUtil.IsNaN(value))
{
return(2.0);
}
return(baseValue);
}
/// <summary>
/// rectHasNaN - this returns true if this rect has X, Y , Height or Width as NaN.
/// </summary>
/// <param name="r">The rectangle to test
/// <returns>returns whether the Rect has NaN</returns>
public static bool RectHasNaN(Rect r)
{
if (DoubleUtil.IsNaN(r.X) ||
DoubleUtil.IsNaN(r.Y) ||
DoubleUtil.IsNaN(r.Height) ||
DoubleUtil.IsNaN(r.Width))
{
return(true);
}
return(false);
}
// Token: 0x06004879 RID: 18553 RVA: 0x001499A4 File Offset: 0x00147BA4
private static object OnCoerceHeight(DependencyObject d, object baseValue)
{
double value = (double)baseValue;
DataGridColumnFloatingHeader dataGridColumnFloatingHeader = (DataGridColumnFloatingHeader)d;
if (dataGridColumnFloatingHeader._referenceHeader != null && DoubleUtil.IsNaN(value))
{
return(dataGridColumnFloatingHeader._referenceHeader.ActualHeight + dataGridColumnFloatingHeader.GetVisualCanvasMarginY());
}
return(baseValue);
}
// Token: 0x0600486F RID: 18543 RVA: 0x00149778 File Offset: 0x00147978
private static object OnCoerceHeight(DependencyObject d, object baseValue)
{
double value = (double)baseValue;
DataGridColumnDropSeparator dataGridColumnDropSeparator = (DataGridColumnDropSeparator)d;
if (dataGridColumnDropSeparator._referenceHeader != null && DoubleUtil.IsNaN(value))
{
return(dataGridColumnDropSeparator._referenceHeader.ActualHeight);
}
return(baseValue);
}
private static object OnCoerceWidth(DependencyObject d, object baseValue)
{
double width = (double)baseValue;
DataGridColumnFloatingHeader header = (DataGridColumnFloatingHeader)d;
if (header._referenceHeader != null && DoubleUtil.IsNaN(width))
{
return(header._referenceHeader.ActualWidth + header.GetVisualCanvasMarginX());
}
return(baseValue);
}
/// <summary>Arranges the content of a <see cref="T:System.Windows.Controls.WrapPanel" /> element.</summary>
/// <param name="finalSize">The <see cref="T:System.Windows.Size" /> that this element should use to arrange its child elements.</param>
/// <returns>The <see cref="T:System.Windows.Size" /> that represents the arranged size of this <see cref="T:System.Windows.Controls.WrapPanel" /> element and its children.</returns>
// Token: 0x06005B53 RID: 23379 RVA: 0x0019BE90 File Offset: 0x0019A090
protected override Size ArrangeOverride(Size finalSize)
{
int num = 0;
double itemWidth = this.ItemWidth;
double itemHeight = this.ItemHeight;
double num2 = 0.0;
double itemU = (this.Orientation == Orientation.Horizontal) ? itemWidth : itemHeight;
WrapPanel.UVSize uvsize = new WrapPanel.UVSize(this.Orientation);
WrapPanel.UVSize uvsize2 = new WrapPanel.UVSize(this.Orientation, finalSize.Width, finalSize.Height);
bool flag = !DoubleUtil.IsNaN(itemWidth);
bool flag2 = !DoubleUtil.IsNaN(itemHeight);
bool useItemU = (this.Orientation == Orientation.Horizontal) ? flag : flag2;
UIElementCollection internalChildren = base.InternalChildren;
int i = 0;
int count = internalChildren.Count;
while (i < count)
{
UIElement uielement = internalChildren[i];
if (uielement != null)
{
WrapPanel.UVSize uvsize3 = new WrapPanel.UVSize(this.Orientation, flag ? itemWidth : uielement.DesiredSize.Width, flag2 ? itemHeight : uielement.DesiredSize.Height);
if (DoubleUtil.GreaterThan(uvsize.U + uvsize3.U, uvsize2.U))
{
this.arrangeLine(num2, uvsize.V, num, i, useItemU, itemU);
num2 += uvsize.V;
uvsize = uvsize3;
if (DoubleUtil.GreaterThan(uvsize3.U, uvsize2.U))
{
this.arrangeLine(num2, uvsize3.V, i, ++i, useItemU, itemU);
num2 += uvsize3.V;
uvsize = new WrapPanel.UVSize(this.Orientation);
}
num = i;
}
else
{
uvsize.U += uvsize3.U;
uvsize.V = Math.Max(uvsize3.V, uvsize.V);
}
}
i++;
}
if (num < internalChildren.Count)
{
this.arrangeLine(num2, uvsize.V, num, internalChildren.Count, useItemU, itemU);
}
return(finalSize);
}
public VirtualizationCacheLength(double cacheBeforeViewport, double cacheAfterViewport)
{
if (DoubleUtil.IsNaN(cacheBeforeViewport))
{
throw new ArgumentException(SR.Get(SRID.InvalidCtorParameterNoNaN, "cacheBeforeViewport"));
}
if (DoubleUtil.IsNaN(cacheAfterViewport))
{
throw new ArgumentException(SR.Get(SRID.InvalidCtorParameterNoNaN, "cacheAfterViewport"));
}
_cacheBeforeViewport = cacheBeforeViewport;
_cacheAfterViewport = cacheAfterViewport;
}
// Token: 0x06004876 RID: 18550 RVA: 0x00149878 File Offset: 0x00147A78
private static void OnWidthChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
DataGridColumnFloatingHeader dataGridColumnFloatingHeader = (DataGridColumnFloatingHeader)d;
double num = (double)e.NewValue;
if (dataGridColumnFloatingHeader._visualBrushCanvas != null && !DoubleUtil.IsNaN(num))
{
VisualBrush visualBrush = dataGridColumnFloatingHeader._visualBrushCanvas.Background as VisualBrush;
if (visualBrush != null)
{
Rect viewbox = visualBrush.Viewbox;
visualBrush.Viewbox = new Rect(viewbox.X, viewbox.Y, num - dataGridColumnFloatingHeader.GetVisualCanvasMarginX(), viewbox.Height);
}
}
}
private static void OnHeightChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
DataGridColumnFloatingHeader header = (DataGridColumnFloatingHeader)d;
double height = (double)e.NewValue;
if (header._visualBrushCanvas != null && !DoubleUtil.IsNaN(height))
{
VisualBrush brush = header._visualBrushCanvas.Background as VisualBrush;
if (brush != null)
{
Rect viewBox = brush.Viewbox;
brush.Viewbox = new Rect(viewBox.X, viewBox.Y, viewBox.Width, height - header.GetVisualCanvasMarginY());
}
}
}
/// <summary>Measures the child elements of a <see cref="T:System.Windows.Controls.WrapPanel" /> in anticipation of arranging them during the <see cref="M:System.Windows.Controls.WrapPanel.ArrangeOverride(System.Windows.Size)" /> pass.</summary>
/// <param name="constraint">An upper limit <see cref="T:System.Windows.Size" /> that should not be exceeded.</param>
/// <returns>The <see cref="T:System.Windows.Size" /> that represents the desired size of the element.</returns>
// Token: 0x06005B52 RID: 23378 RVA: 0x0019BC88 File Offset: 0x00199E88
protected override Size MeasureOverride(Size constraint)
{
WrapPanel.UVSize uvsize = new WrapPanel.UVSize(this.Orientation);
WrapPanel.UVSize uvsize2 = new WrapPanel.UVSize(this.Orientation);
WrapPanel.UVSize uvsize3 = new WrapPanel.UVSize(this.Orientation, constraint.Width, constraint.Height);
double itemWidth = this.ItemWidth;
double itemHeight = this.ItemHeight;
bool flag = !DoubleUtil.IsNaN(itemWidth);
bool flag2 = !DoubleUtil.IsNaN(itemHeight);
Size availableSize = new Size(flag ? itemWidth : constraint.Width, flag2 ? itemHeight : constraint.Height);
UIElementCollection internalChildren = base.InternalChildren;
int i = 0;
int count = internalChildren.Count;
while (i < count)
{
UIElement uielement = internalChildren[i];
if (uielement != null)
{
uielement.Measure(availableSize);
WrapPanel.UVSize uvsize4 = new WrapPanel.UVSize(this.Orientation, flag ? itemWidth : uielement.DesiredSize.Width, flag2 ? itemHeight : uielement.DesiredSize.Height);
if (DoubleUtil.GreaterThan(uvsize.U + uvsize4.U, uvsize3.U))
{
uvsize2.U = Math.Max(uvsize.U, uvsize2.U);
uvsize2.V += uvsize.V;
uvsize = uvsize4;
if (DoubleUtil.GreaterThan(uvsize4.U, uvsize3.U))
{
uvsize2.U = Math.Max(uvsize4.U, uvsize2.U);
uvsize2.V += uvsize4.V;
uvsize = new WrapPanel.UVSize(this.Orientation);
}
}
else
{
uvsize.U += uvsize4.U;
uvsize.V = Math.Max(uvsize4.V, uvsize.V);
}
}
i++;
}
uvsize2.U = Math.Max(uvsize.U, uvsize2.U);
uvsize2.V += uvsize.V;
return(new Size(uvsize2.Width, uvsize2.Height));
}
/// <summary>Creates a new instance of the <see cref="T:System.Windows.Controls.VirtualizationCacheLength" /> class with the specified cache lengths for each side of the viewport.</summary>
/// <param name="cacheBeforeViewport">The size of the cache before the viewport.</param>
/// <param name="cacheAfterViewport">The size of the cache after the viewport.</param>
// Token: 0x06005401 RID: 21505 RVA: 0x001749D4 File Offset: 0x00172BD4
public VirtualizationCacheLength(double cacheBeforeViewport, double cacheAfterViewport)
{
if (DoubleUtil.IsNaN(cacheBeforeViewport))
{
throw new ArgumentException(SR.Get("InvalidCtorParameterNoNaN", new object[]
{
"cacheBeforeViewport"
}));
}
if (DoubleUtil.IsNaN(cacheAfterViewport))
{
throw new ArgumentException(SR.Get("InvalidCtorParameterNoNaN", new object[]
{
"cacheAfterViewport"
}));
}
this._cacheBeforeViewport = cacheBeforeViewport;
this._cacheAfterViewport = cacheAfterViewport;
}
/// <summary>
/// Invalidates a cell's panel if its column's width changes sufficiently.
/// </summary>
/// <param name="cell">The cell or header.</param>
/// <param name="e"></param>
public static void OnColumnWidthChanged(IProvideDataGridColumn cell, DependencyPropertyChangedEventArgs e)
{
Debug.Assert((cell is DataGridCell) || (cell is DataGridColumnHeader), "provideColumn should be one of the cell or header containers.");
UIElement element = (UIElement)cell;
DataGridColumn column = cell.Column;
bool isColumnHeader = (cell is DataGridColumnHeader);
if (column != null)
{
// determine the desired value of width for auto kind columns
DataGridLength width = column.Width;
if (width.IsAuto ||
(!isColumnHeader && width.IsSizeToCells) ||
(isColumnHeader && width.IsSizeToHeader))
{
DataGridLength oldWidth = (DataGridLength)e.OldValue;
double desiredWidth = 0.0;
if (oldWidth.UnitType != width.UnitType)
{
double constraintWidth = column.GetConstraintWidth(isColumnHeader);
if (!DoubleUtil.AreClose(element.DesiredSize.Width, constraintWidth))
{
element.InvalidateMeasure();
element.Measure(new Size(constraintWidth, double.PositiveInfinity));
}
desiredWidth = element.DesiredSize.Width;
}
else
{
desiredWidth = oldWidth.DesiredValue;
}
if (DoubleUtil.IsNaN(width.DesiredValue) ||
DoubleUtil.LessThan(width.DesiredValue, desiredWidth))
{
column.SetWidthInternal(new DataGridLength(width.Value, width.UnitType, desiredWidth, width.DisplayValue));
}
}
}
}
/// <summary>Arranges the content of a <see cref="T:System.Windows.Controls.Canvas" /> element.</summary>
/// <param name="arrangeSize">The size that this <see cref="T:System.Windows.Controls.Canvas" /> element should use to arrange its child elements.</param>
/// <returns>A <see cref="T:System.Windows.Size" /> that represents the arranged size of this <see cref="T:System.Windows.Controls.Canvas" /> element and its descendants.</returns>
// Token: 0x06004335 RID: 17205 RVA: 0x00133674 File Offset: 0x00131874
protected override Size ArrangeOverride(Size arrangeSize)
{
foreach (object obj in base.InternalChildren)
{
UIElement uielement = (UIElement)obj;
if (uielement != null)
{
double x = 0.0;
double y = 0.0;
double left = Canvas.GetLeft(uielement);
if (!DoubleUtil.IsNaN(left))
{
x = left;
}
else
{
double right = Canvas.GetRight(uielement);
if (!DoubleUtil.IsNaN(right))
{
x = arrangeSize.Width - uielement.DesiredSize.Width - right;
}
}
double top = Canvas.GetTop(uielement);
if (!DoubleUtil.IsNaN(top))
{
y = top;
}
else
{
double bottom = Canvas.GetBottom(uielement);
if (!DoubleUtil.IsNaN(bottom))
{
y = arrangeSize.Height - uielement.DesiredSize.Height - bottom;
}
}
uielement.Arrange(new Rect(new Point(x, y), uielement.DesiredSize));
}
}
return(arrangeSize);
}
/// <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");
}
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>
/// Attempts to convert to a DataGridLength from the given object.
/// </summary>
/// <param name="context">The ITypeDescriptorContext for this call.</param>
/// <param name="culture">The CultureInfo which is respected when converting.</param>
/// <param name="value">The object to convert to a DataGridLength.</param>
/// <returns>The DataGridLength instance which was constructed.</returns>
/// <exception cref="ArgumentNullException">
/// An ArgumentNullException is thrown if the source is null.
/// </exception>
/// <exception cref="ArgumentException">
/// An ArgumentException is thrown if the source is not null
/// and is not a valid type which can be converted to a DataGridLength.
/// </exception>
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (value != null)
{
string stringSource = value as string;
if (stringSource != null)
{
// Convert from string
return(ConvertFromString(stringSource, culture));
}
else
{
// Conversion from numeric type
DataGridLengthUnitType type;
double doubleValue = Convert.ToDouble(value, culture);
if (DoubleUtil.IsNaN(doubleValue))
{
// This allows for conversion from Width / Height = "Auto"
doubleValue = 1.0;
type = DataGridLengthUnitType.Auto;
}
else
{
type = DataGridLengthUnitType.Pixel;
}
if (!Double.IsInfinity(doubleValue))
{
return(new DataGridLength(doubleValue, type));
}
}
}
// The default exception to throw in ConvertFrom
throw GetConvertFromException(value);
}
/// <summary>
/// <see cref="DependencyProperty.ValidateValueCallback"/>
/// </summary>
/// <remarks>
/// This method needs to be internal to be accessable from derived classes.
/// </remarks>
internal static bool IsUserMaxSizePropertyValueValid(object value)
{
double v = (double)value;
return(!DoubleUtil.IsNaN(v) && v >= 0.0d);
}
/// <summary>
/// <see cref="DependencyProperty.ValidateValueCallback"/>
/// </summary>
/// <remarks>
/// This method needs to be internal to be accessable from derived classes.
/// </remarks>
internal static bool IsUserMinSizePropertyValueValid(object value)
{
double v = (double)value;
return(!DoubleUtil.IsNaN(v) && v >= 0.0d && !Double.IsPositiveInfinity(v));
}
// Token: 0x06004A5E RID: 19038 RVA: 0x0014FB78 File Offset: 0x0014DD78
internal static bool IsUserMaxSizePropertyValueValid(object value)
{
double num = (double)value;
return(!DoubleUtil.IsNaN(num) && num >= 0.0);
}
// Token: 0x06004A5C RID: 19036 RVA: 0x0014FB14 File Offset: 0x0014DD14
internal static bool IsUserMinSizePropertyValueValid(object value)
{
double num = (double)value;
return(!DoubleUtil.IsNaN(num) && num >= 0.0 && !double.IsPositiveInfinity(num));
}
//-------------------------------------------------------------------
//
// Public Methods
//
//-------------------------------------------------------------------
#region Public Methods
#endregion
//-------------------------------------------------------------------
//
// Public Properties + Dependency Properties's
//
//-------------------------------------------------------------------
#region Public Properties
private static bool IsWidthHeightValid(object value)
{
double v = (double)value;
return((DoubleUtil.IsNaN(v)) || (v >= 0.0d && !Double.IsPositiveInfinity(v)));
}
