Merge remote-tracking branch 'origin/master' into fixes/affect-renderer-memory-leak

samples/BindingDemo/ViewModels/ExceptionErrorViewModel.cs

@@ -21,7 +21,7 @@ namespace BindingDemo.ViewModels
                 }
                 else
                 {
-                    throw new ArgumentOutOfRangeException("Value must be less than 10.");
+                    throw new ArgumentOutOfRangeException(nameof(value), "Value must be less than 10.");
                 }
             }
         }

samples/ControlCatalog/Pages/ContextMenuPage.xaml

@@ -10,7 +10,8 @@
               HorizontalAlignment="Center"
               Spacing="16">
             <Border Background="{DynamicResource ThemeAccentBrush}"
-              Padding="48,48,48,48">
+                    Margin="16"
+                    Padding="48,48,48,48">
                 <Border.ContextMenu>
                     <ContextMenu>
                         <MenuItem Header="Standard _Menu Item"/>
@@ -31,7 +32,24 @@
                         </MenuItem>
                     </ContextMenu>
                 </Border.ContextMenu>
-                <TextBlock Text="Right Click Here"/>
+                <TextBlock Text="Defined in XAML"/>
+            </Border>
+            <Border Background="{DynamicResource ThemeAccentBrush}"
+                    Margin="16"
+                    Padding="48,48,48,48">
+                <Border.ContextMenu>
+                    <ContextMenu Items="{Binding MenuItems}">
+                        <ContextMenu.Styles>
+                            <Style Selector="MenuItem">
+                                <Setter Property="Header" Value="{Binding Header}"/>
+                                <Setter Property="Items" Value="{Binding Items}"/>
+                                <Setter Property="Command" Value="{Binding Command}"/>
+                                <Setter Property="CommandParameter" Value="{Binding CommandParameter}"/>
+                            </Style>
+                        </ContextMenu.Styles>
+                    </ContextMenu>
+                </Border.ContextMenu>
+                <TextBlock Text="Dynamically Generated"/>
             </Border>
         </StackPanel>
     </StackPanel>

samples/ControlCatalog/Pages/ContextMenuPage.xaml.cs

@@ -1,5 +1,6 @@
 using Avalonia.Controls;
 using Avalonia.Markup.Xaml;
+using ControlCatalog.ViewModels;
 
 namespace ControlCatalog.Pages
 {
@@ -8,6 +9,7 @@ namespace ControlCatalog.Pages
         public ContextMenuPage()
         {
             this.InitializeComponent();
+            DataContext = new ContextMenuPageViewModel();
         }
 
         private void InitializeComponent()

samples/ControlCatalog/Pages/MenuPage.xaml.cs

@@ -4,6 +4,7 @@ using System.Threading.Tasks;
 using System.Windows.Input;
 using Avalonia.Controls;
 using Avalonia.Markup.Xaml;
+using ControlCatalog.ViewModels;
 using ReactiveUI;
 
 namespace ControlCatalog.Pages
@@ -13,51 +14,7 @@ namespace ControlCatalog.Pages
         public MenuPage()
         {
             this.InitializeComponent();
-            var vm = new MenuPageViewModel();
+            DataContext = new MenuPageViewModel();
-
-            vm.MenuItems = new[]
-            {
-                new MenuItemViewModel
-                {
-                    Header = "_File",
-                    Items = new[]
-                    {
-                        new MenuItemViewModel { Header = "_Open...", Command = vm.OpenCommand },
-                        new MenuItemViewModel { Header = "Save", Command = vm.SaveCommand },
-                        new MenuItemViewModel { Header = "-" },
-                        new MenuItemViewModel
-                        {
-                            Header = "Recent",
-                            Items = new[]
-                            {
-                                new MenuItemViewModel
-                                {
-                                    Header = "File1.txt",
-                                    Command = vm.OpenRecentCommand,
-                                    CommandParameter = @"c:\foo\File1.txt"
-                                },
-                                new MenuItemViewModel
-                                {
-                                    Header = "File2.txt",
-                                    Command = vm.OpenRecentCommand,
-                                    CommandParameter = @"c:\foo\File2.txt"
-                                },
-                            }
-                        },
-                    }
-                },
-                new MenuItemViewModel
-                {
-                    Header = "_Edit",
-                    Items = new[]
-                    {
-                        new MenuItemViewModel { Header = "_Copy" },
-                        new MenuItemViewModel { Header = "_Paste" },
-                    }
-                }
-            };
-
-            DataContext = vm;
         }
 
         private void InitializeComponent()
@@ -65,51 +22,4 @@ namespace ControlCatalog.Pages
             AvaloniaXamlLoader.Load(this);
         }
     }
-
-    public class MenuPageViewModel
-    {
-        public MenuPageViewModel()
-        {
-            OpenCommand = ReactiveCommand.CreateFromTask(Open);
-            SaveCommand = ReactiveCommand.Create(Save);
-            OpenRecentCommand = ReactiveCommand.Create<string>(OpenRecent);
-        }
-
-        public IReadOnlyList<MenuItemViewModel> MenuItems { get; set; }
-        public ReactiveCommand<Unit, Unit> OpenCommand { get; }
-        public ReactiveCommand<Unit, Unit> SaveCommand { get; }
-        public ReactiveCommand<string, Unit> OpenRecentCommand { get; }
-
-        public async Task Open()
-        {
-            var dialog = new OpenFileDialog();
-            var result = await dialog.ShowAsync(App.Current.MainWindow);
-
-            if (result != null)
-            {
-                foreach (var path in result)
-                {
-                    System.Diagnostics.Debug.WriteLine($"Opened: {path}");
-                }
-            }
-        }
-
-        public void Save()
-        {
-            System.Diagnostics.Debug.WriteLine("Save");
-        }
-
-        public void OpenRecent(string path)
-        {
-            System.Diagnostics.Debug.WriteLine($"Open recent: {path}");
-        }
-    }
-
-    public class MenuItemViewModel
-    {
-        public string Header { get; set; }
-        public ICommand Command { get; set; }
-        public object CommandParameter { get; set; }
-        public IList<MenuItemViewModel> Items { get; set; }
-    }
 }

samples/ControlCatalog/SideBar.xaml

@@ -1,6 +1,14 @@
 <Styles xmlns="https://github.com/avaloniaui"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         x:Class="ControlCatalog.SideBar">
+    <Design.PreviewWith>
+        <Border Padding="20">
+            <TabControl Classes="sidebar">
+                <TabItem Header="Item1"/>
+                <TabItem Header="Item2"/>
+            </TabControl> 
+        </Border>
+    </Design.PreviewWith>
     <Style Selector="TabControl.sidebar">
         <Setter Property="TabStripPlacement" Value="Left"/>
         <Setter Property="Padding" Value="8 0 0 0"/>

samples/ControlCatalog/ViewModels/ContextMenuPageViewModel.cs

@@ -0,0 +1,73 @@
+using System.Collections.Generic;
+using System.Reactive;
+using System.Threading.Tasks;
+using Avalonia.Controls;
+using ReactiveUI;
+
+namespace ControlCatalog.ViewModels
+{
+    public class ContextMenuPageViewModel
+    {
+        public ContextMenuPageViewModel()
+        {
+            OpenCommand = ReactiveCommand.CreateFromTask(Open);
+            SaveCommand = ReactiveCommand.Create(Save);
+            OpenRecentCommand = ReactiveCommand.Create<string>(OpenRecent);
+
+            MenuItems = new[]
+            {
+                new MenuItemViewModel { Header = "_Open...", Command = OpenCommand },
+                new MenuItemViewModel { Header = "Save", Command = SaveCommand },
+                new MenuItemViewModel { Header = "-" },
+                new MenuItemViewModel
+                {
+                    Header = "Recent",
+                    Items = new[]
+                    {
+                        new MenuItemViewModel
+                        {
+                            Header = "File1.txt",
+                            Command = OpenRecentCommand,
+                            CommandParameter = @"c:\foo\File1.txt"
+                        },
+                        new MenuItemViewModel
+                        {
+                            Header = "File2.txt",
+                            Command = OpenRecentCommand,
+                            CommandParameter = @"c:\foo\File2.txt"
+                        },
+                    }
+                },
+            };
+        }
+
+        public IReadOnlyList<MenuItemViewModel> MenuItems { get; set; }
+        public ReactiveCommand<Unit, Unit> OpenCommand { get; }
+        public ReactiveCommand<Unit, Unit> SaveCommand { get; }
+        public ReactiveCommand<string, Unit> OpenRecentCommand { get; }
+
+        public async Task Open()
+        {
+            var dialog = new OpenFileDialog();
+            var result = await dialog.ShowAsync(App.Current.MainWindow);
+
+            if (result != null)
+            {
+                foreach (var path in result)
+                {
+                    System.Diagnostics.Debug.WriteLine($"Opened: {path}");
+                }
+            }
+        }
+
+        public void Save()
+        {
+            System.Diagnostics.Debug.WriteLine("Save");
+        }
+
+        public void OpenRecent(string path)
+        {
+            System.Diagnostics.Debug.WriteLine($"Open recent: {path}");
+        }
+    }
+}

samples/ControlCatalog/ViewModels/MenuItemViewModel.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using System.Windows.Input;
+
+namespace ControlCatalog.ViewModels
+{
+    public class MenuItemViewModel
+    {
+        public string Header { get; set; }
+        public ICommand Command { get; set; }
+        public object CommandParameter { get; set; }
+        public IList<MenuItemViewModel> Items { get; set; }
+    }
+}

samples/ControlCatalog/ViewModels/MenuPageViewModel.cs

