Jumar Macato
7 years ago
6 changed files with 606 additions and 58 deletions
@ -0,0 +1,43 @@ |
|||||
|
// Licensed to the .NET Foundation under one or more agreements.
|
||||
|
// The .NET Foundation licenses this file to you under the MIT license.
|
||||
|
|
||||
|
using System.Collections; |
||||
|
using System.Diagnostics; |
||||
|
|
||||
|
namespace Avalonia.Controls |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Collection of shared states objects for a single scope
|
||||
|
/// </summary>
|
||||
|
internal class SharedSizeScope |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Returns SharedSizeState object for a given group.
|
||||
|
/// Creates a new StatedState object if necessary.
|
||||
|
/// </summary>
|
||||
|
internal SharedSizeState EnsureSharedState(string sharedSizeGroup) |
||||
|
{ |
||||
|
// check that sharedSizeGroup is not default
|
||||
|
Debug.Assert(sharedSizeGroup != null); |
||||
|
|
||||
|
SharedSizeState sharedState = _registry[sharedSizeGroup] as SharedSizeState; |
||||
|
if (sharedState == null) |
||||
|
{ |
||||
|
sharedState = new SharedSizeState(this, sharedSizeGroup); |
||||
|
_registry[sharedSizeGroup] = sharedState; |
||||
|
} |
||||
|
return (sharedState); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Removes an entry in the registry by the given key.
|
||||
|
/// </summary>
|
||||
|
internal void Remove(object key) |
||||
|
{ |
||||
|
Debug.Assert(_registry.Contains(key)); |
||||
|
_registry.Remove(key); |
||||
|
} |
||||
|
|
||||
|
private Hashtable _registry = new Hashtable(); // storage for shared state objects
|
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,209 @@ |
|||||
|
// Licensed to the .NET Foundation under one or more agreements.
|
||||
|
// The .NET Foundation licenses this file to you under the MIT license.
|
||||
|
|
||||
|
using System; |
||||
|
using System.Collections.Generic; |
||||
|
using System.Diagnostics; |
||||
|
using Avalonia.Utilities; |
||||
|
|
||||
|
namespace Avalonia.Controls |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Implementation of per shared group state object
|
||||
|
/// </summary>
|
||||
|
internal class SharedSizeState |
||||
|
{ |
||||
|
private readonly SharedSizeScope _sharedSizeScope; // the scope this state belongs to
|
||||
|
private readonly string _sharedSizeGroupId; // Id of the shared size group this object is servicing
|
||||
|
private readonly List<DefinitionBase> _registry; // registry of participating definitions
|
||||
|
private readonly EventHandler _layoutUpdated; // instance event handler for layout updated event
|
||||
|
private Control _layoutUpdatedHost; // Control for which layout updated event handler is registered
|
||||
|
private bool _broadcastInvalidation; // "true" when broadcasting of invalidation is needed
|
||||
|
private bool _userSizeValid; // "true" when _userSize is up to date
|
||||
|
private GridLength _userSize; // shared state
|
||||
|
private double _minSize; // shared state
|
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Default ctor.
|
||||
|
/// </summary>
|
||||
|
internal SharedSizeState(SharedSizeScope sharedSizeScope, string sharedSizeGroupId) |
||||
|
{ |
||||
|
Debug.Assert(sharedSizeScope != null && sharedSizeGroupId != null); |
||||
|
_sharedSizeScope = sharedSizeScope; |
||||
|
_sharedSizeGroupId = sharedSizeGroupId; |
||||
|
_registry = new List<DefinitionBase>(); |
||||
|
_layoutUpdated = new EventHandler(OnLayoutUpdated); |
||||
|
_broadcastInvalidation = true; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Adds / registers a definition instance.
|
||||
|
/// </summary>
|
||||
|
internal void AddMember(DefinitionBase member) |
||||
|
{ |
||||
|
Debug.Assert(!_registry.Contains(member)); |
||||
|
_registry.Add(member); |
||||
|
Invalidate(); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Removes / un-registers a definition instance.
|
||||
|
/// </summary>
|
||||
|
/// <remarks>
|
||||
|
/// If the collection of registered definitions becomes empty
|
||||
|
/// instantiates self removal from owner's collection.
|
||||
|
/// </remarks>
|
||||
|
internal void RemoveMember(DefinitionBase member) |
||||
|
{ |
||||
|
Invalidate(); |
||||
|
_registry.Remove(member); |
||||
|
|
||||
|
if (_registry.Count == 0) |
||||
|
{ |
||||
|
_sharedSizeScope.Remove(_sharedSizeGroupId); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Propogates invalidations for all registered definitions.
|
||||
|
/// Resets its own state.
|
||||
|
/// </summary>
|
||||
|
internal void Invalidate() |
||||
|
{ |
||||
|
_userSizeValid = false; |
||||
|
|
||||
|
if (_broadcastInvalidation) |
||||
|
{ |
||||
|
for (int i = 0, count = _registry.Count; i < count; ++i) |
||||
|
{ |
||||
|
Grid parentGrid = (Grid)(_registry[i].Parent); |
||||
|
parentGrid.Invalidate(); |
||||
|
} |
||||
|
_broadcastInvalidation = false; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Makes sure that one and only one layout updated handler is registered for this shared state.
|
||||
|
/// </summary>
|
||||
|
internal void EnsureDeferredValidation(Control layoutUpdatedHost) |
||||
|
{ |
||||
|
if (_layoutUpdatedHost == null) |
||||
|
{ |
||||
|
_layoutUpdatedHost = layoutUpdatedHost; |
||||
|
_layoutUpdatedHost.LayoutUpdated += _layoutUpdated; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// DefinitionBase's specific code.
|
||||
|
/// </summary>
|
||||
|
internal double MinSize |
||||
|
{ |
||||
|
get |
||||
|
{ |
||||
|
if (!_userSizeValid) { EnsureUserSizeValid(); } |
||||
|
return (_minSize); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// DefinitionBase's specific code.
|
||||
|
/// </summary>
|
||||
|
internal GridLength UserSize |
||||
|
{ |
||||
|
get |
||||
|
{ |
||||
|
if (!_userSizeValid) { EnsureUserSizeValid(); } |
||||
|
return (_userSize); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void EnsureUserSizeValid() |
||||
|
{ |
||||
|
_userSize = new GridLength(1, GridUnitType.Auto); |
||||
|
|
||||
|
for (int i = 0, count = _registry.Count; i < count; ++i) |
||||
|
{ |
||||
|
Debug.Assert(_userSize.GridUnitType == GridUnitType.Auto |
||||
|
|| _userSize.GridUnitType == GridUnitType.Pixel); |
||||
|
|
||||
|
GridLength currentGridLength = _registry[i].UserSizeValueCache; |
||||
|
if (currentGridLength.GridUnitType == GridUnitType.Pixel) |
||||
|
{ |
||||
|
if (_userSize.GridUnitType == GridUnitType.Auto) |
||||
|
{ |
||||
|
_userSize = currentGridLength; |
||||
|
} |
||||
|
else if (_userSize.Value < currentGridLength.Value) |
||||
|
{ |
||||
|
_userSize = currentGridLength; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
// taking maximum with user size effectively prevents squishy-ness.
|
||||
|
// this is a "solution" to avoid shared definitions from been sized to
|
||||
|
// different final size at arrange time, if / when different grids receive
|
||||
|
// different final sizes.
|
||||
|
_minSize = _userSize.IsAbsolute ? _userSize.Value : 0.0; |
||||
|
|
||||
|
_userSizeValid = 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 = !MathUtilities.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 (!MathUtilities.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 (!MathUtilities.AreClose(sharedMinSize, definitionBase.SizeCache)) |
||||
|
{ |
||||
|
Grid parentGrid = (Grid)definitionBase.Parent; |
||||
|
parentGrid.InvalidateArrange(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
definitionBase.LayoutWasUpdated = false; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
_minSize = sharedMinSize; |
||||
|
|
||||
|
_layoutUpdatedHost.LayoutUpdated -= _layoutUpdated; |
||||
|
_layoutUpdatedHost = null; |
||||
|
|
||||
|
_broadcastInvalidation = true; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
Loading…
Reference in new issue