diff --git a/samples/ControlCatalog/MainView.xaml b/samples/ControlCatalog/MainView.xaml
index c99a6b117b..874560a294 100644
--- a/samples/ControlCatalog/MainView.xaml
+++ b/samples/ControlCatalog/MainView.xaml
@@ -34,7 +34,8 @@
       <TabItem Header="Expander"><pages:ExpanderPage/></TabItem>
       <TabItem Header="Image"><pages:ImagePage/></TabItem>
       <TabItem Header="ItemsRepeater"
-               ScrollViewer.VerticalScrollBarVisibility="Disabled">
+               ScrollViewer.VerticalScrollBarVisibility="Disabled"
+               ScrollViewer.HorizontalScrollBarVisibility="Disabled">
         <pages:ItemsRepeaterPage/>
       </TabItem>
       <TabItem Header="LayoutTransformControl"><pages:LayoutTransformControlPage/></TabItem>
diff --git a/samples/ControlCatalog/Pages/ItemsRepeaterPage.xaml b/samples/ControlCatalog/Pages/ItemsRepeaterPage.xaml
index d0631d2cbd..103c016298 100644
--- a/samples/ControlCatalog/Pages/ItemsRepeaterPage.xaml
+++ b/samples/ControlCatalog/Pages/ItemsRepeaterPage.xaml
@@ -14,12 +14,19 @@
         <ComboBoxItem>UniformGrid - Horizontal</ComboBoxItem>
       </ComboBox>
       <Button Command="{Binding AddItem}">Add Item</Button>
+      <Button Command="{Binding RandomizeHeights}">Randomize Heights</Button>
     </StackPanel>
     <Border BorderThickness="1" BorderBrush="{DynamicResource ThemeBorderMidBrush}" Margin="0 0 0 16">
       <ScrollViewer Name="scroller"
                     HorizontalScrollBarVisibility="Auto"
                     VerticalScrollBarVisibility="Auto">
-        <ItemsRepeater Name="repeater" Background="Transparent" Items="{Binding Items}"/>
+        <ItemsRepeater Name="repeater" Background="Transparent" Items="{Binding Items}">
+          <ItemsRepeater.ItemTemplate>
+            <DataTemplate>
+              <TextBlock Height="{Binding Height}" Text="{Binding Text}"/>
+            </DataTemplate>
+          </ItemsRepeater.ItemTemplate>
+        </ItemsRepeater>
       </ScrollViewer>
     </Border>
   </DockPanel>
diff --git a/samples/ControlCatalog/Pages/ItemsRepeaterPage.xaml.cs b/samples/ControlCatalog/Pages/ItemsRepeaterPage.xaml.cs
index 1a607342f3..decd849adc 100644
--- a/samples/ControlCatalog/Pages/ItemsRepeaterPage.xaml.cs
+++ b/samples/ControlCatalog/Pages/ItemsRepeaterPage.xaml.cs
@@ -74,7 +74,7 @@ namespace ControlCatalog.Pages
 
         private void RepeaterClick(object sender, PointerPressedEventArgs e)
         {
-            var item = (e.Source as TextBlock)?.DataContext as string;
+            var item = (e.Source as TextBlock)?.DataContext as ItemsRepeaterPageViewModel.Item;
             ((ItemsRepeaterPageViewModel)DataContext).SelectedItem = item;
         }
     }
diff --git a/samples/ControlCatalog/ViewModels/ItemsRepeaterPageViewModel.cs b/samples/ControlCatalog/ViewModels/ItemsRepeaterPageViewModel.cs
index 25fd550520..bc2ce80714 100644
--- a/samples/ControlCatalog/ViewModels/ItemsRepeaterPageViewModel.cs
+++ b/samples/ControlCatalog/ViewModels/ItemsRepeaterPageViewModel.cs
@@ -1,4 +1,5 @@
-using System.Collections.ObjectModel;
+using System;
+using System.Collections.ObjectModel;
 using System.Linq;
 using ReactiveUI;
 
