FrameworkContentElement.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Framework / System / Windows / FrameworkContentElement.cs / 1305600 / FrameworkContentElement.cs

                            using System; 
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel; 

using System.Diagnostics; 
using System.Globalization; 
using System.Windows.Threading;
using System.Threading; 

using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents; 

using System.Windows.Input; 
using System.Windows.Media; 
using System.Windows.Media.Animation;
using System.Windows.Media.TextFormatting; 
using System.Windows.Markup;
using System.Security.Permissions;

#if DEBUG 
using System.Reflection;
#endif 
 
using MS.Internal.Text;
using MS.Internal; 
using MS.Internal.KnownBoxes;
using MS.Internal.PresentationFramework;
using MS.Utility;
 
// Disabling 1634 and 1691:
// In order to avoid generating warnings about unknown message numbers and 
// unknown pragmas when compiling C# source code with the C# compiler, 
// you need to disable warnings 1634 and 1691. (Presharp Documentation)
#pragma warning disable 1634, 1691 

namespace System.Windows
{
    ///  
    ///     FrameworkContentElement is used to define
    ///     structure of generic content. 
    ///  
    /// 
    ///     FrameworkContentElement doesnt have its own 
    ///     rendering (rendering must be provided by content
    ///     owner). 
    ///
    ///     FrameworkContentElement  
    ///
    ///      
    ///         Directly extends ContentElement  
    ///         Is not a Visual (doesnt provide its own rendering)
    ///      
    /// 
    [StyleTypedProperty(Property = "FocusVisualStyle", StyleTargetType = typeof(Control))]
    [XmlLangProperty("Language")]
    [UsableDuringInitialization(true)] 
    public partial class FrameworkContentElement : ContentElement, IFrameworkInputElement, ISupportInitialize, IQueryAmbient
    { 
        ///  
        ///     Create an instance of a FrameworkContentElement
        ///  
        /// 
        ///     This does basic initialization of the FrameworkContentElement.  All subclasses
        ///     must call the base constructor to perform this initialization
        ///  
        public FrameworkContentElement()
        { 
            // Initialize the _styleCache to the default value for StyleProperty. 
            // If the default value is non-null then wire it to the current instance.
            PropertyMetadata metadata = StyleProperty.GetMetadata(DependencyObjectType); 
            Style defaultValue = (Style)metadata.DefaultValue;
            if (defaultValue != null)
            {
                OnStyleChanged(this, new DependencyPropertyChangedEventArgs(StyleProperty, metadata, null, defaultValue)); 
            }
 
            // Set the ShouldLookupImplicitStyles flag to true if App.Resources has implicit styles. 
            Application app = Application.Current;
            if (app != null && app.HasImplicitStylesInResources) 
            {
                ShouldLookupImplicitStyles = true;
            }
        } 

        static FrameworkContentElement() 
        { 
            PropertyChangedCallback numberSubstitutionChanged = new PropertyChangedCallback(NumberSubstitutionChanged);
            NumberSubstitution.CultureSourceProperty.OverrideMetadata(typeof(FrameworkContentElement), new FrameworkPropertyMetadata(NumberCultureSource.Text, FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsRender, numberSubstitutionChanged)); 
            NumberSubstitution.CultureOverrideProperty.OverrideMetadata(typeof(FrameworkContentElement), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsRender, numberSubstitutionChanged));
            NumberSubstitution.SubstitutionProperty.OverrideMetadata(typeof(FrameworkContentElement), new FrameworkPropertyMetadata(NumberSubstitutionMethod.AsCulture, FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsRender, numberSubstitutionChanged));

            EventManager.RegisterClassHandler(typeof(FrameworkContentElement), Mouse.QueryCursorEvent, new QueryCursorEventHandler(FrameworkContentElement.OnQueryCursor), true); 

            AllowDropProperty.OverrideMetadata(typeof(FrameworkContentElement), new FrameworkPropertyMetadata(BooleanBoxes.FalseBox, FrameworkPropertyMetadataOptions.Inherits)); 
 
