Merge branch 'master' into master

native/Avalonia.Native/inc/avalonia-native.h

@@ -144,6 +144,7 @@ enum AvnStandardCursorType
     CursorDragMove,
     CursorDragCopy,
     CursorDragLink,
+    CursorNone
 };
 
 enum AvnWindowEdge

native/Avalonia.Native/src/OSX/cursor.h

@@ -11,18 +11,24 @@ class Cursor : public ComSingleObject<IAvnCursor, &IID_IAvnCursor>
 {
 private:
     NSCursor * _native;
-
+    bool _isHidden;
 public:
     FORWARD_IUNKNOWN()
-    Cursor(NSCursor * cursor)
+    Cursor(NSCursor * cursor, bool isHidden = false)
     {
         _native = cursor;
+        _isHidden = isHidden;
     }
 
     NSCursor* GetNative()
     {
         return _native;
     }
+    
+    bool IsHidden ()
+    {
+        return _isHidden;
+    }
 };
 
 extern std::map<AvnStandardCursorType, Cursor*> s_cursorMap;

native/Avalonia.Native/src/OSX/cursor.mm

@@ -21,6 +21,7 @@ class CursorFactory : public ComSingleObject<IAvnCursorFactory, &IID_IAvnCursorF
     Cursor* resizeRightCursor = new Cursor([NSCursor resizeRightCursor]);
     Cursor* resizeWestEastCursor = new Cursor([NSCursor resizeLeftRightCursor]);
     Cursor* operationNotAllowedCursor = new Cursor([NSCursor operationNotAllowedCursor]);
+    Cursor* noCursor = new Cursor([NSCursor arrowCursor], true);
 
     std::map<AvnStandardCursorType, Cursor*> s_cursorMap =
     {
@@ -46,11 +47,13 @@ class CursorFactory : public ComSingleObject<IAvnCursorFactory, &IID_IAvnCursorF
         { CursorIbeam, IBeamCursor },
         { CursorLeftSide, resizeLeftCursor },
         { CursorRightSide, resizeRightCursor },
-        { CursorNo, operationNotAllowedCursor }
+        { CursorNo, operationNotAllowedCursor },
+        { CursorNone, noCursor }
     };
 
 public:
     FORWARD_IUNKNOWN()
+    
     virtual HRESULT GetCursor (AvnStandardCursorType cursorType, IAvnCursor** retOut) override
     {
         *retOut = s_cursorMap[cursorType];

native/Avalonia.Native/src/OSX/window.mm

@@ -353,6 +353,16 @@ public:
             Cursor* avnCursor = dynamic_cast<Cursor*>(cursor);
             this->cursor = avnCursor->GetNative();
             UpdateCursor();
+            
+            if(avnCursor->IsHidden())
+            {
+                [NSCursor hide];
+            }
+            else
+            {
+                [NSCursor unhide];
+            }
+            
             return S_OK;
         }
     }

readme.md

@@ -8,9 +8,9 @@
 
 ## About
 
-Avalonia is a WPF-inspired cross-platform XAML-based UI framework providing a flexible styling system and supporting a wide range of OSs: Windows (.NET Framework, .NET Core), Linux (GTK), MacOS, Android and iOS.
+Avalonia is a WPF/UWP-inspired cross-platform XAML-based UI framework providing a flexible styling system and supporting a wide range of OSs: Windows (.NET Framework, .NET Core), Linux (libX11), MacOS, Android (experimental) and iOS (exprerimental).
 
-**Avalonia is currently in beta** which means that the framework is generally usable for writing applications, but there may be some bugs and breaking changes as we continue development.
+**Avalonia is currently in beta** which means that the framework is generally usable for writing applications, but there may be some bugs and breaking changes as we continue development, for more details about the status see https://github.com/AvaloniaUI/Avalonia/issues/2239
 
 | Control catalog | Desktop platforms | Mobile platforms |
 |---|---|---|

samples/ControlCatalog.NetCore/ControlCatalog.NetCore.csproj

@@ -11,6 +11,7 @@
     <ProjectReference Include="..\ControlCatalog\ControlCatalog.csproj" />
     <ProjectReference Include="..\..\src\Avalonia.Desktop\Avalonia.Desktop.csproj" />
     <ProjectReference Include="..\..\src\Avalonia.X11\Avalonia.X11.csproj" />
+    <PackageReference Include="Avalonia.Angle.Windows.Natives" Version="2.1.0.2019013001"/>
   </ItemGroup>
 
 

samples/ControlCatalog.NetCore/Program.cs

@@ -47,7 +47,11 @@ namespace ControlCatalog.NetCore
             => AppBuilder.Configure<App>()
                 .UsePlatformDetect()
                 .With(new X11PlatformOptions {EnableMultiTouch = true})
-                .With(new Win32PlatformOptions {EnableMultitouch = true})
+                .With(new Win32PlatformOptions
+                {
+                    EnableMultitouch = true,
+                    AllowEglInitialization = true
+                })
                 .UseSkia()
                 .UseReactiveUI();
 

samples/ControlCatalog/Pages/DataGridPage.xaml

@@ -11,7 +11,7 @@
       <Setter Property="Background" Value="{Binding Path=GDP, Mode=OneWay, Converter={StaticResource GDPConverter}}" />
     </Style>
   </UserControl.Styles>
-  <Grid RowDefinitions="Auto,Auto">
+  <Grid RowDefinitions="Auto,*">
     <StackPanel Orientation="Vertical" Spacing="4" Grid.Row="0">
       <TextBlock Classes="h1">DataGrid</TextBlock>
       <TextBlock Classes="h2">A control for displaying and interacting with a data source.</TextBlock>
@@ -52,4 +52,4 @@
       </TabItem>
     </TabControl>
   </Grid>
-</UserControl>
+</UserControl>

samples/RenderDemo/MainWindow.xaml

@@ -38,6 +38,9 @@
       <TabItem Header="SkCanvas">
         <pages:CustomSkiaPage/>
       </TabItem>
+      <TabItem Header="RenderTargetBitmap">
+        <pages:RenderTargetBitmapPage/>
+      </TabItem>
     </TabControl>
   </DockPanel>
 </Window>

samples/RenderDemo/Pages/RenderTargetBitmapPage.cs

@@ -0,0 +1,49 @@
+using System.Diagnostics;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.LogicalTree;
+using Avalonia.Media;
+using Avalonia.Media.Imaging;
+using Avalonia.Threading;
+using Avalonia.Visuals.Media.Imaging;
+
+namespace RenderDemo.Pages
+{
+    public class RenderTargetBitmapPage : Control
+    {
+        private RenderTargetBitmap _bitmap;
+
+        protected override void OnAttachedToLogicalTree(LogicalTreeAttachmentEventArgs e)
+        {
+            _bitmap = new RenderTargetBitmap(new PixelSize(200, 200), new Vector(96, 96));
+            base.OnAttachedToLogicalTree(e);
+        }
+
+        protected override void OnDetachedFromLogicalTree(LogicalTreeAttachmentEventArgs e)
+        {
+            _bitmap.Dispose();
+            _bitmap = null;
+            base.OnDetachedFromLogicalTree(e);
+        }
+
+        readonly Stopwatch _st = Stopwatch.StartNew();
+        public override void Render(DrawingContext context)
+        {
+            using (var ctxi = _bitmap.CreateDrawingContext(null))
+            using(var ctx = new DrawingContext(ctxi, false))
+            using (ctx.PushPostTransform(Matrix.CreateTranslation(-100, -100)
+                                         * Matrix.CreateRotation(_st.Elapsed.TotalSeconds)
+                                         * Matrix.CreateTranslation(100, 100)))
+            {
+                ctxi.Clear(default);
+                ctx.FillRectangle(Brushes.Fuchsia, new Rect(50, 50, 100, 100));
+            }
+
+            context.DrawImage(_bitmap, 1, 
+                new Rect(0, 0, 200, 200), 
+                new Rect(0, 0, 200, 200));
+            Dispatcher.UIThread.Post(InvalidateVisual, DispatcherPriority.Background);
+            base.Render(context);
+        }
+    }
+}

src/Avalonia.Base/Utilities/MathUtilities.cs

@@ -1,6 +1,9 @@
 // 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.
 
+using System;
+using System.Runtime.InteropServices;
+
 namespace Avalonia.Utilities
 {
     /// <summary>
@@ -8,6 +11,89 @@ namespace Avalonia.Utilities
     /// </summary>
     public static class MathUtilities
     {
+        /// <summary>
+        /// AreClose - Returns whether or not two doubles are "close".  That is, whether or 
+        /// not they are within epsilon of each other.
+        /// </summary> 
+        /// <param name="value1"> The first double to compare. </param>
+        /// <param name="value2"> The second double to compare. </param>
+        public static bool AreClose(double value1, double value2)
+        {
+            //in case they are Infinities (then epsilon check does not work)
+            if (value1 == value2) return true;
+            double eps = (Math.Abs(value1) + Math.Abs(value2) + 10.0) * double.Epsilon;
+            double delta = value1 - value2;
+            return (-eps < delta) && (eps > delta);
+        }
+
+        /// <summary>
+        /// LessThan - Returns whether or not the first double is less than the second double.
+        /// That is, whether or not the first is strictly less than *and* not within epsilon of
+        /// the other number.
+        /// </summary>
+        /// <param name="value1"> The first double to compare. </param>
+        /// <param name="value2"> The second double to compare. </param>
+        public static bool LessThan(double value1, double value2)
+        {
+            return (value1 < value2) && !AreClose(value1, value2);
+        }
+
+        /// <summary>
+        /// GreaterThan - Returns whether or not the first double is greater than the second double.
+        /// That is, whether or not the first is strictly greater than *and* not within epsilon of
+        /// the other number.
+        /// </summary>
+        /// <param name="value1"> The first double to compare. </param>
+        /// <param name="value2"> The second double to compare. </param>
+        public static bool GreaterThan(double value1, double value2)
+        {
+            return (value1 > value2) && !AreClose(value1, value2);
+        }
+
+        /// <summary>
+        /// LessThanOrClose - Returns whether or not the first double is less than or close to
+        /// the second double.  That is, whether or not the first is strictly less than or within
+        /// epsilon of the other number.
+        /// </summary>
+        /// <param name="value1"> The first double to compare. </param>
+        /// <param name="value2"> The second double to compare. </param>
+        public static bool LessThanOrClose(double value1, double value2)
+        {
+            return (value1 < value2) || AreClose(value1, value2);
+        }
+
+        /// <summary>
+        /// GreaterThanOrClose - Returns whether or not the first double is greater than or close to
+        /// the second double.  That is, whether or not the first is strictly greater than or within
+        /// epsilon of the other number.
+        /// </summary>
+        /// <param name="value1"> The first double to compare. </param>
+        /// <param name="value2"> The second double to compare. </param>
+        public static bool GreaterThanOrClose(double value1, double value2)
+        {
+            return (value1 > value2) || AreClose(value1, value2);
+        }
+
+        /// <summary>
+        /// IsOne - Returns whether or not the double is "close" to 1.  Same as AreClose(double, 1),
+        /// but this is faster.
+        /// </summary>
+        /// <param name="value"> The double to compare to 1. </param>
+        public static bool IsOne(double value)
+        {
+            return Math.Abs(value - 1.0) < 10.0 * double.Epsilon;
+        }
+
+        /// <summary>
+        /// IsZero - Returns whether or not the double is "close" to 0.  Same as AreClose(double, 0),
+        /// but this is faster.
+        /// </summary>
+        /// <param name="value"> The double to compare to 0. </param>
+        public static bool IsZero(double value)
+        {
+            return Math.Abs(value) < 10.0 * double.Epsilon;
+        }
+
         /// <summary>
         /// Clamps a value between a minimum and maximum value.
         /// </summary>
@@ -31,6 +117,39 @@ namespace Avalonia.Utilities
             }
         }
 
+        /// <summary>
+        /// Calculates the value to be used for layout rounding at high DPI.
+        /// </summary>
+        /// <param name="value">Input value to be rounded.</param>
+        /// <param name="dpiScale">Ratio of screen's DPI to layout DPI</param>
+        /// <returns>Adjusted value that will produce layout rounding on screen at high dpi.</returns>
+        /// <remarks>This is a layout helper method. It takes DPI into account and also does not return
+        /// the rounded value if it is unacceptable for layout, e.g. Infinity or NaN. It's a helper associated with
+        /// UseLayoutRounding  property and should not be used as a general rounding utility.</remarks>
+        public static double RoundLayoutValue(double value, double dpiScale)
+        {
+            double newValue;
+
+            // If DPI == 1, don't use DPI-aware rounding.
+            if (!MathUtilities.AreClose(dpiScale, 1.0))
+            {
+                newValue = Math.Round(value * dpiScale) / dpiScale;
+                // If rounding produces a value unacceptable to layout (NaN, Infinity or MaxValue), use the original value.
+                if (double.IsNaN(newValue) ||
+                    double.IsInfinity(newValue) ||
+                    MathUtilities.AreClose(newValue, double.MaxValue))
+                {
+                    newValue = value;
+                }
+            }
+            else
+            {
+                newValue = Math.Round(value);
+            }
+
+            return newValue;
+        }
+
         /// <summary>
         /// Clamps a value between a minimum and maximum value.
         /// </summary>

src/Avalonia.Build.Tasks/Program.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.IO;
+using System.Linq;
 using Microsoft.Build.Framework;
 
 namespace Avalonia.Build.Tasks
@@ -11,8 +12,14 @@ namespace Avalonia.Build.Tasks
         {
             if (args.Length != 3)
             {
-                Console.Error.WriteLine("input references output");
-                return 1;
+                if (args.Length == 1)
+                    args = new[] {"original.dll", "references", "out.dll"}
+                        .Select(x => Path.Combine(args[0], x)).ToArray();
+                else
+                {
+                    Console.Error.WriteLine("input references output");
+                    return 1;
+                }
             }
 
             return new CompileAvaloniaXamlTask()

src/Avalonia.Build.Tasks/XamlCompilerTaskExecutor.Helpers.cs

@@ -4,6 +4,7 @@ using System.Linq;
 using Avalonia.Utilities;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
+using Mono.Collections.Generic;
 using XamlIl.TypeSystem;
 
 namespace Avalonia.Build.Tasks
@@ -144,6 +145,37 @@ namespace Avalonia.Build.Tasks
             });
 
         }
+        
+
+        private static bool MatchThisCall(Collection<Instruction> instructions, int idx)
+        {
+            var i = instructions[idx];
+            // A "normal" way of passing `this` to a static method:
+            
+            // ldarg.0
+            // call void [Avalonia.Markup.Xaml]Avalonia.Markup.Xaml.AvaloniaXamlLoader::Load(object)
+            
+            if (i.OpCode == OpCodes.Ldarg_0 || (i.OpCode == OpCodes.Ldarg && i.Operand?.Equals(0) == true))
+                return true;
+
+            /* F# way of using `this` in constructor emits a monstrosity like this:
+                IL_01c7: ldarg.0
+                IL_01c8: ldfld class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<class FVim.Cursor> FVim.Cursor::this
+                IL_01cd: call instance !0 class [FSharp.Core]Microsoft.FSharp.Core.FSharpRef`1<class FVim.Cursor>::get_contents()
+                IL_01d2: call !!0 [FSharp.Core]Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::CheckThis<class FVim.Cursor>(!!0)
+                IL_01d7: call void [Avalonia.Markup.Xaml]Avalonia.Markup.Xaml.AvaloniaXamlLoader::Load(object)
+                
+                We check for the previous call to be Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions::CheckThis
+                since it actually returns `this`
+            */
+            if (i.OpCode == OpCodes.Call
+                && i.Operand is GenericInstanceMethod gim
+                && gim.Name == "CheckThis"
+                && gim.DeclaringType.FullName == "Microsoft.FSharp.Core.LanguagePrimitives/IntrinsicFunctions")
+                return true;
+
+            return false;
+        }
     }
  
 }

src/Avalonia.Build.Tasks/XamlCompilerTaskExecutor.cs

@@ -234,8 +234,7 @@ namespace Avalonia.Build.Tasks
                                 var i = method.Body.Instructions;
                                 for (var c = 1; c < i.Count; c++)
                                 {
-                                    if (i[c - 1].OpCode == OpCodes.Ldarg_0
-                                        && i[c].OpCode == OpCodes.Call)
+                                    if (i[c].OpCode == OpCodes.Call)
                                     {
                                         var op = i[c].Operand as MethodReference;
                                         
@@ -254,8 +253,11 @@ namespace Avalonia.Build.Tasks
                                             && op.Parameters[0].ParameterType.FullName == "System.Object"
                                             && op.DeclaringType.FullName == "Avalonia.Markup.Xaml.AvaloniaXamlLoader")
                                         {
-                                            i[c].Operand = trampoline;
-                                            foundXamlLoader = true;
+                                            if (MatchThisCall(i, c - 1))
+                                            {
+                                                i[c].Operand = trampoline;
+                                                foundXamlLoader = true;
+                                            }
                                         }
                                     }
                                 }

src/Avalonia.Controls.DataGrid/DataGridRow.cs

@@ -881,10 +881,10 @@ namespace Avalonia.Controls
                 && (double.IsNaN(_detailsContent.Height))
                 && (AreDetailsVisible)
                 && (!double.IsNaN(_detailsDesiredHeight))
-                && !DoubleUtil.AreClose(_detailsContent.Bounds.Height, _detailsDesiredHeight)
+                && !DoubleUtil.AreClose(_detailsContent.Bounds.Inflate(_detailsContent.Margin).Height, _detailsDesiredHeight)
                 && Slot != -1)
             {
-                _detailsDesiredHeight = _detailsContent.Bounds.Height;
+                _detailsDesiredHeight = _detailsContent.Bounds.Inflate(_detailsContent.Margin).Height;
 
                 if (true)
                 {
@@ -943,6 +943,16 @@ namespace Avalonia.Controls
                 _previousDetailsHeight = newValue.Height;
             }
         }
+        private void DetailsContent_BoundsChanged(Rect newValue)
+        {
+            if(_detailsContent != null)
+                DetailsContent_SizeChanged(newValue.Inflate(_detailsContent.Margin));
+        }
+        private void DetailsContent_MarginChanged(Thickness newValue)
+        {
+            if (_detailsContent != null)
+                DetailsContent_SizeChanged(_detailsContent.Bounds.Inflate(newValue));
+        }
 
         //TODO Animation
         // Sets AreDetailsVisible on the row and animates if necessary
@@ -997,7 +1007,7 @@ namespace Avalonia.Controls
                 }
             }
         }
-
+        
         internal void ApplyDetailsTemplate(bool initializeDetailsPreferredHeight)
         {
             if (_detailsElement != null && AreDetailsVisible)
@@ -1023,8 +1033,11 @@ namespace Avalonia.Controls
                     if (_detailsContent != null)
                     {
                         _detailsContentSizeSubscription =
-                            _detailsContent.GetObservable(BoundsProperty)
-                                           .Subscribe(DetailsContent_SizeChanged);
+                            System.Reactive.Disposables.StableCompositeDisposable.Create(
+                                _detailsContent.GetObservable(BoundsProperty)
+                                               .Subscribe(DetailsContent_BoundsChanged),
+                                _detailsContent.GetObservable(MarginProperty)
+                                               .Subscribe(DetailsContent_MarginChanged));
                         _detailsElement.Children.Add(_detailsContent);
                     }
                 }
@@ -1053,4 +1066,4 @@ namespace Avalonia.Controls
 
     //TODO Styles
 
-}
+}

src/Avalonia.Controls/Button.cs

@@ -252,7 +252,6 @@ namespace Avalonia.Controls
 
             if (e.MouseButton == MouseButton.Left)
             {
-                e.Device.Capture(this);
                 IsPressed = true;
                 e.Handled = true;
 
@@ -270,7 +269,6 @@ namespace Avalonia.Controls
 
             if (IsPressed && e.MouseButton == MouseButton.Left)
             {
-                e.Device.Capture(null);
                 IsPressed = false;
                 e.Handled = true;
 
@@ -282,6 +280,11 @@ namespace Avalonia.Controls
             }
         }
 
+        protected override void OnPointerCaptureLost(PointerCaptureLostEventArgs e)
+        {
+            IsPressed = false;
+        }
+
         protected override void UpdateDataValidation(AvaloniaProperty property, BindingNotification status)
         {
             base.UpdateDataValidation(property, status);

src/Avalonia.Controls/ColumnDefinition.cs

@@ -55,11 +55,7 @@ namespace Avalonia.Controls
         /// <summary>
         /// Gets the actual calculated width of the column.
         /// </summary>
-        public double ActualWidth
-        {
-            get;
-            internal set;
-        }
+        public double ActualWidth => Parent?.GetFinalColumnDefinitionWidth(Index) ?? 0d;
 
         /// <summary>
         /// Gets or sets the maximum width of the column in DIPs.
@@ -87,5 +83,9 @@ namespace Avalonia.Controls
             get { return GetValue(WidthProperty); }
             set { SetValue(WidthProperty, value); }
         }
+
+        internal override GridLength UserSizeValueCache => this.Width;
+        internal override double UserMinSizeValueCache => this.MinWidth;
+        internal override double UserMaxSizeValueCache => this.MaxWidth;
     }
 }

src/Avalonia.Controls/ColumnDefinitions.cs

@@ -1,6 +1,8 @@
 // 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.
 
+using System;
+using System.Collections.Specialized;
 using System.Linq;
 using Avalonia.Collections;
 
@@ -9,7 +11,7 @@ namespace Avalonia.Controls
     /// <summary>
     /// A collection of <see cref="ColumnDefinition"/>s.
     /// </summary>
-    public class ColumnDefinitions : AvaloniaList<ColumnDefinition>
+    public class ColumnDefinitions : DefinitionList<ColumnDefinition>
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="ColumnDefinitions"/> class.
@@ -17,6 +19,7 @@ namespace Avalonia.Controls
         public ColumnDefinitions()
         {
             ResetBehavior = ResetBehavior.Remove;
+            CollectionChanged += OnCollectionChanged;
         }
 
         /// <summary>

src/Avalonia.Controls/DefinitionBase.cs