@@ -10,18 +11,44 @@ namespace ControlCatalog.ViewModels
 
         public ItemsRepeaterPageViewModel()
         {
-            Items = new ObservableCollection<string>(
-                Enumerable.Range(1, 100000).Select(i => $"Item {i.ToString()}"));
+            Items = new ObservableCollection<Item>(
+                Enumerable.Range(1, 100000).Select(i => new Item
+                {
+                    Text = $"Item {i.ToString()}",
+                }));
         }
 
-        public ObservableCollection<string> Items { get; }
+        public ObservableCollection<Item> Items { get; }
 
-        public string SelectedItem { get; set; }
+        public Item SelectedItem { get; set; }
 
         public void AddItem()
         {
             var index = SelectedItem != null ? Items.IndexOf(SelectedItem) : -1;
-            Items.Insert(index + 1, $"New Item {newItemIndex++}");
+            Items.Insert(index + 1, new Item { Text = $"New Item {newItemIndex++}" });
+        }
+
+        public void RandomizeHeights()
+        {
+            var random = new Random();
+
+            foreach (var i in Items)
+            {
+                i.Height = random.Next(240) + 10;
+            }
+        }
+
+        public class Item : ReactiveObject
+        {
+            private double _height = double.NaN;
+
+            public string Text { get; set; }
+            
+            public double Height 
+            {
+                get => _height;
+                set => this.RaiseAndSetIfChanged(ref _height, value);
+            }
         }
     }
 }
diff --git a/src/Avalonia.Controls/Primitives/Track.cs b/src/Avalonia.Controls/Primitives/Track.cs
index 21a7dd68f8..a569808b35 100644
--- a/src/Avalonia.Controls/Primitives/Track.cs
+++ b/src/Avalonia.Controls/Primitives/Track.cs
@@ -1,10 +1,13 @@
-// Copyright (c) The Avalonia Project. All rights reserved.
-// Licensed under the MIT license. See licence.md file in the project root for full license information.
+// Portions of this source file are adapted from the Windows Presentation Foundation project.
+// (https://github.com/dotnet/wpf/) 
+// 
+// Licensed to The Avalonia Project under MIT License, courtesy of The .NET Foundation.
 
 using System;
 using Avalonia.Input;
 using Avalonia.Layout;
 using Avalonia.Metadata;
+using Avalonia.Utilities;
 
 namespace Avalonia.Controls.Primitives
 {
@@ -34,6 +37,9 @@ namespace Avalonia.Controls.Primitives
         public static readonly StyledProperty<Button> DecreaseButtonProperty =
             AvaloniaProperty.Register<Track, Button>(nameof(DecreaseButton));
 
+        public static readonly StyledProperty<bool> IsDirectionReversedProperty =
+            AvaloniaProperty.Register<Track, bool>(nameof(IsDirectionReversed));
+
         private double _minimum;
         private double _maximum = 100.0;
         private double _value;
@@ -97,110 +103,268 @@ namespace Avalonia.Controls.Primitives
             set { SetValue(DecreaseButtonProperty, value); }
         }
 
