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/Pages/ListBoxPage.xaml.cs b/samples/ControlCatalog/Pages/ListBoxPage.xaml.cs
index cdbf8fd2b6..0f2d4461bf 100644
--- a/samples/ControlCatalog/Pages/ListBoxPage.xaml.cs
+++ b/samples/ControlCatalog/Pages/ListBoxPage.xaml.cs
@@ -78,7 +78,7 @@ namespace ControlCatalog.Pages
                 }
             }
 
-            private string GenerateItem() => $"Item {_counter++}";
+            private string GenerateItem() => $"Item {_counter++.ToString()}";
         }
     }
 }
diff --git a/samples/ControlCatalog/ViewModels/ItemsRepeaterPageViewModel.cs b/samples/ControlCatalog/ViewModels/ItemsRepeaterPageViewModel.cs
index 436a479441..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}"));
+            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.Animation/DisposeAnimationInstanceSubject.cs b/src/Avalonia.Animation/DisposeAnimationInstanceSubject.cs
index b44f392ce3..0c15524362 100644
--- a/src/Avalonia.Animation/DisposeAnimationInstanceSubject.cs
+++ b/src/Avalonia.Animation/DisposeAnimationInstanceSubject.cs
@@ -2,14 +2,7 @@
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reactive.Linq;
 using Avalonia.Animation.Animators;