@@ -0,0 +1,89 @@
+using System.Collections.Generic;
+using System.Reactive;
+using System.Threading.Tasks;
+using Avalonia.Controls;
+using ReactiveUI;
+
+namespace ControlCatalog.ViewModels
+{
+    public class MenuPageViewModel
+    {
+        public MenuPageViewModel()
+        {
+            OpenCommand = ReactiveCommand.CreateFromTask(Open);
+            SaveCommand = ReactiveCommand.Create(Save);
+            OpenRecentCommand = ReactiveCommand.Create<string>(OpenRecent);
+
+            MenuItems = new[]
+            {
+                new MenuItemViewModel
+                {
+                    Header = "_File",
+                    Items = new[]
+                    {
+                        new MenuItemViewModel { Header = "_Open...", Command = OpenCommand },
+                        new MenuItemViewModel { Header = "Save", Command = SaveCommand },
+                        new MenuItemViewModel { Header = "-" },
+                        new MenuItemViewModel
+                        {
+                            Header = "Recent",
+                            Items = new[]
+                            {
+                                new MenuItemViewModel
+                                {
+                                    Header = "File1.txt",
+                                    Command = OpenRecentCommand,
+                                    CommandParameter = @"c:\foo\File1.txt"
+                                },
+                                new MenuItemViewModel
+                                {
+                                    Header = "File2.txt",
+                                    Command = OpenRecentCommand,
+                                    CommandParameter = @"c:\foo\File2.txt"
+                                },
+                            }
+                        },
+                    }
+                },
+                new MenuItemViewModel
+                {
+                    Header = "_Edit",
+                    Items = new[]
+                    {
+                        new MenuItemViewModel { Header = "_Copy" },
+                        new MenuItemViewModel { Header = "_Paste" },
+                    }
+                }
+            };
+        }
+
+        public IReadOnlyList<MenuItemViewModel> MenuItems { get; set; }
+        public ReactiveCommand<Unit, Unit> OpenCommand { get; }
+        public ReactiveCommand<Unit, Unit> SaveCommand { get; }
+        public ReactiveCommand<string, Unit> OpenRecentCommand { get; }
+
+        public async Task Open()
+        {
+            var dialog = new OpenFileDialog();
+            var result = await dialog.ShowAsync(App.Current.MainWindow);
+
+            if (result != null)
+            {
+                foreach (var path in result)
+                {
+                    System.Diagnostics.Debug.WriteLine($"Opened: {path}");
+                }
+            }
+        }
+
+        public void Save()
+        {
+            System.Diagnostics.Debug.WriteLine("Save");
+        }
+
+        public void OpenRecent(string path)
+        {
+            System.Diagnostics.Debug.WriteLine($"Open recent: {path}");
+        }
+    }
+}

src/Avalonia.Base/Data/Core/Plugins/MethodAccessorPlugin.cs

@@ -21,7 +21,7 @@ namespace Avalonia.Data.Core.Plugins
             {
                 if (method.GetParameters().Length + (method.ReturnType == typeof(void) ? 0 : 1) > 8)
                 {
-                    var exception = new ArgumentException("Cannot create a binding accessor for a method with more than 8 parameters or more than 7 parameters if it has a non-void return type.", nameof(method));
+                    var exception = new ArgumentException("Cannot create a binding accessor for a method with more than 8 parameters or more than 7 parameters if it has a non-void return type.", nameof(methodName));
                     return new PropertyError(new BindingNotification(exception, BindingErrorType.Error));
                 }
 

src/Avalonia.Controls/ContextMenu.cs

@@ -1,34 +1,31 @@
 using System;
-using System.Reactive.Linq;
-using System.Linq;
 using System.ComponentModel;
+using System.Linq;
+using System.Reactive.Linq;
+using Avalonia.Controls.Generators;
 using Avalonia.Controls.Platform;
-using System.Collections.Generic;
+using Avalonia.Controls.Primitives;
+using Avalonia.Controls.Templates;
 using Avalonia.Input;
 using Avalonia.LogicalTree;
-using Avalonia.Controls.Primitives;
 
 namespace Avalonia.Controls
 {
-    public class ContextMenu : SelectingItemsControl, IMenu
+    /// <summary>
+    /// A control context menu.
+    /// </summary>
+    public class ContextMenu : MenuBase
     {
-        private readonly IMenuInteractionHandler _interaction;
+        private static readonly ITemplate<IPanel> DefaultPanel =
-        private bool _isOpen;
+            new FuncTemplate<IPanel>(() => new StackPanel { Orientation = Orientation.Vertical });
         private Popup _popup;
 
-        /// <summary>
-        /// Defines the <see cref="IsOpen"/> property.
-        /// </summary>
-        public static readonly DirectProperty<ContextMenu, bool> IsOpenProperty =
-                            AvaloniaProperty.RegisterDirect<ContextMenu, bool>(nameof(IsOpen), o => o.IsOpen);
-
         /// <summary>
         /// Initializes a new instance of the <see cref="ContextMenu"/> class.
         /// </summary>
         public ContextMenu()
+            : this(new DefaultMenuInteractionHandler(true))
         {
-            _interaction = AvaloniaLocator.Current.GetService<IMenuInteractionHandler>() ??
-                new DefaultMenuInteractionHandler();
         }
 
         /// <summary>
@@ -36,10 +33,8 @@ namespace Avalonia.Controls
         /// </summary>
         /// <param name="interactionHandler">The menu interaction handler.</param>
         public ContextMenu(IMenuInteractionHandler interactionHandler)
+            : base(interactionHandler)
         {
-            Contract.Requires<ArgumentNullException>(interactionHandler != null);
-
-            _interaction = interactionHandler;
         }
 
         /// <summary>
@@ -47,44 +42,10 @@ namespace Avalonia.Controls
         /// </summary>
         static ContextMenu()
         {
+            ItemsPanelProperty.OverrideDefaultValue(typeof(ContextMenu), DefaultPanel);
             ContextMenuProperty.Changed.Subscribe(ContextMenuChanged);
         }
 
-        /// <summary>
-        /// Gets a value indicating whether the popup is open
-        /// </summary>
-        public bool IsOpen => _isOpen;
-
-        /// <inheritdoc/>
-        IMenuInteractionHandler IMenu.InteractionHandler => _interaction;
-
-        /// <inheritdoc/>
-        IMenuItem IMenuElement.SelectedItem
-        {
-            get
-            {
-                var index = SelectedIndex;
-                return (index != -1) ?
-                    (IMenuItem)ItemContainerGenerator.ContainerFromIndex(index) :
-                    null;
-            }
-            set
-            {
-                SelectedIndex = ItemContainerGenerator.IndexFromContainer(value);
-            }
-        }
-
-        /// <inheritdoc/>
-        IEnumerable<IMenuItem> IMenuElement.SubItems
-        {
-            get
-            {
-                return ItemContainerGenerator.Containers
-                    .Select(x => x.ContainerControl)
-                    .OfType<IMenuItem>();
-            }
-        }
-
         /// <summary>
         /// Occurs when the value of the
         /// <see cref="P:Avalonia.Controls.ContextMenu.IsOpen" />
@@ -121,7 +82,7 @@ namespace Avalonia.Controls
         /// <summary>
         /// Opens the menu.
         /// </summary>
-        public void Open() => Open(null);
+        public override void Open() => Open(null);
 
         /// <summary>
         /// Opens a context menu on the specified control.
@@ -139,21 +100,20 @@ namespace Avalonia.Controls
                     ObeyScreenEdges = true
                 };
 
+                _popup.Opened += PopupOpened;
                 _popup.Closed += PopupClosed;
-                _interaction.Attach(this);
             }
 
             ((ISetLogicalParent)_popup).SetParent(control);
             _popup.Child = this;
             _popup.IsOpen = true;
-
+            IsOpen = true;
-            SetAndRaise(IsOpenProperty, ref _isOpen, true);
         }
 
         /// <summary>
         /// Closes the menu.
         /// </summary>
-        public void Close()
+        public override void Close()
         {
             if (_popup != null && _popup.IsVisible)
             {
@@ -161,8 +121,17 @@ namespace Avalonia.Controls
             }
 
             SelectedIndex = -1;
+            IsOpen = false;
+        }
+
+        protected override IItemContainerGenerator CreateItemContainerGenerator()
+        {
+            return new MenuItemContainerGenerator(this);
+        }
 
-            SetAndRaise(IsOpenProperty, ref _isOpen, false);
+        private void PopupOpened(object sender, EventArgs e)
+        {
+            Focus();
         }
 
         private void PopupClosed(object sender, EventArgs e)
@@ -176,7 +145,7 @@ namespace Avalonia.Controls
                     i.IsSubMenuOpen = false;
                 }
 
-                contextMenu._isOpen = false;
+                contextMenu.IsOpen = false;
                 contextMenu.SelectedIndex = -1;
             }
         }
@@ -186,7 +155,7 @@ namespace Avalonia.Controls
             var control = (Control)sender;
             var contextMenu = control.ContextMenu;
 
-            if (control.ContextMenu._isOpen)
+            if (control.ContextMenu.IsOpen)
             {
                 if (contextMenu.CancelClosing())
                     return;
@@ -218,10 +187,5 @@ namespace Avalonia.Controls
             ContextMenuOpening?.Invoke(this, eventArgs);
             return eventArgs.Cancel;
         }
-
-        bool IMenuElement.MoveSelection(NavigationDirection direction, bool wrap)
-        {
-            throw new NotImplementedException();
-        }
     }
 }

src/Avalonia.Controls/Design.cs

@@ -48,14 +48,14 @@ namespace Avalonia.Controls
         }
         
         public static readonly AttachedProperty<Control> PreviewWithProperty = AvaloniaProperty
-            .RegisterAttached<Style, Control>("PreviewWith", typeof (Design));
+            .RegisterAttached<AvaloniaObject, Control>("PreviewWith", typeof (Design));
 
-        public static void SetPreviewWith(Style target, Control control)
+        public static void SetPreviewWith(AvaloniaObject target, Control control)
         {
             target.SetValue(PreviewWithProperty, control);
         }
 
-        public static Control GetPreviewWith(Style target)
+        public static Control GetPreviewWith(AvaloniaObject target)
         {
             return target.GetValue(PreviewWithProperty);
         }

src/Avalonia.Controls/Embedding/Offscreen/OffscreenTopLevelImpl.cs