+        public bool IsDirectionReversed
+        {
+            get { return GetValue(IsDirectionReversedProperty); }
+            set { SetValue(IsDirectionReversedProperty, value); }
+        }
+
+        private double ThumbCenterOffset { get; set; }
+        private double Density { get; set; }
+
+        /// <summary>
+        /// Calculates the distance along the <see cref="Thumb"/> of a specified point along the
+        /// track.
+        /// </summary>
+        /// <param name="point">The specified point.</param>
+        /// <returns>
+        /// The distance between the Thumb and the specified pt value.
+        /// </returns>
+        public virtual double ValueFromPoint(Point point)
+        {
+            double val;
+
+            // Find distance from center of thumb to given point.
+            if (Orientation == Orientation.Horizontal)
+            {
+                val = Value + ValueFromDistance(point.X - ThumbCenterOffset, point.Y - (Bounds.Height * 0.5));
+            }
+            else
+            {
+                val = Value + ValueFromDistance(point.X - (Bounds.Width * 0.5), point.Y - ThumbCenterOffset);
+            }
+
+            return Math.Max(Minimum, Math.Min(Maximum, val));
+        }
+
+        /// <summary>
+        /// Calculates the change in the <see cref="Value"/> of the <see cref="Track"/> when the
+        /// <see cref="Thumb"/> moves.
+        /// </summary>
+        /// <param name="horizontal">The horizontal displacement of the thumb.</param>
+        /// <param name="vertical">The vertical displacement of the thumb.</param>        
+        public virtual double ValueFromDistance(double horizontal, double vertical)
+        {
+            double scale = IsDirectionReversed ? -1 : 1;
+
+            if (Orientation == Orientation.Horizontal)
+            {
+                return scale * horizontal * Density;
+            }
+            else
+            {
+                // Increases in y cause decreases in Sliders value
+                return -1 * scale * vertical * Density;
+            }
+        }
+
         protected override Size MeasureOverride(Size availableSize)
         {
-            var thumb = Thumb;
+            Size desiredSize = new Size(0.0, 0.0);
 
-            if (thumb != null)
+            // Only measure thumb.
+            // Repeat buttons will be sized based on thumb
+            if (Thumb != null)
             {
-                thumb.Measure(availableSize);
+                Thumb.Measure(availableSize);
+                desiredSize = Thumb.DesiredSize;
+            }
 
-                if (Orientation == Orientation.Horizontal)
-                {
-                    return new Size(0, thumb.DesiredSize.Height);
-                }
+            if (!double.IsNaN(ViewportSize))
+            {
+                // ScrollBar can shrink to 0 in the direction of scrolling
+                if (Orientation == Orientation.Vertical)
+                    desiredSize = desiredSize.WithHeight(0.0);
                 else
-                {
-                    return new Size(thumb.DesiredSize.Width, 0);
-                }
+                    desiredSize = desiredSize.WithWidth(0.0);
             }
 
-            return base.MeasureOverride(availableSize);
+            return desiredSize;
         }
 
