InputElement.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 / Input / InputElement.cs / 1305600 / InputElement.cs

                            using System.Windows.Media; 
using MS.Win32;
using MS.Internal;
using System.Security;
using System.Security.Permissions; 
using System.Runtime.InteropServices;
using System.Windows.Interop; 
using System.Windows.Media.Media3D; 
using System;
 
namespace System.Windows.Input
{
    // Helper class for working with IInputElement objects.
    internal static class InputElement 
    {
        // Return whether the InputElement is one of our types. 
        internal static bool IsValid(IInputElement e) 
        {
            DependencyObject o = e as DependencyObject; 
            return IsValid(o);
        }

        internal static bool IsValid(DependencyObject o) 
        {
            return IsUIElement(o) || IsContentElement(o) || IsUIElement3D(o); 
 
        }
 
        // Returns whether the given DynamicObject is a UIElement or not.
        internal static bool IsUIElement(DependencyObject o)
        {
            return UIElementType.IsInstanceOfType(o); 
        }
 
        // Returns whether the given DynamicObject is a UIElement3D or not. 
        internal static bool IsUIElement3D(DependencyObject o)
        { 
            return UIElement3DType.IsInstanceOfType(o);
        }

        // Returns whether the given DynamicObject is a ContentElement or not. 
        internal static bool IsContentElement(DependencyObject o)
        { 
            return ContentElementType.IsInstanceOfType(o); 
        }
 
        // Returns the containing input element of the given DynamicObject.
        // If onlyTraverse2D is set to true, then we stop once we see a 3D object and return null
        internal static DependencyObject GetContainingUIElement(DependencyObject o, bool onlyTraverse2D)
        { 
            DependencyObject container = null;
            Visual v; 
            Visual3D v3D; 

            if(o != null) 
            {
                if(IsUIElement(o))
                {
                    container = o; 
                }
                else if (IsUIElement3D(o) && !onlyTraverse2D) 
                { 
                    container = o;
                } 
                else if(IsContentElement(o))
                {
                    DependencyObject parent = ContentOperations.GetParent((ContentElement)o);
                    if(parent != null) 
                    {
                        container = GetContainingUIElement(parent, onlyTraverse2D); 
                    } 
                    else
                    { 
                        //


                        parent = ((ContentElement)o).GetUIParentCore(); 
                        if(parent != null)
                        { 
                            container = GetContainingUIElement(parent, onlyTraverse2D); 
                        }
                    } 
                }
                else if ((v = o as Visual) != null)
                {
                    DependencyObject parent = VisualTreeHelper.GetParent(v); 
                    if(parent != null)
                    { 
                        container = GetContainingUIElement(parent, onlyTraverse2D); 
                    }
                } 
                else if (!onlyTraverse2D && (v3D = o as Visual3D) != null)
                {
                    DependencyObject parent = VisualTreeHelper.GetParent(v3D);
                    if (parent != null) 
                    {
                        container = GetContainingUIElement(parent, onlyTraverse2D); 
                    } 
                }
            } 

            return container;
        }
 
        // Returns the containing input element of the given DynamicObject.
        internal static DependencyObject GetContainingUIElement(DependencyObject o) 
        { 
            return GetContainingUIElement(o, false);
        } 


        // Returns the containing input element of the given DynamicObject.
        // If onlyTraverse2D is set to true, then we stop once we see a 3D object and return null 
        internal static IInputElement GetContainingInputElement(DependencyObject o, bool onlyTraverse2D)
        { 
            IInputElement container = null; 
            Visual v;
            Visual3D v3D; 

            if(o != null)
            {
                if(IsUIElement(o)) 
                {
                    container = (UIElement) o; 
                } 
                else if(IsContentElement(o))
                { 
                    container = (ContentElement) o;
                }
                else if (IsUIElement3D(o) && !onlyTraverse2D)
                { 
                    container = (UIElement3D)o;
                } 
                else if((v = o as Visual) != null) 
                {
                    DependencyObject parent = VisualTreeHelper.GetParent(v); 
                    if(parent != null)
                    {
                        container = GetContainingInputElement(parent, onlyTraverse2D);
                    } 
                }
                else if (!onlyTraverse2D && (v3D = o as Visual3D) != null) 
                { 
                    DependencyObject parent = VisualTreeHelper.GetParent(v3D);
                    if (parent != null) 
                    {
                        container = GetContainingInputElement(parent, onlyTraverse2D);
                    }
                } 
            }
 
            return container; 
        }
 