@@ -11,11 +11,13 @@ namespace Avalonia.Controls.Embedding.Offscreen
     {
         private double _scaling = 1;
         private Size _clientSize;
+
         public IInputRoot InputRoot { get; private set; }
+        public bool IsDisposed { get; private set; }
 
         public virtual void Dispose()
         {
-            //No-op
+            IsDisposed = true;
         }
 
         public IRenderer CreateRenderer(IRenderRoot root) => new ImmediateRenderer(root);

src/Avalonia.Controls/Menu.cs

@@ -1,56 +1,26 @@
 // 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.Generic;
-using System.Linq;
-using Avalonia.Controls.Generators;
 using Avalonia.Controls.Platform;
-using Avalonia.Controls.Primitives;
 using Avalonia.Controls.Templates;
 using Avalonia.Input;
 using Avalonia.Interactivity;
-using Avalonia.LogicalTree;
 
 namespace Avalonia.Controls
 {
     /// <summary>
     /// A top-level menu control.
     /// </summary>
-    public class Menu : SelectingItemsControl, IFocusScope, IMainMenu, IMenu
+    public class Menu : MenuBase, IMainMenu
     {
-        /// <summary>
-        /// Defines the <see cref="IsOpen"/> property.
-        /// </summary>
-        public static readonly DirectProperty<Menu, bool> IsOpenProperty =
-            AvaloniaProperty.RegisterDirect<Menu, bool>(
-                nameof(IsOpen),
-                o => o.IsOpen);
-
-        /// <summary>
-        /// Defines the <see cref="MenuOpened"/> event.
-        /// </summary>
-        public static readonly RoutedEvent<RoutedEventArgs> MenuOpenedEvent =
-            RoutedEvent.Register<MenuItem, RoutedEventArgs>(nameof(MenuOpened), RoutingStrategies.Bubble);
-
-        /// <summary>
-        /// Defines the <see cref="MenuClosed"/> event.
-        /// </summary>
-        public static readonly RoutedEvent<RoutedEventArgs> MenuClosedEvent =
-            RoutedEvent.Register<MenuItem, RoutedEventArgs>(nameof(MenuClosed), RoutingStrategies.Bubble);
-
         private static readonly ITemplate<IPanel> DefaultPanel =
             new FuncTemplate<IPanel>(() => new StackPanel { Orientation = Orientation.Horizontal });
-        private readonly IMenuInteractionHandler _interaction;
-        private bool _isOpen;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Menu"/> class.
         /// </summary>
         public Menu()
         {
-            _interaction = AvaloniaLocator.Current.GetService<IMenuInteractionHandler>() ?? 
-                new DefaultMenuInteractionHandler();
         }
 
         /// <summary>
@@ -58,82 +28,17 @@ namespace Avalonia.Controls
         /// </summary>
         /// <param name="interactionHandler">The menu interaction handler.</param>
         public Menu(IMenuInteractionHandler interactionHandler)
+            : base(interactionHandler)
         {
-            Contract.Requires<ArgumentNullException>(interactionHandler != null);
-
-            _interaction = interactionHandler;
         }
 
-        /// <summary>
-        /// Initializes static members of the <see cref="Menu"/> class.
-        /// </summary>
         static Menu()
         {
             ItemsPanelProperty.OverrideDefaultValue(typeof(Menu), DefaultPanel);
-            MenuItem.SubmenuOpenedEvent.AddClassHandler<Menu>(x => x.OnSubmenuOpened);
-        }
-
-        /// <summary>
-        /// Gets a value indicating whether the menu is open.
-        /// </summary>
-        public bool IsOpen
-        {
-            get { return _isOpen; }
-            private set { SetAndRaise(IsOpenProperty, ref _isOpen, value); }
-        }
-
-        /// <inheritdoc/>
-        IMenuInteractionHandler IMenu.InteractionHandler => _interaction;
-
-        /// <inheritdoc/>
-        IMenuItem IMenuElement.SelectedItem
-        {
-            get
-            {
-                var index = SelectedIndex;
-                return (index != -1) ?
-                    (IMenuItem)ItemContainerGenerator.ContainerFromIndex(index) :
-                    null;
-            }
-            set
-            {
-                SelectedIndex = ItemContainerGenerator.IndexFromContainer(value);
-            }
         }
 
         /// <inheritdoc/>
-        IEnumerable<IMenuItem> IMenuElement.SubItems
+        public override void Close()
-        {
-            get
-            {
-                return ItemContainerGenerator.Containers
-                    .Select(x => x.ContainerControl)
-                    .OfType<IMenuItem>();
-            }
-        }
-
-        /// <summary>
-        /// Occurs when a <see cref="Menu"/> is opened.
-        /// </summary>
-        public event EventHandler<RoutedEventArgs> MenuOpened
-        {
-            add { AddHandler(MenuOpenedEvent, value); }
-            remove { RemoveHandler(MenuOpenedEvent, value); }
-        }
-
-        /// <summary>
-        /// Occurs when a <see cref="Menu"/> is closed.
-        /// </summary>
-        public event EventHandler<RoutedEventArgs> MenuClosed
-        {
-            add { AddHandler(MenuClosedEvent, value); }
-            remove { RemoveHandler(MenuClosedEvent, value); }
-        }
-
-        /// <summary>
-        /// Closes the menu.
-        /// </summary>
-        public void Close()
         {
             if (IsOpen)
             {
@@ -153,10 +58,8 @@ namespace Avalonia.Controls
             }
         }
 
-        /// <summary>
+        /// <inheritdoc/>
-        /// Opens the menu in response to the Alt/F10 key.
+        public override void Open()
-        /// </summary>
-        public void Open()
         {
             if (!IsOpen)
             {
@@ -170,15 +73,6 @@ namespace Avalonia.Controls
             }
         }
 
-        /// <inheritdoc/>
-        bool IMenuElement.MoveSelection(NavigationDirection direction, bool wrap) => MoveSelection(direction, wrap);
-
-        /// <inheritdoc/>
-        protected override IItemContainerGenerator CreateItemContainerGenerator()
-        {
-            return new ItemContainerGenerator<MenuItem>(this, MenuItem.HeaderProperty, null);
-        }
-
         /// <inheritdoc/>
         protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
         {
@@ -190,41 +84,6 @@ namespace Avalonia.Controls
             {
                 inputRoot.AccessKeyHandler.MainMenu = this;
             }
-
-            _interaction.Attach(this);
-        }
-
-        /// <inheritdoc/>
-        protected override void OnDetachedFromVisualTree(VisualTreeAttachmentEventArgs e)
-        {
-            base.OnDetachedFromVisualTree(e);
-            _interaction.Detach(this);
-        }
-
-        /// <inheritdoc/>
-        protected override void OnKeyDown(KeyEventArgs e)
-        {
-            // Don't handle here: let the interaction handler handle it.
-        }
-
-        /// <summary>
-        /// Called when a submenu opens somewhere in the menu.
-        /// </summary>
-        /// <param name="e">The event args.</param>
-        protected virtual void OnSubmenuOpened(RoutedEventArgs e)
-        {
-            if (e.Source is MenuItem menuItem && menuItem.Parent == this)
-            {
-                foreach (var child in this.GetLogicalChildren().OfType<MenuItem>())
-                {
-                    if (child != menuItem && child.IsSubMenuOpen)
-                    {
-                        child.IsSubMenuOpen = false;
-                    }
-                }
-            }
-
-            IsOpen = true;
         }
     }
 }

src/Avalonia.Controls/MenuBase.cs

@@ -0,0 +1,192 @@
+// 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.Generic;
+using System.Linq;
+using Avalonia.Controls.Generators;
+using Avalonia.Controls.Platform;
+using Avalonia.Controls.Primitives;
+using Avalonia.Controls.Templates;
+using Avalonia.Input;
+using Avalonia.Interactivity;
+using Avalonia.LogicalTree;
+
+namespace Avalonia.Controls
+{
+    /// <summary>
+    /// Base class for menu controls.
+    /// </summary>
+    public abstract class MenuBase : SelectingItemsControl, IFocusScope, IMenu
+    {
+        /// <summary>
+        /// Defines the <see cref="IsOpen"/> property.
+        /// </summary>
+        public static readonly DirectProperty<Menu, bool> IsOpenProperty =
+            AvaloniaProperty.RegisterDirect<Menu, bool>(
+                nameof(IsOpen),
+                o => o.IsOpen);
+
+        /// <summary>
+        /// Defines the <see cref="MenuOpened"/> event.
+        /// </summary>
+        public static readonly RoutedEvent<RoutedEventArgs> MenuOpenedEvent =
+            RoutedEvent.Register<MenuItem, RoutedEventArgs>(nameof(MenuOpened), RoutingStrategies.Bubble);
+
+        /// <summary>
+        /// Defines the <see cref="MenuClosed"/> event.
+        /// </summary>
+        public static readonly RoutedEvent<RoutedEventArgs> MenuClosedEvent =
+            RoutedEvent.Register<MenuItem, RoutedEventArgs>(nameof(MenuClosed), RoutingStrategies.Bubble);
+
+        private bool _isOpen;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MenuBase"/> class.
+        /// </summary>
+        public MenuBase()
+        {
+            InteractionHandler = new DefaultMenuInteractionHandler(false);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MenuBase"/> class.
+        /// </summary>
+        /// <param name="interactionHandler">The menu interaction handler.</param>
+        public MenuBase(IMenuInteractionHandler interactionHandler)
+        {
+            Contract.Requires<ArgumentNullException>(interactionHandler != null);
+
+            InteractionHandler = interactionHandler;
+        }
+
+        /// <summary>
+        /// Initializes static members of the <see cref="MenuBase"/> class.
+        /// </summary>
+        static MenuBase()
+        {
+            MenuItem.SubmenuOpenedEvent.AddClassHandler<MenuBase>(x => x.OnSubmenuOpened);
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the menu is open.
+        /// </summary>
+        public bool IsOpen
+        {
+            get { return _isOpen; }
+            protected set { SetAndRaise(IsOpenProperty, ref _isOpen, value); }
+        }
+
+        /// <inheritdoc/>
+        IMenuInteractionHandler IMenu.InteractionHandler => InteractionHandler;
+
+        /// <inheritdoc/>
+        IMenuItem IMenuElement.SelectedItem
+        {
+            get
+            {
+                var index = SelectedIndex;
+                return (index != -1) ?
+                    (IMenuItem)ItemContainerGenerator.ContainerFromIndex(index) :
+                    null;
+            }
+            set
+            {
+                SelectedIndex = ItemContainerGenerator.IndexFromContainer(value);
+            }
+        }
+
+        /// <inheritdoc/>
+        IEnumerable<IMenuItem> IMenuElement.SubItems
+        {
+            get
+            {
+                return ItemContainerGenerator.Containers
+                    .Select(x => x.ContainerControl)
+                    .OfType<IMenuItem>();
+            }
+        }
+
+        /// <summary>
+        /// Gets the interaction handler for the menu.
+        /// </summary>
+        protected IMenuInteractionHandler InteractionHandler { get; }
+
+        /// <summary>
+        /// Occurs when a <see cref="Menu"/> is opened.
+        /// </summary>
+        public event EventHandler<RoutedEventArgs> MenuOpened
+        {
+            add { AddHandler(MenuOpenedEvent, value); }
+            remove { RemoveHandler(MenuOpenedEvent, value); }
+        }
+
+        /// <summary>
+        /// Occurs when a <see cref="Menu"/> is closed.
+        /// </summary>
+        public event EventHandler<RoutedEventArgs> MenuClosed
+        {
+            add { AddHandler(MenuClosedEvent, value); }
+            remove { RemoveHandler(MenuClosedEvent, value); }
+        }
+
+        /// <summary>
+        /// Closes the menu.
+        /// </summary>
+        public abstract void Close();
+
+        /// <summary>
+        /// Opens the menu.
+        /// </summary>
+        public abstract void Open();
+
+        /// <inheritdoc/>
+        bool IMenuElement.MoveSelection(NavigationDirection direction, bool wrap) => MoveSelection(direction, wrap);
+
+        /// <inheritdoc/>
+        protected override IItemContainerGenerator CreateItemContainerGenerator()
+        {
+            return new ItemContainerGenerator<MenuItem>(this, MenuItem.HeaderProperty, null);
+        }
+
+        /// <inheritdoc/>
+        protected override void OnKeyDown(KeyEventArgs e)
+        {
+            // Don't handle here: let the interaction handler handle it.
+        }
+
+        /// <inheritdoc/>
+        protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
+        {
+            base.OnAttachedToVisualTree(e);
+            InteractionHandler.Attach(this);
+        }
+
+        /// <inheritdoc/>
+        protected override void OnDetachedFromVisualTree(VisualTreeAttachmentEventArgs e)
+        {
+            base.OnDetachedFromVisualTree(e);
+            InteractionHandler.Detach(this);
+        }
+
+        /// <summary>
+        /// Called when a submenu opens somewhere in the menu.
+        /// </summary>
+        /// <param name="e">The event args.</param>
+        protected virtual void OnSubmenuOpened(RoutedEventArgs e)
+        {
+            if (e.Source is MenuItem menuItem && menuItem.Parent == this)
+            {
+                foreach (var child in this.GetLogicalChildren().OfType<MenuItem>())
+                {
+                    if (child != menuItem && child.IsSubMenuOpen)
+                    {
+                        child.IsSubMenuOpen = false;
+                    }
+                }
+            }
+
+            IsOpen = true;
+        }
+    }
+}

src/Avalonia.Controls/NumericUpDown/NumericUpDown.cs

@@ -965,11 +965,11 @@ namespace Avalonia.Controls
         {
             if (value < Minimum)
             {
-                throw new ArgumentOutOfRangeException(nameof(Minimum), string.Format("Value must be greater than Minimum value of {0}", Minimum));
+                throw new ArgumentOutOfRangeException(nameof(value), string.Format("Value must be greater than Minimum value of {0}", Minimum));
             }
             else if (value > Maximum)
             {
-                throw new ArgumentOutOfRangeException(nameof(Maximum), string.Format("Value must be less than Maximum value of {0}", Maximum));
+                throw new ArgumentOutOfRangeException(nameof(value), string.Format("Value must be less than Maximum value of {0}", Maximum));
             }
         }
 

src/Avalonia.Controls/Platform/DefaultMenuInteractionHandler.cs

@@ -13,18 +13,21 @@ namespace Avalonia.Controls.Platform
     /// </summary>
     public class DefaultMenuInteractionHandler : IMenuInteractionHandler
     {
+        private readonly bool _isContextMenu;
         private IDisposable _inputManagerSubscription;
         private IRenderRoot _root;
 
-        public DefaultMenuInteractionHandler()
+        public DefaultMenuInteractionHandler(bool isContextMenu)
-            : this(Input.InputManager.Instance, DefaultDelayRun)
+            : this(isContextMenu, Input.InputManager.Instance, DefaultDelayRun)
         {
         }
 
         public DefaultMenuInteractionHandler(
+            bool isContextMenu,
             IInputManager inputManager,
             Action<Action, TimeSpan> delayRun)
         {
+            _isContextMenu = isContextMenu;
             InputManager = inputManager;
             DelayRun = delayRun;
         }
@@ -59,7 +62,7 @@ namespace Avalonia.Controls.Platform
                 window.Deactivated += WindowDeactivated;
             }
 
-            _inputManagerSubscription = InputManager.Process.Subscribe(RawInput);
+            _inputManagerSubscription = InputManager?.Process.Subscribe(RawInput);
         }
 
         public virtual void Detach(IMenu menu)
@@ -125,23 +128,16 @@ namespace Avalonia.Controls.Platform
 
         protected internal virtual void KeyDown(object sender, KeyEventArgs e)
         {
-            var item = GetMenuItem(e.Source as IControl);
+            KeyDown(GetMenuItem(e.Source as IControl), e);
-
-            if (item != null)
-            {
-                KeyDown(item, e);
-            }
         }
 
         protected internal virtual void KeyDown(IMenuItem item, KeyEventArgs e)
         {
-            Contract.Requires<ArgumentNullException>(item != null);
-
             switch (e.Key)
             {
                 case Key.Up:
                 case Key.Down:
-                    if (item.IsTopLevel)
+                    if (item?.IsTopLevel == true)
                     {
                         if (item.HasSubMenu && !item.IsSubMenuOpen)
                         {
@@ -156,7 +152,7 @@ namespace Avalonia.Controls.Platform
                     break;
 
                 case Key.Left:
-                    if (item.Parent is IMenuItem parent && !parent.IsTopLevel && parent.IsSubMenuOpen)
+                    if (item?.Parent is IMenuItem parent && !parent.IsTopLevel && parent.IsSubMenuOpen)
                     {
                         parent.Close();
                         parent.Focus();
@@ -169,7 +165,7 @@ namespace Avalonia.Controls.Platform
                     break;
 
                 case Key.Right:
-                    if (!item.IsTopLevel && item.HasSubMenu)
+                    if (item != null && !item.IsTopLevel && item.HasSubMenu)
                     {
                         Open(item, true);
                         e.Handled = true;
@@ -181,47 +177,65 @@ namespace Avalonia.Controls.Platform
                     break;
 
                 case Key.Enter:
-                    if (!item.HasSubMenu)
+                    if (item != null)
                     {
-                        Click(item);
+                        if (!item.HasSubMenu)
-                    }
+                        {
-                    else
+                            Click(item);
-                    {
+                        }
-                        Open(item, true);
+                        else
-                    }
+                        {
+                            Open(item, true);
+                        }
 
-                    e.Handled = true;
+                        e.Handled = true;
+                    }
                     break;
 
                 case Key.Escape:
-                    if (item.Parent != null)
+                    if (item?.Parent != null)
                     {
                         item.Parent.Close();
                         item.Parent.Focus();
-                        e.Handled = true;
                     }
+                    else
+                    {
+                        Menu.Close();
+                    }
+
+                    e.Handled = true;
                     break;
 
                 default:
                     var direction = e.Key.ToNavigationDirection();
 
-                    if (direction.HasValue && item.Parent?.MoveSelection(direction.Value, true) == true)
+                    if (direction.HasValue)
                     {
-                        // If the the parent is an IMenu which successfully moved its selection,
+                        if (item == null && _isContextMenu)
-                        // and the current menu is open then close the current menu and open the
-                        // new menu.
-                        if (item.IsSubMenuOpen && item.Parent is IMenu)
                         {
-                            item.Close();
+                            if (Menu.MoveSelection(direction.Value, true) == true)
-                            Open(item.Parent.SelectedItem, true);
+                            {
+                                e.Handled = true;
+                            }
+                        }
+                        else if (item.Parent?.MoveSelection(direction.Value, true) == true)
+                        {
+                            // If the the parent is an IMenu which successfully moved its selection,
+                            // and the current menu is open then close the current menu and open the
+                            // new menu.
+                            if (item.IsSubMenuOpen && item.Parent is IMenu)
+                            {
+                                item.Close();
+                                Open(item.Parent.SelectedItem, true);
+                            }
+                            e.Handled = true;
                         }
-                        e.Handled = true;
                     }
 
                     break;
             }
 
-            if (!e.Handled && item.Parent is IMenuItem parentItem)
+            if (!e.Handled && item?.Parent is IMenuItem parentItem)
             {
                 KeyDown(parentItem, e);
             }

src/Avalonia.Controls/Remote/Server/RemoteServerTopLevelImpl.cs

@@ -61,6 +61,11 @@ namespace Avalonia.Controls.Remote.Server
         {
             var result = InputModifiers.None;
 
+            if (modifiers == null)
+            {
+                return result;
+            }
+
             foreach(var modifier in modifiers)
             {
                 switch (modifier)
@@ -265,11 +270,15 @@ namespace Avalonia.Controls.Remote.Server
             var bpp = fmt == ProtocolPixelFormat.Rgb565 ? 2 : 4;
             var data = new byte[width * height * bpp];
             var handle = GCHandle.Alloc(data, GCHandleType.Pinned);
+
             try
             {
-                _framebuffer = new LockedFramebuffer(handle.AddrOfPinnedObject(), new PixelSize(width, height), width * bpp, _dpi, (PixelFormat)fmt,
+                if (width > 0 && height > 0)
-                    null);
+                {
-                Paint?.Invoke(new Rect(0, 0, width, height));
+                    _framebuffer = new LockedFramebuffer(handle.AddrOfPinnedObject(), new PixelSize(width, height), width * bpp, _dpi, (PixelFormat)fmt,
+                        null);
+                    Paint?.Invoke(new Rect(0, 0, width, height));
+                }
             }
             finally
             {
@@ -301,8 +310,7 @@ namespace Avalonia.Controls.Remote.Server
                     return;
 
             }
-            if (ClientSize.Width < 1 || ClientSize.Height < 1)
+
-                return;
             var format = ProtocolPixelFormat.Rgba8888;
             foreach(var fmt in _supportedFormats)
                 if (fmt <= ProtocolPixelFormat.MaxValue)
@@ -323,8 +331,11 @@ namespace Avalonia.Controls.Remote.Server
 
         public override void Invalidate(Rect rect)
         {
-            _invalidated = true;
+            if (!IsDisposed)
-            Dispatcher.UIThread.Post(RenderIfNeeded);
+            {
+                _invalidated = true;
+                Dispatcher.UIThread.Post(RenderIfNeeded);
+            }
         }
 
         public override IMouseDevice MouseDevice { get; } = new MouseDevice();

src/Avalonia.Controls/Shapes/Shape.cs

@@ -195,7 +195,7 @@ namespace Avalonia.Controls.Shapes
             if (deferCalculateTransform)
             {
                 _calculateTransformOnArrange = true;
-                return DefiningGeometry.Bounds.Size;
+                return DefiningGeometry?.Bounds.Size ?? Size.Empty;
             }
             else
             {
@@ -217,17 +217,22 @@ namespace Avalonia.Controls.Shapes
 
         private Size CalculateShapeSizeAndSetTransform(Size availableSize)
         {
-            // This should probably use GetRenderBounds(strokeThickness) but then the calculations
+            if (DefiningGeometry != null)
-            // will multiply the stroke thickness as well, which isn't correct.
-            var (size, transform) = CalculateSizeAndTransform(availableSize, DefiningGeometry.Bounds, Stretch);
-
-            if (_transform != transform)
             {
-                _transform = transform;
+                // This should probably use GetRenderBounds(strokeThickness) but then the calculations
-                _renderedGeometry = null;
+                // will multiply the stroke thickness as well, which isn't correct.
+                var (size, transform) = CalculateSizeAndTransform(availableSize, DefiningGeometry.Bounds, Stretch);
+
+                if (_transform != transform)
+                {
+                    _transform = transform;
+                    _renderedGeometry = null;
+                }
+
+                return size;
             }
 
-            return size;
+            return Size.Empty;
         }
 
         internal static (Size, Matrix) CalculateSizeAndTransform(Size availableSize, Rect shapeBounds, Stretch Stretch)

src/Avalonia.DesignerSupport/DesignWindowLoader.cs

@@ -35,13 +35,13 @@ namespace Avalonia.DesignerSupport
 
                 var localAsm = assemblyPath != null ? Assembly.LoadFile(Path.GetFullPath(assemblyPath)) : null;
                 var loaded = loader.Load(stream, localAsm, null, baseUri);
-                var styles = loaded as Styles;
+                var style = loaded as IStyle;
-                if (styles != null)
+                if (style != null)
                 {
-                    var substitute = styles.OfType<Style>().Select(Design.GetPreviewWith).FirstOrDefault(s => s != null);
+                    var substitute = Design.GetPreviewWith((AvaloniaObject)style);
                     if (substitute != null)
                     {
-                        substitute.Styles.AddRange(styles);
+                        substitute.Styles.Add(style);
                         control = substitute;
                     }
                     else
@@ -51,8 +51,8 @@ namespace Avalonia.DesignerSupport
                             {
                                 new TextBlock {Text = "Styles can't be previewed without Design.PreviewWith. Add"},
                                 new TextBlock {Text = "<Design.PreviewWith>"},
-                                new TextBlock {Text = "    <Border Padding=20><!-- YOUR CONTROL FOR PREVIEW HERE--></Border>"},
+                                new TextBlock {Text = "    <Border Padding=20><!-- YOUR CONTROL FOR PREVIEW HERE --></Border>"},
-                                new TextBlock {Text = "<Design.PreviewWith>"},
+                                new TextBlock {Text = "</Design.PreviewWith>"},
                                 new TextBlock {Text = "before setters in your first Style"}
                             }
                         };

src/Avalonia.DesignerSupport/Remote/RemoteDesignerEntryPoint.cs

@@ -8,6 +8,7 @@ using Avalonia.Remote.Protocol;
 using Avalonia.Remote.Protocol.Designer;
 using Avalonia.Remote.Protocol.Viewport;
 using Avalonia.Threading;
+using Portable.Xaml;
 
 namespace Avalonia.DesignerSupport.Remote
 {
@@ -204,9 +205,18 @@ namespace Avalonia.DesignerSupport.Remote
                 }
                 catch (Exception e)
                 {
+                    var xamlException = e as XamlException;
+
                     s_transport.Send(new UpdateXamlResultMessage
                     {
-                        Error = e.ToString()
+                        Error = e.ToString(),
+                        Exception = new ExceptionDetails
+                        {
+                            ExceptionType = e.GetType().FullName,
+                            Message = e.Message.ToString(),
+                            LineNumber = xamlException?.LineNumber,
+                            LinePosition = xamlException?.LinePosition,
+                        }
                     });
                 }
             }

src/Avalonia.Input/InputElement.cs

@@ -375,7 +375,7 @@ namespace Avalonia.Input
         /// </summary>
         public void Focus()
         {
-            FocusManager.Instance.Focus(this);
+            FocusManager.Instance?.Focus(this);
         }
 
         /// <inheritdoc/>

src/Avalonia.Remote.Protocol/Avalonia.Remote.Protocol.csproj

@@ -2,6 +2,8 @@
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
     <DefineConstants>AVALONIA_REMOTE_PROTOCOL;$(DefineConstants)</DefineConstants>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>Key.snk</AssemblyOriginatorKeyFile>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="..\Avalonia.Input\Key.cs" />

src/Avalonia.Remote.Protocol/DesignMessages.cs

@@ -15,6 +15,7 @@ namespace Avalonia.Remote.Protocol.Designer
     {
         public string Error { get; set; }
         public string Handle { get; set; }
+        public ExceptionDetails Exception { get; set; }
     }
 
     [AvaloniaRemoteMessageGuid("854887CF-2694-4EB6-B499-7461B6FB96C7")]
@@ -23,4 +24,11 @@ namespace Avalonia.Remote.Protocol.Designer
         public string SessionId { get; set; }
     }
     
+    public class ExceptionDetails
+    {
+        public string ExceptionType { get; set; }
+        public string Message { get; set; }
+        public int? LineNumber { get; set; }
+        public int? LinePosition { get; set; }
+    }
 }

src/Avalonia.Remote.Protocol/MetsysBson.cs

@@ -749,7 +749,7 @@ namespace Metsys.Bson
 
                         if (memberExpression.Expression.NodeType != ExpressionType.Parameter && memberExpression.Expression.NodeType != ExpressionType.Convert)
                         {
-                            throw new ArgumentException(string.Format("Expression '{0}' must resolve to top-level member.", lambdaExpression), "lambdaExpression");
+                            throw new ArgumentException(string.Format("Expression '{0}' must resolve to top-level member.", lambdaExpression), nameof(lambdaExpression));
                         }
                         return memberExpression.Member.Name;
                     default:

src/Avalonia.Styling/Styling/Selectors.cs

@@ -28,6 +28,9 @@ namespace Avalonia.Styling
         /// <returns>The selector.</returns>
         public static Selector Class(this Selector previous, string name)
         {
+            Contract.Requires<ArgumentNullException>(name != null);
+            Contract.Requires<ArgumentException>(!string.IsNullOrWhiteSpace(name));
+
             var tac = previous as TypeNameAndClassSelector;
 
             if (tac != null)
@@ -59,6 +62,8 @@ namespace Avalonia.Styling
         /// <returns>The selector.</returns>
         public static Selector Is(this Selector previous, Type type)
         {
+            Contract.Requires<ArgumentNullException>(type != null);
+
             return TypeNameAndClassSelector.Is(previous, type);
         }
 
@@ -81,6 +86,9 @@ namespace Avalonia.Styling
         /// <returns>The selector.</returns>
         public static Selector Name(this Selector previous, string name)
         {
+            Contract.Requires<ArgumentNullException>(name != null);
+            Contract.Requires<ArgumentException>(!string.IsNullOrWhiteSpace(name));
+
             var tac = previous as TypeNameAndClassSelector;
 
             if (tac != null)
@@ -113,6 +121,8 @@ namespace Avalonia.Styling
         /// <returns>The selector.</returns>
         public static Selector OfType(this Selector previous, Type type)
         {
+            Contract.Requires<ArgumentNullException>(type != null);
+
             return TypeNameAndClassSelector.OfType(previous, type);
         }
 
@@ -137,6 +147,8 @@ namespace Avalonia.Styling
         /// <returns>The selector.</returns>
         public static Selector PropertyEquals<T>(this Selector previous, AvaloniaProperty<T> property, object value)
         {
+            Contract.Requires<ArgumentNullException>(property != null);
+
             return new PropertyEqualsSelector(previous, property, value);
         }
 
@@ -149,6 +161,8 @@ namespace Avalonia.Styling
         /// <returns>The selector.</returns>
         public static Selector PropertyEquals(this Selector previous, AvaloniaProperty property, object value)
         {
+            Contract.Requires<ArgumentNullException>(property != null);
+
             return new PropertyEqualsSelector(previous, property, value);
         }
 

src/Avalonia.Styling/Styling/Styles.cs

@@ -2,7 +2,9 @@
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
+using System.Collections.Specialized;
 using System.Linq;
 using Avalonia.Collections;
 using Avalonia.Controls;
@@ -12,16 +14,17 @@ namespace Avalonia.Styling
     /// <summary>
     /// A style that consists of a number of child styles.
     /// </summary>
-    public class Styles : AvaloniaList<IStyle>, IStyle, ISetStyleParent
+    public class Styles : AvaloniaObject, IAvaloniaList<IStyle>, IStyle, ISetStyleParent
     {
         private IResourceNode _parent;
         private IResourceDictionary _resources;
+        private AvaloniaList<IStyle> _styles = new AvaloniaList<IStyle>();
         private Dictionary<Type, List<IStyle>> _cache;
 
         public Styles()
         {
-            ResetBehavior = ResetBehavior.Remove;
+            _styles.ResetBehavior = ResetBehavior.Remove;
-            this.ForEachItem(
+            _styles.ForEachItem(
                 x =>
                 {
                     if (x.ResourceParent == null && x is ISetStyleParent setParent)
@@ -57,9 +60,18 @@ namespace Avalonia.Styling
                 () => { });
         }
 
+        public event NotifyCollectionChangedEventHandler CollectionChanged
+        {
+            add => _styles.CollectionChanged += value;
+            remove => _styles.CollectionChanged -= value;
+        }
+
         /// <inheritdoc/>
         public event EventHandler<ResourcesChangedEventArgs> ResourcesChanged;
 
+        /// <inheritdoc/>
+        public int Count => _styles.Count;
+
         /// <inheritdoc/>
         public bool HasResources => _resources?.Count > 0 || this.Any(x => x.HasResources);
 
@@ -94,6 +106,19 @@ namespace Avalonia.Styling
         /// <inheritdoc/>
         IResourceNode IResourceNode.ResourceParent => _parent;
 
+        /// <inheritdoc/>
+        bool ICollection<IStyle>.IsReadOnly => false;
+
+        /// <inheritdoc/>
+        IStyle IReadOnlyList<IStyle>.this[int index] => _styles[index];
+
+        /// <inheritdoc/>
+        public IStyle this[int index]
+        {
+            get => _styles[index];
+            set => _styles[index] = value;
+        }
+
         /// <summary>
         /// Attaches the style to a control if the style's selector matches.
         /// </summary>
@@ -172,6 +197,54 @@ namespace Avalonia.Styling
             return false;
         }
 
+        /// <inheritdoc/>
+        public void AddRange(IEnumerable<IStyle> items) => _styles.AddRange(items);
+
+        /// <inheritdoc/>
+        public void InsertRange(int index, IEnumerable<IStyle> items) => _styles.InsertRange(index, items);
+
+        /// <inheritdoc/>
+        public void Move(int oldIndex, int newIndex) => _styles.Move(oldIndex, newIndex);
+
+        /// <inheritdoc/>
+        public void MoveRange(int oldIndex, int count, int newIndex) => _styles.MoveRange(oldIndex, count, newIndex);
+
+        /// <inheritdoc/>
+        public void RemoveAll(IEnumerable<IStyle> items) => _styles.RemoveAll(items);
+
+        /// <inheritdoc/>
+        public void RemoveRange(int index, int count) => _styles.RemoveRange(index, count);
+
+        /// <inheritdoc/>
+        public int IndexOf(IStyle item) => _styles.IndexOf(item);
+
+        /// <inheritdoc/>
+        public void Insert(int index, IStyle item) => _styles.Insert(index, item);
+
+        /// <inheritdoc/>
+        public void RemoveAt(int index) => _styles.RemoveAt(index);
+
+        /// <inheritdoc/>
+        public void Add(IStyle item) => _styles.Add(item);
+
+        /// <inheritdoc/>
+        public void Clear() => _styles.Clear();
+
+        /// <inheritdoc/>
+        public bool Contains(IStyle item) => _styles.Contains(item);
+
+        /// <inheritdoc/>
+        public void CopyTo(IStyle[] array, int arrayIndex) => _styles.CopyTo(array, arrayIndex);
+
+        /// <inheritdoc/>
+        public bool Remove(IStyle item) => _styles.Remove(item);
+
+        /// <inheritdoc/>
+        public IEnumerator<IStyle> GetEnumerator() => _styles.GetEnumerator();
+
+        /// <inheritdoc/>
+        IEnumerator IEnumerable.GetEnumerator() => _styles.GetEnumerator();
+
         /// <inheritdoc/>
         void ISetStyleParent.SetParent(IResourceNode parent)
         {

src/Avalonia.Themes.Default/ContextMenu.xaml

@@ -10,12 +10,22 @@
               BorderBrush="{TemplateBinding BorderBrush}"
               BorderThickness="{TemplateBinding BorderThickness}"
               Padding="{TemplateBinding Padding}">
-        <ItemsPresenter Name="PART_ItemsPresenter"
+          <ScrollViewer>
-                        Items="{TemplateBinding Items}"
+            <Panel>
-                        ItemsPanel="{TemplateBinding ItemsPanel}"
+              <ItemsPresenter Name="PART_ItemsPresenter"
-                        ItemTemplate="{TemplateBinding ItemTemplate}"
+                              Items="{TemplateBinding Items}"
-                        KeyboardNavigation.TabNavigation="Continue"/>
+                              ItemsPanel="{TemplateBinding ItemsPanel}"
+                              ItemTemplate="{TemplateBinding ItemTemplate}"
+                              KeyboardNavigation.TabNavigation="Continue"/>
+              <Rectangle Name="iconSeparator"
+                         Fill="{DynamicResource ThemeControlMidBrush}"
+                         HorizontalAlignment="Left"
+                         IsHitTestVisible="False"
+                         Margin="29,2,0,2"
+                         Width="1"/>
+              </Panel>
+          </ScrollViewer>
       </Border>
     </ControlTemplate>
   </Setter>
-</Style>
+</Style>

src/Avalonia.Visuals/Media/DrawingContext.cs

@@ -109,6 +109,8 @@ namespace Avalonia.Media
         /// <param name="geometry">The geometry.</param>
         public void DrawGeometry(IBrush brush, Pen pen, Geometry geometry)
         {
+            Contract.Requires<ArgumentNullException>(geometry != null);
+
             if (brush != null || PenIsVisible(pen))
             {
                 PlatformImpl.DrawGeometry(brush, pen, geometry.PlatformImpl);

src/Avalonia.Visuals/Media/GeometryDrawing.cs

@@ -31,7 +31,10 @@
 
         public override void Draw(DrawingContext context)
         {
-            context.DrawGeometry(Brush, Pen, Geometry);
+            if (Geometry != null)
+            {
+                context.DrawGeometry(Brush, Pen, Geometry);
+            }
         }
 
         public override Rect GetBounds()
@@ -41,4 +44,4 @@
             return Geometry?.GetRenderBounds(pen) ?? new Rect();
         }
     }
-}
+}

src/Avalonia.Visuals/Rendering/SceneGraph/GeometryNode.cs

@@ -89,9 +89,14 @@ namespace Avalonia.Rendering.SceneGraph
         /// <inheritdoc/>
         public override bool HitTest(Point p)
         {
-            p *= Transform.Invert();
+            if (Transform.HasInverse)
-            return (Brush != null && Geometry.FillContains(p)) || 
+            {
-                (Pen != null && Geometry.StrokeContains(Pen, p));
+                p *= Transform.Invert();
+                return (Brush != null && Geometry.FillContains(p)) ||
+                    (Pen != null && Geometry.StrokeContains(Pen, p));
+            }
+
+            return false;
         }
     }
 }

src/Avalonia.Visuals/Visual.cs

@@ -552,7 +552,7 @@ namespace Avalonia
         {
             if (c == null)
             {
-                throw new ArgumentNullException("Cannot add null to VisualChildren.");
+                throw new ArgumentNullException(nameof(c), "Cannot add null to VisualChildren.");
             }
 
             if (c.VisualParent != null)

src/Gtk/Avalonia.Gtk3/ImageSurfaceFramebuffer.cs

@@ -84,7 +84,7 @@ namespace Avalonia.Gtk3
             public RenderOp(GtkWidget widget, ManagedCairoSurface surface, double factor, int width, int height)
             {
                 _widget = widget;
-                _surface = surface ?? throw new ArgumentNullException();
+                _surface = surface ?? throw new ArgumentNullException(nameof(surface));
                 _factor = factor;
                 _width = width;
                 _height = height;

src/Markup/Avalonia.Markup.Xaml/Avalonia.Markup.Xaml.csproj

@@ -9,6 +9,7 @@
     <ItemGroup>
         <Compile Include="AvaloniaXamlLoader.cs" />
         <Compile Include="Converters\AvaloniaUriTypeConverter.cs" />
+        <Compile Include="Converters\AvaloniaEventConverter.cs" />
         <Compile Include="Converters\FontFamilyTypeConverter.cs" />
         <Compile Include="Converters\MemberSelectorTypeConverter.cs" />
         <Compile Include="Converters\NullableTypeConverter.cs" />

src/Markup/Avalonia.Markup.Xaml/AvaloniaTypeConverters.cs

@@ -11,6 +11,7 @@ using Avalonia.Controls.Templates;
 
 namespace Avalonia.Markup.Xaml
 {
+    using System.Reflection;
     using Avalonia.Media;
 
     /// <summary>
@@ -41,7 +42,8 @@ namespace Avalonia.Markup.Xaml
             { typeof(WindowIcon), typeof(IconTypeConverter) },
             { typeof(CultureInfo), typeof(CultureInfoConverter) },
             { typeof(Uri), typeof(AvaloniaUriTypeConverter) },
-            { typeof(FontFamily), typeof(FontFamilyTypeConverter) }
+            { typeof(FontFamily), typeof(FontFamilyTypeConverter) },
+            { typeof(EventInfo), typeof(AvaloniaEventConverter) },
         };
 
         internal static Type GetBuiltinTypeConverter(Type type)

src/Markup/Avalonia.Markup.Xaml/AvaloniaXamlLoader.cs

@@ -1,21 +1,20 @@
 // Copyright (c) The Avalonia Project. All rights reserved.
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
-using Avalonia.Controls;
-using Avalonia.Markup.Data;
-using Avalonia.Markup.Xaml.PortableXaml;
-using Avalonia.Platform;
-using Portable.Xaml;
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.IO;
+using System.Linq;
 using System.Reflection;
 using System.Runtime.Serialization;
-using System.Runtime.Serialization.Json;
 using System.Text;
 using System.Xml.Linq;
-using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Markup.Data;
+using Avalonia.Markup.Xaml.PortableXaml;
+using Avalonia.Platform;
+using Portable.Xaml;
 
 namespace Avalonia.Markup.Xaml
 {
@@ -24,29 +23,7 @@ namespace Avalonia.Markup.Xaml
     /// </summary>
     public class AvaloniaXamlLoader
     {
-        private readonly AvaloniaXamlSchemaContext _context = GetContext();
+        public bool IsDesignMode { get; set; }
-
-        public bool IsDesignMode
-        {
-            get => _context.IsDesignMode;
-            set => _context.IsDesignMode = value;
-        }
-
-        private static AvaloniaXamlSchemaContext GetContext()
-        {
-            var result = AvaloniaLocator.Current.GetService<AvaloniaXamlSchemaContext>();
-
-            if (result == null)
-            {
-                result = AvaloniaXamlSchemaContext.Create();
-
-                AvaloniaLocator.CurrentMutable
-                    .Bind<AvaloniaXamlSchemaContext>()
-                    .ToConstant(result);
-            }
-
-            return result;
-        }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="AvaloniaXamlLoader"/> class.
@@ -188,7 +165,8 @@ namespace Avalonia.Markup.Xaml
                 LocalAssembly = localAssembly
             };
 
-            var reader = new XamlXmlReader(stream, _context, readerSettings);
+            var context = IsDesignMode ? AvaloniaXamlSchemaContext.DesignInstance : AvaloniaXamlSchemaContext.Instance;
+            var reader = new XamlXmlReader(stream, context, readerSettings);
 
             object result = LoadFromReader(
                 reader,

src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaEventConverter.cs

@@ -0,0 +1,99 @@
+using System;
+using System.ComponentModel;
+using System.Globalization;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml.PortableXaml;
+using Portable.Xaml;
+
+namespace Avalonia.Markup.Xaml.Converters
+{
+    internal class AvaloniaEventConverter : TypeConverter
+    {
+        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+        {
+            return sourceType == typeof(string) || base.CanConvertFrom(context, sourceType);
+        }
+
+        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+        {
+            var text = value as string;
+            if (text != null)
+            {
+                var rootObjectProvider = context.GetService(typeof(IRootObjectProvider)) as IRootObjectProvider;
+                var destinationTypeProvider = context.GetService(typeof(IDestinationTypeProvider)) as IDestinationTypeProvider;
+                if (rootObjectProvider != null && destinationTypeProvider != null)
+                {
+                    var target = rootObjectProvider.RootObject;
+                    var eventType = destinationTypeProvider.GetDestinationType();
+                    var eventParameters = eventType.GetRuntimeMethods().First(r => r.Name == "Invoke").GetParameters();
+                    // go in reverse to match System.Xaml behaviour
+                    var methods = target.GetType().GetRuntimeMethods().Reverse();
+
+                    // find based on exact match parameter types first
+                    foreach (var method in methods)
+                    {
+                        if (method.Name != text)
+                            continue;
+                        var parameters = method.GetParameters();
+                        if (eventParameters.Length != parameters.Length)
+                            continue;
+                        if (parameters.Length == 0)
+                            return method.CreateDelegate(eventType, target);
+
+                        for (int i = 0; i < parameters.Length; i++)
+                        {
+                            var param = parameters[i];
+                            var eventParam = eventParameters[i];
+                            if (param.ParameterType != eventParam.ParameterType)
+                                break;
+                            if (i == parameters.Length - 1)
+                                return method.CreateDelegate(eventType, target);
+                        }
+                    }
+
+                    // EnhancedXaml: Find method with compatible base class parameters
+                    foreach (var method in methods)
+                    {
+                        if (method.Name != text)
+                            continue;
+                        var parameters = method.GetParameters();
+                        if (parameters.Length == 0 || eventParameters.Length != parameters.Length)
+                            continue;
+
+                        for (int i = 0; i < parameters.Length; i++)
+                        {
+                            var param = parameters[i];
+                            var eventParam = eventParameters[i];
+                            if (!param.ParameterType.GetTypeInfo().IsAssignableFrom(eventParam.ParameterType.GetTypeInfo()))
+                                break;
+                            if (i == parameters.Length - 1)
+                                return method.CreateDelegate(eventType, target);
+                        }
+                    }
+
+                    var contextProvider = (IXamlSchemaContextProvider)context.GetService(typeof(IXamlSchemaContextProvider));
+                    var avaloniaContext = (AvaloniaXamlSchemaContext)contextProvider.SchemaContext;
+
+                    if (avaloniaContext.IsDesignMode)
+                    {
+                        // We want to ignore missing events in the designer, so if event handler
+                        // wasn't found create an empty delegate.
+                        var lambdaExpression = Expression.Lambda(
+                            eventType,
+                            Expression.Empty(),
+                            eventParameters.Select(x => Expression.Parameter(x.ParameterType)));
+                        return lambdaExpression.Compile();
+                    }
+                    else
+                    {
+                        throw new XamlObjectWriterException($"Referenced value method {text} in type {target.GetType()} indicated by event {eventType.FullName} was not found");
+                    }
+                }
+            }
+            return base.ConvertFrom(context, culture, value);
+        }
+    }
+}

src/Markup/Avalonia.Markup.Xaml/PortableXaml/AvaloniaMemberAttributeProvider.cs

@@ -49,6 +49,18 @@ namespace Avalonia.Markup.Xaml.PortableXaml
                 //Portable.Xaml is not searching for Type Converter
                 result = new TypeConverterAttribute(typeof(SetterValueTypeConverter));
             }
+            else if (attributeType == typeof(TypeConverterAttribute) && _info is EventInfo)
+            {
+                // If a type converter for `EventInfo` is registered, then use that to convert
+                // event handler values. This is used by the designer to override the lookup
+                // for event handlers with a null handler.
+                var eventConverter = AvaloniaTypeConverters.GetTypeConverter(typeof(EventInfo));
+
+                if (eventConverter != null)
+                {
+                    result = new TypeConverterAttribute(eventConverter);
+                }
+            }
 
             if (result == null)
             {
@@ -68,4 +80,4 @@ namespace Avalonia.Markup.Xaml.PortableXaml
 
         private readonly MemberInfo _info;
     }
-}
+}

src/Markup/Avalonia.Markup.Xaml/PortableXaml/AvaloniaXamlSchemaContext.cs

@@ -1,21 +1,48 @@
-using Avalonia.Data;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using Avalonia.Data;
 using Avalonia.Markup.Xaml.Context;
-using Avalonia.Markup.Data;
 using Avalonia.Markup.Xaml.MarkupExtensions;
 using Avalonia.Markup.Xaml.Styling;
 using Portable.Xaml;
-using Portable.Xaml.ComponentModel;
-using System.ComponentModel;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
 
 namespace Avalonia.Markup.Xaml.PortableXaml
 {
     internal class AvaloniaXamlSchemaContext : XamlSchemaContext
     {
-        public bool IsDesignMode { get; set; }
+        private static AvaloniaXamlSchemaContext s_instance;
+        private static AvaloniaXamlSchemaContext s_designInstance;
+
+        public static AvaloniaXamlSchemaContext Instance
+        {
+            get
+            {
+                if (s_instance == null)
+                {
+                    s_instance = Create();
+                }
+
+                return s_instance;
+            }
+        }
+
+        public static AvaloniaXamlSchemaContext DesignInstance
+        {
+            get
+            {
+                if (s_designInstance == null)
+                {
+                    s_designInstance = Create();
+                    s_designInstance.IsDesignMode = true;
+                }
+
+                return s_designInstance;
+            }
+        }
+
+        public bool IsDesignMode { get; private set; }
         public static AvaloniaXamlSchemaContext Create(IRuntimeTypeProvider typeProvider = null)
         {
             return new AvaloniaXamlSchemaContext(typeProvider ?? new AvaloniaRuntimeTypeProvider());

src/Markup/Avalonia.Markup.Xaml/PortableXaml/AvaloniaXamlType.cs

@@ -385,4 +385,4 @@ namespace Avalonia.Markup.Xaml.PortableXaml
         {
         }
     }
-}
+}

src/Markup/Avalonia.Markup/Data/RelativeSource.cs

@@ -85,9 +85,9 @@ namespace Avalonia.Data
             get { return _ancestorLevel; }
             set
             {
-                if (_ancestorLevel <= 0)
+                if (value <= 0)
                 {
-                    throw new ArgumentOutOfRangeException("AncestorLevel may not be set to less than 1.");
+                    throw new ArgumentOutOfRangeException(nameof(value), "AncestorLevel may not be set to less than 1.");
                 }
 
                 _ancestorLevel = value;

src/Markup/Avalonia.Markup/Markup/Parsers/SelectorParser.cs

@@ -50,10 +50,10 @@ namespace Avalonia.Markup.Parsers
                 {
 
                     case SelectorGrammar.OfTypeSyntax ofType:
-                        result = result.OfType(_typeResolver(ofType.Xmlns, ofType.TypeName));
+                        result = result.OfType(Resolve(ofType.Xmlns, ofType.TypeName));
                         break;
                     case SelectorGrammar.IsSyntax @is:
-                        result = result.Is(_typeResolver(@is.Xmlns, @is.TypeName));
+                        result = result.Is(Resolve(@is.Xmlns, @is.TypeName));
                         break;
                     case SelectorGrammar.ClassSyntax @class:
                         result = result.Class(@class.Class);
@@ -113,5 +113,18 @@ namespace Avalonia.Markup.Parsers
 
             return result;
         }
+
+        private Type Resolve(string xmlns, string typeName)
+        {
+            var result = _typeResolver(xmlns, typeName);
+
+            if (result == null)
+            {
+                var type = string.IsNullOrWhiteSpace(xmlns) ? typeName : xmlns + ':' + typeName;
+                throw new InvalidOperationException($"Could not resolve type '{type}'");
+            }
+
+            return result;
+        }
     }
 }

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

@@ -13,7 +13,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void Up_Opens_MenuItem_With_SubMenu()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var item = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true);
                 var e = new KeyEventArgs { Key = Key.Up, Source = item };
 
@@ -27,7 +27,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void Down_Opens_MenuItem_With_SubMenu()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var item = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true);
                 var e = new KeyEventArgs { Key = Key.Down, Source = item };
 
@@ -41,7 +41,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void Right_Selects_Next_MenuItem()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var menu = Mock.Of<IMenu>(x => x.MoveSelection(NavigationDirection.Right, true) == true);
                 var item = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.Parent == menu);
                 var e = new KeyEventArgs { Key = Key.Right, Source = item };
@@ -55,7 +55,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void Left_Selects_Previous_MenuItem()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var menu = Mock.Of<IMenu>(x => x.MoveSelection(NavigationDirection.Left, true) == true);
                 var item = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.Parent == menu);
                 var e = new KeyEventArgs { Key = Key.Left, Source = item };
@@ -69,7 +69,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void Enter_On_Item_With_No_SubMenu_Causes_Click()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var menu = Mock.Of<IMenu>();
                 var item = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.Parent == menu);
                 var e = new KeyEventArgs { Key = Key.Enter, Source = item };
@@ -84,7 +84,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void Enter_On_Item_With_SubMenu_Opens_SubMenu()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var menu = Mock.Of<IMenu>();
                 var item = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.Parent == menu);
                 var e = new KeyEventArgs { Key = Key.Enter, Source = item };
@@ -99,7 +99,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void Escape_Closes_Parent_Menu()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var menu = Mock.Of<IMenu>();
                 var item = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.Parent == menu);
                 var e = new KeyEventArgs { Key = Key.Escape, Source = item };