@@ -1,26 +1,947 @@
-// 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.
+// This source file is 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 System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+using Avalonia;
+using Avalonia.Collections;
+using Avalonia.Utilities;
 
 namespace Avalonia.Controls
 {
     /// <summary>
-    /// Base class for <see cref="ColumnDefinition"/> and <see cref="RowDefinition"/>.
+    /// DefinitionBase provides core functionality used internally by Grid
+    /// and ColumnDefinitionCollection / RowDefinitionCollection
     /// </summary>
-    public class DefinitionBase : AvaloniaObject
+    public abstract class DefinitionBase : AvaloniaObject
     {
-        /// <summary>
-        /// Defines the <see cref="SharedSizeGroup"/> property.
-        /// </summary>
-        public static readonly StyledProperty<string> SharedSizeGroupProperty =
-            AvaloniaProperty.Register<DefinitionBase, string>(nameof(SharedSizeGroup), inherits: true);
+        //------------------------------------------------------
+        //
+        //  Constructors
+        //
+        //------------------------------------------------------
+
+        #region Constructors
+
+        /* internal DefinitionBase(bool isColumnDefinition)
+        {
+            _isColumnDefinition = isColumnDefinition;
+            _parentIndex = -1;
+        }*/
+
+        #endregion Constructors
+
+        //------------------------------------------------------
+        //
+        //  Public Properties
+        //
+        //------------------------------------------------------
+
+        #region Public Properties
 
         /// <summary>
-        /// Gets or sets the name of the shared size group of the column or row.
+        /// SharedSizeGroup property.
         /// </summary>
         public string SharedSizeGroup
         {
-            get { return GetValue(SharedSizeGroupProperty); }
+            get { return (string) GetValue(SharedSizeGroupProperty); }
             set { SetValue(SharedSizeGroupProperty, value); }
         }
+
+        #endregion Public Properties
+
+        //------------------------------------------------------
+        //
+        //  Internal Methods
+        //
+        //------------------------------------------------------
+
+        #region Internal Methods
+
+        /// <summary>
+        /// Callback to notify about entering model tree.
+        /// </summary>
+        internal void OnEnterParentTree()
+        {
+            this.InheritanceParent = Parent;
+            if (_sharedState == null)
+            {
+                //  start with getting SharedSizeGroup value. 
+                //  this property is NOT inhereted which should result in better overall perf.
+                string sharedSizeGroupId = SharedSizeGroup;
+                if (sharedSizeGroupId != null)
+                {
+                    SharedSizeScope privateSharedSizeScope = PrivateSharedSizeScope;
+                    if (privateSharedSizeScope != null)
+                    {
+                        _sharedState = privateSharedSizeScope.EnsureSharedState(sharedSizeGroupId);
+                        _sharedState.AddMember(this);
+                    }
+                }
+            }
+        }
+
+        protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs e)
+        {
+            if (e.Property.PropertyType == typeof(GridLength)
+             || e.Property.PropertyType == typeof(double))
+                OnUserSizePropertyChanged(e);
+                
+            base.OnPropertyChanged(e);
+        }
+
+        /// <summary>
+        /// Callback to notify about exitting model tree.
+        /// </summary>
+        internal void OnExitParentTree()
+        {
+            _offset = 0;
+            if (_sharedState != null)
+            {
+                _sharedState.RemoveMember(this);
+                _sharedState = null;
+            }
+        }
+
+        /// <summary>
+        /// Performs action preparing definition to enter layout calculation mode.
+        /// </summary>
+        internal void OnBeforeLayout(Grid grid)
+        {
+            //  reset layout state.
+            _minSize = 0;
+            LayoutWasUpdated = true;
+
+            //  defer verification for shared definitions
+            if (_sharedState != null) { _sharedState.EnsureDeferredValidation(grid); }
+        }
+
+        /// <summary>
+        /// Updates min size.
+        /// </summary>
+        /// <param name="minSize">New size.</param>
+        internal void UpdateMinSize(double minSize)
+        {
+            _minSize = Math.Max(_minSize, minSize);
+        }
+
+        /// <summary>
+        /// Sets min size.
+        /// </summary>
+        /// <param name="minSize">New size.</param>
+        internal void SetMinSize(double minSize)
+        {
+            _minSize = minSize;
+        }
+
+        /// <summary>
+        /// <see cref="PropertyMetadata.PropertyChangedCallback"/>
+        /// </summary>
+        /// <remarks>
+        /// This method needs to be internal to be accessable from derived classes.
+        /// </remarks>
+        internal void OnUserSizePropertyChanged(AvaloniaPropertyChangedEventArgs e)
+        {
+            if (InParentLogicalTree)
+            {
+                if (_sharedState != null)
+                {
+                    _sharedState.Invalidate();
+                }
+                else
+                {
+                    if (((GridLength)e.OldValue).GridUnitType != ((GridLength)e.NewValue).GridUnitType)
+                    {
+                        Parent.Invalidate();
+                    }
+                    else
+                    {
+                        Parent.InvalidateMeasure();
+                    }
+                }
+            }
+        }
+        /// <summary>
+        /// <see cref="AvaloniaProperty.ValidateValueCallback"/>
+        /// </summary>
+        /// <remarks>
+        /// This method needs to be internal to be accessable from derived classes.
+        /// </remarks>
+        internal static bool IsUserSizePropertyValueValid(object value)
+        {
+            return (((GridLength)value).Value >= 0);
+        }
+
+        /// <summary>
+        /// <see cref="PropertyMetadata.PropertyChangedCallback"/>
+        /// </summary>
+        /// <remarks>
+        /// This method needs to be internal to be accessable from derived classes.
+        /// </remarks>
+        internal static void OnUserMinSizePropertyChanged(AvaloniaObject d, AvaloniaPropertyChangedEventArgs e)
+        {
+            DefinitionBase definition = (DefinitionBase) d;
+
+            if (definition.InParentLogicalTree)
+            {
+                Grid parentGrid = (Grid) definition.Parent;
+                parentGrid.InvalidateMeasure();
+            }
+        }
+
+        /// <summary>
+        /// <see cref="AvaloniaProperty.ValidateValueCallback"/>
+        /// </summary>
+        /// <remarks>
+        /// This method needs to be internal to be accessable from derived classes.
+        /// </remarks>
+        internal static bool IsUserMinSizePropertyValueValid(object value)
+        {
+            double v = (double)value;
+            return (!double.IsNaN(v) && v >= 0.0d && !Double.IsPositiveInfinity(v));
+        }
+
+        /// <summary>
+        /// <see cref="PropertyMetadata.PropertyChangedCallback"/>
+        /// </summary>
+        /// <remarks>
+        /// This method needs to be internal to be accessable from derived classes.
+        /// </remarks>
+        internal static void OnUserMaxSizePropertyChanged(AvaloniaObject d, AvaloniaPropertyChangedEventArgs e)
+        {
+            DefinitionBase definition = (DefinitionBase) d;
+
+            if (definition.InParentLogicalTree)
+            {
+                Grid parentGrid = (Grid) definition.Parent;
+                parentGrid.InvalidateMeasure();
+            }
+        }
+
+        /// <summary>
+        /// <see cref="AvaloniaProperty.ValidateValueCallback"/>
+        /// </summary>
+        /// <remarks>
+        /// This method needs to be internal to be accessable from derived classes.
+        /// </remarks>
+        internal static bool IsUserMaxSizePropertyValueValid(object value)
+        {
+            double v = (double)value;
+            return (!double.IsNaN(v) && v >= 0.0d);
+        }
+
+        /// <summary>
+        /// <see cref="PropertyMetadata.PropertyChangedCallback"/>
+        /// </summary>
+        /// <remarks>
+        /// This method reflects Grid.SharedScopeProperty state by setting / clearing
+        /// dynamic property PrivateSharedSizeScopeProperty. Value of PrivateSharedSizeScopeProperty
+        /// is a collection of SharedSizeState objects for the scope.
+        /// Also PrivateSharedSizeScopeProperty is FrameworkPropertyMetadataOptions.Inherits property. So that all children
+        /// elements belonging to a certain scope can easily access SharedSizeState collection. As well
+        /// as been norified about enter / exit a scope.
+        /// </remarks>
+        internal static void OnIsSharedSizeScopePropertyChanged(AvaloniaObject d, AvaloniaPropertyChangedEventArgs e)
+        {
+            //  is it possible to optimize here something like this:
+            //  if ((bool)d.GetValue(Grid.IsSharedSizeScopeProperty) == (d.GetLocalValue(PrivateSharedSizeScopeProperty) != null)
+            //  { /* do nothing */ }
+            if ((bool) e.NewValue)
+            {
+                SharedSizeScope sharedStatesCollection = new SharedSizeScope();
+                d.SetValue(PrivateSharedSizeScopeProperty, sharedStatesCollection);
+            }
+            else
+            {
+                d.ClearValue(PrivateSharedSizeScopeProperty);
+            }
+        }
+
+        #endregion Internal Methods
+
+        //------------------------------------------------------
+        //
+        //  Internal Properties
+        //
+        //------------------------------------------------------
+
+        #region Internal Properties
+
+        /// <summary>
+        /// Returns <c>true</c> if this definition is a part of shared group.
+        /// </summary>
+        internal bool IsShared
+        {
+            get { return (_sharedState != null); }
+        }
+
+        /// <summary>
+        /// Internal accessor to user size field.
+        /// </summary>
+        internal GridLength UserSize
+        {
+            get { return (_sharedState != null ? _sharedState.UserSize : UserSizeValueCache); }
+        }
+
+        /// <summary>
+        /// Internal accessor to user min size field.
+        /// </summary>
+        internal double UserMinSize
+        {
+            get { return (UserMinSizeValueCache); }
+        }
+
+        /// <summary>
+        /// Internal accessor to user max size field.
+        /// </summary>
+        internal double UserMaxSize
+        {
+            get { return (UserMaxSizeValueCache); }
+        }
+
+        /// <summary>
+        /// DefinitionBase's index in the parents collection.
+        /// </summary>
+        internal int Index
+        {
+            get
+            {
+                return (_parentIndex);
+            }
+            set
+            {
+                Debug.Assert(value >= -1);
+                _parentIndex = value;
+            }
+        }
+
+        /// <summary>
+        /// Layout-time user size type.
+        /// </summary>
+        internal Grid.LayoutTimeSizeType SizeType
+        {
+            get { return (_sizeType); }
+            set { _sizeType = value; }
+        }
+
+        /// <summary>
+        /// Returns or sets measure size for the definition.
+        /// </summary>
+        internal double MeasureSize
+        {
+            get { return (_measureSize); }
+            set { _measureSize = value; }
+        }
+
+        /// <summary>
+        /// Returns definition's layout time type sensitive preferred size.
+        /// </summary>
+        /// <remarks>
+        /// Returned value is guaranteed to be true preferred size.
+        /// </remarks>
+        internal double PreferredSize
+        {
+            get
+            {
+                double preferredSize = MinSize;
+                if (    _sizeType != Grid.LayoutTimeSizeType.Auto
+                    &&  preferredSize < _measureSize    )
+                {
+                    preferredSize = _measureSize;
+                }
+                return (preferredSize);
+            }
+        }
+
+        /// <summary>
+        /// Returns or sets size cache for the definition.
+        /// </summary>
+        internal double SizeCache
+        {
+            get { return (_sizeCache); }
+            set { _sizeCache = value; }
+        }
+
+        /// <summary>
+        /// Returns min size.
+        /// </summary>
+        internal double MinSize
+        {
+            get
+            {
+                double minSize = _minSize;
+                if (    UseSharedMinimum
+                    &&  _sharedState != null
+                    &&  minSize < _sharedState.MinSize  )
+                {
+                    minSize = _sharedState.MinSize;
+                }
+                return (minSize);
+            }
+        }
+
+        /// <summary>
+        /// Returns min size, always taking into account shared state.
+        /// </summary>
+        internal double MinSizeForArrange
+        {
+            get
+            {
+                double minSize = _minSize;
+                if (    _sharedState != null
+                    &&  (UseSharedMinimum || !LayoutWasUpdated)
+                    &&  minSize < _sharedState.MinSize  )
+                {
+                    minSize = _sharedState.MinSize;
+                }
+                return (minSize);
+            }
+        }
+
+        /// <summary>
+        /// Offset.
+        /// </summary>
+        internal double FinalOffset
+        {
+            get { return _offset; }
+            set { _offset = value; }
+        }
+
+        /// <summary>
+        /// Internal helper to access up-to-date UserSize property value.
+        /// </summary>
+        internal abstract GridLength UserSizeValueCache { get; }
+
+        /// <summary>
+        /// Internal helper to access up-to-date UserMinSize property value.
+        /// </summary>
+        internal abstract double UserMinSizeValueCache { get; }
+
+        /// <summary>
+        /// Internal helper to access up-to-date UserMaxSize property value.
+        /// </summary>
+        internal abstract double UserMaxSizeValueCache { get; }
+        
+        /// <summary>
+        /// Protected. Returns <c>true</c> if this DefinitionBase instance is in parent's logical tree.
+        /// </summary>
+        internal bool InParentLogicalTree
+        {
+            get { return (_parentIndex != -1); }
+        }
+
+        internal Grid Parent { get; set; }
+
+        #endregion Internal Properties
+
+        //------------------------------------------------------
+        //
+        //  Private Methods
+        //
+        //------------------------------------------------------
+
+        #region Private Methods
+
+        /// <summary>
+        /// SetFlags is used to set or unset one or multiple
+        /// flags on the object.
+        /// </summary>
+        private void SetFlags(bool value, Flags flags)
+        {
+            _flags = value ? (_flags | flags) : (_flags & (~flags));
+        }
+
+        /// <summary>
+        /// CheckFlagsAnd returns <c>true</c> if all the flags in the
+        /// given bitmask are set on the object.
+        /// </summary>
+        private bool CheckFlagsAnd(Flags flags)
+        {
+            return ((_flags & flags) == flags);
+        }
+
+        /// <summary>
+        /// <see cref="PropertyMetadata.PropertyChangedCallback"/>
+        /// </summary>
+        private static void OnSharedSizeGroupPropertyChanged(AvaloniaObject d, AvaloniaPropertyChangedEventArgs e)
+        {
+            DefinitionBase definition = (DefinitionBase) d;
+            
+            if (definition.InParentLogicalTree)
+            {
+                string sharedSizeGroupId = (string) e.NewValue;
+
+                if (definition._sharedState != null)
+                {
+                    //  if definition is already registered AND shared size group id is changing,
+                    //  then un-register the definition from the current shared size state object.
+                    definition._sharedState.RemoveMember(definition);
+                    definition._sharedState = null;
+                }
+                
+                if ((definition._sharedState == null) && (sharedSizeGroupId != null))
+                {
+                    SharedSizeScope privateSharedSizeScope = definition.PrivateSharedSizeScope;
+                    if (privateSharedSizeScope != null)
+                    {
+                        //  if definition is not registered and both: shared size group id AND private shared scope 
+                        //  are available, then register definition.
+                        definition._sharedState = privateSharedSizeScope.EnsureSharedState(sharedSizeGroupId);
+                        definition._sharedState.AddMember(definition);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// <see cref="AvaloniaProperty.ValidateValueCallback"/>
+        /// </summary>
+        /// <remarks>
+        /// Verifies that Shared Size Group Property string
+        /// a) not empty.
+        /// b) contains only letters, digits and underscore ('_').
+        /// c) does not start with a digit.
+        /// </remarks>
+        private static string SharedSizeGroupPropertyValueValid(Control _, string value)
+        {
+            Contract.Requires<ArgumentNullException>(value != null);
+
+            string id = (string)value;
+
+            if (id != string.Empty)
+            {
+                int i = -1;
+                while (++i < id.Length)
+                {
+                    bool isDigit = Char.IsDigit(id[i]);
+
+                    if (    (i == 0 && isDigit)
+                        ||  !(  isDigit
+                            ||  Char.IsLetter(id[i])
+                            ||  '_' == id[i]    )   )
+                    {
+                        break;
+                    }
+                }
+
+                if (i == id.Length)
+                {
+                    return value;
+                }
+            }
+
+            throw new ArgumentException("Invalid SharedSizeGroup string.");            
+        }
+
+        /// <summary>
+        /// <see cref="PropertyMetadata.PropertyChangedCallback"/>
+        /// </summary>
+        /// <remark>
+        /// OnPrivateSharedSizeScopePropertyChanged is called when new scope enters or
+        /// existing scope just left. In both cases if the DefinitionBase object is already registered
+        /// in SharedSizeState, it should un-register and register itself in a new one.
+        /// </remark>
+        private static void OnPrivateSharedSizeScopePropertyChanged(AvaloniaObject d, AvaloniaPropertyChangedEventArgs e)
+        {
+            DefinitionBase definition = (DefinitionBase)d;
+
+            if (definition.InParentLogicalTree)
+            {
+                SharedSizeScope privateSharedSizeScope = (SharedSizeScope) e.NewValue;
+
+                if (definition._sharedState != null)
+                {
+                    //  if definition is already registered And shared size scope is changing,
+                    //  then un-register the definition from the current shared size state object.
+                    definition._sharedState.RemoveMember(definition);
+                    definition._sharedState = null;
+                }
+
+                if ((definition._sharedState == null) && (privateSharedSizeScope != null))
+                {
+                    string sharedSizeGroup = definition.SharedSizeGroup;
+                    if (sharedSizeGroup != null)
+                    {
+                        //  if definition is not registered and both: shared size group id AND private shared scope 
+                        //  are available, then register definition.
+                        definition._sharedState = privateSharedSizeScope.EnsureSharedState(definition.SharedSizeGroup);
+                        definition._sharedState.AddMember(definition);
+                    }
+                }
+            }
+        }
+
+        #endregion Private Methods
+
+        //------------------------------------------------------
+        //
+        //  Private Properties
+        //
+        //------------------------------------------------------
+
+        #region Private Properties
+
+        /// <summary>
+        /// Private getter of shared state collection dynamic property.
+        /// </summary>
+        private SharedSizeScope PrivateSharedSizeScope
+        {
+            get { return (SharedSizeScope) GetValue(PrivateSharedSizeScopeProperty); }
+        }
+
+        /// <summary>
+        /// Convenience accessor to UseSharedMinimum flag
+        /// </summary>
+        private bool UseSharedMinimum
+        {
+            get { return (CheckFlagsAnd(Flags.UseSharedMinimum)); }
+            set { SetFlags(value, Flags.UseSharedMinimum); }
+        }
+
+        /// <summary>
+        /// Convenience accessor to LayoutWasUpdated flag
+        /// </summary>
+        private bool LayoutWasUpdated
+        {
+            get { return (CheckFlagsAnd(Flags.LayoutWasUpdated)); }
+            set { SetFlags(value, Flags.LayoutWasUpdated); }
+        }
+
+        #endregion Private Properties
+
+        //------------------------------------------------------
+        //
+        //  Private Fields
+        //
+        //------------------------------------------------------
+
+        #region Private Fields
+        private readonly bool _isColumnDefinition;      //  when "true", this is a ColumnDefinition; when "false" this is a RowDefinition (faster than a type check)
+        private Flags _flags;                           //  flags reflecting various aspects of internal state
+        internal int _parentIndex = -1;                  //  this instance's index in parent's children collection
+
+        private Grid.LayoutTimeSizeType _sizeType;      //  layout-time user size type. it may differ from _userSizeValueCache.UnitType when calculating "to-content"
+
+        private double _minSize;                        //  used during measure to accumulate size for "Auto" and "Star" DefinitionBase's
+        private double _measureSize;                    //  size, calculated to be the input contstraint size for Child.Measure
+        private double _sizeCache;                      //  cache used for various purposes (sorting, caching, etc) during calculations
+        private double _offset;                         //  offset of the DefinitionBase from left / top corner (assuming LTR case)
+
+        private SharedSizeState _sharedState;           //  reference to shared state object this instance is registered with
+        
+        internal const bool ThisIsColumnDefinition = true;
+        internal const bool ThisIsRowDefinition = false;
+
+        #endregion Private Fields
+
+        //------------------------------------------------------
+        //
+        //  Private Structures / Classes
+        //
+        //------------------------------------------------------
+
+        #region Private Structures Classes
+
+        [System.Flags]
+        private enum Flags : byte
+        {
+            //
+            //  bool flags
+            //
+            UseSharedMinimum                    =   0x00000020,     //  when "1", definition will take into account shared state's minimum
+            LayoutWasUpdated                    =   0x00000040,     //  set to "1" every time the parent grid is measured
+        }
+
+        /// <summary>
+        /// Collection of shared states objects for a single scope
+        /// </summary>
+        internal class SharedSizeScope
+        {
+            /// <summary>
+            /// Returns SharedSizeState object for a given group.
+            /// Creates a new StatedState object if necessary.
+            /// </summary>
+            internal SharedSizeState EnsureSharedState(string sharedSizeGroup)
+            {
+                //  check that sharedSizeGroup is not default
+                Debug.Assert(sharedSizeGroup != null);
+
+                SharedSizeState sharedState = _registry[sharedSizeGroup] as SharedSizeState;
+                if (sharedState == null)
+                {
+                    sharedState = new SharedSizeState(this, sharedSizeGroup);
+                    _registry[sharedSizeGroup] = sharedState;
+                }
+                return (sharedState);
+            }
+
+            /// <summary>
+            /// Removes an entry in the registry by the given key.
+            /// </summary>
+            internal void Remove(object key)
+            {
+                Debug.Assert(_registry.Contains(key));
+                _registry.Remove(key);
+            }
+
+            private Hashtable _registry = new Hashtable();  //  storage for shared state objects
+        }
+
+        /// <summary>
+        /// Implementation of per shared group state object
+        /// </summary>
+        internal class SharedSizeState
+        {
+            /// <summary>
+            /// Default ctor.
+            /// </summary>
+            internal SharedSizeState(SharedSizeScope sharedSizeScope, string sharedSizeGroupId)
+            {
+                Debug.Assert(sharedSizeScope != null && sharedSizeGroupId != null);
+                _sharedSizeScope = sharedSizeScope;
+                _sharedSizeGroupId = sharedSizeGroupId;
+                _registry = new List<DefinitionBase>();
+                _layoutUpdated = new EventHandler(OnLayoutUpdated);
+                _broadcastInvalidation = true;
+            }
+
+            /// <summary>
+            /// Adds / registers a definition instance.
+            /// </summary>
+            internal void AddMember(DefinitionBase member)
+            {
+                Debug.Assert(!_registry.Contains(member));
+                _registry.Add(member);
+                Invalidate();
+            }
+
+            /// <summary>
+            /// Removes / un-registers a definition instance.
+            /// </summary>
+            /// <remarks>
+            /// If the collection of registered definitions becomes empty
+            /// instantiates self removal from owner's collection.
+            /// </remarks>
+            internal void RemoveMember(DefinitionBase member)
+            {
+                Invalidate();
+                _registry.Remove(member);
+
+                if (_registry.Count == 0)
+                {
+                    _sharedSizeScope.Remove(_sharedSizeGroupId);
+                }
+            }
+
+            /// <summary>
+            /// Propogates invalidations for all registered definitions.
+            /// Resets its own state.
+            /// </summary>
+            internal void Invalidate()
+            {
+                _userSizeValid = false;
+
+                if (_broadcastInvalidation)
+                {
+                    for (int i = 0, count = _registry.Count; i < count; ++i)
+                    {
+                        Grid parentGrid = (Grid)(_registry[i].Parent);
+                        parentGrid.Invalidate();
+                    }
+                    _broadcastInvalidation = false;
+                }
+            }
+
+            /// <summary>
+            /// Makes sure that one and only one layout updated handler is registered for this shared state.
+            /// </summary>
+            internal void EnsureDeferredValidation(Control layoutUpdatedHost)
+            {
+                if (_layoutUpdatedHost == null)
+                {
+                    _layoutUpdatedHost = layoutUpdatedHost;
+                    _layoutUpdatedHost.LayoutUpdated += _layoutUpdated;
+                }
+            }
+
+            /// <summary>
+            /// DefinitionBase's specific code.
+            /// </summary>
+            internal double MinSize
+            {
+                get
+                {
+                    if (!_userSizeValid) { EnsureUserSizeValid(); }
+                    return (_minSize);
+                }
+            }
+
+            /// <summary>
+            /// DefinitionBase's specific code.
+            /// </summary>
+            internal GridLength UserSize
+            {
+                get
+                {
+                    if (!_userSizeValid) { EnsureUserSizeValid(); }
+                    return (_userSize);
+                }
+            }
+
+            private void EnsureUserSizeValid()
+            {
+                _userSize = new GridLength(1, GridUnitType.Auto);
+
+                for (int i = 0, count = _registry.Count; i < count; ++i)
+                {
+                    Debug.Assert(   _userSize.GridUnitType == GridUnitType.Auto
+                                ||  _userSize.GridUnitType == GridUnitType.Pixel    );
+
+                    GridLength currentGridLength = _registry[i].UserSizeValueCache;
+                    if (currentGridLength.GridUnitType == GridUnitType.Pixel)
+                    {
+                        if (_userSize.GridUnitType == GridUnitType.Auto)
+                        {
+                            _userSize = currentGridLength;
+                        }
+                        else if (_userSize.Value < currentGridLength.Value)
+                        {
+                            _userSize = currentGridLength;
+                        }
+                    }
+                }
+                //  taking maximum with user size effectively prevents squishy-ness.
+                //  this is a "solution" to avoid shared definitions from been sized to
+                //  different final size at arrange time, if / when different grids receive
+                //  different final sizes.
+                _minSize = _userSize.IsAbsolute ? _userSize.Value : 0.0;
+
+                _userSizeValid = true;
+            }
+
+            /// <summary>
+            /// OnLayoutUpdated handler. Validates that all participating definitions
+            /// have updated min size value. Forces another layout update cycle if needed.
+            /// </summary>
+            private void OnLayoutUpdated(object sender, EventArgs e)
+            {
+                double sharedMinSize = 0;
+
+                //  accumulate min size of all participating definitions
+                for (int i = 0, count = _registry.Count; i < count; ++i)
+                {
+                    sharedMinSize = Math.Max(sharedMinSize, _registry[i].MinSize);
+                }
+
+                bool sharedMinSizeChanged = !MathUtilities.AreClose(_minSize, sharedMinSize);
+
+                //  compare accumulated min size with min sizes of the individual definitions
+                for (int i = 0, count = _registry.Count; i < count; ++i)
+                {
+                    DefinitionBase definitionBase = _registry[i];
+
+                    if (sharedMinSizeChanged ||  definitionBase.LayoutWasUpdated)
+                    {
+                        //  if definition's min size is different, then need to re-measure
+                        if (!MathUtilities.AreClose(sharedMinSize, definitionBase.MinSize))
+                        {
+                            Grid parentGrid = (Grid)definitionBase.Parent;
+                            parentGrid.InvalidateMeasure();
+                            definitionBase.UseSharedMinimum = true;
+                        }
+                        else
+                        {
+                            definitionBase.UseSharedMinimum = false;
+                            
+                            //  if measure is valid then also need to check arrange.
+                            //  Note: definitionBase.SizeCache is volatile but at this point 
+                            //  it contains up-to-date final size
+                            if (!MathUtilities.AreClose(sharedMinSize, definitionBase.SizeCache))
+                            {
+                                Grid parentGrid = (Grid)definitionBase.Parent;
+                                parentGrid.InvalidateArrange();
+                            }
+                        }
+
+                        definitionBase.LayoutWasUpdated = false;
+                    }
+                }
+
+                _minSize = sharedMinSize;
+
+                _layoutUpdatedHost.LayoutUpdated -= _layoutUpdated;
+                _layoutUpdatedHost = null;
+
+                _broadcastInvalidation = true;
+            }
+            
+            private readonly SharedSizeScope _sharedSizeScope;  //  the scope this state belongs to
+            private readonly string _sharedSizeGroupId;         //  Id of the shared size group this object is servicing
+            private readonly List<DefinitionBase> _registry;    //  registry of participating definitions
+            private readonly EventHandler _layoutUpdated;       //  instance event handler for layout updated event
+            private Control _layoutUpdatedHost;               //  Control for which layout updated event handler is registered
+            private bool _broadcastInvalidation;                //  "true" when broadcasting of invalidation is needed
+            private bool _userSizeValid;                        //  "true" when _userSize is up to date
+            private GridLength _userSize;                       //  shared state
+            private double _minSize;                            //  shared state
+        }
+
+        #endregion Private Structures Classes
+
+        //------------------------------------------------------
+        //
+        //  Properties
+        //
+        //------------------------------------------------------
+
+        #region Properties
+
+        /// <summary>
+        /// Private shared size scope property holds a collection of shared state objects for the a given shared size scope.
+        /// <see cref="OnIsSharedSizeScopePropertyChanged"/>
+        /// </summary>
+        internal static readonly AttachedProperty<SharedSizeScope> PrivateSharedSizeScopeProperty =
+            AvaloniaProperty.RegisterAttached<DefinitionBase, Control, SharedSizeScope>(
+                "PrivateSharedSizeScope",
+                defaultValue: null,
+                inherits: true);
+
+        /// <summary>
+        /// Shared size group property marks column / row definition as belonging to a group "Foo" or "Bar".
+        /// </summary>
+        /// <remarks>
+        /// Value of the Shared Size Group Property must satisfy the following rules:
+        /// <list type="bullet">
+        /// <item><description>
+        /// String must not be empty.
+        /// </description></item>
+        /// <item><description>
+        /// String must consist of letters, digits and underscore ('_') only.
+        /// </description></item>
+        /// <item><description>
+        /// String must not start with a digit.
+        /// </description></item>
+        /// </list>
+        /// </remarks> 
+        public static readonly AttachedProperty<string> SharedSizeGroupProperty =
+            AvaloniaProperty.RegisterAttached<DefinitionBase, Control, string>(
+                "SharedSizeGroup",
+                validate:SharedSizeGroupPropertyValueValid);
+
+        /// <summary>
+        /// Static ctor. Used for static registration of properties.
+        /// </summary>
+        static DefinitionBase()
+        {
+            SharedSizeGroupProperty.Changed.AddClassHandler<DefinitionBase>(OnSharedSizeGroupPropertyChanged);
+            PrivateSharedSizeScopeProperty.Changed.AddClassHandler<DefinitionBase>(OnPrivateSharedSizeScopePropertyChanged);
+        }
+
+        #endregion Properties
     }
-}
+}

src/Avalonia.Controls/DefinitionList.cs

@@ -0,0 +1,55 @@
+// 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.
+
+using System;
+using System.Collections.Specialized;
+using System.Linq;
+using Avalonia.Collections;
+
+namespace Avalonia.Controls
+{
+    public abstract class DefinitionList<T> : AvaloniaList<T> where T : DefinitionBase
+    {
+        internal bool IsDirty = true;
+        private Grid _parent;
+
+        internal Grid Parent
+        {
+            get => _parent;
+            set => SetParent(value);
+        }
+
+
+        private void SetParent(Grid value)
+        {
+            _parent = value;
+
+            foreach (var pair in this.Select((definitions, index) => (definitions, index)))
+            {
+                pair.definitions.Parent = value;
+                pair.definitions.Index = pair.index;
+            }
+        }
+
+        internal void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+        {
+            foreach (var nI in this.Select((d, i) => (d, i)))
+                nI.d._parentIndex = nI.i;
+
+            foreach (var nD in e.NewItems?.Cast<DefinitionBase>()
+                            ?? Enumerable.Empty<DefinitionBase>())
+            {
+                nD.Parent = this.Parent;
+                nD.OnEnterParentTree();
+            }
+
+            foreach (var oD in e.OldItems?.Cast<DefinitionBase>()
+                            ?? Enumerable.Empty<DefinitionBase>())
+            {
+                oD.OnExitParentTree();
+            }
+
+            IsDirty = true;
+        }
+    }
+}

src/Avalonia.Controls/MenuItem.cs

@@ -339,7 +339,7 @@ namespace Avalonia.Controls
 
             var point = e.GetPointerPoint(null);
             RaiseEvent(new PointerEventArgs(PointerEnterItemEvent, this, e.Pointer, this.VisualRoot, point.Position,
-                point.Properties, e.InputModifiers));
+                e.Timestamp, point.Properties, e.InputModifiers));
         }
 
         /// <inheritdoc/>
@@ -349,7 +349,7 @@ namespace Avalonia.Controls
 
             var point = e.GetPointerPoint(null);
             RaiseEvent(new PointerEventArgs(PointerLeaveItemEvent, this, e.Pointer, this.VisualRoot, point.Position,
-                point.Properties, e.InputModifiers));
+                e.Timestamp, point.Properties, e.InputModifiers));
         }
 
         /// <summary>

src/Avalonia.Controls/Presenters/ScrollContentPresenter.cs

@@ -2,6 +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.Disposables;
 using System.Reactive.Linq;
@@ -64,6 +65,7 @@ namespace Avalonia.Controls.Presenters
         private Vector _offset;
         private IDisposable _logicalScrollSubscription;
         private Size _viewport;
+        private Dictionary<int, Vector> _activeLogicalGestureScrolls;
 
         /// <summary>
         /// Initializes static members of the <see cref="ScrollContentPresenter"/> class.
@@ -81,6 +83,7 @@ namespace Avalonia.Controls.Presenters
         public ScrollContentPresenter()
         {
             AddHandler(RequestBringIntoViewEvent, BringIntoViewRequested);
+            AddHandler(Gestures.ScrollGestureEvent, OnScrollGesture);
 
             this.GetObservable(ChildProperty).Subscribe(UpdateScrollableSubscription);
         }
@@ -227,6 +230,72 @@ namespace Avalonia.Controls.Presenters
             return finalSize;
         }
 
+        // Arbitrary chosen value, probably need to ask ILogicalScrollable
+        private const int LogicalScrollItemSize = 50;
+        private void OnScrollGesture(object sender, ScrollGestureEventArgs e)
+        {
+            if (Extent.Height > Viewport.Height || Extent.Width > Viewport.Width)
+            {
+                var scrollable = Child as ILogicalScrollable;
+                bool isLogical = scrollable?.IsLogicalScrollEnabled == true;
+
+                double x = Offset.X;
+                double y = Offset.Y;
+
+                Vector delta = default;
+                if (isLogical)
+                    _activeLogicalGestureScrolls?.TryGetValue(e.Id, out delta);
+                delta += e.Delta;
+                
+                if (Extent.Height > Viewport.Height)
+                {
+                    double dy;
+                    if (isLogical)
+                    {
+                        var logicalUnits = delta.Y / LogicalScrollItemSize;
+                        delta = delta.WithY(delta.Y - logicalUnits * LogicalScrollItemSize);
+                        dy = logicalUnits * scrollable.ScrollSize.Height;
+                    }
+                    else
+                        dy = delta.Y;
+
+
+                    y += dy;
+                    y = Math.Max(y, 0);
+                    y = Math.Min(y, Extent.Height - Viewport.Height);
+                }
+
+                if (Extent.Width > Viewport.Width)
+                {
+                    double dx;
+                    if (isLogical)
+                    {
+                        var logicalUnits = delta.X / LogicalScrollItemSize;
+                        delta = delta.WithX(delta.X - logicalUnits * LogicalScrollItemSize);
+                        dx = logicalUnits * scrollable.ScrollSize.Width;
+                    }
+                    else
+                        dx = delta.X;
+                    x += dx;
+                    x = Math.Max(x, 0);
+                    x = Math.Min(x, Extent.Width - Viewport.Width);
+                }
+
+                if (isLogical)
+                {
+                    if (_activeLogicalGestureScrolls == null)
+                        _activeLogicalGestureScrolls = new Dictionary<int, Vector>();
+                    _activeLogicalGestureScrolls[e.Id] = delta;
+                }
+
+                Offset = new Vector(x, y);
+                e.Handled = true;
+            }
+        }
+
+        private void OnScrollGestureEnded(object sender, ScrollGestureEndedEventArgs e) 
+            => _activeLogicalGestureScrolls?.Remove(e.Id);
+
         /// <inheritdoc/>
         protected override void OnPointerWheelChanged(PointerWheelEventArgs e)
         {

src/Avalonia.Controls/Primitives/SelectingItemsControl.cs

@@ -54,7 +54,8 @@ namespace Avalonia.Controls.Primitives
                 nameof(SelectedIndex),
                 o => o.SelectedIndex,
                 (o, v) => o.SelectedIndex = v,
-                unsetValue: -1);
+                unsetValue: -1,
+                defaultBindingMode: BindingMode.TwoWay);
 
         /// <summary>
         /// Defines the <see cref="SelectedItem"/> property.

src/Avalonia.Controls/RowDefinition.cs

@@ -29,7 +29,7 @@ namespace Avalonia.Controls
         /// <summary>
         /// Initializes a new instance of the <see cref="RowDefinition"/> class.
         /// </summary>
-        public RowDefinition()
+        public RowDefinition() 
         {
         }
 
@@ -38,7 +38,7 @@ namespace Avalonia.Controls
         /// </summary>
         /// <param name="value">The height of the row.</param>
         /// <param name="type">The height unit of the column.</param>
-        public RowDefinition(double value, GridUnitType type)
+        public RowDefinition(double value, GridUnitType type) 
         {
             Height = new GridLength(value, type);
         }
@@ -47,7 +47,7 @@ namespace Avalonia.Controls
         /// Initializes a new instance of the <see cref="RowDefinition"/> class.
         /// </summary>
         /// <param name="height">The height of the column.</param>
-        public RowDefinition(GridLength height)
+        public RowDefinition(GridLength height) 
         {
             Height = height;
         }
@@ -55,11 +55,7 @@ namespace Avalonia.Controls
         /// <summary>
         /// Gets the actual calculated height of the row.
         /// </summary>
-        public double ActualHeight
-        {
-            get;
-            internal set;
-        }
+        public double ActualHeight => Parent?.GetFinalRowDefinitionHeight(Index) ?? 0d;
 
         /// <summary>
         /// Gets or sets the maximum height of the row in DIPs.
@@ -87,5 +83,9 @@ namespace Avalonia.Controls
             get { return GetValue(HeightProperty); }
             set { SetValue(HeightProperty, value); }
         }
+
+        internal override GridLength UserSizeValueCache => this.Height;
+        internal override double UserMinSizeValueCache => this.MinHeight;
+        internal override double UserMaxSizeValueCache => this.MaxHeight;
     }
 }

src/Avalonia.Controls/RowDefinitions.cs

@@ -9,7 +9,7 @@ namespace Avalonia.Controls
     /// <summary>
     /// A collection of <see cref="RowDefinition"/>s.
     /// </summary>
-    public class RowDefinitions : AvaloniaList<RowDefinition>
+    public class RowDefinitions : DefinitionList<RowDefinition>
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="RowDefinitions"/> class.
@@ -17,6 +17,7 @@ namespace Avalonia.Controls
         public RowDefinitions()
         {
             ResetBehavior = ResetBehavior.Remove;
+            CollectionChanged += OnCollectionChanged;
         }
 
         /// <summary>

src/Avalonia.Controls/TabControl.cs

@@ -1,6 +1,7 @@
 // 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.
 
+using System.Linq;
 using Avalonia.Controls.Generators;
 using Avalonia.Controls.Mixins;
 using Avalonia.Controls.Presenters;
@@ -8,6 +9,7 @@ using Avalonia.Controls.Primitives;
 using Avalonia.Controls.Templates;
 using Avalonia.Input;
 using Avalonia.Layout;
+using Avalonia.VisualTree;
 
 namespace Avalonia.Controls
 {
@@ -166,10 +168,24 @@ namespace Avalonia.Controls
         {
             base.OnPointerPressed(e);
 
-            if (e.MouseButton == MouseButton.Left)
+            if (e.MouseButton == MouseButton.Left && e.Pointer.Type == PointerType.Mouse)
             {
                 e.Handled = UpdateSelectionFromEventSource(e.Source);
             }
         }
+
+        protected override void OnPointerReleased(PointerReleasedEventArgs e)
+        {
+            if (e.MouseButton == MouseButton.Left && e.Pointer.Type != PointerType.Mouse)
+            {
+                var container = GetContainerFromEventSource(e.Source);
+                if (container != null
+                    && container.GetVisualsAt(e.GetPosition(container))
+                        .Any(c => container == c || container.IsVisualAncestorOf(c)))
+                {
+                    e.Handled = UpdateSelectionFromEventSource(e.Source);
+                }
+            }
+        }
     }
 }

src/Avalonia.Controls/Utils/GridLayout.cs

@@ -1,705 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Globalization;
-using System.Linq;
-using System.Runtime.CompilerServices;
-using Avalonia.Layout;
-using JetBrains.Annotations;
-
-namespace Avalonia.Controls.Utils
-{
-    /// <summary>
-    /// Contains algorithms that can help to measure and arrange a Grid.
-    /// </summary>
-    internal class GridLayout
-    {
-        /// <summary>
-        /// Initialize a new <see cref="GridLayout"/> instance from the column definitions.
-        /// The instance doesn't care about whether the definitions are rows or columns.
-        /// It will not calculate the column or row differently.
-        /// </summary>
-        internal GridLayout([NotNull] ColumnDefinitions columns)
-        {
-            if (columns == null) throw new ArgumentNullException(nameof(columns));
-            _conventions = columns.Count == 0
-                ? new List<LengthConvention> { new LengthConvention() }
-                : columns.Select(x => new LengthConvention(x.Width, x.MinWidth, x.MaxWidth)).ToList();
-        }
-
-        /// <summary>
-        /// Initialize a new <see cref="GridLayout"/> instance from the row definitions.
-        /// The instance doesn't care about whether the definitions are rows or columns.
-        /// It will not calculate the column or row differently.
-        /// </summary>
-        internal GridLayout([NotNull] RowDefinitions rows)
-        {
-            if (rows == null) throw new ArgumentNullException(nameof(rows));
-            _conventions = rows.Count == 0
-                ? new List<LengthConvention> { new LengthConvention() }
-                : rows.Select(x => new LengthConvention(x.Height, x.MinHeight, x.MaxHeight)).ToList();
-        }
-
-        /// <summary>
-        /// Gets the layout tolerance. If any length offset is less than this value, we will treat them the same.
-        /// </summary>
-        private const double LayoutTolerance = 1.0 / 256.0;
-
-        /// <summary>
-        /// Gets all the length conventions that come from column/row definitions.
-        /// These conventions provide cell limitations, such as the expected pixel length, the min/max pixel length and the * count.
-        /// </summary>
-        [NotNull]
-        private readonly List<LengthConvention> _conventions;
-
-        /// <summary>
-        /// Gets all the length conventions that come from the grid children.
-        /// </summary>
-        [NotNull]
-        private readonly List<AdditionalLengthConvention> _additionalConventions =
-            new List<AdditionalLengthConvention>();
-
-        /// <summary>
-        /// Appending these elements into the convention list helps lay them out according to their desired sizes.
-        /// <para/>
-        /// Some elements are not only in a single grid cell, they have one or more column/row spans,
-        /// and these elements may affect the grid layout especially the measuring procedure.<para/>
-        /// Append these elements into the convention list can help to layout them correctly through
-        /// their desired size. Only a small subset of children need to be measured before layout starts
-        /// and they will be called via the<paramref name="getDesiredLength"/> callback.
-        /// </summary>
-        /// <typeparam name="T">The grid children type.</typeparam>
-        /// <param name="source">
-        /// Contains the safe column/row index and its span.
-        /// Notice that we will not verify whether the range is in the column/row count,
-        /// so you should get the safe column/row info first.
-        /// </param>
-        /// <param name="getDesiredLength">
-        /// This callback will be called if the <see cref="GridLayout"/> thinks that a child should be
-        /// measured first. Usually, these are the children that have the * or Auto length.
-        /// </param>
-        internal void AppendMeasureConventions<T>([NotNull] IDictionary<T, (int index, int span)> source,
-            [NotNull] Func<T, double> getDesiredLength)
-        {
-            if (source == null) throw new ArgumentNullException(nameof(source));
-            if (getDesiredLength == null) throw new ArgumentNullException(nameof(getDesiredLength));
-
-            // M1/7. Find all the Auto and * length columns/rows. (M1/7 means the 1st procedure of measurement.)
-            // Only these columns/rows' layout can be affected by the child desired size.
-            // 
-            // Find all columns/rows that have Auto or * length. We'll measure the children in advance.
-            // Only these kind of columns/rows will affect the Grid layout.
-            // Please note:
-            // - If the column / row has Auto length, the Grid.DesiredSize and the column width
-            //   will be affected by the child's desired size.
-            // - If the column / row has* length, the Grid.DesiredSize will be affected by the
-            //   child's desired size but the column width not.
-
-            //               +-----------------------------------------------------------+
-            //               |  *  |  A  |  *  |  P  |  A  |  *  |  P  |     *     |  *  |
-            //               +-----------------------------------------------------------+
-            // _conventions: | min | max |     |           | min |     |  min max  | max |
-            // _additionalC:                   |<-   desired   ->|     |< desired >|
-            // _additionalC:       |< desired >|           |<-        desired          ->|
-
-            // 寻找所有行列范围中包含 Auto 和 * 的元素，使用全部可用尺寸提前测量。
-            // 因为只有这部分元素的布局才会被 Grid 的子元素尺寸影响。
-            // 请注意：
-            // - Auto 长度的行列必定会受到子元素布局影响，会影响到行列的布局长度和 Grid 本身的 DesiredSize；
-            // - 而对于 * 长度，只有 Grid.DesiredSize 会受到子元素布局影响，而行列长度不会受影响。
-
-            // Find all the Auto and * length columns/rows.
-            var found = new Dictionary<T, (int index, int span)>();
-            for (var i = 0; i < _conventions.Count; i++)
-            {
-                var index = i;
-                var convention = _conventions[index];
-                if (convention.Length.IsAuto || convention.Length.IsStar)
-                {
-                    foreach (var pair in source.Where(x =>
-                        x.Value.index <= index && index < x.Value.index + x.Value.span))
-                    {
-                        found[pair.Key] = pair.Value;
-                    }
-                }
-            }
-
-            // Append these layout into the additional convention list.
-            foreach (var pair in found)
-            {
-                var t = pair.Key;
-                var (index, span) = pair.Value;
-                var desiredLength = getDesiredLength(t);
-                if (Math.Abs(desiredLength) > LayoutTolerance)
-                {
-                    _additionalConventions.Add(new AdditionalLengthConvention(index, span, desiredLength));
-                }
-            }
-        }
-
-        /// <summary>
-        /// Run measure procedure according to the <paramref name="containerLength"/> and gets the <see cref="MeasureResult"/>.
-        /// </summary>
-        /// <param name="containerLength">
-        /// The container length. Usually, it is the constraint of the <see cref="Layoutable.MeasureOverride"/> method.
-        /// </param>
-        /// <param name="conventions">
-        /// Overriding conventions that allows the algorithm to handle external inputa 
-        /// </param>
-        /// <returns>
-        /// The measured result that containing the desired size and all the column/row lengths.
-        /// </returns>
-        [NotNull, Pure]
-        internal MeasureResult Measure(double containerLength, IReadOnlyList<LengthConvention> conventions = null)
-        {
-            // Prepare all the variables that this method needs to use.
-            conventions = conventions ?? _conventions.Select(x => x.Clone()).ToList();
-            var starCount = conventions.Where(x => x.Length.IsStar).Sum(x => x.Length.Value);
-            var aggregatedLength = 0.0;
-            double starUnitLength;
-
-            // M2/7. Aggregate all the pixel lengths. Then we can get the remaining length by `containerLength - aggregatedLength`.
-            // We mark the aggregated length as "fix" because we can completely determine their values. Same as below.
-            //
-            // +-----------------------------------------------------------+
-            // |  *  |  A  |  *  |  P  |  A  |  *  |  P  |     *     |  *  |
-            // +-----------------------------------------------------------+
-            //                   |#fix#|           |#fix#|
-            //
-            // 将全部的固定像素长度的行列长度累加。这样，containerLength - aggregatedLength 便能得到剩余长度。
-            // 我们会将所有能够确定下长度的行列标记为 fix。下同。
-            // 请注意：
-            // - 我们并没有直接从 containerLength 一直减下去，而是使用 aggregatedLength 进行累加，是因为无穷大相减得到的是 NaN，不利于后续计算。
-
-            aggregatedLength += conventions.Where(x => x.Length.IsAbsolute).Sum(x => x.Length.Value);
-
-            // M3/7. Fix all the * lengths that have reached the minimum.
-            //
-            // +-----------------------------------------------------------+
-            // |  *  |  A  |  *  |  P  |  A  |  *  |  P  |     *     |  *  |
-            // +-----------------------------------------------------------+
-            // | min | max |     |           | min |     |  min max  | max |
-            //                   | fix |     |#fix#| fix |
-
-            var shouldTestStarMin = true;
-            while (shouldTestStarMin)
-            {
-                // Calculate the unit * length to estimate the length of each column/row that has * length.
-                // Under this estimated length, check if there is a minimum value that has a length less than its constraint.
-                // If there is such a *, then fix the size of this cell, and then loop it again until there is no * that can be constrained by the minimum value.
-                //
-                // 计算单位 * 的长度，以便预估出每一个 * 行列的长度。
-                // 在此预估的长度下，从前往后寻找是否存在某个 * 长度已经小于其约束的最小值。
-                // 如果发现存在这样的 *，那么将此单元格的尺寸固定下来（Fix），然后循环重来，直至再也没有能被最小值约束的 *。
-                var @fixed = false;
-                starUnitLength = (containerLength - aggregatedLength) / starCount;
-                foreach (var convention in conventions.Where(x => x.Length.IsStar))
-                {
-                    var (star, min) = (convention.Length.Value, convention.MinLength);
-                    var starLength = star * starUnitLength;
-                    if (starLength < min)
-                    {
-                        convention.Fix(min);
-                        starLength = min;
-                        aggregatedLength += starLength;
-                        starCount -= star;
-                        @fixed = true;
-                        break;
-                    }
-                }
-
-                shouldTestStarMin = @fixed;
-            }
-
-            // M4/7. Determine the absolute pixel size of all columns/rows that have an Auto length.
-            //
-            // +-----------------------------------------------------------+
-            // |  *  |  A  |  *  |  P  |  A  |  *  |  P  |     *     |  *  |
-            // +-----------------------------------------------------------+
-            // | min | max |     |           | min |     |  min max  | max |
-            //       |#fix#|     | fix |#fix#| fix | fix |
-
-            var shouldTestAuto = true;
-            while (shouldTestAuto)
-            {
-                var @fixed = false;
-                starUnitLength = (containerLength - aggregatedLength) / starCount;
-                for (var i = 0; i < conventions.Count; i++)
-                {
-                    var convention = conventions[i];
-                    if (!convention.Length.IsAuto)
-                    {
-                        continue;
-                    }
-
-                    var more = ApplyAdditionalConventionsForAuto(conventions, i, starUnitLength);
-                    convention.Fix(more);
-                    aggregatedLength += more;
-                    @fixed = true;
-                    break;
-                }
-
-                shouldTestAuto = @fixed;
-            }
-
-            // M5/7. Expand the stars according to the additional conventions (usually the child desired length).
-            // We can't fix this kind of length, so we just mark them as desired (des).
-            //
-            // +-----------------------------------------------------------+
-            // |  *  |  A  |  *  |  P  |  A  |  *  |  P  |     *     |  *  |
-            // +-----------------------------------------------------------+
-            // | min | max |     |           | min |     |  min max  | max |
-            // |#des#| fix |#des#| fix | fix | fix | fix |   #des#   |#des#|
-
-            var (minLengths, desiredStarMin) = AggregateAdditionalConventionsForStars(conventions);
-            aggregatedLength += desiredStarMin;
-
-            // M6/7. Determine the desired length of the grid for current container length. Its value is stored in desiredLength.
-            // Assume if the container has infinite length, the grid desired length is stored in greedyDesiredLength.
-            //
-            // +-----------------------------------------------------------+
-            // |  *  |  A  |  *  |  P  |  A  |  *  |  P  |     *     |  *  |
-            // +-----------------------------------------------------------+
-            // | min | max |     |           | min |     |  min max  | max |
-            // |#des#| fix |#des#| fix | fix | fix | fix |   #des#   |#des#|
-            // Note: This table will be stored as the intermediate result into the MeasureResult and it will be reused by Arrange procedure.
-            // 
-            // desiredLength = Math.Max(0.0, des + fix + des + fix + fix + fix + fix + des + des)
-            // greedyDesiredLength = des + fix + des + fix + fix + fix + fix + des + des
-
-            var desiredLength = containerLength - aggregatedLength >= 0.0 ? aggregatedLength : containerLength;
-            var greedyDesiredLength = aggregatedLength;
-
-            // M7/7. Expand all the rest stars. These stars have no conventions or only have
-            // max value they can be expanded from zero to constraint.
-            //
-            // +-----------------------------------------------------------+
-            // |  *  |  A  |  *  |  P  |  A  |  *  |  P  |     *     |  *  |
-            // +-----------------------------------------------------------+
-            // | min | max |     |           | min |     |  min max  | max |
-            // |#fix#| fix |#fix#| fix | fix | fix | fix |   #fix#   |#fix#|
-            // Note: This table will be stored as the final result into the MeasureResult.
-
-            var dynamicConvention = ExpandStars(conventions, containerLength);
-            Clip(dynamicConvention, containerLength);
-
-            // Returns the measuring result.
-            return new MeasureResult(containerLength, desiredLength, greedyDesiredLength,
-                conventions, dynamicConvention, minLengths);
-        }
-
-        /// <summary>
-        /// Run arrange procedure according to the <paramref name="measure"/> and gets the <see cref="ArrangeResult"/>.
-        /// </summary>
-        /// <param name="finalLength">
-        /// The container length. Usually, it is the finalSize of the <see cref="Layoutable.ArrangeOverride"/> method.
-        /// </param>
-        /// <param name="measure">
-        /// The result that the measuring procedure returns. If it is null, a new measure procedure will run.
-        /// </param>
-        /// <returns>
-        /// The measured result that containing the desired size and all the column/row length.
-        /// </returns>
-        [NotNull, Pure]
-        public ArrangeResult Arrange(double finalLength, [CanBeNull] MeasureResult measure)
-        {
-            measure = measure ?? Measure(finalLength);
-
-            // If the arrange final length does not equal to the measure length, we should measure again.
-            if (finalLength - measure.ContainerLength > LayoutTolerance)
-            {
-                // If the final length is larger, we will rerun the whole measure.
-                measure = Measure(finalLength, measure.LeanLengthList);
-            }
-            else if (finalLength - measure.ContainerLength < -LayoutTolerance)
-            {
-                // If the final length is smaller, we measure the M6/6 procedure only.
-                var dynamicConvention = ExpandStars(measure.LeanLengthList, finalLength);
-                measure = new MeasureResult(finalLength, measure.DesiredLength, measure.GreedyDesiredLength,
-                    measure.LeanLengthList, dynamicConvention, measure.MinLengths);
-            }
-
-            return new ArrangeResult(measure.LengthList);
-        }
-
-        /// <summary>
-        /// Use the <see cref="_additionalConventions"/> to calculate the fixed length of the Auto column/row.
-        /// </summary>
-        /// <param name="conventions">The convention list that all the * with minimum length are fixed.</param>
-        /// <param name="index">The column/row index that should be fixed.</param>
-        /// <param name="starUnitLength">The unit * length for the current rest length.</param>
-        /// <returns>The final length of the Auto length column/row.</returns>
-        [Pure]
-        private double ApplyAdditionalConventionsForAuto(IReadOnlyList<LengthConvention> conventions,
-            int index, double starUnitLength)
-        {
-            // 1. Calculate all the * length with starUnitLength.
-            // 2. Exclude all the fixed length and all the * length.
-            // 3. Compare the rest of the desired length and the convention.
-            // +-----------------+
-            // |  *  |  A  |  *  |
-            // +-----------------+
-            // | exl |     | exl |
-            // |< desired >|
-            //       |< desired >|
-
-            var more = 0.0;
-            foreach (var additional in _additionalConventions)
-            {
-                // If the additional convention's last column/row contains the Auto column/row, try to determine the Auto column/row length.
-                if (index == additional.Index + additional.Span - 1)
-                {
-                    var min = Enumerable.Range(additional.Index, additional.Span)
-                        .Select(x =>
-                        {
-                            var c = conventions[x];
-                            if (c.Length.IsAbsolute) return c.Length.Value;
-                            if (c.Length.IsStar) return c.Length.Value * starUnitLength;
-                            return 0.0;
-                        }).Sum();
-                    more = Math.Max(additional.Min - min, more);
-                }
-            }
-
-            return Math.Min(conventions[index].MaxLength, more);
-        }
-
-        /// <summary>
-        /// Calculate the total desired length of all the * length.
-        /// Bug Warning:
-        /// - The behavior of this method is undefined! Different UI Frameworks have different behaviors.
-        /// - We ignore all the span columns/rows and just take single cells into consideration.
-        /// </summary>
-        /// <param name="conventions">All the conventions that have almost been fixed except the rest *.</param>
-        /// <returns>The total desired length of all the * length.</returns>
-        [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private (List<double>, double) AggregateAdditionalConventionsForStars(
-            IReadOnlyList<LengthConvention> conventions)
-        {
-            // 1. Determine all one-span column's desired widths or row's desired heights.
-            // 2. Order the multi-span conventions by its last index
-            //    (Notice that the sorted data is much smaller than the source.)
-            // 3. Determine each multi-span last index by calculating the maximum desired size.
-
-            // Before we determine the behavior of this method, we just aggregate the one-span * columns.
-
-            var fixedLength = conventions.Where(x => x.Length.IsAbsolute).Sum(x => x.Length.Value);
-
-            // Prepare a lengthList variable indicating the fixed length of each column/row.
-            var lengthList = conventions.Select(x => x.Length.IsAbsolute ? x.Length.Value : 0.0).ToList();
-            foreach (var group in _additionalConventions
-                .Where(x => x.Span == 1 && conventions[x.Index].Length.IsStar)
-                .ToLookup(x => x.Index))
-            {
-                lengthList[group.Key] = Math.Max(lengthList[group.Key], group.Max(x => x.Min));
-            }
-
-            // Now the lengthList is fixed by every one-span columns/rows.
-            // Then we should determine the multi-span column's/row's length.
-            foreach (var group in _additionalConventions
-                .Where(x => x.Span > 1)
-                .ToLookup(x => x.Index + x.Span - 1)
-                // Order the multi-span columns/rows by last index.
-                .OrderBy(x => x.Key))
-            {
-                var length = group.Max(x => x.Min - Enumerable.Range(x.Index, x.Span - 1).Sum(r => lengthList[r]));
-                lengthList[group.Key] = Math.Max(lengthList[group.Key], length > 0 ? length : 0);
-            }
-
-            return (lengthList, lengthList.Sum() - fixedLength);
-        }
-
-        /// <summary>
-        /// This method implements the last procedure (M7/7) of measure.
-        /// It expands all the * length to the fixed length according to the <paramref name="constraint"/>.
-        /// </summary>
-        /// <param name="conventions">All the conventions that have almost been fixed except the remaining *.</param>
-        /// <param name="constraint">The container length.</param>
-        /// <returns>The final pixel length list.</returns>
-        [Pure]
-        private static List<double> ExpandStars(IEnumerable<LengthConvention> conventions, double constraint)
-        {
-            // Initial.
-            var dynamicConvention = conventions.Select(x => x.Clone()).ToList();
-            constraint -= dynamicConvention.Where(x => x.Length.IsAbsolute).Sum(x => x.Length.Value);
-            var starUnitLength = 0.0;
-
-            // M6/6.
-            if (constraint >= 0)
-            {
-                var starCount = dynamicConvention.Where(x => x.Length.IsStar).Sum(x => x.Length.Value);
-
-                var shouldTestStarMax = true;
-                while (shouldTestStarMax)
-                {
-                    var @fixed = false;
-                    starUnitLength = constraint / starCount;
-                    foreach (var convention in dynamicConvention.Where(x =>
-                        x.Length.IsStar && !double.IsPositiveInfinity(x.MaxLength)))
-                    {
-                        var (star, max) = (convention.Length.Value, convention.MaxLength);
-                        var starLength = star * starUnitLength;
-                        if (starLength > max)
-                        {
-                            convention.Fix(max);
-                            starLength = max;
-                            constraint -= starLength;
-                            starCount -= star;
-                            @fixed = true;
-                            break;
-                        }
-                    }
-
-                    shouldTestStarMax = @fixed;
-                }
-            }
-
-            Debug.Assert(dynamicConvention.All(x => !x.Length.IsAuto));
-
-            var starUnit = starUnitLength;
-            var result = dynamicConvention.Select(x =>
-            {
-                if (x.Length.IsStar)
-                {
-                    return double.IsInfinity(starUnit) ? double.PositiveInfinity : starUnit * x.Length.Value;
-                }
-
-                return x.Length.Value;
-            }).ToList();
-
-            return result;
-        }
-
-        /// <summary>
-        /// If the container length is not infinity. It may be not enough to contain all the columns/rows.
-        /// We should clip the columns/rows that have been out of the container bounds.
-        /// Note: This method may change the items value of <paramref name="lengthList"/>.
-        /// </summary>
-        /// <param name="lengthList">A list of all the column widths and row heights with a fixed pixel length</param>
-        /// <param name="constraint">the container length. It can be positive infinity.</param>
-        private static void Clip([NotNull] IList<double> lengthList, double constraint)
-        {
-            if (double.IsInfinity(constraint))
-            {
-                return;
-            }
-
-            var measureLength = 0.0;
-            for (var i = 0; i < lengthList.Count; i++)
-            {
-                var length = lengthList[i];
-                if (constraint - measureLength > length)
-                {
-                    measureLength += length;
-                }
-                else
-                {
-                    lengthList[i] = constraint - measureLength;
-                    measureLength = constraint;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Contains the convention of each column/row.
-        /// This is mostly the same as <see cref="RowDefinition"/> or <see cref="ColumnDefinition"/>.
-        /// We use this because we can treat the column and the row the same.
-        /// </summary>
-        [DebuggerDisplay("{" + nameof(DebuggerDisplay) + ",nq}")]
-        internal class LengthConvention : ICloneable
-        {
-            /// <summary>
-            /// Initialize a new instance of <see cref="LengthConvention"/>.
-            /// </summary>
-            public LengthConvention()
-            {
-                Length = new GridLength(1.0, GridUnitType.Star);
-                MinLength = 0.0;
-                MaxLength = double.PositiveInfinity;
-            }
-
-            /// <summary>
-            /// Initialize a new instance of <see cref="LengthConvention"/>.
-            /// </summary>
-            public LengthConvention(GridLength length, double minLength, double maxLength)
-            {
-                Length = length;
-                MinLength = minLength;
-                MaxLength = maxLength;
-                if (length.IsAbsolute)
-                {
-                    _isFixed = true;
-                }
-            }
-
-            /// <summary>
-            /// Gets the <see cref="GridLength"/> of a column or a row.
-            /// </summary>
-            internal GridLength Length { get; private set; }
-
-            /// <summary>
-            /// Gets the minimum convention for a column or a row.
-            /// </summary>
-            internal double MinLength { get; }
-
-            /// <summary>
-            /// Gets the maximum convention for a column or a row.
-            /// </summary>
-            internal double MaxLength { get; }
-
-            /// <summary>
-            /// Fix the <see cref="LengthConvention"/>.
-            /// If all columns/rows are fixed, we can get the size of all columns/rows in pixels.
-            /// </summary>
-            /// <param name="pixel">
-            /// The pixel length that should be used to fix the convention.
-            /// </param>
-            /// <exception cref="InvalidOperationException">
-            /// If the convention is pixel length, this exception will throw.
-            /// </exception>
-            public void Fix(double pixel)
-            {
-                if (_isFixed)
-                {
-                    throw new InvalidOperationException("Cannot fix the length convention if it is fixed.");
-                }
-
-                Length = new GridLength(pixel);
-                _isFixed = true;
-            }
-
-            /// <summary>
-            /// Gets a value that indicates whether this convention is fixed.
-            /// </summary>
-            private bool _isFixed;
-
-            /// <summary>
-            /// Helps the debugger to display the intermediate column/row calculation result.
-            /// </summary>
-            private string DebuggerDisplay =>
-                $"{(_isFixed ? Length.Value.ToString(CultureInfo.InvariantCulture) : (Length.GridUnitType == GridUnitType.Auto ? "Auto" : $"{Length.Value}*"))}, ∈[{MinLength}, {MaxLength}]";
-
-            /// <inheritdoc />
-            object ICloneable.Clone() => Clone();
-
-            /// <summary>
-            /// Get a deep copy of this convention list.
-            /// We need this because we want to store some intermediate states.
-            /// </summary>
-            internal LengthConvention Clone() => new LengthConvention(Length, MinLength, MaxLength);
-        }
-
-        /// <summary>
-        /// Contains the convention that comes from the grid children.
-        /// Some children span multiple columns or rows, so even a simple column/row can have multiple conventions.
-        /// </summary>
-        [DebuggerDisplay("{" + nameof(DebuggerDisplay) + ",nq}")]
-        internal struct AdditionalLengthConvention
-        {
-            /// <summary>
-            /// Initialize a new instance of <see cref="AdditionalLengthConvention"/>.
-            /// </summary>
-            public AdditionalLengthConvention(int index, int span, double min)
-            {
-                Index = index;
-                Span = span;
-                Min = min;
-            }
-
-            /// <summary>
-            /// Gets the start index of this additional convention.
-            /// </summary>
-            public int Index { get; }
-
-            /// <summary>
-            /// Gets the span of this additional convention.
-            /// </summary>
-            public int Span { get; }
-
-            /// <summary>
-            /// Gets the minimum length of this additional convention.
-            /// This value is usually provided by the child's desired length.
-            /// </summary>
-            public double Min { get; }
-
-            /// <summary>
-            /// Helps the debugger to display the intermediate column/row calculation result.
-            /// </summary>
-            private string DebuggerDisplay =>
-                $"{{{string.Join(",", Enumerable.Range(Index, Span))}}}, ∈[{Min},∞)";
-        }
-
-        /// <summary>
-        /// Stores the result of the measuring procedure.
-        /// This result can be used to measure children and assign the desired size.
-        /// Passing this result to <see cref="Arrange"/> can reduce calculation.
-        /// </summary>
-        [DebuggerDisplay("{" + nameof(LengthList) + ",nq}")]
-        internal class MeasureResult
-        {
-            /// <summary>
-            /// Initialize a new instance of <see cref="MeasureResult"/>.
-            /// </summary>
-            internal MeasureResult(double containerLength, double desiredLength, double greedyDesiredLength,
-                IReadOnlyList<LengthConvention> leanConventions, IReadOnlyList<double> expandedConventions, IReadOnlyList<double> minLengths)
-            {
-                ContainerLength = containerLength;
-                DesiredLength = desiredLength;
-                GreedyDesiredLength = greedyDesiredLength;
-                LeanLengthList = leanConventions;
-                LengthList = expandedConventions;
-                MinLengths = minLengths;
-            }
-
-            /// <summary>
-            /// Gets the container length for this result.
-            /// This property will be used by <see cref="Arrange"/> to determine whether to measure again or not.
-            /// </summary>
-            public double ContainerLength { get; }
-
-            /// <summary>
-            /// Gets the desired length of this result.
-            /// Just return this value as the desired size in <see cref="Layoutable.MeasureOverride"/>.
-            /// </summary>
-            public double DesiredLength { get; }
-
-            /// <summary>
-            /// Gets the desired length if the container has infinite length.
-            /// </summary>
-            public double GreedyDesiredLength { get; }
-
-            /// <summary>
-            /// Contains the column/row calculation intermediate result.
-            /// This value is used by <see cref="Arrange"/> for reducing repeat calculation.
-            /// </summary>
-            public IReadOnlyList<LengthConvention> LeanLengthList { get; }
-
-            /// <summary>
-            /// Gets the length list for each column/row.
-            /// </summary>
-            public IReadOnlyList<double> LengthList { get; }
-            public IReadOnlyList<double> MinLengths { get; }
-        }
-
-        /// <summary>
-        /// Stores the result of the measuring procedure.
-        /// This result can be used to arrange children and assign the render size.
-        /// </summary>
-        [DebuggerDisplay("{" + nameof(LengthList) + ",nq}")]
-        internal class ArrangeResult
-        {
-            /// <summary>
-            /// Initialize a new instance of <see cref="ArrangeResult"/>.
-            /// </summary>
-            internal ArrangeResult(IReadOnlyList<double> lengthList)
-            {
-                LengthList = lengthList;
-            }
-
-            /// <summary>
-            /// Gets the length list for each column/row.
-            /// </summary>
-            public IReadOnlyList<double> LengthList { get; }
-        }
-    }
-}

src/Avalonia.Controls/Utils/SharedSizeScopeHost.cs

@@ -1,651 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Collections.Specialized;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Linq;
-using System.Reactive.Disposables;
-using System.Reactive.Subjects;
-using Avalonia.Collections;
-using Avalonia.Controls.Utils;
-using Avalonia.Layout;
-using Avalonia.VisualTree;
-
-namespace Avalonia.Controls
-{
-    /// <summary>
-    /// Shared size scope implementation.
-    /// Shares the size information between participating grids.
-    /// An instance of this class is attached to every <see cref="Control"/> that has its
-    /// IsSharedSizeScope property set to true.
-    /// </summary>
-    internal sealed class SharedSizeScopeHost : IDisposable
-    {
-        private enum MeasurementState
-        {
-            Invalidated,
-            Measuring,
-            Cached
-        }
-
-        /// <summary>
-        /// Class containing the measured rows/columns for a single grid.
-        /// Monitors changes to the row/column collections as well as the SharedSizeGroup changes
-        /// for the individual items in those collections.
-        /// Notifies the <see cref="SharedSizeScopeHost"/> of SharedSizeGroup changes.
-        /// </summary>
-        private sealed class MeasurementCache : IDisposable
-        {
-            readonly CompositeDisposable _subscriptions;
-            readonly Subject<(string, string, MeasurementResult)> _groupChanged = new Subject<(string, string, MeasurementResult)>();
-
-            public ISubject<(string oldName, string newName, MeasurementResult result)> GroupChanged => _groupChanged;
-
-            public MeasurementCache(Grid grid)
-            {
-                Grid = grid;
-                Results = grid.RowDefinitions.Cast<DefinitionBase>()
-                    .Concat(grid.ColumnDefinitions)
-                    .Select(d => new MeasurementResult(grid, d))
-                    .ToList();
-
-                grid.RowDefinitions.CollectionChanged += DefinitionsCollectionChanged;
-                grid.ColumnDefinitions.CollectionChanged += DefinitionsCollectionChanged;
-
-
-                _subscriptions = new CompositeDisposable(
-                    Disposable.Create(() => grid.RowDefinitions.CollectionChanged -= DefinitionsCollectionChanged),
-                    Disposable.Create(() => grid.ColumnDefinitions.CollectionChanged -= DefinitionsCollectionChanged),
-                    grid.RowDefinitions.TrackItemPropertyChanged(DefinitionPropertyChanged),
-                    grid.ColumnDefinitions.TrackItemPropertyChanged(DefinitionPropertyChanged));
-
-            }
-
-            // method to be hooked up once RowDefinitions/ColumnDefinitions collections can be replaced on a grid
-            private void DefinitionsChanged(object sender, AvaloniaPropertyChangedEventArgs e)
-            {
-                // route to collection changed as a Reset.
-                DefinitionsCollectionChanged(null, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
-            }
-
-            private void DefinitionPropertyChanged(Tuple<object, PropertyChangedEventArgs> propertyChanged)
-            {
-                if (propertyChanged.Item2.PropertyName == nameof(DefinitionBase.SharedSizeGroup))
-                {
-                    var result = Results.Single(mr => ReferenceEquals(mr.Definition, propertyChanged.Item1));
-                    var oldName = result.SizeGroup?.Name;
-                    var newName = (propertyChanged.Item1 as DefinitionBase).SharedSizeGroup;
-                    _groupChanged.OnNext((oldName, newName, result));
-                }
-            }
-
-            private void DefinitionsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
-            {
-                int offset = 0;
-                if (sender is ColumnDefinitions)
-                    offset = Grid.RowDefinitions.Count;
-
-                var newItems = e.NewItems?.OfType<DefinitionBase>().Select(db => new MeasurementResult(Grid, db)).ToList() ?? new List<MeasurementResult>();
-                var oldItems = e.OldStartingIndex >= 0 
-                                    ? Results.GetRange(e.OldStartingIndex + offset, e.OldItems.Count) 
-                                    : new List<MeasurementResult>();
-
-                void NotifyNewItems()
-                {
-                    foreach (var item in newItems)
-                    {
-                        if (string.IsNullOrEmpty(item.Definition.SharedSizeGroup))
-                            continue;
-
-                        _groupChanged.OnNext((null, item.Definition.SharedSizeGroup, item));
-                    }
-                }
-
-                void NotifyOldItems()
-                {
-                    foreach (var item in oldItems)
-                    {
-                        if (string.IsNullOrEmpty(item.Definition.SharedSizeGroup))
-                            continue;
-
-                        _groupChanged.OnNext((item.Definition.SharedSizeGroup, null, item));
-                    }
-                }
-
-                switch (e.Action)
-                {
-                    case NotifyCollectionChangedAction.Add:
-                        Results.InsertRange(e.NewStartingIndex + offset, newItems);
-                        NotifyNewItems();
-                        break;
-
-                    case NotifyCollectionChangedAction.Remove:
-                        Results.RemoveRange(e.OldStartingIndex + offset, oldItems.Count);
-                        NotifyOldItems();
-                        break;
-
-                    case NotifyCollectionChangedAction.Move:
-                        Results.RemoveRange(e.OldStartingIndex + offset, oldItems.Count);
-                        Results.InsertRange(e.NewStartingIndex + offset, oldItems);
-                        break;
-
-                    case NotifyCollectionChangedAction.Replace:
-                        Results.RemoveRange(e.OldStartingIndex + offset, oldItems.Count);
-                        Results.InsertRange(e.NewStartingIndex + offset, newItems);
-
-                        NotifyOldItems();
-                        NotifyNewItems();
-
-                        break;
-
-                    case NotifyCollectionChangedAction.Reset:
-                        oldItems = Results;
-                        newItems = Results = Grid.RowDefinitions.Cast<DefinitionBase>()
-                            .Concat(Grid.ColumnDefinitions)
-                            .Select(d => new MeasurementResult(Grid, d))
-                            .ToList();
-                        NotifyOldItems();
-                        NotifyNewItems();
-
-                        break;
-                }
-            }
-
-
-            /// <summary>
-            /// Updates the Results collection with Grid Measure results. 
-            /// </summary>
-            /// <param name="rowResult">Result of the GridLayout.Measure method for the RowDefinitions in the grid.</param>
-            /// <param name="columnResult">Result of the GridLayout.Measure method for the ColumnDefinitions in the grid.</param>
-            public void UpdateMeasureResult(GridLayout.MeasureResult rowResult, GridLayout.MeasureResult columnResult)
-            {
-                MeasurementState = MeasurementState.Cached;
-                for (int i = 0; i < Grid.RowDefinitions.Count; i++)
-                {
-                    Results[i].MeasuredResult = rowResult.LengthList[i];
-                    Results[i].MinLength = rowResult.MinLengths[i];
-                }
-
-                for (int i = 0; i < Grid.ColumnDefinitions.Count; i++)
-                {
-                    Results[i + Grid.RowDefinitions.Count].MeasuredResult = columnResult.LengthList[i];
-                    Results[i + Grid.RowDefinitions.Count].MinLength = columnResult.MinLengths[i];
-                }
-            }
-
-            /// <summary>
-            /// Clears the measurement cache, in preparation for the Measure pass.
-            /// </summary>
-            public void InvalidateMeasure()
-            {
-                var newItems = new List<MeasurementResult>();
-                var oldItems = new List<MeasurementResult>();
-
-                MeasurementState = MeasurementState.Invalidated;
-
-                Results.ForEach(r =>
-                {
-                    r.MeasuredResult = double.NaN;
-                    r.SizeGroup?.Reset();
-                });
-            }
-
-            /// <summary>
-            /// Clears the <see cref="IObservable{T}"/> subscriptions.
-            /// </summary>
-            public void Dispose()
-            {
-                _subscriptions.Dispose();
-                _groupChanged.OnCompleted();
-            }
-
-            /// <summary>
-            /// Gets the <see cref="Grid"/> for which this cache has been created.
-            /// </summary>
-            public Grid Grid { get; }
-            
-            /// <summary>
-            /// Gets the <see cref="MeasurementState"/> of this cache.
-            /// </summary>
-            public MeasurementState MeasurementState { get; private set; }
-
-            /// <summary>
-            /// Gets the list of <see cref="MeasurementResult"/> instances.
-            /// </summary>
-            /// <remarks>
-            /// The list is a 1-1 map of the concatenation of RowDefinitions and ColumnDefinitions
-            /// </remarks>
-            public List<MeasurementResult> Results { get; private set; }
-        }
-
-
-        /// <summary>
-        /// Class containing the Measure result for a single Row/Column in a grid.
-        /// </summary>
-        private class MeasurementResult
-        {
-            public MeasurementResult(Grid owningGrid, DefinitionBase definition)
-            {
-                OwningGrid = owningGrid;
-                Definition = definition;
-                MeasuredResult = double.NaN;
-            }
-
-            /// <summary>
-            /// Gets the <see cref="RowDefinition"/>/<see cref="ColumnDefinition"/> related to this <see cref="MeasurementResult"/>
-            /// </summary>
-            public DefinitionBase Definition { get; }
-            
-            /// <summary>
-            /// Gets or sets the actual result of the Measure operation for this column.
-            /// </summary>
-            public double MeasuredResult { get; set; }
-            
-            /// <summary>
-            /// Gets or sets the Minimum constraint for a Row/Column - relevant for star Rows/Columns in unconstrained grids.
-            /// </summary>
-            public double MinLength { get; set; }
-            
-            /// <summary>
-            /// Gets or sets the <see cref="Group"/> that this result belongs to.
-            /// </summary>
-            public Group SizeGroup { get; set; }
-            
-            /// <summary>
-            /// Gets the Grid that is the parent of the Row/Column
-            /// </summary>
-            public Grid OwningGrid { get; }
-
-            /// <summary>
-            /// Calculates the effective length that this Row/Column wishes to enforce in the SharedSizeGroup.
-            /// </summary>
-            /// <returns>A tuple of length and the priority in the shared size group.</returns>
-            public (double length, int priority) GetPriorityLength()
-            {
-                var length = (Definition as ColumnDefinition)?.Width ?? ((RowDefinition)Definition).Height;
-
-                if (length.IsAbsolute)
-                    return (MeasuredResult, 1);
-                if (length.IsAuto)
-                    return (MeasuredResult, 2);
-                if (MinLength > 0)
-                    return (MinLength, 3);
-                return (MeasuredResult, 4);
-            }
-        }
-
-        /// <summary>
-        /// Visitor class used to gather the final length for a given SharedSizeGroup.
-        /// </summary>
-        /// <remarks>
-        /// The values are applied according to priorities defined in <see cref="MeasurementResult.GetPriorityLength"/>.
-        /// </remarks>
-        private class LentgthGatherer
-        {
-            /// <summary>
-            /// Gets the final Length to be applied to every Row/Column in a SharedSizeGroup
-            /// </summary>
-            public double Length { get; private set; }
-            private int gatheredPriority = 6;
-
-            /// <summary>
-            /// Visits the <paramref name="result"/> applying the result of <see cref="MeasurementResult.GetPriorityLength"/> to its internal cache.
-            /// </summary>
-            /// <param name="result">The <see cref="MeasurementResult"/> instance to visit.</param>
-            public void Visit(MeasurementResult result)
-            {
-                var (length, priority) = result.GetPriorityLength();
-
-                if (gatheredPriority < priority)
-                    return;
-
-                gatheredPriority = priority;
-                if (gatheredPriority == priority)
-                {
-                    Length = Math.Max(length,Length);
-                }
-                else
-                {
-                    Length = length;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Representation of a SharedSizeGroup, containing Rows/Columns with the same SharedSizeGroup property value.
-        /// </summary>
-        private class Group
-        {
-            private double? cachedResult;
-            private List<MeasurementResult> _results = new List<MeasurementResult>(); 
-
-            /// <summary>
-            /// Gets the name of the SharedSizeGroup.
-            /// </summary>
-            public string Name { get; }
-
-            public Group(string name)
-            {
-                Name = name;
-            }
-
-            /// <summary>
-            /// Gets the collection of the <see cref="MeasurementResult"/> instances.
-            /// </summary>
-            public IReadOnlyList<MeasurementResult> Results => _results;
-
-            /// <summary>
-            /// Gets the final, calculated length for all Rows/Columns in the SharedSizeGroup.
-            /// </summary>
-            public double CalculatedLength => (cachedResult ?? (cachedResult = Gather())).Value;
-
-            /// <summary>
-            /// Clears the previously cached result in preparation for measurement.
-            /// </summary>
-            public void Reset()
-            {
-                cachedResult = null;
-            }
-
-            /// <summary>
-            /// Ads a measurement result to this group and sets it's <see cref="MeasurementResult.SizeGroup"/> property
-            /// to this instance.
-            /// </summary>
-            /// <param name="result">The <see cref="MeasurementResult"/> to include in this group.</param>
-            public void Add(MeasurementResult result)
-            {
-                if (_results.Contains(result))
-                    throw new AvaloniaInternalException(
-                        $"SharedSizeScopeHost: Invalid call to Group.Add - The SharedSizeGroup {Name} already contains the passed result");
-
-                result.SizeGroup = this;
-                _results.Add(result);
-            }
-
-            /// <summary>
-            /// Removes the measurement result from this group and clears its <see cref="MeasurementResult.SizeGroup"/> value.
-            /// </summary>
-            /// <param name="result">The <see cref="MeasurementResult"/> to clear.</param>
-            public void Remove(MeasurementResult result)
-            {
-                if (!_results.Contains(result))
-                    throw new AvaloniaInternalException(
-                        $"SharedSizeScopeHost: Invalid call to Group.Remove - The SharedSizeGroup {Name} does not contain the passed result");
-                result.SizeGroup = null;
-                _results.Remove(result);
-            }
-
-
-            private double Gather()
-            {
-                var visitor = new LentgthGatherer();
-
-                _results.ForEach(visitor.Visit);
-
-                return visitor.Length;
-            }
-        }
-
-        private readonly AvaloniaList<MeasurementCache> _measurementCaches = new AvaloniaList<MeasurementCache>();
-        private readonly Dictionary<string, Group> _groups = new Dictionary<string, Group>();
-        private bool _invalidating;
-
-        /// <summary>
-        /// Removes the SharedSizeScope and notifies all affected grids of the change.
-        /// </summary>
-        public void Dispose()
-        {
-            while (_measurementCaches.Any())
-                _measurementCaches[0].Grid.SharedScopeChanged();
-        }
-
-        /// <summary>
-        /// Registers the grid in this SharedSizeScope, to be called when the grid is added to the visual tree. 
-        /// </summary>
-        /// <param name="toAdd">The <see cref="Grid"/> to add to this scope.</param>
-        internal void RegisterGrid(Grid toAdd)
-        {
-            if (_measurementCaches.Any(mc => ReferenceEquals(mc.Grid, toAdd)))
-                throw new AvaloniaInternalException("SharedSizeScopeHost: tried to register a grid twice!");
-
-            var cache = new MeasurementCache(toAdd);
-            _measurementCaches.Add(cache);
-            AddGridToScopes(cache);
-        }
-
-        /// <summary>
-        /// Removes the registration for a grid in this SharedSizeScope.
-        /// </summary>
-        /// <param name="toRemove">The <see cref="Grid"/> to remove.</param>
-        internal void UnegisterGrid(Grid toRemove)
-        {
-            var cache = _measurementCaches.FirstOrDefault(mc => ReferenceEquals(mc.Grid, toRemove));
-            if (cache == null)
-                throw new AvaloniaInternalException("SharedSizeScopeHost: tried to unregister a grid that wasn't registered before!");
-
-            _measurementCaches.Remove(cache);
-            RemoveGridFromScopes(cache);
-            cache.Dispose();
-        }
-
-        /// <summary>
-        /// Helper method to check if a grid needs to forward its Mesure results to, and requrest Arrange results from this scope.
-        /// </summary>
-        /// <param name="toCheck">The <see cref="Grid"/> that should be checked.</param>
-        /// <returns>True if the grid should forward its calls.</returns>
-        internal bool ParticipatesInScope(Grid toCheck)
-        {
-            return _measurementCaches.FirstOrDefault(mc => ReferenceEquals(mc.Grid, toCheck))
-                                    ?.Results.Any(r => r.SizeGroup != null) ?? false;
-        }
-
-        /// <summary>
-        /// Notifies the SharedSizeScope that a grid had requested its measurement to be invalidated.
-        /// Forwards the same call to all affected grids in this scope.
-        /// </summary>
-        /// <param name="grid">The <see cref="Grid"/> that had it's Measure invalidated.</param>
-        internal void InvalidateMeasure(Grid grid)
-        {
-            // prevent stack overflow
-            if (_invalidating)
-                return;
-            _invalidating = true;
-
-            InvalidateMeasureImpl(grid);
-
-            _invalidating = false;
-        }
-
-        /// <summary>
-        /// Updates the measurement cache with the results of the <paramref name="grid"/> measurement pass.
-        /// </summary>
-        /// <param name="grid">The <see cref="Grid"/> that has been measured.</param>
-        /// <param name="rowResult">Measurement result for the grid's <see cref="RowDefinitions"/></param>
-        /// <param name="columnResult">Measurement result for the grid's <see cref="ColumnDefinitions"/></param>
-        internal void UpdateMeasureStatus(Grid grid, GridLayout.MeasureResult rowResult, GridLayout.MeasureResult columnResult)
-        {
-            var cache = _measurementCaches.FirstOrDefault(mc => ReferenceEquals(mc.Grid, grid));
-            if (cache == null)
-                throw new AvaloniaInternalException("SharedSizeScopeHost: Attempted to update measurement status for a grid that wasn't registered!");
-
-            cache.UpdateMeasureResult(rowResult, columnResult);
-        }
-
-        /// <summary>
-        /// Calculates the measurement result including the impact of any SharedSizeGroups that might affect this grid.
-        /// </summary>
-        /// <param name="grid">The <see cref="Grid"/> that is being Arranged</param>
-        /// <param name="rowResult">The <paramref name="grid"/>'s cached measurement result.</param>
-        /// <param name="columnResult">The <paramref name="grid"/>'s cached measurement result.</param>
-        /// <returns>Row and column measurement result updated with the SharedSizeScope constraints.</returns>
-        internal (GridLayout.MeasureResult, GridLayout.MeasureResult) HandleArrange(Grid grid, GridLayout.MeasureResult rowResult, GridLayout.MeasureResult columnResult)
-        {
-            return (
-                 Arrange(grid.RowDefinitions, rowResult),
-                 Arrange(grid.ColumnDefinitions, columnResult)
-                 );
-        }
-
-        /// <summary>
-        /// Invalidates the measure of all grids affected by the SharedSizeGroups contained within.
-        /// </summary>
-        /// <param name="grid">The <see cref="Grid"/> that is being invalidated.</param>
-        private void InvalidateMeasureImpl(Grid grid)
-        {
-            var cache = _measurementCaches.FirstOrDefault(mc => ReferenceEquals(mc.Grid, grid));
-
-            if (cache == null)
-                throw new AvaloniaInternalException(
-                    $"SharedSizeScopeHost: InvalidateMeasureImpl - called with a grid not present in the internal cache");
-
-            // already invalidated the cache, early out.
-            if (cache.MeasurementState == MeasurementState.Invalidated)
-                return;
-
-            // we won't calculate, so we should not invalidate.
-            if (!ParticipatesInScope(grid))
-                return;
-
-            cache.InvalidateMeasure();
-
-            // maybe there is a condition to only call arrange on some of the calls?
-            grid.InvalidateMeasure();
-
-            // find all the scopes within the invalidated grid
-            var scopeNames = cache.Results
-                                  .Where(mr => mr.SizeGroup != null)
-                                  .Select(mr => mr.SizeGroup.Name)
-                                  .Distinct();
-            // find all grids related to those scopes
-            var otherGrids = scopeNames.SelectMany(sn => _groups[sn].Results)
-                                       .Select(r => r.OwningGrid)
-                                       .Where(g => g.IsMeasureValid)
-                                       .Distinct();
-
-            // invalidate them as well
-            foreach (var otherGrid in otherGrids)
-            {
-                InvalidateMeasureImpl(otherGrid);
-            }
-        }
-
-        /// <summary>
-        /// <see cref="IObserver{T}"/> callback notifying the scope that a <see cref="MeasurementResult"/> has changed its
-        /// SharedSizeGroup
-        /// </summary>
-        /// <param name="change">Old and New name (either can be null) of the SharedSizeGroup, as well as the result.</param>
-        private void SharedGroupChanged((string oldName, string newName, MeasurementResult result) change)
-        {
-            RemoveFromGroup(change.oldName, change.result);
-            AddToGroup(change.newName, change.result);
-        }
-
-        /// <summary>
-        /// Handles the impact of SharedSizeGroups on the Arrange of <see cref="RowDefinitions"/>/<see cref="ColumnDefinitions"/>
-        /// </summary>
-        /// <param name="definitions">Rows/Columns that were measured</param>
-        /// <param name="measureResult">The initial measurement result.</param>
-        /// <returns>Modified measure result</returns>
-        private GridLayout.MeasureResult Arrange(IReadOnlyList<DefinitionBase> definitions, GridLayout.MeasureResult measureResult)
-        {
-            var conventions = measureResult.LeanLengthList.ToList();
-            var lengths = measureResult.LengthList.ToList();
-            var desiredLength = 0.0;
-            for (int i = 0; i < definitions.Count; i++)
-            {
-                var definition = definitions[i];
-
-                // for empty SharedSizeGroups pass on unmodified result.
-                if (string.IsNullOrEmpty(definition.SharedSizeGroup))
-                {
-                    desiredLength += measureResult.LengthList[i];
-                    continue;
-                }
-
-                var group = _groups[definition.SharedSizeGroup];
-                // Length calculated over all Definitions participating in a SharedSizeGroup.
-                var length = group.CalculatedLength;
-
-                conventions[i] = new GridLayout.LengthConvention(
-                    new GridLength(length),
-                    measureResult.LeanLengthList[i].MinLength,
-                    measureResult.LeanLengthList[i].MaxLength
-                );
-                lengths[i] = length;
-                desiredLength += length;
-            }
-
-            return new GridLayout.MeasureResult(
-                    measureResult.ContainerLength,
-                    desiredLength,
-                    measureResult.GreedyDesiredLength,//??
-                    conventions,
-                    lengths,
-                    measureResult.MinLengths);
-        }
-
-        /// <summary>
-        /// Adds all measurement results for a grid to their repsective scopes.
-        /// </summary>
-        /// <param name="cache">The <see cref="MeasurementCache"/> for a grid to be added.</param>
-        private void AddGridToScopes(MeasurementCache cache)
-        {
-            cache.GroupChanged.Subscribe(SharedGroupChanged);
-
-            foreach (var result in cache.Results)
-            {
-                var scopeName = result.Definition.SharedSizeGroup;
-                AddToGroup(scopeName, result);
-            }
-        }
-
-        /// <summary>
-        /// Handles adding the <see cref="MeasurementResult"/> to a SharedSizeGroup.
-        /// Does nothing for empty SharedSizeGroups.
-        /// </summary>
-        /// <param name="scopeName">The name (can be null or empty) of the group to add the <paramref name="result"/> to.</param>
-        /// <param name="result">The <see cref="MeasurementResult"/> to add to a scope.</param>
-        private void AddToGroup(string scopeName, MeasurementResult result)
-        {
-            if (string.IsNullOrEmpty(scopeName))
-                return;
-
-            if (!_groups.TryGetValue(scopeName, out var group))
-                _groups.Add(scopeName, group = new Group(scopeName));
-
-            group.Add(result);
-        }
-
-        /// <summary>
-        /// Removes all measurement results for a grid from their respective scopes.
-        /// </summary>
-        /// <param name="cache">The <see cref="MeasurementCache"/> for a grid to be removed.</param>
-        private void RemoveGridFromScopes(MeasurementCache cache)
-        {
-            foreach (var result in cache.Results)
-            {
-                var scopeName = result.Definition.SharedSizeGroup;
-                RemoveFromGroup(scopeName, result);
-            }
-        }
-
-        /// <summary>
-        /// Handles removing the <see cref="MeasurementResult"/> from a SharedSizeGroup.
-        /// Does nothing for empty SharedSizeGroups.
-        /// </summary>
-        /// <param name="scopeName">The name (can be null or empty) of the group to remove the <paramref name="result"/> from.</param>
-        /// <param name="result">The <see cref="MeasurementResult"/> to remove from a scope.</param>
-        private void RemoveFromGroup(string scopeName, MeasurementResult result)
-        {
-            if (string.IsNullOrEmpty(scopeName))
-                return;
-
-            if (!_groups.TryGetValue(scopeName, out var group))
-                throw new AvaloniaInternalException($"SharedSizeScopeHost: The scope {scopeName} wasn't found in the shared size scope");
-
-            group.Remove(result);
-            if (!group.Results.Any())
-                _groups.Remove(scopeName);
-        }
-    }
-}

src/Avalonia.Controls/WrapPanel.cs

@@ -6,6 +6,7 @@ using System.Diagnostics;
 using System.Linq;
 
 using Avalonia.Input;
+using Avalonia.Utilities;
 
 using static System.Math;
 
@@ -92,109 +93,127 @@ namespace Avalonia.Controls
             }
         }
 
-        private UVSize CreateUVSize(Size size) => new UVSize(Orientation, size);
-
-        private UVSize CreateUVSize() => new UVSize(Orientation);
-
         /// <inheritdoc/>
-        protected override Size MeasureOverride(Size availableSize)
+        protected override Size MeasureOverride(Size constraint)
         {
-            var desiredSize = CreateUVSize();
-            var lineSize = CreateUVSize();
-            var uvAvailableSize = CreateUVSize(availableSize);
+            var curLineSize = new UVSize(Orientation);
+            var panelSize = new UVSize(Orientation);
+            var uvConstraint = new UVSize(Orientation, constraint.Width, constraint.Height);
 
-            foreach (var child in Children)
+            var childConstraint = new Size(constraint.Width, constraint.Height);
+
+            for (int i = 0, count = Children.Count; i < count; i++)
             {
-                child.Measure(availableSize);
-                var childSize = CreateUVSize(child.DesiredSize);
-                if (lineSize.U + childSize.U <= uvAvailableSize.U) // same line
+                var child = Children[i];
+                if (child == null) continue;
+
+                //Flow passes its own constrint to children
+                child.Measure(childConstraint);
+
+                //this is the size of the child in UV space
+                var sz = new UVSize(Orientation, child.DesiredSize.Width, child.DesiredSize.Height);
+
+                if (MathUtilities.GreaterThan(curLineSize.U + sz.U, uvConstraint.U)) //need to switch to another line
                 {
-                    lineSize.U += childSize.U;
-                    lineSize.V = Max(lineSize.V, childSize.V);
+                    panelSize.U = Max(curLineSize.U, panelSize.U);
+                    panelSize.V += curLineSize.V;
+                    curLineSize = sz;
+
+                    if (MathUtilities.GreaterThan(sz.U, uvConstraint.U)) //the element is wider then the constrint - give it a separate line                    
+                    {
+                        panelSize.U = Max(sz.U, panelSize.U);
+                        panelSize.V += sz.V;
+                        curLineSize = new UVSize(Orientation);
+                    }
                 }
-                else // moving to next line
+                else //continue to accumulate a line
                 {
-                    desiredSize.U = Max(lineSize.U, uvAvailableSize.U);
-                    desiredSize.V += lineSize.V;
-                    lineSize = childSize;
+                    curLineSize.U += sz.U;
+                    curLineSize.V = Max(sz.V, curLineSize.V);
                 }
             }
-            // last element
-            desiredSize.U = Max(lineSize.U, desiredSize.U);
-            desiredSize.V += lineSize.V;
 
-            return desiredSize.ToSize();
+            //the last line size, if any should be added
+            panelSize.U = Max(curLineSize.U, panelSize.U);
+            panelSize.V += curLineSize.V;
+
+            //go from UV space to W/H space
+            return new Size(panelSize.Width, panelSize.Height);
         }
 
         /// <inheritdoc/>
         protected override Size ArrangeOverride(Size finalSize)
         {
+            int firstInLine = 0;
             double accumulatedV = 0;
-            var uvFinalSize = CreateUVSize(finalSize);
-            var lineSize = CreateUVSize();
-            int firstChildInLineIndex = 0;
-            for (int index = 0; index < Children.Count; index++)
+            UVSize curLineSize = new UVSize(Orientation);
+            UVSize uvFinalSize = new UVSize(Orientation, finalSize.Width, finalSize.Height);
+
+            for (int i = 0; i < Children.Count; i++)
             {
-                var child = Children[index];
-                var childSize = CreateUVSize(child.DesiredSize);
-                if (lineSize.U + childSize.U <= uvFinalSize.U) // same line
+                var child = Children[i];
+                if (child == null) continue;
+
+                var sz = new UVSize(Orientation, child.DesiredSize.Width, child.DesiredSize.Height);
+
+                if (MathUtilities.GreaterThan(curLineSize.U + sz.U, uvFinalSize.U)) //need to switch to another line
                 {
-                    lineSize.U += childSize.U;
-                    lineSize.V = Max(lineSize.V, childSize.V);
+                    arrangeLine(accumulatedV, curLineSize.V, firstInLine, i);
+
+                    accumulatedV += curLineSize.V;
+                    curLineSize = sz;
+
+                    if (MathUtilities.GreaterThan(sz.U, uvFinalSize.U)) //the element is wider then the constraint - give it a separate line                    
+                    {
+                        //switch to next line which only contain one element
+                        arrangeLine(accumulatedV, sz.V, i, ++i);
+
+                        accumulatedV += sz.V;
+                        curLineSize = new UVSize(Orientation);
+                    }
+                    firstInLine = i;
                 }
-                else // moving to next line
+                else //continue to accumulate a line
                 {
-                    var controlsInLine = GetControlsBetween(firstChildInLineIndex, index);
-                    ArrangeLine(accumulatedV, lineSize.V, controlsInLine);
-                    accumulatedV += lineSize.V;
-                    lineSize = childSize;
-                    firstChildInLineIndex = index;
+                    curLineSize.U += sz.U;
+                    curLineSize.V = Max(sz.V, curLineSize.V);
                 }
             }
 
-            if (firstChildInLineIndex < Children.Count)
+            //arrange the last line, if any
+            if (firstInLine < Children.Count)
             {
-                var controlsInLine = GetControlsBetween(firstChildInLineIndex, Children.Count);
-                ArrangeLine(accumulatedV, lineSize.V, controlsInLine);
+                arrangeLine(accumulatedV, curLineSize.V, firstInLine, Children.Count);
             }
-            return finalSize;
-        }
 
-        private IEnumerable<IControl> GetControlsBetween(int first, int last)
-        {
-            return Children.Skip(first).Take(last - first);
+            return finalSize;
         }
 
-        private void ArrangeLine(double v, double lineV, IEnumerable<IControl> controls)
+        private void arrangeLine(double v, double lineV, int start, int end)
         {
             double u = 0;
             bool isHorizontal = (Orientation == Orientation.Horizontal);
-            foreach (var child in controls)
+
+            for (int i = start; i < end; i++)
             {
-                var childSize = CreateUVSize(child.DesiredSize);
-                var x = isHorizontal ? u : v;
-                var y = isHorizontal ? v : u;
-                var width = isHorizontal ? childSize.U : lineV;
-                var height = isHorizontal ? lineV : childSize.U;
-                child.Arrange(new Rect(x, y, width, height));
-                u += childSize.U;
+                var child = Children[i];
+                if (child != null)
+                {
+                    UVSize childSize = new UVSize(Orientation, child.DesiredSize.Width, child.DesiredSize.Height);
+                    double layoutSlotU = childSize.U;
+                    child.Arrange(new Rect(
+                        (isHorizontal ? u : v),
+                        (isHorizontal ? v : u),
+                        (isHorizontal ? layoutSlotU : lineV),
+                        (isHorizontal ? lineV : layoutSlotU)));
+                    u += layoutSlotU;
+                }
             }
         }
-        /// <summary>
-        /// Used to not not write separate code for horizontal and vertical orientation.
-        /// U is direction in line. (x if orientation is horizontal)
-        /// V is direction of lines. (y if orientation is horizontal)
-        /// </summary>
-        [DebuggerDisplay("U = {U} V = {V}")]
+
         private struct UVSize
         {
-            private readonly Orientation _orientation;
-
-            internal double U;
-
-            internal double V;
-
-            private UVSize(Orientation orientation, double width, double height)
+            internal UVSize(Orientation orientation, double width, double height)
             {
                 U = V = 0d;
                 _orientation = orientation;
@@ -202,52 +221,25 @@ namespace Avalonia.Controls
                 Height = height;
             }
 
-            internal UVSize(Orientation orientation, Size size)
-                : this(orientation, size.Width, size.Height)
-            {
-            }
-
             internal UVSize(Orientation orientation)
             {
                 U = V = 0d;
                 _orientation = orientation;
             }
 
-            private double Width
+            internal double U;
+            internal double V;
+            private Orientation _orientation;
+
+            internal double Width
             {
                 get { return (_orientation == Orientation.Horizontal ? U : V); }
-                set
-                {
-                    if (_orientation == Orientation.Horizontal)
-                    {
-                        U = value;
-                    }
-                    else
-                    {
-                        V = value;
-                    }
-                }
+                set { if (_orientation == Orientation.Horizontal) U = value; else V = value; }
             }
-
-            private double Height
+            internal double Height
             {
                 get { return (_orientation == Orientation.Horizontal ? V : U); }
-                set
-                {
-                    if (_orientation == Orientation.Horizontal)
-                    {
-                        V = value;
-                    }
-                    else
-                    {
-                        U = value;
-                    }
-                }
-            }
-
-            public Size ToSize()
-            {
-                return new Size(Width, Height);
+                set { if (_orientation == Orientation.Horizontal) V = value; else U = value; }
             }
         }
     }

src/Avalonia.Input/Cursors.cs

@@ -38,6 +38,7 @@ namespace Avalonia.Input
         DragMove,
         DragCopy,
         DragLink,
+        None,
 
         // Not available in GTK directly, see http://www.pixelbeat.org/programming/x_cursors/ 
         // We might enable them later, preferably, by loading pixmax direclty from theme with fallback image

src/Avalonia.Input/GestureRecognizers/GestureRecognizerCollection.cs

@@ -0,0 +1,127 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Avalonia.Controls;
+using Avalonia.Data;
+using Avalonia.LogicalTree;
+using Avalonia.Styling;
+
+namespace Avalonia.Input.GestureRecognizers
+{
+    public class GestureRecognizerCollection : IReadOnlyCollection<IGestureRecognizer>, IGestureRecognizerActionsDispatcher
+    {
+        private readonly IInputElement _inputElement;
+        private List<IGestureRecognizer> _recognizers;
+        private Dictionary<IPointer, IGestureRecognizer> _pointerGrabs;
+        
+        
+        public GestureRecognizerCollection(IInputElement inputElement)
+        {
+            _inputElement = inputElement;
+        }
+        
+        public void Add(IGestureRecognizer recognizer)
+        {
+            if (_recognizers == null)
+            {
+                // We initialize the collection when the first recognizer is added
+                _recognizers = new List<IGestureRecognizer>();
+                _pointerGrabs = new Dictionary<IPointer, IGestureRecognizer>();
+            }
+
+            _recognizers.Add(recognizer);
+            recognizer.Initialize(_inputElement, this);
+
+            // Hacks to make bindings work
+            
+            if (_inputElement is ILogical logicalParent && recognizer is ISetLogicalParent logical)
+            {
+                logical.SetParent(logicalParent);
+                if (recognizer is IStyleable styleableRecognizer
+                    && _inputElement is IStyleable styleableParent)
+                    styleableRecognizer.Bind(StyledElement.TemplatedParentProperty,
+                        styleableParent.GetObservable(StyledElement.TemplatedParentProperty));
+            }
+        }
+
+        static readonly List<IGestureRecognizer> s_Empty = new List<IGestureRecognizer>();
+
+        public IEnumerator<IGestureRecognizer> GetEnumerator()
+            => _recognizers?.GetEnumerator() ?? s_Empty.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        public int Count => _recognizers?.Count ?? 0;
+
+
+        internal bool HandlePointerPressed(PointerPressedEventArgs e)
+        {
+            if (_recognizers == null)
+                return false;
+            foreach (var r in _recognizers)
+            {
+                if(e.Handled)
+                    break;
+                r.PointerPressed(e);
+            }
+
+            return e.Handled;
+        }
+
+        internal bool HandlePointerReleased(PointerReleasedEventArgs e)
+        {
+            if (_recognizers == null)
+                return false;
+            if (_pointerGrabs.TryGetValue(e.Pointer, out var capture))
+            {
+                capture.PointerReleased(e);
+            }
+            else
+                foreach (var r in _recognizers)
+                {
+                    if (e.Handled)
+                        break;
+                    r.PointerReleased(e);
+                }
+            return e.Handled;
+        }
+
+        internal bool HandlePointerMoved(PointerEventArgs e)
+        {
+            if (_recognizers == null)
+                return false;
+            if (_pointerGrabs.TryGetValue(e.Pointer, out var capture))
+            {
+                capture.PointerMoved(e);
+            }
+            else
+                foreach (var r in _recognizers)
+                {
+                    if (e.Handled)
+                        break;
+                    r.PointerMoved(e);
+                }
+            return e.Handled;
+        }
+
+        internal void HandlePointerCaptureLost(PointerCaptureLostEventArgs e)
+        {
+            if (_recognizers == null)
+                return;
+            _pointerGrabs.Remove(e.Pointer);
+            foreach (var r in _recognizers)
+            {
+                if(e.Handled)
+                    break;
+                r.PointerCaptureLost(e);
+            }
+        }
+
+        void IGestureRecognizerActionsDispatcher.Capture(IPointer pointer, IGestureRecognizer recognizer)
+        {
+            pointer.Capture(_inputElement);
+            _pointerGrabs[pointer] = recognizer;
+        }
+
+    }
+}

src/Avalonia.Input/GestureRecognizers/IGestureRecognizer.cs

@@ -0,0 +1,23 @@
+namespace Avalonia.Input.GestureRecognizers
+{
+    public interface IGestureRecognizer
+    {
+        void Initialize(IInputElement target, IGestureRecognizerActionsDispatcher actions);
+        void PointerPressed(PointerPressedEventArgs e);
+        void PointerReleased(PointerReleasedEventArgs e);
+        void PointerMoved(PointerEventArgs e);
+        void PointerCaptureLost(PointerCaptureLostEventArgs e);
+    }
+    
+    public interface IGestureRecognizerActionsDispatcher
+    {
+        void Capture(IPointer pointer, IGestureRecognizer recognizer);
+    }
+    
+    public enum GestureRecognizerResult
+    {
+        None,
+        Capture,
+        ReleaseCapture
+    }
+}

src/Avalonia.Input/GestureRecognizers/ScrollGestureRecognizer.cs

@@ -0,0 +1,183 @@
+using System;
+using System.Diagnostics;
+using Avalonia.Interactivity;
+using Avalonia.Threading;
+
+namespace Avalonia.Input.GestureRecognizers
+{
+    public class ScrollGestureRecognizer 
+        : StyledElement, // It's not an "element" in any way, shape or form, but TemplateBinding refuse to work otherwise
+            IGestureRecognizer
+    {
+        private bool _scrolling;
+        private Point _trackedRootPoint;
+        private IPointer _tracking;
+        private IInputElement _target;
+        private IGestureRecognizerActionsDispatcher _actions;
+        private bool _canHorizontallyScroll;
+        private bool _canVerticallyScroll;
+        private int _gestureId;
+        
+        // Movement per second
+        private Vector _inertia;
+        private ulong? _lastMoveTimestamp;
+        
+        /// <summary>
+        /// Defines the <see cref="CanHorizontallyScroll"/> property.
+        /// </summary>
+        public static readonly DirectProperty<ScrollGestureRecognizer, bool> CanHorizontallyScrollProperty =
+            AvaloniaProperty.RegisterDirect<ScrollGestureRecognizer, bool>(
+                nameof(CanHorizontallyScroll),
+                o => o.CanHorizontallyScroll,
+                (o, v) => o.CanHorizontallyScroll = v);
+
+        /// <summary>
+        /// Defines the <see cref="CanVerticallyScroll"/> property.
+        /// </summary>
+        public static readonly DirectProperty<ScrollGestureRecognizer, bool> CanVerticallyScrollProperty =
+            AvaloniaProperty.RegisterDirect<ScrollGestureRecognizer, bool>(
+                nameof(CanVerticallyScroll),
+                o => o.CanVerticallyScroll,
+                (o, v) => o.CanVerticallyScroll = v);
+        
+        /// <summary>
+        /// Gets or sets a value indicating whether the content can be scrolled horizontally.
+        /// </summary>
+        public bool CanHorizontallyScroll
+        {
+            get => _canHorizontallyScroll;
+            set => SetAndRaise(CanHorizontallyScrollProperty, ref _canHorizontallyScroll, value);
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the content can be scrolled horizontally.
+        /// </summary>
+        public bool CanVerticallyScroll
+        {
+            get => _canVerticallyScroll;
+            set => SetAndRaise(CanVerticallyScrollProperty, ref _canVerticallyScroll, value);
+        }
+        
+
+        public void Initialize(IInputElement target, IGestureRecognizerActionsDispatcher actions)
+        {
+            _target = target;
+            _actions = actions;
+        }
+        
+        public void PointerPressed(PointerPressedEventArgs e)
+        {
+            if (e.Pointer.IsPrimary && e.Pointer.Type == PointerType.Touch)
+            {
+                EndGesture();
+                _tracking = e.Pointer;
+                _gestureId = ScrollGestureEventArgs.GetNextFreeId();;
+                _trackedRootPoint = e.GetPosition(null);
+            }
+        }
+
+        // Arbitrary chosen value, probably need to move that to platform settings or something
+        private const double ScrollStartDistance = 30;
+        
+        // Pixels per second speed that is considered to be the stop of inertiall scroll
+        private const double InertialScrollSpeedEnd = 5;
+        
+        public void PointerMoved(PointerEventArgs e)
+        {
+            if (e.Pointer == _tracking)
+            {
+                var rootPoint = e.GetPosition(null);
+                if (!_scrolling)
+                {
+                    if (CanHorizontallyScroll && Math.Abs(_trackedRootPoint.X - rootPoint.X) > ScrollStartDistance)
+                        _scrolling = true;
+                    if (CanVerticallyScroll && Math.Abs(_trackedRootPoint.Y - rootPoint.Y) > ScrollStartDistance)
+                        _scrolling = true;
+                    if (_scrolling)
+                    {
+                        _actions.Capture(e.Pointer, this);
+                    }
+                }
+
+                if (_scrolling)
+                {
+                    var vector = _trackedRootPoint - rootPoint;
+                    var elapsed = _lastMoveTimestamp.HasValue ?
+                        TimeSpan.FromMilliseconds(e.Timestamp - _lastMoveTimestamp.Value) :
+                        TimeSpan.Zero;
+                    
+                    _lastMoveTimestamp = e.Timestamp;
+                    _trackedRootPoint = rootPoint;
+                    if (elapsed.TotalSeconds > 0)
+                        _inertia = vector / elapsed.TotalSeconds;
+                    _target.RaiseEvent(new ScrollGestureEventArgs(_gestureId, vector));
+                    e.Handled = true;
+                }
+            }
+        }
+
+        public void PointerCaptureLost(PointerCaptureLostEventArgs e)
+        {
+            if (e.Pointer == _tracking) EndGesture();
+        }
+
+        void EndGesture()
+        {
+            _tracking = null;
+            if (_scrolling)
+            {
+                _inertia = default;
+                _scrolling = false;
+                _target.RaiseEvent(new ScrollGestureEndedEventArgs(_gestureId));
+                _gestureId = 0;
+                _lastMoveTimestamp = null;
+            }
+            
+        }
+        
+        
+        public void PointerReleased(PointerReleasedEventArgs e)
+        {
+            if (e.Pointer == _tracking && _scrolling)
+            {
+                e.Handled = true;
+                if (_inertia == default
+                    || e.Timestamp == 0
+                    || _lastMoveTimestamp == 0
+                    || e.Timestamp - _lastMoveTimestamp > 200)
+                    EndGesture();
+                else
+                {
+                    var savedGestureId = _gestureId;
+                    var st = Stopwatch.StartNew();
+                    var lastTime = TimeSpan.Zero;
+                    DispatcherTimer.Run(() =>
+                    {
+                        // Another gesture has started, finish the current one
+                        if (_gestureId != savedGestureId)
+                        {
+                            return false;
+                        }
+
+                        var elapsedSinceLastTick = st.Elapsed - lastTime;
+                        lastTime = st.Elapsed;
+
+                        var speed = _inertia * Math.Pow(0.15, st.Elapsed.TotalSeconds);
+                        var distance = speed * elapsedSinceLastTick.TotalSeconds;
+                        _target.RaiseEvent(new ScrollGestureEventArgs(_gestureId, distance));
+
+
+
+                        if (Math.Abs(speed.X) < InertialScrollSpeedEnd || Math.Abs(speed.Y) <= InertialScrollSpeedEnd)
+                        {
+                            EndGesture();
+                            return false;
+                        }
+
+                        return true;
+                    }, TimeSpan.FromMilliseconds(16), DispatcherPriority.Background);
+                }
+            }
+        }
+    }
+}

src/Avalonia.Input/Gestures.cs

@@ -18,6 +18,14 @@ namespace Avalonia.Input
             RoutingStrategies.Bubble,
             typeof(Gestures));
 
+        public static readonly RoutedEvent<ScrollGestureEventArgs> ScrollGestureEvent =
+            RoutedEvent.Register<ScrollGestureEventArgs>(
+                "ScrollGesture", RoutingStrategies.Bubble, typeof(Gestures));
+ 
+        public static readonly RoutedEvent<ScrollGestureEventArgs> ScrollGestureEndedEvent =
+            RoutedEvent.Register<ScrollGestureEventArgs>(
+                "ScrollGestureEnded", RoutingStrategies.Bubble, typeof(Gestures));
+
         private static WeakReference s_lastPress;
 
         static Gestures()

src/Avalonia.Input/InputElement.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Avalonia.Input.GestureRecognizers;
 using Avalonia.Interactivity;
 using Avalonia.VisualTree;
 
@@ -127,6 +128,14 @@ namespace Avalonia.Input
             RoutedEvent.Register<InputElement, PointerReleasedEventArgs>(
                 "PointerReleased",
                 RoutingStrategies.Tunnel | RoutingStrategies.Bubble);
+        
+        /// <summary>
+        /// Defines the <see cref="PointerCaptureLost"/> routed event.
+        /// </summary>
+        public static readonly RoutedEvent<PointerCaptureLostEventArgs> PointerCaptureLostEvent =
+            RoutedEvent.Register<InputElement, PointerCaptureLostEventArgs>(
+                "PointerCaptureLost", 
+                RoutingStrategies.Direct);
 
         /// <summary>
         /// Defines the <see cref="PointerWheelChanged"/> event.
@@ -148,6 +157,7 @@ namespace Avalonia.Input
 
         private bool _isFocused;
         private bool _isPointerOver;
+        private GestureRecognizerCollection _gestureRecognizers;
 
         /// <summary>
         /// Initializes static members of the <see cref="InputElement"/> class.
@@ -166,6 +176,7 @@ namespace Avalonia.Input
             PointerMovedEvent.AddClassHandler<InputElement>(x => x.OnPointerMoved);
             PointerPressedEvent.AddClassHandler<InputElement>(x => x.OnPointerPressed);
             PointerReleasedEvent.AddClassHandler<InputElement>(x => x.OnPointerReleased);
+            PointerCaptureLostEvent.AddClassHandler<InputElement>(x => x.OnPointerCaptureLost);
             PointerWheelChangedEvent.AddClassHandler<InputElement>(x => x.OnPointerWheelChanged);
 
             PseudoClass<InputElement, bool>(IsEnabledCoreProperty, x => !x, ":disabled");
@@ -263,6 +274,16 @@ namespace Avalonia.Input
             remove { RemoveHandler(PointerReleasedEvent, value); }
         }
 
+        /// <summary>
+        /// Occurs when the control or its child control loses the pointer capture for any reason,
+        /// event will not be triggered for a parent control if capture was transferred to another child of that parent control
+        /// </summary>
+        public event EventHandler<PointerCaptureLostEventArgs> PointerCaptureLost
+        {
+            add => AddHandler(PointerCaptureLostEvent, value);
+            remove => RemoveHandler(PointerCaptureLostEvent, value);
+        }
+        
         /// <summary>
         /// Occurs when the mouse wheen is scrolled over the control.
         /// </summary>
@@ -370,6 +391,9 @@ namespace Avalonia.Input
 
         public List<KeyBinding> KeyBindings { get; } = new List<KeyBinding>();
 
+        public GestureRecognizerCollection GestureRecognizers
+            => _gestureRecognizers ?? (_gestureRecognizers = new GestureRecognizerCollection(this));
+
         /// <summary>
         /// Focuses the control.
         /// </summary>
@@ -460,6 +484,8 @@ namespace Avalonia.Input
         /// <param name="e">The event args.</param>
         protected virtual void OnPointerMoved(PointerEventArgs e)
         {
+            if (_gestureRecognizers?.HandlePointerMoved(e) == true)
+                e.Handled = true;
         }
 
         /// <summary>
@@ -468,6 +494,8 @@ namespace Avalonia.Input
         /// <param name="e">The event args.</param>
         protected virtual void OnPointerPressed(PointerPressedEventArgs e)
         {
+            if (_gestureRecognizers?.HandlePointerPressed(e) == true)
+                e.Handled = true;
         }
 
         /// <summary>
@@ -476,6 +504,17 @@ namespace Avalonia.Input
         /// <param name="e">The event args.</param>
         protected virtual void OnPointerReleased(PointerReleasedEventArgs e)
         {
+            if (_gestureRecognizers?.HandlePointerReleased(e) == true)
+                e.Handled = true;
+        }
+
+        /// <summary>
+        /// Called before the <see cref="PointerCaptureLost"/> event occurs.
+        /// </summary>
+        /// <param name="e">The event args.</param>
+        protected virtual void OnPointerCaptureLost(PointerCaptureLostEventArgs e)
+        {
+            _gestureRecognizers?.HandlePointerCaptureLost(e);
         }
 
         /// <summary>

src/Avalonia.Input/MouseDevice.cs

@@ -14,17 +14,18 @@ namespace Avalonia.Input
     /// <summary>
     /// Represents a mouse device.
     /// </summary>
-    public class MouseDevice : IMouseDevice, IPointer
+    public class MouseDevice : IMouseDevice
     {
         private int _clickCount;
         private Rect _lastClickRect;
         private ulong _lastClickTime;
-        private IInputElement _captured;
-        private IDisposable _capturedSubscription;
 
-        PointerType IPointer.Type => PointerType.Mouse;
-        bool IPointer.IsPrimary => true;
-        int IPointer.Id { get; } = Pointer.GetNextFreeId();
+        private readonly Pointer _pointer;
+
+        public MouseDevice(Pointer pointer = null)
+        {
+            _pointer = pointer ?? new Pointer(Pointer.GetNextFreeId(), PointerType.Mouse, true);
+        }
         
         /// <summary>
         /// Gets the control that is currently capturing by the mouse, if any.
@@ -34,27 +35,9 @@ namespace Avalonia.Input
         /// within the control's bounds or not. To set the mouse capture, call the 
         /// <see cref="Capture"/> method.
         /// </remarks>
-        public IInputElement Captured
-        {
-            get => _captured;
-            protected set
-            {
-                _capturedSubscription?.Dispose();
-                _capturedSubscription = null;
-
-                if (value != null)
-                {
-                    _capturedSubscription = Observable.FromEventPattern<VisualTreeAttachmentEventArgs>(
-                        x => value.DetachedFromVisualTree += x,
-                        x => value.DetachedFromVisualTree -= x)
-                        .Take(1)
-                        .Subscribe(_ => Captured = null);
-                }
+        [Obsolete("Use IPointer instead")]
+        public IInputElement Captured => _pointer.Captured;
 
-                _captured = value;
-            }
-        }
-        
         /// <summary>
         /// Gets the mouse position, in screen coordinates.
         /// </summary>
@@ -73,10 +56,9 @@ namespace Avalonia.Input
         /// within the control's bounds or not. The current mouse capture control is exposed
         /// by the <see cref="Captured"/> property.
         /// </remarks>
-        public virtual void Capture(IInputElement control)
+        public void Capture(IInputElement control)
         {
-            // TODO: Check visibility and enabled state before setting capture.
-            Captured = control;
+            _pointer.Capture(control);
         }
 
         /// <summary>
@@ -110,13 +92,13 @@ namespace Avalonia.Input
 
             if (rect.Contains(clientPoint))
             {
-                if (Captured == null)
+                if (_pointer.Captured == null)
                 {
-                    SetPointerOver(this, root, clientPoint, InputModifiers.None);
+                    SetPointerOver(this, 0 /* TODO: proper timestamp */, root, clientPoint, InputModifiers.None);
                 }
                 else
                 {
-                    SetPointerOver(this, root, Captured, InputModifiers.None);
+                    SetPointerOver(this, 0 /* TODO: proper timestamp */, root, _pointer.Captured, InputModifiers.None);
                 }
             }
         }
@@ -144,13 +126,13 @@ namespace Avalonia.Input
             switch (e.Type)
             {
                 case RawPointerEventType.LeaveWindow:
-                    LeaveWindow(mouse, e.Root, e.InputModifiers);
+                    LeaveWindow(mouse, e.Timestamp, e.Root, e.InputModifiers);
                     break;
                 case RawPointerEventType.LeftButtonDown:
                 case RawPointerEventType.RightButtonDown:
                 case RawPointerEventType.MiddleButtonDown:
                     if (ButtonCount(props) > 1)
-                        e.Handled = MouseMove(mouse, e.Root, e.Position, props, e.InputModifiers);
+                        e.Handled = MouseMove(mouse, e.Timestamp, e.Root, e.Position, props, e.InputModifiers);
                     else
                         e.Handled = MouseDown(mouse, e.Timestamp, e.Root, e.Position,
                             props, e.InputModifiers);
@@ -159,25 +141,25 @@ namespace Avalonia.Input
                 case RawPointerEventType.RightButtonUp:
                 case RawPointerEventType.MiddleButtonUp:
                     if (ButtonCount(props) != 0)
-                        e.Handled = MouseMove(mouse, e.Root, e.Position, props, e.InputModifiers);
+                        e.Handled = MouseMove(mouse, e.Timestamp, e.Root, e.Position, props, e.InputModifiers);
                     else
-                        e.Handled = MouseUp(mouse, e.Root, e.Position, props, e.InputModifiers);
+                        e.Handled = MouseUp(mouse, e.Timestamp, e.Root, e.Position, props, e.InputModifiers);
                     break;
                 case RawPointerEventType.Move:
-                    e.Handled = MouseMove(mouse, e.Root, e.Position, props, e.InputModifiers);
+                    e.Handled = MouseMove(mouse, e.Timestamp, e.Root, e.Position, props, e.InputModifiers);
                     break;
                 case RawPointerEventType.Wheel:
-                    e.Handled = MouseWheel(mouse, e.Root, e.Position, props, ((RawMouseWheelEventArgs)e).Delta, e.InputModifiers);
+                    e.Handled = MouseWheel(mouse, e.Timestamp, e.Root, e.Position, props, ((RawMouseWheelEventArgs)e).Delta, e.InputModifiers);
                     break;
             }
         }
 
-        private void LeaveWindow(IMouseDevice device, IInputRoot root, InputModifiers inputModifiers)
+        private void LeaveWindow(IMouseDevice device, ulong timestamp, IInputRoot root, InputModifiers inputModifiers)
         {
             Contract.Requires<ArgumentNullException>(device != null);
             Contract.Requires<ArgumentNullException>(root != null);
 
-            ClearPointerOver(this, root, inputModifiers);
+            ClearPointerOver(this, timestamp, root, inputModifiers);
         }
 
 
@@ -195,7 +177,7 @@ namespace Avalonia.Input
                 rv.IsLeftButtonPressed = false;
             if (args.Type == RawPointerEventType.MiddleButtonUp)
                 rv.IsMiddleButtonPressed = false;
-            if (args.Type == RawPointerEventType.RightButtonDown)
+            if (args.Type == RawPointerEventType.RightButtonUp)
                 rv.IsRightButtonPressed = false;
             return rv;
         }
@@ -212,8 +194,8 @@ namespace Avalonia.Input
 
             if (hit != null)
             {
-                IInteractive source = GetSource(hit);
-
+                _pointer.Capture(hit);
+                var source = GetSource(hit);
                 if (source != null)
                 {
                     var settings = AvaloniaLocator.Current.GetService<IPlatformSettings>();
@@ -229,8 +211,7 @@ namespace Avalonia.Input
                     _lastClickRect = new Rect(p, new Size())
                         .Inflate(new Thickness(settings.DoubleClickSize.Width / 2, settings.DoubleClickSize.Height / 2));
                     _lastMouseDownButton = properties.GetObsoleteMouseButton();
-                    var e = new PointerPressedEventArgs(source, this, root, p, properties, inputModifiers, _clickCount);
-
+                    var e = new PointerPressedEventArgs(source, _pointer, root, p, timestamp, properties, inputModifiers, _clickCount);
                     source.RaiseEvent(e);
                     return e.Handled;
                 }
@@ -239,7 +220,7 @@ namespace Avalonia.Input
             return false;
         }
 
-        private bool MouseMove(IMouseDevice device, IInputRoot root, Point p, PointerPointProperties properties,
+        private bool MouseMove(IMouseDevice device, ulong timestamp, IInputRoot root, Point p, PointerPointProperties properties,
             InputModifiers inputModifiers)
         {
             Contract.Requires<ArgumentNullException>(device != null);
@@ -247,24 +228,24 @@ namespace Avalonia.Input
 
             IInputElement source;
 
-            if (Captured == null)
+            if (_pointer.Captured == null)
             {
-                source = SetPointerOver(this, root, p, inputModifiers);
+                source = SetPointerOver(this, timestamp, root, p, inputModifiers);
             }
             else
             {
-                SetPointerOver(this, root, Captured, inputModifiers);
-                source = Captured;
+                SetPointerOver(this, timestamp, root, _pointer.Captured, inputModifiers);
+                source = _pointer.Captured;
             }
 
-            var e = new PointerEventArgs(InputElement.PointerMovedEvent, source, this, root,
-                p, properties, inputModifiers);
+            var e = new PointerEventArgs(InputElement.PointerMovedEvent, source, _pointer, root,
+                p, timestamp, properties, inputModifiers);
 
             source?.RaiseEvent(e);
             return e.Handled;
         }
 
-        private bool MouseUp(IMouseDevice device, IInputRoot root, Point p, PointerPointProperties props,
+        private bool MouseUp(IMouseDevice device, ulong timestamp, IInputRoot root, Point p, PointerPointProperties props,
             InputModifiers inputModifiers)
         {
             Contract.Requires<ArgumentNullException>(device != null);
@@ -275,16 +256,18 @@ namespace Avalonia.Input
             if (hit != null)
             {
                 var source = GetSource(hit);
-                var e = new PointerReleasedEventArgs(source, this, root, p, props, inputModifiers, _lastMouseDownButton);
+                var e = new PointerReleasedEventArgs(source, _pointer, root, p, timestamp, props, inputModifiers,
+                    _lastMouseDownButton);
 
                 source?.RaiseEvent(e);
+                _pointer.Capture(null);
                 return e.Handled;
             }
 
             return false;
         }
 
-        private bool MouseWheel(IMouseDevice device, IInputRoot root, Point p,
+        private bool MouseWheel(IMouseDevice device, ulong timestamp, IInputRoot root, Point p,
             PointerPointProperties props,
             Vector delta, InputModifiers inputModifiers)
         {
@@ -296,7 +279,7 @@ namespace Avalonia.Input
             if (hit != null)
             {
                 var source = GetSource(hit);
-                var e = new PointerWheelEventArgs(source, this, root, p, props, inputModifiers, delta);
+                var e = new PointerWheelEventArgs(source, _pointer, root, p, timestamp, props, inputModifiers, delta);
 
                 source?.RaiseEvent(e);
                 return e.Handled;
@@ -309,7 +292,7 @@ namespace Avalonia.Input
         {
             Contract.Requires<ArgumentNullException>(hit != null);
 
-            return Captured ??
+            return _pointer.Captured ??
                 (hit as IInteractive) ??
                 hit.GetSelfAndVisualAncestors().OfType<IInteractive>().FirstOrDefault();
         }
@@ -318,22 +301,22 @@ namespace Avalonia.Input
         {
             Contract.Requires<ArgumentNullException>(root != null);
 
-            return Captured ?? root.InputHitTest(p);
+            return _pointer.Captured ?? root.InputHitTest(p);
         }
 
-        PointerEventArgs CreateSimpleEvent(RoutedEvent ev, IInteractive source, InputModifiers inputModifiers)
+        PointerEventArgs CreateSimpleEvent(RoutedEvent ev, ulong timestamp, IInteractive source, InputModifiers inputModifiers)
         {
-            return new PointerEventArgs(ev, source, this, null, default,
-                new PointerPointProperties(inputModifiers), inputModifiers);
+            return new PointerEventArgs(ev, source, _pointer, null, default,
+                timestamp, new PointerPointProperties(inputModifiers), inputModifiers);
         }
 
-        private void ClearPointerOver(IPointerDevice device, IInputRoot root, InputModifiers inputModifiers)
+        private void ClearPointerOver(IPointerDevice device, ulong timestamp, IInputRoot root, InputModifiers inputModifiers)
         {
             Contract.Requires<ArgumentNullException>(device != null);
             Contract.Requires<ArgumentNullException>(root != null);
 
             var element = root.PointerOverElement;
-            var e = CreateSimpleEvent(InputElement.PointerLeaveEvent, element, inputModifiers);
+            var e = CreateSimpleEvent(InputElement.PointerLeaveEvent, timestamp, element, inputModifiers);
 
             if (element!=null && !element.IsAttachedToVisualTree)
             {
@@ -370,7 +353,7 @@ namespace Avalonia.Input
             }
         }
 
-        private IInputElement SetPointerOver(IPointerDevice device, IInputRoot root, Point p, InputModifiers inputModifiers)
+        private IInputElement SetPointerOver(IPointerDevice device, ulong timestamp, IInputRoot root, Point p, InputModifiers inputModifiers)
         {
             Contract.Requires<ArgumentNullException>(device != null);
             Contract.Requires<ArgumentNullException>(root != null);
@@ -381,18 +364,18 @@ namespace Avalonia.Input
             {
                 if (element != null)
                 {
-                    SetPointerOver(device, root, element, inputModifiers);
+                    SetPointerOver(device, timestamp, root, element, inputModifiers);
                 }
                 else
                 {
-                    ClearPointerOver(device, root, inputModifiers);
+                    ClearPointerOver(device, timestamp, root, inputModifiers);
                 }
             }
 
             return element;
         }
 
-        private void SetPointerOver(IPointerDevice device, IInputRoot root, IInputElement element, InputModifiers inputModifiers)
+        private void SetPointerOver(IPointerDevice device, ulong timestamp, IInputRoot root, IInputElement element, InputModifiers inputModifiers)
         {
             Contract.Requires<ArgumentNullException>(device != null);
             Contract.Requires<ArgumentNullException>(root != null);
@@ -414,7 +397,7 @@ namespace Avalonia.Input
 
             el = root.PointerOverElement;
 
-            var e = CreateSimpleEvent(InputElement.PointerLeaveEvent, el, inputModifiers);
+            var e = CreateSimpleEvent(InputElement.PointerLeaveEvent, timestamp, el, inputModifiers);
             if (el!=null && branch!=null && !el.IsAttachedToVisualTree)
             {
                 ClearChildrenPointerOver(e,branch,false);

src/Avalonia.Input/Pointer.cs

@@ -1,5 +1,7 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
+using Avalonia.Interactivity;
 using Avalonia.VisualTree;
 
 namespace Avalonia.Input
@@ -9,23 +11,46 @@ namespace Avalonia.Input
         private static int s_NextFreePointerId = 1000;
         public static int GetNextFreeId() => s_NextFreePointerId++;
         
-        public Pointer(int id, PointerType type, bool isPrimary, IInputElement implicitlyCaptured)
+        public Pointer(int id, PointerType type, bool isPrimary)
         {
             Id = id;
             Type = type;
             IsPrimary = isPrimary;
-            ImplicitlyCaptured = implicitlyCaptured;
-            if (ImplicitlyCaptured != null)
-                ImplicitlyCaptured.DetachedFromVisualTree += OnImplicitCaptureDetached;
         }
 
         public int Id { get; }
 
+        IInputElement FindCommonParent(IInputElement control1, IInputElement control2)
+        {
+            if (control1 == null || control2 == null)
+                return null;
+            var seen = new HashSet<IInputElement>(control1.GetSelfAndVisualAncestors().OfType<IInputElement>());
+            return control2.GetSelfAndVisualAncestors().OfType<IInputElement>().FirstOrDefault(seen.Contains);
+        }
+
+        protected virtual void PlatformCapture(IInputElement element)
+        {
+            
+        }
+        
         public void Capture(IInputElement control)
         {
             if (Captured != null)
                 Captured.DetachedFromVisualTree -= OnCaptureDetached;
+            var oldCapture = control;
             Captured = control;
+            PlatformCapture(control);
+            if (oldCapture != null)
+            {
+                var commonParent = FindCommonParent(control, oldCapture);
+                foreach (var notifyTarget in oldCapture.GetSelfAndVisualAncestors().OfType<IInputElement>())
+                {
+                    if (notifyTarget == commonParent)
+                        break;
+                    notifyTarget.RaiseEvent(new PointerCaptureLostEventArgs(notifyTarget, this));
+                }
+            }
+
             if (Captured != null)
                 Captured.DetachedFromVisualTree += OnCaptureDetached;
         }
@@ -38,26 +63,11 @@ namespace Avalonia.Input
             Capture(GetNextCapture(e.Parent));
         }
 
-        private void OnImplicitCaptureDetached(object sender, VisualTreeAttachmentEventArgs e)
-        {
-            ImplicitlyCaptured.DetachedFromVisualTree -= OnImplicitCaptureDetached;
-            ImplicitlyCaptured = GetNextCapture(e.Parent);
-            if (ImplicitlyCaptured != null)
-                ImplicitlyCaptured.DetachedFromVisualTree += OnImplicitCaptureDetached;
-        }
 
         public IInputElement Captured { get; private set; }
-        public IInputElement ImplicitlyCaptured { get; private set; }
-        public IInputElement GetEffectiveCapture() => Captured ?? ImplicitlyCaptured;
             
         public PointerType Type { get; }
         public bool IsPrimary { get; }
-        public void Dispose()
-        {
-            if (ImplicitlyCaptured != null)
-                ImplicitlyCaptured.DetachedFromVisualTree -= OnImplicitCaptureDetached;
-            if (Captured != null)
-                Captured.DetachedFromVisualTree -= OnCaptureDetached;
-        }
+        public void Dispose() => Capture(null);
     }
 }

src/Avalonia.Input/PointerEventArgs.cs

@@ -17,7 +17,9 @@ namespace Avalonia.Input
         public PointerEventArgs(RoutedEvent routedEvent,
             IInteractive source,
             IPointer pointer,
-            IVisual rootVisual, Point rootVisualPosition, PointerPointProperties properties,
+            IVisual rootVisual, Point rootVisualPosition,
+            ulong timestamp,
+            PointerPointProperties properties,
             InputModifiers modifiers)
            : base(routedEvent)
         {
@@ -26,6 +28,7 @@ namespace Avalonia.Input
             _rootVisualPosition = rootVisualPosition;
             _properties = properties;
             Pointer = pointer;
+            Timestamp = timestamp;
             InputModifiers = modifiers;
         }
 
@@ -50,6 +53,7 @@ namespace Avalonia.Input
         }
 
         public IPointer Pointer { get; }
+        public ulong Timestamp { get; }
 
         private IPointerDevice _device;
 
@@ -86,11 +90,13 @@ namespace Avalonia.Input
         public PointerPressedEventArgs(
             IInteractive source,
             IPointer pointer,
-            IVisual rootVisual, Point rootVisualPosition, PointerPointProperties properties,
+            IVisual rootVisual, Point rootVisualPosition,
+            ulong timestamp,
+            PointerPointProperties properties,
             InputModifiers modifiers,
             int obsoleteClickCount = 1)
-            : base(InputElement.PointerPressedEvent, source, pointer, rootVisual, rootVisualPosition, properties,
-                modifiers)
+            : base(InputElement.PointerPressedEvent, source, pointer, rootVisual, rootVisualPosition,
+                timestamp, properties, modifiers)
         {
             _obsoleteClickCount = obsoleteClickCount;
         }
@@ -105,10 +111,10 @@ namespace Avalonia.Input
     {
         public PointerReleasedEventArgs(
             IInteractive source, IPointer pointer,
-            IVisual rootVisual, Point rootVisualPosition, PointerPointProperties properties, InputModifiers modifiers,
-            MouseButton obsoleteMouseButton)
+            IVisual rootVisual, Point rootVisualPosition, ulong timestamp,
+            PointerPointProperties properties, InputModifiers modifiers, MouseButton obsoleteMouseButton)
             : base(InputElement.PointerReleasedEvent, source, pointer, rootVisual, rootVisualPosition,
-                properties, modifiers)
+                timestamp, properties, modifiers)
         {
             MouseButton = obsoleteMouseButton;
         }
@@ -116,4 +122,15 @@ namespace Avalonia.Input
         [Obsolete()]
         public MouseButton MouseButton { get; private set; }
     }
+
+    public class PointerCaptureLostEventArgs : RoutedEventArgs
+    {
+        public IPointer Pointer { get; }
+
+        public PointerCaptureLostEventArgs(IInteractive source, IPointer pointer) : base(InputElement.PointerCaptureLostEvent)
+        {
+            Pointer = pointer;
+            Source = source;
+        }
+    }
 }

src/Avalonia.Input/PointerWheelEventArgs.cs

@@ -11,9 +11,10 @@ namespace Avalonia.Input
         public Vector Delta { get; set; }
 
         public PointerWheelEventArgs(IInteractive source, IPointer pointer, IVisual rootVisual,
-            Point rootVisualPosition,
+            Point rootVisualPosition, ulong timestamp,
             PointerPointProperties properties, InputModifiers modifiers, Vector delta) 
-            : base(InputElement.PointerWheelChangedEvent, source, pointer, rootVisual, rootVisualPosition, properties, modifiers)
+            : base(InputElement.PointerWheelChangedEvent, source, pointer, rootVisual, rootVisualPosition,
+                timestamp, properties, modifiers)
         {
             Delta = delta;
         }

src/Avalonia.Input/Properties/AssemblyInfo.cs

@@ -5,3 +5,4 @@ using System.Reflection;
 using Avalonia.Metadata;
 
 [assembly: XmlnsDefinition("https://github.com/avaloniaui", "Avalonia.Input")]
+[assembly: XmlnsDefinition("https://github.com/avaloniaui", "Avalonia.Input.GestureRecognizers")]

src/Avalonia.Input/ScrollGestureEventArgs.cs

@@ -0,0 +1,29 @@
+using Avalonia.Interactivity;
+
+namespace Avalonia.Input
+{
+    public class ScrollGestureEventArgs : RoutedEventArgs
+    {
+        public int Id { get; }
+        public Vector Delta { get; }
+        private static int _nextId = 1;
+
+        public static int GetNextFreeId() => _nextId++;
+        
+        public ScrollGestureEventArgs(int id, Vector delta) : base(Gestures.ScrollGestureEvent)
+        {
+            Id = id;
+            Delta = delta;
+        }
+    }
+
+    public class ScrollGestureEndedEventArgs : RoutedEventArgs
+    {
+        public int Id { get; }
+
+        public ScrollGestureEndedEventArgs(int id) : base(Gestures.ScrollGestureEndedEvent)
+        {
+            Id = id;
+        }
+    }
+}

src/Avalonia.Input/TouchDevice.cs

@@ -35,28 +35,30 @@ namespace Avalonia.Input
                 var hit = args.Root.InputHitTest(args.Position);
 
                 _pointers[args.TouchPointId] = pointer = new Pointer(Pointer.GetNextFreeId(),
-                    PointerType.Touch, _pointers.Count == 0, hit);
+                    PointerType.Touch, _pointers.Count == 0);
+                pointer.Capture(hit);
             }
             
 
