From 2856c84fe3d71d4de241aadb360ac367339236f4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jan=20Ku=C4=8Dera?=
 <10546952+miloush@users.noreply.github.com>
Date: Wed, 11 Feb 2026 11:03:49 +0000
Subject: [PATCH] FindAncestorOfType and FindDescendantOfType with predicates
 (#20661)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Find ancestors/descendants with a predicate

* Use Predicate instead of Func

* Find ancestors/descendants with a predicate

* Use Predicate instead of Func

* Predicate<Visual> to Predicate<T>

---------

Co-authored-by: Jan Kučera <miloush@users.noreply.github.com>
---
 .../VisualTree/VisualExtensions.cs            | 44 ++++++++++++++++---
 .../VisualExtensionsTests.cs                  | 43 ++++++++++++++++++
 2 files changed, 81 insertions(+), 6 deletions(-)

diff --git a/src/Avalonia.Base/VisualTree/VisualExtensions.cs b/src/Avalonia.Base/VisualTree/VisualExtensions.cs
index 670d879f29..bb9e5d4d0e 100644
--- a/src/Avalonia.Base/VisualTree/VisualExtensions.cs
+++ b/src/Avalonia.Base/VisualTree/VisualExtensions.cs
@@ -147,6 +147,19 @@ namespace Avalonia.VisualTree
         /// <param name="includeSelf">If given visual should be included in search.</param>
         /// <returns>First ancestor of given type.</returns>
         public static T? FindAncestorOfType<T>(this Visual? visual, bool includeSelf = false) where T : class
+        {
+            return FindAncestorOfType<T>(visual, includeSelf, predicate: null);
+        }
+
+        /// <summary>
+        /// Finds first ancestor of given type that matches a predicate.
+        /// </summary>
+        /// <typeparam name="T">Ancestor type.</typeparam>
+        /// <param name="visual">The visual.</param>
+        /// <param name="includeSelf">If given visual should be included in search.</param>
+        /// <param name="predicate">The predicate that the ancestor must match.</param>
+        /// <returns>First ancestor of given type.</returns>
+        public static T? FindAncestorOfType<T>(this Visual? visual, bool includeSelf, Predicate<T>? predicate) where T : class
         {
             if (visual is null)
             {
@@ -159,7 +172,10 @@ namespace Avalonia.VisualTree
             {
                 if (parent is T result)
                 {
-                    return result;
+                    if (predicate == null || predicate(result))
+                    {
+                        return result;
+                    }
                 }
 
                 parent = parent.VisualParent;
@@ -176,18 +192,31 @@ namespace Avalonia.VisualTree
         /// <param name="includeSelf">If given visual should be included in search.</param>
         /// <returns>First descendant of given type.</returns>
         public static T? FindDescendantOfType<T>(this Visual? visual, bool includeSelf = false) where T : class
+        {
+            return FindDescendantOfType<T>(visual, includeSelf, predicate: null);
+        }
+
+        /// <summary>
+        /// Finds first descendant of given type that matches given predicate.
+        /// </summary>
+        /// <typeparam name="T">Descendant type.</typeparam>
+        /// <param name="visual">The visual.</param>
+        /// <param name="includeSelf">If given visual should be included in search.</param>
+        /// <param name="predicate">The predicate that the descendant must match.</param>
+        /// <returns>First descendant of given type that matches given predicate.</returns>
+        public static T? FindDescendantOfType<T>(this Visual? visual, bool includeSelf, Predicate<T>? predicate) where T : class
         {
             if (visual is null)
             {
                 return null;
             }
 
-            if (includeSelf && visual is T result)
+            if (includeSelf && visual is T result && (predicate == null || predicate(result)))
             {
                 return result;
             }
 
-            return FindDescendantOfTypeCore<T>(visual);
+            return FindDescendantOfTypeCore<T>(visual, predicate);
         }
 
         /// <summary>
@@ -492,7 +521,7 @@ namespace Avalonia.VisualTree
                 .Select(x => x.Element!);
         }
 
-        private static T? FindDescendantOfTypeCore<T>(Visual visual) where T : class
+        private static T? FindDescendantOfTypeCore<T>(Visual visual, Predicate<T>? predicate) where T : class
         {
             var visualChildren = visual.VisualChildren;
             var visualChildrenCount = visualChildren.Count;
@@ -503,10 +532,13 @@ namespace Avalonia.VisualTree
 
                 if (child is T result)
                 {
-                    return result;
+                    if (predicate == null || predicate(result))
+                    {
+                        return result;
+                    }
                 }
 
-                var childResult = FindDescendantOfTypeCore<T>(child);
+                var childResult = FindDescendantOfTypeCore<T>(child, predicate);
 
                 if (!(childResult is null))
                 {
diff --git a/tests/Avalonia.Base.UnitTests/VisualExtensionsTests.cs b/tests/Avalonia.Base.UnitTests/VisualExtensionsTests.cs
index 4863c0fa61..270702f178 100644
--- a/tests/Avalonia.Base.UnitTests/VisualExtensionsTests.cs
+++ b/tests/Avalonia.Base.UnitTests/VisualExtensionsTests.cs
@@ -22,6 +22,23 @@ namespace Avalonia.Base.UnitTests
             Assert.Equal(root, target.FindAncestorOfType<TestRoot>());
         }
 
+        [Fact]
+        public void FindAncestorOfType_Finds_Visible_Parent()
+        {
+            StackPanel target;
+
+            var root = new TestRoot
+            {
+                Child = new TestRoot
+                {
+                    Child = target = new StackPanel(),
+                    IsVisible = false
+                }
+            };
+
+            Assert.Equal(root, target.FindAncestorOfType<TestRoot>(false, v => v.IsVisible));
+        }
+
         [Fact]
         public void FindAncestorOfType_Finds_Ancestor_Of_Nested_Child()
         {
@@ -85,6 +102,32 @@ namespace Avalonia.Base.UnitTests
             Assert.Equal(target, root.FindDescendantOfType<Button>());
         }
 
+        [Fact]
+        public void FindDescendantOfType_Finds_Nested_Visible_Child()
+        {
+            Button target;
+
+            var root = new TestRoot
+            {
+                Child = new StackPanel
+                {
+                    Children =
+                    {
+                        new StackPanel
+                        {
+                            Children =
+                            {
+                                new Button { IsVisible = false },
+                                (target = new Button())
+                            }
+                        }
+                    }
+                }
+            };
+
+            Assert.Equal(target, root.FindDescendantOfType<Button>(false, v => v.IsVisible));
+        }
+
         [Fact]
         public void FindCommonVisualAncestor_First_Is_Parent_Of_Second()
         {