public override object GetPattern(PatternInterface patternInterface)
        {
            if (patternInterface == PatternInterface.Value)
                return this;

            return base.GetPattern(patternInterface);
        }

        /// <summary>
        /// <see cref="AutomationPeer.GetAutomationControlTypeCore"/>
        /// </summary>
        public override object GetPattern(PatternInterface patternInterface)
        {
            object returnValue = null;

            if (patternInterface == PatternInterface.Text)
            {
                if (_textPattern == null)
                {
                    if (Owner is IServiceProvider)
                    {
                        ITextContainer textContainer = ((IServiceProvider)Owner).GetService(typeof(ITextContainer)) as ITextContainer;
                        if (textContainer != null)
                        {
                            _textPattern = new TextAdaptor(this, textContainer);
                        }
                    }
                }
                returnValue = _textPattern;
            }
            else
            {
                returnValue = base.GetPattern(patternInterface);
            }
            return returnValue;
        }

    public override object GetPattern( PatternInterface patternInterface )
    {
      if( patternInterface == PatternInterface.ExpandCollapse )
        return this;

      return null;
    }

        public override object GetPattern(PatternInterface patternInterface)
        {
            // In .net4 ItemAutomationPeer implements VirtualizedItemPattern, then we would need to call base.GetPattern here.
            object peer = null;

            if (patternInterface == PatternInterface.ScrollItem)
            {
                peer = this;
            }
            else if (patternInterface == PatternInterface.ExpandCollapse)
            {
                // only if RibbonGroup is Collapsed this Pattern applies.
                RibbonGroup wrapperGroup = GetWrapper();
                if (wrapperGroup != null && wrapperGroup.IsCollapsed)
                {
                    peer = this;
                }
            }

            if (peer == null)
            {
                RibbonGroupAutomationPeer wrapperPeer = GetWrapperPeer();
                if (wrapperPeer != null)
                {
                    peer = wrapperPeer.GetPattern(patternInterface);
                }
            }
            return peer;
        }

        /// <summary>
        /// Gets the control pattern that is associated with the specified System.Windows.Automation.Peers.PatternInterface.
        /// </summary>
        /// <param name="patternInterface">A value from the System.Windows.Automation.Peers.PatternInterface enumeration.</param>
        /// <returns>The object that supports the specified pattern, or null if unsupported.</returns>
        public override object GetPattern(PatternInterface patternInterface)
        {
            switch (patternInterface)
            {
                case PatternInterface.Grid:
                case PatternInterface.Selection:
                case PatternInterface.Table:
                    return this;
                case PatternInterface.Scroll:
                    {
                        ScrollViewer scrollViewer = this.OwningDataGrid.InternalScrollHost;
                        if (scrollViewer != null)
                        {
                            AutomationPeer scrollPeer = UIElementAutomationPeer.CreatePeerForElement(scrollViewer);
                            IScrollProvider scrollProvider = scrollPeer as IScrollProvider;
                            if (scrollPeer != null && scrollProvider != null)
                            {
                                scrollPeer.EventsSource = this;
                                return scrollProvider;
                            }
                        }

                        break;
                    }
            }

            return base.GetPattern(patternInterface);
        }

        ///
        override public object GetPattern(PatternInterface patternInterface) 
        { 
            if (patternInterface == PatternInterface.VirtualizedItem)
            { 
                // Virtualization not supported for GriViewItem or when Grouping is enabled
                if(VirtualizedItemPatternIdentifiers.Pattern != null && !(this is GridViewItemAutomationPeer) && !IsGroupingEnabled())
                {
                    if(GetWrapperPeer() == null) 
                        return this;
                    else 
                    { 
                        // ItemsControlAutomationPeer can be null in case of TreeViewItems when parent TreeViewItem is also virtualized
                        // If the Item is in Automation Tree we consider it has Realized and need not return VirtualizeItem pattern. 
                        if(ItemsControlAutomationPeer != null && !IsItemInAutomationTree())
                        {
                            return this;
                        } 

                        if(ItemsControlAutomationPeer == null) 
                            return this; 
                    }
                } 
                return null;
            }
            else if(patternInterface == PatternInterface.SynchronizedInput)
            { 
                UIElementAutomationPeer peer = GetWrapperPeer() as UIElementAutomationPeer;
                if(peer != null) 
                { 
                    return peer.GetPattern(patternInterface);
                } 
            }

            return null;
        } 

        ///
        override public object GetPattern(PatternInterface patternInterface) 
        {
            if (patternInterface == PatternInterface.ExpandCollapse)
            {
                return this; 
            }
            else if (patternInterface == PatternInterface.SelectionItem) 
            { 
                return this;
            } 
            else if (patternInterface == PatternInterface.ScrollItem)
            {
                return this;
            } 
            else if ((patternInterface == PatternInterface.ItemContainer) || (patternInterface == PatternInterface.SynchronizedInput))
            { 
                TreeViewItemAutomationPeer treeViewItemAutomationPeer = GetWrapperPeer() as TreeViewItemAutomationPeer; 
                if (treeViewItemAutomationPeer != null)
                { 
                    if(patternInterface == PatternInterface.SynchronizedInput)
                    {
                        return treeViewItemAutomationPeer.GetPattern(patternInterface);
 
                    }
                    else 
                    { 
                        return treeViewItemAutomationPeer;
                    } 
                }
            }

            return base.GetPattern(patternInterface); 
        }

		public override object GetPattern (PatternInterface patternInterface)
		{
			if (patternInterface == PatternInterface.Scroll)
				return this;
			else
				return base.GetPattern (patternInterface);
		}

        /// <summary>
        /// Gets the control pattern that is associated with the specified System.Windows.Automation.Peers.PatternInterface.
        /// </summary>
        /// <param name="patternInterface">A value from the System.Windows.Automation.Peers.PatternInterface enumeration.</param>
        /// <returns>The object that supports the specified pattern, or null if unsupported.</returns>
        public override object GetPattern(PatternInterface patternInterface)
        {
            switch (patternInterface)
            {
                case PatternInterface.Invoke:
                    {
                        if (this.OwningHeader.Column != null && this.OwningHeader.Column.CanUserSort)
                        {
                            return this;
                        }

                        break;
                    }

                case PatternInterface.ScrollItem:
                    {
                        return this;
                    }

                case PatternInterface.Transform:
                    {
                        if (this.OwningHeader.Column != null && this.OwningHeader.Column.DataGridOwner.CanUserResizeColumns)
                        {
                            return this;
                        }
                        
                        break;
                    }
            }

            return base.GetPattern(patternInterface);
        }

        /// <summary>
        /// <see cref="AutomationPeer.GetPattern"/>
        /// </summary>
        override public object GetPattern(PatternInterface patternInterface)
        {
            object returnValue = null;

            // Check if provided patternInterface is for Scroll, which is all
            // that is currently exposed.
            if (patternInterface == PatternInterface.Scroll)
            {
                // Get a reference to DocumentViewer's ScrollViewer
                DocumentViewer owner = (DocumentViewer)Owner;
                if (owner.ScrollViewer != null)
                {
                    // Get a reference to ScrollViewer's AutomationPeer.
                    AutomationPeer scrollPeer = UIElementAutomationPeer.CreatePeerForElement(owner.ScrollViewer);
                    if (scrollPeer != null && scrollPeer is IScrollProvider)
                    {
                        scrollPeer.EventsSource = this;
                        returnValue = scrollPeer;
                    }
                }
            }
            else
            {
                returnValue = base.GetPattern(patternInterface);
            }

            return returnValue;
        }

		public override object GetPattern (PatternInterface patternInterface)
		{
			if (patternInterface == PatternInterface.SelectionItem)
				return this;

			return base.GetPattern (patternInterface);
		}

        /// 
        override public object GetPattern(PatternInterface patternInterface)
        {
            object returnValue = null;

            if(patternInterface == PatternInterface.Value)
                returnValue = this;

            if (patternInterface == PatternInterface.Text)
            {
                if(_textPattern == null)
                    _textPattern = new TextAdaptor(this, ((TextBoxBase)Owner).TextContainer);

                return _textPattern;
            }

            if (patternInterface == PatternInterface.Scroll)
            {
                TextBox owner = (TextBox)Owner;
                if (owner.ScrollViewer != null)
                {
                    returnValue = owner.ScrollViewer.CreateAutomationPeer();
                    ((AutomationPeer)returnValue).EventsSource = this;
                }
            }

            if (patternInterface == PatternInterface.SynchronizedInput)
            {
                returnValue = base.GetPattern(patternInterface);
            }
            return returnValue;
        }

        /// <summary> 
        /// Return the patterns supported by PasswordBoxAutomationPeer
        /// </summary> 
        /// <param name="patternInterface"></param> 
        /// <returns></returns>
        override public object GetPattern(PatternInterface patternInterface) 
        {
            object returnValue = null;

            if (patternInterface == PatternInterface.Value) 
            {
                returnValue = this; 
            } 
            else if (patternInterface == PatternInterface.Text)
            { 
                if (_textPattern == null)
                {
                    _textPattern = new TextAdaptor(this, ((PasswordBox)Owner).TextContainer);
                } 

                returnValue = _textPattern; 
            } 
            else if (patternInterface == PatternInterface.Scroll)
            { 
                PasswordBox owner = (PasswordBox)Owner;
                if (owner.ScrollViewer != null)
                {
                    returnValue = owner.ScrollViewer.CreateAutomationPeer(); 
                    ((AutomationPeer)returnValue).EventsSource = this;
                } 
            } 
            else
            { 
                returnValue = base.GetPattern(patternInterface);
            }

            return returnValue; 
        }

 ///
 override public object GetPattern(PatternInterface patternInterface)
 {
     if (patternInterface == PatternInterface.Invoke) 
         return this;
     else 
         return base.GetPattern(patternInterface); 
 }

 ///
 override public object GetPattern(PatternInterface patternInterface)
 {
     if (patternInterface == PatternInterface.ScrollItem)
     {
         return this;
     }
     return base.GetPattern(patternInterface);
 }

		public override object GetPattern (PatternInterface pattern)
		{
			if (pattern == PatternInterface.ExpandCollapse)
				return this;
			else if (pattern == PatternInterface.Value)
				return null;
			return base.GetPattern (pattern);
		}

        ///
        override public object GetPattern(PatternInterface patternInterface)
        {
            // Indeterminate ProgressBar should not support RangeValue pattern
            if (patternInterface == PatternInterface.RangeValue && ((ProgressBar)Owner).IsIndeterminate)
                return null;

            return base.GetPattern(patternInterface);
        }

 /// <summary>
 /// Gets the control pattern that is associated with the specified System.Windows.Automation.Peers.PatternInterface.
 /// </summary>
 /// <param name="patternInterface">A value from the System.Windows.Automation.Peers.PatternInterface enumeration.</param>
 /// <returns>The object that supports the specified pattern, or null if unsupported.</returns>
 public override object GetPattern(PatternInterface patternInterface)
 {
     if (patternInterface == PatternInterface.ExpandCollapse || patternInterface == PatternInterface.Value)
     {
         return this;
     }
     return base.GetPattern(patternInterface);
 }

 /// <summary>
 /// Gets the control pattern for the
 /// <see cref="T:Microsoft.Silverlight.Testing.Controls.GridSplitter" /> that is
 /// associated with this
 /// <see cref="T:System.Windows.Automation.Peers.GridSplitterAutomationPeer" />.
 /// </summary>
 /// <param name="patternInterface">
 /// One of the enumeration values.
 /// </param>
 /// <returns>
 /// The object that implements the pattern interface, or null if the
 /// specified pattern interface is not implemented by this peer.
 /// </returns>
 public override object GetPattern(PatternInterface patternInterface)
 {
     if (patternInterface == PatternInterface.Transform)
     {
         return this;
     }
     return base.GetPattern(patternInterface);
 }

 public override object GetPattern(PatternInterface patternInterface)
 {
     var patternId = (int)patternInterface;
     if (patternId == TestOfMoreThanTwoPatternPropertiesPattern.Pattern ||
         patternId == AutomationElementRetievingPattern.Pattern.Id)
         return this;
     return base.GetPattern(patternInterface);
 }