initial working

src/Avalonia.Controls/ComboBox.cs

@@ -184,23 +184,10 @@ namespace Avalonia.Controls
             this.UpdateSelectionBoxItem(SelectedItem);
         }
 
-        // Because the SelectedItem isn't connected to the visual tree
         public override void InvalidateMirrorTransform()
         {
             base.InvalidateMirrorTransform();
-
+           UpdateSelectionBoxItem(SelectedItem);
-            if (SelectedItem is Control selectedControl)
-            {
-                selectedControl.InvalidateMirrorTransform();
-
-                foreach (var visual in selectedControl.GetVisualDescendants())
-                {
-                    if (visual is Control childControl)
-                    {
-                        childControl.InvalidateMirrorTransform();
-                    }
-                }
-            }
         }
 
         /// <inheritdoc/>
@@ -365,6 +352,8 @@ namespace Avalonia.Controls
             {
                 parent.GetObservable(IsVisibleProperty).Subscribe(IsVisibleChanged).DisposeWith(_subscriptionsOnOpen);
             }
+
+            UpdateSelectionBoxItem(SelectedItem);
         }
 
         private void IsVisibleChanged(bool isVisible)
@@ -420,8 +409,12 @@ namespace Avalonia.Controls
                 {
                     control.Measure(Size.Infinity);
 
+                    var flowDirection = control.IsAttachedToVisualTree ? 
+                        (control.VisualParent as Control)!.FlowDirection : FlowDirection.LeftToRight;
+
                     SelectionBoxItem = new Rectangle
                     {
+                        FlowDirection = flowDirection,
                         Width = control.DesiredSize.Width,
                         Height = control.DesiredSize.Height,
                         Fill = new VisualBrush

src/Avalonia.Controls/Control.cs

@@ -378,17 +378,12 @@ namespace Avalonia.Controls
             bool bypassFlowDirectionPolicies = BypassFlowDirectionPolicies;
             bool parentBypassFlowDirectionPolicies = false;
 
-            var parent = this.FindAncestorOfType<Control>();
+            var parent = ((IVisual)this).VisualParent as Control;
             if (parent != null)
             {
                 parentFlowDirection = parent.FlowDirection;
                 parentBypassFlowDirectionPolicies = parent.BypassFlowDirectionPolicies;
             }
-            else if (Parent is Control logicalParent)
-            {
-                parentFlowDirection = logicalParent.FlowDirection;
-                parentBypassFlowDirectionPolicies = logicalParent.BypassFlowDirectionPolicies;
-            }
 
             bool thisShouldBeMirrored = flowDirection == FlowDirection.RightToLeft && !bypassFlowDirectionPolicies;
             bool parentShouldBeMirrored = parentFlowDirection == FlowDirection.RightToLeft && !parentBypassFlowDirectionPolicies;

tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/SceneBuilderTests.cs

@@ -349,6 +349,39 @@ namespace Avalonia.Base.UnitTests.Rendering.SceneGraph
             }
         }
 
+        [Fact]
+        public void MirrorTransform_For_Control_With_RenderTransform_Should_Be_Correct()
+        {
+            using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
+            {
+                Border border;
+                var tree = new TestRoot
+                {
+                    Width = 400,
+                    Height = 200,
+                    Child = border = new Border
+                    {
+                        HorizontalAlignment = HorizontalAlignment.Left,
+                        Background = Brushes.Red,
+                        Width = 100,
+                        RenderTransform = new ScaleTransform(0.5, 1),
+                        FlowDirection = FlowDirection.RightToLeft
+                    }
+                };
+
+                tree.Measure(Size.Infinity);
+                tree.Arrange(new Rect(tree.DesiredSize));
+
+                var scene = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(scene);
+
+                var expectedTransform = new Matrix(-1, 0, 0, 1, 100, 0) * Matrix.CreateScale(0.5, 1) * Matrix.CreateTranslation(25, 0);
+                var borderNode = scene.FindNode(border);
+                Assert.Equal(expectedTransform, borderNode.Transform);
+            }
+        }
+
         [Fact]
         public void Should_Update_Border_Background_Node()
         {

tests/Avalonia.Controls.UnitTests/ComboBoxTests.cs

@@ -336,5 +336,104 @@ namespace Avalonia.Controls.UnitTests
                 Assert.Equal(1, count);
             }
         }
