Merge branch 'master' into win32-nuget-fix

src/Avalonia.Controls/Screens.cs

@@ -39,7 +39,7 @@ namespace Avalonia.Controls
             return currMaxScreen;
         }
         
-        public Screen SceenFromPoint(Point point)
+        public Screen ScreenFromPoint(Point point)
         {
             return All.FirstOrDefault(x=>x.Bounds.Contains(point));        
         }

src/Avalonia.Controls/Window.cs

@@ -85,9 +85,19 @@ namespace Avalonia.Controls
         public static readonly StyledProperty<WindowIcon> IconProperty =
             AvaloniaProperty.Register<Window, WindowIcon>(nameof(Icon));
 
+        /// <summary>
+        /// Defines the <see cref="WindowStartupLocation"/> proeprty.
+        /// </summary>
+        public static readonly DirectProperty<Window, WindowStartupLocation> WindowStartupLocationProperty =
+            AvaloniaProperty.RegisterDirect<Window, WindowStartupLocation>(
+                nameof(WindowStartupLocation),
+                o => o.WindowStartupLocation,
+                (o, v) => o.WindowStartupLocation = v);
+
         private readonly NameScope _nameScope = new NameScope();
         private object _dialogResult;
         private readonly Size _maxPlatformClientSize;
+        private WindowStartupLocation _windowStartupLoction;
 
         /// <summary>
         /// Initializes static members of the <see cref="Window"/> class.
@@ -205,6 +215,15 @@ namespace Avalonia.Controls
             set { SetValue(IconProperty, value); }
         }
 
+        /// <summary>
+        /// Gets or sets the startup location of the window.
+        /// </summary>
+        public WindowStartupLocation WindowStartupLocation
+        {
+            get { return _windowStartupLoction; }
+            set { SetAndRaise(WindowStartupLocationProperty, ref _windowStartupLoction, value); }
+        }
+
         /// <inheritdoc/>
         Size ILayoutRoot.MaxClientSize => _maxPlatformClientSize;
 
@@ -274,6 +293,7 @@ namespace Avalonia.Controls
             s_windows.Add(this);
 
             EnsureInitialized();
+            SetWindowStartupLocation();
             IsVisible = true;
             LayoutManager.Instance.ExecuteInitialLayoutPass(this);
 
@@ -314,6 +334,7 @@ namespace Avalonia.Controls
             s_windows.Add(this);
 
             EnsureInitialized();
+            SetWindowStartupLocation();
             IsVisible = true;
             LayoutManager.Instance.ExecuteInitialLayoutPass(this);
 
@@ -352,6 +373,25 @@ namespace Avalonia.Controls
             }
         }
 
