Animatable.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / Orcas / NetFXw7 / wpf / src / Core / CSharp / System / Windows / Media / Animation / Animatable.cs / 1 / Animatable.cs

                            //------------------------------------------------------------------------------ 
//  Microsoft Avalon
//  Copyright (c) Microsoft Corporation, 2003
//
//  File: Animatable.cs 
//-----------------------------------------------------------------------------
 
// Allow suppression of certain presharp messages 
#pragma warning disable 1634, 1691
 
using MS.Internal;
using MS.Utility;
using System;
using System.Collections; 
using System.Collections.Generic;
using System.Diagnostics; 
using System.Windows.Threading; 
using System.Windows.Media.Composition;
 
using SR = MS.Internal.PresentationCore.SR;
using SRID = MS.Internal.PresentationCore.SRID;

namespace System.Windows.Media.Animation 
{
    ///  
    /// This class derives from Freezable and adds the ability to animate properties. 
    /// 
    public abstract partial class Animatable : Freezable, IAnimatable, DUCE.IResource 
    {
        #region Constructors

        ///  
        ///
        ///  
        protected Animatable() 
        {
        } 

        #endregion

        #region Realization Support 
        /// 
        /// Precompute is called during the frame preparation phase. Derived classes 
        /// typically check if the brush requires realizations during this phase. 
        /// 
        internal virtual void Precompute() 
        {
            return;
        }
 
        /// 
        /// Checks if realization updates are requried for this resource. 
        ///  
        internal virtual bool RequiresRealizationUpdates
        { 
            get { return false; }
            set {}
        }
        #endregion 

        #region Public 
 
        /// 
        /// Creates a copy of this Animatable. 
        /// 
        /// The copy.
        public new Animatable Clone()
        { 
            return (Animatable)base.Clone();
        } 
 
        /// 
        /// Determines whether this node can introduce a graph into the 
        /// scene. Default to false and intended to be overriden by
        /// the appropriate classes
        /// 
        /// True if this node can introduce graphness, else false 
        internal virtual bool CanIntroduceGraphness()
        { 
            return false; 
        }
 
        internal void PropertyChanged(DependencyProperty dp)
        {
            AnimationStorage animationStorage = AnimationStorage.GetStorage(this, dp);
            IndependentAnimationStorage independentAnimationStorage = animationStorage as IndependentAnimationStorage; 

            // If this property is independently animated and currently has 
            // animations all we need to do is update the animation resource 
            // that represents this property value. Otherwise we need to invalidate
            // and and eventually update this whole object. 
            if (independentAnimationStorage != null)
            {
                independentAnimationStorage.InvalidateResource();
            } 
            else
            { 
                RegisterForAsyncUpdateResource(); 
            }
        } 

        internal virtual void AddRefOnChannelAnimations(DUCE.Channel channel)
        {
            if (IAnimatable_HasAnimatedProperties) 
            {
                FrugalMap animatedPropertiesMap = AnimationStorage.GetAnimatedPropertiesMap(this); 
 
                Debug.Assert(animatedPropertiesMap.Count > 0);
 
                for (int i = 0; i < animatedPropertiesMap.Count; i++)
                {
                    Int32   dpGlobalIndex;
                    Object  storageObject; 

                    animatedPropertiesMap.GetKeyValuePair(i, out dpGlobalIndex, out storageObject); 
 
                    DUCE.IResource storage = storageObject as DUCE.IResource;
 
                    if (storage != null)
                    {
                        storage.AddRefOnChannel(channel);
                    } 
                }
            } 
        } 

        internal virtual void ReleaseOnChannelAnimations(DUCE.Channel channel) 
        {
            if (IAnimatable_HasAnimatedProperties)
            {
                FrugalMap animatedPropertiesMap = AnimationStorage.GetAnimatedPropertiesMap(this); 

                Debug.Assert(animatedPropertiesMap.Count > 0); 
 
                for (int i = 0; i < animatedPropertiesMap.Count; i++)
                { 
                    Int32 dpGlobalIndex;
                    Object storageObject;

                    animatedPropertiesMap.GetKeyValuePair(i, out dpGlobalIndex, out storageObject); 

                    DUCE.IResource storage = storageObject as DUCE.IResource; 
 
                    if (storage != null)
                    { 
                        storage.ReleaseOnChannel(channel);
                    }
                }
            } 
        }
 