@@ -113,7 +113,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void PointerEnter_Opens_Item_When_Old_Item_Is_Open()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var menu = new Mock<IMenu>();
                 var item = Mock.Of<IMenuItem>(x =>
                     x.IsSubMenuOpen == true &&
@@ -141,7 +141,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void PointerLeave_Deselects_Item_When_Menu_Not_Open()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var menu = new Mock<IMenu>();
                 var item = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.Parent == menu.Object);
                 var e = new PointerEventArgs { RoutedEvent = MenuItem.PointerLeaveItemEvent, Source = item };
@@ -156,7 +156,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void PointerLeave_Doesnt_Deselect_Item_When_Menu_Open()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var menu = new Mock<IMenu>();
                 var item = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.Parent == menu.Object);
                 var e = new PointerEventArgs { RoutedEvent = MenuItem.PointerLeaveItemEvent, Source = item };
@@ -175,7 +175,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void Up_Selects_Previous_MenuItem()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var parentItem = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true);
                 var item = Mock.Of<IMenuItem>(x => x.Parent == parentItem);
                 var e = new KeyEventArgs { Key = Key.Up, Source = item };
@@ -189,7 +189,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void Down_Selects_Next_MenuItem()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var parentItem = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true);
                 var item = Mock.Of<IMenuItem>(x => x.Parent == parentItem);
                 var e = new KeyEventArgs { Key = Key.Down, Source = item };