+        void SetWindowStartupLocation()
+        {
+            if (WindowStartupLocation == WindowStartupLocation.CenterScreen)
+            {
+                var screen = Screens.ScreenFromPoint(Bounds.Position);
+
+                if (screen != null)
+                    Position = screen.WorkingArea.CenterRect(new Rect(ClientSize)).Position;
+            }
+            else if (WindowStartupLocation == WindowStartupLocation.CenterOwner)
+            {
+                if (Owner != null)
+                {
+                    var positionAsSize = Owner.ClientSize / 2 - ClientSize / 2;
+                    Position = Owner.Position + new Point(positionAsSize.Width, positionAsSize.Height);
+                }
+            }
+        }
+
         /// <inheritdoc/>
         void INameScope.Register(string name, object element)
         {

src/Avalonia.Controls/WindowBase.cs

@@ -29,9 +29,19 @@ namespace Avalonia.Controls
         public static readonly DirectProperty<WindowBase, bool> IsActiveProperty =
             AvaloniaProperty.RegisterDirect<WindowBase, bool>(nameof(IsActive), o => o.IsActive);
 
+        /// <summary>
+        /// Defines the <see cref="Owner"/> property.
+        /// </summary>
+        public static readonly DirectProperty<WindowBase, WindowBase> OwnerProperty =
+            AvaloniaProperty.RegisterDirect<WindowBase, WindowBase>(
+                nameof(Owner),
+                o => o.Owner,
+                (o, v) => o.Owner = v);
+
         private bool _hasExecutedInitialLayoutPass;
         private bool _isActive;
         private bool _ignoreVisibilityChange;
+        private WindowBase _owner;
 
         static WindowBase()
         {
@@ -100,6 +110,15 @@ namespace Avalonia.Controls
             private set;
         }
 
+        /// <summary>
+        /// Gets or sets the owner of the window.
+        /// </summary>
+        public WindowBase Owner
+        {
+            get { return _owner; }
+            set { SetAndRaise(OwnerProperty, ref _owner, value); }
+        }
+
         /// <summary>
         /// Activates the window.
         /// </summary>

src/Avalonia.Controls/WindowStartupLocation.cs

@@ -0,0 +1,23 @@
+namespace Avalonia.Controls
+{
+    /// <summary>
+    /// Determines the startup location of the window.
+    /// </summary>
+    public enum WindowStartupLocation
+    {
+        /// <summary>
+        /// The startup location is defined by the Position property.
+        /// </summary>
+        Manual,
+
+        /// <summary>
+        /// The startup location is the center of the screen.
+        /// </summary>
+        CenterScreen,
+
+        /// <summary>
+        /// The startup location is the center of the owner window. If the owner window is not specified, the startup location will be <see cref="Manual"/>.
+        /// </summary>
+        CenterOwner
+    }
+}

src/Avalonia.DotNetCoreRuntime/AppBuilder.cs

@@ -10,6 +10,9 @@ using Avalonia.Shared.PlatformSupport;
 
 namespace Avalonia
 {
+    /// <summary>
+    /// Initializes platform-specific services for an <see cref="Application"/>.
+    /// </summary>
     public sealed class AppBuilder : AppBuilderBase<AppBuilder>
     {
         /// <summary>

src/Windows/Avalonia.Win32/ScreenImpl.cs

@@ -41,8 +41,8 @@ namespace Avalonia.Win32
                                 Rect avaloniaBounds = new Rect(bounds.left, bounds.top, bounds.right - bounds.left,
                                     bounds.bottom - bounds.top);
                                 Rect avaloniaWorkArea =
-                                    new Rect(workingArea.left, workingArea.top, workingArea.right - bounds.left,
-                                        workingArea.bottom - bounds.top);
+                                    new Rect(workingArea.left, workingArea.top, workingArea.right - workingArea.left,
+                                        workingArea.bottom - workingArea.top);
                                 screens[index] =
                                     new WinScreen(avaloniaBounds, avaloniaWorkArea, monitorInfo.dwFlags == 1,
                                         monitor);

tests/Avalonia.Controls.UnitTests/WindowTests.cs

@@ -70,7 +70,7 @@ namespace Avalonia.Controls.UnitTests
         }
 
         [Fact]
-        public void IsVisible_Should_Be_False_Atfer_Hide()
+        public void IsVisible_Should_Be_False_After_Hide()
         {
             using (UnitTestApplication.Start(TestServices.StyledWindow))
             {
@@ -84,7 +84,7 @@ namespace Avalonia.Controls.UnitTests
         }
 
         [Fact]
-        public void IsVisible_Should_Be_False_Atfer_Close()
+        public void IsVisible_Should_Be_False_After_Close()
         {
             using (UnitTestApplication.Start(TestServices.StyledWindow))
             {
@@ -98,7 +98,7 @@ namespace Avalonia.Controls.UnitTests
         }
 
         [Fact]
-        public void IsVisible_Should_Be_False_Atfer_Impl_Signals_Close()
+        public void IsVisible_Should_Be_False_After_Impl_Signals_Close()
         {
             var windowImpl = new Mock<IWindowImpl>();
             windowImpl.SetupProperty(x => x.Closed);
@@ -238,6 +238,83 @@ namespace Avalonia.Controls.UnitTests
             ((IList<Window>)Window.OpenWindows).Clear();
         }
 
+        [Fact]
+        public void Window_Should_Be_Centered_When_WindowStartupLocation_Is_CenterScreen()
+        {
+            var screen1 = new Mock<Screen>(new Rect(new Size(1920, 1080)), new Rect(new Size(1920, 1040)), true);
+            var screen2 = new Mock<Screen>(new Rect(new Size(1366, 768)), new Rect(new Size(1366, 728)), false);
+
+            var screens = new Mock<IScreenImpl>();
+            screens.Setup(x => x.AllScreens).Returns(new Screen[] { screen1.Object, screen2.Object });
+
+            var windowImpl = new Mock<IWindowImpl>();
+            windowImpl.SetupProperty(x => x.Position);
+            windowImpl.Setup(x => x.ClientSize).Returns(new Size(800, 480));
+            windowImpl.Setup(x => x.Scaling).Returns(1);
+            windowImpl.Setup(x => x.Screen).Returns(screens.Object);
+
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var window = new Window(windowImpl.Object);
+                window.WindowStartupLocation = WindowStartupLocation.CenterScreen;
+                window.Position = new Point(60, 40);
+
+                window.Show();
+
+                var expectedPosition = new Point(
+                    screen1.Object.WorkingArea.Size.Width / 2 - window.ClientSize.Width / 2,
+                    screen1.Object.WorkingArea.Size.Height / 2 - window.ClientSize.Height / 2);
+
+                Assert.Equal(window.Position, expectedPosition);
+            }
+        }
+
+        [Fact]
+        public void Window_Should_Be_Centered_Relative_To_Owner_When_WindowStartupLocation_Is_CenterOwner()
+        {
+            var parentWindowImpl = new Mock<IWindowImpl>();
+            parentWindowImpl.SetupProperty(x => x.Position);
+            parentWindowImpl.Setup(x => x.ClientSize).Returns(new Size(800, 480));
+            parentWindowImpl.Setup(x => x.MaxClientSize).Returns(new Size(1920, 1080));
+            parentWindowImpl.Setup(x => x.Scaling).Returns(1);
+
+            var windowImpl = new Mock<IWindowImpl>();
+            windowImpl.SetupProperty(x => x.Position);
+            windowImpl.Setup(x => x.ClientSize).Returns(new Size(320, 200));
+            windowImpl.Setup(x => x.MaxClientSize).Returns(new Size(1920, 1080));
+            windowImpl.Setup(x => x.Scaling).Returns(1);
+
+            var parentWindowServices = TestServices.StyledWindow.With(
+                windowingPlatform: new MockWindowingPlatform(() => parentWindowImpl.Object));
+
+            var windowServices = TestServices.StyledWindow.With(
+                windowingPlatform: new MockWindowingPlatform(() => windowImpl.Object));
+
+            using (UnitTestApplication.Start(parentWindowServices))
+            {
+                var parentWindow = new Window();
+                parentWindow.Position = new Point(60, 40);
+
+                parentWindow.Show();
+
+                using (UnitTestApplication.Start(windowServices))
+                {
+                    var window = new Window();
+                    window.WindowStartupLocation = WindowStartupLocation.CenterOwner;
+                    window.Position = new Point(60, 40);
+                    window.Owner = parentWindow;
+
+                    window.Show();
+
+                    var expectedPosition = new Point(
+                        parentWindow.Position.X + parentWindow.ClientSize.Width / 2 - window.ClientSize.Width / 2,
+                        parentWindow.Position.Y + parentWindow.ClientSize.Height / 2 - window.ClientSize.Height / 2);
+
+                    Assert.Equal(window.Position, expectedPosition);
+                }
+            }
+        }
+
         private IWindowImpl CreateImpl(Mock<IRenderer> renderer)
         {
             return Mock.Of<IWindowImpl>(x =>