        #region LocalProperty/CachedValue stuff 

        internal static DependencyProperty RegisterProperty( 
            string name,
            Type propertyType,
            Type ownerType,
            object defaultValue, 
            PropertyChangedCallback changed,
            ValidateValueCallback validate, 
            bool isIndependentlyAnimated, 
            CoerceValueCallback coerced)
        { 
            // Override metadata for this particular object type. This defines
            // the methods that will be called when property actions (setting,
            // getting, invalidating) are taken for this specific object type.
 
            UIPropertyMetadata propertyMetadata;
 
            // If this property is animated using a property resource, we create 
            // AnimatablePropertyMetadata instead of UIPropertyMetadata.
 
            if (isIndependentlyAnimated)
            {
                propertyMetadata = new IndependentlyAnimatedPropertyMetadata(defaultValue);
            } 
            else
            { 
                propertyMetadata = new UIPropertyMetadata(defaultValue); 
            }
 
            propertyMetadata.PropertyChangedCallback = changed;

            if (coerced != null)
            { 
                propertyMetadata.CoerceValueCallback = coerced;
            } 
 
            // Register property with passed in default metadata.  The type of
            // defaultMetadata will determine whether this property is animatable. 
            DependencyProperty dp = DependencyProperty.Register(
                name,
                propertyType,
                ownerType, 
                propertyMetadata,
                validate); 
 
            return dp;
        } 

        // Helpers for addref and release of local properties.  Subclasses can provide
        // overloads.
        internal void AddRefResource(DUCE.IResource resource, DUCE.Channel channel) 
        {
            if (resource != null) 
            { 
                resource.AddRefOnChannel(channel);
            } 
        }

        internal void ReleaseResource(DUCE.IResource resource, DUCE.Channel channel)
        { 
            if (resource != null)
            { 
                resource.ReleaseOnChannel(channel); 
            }
        } 

        #endregion LocalProperty/CachedValue stuff

        #endregion 

        #region Protected 
 
        /// 
        /// An Animatable will return false from this method if there are any Clocks 
        /// animating any of its properties. If the Animatable has persistent animations
        /// specified, but all of the Clocks have been removed, it may still return
        /// true from this method if the Timelines themselves can be frozen.
        ///  
        /// 
        /// True if the Freezable should actually Freeze itself; false if 
        /// the Freezable should simply return whether it can be frozen. 
        /// True if this object can be frozen; otherwise false.
        protected override bool FreezeCore(bool isChecking) 
        {
            if (IAnimatable_HasAnimatedProperties)
            {
                if (TraceFreezable.IsEnabled) 
                {
                    TraceFreezable.Trace( 
                        TraceEventType.Warning, 
                        TraceFreezable.UnableToFreezeAnimatedProperties,
                        this); 
                }

                return false;
            } 

            return base.FreezeCore(isChecking); 
        } 

        #endregion 

        #region IResource

        ///  
        /// Derived classes implement this function.
        ///  
        DUCE.ResourceHandle DUCE.IResource.AddRefOnChannel(DUCE.Channel channel) 
        {
            // Just return null instead of throwing an exception, since some 
            // derived classes like BitmapEffect do their own addref/release.
            return DUCE.ResourceHandle.Null;
        }
 
        /// 
        /// Derived classes implement this function. 
        ///  
        void DUCE.IResource.ReleaseOnChannel(DUCE.Channel channel)
        { 
            // Just return instead of throwing an exception, since some
            // derived classes like BitmapEffect do their own addref/release.
        }
 
        /// 
        /// Derived classes implement this function. 
        ///  
        DUCE.ResourceHandle DUCE.IResource.GetHandle(DUCE.Channel channel)
        { 
            // Just return null instead of throwing an exception, since some
            // derived classes like BitmapEffect do their own addref/release.
            return DUCE.ResourceHandle.Null;
        } 

        ///  
        /// Derived classes implement this function. 
        /// 
        int DUCE.IResource.GetChannelCount() 
        {
            return 0;
        }
 
        /// 
        /// Derived classes implement this function. 
        ///  
        DUCE.Channel DUCE.IResource.GetChannel(int index)
        { 
            return null;
        }

