// Token: 0x06008770 RID: 34672 RVA: 0x0024FBDC File Offset: 0x0024DDDC
private void ValidateSharedSizeGroup()
{
double num = 0.0;
int i = 0;
int count = this._registry.Count;
while (i < count)
{
num = Math.Max(num, this._registry[i]._minSize);
i++;
}
bool flag = !DoubleUtil.AreClose(this._minSize, num);
int j = 0;
int count2 = this._registry.Count;
while (j < count2)
{
DefinitionBase definitionBase = this._registry[j];
bool flag2 = !DoubleUtil.AreClose(definitionBase._minSize, num);
bool flag3;
if (!definitionBase.UseSharedMinimum)
{
flag3 = !flag2;
}
else if (flag2)
{
flag3 = !flag;
}
else
{
flag3 = (definitionBase.LayoutWasUpdated && DoubleUtil.GreaterThanOrClose(definitionBase._minSize, this.MinSize));
}
if (!flag3)
{
Grid grid = (Grid)definitionBase.Parent;
grid.InvalidateMeasure();
}
else if (!DoubleUtil.AreClose(num, definitionBase.SizeCache))
{
Grid grid2 = (Grid)definitionBase.Parent;
grid2.InvalidateArrange();
}
definitionBase.UseSharedMinimum = flag2;
definitionBase.LayoutWasUpdated = false;
j++;
}
this._minSize = num;
this._layoutUpdatedHost.LayoutUpdated -= this._layoutUpdated;
this._layoutUpdatedHost = null;
this._broadcastInvalidation = true;
}
/// <summary>
/// OnLayoutUpdated handler. Validates that all participating definitions
/// have updated min size value. Forces another layout update cycle if needed.
/// </summary>
private void OnLayoutUpdated(object sender, EventArgs e)
{
double sharedMinSize = 0;
// accumulate min size of all participating definitions
for (int i = 0, count = _registry.Count; i < count; ++i)
{
sharedMinSize = Math.Max(sharedMinSize, _registry[i].MinSize);
}
bool sharedMinSizeChanged = !DoubleUtil.AreClose(_minSize, sharedMinSize);
// compare accumulated min size with min sizes of the individual definitions
for (int i = 0, count = _registry.Count; i < count; ++i)
{
DefinitionBase definitionBase = _registry[i];
if (sharedMinSizeChanged || definitionBase.LayoutWasUpdated)
{
// if definition's min size is different, then need to re-measure
if (!DoubleUtil.AreClose(sharedMinSize, definitionBase.MinSize))
{
Grid parentGrid = (Grid)definitionBase.Parent;
parentGrid.InvalidateMeasure();
definitionBase.UseSharedMinimum = true;
}
else
{
definitionBase.UseSharedMinimum = false;
// if measure is valid then also need to check arrange.
// Note: definitionBase.SizeCache is volatile but at this point
// it contains up-to-date final size
if (!DoubleUtil.AreClose(sharedMinSize, definitionBase.SizeCache))
{
Grid parentGrid = (Grid)definitionBase.Parent;
parentGrid.InvalidateArrange();
}
}
definitionBase.LayoutWasUpdated = false;
}
}
_minSize = sharedMinSize;
_layoutUpdatedHost.LayoutUpdated -= _layoutUpdated;
_layoutUpdatedHost = null;
_broadcastInvalidation = true;
}
// Token: 0x06008771 RID: 34673 RVA: 0x0024FD2C File Offset: 0x0024DF2C
private void ValidateSharedSizeGroupLegacy()
{
double num = 0.0;
int i = 0;
int count = this._registry.Count;
while (i < count)
{
num = Math.Max(num, this._registry[i].MinSize);
i++;
}
bool flag = !DoubleUtil.AreClose(this._minSize, num);
int j = 0;
int count2 = this._registry.Count;
while (j < count2)
{
DefinitionBase definitionBase = this._registry[j];
if (flag || definitionBase.LayoutWasUpdated)
{
if (!DoubleUtil.AreClose(num, definitionBase.MinSize))
{
Grid grid = (Grid)definitionBase.Parent;
grid.InvalidateMeasure();
definitionBase.UseSharedMinimum = true;
}
else
{
definitionBase.UseSharedMinimum = false;
if (!DoubleUtil.AreClose(num, definitionBase.SizeCache))
{
Grid grid2 = (Grid)definitionBase.Parent;
grid2.InvalidateArrange();
}
}
definitionBase.LayoutWasUpdated = false;
}
j++;
}
this._minSize = num;
this._layoutUpdatedHost.LayoutUpdated -= this._layoutUpdated;
this._layoutUpdatedHost = null;
this._broadcastInvalidation = true;
}
private static void InitGrid(Grid grid, DtoTableViewModel vm)
{
if (vm != null && grid != null)
{
grid.RowDefinitions.Clear();
grid.ColumnDefinitions.Clear();
foreach (var row in vm.Rows)
{
grid.RowDefinitions.Add(new RowDefinition());
}
foreach (var col in vm.Columns)
{
grid.ColumnDefinitions.Add(new ColumnDefinition() { SharedSizeGroup = "col" + col.Column.ToString() });
}
grid.InvalidateArrange();
grid.UpdateLayout();
}
}
// Calculated content height
protected virtual void initialChildren()
{
double w = System.Windows.Application.Current.Host.Content.ActualWidth;
topShadow = GetTemplateChild("TopShadow") as Rectangle;
bottomShadow = GetTemplateChild("BottomShadow") as Rectangle;
contentView = GetTemplateChild("ContentView") as Grid;
buttonContainer = GetTemplateChild("ButtonContainer") as StackPanel;
curtain = GetTemplateChild("Curtain") as Rectangle;
// Add an optional title label
titleLabel = null;
if (title != null)
{
titleLabel = new TextBlock();
titleLabel.Text = title;
titleLabel.Foreground = new SolidColorBrush(Color.FromArgb(0xff, 0x00, 0xd9, 0xf3));
titleLabel.FontSize = 42;
titleLabel.HorizontalAlignment = HorizontalAlignment.Center;
titleLabel.TextWrapping = TextWrapping.Wrap;
titleLabel.TextAlignment = TextAlignment.Center;
titleLabel.Margin = new Thickness(0, 8, 0, 8);
titleLabel.SetValue(Grid.RowProperty, 0);
contentView.Children.Add(titleLabel);
}
// Add any custom content
if (contentElement != null)
{
contentElement.SetValue(Grid.RowProperty, 1);
contentView.Children.Add(contentElement);
contentView.InvalidateArrange();
contentView.UpdateLayout();
double measuredWidth = contentElement.ActualWidth + contentElement.Margin.Left + contentElement.Margin.Right;
double measuredHeight = 0;
if (titleLabel != null)
{
measuredHeight += titleLabel.ActualHeight;
}
double contentHeight = Math.Max(contentElement.ActualHeight, contentElement.Height);
if(!double.IsNaN(contentHeight))
measuredHeight += contentHeight + contentElement.Margin.Top + contentElement.Margin.Bottom;
else
measuredHeight += 240 + contentElement.Margin.Top + contentElement.Margin.Bottom;
expectedContentSize = new Size(measuredWidth, measuredHeight);
}
else
{
expectedContentSize = new Size(w, 240);
}
// Add custom buttons
if (buttonTitles.Count > 0)
{
foreach (string buttonTitle in buttonTitles)
{
var button = new Avarice.Controls.Button();
button.Content = buttonTitle;
button.Margin = new Thickness(20, 0, 20, 0);
button.HorizontalAlignment = HorizontalAlignment.Right;
buttonContainer.Children.Add(button);
button.Click += OnButtonClick;
}
}
else if(Buttons.Count > 0)
{
foreach (var button in Buttons)
{
button.Margin = new Thickness(20, 0, 20, 0);
button.HorizontalAlignment = HorizontalAlignment.Right;
buttonContainer.Children.Add(button);
button.Click += OnButtonClick;
}
}
}
private static void RebuildGridChildren(Grid grid)
{
int column = 0;
int row = 0;
var columnCount = GetColumns(grid);
for (int i = 0; i < grid.Children.Count; i++)
{
var child = grid.Children[i];
if (child == null) continue;
Grid.SetColumn(child, column);
Grid.SetRow(child, row);
column++;
if (column >= columnCount)
{
column = 0;
row++;
}
}
grid.InvalidateArrange();
grid.InvalidateVisual();
}
/// <summary>
/// OnLayoutUpdated handler. Validates that all participating definitions
/// have updated min size value. Forces another layout update cycle if needed.
/// </summary>
private void OnLayoutUpdated(object sender, EventArgs e)
{
double sharedMinSize = 0;
// accumulate min size of all participating definitions
for (int i = 0, count = _registry.Count; i < count; ++i)
{
sharedMinSize = Math.Max(sharedMinSize, _registry[i]._minSize);
}
bool sharedMinSizeChanged = !DoubleUtil.AreClose(_minSize, sharedMinSize);
// compare accumulated min size with min sizes of the individual definitions
for (int i = 0, count = _registry.Count; i < count; ++i)
{
DefinitionBase definitionBase = _registry[i];
// we'll set d.UseSharedMinimum to maintain the invariant:
// d.UseSharedMinimum iff d._minSize < this.MinSize
// i.e. iff d is not a "long-pole" definition.
//
// Measure/Arrange of d's Grid uses d._minSize for long-pole
// definitions, and max(d._minSize, shared size) for
// short-pole definitions. This distinction allows us to react
// to changes in "long-pole-ness" more efficiently and correctly,
// by avoiding remeasures when a long-pole definition changes.
bool useSharedMinimum = !DoubleUtil.AreClose(definitionBase._minSize, sharedMinSize);
// before doing that, determine whether d's Grid needs to be remeasured.
// It's important _not_ to remeasure if the last measure is still
// valid, otherwise infinite loops are possible
bool measureIsValid;
if (!definitionBase.UseSharedMinimum)
{
// d was a long-pole. measure is valid iff it's still a long-pole,
// since previous measure didn't use shared size.
measureIsValid = !useSharedMinimum;
}
else if (useSharedMinimum)
{
// d was a short-pole, and still is. measure is valid
// iff the shared size didn't change
measureIsValid = !sharedMinSizeChanged;
}
else
{
// d was a short-pole, but is now a long-pole. This can
// happen in several ways:
// a. d's minSize increased to or past the old shared size
// b. other long-pole definitions decreased, leaving
// d as the new winner
// In the former case, the measure is valid - it used
// d's new larger minSize. In the latter case, the
// measure is invalid - it used the old shared size,
// which is larger than d's (possibly changed) minSize
measureIsValid = (definitionBase.LayoutWasUpdated &&
DoubleUtil.GreaterThanOrClose(definitionBase._minSize, this.MinSize));
}
if (!measureIsValid)
{
Grid parentGrid = (Grid)definitionBase.Parent;
parentGrid.InvalidateMeasure();
}
else if (!DoubleUtil.AreClose(sharedMinSize, definitionBase.SizeCache))
{
// if measure is valid then also need to check arrange.
// Note: definitionBase.SizeCache is volatile but at this point
// it contains up-to-date final size
Grid parentGrid = (Grid)definitionBase.Parent;
parentGrid.InvalidateArrange();
}
// now we can restore the invariant, and clear the layout flag
definitionBase.UseSharedMinimum = useSharedMinimum;
definitionBase.LayoutWasUpdated = false;
}
_minSize = sharedMinSize;
_layoutUpdatedHost.LayoutUpdated -= _layoutUpdated;
_layoutUpdatedHost = null;
_broadcastInvalidation = true;
}
