PresentationSource.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Core / CSharp / System / Windows / PresentationSource.cs / 1305600 / PresentationSource.cs

                            using System; 
using System.Collections;
using System.Diagnostics;
using System.ComponentModel;
using System.Runtime.InteropServices; 
using System.Windows.Threading;
using System.Security; 
using System.Security.Permissions; 
using System.Windows.Media;
using System.Windows.Media.Media3D; 
using System.Windows.Markup;
using System.Windows.Input;
using MS.Win32;
using MS.Utility; 
using MS.Internal;
using MS.Internal.PresentationCore;                        // SecurityHelper 
 
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID; 

namespace System.Windows
{
    ///  
    ///     PresentationSource is the abstract base for classes that
    ///     present content in another technology.  In addition, this 
    ///     class provides static methods for working with these sources. 
    /// 
    ///  
    ///     We currently have one implementation - HwndSource - that
    ///     presents content in a Win32 HWND.
    /// 
    ///  
    ///     Keep this from being derived from in partial-trust code.
    ///  
    [UIPermissionAttribute(SecurityAction.InheritanceDemand,Unrestricted=true)] 
    public abstract class PresentationSource : DispatcherObject
    { 
        //------------------------------------------------------
        //
        // Constructors
        // 
        //-----------------------------------------------------
 
        #region Constructors 
        /// 
        ///     Constructs an instance of the PresentationSource object. 
        /// 
        /// 
        ///     This is protected since this is an abstract base class.
        ///  
        protected PresentationSource()
        { 
        } 

        ///  
        ///     This constructor exists since the code gen for managed code generates a static constructor
        ///     and in that code it initializes a critical field which causes an fxcop violation for the codegen
        ///     constructor.
        ///  
        [SecurityCritical]
        static PresentationSource() 
        { 
        }
 
        #endregion

        //-----------------------------------------------------
        // 
        //  Public Methods
        // 
        //----------------------------------------------------- 

        #region Public Methods 
        /// 
        ///     InputProvider given the Device type.
        /// 
        ///  
        ///     Critical: Sub classing this can let you provide fake input providers which
        ///     can compromise the input system 
        ///  
        [SecurityCritical]
        [UIPermissionAttribute(SecurityAction.InheritanceDemand, Unrestricted = true)] 
        internal virtual IInputProvider GetInputProvider(Type inputDevice)
        {
            return null;
        } 

        #endregion 
 
        //------------------------------------------------------
        // 
        //  Public Static Methods
        //
        //-----------------------------------------------------
 
        #region Public Static Methods
        ///  
        ///     Returns the source in which the visual is being presented. 
        /// 
        /// The visual to find the source for. 
        /// The source in which the visual is being presented.
        ///
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API.
        /// 
        /// 
        ///     Critical - calls CriticalFromVisual. and returns the PresentationSource 
        ///     PublicOK: There exists a demand 
        /// 
        [SecurityCritical] 
        public static PresentationSource FromVisual(Visual visual)
        {
            SecurityHelper.DemandUIWindowPermission();
 
            return CriticalFromVisual(visual);
        } 
 
        /// 
        ///     Returns the source in which the Visual or Visual3D is being presented. 
        /// 
        /// The dependency object to find the source for.
        /// The source in which the dependency object is being presented.
        /// 
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API.
        /// 
        ///  
        ///     Critical - calls CriticalFromVisual. and returns the PresentationSource
        ///     PublicOK: There exists a demand 
        /// 
        [SecurityCritical]
        public static PresentationSource FromDependencyObject(DependencyObject dependencyObject)
        { 
            SecurityHelper.DemandUIWindowPermission();
 
            return CriticalFromVisual(dependencyObject); 
        }
 