        ///  
        /// This is only implemented by Visual and Visual3D.
        ///  
        DUCE.ResourceHandle DUCE.IResource.Get3DHandle(DUCE.Channel channel) 
        {
            throw new NotImplementedException(); 
        }

        /// 
        /// This is only implemented by Visual and Visual3D. 
        /// 
        void DUCE.IResource.RemoveChildFromParent(DUCE.IResource parent, DUCE.Channel channel) 
        { 
            throw new NotImplementedException();
        } 

        #endregion

 
        #region Internal
 
 
        internal DUCE.ResourceHandle GetAnimationResourceHandle(DependencyProperty dp, DUCE.Channel channel)
        { 
            if (channel != null && IAnimatable_HasAnimatedProperties)
            {
                return IndependentAnimationStorage.GetResourceHandle(this, dp, channel);
            } 
            else
            { 
                return DUCE.ResourceHandle.Null; 
            }
        } 

        /// 
        /// Returns a WeakReference to this Animatable that can be used by
        /// anyone who needs one. 
        /// 
        ///  
        /// The WeakReference isn't created or stored until this method is 
        /// called.
        ///  
        /// A WeakReference to this Animtable.
        internal WeakReference GetWeakReference()
        {
            object reference = StoredWeakReferenceField.GetValue(this); 

            if (reference == null) 
            { 
                reference = new WeakReference(this);
 
                StoredWeakReferenceField.SetValue(this, (WeakReference)reference);
            }

            Debug.Assert(reference is WeakReference); 

            return (WeakReference)reference; 
        } 

        ///  
        /// IsBaseValueDefault returns true if there is no local value specified for this DP.
        /// 
        /// The property for which the local value is checked.
        internal bool IsBaseValueDefault(DependencyProperty dp) 
        {
            return ReadLocalValue(dp) == DependencyProperty.UnsetValue; 
        } 

        ///  
        /// Every time something changes, we don't want to send resource
        /// updates to the UCE, we only really want to do it once per UIThread
        /// render.
        /// Calling this will make sure that a resource update request 
        /// is registered with the MediaContext.
        /// If this object doesn't have context affinity, it's unlikely 
        /// that resource update requests would ever be made, however if they 
        /// are the request will happen immediately.
        ///  
        internal void RegisterForAsyncUpdateResource()
        {
            DUCE.IResource resource = this as DUCE.IResource;
 
            if (resource != null)
            { 
                if ((Dispatcher != null) && Animatable_IsResourceInvalidationNecessary) 
                {
                    MediaContext mediaContext = MediaContext.From(Dispatcher); 

                    //
                    // Only register for a deferred resource update if this
                    // is actually on the channel. 
                    //
                    if (!resource.GetHandle(mediaContext.Channel).IsNull) 
                    { 

                        // Add this handler to this event means that the handler will be 
                        // called on the next UIThread render for this Dispatcher.
                        mediaContext.ResourcesUpdated += new MediaContext.ResourcesUpdatedHandler(UpdateResource);
                        Animatable_IsResourceInvalidationNecessary = false;
                    } 
                }
            } 
        } 

        ///  
        /// UpdateResource - this implements the prototype required by ResourcesUpdatedHandler
        /// The method which implements this prototype is also often called in situations where
        /// the resource is known to be "on channel" - in those cases, "true" is passed for the second
        /// parameter (allowing the implementation to skip the check). 
        /// 
        internal virtual void UpdateResource(DUCE.Channel channel, bool skipOnChannelCheck) 
        { 
            Animatable_IsResourceInvalidationNecessary = true;
        } 

        /// 
        /// WritePreamble for objects such as AnimationCollection and
        /// TimelineCollection which modify an Animatable from the outside. 
        /// 
        internal void InternalWritePreamble() 
        { 
            WritePreamble();
        } 

        #endregion

        #region Private 

        ///  
        /// We use this property to store the a WeakReference to this Animatable 
        /// that can be used by anyone who needs a WeakReference.  It won't be
        /// created until its requested using the GetWeakReference method. 
        /// 
        private static readonly UncommonField StoredWeakReferenceField
            = new UncommonField();
 
        /// 
        /// This method is used by TypeDescriptor to determine if this property should 
        /// be serialized. 
        /// 
        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] 
        public static bool ShouldSerializeStoredWeakReference(DependencyObject target)
        {
            return false;
        } 