-        protected override Size ArrangeOverride(Size finalSize)
+        protected override Size ArrangeOverride(Size arrangeSize)
         {
-            var thumb = Thumb;
-            var increaseButton = IncreaseButton;
-            var decreaseButton = DecreaseButton;
-
-            var range = Maximum - Minimum;
-            var offset = Math.Min(Value - Minimum, range);
-            var viewportSize = ViewportSize;
-            var extent = range + viewportSize;
+            double decreaseButtonLength, thumbLength, increaseButtonLength;
+            var isVertical = Orientation == Orientation.Vertical;
+            var viewportSize = Math.Max(0.0, ViewportSize);
 
-            if (Orientation == Orientation.Horizontal)
+            // If viewport is NaN, compute thumb's size based on its desired size,
+            // otherwise compute the thumb base on the viewport and extent properties
+            if (double.IsNaN(ViewportSize))
             {
-                double thumbWidth = 0;
-
-                if (double.IsNaN(viewportSize))
-                {
-                    thumbWidth = thumb?.DesiredSize.Width ?? 0;
-                }
-                else if (extent > 0)
+                ComputeSliderLengths(arrangeSize, isVertical, out decreaseButtonLength, out thumbLength, out increaseButtonLength);
+            }
+            else
+            {
+                // Don't arrange if there's not enough content or the track is too small
+                if (!ComputeScrollBarLengths(arrangeSize, viewportSize, isVertical, out decreaseButtonLength, out thumbLength, out increaseButtonLength))
                 {
-                    thumbWidth = finalSize.Width * viewportSize / extent;
+                    return arrangeSize;
                 }
+            }
 
-                var remaining = finalSize.Width - thumbWidth;
-                var firstWidth = range <= 0 ? 0 : remaining * offset / range;
+            // Layout the pieces of track
+            var offset = new Point();
+            var pieceSize = arrangeSize;
+            var isDirectionReversed = IsDirectionReversed;
 
-                if (decreaseButton != null)
+            if (isVertical)
+            {
+                CoerceLength(ref decreaseButtonLength, arrangeSize.Height);
+                CoerceLength(ref increaseButtonLength, arrangeSize.Height);
+                CoerceLength(ref thumbLength, arrangeSize.Height);
+
+                offset = offset.WithY(isDirectionReversed ? decreaseButtonLength + thumbLength : 0.0);
+                pieceSize = pieceSize.WithHeight(increaseButtonLength);
+
+                if (IncreaseButton != null)
                 {
-                    decreaseButton.Arrange(new Rect(0, 0, firstWidth, finalSize.Height));
+                    IncreaseButton.Arrange(new Rect(offset, pieceSize));
                 }
 
-                if (thumb != null)
+                offset = offset.WithY(isDirectionReversed ? 0.0 : increaseButtonLength + thumbLength);
+                pieceSize = pieceSize.WithHeight(decreaseButtonLength);
+
+                if (DecreaseButton != null)
                 {
-                    thumb.Arrange(new Rect(firstWidth, 0, thumbWidth, finalSize.Height));
+                    DecreaseButton.Arrange(new Rect(offset, pieceSize));
                 }
 
-                if (increaseButton != null)
+                offset = offset.WithY(isDirectionReversed ? decreaseButtonLength : increaseButtonLength);
+                pieceSize = pieceSize.WithHeight(thumbLength);
+
+                if (Thumb != null)
                 {
-                    increaseButton.Arrange(new Rect(
-                        firstWidth + thumbWidth,
-                        0,
-                        Math.Max(0, remaining - firstWidth),
-                        finalSize.Height));
+                    Thumb.Arrange(new Rect(offset, pieceSize));
                 }
+
+                ThumbCenterOffset = offset.Y + (thumbLength * 0.5);
             }
             else
             {
-                double thumbHeight = 0;
+                CoerceLength(ref decreaseButtonLength, arrangeSize.Width);
+                CoerceLength(ref increaseButtonLength, arrangeSize.Width);
+                CoerceLength(ref thumbLength, arrangeSize.Width);
 
-                if (double.IsNaN(viewportSize))
-                {
-                    thumbHeight = thumb?.DesiredSize.Height ?? 0;
-                }
-                else if (extent > 0)
+                offset = offset.WithY(isDirectionReversed ? increaseButtonLength + thumbLength : 0.0);
+                pieceSize = pieceSize.WithWidth(decreaseButtonLength);
+
+                if (DecreaseButton != null)
                 {
-                    thumbHeight = finalSize.Height * viewportSize / extent;
+                    DecreaseButton.Arrange(new Rect(offset, pieceSize));
                 }
 
-                var remaining = finalSize.Height - thumbHeight;
-                var firstHeight = range <= 0 ? 0 : remaining * offset / range;
+                offset = offset.WithX(isDirectionReversed ? 0.0 : decreaseButtonLength + thumbLength);
+                pieceSize = pieceSize.WithWidth(increaseButtonLength);
 
-                if (decreaseButton != null)
+                if (IncreaseButton != null)
                 {
-                    decreaseButton.Arrange(new Rect(0, 0, finalSize.Width, firstHeight));
+                    IncreaseButton.Arrange(new Rect(offset, pieceSize));
                 }
 
-                if (thumb != null)
-                {
-                    thumb.Arrange(new Rect(0, firstHeight, finalSize.Width, thumbHeight));
-                }
+                offset = offset.WithX(isDirectionReversed ? increaseButtonLength : decreaseButtonLength);
+                pieceSize = pieceSize.WithWidth(thumbLength);
 
-                if (increaseButton != null)
+                if (Thumb != null)
                 {
-                    increaseButton.Arrange(new Rect(
-                        0,
-                        firstHeight + thumbHeight,
-                        finalSize.Width,
-                        Math.Max(remaining - firstHeight, 0)));
+                    Thumb.Arrange(new Rect(offset, pieceSize));
                 }
+
+                ThumbCenterOffset = offset.X + (thumbLength * 0.5);
             }
 
-            return finalSize;
+            return arrangeSize;
+        }
+
+        private static void CoerceLength(ref double componentLength, double trackLength)
+        {
+            if (componentLength < 0)
+            {
+                componentLength = 0.0;
+            }
+            else if (componentLength > trackLength || double.IsNaN(componentLength))
+            {
+                componentLength = trackLength;
+            }
+        }
+
+        private void ComputeSliderLengths(Size arrangeSize, bool isVertical, out double decreaseButtonLength, out double thumbLength, out double increaseButtonLength)
+        {
+            double min = Minimum;
+            double range = Math.Max(0.0, Maximum - min);
+            double offset = Math.Min(range, Value - min);
+
+            double trackLength;
+
+            // Compute thumb size
+            if (isVertical)
+            {
+                trackLength = arrangeSize.Height;
+                thumbLength = Thumb == null ? 0 : Thumb.DesiredSize.Height;
+            }
+            else
+            {
+                trackLength = arrangeSize.Width;
+                thumbLength = Thumb == null ? 0 : Thumb.DesiredSize.Width;
+            }
+
+            CoerceLength(ref thumbLength, trackLength);
+
+            double remainingTrackLength = trackLength - thumbLength;
+
+            decreaseButtonLength = remainingTrackLength * offset / range;
+            CoerceLength(ref decreaseButtonLength, remainingTrackLength);
+
+            increaseButtonLength = remainingTrackLength - decreaseButtonLength;
+            CoerceLength(ref increaseButtonLength, remainingTrackLength);
+
+            Density = range / remainingTrackLength;
+        }
+
+        private bool ComputeScrollBarLengths(Size arrangeSize, double viewportSize, bool isVertical, out double decreaseButtonLength, out double thumbLength, out double increaseButtonLength)
+        {
+            var min = Minimum;
+            var range = Math.Max(0.0, Maximum - min);
+            var offset = Math.Min(range, Value - min);
+            var extent = Math.Max(0.0, range) + viewportSize;
+            var trackLength = isVertical ? arrangeSize.Height : arrangeSize.Width;
+            double thumbMinLength = 10;
+
+            thumbLength = trackLength * viewportSize / extent;
+            CoerceLength(ref thumbLength, trackLength);
+            thumbLength = Math.Max(thumbMinLength, thumbLength);
+
+            // If we don't have enough content to scroll, disable the track.
+            var notEnoughContentToScroll = MathUtilities.LessThanOrClose(range, 0.0);
+            var thumbLongerThanTrack = thumbLength > trackLength;
+
+            // if there's not enough content or the thumb is longer than the track, 
+            // hide the track and don't arrange the pieces
+            if (notEnoughContentToScroll || thumbLongerThanTrack)
+            {
+                ShowChildren(false);
+                ThumbCenterOffset = Double.NaN;
+                Density = Double.NaN;
+                decreaseButtonLength = 0.0;
+                increaseButtonLength = 0.0;
+                return false; // don't arrange
+            }
+            else
+            {
+                ShowChildren(true);
+            }
+
+            // Compute lengths of increase and decrease button
+            double remainingTrackLength = trackLength - thumbLength;
+            decreaseButtonLength = remainingTrackLength * offset / range;
+            CoerceLength(ref decreaseButtonLength, remainingTrackLength);
+
+            increaseButtonLength = remainingTrackLength - decreaseButtonLength;
+            CoerceLength(ref increaseButtonLength, remainingTrackLength);
+
+            Density = range / remainingTrackLength;
+
+            return true;
         }
 
         private void ThumbChanged(AvaloniaPropertyChangedEventArgs e)
