RoutedEventHandlerInfo.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 / Core / System / Windows / RoutedEventHandlerInfo.cs / 1 / RoutedEventHandlerInfo.cs
                        

                        
                            using System; 

namespace System.Windows
{
    ///  
    ///     Container for handler instance and other
    ///     invocation preferences for this handler 
    ///     instance 
    /// 
    ///  
    ///     RoutedEventHandlerInfo constitutes the
    ///     handler instance and flag that indicates if
    ///     or not this handler must be invoked for
    ///     already handled events  
    ///     
    /// 
    ///     This class needs to be public because it is 
    ///     used by ContentElement in the Framework
    ///     to store Instance EventHandlers 
    /// 
    //CASRemoval:[StrongNameIdentityPermission(SecurityAction.LinkDemand, PublicKey = Microsoft.Internal.BuildInfo.WCP_PUBLIC_KEY_STRING)]
    public struct RoutedEventHandlerInfo
    { 
        #region Construction
 
        ///  
        ///     Construtor for RoutedEventHandlerInfo
        ///  
        /// 
        ///     Non-null handler
        /// 
        ///  
        ///     Flag that indicates if or not the handler must
        ///     be invoked for already handled events 
        ///  
        internal RoutedEventHandlerInfo(Delegate handler, bool handledEventsToo)
        { 
            _handler = handler;
            _handledEventsToo = handledEventsToo;
        }
 
        #endregion Construction
 
        #region Operations 

        ///  
        ///     Returns associated handler instance
        /// 
        public Delegate Handler
        { 
            get {return _handler;}
        } 
 
        /// 
        ///     Returns HandledEventsToo Flag 
        /// 
        public bool InvokeHandledEventsToo
        {
            get {return _handledEventsToo;} 
        }
 
        // Invokes handler instance as per specified 
        // invocation preferences
        internal void InvokeHandler(object target, RoutedEventArgs routedEventArgs) 
        {
            if ((routedEventArgs.Handled == false) || (_handledEventsToo == true))
            {
                if (_handler is RoutedEventHandler) 
                {
                    // Generic RoutedEventHandler is called directly here since 
                    //  we don't need the InvokeEventHandler override to cast to 
                    //  the proper type - we know what it is.
                    ((RoutedEventHandler)_handler)(target, routedEventArgs); 
                }
                else
                {
                    // NOTE: Cannot call protected method InvokeEventHandler directly 
                    routedEventArgs.InvokeHandler(_handler, target);
                } 
            } 
        }
 
        /// 
        ///     Is the given object equivalent to the current one
        /// 
        public override bool Equals(object obj) 
        {
            if (obj == null || !(obj is RoutedEventHandlerInfo)) 
                return false; 

            return Equals((RoutedEventHandlerInfo)obj); 
        }

        /// 
        ///     Is the given RoutedEventHandlerInfo equals the current 
        /// 
        public bool Equals(RoutedEventHandlerInfo handlerInfo) 
        { 
            return _handler == handlerInfo._handler && _handledEventsToo == handlerInfo._handledEventsToo;
        } 

        /// 
        ///     Serves as a hash function for a particular type, suitable for use in
        ///     hashing algorithms and data structures like a hash table 
        /// 
        public override int GetHashCode() 
        { 
            return base.GetHashCode();
        } 

        /// 
        ///     Equals operator overload
        ///  
        public static bool operator== (RoutedEventHandlerInfo handlerInfo1, RoutedEventHandlerInfo handlerInfo2)
        { 
            return handlerInfo1.Equals(handlerInfo2); 
        }
 
        /// 
        ///     NotEquals operator overload
        /// 
        public static bool operator!= (RoutedEventHandlerInfo handlerInfo1, RoutedEventHandlerInfo handlerInfo2) 
        {
            return !handlerInfo1.Equals(handlerInfo2); 
        } 

        ///  
        ///     Cleanup all the references within the data
        /// 
        /*
        Commented out to avoid "uncalled private code" fxcop violation 
        internal void Clear()
        { 
            _handler = null; 
            _handledEventsToo = false;
        } 
        */

        #endregion Operations
 
        #region Data
 
        private Delegate _handler; 
        private bool _handledEventsToo;
 
        #endregion Data
    }
}
 

// 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