VisualTreeHelper.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Core / System / Windows / Media / VisualTreeHelper.cs / 3 / VisualTreeHelper.cs
                        

                        
                            //------------------------------------------------------------------------------ 
//  Microsoft Avalon
//  Copyright (c) Microsoft Corporation, 2003
//
//  File:       VisualTreeHelper 
//-----------------------------------------------------------------------------
using System; 
using System.Windows.Media; 
using System.Windows.Media.Media3D;
using System.Windows.Media.Animation; 
using System.Windows.Threading;
using System.Security.Permissions;
using System.Windows.Media.Effects;
 
using System.Collections;
using System.Diagnostics; 
using MS.Internal; 
using MS.Internal.Media;
using MS.Internal.PresentationCore; 

using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
 
namespace System.Windows.Media
{ 
    ///  
    /// The VisualTreeHelper class contains static methods that are useful for performing
    /// common tasks with visual tree nodes.  Nodes in the visual tree may be Visual or 
    /// Visual3Ds.
    ///
    /// When possible methods are typed to DependencyObject and may accept or
    /// return either type of visual tree node (e.g. GetParent). 
    ///
    /// When the result of the operation is specific to 2D or 3D the methods are typed 
    /// to Visual or Visual3D (e.g., GetDescendantBounds()). 
    /// 
    public static class VisualTreeHelper 
    {
        private static void CheckVisualReferenceArgument(DependencyObject reference)
        {
            if (reference == null) 
            {
                throw new ArgumentNullException("reference"); 
            } 
        }
 
        /// 
        /// Get the number of children of the specified Visual.
        /// 
        public static int GetChildrenCount(DependencyObject reference) 
        {
            Visual visual; 
            Visual3D visual3D; 

            VisualTreeUtils.AsNonNullVisual(reference, out visual, out visual3D); 

            // x86 branch prediction skips the branch on first encounter.  We favor 2D.
            if (visual3D != null)
            { 
                return visual3D.InternalVisual2DOr3DChildrenCount;
            } 
 
            //
            // Even though visual is a 2D visual, it still may have 
            // 3D children.
            //
            return visual.InternalVisual2DOr3DChildrenCount;
        } 

        ///  
        /// Returns the child of Visual visual at the specified index. 
        /// 
        public static DependencyObject GetChild(DependencyObject reference, int childIndex) 
        {
            Visual visual;
            Visual3D visual3D;
 
            VisualTreeUtils.AsNonNullVisual(reference, out visual, out visual3D);
 
            // x86 branch prediction skips the branch on first encounter.  We favor 2D. 
            if (visual3D != null)
            { 
                return visual3D.InternalGet2DOr3DVisualChild(childIndex);
            }

            // 
            // Even though visual is a 2D visual, it still may have
            // 3D children. 
            // 
            return visual.InternalGet2DOr3DVisualChild(childIndex);
        } 

        /// 
        /// Visual parent of this Visual.
        ///  
        public static DependencyObject GetParent(DependencyObject reference)
        { 
            Visual visual; 
            Visual3D visual3D;
 
            VisualTreeUtils.AsNonNullVisual(reference, out visual, out visual3D);

            // x86 branch prediction skips the branch on first encounter.  We favor 2D.
            if (visual3D != null) 
            {
                return visual3D.InternalVisualParent; 
            } 

            return visual.InternalVisualParent; 
        }

        /// 
        /// Equivalent to GetParent except that it does not VerifyAccess and only asserts 
        /// in
 
 

 
        [FriendAccessAllowed]
        internal static DependencyObject GetParentInternal(DependencyObject reference)
        {
            Visual visual; 
            Visual3D visual3D;
 
            VisualTreeUtils.AsVisualInternal(reference, out visual, out visual3D); 

            if (visual != null) 
            {
                return visual.InternalVisualParent;
            }
 
            if (visual3D != null)
            { 
                return visual3D.InternalVisualParent; 
            }
 
            Debug.Assert(reference == null);

            return null;
        } 