-            var target = pointer.GetEffectiveCapture() ?? args.Root;
+            var target = pointer.Captured ?? args.Root;
             if (args.Type == RawPointerEventType.TouchBegin)
             {
-                var modifiers = GetModifiers(args.InputModifiers, false);
                 target.RaiseEvent(new PointerPressedEventArgs(target, pointer,
-                    args.Root, args.Position, new PointerPointProperties(modifiers),
-                    modifiers));
+                    args.Root, args.Position, ev.Timestamp,
+                    new PointerPointProperties(GetModifiers(args.InputModifiers, pointer.IsPrimary)),
+                    GetModifiers(args.InputModifiers, false)));
             }
 
             if (args.Type == RawPointerEventType.TouchEnd)
             {
                 _pointers.Remove(args.TouchPointId);
-                var modifiers = GetModifiers(args.InputModifiers, pointer.IsPrimary);
                 using (pointer)
                 {
                     target.RaiseEvent(new PointerReleasedEventArgs(target, pointer,
-                        args.Root, args.Position, new PointerPointProperties(modifiers),
-                        modifiers, pointer.IsPrimary ? MouseButton.Left : MouseButton.None));
+                        args.Root, args.Position, ev.Timestamp,
+                        new PointerPointProperties(GetModifiers(args.InputModifiers, false)),
+                        GetModifiers(args.InputModifiers, pointer.IsPrimary),
+                        pointer.IsPrimary ? MouseButton.Left : MouseButton.None));
                 }
             }
 