        #endregion 
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------ 
//  Microsoft Avalon
//  Copyright (c) Microsoft Corporation, 2003
//
//  File: Animatable.cs 
//-----------------------------------------------------------------------------
 
// Allow suppression of certain presharp messages 
#pragma warning disable 1634, 1691
 
using MS.Internal;
using MS.Utility;
using System;
using System.Collections; 
using System.Collections.Generic;
using System.Diagnostics; 
using System.Windows.Threading; 
using System.Windows.Media.Composition;
 
using SR = MS.Internal.PresentationCore.SR;
using SRID = MS.Internal.PresentationCore.SRID;

namespace System.Windows.Media.Animation 
{
    ///  
    /// This class derives from Freezable and adds the ability to animate properties. 
    /// 
    public abstract partial class Animatable : Freezable, IAnimatable, DUCE.IResource 
    {
        #region Constructors

        ///  
        ///
        ///  
        protected Animatable() 
        {
        } 

        #endregion

        #region Realization Support 
        /// 
        /// Precompute is called during the frame preparation phase. Derived classes 
        /// typically check if the brush requires realizations during this phase. 
        /// 
        internal virtual void Precompute() 
        {
            return;
        }
 
        /// 
        /// Checks if realization updates are requried for this resource. 
        ///  
        internal virtual bool RequiresRealizationUpdates
        { 
            get { return false; }
            set {}
        }
        #endregion 

        #region Public 
 
        /// 
        /// Creates a copy of this Animatable. 
        /// 
        /// The copy.
        public new Animatable Clone()
        { 
            return (Animatable)base.Clone();
        } 
 
        /// 
        /// Determines whether this node can introduce a graph into the 
        /// scene. Default to false and intended to be overriden by
        /// the appropriate classes
        /// 
        /// True if this node can introduce graphness, else false 
        internal virtual bool CanIntroduceGraphness()
        { 
            return false; 
        }
 
        internal void PropertyChanged(DependencyProperty dp)
        {
            AnimationStorage animationStorage = AnimationStorage.GetStorage(this, dp);
            IndependentAnimationStorage independentAnimationStorage = animationStorage as IndependentAnimationStorage; 

            // If this property is independently animated and currently has 
            // animations all we need to do is update the animation resource 
            // that represents this property value. Otherwise we need to invalidate
            // and and eventually update this whole object. 
            if (independentAnimationStorage != null)
            {
                independentAnimationStorage.InvalidateResource();
            } 
            else
            { 
                RegisterForAsyncUpdateResource(); 
            }
        } 

        internal virtual void AddRefOnChannelAnimations(DUCE.Channel channel)
        {
            if (IAnimatable_HasAnimatedProperties) 
            {
                FrugalMap animatedPropertiesMap = AnimationStorage.GetAnimatedPropertiesMap(this); 
 
                Debug.Assert(animatedPropertiesMap.Count > 0);
 
                for (int i = 0; i < animatedPropertiesMap.Count; i++)
                {
                    Int32   dpGlobalIndex;
                    Object  storageObject; 

                    animatedPropertiesMap.GetKeyValuePair(i, out dpGlobalIndex, out storageObject); 
 
                    DUCE.IResource storage = storageObject as DUCE.IResource;
 
                    if (storage != null)
                    {
                        storage.AddRefOnChannel(channel);
                    } 
                }
            } 
        } 

        internal virtual void ReleaseOnChannelAnimations(DUCE.Channel channel) 
        {
            if (IAnimatable_HasAnimatedProperties)
            {
                FrugalMap animatedPropertiesMap = AnimationStorage.GetAnimatedPropertiesMap(this); 

                Debug.Assert(animatedPropertiesMap.Count > 0); 
 
                for (int i = 0; i < animatedPropertiesMap.Count; i++)
                { 
                    Int32 dpGlobalIndex;
                    Object storageObject;

                    animatedPropertiesMap.GetKeyValuePair(i, out dpGlobalIndex, out storageObject); 

                    DUCE.IResource storage = storageObject as DUCE.IResource; 
 
                    if (storage != null)
                    { 
                        storage.ReleaseOnChannel(channel);
                    }
                }
            } 
        }
 