        ///  
        /// Returns the closest Visual that contains the given DependencyObject 
        /// 
        internal static Visual GetContainingVisual2D(DependencyObject reference) 
        {
            Visual visual = null;

            while (reference != null) 
            {
                visual = reference as Visual; 
 
                if (visual != null) break;
 
                reference = VisualTreeHelper.GetParent(reference);
            }

            return visual; 
        }
 
        ///  
        /// Returns the closest Visual3D that contains the given DependencyObject
        ///  
        internal static Visual3D GetContainingVisual3D(DependencyObject reference)
        {
            Visual3D visual3D = null;
 
            while (reference != null)
            { 
                visual3D = reference as Visual3D; 

                if (visual3D != null) break; 

                reference = VisualTreeHelper.GetParent(reference);
            }
 
            return visual3D;
        } 
 
        internal static bool IsAncestorOf(DependencyObject reference, DependencyObject descendant)
        { 
            Visual visual;
            Visual3D visual3D;

            VisualTreeUtils.AsNonNullVisual(reference, out visual, out visual3D); 

            // x86 branch prediction skips the branch on first encounter.  We favor 2D. 
            if (visual3D != null) 
            {
                return visual3D.IsAncestorOf(descendant); 
            }

            return visual.IsAncestorOf(descendant);
        } 

        internal static DependencyObject FindCommonAncestor(DependencyObject reference, DependencyObject otherVisual) 
        { 
            Visual visual;
            Visual3D visual3D; 

            VisualTreeUtils.AsNonNullVisual(reference, out visual, out visual3D);

            // x86 branch prediction skips the branch on first encounter.  We favor 2D. 
            if (visual3D != null)
            { 
                return visual3D.FindCommonVisualAncestor(otherVisual); 
            }
 
            return visual.FindCommonVisualAncestor(otherVisual);
        }

        ///  
        /// Gets the clip of this Visual.
        ///  
        public static Geometry GetClip(Visual reference) 
        {
            CheckVisualReferenceArgument(reference); 
            return reference.VisualClip;
        }

        ///  
        /// Gets the opacity of the Visual.
        ///  
        public static double GetOpacity(Visual reference) 
        {
            CheckVisualReferenceArgument(reference); 
            return reference.VisualOpacity;
        }

        ///  
        /// Gets the OpacityMask.
        ///  
        public static Brush GetOpacityMask(Visual reference) 
        {
            CheckVisualReferenceArgument(reference); 
            return reference.VisualOpacityMask;
        }

        ///  
        /// Returns the offset of the Visual.
        ///  
        public static Vector GetOffset(Visual reference) 
        {
            CheckVisualReferenceArgument(reference); 
            return reference.VisualOffset;
        }

         ///  
        /// Returns the Visual transform.
        ///  
        public static Transform GetTransform(Visual reference) 
        {
            CheckVisualReferenceArgument(reference); 
            return reference.VisualTransform;
        }

        ///  
        /// Returns X-coordinate (vertical) guideline collection.
        ///  
        public static DoubleCollection GetXSnappingGuidelines(Visual reference) 
        {
            CheckVisualReferenceArgument(reference); 
            return reference.VisualXSnappingGuidelines;
        }

         ///  
        /// Returns Y-coordinate (horizontal) guideline collection.
        ///  
        public static DoubleCollection GetYSnappingGuidelines(Visual reference) 
        {
            CheckVisualReferenceArgument(reference); 
            return reference.VisualYSnappingGuidelines;
        }

        ///  
        /// GetDrawing returns the drawing content of the reference Visual
        ///  
        public static DrawingGroup GetDrawing(Visual reference) 
        {
            CheckVisualReferenceArgument(reference); 
            return reference.GetDrawing();
        }

        ///  
        /// GetContentBounds returns the bounding box for the contents of the specified visual.
        ///  
        public static Rect GetContentBounds(Visual reference) 
        {
            CheckVisualReferenceArgument(reference); 
            return reference.VisualContentBounds;
        }