@@ -64,7 +66,7 @@ namespace Avalonia.Input
             {
                 var modifiers = GetModifiers(args.InputModifiers, pointer.IsPrimary);
                 target.RaiseEvent(new PointerEventArgs(InputElement.PointerMovedEvent, target, pointer, args.Root,
-                    args.Position, new PointerPointProperties(modifiers), modifiers));
+                    args.Position, ev.Timestamp, new PointerPointProperties(modifiers), modifiers));
             }
         }
         

src/Avalonia.OpenGL/AngleOptions.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+
+namespace Avalonia.OpenGL
+{
+    public class AngleOptions
+    {
+        public enum PlatformApi
+        {
+			DirectX9,
+			DirectX11
+        }
+
+        public List<PlatformApi> AllowedPlatformApis = new List<PlatformApi>
+        {
+            PlatformApi.DirectX9
+        };
+    }
+}

src/Avalonia.OpenGL/EglDisplay.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Runtime.InteropServices;
 using Avalonia.Platform.Interop;
 using static Avalonia.OpenGL.EglConsts;
@@ -13,21 +14,42 @@ namespace Avalonia.OpenGL
         private readonly int[] _contextAttributes;
 
         public IntPtr Handle => _display;
+        private AngleOptions.PlatformApi? _angleApi;
         public EglDisplay(EglInterface egl)
         {
             _egl = egl;  
 
-            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && _egl.GetPlatformDisplayEXT != null)
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
-                foreach (var dapi in new[] {EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE, EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE})
+                if (_egl.GetPlatformDisplayEXT == null)
+                    throw new OpenGlException("eglGetPlatformDisplayEXT is not supported by libegl.dll");
+                
+                var allowedApis = AvaloniaLocator.Current.GetService<AngleOptions>()?.AllowedPlatformApis
+                              ?? new List<AngleOptions.PlatformApi> {AngleOptions.PlatformApi.DirectX9};              
+                
+                foreach (var platformApi in allowedApis)
                 {
+                    int dapi;
+                    if (platformApi == AngleOptions.PlatformApi.DirectX9)
+                        dapi = EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE;
+                    else if (platformApi == AngleOptions.PlatformApi.DirectX11)
+                        dapi = EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE;
+                    else 
+                        continue;
+                    
                     _display = _egl.GetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE, IntPtr.Zero, new[]
                     {
                         EGL_PLATFORM_ANGLE_TYPE_ANGLE, dapi, EGL_NONE
                     });