-using Avalonia.Animation.Utils;
-using Avalonia.Collections;
-using Avalonia.Data;
-using Avalonia.Reactive;
 
 namespace Avalonia.Animation
 {
@@ -46,6 +39,7 @@ namespace Avalonia.Animation
         public void OnError(Exception error)
         {
             _lastInstance?.Dispose();
+            _lastInstance = null;
         }
 
         void IObserver<bool>.OnNext(bool matchVal)
@@ -53,12 +47,18 @@ namespace Avalonia.Animation
             if (matchVal != _lastMatch)
             {
                 _lastInstance?.Dispose();
+
                 if (matchVal)
                 {
                     _lastInstance = _animator.Run(_animation, _control, _clock, _onComplete);
                 }
+                else
+                {
+                    _lastInstance = null;
+                }
+
                 _lastMatch = matchVal;
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Avalonia.Base/PriorityLevel.cs b/src/Avalonia.Base/PriorityLevel.cs
index 6366911e77..a2364083ea 100644
--- a/src/Avalonia.Base/PriorityLevel.cs
+++ b/src/Avalonia.Base/PriorityLevel.cs
@@ -3,7 +3,8 @@
 
 using System;
 using System.Collections.Generic;
-using System.Reactive.Disposables;
+using System.Diagnostics;
+using System.Threading;
 using Avalonia.Data;
 
 namespace Avalonia
@@ -181,9 +182,9 @@ namespace Avalonia
 
         private sealed class RemoveBindingDisposable : IDisposable
         {
-            private readonly LinkedListNode<PriorityBindingEntry> _binding;
             private readonly LinkedList<PriorityBindingEntry> _bindings;
             private readonly PriorityLevel _priorityLevel;
+            private LinkedListNode<PriorityBindingEntry> _binding;
 
             public RemoveBindingDisposable(
                 LinkedListNode<PriorityBindingEntry> binding,
@@ -197,11 +198,21 @@ namespace Avalonia
 
             public void Dispose()
             {
-                PriorityBindingEntry entry = _binding.Value;
+                LinkedListNode<PriorityBindingEntry> binding = Interlocked.Exchange(ref _binding, null);
+
+                if (binding == null)
+                {
+                    // Some system is trying to remove binding twice.
+                    Debug.Assert(false);
+
+                    return;
+                }
+
+                PriorityBindingEntry entry = binding.Value;
 
                 if (!entry.HasCompleted)
                 {
-                    _bindings.Remove(_binding);
+                    _bindings.Remove(binding);
 
                     entry.Dispose();
 
diff --git a/src/Avalonia.Base/Utilities/SingleOrDictionary.cs b/src/Avalonia.Base/Utilities/SingleOrDictionary.cs
index bda85f90e2..140da6750d 100644
--- a/src/Avalonia.Base/Utilities/SingleOrDictionary.cs
+++ b/src/Avalonia.Base/Utilities/SingleOrDictionary.cs
@@ -38,7 +38,7 @@ namespace Avalonia.Utilities
         {
             if (dictionary == null)
             {
-                if (!_singleValue.HasValue || !_singleValue.Value.Key.Equals(key))
+                if (!_singleValue.HasValue || !EqualityComparer<TKey>.Default.Equals(_singleValue.Value.Key, key))
                 {
                     value = default(TValue);
                     return false;
diff --git a/src/Avalonia.Base/Utilities/WeakEventHandlerManager.cs b/src/Avalonia.Base/Utilities/WeakEventHandlerManager.cs
index f4cec98628..37e25d0fac 100644
--- a/src/Avalonia.Base/Utilities/WeakEventHandlerManager.cs
+++ b/src/Avalonia.Base/Utilities/WeakEventHandlerManager.cs
@@ -142,10 +142,12 @@ namespace Avalonia.Utilities
                     _data = ndata;
                 }
 
+                MethodInfo method = s.Method;
+
                 var subscriber = (TSubscriber)s.Target;
-                if (!s_Callers.TryGetValue(s.Method, out var caller))
-                    s_Callers[s.Method] = caller =
-                        (CallerDelegate)Delegate.CreateDelegate(typeof(CallerDelegate), null, s.Method);
+                if (!s_Callers.TryGetValue(method, out var caller))
+                    s_Callers[method] = caller =
+                        (CallerDelegate)Delegate.CreateDelegate(typeof(CallerDelegate), null, method);
                 _data[_count] = new Descriptor
                 {
                     Caller = caller,
diff --git a/src/Avalonia.Controls/Calendar/DatePicker.cs b/src/Avalonia.Controls/Calendar/DatePicker.cs
index 70de8bec16..55797ae1e3 100644
--- a/src/Avalonia.Controls/Calendar/DatePicker.cs
+++ b/src/Avalonia.Controls/Calendar/DatePicker.cs
@@ -1042,7 +1042,8 @@ namespace Avalonia.Controls
                         }
                     }
                     DateTime? d = SetTextBoxValue(s);
-                    if (!SelectedDate.Equals(d))
+                    
+                    if (SelectedDate != d)
                     {
                         SelectedDate = d;
                     }
@@ -1058,7 +1059,8 @@ namespace Avalonia.Controls
             else
             {
                 DateTime? d = SetTextBoxValue(_defaultText);
-                if (!SelectedDate.Equals(d))
+
+                if (SelectedDate != d)
                 {
                     SelectedDate = d;
                 }
diff --git a/src/Avalonia.Controls/Presenters/TextPresenter.cs b/src/Avalonia.Controls/Presenters/TextPresenter.cs
index debbb81264..5931fec350 100644
--- a/src/Avalonia.Controls/Presenters/TextPresenter.cs
+++ b/src/Avalonia.Controls/Presenters/TextPresenter.cs
@@ -244,7 +244,7 @@ namespace Avalonia.Controls.Presenters
                             var rect = FormattedText.HitTestTextPosition(caretIndex);
                             this.BringIntoView(rect);
                         },
-                        DispatcherPriority.Normal);
+                        DispatcherPriority.Render);
                 }
             }
         }
diff --git a/src/Avalonia.Controls/Primitives/SelectingItemsControl.cs b/src/Avalonia.Controls/Primitives/SelectingItemsControl.cs
index a50175bdee..6869ea0822 100644
--- a/src/Avalonia.Controls/Primitives/SelectingItemsControl.cs
+++ b/src/Avalonia.Controls/Primitives/SelectingItemsControl.cs
@@ -1088,7 +1088,9 @@ namespace Avalonia.Controls.Primitives
                 }
                 else
                 {
-                    SelectedIndex = _updateSelectedIndex != int.MinValue ? _updateSelectedIndex : 0;
+                    SelectedIndex = _updateSelectedIndex != int.MinValue ? 
+                        _updateSelectedIndex : 
+                        AlwaysSelected ? 0 : -1;
                 }
             }
         }
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/src/Avalonia.Visuals/Media/PathMarkupParser.cs b/src/Avalonia.Visuals/Media/PathMarkupParser.cs
index 8852883dcc..e8f149df11 100644
--- a/src/Avalonia.Visuals/Media/PathMarkupParser.cs
+++ b/src/Avalonia.Visuals/Media/PathMarkupParser.cs
@@ -32,6 +32,7 @@ namespace Avalonia.Media
 
         private IGeometryContext _geometryContext;
         private Point _currentPoint;
+        private Point? _beginFigurePoint;
         private Point? _previousControlPoint;
         private bool _isOpen;
         private bool _isDisposed;
@@ -180,6 +181,8 @@ namespace Avalonia.Media
 
             _geometryContext.BeginFigure(_currentPoint);
 
+            _beginFigurePoint = _currentPoint;
+
             _isOpen = true;
         }
 
@@ -212,6 +215,12 @@ namespace Avalonia.Media
             if (_isOpen)
             {
                 _geometryContext.EndFigure(true);
+
+                if (_beginFigurePoint != null)
+                {
+                    _currentPoint = _beginFigurePoint.Value;
+                    _beginFigurePoint = null;
+                }
             }
 
             _previousControlPoint = null;
@@ -233,12 +242,6 @@ namespace Avalonia.Media
             {
                 span = ReadSeparator(span);
                 AddLine(ref span, relative);
-
-                if (!relative)
-                {
-                    _currentPoint = currentPoint;
-                    CreateFigure();
-                }
             }
         }
 
