diff --git a/appveyor.yml b/appveyor.yml
index aa8c19ace4..76d1ae3e1c 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -23,10 +23,6 @@ before_build:
 - git submodule update --init
 build_script:
 - ps: .\build.ps1 -Target "AppVeyor" -Platform "$env:platform" -Configuration "$env:configuration"
-after_build:
-- "SET PATH=C:\\Python34;C:\\Python34\\Scripts;%PATH%"
-- pip install codecov
-- codecov -f "./artifacts/coverage.xml"
 
 test: off
 artifacts:
diff --git a/build/MonoMac.props b/build/MonoMac.props
index 452177ca5d..5cf19ef503 100644
--- a/build/MonoMac.props
+++ b/build/MonoMac.props
@@ -1,5 +1,5 @@
 <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
-    <PackageReference Include="MonoMac.NetStandard" Version="0.0.3" />
+    <PackageReference Include="MonoMac.NetStandard" Version="0.0.4" />
   </ItemGroup>
 </Project>
diff --git a/build/Splat.props b/build/Splat.props
deleted file mode 100644
index bc3367be01..0000000000
--- a/build/Splat.props
+++ /dev/null
@@ -1,5 +0,0 @@
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-     <PackageReference Include="Splat" Version="2.0.0" />
-  </ItemGroup>
-</Project>
diff --git a/packages.cake b/packages.cake
index 98075ef36b..9e78ee75d5 100644
--- a/packages.cake
+++ b/packages.cake
@@ -107,7 +107,6 @@ public class Packages
         context.Information("Setting NuGet package dependencies versions:");
 
         var SerilogVersion = packageVersions["Serilog"].FirstOrDefault().Item1;
-        var SplatVersion = packageVersions["Splat"].FirstOrDefault().Item1;
         var SpracheVersion = packageVersions["Sprache"].FirstOrDefault().Item1;
         var SystemReactiveVersion = packageVersions["System.Reactive"].FirstOrDefault().Item1;
         var ReactiveUIVersion = packageVersions["reactiveui"].FirstOrDefault().Item1;
@@ -121,7 +120,6 @@ public class Packages
         var SharpDXDXGIVersion = packageVersions["SharpDX.DXGI"].FirstOrDefault().Item1;
 
         context.Information("Package: Serilog, version: {0}", SerilogVersion);
-        context.Information("Package: Splat, version: {0}", SplatVersion);
         context.Information("Package: Sprache, version: {0}", SpracheVersion);
         context.Information("Package: System.Reactive, version: {0}", SystemReactiveVersion);
         context.Information("Package: reactiveui, version: {0}", ReactiveUIVersion);
@@ -245,7 +243,6 @@ public class Packages
                 Dependencies = new DependencyBuilder(this)
                 {
                     new NuSpecDependency() { Id = "Serilog", Version = SerilogVersion },
-                    new NuSpecDependency() { Id = "Splat", Version = SplatVersion },
                     new NuSpecDependency() { Id = "Sprache", Version = SpracheVersion },
                     new NuSpecDependency() { Id = "System.Reactive", Version = SystemReactiveVersion },
                     new NuSpecDependency() { Id = "Avalonia.Remote.Protocol", Version = parameters.Version },
@@ -253,7 +250,6 @@ public class Packages
                     new NuSpecDependency() { Id = "System.Threading.ThreadPool", TargetFramework = "netcoreapp2.0", Version = "4.3.0" },
                     new NuSpecDependency() { Id = "Microsoft.Extensions.DependencyModel", TargetFramework = "netcoreapp2.0", Version = "1.1.0" },
                     new NuSpecDependency() { Id = "NETStandard.Library", TargetFramework = "netcoreapp2.0", Version = "1.6.0" },
-                    new NuSpecDependency() { Id = "Splat", TargetFramework = "netcoreapp2.0", Version = SplatVersion },
                     new NuSpecDependency() { Id = "Serilog", TargetFramework = "netcoreapp2.0", Version = SerilogVersion },
                     new NuSpecDependency() { Id = "Sprache", TargetFramework = "netcoreapp2.0", Version = SpracheVersion },
                     new NuSpecDependency() { Id = "System.Reactive", TargetFramework = "netcoreapp2.0", Version = SystemReactiveVersion },
diff --git a/samples/BindingTest/BindingTest.csproj b/samples/BindingTest/BindingTest.csproj
index d7d349fbdf..4f82303c3a 100644
--- a/samples/BindingTest/BindingTest.csproj
+++ b/samples/BindingTest/BindingTest.csproj
@@ -152,7 +152,6 @@
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="..\..\build\Serilog.props" />
   <Import Project="..\..\build\Serilog.Sinks.Trace.props" />
-  <Import Project="..\..\build\Splat.props" />
   <Import Project="..\..\build\Rx.props" />
   <Import Project="..\..\build\ReactiveUI.props" />
 </Project>
\ No newline at end of file
diff --git a/samples/ControlCatalog/ControlCatalog.csproj b/samples/ControlCatalog/ControlCatalog.csproj
index 11ff531514..0b4463ddb7 100644
--- a/samples/ControlCatalog/ControlCatalog.csproj
+++ b/samples/ControlCatalog/ControlCatalog.csproj
@@ -44,6 +44,9 @@
     <EmbeddedResource Include="Pages\ButtonPage.xaml">
       <SubType>Designer</SubType>
     </EmbeddedResource>
+    <EmbeddedResource Include="Pages\CalendarPage.xaml">
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
     <EmbeddedResource Include="Pages\CanvasPage.xaml">
       <SubType>Designer</SubType>
     </EmbeddedResource>
@@ -107,6 +110,9 @@
     <Compile Include="Pages\ButtonPage.xaml.cs">
       <DependentUpon>ButtonPage.xaml</DependentUpon>
     </Compile>
+    <Compile Include="Pages\CalendarPage.xaml.cs">
+      <DependentUpon>CalendarPage.xaml</DependentUpon>
+    </Compile>
     <Compile Include="Pages\CanvasPage.xaml.cs">
       <DependentUpon>CanvasPage.xaml</DependentUpon>
     </Compile>
diff --git a/samples/ControlCatalog/MainView.xaml b/samples/ControlCatalog/MainView.xaml
index 0940316ce9..311a61a6dc 100644
--- a/samples/ControlCatalog/MainView.xaml
+++ b/samples/ControlCatalog/MainView.xaml
@@ -7,6 +7,7 @@
     </TabControl.Transition>
     <TabItem Header="Border"><pages:BorderPage/></TabItem>
     <TabItem Header="Button"><pages:ButtonPage/></TabItem>
+    <TabItem Header="Calendar"><pages:CalendarPage/></TabItem>
     <TabItem Header="Canvas"><pages:CanvasPage/></TabItem>
     <TabItem Header="Carousel"><pages:CarouselPage/></TabItem>
     <TabItem Header="CheckBox"><pages:CheckBoxPage/></TabItem>
diff --git a/samples/ControlCatalog/Pages/CalendarPage.xaml b/samples/ControlCatalog/Pages/CalendarPage.xaml
new file mode 100644
index 0000000000..a433fd1add
--- /dev/null
+++ b/samples/ControlCatalog/Pages/CalendarPage.xaml
@@ -0,0 +1,47 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+  <StackPanel Orientation="Vertical" Gap="4">
+    <TextBlock Classes="h1">Calendar</TextBlock>
+    <TextBlock Classes="h2">A calendar control for selecting dates</TextBlock>
+        
+    <StackPanel Orientation="Horizontal"
+                Margin="0,16,0,0"
+                HorizontalAlignment="Center"
+                Gap="16">
+      <StackPanel Orientation="Vertical">
+        <TextBlock Text="SelectionMode: None"/>
+        <Calendar SelectionMode="None"
+                  Margin="0,0,0,8"/>
+
+        <TextBlock Text="SelectionMode: SingleDate"/>
+        <Calendar SelectionMode="SingleDate"
+                  Margin="0,0,0,8"/>
+
+        <TextBlock Text="Disabled"/>
+        <Calendar IsEnabled="False"
+                  SelectionMode="SingleDate"/>
+      </StackPanel>
+
+      <StackPanel Orientation="Vertical">
+        <TextBlock Text="SelectionMode: SingleRange"/>
+        <Calendar SelectionMode="SingleRange"
+                  Margin="0,0,0,8"/>
+
+        <TextBlock Text="SelectionMode: MultipleRange"/>
+        <Calendar SelectionMode="MultipleRange"/>
+      </StackPanel>
+
+      <StackPanel Orientation="Vertical">
+        <TextBlock Text="DisplayDates"/>
+        <Calendar Name="DisplayDatesCalendar"
+                  SelectionMode="SingleDate"
+                  Margin="0,0,0,8"/>
+
+        <TextBlock Text="BlackoutDates"/>
+        <Calendar Name="BlackoutDatesCalendar"
+                  SelectionMode="SingleDate" />
+      </StackPanel>
+      
+    </StackPanel> 
+  </StackPanel>
+</UserControl>
\ No newline at end of file
diff --git a/samples/ControlCatalog/Pages/CalendarPage.xaml.cs b/samples/ControlCatalog/Pages/CalendarPage.xaml.cs
new file mode 100644
index 0000000000..e3e9a3444e
--- /dev/null
+++ b/samples/ControlCatalog/Pages/CalendarPage.xaml.cs
@@ -0,0 +1,28 @@
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+using System;
+
+namespace ControlCatalog.Pages
+{
+    public class CalendarPage : UserControl
+    {
+        public CalendarPage()
+        {
+            this.InitializeComponent();
+
+            var today = DateTime.Today; 
+            var cal1 = this.FindControl<Calendar>("DisplayDatesCalendar");
+            cal1.DisplayDateStart = today.AddDays(-25);
+            cal1.DisplayDateEnd = today.AddDays(25);
+
+            var cal2 = this.FindControl<Calendar>("BlackoutDatesCalendar");
+            cal2.BlackoutDates.AddDatesInPast();
+            cal2.BlackoutDates.Add(new CalendarDateRange(today.AddDays(6)));
+        }
+
+        private void InitializeComponent()
+        {
+            AvaloniaXamlLoader.Load(this);
+        }
+    }
+}
diff --git a/samples/ControlCatalog/Pages/CarouselPage.xaml b/samples/ControlCatalog/Pages/CarouselPage.xaml
index 317159cd8d..4a5b2cea26 100644
--- a/samples/ControlCatalog/Pages/CarouselPage.xaml
+++ b/samples/ControlCatalog/Pages/CarouselPage.xaml
@@ -9,7 +9,7 @@
       </Button>
       <Carousel Name="carousel">
         <Carousel.Transition>
-          <PageSlide Duration="0.25"/>
+          <PageSlide Duration="0.25" Orientation="Vertical" />
         </Carousel.Transition>
         <Image Source="resm:ControlCatalog.Assets.delicate-arch-896885_640.jpg"/>
         <Image Source="resm:ControlCatalog.Assets.hirsch-899118_640.jpg"/>
@@ -28,6 +28,14 @@
         <DropDownItem>Crossfade</DropDownItem>
       </DropDown>
     </StackPanel>
+
+    <StackPanel Orientation="Horizontal" Gap="4">
+      <TextBlock VerticalAlignment="Center">Orientation</TextBlock>
+      <DropDown Name="orientation" SelectedIndex="1" VerticalAlignment="Center">
+        <DropDownItem>Horizontal</DropDownItem>
+        <DropDownItem>Vertical</DropDownItem>
+      </DropDown>
+    </StackPanel>
     
   </StackPanel>
 </UserControl>
\ No newline at end of file
diff --git a/samples/ControlCatalog/Pages/CarouselPage.xaml.cs b/samples/ControlCatalog/Pages/CarouselPage.xaml.cs
index 1c408c8ed7..272290e679 100644
--- a/samples/ControlCatalog/Pages/CarouselPage.xaml.cs
+++ b/samples/ControlCatalog/Pages/CarouselPage.xaml.cs
@@ -11,6 +11,7 @@ namespace ControlCatalog.Pages
         private Button _left;
         private Button _right;
         private DropDown _transition;
+        private DropDown _orientation;
 
         public CarouselPage()
         {
@@ -18,6 +19,7 @@ namespace ControlCatalog.Pages
             _left.Click += (s, e) => _carousel.Previous();
             _right.Click += (s, e) => _carousel.Next();
             _transition.SelectionChanged += TransitionChanged;
+            _orientation.SelectionChanged += TransitionChanged;
         }
 
         private void InitializeComponent()
@@ -27,6 +29,7 @@ namespace ControlCatalog.Pages
             _left = this.FindControl<Button>("left");
             _right = this.FindControl<Button>("right");
             _transition = this.FindControl<DropDown>("transition");
+            _orientation = this.FindControl<DropDown>("orientation");
         }
 
         private void TransitionChanged(object sender, SelectionChangedEventArgs e)
@@ -37,7 +40,7 @@ namespace ControlCatalog.Pages
                     _carousel.Transition = null;
                     break;
                 case 1:
-                    _carousel.Transition = new PageSlide(TimeSpan.FromSeconds(0.25));
+                    _carousel.Transition = new PageSlide(TimeSpan.FromSeconds(0.25), _orientation.SelectedIndex == 0 ? PageSlide.SlideAxis.Horizontal : PageSlide.SlideAxis.Vertical);
                     break;
                 case 2:
                     _carousel.Transition = new CrossFade(TimeSpan.FromSeconds(0.25));
diff --git a/samples/ControlCatalog/Pages/CheckBoxPage.xaml b/samples/ControlCatalog/Pages/CheckBoxPage.xaml
index 4a6db5bed9..a00b3a7bef 100644
--- a/samples/ControlCatalog/Pages/CheckBoxPage.xaml
+++ b/samples/ControlCatalog/Pages/CheckBoxPage.xaml
@@ -1,15 +1,28 @@
-<UserControl xmlns="https://github.com/avaloniaui">
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
   <StackPanel Orientation="Vertical" Gap="4">
     <TextBlock Classes="h1">CheckBox</TextBlock>
     <TextBlock Classes="h2">A check box control</TextBlock>
 
-    <StackPanel Orientation="Vertical"
+    <StackPanel Orientation="Horizontal"
                 Margin="0,16,0,0"
                 HorizontalAlignment="Center"
                 Gap="16">
-      <CheckBox>Unchecked</CheckBox>
-      <CheckBox IsChecked="True">Checked</CheckBox>
-      <CheckBox IsChecked="True" IsEnabled="False">Disabled</CheckBox>
-    </StackPanel>    
+      <StackPanel Orientation="Vertical"
+                  Gap="16">
+        <CheckBox>Unchecked</CheckBox>
+        <CheckBox IsChecked="True">Checked</CheckBox>
+        <CheckBox IsChecked="{x:Null}">Indeterminate</CheckBox>
+        <CheckBox IsChecked="True" IsEnabled="False">Disabled</CheckBox>
+      </StackPanel>
+      <StackPanel Orientation="Vertical"
+                  HorizontalAlignment="Center"
+                  Gap="16">
+        <CheckBox IsChecked="False" IsThreeState="True">Three State: Unchecked</CheckBox>
+        <CheckBox IsChecked="True" IsThreeState="True">Three State: Checked</CheckBox>
+        <CheckBox IsChecked="{x:Null}" IsThreeState="True">Three State: Indeterminate</CheckBox>
+        <CheckBox IsChecked="{x:Null}" IsThreeState="True" IsEnabled="False">Three State: Disabled</CheckBox>
+      </StackPanel>
+    </StackPanel>
   </StackPanel>
 </UserControl>
\ No newline at end of file
diff --git a/samples/ControlCatalog/Pages/DialogsPage.xaml.cs b/samples/ControlCatalog/Pages/DialogsPage.xaml.cs
index 94364da698..8b3e810f0a 100644
--- a/samples/ControlCatalog/Pages/DialogsPage.xaml.cs
+++ b/samples/ControlCatalog/Pages/DialogsPage.xaml.cs
@@ -36,7 +36,7 @@ namespace ControlCatalog.Pages
             };
         }
 
-        Window GetWindow() => this.FindControl<CheckBox>("IsModal").IsChecked ? (Window)this.VisualRoot : null;
+        Window GetWindow() => this.FindControl<CheckBox>("IsModal").IsChecked.Value ? (Window)this.VisualRoot : null;
 
         private void InitializeComponent()
         {
diff --git a/samples/ControlCatalog/Pages/RadioButtonPage.xaml b/samples/ControlCatalog/Pages/RadioButtonPage.xaml
index a40477a679..d382b94f2c 100644
--- a/samples/ControlCatalog/Pages/RadioButtonPage.xaml
+++ b/samples/ControlCatalog/Pages/RadioButtonPage.xaml
@@ -1,15 +1,27 @@
-<UserControl xmlns="https://github.com/avaloniaui">
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
   <StackPanel Orientation="Vertical" Gap="4">
     <TextBlock Classes="h1">RadioButton</TextBlock>
     <TextBlock Classes="h2">Allows the selection of a single option of many</TextBlock>
 
-    <StackPanel Orientation="Vertical"
+    <StackPanel Orientation="Horizontal"
                 Margin="0,16,0,0"
                 HorizontalAlignment="Center"
                 Gap="16">
-      <RadioButton IsChecked="True">Option 1</RadioButton>
-      <RadioButton>Option 2</RadioButton>
-      <RadioButton IsEnabled="False">Disabled</RadioButton>
-    </StackPanel>    
+      <StackPanel Orientation="Vertical"
+                  Gap="16">
+        <RadioButton IsChecked="True">Option 1</RadioButton>
+        <RadioButton>Option 2</RadioButton>
+        <RadioButton IsChecked="{x:Null}">Option 3</RadioButton>
+        <RadioButton IsEnabled="False">Disabled</RadioButton>
+      </StackPanel>
+      <StackPanel Orientation="Vertical"
+                  Gap="16">
+        <RadioButton IsChecked="True" IsThreeState="True">Three States: Option 1</RadioButton>
+        <RadioButton IsChecked="False" IsThreeState="True">Three States: Option 2</RadioButton>
+        <RadioButton IsChecked="{x:Null}" IsThreeState="True">Three States: Option 3</RadioButton>
+        <RadioButton IsChecked="{x:Null}" IsThreeState="True" IsEnabled="False">Disabled</RadioButton>
+      </StackPanel>
+    </StackPanel>
   </StackPanel>
 </UserControl>
\ No newline at end of file
diff --git a/samples/RenderTest/RenderTest.csproj b/samples/RenderTest/RenderTest.csproj
index 0141ad29c6..a71f17ab7a 100644
--- a/samples/RenderTest/RenderTest.csproj
+++ b/samples/RenderTest/RenderTest.csproj
@@ -181,7 +181,6 @@
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="..\..\build\Serilog.props" />
   <Import Project="..\..\build\Serilog.Sinks.Trace.props" />
-  <Import Project="..\..\build\Splat.props" />
   <Import Project="..\..\build\Rx.props" />
   <Import Project="..\..\build\ReactiveUI.props" />
 </Project>
\ No newline at end of file
diff --git a/samples/VirtualizationTest/VirtualizationTest.csproj b/samples/VirtualizationTest/VirtualizationTest.csproj
index 58775926cc..6d3803b4cf 100644
--- a/samples/VirtualizationTest/VirtualizationTest.csproj
+++ b/samples/VirtualizationTest/VirtualizationTest.csproj
@@ -148,7 +148,6 @@
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="..\..\build\Serilog.props" />
   <Import Project="..\..\build\Serilog.Sinks.Trace.props" />
-  <Import Project="..\..\build\Splat.props" />
   <Import Project="..\..\build\Rx.props" />
   <Import Project="..\..\build\ReactiveUI.props" />
 </Project>
\ No newline at end of file
diff --git a/samples/interop/Direct3DInteropSample/Direct3DInteropSample.csproj b/samples/interop/Direct3DInteropSample/Direct3DInteropSample.csproj
index da230d34c6..e0fc79faea 100644
--- a/samples/interop/Direct3DInteropSample/Direct3DInteropSample.csproj
+++ b/samples/interop/Direct3DInteropSample/Direct3DInteropSample.csproj
@@ -29,6 +29,5 @@
     </ItemGroup>
     <Import Project="..\..\..\build\Serilog.props" />
     <Import Project="..\..\..\build\Serilog.Sinks.Trace.props" />
-    <Import Project="..\..\..\build\Splat.props" />
     <Import Project="..\..\..\build\Rx.props" />
 </Project>
\ No newline at end of file
diff --git a/src/Android/Avalonia.AndroidTestApplication/Avalonia.AndroidTestApplication.csproj b/src/Android/Avalonia.AndroidTestApplication/Avalonia.AndroidTestApplication.csproj
index 5b621b9e08..9977d77978 100644
--- a/src/Android/Avalonia.AndroidTestApplication/Avalonia.AndroidTestApplication.csproj
+++ b/src/Android/Avalonia.AndroidTestApplication/Avalonia.AndroidTestApplication.csproj
@@ -154,7 +154,6 @@
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />
   <Import Project="..\..\..\build\Serilog.props" />
-  <Import Project="..\..\..\build\Splat.props" />
   <Import Project="..\..\..\build\Sprache.props" />
   <Import Project="..\..\..\build\Rx.props" />
 </Project>
\ No newline at end of file
diff --git a/src/Avalonia.Base/AvaloniaObjectExtensions.cs b/src/Avalonia.Base/AvaloniaObjectExtensions.cs
index 685bf83a75..e96679e643 100644
--- a/src/Avalonia.Base/AvaloniaObjectExtensions.cs
+++ b/src/Avalonia.Base/AvaloniaObjectExtensions.cs
@@ -326,7 +326,7 @@ namespace Avalonia
                 object anchor = null,
                 bool enableDataValidation = false)
             {
-                return new InstancedBinding(_source);
+                return InstancedBinding.OneWay(_source);
             }
         }
     }
diff --git a/src/Avalonia.Base/Data/IndexerBinding.cs b/src/Avalonia.Base/Data/IndexerBinding.cs
index 729b21b0d9..6b5a84989a 100644
--- a/src/Avalonia.Base/Data/IndexerBinding.cs
+++ b/src/Avalonia.Base/Data/IndexerBinding.cs
@@ -31,13 +31,18 @@ namespace Avalonia.Data
                 targetProperty.GetMetadata(target.GetType()).DefaultBindingMode :
                 Mode;
 
-            if (mode == BindingMode.TwoWay)
+            switch (mode)
             {
-                return new InstancedBinding(Source.GetSubject(Property), mode);
-            }
-            else
-            {
-                return new InstancedBinding(Source.GetObservable(Property), mode);
+                case BindingMode.OneTime:
+                    return InstancedBinding.OneTime(Source.GetObservable(Property));
+                case BindingMode.OneWay:
+                    return InstancedBinding.OneWay(Source.GetObservable(Property));
+                case BindingMode.OneWayToSource:
+                    return InstancedBinding.OneWayToSource(Source.GetSubject(Property));
+                case BindingMode.TwoWay:
+                    return InstancedBinding.TwoWay(Source.GetSubject(Property));
+                default:
+                    throw new NotSupportedException("Unsupported BindingMode.");
             }
         }
     }
diff --git a/src/Avalonia.Base/Data/InstancedBinding.cs b/src/Avalonia.Base/Data/InstancedBinding.cs
index 899cfed1fe..dc35fe076b 100644
--- a/src/Avalonia.Base/Data/InstancedBinding.cs
+++ b/src/Avalonia.Base/Data/InstancedBinding.cs
@@ -14,71 +14,35 @@ namespace Avalonia.Data
     /// property on a control's DataContext"; this class represents a binding that has been 
     /// *instanced* by calling <see cref="IBinding.Initiate(IAvaloniaObject, AvaloniaProperty, object, bool)"/>
     /// on a target object.
-    /// 
-    /// When a binding is initiated, it can return one of 3 possible sources for the binding:
-    /// - An <see cref="ISubject{Object}"/> which can be used for any type of binding.
-    /// - An <see cref="IObservable{Object}"/> which can be used for all types of bindings except
-    ///  <see cref="BindingMode.OneWayToSource"/> and <see cref="BindingMode.TwoWay"/>.
-    /// - A plain object, which can only represent a <see cref="BindingMode.OneTime"/> binding.
     /// </remarks>
     public class InstancedBinding
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="InstancedBinding"/> class.
         /// </summary>
-        /// <param name="value">
-        /// The value used for the <see cref="BindingMode.OneTime"/> binding.
-        /// </param>
-        /// <param name="priority">The binding priority.</param>
-        public InstancedBinding(object value,
-            BindingPriority priority = BindingPriority.LocalValue)
-        {
-            Mode = BindingMode.OneTime;
-            Priority = priority;
-            Value = value;
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="InstancedBinding"/> class.
-        /// </summary>
-        /// <param name="observable">The observable for a one-way binding.</param>
+        /// <param name="subject">The binding source.</param>
         /// <param name="mode">The binding mode.</param>
-        /// <param name="priority">The binding priority.</param>
-        public InstancedBinding(
-            IObservable<object> observable, 
-            BindingMode mode = BindingMode.OneWay,
-            BindingPriority priority = BindingPriority.LocalValue)
+        /// <param name="priority">The priority of the binding.</param>
+        /// <remarks>
+        /// This constructor can be used to create any type of binding and as such requires an
+        /// <see cref="ISubject{Object}"/> as the binding source because this is the only binding
+        /// source which can be used for all binding modes. If you wish to create an instance with
+        /// something other than a subject, use one of the static creation methods on this class.
+        /// </remarks>
+        public InstancedBinding(ISubject<object> subject, BindingMode mode, BindingPriority priority)
         {
-            Contract.Requires<ArgumentNullException>(observable != null);
-
-            if (mode == BindingMode.OneWayToSource || mode == BindingMode.TwoWay)
-            {
-                throw new ArgumentException(
-                    "Invalid BindingResult mode: OneWayToSource and TwoWay bindings" +
-                    "require a Subject.");
-            }
+            Contract.Requires<ArgumentNullException>(subject != null);
 
             Mode = mode;
             Priority = priority;
-            Observable = observable;
+            Value = subject;
         }
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="InstancedBinding"/> class.
-        /// </summary>
-        /// <param name="subject">The subject for a two-way binding.</param>
-        /// <param name="mode">The binding mode.</param>
-        /// <param name="priority">The binding priority.</param>
-        public InstancedBinding(
-            ISubject<object> subject,
-            BindingMode mode = BindingMode.OneWay,
-            BindingPriority priority = BindingPriority.LocalValue)
+        private InstancedBinding(object value, BindingMode mode, BindingPriority priority)
         {
-            Contract.Requires<ArgumentNullException>(subject != null);
-
             Mode = mode;
             Priority = priority;
-            Subject = subject;
+            Value = value;
         }
 
         /// <summary>
@@ -92,18 +56,101 @@ namespace Avalonia.Data
         public BindingPriority Priority { get; }
 
         /// <summary>
-        /// Gets the value used for a <see cref="BindingMode.OneTime"/> binding.
+        /// Gets the value or source of the binding.
         /// </summary>
         public object Value { get; }
 
         /// <summary>
-        /// Gets the observable for a one-way binding.
+        /// Gets the <see cref="Value"/> as an observable.
         /// </summary>
-        public IObservable<object> Observable { get; }
+        public IObservable<object> Observable => Value as IObservable<object>;
 
         /// <summary>
-        /// Gets the subject for a two-way binding.
+        /// Gets the <see cref="Value"/> as a subject.
         /// </summary>
-        public ISubject<object> Subject { get; }
+        public ISubject<object> Subject => Value as ISubject<object>;
+
+        /// <summary>
+        /// Creates a new one-time binding with a fixed value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <param name="priority">The priority of the binding.</param>
+        /// <returns>An <see cref="InstancedBinding"/> instance.</returns>
+        public static InstancedBinding OneTime(
+            object value,
+            BindingPriority priority = BindingPriority.LocalValue)
+        {
+            return new InstancedBinding(value, BindingMode.OneTime, priority);
+        }
+
+        /// <summary>
+        /// Creates a new one-time binding.
+        /// </summary>
+        /// <param name="observable">The source observable.</param>
+        /// <param name="priority">The priority of the binding.</param>
+        /// <returns>An <see cref="InstancedBinding"/> instance.</returns>
+        public static InstancedBinding OneTime(
+            IObservable<object> observable,
+            BindingPriority priority = BindingPriority.LocalValue)
+        {
+            Contract.Requires<ArgumentNullException>(observable != null);
+
+            return new InstancedBinding(observable, BindingMode.OneTime, priority);
+        }
+
+        /// <summary>
+        /// Creates a new one-way binding.
+        /// </summary>
+        /// <param name="observable">The source observable.</param>
+        /// <param name="priority">The priority of the binding.</param>
+        /// <returns>An <see cref="InstancedBinding"/> instance.</returns>
+        public static InstancedBinding OneWay(
+            IObservable<object> observable,
+            BindingPriority priority = BindingPriority.LocalValue)
+        {
+            Contract.Requires<ArgumentNullException>(observable != null);
+
+            return new InstancedBinding(observable, BindingMode.OneWay, priority);
+        }
+
+        /// <summary>
+        /// Creates a new one-way to source binding.
+        /// </summary>
+        /// <param name="subject">The binding source.</param>
+        /// <param name="priority">The priority of the binding.</param>
+        /// <returns>An <see cref="InstancedBinding"/> instance.</returns>
+        public static InstancedBinding OneWayToSource(
+            ISubject<object> subject,
+            BindingPriority priority = BindingPriority.LocalValue)
+        {
+            Contract.Requires<ArgumentNullException>(subject != null);
+
+            return new InstancedBinding(subject, BindingMode.OneWayToSource, priority);
+        }
+
+        /// <summary>
+        /// Creates a new two-way binding.
+        /// </summary>
+        /// <param name="subject">The binding source.</param>
+        /// <param name="priority">The priority of the binding.</param>
+        /// <returns>An <see cref="InstancedBinding"/> instance.</returns>
+        public static InstancedBinding TwoWay(
+            ISubject<object> subject,
+            BindingPriority priority = BindingPriority.LocalValue)
+        {
+            Contract.Requires<ArgumentNullException>(subject != null);
+
+            return new InstancedBinding(subject, BindingMode.TwoWay, priority);
+        }
+
+        /// <summary>
+        /// Creates a copy of the <see cref="InstancedBinding"/> with a different priority.
+        /// </summary>
+        /// <param name="priority">The priority of the binding.</param>
+        /// <returns>An <see cref="InstancedBinding"/> instance.</returns>
+        public InstancedBinding WithPriority(BindingPriority priority)
+        {
+            return new InstancedBinding(Value, Mode, priority);
+        }
     }
 }
diff --git a/src/Avalonia.Base/Threading/Dispatcher.cs b/src/Avalonia.Base/Threading/Dispatcher.cs
index a4b1aaafbc..4a096fc326 100644
--- a/src/Avalonia.Base/Threading/Dispatcher.cs
+++ b/src/Avalonia.Base/Threading/Dispatcher.cs
@@ -72,6 +72,12 @@ namespace Avalonia.Threading
             _jobRunner?.RunJobs(null);
         }
 