@@ -203,7 +203,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void Left_Closes_Parent_SubMenu()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var parentItem = Mock.Of<IMenuItem>(x => x.HasSubMenu == true && x.IsSubMenuOpen == true);
                 var item = Mock.Of<IMenuItem>(x => x.Parent == parentItem);
                 var e = new KeyEventArgs { Key = Key.Left, Source = item };
@@ -218,7 +218,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void Right_With_SubMenu_Items_Opens_SubMenu()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var parentItem = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true);
                 var item = Mock.Of<IMenuItem>(x => x.Parent == parentItem && x.HasSubMenu == true);
                 var e = new KeyEventArgs { Key = Key.Right, Source = item };
@@ -233,7 +233,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void Right_On_TopLevel_Child_Navigates_TopLevel_Selection()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var menu = new Mock<IMenu>();
                 var parentItem = Mock.Of<IMenuItem>(x => 
                     x.IsSubMenuOpen == true &&
@@ -263,7 +263,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void Enter_On_Item_With_No_SubMenu_Causes_Click()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var menu = Mock.Of<IMenu>();
                 var parentItem = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.Parent == menu);
                 var item = Mock.Of<IMenuItem>(x => x.Parent == parentItem);
@@ -279,7 +279,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void Enter_On_Item_With_SubMenu_Opens_SubMenu()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var parentItem = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true);
                 var item = Mock.Of<IMenuItem>(x => x.Parent == parentItem && x.HasSubMenu == true);
                 var e = new KeyEventArgs { Key = Key.Enter, Source = item };