-                    if(_display != IntPtr.Zero)
+                    if (_display != IntPtr.Zero)
+                    {
+                        _angleApi = platformApi;
                         break;
+                    }
                 }
+
+                if (_display == IntPtr.Zero)
+                    throw new OpenGlException("Unable to create ANGLE display");
             }
 
             if (_display == IntPtr.Zero)
@@ -64,29 +86,35 @@ namespace Avalonia.OpenGL
                 if (!_egl.BindApi(cfg.Api))
                     continue;
 
-                var attribs = new[]
+                foreach(var stencilSize in new[]{8, 1, 0})
+                foreach (var depthSize in new []{8, 1, 0})
                 {
-                    EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
-                    EGL_RENDERABLE_TYPE, cfg.RenderableTypeBit,
-                    EGL_RED_SIZE, 8,
-                    EGL_GREEN_SIZE, 8,
-                    EGL_BLUE_SIZE, 8,
-                    EGL_ALPHA_SIZE, 8,
-                    EGL_STENCIL_SIZE, 8,
-                    EGL_DEPTH_SIZE, 8,
-                    EGL_NONE
-                };
-                if (!_egl.ChooseConfig(_display, attribs, out _config, 1, out int numConfigs))
-                    continue;
-                if (numConfigs == 0)
-                    continue;
-                _contextAttributes = cfg.Attributes;
-                Type = cfg.Type;
+                    var attribs = new[]
+                    {
+                        EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
+
+                        EGL_RENDERABLE_TYPE, cfg.RenderableTypeBit,
+
+                        EGL_RED_SIZE, 8,
+                        EGL_GREEN_SIZE, 8,
+                        EGL_BLUE_SIZE, 8,
+                        EGL_ALPHA_SIZE, 8,
+                        EGL_STENCIL_SIZE, stencilSize,
+                        EGL_DEPTH_SIZE, depthSize,
+                        EGL_NONE
+                    };
+                    if (!_egl.ChooseConfig(_display, attribs, out _config, 1, out int numConfigs))
+                        continue;
+                    if (numConfigs == 0)
+                        continue;
+                    _contextAttributes = cfg.Attributes;
+                    Type = cfg.Type;
+                }
             }
 
             if (_contextAttributes == null)
                 throw new OpenGlException("No suitable EGL config was found");
-
+               
             GlInterface = GlInterface.FromNativeUtf8GetProcAddress(b => _egl.GetProcAddress(b));
         }
 
@@ -97,6 +125,7 @@ namespace Avalonia.OpenGL
         
         public GlDisplayType Type { get; }
         public GlInterface GlInterface { get; }
+        public EglInterface EglInterface => _egl;
         public IGlContext CreateContext(IGlContext share)
         {
             var shareCtx = (EglContext)share;

src/Avalonia.OpenGL/EglGlPlatformSurface.cs

@@ -26,31 +26,44 @@ namespace Avalonia.OpenGL
         public IGlPlatformSurfaceRenderTarget CreateGlRenderTarget()
         {
             var glSurface = _display.CreateWindowSurface(_info.Handle);
-            return new RenderTarget(_context, glSurface, _info);
+            return new RenderTarget(_display, _context, glSurface, _info);
         }
 
-        class RenderTarget : IGlPlatformSurfaceRenderTarget
+        class RenderTarget : IGlPlatformSurfaceRenderTargetWithCorruptionInfo
         {
+            private readonly EglDisplay _display;
             private readonly EglContext _context;
             private readonly EglSurface _glSurface;
             private readonly IEglWindowGlPlatformSurfaceInfo _info;
+            private PixelSize _initialSize;
 
-            public RenderTarget(EglContext context, EglSurface glSurface, IEglWindowGlPlatformSurfaceInfo info)
+            public RenderTarget(EglDisplay display, EglContext context,
+                EglSurface glSurface, IEglWindowGlPlatformSurfaceInfo info)
             {
+                _display = display;
                 _context = context;
                 _glSurface = glSurface;
                 _info = info;
+                _initialSize = info.Size;
             }
 
             public void Dispose() => _glSurface.Dispose();
 
+            public bool IsCorrupted => _initialSize != _info.Size;
+            
             public IGlPlatformSurfaceRenderingSession BeginDraw()
             {
                 var l = _context.Lock();
                 try
                 {
+                    if (IsCorrupted)
+                        throw new RenderTargetCorruptedException();
                     _context.MakeCurrent(_glSurface);
-                    return new Session(_context, _glSurface, _info, l);
+                    _display.EglInterface.WaitClient();
+                    _display.EglInterface.WaitGL();
+                    _display.EglInterface.WaitNative();
+                    
+                    return new Session(_display, _context, _glSurface, _info, l);
                 }
                 catch
                 {
@@ -61,15 +74,19 @@ namespace Avalonia.OpenGL
             
             class Session : IGlPlatformSurfaceRenderingSession
             {
-                private readonly IGlContext _context;
+                private readonly EglContext _context;
                 private readonly EglSurface _glSurface;
                 private readonly IEglWindowGlPlatformSurfaceInfo _info;
+                private readonly EglDisplay _display;
                 private IDisposable _lock;
+                
 
-                public Session(IGlContext context, EglSurface glSurface, IEglWindowGlPlatformSurfaceInfo info,
+                public Session(EglDisplay display, EglContext context,
+                    EglSurface glSurface, IEglWindowGlPlatformSurfaceInfo info,
                     IDisposable @lock)
                 {
                     _context = context;
+                    _display = display;
                     _glSurface = glSurface;
                     _info = info;
                     _lock = @lock;
@@ -78,7 +95,11 @@ namespace Avalonia.OpenGL
                 public void Dispose()
                 {
                     _context.Display.GlInterface.Flush();
+                    _display.EglInterface.WaitGL();
                     _glSurface.SwapBuffers();
+                    _display.EglInterface.WaitClient();
+                    _display.EglInterface.WaitGL();
+                    _display.EglInterface.WaitNative();
                     _context.Display.ClearContext();
                     _lock.Dispose();
                 }

src/Avalonia.OpenGL/EglInterface.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Runtime.InteropServices;
 using Avalonia.Platform;
 using Avalonia.Platform.Interop;
 
@@ -15,13 +16,28 @@ namespace Avalonia.OpenGL
         {
         }
 
+        [DllImport("libegl.dll", CharSet = CharSet.Ansi)]
+        static extern IntPtr eglGetProcAddress(string proc);
+        
         static Func<string, bool, IntPtr> Load()
         {
             var os = AvaloniaLocator.Current.GetService<IRuntimePlatform>().GetRuntimeInfo().OperatingSystem;
             if(os == OperatingSystemType.Linux || os == OperatingSystemType.Android)
                 return Load("libEGL.so.1");
             if (os == OperatingSystemType.WinNT)
-                return Load(@"libegl.dll");
+            {
+                var disp = eglGetProcAddress("eglGetPlatformDisplayEXT");
+                if (disp == IntPtr.Zero)
+                    throw new OpenGlException("libegl.dll doesn't have eglGetPlatformDisplayEXT entry point");
+                return (name, optional) =>
+                {
+                    var r = eglGetProcAddress(name);
+                    if (r == IntPtr.Zero && !optional)
+                        throw new OpenGlException($"Entry point {r} is not found");
+                    return r;
+                };
+            }
+
             throw new PlatformNotSupportedException();
         }
 
@@ -91,6 +107,31 @@ namespace Avalonia.OpenGL
         [GlEntryPoint("eglGetConfigAttrib")]
         public EglGetConfigAttrib GetConfigAttrib { get; }
 
+        public delegate bool EglWaitGL();
+        [GlEntryPoint("eglWaitGL")]
+        public EglWaitGL WaitGL { get; }
+        
+        public delegate bool EglWaitClient();
+        [GlEntryPoint("eglWaitClient")]
+        public EglWaitGL WaitClient { get; }
+        
+        public delegate bool EglWaitNative();
+        [GlEntryPoint("eglWaitNative")]
+        public EglWaitGL WaitNative { get; }
+        
+        public delegate IntPtr EglQueryString(IntPtr display, int i);
+        
+        [GlEntryPoint("eglQueryString")]
+        public EglQueryString QueryStringNative { get; }
+
+        public string QueryString(IntPtr display, int i)
+        {
+            var rv = QueryStringNative(display, i);
+            if (rv == IntPtr.Zero)
+                return null;
+            return Marshal.PtrToStringAnsi(rv);
+        }
+
         // ReSharper restore UnassignedGetOnlyAutoProperty
     }
 }

src/Avalonia.OpenGL/IGlPlatformSurfaceRenderTarget.cs

@@ -6,4 +6,9 @@ namespace Avalonia.OpenGL
     {
         IGlPlatformSurfaceRenderingSession BeginDraw();
     }
-}
+
+    public interface IGlPlatformSurfaceRenderTargetWithCorruptionInfo : IGlPlatformSurfaceRenderTarget
+    {
+        bool IsCorrupted { get; }
+    }
+}

src/Avalonia.ReactiveUI/AppBuilderExtensions.cs

@@ -21,9 +21,8 @@ namespace Avalonia.ReactiveUI
             return builder.AfterSetup(_ =>
             {
                 RxApp.MainThreadScheduler = AvaloniaScheduler.Instance;
-                Locator.CurrentMutable.Register(
-                    () => new AvaloniaActivationForViewFetcher(), 
-                    typeof(IActivationForViewFetcher));
+                Locator.CurrentMutable.RegisterConstant(new AvaloniaActivationForViewFetcher(), typeof(IActivationForViewFetcher));
+                Locator.CurrentMutable.RegisterConstant(new AutoDataTemplateBindingHook(), typeof(IPropertyBindingHook));
             });
         }
     }

src/Avalonia.ReactiveUI/AutoDataTemplateBindingHook.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Controls.Templates;
+using Avalonia.Layout;
+using Avalonia.Markup.Xaml;
+using Avalonia.Markup.Xaml.Templates;
+using ReactiveUI;
+
+namespace Avalonia.ReactiveUI
+{
+    /// <summary>
+    /// AutoDataTemplateBindingHook is a binding hook that checks ItemsControls
+    /// that don't have DataTemplates, and assigns a default DataTemplate that
+    /// loads the View associated with each ViewModel.
+    /// </summary>
+    public class AutoDataTemplateBindingHook : IPropertyBindingHook
+    {
+        private static FuncDataTemplate DefaultItemTemplate = new FuncDataTemplate<object>(x =>
+        {
+            var control = new ViewModelViewHost();
+            var context = control.GetObservable(Control.DataContextProperty);
+            control.Bind(ViewModelViewHost.ViewModelProperty, context);
+            control.HorizontalContentAlignment = HorizontalAlignment.Stretch;
+            control.VerticalContentAlignment = VerticalAlignment.Stretch;
+            return control;
+        },
+        true);
+
+        /// <inheritdoc/>
+        public bool ExecuteHook(
+            object source, object target,
+            Func<IObservedChange<object, object>[]> getCurrentViewModelProperties,
+            Func<IObservedChange<object, object>[]> getCurrentViewProperties,
+            BindingDirection direction)
+        {
+            var viewProperties = getCurrentViewProperties();
+            var lastViewProperty = viewProperties.LastOrDefault();
+            var itemsControl = lastViewProperty?.Sender as ItemsControl;
+            if (itemsControl == null)
+                return true;
+
+            var propertyName = viewProperties.Last().GetPropertyName();
+            if (propertyName != "Items" &&
+                propertyName != "ItemsSource")
+                return true;
+            
+            if (itemsControl.ItemTemplate != null)
+                return true;
+
+            itemsControl.ItemTemplate = DefaultItemTemplate;
+            return true;
+        }
+    }
+}

src/Avalonia.ReactiveUI/RoutedViewHost.cs

@@ -53,33 +53,13 @@ namespace Avalonia.ReactiveUI
     /// ReactiveUI routing documentation website</see> for more info.
     /// </para>
     /// </remarks>
-    public class RoutedViewHost : UserControl, IActivatable, IEnableLogger
+    public class RoutedViewHost : TransitioningContentControl, IActivatable, IEnableLogger
     {
         /// <summary>
-        /// The router dependency property.
+        /// <see cref="AvaloniaProperty"/> for the <see cref="Router"/> property.
         /// </summary>
         public static readonly AvaloniaProperty<RoutingState> RouterProperty =
             AvaloniaProperty.Register<RoutedViewHost, RoutingState>(nameof(Router));
-        
-        /// <summary>
-        /// The default content property.
-        /// </summary> 
-        public static readonly AvaloniaProperty<object> DefaultContentProperty =
-            AvaloniaProperty.Register<RoutedViewHost, object>(nameof(DefaultContent));
-
-        /// <summary>
-        /// Fade in animation property.
-        /// </summary>
-        public static readonly AvaloniaProperty<IAnimation> FadeInAnimationProperty =
-            AvaloniaProperty.Register<RoutedViewHost, IAnimation>(nameof(DefaultContent),
-                CreateOpacityAnimation(0d, 1d, TimeSpan.FromSeconds(0.25)));
-
-        /// <summary>
-        /// Fade out animation property.
-        /// </summary>
-        public static readonly AvaloniaProperty<IAnimation> FadeOutAnimationProperty =
-            AvaloniaProperty.Register<RoutedViewHost, IAnimation>(nameof(DefaultContent),
-                CreateOpacityAnimation(1d, 0d, TimeSpan.FromSeconds(0.25)));
     
         /// <summary>
         /// Initializes a new instance of the <see cref="RoutedViewHost"/> class.
@@ -104,42 +84,6 @@ namespace Avalonia.ReactiveUI
             set => SetValue(RouterProperty, value);
         }
         
-        /// <summary>
-        /// Gets or sets the content displayed whenever there is no page currently routed.
-        /// </summary>
-        public object DefaultContent
-        {
-            get => GetValue(DefaultContentProperty);
-            set => SetValue(DefaultContentProperty, value);
-        }
-
-        /// <summary>
-        /// Gets or sets the animation played when page appears.
-        /// </summary>
-        public IAnimation FadeInAnimation
-        {
-            get => GetValue(FadeInAnimationProperty);
-            set => SetValue(FadeInAnimationProperty, value);
-        }
-
-        /// <summary>
-        /// Gets or sets the animation played when page disappears.
-        /// </summary>
-        public IAnimation FadeOutAnimation
-        {
-            get => GetValue(FadeOutAnimationProperty);
-            set => SetValue(FadeOutAnimationProperty, value);
-        }
-    
-        /// <summary>
-        /// Duplicates the Content property with a private setter.
-        /// </summary>
-        public new object Content
-        {
-            get => base.Content;
-            private set => base.Content = value;
-        }
-
         /// <summary>
         /// Gets or sets the ReactiveUI view locator used by this router.
         /// </summary>
@@ -149,82 +93,29 @@ namespace Avalonia.ReactiveUI
         /// Invoked when ReactiveUI router navigates to a view model.
         /// </summary>
         /// <param name="viewModel">ViewModel to which the user navigates.</param>
-        /// <exception cref="Exception">
-        /// Thrown when ViewLocator is unable to find the appropriate view.
-        /// </exception>
-        private void NavigateToViewModel(IRoutableViewModel viewModel)
+        private void NavigateToViewModel(object viewModel)
         {
             if (viewModel == null)
             {
-                this.Log().Info("ViewModel is null, falling back to default content.");
-                UpdateContent(DefaultContent);
+                this.Log().Info("ViewModel is null. Falling back to default content.");
+                Content = DefaultContent;
                 return;
             }
     
             var viewLocator = ViewLocator ?? global::ReactiveUI.ViewLocator.Current;
-            var view = viewLocator.ResolveView(viewModel);
-            if (view == null) throw new Exception($"Couldn't find view for '{viewModel}'. Is it registered?");
+            var viewInstance = viewLocator.ResolveView(viewModel);
+            if (viewInstance == null)
+            {
+                this.Log().Warn($"Couldn't find view for '{viewModel}'. Is it registered? Falling back to default content.");
+                Content = DefaultContent;
+                return;
+            }
     
-            this.Log().Info($"Ready to show {view} with autowired {viewModel}.");
-            view.ViewModel = viewModel;
-            if (view is IStyledElement styled)
+            this.Log().Info($"Ready to show {viewInstance} with autowired {viewModel}.");
+            viewInstance.ViewModel = viewModel;
+            if (viewInstance is IStyledElement styled)
                 styled.DataContext = viewModel;
-            UpdateContent(view);
-        }
-    
-        /// <summary>
-        /// Updates the content with transitions.
-        /// </summary>
-        /// <param name="newContent">New content to set.</param>
-        private async void UpdateContent(object newContent)
-        {
-            if (FadeOutAnimation != null)
-                await FadeOutAnimation.RunAsync(this, Clock);
-            Content = newContent;
-            if (FadeInAnimation != null)
-                await FadeInAnimation.RunAsync(this, Clock);
-        }
-    
-        /// <summary>
-        /// Creates opacity animation for this routed view host.
-        /// </summary>
-        /// <param name="from">Opacity to start from.</param>
-        /// <param name="to">Opacity to finish with.</param>
-        /// <param name="duration">Duration of the animation.</param>
-        /// <returns>Animation object instance.</returns>
-        private static IAnimation CreateOpacityAnimation(double from, double to, TimeSpan duration) 
-        {
-            return new Avalonia.Animation.Animation
-            {
-                Duration = duration,
-                Children =
-                {
-                    new KeyFrame
-                    {
-                        Setters =
-                        {
-                            new Setter
-                            {
-                                Property = OpacityProperty,
-                                Value = from
-                            }
-                        },
-                        Cue = new Cue(0d)
-                    },
-                    new KeyFrame
-                    {
-                        Setters =
-                        {
-                            new Setter
-                            {
-                                Property = OpacityProperty,
-                                Value = to
-                            }
-                        },
-                        Cue = new Cue(1d)
-                    }
-                }
-            };
+            Content = viewInstance;
         }
     }
-}
+}

src/Avalonia.ReactiveUI/TransitioningContentControl.cs

@@ -0,0 +1,75 @@
+// 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.
+
+using System;
+using Avalonia.Animation;
+using Avalonia.Controls;
+using Avalonia.Styling;
+
+namespace Avalonia.ReactiveUI
+{
+    /// <summary>
+    /// A ContentControl that animates the transition when its content is changed.
+    /// </summary>
+    public class TransitioningContentControl : ContentControl, IStyleable
+    {
+        /// <summary>
+        /// <see cref="AvaloniaProperty"/> for the <see cref="PageTransition"/> property.
+        /// </summary>
+        public static readonly AvaloniaProperty<IPageTransition> PageTransitionProperty =
+            AvaloniaProperty.Register<TransitioningContentControl, IPageTransition>(nameof(PageTransition),
+                new CrossFade(TimeSpan.FromSeconds(0.5)));
+
+        /// <summary>
+        /// <see cref="AvaloniaProperty"/> for the <see cref="DefaultContent"/> property.
+        /// </summary>
+        public static readonly AvaloniaProperty<object> DefaultContentProperty =
+            AvaloniaProperty.Register<TransitioningContentControl, object>(nameof(DefaultContent));
+        
+        /// <summary>
+        /// Gets or sets the animation played when content appears and disappears.
+        /// </summary>
+        public IPageTransition PageTransition
+        {
+            get => GetValue(PageTransitionProperty);
+            set => SetValue(PageTransitionProperty, value);
+        }
+
+        /// <summary>
+        /// Gets or sets the content displayed whenever there is no page currently routed.
+        /// </summary>
+        public object DefaultContent
+        {
+            get => GetValue(DefaultContentProperty);
+            set => SetValue(DefaultContentProperty, value);
+        }
+
+        /// <summary>
+        /// Gets or sets the content with animation.
+        /// </summary>
+        public new object Content
+        {
+            get => base.Content;
+            set => UpdateContentWithTransition(value);
+        }
+        
+        /// <summary>
+        /// TransitioningContentControl uses the default ContentControl 
+        /// template from Avalonia default theme.
+        /// </summary>
+        Type IStyleable.StyleKey => typeof(ContentControl);
+
+        /// <summary>
+        /// Updates the content with transitions.
+        /// </summary>
+        /// <param name="content">New content to set.</param>
+        private async void UpdateContentWithTransition(object content)
+        {
+            if (PageTransition != null)
+                await PageTransition.Start(this, null, true);
+            base.Content = content;
+            if (PageTransition != null)
+                await PageTransition.Start(null, this, true);
+        }
+    }
+}

src/Avalonia.ReactiveUI/ViewModelViewHost.cs

@@ -0,0 +1,80 @@
+// 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.
+
+using System;
+using System.Reactive.Disposables;
+using ReactiveUI;
+using Splat;
+
+namespace Avalonia.ReactiveUI 
+{
+    /// <summary>
+    /// This content control will automatically load the View associated with
+    /// the ViewModel property and display it. This control is very useful
+    /// inside a DataTemplate to display the View associated with a ViewModel.
+    /// </summary>
+    public class ViewModelViewHost : TransitioningContentControl, IViewFor, IEnableLogger
+    {
+        /// <summary>
+        /// <see cref="AvaloniaProperty"/> for the <see cref="ViewModel"/> property.
+        /// </summary>
+        public static readonly AvaloniaProperty<object> ViewModelProperty =
+            AvaloniaProperty.Register<ViewModelViewHost, object>(nameof(ViewModel));
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ViewModelViewHost"/> class.
+        /// </summary>
+        public ViewModelViewHost()
+        {
+            this.WhenActivated(disposables =>
+            {
+                this.WhenAnyValue(x => x.ViewModel)
+                    .Subscribe(NavigateToViewModel)
+                    .DisposeWith(disposables);
+            });
+        }
+
+        /// <summary>
+        /// Gets or sets the ViewModel to display.
+        /// </summary>
+        public object ViewModel
+        {
+            get => GetValue(ViewModelProperty);
+            set => SetValue(ViewModelProperty, value);
+        }
+        
+        /// <summary>
+        /// Gets or sets the view locator.
+        /// </summary>
+        public IViewLocator ViewLocator { get; set; }
+
+        /// <summary>
+        /// Invoked when ReactiveUI router navigates to a view model.
+        /// </summary>
+        /// <param name="viewModel">ViewModel to which the user navigates.</param>
+        private void NavigateToViewModel(object viewModel)
+        {
+            if (viewModel == null)
+            {
+                this.Log().Info("ViewModel is null. Falling back to default content.");
+                Content = DefaultContent;
+                return;
+            }
+    
+            var viewLocator = ViewLocator ?? global::ReactiveUI.ViewLocator.Current;
+            var viewInstance = viewLocator.ResolveView(viewModel);
+            if (viewInstance == null)
+            {
+                this.Log().Warn($"Couldn't find view for '{viewModel}'. Is it registered? Falling back to default content.");
+                Content = DefaultContent;
+                return;
+            }
+    
+            this.Log().Info($"Ready to show {viewInstance} with autowired {viewModel}.");
+            viewInstance.ViewModel = viewModel;
+            if (viewInstance is IStyledElement styled)
+                styled.DataContext = viewModel;
+            Content = viewInstance;
+        }
+    }
+}

src/Avalonia.Themes.Default/Accents/BaseDark.xaml

@@ -46,11 +46,11 @@
         <SolidColorBrush x:Key="ErrorBrush" Color="{DynamicResource ErrorColor}"></SolidColorBrush>
         <SolidColorBrush x:Key="ErrorLowBrush" Color="{DynamicResource ErrorLowColor}"></SolidColorBrush>
 
-        <SolidColorBrush x:Key="NotificationCardBackgroundBrush" Color="#444444"/>
-        <SolidColorBrush x:Key="NotificationCardInformationBackgroundBrush" Color="Teal"/>
-        <SolidColorBrush x:Key="NotificationCardSuccessBackgroundBrush" Color="LimeGreen"/>
-        <SolidColorBrush x:Key="NotificationCardWarningBackgroundBrush" Color="Orange"/>
-        <SolidColorBrush x:Key="NotificationCardErrorBackgroundBrush" Color="OrangeRed"/>
+        <SolidColorBrush x:Key="NotificationCardBackgroundBrush" Color="#444444" Opacity="0.75"/>
+        <SolidColorBrush x:Key="NotificationCardInformationBackgroundBrush" Color="#007ACC" Opacity="0.75"/>
+        <SolidColorBrush x:Key="NotificationCardSuccessBackgroundBrush" Color="#1F9E45" Opacity="0.75"/>
+        <SolidColorBrush x:Key="NotificationCardWarningBackgroundBrush" Color="#FDB328" Opacity="0.75"/>
+        <SolidColorBrush x:Key="NotificationCardErrorBackgroundBrush" Color="#BD202C" Opacity="0.75"/>
 
         <Thickness x:Key="ThemeBorderThickness">1,1,1,1</Thickness>
         <sys:Double x:Key="ThemeDisabledOpacity">0.5</sys:Double>

src/Avalonia.Themes.Default/Accents/BaseLight.xaml

@@ -46,11 +46,11 @@
         <SolidColorBrush x:Key="ErrorBrush" Color="{DynamicResource ErrorColor}"></SolidColorBrush>
         <SolidColorBrush x:Key="ErrorLowBrush" Color="{DynamicResource ErrorLowColor}"></SolidColorBrush>
 
-        <SolidColorBrush x:Key="NotificationCardBackgroundBrush" Color="#444444"/>
-        <SolidColorBrush x:Key="NotificationCardInformationBackgroundBrush" Color="Teal"/>
-        <SolidColorBrush x:Key="NotificationCardSuccessBackgroundBrush" Color="LimeGreen"/>
-        <SolidColorBrush x:Key="NotificationCardWarningBackgroundBrush" Color="Orange"/>
-        <SolidColorBrush x:Key="NotificationCardErrorBackgroundBrush" Color="OrangeRed"/>
+        <SolidColorBrush x:Key="NotificationCardBackgroundBrush" Color="#444444" Opacity="0.75"/>
+        <SolidColorBrush x:Key="NotificationCardInformationBackgroundBrush" Color="#007ACC" Opacity="0.75"/>
+        <SolidColorBrush x:Key="NotificationCardSuccessBackgroundBrush" Color="#1F9E45" Opacity="0.75"/>
+        <SolidColorBrush x:Key="NotificationCardWarningBackgroundBrush" Color="#FDB328" Opacity="0.75"/>
+        <SolidColorBrush x:Key="NotificationCardErrorBackgroundBrush" Color="#BD202C" Opacity="0.75"/>
 
         <Thickness x:Key="ThemeBorderThickness">1</Thickness>
         <sys:Double x:Key="ThemeDisabledOpacity">0.5</sys:Double>

src/Avalonia.Themes.Default/NotificationCard.xaml

@@ -13,7 +13,7 @@
                             BorderBrush="{TemplateBinding BorderBrush}" 
                             BorderThickness="{TemplateBinding BorderThickness}"
                             Margin="8,8,0,0">
-                        <ContentControl MinHeight="150" Content="{TemplateBinding Content}" />
+                        <ContentControl Name="PART_Content" Content="{TemplateBinding Content}" />
                     </Border>
                 </LayoutTransformControl>
             </ControlTemplate>
@@ -40,6 +40,10 @@
         </Style.Animations>
     </Style>
 
+    <Style Selector="NotificationCard/template/ ContentControl#PART_Content">
+        <Setter Property="MinHeight" Value="150" />
+    </Style>
+
     <Style Selector="NotificationCard[IsClosing=true] /template/ LayoutTransformControl#PART_LayoutTransformControl">
         <Setter Property="RenderTransformOrigin" Value="50%,0%"/>
         <Style.Animations>

src/Avalonia.Themes.Default/ScrollViewer.xaml

@@ -12,7 +12,14 @@
                                 Extent="{TemplateBinding Extent, Mode=TwoWay}"
                                 Margin="{TemplateBinding Padding}"
                                 Offset="{TemplateBinding Offset, Mode=TwoWay}"
-                                Viewport="{TemplateBinding Viewport, Mode=TwoWay}"/>
+                                Viewport="{TemplateBinding Viewport, Mode=TwoWay}">
+          <ScrollContentPresenter.GestureRecognizers>
+            <ScrollGestureRecognizer 
+              CanHorizontallyScroll="{TemplateBinding CanHorizontallyScroll}"
+              CanVerticallyScroll="{TemplateBinding CanVerticallyScroll}"
+            />
+          </ScrollContentPresenter.GestureRecognizers>  
+        </ScrollContentPresenter>
         <ScrollBar Name="horizontalScrollBar"
                    Orientation="Horizontal"
                    Maximum="{TemplateBinding HorizontalScrollBarMaximum}"
@@ -32,4 +39,4 @@
       </Grid>
     </ControlTemplate>
   </Setter>
-</Style>
+</Style>

src/Avalonia.Visuals/Animation/CrossFade.cs

@@ -14,8 +14,8 @@ namespace Avalonia.Animation
     /// </summary>
     public class CrossFade : IPageTransition
     {
-        private Animation _fadeOutAnimation;
-        private Animation _fadeInAnimation;
+        private readonly Animation _fadeOutAnimation;
+        private readonly Animation _fadeInAnimation;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="CrossFade"/> class.
@@ -61,10 +61,10 @@ namespace Avalonia.Animation
                             new Setter
                             {
                                 Property = Visual.OpacityProperty,
-                                Value = 0d
+                                Value = 1d
                             }
                         },
-                        Cue = new Cue(0d)
+                        Cue = new Cue(1d)
                     }
 
                 }

src/Avalonia.Visuals/Platform/IRenderTarget.cs

@@ -23,4 +23,9 @@ namespace Avalonia.Platform
         /// </param>
         IDrawingContextImpl CreateDrawingContext(IVisualBrushRenderer visualBrushRenderer);
     }
+
+    public interface IRenderTargetWithCorruptionInfo : IRenderTarget
+    {
+        bool IsCorrupted { get; }
+    }
 }

src/Avalonia.Visuals/Rendering/DeferredRenderer.cs

@@ -245,6 +245,11 @@ namespace Avalonia.Rendering
                         {
                             if (context != null)
                                 return context;
+                            if ((RenderTarget as IRenderTargetWithCorruptionInfo)?.IsCorrupted == true)
+                            {
+                                RenderTarget.Dispose();
+                                RenderTarget = null;
+                            }
                             if (RenderTarget == null)
                                 RenderTarget = ((IRenderRoot)_root).CreateRenderTarget();
                             return context = RenderTarget.CreateDrawingContext(this);

src/Avalonia.Visuals/Rendering/ManagedDeferredRendererLock.cs

@@ -7,11 +7,25 @@ namespace Avalonia.Rendering
     public class ManagedDeferredRendererLock : IDeferredRendererLock
     {
         private readonly object _lock = new object();
+        
+        /// <summary>
+        /// Tries to lock the target surface or window
+        /// </summary>
+        /// <returns>IDisposable if succeeded to obtain the lock</returns>
         public IDisposable TryLock()
         {
             if (Monitor.TryEnter(_lock))
                 return Disposable.Create(() => Monitor.Exit(_lock));
             return null;
         }
+
+        /// <summary>
+        /// Enters a waiting lock, only use from platform code, not from the renderer
+        /// </summary>
+        public IDisposable Lock()
+        {
+            Monitor.Enter(_lock);
+            return Disposable.Create(() => Monitor.Exit(_lock));
+        }
     }
 }

src/Avalonia.Visuals/Rendering/UiThreadRenderTimer.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Diagnostics;
+using System.Reactive.Disposables;
+using Avalonia.Threading;
+
+namespace Avalonia.Rendering
+{
+    /// <summary>
+    /// Render timer that ticks on UI thread. Useful for debugging or bootstrapping on new platforms 
+    /// </summary>
+    
+    public class UiThreadRenderTimer : DefaultRenderTimer
+    {
+        public UiThreadRenderTimer(int framesPerSecond) : base(framesPerSecond)
+        {
+        }
+
+        protected override IDisposable StartCore(Action<TimeSpan> tick)
+        {
+            bool cancelled = false;
+            var st = Stopwatch.StartNew();
+            DispatcherTimer.Run(() =>
+            {
+                if (cancelled)
+                    return false;
+                tick(st.Elapsed);
+                return !cancelled;
+            }, TimeSpan.FromSeconds(1.0 / FramesPerSecond), DispatcherPriority.Render);
+            return Disposable.Create(() => cancelled = true);
+        }
+    }
+}

src/Avalonia.X11/X11CursorFactory.cs