        /// 
        ///     Adds a handler for the SourceChanged event to the element.
        /// 
        /// The element to add the handler too. 
        /// The hander to add.
        ///  
        ///     Even though this is a routed event handler, there are special 
        ///     restrictions placed on this event.
        ///     1) You cannot use the UIElement or ContentElement AddHandler() method. 
        ///     2) Class handlers are not allowed.
        ///     3) The handlers will receive the SourceChanged event even if it was handled.
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API.
        ///  
        /// 
        ///     Critical: This code lets you get access to a presentationSource object. Here the link demand 
        ///     is defense in depth since , the object by itself has all public properties blocked off. Also this 
        ///     is part of startup code.
        ///  
        [SecurityCritical]
        [UIPermissionAttribute(SecurityAction.LinkDemand,Window=UIPermissionWindow.AllWindows)]
        public static void AddSourceChangedHandler(IInputElement element, SourceChangedEventHandler handler)
        { 
            if (element == null)
            { 
                throw new ArgumentNullException("element"); 
            }
 
            // Either UIElement or ContentElement
            if (!InputElement.IsValid(element))
            {
                throw new ArgumentException(SR.Get(SRID.Invalid_IInputElement), "element"); 
            }
            DependencyObject o = (DependencyObject)element; 
 
            //             o.VerifyAccess();
 

            // I would rather throw an exception here, but the CLR doesn't
            // so we won't either.
            if (handler != null) 
            {
                FrugalObjectList info; 
 
                if (InputElement.IsUIElement(o))
                { 
                    UIElement uie = o as UIElement;
                    uie.AddHandler(SourceChangedEvent, handler);
                    info = uie.EventHandlersStore[SourceChangedEvent];
                    if (1 == info.Count) 
                    {
                        uie.VisualAncestorChanged += new Visual.AncestorChangedEventHandler(uie.OnVisualAncestorChanged); 
                        AddElementToWatchList(uie); 
                    }
                } 
                else if (InputElement.IsUIElement3D(o))
                {

                    UIElement3D uie3D = o as UIElement3D; 
                    uie3D.AddHandler(SourceChangedEvent, handler);
                    info = uie3D.EventHandlersStore[SourceChangedEvent]; 
                    if (1 == info.Count) 
                    {
                        uie3D.VisualAncestorChanged += new Visual.AncestorChangedEventHandler(uie3D.OnVisualAncestorChanged); 
                        AddElementToWatchList(uie3D);
                    }
                }
                else 
                {
                    ContentElement ce = o as ContentElement; 
                    ce.AddHandler(SourceChangedEvent, handler); 
                    info = ce.EventHandlersStore[SourceChangedEvent];
                    if (1 == info.Count) 
                        AddElementToWatchList(ce);
                }
            }
        } 

        ///  
        ///     Removes a handler for the SourceChanged event to the element. 
        /// 
        /// The element to remove the handler from. 
        /// The hander to remove.
        /// 
        ///     Even though this is a routed event handler, there are special
        ///     restrictions placed on this event. 
        ///     1) You cannot use the UIElement or ContentElement RemoveHandler() method.
        ///  
        public static void RemoveSourceChangedHandler(IInputElement e, SourceChangedEventHandler handler) 
        {
            if (e == null) 
            {
                throw new ArgumentNullException("e");
            }
 
            if (!InputElement.IsValid(e))
            { 
                throw new ArgumentException(SR.Get(SRID.Invalid_IInputElement), "e"); 
            }
            DependencyObject o = (DependencyObject)e; 

            //             o.VerifyAccess();

            // I would rather throw an exception here, but the CLR doesn't 
            // so we won't either.
            if (handler != null) 
            { 
                FrugalObjectList info = null;
                EventHandlersStore store; 

                // Either UIElement or ContentElement.
                if (InputElement.IsUIElement(o))
                { 
                    UIElement uie = o as UIElement;
                    uie.RemoveHandler(SourceChangedEvent, handler); 
                    store = uie.EventHandlersStore; 
                    if (store != null)
                    { 
                        info = store[SourceChangedEvent];
                    }
                    if (info == null || info.Count == 0)
                    { 
                        uie.VisualAncestorChanged -= new Visual.AncestorChangedEventHandler(uie.OnVisualAncestorChanged); ;
                        RemoveElementFromWatchList(uie); 
                    } 
                }
                else if (InputElement.IsUIElement3D(o)) 
                {
                    UIElement3D uie3D = o as UIElement3D;
                    uie3D.RemoveHandler(SourceChangedEvent, handler);
                    store = uie3D.EventHandlersStore; 
                    if (store != null)
                    { 
                        info = store[SourceChangedEvent]; 
                    }
                    if (info == null || info.Count == 0) 
                    {
                        uie3D.VisualAncestorChanged -= new Visual.AncestorChangedEventHandler(uie3D.OnVisualAncestorChanged); ;
                        RemoveElementFromWatchList(uie3D);
                    } 
                }
                else 
                { 
                    ContentElement ce = o as ContentElement;
                    ce.RemoveHandler(SourceChangedEvent, handler); 
                    store = ce.EventHandlersStore;
                    if (store != null)
                    {
                        info = store[SourceChangedEvent]; 
                    }
                    if (info == null || info.Count == 0) 
                    { 
                        RemoveElementFromWatchList(ce);
                    } 
                }
            }
        }
 
