FrameworkElement.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / Orcas / QFE / wpf / src / Framework / System / Windows / FrameworkElement.cs / 1 / FrameworkElement.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.Reflection; 
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.Media3D; 
using System.Windows.Media.TextFormatting;
using System.Windows.Navigation; 
using System.Windows.Markup;
using System.Windows.Controls;
using System.Windows.Automation;
 
using MS.Internal;
using MS.Internal.KnownBoxes; 
using MS.Internal.PresentationFramework;    // SafeSecurityHelper 
using MS.Utility;
using MS.Internal.Automation; 
using MS.Internal.PtsTable;                 // BodyContainerProxy
using System.Security;
using System.Security.Permissions;
using System.Xml; 

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

    ///  
    /// HorizontalAlignment - The HorizontalAlignment enum is used to describe 
    /// how element is positioned or stretched horizontally within a parent's layout slot.
    ///  
    [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)]
    public enum HorizontalAlignment
    {
        ///  
        /// Left - Align element towards the left of a parent's layout slot.
        ///  
        Left = 0, 

        ///  
        /// Center - Center element horizontally.
        /// 
        Center = 1,
 
        /// 
        /// Right - Align element towards the right of a parent's layout slot. 
        ///  
        Right = 2,
 
        /// 
        /// Stretch - Stretch element horizontally within a parent's layout slot.
        /// 
        Stretch = 3, 
    }
 
    ///  
    /// VerticalAlignment - The VerticalAlignment enum is used to describe
    /// how element is positioned or stretched vertically within a parent's layout slot. 
    /// 
    [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)]
    public enum VerticalAlignment
    { 
        /// 
        /// Top - Align element towards the top of a parent's layout slot. 
        ///  
        Top = 0,
 
        /// 
        /// Center - Center element vertically.
        /// 
        Center = 1, 

        ///  
        /// Bottom - Align element towards the bottom of a parent's layout slot. 
        /// 
        Bottom = 2, 

        /// 
        /// Stretch - Stretch element vertically within a parent's layout slot.
        ///  
        Stretch = 3,
    } 
 
    /// 
    ///     The base object for the Frameworks 
    /// 
    /// 
    ///     FrameworkElement is the interface between higher-level Framework
    ///     classes and PresentationCore services 
    /// 
    [StyleTypedProperty(Property = "FocusVisualStyle", StyleTargetType = typeof(Control))] 
    [XmlLangProperty("Language")] 
    [UsableDuringInitialization(true)]
    public partial class FrameworkElement : UIElement, IFrameworkInputElement, ISupportInitialize, IHaveResources 
    {
        static private readonly Type _typeofThis = typeof(FrameworkElement);

        ///  
        ///     Default FrameworkElement constructor
        ///  
        ///  
        ///     Automatic determination of current Dispatcher. Use alternative constructor
        ///     that accepts a Dispatcher for best performance. 
        /// 
        public FrameworkElement() : base()
        {
            // 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));
            }

            if (((FlowDirection)FlowDirectionProperty.GetDefaultValue(DependencyObjectType)) == FlowDirection.RightToLeft) 
            {
                IsRightToLeft = true; 
            } 

            // Set the ShouldLookupImplicitStyles flag to true if App.Resources has implicit styles. 
            Application app = Application.Current;
            if (app != null && app.HasImplicitStylesInResources)
            {
                ShouldLookupImplicitStyles = true; 
            }
 
            FrameworkElement.EnsureFrameworkServices(); 
        }
 
        /// Style Dependency Property
        [CommonDependencyProperty]
        public static readonly DependencyProperty StyleProperty =
                DependencyProperty.Register( 
                        "Style",
                        typeof(Style), 
                        _typeofThis, 
                        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) 
        {
            FrameworkElement fe = (FrameworkElement) d; 
            fe.HasLocalStyle = (e.NewEntry.BaseValueSourceInternal == BaseValueSourceInternal.Local);
            StyleHelper.UpdateStyleCache(fe, null, (Style) e.OldValue, (Style) e.NewValue, ref fe._styleCache);
        }
 
        /// 
        /// OverridesDefaultStyleProperty 
        ///  
        public static readonly DependencyProperty OverridesDefaultStyleProperty
            = DependencyProperty.Register("OverridesDefaultStyle", typeof(bool), _typeofThis, 
                                            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)); }
        } 
 

        ///  
        /// DefaultStyleKeyProperty
        /// 
        protected internal static readonly DependencyProperty DefaultStyleKeyProperty
            = DependencyProperty.Register("DefaultStyleKey", typeof(object), _typeofThis, 
                                            new FrameworkPropertyMetadata(
                                                        null,   // default value 
                                                        FrameworkPropertyMetadataOptions.AffectsMeasure, 
                                                        new PropertyChangedCallback(OnThemeStyleKeyChanged)));
 
        /// 
        ///     This specifies the key to use to find
        ///     a style in a theme for this control
        ///  
        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 
            ((FrameworkElement)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 ThemeStyleKey's default
        // value. Controls will override this method to return approriate types. 
        internal virtual DependencyObjectType DTypeThemeStyleKey
        {
            get { return null; }
        } 

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

        // Internal helper so the FrameworkElement could see the 
        // ControlTemplate/DataTemplate set on the
        // Control/Page/PageFunction/ContentPresenter 
        internal virtual FrameworkTemplate TemplateInternal 
        {
            get { return null; } 
        }

        // Internal helper so the FrameworkElement could see the
        // ControlTemplate/DataTemplate set on the 
        // Control/Page/PageFunction/ContentPresenter
        internal virtual FrameworkTemplate TemplateCache 
        { 
            get { return null; }
            set {} 
        }

        // Internal so that StyleHelper could uniformly call the TemplateChanged
        // virtual on any templated parent 
        internal virtual void OnTemplateChangedInternal(
            FrameworkTemplate oldTemplate, 
            FrameworkTemplate newTemplate) 
        {
            HasTemplateChanged = true; 
        }

        /// 
        ///     Style has changed 
        /// 
        /// The old Style 
        /// The new Style 
        protected internal virtual void OnStyleChanged(Style oldStyle, Style newStyle)
        { 
            HasStyleChanged = true;
        }

        ///  
        /// This method is called from during property invalidation time. If the FrameworkElement has a child on which
        /// some property was invalidated and the property was marked as AffectsParentMeasure or AffectsParentArrange 
        /// during registration, this method is invoked to let a FrameworkElement know which particualr child must be 
        /// remeasured if the FrameworkElement wants to do partial (incremental) update of layout.
        ///  
        /// Olny advanced FrameworkElement, which implement incremental update should override this method. Since
        /// Panel always gets InvalidateMeasure or InvalidateArrange called in this situation, it ensures that
        /// the FrameworkElement will be re-measured and/or re-arranged. Only if the FrameworkElement wants to implement a performance
        /// optimization and avoid calling Measure/Arrange on all children, it should override this method and 
        /// store the info about invalidated children, to use subsequently in the FrameworkElement's MeasureOverride/ArrangeOverride
        /// implementations. 
        ///  
        /// Note: to listen for added/removed children, Panel should provide its derived version of
        /// . 
        /// 
        ///Reference to a child UIElement that had AffectsParentMeasure/AffectsParentArrange property invalidated.
        protected internal virtual void ParentLayoutInvalidated(UIElement child)
        { 
        }
 
        ///  
        /// ApplyTemplate is called on every Measure
        ///  
        /// 
        /// Used by subclassers as a notification to delay fault-in their Visuals
        /// Used by application authors ensure an Elements Visual tree is completely built
        ///  
        /// Whether Visuals were added to the tree
        public bool ApplyTemplate() 
        { 
            // Notify the ContentPresenter/ItemsPresenter that we are about to generate the
            // template tree and allow them to choose the right template to be applied. 
            OnPreApplyTemplate();

            bool visualsCreated = false;
 
            UncommonField  dataField = StyleHelper.TemplateDataField;
            FrameworkTemplate           template = TemplateInternal; 
 
            // VisualTree application never clears existing trees. Trees
            // will be conditionally cleared on Template invalidation 
            if (!HasTemplateGeneratedSubTree)
            {
                if (template != null)
                { 
                    // Create a VisualTree using the given template
                    visualsCreated = template.ApplyTemplateContent(dataField, this); 
                    if (visualsCreated) 
                    {
                        // This VisualTree was created via a Template 
                        HasTemplateGeneratedSubTree =  true;

                        // We may have had trigger actions that had to wait until the
                        //  template subtree has been created.  Invoke them now. 
                        StyleHelper.InvokeDeferredActions(this, template);
 
                        // Notify sub-classes when the template tree has been created 
                        OnApplyTemplate();
                    } 
                }
            }

            return visualsCreated; 
        }
 
        ///  
        /// This virtual is called by FE.ApplyTemplate before it does work to generate the template tree.
        ///  
        /// 
        /// This virtual is overridden for the following three reasons
        /// 1. By ContentPresenter/ItemsPresenter to choose the template to be applied in this case.
        /// 2. By RowPresenter/ColumnHeaderPresenter/InkCanvas to build custom visual trees 
        /// 3. By ScrollViewer/TickBar/ToolBarPanel/Track to hookup bindings to their TemplateParent
        ///  
        internal virtual void OnPreApplyTemplate() 
        {
        } 

        /// 
        ///     This is the virtual that sub-classes must override if they wish to get
        ///     notified that the template tree has been created. 
        /// 
        ///  
        ///     This virtual is called after the template tree has been generated and it is invoked only 
        ///     if the call to ApplyTemplate actually caused the template tree to be generated.
        ///  
        public virtual void OnApplyTemplate()
        {
        }
 
        /// 
        ///     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 ); 
        }

        // Given a FrameworkElement and a name string, this routine will try to find
        //  a node with Name property set to the given name.  It will search all 
        //  the child logical tree nodes of the given starting element.
        // If the name string is null or an empty string, the given starting element 
        //  is returned. 
        // If the name is found on a FrameworkContentElement, an exception is thrown
        // If the name is not found attached to anything, an exception is thrown 
        internal static FrameworkElement FindNamedFrameworkElement( FrameworkElement startElement, string targetName )
        {
            FrameworkElement targetFE = null;
 
            if( targetName == null || targetName.Length == 0 )
            { 
                targetFE = startElement; 
            }
            else 
            {
                DependencyObject targetObject = null;

                targetObject = LogicalTreeHelper.FindLogicalNode( startElement, targetName ); 

                if( targetObject == null ) 
                { 
                    throw new ArgumentException( SR.Get(SRID.TargetNameNotFound, targetName));
                } 

                FrameworkObject fo = new FrameworkObject(targetObject);
                if( fo.IsFE )
                { 
                    targetFE = fo.FE;
                } 
                else 
                {
                    throw new InvalidOperationException(SR.Get(SRID.NamedObjectMustBeFrameworkElement, targetName)); 
                }
            }

            return targetFE; 
        }
 
        ///  
        ///     Triggers associated with this object.  Both the triggering condition
        /// and the trigger effect may be on this object or on its tree child 
        /// objects.
        /// 
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public TriggerCollection Triggers 
        {
            get 
            { 
                TriggerCollection triggerCollection = EventTrigger.TriggerCollectionField.GetValue(this);
                if (triggerCollection == null) 
                {
                    // Give the TriggerCollectiona back-link so that it can update
                    // 'this' on Add/Remove.
                    triggerCollection = new TriggerCollection(this); 

                    EventTrigger.TriggerCollectionField.SetValue(this, triggerCollection); 
                } 

                return triggerCollection; 
            }
        }

        ///  
        ///     Return true if the Triggers property contains something that
        ///     should be serialized. 
        ///  
        [EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializeTriggers() 
        {
            TriggerCollection triggerCollection = EventTrigger.TriggerCollectionField.GetValue(this);
            if (triggerCollection == null || triggerCollection.Count == 0)
            { 
                return false;
            } 
 
            return true;
        } 

        // This should be called when the FrameworkElement tree is built up,
        //  at this point we can process all the setter-related information
        //  because now we'll be able to resolve "Target" references in setters. 
        private void PrivateInitialized()
        { 
            // Process Trigger information when this object is loaded. 
            EventTrigger.ProcessTriggerCollection(this);
        } 

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

        ///  
        ///     Returns true if this FrameworkElement was created as the root
        ///     node of a Template.VisualTree or if it were the root node of a template.
        /// 
        //     Most people can get this information by comparing this.TemplatedParent 
        // against this.Parent.  However, layout has a need to know this when
        // the tree is not yet hooked up and/or just disconnected. 
        //     This function uses esoteric knowledge of FrameworkElementFactory 
        // and how it is actually used to build visual trees from style.
        // Exposing this property is easier than explaining the ChildIndex magic. 
        internal bool IsTemplateRoot
        {
            get
            { 
                return (TemplateChildIndex==1);
            } 
        } 

 
        /// 
        /// Gets or sets the template child of the FrameworkElement.
        /// 
        virtual internal UIElement TemplateChild 
        {
            get 
            { 
                return _templateChild;
            } 
            set
            {
                if (value != _templateChild)
                { 
                    RemoveVisualChild(_templateChild);
                    _templateChild = value; 
                    AddVisualChild(value); 
                }
            } 
        }

        /// 
        /// Gets the number of Visual children of this FrameworkElement. 
        /// 
        ///  
        /// Derived classes override this property getter to provide the children count 
        /// of their custom children collection.
        ///  
        protected override int VisualChildrenCount
        {
            get
            { 
                return (_templateChild == null) ? 0 : 1;
            } 
        } 

 
        /// 
        /// Gets the Visual child at the specified index.
        /// 
        ///  
        /// Derived classes that provide a custom children collection must override this method
        /// and return the child at the specified index. 
        ///  
        protected override Visual GetVisualChild(int index)
        { 
            if (_templateChild == null)
            {
                throw new ArgumentOutOfRangeException("index", index, SR.Get(SRID.Visual_ArgumentOutOfRange));
            } 
            if (index != 0)
            { 
                throw new ArgumentOutOfRangeException("index", index, SR.Get(SRID.Visual_ArgumentOutOfRange)); 
            }
            return _templateChild; 
        }

        /// 
        ///     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
        /// 
        public ResourceDictionary Resources
        { 
            get
            { 
                ResourceDictionary resources = ResourcesField.GetValue(this); 
                if (resources == null)
                { 
                    resources = new ResourceDictionary();
                    resources.AddOwner(this);
                    ResourcesField.SetValue(this, resources);
 
                    if( TraceResourceDictionary.IsEnabled )
                    { 
                        TraceResourceDictionary.TraceActivityItem( 
                                TraceResourceDictionary.NewResourceDictionary,
                                this, 
                                0,
                                resources );
                    }
 
                }
 
                return resources; 

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

                if( TraceResourceDictionary.IsEnabled ) 
                { 
                    TraceResourceDictionary.Trace(
                            TraceEventType.Start, 
                            TraceResourceDictionary.NewResourceDictionary,
                            this,
                            oldValue,
                            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(this, null, new ResourcesChangeInfo(oldValue, value));
                } 
 

                if( TraceResourceDictionary.IsEnabled ) 
                {
                    TraceResourceDictionary.Trace(
                            TraceEventType.Stop,
                            TraceResourceDictionary.NewResourceDictionary, 
                            this,
                            oldValue, 
                            value ); 
                }
 

            }
        }
 
        ResourceDictionary IHaveResources.Resources
        { 
            get { return Resources; } 
            set { Resources = value; }
        } 

        /// 
        /// This method is used by TypeDescriptor to determine if this property should
        /// be serialized. 
        /// 
        // This is to tell the serialization engine when we 
        // must and must not serialize the Resources property 
        [EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializeResources() 
        {
            if (Resources == null || Resources.Count == 0)
            {
                return false; 
            }
 
            return true; 
        }
 
        /// 
        ///     Retrieves the element in the VisualTree of thie element that corresponds to
        ///     the element with the given childName in this element's style definition
        ///  
        /// the Name to find the matching element for
        /// The Named element.  Null if no element has this Name. 
        protected internal DependencyObject GetTemplateChild(string childName) 
        {
            FrameworkTemplate template = TemplateInternal; 
            /* Calling this before getting a style/template is not a bug.
            Debug.Assert(template != null,
                "The VisualTree should have been created from a Template");
            */ 

            if (template == null) 
            { 
                return null;
            } 

            return StyleHelper.FindNameInTemplateContent(this, childName, template) as DependencyObject;
        }
 
        /// 
        ///     Searches for a resource with the passed resourceKey and returns it. 
        ///     Throws an exception if the resource was not found. 
        /// 
        ///  
        ///     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.
        public object FindResource(object resourceKey) 
        { 
            // Verify Context Access
            // VerifyAccess(); 

            if (resourceKey == null)
            {
                throw new ArgumentNullException("resourceKey"); 
            }
 
            object resource = FrameworkElement.FindResourceInternal(this, null /* fce */, 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(this, null /* fce */, 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;
        }
 

        // FindImplicitSytle(fe) : Default: unlinkedParent, deferReference 
        internal static object FindImplicitStyleResource(FrameworkElement fe, object resourceKey, out object source) 
        {
            // Do a FindResource call only if someone in the ancestry has 
            // implicit styles. This is a performance optimization.

#if !DEBUG
            if (fe.ShouldLookupImplicitStyles) 
            {
#endif 
                object unlinkedParent = null; 
                bool allowDeferredResourceReference = false;
                bool mustReturnDeferredResourceReference = false; 

                // Implicit style lookup must stop at the app.
                bool isImplicitStyleLookup = true;
 
                // For non-controls the implicit StyleResource lookup must stop at
                // the templated parent. Look at task 25606 for further details. 
                DependencyObject boundaryElement = null; 
                if (!(fe is Control))
                { 
                    boundaryElement = fe.TemplatedParent;
                }

                object implicitStyle = FindResourceInternal(fe, null, FrameworkElement.StyleProperty, resourceKey, unlinkedParent, allowDeferredResourceReference, mustReturnDeferredResourceReference, boundaryElement, isImplicitStyleLookup, out source); 

                // The reason this assert is commented is because there are specific scenarios when we can reach 
                // here even before the ShouldLookupImplicitStyles flag is updated. But this is still acceptable 
                // because the flag does get updated and the style property gets re-fetched soon after.
 
                // Look at AccessText.GetVisualChild implementation for example and
                // consider the following sequence of operations.

                // 1. contentPresenter.AddVisualChild(accessText) 
                // 1.1. accessText._parent = contentPresenter
                // 1.2. accessText.GetVisualChild(...) 
                // 1.2.1  accessText.AddVisualChild(textBlock) 
                // 1.2.1.1 textBlock.OnVisualParentChanged()
                // 1.2.1.1.1 FindImplicitStyleResource(textBlock) 
                // .
                // .
                // .
                // 1.3 accessText.OnVisualParentChanged 
                // 1.3.1 Set accessText.ShouldLookupImplicitStyle
                // 1.3.2 FindImplicitStyleResource(accessText) 
                // 1.3.3 Set textBlock.ShouldLookupImplicitStyle 
                // 1.3.4 FindImplicitStyleResource(textBlock)
 
                // Notice how we end up calling FindImplicitStyleResource on the textBlock before we have set the
                // ShouldLookupImplicitStyle flag on either accessText or textBlock. However this is still acceptable
                // because we eventually going to synchronize the flag and the style property value on both these objects.
 
                // Debug.Assert(!(implicitStyle != DependencyProperty.UnsetValue && fe.ShouldLookupImplicitStyles == false),
                //     "ShouldLookupImplicitStyles is false even while there exists an implicit style in the lookup path. To be precise at source " + source); 
 
                return implicitStyle;
#if !DEBUG 
            }

            source = null;
            return DependencyProperty.UnsetValue; 
#endif
        } 
 
        // FindImplicitSytle(fce) : Default: unlinkedParent, deferReference
        internal static object FindImplicitStyleResource(FrameworkContentElement fce, object resourceKey, out object source) 
        {
            // Do a FindResource call only if someone in the ancestry has
            // implicit styles. This is a performance optimization.
 
#if !DEBUG
            if (fce.ShouldLookupImplicitStyles) 
            { 
#endif
                object unlinkedParent = null; 
                bool allowDeferredResourceReference = false;
                bool mustReturnDeferredResourceReference = false;

                // Implicit style lookup must stop at the app. 
                bool isImplicitStyleLookup = true;
 
                // For non-controls the implicit StyleResource lookup must stop at 
                // the templated parent. Look at task 25606 for further details.
                DependencyObject boundaryElement = fce.TemplatedParent; 

                object implicitStyle = FindResourceInternal(null, fce, FrameworkContentElement.StyleProperty, resourceKey, unlinkedParent, allowDeferredResourceReference, mustReturnDeferredResourceReference, boundaryElement, isImplicitStyleLookup, out source);

                // Look at comments on the FE version of this method. 

                // Debug.Assert(!(implicitStyle != DependencyProperty.UnsetValue && fce.ShouldLookupImplicitStyles == false), 
                //     "ShouldLookupImplicitStyles is false even while there exists an implicit style in the lookup path. To be precise at source " + source); 

                return implicitStyle; 
#if !DEBUG
            }

            source = null; 
            return DependencyProperty.UnsetValue;
#endif 
        } 

        // Internal method for Parser to find a resource when 
        // the instance is not yet hooked to the logical tree
        // This method returns DependencyProperty.UnsetValue when
        // resource is not found. Otherwise it returns the value
        // found. NOTE: Value resource found could be null 
        // FindResource(fe/fce)  Default: dp, unlinkedParent, deferReference, boundaryElement, source, isImplicitStyleLookup
        internal static object FindResourceInternal(FrameworkElement fe, FrameworkContentElement fce, object resourceKey) 
        { 
            DependencyProperty      dp = null;
            object                  unlinkedParent = null; 
            bool                    allowDeferredResourceReference = false;
            bool                    mustReturnDeferredResourceReference = false;
            DependencyObject        boundaryElement = null;
            object                  source; 
            bool                    isImplicitStyleLookup = false;
 
            return FindResourceInternal(fe, fce, dp, resourceKey, unlinkedParent, allowDeferredResourceReference, mustReturnDeferredResourceReference, boundaryElement, isImplicitStyleLookup, out source); 
        }
 
        // FindresourceInternal(fe/fce)  Default: source
        internal static object FindResourceInternal(FrameworkElement fe, FrameworkContentElement fce, DependencyProperty dp, object resourceKey, object unlinkedParent, bool deferReference)
        {
            object source; 
            return FindResourceInternal(fe, fce, dp, resourceKey, unlinkedParent, deferReference, out source);
        } 
 
        // FindresourceInternal(fe/fce)  Default: boundaryElement
        internal static object FindResourceInternal(FrameworkElement fe, FrameworkContentElement fce, DependencyProperty dp, object resourceKey, object unlinkedParent, bool deferReference, out object source) 
        {
            DependencyObject boundaryElement = null;
            return FindResourceInternal(fe, fce, dp, resourceKey, unlinkedParent, deferReference, boundaryElement, out source);
        } 

        // FindresourceInternal(fe/fce)  Default: isImplicitStyleLookup 
        internal static object FindResourceInternal( 
            FrameworkElement        fe,
            FrameworkContentElement fce, 
            DependencyProperty      dp,
            object                  resourceKey,
            object                  unlinkedParent,
            bool                    deferReference, 
            DependencyObject        boundaryElement,
            out object              source) 
        { 
            bool isImplicitStyleLookup = false;
            bool mustReturnDeferredResourceReference = false; 
            return FindResourceInternal(fe, fce, dp, resourceKey, unlinkedParent, deferReference, mustReturnDeferredResourceReference, boundaryElement,  isImplicitStyleLookup, out source);
        }

        // FindResourceInternal(fe/fce)  Defaults: none 
        internal static object FindResourceInternal(
            FrameworkElement        fe, 
            FrameworkContentElement fce, 
            DependencyProperty      dp,
            object                  resourceKey, 
            object                  unlinkedParent,
            bool                    allowDeferredResourceReference,
            bool                    mustReturnDeferredResourceReference,
            DependencyObject        boundaryElement, 
            bool                    isImplicitStyleLookup,
            out object              source) 
        { 
            object value;
            InheritanceBehavior inheritanceBehavior = InheritanceBehavior.Default; 

            if( TraceResourceDictionary.IsEnabled )
            {
                FrameworkObject element = new FrameworkObject(fe, fce); 

                TraceResourceDictionary.Trace( 
                    TraceEventType.Start, 
                    TraceResourceDictionary.FindResource,
                     element.DO, 
                     resourceKey );
            }

            try 
            {
 
                // First try to find the resource in the tree 
                if (fe != null || fce != null || unlinkedParent != null)
                { 
                    value = FindResourceInTree(fe, fce, dp, resourceKey, unlinkedParent, allowDeferredResourceReference, mustReturnDeferredResourceReference, boundaryElement,
                                                out inheritanceBehavior, out source);
                    if (value != DependencyProperty.UnsetValue)
                    { 
                        return value;
                    } 
 
                }
 
                // Then we try to find the resource in the App's Resources
                Application app = Application.Current;
                if (app != null &&
                    (inheritanceBehavior == InheritanceBehavior.Default || 
                     inheritanceBehavior == InheritanceBehavior.SkipToAppNow ||
                     inheritanceBehavior == InheritanceBehavior.SkipToAppNext)) 
                { 
                    value = app.FindResourceInternal(resourceKey, allowDeferredResourceReference, mustReturnDeferredResourceReference);
                    if (value != null) 
                    {
                        source = app;

                        if( TraceResourceDictionary.IsEnabled ) 
                        {
                            TraceResourceDictionary.TraceActivityItem( 
                                TraceResourceDictionary.FoundResourceInApplication, 
                                 resourceKey,
                                value ); 
                        }

                        return value;
                    } 
                }
 
                // Then we try to find the resource in the SystemResources but that is only if we aren't 
                // doing an implicit style lookup. Implicit style lookup will stop at the app.
                if (!isImplicitStyleLookup && 
                    inheritanceBehavior != InheritanceBehavior.SkipAllNow &&
                    inheritanceBehavior != InheritanceBehavior.SkipAllNext)
                {
                    value = SystemResources.FindResourceInternal(resourceKey, allowDeferredResourceReference, mustReturnDeferredResourceReference); 
                    if (value != null)
                    { 
                        source = SystemResourceHost.Instance; 

                        if( TraceResourceDictionary.IsEnabled ) 
                        {
                            TraceResourceDictionary.TraceActivityItem(
                                TraceResourceDictionary.FoundResourceInTheme,
                                source, 
                                resourceKey,
                                value ); 
                        } 

 
                        return value;
                    }
                }
            } 
            finally
            { 
                if( TraceResourceDictionary.IsEnabled ) 
                {
                    FrameworkObject element = new FrameworkObject(fe, fce); 

                    TraceResourceDictionary.Trace(
                        TraceEventType.Stop,
                        TraceResourceDictionary.FindResource, 
                         element.DO,
                         resourceKey ); 
                } 
            }
 
            // We haven't found the resource.  Trace a message to the debugger.
            //
            // Only trace if this isn't an implicit
            // style lookup and the element has been loaded 
            if (TraceResourceDictionary.IsEnabledOverride && !isImplicitStyleLookup)
            { 
                if ((fe != null && fe.IsLoaded) || (fce != null && fce.IsLoaded)) 
                {
                    TraceResourceDictionary.Trace( TraceEventType.Warning, 
                            TraceResourceDictionary.ResourceNotFound,
                            resourceKey );
                }
                else if( TraceResourceDictionary.IsEnabled ) 
                {
                    TraceResourceDictionary.TraceActivityItem( 
                            TraceResourceDictionary.ResourceNotFound, 
                            resourceKey );
                } 
            }

            source = null;
            return DependencyProperty.UnsetValue; 
        }
 
        // FindResourceInTree(fe/fce)  Defaults: none 
        internal static object FindResourceInTree(
            FrameworkElement        feStart, 
            FrameworkContentElement fceStart,
            DependencyProperty      dp,
            object                  resourceKey,
            object                  unlinkedParent, 
            bool                    allowDeferredResourceReference,
            bool                    mustReturnDeferredResourceReference, 
            DependencyObject        boundaryElement, 
            out InheritanceBehavior inheritanceBehavior,
            out object              source) 
        {
            FrameworkObject startNode = new FrameworkObject(feStart, fceStart);
            FrameworkObject fo = startNode;
            object value; 
            Style style;
            FrameworkTemplate frameworkTemplate; 
            Style themeStyle; 
            int loopCount = 0;
            bool hasParent = true; 
            inheritanceBehavior = InheritanceBehavior.Default;

            while (hasParent)
            { 
                Debug.Assert(startNode.IsValid || unlinkedParent != null,
                              "Don't call FindResource with a null fe/fce and unlinkedParent"); 
 
                if (loopCount > DescendentsWalkerBase.MAX_TREE_DEPTH)
                { 
                    // We suspect a loop here because the loop count
                    // has exceeded the MAX_TREE_DEPTH expected
                    throw new InvalidOperationException(SR.Get(SRID.LogicalTreeLoop));
                } 
                else
                { 
                    loopCount++; 
                }
 
                // -------------------------------------------
                //  Lookup ResourceDictionary on the current instance
                // -------------------------------------------
 
                style = null;
                frameworkTemplate = null; 
                themeStyle = null; 

                if (fo.IsFE) 
                {
                    FrameworkElement fe = fo.FE;

                    value = fe.FindResourceOnSelf(resourceKey, allowDeferredResourceReference, mustReturnDeferredResourceReference); 
                    if (value != DependencyProperty.UnsetValue)
                    { 
                        source = fe; 

                        if( TraceResourceDictionary.IsEnabled ) 
                        {
                            TraceResourceDictionary.TraceActivityItem(
                                TraceResourceDictionary.FoundResourceOnElement,
                                source, 
                                resourceKey,
                                value ); 
                        } 

                        return value; 
                    }

                    if ((fe != startNode.FE) || StyleHelper.ShouldGetValueFromStyle(dp))
                    { 
                        style = fe.Style;
                    } 
                    // Fetch the Template 
                    if ((fe != startNode.FE) || StyleHelper.ShouldGetValueFromTemplate(dp))
                    { 
                        frameworkTemplate = fe.TemplateInternal;
                    }
                    // Fetch the ThemeStyle
                    if ((fe != startNode.FE) || StyleHelper.ShouldGetValueFromThemeStyle(dp)) 
                    {
                        themeStyle = fe.ThemeStyle; 
                    } 
                }
                else if (fo.IsFCE) 
                {
                    FrameworkContentElement fce = fo.FCE;

                    value = fce.FindResourceOnSelf(resourceKey, allowDeferredResourceReference, mustReturnDeferredResourceReference); 
                    if (value != DependencyProperty.UnsetValue)
                    { 
                        source = fce; 

                        if( TraceResourceDictionary.IsEnabled ) 
                        {
                            TraceResourceDictionary.TraceActivityItem(
                                TraceResourceDictionary.FoundResourceOnElement,
                                source, 
                                resourceKey,
                                value ); 
                        } 

                        return value; 
                    }

                    if ((fce != startNode.FCE) || StyleHelper.ShouldGetValueFromStyle(dp))
                    { 
                        style = fce.Style;
                    } 
                    // Fetch the ThemeStyle 
                    if ((fce != startNode.FCE) || StyleHelper.ShouldGetValueFromThemeStyle(dp))
                    { 
                        themeStyle = fce.ThemeStyle;
                    }
                }
 
                if (style != null)
                { 
                    value = style.FindResource(resourceKey, allowDeferredResourceReference, mustReturnDeferredResourceReference); 
                    if (value != DependencyProperty.UnsetValue)
                    { 
                        source = style;

                        if( TraceResourceDictionary.IsEnabled )
                        { 
                            TraceResourceDictionary.TraceActivityItem(
                                TraceResourceDictionary.FoundResourceInStyle, 
                                style.Resources, 
                                resourceKey,
                                style, 
                                fo.DO,
                                value );
                        }
 
                        return value;
                    } 
                } 
                if (frameworkTemplate != null)
                { 
                    value = frameworkTemplate.FindResource(resourceKey, allowDeferredResourceReference, mustReturnDeferredResourceReference);
                    if (value != DependencyProperty.UnsetValue)
                    {
                        source = frameworkTemplate; 

                        if( TraceResourceDictionary.IsEnabled ) 
                        { 
                            TraceResourceDictionary.TraceActivityItem(
                                TraceResourceDictionary.FoundResourceInTemplate, 
                                frameworkTemplate.Resources,
                                resourceKey,
                                frameworkTemplate,
                                fo.DO, 
                                value );
                        } 
 
                        return value;
                    } 
                }

                if (themeStyle != null)
                { 
                    value = themeStyle.FindResource(resourceKey, allowDeferredResourceReference, mustReturnDeferredResourceReference);
                    if (value != DependencyProperty.UnsetValue) 
                    { 
                        source = themeStyle;
 
                        if( TraceResourceDictionary.IsEnabled )
                        {
                            TraceResourceDictionary.TraceActivityItem(
                                TraceResourceDictionary.FoundResourceInThemeStyle, 
                                themeStyle.Resources,
                                resourceKey, 
                                themeStyle, 
                                fo.DO,
                                value ); 
                        }

                        return value;
                    } 
                }
 
 
                // If the current element that has been searched is the boundary element
                // then we need to progress no further 
                if (boundaryElement != null && (fo.DO == boundaryElement))
                {
                    break;
                } 

                // If the current element for resource lookup is marked such 
                // then skip to the Application and/or System resources 
                if (fo.IsValid && TreeWalkHelper.SkipNext(fo.InheritanceBehavior))
                { 
                    inheritanceBehavior = fo.InheritanceBehavior;
                    break;
                }
 
                // -------------------------------------------
                //  Find the next parent instance to lookup 
                // ------------------------------------------- 

                if (unlinkedParent != null) 
                {
                    // This is for the special case when the parser tries to fetch
                    // a resource on an element even before it is hooked to the
                    // tree. In this case the parser passes us the unlinkedParent 
                    // to use it for resource lookup.
                    DependencyObject unlinkedParentAsDO = unlinkedParent as DependencyObject; 
                    if (unlinkedParentAsDO != null) 
                    {
                        fo.Reset(unlinkedParentAsDO); 
                        if (fo.IsValid)
                        {
                            hasParent = true;
                        } 
                        else
                        { 
                            DependencyObject doParent = GetFrameworkParent(unlinkedParent); 
                            if (doParent != null)
                            { 
                                fo.Reset(doParent);
                                hasParent = true;
                            }
                            else 
                            {
                                hasParent = false; 
                            } 
                        }
                    } 
                    else
                    {
                        hasParent = false;
                    } 
                    unlinkedParent = null;
                } 
                else 
                {
                    Debug.Assert(fo.IsValid, 
                                  "The current node being processed should be an FE/FCE");

                    fo = fo.FrameworkParent;
 
                    hasParent = fo.IsValid;
                } 
 
                // If the current element for resource lookup is marked such
                // then skip to the Application and/or System resources 
                if (fo.IsValid && TreeWalkHelper.SkipNow(fo.InheritanceBehavior))
                {
                    inheritanceBehavior = fo.InheritanceBehavior;
                    break; 
                }
            } 
 
            // No matching resource was found in the tree
            source = null; 
            return DependencyProperty.UnsetValue;
        }

 
        // Searches through resource dictionaries to find a [Data|Table]Template
        //  that matches the type of the 'item' parameter.  Failing an exact 
        //  match of the type, return something that matches one of its parent 
        //  types.
        internal static object FindTemplateResourceInternal(DependencyObject target, object item, Type templateType) 
        {
            // Data styling doesn't apply to UIElement (bug 1007133).
            if (item == null || (item is UIElement))
            { 
                return null;
            } 
 
            object dataType;
            Type type = item.GetType(); 
            if (type.FullName == "System.Xml.Linq.XElement" &&
                (dataType = GetXLinqTagName(item, type)) != null)
            {
                type = null; 
            }
            else if (type.FullName.StartsWith("System.Xml", StringComparison.Ordinal) && 
                        (dataType = GetXmlTagName(item, target)) != null) 
            {
                type = null; 
            }
            else if (type == typeof(Object))
            {
                dataType = null;     // don't search for Object - perf 
            }
            else 
            { 
                dataType = type;
            } 

            ArrayList keys = new ArrayList();

            // construct the list of acceptable keys, in priority order 
            int exactMatch = -1;    // number of entries that count as an exact match
 
            // add compound keys for the dataType and all its base types 
            while (dataType != null)
            { 
                object key = null;
                if (templateType == typeof(DataTemplate))
                    key = new DataTemplateKey(dataType);
 
                if (key != null)
                    keys.Add(key); 
 
                // all keys added for the given item type itself count as an exact match
                if (exactMatch == -1) 
                    exactMatch = keys.Count;

                if (type != null)
                { 
                    type = type.BaseType;
                    if (type == typeof(Object))     // don't search for Object - perf 
                        type = null; 
                }
 
                dataType = type;
            }

            int bestMatch = keys.Count; // index of best match so far 

            // Search the parent chain 
            object resource = FindTemplateResourceInTree(target, keys, exactMatch, ref bestMatch); 

            if (bestMatch >= exactMatch) 
            {
                // Exact match not found in the parent chain.  Try App and System Resources.
                object appResource = Helper.FindTemplateResourceFromAppOrSystem(target, keys, exactMatch, ref bestMatch);
 
                if (appResource != null)
                    resource = appResource; 
            } 

            return resource; 
        }

        // Search the parent chain for a [Data|Table]Template in a ResourceDictionary.
        private static object FindTemplateResourceInTree(DependencyObject target, ArrayList keys, int exactMatch, ref int bestMatch) 
        {
            Debug.Assert(target != null, "Don't call FindTemplateResource with a null target object"); 
 
            ResourceDictionary table;
            object resource = null; 

            FrameworkObject fo = new FrameworkObject(target);
            Debug.Assert(fo.IsValid, "Don't call FindTemplateResource with a target object that is neither a FrameworkElement nor a FrameworkContentElement");
 
            while (fo.IsValid)
            { 
                object candidate; 

                // ------------------------------------------- 
                //  Lookup ResourceDictionary on the current instance
                // -------------------------------------------

                // Fetch the ResourceDictionary 
                // for the given target element
                table = GetInstanceResourceDictionary(fo.FE, fo.FCE); 
                if( table != null ) 
                {
                    candidate = FindBestMatchInResourceDictionary( table, keys, exactMatch, ref bestMatch ); 
                    if (candidate != null)
                    {
                        resource = candidate;
                        if (bestMatch < exactMatch) 
                        {
                            // Exact match found, stop here. 
                            return resource; 
                        }
                    } 
                }

                // -------------------------------------------
                //  Lookup ResourceDictionary on the current instance's Style, if one exists. 
                // -------------------------------------------
 
                table = GetStyleResourceDictionary(fo.FE, fo.FCE); 
                if( table != null )
                { 
                    candidate = FindBestMatchInResourceDictionary( table, keys, exactMatch, ref bestMatch );
                    if (candidate != null)
                    {
                        resource = candidate; 
                        if (bestMatch < exactMatch)
                        { 
                            // Exact match found, stop here. 
                            return resource;
                        } 
                    }
                }

                // ------------------------------------------- 
                //  Lookup ResourceDictionary on the current instance's Theme Style, if one exists.
                // ------------------------------------------- 
 
                table = GetThemeStyleResourceDictionary(fo.FE, fo.FCE);
                if( table != null ) 
                {
                    candidate = FindBestMatchInResourceDictionary( table, keys, exactMatch, ref bestMatch );
                    if (candidate != null)
                    { 
                        resource = candidate;
                        if (bestMatch < exactMatch) 
                        { 
                            // Exact match found, stop here.
                            return resource; 
                        }
                    }
                }
 
                // -------------------------------------------
                //  Lookup ResourceDictionary on the current instance's Template, if one exists. 
                // ------------------------------------------- 

                table = GetTemplateResourceDictionary(fo.FE, fo.FCE); 
                if( table != null )
                {
                    candidate = FindBestMatchInResourceDictionary( table, keys, exactMatch, ref bestMatch );
                    if (candidate != null) 
                    {
                        resource = candidate; 
                        if (bestMatch < exactMatch) 
                        {
                            // Exact match found, stop here. 
                            return resource;
                        }
                    }
                } 

                // If the current element for resource lookup is marked such then abort 
                // lookup because resource lookup does not span tree boundaries 
                if (fo.IsValid && TreeWalkHelper.SkipNext(fo.InheritanceBehavior))
                { 
                    break;
                }

                // ------------------------------------------- 
                //  Find the next parent instance to lookup
                // ------------------------------------------- 
 
                // Get Framework Parent
                fo = fo.FrameworkParent; 

                // If the next parent for resource lookup is marked such then abort
                // lookup because resource lookup does not span tree boundaries
                if (fo.IsValid && TreeWalkHelper.SkipNext(fo.InheritanceBehavior)) 
                {
                    break; 
                } 
            }
 
            return resource;
        }

        // Given a ResourceDictionary and a set of keys, try to find the best 
        //  match in the resource dictionary.
        private static object FindBestMatchInResourceDictionary( 
            ResourceDictionary table, ArrayList keys, int exactMatch, ref int bestMatch) 
        {
            object resource = null; 
            int k;

            // Search target element's ResourceDictionary for the resource
            if (table != null) 
            {
                for (k = 0;  k < bestMatch;  ++k) 
                { 
                    object candidate = table[keys[k]];
                    if (candidate != null) 
                    {
                        resource = candidate;
                        bestMatch = k;
 
                        // if we found an exact match, no need to continue
                        if (bestMatch < exactMatch) 
                            return resource; 
                    }
                } 
            }

            return resource;
        } 

        // Return a reference to the ResourceDictionary set on the instance of 
        //  the given Framework(Content)Element, if such a ResourceDictionary exists. 
        private static ResourceDictionary GetInstanceResourceDictionary(FrameworkElement fe, FrameworkContentElement fce)
        { 
            ResourceDictionary table = null;

            if (fe != null)
            { 
                if (fe.HasResources)
                { 
                    table = fe.Resources; 
                }
            } 
            else // (fce != null)
            {
                if (fce.HasResources)
                { 
                    table = fce.Resources;
                } 
            } 

            return table; 
        }

        // Return a reference to the ResourceDictionary attached to the Style of
        //  the given Framework(Content)Element, if such a ResourceDictionary exists. 
        private static ResourceDictionary GetStyleResourceDictionary(FrameworkElement fe, FrameworkContentElement fce)
        { 
            ResourceDictionary table = null; 

            if (fe != null) 
            {
#if DEBUG
                if( !fe.IsStyleUpdateInProgress )
                { 
#endif
                    if( fe.Style != null && 
                        fe.Style._resources != null ) 
                    {
                        table = fe.Style._resources; 
                    }
#if DEBUG
                }
#endif 
            }
            else // (fce != null) 
            { 
#if DEBUG
                if( !fce.IsStyleUpdateInProgress ) 
                {
#endif
                    if( fce.Style != null &&
                        fce.Style._resources != null ) 
                    {
                        table = fce.Style._resources; 
                    } 
#if DEBUG
                } 
#endif
            }

            return table; 
        }
 
        // Return a reference to the ResourceDictionary attached to the Theme Style of 
        //  the given Framework(Content)Element, if such a ResourceDictionary exists.
        private static ResourceDictionary GetThemeStyleResourceDictionary(FrameworkElement fe, FrameworkContentElement fce) 
        {
            ResourceDictionary table = null;

            if (fe != null) 
            {
#if DEBUG 
                if( !fe.IsThemeStyleUpdateInProgress ) 
                {
#endif 
                    if( fe.ThemeStyle != null &&
                        fe.ThemeStyle._resources != null )
                    {
                        table = fe.ThemeStyle._resources; 
                    }
#if DEBUG 
                } 
#endif
            } 
            else // (fce != null)
            {
#if DEBUG
                if( !fce.IsThemeStyleUpdateInProgress ) 
                {
#endif 
                    if( fce.ThemeStyle != null && 
                        fce.ThemeStyle._resources != null )
                    { 
                        table = fce.ThemeStyle._resources;
                    }
#if DEBUG
                } 
#endif
            } 
 
            return table;
        } 

        // Return a reference to the ResourceDictionary attached to the Template of
        //  the given Framework(Content)Element, if such a ResourceDictionary exists.
        private static ResourceDictionary GetTemplateResourceDictionary(FrameworkElement fe, FrameworkContentElement fce) 
        {
            ResourceDictionary table = null; 
 
            if (fe != null)
            { 
                if( fe.TemplateInternal != null &&
                    fe.TemplateInternal._resources != null )
                {
                    table = fe.TemplateInternal._resources; 
                }
            } 
 
            return table;
        } 

        // return true if there is a local or style-supplied value for the dp
        internal bool HasNonDefaultValue(DependencyProperty dp)
        { 
            return !Helper.HasDefaultValue(dp, this, this/*fe*/, null/*fce*/);
        } 
 
        // Finds the nearest NameScope by walking up the logical tree
        internal static INameScope FindScope(DependencyObject d) 
        {
            DependencyObject scopeOwner;
            return FindScope(d, out scopeOwner);
        } 

        // Finds the nearest NameScope by walking up the logical tree 
        internal static INameScope FindScope(DependencyObject d, out DependencyObject scopeOwner) 
        {
            while (d != null) 
            {
                INameScope nameScope = NameScope.NameScopeFromObject(d);
                if (nameScope != null)
                { 
                    scopeOwner = d;
                    return nameScope; 
                } 

                DependencyObject parent = LogicalTreeHelper.GetParent(d); 

                d = (parent != null) ? parent : Helper.FindMentor(d.InheritanceContext);
            }
 
            scopeOwner = null;
            return null; 
        } 

        // separate function to avoid loading System.Xml until we have a good reason 
        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
        private static string GetXmlTagName(object item, DependencyObject target)
        {
            System.Xml.XmlNode node = item as System.Xml.XmlNode; 
            if (node != null)
            { 
                XmlNamespaceManager namespaceManager = GetXmlNamespaceManager(target); 
                if (namespaceManager != null)
                { 
                    string prefix = namespaceManager.LookupPrefix(node.NamespaceURI);
                    if (prefix != string.Empty)
                        return string.Concat(prefix, ":", node.LocalName);
                } 

                return node.Name; 
            } 
            return null;
        } 

        // In WPF 3.5 we cannot refer to XLinq classes directly, so we
        // have to use reflection to find out what we need.
        private static string GetXLinqTagName(object item, Type type) 
        {
            // get the accessor for the XElement.Name property 
            if (XElement_Name_PropertyInfo == null) 
            {
                XElement_Name_PropertyInfo = type.GetProperty("Name", 
                                BindingFlags.Instance | BindingFlags.Public);
            }

            // get the value of the Name property (of type XName), and convert 
            // it to a string (of the form "{http://my.namespace}TagName")
            if (XElement_Name_PropertyInfo != null) 
            { 
                object value = XElement_Name_PropertyInfo.GetValue(item, null);
                if (value != null) 
                    return value.ToString();
            }

            return null; 
        }
 
        // find the appropriate namespace manager for the given element 
        private static XmlNamespaceManager GetXmlNamespaceManager(DependencyObject target)
        { 
            XmlNamespaceManager nsmgr = Binding.GetXmlNamespaceManager(target);

            if (nsmgr == null)
            { 
                XmlDataProvider xdp = Helper.XmlDataProviderForElement(target);
                nsmgr = (xdp != null) ? xdp.XmlNamespaceManager : null; 
            } 

            return nsmgr; 
        }

        /// 
        ///     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 FrameworkElement 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;
        }

 
        /// 
        ///     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);
        }

        internal void GetRawValue(DependencyProperty dp, PropertyMetadata metadata, ref EffectiveValueEntry entry) 
        {
            // Queries to FrameworkElement will automatically fault in the Style 
 
            // If a value was resolved by base, return that.
            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 
            // (Style already initialized by ParentChainStyleInitialization above)
            //

            // 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(this, null), 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;
 
            // Metadata must exist specifically stating to group or inherit
            // 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) 
                {
                    object value = GetInheritableValue(dp, fmetadata); 

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

            // No value found.
            Debug.Assert(entry.Value == DependencyProperty.UnsetValue,"FrameworkElement.GetRawValue should never fall through with a value != DependencyProperty.UnsetValue.  We're supposed to return as soon as we found something."); 
        }
 
 

        // 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; 
            Debug.Assert( IsTemplatedParentAnFE ); 

            FrameworkElement feTemplatedParent = (FrameworkElement)_templatedParent; 
            frameworkTemplate = feTemplatedParent.TemplateInternal;

            if (frameworkTemplate != null)
            { 
                return StyleHelper.GetValueFromTemplatedParent(
                        _templatedParent, 
                        TemplateChildIndex, 
                        new FrameworkObject(this, null),
                        dp, 
                    ref frameworkTemplate.ChildRecordFromChildIndex,
                        frameworkTemplate.VisualTree,
                    ref entry);
            } 
            return false;
        } 
 
        // Climb the framework tree hierarchy and see if we can pick up an
        //  inheritable property value somewhere in that parent chain. 
        //[CodeAnalysis("AptcaMethodsShouldOnlyCallAptcaMethods")] //Tracking Bug: 29647
        private object GetInheritableValue(DependencyProperty dp, FrameworkPropertyMetadata fmetadata)
        {
            // 
            // Inheritance
            // 
 
            if (!TreeWalkHelper.SkipNext(InheritanceBehavior) || fmetadata.OverridesInheritanceBehavior == true)
            { 
                // Used to terminate tree walk if a tree boundary is hit
                InheritanceBehavior inheritanceBehavior = InheritanceBehavior.Default;

                FrameworkContentElement parentFCE; 
                FrameworkElement parentFE;
                bool hasParent = 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.Flags.performance, EventTrace.Level.verbose))
                        { 
                            string TypeAndName = String.Format(CultureInfo.InvariantCulture, "[{0}]{1}({2})",GetType().Name,dp.Name,base.GetHashCode());
                            EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.PROPERTYPARENTCHECKGUID), 
                                                                 MS.Utility.EventType.Info, 
                                                                 base.GetHashCode(), TypeAndName ); // base.GetHashCode() to avoid calling a virtual, which FxCop doesn't like.
                        } 
#endregion EventTracing

                        DependencyObject parentDO = parentFE;
                        if (parentDO == null) 
                        {
                            parentDO = parentFCE; 
                        } 

                        EntryIndex entryIndex = parentDO.LookupEntry(dp.GlobalIndex); 

                        return parentDO.GetValueEntry(
                                        entryIndex,
                                        dp, 
                                        fmetadata,
                                        RequestFlags.SkipDefault | RequestFlags.DeferredReferences).Value; 
                    } 

                    // 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 = GetFrameworkParent(parentFE, out parentFE, out parentFCE);
                    }
                    else
                    { 
                        hasParent = GetFrameworkParent(parentFCE, out parentFE, out parentFCE);
                    } 
                } 
            }
 
            // Didn't find this value anywhere in the framework tree parent chain,
            //  or search was aborted when we hit a tree boundary node.
            return DependencyProperty.UnsetValue;
        } 

        // 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();
                }

                // 
                // Invalidation propagation for Styles
                // 
 
                // Regardless of metadata, the Style/Template/DefaultStyleKey properties are never a trigger drivers
                if (dp != StyleProperty && dp != Control.TemplateProperty && 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 /*sourceChildIndex*/); // 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)
                    if (TemplateInternal != null) 
                    {
                        StyleHelper.OnTriggerSourcePropertyInvalidated(null, TemplateInternal, this, dp, e, !HasTemplateGeneratedSubTree /*invalidateOnlyContainer*/, 
                            ref TemplateInternal.TriggerSourceRecordFromChildIndex, ref TemplateInternal.PropertyTriggersWithActions, 0 /*sourceChildIndex*/); // These are driven by the container 
                    }
 
                    // 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)
                    {
                        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( e.OperationType != OperationType.AddChild && 
                            e.OperationType != OperationType.RemoveChild &&
                            e.OperationType != OperationType.Inherit) 
                        {
                            TreeWalkHelper.InvalidateOnInheritablePropertyChange(this, null, info, true);
                        }
 
                        // Notify mentees if they exist
                        if (PotentiallyHasMentees) 
                        { 
                            TreeWalkHelper.OnInheritedPropertyChanged(this, ref info, InheritanceBehavior);
                        } 
                    }
                }

                if (e.IsAValueChange || e.IsASubPropertyChange) 
                {
                    // 
                    // Layout invalidation 
                    //
 
                    // Skip if we're traversing an Visibility=Collapsed subtree while
                    //  in the middle of an invalidation storm due to ancestor change
                    if( !(AncestorChangeInProgress && InVisibilityCollapsedTree) )
                    { 
                        UIElement layoutParent = null;
 
                        bool affectsParentMeasure = fmetadata.AffectsParentMeasure; 
                        bool affectsParentArrange = fmetadata.AffectsParentArrange;
                        bool affectsMeasure = fmetadata.AffectsMeasure; 
                        bool affectsArrange = fmetadata.AffectsArrange;
                        if (affectsMeasure || affectsArrange || affectsParentArrange || affectsParentMeasure)
                        {
                            // Locate nearest Layout parent 
                            for (Visual v = VisualTreeHelper.GetParent(this) as Visual;
                                 v != null; 
                                 v = VisualTreeHelper.GetParent(v) as Visual) 
                            {
                                layoutParent = v as UIElement; 
                                if (layoutParent != null)
                                {
                                    //let incrementally-updating FrameworkElements to mark the vicinity of the affected child
                                    //to perform partial update. 
                                    if(FrameworkElement.DType.IsInstanceOfType(layoutParent))
                                        ((FrameworkElement)layoutParent).ParentLayoutInvalidated(this); 
 
                                    if (affectsParentMeasure)
                                    { 
                                        layoutParent.InvalidateMeasure();
                                    }

                                    if (affectsParentArrange) 
                                    {
                                        layoutParent.InvalidateArrange(); 
                                    } 

                                    break; 
                                }
                            }
                        }
 
                        if (fmetadata.AffectsMeasure)
                        { 
                            // 

 

                            if (!BypassLayoutPolicies || !((dp == WidthProperty) || (dp == HeightProperty)))
                            {
                                InvalidateMeasure(); 
                            }
                        } 
 
                        if (fmetadata.AffectsArrange)
                        { 
                            InvalidateArrange();
                        }

                        if (fmetadata.AffectsRender && 
                            (e.IsAValueChange || !fmetadata.SubPropertiesDoNotAffectRender))
                        { 
                            InvalidateVisual(); 
                        }
                    } 
                }
            }
        }
 
        //
        // Get the closest Framework type up the logical or physical tree 
        // 
        // (Shared between FrameworkElement and FrameworkContentElement)
        // 
        internal static DependencyObject GetFrameworkParent(object current)
        {
            FrameworkObject fo = new FrameworkObject(current as DependencyObject);
 
            fo = fo.FrameworkParent;
 
            return fo.DO; 
        }
 
        internal static bool GetFrameworkParent(FrameworkElement current, out FrameworkElement feParent, out FrameworkContentElement fceParent)
        {
            FrameworkObject fo = new FrameworkObject(current, null);
 
            fo = fo.FrameworkParent;
 
            feParent = fo.FE; 
            fceParent = fo.FCE;
 
            return fo.IsValid;
        }

 
        internal static bool GetFrameworkParent(FrameworkContentElement current, out FrameworkElement feParent, out FrameworkContentElement fceParent)
        { 
            FrameworkObject fo = new FrameworkObject(null, current); 

            fo = fo.FrameworkParent; 

            feParent = fo.FE;
            fceParent = fo.FCE;
 
            return fo.IsValid;
        } 
 
        internal static bool GetContainingFrameworkElement(DependencyObject current, out FrameworkElement fe, out FrameworkContentElement fce)
        { 
            FrameworkObject fo = FrameworkObject.GetContainingFrameworkElement(current);

            if (fo.IsValid)
            { 
                fe = fo.FE;
                fce = fo.FCE; 
                return true; 
            }
            else 
            {
                fe = null;
                fce = null;
                return false; 
            }
        } 
 

        // Fetchs the specified childRecord for the given template.  Returns true if successful. 
        internal static void GetTemplatedParentChildRecord(
            DependencyObject templatedParent,
            int childIndex,
            out ChildRecord childRecord, 
            out bool isChildRecordValid)
        { 
            FrameworkTemplate templatedParentTemplate = null; 
            isChildRecordValid = false;
            childRecord = new ChildRecord();    // CS0177 

            if (templatedParent != null)
            {
                FrameworkObject foTemplatedParent = new FrameworkObject(templatedParent, true); 

                Debug.Assert( foTemplatedParent.IsFE ); 
 
                // This node is the result of a style expansion
 
                // Pick the owner for the VisualTree that generated this node
                templatedParentTemplate = foTemplatedParent.FE.TemplateInternal;

                Debug.Assert(templatedParentTemplate != null , 
                    "If this node is the result of a VisualTree expansion then it should have a parent template");
 
                // Check if this Child Index is represented in FrameworkTemplate 
                if (templatedParentTemplate != null && ((0 <= childIndex) && (childIndex < templatedParentTemplate.ChildRecordFromChildIndex.Count)))
                { 
                    childRecord = templatedParentTemplate.ChildRecordFromChildIndex[childIndex];
                    isChildRecordValid = true;
                }
 
            }
        } 
 
        /// 
        ///     Return the text that represents this object, from the User's perspective. 
        /// 
        /// 
        internal virtual string GetPlainText()
        { 
            return null;
        } 
 

        static FrameworkElement() 
        {
            SnapsToDevicePixelsProperty.OverrideMetadata(_typeofThis, new FrameworkPropertyMetadata(BooleanBoxes.FalseBox, FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsArrange));

            EventManager.RegisterClassHandler(_typeofThis, Mouse.QueryCursorEvent, new QueryCursorEventHandler(FrameworkElement.OnQueryCursorOverride), true); 

            EventManager.RegisterClassHandler(_typeofThis, Keyboard.PreviewGotKeyboardFocusEvent, new KeyboardFocusChangedEventHandler(OnPreviewGotKeyboardFocus)); 
            EventManager.RegisterClassHandler(_typeofThis, Keyboard.GotKeyboardFocusEvent, new KeyboardFocusChangedEventHandler(OnGotKeyboardFocus)); 
            EventManager.RegisterClassHandler(_typeofThis, Keyboard.LostKeyboardFocusEvent, new KeyboardFocusChangedEventHandler(OnLostKeyboardFocus));
 
            AllowDropProperty.OverrideMetadata(_typeofThis, new FrameworkPropertyMetadata(BooleanBoxes.FalseBox, FrameworkPropertyMetadataOptions.Inherits));

            Stylus.IsPressAndHoldEnabledProperty.AddOwner(_typeofThis, new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, FrameworkPropertyMetadataOptions.Inherits));
            Stylus.IsFlicksEnabledProperty.AddOwner(_typeofThis, new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, FrameworkPropertyMetadataOptions.Inherits)); 
            Stylus.IsTapFeedbackEnabledProperty.AddOwner(_typeofThis, new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, FrameworkPropertyMetadataOptions.Inherits));
            Stylus.IsTouchFeedbackEnabledProperty.AddOwner(_typeofThis, new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, FrameworkPropertyMetadataOptions.Inherits)); 
 
            PropertyChangedCallback numberSubstitutionChanged = new PropertyChangedCallback(NumberSubstitutionChanged);
            NumberSubstitution.CultureSourceProperty.OverrideMetadata(_typeofThis, new FrameworkPropertyMetadata(NumberCultureSource.User, FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsRender, numberSubstitutionChanged)); 
            NumberSubstitution.CultureOverrideProperty.OverrideMetadata(_typeofThis, new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsRender, numberSubstitutionChanged));
            NumberSubstitution.SubstitutionProperty.OverrideMetadata(_typeofThis, new FrameworkPropertyMetadata(NumberSubstitutionMethod.AsCulture, FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsRender, numberSubstitutionChanged));

            // Exposing these events in protected virtual methods 
            EventManager.RegisterClassHandler(_typeofThis, ToolTipOpeningEvent, new ToolTipEventHandler(OnToolTipOpeningThunk));
            EventManager.RegisterClassHandler(_typeofThis, ToolTipClosingEvent, new ToolTipEventHandler(OnToolTipClosingThunk)); 
            EventManager.RegisterClassHandler(_typeofThis, ContextMenuOpeningEvent, new ContextMenuEventHandler(OnContextMenuOpeningThunk)); 
            EventManager.RegisterClassHandler(_typeofThis, ContextMenuClosingEvent, new ContextMenuEventHandler(OnContextMenuClosingThunk));
 
            // Coerce Callback for font properties for responding to system themes
            TextElement.FontFamilyProperty.OverrideMetadata(_typeofThis, new FrameworkPropertyMetadata(SystemFonts.MessageFontFamily, FrameworkPropertyMetadataOptions.Inherits, null, new CoerceValueCallback(CoerceFontFamily)));
            TextElement.FontSizeProperty.OverrideMetadata(_typeofThis, new FrameworkPropertyMetadata(SystemFonts.MessageFontSize, FrameworkPropertyMetadataOptions.Inherits, null, new CoerceValueCallback(CoerceFontSize)));
            TextElement.FontStyleProperty.OverrideMetadata(_typeofThis, new FrameworkPropertyMetadata(SystemFonts.MessageFontStyle, FrameworkPropertyMetadataOptions.Inherits, null, new CoerceValueCallback(CoerceFontStyle))); 
            TextElement.FontWeightProperty.OverrideMetadata(_typeofThis, new FrameworkPropertyMetadata(SystemFonts.MessageFontWeight, FrameworkPropertyMetadataOptions.Inherits, null, new CoerceValueCallback(CoerceFontWeight)));
        } 
 
        internal static readonly NumberSubstitution DefaultNumberSubstitution = new NumberSubstitution(
            NumberCultureSource.User,           // number substitution in UI defaults to user culture 
            null,                               // culture override
            NumberSubstitutionMethod.AsCulture
            );
 
        /// 
        ///     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()
        {
        } 

        ///  
        /// OnVisualParentChanged is called when the parent of the Visual is changed. 
        /// 
        /// Old parent or null if the Visual did not have a parent before. 
        protected internal override void OnVisualParentChanged(DependencyObject oldParent)
        {
            DependencyObject newParent = VisualTreeHelper.GetParentInternal(this);
 
            // Visual parent implies no InheritanceContext
            if (newParent != null) 
            { 
                ClearInheritanceContext();
            } 

            // Update HasLoadedChangeHandler Flag
            BroadcastEventHelper.AddOrRemoveHasLoadedChangeHandlerFlag(this, oldParent, newParent);
 
            // Fire Loaded and Unloaded Events
            BroadcastEventHelper.BroadcastLoadedOrUnloadedEvent(this, oldParent, newParent); 
 
            if (newParent != null && (newParent is FrameworkElement) == false)
            { 
                // If you are being connected to a non-FE parent then start listening for VisualAncestor
                // changes because otherwise you won't know about changes happening above you
                Visual newParentAsVisual = newParent as Visual;
                if (newParentAsVisual != null) 
                {
                    newParentAsVisual.VisualAncestorChanged += new AncestorChangedEventHandler(OnVisualAncestorChanged); 
                } 
                else if (newParent is Visual3D)
                { 
                    ((Visual3D)newParent).VisualAncestorChanged += new Visual.AncestorChangedEventHandler(OnVisualAncestorChanged);
                }
            }
            else if (oldParent != null && (oldParent is FrameworkElement) == false) 
            {
                // If you are being disconnected from a non-FE parent then stop listening for 
                // VisualAncestor changes 
                Visual oldParentAsVisual = oldParent as Visual;
                if (oldParentAsVisual != null) 
                {
                    oldParentAsVisual.VisualAncestorChanged -= new AncestorChangedEventHandler(OnVisualAncestorChanged);
                }
                else if (oldParent is Visual3D) 
                {
                    ((Visual3D)oldParent).VisualAncestorChanged -= new Visual.AncestorChangedEventHandler(OnVisualAncestorChanged); 
                } 
            }
 
            // Do it only if you do not have a logical parent
            if (Parent == null)
            {
                // Invalidate relevant properties for this subtree 
                DependencyObject parent = (newParent != null) ? newParent : oldParent;
                TreeWalkHelper.InvalidateOnTreeChange(this, null, parent, (newParent != null)); 
            } 

            // Initialize, if not already done. 

            // Note that it is for performance reasons that we TryFireInitialize after
            // we have done InvalidateOnTreeChange. This is because InvalidateOnTreeChange
            // invalidates the style property conditionally if the object has been initialized. 
            // And OnInitialized also invalidates the style property. If we were to do these
            // operations in the reverse order we would be invalidating the style property twice. 
            // Whereas now we do it only once. 

            TryFireInitialized(); 

            base.OnVisualParentChanged(oldParent);
        }
 
        internal new void OnVisualAncestorChanged(object sender, AncestorChangedEventArgs e)
        { 
            // NOTE: 
            //
            // We are forced to listen to AncestorChanged events because a FrameworkElement 
            // may have raw Visuals/UIElements between it and its nearest FrameworkElement
            // parent.  We only care about changes that happen to the visual tree BETWEEN
            // this FrameworkElement and its nearest FrameworkElement parent.  This is
            // because we can rely on our nearest FrameworkElement parent to notify us 
            // when its loaded state changes.
 
            FrameworkElement feParent = null; 
            FrameworkContentElement fceParent = null;
 
            // Find our nearest FrameworkElement parent.
            FrameworkElement.GetContainingFrameworkElement(VisualTreeHelper.GetParent(this), out feParent, out fceParent);
            Debug.Assert(fceParent == null, "Nearest framework parent via the visual tree has to be an FE. It cannot be an FCE");
 
            if(e.OldParent == null)
            { 
                // We were plugged into something. 

                // See if this parent is a child of the ancestor who's parent changed. 
                // If so, we don't care about changes that happen above us.
                if(feParent == null || !VisualTreeHelper.IsAncestorOf(e.Ancestor, feParent))
                {
                    // Update HasLoadedChangeHandler Flag 
                    BroadcastEventHelper.AddOrRemoveHasLoadedChangeHandlerFlag(this, null, VisualTreeHelper.GetParent(e.Ancestor));
 
                    // Fire Loaded and Unloaded Events 
                    BroadcastEventHelper.BroadcastLoadedOrUnloadedEvent(this, null, VisualTreeHelper.GetParent(e.Ancestor));
                } 
            }
            else
            {
                // we were unplugged from something. 

                // If we found a FrameworkElement parent in our subtree, the 
                // break in the visual tree must have been above it, 
                // so we don't need to respond.
 
                if(feParent == null)
                {
                    // There was no FrameworkElement parent in our subtree, so we
                    // may be detaching from some FrameworkElement parent above 
                    // the break point in the tree.
                    FrameworkElement.GetContainingFrameworkElement(e.OldParent, out feParent, out fceParent); 
 
                    if(feParent != null)
                    { 
                        // Update HasLoadedChangeHandler Flag
                        BroadcastEventHelper.AddOrRemoveHasLoadedChangeHandlerFlag(this, feParent, null);

                        // Fire Loaded and Unloaded Events 
                        BroadcastEventHelper.BroadcastLoadedOrUnloadedEvent(this, feParent, null);
                    } 
                } 
            }
        } 

        /// 
        ///     Indicates the current mode of lookup for both inheritance and resources.
        ///  
        /// 
        ///     Used in property inheritance and reverse 
        ///     inheritance 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. 
        /// 
        protected 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 FE 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:*/this, /*fce:*/null, _parent, true);
                    }
                } 
                else
                { 
                    throw new InvalidOperationException(SR.Get(SRID.Illegal_InheritanceBehaviorSettor)); 
                }
            } 
        }


        #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 =
                    DependencyProperty.Register(
                                "DataContext",
                                typeof(object), 
                                _typeofThis,
                                new FrameworkPropertyMetadata(null, 
                                        FrameworkPropertyMetadataOptions.Inherits, 
                                        new PropertyChangedCallback(OnDataContextChanged)));
 
        /// 
        ///     DataContextChanged private key
        /// 
        internal static readonly EventPrivateKey DataContextChangedKey = new EventPrivateKey(); 

        ///  
        ///     DataContextChanged event 
        /// 
        ///  
        ///     When an element's DataContext changes, all data-bound properties
        ///     (on this element or any other element) whose Bindings 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(DataContextChangedKey, value); }
            remove { EventHandlersStoreRemove(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)
        { 
            ((FrameworkElement) d).RaiseDependencyPropertyChanged(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 the 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 = 
                    DependencyProperty.Register(
                                "BindingGroup", 
                                typeof(BindingGroup), 
                                _typeofThis,
                                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
 
 
        /// 
        ///     Returns a non-null value when some framework implementation 
        ///     of this method has a non-visual parent connection,
        /// 
        protected internal override DependencyObject GetUIParentCore()
        { 
            // Note: this only follows one logical link.
            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)
        {
        }
 
        /// 
        ///     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 bool BuildRouteCore(EventRoute route, RoutedEventArgs args)
        { 
            return BuildRouteCoreHelper(route, args, true);
        } 
        internal bool BuildRouteCoreHelper(EventRoute route, RoutedEventArgs args, bool shouldAddIntermediateElementsToRoute) 
        {
            bool continuePastCoreTree = false; 

            DependencyObject visualParent = VisualTreeHelper.GetParent(this);
            DependencyObject modelParent = GetUIParentCore();
 
            // 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
                if (shouldAddIntermediateElementsToRoute) 
                {
                    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)
                { 
                    Visual visualParentAsVisual = visualParent as Visual;
                    if (visualParentAsVisual != null) 
                    { 
                        if (visualParentAsVisual.CheckFlagsAnd(VisualFlags.IsLayoutIslandRoot))
                        { 
                            continuePastCoreTree = true;
                        }
                    }
                    else 
                    {
                        if (((Visual3D)visualParent).CheckFlagsAnd(VisualFlags.IsLayoutIslandRoot)) 
                        { 
                            continuePastCoreTree = true;
                        } 
                    }

                    // 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) 
        {
            AddStyleHandlersToEventRoute(this, null, route, args);
        }
 
        // Add Style TargetType and FEF EventHandlers to the EventRoute
        internal static void AddStyleHandlersToEventRoute( 
            FrameworkElement fe, 
            FrameworkContentElement fce,
            EventRoute route, 
            RoutedEventArgs args)
        {
            Debug.Assert(fe != null || fce != null);
 
            DependencyObject source = (fe != null) ? (DependencyObject)fe : (DependencyObject)fce;
            Style selfStyle = null; 
            FrameworkTemplate selfFrameworkTemplate = null; 
            DependencyObject templatedParent = null;
            int templateChildIndex = -1; 

            // Fetch selfStyle, TemplatedParent and TemplateChildIndex
            if (fe != null)
            { 
                selfStyle = fe.Style;
                selfFrameworkTemplate = fe.TemplateInternal; 
                templatedParent = fe.TemplatedParent; 
                templateChildIndex = fe.TemplateChildIndex;
            } 
            else
            {
                selfStyle = fce.Style;
                templatedParent = fce.TemplatedParent; 
                templateChildIndex = fce.TemplateChildIndex;
            } 
 
            // Add TargetType EventHandlers to the route. Notice that ThemeStyle
            // cannot have EventHandlers and hence are ignored here. 
            RoutedEventHandlerInfo[] handlers = null;
            if (selfStyle != null && selfStyle.EventHandlersStore != null)
            {
                handlers = selfStyle.EventHandlersStore.GetRoutedEventHandlers(args.RoutedEvent); 
                AddStyleHandlersToEventRoute(route, source, handlers);
            } 
            if (selfFrameworkTemplate != null && selfFrameworkTemplate.EventHandlersStore != null) 
            {
                handlers = selfFrameworkTemplate.EventHandlersStore.GetRoutedEventHandlers(args.RoutedEvent); 
                AddStyleHandlersToEventRoute(route, source, handlers);
            }

            if (templatedParent != null) 
            {
                FrameworkTemplate templatedParentTemplate = null; 
 
                FrameworkElement feTemplatedParent = templatedParent as FrameworkElement;
                Debug.Assert( feTemplatedParent != null ); 

                templatedParentTemplate = feTemplatedParent.TemplateInternal;

                // Fetch handlers from either the parent style or template 
                handlers = null;
                if (templatedParentTemplate != null && templatedParentTemplate.HasEventDependents) 
                { 
                    handlers = StyleHelper.GetChildRoutedEventHandlers(templateChildIndex, args.RoutedEvent, ref templatedParentTemplate.EventDependents);
                } 

                // Add FEF EventHandlers to the route
                AddStyleHandlersToEventRoute(route, source, handlers);
            } 
        }
 
        // This is a helper that will facilitate adding a given array of handlers to the route 
        private static void AddStyleHandlersToEventRoute(
            EventRoute route, 
            DependencyObject source,
            RoutedEventHandlerInfo[] handlers)
        {
            if (handlers != null) 
            {
                for (int i=0; i
        /// 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 = 
                    DependencyProperty.RegisterAttached( 
                                "Language",
                                typeof(XmlLanguage), 
                                _typeofThis,
                                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 
 
        /// 
        ///     The DependencyProperty for the Name property. 
        /// 
        [CommonDependencyProperty]
        public static readonly DependencyProperty NameProperty =
                    DependencyProperty.Register( 
                                "Name",
                                typeof(string), 
                                _typeofThis, 
                                new FrameworkPropertyMetadata(
                                    string.Empty,                           // defaultValue 
                                    FrameworkPropertyMetadataOptions.None,  // flags
                                    null,                                   // propertyChangedCallback
                                    null,                                   // coerceValueCallback
                                    true),                                  // isAnimationProhibited 
                                new ValidateValueCallback(System.Windows.Markup.NameValidationHelper.NameValidationCallback));
 
        ///  
        ///     Name property.
        ///  
        [Localizability(LocalizationCategory.NeverLocalize)]
        [MergableProperty(false)]
        [DesignerSerializationOptions(DesignerSerializationOptions.SerializeAsAttribute)]
        public string Name 
        {
            get { return (string) GetValue(NameProperty); } 
            set { SetValue(NameProperty, value);  } 
        }
 
        /// 
        ///     The DependencyProperty for the Tag property.
        /// 
        public static readonly DependencyProperty TagProperty = 
                    DependencyProperty.Register(
                                "Tag", 
                                typeof(object), 
                                _typeofThis,
                                new FrameworkPropertyMetadata((object) null)); 

        /// 
        ///     Tag property.
        ///  
        [Localizability(LocalizationCategory.NeverLocalize)]
        public object Tag 
        { 
            get { return GetValue(TagProperty); }
            set { SetValue(TagProperty, value); } 
        }

        #region InputScope
 
        /// 
        ///     InputScope DependencyProperty 
        ///     this is originally registered on InputMethod class 
        /// 
        public static readonly DependencyProperty InputScopeProperty = 
                    InputMethod.InputScopeProperty.AddOwner(_typeofThis,
                                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
 
        ///  
        /// RequestBringIntoView Event
        ///  
        public static readonly RoutedEvent RequestBringIntoViewEvent = EventManager.RegisterRoutedEvent("RequestBringIntoView", RoutingStrategy.Bubble, typeof(RequestBringIntoViewEventHandler), _typeofThis);

        /// 
        /// Handler registration for RequestBringIntoView event. 
        /// 
        public event RequestBringIntoViewEventHandler RequestBringIntoView 
        { 
            add { AddHandler(RequestBringIntoViewEvent, value, false); }
            remove { RemoveHandler(RequestBringIntoViewEvent, value); } 
        }

        /// 
        /// Attempts to bring this element into view by originating a RequestBringIntoView event. 
        /// 
        public void BringIntoView() 
        { 
            //dmitryt, bug 1126518. On new/updated elements RenderSize isn't yet computed
            //so we need to postpone the rect computation until layout is done. 
            //this is accomplished by passing Empty rect here and then asking for RenderSize
            //in IScrollInfo when it actually executes an async MakeVisible command.
            BringIntoView( /*RenderSize*/ Rect.Empty);
        } 

        ///  
        /// Attempts to bring the given rectangle of this element into view by originating a RequestBringIntoView event. 
        /// 
        public void BringIntoView(Rect targetRectangle) 
        {
            RequestBringIntoViewEventArgs args = new RequestBringIntoViewEventArgs(this, targetRectangle);
            args.RoutedEvent=RequestBringIntoViewEvent;
            RaiseEvent(args); 
        }
 
 
        /// 
        /// SizeChanged event 
        /// 
        public static readonly RoutedEvent SizeChangedEvent = EventManager.RegisterRoutedEvent("SizeChanged", RoutingStrategy.Direct, typeof(SizeChangedEventHandler), _typeofThis);

        ///  
        /// SizeChanged event. It is fired when ActualWidth or ActualHeight (or both) changed.
        /// SizeChangedEventArgs parameter contains new and 
        /// old sizes, and flags indicating whether Width or Height actually changed.  
        /// These flags are provided to avoid common mistake of comparing new and old values
        /// since simple compare of double-precision numbers can yield "not equal" when size in fact 
        /// didn't change (round off errors accumulated during input processing and layout calculations
        /// may result in very small differencies that are considered "the same layout").
        /// 
        public event SizeChangedEventHandler SizeChanged 
        {
            add {AddHandler(SizeChangedEvent, value, false);} 
            remove {RemoveHandler(SizeChangedEvent, value);} 
        }
 
        private static PropertyMetadata _actualWidthMetadata = new ReadOnlyFrameworkPropertyMetadata(0d, new GetReadOnlyValueCallback(GetActualWidth));

        /// 
        ///     The key needed set a read-only property. 
        /// 
        private static readonly DependencyPropertyKey ActualWidthPropertyKey = 
                DependencyProperty.RegisterReadOnly( 
                        "ActualWidth",
                        typeof(double), 
                        _typeofThis,
                        _actualWidthMetadata);

        private static object GetActualWidth(DependencyObject d, out BaseValueSourceInternal source) 
        {
            FrameworkElement fe = (FrameworkElement) d; 
            if (fe.HasWidthEverChanged) 
            {
                source = BaseValueSourceInternal.Local; 
                return fe.RenderSize.Width;
            }
            else
            { 
                source = BaseValueSourceInternal.Default;
                return 0d; 
            } 
        }
 
        /// 
        /// The ActualWidth dynamic property.
        /// 
        public static readonly DependencyProperty ActualWidthProperty = 
                ActualWidthPropertyKey.DependencyProperty;
 
        ///  
        /// The ActualWidth CLR property - wrapper for ActualWidthProperty.
        /// Result in 1/96th inch. ("device-independent pixel") 
        /// 
        public double ActualWidth
        {
            get 
            {
                return RenderSize.Width; 
            } 
        }
 
        private static PropertyMetadata _actualHeightMetadata = new ReadOnlyFrameworkPropertyMetadata(0d, new GetReadOnlyValueCallback(GetActualHeight));

        /// 
        ///     The key needed set a read-only property. 
        /// 
        private static readonly DependencyPropertyKey ActualHeightPropertyKey = 
                DependencyProperty.RegisterReadOnly( 
                        "ActualHeight",
                        typeof(double), 
                        _typeofThis,
                        _actualHeightMetadata);

        private static object GetActualHeight(DependencyObject d, out BaseValueSourceInternal source) 
        {
            FrameworkElement fe = (FrameworkElement) d; 
            if (fe.HasHeightEverChanged) 
            {
                source = BaseValueSourceInternal.Local; 
                return fe.RenderSize.Height;
            }
            else
            { 
                source = BaseValueSourceInternal.Default;
                return 0d; 
            } 
        }
 
        /// 
        /// The ActualHeight dynamic property.
        /// 
        public static readonly DependencyProperty ActualHeightProperty = 
                ActualHeightPropertyKey.DependencyProperty;
 
        ///  
        /// The ActualHeight CLR property - wrapper for ActualHeightProperty.
        /// Result in 1/96th inch. ("device-independent pixel") 
        /// 
        public double ActualHeight
        {
            get 
            {
                return RenderSize.Height; 
            } 
        }
 
        /// 
        /// The LayoutTransform dependency property.
        /// 
        public static readonly DependencyProperty LayoutTransformProperty = DependencyProperty.Register( 
                    "LayoutTransform",
                    typeof(Transform), 
                    _typeofThis, 
                    new FrameworkPropertyMetadata(
                            Transform.Identity, 
                            FrameworkPropertyMetadataOptions.AffectsMeasure,
                            new PropertyChangedCallback(OnLayoutTransformChanged)));

        ///  
        ///  The LayoutTransform property defines the transform that will be
        ///  applied to the element during layout. In contrast to RenderTransform, LayoutTransform does affect 
        ///  results of layout, and provides powerful capabilities of scaling and rotating. At the same time, the 
        ///  LayoutTransform does not support Translate operation since it auto-compensate any offsets to position
        ///  sclaed/rotated element into layout partition created by the parent Panel. 
        /// 
        public Transform LayoutTransform
        {
            get { return (Transform) GetValue(LayoutTransformProperty); } 
            set { SetValue(LayoutTransformProperty, value); }
        } 
 
        private static void OnLayoutTransformChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            FrameworkElement fe = (FrameworkElement)d;
            fe.AreTransformsClean = false;
        }
 
        private static bool IsWidthHeightValid(object value)
        { 
            double v = (double)value; 
            return (DoubleUtil.IsNaN(v)) || (v >= 0.0d && !Double.IsPositiveInfinity(v));
        } 

        private static bool IsMinWidthHeightValid(object value)
        {
            double v = (double)value; 
            return (!DoubleUtil.IsNaN(v) && v >= 0.0d && !Double.IsPositiveInfinity(v));
        } 
 
        private static bool IsMaxWidthHeightValid(object value)
        { 
            double v = (double)value;
            return (!DoubleUtil.IsNaN(v) && v >= 0.0d);
        }
 
        private static void OnTransformDirty(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            // Callback for MinWidth, MaxWidth, Width, MinHeight, MaxHeight, Height, and RenderTransformOffset 
            FrameworkElement fe = (FrameworkElement)d;
            fe.AreTransformsClean = false; 
        }

        /// 
        /// Width Dependency Property 
        /// 
        [CommonDependencyProperty] 
        public static readonly DependencyProperty WidthProperty = 
                    DependencyProperty.Register(
                                "Width", 
                                typeof(double),
                                _typeofThis,
                                new FrameworkPropertyMetadata(
                                        Double.NaN, 
                                        FrameworkPropertyMetadataOptions.AffectsMeasure,
                                        new PropertyChangedCallback(OnTransformDirty)), 
                                new ValidateValueCallback(IsWidthHeightValid)); 

        ///  
        /// Width Property
        /// 
        [TypeConverter(typeof(LengthConverter))]
        [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)] 
        public double Width
        { 
            get { return (double) GetValue(WidthProperty); } 
            set { SetValue(WidthProperty, value); }
        } 

        /// 
        /// MinWidth Dependency Property
        ///  
        [CommonDependencyProperty]
        public static readonly DependencyProperty MinWidthProperty = 
                    DependencyProperty.Register( 
                                "MinWidth",
                                typeof(double), 
                                _typeofThis,
                                new FrameworkPropertyMetadata(
                                        0d,
                                        FrameworkPropertyMetadataOptions.AffectsMeasure, 
                                        new PropertyChangedCallback(OnTransformDirty)),
                                new ValidateValueCallback(IsMinWidthHeightValid)); 
 
        /// 
        /// MinWidth Property 
        /// 
        [TypeConverter(typeof(LengthConverter))]
        [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)]
        public double MinWidth 
        {
            get { return (double) GetValue(MinWidthProperty); } 
            set { SetValue(MinWidthProperty, value); } 
        }
 
        /// 
        /// MaxWidth Dependency Property
        /// 
        [CommonDependencyProperty] 
        public static readonly DependencyProperty MaxWidthProperty =
                    DependencyProperty.Register( 
                                "MaxWidth", 
                                typeof(double),
                                _typeofThis, 
                                new FrameworkPropertyMetadata(
                                        Double.PositiveInfinity,
                                        FrameworkPropertyMetadataOptions.AffectsMeasure,
                                        new PropertyChangedCallback(OnTransformDirty)), 
                                new ValidateValueCallback(IsMaxWidthHeightValid));
 
 
        /// 
        /// MaxWidth Property 
        /// 
        [TypeConverter(typeof(LengthConverter))]
        [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)]
        public double MaxWidth 
        {
            get { return (double) GetValue(MaxWidthProperty); } 
            set { SetValue(MaxWidthProperty, value); } 
        }
 
        /// 
        /// Height Dependency Property
        /// 
        [CommonDependencyProperty] 
        public static readonly DependencyProperty HeightProperty =
                    DependencyProperty.Register( 
                                "Height", 
                                typeof(double),
                                _typeofThis, 
                                new FrameworkPropertyMetadata(
                                    Double.NaN,
                                    FrameworkPropertyMetadataOptions.AffectsMeasure,
                                    new PropertyChangedCallback(OnTransformDirty)), 
                                new ValidateValueCallback(IsWidthHeightValid));
 
        ///  
        /// Height Property
        ///  
        [TypeConverter(typeof(LengthConverter))]
        [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)]
        public double Height
        { 
            get { return (double) GetValue(HeightProperty); }
            set { SetValue(HeightProperty, value); } 
        } 

        ///  
        /// MinHeight Dependency Property
        /// 
        [CommonDependencyProperty]
        public static readonly DependencyProperty MinHeightProperty = 
                    DependencyProperty.Register(
                                "MinHeight", 
                                typeof(double), 
                                _typeofThis,
                                new FrameworkPropertyMetadata( 
                                        0d,
                                        FrameworkPropertyMetadataOptions.AffectsMeasure,
                                        new PropertyChangedCallback(OnTransformDirty)),
                                new ValidateValueCallback(IsMinWidthHeightValid)); 

        ///  
        /// MinHeight Property 
        /// 
        [TypeConverter(typeof(LengthConverter))] 
        [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)]
        public double MinHeight
        {
            get { return (double) GetValue(MinHeightProperty); } 
            set { SetValue(MinHeightProperty, value); }
        } 
 
        /// 
        /// MaxHeight Dependency Property 
        /// 
        [CommonDependencyProperty]
        public static readonly DependencyProperty MaxHeightProperty =
                    DependencyProperty.Register( 
                                "MaxHeight",
                                typeof(double), 
                                _typeofThis, 
                                new FrameworkPropertyMetadata(
                                        Double.PositiveInfinity, 
                                        FrameworkPropertyMetadataOptions.AffectsMeasure,
                                        new PropertyChangedCallback(OnTransformDirty)),
                                new ValidateValueCallback(IsMaxWidthHeightValid));
 
        /// 
        /// MaxHeight Property 
        ///  
        [TypeConverter(typeof(LengthConverter))]
        [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)] 
        public double MaxHeight
        {
            get { return (double) GetValue(MaxHeightProperty); }
            set { SetValue(MaxHeightProperty, value); } 
        }
 
        ///  
        /// FlowDirectionProperty
        ///  
        [CommonDependencyProperty]
        public static readonly DependencyProperty FlowDirectionProperty =
                    DependencyProperty.RegisterAttached(
                                "FlowDirection", 
                                typeof(FlowDirection),
                                _typeofThis, 
                                new FrameworkPropertyMetadata( 
                                            System.Windows.FlowDirection.LeftToRight, // default value
                                            FrameworkPropertyMetadataOptions.Inherits 
                                          | FrameworkPropertyMetadataOptions.AffectsParentArrange,
                                            new PropertyChangedCallback(OnFlowDirectionChanged),
                                            new CoerceValueCallback(CoerceFlowDirectionProperty)),
                                new ValidateValueCallback(IsValidFlowDirection)); 

        //  Since layout applies mirroring based on pair-wise flow direction property value comparison 
        //  of an element and its visual parent and since this does not exactly match property engine's 
        //  notion of dirty-ness, the following measures are taken:
        //  1.  FlowDirectionProperty is made force inherited property. 
        //  2.  Invalidation happens during coercion (which is called always unlike behaviour of
        //      flags set in metadata).
        private static object CoerceFlowDirectionProperty(DependencyObject d, object value)
        { 
            FrameworkElement fe = d as FrameworkElement;
            if (fe != null) 
            { 
                fe.InvalidateArrange();
                fe.InvalidateVisual(); 
                fe.AreTransformsClean = false;
            }
            return value;
        } 

        private static void OnFlowDirectionChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        { 
            // Check that d is a FrameworkElement since the property inherits and this can be called
            // on non-FEs. 
            FrameworkElement fe = d as FrameworkElement;
            if (fe != null)
            {
                // Cache the new value as a bit to optimize accessing the FlowDirection property's CLR accessor 
                fe.IsRightToLeft = ((FlowDirection)e.NewValue) == FlowDirection.RightToLeft;
                fe.AreTransformsClean = false; 
            } 
        }
 
        /// 
        /// FlowDirection Property
        /// 
    [Localizability(LocalizationCategory.None)] 
        public FlowDirection FlowDirection
        { 
            get { return IsRightToLeft ? FlowDirection.RightToLeft : FlowDirection.LeftToRight; } 
            set { SetValue(FlowDirectionProperty, value); }
        } 

        /// 
        /// Queries the attached property FlowDirection from the given element.
        ///  
        /// 
        public static FlowDirection GetFlowDirection(DependencyObject element) 
        { 
            if (element == null) { throw new ArgumentNullException("element"); }
            return (FlowDirection)element.GetValue(FlowDirectionProperty); 
        }

        /// 
        /// Writes the attached property FlowDirection to the given element. 
        /// 
        ///  
        public static void SetFlowDirection(DependencyObject element, FlowDirection value) 
        {
            if (element == null) { throw new ArgumentNullException("element"); } 
            element.SetValue(FlowDirectionProperty, value);
        }

        ///  
        /// Validates the flow direction property values
        ///  
        private static bool IsValidFlowDirection(object o) 
        {
            FlowDirection value = (FlowDirection)o; 
            return value == FlowDirection.LeftToRight || value == FlowDirection.RightToLeft;
        }

        ///  
        /// MarginProperty
        ///  
        [CommonDependencyProperty] 
        public static readonly DependencyProperty MarginProperty
            = DependencyProperty.Register("Margin", typeof(Thickness), _typeofThis, 
                                          new FrameworkPropertyMetadata(
                                                new Thickness(),
                                                FrameworkPropertyMetadataOptions.AffectsMeasure),
                                          new ValidateValueCallback(IsMarginValid)); 

        private static bool IsMarginValid(object value) 
        { 
            Thickness m = (Thickness)value;
            return m.IsValid(true, false, true, false); 
        }


        ///  
        /// Margin Property
        ///  
        public Thickness Margin 
        {
            get { return (Thickness) GetValue(MarginProperty); } 
            set { SetValue(MarginProperty, value); }
        }

        // 
        //  Properties overrides are needed only to discourage usage in old layout.
        // 
 
        /// 
        /// HorizontalAlignment Dependency Property. 
        /// 
        [CommonDependencyProperty]
        public static readonly DependencyProperty HorizontalAlignmentProperty =
                    DependencyProperty.Register( 
                                "HorizontalAlignment",
                                typeof(HorizontalAlignment), 
                                _typeofThis, 
                                new FrameworkPropertyMetadata(
                                            HorizontalAlignment.Stretch, 
                                            FrameworkPropertyMetadataOptions.AffectsArrange),
                                new ValidateValueCallback(ValidateHorizontalAlignmentValue));

        internal static bool ValidateHorizontalAlignmentValue(object value) 
        {
            HorizontalAlignment ha = (HorizontalAlignment)value; 
            return (    ha == HorizontalAlignment.Left 
                    ||  ha == HorizontalAlignment.Center
                    ||  ha == HorizontalAlignment.Right 
                    ||  ha == HorizontalAlignment.Stretch   );
        }

        ///  
        /// HorizontalAlignment Property.
        ///  
        public HorizontalAlignment HorizontalAlignment 
        {
            get { return (HorizontalAlignment) GetValue(HorizontalAlignmentProperty); } 
            set { SetValue(HorizontalAlignmentProperty, value); }
        }

        ///  
        /// VerticalAlignment Dependency Property.
        ///  
        [CommonDependencyProperty] 
        public static readonly DependencyProperty VerticalAlignmentProperty =
                    DependencyProperty.Register( 
                                "VerticalAlignment",
                                typeof(VerticalAlignment),
                                _typeofThis,
                                new FrameworkPropertyMetadata( 
                                            VerticalAlignment.Stretch,
                                            FrameworkPropertyMetadataOptions.AffectsArrange), 
                                new ValidateValueCallback(ValidateVerticalAlignmentValue)); 

        internal static bool ValidateVerticalAlignmentValue(object value) 
        {
            VerticalAlignment va = (VerticalAlignment)value;
            return (    va == VerticalAlignment.Top
                    ||  va == VerticalAlignment.Center 
                    ||  va == VerticalAlignment.Bottom
                    ||  va == VerticalAlignment.Stretch); 
        } 

        ///  
        /// VerticalAlignment Property.
        /// 
        public VerticalAlignment VerticalAlignment
        { 
            get { return (VerticalAlignment) GetValue(VerticalAlignmentProperty); }
            set { SetValue(VerticalAlignmentProperty, value); } 
        } 

        // Need a special value here until bug 1016350 is fixed.  KeyboardNavigation 
        // treats this as the value to indicate that it should do a resource lookup
        // to find the "real" default value.
        private static Style _defaultFocusVisualStyle = null;
 
        internal static Style DefaultFocusVisualStyle
        { 
            get 
            {
                if (_defaultFocusVisualStyle == null) 
                {
                    Style defaultFocusVisualStyle = new Style();
                    defaultFocusVisualStyle.Seal();
                    _defaultFocusVisualStyle = defaultFocusVisualStyle; 
                }
 
                return _defaultFocusVisualStyle; 
            }
        } 

        /// 
        /// FocusVisualStyleProperty
        ///  
        public static readonly DependencyProperty FocusVisualStyleProperty =
                    DependencyProperty.Register( 
                                "FocusVisualStyle", 
                                typeof(Style),
                                _typeofThis, 
                                new FrameworkPropertyMetadata(DefaultFocusVisualStyle));


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

        ///  
        /// CursorProperty
        ///  
        public static readonly DependencyProperty CursorProperty = 
                    DependencyProperty.Register(
                                "Cursor", 
                                typeof(Cursor),
                                _typeofThis,
                                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) 
        {
            FrameworkElement fe = ((FrameworkElement)d);

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

        /// 
        ///     ForceCursorProperty
        ///  
        public static readonly DependencyProperty ForceCursorProperty =
                    DependencyProperty.Register( 
                                "ForceCursor", 
                                typeof(bool),
                                _typeofThis, 
                                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)
        { 
            FrameworkElement fe = ((FrameworkElement)d);

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

        private static void OnQueryCursorOverride(object sender, QueryCursorEventArgs e) 
        {
            FrameworkElement fe = (FrameworkElement) sender;

            // We respond to querying the cursor by specifying the cursor set 
            // as a property on this element.
            Cursor cursor = fe.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 || fe.ForceCursor) 
                { 
                    e.Cursor = cursor;
                    e.Handled = true; 
                }
            }
        }
 
        /// 
        /// Helper method determining if mirroring transform is needed for this element. 
        /// If the case mirroring transform is created and returned. 
        /// 
        ///  
        /// Depending of flow direction property value of this element and its framework element parent:
        /// returns either mirror transform instance or null.
        /// 
        private Transform GetFlowDirectionTransform() 
        {
            if (!BypassLayoutPolicies && ShouldApplyMirrorTransform(this)) //Window applies its own mirror 
            { 
                return new MatrixTransform(-1.0, 0.0, 0.0, 1.0, RenderSize.Width, 0.0);
            } 

            return null;
        }
 
        internal static bool ShouldApplyMirrorTransform(FrameworkElement fe)
        { 
            FlowDirection thisFlowDirection = fe.FlowDirection; 
            FlowDirection parentFlowDirection = FlowDirection.LeftToRight; // Assume LTR if no parent is found.
            // If the element is connected to visual tree, get FlowDirection 
            // from its visual parent.
            // If there is no visual parent, look for logical parent and if
            // it is a ContentElement get FlowDirection form it. ContentHosts
            // may not fully create their visual tree before Arrange process is done. 
            DependencyObject parentVisual = VisualTreeHelper.GetParent(fe);
            if (parentVisual != null) 
            { 
                parentFlowDirection = GetFlowDirectionFromVisual(parentVisual);
            } 
            else
            {
                FrameworkContentElement parentFCE;
                FrameworkElement parentFE; 
                bool hasParent = GetFrameworkParent(fe, out parentFE, out parentFCE);
                if (hasParent) 
                { 
                    if (parentFE != null && parentFE is IContentHost)
                    { 
                        parentFlowDirection = parentFE.FlowDirection;
                    }
                    else if (parentFCE != null)
                    { 
                        parentFlowDirection = (FlowDirection)parentFCE.GetValue(FlowDirectionProperty);
                    } 
                } 
            }
 
            //  if direction changes, instantiate a mirroring transform
            return ApplyMirrorTransform(parentFlowDirection, thisFlowDirection);
        }
 
        /// 
        /// Helper method to read and return flow direction property value for a given visual. 
        ///  
        /// Visual to get flow direction for.
        /// Flow direction property value. 
        private static FlowDirection GetFlowDirectionFromVisual(DependencyObject visual)
        {
            FlowDirection flowDirection = FlowDirection.LeftToRight;
 
            for (DependencyObject v = visual; v != null; v = VisualTreeHelper.GetParent(v))
            { 
                FrameworkElement fe = v as FrameworkElement; 
                if (fe != null)
                { 
                    flowDirection = fe.FlowDirection;
                    break;
                }
                else 
                {
                    // Try to get value from Visual. 
                    // ContentHost, when processing ContentElements with changing FlowDirection 
                    // property value, will create a Visual and set FlowDirectionProperty on it.
                    // For this reason need to take into account Visuals with local value set 
                    // for FlowDirectionProperty.
                    object flowDirectionValue = v.ReadLocalValue(FlowDirectionProperty);
                    if (flowDirectionValue != DependencyProperty.UnsetValue)
                    { 
                        flowDirection = (FlowDirection)flowDirectionValue;
                        break; 
                    } 
                }
            } 

            return (flowDirection);
        }
 
        /// 
        ///     This method indicates whether a new transform should be created for the effects of 
        ///     changing from LTR to RTL or RTL to LTR. 
        ///     This method is internal so that Popup can use the same logic.
        ///  
        /// The element that sits above where the transform would go.
        /// The element that sits below where the transform would go and is where a potentially new flow direction is desired.
        /// True if the transform is needed, false otherwise.
        internal static bool ApplyMirrorTransform(FlowDirection parentFD, FlowDirection thisFD) 
        {
            return ((parentFD == FlowDirection.LeftToRight && thisFD == FlowDirection.RightToLeft) || 
                    (parentFD == FlowDirection.RightToLeft && thisFD == FlowDirection.LeftToRight)); 
        }
 
        private struct MinMax
        {
            internal MinMax(FrameworkElement e)
            { 
                maxHeight = e.MaxHeight;
                minHeight = e.MinHeight; 
                double l  = e.Height; 

                double height = (DoubleUtil.IsNaN(l) ? Double.PositiveInfinity : l); 
                maxHeight = Math.Max(Math.Min(height, maxHeight), minHeight);

                height = (DoubleUtil.IsNaN(l) ? 0 : l);
                minHeight = Math.Max(Math.Min(maxHeight, height), minHeight); 

                maxWidth = e.MaxWidth; 
                minWidth = e.MinWidth; 
                l        = e.Width;
 
                double width = (DoubleUtil.IsNaN(l) ? Double.PositiveInfinity : l);
                maxWidth = Math.Max(Math.Min(width, maxWidth), minWidth);

                width = (DoubleUtil.IsNaN(l) ? 0 : l); 
                minWidth = Math.Max(Math.Min(maxWidth, width), minWidth);
            } 
 
            internal double minWidth;
            internal double maxWidth; 
            internal double minHeight;
            internal double maxHeight;
        }
 
        //  LayoutTransform property may be animated and its value change in time,
        //  LayoutTransformData is used to store a snapshot of LayoutTransform 
        //  property value to avoid layout / render inconsistencies caused by 
        //  animated LayoutTransforms...
        private class LayoutTransformData 
        {
            internal Size UntransformedDS;
            private  Transform  _transform;
 
            internal void CreateTransformSnapshot(Transform sourceTransform)
            { 
                Debug.Assert(sourceTransform != null); 
                _transform = new MatrixTransform(sourceTransform.Value);
                _transform.Freeze(); 
            }

            internal Transform Transform
            { 
                get
                { 
                    Debug.Assert(_transform != null); 
                    return (_transform);
                } 
            }
        }

        // Method FindMaximalAreaLocalSpaceRect - used only if LayoutTransform is specified 
        // Summary:
        //   Given the transform currently applied to child, this method finds (in 
        //     axis-aligned local space) the largest rectangle that, after transform, 
        //   fits within transformSpaceBounds.  Largest rectangle means rectangle
        //   of greatest area in local space (although maximal area in local space 
        //   implies maximal area in transform space).
        // Parameters:
        //   transformSpaceBounds: the bounds (in destination/transform space) that
        //   the 
        // Returns:
        //   The dimensions, in local space, of the maximal area rectangle found. 
        private Size FindMaximalAreaLocalSpaceRect(Transform layoutTransform, Size transformSpaceBounds) 
        {
            // X (width) and Y (height) constraints for axis-aligned bounding box in dest. space 
            Double xConstr = transformSpaceBounds.Width;
            Double yConstr = transformSpaceBounds.Height;

            //if either of the sizes is 0, return 0,0 to avoid doing math on an empty rect (bug 963569) 
            if(DoubleUtil.IsZero(xConstr) || DoubleUtil.IsZero(yConstr))
                return new Size(0,0); 
 
            bool xConstrInfinite = Double.IsInfinity(xConstr);
            bool yConstrInfinite = Double.IsInfinity(yConstr); 

            if (xConstrInfinite && yConstrInfinite)
            {
                return new Size(Double.PositiveInfinity, Double.PositiveInfinity); 
            }
            else if(xConstrInfinite) //assume square for one-dimensional constraint 
            { 
                xConstr = yConstr;
            } 
            else if (yConstrInfinite)
            {
                yConstr = xConstr;
            } 

 
            // Get parameters from transform matrix. 
            Matrix trMatrix = layoutTransform.Value;
 
            // We only deal with nonsingular matrices here. The nonsingular matrix is the one
            // that has inverse (determinant != 0).
            if(!trMatrix.HasInverse)
                return new Size(0,0); 

            Double a = trMatrix.M11; 
            Double b = trMatrix.M12; 
            Double c = trMatrix.M21;
            Double d = trMatrix.M22; 

            // Result width and height (in child/local space)
            Double w=0, h=0;
 
            // because we are dealing with nonsingular transform matrices,
            // we have (b==0 || c==0) XOR (a==0 || d==0) 
 
            if (DoubleUtil.IsZero(b) || DoubleUtil.IsZero(c))
            { 
                // (b==0 || c==0) ==> a!=0 && d!=0

                Double yCoverD = (yConstrInfinite ? Double.PositiveInfinity : Math.Abs(yConstr/d));
                Double xCoverA = (xConstrInfinite ? Double.PositiveInfinity : Math.Abs(xConstr/a)); 

                if (DoubleUtil.IsZero(b)) 
                { 
                    if (DoubleUtil.IsZero(c))
                    { 
                        // Case: b=0, c=0, a!=0, d!=0

                        // No constraint relation; use maximal width and height
 
                        h = yCoverD;
                        w = xCoverA; 
                    } 
                    else
                    { 
                        // Case: b==0, a!=0, c!=0, d!=0

                        // Maximizing under line (hIntercept=xConstr/c, wIntercept=xConstr/a)
                        // BUT we still have constraint: h <= yConstr/d 

                        h = Math.Min(0.5*Math.Abs(xConstr/c), yCoverD); 
                        w = xCoverA - ((c * h) / a); 
                    }
                } 
                else
                {
                    // Case: c==0, a!=0, b!=0, d!=0
 
                    // Maximizing under line (hIntercept=yConstr/d, wIntercept=yConstr/b)
                    // BUT we still have constraint: w <= xConstr/a 
 
                    w = Math.Min( 0.5*Math.Abs(yConstr/b), xCoverA);
                    h = yCoverD - ((b * w) / d); 
                }
            }
            else if (DoubleUtil.IsZero(a) || DoubleUtil.IsZero(d))
            { 
                // (a==0 || d==0) ==> b!=0 && c!=0
 
                Double yCoverB = Math.Abs(yConstr/b); 
                Double xCoverC = Math.Abs(xConstr/c);
 
                if (DoubleUtil.IsZero(a))
                {
                    if (DoubleUtil.IsZero(d))
                    { 
                        // Case: a=0, d=0, b!=0, c!=0
 
                        // No constraint relation; use maximal width and height 

                        h = xCoverC; 
                        w = yCoverB;
                    }
                    else
                    { 
                        // Case: a==0, b!=0, c!=0, d!=0
 
                        // Maximizing under line (hIntercept=yConstr/d, wIntercept=yConstr/b) 
                        // BUT we still have constraint: h <= xConstr/c
 
                        h = Math.Min(0.5*Math.Abs(yConstr/d), xCoverC);
                        w = yCoverB - ((d * h) / b);
                    }
                } 
                else
                { 
                    // Case: d==0, a!=0, b!=0, c!=0 

                    // Maximizing under line (hIntercept=xConstr/c, wIntercept=xConstr/a) 
                    // BUT we still have constraint: w <= yConstr/b

                    w = Math.Min( 0.5*Math.Abs(xConstr/a), yCoverB);
                    h = xCoverC - ((a * w) / c); 
                }
            } 
            else 
            {
                Double xCoverA = Math.Abs(xConstr / a);        // w-intercept of x-constraint line. 
                Double xCoverC = Math.Abs(xConstr / c);        // h-intercept of x-constraint line.

                Double yCoverB = Math.Abs(yConstr / b);        // w-intercept of y-constraint line.
                Double yCoverD = Math.Abs(yConstr / d);        // h-intercept of y-constraint line. 

                // The tighest constraint governs, so we pick the lowest constraint line. 
                // 
                //   The optimal point (w,h) for which Area = w*h is maximized occurs halfway
                //   to each intercept. 

                w = Math.Min(yCoverB, xCoverA) * 0.5;
                h = Math.Min(xCoverC, yCoverD) * 0.5;
 
                if ( (DoubleUtil.GreaterThanOrClose(xCoverA, yCoverB) &&
                    DoubleUtil.LessThanOrClose(xCoverC, yCoverD)) || 
                    (DoubleUtil.LessThanOrClose(xCoverA, yCoverB) && 
                    DoubleUtil.GreaterThanOrClose(xCoverC, yCoverD))  )
                { 
                    // Constraint lines cross; since the most restrictive constraint wins,
                    // we have to maximize under two line segments, which together are discontinuous.
                    // Instead, we maximize w*h under the line segment from the two smallest endpoints.
 
                    // Since we are not (except for in corner cases) on the original constraint lines,
                    // we are not using up all the available area in transform space.  So scale our shape up 
                    // until it does in at least one dimension. 

                    Rect childBoundsTr = Rect.Transform(new Rect(0, 0, w, h), 
                                                        layoutTransform.Value);
                    Double expandFactor = Math.Min(xConstr / childBoundsTr.Width,
                                                   yConstr / childBoundsTr.Height);
                    if(    !Double.IsNaN(expandFactor) 
                        && !Double.IsInfinity(expandFactor))
                    { 
                        w *= expandFactor; 
                        h *= expandFactor;
                    } 
                }
            }

            return new Size(w,h); 
        }
 
        ///  
        /// Override for .
        ///  
        protected sealed override Size MeasureCore(Size availableSize)
        {
            Debug.Assert(MeasureData == null || availableSize == MeasureData.AvailableSize, "MeasureData needs to be passed down in [....] with size");
 
            //build the visual tree from styles first
            ApplyTemplate(); 
 
            if (BypassLayoutPolicies)
            { 
                return MeasureOverride(availableSize);
            }
            else
            { 
                Thickness margin = Margin;
                double marginWidth = margin.Left + margin.Right; 
                double marginHeight = margin.Top + margin.Bottom; 
                MeasureData measureData = MeasureData;
 
                //  parent size is what parent want us to be
                Size frameworkAvailableSize = new Size(
                Math.Max(availableSize.Width - marginWidth, 0),
                Math.Max(availableSize.Height - marginHeight, 0)); 

                MinMax mm = new MinMax(this); 
 
                LayoutTransformData ltd = LayoutTransformDataField.GetValue(this);
                { 
                    Transform layoutTransform = this.LayoutTransform;
                    //  check that LayoutTransform is non-trivial
                    if (layoutTransform != null && !layoutTransform.IsIdentity)
                    { 
                        if (ltd == null)
                        { 
                            //  allocate and store ltd if needed 
                            ltd = new LayoutTransformData();
                            LayoutTransformDataField.SetValue(this, ltd); 
                        }

                        ltd.CreateTransformSnapshot(layoutTransform);
                        ltd.UntransformedDS = new Size(); 
                    }
                    else if (ltd != null) 
                    { 
                        //  clear ltd storage
                        ltd = null; 
                        LayoutTransformDataField.ClearValue(this);
                    }
                }
 
                if(ltd != null)
                { 
                    // Find the maximal area rectangle in local (child) space that we can fit, post-transform 
                    // in the decorator's measure constraint.
                    frameworkAvailableSize = FindMaximalAreaLocalSpaceRect(ltd.Transform, frameworkAvailableSize); 
                }

                frameworkAvailableSize.Width  = Math.Max(mm.minWidth,  Math.Min(frameworkAvailableSize.Width, mm.maxWidth));
                frameworkAvailableSize.Height = Math.Max(mm.minHeight, Math.Min(frameworkAvailableSize.Height, mm.maxHeight)); 

                //  call to specific layout to measure 
                if (measureData != null) 
                {
                    measureData.AvailableSize = frameworkAvailableSize; 
                }
                Size desiredSize = MeasureOverride(frameworkAvailableSize);

                if (measureData != null) 
                {
                    // MeasureData should be treated like a parameter to Measure and thus not modified when returning from this call. 
                    measureData.AvailableSize = availableSize; 
                }
 
                //  maximize desiredSize with user provided min size
                desiredSize = new Size(
                    Math.Max(desiredSize.Width, mm.minWidth),
                    Math.Max(desiredSize.Height, mm.minHeight)); 

                //here is the "true minimum" desired size - the one that is 
                //for sure enough for the control to render its content. 
                Size unclippedDesiredSize = desiredSize;
 
                if (ltd != null)
                {
                    //need to store unclipped, untransformed desired size to be able to arrange later
                    ltd.UntransformedDS = unclippedDesiredSize; 

                    //transform unclipped desired size 
                    Rect unclippedBoundsTransformed = Rect.Transform(new Rect(0, 0, unclippedDesiredSize.Width, unclippedDesiredSize.Height), ltd.Transform.Value); 
                    unclippedDesiredSize.Width = unclippedBoundsTransformed.Width;
                    unclippedDesiredSize.Height = unclippedBoundsTransformed.Height; 
                }

                bool clipped = false;
 
                // User-specified max size starts to "clip" the control here.
                //Starting from this point desiredSize could be smaller then actually 
                //needed to render the whole control 
                if(desiredSize.Width > mm.maxWidth)
                { 
                    desiredSize.Width = mm.maxWidth;
                    clipped = true;
                }
 
                if(desiredSize.Height > mm.maxHeight)
                { 
                    desiredSize.Height = mm.maxHeight; 
                    clipped = true;
                } 

                //transform desired size to layout slot space
                if (ltd != null)
                { 
                    Rect childBoundsTransformed = Rect.Transform(new Rect(0, 0, desiredSize.Width, desiredSize.Height), ltd.Transform.Value);
                    desiredSize.Width = childBoundsTransformed.Width; 
                    desiredSize.Height = childBoundsTransformed.Height; 
                }
 
                //  because of negative margins, clipped desired size may be negative.
                //  need to keep it as doubles for that reason and maximize with 0 at the
                //  very last point - before returning desired size to the parent.
                double clippedDesiredWidth = desiredSize.Width + marginWidth; 
                double clippedDesiredHeight = desiredSize.Height + marginHeight;
 
                // In overconstrained scenario, parent wins and measured size of the child, 
                // including any sizes set or computed, can not be larger then
                // available size. We will clip the guy later. 
                if (clippedDesiredWidth > availableSize.Width)
                {
                    clippedDesiredWidth = availableSize.Width;
                    clipped = true; 
                }
 
                if (clippedDesiredHeight > availableSize.Height) 
                {
                    clippedDesiredHeight = availableSize.Height; 
                    clipped = true;
                }

                //  Note: unclippedDesiredSize is needed in ArrangeCore, 
                //  because due to the layout protocol, arrange should be called
                //  with constraints greater or equal to child's desired size 
                //  returned from MeasureOverride. But in most circumstances 
                //  it is possible to reconstruct original unclipped desired size.
                //  In such cases we want to optimize space and save 16 bytes by 
                //  not storing it on each FrameworkElement.
                //
                //  The if statement conditions below lists the cases when
                //  it is NOT possible to recalculate unclipped desired size later 
                //  in ArrangeCore, thus we save it into Uncommon Fields...
                // 
                //  Note 2: use SizeBox to avoid CLR boxing of Size. 
                //  measurements show it is better to allocate an object once than
                //  have spurious boxing allocations on every resize 
                SizeBox sb = UnclippedDesiredSizeField.GetValue(this);
                if (    clipped
                    ||  clippedDesiredWidth < 0
                    ||  clippedDesiredHeight < 0    ) 
                {
                    if (sb == null) //not yet allocated, allocate the box 
                    { 
                        sb = new SizeBox(unclippedDesiredSize);
                        UnclippedDesiredSizeField.SetValue(this, sb); 
                    }
                    else //we already have allocated size box, simply change it
                    {
                        sb.Width = unclippedDesiredSize.Width; 
                        sb.Height = unclippedDesiredSize.Height;
                    } 
                } 
                else
                { 
                    if (sb != null)
                        UnclippedDesiredSizeField.ClearValue(this);
                }
 
                return new Size(Math.Max(0, clippedDesiredWidth), Math.Max(0, clippedDesiredHeight));
            } 
        } 

        ///  
        /// Override for .
        /// 
        protected sealed override void ArrangeCore(Rect finalRect)
        { 
            if (BypassLayoutPolicies)
            { 
                Size oldRenderSize = RenderSize; 
                Size inkSize = ArrangeOverride(finalRect.Size);
                RenderSize = inkSize; 
                SetLayoutOffset(new Vector(finalRect.X, finalRect.Y), oldRenderSize);
            }
            else
            { 
                // If LayoutConstrained==true (parent wins in layout),
                // we might get finalRect.Size smaller then UnclippedDesiredSize. 
                // Stricltly speaking, this may be the case even if LayoutConstrained==false (child wins), 
                // since who knows what a particualr parent panel will try to do in error.
                // In this case we will not actually arrange a child at a smaller size, 
                // since the logic of the child does not expect to receive smaller size
                // (if it coudl deal with smaller size, it probably would accept it in MeasureOverride)
                // so lets replace the smaller arreange size with UnclippedDesiredSize
                // and then clip the guy later. 
                // We will use at least UnclippedDesiredSize to compute arrangeSize of the child, and
                // we will use layoutSlotSize to compute alignments - so the bigger child can be aligned within 
                // smaller slot. 

                // This is computed on every ArrangeCore. Depending on LayoutConstrained, actual clip may apply or not 
                NeedsClipBounds = false;

                // Start to compute arrange size for the child.
                // It starts from layout slot or deisred size if layout slot is smaller then desired, 
                // and then we reduce it by margins, apply Width/Height etc, to arrive at the size
                // that child will get in its ArrangeOverride. 
                Size arrangeSize = finalRect.Size; 

                Thickness margin = Margin; 
                double marginWidth = margin.Left + margin.Right;
                double marginHeight = margin.Top + margin.Bottom;

                arrangeSize.Width = Math.Max(0, arrangeSize.Width - marginWidth); 
                arrangeSize.Height = Math.Max(0, arrangeSize.Height - marginHeight);
 
                SizeBox sb = UnclippedDesiredSizeField.GetValue(this); 
                Size unclippedDesiredSize;
                if(sb == null) 
                {
                    unclippedDesiredSize = new Size(this.DesiredSize.Width - marginWidth,
                                                    this.DesiredSize.Height - marginHeight);
                } 
                else
                { 
                    unclippedDesiredSize = new Size(sb.Width, sb.Height); 
                }
 
                if (DoubleUtil.LessThan(arrangeSize.Width, unclippedDesiredSize.Width))
                {
                    NeedsClipBounds = true;
                    arrangeSize.Width = unclippedDesiredSize.Width; 
                }
 
                if (DoubleUtil.LessThan(arrangeSize.Height, unclippedDesiredSize.Height)) 
                {
                    NeedsClipBounds = true; 
                    arrangeSize.Height = unclippedDesiredSize.Height;
                }

                // Alignment==Stretch --> arrange at the slot size minus margins 
                // Alignment!=Stretch --> arrange at the unclippedDesiredSize
                if (HorizontalAlignment != HorizontalAlignment.Stretch) 
                { 
                    arrangeSize.Width = unclippedDesiredSize.Width;
                } 

                if (VerticalAlignment != VerticalAlignment.Stretch)
                {
                    arrangeSize.Height = unclippedDesiredSize.Height; 
                }
 
                //if LayoutTransform is set, arrange at untransformed DS always 
                //alignments apply to the BoundingBox after transform
                LayoutTransformData ltd = LayoutTransformDataField.GetValue(this); 
                if(ltd != null)
                {
                    // Repeat the measure-time algorithm for finding a best fit local rect.
                    // This essentially implements Stretch in case of LayoutTransform 
                    Size potentialArrangeSize = FindMaximalAreaLocalSpaceRect(ltd.Transform, arrangeSize);
                    arrangeSize = potentialArrangeSize; 
 
                    unclippedDesiredSize = ltd.UntransformedDS;
 
                    //only use max area rect if both dimensions of it are larger then
                    //desired size - replace with desired size otherwise
                    if(    !DoubleUtil.IsZero(potentialArrangeSize.Width)
                        && !DoubleUtil.IsZero(potentialArrangeSize.Height)) 
                    {
                        //Use less precise comparision - otherwise FP jitter may cause drastic jumps here 
                        if(   LayoutDoubleUtil.LessThan(potentialArrangeSize.Width, unclippedDesiredSize.Width) 
                           || LayoutDoubleUtil.LessThan(potentialArrangeSize.Height, unclippedDesiredSize.Height))
                        { 
                            arrangeSize = unclippedDesiredSize;
                        }
                    }
 
                    //if pre-transformed into local space arrangeSize is smaller in any dimension then
                    //unclipped local DesiredSize of the element, extend the arrangeSize but 
                    //remember that we potentially need to clip the result of such arrange. 
                    if(DoubleUtil.LessThan(arrangeSize.Width,  unclippedDesiredSize.Width))
                    { 
                        NeedsClipBounds = true;
                        arrangeSize.Width = unclippedDesiredSize.Width;
                    }
 
                    if(DoubleUtil.LessThan(arrangeSize.Height, unclippedDesiredSize.Height))
                    { 
                        NeedsClipBounds = true; 
                        arrangeSize.Height = unclippedDesiredSize.Height;
                    } 

                }

                MinMax mm = new MinMax(this); 

                //we have to choose max between UnclippedDesiredSize and Max here, because 
                //otherwise setting of max property could cause arrange at less then unclippedDS. 
                //Clipping by Max is needed to limit stretch here
                double effectiveMaxWidth = Math.Max(unclippedDesiredSize.Width, mm.maxWidth); 
                if (DoubleUtil.LessThan(effectiveMaxWidth, arrangeSize.Width))
                {
                    NeedsClipBounds = true;
                    arrangeSize.Width = effectiveMaxWidth; 
                }
 
                double effectiveMaxHeight = Math.Max(unclippedDesiredSize.Height, mm.maxHeight); 
                if (DoubleUtil.LessThan(effectiveMaxHeight, arrangeSize.Height))
                { 
                    NeedsClipBounds = true;
                    arrangeSize.Height = effectiveMaxHeight;
                }
 
                Size oldRenderSize = RenderSize;
                Size innerInkSize = ArrangeOverride(arrangeSize); 
 
                //Here we use un-clipped InkSize because element does not know that it is
                //clipped by layout system and it shoudl have as much space to render as 
                //it returned from its own ArrangeOverride
                RenderSize = innerInkSize;

                //clippedInkSize differs from InkSize only what MaxWidth/Height explicitly clip the 
                //otherwise good arrangement. For ex, DSMaxWidth - in this
                //case we should initiate clip at MaxWidth and only show Top-Left portion 
                //of the element limited by Max properties. It is Top-left because in case when we 
                //are clipped by container we also degrade to Top-Left, so we are consistent.
                Size clippedInkSize = new Size(Math.Min(innerInkSize.Width, mm.maxWidth), 
                                               Math.Min(innerInkSize.Height, mm.maxHeight));

                //remember we have to clip if Max properties limit the inkSize
                NeedsClipBounds |= 
                        DoubleUtil.LessThan(clippedInkSize.Width, innerInkSize.Width)
                    ||  DoubleUtil.LessThan(clippedInkSize.Height, innerInkSize.Height); 
 
                //if LayoutTransform is set, get the "outer bounds" - the alignments etc work on them
                if(ltd != null) 
                {
                    Rect inkRectTransformed = Rect.Transform(new Rect(0, 0, clippedInkSize.Width, clippedInkSize.Height), ltd.Transform.Value);
                    clippedInkSize.Width = inkRectTransformed.Width;
                    clippedInkSize.Height = inkRectTransformed.Height; 
                }
 
                //Note that inkSize now can be bigger then layoutSlotSize-margin (because of layout 
                //squeeze by the parent or LayoutConstrained=true, which clips desired size in Measure).
 
                // The client size is the size of layout slot decreased by margins.
                // This is the "window" through which we see the content of the child.
                // Alignments position ink of the child in this "window".
                // Max with 0 is neccessary because layout slot may be smaller then unclipped desired size. 
                Size clientSize = new Size(Math.Max(0, finalRect.Width - marginWidth),
                                        Math.Max(0, finalRect.Height - marginHeight)); 
 

                //remember we have to clip if clientSize limits the inkSize 
                NeedsClipBounds |=
                        DoubleUtil.LessThan(clientSize.Width, clippedInkSize.Width)
                    ||  DoubleUtil.LessThan(clientSize.Height, clippedInkSize.Height);
 
                Vector offset = ComputeAlignmentOffset(clientSize, clippedInkSize);
 
                offset.X += finalRect.X + margin.Left; 
                offset.Y += finalRect.Y + margin.Top;
 
                SetLayoutOffset(offset, oldRenderSize);
            }
        }
 
        /// 
        /// Override for  
        ///  
        protected internal override void OnRenderSizeChanged(SizeChangedInfo sizeInfo)
        { 
            SizeChangedEventArgs localArgs = new SizeChangedEventArgs(this, sizeInfo);
            localArgs.RoutedEvent = SizeChangedEvent;

            //first, invalidate ActualWidth and/or ActualHeight 
            //Note: if any handler of invalidation will dirtyfy layout,
            //subsequent handlers will run on effectively dirty layouts 
            //we only guarantee cleaning between elements, not between handlers here 
            if(sizeInfo.WidthChanged)
            { 
                HasWidthEverChanged = true;
                NotifyPropertyChange(new DependencyPropertyChangedEventArgs(ActualWidthProperty, _actualWidthMetadata, sizeInfo.PreviousSize.Width, sizeInfo.NewSize.Width));
            }
 
            if(sizeInfo.HeightChanged)
            { 
                HasHeightEverChanged = true; 
                NotifyPropertyChange(new DependencyPropertyChangedEventArgs(ActualHeightProperty, _actualHeightMetadata, sizeInfo.PreviousSize.Height, sizeInfo.NewSize.Height));
            } 

            RaiseEvent(localArgs);
        }
 
        private Vector ComputeAlignmentOffset(Size clientSize, Size inkSize)
        { 
            Vector offset = new Vector(); 

            HorizontalAlignment ha = HorizontalAlignment; 
            VerticalAlignment va = VerticalAlignment;

            //this is to degenerate Stretch to Top-Left in case when clipping is about to occur
            //if we need it to be Center instead, simply remove these 2 ifs 
            if(    ha == HorizontalAlignment.Stretch
                && inkSize.Width > clientSize.Width) 
            { 
                ha = HorizontalAlignment.Left;
            } 

            if(    va == VerticalAlignment.Stretch
                && inkSize.Height > clientSize.Height)
            { 
                va = VerticalAlignment.Top;
            } 
            //end of degeneration of Stretch to Top-Left 

            if (    ha == HorizontalAlignment.Center 
                ||  ha == HorizontalAlignment.Stretch  )
            {
                offset.X = (clientSize.Width - inkSize.Width) * 0.5;
            } 
            else if (ha == HorizontalAlignment.Right)
            { 
                offset.X = clientSize.Width - inkSize.Width; 
            }
            else 
            {
                offset.X = 0;
            }
 
            if (    va == VerticalAlignment.Center
                ||  va == VerticalAlignment.Stretch  ) 
            { 
                offset.Y = (clientSize.Height - inkSize.Height) * 0.5;
            } 
            else if (va == VerticalAlignment.Bottom)
            {
                offset.Y = clientSize.Height - inkSize.Height;
            } 
            else
            { 
                offset.Y = 0; 
            }
 
            return offset;
        }

        ///  
        /// Override of .
        ///  
        /// Geometry to use as additional clip in case when element is larger then available space 
        protected override Geometry GetLayoutClip(Size layoutSlotSize)
        { 
            if (NeedsClipBounds || ClipToBounds)
            {
                // see if  MaxWidth/MaxHeight limit the element
                MinMax mm = new MinMax(this); 

                //this is in element's local rendering coord system 
                Size inkSize = this.RenderSize; 

                double maxWidthClip = ( Double.IsPositiveInfinity(mm.maxWidth) ? inkSize.Width : mm.maxWidth); 
                double maxHeightClip = ( Double.IsPositiveInfinity(mm.maxHeight) ? inkSize.Height : mm.maxHeight);

                //need to clip because the computed sizes exceed MaxWidth/MaxHeight/Width/Height
                bool needToClipLocally = 
                     ClipToBounds //need to clip at bounds even if inkSize is less then maxSize
                  || (DoubleUtil.LessThan(maxWidthClip, inkSize.Width) 
                  ||  DoubleUtil.LessThan(maxHeightClip, inkSize.Height)); 

                //now lets say we already clipped by MaxWidth/MaxHeight, lets see if further clipping is needed 
                inkSize.Width = Math.Min(inkSize.Width, mm.maxWidth);
                inkSize.Height = Math.Min(inkSize.Height, mm.maxHeight);

                //if LayoutTransform is set, convert RenderSize to "outer bounds" 
                LayoutTransformData ltd = LayoutTransformDataField.GetValue(this);
                Rect inkRectTransformed = new Rect(); 
                if(ltd != null) 
                {
                    inkRectTransformed = Rect.Transform(new Rect(0, 0, inkSize.Width, inkSize.Height), ltd.Transform.Value); 
                    inkSize.Width = inkRectTransformed.Width;
                    inkSize.Height = inkRectTransformed.Height;
                }
 
                //now see if layout slot should clip the element
                Thickness margin = Margin; 
                double marginWidth = margin.Left + margin.Right; 
                double marginHeight = margin.Top + margin.Bottom;
 
                Size clippingSize = new Size(Math.Max(0, layoutSlotSize.Width  - marginWidth),
                                             Math.Max(0, layoutSlotSize.Height - marginHeight));

                bool needToClipSlot = ( 
                     ClipToBounds //forces clip at layout slot bounds even if reported sizes are ok
                  || DoubleUtil.LessThan(clippingSize.Width, inkSize.Width) 
                  || DoubleUtil.LessThan(clippingSize.Height, inkSize.Height)); 

                Transform rtlMirror = GetFlowDirectionTransform(); 

                if(needToClipLocally && !needToClipSlot)
                {
                    RectangleGeometry localClip = new RectangleGeometry(new Rect(0, 0, maxWidthClip, maxHeightClip)); 
                    if(rtlMirror != null) localClip.Transform = rtlMirror;
                    return localClip; 
                } 

                if(needToClipSlot) 
                {
                    Vector offset = ComputeAlignmentOffset(clippingSize, inkSize);

                    if(ltd != null) 
                    {
                        RectangleGeometry slotClip = new RectangleGeometry(new Rect( 
                                                                                -offset.X + inkRectTransformed.X, 
                                                                                -offset.Y + inkRectTransformed.Y,
                                                                                clippingSize.Width, 
                                                                                clippingSize.Height));
                        Matrix m = ltd.Transform.Value;
                        if(m.HasInverse)
                        { 
                            m.Invert();
                            slotClip.Transform = new MatrixTransform(m); 
                        } 

                        if(needToClipLocally) 
                        {
                            RectangleGeometry localClip = new RectangleGeometry(new Rect(0, 0, maxWidthClip, maxHeightClip));
                            PathGeometry combinedClip = Geometry.Combine(localClip, slotClip, GeometryCombineMode.Intersect, null);
                            if(rtlMirror != null) combinedClip.Transform = rtlMirror; 
                            return combinedClip;
                        } 
                        else 
                        {
                            if(rtlMirror != null) 
                            {
                                if(slotClip.Transform != null)
                                    slotClip.Transform = new MatrixTransform(slotClip.Transform.Value * rtlMirror.Value);
                                else 
                                    slotClip.Transform = rtlMirror;
                            } 
                            return slotClip; 
                        }
                    } 
                    else //no layout transform, intersect axis-aligned rects
                    {
                        Rect slotRect = new Rect(-offset.X, -offset.Y, clippingSize.Width, clippingSize.Height);
 
                        if(needToClipLocally) //intersect 2 rects
                        { 
                            Rect localRect = new Rect(0, 0, maxWidthClip, maxHeightClip); 
                            slotRect.Intersect(localRect);
                        } 

                        RectangleGeometry combinedClip = new RectangleGeometry(slotRect);
                        if(rtlMirror != null) combinedClip.Transform = rtlMirror;
                        return combinedClip; 
                    }
                } 
 
                return null;
            } 
            return base.GetLayoutClip(layoutSlotSize);
        }

        // see LayoutInformation 
        internal Geometry GetLayoutClipInternal()
        { 
            if(IsMeasureValid && IsArrangeValid) 
                return GetLayoutClip(PreviousArrangeRect.Size);
            else 
                return null;
        }

        ///  
        /// Measurement override. Implement your size-to-content logic here.
        ///  
        ///  
        /// MeasureOverride is designed to be the main customizability point for size control of layout.
        /// Element authors should override this method, call Measure on each child element, 
        /// and compute their desired size based upon the measurement of the children.
        /// The return value should be the desired size.
        /// Note: It is required that a parent element calls Measure on each child or they won't be sized/arranged.
        /// Typical override follows a pattern roughly like this (pseudo-code): 
        /// 
        ///      
        /// 
        ///     
        ///  
        /// The key aspects of this snippet are:
        ///      
        /// You must call Measure on each child element 
        /// It is common to cache measurement information between the MeasureOverride and ArrangeOverride method calls
        /// Calling base.MeasureOverride is not required. 
        /// Calls to Measure on children are passing either the same availableSize as the parent, or a subset of the area depending
        /// on the type of layout the parent will perform (for example, it would be valid to remove the area
        /// for some border or padding).
        ///      
        /// 
        /// Available size that parent can give to the child. May be infinity (when parent wants to 
        /// measure to content). This is soft constraint. Child can return bigger size to indicate that it wants bigger space and hope 
        /// that parent can throw in scrolling...
        /// Desired Size of the control, given available size passed as parameter. 
        protected virtual Size MeasureOverride(Size availableSize)
        {
            return new Size(0,0);
        } 

        ///  
        /// ArrangeOverride allows for the customization of the positioning of children. 
        /// 
        ///  
        /// Element authors should override this method, call Arrange on each visible child element,
        /// passing final size for each child element via finalSize parameter.
        /// Note: It is required that a parent element calls Arrange on each child or they won't be rendered.
        /// Typical override follows a pattern roughly like this (pseudo-code): 
        /// 
        ///      
        ///  
        ///     
        /// 
        /// 
        /// The final size that element should use to arrange itself and its children. 
        /// The size that element actually is going to use for rendering. If this size is not the same as finalSize
        /// input parameter, the AlignmentX/AlignmentY properties will position the ink rect of the element 
        /// appropriately. 
        protected virtual Size ArrangeOverride(Size finalSize)
        { 
            return finalSize;
        }

        ///  
        /// NOTE: THIS METHOD IS ONLY FOR INTERNAL SPECIFIC USE. It does not support some features of FrameworkElement,
        /// for example RenderTarnsfromOrigin and LayoutTransform. 
        /// 
        /// This is the method layout parent uses to set a location of the child
        /// relative to parent's visual as a result of layout. Typically, this is called 
        /// by the parent inside of its ArrangeOverride implementation. The transform passed into
        /// this method does not get combined with offset that is set by SetLayoutOffset, but rahter resets
        /// LayoutOffset to (0,0). Typically, layout parents use offset most of the time and only need to use this method instead if they need to introduce
        /// a non-trivial transform (including rotation or scale) between them and a layout child. 
        /// DO NOT name this SetLayoutTransform()!  The Xaml Compile may be fooled into thinking LayoutTransform is an attached property.
        ///  
        /// The element on which to set a transform. 
        /// The final transform of this element relative to its parent's visual.
        internal static void InternalSetLayoutTransform(UIElement element, Transform layoutTransform) 
        {
            FrameworkElement fe = element as FrameworkElement;
            element.InternalSetOffsetWorkaround(new Vector());
 
            Transform additionalTransform = (fe == null ? null : fe.GetFlowDirectionTransform()); //rtl
 
            Transform renderTransform = element.RenderTransform; 
            if(renderTransform == Transform.Identity)
                renderTransform = null; 

            // Create a TransformCollection and make sure it does not participate
            // in the InheritanceContext treeness because it is internal operation only.
            TransformCollection ts = new TransformCollection(); 
            ts.CanBeInheritanceContext = false;
 
            if(additionalTransform != null) 
                ts.Add(additionalTransform);
 
            if(renderTransform != null)
                ts.Add(renderTransform);

            ts.Add(layoutTransform); 

            TransformGroup group = new TransformGroup(); 
            group.Children = ts; 

            element.InternalSetTransformWorkaround(group); 
        }

        /// 
        /// This is the method layout parent uses to set a location of the child 
        /// relative to parent's visual as a result of layout. Typically, this is called
        /// by the parent inside of its ArrangeOverride implementation after calling Arrange on a child. 
        /// Note that this method resets layout tarnsform set by  method, 
        /// so only one of these two should be used by the parent.
        ///  
        private void SetLayoutOffset(Vector offset, Size oldRenderSize)
        {
            //
            // Attempt to avoid changing the transform more often than needed, 
            // such as when a parent is arrange dirty but its children aren't.
            // 
            // The dependencies for VisualTransform are as follows: 
            //     Mirror
            //         RenderSize.Width 
            //         FlowDirection
            //         parent.FlowDirection
            //     RenderTransform
            //         RenderTransformOrigin 
            //     LayoutTransform
            //         RenderSize 
            //         Width, MinWidth, MaxWidth 
            //         Height, MinHeight, MaxHeight
            // 
            // The AreTransformsClean flag will be false (dirty) when FlowDirection,
            // RenderTransform, LayoutTransform, Min/Max/Width/Height, or
            // RenderTransformOrigin changes.
            // 
            // RenderSize is compared here with the previous size to see if it changed.
            // 
            if (!AreTransformsClean || !DoubleUtil.AreClose(RenderSize, oldRenderSize)) 
            {
                Transform additionalTransform = GetFlowDirectionTransform(); //rtl 

                Transform renderTransform = this.RenderTransform;
                if(renderTransform == Transform.Identity) renderTransform = null;
 
                LayoutTransformData ltd = LayoutTransformDataField.GetValue(this);
 
                TransformGroup t = null; 

                //arbitrary transform, create a collection 
                if (additionalTransform != null
                    || renderTransform != null
                    || ltd != null)
                { 
                    // Create a TransformGroup and make sure it does not participate
                    // in the InheritanceContext treeness because it is internal operation only. 
                    t = new TransformGroup(); 
                    t.CanBeInheritanceContext = false;
                    t.Children.CanBeInheritanceContext = false; 

                    if (additionalTransform != null)
                        t.Children.Add(additionalTransform);
 
                    if(ltd != null)
                    { 
                        t.Children.Add(ltd.Transform); 

                        // see if  MaxWidth/MaxHeight limit the element 
                        MinMax mm = new MinMax(this);

                        //this is in element's local rendering coord system
                        Size inkSize = this.RenderSize; 

                        double maxWidthClip = (Double.IsPositiveInfinity(mm.maxWidth) ? inkSize.Width : mm.maxWidth); 
                        double maxHeightClip = (Double.IsPositiveInfinity(mm.maxHeight) ? inkSize.Height : mm.maxHeight); 

                        //get the size clipped by the MaxWidth/MaxHeight/Width/Height 
                        inkSize.Width = Math.Min(inkSize.Width, mm.maxWidth);
                        inkSize.Height = Math.Min(inkSize.Height, mm.maxHeight);

                        Rect inkRectTransformed = Rect.Transform(new Rect(inkSize), ltd.Transform.Value); 

                        t.Children.Add(new TranslateTransform(-inkRectTransformed.X, -inkRectTransformed.Y)); 
                    } 

                    if (renderTransform != null) 
                    {
                        Point origin = GetRenderTransformOrigin();
                        bool hasOrigin = (origin.X != 0d || origin.Y != 0d);
                        if (hasOrigin) 
                        {
                            TranslateTransform backOrigin = new TranslateTransform(-origin.X, -origin.Y); 
                            backOrigin.Freeze(); 
                            t.Children.Add(backOrigin);
                        } 

                        //can not freeze render transform - it can be animated
                        t.Children.Add(renderTransform);
 
                        if (hasOrigin)
                        { 
                            TranslateTransform forwardOrigin = new TranslateTransform(origin.X, origin.Y); 
                            forwardOrigin.Freeze();
                            t.Children.Add(forwardOrigin); 
                        }

                    }
                } 

                this.VisualTransform = t; 
                AreTransformsClean = true; 
            }
 
            Vector oldOffset = this.VisualOffset;
            if(!DoubleUtil.AreClose(oldOffset.X, offset.X) ||
               !DoubleUtil.AreClose(oldOffset.Y, offset.Y))
            { 
                this.VisualOffset = offset;
            } 
        } 

        private Point GetRenderTransformOrigin() 
        {
            Point relativeOrigin = this.RenderTransformOrigin;
            //important: this depends on a fact that RenderSize was already set by ArrangeCore *before* calling
            //SetLayoutOffset/GetRenderTransformOrigin sequence. 
            Size renderSize = this.RenderSize;
 
            return new Point(renderSize.Width * relativeOrigin.X, renderSize.Height * relativeOrigin.Y); 
        }
 
        #region Input
        // 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);
        } 
 
        private static void OnPreviewGotKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
        { 
            if (e.OriginalSource == sender)
            {
                FrameworkElement fe = (FrameworkElement)sender;
 
                // If element has an FocusedElement we need to delegate focus to it
                // and handle the event if focus successfully delegated 
                IInputElement activeElement = FocusManager.GetFocusedElement(fe); 
                if (activeElement != null && activeElement != sender && Keyboard.IsFocusable(activeElement as DependencyObject))
                { 
                    IInputElement oldFocus = Keyboard.FocusedElement;
                    activeElement.Focus();
                    // If focus is set to activeElement or delegated - handle the event
                    if (Keyboard.FocusedElement == activeElement || Keyboard.FocusedElement != oldFocus) 
                    {
                        e.Handled = true; 
                        return; 
                    }
                } 
            }
        }

        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) 
            {
                FrameworkElement fe = (FrameworkElement)sender;
                KeyboardNavigation.UpdateFocusedElement(fe);
 
                KeyboardNavigation keyNav = KeyboardNavigation.Current;
                KeyboardNavigation.ShowFocusVisual(); 
                keyNav.NotifyFocusChanged(fe, e); 
                keyNav.UpdateActiveElement(fe);
            } 
        }

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

                if (e.NewFocus == null) 
                {
                    KeyboardNavigation.Current.NotifyFocusChanged(sender, e);
                }
            } 
        }
 
        ///  
        ///     This method is invoked when the IsFocused property changes to true
        ///  
        /// RoutedEventArgs
        protected override void OnGotFocus(RoutedEventArgs e)
        {
            if (IsKeyboardFocused) 
                BringIntoView();
 
            base.OnGotFocus(e); 
        }
 
        #endregion Input

        #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); }
        } 

        ///  
        ///     Initialized private key 
        /// 
        internal static readonly EventPrivateKey InitializedKey = new EventPrivateKey(); 

        /// 
        ///     This clr event is fired when
        ///      
        ///     becomes true
        ///  
        [EditorBrowsable(EditorBrowsableState.Advanced)] 
        public event EventHandler Initialized
        { 
            add { EventHandlersStoreAdd(InitializedKey, value); }
            remove { EventHandlersStoreRemove(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(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);

                // Do instance initialization outside of the OnInitialized virtual
                // to make sure that: 
                // 1) We avoid attaching instance handlers to FrameworkElement
                //    (instance handlers are expensive). 
                // 2) If a derived class forgets to call base OnInitialized, 
                //    this work will still happen.
                PrivateInitialized(); 

                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 

        private static void NumberSubstitutionChanged(DependencyObject o, DependencyPropertyChangedEventArgs e) 
        { 
            ((FrameworkElement) o).HasNumberSubstitutionChanged = true;
        } 

        // Returns true when the coerce callback should return the current system metric
        private static bool ShouldUseSystemFont(FrameworkElement fe, DependencyProperty dp)
        { 
            bool hasModifiers;
 
            // Return the current system font when (changing the system theme OR creating an element and the default is outdated) 
            // AND the element is a root AND the element has not had a value set on it by the user
            return  (SystemResources.SystemResourcesAreChanging || (fe.ReadInternalFlag(InternalFlags.CreatingRoot) && SystemResources.SystemResourcesHaveChanged)) && 
                     fe._parent == null && VisualTreeHelper.GetParent(fe) == null &&
                     fe.GetValueSource(dp, null, out hasModifiers) == BaseValueSourceInternal.Default;
        }
 
        // Coerce Font properties on root elements when created or System resources change
        private static object CoerceFontFamily(DependencyObject o, object value) 
        { 
            // For root elements with default values, return current system metric if local value has not been set
            if (ShouldUseSystemFont((FrameworkElement)o, TextElement.FontFamilyProperty)) 
            {
                return SystemFonts.MessageFontFamily;
            }
 
            return value;
        } 
 
        private static object CoerceFontSize(DependencyObject o, object value)
        { 
            // For root elements with default values, return current system metric if local value has not been set
            if (ShouldUseSystemFont((FrameworkElement)o, TextElement.FontSizeProperty))
            {
                return SystemFonts.MessageFontSize; 
            }
 
            return value; 
        }
 
        private static object CoerceFontStyle(DependencyObject o, object value)
        {
            // For root elements with default values, return current system metric if local value has not been set
            if (ShouldUseSystemFont((FrameworkElement)o, TextElement.FontStyleProperty)) 
            {
                return SystemFonts.MessageFontStyle; 
            } 

            return value; 
        }

        private static object CoerceFontWeight(DependencyObject o, object value)
        { 
            // For root elements with default values, return current system metric if local value has not been set
            if (ShouldUseSystemFont((FrameworkElement)o, TextElement.FontWeightProperty)) 
            { 
                return SystemFonts.MessageFontWeight;
            } 

            return value;
        }
 

        /// 
        ///     Initiate the processing for [Un]Loaded event broadcast starting at this node 
        /// 
        internal sealed override void OnPresentationSourceChanged(bool attached) 
        {
            base.OnPresentationSourceChanged(attached);

            if (attached) 
            {
                // LOADED EVENT 
 
                // Broadcast Loaded
                // Note (see bug 1422684): Do not make this conditional on 
                // SubtreeHasLoadedChangeHandler. A layout pass may add loaded
                // handlers before the callback into BroadcastLoadedEvent occurs.
                // If we don't post the callback request, these handlers won't get
                // called. The optimization should be done in the callback. 
                FireLoadedOnDescendentsInternal();
 
                if (SystemResources.SystemResourcesHaveChanged) 
                {
                    // If root visual is created after resources have changed, update 
                    // Font properties because defaults are not in [....] with system
                    WriteInternalFlag(InternalFlags.CreatingRoot, true);
                    CoerceValue(TextElement.FontFamilyProperty);
                    CoerceValue(TextElement.FontSizeProperty); 
                    CoerceValue(TextElement.FontStyleProperty);
                    CoerceValue(TextElement.FontWeightProperty); 
                    WriteInternalFlag(InternalFlags.CreatingRoot, false); 
                }
            } 
            else
            {
                // UNLOADED EVENT
 
                // Broadcast Unloaded
                FireUnloadedOnDescendentsInternal(); 
            } 
        }
 
        /// 
        ///     The key needed set a read-only property.
        /// 
        internal static readonly DependencyPropertyKey LoadedPendingPropertyKey = 
                    DependencyProperty.RegisterReadOnly(
                                "LoadedPending", 
                                typeof(object[]), 
                                _typeofThis,
                                new PropertyMetadata(null)); // default value 

        /// 
        ///     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 
        /// 
        internal static readonly DependencyProperty LoadedPendingProperty = 
            LoadedPendingPropertyKey.DependencyProperty; 

        ///  
        ///     The key needed set a read-only property.
        /// 
        internal static readonly DependencyPropertyKey UnloadedPendingPropertyKey =
                    DependencyProperty.RegisterReadOnly( 
                                "UnloadedPending",
                                typeof(object[]), 
                                _typeofThis, 
                                new PropertyMetadata(null)); // default value
 
        /// 
        ///     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
        ///  
        internal static readonly DependencyProperty UnloadedPendingProperty =
            UnloadedPendingPropertyKey.DependencyProperty; 
 
        /// 
        ///     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 = EventManager.RegisterRoutedEvent("Loaded", RoutingStrategy.Direct, typeof(RoutedEventHandler), _typeofThis);
 
        /// 
        ///     This event is fired when the element is laid out, rendered and ready for interaction
        /// 
        public event RoutedEventHandler Loaded 
        {
            add 
            { 
                AddHandler(LoadedEvent, value, false);
            } 
            remove
            {
                RemoveHandler(LoadedEvent, value);
            } 
        }
 
        ///  
        ///     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 that will set the IsLoaded flag and Raise the Loaded event 
        ///  
        internal void OnLoaded(RoutedEventArgs args)
        { 
            RaiseEvent(args);
        }

        ///  
        ///     Unloaded private key
        ///  
        public static readonly RoutedEvent UnloadedEvent = EventManager.RegisterRoutedEvent("Unloaded", RoutingStrategy.Direct, typeof(RoutedEventHandler), _typeofThis); 

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

        ///  
        ///     Helper that will reset the IsLoaded flag and Raise the Unloaded event 
        /// 
        internal void OnUnloaded(RoutedEventArgs args) 
        {
            RaiseEvent(args);
        }
 
        // 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
 
        // This is part of an optimization to avoid accessing thread local storage
        // and thread apartment state multiple times. 
        private class FrameworkServices 
        {
            internal FrameworkServices() 
            {
                // STA Requirement are checked in InputManager cctor where InputManager.Current is used in KeyboardNavigation cctor
                _keyboardNavigation = new KeyboardNavigation();
                _popupControlService = new PopupControlService(); 
            }
 
            internal KeyboardNavigation _keyboardNavigation; 
            internal PopupControlService _popupControlService;
        } 

        internal static PopupControlService PopupControlService
        {
            get 
            {
                return EnsureFrameworkServices()._popupControlService; 
            } 
        }
 

        internal static KeyboardNavigation KeyboardNavigation
        {
            get 
            {
                return EnsureFrameworkServices()._keyboardNavigation; 
            } 
        }
 
        private static FrameworkServices EnsureFrameworkServices()
        {
            if ((_frameworkServices == null))
            { 
                // Enable KeyboardNavigation, ContextMenu, and ToolTip services.
                 _frameworkServices = new FrameworkServices(); 
            } 

            return _frameworkServices; 
        }

        /// 
        ///     The DependencyProperty for the ToolTip property 
        /// 
        public static readonly DependencyProperty ToolTipProperty = 
            ToolTipService.ToolTipProperty.AddOwner(_typeofThis); 

        ///  
        ///     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")] 
        [Localizability(LocalizationCategory.ToolTip)]
        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( 
                        _typeofThis,
                        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 GetValue(ContextMenuProperty) as ContextMenu;
            }
 
            set
            { 
                SetValue(ContextMenuProperty, value); 
            }
        } 

        /// 
        ///     The RoutedEvent for the ToolTipOpening event.
        ///  
        public static readonly RoutedEvent ToolTipOpeningEvent = ToolTipService.ToolTipOpeningEvent.AddOwner(_typeofThis);
 
        ///  
        ///     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) 
        {
            ((FrameworkElement)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(_typeofThis); 

        ///  
        ///     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)
        { 
            ((FrameworkElement)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(_typeofThis);
 
        /// 
        ///     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) 
        {
            ((FrameworkElement)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(_typeofThis); 

        ///  
        ///     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) 
        {
            ((FrameworkElement)sender).OnContextMenuClosing(e);
        }
 
        /// 
        ///     Called when ContextMenuClosing is raised on this element. 
        ///  
        /// Event arguments
        protected virtual void OnContextMenuClosing(ContextMenuEventArgs e) 
        {
        }

        #endregion 

        #region Operations 
 
        // 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);
                } 
            }
        }

        internal static void AddIntermediateElementsToRoute( 
            DependencyObject mergePoint,
            EventRoute route, 
            RoutedEventArgs args, 
            DependencyObject modelTreeNode)
        { 
            while (modelTreeNode != null && modelTreeNode != mergePoint)
            {
                UIElement uiElement = modelTreeNode as UIElement;
                ContentElement contentElement = modelTreeNode as ContentElement; 
                UIElement3D uiElement3D = modelTreeNode as UIElement3D;
 
                if(uiElement != null) 
                {
                    uiElement.AddToEventRoute(route, args); 

                    FrameworkElement fe = uiElement as FrameworkElement;
                    if (fe != null)
                    { 
                        AddStyleHandlersToEventRoute(fe, null, route, args);
                    } 
                } 
                else if (contentElement != null)
                { 
                    contentElement.AddToEventRoute(route, args);

                    FrameworkContentElement fce = contentElement as FrameworkContentElement;
                    if (fce != null) 
                    {
                        AddStyleHandlersToEventRoute(null, fce, route, args); 
                    } 
                }
                else if (uiElement3D != null) 
                {
                    uiElement3D.AddToEventRoute(route, args);
                }
 
                // Get model parent
                modelTreeNode = LogicalTreeHelper.GetParent(modelTreeNode); 
            } 
        }
 
        // 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;
        } 
 
        internal void EventHandlersStoreAdd(EventPrivateKey key, Delegate handler)
        { 
            EnsureEventHandlersStore();
            EventHandlersStore.Add(key, handler);
        }
 
        internal 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 InVisibilityCollapsedTree
        {
            get { return ReadInternalFlag(InternalFlags.InVisibilityCollapsedTree); } 
            set { WriteInternalFlag(InternalFlags.InVisibilityCollapsedTree, 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); }
        } 

        private bool NeedsClipBounds
        {
            get { return ReadInternalFlag(InternalFlags.NeedsClipBounds); } 
            set { WriteInternalFlag(InternalFlags.NeedsClipBounds, value); }
        } 
 
        private bool HasWidthEverChanged
        { 
            get { return ReadInternalFlag(InternalFlags.HasWidthEverChanged); }
            set { WriteInternalFlag(InternalFlags.HasWidthEverChanged, value); }
        }
 
        private bool HasHeightEverChanged
        { 
            get { return ReadInternalFlag(InternalFlags.HasHeightEverChanged); } 
            set { WriteInternalFlag(InternalFlags.HasHeightEverChanged, value); }
        } 

        internal bool IsRightToLeft
        {
            get { return ReadInternalFlag(InternalFlags.IsRightToLeft); } 
            set { WriteInternalFlag(InternalFlags.IsRightToLeft, value); }
        } 
 

        // Root node of VisualTree is the first FrameworkElementFactory 
        //  to be created.  -1 means "not involved in Style", 0 means
        //  "I am the object that has a Style with VisualTree", and 1
        //  means "I am the root of the VisualTree".  All following
        //  numbers are labeled in the order of a depth-first traversal 
        //  of the visual tree built from Style.VisualTree.
        // NOTE: Nodes that Style is not interested in (no properties, no 
        //  bindings, etc.) have a TemplateChildIndex of -1 because they are "not 
        //  involved" in Styles but they are in the chain.  They're at the end,
        //  behind all the nodes with TemplateChildIndex values, kept around so we 
        //  remember to clean them up.
        // NOTE: TemplateChildIndex is stored in the low bits of _flags2
        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); }
        } 

        internal bool BypassLayoutPolicies
        {
            get { return ReadInternalFlag2(InternalFlags2.BypassLayoutPolicies); } 
            set { WriteInternalFlag2(InternalFlags2.BypassLayoutPolicies, 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); 
            } 
        }
 
        private static DependencyObjectType ControlDType
        {
            get
            { 
                if (_controlDType == null)
                { 
                    _controlDType = DependencyObjectType.FromSystemTypeInternal(typeof(Control)); 
                }
 
                return _controlDType;
            }
        }
 
        private static DependencyObjectType ContentPresenterDType
        { 
            get 
            {
                if (_contentPresenterDType == null) 
                {
                    _contentPresenterDType = DependencyObjectType.FromSystemTypeInternal(typeof(ContentPresenter));
                }
 
                return _contentPresenterDType;
            } 
        } 

        private static DependencyObjectType PageDType 
        {
            get
            {
                if (_pageDType == null) 
                {
                    _pageDType = DependencyObjectType.FromSystemTypeInternal(typeof(Page)); 
                } 

                return _pageDType; 
            }
        }

        private static DependencyObjectType PageFunctionBaseDType 
        {
            get 
            { 
                if (_pageFunctionBaseDType == null)
                { 
                    _pageFunctionBaseDType = DependencyObjectType.FromSystemTypeInternal(typeof(PageFunctionBase));
                }

                return _pageFunctionBaseDType; 
            }
        } 
 
        //
        //  This property 
        //  1. Finds the correct initial size for the _effectiveValues store on the current DependencyObject
        //  2. This is a performance optimization
        //
        internal override int EffectiveValuesInitialSize 
        {
            get { return 7; } 
        } 

        #endregion Operations 

        // ThemeStyle used only when a ThemeStyleKey is specified (per-instance data in ThemeStyleDataField)
        private Style _themeStyleCache;
 
        // Layout
        private static readonly UncommonField UnclippedDesiredSizeField = new UncommonField(); 
        private static readonly UncommonField LayoutTransformDataField = new UncommonField(); 

        // Style/Template state (internals maintained by Style, per-instance data in StyleDataField) 
        private  Style       _styleCache;

        // Resources dictionary
        internal static readonly UncommonField ResourcesField = new UncommonField(); 

        internal DependencyObject _templatedParent;    // Non-null if this object was created as a result of a Template.VisualTree 
        private UIElement _templateChild;                // Non-null if this FE has a child that was created as part of a template. 

        private InternalFlags       _flags     = 0; // Stores Flags (see Flags enum) 
        private InternalFlags2      _flags2    = InternalFlags2.Default; // Stores Flags (see Flags enum)

        // Optimization, to avoid calling FromSystemType too often
        internal static DependencyObjectType UIElementDType = DependencyObjectType.FromSystemTypeInternal(typeof(UIElement)); 
        private static DependencyObjectType _controlDType = null;
        private static DependencyObjectType _contentPresenterDType = null; 
        private static DependencyObjectType _pageFunctionBaseDType = null; 
        private static DependencyObjectType _pageDType = null;
 
        // KeyboardNavigation, ContextMenu, and ToolTip
        [ThreadStatic]
        private static FrameworkServices _frameworkServices;
 
        // XLinq support
        private static PropertyInfo XElement_Name_PropertyInfo; 
 
#if DEBUG
        // This is used to make sure that Template-derived classes overriding 
        //  BuildVisualTree are doing the right thing when calling
        //  AddCustomTemplateRoot.
        internal VerificationState _buildVisualTreeVerification =
            VerificationState.WaitingForBuildVisualTree; 
#endif
    } 
 
    // LayoutDoubleUtil, uses fixed eps unlike DoubleUtil which uses relative one.
    // This is more suitable for some layout comparisons because the computation 
    // paths in layout may easily be quite long so DoubleUtil method gives a lot of false
    // results, while bigger absolute deviation is normally harmless in layout.
    // Note that FP noise is a big problem and using any of these compare methods is
    // not a complete solution, but rather the way to reduce the probability 
    // of the dramatically bad-looking results.
    internal static class LayoutDoubleUtil 
    { 
        private const double eps = 0.00000153; //more or less random more or less small number
 
        internal static bool AreClose(double value1, double value2)
        {
            if(value1 == value2) return true;
 
            double diff = value1 - value2;
            return (diff < eps) && (diff > -eps); 
        } 

        internal static bool LessThan(double value1, double value2) 
        {
            return (value1 < value2) && !AreClose(value1, value2);
        }
    } 

    internal enum InternalFlags : uint 
    { 
        // Does the instance have ResourceReference properties
        HasResourceReferences       = 0x00000001, 

        HasNumberSubstitutionChanged = 0x00000002,

        // Is the style for this instance obtained from a 
        // typed-style declared in the Resources
        HasImplicitStyleFromResources   = 0x00000004, 
        InheritanceBehavior0            = 0x00000008, 
        InheritanceBehavior1            = 0x00000010,
        InheritanceBehavior2            = 0x00000020, 

        IsStyleUpdateInProgress         = 0x00000040,
        IsThemeStyleUpdateInProgress    = 0x00000080,
        StoresParentTemplateValues     = 0x00000100, 

        // free bit = 0x00000200, 
        NeedsClipBounds             = 0x00000400, 

        HasWidthEverChanged        = 0x00000800, 
        HasHeightEverChanged        = 0x00001000,
        // free bit = 0x00002000,
        // free bit = 0x00004000,
 
        // Has this instance been initialized
        IsInitialized               = 0x00008000, 
 
        // Set on BeginInit and reset on EndInit
        InitPending                 = 0x00010000, 

        IsResourceParentValid       = 0x00020000,
        // free bit                     0x00040000,
 
        // This flag is set to true when this FrameworkElement is in the middle
        //  of an invalidation storm caused by InvalidateTree for ancestor change, 
        //  so we know not to trigger another one. 
        AncestorChangeInProgress    = 0x00080000,
 
        // This is used when we know that we're in a subtree whose visibility
        //  is collapsed.  A false here does not indicate otherwise.  A false
        //  merely indicates "we don't know".
        InVisibilityCollapsedTree   = 0x00100000, 

        HasStyleEverBeenFetched         = 0x00200000, 
        HasThemeStyleEverBeenFetched    = 0x00400000, 

        HasLocalStyle                    = 0x00800000, 

        // This instance's Visual or logical Tree was generated by a Template
        HasTemplateGeneratedSubTree    = 0x01000000,
 
        // free bit   = 0x02000000,
 
        HasLogicalChildren                    = 0x04000000, 

        // Are we in the process of iterating the logical children. 
        // This flag is set during a descendents walk, for property invalidation.
        IsLogicalChildrenIterationInProgress   = 0x08000000,

        //Are we creating a new root after system metrics have changed? 
        CreatingRoot                 = 0x10000000,
 
        // FlowDirection is set to RightToLeft (0 == LeftToRight, 1 == RightToLeft) 
        // This is an optimization to speed reading the FlowDirection property
        IsRightToLeft               = 0x20000000, 

        ShouldLookupImplicitStyles  = 0x40000000,

        // This flag is set to true there are mentees listening to either the 
        // InheritedPropertyChanged event or the ResourcesChanged event. Once
        // this flag is set to true it does not get reset after that. 
 
        PotentiallyHasMentees        = 0x80000000,
    } 

    [Flags]
    internal enum InternalFlags2 : uint
    { 
        // RESERVED: Bits 0-15  (0x0000FFFF): TemplateChildIndex
        R0                          = 0x00000001, 
        R1                          = 0x00000002, 
        R2                          = 0x00000004,
        R3                          = 0x00000008, 
        R4                          = 0x00000010,
        R5                          = 0x00000020,
        R6                          = 0x00000040,
        R7                          = 0x00000080, 
        R8                          = 0x00000100,
        R9                          = 0x00000200, 
        RA                          = 0x00000400, 
        RB                          = 0x00000800,
        RC                          = 0x00001000, 
        RD                          = 0x00002000,
        RE                          = 0x00004000,
        RF                          = 0x00008000,
 
        // free bit                 = 0x00010000,
        // free bit                 = 0x00020000, 
        // free bit                 = 0x00040000, 
        // free bit                 = 0x00080000,
 
        TreeHasLoadedChangeHandler  = 0x00100000,
        IsLoadedCache               = 0x00200000,
        IsStyleSetFromGenerator     = 0x00400000,
        IsParentAnFE                = 0x00800000, 
        IsTemplatedParentAnFE       = 0x01000000,
        HasStyleChanged             = 0x02000000, 
        HasTemplateChanged          = 0x04000000, 
        HasStyleInvalidated         = 0x08000000,
        IsRequestingExpression      = 0x10000000, 
        HasMultipleInheritanceContexts = 0x20000000,

        // free bit                 = 0x40000000,
        BypassLayoutPolicies        = 0x80000000, 

        // Default is so that the default value of TemplateChildIndex 
        // (which is stored in the low 16 bits) can be 0xFFFF (interpreted to be -1). 
        Default                     = 0x0000FFFF,
 
    }
}

 

 

// 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.Reflection; 
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.Media3D; 
using System.Windows.Media.TextFormatting;
using System.Windows.Navigation; 
using System.Windows.Markup;
using System.Windows.Controls;
using System.Windows.Automation;
 
using MS.Internal;
using MS.Internal.KnownBoxes; 
using MS.Internal.PresentationFramework;    // SafeSecurityHelper 
using MS.Utility;
using MS.Internal.Automation; 
using MS.Internal.PtsTable;                 // BodyContainerProxy
using System.Security;
using System.Security.Permissions;
using System.Xml; 

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

    ///  
    /// HorizontalAlignment - The HorizontalAlignment enum is used to describe 
    /// how element is positioned or stretched horizontally within a parent's layout slot.
    ///  
    [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)]
    public enum HorizontalAlignment
    {
        ///  
        /// Left - Align element towards the left of a parent's layout slot.
        ///  
        Left = 0, 

        ///  
        /// Center - Center element horizontally.
        /// 
        Center = 1,
 
        /// 
        /// Right - Align element towards the right of a parent's layout slot. 
        ///  
        Right = 2,
 
        /// 
        /// Stretch - Stretch element horizontally within a parent's layout slot.
        /// 
        Stretch = 3, 
    }
 
    ///  
    /// VerticalAlignment - The VerticalAlignment enum is used to describe
    /// how element is positioned or stretched vertically within a parent's layout slot. 
    /// 
    [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)]
    public enum VerticalAlignment
    { 
        /// 
        /// Top - Align element towards the top of a parent's layout slot. 
        ///  
        Top = 0,
 
        /// 
        /// Center - Center element vertically.
        /// 
        Center = 1, 

        ///  
        /// Bottom - Align element towards the bottom of a parent's layout slot. 
        /// 
        Bottom = 2, 

        /// 
        /// Stretch - Stretch element vertically within a parent's layout slot.
        ///  
        Stretch = 3,
    } 
 
    /// 
    ///     The base object for the Frameworks 
    /// 
    /// 
    ///     FrameworkElement is the interface between higher-level Framework
    ///     classes and PresentationCore services 
    /// 
    [StyleTypedProperty(Property = "FocusVisualStyle", StyleTargetType = typeof(Control))] 
    [XmlLangProperty("Language")] 
    [UsableDuringInitialization(true)]
    public partial class FrameworkElement : UIElement, IFrameworkInputElement, ISupportInitialize, IHaveResources 
    {
        static private readonly Type _typeofThis = typeof(FrameworkElement);

        ///  
        ///     Default FrameworkElement constructor
        ///  
        ///  
        ///     Automatic determination of current Dispatcher. Use alternative constructor
        ///     that accepts a Dispatcher for best performance. 
        /// 
        public FrameworkElement() : base()
        {
            // 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));
            }

            if (((FlowDirection)FlowDirectionProperty.GetDefaultValue(DependencyObjectType)) == FlowDirection.RightToLeft) 
            {
                IsRightToLeft = true; 
            } 

            // Set the ShouldLookupImplicitStyles flag to true if App.Resources has implicit styles. 
            Application app = Application.Current;
            if (app != null && app.HasImplicitStylesInResources)
            {
                ShouldLookupImplicitStyles = true; 
            }
 
            FrameworkElement.EnsureFrameworkServices(); 
        }
 
        /// Style Dependency Property
        [CommonDependencyProperty]
        public static readonly DependencyProperty StyleProperty =
                DependencyProperty.Register( 
                        "Style",
                        typeof(Style), 
                        _typeofThis, 
                        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) 
        {
            FrameworkElement fe = (FrameworkElement) d; 
            fe.HasLocalStyle = (e.NewEntry.BaseValueSourceInternal == BaseValueSourceInternal.Local);
            StyleHelper.UpdateStyleCache(fe, null, (Style) e.OldValue, (Style) e.NewValue, ref fe._styleCache);
        }
 
        /// 
        /// OverridesDefaultStyleProperty 
        ///  
        public static readonly DependencyProperty OverridesDefaultStyleProperty
            = DependencyProperty.Register("OverridesDefaultStyle", typeof(bool), _typeofThis, 
                                            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)); }
        } 
 

        ///  
        /// DefaultStyleKeyProperty
        /// 
        protected internal static readonly DependencyProperty DefaultStyleKeyProperty
            = DependencyProperty.Register("DefaultStyleKey", typeof(object), _typeofThis, 
                                            new FrameworkPropertyMetadata(
                                                        null,   // default value 
                                                        FrameworkPropertyMetadataOptions.AffectsMeasure, 
                                                        new PropertyChangedCallback(OnThemeStyleKeyChanged)));
 
        /// 
        ///     This specifies the key to use to find
        ///     a style in a theme for this control
        ///  
        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 
            ((FrameworkElement)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 ThemeStyleKey's default
        // value. Controls will override this method to return approriate types. 
        internal virtual DependencyObjectType DTypeThemeStyleKey
        {
            get { return null; }
        } 

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

        // Internal helper so the FrameworkElement could see the 
        // ControlTemplate/DataTemplate set on the
        // Control/Page/PageFunction/ContentPresenter 
        internal virtual FrameworkTemplate TemplateInternal 
        {
            get { return null; } 
        }

        // Internal helper so the FrameworkElement could see the
        // ControlTemplate/DataTemplate set on the 
        // Control/Page/PageFunction/ContentPresenter
        internal virtual FrameworkTemplate TemplateCache 
        { 
            get { return null; }
            set {} 
        }

        // Internal so that StyleHelper could uniformly call the TemplateChanged
        // virtual on any templated parent 
        internal virtual void OnTemplateChangedInternal(
            FrameworkTemplate oldTemplate, 
            FrameworkTemplate newTemplate) 
        {
            HasTemplateChanged = true; 
        }

        /// 
        ///     Style has changed 
        /// 
        /// The old Style 
        /// The new Style 
        protected internal virtual void OnStyleChanged(Style oldStyle, Style newStyle)
        { 
            HasStyleChanged = true;
        }

        ///  
        /// This method is called from during property invalidation time. If the FrameworkElement has a child on which
        /// some property was invalidated and the property was marked as AffectsParentMeasure or AffectsParentArrange 
        /// during registration, this method is invoked to let a FrameworkElement know which particualr child must be 
        /// remeasured if the FrameworkElement wants to do partial (incremental) update of layout.
        ///  
        /// Olny advanced FrameworkElement, which implement incremental update should override this method. Since
        /// Panel always gets InvalidateMeasure or InvalidateArrange called in this situation, it ensures that
        /// the FrameworkElement will be re-measured and/or re-arranged. Only if the FrameworkElement wants to implement a performance
        /// optimization and avoid calling Measure/Arrange on all children, it should override this method and 
        /// store the info about invalidated children, to use subsequently in the FrameworkElement's MeasureOverride/ArrangeOverride
        /// implementations. 
        ///  
        /// Note: to listen for added/removed children, Panel should provide its derived version of
        /// . 
        /// 
        ///Reference to a child UIElement that had AffectsParentMeasure/AffectsParentArrange property invalidated.
        protected internal virtual void ParentLayoutInvalidated(UIElement child)
        { 
        }
 
        ///  
        /// ApplyTemplate is called on every Measure
        ///  
        /// 
        /// Used by subclassers as a notification to delay fault-in their Visuals
        /// Used by application authors ensure an Elements Visual tree is completely built
        ///  
        /// Whether Visuals were added to the tree
        public bool ApplyTemplate() 
        { 
            // Notify the ContentPresenter/ItemsPresenter that we are about to generate the
            // template tree and allow them to choose the right template to be applied. 
            OnPreApplyTemplate();

            bool visualsCreated = false;
 
            UncommonField  dataField = StyleHelper.TemplateDataField;
            FrameworkTemplate           template = TemplateInternal; 
 
            // VisualTree application never clears existing trees. Trees
            // will be conditionally cleared on Template invalidation 
            if (!HasTemplateGeneratedSubTree)
            {
                if (template != null)
                { 
                    // Create a VisualTree using the given template
                    visualsCreated = template.ApplyTemplateContent(dataField, this); 
                    if (visualsCreated) 
                    {
                        // This VisualTree was created via a Template 
                        HasTemplateGeneratedSubTree =  true;

                        // We may have had trigger actions that had to wait until the
                        //  template subtree has been created.  Invoke them now. 
                        StyleHelper.InvokeDeferredActions(this, template);
 
                        // Notify sub-classes when the template tree has been created 
                        OnApplyTemplate();
                    } 
                }
            }

            return visualsCreated; 
        }
 
        ///  
        /// This virtual is called by FE.ApplyTemplate before it does work to generate the template tree.
        ///  
        /// 
        /// This virtual is overridden for the following three reasons
        /// 1. By ContentPresenter/ItemsPresenter to choose the template to be applied in this case.
        /// 2. By RowPresenter/ColumnHeaderPresenter/InkCanvas to build custom visual trees 
        /// 3. By ScrollViewer/TickBar/ToolBarPanel/Track to hookup bindings to their TemplateParent
        ///  
        internal virtual void OnPreApplyTemplate() 
        {
        } 

        /// 
        ///     This is the virtual that sub-classes must override if they wish to get
        ///     notified that the template tree has been created. 
        /// 
        ///  
        ///     This virtual is called after the template tree has been generated and it is invoked only 
        ///     if the call to ApplyTemplate actually caused the template tree to be generated.
        ///  
        public virtual void OnApplyTemplate()
        {
        }
 
        /// 
        ///     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 ); 
        }

        // Given a FrameworkElement and a name string, this routine will try to find
        //  a node with Name property set to the given name.  It will search all 
        //  the child logical tree nodes of the given starting element.
        // If the name string is null or an empty string, the given starting element 
        //  is returned. 
        // If the name is found on a FrameworkContentElement, an exception is thrown
        // If the name is not found attached to anything, an exception is thrown 
        internal static FrameworkElement FindNamedFrameworkElement( FrameworkElement startElement, string targetName )
        {
            FrameworkElement targetFE = null;
 
            if( targetName == null || targetName.Length == 0 )
            { 
                targetFE = startElement; 
            }
            else 
            {
                DependencyObject targetObject = null;

                targetObject = LogicalTreeHelper.FindLogicalNode( startElement, targetName ); 

                if( targetObject == null ) 
                { 
                    throw new ArgumentException( SR.Get(SRID.TargetNameNotFound, targetName));
                } 

                FrameworkObject fo = new FrameworkObject(targetObject);
                if( fo.IsFE )
                { 
                    targetFE = fo.FE;
                } 
                else 
                {
                    throw new InvalidOperationException(SR.Get(SRID.NamedObjectMustBeFrameworkElement, targetName)); 
                }
            }

            return targetFE; 
        }
 
        ///  
        ///     Triggers associated with this object.  Both the triggering condition
        /// and the trigger effect may be on this object or on its tree child 
        /// objects.
        /// 
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public TriggerCollection Triggers 
        {
            get 
            { 
                TriggerCollection triggerCollection = EventTrigger.TriggerCollectionField.GetValue(this);
                if (triggerCollection == null) 
                {
                    // Give the TriggerCollectiona back-link so that it can update
                    // 'this' on Add/Remove.
                    triggerCollection = new TriggerCollection(this); 

                    EventTrigger.TriggerCollectionField.SetValue(this, triggerCollection); 
                } 

                return triggerCollection; 
            }
        }

        ///  
        ///     Return true if the Triggers property contains something that
        ///     should be serialized. 
        ///  
        [EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializeTriggers() 
        {
            TriggerCollection triggerCollection = EventTrigger.TriggerCollectionField.GetValue(this);
            if (triggerCollection == null || triggerCollection.Count == 0)
            { 
                return false;
            } 
 
            return true;
        } 

        // This should be called when the FrameworkElement tree is built up,
        //  at this point we can process all the setter-related information
        //  because now we'll be able to resolve "Target" references in setters. 
        private void PrivateInitialized()
        { 
            // Process Trigger information when this object is loaded. 
            EventTrigger.ProcessTriggerCollection(this);
        } 

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

        ///  
        ///     Returns true if this FrameworkElement was created as the root
        ///     node of a Template.VisualTree or if it were the root node of a template.
        /// 
        //     Most people can get this information by comparing this.TemplatedParent 
        // against this.Parent.  However, layout has a need to know this when
        // the tree is not yet hooked up and/or just disconnected. 
        //     This function uses esoteric knowledge of FrameworkElementFactory 
        // and how it is actually used to build visual trees from style.
        // Exposing this property is easier than explaining the ChildIndex magic. 
        internal bool IsTemplateRoot
        {
            get
            { 
                return (TemplateChildIndex==1);
            } 
        } 

 
        /// 
        /// Gets or sets the template child of the FrameworkElement.
        /// 
        virtual internal UIElement TemplateChild 
        {
            get 
            { 
                return _templateChild;
            } 
            set
            {
                if (value != _templateChild)
                { 
                    RemoveVisualChild(_templateChild);
                    _templateChild = value; 
                    AddVisualChild(value); 
                }
            } 
        }

        /// 
        /// Gets the number of Visual children of this FrameworkElement. 
        /// 
        ///  
        /// Derived classes override this property getter to provide the children count 
        /// of their custom children collection.
        ///  
        protected override int VisualChildrenCount
        {
            get
            { 
                return (_templateChild == null) ? 0 : 1;
            } 
        } 

 
        /// 
        /// Gets the Visual child at the specified index.
        /// 
        ///  
        /// Derived classes that provide a custom children collection must override this method
        /// and return the child at the specified index. 
        ///  
        protected override Visual GetVisualChild(int index)
        { 
            if (_templateChild == null)
            {
                throw new ArgumentOutOfRangeException("index", index, SR.Get(SRID.Visual_ArgumentOutOfRange));
            } 
            if (index != 0)
            { 
                throw new ArgumentOutOfRangeException("index", index, SR.Get(SRID.Visual_ArgumentOutOfRange)); 
            }
            return _templateChild; 
        }

        /// 
        ///     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
        /// 
        public ResourceDictionary Resources
        { 
            get
            { 
                ResourceDictionary resources = ResourcesField.GetValue(this); 
                if (resources == null)
                { 
                    resources = new ResourceDictionary();
                    resources.AddOwner(this);
                    ResourcesField.SetValue(this, resources);
 
                    if( TraceResourceDictionary.IsEnabled )
                    { 
                        TraceResourceDictionary.TraceActivityItem( 
                                TraceResourceDictionary.NewResourceDictionary,
                                this, 
                                0,
                                resources );
                    }
 
                }
 
                return resources; 

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

                if( TraceResourceDictionary.IsEnabled ) 
                { 
                    TraceResourceDictionary.Trace(
                            TraceEventType.Start, 
                            TraceResourceDictionary.NewResourceDictionary,
                            this,
                            oldValue,
                            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(this, null, new ResourcesChangeInfo(oldValue, value));
                } 
 

                if( TraceResourceDictionary.IsEnabled ) 
                {
                    TraceResourceDictionary.Trace(
                            TraceEventType.Stop,
                            TraceResourceDictionary.NewResourceDictionary, 
                            this,
                            oldValue, 
                            value ); 
                }
 

            }
        }
 
        ResourceDictionary IHaveResources.Resources
        { 
            get { return Resources; } 
            set { Resources = value; }
        } 

        /// 
        /// This method is used by TypeDescriptor to determine if this property should
        /// be serialized. 
        /// 
        // This is to tell the serialization engine when we 
        // must and must not serialize the Resources property 
        [EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializeResources() 
        {
            if (Resources == null || Resources.Count == 0)
            {
                return false; 
            }
 
            return true; 
        }
 
        /// 
        ///     Retrieves the element in the VisualTree of thie element that corresponds to
        ///     the element with the given childName in this element's style definition
        ///  
        /// the Name to find the matching element for
        /// The Named element.  Null if no element has this Name. 
        protected internal DependencyObject GetTemplateChild(string childName) 
        {
            FrameworkTemplate template = TemplateInternal; 
            /* Calling this before getting a style/template is not a bug.
            Debug.Assert(template != null,
                "The VisualTree should have been created from a Template");
            */ 

            if (template == null) 
            { 
                return null;
            } 

            return StyleHelper.FindNameInTemplateContent(this, childName, template) as DependencyObject;
        }
 
        /// 
        ///     Searches for a resource with the passed resourceKey and returns it. 
        ///     Throws an exception if the resource was not found. 
        /// 
        ///  
        ///     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.
        public object FindResource(object resourceKey) 
        { 
            // Verify Context Access
            // VerifyAccess(); 

            if (resourceKey == null)
            {
                throw new ArgumentNullException("resourceKey"); 
            }
 
            object resource = FrameworkElement.FindResourceInternal(this, null /* fce */, 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(this, null /* fce */, 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;
        }
 

        // FindImplicitSytle(fe) : Default: unlinkedParent, deferReference 
        internal static object FindImplicitStyleResource(FrameworkElement fe, object resourceKey, out object source) 
        {
            // Do a FindResource call only if someone in the ancestry has 
            // implicit styles. This is a performance optimization.

#if !DEBUG
            if (fe.ShouldLookupImplicitStyles) 
            {
#endif 
                object unlinkedParent = null; 
                bool allowDeferredResourceReference = false;
                bool mustReturnDeferredResourceReference = false; 

                // Implicit style lookup must stop at the app.
                bool isImplicitStyleLookup = true;
 
                // For non-controls the implicit StyleResource lookup must stop at
                // the templated parent. Look at task 25606 for further details. 
                DependencyObject boundaryElement = null; 
                if (!(fe is Control))
                { 
                    boundaryElement = fe.TemplatedParent;
                }

                object implicitStyle = FindResourceInternal(fe, null, FrameworkElement.StyleProperty, resourceKey, unlinkedParent, allowDeferredResourceReference, mustReturnDeferredResourceReference, boundaryElement, isImplicitStyleLookup, out source); 

                // The reason this assert is commented is because there are specific scenarios when we can reach 
                // here even before the ShouldLookupImplicitStyles flag is updated. But this is still acceptable 
                // because the flag does get updated and the style property gets re-fetched soon after.
 
                // Look at AccessText.GetVisualChild implementation for example and
                // consider the following sequence of operations.

                // 1. contentPresenter.AddVisualChild(accessText) 
                // 1.1. accessText._parent = contentPresenter
                // 1.2. accessText.GetVisualChild(...) 
                // 1.2.1  accessText.AddVisualChild(textBlock) 
                // 1.2.1.1 textBlock.OnVisualParentChanged()
                // 1.2.1.1.1 FindImplicitStyleResource(textBlock) 
                // .
                // .
                // .
                // 1.3 accessText.OnVisualParentChanged 
                // 1.3.1 Set accessText.ShouldLookupImplicitStyle
                // 1.3.2 FindImplicitStyleResource(accessText) 
                // 1.3.3 Set textBlock.ShouldLookupImplicitStyle 
                // 1.3.4 FindImplicitStyleResource(textBlock)
 
                // Notice how we end up calling FindImplicitStyleResource on the textBlock before we have set the
                // ShouldLookupImplicitStyle flag on either accessText or textBlock. However this is still acceptable
                // because we eventually going to synchronize the flag and the style property value on both these objects.
 
                // Debug.Assert(!(implicitStyle != DependencyProperty.UnsetValue && fe.ShouldLookupImplicitStyles == false),
                //     "ShouldLookupImplicitStyles is false even while there exists an implicit style in the lookup path. To be precise at source " + source); 
 
                return implicitStyle;
#if !DEBUG 
            }

            source = null;
            return DependencyProperty.UnsetValue; 
#endif
        } 
 
        // FindImplicitSytle(fce) : Default: unlinkedParent, deferReference
        internal static object FindImplicitStyleResource(FrameworkContentElement fce, object resourceKey, out object source) 
        {
            // Do a FindResource call only if someone in the ancestry has
            // implicit styles. This is a performance optimization.
 
#if !DEBUG
            if (fce.ShouldLookupImplicitStyles) 
            { 
#endif
                object unlinkedParent = null; 
                bool allowDeferredResourceReference = false;
                bool mustReturnDeferredResourceReference = false;

                // Implicit style lookup must stop at the app. 
                bool isImplicitStyleLookup = true;
 
                // For non-controls the implicit StyleResource lookup must stop at 
                // the templated parent. Look at task 25606 for further details.
                DependencyObject boundaryElement = fce.TemplatedParent; 

                object implicitStyle = FindResourceInternal(null, fce, FrameworkContentElement.StyleProperty, resourceKey, unlinkedParent, allowDeferredResourceReference, mustReturnDeferredResourceReference, boundaryElement, isImplicitStyleLookup, out source);

                // Look at comments on the FE version of this method. 

                // Debug.Assert(!(implicitStyle != DependencyProperty.UnsetValue && fce.ShouldLookupImplicitStyles == false), 
                //     "ShouldLookupImplicitStyles is false even while there exists an implicit style in the lookup path. To be precise at source " + source); 

                return implicitStyle; 
#if !DEBUG
            }

            source = null; 
            return DependencyProperty.UnsetValue;
#endif 
        } 

        // Internal method for Parser to find a resource when 
        // the instance is not yet hooked to the logical tree
        // This method returns DependencyProperty.UnsetValue when
        // resource is not found. Otherwise it returns the value
        // found. NOTE: Value resource found could be null 
        // FindResource(fe/fce)  Default: dp, unlinkedParent, deferReference, boundaryElement, source, isImplicitStyleLookup
        internal static object FindResourceInternal(FrameworkElement fe, FrameworkContentElement fce, object resourceKey) 
        { 
            DependencyProperty      dp = null;
            object                  unlinkedParent = null; 
            bool                    allowDeferredResourceReference = false;
            bool                    mustReturnDeferredResourceReference = false;
            DependencyObject        boundaryElement = null;
            object                  source; 
            bool                    isImplicitStyleLookup = false;
 
            return FindResourceInternal(fe, fce, dp, resourceKey, unlinkedParent, allowDeferredResourceReference, mustReturnDeferredResourceReference, boundaryElement, isImplicitStyleLookup, out source); 
        }
 
        // FindresourceInternal(fe/fce)  Default: source
        internal static object FindResourceInternal(FrameworkElement fe, FrameworkContentElement fce, DependencyProperty dp, object resourceKey, object unlinkedParent, bool deferReference)
        {
            object source; 
            return FindResourceInternal(fe, fce, dp, resourceKey, unlinkedParent, deferReference, out source);
        } 
 
        // FindresourceInternal(fe/fce)  Default: boundaryElement
        internal static object FindResourceInternal(FrameworkElement fe, FrameworkContentElement fce, DependencyProperty dp, object resourceKey, object unlinkedParent, bool deferReference, out object source) 
        {
            DependencyObject boundaryElement = null;
            return FindResourceInternal(fe, fce, dp, resourceKey, unlinkedParent, deferReference, boundaryElement, out source);
        } 

        // FindresourceInternal(fe/fce)  Default: isImplicitStyleLookup 
        internal static object FindResourceInternal( 
            FrameworkElement        fe,
            FrameworkContentElement fce, 
            DependencyProperty      dp,
            object                  resourceKey,
            object                  unlinkedParent,
            bool                    deferReference, 
            DependencyObject        boundaryElement,
            out object              source) 
        { 
            bool isImplicitStyleLookup = false;
            bool mustReturnDeferredResourceReference = false; 
            return FindResourceInternal(fe, fce, dp, resourceKey, unlinkedParent, deferReference, mustReturnDeferredResourceReference, boundaryElement,  isImplicitStyleLookup, out source);
        }

        // FindResourceInternal(fe/fce)  Defaults: none 
        internal static object FindResourceInternal(
            FrameworkElement        fe, 
            FrameworkContentElement fce, 
            DependencyProperty      dp,
            object                  resourceKey, 
            object                  unlinkedParent,
            bool                    allowDeferredResourceReference,
            bool                    mustReturnDeferredResourceReference,
            DependencyObject        boundaryElement, 
            bool                    isImplicitStyleLookup,
            out object              source) 
        { 
            object value;
            InheritanceBehavior inheritanceBehavior = InheritanceBehavior.Default; 

            if( TraceResourceDictionary.IsEnabled )
            {
                FrameworkObject element = new FrameworkObject(fe, fce); 

                TraceResourceDictionary.Trace( 
                    TraceEventType.Start, 
                    TraceResourceDictionary.FindResource,
                     element.DO, 
                     resourceKey );
            }

            try 
            {
 
                // First try to find the resource in the tree 
                if (fe != null || fce != null || unlinkedParent != null)
                { 
                    value = FindResourceInTree(fe, fce, dp, resourceKey, unlinkedParent, allowDeferredResourceReference, mustReturnDeferredResourceReference, boundaryElement,
                                                out inheritanceBehavior, out source);
                    if (value != DependencyProperty.UnsetValue)
                    { 
                        return value;
                    } 
 
                }
 
                // Then we try to find the resource in the App's Resources
                Application app = Application.Current;
                if (app != null &&
                    (inheritanceBehavior == InheritanceBehavior.Default || 
                     inheritanceBehavior == InheritanceBehavior.SkipToAppNow ||
                     inheritanceBehavior == InheritanceBehavior.SkipToAppNext)) 
                { 
                    value = app.FindResourceInternal(resourceKey, allowDeferredResourceReference, mustReturnDeferredResourceReference);
                    if (value != null) 
                    {
                        source = app;

                        if( TraceResourceDictionary.IsEnabled ) 
                        {
                            TraceResourceDictionary.TraceActivityItem( 
                                TraceResourceDictionary.FoundResourceInApplication, 
                                 resourceKey,
                                value ); 
                        }

                        return value;
                    } 
                }
 
                // Then we try to find the resource in the SystemResources but that is only if we aren't 
                // doing an implicit style lookup. Implicit style lookup will stop at the app.
                if (!isImplicitStyleLookup && 
                    inheritanceBehavior != InheritanceBehavior.SkipAllNow &&
                    inheritanceBehavior != InheritanceBehavior.SkipAllNext)
                {
                    value = SystemResources.FindResourceInternal(resourceKey, allowDeferredResourceReference, mustReturnDeferredResourceReference); 
                    if (value != null)
                    { 
                        source = SystemResourceHost.Instance; 

                        if( TraceResourceDictionary.IsEnabled ) 
                        {
                            TraceResourceDictionary.TraceActivityItem(
                                TraceResourceDictionary.FoundResourceInTheme,
                                source, 
                                resourceKey,
                                value ); 
                        } 

 
                        return value;
                    }
                }
            } 
            finally
            { 
                if( TraceResourceDictionary.IsEnabled ) 
                {
                    FrameworkObject element = new FrameworkObject(fe, fce); 

                    TraceResourceDictionary.Trace(
                        TraceEventType.Stop,
                        TraceResourceDictionary.FindResource, 
                         element.DO,
                         resourceKey ); 
                } 
            }
 
            // We haven't found the resource.  Trace a message to the debugger.
            //
            // Only trace if this isn't an implicit
            // style lookup and the element has been loaded 
            if (TraceResourceDictionary.IsEnabledOverride && !isImplicitStyleLookup)
            { 
                if ((fe != null && fe.IsLoaded) || (fce != null && fce.IsLoaded)) 
                {
                    TraceResourceDictionary.Trace( TraceEventType.Warning, 
                            TraceResourceDictionary.ResourceNotFound,
                            resourceKey );
                }
                else if( TraceResourceDictionary.IsEnabled ) 
                {
                    TraceResourceDictionary.TraceActivityItem( 
                            TraceResourceDictionary.ResourceNotFound, 
                            resourceKey );
                } 
            }

            source = null;
            return DependencyProperty.UnsetValue; 
        }
 
        // FindResourceInTree(fe/fce)  Defaults: none 
        internal static object FindResourceInTree(
            FrameworkElement        feStart, 
            FrameworkContentElement fceStart,
            DependencyProperty      dp,
            object                  resourceKey,
            object                  unlinkedParent, 
            bool                    allowDeferredResourceReference,
            bool                    mustReturnDeferredResourceReference, 
            DependencyObject        boundaryElement, 
            out InheritanceBehavior inheritanceBehavior,
            out object              source) 
        {
            FrameworkObject startNode = new FrameworkObject(feStart, fceStart);
            FrameworkObject fo = startNode;
            object value; 
            Style style;
            FrameworkTemplate frameworkTemplate; 
            Style themeStyle; 
            int loopCount = 0;
            bool hasParent = true; 
            inheritanceBehavior = InheritanceBehavior.Default;

            while (hasParent)
            { 
                Debug.Assert(startNode.IsValid || unlinkedParent != null,
                              "Don't call FindResource with a null fe/fce and unlinkedParent"); 
 
                if (loopCount > DescendentsWalkerBase.MAX_TREE_DEPTH)
                { 
                    // We suspect a loop here because the loop count
                    // has exceeded the MAX_TREE_DEPTH expected
                    throw new InvalidOperationException(SR.Get(SRID.LogicalTreeLoop));
                } 
                else
                { 
                    loopCount++; 
                }
 
                // -------------------------------------------
                //  Lookup ResourceDictionary on the current instance
                // -------------------------------------------
 
                style = null;
                frameworkTemplate = null; 
                themeStyle = null; 

                if (fo.IsFE) 
                {
                    FrameworkElement fe = fo.FE;

                    value = fe.FindResourceOnSelf(resourceKey, allowDeferredResourceReference, mustReturnDeferredResourceReference); 
                    if (value != DependencyProperty.UnsetValue)
                    { 
                        source = fe; 

                        if( TraceResourceDictionary.IsEnabled ) 
                        {
                            TraceResourceDictionary.TraceActivityItem(
                                TraceResourceDictionary.FoundResourceOnElement,
                                source, 
                                resourceKey,
                                value ); 
                        } 

                        return value; 
                    }

                    if ((fe != startNode.FE) || StyleHelper.ShouldGetValueFromStyle(dp))
                    { 
                        style = fe.Style;
                    } 
                    // Fetch the Template 
                    if ((fe != startNode.FE) || StyleHelper.ShouldGetValueFromTemplate(dp))
                    { 
                        frameworkTemplate = fe.TemplateInternal;
                    }
                    // Fetch the ThemeStyle
                    if ((fe != startNode.FE) || StyleHelper.ShouldGetValueFromThemeStyle(dp)) 
                    {
                        themeStyle = fe.ThemeStyle; 
                    } 
                }
                else if (fo.IsFCE) 
                {
                    FrameworkContentElement fce = fo.FCE;

                    value = fce.FindResourceOnSelf(resourceKey, allowDeferredResourceReference, mustReturnDeferredResourceReference); 
                    if (value != DependencyProperty.UnsetValue)
                    { 
                        source = fce; 

                        if( TraceResourceDictionary.IsEnabled ) 
                        {
                            TraceResourceDictionary.TraceActivityItem(
                                TraceResourceDictionary.FoundResourceOnElement,
                                source, 
                                resourceKey,
                                value ); 
                        } 

                        return value; 
                    }

                    if ((fce != startNode.FCE) || StyleHelper.ShouldGetValueFromStyle(dp))
                    { 
                        style = fce.Style;
                    } 
                    // Fetch the ThemeStyle 
                    if ((fce != startNode.FCE) || StyleHelper.ShouldGetValueFromThemeStyle(dp))
                    { 
                        themeStyle = fce.ThemeStyle;
                    }
                }
 
                if (style != null)
                { 
                    value = style.FindResource(resourceKey, allowDeferredResourceReference, mustReturnDeferredResourceReference); 
                    if (value != DependencyProperty.UnsetValue)
                    { 
                        source = style;

                        if( TraceResourceDictionary.IsEnabled )
                        { 
                            TraceResourceDictionary.TraceActivityItem(
                                TraceResourceDictionary.FoundResourceInStyle, 
                                style.Resources, 
                                resourceKey,
                                style, 
                                fo.DO,
                                value );
                        }
 
                        return value;
                    } 
                } 
                if (frameworkTemplate != null)
                { 
                    value = frameworkTemplate.FindResource(resourceKey, allowDeferredResourceReference, mustReturnDeferredResourceReference);
                    if (value != DependencyProperty.UnsetValue)
                    {
                        source = frameworkTemplate; 

                        if( TraceResourceDictionary.IsEnabled ) 
                        { 
                            TraceResourceDictionary.TraceActivityItem(
                                TraceResourceDictionary.FoundResourceInTemplate, 
                                frameworkTemplate.Resources,
                                resourceKey,
                                frameworkTemplate,
                                fo.DO, 
                                value );
                        } 
 
                        return value;
                    } 
                }

                if (themeStyle != null)
                { 
                    value = themeStyle.FindResource(resourceKey, allowDeferredResourceReference, mustReturnDeferredResourceReference);
                    if (value != DependencyProperty.UnsetValue) 
                    { 
                        source = themeStyle;
 
                        if( TraceResourceDictionary.IsEnabled )
                        {
                            TraceResourceDictionary.TraceActivityItem(
                                TraceResourceDictionary.FoundResourceInThemeStyle, 
                                themeStyle.Resources,
                                resourceKey, 
                                themeStyle, 
                                fo.DO,
                                value ); 
                        }

                        return value;
                    } 
                }
 
 
                // If the current element that has been searched is the boundary element
                // then we need to progress no further 
                if (boundaryElement != null && (fo.DO == boundaryElement))
                {
                    break;
                } 

                // If the current element for resource lookup is marked such 
                // then skip to the Application and/or System resources 
                if (fo.IsValid && TreeWalkHelper.SkipNext(fo.InheritanceBehavior))
                { 
                    inheritanceBehavior = fo.InheritanceBehavior;
                    break;
                }
 
                // -------------------------------------------
                //  Find the next parent instance to lookup 
                // ------------------------------------------- 

                if (unlinkedParent != null) 
                {
                    // This is for the special case when the parser tries to fetch
                    // a resource on an element even before it is hooked to the
                    // tree. In this case the parser passes us the unlinkedParent 
                    // to use it for resource lookup.
                    DependencyObject unlinkedParentAsDO = unlinkedParent as DependencyObject; 
                    if (unlinkedParentAsDO != null) 
                    {
                        fo.Reset(unlinkedParentAsDO); 
                        if (fo.IsValid)
                        {
                            hasParent = true;
                        } 
                        else
                        { 
                            DependencyObject doParent = GetFrameworkParent(unlinkedParent); 
                            if (doParent != null)
                            { 
                                fo.Reset(doParent);
                                hasParent = true;
                            }
                            else 
                            {
                                hasParent = false; 
                            } 
                        }
                    } 
                    else
                    {
                        hasParent = false;
                    } 
                    unlinkedParent = null;
                } 
                else 
                {
                    Debug.Assert(fo.IsValid, 
                                  "The current node being processed should be an FE/FCE");

                    fo = fo.FrameworkParent;
 
                    hasParent = fo.IsValid;
                } 
 
                // If the current element for resource lookup is marked such
                // then skip to the Application and/or System resources 
                if (fo.IsValid && TreeWalkHelper.SkipNow(fo.InheritanceBehavior))
                {
                    inheritanceBehavior = fo.InheritanceBehavior;
                    break; 
                }
            } 
 
            // No matching resource was found in the tree
            source = null; 
            return DependencyProperty.UnsetValue;
        }

 
        // Searches through resource dictionaries to find a [Data|Table]Template
        //  that matches the type of the 'item' parameter.  Failing an exact 
        //  match of the type, return something that matches one of its parent 
        //  types.
        internal static object FindTemplateResourceInternal(DependencyObject target, object item, Type templateType) 
        {
            // Data styling doesn't apply to UIElement (bug 1007133).
            if (item == null || (item is UIElement))
            { 
                return null;
            } 
 
            object dataType;
            Type type = item.GetType(); 
            if (type.FullName == "System.Xml.Linq.XElement" &&
                (dataType = GetXLinqTagName(item, type)) != null)
            {
                type = null; 
            }
            else if (type.FullName.StartsWith("System.Xml", StringComparison.Ordinal) && 
                        (dataType = GetXmlTagName(item, target)) != null) 
            {
                type = null; 
            }
            else if (type == typeof(Object))
            {
                dataType = null;     // don't search for Object - perf 
            }
            else 
            { 
                dataType = type;
            } 

            ArrayList keys = new ArrayList();

            // construct the list of acceptable keys, in priority order 
            int exactMatch = -1;    // number of entries that count as an exact match
 
            // add compound keys for the dataType and all its base types 
            while (dataType != null)
            { 
                object key = null;
                if (templateType == typeof(DataTemplate))
                    key = new DataTemplateKey(dataType);
 
                if (key != null)
                    keys.Add(key); 
 
                // all keys added for the given item type itself count as an exact match
                if (exactMatch == -1) 
                    exactMatch = keys.Count;

                if (type != null)
                { 
                    type = type.BaseType;
                    if (type == typeof(Object))     // don't search for Object - perf 
                        type = null; 
                }
 
                dataType = type;
            }

            int bestMatch = keys.Count; // index of best match so far 

            // Search the parent chain 
            object resource = FindTemplateResourceInTree(target, keys, exactMatch, ref bestMatch); 

            if (bestMatch >= exactMatch) 
            {
                // Exact match not found in the parent chain.  Try App and System Resources.
                object appResource = Helper.FindTemplateResourceFromAppOrSystem(target, keys, exactMatch, ref bestMatch);
 
                if (appResource != null)
                    resource = appResource; 
            } 

            return resource; 
        }

        // Search the parent chain for a [Data|Table]Template in a ResourceDictionary.
        private static object FindTemplateResourceInTree(DependencyObject target, ArrayList keys, int exactMatch, ref int bestMatch) 
        {
            Debug.Assert(target != null, "Don't call FindTemplateResource with a null target object"); 
 
            ResourceDictionary table;
            object resource = null; 

            FrameworkObject fo = new FrameworkObject(target);
            Debug.Assert(fo.IsValid, "Don't call FindTemplateResource with a target object that is neither a FrameworkElement nor a FrameworkContentElement");
 
            while (fo.IsValid)
            { 
                object candidate; 

                // ------------------------------------------- 
                //  Lookup ResourceDictionary on the current instance
                // -------------------------------------------

                // Fetch the ResourceDictionary 
                // for the given target element
                table = GetInstanceResourceDictionary(fo.FE, fo.FCE); 
                if( table != null ) 
                {
                    candidate = FindBestMatchInResourceDictionary( table, keys, exactMatch, ref bestMatch ); 
                    if (candidate != null)
                    {
                        resource = candidate;
                        if (bestMatch < exactMatch) 
                        {
                            // Exact match found, stop here. 
                            return resource; 
                        }
                    } 
                }

                // -------------------------------------------
                //  Lookup ResourceDictionary on the current instance's Style, if one exists. 
                // -------------------------------------------
 
                table = GetStyleResourceDictionary(fo.FE, fo.FCE); 
                if( table != null )
                { 
                    candidate = FindBestMatchInResourceDictionary( table, keys, exactMatch, ref bestMatch );
                    if (candidate != null)
                    {
                        resource = candidate; 
                        if (bestMatch < exactMatch)
                        { 
                            // Exact match found, stop here. 
                            return resource;
                        } 
                    }
                }

                // ------------------------------------------- 
                //  Lookup ResourceDictionary on the current instance's Theme Style, if one exists.
                // ------------------------------------------- 
 
                table = GetThemeStyleResourceDictionary(fo.FE, fo.FCE);
                if( table != null ) 
                {
                    candidate = FindBestMatchInResourceDictionary( table, keys, exactMatch, ref bestMatch );
                    if (candidate != null)
                    { 
                        resource = candidate;
                        if (bestMatch < exactMatch) 
                        { 
                            // Exact match found, stop here.
                            return resource; 
                        }
                    }
                }
 
                // -------------------------------------------
                //  Lookup ResourceDictionary on the current instance's Template, if one exists. 
                // ------------------------------------------- 

                table = GetTemplateResourceDictionary(fo.FE, fo.FCE); 
                if( table != null )
                {
                    candidate = FindBestMatchInResourceDictionary( table, keys, exactMatch, ref bestMatch );
                    if (candidate != null) 
                    {
                        resource = candidate; 
                        if (bestMatch < exactMatch) 
                        {
                            // Exact match found, stop here. 
                            return resource;
                        }
                    }
                } 

                // If the current element for resource lookup is marked such then abort 
                // lookup because resource lookup does not span tree boundaries 
                if (fo.IsValid && TreeWalkHelper.SkipNext(fo.InheritanceBehavior))
                { 
                    break;
                }

                // ------------------------------------------- 
                //  Find the next parent instance to lookup
                // ------------------------------------------- 
 
                // Get Framework Parent
                fo = fo.FrameworkParent; 

                // If the next parent for resource lookup is marked such then abort
                // lookup because resource lookup does not span tree boundaries
                if (fo.IsValid && TreeWalkHelper.SkipNext(fo.InheritanceBehavior)) 
                {
                    break; 
                } 
            }
 
            return resource;
        }

        // Given a ResourceDictionary and a set of keys, try to find the best 
        //  match in the resource dictionary.
        private static object FindBestMatchInResourceDictionary( 
            ResourceDictionary table, ArrayList keys, int exactMatch, ref int bestMatch) 
        {
            object resource = null; 
            int k;

            // Search target element's ResourceDictionary for the resource
            if (table != null) 
            {
                for (k = 0;  k < bestMatch;  ++k) 
                { 
                    object candidate = table[keys[k]];
                    if (candidate != null) 
                    {
                        resource = candidate;
                        bestMatch = k;
 
                        // if we found an exact match, no need to continue
                        if (bestMatch < exactMatch) 
                            return resource; 
                    }
                } 
            }

            return resource;
        } 

        // Return a reference to the ResourceDictionary set on the instance of 
        //  the given Framework(Content)Element, if such a ResourceDictionary exists. 
        private static ResourceDictionary GetInstanceResourceDictionary(FrameworkElement fe, FrameworkContentElement fce)
        { 
            ResourceDictionary table = null;

            if (fe != null)
            { 
                if (fe.HasResources)
                { 
                    table = fe.Resources; 
                }
            } 
            else // (fce != null)
            {
                if (fce.HasResources)
                { 
                    table = fce.Resources;
                } 
            } 

            return table; 
        }

        // Return a reference to the ResourceDictionary attached to the Style of
        //  the given Framework(Content)Element, if such a ResourceDictionary exists. 
        private static ResourceDictionary GetStyleResourceDictionary(FrameworkElement fe, FrameworkContentElement fce)
        { 
            ResourceDictionary table = null; 

            if (fe != null) 
            {
#if DEBUG
                if( !fe.IsStyleUpdateInProgress )
                { 
#endif
                    if( fe.Style != null && 
                        fe.Style._resources != null ) 
                    {
                        table = fe.Style._resources; 
                    }
#if DEBUG
                }
#endif 
            }
            else // (fce != null) 
            { 
#if DEBUG
                if( !fce.IsStyleUpdateInProgress ) 
                {
#endif
                    if( fce.Style != null &&
                        fce.Style._resources != null ) 
                    {
                        table = fce.Style._resources; 
                    } 
#if DEBUG
                } 
#endif
            }

            return table; 
        }
 
        // Return a reference to the ResourceDictionary attached to the Theme Style of 
        //  the given Framework(Content)Element, if such a ResourceDictionary exists.
        private static ResourceDictionary GetThemeStyleResourceDictionary(FrameworkElement fe, FrameworkContentElement fce) 
        {
            ResourceDictionary table = null;

            if (fe != null) 
            {
#if DEBUG 
                if( !fe.IsThemeStyleUpdateInProgress ) 
                {
#endif 
                    if( fe.ThemeStyle != null &&
                        fe.ThemeStyle._resources != null )
                    {
                        table = fe.ThemeStyle._resources; 
                    }
#if DEBUG 
                } 
#endif
            } 
            else // (fce != null)
            {
#if DEBUG
                if( !fce.IsThemeStyleUpdateInProgress ) 
                {
#endif 
                    if( fce.ThemeStyle != null && 
                        fce.ThemeStyle._resources != null )
                    { 
                        table = fce.ThemeStyle._resources;
                    }
#if DEBUG
                } 
#endif
            } 
 
            return table;
        } 

        // Return a reference to the ResourceDictionary attached to the Template of
        //  the given Framework(Content)Element, if such a ResourceDictionary exists.
        private static ResourceDictionary GetTemplateResourceDictionary(FrameworkElement fe, FrameworkContentElement fce) 
        {
            ResourceDictionary table = null; 
 
            if (fe != null)
            { 
                if( fe.TemplateInternal != null &&
                    fe.TemplateInternal._resources != null )
                {
                    table = fe.TemplateInternal._resources; 
                }
            } 
 
            return table;
        } 

        // return true if there is a local or style-supplied value for the dp
        internal bool HasNonDefaultValue(DependencyProperty dp)
        { 
            return !Helper.HasDefaultValue(dp, this, this/*fe*/, null/*fce*/);
        } 
 
        // Finds the nearest NameScope by walking up the logical tree
        internal static INameScope FindScope(DependencyObject d) 
        {
            DependencyObject scopeOwner;
            return FindScope(d, out scopeOwner);
        } 

        // Finds the nearest NameScope by walking up the logical tree 
        internal static INameScope FindScope(DependencyObject d, out DependencyObject scopeOwner) 
        {
            while (d != null) 
            {
                INameScope nameScope = NameScope.NameScopeFromObject(d);
                if (nameScope != null)
                { 
                    scopeOwner = d;
                    return nameScope; 
                } 

                DependencyObject parent = LogicalTreeHelper.GetParent(d); 

                d = (parent != null) ? parent : Helper.FindMentor(d.InheritanceContext);
            }
 
            scopeOwner = null;
            return null; 
        } 

        // separate function to avoid loading System.Xml until we have a good reason 
        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
        private static string GetXmlTagName(object item, DependencyObject target)
        {
            System.Xml.XmlNode node = item as System.Xml.XmlNode; 
            if (node != null)
            { 
                XmlNamespaceManager namespaceManager = GetXmlNamespaceManager(target); 
                if (namespaceManager != null)
                { 
                    string prefix = namespaceManager.LookupPrefix(node.NamespaceURI);
                    if (prefix != string.Empty)
                        return string.Concat(prefix, ":", node.LocalName);
                } 

                return node.Name; 
            } 
            return null;
        } 

        // In WPF 3.5 we cannot refer to XLinq classes directly, so we
        // have to use reflection to find out what we need.
        private static string GetXLinqTagName(object item, Type type) 
        {
            // get the accessor for the XElement.Name property 
            if (XElement_Name_PropertyInfo == null) 
            {
                XElement_Name_PropertyInfo = type.GetProperty("Name", 
                                BindingFlags.Instance | BindingFlags.Public);
            }

            // get the value of the Name property (of type XName), and convert 
            // it to a string (of the form "{http://my.namespace}TagName")
            if (XElement_Name_PropertyInfo != null) 
            { 
                object value = XElement_Name_PropertyInfo.GetValue(item, null);
                if (value != null) 
                    return value.ToString();
            }

            return null; 
        }
 
        // find the appropriate namespace manager for the given element 
        private static XmlNamespaceManager GetXmlNamespaceManager(DependencyObject target)
        { 
            XmlNamespaceManager nsmgr = Binding.GetXmlNamespaceManager(target);

            if (nsmgr == null)
            { 
                XmlDataProvider xdp = Helper.XmlDataProviderForElement(target);
                nsmgr = (xdp != null) ? xdp.XmlNamespaceManager : null; 
            } 

            return nsmgr; 
        }

        /// 
        ///     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 FrameworkElement 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;
        }

 
        /// 
        ///     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);
        }

        internal void GetRawValue(DependencyProperty dp, PropertyMetadata metadata, ref EffectiveValueEntry entry) 
        {
            // Queries to FrameworkElement will automatically fault in the Style 
 
            // If a value was resolved by base, return that.
            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 
            // (Style already initialized by ParentChainStyleInitialization above)
            //

            // 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(this, null), 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;
 
            // Metadata must exist specifically stating to group or inherit
            // 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) 
                {
                    object value = GetInheritableValue(dp, fmetadata); 

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

            // No value found.
            Debug.Assert(entry.Value == DependencyProperty.UnsetValue,"FrameworkElement.GetRawValue should never fall through with a value != DependencyProperty.UnsetValue.  We're supposed to return as soon as we found something."); 
        }
 
 

        // 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; 
            Debug.Assert( IsTemplatedParentAnFE ); 

            FrameworkElement feTemplatedParent = (FrameworkElement)_templatedParent; 
            frameworkTemplate = feTemplatedParent.TemplateInternal;

            if (frameworkTemplate != null)
            { 
                return StyleHelper.GetValueFromTemplatedParent(
                        _templatedParent, 
                        TemplateChildIndex, 
                        new FrameworkObject(this, null),
                        dp, 
                    ref frameworkTemplate.ChildRecordFromChildIndex,
                        frameworkTemplate.VisualTree,
                    ref entry);
            } 
            return false;
        } 
 
        // Climb the framework tree hierarchy and see if we can pick up an
        //  inheritable property value somewhere in that parent chain. 
        //[CodeAnalysis("AptcaMethodsShouldOnlyCallAptcaMethods")] //Tracking Bug: 29647
        private object GetInheritableValue(DependencyProperty dp, FrameworkPropertyMetadata fmetadata)
        {
            // 
            // Inheritance
            // 
 
            if (!TreeWalkHelper.SkipNext(InheritanceBehavior) || fmetadata.OverridesInheritanceBehavior == true)
            { 
                // Used to terminate tree walk if a tree boundary is hit
                InheritanceBehavior inheritanceBehavior = InheritanceBehavior.Default;

                FrameworkContentElement parentFCE; 
                FrameworkElement parentFE;
                bool hasParent = 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.Flags.performance, EventTrace.Level.verbose))
                        { 
                            string TypeAndName = String.Format(CultureInfo.InvariantCulture, "[{0}]{1}({2})",GetType().Name,dp.Name,base.GetHashCode());
                            EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.PROPERTYPARENTCHECKGUID), 
                                                                 MS.Utility.EventType.Info, 
                                                                 base.GetHashCode(), TypeAndName ); // base.GetHashCode() to avoid calling a virtual, which FxCop doesn't like.
                        } 
#endregion EventTracing

                        DependencyObject parentDO = parentFE;
                        if (parentDO == null) 
                        {
                            parentDO = parentFCE; 
                        } 

                        EntryIndex entryIndex = parentDO.LookupEntry(dp.GlobalIndex); 

                        return parentDO.GetValueEntry(
                                        entryIndex,
                                        dp, 
                                        fmetadata,
                                        RequestFlags.SkipDefault | RequestFlags.DeferredReferences).Value; 
                    } 

                    // 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 = GetFrameworkParent(parentFE, out parentFE, out parentFCE);
                    }
                    else
                    { 
                        hasParent = GetFrameworkParent(parentFCE, out parentFE, out parentFCE);
                    } 
                } 
            }
 
            // Didn't find this value anywhere in the framework tree parent chain,
            //  or search was aborted when we hit a tree boundary node.
            return DependencyProperty.UnsetValue;
        } 

        // 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();
                }

                // 
                // Invalidation propagation for Styles
                // 
 
                // Regardless of metadata, the Style/Template/DefaultStyleKey properties are never a trigger drivers
                if (dp != StyleProperty && dp != Control.TemplateProperty && 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 /*sourceChildIndex*/); // 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)
                    if (TemplateInternal != null) 
                    {
                        StyleHelper.OnTriggerSourcePropertyInvalidated(null, TemplateInternal, this, dp, e, !HasTemplateGeneratedSubTree /*invalidateOnlyContainer*/, 
                            ref TemplateInternal.TriggerSourceRecordFromChildIndex, ref TemplateInternal.PropertyTriggersWithActions, 0 /*sourceChildIndex*/); // These are driven by the container 
                    }
 
                    // 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)
                    {
                        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( e.OperationType != OperationType.AddChild && 
                            e.OperationType != OperationType.RemoveChild &&
                            e.OperationType != OperationType.Inherit) 
                        {
                            TreeWalkHelper.InvalidateOnInheritablePropertyChange(this, null, info, true);
                        }
 
                        // Notify mentees if they exist
                        if (PotentiallyHasMentees) 
                        { 
                            TreeWalkHelper.OnInheritedPropertyChanged(this, ref info, InheritanceBehavior);
                        } 
                    }
                }

                if (e.IsAValueChange || e.IsASubPropertyChange) 
                {
                    // 
                    // Layout invalidation 
                    //
 
                    // Skip if we're traversing an Visibility=Collapsed subtree while
                    //  in the middle of an invalidation storm due to ancestor change
                    if( !(AncestorChangeInProgress && InVisibilityCollapsedTree) )
                    { 
                        UIElement layoutParent = null;
 
                        bool affectsParentMeasure = fmetadata.AffectsParentMeasure; 
                        bool affectsParentArrange = fmetadata.AffectsParentArrange;
                        bool affectsMeasure = fmetadata.AffectsMeasure; 
                        bool affectsArrange = fmetadata.AffectsArrange;
                        if (affectsMeasure || affectsArrange || affectsParentArrange || affectsParentMeasure)
                        {
                            // Locate nearest Layout parent 
                            for (Visual v = VisualTreeHelper.GetParent(this) as Visual;
                                 v != null; 
                                 v = VisualTreeHelper.GetParent(v) as Visual) 
                            {
                                layoutParent = v as UIElement; 
                                if (layoutParent != null)
                                {
                                    //let incrementally-updating FrameworkElements to mark the vicinity of the affected child
                                    //to perform partial update. 
                                    if(FrameworkElement.DType.IsInstanceOfType(layoutParent))
                                        ((FrameworkElement)layoutParent).ParentLayoutInvalidated(this); 
 
                                    if (affectsParentMeasure)
                                    { 
                                        layoutParent.InvalidateMeasure();
                                    }

                                    if (affectsParentArrange) 
                                    {
                                        layoutParent.InvalidateArrange(); 
                                    } 

                                    break; 
                                }
                            }
                        }
 
                        if (fmetadata.AffectsMeasure)
                        { 
                            // 

 

                            if (!BypassLayoutPolicies || !((dp == WidthProperty) || (dp == HeightProperty)))
                            {
                                InvalidateMeasure(); 
                            }
                        } 
 
                        if (fmetadata.AffectsArrange)
                        { 
                            InvalidateArrange();
                        }

                        if (fmetadata.AffectsRender && 
                            (e.IsAValueChange || !fmetadata.SubPropertiesDoNotAffectRender))
                        { 
                            InvalidateVisual(); 
                        }
                    } 
                }
            }
        }
 
        //
        // Get the closest Framework type up the logical or physical tree 
        // 
        // (Shared between FrameworkElement and FrameworkContentElement)
        // 
        internal static DependencyObject GetFrameworkParent(object current)
        {
            FrameworkObject fo = new FrameworkObject(current as DependencyObject);
 
            fo = fo.FrameworkParent;
 
            return fo.DO; 
        }
 
        internal static bool GetFrameworkParent(FrameworkElement current, out FrameworkElement feParent, out FrameworkContentElement fceParent)
        {
            FrameworkObject fo = new FrameworkObject(current, null);
 
            fo = fo.FrameworkParent;
 
            feParent = fo.FE; 
            fceParent = fo.FCE;
 
            return fo.IsValid;
        }

 
        internal static bool GetFrameworkParent(FrameworkContentElement current, out FrameworkElement feParent, out FrameworkContentElement fceParent)
        { 
            FrameworkObject fo = new FrameworkObject(null, current); 

            fo = fo.FrameworkParent; 

            feParent = fo.FE;
            fceParent = fo.FCE;
 
            return fo.IsValid;
        } 
 
        internal static bool GetContainingFrameworkElement(DependencyObject current, out FrameworkElement fe, out FrameworkContentElement fce)
        { 
            FrameworkObject fo = FrameworkObject.GetContainingFrameworkElement(current);

            if (fo.IsValid)
            { 
                fe = fo.FE;
                fce = fo.FCE; 
                return true; 
            }
            else 
            {
                fe = null;
                fce = null;
                return false; 
            }
        } 
 

        // Fetchs the specified childRecord for the given template.  Returns true if successful. 
        internal static void GetTemplatedParentChildRecord(
            DependencyObject templatedParent,
            int childIndex,
            out ChildRecord childRecord, 
            out bool isChildRecordValid)
        { 
            FrameworkTemplate templatedParentTemplate = null; 
            isChildRecordValid = false;
            childRecord = new ChildRecord();    // CS0177 

            if (templatedParent != null)
            {
                FrameworkObject foTemplatedParent = new FrameworkObject(templatedParent, true); 

                Debug.Assert( foTemplatedParent.IsFE ); 
 
                // This node is the result of a style expansion
 
                // Pick the owner for the VisualTree that generated this node
                templatedParentTemplate = foTemplatedParent.FE.TemplateInternal;

                Debug.Assert(templatedParentTemplate != null , 
                    "If this node is the result of a VisualTree expansion then it should have a parent template");
 
                // Check if this Child Index is represented in FrameworkTemplate 
                if (templatedParentTemplate != null && ((0 <= childIndex) && (childIndex < templatedParentTemplate.ChildRecordFromChildIndex.Count)))
                { 
                    childRecord = templatedParentTemplate.ChildRecordFromChildIndex[childIndex];
                    isChildRecordValid = true;
                }
 
            }
        } 
 
        /// 
        ///     Return the text that represents this object, from the User's perspective. 
        /// 
        /// 
        internal virtual string GetPlainText()
        { 
            return null;
        } 
 

        static FrameworkElement() 
        {
            SnapsToDevicePixelsProperty.OverrideMetadata(_typeofThis, new FrameworkPropertyMetadata(BooleanBoxes.FalseBox, FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsArrange));

            EventManager.RegisterClassHandler(_typeofThis, Mouse.QueryCursorEvent, new QueryCursorEventHandler(FrameworkElement.OnQueryCursorOverride), true); 

            EventManager.RegisterClassHandler(_typeofThis, Keyboard.PreviewGotKeyboardFocusEvent, new KeyboardFocusChangedEventHandler(OnPreviewGotKeyboardFocus)); 
            EventManager.RegisterClassHandler(_typeofThis, Keyboard.GotKeyboardFocusEvent, new KeyboardFocusChangedEventHandler(OnGotKeyboardFocus)); 
            EventManager.RegisterClassHandler(_typeofThis, Keyboard.LostKeyboardFocusEvent, new KeyboardFocusChangedEventHandler(OnLostKeyboardFocus));
 
            AllowDropProperty.OverrideMetadata(_typeofThis, new FrameworkPropertyMetadata(BooleanBoxes.FalseBox, FrameworkPropertyMetadataOptions.Inherits));

            Stylus.IsPressAndHoldEnabledProperty.AddOwner(_typeofThis, new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, FrameworkPropertyMetadataOptions.Inherits));
            Stylus.IsFlicksEnabledProperty.AddOwner(_typeofThis, new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, FrameworkPropertyMetadataOptions.Inherits)); 
            Stylus.IsTapFeedbackEnabledProperty.AddOwner(_typeofThis, new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, FrameworkPropertyMetadataOptions.Inherits));
            Stylus.IsTouchFeedbackEnabledProperty.AddOwner(_typeofThis, new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, FrameworkPropertyMetadataOptions.Inherits)); 
 
            PropertyChangedCallback numberSubstitutionChanged = new PropertyChangedCallback(NumberSubstitutionChanged);
            NumberSubstitution.CultureSourceProperty.OverrideMetadata(_typeofThis, new FrameworkPropertyMetadata(NumberCultureSource.User, FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsRender, numberSubstitutionChanged)); 
            NumberSubstitution.CultureOverrideProperty.OverrideMetadata(_typeofThis, new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsRender, numberSubstitutionChanged));
            NumberSubstitution.SubstitutionProperty.OverrideMetadata(_typeofThis, new FrameworkPropertyMetadata(NumberSubstitutionMethod.AsCulture, FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsRender, numberSubstitutionChanged));

            // Exposing these events in protected virtual methods 
            EventManager.RegisterClassHandler(_typeofThis, ToolTipOpeningEvent, new ToolTipEventHandler(OnToolTipOpeningThunk));
            EventManager.RegisterClassHandler(_typeofThis, ToolTipClosingEvent, new ToolTipEventHandler(OnToolTipClosingThunk)); 
            EventManager.RegisterClassHandler(_typeofThis, ContextMenuOpeningEvent, new ContextMenuEventHandler(OnContextMenuOpeningThunk)); 
            EventManager.RegisterClassHandler(_typeofThis, ContextMenuClosingEvent, new ContextMenuEventHandler(OnContextMenuClosingThunk));
 
            // Coerce Callback for font properties for responding to system themes
            TextElement.FontFamilyProperty.OverrideMetadata(_typeofThis, new FrameworkPropertyMetadata(SystemFonts.MessageFontFamily, FrameworkPropertyMetadataOptions.Inherits, null, new CoerceValueCallback(CoerceFontFamily)));
            TextElement.FontSizeProperty.OverrideMetadata(_typeofThis, new FrameworkPropertyMetadata(SystemFonts.MessageFontSize, FrameworkPropertyMetadataOptions.Inherits, null, new CoerceValueCallback(CoerceFontSize)));
            TextElement.FontStyleProperty.OverrideMetadata(_typeofThis, new FrameworkPropertyMetadata(SystemFonts.MessageFontStyle, FrameworkPropertyMetadataOptions.Inherits, null, new CoerceValueCallback(CoerceFontStyle))); 
            TextElement.FontWeightProperty.OverrideMetadata(_typeofThis, new FrameworkPropertyMetadata(SystemFonts.MessageFontWeight, FrameworkPropertyMetadataOptions.Inherits, null, new CoerceValueCallback(CoerceFontWeight)));
        } 
 
        internal static readonly NumberSubstitution DefaultNumberSubstitution = new NumberSubstitution(
            NumberCultureSource.User,           // number substitution in UI defaults to user culture 
            null,                               // culture override
            NumberSubstitutionMethod.AsCulture
            );
 
        /// 
        ///     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()
        {
        } 

        ///  
        /// OnVisualParentChanged is called when the parent of the Visual is changed. 
        /// 
        /// Old parent or null if the Visual did not have a parent before. 
        protected internal override void OnVisualParentChanged(DependencyObject oldParent)
        {
            DependencyObject newParent = VisualTreeHelper.GetParentInternal(this);
 
            // Visual parent implies no InheritanceContext
            if (newParent != null) 
            { 
                ClearInheritanceContext();
            } 

            // Update HasLoadedChangeHandler Flag
            BroadcastEventHelper.AddOrRemoveHasLoadedChangeHandlerFlag(this, oldParent, newParent);
 
            // Fire Loaded and Unloaded Events
            BroadcastEventHelper.BroadcastLoadedOrUnloadedEvent(this, oldParent, newParent); 
 
            if (newParent != null && (newParent is FrameworkElement) == false)
            { 
                // If you are being connected to a non-FE parent then start listening for VisualAncestor
                // changes because otherwise you won't know about changes happening above you
                Visual newParentAsVisual = newParent as Visual;
                if (newParentAsVisual != null) 
                {
                    newParentAsVisual.VisualAncestorChanged += new AncestorChangedEventHandler(OnVisualAncestorChanged); 
                } 
                else if (newParent is Visual3D)
                { 
                    ((Visual3D)newParent).VisualAncestorChanged += new Visual.AncestorChangedEventHandler(OnVisualAncestorChanged);
                }
            }
            else if (oldParent != null && (oldParent is FrameworkElement) == false) 
            {
                // If you are being disconnected from a non-FE parent then stop listening for 
                // VisualAncestor changes 
                Visual oldParentAsVisual = oldParent as Visual;
                if (oldParentAsVisual != null) 
                {
                    oldParentAsVisual.VisualAncestorChanged -= new AncestorChangedEventHandler(OnVisualAncestorChanged);
                }
                else if (oldParent is Visual3D) 
                {
                    ((Visual3D)oldParent).VisualAncestorChanged -= new Visual.AncestorChangedEventHandler(OnVisualAncestorChanged); 
                } 
            }
 
            // Do it only if you do not have a logical parent
            if (Parent == null)
            {
                // Invalidate relevant properties for this subtree 
                DependencyObject parent = (newParent != null) ? newParent : oldParent;
                TreeWalkHelper.InvalidateOnTreeChange(this, null, parent, (newParent != null)); 
            } 

            // Initialize, if not already done. 

            // Note that it is for performance reasons that we TryFireInitialize after
            // we have done InvalidateOnTreeChange. This is because InvalidateOnTreeChange
            // invalidates the style property conditionally if the object has been initialized. 
            // And OnInitialized also invalidates the style property. If we were to do these
            // operations in the reverse order we would be invalidating the style property twice. 
            // Whereas now we do it only once. 

            TryFireInitialized(); 

            base.OnVisualParentChanged(oldParent);
        }
 
        internal new void OnVisualAncestorChanged(object sender, AncestorChangedEventArgs e)
        { 
            // NOTE: 
            //
            // We are forced to listen to AncestorChanged events because a FrameworkElement 
            // may have raw Visuals/UIElements between it and its nearest FrameworkElement
            // parent.  We only care about changes that happen to the visual tree BETWEEN
            // this FrameworkElement and its nearest FrameworkElement parent.  This is
            // because we can rely on our nearest FrameworkElement parent to notify us 
            // when its loaded state changes.
 
            FrameworkElement feParent = null; 
            FrameworkContentElement fceParent = null;
 
            // Find our nearest FrameworkElement parent.
            FrameworkElement.GetContainingFrameworkElement(VisualTreeHelper.GetParent(this), out feParent, out fceParent);
            Debug.Assert(fceParent == null, "Nearest framework parent via the visual tree has to be an FE. It cannot be an FCE");
 
            if(e.OldParent == null)
            { 
                // We were plugged into something. 

                // See if this parent is a child of the ancestor who's parent changed. 
                // If so, we don't care about changes that happen above us.
                if(feParent == null || !VisualTreeHelper.IsAncestorOf(e.Ancestor, feParent))
                {
                    // Update HasLoadedChangeHandler Flag 
                    BroadcastEventHelper.AddOrRemoveHasLoadedChangeHandlerFlag(this, null, VisualTreeHelper.GetParent(e.Ancestor));
 
                    // Fire Loaded and Unloaded Events 
                    BroadcastEventHelper.BroadcastLoadedOrUnloadedEvent(this, null, VisualTreeHelper.GetParent(e.Ancestor));
                } 
            }
            else
            {
                // we were unplugged from something. 

                // If we found a FrameworkElement parent in our subtree, the 
                // break in the visual tree must have been above it, 
                // so we don't need to respond.
 
                if(feParent == null)
                {
                    // There was no FrameworkElement parent in our subtree, so we
                    // may be detaching from some FrameworkElement parent above 
                    // the break point in the tree.
                    FrameworkElement.GetContainingFrameworkElement(e.OldParent, out feParent, out fceParent); 
 
                    if(feParent != null)
                    { 
                        // Update HasLoadedChangeHandler Flag
                        BroadcastEventHelper.AddOrRemoveHasLoadedChangeHandlerFlag(this, feParent, null);

                        // Fire Loaded and Unloaded Events 
                        BroadcastEventHelper.BroadcastLoadedOrUnloadedEvent(this, feParent, null);
                    } 
                } 
            }
        } 

        /// 
        ///     Indicates the current mode of lookup for both inheritance and resources.
        ///  
        /// 
        ///     Used in property inheritance and reverse 
        ///     inheritance 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. 
        /// 
        protected 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 FE 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:*/this, /*fce:*/null, _parent, true);
                    }
                } 
                else
                { 
                    throw new InvalidOperationException(SR.Get(SRID.Illegal_InheritanceBehaviorSettor)); 
                }
            } 
        }


        #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 =
                    DependencyProperty.Register(
                                "DataContext",
                                typeof(object), 
                                _typeofThis,
                                new FrameworkPropertyMetadata(null, 
                                        FrameworkPropertyMetadataOptions.Inherits, 
                                        new PropertyChangedCallback(OnDataContextChanged)));
 
        /// 
        ///     DataContextChanged private key
        /// 
        internal static readonly EventPrivateKey DataContextChangedKey = new EventPrivateKey(); 

        ///  
        ///     DataContextChanged event 
        /// 
        ///  
        ///     When an element's DataContext changes, all data-bound properties
        ///     (on this element or any other element) whose Bindings 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(DataContextChangedKey, value); }
            remove { EventHandlersStoreRemove(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)
        { 
            ((FrameworkElement) d).RaiseDependencyPropertyChanged(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 the 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 = 
                    DependencyProperty.Register(
                                "BindingGroup", 
                                typeof(BindingGroup), 
                                _typeofThis,
                                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
 
 
        /// 
        ///     Returns a non-null value when some framework implementation 
        ///     of this method has a non-visual parent connection,
        /// 
        protected internal override DependencyObject GetUIParentCore()
        { 
            // Note: this only follows one logical link.
            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)
        {
        }
 
        /// 
        ///     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 bool BuildRouteCore(EventRoute route, RoutedEventArgs args)
        { 
            return BuildRouteCoreHelper(route, args, true);
        } 
        internal bool BuildRouteCoreHelper(EventRoute route, RoutedEventArgs args, bool shouldAddIntermediateElementsToRoute) 
        {
            bool continuePastCoreTree = false; 

            DependencyObject visualParent = VisualTreeHelper.GetParent(this);
            DependencyObject modelParent = GetUIParentCore();
 
            // 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
                if (shouldAddIntermediateElementsToRoute) 
                {
                    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)
                { 
                    Visual visualParentAsVisual = visualParent as Visual;
                    if (visualParentAsVisual != null) 
                    { 
                        if (visualParentAsVisual.CheckFlagsAnd(VisualFlags.IsLayoutIslandRoot))
                        { 
                            continuePastCoreTree = true;
                        }
                    }
                    else 
                    {
                        if (((Visual3D)visualParent).CheckFlagsAnd(VisualFlags.IsLayoutIslandRoot)) 
                        { 
                            continuePastCoreTree = true;
                        } 
                    }

                    // 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) 
        {
            AddStyleHandlersToEventRoute(this, null, route, args);
        }
 
        // Add Style TargetType and FEF EventHandlers to the EventRoute
        internal static void AddStyleHandlersToEventRoute( 
            FrameworkElement fe, 
            FrameworkContentElement fce,
            EventRoute route, 
            RoutedEventArgs args)
        {
            Debug.Assert(fe != null || fce != null);
 
            DependencyObject source = (fe != null) ? (DependencyObject)fe : (DependencyObject)fce;
            Style selfStyle = null; 
            FrameworkTemplate selfFrameworkTemplate = null; 
            DependencyObject templatedParent = null;
            int templateChildIndex = -1; 

            // Fetch selfStyle, TemplatedParent and TemplateChildIndex
            if (fe != null)
            { 
                selfStyle = fe.Style;
                selfFrameworkTemplate = fe.TemplateInternal; 
                templatedParent = fe.TemplatedParent; 
                templateChildIndex = fe.TemplateChildIndex;
            } 
            else
            {
                selfStyle = fce.Style;
                templatedParent = fce.TemplatedParent; 
                templateChildIndex = fce.TemplateChildIndex;
            } 
 
            // Add TargetType EventHandlers to the route. Notice that ThemeStyle
            // cannot have EventHandlers and hence are ignored here. 
            RoutedEventHandlerInfo[] handlers = null;
            if (selfStyle != null && selfStyle.EventHandlersStore != null)
            {
                handlers = selfStyle.EventHandlersStore.GetRoutedEventHandlers(args.RoutedEvent); 
                AddStyleHandlersToEventRoute(route, source, handlers);
            } 
            if (selfFrameworkTemplate != null && selfFrameworkTemplate.EventHandlersStore != null) 
            {
                handlers = selfFrameworkTemplate.EventHandlersStore.GetRoutedEventHandlers(args.RoutedEvent); 
                AddStyleHandlersToEventRoute(route, source, handlers);
            }

            if (templatedParent != null) 
            {
                FrameworkTemplate templatedParentTemplate = null; 
 
                FrameworkElement feTemplatedParent = templatedParent as FrameworkElement;
                Debug.Assert( feTemplatedParent != null ); 

                templatedParentTemplate = feTemplatedParent.TemplateInternal;

                // Fetch handlers from either the parent style or template 
                handlers = null;
                if (templatedParentTemplate != null && templatedParentTemplate.HasEventDependents) 
                { 
                    handlers = StyleHelper.GetChildRoutedEventHandlers(templateChildIndex, args.RoutedEvent, ref templatedParentTemplate.EventDependents);
                } 

                // Add FEF EventHandlers to the route
                AddStyleHandlersToEventRoute(route, source, handlers);
            } 
        }
 
        // This is a helper that will facilitate adding a given array of handlers to the route 
        private static void AddStyleHandlersToEventRoute(
            EventRoute route, 
            DependencyObject source,
            RoutedEventHandlerInfo[] handlers)
        {
            if (handlers != null) 
            {
                for (int i=0; i
        /// 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 = 
                    DependencyProperty.RegisterAttached( 
                                "Language",
                                typeof(XmlLanguage), 
                                _typeofThis,
                                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 
 
        /// 
        ///     The DependencyProperty for the Name property. 
        /// 
        [CommonDependencyProperty]
        public static readonly DependencyProperty NameProperty =
                    DependencyProperty.Register( 
                                "Name",
                                typeof(string), 
                                _typeofThis, 
                                new FrameworkPropertyMetadata(
                                    string.Empty,                           // defaultValue 
                                    FrameworkPropertyMetadataOptions.None,  // flags
                                    null,                                   // propertyChangedCallback
                                    null,                                   // coerceValueCallback
                                    true),                                  // isAnimationProhibited 
                                new ValidateValueCallback(System.Windows.Markup.NameValidationHelper.NameValidationCallback));
 
        ///  
        ///     Name property.
        ///  
        [Localizability(LocalizationCategory.NeverLocalize)]
        [MergableProperty(false)]
        [DesignerSerializationOptions(DesignerSerializationOptions.SerializeAsAttribute)]
        public string Name 
        {
            get { return (string) GetValue(NameProperty); } 
            set { SetValue(NameProperty, value);  } 
        }
 
        /// 
        ///     The DependencyProperty for the Tag property.
        /// 
        public static readonly DependencyProperty TagProperty = 
                    DependencyProperty.Register(
                                "Tag", 
                                typeof(object), 
                                _typeofThis,
                                new FrameworkPropertyMetadata((object) null)); 

        /// 
        ///     Tag property.
        ///  
        [Localizability(LocalizationCategory.NeverLocalize)]
        public object Tag 
        { 
            get { return GetValue(TagProperty); }
            set { SetValue(TagProperty, value); } 
        }

        #region InputScope
 
        /// 
        ///     InputScope DependencyProperty 
        ///     this is originally registered on InputMethod class 
        /// 
        public static readonly DependencyProperty InputScopeProperty = 
                    InputMethod.InputScopeProperty.AddOwner(_typeofThis,
                                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
 
        ///  
        /// RequestBringIntoView Event
        ///  
        public static readonly RoutedEvent RequestBringIntoViewEvent = EventManager.RegisterRoutedEvent("RequestBringIntoView", RoutingStrategy.Bubble, typeof(RequestBringIntoViewEventHandler), _typeofThis);

        /// 
        /// Handler registration for RequestBringIntoView event. 
        /// 
        public event RequestBringIntoViewEventHandler RequestBringIntoView 
        { 
            add { AddHandler(RequestBringIntoViewEvent, value, false); }
            remove { RemoveHandler(RequestBringIntoViewEvent, value); } 
        }

        /// 
        /// Attempts to bring this element into view by originating a RequestBringIntoView event. 
        /// 
        public void BringIntoView() 
        { 
            //dmitryt, bug 1126518. On new/updated elements RenderSize isn't yet computed
            //so we need to postpone the rect computation until layout is done. 
            //this is accomplished by passing Empty rect here and then asking for RenderSize
            //in IScrollInfo when it actually executes an async MakeVisible command.
            BringIntoView( /*RenderSize*/ Rect.Empty);
        } 

        ///  
        /// Attempts to bring the given rectangle of this element into view by originating a RequestBringIntoView event. 
        /// 
        public void BringIntoView(Rect targetRectangle) 
        {
            RequestBringIntoViewEventArgs args = new RequestBringIntoViewEventArgs(this, targetRectangle);
            args.RoutedEvent=RequestBringIntoViewEvent;
            RaiseEvent(args); 
        }
 
 
        /// 
        /// SizeChanged event 
        /// 
        public static readonly RoutedEvent SizeChangedEvent = EventManager.RegisterRoutedEvent("SizeChanged", RoutingStrategy.Direct, typeof(SizeChangedEventHandler), _typeofThis);

        ///  
        /// SizeChanged event. It is fired when ActualWidth or ActualHeight (or both) changed.
        /// SizeChangedEventArgs parameter contains new and 
        /// old sizes, and flags indicating whether Width or Height actually changed.  
        /// These flags are provided to avoid common mistake of comparing new and old values
        /// since simple compare of double-precision numbers can yield "not equal" when size in fact 
        /// didn't change (round off errors accumulated during input processing and layout calculations
        /// may result in very small differencies that are considered "the same layout").
        /// 
        public event SizeChangedEventHandler SizeChanged 
        {
            add {AddHandler(SizeChangedEvent, value, false);} 
            remove {RemoveHandler(SizeChangedEvent, value);} 
        }
 
        private static PropertyMetadata _actualWidthMetadata = new ReadOnlyFrameworkPropertyMetadata(0d, new GetReadOnlyValueCallback(GetActualWidth));

        /// 
        ///     The key needed set a read-only property. 
        /// 
        private static readonly DependencyPropertyKey ActualWidthPropertyKey = 
                DependencyProperty.RegisterReadOnly( 
                        "ActualWidth",
                        typeof(double), 
                        _typeofThis,
                        _actualWidthMetadata);

        private static object GetActualWidth(DependencyObject d, out BaseValueSourceInternal source) 
        {
            FrameworkElement fe = (FrameworkElement) d; 
            if (fe.HasWidthEverChanged) 
            {
                source = BaseValueSourceInternal.Local; 
                return fe.RenderSize.Width;
            }
            else
            { 
                source = BaseValueSourceInternal.Default;
                return 0d; 
            } 
        }
 
        /// 
        /// The ActualWidth dynamic property.
        /// 
        public static readonly DependencyProperty ActualWidthProperty = 
                ActualWidthPropertyKey.DependencyProperty;
 
        ///  
        /// The ActualWidth CLR property - wrapper for ActualWidthProperty.
        /// Result in 1/96th inch. ("device-independent pixel") 
        /// 
        public double ActualWidth
        {
            get 
            {
                return RenderSize.Width; 
            } 
        }
 
        private static PropertyMetadata _actualHeightMetadata = new ReadOnlyFrameworkPropertyMetadata(0d, new GetReadOnlyValueCallback(GetActualHeight));

        /// 
        ///     The key needed set a read-only property. 
        /// 
        private static readonly DependencyPropertyKey ActualHeightPropertyKey = 
                DependencyProperty.RegisterReadOnly( 
                        "ActualHeight",
                        typeof(double), 
                        _typeofThis,
                        _actualHeightMetadata);

        private static object GetActualHeight(DependencyObject d, out BaseValueSourceInternal source) 
        {
            FrameworkElement fe = (FrameworkElement) d; 
            if (fe.HasHeightEverChanged) 
            {
                source = BaseValueSourceInternal.Local; 
                return fe.RenderSize.Height;
            }
            else
            { 
                source = BaseValueSourceInternal.Default;
                return 0d; 
            } 
        }
 
        /// 
        /// The ActualHeight dynamic property.
        /// 
        public static readonly DependencyProperty ActualHeightProperty = 
                ActualHeightPropertyKey.DependencyProperty;
 
        ///  
        /// The ActualHeight CLR property - wrapper for ActualHeightProperty.
        /// Result in 1/96th inch. ("device-independent pixel") 
        /// 
        public double ActualHeight
        {
            get 
            {
                return RenderSize.Height; 
            } 
        }
 
        /// 
        /// The LayoutTransform dependency property.
        /// 
        public static readonly DependencyProperty LayoutTransformProperty = DependencyProperty.Register( 
                    "LayoutTransform",
                    typeof(Transform), 
                    _typeofThis, 
                    new FrameworkPropertyMetadata(
                            Transform.Identity, 
                            FrameworkPropertyMetadataOptions.AffectsMeasure,
                            new PropertyChangedCallback(OnLayoutTransformChanged)));

        ///  
        ///  The LayoutTransform property defines the transform that will be
        ///  applied to the element during layout. In contrast to RenderTransform, LayoutTransform does affect 
        ///  results of layout, and provides powerful capabilities of scaling and rotating. At the same time, the 
        ///  LayoutTransform does not support Translate operation since it auto-compensate any offsets to position
        ///  sclaed/rotated element into layout partition created by the parent Panel. 
        /// 
        public Transform LayoutTransform
        {
            get { return (Transform) GetValue(LayoutTransformProperty); } 
            set { SetValue(LayoutTransformProperty, value); }
        } 
 
        private static void OnLayoutTransformChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            FrameworkElement fe = (FrameworkElement)d;
            fe.AreTransformsClean = false;
        }
 
        private static bool IsWidthHeightValid(object value)
        { 
            double v = (double)value; 
            return (DoubleUtil.IsNaN(v)) || (v >= 0.0d && !Double.IsPositiveInfinity(v));
        } 

        private static bool IsMinWidthHeightValid(object value)
        {
            double v = (double)value; 
            return (!DoubleUtil.IsNaN(v) && v >= 0.0d && !Double.IsPositiveInfinity(v));
        } 
 
        private static bool IsMaxWidthHeightValid(object value)
        { 
            double v = (double)value;
            return (!DoubleUtil.IsNaN(v) && v >= 0.0d);
        }
 
        private static void OnTransformDirty(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            // Callback for MinWidth, MaxWidth, Width, MinHeight, MaxHeight, Height, and RenderTransformOffset 
            FrameworkElement fe = (FrameworkElement)d;
            fe.AreTransformsClean = false; 
        }

        /// 
        /// Width Dependency Property 
        /// 
        [CommonDependencyProperty] 
        public static readonly DependencyProperty WidthProperty = 
                    DependencyProperty.Register(
                                "Width", 
                                typeof(double),
                                _typeofThis,
                                new FrameworkPropertyMetadata(
                                        Double.NaN, 
                                        FrameworkPropertyMetadataOptions.AffectsMeasure,
                                        new PropertyChangedCallback(OnTransformDirty)), 
                                new ValidateValueCallback(IsWidthHeightValid)); 

        ///  
        /// Width Property
        /// 
        [TypeConverter(typeof(LengthConverter))]
        [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)] 
        public double Width
        { 
            get { return (double) GetValue(WidthProperty); } 
            set { SetValue(WidthProperty, value); }
        } 

        /// 
        /// MinWidth Dependency Property
        ///  
        [CommonDependencyProperty]
        public static readonly DependencyProperty MinWidthProperty = 
                    DependencyProperty.Register( 
                                "MinWidth",
                                typeof(double), 
                                _typeofThis,
                                new FrameworkPropertyMetadata(
                                        0d,
                                        FrameworkPropertyMetadataOptions.AffectsMeasure, 
                                        new PropertyChangedCallback(OnTransformDirty)),
                                new ValidateValueCallback(IsMinWidthHeightValid)); 
 
        /// 
        /// MinWidth Property 
        /// 
        [TypeConverter(typeof(LengthConverter))]
        [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)]
        public double MinWidth 
        {
            get { return (double) GetValue(MinWidthProperty); } 
            set { SetValue(MinWidthProperty, value); } 
        }
 
        /// 
        /// MaxWidth Dependency Property
        /// 
        [CommonDependencyProperty] 
        public static readonly DependencyProperty MaxWidthProperty =
                    DependencyProperty.Register( 
                                "MaxWidth", 
                                typeof(double),
                                _typeofThis, 
                                new FrameworkPropertyMetadata(
                                        Double.PositiveInfinity,
                                        FrameworkPropertyMetadataOptions.AffectsMeasure,
                                        new PropertyChangedCallback(OnTransformDirty)), 
                                new ValidateValueCallback(IsMaxWidthHeightValid));
 
 
        /// 
        /// MaxWidth Property 
        /// 
        [TypeConverter(typeof(LengthConverter))]
        [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)]
        public double MaxWidth 
        {
            get { return (double) GetValue(MaxWidthProperty); } 
            set { SetValue(MaxWidthProperty, value); } 
        }
 
        /// 
        /// Height Dependency Property
        /// 
        [CommonDependencyProperty] 
        public static readonly DependencyProperty HeightProperty =
                    DependencyProperty.Register( 
                                "Height", 
                                typeof(double),
                                _typeofThis, 
                                new FrameworkPropertyMetadata(
                                    Double.NaN,
                                    FrameworkPropertyMetadataOptions.AffectsMeasure,
                                    new PropertyChangedCallback(OnTransformDirty)), 
                                new ValidateValueCallback(IsWidthHeightValid));
 
        ///  
        /// Height Property
        ///  
        [TypeConverter(typeof(LengthConverter))]
        [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)]
        public double Height
        { 
            get { return (double) GetValue(HeightProperty); }
            set { SetValue(HeightProperty, value); } 
        } 

        ///  
        /// MinHeight Dependency Property
        /// 
        [CommonDependencyProperty]
        public static readonly DependencyProperty MinHeightProperty = 
                    DependencyProperty.Register(
                                "MinHeight", 
                                typeof(double), 
                                _typeofThis,
                                new FrameworkPropertyMetadata( 
                                        0d,
                                        FrameworkPropertyMetadataOptions.AffectsMeasure,
                                        new PropertyChangedCallback(OnTransformDirty)),
                                new ValidateValueCallback(IsMinWidthHeightValid)); 

        ///  
        /// MinHeight Property 
        /// 
        [TypeConverter(typeof(LengthConverter))] 
        [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)]
        public double MinHeight
        {
            get { return (double) GetValue(MinHeightProperty); } 
            set { SetValue(MinHeightProperty, value); }
        } 
 
        /// 
        /// MaxHeight Dependency Property 
        /// 
        [CommonDependencyProperty]
        public static readonly DependencyProperty MaxHeightProperty =
                    DependencyProperty.Register( 
                                "MaxHeight",
                                typeof(double), 
                                _typeofThis, 
                                new FrameworkPropertyMetadata(
                                        Double.PositiveInfinity, 
                                        FrameworkPropertyMetadataOptions.AffectsMeasure,
                                        new PropertyChangedCallback(OnTransformDirty)),
                                new ValidateValueCallback(IsMaxWidthHeightValid));
 
        /// 
        /// MaxHeight Property 
        ///  
        [TypeConverter(typeof(LengthConverter))]
        [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)] 
        public double MaxHeight
        {
            get { return (double) GetValue(MaxHeightProperty); }
            set { SetValue(MaxHeightProperty, value); } 
        }
 
        ///  
        /// FlowDirectionProperty
        ///  
        [CommonDependencyProperty]
        public static readonly DependencyProperty FlowDirectionProperty =
                    DependencyProperty.RegisterAttached(
                                "FlowDirection", 
                                typeof(FlowDirection),
                                _typeofThis, 
                                new FrameworkPropertyMetadata( 
                                            System.Windows.FlowDirection.LeftToRight, // default value
                                            FrameworkPropertyMetadataOptions.Inherits 
                                          | FrameworkPropertyMetadataOptions.AffectsParentArrange,
                                            new PropertyChangedCallback(OnFlowDirectionChanged),
                                            new CoerceValueCallback(CoerceFlowDirectionProperty)),
                                new ValidateValueCallback(IsValidFlowDirection)); 

        //  Since layout applies mirroring based on pair-wise flow direction property value comparison 
        //  of an element and its visual parent and since this does not exactly match property engine's 
        //  notion of dirty-ness, the following measures are taken:
        //  1.  FlowDirectionProperty is made force inherited property. 
        //  2.  Invalidation happens during coercion (which is called always unlike behaviour of
        //      flags set in metadata).
        private static object CoerceFlowDirectionProperty(DependencyObject d, object value)
        { 
            FrameworkElement fe = d as FrameworkElement;
            if (fe != null) 
            { 
                fe.InvalidateArrange();
                fe.InvalidateVisual(); 
                fe.AreTransformsClean = false;
            }
            return value;
        } 

        private static void OnFlowDirectionChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        { 
            // Check that d is a FrameworkElement since the property inherits and this can be called
            // on non-FEs. 
            FrameworkElement fe = d as FrameworkElement;
            if (fe != null)
            {
                // Cache the new value as a bit to optimize accessing the FlowDirection property's CLR accessor 
                fe.IsRightToLeft = ((FlowDirection)e.NewValue) == FlowDirection.RightToLeft;
                fe.AreTransformsClean = false; 
            } 
        }
 
        /// 
        /// FlowDirection Property
        /// 
    [Localizability(LocalizationCategory.None)] 
        public FlowDirection FlowDirection
        { 
            get { return IsRightToLeft ? FlowDirection.RightToLeft : FlowDirection.LeftToRight; } 
            set { SetValue(FlowDirectionProperty, value); }
        } 

        /// 
        /// Queries the attached property FlowDirection from the given element.
        ///  
        /// 
        public static FlowDirection GetFlowDirection(DependencyObject element) 
        { 
            if (element == null) { throw new ArgumentNullException("element"); }
            return (FlowDirection)element.GetValue(FlowDirectionProperty); 
        }

        /// 
        /// Writes the attached property FlowDirection to the given element. 
        /// 
        ///  
        public static void SetFlowDirection(DependencyObject element, FlowDirection value) 
        {
            if (element == null) { throw new ArgumentNullException("element"); } 
            element.SetValue(FlowDirectionProperty, value);
        }

        ///  
        /// Validates the flow direction property values
        ///  
        private static bool IsValidFlowDirection(object o) 
        {
            FlowDirection value = (FlowDirection)o; 
            return value == FlowDirection.LeftToRight || value == FlowDirection.RightToLeft;
        }

        ///  
        /// MarginProperty
        ///  
        [CommonDependencyProperty] 
        public static readonly DependencyProperty MarginProperty
            = DependencyProperty.Register("Margin", typeof(Thickness), _typeofThis, 
                                          new FrameworkPropertyMetadata(
                                                new Thickness(),
                                                FrameworkPropertyMetadataOptions.AffectsMeasure),
                                          new ValidateValueCallback(IsMarginValid)); 

        private static bool IsMarginValid(object value) 
        { 
            Thickness m = (Thickness)value;
            return m.IsValid(true, false, true, false); 
        }


        ///  
        /// Margin Property
        ///  
        public Thickness Margin 
        {
            get { return (Thickness) GetValue(MarginProperty); } 
            set { SetValue(MarginProperty, value); }
        }

        // 
        //  Properties overrides are needed only to discourage usage in old layout.
        // 
 
        /// 
        /// HorizontalAlignment Dependency Property. 
        /// 
        [CommonDependencyProperty]
        public static readonly DependencyProperty HorizontalAlignmentProperty =
                    DependencyProperty.Register( 
                                "HorizontalAlignment",
                                typeof(HorizontalAlignment), 
                                _typeofThis, 
                                new FrameworkPropertyMetadata(
                                            HorizontalAlignment.Stretch, 
                                            FrameworkPropertyMetadataOptions.AffectsArrange),
                                new ValidateValueCallback(ValidateHorizontalAlignmentValue));

        internal static bool ValidateHorizontalAlignmentValue(object value) 
        {
            HorizontalAlignment ha = (HorizontalAlignment)value; 
            return (    ha == HorizontalAlignment.Left 
                    ||  ha == HorizontalAlignment.Center
                    ||  ha == HorizontalAlignment.Right 
                    ||  ha == HorizontalAlignment.Stretch   );
        }

        ///  
        /// HorizontalAlignment Property.
        ///  
        public HorizontalAlignment HorizontalAlignment 
        {
            get { return (HorizontalAlignment) GetValue(HorizontalAlignmentProperty); } 
            set { SetValue(HorizontalAlignmentProperty, value); }
        }

        ///  
        /// VerticalAlignment Dependency Property.
        ///  
        [CommonDependencyProperty] 
        public static readonly DependencyProperty VerticalAlignmentProperty =
                    DependencyProperty.Register( 
                                "VerticalAlignment",
                                typeof(VerticalAlignment),
                                _typeofThis,
                                new FrameworkPropertyMetadata( 
                                            VerticalAlignment.Stretch,
                                            FrameworkPropertyMetadataOptions.AffectsArrange), 
                                new ValidateValueCallback(ValidateVerticalAlignmentValue)); 

        internal static bool ValidateVerticalAlignmentValue(object value) 
        {
            VerticalAlignment va = (VerticalAlignment)value;
            return (    va == VerticalAlignment.Top
                    ||  va == VerticalAlignment.Center 
                    ||  va == VerticalAlignment.Bottom
                    ||  va == VerticalAlignment.Stretch); 
        } 

        ///  
        /// VerticalAlignment Property.
        /// 
        public VerticalAlignment VerticalAlignment
        { 
            get { return (VerticalAlignment) GetValue(VerticalAlignmentProperty); }
            set { SetValue(VerticalAlignmentProperty, value); } 
        } 

        // Need a special value here until bug 1016350 is fixed.  KeyboardNavigation 
        // treats this as the value to indicate that it should do a resource lookup
        // to find the "real" default value.
        private static Style _defaultFocusVisualStyle = null;
 
        internal static Style DefaultFocusVisualStyle
        { 
            get 
            {
                if (_defaultFocusVisualStyle == null) 
                {
                    Style defaultFocusVisualStyle = new Style();
                    defaultFocusVisualStyle.Seal();
                    _defaultFocusVisualStyle = defaultFocusVisualStyle; 
                }
 
                return _defaultFocusVisualStyle; 
            }
        } 

        /// 
        /// FocusVisualStyleProperty
        ///  
        public static readonly DependencyProperty FocusVisualStyleProperty =
                    DependencyProperty.Register( 
                                "FocusVisualStyle", 
                                typeof(Style),
                                _typeofThis, 
                                new FrameworkPropertyMetadata(DefaultFocusVisualStyle));


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

        ///  
        /// CursorProperty
        ///  
        public static readonly DependencyProperty CursorProperty = 
                    DependencyProperty.Register(
                                "Cursor", 
                                typeof(Cursor),
                                _typeofThis,
                                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) 
        {
            FrameworkElement fe = ((FrameworkElement)d);

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

        /// 
        ///     ForceCursorProperty
        ///  
        public static readonly DependencyProperty ForceCursorProperty =
                    DependencyProperty.Register( 
                                "ForceCursor", 
                                typeof(bool),
                                _typeofThis, 
                                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)
        { 
            FrameworkElement fe = ((FrameworkElement)d);

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

        private static void OnQueryCursorOverride(object sender, QueryCursorEventArgs e) 
        {
            FrameworkElement fe = (FrameworkElement) sender;

            // We respond to querying the cursor by specifying the cursor set 
            // as a property on this element.
            Cursor cursor = fe.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 || fe.ForceCursor) 
                { 
                    e.Cursor = cursor;
                    e.Handled = true; 
                }
            }
        }
 
        /// 
        /// Helper method determining if mirroring transform is needed for this element. 
        /// If the case mirroring transform is created and returned. 
        /// 
        ///  
        /// Depending of flow direction property value of this element and its framework element parent:
        /// returns either mirror transform instance or null.
        /// 
        private Transform GetFlowDirectionTransform() 
        {
            if (!BypassLayoutPolicies && ShouldApplyMirrorTransform(this)) //Window applies its own mirror 
            { 
                return new MatrixTransform(-1.0, 0.0, 0.0, 1.0, RenderSize.Width, 0.0);
            } 

            return null;
        }
 
        internal static bool ShouldApplyMirrorTransform(FrameworkElement fe)
        { 
            FlowDirection thisFlowDirection = fe.FlowDirection; 
            FlowDirection parentFlowDirection = FlowDirection.LeftToRight; // Assume LTR if no parent is found.
            // If the element is connected to visual tree, get FlowDirection 
            // from its visual parent.
            // If there is no visual parent, look for logical parent and if
            // it is a ContentElement get FlowDirection form it. ContentHosts
            // may not fully create their visual tree before Arrange process is done. 
            DependencyObject parentVisual = VisualTreeHelper.GetParent(fe);
            if (parentVisual != null) 
            { 
                parentFlowDirection = GetFlowDirectionFromVisual(parentVisual);
            } 
            else
            {
                FrameworkContentElement parentFCE;
                FrameworkElement parentFE; 
                bool hasParent = GetFrameworkParent(fe, out parentFE, out parentFCE);
                if (hasParent) 
                { 
                    if (parentFE != null && parentFE is IContentHost)
                    { 
                        parentFlowDirection = parentFE.FlowDirection;
                    }
                    else if (parentFCE != null)
                    { 
                        parentFlowDirection = (FlowDirection)parentFCE.GetValue(FlowDirectionProperty);
                    } 
                } 
            }
 
            //  if direction changes, instantiate a mirroring transform
            return ApplyMirrorTransform(parentFlowDirection, thisFlowDirection);
        }
 
        /// 
        /// Helper method to read and return flow direction property value for a given visual. 
        ///  
        /// Visual to get flow direction for.
        /// Flow direction property value. 
        private static FlowDirection GetFlowDirectionFromVisual(DependencyObject visual)
        {
            FlowDirection flowDirection = FlowDirection.LeftToRight;
 
            for (DependencyObject v = visual; v != null; v = VisualTreeHelper.GetParent(v))
            { 
                FrameworkElement fe = v as FrameworkElement; 
                if (fe != null)
                { 
                    flowDirection = fe.FlowDirection;
                    break;
                }
                else 
                {
                    // Try to get value from Visual. 
                    // ContentHost, when processing ContentElements with changing FlowDirection 
                    // property value, will create a Visual and set FlowDirectionProperty on it.
                    // For this reason need to take into account Visuals with local value set 
                    // for FlowDirectionProperty.
                    object flowDirectionValue = v.ReadLocalValue(FlowDirectionProperty);
                    if (flowDirectionValue != DependencyProperty.UnsetValue)
                    { 
                        flowDirection = (FlowDirection)flowDirectionValue;
                        break; 
                    } 
                }
            } 

            return (flowDirection);
        }
 
        /// 
        ///     This method indicates whether a new transform should be created for the effects of 
        ///     changing from LTR to RTL or RTL to LTR. 
        ///     This method is internal so that Popup can use the same logic.
        ///  
        /// The element that sits above where the transform would go.
        /// The element that sits below where the transform would go and is where a potentially new flow direction is desired.
        /// True if the transform is needed, false otherwise.
        internal static bool ApplyMirrorTransform(FlowDirection parentFD, FlowDirection thisFD) 
        {
            return ((parentFD == FlowDirection.LeftToRight && thisFD == FlowDirection.RightToLeft) || 
                    (parentFD == FlowDirection.RightToLeft && thisFD == FlowDirection.LeftToRight)); 
        }
 
        private struct MinMax
        {
            internal MinMax(FrameworkElement e)
            { 
                maxHeight = e.MaxHeight;
                minHeight = e.MinHeight; 
                double l  = e.Height; 

                double height = (DoubleUtil.IsNaN(l) ? Double.PositiveInfinity : l); 
                maxHeight = Math.Max(Math.Min(height, maxHeight), minHeight);

                height = (DoubleUtil.IsNaN(l) ? 0 : l);
                minHeight = Math.Max(Math.Min(maxHeight, height), minHeight); 

                maxWidth = e.MaxWidth; 
                minWidth = e.MinWidth; 
                l        = e.Width;
 
                double width = (DoubleUtil.IsNaN(l) ? Double.PositiveInfinity : l);
                maxWidth = Math.Max(Math.Min(width, maxWidth), minWidth);

                width = (DoubleUtil.IsNaN(l) ? 0 : l); 
                minWidth = Math.Max(Math.Min(maxWidth, width), minWidth);
            } 
 
            internal double minWidth;
            internal double maxWidth; 
            internal double minHeight;
            internal double maxHeight;
        }
 
        //  LayoutTransform property may be animated and its value change in time,
        //  LayoutTransformData is used to store a snapshot of LayoutTransform 
        //  property value to avoid layout / render inconsistencies caused by 
        //  animated LayoutTransforms...
        private class LayoutTransformData 
        {
            internal Size UntransformedDS;
            private  Transform  _transform;
 
            internal void CreateTransformSnapshot(Transform sourceTransform)
            { 
                Debug.Assert(sourceTransform != null); 
                _transform = new MatrixTransform(sourceTransform.Value);
                _transform.Freeze(); 
            }

            internal Transform Transform
            { 
                get
                { 
                    Debug.Assert(_transform != null); 
                    return (_transform);
                } 
            }
        }

        // Method FindMaximalAreaLocalSpaceRect - used only if LayoutTransform is specified 
        // Summary:
        //   Given the transform currently applied to child, this method finds (in 
        //     axis-aligned local space) the largest rectangle that, after transform, 
        //   fits within transformSpaceBounds.  Largest rectangle means rectangle
        //   of greatest area in local space (although maximal area in local space 
        //   implies maximal area in transform space).
        // Parameters:
        //   transformSpaceBounds: the bounds (in destination/transform space) that
        //   the 
        // Returns:
        //   The dimensions, in local space, of the maximal area rectangle found. 
        private Size FindMaximalAreaLocalSpaceRect(Transform layoutTransform, Size transformSpaceBounds) 
        {
            // X (width) and Y (height) constraints for axis-aligned bounding box in dest. space 
            Double xConstr = transformSpaceBounds.Width;
            Double yConstr = transformSpaceBounds.Height;

            //if either of the sizes is 0, return 0,0 to avoid doing math on an empty rect (bug 963569) 
            if(DoubleUtil.IsZero(xConstr) || DoubleUtil.IsZero(yConstr))
                return new Size(0,0); 
 
            bool xConstrInfinite = Double.IsInfinity(xConstr);
            bool yConstrInfinite = Double.IsInfinity(yConstr); 

            if (xConstrInfinite && yConstrInfinite)
            {
                return new Size(Double.PositiveInfinity, Double.PositiveInfinity); 
            }
            else if(xConstrInfinite) //assume square for one-dimensional constraint 
            { 
                xConstr = yConstr;
            } 
            else if (yConstrInfinite)
            {
                yConstr = xConstr;
            } 

 
            // Get parameters from transform matrix. 
            Matrix trMatrix = layoutTransform.Value;
 
            // We only deal with nonsingular matrices here. The nonsingular matrix is the one
            // that has inverse (determinant != 0).
            if(!trMatrix.HasInverse)
                return new Size(0,0); 

            Double a = trMatrix.M11; 
            Double b = trMatrix.M12; 
            Double c = trMatrix.M21;
            Double d = trMatrix.M22; 

            // Result width and height (in child/local space)
            Double w=0, h=0;
 
            // because we are dealing with nonsingular transform matrices,
            // we have (b==0 || c==0) XOR (a==0 || d==0) 
 
            if (DoubleUtil.IsZero(b) || DoubleUtil.IsZero(c))
            { 
                // (b==0 || c==0) ==> a!=0 && d!=0

                Double yCoverD = (yConstrInfinite ? Double.PositiveInfinity : Math.Abs(yConstr/d));
                Double xCoverA = (xConstrInfinite ? Double.PositiveInfinity : Math.Abs(xConstr/a)); 

                if (DoubleUtil.IsZero(b)) 
                { 
                    if (DoubleUtil.IsZero(c))
                    { 
                        // Case: b=0, c=0, a!=0, d!=0

                        // No constraint relation; use maximal width and height
 
                        h = yCoverD;
                        w = xCoverA; 
                    } 
                    else
                    { 
                        // Case: b==0, a!=0, c!=0, d!=0

                        // Maximizing under line (hIntercept=xConstr/c, wIntercept=xConstr/a)
                        // BUT we still have constraint: h <= yConstr/d 

                        h = Math.Min(0.5*Math.Abs(xConstr/c), yCoverD); 
                        w = xCoverA - ((c * h) / a); 
                    }
                } 
                else
                {
                    // Case: c==0, a!=0, b!=0, d!=0
 
                    // Maximizing under line (hIntercept=yConstr/d, wIntercept=yConstr/b)
                    // BUT we still have constraint: w <= xConstr/a 
 
                    w = Math.Min( 0.5*Math.Abs(yConstr/b), xCoverA);
                    h = yCoverD - ((b * w) / d); 
                }
            }
            else if (DoubleUtil.IsZero(a) || DoubleUtil.IsZero(d))
            { 
                // (a==0 || d==0) ==> b!=0 && c!=0
 
                Double yCoverB = Math.Abs(yConstr/b); 
                Double xCoverC = Math.Abs(xConstr/c);
 
                if (DoubleUtil.IsZero(a))
                {
                    if (DoubleUtil.IsZero(d))
                    { 
                        // Case: a=0, d=0, b!=0, c!=0
 
                        // No constraint relation; use maximal width and height 

                        h = xCoverC; 
                        w = yCoverB;
                    }
                    else
                    { 
                        // Case: a==0, b!=0, c!=0, d!=0
 
                        // Maximizing under line (hIntercept=yConstr/d, wIntercept=yConstr/b) 
                        // BUT we still have constraint: h <= xConstr/c
 
                        h = Math.Min(0.5*Math.Abs(yConstr/d), xCoverC);
                        w = yCoverB - ((d * h) / b);
                    }
                } 
                else
                { 
                    // Case: d==0, a!=0, b!=0, c!=0 

                    // Maximizing under line (hIntercept=xConstr/c, wIntercept=xConstr/a) 
                    // BUT we still have constraint: w <= yConstr/b

                    w = Math.Min( 0.5*Math.Abs(xConstr/a), yCoverB);
                    h = xCoverC - ((a * w) / c); 
                }
            } 
            else 
            {
                Double xCoverA = Math.Abs(xConstr / a);        // w-intercept of x-constraint line. 
                Double xCoverC = Math.Abs(xConstr / c);        // h-intercept of x-constraint line.

                Double yCoverB = Math.Abs(yConstr / b);        // w-intercept of y-constraint line.
                Double yCoverD = Math.Abs(yConstr / d);        // h-intercept of y-constraint line. 

                // The tighest constraint governs, so we pick the lowest constraint line. 
                // 
                //   The optimal point (w,h) for which Area = w*h is maximized occurs halfway
                //   to each intercept. 

                w = Math.Min(yCoverB, xCoverA) * 0.5;
                h = Math.Min(xCoverC, yCoverD) * 0.5;
 
                if ( (DoubleUtil.GreaterThanOrClose(xCoverA, yCoverB) &&
                    DoubleUtil.LessThanOrClose(xCoverC, yCoverD)) || 
                    (DoubleUtil.LessThanOrClose(xCoverA, yCoverB) && 
                    DoubleUtil.GreaterThanOrClose(xCoverC, yCoverD))  )
                { 
                    // Constraint lines cross; since the most restrictive constraint wins,
                    // we have to maximize under two line segments, which together are discontinuous.
                    // Instead, we maximize w*h under the line segment from the two smallest endpoints.
 
                    // Since we are not (except for in corner cases) on the original constraint lines,
                    // we are not using up all the available area in transform space.  So scale our shape up 
                    // until it does in at least one dimension. 

                    Rect childBoundsTr = Rect.Transform(new Rect(0, 0, w, h), 
                                                        layoutTransform.Value);
                    Double expandFactor = Math.Min(xConstr / childBoundsTr.Width,
                                                   yConstr / childBoundsTr.Height);
                    if(    !Double.IsNaN(expandFactor) 
                        && !Double.IsInfinity(expandFactor))
                    { 
                        w *= expandFactor; 
                        h *= expandFactor;
                    } 
                }
            }

            return new Size(w,h); 
        }
 
        ///  
        /// Override for .
        ///  
        protected sealed override Size MeasureCore(Size availableSize)
        {
            Debug.Assert(MeasureData == null || availableSize == MeasureData.AvailableSize, "MeasureData needs to be passed down in [....] with size");
 
            //build the visual tree from styles first
            ApplyTemplate(); 
 
            if (BypassLayoutPolicies)
            { 
                return MeasureOverride(availableSize);
            }
            else
            { 
                Thickness margin = Margin;
                double marginWidth = margin.Left + margin.Right; 
                double marginHeight = margin.Top + margin.Bottom; 
                MeasureData measureData = MeasureData;
 
                //  parent size is what parent want us to be
                Size frameworkAvailableSize = new Size(
                Math.Max(availableSize.Width - marginWidth, 0),
                Math.Max(availableSize.Height - marginHeight, 0)); 

                MinMax mm = new MinMax(this); 
 
                LayoutTransformData ltd = LayoutTransformDataField.GetValue(this);
                { 
                    Transform layoutTransform = this.LayoutTransform;
                    //  check that LayoutTransform is non-trivial
                    if (layoutTransform != null && !layoutTransform.IsIdentity)
                    { 
                        if (ltd == null)
                        { 
                            //  allocate and store ltd if needed 
                            ltd = new LayoutTransformData();
                            LayoutTransformDataField.SetValue(this, ltd); 
                        }

                        ltd.CreateTransformSnapshot(layoutTransform);
                        ltd.UntransformedDS = new Size(); 
                    }
                    else if (ltd != null) 
                    { 
                        //  clear ltd storage
                        ltd = null; 
                        LayoutTransformDataField.ClearValue(this);
                    }
                }
 
                if(ltd != null)
                { 
                    // Find the maximal area rectangle in local (child) space that we can fit, post-transform 
                    // in the decorator's measure constraint.
                    frameworkAvailableSize = FindMaximalAreaLocalSpaceRect(ltd.Transform, frameworkAvailableSize); 
                }

                frameworkAvailableSize.Width  = Math.Max(mm.minWidth,  Math.Min(frameworkAvailableSize.Width, mm.maxWidth));
                frameworkAvailableSize.Height = Math.Max(mm.minHeight, Math.Min(frameworkAvailableSize.Height, mm.maxHeight)); 

                //  call to specific layout to measure 
                if (measureData != null) 
                {
                    measureData.AvailableSize = frameworkAvailableSize; 
                }
                Size desiredSize = MeasureOverride(frameworkAvailableSize);

                if (measureData != null) 
                {
                    // MeasureData should be treated like a parameter to Measure and thus not modified when returning from this call. 
                    measureData.AvailableSize = availableSize; 
                }
 
                //  maximize desiredSize with user provided min size
                desiredSize = new Size(
                    Math.Max(desiredSize.Width, mm.minWidth),
                    Math.Max(desiredSize.Height, mm.minHeight)); 

                //here is the "true minimum" desired size - the one that is 
                //for sure enough for the control to render its content. 
                Size unclippedDesiredSize = desiredSize;
 
                if (ltd != null)
                {
                    //need to store unclipped, untransformed desired size to be able to arrange later
                    ltd.UntransformedDS = unclippedDesiredSize; 

                    //transform unclipped desired size 
                    Rect unclippedBoundsTransformed = Rect.Transform(new Rect(0, 0, unclippedDesiredSize.Width, unclippedDesiredSize.Height), ltd.Transform.Value); 
                    unclippedDesiredSize.Width = unclippedBoundsTransformed.Width;
                    unclippedDesiredSize.Height = unclippedBoundsTransformed.Height; 
                }

                bool clipped = false;
 
                // User-specified max size starts to "clip" the control here.
                //Starting from this point desiredSize could be smaller then actually 
                //needed to render the whole control 
                if(desiredSize.Width > mm.maxWidth)
                { 
                    desiredSize.Width = mm.maxWidth;
                    clipped = true;
                }
 
                if(desiredSize.Height > mm.maxHeight)
                { 
                    desiredSize.Height = mm.maxHeight; 
                    clipped = true;
                } 

                //transform desired size to layout slot space
                if (ltd != null)
                { 
                    Rect childBoundsTransformed = Rect.Transform(new Rect(0, 0, desiredSize.Width, desiredSize.Height), ltd.Transform.Value);
                    desiredSize.Width = childBoundsTransformed.Width; 
                    desiredSize.Height = childBoundsTransformed.Height; 
                }
 
                //  because of negative margins, clipped desired size may be negative.
                //  need to keep it as doubles for that reason and maximize with 0 at the
                //  very last point - before returning desired size to the parent.
                double clippedDesiredWidth = desiredSize.Width + marginWidth; 
                double clippedDesiredHeight = desiredSize.Height + marginHeight;
 
                // In overconstrained scenario, parent wins and measured size of the child, 
                // including any sizes set or computed, can not be larger then
                // available size. We will clip the guy later. 
                if (clippedDesiredWidth > availableSize.Width)
                {
                    clippedDesiredWidth = availableSize.Width;
                    clipped = true; 
                }
 
                if (clippedDesiredHeight > availableSize.Height) 
                {
                    clippedDesiredHeight = availableSize.Height; 
                    clipped = true;
                }

                //  Note: unclippedDesiredSize is needed in ArrangeCore, 
                //  because due to the layout protocol, arrange should be called
                //  with constraints greater or equal to child's desired size 
                //  returned from MeasureOverride. But in most circumstances 
                //  it is possible to reconstruct original unclipped desired size.
                //  In such cases we want to optimize space and save 16 bytes by 
                //  not storing it on each FrameworkElement.
                //
                //  The if statement conditions below lists the cases when
                //  it is NOT possible to recalculate unclipped desired size later 
                //  in ArrangeCore, thus we save it into Uncommon Fields...
                // 
                //  Note 2: use SizeBox to avoid CLR boxing of Size. 
                //  measurements show it is better to allocate an object once than
                //  have spurious boxing allocations on every resize 
                SizeBox sb = UnclippedDesiredSizeField.GetValue(this);
                if (    clipped
                    ||  clippedDesiredWidth < 0
                    ||  clippedDesiredHeight < 0    ) 
                {
                    if (sb == null) //not yet allocated, allocate the box 
                    { 
                        sb = new SizeBox(unclippedDesiredSize);
                        UnclippedDesiredSizeField.SetValue(this, sb); 
                    }
                    else //we already have allocated size box, simply change it
                    {
                        sb.Width = unclippedDesiredSize.Width; 
                        sb.Height = unclippedDesiredSize.Height;
                    } 
                } 
                else
                { 
                    if (sb != null)
                        UnclippedDesiredSizeField.ClearValue(this);
                }
 
                return new Size(Math.Max(0, clippedDesiredWidth), Math.Max(0, clippedDesiredHeight));
            } 
        } 

        ///  
        /// Override for .
        /// 
        protected sealed override void ArrangeCore(Rect finalRect)
        { 
            if (BypassLayoutPolicies)
            { 
                Size oldRenderSize = RenderSize; 
                Size inkSize = ArrangeOverride(finalRect.Size);
                RenderSize = inkSize; 
                SetLayoutOffset(new Vector(finalRect.X, finalRect.Y), oldRenderSize);
            }
            else
            { 
                // If LayoutConstrained==true (parent wins in layout),
                // we might get finalRect.Size smaller then UnclippedDesiredSize. 
                // Stricltly speaking, this may be the case even if LayoutConstrained==false (child wins), 
                // since who knows what a particualr parent panel will try to do in error.
                // In this case we will not actually arrange a child at a smaller size, 
                // since the logic of the child does not expect to receive smaller size
                // (if it coudl deal with smaller size, it probably would accept it in MeasureOverride)
                // so lets replace the smaller arreange size with UnclippedDesiredSize
                // and then clip the guy later. 
                // We will use at least UnclippedDesiredSize to compute arrangeSize of the child, and
                // we will use layoutSlotSize to compute alignments - so the bigger child can be aligned within 
                // smaller slot. 

                // This is computed on every ArrangeCore. Depending on LayoutConstrained, actual clip may apply or not 
                NeedsClipBounds = false;

                // Start to compute arrange size for the child.
                // It starts from layout slot or deisred size if layout slot is smaller then desired, 
                // and then we reduce it by margins, apply Width/Height etc, to arrive at the size
                // that child will get in its ArrangeOverride. 
                Size arrangeSize = finalRect.Size; 

                Thickness margin = Margin; 
                double marginWidth = margin.Left + margin.Right;
                double marginHeight = margin.Top + margin.Bottom;

                arrangeSize.Width = Math.Max(0, arrangeSize.Width - marginWidth); 
                arrangeSize.Height = Math.Max(0, arrangeSize.Height - marginHeight);
 
                SizeBox sb = UnclippedDesiredSizeField.GetValue(this); 
                Size unclippedDesiredSize;
                if(sb == null) 
                {
                    unclippedDesiredSize = new Size(this.DesiredSize.Width - marginWidth,
                                                    this.DesiredSize.Height - marginHeight);
                } 
                else
                { 
                    unclippedDesiredSize = new Size(sb.Width, sb.Height); 
                }
 
                if (DoubleUtil.LessThan(arrangeSize.Width, unclippedDesiredSize.Width))
                {
                    NeedsClipBounds = true;
                    arrangeSize.Width = unclippedDesiredSize.Width; 
                }
 
                if (DoubleUtil.LessThan(arrangeSize.Height, unclippedDesiredSize.Height)) 
                {
                    NeedsClipBounds = true; 
                    arrangeSize.Height = unclippedDesiredSize.Height;
                }

                // Alignment==Stretch --> arrange at the slot size minus margins 
                // Alignment!=Stretch --> arrange at the unclippedDesiredSize
                if (HorizontalAlignment != HorizontalAlignment.Stretch) 
                { 
                    arrangeSize.Width = unclippedDesiredSize.Width;
                } 

                if (VerticalAlignment != VerticalAlignment.Stretch)
                {
                    arrangeSize.Height = unclippedDesiredSize.Height; 
                }
 
                //if LayoutTransform is set, arrange at untransformed DS always 
                //alignments apply to the BoundingBox after transform
                LayoutTransformData ltd = LayoutTransformDataField.GetValue(this); 
                if(ltd != null)
                {
                    // Repeat the measure-time algorithm for finding a best fit local rect.
                    // This essentially implements Stretch in case of LayoutTransform 
                    Size potentialArrangeSize = FindMaximalAreaLocalSpaceRect(ltd.Transform, arrangeSize);
                    arrangeSize = potentialArrangeSize; 
 
                    unclippedDesiredSize = ltd.UntransformedDS;
 
                    //only use max area rect if both dimensions of it are larger then
                    //desired size - replace with desired size otherwise
                    if(    !DoubleUtil.IsZero(potentialArrangeSize.Width)
                        && !DoubleUtil.IsZero(potentialArrangeSize.Height)) 
                    {
                        //Use less precise comparision - otherwise FP jitter may cause drastic jumps here 
                        if(   LayoutDoubleUtil.LessThan(potentialArrangeSize.Width, unclippedDesiredSize.Width) 
                           || LayoutDoubleUtil.LessThan(potentialArrangeSize.Height, unclippedDesiredSize.Height))
                        { 
                            arrangeSize = unclippedDesiredSize;
                        }
                    }
 
                    //if pre-transformed into local space arrangeSize is smaller in any dimension then
                    //unclipped local DesiredSize of the element, extend the arrangeSize but 
                    //remember that we potentially need to clip the result of such arrange. 
                    if(DoubleUtil.LessThan(arrangeSize.Width,  unclippedDesiredSize.Width))
                    { 
                        NeedsClipBounds = true;
                        arrangeSize.Width = unclippedDesiredSize.Width;
                    }
 
                    if(DoubleUtil.LessThan(arrangeSize.Height, unclippedDesiredSize.Height))
                    { 
                        NeedsClipBounds = true; 
                        arrangeSize.Height = unclippedDesiredSize.Height;
                    } 

                }

                MinMax mm = new MinMax(this); 

                //we have to choose max between UnclippedDesiredSize and Max here, because 
                //otherwise setting of max property could cause arrange at less then unclippedDS. 
                //Clipping by Max is needed to limit stretch here
                double effectiveMaxWidth = Math.Max(unclippedDesiredSize.Width, mm.maxWidth); 
                if (DoubleUtil.LessThan(effectiveMaxWidth, arrangeSize.Width))
                {
                    NeedsClipBounds = true;
                    arrangeSize.Width = effectiveMaxWidth; 
                }
 
                double effectiveMaxHeight = Math.Max(unclippedDesiredSize.Height, mm.maxHeight); 
                if (DoubleUtil.LessThan(effectiveMaxHeight, arrangeSize.Height))
                { 
                    NeedsClipBounds = true;
                    arrangeSize.Height = effectiveMaxHeight;
                }
 
                Size oldRenderSize = RenderSize;
                Size innerInkSize = ArrangeOverride(arrangeSize); 
 
                //Here we use un-clipped InkSize because element does not know that it is
                //clipped by layout system and it shoudl have as much space to render as 
                //it returned from its own ArrangeOverride
                RenderSize = innerInkSize;

                //clippedInkSize differs from InkSize only what MaxWidth/Height explicitly clip the 
                //otherwise good arrangement. For ex, DSMaxWidth - in this
                //case we should initiate clip at MaxWidth and only show Top-Left portion 
                //of the element limited by Max properties. It is Top-left because in case when we 
                //are clipped by container we also degrade to Top-Left, so we are consistent.
                Size clippedInkSize = new Size(Math.Min(innerInkSize.Width, mm.maxWidth), 
                                               Math.Min(innerInkSize.Height, mm.maxHeight));

                //remember we have to clip if Max properties limit the inkSize
                NeedsClipBounds |= 
                        DoubleUtil.LessThan(clippedInkSize.Width, innerInkSize.Width)
                    ||  DoubleUtil.LessThan(clippedInkSize.Height, innerInkSize.Height); 
 
                //if LayoutTransform is set, get the "outer bounds" - the alignments etc work on them
                if(ltd != null) 
                {
                    Rect inkRectTransformed = Rect.Transform(new Rect(0, 0, clippedInkSize.Width, clippedInkSize.Height), ltd.Transform.Value);
                    clippedInkSize.Width = inkRectTransformed.Width;
                    clippedInkSize.Height = inkRectTransformed.Height; 
                }
 
                //Note that inkSize now can be bigger then layoutSlotSize-margin (because of layout 
                //squeeze by the parent or LayoutConstrained=true, which clips desired size in Measure).
 
                // The client size is the size of layout slot decreased by margins.
                // This is the "window" through which we see the content of the child.
                // Alignments position ink of the child in this "window".
                // Max with 0 is neccessary because layout slot may be smaller then unclipped desired size. 
                Size clientSize = new Size(Math.Max(0, finalRect.Width - marginWidth),
                                        Math.Max(0, finalRect.Height - marginHeight)); 
 

                //remember we have to clip if clientSize limits the inkSize 
                NeedsClipBounds |=
                        DoubleUtil.LessThan(clientSize.Width, clippedInkSize.Width)
                    ||  DoubleUtil.LessThan(clientSize.Height, clippedInkSize.Height);
 
                Vector offset = ComputeAlignmentOffset(clientSize, clippedInkSize);
 
                offset.X += finalRect.X + margin.Left; 
                offset.Y += finalRect.Y + margin.Top;
 
                SetLayoutOffset(offset, oldRenderSize);
            }
        }
 
        /// 
        /// Override for  
        ///  
        protected internal override void OnRenderSizeChanged(SizeChangedInfo sizeInfo)
        { 
            SizeChangedEventArgs localArgs = new SizeChangedEventArgs(this, sizeInfo);
            localArgs.RoutedEvent = SizeChangedEvent;

            //first, invalidate ActualWidth and/or ActualHeight 
            //Note: if any handler of invalidation will dirtyfy layout,
            //subsequent handlers will run on effectively dirty layouts 
            //we only guarantee cleaning between elements, not between handlers here 
            if(sizeInfo.WidthChanged)
            { 
                HasWidthEverChanged = true;
                NotifyPropertyChange(new DependencyPropertyChangedEventArgs(ActualWidthProperty, _actualWidthMetadata, sizeInfo.PreviousSize.Width, sizeInfo.NewSize.Width));
            }
 
            if(sizeInfo.HeightChanged)
            { 
                HasHeightEverChanged = true; 
                NotifyPropertyChange(new DependencyPropertyChangedEventArgs(ActualHeightProperty, _actualHeightMetadata, sizeInfo.PreviousSize.Height, sizeInfo.NewSize.Height));
            } 

            RaiseEvent(localArgs);
        }
 
        private Vector ComputeAlignmentOffset(Size clientSize, Size inkSize)
        { 
            Vector offset = new Vector(); 

            HorizontalAlignment ha = HorizontalAlignment; 
            VerticalAlignment va = VerticalAlignment;

            //this is to degenerate Stretch to Top-Left in case when clipping is about to occur
            //if we need it to be Center instead, simply remove these 2 ifs 
            if(    ha == HorizontalAlignment.Stretch
                && inkSize.Width > clientSize.Width) 
            { 
                ha = HorizontalAlignment.Left;
            } 

            if(    va == VerticalAlignment.Stretch
                && inkSize.Height > clientSize.Height)
            { 
                va = VerticalAlignment.Top;
            } 
            //end of degeneration of Stretch to Top-Left 

            if (    ha == HorizontalAlignment.Center 
                ||  ha == HorizontalAlignment.Stretch  )
            {
                offset.X = (clientSize.Width - inkSize.Width) * 0.5;
            } 
            else if (ha == HorizontalAlignment.Right)
            { 
                offset.X = clientSize.Width - inkSize.Width; 
            }
            else 
            {
                offset.X = 0;
            }
 
            if (    va == VerticalAlignment.Center
                ||  va == VerticalAlignment.Stretch  ) 
            { 
                offset.Y = (clientSize.Height - inkSize.Height) * 0.5;
            } 
            else if (va == VerticalAlignment.Bottom)
            {
                offset.Y = clientSize.Height - inkSize.Height;
            } 
            else
            { 
                offset.Y = 0; 
            }
 
            return offset;
        }

        ///  
        /// Override of .
        ///  
        /// Geometry to use as additional clip in case when element is larger then available space 
        protected override Geometry GetLayoutClip(Size layoutSlotSize)
        { 
            if (NeedsClipBounds || ClipToBounds)
            {
                // see if  MaxWidth/MaxHeight limit the element
                MinMax mm = new MinMax(this); 

                //this is in element's local rendering coord system 
                Size inkSize = this.RenderSize; 

                double maxWidthClip = ( Double.IsPositiveInfinity(mm.maxWidth) ? inkSize.Width : mm.maxWidth); 
                double maxHeightClip = ( Double.IsPositiveInfinity(mm.maxHeight) ? inkSize.Height : mm.maxHeight);

                //need to clip because the computed sizes exceed MaxWidth/MaxHeight/Width/Height
                bool needToClipLocally = 
                     ClipToBounds //need to clip at bounds even if inkSize is less then maxSize
                  || (DoubleUtil.LessThan(maxWidthClip, inkSize.Width) 
                  ||  DoubleUtil.LessThan(maxHeightClip, inkSize.Height)); 

                //now lets say we already clipped by MaxWidth/MaxHeight, lets see if further clipping is needed 
                inkSize.Width = Math.Min(inkSize.Width, mm.maxWidth);
                inkSize.Height = Math.Min(inkSize.Height, mm.maxHeight);

                //if LayoutTransform is set, convert RenderSize to "outer bounds" 
                LayoutTransformData ltd = LayoutTransformDataField.GetValue(this);
                Rect inkRectTransformed = new Rect(); 
                if(ltd != null) 
                {
                    inkRectTransformed = Rect.Transform(new Rect(0, 0, inkSize.Width, inkSize.Height), ltd.Transform.Value); 
                    inkSize.Width = inkRectTransformed.Width;
                    inkSize.Height = inkRectTransformed.Height;
                }
 
                //now see if layout slot should clip the element
                Thickness margin = Margin; 
                double marginWidth = margin.Left + margin.Right; 
                double marginHeight = margin.Top + margin.Bottom;
 
                Size clippingSize = new Size(Math.Max(0, layoutSlotSize.Width  - marginWidth),
                                             Math.Max(0, layoutSlotSize.Height - marginHeight));

                bool needToClipSlot = ( 
                     ClipToBounds //forces clip at layout slot bounds even if reported sizes are ok
                  || DoubleUtil.LessThan(clippingSize.Width, inkSize.Width) 
                  || DoubleUtil.LessThan(clippingSize.Height, inkSize.Height)); 

                Transform rtlMirror = GetFlowDirectionTransform(); 

                if(needToClipLocally && !needToClipSlot)
                {
                    RectangleGeometry localClip = new RectangleGeometry(new Rect(0, 0, maxWidthClip, maxHeightClip)); 
                    if(rtlMirror != null) localClip.Transform = rtlMirror;
                    return localClip; 
                } 

                if(needToClipSlot) 
                {
                    Vector offset = ComputeAlignmentOffset(clippingSize, inkSize);

                    if(ltd != null) 
                    {
                        RectangleGeometry slotClip = new RectangleGeometry(new Rect( 
                                                                                -offset.X + inkRectTransformed.X, 
                                                                                -offset.Y + inkRectTransformed.Y,
                                                                                clippingSize.Width, 
                                                                                clippingSize.Height));
                        Matrix m = ltd.Transform.Value;
                        if(m.HasInverse)
                        { 
                            m.Invert();
                            slotClip.Transform = new MatrixTransform(m); 
                        } 

                        if(needToClipLocally) 
                        {
                            RectangleGeometry localClip = new RectangleGeometry(new Rect(0, 0, maxWidthClip, maxHeightClip));
                            PathGeometry combinedClip = Geometry.Combine(localClip, slotClip, GeometryCombineMode.Intersect, null);
                            if(rtlMirror != null) combinedClip.Transform = rtlMirror; 
                            return combinedClip;
                        } 
                        else 
                        {
                            if(rtlMirror != null) 
                            {
                                if(slotClip.Transform != null)
                                    slotClip.Transform = new MatrixTransform(slotClip.Transform.Value * rtlMirror.Value);
                                else 
                                    slotClip.Transform = rtlMirror;
                            } 
                            return slotClip; 
                        }
                    } 
                    else //no layout transform, intersect axis-aligned rects
                    {
                        Rect slotRect = new Rect(-offset.X, -offset.Y, clippingSize.Width, clippingSize.Height);
 
                        if(needToClipLocally) //intersect 2 rects
                        { 
                            Rect localRect = new Rect(0, 0, maxWidthClip, maxHeightClip); 
                            slotRect.Intersect(localRect);
                        } 

                        RectangleGeometry combinedClip = new RectangleGeometry(slotRect);
                        if(rtlMirror != null) combinedClip.Transform = rtlMirror;
                        return combinedClip; 
                    }
                } 
 
                return null;
            } 
            return base.GetLayoutClip(layoutSlotSize);
        }

        // see LayoutInformation 
        internal Geometry GetLayoutClipInternal()
        { 
            if(IsMeasureValid && IsArrangeValid) 
                return GetLayoutClip(PreviousArrangeRect.Size);
            else 
                return null;
        }

        ///  
        /// Measurement override. Implement your size-to-content logic here.
        ///  
        ///  
        /// MeasureOverride is designed to be the main customizability point for size control of layout.
        /// Element authors should override this method, call Measure on each child element, 
        /// and compute their desired size based upon the measurement of the children.
        /// The return value should be the desired size.
        /// Note: It is required that a parent element calls Measure on each child or they won't be sized/arranged.
        /// Typical override follows a pattern roughly like this (pseudo-code): 
        /// 
        ///      
        /// 
        ///     
        ///  
        /// The key aspects of this snippet are:
        ///      
        /// You must call Measure on each child element 
        /// It is common to cache measurement information between the MeasureOverride and ArrangeOverride method calls
        /// Calling base.MeasureOverride is not required. 
        /// Calls to Measure on children are passing either the same availableSize as the parent, or a subset of the area depending
        /// on the type of layout the parent will perform (for example, it would be valid to remove the area
        /// for some border or padding).
        ///      
        /// 
        /// Available size that parent can give to the child. May be infinity (when parent wants to 
        /// measure to content). This is soft constraint. Child can return bigger size to indicate that it wants bigger space and hope 
        /// that parent can throw in scrolling...
        /// Desired Size of the control, given available size passed as parameter. 
        protected virtual Size MeasureOverride(Size availableSize)
        {
            return new Size(0,0);
        } 

        ///  
        /// ArrangeOverride allows for the customization of the positioning of children. 
        /// 
        ///  
        /// Element authors should override this method, call Arrange on each visible child element,
        /// passing final size for each child element via finalSize parameter.
        /// Note: It is required that a parent element calls Arrange on each child or they won't be rendered.
        /// Typical override follows a pattern roughly like this (pseudo-code): 
        /// 
        ///      
        ///  
        ///     
        /// 
        /// 
        /// The final size that element should use to arrange itself and its children. 
        /// The size that element actually is going to use for rendering. If this size is not the same as finalSize
        /// input parameter, the AlignmentX/AlignmentY properties will position the ink rect of the element 
        /// appropriately. 
        protected virtual Size ArrangeOverride(Size finalSize)
        { 
            return finalSize;
        }

        ///  
        /// NOTE: THIS METHOD IS ONLY FOR INTERNAL SPECIFIC USE. It does not support some features of FrameworkElement,
        /// for example RenderTarnsfromOrigin and LayoutTransform. 
        /// 
        /// This is the method layout parent uses to set a location of the child
        /// relative to parent's visual as a result of layout. Typically, this is called 
        /// by the parent inside of its ArrangeOverride implementation. The transform passed into
        /// this method does not get combined with offset that is set by SetLayoutOffset, but rahter resets
        /// LayoutOffset to (0,0). Typically, layout parents use offset most of the time and only need to use this method instead if they need to introduce
        /// a non-trivial transform (including rotation or scale) between them and a layout child. 
        /// DO NOT name this SetLayoutTransform()!  The Xaml Compile may be fooled into thinking LayoutTransform is an attached property.
        ///  
        /// The element on which to set a transform. 
        /// The final transform of this element relative to its parent's visual.
        internal static void InternalSetLayoutTransform(UIElement element, Transform layoutTransform) 
        {
            FrameworkElement fe = element as FrameworkElement;
            element.InternalSetOffsetWorkaround(new Vector());
 
            Transform additionalTransform = (fe == null ? null : fe.GetFlowDirectionTransform()); //rtl
 
            Transform renderTransform = element.RenderTransform; 
            if(renderTransform == Transform.Identity)
                renderTransform = null; 

            // Create a TransformCollection and make sure it does not participate
            // in the InheritanceContext treeness because it is internal operation only.
            TransformCollection ts = new TransformCollection(); 
            ts.CanBeInheritanceContext = false;
 
            if(additionalTransform != null) 
                ts.Add(additionalTransform);
 
            if(renderTransform != null)
                ts.Add(renderTransform);

            ts.Add(layoutTransform); 

            TransformGroup group = new TransformGroup(); 
            group.Children = ts; 

            element.InternalSetTransformWorkaround(group); 
        }

        /// 
        /// This is the method layout parent uses to set a location of the child 
        /// relative to parent's visual as a result of layout. Typically, this is called
        /// by the parent inside of its ArrangeOverride implementation after calling Arrange on a child. 
        /// Note that this method resets layout tarnsform set by  method, 
        /// so only one of these two should be used by the parent.
        ///  
        private void SetLayoutOffset(Vector offset, Size oldRenderSize)
        {
            //
            // Attempt to avoid changing the transform more often than needed, 
            // such as when a parent is arrange dirty but its children aren't.
            // 
            // The dependencies for VisualTransform are as follows: 
            //     Mirror
            //         RenderSize.Width 
            //         FlowDirection
            //         parent.FlowDirection
            //     RenderTransform
            //         RenderTransformOrigin 
            //     LayoutTransform
            //         RenderSize 
            //         Width, MinWidth, MaxWidth 
            //         Height, MinHeight, MaxHeight
            // 
            // The AreTransformsClean flag will be false (dirty) when FlowDirection,
            // RenderTransform, LayoutTransform, Min/Max/Width/Height, or
            // RenderTransformOrigin changes.
            // 
            // RenderSize is compared here with the previous size to see if it changed.
            // 
            if (!AreTransformsClean || !DoubleUtil.AreClose(RenderSize, oldRenderSize)) 
            {
                Transform additionalTransform = GetFlowDirectionTransform(); //rtl 

                Transform renderTransform = this.RenderTransform;
                if(renderTransform == Transform.Identity) renderTransform = null;
 
                LayoutTransformData ltd = LayoutTransformDataField.GetValue(this);
 
                TransformGroup t = null; 

                //arbitrary transform, create a collection 
                if (additionalTransform != null
                    || renderTransform != null
                    || ltd != null)
                { 
                    // Create a TransformGroup and make sure it does not participate
                    // in the InheritanceContext treeness because it is internal operation only. 
                    t = new TransformGroup(); 
                    t.CanBeInheritanceContext = false;
                    t.Children.CanBeInheritanceContext = false; 

                    if (additionalTransform != null)
                        t.Children.Add(additionalTransform);
 
                    if(ltd != null)
                    { 
                        t.Children.Add(ltd.Transform); 

                        // see if  MaxWidth/MaxHeight limit the element 
                        MinMax mm = new MinMax(this);

                        //this is in element's local rendering coord system
                        Size inkSize = this.RenderSize; 

                        double maxWidthClip = (Double.IsPositiveInfinity(mm.maxWidth) ? inkSize.Width : mm.maxWidth); 
                        double maxHeightClip = (Double.IsPositiveInfinity(mm.maxHeight) ? inkSize.Height : mm.maxHeight); 

                        //get the size clipped by the MaxWidth/MaxHeight/Width/Height 
                        inkSize.Width = Math.Min(inkSize.Width, mm.maxWidth);
                        inkSize.Height = Math.Min(inkSize.Height, mm.maxHeight);

                        Rect inkRectTransformed = Rect.Transform(new Rect(inkSize), ltd.Transform.Value); 

                        t.Children.Add(new TranslateTransform(-inkRectTransformed.X, -inkRectTransformed.Y)); 
                    } 

                    if (renderTransform != null) 
                    {
                        Point origin = GetRenderTransformOrigin();
                        bool hasOrigin = (origin.X != 0d || origin.Y != 0d);
                        if (hasOrigin) 
                        {
                            TranslateTransform backOrigin = new TranslateTransform(-origin.X, -origin.Y); 
                            backOrigin.Freeze(); 
                            t.Children.Add(backOrigin);
                        } 

                        //can not freeze render transform - it can be animated
                        t.Children.Add(renderTransform);
 
                        if (hasOrigin)
                        { 
                            TranslateTransform forwardOrigin = new TranslateTransform(origin.X, origin.Y); 
                            forwardOrigin.Freeze();
                            t.Children.Add(forwardOrigin); 
                        }

                    }
                } 

                this.VisualTransform = t; 
                AreTransformsClean = true; 
            }
 
            Vector oldOffset = this.VisualOffset;
            if(!DoubleUtil.AreClose(oldOffset.X, offset.X) ||
               !DoubleUtil.AreClose(oldOffset.Y, offset.Y))
            { 
                this.VisualOffset = offset;
            } 
        } 

        private Point GetRenderTransformOrigin() 
        {
            Point relativeOrigin = this.RenderTransformOrigin;
            //important: this depends on a fact that RenderSize was already set by ArrangeCore *before* calling
            //SetLayoutOffset/GetRenderTransformOrigin sequence. 
            Size renderSize = this.RenderSize;
 
            return new Point(renderSize.Width * relativeOrigin.X, renderSize.Height * relativeOrigin.Y); 
        }
 
        #region Input
        // 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);
        } 
 
        private static void OnPreviewGotKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
        { 
            if (e.OriginalSource == sender)
            {
                FrameworkElement fe = (FrameworkElement)sender;
 
                // If element has an FocusedElement we need to delegate focus to it
                // and handle the event if focus successfully delegated 
                IInputElement activeElement = FocusManager.GetFocusedElement(fe); 
                if (activeElement != null && activeElement != sender && Keyboard.IsFocusable(activeElement as DependencyObject))
                { 
                    IInputElement oldFocus = Keyboard.FocusedElement;
                    activeElement.Focus();
                    // If focus is set to activeElement or delegated - handle the event
                    if (Keyboard.FocusedElement == activeElement || Keyboard.FocusedElement != oldFocus) 
                    {
                        e.Handled = true; 
                        return; 
                    }
                } 
            }
        }

        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) 
            {
                FrameworkElement fe = (FrameworkElement)sender;
                KeyboardNavigation.UpdateFocusedElement(fe);
 
                KeyboardNavigation keyNav = KeyboardNavigation.Current;
                KeyboardNavigation.ShowFocusVisual(); 
                keyNav.NotifyFocusChanged(fe, e); 
                keyNav.UpdateActiveElement(fe);
            } 
        }

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

                if (e.NewFocus == null) 
                {
                    KeyboardNavigation.Current.NotifyFocusChanged(sender, e);
                }
            } 
        }
 
        ///  
        ///     This method is invoked when the IsFocused property changes to true
        ///  
        /// RoutedEventArgs
        protected override void OnGotFocus(RoutedEventArgs e)
        {
            if (IsKeyboardFocused) 
                BringIntoView();
 
            base.OnGotFocus(e); 
        }
 
        #endregion Input

        #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); }
        } 

        ///  
        ///     Initialized private key 
        /// 
        internal static readonly EventPrivateKey InitializedKey = new EventPrivateKey(); 

        /// 
        ///     This clr event is fired when
        ///      
        ///     becomes true
        ///  
        [EditorBrowsable(EditorBrowsableState.Advanced)] 
        public event EventHandler Initialized
        { 
            add { EventHandlersStoreAdd(InitializedKey, value); }
            remove { EventHandlersStoreRemove(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(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);

                // Do instance initialization outside of the OnInitialized virtual
                // to make sure that: 
                // 1) We avoid attaching instance handlers to FrameworkElement
                //    (instance handlers are expensive). 
                // 2) If a derived class forgets to call base OnInitialized, 
                //    this work will still happen.
                PrivateInitialized(); 

                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 

        private static void NumberSubstitutionChanged(DependencyObject o, DependencyPropertyChangedEventArgs e) 
        { 
            ((FrameworkElement) o).HasNumberSubstitutionChanged = true;
        } 

        // Returns true when the coerce callback should return the current system metric
        private static bool ShouldUseSystemFont(FrameworkElement fe, DependencyProperty dp)
        { 
            bool hasModifiers;
 
            // Return the current system font when (changing the system theme OR creating an element and the default is outdated) 
            // AND the element is a root AND the element has not had a value set on it by the user
            return  (SystemResources.SystemResourcesAreChanging || (fe.ReadInternalFlag(InternalFlags.CreatingRoot) && SystemResources.SystemResourcesHaveChanged)) && 
                     fe._parent == null && VisualTreeHelper.GetParent(fe) == null &&
                     fe.GetValueSource(dp, null, out hasModifiers) == BaseValueSourceInternal.Default;
        }
 
        // Coerce Font properties on root elements when created or System resources change
        private static object CoerceFontFamily(DependencyObject o, object value) 
        { 
            // For root elements with default values, return current system metric if local value has not been set
            if (ShouldUseSystemFont((FrameworkElement)o, TextElement.FontFamilyProperty)) 
            {
                return SystemFonts.MessageFontFamily;
            }
 
            return value;
        } 
 
        private static object CoerceFontSize(DependencyObject o, object value)
        { 
            // For root elements with default values, return current system metric if local value has not been set
            if (ShouldUseSystemFont((FrameworkElement)o, TextElement.FontSizeProperty))
            {
                return SystemFonts.MessageFontSize; 
            }
 
            return value; 
        }
 
        private static object CoerceFontStyle(DependencyObject o, object value)
        {
            // For root elements with default values, return current system metric if local value has not been set
            if (ShouldUseSystemFont((FrameworkElement)o, TextElement.FontStyleProperty)) 
            {
                return SystemFonts.MessageFontStyle; 
            } 

            return value; 
        }

        private static object CoerceFontWeight(DependencyObject o, object value)
        { 
            // For root elements with default values, return current system metric if local value has not been set
            if (ShouldUseSystemFont((FrameworkElement)o, TextElement.FontWeightProperty)) 
            { 
                return SystemFonts.MessageFontWeight;
            } 

            return value;
        }
 

        /// 
        ///     Initiate the processing for [Un]Loaded event broadcast starting at this node 
        /// 
        internal sealed override void OnPresentationSourceChanged(bool attached) 
        {
            base.OnPresentationSourceChanged(attached);

            if (attached) 
            {
                // LOADED EVENT 
 
                // Broadcast Loaded
                // Note (see bug 1422684): Do not make this conditional on 
                // SubtreeHasLoadedChangeHandler. A layout pass may add loaded
                // handlers before the callback into BroadcastLoadedEvent occurs.
                // If we don't post the callback request, these handlers won't get
                // called. The optimization should be done in the callback. 
                FireLoadedOnDescendentsInternal();
 
                if (SystemResources.SystemResourcesHaveChanged) 
                {
                    // If root visual is created after resources have changed, update 
                    // Font properties because defaults are not in [....] with system
                    WriteInternalFlag(InternalFlags.CreatingRoot, true);
                    CoerceValue(TextElement.FontFamilyProperty);
                    CoerceValue(TextElement.FontSizeProperty); 
                    CoerceValue(TextElement.FontStyleProperty);
                    CoerceValue(TextElement.FontWeightProperty); 
                    WriteInternalFlag(InternalFlags.CreatingRoot, false); 
                }
            } 
            else
            {
                // UNLOADED EVENT
 
                // Broadcast Unloaded
                FireUnloadedOnDescendentsInternal(); 
            } 
        }
 
        /// 
        ///     The key needed set a read-only property.
        /// 
        internal static readonly DependencyPropertyKey LoadedPendingPropertyKey = 
                    DependencyProperty.RegisterReadOnly(
                                "LoadedPending", 
                                typeof(object[]), 
                                _typeofThis,
                                new PropertyMetadata(null)); // default value 

        /// 
        ///     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 
        /// 
        internal static readonly DependencyProperty LoadedPendingProperty = 
            LoadedPendingPropertyKey.DependencyProperty; 

        ///  
        ///     The key needed set a read-only property.
        /// 
        internal static readonly DependencyPropertyKey UnloadedPendingPropertyKey =
                    DependencyProperty.RegisterReadOnly( 
                                "UnloadedPending",
                                typeof(object[]), 
                                _typeofThis, 
                                new PropertyMetadata(null)); // default value
 
        /// 
        ///     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
        ///  
        internal static readonly DependencyProperty UnloadedPendingProperty =
            UnloadedPendingPropertyKey.DependencyProperty; 
 
        /// 
        ///     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 = EventManager.RegisterRoutedEvent("Loaded", RoutingStrategy.Direct, typeof(RoutedEventHandler), _typeofThis);
 
        /// 
        ///     This event is fired when the element is laid out, rendered and ready for interaction
        /// 
        public event RoutedEventHandler Loaded 
        {
            add 
            { 
                AddHandler(LoadedEvent, value, false);
            } 
            remove
            {
                RemoveHandler(LoadedEvent, value);
            } 
        }
 
        ///  
        ///     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 that will set the IsLoaded flag and Raise the Loaded event 
        ///  
        internal void OnLoaded(RoutedEventArgs args)
        { 
            RaiseEvent(args);
        }

        ///  
        ///     Unloaded private key
        ///  
        public static readonly RoutedEvent UnloadedEvent = EventManager.RegisterRoutedEvent("Unloaded", RoutingStrategy.Direct, typeof(RoutedEventHandler), _typeofThis); 

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

        ///  
        ///     Helper that will reset the IsLoaded flag and Raise the Unloaded event 
        /// 
        internal void OnUnloaded(RoutedEventArgs args) 
        {
            RaiseEvent(args);
        }
 
        // 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
 
        // This is part of an optimization to avoid accessing thread local storage
        // and thread apartment state multiple times. 
        private class FrameworkServices 
        {
            internal FrameworkServices() 
            {
                // STA Requirement are checked in InputManager cctor where InputManager.Current is used in KeyboardNavigation cctor
                _keyboardNavigation = new KeyboardNavigation();
                _popupControlService = new PopupControlService(); 
            }
 
            internal KeyboardNavigation _keyboardNavigation; 
            internal PopupControlService _popupControlService;
        } 

        internal static PopupControlService PopupControlService
        {
            get 
            {
                return EnsureFrameworkServices()._popupControlService; 
            } 
        }
 

        internal static KeyboardNavigation KeyboardNavigation
        {
            get 
            {
                return EnsureFrameworkServices()._keyboardNavigation; 
            } 
        }
 
        private static FrameworkServices EnsureFrameworkServices()
        {
            if ((_frameworkServices == null))
            { 
                // Enable KeyboardNavigation, ContextMenu, and ToolTip services.
                 _frameworkServices = new FrameworkServices(); 
            } 

            return _frameworkServices; 
        }

        /// 
        ///     The DependencyProperty for the ToolTip property 
        /// 
        public static readonly DependencyProperty ToolTipProperty = 
            ToolTipService.ToolTipProperty.AddOwner(_typeofThis); 

        ///  
        ///     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")] 
        [Localizability(LocalizationCategory.ToolTip)]
        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( 
                        _typeofThis,
                        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 GetValue(ContextMenuProperty) as ContextMenu;
            }
 
            set
            { 
                SetValue(ContextMenuProperty, value); 
            }
        } 

        /// 
        ///     The RoutedEvent for the ToolTipOpening event.
        ///  
        public static readonly RoutedEvent ToolTipOpeningEvent = ToolTipService.ToolTipOpeningEvent.AddOwner(_typeofThis);
 
        ///  
        ///     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) 
        {
            ((FrameworkElement)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(_typeofThis); 

        ///  
        ///     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)
        { 
            ((FrameworkElement)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(_typeofThis);
 
        /// 
        ///     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) 
        {
            ((FrameworkElement)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(_typeofThis); 

        ///  
        ///     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) 
        {
            ((FrameworkElement)sender).OnContextMenuClosing(e);
        }
 
        /// 
        ///     Called when ContextMenuClosing is raised on this element. 
        ///  
        /// Event arguments
        protected virtual void OnContextMenuClosing(ContextMenuEventArgs e) 
        {
        }

        #endregion 

        #region Operations 
 
        // 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);
                } 
            }
        }

        internal static void AddIntermediateElementsToRoute( 
            DependencyObject mergePoint,
            EventRoute route, 
            RoutedEventArgs args, 
            DependencyObject modelTreeNode)
        { 
            while (modelTreeNode != null && modelTreeNode != mergePoint)
            {
                UIElement uiElement = modelTreeNode as UIElement;
                ContentElement contentElement = modelTreeNode as ContentElement; 
                UIElement3D uiElement3D = modelTreeNode as UIElement3D;
 
                if(uiElement != null) 
                {
                    uiElement.AddToEventRoute(route, args); 

                    FrameworkElement fe = uiElement as FrameworkElement;
                    if (fe != null)
                    { 
                        AddStyleHandlersToEventRoute(fe, null, route, args);
                    } 
                } 
                else if (contentElement != null)
                { 
                    contentElement.AddToEventRoute(route, args);

                    FrameworkContentElement fce = contentElement as FrameworkContentElement;
                    if (fce != null) 
                    {
                        AddStyleHandlersToEventRoute(null, fce, route, args); 
                    } 
                }
                else if (uiElement3D != null) 
                {
                    uiElement3D.AddToEventRoute(route, args);
                }
 
                // Get model parent
                modelTreeNode = LogicalTreeHelper.GetParent(modelTreeNode); 
            } 
        }
 
        // 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;
        } 
 
        internal void EventHandlersStoreAdd(EventPrivateKey key, Delegate handler)
        { 
            EnsureEventHandlersStore();
            EventHandlersStore.Add(key, handler);
        }
 
        internal 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 InVisibilityCollapsedTree
        {
            get { return ReadInternalFlag(InternalFlags.InVisibilityCollapsedTree); } 
            set { WriteInternalFlag(InternalFlags.InVisibilityCollapsedTree, 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); }
        } 

        private bool NeedsClipBounds
        {
            get { return ReadInternalFlag(InternalFlags.NeedsClipBounds); } 
            set { WriteInternalFlag(InternalFlags.NeedsClipBounds, value); }
        } 
 
        private bool HasWidthEverChanged
        { 
            get { return ReadInternalFlag(InternalFlags.HasWidthEverChanged); }
            set { WriteInternalFlag(InternalFlags.HasWidthEverChanged, value); }
        }
 
        private bool HasHeightEverChanged
        { 
            get { return ReadInternalFlag(InternalFlags.HasHeightEverChanged); } 
            set { WriteInternalFlag(InternalFlags.HasHeightEverChanged, value); }
        } 

        internal bool IsRightToLeft
        {
            get { return ReadInternalFlag(InternalFlags.IsRightToLeft); } 
            set { WriteInternalFlag(InternalFlags.IsRightToLeft, value); }
        } 
 

        // Root node of VisualTree is the first FrameworkElementFactory 
        //  to be created.  -1 means "not involved in Style", 0 means
        //  "I am the object that has a Style with VisualTree", and 1
        //  means "I am the root of the VisualTree".  All following
        //  numbers are labeled in the order of a depth-first traversal 
        //  of the visual tree built from Style.VisualTree.
        // NOTE: Nodes that Style is not interested in (no properties, no 
        //  bindings, etc.) have a TemplateChildIndex of -1 because they are "not 
        //  involved" in Styles but they are in the chain.  They're at the end,
        //  behind all the nodes with TemplateChildIndex values, kept around so we 
        //  remember to clean them up.
        // NOTE: TemplateChildIndex is stored in the low bits of _flags2
        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); }
        } 

        internal bool BypassLayoutPolicies
        {
            get { return ReadInternalFlag2(InternalFlags2.BypassLayoutPolicies); } 
            set { WriteInternalFlag2(InternalFlags2.BypassLayoutPolicies, 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); 
            } 
        }
 
        private static DependencyObjectType ControlDType
        {
            get
            { 
                if (_controlDType == null)
                { 
                    _controlDType = DependencyObjectType.FromSystemTypeInternal(typeof(Control)); 
                }
 
                return _controlDType;
            }
        }
 
        private static DependencyObjectType ContentPresenterDType
        { 
            get 
            {
                if (_contentPresenterDType == null) 
                {
                    _contentPresenterDType = DependencyObjectType.FromSystemTypeInternal(typeof(ContentPresenter));
                }
 
                return _contentPresenterDType;
            } 
        } 

        private static DependencyObjectType PageDType 
        {
            get
            {
                if (_pageDType == null) 
                {
                    _pageDType = DependencyObjectType.FromSystemTypeInternal(typeof(Page)); 
                } 

                return _pageDType; 
            }
        }

        private static DependencyObjectType PageFunctionBaseDType 
        {
            get 
            { 
                if (_pageFunctionBaseDType == null)
                { 
                    _pageFunctionBaseDType = DependencyObjectType.FromSystemTypeInternal(typeof(PageFunctionBase));
                }

                return _pageFunctionBaseDType; 
            }
        } 
 
        //
        //  This property 
        //  1. Finds the correct initial size for the _effectiveValues store on the current DependencyObject
        //  2. This is a performance optimization
        //
        internal override int EffectiveValuesInitialSize 
        {
            get { return 7; } 
        } 

        #endregion Operations 

        // ThemeStyle used only when a ThemeStyleKey is specified (per-instance data in ThemeStyleDataField)
        private Style _themeStyleCache;
 
        // Layout
        private static readonly UncommonField UnclippedDesiredSizeField = new UncommonField(); 
        private static readonly UncommonField LayoutTransformDataField = new UncommonField(); 

        // Style/Template state (internals maintained by Style, per-instance data in StyleDataField) 
        private  Style       _styleCache;

        // Resources dictionary
        internal static readonly UncommonField ResourcesField = new UncommonField(); 

        internal DependencyObject _templatedParent;    // Non-null if this object was created as a result of a Template.VisualTree 
        private UIElement _templateChild;                // Non-null if this FE has a child that was created as part of a template. 

        private InternalFlags       _flags     = 0; // Stores Flags (see Flags enum) 
        private InternalFlags2      _flags2    = InternalFlags2.Default; // Stores Flags (see Flags enum)

        // Optimization, to avoid calling FromSystemType too often
        internal static DependencyObjectType UIElementDType = DependencyObjectType.FromSystemTypeInternal(typeof(UIElement)); 
        private static DependencyObjectType _controlDType = null;
        private static DependencyObjectType _contentPresenterDType = null; 
        private static DependencyObjectType _pageFunctionBaseDType = null; 
        private static DependencyObjectType _pageDType = null;
 
        // KeyboardNavigation, ContextMenu, and ToolTip
        [ThreadStatic]
        private static FrameworkServices _frameworkServices;
 
        // XLinq support
        private static PropertyInfo XElement_Name_PropertyInfo; 
 
#if DEBUG
        // This is used to make sure that Template-derived classes overriding 
        //  BuildVisualTree are doing the right thing when calling
        //  AddCustomTemplateRoot.
        internal VerificationState _buildVisualTreeVerification =
            VerificationState.WaitingForBuildVisualTree; 
#endif
    } 
 
    // LayoutDoubleUtil, uses fixed eps unlike DoubleUtil which uses relative one.
    // This is more suitable for some layout comparisons because the computation 
    // paths in layout may easily be quite long so DoubleUtil method gives a lot of false
    // results, while bigger absolute deviation is normally harmless in layout.
    // Note that FP noise is a big problem and using any of these compare methods is
    // not a complete solution, but rather the way to reduce the probability 
    // of the dramatically bad-looking results.
    internal static class LayoutDoubleUtil 
    { 
        private const double eps = 0.00000153; //more or less random more or less small number
 
        internal static bool AreClose(double value1, double value2)
        {
            if(value1 == value2) return true;
 
            double diff = value1 - value2;
            return (diff < eps) && (diff > -eps); 
        } 

        internal static bool LessThan(double value1, double value2) 
        {
            return (value1 < value2) && !AreClose(value1, value2);
        }
    } 

    internal enum InternalFlags : uint 
    { 
        // Does the instance have ResourceReference properties
        HasResourceReferences       = 0x00000001, 

        HasNumberSubstitutionChanged = 0x00000002,

        // Is the style for this instance obtained from a 
        // typed-style declared in the Resources
        HasImplicitStyleFromResources   = 0x00000004, 
        InheritanceBehavior0            = 0x00000008, 
        InheritanceBehavior1            = 0x00000010,
        InheritanceBehavior2            = 0x00000020, 

        IsStyleUpdateInProgress         = 0x00000040,
        IsThemeStyleUpdateInProgress    = 0x00000080,
        StoresParentTemplateValues     = 0x00000100, 

        // free bit = 0x00000200, 
        NeedsClipBounds             = 0x00000400, 

        HasWidthEverChanged        = 0x00000800, 
        HasHeightEverChanged        = 0x00001000,
        // free bit = 0x00002000,
        // free bit = 0x00004000,
 
        // Has this instance been initialized
        IsInitialized               = 0x00008000, 
 
        // Set on BeginInit and reset on EndInit
        InitPending                 = 0x00010000, 

        IsResourceParentValid       = 0x00020000,
        // free bit                     0x00040000,
 
        // This flag is set to true when this FrameworkElement is in the middle
        //  of an invalidation storm caused by InvalidateTree for ancestor change, 
        //  so we know not to trigger another one. 
        AncestorChangeInProgress    = 0x00080000,
 
        // This is used when we know that we're in a subtree whose visibility
        //  is collapsed.  A false here does not indicate otherwise.  A false
        //  merely indicates "we don't know".
        InVisibilityCollapsedTree   = 0x00100000, 

        HasStyleEverBeenFetched         = 0x00200000, 
        HasThemeStyleEverBeenFetched    = 0x00400000, 

        HasLocalStyle                    = 0x00800000, 

        // This instance's Visual or logical Tree was generated by a Template
        HasTemplateGeneratedSubTree    = 0x01000000,
 
        // free bit   = 0x02000000,
 
        HasLogicalChildren                    = 0x04000000, 

        // Are we in the process of iterating the logical children. 
        // This flag is set during a descendents walk, for property invalidation.
        IsLogicalChildrenIterationInProgress   = 0x08000000,

        //Are we creating a new root after system metrics have changed? 
        CreatingRoot                 = 0x10000000,
 
        // FlowDirection is set to RightToLeft (0 == LeftToRight, 1 == RightToLeft) 
        // This is an optimization to speed reading the FlowDirection property
        IsRightToLeft               = 0x20000000, 

        ShouldLookupImplicitStyles  = 0x40000000,

        // This flag is set to true there are mentees listening to either the 
        // InheritedPropertyChanged event or the ResourcesChanged event. Once
        // this flag is set to true it does not get reset after that. 
 
        PotentiallyHasMentees        = 0x80000000,
    } 

    [Flags]
    internal enum InternalFlags2 : uint
    { 
        // RESERVED: Bits 0-15  (0x0000FFFF): TemplateChildIndex
        R0                          = 0x00000001, 
        R1                          = 0x00000002, 
        R2                          = 0x00000004,
        R3                          = 0x00000008, 
        R4                          = 0x00000010,
        R5                          = 0x00000020,
        R6                          = 0x00000040,
        R7                          = 0x00000080, 
        R8                          = 0x00000100,
        R9                          = 0x00000200, 
        RA                          = 0x00000400, 
        RB                          = 0x00000800,
        RC                          = 0x00001000, 
        RD                          = 0x00002000,
        RE                          = 0x00004000,
        RF                          = 0x00008000,
 
        // free bit                 = 0x00010000,
        // free bit                 = 0x00020000, 
        // free bit                 = 0x00040000, 
        // free bit                 = 0x00080000,
 
        TreeHasLoadedChangeHandler  = 0x00100000,
        IsLoadedCache               = 0x00200000,
        IsStyleSetFromGenerator     = 0x00400000,
        IsParentAnFE                = 0x00800000, 
        IsTemplatedParentAnFE       = 0x01000000,
        HasStyleChanged             = 0x02000000, 
        HasTemplateChanged          = 0x04000000, 
        HasStyleInvalidated         = 0x08000000,
        IsRequestingExpression      = 0x10000000, 
        HasMultipleInheritanceContexts = 0x20000000,

        // free bit                 = 0x40000000,
        BypassLayoutPolicies        = 0x80000000, 

        // Default is so that the default value of TemplateChildIndex 
        // (which is stored in the low 16 bits) can be 0xFFFF (interpreted to be -1). 
        Default                     = 0x0000FFFF,
 
    }
}

 

 

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