            Stylus.IsPressAndHoldEnabledProperty.AddOwner(typeof(FrameworkContentElement), new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, FrameworkPropertyMetadataOptions.Inherits));
            Stylus.IsFlicksEnabledProperty.AddOwner(typeof(FrameworkContentElement), new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, FrameworkPropertyMetadataOptions.Inherits)); 
            Stylus.IsTapFeedbackEnabledProperty.AddOwner(typeof(FrameworkContentElement), new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, FrameworkPropertyMetadataOptions.Inherits));
            Stylus.IsTouchFeedbackEnabledProperty.AddOwner(typeof(FrameworkContentElement), new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, FrameworkPropertyMetadataOptions.Inherits));

            // Exposing these events in protected virtual methods 
            EventManager.RegisterClassHandler(typeof(FrameworkContentElement), ToolTipOpeningEvent, new ToolTipEventHandler(OnToolTipOpeningThunk));
            EventManager.RegisterClassHandler(typeof(FrameworkContentElement), ToolTipClosingEvent, new ToolTipEventHandler(OnToolTipClosingThunk)); 
            EventManager.RegisterClassHandler(typeof(FrameworkContentElement), ContextMenuOpeningEvent, new ContextMenuEventHandler(OnContextMenuOpeningThunk)); 
            EventManager.RegisterClassHandler(typeof(FrameworkContentElement), ContextMenuClosingEvent, new ContextMenuEventHandler(OnContextMenuClosingThunk));
            EventManager.RegisterClassHandler(typeof(FrameworkContentElement), Keyboard.GotKeyboardFocusEvent, new KeyboardFocusChangedEventHandler(OnGotKeyboardFocus)); 
            EventManager.RegisterClassHandler(typeof(FrameworkContentElement), Keyboard.LostKeyboardFocusEvent, new KeyboardFocusChangedEventHandler(OnLostKeyboardFocus));
        }

        internal static readonly NumberSubstitution DefaultNumberSubstitution = new NumberSubstitution( 
            NumberCultureSource.Text,           // number substitution in documents defaults to text culture
            null,                               // culture override 
            NumberSubstitutionMethod.AsCulture 
            );
 
        private static void NumberSubstitutionChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
        {
            ((FrameworkContentElement) o).HasNumberSubstitutionChanged = true;
        } 

 
        /// Style Dependency Property 
        [CommonDependencyProperty]
        public static readonly DependencyProperty StyleProperty = 
                FrameworkElement.StyleProperty.AddOwner(
                        typeof(FrameworkContentElement),
                        new FrameworkPropertyMetadata(
                                (Style) null,  // default value 
                                FrameworkPropertyMetadataOptions.AffectsMeasure,
                                new PropertyChangedCallback(OnStyleChanged))); 
 

        ///  
        ///     Style property
        /// 
        public Style Style
        { 
            get { return _styleCache; }
            set { SetValue(StyleProperty, value); } 
        } 

        ///  
        /// This method is used by TypeDescriptor to determine if this property should
        /// be serialized.
        /// 
        [EditorBrowsable(EditorBrowsableState.Never)] 
        public bool ShouldSerializeStyle()
        { 
            return !IsStyleSetFromGenerator 
                    && ReadLocalValue(StyleProperty) != DependencyProperty.UnsetValue;
        } 

        // Invoked when the Style property is changed
        private static void OnStyleChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            FrameworkContentElement fce = (FrameworkContentElement) d;
            fce.HasLocalStyle = (e.NewEntry.BaseValueSourceInternal == BaseValueSourceInternal.Local); 
            StyleHelper.UpdateStyleCache(null, fce, (Style) e.OldValue, (Style) e.NewValue, ref fce._styleCache); 
        }
 
        ///
        protected internal virtual void OnStyleChanged(Style oldStyle, Style newStyle)
        {
            HasStyleChanged = true; 
        }
 
        ///  
        /// OverridesDefaultStyleProperty
        ///  
        public static readonly DependencyProperty OverridesDefaultStyleProperty
            = FrameworkElement.OverridesDefaultStyleProperty.AddOwner(typeof(FrameworkContentElement),
                                           new FrameworkPropertyMetadata(
                                                        BooleanBoxes.FalseBox,   // default value 
                                                        FrameworkPropertyMetadataOptions.AffectsMeasure,
                                                        new PropertyChangedCallback(OnThemeStyleKeyChanged))); 
 

        ///  
        ///     This specifies that the current style ignores all
        ///     properties from the Theme Style
        /// 
        public bool OverridesDefaultStyle 
        {
            get { return (bool)GetValue(OverridesDefaultStyleProperty); } 
            set { SetValue(OverridesDefaultStyleProperty, BooleanBoxes.Box(value)); } 
        }
 
        /// DefaultStyleKey Dependency Property
        protected internal static readonly DependencyProperty DefaultStyleKeyProperty =
                    FrameworkElement.DefaultStyleKeyProperty.AddOwner(
                                typeof(FrameworkContentElement), 
                                new FrameworkPropertyMetadata(
                                            null,  // default value 
                                            FrameworkPropertyMetadataOptions.AffectsMeasure, 
                                            new PropertyChangedCallback(OnThemeStyleKeyChanged)));
 
        /// 
        ///     DefaultStyleKey property
        /// 
        protected internal object DefaultStyleKey 
        {
            get { return GetValue(DefaultStyleKeyProperty); } 
            set { SetValue(DefaultStyleKeyProperty, value); } 
        }
 
        // This function is called when ThemeStyleKey or OverridesThemeStyle properties change
        private static void OnThemeStyleKeyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            // Re-evaluate ThemeStyle because it is 
            // a factor of the ThemeStyleKey property
            ((FrameworkContentElement)d).UpdateThemeStyleProperty(); 
        } 

        // Cache the ThemeStyle for the current instance if there is a DefaultStyleKey specified for it 
        internal Style ThemeStyle
        {
            get { return _themeStyleCache; }
        } 

        // Returns the DependencyObjectType for the registered DefaultStyleKey's default 
        // value. Controls will override this method to return approriate types. 
        internal virtual DependencyObjectType DTypeThemeStyleKey
        { 
            get { return null; }
        }

 
        // Invoked when the ThemeStyle/DefaultStyleKey property is changed
        internal static void OnThemeStyleChanged(DependencyObject d, object oldValue, object newValue) 
        { 
            FrameworkContentElement fce = (FrameworkContentElement) d;
            StyleHelper.UpdateThemeStyleCache(null, fce, (Style) oldValue, (Style) newValue, ref fce._themeStyleCache); 
        }


        ///  
        ///     Reference to the style parent of this node, if any.
        ///  
        ///  
        ///     Reference to FrameworkElement or FrameworkContentElement whose
        ///     Template.VisualTree caused this FrameworkContentElement to be created. 
        /// 
        public DependencyObject TemplatedParent
        {
            get 
            {
                return _templatedParent; 
            } 
        }
 

        /// 
        ///     Check if resource is not empty.
        /// Call HasResources before accessing resources every time you need 
        /// to query for a resource.
        ///  
        internal bool HasResources 
        {
            get 
            {
                ResourceDictionary resources = ResourcesField.GetValue(this);
                return (resources != null &&
                        ((resources.Count > 0) || (resources.MergedDictionaries.Count > 0))); 
            }
        } 
 
        /// 
        ///     Current locally defined Resources 
        /// 
        [Ambient]
        public ResourceDictionary Resources
        { 
            get
            { 
                ResourceDictionary resources = ResourcesField.GetValue(this); 
                if (resources == null)
                { 
                    resources = new ResourceDictionary();
                    resources.AddOwner(this);
                    ResourcesField.SetValue(this, resources);
                } 

                return resources; 
            } 
            set
            { 
                ResourceDictionary oldValue = ResourcesField.GetValue(this);
                ResourcesField.SetValue(this, value);

                if (oldValue != null) 
                {
                    // This element is no longer an owner for the old RD 
                    oldValue.RemoveOwner(this); 
                }
 
                if (value != null)
                {
                    if (!value.ContainsOwner(this))
                    { 
                        // This element is an owner for the new RD
                        value.AddOwner(this); 
                    } 
                }
 
                // Invalidate ResourceReference properties for this subtree
                //

 

 
 
                if (oldValue != value)
                { 
                    TreeWalkHelper.InvalidateOnResourcesChange(null, this, new ResourcesChangeInfo(oldValue, value));
                }
            }
        } 

        bool IQueryAmbient.IsAmbientPropertyAvailable(string propertyName) 
        { 
            // We want to make sure that StaticResource resolution checks the .Resources
            // Ie.  The Ambient search should look at Resources if it is set. 
            // Even if it wasn't set from XAML (eg. the Ctor (or derived Ctor) added stuff)
            return (propertyName != "Resources" || HasResources);
        }
 
        /// 
        /// This method is used by TypeDescriptor to determine if this property should 
        /// be serialized. 
        /// 
        [EditorBrowsable(EditorBrowsableState.Never)] 
        public bool ShouldSerializeResources()
        {
            if (Resources == null || Resources.Count == 0)
            { 
                return false;
            } 
 
            return true;
        } 


        /// 
        ///     Searches for a resource with the passed resourceKey and returns it 
        /// 
        ///  
        ///     If the sources is not found on the called Element, the parent 
        ///     chain is searched, using the logical tree.
        ///  
        /// Name of the resource
        /// The found resource.  Null if not found.
        public object FindResource(object resourceKey)
        { 
            // Verify Context Access
            //             VerifyAccess(); 
 
            if (resourceKey == null)
            { 
                throw new ArgumentNullException("resourceKey");
            }

            object resource = FrameworkElement.FindResourceInternal(null /* fe */, this, resourceKey); 

            if (resource == DependencyProperty.UnsetValue) 
            { 
                // Resource not found in parent chain, app or system
                Helper.ResourceFailureThrow(resourceKey); 
            }

            return resource;
        } 

        ///  
        ///     Searches for a resource with the passed resourceKey and returns it 
        /// 
        ///  
        ///     If the sources is not found on the called Element, the parent
        ///     chain is searched, using the logical tree.
        /// 
        /// Name of the resource 
        /// The found resource.  Null if not found.
        public object TryFindResource(object resourceKey) 
        { 
            // Verify Context Access
//             VerifyAccess(); 

            if (resourceKey == null)
            {
                throw new ArgumentNullException("resourceKey"); 
            }
 
            object resource = FrameworkElement.FindResourceInternal(null /* fe */, this, resourceKey); 

            if (resource == DependencyProperty.UnsetValue) 
            {
                // Resource not found in parent chain, app or system
                // This is where we translate DependencyProperty.UnsetValue to a null
                resource = null; 
            }
 
            return resource; 
        }
 
        /// 
        ///     Searches for a resource called name and sets up a resource reference
        ///     to it for the passed property.
        ///  
        /// Property to which the resource is bound
        /// Name of the resource 
        public void SetResourceReference( 
            DependencyProperty dp,
            object             name) 
        {
            // Set the value of the property to a ResourceReferenceExpression
            SetValue(dp, new ResourceReferenceExpression(name));
 
            // Set flag indicating that the current FrameworkContentElement instance
            // has a property value set to a resource reference and hence must 
            // be invalidated on parent changed or resource property change events 
            HasResourceReference = true;
        } 

        /// 
        ///     Begins the given Storyboard as a non-controllable Storyboard and
        /// the default handoff policy. 
        /// 
        public void BeginStoryboard(Storyboard storyboard) 
        { 
            BeginStoryboard(storyboard, HandoffBehavior.SnapshotAndReplace, false);
        } 

        /// 
        ///     Begins the given Storyboard as a non-controllable Storyboard but
        /// with the given handoff policy. 
        /// 
        public void BeginStoryboard(Storyboard storyboard, HandoffBehavior handoffBehavior) 
        { 
            BeginStoryboard(storyboard, handoffBehavior, false);
        } 

        /// 
        ///     Begins the given Storyboard as a Storyboard with the given handoff
        /// policy, and with the specified state for controllability. 
        /// 
        public void BeginStoryboard(Storyboard storyboard, HandoffBehavior handoffBehavior, bool isControllable) 
        { 
            if( storyboard == null )
            { 
                throw new ArgumentNullException("storyboard");
            }

            // Storyboard.Begin is a public API and needs to be validating handoffBehavior anyway. 

            storyboard.Begin( this, handoffBehavior, isControllable ); 
        } 

        ///  
        ///     Allows subclasses to participate in property base value computation
        /// 
        /// Dependency property
        /// Type metadata of the property for the type 
        /// entry computed by base
        internal sealed override void EvaluateBaseValueCore( 
            DependencyProperty  dp, 
            PropertyMetadata    metadata,
            ref EffectiveValueEntry newEntry) 
        {
            if (dp == StyleProperty)
            {
                // If this is the first time that the StyleProperty 
                // is being fetched then mark it such
                HasStyleEverBeenFetched = true; 
 
                // Clear the flags associated with the StyleProperty
                HasImplicitStyleFromResources = false; 
                IsStyleSetFromGenerator = false;
            }

            GetRawValue(dp, metadata, ref newEntry); 
            Storyboard.GetComplexPathValue(this, dp, ref newEntry, metadata);
        } 
 
        //[CodeAnalysis("AptcaMethodsShouldOnlyCallAptcaMethods")] //Tracking Bug: 29647
        internal void GetRawValue(DependencyProperty dp, PropertyMetadata metadata, ref EffectiveValueEntry entry) 
        {
            // Check if value was resolved by base. If so, run it by animations
            if ((entry.BaseValueSourceInternal == BaseValueSourceInternal.Local) &&
                (entry.GetFlattenedEntry(RequestFlags.FullyResolved).Value != DependencyProperty.UnsetValue)) 
            {
                return; 
            } 

            // 
            // Try for container Style driven value
            //
            if (TemplateChildIndex != -1)
            { 
                // This instance is in the template child chain of a Template.VisualTree,
                //  so we need to see if the Style has an applicable value. 
                // 
                // If the parent element's style is changing, this instance is
                // in a visual tree that is being removed, and the value request 
                // is simply a result of tearing down some information in that
                // tree (e.g. a BindingExpression).  If so, just pretend there is no style (bug 991395).

                if (GetValueFromTemplatedParent(dp, ref entry)) 
                {
                    return; 
                } 
            }
 

            //
            // Try for Styled value
            // 

            // Here are some of the implicit rules used by GetRawValue, 
            // while querying properties on the container. 
            // 1. Style property cannot be specified in a Style
            // 2. Style property cannot be specified in a ThemeStyle 
            // 3. Style property cannot be specified in a Template
            // 4. DefaultStyleKey property cannot be specified in a ThemeStyle
            // 5. DefaultStyleKey property cannot be specified in a Template
            // 6. Template property cannot be specified in a Template 

            if (dp != StyleProperty) 
            { 
                if (StyleHelper.GetValueFromStyleOrTemplate(new FrameworkObject(null, this), dp, ref entry))
                { 
                    return;
                }
            }
            else 
            {
                object source; 
                object implicitValue = FrameworkElement.FindImplicitStyleResource(this, this.GetType(), out source); 
                if (implicitValue != DependencyProperty.UnsetValue)
                { 
                    // Commented this because the implicit fetch could also return a DeferredDictionaryReference
                    // if (!(implicitValue is Style))
                    // {
                    //     throw new InvalidOperationException(SR.Get(SRID.InvalidImplicitStyleResource, this.GetType().Name, implicitValue)); 
                    // }
 
                    // This style has been fetched from resources 
                    HasImplicitStyleFromResources = true;
 
                    entry.BaseValueSourceInternal = BaseValueSourceInternal.ImplicitReference;
                    entry.Value = implicitValue;
                    return;
                } 
            }
 
            // 
            // Try for Inherited value
            // 
            FrameworkPropertyMetadata fmetadata = metadata as FrameworkPropertyMetadata;

            // Note that for inheritable properties that override the default value a parent can impart
            // its default value to the child even though the property may not have been set locally or 
            // via a style or template (ie. IsUsed flag would be false).
            if (fmetadata != null) 
            { 
                if (fmetadata.Inherits)
                { 
                    //
                    // Inheritance
                    //
 
                    if (!TreeWalkHelper.SkipNext(InheritanceBehavior) || fmetadata.OverridesInheritanceBehavior == true)
                    { 
                        // Used to terminate tree walk if a tree boundary is hit 
                        InheritanceBehavior inheritanceBehavior;
 
                        FrameworkContentElement parentFCE;
                        FrameworkElement parentFE;
                        bool hasParent = FrameworkElement.GetFrameworkParent(this, out parentFE, out parentFCE);
                        while (hasParent) 
                        {
                            bool inheritanceNode; 
                            if (parentFE != null) 
                            {
                                inheritanceNode = TreeWalkHelper.IsInheritanceNode(parentFE, dp, out inheritanceBehavior); 
                            }
                            else // (parentFCE != null)
                            {
                                inheritanceNode = TreeWalkHelper.IsInheritanceNode(parentFCE, dp, out inheritanceBehavior); 
                            }
 
                            // If the current node has SkipNow semantics then we do 
                            // not need to lookup the inheritable value on it.
                            if (TreeWalkHelper.SkipNow(inheritanceBehavior)) 
                            {
                                break;
                            }
 
                            // Check if node is an inheritance node, if so, query it
                            if (inheritanceNode) 
                            { 
                                #region EventTracing
                                if (EventTrace.IsEnabled(EventTrace.Keyword.KeywordGeneral, EventTrace.Level.Verbose)) 
                                {
                                    string TypeAndName = "[" + GetType().Name + "]" + dp.Name;
                                    EventTrace.EventProvider.TraceEvent(EventTrace.Event.WClientPropParentCheck,
                                                                         EventTrace.Keyword.KeywordGeneral, EventTrace.Level.Verbose, 
                                                                         GetHashCode(), TypeAndName);
                                } 
                                #endregion EventTracing 
                                DependencyObject parentDO = parentFE;
                                if (parentDO == null) 
                                {
                                    parentDO = parentFCE;
                                }
 
                                EntryIndex entryIndex = parentDO.LookupEntry(dp.GlobalIndex);
 
                                entry = parentDO.GetValueEntry( 
                                                entryIndex,
                                                dp, 
                                                fmetadata,
                                                RequestFlags.SkipDefault | RequestFlags.DeferredReferences);

                                if (entry.Value != DependencyProperty.UnsetValue) 
                                {
                                    entry.BaseValueSourceInternal = BaseValueSourceInternal.Inherited; 
                                } 
                                return;
                            } 

                            // If the current node has SkipNext semantics then we do
                            // not need to lookup the inheritable value on its parent.
                            if (TreeWalkHelper.SkipNext(inheritanceBehavior)) 
                            {
                                break; 
                            } 

                            // No boundary or inheritance node found, continue search 
                            if (parentFE != null)
                            {
                                hasParent = FrameworkElement.GetFrameworkParent(parentFE, out parentFE, out parentFCE);
                            } 
                            else
                            { 
                                hasParent = FrameworkElement.GetFrameworkParent(parentFCE, out parentFE, out parentFCE); 
                            }
                        } 
                    }
                }

 
            }
 
            // No value found. 
            Debug.Assert(entry.Value == DependencyProperty.UnsetValue);
        } 

        // This FrameworkElement has been established to be a Template.VisualTree
        //  node of a parent object.  Ask the TemplatedParent's Style object if
        //  they have a value for us. 

        private bool GetValueFromTemplatedParent(DependencyProperty dp, ref EffectiveValueEntry entry) 
        { 
            FrameworkTemplate frameworkTemplate = null;
            FrameworkElement feTemplatedParent = (FrameworkElement)_templatedParent; 
            frameworkTemplate = feTemplatedParent.TemplateInternal;

            if (frameworkTemplate != null)
            { 
                return StyleHelper.GetValueFromTemplatedParent(
                    _templatedParent, 
                    TemplateChildIndex, 
                    new FrameworkObject(null, this),
                    dp, 
                    ref frameworkTemplate.ChildRecordFromChildIndex,
                    frameworkTemplate.VisualTree,
                    ref entry);
            } 

            return false; 
        } 

 
        // Like GetValueCore, except it returns the expression (if any) instead of its value
        internal Expression GetExpressionCore(DependencyProperty dp, PropertyMetadata metadata)
        {
            this.IsRequestingExpression = true; 
            EffectiveValueEntry entry = new EffectiveValueEntry(dp);
            entry.Value = DependencyProperty.UnsetValue; 
            this.EvaluateBaseValueCore(dp, metadata, ref entry); 
            this.IsRequestingExpression = false;
 
            return entry.Value as Expression;
        }

 
        /// 
        ///     Notification that a specified property has been changed 
        ///  
        /// EventArgs that contains the property, metadata, old value, and new value for this change
        protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e) 
        {
            DependencyProperty dp = e.Property;

            base.OnPropertyChanged(e); 

            if (e.IsAValueChange || e.IsASubPropertyChange) 
            { 
                //
                // Try to fire the Loaded event on the root of the tree 
                // because for this case the OnParentChanged will not
                // have a chance to fire the Loaded event.
                //
                if (dp != null && dp.OwnerType == typeof(PresentationSource) && dp.Name == "RootSource") 
                {
                    TryFireInitialized(); 
                } 

                if (dp == FrameworkElement.NameProperty && 
                    EventTrace.IsEnabled(EventTrace.Keyword.KeywordGeneral, EventTrace.Level.Verbose))
                {
                    EventTrace.EventProvider.TraceEvent(EventTrace.Event.PerfElementIDName, EventTrace.Keyword.KeywordGeneral, EventTrace.Level.Verbose,
                            PerfService.GetPerfElementID(this), GetType().Name, GetValue(dp)); 
                }
 
                // 
                // Invalidation propagation for Styles
                // 

                // Regardless of metadata, the Style/DefaultStyleKey properties are never a trigger drivers
                if (dp != StyleProperty && dp != DefaultStyleKeyProperty)
                { 
                    // Note even properties on non-container nodes within a template could be driving a trigger
                    if (TemplatedParent != null) 
                    { 
                        FrameworkElement feTemplatedParent = TemplatedParent as FrameworkElement;
 
                        FrameworkTemplate frameworkTemplate = feTemplatedParent.TemplateInternal;
                        StyleHelper.OnTriggerSourcePropertyInvalidated(null, frameworkTemplate, TemplatedParent, dp, e, false /*invalidateOnlyContainer*/,
                            ref frameworkTemplate.TriggerSourceRecordFromChildIndex, ref frameworkTemplate.PropertyTriggersWithActions, TemplateChildIndex /*sourceChildIndex*/);
                    } 

                    // Do not validate Style during an invalidation if the Style was 
                    // never used before (dependents do not need invalidation) 
                    if (Style != null)
                    { 
                        StyleHelper.OnTriggerSourcePropertyInvalidated(Style, null, this, dp, e, true /*invalidateOnlyContainer*/,
                            ref Style.TriggerSourceRecordFromChildIndex, ref Style.PropertyTriggersWithActions, 0 /*sourceChildId*/); // Style can only have triggers that are driven by properties on the container
                    }
 
                    // Do not validate Template during an invalidation if the Template was
                    // never used before (dependents do not need invalidation) 
 
                    // There may be container dependents in the ThemeStyle. Invalidate them.
                    if (ThemeStyle != null && Style != ThemeStyle) 
                    {
                        StyleHelper.OnTriggerSourcePropertyInvalidated(ThemeStyle, null, this, dp, e, true /*invalidateOnlyContainer*/,
                            ref ThemeStyle.TriggerSourceRecordFromChildIndex, ref ThemeStyle.PropertyTriggersWithActions, 0 /*sourceChildIndex*/); // ThemeStyle can only have triggers that are driven by properties on the container
                    } 
                }
            } 
 
            FrameworkPropertyMetadata fmetadata = e.Metadata as FrameworkPropertyMetadata;
 
            //
            // Invalidation propagation for Groups and Inheritance
            //
 
            // Metadata must exist specifically stating propagate invalidation
            // due to group or inheritance 
            if (fmetadata != null) 
            {
                // 
                // Inheritance
                //

                if (fmetadata.Inherits) 
                {
                    // Invalidate Inheritable descendents only if instance is not a TreeSeparator 
                    // or fmetadata.OverridesInheritanceBehavior is set to override separated tree behavior 
                    if ((InheritanceBehavior == InheritanceBehavior.Default || fmetadata.OverridesInheritanceBehavior) &&
                        (!DependencyObject.IsTreeWalkOperation(e.OperationType) || PotentiallyHasMentees)) 
                    {
                        EffectiveValueEntry newEntry = e.NewEntry;
                        EffectiveValueEntry oldEntry = e.OldEntry;
                        if (oldEntry.BaseValueSourceInternal > newEntry.BaseValueSourceInternal) 
                        {
                            // valuesource == Inherited && value == UnsetValue indicates that we are clearing the inherited value 
                            newEntry = new EffectiveValueEntry(dp, BaseValueSourceInternal.Inherited); 
                        }
                        else 
                        {
                            newEntry = newEntry.GetFlattenedEntry(RequestFlags.FullyResolved);
                            newEntry.BaseValueSourceInternal = BaseValueSourceInternal.Inherited;
                        } 

                        if (oldEntry.BaseValueSourceInternal != BaseValueSourceInternal.Default || oldEntry.HasModifiers) 
                        { 
                            oldEntry = oldEntry.GetFlattenedEntry(RequestFlags.FullyResolved);
                            oldEntry.BaseValueSourceInternal = BaseValueSourceInternal.Inherited; 
                        }
                        else
                        {
                            // we use an empty EffectiveValueEntry as a signal that the old entry was the default value 
                            oldEntry = new EffectiveValueEntry();
                        } 
 
                        InheritablePropertyChangeInfo info =
                                new InheritablePropertyChangeInfo( 
                                        dp,
                                        oldEntry,
                                        newEntry);
 
                        // Don't InvalidateTree if we're in the middle of doing it.
                        if (!DependencyObject.IsTreeWalkOperation(e.OperationType)) 
                        { 
                            TreeWalkHelper.InvalidateOnInheritablePropertyChange(null, this, info, true);
                        } 

                        // Notify mentees if they exist
                        if (PotentiallyHasMentees)
                        { 
                            TreeWalkHelper.OnInheritedPropertyChanged(this, ref info, InheritanceBehavior);
                        } 
                    } 
                }
            } 
        }

        /// 
        ///     The DependencyProperty for the Name property. 
        /// 
        public static readonly DependencyProperty NameProperty = 
                    FrameworkElement.NameProperty.AddOwner( 
                                typeof(FrameworkContentElement),
                                new FrameworkPropertyMetadata(string.Empty)); 

        /// 
        ///     Name property.
        ///  
        [MergableProperty(false)]
        [Localizability(LocalizationCategory.NeverLocalize)] // cannot be localized 
        public string Name 
        {
            get { return (string) GetValue(NameProperty); } 
            set { SetValue(NameProperty, value); }
        }

        ///  
        ///     The DependencyProperty for the Tag property.
        ///  
        public static readonly DependencyProperty TagProperty = 
                    FrameworkElement.TagProperty.AddOwner(
                                typeof(FrameworkContentElement), 
                                new FrameworkPropertyMetadata((object) null));

        /// 
        ///     Tag property. 
        /// 
        public object Tag 
        { 
            get { return GetValue(TagProperty); }
            set { SetValue(TagProperty, value); } 
        }

        #region Language
 
        /// 
        /// Language can be specified in xaml at any point using the xml language attribute xml:lang. 
        /// This will make the culture pertain to the scope of the element where it is applied.  The 
        /// XmlLanguage names follow the RFC 3066 standard. For example, U.S. English is "en-US".
        ///  
        static public readonly DependencyProperty LanguageProperty =
                    FrameworkElement.LanguageProperty.AddOwner(
                                typeof(FrameworkContentElement),
                                new FrameworkPropertyMetadata( 
                                        XmlLanguage.GetLanguage("en-US"),
                                        FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsMeasure)); 
 
        /// 
        /// Language can be specified in xaml at any point using the xml language attribute xml:lang. 
        /// This will make the culture pertain to the scope of the element where it is applied.  The
        /// XmlLanguage names follow the RFC 3066 standard. For example, U.S. English is "en-US".
        /// 
        public XmlLanguage Language 
        {
            get { return (XmlLanguage) GetValue(LanguageProperty); } 
            set { SetValue(LanguageProperty, value); } 
        }
        #endregion Language 

        #region Input

        ///  
        /// FocusVisualStyleProperty
        ///  
        public static readonly DependencyProperty FocusVisualStyleProperty = 
                    FrameworkElement.FocusVisualStyleProperty.AddOwner(typeof(FrameworkContentElement),
                    new FrameworkPropertyMetadata(FrameworkElement.DefaultFocusVisualStyle)); 

        /// 
        /// FocusVisualStyle Property
        ///  
        public Style FocusVisualStyle
        { 
            get { return (Style) GetValue(FocusVisualStyleProperty); } 
            set { SetValue(FocusVisualStyleProperty, value); }
        } 

        /// 
        ///     CursorProperty
        ///  
        public static readonly DependencyProperty CursorProperty =
                    FrameworkElement.CursorProperty.AddOwner( 
                                typeof(FrameworkContentElement), 
                                new FrameworkPropertyMetadata(
                                            (object) null, // default value 
                                            0,
                                            new PropertyChangedCallback(OnCursorChanged)));

        ///  
        ///     Cursor Property
        ///  
        public System.Windows.Input.Cursor Cursor 
        {
            get { return (System.Windows.Input.Cursor)GetValue(CursorProperty); } 

            set { SetValue(CursorProperty, value); }
        }
 
        // If the cursor is changed, we may need to set the actual cursor.
        static private void OnCursorChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        { 
            FrameworkContentElement fce = ((FrameworkContentElement)d);
 
            if(fce.IsMouseOver)
            {
                Mouse.UpdateCursor();
            } 
        }
 
        ///  
        ///     ForceCursorProperty
        ///  
        public static readonly DependencyProperty ForceCursorProperty =
                    FrameworkElement.ForceCursorProperty.AddOwner(
                                typeof(FrameworkContentElement),
                                new FrameworkPropertyMetadata( 
                                            BooleanBoxes.FalseBox, // default value
                                            0, 
                                            new PropertyChangedCallback(OnForceCursorChanged))); 

 
        /// 
        ///     ForceCursor Property
        /// 
        public bool ForceCursor 
        {
            get { return (bool) GetValue(ForceCursorProperty); } 
            set { SetValue(ForceCursorProperty, BooleanBoxes.Box(value)); } 
        }
 
        // If the ForceCursor property changed, we may need to set the actual cursor.
        static private void OnForceCursorChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            FrameworkContentElement fce = ((FrameworkContentElement)d); 

            if (fce.IsMouseOver) 
            { 
                Mouse.UpdateCursor();
            } 
        }

        private static void OnQueryCursor(object sender, QueryCursorEventArgs e)
        { 
            FrameworkContentElement fce = (FrameworkContentElement) sender;
 
            // We respond to querying the cursor by specifying the cursor set 
            // as a property on this element.
            Cursor cursor = fce.Cursor; 

            if(cursor != null)
            {
                // We specify the cursor if the QueryCursor event is not 
                // handled by the time it gets to us, or if we are configured
                // to force our cursor anyways.  Since the QueryCursor event 
                // bubbles, this has the effect of overriding whatever cursor 
                // a child of ours specified.
                if(!e.Handled || fce.ForceCursor) 
                {
                    e.Cursor = cursor;
                    e.Handled = true;
                } 
            }
        } 
 
        // Keyboard
        ///  
        ///     Request to move the focus from this element to another element
        /// 
        /// 
        ///     The direction that focus is to move. 
        /// 
        ///  Returns true if focus is moved successfully. Returns false if there is no next element 
        public sealed override bool MoveFocus(TraversalRequest request) 
        {
            if (request == null) 
            {
                throw new ArgumentNullException("request");
            }
 
            return KeyboardNavigation.Current.Navigate(this, request);
        } 
 
        /// 
        ///     Request to predict the element that should receive focus relative to this element for a 
        /// given direction, without actually moving focus to it.
        /// 
        /// The direction for which focus should be predicted
        ///  
        ///     Returns the next element that focus should move to for a given FocusNavigationDirection.
        /// Returns null if focus cannot be moved relative to this element. 
        ///  
        public sealed override DependencyObject PredictFocus(FocusNavigationDirection direction)
        { 
            return KeyboardNavigation.Current.PredictFocusedElement(this, direction);
        }

        ///  
        ///     This method is invoked when the IsFocused property changes to true
        ///  
        /// RoutedEventArgs 
        protected override void OnGotFocus(RoutedEventArgs e)
        { 
            // Scroll the element into view if currently focused
            if (IsKeyboardFocused)
                BringIntoView();
 
            base.OnGotFocus(e);
        } 
 
        private static void OnGotKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
        { 
            // This static class handler will get hit each time anybody gets hit with a tunnel that someone is getting focused.
            // We're only interested when the element is getting focused is processing the event.
            // NB: This will not do the right thing if the element rejects focus or does not want to be scrolled into view.
            if (sender == e.OriginalSource) 
            {
                FrameworkContentElement fce = (FrameworkContentElement)sender; 
                KeyboardNavigation.UpdateFocusedElement(fce); 

                KeyboardNavigation keyNav = KeyboardNavigation.Current; 
                KeyboardNavigation.ShowFocusVisual();
                keyNav.UpdateActiveElement(fce);
            }
        } 

        private static void OnLostKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e) 
        { 
            if (sender == e.OriginalSource)
            { 
                KeyboardNavigation.Current.HideFocusVisual();

                if (e.NewFocus == null)
                { 
                    KeyboardNavigation.Current.NotifyFocusChanged(sender, e);
                } 
            } 
        }
 
        /// 
        /// Attempts to bring this element into view by originating a RequestBringIntoView event.
        /// 
        public void BringIntoView() 
        {
            RequestBringIntoViewEventArgs args = new RequestBringIntoViewEventArgs(this, Rect.Empty); 
            args.RoutedEvent=FrameworkElement.RequestBringIntoViewEvent; 
            RaiseEvent(args);
        } 

        #endregion Input

        #region InputScope 

        ///  
        ///     InputScope DependencyProperty 
        ///     this is originally registered on InputMethod class
        ///  
        public static readonly DependencyProperty InputScopeProperty =
                    InputMethod.InputScopeProperty.AddOwner(typeof(FrameworkContentElement),
                                new FrameworkPropertyMetadata((InputScope)null, // default value
                                            FrameworkPropertyMetadataOptions.Inherits)); 

        ///  
        ///     InputScope Property accessor 
        /// 
        public InputScope InputScope 
        {
            get { return (InputScope) GetValue(InputScopeProperty); }
            set { SetValue(InputScopeProperty, value); }
        } 

        #endregion InputScope 
 
        #region Data binding
 
        /// 
        /// Add / Remove TargetUpdatedEvent handler
        /// 
        public event EventHandler TargetUpdated 
        {
            add     { AddHandler(Binding.TargetUpdatedEvent, value); } 
            remove  { RemoveHandler(Binding.TargetUpdatedEvent, value); } 
        }
 

        /// 
        /// Add / Remove SourceUpdatedEvent handler
        ///  
        public event EventHandler SourceUpdated
        { 
            add     { AddHandler(Binding.SourceUpdatedEvent, value); } 
            remove  { RemoveHandler(Binding.SourceUpdatedEvent, value); }
        } 


        /// 
        ///     DataContext DependencyProperty 
        /// 
        public static readonly DependencyProperty DataContextProperty = 
                FrameworkElement.DataContextProperty.AddOwner( 
                        typeof(FrameworkContentElement),
                        new FrameworkPropertyMetadata(null, 
                                FrameworkPropertyMetadataOptions.Inherits,
                                new PropertyChangedCallback(OnDataContextChanged)));

        ///  
        ///     DataContextChanged event
        ///  
        ///  
        ///     When an element's DataContext changes, all data-bound properties
        ///     (on this element or any other element) whose Binding use this 
        ///     DataContext will change to reflect the new value.  There is no
        ///     guarantee made about the order of these changes relative to the
        ///     raising of the DataContextChanged event.  The changes can happen
        ///     before the event, after the event, or in any mixture. 
        /// 
        public event DependencyPropertyChangedEventHandler DataContextChanged 
        { 
            add { EventHandlersStoreAdd(FrameworkElement.DataContextChangedKey, value); }
            remove { EventHandlersStoreRemove(FrameworkElement.DataContextChangedKey, value); } 
        }

        /// 
        ///     DataContext Property 
        /// 
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] 
        [Localizability(LocalizationCategory.NeverLocalize)] 
        public object DataContext
        { 
            get { return GetValue(DataContextProperty); }
            set { SetValue(DataContextProperty, value); }
        }
 
        private static void OnDataContextChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            ((FrameworkContentElement) d).RaiseDependencyPropertyChanged(FrameworkElement.DataContextChangedKey, e); 
        }
 
        /// 
        /// Get the BindingExpression for the given property
        /// 
        /// DependencyProperty that represents the property 
        ///  BindingExpression if property is data-bound, null if it is not
        public BindingExpression GetBindingExpression(DependencyProperty dp) 
        { 
            return BindingOperations.GetBindingExpression(this, dp);
        } 

        /// 
        /// Attach a data Binding to a property
        ///  
        /// DependencyProperty that represents the property
        /// description of Binding to attach 
        public BindingExpressionBase SetBinding(DependencyProperty dp, BindingBase binding) 
        {
            return BindingOperations.SetBinding(this, dp, binding); 
        }

        /// 
        /// Convenience method.  Create a BindingExpression and attach it. 
        /// Most fields of the BindingExpression get default values.
        ///  
        /// DependencyProperty that represents the property 
        /// source path
        public BindingExpression SetBinding(DependencyProperty dp, string path) 
        {
            return (BindingExpression)SetBinding(dp, new Binding(path));
        }
 
        /// 
        ///     BindingGroup DependencyProperty 
        ///  
        public static readonly DependencyProperty BindingGroupProperty =
                FrameworkElement.BindingGroupProperty.AddOwner( 
                        typeof(FrameworkContentElement),
                        new FrameworkPropertyMetadata(null,
                                FrameworkPropertyMetadataOptions.Inherits));
 
        /// 
        ///     BindingGroup Property 
        ///  
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Localizability(LocalizationCategory.NeverLocalize)] 
        public BindingGroup BindingGroup
        {
            get { return (BindingGroup)GetValue(BindingGroupProperty); }
            set { SetValue(BindingGroupProperty, value); } 
        }
 
        #endregion Data binding 

        #region LogicalTree 

        /// 
        ///     Returns a non-null value when some framework implementation
        ///     of this method has a non-visual parent connection, 
        /// 
        protected internal override DependencyObject GetUIParentCore() 
        { 
            return this._parent;
        } 

        /// 
        ///     Allows adjustment to the event source
        ///  
        /// 
        ///     Subclasses must override this method 
        ///     to be able to adjust the source during 
        ///     route invocation 
        /// 
        ///     NOTE: Expected to return null when no
        ///     change is made to source
        /// 
        ///  
        ///     Routed Event Args
        ///  
        ///  
        ///     Returns new source
        ///  
        internal override object AdjustEventSource(RoutedEventArgs args)
        {
            object source = null;
 
            // As part of routing events through logical trees, we have
            // to be careful about events that come to us from "foreign" 
            // trees.  For example, the event could come from an element 
            // in our "implementation" visual tree, or from an element
            // in a different logical tree all together. 
            //
            // Note that we consider ourselves to be part of a logical tree
            // if we have either a logical parent, or any logical children.
            // 
            //
 
            if(_parent != null || HasLogicalChildren) 
            {
                DependencyObject logicalSource = args.Source as DependencyObject; 
                if(logicalSource == null || !IsLogicalDescendent(logicalSource))
                {
                    args.Source=this;
                    source = this; 
                }
            } 
 
            return source;
        } 

        // Allows adjustments to the branch source popped off the stack
        internal virtual void AdjustBranchSource(RoutedEventArgs args)
        { 
        }
 
        //CASRemoval:[StrongNameIdentityPermissionAttribute(SecurityAction.InheritanceDemand, PublicKey=Microsoft.Internal.BuildInfo.WCP_PUBLIC_KEY_STRING)] 
        internal virtual bool IgnoreModelParentBuildRoute(RoutedEventArgs args)
        { 
            return false;
        }

        ///  
        ///     Allows FrameworkElement to augment the
        ///      
        ///  
        /// 
        ///     NOTE: If this instance does not have a 
        ///     visualParent but has a model parent
        ///     then route is built through the model
        ///     parent
        ///  
        /// 
        ///     The  to be 
        ///     augmented 
        /// 
        ///  
        ///      for the
        ///     RoutedEvent to be raised post building
        ///     the route
        ///  
        /// 
        ///     Whether or not the route should continue past the visual tree. 
        ///     If this is true, and there are no more visual parents, the route 
        ///     building code will call the GetUIParentCore method to find the
        ///     next non-visual parent. 
        /// 
        internal override sealed bool BuildRouteCore(EventRoute route, RoutedEventArgs args)
        {
            bool continuePastCoreTree = false; 

            // Verify Context Access 
//             VerifyAccess(); 

            DependencyObject visualParent = (DependencyObject) ContentOperations.GetParent(this); 
            DependencyObject modelParent = this._parent;

            // FrameworkElement extends the basic event routing strategy by
            // introducing the concept of a logical tree.  When an event 
            // passes through an element in a logical tree, the source of
            // the event needs to change to the leaf-most node in the same 
            // logical tree that is in the route. 

            // Check the route to see if we are returning into a logical tree 
            // that we left before.  If so, restore the source of the event to
            // be the source that it was when we left the logical tree.
            DependencyObject branchNode = route.PeekBranchNode() as DependencyObject;
            if (branchNode != null && IsLogicalDescendent(branchNode)) 
            {
                // We keep the most recent source in the event args.  Note that 
                // this is only for our consumption.  Once the event is raised, 
                // it will use the source information in the route.
                args.Source  = (route.PeekBranchSource()); 

                AdjustBranchSource(args);

                route.AddSource(args.Source); 

                // By popping the branch node we will also be setting the source 
                // in the event route. 
                route.PopBranchNode();
 
                // Add intermediate ContentElements to the route
                FrameworkElement.AddIntermediateElementsToRoute(this, route, args, LogicalTreeHelper.GetParent(branchNode));
            }
 

            // Check if the next element in the route is in a different 
            // logical tree. 

            if (!IgnoreModelParentBuildRoute(args)) 
            {
                // If there is no visual parent, route via the model tree.
                if (visualParent == null)
                { 
                    continuePastCoreTree = modelParent != null;
                } 
                else if(modelParent != null) 
                {
                    // If there is a model parent, record the branch node. 
                    route.PushBranchNode(this, args.Source);

                    // The source is going to be the visual parent, which
                    // could live in a different logical tree. 
                    args.Source  = (visualParent);
                } 
 
            }
 
            return continuePastCoreTree;
        }

        ///  
        ///     Add Style TargetType and FEF EventHandlers to the EventRoute
        ///  
        internal override void AddToEventRouteCore(EventRoute route, RoutedEventArgs args) 
        {
            FrameworkElement.AddStyleHandlersToEventRoute(null, this, route, args); 
        }

        // Returns if the given child instance is a logical descendent
        private bool IsLogicalDescendent(DependencyObject child) 
        {
            while (child != null) 
            { 
                if (child == this)
                { 
                    return true;
                }

                child = LogicalTreeHelper.GetParent(child); 
            }
 
            return false; 
        }
 
        /// 
        ///     Invoked when ancestor is changed.  This is invoked after
        ///     the ancestor has changed, and the purpose is to allow elements to
        ///     perform actions based on the changed ancestor. 
        /// 
        //CASRemoval:[StrongNameIdentityPermissionAttribute(SecurityAction.InheritanceDemand, PublicKey=Microsoft.Internal.BuildInfo.WCP_PUBLIC_KEY_STRING)] 
        internal virtual void OnAncestorChanged() 
        {
        } 

        /// 
        /// OnContentParentChanged is called when the parent of the content element is changed.
        ///  
        /// Old parent or null if the content element did not have a parent before.
        internal override void OnContentParentChanged(DependencyObject oldParent) 
        { 
            DependencyObject newParent = ContentOperations.GetParent(this);
 
            // Initialize, if not already done
            TryFireInitialized();

            base.OnContentParentChanged(oldParent); 
        }
 
        ///  
        ///     Indicates the current mode of lookup for both inheritance and resources.
        ///  
        /// 
        ///     Used in property inheritence and reverse
        ///     inheritence and resource lookup to stop at
        ///     logical tree boundaries 
        ///
        ///     It is also used by designers such as Sparkle to 
        ///     skip past the app resources directly to the theme. 
        ///     They are expected to merge in the client's app
        ///     resources via the MergedDictionaries feature on 
        ///     root element of the tree.
        ///
        ///     NOTE: Property can be set only when the
        ///     instance is not yet hooked to the tree. This 
        ///     is to encourage setting it at construction time.
        ///     If we didn't restrict it to (roughly) construction 
        ///     time, we would have to take the complexity of 
        ///     firing property invalidations when the flag was
        ///     changed. 
        /// 
        internal InheritanceBehavior InheritanceBehavior
        {
            get 
            {
                Debug.Assert((uint)InternalFlags.InheritanceBehavior0 == 0x08); 
                Debug.Assert((uint)InternalFlags.InheritanceBehavior1 == 0x10); 
                Debug.Assert((uint)InternalFlags.InheritanceBehavior2 == 0x20);
 
                const uint inheritanceBehaviorMask =
                    (uint)InternalFlags.InheritanceBehavior0 +
                    (uint)InternalFlags.InheritanceBehavior1 +
                    (uint)InternalFlags.InheritanceBehavior2; 

                uint inheritanceBehavior = ((uint)_flags & inheritanceBehaviorMask) >> 3; 
                return (InheritanceBehavior)inheritanceBehavior; 
            }
 
            set
            {
                Debug.Assert((uint)InternalFlags.InheritanceBehavior0 == 0x08);
                Debug.Assert((uint)InternalFlags.InheritanceBehavior1 == 0x10); 
                Debug.Assert((uint)InternalFlags.InheritanceBehavior2 == 0x20);
 
                const uint inheritanceBehaviorMask = 
                    (uint)InternalFlags.InheritanceBehavior0 +
                    (uint)InternalFlags.InheritanceBehavior1 + 
                    (uint)InternalFlags.InheritanceBehavior2;

                if (!this.IsInitialized)
                { 
                    if ((uint)value < 0 ||
                        (uint)value > (uint)InheritanceBehavior.SkipAllNext) 
                    { 
                        throw new InvalidEnumArgumentException("value", (int)value, typeof(InheritanceBehavior));
                    } 

                    uint inheritanceBehavior = (uint)value << 3;

                    _flags = (InternalFlags)((inheritanceBehavior & inheritanceBehaviorMask) | (((uint)_flags) & ~inheritanceBehaviorMask)); 

                    if (_parent != null) 
                    { 
                        // This means that we are in the process of xaml parsing:
                        // an instance of FCE has been created and added to a parent, 
                        // but no children yet added to it (otherwise it would be initialized already
                        // and we would not be allowed to change InheritanceBehavior).
                        // So we need to re-calculate properties accounting for the new
                        // inheritance behavior. 
                        // This must have no performance effect as the subtree of this
                        // element is empty (no children yet added). 
                        TreeWalkHelper.InvalidateOnTreeChange(/*fe:*/null, /*fce:*/this, _parent, true); 
                    }
                } 
                else
                {
                    throw new InvalidOperationException(SR.Get(SRID.Illegal_InheritanceBehaviorSettor));
                } 
            }
        } 
 
        #endregion LogicalTree
 
        #region ISupportInitialize

        /// 
        ///     Initialization of this element is about to begin 
        /// 
        public virtual void BeginInit() 
        { 
            // Nested BeginInits on the same instance aren't permitted
            if (ReadInternalFlag(InternalFlags.InitPending)) 
            {
                throw new InvalidOperationException(SR.Get(SRID.NestedBeginInitNotSupported));
            }
 
            // Mark the element as pending initialization
            WriteInternalFlag(InternalFlags.InitPending, true); 
        } 

        ///  
        ///     Initialization of this element has completed
        /// 
        public virtual void EndInit()
        { 
            // Every EndInit must be preceeded by a BeginInit
            if (!ReadInternalFlag(InternalFlags.InitPending)) 
            { 
                throw new InvalidOperationException(SR.Get(SRID.EndInitWithoutBeginInitNotSupported));
            } 

            // Reset the pending flag
            WriteInternalFlag(InternalFlags.InitPending, false);
 
            // Mark the element initialized and fire Initialized event
            // (eg. tree building via parser) 
            TryFireInitialized(); 
        }
 
        /// 
        ///     Has this element been initialized
        /// 
        ///  
        ///     True if either EndInit or OnParentChanged were called
        ///  
        [EditorBrowsable(EditorBrowsableState.Advanced)] 
        public bool IsInitialized
        { 
            get { return ReadInternalFlag(InternalFlags.IsInitialized); }
        }

        ///  
        ///     This clr event is fired when
        ///      
        ///     becomes true 
        /// 
        [EditorBrowsable(EditorBrowsableState.Advanced)] 
        public event EventHandler Initialized
        {
            add { EventHandlersStoreAdd(FrameworkElement.InitializedKey, value); }
            remove { EventHandlersStoreRemove(FrameworkElement.InitializedKey, value); } 
        }
 
        ///  
        ///     This virtual method in called when IsInitialized is set to true and it raises an Initialized event
        ///  
        protected virtual void OnInitialized(EventArgs e)
        {
            // Need to update the StyleProperty so that we can pickup
            // the implicit style if it hasn't already been fetched 
            if (!HasStyleEverBeenFetched)
            { 
                UpdateStyleProperty(); 
            }
 
            // Need to update the ThemeStyleProperty so that we can pickup
            // the implicit style if it hasn't already been fetched
            if (!HasThemeStyleEverBeenFetched)
            { 
                UpdateThemeStyleProperty();
            } 
 
            RaiseInitialized(FrameworkElement.InitializedKey, e);
        } 

        // Helper method that tries to set IsInitialized to true
        // and Fire the Initialized event
        // This method can be invoked from two locations 
        //      1> EndInit
        //      2> OnParentChanged 
        private void TryFireInitialized() 
        {
            if (!ReadInternalFlag(InternalFlags.InitPending) && 
                !ReadInternalFlag(InternalFlags.IsInitialized))
            {
                WriteInternalFlag(InternalFlags.IsInitialized, true);
 
                OnInitialized(EventArgs.Empty);
            } 
        } 

        // Helper method to retrieve and fire Clr Event handlers for Initialized event 
        private void RaiseInitialized(EventPrivateKey key, EventArgs e)
        {
            EventHandlersStore store = EventHandlersStore;
            if (store != null) 
            {
                Delegate handler = store.Get(key); 
                if (handler != null) 
                {
                    ((EventHandler)handler)(this, e); 
                }
            }
        }
 
        #endregion ISupportInitialize
 
        #region LoadedAndUnloadedEvents 

        ///  
        ///     This DP is set on the root of a sub-tree that is about to receive a broadcast Loaded event
        ///     This DP is cleared when the Loaded event is either fired or cancelled for some reason
        /// 
        private static readonly DependencyProperty LoadedPendingProperty 
            = FrameworkElement.LoadedPendingProperty.AddOwner(typeof(FrameworkContentElement));
 
        ///  
        ///     This DP is set on the root of a sub-tree that is about to receive a broadcast Unloaded event
        ///     This DP is cleared when the Unloaded event is either fired or cancelled for some reason 
        /// 
        private static readonly DependencyProperty UnloadedPendingProperty
            = FrameworkElement.UnloadedPendingProperty.AddOwner(typeof(FrameworkContentElement));
 
        /// 
        ///     Turns true when this element is attached to a tree and is laid out and rendered. 
        ///     Turns false when the element gets detached from a loaded tree 
        /// 
        public bool IsLoaded 
        {
            get
            {
                object[] loadedPending = LoadedPending; 
                object[] unloadedPending = UnloadedPending;
 
                if (loadedPending == null && unloadedPending == null) 
                {
                    // The HasHandler flags are used for validation of the IsLoaded flag 
                    if (SubtreeHasLoadedChangeHandler)
                    {
                        // The IsLoaded flag is valid
                        return IsLoadedCache; 
                    }
                    else 
                    { 
                        // IsLoaded flag isn't valid
                        return BroadcastEventHelper.IsParentLoaded(this); 
                    }
                }
                else
                { 
                    // This is the case where we might be
                    // 1. Pending Unloaded only 
                    //    In this case we are already Loaded 
                    // 2. Pending Loaded only
                    //    In this case we are not Loaded yet 
                    // 3. Pending both Loaded and Unloaded
                    //    We can get to this state only when Unloaded operation preceeds Loaded.
                    //    If Loaded preceeded Unloaded then it is sure to have been cancelled
                    //    out by the latter. 

                    return (unloadedPending != null); 
                } 
            }
        } 

        /// 
        ///     Loaded RoutedEvent
        ///  

        public static readonly RoutedEvent LoadedEvent = FrameworkElement.LoadedEvent.AddOwner( typeof(FrameworkContentElement)); 
 
        /// 
        ///     This event is fired when the element is laid out, rendered and ready for interaction 
        /// 

        public event RoutedEventHandler Loaded
        { 
            add
            { 
                AddHandler(FrameworkElement.LoadedEvent, value, false); 
            }
            remove 
            {
                RemoveHandler(FrameworkElement.LoadedEvent, value);
            }
        } 

 
        ///  
        ///     Helper that will set the IsLoaded flag and Raise the Loaded event
        ///  
        internal void OnLoaded(RoutedEventArgs args)
        {
            RaiseEvent(args);
        } 

        ///  
        ///     Unloaded RoutedEvent 
        /// 
 
        public static readonly RoutedEvent UnloadedEvent = FrameworkElement.UnloadedEvent.AddOwner( typeof(FrameworkContentElement));

        /// 
        ///     This clr event is fired when this element is detached form a loaded tree 
        /// 
        public event RoutedEventHandler Unloaded 
        { 
            add
            { 
                AddHandler(FrameworkElement.UnloadedEvent, value, false);
            }
            remove
            { 
                RemoveHandler(FrameworkElement.UnloadedEvent, value);
            } 
        } 

        ///  
        ///     Helper that will reset the IsLoaded flag and Raise the Unloaded event
        /// 
        internal void OnUnloaded(RoutedEventArgs args)
        { 
            RaiseEvent(args);
        } 
 

        ///  
        ///     Notifies subclass of a new routed event handler.  Note that this is
        ///     called once for each handler added, but OnRemoveHandler is only called
        ///     on the last removal.
        ///  
        internal override void OnAddHandler(
            RoutedEvent routedEvent, 
            Delegate handler) 
        {
            if (routedEvent == LoadedEvent || routedEvent == UnloadedEvent) 
            {
                BroadcastEventHelper.AddHasLoadedChangeHandlerFlagInAncestry(this);
            }
        } 

 
        ///  
        ///     Notifies subclass of an event for which a handler has been removed.
        ///  
        internal override void OnRemoveHandler(
            RoutedEvent routedEvent,
            Delegate handler)
        { 
            // We only care about Loaded & Unloaded events
            if (routedEvent != LoadedEvent && routedEvent != UnloadedEvent) 
                return; 

            if (!ThisHasLoadedChangeEventHandler) 
            {
                BroadcastEventHelper.RemoveHasLoadedChangeHandlerFlagInAncestry(this);
            }
        } 

 
        // Helper method to retrieve and fire Clr Event handlers 
        internal void RaiseClrEvent(EventPrivateKey key, EventArgs args)
        { 
            EventHandlersStore store = EventHandlersStore;
            if (store != null)
            {
                Delegate handler = store.Get(key); 
                if (handler != null)
                { 
                    ((EventHandler)handler)(this, args); 
                }
            } 
        }

        #endregion LoadedAndUnloadedEvents
 
        #region PopupControlService
 
        ///  
        ///     The DependencyProperty for the ToolTip property
        ///  
        public static readonly DependencyProperty ToolTipProperty =
            ToolTipService.ToolTipProperty.AddOwner(typeof(FrameworkContentElement));

        ///  
        ///     The ToolTip for the element.
        ///     If the value is of type ToolTip, then that is the ToolTip that will be used. 
        ///     If the value is of any other type, then that value will be used 
        ///     as the content for a ToolTip provided by the system. Refer to ToolTipService
        ///     for attached properties to customize the ToolTip. 
        /// 
        [Bindable(true), Category("Appearance")]
        public object ToolTip
        { 
            get
            { 
                return ToolTipService.GetToolTip(this); 
            }
 
            set
            {
                ToolTipService.SetToolTip(this, value);
            } 
        }
 
 
        /// 
        /// The DependencyProperty for the Contextmenu property 
        /// 
        public static readonly DependencyProperty ContextMenuProperty =
            ContextMenuService.ContextMenuProperty.AddOwner(typeof(FrameworkContentElement),
            new FrameworkPropertyMetadata((ContextMenu) null)); 

        ///  
        /// The ContextMenu data set on this element. Can be any type that can be converted to a UIElement. 
        /// 
        public ContextMenu ContextMenu 
        {
            get
            {
                return (ContextMenu)GetValue(ContextMenuProperty); 
            }
 
            set 
            {
                SetValue(ContextMenuProperty, value); 
            }
        }

        ///  
        ///     The RoutedEvent for the ToolTipOpening event.
        ///  
        public static readonly RoutedEvent ToolTipOpeningEvent = ToolTipService.ToolTipOpeningEvent.AddOwner(typeof(FrameworkContentElement)); 

        ///  
        ///     An event that fires just before a ToolTip should be opened.
        ///     This event does not fire if the value of ToolTip is null or unset.
        ///
        ///     To manually open and close ToolTips, set the value of ToolTip to a non-null value 
        ///     and then mark this event as handled.
        /// 
        ///     To delay loading the actual ToolTip value, set the value of the ToolTip property to 
        ///     any value (you can also use it as a tag) and then set the value to the actual value
        ///     in a handler for this event. Do not mark the event as handled if the system provided 
        ///     functionality for showing or hiding the ToolTip is desired.
        /// 
        public event ToolTipEventHandler ToolTipOpening
        { 
            add { AddHandler(ToolTipOpeningEvent, value); }
            remove { RemoveHandler(ToolTipOpeningEvent, value); } 
        } 

        private static void OnToolTipOpeningThunk(object sender, ToolTipEventArgs e) 
        {
            ((FrameworkContentElement)sender).OnToolTipOpening(e);
        }
 
        /// 
        ///     Called when the ToolTipOpening event fires. 
        ///     Allows subclasses to add functionality without having to attach 
        ///     an individual handler.
        ///  
        /// Event arguments
        protected virtual void OnToolTipOpening(ToolTipEventArgs e)
        {
        } 

        ///  
        ///     The RoutedEvent for the ToolTipClosing event. 
        /// 
        public static readonly RoutedEvent ToolTipClosingEvent = ToolTipService.ToolTipClosingEvent.AddOwner(typeof(FrameworkContentElement)); 

        /// 
        ///     An event that fires just before a ToolTip should be closed.
        ///     This event will only fire if there was a preceding ToolTipOpening event. 
        ///
        ///     To manually close a ToolTip and not use the system behavior, mark this event as handled. 
        ///  
        public event ToolTipEventHandler ToolTipClosing
        { 
            add { AddHandler(ToolTipClosingEvent, value); }
            remove { RemoveHandler(ToolTipClosingEvent, value); }
        }
 
        private static void OnToolTipClosingThunk(object sender, ToolTipEventArgs e)
        { 
            ((FrameworkContentElement)sender).OnToolTipClosing(e); 
        }
 
        /// 
        ///     Called when the ToolTipClosing event fires.
        ///     Allows subclasses to add functionality without having to attach
        ///     an individual handler. 
        /// 
        /// Event arguments 
        protected virtual void OnToolTipClosing(ToolTipEventArgs e) 
        {
        } 

        /// 
        ///     RoutedEvent for the ContextMenuOpening event.
        ///  
        public static readonly RoutedEvent ContextMenuOpeningEvent = ContextMenuService.ContextMenuOpeningEvent.AddOwner(typeof(FrameworkContentElement));
 
        ///  
        ///     An event that fires just before a ContextMenu should be opened.
        /// 
        ///     To manually open and close ContextMenus, mark this event as handled.
        ///     Otherwise, the value of the the ContextMenu property will be used
        ///     to automatically open a ContextMenu.
        ///  
        public event ContextMenuEventHandler ContextMenuOpening
        { 
            add { AddHandler(ContextMenuOpeningEvent, value); } 
            remove { RemoveHandler(ContextMenuOpeningEvent, value); }
        } 

        private static void OnContextMenuOpeningThunk(object sender, ContextMenuEventArgs e)
        {
            ((FrameworkContentElement)sender).OnContextMenuOpening(e); 
        }
 
        ///  
        ///     Called when ContextMenuOpening is raised on this element.
        ///  
        /// Event arguments
        protected virtual void OnContextMenuOpening(ContextMenuEventArgs e)
        {
        } 

        ///  
        ///     RoutedEvent for the ContextMenuClosing event. 
        /// 
        public static readonly RoutedEvent ContextMenuClosingEvent = ContextMenuService.ContextMenuClosingEvent.AddOwner(typeof(FrameworkContentElement)); 

        /// 
        ///     An event that fires just as a ContextMenu closes.
        ///  
        public event ContextMenuEventHandler ContextMenuClosing
        { 
            add { AddHandler(ContextMenuClosingEvent, value); } 
            remove { RemoveHandler(ContextMenuClosingEvent, value); }
        } 

        private static void OnContextMenuClosingThunk(object sender, ContextMenuEventArgs e)
        {
            ((FrameworkContentElement)sender).OnContextMenuClosing(e); 
        }
 
        ///  
        ///     Called when ContextMenuClosing is raised on this element.
        ///  
        /// Event arguments
        protected virtual void OnContextMenuClosing(ContextMenuEventArgs e)
        {
        } 

        #endregion 
 
        // This has to be virtual, since there is no concept of "core" content children,
        // so we have no choice by to rely on FrameworkContentElement to use logical 
        // children instead.
        internal override void InvalidateForceInheritPropertyOnChildren(DependencyProperty property)
        {
            IEnumerator enumerator = LogicalChildren; 

            if(enumerator != null) 
            { 
                while(enumerator.MoveNext())
                { 
                    DependencyObject child =enumerator.Current as DependencyObject;
                    if(child != null)
                    {
                        // CODE 

 
 

                        child.CoerceValue(property); 
                    }
                }
            }
        } 

        // Helper method to retrieve and fire Clr Event handlers for DependencyPropertyChanged event 
        private void RaiseDependencyPropertyChanged(EventPrivateKey key, DependencyPropertyChangedEventArgs args) 
        {
            EventHandlersStore store = EventHandlersStore; 
            if (store != null)
            {
                Delegate handler = store.Get(key);
                if (handler != null) 
                {
                    ((DependencyPropertyChangedEventHandler)handler)(this, args); 
                } 
            }
        } 

        private void EventHandlersStoreAdd(EventPrivateKey key, Delegate handler)
        {
            EnsureEventHandlersStore(); 
            EventHandlersStore.Add(key, handler);
        } 
 
        private void EventHandlersStoreRemove(EventPrivateKey key, Delegate handler)
        { 
            EventHandlersStore store = EventHandlersStore;
            if (store != null)
            {
                store.Remove(key, handler); 
            }
        } 
 
        // Gettor and Settor for flag that indicates
        // if this instance has some property values 
        // that are set to a resource reference
        internal bool HasResourceReference
        {
            get { return ReadInternalFlag(InternalFlags.HasResourceReferences); } 
            set { WriteInternalFlag(InternalFlags.HasResourceReferences, value); }
        } 
 
        internal bool IsLogicalChildrenIterationInProgress
        { 
            get { return ReadInternalFlag(InternalFlags.IsLogicalChildrenIterationInProgress); }
            set { WriteInternalFlag(InternalFlags.IsLogicalChildrenIterationInProgress, value); }
        }
 
        internal bool SubtreeHasLoadedChangeHandler
        { 
            get { return ReadInternalFlag2(InternalFlags2.TreeHasLoadedChangeHandler); } 
            set { WriteInternalFlag2(InternalFlags2.TreeHasLoadedChangeHandler, value); }
        } 

        internal bool IsLoadedCache
        {
            get { return ReadInternalFlag2(InternalFlags2.IsLoadedCache); } 
            set { WriteInternalFlag2(InternalFlags2.IsLoadedCache, value); }
        } 
 
        internal bool IsParentAnFE
        { 
            get { return ReadInternalFlag2(InternalFlags2.IsParentAnFE); }
            set { WriteInternalFlag2(InternalFlags2.IsParentAnFE, value); }
        }
 
        internal bool IsTemplatedParentAnFE
        { 
            get { return ReadInternalFlag2(InternalFlags2.IsTemplatedParentAnFE); } 
            set { WriteInternalFlag2(InternalFlags2.IsTemplatedParentAnFE, value); }
        } 

        internal bool HasLogicalChildren
        {
            get { return ReadInternalFlag(InternalFlags.HasLogicalChildren); } 
            set { WriteInternalFlag(InternalFlags.HasLogicalChildren, value); }
        } 
 
        // See comment on FrameworkElement.TemplateChildIndex
        internal int TemplateChildIndex 
        {
            get
            {
                uint childIndex = (((uint)_flags2) & 0xFFFF); 
                if (childIndex == 0xFFFF)
                { 
                    return -1; 
                }
                else 
                {
                    return (int)childIndex;
                }
            } 
            set
            { 
                // We store TemplateChildIndex as a 16-bit integer with 0xFFFF meaning "-1". 
                // Thus we support any indices in the range [-1, 65535).
                if (value < -1 || value >= 0xFFFF) 
                {
                    throw new ArgumentOutOfRangeException("value", SR.Get(SRID.TemplateChildIndexOutOfRange));
                }
 
                uint childIndex = (value == -1) ? 0xFFFF : (uint)value;
 
                _flags2 = (InternalFlags2)(childIndex | (((uint)_flags2) & 0xFFFF0000)); 
            }
        } 

        internal bool IsRequestingExpression
        {
            get { return ReadInternalFlag2(InternalFlags2.IsRequestingExpression); } 
            set { WriteInternalFlag2(InternalFlags2.IsRequestingExpression, value); }
        } 
 
        // Extracts the required flag and returns
        // bool to indicate if it is set or unset 
        internal bool ReadInternalFlag(InternalFlags reqFlag)
        {
            return (_flags & reqFlag) != 0;
        } 

        internal bool ReadInternalFlag2(InternalFlags2 reqFlag) 
        { 
            return (_flags2 & reqFlag) != 0;
        } 

        // Sets or Unsets the required flag based on
        // the bool argument
        internal void WriteInternalFlag(InternalFlags reqFlag, bool set) 
        {
            if (set) 
            { 
                _flags |= reqFlag;
            } 
            else
            {
                _flags &= (~reqFlag);
            } 
        }
 
        internal void WriteInternalFlag2(InternalFlags2 reqFlag, bool set) 
        {
            if (set) 
            {
                _flags2 |= reqFlag;
            }
            else 
            {
                _flags2 &= ~reqFlag; 
            } 
        }
 
        // Style/Template state (internals maintained by Style)
        private Style _styleCache;

        // ThemeStyle used only when a DefaultStyleKey is specified 
        private Style _themeStyleCache;
 
        // See FrameworkElement (who also have these) for details on these values. 
        internal DependencyObject _templatedParent;    // Non-null if this object was created as a result of a Template.VisualTree
 
        // Resources dictionary
        private static readonly UncommonField ResourcesField = FrameworkElement.ResourcesField;

        private InternalFlags  _flags  = 0; // field used to store various flags such as HasResourceReferences, etc. 
        private InternalFlags2 _flags2 = InternalFlags2.Default; // field used to store various flags such as HasResourceReferences, etc.
    } 
} 


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
using System; 
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel; 