diff --git a/src/Avalonia.X11/X11Window.cs b/src/Avalonia.X11/X11Window.cs
index a1c701649e..860456a838 100644
--- a/src/Avalonia.X11/X11Window.cs
+++ b/src/Avalonia.X11/X11Window.cs
@@ -102,14 +102,17 @@ namespace Avalonia.X11
 
             int defaultWidth = 300, defaultHeight = 200;
 
-            if (!_popup)
+            if (!_popup && Screen != null)
             {
                 var monitor = Screen.AllScreens.OrderBy(x => x.PixelDensity)
                    .FirstOrDefault(m => m.Bounds.Contains(Position));
 
-                // Emulate Window 7+'s default window size behavior.
-                defaultWidth = (int)(monitor.WorkingArea.Width * 0.75d);
-                defaultHeight = (int)(monitor.WorkingArea.Height * 0.7d);
+                if (monitor != null)
+                {
+                    // Emulate Window 7+'s default window size behavior.
+                    defaultWidth = (int)(monitor.WorkingArea.Width * 0.75d);
+                    defaultHeight = (int)(monitor.WorkingArea.Height * 0.7d);
+                }
             }
 
             _handle = XCreateWindow(_x11.Display, _x11.RootWindow, 10, 10, defaultWidth, defaultHeight, 0,
diff --git a/tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests.cs b/tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests.cs
index 8f27ebe853..d5237e2aca 100644
--- a/tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests.cs
@@ -109,6 +109,43 @@ namespace Avalonia.Controls.UnitTests.Primitives
             Assert.True(items[1].IsSelected);
         }
 
+        [Fact]
+        public void SelectedIndex_Should_Be_Minus_1_After_Initialize()
+        {
+            var items = new[]
+            {
+                new Item(),
+                new Item(),
+            };
+
+            var target = new ListBox();
+            target.BeginInit();
+            target.Items = items;
+            target.Template = Template();
+            target.EndInit();
+
+            Assert.Equal(-1, target.SelectedIndex);
+        }
+
+        [Fact]
+        public void SelectedIndex_Should_Be_0_After_Initialize_With_AlwaysSelected()
+        {
+            var items = new[]
+            {
+                new Item(),
+                new Item(),
+            };
+
+            var target = new ListBox();
+            target.BeginInit();
+            target.SelectionMode = SelectionMode.Single | SelectionMode.AlwaysSelected;
+            target.Items = items;
+            target.Template = Template();
+            target.EndInit();
+
+            Assert.Equal(0, target.SelectedIndex);
+        }
+
         [Fact]
         public void Setting_SelectedIndex_During_Initialize_Should_Select_Item_When_AlwaysSelected_Is_Used()
         {
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);
+        }
     }
 }
diff --git a/tests/Avalonia.Visuals.UnitTests/Media/PathMarkupParserTests.cs b/tests/Avalonia.Visuals.UnitTests/Media/PathMarkupParserTests.cs
index 5570378063..e1475dce80 100644
--- a/tests/Avalonia.Visuals.UnitTests/Media/PathMarkupParserTests.cs
+++ b/tests/Avalonia.Visuals.UnitTests/Media/PathMarkupParserTests.cs
@@ -100,9 +100,7 @@ namespace Avalonia.Visuals.UnitTests.Media
 
                 Assert.Equal(new Point(10, 10), lineSegment.Point);
 
-                figure = pathGeometry.Figures[1];
-
-                segment = figure.Segments[0];
+                segment = figure.Segments[1];
 
                 Assert.IsType<LineSegment>(segment);
 
@@ -235,5 +233,30 @@ namespace Avalonia.Visuals.UnitTests.Media
                 Assert.Throws<InvalidDataException>(() => parser.Parse(pathData));
             }
         }
+
+        [Fact]
+        public void CloseFigure_Should_Move_CurrentPoint_To_CreateFigurePoint()
+        {
+            var pathGeometry = new PathGeometry();
+            using (var context = new PathGeometryContext(pathGeometry))
+            using (var parser = new PathMarkupParser(context))
+            {
+                parser.Parse("M10,10L100,100Z m10,10");
+
+                Assert.Equal(2, pathGeometry.Figures.Count);
+
+                var figure = pathGeometry.Figures[0];
+
+                Assert.Equal(new Point(10, 10), figure.StartPoint);
+
+                Assert.Equal(true, figure.IsClosed);
+
+                Assert.Equal(new Point(100, 100), ((LineSegment)figure.Segments[0]).Point);
+
+                figure = pathGeometry.Figures[1];
+
+                Assert.Equal(new Point(20, 20), figure.StartPoint);
+            }
+        }
     }
 }