@@ -8,6 +8,8 @@ namespace Avalonia.X11
 {
     class X11CursorFactory : IStandardCursorFactory
     {
+        private static IntPtr _nullCursor;
+
         private readonly IntPtr _display;
         private Dictionary<CursorFontShape, IntPtr> _cursors;
 
@@ -42,16 +44,34 @@ namespace Avalonia.X11
         public X11CursorFactory(IntPtr display)
         {
             _display = display;
+            _nullCursor = GetNullCursor(display);
             _cursors = Enum.GetValues(typeof(CursorFontShape)).Cast<CursorFontShape>()
                 .ToDictionary(id => id, id => XLib.XCreateFontCursor(_display, id));
         }
-        
+
         public IPlatformHandle GetCursor(StandardCursorType cursorType)
         {
-            var handle = s_mapping.TryGetValue(cursorType, out var shape)
+            IntPtr handle;
+            if (cursorType == StandardCursorType.None)
+            {
+                handle = _nullCursor;
+            }
+            else
+            {
+                handle = s_mapping.TryGetValue(cursorType, out var shape)
                 ? _cursors[shape]
                 : _cursors[CursorFontShape.XC_top_left_arrow];
+            }
             return new PlatformHandle(handle, "XCURSOR");
         }
+
+        private static IntPtr GetNullCursor(IntPtr display)
+        {
+            XColor color = new XColor();
+            byte[] data = new byte[] { 0 };
+            IntPtr window = XLib.XRootWindow(display, 0);
+            IntPtr pixmap = XLib.XCreateBitmapFromData(display, window, data, 1, 1);
+            return XLib.XCreatePixmapCursor(display, pixmap, pixmap, ref color, ref color, 0, 0);
+        }
     }
 }

src/Avalonia.X11/XLib.cs

@@ -321,6 +321,9 @@ namespace Avalonia.X11
         public static extern IntPtr XCreatePixmapCursor(IntPtr display, IntPtr source, IntPtr mask,
             ref XColor foreground_color, ref XColor background_color, int x_hot, int y_hot);
 
+        [DllImport(libX11)]
+        public static extern IntPtr XCreateBitmapFromData(IntPtr display, IntPtr drawable, byte[] data, int width, int height);
+
         [DllImport(libX11)]
         public static extern IntPtr XCreatePixmapFromBitmapData(IntPtr display, IntPtr drawable, byte[] data, int width,
             int height, IntPtr fg, IntPtr bg, int depth);

src/Gtk/Avalonia.Gtk3/CursorFactory.cs

@@ -12,6 +12,7 @@ namespace Avalonia.Gtk3
         private static readonly Dictionary<StandardCursorType, object> CursorTypeMapping = new Dictionary
     <StandardCursorType, object>
         {
+            {StandardCursorType.None, CursorType.Blank},
             {StandardCursorType.AppStarting, CursorType.Watch},
             {StandardCursorType.Arrow, CursorType.LeftPtr},
             {StandardCursorType.Cross, CursorType.Cross},
@@ -80,4 +81,4 @@ namespace Avalonia.Gtk3
             return rv;
         }
     }
-}
+}

src/Gtk/Avalonia.Gtk3/GdkCursor.cs

@@ -2,6 +2,7 @@
 {
     enum GdkCursorType
     {
+        Blank = -2,
         CursorIsPixmap = -1,
         XCursor = 0,
         Arrow = 2,

src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlSetterTransformer.cs

@@ -16,8 +16,10 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
             if (!(node is XamlIlAstObjectNode on
                   && on.Type.GetClrType().FullName == "Avalonia.Styling.Setter"))
                 return node;
+
             var parent = context.ParentNodes().OfType<XamlIlAstObjectNode>()
-                .FirstOrDefault(x => x.Type.GetClrType().FullName == "Avalonia.Styling.Style");
+                .FirstOrDefault(p => p.Type.GetClrType().FullName == "Avalonia.Styling.Style");
+            
             if (parent == null)
                 throw new XamlIlParseException(
                     "Avalonia.Styling.Setter is only valid inside Avalonia.Styling.Style", node);
@@ -53,8 +55,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
                 .OfType<XamlIlAstXamlPropertyValueNode>().FirstOrDefault(p => p.Property.GetClrProperty().Name == "Value");
             if (valueProperty?.Values?.Count == 1 && valueProperty.Values[0] is XamlIlAstTextNode)
             {
-                var propType = avaloniaPropertyNode.Property.Getter?.ReturnType
-                               ?? avaloniaPropertyNode.Property.Setters.First().Parameters[0];
+                var propType = avaloniaPropertyNode.AvaloniaPropertyType;
                 if (!XamlIlTransformHelpers.TryGetCorrectlyTypedValue(context, valueProperty.Values[0],
                         propType, out var converted))
                     throw new XamlIlParseException(

src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlWellKnownTypes.cs

@@ -10,6 +10,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
         public IXamlIlType BindingPriority { get; }
         public IXamlIlType AvaloniaObjectExtensions { get; }
         public IXamlIlType AvaloniaProperty { get; }
+        public IXamlIlType AvaloniaPropertyT { get; }
         public IXamlIlType IBinding { get; }
         public IXamlIlMethod AvaloniaObjectBindMethod { get; }
         public IXamlIlMethod AvaloniaObjectSetValueMethod { get; }
@@ -26,6 +27,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
             IAvaloniaObject = ctx.Configuration.TypeSystem.GetType("Avalonia.IAvaloniaObject");
             AvaloniaObjectExtensions = ctx.Configuration.TypeSystem.GetType("Avalonia.AvaloniaObjectExtensions");
             AvaloniaProperty = ctx.Configuration.TypeSystem.GetType("Avalonia.AvaloniaProperty");
+            AvaloniaPropertyT = ctx.Configuration.TypeSystem.GetType("Avalonia.AvaloniaProperty`1");
             BindingPriority = ctx.Configuration.TypeSystem.GetType("Avalonia.Data.BindingPriority");
             IBinding = ctx.Configuration.TypeSystem.GetType("Avalonia.Data.IBinding");
             IDisposable = ctx.Configuration.TypeSystem.GetType("System.IDisposable");

src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/XamlIlAvaloniaPropertyHelper.cs

@@ -44,7 +44,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
             return true;
         }
 
-        public static XamlIlAvaloniaPropertyNode CreateNode(XamlIlAstTransformationContext context,
+        public static IXamlIlAvaloniaPropertyNode CreateNode(XamlIlAstTransformationContext context,
             string propertyName, IXamlIlAstTypeReference selectorTypeReference, IXamlIlLineInfo lineInfo)
         {
             XamlIlAstNamePropertyReference forgedReference;
@@ -63,8 +63,14 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
                 xmlOwner += parsedPropertyName.owner;
                 
                 var tref = XamlIlTypeReferenceResolver.ResolveType(context, xmlOwner, false, lineInfo, true);
-                forgedReference = new XamlIlAstNamePropertyReference(lineInfo,
-                    tref, parsedPropertyName.name, tref);
+
+                var propertyFieldName = parsedPropertyName.name + "Property";
+                var found = tref.Type.GetAllFields()
+                    .FirstOrDefault(f => f.IsStatic && f.IsPublic && f.Name == propertyFieldName);
+                if (found == null)
+                    throw new XamlIlParseException(
+                        $"Unable to find {propertyFieldName} field on type {tref.Type.GetFullName()}", lineInfo);
+                return new XamlIlAvaloniaPropertyFieldNode(context.GetAvaloniaTypes(), lineInfo, found);
             }
 
             var clrProperty =
@@ -75,13 +81,20 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
                 clrProperty);
         }
     }
+
+    interface IXamlIlAvaloniaPropertyNode : IXamlIlAstValueNode
+    {
+        IXamlIlType AvaloniaPropertyType { get; }
+    }
     
-    class XamlIlAvaloniaPropertyNode : XamlIlAstNode, IXamlIlAstValueNode, IXamlIlAstEmitableNode
+    class XamlIlAvaloniaPropertyNode : XamlIlAstNode, IXamlIlAstValueNode, IXamlIlAstEmitableNode, IXamlIlAvaloniaPropertyNode
     {
         public XamlIlAvaloniaPropertyNode(IXamlIlLineInfo lineInfo, IXamlIlType type, XamlIlAstClrProperty property) : base(lineInfo)
         {
             Type = new XamlIlAstClrTypeReference(this, type, false);
             Property = property;
+            AvaloniaPropertyType = Property.Getter?.ReturnType
+                                   ?? Property.Setters.First().Parameters[0];
         }
 
         public XamlIlAstClrProperty Property { get; }
@@ -93,6 +106,46 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
                 throw new XamlIlLoadException(Property.Name + " is not an AvaloniaProperty", this);
             return XamlIlNodeEmitResult.Type(0, Type.GetClrType());
         }
+
+        public IXamlIlType AvaloniaPropertyType { get; }
+    }
+
+    class XamlIlAvaloniaPropertyFieldNode : XamlIlAstNode, IXamlIlAstValueNode, IXamlIlAstEmitableNode, IXamlIlAvaloniaPropertyNode
+    {
+        private readonly IXamlIlField _field;
+
+        public XamlIlAvaloniaPropertyFieldNode(AvaloniaXamlIlWellKnownTypes types,
+            IXamlIlLineInfo lineInfo, IXamlIlField field) : base(lineInfo)
+        {
+            _field = field;
+            var avaloniaPropertyType = field.FieldType;
+            while (avaloniaPropertyType != null)
+            {
+                if (avaloniaPropertyType.GenericTypeDefinition?.Equals(types.AvaloniaPropertyT) == true)
+                {
+                    AvaloniaPropertyType = avaloniaPropertyType.GenericArguments[0];
+                    return;
+                }
+
+                avaloniaPropertyType = avaloniaPropertyType.BaseType;
+            }
+
+            throw new XamlIlParseException(
+                $"{field.Name}'s type {field.FieldType} doesn't inherit from AvaloniaProperty<T>, make sure to use typed properties",
+                lineInfo);
+
+        }
+        
+        
+
+        public IXamlIlAstTypeReference Type => new XamlIlAstClrTypeReference(this, _field.FieldType, false);
+        public XamlIlNodeEmitResult Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen)
+        {
+            codeGen.Ldsfld(_field);
+            return XamlIlNodeEmitResult.Type(0, _field.FieldType);
+        }
+
+        public IXamlIlType AvaloniaPropertyType { get; }
     }
 
     interface IXamlIlAvaloniaProperty

src/Markup/Avalonia.Markup.Xaml/XamlIl/xamlil.github

@@ -1 +1 @@
-Subproject commit 1e3ffc315401f0b2eb96a0e79b25c2fc19a80d78
+Subproject commit 610cda30c69e32e83c8235060606480904c937bc

src/Skia/Avalonia.Skia/GlRenderTarget.cs

@@ -8,7 +8,7 @@ using static Avalonia.OpenGL.GlConsts;
 
 namespace Avalonia.Skia
 {
-    internal class GlRenderTarget : IRenderTarget
+    internal class GlRenderTarget : IRenderTargetWithCorruptionInfo
     {
         private readonly GRContext _grContext;
         private IGlPlatformSurfaceRenderTarget _surface;
@@ -21,6 +21,8 @@ namespace Avalonia.Skia
 
         public void Dispose() => _surface.Dispose();
 
+        public bool IsCorrupted => (_surface as IGlPlatformSurfaceRenderTargetWithCorruptionInfo)?.IsCorrupted == true;
+        
         public IDrawingContextImpl CreateDrawingContext(IVisualBrushRenderer visualBrushRenderer)
         {
             var session = _surface.BeginDraw();

src/Skia/Avalonia.Skia/PlatformRenderInterface.cs

@@ -111,8 +111,7 @@ namespace Avalonia.Skia
                 Width = size.Width,
                 Height = size.Height,
                 Dpi = dpi,
-                DisableTextLcdRendering = false,
-                GrContext = GrContext
+                DisableTextLcdRendering = false
             };
 
             return new SurfaceRenderTarget(createInfo);

src/Windows/Avalonia.Win32.Interop/Wpf/WpfMouseDevice.cs

@@ -9,22 +9,32 @@ namespace Avalonia.Win32.Interop.Wpf
     {
         private readonly WpfTopLevelImpl _impl;
 
-        public WpfMouseDevice(WpfTopLevelImpl impl)
+        public WpfMouseDevice(WpfTopLevelImpl impl) : base(new WpfMousePointer(impl))
         {
             _impl = impl;
         }
 
-        public override void Capture(IInputElement control)
+        class WpfMousePointer : Pointer
         {
-            if (control == null)
+            private readonly WpfTopLevelImpl _impl;
+
+            public WpfMousePointer(WpfTopLevelImpl impl) : base(Pointer.GetNextFreeId(), PointerType.Mouse, true)
+            {
+                _impl = impl;
+            }
+
+            protected override void PlatformCapture(IInputElement control)
             {
-                System.Windows.Input.Mouse.Capture(null);
+                if (control == null)
+                {
+                    System.Windows.Input.Mouse.Capture(null);
+                }
+                else if ((control.GetVisualRoot() as EmbeddableControlRoot)?.PlatformImpl != _impl)
+                    throw new ArgumentException("Visual belongs to unknown toplevel");
+                else
+                    System.Windows.Input.Mouse.Capture(_impl);
             }
-            else if ((control.GetVisualRoot() as EmbeddableControlRoot)?.PlatformImpl != _impl)
-                throw new ArgumentException("Visual belongs to unknown toplevel");
-            else
-                System.Windows.Input.Mouse.Capture(_impl);
-            base.Capture(control);
         }
+        
     }
 }

src/Windows/Avalonia.Win32/CursorFactory.cs

@@ -41,6 +41,7 @@ namespace Avalonia.Win32
         private static readonly Dictionary<StandardCursorType, int> CursorTypeMapping = new Dictionary
             <StandardCursorType, int>
         {
+            {StandardCursorType.None, 0},
             {StandardCursorType.AppStarting, 32650},
             {StandardCursorType.Arrow, 32512},
             {StandardCursorType.Cross, 32515},

src/Windows/Avalonia.Win32/Input/WindowsMouseDevice.cs

@@ -1,7 +1,10 @@
 // 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.
 
+using System;
+using Avalonia.Controls;
 using Avalonia.Input;
+using Avalonia.VisualTree;
 using Avalonia.Win32.Interop;
 
 namespace Avalonia.Win32.Input
@@ -10,23 +13,32 @@ namespace Avalonia.Win32.Input
     {
         public static WindowsMouseDevice Instance { get; } = new WindowsMouseDevice();
 
+        public WindowsMouseDevice() : base(new WindowsMousePointer())
+        {
+            
+        }
+        
         public WindowImpl CurrentWindow
         {
             get;
             set;
         }
 
-        public override void Capture(IInputElement control)
+        class WindowsMousePointer : Pointer
         {
-            base.Capture(control);
-
-            if (control != null)
+            public WindowsMousePointer() : base(Pointer.GetNextFreeId(),PointerType.Mouse, true)
             {
-                UnmanagedMethods.SetCapture(CurrentWindow.Handle.Handle);
             }
-            else
+
+            protected override void PlatformCapture(IInputElement element)
             {
-                UnmanagedMethods.ReleaseCapture();
+                var hwnd = ((element?.GetVisualRoot() as TopLevel)?.PlatformImpl as WindowImpl)
+                    ?.Handle.Handle;
+
+                if (hwnd.HasValue && hwnd != IntPtr.Zero)
+                    UnmanagedMethods.SetCapture(hwnd.Value);
+                else
+                    UnmanagedMethods.ReleaseCapture();
             }
         }
     }

src/Windows/Avalonia.Win32/WindowImpl.cs

@@ -33,6 +33,7 @@ namespace Avalonia.Win32
         private bool _multitouch;
         private TouchDevice _touchDevice = new TouchDevice();
         private IInputRoot _owner;
+        private ManagedDeferredRendererLock _rendererLock = new ManagedDeferredRendererLock();
         private bool _trackingMouse;
         private bool _decorated = true;
         private bool _resizable = true;
@@ -150,7 +151,9 @@ namespace Avalonia.Win32
             if (customRendererFactory != null)
                 return customRendererFactory.Create(root, loop);
 
-            return Win32Platform.UseDeferredRendering ? (IRenderer)new DeferredRenderer(root, loop) : new ImmediateRenderer(root);
+            return Win32Platform.UseDeferredRendering ?
+                (IRenderer)new DeferredRenderer(root, loop, rendererLock: _rendererLock) :
+                new ImmediateRenderer(root);
         }
 
         public void Resize(Size value)
@@ -333,6 +336,7 @@ namespace Avalonia.Win32
 
         public void BeginMoveDrag()
         {
+            WindowsMouseDevice.Instance.Capture(null);
             UnmanagedMethods.DefWindowProc(_hwnd, (int)UnmanagedMethods.WindowsMessage.WM_NCLBUTTONDOWN,
                 new IntPtr((int)UnmanagedMethods.HitTestValues.HTCAPTION), IntPtr.Zero);
         }
@@ -354,6 +358,7 @@ namespace Avalonia.Win32
 #if USE_MANAGED_DRAG
             _managedDrag.BeginResizeDrag(edge, ScreenToClient(MouseDevice.Position));
 #else
+            WindowsMouseDevice.Instance.Capture(null);
             UnmanagedMethods.DefWindowProc(_hwnd, (int)UnmanagedMethods.WindowsMessage.WM_NCLBUTTONDOWN,
                 new IntPtr((int)EdgeDic[edge]), IntPtr.Zero);
 #endif
@@ -634,8 +639,6 @@ namespace Avalonia.Win32
                     {
                         foreach (var touchInput in touchInputs)
                         {
-                            var pt = new POINT {X = touchInput.X / 100, Y = touchInput.Y / 100};
-                            UnmanagedMethods.ScreenToClient(_hwnd, ref pt);
                             Input?.Invoke(new RawTouchEventArgs(_touchDevice, touchInput.Time,
                                 _owner,
                                 touchInput.Flags.HasFlag(TouchInputFlags.TOUCHEVENTF_UP) ?
@@ -643,7 +646,7 @@ namespace Avalonia.Win32
                                     touchInput.Flags.HasFlag(TouchInputFlags.TOUCHEVENTF_DOWN) ?
                                         RawPointerEventType.TouchBegin :
                                         RawPointerEventType.TouchUpdate,
-                                new Point(pt.X, pt.Y),
+                                PointToClient(new PixelPoint(touchInput.X / 100, touchInput.Y / 100)),
                                 WindowsKeyboardDevice.Instance.Modifiers,
                                 touchInput.Id));
                         }
@@ -667,18 +670,26 @@ namespace Avalonia.Win32
                     break;
 
                 case UnmanagedMethods.WindowsMessage.WM_PAINT:
-                    UnmanagedMethods.PAINTSTRUCT ps;
-                    if (UnmanagedMethods.BeginPaint(_hwnd, out ps) != IntPtr.Zero)
+                    using (_rendererLock.Lock())
                     {
-                        var f = Scaling;
-                        var r = ps.rcPaint;
-                        Paint?.Invoke(new Rect(r.left / f, r.top / f, (r.right - r.left) / f, (r.bottom - r.top) / f));
-                        UnmanagedMethods.EndPaint(_hwnd, ref ps);
+                        UnmanagedMethods.PAINTSTRUCT ps;
+                        if (UnmanagedMethods.BeginPaint(_hwnd, out ps) != IntPtr.Zero)
+                        {
+                            var f = Scaling;
+                            var r = ps.rcPaint;
+                            Paint?.Invoke(new Rect(r.left / f, r.top / f, (r.right - r.left) / f,
+                                (r.bottom - r.top) / f));
+                            UnmanagedMethods.EndPaint(_hwnd, ref ps);
+                        }
                     }
 
                     return IntPtr.Zero;
 
                 case UnmanagedMethods.WindowsMessage.WM_SIZE:
+                    using (_rendererLock.Lock())
+                    {
+                        // Do nothing here, just block until the pending frame render is completed on the render thread
+                    }
                     var size = (UnmanagedMethods.SizeCommand)wParam;
 
                     if (Resized != null &&
@@ -744,7 +755,8 @@ namespace Avalonia.Win32
                 }
             }
 
-            return UnmanagedMethods.DefWindowProc(hWnd, msg, wParam, lParam);
+            using (_rendererLock.Lock())
+                return UnmanagedMethods.DefWindowProc(hWnd, msg, wParam, lParam);
         }
 
         static InputModifiers GetMouseModifiers(IntPtr wParam)

tests/Avalonia.Controls.UnitTests/GridLayoutTests.cs

@@ -1,184 +0,0 @@
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using Avalonia.Controls.Utils;
-using Xunit;
-
-namespace Avalonia.Controls.UnitTests
-{
-    public class GridLayoutTests
-    {
-        private const double Inf = double.PositiveInfinity;
-
-        [Theory]
-        [InlineData("100, 200, 300", 0d, 0d, new[] { 0d, 0d, 0d })]
-        [InlineData("100, 200, 300", 800d, 600d, new[] { 100d, 200d, 300d })]
-        [InlineData("100, 200, 300", 600d, 600d, new[] { 100d, 200d, 300d })]
-        [InlineData("100, 200, 300", 400d, 400d, new[] { 100d, 200d, 100d })]
-        public void MeasureArrange_AllPixelLength_Correct(string length, double containerLength,
-            double expectedDesiredLength, IList expectedLengthList)
-        {
-            TestRowDefinitionsOnly(length, containerLength, expectedDesiredLength, expectedLengthList);
-        }
-
-        [Theory]
-        [InlineData("*,2*,3*", 0d, 0d, new[] { 0d, 0d, 0d })]
-        [InlineData("*,2*,3*", 600d, 0d, new[] { 100d, 200d, 300d })]
-        public void MeasureArrange_AllStarLength_Correct(string length, double containerLength,
-            double expectedDesiredLength, IList expectedLengthList)
-        {
-            TestRowDefinitionsOnly(length, containerLength, expectedDesiredLength, expectedLengthList);
-        }
-
-        [Theory]
-        [InlineData("100,2*,3*", 0d, 0d, new[] { 0d, 0d, 0d })]
-        [InlineData("100,2*,3*", 600d, 100d, new[] { 100d, 200d, 300d })]
-        [InlineData("100,2*,3*", 100d, 100d, new[] { 100d, 0d, 0d })]
-        [InlineData("100,2*,3*", 50d, 50d, new[] { 50d, 0d, 0d })]
-        public void MeasureArrange_MixStarPixelLength_Correct(string length, double containerLength,
-            double expectedDesiredLength, IList expectedLengthList)
-        {
-            TestRowDefinitionsOnly(length, containerLength, expectedDesiredLength, expectedLengthList);
-        }
-
-        [Theory]
-        [InlineData("100,200,Auto", 0d, 0d, new[] { 0d, 0d, 0d })]
-        [InlineData("100,200,Auto", 600d, 300d, new[] { 100d, 200d, 0d })]
-        [InlineData("100,200,Auto", 300d, 300d, new[] { 100d, 200d, 0d })]
-        [InlineData("100,200,Auto", 200d, 200d, new[] { 100d, 100d, 0d })]
-        [InlineData("100,200,Auto", 100d, 100d, new[] { 100d, 0d, 0d })]
-        [InlineData("100,200,Auto", 50d, 50d, new[] { 50d, 0d, 0d })]
-        public void MeasureArrange_MixAutoPixelLength_Correct(string length, double containerLength,
-            double expectedDesiredLength, IList expectedLengthList)
-        {
-            TestRowDefinitionsOnly(length, containerLength, expectedDesiredLength, expectedLengthList);
-        }
-
-        [Theory]
-        [InlineData("*,2*,Auto", 0d, 0d, new[] { 0d, 0d, 0d })]
-        [InlineData("*,2*,Auto", 600d, 0d, new[] { 200d, 400d, 0d })]
-        public void MeasureArrange_MixAutoStarLength_Correct(string length, double containerLength,
-            double expectedDesiredLength, IList expectedLengthList)
-        {
-            TestRowDefinitionsOnly(length, containerLength, expectedDesiredLength, expectedLengthList);
-        }
-
-        [Theory]
-        [InlineData("*,200,Auto", 0d, 0d, new[] { 0d, 0d, 0d })]
-        [InlineData("*,200,Auto", 600d, 200d, new[] { 400d, 200d, 0d })]
-        [InlineData("*,200,Auto", 200d, 200d, new[] { 0d, 200d, 0d })]
-        [InlineData("*,200,Auto", 100d, 100d, new[] { 0d, 100d, 0d })]
-        public void MeasureArrange_MixAutoStarPixelLength_Correct(string length, double containerLength,
-            double expectedDesiredLength, IList expectedLengthList)
-        {
-            TestRowDefinitionsOnly(length, containerLength, expectedDesiredLength, expectedLengthList);
-        }
-
-        
-        /// <summary>
-        /// This is needed because Mono somehow converts double array to object array in attribute metadata
-        /// </summary>
-        static void AssertEqual(IList expected, IReadOnlyList<double> actual)
-        {
-            var conv = expected.Cast<double>().ToArray();
-            Assert.Equal(conv, actual);
-        }
-
-        [SuppressMessage("ReSharper", "ParameterOnlyUsedForPreconditionCheck.Local")]
-        private static void TestRowDefinitionsOnly(string length, double containerLength,
-            double expectedDesiredLength, IList expectedLengthList)
-        {
-            // Arrange
-            var layout = new GridLayout(new RowDefinitions(length));
-
-            // Measure - Action & Assert
-            var measure = layout.Measure(containerLength);
-            Assert.Equal(expectedDesiredLength, measure.DesiredLength);
-            AssertEqual(expectedLengthList, measure.LengthList);
-
-            // Arrange - Action & Assert
-            var arrange = layout.Arrange(containerLength, measure);
-            AssertEqual(expectedLengthList, arrange.LengthList);
-        }
-
-        [Theory]
-        [InlineData("100, 200, 300", 600d, new[] { 100d, 200d, 300d }, new[] { 100d, 200d, 300d })]
-        [InlineData("*,2*,3*", 0d, new[] { Inf, Inf, Inf }, new[] { 0d, 0d, 0d })]
-        [InlineData("100,2*,3*", 100d, new[] { 100d, Inf, Inf }, new[] { 100d, 0d, 0d })]
-        [InlineData("100,200,Auto", 300d, new[] { 100d, 200d, 0d }, new[] { 100d, 200d, 0d })]
-        [InlineData("*,2*,Auto", 0d, new[] { Inf, Inf, 0d }, new[] { 0d, 0d, 0d })]
-        [InlineData("*,200,Auto", 200d, new[] { Inf, 200d, 0d }, new[] { 0d, 200d, 0d })]
-        public void MeasureArrange_InfiniteMeasure_Correct(string length, double expectedDesiredLength,
-            IList expectedMeasureList, IList expectedArrangeList)
-        {
-            // Arrange
-            var layout = new GridLayout(new RowDefinitions(length));
-
-            // Measure - Action & Assert
-            var measure = layout.Measure(Inf);
-            Assert.Equal(expectedDesiredLength, measure.DesiredLength);
-            AssertEqual(expectedMeasureList, measure.LengthList);
-
-            // Arrange - Action & Assert
-            var arrange = layout.Arrange(measure.DesiredLength, measure);
-            AssertEqual(expectedArrangeList, arrange.LengthList);
-        }
-
-        [Theory]
-        [InlineData("Auto,*,*", new[] { 100d, 100d, 100d }, 600d, 300d, new[] { 100d, 250d, 250d })]
-        public void MeasureArrange_ChildHasSize_Correct(string length,
-            IList childLengthList, double containerLength,
-            double expectedDesiredLength, IList expectedLengthList)
-        {
-            // Arrange
-            var lengthList = new ColumnDefinitions(length);
-            var layout = new GridLayout(lengthList);
-            layout.AppendMeasureConventions(
-                Enumerable.Range(0, lengthList.Count).ToDictionary(x => x, x => (x, 1)),
-                x => (double)childLengthList[x]);
-
-            // Measure - Action & Assert
-            var measure = layout.Measure(containerLength);
-            Assert.Equal(expectedDesiredLength, measure.DesiredLength);
-            AssertEqual(expectedLengthList, measure.LengthList);
-
-            // Arrange - Action & Assert
-            var arrange = layout.Arrange(containerLength, measure);
-            AssertEqual(expectedLengthList, arrange.LengthList);
-        }
-
-        [Theory]
-        [InlineData(Inf, 250d, new[] { 100d, Inf, Inf }, new[] { 100d, 50d, 100d })]
-        [InlineData(400d, 250d, new[] { 100d, 100d, 200d }, new[] { 100d, 100d, 200d })]
-        [InlineData(325d, 250d, new[] { 100d, 75d, 150d }, new[] { 100d, 75d, 150d })]
-        [InlineData(250d, 250d, new[] { 100d, 50d, 100d }, new[] { 100d, 50d, 100d })]
-        [InlineData(160d, 160d, new[] { 100d, 20d, 40d }, new[] { 100d, 20d, 40d })]
-        public void MeasureArrange_ChildHasSizeAndHasMultiSpan_Correct(
-            double containerLength, double expectedDesiredLength,
-            IList expectedMeasureLengthList, IList expectedArrangeLengthList)
-        {
-            var length = "100,*,2*";
-            var childLengthList = new[] { 150d, 150d, 150d };
-            var spans = new[] { 1, 2, 1 };
-
-            // Arrange
-            var lengthList = new ColumnDefinitions(length);
-            var layout = new GridLayout(lengthList);
-            layout.AppendMeasureConventions(
-                Enumerable.Range(0, lengthList.Count).ToDictionary(x => x, x => (x, spans[x])),
-                x => childLengthList[x]);
-
-            // Measure - Action & Assert
-            var measure = layout.Measure(containerLength);
-            Assert.Equal(expectedDesiredLength, measure.DesiredLength);
-            AssertEqual(expectedMeasureLengthList, measure.LengthList);
-
-            // Arrange - Action & Assert
-            var arrange = layout.Arrange(
-                double.IsInfinity(containerLength) ? measure.DesiredLength : containerLength,
-                measure);
-            AssertEqual(expectedArrangeLengthList, arrange.LengthList);
-        }
-    }
-}

tests/Avalonia.Controls.UnitTests/MouseTestHelper.cs

@@ -1,3 +1,4 @@
+using System.Reactive;
 using Avalonia.Input;
 using Avalonia.Interactivity;
 using Avalonia.VisualTree;
@@ -6,22 +7,9 @@ namespace Avalonia.Controls.UnitTests
 {
     public class MouseTestHelper
     {
-
-        class TestPointer : IPointer
-        {
-            public int Id { get; } = Pointer.GetNextFreeId();
-
-            public void Capture(IInputElement control)
-            {
-                Captured = control;
-            }
-
-            public IInputElement Captured { get; set; }
-            public PointerType Type => PointerType.Mouse;
-            public bool IsPrimary => true;
-        }
-        
-        TestPointer _pointer = new TestPointer();
+        private Pointer _pointer = new Pointer(Pointer.GetNextFreeId(), PointerType.Mouse, true);
+        private ulong _nextStamp = 1;
+        private ulong Timestamp() => _nextStamp++;
 
         private InputModifiers _pressedButtons;
         public IInputElement Captured => _pointer.Captured;
@@ -49,8 +37,10 @@ namespace Avalonia.Controls.UnitTests
         
         public void Down(IInteractive target, MouseButton mouseButton = MouseButton.Left, Point position = default,
             InputModifiers modifiers = default, int clickCount = 1)
-            => Down(target, target, mouseButton, position, modifiers, clickCount);
-        
+        {
+            Down(target, target, mouseButton, position, modifiers, clickCount);
+        }
+
         public void Down(IInteractive target, IInteractive source, MouseButton mouseButton = MouseButton.Left, 
             Point position = default, InputModifiers modifiers = default, int clickCount = 1)
         {
@@ -61,7 +51,8 @@ namespace Avalonia.Controls.UnitTests
             else
             {
                 _pressedButton = mouseButton;
-                target.RaiseEvent(new PointerPressedEventArgs(source, _pointer, (IVisual)source, position, props,
+                _pointer.Capture((IInputElement)target);
+                target.RaiseEvent(new PointerPressedEventArgs(source, _pointer, (IVisual)source, position, Timestamp(), props,
                     GetModifiers(modifiers), clickCount));
             }
         }
@@ -70,7 +61,7 @@ namespace Avalonia.Controls.UnitTests
         public void Move(IInteractive target, IInteractive source, in Point position, InputModifiers modifiers = default)
         {
             target.RaiseEvent(new PointerEventArgs(InputElement.PointerMovedEvent, source, _pointer, (IVisual)target, position,
-                new PointerPointProperties(_pressedButtons), GetModifiers(modifiers)));
+                Timestamp(), new PointerPointProperties(_pressedButtons), GetModifiers(modifiers)));
         }
 
         public void Up(IInteractive target, MouseButton mouseButton = MouseButton.Left, Point position = default,
@@ -84,8 +75,12 @@ namespace Avalonia.Controls.UnitTests
             _pressedButtons = (_pressedButtons | conv) ^ conv;
             var props = new PointerPointProperties(_pressedButtons);
             if (ButtonCount(props) == 0)
-                target.RaiseEvent(new PointerReleasedEventArgs(source, _pointer, (IVisual)target, position, props,
+            {
+                _pointer.Capture(null);
+                target.RaiseEvent(new PointerReleasedEventArgs(source, _pointer, (IVisual)target, position,
+                    Timestamp(), props,
                     GetModifiers(modifiers), _pressedButton));
+            }
             else
                 Move(target, source, position);
         }
@@ -103,13 +98,13 @@ namespace Avalonia.Controls.UnitTests
         public void Enter(IInteractive target)
         {
             target.RaiseEvent(new PointerEventArgs(InputElement.PointerEnterEvent, target, _pointer, (IVisual)target, default,
-                new PointerPointProperties(_pressedButtons), _pressedButtons));
+                Timestamp(), new PointerPointProperties(_pressedButtons), _pressedButtons));
         }
 
         public void Leave(IInteractive target)
         {
             target.RaiseEvent(new PointerEventArgs(InputElement.PointerLeaveEvent, target, _pointer, (IVisual)target, default,
-                new PointerPointProperties(_pressedButtons), _pressedButtons));
+                Timestamp(), new PointerPointProperties(_pressedButtons), _pressedButtons));
         }
 
     }