        /// 
        ///     Called by FrameworkElements when a framework ancenstor link of 
        ///     ContentElement has changed. 
        /// 
        ///  
        ///     The element whose ancestory may have changed.
        /// 
        /// 
        ///     This API is not available in the internet zone.It was protected 
        ///     as defense in depth since we did not want the PresentationSource
        ///     surface to be exposed. 
        ///  
        [SecurityCritical]
        [UIPermissionAttribute(SecurityAction.LinkDemand,Window=UIPermissionWindow.AllWindows)] 
        [FriendAccessAllowed] // Built into Core, also used by Framework.
        internal static void OnAncestorChanged(ContentElement ce)
        {
            if (ce == null) 
            {
                throw new ArgumentNullException("ce"); 
            } 

 
            if (true == (bool)ce.GetValue(GetsSourceChangedEventProperty))
            {
                UpdateSourceOfElement(ce, null, null);
            } 
        }
 
        #endregion 

        //------------------------------------------------------ 
        //
        //  Public Properties
        //
        //------------------------------------------------------ 

        #region Public Properties 
        ///  
        ///     The visual target for the visuals being presented in the source.
        ///  
        /// 
        ///     Critical: Calls GetCompositionTargetCore() and returns a CompositionTarget object, which is considered critical.
        ///     PublicOk: Protected by a LinkDemand
        ///  
        public CompositionTarget CompositionTarget
        { 
            [UIPermissionAttribute(SecurityAction.LinkDemand,Window=UIPermissionWindow.AllWindows)] 
            [SecurityCritical]
            get 
            {
                return GetCompositionTargetCore();
            }
        } 

        ///  
        ///     The root visual being presented in the source. 
        /// 
        ///  
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API.
        /// 
        /// 
        ///     Critical: This code is not safe to expose publicly since it lets you 
        ///     change rootvisual which puts popup code at risk
        ///     PublicOK: Inheritance demand prevents random subclassing in partial trust 
        ///     and Linkdemand prevents unauthorized public callers 
        /// 
        public abstract Visual RootVisual 
        {
            get;
            [SecurityCritical]
            [UIPermissionAttribute(SecurityAction.InheritanceDemand, Window = UIPermissionWindow.AllWindows)] 
            [UIPermissionAttribute(SecurityAction.LinkDemand, Window = UIPermissionWindow.AllWindows)]
            set; 
        } 

        ///  
        ///     Causes this PresentationSource to enter "menu mode".
        /// 
        internal void PushMenuMode()
        { 
            _menuModeCount += 1;
            if(1 == _menuModeCount) 
            { 
                OnEnterMenuMode();
            } 
        }

        /// 
        ///     Causes this PresentationSource to enter "menu mode". 
        /// 
        internal void PopMenuMode() 
        { 
            if(_menuModeCount <= 0)
            { 
                throw new InvalidOperationException();
            }

            _menuModeCount -= 1; 
            if(0 == _menuModeCount)
            { 
                OnLeaveMenuMode(); 
            }
        } 

