|
using System;
namespace System.Windows
{
/// <summary>
/// The SizeChangedinfo class is used as a parameter to OnSizeRenderChanged.
/// </summary>
public class SizeChangedInfo
{
/// <summary>
/// Initializes a new instance of the SizeChangedinfo class.
/// </summary>
/// <param name="element">
/// The element which size is changing.
/// </param>
/// <param name="previousSize">
/// The size of the object before update. New size is element.RenderSize
/// </param>
/// <param name="widthChanged">
/// The flag indicating that width component of the size changed. Note that due to double math
/// effects, the it may be (previousSize.Width != newSize.Width) and widthChanged = true.
/// This may happen in layout when sizes of objects are fluctuating because of a precision "jitter" of
/// the input parameters, but the overall scene is considered to be "the same" so no visible changes
/// will be detected. Typically, the handler of SizeChangedEvent should check this bit to avoid
/// invalidation of layout if the dimension didn't change.
/// </param>
/// <param name="heightChanged">
/// The flag indicating that height component of the size changed. Note that due to double math
/// effects, the it may be (previousSize.Height != newSize.Height) and heightChanged = true.
/// This may happen in layout when sizes of objects are fluctuating because of a precision "jitter" of
/// the input parameters, but the overall scene is considered to be "the same" so no visible changes
/// will be detected. Typically, the handler of SizeChangedEvent should check this bit to avoid
/// invalidation of layout if the dimension didn't change.
/// </param>
public SizeChangedInfo(UIElement element, Size previousSize, bool widthChanged, bool heightChanged)
{
_element = element;
_previousSize = previousSize;
_widthChanged = widthChanged;
_heightChanged = heightChanged;
}
/// <summary>
/// Read-only access to the previous Size
/// </summary>
public Size PreviousSize
{
get { return _previousSize; }
}
/// <summary>
/// Read-only access to the new Size
/// </summary>
public Size NewSize
{
get { return _element.RenderSize; }
}
/// <summary>
/// Read-only access to the flag indicating that Width component of the size changed.
/// Note that due to double math
/// effects, the it may be (previousSize.Width != newSize.Width) and widthChanged = true.
/// This may happen in layout when sizes of objects are fluctuating because of a precision "jitter" of
/// the input parameters, but the overall scene is considered to be "the same" so no visible changes
/// will be detected. Typically, the handler of SizeChangedEvent should check this bit to avoid
/// invalidation of layout if the dimension didn't change.
/// </summary>
public bool WidthChanged
{
get { return _widthChanged; }
}
/// <summary>
/// Read-only access to the flag indicating that Height component of the size changed.
/// Note that due to double math
/// effects, the it may be (previousSize.Height != newSize.Height) and heightChanged = true.
/// This may happen in layout when sizes of objects are fluctuating because of a precision "jitter" of
/// the input parameters, but the overall scene is considered to be "the same" so no visible changes
/// will be detected. Typically, the handler of SizeChangedEvent should check this bit to avoid
/// invalidation of layout if the dimension didn't change.
/// </summary>
public bool HeightChanged
{
get { return _heightChanged; }
}
//this method is used by UIElement to "accumulate" several cosequitive layout updates
//into the single args object cahced on UIElement. Since the SizeChanged is deferred event,
//there could be several size changes before it will actually fire.
internal void Update(bool widthChanged, bool heightChanged)
{
_widthChanged = _widthChanged | widthChanged;
_heightChanged = _heightChanged | heightChanged;
}
internal UIElement Element
{
get { return _element; }
}
private UIElement _element;
private Size _previousSize;
private bool _widthChanged;
private bool _heightChanged;
internal SizeChangedInfo Next;
}
}
|