using System.Diagnostics; 
using System.Globalization; 
using System.Windows.Threading;
using System.Threading; 

using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents; 

using System.Windows.Input; 
using System.Windows.Media; 
using System.Windows.Media.Animation;
using System.Windows.Media.TextFormatting; 
using System.Windows.Markup;
using System.Security.Permissions;

#if DEBUG 
using System.Reflection;
#endif 
 
using MS.Internal.Text;
using MS.Internal; 
using MS.Internal.KnownBoxes;
using MS.Internal.PresentationFramework;
using MS.Utility;
 
// Disabling 1634 and 1691:
// In order to avoid generating warnings about unknown message numbers and 
// unknown pragmas when compiling C# source code with the C# compiler, 
// you need to disable warnings 1634 and 1691. (Presharp Documentation)
#pragma warning disable 1634, 1691 

namespace System.Windows
{
    ///  
    ///     FrameworkContentElement is used to define
    ///     structure of generic content. 
    ///  
    /// 
    ///     FrameworkContentElement doesnt have its own 
    ///     rendering (rendering must be provided by content
    ///     owner). 
    ///
    ///     FrameworkContentElement  
    ///
    ///      
    ///         Directly extends ContentElement  
    ///         Is not a Visual (doesnt provide its own rendering)
    ///      
    /// 
    [StyleTypedProperty(Property = "FocusVisualStyle", StyleTargetType = typeof(Control))]
    [XmlLangProperty("Language")]
    [UsableDuringInitialization(true)] 
    public partial class FrameworkContentElement : ContentElement, IFrameworkInputElement, ISupportInitialize, IQueryAmbient
    { 
        ///  
        ///     Create an instance of a FrameworkContentElement
        ///  
        /// 
        ///     This does basic initialization of the FrameworkContentElement.  All subclasses
        ///     must call the base constructor to perform this initialization
        ///  
        public FrameworkContentElement()
        { 
            // Initialize the _styleCache to the default value for StyleProperty. 
            // If the default value is non-null then wire it to the current instance.
            PropertyMetadata metadata = StyleProperty.GetMetadata(DependencyObjectType); 
            Style defaultValue = (Style)metadata.DefaultValue;
            if (defaultValue != null)
            {
                OnStyleChanged(this, new DependencyPropertyChangedEventArgs(StyleProperty, metadata, null, defaultValue)); 
            }
 
            // Set the ShouldLookupImplicitStyles flag to true if App.Resources has implicit styles. 
            Application app = Application.Current;
            if (app != null && app.HasImplicitStylesInResources) 
            {
                ShouldLookupImplicitStyles = true;
            }
        } 