@@ -294,7 +294,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void Escape_Closes_Parent_MenuItem()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var parentItem = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true);
                 var item = Mock.Of<IMenuItem>(x => x.Parent == parentItem);
                 var e = new KeyEventArgs { Key = Key.Escape, Source = item };
@@ -309,7 +309,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void PointerEnter_Selects_Item()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var menu = Mock.Of<IMenu>();
                 var parentItem = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.Parent == menu);
                 var item = Mock.Of<IMenuItem>(x => x.Parent == parentItem);
@@ -325,7 +325,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             public void PointerEnter_Opens_Submenu_After_Delay()
             {
                 var timer = new TestTimer();
-                var target = new DefaultMenuInteractionHandler(null, timer.RunOnce);
+                var target = new DefaultMenuInteractionHandler(false, null, timer.RunOnce);
                 var menu = Mock.Of<IMenu>();
                 var parentItem = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.Parent == menu);
                 var item = Mock.Of<IMenuItem>(x => x.Parent == parentItem && x.HasSubMenu == true);
@@ -344,7 +344,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             public void PointerEnter_Closes_Sibling_Submenu_After_Delay()
             {
                 var timer = new TestTimer();
-                var target = new DefaultMenuInteractionHandler(null, timer.RunOnce);
+                var target = new DefaultMenuInteractionHandler(false, null, timer.RunOnce);
                 var menu = Mock.Of<IMenu>();
                 var parentItem = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.Parent == menu);
                 var item = Mock.Of<IMenuItem>(x => x.Parent == parentItem);