+        /// <summary>
+        /// Use this method to ensure that more prioritized tasks are executed
+        /// </summary>
+        /// <param name="minimumPriority"></param>
+        public void RunJobs(DispatcherPriority minimumPriority) => _jobRunner.RunJobs(minimumPriority);
+
         /// <inheritdoc/>
         public Task InvokeTaskAsync(Action action, DispatcherPriority priority = DispatcherPriority.Normal)
         {
diff --git a/src/Avalonia.Controls/Calendar/Calendar.cs b/src/Avalonia.Controls/Calendar/Calendar.cs
new file mode 100644
index 0000000000..8c79e5dce5
--- /dev/null
+++ b/src/Avalonia.Controls/Calendar/Calendar.cs
@@ -0,0 +1,2132 @@
+// (c) Copyright Microsoft Corporation.
+// This source is subject to the Microsoft Public License (Ms-PL).
+// Please see http://go.microsoft.com/fwlink/?LinkID=131993 for details.
+// All other rights reserved.
+
+using Avalonia.Controls.Primitives;
+using Avalonia.Data;
+using Avalonia.Input;
+using Avalonia.Interactivity;
+using Avalonia.Media;
+using System;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+
+namespace Avalonia.Controls
+{
+    /// <summary>
+    /// Specifies values for the different modes of operation of a
+    /// <see cref="T:Avalonia.Controls.Calendar" />.
+    /// </summary>
+    public enum CalendarMode
+    {
+        /// <summary>
+        /// The <see cref="T:Avalonia.Controls.Calendar" /> displays a
+        /// month at a time.
+        /// </summary>
+        Month = 0,
+
+        /// <summary>
+        /// The <see cref="T:Avalonia.Controls.Calendar" /> displays a
+        /// year at a time.
+        /// </summary>
+        Year = 1,
+
+        /// <summary>
+        /// The <see cref="T:Avalonia.Controls.Calendar" /> displays a
+        /// decade at a time.
+        /// </summary>
+        Decade = 2,
+    }
+
+    /// <summary>
+    /// Specifies values that describe the available selection modes for a
+    /// <see cref="T:Avalonia.Controls.Calendar" />.
+    /// </summary>
+    /// <remarks>
+    /// This enumeration provides the values that are used by the SelectionMode
+    /// property.
+    /// </remarks>
+    public enum CalendarSelectionMode
+    {
+        /// <summary>
+        /// Only a single date can be selected. Use the
+        /// <see cref="P:Avalonia.Controls.Calendar.SelectedDate" />
+        /// property to retrieve the selected date.
+        /// </summary>
+        SingleDate = 0,
+
+        /// <summary>
+        /// A single range of dates can be selected. Use 
+        /// <see cref="P:Avalonia.Controls.Calendar.SelectedDates" />
+        /// property to retrieve the selected dates.
+        /// </summary>
+        SingleRange = 1,
+
+        /// <summary>
+        /// Multiple non-contiguous ranges of dates can be selected. Use the
+        /// <see cref="P:Avalonia.Controls.Calendar.SelectedDates" />
+        /// property to retrieve the selected dates.
+        /// </summary>
+        MultipleRange = 2,
+
+        /// <summary>
+        /// No selections are allowed.
+        /// </summary>
+        None = 3,
+    }
+
+    /// <summary>
+    /// Provides data for the
+    /// <see cref="E:Avalonia.Controls.Calendar.DisplayDateChanged" />
+    /// event.
+    /// </summary>
+    public class CalendarDateChangedEventArgs : RoutedEventArgs
+    {
+        /// <summary>
+        /// Gets the date that was previously displayed.
+        /// </summary>
+        /// <value>
+        /// The date previously displayed.
+        /// </value>
+        public DateTime? RemovedDate { get; private set; }
+
+        /// <summary>
+        /// Gets the date to be newly displayed.
+        /// </summary>
+        /// <value>The new date to display.</value>
+        public DateTime? AddedDate { get; private set; }
+
+        /// <summary>
+        /// Initializes a new instance of the CalendarDateChangedEventArgs
+        /// class.
+        /// </summary>
+        /// <param name="removedDate">
+        /// The date that was previously displayed.
+        /// </param>
+        /// <param name="addedDate">The date to be newly displayed.</param>
+        internal CalendarDateChangedEventArgs(DateTime? removedDate, DateTime? addedDate)
+        {
+            RemovedDate = removedDate;
+            AddedDate = addedDate;
+        }
+    }
+
+    /// <summary>
+    /// Provides data for the
+    /// <see cref="E:Avalonia.Controls.Calendar.DisplayModeChanged" />
+    /// event.
+    /// </summary>
+    /// <QualityBand>Mature</QualityBand>
+    public class CalendarModeChangedEventArgs : RoutedEventArgs
+    {
+        /// <summary>
+        /// Gets the previous mode of the
+        /// <see cref="T:Avalonia.Controls.Calendar" />.
+        /// </summary>
+        /// <value>
+        /// A <see cref="T:Avalonia.Controls.CalendarMode" /> representing
+        /// the previous mode.
+        /// </value>
+        public CalendarMode OldMode { get; private set; }
+
+        /// <summary>
+        /// Gets the new mode of the
+        /// <see cref="T:Avalonia.Controls.Calendar" />.
+        /// </summary>
+        /// <value>
+        /// A <see cref="T:Avalonia.Controls.CalendarMode" /> 
+        /// the new mode.
+        /// </value>
+        public CalendarMode NewMode { get; private set; }
+
+        /// <summary>
+        /// Initializes a new instance of the
+        /// <see cref="T:Avalonia.Controls.CalendarModeChangedEventArgs" />
+        /// class.
+        /// </summary>
+        /// <param name="oldMode">The previous mode.</param>
+        /// <param name="newMode">The new mode.</param>
+        public CalendarModeChangedEventArgs(CalendarMode oldMode, CalendarMode newMode)
+        {
+            OldMode = oldMode;
+            NewMode = newMode;
+        }
+    }
+
+    /// <summary>
+    /// Represents a control that enables a user to select a date by using a
+    /// visual calendar display.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// A Calendar control can be used on its own, or as a drop-down part of a
+    /// DatePicker control. For more information, see DatePicker.  A Calendar
+    /// displays either the days of a month, the months of a year, or the years
+    /// of a decade, depending on the value of the DisplayMode property.  When
+    /// displaying the days of a month, the user can select a date, a range of
+    /// dates, or multiple ranges of dates.  The kinds of selections that are
+    /// allowed are controlled by the SelectionMode property.
+    /// </para>
+    /// <para>
+    /// The range of dates displayed is governed by the DisplayDateStart and
+    /// DisplayDateEnd properties.  If DisplayMode is Year or Decade, only
+    /// months or years that contain displayable dates will be displayed.
+    /// Setting the displayable range to a range that does not include the
+    /// current DisplayDate will throw an ArgumentOutOfRangeException.
+    /// </para>
+    /// <para>
+    /// The BlackoutDates property can be used to specify dates that cannot be
+    /// selected. These dates will be displayed as dimmed and disabled.
+    /// </para>
+    /// <para>
+    /// By default, Today is highlighted.  This can be disabled by setting
+    /// IsTodayHighlighted to false.
+    /// </para>
+    /// <para>
+    /// The Calendar control provides basic navigation using either the mouse or
+    /// keyboard. The following table summarizes keyboard navigation.
+    /// 
+    ///     Key Combination     DisplayMode     Action
+    ///     ARROW               Any             Change focused date, unselect
+    ///                                         all selected dates, and select
+    ///                                         new focused date.
+    ///                                         
+    ///     SHIFT+ARROW         Any             If SelectionMode is not set to
+    ///                                         SingleDate or None begin
+    ///                                         selecting a range of dates.
+    ///                                         
+    ///     CTRL+UP ARROW       Any             Switch to the next larger
+    ///                                         DisplayMode.  If DisplayMode is
+    ///                                         already Decade, no action.
+    ///                                         
+    ///     CTRL+DOWN ARROW     Any             Switch to the next smaller
+    ///                                         DisplayMode.  If DisplayMode is
+    ///                                         already Month, no action.
+    ///                                         
+    ///     SPACEBAR            Month           Select focused date.
+    ///     
+    ///     SPACEBAR            Year or Decade  Switch DisplayMode to the Month
+    ///                                         or Year represented by focused
+    ///                                         item.
+    /// </para>
+    /// <para>
+    /// XAML Usage for Classes Derived from Calendar
+    /// If you define a class that derives from Calendar, the class can be used
+    /// as an object element in XAML, and all of the inherited properties and
+    /// events that show a XAML usage in the reference for the Calendar members
+    /// can have the same XAML usage for the derived class. However, the object
+    /// element itself must have a different prefix mapping than the controls:
+    /// mapping shown in the usages, because the derived class comes from an
+    /// assembly and namespace that you create and define.  You must define your
+    /// own prefix mapping to an XML namespace to use the class as an object
+    /// element in XAML.
+    /// </para>
+    /// </remarks>
+    public class Calendar : TemplatedControl
+    {
+        internal const int RowsPerMonth = 7;
+        internal const int ColumnsPerMonth = 7;
+        internal const int RowsPerYear = 3;
+        internal const int ColumnsPerYear = 4;
+
+        private DateTime? _selectedDate;
+        private DateTime _selectedMonth;
+        private DateTime _selectedYear;
+
+        private DateTime _displayDate = DateTime.Today;
+        private DateTime? _displayDateStart = null;
+        private DateTime? _displayDateEnd = null;
+
+        private bool _isShiftPressed;
+        private bool _displayDateIsChanging = false;
+
+        internal CalendarDayButton FocusButton { get; set; }
+        internal CalendarButton FocusCalendarButton { get; set; }
+
+        internal Panel Root { get; set; }
+        internal CalendarItem MonthControl
+        {
+            get
+            {
+
+                if (Root != null && Root.Children.Count > 0)
+                {
+                    return Root.Children[0] as CalendarItem;
+                }
+                return null;
+            }
+        }
+
+        public static readonly StyledProperty<DayOfWeek> FirstDayOfWeekProperty =
+            AvaloniaProperty.Register<Calendar, DayOfWeek>(
+                    nameof(FirstDayOfWeek),
+                    defaultValue: DateTimeHelper.GetCurrentDateFormat().FirstDayOfWeek);
+        /// <summary>
+        /// Gets or sets the day that is considered the beginning of the week.
+        /// </summary>
+        /// <value>
+        /// A <see cref="T:System.DayOfWeek" /> representing the beginning of
+        /// the week. The default is <see cref="F:System.DayOfWeek.Sunday" />.
+        /// </value>
+        public DayOfWeek FirstDayOfWeek
+        {
+            get { return GetValue(FirstDayOfWeekProperty); }
+            set { SetValue(FirstDayOfWeekProperty, value); }
+        }
+        /// <summary>
+        /// FirstDayOfWeekProperty property changed handler.
+        /// </summary>
+        /// <param name="e">The DependencyPropertyChangedEventArgs.</param>
+        private void OnFirstDayOfWeekChanged(AvaloniaPropertyChangedEventArgs e)
+        {
+
+            if (IsValidFirstDayOfWeek(e.NewValue))
+            {
+                UpdateMonths();
+            }
+            else
+            {
+                throw new ArgumentOutOfRangeException("d", "Invalid DayOfWeek");
+            }
+        }
+        /// <summary>
+        /// Inherited code: Requires comment.
+        /// </summary>
+        /// <param name="value">Inherited code: Requires comment 1.</param>
+        /// <returns>Inherited code: Requires comment 2.</returns>
+        private static bool IsValidFirstDayOfWeek(object value)
+        {
+            DayOfWeek day = (DayOfWeek)value;
+
+            return day == DayOfWeek.Sunday
+                || day == DayOfWeek.Monday
+                || day == DayOfWeek.Tuesday
+                || day == DayOfWeek.Wednesday
+                || day == DayOfWeek.Thursday
+                || day == DayOfWeek.Friday
+                || day == DayOfWeek.Saturday;
+        }
+
+        public static readonly StyledProperty<bool> IsTodayHighlightedProperty =
+            AvaloniaProperty.Register<Calendar, bool>(
+                nameof(IsTodayHighlighted),
+                defaultValue: true);
+        /// <summary>
+        /// Gets or sets a value indicating whether the current date is
+        /// highlighted.
+        /// </summary>
+        /// <value>
+        /// True if the current date is highlighted; otherwise, false. The
+        /// default is true.
+        /// </value>
+        public bool IsTodayHighlighted
+        {
+            get { return GetValue(IsTodayHighlightedProperty); }
+            set { SetValue(IsTodayHighlightedProperty, value); }
+        }
+        /// <summary>
+        /// IsTodayHighlightedProperty property changed handler.
+        /// </summary>
+        /// <param name="e">The DependencyPropertyChangedEventArgs.</param>
+        private void OnIsTodayHighlightedChanged(AvaloniaPropertyChangedEventArgs e)
+        {
+            if (DisplayDate != null)
+            {
+                int i = DateTimeHelper.CompareYearMonth(DisplayDateInternal, DateTime.Today);
+
+                if (i > -2 && i < 2)
+                {
+                    UpdateMonths();
+                }
+            }
+        }
+
+        public static readonly StyledProperty<IBrush> HeaderBackgroundProperty =
+            AvaloniaProperty.Register<Calendar, IBrush>(nameof(HeaderBackground));
+        public IBrush HeaderBackground
+        {
+            get { return GetValue(HeaderBackgroundProperty); }
+            set { SetValue(HeaderBackgroundProperty, value); }
+        }
+
+        public static readonly StyledProperty<CalendarMode> DisplayModeProperty =
+            AvaloniaProperty.Register<Calendar, CalendarMode>(
+                nameof(DisplayMode),
+                validate: ValidateDisplayMode);
+        /// <summary>
+        /// Gets or sets a value indicating whether the calendar is displayed in
+        /// months, years, or decades.
+        /// </summary>
+        /// <value>
+        /// A value indicating what length of time the
+        /// <see cref="T:System.Windows.Controls.Calendar" /> should display.
+        /// </value>
+        public CalendarMode DisplayMode
+        {
+            get { return GetValue(DisplayModeProperty); }
+            set { SetValue(DisplayModeProperty, value); }
+        }
+        /// <summary>
+        /// DisplayModeProperty property changed handler.
+        /// </summary>
+        /// <param name="e">The DependencyPropertyChangedEventArgs.</param>
+        private void OnDisplayModePropertyChanged(AvaloniaPropertyChangedEventArgs e)
+        {
+            CalendarMode mode = (CalendarMode)e.NewValue;
+            CalendarMode oldMode = (CalendarMode)e.OldValue;
+            CalendarItem monthControl = MonthControl;
+
+            if (monthControl != null)
+            {
+                switch (oldMode)
+                {
+                    case CalendarMode.Month:
+                        {
+                            SelectedYear = DisplayDateInternal;
+                            SelectedMonth = DisplayDateInternal;
+                            break;
+                        }
+                    case CalendarMode.Year:
+                        {
+                            DisplayDate = SelectedMonth;
+                            SelectedYear = SelectedMonth;
+                            break;
+                        }
+                    case CalendarMode.Decade:
+                        {
+                            DisplayDate = SelectedYear;
+                            SelectedMonth = SelectedYear;
+                            break;
+                        }
+                }
+
+                switch (mode)
+                {
+                    case CalendarMode.Month:
+                        {
+                            OnMonthClick();
+                            break;
+                        }
+                    case CalendarMode.Year:
+                    case CalendarMode.Decade:
+                        {
+                            OnHeaderClick();
+                            break;
+                        }
+                }
+            }
+            OnDisplayModeChanged(new CalendarModeChangedEventArgs((CalendarMode)e.OldValue, mode));
+        }
+        private static CalendarMode ValidateDisplayMode(Calendar o, CalendarMode mode)
+        {
+            if(IsValidDisplayMode(mode))
+            {
+                return mode;
+            }
+            else
+            {
+                throw new ArgumentOutOfRangeException(nameof(mode), "Invalid DisplayMode");
+            }
+        }
+        private static bool IsValidDisplayMode(CalendarMode mode)
+        {
+            return mode == CalendarMode.Month
+                || mode == CalendarMode.Year
+                || mode == CalendarMode.Decade;
+        }
+        private void OnDisplayModeChanged(CalendarModeChangedEventArgs args)
+        {
+            DisplayModeChanged?.Invoke(this, args);
+        }
+
+        public static readonly StyledProperty<CalendarSelectionMode> SelectionModeProperty =
+            AvaloniaProperty.Register<Calendar, CalendarSelectionMode>(
+                nameof(SelectionMode),
+                defaultValue: CalendarSelectionMode.SingleDate);
+        /// <summary>
+        /// Gets or sets a value that indicates what kind of selections are
+        /// allowed.
+        /// </summary>
+        /// <value>
+        /// A value that indicates the current selection mode. The default is
+        /// <see cref="F:System.Windows.Controls.CalendarSelectionMode.SingleDate" />.
+        /// </value>
+        /// <remarks>
+        /// <para>
+        /// This property determines whether the Calendar allows no selection,
+        /// selection of a single date, or selection of multiple dates.  The
+        /// selection mode is specified with the CalendarSelectionMode
+        /// enumeration.
+        /// </para>
+        /// <para>
+        /// When this property is changed, all selected dates will be cleared.
+        /// </para>
+        /// </remarks>
+        public CalendarSelectionMode SelectionMode
+        {
+            get { return GetValue(SelectionModeProperty); }
+            set { SetValue(SelectionModeProperty, value); }
+        }
+        private void OnSelectionModeChanged(AvaloniaPropertyChangedEventArgs e)
+        {
+            if (IsValidSelectionMode(e.NewValue))
+            {
+                _displayDateIsChanging = true;
+                SelectedDate = null;
+                _displayDateIsChanging = false;
+                SelectedDates.Clear();
+            }
+            else
+            {
+                throw new ArgumentOutOfRangeException("d", "Invalid SelectionMode");
+            }
+        }
+        /// <summary>
+        /// Inherited code: Requires comment.
+        /// </summary>
+        /// <param name="value">Inherited code: Requires comment 1.</param>
+        /// <returns>Inherited code: Requires comment 2.</returns>
+        private static bool IsValidSelectionMode(object value)
+        {
+            CalendarSelectionMode mode = (CalendarSelectionMode)value;
+
+            return mode == CalendarSelectionMode.SingleDate
+                || mode == CalendarSelectionMode.SingleRange
+                || mode == CalendarSelectionMode.MultipleRange
+                || mode == CalendarSelectionMode.None;
+        }
+
+        public static readonly DirectProperty<Calendar, DateTime?> SelectedDateProperty =
+            AvaloniaProperty.RegisterDirect<Calendar, DateTime?>(
+                nameof(SelectedDate),
+                o => o.SelectedDate,
+                (o, v) => o.SelectedDate = v,
+                defaultBindingMode: BindingMode.TwoWay);
+        /// <summary>
+        /// Gets or sets the currently selected date.
+        /// </summary>
+        /// <value>The date currently selected. The default is null.</value>
+        /// <exception cref="T:System.ArgumentOutOfRangeException">
+        /// The given date is outside the range specified by
+        /// <see cref="P:System.Windows.Controls.Calendar.DisplayDateStart" />
+        /// and <see cref="P:System.Windows.Controls.Calendar.DisplayDateEnd" />
+        /// -or-
+        /// The given date is in the
+        /// <see cref="P:System.Windows.Controls.Calendar.BlackoutDates" />
+        /// collection.
+        /// </exception>
+        /// <exception cref="T:System.InvalidOperationException">
+        /// If set to anything other than null when
+        /// <see cref="P:System.Windows.Controls.Calendar.SelectionMode" /> is
+        /// set to
+        /// <see cref="F:System.Windows.Controls.CalendarSelectionMode.None" />.
+        /// </exception>
+        /// <remarks>
+        /// Use this property when SelectionMode is set to SingleDate.  In other
+        /// modes, this property will always be the first date in SelectedDates.
+        /// </remarks>
+        public DateTime? SelectedDate
+        {
+            get { return _selectedDate; }
+            set { SetAndRaise(SelectedDateProperty, ref _selectedDate, value); }
+        }
+        private void OnSelectedDateChanged(AvaloniaPropertyChangedEventArgs e)
+        {
+            if (!_displayDateIsChanging)
+            {
+                if (SelectionMode != CalendarSelectionMode.None)
+                {
+                    DateTime? addedDate;
+
+                    addedDate = (DateTime?)e.NewValue;
+
+                    if (IsValidDateSelection(this, addedDate))
+                    {
+                        if (addedDate == null)
+                        {
+                            SelectedDates.Clear();
+                        }
+                        else
+                        {
+                            if (addedDate.HasValue && !(SelectedDates.Count > 0 && SelectedDates[0] == addedDate.Value))
+                            {
+                                foreach (DateTime item in SelectedDates)
+                                {
+                                    RemovedItems.Add(item);
+                                }
+                                SelectedDates.ClearInternal();
+                                // the value is added as a range so that the
+                                // SelectedDatesChanged event can be thrown with
+                                // all the removed items
+                                SelectedDates.AddRange(addedDate.Value, addedDate.Value);
+                            }
+                        }
+
+                        // We update the LastSelectedDate for only the Single
+                        // mode.  For the other modes it automatically gets
+                        // updated when the HoverEnd is updated.
+                        if (SelectionMode == CalendarSelectionMode.SingleDate)
+                        {
+                            LastSelectedDate = addedDate;
+                        }
+                    }
+                    else
+                    {
+                        throw new ArgumentOutOfRangeException("d", "SelectedDate value is not valid.");
+                    }
+                }
+                else
+                {
+                    throw new InvalidOperationException("The SelectedDate property cannot be set when the selection mode is None.");
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets a collection of selected dates.
+        /// </summary>
+        /// <value>
+        /// A <see cref="T:System.Windows.Controls.SelectedDatesCollection" />
+        /// object that contains the currently selected dates. The default is an
+        /// empty collection.
+        /// </value>
+        /// <remarks>
+        /// Dates can be added to the collection either individually or in a
+        /// range using the AddRange method.  Depending on the value of the
+        /// SelectionMode property, adding a date or range to the collection may
+        /// cause it to be cleared.  The following table lists how
+        /// CalendarSelectionMode affects the SelectedDates property.
+        /// 
+        ///     CalendarSelectionMode   Description
+        ///     None                    No selections are allowed.  SelectedDate
+        ///                             cannot be set and no values can be added
+        ///                             to SelectedDates.
+        ///                             
+        ///     SingleDate              Only a single date can be selected,
+        ///                             either by setting SelectedDate or the
+        ///                             first value in SelectedDates.  AddRange
+        ///                             cannot be used.
+        ///                             
+        ///     SingleRange             A single range of dates can be selected.
+        ///                             Setting SelectedDate, adding a date
+        ///                             individually to SelectedDates, or using
+        ///                             AddRange will clear all previous values
+        ///                             from SelectedDates.
+        ///     MultipleRange           Multiple non-contiguous ranges of dates
+        ///                             can be selected. Adding a date
+        ///                             individually to SelectedDates or using
+        ///                             AddRange will not clear SelectedDates.
+        ///                             Setting SelectedDate will still clear
+        ///                             SelectedDates, but additional dates or
+        ///                             range can then be added.  Adding a range
+        ///                             that includes some dates that are
+        ///                             already selected or overlaps with
+        ///                             another range results in the union of
+        ///                             the ranges and does not cause an
+        ///                             exception.
+        /// </remarks>
+        public SelectedDatesCollection SelectedDates { get; private set; }
+        private static bool IsSelectionChanged(SelectionChangedEventArgs e)
+        {
+            if (e.AddedItems.Count != e.RemovedItems.Count)
+            {
+                return true;
+            }
+            foreach (DateTime addedDate in e.AddedItems)
+            {
+                if (!e.RemovedItems.Contains(addedDate))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+        internal void OnSelectedDatesCollectionChanged(SelectionChangedEventArgs e)
+        {
+            if (IsSelectionChanged(e))
+            {
+                e.RoutedEvent = SelectingItemsControl.SelectionChangedEvent;
+                e.Source = this;
+                SelectedDatesChanged?.Invoke(this, e);
+            }
+        }
+        
+        internal Collection<DateTime> RemovedItems { get; set; }
+        internal DateTime? LastSelectedDateInternal { get; set; }
+        internal DateTime? LastSelectedDate
+        {
+            get { return LastSelectedDateInternal; }
+            set
+            {
+                LastSelectedDateInternal = value;
+
+                if (SelectionMode == CalendarSelectionMode.None)
+                {
+                    if (FocusButton != null)
+                    {
+                        FocusButton.IsCurrent = false;
+                    }
+                    FocusButton = FindDayButtonFromDay(LastSelectedDate.Value);
+                    if (FocusButton != null)
+                    {
+                        FocusButton.IsCurrent = HasFocusInternal;
+                    }
+                }
+            }
+        }
+
+        internal DateTime SelectedMonth
+        {
+            get { return _selectedMonth; }
+            set
+            {
+                int monthDifferenceStart = DateTimeHelper.CompareYearMonth(value, DisplayDateRangeStart);
+                int monthDifferenceEnd = DateTimeHelper.CompareYearMonth(value, DisplayDateRangeEnd);
+
+                if (monthDifferenceStart >= 0 && monthDifferenceEnd <= 0)
+                {
+                    _selectedMonth = DateTimeHelper.DiscardDayTime(value);
+                }
+                else
+                {
+                    if (monthDifferenceStart < 0)
+                    {
+                        _selectedMonth = DateTimeHelper.DiscardDayTime(DisplayDateRangeStart);
+                    }
+                    else
+                    {
+                        Debug.Assert(monthDifferenceEnd > 0, "monthDifferenceEnd should be greater than 0!");
+                        _selectedMonth = DateTimeHelper.DiscardDayTime(DisplayDateRangeEnd);
+                    }
+                }
+            }
+        }
+        internal DateTime SelectedYear
+        {
+            get { return _selectedYear; }
+            set
+            {
+                if (value.Year < DisplayDateRangeStart.Year)
+                {
+                    _selectedYear = DisplayDateRangeStart;
+                }
+                else
+                {
+                    if (value.Year > DisplayDateRangeEnd.Year)
+                    {
+                        _selectedYear = DisplayDateRangeEnd;
+                    }
+                    else
+                    {
+                        _selectedYear = value;
+                    }
+                }
+            }
+        }
+
+        public static readonly DirectProperty<Calendar, DateTime> DisplayDateProperty =
+            AvaloniaProperty.RegisterDirect<Calendar, DateTime>(
+                nameof(DisplayDate),
+                o => o.DisplayDate,
+                (o, v) => o.DisplayDate = v,
+                defaultBindingMode: BindingMode.TwoWay);
+        /// <summary>
+        /// Gets or sets the date to display.
+        /// </summary>
+        /// <value>The date to display.</value>
+        /// <exception cref="T:System.ArgumentOutOfRangeException">
+        /// The given date is not in the range specified by
+        /// <see cref="P:System.Windows.Controls.Calendar.DisplayDateStart" />
+        /// and
+        /// <see cref="P:System.Windows.Controls.Calendar.DisplayDateEnd" />.
+        /// </exception>
+        /// <remarks>
+        /// <para>
+        /// This property allows the developer to specify a date to display.  If
+        /// this property is a null reference (Nothing in Visual Basic),
+        /// SelectedDate is displayed.  If SelectedDate is also a null reference
+        /// (Nothing in Visual Basic), Today is displayed.  The default is
+        /// Today.
+        /// </para>
+        /// <para>
+        /// To set this property in XAML, use a date specified in the format
+        /// yyyy/mm/dd.  The mm and dd components must always consist of two
+        /// characters, with a leading zero if necessary.  For instance, the
+        /// month of May should be specified as 05.
+        /// </para>
+        /// </remarks>
+        public DateTime DisplayDate
+        {
+            get { return _displayDate; }
+            set { SetAndRaise(DisplayDateProperty, ref _displayDate, value); }
+        }
+        internal DateTime DisplayDateInternal { get; private set; }
+
+        private void OnDisplayDateChanged(AvaloniaPropertyChangedEventArgs e)
+        {
+            UpdateDisplayDate(this, (DateTime)e.NewValue, (DateTime)e.OldValue);
+        }
+        private static void UpdateDisplayDate(Calendar c, DateTime addedDate, DateTime removedDate)
+        {
+            Debug.Assert(c != null, "c should not be null!");
+
+            // If DisplayDate < DisplayDateStart, DisplayDate = DisplayDateStart
+            if (DateTime.Compare(addedDate, c.DisplayDateRangeStart) < 0)
+            {
+                c.DisplayDate = c.DisplayDateRangeStart;
+                return;
+            }
+
+            // If DisplayDate > DisplayDateEnd, DisplayDate = DisplayDateEnd
+            if (DateTime.Compare(addedDate, c.DisplayDateRangeEnd) > 0)
+            {
+                c.DisplayDate = c.DisplayDateRangeEnd;
+                return;
+            }
+
+            c.DisplayDateInternal = DateTimeHelper.DiscardDayTime(addedDate);
+            c.UpdateMonths();
+            c.OnDisplayDate(new CalendarDateChangedEventArgs(removedDate, addedDate));
+        }
+        private void OnDisplayDate(CalendarDateChangedEventArgs e)
+        {
+            DisplayDateChanged?.Invoke(this, e);
+        }
+
+        public static readonly DirectProperty<Calendar, DateTime?> DisplayDateStartProperty =
+            AvaloniaProperty.RegisterDirect<Calendar, DateTime?>(
+                nameof(DisplayDateStart),
+                o => o.DisplayDateStart,
+                (o, v) => o.DisplayDateStart = v,
+                defaultBindingMode: BindingMode.TwoWay);
+        /// <summary>
+        /// Gets or sets the first date to be displayed.
+        /// </summary>
+        /// <value>The first date to display.</value>
+        /// <remarks>
+        /// To set this property in XAML, use a date specified in the format
+        /// yyyy/mm/dd.  The mm and dd components must always consist of two
+        /// characters, with a leading zero if necessary.  For instance, the
+        /// month of May should be specified as 05.
+        /// </remarks>
+        public DateTime? DisplayDateStart
+        {
+            get { return _displayDateStart; }
+            set { SetAndRaise(DisplayDateStartProperty, ref _displayDateStart, value); }
+        }
+        private void OnDisplayDateStartChanged(AvaloniaPropertyChangedEventArgs e)
+        {
+            if (!_displayDateIsChanging)
+            {
+                DateTime? newValue = e.NewValue as DateTime?;
+
+                if (newValue.HasValue)
+                {
+                    // DisplayDateStart coerces to the value of the
+                    // SelectedDateMin if SelectedDateMin < DisplayDateStart
+                    DateTime? selectedDateMin = SelectedDateMin(this);
+
+                    if (selectedDateMin.HasValue && DateTime.Compare(selectedDateMin.Value, newValue.Value) < 0)
+                    {
+                        DisplayDateStart = selectedDateMin.Value;
+                        return;
+                    }
+
+                    // if DisplayDateStart > DisplayDateEnd,
+                    // DisplayDateEnd = DisplayDateStart
+                    if (DateTime.Compare(newValue.Value, DisplayDateRangeEnd) > 0)
+                    {
+                        DisplayDateEnd = DisplayDateStart;
+                    }
+
+                    // If DisplayDate < DisplayDateStart,
+                    // DisplayDate = DisplayDateStart
+                    if (DateTimeHelper.CompareYearMonth(newValue.Value, DisplayDateInternal) > 0)
+                    {
+                        DisplayDate = newValue.Value;
+                    }
+                }
+                UpdateMonths();
+            }
+        }
+
+        /// <summary>
+        /// Gets a collection of dates that are marked as not selectable.
+        /// </summary>
+        /// <value>
+        /// A collection of dates that cannot be selected. The default value is
+        /// an empty collection.
+        /// </value>
+        /// <exception cref="System.ArgumentOutOfRangeException">
+        /// Adding a date to this collection when it is already selected or
+        /// adding a date outside the range specified by DisplayDateStart and
+        /// DisplayDateEnd.
+        /// </exception>
+        /// <remarks>
+        /// <para>
+        /// Dates in this collection will appear as disabled on the calendar.
+        /// </para>
+        /// <para>
+        /// To make all past dates not selectable, you can use the
+        /// AddDatesInPast method provided by the collection returned by this
+        /// property.
+        /// </para>
+        /// </remarks>
+        public CalendarBlackoutDatesCollection BlackoutDates { get; private set; }
+
+        private static DateTime? SelectedDateMin(Calendar cal)
+        {
+            DateTime selectedDateMin;
+
+            if (cal.SelectedDates.Count > 0)
+            {
+                selectedDateMin = cal.SelectedDates[0];
+                Debug.Assert(DateTime.Compare(cal.SelectedDate.Value, selectedDateMin) == 0, "The SelectedDate should be the minimum selected date!");
+            }
+            else
+            {
+                return null;
+            }
+
+            foreach (DateTime selectedDate in cal.SelectedDates)
+            {
+                if (DateTime.Compare(selectedDate, selectedDateMin) < 0)
+                {
+                    selectedDateMin = selectedDate;
+                }
+            }
+            return selectedDateMin;
+        }
+        internal DateTime DisplayDateRangeStart
+        {
+            get { return DisplayDateStart.GetValueOrDefault(DateTime.MinValue); }
+        }
+
+        public static readonly DirectProperty<Calendar, DateTime?> DisplayDateEndProperty =
+            AvaloniaProperty.RegisterDirect<Calendar, DateTime?>(
+                nameof(DisplayDateEnd),
+                o => o.DisplayDateEnd,
+                (o, v) => o.DisplayDateEnd = v,
+                defaultBindingMode: BindingMode.TwoWay);
+        
+        /// <summary>
+        /// Gets or sets the last date to be displayed.
+        /// </summary>
+        /// <value>The last date to display.</value>
+        /// <remarks>
+        /// To set this property in XAML, use a date specified in the format
+        /// yyyy/mm/dd.  The mm and dd components must always consist of two
+        /// characters, with a leading zero if necessary.  For instance, the
+        /// month of May should be specified as 05.
+        /// </remarks>
+        public DateTime? DisplayDateEnd
+        {
+            get { return _displayDateEnd; }
+            set { SetAndRaise(DisplayDateEndProperty, ref _displayDateEnd, value); }
+        }
+
+        private void OnDisplayDateEndChanged(AvaloniaPropertyChangedEventArgs e)
+        {
+            if (!_displayDateIsChanging)
+            {
+                DateTime? newValue = e.NewValue as DateTime?;
+
+                if (newValue.HasValue)
+                {
+                    // DisplayDateEnd coerces to the value of the
+                    // SelectedDateMax if SelectedDateMax > DisplayDateEnd
+                    DateTime? selectedDateMax = SelectedDateMax(this);
+
+                    if (selectedDateMax.HasValue && DateTime.Compare(selectedDateMax.Value, newValue.Value) > 0)
+                    {
+                        DisplayDateEnd = selectedDateMax.Value;
+                        return;
+                    }
+
+                    // if DisplayDateEnd < DisplayDateStart,
+                    // DisplayDateEnd = DisplayDateStart
+                    if (DateTime.Compare(newValue.Value, DisplayDateRangeStart) < 0)
+                    {
+                        DisplayDateEnd = DisplayDateStart;
+                        return;
+                    }
+
+                    // If DisplayDate > DisplayDateEnd,
+                    // DisplayDate = DisplayDateEnd
+                    if (DateTimeHelper.CompareYearMonth(newValue.Value, DisplayDateInternal) < 0)
+                    {
+                        DisplayDate = newValue.Value;
+                    }
+                }
+                UpdateMonths();
+            }
+        }
+
+        private static DateTime? SelectedDateMax(Calendar cal)
+        {
+            DateTime selectedDateMax;
+
+            if (cal.SelectedDates.Count > 0)
+            {
+                selectedDateMax = cal.SelectedDates[0];
+                Debug.Assert(DateTime.Compare(cal.SelectedDate.Value, selectedDateMax) == 0, "The SelectedDate should be the maximum SelectedDate!");
+            }
+            else
+            {
+                return null;
+            }
+
+            foreach (DateTime selectedDate in cal.SelectedDates)
+            {
+                if (DateTime.Compare(selectedDate, selectedDateMax) > 0)
+                {
+                    selectedDateMax = selectedDate;
+                }
+            }
+            return selectedDateMax;
+        }
+        internal DateTime DisplayDateRangeEnd
+        {
+            get { return DisplayDateEnd.GetValueOrDefault(DateTime.MaxValue); }
+        }
+
+        internal DateTime? HoverStart { get; set; }
+        internal int? HoverStartIndex { get; set; }
+        internal DateTime? HoverEndInternal { get; set; }
+        internal DateTime? HoverEnd
+        {
+            get { return HoverEndInternal; }
+            set
+            {
+                HoverEndInternal = value;
+                LastSelectedDate = value;
+            }
+        }
+        internal int? HoverEndIndex { get; set; }
+        internal bool HasFocusInternal { get; set; }
+        internal bool IsMouseSelection { get; set; }
+
+
+        /// <summary>
+        /// Gets or sets a value indicating whether DatePicker should change its 
+        /// DisplayDate because of a SelectedDate change on its Calendar.
+        /// </summary>
+        internal bool DatePickerDisplayDateFlag { get; set; }
+
+        internal CalendarDayButton FindDayButtonFromDay(DateTime day)
+        {
+            CalendarDayButton b;
+            DateTime? d;
+            CalendarItem monthControl = MonthControl;
+
+            // REMOVE_RTM: should be updated if we support MultiCalendar
+            int count = RowsPerMonth * ColumnsPerMonth;
+            if (monthControl != null)
+            {
+                if (monthControl.MonthView != null)
+                {
+                    for (int childIndex = ColumnsPerMonth; childIndex < count; childIndex++)
+                    {
+                        b = monthControl.MonthView.Children[childIndex] as CalendarDayButton;
+                        d = b.DataContext as DateTime?;
+
+                        if (d.HasValue)
+                        {
+                            if (DateTimeHelper.CompareDays(d.Value, day) == 0)
+                            {
+                                return b;
+                            }
+                        }
+                    }
+                }
+            }
+            return null;
+        }
+
+        private void Calendar_SizeChanged(object sender, EventArgs e)
+        {
+            Debug.Assert(sender is Calendar, "The sender should be a Calendar!");
+
+            var size = Bounds.Size;
+            RectangleGeometry rg = new RectangleGeometry();
+            rg.Rect = new Rect(0, 0, size.Width, size.Height);
+
+            if (Root != null)
+            {
+                Root.Clip = rg;
+            }
+        }
+
+        private void OnSelectedMonthChanged(DateTime? selectedMonth)
+        {
+            if (selectedMonth.HasValue)
+            {
+                Debug.Assert(DisplayMode == CalendarMode.Year, "DisplayMode should be Year!");
+                SelectedMonth = selectedMonth.Value;
+                UpdateMonths();
+            }
+        }
+        private void OnSelectedYearChanged(DateTime? selectedYear)
+        {
+            if (selectedYear.HasValue)
+            {
+                Debug.Assert(DisplayMode == CalendarMode.Decade, "DisplayMode should be Decade!");
+                SelectedYear = selectedYear.Value;
+                UpdateMonths();
+            }
+        }
+        internal void OnHeaderClick()
+        {
+            Debug.Assert(DisplayMode == CalendarMode.Year || DisplayMode == CalendarMode.Decade, "The DisplayMode should be Year or Decade");
+            CalendarItem monthControl = MonthControl;
+            if (monthControl != null && monthControl.MonthView != null && monthControl.YearView != null)
+            {
+                monthControl.MonthView.IsVisible = false;
+                monthControl.YearView.IsVisible = true;
+                UpdateMonths();
+            }
+        }
+
+        internal void ResetStates()
+        {
+            CalendarDayButton d;
+            CalendarItem monthControl = MonthControl;
+            int count = RowsPerMonth * ColumnsPerMonth;
+            if (monthControl != null)
+            {
+                if (monthControl.MonthView != null)
+                {
+                    for (int childIndex = ColumnsPerMonth; childIndex < count; childIndex++)
+                    {
+                        d = monthControl.MonthView.Children[childIndex] as CalendarDayButton;
+                        d.IgnoreMouseOverState();
+                    }
+                }
+            }
+
+        }
+
+        internal void UpdateMonths()
+        {
+            CalendarItem monthControl = MonthControl;
+            if (monthControl != null)
+            {
+                switch (DisplayMode)
+                {
+                    case CalendarMode.Month:
+                        {
+                            monthControl.UpdateMonthMode();
+                            break;
+                        }
+                    case CalendarMode.Year:
+                        {
+                            monthControl.UpdateYearMode();
+                            break;
+                        }
+                    case CalendarMode.Decade:
+                        {
+                            monthControl.UpdateDecadeMode();
+                            break;
+                        }
+                }
+            }
+        }
+
+        internal static bool IsValidDateSelection(Calendar cal, DateTime? value)
+        {
+            if (!value.HasValue)
+            {
+                return true;
+            }
+            else
+            {
+                if (cal.BlackoutDates.Contains(value.Value))
+                {
+                    return false;
+                }
+                else
+                {
+                    cal._displayDateIsChanging = true;
+                    if (DateTime.Compare(value.Value, cal.DisplayDateRangeStart) < 0)
+                    {
+                        cal.DisplayDateStart = value;
+                    }
+                    else if (DateTime.Compare(value.Value, cal.DisplayDateRangeEnd) > 0)
+                    {
+                        cal.DisplayDateEnd = value;
+                    }
+                    cal._displayDateIsChanging = false;
+
+                    return true;
+                }
+            }
+        }
+        private static bool IsValidKeyboardSelection(Calendar cal, DateTime? value)
+        {
+            if (!value.HasValue)
+            {
+                return true;
+            }
+            else
+            {
+                if (cal.BlackoutDates.Contains(value.Value))
+                {
+                    return false;
+                }
+                else
+                {
+                    return (DateTime.Compare(value.Value, cal.DisplayDateRangeStart) >= 0 && DateTime.Compare(value.Value, cal.DisplayDateRangeEnd) <= 0);
+                }
+            }
+        }
+
+        /// <summary>
+        /// This method highlights the days in MultiSelection mode without
+        /// adding them to the SelectedDates collection.
+        /// </summary>
+        internal void HighlightDays()
+        {
+            if (HoverEnd != null && HoverStart != null)
+            {
+                int startIndex, endIndex, i;
+                CalendarDayButton b;
+                DateTime? d;
+                CalendarItem monthControl = MonthControl;
+
+                // This assumes a contiguous set of dates:
+                if (HoverEndIndex != null && HoverStartIndex != null)
+                {
+                    SortHoverIndexes(out startIndex, out endIndex);
+
+                    for (i = startIndex; i <= endIndex; i++)
+                    {
+                        b = monthControl.MonthView.Children[i] as CalendarDayButton;
+                        b.IsSelected = true;
+                        d = b.DataContext as DateTime?;
+
+                        if (d.HasValue && DateTimeHelper.CompareDays(HoverEnd.Value, d.Value) == 0)
+                        {
+                            if (FocusButton != null)
+                            {
+                                FocusButton.IsCurrent = false;
+                            }
+                            b.IsCurrent = HasFocusInternal;
+                            FocusButton = b;
+                        }
+                    }
+                }
+            }
+        }
+        /// <summary>
+        /// This method un-highlights the days that were hovered over but not
+        /// added to the SelectedDates collection or un-highlighted the
+        /// previously selected days in SingleRange Mode.
+        /// </summary>
+        internal void UnHighlightDays()
+        {
+            if (HoverEnd != null && HoverStart != null)
+            {
+                CalendarItem monthControl = MonthControl;
+                CalendarDayButton b;
+                DateTime? d;
+
+                if (HoverEndIndex != null && HoverStartIndex != null)
+                {
+                    int i;
+                    SortHoverIndexes(out int startIndex, out int endIndex);
+
+                    if (SelectionMode == CalendarSelectionMode.MultipleRange)
+                    {
+                        for (i = startIndex; i <= endIndex; i++)
+                        {
+                            b = monthControl.MonthView.Children[i] as CalendarDayButton;
+                            d = b.DataContext as DateTime?;
+
+                            if (d.HasValue)
+                            {
+                                if (!SelectedDates.Contains(d.Value))
+                                {
+                                    b.IsSelected = false;
+                                }
+                            }
+                        }
+                    }
+                    else
+                    {
+                        // It is SingleRange
+                        for (i = startIndex; i <= endIndex; i++)
+                        {
+                            (monthControl.MonthView.Children[i] as CalendarDayButton).IsSelected = false;
+                        }
+                    }
+                }
+            }
+        }
+        internal void SortHoverIndexes(out int startIndex, out int endIndex)
+        {
+            if (DateTimeHelper.CompareDays(HoverEnd.Value, HoverStart.Value) > 0)
+            {
+                startIndex = HoverStartIndex.Value;
+                endIndex = HoverEndIndex.Value;
+            }
+            else
+            {
+                startIndex = HoverEndIndex.Value;
+                endIndex = HoverStartIndex.Value;
+            }
+        }
+
+        internal void OnPreviousClick()
+        {
+            if (DisplayMode == CalendarMode.Month && DisplayDate != null)
+            {
+                DateTime? d = DateTimeHelper.AddMonths(DateTimeHelper.DiscardDayTime(DisplayDate), -1);
+                if (d.HasValue)
+                {
+                    if (!LastSelectedDate.HasValue || DateTimeHelper.CompareYearMonth(LastSelectedDate.Value, d.Value) != 0)
+                    {
+                        LastSelectedDate = d.Value;
+                    }
+                    DisplayDate = d.Value;
+                }
+            }
+            else
+            {
+                if (DisplayMode == CalendarMode.Year)
+                {
+                    DateTime? d = DateTimeHelper.AddYears(new DateTime(SelectedMonth.Year, 1, 1), -1);
+
+                    if (d.HasValue)
+                    {
+                        SelectedMonth = d.Value;
+                    }
+                    else
+                    {
+                        SelectedMonth = DateTimeHelper.DiscardDayTime(DisplayDateRangeStart);
+                    }
+                }
+                else
+                {
+                    Debug.Assert(DisplayMode == CalendarMode.Decade, "DisplayMode should be Decade!");
+
+                    DateTime? d = DateTimeHelper.AddYears(new DateTime(SelectedYear.Year, 1, 1), -10);
+
+                    if (d.HasValue)
+                    {
+                        int decade = Math.Max(1, DateTimeHelper.DecadeOfDate(d.Value));
+                        SelectedYear = new DateTime(decade, 1, 1);
+                    }
+                    else
+                    {
+                        SelectedYear = DateTimeHelper.DiscardDayTime(DisplayDateRangeStart);
+                    }
+                }
+                UpdateMonths();
+            }
+        }
+        internal void OnNextClick()
+        {
+            if (DisplayMode == CalendarMode.Month && DisplayDate != null)
+            {
+                DateTime? d = DateTimeHelper.AddMonths(DateTimeHelper.DiscardDayTime(DisplayDate), 1);
+                if (d.HasValue)
+                {
+                    if (!LastSelectedDate.HasValue || DateTimeHelper.CompareYearMonth(LastSelectedDate.Value, d.Value) != 0)
+                    {
+                        LastSelectedDate = d.Value;
+                    }
+                    DisplayDate = d.Value;
+                }
+            }
+            else
+            {
+                if (DisplayMode == CalendarMode.Year)
+                {
+                    DateTime? d = DateTimeHelper.AddYears(new DateTime(SelectedMonth.Year, 1, 1), 1);
+
+                    if (d.HasValue)
+                    {
+                        SelectedMonth = d.Value;
+                    }
+                    else
+                    {
+                        SelectedMonth = DateTimeHelper.DiscardDayTime(DisplayDateRangeEnd);
+                    }
+                }
+                else
+                {
+                    Debug.Assert(DisplayMode == CalendarMode.Decade, "DisplayMode should be Decade");
+
+                    DateTime? d = DateTimeHelper.AddYears(new DateTime(SelectedYear.Year, 1, 1), 10);
+
+                    if (d.HasValue)
+                    {
+                        int decade = Math.Max(1, DateTimeHelper.DecadeOfDate(d.Value));
+                        SelectedYear = new DateTime(decade, 1, 1);
+                    }
+                    else
+                    {
+                        SelectedYear = DateTimeHelper.DiscardDayTime(DisplayDateRangeEnd);
+                    }
+                }
+                UpdateMonths();
+            }
+        }
+
+        /// <summary>
+        /// If the day is a trailing day, Update the DisplayDate.
+        /// </summary>
+        /// <param name="selectedDate">Inherited code: Requires comment.</param>
+        internal void OnDayClick(DateTime selectedDate)
+        {
+            Debug.Assert(DisplayMode == CalendarMode.Month, "DisplayMode should be Month!");
+            int i = DateTimeHelper.CompareYearMonth(selectedDate, DisplayDateInternal);
+
+            if (SelectionMode == CalendarSelectionMode.None)
+            {
+                LastSelectedDate = selectedDate;
+            }
+
+            if (i > 0)
+            {
+                OnNextClick();
+            }
+            else if (i < 0)
+            {
+                OnPreviousClick();
+            }
+        }
+        private void OnMonthClick()
+        {
+            CalendarItem monthControl = MonthControl;
+            if (monthControl != null && monthControl.YearView != null && monthControl.MonthView != null)
+            {
+                monthControl.YearView.IsVisible = false;
+                monthControl.MonthView.IsVisible = true;
+
+                if (!LastSelectedDate.HasValue || DateTimeHelper.CompareYearMonth(LastSelectedDate.Value, DisplayDate) != 0)
+                {
+                    LastSelectedDate = DisplayDate;
+                }
+
+                UpdateMonths();
+            }
+        }
+
+        public override string ToString()
+        {
+            if (SelectedDate != null)
+            {
+                return SelectedDate.Value.ToString(DateTimeHelper.GetCurrentDateFormat());
+            }
+            else
+            {
+                return string.Empty;
+            }
+        }
+
+        public event EventHandler<SelectionChangedEventArgs> SelectedDatesChanged;
+
+        /// <summary>
+        /// Occurs when the
+        /// <see cref="P:System.Windows.Controls.Calendar.DisplayDate" />
+        /// property is changed.
+        /// </summary>
+        /// <remarks>
+        /// This event occurs after DisplayDate is assigned its new value.
+        /// </remarks>
+        public event EventHandler<CalendarDateChangedEventArgs> DisplayDateChanged;
+
+        /// <summary>
+        /// Occurs when the
+        /// <see cref="P:System.Windows.Controls.Calendar.DisplayMode" />
+        /// property is changed.
+        /// </summary>
+        public event EventHandler<CalendarModeChangedEventArgs> DisplayModeChanged;
+
+        /// <summary>
+        /// Inherited code: Requires comment.
+        /// </summary>
+        internal event EventHandler<PointerReleasedEventArgs> DayButtonMouseUp;
+
+        /// <summary>
+        /// This method adds the days that were selected by Keyboard to the
+        /// SelectedDays Collection.
+        /// </summary>
+        private void AddSelection()
+        {
+            if (HoverEnd != null && HoverStart != null)
+            {
+                foreach (DateTime item in SelectedDates)
+                {
+                    RemovedItems.Add(item);
+                }
+
+                SelectedDates.ClearInternal();
+                // In keyboard selection, we are sure that the collection does
+                // not include any blackout days
+                SelectedDates.AddRange(HoverStart.Value, HoverEnd.Value);
+            }
+        }
+        private void ProcessSelection(bool shift, DateTime? lastSelectedDate, int? index)
+        {
+            if (SelectionMode == CalendarSelectionMode.None && lastSelectedDate != null)
+            {
+                OnDayClick(lastSelectedDate.Value);
+                return;
+            }
+            if (lastSelectedDate != null && IsValidKeyboardSelection(this, lastSelectedDate.Value))
+            {
+                if (SelectionMode == CalendarSelectionMode.SingleRange || SelectionMode == CalendarSelectionMode.MultipleRange)
+                {
+                    foreach (DateTime item in SelectedDates)
+                    {
+                        RemovedItems.Add(item);
+                    }
+                    SelectedDates.ClearInternal();
+                    if (shift)
+                    {
+                        CalendarDayButton b;
+                        _isShiftPressed = true;
+                        if (HoverStart == null)
+                        {
+                            if (LastSelectedDate != null)
+                            {
+                                HoverStart = LastSelectedDate;
+                            }
+                            else
+                            {
+                                if (DateTimeHelper.CompareYearMonth(DisplayDateInternal, DateTime.Today) == 0)
+                                {
+                                    HoverStart = DateTime.Today;
+                                }
+                                else
+                                {
+                                    HoverStart = DisplayDateInternal;
+                                }
+                            }
+
+                            b = FindDayButtonFromDay(HoverStart.Value);
+                            if (b != null)
+                            {
+                                HoverStartIndex = b.Index;
+                            }
+                        }
+                        // the index of the SelectedDate is always the last
+                        // selectedDate's index
+                        UnHighlightDays();
+                        // If we hit a BlackOutDay with keyboard we do not
+                        // update the HoverEnd
+                        CalendarDateRange range;
+
+                        if (DateTime.Compare(HoverStart.Value, lastSelectedDate.Value) < 0)
+                        {
+                            range = new CalendarDateRange(HoverStart.Value, lastSelectedDate.Value);
+                        }
+                        else
+                        {
+                            range = new CalendarDateRange(lastSelectedDate.Value, HoverStart.Value);
+                        }
+
+                        if (!BlackoutDates.ContainsAny(range))
+                        {
+                            HoverEnd = lastSelectedDate;
+
+                            if (index.HasValue)
+                            {
+                                HoverEndIndex += index;
+                            }
+                            else
+                            {
+                                // For Home, End, PageUp and PageDown Keys there
+                                // is no easy way to predict the index value
+                                b = FindDayButtonFromDay(HoverEndInternal.Value);
+
+                                if (b != null)
+                                {
+                                    HoverEndIndex = b.Index;
+                                }
+                            }
+                        }
+
+                        OnDayClick(HoverEnd.Value);
+                        HighlightDays();
+                    }
+                    else
+                    {
+                        HoverStart = lastSelectedDate;
+                        HoverEnd = lastSelectedDate;
+                        AddSelection();
+                        OnDayClick(lastSelectedDate.Value);
+                    }
+                }
+                else
+                {
+                    // ON CLEAR 
+                    LastSelectedDate = lastSelectedDate.Value;
+                    if (SelectedDates.Count > 0)
+                    {
+                        SelectedDates[0] = lastSelectedDate.Value;
+                    }
+                    else
+                    {
+                        SelectedDates.Add(lastSelectedDate.Value);
+                    }
+                    OnDayClick(lastSelectedDate.Value);
+                }
+            }
+        }
+
+        protected override void OnPointerReleased(PointerReleasedEventArgs e)
+        {
+            base.OnPointerReleased(e);
+            if (!HasFocusInternal && e.MouseButton == MouseButton.Left)
+            {
+                FocusManager.Instance.Focus(this);
+            }
+        }
+
+        internal void OnDayButtonMouseUp(PointerReleasedEventArgs e)
+        {
+            DayButtonMouseUp?.Invoke(this, e);
+        }
+
+        /// <summary>
+        /// Default mouse wheel handler for the calendar control.
+        /// </summary>
+        /// <param name="e">Mouse wheel event args.</param>
+        protected override void OnPointerWheelChanged(PointerWheelEventArgs e)
+        {
+            base.OnPointerWheelChanged(e);
+            if (!e.Handled)
+            {
+                CalendarExtensions.GetMetaKeyState(e.InputModifiers, out bool ctrl, out bool shift);
+
+                if (!ctrl)
+                {
+                    if (e.Delta.Y > 0)
+                    {
+                        ProcessPageUpKey(false);
+                    }
+                    else
+                    {
+                        ProcessPageDownKey(false);
+                    }
+                }
+                else
+                {
+                    if (e.Delta.Y > 0)
+                    {
+                        ProcessDownKey(ctrl, shift);
+                    }
+                    else
+                    {
+                        ProcessUpKey(ctrl, shift);
+                    }
+                }
+                e.Handled = true;
+            }
+        }
+        internal void Calendar_KeyDown(object sender, KeyEventArgs e)
+        {
+            Calendar c = sender as Calendar;
+            Debug.Assert(c != null, "c should not be null!");
+
+            if (!e.Handled && c.IsEnabled)
+            {
+                e.Handled = ProcessCalendarKey(e);
+            }
+        }
+        internal bool ProcessCalendarKey(KeyEventArgs e)
+        {
+            if (DisplayMode == CalendarMode.Month)
+            {
+                if (LastSelectedDate.HasValue && DisplayDateInternal != null)
+                {
+                    // If a blackout day is inactive, when clicked on it, the
+                    // previous inactive day which is not a blackout day can get
+                    // the focus.  In this case we should allow keyboard
+                    // functions on that inactive day
+                    if (DateTimeHelper.CompareYearMonth(LastSelectedDate.Value, DisplayDateInternal) != 0 && FocusButton != null && !FocusButton.IsInactive)
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            // Some keys (e.g. Left/Right) need to be translated in RightToLeft mode
+            Key invariantKey = e.Key;  //InteractionHelper.GetLogicalKey(FlowDirection, e.Key);
+
+            CalendarExtensions.GetMetaKeyState(e.Modifiers, out bool ctrl, out bool shift);
+
+            switch (invariantKey)
+            {
+                case Key.Up:
+                    {
+                        ProcessUpKey(ctrl, shift);
+                        return true;
+                    }
+                case Key.Down:
+                    {
+                        ProcessDownKey(ctrl, shift);
+                        return true;
+                    }
+                case Key.Left:
+                    {
+                        ProcessLeftKey(shift);
+                        return true;
+                    }
+                case Key.Right:
+                    {
+                        ProcessRightKey(shift);
+                        return true;
+                    }
+                case Key.PageDown:
+                    {
+                        ProcessPageDownKey(shift);
+                        return true;
+                    }
+                case Key.PageUp:
+                    {
+                        ProcessPageUpKey(shift);
+                        return true;
+                    }
+                case Key.Home:
+                    {
+                        ProcessHomeKey(shift);
+                        return true;
+                    }
+                case Key.End:
+                    {
+                        ProcessEndKey(shift);
+                        return true;
+                    }
+                case Key.Enter:
+                case Key.Space:
+                    {
+                        return ProcessEnterKey();
+                    }
+            }
+            return false;
+        }
+        internal void ProcessUpKey(bool ctrl, bool shift)
+        {
+            switch (DisplayMode)
+            {
+                case CalendarMode.Month:
+                    {
+                        if (ctrl)
+                        {
+                            SelectedMonth = DisplayDateInternal;
+                            DisplayMode = CalendarMode.Year;
+                        }
+                        else
+                        {
+                            DateTime? selectedDate = DateTimeHelper.AddDays(LastSelectedDate.GetValueOrDefault(DateTime.Today), -ColumnsPerMonth);
+                            ProcessSelection(shift, selectedDate, -ColumnsPerMonth);
+                        }
+                        break;
+                    }
+                case CalendarMode.Year:
+                    {
+                        if (ctrl)
+                        {
+                            SelectedYear = SelectedMonth;
+                            DisplayMode = CalendarMode.Decade;
+                        }
+                        else
+                        {
+                            DateTime? selectedMonth = DateTimeHelper.AddMonths(_selectedMonth, -ColumnsPerYear);
+                            OnSelectedMonthChanged(selectedMonth);
+                        }
+                        break;
+                    }
+                case CalendarMode.Decade:
+                    {
+                        if (!ctrl)
+                        {
+                            DateTime? selectedYear = DateTimeHelper.AddYears(SelectedYear, -ColumnsPerYear);
+                            OnSelectedYearChanged(selectedYear);
+                        }
+                        break;
+                    }
+            }
+        }
+        internal void ProcessDownKey(bool ctrl, bool shift)
+        {
+            switch (DisplayMode)
+            {
+                case CalendarMode.Month:
+                    {
+                        if (!ctrl || shift)
+                        {
+                            DateTime? selectedDate = DateTimeHelper.AddDays(LastSelectedDate.GetValueOrDefault(DateTime.Today), ColumnsPerMonth);
+                            ProcessSelection(shift, selectedDate, ColumnsPerMonth);
+                        }
+                        break;
+                    }
+                case CalendarMode.Year:
+                    {
+                        if (ctrl)
+                        {
+                            DisplayDate = SelectedMonth;
+                            DisplayMode = CalendarMode.Month;
+                        }
+                        else
+                        {
+                            DateTime? selectedMonth = DateTimeHelper.AddMonths(_selectedMonth, ColumnsPerYear);
+                            OnSelectedMonthChanged(selectedMonth);
+                        }
+                        break;
+                    }
+                case CalendarMode.Decade:
+                    {
+                        if (ctrl)
+                        {
+                            SelectedMonth = SelectedYear;
+                            DisplayMode = CalendarMode.Year;
+                        }
+                        else
+                        {
+                            DateTime? selectedYear = DateTimeHelper.AddYears(SelectedYear, ColumnsPerYear);
+                            OnSelectedYearChanged(selectedYear);
+                        }
+                        break;
+                    }
+            }
+        }
+        internal void ProcessLeftKey(bool shift)
+        {
+            switch (DisplayMode)
+            {
+                case CalendarMode.Month:
+                    {
+                        DateTime? selectedDate = DateTimeHelper.AddDays(LastSelectedDate.GetValueOrDefault(DateTime.Today), -1);
+                        ProcessSelection(shift, selectedDate, -1);
+                        break;
+                    }
+                case CalendarMode.Year:
+                    {
+                        DateTime? selectedMonth = DateTimeHelper.AddMonths(_selectedMonth, -1);
+                        OnSelectedMonthChanged(selectedMonth);
+                        break;
+                    }
+                case CalendarMode.Decade:
+                    {
+                        DateTime? selectedYear = DateTimeHelper.AddYears(SelectedYear, -1);
+                        OnSelectedYearChanged(selectedYear);
+                        break;
+                    }
+            }
+        }
+        internal void ProcessRightKey(bool shift)
+        {
+            switch (DisplayMode)
+            {
+                case CalendarMode.Month:
+                    {
+                        DateTime? selectedDate = DateTimeHelper.AddDays(LastSelectedDate.GetValueOrDefault(DateTime.Today), 1);
+                        ProcessSelection(shift, selectedDate, 1);
+                        break;
+                    }
+                case CalendarMode.Year:
+                    {
+                        DateTime? selectedMonth = DateTimeHelper.AddMonths(_selectedMonth, 1);
+                        OnSelectedMonthChanged(selectedMonth);
+                        break;
+                    }
+                case CalendarMode.Decade:
+                    {
+                        DateTime? selectedYear = DateTimeHelper.AddYears(SelectedYear, 1);
+                        OnSelectedYearChanged(selectedYear);
+                        break;
+                    }
+            }
+        }
+        private bool ProcessEnterKey()
+        {
+            switch (DisplayMode)
+            {
+                case CalendarMode.Year:
+                    {
+                        DisplayDate = SelectedMonth;
+                        DisplayMode = CalendarMode.Month;
+                        return true;
+                    }
+                case CalendarMode.Decade:
+                    {
+                        SelectedMonth = SelectedYear;
+                        DisplayMode = CalendarMode.Year;
+                        return true;
+                    }
+            }
+            return false;
+        }
+        internal void ProcessHomeKey(bool shift)
+        {
+            switch (DisplayMode)
+            {
+                case CalendarMode.Month:
+                    {
+                        // REMOVE_RTM: Not all types of calendars start with Day1. If Non-Gregorian is supported check this:
+                        DateTime? selectedDate = new DateTime(DisplayDateInternal.Year, DisplayDateInternal.Month, 1);
+                        ProcessSelection(shift, selectedDate, null);
+                        break;
+                    }
+                case CalendarMode.Year:
+                    {
+                        DateTime selectedMonth = new DateTime(_selectedMonth.Year, 1, 1);
+                        OnSelectedMonthChanged(selectedMonth);
+                        break;
+                    }
+                case CalendarMode.Decade:
+                    {
+                        DateTime? selectedYear = new DateTime(DateTimeHelper.DecadeOfDate(SelectedYear), 1, 1);
+                        OnSelectedYearChanged(selectedYear);
+                        break;
+                    }
+            }
+        }
+        internal void ProcessEndKey(bool shift)
+        {
+            switch (DisplayMode)
+            {
+                case CalendarMode.Month:
+                    {
+                        if (DisplayDate != null)
+                        {
+                            DateTime? selectedDate = new DateTime(DisplayDateInternal.Year, DisplayDateInternal.Month, 1);
+
+                            if (DateTimeHelper.CompareYearMonth(DateTime.MaxValue, selectedDate.Value) > 0)
+                            {
+                                // since DisplayDate is not equal to
+                                // DateTime.MaxValue we are sure selectedDate is\
+                                // not null
+                                selectedDate = DateTimeHelper.AddMonths(selectedDate.Value, 1).Value;
+                                selectedDate = DateTimeHelper.AddDays(selectedDate.Value, -1).Value;
+                            }
+                            else
+                            {
+                                selectedDate = DateTime.MaxValue;
+                            }
+                            ProcessSelection(shift, selectedDate, null);
+                        }
+                        break;
+                    }
+                case CalendarMode.Year:
+                    {
+                        DateTime selectedMonth = new DateTime(_selectedMonth.Year, 12, 1);
+                        OnSelectedMonthChanged(selectedMonth);
+                        break;
+                    }
+                case CalendarMode.Decade:
+                    {
+                        DateTime? selectedYear = new DateTime(DateTimeHelper.EndOfDecade(SelectedYear), 1, 1);
+                        OnSelectedYearChanged(selectedYear);
+                        break;
+                    }
+            }
+        }
+        internal void ProcessPageDownKey(bool shift)
+        {
+            switch (DisplayMode)
+            {
+                case CalendarMode.Month:
+                    {
+                        DateTime? selectedDate = DateTimeHelper.AddMonths(LastSelectedDate.GetValueOrDefault(DateTime.Today), 1);
+                        ProcessSelection(shift, selectedDate, null);
+                        break;
+                    }
+                case CalendarMode.Year:
+                    {
+                        DateTime? selectedMonth = DateTimeHelper.AddYears(_selectedMonth, 1);
+                        OnSelectedMonthChanged(selectedMonth);
+                        break;
+                    }
+                case CalendarMode.Decade:
+                    {
+                        DateTime? selectedYear = DateTimeHelper.AddYears(SelectedYear, 10);
+                        OnSelectedYearChanged(selectedYear);
+                        break;
+                    }
+            }
+        }
+        internal void ProcessPageUpKey(bool shift)
+        {
+            switch (DisplayMode)
+            {
+                case CalendarMode.Month:
+                    {
+                        DateTime? selectedDate = DateTimeHelper.AddMonths(LastSelectedDate.GetValueOrDefault(DateTime.Today), -1);
+                        ProcessSelection(shift, selectedDate, null);
+                        break;
+                    }
+                case CalendarMode.Year:
+                    {
+                        DateTime? selectedMonth = DateTimeHelper.AddYears(_selectedMonth, -1);
+                        OnSelectedMonthChanged(selectedMonth);
+                        break;
+                    }
+                case CalendarMode.Decade:
+                    {
+                        DateTime? selectedYear = DateTimeHelper.AddYears(SelectedYear, -10);
+                        OnSelectedYearChanged(selectedYear);
+                        break;
+                    }
+            }
+        }
+        private void Calendar_KeyUp(object sender, KeyEventArgs e)
+        {
+            if (!e.Handled && (e.Key == Key.LeftShift || e.Key == Key.RightShift))
+            {
+                ProcessShiftKeyUp();
+            }
+        }
+        internal void ProcessShiftKeyUp()
+        {
+            if (_isShiftPressed && (SelectionMode == CalendarSelectionMode.SingleRange || SelectionMode == CalendarSelectionMode.MultipleRange))
+            {
+                AddSelection();
+                _isShiftPressed = false;
+            }
+        }
+
+        protected override void OnGotFocus(GotFocusEventArgs e)
+        {
+            base.OnGotFocus(e);
+            HasFocusInternal = true;
+
+            switch (DisplayMode)
+            {
+                case CalendarMode.Month:
+                    {
+                        DateTime focusDate;
+                        if (LastSelectedDate.HasValue && DateTimeHelper.CompareYearMonth(DisplayDateInternal, LastSelectedDate.Value) == 0)
+                        {
+                            focusDate = LastSelectedDate.Value;
+                        }
+                        else
+                        {
+                            focusDate = DisplayDate;
+                            LastSelectedDate = DisplayDate;
+                        }
+                        Debug.Assert(focusDate != null, "focusDate should not be null!");
+                        FocusButton = FindDayButtonFromDay(focusDate);
+
+                        if (FocusButton != null)
+                        {
+                            FocusButton.IsCurrent = true;
+                        }
+                        break;
+                    }
+                case CalendarMode.Year:
+                case CalendarMode.Decade:
+                    {
+                        if (this.FocusCalendarButton != null)
+                        {
+                            FocusCalendarButton.IsCalendarButtonFocused = true;
+                        }
+                        break;
+                    }
+            }
+        }
+        protected override void OnLostFocus(RoutedEventArgs e)
+        {
+            base.OnLostFocus(e);
+            HasFocusInternal = false;
+
+            switch (DisplayMode)
+            {
+                case CalendarMode.Month:
+                    {
+                        if (FocusButton != null)
+                        {
+                            FocusButton.IsCurrent = false;
+                        }
+                        break;
+                    }
+                case CalendarMode.Year:
+                case CalendarMode.Decade:
+                    {
+                        if (FocusCalendarButton != null)
+                        {
+                            FocusCalendarButton.IsCalendarButtonFocused = false;
+                        }
+                        break;
+                    }
+            }
+        }
+        /// <summary>
+        ///  Called when the IsEnabled property changes.
+        /// </summary>
+        /// <param name="e">Property changed args.</param>
+        private void OnIsEnabledChanged(AvaloniaPropertyChangedEventArgs e)
+        {
+            Debug.Assert(e.NewValue is bool, "NewValue should be a boolean!");
+            bool isEnabled = (bool)e.NewValue;
+
+            if (MonthControl != null)
+            {
+                MonthControl.UpdateDisabled(isEnabled);
+            }
+        }
+
+        static Calendar()
+        {
+            IsEnabledProperty.Changed.AddClassHandler<Calendar>(x => x.OnIsEnabledChanged);
+            FirstDayOfWeekProperty.Changed.AddClassHandler<Calendar>(x => x.OnFirstDayOfWeekChanged);
+            IsTodayHighlightedProperty.Changed.AddClassHandler<Calendar>(x => x.OnIsTodayHighlightedChanged);
+            DisplayModeProperty.Changed.AddClassHandler<Calendar>(x => x.OnDisplayModePropertyChanged);
+            SelectionModeProperty.Changed.AddClassHandler<Calendar>(x => x.OnSelectionModeChanged);
+            SelectedDateProperty.Changed.AddClassHandler<Calendar>(x => x.OnSelectedDateChanged);
+            DisplayDateProperty.Changed.AddClassHandler<Calendar>(x => x.OnDisplayDateChanged);
+            DisplayDateStartProperty.Changed.AddClassHandler<Calendar>(x => x.OnDisplayDateStartChanged);
+            DisplayDateEndProperty.Changed.AddClassHandler<Calendar>(x => x.OnDisplayDateEndChanged);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the
+        /// <see cref="T:System.Windows.Controls.Calendar" /> class.
+        /// </summary>
+        public Calendar()
+        {
+            UpdateDisplayDate(this, this.DisplayDate, DateTime.MinValue);
+            BlackoutDates = new CalendarBlackoutDatesCollection(this);
+            SelectedDates = new SelectedDatesCollection(this);
+            RemovedItems = new Collection<DateTime>();
+        }
+
+        private const string PART_ElementRoot = "Root";
+        private const string PART_ElementMonth = "CalendarItem";
+        /// <summary>
+        /// Builds the visual tree for the
+        /// <see cref="T:System.Windows.Controls.Calendar" /> when a new
+        /// template is applied.
+        /// </summary>
+        protected override void OnTemplateApplied(TemplateAppliedEventArgs e)
+        {
+            base.OnTemplateApplied(e);
+
+            Root = e.NameScope.Find<Panel>(PART_ElementRoot);
+
+            SelectedMonth = DisplayDate;
+            SelectedYear = DisplayDate;
+
+            if (Root != null)
+            {
+                CalendarItem month = e.NameScope.Find<CalendarItem>(PART_ElementMonth);
+
+                if (month != null)
+                {
+                    month.Owner = this;
+                }
+            }
+
+            LayoutUpdated += Calendar_SizeChanged;
+            KeyDown += Calendar_KeyDown;
+            KeyUp += Calendar_KeyUp;
+        }
+
+    }
+}
diff --git a/src/Avalonia.Controls/Calendar/CalendarBlackoutDatesCollection.cs b/src/Avalonia.Controls/Calendar/CalendarBlackoutDatesCollection.cs
new file mode 100644
index 0000000000..0d48418683
--- /dev/null
+++ b/src/Avalonia.Controls/Calendar/CalendarBlackoutDatesCollection.cs
@@ -0,0 +1,215 @@
+// (c) Copyright Microsoft Corporation.
+// This source is subject to the Microsoft Public License (Ms-PL).
+// Please see http://go.microsoft.com/fwlink/?LinkID=131993 for details.
+// All other rights reserved.
+
+using Avalonia.Threading;
+using System;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading;
+
+namespace Avalonia.Controls.Primitives
+{
+    public sealed class CalendarBlackoutDatesCollection : ObservableCollection<CalendarDateRange>
+    {
+        /// <summary>
+        /// The Calendar whose dates this object represents.
+        /// </summary>
+        private Calendar _owner;
+        
+        /// <summary>
+        /// Initializes a new instance of the
+        /// <see cref="T:Avalonia.Controls.Primitives.CalendarBlackoutDatesCollection" />
+        /// class.
+        /// </summary>
+        /// <param name="owner">
+        /// The <see cref="T:Avalonia.Controls.Calendar" /> whose dates
+        /// this object represents.
+        /// </param>
+        public CalendarBlackoutDatesCollection(Calendar owner)
+        {
+            _owner = owner ?? throw new ArgumentNullException(nameof(owner));
+        }
+
+        /// <summary>
+        /// Adds all dates before <see cref="P:System.DateTime.Today" /> to the
+        /// collection.
+        /// </summary>
+        public void AddDatesInPast()
+        {
+            Add(new CalendarDateRange(DateTime.MinValue, DateTime.Today.AddDays(-1)));
+        }
+
+        /// <summary>
+        /// Returns a value that represents whether this collection contains the
+        /// specified date.
+        /// </summary>
+        /// <param name="date">The date to search for.</param>
+        /// <returns>
+        /// True if the collection contains the specified date; otherwise,
+        /// false.
+        /// </returns>
+        public bool Contains(DateTime date)
+        {
+            int count = Count;
+            for (int i = 0; i < count; i++)
+            {
+                if (DateTimeHelper.InRange(date, this[i]))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Returns a value that represents whether this collection contains the
+        /// specified range of dates.
+        /// </summary>
+        /// <param name="start">The start of the date range.</param>
+        /// <param name="end">The end of the date range.</param>
+        /// <returns>
+        /// True if all dates in the range are contained in the collection;
+        /// otherwise, false.
+        /// </returns>
+        public bool Contains(DateTime start, DateTime end)
+        {
+            DateTime rangeStart;
+            DateTime rangeEnd;
+
+            if (DateTime.Compare(end, start) > -1)
+            {
+                rangeStart = DateTimeHelper.DiscardTime(start).Value;
+                rangeEnd = DateTimeHelper.DiscardTime(end).Value;
+            }
+            else
+            {
+                rangeStart = DateTimeHelper.DiscardTime(end).Value;
+                rangeEnd = DateTimeHelper.DiscardTime(start).Value;
+            }
+
+            int count = Count;
+            for (int i = 0; i < count; i++)
+            {
+                CalendarDateRange range = this[i];
+                if (DateTime.Compare(range.Start, rangeStart) == 0 && DateTime.Compare(range.End, rangeEnd) == 0)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Returns a value that represents whether this collection contains any
+        /// date in the specified range.
+        /// </summary>
+        /// <param name="range">The range of dates to search for.</param>
+        /// <returns>
+        /// True if any date in the range is contained in the collection;
+        /// otherwise, false.
+        /// </returns>
+        public bool ContainsAny(CalendarDateRange range)
+        {
+            return this.Any(r => r.ContainsAny(range));
+        }
+
+        /// <summary>
+        /// Removes all items from the collection.
+        /// </summary>
+        /// <remarks>
+        /// This implementation raises the CollectionChanged event.
+        /// </remarks>
+        protected override void ClearItems()
+        {
+            EnsureValidThread();
+
+            base.ClearItems();
+            _owner.UpdateMonths();
+        }
+
+        /// <summary>
+        /// Inserts an item into the collection at the specified index.
+        /// </summary>
+        /// <param name="index">
+        /// The zero-based index at which item should be inserted.
+        /// </param>
+        /// <param name="item">The object to insert.</param>
+        /// <remarks>
+        /// This implementation raises the CollectionChanged event.
+        /// </remarks>
+        protected override void InsertItem(int index, CalendarDateRange item)
+        {
+            EnsureValidThread();
+
+            if (!IsValid(item))
+            {
+                throw new ArgumentOutOfRangeException("Value is not valid.");
+            }
+
+            base.InsertItem(index, item);
+            _owner.UpdateMonths();
+        }
+
+        /// <summary>
+        /// Removes the item at the specified index of the collection.
+        /// </summary>
+        /// <param name="index">
+        /// The zero-based index of the element to remove.
+        /// </param>
+        /// <remarks>
+        /// This implementation raises the CollectionChanged event.
+        /// </remarks>
+        protected override void RemoveItem(int index)
+        {
+            EnsureValidThread();
+
+            base.RemoveItem(index);
+            _owner.UpdateMonths();
+        }
+
+        /// <summary>
+        /// Replaces the element at the specified index.
+        /// </summary>
+        /// <param name="index">
+        /// The zero-based index of the element to replace.
+        /// </param>
+        /// <param name="item">
+        /// The new value for the element at the specified index.
+        /// </param>
+        /// <remarks>
+        /// This implementation raises the CollectionChanged event.
+        /// </remarks>
+        protected override void SetItem(int index, CalendarDateRange item)
+        {
+            EnsureValidThread();
+
+            if (!IsValid(item))
+            {
+                throw new ArgumentOutOfRangeException("Value is not valid.");
+            }
+
+            base.SetItem(index, item);
+            _owner.UpdateMonths();
+        }
+        
+        private bool IsValid(CalendarDateRange item)
+        {
+            foreach (DateTime day in _owner.SelectedDates)
+            {
+                if (DateTimeHelper.InRange(day, item))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+        
+        private void EnsureValidThread()
+        {
+            Dispatcher.UIThread.VerifyAccess();
+        }
+    }
+}
diff --git a/src/Avalonia.Controls/Calendar/CalendarButton.cs b/src/Avalonia.Controls/Calendar/CalendarButton.cs
new file mode 100644
index 0000000000..224d9b782b
--- /dev/null
+++ b/src/Avalonia.Controls/Calendar/CalendarButton.cs
@@ -0,0 +1,193 @@
+// (c) Copyright Microsoft Corporation.
+// This source is subject to the Microsoft Public License (Ms-PL).
+// Please see http://go.microsoft.com/fwlink/?LinkID=131993 for details.
+// All other rights reserved.
+
+using Avalonia.Input;
+using System;
+
+namespace Avalonia.Controls.Primitives
+{
+    /// <summary>
+    /// Represents a button on a
+    /// <see cref="T:Avalonia.Controls.Calendar" />.
+    /// </summary>
+    public sealed class CalendarButton : Button
+    {
+        /// <summary>
+        /// A value indicating whether the button is focused.
+        /// </summary>
+        private bool _isCalendarButtonFocused;
+
+        /// <summary>
+        /// A value indicating whether the button is inactive.
+        /// </summary>
+        private bool _isInactive;
+
+        /// <summary>
+        /// A value indicating whether the button is selected.
+        /// </summary>
+        private bool _isSelected;
+
+        /// <summary>
+        /// Initializes a new instance of the
+        /// <see cref="T:Avalonia.Controls.Primitives.CalendarButton" />
+        /// class.
+        /// </summary>
+        public CalendarButton()
+            : base()
+        {
+            Content = DateTimeHelper.GetCurrentDateFormat().AbbreviatedMonthNames[0];
+        }
+
+        /// <summary>
+        /// Gets or sets the Calendar associated with this button.
+        /// </summary>
+        internal Calendar Owner { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the button is focused.
+        /// </summary>
+        internal bool IsCalendarButtonFocused
+        {
+            get { return _isCalendarButtonFocused; }
+            set
+            {
+                if (_isCalendarButtonFocused != value)
+                {
+                    _isCalendarButtonFocused = value;
+                    SetPseudoClasses();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the button is inactive.
+        /// </summary>
+        internal bool IsInactive
+        {
+            get { return _isInactive; }
+            set
+            {
+                if (_isInactive != value)
+                {
+                    _isInactive = value;
+                    SetPseudoClasses();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the button is selected.
+        /// </summary>
+        internal bool IsSelected
+        {
+            get { return _isSelected; }
+            set
+            {
+                if (_isSelected != value)
+                {
+                    _isSelected = value;
+                    SetPseudoClasses();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Builds the visual tree for the
+        /// <see cref="T:System.Windows.Controls.Primitives.CalendarButton" />
+        /// when a new template is applied.
+        /// </summary>
+        protected override void OnTemplateApplied(TemplateAppliedEventArgs e)
+        {
+            base.OnTemplateApplied(e);
+            SetPseudoClasses();
+        }
+        
+        /// <summary>
+        /// Sets PseudoClasses based on current state.
+        /// </summary>
+        private void SetPseudoClasses()
+        {
+            PseudoClasses.Set(":selected", IsSelected);
+            PseudoClasses.Set(":inactive", IsInactive);
+            PseudoClasses.Set(":btnfocused", IsCalendarButtonFocused && IsEnabled);
+        }
+
+        /// <summary>
+        /// Occurs when the left mouse button is pressed (or when the tip of the
+        /// stylus touches the tablet PC) while the mouse pointer is over a
+        /// UIElement.
+        /// </summary>
+        public event EventHandler<PointerPressedEventArgs> CalendarLeftMouseButtonDown;
+
+        /// <summary>
+        /// Occurs when the left mouse button is released (or the tip of the
+        /// stylus is removed from the tablet PC) while the mouse (or the
+        /// stylus) is over a UIElement (or while a UIElement holds mouse
+        /// capture).
+        /// </summary>
+        public event EventHandler<PointerReleasedEventArgs> CalendarLeftMouseButtonUp;
+
+        /// <summary>
+        /// Provides class handling for the MouseLeftButtonDown event that
+        /// occurs when the left mouse button is pressed while the mouse pointer
+        /// is over this control.
+        /// </summary>
+        /// <param name="e">The event data. </param>
+        /// <exception cref="System.ArgumentNullException">
+        /// e is a null reference (Nothing in Visual Basic).
+        /// </exception>
+        /// <remarks>
+        /// This method marks the MouseLeftButtonDown event as handled by
+        /// setting the MouseButtonEventArgs.Handled property of the event data
+        /// to true when the button is enabled and its ClickMode is not set to
+        /// Hover.  Since this method marks the MouseLeftButtonDown event as
+        /// handled in some situations, you should use the Click event instead
+        /// to detect a button click.
+        /// </remarks>
+        protected override void OnPointerPressed(PointerPressedEventArgs e)
+        {
+            base.OnPointerPressed(e);
+            if (e.MouseButton == MouseButton.Left)
+                CalendarLeftMouseButtonDown?.Invoke(this, e);
+        }
+
+        /// <summary>
+        /// Provides handling for the MouseLeftButtonUp event that occurs when
+        /// the left mouse button is released while the mouse pointer is over
+        /// this control. 
+        /// </summary>
+        /// <param name="e">The event data.</param>
+        /// <exception cref="System.ArgumentNullException">
+        /// e is a null reference (Nothing in Visual Basic).
+        /// </exception>
+        /// <remarks>
+        /// This method marks the MouseLeftButtonUp event as handled by setting
+        /// the MouseButtonEventArgs.Handled property of the event data to true
+        /// when the button is enabled and its ClickMode is not set to Hover.
+        /// Since this method marks the MouseLeftButtonUp event as handled in
+        /// some situations, you should use the Click event instead to detect a
+        /// button click.
+        /// </remarks>
+        protected override void OnPointerReleased(PointerReleasedEventArgs e)
+        {
+            base.OnPointerReleased(e);
+            if (e.MouseButton == MouseButton.Left)
+                CalendarLeftMouseButtonUp?.Invoke(this, e);
+        }
+        
+        /// <summary>
+        /// We need to simulate the MouseLeftButtonUp event for the
+        /// CalendarButton that stays in Pressed state after MouseCapture is
+        /// released since there is no actual MouseLeftButtonUp event for the
+        /// release.
+        /// </summary>
+        /// <param name="e">Event arguments.</param>
+        internal void SendMouseLeftButtonUp(PointerReleasedEventArgs e)
+        {
+            e.Handled = false;
+            base.OnPointerReleased(e);
+        }
+    }
+}
diff --git a/src/Avalonia.Controls/Calendar/CalendarDateRange.cs b/src/Avalonia.Controls/Calendar/CalendarDateRange.cs
new file mode 100644
index 0000000000..273cda8c5b
--- /dev/null
+++ b/src/Avalonia.Controls/Calendar/CalendarDateRange.cs
@@ -0,0 +1,79 @@
+// (c) Copyright Microsoft Corporation.
+// This source is subject to the Microsoft Public License (Ms-PL).
+// Please see http://go.microsoft.com/fwlink/?LinkID=131993 for details.
+// All other rights reserved.
+
+using System;
+using System.Diagnostics;
+
+namespace Avalonia.Controls
+{
+    public sealed class CalendarDateRange
+    {
+        /// <summary>
+        /// Gets the first date in the represented range.
+        /// </summary>
+        /// <value>The first date in the represented range.</value>
+        public DateTime Start { get; private set; }
+
+        /// <summary>
+        /// Gets the last date in the represented range.
+        /// </summary>
+        /// <value>The last date in the represented range.</value>
+        public DateTime End { get; private set; }
+
+        /// <summary>
+        /// Initializes a new instance of the
+        /// <see cref="T:System.Windows.Controls.CalendarDateRange" /> class
+        /// with a single date.
+        /// </summary>
+        /// <param name="day">The date to be represented by the range.</param>
+        public CalendarDateRange(DateTime day)
+        {
+            Start = day;
+            End = day;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the
+        /// <see cref="T:System.Windows.Controls.CalendarDateRange" /> class
+        /// with a range of dates.
+        /// </summary>
+        /// <param name="start">
+        /// The start of the range to be represented.
+        /// </param>
+        /// <param name="end">The end of the range to be represented.</param>
+        public CalendarDateRange(DateTime start, DateTime end)
+        {
+            if (DateTime.Compare(end, start) >= 0)
+            {
+                Start = start;
+                End = end;
+            }
+            else
+            {
+                // Always use the start for ranges on the same day
+                Start = start;
+                End = start;
+            }
+        }
+
+        /// <summary>
+        /// Returns true if any day in the given DateTime range is contained in
+        /// the current CalendarDateRange.
+        /// </summary>
+        /// <param name="range">Inherited code: Requires comment 1.</param>
+        /// <returns>Inherited code: Requires comment 2.</returns>
+        internal bool ContainsAny(CalendarDateRange range)
+        {
+            Debug.Assert(range != null, "range should not be null!");
+
+            int start = DateTime.Compare(Start, range.Start);
+
+            // Check if any part of the supplied range is contained by this
+            // range or if the supplied range completely covers this range.
+            return (start <= 0 && DateTime.Compare(End, range.Start) >= 0) ||
+                (start >= 0 && DateTime.Compare(Start, range.End) <= 0);
+        }
+    }
+}
diff --git a/src/Avalonia.Controls/Calendar/CalendarDayButton.cs b/src/Avalonia.Controls/Calendar/CalendarDayButton.cs
new file mode 100644
index 0000000000..f6d0fbba62
--- /dev/null
+++ b/src/Avalonia.Controls/Calendar/CalendarDayButton.cs
@@ -0,0 +1,253 @@
+// (c) Copyright Microsoft Corporation.
+// This source is subject to the Microsoft Public License (Ms-PL).
+// Please see http://go.microsoft.com/fwlink/?LinkID=131993 for details.
+// All other rights reserved.
+
+using Avalonia.Input;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Text;
+
+namespace Avalonia.Controls.Primitives
+{
+    public sealed class CalendarDayButton : Button
+    {
+        /// <summary>
+        /// Default content for the CalendarDayButton.
+        /// </summary>
+        private const int DefaultContent = 1;
+
+        private bool _isCurrent;
+        private bool _ignoringMouseOverState;
+        private bool _isBlackout;
+        private bool _isToday;
+        private bool _isInactive;
+        private bool _isSelected;
+
+        /// <summary>
+        /// Initializes a new instance of the
+        /// <see cref="T:Avalonia.Controls.Primitives.CalendarDayButton" />
+        /// class.
+        /// </summary>
+        public CalendarDayButton()
+            : base()
+        {
+            //Focusable = false;
+            Content = DefaultContent.ToString(CultureInfo.CurrentCulture);
+        }
+
+        /// <summary>
+        /// Gets or sets the Calendar associated with this button.
+        /// </summary>
+        internal Calendar Owner { get; set; }
+        internal int Index { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the button is the focused
+        /// element on the Calendar control.
+        /// </summary>
+        internal bool IsCurrent
+        {
+            get { return _isCurrent; }
+            set
+            {
+                if (_isCurrent != value)
+                {
+                    _isCurrent = value;
+                    SetPseudoClasses();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Ensure the button is not in the MouseOver state.
+        /// </summary>
+        /// <remarks>
+        /// If a button is in the MouseOver state when a Popup is closed (as is
+        /// the case when you select a date in the DatePicker control), it will
+        /// continue to think it's in the mouse over state even when the Popup
+        /// opens again and it's not.  This method is used to forcibly clear the
+        /// state by changing the CommonStates state group.
+        /// </remarks>
+        internal void IgnoreMouseOverState()
+        {
+            // TODO: Investigate whether this needs to be done by changing the
+            // state everytime we change any state, or if it can be done once
+            // to properly reset the control.
+
+            _ignoringMouseOverState = false;
+
+            // If the button thinks it's in the MouseOver state (which can
+            // happen when a Popup is closed before the button can change state)
+            // we will override the state so it shows up as normal.
+            if (IsPointerOver)
+            {
+                _ignoringMouseOverState = true;
+                SetPseudoClasses();
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether this is a blackout date.
+        /// </summary>
+        internal bool IsBlackout
+        {
+            get { return _isBlackout; }
+            set
+            {
+                if (_isBlackout != value)
+                {
+                    _isBlackout = value;
+                    SetPseudoClasses();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether this button represents
+        /// today.
+        /// </summary>
+        internal bool IsToday
+        {
+            get { return _isToday; }
+            set
+            {
+                if (_isToday != value)
+                {
+                    _isToday = value;
+                    SetPseudoClasses();
+                }
+            }
+        }
+        /// <summary>
+        /// Gets or sets a value indicating whether the button is inactive.
+        /// </summary>
+        internal bool IsInactive
+        {
+            get { return _isInactive; }
+            set
+            {
+                if (_isInactive != value)
+                {
+                    _isInactive = value;
+                    SetPseudoClasses();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the button is selected.
+        /// </summary>
+        internal bool IsSelected
+        {
+            get { return _isSelected; }
+            set
+            {
+                if (_isSelected != value)
+                {
+                    _isSelected = value;
+                    SetPseudoClasses();
+                }
+            }
+        }
+
+        protected override void OnTemplateApplied(TemplateAppliedEventArgs e)
+        {
+            base.OnTemplateApplied(e);
+            SetPseudoClasses();
+        }
+        private void SetPseudoClasses()
+        {
+            if (_ignoringMouseOverState)
+            {
+                PseudoClasses.Set(":pressed", IsPressed);
+                PseudoClasses.Set(":disabled", !IsEnabled);
+            }
+
+            PseudoClasses.Set(":selected", IsSelected);
+            PseudoClasses.Set(":inactive", IsInactive);
+            PseudoClasses.Set(":today", IsToday);
+            PseudoClasses.Set(":blackout", IsBlackout);
+            PseudoClasses.Set(":dayfocused", IsCurrent && IsEnabled);
+        }
+
+        /// <summary>
+        /// Occurs when the left mouse button is pressed (or when the tip of the
+        /// stylus touches the tablet PC) while the mouse pointer is over a
+        /// UIElement.
+        /// </summary>
+        public event EventHandler<PointerPressedEventArgs> CalendarDayButtonMouseDown;
+
+        /// <summary>
+        /// Occurs when the left mouse button is released (or the tip of the
+        /// stylus is removed from the tablet PC) while the mouse (or the
+        /// stylus) is over a UIElement (or while a UIElement holds mouse
+        /// capture).
+        /// </summary>
+        public event EventHandler<PointerReleasedEventArgs> CalendarDayButtonMouseUp;
+
+        /// <summary>
+        /// Provides class handling for the MouseLeftButtonDown event that
+        /// occurs when the left mouse button is pressed while the mouse pointer
+        /// is over this control.
+        /// </summary>
+        /// <param name="e">The event data. </param>
+        /// <exception cref="System.ArgumentNullException">
+        /// e is a null reference (Nothing in Visual Basic).
+        /// </exception>
+        /// <remarks>
+        /// This method marks the MouseLeftButtonDown event as handled by
+        /// setting the MouseButtonEventArgs.Handled property of the event data
+        /// to true when the button is enabled and its ClickMode is not set to
+        /// Hover.  Since this method marks the MouseLeftButtonDown event as
+        /// handled in some situations, you should use the Click event instead
+        /// to detect a button click.
+        /// </remarks>
+        protected override void OnPointerPressed(PointerPressedEventArgs e)
+        {
+            base.OnPointerPressed(e);
+
+            if (e.MouseButton == MouseButton.Left)
+                CalendarDayButtonMouseDown?.Invoke(this, e);
+        }
+
+        /// <summary>
+        /// Provides handling for the MouseLeftButtonUp event that occurs when
+        /// the left mouse button is released while the mouse pointer is over
+        /// this control. 
+        /// </summary>
+        /// <param name="e">The event data.</param>
+        /// <exception cref="System.ArgumentNullException">
+        /// e is a null reference (Nothing in Visual Basic).
+        /// </exception>
+        /// <remarks>
+        /// This method marks the MouseLeftButtonUp event as handled by setting
+        /// the MouseButtonEventArgs.Handled property of the event data to true
+        /// when the button is enabled and its ClickMode is not set to Hover.
+        /// Since this method marks the MouseLeftButtonUp event as handled in
+        /// some situations, you should use the Click event instead to detect a
+        /// button click.
+        /// </remarks>
+        protected override void OnPointerReleased(PointerReleasedEventArgs e)
+        {
+            base.OnPointerReleased(e);
+
+            if (e.MouseButton == MouseButton.Left)
+                CalendarDayButtonMouseUp?.Invoke(this, e);
+        }
+
+        /// <summary>
+        /// We need to simulate the MouseLeftButtonUp event for the
+        /// CalendarDayButton that stays in Pressed state after MouseCapture is
+        /// released since there is no actual MouseLeftButtonUp event for the
+        /// release.
+        /// </summary>
+        /// <param name="e">Event arguments.</param>
+        internal void SendMouseLeftButtonUp(PointerReleasedEventArgs e)
+        {
+            e.Handled = false;
+            base.OnPointerReleased(e);
+        }
+    }
+}
diff --git a/src/Avalonia.Controls/Calendar/CalendarExtensions.cs b/src/Avalonia.Controls/Calendar/CalendarExtensions.cs
new file mode 100644
index 0000000000..4fda02bff3
--- /dev/null
+++ b/src/Avalonia.Controls/Calendar/CalendarExtensions.cs
@@ -0,0 +1,21 @@
+// (c) Copyright Microsoft Corporation.
+// This source is subject to the Microsoft Public License (Ms-PL).
+// Please see http://go.microsoft.com/fwlink/?LinkID=131993 for details.
+// All other rights reserved.
+
+using System;
+using System.Collections.Generic;
+using Avalonia.Input;
+using System.Diagnostics;
+
+namespace Avalonia.Controls.Primitives
+{
+    internal static class CalendarExtensions
+    {
+        public static void GetMetaKeyState(InputModifiers modifiers, out bool ctrl, out bool shift)
+        {
+            ctrl = (modifiers & InputModifiers.Control) == InputModifiers.Control;
+            shift = (modifiers & InputModifiers.Shift) == InputModifiers.Shift;
+        }
+    }
+}
diff --git a/src/Avalonia.Controls/Calendar/CalendarItem.cs b/src/Avalonia.Controls/Calendar/CalendarItem.cs
new file mode 100644
index 0000000000..3432fa549d
--- /dev/null
+++ b/src/Avalonia.Controls/Calendar/CalendarItem.cs
@@ -0,0 +1,1264 @@
+// (c) Copyright Microsoft Corporation.
+// This source is subject to the Microsoft Public License (Ms-PL).
+// Please see http://go.microsoft.com/fwlink/?LinkID=131993 for details.
+// All other rights reserved.
+
+using Avalonia.Data;
+using Avalonia.Input;
+using Avalonia.Interactivity;
+using Avalonia.Media;
+using System;
+using System.Diagnostics;
+using System.Globalization;
+
+namespace Avalonia.Controls.Primitives
+{
+    /// <summary>
+    /// Represents the currently displayed month or year on a
+    /// <see cref="T:Avalonia.Controls.Calendar" />.
+    /// </summary>
+    public sealed class CalendarItem : TemplatedControl
+    {
+        /// <summary>
+        /// The number of days per week.
+        /// </summary>
+        private const int NumberOfDaysPerWeek = 7;
+
+        private const string PART_ElementHeaderButton = "HeaderButton";
+        private const string PART_ElementPreviousButton = "PreviousButton";
+        private const string PART_ElementNextButton = "NextButton";
+        private const string PART_ElementMonthView = "MonthView";
+        private const string PART_ElementYearView = "YearView";
+
+        private Button _headerButton;
+        private Button _nextButton;
+        private Button _previousButton;
+        private Grid _monthView;
+        private Grid _yearView;
+        private ITemplate<IControl> _dayTitleTemplate;
+        private CalendarButton _lastCalendarButton;
+        private CalendarDayButton _lastCalendarDayButton;
+        
+        private DateTime _currentMonth;
+        private bool _isMouseLeftButtonDown = false;
+        private bool _isMouseLeftButtonDownYearView = false;
+        private bool _isControlPressed = false;
+
+        private System.Globalization.Calendar _calendar = new System.Globalization.GregorianCalendar();
+
+        private PointerPressedEventArgs _downEventArg;
+        private PointerPressedEventArgs _downEventArgYearView;
+
+        internal Calendar Owner { get; set; }
+        internal CalendarDayButton CurrentButton { get; set; }
+
+        public static StyledProperty<IBrush> HeaderBackgroundProperty = Calendar.HeaderBackgroundProperty.AddOwner<CalendarItem>();
+        public IBrush HeaderBackground
+        {
+            get { return GetValue(HeaderBackgroundProperty); }
+            set { SetValue(HeaderBackgroundProperty, value); }
+        }
+        public static readonly DirectProperty<CalendarItem, ITemplate<IControl>> DayTitleTemplateProperty =
+                AvaloniaProperty.RegisterDirect<CalendarItem, ITemplate<IControl>>(
+                    nameof(DayTitleTemplate),
+                    o => o.DayTitleTemplate,
+                    (o,v) => o.DayTitleTemplate = v,
+                    defaultBindingMode: BindingMode.OneTime);
+        public ITemplate<IControl> DayTitleTemplate
+        {
+            get { return _dayTitleTemplate; }
+            set { SetAndRaise(DayTitleTemplateProperty, ref _dayTitleTemplate, value); }
+        }
+
+        /// <summary>
+        /// Gets the button that allows switching between month mode, year mode,
+        /// and decade mode. 
+        /// </summary>
+        internal Button HeaderButton
+        {
+            get { return _headerButton; }
+            private set
+            {
+                if (_headerButton != null)
+                    _headerButton.Click -= HeaderButton_Click;
+
+                _headerButton = value;
+
+                if (_headerButton != null)
+                {
+                    _headerButton.Click += HeaderButton_Click;
+                    _headerButton.Focusable = false;
+                }
+            }
+        }
+        /// <summary>
+        /// Gets the button that displays the next page of the calendar when it
+        /// is clicked.
+        /// </summary>
+        internal Button NextButton
+        {
+            get { return _nextButton; }
+            private set
+            {
+                if (_nextButton != null)
+                    _nextButton.Click -= NextButton_Click;
+
+                _nextButton = value;
+
+                if (_nextButton != null)
+                {
+                    // If the user does not provide a Content value in template,
+                    // we provide a helper text that can be used in
+                    // Accessibility this text is not shown on the UI, just used
+                    // for Accessibility purposes
+                    if (_nextButton.Content == null)
+                    {
+                        _nextButton.Content = "next button";
+                    }
+
+                    _nextButton.IsVisible = true;
+                    _nextButton.Click += NextButton_Click;
+                    _nextButton.Focusable = false;
+                }
+            }
+        }
+        /// <summary>
+        /// Gets the button that displays the previous page of the calendar when
+        /// it is clicked.
+        /// </summary>
+        internal Button PreviousButton
+        {
+            get { return _previousButton; }
+            private set
+            {
+                if (_previousButton != null)
+                    _previousButton.Click -= PreviousButton_Click;
+
+                _previousButton = value;
+
+                if (_previousButton != null)
+                {
+                    // If the user does not provide a Content value in template,
+                    // we provide a helper text that can be used in
+                    // Accessibility this text is not shown on the UI, just used
+                    // for Accessibility purposes
+                    if (_previousButton.Content == null)
+                    {
+                        _previousButton.Content = "previous button";
+                    }
+
+                    _previousButton.IsVisible = true;
+                    _previousButton.Click += PreviousButton_Click;
+                    _previousButton.Focusable = false;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the Grid that hosts the content when in month mode.
+        /// </summary>
+        internal Grid MonthView
+        {
+            get { return _monthView; }
+            private set
+            {
+                if (_monthView != null)
+                    _monthView.PointerLeave -= MonthView_MouseLeave;
+
+                _monthView = value;
+
+                if (_monthView != null)
+                    _monthView.PointerLeave += MonthView_MouseLeave;
+            }
+        }
+        /// <summary>
+        /// Gets the Grid that hosts the content when in year or decade mode.
+        /// </summary>
+        internal Grid YearView
+        {
+            get { return _yearView; }
+            private set
+            {
+                if (_yearView != null)
+                    _yearView.PointerLeave -= YearView_MouseLeave;
+
+                _yearView = value;
+
+                if (_yearView != null)
+                    _yearView.PointerLeave += YearView_MouseLeave;
+            }
+        }
+
+        private void PopulateGrids()
+        {
+            if (MonthView != null)
+            {
+                for (int i = 0; i < Calendar.RowsPerMonth; i++)
+                {
+                    if (_dayTitleTemplate != null)
+                    {
+                        var cell = _dayTitleTemplate.Build();
+                        cell.DataContext = string.Empty;
+                        cell.SetValue(Grid.RowProperty, 0);
+                        cell.SetValue(Grid.ColumnProperty, i);
+                        MonthView.Children.Add(cell);
+                    }
+                }
+
+                for (int i = 1; i < Calendar.RowsPerMonth; i++)
+                {
+                    for (int j = 0; j < Calendar.ColumnsPerMonth; j++)
+                    {
+                        CalendarDayButton cell = new CalendarDayButton();
+
+                        if (Owner != null)
+                        {
+                            cell.Owner = Owner;
+                        }
+                        cell.SetValue(Grid.RowProperty, i);
+                        cell.SetValue(Grid.ColumnProperty, j);
+                        cell.CalendarDayButtonMouseDown += Cell_MouseLeftButtonDown;
+                        cell.CalendarDayButtonMouseUp += Cell_MouseLeftButtonUp;
+                        cell.PointerEnter += Cell_MouseEnter;
+                        cell.PointerLeave += Cell_MouseLeave;
+                        cell.Click += Cell_Click;
+                        MonthView.Children.Add(cell);
+                    }
+                }
+            }
+
+            if (YearView != null)
+            {
+                CalendarButton month;
+                for (int i = 0; i < Calendar.RowsPerYear; i++)
+                {
+                    for (int j = 0; j < Calendar.ColumnsPerYear; j++)
+                    {
+                        month = new CalendarButton();
+
+                        if (Owner != null)
+                        {
+                            month.Owner = Owner;
+                        }
+                        month.SetValue(Grid.RowProperty, i);
+                        month.SetValue(Grid.ColumnProperty, j);
+                        month.CalendarLeftMouseButtonDown += Month_CalendarButtonMouseDown;
+                        month.CalendarLeftMouseButtonUp += Month_CalendarButtonMouseUp;
+                        month.PointerEnter += Month_MouseEnter;
+                        month.PointerLeave += Month_MouseLeave;
+                        YearView.Children.Add(month);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Builds the visual tree for the
+        /// <see cref="T:System.Windows.Controls.Primitives.CalendarItem" />
+        /// when a new template is applied.
+        /// </summary>
+        protected override void OnTemplateApplied(TemplateAppliedEventArgs e)
+        {
+            base.OnTemplateApplied(e);
+            
+            HeaderButton = e.NameScope.Find<Button>(PART_ElementHeaderButton);
+            PreviousButton = e.NameScope.Find<Button>(PART_ElementPreviousButton);
+            NextButton = e.NameScope.Find<Button>(PART_ElementNextButton);
+            MonthView = e.NameScope.Find<Grid>(PART_ElementMonthView);
+            YearView = e.NameScope.Find<Grid>(PART_ElementYearView);
+            
+            if (Owner != null)
+            {
+                UpdateDisabled(Owner.IsEnabled);
+            }
+
+            PopulateGrids();
+
+            if (MonthView != null && YearView != null)
+            {
+                if (Owner != null)
+                {
+                    Owner.SelectedMonth = Owner.DisplayDateInternal;
+                    Owner.SelectedYear = Owner.DisplayDateInternal;
+
+                    if (Owner.DisplayMode == CalendarMode.Year)
+                    {
+                        UpdateYearMode();
+                    }
+                    else if (Owner.DisplayMode == CalendarMode.Decade)
+                    {
+                        UpdateDecadeMode();
+                    }
+
+                    if (Owner.DisplayMode == CalendarMode.Month)
+                    {
+                        UpdateMonthMode();
+                        MonthView.IsVisible = true;
+                        YearView.IsVisible = false;
+                    }
+                    else
+                    {
+                        YearView.IsVisible = true;
+                        MonthView.IsVisible = false;
+                    }
+                }
+                else
+                {
+                    UpdateMonthMode();
+                    MonthView.IsVisible = true;
+                    YearView.IsVisible = false;
+                }
+            }
+        }
+
+        private void SetDayTitles()
+        {
+            for (int childIndex = 0; childIndex < Calendar.ColumnsPerMonth; childIndex++)
+            {
+                var daytitle = MonthView.Children[childIndex];
+                if (daytitle != null)
+                {
+                    if (Owner != null)
+                    {
+                        daytitle.DataContext = DateTimeHelper.GetCurrentDateFormat().ShortestDayNames[(childIndex + (int)Owner.FirstDayOfWeek) % NumberOfDaysPerWeek];
+                    }
+                    else
+                    {
+                        daytitle.DataContext = DateTimeHelper.GetCurrentDateFormat().ShortestDayNames[(childIndex + (int)DateTimeHelper.GetCurrentDateFormat().FirstDayOfWeek) % NumberOfDaysPerWeek];
+                    }
+                }
+            }
+        }
+        /// <summary>
+        /// How many days of the previous month need to be displayed.
+        /// </summary>
+        private int PreviousMonthDays(DateTime firstOfMonth)
+        {
+            DayOfWeek day = _calendar.GetDayOfWeek(firstOfMonth);
+            int i;
+
+            if (Owner != null)
+            {
+                i = ((day - Owner.FirstDayOfWeek + NumberOfDaysPerWeek) % NumberOfDaysPerWeek);
+            }
+            else
+            {
+                i = ((day - DateTimeHelper.GetCurrentDateFormat().FirstDayOfWeek + NumberOfDaysPerWeek) % NumberOfDaysPerWeek);
+            }
+
+            if (i == 0)
+            {
+                return NumberOfDaysPerWeek;
+            }
+            else
+            {
+                return i;
+            }
+        }
+
+        internal void UpdateMonthMode()
+        {
+            if (Owner != null)
+            {
+                Debug.Assert(Owner.DisplayDate != null, "The Owner Calendar's DisplayDate should not be null!");
+                _currentMonth = Owner.DisplayDateInternal;
+            }
+            else
+            {
+                _currentMonth = DateTime.Today;
+            }
+
+            if (_currentMonth != null)
+            {
+                SetMonthModeHeaderButton();
+                SetMonthModePreviousButton(_currentMonth);
+                SetMonthModeNextButton(_currentMonth);
+
+                if (MonthView != null)
+                {
+                    SetDayTitles();
+                    SetCalendarDayButtons(_currentMonth);
+                }
+            }
+        }
+        private void SetMonthModeHeaderButton()
+        {
+            if (HeaderButton != null)
+            {
+                if (Owner != null)
+                {
+                    HeaderButton.Content = Owner.DisplayDateInternal.ToString("Y", DateTimeHelper.GetCurrentDateFormat());
+                    HeaderButton.IsEnabled = true;
+                }
+                else
+                {
+                    HeaderButton.Content = DateTime.Today.ToString("Y", DateTimeHelper.GetCurrentDateFormat());
+                }
+            }
+        }
+        private void SetMonthModeNextButton(DateTime firstDayOfMonth)
+        {
+            if (Owner != null && NextButton != null)
+            {
+                // DisplayDate is equal to DateTime.MaxValue
+                if (DateTimeHelper.CompareYearMonth(firstDayOfMonth, DateTime.MaxValue) == 0)
+                {
+                    NextButton.IsEnabled = false;
+                }
+                else
+                {
+                    // Since we are sure DisplayDate is not equal to
+                    // DateTime.MaxValue, it is safe to use AddMonths  
+                    DateTime firstDayOfNextMonth = _calendar.AddMonths(firstDayOfMonth, 1);
+                    NextButton.IsEnabled = (DateTimeHelper.CompareDays(Owner.DisplayDateRangeEnd, firstDayOfNextMonth) > -1);
+                }
+            }
+        }
+        private void SetMonthModePreviousButton(DateTime firstDayOfMonth)
+        {
+            if (Owner != null && PreviousButton != null)
+            {
+                PreviousButton.IsEnabled = (DateTimeHelper.CompareDays(Owner.DisplayDateRangeStart, firstDayOfMonth) < 0);
+            }
+        }
+
+        private void SetButtonState(CalendarDayButton childButton, DateTime dateToAdd)
+        {
+            if (Owner != null)
+            {
+                childButton.Opacity = 1;
+
+                // If the day is outside the DisplayDateStart/End boundary, do
+                // not show it
+                if (DateTimeHelper.CompareDays(dateToAdd, Owner.DisplayDateRangeStart) < 0 || DateTimeHelper.CompareDays(dateToAdd, Owner.DisplayDateRangeEnd) > 0)
+                {
+                    childButton.IsEnabled = false;
+                    childButton.IsToday = false;
+                    childButton.IsSelected = false;
+                    childButton.Opacity = 0;
+                }
+                else
+                {
+                    // SET IF THE DAY IS SELECTABLE OR NOT
+                    if (Owner.BlackoutDates.Contains(dateToAdd))
+                    {
+                        childButton.IsBlackout = true;
+                    }
+                    else
+                    {
+                        childButton.IsBlackout = false;
+                    }
+                    childButton.IsEnabled = true;
+
+                    // SET IF THE DAY IS INACTIVE OR NOT: set if the day is a
+                    // trailing day or not
+                    childButton.IsInactive = (DateTimeHelper.CompareYearMonth(dateToAdd, Owner.DisplayDateInternal) != 0);
+
+                    // SET IF THE DAY IS TODAY OR NOT
+                    childButton.IsToday = (Owner.IsTodayHighlighted && dateToAdd == DateTime.Today);
+
+                    // SET IF THE DAY IS SELECTED OR NOT
+                    childButton.IsSelected = false;
+                    foreach (DateTime item in Owner.SelectedDates)
+                    {
+                        // Since we should be comparing the Date values not
+                        // DateTime values, we can't use
+                        // Owner.SelectedDates.Contains(dateToAdd) directly
+                        childButton.IsSelected |= (DateTimeHelper.CompareDays(dateToAdd, item) == 0);
+                    }
+
+                    // SET THE FOCUS ELEMENT
+                    if (Owner.LastSelectedDate != null)
+                    {
+                        if (DateTimeHelper.CompareDays(Owner.LastSelectedDate.Value, dateToAdd) == 0)
+                        {
+                            if (Owner.FocusButton != null)
+                            {
+                                Owner.FocusButton.IsCurrent = false;
+                            }
+                            Owner.FocusButton = childButton;
+                            if (Owner.HasFocusInternal)
+                            {
+                                Owner.FocusButton.IsCurrent = true;
+                            }
+                        }
+                        else
+                        {
+                            childButton.IsCurrent = false;
+                        }
+                    }
+                }
+            }
+        }
+        private void SetCalendarDayButtons(DateTime firstDayOfMonth)
+        {
+            int lastMonthToDisplay = PreviousMonthDays(firstDayOfMonth);
+            DateTime dateToAdd;
+
+            if (DateTimeHelper.CompareYearMonth(firstDayOfMonth, DateTime.MinValue) > 0)
+            {
+                // DisplayDate is not equal to DateTime.MinValue we can subtract
+                // days from the DisplayDate
+                dateToAdd = _calendar.AddDays(firstDayOfMonth, -lastMonthToDisplay);
+            }
+            else
+            {
+                dateToAdd = firstDayOfMonth;
+            }
+
+            if (Owner != null && Owner.HoverEnd != null && Owner.HoverStart != null)
+            {
+                Owner.HoverEndIndex = null;
+                Owner.HoverStartIndex = null;
+            }
+
+            int count = Calendar.RowsPerMonth * Calendar.ColumnsPerMonth;
+
+            for (int childIndex = Calendar.ColumnsPerMonth; childIndex < count; childIndex++)
+            {
+                CalendarDayButton childButton = MonthView.Children[childIndex] as CalendarDayButton;
+                Debug.Assert(childButton != null, "childButton should not be null!");
+
+                childButton.Index = childIndex;
+                SetButtonState(childButton, dateToAdd);
+
+                // Update the indexes of hoverStart and hoverEnd
+                if (Owner != null && Owner.HoverEnd != null && Owner.HoverStart != null)
+                {
+                    if (DateTimeHelper.CompareDays(dateToAdd, Owner.HoverEnd.Value) == 0)
+                    {
+                        Owner.HoverEndIndex = childIndex;
+                    }
+
+                    if (DateTimeHelper.CompareDays(dateToAdd, Owner.HoverStart.Value) == 0)
+                    {
+                        Owner.HoverStartIndex = childIndex;
+                    }
+                }
+
+                //childButton.Focusable = false;
+                childButton.Content = dateToAdd.Day.ToString(DateTimeHelper.GetCurrentDateFormat());
+                childButton.DataContext = dateToAdd;
+
+                if (DateTime.Compare((DateTime)DateTimeHelper.DiscardTime(DateTime.MaxValue), dateToAdd) > 0)
+                {
+                    // Since we are sure DisplayDate is not equal to
+                    // DateTime.MaxValue, it is safe to use AddDays 
+                    dateToAdd = _calendar.AddDays(dateToAdd, 1);
+                }
+                else
+                {
+                    // DisplayDate is equal to the DateTime.MaxValue, so there
+                    // are no trailing days
+                    childIndex++;
+                    for (int i = childIndex; i < count; i++)
+                    {
+                        childButton = MonthView.Children[i] as CalendarDayButton;
+                        Debug.Assert(childButton != null, "childButton should not be null!");
+                        // button needs a content to occupy the necessary space
+                        // for the content presenter
+                        childButton.Content = i.ToString(DateTimeHelper.GetCurrentDateFormat());
+                        childButton.IsEnabled = false;
+                        childButton.Opacity = 0;
+                    }
+                    return;
+                }
+            }
+
+            // If the HoverStart or HoverEndInternal could not be found on the
+            // DisplayMonth set the values of the HoverStartIndex or
+            // HoverEndIndex to be the first or last day indexes on the current
+            // month
+            if (Owner != null && Owner.HoverStart.HasValue && Owner.HoverEndInternal.HasValue)
+            {
+                if (!Owner.HoverEndIndex.HasValue)
+                {
+                    if (DateTimeHelper.CompareDays(Owner.HoverEndInternal.Value, Owner.HoverStart.Value) > 0)
+                    {
+                        Owner.HoverEndIndex = Calendar.ColumnsPerMonth * Calendar.RowsPerMonth - 1;
+                    }
+                    else
+                    {
+                        Owner.HoverEndIndex = Calendar.ColumnsPerMonth;
+                    }
+                }
+
+                if (!Owner.HoverStartIndex.HasValue)
+                {
+                    if (DateTimeHelper.CompareDays(Owner.HoverEndInternal.Value, Owner.HoverStart.Value) > 0)
+                    {
+                        Owner.HoverStartIndex = Calendar.ColumnsPerMonth;
+                    }
+                    else
+                    {
+                        Owner.HoverStartIndex = Calendar.ColumnsPerMonth * Calendar.RowsPerMonth - 1;
+                    }
+                }
+            }
+        }
+
+        internal void UpdateYearMode()
+        {
+            if (Owner != null)
+            {
+                Debug.Assert(Owner.SelectedMonth != null, "The Owner Calendar's SelectedMonth should not be null!");
+                _currentMonth = (DateTime)Owner.SelectedMonth;
+            }
+            else
+            {
+                _currentMonth = DateTime.Today;
+            }
+
+            if (_currentMonth != null)
+            {
+                SetYearModeHeaderButton();
+                SetYearModePreviousButton();
+                SetYearModeNextButton();
+
+                if (YearView != null)
+                {
+                    SetMonthButtonsForYearMode();
+                }
+            }
+        }
+        private void SetYearModeHeaderButton()
+        {
+            if (HeaderButton != null)
+            {
+                HeaderButton.IsEnabled = true;
+                HeaderButton.Content = _currentMonth.Year.ToString(DateTimeHelper.GetCurrentDateFormat());
+            }
+        }
+        private void SetYearModePreviousButton()
+        {
+            if (Owner != null && PreviousButton != null)
+            {
+                PreviousButton.IsEnabled = (Owner.DisplayDateRangeStart.Year != _currentMonth.Year);
+            }
+        }
+        private void SetYearModeNextButton()
+        {
+            if (Owner != null && NextButton != null)
+            {
+                NextButton.IsEnabled = (Owner.DisplayDateRangeEnd.Year != _currentMonth.Year);
+            }
+        }
+
+        private void SetMonthButtonsForYearMode()
+        {
+            int count = 0;
+            foreach (object child in YearView.Children)
+            {
+                CalendarButton childButton = child as CalendarButton;
+                Debug.Assert(childButton != null, "childButton should not be null!");
+                // There should be no time component. Time is 12:00 AM
+                DateTime day = new DateTime(_currentMonth.Year, count + 1, 1);
+                childButton.DataContext = day;
+
+                childButton.Content = DateTimeHelper.GetCurrentDateFormat().AbbreviatedMonthNames[count];
+                childButton.IsVisible = true;
+
+                if (Owner != null)
+                {
+                    if (day.Year == _currentMonth.Year && day.Month == _currentMonth.Month && day.Day == _currentMonth.Day)
+                    {
+                        Owner.FocusCalendarButton = childButton;
+                        childButton.IsCalendarButtonFocused = Owner.HasFocusInternal;
+                    }
+                    else
+                    {
+                        childButton.IsCalendarButtonFocused = false;
+                    }
+
+                    Debug.Assert(Owner.DisplayDateInternal != null, "The Owner Calendar's DisplayDateInternal should not be null!");
+                    childButton.IsSelected = (DateTimeHelper.CompareYearMonth(day, Owner.DisplayDateInternal) == 0);
+
+                    if (DateTimeHelper.CompareYearMonth(day, Owner.DisplayDateRangeStart) < 0 || DateTimeHelper.CompareYearMonth(day, Owner.DisplayDateRangeEnd) > 0)
+                    {
+                        childButton.IsEnabled = false;
+                        childButton.Opacity = 0;
+                    }
+                    else
+                    {
+                        childButton.IsEnabled = true;
+                        childButton.Opacity = 1;
+                    }
+                }
+
+                childButton.IsInactive = false;
+                count++;
+            }
+        }
+        internal void UpdateDecadeMode()
+        {
+            DateTime selectedYear;
+
+            if (Owner != null)
+            {
+                Debug.Assert(Owner.SelectedYear != null, "The owning Calendar's selected year should not be null!");
+                selectedYear = Owner.SelectedYear;
+                _currentMonth = (DateTime)Owner.SelectedMonth;
+            }
+            else
+            {
+                _currentMonth = DateTime.Today;
+                selectedYear = DateTime.Today;
+            }
+
+            if (_currentMonth != null)
+            {
+                int decade = DateTimeHelper.DecadeOfDate(selectedYear);
+                int decadeEnd = DateTimeHelper.EndOfDecade(selectedYear);
+
+                SetDecadeModeHeaderButton(decade, decadeEnd);
+                SetDecadeModePreviousButton(decade);
+                SetDecadeModeNextButton(decadeEnd);
+
+                if (YearView != null)
+                {
+                    SetYearButtons(decade, decadeEnd);
+                }
+            }
+        }
+        internal void UpdateYearViewSelection(CalendarButton calendarButton)
+        {
+            if (Owner != null && calendarButton != null && calendarButton.DataContext != null)
+            {
+                Owner.FocusCalendarButton.IsCalendarButtonFocused = false;
+                Owner.FocusCalendarButton = calendarButton;
+                calendarButton.IsCalendarButtonFocused = Owner.HasFocusInternal;
+
+                if (Owner.DisplayMode == CalendarMode.Year)
+                {
+                    Owner.SelectedMonth = (DateTime)calendarButton.DataContext;
+                }
+                else
+                {
+                    Owner.SelectedYear = (DateTime)calendarButton.DataContext;
+                }
+            }
+        }
+
+        private void SetYearButtons(int decade, int decadeEnd)
+        {
+            int year;
+            int count = -1;
+            foreach (object child in YearView.Children)
+            {
+                CalendarButton childButton = child as CalendarButton;
+                Debug.Assert(childButton != null, "childButton should not be null!");
+                year = decade + count;
+
+                if (year <= DateTime.MaxValue.Year && year >= DateTime.MinValue.Year)
+                {
+                    // There should be no time component. Time is 12:00 AM
+                    DateTime day = new DateTime(year, 1, 1);
+                    childButton.DataContext = day;
+                    childButton.Content = year.ToString(DateTimeHelper.GetCurrentDateFormat());
+                    childButton.IsVisible = true;
+
+                    if (Owner != null)
+                    {
+                        if (year == Owner.SelectedYear.Year)
+                        {
+                            Owner.FocusCalendarButton = childButton;
+                            childButton.IsCalendarButtonFocused = Owner.HasFocusInternal;
+                        }
+                        else
+                        {
+                            childButton.IsCalendarButtonFocused = false;
+                        }
+                        childButton.IsSelected = (Owner.DisplayDate.Year == year);
+
+                        if (year < Owner.DisplayDateRangeStart.Year || year > Owner.DisplayDateRangeEnd.Year)
+                        {
+                            childButton.IsEnabled = false;
+                            childButton.Opacity = 0;
+                        }
+                        else
+                        {
+                            childButton.IsEnabled = true;
+                            childButton.Opacity = 1;
+                        }
+                    }
+
+                    // SET IF THE YEAR IS INACTIVE OR NOT: set if the year is a
+                    // trailing year or not
+                    childButton.IsInactive = (year < decade || year > decadeEnd);
+                }
+                else
+                {
+                    childButton.IsEnabled = false;
+                    childButton.Opacity = 0;
+                }
+
+                count++;
+            }
+        }
+        private void SetDecadeModeHeaderButton(int decade, int decadeEnd)
+        {
+            if (HeaderButton != null)
+            {
+                HeaderButton.Content = decade.ToString(CultureInfo.CurrentCulture) + "-" + decadeEnd.ToString(CultureInfo.CurrentCulture);
+                HeaderButton.IsEnabled = false;
+            }
+        }
+        private void SetDecadeModeNextButton(int decadeEnd)
+        {
+            if (Owner != null && NextButton != null)
+            {
+                NextButton.IsEnabled = (Owner.DisplayDateRangeEnd.Year > decadeEnd);
+            }
+        }
+        private void SetDecadeModePreviousButton(int decade)
+        {
+            if (Owner != null && PreviousButton != null)
+            {
+                PreviousButton.IsEnabled = (decade > Owner.DisplayDateRangeStart.Year);
+            }
+        }
+
+        internal void HeaderButton_Click(object sender, RoutedEventArgs e)
+        {
+            if (Owner != null)
+            {
+                if (!Owner.HasFocusInternal)
+                {
+                    Owner.Focus();
+                }
+                Button b = sender as Button;
+                DateTime d;
+
+                if (b.IsEnabled)
+                {
+                    if (Owner.DisplayMode == CalendarMode.Month)
+                    {
+                        if (Owner.DisplayDate != null)
+                        {
+                            d = Owner.DisplayDateInternal;
+                            Owner.SelectedMonth = new DateTime(d.Year, d.Month, 1);
+                        }
+                        Owner.DisplayMode = CalendarMode.Year;
+                    }
+                    else
+                    {
+                        Debug.Assert(Owner.DisplayMode == CalendarMode.Year, "The Owner Calendar's DisplayMode should be Year!");
+
+                        if (Owner.SelectedMonth != null)
+                        {
+                            d = Owner.SelectedMonth;
+                            Owner.SelectedYear = new DateTime(d.Year, d.Month, 1);
+                        }
+                        Owner.DisplayMode = CalendarMode.Decade;
+                    }
+                }
+            }
+        }
+        internal void PreviousButton_Click(object sender, RoutedEventArgs e)
+        {
+            if (Owner != null)
+            {
+                if (!Owner.HasFocusInternal)
+                {
+                    Owner.Focus();
+                }
+
+                Button b = sender as Button;
+                if (b.IsEnabled)
+                {
+                    Owner.OnPreviousClick();
+                }
+            }
+        }
+        internal void NextButton_Click(object sender, RoutedEventArgs e)
+        {
+            if (Owner != null)
+            {
+                if (!Owner.HasFocusInternal)
+                {
+                    Owner.Focus();
+                }
+                Button b = sender as Button;
+
+                if (b.IsEnabled)
+                {
+                    Owner.OnNextClick();
+                }
+            }
+        }
+
+        internal void Cell_MouseEnter(object sender, PointerEventArgs e)
+        {
+            if (Owner != null)
+            {
+                CalendarDayButton b = sender as CalendarDayButton;
+                if (_isMouseLeftButtonDown && b != null && b.IsEnabled && !b.IsBlackout)
+                {
+                    // Update the states of all buttons to be selected starting
+                    // from HoverStart to b
+                    switch (Owner.SelectionMode)
+                    {
+                        case CalendarSelectionMode.SingleDate:
+                            {
+                                DateTime selectedDate = (DateTime)b.DataContext;
+                                Owner.DatePickerDisplayDateFlag = true;
+                                if (Owner.SelectedDates.Count == 0)
+                                {
+                                    Owner.SelectedDates.Add(selectedDate);
+                                }
+                                else
+                                {
+                                    Owner.SelectedDates[0] = selectedDate;
+                                }
+                                return;
+                            }
+                        case CalendarSelectionMode.SingleRange:
+                        case CalendarSelectionMode.MultipleRange:
+                            {
+                                Debug.Assert(b.DataContext != null, "The DataContext should not be null!");
+                                Owner.UnHighlightDays();
+                                Owner.HoverEndIndex = b.Index;
+                                Owner.HoverEnd = (DateTime)b.DataContext;
+                                // Update the States of the buttons
+                                Owner.HighlightDays();
+                                return;
+                            }
+                    }
+                }
+            }
+        }
+        internal void Cell_MouseLeave(object sender, PointerEventArgs e)
+        {
+            if (_isMouseLeftButtonDown)
+            {
+                CalendarDayButton b = sender as CalendarDayButton;
+                // The button is in Pressed state. Change the state to normal.
+                if (e.Device.Captured == b)
+                    e.Device.Capture(null);
+                // null check is added for unit tests
+                if (_downEventArg != null)
+                {
+                    var arg =
+                        new PointerReleasedEventArgs()
+                        {
+                            Device = _downEventArg.Device,
+                            MouseButton = _downEventArg.MouseButton,
+                            Handled = _downEventArg.Handled,
+                            InputModifiers = _downEventArg.InputModifiers,
+                            Route = _downEventArg.Route,
+                            Source = _downEventArg.Source
+                        };
+
+                    b.SendMouseLeftButtonUp(arg);
+                }
+                _lastCalendarDayButton = b;
+            }
+        }
+        internal void Cell_MouseLeftButtonDown(object sender, PointerPressedEventArgs e)
+        {
+            if (Owner != null)
+            {
+                if (!Owner.HasFocusInternal)
+                {
+                    Owner.Focus();
+                }
+
+                bool ctrl, shift;
+                CalendarExtensions.GetMetaKeyState(e.InputModifiers, out ctrl, out shift);
+                CalendarDayButton b = sender as CalendarDayButton;
+
+                if (b != null)
+                {
+                    _isControlPressed = ctrl;
+                    if (b.IsEnabled && !b.IsBlackout)
+                    {
+                        DateTime selectedDate = (DateTime)b.DataContext;
+                        Debug.Assert(selectedDate != null, "selectedDate should not be null!");
+                        _isMouseLeftButtonDown = true;
+                        // null check is added for unit tests
+                        if (e != null)
+                        {
+                            _downEventArg = e;
+                        }
+
+                        switch (Owner.SelectionMode)
+                        {
+                            case CalendarSelectionMode.None:
+                                {
+                                    return;
+                                }
+                            case CalendarSelectionMode.SingleDate:
+                                {
+                                    Owner.DatePickerDisplayDateFlag = true;
+                                    if (Owner.SelectedDates.Count == 0)
+                                    {
+                                        Owner.SelectedDates.Add(selectedDate);
+                                    }
+                                    else
+                                    {
+                                        Owner.SelectedDates[0] = selectedDate;
+                                    }
+                                    return;
+                                }
+                            case CalendarSelectionMode.SingleRange:
+                                {
+                                    // Set the start or end of the selection
+                                    // range
+                                    if (shift)
+                                    {
+                                        Owner.UnHighlightDays();
+                                        Owner.HoverEnd = selectedDate;
+                                        Owner.HoverEndIndex = b.Index;
+                                        Owner.HighlightDays();
+                                    }
+                                    else
+                                    {
+                                        Owner.UnHighlightDays();
+                                        Owner.HoverStart = selectedDate;
+                                        Owner.HoverStartIndex = b.Index;
+                                    }
+                                    return;
+                                }
+                            case CalendarSelectionMode.MultipleRange:
+                                {
+                                    if (shift)
+                                    {
+                                        if (!ctrl)
+                                        {
+                                            // clear the list, set the states to
+                                            // default
+                                            foreach (DateTime item in Owner.SelectedDates)
+                                            {
+                                                Owner.RemovedItems.Add(item);
+                                            }
+                                            Owner.SelectedDates.ClearInternal();
+                                        }
+                                        Owner.HoverEnd = selectedDate;
+                                        Owner.HoverEndIndex = b.Index;
+                                        Owner.HighlightDays();
+                                    }
+                                    else
+                                    {
+                                        if (!ctrl)
+                                        {
+                                            // clear the list, set the states to
+                                            // default
+                                            foreach (DateTime item in Owner.SelectedDates)
+                                            {
+                                                Owner.RemovedItems.Add(item);
+                                            }
+                                            Owner.SelectedDates.ClearInternal();
+                                            Owner.UnHighlightDays();
+                                        }
+                                        Owner.HoverStart = selectedDate;
+                                        Owner.HoverStartIndex = b.Index;
+                                    }
+                                    return;
+                                }
+                        }
+                    }
+                    else
+                    {
+                        // If a click occurs on a BlackOutDay we set the
+                        // HoverStart to be null
+                        Owner.HoverStart = null;
+                    }
+                }
+                else
+                {
+                    _isControlPressed = false;
+                }
+            }
+        }
+        private void AddSelection(CalendarDayButton b)
+        {
+            if (Owner != null)
+            {
+                Owner.HoverEndIndex = b.Index;
+                Owner.HoverEnd = (DateTime)b.DataContext;
+
+                if (Owner.HoverEnd != null && Owner.HoverStart != null)
+                {
+                    // this is selection with Mouse, we do not guarantee the
+                    // range does not include BlackOutDates.  AddRange method
+                    // will throw away the BlackOutDates based on the
+                    // SelectionMode
+                    Owner.IsMouseSelection = true;
+                    Owner.SelectedDates.AddRange(Owner.HoverStart.Value, Owner.HoverEnd.Value);
+                    Owner.OnDayClick((DateTime)b.DataContext);
+                }
+            }
+        }
+        internal void Cell_MouseLeftButtonUp(object sender, PointerReleasedEventArgs e)
+        {
+            if (Owner != null)
+            {
+                CalendarDayButton b = sender as CalendarDayButton;
+                if (b != null && !b.IsBlackout)
+                {
+                    Owner.OnDayButtonMouseUp(e);
+                }
+                _isMouseLeftButtonDown = false;
+                if (b != null && b.DataContext != null)
+                {
+                    if (Owner.SelectionMode == CalendarSelectionMode.None || Owner.SelectionMode == CalendarSelectionMode.SingleDate)
+                    {
+                        Owner.OnDayClick((DateTime)b.DataContext);
+                        return;
+                    }
+                    if (Owner.HoverStart.HasValue)
+                    {
+                        switch (Owner.SelectionMode)
+                        {
+                            case CalendarSelectionMode.SingleRange:
+                                {
+                                    // Update SelectedDates
+                                    foreach (DateTime item in Owner.SelectedDates)
+                                    {
+                                        Owner.RemovedItems.Add(item);
+                                    }
+                                    Owner.SelectedDates.ClearInternal();
+                                    AddSelection(b);
+                                    return;
+                                }
+                            case CalendarSelectionMode.MultipleRange:
+                                {
+                                    // add the selection (either single day or
+                                    // SingleRange day)
+                                    AddSelection(b);
+                                    return;
+                                }
+                        }
+                    }
+                    else
+                    {
+                        // If the day is Disabled but a trailing day we should
+                        // be able to switch months
+                        if (b.IsInactive && b.IsBlackout)
+                        {
+                            Owner.OnDayClick((DateTime)b.DataContext);
+                        }
+                    }
+                }
+            }
+        }
+        private void Cell_Click(object sender, RoutedEventArgs e)
+        {
+            if (Owner != null)
+            {
+                if (_isControlPressed && Owner.SelectionMode == CalendarSelectionMode.MultipleRange)
+                {
+                    CalendarDayButton b = sender as CalendarDayButton;
+                    Debug.Assert(b != null, "The sender should be a non-null CalendarDayButton!");
+
+                    if (b.IsSelected)
+                    {
+                        Owner.HoverStart = null;
+                        _isMouseLeftButtonDown = false;
+                        b.IsSelected = false;
+                        if (b.DataContext != null)
+                        {
+                            Owner.SelectedDates.Remove((DateTime)b.DataContext);
+                        }
+                    }
+                }
+            }
+            _isControlPressed = false;
+        }
+
+        private void Month_CalendarButtonMouseDown(object sender, PointerPressedEventArgs e)
+        {
+            CalendarButton b = sender as CalendarButton;
+            Debug.Assert(b != null, "The sender should be a non-null CalendarDayButton!");
+
+            _isMouseLeftButtonDownYearView = true;
+
+            if (e != null)
+            {
+                _downEventArgYearView = e;
+            }
+
+            UpdateYearViewSelection(b);
+        }
+
+        internal void Month_CalendarButtonMouseUp(object sender, PointerReleasedEventArgs e)
+        {
+            _isMouseLeftButtonDownYearView = false;
+
+            if (Owner != null)
+            {
+                DateTime newmonth = (DateTime)((CalendarButton)sender).DataContext;
+
+                if (Owner.DisplayMode == CalendarMode.Year)
+                {
+                    Owner.DisplayDate = newmonth;
+                    Owner.DisplayMode = CalendarMode.Month;
+                }
+                else
+                {
+                    Debug.Assert(Owner.DisplayMode == CalendarMode.Decade, "The owning Calendar should be in decade mode!");
+                    Owner.SelectedMonth = newmonth;
+                    Owner.DisplayMode = CalendarMode.Year;
+                }
+            }
+        }
+
+        private void Month_MouseEnter(object sender, PointerEventArgs e)
+        {
+            if (_isMouseLeftButtonDownYearView)
+            {
+                CalendarButton b = sender as CalendarButton;
+                Debug.Assert(b != null, "The sender should be a non-null CalendarDayButton!");
+                UpdateYearViewSelection(b);
+            }
+        }
+
+        private void Month_MouseLeave(object sender, PointerEventArgs e)
+        {
+            if (_isMouseLeftButtonDownYearView)
+            {
+                CalendarButton b = sender as CalendarButton;
+                // The button is in Pressed state. Change the state to normal.
+                if (e.Device.Captured == b)
+                    e.Device.Capture(null);
+                //b.ReleaseMouseCapture();
+                if (_downEventArgYearView != null)
+                {
+                    var args =
+                        new PointerReleasedEventArgs()
+                        {
+                            Device = _downEventArgYearView.Device,
+                            MouseButton = _downEventArgYearView.MouseButton,
+                            Handled = _downEventArgYearView.Handled,
+                            InputModifiers = _downEventArgYearView.InputModifiers,
+                            Route = _downEventArgYearView.Route,
+                            Source = _downEventArgYearView.Source
+                        };
+
+                    b.SendMouseLeftButtonUp(args);
+                }
+                _lastCalendarButton = b;
+            }
+        }
+        private void MonthView_MouseLeave(object sender, PointerEventArgs e)
+        {
+            if (_lastCalendarDayButton != null)
+            {
+                e.Device.Capture(_lastCalendarDayButton);
+            }
+        }
+
+        private void YearView_MouseLeave(object sender, PointerEventArgs e)
+        {
+            if (_lastCalendarButton != null)
+            {
+                e.Device.Capture(_lastCalendarButton);
+            }
+        }
+        
+        internal void UpdateDisabled(bool isEnabled)
+        {
+            PseudoClasses.Set(":calendardisabled", !isEnabled);
+        }
+    }
+}
diff --git a/src/Avalonia.Controls/Calendar/DateTimeHelper.cs b/src/Avalonia.Controls/Calendar/DateTimeHelper.cs
new file mode 100644
index 0000000000..033bfc5726
--- /dev/null
+++ b/src/Avalonia.Controls/Calendar/DateTimeHelper.cs
@@ -0,0 +1,155 @@
+// (c) Copyright Microsoft Corporation.
+// This source is subject to the Microsoft Public License (Ms-PL).
+// Please see http://go.microsoft.com/fwlink/?LinkID=131993 for details.
+// All other rights reserved.
+
+using System;
+using System.Diagnostics;
+using System.Globalization;
+
+namespace Avalonia.Controls
+{
+    internal static class DateTimeHelper
+    {
+        public static DateTime? AddDays(DateTime time, int days)
+        {
+            System.Globalization.Calendar cal = new GregorianCalendar();
+            try
+            {
+                return cal.AddDays(time, days);
+            }
+            catch (ArgumentException)
+            {
+                return null;
+            }
+        }
+
+        public static DateTime? AddMonths(DateTime time, int months)
+        {
+            System.Globalization.Calendar cal = new GregorianCalendar();
+            try
+            {
+                return cal.AddMonths(time, months);
+            }
+            catch (ArgumentException)
+            {
+                return null;
+            }
+        }
+
+        public static DateTime? AddYears(DateTime time, int years)
+        {
+            System.Globalization.Calendar cal = new GregorianCalendar();
+            try
+            {
+                return cal.AddYears(time, years);
+            }
+            catch (ArgumentException)
+            {
+                return null;
+            }
+        }
+
+        public static int CompareDays(DateTime dt1, DateTime dt2)
+        {
+            return DateTime.Compare(DiscardTime(dt1).Value, DiscardTime(dt2).Value);
+        }
+
+        public static int CompareYearMonth(DateTime dt1, DateTime dt2)
+        {
+            return (dt1.Year - dt2.Year) * 12 + (dt1.Month - dt2.Month);
+        }
+
+        public static int DecadeOfDate(DateTime date)
+        {
+            return date.Year - (date.Year % 10);
+        }
+
+        public static DateTime DiscardDayTime(DateTime d)
+        {
+            int year = d.Year;
+            int month = d.Month;
+            DateTime newD = new DateTime(year, month, 1, 0, 0, 0);
+            return newD;
+        }
+
+        public static DateTime? DiscardTime(DateTime? d)
+        {
+            if (d == null)
+            {
+                return null;
+            }
+            return d.Value.Date;
+        }
+
+        public static int EndOfDecade(DateTime date)
+        {
+            return DecadeOfDate(date) + 9;
+        }
+
+        public static DateTimeFormatInfo GetCurrentDateFormat()
+        {
+            if (CultureInfo.CurrentCulture.Calendar is GregorianCalendar)
+            {
+                return CultureInfo.CurrentCulture.DateTimeFormat;
+            }
+            else
+            {
+                foreach (System.Globalization.Calendar cal in CultureInfo.CurrentCulture.OptionalCalendars)
+                {
+                    if (cal is GregorianCalendar)
+                    {
+                        // if the default calendar is not Gregorian, return the
+                        // first supported GregorianCalendar dtfi
+                        DateTimeFormatInfo dtfi = new CultureInfo(CultureInfo.CurrentCulture.Name).DateTimeFormat;
+                        dtfi.Calendar = cal;
+                        return dtfi;
+                    }
+                }
+
+                // if there are no GregorianCalendars in the OptionalCalendars
+                // list, use the invariant dtfi
+                DateTimeFormatInfo dt = new CultureInfo(CultureInfo.InvariantCulture.Name).DateTimeFormat;
+                dt.Calendar = new GregorianCalendar();
+                return dt;
+            }
+        }
+        public static bool InRange(DateTime date, CalendarDateRange range)
+        {
+            Debug.Assert(DateTime.Compare(range.Start, range.End) < 1, "The range should start before it ends!");
+
+            if (CompareDays(date, range.Start) > -1 && CompareDays(date, range.End) < 1)
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        public static string ToYearMonthPatternString(DateTime date)
+        {
+            string result = string.Empty;
+            DateTimeFormatInfo format = GetCurrentDateFormat();
+
+            if (format != null)
+            {
+                result = date.ToString(format.YearMonthPattern, format);
+            }
+
+            return result;
+        }
+
+        public static string ToYearString(DateTime date)
+        {
+            string result = string.Empty;
+            DateTimeFormatInfo format = GetCurrentDateFormat();
+
+            if (format != null)
+            {
+                result = date.Year.ToString(format);
+            }
+
+            return result;
+        }
+    }
+}
diff --git a/src/Avalonia.Controls/Calendar/SelectedDatesCollection.cs b/src/Avalonia.Controls/Calendar/SelectedDatesCollection.cs
new file mode 100644
index 0000000000..e6e0cf7c4f
--- /dev/null
+++ b/src/Avalonia.Controls/Calendar/SelectedDatesCollection.cs
@@ -0,0 +1,361 @@
+// (c) Copyright Microsoft Corporation.
+// This source is subject to the Microsoft Public License (Ms-PL).
+// Please see http://go.microsoft.com/fwlink/?LinkID=131993 for details.
+// All other rights reserved.
+
+using Avalonia.Threading;
+using System;
+using System.Collections.ObjectModel;
+using System.Threading;
+
+namespace Avalonia.Controls.Primitives
+{
+    public sealed class SelectedDatesCollection : ObservableCollection<DateTime>
+    {
+        /// <summary>
+        /// Inherited code: Requires comment.
+        /// </summary>
+        private Collection<DateTime> _addedItems;
+        
+        /// <summary>
+        /// Inherited code: Requires comment.
+        /// </summary>
+        private bool _isCleared;
+
+        /// <summary>
+        /// Inherited code: Requires comment.
+        /// </summary>
+        private bool _isRangeAdded;
+
+        /// <summary>
+        /// Inherited code: Requires comment.
+        /// </summary>
+        private Calendar _owner;
+
+        /// <summary>
+        /// Initializes a new instance of the
+        /// <see cref="T:Avalonia.Controls.Primitives.SelectedDatesCollection" />
+        /// class.
+        /// </summary>
+        /// <param name="owner">
+        /// The <see cref="T:Avalonia.Controls.Calendar" /> associated
+        /// with this object.
+        /// </param>
+        public SelectedDatesCollection(Calendar owner)
+        {
+            _owner = owner;
+            _addedItems = new Collection<DateTime>();
+        }
+
+        private void InvokeCollectionChanged(System.Collections.IList removedItems, System.Collections.IList addedItems)
+        {
+            _owner.OnSelectedDatesCollectionChanged(new SelectionChangedEventArgs(null, addedItems, removedItems));
+        }
+
+        /// <summary>
+        /// Adds all the dates in the specified range, which includes the first
+        /// and last dates, to the collection.
+        /// </summary>
+        /// <param name="start">The first date to add to the collection.</param>
+        /// <param name="end">The last date to add to the collection.</param>
+        public void AddRange(DateTime start, DateTime end)
+        {
+            DateTime? rangeStart;
+
+            // increment parameter specifies if the Days were selected in
+            // Descending order or Ascending order based on this value, we add 
+            // the days in the range either in Ascending order or in Descending
+            // order
+            int increment = (DateTime.Compare(end, start) >= 0) ? 1 : -1;
+
+            _addedItems.Clear();
+
+            rangeStart = start;
+            _isRangeAdded = true;
+
+            if (_owner.IsMouseSelection)
+            {
+                // In Mouse Selection we allow the user to be able to add
+                // multiple ranges in one action in MultipleRange Mode.  In
+                // SingleRange Mode, we only add the first selected range.
+                while (rangeStart.HasValue && DateTime.Compare(end, rangeStart.Value) != -increment)
+                {
+                    if (Calendar.IsValidDateSelection(_owner, rangeStart))
+                    {
+                        Add(rangeStart.Value);
+                    }
+                    else
+                    {
+                        if (_owner.SelectionMode == CalendarSelectionMode.SingleRange)
+                        {
+                            _owner.HoverEnd = rangeStart.Value.AddDays(-increment);
+                            break;
+                        }
+                    }
+
+                    rangeStart = DateTimeHelper.AddDays(rangeStart.Value, increment);
+                }
+            }
+            else
+            {
+                // If CalendarSelectionMode.SingleRange and a user
+                // programmatically tries to add multiple ranges, we will throw
+                // away the old range and replace it with the new one.  In order
+                // to provide the removed items without an additional event, we
+                // are calling ClearInternal
+                if (_owner.SelectionMode == CalendarSelectionMode.SingleRange && Count > 0)
+                {
+                    foreach (DateTime item in this)
+                    {
+                        _owner.RemovedItems.Add(item);
+                    }
+                    ClearInternal();
+                }
+
+                while (rangeStart.HasValue && DateTime.Compare(end, rangeStart.Value) != -increment)
+                {
+                    Add(rangeStart.Value);
+                    rangeStart = DateTimeHelper.AddDays(rangeStart.Value, increment);
+                }
+            }
+
+            _owner.OnSelectedDatesCollectionChanged(new SelectionChangedEventArgs(null, _addedItems, _owner.RemovedItems));
+            _owner.RemovedItems.Clear();
+            _owner.UpdateMonths();
+            _isRangeAdded = false;
+        }
+
+        /// <summary>
+        /// Removes all items from the collection.
+        /// </summary>
+        /// <remarks>
+        /// This implementation raises the CollectionChanged event.
+        /// </remarks>
+        protected override void ClearItems()
+        {
+            EnsureValidThread();
+
+            Collection<DateTime> addedItems = new Collection<DateTime>();
+            Collection<DateTime> removedItems = new Collection<DateTime>();
+
+            foreach (DateTime item in this)
+            {
+                removedItems.Add(item);
+            }
+
+            base.ClearItems();
+
+            // The event fires after SelectedDate changes
+            if (_owner.SelectionMode != CalendarSelectionMode.None && _owner.SelectedDate != null)
+            {
+                _owner.SelectedDate = null;
+            }
+
+            if (removedItems.Count != 0)
+            {
+                InvokeCollectionChanged(removedItems, addedItems);
+            }
+            _owner.UpdateMonths();
+        }
+
+        /// <summary>
+        /// Inserts an item into the collection at the specified index.
+        /// </summary>
+        /// <param name="index">
+        /// The zero-based index at which item should be inserted.
+        /// </param>
+        /// <param name="item">The object to insert.</param>
+        /// <remarks>
+        /// This implementation raises the CollectionChanged event.
+        /// </remarks>
+        protected override void InsertItem(int index, DateTime item)
+        {
+            EnsureValidThread();
+
+            if (!Contains(item))
+            {
+                Collection<DateTime> addedItems = new Collection<DateTime>();
+
+                if (CheckSelectionMode())
+                {
+                    if (Calendar.IsValidDateSelection(_owner, item))
+                    {
+                        // If the Collection is cleared since it is SingleRange
+                        // and it had another range set the index to 0
+                        if (_isCleared)
+                        {
+                            index = 0;
+                            _isCleared = false;
+                        }
+
+                        base.InsertItem(index, item);
+
+                        // The event fires after SelectedDate changes
+                        if (index == 0 && !(_owner.SelectedDate.HasValue && DateTime.Compare(_owner.SelectedDate.Value, item) == 0))
+                        {
+                            _owner.SelectedDate = item;
+                        }
+
+                        if (!_isRangeAdded)
+                        {
+                            addedItems.Add(item);
+
+                            InvokeCollectionChanged(_owner.RemovedItems, addedItems);
+                            _owner.RemovedItems.Clear();
+                            int monthDifference = DateTimeHelper.CompareYearMonth(item, _owner.DisplayDateInternal);
+
+                            if (monthDifference < 2 && monthDifference > -2)
+                            {
+                                _owner.UpdateMonths();
+                            }
+                        }
+                        else
+                        {
+                            _addedItems.Add(item);
+                        }
+                    }
+                    else
+                    {
+                        throw new ArgumentOutOfRangeException("SelectedDate value is not valid.");
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Removes the item at the specified index of the collection.
+        /// </summary>
+        /// <param name="index">
+        /// The zero-based index of the element to remove.
+        /// </param>
+        /// <remarks>
+        /// This implementation raises the CollectionChanged event.
+        /// </remarks>
+        protected override void RemoveItem(int index)
+        {
+            EnsureValidThread();
+
+            if (index >= Count)
+            {
+                base.RemoveItem(index);
+            }
+            else
+            {
+                Collection<DateTime> addedItems = new Collection<DateTime>();
+                Collection<DateTime> removedItems = new Collection<DateTime>();
+                int monthDifference = DateTimeHelper.CompareYearMonth(this[index], _owner.DisplayDateInternal);
+
+                removedItems.Add(this[index]);
+                base.RemoveItem(index);
+
+                // The event fires after SelectedDate changes
+                if (index == 0)
+                {
+                    if (Count > 0)
+                    {
+                        _owner.SelectedDate = this[0];
+                    }
+                    else
+                    {
+                        _owner.SelectedDate = null;
+                    }
+                }
+
+                InvokeCollectionChanged(removedItems, addedItems);
+
+                if (monthDifference < 2 && monthDifference > -2)
+                {
+                    _owner.UpdateMonths();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Replaces the element at the specified index.
+        /// </summary>
+        /// <param name="index">
+        /// The zero-based index of the element to replace.
+        /// </param>
+        /// <param name="item">
+        /// The new value for the element at the specified index.
+        /// </param>
+        /// <remarks>
+        /// This implementation raises the CollectionChanged event.
+        /// </remarks>
+        protected override void SetItem(int index, DateTime item)
+        {
+            EnsureValidThread();
+
+            if (!Contains(item))
+            {
+                Collection<DateTime> addedItems = new Collection<DateTime>();
+                Collection<DateTime> removedItems = new Collection<DateTime>();
+
+                if (index >= Count)
+                {
+                    base.SetItem(index, item);
+                }
+                else
+                {
+                    if (item != null && DateTime.Compare(this[index], item) != 0 && Calendar.IsValidDateSelection(_owner, item))
+                    {
+                        removedItems.Add(this[index]);
+                        base.SetItem(index, item);
+                        addedItems.Add(item);
+
+                        // The event fires after SelectedDate changes
+                        if (index == 0 && !(_owner.SelectedDate.HasValue && DateTime.Compare(_owner.SelectedDate.Value, item) == 0))
+                        {
+                            _owner.SelectedDate = item;
+                        }
+                        InvokeCollectionChanged(removedItems, addedItems);
+
+                        int monthDifference = DateTimeHelper.CompareYearMonth(item, _owner.DisplayDateInternal);
+
+                        if (monthDifference < 2 && monthDifference > -2)
+                        {
+                            _owner.UpdateMonths();
+                        }
+                    }
+                }
+            }
+        }
+        
+        internal void ClearInternal()
+        {
+            base.ClearItems();
+        }
+        
+        private bool CheckSelectionMode()
+        {
+            if (_owner.SelectionMode == CalendarSelectionMode.None)
+            {
+                throw new InvalidOperationException("The SelectedDate property cannot be set when the selection mode is None.");
+            }
+            if (_owner.SelectionMode == CalendarSelectionMode.SingleDate && Count > 0)
+            {
+                throw new InvalidOperationException("The SelectedDates collection can be changed only in a multiple selection mode. Use the SelectedDate in a single selection mode.");
+            }
+
+            // if user tries to add an item into the SelectedDates in
+            // SingleRange mode, we throw away the old range and replace it with
+            // the new one in order to provide the removed items without an
+            // additional event, we are calling ClearInternal
+            if (_owner.SelectionMode == CalendarSelectionMode.SingleRange && !_isRangeAdded && Count > 0)
+            {
+                foreach (DateTime item in this)
+                {
+                    _owner.RemovedItems.Add(item);
+                }
+                ClearInternal();
+                _isCleared = true;
+            }
+            return true;
+        }
+        
+        private void EnsureValidThread()
+        {
+            Dispatcher.UIThread.VerifyAccess();
+        }
+    }
+}
diff --git a/src/Avalonia.Controls/Classes.cs b/src/Avalonia.Controls/Classes.cs
index c897e86697..613273d5c7 100644
--- a/src/Avalonia.Controls/Classes.cs
+++ b/src/Avalonia.Controls/Classes.cs
@@ -179,7 +179,7 @@ namespace Avalonia.Controls
             {
                 ThrowIfPseudoclass(name, "removed");
 
-                if (!Contains(name))
+                if (Contains(name))
                 {
                     c.Add(name);
                 }
diff --git a/src/Avalonia.Controls/Control.cs b/src/Avalonia.Controls/Control.cs
index a7aafbf6e8..d4777b2f8a 100644
--- a/src/Avalonia.Controls/Control.cs
+++ b/src/Avalonia.Controls/Control.cs
@@ -774,7 +774,9 @@ namespace Avalonia.Controls
 
                     foreach (var child in control.LogicalChildren)
                     {
-                        if (child is Control c && !c.IsSet(DataContextProperty))
+                        if (child is Control c && 
+                            c.InheritanceParent == control &&
+                            !c.IsSet(DataContextProperty))
                         {
                             DataContextNotifying(c, notifying);
                         }
diff --git a/src/Avalonia.Controls/Primitives/ToggleButton.cs b/src/Avalonia.Controls/Primitives/ToggleButton.cs
index 4e9e326997..7d500975f0 100644
--- a/src/Avalonia.Controls/Primitives/ToggleButton.cs
+++ b/src/Avalonia.Controls/Primitives/ToggleButton.cs
@@ -9,26 +9,37 @@ namespace Avalonia.Controls.Primitives
 {
     public class ToggleButton : Button
     {
-        public static readonly DirectProperty<ToggleButton, bool> IsCheckedProperty =
-            AvaloniaProperty.RegisterDirect<ToggleButton, bool>(
-                "IsChecked",
+        public static readonly DirectProperty<ToggleButton, bool?> IsCheckedProperty =
+            AvaloniaProperty.RegisterDirect<ToggleButton, bool?>(
+                nameof(IsChecked),
                 o => o.IsChecked,
-                (o,v) => o.IsChecked = v,
+                (o, v) => o.IsChecked = v,
                 defaultBindingMode: BindingMode.TwoWay);
 
-        private bool _isChecked;
+        public static readonly StyledProperty<bool> IsThreeStateProperty =
+            AvaloniaProperty.Register<ToggleButton, bool>(nameof(IsThreeState));
+
+        private bool? _isChecked = false;
 
         static ToggleButton()
         {
-            PseudoClass(IsCheckedProperty, ":checked");
+            PseudoClass(IsCheckedProperty, c => c == true, ":checked");
+            PseudoClass(IsCheckedProperty, c => c == false, ":unchecked");
+            PseudoClass(IsCheckedProperty, c => c == null, ":indeterminate");
         }
 
-        public bool IsChecked
+        public bool? IsChecked
         {
             get { return _isChecked; }
             set { SetAndRaise(IsCheckedProperty, ref _isChecked, value); }
         }
 
+        public bool IsThreeState
+        {
+            get => GetValue(IsThreeStateProperty);
+            set => SetValue(IsThreeStateProperty, value);
+        }
+
         protected override void OnClick()
         {
             Toggle();
@@ -37,7 +48,16 @@ namespace Avalonia.Controls.Primitives
 
         protected virtual void Toggle()
         {
-            IsChecked = !IsChecked;
+            if (IsChecked.HasValue)
+                if (IsChecked.Value)
+                    if (IsThreeState)
+                        IsChecked = null;
+                    else
+                        IsChecked = false;
+                else
+                    IsChecked = true;
+            else
+                IsChecked = false;
         }
     }
 }
diff --git a/src/Avalonia.Controls/RadioButton.cs b/src/Avalonia.Controls/RadioButton.cs
index 25ab0f9c12..945335b8f7 100644
--- a/src/Avalonia.Controls/RadioButton.cs
+++ b/src/Avalonia.Controls/RadioButton.cs
@@ -17,17 +17,17 @@ namespace Avalonia.Controls
 
         protected override void Toggle()
         {
-            if (!IsChecked)
+            if (!IsChecked.GetValueOrDefault())
             {
                 IsChecked = true;
             }
         }
 
-        private void IsCheckedChanged(bool value)
+        private void IsCheckedChanged(bool? value)
         {
             var parent = this.GetVisualParent();
 
-            if (value && parent != null)
+            if (value.GetValueOrDefault() && parent != null)
             {
                 var siblings = parent
                     .GetVisualChildren()
@@ -36,7 +36,8 @@ namespace Avalonia.Controls
 
                 foreach (var sibling in siblings)
                 {
-                    sibling.IsChecked = false;
+                    if (sibling.IsChecked.GetValueOrDefault())
+                        sibling.IsChecked = false;
                 }
             }
         }
diff --git a/src/Avalonia.Controls/Shapes/Shape.cs b/src/Avalonia.Controls/Shapes/Shape.cs
index c03f4dc563..73b89ca4b7 100644
--- a/src/Avalonia.Controls/Shapes/Shape.cs
+++ b/src/Avalonia.Controls/Shapes/Shape.cs
@@ -29,6 +29,8 @@ namespace Avalonia.Controls.Shapes
         private Matrix _transform = Matrix.Identity;
         private Geometry _definingGeometry;
         private Geometry _renderedGeometry;
+        bool _calculateTransformOnArrange = false;
+
 
         static Shape()
         {
@@ -150,13 +152,53 @@ namespace Avalonia.Controls.Shapes
             this._definingGeometry = null;
             InvalidateMeasure();
         }
-
+        
         protected override Size MeasureOverride(Size availableSize)
+        {
+            bool deferCalculateTransform;
+            switch (Stretch)
+            {
+                case Stretch.Fill:
+                case Stretch.UniformToFill:
+                    deferCalculateTransform = double.IsInfinity(availableSize.Width) || double.IsInfinity(availableSize.Height);
+                    break;
+                case Stretch.Uniform:
+                    deferCalculateTransform = double.IsInfinity(availableSize.Width) && double.IsInfinity(availableSize.Height);
+                    break;
+                case Stretch.None:
+                default:
+                    deferCalculateTransform = false;
+                    break;
+            }
+
+            if (deferCalculateTransform)
+            {
+                _calculateTransformOnArrange = true;
+                return DefiningGeometry.Bounds.Size;
+            }
+            else
+            {
+                _calculateTransformOnArrange = false;
+                return CalculateShapeSizeAndSetTransform(availableSize);
+            }
+        }
+        
+        protected override Size ArrangeOverride(Size finalSize)
+        {
+            if(_calculateTransformOnArrange)
+            {
+                _calculateTransformOnArrange = false;
+                CalculateShapeSizeAndSetTransform(finalSize);
+            }
+
+            return finalSize;
+        }
+        private Size CalculateShapeSizeAndSetTransform(Size availableSize)
         {
             // This should probably use GetRenderBounds(strokeThickness) but then the calculations
             // will multiply the stroke thickness as well, which isn't correct.
             var (size, transform) = CalculateSizeAndTransform(availableSize, DefiningGeometry.Bounds, Stretch);
-            
+
             if (_transform != transform)
             {
                 _transform = transform;
diff --git a/src/Avalonia.Controls/Templates/FuncTreeDataTemplate.cs b/src/Avalonia.Controls/Templates/FuncTreeDataTemplate.cs
index 04e6ece832..2e55dd3552 100644
--- a/src/Avalonia.Controls/Templates/FuncTreeDataTemplate.cs
+++ b/src/Avalonia.Controls/Templates/FuncTreeDataTemplate.cs
@@ -62,7 +62,7 @@ namespace Avalonia.Controls.Templates
         /// <returns>The child items, or null if no child items.</returns>
         public InstancedBinding ItemsSelector(object item)
         {
-            return new InstancedBinding(this?._itemsSelector(item));
+            return InstancedBinding.OneTime(this?._itemsSelector(item));
         }
 
         /// <summary>
diff --git a/src/Avalonia.Diagnostics/Avalonia.Diagnostics.csproj b/src/Avalonia.Diagnostics/Avalonia.Diagnostics.csproj
index 5cb56e0be1..abbdd15bed 100644
--- a/src/Avalonia.Diagnostics/Avalonia.Diagnostics.csproj
+++ b/src/Avalonia.Diagnostics/Avalonia.Diagnostics.csproj
@@ -50,5 +50,4 @@
     </EmbeddedResource>
   </ItemGroup>
   <Import Project="..\..\build\Rx.props" />
-  <Import Project="..\..\build\Splat.props" />
 </Project>
\ No newline at end of file
diff --git a/src/Avalonia.Diagnostics/LogManager.cs b/src/Avalonia.Diagnostics/LogManager.cs
deleted file mode 100644
index d08d61836e..0000000000
--- a/src/Avalonia.Diagnostics/LogManager.cs
+++ /dev/null
@@ -1,53 +0,0 @@
-// 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.Layout;
-using Splat;
-
-namespace Avalonia.Diagnostics
-{
-    public class LogManager : ILogManager
-    {
-        private static LogManager s_instance;
-
-        public static LogManager Instance => s_instance ?? (s_instance = new LogManager());
-
-        public ILogger Logger
-        {
-            get;
-            set;
-        }
-
-        public bool LogPropertyMessages
-        {
-            get;
-            set;
-        }
-
-        public bool LogLayoutMessages
-        {
-            get;
-            set;
-        }
-
-        public static void Enable(ILogger logger)
-        {
-            Instance.Logger = logger;
-            Locator.CurrentMutable.Register(() => Instance, typeof(ILogManager));
-        }
-
-        public IFullLogger GetLogger(Type type)
-        {
-            if ((type == typeof(AvaloniaObject) && LogPropertyMessages) ||
-                (type == typeof(Layoutable) && LogLayoutMessages))
-            {
-                return new WrappingFullLogger(Logger, type);
-            }
-            else
-            {
-                return new WrappingFullLogger(new NullLogger(), type);
-            }
-        }
-    }
-}
diff --git a/src/Avalonia.ReactiveUI/Avalonia.ReactiveUI.csproj b/src/Avalonia.ReactiveUI/Avalonia.ReactiveUI.csproj
index c29dbcd381..b7ad36f8b2 100644
--- a/src/Avalonia.ReactiveUI/Avalonia.ReactiveUI.csproj
+++ b/src/Avalonia.ReactiveUI/Avalonia.ReactiveUI.csproj
@@ -16,5 +16,4 @@
   </ItemGroup>
   <Import Project="..\..\build\Rx.props" />
   <Import Project="..\..\build\ReactiveUI.props" />
-  <Import Project="..\..\build\Splat.props" />
 </Project>
\ No newline at end of file
diff --git a/src/Avalonia.Remote.Protocol/BsonStreamTransport.cs b/src/Avalonia.Remote.Protocol/BsonStreamTransport.cs
index 604703cac8..93a3b60599 100644
--- a/src/Avalonia.Remote.Protocol/BsonStreamTransport.cs
+++ b/src/Avalonia.Remote.Protocol/BsonStreamTransport.cs
@@ -64,7 +64,6 @@ namespace Avalonia.Remote.Protocol
 
         async Task Reader()
         {
-            Task.Yield();
             try
             {
                 while (true)
@@ -147,4 +146,4 @@ namespace Avalonia.Remote.Protocol
         public event Action<IAvaloniaRemoteTransportConnection, object> OnMessage;
         public event Action<IAvaloniaRemoteTransportConnection, Exception> OnException;
     }
-}
\ No newline at end of file
+}
diff --git a/src/Avalonia.Styling/Styling/Setter.cs b/src/Avalonia.Styling/Styling/Setter.cs
index eb5218cd6f..e4d0ce5fab 100644
--- a/src/Avalonia.Styling/Styling/Setter.cs
+++ b/src/Avalonia.Styling/Styling/Setter.cs
@@ -135,45 +135,47 @@ namespace Avalonia.Styling
 
         private InstancedBinding Clone(InstancedBinding sourceInstance, IStyle style, IObservable<bool> activator)
         {
-            InstancedBinding cloned;
-
             if (activator != null)
             {
                 var description = style?.ToString();
 
-                if (sourceInstance.Mode == BindingMode.TwoWay || sourceInstance.Mode == BindingMode.OneWayToSource)
-                {
-                    var activated = new ActivatedSubject(activator, sourceInstance.Subject, description);
-                    cloned = new InstancedBinding(activated, sourceInstance.Mode, BindingPriority.StyleTrigger);
-                }
-                else if (sourceInstance.Mode == BindingMode.OneTime)
-                {
-                    var activated = new ActivatedValue(activator, sourceInstance.Value, description);
-                    cloned = new InstancedBinding(activated, BindingMode.OneWay, BindingPriority.StyleTrigger);
-                }
-                else
+                switch (sourceInstance.Mode)
                 {
-                    var activated = new ActivatedObservable(activator, sourceInstance.Observable ?? sourceInstance.Subject, description);
-                    cloned = new InstancedBinding(activated, sourceInstance.Mode, BindingPriority.StyleTrigger);
+                    case BindingMode.OneTime:
+                        if (sourceInstance.Observable != null)
+                        {
+                            var activated = new ActivatedObservable(activator, sourceInstance.Observable, description);
+                            return InstancedBinding.OneTime(activated, BindingPriority.StyleTrigger);
+                        }
+                        else
+                        {
+                            var activated = new ActivatedValue(activator, sourceInstance.Value, description);
+                            return InstancedBinding.OneTime(activated, BindingPriority.StyleTrigger);
+                        }
+                    case BindingMode.OneWay:
+                        {
+                            var activated = new ActivatedObservable(activator, sourceInstance.Observable, description);
+                            return InstancedBinding.OneWay(activated, BindingPriority.StyleTrigger);
+                        }
+                    case BindingMode.OneWayToSource:
+                        {
+                            var activated = new ActivatedSubject(activator, sourceInstance.Subject, description);
+                            return InstancedBinding.OneWayToSource(activated, BindingPriority.StyleTrigger);
+                        }
+                    case BindingMode.TwoWay:
+                        {
+                            var activated = new ActivatedSubject(activator, sourceInstance.Subject, description);
+                            return InstancedBinding.TwoWay(activated, BindingPriority.StyleTrigger);
+                        }
+                    default:
+                        throw new NotSupportedException("Unsupported BindingMode.");
                 }
+
             }
             else
             {
-                if (sourceInstance.Subject != null)
-                {
-                    cloned = new InstancedBinding(sourceInstance.Subject, sourceInstance.Mode, BindingPriority.Style);
-                }
-                else if (sourceInstance.Observable != null)
-                {
-                    cloned = new InstancedBinding(sourceInstance.Observable, sourceInstance.Mode, BindingPriority.Style);
-                }
-                else
-                {
-                    cloned = new InstancedBinding(sourceInstance.Value, BindingPriority.Style);
-                }
+                return sourceInstance.WithPriority(BindingPriority.Style);
             }
-
-            return cloned;
         }
     }
 }
diff --git a/src/Avalonia.Themes.Default/Calendar.xaml b/src/Avalonia.Themes.Default/Calendar.xaml
new file mode 100644
index 0000000000..5e4306c217
--- /dev/null
+++ b/src/Avalonia.Themes.Default/Calendar.xaml
@@ -0,0 +1,30 @@
+<!--
+// (c) Copyright Microsoft Corporation.
+// This source is subject to the Microsoft Public License (Ms-PL).
+// Please see http://go.microsoft.com/fwlink/?LinkID=131993 for details.
+// All other rights reserved.
+-->
+
+<Styles xmlns="https://github.com/avaloniaui">
+  <Style Selector="Calendar">
+    <!--<Setter Property="Focusable" Value="False" />-->
+    <Setter Property="BorderThickness" Value="{DynamicResource ThemeBorderThickness}" />
+    <Setter Property="BorderBrush" Value="{DynamicResource ThemeBorderDarkBrush}" />
+    <Setter Property="Background" Value="{DynamicResource ThemeBackgroundBrush}" />
+    <Setter Property="HeaderBackground" Value="{DynamicResource ThemeAccentBrush2}" />
+    <Setter Property="Template">
+      <ControlTemplate>
+        <StackPanel Name="Root"
+                    HorizontalAlignment="Center">
+
+          <CalendarItem Name="CalendarItem"
+                        Background="{TemplateBinding Background}"
+                        BorderBrush="{TemplateBinding BorderBrush}"
+                        BorderThickness="{TemplateBinding BorderThickness}"
+                        HeaderBackground="{TemplateBinding HeaderBackground}"/>
+
+        </StackPanel>
+      </ControlTemplate>
+    </Setter>
+  </Style>
+</Styles>
\ No newline at end of file
diff --git a/src/Avalonia.Themes.Default/CalendarButton.xaml b/src/Avalonia.Themes.Default/CalendarButton.xaml
new file mode 100644
index 0000000000..5f3cba5c7a
--- /dev/null
+++ b/src/Avalonia.Themes.Default/CalendarButton.xaml
@@ -0,0 +1,80 @@
+<!--
+// (c) Copyright Microsoft Corporation.
+// This source is subject to the Microsoft Public License (Ms-PL).
+// Please see http://go.microsoft.com/fwlink/?LinkID=131993 for details.
+// All other rights reserved.
+-->
+
+<Styles xmlns="https://github.com/avaloniaui">
+  <Style Selector="CalendarButton">
+    <Setter Property="Background" Value="{DynamicResource ThemeAccentBrush2}" />
+    <Setter Property="FontSize" Value="{DynamicResource FontSizeSmall}" />
+    <Setter Property="HorizontalContentAlignment" Value="Center" />
+    <Setter Property="VerticalContentAlignment" Value="Center" />
+    <Setter Property="MinWidth" Value="37" />
+    <Setter Property="MinHeight" Value="38" />
+    <Setter Property="Focusable" Value="False"/>
+    <Setter Property="Template">
+      <ControlTemplate>
+        <Grid>
+
+          <Rectangle Name="SelectedBackground"
+                     Opacity="0.75"
+                     Fill="{TemplateBinding Background}"/>
+
+          <Rectangle Name="Background"
+                     Opacity="0.5"
+                     Fill="{TemplateBinding Background}"/>
+
+          <!--Focusable="False"-->
+          <ContentControl Name="Content"
+                          Foreground="#FF333333"
+                          Content="{TemplateBinding Content}"
+                          ContentTemplate="{TemplateBinding ContentTemplate}"
+                          HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
+                          VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
+                          FontSize="{TemplateBinding FontSize}"
+                          Margin="1,0,1,1"/>
+
+          <Rectangle Name="FocusVisual"
+                     StrokeThickness="1"
+                     Stroke="{DynamicResource HighlightBrush}"
+                     IsHitTestVisible="False"/>
+
+        </Grid>
+      </ControlTemplate>
+    </Setter>
+  </Style>
+
+  <Style Selector="CalendarButton /template/ Rectangle#Background">
+    <Setter Property="IsVisible" Value="False"/>
+  </Style>
+  <Style Selector="CalendarButton:pointerover /template/ Rectangle#Background">
+    <Setter Property="IsVisible" Value="True"/>
+  </Style>
+  <Style Selector="CalendarButton:pressed /template/ Rectangle#Background">
+    <Setter Property="IsVisible" Value="True"/>
+  </Style>
+
+  <Style Selector="CalendarButton /template/ Rectangle#SelectedBackground">
+    <Setter Property="IsVisible" Value="False"/>
+  </Style>
+  <Style Selector="CalendarButton:selected /template/ Rectangle#SelectedBackground">
+    <Setter Property="IsVisible" Value="True"/>
+  </Style>
+
+  <Style Selector="CalendarButton /template/ ContentControl#Content">
+    <Setter Property="Foreground" Value="{DynamicResource ThemeForegroundBrush}"/>
+  </Style>
+  <Style Selector="CalendarButton:inactive /template/ ContentControl#Content">
+    <Setter Property="Foreground" Value="{DynamicResource ThemeForegroundLightBrush}"/>
+  </Style>
+
+
+  <Style Selector="CalendarButton /template/ Rectangle#FocusVisual">
+    <Setter Property="IsVisible" Value="False"/>
+  </Style>
+  <Style Selector="CalendarButton:btnfocused /template/ Rectangle#FocusVisual">
+    <Setter Property="IsVisible" Value="True"/>
+  </Style>
+</Styles>
\ No newline at end of file
diff --git a/src/Avalonia.Themes.Default/CalendarDayButton.xaml b/src/Avalonia.Themes.Default/CalendarDayButton.xaml
new file mode 100644
index 0000000000..01c6e6a708
--- /dev/null
+++ b/src/Avalonia.Themes.Default/CalendarDayButton.xaml
@@ -0,0 +1,116 @@
+<!--
+// (c) Copyright Microsoft Corporation.
+// This source is subject to the Microsoft Public License (Ms-PL).
+// Please see http://go.microsoft.com/fwlink/?LinkID=131993 for details.
+// All other rights reserved.
+-->
+
+<Styles xmlns="https://github.com/avaloniaui">
+  <Style Selector="CalendarDayButton">
+    <Setter Property="Background" Value="{DynamicResource ThemeAccentBrush2}" />
+    <Setter Property="FontSize" Value="{DynamicResource FontSizeSmall}" />
+    <Setter Property="HorizontalContentAlignment" Value="Center" />
+    <Setter Property="VerticalContentAlignment" Value="Center" />
+    <Setter Property="MinWidth" Value="5" />
+    <Setter Property="MinHeight" Value="5" />
+    <Setter Property="Focusable" Value="False"/>
+    <Setter Property="Template">
+      <ControlTemplate>
+        <Panel Background="Transparent">
+
+          <Rectangle Name="TodayBackground"
+                     Fill="{DynamicResource HighlightBrush}"/>
+
+          <Rectangle Name="SelectedBackground"
+                     Opacity="0.75"
+                     Fill="{TemplateBinding Background}"/>
+
+          <Rectangle Name="Background"
+                     Opacity="0.5"
+                     Fill="{TemplateBinding Background}"/>
+
+          <ContentControl Name="Content"
+                          Content="{TemplateBinding Content}"
+                          ContentTemplate="{TemplateBinding ContentTemplate}"
+                          HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
+                          VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
+                          FontSize="{TemplateBinding FontSize}"
+                          Margin="5,1,5,1"/>
+
+          <Path Name="BlackoutVisual"
+                Margin="3"
+                HorizontalAlignment="Stretch"
+                VerticalAlignment="Stretch"
+                RenderTransformOrigin="0.5,0.5"
+                Fill="#FF000000"
+                Stretch="Fill"
+                Data="M8.1772461,11.029181 L10.433105,11.029181 L11.700684,12.801641 L12.973633,11.029181 L15.191895,11.029181 L12.844727,13.999395 L15.21875,17.060919 L12.962891,17.060919 L11.673828,15.256231 L10.352539,17.060919 L8.1396484,17.060919 L10.519043,14.042364 z" />
+          
+          <Rectangle Name="FocusVisual"
+                     StrokeThickness="1"
+                     Stroke="{DynamicResource HighlightBrush}"
+                     IsHitTestVisible="False"/>
+
+        </Panel>
+      </ControlTemplate>
+    </Setter>
+  </Style>
+
+  <Style Selector="CalendarDayButton /template/ Rectangle#Background">
+    <Setter Property="IsVisible" Value="False"/>
+  </Style>
+  <Style Selector="CalendarDayButton:pointerover /template/ Rectangle#Background">
+    <Setter Property="IsVisible" Value="True"/>
+  </Style>
+  <Style Selector="CalendarDayButton:pressed /template/ Rectangle#Background">
+    <Setter Property="IsVisible" Value="True"/>
+  </Style>
+
+  <Style Selector="CalendarDayButton /template/ Rectangle#SelectedBackground">
+    <Setter Property="IsVisible" Value="False"/>
+  </Style>
+  <Style Selector="CalendarDayButton:selected /template/ Rectangle#SelectedBackground">
+    <Setter Property="IsVisible" Value="True"/>
+  </Style>
+
+  <Style Selector="CalendarDayButton /template/ ContentControl#Content">
+    <Setter Property="Opacity" Value="1"/>
+    <Setter Property="Foreground" Value="{DynamicResource ThemeForegroundBrush}"/>
+  </Style>
+  <Style Selector="CalendarDayButton:disabled /template/ Rectangle#Background">
+    <Setter Property="IsVisible" Value="False"/>
+  </Style>
+  <Style Selector="CalendarDayButton:disabled /template/ ContentControl#Content">
+    <Setter Property="Opacity" Value="0.3"/>
+  </Style>
+
+  <Style Selector="CalendarDayButton /template/ Rectangle#FocusVisual">
+    <Setter Property="IsVisible" Value="False"/>
+  </Style>
+  <Style Selector="CalendarDayButton:dayfocused /template/ Rectangle#FocusVisual">
+    <Setter Property="IsVisible" Value="True"/>
+  </Style>
+
+  <Style Selector="CalendarDayButton /template/ Rectangle#TodayBackground">
+    <Setter Property="IsVisible" Value="False"/>
+  </Style>
+  <Style Selector="CalendarDayButton:today /template/ Rectangle#TodayBackground">
+    <Setter Property="IsVisible" Value="True"/>
+  </Style>
+
+
+  <Style Selector="CalendarDayButton:inactive /template/ ContentControl#Content">
+    <Setter Property="Foreground" Value="{DynamicResource ThemeForegroundLightBrush}"/>
+  </Style>
+  <Style Selector="CalendarDayButton:today /template/ ContentControl#Content">
+    <Setter Property="Foreground" Value="#FFFFFFFF"/>
+  </Style>
+
+  <Style Selector="CalendarDayButton /template/ Path#BlackoutVisual">
+    <Setter Property="Opacity" Value="0"/>
+  </Style>
+  <Style Selector="CalendarDayButton:blackout /template/ Path#BlackoutVisual">
+    <Setter Property="Opacity" Value="0.3"/>
+  </Style>  
+
+</Styles>
\ No newline at end of file
diff --git a/src/Avalonia.Themes.Default/CalendarItem.xaml b/src/Avalonia.Themes.Default/CalendarItem.xaml
new file mode 100644
index 0000000000..a9756fdb5f
--- /dev/null
+++ b/src/Avalonia.Themes.Default/CalendarItem.xaml
@@ -0,0 +1,183 @@
+<!--
+// (c) Copyright Microsoft Corporation.
+// This source is subject to the Microsoft Public License (Ms-PL).
+// Please see http://go.microsoft.com/fwlink/?LinkID=131993 for details.
+// All other rights reserved.
+-->
+
+<Styles xmlns="https://github.com/avaloniaui"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+  <Style Selector="CalendarItem">
+    <Setter Property="Template">
+      <ControlTemplate>
+        <Panel>
+          <Border BorderThickness="{TemplateBinding BorderThickness}"
+                  BorderBrush="{TemplateBinding BorderBrush}"
+                  Background="{TemplateBinding Background}"
+                  Margin="0,2,0,2"
+                  CornerRadius="1">
+
+            <Border CornerRadius="1"
+                    BorderBrush="{DynamicResource ThemeBackgroundBrush}"
+                    BorderThickness="2">
+              <Grid>
+                <Grid.RowDefinitions>
+                  <RowDefinition Height="Auto" />
+                  <RowDefinition Height="*" />
+                </Grid.RowDefinitions>
+                <Grid.ColumnDefinitions>
+                  <ColumnDefinition Width="Auto" />
+                  <ColumnDefinition Width="Auto" />
+                  <ColumnDefinition Width="Auto" />
+                </Grid.ColumnDefinitions>
+
+                <Grid.Styles>
+                  <Style Selector="Button.CalendarHeader">
+                    <Setter Property="Cursor" Value="Hand"/>
+                    <Setter Property="Background" Value="Transparent"/>
+                    <Setter Property="BorderThickness" Value="0"/>
+                  </Style>
+                    <Style Selector="Button.CalendarHeader:pressed  /template/ ContentPresenter">
+                    <Setter Property="Background" Value="Transparent"/>
+                  </Style>
+
+                  <Style Selector="Button.CalendarNavigation">
+                    <Setter Property="Height" Value="20"/>
+                    <Setter Property="Width" Value="28"/>
+                  </Style>
+                  <Style Selector="Button.CalendarNavigation > Path">
+                    <Setter Property="Fill" Value="{DynamicResource ThemeForegroundBrush}"/>
+                  </Style>
+                  <Style Selector="Button.CalendarNavigation:pointerover > Path">
+                    <Setter Property="Fill" Value="{DynamicResource HighlightBrush}"/>
+                  </Style>
+
+                  <Style Selector="Button#HeaderButton:pointerover">
+                    <Setter Property="Foreground" Value="{DynamicResource HighlightBrush}"/>
+                  </Style>
+                </Grid.Styles>
+
+                <Rectangle Grid.ColumnSpan="3"
+                           Fill="{TemplateBinding HeaderBackground}"
+                           Stretch="Fill"
+                           VerticalAlignment="Top"
+                           Height="22"/>
+
+                <Button Name="PreviousButton"
+                        Classes="CalendarHeader CalendarNavigation"
+                        IsVisible="False"
+                        HorizontalAlignment="Left">
+
+                  <Path Margin="14,-6,0,0"
+                        Height="10"
+                        Width="6"
+                        VerticalAlignment="Center"
+                        HorizontalAlignment="Left"
+                        Stretch="Fill"
+                        Data="M288.75,232.25 L288.75,240.625 L283,236.625 z" />
+                  
+                </Button>
+                
+                <Button Name="HeaderButton"
+                        Classes="CalendarHeader"
+                        Grid.Column="1"
+                        FontWeight="Bold"
+                        FontSize="10.5"
+                        HorizontalAlignment="Center"
+                        VerticalAlignment="Center" 
+                        Padding="1,5,1,9"/>
+
+                <Button Name="NextButton"
+                        Classes="CalendarHeader CalendarNavigation"
+                        Grid.Column="2"
+                        IsVisible="False"
+                        HorizontalAlignment="Right" >
+
+                  <Path Margin="0,-6,14,0"
+                        Height="10"
+                        Width="6"
+                        Stretch="Fill"
+                        VerticalAlignment="Center"
+                        HorizontalAlignment="Right"
+                        Data="M282.875,231.875 L282.875,240.375 L288.625,236 z" />
+                  
+                </Button>
+
+                <Grid Name="MonthView"
+                      Grid.Row="1"
+                      Grid.ColumnSpan="3"
+                      IsVisible="False"
+                      Margin="6,-1,6,6">
+                  <Grid.RowDefinitions>
+                    <RowDefinition Height="Auto" />
+                    <RowDefinition Height="Auto" />
+                    <RowDefinition Height="Auto" />
+                    <RowDefinition Height="Auto" />
+                    <RowDefinition Height="Auto" />
+                    <RowDefinition Height="Auto" />
+                    <RowDefinition Height="Auto" />
+                  </Grid.RowDefinitions>
+                  <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="Auto" />
+                  </Grid.ColumnDefinitions>
+                </Grid>
+
+                <Grid Name="YearView"
+                      Grid.Row="1"
+                      Grid.ColumnSpan="3"
+                      IsVisible="False"
+                      Margin="6,-3,7,6">
+                  <Grid.RowDefinitions>
+                    <RowDefinition Height="Auto" />
+                    <RowDefinition Height="Auto" />
+                    <RowDefinition Height="Auto" />
+                  </Grid.RowDefinitions>
+                  <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="Auto" />
+                  </Grid.ColumnDefinitions>
+                </Grid>
+
+              </Grid>
+            </Border>
+          </Border>
+
+
+          <Rectangle Name="DisabledVisual"
+                     Stretch="Fill"
+                     Fill="#FFFFFFFF"
+                     Opacity="{DynamicResource ThemeDisabledOpacity}"
+                     Margin="0,2,0,2" />
+
+        </Panel>
+      </ControlTemplate>
+    </Setter>
+    <Setter Property="DayTitleTemplate">
+      <Template>
+        <TextBlock FontWeight="Bold"
+                   FontSize="9.5"
+                   Margin="0,4,0,4"
+                   HorizontalAlignment="Center"
+                   VerticalAlignment="Center"
+                   Text="{Binding}" />
+      </Template>
+
+    </Setter>
+  </Style>
+
+  <Style Selector="CalendarItem /template/ Rectangle#DisabledVisual">
+    <Setter Property="IsVisible" Value="False"/>
+  </Style>
+  <Style Selector="CalendarItem:calendardisabled /template/ Rectangle#DisabledVisual">
+    <Setter Property="IsVisible" Value="True"/>
+  </Style>
+  
+</Styles>
\ No newline at end of file
diff --git a/src/Avalonia.Themes.Default/CheckBox.xaml b/src/Avalonia.Themes.Default/CheckBox.xaml
index 195ec098c9..ef96e7ed4f 100644
--- a/src/Avalonia.Themes.Default/CheckBox.xaml
+++ b/src/Avalonia.Themes.Default/CheckBox.xaml
@@ -12,14 +12,23 @@
                   Width="18"
                   Height="18"
                   VerticalAlignment="Center">
-            <Path Name="checkMark"
-                  Fill="{DynamicResource HighlightBrush}"
-                  Width="11"
-                  Height="10"
-                  Stretch="Uniform"
-                  HorizontalAlignment="Center"
-                  VerticalAlignment="Center"
-                  Data="M 1145.607177734375,430 C1145.607177734375,430 1141.449951171875,435.0772705078125 1141.449951171875,435.0772705078125 1141.449951171875,435.0772705078125 1139.232177734375,433.0999755859375 1139.232177734375,433.0999755859375 1139.232177734375,433.0999755859375 1138,434.5538330078125 1138,434.5538330078125 1138,434.5538330078125 1141.482177734375,438 1141.482177734375,438 1141.482177734375,438 1141.96875,437.9375 1141.96875,437.9375 1141.96875,437.9375 1147,431.34619140625 1147,431.34619140625 1147,431.34619140625 1145.607177734375,430 1145.607177734375,430 z"/>
+            <Panel>
+              <Path Name="checkMark"
+                    Fill="{DynamicResource HighlightBrush}"
+                    Width="11"
+                    Height="10"
+                    Stretch="Uniform"
+                    HorizontalAlignment="Center"
+                    VerticalAlignment="Center"
+                    Data="M 1145.607177734375,430 C1145.607177734375,430 1141.449951171875,435.0772705078125 1141.449951171875,435.0772705078125 1141.449951171875,435.0772705078125 1139.232177734375,433.0999755859375 1139.232177734375,433.0999755859375 1139.232177734375,433.0999755859375 1138,434.5538330078125 1138,434.5538330078125 1138,434.5538330078125 1141.482177734375,438 1141.482177734375,438 1141.482177734375,438 1141.96875,437.9375 1141.96875,437.9375 1141.96875,437.9375 1147,431.34619140625 1147,431.34619140625 1147,431.34619140625 1145.607177734375,430 1145.607177734375,430 z"/>
+              <Rectangle Name="indeterminateMark"
+                         Fill="{DynamicResource HighlightBrush}"
+                         Width="10"
+                         Height="10"
+                         Stretch="Uniform"
+                         HorizontalAlignment="Center"
+                         VerticalAlignment="Center"/>
+            </Panel>
           </Border>
           <ContentPresenter Name="PART_ContentPresenter"
                             Content="{TemplateBinding Content}"
@@ -37,9 +46,15 @@
   <Style Selector="CheckBox /template/ Path#checkMark">
     <Setter Property="IsVisible" Value="False"/>
   </Style>
+  <Style Selector="CheckBox /template/ Rectangle#indeterminateMark">
+    <Setter Property="IsVisible" Value="False"/>
+  </Style>
   <Style Selector="CheckBox:checked /template/ Path#checkMark">
     <Setter Property="IsVisible" Value="True"/>
   </Style>
+  <Style Selector="CheckBox:indeterminate /template/ Rectangle#indeterminateMark">
+    <Setter Property="IsVisible" Value="True"/>
+  </Style>
   <Style Selector="CheckBox:disabled /template/ Border#border">
     <Setter Property="Opacity" Value="{DynamicResource ThemeDisabledOpacity}"/>
   </Style>
diff --git a/src/Avalonia.Themes.Default/DefaultTheme.xaml b/src/Avalonia.Themes.Default/DefaultTheme.xaml
index 48f530cca8..ae00f0757a 100644
--- a/src/Avalonia.Themes.Default/DefaultTheme.xaml
+++ b/src/Avalonia.Themes.Default/DefaultTheme.xaml
@@ -36,4 +36,8 @@
   <StyleInclude Source="resm:Avalonia.Themes.Default.TreeViewItem.xaml?assembly=Avalonia.Themes.Default"/>
   <StyleInclude Source="resm:Avalonia.Themes.Default.Window.xaml?assembly=Avalonia.Themes.Default"/>
   <StyleInclude Source="resm:Avalonia.Themes.Default.EmbeddableControlRoot.xaml?assembly=Avalonia.Themes.Default"/>
+  <StyleInclude Source="resm:Avalonia.Themes.Default.CalendarButton.xaml?assembly=Avalonia.Themes.Default"/>
+  <StyleInclude Source="resm:Avalonia.Themes.Default.CalendarDayButton.xaml?assembly=Avalonia.Themes.Default"/>
+  <StyleInclude Source="resm:Avalonia.Themes.Default.CalendarItem.xaml?assembly=Avalonia.Themes.Default"/>
+  <StyleInclude Source="resm:Avalonia.Themes.Default.Calendar.xaml?assembly=Avalonia.Themes.Default"/>
 </Styles>
diff --git a/src/Avalonia.Themes.Default/RadioButton.xaml b/src/Avalonia.Themes.Default/RadioButton.xaml
index 996f46023e..0a0eb48564 100644
--- a/src/Avalonia.Themes.Default/RadioButton.xaml
+++ b/src/Avalonia.Themes.Default/RadioButton.xaml
@@ -20,6 +20,14 @@
                    UseLayoutRounding="False"
                    HorizontalAlignment="Center"
                    VerticalAlignment="Center"/>
+          <Ellipse Name="indeterminateMark"
+                   Fill="{DynamicResource ThemeAccentBrush}"
+                   Width="10"
+                   Height="10"
+                   Stretch="Uniform"
+                   UseLayoutRounding="False"
+                   HorizontalAlignment="Center"
+                   VerticalAlignment="Center"/>
           <ContentPresenter Name="PART_ContentPresenter"
                             Content="{TemplateBinding Content}"
                             ContentTemplate="{TemplateBinding ContentTemplate}"
@@ -36,9 +44,15 @@
   <Style Selector="RadioButton /template/ Ellipse#checkMark">
     <Setter Property="IsVisible" Value="False"/>
   </Style>
+  <Style Selector="RadioButton /template/ Ellipse#indeterminateMark">
+    <Setter Property="IsVisible" Value="False"/>
+  </Style>
   <Style Selector="RadioButton:checked /template/ Ellipse#checkMark">
     <Setter Property="IsVisible" Value="True"/>
   </Style>
+  <Style Selector="RadioButton:indeterminate /template/ Ellipse#indeterminateMark">
+    <Setter Property="IsVisible" Value="True"/>
+  </Style>
   <Style Selector="RadioButton:disabled /template/ Ellipse#border">
     <Setter Property="Opacity" Value="{DynamicResource ThemeDisabledOpacity}"/>
   </Style>
diff --git a/src/Avalonia.Visuals/Animation/PageSlide.cs b/src/Avalonia.Visuals/Animation/PageSlide.cs
index 015f22ec14..ebc358379d 100644
--- a/src/Avalonia.Visuals/Animation/PageSlide.cs
+++ b/src/Avalonia.Visuals/Animation/PageSlide.cs
@@ -15,6 +15,15 @@ namespace Avalonia.Animation
     /// </summary>
     public class PageSlide : IPageTransition
     {
+        /// <summary>
+        /// The axis on which the PageSlide should occur
+        /// </summary>
+        public enum SlideAxis
+        {
+            Horizontal,
+            Vertical
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="PageSlide"/> class.
         /// </summary>
@@ -26,9 +35,11 @@ namespace Avalonia.Animation
         /// Initializes a new instance of the <see cref="PageSlide"/> class.
         /// </summary>
         /// <param name="duration">The duration of the animation.</param>
-        public PageSlide(TimeSpan duration)
+        /// <param name="orientation">The axis on which the animation should occur</param>
+        public PageSlide(TimeSpan duration, SlideAxis orientation = SlideAxis.Horizontal)
         {
             Duration = duration;
+            Orientation = orientation;
         }
 
         /// <summary>
@@ -36,6 +47,11 @@ namespace Avalonia.Animation
         /// </summary>
         public TimeSpan Duration { get; set; }
 
+        /// <summary>
+        /// Gets the duration of the animation.
+        /// </summary>
+        public SlideAxis Orientation { get; set; }
+
         /// <summary>
         /// Starts the animation.
         /// </summary>
@@ -55,7 +71,8 @@ namespace Avalonia.Animation
         {
             var tasks = new List<Task>();
             var parent = GetVisualParent(from, to);
-            var distance = parent.Bounds.Width;
+            var distance = Orientation == SlideAxis.Horizontal ? parent.Bounds.Width : parent.Bounds.Height;
+            var translateProperty = Orientation == SlideAxis.Horizontal ? TranslateTransform.XProperty : TranslateTransform.YProperty;
 
             if (from != null)
             {
@@ -63,7 +80,7 @@ namespace Avalonia.Animation
                 from.RenderTransform = transform;
                 tasks.Add(Animate.Property(
                     transform,
-                    TranslateTransform.XProperty,
+                    translateProperty,
                     0.0,
                     forward ? -distance : distance,
                     LinearEasing.For<double>(),
@@ -77,7 +94,7 @@ namespace Avalonia.Animation
                 to.IsVisible = true;
                 tasks.Add(Animate.Property(
                     transform,
-                    TranslateTransform.XProperty,
+                    translateProperty,
                     forward ? distance : -distance,
                     0.0,
                     LinearEasing.For<double>(),
diff --git a/src/Gtk/Avalonia.Gtk3/Gtk3Platform.cs b/src/Gtk/Avalonia.Gtk3/Gtk3Platform.cs
index 2cf893346f..b687d9d447 100644
--- a/src/Gtk/Avalonia.Gtk3/Gtk3Platform.cs
+++ b/src/Gtk/Avalonia.Gtk3/Gtk3Platform.cs
@@ -35,6 +35,9 @@ namespace Avalonia.Gtk3
                     X11.XInitThreads();
                 }catch{}
                 Resolver.Resolve();
+                if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+                    using (var backends = new Utf8Buffer("x11"))
+                        Native.GdkSetAllowedBackends?.Invoke(backends);
                 Native.GtkInit(0, IntPtr.Zero);
                 var disp = Native.GdkGetDefaultDisplay();
                 DisplayClassName =
diff --git a/src/Gtk/Avalonia.Gtk3/Interop/Native.cs b/src/Gtk/Avalonia.Gtk3/Interop/Native.cs
index 3b9007786d..3e945798d4 100644
--- a/src/Gtk/Avalonia.Gtk3/Interop/Native.cs
+++ b/src/Gtk/Avalonia.Gtk3/Interop/Native.cs
@@ -48,10 +48,13 @@ namespace Avalonia.Gtk3.Interop
             public delegate void gtk_main_iteration();
 
             [UnmanagedFunctionPointer(CallingConvention.Cdecl), GtkImport(GtkDll.Gtk)]
-            public delegate GtkWindow gtk_window_new(GtkWindowType windowType);
-
+            public delegate GtkWindow gtk_window_new(GtkWindowType windowType);           
+            
             [UnmanagedFunctionPointer(CallingConvention.Cdecl), GtkImport(GtkDll.Gtk)]
             public delegate IntPtr gtk_init(int argc, IntPtr argv);
+            
+            [UnmanagedFunctionPointer(CallingConvention.Cdecl), GtkImport(GtkDll.Gdk, optional: true)]
+            public delegate IntPtr gdk_set_allowed_backends (Utf8Buffer backends);
 
             [UnmanagedFunctionPointer(CallingConvention.Cdecl), GtkImport(GtkDll.Gtk)]
             public delegate void gtk_window_present(GtkWindow gtkWindow);
@@ -393,6 +396,7 @@ namespace Avalonia.Gtk3.Interop
         public static D.gtk_window_new GtkWindowNew;
         public static D.gtk_window_set_icon GtkWindowSetIcon;
         public static D.gtk_window_set_modal GtkWindowSetModal;
+        public static D.gdk_set_allowed_backends GdkSetAllowedBackends;
         public static D.gtk_init GtkInit;
         public static D.gtk_window_present GtkWindowPresent;
         public static D.gtk_widget_hide GtkWidgetHide;
diff --git a/src/Markup/Avalonia.Markup.Xaml/Avalonia.Markup.Xaml.csproj b/src/Markup/Avalonia.Markup.Xaml/Avalonia.Markup.Xaml.csproj
index e07c22d750..a1db5c2915 100644
--- a/src/Markup/Avalonia.Markup.Xaml/Avalonia.Markup.Xaml.csproj
+++ b/src/Markup/Avalonia.Markup.Xaml/Avalonia.Markup.Xaml.csproj
@@ -39,7 +39,6 @@
         <Compile Include="MarkupExtensions\StaticResourceExtension.cs" />
         <Compile Include="MarkupExtensions\StyleIncludeExtension.cs" />
         <Compile Include="PortableXaml\AvaloniaXamlContext.cs" />
-        <Compile Include="PortableXaml\XamlBinding.cs" />
         <Compile Include="PortableXaml\AttributeExtensions.cs" />
         <Compile Include="PortableXaml\AvaloniaMemberAttributeProvider.cs" />
         <Compile Include="PortableXaml\AvaloniaNameScope.cs" />
@@ -73,8 +72,6 @@
         <Compile Include="Data\DelayedBinding.cs" />
         <Compile Include="Data\MultiBinding.cs" />
         <Compile Include="Data\RelativeSource.cs" />
-        <Compile Include="Data\StyleResourceBinding.cs" />
-        <Compile Include="MarkupExtensions\StyleResourceExtension.cs" />
         <Compile Include="MarkupExtensions\BindingExtension.cs" />
         <Compile Include="MarkupExtensions\RelativeSourceExtension.cs" />
         <Compile Include="MarkupExtensions\TemplateBindingExtension.cs" />
diff --git a/src/Markup/Avalonia.Markup.Xaml/Data/Binding.cs b/src/Markup/Avalonia.Markup.Xaml/Data/Binding.cs
index 3f12593197..eb5f87ea2a 100644
--- a/src/Markup/Avalonia.Markup.Xaml/Data/Binding.cs
+++ b/src/Markup/Avalonia.Markup.Xaml/Data/Binding.cs
@@ -83,6 +83,8 @@ namespace Avalonia.Markup.Xaml.Data
         /// </summary>
         public object Source { get; set; }
 
+        internal WeakReference DefaultAnchor { get; set; }
+
         /// <inheritdoc/>
         public InstancedBinding Initiate(
             IAvaloniaObject target,
@@ -92,6 +94,8 @@ namespace Avalonia.Markup.Xaml.Data
         {
             Contract.Requires<ArgumentNullException>(target != null);
 
+            anchor = anchor ?? DefaultAnchor?.Target;
+
             var pathInfo = ParsePath(Path);
             ValidateState(pathInfo);
             enableDataValidation = enableDataValidation && Priority == BindingPriority.LocalValue;
diff --git a/src/Markup/Avalonia.Markup.Xaml/Data/MultiBinding.cs b/src/Markup/Avalonia.Markup.Xaml/Data/MultiBinding.cs
index 621e06efba..3c29ed3a39 100644
--- a/src/Markup/Avalonia.Markup.Xaml/Data/MultiBinding.cs
+++ b/src/Markup/Avalonia.Markup.Xaml/Data/MultiBinding.cs
@@ -62,41 +62,20 @@ namespace Avalonia.Markup.Xaml.Data
             }
 
             var targetType = targetProperty?.PropertyType ?? typeof(object);
-            var result = new BehaviorSubject<object>(AvaloniaProperty.UnsetValue);
             var children = Bindings.Select(x => x.Initiate(target, null));
             var input = children.Select(x => x.Subject).CombineLatest().Select(x => ConvertValue(x, targetType));
-            input.Subscribe(result);
-            return new InstancedBinding(result, Mode, Priority);
-        }
-
-        /// <summary>
-        /// Applies a binding subject to a property on an instance.
-        /// </summary>
-        /// <param name="target">The target instance.</param>
-        /// <param name="property">The target property.</param>
-        /// <param name="subject">The binding subject.</param>
-        internal void Bind(IAvaloniaObject target, AvaloniaProperty property, ISubject<object> subject)
-        {
             var mode = Mode == BindingMode.Default ?
-                property.GetMetadata(target.GetType()).DefaultBindingMode : Mode;
+                targetProperty.GetMetadata(target.GetType()).DefaultBindingMode : Mode;
 
             switch (mode)
             {
-                case BindingMode.Default:
-                case BindingMode.OneWay:
-                    target.Bind(property, subject, Priority);
-                    break;
-                case BindingMode.TwoWay:
-                    throw new NotSupportedException("TwoWay MultiBinding not currently supported.");
                 case BindingMode.OneTime:
-                    target.GetObservable(Control.DataContextProperty).Subscribe(dataContext =>
-                    {
-                        subject.Take(1).Subscribe(x => target.SetValue(property, x, Priority));
-                    });                    
-                    break;
-                case BindingMode.OneWayToSource:
-                    target.GetObservable(property).Subscribe(subject);
-                    break;
+                    return InstancedBinding.OneTime(input, Priority);
+                case BindingMode.OneWay:
+                    return InstancedBinding.OneWay(input, Priority);
+                default:
+                    throw new NotSupportedException(
+                        "MultiBinding currently only supports OneTime and OneWay BindingMode.");
             }
         }
 
diff --git a/src/Markup/Avalonia.Markup.Xaml/Data/StyleResourceBinding.cs b/src/Markup/Avalonia.Markup.Xaml/Data/StyleResourceBinding.cs
deleted file mode 100644
index 787aebbdc6..0000000000
--- a/src/Markup/Avalonia.Markup.Xaml/Data/StyleResourceBinding.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright (c) The Avalonia Project. All rights reserved.
-// Licensed under the MIT license. See licence.md file in the project root for full license information.
-
-using System;
-using System.Reactive.Disposables;
-using System.Reactive.Linq;
-using System.Reactive.Subjects;
-using Avalonia.Controls;
-using Avalonia.Data;
-using Avalonia.Styling;
-
-namespace Avalonia.Markup.Xaml.Data
-{
-    public class StyleResourceBinding : IBinding
-    {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="StyleResourceBinding"/> class.
-        /// </summary>
-        /// <param name="name">The resource name.</param>
-        public StyleResourceBinding(string name)
-        {
-            Name = name;
-        }
-
-        /// <inheritdoc/>
-        public BindingMode Mode => BindingMode.OneTime;
-
-        /// <summary>
-        /// Gets the resource name.
-        /// </summary>
-        public string Name { get; }
-
-        /// <inheritdoc/>
-        public BindingPriority Priority => BindingPriority.LocalValue;
-
-        /// <inheritdoc/>
-        public InstancedBinding Initiate(
-            IAvaloniaObject target,
-            AvaloniaProperty targetProperty,
-            object anchor = null,
-            bool enableDataValidation = false)
-        {
-            var host = (target as IControl) ?? (anchor as IControl);
-            var style = anchor as IStyle;
-            var resource = AvaloniaProperty.UnsetValue;
-
-            if (host != null)
-            {
-                resource = host.FindResource(Name);
-            }
-            else if (style != null)
-            {
-                if (!style.TryGetResource(Name, out resource))
-                {
-                    resource = AvaloniaProperty.UnsetValue;
-                }
-            }
-
-            if (resource != AvaloniaProperty.UnsetValue)
-            {
-                return new InstancedBinding(resource, Priority);
-            }
-            else
-            {
-                return null;
-            }
-        }
-    }
-}
diff --git a/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/BindingExtension.cs b/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/BindingExtension.cs
index 9d1e36ee78..8984498393 100644
--- a/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/BindingExtension.cs
+++ b/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/BindingExtension.cs
@@ -7,8 +7,13 @@ using System;
 
 namespace Avalonia.Markup.Xaml.MarkupExtensions
 {
+    using Avalonia.Controls;
+    using Avalonia.Styling;
+    using Portable.Xaml;
+    using Portable.Xaml.ComponentModel;
     using Portable.Xaml.Markup;
     using PortableXaml;
+    using System.ComponentModel;
 
     [MarkupExtensionReturnType(typeof(IBinding))]
     public class BindingExtension : MarkupExtension
@@ -24,7 +29,7 @@ namespace Avalonia.Markup.Xaml.MarkupExtensions
 
         public override object ProvideValue(IServiceProvider serviceProvider)
         {
-            var b = new Binding
+            return new Binding
             {
                 Converter = Converter,
                 ConverterParameter = ConverterParameter,
@@ -33,10 +38,26 @@ namespace Avalonia.Markup.Xaml.MarkupExtensions
                 Mode = Mode,
                 Path = Path,
                 Priority = Priority,
-                RelativeSource = RelativeSource
+                RelativeSource = RelativeSource,
+                DefaultAnchor = new WeakReference(GetDefaultAnchor((ITypeDescriptorContext)serviceProvider))
             };
+        }
+
+
+        private static object GetDefaultAnchor(ITypeDescriptorContext context)
+        {
+            object anchor = null;
+
+            // The target is not a control, so we need to find an anchor that will let us look
+            // up named controls and style resources. First look for the closest IControl in
+            // the context.
+            anchor = context.GetFirstAmbientValue<IControl>();
 
-            return XamlBinding.FromMarkupExtensionContext(b, serviceProvider);
+            // If a control was not found, then try to find the highest-level style as the XAML
+            // file could be a XAML file containing only styles.
+            return anchor ??
+                    context.GetService<IRootObjectProvider>()?.RootObject as IStyle ??
+                    context.GetLastOrDefaultAmbientValue<IStyle>();
         }
 
         public IValueConverter Converter { get; set; }
diff --git a/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/DynamicResourceExtension.cs b/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/DynamicResourceExtension.cs
index 231778be09..52d9f043f4 100644
--- a/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/DynamicResourceExtension.cs
+++ b/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/DynamicResourceExtension.cs
@@ -51,7 +51,7 @@ namespace Avalonia.Markup.Xaml.MarkupExtensions
 
             if (control != null)
             {
-                return new InstancedBinding(control.GetResourceObservable(ResourceKey));
+                return InstancedBinding.OneWay(control.GetResourceObservable(ResourceKey));
             }
 
             return null;
diff --git a/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/StyleResourceExtension.cs b/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/StyleResourceExtension.cs
deleted file mode 100644
index 55a1b72125..0000000000
--- a/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/StyleResourceExtension.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// 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.Data;
-using Avalonia.Markup.Xaml.Data;
-using System;
-
-namespace Avalonia.Markup.Xaml.MarkupExtensions
-{
-    using Portable.Xaml.Markup;
-    using PortableXaml;
-
-    [MarkupExtensionReturnType(typeof(IBinding))]
-    public class StyleResourceExtension : MarkupExtension
-    {
-        public StyleResourceExtension(string name)
-        {
-            Name = name;
-        }
-
-        public override object ProvideValue(IServiceProvider serviceProvider)
-        {
-            return XamlBinding.FromMarkupExtensionContext(
-                            new StyleResourceBinding(Name),
-                            serviceProvider);
-        }
-
-        [ConstructorArgument("name")]
-        public string Name { get; set; }
-    }
-}
\ No newline at end of file
diff --git a/src/Markup/Avalonia.Markup.Xaml/PortableXaml/AvaloniaXamlType.cs b/src/Markup/Avalonia.Markup.Xaml/PortableXaml/AvaloniaXamlType.cs
index a38029964f..7de96ea220 100644
--- a/src/Markup/Avalonia.Markup.Xaml/PortableXaml/AvaloniaXamlType.cs
+++ b/src/Markup/Avalonia.Markup.Xaml/PortableXaml/AvaloniaXamlType.cs
@@ -212,11 +212,6 @@ namespace Avalonia.Markup.Xaml.PortableXaml
                                             value);
                 }
 
-                if (value is XamlBinding)
-                {
-                    value = (value as XamlBinding).Value;
-                }
-
                 if (UpdateListInsteadSet &&
                     value != null &&
                     UpdateListInsteadSetValue(instance, value))
@@ -317,9 +312,7 @@ namespace Avalonia.Markup.Xaml.PortableXaml
                         if (!Member.AssignBinding)
                             ApplyBinding(obj, (IBinding)value);
                         else
-                            obj.SetValue(Property, value is XamlBinding ?
-                                                        (value as XamlBinding).Value :
-                                                        value);
+                            obj.SetValue(Property, value);
                     }
                     else
                     {
@@ -348,12 +341,9 @@ namespace Avalonia.Markup.Xaml.PortableXaml
             {
                 var control = obj as IControl;
                 var property = Property;
-                var xamlBinding = binding as XamlBinding;
 
                 if (control != null && property != Control.DataContextProperty)
                     DelayedBinding.Add(control, property, binding);
-                else if (xamlBinding != null)
-                    obj.Bind(property, xamlBinding.Value, xamlBinding.Anchor?.Target);
                 else
                     obj.Bind(property, binding);
             }
diff --git a/src/Markup/Avalonia.Markup.Xaml/PortableXaml/XamlBinding.cs b/src/Markup/Avalonia.Markup.Xaml/PortableXaml/XamlBinding.cs
deleted file mode 100644
index 1f4e66471c..0000000000
--- a/src/Markup/Avalonia.Markup.Xaml/PortableXaml/XamlBinding.cs
+++ /dev/null
@@ -1,63 +0,0 @@
-using Avalonia.Controls;
-using Avalonia.Data;
-using Avalonia.Styling;
-using Portable.Xaml;
-using Portable.Xaml.ComponentModel;
-using System.ComponentModel;
-using Portable.Xaml.Markup;
-using System;
-
-namespace Avalonia.Markup.Xaml.PortableXaml
-{
-    internal class XamlBinding : IBinding
-    {
-        public static IBinding FromMarkupExtensionContext(
-                                    IBinding binding,
-                                    IServiceProvider serviceProvider)
-        {
-            var context = (ITypeDescriptorContext)serviceProvider;
-            var pvt = context.GetService<IProvideValueTarget>();
-
-            if (pvt.TargetObject is IControl) return binding;
-
-            object anchor = GetDefaultAnchor(context);
-
-            if (anchor == null) return binding;
-
-            return new XamlBinding(binding, anchor);
-        }
-
-        private static object GetDefaultAnchor(ITypeDescriptorContext context)
-        {
-            object anchor = null;
-
-            // The target is not a control, so we need to find an anchor that will let us look
-            // up named controls and style resources. First look for the closest IControl in
-            // the context.
-            anchor = context.GetFirstAmbientValue<IControl>();
-
-            // If a control was not found, then try to find the highest-level style as the XAML
-            // file could be a XAML file containing only styles.
-            return anchor ??
-                    context.GetService<IRootObjectProvider>()?.RootObject as IStyle ??
-                    context.GetLastOrDefaultAmbientValue<IStyle>();
-        }
-
-        private XamlBinding(IBinding binding, object anchor)
-        {
-            Value = binding;
-
-            Anchor = new WeakReference(anchor);
-        }
-
-        public WeakReference Anchor { get; }
-
-        public IBinding Value { get; }
-
-        public InstancedBinding Initiate(IAvaloniaObject target, AvaloniaProperty targetProperty, object anchor = null, bool enableDataValidation = false)
-        {
-            return Value.Initiate(target, targetProperty,
-                            anchor ?? Anchor.Target, enableDataValidation);
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/Markup/Avalonia.Markup.Xaml/Templates/TreeDataTemplate.cs b/src/Markup/Avalonia.Markup.Xaml/Templates/TreeDataTemplate.cs
index d6d3bd46ec..883e177f8a 100644
--- a/src/Markup/Avalonia.Markup.Xaml/Templates/TreeDataTemplate.cs
+++ b/src/Markup/Avalonia.Markup.Xaml/Templates/TreeDataTemplate.cs
@@ -42,7 +42,7 @@ namespace Avalonia.Markup.Xaml.Templates
             if (ItemsSource != null)
             {
                 var obs = new ExpressionObserver(item, ItemsSource.Path);
-                return new InstancedBinding(obs, BindingMode.OneWay, BindingPriority.Style);
+                return InstancedBinding.OneWay(obs, BindingPriority.Style);
             }
 
             return null;
diff --git a/src/OSX/Avalonia.MonoMac/EmulatedFramebuffer.cs b/src/OSX/Avalonia.MonoMac/EmulatedFramebuffer.cs
index 1ecfa0eb7d..935ab53432 100644
--- a/src/OSX/Avalonia.MonoMac/EmulatedFramebuffer.cs
+++ b/src/OSX/Avalonia.MonoMac/EmulatedFramebuffer.cs
@@ -2,44 +2,80 @@
 using Avalonia.Platform;
 using MonoMac.AppKit;
 using System.Runtime.InteropServices;
+using Avalonia.Threading;
 using MonoMac.CoreGraphics;
 
 namespace Avalonia.MonoMac
 {
     class EmulatedFramebuffer : ILockedFramebuffer
     {
+        private readonly TopLevelImpl.TopLevelView _view;
         private readonly CGSize _logicalSize;
-        public EmulatedFramebuffer(NSView view)
+        private readonly bool _isDeferred;
+
+        [DllImport("libc")]
+        static extern void memset(IntPtr p, int c, IntPtr size);
+
+        public EmulatedFramebuffer(TopLevelImpl.TopLevelView view)
         {
-            _logicalSize = view.Frame.Size;
-            var pixelSize = view.ConvertSizeToBacking(_logicalSize);
+            _view = view;
+
+            _isDeferred = !Dispatcher.UIThread.CheckAccess();
+            _logicalSize = _view.LogicalSize;
+            var pixelSize = _view.PixelSize;
             Width = (int)pixelSize.Width;
             Height = (int)pixelSize.Height;
             RowBytes = Width * 4;
             Dpi = new Vector(96 * pixelSize.Width / _logicalSize.Width, 96 * pixelSize.Height / _logicalSize.Height);
             Format = PixelFormat.Rgba8888;
-            Address = Marshal.AllocHGlobal(Height * RowBytes);
+            var size = Height * RowBytes;
+            Address = Marshal.AllocHGlobal(size);
+            memset(Address, 0, new IntPtr(size));
         }
-
+        
         public void Dispose()
         {
             if (Address == IntPtr.Zero)
                 return;
             var nfo = (int) CGBitmapFlags.ByteOrder32Big | (int) CGImageAlphaInfo.PremultipliedLast;
-
-            using (var colorSpace = CGColorSpace.CreateDeviceRGB())
-            using (var bContext = new CGBitmapContext(Address, Width, Height, 8, Width * 4,
-                colorSpace, (CGImageAlphaInfo) nfo))
-            using (var image = bContext.ToImage())
-            using (var nscontext = NSGraphicsContext.CurrentContext)
-            using (var context = nscontext.GraphicsPort)
+            CGImage image = null;
+            try
             {
-                context.SetFillColor(255, 255, 255, 255);
-                context.FillRect(new CGRect(default(CGPoint), _logicalSize));
-                context.DrawImage(new CGRect(default(CGPoint), _logicalSize), image);
+                using (var colorSpace = CGColorSpace.CreateDeviceRGB())
+                using (var bContext = new CGBitmapContext(Address, Width, Height, 8, Width * 4,
+                    colorSpace, (CGImageAlphaInfo)nfo))
+                    image = bContext.ToImage();
+                lock (_view.SyncRoot)
+                {
+                    if(!_isDeferred)
+                    {
+                        using (var nscontext = NSGraphicsContext.CurrentContext)
+                        using (var context = nscontext.GraphicsPort)
+                        {
+                            context.SetFillColor(255, 255, 255, 255);
+                            context.FillRect(new CGRect(default(CGPoint), _view.LogicalSize));
+                            context.TranslateCTM(0, _view.LogicalSize.Height - _logicalSize.Height);
+                            context.DrawImage(new CGRect(default(CGPoint), _logicalSize), image);
+                            context.Flush();
+                            nscontext.FlushGraphics();
+                        }
+                    }
+                }
             }
-            Marshal.FreeHGlobal(Address);
-            Address = IntPtr.Zero;
+            finally
+            {
+                if (image != null)
+                {
+                    if (!_isDeferred)
+                        image.Dispose();
+                    else
+                        _view.SetBackBufferImage(new SavedImage(image, _logicalSize));
+                }
+                Marshal.FreeHGlobal(Address);
+                Address = IntPtr.Zero;
+            }
+
+
         }
 
         public IntPtr Address { get; private set; }
@@ -49,4 +85,22 @@ namespace Avalonia.MonoMac
         public Vector Dpi { get; }
         public PixelFormat Format { get; }
     }
+
+    class SavedImage : IDisposable
+    {
+        public CGImage Image { get; private set; }
+        public CGSize LogicalSize { get; }
+
+        public SavedImage(CGImage image, CGSize logicalSize)
+        {
+            Image = image;
+            LogicalSize = logicalSize;
+        }
+
+        public void Dispose()
+        {
+            Image?.Dispose();
+            Image = null;
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/OSX/Avalonia.MonoMac/MonoMacPlatform.cs b/src/OSX/Avalonia.MonoMac/MonoMacPlatform.cs
index 0deea7fb44..a6b1f1d5b4 100644
--- a/src/OSX/Avalonia.MonoMac/MonoMacPlatform.cs
+++ b/src/OSX/Avalonia.MonoMac/MonoMacPlatform.cs
@@ -1,10 +1,13 @@
 using System;
+using System.Threading;
 using Avalonia.Controls;
 using Avalonia.Controls.Platform;
 using Avalonia.Input;
 using Avalonia.Platform;
 using Avalonia.Rendering;
 using MonoMac.AppKit;
+using MonoMac.Foundation;
+using MonoMac.ObjCRuntime;
 
 namespace Avalonia.MonoMac
 {
@@ -16,9 +19,11 @@ namespace Avalonia.MonoMac
         internal static NSApplication App;
         private static bool s_monoMacInitialized;
         private static bool s_showInDock = true;
+        private static IRenderLoop s_renderLoop;
 
         void DoInitialize()
         {
+            InitializeMonoMac();
             AvaloniaLocator.CurrentMutable
                 .Bind<IStandardCursorFactory>().ToTransient<CursorFactoryStub>()
                 .Bind<IPlatformIconLoader>().ToSingleton<IconLoader>()
@@ -27,9 +32,8 @@ namespace Avalonia.MonoMac
                 .Bind<IPlatformSettings>().ToConstant(this)
                 .Bind<IWindowingPlatform>().ToConstant(this)
                 .Bind<ISystemDialogImpl>().ToSingleton<SystemDialogsImpl>()
+                .Bind<IRenderLoop>().ToConstant(s_renderLoop)
                 .Bind<IPlatformThreadingInterface>().ToConstant(PlatformThreadingInterface.Instance);
-
-            InitializeMonoMac();
         }
 
         public static void Initialize()
@@ -39,13 +43,44 @@ namespace Avalonia.MonoMac
 
         }
 
+
+        /// <summary>
+        /// See "Using POSIX Threads in a Cocoa Application" section here:
+        /// https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/Multithreading/CreatingThreads/CreatingThreads.html#//apple_ref/doc/uid/20000738-125024
+        /// </summary>
+        class ThreadHelper : NSObject
+        {
+            private readonly AutoResetEvent _event = new AutoResetEvent(false);
+            private const string InitThreadingName = "initThreading";
+            [Export(InitThreadingName)]
+            public void DoNothing()
+            {
+                _event.Set();
+            }
+
+            public static void InitializeCocoaThreadingLocks()
+            {
+                var helper = new ThreadHelper();
+                var thread = new NSThread(helper, Selector.FromHandle(Selector.GetHandle(InitThreadingName)), new NSObject());
+                thread.Start();
+                helper._event.WaitOne();
+                helper._event.Dispose();
+                if (!NSThread.IsMultiThreaded)
+                {
+                    throw new Exception("Unable to initialize Cocoa threading");
+                }
+            }
+        }
+
         void InitializeMonoMac()
         {
             if(s_monoMacInitialized)
                 return;
             NSApplication.Init();
+            ThreadHelper.InitializeCocoaThreadingLocks();
             App = NSApplication.SharedApplication;
             UpdateActivationPolicy();
+            s_renderLoop = new RenderLoop(); //TODO: use CVDisplayLink
             s_monoMacInitialized = true;
         }
 
@@ -64,6 +99,7 @@ namespace Avalonia.MonoMac
             }
         }
 
+        public static bool UseDeferredRendering { get; set; } = true;
 
         public Size DoubleClickSize => new Size(4, 4);
         public TimeSpan DoubleClickTime => TimeSpan.FromSeconds(NSEvent.DoubleClickInterval);
@@ -87,9 +123,11 @@ namespace Avalonia
 {
     public static class MonoMacPlatformExtensions
     {
-        public static T UseMonoMac<T>(this T builder) where T : AppBuilderBase<T>, new()
+        public static T UseMonoMac<T>(this T builder, bool? useDeferredRendering = null) where T : AppBuilderBase<T>, new()
         {
-            return builder.UseWindowingSubsystem(MonoMac.MonoMacPlatform.Initialize);
+            if (useDeferredRendering.HasValue)
+                MonoMac.MonoMacPlatform.UseDeferredRendering = useDeferredRendering.Value;
+            return builder.UseWindowingSubsystem(MonoMac.MonoMacPlatform.Initialize, "MonoMac");
         }
     }
 }
\ No newline at end of file
diff --git a/src/OSX/Avalonia.MonoMac/PlatformThreadingInterface.cs b/src/OSX/Avalonia.MonoMac/PlatformThreadingInterface.cs
index 184416e77a..88189ba12c 100644
--- a/src/OSX/Avalonia.MonoMac/PlatformThreadingInterface.cs
+++ b/src/OSX/Avalonia.MonoMac/PlatformThreadingInterface.cs
@@ -3,14 +3,18 @@ using System.Threading;
 using Avalonia.Platform;
 using Avalonia.Threading;
 using MonoMac.AppKit;
+using MonoMac.CoreFoundation;
 using MonoMac.CoreGraphics;
 using MonoMac.Foundation;
+using MonoMac.ObjCRuntime;
 
 namespace Avalonia.MonoMac
 {
-    class PlatformThreadingInterface : IPlatformThreadingInterface
+    class PlatformThreadingInterface : NSObject, IPlatformThreadingInterface
     {
         private bool _signaled;
+        private const string SignaledSelectorName = "avaloniauiSignaled";
+        private readonly Selector _signaledSelector = new Selector(SignaledSelectorName);
         public static PlatformThreadingInterface Instance { get; } = new PlatformThreadingInterface();
         public bool CurrentThreadIsLoopThread => NSThread.Current.IsMainThread;
 
@@ -27,18 +31,25 @@ namespace Avalonia.MonoMac
                     return;
                 _signaled = true;
             }
-            NSApplication.SharedApplication.BeginInvokeOnMainThread(() =>
-            {
-                lock (this)
+            PerformSelector(_signaledSelector, NSThread.MainThread, this, false,
+                new[]
                 {
-                    if (!_signaled)
-                        return;
-                    _signaled = false;
-                }
-                Signaled?.Invoke(null);
-            });
+                    NSRunLoop.NSDefaultRunLoopMode, NSRunLoop.NSRunLoopEventTracking, NSRunLoop.NSRunLoopModalPanelMode,
+                    NSRunLoop.NSRunLoopCommonModes, NSRunLoop.NSRunLoopConnectionReplyMode
+                });
         }
 
+        [Export(SignaledSelectorName)]
+        public void CallSignaled()
+        {
+            lock (this)
+            {
+                if (!_signaled)
+                    return;
+                _signaled = false;
+            }
+            Signaled?.Invoke(null);
+        }
 
 
         public void RunLoop(CancellationToken cancellationToken)
@@ -55,6 +66,7 @@ namespace Avalonia.MonoMac
                 var ev = app.NextEvent(NSEventMask.AnyEvent, NSDate.DistantFuture, NSRunLoop.NSDefaultRunLoopMode, true);
                 if (ev != null)
                 {
+                    Console.WriteLine("NSEVENT");
                     app.SendEvent(ev);
                     ev.Dispose();
                 }
diff --git a/src/OSX/Avalonia.MonoMac/RenderLoop.cs b/src/OSX/Avalonia.MonoMac/RenderLoop.cs
new file mode 100644
index 0000000000..a6f3e9f493
--- /dev/null
+++ b/src/OSX/Avalonia.MonoMac/RenderLoop.cs
@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Avalonia.Platform;
+using Avalonia.Rendering;
+using MonoMac.Foundation;
+
+namespace Avalonia.MonoMac
+{
+    //TODO: Switch to using CVDisplayLink
+    public class RenderLoop : IRenderLoop
+    {
+        private readonly object _lock = new object();
+        private readonly IDisposable _timer;
+
+        public RenderLoop()
+        {
+            _timer = AvaloniaLocator.Current.GetService<IRuntimePlatform>().StartSystemTimer(new TimeSpan(0, 0, 0, 0, 1000 / 60),
+                () =>
+                {
+                    lock (_lock)
+                    {
+                        using (new NSAutoreleasePool())
+                        {
+                            Tick?.Invoke(this, EventArgs.Empty);
+                        }
+                    }
+                });
+        }
+
+        public event EventHandler<EventArgs> Tick;
+    }
+}
diff --git a/src/OSX/Avalonia.MonoMac/TopLevelImpl.cs b/src/OSX/Avalonia.MonoMac/TopLevelImpl.cs
index 2744474214..5ea7972871 100644
--- a/src/OSX/Avalonia.MonoMac/TopLevelImpl.cs
+++ b/src/OSX/Avalonia.MonoMac/TopLevelImpl.cs
@@ -5,8 +5,9 @@ using Avalonia.Input.Raw;
 using Avalonia.Platform;
 using Avalonia.Controls.Platform.Surfaces;
 using Avalonia.Rendering;
+using Avalonia.Threading;
 using MonoMac.AppKit;
-
+using MonoMac.CoreFoundation;
 using MonoMac.CoreGraphics;
 using MonoMac.Foundation;
 using MonoMac.ObjCRuntime;
@@ -24,6 +25,7 @@ namespace Avalonia.MonoMac
 
         protected virtual void OnInput(RawInputEventArgs args)
         {
+            Dispatcher.UIThread.RunJobs(DispatcherPriority.Input + 1);
             Input?.Invoke(args);
         }
 
@@ -36,6 +38,14 @@ namespace Avalonia.MonoMac
             private readonly IKeyboardDevice _keyboard;
             private NSTrackingArea _area;
             private NSCursor _cursor;
+            private bool _nonUiRedrawQueued;
+
+            public CGSize PixelSize { get; set; }
+
+            public CGSize LogicalSize { get; set; }
+
+            private SavedImage _backBuffer;
+            public object SyncRoot { get; } = new object();
 
             public TopLevelView(TopLevelImpl tl)
             {
@@ -44,17 +54,75 @@ namespace Avalonia.MonoMac
                 _keyboard = AvaloniaLocator.Current.GetService<IKeyboardDevice>();
             }
 
+            protected override void Dispose(bool disposing)
+            {
+                if (disposing)
+                {
+                    _backBuffer?.Dispose();
+                    _backBuffer = null;
+                }
+                base.Dispose(disposing);
+            }
+
             public override bool ConformsToProtocol(IntPtr protocol)
             {
                 var rv = base.ConformsToProtocol(protocol);
                 return rv;
             }
 
+            public override bool IsOpaque => false;
+
             public override void DrawRect(CGRect dirtyRect)
             {
+                lock (SyncRoot)
+                    _nonUiRedrawQueued = false;
+                Dispatcher.UIThread.RunJobs(DispatcherPriority.Render);
+                lock (SyncRoot)
+                {
+                    if (_backBuffer != null)
+                    {
+                        using (var context = NSGraphicsContext.CurrentContext.GraphicsPort)
+                        {
+                            context.SetFillColor(255, 255, 255, 255);
+                            context.FillRect(new CGRect(default(CGPoint), LogicalSize));
+                            context.TranslateCTM(0, LogicalSize.Height - _backBuffer.LogicalSize.Height);
+                            context.DrawImage(new CGRect(default(CGPoint), _backBuffer.LogicalSize), _backBuffer.Image);
+                            context.Flush();
+                            NSGraphicsContext.CurrentContext.FlushGraphics();
+                        }
+                    }
+                }
                 _tl.Paint?.Invoke(dirtyRect.ToAvaloniaRect());
             }
 
+            public void SetBackBufferImage(SavedImage image)
+            {
+                lock (SyncRoot)
+                {
+                    _backBuffer?.Dispose();
+                    _backBuffer = image;
+                    if (image == null)
+                        return;
+
+                    if (_nonUiRedrawQueued)
+                        return;
+                    _nonUiRedrawQueued = true;
+                    Dispatcher.UIThread.InvokeAsync(
+                        () =>
+                        {
+                            lock (SyncRoot)
+                            {
+                                if (!_nonUiRedrawQueued)
+                                    return;
+                                _nonUiRedrawQueued = false;
+                            }
+                            SetNeedsDisplayInRect(Frame);
+                            Display();
+                        }, DispatcherPriority.Render);
+
+                }
+            }
+            
             [Export("viewDidChangeBackingProperties:")]
             public void ViewDidChangeBackingProperties()
             {
@@ -78,7 +146,12 @@ namespace Avalonia.MonoMac
 
             public override void SetFrameSize(CGSize newSize)
             {
-                base.SetFrameSize(newSize);
+                lock (SyncRoot)
+                {
+                    base.SetFrameSize(newSize);
+                    LogicalSize = Frame.Size;
+                    PixelSize = ConvertSizeToBacking(LogicalSize);
+                }
 
                 if (_area != null)
                 {
@@ -92,6 +165,7 @@ namespace Avalonia.MonoMac
                 AddTrackingArea(_area);
                 UpdateCursor();
                 _tl?.Resized?.Invoke(_tl.ClientSize);
+                Dispatcher.UIThread.RunJobs(DispatcherPriority.Layout);
             }
 
             InputModifiers GetModifiers(NSEventModifierMask mod)
@@ -348,9 +422,16 @@ namespace Avalonia.MonoMac
             View.Dispose();
         }
 
-        public IRenderer CreateRenderer(IRenderRoot root) => new ImmediateRenderer(root);
+        public IRenderer CreateRenderer(IRenderRoot root) =>
+            MonoMacPlatform.UseDeferredRendering
+                ? new DeferredRenderer(root, AvaloniaLocator.Current.GetService<IRenderLoop>())
+                : (IRenderer) new ImmediateRenderer(root);
 
-        public void Invalidate(Rect rect) => View.SetNeedsDisplayInRect(View.Frame);
+        public void Invalidate(Rect rect)
+        {
+            if (!MonoMacPlatform.UseDeferredRendering)
+                View.SetNeedsDisplayInRect(View.Frame);
+        }
 
         public abstract Point PointToClient(Point point);
 
diff --git a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Binding.cs b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Binding.cs
index 66b237de06..4d6559a078 100644
--- a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Binding.cs
+++ b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_Binding.cs
@@ -428,7 +428,7 @@ namespace Avalonia.Base.UnitTests
                 object anchor = null,
                 bool enableDataValidation = false)
             {
-                return new InstancedBinding(_source, BindingMode.OneTime);
+                return InstancedBinding.OneTime(_source);
             }
         }
     }
diff --git a/tests/Avalonia.Controls.UnitTests/CalendarTests.cs b/tests/Avalonia.Controls.UnitTests/CalendarTests.cs
new file mode 100644
index 0000000000..4c45b1b230
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/CalendarTests.cs
@@ -0,0 +1,277 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using Xunit;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Avalonia.Controls.UnitTests
+{
+    public class CalendarTests
+    {
+        private static bool CompareDates(DateTime first, DateTime second)
+        {
+            return first.Year == second.Year && 
+                first.Month == second.Month &&
+                first.Day == second.Day;
+        }
+
+        [Fact]
+        public void SelectedDatesChanged_Should_Fire_When_SelectedDate_Set()
+        {
+            bool handled = false;
+            Calendar calendar = new Calendar();
+            calendar.SelectionMode = CalendarSelectionMode.SingleDate;
+            calendar.SelectedDatesChanged += new EventHandler<SelectionChangedEventArgs>(delegate
+            {
+                handled = true;
+            });
+            DateTime value = new DateTime(2000, 10, 10);
+            calendar.SelectedDate = value;
+            Assert.True(handled);
+        }
+
+        [Fact]
+        public void DisplayDateChanged_Should_Fire_When_DisplayDate_Set()
+        {
+            bool handled = false;
+            Calendar calendar = new Calendar();
+            calendar.SelectionMode = CalendarSelectionMode.SingleDate;
+            calendar.DisplayDateChanged += new EventHandler<CalendarDateChangedEventArgs>(delegate
+            {
+                handled = true;
+            });
+            DateTime value = new DateTime(2000, 10, 10);
+            calendar.DisplayDate = value;
+            Assert.True(handled);
+        }
+
+        [Fact]
+        public void Setting_Selected_Date_To_Blackout_Date_Should_Throw()
+        {
+            Calendar calendar = new Calendar();
+            calendar.BlackoutDates.AddDatesInPast();
+
+            Assert.ThrowsAny<ArgumentOutOfRangeException>(
+                () => calendar.SelectedDate = DateTime.Today.AddDays(-1));
+        }
+
+        [Fact]
+        public void Setting_Selected_Date_To_Blackout_Date_Should_Throw_Range()
+        {
+            Calendar calendar = new Calendar();
+            calendar.BlackoutDates.Add(new CalendarDateRange(DateTime.Today, DateTime.Today.AddDays(10)));
+
+            calendar.SelectedDate = DateTime.Today.AddDays(-1);
+            Assert.True(CompareDates(calendar.SelectedDate.Value, DateTime.Today.AddDays(-1)));
+            Assert.True(CompareDates(calendar.SelectedDate.Value, calendar.SelectedDates[0]));
+
+            calendar.SelectedDate = DateTime.Today.AddDays(11);
+            Assert.True(CompareDates(calendar.SelectedDate.Value, DateTime.Today.AddDays(11)));
+            Assert.True(CompareDates(calendar.SelectedDate.Value, calendar.SelectedDates[0]));
+
+            Assert.ThrowsAny<ArgumentOutOfRangeException>(
+                () => calendar.SelectedDate = DateTime.Today.AddDays(5));
+        }
+
+        [Fact]
+        public void Adding_Blackout_Dates_Containing_Selected_Date_Should_Throw()
+        {
+            Calendar calendar = new Calendar();
+            calendar.SelectedDate = DateTime.Today.AddDays(5);
+
+            Assert.ThrowsAny<ArgumentOutOfRangeException>(
+                () => calendar.BlackoutDates.Add(new CalendarDateRange(DateTime.Today, DateTime.Today.AddDays(10))));
+        }
+
+        [Fact]
+        public void DisplayDateStartEnd_Should_Constrain_Display_Date()
+        {
+            Calendar calendar = new Calendar();
+            calendar.SelectionMode = CalendarSelectionMode.SingleDate;
+            calendar.DisplayDateStart = new DateTime(2005, 12, 30);
+
+            DateTime value = new DateTime(2005, 12, 15);
+            calendar.DisplayDate = value;
+            Assert.True(CompareDates(calendar.DisplayDate, calendar.DisplayDateStart.Value));
+
+            value = new DateTime(2005, 12, 30);
+            calendar.DisplayDate = value;
+            Assert.True(CompareDates(calendar.DisplayDate, value));
+
+            value = DateTime.MaxValue;
+            calendar.DisplayDate = value;
+            Assert.True(CompareDates(calendar.DisplayDate, value));
+
+            calendar.DisplayDateEnd = new DateTime(2010, 12, 30);
+            Assert.True(CompareDates(calendar.DisplayDate, calendar.DisplayDateEnd.Value));
+        }
+
+        [Fact]
+        public void Setting_DisplayDateEnd_Should_Alter_DispalyDate_And_DisplayDateStart()
+        {
+            Calendar calendar = new Calendar();
+            DateTime value = new DateTime(2000, 1, 30);
+
+            calendar.DisplayDate = value;
+            calendar.DisplayDateEnd = value;
+            calendar.DisplayDateStart = value;
+            Assert.True(CompareDates(calendar.DisplayDateStart.Value, value));
+            Assert.True(CompareDates(calendar.DisplayDateEnd.Value, value));
+
+            value = value.AddMonths(2);
+            calendar.DisplayDateStart = value;
+            Assert.True(CompareDates(calendar.DisplayDateStart.Value, value));
+            Assert.True(CompareDates(calendar.DisplayDateEnd.Value, value));
+            Assert.True(CompareDates(calendar.DisplayDate, value));
+        }
+
+        [Fact]
+        public void Display_Date_Range_End_Will_Contain_SelectedDate()
+        {
+            Calendar calendar = new Calendar();
+            calendar.SelectionMode = CalendarSelectionMode.SingleDate;
+
+            calendar.SelectedDate = DateTime.MaxValue;
+            Assert.True(CompareDates((DateTime)calendar.SelectedDate, DateTime.MaxValue));
+
+            calendar.DisplayDateEnd = DateTime.MaxValue.AddDays(-1);
+            Assert.True(CompareDates((DateTime)calendar.DisplayDateEnd, DateTime.MaxValue));
+        }
+
+
+        /// <summary>
+        /// The days added to the SelectedDates collection.
+        /// </summary>
+        private IList<object> _selectedDatesChangedAddedDays;
+
+        /// <summary>
+        /// The days removed from the SelectedDates collection.
+        /// </summary>
+        private IList<object> _selectedDateChangedRemovedDays;
+
+        /// <summary>
+        /// The number of times the SelectedDatesChanged event has been fired.
+        /// </summary>
+        private int _selectedDatesChangedCount;
+
+        /// <summary>
+        /// Handle the SelectedDatesChanged event.
+        /// </summary>
+        /// <param name="sender">The calendar.</param>
+        /// <param name="e">Event arguments.</param>
+        private void OnSelectedDatesChanged(object sender, SelectionChangedEventArgs e)
+        {
+            _selectedDatesChangedAddedDays =
+                e.AddedItems
+                 .Cast<object>()
+                 .ToList();
+            _selectedDateChangedRemovedDays = 
+                e.RemovedItems
+                 .Cast<object>()
+                 .ToList();
+            _selectedDatesChangedCount++;
+        }
+
+        /// <summary>
+        /// Clear the variables used to track the SelectedDatesChanged event.
+        /// </summary>
+        private void ResetSelectedDatesChanged()
+        {
+            if (_selectedDatesChangedAddedDays != null)
+            {
+                _selectedDatesChangedAddedDays.Clear();
+            }
+
+            if (_selectedDateChangedRemovedDays != null)
+            {
+                _selectedDateChangedRemovedDays.Clear();
+            }
+
+            _selectedDatesChangedCount = 0;
+        }
+
+        [Fact]
+        public void SingleDate_Selection_Behavior()
+        {
+            ResetSelectedDatesChanged();
+            Calendar calendar = new Calendar();
+            calendar.SelectedDatesChanged += new EventHandler<SelectionChangedEventArgs>(OnSelectedDatesChanged);
+            calendar.SelectionMode = CalendarSelectionMode.SingleDate;
+            calendar.SelectedDate = DateTime.Today;
+            Assert.True(CompareDates(calendar.SelectedDate.Value, DateTime.Today));
+            Assert.True(calendar.SelectedDates.Count == 1);
+            Assert.True(CompareDates(calendar.SelectedDates[0], DateTime.Today));
+            Assert.True(_selectedDatesChangedCount == 1);
+            Assert.True(_selectedDatesChangedAddedDays.Count == 1);
+            Assert.True(_selectedDateChangedRemovedDays.Count == 0);
+            ResetSelectedDatesChanged();
+
+            calendar.SelectedDate = DateTime.Today;
+            Assert.True(CompareDates(calendar.SelectedDate.Value, DateTime.Today));
+            Assert.True(calendar.SelectedDates.Count == 1);
+            Assert.True(CompareDates(calendar.SelectedDates[0], DateTime.Today));
+            Assert.True(_selectedDatesChangedCount == 0);
+
+            calendar.ClearValue(Calendar.SelectedDateProperty);
+
+            calendar.SelectionMode = CalendarSelectionMode.None;
+            Assert.True(calendar.SelectedDates.Count == 0);
+            Assert.Null(calendar.SelectedDate);
+
+            calendar.SelectionMode = CalendarSelectionMode.SingleDate;
+
+            calendar.SelectedDates.Add(DateTime.Today.AddDays(1));
+            Assert.True(CompareDates(calendar.SelectedDate.Value, DateTime.Today.AddDays(1)));
+            Assert.True(calendar.SelectedDates.Count == 1);
+
+            Assert.ThrowsAny<InvalidOperationException>(
+                () => calendar.SelectedDates.Add(DateTime.Today.AddDays(2)));
+        }
+
+        [Fact]
+        public void SingleRange_Selection_Behavior()
+        {
+            ResetSelectedDatesChanged();
+            Calendar calendar = new Calendar();
+            calendar.SelectedDatesChanged += new EventHandler<SelectionChangedEventArgs>(OnSelectedDatesChanged);
+            calendar.SelectionMode = CalendarSelectionMode.SingleRange;
+            calendar.SelectedDate = DateTime.Today;
+            Assert.True(CompareDates(calendar.SelectedDate.Value, DateTime.Today));
+            Assert.True(calendar.SelectedDates.Count == 1);
+            Assert.True(CompareDates(calendar.SelectedDates[0], DateTime.Today));
+            Assert.True(_selectedDatesChangedCount == 1);
+            Assert.True(_selectedDatesChangedAddedDays.Count == 1);
+            Assert.True(_selectedDateChangedRemovedDays.Count == 0);
+            ResetSelectedDatesChanged();
+
+            calendar.SelectedDates.Clear();
+            Assert.Null(calendar.SelectedDate);
+            ResetSelectedDatesChanged();
+
+            calendar.SelectedDates.AddRange(DateTime.Today, DateTime.Today.AddDays(10));
+            Assert.True(CompareDates(calendar.SelectedDate.Value, DateTime.Today));
+            Assert.True(calendar.SelectedDates.Count == 11);
+            ResetSelectedDatesChanged();
+
+            calendar.SelectedDates.AddRange(DateTime.Today, DateTime.Today.AddDays(10));
+            Assert.True(calendar.SelectedDates.Count == 11);
+            Assert.True(_selectedDatesChangedCount == 0);
+            ResetSelectedDatesChanged();
+
+            calendar.SelectedDates.AddRange(DateTime.Today.AddDays(-20), DateTime.Today);
+            Assert.True(CompareDates(calendar.SelectedDate.Value, DateTime.Today.AddDays(-20)));
+            Assert.True(calendar.SelectedDates.Count == 21);
+            Assert.True(_selectedDatesChangedCount == 1);
+            Assert.True(_selectedDatesChangedAddedDays.Count == 21);
+            Assert.True(_selectedDateChangedRemovedDays.Count == 11);
+            ResetSelectedDatesChanged();
+
+            calendar.SelectedDates.Add(DateTime.Today.AddDays(100));
+            Assert.True(CompareDates(calendar.SelectedDate.Value, DateTime.Today.AddDays(100)));
+            Assert.True(calendar.SelectedDates.Count == 1);
+        }
+    }
+}
diff --git a/tests/Avalonia.Controls.UnitTests/ClassesTests.cs b/tests/Avalonia.Controls.UnitTests/ClassesTests.cs
index c9b9d9f82c..8d2e23d027 100644
--- a/tests/Avalonia.Controls.UnitTests/ClassesTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/ClassesTests.cs
@@ -161,5 +161,15 @@ namespace Avalonia.Controls.UnitTests
 
             Assert.Equal(new[] { ":baz" }, target);
         }
+
+        [Fact]
+        public void RemoveAll_Should_Remove_Classes()
+        {
+            var target = new Classes("foo", "bar", "baz");
+
+            target.RemoveAll(new[] { "bar", "baz" });
+
+            Assert.Equal(new[] { "foo" }, target);
+        }
     }
 }
diff --git a/tests/Avalonia.Controls.UnitTests/Primitives/PopupTests.cs b/tests/Avalonia.Controls.UnitTests/Primitives/PopupTests.cs
index ccbf04533d..85a450e1dc 100644
--- a/tests/Avalonia.Controls.UnitTests/Primitives/PopupTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/Primitives/PopupTests.cs
@@ -249,6 +249,37 @@ namespace Avalonia.Controls.UnitTests.Primitives
             }
         }
 
+        [Fact]
+        public void DataContextBeginUpdate_Should_Not_Be_Called_For_Controls_That_Dont_Inherit()
+        {
+            using (CreateServices())
+            {
+                TestControl child;
+                var popup = new Popup
+                {
+                    Child = child = new TestControl(),
+                    DataContext = "foo",
+                };
+
+                var beginCalled = false;
+                child.DataContextBeginUpdate += (s, e) => beginCalled = true;
+
+                // Test for #1245. Here, the child's logical parent is the popup but it's not yet
+                // attached to a visual tree because the popup hasn't been opened.
+                Assert.Same(popup, ((ILogical)child).LogicalParent);
+                Assert.Same(popup, child.InheritanceParent);
+                Assert.Null(child.GetVisualRoot());
+
+                popup.Open();
+
+                // #1245 was caused by the fact that DataContextBeginUpdate was called on `target`
+                // when the PopupRoot was created, even though PopupRoot isn't the
+                // InheritanceParent of child.
+                Assert.False(beginCalled);
+            }
+        }
+
+
         private static IDisposable CreateServices()
         {
             var result = AvaloniaLocator.EnterScope();
@@ -304,5 +335,18 @@ namespace Avalonia.Controls.UnitTests.Primitives
         private class PopupContentControl : ContentControl
         {
         }
+
+        private class TestControl : Decorator
+        {
+            public event EventHandler DataContextBeginUpdate;
+
+            public new IAvaloniaObject InheritanceParent => base.InheritanceParent;
+
+            protected override void OnDataContextBeginUpdate()
+            {
+                DataContextBeginUpdate?.Invoke(this, EventArgs.Empty);
+                base.OnDataContextBeginUpdate();
+            }
+        }
     }
 }
diff --git a/tests/Avalonia.Controls.UnitTests/Primitives/ToggleButtonTests.cs b/tests/Avalonia.Controls.UnitTests/Primitives/ToggleButtonTests.cs
new file mode 100644
index 0000000000..db60d05a34
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/Primitives/ToggleButtonTests.cs
@@ -0,0 +1,57 @@
+using Avalonia.Markup.Xaml.Data;
+using Avalonia.UnitTests;
+
+using Xunit;
+
+namespace Avalonia.Controls.Primitives.UnitTests
+{
+    public class ToggleButtonTests
+    {
+        private const string uncheckedClass = ":unchecked";
+        private const string checkedClass = ":checked";
+        private const string indeterminateClass = ":indeterminate";
+
+        [Theory]
+        [InlineData(false, uncheckedClass, false)]
+        [InlineData(false, uncheckedClass, true)]
+        [InlineData(true, checkedClass, false)]
+        [InlineData(true, checkedClass, true)]
+        [InlineData(null, indeterminateClass, false)]
+        [InlineData(null, indeterminateClass, true)]
+        public void ToggleButton_Has_Correct_Class_According_To_Is_Checked(bool? isChecked, string expectedClass, bool isThreeState)
+        {
+            var toggleButton = new ToggleButton();
+            toggleButton.IsThreeState = isThreeState;
+            toggleButton.IsChecked = isChecked;
+
+            Assert.Contains(expectedClass, toggleButton.Classes);
+        }
+
+        [Fact]
+        public void ToggleButton_Is_Checked_Binds_To_Bool()
+        {
+            var toggleButton = new ToggleButton();
+            var source = new Class1();
+
+            toggleButton.DataContext = source;
+            toggleButton.Bind(ToggleButton.IsCheckedProperty, new Binding("Foo"));
+
+            source.Foo = true;
+            Assert.True(toggleButton.IsChecked);
+
+            source.Foo = false;
+            Assert.False(toggleButton.IsChecked);
+        }
+
+        private class Class1 : NotifyingBase
+        {
+            private bool _foo;
+
+            public bool Foo
+            {
+                get { return _foo; }
+                set { _foo = value; RaisePropertyChanged(); }
+            }
+        }
+    }
+}
diff --git a/tests/Avalonia.Controls.UnitTests/RadioButtonTests.cs b/tests/Avalonia.Controls.UnitTests/RadioButtonTests.cs
new file mode 100644
index 0000000000..37fb52beeb
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/RadioButtonTests.cs
@@ -0,0 +1,36 @@
+using Avalonia.Markup.Xaml.Data;
+using Avalonia.UnitTests;
+
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests
+{
+    public class RadioButtonTests
+    {
+        [Theory]
+        [InlineData(false)]
+        [InlineData(true)]
+        public void Indeterminate_RadioButton_Is_Not_Unchecked_After_Checking_Other_Radio_Button(bool isThreeState)
+        {
+            var panel = new Panel();
+
+            var radioButton1 = new RadioButton();
+            radioButton1.IsThreeState = false;
+            radioButton1.IsChecked = false;
+
+            var radioButton2 = new RadioButton();
+            radioButton2.IsThreeState = isThreeState;
+            radioButton2.IsChecked = null;
+
+            panel.Children.Add(radioButton1);
+            panel.Children.Add(radioButton2);
+
+            Assert.Null(radioButton2.IsChecked);
+
+            radioButton1.IsChecked = true;
+
+            Assert.True(radioButton1.IsChecked);
+            Assert.Null(radioButton2.IsChecked);
+        }
+    }
+}
diff --git a/tests/Avalonia.Controls.UnitTests/TreeViewTests.cs b/tests/Avalonia.Controls.UnitTests/TreeViewTests.cs
index 29eac3d8f5..17eccc96bc 100644
--- a/tests/Avalonia.Controls.UnitTests/TreeViewTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/TreeViewTests.cs
@@ -515,7 +515,7 @@ namespace Avalonia.Controls.UnitTests
             public InstancedBinding ItemsSelector(object item)
             {
                 var obs = new ExpressionObserver(item, nameof(Node.Children));
-                return new InstancedBinding(obs);
+                return InstancedBinding.OneWay(obs);
             }
 
             public bool Match(object data)
diff --git a/tests/Avalonia.Layout.UnitTests/ShapeLayoutTests.cs b/tests/Avalonia.Layout.UnitTests/ShapeLayoutTests.cs
new file mode 100644
index 0000000000..2ccd6fb04c
--- /dev/null
+++ b/tests/Avalonia.Layout.UnitTests/ShapeLayoutTests.cs
@@ -0,0 +1,113 @@
+using System.Collections.Generic;
+using Avalonia.Controls;
+using Avalonia.Controls.Shapes;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.UnitTests;
+using Xunit;
+
+namespace Avalonia.Layout.UnitTests
+
+{
+    public class ShapeLayoutTests : TestWithServicesBase
+    {
+
+        public ShapeLayoutTests()
+        {
+            AvaloniaLocator.CurrentMutable
+                .Bind<IPlatformRenderInterface>().ToSingleton<MockPlatformRenderInterface>();
+        }
+
+        [Fact]
+        public void Shape_Transformation_Calculation_Should_Be_Deferred_To_Arrange_When_Strech_Is_Fill_And_Aviable_Size_Is_Infinite()
+        {
+            var shape = new Polygon()
+            {
+                Points = new List<Point>
+                {
+                    new Point(0, 0),
+                    new Point(10, 5),
+                    new Point(0, 10)
+                },
+                Stretch = Stretch.Fill
+            };
+
+            var availableSize = new Size(double.PositiveInfinity, double.PositiveInfinity);
+            shape.Measure(availableSize);
+            Geometry postMeasureGeometry = shape.RenderedGeometry;
+            Transform postMeasureTransform = postMeasureGeometry.Transform;
+
+            var finalSize = new Size(100, 50);
+            var finalRect = new Rect(finalSize);
+            shape.Arrange(finalRect);
+
+            Geometry postArrangeGeometry = shape.RenderedGeometry;
+            Transform postArrangeTransform = postArrangeGeometry.Transform;
+
+            Assert.NotEqual(postMeasureGeometry, postArrangeGeometry);
+            Assert.NotEqual(postMeasureTransform, postArrangeTransform);
+            Assert.Equal(finalSize, shape.Bounds.Size);
+        }
+
+        [Fact]
+        public void Shape_Transformation_Calculation_Should_Not_Be_Deferred_To_Arrange_When_Strech_Is_Fill_And_Aviable_Size_Is_Finite()
+        {
+            var shape = new Polygon()
+            {
+                Points = new List<Point>
+                {
+                    new Point(0, 0),
+                    new Point(10, 5),
+                    new Point(0, 10)
+                },
+                Stretch = Stretch.Fill
+            };
+
+            var availableSize = new Size(100, 50);
+            shape.Measure(availableSize);
+            Geometry postMeasureGeometry = shape.RenderedGeometry;
+            Transform postMeasureTransform = postMeasureGeometry.Transform;
+
+            var finalRect = new Rect(availableSize);
+            shape.Arrange(finalRect);
+
+            Geometry postArrangeGeometry = shape.RenderedGeometry;
+            Transform postArrangeTransform = postArrangeGeometry.Transform;
+
+            Assert.Equal(postMeasureGeometry, postArrangeGeometry);
+            Assert.Equal(postMeasureTransform, postArrangeTransform);
+            Assert.Equal(availableSize, shape.Bounds.Size);
+        }
+
+        [Fact]
+        public void Shape_Transformation_Calculation_Should_Not_Be_Deferred_To_Arrange_When_Strech_Is_None()
+        {
+            var shape = new Polygon()
+            {
+                Points = new List<Point>
+                {
+                    new Point(0, 0),
+                    new Point(10, 5),
+                    new Point(0, 10)
+                },
+                Stretch = Stretch.None
+            };
+
+            var availableSize = new Size(double.PositiveInfinity, double.PositiveInfinity);
+            shape.Measure(availableSize);
+            Geometry postMeasureGeometry = shape.RenderedGeometry;
+            Transform postMeasureTransform = postMeasureGeometry.Transform;
+
+            var finalSize = new Size(100, 50);
+            var finalRect = new Rect(finalSize);
+            shape.Arrange(finalRect);
+
+            Geometry postArrangeGeometry = shape.RenderedGeometry;
+            Transform postArrangeTransform = postArrangeGeometry.Transform;
+
+            Assert.Equal(postMeasureGeometry, postArrangeGeometry);
+            Assert.Equal(postMeasureTransform, postArrangeTransform);
+            Assert.Equal(finalSize, shape.Bounds.Size);
+        }
+    }
+}
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Avalonia.Markup.Xaml.UnitTests.csproj b/tests/Avalonia.Markup.Xaml.UnitTests/Avalonia.Markup.Xaml.UnitTests.csproj
index 03bb71a383..eb6dc8b5e5 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/Avalonia.Markup.Xaml.UnitTests.csproj
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/Avalonia.Markup.Xaml.UnitTests.csproj
@@ -8,7 +8,6 @@
   <Import Project="..\..\build\XUnit.props" />
   <Import Project="..\..\build\Rx.props" />
   <Import Project="..\..\build\Microsoft.Reactive.Testing.props" />
-  <Import Project="..\..\build\Splat.props" />
   <Import Project="..\..\build\Sprache.props" />
   <ItemGroup>
     <ProjectReference Include="..\..\src\Markup\Avalonia.Markup.Xaml\Avalonia.Markup.Xaml.csproj" />
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Data/MultiBindingTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Data/MultiBindingTests.cs
index 874dc18552..4450cc0c90 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/Data/MultiBindingTests.cs
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/Data/MultiBindingTests.cs
@@ -34,8 +34,8 @@ namespace Avalonia.Markup.Xaml.UnitTests.Data
             var target = new Mock<IAvaloniaObject>().As<IControl>();
             target.Setup(x => x.GetValue(Control.DataContextProperty)).Returns(source);
 
-            var subject = binding.Initiate(target.Object, null).Subject;
-            var result = await subject.Take(1);
+            var observable = binding.Initiate(target.Object, null).Observable;
+            var result = await observable.Take(1);
 
             Assert.Equal("1,2,3", result);
         }
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BasicTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BasicTests.cs
index 8c7dad1bce..03dc5374e0 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BasicTests.cs
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BasicTests.cs
@@ -411,8 +411,8 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
                 var xaml = @"
 <Styles xmlns='https://github.com/avaloniaui'>
   <Style Selector='CheckBox'>
-    <Setter Property='BorderBrush' Value='{StyleResource ThemeBorderMidBrush}'/>
-    <Setter Property='BorderThickness' Value='{StyleResource ThemeBorderThickness}'/>
+    <Setter Property='BorderBrush' Value='{DynamicResource ThemeBorderMidBrush}'/>
+    <Setter Property='BorderThickness' Value='{DynamicResource ThemeBorderThickness}'/>
     <Setter Property='Template'>
       <ControlTemplate>
         <Grid ColumnDefinitions='Auto,*'>
@@ -423,7 +423,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
                   Height='18'
                   VerticalAlignment='Center'>
             <Path Name='checkMark'
-                  Fill='{StyleResource HighlightBrush}'
+                  Fill='{StaticResource HighlightBrush}'
                   Width='11'
                   Height='10'
                   Stretch='Uniform'
@@ -457,8 +457,6 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
                 Assert.Equal(CheckBox.BorderThicknessProperty, setters[1].Property);
                 Assert.Equal(CheckBox.TemplateProperty, setters[2].Property);
 
-                Assert.IsType<StyleResourceBinding>(setters[0].Value);
-                Assert.IsType<StyleResourceBinding>(setters[1].Value);
                 Assert.IsType<ControlTemplate>(setters[2].Value);
             }
         }
@@ -772,15 +770,8 @@ do we need it?")]
 <Window xmlns='https://github.com/avaloniaui'
                 xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
                 xmlns:local='clr-namespace:Avalonia.Markup.Xaml.UnitTests.Xaml;assembly=Avalonia.Markup.Xaml.UnitTests'>
-    <Window.Styles>
-        <Style>
-            <Style.Resources>
-                <x:Double x:Key='Double'>100</x:Double>
-            </Style.Resources>
-        </Style>
-    </Window.Styles>
-    <local:InitializationOrderTracker Width='100' Height='{StyleResource Double}'
-                     Tag='{Binding Height, RelativeSource={RelativeSource Self}}' />
+    <local:InitializationOrderTracker Width='100' Height='100'
+        Tag='{Binding Height, RelativeSource={RelativeSource Self}}' />
 </Window>";
 
 
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs
index 65fc9eaddd..b339972029 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs
@@ -61,171 +61,6 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
             }
         }
 
-        [Fact]
-        public void StyleResource_Can_Be_Assigned_To_Property()
-        {
-            var xaml = @"
-<UserControl xmlns='https://github.com/avaloniaui'
-             xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>
-    <UserControl.Styles>
-        <Style>
-            <Style.Resources>
-                <SolidColorBrush x:Key='brush'>#ff506070</SolidColorBrush>
-            </Style.Resources>
-        </Style>
-    </UserControl.Styles>
-
-    <Border Name='border' Background='{StyleResource brush}'/>
-</UserControl>";
-
-            var loader = new AvaloniaXamlLoader();
-            var userControl = (UserControl)loader.Load(xaml);
-            var border = userControl.FindControl<Border>("border");
-
-            DelayedBinding.ApplyBindings(border);
-
-            var brush = (SolidColorBrush)border.Background;
-            Assert.Equal(0xff506070, brush.Color.ToUint32());
-        }
-
-        [Fact]
-        public void StyleResource_Can_Be_Assigned_To_Setter()
-        {
-            //skip default theme and styles, they are not needed
-            using (UnitTestApplication.Start(TestServices.StyledWindow
-                                        .With(theme: () => new Styles())))
-            {
-                var xaml = @"
-<Window xmlns='https://github.com/avaloniaui'
-        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>
-    <Window.Styles>
-        <Style>
-            <Style.Resources>
-                <SolidColorBrush x:Key='brush'>#ff506070</SolidColorBrush>
-            </Style.Resources>
-        </Style>
-        <Style Selector='Button'>
-            <Setter Property='Background' Value='{StyleResource brush}'/>
-        </Style>
-    </Window.Styles>
-    <Button Name='button'/>
-</Window>";
-
-                var loader = new AvaloniaXamlLoader();
-                var window = (Window)loader.Load(xaml);
-                var button = window.FindControl<Button>("button");
-                var brush = (SolidColorBrush)button.Background;
-
-                Assert.Equal(0xff506070, brush.Color.ToUint32());
-            }
-        }
-
-        [Fact]
-        public void StyleResource_Can_Be_Assigned_To_StyleResource_Property()
-        {
-            using (UnitTestApplication.Start(TestServices.StyledWindow))
-            {
-                var xaml = @"
-<Window xmlns='https://github.com/avaloniaui'
-        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>
-    <Window.Styles>
-        <Style>
-            <Style.Resources>
-                <Color x:Key='color'>#ff506070</Color>
-                <SolidColorBrush x:Key='brush' Color='{StyleResource color}'/>
-            </Style.Resources>
-        </Style>
-    </Window.Styles>
-    <Button Name='button' Background='{StyleResource brush}'/>
-</Window>";
-
-                var loader = new AvaloniaXamlLoader();
-                var window = (Window)loader.Load(xaml);
-                var brush = (ISolidColorBrush)window.FindResource("brush");
-                var button = window.FindControl<Button>("button");
-
-                DelayedBinding.ApplyBindings(button);
-
-                var buttonBrush = (ISolidColorBrush)button.Background;
-
-                Assert.Equal(0xff506070, brush.Color.ToUint32());
-                Assert.Equal(0xff506070, buttonBrush.Color.ToUint32());
-            }
-        }
-
-        [Fact]
-        public void StyleResource_Can_Be_Found_In_TopLevel_Styles()
-        {
-            var xaml = @"
-<Styles xmlns='https://github.com/avaloniaui'
-        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>
-    <Style>
-        <Style.Resources>
-            <Color x:Key='color'>#ff506070</Color>
-            <SolidColorBrush x:Key='brush' Color='{StyleResource color}'/>
-        </Style.Resources>
-    </Style>
-</Styles>";
-
-            var loader = new AvaloniaXamlLoader();
-            var styles = (Styles)loader.Load(xaml);
-
-            styles.TryGetResource("brush", out var brush);
-
-            Assert.Equal(0xff506070, ((SolidColorBrush)brush).Color.ToUint32());
-        }
-
-        [Fact]
-        public void StyleResource_Can_Be_Found_In_Sibling_Styles()
-        {
-            var xaml = @"
-<Styles xmlns='https://github.com/avaloniaui'
-        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>
-    <Style>
-        <Style.Resources>
-            <Color x:Key='color'>#ff506070</Color>
-        </Style.Resources>
-    </Style>
-    <Style>
-        <Style.Resources>
-            <SolidColorBrush x:Key='brush' Color='{StyleResource color}'/>
-        </Style.Resources>
-    </Style>
-</Styles>";
-
-            var loader = new AvaloniaXamlLoader();
-            var styles = (Styles)loader.Load(xaml);
-
-            styles.TryGetResource("brush", out var brush);
-
-            Assert.Equal(0xff506070, ((SolidColorBrush)brush).Color.ToUint32());
-        }
-
-        [Fact(Skip = "TODO: Issue #492")]
-        public void StyleResource_Can_Be_Found_Across_Xaml_Files()
-        {
-            using (UnitTestApplication.Start(TestServices.StyledWindow))
-            {
-                var xaml = @"
-<Window xmlns='https://github.com/avaloniaui'
-        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>
-    <Window.Styles>
-        <StyleInclude Source='resm:Avalonia.Markup.Xaml.UnitTests.Xaml.Style1.xaml?assembly=Avalonia.Markup.Xaml.UnitTests'/>
-        <StyleInclude Source='resm:Avalonia.Markup.Xaml.UnitTests.Xaml.Style2.xaml?assembly=Avalonia.Markup.Xaml.UnitTests'/>
-    </Window.Styles>
-    <Border Name='border' Background='{StyleResource RedBrush}'/>
-</Window>";
-
-                var loader = new AvaloniaXamlLoader();
-                var window = (Window)loader.Load(xaml);
-                var border = window.FindControl<Border>("border");
-                var borderBrush = (ISolidColorBrush)border.Background;
-
-                Assert.NotNull(borderBrush);
-                Assert.Equal(0xffff0000, borderBrush.Color.ToUint32());
-            }
-        }
-
         [Fact]
         public void StyleInclude_Is_Built()
         {
diff --git a/tests/Avalonia.Styling.UnitTests/SetterTests.cs b/tests/Avalonia.Styling.UnitTests/SetterTests.cs
index 9c43097a21..f376df4d0b 100644
--- a/tests/Avalonia.Styling.UnitTests/SetterTests.cs
+++ b/tests/Avalonia.Styling.UnitTests/SetterTests.cs
@@ -29,7 +29,7 @@ namespace Avalonia.Styling.UnitTests
         {
             var control = new TextBlock();
             var subject = new BehaviorSubject<object>("foo");
-            var descriptor = new InstancedBinding(subject);
+            var descriptor = InstancedBinding.OneWay(subject);
             var binding = Mock.Of<IBinding>(x => x.Initiate(control, TextBlock.TextProperty, null, false) == descriptor);
             var style = Mock.Of<IStyle>();
             var setter = new Setter(TextBlock.TextProperty, binding);
@@ -86,6 +86,77 @@ namespace Avalonia.Styling.UnitTests
             Assert.Null(control.Tag);
         }
 
+        [Fact]
+        public void Setter_Should_Apply_Value_Without_Activator_With_Style_Priority()
+        {
+            var control = new Mock<IStyleable>();
+            var style = Mock.Of<Style>();
+            var setter = new Setter(TextBlock.TextProperty, "foo");
+
+            setter.Apply(style, control.Object, null);
+
+            control.Verify(x => x.Bind(
+                TextBlock.TextProperty,
+                It.IsAny<IObservable<object>>(),
+                BindingPriority.Style));
+        }
+
+        [Fact]
+        public void Setter_Should_Apply_Value_With_Activator_With_StyleTrigger_Priority()
+        {
+            var control = new Mock<IStyleable>();
+            var style = Mock.Of<Style>();
+            var setter = new Setter(TextBlock.TextProperty, "foo");
+            var activator = new Subject<bool>();
+
+            setter.Apply(style, control.Object, activator);
+
+            control.Verify(x => x.Bind(
+                TextBlock.TextProperty,
+                It.IsAny<IObservable<object>>(),
+                BindingPriority.StyleTrigger));
+        }
+
+        [Fact]
+        public void Setter_Should_Apply_Binding_Without_Activator_With_Style_Priority()
+        {
+            var control = new Mock<IStyleable>();
+            var style = Mock.Of<Style>();
+            var setter = new Setter(TextBlock.TextProperty, CreateMockBinding(TextBlock.TextProperty));
+
+            setter.Apply(style, control.Object, null);
+
+            control.Verify(x => x.Bind(
+                TextBlock.TextProperty,
+                It.IsAny<IObservable<object>>(),
+                BindingPriority.Style));
+        }
+
+        [Fact]
+        public void Setter_Should_Apply_Binding_With_Activator_With_StyleTrigger_Priority()
+        {
+            var control = new Mock<IStyleable>();
+            var style = Mock.Of<Style>();
+            var setter = new Setter(TextBlock.TextProperty, CreateMockBinding(TextBlock.TextProperty));
+            var activator = new Subject<bool>();
+
+            setter.Apply(style, control.Object, activator);
+
+            control.Verify(x => x.Bind(
+                TextBlock.TextProperty,
+                It.IsAny<IObservable<object>>(),
+                BindingPriority.StyleTrigger));
+        }
+
+        private IBinding CreateMockBinding(AvaloniaProperty property)
+        {
+            var subject = new Subject<object>();
+            var descriptor = InstancedBinding.OneWay(subject);
+            var binding = Mock.Of<IBinding>(x => 
+                x.Initiate(It.IsAny<IAvaloniaObject>(), property, null, false) == descriptor);
+            return binding;
+        }
+
         private class TestConverter : IValueConverter
         {
             public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
diff --git a/tests/Avalonia.UnitTests/TestWithServicesBase.cs b/tests/Avalonia.UnitTests/TestWithServicesBase.cs
new file mode 100644
index 0000000000..bbd6c7427c
--- /dev/null
+++ b/tests/Avalonia.UnitTests/TestWithServicesBase.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Avalonia.UnitTests
+{
+    public class TestWithServicesBase : IDisposable
+    {
+        private IDisposable _scope;
+
+        public TestWithServicesBase()
+        {
+            _scope = AvaloniaLocator.EnterScope();
+        }
+
+        public void Dispose()
+        {
+            _scope.Dispose();
+        }
+    }
+}