AttachedPropertyBrowsableForTypeAttribute.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 / Base / System / Windows / AttachedPropertyBrowsableForTypeAttribute.cs / 1 / AttachedPropertyBrowsableForTypeAttribute.cs
                        

                        
                             
namespace System.Windows
{
    using System;
 
    /// 
    ///     This class declares that an attached property is browsable only 
    ///     for dependency objects that derive from the given type.  If more 
    ///     than one type is specified, the property is browsable if any type
    ///     matches (logical or).  The type may also be an interface. 
    /// 
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
    public sealed class AttachedPropertyBrowsableForTypeAttribute : AttachedPropertyBrowsableAttribute
    { 
        //------------------------------------------------------
        // 
        //  Constructors 
        //
        //----------------------------------------------------- 


        /// 
        ///     Creates a new AttachedPropertyBrowsableForTypeAttribute.  Provide the type 
        ///     you want the attached property to be browsable for.  Multiple
        ///     attributes may be used to provide support for more than one 
        ///     type. 
        /// 
        public AttachedPropertyBrowsableForTypeAttribute(Type targetType) 
        {
            if (targetType == null) throw new ArgumentNullException("targetType");
            _targetType = targetType;
        } 

 
        //----------------------------------------------------- 
        //
        //  Public Properties 
        //
        //-----------------------------------------------------

 
        /// 
        ///     Returns the type passed into the constructor. 
        ///  
        public Type TargetType
        { 
            get
            {
                return _targetType;
            } 
        }
 
 
        /// 
        ///     For AllowMultiple attributes, TypeId must be unique for 
        ///     each unique instance.  The default returns the type, which
        ///     is only correct for AllowMultiple == false.
        /// 
        public override object TypeId 
        {
            get 
            { 
                return this;
            } 
        }


        //------------------------------------------------------ 
        //
        //  Public Methods 
        // 
        //-----------------------------------------------------
 
        /// 
        ///     Overrides Object.Equals to implement correct equality semantics for this
        ///     attribute.
        ///  
        public override bool Equals(object obj)
        { 
            AttachedPropertyBrowsableForTypeAttribute other = obj as AttachedPropertyBrowsableForTypeAttribute; 
            if (other == null) return false;
            return _targetType == other._targetType; 
        }

        /// 
        ///     Overrides Object.GetHashCode to implement correct hashing semantics. 
        /// 
        public override int GetHashCode() 
        { 
            return _targetType.GetHashCode();
        } 


        //------------------------------------------------------
        // 
        //  Internal Methods
        // 
        //------------------------------------------------------ 

 
        /// 
        ///     Returns true if the dependency object passed to the method is a type,
        ///     subtype or implememts the interface of any of the the types contained
        ///     in this object. 
        /// 
        internal override bool IsBrowsable(DependencyObject d, DependencyProperty dp) 
        { 
            if (d == null) throw new ArgumentNullException("d");
            if (dp == null) throw new ArgumentNullException("dp"); 

            // Get the dependency object type for our target type.
            // We cannot assume the user didn't follow the guidelines and
            // feed us a type that is not a dependency object, but that is 
            // rare enough that it is worth the try/catch here rather than
            // a double IsAssignableFrom (one here, and one in DependencyObjectType). 
            // We still use a flag here rather than checking for a null 
            // _dTargetType so that a bad property that throws won't consistently
            // slow the system down with ArgumentExceptions. 

            if (!_dTargetTypeChecked)
            {
                try 
                {
                    _dTargetType = DependencyObjectType.FromSystemType(_targetType); 
                } 
                catch(ArgumentException)
                { 
                }

                _dTargetTypeChecked = true;
            } 

 
            if (_dTargetType != null && _dTargetType.IsInstanceOfType(d)) 
            {
                return true; 
            }

            return false;
        } 

        ///  
        ///     Returns true if a browsable match is true if any one of multiple 
        ///     instances of the same type return true for IsBrowsable.  We override
        ///     this to return true because any one of a successfull match for 
        ///     IsBrowsable is accepted.
        /// 
        internal override bool UnionResults
        { 
            get
            { 
                return true; 
            }
        } 

        //-----------------------------------------------------
        //
        //  Private Fields 
        //
        //------------------------------------------------------ 
 
        private Type _targetType;
        private DependencyObjectType _dTargetType; 
        private bool _dTargetTypeChecked;
    }
}
 

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