        static FrameworkContentElement() 
        { 
            PropertyChangedCallback numberSubstitutionChanged = new PropertyChangedCallback(NumberSubstitutionChanged);
            NumberSubstitution.CultureSourceProperty.OverrideMetadata(typeof(FrameworkContentElement), new FrameworkPropertyMetadata(NumberCultureSource.Text, FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsRender, numberSubstitutionChanged)); 
            NumberSubstitution.CultureOverrideProperty.OverrideMetadata(typeof(FrameworkContentElement), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsRender, numberSubstitutionChanged));
            NumberSubstitution.SubstitutionProperty.OverrideMetadata(typeof(FrameworkContentElement), new FrameworkPropertyMetadata(NumberSubstitutionMethod.AsCulture, FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsRender, numberSubstitutionChanged));

            EventManager.RegisterClassHandler(typeof(FrameworkContentElement), Mouse.QueryCursorEvent, new QueryCursorEventHandler(FrameworkContentElement.OnQueryCursor), true); 

            AllowDropProperty.OverrideMetadata(typeof(FrameworkContentElement), new FrameworkPropertyMetadata(BooleanBoxes.FalseBox, FrameworkPropertyMetadataOptions.Inherits)); 
 
            Stylus.IsPressAndHoldEnabledProperty.AddOwner(typeof(FrameworkContentElement), new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, FrameworkPropertyMetadataOptions.Inherits));
            Stylus.IsFlicksEnabledProperty.AddOwner(typeof(FrameworkContentElement), new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, FrameworkPropertyMetadataOptions.Inherits)); 
            Stylus.IsTapFeedbackEnabledProperty.AddOwner(typeof(FrameworkContentElement), new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, FrameworkPropertyMetadataOptions.Inherits));
            Stylus.IsTouchFeedbackEnabledProperty.AddOwner(typeof(FrameworkContentElement), new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, FrameworkPropertyMetadataOptions.Inherits));

            // Exposing these events in protected virtual methods 
            EventManager.RegisterClassHandler(typeof(FrameworkContentElement), ToolTipOpeningEvent, new ToolTipEventHandler(OnToolTipOpeningThunk));
            EventManager.RegisterClassHandler(typeof(FrameworkContentElement), ToolTipClosingEvent, new ToolTipEventHandler(OnToolTipClosingThunk)); 
            EventManager.RegisterClassHandler(typeof(FrameworkContentElement), ContextMenuOpeningEvent, new ContextMenuEventHandler(OnContextMenuOpeningThunk)); 
            EventManager.RegisterClassHandler(typeof(FrameworkContentElement), ContextMenuClosingEvent, new ContextMenuEventHandler(OnContextMenuClosingThunk));
            EventManager.RegisterClassHandler(typeof(FrameworkContentElement), Keyboard.GotKeyboardFocusEvent, new KeyboardFocusChangedEventHandler(OnGotKeyboardFocus)); 
            EventManager.RegisterClassHandler(typeof(FrameworkContentElement), Keyboard.LostKeyboardFocusEvent, new KeyboardFocusChangedEventHandler(OnLostKeyboardFocus));
        }

        internal static readonly NumberSubstitution DefaultNumberSubstitution = new NumberSubstitution( 
            NumberCultureSource.Text,           // number substitution in documents defaults to text culture
            null,                               // culture override 
            NumberSubstitutionMethod.AsCulture 
            );
 
        private static void NumberSubstitutionChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
        {
            ((FrameworkContentElement) o).HasNumberSubstitutionChanged = true;
        } 

 
        /// Style Dependency Property 
        [CommonDependencyProperty]
        public static readonly DependencyProperty StyleProperty = 
                FrameworkElement.StyleProperty.AddOwner(
                        typeof(FrameworkContentElement),
                        new FrameworkPropertyMetadata(
                                (Style) null,  // default value 
                                FrameworkPropertyMetadataOptions.AffectsMeasure,
                                new PropertyChangedCallback(OnStyleChanged))); 
 

        ///  
        ///     Style property
        /// 
        public Style Style
        { 
            get { return _styleCache; }
            set { SetValue(StyleProperty, value); } 
        } 

        ///  
        /// This method is used by TypeDescriptor to determine if this property should
        /// be serialized.
        /// 
        [EditorBrowsable(EditorBrowsableState.Never)] 
        public bool ShouldSerializeStyle()
        { 
            return !IsStyleSetFromGenerator 
                    && ReadLocalValue(StyleProperty) != DependencyProperty.UnsetValue;
        } 

        // Invoked when the Style property is changed
        private static void OnStyleChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            FrameworkContentElement fce = (FrameworkContentElement) d;
            fce.HasLocalStyle = (e.NewEntry.BaseValueSourceInternal == BaseValueSourceInternal.Local); 
            StyleHelper.UpdateStyleCache(null, fce, (Style) e.OldValue, (Style) e.NewValue, ref fce._styleCache); 
        }
 
        ///
        protected internal virtual void OnStyleChanged(Style oldStyle, Style newStyle)
        {
            HasStyleChanged = true; 
        }
 
        ///  
        /// OverridesDefaultStyleProperty
        ///  
        public static readonly DependencyProperty OverridesDefaultStyleProperty
            = FrameworkElement.OverridesDefaultStyleProperty.AddOwner(typeof(FrameworkContentElement),
                                           new FrameworkPropertyMetadata(
                                                        BooleanBoxes.FalseBox,   // default value 
                                                        FrameworkPropertyMetadataOptions.AffectsMeasure,
                                                        new PropertyChangedCallback(OnThemeStyleKeyChanged))); 
 

        ///  
        ///     This specifies that the current style ignores all
        ///     properties from the Theme Style
        /// 
        public bool OverridesDefaultStyle 
        {
            get { return (bool)GetValue(OverridesDefaultStyleProperty); } 
            set { SetValue(OverridesDefaultStyleProperty, BooleanBoxes.Box(value)); } 
        }
 
        /// DefaultStyleKey Dependency Property
        protected internal static readonly DependencyProperty DefaultStyleKeyProperty =
                    FrameworkElement.DefaultStyleKeyProperty.AddOwner(
                                typeof(FrameworkContentElement), 
                                new FrameworkPropertyMetadata(
                                            null,  // default value 
                                            FrameworkPropertyMetadataOptions.AffectsMeasure, 
                                            new PropertyChangedCallback(OnThemeStyleKeyChanged)));
 
        /// 
        ///     DefaultStyleKey property
        /// 
        protected internal object DefaultStyleKey 
        {
            get { return GetValue(DefaultStyleKeyProperty); } 
            set { SetValue(DefaultStyleKeyProperty, value); } 
        }
 
        // This function is called when ThemeStyleKey or OverridesThemeStyle properties change
        private static void OnThemeStyleKeyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            // Re-evaluate ThemeStyle because it is 
            // a factor of the ThemeStyleKey property
            ((FrameworkContentElement)d).UpdateThemeStyleProperty(); 
        } 

        // Cache the ThemeStyle for the current instance if there is a DefaultStyleKey specified for it 
        internal Style ThemeStyle
        {
            get { return _themeStyleCache; }
        } 

        // Returns the DependencyObjectType for the registered DefaultStyleKey's default 
        // value. Controls will override this method to return approriate types. 
        internal virtual DependencyObjectType DTypeThemeStyleKey
        { 
            get { return null; }
        }

 
        // Invoked when the ThemeStyle/DefaultStyleKey property is changed
        internal static void OnThemeStyleChanged(DependencyObject d, object oldValue, object newValue) 
        { 
            FrameworkContentElement fce = (FrameworkContentElement) d;
            StyleHelper.UpdateThemeStyleCache(null, fce, (Style) oldValue, (Style) newValue, ref fce._themeStyleCache); 
        }


        ///  
        ///     Reference to the style parent of this node, if any.
        ///  
        ///  
        ///     Reference to FrameworkElement or FrameworkContentElement whose
        ///     Template.VisualTree caused this FrameworkContentElement to be created. 
        /// 
        public DependencyObject TemplatedParent
        {
            get 
            {
                return _templatedParent; 
            } 
        }
 

        /// 
        ///     Check if resource is not empty.
        /// Call HasResources before accessing resources every time you need 
        /// to query for a resource.
        ///  
        internal bool HasResources 
        {
            get 
            {
                ResourceDictionary resources = ResourcesField.GetValue(this);
                return (resources != null &&
                        ((resources.Count > 0) || (resources.MergedDictionaries.Count > 0))); 
            }
        } 
 
        /// 
        ///     Current locally defined Resources 
        /// 
        [Ambient]
        public ResourceDictionary Resources
        { 
            get
            { 
                ResourceDictionary resources = ResourcesField.GetValue(this); 
                if (resources == null)
                { 
                    resources = new ResourceDictionary();
                    resources.AddOwner(this);
                    ResourcesField.SetValue(this, resources);
                } 

                return resources; 
            } 
            set
            { 
                ResourceDictionary oldValue = ResourcesField.GetValue(this);
                ResourcesField.SetValue(this, value);

                if (oldValue != null) 
                {
                    // This element is no longer an owner for the old RD 
                    oldValue.RemoveOwner(this); 
                }
 
                if (value != null)
                {
                    if (!value.ContainsOwner(this))
                    { 
                        // This element is an owner for the new RD
                        value.AddOwner(this); 
                    } 
                }
 
                // Invalidate ResourceReference properties for this subtree
                //

 

 
 
                if (oldValue != value)
                { 
                    TreeWalkHelper.InvalidateOnResourcesChange(null, this, new ResourcesChangeInfo(oldValue, value));
                }
            }
        } 

        bool IQueryAmbient.IsAmbientPropertyAvailable(string propertyName) 
        { 
            // We want to make sure that StaticResource resolution checks the .Resources
            // Ie.  The Ambient search should look at Resources if it is set. 
            // Even if it wasn't set from XAML (eg. the Ctor (or derived Ctor) added stuff)
            return (propertyName != "Resources" || HasResources);
        }
 
        /// 
        /// This method is used by TypeDescriptor to determine if this property should 
        /// be serialized. 
        /// 
        [EditorBrowsable(EditorBrowsableState.Never)] 
        public bool ShouldSerializeResources()
        {
            if (Resources == null || Resources.Count == 0)
            { 
                return false;
            } 
 
            return true;
        } 


        /// 
        ///     Searches for a resource with the passed resourceKey and returns it 
        /// 
        ///  
        ///     If the sources is not found on the called Element, the parent 
        ///     chain is searched, using the logical tree.
        ///  
        /// Name of the resource
        /// The found resource.  Null if not found.
        public object FindResource(object resourceKey)
        { 
            // Verify Context Access
            //             VerifyAccess(); 
 
            if (resourceKey == null)
            { 
                throw new ArgumentNullException("resourceKey");
            }

            object resource = FrameworkElement.FindResourceInternal(null /* fe */, this, resourceKey); 

            if (resource == DependencyProperty.UnsetValue) 
            { 
                // Resource not found in parent chain, app or system
                Helper.ResourceFailureThrow(resourceKey); 
            }

            return resource;
        } 

        ///  
        ///     Searches for a resource with the passed resourceKey and returns it 
        /// 
        ///  
        ///     If the sources is not found on the called Element, the parent
        ///     chain is searched, using the logical tree.
        /// 
        /// Name of the resource 
        /// The found resource.  Null if not found.
        public object TryFindResource(object resourceKey) 
        { 
            // Verify Context Access
//             VerifyAccess(); 

            if (resourceKey == null)
            {
                throw new ArgumentNullException("resourceKey"); 
            }
 
            object resource = FrameworkElement.FindResourceInternal(null /* fe */, this, resourceKey); 

            if (resource == DependencyProperty.UnsetValue) 
            {
                // Resource not found in parent chain, app or system
                // This is where we translate DependencyProperty.UnsetValue to a null
                resource = null; 
            }
 
            return resource; 
        }
 
        /// 
        ///     Searches for a resource called name and sets up a resource reference
        ///     to it for the passed property.
        ///  
        /// Property to which the resource is bound
        /// Name of the resource 
        public void SetResourceReference( 
            DependencyProperty dp,
            object             name) 
        {
            // Set the value of the property to a ResourceReferenceExpression
            SetValue(dp, new ResourceReferenceExpression(name));
 
            // Set flag indicating that the current FrameworkContentElement instance
            // has a property value set to a resource reference and hence must 
            // be invalidated on parent changed or resource property change events 
            HasResourceReference = true;
        } 

        /// 
        ///     Begins the given Storyboard as a non-controllable Storyboard and
        /// the default handoff policy. 
        /// 
        public void BeginStoryboard(Storyboard storyboard) 
        { 
            BeginStoryboard(storyboard, HandoffBehavior.SnapshotAndReplace, false);
        } 

        /// 
        ///     Begins the given Storyboard as a non-controllable Storyboard but
        /// with the given handoff policy. 
        /// 
        public void BeginStoryboard(Storyboard storyboard, HandoffBehavior handoffBehavior) 
        { 
            BeginStoryboard(storyboard, handoffBehavior, false);
        } 

        /// 
        ///     Begins the given Storyboard as a Storyboard with the given handoff
        /// policy, and with the specified state for controllability. 
        /// 
        public void BeginStoryboard(Storyboard storyboard, HandoffBehavior handoffBehavior, bool isControllable) 
        { 
            if( storyboard == null )
            { 
                throw new ArgumentNullException("storyboard");
            }

            // Storyboard.Begin is a public API and needs to be validating handoffBehavior anyway. 

            storyboard.Begin( this, handoffBehavior, isControllable ); 
        } 

        ///  
        ///     Allows subclasses to participate in property base value computation
        /// 
        /// Dependency property
        /// Type metadata of the property for the type 
        /// entry computed by base
        internal sealed override void EvaluateBaseValueCore( 
            DependencyProperty  dp, 
            PropertyMetadata    metadata,
            ref EffectiveValueEntry newEntry) 
        {
            if (dp == StyleProperty)
            {
                // If this is the first time that the StyleProperty 
                // is being fetched then mark it such
                HasStyleEverBeenFetched = true; 
 
                // Clear the flags associated with the StyleProperty
                HasImplicitStyleFromResources = false; 
                IsStyleSetFromGenerator = false;
            }

            GetRawValue(dp, metadata, ref newEntry); 
            Storyboard.GetComplexPathValue(this, dp, ref newEntry, metadata);
        } 
 
        //[CodeAnalysis("AptcaMethodsShouldOnlyCallAptcaMethods")] //Tracking Bug: 29647
        internal void GetRawValue(DependencyProperty dp, PropertyMetadata metadata, ref EffectiveValueEntry entry) 
        {
            // Check if value was resolved by base. If so, run it by animations
            if ((entry.BaseValueSourceInternal == BaseValueSourceInternal.Local) &&
                (entry.GetFlattenedEntry(RequestFlags.FullyResolved).Value != DependencyProperty.UnsetValue)) 
            {
                return; 
            } 

            // 
            // Try for container Style driven value
            //
            if (TemplateChildIndex != -1)
            { 
                // This instance is in the template child chain of a Template.VisualTree,
                //  so we need to see if the Style has an applicable value. 
                // 
                // If the parent element's style is changing, this instance is
                // in a visual tree that is being removed, and the value request 
                // is simply a result of tearing down some information in that
                // tree (e.g. a BindingExpression).  If so, just pretend there is no style (bug 991395).

                if (GetValueFromTemplatedParent(dp, ref entry)) 
                {
                    return; 
                } 
            }
 

            //
            // Try for Styled value
            // 

            // Here are some of the implicit rules used by GetRawValue, 
            // while querying properties on the container. 
            // 1. Style property cannot be specified in a Style
            // 2. Style property cannot be specified in a ThemeStyle 
            // 3. Style property cannot be specified in a Template
            // 4. DefaultStyleKey property cannot be specified in a ThemeStyle
            // 5. DefaultStyleKey property cannot be specified in a Template
            // 6. Template property cannot be specified in a Template 

            if (dp != StyleProperty) 
            { 
                if (StyleHelper.GetValueFromStyleOrTemplate(new FrameworkObject(null, this), dp, ref entry))
                { 
                    return;
                }
            }
            else 
            {
                object source; 
                object implicitValue = FrameworkElement.FindImplicitStyleResource(this, this.GetType(), out source); 
                if (implicitValue != DependencyProperty.UnsetValue)
                { 
                    // Commented this because the implicit fetch could also return a DeferredDictionaryReference
                    // if (!(implicitValue is Style))
                    // {
                    //     throw new InvalidOperationException(SR.Get(SRID.InvalidImplicitStyleResource, this.GetType().Name, implicitValue)); 
                    // }
 
                    // This style has been fetched from resources 
                    HasImplicitStyleFromResources = true;
 
                    entry.BaseValueSourceInternal = BaseValueSourceInternal.ImplicitReference;
                    entry.Value = implicitValue;
                    return;
                } 
            }
 
            // 
            // Try for Inherited value
            // 
            FrameworkPropertyMetadata fmetadata = metadata as FrameworkPropertyMetadata;

            // Note that for inheritable properties that override the default value a parent can impart
            // its default value to the child even though the property may not have been set locally or 
            // via a style or template (ie. IsUsed flag would be false).
            if (fmetadata != null) 
            { 
                if (fmetadata.Inherits)
                { 
                    //
                    // Inheritance
                    //
 
                    if (!TreeWalkHelper.SkipNext(InheritanceBehavior) || fmetadata.OverridesInheritanceBehavior == true)
                    { 
                        // Used to terminate tree walk if a tree boundary is hit 
                        InheritanceBehavior inheritanceBehavior;
 
                        FrameworkContentElement parentFCE;
                        FrameworkElement parentFE;
                        bool hasParent = FrameworkElement.GetFrameworkParent(this, out parentFE, out parentFCE);
                        while (hasParent) 
                        {
                            bool inheritanceNode; 
                            if (parentFE != null) 
                            {
                                inheritanceNode = TreeWalkHelper.IsInheritanceNode(parentFE, dp, out inheritanceBehavior); 
                            }
                            else // (parentFCE != null)
                            {
                                inheritanceNode = TreeWalkHelper.IsInheritanceNode(parentFCE, dp, out inheritanceBehavior); 
                            }
 
                            // If the current node has SkipNow semantics then we do 
                            // not need to lookup the inheritable value on it.
                            if (TreeWalkHelper.SkipNow(inheritanceBehavior)) 
                            {
                                break;
                            }
 
                            // Check if node is an inheritance node, if so, query it
                            if (inheritanceNode) 
                            { 
                                #region EventTracing
                                if (EventTrace.IsEnabled(EventTrace.Keyword.KeywordGeneral, EventTrace.Level.Verbose)) 
                                {
                                    string TypeAndName = "[" + GetType().Name + "]" + dp.Name;
                                    EventTrace.EventProvider.TraceEvent(EventTrace.Event.WClientPropParentCheck,
                                                                         EventTrace.Keyword.KeywordGeneral, EventTrace.Level.Verbose, 
                                                                         GetHashCode(), TypeAndName);
                                } 
                                #endregion EventTracing 
                                DependencyObject parentDO = parentFE;
                                if (parentDO == null) 
                                {
                                    parentDO = parentFCE;
                                }
 
                                EntryIndex entryIndex = parentDO.LookupEntry(dp.GlobalIndex);
 
                                entry = parentDO.GetValueEntry( 
                                                entryIndex,
                                                dp, 
                                                fmetadata,
                                                RequestFlags.SkipDefault | RequestFlags.DeferredReferences);

                                if (entry.Value != DependencyProperty.UnsetValue) 
                                {
                                    entry.BaseValueSourceInternal = BaseValueSourceInternal.Inherited; 
                                } 
                                return;
                            } 

                            // If the current node has SkipNext semantics then we do
                            // not need to lookup the inheritable value on its parent.
                            if (TreeWalkHelper.SkipNext(inheritanceBehavior)) 
                            {
                                break; 
                            } 

                            // No boundary or inheritance node found, continue search 
                            if (parentFE != null)
                            {
                                hasParent = FrameworkElement.GetFrameworkParent(parentFE, out parentFE, out parentFCE);
                            } 
                            else
                            { 
                                hasParent = FrameworkElement.GetFrameworkParent(parentFCE, out parentFE, out parentFCE); 
                            }
                        } 
                    }
                }

 
            }
 
            // No value found. 
            Debug.Assert(entry.Value == DependencyProperty.UnsetValue);
        } 

        // This FrameworkElement has been established to be a Template.VisualTree
        //  node of a parent object.  Ask the TemplatedParent's Style object if
        //  they have a value for us. 

        private bool GetValueFromTemplatedParent(DependencyProperty dp, ref EffectiveValueEntry entry) 
        { 
            FrameworkTemplate frameworkTemplate = null;
            FrameworkElement feTemplatedParent = (FrameworkElement)_templatedParent; 
            frameworkTemplate = feTemplatedParent.TemplateInternal;

            if (frameworkTemplate != null)
            { 
                return StyleHelper.GetValueFromTemplatedParent(
                    _templatedParent, 
                    TemplateChildIndex, 
                    new FrameworkObject(null, this),
                    dp, 
                    ref frameworkTemplate.ChildRecordFromChildIndex,
                    frameworkTemplate.VisualTree,
                    ref entry);
            } 

            return false; 
        } 

 
        // Like GetValueCore, except it returns the expression (if any) instead of its value
        internal Expression GetExpressionCore(DependencyProperty dp, PropertyMetadata metadata)
        {
            this.IsRequestingExpression = true; 
            EffectiveValueEntry entry = new EffectiveValueEntry(dp);
            entry.Value = DependencyProperty.UnsetValue; 
            this.EvaluateBaseValueCore(dp, metadata, ref entry); 
            this.IsRequestingExpression = false;
 
            return entry.Value as Expression;
        }

 
        /// 
        ///     Notification that a specified property has been changed 
        ///  
        /// EventArgs that contains the property, metadata, old value, and new value for this change
        protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e) 
        {
            DependencyProperty dp = e.Property;

            base.OnPropertyChanged(e); 

            if (e.IsAValueChange || e.IsASubPropertyChange) 
            { 
                //
                // Try to fire the Loaded event on the root of the tree 
                // because for this case the OnParentChanged will not
                // have a chance to fire the Loaded event.
                //
                if (dp != null && dp.OwnerType == typeof(PresentationSource) && dp.Name == "RootSource") 
                {
                    TryFireInitialized(); 
                } 

                if (dp == FrameworkElement.NameProperty && 
                    EventTrace.IsEnabled(EventTrace.Keyword.KeywordGeneral, EventTrace.Level.Verbose))
                {
                    EventTrace.EventProvider.TraceEvent(EventTrace.Event.PerfElementIDName, EventTrace.Keyword.KeywordGeneral, EventTrace.Level.Verbose,
                            PerfService.GetPerfElementID(this), GetType().Name, GetValue(dp)); 
                }
 
                // 
                // Invalidation propagation for Styles
                // 

                // Regardless of metadata, the Style/DefaultStyleKey properties are never a trigger drivers
                if (dp != StyleProperty && dp != DefaultStyleKeyProperty)
                { 
                    // Note even properties on non-container nodes within a template could be driving a trigger
                    if (TemplatedParent != null) 
                    { 
                        FrameworkElement feTemplatedParent = TemplatedParent as FrameworkElement;
 
                        FrameworkTemplate frameworkTemplate = feTemplatedParent.TemplateInternal;
                        StyleHelper.OnTriggerSourcePropertyInvalidated(null, frameworkTemplate, TemplatedParent, dp, e, false /*invalidateOnlyContainer*/,
                            ref frameworkTemplate.TriggerSourceRecordFromChildIndex, ref frameworkTemplate.PropertyTriggersWithActions, TemplateChildIndex /*sourceChildIndex*/);
                    } 

                    // Do not validate Style during an invalidation if the Style was 
                    // never used before (dependents do not need invalidation) 
                    if (Style != null)
                    { 
                        StyleHelper.OnTriggerSourcePropertyInvalidated(Style, null, this, dp, e, true /*invalidateOnlyContainer*/,
                            ref Style.TriggerSourceRecordFromChildIndex, ref Style.PropertyTriggersWithActions, 0 /*sourceChildId*/); // Style can only have triggers that are driven by properties on the container
                    }
 
                    // Do not validate Template during an invalidation if the Template was
                    // never used before (dependents do not need invalidation) 
 
                    // There may be container dependents in the ThemeStyle. Invalidate them.
                    if (ThemeStyle != null && Style != ThemeStyle) 
                    {
                        StyleHelper.OnTriggerSourcePropertyInvalidated(ThemeStyle, null, this, dp, e, true /*invalidateOnlyContainer*/,
                            ref ThemeStyle.TriggerSourceRecordFromChildIndex, ref ThemeStyle.PropertyTriggersWithActions, 0 /*sourceChildIndex*/); // ThemeStyle can only have triggers that are driven by properties on the container
                    } 
                }
            } 
 
            FrameworkPropertyMetadata fmetadata = e.Metadata as FrameworkPropertyMetadata;
 
            //
            // Invalidation propagation for Groups and Inheritance
            //
 
            // Metadata must exist specifically stating propagate invalidation
            // due to group or inheritance 
            if (fmetadata != null) 
            {
                // 
                // Inheritance
                //

                if (fmetadata.Inherits) 
                {
                    // Invalidate Inheritable descendents only if instance is not a TreeSeparator 
                    // or fmetadata.OverridesInheritanceBehavior is set to override separated tree behavior 
                    if ((InheritanceBehavior == InheritanceBehavior.Default || fmetadata.OverridesInheritanceBehavior) &&
                        (!DependencyObject.IsTreeWalkOperation(e.OperationType) || PotentiallyHasMentees)) 
                    {
                        EffectiveValueEntry newEntry = e.NewEntry;
                        EffectiveValueEntry oldEntry = e.OldEntry;
                        if (oldEntry.BaseValueSourceInternal > newEntry.BaseValueSourceInternal) 
                        {
                            // valuesource == Inherited && value == UnsetValue indicates that we are clearing the inherited value 
                            newEntry = new EffectiveValueEntry(dp, BaseValueSourceInternal.Inherited); 
                        }
                        else 
                        {
                            newEntry = newEntry.GetFlattenedEntry(RequestFlags.FullyResolved);
                            newEntry.BaseValueSourceInternal = BaseValueSourceInternal.Inherited;
                        } 

                        if (oldEntry.BaseValueSourceInternal != BaseValueSourceInternal.Default || oldEntry.HasModifiers) 
                        { 
                            oldEntry = oldEntry.GetFlattenedEntry(RequestFlags.FullyResolved);
                            oldEntry.BaseValueSourceInternal = BaseValueSourceInternal.Inherited; 
                        }
                        else
                        {
                            // we use an empty EffectiveValueEntry as a signal that the old entry was the default value 
                            oldEntry = new EffectiveValueEntry();
                        } 
 
                        InheritablePropertyChangeInfo info =
                                new InheritablePropertyChangeInfo( 
                                        dp,
                                        oldEntry,
                                        newEntry);
 
                        // Don't InvalidateTree if we're in the middle of doing it.
                        if (!DependencyObject.IsTreeWalkOperation(e.OperationType)) 
                        { 
                            TreeWalkHelper.InvalidateOnInheritablePropertyChange(null, this, info, true);
                        } 

                        // Notify mentees if they exist
                        if (PotentiallyHasMentees)
                        { 
                            TreeWalkHelper.OnInheritedPropertyChanged(this, ref info, InheritanceBehavior);
                        } 
                    } 
                }
            } 
        }

        /// 
        ///     The DependencyProperty for the Name property. 
        /// 
        public static readonly DependencyProperty NameProperty = 
                    FrameworkElement.NameProperty.AddOwner( 
                                typeof(FrameworkContentElement),
                                new FrameworkPropertyMetadata(string.Empty)); 

        /// 
        ///     Name property.
        ///  
        [MergableProperty(false)]
        [Localizability(LocalizationCategory.NeverLocalize)] // cannot be localized 
        public string Name 
        {
            get { return (string) GetValue(NameProperty); } 
            set { SetValue(NameProperty, value); }
        }

        ///  
        ///     The DependencyProperty for the Tag property.
        ///  
        public static readonly DependencyProperty TagProperty = 
                    FrameworkElement.TagProperty.AddOwner(
                                typeof(FrameworkContentElement), 
                                new FrameworkPropertyMetadata((object) null));

        /// 
        ///     Tag property. 
        /// 
        public object Tag 
        { 
            get { return GetValue(TagProperty); }
            set { SetValue(TagProperty, value); } 
        }

        #region Language
 
        /// 
        /// Language can be specified in xaml at any point using the xml language attribute xml:lang. 
        /// This will make the culture pertain to the scope of the element where it is applied.  The 
        /// XmlLanguage names follow the RFC 3066 standard. For example, U.S. English is "en-US".
        ///  
        static public readonly DependencyProperty LanguageProperty =
                    FrameworkElement.LanguageProperty.AddOwner(
                                typeof(FrameworkContentElement),
                                new FrameworkPropertyMetadata( 
                                        XmlLanguage.GetLanguage("en-US"),
                                        FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsMeasure)); 
 
        /// 
        /// Language can be specified in xaml at any point using the xml language attribute xml:lang. 
        /// This will make the culture pertain to the scope of the element where it is applied.  The
        /// XmlLanguage names follow the RFC 3066 standard. For example, U.S. English is "en-US".
        /// 
        public XmlLanguage Language 
        {
            get { return (XmlLanguage) GetValue(LanguageProperty); } 
            set { SetValue(LanguageProperty, value); } 
        }
        #endregion Language 

        #region Input

        ///  
        /// FocusVisualStyleProperty
        ///  
        public static readonly DependencyProperty FocusVisualStyleProperty = 
                    FrameworkElement.FocusVisualStyleProperty.AddOwner(typeof(FrameworkContentElement),
                    new FrameworkPropertyMetadata(FrameworkElement.DefaultFocusVisualStyle)); 

        /// 
        /// FocusVisualStyle Property
        ///  
        public Style FocusVisualStyle
        { 
            get { return (Style) GetValue(FocusVisualStyleProperty); } 
            set { SetValue(FocusVisualStyleProperty, value); }
        } 

        /// 
        ///     CursorProperty
        ///  
        public static readonly DependencyProperty CursorProperty =
                    FrameworkElement.CursorProperty.AddOwner( 
                                typeof(FrameworkContentElement), 
                                new FrameworkPropertyMetadata(
                                            (object) null, // default value 
                                            0,
                                            new PropertyChangedCallback(OnCursorChanged)));

        ///  
        ///     Cursor Property
        ///  
        public System.Windows.Input.Cursor Cursor 
        {
            get { return (System.Windows.Input.Cursor)GetValue(CursorProperty); } 

            set { SetValue(CursorProperty, value); }
        }
 
        // If the cursor is changed, we may need to set the actual cursor.
        static private void OnCursorChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        { 
            FrameworkContentElement fce = ((FrameworkContentElement)d);
 
            if(fce.IsMouseOver)
            {
                Mouse.UpdateCursor();
            } 
        }
 
        ///  
        ///     ForceCursorProperty
        ///  
        public static readonly DependencyProperty ForceCursorProperty =
                    FrameworkElement.ForceCursorProperty.AddOwner(
                                typeof(FrameworkContentElement),
                                new FrameworkPropertyMetadata( 
                                            BooleanBoxes.FalseBox, // default value
                                            0, 
                                            new PropertyChangedCallback(OnForceCursorChanged))); 

 
        /// 
        ///     ForceCursor Property
        /// 
        public bool ForceCursor 
        {
            get { return (bool) GetValue(ForceCursorProperty); } 
            set { SetValue(ForceCursorProperty, BooleanBoxes.Box(value)); } 
        }
 
        // If the ForceCursor property changed, we may need to set the actual cursor.
        static private void OnForceCursorChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            FrameworkContentElement fce = ((FrameworkContentElement)d); 

            if (fce.IsMouseOver) 
            { 
                Mouse.UpdateCursor();
            } 
        }

        private static void OnQueryCursor(object sender, QueryCursorEventArgs e)
        { 
            FrameworkContentElement fce = (FrameworkContentElement) sender;
 
            // We respond to querying the cursor by specifying the cursor set 
            // as a property on this element.
            Cursor cursor = fce.Cursor; 

            if(cursor != null)
            {
                // We specify the cursor if the QueryCursor event is not 
                // handled by the time it gets to us, or if we are configured
                // to force our cursor anyways.  Since the QueryCursor event 
                // bubbles, this has the effect of overriding whatever cursor 
                // a child of ours specified.
                if(!e.Handled || fce.ForceCursor) 
                {
                    e.Cursor = cursor;
                    e.Handled = true;
                } 
            }
        } 
 
        // Keyboard
        ///  
        ///     Request to move the focus from this element to another element
        /// 
        /// 
        ///     The direction that focus is to move. 
        /// 
        ///  Returns true if focus is moved successfully. Returns false if there is no next element 
        public sealed override bool MoveFocus(TraversalRequest request) 
        {
            if (request == null) 
            {
                throw new ArgumentNullException("request");
            }
 
            return KeyboardNavigation.Current.Navigate(this, request);
        } 
 
        /// 
        ///     Request to predict the element that should receive focus relative to this element for a 
        /// given direction, without actually moving focus to it.
        /// 
        /// The direction for which focus should be predicted
        ///  
        ///     Returns the next element that focus should move to for a given FocusNavigationDirection.
        /// Returns null if focus cannot be moved relative to this element. 
        ///  
        public sealed override DependencyObject PredictFocus(FocusNavigationDirection direction)
        { 
            return KeyboardNavigation.Current.PredictFocusedElement(this, direction);
        }

        ///  
        ///     This method is invoked when the IsFocused property changes to true
        ///  
        /// RoutedEventArgs 
        protected override void OnGotFocus(RoutedEventArgs e)
        { 
            // Scroll the element into view if currently focused
            if (IsKeyboardFocused)
                BringIntoView();
 
            base.OnGotFocus(e);
        } 
 
        private static void OnGotKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
        { 
            // This static class handler will get hit each time anybody gets hit with a tunnel that someone is getting focused.
            // We're only interested when the element is getting focused is processing the event.
            // NB: This will not do the right thing if the element rejects focus or does not want to be scrolled into view.
            if (sender == e.OriginalSource) 
            {
                FrameworkContentElement fce = (FrameworkContentElement)sender; 
                KeyboardNavigation.UpdateFocusedElement(fce); 

                KeyboardNavigation keyNav = KeyboardNavigation.Current; 
                KeyboardNavigation.ShowFocusVisual();
                keyNav.UpdateActiveElement(fce);
            }
        } 

        private static void OnLostKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e) 
        { 
            if (sender == e.OriginalSource)
            { 
                KeyboardNavigation.Current.HideFocusVisual();

                if (e.NewFocus == null)
                { 
                    KeyboardNavigation.Current.NotifyFocusChanged(sender, e);
                } 
            } 
        }
 
        /// 
        /// Attempts to bring this element into view by originating a RequestBringIntoView event.
        /// 
        public void BringIntoView() 
        {
            RequestBringIntoViewEventArgs args = new RequestBringIntoViewEventArgs(this, Rect.Empty); 
            args.RoutedEvent=FrameworkElement.RequestBringIntoViewEvent; 
            RaiseEvent(args);
        } 

        #endregion Input

        #region InputScope 

        ///  
        ///     InputScope DependencyProperty 
        ///     this is originally registered on InputMethod class
        ///  
        public static readonly DependencyProperty InputScopeProperty =
                    InputMethod.InputScopeProperty.AddOwner(typeof(FrameworkContentElement),
                                new FrameworkPropertyMetadata((InputScope)null, // default value
                                            FrameworkPropertyMetadataOptions.Inherits)); 

        ///  
        ///     InputScope Property accessor 
        /// 
        public InputScope InputScope 
        {
            get { return (InputScope) GetValue(InputScopeProperty); }
            set { SetValue(InputScopeProperty, value); }
        } 

        #endregion InputScope 
 
        #region Data binding
 
        /// 
        /// Add / Remove TargetUpdatedEvent handler
        /// 
        public event EventHandler TargetUpdated 
        {
            add     { AddHandler(Binding.TargetUpdatedEvent, value); } 
            remove  { RemoveHandler(Binding.TargetUpdatedEvent, value); } 
        }
 

        /// 
        /// Add / Remove SourceUpdatedEvent handler
        ///  
        public event EventHandler SourceUpdated
        { 
            add     { AddHandler(Binding.SourceUpdatedEvent, value); } 
            remove  { RemoveHandler(Binding.SourceUpdatedEvent, value); }
        } 


        /// 
        ///     DataContext DependencyProperty 
        /// 
        public static readonly DependencyProperty DataContextProperty = 
                FrameworkElement.DataContextProperty.AddOwner( 
                        typeof(FrameworkContentElement),
                        new FrameworkPropertyMetadata(null, 
                                FrameworkPropertyMetadataOptions.Inherits,
                                new PropertyChangedCallback(OnDataContextChanged)));

        ///  
        ///     DataContextChanged event
        ///  
        ///  
        ///     When an element's DataContext changes, all data-bound properties
        ///     (on this element or any other element) whose Binding use this 
        ///     DataContext will change to reflect the new value.  There is no
        ///     guarantee made about the order of these changes relative to the
        ///     raising of the DataContextChanged event.  The changes can happen
        ///     before the event, after the event, or in any mixture. 
        /// 
        public event DependencyPropertyChangedEventHandler DataContextChanged 
        { 
            add { EventHandlersStoreAdd(FrameworkElement.DataContextChangedKey, value); }
            remove { EventHandlersStoreRemove(FrameworkElement.DataContextChangedKey, value); } 
        }

        /// 
        ///     DataContext Property 
        /// 
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] 
        [Localizability(LocalizationCategory.NeverLocalize)] 
        public object DataContext
        { 
            get { return GetValue(DataContextProperty); }
            set { SetValue(DataContextProperty, value); }
        }
 
        private static void OnDataContextChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            ((FrameworkContentElement) d).RaiseDependencyPropertyChanged(FrameworkElement.DataContextChangedKey, e); 
        }
 
        /// 
        /// Get the BindingExpression for the given property
        /// 
        /// DependencyProperty that represents the property 
        ///  BindingExpression if property is data-bound, null if it is not
        public BindingExpression GetBindingExpression(DependencyProperty dp) 
        { 
            return BindingOperations.GetBindingExpression(this, dp);
        } 

        /// 
        /// Attach a data Binding to a property
        ///  
        /// DependencyProperty that represents the property
        /// description of Binding to attach 
        public BindingExpressionBase SetBinding(DependencyProperty dp, BindingBase binding) 
        {
            return BindingOperations.SetBinding(this, dp, binding); 
        }

        /// 
        /// Convenience method.  Create a BindingExpression and attach it. 
        /// Most fields of the BindingExpression get default values.
        ///  
        /// DependencyProperty that represents the property 
        /// source path
        public BindingExpression SetBinding(DependencyProperty dp, string path) 
        {
            return (BindingExpression)SetBinding(dp, new Binding(path));
        }
 
        /// 
        ///     BindingGroup DependencyProperty 
        ///  
        public static readonly DependencyProperty BindingGroupProperty =
                FrameworkElement.BindingGroupProperty.AddOwner( 
                        typeof(FrameworkContentElement),
                        new FrameworkPropertyMetadata(null,
                                FrameworkPropertyMetadataOptions.Inherits));
 
        /// 
        ///     BindingGroup Property 
        ///  
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Localizability(LocalizationCategory.NeverLocalize)] 
        public BindingGroup BindingGroup
        {
            get { return (BindingGroup)GetValue(BindingGroupProperty); }
            set { SetValue(BindingGroupProperty, value); } 
        }
 
        #endregion Data binding 

        #region LogicalTree 

        /// 
        ///     Returns a non-null value when some framework implementation
        ///     of this method has a non-visual parent connection, 
        /// 
        protected internal override DependencyObject GetUIParentCore() 
        { 
            return this._parent;
        } 

        /// 
        ///     Allows adjustment to the event source
        ///  
        /// 
        ///     Subclasses must override this method 
        ///     to be able to adjust the source during 
        ///     route invocation 
        /// 
        ///     NOTE: Expected to return null when no
        ///     change is made to source
        /// 
        ///  
        ///     Routed Event Args
        ///  
        ///  
        ///     Returns new source
        ///  
        internal override object AdjustEventSource(RoutedEventArgs args)
        {
            object source = null;
 
            // As part of routing events through logical trees, we have
            // to be careful about events that come to us from "foreign" 
            // trees.  For example, the event could come from an element 
            // in our "implementation" visual tree, or from an element
            // in a different logical tree all together. 
            //
            // Note that we consider ourselves to be part of a logical tree
            // if we have either a logical parent, or any logical children.
            // 
            //
 
            if(_parent != null || HasLogicalChildren) 
            {
                DependencyObject logicalSource = args.Source as DependencyObject; 
                if(logicalSource == null || !IsLogicalDescendent(logicalSource))
                {
                    args.Source=this;
                    source = this; 
                }
            } 
 
            return source;
        } 

        // Allows adjustments to the branch source popped off the stack
        internal virtual void AdjustBranchSource(RoutedEventArgs args)
        { 
        }
 
        //CASRemoval:[StrongNameIdentityPermissionAttribute(SecurityAction.InheritanceDemand, PublicKey=Microsoft.Internal.BuildInfo.WCP_PUBLIC_KEY_STRING)] 
        internal virtual bool IgnoreModelParentBuildRoute(RoutedEventArgs args)
        { 
            return false;
        }

        ///  
        ///     Allows FrameworkElement to augment the
        ///      
        ///  
        /// 
        ///     NOTE: If this instance does not have a 
        ///     visualParent but has a model parent
        ///     then route is built through the model
        ///     parent
        ///  
        /// 
        ///     The  to be 
        ///     augmented 
        /// 
        ///  
        ///      for the
        ///     RoutedEvent to be raised post building
        ///     the route
        ///  
        /// 
        ///     Whether or not the route should continue past the visual tree. 
        ///     If this is true, and there are no more visual parents, the route 
        ///     building code will call the GetUIParentCore method to find the
        ///     next non-visual parent. 
        /// 
        internal override sealed bool BuildRouteCore(EventRoute route, RoutedEventArgs args)
        {
            bool continuePastCoreTree = false; 

            // Verify Context Access 
//             VerifyAccess(); 

            DependencyObject visualParent = (DependencyObject) ContentOperations.GetParent(this); 
            DependencyObject modelParent = this._parent;

            // FrameworkElement extends the basic event routing strategy by
            // introducing the concept of a logical tree.  When an event 
            // passes through an element in a logical tree, the source of
            // the event needs to change to the leaf-most node in the same 
            // logical tree that is in the route. 

            // Check the route to see if we are returning into a logical tree 
            // that we left before.  If so, restore the source of the event to
            // be the source that it was when we left the logical tree.
            DependencyObject branchNode = route.PeekBranchNode() as DependencyObject;
            if (branchNode != null && IsLogicalDescendent(branchNode)) 
            {
                // We keep the most recent source in the event args.  Note that 
                // this is only for our consumption.  Once the event is raised, 
                // it will use the source information in the route.
                args.Source  = (route.PeekBranchSource()); 

                AdjustBranchSource(args);

                route.AddSource(args.Source); 

                // By popping the branch node we will also be setting the source 
                // in the event route. 
                route.PopBranchNode();
 
                // Add intermediate ContentElements to the route
                FrameworkElement.AddIntermediateElementsToRoute(this, route, args, LogicalTreeHelper.GetParent(branchNode));
            }
 

            // Check if the next element in the route is in a different 
            // logical tree. 

            if (!IgnoreModelParentBuildRoute(args)) 
            {
                // If there is no visual parent, route via the model tree.
                if (visualParent == null)
                { 
                    continuePastCoreTree = modelParent != null;
                } 
                else if(modelParent != null) 
                {
                    // If there is a model parent, record the branch node. 
                    route.PushBranchNode(this, args.Source);

                    // The source is going to be the visual parent, which
                    // could live in a different logical tree. 
                    args.Source  = (visualParent);
                } 
 
            }
 
            return continuePastCoreTree;
        }

        ///  
        ///     Add Style TargetType and FEF EventHandlers to the EventRoute
        ///  
        internal override void AddToEventRouteCore(EventRoute route, RoutedEventArgs args) 
        {
            FrameworkElement.AddStyleHandlersToEventRoute(null, this, route, args); 
        }

        // Returns if the given child instance is a logical descendent
        private bool IsLogicalDescendent(DependencyObject child) 
        {
            while (child != null) 
            { 
                if (child == this)
                { 
                    return true;
                }

                child = LogicalTreeHelper.GetParent(child); 
            }
 
            return false; 
        }
 
        /// 
        ///     Invoked when ancestor is changed.  This is invoked after
        ///     the ancestor has changed, and the purpose is to allow elements to
        ///     perform actions based on the changed ancestor. 
        /// 
        //CASRemoval:[StrongNameIdentityPermissionAttribute(SecurityAction.InheritanceDemand, PublicKey=Microsoft.Internal.BuildInfo.WCP_PUBLIC_KEY_STRING)] 
        internal virtual void OnAncestorChanged() 
        {
        } 

        /// 
        /// OnContentParentChanged is called when the parent of the content element is changed.
        ///  
        /// Old parent or null if the content element did not have a parent before.
        internal override void OnContentParentChanged(DependencyObject oldParent) 
        { 
            DependencyObject newParent = ContentOperations.GetParent(this);
 
            // Initialize, if not already done
            TryFireInitialized();

            base.OnContentParentChanged(oldParent); 
        }
 
        ///  
        ///     Indicates the current mode of lookup for both inheritance and resources.
        ///  
        /// 
        ///     Used in property inheritence and reverse
        ///     inheritence and resource lookup to stop at
        ///     logical tree boundaries 
        ///
        ///     It is also used by designers such as Sparkle to 
        ///     skip past the app resources directly to the theme. 
        ///     They are expected to merge in the client's app
        ///     resources via the MergedDictionaries feature on 
        ///     root element of the tree.
        ///
        ///     NOTE: Property can be set only when the
        ///     instance is not yet hooked to the tree. This 
        ///     is to encourage setting it at construction time.
        ///     If we didn't restrict it to (roughly) construction 
        ///     time, we would have to take the complexity of 
        ///     firing property invalidations when the flag was
        ///     changed. 
        /// 
        internal InheritanceBehavior InheritanceBehavior
        {
            get 
            {
                Debug.Assert((uint)InternalFlags.InheritanceBehavior0 == 0x08); 
                Debug.Assert((uint)InternalFlags.InheritanceBehavior1 == 0x10); 
                Debug.Assert((uint)InternalFlags.InheritanceBehavior2 == 0x20);
 
                const uint inheritanceBehaviorMask =
                    (uint)InternalFlags.InheritanceBehavior0 +
                    (uint)InternalFlags.InheritanceBehavior1 +
                    (uint)InternalFlags.InheritanceBehavior2; 

                uint inheritanceBehavior = ((uint)_flags & inheritanceBehaviorMask) >> 3; 
                return (InheritanceBehavior)inheritanceBehavior; 
            }
 
            set
            {
                Debug.Assert((uint)InternalFlags.InheritanceBehavior0 == 0x08);
                Debug.Assert((uint)InternalFlags.InheritanceBehavior1 == 0x10); 
                Debug.Assert((uint)InternalFlags.InheritanceBehavior2 == 0x20);
 
                const uint inheritanceBehaviorMask = 
                    (uint)InternalFlags.InheritanceBehavior0 +
                    (uint)InternalFlags.InheritanceBehavior1 + 
                    (uint)InternalFlags.InheritanceBehavior2;

                if (!this.IsInitialized)
                { 
                    if ((uint)value < 0 ||
                        (uint)value > (uint)InheritanceBehavior.SkipAllNext) 
                    { 
                        throw new InvalidEnumArgumentException("value", (int)value, typeof(InheritanceBehavior));
                    } 

                    uint inheritanceBehavior = (uint)value << 3;

                    _flags = (InternalFlags)((inheritanceBehavior & inheritanceBehaviorMask) | (((uint)_flags) & ~inheritanceBehaviorMask)); 

                    if (_parent != null) 
                    { 
                        // This means that we are in the process of xaml parsing:
                        // an instance of FCE has been created and added to a parent, 
                        // but no children yet added to it (otherwise it would be initialized already
                        // and we would not be allowed to change InheritanceBehavior).
                        // So we need to re-calculate properties accounting for the new
                        // inheritance behavior. 
                        // This must have no performance effect as the subtree of this
                        // element is empty (no children yet added). 
                        TreeWalkHelper.InvalidateOnTreeChange(/*fe:*/null, /*fce:*/this, _parent, true); 
                    }
                } 
                else
                {
                    throw new InvalidOperationException(SR.Get(SRID.Illegal_InheritanceBehaviorSettor));
                } 
            }
        } 
 
        #endregion LogicalTree
 
        #region ISupportInitialize

        /// 
        ///     Initialization of this element is about to begin 
        /// 
        public virtual void BeginInit() 
        { 
            // Nested BeginInits on the same instance aren't permitted
            if (ReadInternalFlag(InternalFlags.InitPending)) 
            {
                throw new InvalidOperationException(SR.Get(SRID.NestedBeginInitNotSupported));
            }
 
            // Mark the element as pending initialization
            WriteInternalFlag(InternalFlags.InitPending, true); 
        } 

        ///  
        ///     Initialization of this element has completed
        /// 
        public virtual void EndInit()
        { 
            // Every EndInit must be preceeded by a BeginInit
            if (!ReadInternalFlag(InternalFlags.InitPending)) 
            { 
                throw new InvalidOperationException(SR.Get(SRID.EndInitWithoutBeginInitNotSupported));
            } 

            // Reset the pending flag
            WriteInternalFlag(InternalFlags.InitPending, false);
 
            // Mark the element initialized and fire Initialized event
            // (eg. tree building via parser) 
            TryFireInitialized(); 
        }
 
        /// 
        ///     Has this element been initialized
        /// 
        ///  
        ///     True if either EndInit or OnParentChanged were called
        ///  
        [EditorBrowsable(EditorBrowsableState.Advanced)] 
        public bool IsInitialized
        { 
            get { return ReadInternalFlag(InternalFlags.IsInitialized); }
        }

        ///  
        ///     This clr event is fired when
        ///      
        ///     becomes true 
        /// 
        [EditorBrowsable(EditorBrowsableState.Advanced)] 
        public event EventHandler Initialized
        {
            add { EventHandlersStoreAdd(FrameworkElement.InitializedKey, value); }
            remove { EventHandlersStoreRemove(FrameworkElement.InitializedKey, value); } 
        }
 
        ///  
        ///     This virtual method in called when IsInitialized is set to true and it raises an Initialized event
        ///  
        protected virtual void OnInitialized(EventArgs e)
        {
            // Need to update the StyleProperty so that we can pickup
            // the implicit style if it hasn't already been fetched 
            if (!HasStyleEverBeenFetched)
            { 
                UpdateStyleProperty(); 
            }
 
            // Need to update the ThemeStyleProperty so that we can pickup
            // the implicit style if it hasn't already been fetched
            if (!HasThemeStyleEverBeenFetched)
            { 
                UpdateThemeStyleProperty();
            } 
 
            RaiseInitialized(FrameworkElement.InitializedKey, e);
        } 

        // Helper method that tries to set IsInitialized to true
        // and Fire the Initialized event
        // This method can be invoked from two locations 
        //      1> EndInit
        //      2> OnParentChanged 
        private void TryFireInitialized() 
        {
            if (!ReadInternalFlag(InternalFlags.InitPending) && 
                !ReadInternalFlag(InternalFlags.IsInitialized))
            {
                WriteInternalFlag(InternalFlags.IsInitialized, true);
 
                OnInitialized(EventArgs.Empty);
            } 
        } 

        // Helper method to retrieve and fire Clr Event handlers for Initialized event 
        private void RaiseInitialized(EventPrivateKey key, EventArgs e)
        {
            EventHandlersStore store = EventHandlersStore;
            if (store != null) 
            {
                Delegate handler = store.Get(key); 
                if (handler != null) 
                {
                    ((EventHandler)handler)(this, e); 
                }
            }
        }
 
        #endregion ISupportInitialize
 
        #region LoadedAndUnloadedEvents 

        ///  
        ///     This DP is set on the root of a sub-tree that is about to receive a broadcast Loaded event
        ///     This DP is cleared when the Loaded event is either fired or cancelled for some reason
        /// 
        private static readonly DependencyProperty LoadedPendingProperty 
            = FrameworkElement.LoadedPendingProperty.AddOwner(typeof(FrameworkContentElement));
 
        ///  
        ///     This DP is set on the root of a sub-tree that is about to receive a broadcast Unloaded event
        ///     This DP is cleared when the Unloaded event is either fired or cancelled for some reason 
        /// 
        private static readonly DependencyProperty UnloadedPendingProperty
            = FrameworkElement.UnloadedPendingProperty.AddOwner(typeof(FrameworkContentElement));
 
        /// 
        ///     Turns true when this element is attached to a tree and is laid out and rendered. 
        ///     Turns false when the element gets detached from a loaded tree 
        /// 
        public bool IsLoaded 
        {
            get
            {
                object[] loadedPending = LoadedPending; 
                object[] unloadedPending = UnloadedPending;
 
                if (loadedPending == null && unloadedPending == null) 
                {
                    // The HasHandler flags are used for validation of the IsLoaded flag 
                    if (SubtreeHasLoadedChangeHandler)
                    {
                        // The IsLoaded flag is valid
                        return IsLoadedCache; 
                    }
                    else 
                    { 
                        // IsLoaded flag isn't valid
                        return BroadcastEventHelper.IsParentLoaded(this); 
                    }
                }
                else
                { 
                    // This is the case where we might be
                    // 1. Pending Unloaded only 
                    //    In this case we are already Loaded 
                    // 2. Pending Loaded only
                    //    In this case we are not Loaded yet 
                    // 3. Pending both Loaded and Unloaded
                    //    We can get to this state only when Unloaded operation preceeds Loaded.
                    //    If Loaded preceeded Unloaded then it is sure to have been cancelled
                    //    out by the latter. 

                    return (unloadedPending != null); 
                } 
            }
        } 

        /// 
        ///     Loaded RoutedEvent
        ///  

        public static readonly RoutedEvent LoadedEvent = FrameworkElement.LoadedEvent.AddOwner( typeof(FrameworkContentElement)); 
 
        /// 
        ///     This event is fired when the element is laid out, rendered and ready for interaction 
        /// 

        public event RoutedEventHandler Loaded
        { 
            add
            { 
                AddHandler(FrameworkElement.LoadedEvent, value, false); 
            }
            remove 
            {
                RemoveHandler(FrameworkElement.LoadedEvent, value);
            }
        } 

 
        ///  
        ///     Helper that will set the IsLoaded flag and Raise the Loaded event
        ///  
        internal void OnLoaded(RoutedEventArgs args)
        {
            RaiseEvent(args);
        } 

        ///  
        ///     Unloaded RoutedEvent 
        /// 
 
        public static readonly RoutedEvent UnloadedEvent = FrameworkElement.UnloadedEvent.AddOwner( typeof(FrameworkContentElement));

        /// 
        ///     This clr event is fired when this element is detached form a loaded tree 
        /// 
        public event RoutedEventHandler Unloaded 
        { 
            add
            { 
                AddHandler(FrameworkElement.UnloadedEvent, value, false);
            }
            remove
            { 
                RemoveHandler(FrameworkElement.UnloadedEvent, value);
            } 
        } 

        ///  
        ///     Helper that will reset the IsLoaded flag and Raise the Unloaded event
        /// 
        internal void OnUnloaded(RoutedEventArgs args)
        { 
            RaiseEvent(args);
        } 
 

        ///  
        ///     Notifies subclass of a new routed event handler.  Note that this is
        ///     called once for each handler added, but OnRemoveHandler is only called
        ///     on the last removal.
        ///  
        internal override void OnAddHandler(
            RoutedEvent routedEvent, 
            Delegate handler) 
        {
            if (routedEvent == LoadedEvent || routedEvent == UnloadedEvent) 
            {
                BroadcastEventHelper.AddHasLoadedChangeHandlerFlagInAncestry(this);
            }
        } 

 
        ///  
        ///     Notifies subclass of an event for which a handler has been removed.
        ///  
        internal override void OnRemoveHandler(
            RoutedEvent routedEvent,
            Delegate handler)
        { 
            // We only care about Loaded & Unloaded events
            if (routedEvent != LoadedEvent && routedEvent != UnloadedEvent) 
                return; 

            if (!ThisHasLoadedChangeEventHandler) 
            {
                BroadcastEventHelper.RemoveHasLoadedChangeHandlerFlagInAncestry(this);
            }
        } 

 
        // Helper method to retrieve and fire Clr Event handlers 
        internal void RaiseClrEvent(EventPrivateKey key, EventArgs args)
        { 
            EventHandlersStore store = EventHandlersStore;
            if (store != null)
            {
                Delegate handler = store.Get(key); 
                if (handler != null)
                { 
                    ((EventHandler)handler)(this, args); 
                }
            } 
        }

        #endregion LoadedAndUnloadedEvents
 
        #region PopupControlService
 
        ///  
        ///     The DependencyProperty for the ToolTip property
        ///  
        public static readonly DependencyProperty ToolTipProperty =
            ToolTipService.ToolTipProperty.AddOwner(typeof(FrameworkContentElement));

        ///  
        ///     The ToolTip for the element.
        ///     If the value is of type ToolTip, then that is the ToolTip that will be used. 
        ///     If the value is of any other type, then that value will be used 
        ///     as the content for a ToolTip provided by the system. Refer to ToolTipService
        ///     for attached properties to customize the ToolTip. 
        /// 
        [Bindable(true), Category("Appearance")]
        public object ToolTip
        { 
            get
            { 
                return ToolTipService.GetToolTip(this); 
            }
 
            set
            {
                ToolTipService.SetToolTip(this, value);
            } 
        }
 
 
        /// 
        /// The DependencyProperty for the Contextmenu property 
        /// 
        public static readonly DependencyProperty ContextMenuProperty =
            ContextMenuService.ContextMenuProperty.AddOwner(typeof(FrameworkContentElement),
            new FrameworkPropertyMetadata((ContextMenu) null)); 

        ///  
        /// The ContextMenu data set on this element. Can be any type that can be converted to a UIElement. 
        /// 
        public ContextMenu ContextMenu 
        {
            get
            {
                return (ContextMenu)GetValue(ContextMenuProperty); 
            }
 
            set 
            {
                SetValue(ContextMenuProperty, value); 
            }
        }

        ///  
        ///     The RoutedEvent for the ToolTipOpening event.
        ///  
        public static readonly RoutedEvent ToolTipOpeningEvent = ToolTipService.ToolTipOpeningEvent.AddOwner(typeof(FrameworkContentElement)); 

        ///  
        ///     An event that fires just before a ToolTip should be opened.
        ///     This event does not fire if the value of ToolTip is null or unset.
        ///
        ///     To manually open and close ToolTips, set the value of ToolTip to a non-null value 
        ///     and then mark this event as handled.
        /// 
        ///     To delay loading the actual ToolTip value, set the value of the ToolTip property to 
        ///     any value (you can also use it as a tag) and then set the value to the actual value
        ///     in a handler for this event. Do not mark the event as handled if the system provided 
        ///     functionality for showing or hiding the ToolTip is desired.
        /// 
        public event ToolTipEventHandler ToolTipOpening
        { 
            add { AddHandler(ToolTipOpeningEvent, value); }
            remove { RemoveHandler(ToolTipOpeningEvent, value); } 
        } 

        private static void OnToolTipOpeningThunk(object sender, ToolTipEventArgs e) 
        {
            ((FrameworkContentElement)sender).OnToolTipOpening(e);
        }
 
        /// 
        ///     Called when the ToolTipOpening event fires. 
        ///     Allows subclasses to add functionality without having to attach 
        ///     an individual handler.
        ///  
        /// Event arguments
        protected virtual void OnToolTipOpening(ToolTipEventArgs e)
        {
        } 

        ///  
        ///     The RoutedEvent for the ToolTipClosing event. 
        /// 
        public static readonly RoutedEvent ToolTipClosingEvent = ToolTipService.ToolTipClosingEvent.AddOwner(typeof(FrameworkContentElement)); 

        /// 
        ///     An event that fires just before a ToolTip should be closed.
        ///     This event will only fire if there was a preceding ToolTipOpening event. 
        ///
        ///     To manually close a ToolTip and not use the system behavior, mark this event as handled. 
        ///  
        public event ToolTipEventHandler ToolTipClosing
        { 
            add { AddHandler(ToolTipClosingEvent, value); }
            remove { RemoveHandler(ToolTipClosingEvent, value); }
        }
 
        private static void OnToolTipClosingThunk(object sender, ToolTipEventArgs e)
        { 
            ((FrameworkContentElement)sender).OnToolTipClosing(e); 
        }
 
        /// 
        ///     Called when the ToolTipClosing event fires.
        ///     Allows subclasses to add functionality without having to attach
        ///     an individual handler. 
        /// 
        /// Event arguments 
        protected virtual void OnToolTipClosing(ToolTipEventArgs e) 
        {
        } 

        /// 
        ///     RoutedEvent for the ContextMenuOpening event.
        ///  
        public static readonly RoutedEvent ContextMenuOpeningEvent = ContextMenuService.ContextMenuOpeningEvent.AddOwner(typeof(FrameworkContentElement));
 
        ///  
        ///     An event that fires just before a ContextMenu should be opened.
        /// 
        ///     To manually open and close ContextMenus, mark this event as handled.
        ///     Otherwise, the value of the the ContextMenu property will be used
        ///     to automatically open a ContextMenu.
        ///  
        public event ContextMenuEventHandler ContextMenuOpening
        { 
            add { AddHandler(ContextMenuOpeningEvent, value); } 
            remove { RemoveHandler(ContextMenuOpeningEvent, value); }
        } 

        private static void OnContextMenuOpeningThunk(object sender, ContextMenuEventArgs e)
        {
            ((FrameworkContentElement)sender).OnContextMenuOpening(e); 
        }
 
        ///  
        ///     Called when ContextMenuOpening is raised on this element.
        ///  
        /// Event arguments
        protected virtual void OnContextMenuOpening(ContextMenuEventArgs e)
        {
        } 

        ///  
        ///     RoutedEvent for the ContextMenuClosing event. 
        /// 
        public static readonly RoutedEvent ContextMenuClosingEvent = ContextMenuService.ContextMenuClosingEvent.AddOwner(typeof(FrameworkContentElement)); 

        /// 
        ///     An event that fires just as a ContextMenu closes.
        ///  
        public event ContextMenuEventHandler ContextMenuClosing
        { 
            add { AddHandler(ContextMenuClosingEvent, value); } 
            remove { RemoveHandler(ContextMenuClosingEvent, value); }
        } 

        private static void OnContextMenuClosingThunk(object sender, ContextMenuEventArgs e)
        {
            ((FrameworkContentElement)sender).OnContextMenuClosing(e); 
        }
 
        ///  
        ///     Called when ContextMenuClosing is raised on this element.
        ///  
        /// Event arguments
        protected virtual void OnContextMenuClosing(ContextMenuEventArgs e)
        {
        } 

        #endregion 
 
        // This has to be virtual, since there is no concept of "core" content children,
        // so we have no choice by to rely on FrameworkContentElement to use logical 
        // children instead.
        internal override void InvalidateForceInheritPropertyOnChildren(DependencyProperty property)
        {
            IEnumerator enumerator = LogicalChildren; 

            if(enumerator != null) 
            { 
                while(enumerator.MoveNext())
                { 
                    DependencyObject child =enumerator.Current as DependencyObject;
                    if(child != null)
                    {
                        // CODE 

 
 

                        child.CoerceValue(property); 
                    }
                }
            }
        } 

        // Helper method to retrieve and fire Clr Event handlers for DependencyPropertyChanged event 
        private void RaiseDependencyPropertyChanged(EventPrivateKey key, DependencyPropertyChangedEventArgs args) 
        {
            EventHandlersStore store = EventHandlersStore; 
            if (store != null)
            {
                Delegate handler = store.Get(key);
                if (handler != null) 
                {
                    ((DependencyPropertyChangedEventHandler)handler)(this, args); 
                } 
            }
        } 

        private void EventHandlersStoreAdd(EventPrivateKey key, Delegate handler)
        {
            EnsureEventHandlersStore(); 
            EventHandlersStore.Add(key, handler);
        } 
 
        private void EventHandlersStoreRemove(EventPrivateKey key, Delegate handler)
        { 
            EventHandlersStore store = EventHandlersStore;
            if (store != null)
            {
                store.Remove(key, handler); 
            }
        } 
 
        // Gettor and Settor for flag that indicates
        // if this instance has some property values 
        // that are set to a resource reference
        internal bool HasResourceReference
        {
            get { return ReadInternalFlag(InternalFlags.HasResourceReferences); } 
            set { WriteInternalFlag(InternalFlags.HasResourceReferences, value); }
        } 
 
        internal bool IsLogicalChildrenIterationInProgress
        { 
            get { return ReadInternalFlag(InternalFlags.IsLogicalChildrenIterationInProgress); }
            set { WriteInternalFlag(InternalFlags.IsLogicalChildrenIterationInProgress, value); }
        }
 
        internal bool SubtreeHasLoadedChangeHandler
        { 
            get { return ReadInternalFlag2(InternalFlags2.TreeHasLoadedChangeHandler); } 
            set { WriteInternalFlag2(InternalFlags2.TreeHasLoadedChangeHandler, value); }
        } 

        internal bool IsLoadedCache
        {
            get { return ReadInternalFlag2(InternalFlags2.IsLoadedCache); } 
            set { WriteInternalFlag2(InternalFlags2.IsLoadedCache, value); }
        } 
 
        internal bool IsParentAnFE
        { 
            get { return ReadInternalFlag2(InternalFlags2.IsParentAnFE); }
            set { WriteInternalFlag2(InternalFlags2.IsParentAnFE, value); }
        }
 
        internal bool IsTemplatedParentAnFE
        { 
            get { return ReadInternalFlag2(InternalFlags2.IsTemplatedParentAnFE); } 
            set { WriteInternalFlag2(InternalFlags2.IsTemplatedParentAnFE, value); }
        } 

        internal bool HasLogicalChildren
        {
            get { return ReadInternalFlag(InternalFlags.HasLogicalChildren); } 
            set { WriteInternalFlag(InternalFlags.HasLogicalChildren, value); }
        } 
 
        // See comment on FrameworkElement.TemplateChildIndex
        internal int TemplateChildIndex 
        {
            get
            {
                uint childIndex = (((uint)_flags2) & 0xFFFF); 
                if (childIndex == 0xFFFF)
                { 
                    return -1; 
                }
                else 
                {
                    return (int)childIndex;
                }
            } 
            set
            { 
                // We store TemplateChildIndex as a 16-bit integer with 0xFFFF meaning "-1". 
                // Thus we support any indices in the range [-1, 65535).
                if (value < -1 || value >= 0xFFFF) 
                {
                    throw new ArgumentOutOfRangeException("value", SR.Get(SRID.TemplateChildIndexOutOfRange));
                }
 
                uint childIndex = (value == -1) ? 0xFFFF : (uint)value;
 
                _flags2 = (InternalFlags2)(childIndex | (((uint)_flags2) & 0xFFFF0000)); 
            }
        } 

        internal bool IsRequestingExpression
        {
            get { return ReadInternalFlag2(InternalFlags2.IsRequestingExpression); } 
            set { WriteInternalFlag2(InternalFlags2.IsRequestingExpression, value); }
        } 
 
        // Extracts the required flag and returns
        // bool to indicate if it is set or unset 
        internal bool ReadInternalFlag(InternalFlags reqFlag)
        {
            return (_flags & reqFlag) != 0;
        } 

        internal bool ReadInternalFlag2(InternalFlags2 reqFlag) 
        { 
            return (_flags2 & reqFlag) != 0;
        } 

        // Sets or Unsets the required flag based on
        // the bool argument
        internal void WriteInternalFlag(InternalFlags reqFlag, bool set) 
        {
            if (set) 
            { 
                _flags |= reqFlag;
            } 
            else
            {
                _flags &= (~reqFlag);
            } 
        }
 
        internal void WriteInternalFlag2(InternalFlags2 reqFlag, bool set) 
        {
            if (set) 
            {
                _flags2 |= reqFlag;
            }
            else 
            {
                _flags2 &= ~reqFlag; 
            } 
        }
 
        // Style/Template state (internals maintained by Style)
        private Style _styleCache;

        // ThemeStyle used only when a DefaultStyleKey is specified 
        private Style _themeStyleCache;
 
        // See FrameworkElement (who also have these) for details on these values. 
        internal DependencyObject _templatedParent;    // Non-null if this object was created as a result of a Template.VisualTree
 
        // Resources dictionary
        private static readonly UncommonField ResourcesField = FrameworkElement.ResourcesField;

        private InternalFlags  _flags  = 0; // field used to store various flags such as HasResourceReferences, etc. 
        private InternalFlags2 _flags2 = InternalFlags2.Default; // field used to store various flags such as HasResourceReferences, etc.
    } 
} 


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