@@ -244,25 +408,29 @@ namespace Avalonia.Controls.Primitives
 
         private void ThumbDragged(object sender, VectorEventArgs e)
         {
-            double range = Maximum - Minimum;
-            double value = Value;
-            double offset;
+            Value = MathUtilities.Clamp(
+                Value + ValueFromDistance(e.Vector.X, e.Vector.Y),
+                Minimum,
+                Maximum);
+        }
 
-            if (Orientation == Orientation.Horizontal)
+        private void ShowChildren(bool visible)
+        {
+            // WPF sets Visible = Hidden here but we don't have that, and setting IsVisible = false
+            // will cause us to stop being laid out. Instead show/hide the child controls.
+            if (Thumb != null)
             {
-                offset = e.Vector.X / ((Bounds.Size.Width - Thumb.Bounds.Size.Width) / range);
+                Thumb.IsVisible = visible;
             }
-            else
+
+            if (IncreaseButton != null)
             {
-                offset = e.Vector.Y * (range / (Bounds.Size.Height - Thumb.Bounds.Size.Height));
+                IncreaseButton.IsVisible = visible;
             }
 
-            if (!double.IsNaN(offset) && !double.IsInfinity(offset))
+            if (DecreaseButton != null)
             {
-                value += offset;
-                value = Math.Max(value, Minimum);
-                value = Math.Min(value, Maximum);
-                Value = value;
+                DecreaseButton.IsVisible = visible;
             }
         }
     }