        // Returns the containing input element of the given DynamicObject.
        //
        internal static IInputElement GetContainingInputElement(DependencyObject o)
        { 
            return GetContainingInputElement(o, false);
        } 
 
        // Returns the containing visual of the given DynamicObject.
        internal static DependencyObject GetContainingVisual(DependencyObject o) 
        {
            DependencyObject v = null;

            if(o != null) 
            {
                if(IsUIElement(o)) 
                { 
                    v = (Visual)o;
                } 
                else if (IsUIElement3D(o))
                {
                    v = (Visual3D)o;
                } 
                else if(IsContentElement(o))
                { 
                    DependencyObject parent = ContentOperations.GetParent((ContentElement)o); 
                    if(parent != null)
                    { 
                        v = GetContainingVisual(parent);
                    }
                    else
                    { 
                        //
 
 
                        parent = ((ContentElement)o).GetUIParentCore();
                        if(parent != null) 
                        {
                            v = GetContainingVisual(parent);
                        }
                    } 
                }
                else 
                { 
                    v = o as Visual;
 
                    if (v == null)
                    {
                        v = o as Visual3D;
                    } 
                }
            } 
 
            return v;
        } 

        // Returns the root visual of the containing element.
        internal static DependencyObject GetRootVisual(DependencyObject o)
        { 
            return GetRootVisual(o, true /* enable2DTo3DTransition */);
        } 
 
        internal static DependencyObject GetRootVisual(DependencyObject o, bool enable2DTo3DTransition)
        { 
            DependencyObject rootVisual = GetContainingVisual(o);
            DependencyObject parentVisual;

            while(rootVisual != null && ((parentVisual = VisualTreeHelper.GetParent(rootVisual)) != null)) 
            {
                // if we are not supposed to transition from 2D to 3D and the root 
                // is a Visual and the parent is a Visual3D break 
                if (!enable2DTo3DTransition &&
                     rootVisual is Visual && parentVisual is Visual3D) 

                {
                    break;
                } 

                rootVisual = parentVisual; 
            } 

 
            return rootVisual;
        }

        ///  
        ///     Critical: This code accesses PresetationSource
        ///     TreatAsSafe: This code does not expose the critical resource. 
        ///                  Translating points considered safe to expose. 
        /// 
        [SecurityCritical,SecurityTreatAsSafe] 
        internal static Point TranslatePoint(Point pt, DependencyObject from, DependencyObject to)
        {
            bool unused = false;
            return TranslatePoint(pt, from, to, out unused); 
        }
 