        /// 
        ///     Notification to derived classes to enter menu mode.
        ///  
        internal virtual void OnEnterMenuMode()
        { 
        } 

        ///  
        ///     Notification to derived classes to leave menu mode.
        /// 
        internal virtual void OnLeaveMenuMode()
        { 
        }
 
        private int _menuModeCount; 

        ///  
        ///     Whether or not the object is disposed.
        /// 
        public abstract bool IsDisposed
        { 
            get;
        } 
 
        #endregion
 
        //-----------------------------------------------------
        //
        //  Public Static Properties
        // 
        //------------------------------------------------------
 
        #region Public Static Properties 
        /// 
        ///   Return a WeakReferenceList which supports returning an Enumerator 
        ///   over a ReadOnly SnapShot of the List of sources.  The Enumerator
        ///   skips over the any dead weak references in the list.
        /// 
        ///  
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API.
        ///  
        ///  
        ///     Critical: This code exposes the sources which are deemed as critical. This is defense in depth.
        ///     PublicOK: There exists a demand in this code 
        /// 
        public static IEnumerable CurrentSources
        {
            [SecurityCritical] 
            get
            { 
                SecurityHelper.DemandUIWindowPermission(); 
                return CriticalCurrentSources;
            } 
        }


        #endregion 

        //----------------------------------------------------- 
        // 
        //  Public Events
        // 
        //-----------------------------------------------------

        #region Public Events
        ///  
        ///     This event fires when content is rendered and ready for user interaction.
        ///  
        public event EventHandler ContentRendered; 

        #endregion 

        //-----------------------------------------------------
        //
        //  Protected Methods 
        //
        //------------------------------------------------------ 
 
        #region Protected Methods
        ///  
        ///     Returns visual target for the given source. Implemented by
        ///     the derived class.
        /// 
        protected abstract CompositionTarget GetCompositionTargetCore(); 

 
        // 

 



 

 
 

 



 
        [SecurityCritical, SecurityTreatAsSafe]
        protected void RootChanged(Visual oldRoot, Visual newRoot) 
        { 
            PresentationSource oldSource = null;
 
            if (oldRoot == newRoot)
            {
                return;
            } 

            // Always clear the RootSourceProperty on the old root. 
            if (oldRoot != null) 
            {
                oldSource = CriticalGetPresentationSourceFromElement(oldRoot, RootSourceProperty); 
                oldRoot.ClearValue(RootSourceProperty);
            }

            // Always set the SourceProperty on the new root. 
            if (newRoot != null)
            { 
                newRoot.SetValue(RootSourceProperty, new SecurityCriticalDataForMultipleGetAndSet(this)); 
            }
 
            UIElement oldRootUIElement = oldRoot as UIElement;
            UIElement newRootUIElement = newRoot as UIElement;

            // The IsVisible property can only be true if root visual is connected to a presentation source. 
            // For Read-Only force-inherited properties, use a private update method.
            if(oldRootUIElement != null) 
            { 
                oldRootUIElement.UpdateIsVisibleCache();
            } 
            if(newRootUIElement != null)
            {
                newRootUIElement.UpdateIsVisibleCache();
            } 

            // Broadcast the Unloaded event starting at the old root visual 
            if (oldRootUIElement != null) 
            {
                oldRootUIElement.OnPresentationSourceChanged(false); 
            }

            // Broadcast the Loaded event starting at the root visual
            if (newRootUIElement != null) 
            {
                newRootUIElement.OnPresentationSourceChanged(true); 
            } 

            // To fire PresentationSourceChanged when the RootVisual changes; 
            // rather than simulate a "parent" pointer change, we just walk the
            // collection of all nodes that need the event.
            foreach (DependencyObject element in _watchers)
            { 
                // We only need to update those elements that are in the
                // same context as this presentation source. 
                if (element.Dispatcher == Dispatcher) 
                {
                    PresentationSource testSource = CriticalGetPresentationSourceFromElement(element,CachedSourceProperty); 
                    // 1) If we are removing the rootvisual, then fire on any node whos old
                    // PresetationSource was the oldSource.
                    // 2) If we are attaching a rootvisual then fire on any node whos old
                    // PresentationSource is null; 
                    if (oldSource == testSource || null == testSource)
                    { 
                        UpdateSourceOfElement(element, null, null); 
                    }
                } 
            }
        }

 