diff --git a/src/Avalonia.Controls/Repeater/ViewManager.cs b/src/Avalonia.Controls/Repeater/ViewManager.cs
index 3e09a5b3ee..51c14d47d6 100644
--- a/src/Avalonia.Controls/Repeater/ViewManager.cs
+++ b/src/Avalonia.Controls/Repeater/ViewManager.cs
@@ -581,13 +581,16 @@ namespace Avalonia.Controls
 
         private bool ClearElementToPinnedPool(IControl element, VirtualizationInfo virtInfo, bool isClearedDueToCollectionChange)
         {
-            if (_isDataSourceStableResetPending)
+            bool moveToPinnedPool =
+                !isClearedDueToCollectionChange && virtInfo.IsPinned;
+
+            if (moveToPinnedPool)
             {
-                _resetPool.Add(element);
-                virtInfo.MoveOwnershipToUniqueIdResetPoolFromLayout();
+                _pinnedPool.Add(new PinnedElementInfo(element));
+                virtInfo.MoveOwnershipToPinnedPool();
             }
 
-            return _isDataSourceStableResetPending;
+            return moveToPinnedPool;
         }
 
         private void UpdateFocusedElement()
diff --git a/src/Avalonia.Interactivity/Interactive.cs b/src/Avalonia.Interactivity/Interactive.cs
index f8d388ec89..27ece25183 100644
--- a/src/Avalonia.Interactivity/Interactive.cs
+++ b/src/Avalonia.Interactivity/Interactive.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using Avalonia.Layout;
 using Avalonia.VisualTree;
 
@@ -170,10 +171,9 @@ namespace Avalonia.Interactivity
 
             e.Route = RoutingStrategies.Bubble;
 
-            foreach (var target in this.GetBubbleEventRoute())
-            {
-                ((Interactive)target).RaiseEventImpl(e);
-            }
+            var traverser = HierarchyTraverser<RaiseEventTraverse, NopTraverse>.Create(e);
+
+            traverser.Traverse(this);
         }
 
         /// <summary>
@@ -186,10 +186,9 @@ namespace Avalonia.Interactivity
 
             e.Route = RoutingStrategies.Tunnel;
 
-            foreach (var target in this.GetTunnelEventRoute())
-            {
-                ((Interactive)target).RaiseEventImpl(e);
-            }
+            var traverser = HierarchyTraverser<NopTraverse, RaiseEventTraverse>.Create(e);
+
+            traverser.Traverse(this);
         }
 
         /// <summary>