tests/Avalonia.Controls.UnitTests/Platform/DefaultMenuInteractionHandlerTests.cs

@@ -11,14 +11,14 @@ namespace Avalonia.Controls.UnitTests.Platform
     public class DefaultMenuInteractionHandlerTests
     {
         static PointerEventArgs CreateArgs(RoutedEvent ev, IInteractive source) 
-            => new PointerEventArgs(ev, source, new FakePointer(), (IVisual)source, default, new PointerPointProperties(), default);
+            => new PointerEventArgs(ev, source, new FakePointer(), (IVisual)source, default, 0, new PointerPointProperties(), default);
 
         static PointerPressedEventArgs CreatePressed(IInteractive source) => new PointerPressedEventArgs(source,
-            new FakePointer(), (IVisual)source, default, new PointerPointProperties {IsLeftButtonPressed = true},
+            new FakePointer(), (IVisual)source, default,0, new PointerPointProperties {IsLeftButtonPressed = true},
             default);
         
         static PointerReleasedEventArgs CreateReleased(IInteractive source) => new PointerReleasedEventArgs(source,
-            new FakePointer(), (IVisual)source, default, new PointerPointProperties(), default, MouseButton.Left);
+            new FakePointer(), (IVisual)source, default,0, new PointerPointProperties(), default, MouseButton.Left);
         
         public class TopLevel
         {

tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests.cs

@@ -749,6 +749,40 @@ namespace Avalonia.Controls.UnitTests.Primitives
             Assert.Equal("b", target.SelectedItem);
         }
 
+        [Fact]
+        public void Mode_For_SelectedIndex_Is_TwoWay_By_Default()
+        {
+            var items = new[]
+            {
+                new Item(),
+                new Item(),
+                new Item(),
+            };
+
+            var vm = new MasterViewModel
+            {
+                Child = new ChildViewModel
+                {
+                    Items = items,
+                    SelectedIndex = 1,
+                }
+            };
+
+            var target = new SelectingItemsControl { DataContext = vm };
+            var itemsBinding = new Binding("Child.Items");
+            var selectedIndBinding = new Binding("Child.SelectedIndex");
+
+            target.Bind(SelectingItemsControl.ItemsProperty, itemsBinding);
+            target.Bind(SelectingItemsControl.SelectedIndexProperty, selectedIndBinding);
+
+            Assert.Equal(1, target.SelectedIndex);
+
+            target.SelectedIndex = 2;
+
+            Assert.Equal(2, target.SelectedIndex);
+            Assert.Equal(2, vm.Child.SelectedIndex);
+        }
+
         private FuncControlTemplate Template()
         {
             return new FuncControlTemplate<SelectingItemsControl>(control =>
@@ -785,6 +819,7 @@ namespace Avalonia.Controls.UnitTests.Primitives
         {
             public IList<Item> Items { get; set; }
             public Item SelectedItem { get; set; }
+            public int SelectedIndex { get; set; }
         }
 
         private class RootWithItems : TestRoot

tests/Avalonia.Controls.UnitTests/SharedSizeScopeTests.cs

@@ -1,284 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using Avalonia.Controls.Primitives;
-using Avalonia.Input;
-using Avalonia.Platform;
-using Avalonia.UnitTests;
-
-using Moq;
-
-using Xunit;
-
-namespace Avalonia.Controls.UnitTests
-{
-    public class SharedSizeScopeTests
-    {
-        public SharedSizeScopeTests()
-        {
-        }
-
-        [Fact]
-        public void All_Descendant_Grids_Are_Registered_When_Added_After_Setting_Scope()
-        {
-            var grids = new[] { new Grid(), new Grid(), new Grid() };
-            var scope = new Panel();
-            scope.Children.AddRange(grids);
-
-            var root = new TestRoot();
-            root.SetValue(Grid.IsSharedSizeScopeProperty, true);
-            root.Child = scope;
-
-            Assert.All(grids, g => Assert.True(g.HasSharedSizeScope()));
-        }
-
-        [Fact]
-        public void All_Descendant_Grids_Are_Registered_When_Setting_Scope()
-        {
-            var grids = new[] { new Grid(), new Grid(), new Grid() };
-            var scope = new Panel();
-            scope.Children.AddRange(grids);
-
-            var root = new TestRoot();
-            root.Child = scope;
-            root.SetValue(Grid.IsSharedSizeScopeProperty, true);
-
-            Assert.All(grids, g => Assert.True(g.HasSharedSizeScope()));
-        }
-
-        [Fact]
-        public void All_Descendant_Grids_Are_Unregistered_When_Resetting_Scope()
-        {
-            var grids = new[] { new Grid(), new Grid(), new Grid() };
-            var scope = new Panel();
-            scope.Children.AddRange(grids);
-
-            var root = new TestRoot();
-            root.SetValue(Grid.IsSharedSizeScopeProperty, true);
-            root.Child = scope;
-
-            Assert.All(grids, g => Assert.True(g.HasSharedSizeScope()));
-            root.SetValue(Grid.IsSharedSizeScopeProperty, false);
-            Assert.All(grids, g => Assert.False(g.HasSharedSizeScope()));
-            Assert.Equal(null, root.GetValue(Grid.s_sharedSizeScopeHostProperty));
-        }
-
-        [Fact]
-        public void Size_Is_Propagated_Between_Grids()
-        {
-            var grids = new[] { CreateGrid("A", null),CreateGrid(("A",new GridLength(30)), (null, new GridLength()))};
-            var scope = new Panel();
-            scope.Children.AddRange(grids);
-
-            var root = new TestRoot();
-            root.SetValue(Grid.IsSharedSizeScopeProperty, true);
-            root.Child = scope;
-
-            root.Measure(new Size(50, 50));
-            root.Arrange(new Rect(new Point(), new Point(50, 50)));
-            Assert.Equal(30, grids[0].ColumnDefinitions[0].ActualWidth);
-        }
-
-        [Fact]
-        public void Size_Propagation_Is_Constrained_To_Innermost_Scope()
-        {
-            var grids = new[] { CreateGrid("A", null), CreateGrid(("A", new GridLength(30)), (null, new GridLength())) };
-            var innerScope = new Panel();
-            innerScope.Children.AddRange(grids);
-            innerScope.SetValue(Grid.IsSharedSizeScopeProperty, true);
-
-            var outerGrid = CreateGrid(("A", new GridLength(0)));
-            var outerScope = new Panel();
-            outerScope.Children.AddRange(new[] { outerGrid, innerScope });
-
-            var root = new TestRoot();
-            root.SetValue(Grid.IsSharedSizeScopeProperty, true);
-            root.Child = outerScope;
-
-            root.Measure(new Size(50, 50));
-            root.Arrange(new Rect(new Point(), new Point(50, 50)));
-            Assert.Equal(0, outerGrid.ColumnDefinitions[0].ActualWidth);
-        }
-
-        [Fact]
-        public void Size_Is_Propagated_Between_Rows_And_Columns()
-        {
-            var grid = new Grid
-            {
-                ColumnDefinitions = new ColumnDefinitions("*,30"),
-                RowDefinitions = new RowDefinitions("*,10")
-            };
-
-            grid.ColumnDefinitions[1].SharedSizeGroup = "A";
-            grid.RowDefinitions[1].SharedSizeGroup = "A";
-
-            var root = new TestRoot();
-            root.SetValue(Grid.IsSharedSizeScopeProperty, true);
-            root.Child = grid;
-
-            root.Measure(new Size(50, 50));
-            root.Arrange(new Rect(new Point(), new Point(50, 50)));
-            Assert.Equal(30, grid.RowDefinitions[1].ActualHeight);
-        }
-
-        [Fact]
-        public void Size_Group_Changes_Are_Tracked()
-        {
-            var grids = new[] {
-                CreateGrid((null, new GridLength(0, GridUnitType.Auto)), (null, new GridLength())),
-                CreateGrid(("A", new GridLength(30)), (null, new GridLength())) };
-            var scope = new Panel();
-            scope.Children.AddRange(grids);
-
-            var root = new TestRoot();
-            root.SetValue(Grid.IsSharedSizeScopeProperty, true);
-            root.Child = scope;
-
-            root.Measure(new Size(50, 50));
-            root.Arrange(new Rect(new Point(), new Point(50, 50)));
-            Assert.Equal(0, grids[0].ColumnDefinitions[0].ActualWidth);
-
-            grids[0].ColumnDefinitions[0].SharedSizeGroup = "A";
-
-            root.Measure(new Size(51, 51));
-            root.Arrange(new Rect(new Point(), new Point(51, 51)));
-            Assert.Equal(30, grids[0].ColumnDefinitions[0].ActualWidth);
-
-            grids[0].ColumnDefinitions[0].SharedSizeGroup = null;
-
-            root.Measure(new Size(52, 52));
-            root.Arrange(new Rect(new Point(), new Point(52, 52)));
-            Assert.Equal(0, grids[0].ColumnDefinitions[0].ActualWidth);
-        }
-
-        [Fact]
-        public void Collection_Changes_Are_Tracked()
-        {
-            var grid = CreateGrid(
-                ("A", new GridLength(20)),
-                ("A", new GridLength(30)),
-                ("A", new GridLength(40)),
-                (null, new GridLength()));
-
-            var scope = new Panel();
-            scope.Children.Add(grid);
-
-            var root = new TestRoot();
-            root.SetValue(Grid.IsSharedSizeScopeProperty, true);
-            root.Child = scope;
-
-            grid.Measure(new Size(200, 200));
-            grid.Arrange(new Rect(new Point(), new Point(200, 200)));
-            Assert.All(grid.ColumnDefinitions.Where(cd => cd.SharedSizeGroup == "A"), cd => Assert.Equal(40, cd.ActualWidth));
-
-            grid.ColumnDefinitions.RemoveAt(2);
-
-            grid.Measure(new Size(200, 200));
-            grid.Arrange(new Rect(new Point(), new Point(200, 200)));
-            Assert.All(grid.ColumnDefinitions.Where(cd => cd.SharedSizeGroup == "A"), cd => Assert.Equal(30, cd.ActualWidth));
-
-            grid.ColumnDefinitions.Insert(1, new ColumnDefinition { Width = new GridLength(35), SharedSizeGroup = "A" });
-
-            grid.Measure(new Size(200, 200));
-            grid.Arrange(new Rect(new Point(), new Point(200, 200)));
-            Assert.All(grid.ColumnDefinitions.Where(cd => cd.SharedSizeGroup == "A"), cd => Assert.Equal(35, cd.ActualWidth));
-
-            grid.ColumnDefinitions[1] = new ColumnDefinition { Width = new GridLength(10), SharedSizeGroup = "A" };
-
-            grid.Measure(new Size(200, 200));
-            grid.Arrange(new Rect(new Point(), new Point(200, 200)));
-            Assert.All(grid.ColumnDefinitions.Where(cd => cd.SharedSizeGroup == "A"), cd => Assert.Equal(30, cd.ActualWidth));
-
-            grid.ColumnDefinitions[1] = new ColumnDefinition { Width = new GridLength(50), SharedSizeGroup = "A" };
-
-            grid.Measure(new Size(200, 200));
-            grid.Arrange(new Rect(new Point(), new Point(200, 200)));
-            Assert.All(grid.ColumnDefinitions.Where(cd => cd.SharedSizeGroup == "A"), cd => Assert.Equal(50, cd.ActualWidth));
-        }
-
-        [Fact]
-        public void Size_Priorities_Are_Maintained()
-        {
-            var sizers = new List<Control>();
-            var grid = CreateGrid(
-                ("A", new GridLength(20)), 
-                ("A", new GridLength(20, GridUnitType.Auto)), 
-                ("A", new GridLength(1, GridUnitType.Star)), 
-                ("A", new GridLength(1, GridUnitType.Star)),
-                (null, new GridLength()));
-            for (int i = 0; i < 3; i++)
-                sizers.Add(AddSizer(grid, i, 6 + i * 6));
-            var scope = new Panel();
-            scope.Children.Add(grid);
-
-            var root = new TestRoot();
-            root.SetValue(Grid.IsSharedSizeScopeProperty, true);
-            root.Child = scope;
-
-            grid.Measure(new Size(100, 100));
-            grid.Arrange(new Rect(new Point(), new Point(100, 100)));
-            // all in group are equal to the first fixed column
-            Assert.All(grid.ColumnDefinitions.Where(cd => cd.SharedSizeGroup == "A"), cd => Assert.Equal(20, cd.ActualWidth));
-
-            grid.ColumnDefinitions[0].SharedSizeGroup = null;
-
-            grid.Measure(new Size(100, 100));
-            grid.Arrange(new Rect(new Point(), new Point(100, 100)));
-            // all in group are equal to width (MinWidth) of the sizer in the second column
-            Assert.All(grid.ColumnDefinitions.Where(cd => cd.SharedSizeGroup == "A"), cd => Assert.Equal(6 + 1 * 6, cd.ActualWidth));
-
-            grid.ColumnDefinitions[1].SharedSizeGroup = null;
-
-            grid.Measure(new Size(double.PositiveInfinity, 100));
-            grid.Arrange(new Rect(new Point(), new Point(100, 100)));
-            // with no constraint star columns default to the MinWidth of the sizer in the column
-            Assert.All(grid.ColumnDefinitions.Where(cd => cd.SharedSizeGroup == "A"), cd => Assert.Equal(6 + 2 * 6, cd.ActualWidth));
-        }
-
-        // grid creators
-        private Grid CreateGrid(params string[] columnGroups)
-        {
-            return CreateGrid(columnGroups.Select(s => (s, ColumnDefinition.WidthProperty.GetDefaultValue(typeof(ColumnDefinition)))).ToArray());
-        }
-
-        private Grid CreateGrid(params (string name, GridLength width)[] columns)
-        {
-            return CreateGrid(columns.Select(c =>
-                (c.name, c.width, ColumnDefinition.MinWidthProperty.GetDefaultValue(typeof(ColumnDefinition)))).ToArray());
-        }
-
-        private Grid CreateGrid(params (string name, GridLength width, double minWidth)[] columns)
-        {
-            return CreateGrid(columns.Select(c =>
-                (c.name, c.width, c.minWidth, ColumnDefinition.MaxWidthProperty.GetDefaultValue(typeof(ColumnDefinition)))).ToArray());
-        }
-
-        private Grid CreateGrid(params (string name, GridLength width, double minWidth, double maxWidth)[] columns)
-        {
-            var columnDefinitions = new ColumnDefinitions();
-
-            columnDefinitions.AddRange(
-                    columns.Select(c => new ColumnDefinition
-                    {
-                        SharedSizeGroup = c.name,
-                        Width = c.width,
-                        MinWidth = c.minWidth,
-                        MaxWidth = c.maxWidth
-                    })
-                );
-            var grid = new Grid
-            {
-                ColumnDefinitions = columnDefinitions
-            };
-
-            return grid;
-        }
-
-        private Control AddSizer(Grid grid, int column, double size = 30)
-        {
-            var ctrl = new Control {  MinWidth = size, MinHeight = size };
-            ctrl.SetValue(Grid.ColumnProperty,column);
-            grid.Children.Add(ctrl);
-            return ctrl;
-        }
-    }
-}

tests/Avalonia.Input.UnitTests/MouseDeviceTests.cs

@@ -15,7 +15,7 @@ namespace Avalonia.Input.UnitTests
     public class MouseDeviceTests
     {
         [Fact]
-        public void Capture_Is_Cleared_When_Control_Removed()
+        public void Capture_Is_Transferred_To_Parent_When_Control_Removed()
         {
             Canvas control;
             var root = new TestRoot
@@ -29,7 +29,7 @@ namespace Avalonia.Input.UnitTests
 
             root.Child = null;
 
-            Assert.Null(target.Captured);
+            Assert.Same(root, target.Captured);
         }
 
         [Fact]

tests/Avalonia.Markup.Xaml.UnitTests/Xaml/XamlIlTests.cs

@@ -158,6 +158,82 @@ namespace Avalonia.Markup.Xaml.UnitTests
             Assert.Equal("321", loaded.Test);
             
         }
+
+        void AssertThrows(Action callback, Func<Exception, bool> check)
+        {
+            try
+            {
+                callback();
+            }
+            catch (Exception e) when (check(e))
+            {
+                return;
+            }
+
+            throw new Exception("Expected exception was not thrown");
+        }
+        
+        public static object SomeStaticProperty { get; set; }
+
+        [Fact]
+        public void Bug2570()
+        {
+            SomeStaticProperty = "123";
+            AssertThrows(() => new AvaloniaXamlLoader() {IsDesignMode = true}
+                    .Load(@"
+<UserControl 
+    xmlns='https://github.com/avaloniaui'
+    xmlns:d='http://schemas.microsoft.com/expression/blend/2008'
+    xmlns:tests='clr-namespace:Avalonia.Markup.Xaml.UnitTests'
+    d:DataContext='{x:Static tests:XamlIlTests.SomeStaticPropery}'
+    xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'/>", typeof(XamlIlTests).Assembly),
+                e => e.Message.Contains("Unable to resolve ")
+                     && e.Message.Contains(" as static field, property, constant or enum value"));
+
+        }
+        
+        [Fact]
+        public void Design_Mode_DataContext_Should_Be_Set()
+        {
+            SomeStaticProperty = "123";
+            
+            var loaded = (UserControl)new AvaloniaXamlLoader() {IsDesignMode = true}
+                .Load(@"
+<UserControl 
+    xmlns='https://github.com/avaloniaui'
+    xmlns:d='http://schemas.microsoft.com/expression/blend/2008'
+    xmlns:tests='clr-namespace:Avalonia.Markup.Xaml.UnitTests'
+    d:DataContext='{x:Static tests:XamlIlTests.SomeStaticProperty}'
+    xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'/>", typeof(XamlIlTests).Assembly);
+            Assert.Equal(Design.GetDataContext(loaded), SomeStaticProperty);
+        }
+        
+        [Fact]
+        public void Attached_Properties_From_Static_Types_Should_Work_In_Style_Setters_Bug_2561()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+
+                var parsed = (Window)AvaloniaXamlLoader.Parse(@"
+<Window
+  xmlns='https://github.com/avaloniaui'
+  xmlns:local='clr-namespace:Avalonia.Markup.Xaml.UnitTests;assembly=Avalonia.Markup.Xaml.UnitTests'
+>
+  <Window.Styles>
+    <Style Selector='TextBox'>
+      <Setter Property='local:XamlIlBugTestsStaticClassWithAttachedProperty.TestInt' Value='100'/>
+    </Style>
+  </Window.Styles>
+  <TextBox/>
+
+</Window>
+");
+                var tb = ((TextBox)parsed.Content);
+                parsed.Show();
+                tb.ApplyTemplate();
+                Assert.Equal(100, XamlIlBugTestsStaticClassWithAttachedProperty.GetTestInt(tb));
+            }
+        }
     }
     
     public class XamlIlBugTestsEventHandlerCodeBehind : Window
@@ -188,7 +264,7 @@ namespace Avalonia.Markup.Xaml.UnitTests
             ((ItemsControl)Content).Items = new[] {"123"};
         }
     }
-
+    
     public class XamlIlClassWithCustomProperty : UserControl
     {
         public string Test { get; set; }
@@ -223,4 +299,19 @@ namespace Avalonia.Markup.Xaml.UnitTests
     {
     }
 
+    public static class XamlIlBugTestsStaticClassWithAttachedProperty
+    {
+        public static readonly AvaloniaProperty<int> TestIntProperty = AvaloniaProperty
+            .RegisterAttached<Control, int>("TestInt", typeof(XamlIlBugTestsStaticClassWithAttachedProperty));
+
+        public static void SetTestInt(Control control, int value)
+        {
+            control.SetValue(TestIntProperty, value);
+        }
+
+        public static int GetTestInt(Control control)
+        {
+            return (int)control.GetValue(TestIntProperty);
+        }
+    }
 }

tests/Avalonia.ReactiveUI.UnitTests/Attributes.cs

@@ -0,0 +1,9 @@
+// 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.
+
+using Xunit;
+
+// Required to avoid InvalidOperationException sometimes thrown
+// from Splat.MemoizingMRUCache.cs which is not thread-safe.
+// Thrown when trying to access WhenActivated concurrently.
+[assembly: CollectionBehavior(DisableTestParallelization = true)]

tests/Avalonia.ReactiveUI.UnitTests/AutoDataTemplateBindingHookTest.cs

@@ -0,0 +1,116 @@
+// 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.
+
+using Xunit;
+using ReactiveUI;
+using Avalonia.ReactiveUI;
+using Avalonia.UnitTests;
+using Avalonia.Controls;
+using Avalonia.Controls.Templates;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using Avalonia.VisualTree;
+using Avalonia.Controls.Presenters;
+using Splat;
+using System.Threading.Tasks;
+using System;
+
+namespace Avalonia.ReactiveUI.UnitTests
+{
+    public class AutoDataTemplateBindingHookTest
+    {
+        public class NestedViewModel : ReactiveObject { }
+
+        public class NestedView : ReactiveUserControl<NestedViewModel> { }
+
+        public class ExampleViewModel : ReactiveObject 
+        {
+            public ObservableCollection<NestedViewModel> Items { get; } = new ObservableCollection<NestedViewModel>();
+        }
+
+        public class ExampleView : ReactiveUserControl<ExampleViewModel>
+        {
+            public ItemsControl List { get; } = new ItemsControl();
+
+            public ExampleView()
+            {
+                Content = List;
+                ViewModel = new ExampleViewModel();
+                this.OneWayBind(ViewModel, x => x.Items, x => x.List.Items);
+            }
+        }
+
+        public AutoDataTemplateBindingHookTest() 
+        {
+            Locator.CurrentMutable.RegisterConstant(new AutoDataTemplateBindingHook(), typeof(IPropertyBindingHook));
+            Locator.CurrentMutable.RegisterConstant(new AvaloniaActivationForViewFetcher(), typeof(IActivationForViewFetcher));
+            Locator.CurrentMutable.Register(() => new NestedView(), typeof(IViewFor<NestedViewModel>));
+        }
+
+        [Fact]
+        public void Should_Apply_Data_Template_Binding_When_No_Template_Is_Set()
+        {
+            var view = new ExampleView();
+            Assert.NotNull(view.List.ItemTemplate);
+        }
+
+        [Fact]
+        public void Should_Use_View_Model_View_Host_As_Data_Template()
+        {
+            var view = new ExampleView();
+            view.ViewModel.Items.Add(new NestedViewModel());
+
+            view.List.Template = GetTemplate();
+            view.List.ApplyTemplate();
+            view.List.Presenter.ApplyTemplate();
+
+            var child = view.List.Presenter.Panel.Children[0];
+            var container = (ContentPresenter) child;
+            container.UpdateChild();
+
+            Assert.IsType<ViewModelViewHost>(container.Child);
+        }
+
+        [Fact]
+        public void Should_Resolve_And_Embedd_Appropriate_View_Model()
+        {
+            var view = new ExampleView();
+            var root = new TestRoot { Child = view };
+            view.ViewModel.Items.Add(new NestedViewModel());
+
+            view.List.Template = GetTemplate();
+            view.List.ApplyTemplate();
+            view.List.Presenter.ApplyTemplate();
+
+            var child = view.List.Presenter.Panel.Children[0];
+            var container = (ContentPresenter) child;
+            container.UpdateChild();
+
+            var host = (ViewModelViewHost) container.Child;
+            Assert.IsType<NestedViewModel>(host.ViewModel);
+            Assert.IsType<NestedViewModel>(host.DataContext);
+
+            host.DataContext = "changed context";
+            Assert.IsType<string>(host.ViewModel);
+            Assert.IsType<string>(host.DataContext);
+        }
+
+        private FuncControlTemplate GetTemplate()
+        {
+            return new FuncControlTemplate<ItemsControl>(parent =>
+            {
+                return new Border
+                {
+                    Background = new Media.SolidColorBrush(0xffffffff),
+                    Child = new ItemsPresenter
+                    {
+                        Name = "PART_ItemsPresenter",
+                        MemberSelector = parent.MemberSelector,
+                        [~ItemsPresenter.ItemsProperty] = parent[~ItemsControl.ItemsProperty],
+                    }
+                };
+            });
+        }
+    }
+}

tests/Avalonia.ReactiveUI.UnitTests/AvaloniaActivationForViewFetcherTest.cs

@@ -1,3 +1,6 @@
+// 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.
+
 using System;
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
@@ -13,7 +16,7 @@ using Splat;
 using Avalonia.Markup.Xaml;
 using Avalonia.ReactiveUI;
 
-namespace Avalonia 
+namespace Avalonia.ReactiveUI.UnitTests
 {
     public class AvaloniaActivationForViewFetcherTest
     {

tests/Avalonia.ReactiveUI.UnitTests/ReactiveUserControlTest.cs

@@ -0,0 +1,34 @@
+// 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.
+
+using Avalonia.Controls;
+using Avalonia.UnitTests;
+using ReactiveUI;
+using Splat;
+using Xunit;
+
+namespace Avalonia.ReactiveUI.UnitTests
+{
+    public class ReactiveUserControlTest
+    {
+        public class ExampleViewModel : ReactiveObject { }
+
+        public class ExampleView : ReactiveUserControl<ExampleViewModel> { }
+
+        [Fact]
+        public void Data_Context_Should_Stay_In_Sync_With_Reactive_User_Control_View_Model() 
+        {
+            var view = new ExampleView();
+            var viewModel = new ExampleViewModel();
+            Assert.Null(view.ViewModel);
+
+            view.DataContext = viewModel;
+            Assert.Equal(view.ViewModel, viewModel);
+            Assert.Equal(view.DataContext, viewModel);
+
+            view.DataContext = null;
+            Assert.Null(view.ViewModel);
+            Assert.Null(view.DataContext);
+        }
+    }
+}

tests/Avalonia.ReactiveUI.UnitTests/ReactiveWindowTest.cs

@@ -0,0 +1,37 @@
+// 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.
+
+using Avalonia.Controls;
+using Avalonia.UnitTests;
+using ReactiveUI;
+using Splat;
+using Xunit;
+
+namespace Avalonia.ReactiveUI.UnitTests
+{
+    public class ReactiveWindowTest
+    {
+        public class ExampleViewModel : ReactiveObject { }
+
+        public class ExampleWindow : ReactiveWindow<ExampleViewModel> { }
+
+        [Fact]
+        public void Data_Context_Should_Stay_In_Sync_With_Reactive_Window_View_Model() 
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var view = new ExampleWindow();
+                var viewModel = new ExampleViewModel();
+                Assert.Null(view.ViewModel);
+
+                view.DataContext = viewModel;
+                Assert.Equal(view.ViewModel, viewModel);
+                Assert.Equal(view.DataContext, viewModel);
+
+                view.DataContext = null;
+                Assert.Null(view.ViewModel);
+                Assert.Null(view.DataContext);
+            }
+        }
+    }
+}

tests/Avalonia.ReactiveUI.UnitTests/RoutedViewHostTest.cs

@@ -1,3 +1,6 @@
+// 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.
+
 using System;
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
@@ -16,7 +19,7 @@ using System.Threading.Tasks;
 using System.Reactive;
 using Avalonia.ReactiveUI;
 
-namespace Avalonia
+namespace Avalonia.ReactiveUI.UnitTests
 {
     public class RoutedViewHostTest
     {
@@ -59,8 +62,7 @@ namespace Avalonia
             { 
                 Router = screen.Router,
                 DefaultContent = defaultContent,
-                FadeOutAnimation = null,
-                FadeInAnimation = null
+                PageTransition = null
             };
 
             var root = new TestRoot 

tests/Avalonia.ReactiveUI.UnitTests/TransitioningContentControlTest.cs

@@ -0,0 +1,63 @@
+// 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.
+
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Controls.Presenters;
+using Avalonia.Controls.Templates;
+using Avalonia.UnitTests;
+using Avalonia.VisualTree;
+using ReactiveUI;
+using Splat;
+using Xunit;
+
+namespace Avalonia.ReactiveUI.UnitTests
+{
+    public class TransitioningContentControlTest
+    {
+        [Fact]
+        public void Transitioning_Control_Should_Derive_Template_From_Content_Control()
+        {
+            var target = new TransitioningContentControl();
+            var stylable = (IStyledElement)target;
+            Assert.Equal(typeof(ContentControl),stylable.StyleKey);
+        }
+
+        [Fact]
+        public void Transitioning_Control_Template_Should_Be_Instantiated() 
+        {
+            var target = new TransitioningContentControl
+            {
+                PageTransition = null,
+                Template = GetTemplate(),
+                Content = "Foo"
+            };
+            target.ApplyTemplate();
+            ((ContentPresenter)target.Presenter).UpdateChild();
+
+            var child = ((IVisual)target).VisualChildren.Single();
+            Assert.IsType<Border>(child);
+            child = child.VisualChildren.Single();
+            Assert.IsType<ContentPresenter>(child);
+            child = child.VisualChildren.Single();
+            Assert.IsType<TextBlock>(child);
+        }
+
+        private FuncControlTemplate GetTemplate()
+        {
+            return new FuncControlTemplate<ContentControl>(parent =>
+            {
+                return new Border
+                {
+                    Background = new Media.SolidColorBrush(0xffffffff),
+                    Child = new ContentPresenter
+                    {
+                        Name = "PART_ContentPresenter",
+                        [~ContentPresenter.ContentProperty] = parent[~ContentControl.ContentProperty],
+                        [~ContentPresenter.ContentTemplateProperty] = parent[~ContentControl.ContentTemplateProperty],
+                    }
+                };
+            });
+        }
+    }
+}

tests/Avalonia.ReactiveUI.UnitTests/ViewModelViewHostTest.cs

@@ -0,0 +1,74 @@
+// 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.
+
+using Avalonia.Controls;
+using Avalonia.UnitTests;
+using ReactiveUI;
+using Splat;
+using Xunit;
+
+namespace Avalonia.ReactiveUI.UnitTests
+{
+    public class ViewModelViewHostTest
+    {
+        public class FirstViewModel { }
+
+        public class FirstView : ReactiveUserControl<FirstViewModel> { }
+
+        public class SecondViewModel : ReactiveObject { }
+
+        public class SecondView : ReactiveUserControl<SecondViewModel> { }
+
+        public ViewModelViewHostTest()
+        {
+            Locator.CurrentMutable.RegisterConstant(new AvaloniaActivationForViewFetcher(), typeof(IActivationForViewFetcher));
+            Locator.CurrentMutable.Register(() => new FirstView(), typeof(IViewFor<FirstViewModel>));
+            Locator.CurrentMutable.Register(() => new SecondView(), typeof(IViewFor<SecondViewModel>));
+        }
+
+        [Fact]
+        public void ViewModelViewHost_View_Should_Stay_In_Sync_With_ViewModel() 
+        {
+            var defaultContent = new TextBlock();
+            var host = new ViewModelViewHost 
+            {
+                DefaultContent = defaultContent,
+                PageTransition = null
+            };
+
+            var root = new TestRoot 
+            { 
+                Child = host 
+            };
+            
+            Assert.NotNull(host.Content);
+            Assert.Equal(typeof(TextBlock), host.Content.GetType());
+            Assert.Equal(defaultContent, host.Content);
+
+            var first = new FirstViewModel();
+            host.ViewModel = first;
+            Assert.NotNull(host.Content);
+            Assert.Equal(typeof(FirstView), host.Content.GetType());
+            Assert.Equal(first, ((FirstView)host.Content).DataContext);
+            Assert.Equal(first, ((FirstView)host.Content).ViewModel);
+
+            var second = new SecondViewModel();
+            host.ViewModel = second;
+            Assert.NotNull(host.Content);
+            Assert.Equal(typeof(SecondView), host.Content.GetType());
+            Assert.Equal(second, ((SecondView)host.Content).DataContext);
+            Assert.Equal(second, ((SecondView)host.Content).ViewModel);
+
+            host.ViewModel = null;
+            Assert.NotNull(host.Content);
+            Assert.Equal(typeof(TextBlock), host.Content.GetType());
+            Assert.Equal(defaultContent, host.Content);
+
+            host.ViewModel = first;
+            Assert.NotNull(host.Content);
+            Assert.Equal(typeof(FirstView), host.Content.GetType());
+            Assert.Equal(first, ((FirstView)host.Content).DataContext);
+            Assert.Equal(first, ((FirstView)host.Content).ViewModel);
+        }
+    }
+}