        ///  
        ///     Called by derived classes to indicate that they need to be tracked. 
        /// 
        protected void AddSource() 
        {
            _sources.Add(this);
        }
 
        /// 
        ///     Called by derived classes to indicate that they no longer need to be tracked. 
        ///  
        protected void RemoveSource()
        { 
            _sources.Remove(this);
        }

        ///  
        ///     Sets the ContentRendered event to null.
        ///  
        protected void ClearContentRenderedListeners() 
        {
            ContentRendered = null; 
        }

        #endregion
 
        //-----------------------------------------------------
        // 
        //  Internal Methods 
        //
        //------------------------------------------------------ 
        // None

        //------------------------------------------------------
        // 
        //  Internal Static Methods
        // 
        //----------------------------------------------------- 

        #region Internal Static Methods 
        /// 
        ///     Called by UIElement(3D)s when a visual ancestor link has changed.
        /// 
        /// The UIElement whose ancestory may have changed. 
        ///   Event Args.
        ///  
        ///     Critical: This code calls into a critical code path UpdateSourceOfElement. 
        ///     TreatAsSafe: This code does not access any critical data itself and does not expose
        ///     anything 
        /// 
        [SecurityCritical, SecurityTreatAsSafe]
        internal static void OnVisualAncestorChanged(DependencyObject uie, AncestorChangedEventArgs e)
        { 
            Debug.Assert(InputElement.IsUIElement3D(uie) || InputElement.IsUIElement(uie));
 
            if (true == (bool)uie.GetValue(GetsSourceChangedEventProperty)) 
            {
                UpdateSourceOfElement(uie, e.Ancestor, e.OldParent); 
            }
        }

        ///  
        ///     Critical - Returns the PresentationSource
        ///  
        [FriendAccessAllowed] // To allow internal code paths to access this function 
        [SecurityCritical]
        internal static PresentationSource CriticalFromVisual(DependencyObject v) 
        {
            return CriticalFromVisual(v, true /* enable2DTo3DTransition */);
        }
 
        /// 
        ///     Critical - uses RootSourceProperty. and returns the PresentationSource 
        ///  
        /// The dependency object to find the source for
        ///  
        ///     Determines whether when walking the tree to enable transitioning from a 2D child
        ///     to a 3D parent or to stop once a 3D parent is encountered.
        /// 
        [FriendAccessAllowed] // To allow internal code paths to access this function 
        [SecurityCritical]
        internal static PresentationSource CriticalFromVisual(DependencyObject v, bool enable2DTo3DTransition) 
        { 
            if (v == null)
            { 
                throw new ArgumentNullException("v");
            }

            PresentationSource source = FindSource(v, enable2DTo3DTransition); 

            // Don't hand out a disposed source. 
            if (null != source && source.IsDisposed) 
            {
                source = null; 
            }

            return source;
        } 

        ///  
        ///     Fire the event when content is rendered and ready for user interaction. 
        /// 
        ///  
        internal static object FireContentRendered(object arg)
        {
            PresentationSource ps = (PresentationSource)arg;
            if (ps.ContentRendered != null) 
            {
                ps.ContentRendered(arg, EventArgs.Empty); 
            } 
            return null;
        } 