        ///  
        ///     Critical: This code accesses PresetationSource
        ///     TreatAsSafe: This code does not expose the critical resource. 
        ///                  Translating points considered safe to expose.
        /// 
        [SecurityCritical,SecurityTreatAsSafe]
        internal static Point TranslatePoint(Point pt, DependencyObject from, DependencyObject to, out bool translated) 
        {
            translated = false; 
 
            Point ptTranslated = pt;
 
            // Get the containing and root visuals we are coming from.
            DependencyObject vFromAsDO = InputElement.GetContainingVisual(from);
            Visual rootFrom = InputElement.GetRootVisual(from) as Visual;
 
            Visual vFrom = vFromAsDO as Visual;
 
            if (vFromAsDO != null && vFrom == null) 
            {
                // must be a Visual3D - get it's 2D visual parent 
                vFrom = VisualTreeHelper.GetContainingVisual2D(vFromAsDO);
            }

            if(vFrom != null && rootFrom != null) 
            {
                GeneralTransform gUp; 
                Matrix mUp; 

                bool isUpSimple = false; 
                isUpSimple = vFrom.TrySimpleTransformToAncestor(rootFrom,
                                                                false, /* do not apply inverse */
                                                                out gUp,
                                                                out mUp); 
                if (isUpSimple)
                { 
                    ptTranslated = mUp.Transform(ptTranslated); 
                }
                else if (gUp.TryTransform(ptTranslated, out ptTranslated) == false) 
                {
                    // Error.  Out parameter has been set false.
                    return new Point();
                } 

                // If no element was specified to translate to, we leave the coordinates 
                // translated to the root. 
                if(to != null)
                { 
                    // Get the containing and root visuals we are going to.
                    DependencyObject vTo = InputElement.GetContainingVisual(to);
                    Visual rootTo = InputElement.GetRootVisual(to) as Visual;
 
                    if(vTo != null && rootTo != null)
                    { 
                        // If both are under the same root visual, we can easily translate the point 
                        // between them by translating up to the root, and then back down.
                        // 
                        // However, if both are under different roots, we can only translate
                        // between them if we know how to relate the two root visuals.  Currently
                        // we only know how to do that if both roots are sourced in HwndSources.
                        if(rootFrom != rootTo) 
                        {
                            HwndSource sourceFrom = PresentationSource.CriticalFromVisual(rootFrom) as HwndSource; 
                            HwndSource sourceTo = PresentationSource.CriticalFromVisual(rootTo) as HwndSource; 

 
                            if(sourceFrom != null && sourceFrom.CriticalHandle != IntPtr.Zero && sourceFrom.CompositionTarget != null &&
                               sourceTo != null && sourceTo.CriticalHandle != IntPtr.Zero && sourceTo.CompositionTarget != null)
                            {
                                // Translate the point into client coordinates. 
                                ptTranslated = PointUtil.RootToClient(ptTranslated, sourceFrom);
 
                                // Translate the point into screen coordinates. 
                                Point ptScreen = PointUtil.ClientToScreen(ptTranslated, sourceFrom);
 
                                // Translate the point back the the client coordinates of the To window.
                                ptTranslated = PointUtil.ScreenToClient(ptScreen, sourceTo);

                                // Translate the point back to the root element. 
                                ptTranslated = PointUtil.ClientToRoot(ptTranslated, sourceTo);
 
                            } 
                            else
                            { 
                                // Error.  Out parameter has been set false.
                                return new Point();
                            }
                        } 

                        // Translate the point from the root to the visual. 
                        GeneralTransform gDown; 
                        Matrix mDown;
 
                        Visual vToAsVisual = vTo as Visual;
                        if (vToAsVisual == null)
                        {
                            // must be a Visual3D 
                            vToAsVisual = VisualTreeHelper.GetContainingVisual2D(vTo);
                        } 
 
                        bool isDownSimple = vToAsVisual.TrySimpleTransformToAncestor(rootTo,
                                                                                     true, /* apply inverse */ 
                                                                                     out gDown,
                                                                                     out mDown);

                        if (isDownSimple) 
                        {
                            ptTranslated = mDown.Transform(ptTranslated); 
                        } 
                        else if (gDown != null)
                        { 
                            if (gDown.TryTransform(ptTranslated, out ptTranslated) == false)
                            {
                                // Error.  Out parameter has been set false.
                                return new Point(); 
                            }
                        } 
                        else 
                        {
                            // Error.  Out parameter has been set false. 
                            return new Point();
                        }
                    }
                    else 
                    {
                        // Error.  Out parameter has been set false. 
                        return new Point(); 
                    }
                } 
            }
            else
            {
                // Error.  Out parameter has been set false. 
                return new Point();
            } 
 
            translated = true;
            return ptTranslated; 
        }

        // Caches the ContentElement's DependencyObjectType
        private static DependencyObjectType ContentElementType = DependencyObjectType.FromSystemTypeInternal(typeof(ContentElement)); 

        // Caches the UIElement's DependencyObjectType 
        private static DependencyObjectType UIElementType = DependencyObjectType.FromSystemTypeInternal(typeof(UIElement)); 

        // Caches the UIElement3D's DependencyObjectType 
        private static DependencyObjectType UIElement3DType = DependencyObjectType.FromSystemTypeInternal(typeof(UIElement3D));
    }
}
 

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