@@ -365,7 +365,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void PointerLeave_Deselects_Item()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var menu = Mock.Of<IMenu>();
                 var parentItem = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.Parent == menu);
                 var item = Mock.Of<IMenuItem>(x => x.Parent == parentItem);
@@ -381,7 +381,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void PointerLeave_Doesnt_Deselect_Sibling()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var menu = Mock.Of<IMenu>();
                 var parentItem = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.Parent == menu);
                 var item = Mock.Of<IMenuItem>(x => x.Parent == parentItem);
@@ -398,7 +398,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void PointerLeave_Doesnt_Deselect_Item_If_Pointer_Over_Submenu()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var menu = Mock.Of<IMenu>();
                 var parentItem = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.Parent == menu);
                 var item = Mock.Of<IMenuItem>(x => x.Parent == parentItem && x.HasSubMenu == true && x.IsPointerOverSubMenu == true);
@@ -413,7 +413,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void PointerReleased_On_Item_With_No_SubMenu_Causes_Click()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var menu = Mock.Of<IMenu>();
                 var parentItem = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.Parent == menu);
                 var item = Mock.Of<IMenuItem>(x => x.Parent == parentItem);
@@ -430,7 +430,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             public void Selection_Is_Correct_When_Pointer_Temporarily_Exits_Item_To_Select_SubItem()
             {
                 var timer = new TestTimer();
-                var target = new DefaultMenuInteractionHandler(null, timer.RunOnce);
+                var target = new DefaultMenuInteractionHandler(false, null, timer.RunOnce);
                 var menu = Mock.Of<IMenu>();
                 var parentItem = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.Parent == menu);
                 var item = Mock.Of<IMenuItem>(x => x.Parent == parentItem && x.HasSubMenu == true);