        /// 
        ///     Helper method which returns true when all the given visuals
        ///     are in the same presentation source. 
        /// 
        [FriendAccessAllowed] // To allow internal code paths to access this function 
        [SecurityCritical, SecurityTreatAsSafe] 
        internal static bool UnderSamePresentationSource(params DependencyObject[] visuals)
        { 
            if (visuals == null || visuals.Length == 0)
            {
                return true;
            } 

            PresentationSource baseSource = CriticalFromVisual(visuals[0]); 
 
            int count = visuals.Length;
            for (int i = 1; i < count; i++) 
            {
                PresentationSource currentSource = CriticalFromVisual(visuals[i]);
                if (currentSource != baseSource)
                { 
                    return false;
                } 
            } 
            return true;
        } 

        #endregion

        //------------------------------------------------------ 
        //
        //  Internal Properties 
        // 
        //-----------------------------------------------------
        // None 

        //-----------------------------------------------------
        //
        //  Internal Events 
        //
        //----------------------------------------------------- 
        // None 

        //------------------------------------------------------ 
        //
        //  Private Static Methods
        //
        //----------------------------------------------------- 

        #region Private Static Methods 
        ///  
        ///   Return a WeakReferenceList which supports returning an Enumerator
        ///   over a ReadOnly SnapShot of the List of sources.  The Enumerator 
        ///   skips over the any dead weak references in the list.
        /// 
        /// 
        ///     Critical: This code exposes the sources which are deemed as critical. This is internal access point. 
        ///     Public consumers should use CurrentSources
        ///  
        internal static IEnumerable CriticalCurrentSources 
        {
            [SecurityCritical] 
            get
            {
                return (IEnumerable)_sources;
            } 
        }
 
        ///  
        ///     Critical: Returns a presentationsource given a canister
        ///  
        [SecurityCritical]
        private static PresentationSource CriticalGetPresentationSourceFromElement(DependencyObject dObject,DependencyProperty dp)
        {
            PresentationSource testSource; 
            SecurityCriticalDataForMultipleGetAndSet tempCriticalDataWrapper =
                (SecurityCriticalDataForMultipleGetAndSet < PresentationSource > ) 
                dObject.GetValue(dp); 
            if (tempCriticalDataWrapper == null || tempCriticalDataWrapper.Value == null)
            { 
                testSource = null;
            }
            else
            { 
                testSource = tempCriticalDataWrapper.Value;
            } 
            return testSource; 
        }
 
        /// 
        ///     Critical: This code acceses PresentationSource and stores it.
        /// 
        [SecurityCritical] 
        private static void AddElementToWatchList(DependencyObject element)
        { 
            if(_watchers.Add(element)) 
            {
                element.SetValue(CachedSourceProperty,new 
                    SecurityCriticalDataForMultipleGetAndSet(PresentationSource.FindSource(element)));
                element.SetValue(GetsSourceChangedEventProperty, true);
            }
        } 

 
        ///  
        ///     Critical: This code acceses PresentationSource
        ///     TreatAsSafe: This code is safe to expose. 
        /// 
        [SecurityCritical,SecurityTreatAsSafe]
        private static void RemoveElementFromWatchList(DependencyObject element)
        { 
            if(_watchers.Remove(element))
            { 
                element.ClearValue(CachedSourceProperty); 
                element.ClearValue(GetsSourceChangedEventProperty);
            } 
        }

        ///
        ///     Critical - Returns a PresentationSource. 
        ///
        [SecurityCritical] 
        private static PresentationSource FindSource(DependencyObject o) 
        {
            return FindSource(o, true /* enable2DTo3DTransition */); 
        }

        ///
        ///     Critical - uses RootSourceProperty and returns the PresentationSource 
        ///
        /// The dependency object to find the source for 
        ///  
        ///     Determines whether when walking the tree to enable transitioning from a 2D child
        ///     to a 3D parent or to stop once a 3D parent is encountered. 
        /// 
        [SecurityCritical]
        private static PresentationSource FindSource(DependencyObject o, bool enable2DTo3DTransition)
        { 
            PresentationSource source = null;
 
            // For "Visual" nodes GetRootVisual() climbs to the top of the 
            //       visual tree (parent==null)
            // For "ContentElements" it climbs the logical parent until it 
            // reaches a visual then climbs to the top of the visual tree.
            DependencyObject v = InputElement.GetRootVisual(o, enable2DTo3DTransition);
            if (v != null)
            { 
               source = CriticalGetPresentationSourceFromElement(v, RootSourceProperty);
            } 
            return source; 
        }
 