        #region LocalProperty/CachedValue stuff 

        internal static DependencyProperty RegisterProperty( 
            string name,
            Type propertyType,
            Type ownerType,
            object defaultValue, 
            PropertyChangedCallback changed,
            ValidateValueCallback validate, 
            bool isIndependentlyAnimated, 
            CoerceValueCallback coerced)
        { 
            // Override metadata for this particular object type. This defines
            // the methods that will be called when property actions (setting,
            // getting, invalidating) are taken for this specific object type.
 
            UIPropertyMetadata propertyMetadata;
 
            // If this property is animated using a property resource, we create 
            // AnimatablePropertyMetadata instead of UIPropertyMetadata.
 
            if (isIndependentlyAnimated)
            {
                propertyMetadata = new IndependentlyAnimatedPropertyMetadata(defaultValue);
            } 
            else
            { 
                propertyMetadata = new UIPropertyMetadata(defaultValue); 
            }
 
            propertyMetadata.PropertyChangedCallback = changed;

            if (coerced != null)
            { 
                propertyMetadata.CoerceValueCallback = coerced;
            } 
 
            // Register property with passed in default metadata.  The type of
            // defaultMetadata will determine whether this property is animatable. 
            DependencyProperty dp = DependencyProperty.Register(
                name,
                propertyType,
                ownerType, 
                propertyMetadata,
                validate); 
 
            return dp;
        } 

        // Helpers for addref and release of local properties.  Subclasses can provide
        // overloads.
        internal void AddRefResource(DUCE.IResource resource, DUCE.Channel channel) 
        {
            if (resource != null) 
            { 
                resource.AddRefOnChannel(channel);
            } 
        }

        internal void ReleaseResource(DUCE.IResource resource, DUCE.Channel channel)
        { 
            if (resource != null)
            { 
                resource.ReleaseOnChannel(channel); 
            }
        } 

        #endregion LocalProperty/CachedValue stuff

        #endregion 

        #region Protected 
 
        /// 
        /// An Animatable will return false from this method if there are any Clocks 
        /// animating any of its properties. If the Animatable has persistent animations
        /// specified, but all of the Clocks have been removed, it may still return
        /// true from this method if the Timelines themselves can be frozen.
        ///  
        /// 
        /// True if the Freezable should actually Freeze itself; false if 
        /// the Freezable should simply return whether it can be frozen. 
        /// True if this object can be frozen; otherwise false.
        protected override bool FreezeCore(bool isChecking) 
        {
            if (IAnimatable_HasAnimatedProperties)
            {
                if (TraceFreezable.IsEnabled) 
                {
                    TraceFreezable.Trace( 
                        TraceEventType.Warning, 
                        TraceFreezable.UnableToFreezeAnimatedProperties,
                        this); 
                }

                return false;
            } 

            return base.FreezeCore(isChecking); 
        } 

        #endregion 

        #region IResource

        ///  
        /// Derived classes implement this function.
        ///  
        DUCE.ResourceHandle DUCE.IResource.AddRefOnChannel(DUCE.Channel channel) 
        {
            // Just return null instead of throwing an exception, since some 
            // derived classes like BitmapEffect do their own addref/release.
            return DUCE.ResourceHandle.Null;
        }
 
        /// 
        /// Derived classes implement this function. 
        ///  
        void DUCE.IResource.ReleaseOnChannel(DUCE.Channel channel)
        { 
            // Just return instead of throwing an exception, since some
            // derived classes like BitmapEffect do their own addref/release.
        }
 
        /// 
        /// Derived classes implement this function. 
        ///  
        DUCE.ResourceHandle DUCE.IResource.GetHandle(DUCE.Channel channel)
        { 
            // Just return null instead of throwing an exception, since some
            // derived classes like BitmapEffect do their own addref/release.
            return DUCE.ResourceHandle.Null;
        } 

        ///  
        /// Derived classes implement this function. 
        /// 
        int DUCE.IResource.GetChannelCount() 
        {
            return 0;
        }
 
        /// 
        /// Derived classes implement this function. 
        ///  
        DUCE.Channel DUCE.IResource.GetChannel(int index)
        { 
            return null;
        }

        ///  
        /// This is only implemented by Visual and Visual3D.
        ///  
        DUCE.ResourceHandle DUCE.IResource.Get3DHandle(DUCE.Channel channel) 
        {
            throw new NotImplementedException(); 
        }

        /// 
        /// This is only implemented by Visual and Visual3D. 
        /// 
        void DUCE.IResource.RemoveChildFromParent(DUCE.IResource parent, DUCE.Channel channel) 
        { 
            throw new NotImplementedException();
        } 

        #endregion

 
        #region Internal
 
 
        internal DUCE.ResourceHandle GetAnimationResourceHandle(DependencyProperty dp, DUCE.Channel channel)
        { 
            if (channel != null && IAnimatable_HasAnimatedProperties)
            {
                return IndependentAnimationStorage.GetResourceHandle(this, dp, channel);
            } 
            else
            { 
                return DUCE.ResourceHandle.Null; 
            }
        } 

        /// 
        /// Returns a WeakReference to this Animatable that can be used by
        /// anyone who needs one. 
        /// 
        ///  
        /// The WeakReference isn't created or stored until this method is 
        /// called.
        ///  
        /// A WeakReference to this Animtable.
        internal WeakReference GetWeakReference()
        {
            object reference = StoredWeakReferenceField.GetValue(this); 

            if (reference == null) 
            { 
                reference = new WeakReference(this);
 
                StoredWeakReferenceField.SetValue(this, (WeakReference)reference);
            }

            Debug.Assert(reference is WeakReference); 

            return (WeakReference)reference; 
        } 

        ///  
        /// IsBaseValueDefault returns true if there is no local value specified for this DP.
        /// 
        /// The property for which the local value is checked.
        internal bool IsBaseValueDefault(DependencyProperty dp) 
        {
            return ReadLocalValue(dp) == DependencyProperty.UnsetValue; 
        } 

        ///  
        /// Every time something changes, we don't want to send resource
        /// updates to the UCE, we only really want to do it once per UIThread
        /// render.
        /// Calling this will make sure that a resource update request 
        /// is registered with the MediaContext.
        /// If this object doesn't have context affinity, it's unlikely 
        /// that resource update requests would ever be made, however if they 
        /// are the request will happen immediately.
        ///  
        internal void RegisterForAsyncUpdateResource()
        {
            DUCE.IResource resource = this as DUCE.IResource;
 
            if (resource != null)
            { 
                if ((Dispatcher != null) && Animatable_IsResourceInvalidationNecessary) 
                {
                    MediaContext mediaContext = MediaContext.From(Dispatcher); 

                    //
                    // Only register for a deferred resource update if this
                    // is actually on the channel. 
                    //
                    if (!resource.GetHandle(mediaContext.Channel).IsNull) 
                    { 

                        // Add this handler to this event means that the handler will be 
                        // called on the next UIThread render for this Dispatcher.
                        mediaContext.ResourcesUpdated += new MediaContext.ResourcesUpdatedHandler(UpdateResource);
                        Animatable_IsResourceInvalidationNecessary = false;
                    } 
                }
            } 
        } 

        ///  
        /// UpdateResource - this implements the prototype required by ResourcesUpdatedHandler
        /// The method which implements this prototype is also often called in situations where
        /// the resource is known to be "on channel" - in those cases, "true" is passed for the second
        /// parameter (allowing the implementation to skip the check). 
        /// 
        internal virtual void UpdateResource(DUCE.Channel channel, bool skipOnChannelCheck) 
        { 
            Animatable_IsResourceInvalidationNecessary = true;
        } 

        /// 
        /// WritePreamble for objects such as AnimationCollection and
        /// TimelineCollection which modify an Animatable from the outside. 
        /// 
        internal void InternalWritePreamble() 
        { 
            WritePreamble();
        } 

        #endregion

        #region Private 

        ///  
        /// We use this property to store the a WeakReference to this Animatable 
        /// that can be used by anyone who needs a WeakReference.  It won't be
        /// created until its requested using the GetWeakReference method. 
        /// 
        private static readonly UncommonField StoredWeakReferenceField
            = new UncommonField();
 
        /// 
        /// This method is used by TypeDescriptor to determine if this property should 
        /// be serialized. 
        /// 
        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] 
        public static bool ShouldSerializeStoredWeakReference(DependencyObject target)
        {
            return false;
        } 

        #endregion 
    } 
}

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