@@ -467,7 +467,7 @@ namespace Avalonia.Controls.UnitTests.Platform
             [Fact]
             public void PointerPressed_On_Item_With_SubMenu_Causes_Opens_Submenu()
             {
-                var target = new DefaultMenuInteractionHandler();
+                var target = new DefaultMenuInteractionHandler(false);
                 var menu = Mock.Of<IMenu>();
                 var parentItem = Mock.Of<IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.Parent == menu);
                 var item = Mock.Of<IMenuItem>(x => x.Parent == parentItem && x.HasSubMenu == true);
@@ -481,6 +481,23 @@ namespace Avalonia.Controls.UnitTests.Platform
             }
         }
 
+        public class ContextMenu
+        {
+            [Fact]
+            public void Down_Selects_Selects_First_MenuItem_When_No_Selection()
+            {
+                var target = new DefaultMenuInteractionHandler(true);
+                var contextMenu = Mock.Of<IMenu>(x => x.MoveSelection(NavigationDirection.Down, true) == true);
+                var e = new KeyEventArgs { Key = Key.Down, Source = contextMenu };
+
+                target.Attach(contextMenu);
+                target.KeyDown(contextMenu, e);
+
+                Mock.Get(contextMenu).Verify(x => x.MoveSelection(NavigationDirection.Down, true));
+                Assert.True(e.Handled);
+            }
+        }
+
         private class TestTimer
         {
             private Action _action;

tests/Avalonia.Controls.UnitTests/Shapes/PathTests.cs

@@ -0,0 +1,16 @@
+using Avalonia.Controls.Shapes;
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests.Shapes
+{
+    public class PathTests
+    {
+        [Fact]
+        public void Path_With_Null_Data_Does_Not_Throw_On_Measure()
+        {
+            var target = new Path();
+
+            target.Measure(Size.Infinity);
+        }
+    }
+}

tests/Avalonia.DesignerSupport.Tests/RemoteProtocolTests.cs

@@ -9,6 +9,7 @@ using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
 using Avalonia.Remote.Protocol;
+using Avalonia.Remote.Protocol.Designer;
 using Avalonia.Remote.Protocol.Viewport;
 using Xunit;
 
@@ -109,6 +110,16 @@ namespace Avalonia.DesignerSupport.Tests
                     return Guid.NewGuid().ToString();
                 if (t == typeof(Guid))
                     return Guid.NewGuid();
+                if (t == typeof(Exception))
+                    return new Exception("Here");
+                if (t == typeof(ExceptionDetails))
+                    return new ExceptionDetails
+                    {
+                        ExceptionType = "Exception",
+                        LineNumber = 5,
+                        LinePosition = 6,
+                        Message = "Here",
+                    };
                 throw new Exception($"Doesn't know how to fabricate a random value for {t}, path {pathInfo}");
             }
             

tests/Avalonia.Markup.UnitTests/Parsers/SelectorParserTests.cs

@@ -1,8 +1,6 @@
 using System;
 using Avalonia.Controls;
-using Avalonia.Controls.Primitives;
 using Avalonia.Markup.Parsers;
-using Avalonia.Styling;
 using Xunit;
 
 namespace Avalonia.Markup.UnitTests.Parsers
@@ -15,5 +13,19 @@ namespace Avalonia.Markup.UnitTests.Parsers
             var target = new SelectorParser((ns, type) => typeof(TextBlock));
             var result = target.Parse("TextBlock[IsPointerOver=True]");
         }
+
+        [Fact]
+        public void Throws_If_OfType_Type_Not_Found()
+        {
+            var target = new SelectorParser((ns, type) => null);
+            Assert.Throws<InvalidOperationException>(() => target.Parse("NotFound"));
+        }
+
+        [Fact]
+        public void Throws_If_Is_Type_Not_Found()
+        {
+            var target = new SelectorParser((ns, type) => null);
+            Assert.Throws<InvalidOperationException>(() => target.Parse(":is(NotFound)"));
+        }
     }
 }

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

@@ -0,0 +1,66 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Portable.Xaml;
+using Xunit;
+
+namespace Avalonia.Markup.Xaml.UnitTests.Xaml
+{
+    public class EventTests
+    {
+        [Fact]
+        public void Event_Is_Attached()
+        {
+            var xaml = @"<Button xmlns='https://github.com/avaloniaui' Click='OnClick'/>";
+            var loader = new AvaloniaXamlLoader();
+            var target = new MyButton();
+
+            loader.Load(xaml, rootInstance: target);
+            RaiseClick(target);
+
+            Assert.True(target.Clicked);
+        }
+
+        [Fact]
+        public void Exception_Is_Thrown_If_Event_Not_Found()
+        {
+            var xaml = @"<Button xmlns='https://github.com/avaloniaui' Click='NotFound'/>";
+            var loader = new AvaloniaXamlLoader();
+            var target = new MyButton();
+
+            Assert.Throws<XamlObjectWriterException>(() => loader.Load(xaml, rootInstance: target));
+        }
+
+        [Fact]
+        public void Exception_Is_Not_Thrown_If_Event_Not_Found_In_Design_Mode()
+        {
+            var xaml = @"<Button xmlns='https://github.com/avaloniaui' Click='NotFound'/>";
+            var loader = new AvaloniaXamlLoader { IsDesignMode = true };
+            var target = new MyButton();
+
+            loader.Load(xaml, rootInstance: target);
+        }
+
+        private void RaiseClick(MyButton target)
+        {
+            target.RaiseEvent(new KeyEventArgs
+            {
+                RoutedEvent = Button.KeyDownEvent,
+                Key = Key.Enter,
+            });
+        }
+
+        class MyButton : Button
+        {
+            public bool Clicked { get; private set; }
+
+            public void OnClick(object sender, EventArgs e)
+            {
+                Clicked = true;
+            }
+        }
+    }
+}

tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs

@@ -61,6 +61,19 @@ namespace Avalonia.Visuals.UnitTests.Rendering.SceneGraph
             Assert.Equal(1, bitmap.RefCount);
         }
 
+        [Fact]
+        public void HitTest_On_Geometry_Node_With_Zero_Transform_Does_Not_Throw()
+        {
+            var geometry = Mock.Of<IGeometryImpl>();
+            var geometryNode = new GeometryNode(
+                new Matrix(),
+                Brushes.Black,
+                null,
+                geometry);
+
+            geometryNode.HitTest(new Point());
+        }
+
         private class TestDrawOperation : DrawOperation
         {
             public TestDrawOperation(Rect bounds, Matrix transform, Pen pen)