        /// 
        ///     Critical: This code accesses PresentationSource which is a critical resource. It then
        ///     packages it into an event args and fires it into the tree.
        ///  
        [SecurityCritical]
        private static bool UpdateSourceOfElement(DependencyObject doTarget, 
                                                  DependencyObject doAncestor, 
                                                  DependencyObject doOldParent)
        { 
            bool calledOut = false;

            PresentationSource realSource = FindSource(doTarget);
            PresentationSource cachedSource = CriticalGetPresentationSourceFromElement(doTarget, CachedSourceProperty); 
            if (cachedSource != realSource)
            { 
                doTarget.SetValue(CachedSourceProperty, new SecurityCriticalDataForMultipleGetAndSet(realSource)); 

                SourceChangedEventArgs args = new SourceChangedEventArgs(cachedSource, realSource); 

                args.RoutedEvent=SourceChangedEvent;
                if (InputElement.IsUIElement(doTarget))
                { 
                    ((UIElement)doTarget).RaiseEvent(args);
                } 
                else if (InputElement.IsContentElement(doTarget)) 
                {
                    ((ContentElement)doTarget).RaiseEvent(args); 
                }
                else
                {
                    ((UIElement3D)doTarget).RaiseEvent(args); 
                }
 
                calledOut = true; 
            }
 
            return calledOut;
        }

        #endregion 

        //------------------------------------------------------ 
        // 
        //  Private Static Members
        // 
        //------------------------------------------------------

        #region Private Static Members
        // We use a private DP for the RootSource (the connection from the root 
        // element in a tree to the source it is displayed in).  Use the public
        // API FromVisual to get the source that a visual is displayed in. 
        /// 
        ///     Critical - used to store PresentationSource
        /// 
        [SecurityCritical]
        private static readonly DependencyProperty RootSourceProperty
            = DependencyProperty.RegisterAttached("RootSource", typeof(SecurityCriticalDataForMultipleGetAndSet), typeof(PresentationSource),
                                          new PropertyMetadata((SecurityCriticalDataForMultipleGetAndSet)null)); 

        // We use a private DP for the CachedSource (stored on the elements 
        // that we are watching, so that we can send a change notification). 
        // Use the public API FromVisual to get the source that a visual is
        // displayed in. 
        ///
        ///     Critical - used to store PresentationSource
        ///
        [SecurityCritical] 
        private static readonly DependencyProperty CachedSourceProperty
            = DependencyProperty.RegisterAttached("CachedSource", typeof(SecurityCriticalDataForMultipleGetAndSet), typeof(PresentationSource), 
                                          new PropertyMetadata((SecurityCriticalDataForMultipleGetAndSet)null)); 

        // We use a private DP to mark elements that we are watchin. 
        private static readonly DependencyProperty GetsSourceChangedEventProperty = DependencyProperty.RegisterAttached("IsBeingWatched", typeof(bool), typeof(PresentationSource), new PropertyMetadata((bool)false));

        // We use a private direct-only event to notify elements of when the
        // source changes.  Use the public APIs AddSourceChangedHandler and 
        // RemoveSourceChangedHandler to listen to this event.
        private static readonly RoutedEvent SourceChangedEvent = EventManager.RegisterRoutedEvent("SourceChanged", RoutingStrategy.Direct, typeof(SourceChangedEventHandler), typeof(PresentationSource)); 
 
        // The lock we use to protect our static data.
        private static object _globalLock = new object(); 

        // An array of weak-references to sources that we know about.
        private static WeakReferenceList _sources = new WeakReferenceList(_globalLock);
 
        // An array of weak-references to elements that need to know
        // about source changes. 
        private static WeakReferenceList _watchers = new WeakReferenceList(_globalLock); 

        #endregion 

    }
}
 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK