C# Visual.InternalGetVisualChild方法代码示例

        /// <summary>
        /// Does deep Visual tree walk to retrieve all DocumentPageViews.
        /// It stops recursing down into visual tree in following situations:
        /// a) Visual is UIElement and it is not part of Contol Template,
        /// b) Visual is DocumentPageView.
        /// </summary>
        /// <param name="root">FrameworkElement that is part of Control Template.</param>
        /// <param name="pageViews">Collection of DocumentPageViews; found elements are appended here.</param>
        /// <returns>Whether collection of DocumentPageViews has been updated.</returns>
        private static void FindDocumentPageViews(Visual root, List<DocumentPageView> pageViews)
        {
            Invariant.Assert(root != null);
            Invariant.Assert(pageViews != null);

            if (root is DocumentPageView)
            {
                pageViews.Add((DocumentPageView)root);
            }
            else
            {
                FrameworkElement fe;
                // Do deep tree walk to retrieve all DocumentPageViews.
                // It stops recursing down into visual tree in following situations:
                // a) Visual is UIElement and it is not part of Contol Template,
                // b) Visual is DocumentPageView.
                // Add to collection any DocumentPageViews found in the Control Template.
                int count = root.InternalVisualChildrenCount;
                for (int i = 0; i < count; i++)
                {
                    Visual child = root.InternalGetVisualChild(i);
                    fe = child as FrameworkElement;
                    if (fe != null)
                    {
                        if (fe.TemplatedParent != null)
                        {
                            if (fe is DocumentPageView)
                            {
                                pageViews.Add(fe as DocumentPageView);
                            }
                            else
                            {
                                FindDocumentPageViews(fe, pageViews);
                            }
                        }
                    }
                    else
                    {
                        FindDocumentPageViews(child, pageViews);
                    }
                }
            }
        }

 // ------------------------------------------------------------------
 // Walk visual children and find children UIElements. Performs deep 
 // walk of visual tree, but stops when runs into a UIElement.
 // All found UIElements are appended to uiElements collection.
 //
 //      visual - Visual element from which UIElements are extracted.
 //      uiElements - collection of UIElements.
 // ------------------------------------------------------------------
 internal static void GetUIElementsFromVisual(Visual visual, List<UIElement> uiElements)
 {
     int count = VisualTreeHelper.GetChildrenCount(visual);
     
     for(int i = 0; i < count; i++)
     {
         Visual child = visual.InternalGetVisualChild(i);
         if (child is UIElement)
         {
             uiElements.Add((UIElement)(child));
         }
         else
         {
             GetUIElementsFromVisual(child, uiElements);
         }
     }
 }

        /// <summary>
        /// Does deep Visual tree walk to retrieve an AdornerDecorator. Because
        /// AdornerDecorator is supposed to cover all DocumentPageViews, it stops
        /// recursing down into visual tree in following situations:
        /// a) Visual is UIElement and it is not part of Contol Template,
        /// b) Visual is DocumentPageView.
        /// c) Visual is AdornerDecorator.
        /// </summary>
        /// <param name="root">FrameworkElement that is part of Control Template.</param>
        /// <returns>AdornerDecorator, if found.</returns>
        private AdornerDecorator FindAdornerDecorator(Visual root)
        {
            Invariant.Assert(root != null);

            FrameworkElement fe;
            AdornerDecorator adornerDecorator = null;

            // Do deep Visual tree walk to retrieve an AdornerDecorator. Because
            // AdornerDecorator is supposed to cover all DocumentPageViews, it stops
            // recursing down into visual tree in following situations:
            // a) Visual is UIElement and it is not part of Contol Template,
            // b) Visual is DocumentPageView.
            // c) Visual is AdornerDecorator.
            int count = root.InternalVisualChildrenCount;
            for(int i = 0; i < count; i++)
            {
                Visual child = root.InternalGetVisualChild(i);
                fe = child as FrameworkElement;
                if (fe != null)
                {
                    if (fe.TemplatedParent != null)
                    {
                        if (fe is AdornerDecorator)
                        {
                            adornerDecorator = (AdornerDecorator)fe;
                        }
                        else if (!(fe is DocumentPageView))
                        {
                            adornerDecorator = FindAdornerDecorator(fe);
                        }
                        // else stop on DocumentPageView
                    }
                }
                else
                {
                    adornerDecorator = FindAdornerDecorator(child);
                }
                if (adornerDecorator != null)
                {
                    break;
                }
            }
            return adornerDecorator;
        }

        //
        private static bool iterate(Visual parent, IteratorCallback callback) 
        {
            bool done = false;

            AutomationPeer peer = null; 

            int count = parent.InternalVisualChildrenCount; 
            for (int i = 0; i < count && !done; i++) 
            {
                Visual child = parent.InternalGetVisualChild(i); 
                if (child != null
                    && child.CheckFlagsAnd(VisualFlags.IsUIElement)
                    && (peer = CreatePeerForElement((UIElement)child)) != null)
                { 
                    done = callback(peer);
                } 
                else 
                {
                    done = iterate(child, callback); 
                }
            }

            return (done); 
        }

        // ------------------------------------------------------------------
        // Dump visual children.
        // ------------------------------------------------------------------
        private static void DumpVisualChildren(XmlTextWriter writer, string tagName, Visual visualParent)
        {
            int count = VisualTreeHelper.GetChildrenCount(visualParent);

            if (count>0)
            {

                writer.WriteStartElement(tagName);
                writer.WriteAttributeString("Count", count.ToString(CultureInfo.InvariantCulture));

                for(int i = 0; i < count; i++)
                {
                    DumpVisual(writer, visualParent.InternalGetVisualChild(i), visualParent);
                }

                writer.WriteEndElement();
            }
        }

        private void markTreeDirtyHelper(Visual v) 
        {
            //now walk down and mark all UIElements dirty 
            if(v != null) 
            {
                if(v.CheckFlagsAnd(VisualFlags.IsUIElement)) 
                {
                    UIElement uie = ((UIElement)v);
                    uie.InvalidateMeasureInternal();
                    uie.InvalidateArrangeInternal(); 
                }
 
                //walk children doing the same, don't stop if they are already dirty since there can 
                //be insulated dirty islands below
                int cnt = v.InternalVisualChildrenCount; 

                for(int i=0; i<cnt; i++)
                {
                    Visual child = v.InternalGetVisualChild(i); 
                    if (child != null) markTreeDirtyHelper(child);
                } 
            } 
        }

        private void CloneVisualTree(ContainerVisual parent, Visual old)
        { 
            DrawingVisual visual = new DrawingVisual();
            parent.Children.Add(visual); 
 
            visual.Clip = VisualTreeHelper.GetClip(old);
            visual.Offset = VisualTreeHelper.GetOffset(old); 
            visual.Transform = VisualTreeHelper.GetTransform(old);
            visual.Opacity = VisualTreeHelper.GetOpacity(old);
            visual.OpacityMask = VisualTreeHelper.GetOpacityMask(old);
 
#pragma warning disable 0618
            visual.BitmapEffectInput = VisualTreeHelper.GetBitmapEffectInput(old); 
            visual.BitmapEffect = VisualTreeHelper.GetBitmapEffect(old); 
#pragma warning restore 0618
 
            // snapping guidelines??

            DrawingContext dc = visual.RenderOpen();
            dc.DrawDrawing(old.GetDrawing()); 
            dc.Close();
 
            int count = VisualTreeHelper.GetChildrenCount(old); 
            for(int i = 0; i < count; i++)
            { 
                Visual child = old.InternalGetVisualChild(i);
                CloneVisualTree(visual, child);
            }
 
        }

        // 






        private static Visual FindVisibleSibling(Visual parent, Visual child, bool searchForwards)
        {
            //
            // First we figure out the index of the specified child Visual. This is why the runtime
            // of this method is O(n).
            
            int childrenCount = parent.InternalVisualChildrenCount;
            int childIndex;

            for (childIndex = 0; childIndex < childrenCount; childIndex++)
            {
                Visual current = parent.InternalGetVisualChild(childIndex);
                if (current == child)
                {
                    // Found the child.
                    break;
                }
            }

            //
            // Now that we have the child index, we can go and lookup the sibling.
            if(searchForwards)
                return FindVisibleSibling(parent, childIndex+1, searchForwards); // (FindVisibleSibling can deal with out of range indices).
            else
                return FindVisibleSibling(parent, childIndex-1, searchForwards); // (FindVisibleSibling can deal with out of range indices).
        }

 private int IndexOf(Visual parent, Visual child, out Visual prevChild)
 {
     Visual temp;
     bool foundIndex = false; 
     prevChild = null;
     int count = parent.InternalVisualChildrenCount; 
     int i; 
     for(i = 0; i < count; i++)
     { 
         temp = parent.InternalGetVisualChild(i);
         if(child == temp)
         {
             foundIndex = true; 
             break;
         } 
         prevChild = temp; 
     }
     if (foundIndex) return i; 
     else return -1;
 }

        //--------------------------------------------------------------------
        //
        //  Private Methods
        // 
        //-------------------------------------------------------------------
 
        #region Private Methods 

        private static void iterate(Visual parent, List<AutomationPeer> peers) 
        {
            AutomationPeer peer = null;
            int count = parent.InternalVisualChildrenCount;
            for (int i = 0; i < count; i++) 
            {
                Visual child = parent.InternalGetVisualChild(i); 
                if (child != null 
                    && child.CheckFlagsAnd(VisualFlags.IsUIElement)
                    && (peer = UIElementAutomationPeer.CreatePeerForElement((UIElement)child)) != null) 
                {
                    peers.Add(peer);
                }
                else 
                {
                    iterate(child, peers); 
                } 
            }
        } 

        internal static Visual FindVisualByType(Visual parent, Type type) 
        { 
            if (parent != null)
            { 
                int count = parent.InternalVisualChildrenCount;
                for (int i = 0; i < count; i++)
                {
                    Visual visual = parent.InternalGetVisualChild(i); 
                    if (!type.IsInstanceOfType(visual))
                    { 
                        visual = FindVisualByType(visual, type); 
                    }
 
                    if (visual != null)
                    {
                        return visual;
                    } 
                }
            } 
 
            return null;
        } 

        /// <summary>
        /// Recursively resets IsLayoutSuspended flag on all visuals of the whole v's sub tree.
        /// For UIElements also re-inserts the UIElement into Measure and / or Arrange update queues
        /// if necessary.
        /// </summary>
        internal static void PropagateResumeLayout(Visual parent, Visual v)
        {
            if(v.CheckFlagsAnd(VisualFlags.IsLayoutIslandRoot)) return;

            //the subtree is already active - happens when new elements are added to the active tree
            //elements are created layout-active so they don't need to be specifically unsuspended
            //no need to walk down in this case
            //if(!v.CheckFlagsAnd(VisualFlags.IsLayoutSuspended)) return;

            //that can be true only on top of recursion, if suspended v is being connected to suspended parent.
            bool parentIsSuspended = parent == null ? false : parent.CheckFlagsAnd(VisualFlags.IsLayoutSuspended);
            uint parentTreeLevel   = parent == null ? 0     : parent.TreeLevel;

            if(parentIsSuspended) return;

            v.SetFlags(false, VisualFlags.IsLayoutSuspended);
            v.TreeLevel = parentTreeLevel + 1;

            if (v.CheckFlagsAnd(VisualFlags.IsUIElement))
            {
                //  re-insert UIElement into the update queues
                UIElement e = (UIElement)v;

                Invariant.Assert(!e.MeasureInProgress && !e.ArrangeInProgress);

                bool requireMeasureUpdate = e.MeasureDirty && !e.NeverMeasured && (e.MeasureRequest == null);
                bool requireArrangeUpdate = e.ArrangeDirty && !e.NeverArranged && (e.ArrangeRequest == null);
                ContextLayoutManager contextLayoutManager = (requireMeasureUpdate || requireArrangeUpdate)
                    ? ContextLayoutManager.From(e.Dispatcher)
                    : null;

                if (requireMeasureUpdate)
                {
                    contextLayoutManager.MeasureQueue.Add(e);
                }

                if (requireArrangeUpdate)
                {
                    contextLayoutManager.ArrangeQueue.Add(e);
                }
            }

            int count = v.InternalVisualChildrenCount;

            for (int i = 0; i < count; i++)
            {
                Visual cv = v.InternalGetVisualChild(i);
                if (cv != null)
                {
                    PropagateResumeLayout(v, cv);
                }
            }
        }

        /// <summary>
        /// Recursively propagates IsLayoutSuspended flag down to the whole v's sub tree.
        /// </summary>
        internal static void PropagateSuspendLayout(Visual v)
        {
            if(v.CheckFlagsAnd(VisualFlags.IsLayoutIslandRoot)) return;

            //the subtree is already suspended - happens when already suspended tree is further disassembled
            //no need to walk down in this case
            if(v.CheckFlagsAnd(VisualFlags.IsLayoutSuspended)) return;

            //  (bug # 1623922) assert that a UIElement has not being
            //  removed from the visual tree while updating layout.
            if (    Invariant.Strict
                &&  v.CheckFlagsAnd(VisualFlags.IsUIElement)    )
            {
                UIElement e = (UIElement)v;
                Invariant.Assert(!e.MeasureInProgress && !e.ArrangeInProgress);
            }

            v.SetFlags(true, VisualFlags.IsLayoutSuspended);
            v.TreeLevel = 0;

            int count = v.InternalVisualChildrenCount;

            for (int i = 0; i < count; i++)
            {
                Visual cv = v.InternalGetVisualChild(i);
                if (cv != null)
                {
                    PropagateSuspendLayout(cv);
                }
            }
        }