public Calendar (Adapter adapter, AutomationPeer peer)
			: base (adapter, peer)
		{
			FrameworkElementAutomationPeer feap = peer as FrameworkElementAutomationPeer;
			if (feap == null)
				return;

			// XXX: We can't link to System.Windows.Controls, so
			// we'll use reflection instead.

			UIElement calendar = feap.Owner;

			Type t = calendar.GetType ();
			if (t.Namespace != "System.Windows.Controls" || t.Name != "Calendar")
				return;

			// XXX SUCH A HACK! XXX
			// Workaround a bug in CalendarAutomationPeer.
			// Even though its selection and NameProperty
			// change, it does not send the proper change
			// notifications via the peer.  So we fake them.
			EventInfo ei = t.GetEvent ("SelectedDatesChanged");
			ei.AddEventHandler (calendar,
			                    new EventHandler<SelectionChangedEventArgs> (OnSelectedDatesChanged));
		}

		public BaseActionImplementor (Adapter adapter, AutomationPeer peer)
			: base (adapter, peer)
		{
			// TODO: also do this in response to patterns being
			// added/removed
			RefreshActions ();
		}

		public ExpandCollapseInvokeToggle (Adapter adapter, AutomationPeer peer)
			: base (adapter, peer)
		{
			adapter.AutomationPropertyChanged
				+= new EventHandler<AutomationPropertyChangedEventArgs> (
					OnAutomationPropertyChanged);
		}

		public void RaisePropertyChangedEvent (AutomationPeer peer, 
		                                       AutomationProperty property, 
		                                       object oldValue, 
						       object newValue)
		{
			if (!AccessibilityEnabled || peer == null)
				return;

			if (object.Equals (newValue, oldValue))
				return;

			// We are going to raise changes only when the value ACTUALLY CHANGES
			IAutomationCacheProperty cachedProperty = peer.GetCachedProperty (property);
			if (cachedProperty != null) {
				if (object.Equals (newValue, cachedProperty.OldValue))
					return;
				cachedProperty.OldValue = newValue;
			}

			if (AutomationPropertyChanged != null)
				AutomationPropertyChanged (this, 
				                           new AutomationPropertyChangedEventArgs (peer, 
							                                           property, 
												   oldValue, 
												   newValue));
		}

		public RadioButton (Adapter adapter, AutomationPeer peer)
			: base (adapter, peer)
		{
			adapter.AutomationPropertyChanged
				+= new EventHandler<AutomationPropertyChangedEventArgs> (
					OnAutomationPropertyChanged);
		}

		public GridTable (Adapter adapter, AutomationPeer peer) : base (adapter, peer)
		{
			this.peer = peer;

			this.tableProvider = (ITableProvider) peer.GetPattern (
				PatternInterface.Table);
		}

        // Private ctor called from two public, static accessors
        private CategoryContainerAutomationPeer(CiderCategoryContainer container, AutomationPeer itemPeer) 
        {
            Fx.Assert(container != null, "CategoryContainer not specified.");
            Fx.Assert(itemPeer != null, "CategoryContainerItemAutomationPeer not specified.");
            _container = container;
            _itemAutomationPeer = itemPeer;

        }

		public void RaiseAutomationEvent (AutomationPeer peer, AutomationEvents eventId)
		{
			if (!AccessibilityEnabled || peer == null)
				return;

			if (AutomationEventRaised != null)
				AutomationEventRaised (this, new AutomationEventEventArgs (peer, eventId));
		}

		public Selection (Adapter adapter, AutomationPeer peer) : base (adapter, peer)
		{
			this.selectionProvider = (ISelectionProvider) peer.GetPattern (
				PatternInterface.Selection);

			adapter.AutomationPropertyChanged += (o, args) => {
				if (args.Property == SelectionPatternIdentifiers.SelectionProperty)
					adapter.EmitSignal ("selection_changed");
			};
		}

		public RangeValue (Adapter adapter, AutomationPeer peer)
			: base (adapter, peer)
		{
			this.rangeValueProvider = (IRangeValueProvider) peer.GetPattern (
				PatternInterface.RangeValue);

			adapter.AutomationPropertyChanged
				+= new EventHandler<AutomationPropertyChangedEventArgs> (
					OnAutomationPropertyChanged);
		}

        //-------------------------------------------------------------------
        //
        //  Constructors
        //
        //-------------------------------------------------------------------

        #region Constructors

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="textPeer">Automation Peer representing element for the ui scope of the text</param>
        /// <param name="textContainer">ITextContainer</param>
        internal TextAdaptor(AutomationPeer textPeer, ITextContainer textContainer)
        {
            Invariant.Assert(textContainer != null, "Invalid ITextContainer");
            Invariant.Assert(textPeer is TextAutomationPeer || textPeer is ContentTextAutomationPeer, "Invalid AutomationPeer");
            _textPeer = textPeer;
            _textContainer = textContainer;
            _textContainer.Changed += new TextContainerChangedEventHandler(OnTextContainerChanged);
            if (_textContainer.TextSelection != null)
            {
                _textContainer.TextSelection.Changed += new EventHandler(OnTextSelectionChanged);
            }
        }

 internal static new object GetSupportedPropertyValueInternal(AutomationPeer itemPeer, int propertyId)
 {
     if (SelectionItemPatternIdentifiers.IsSelectedProperty.Id == propertyId)
     {
         ISelectionItemProvider selectionItem = itemPeer.GetPattern(PatternInterface.SelectionItem) as ISelectionItemProvider;
         if (selectionItem != null)
             return selectionItem.IsSelected;
         else
             return null;
     }
     return ItemsControlAutomationPeer.GetSupportedPropertyValueInternal(itemPeer, propertyId);
 }

        //------------------------------------------------------
        //
        //  Constructors
        //
        //------------------------------------------------------
 
        #region Constructors

        // private ctor - the Wrap() pseudo-ctor is used instead.
        private ElementProxy(AutomationPeer peer)
        {
            if ((AutomationInteropReferenceType == ReferenceType.Weak) && 
                (peer is UIElementAutomationPeer || peer is ContentElementAutomationPeer || peer is UIElement3DAutomationPeer))
            {
                _peer = new WeakReference(peer);
            }
            else
            {
                _peer = peer;
            }
        }

        internal InteropAutomationProvider(HostedWindowWrapper wrapper, AutomationPeer parent)
        { 
            if (wrapper == null)
            {
                throw new ArgumentNullException("wrapper");
            } 
            if (parent == null)
            { 
                throw new ArgumentNullException("parent"); 
            }
 
            _wrapper = wrapper;
            _parent = parent;
        }

		public SelectionItem (Adapter adapter, AutomationPeer peer) : base (adapter, peer)
		{
			bool? isSelected = IsSelected;
			if (isSelected.HasValue)
				WasSelected = isSelected.Value;

			adapter.AutomationPropertyChanged
				+= new EventHandler<AutomationPropertyChangedEventArgs> (
				OnAutomationPropertyChanged);

			adapter.AutomationEventRaised
				+= new EventHandler<AutomationEventEventArgs> (
				OnAutomationEventRaised);
		}

        /// <summary>
        /// AutomationPeer for an item in a DataGrid
        /// </summary>
        public DataGridItemAutomationPeer(object item, DataGrid dataGrid)
            : base()
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }

            if (dataGrid == null)
            {
                throw new ArgumentNullException("dataGrid");
            }

            _item = item;
            _dataGridAutomationPeer = FrameworkElementAutomationPeer.CreatePeerForElement(dataGrid);
        }

        private static bool TryInvokePatternAutomation(AutomationPeer peer)
        {
            var pattern = peer.GetPattern(PatternInterface.Invoke) as IInvokeProvider;
            if (pattern == null)
                return false;

            try
            {
                pattern.Invoke();
            }
            catch (Exception exception)
            {
                throw new TestAutomationException("Exception while invoking pattern", exception);
            }

            return true;
        }

        /// <summary>
        /// AutomationPeer for a group of items in a DataGrid
        /// </summary>
        public DataGridGroupItemAutomationPeer(CollectionViewGroup group, DataGrid dataGrid)
            : base(dataGrid)
        {
            if (group == null)
            {
                //

                throw new ElementNotAvailableException();
            }
            if (dataGrid == null)
            {
                //

                throw new ElementNotAvailableException();
            }

            _group = group;
            _dataGridAutomationPeer = FrameworkElementAutomationPeer.CreatePeerForElement(dataGrid);
        }

        /// <summary>
        /// AutomationPeer for an item in a DataGrid
        /// </summary>
        public DataGridItemAutomationPeer(object item, DataGrid dataGrid)
            : base(dataGrid)
        {
            if (item == null)
            {
                // 

                throw new ElementNotAvailableException();
            }
            if (dataGrid == null)
            {
                // 

                throw new ElementNotAvailableException();
            }

            _item = item;
            _dataGridAutomationPeer = FrameworkElementAutomationPeer.CreatePeerForElement(dataGrid);
        }

        internal static void RaiseAsyncContentLoadedEvent(AutomationPeer peer, long bytesRead, long maxBytes)
        {
            double percentComplete = 0d;
            AsyncContentLoadedState asyncContentState = AsyncContentLoadedState.Beginning;

            if (bytesRead > 0)
            {
                if (bytesRead < maxBytes)
                {
                    percentComplete = maxBytes > 0 ? (bytesRead * 100d / maxBytes) : 0;
                    asyncContentState = AsyncContentLoadedState.Progress;
                }
                else
                {
                    percentComplete = 100d;
                    asyncContentState = AsyncContentLoadedState.Completed;
                }
            }

            peer.RaiseAsyncContentLoadedEvent(new AsyncContentLoadedEventArgs(asyncContentState, percentComplete));
        }