SizeChangedEventArgs.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Framework / System / Windows / SizeChangedEventArgs.cs / 1 / SizeChangedEventArgs.cs
                        

                        
                             
using System;

namespace System.Windows
{ 
    /// 
    ///  The SizeChangedEventArgs class is used by SizeChangedEventHandler. 
    ///  This handler is used for ComputedWidthChanged and ComputedHeightChanged events 
    ///  on UIElement.
    ///  
    public class SizeChangedEventArgs : RoutedEventArgs
    {
        /// 
        ///     Initializes a new instance of the SizeChangedEventArgs class. 
        /// 
        ///  
        ///     The UIElement which has its size changed by layout engine/>. 
        /// 
        ///  
        ///     The SizeChangeInfo that is used by .
        /// 
        internal SizeChangedEventArgs(UIElement element, SizeChangedInfo info)
        { 
            if (info == null)
            { 
                throw new ArgumentNullException("info"); 
            }
            if (element == null) 
            {
                throw new ArgumentNullException("element");
            }
            _element = element; 
            _previousSize = info.PreviousSize;
            if(info.WidthChanged) _bits |= _widthChangedBit; 
            if(info.HeightChanged) _bits |= _heightChangedBit; 
        }
 
        /// 
        /// Read-only access to the previous Size
        /// 
        public Size PreviousSize 
        {
            get { return _previousSize; } 
        } 

        ///  
        /// Read-only access to the new Size
        /// 
        public Size NewSize
        { 
            get { return _element.RenderSize; }
        } 
 
        /// 
        /// 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. 
        ///  
        public bool WidthChanged
        { 
            get { return ((_bits & _widthChangedBit) != 0); }
        }

        ///  
        /// 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.
        /// 
        public bool HeightChanged 
        {
            get { return ((_bits & _heightChangedBit) != 0); } 
        } 

        private Size _previousSize; 
        private UIElement _element;
        private byte _bits;

        private static byte _widthChangedBit = 0x1; 
        private static byte _heightChangedBit = 0x2;
 
        ///  
        ///     The mechanism used to call the type-specific handler on the
        ///     target. 
        /// 
        /// 
        ///     The generic handler to call in a type-specific way.
        ///  
        /// 
        ///     The target to call the handler on. 
        ///  
        /// 
        protected override void InvokeEventHandler(Delegate genericHandler, object genericTarget) 
        {
            SizeChangedEventHandler handler = (SizeChangedEventHandler) genericHandler;

            handler(genericTarget, this); 
        }
    } 
} 

 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK