Merge branch 'master' into datagrid-rowdetails

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();
 

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
+                                    if (i[c].OpCode == OpCodes.Call)
-                                        && 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;
+                                            if (MatchThisCall(i, c - 1))
-                                            foundXamlLoader = true;
+                                            {
+                                                i[c].Operand = trampoline;
+                                                foundXamlLoader = true;
+                                            }
                                         }
                                     }
                                 }

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
+        public double ActualWidth => Parent?.GetFinalColumnDefinitionWidth(Index) ?? 0d;
-        {
-            get;
-            internal set;
-        }
 
         /// <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.
+// This source file is adapted from the Windows Presentation Foundation project. 
-// Licensed under the MIT license. See licence.md file in the project root for full license information.
+// (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>
+        //  Constructors
-        public static readonly StyledProperty<string> SharedSizeGroupProperty =
+        //
-            AvaloniaProperty.Register<DefinitionBase, string>(nameof(SharedSizeGroup), inherits: true);
+        //------------------------------------------------------
+
+        #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/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
+        public double ActualHeight => Parent?.GetFinalRowDefinitionHeight(Index) ?? 0d;
-        {
-            get;
-            internal set;
-        }
 
         /// <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.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,18 +14,14 @@ 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;
+        private readonly Pointer _pointer = new Pointer(Pointer.GetNextFreeId(), PointerType.Mouse, true);
-        bool IPointer.IsPrimary => true;
+
-        int IPointer.Id { get; } = Pointer.GetNextFreeId();
-        
         /// <summary>
         /// Gets the control that is currently capturing by the mouse, if any.
         /// </summary>
@@ -34,27 +30,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
+        [Obsolete("Use IPointer instead")]
-        {
+        public IInputElement Captured => _pointer.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);
-                }
 
-                _captured = value;
-            }
-        }
-        
         /// <summary>
         /// Gets the mouse position, in screen coordinates.
         /// </summary>
@@ -75,8 +53,7 @@ namespace Avalonia.Input
         /// </remarks>
         public virtual void Capture(IInputElement control)
         {
-            // TODO: Check visibility and enabled state before setting capture.
+            _pointer.Capture(control);
-            Captured = control;
         }
 
         /// <summary>
@@ -110,13 +87,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 +121,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 +136,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 +172,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 +189,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 +206,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 +215,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 +223,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);
+                SetPointerOver(this, timestamp, root, _pointer.Captured, inputModifiers);
-                source = Captured;
+                source = _pointer.Captured;
             }
 
-            var e = new PointerEventArgs(InputElement.PointerMovedEvent, source, this, root,
+            var e = new PointerEventArgs(InputElement.PointerMovedEvent, source, _pointer, root,
-                p, properties, inputModifiers);
+                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 +251,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 +274,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 +287,7 @@ namespace Avalonia.Input
         {
             Contract.Requires<ArgumentNullException>(hit != null);
 
-            return Captured ??
+            return _pointer.Captured ??
                 (hit as IInteractive) ??
                 hit.GetSelfAndVisualAncestors().OfType<IInteractive>().FirstOrDefault();
         }
@@ -318,22 +296,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,
+            return new PointerEventArgs(ev, source, _pointer, null, default,
-                new PointerPointProperties(inputModifiers), inputModifiers);
+                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 +348,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 +359,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 +392,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,40 @@ 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);
+        }
+        
         public void Capture(IInputElement control)
         {
             if (Captured != null)
                 Captured.DetachedFromVisualTree -= OnCaptureDetached;
+            var oldCapture = control;
             Captured = 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 +57,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()
+        public void Dispose() => Capture(null);
-        {
-            if (ImplicitlyCaptured != null)
-                ImplicitlyCaptured.DetachedFromVisualTree -= OnImplicitCaptureDetached;
-            if (Captured != null)
-                Captured.DetachedFromVisualTree -= OnCaptureDetached;
-        }
     }
 }

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,
+            : base(InputElement.PointerPressedEvent, source, pointer, rootVisual, rootVisualPosition,
-                modifiers)
+                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,
+            IVisual rootVisual, Point rootVisualPosition, ulong timestamp,
-            MouseButton obsoleteMouseButton)
+            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),
+                    args.Root, args.Position, ev.Timestamp,
-                    modifiers));
+                    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),
+                        args.Root, args.Position, ev.Timestamp,
-                        modifiers, pointer.IsPrimary ? MouseButton.Left : MouseButton.None));
+                        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,
+                    var attribs = new[]
-                    EGL_RENDERABLE_TYPE, cfg.RenderableTypeBit,
+                    {
-                    EGL_RED_SIZE, 8,
+                        EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
-                    EGL_GREEN_SIZE, 8,
+
-                    EGL_BLUE_SIZE, 8,
+                        EGL_RENDERABLE_TYPE, cfg.RenderableTypeBit,
-                    EGL_ALPHA_SIZE, 8,
+
-                    EGL_STENCIL_SIZE, 8,
+                        EGL_RED_SIZE, 8,
-                    EGL_DEPTH_SIZE, 8,
+                        EGL_GREEN_SIZE, 8,
-                    EGL_NONE
+                        EGL_BLUE_SIZE, 8,
-                };
+                        EGL_ALPHA_SIZE, 8,
-                if (!_egl.ChooseConfig(_display, attribs, out _config, 1, out int numConfigs))
+                        EGL_STENCIL_SIZE, stencilSize,
-                    continue;
+                        EGL_DEPTH_SIZE, depthSize,
-                if (numConfigs == 0)
+                        EGL_NONE
-                    continue;
+                    };
-                _contextAttributes = cfg.Attributes;
+                    if (!_egl.ChooseConfig(_display, attribs, out _config, 1, out int numConfigs))
-                Type = cfg.Type;
+                        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.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/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/Markup/Avalonia.Markup.Xaml/XamlIl/xamlil.github

@@ -1 +1 @@
-Subproject commit a73c5234831267b23160e01a9fbc83be633f69fc
+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/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)
@@ -634,8 +637,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 +644,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 +668,26 @@ namespace Avalonia.Win32
                     break;
 
                 case UnmanagedMethods.WindowsMessage.WM_PAINT:
-                    UnmanagedMethods.PAINTSTRUCT ps;
+                    using (_rendererLock.Lock())
-                    if (UnmanagedMethods.BeginPaint(_hwnd, out ps) != IntPtr.Zero)
                     {
-                        var f = Scaling;
+                        UnmanagedMethods.PAINTSTRUCT ps;
-                        var r = ps.rcPaint;
+                        if (UnmanagedMethods.BeginPaint(_hwnd, out ps) != IntPtr.Zero)
-                        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);
+                            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 +753,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
     {
-
+        private Pointer _pointer = new Pointer(Pointer.GetNextFreeId(), PointerType.Mouse, true);
-        class TestPointer : IPointer
+        private ulong _nextStamp = 1;
-        {
+        private ulong Timestamp() => _nextStamp++;
-            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 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/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,55 @@ 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);
+        }
     }
     
     public class XamlIlBugTestsEventHandlerCodeBehind : Window
@@ -188,7 +237,7 @@ namespace Avalonia.Markup.Xaml.UnitTests
             ((ItemsControl)Content).Items = new[] {"123"};
         }
     }
-
+    
     public class XamlIlClassWithCustomProperty : UserControl
     {
         public string Test { get; set; }