@@ -262,5 +261,67 @@ namespace Avalonia.Interactivity
                 _subscriptions.Remove(_subscription);
             }
         }
+
+        private interface ITraverse
+        {
+            void Execute(IInteractive target, RoutedEventArgs e);
+        }
+
+        private struct NopTraverse : ITraverse
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public void Execute(IInteractive target, RoutedEventArgs e)
+            {
+            }
+        }
+
+        private struct RaiseEventTraverse : ITraverse
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public void Execute(IInteractive target, RoutedEventArgs e)
+            {
+                ((Interactive)target).RaiseEventImpl(e);
+            }
+        }
+
+        /// <summary>
+        /// Traverses interactive hierarchy allowing for raising events.
+        /// </summary>
+        /// <typeparam name="TPreTraverse">Called before parent is traversed.</typeparam>
+        /// <typeparam name="TPostTraverse">Called after parent has been traversed.</typeparam>
+        private struct HierarchyTraverser<TPreTraverse, TPostTraverse>
+            where TPreTraverse : struct, ITraverse
+            where TPostTraverse : struct, ITraverse
+        {
+            private TPreTraverse _preTraverse;
+            private TPostTraverse _postTraverse;
+            private readonly RoutedEventArgs _args;
+
+            private HierarchyTraverser(TPreTraverse preTraverse, TPostTraverse postTraverse, RoutedEventArgs args)
+            {
+                _preTraverse = preTraverse;
+                _postTraverse = postTraverse;
+                _args = args;
+            }
+
+            public static HierarchyTraverser<TPreTraverse, TPostTraverse> Create(RoutedEventArgs args)
+            {
+                return new HierarchyTraverser<TPreTraverse, TPostTraverse>(new TPreTraverse(), new TPostTraverse(), args);
+            }
+
+            public void Traverse(IInteractive target)
+            {
+                _preTraverse.Execute(target, _args);
+
+                IInteractive parent = target.InteractiveParent;
+
+                if (parent != null)
+                {
+                    Traverse(parent);
+                }
+
+                _postTraverse.Execute(target, _args);
+            }
+        }
     }
 }
diff --git a/src/Avalonia.Interactivity/InteractiveExtensions.cs b/src/Avalonia.Interactivity/InteractiveExtensions.cs
index b03590951b..07e4029240 100644
--- a/src/Avalonia.Interactivity/InteractiveExtensions.cs
+++ b/src/Avalonia.Interactivity/InteractiveExtensions.cs
@@ -36,29 +36,5 @@ namespace Avalonia.Interactivity
                 routes,
                 handledEventsToo));
         }
-
-        /// <summary>
-        /// Gets the route for bubbling events from the specified interactive.
-        /// </summary>
-        /// <param name="interactive">The interactive.</param>
-        /// <returns>The event route.</returns>
-        internal static IEnumerable<IInteractive> GetBubbleEventRoute(this IInteractive interactive)
-        {
-            while (interactive != null)
-            {
-                yield return interactive;
-                interactive = interactive.InteractiveParent;
-            }
-        }
-
-        /// <summary>
-        /// Gets the route for tunneling events from the specified interactive.
-        /// </summary>
-        /// <param name="interactive">The interactive.</param>
-        /// <returns>The event route.</returns>
-        internal static IEnumerable<IInteractive> GetTunnelEventRoute(this IInteractive interactive)
-        {
-            return interactive.GetBubbleEventRoute().Reverse();
-        }
     }
 }