        ///  
        /// GetContentBounds returns the bounding box for the contents of the specified visual.
        ///  
        public static Rect3D GetContentBounds(Visual3D reference) 
        {
            CheckVisualReferenceArgument(reference); 
            return reference.VisualContentBounds;
        }

        ///  
        /// GetDescendantBounds returns the union of all of the content bounding
        /// boxes of the specified Visual's sub-graph. 
        ///  
        public static Rect GetDescendantBounds(Visual reference)
        { 
            CheckVisualReferenceArgument(reference);
            return reference.VisualDescendantBounds;
        }
 
        /// 
        /// GetDescendantBounds returns the union of all of the content bounding 
        /// boxes of the specified Visual3D's sub-graph. 
        /// 
        public static Rect3D GetDescendantBounds(Visual3D reference) 
        {
            CheckVisualReferenceArgument(reference);
            return reference.VisualDescendantBounds;
        } 

        ///  
        /// Gets the BitmapEffect. 
        /// 
        public static BitmapEffect GetBitmapEffect(Visual reference) 
        {
            CheckVisualReferenceArgument(reference);
            return reference.VisualBitmapEffect;
        } 

        ///  
        /// Gets the BitmapEffectInput. 
        /// 
        public static BitmapEffectInput GetBitmapEffectInput(Visual reference) 
        {
            CheckVisualReferenceArgument(reference);
            return reference.VisualBitmapEffectInput;
        } 

        ///  
        /// Gets the EdgeMode of the Visual. 
        /// 
        public static EdgeMode GetEdgeMode(Visual reference) 
        {
            CheckVisualReferenceArgument(reference);
            return reference.VisualEdgeMode;
        } 

        ///  
        /// Return top most visual of a hit test. 
        /// 
        public static HitTestResult HitTest(Visual reference, Point point) 
        {
            return HitTest(reference, point, true);
        }
 
        /// 
        ///  
        [FriendAccessAllowed] 
        internal static HitTestResult HitTest(Visual reference, Point point, bool include2DOn3D)
        { 
            CheckVisualReferenceArgument(reference);

            return reference.HitTest(point, include2DOn3D);
        } 

        ///  
        /// Initiate a hit test using delegates. 
        /// 
        public static void HitTest( 
            Visual reference,
            HitTestFilterCallback filterCallback,
            HitTestResultCallback resultCallback,
            HitTestParameters hitTestParameters) 
        {
            CheckVisualReferenceArgument(reference); 
            reference.HitTest(filterCallback, resultCallback, hitTestParameters); 
        }
 
        /// 
        /// Initiate a hit test using delegates.
        /// 
        public static void HitTest( 
            Visual3D reference,
            HitTestFilterCallback filterCallback, 
            HitTestResultCallback resultCallback, 
            HitTestParameters3D hitTestParameters)
        { 
            CheckVisualReferenceArgument(reference);
            reference.HitTest(filterCallback, resultCallback, hitTestParameters);
        }
 
#if WCP_MF_ENABLED
        ///  
        /// Serialize a visual to fixed (S0) XAML 
        /// 
        ///  
        /// 
        static internal void SaveAsXml(Visual visual, System.Xml.XmlWriter writer)
        {
            VisualTreeFlattener.SaveAsXml(visual, writer, new FixedXamlDesigner()); 
        }
 
        ///  
        /// Walk a visual tree and flatten it to (S0) DrawingContext
        ///  
        /// 
        /// 
        //CASRemoval:[StrongNameIdentityPermission(SecurityAction.LinkDemand, PublicKey=Microsoft.Internal.BuildInfo.WCP_PUBLIC_KEY_STRING)]
        static public void Walk(Visual visual, DrawingContext dc) 
        {
            VisualTreeFlattener flattener = new VisualTreeFlattener(dc); 
 
            flattener.Walk(visual, null);
        } 
#endif // WCP_MF_ENABLED

    }
} 

 
 

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