+
+        [Fact]
+        public void FlowDirection_Of_RectangleContent_Shuold_Be_LeftToRight()
+        {
+            using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
+            {
+                var items = new[]
+                {
+                    new ComboBoxItem()
+                    { 
+                        Content = new Control()
+                    }
+                };
+                var target = new ComboBox
+                {
+                    Items = items,
+                    Template = GetTemplate()
+                };
+
+                var root = new TestRoot(target);
+                target.ApplyTemplate();
+                target.SelectedIndex = 0;
+
+                var rectangle = target.GetValue(ComboBox.SelectionBoxItemProperty) as Rectangle;
+
+                Assert.Equal(FlowDirection.LeftToRight, rectangle.FlowDirection);
+            }
+        }
+
+        [Fact]
+        public void FlowDirection_Of_RectangleContent_Updated_After_Change_ComboBox()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var items = new[]
+                {
+                    new ComboBoxItem()
+                    { 
+                        Content = new Control()
+                    }
+                };
+                var target = new ComboBox
+                {
+                    FlowDirection = FlowDirection.RightToLeft,
+                    Items = items,
+                    Template = GetTemplate()
+                };
+
+                var root = new TestRoot(target);
+                
+                target.ApplyTemplate();
+                target.Presenter.ApplyTemplate();
+                target.SelectedIndex = 0;
+
+                var rectangle = target.GetValue(ComboBox.SelectionBoxItemProperty) as Rectangle;
+
+                // need help here, the 'rectangle' isn't connected to visual tree for some reason
+
+                Assert.True(rectangle.HasMirrorTransform);
+
+                target.FlowDirection = FlowDirection.LeftToRight;
+
+                Assert.False(rectangle.HasMirrorTransform);
+            }
+        }
+
+        [Fact]
+        public void FlowDirection_Of_RectangleContent_Updated_After_Content_In_VisualTree()
+        {
+            using (UnitTestApplication.Start(TestServices.RealFocus))
+            {
+                Control content;
+                var items = new[]
+                {
+                    new ComboBoxItem()
+                    {
+                        Content = content = new Control()
+                    }
+                };
+                var target = new ComboBox
+                {
+                    FlowDirection = FlowDirection.RightToLeft,
+                    Items = items,
+                    Template = GetTemplate()
+                };
+
+                var root = new TestRoot(target);
+                target.ApplyTemplate();
+                target.Presenter.ApplyTemplate();
+                target.SelectedIndex = 0;
+
+                // need help here how to connect 'content' tio visual tree, or how to
+
+
+                var rectangle = target.GetValue(ComboBox.SelectionBoxItemProperty) as Rectangle;
+
+                Assert.Equal(FlowDirection.RightToLeft, rectangle.FlowDirection);
+            }
+        }
     }
 }

tests/Avalonia.Controls.UnitTests/FlowDirectionTests.cs

@@ -0,0 +1,41 @@
+using Avalonia.Media;
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests
+{
+    public class FlowDirectionTests
+    {
+        [Fact]
+        public void HasMirrorTransform_Should_Be_True()
+        {
+            var target = new Control
+            {
+                FlowDirection = FlowDirection.RightToLeft,
+            };
+
+            Assert.True(target.HasMirrorTransform);    
+        }
+
+        [Fact]
+        public void HasMirrorTransform_Of_Children_Is_Updated_After_Change()
+        {
+            Control child;
+            var target = new Decorator
+            {
+                FlowDirection = FlowDirection.LeftToRight,
+                Child = child = new Control()
+                {
+                    FlowDirection = FlowDirection.LeftToRight,
+                }
+            };
+
+            Assert.False(target.HasMirrorTransform);
+            Assert.False(child.HasMirrorTransform);
+
+            target.FlowDirection = FlowDirection.RightToLeft;
+
+            Assert.True(target.HasMirrorTransform);
+            Assert.True(child.HasMirrorTransform);
+        }
+    }
+}