diff --git a/src/Avalonia.Layout/LayoutQueue.cs b/src/Avalonia.Layout/LayoutQueue.cs
index ce40fdde49..eb0e4bd9f3 100644
--- a/src/Avalonia.Layout/LayoutQueue.cs
+++ b/src/Avalonia.Layout/LayoutQueue.cs
@@ -60,7 +60,7 @@ namespace Avalonia.Layout
 
         public void EndLoop()
         {
-            var notfinalized = _loopQueueInfo.Where(v => v.Value.Count == _maxEnqueueCountPerLoop).ToArray();
+            var notfinalized = _loopQueueInfo.Where(v => v.Value.Count >= _maxEnqueueCountPerLoop).ToArray();
 
             _loopQueueInfo.Clear();
 
diff --git a/src/Avalonia.Themes.Default/ScrollBar.xaml b/src/Avalonia.Themes.Default/ScrollBar.xaml
index ca308b33c3..c9552a607c 100644
--- a/src/Avalonia.Themes.Default/ScrollBar.xaml
+++ b/src/Avalonia.Themes.Default/ScrollBar.xaml
@@ -19,7 +19,8 @@
                                Maximum="{TemplateBinding Maximum}"
                                Value="{TemplateBinding Value, Mode=TwoWay}"
                                ViewportSize="{TemplateBinding ViewportSize}"
-                               Orientation="{TemplateBinding Orientation}">
+                               Orientation="{TemplateBinding Orientation}"
+                               IsDirectionReversed="True">
                             <Track.DecreaseButton>
                                 <RepeatButton Name="PART_PageUpButton"
                                               Classes="repeattrack"
diff --git a/src/Avalonia.Themes.Default/Slider.xaml b/src/Avalonia.Themes.Default/Slider.xaml
index 04ec6fb58a..eb46fdffa2 100644
--- a/src/Avalonia.Themes.Default/Slider.xaml
+++ b/src/Avalonia.Themes.Default/Slider.xaml
@@ -46,7 +46,7 @@
             <ColumnDefinition Width="Auto"/>
           </Grid.ColumnDefinitions>
           <Border Name="TrackBackground" Grid.Column="1" Width="4" Margin="0,6" HorizontalAlignment="Center"/>
-          <Track Name="PART_Track" Grid.Column="1" Orientation="Vertical">
+          <Track Name="PART_Track" Grid.Column="1" Orientation="Vertical" IsDirectionReversed="True">
             <Track.DecreaseButton>
                <RepeatButton Name="PART_DecreaseButton"
                              Classes="repeattrack" />
diff --git a/tests/Avalonia.Layout.UnitTests/LayoutManagerTests.cs b/tests/Avalonia.Layout.UnitTests/LayoutManagerTests.cs
index 4c288b2702..3f20c9a76a 100644
--- a/tests/Avalonia.Layout.UnitTests/LayoutManagerTests.cs
+++ b/tests/Avalonia.Layout.UnitTests/LayoutManagerTests.cs
@@ -341,5 +341,38 @@ namespace Avalonia.Layout.UnitTests
             //layoutmanager should process properly other visuals
             Assert.All(targets, c => Assert.True(c.Arranged));
         }
+
+
+        [Fact]
+        public void LayoutManager_Should_Recover_From_Infinite_Loop_On_Measure()
+        {
+            // Test for issue #3041.
+            var control = new LayoutTestControl();
+            var root = new LayoutTestRoot { Child = control };
+
+            root.LayoutManager.ExecuteInitialLayoutPass(root);
+            control.Measured = false;
+
+            control.DoMeasureOverride = (l, s) =>
+            {
+                control.InvalidateMeasure();
+                return new Size(100, 100);
+            };
+
+            control.InvalidateMeasure();
+            root.LayoutManager.ExecuteLayoutPass();
+
+            // This is the important part: running a second layout pass in which we exceed the maximum
+            // retries causes LayoutQueue<T>.Info.Count to exceed _maxEnqueueCountPerLoop.
+            root.LayoutManager.ExecuteLayoutPass();
+
+            control.Measured = false;
+            control.DoMeasureOverride = null;
+
+            root.LayoutManager.ExecuteLayoutPass();
+
+            Assert.True(control.Measured);
+            Assert.True(control.IsMeasureValid);
+        }
     }
 }