Merge branch 'master' into new-animations-algo

src/Avalonia.Base/Data/Converters/StringFormatValueConverter.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Globalization;
+
+namespace Avalonia.Data.Converters
+{
+    /// <summary>
+    /// A value converter which calls <see cref="string.Format(string, object)"/>
+    /// </summary>
+    public class StringFormatValueConverter : IValueConverter
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StringFormatValueConverter"/> class.
+        /// </summary>
+        /// <param name="format">The format string.</param>
+        /// <param name="inner">
+        /// An optional inner converter to be called before the format takes place.
+        /// </param>
+        public StringFormatValueConverter(string format, IValueConverter inner)
+        {
+            Contract.Requires<ArgumentNullException>(format != null);
+
+            Format = format;
+            Inner = inner;
+        }
+
+        /// <summary>
+        /// Gets an inner value converter which will be called before the string format takes place.
+        /// </summary>
+        public IValueConverter Inner { get; }
+
+        /// <summary>
+        /// Gets the format string.
+        /// </summary>
+        public string Format { get; }
+
+        /// <inheritdoc/>
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            value = Inner?.Convert(value, targetType, parameter, culture) ?? value;
+            return string.Format(culture, Format, value);
+        }
+
+        /// <inheritdoc/>
+        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            throw new NotSupportedException("Two way bindings are not supported with a string format");
+        }
+    }
+}

src/Avalonia.Controls/Primitives/PopupRoot.cs

@@ -83,21 +83,22 @@ namespace Avalonia.Controls.Primitives
         /// </summary>
         public void SnapInsideScreenEdges()
         {
-            var window = this.GetSelfAndLogicalAncestors().OfType<Window>().First();
+            var screen = Application.Current.MainWindow?.Screens.ScreenFromPoint(Position);
-            
-            var screen = window.Screens.ScreenFromPoint(Position);
 
-            var screenX = Position.X + Bounds.Width - screen.Bounds.X;
+            if (screen != null)
-            var screenY = Position.Y + Bounds.Height - screen.Bounds.Y;
-
-            if (screenX > screen.Bounds.Width)
             {
-                Position = Position.WithX(Position.X - (screenX - screen.Bounds.Width));
+                var screenX = Position.X + Bounds.Width - screen.Bounds.X;
-            }
+                var screenY = Position.Y + Bounds.Height - screen.Bounds.Y;
 
-            if (screenY > screen.Bounds.Height)
+                if (screenX > screen.Bounds.Width)
-            {
+                {
-                Position = Position.WithY(Position.Y - (screenY - screen.Bounds.Height));
+                    Position = Position.WithX(Position.X - (screenX - screen.Bounds.Width));
+                }
+
+                if (screenY > screen.Bounds.Height)
+                {
+                    Position = Position.WithY(Position.Y - (screenY - screen.Bounds.Height));
+                }
             }
         }
 

src/Avalonia.DotNetCoreRuntime/Avalonia.DotNetCoreRuntime.csproj

@@ -10,6 +10,7 @@
     <ProjectReference Include="..\Gtk\Avalonia.Gtk3\Avalonia.Gtk3.csproj" />
     <ProjectReference Include="..\OSX\Avalonia.MonoMac\Avalonia.MonoMac.csproj" />
     <ProjectReference Include="..\Skia\Avalonia.Skia\Avalonia.Skia.csproj" />
+    <ProjectReference Include="..\Windows\Avalonia.Direct2D1\Avalonia.Direct2D1.csproj" />
     <ProjectReference Include="..\Windows\Avalonia.Win32\Avalonia.Win32.csproj" />
   </ItemGroup>  
   <Import Project="..\..\build\NetCore.props" />

src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/BindingExtension.cs

@@ -43,8 +43,9 @@ namespace Avalonia.Markup.Xaml.MarkupExtensions
                 Path = Path,
                 Priority = Priority,
                 Source = Source,
+                StringFormat = StringFormat,
                 RelativeSource = RelativeSource,
-                DefaultAnchor = new WeakReference(GetDefaultAnchor((ITypeDescriptorContext)serviceProvider))
+                DefaultAnchor = new WeakReference(GetDefaultAnchor(descriptorContext))
             };
         }
 
@@ -79,6 +80,8 @@ namespace Avalonia.Markup.Xaml.MarkupExtensions
 
         public object Source { get; set; }
 
+        public string StringFormat { get; set; }
+
         public RelativeSource RelativeSource { get; set; }
     }
 }

src/Markup/Avalonia.Markup/Data/Binding.cs

@@ -84,6 +84,11 @@ namespace Avalonia.Data
         /// </summary>
         public object Source { get; set; }
 
+        /// <summary>
+        /// Gets or sets the string format.
+        /// </summary>
+        public string StringFormat { get; set; }
+
         public WeakReference DefaultAnchor { get; set; }
 
         /// <summary>
@@ -181,11 +186,23 @@ namespace Avalonia.Data
                 fallback = null;
             }
 
+            var converter = Converter;
+            var targetType = targetProperty?.PropertyType ?? typeof(object);
+
+            // We only respect `StringFormat` if the type of the property we're assigning to will
+            // accept a string. Note that this is slightly different to WPF in that WPF only applies
+            // `StringFormat` for target type `string` (not `object`).
+            if (!string.IsNullOrWhiteSpace(StringFormat) && 
+                (targetType == typeof(string) || targetType == typeof(object)))
+            {
+                converter = new StringFormatValueConverter(StringFormat, converter);
+            }
+
             var subject = new BindingExpression(
                 observer,
-                targetProperty?.PropertyType ?? typeof(object),
+                targetType,
                 fallback,
-                Converter ?? DefaultValueConverter.Instance,
+                converter ?? DefaultValueConverter.Instance,
                 ConverterParameter,
                 Priority);
 

src/OSX/Avalonia.MonoMac/PopupImpl.cs

@@ -8,11 +8,23 @@ namespace Avalonia.MonoMac
         public PopupImpl()
         {
             UpdateStyle();
+            Window.Level = NSWindowLevel.PopUpMenu;
         }
 
         protected override NSWindowStyle GetStyle()
         {
             return NSWindowStyle.Borderless;
         }
+
+        protected override CustomWindow CreateCustomWindow() => new CustomPopupWindow(this);
+
+        private class CustomPopupWindow : CustomWindow
+        {
+            public CustomPopupWindow(WindowBaseImpl impl)
+                : base(impl)
+            { }
+
+            public override bool WorksWhenModal() => true;
+        }
     }
-}
+}

src/OSX/Avalonia.MonoMac/WindowBaseImpl.cs

@@ -14,17 +14,18 @@ namespace Avalonia.MonoMac
         private readonly ManagedWindowResizeDragHelper _managedDrag;
         public CustomWindow Window { get; private set; }
 
+        private bool _closed;
+
         public WindowBaseImpl()
         {
             _managedDrag = new ManagedWindowResizeDragHelper(this, _ => { }, ResizeForManagedDrag);
-            Window = new CustomWindow(this)
+            // ReSharper disable once VirtualMemberCallInConstructor
-            {
+            Window = CreateCustomWindow();
-                StyleMask = NSWindowStyle.Titled,
+            Window.StyleMask = NSWindowStyle.Titled;
-                BackingType = NSBackingStore.Buffered,
+            Window.BackingType = NSBackingStore.Buffered;
-                ContentView = View,
+            Window.ContentView = View;
-                // ReSharper disable once VirtualMemberCallInConstructor
+            // ReSharper disable once VirtualMemberCallInConstructor
-                Delegate = CreateWindowDelegate()
+            Window.Delegate = CreateWindowDelegate();
-            };
         }
 
         public class CustomWindow : NSWindow
@@ -55,6 +56,7 @@ namespace Avalonia.MonoMac
             public void SetCanBecomeKeyAndMain() => _canBecomeKeyAndMain = true;
         }
 
+        protected virtual CustomWindow CreateCustomWindow() => new CustomWindow(this);
         protected virtual NSWindowDelegate CreateWindowDelegate() => new WindowBaseDelegate(this);
 
         public class WindowBaseDelegate : NSWindowDelegate
@@ -78,9 +80,8 @@ namespace Avalonia.MonoMac
 
             public override void WillClose(global::MonoMac.Foundation.NSNotification notification)
             {
-                _impl.Window.Dispose();
+                _impl._closed = true;
-                _impl.Window = null;
+                _impl.Closed?.Invoke();
-                _impl.Dispose();
             }
 
             public override CGRect WillUseStandardFrame(NSWindow window, CGRect newFrame)
@@ -94,8 +95,19 @@ namespace Avalonia.MonoMac
             {
                 return true;
             }
+
+            public override void DidResize(NSNotification notification)
+            {
+                _impl.OnResized();
+            }
         }
 
+        /// <summary>
+        /// As you can't combine NSWindowDelegate overrides and events this is a workaround
+        /// </summary>
+        protected virtual void OnResized()
+        {
+        }
 
         public Point Position
         {
@@ -185,12 +197,11 @@ namespace Avalonia.MonoMac
             return cocoaScreenPoint.ConvertPointY().ToAvaloniaPoint();
         }
 
-
-
         public override void Dispose()
         {
-            Window?.Close();
+            if (!_closed)
-            Window?.Dispose();
+                Window.Close();
+            Window.Dispose();
             base.Dispose();
         }
     }

src/OSX/Avalonia.MonoMac/WindowImpl.cs

@@ -26,18 +26,19 @@ namespace Avalonia.MonoMac
             });
 
             Window.SetCanBecomeKeyAndMain();
-            
+        }
-            Window.DidResize += delegate
-            {
-                var windowState = Window.IsMiniaturized ? WindowState.Minimized
-                    : (IsZoomed ? WindowState.Maximized : WindowState.Normal);
 
-                if (windowState != _lastWindowState)
+        
-                {
+        protected override void OnResized()
-                    _lastWindowState = windowState;
+        {
-                    WindowStateChanged?.Invoke(windowState);
+            var windowState = Window.IsMiniaturized ? WindowState.Minimized
-                }
+                : (IsZoomed ? WindowState.Maximized : WindowState.Normal);
-            };
+
+            if (windowState != _lastWindowState)
+            {
+                _lastWindowState = windowState;
+                WindowStateChanged?.Invoke(windowState);
+            }
         }
 
         public WindowState WindowState
@@ -129,24 +130,47 @@ namespace Avalonia.MonoMac
         class ModalDisposable : IDisposable
         {
             readonly WindowImpl _impl;
+            readonly IntPtr _modalSession;
+            bool disposed;
 
-            public ModalDisposable(WindowImpl impl)
+            public ModalDisposable(WindowImpl impl, IntPtr modalSession)
             {
                 _impl = impl;
+                _modalSession = modalSession;
+            }
+
+            public void Continue()
+            {
+                if (disposed)
+                    return;
+
+                var response = (NSRunResponse)NSApplication.SharedApplication.RunModalSession(_modalSession);
+                if (response == NSRunResponse.Continues)
+                {
+                    Dispatcher.UIThread.Post(Continue, DispatcherPriority.ContextIdle);
+                }
+                else
+                {
+                    Logging.Logger.Log(Logging.LogEventLevel.Debug, "MonoMac", this, "Modal session ended");
+                }
             }
 
             public void Dispose()
             {
+                Logging.Logger.Log(Logging.LogEventLevel.Debug, "MonoMac", this, "ModalDisposable disposed");
                 _impl.Window.OrderOut(_impl.Window);
+                NSApplication.SharedApplication.EndModalSession(_modalSession);
+                disposed = true;
             }
         }
 
         public IDisposable ShowDialog()
         {
-            //TODO: Investigate how to return immediately. 
+            var session = NSApplication.SharedApplication.BeginModalSession(Window);
-            // May be add some magic to our run loop or something
+            var disposable = new ModalDisposable(this, session);
-            NSApplication.SharedApplication.RunModalForWindow(Window);
+            Dispatcher.UIThread.Post(disposable.Continue, DispatcherPriority.ContextIdle);
-            return new ModalDisposable(this);
+
+            return disposable;
         }
     }
-}
+}

tests/Avalonia.Controls.UnitTests/ContextMenuTests.cs

@@ -64,7 +64,10 @@ namespace Avalonia.Controls.UnitTests
                 {
                     ContextMenu = sut
                 };
-                new Window { Content = target };
+
+                var window = new Window { Content = target };
+
+                Avalonia.Application.Current.MainWindow = window;
 
                 target.RaiseEvent(new PointerReleasedEventArgs
                 {

tests/Avalonia.Markup.UnitTests/Data/BindingTests_Converters.cs

@@ -0,0 +1,146 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System;
+using Avalonia.Controls;
+using Avalonia.Data;
+using Avalonia.Data.Converters;
+using Avalonia.Data.Core;
+using Xunit;
+
+namespace Avalonia.Markup.UnitTests.Data
+{
+    public class BindingTests_Converters
+    {
+        [Fact]
+        public void Converter_Should_Be_Used()
+        {
+            var textBlock = new TextBlock
+            {
+                DataContext = new Class1(),
+            };
+
+            var target = new Binding(nameof(Class1.Foo))
+            {
+                Converter = StringConverters.NullOrEmpty,
+            };
+
+            var expressionObserver = (BindingExpression)target.Initiate(
+                textBlock, 
+                TextBlock.TextProperty).Observable;
+
+            Assert.Same(StringConverters.NullOrEmpty, expressionObserver.Converter);
+        }
+
+        public class When_Binding_To_String
+        {
+            [Fact]
+            public void StringFormatConverter_Should_Be_Used_When_Binding_Has_StringFormat()
+            {
+                var textBlock = new TextBlock
+                {
+                    DataContext = new Class1(),
+                };
+
+                var target = new Binding(nameof(Class1.Foo))
+                {
+                    StringFormat = "Hello {0}",
+                };
+
+                var expressionObserver = (BindingExpression)target.Initiate(
+                    textBlock,
+                    TextBlock.TextProperty).Observable;
+
+                Assert.IsType<StringFormatValueConverter>(expressionObserver.Converter);
+            }
+        }
+
+        public class When_Binding_To_Object
+        {
+            [Fact]
+            public void StringFormatConverter_Should_Be_Used_When_Binding_Has_StringFormat()
+            {
+                var textBlock = new TextBlock
+                {
+                    DataContext = new Class1(),
+                };
+
+                var target = new Binding(nameof(Class1.Foo))
+                {
+                    StringFormat = "Hello {0}",
+                };
+
+                var expressionObserver = (BindingExpression)target.Initiate(
+                    textBlock,
+                    TextBlock.TagProperty).Observable;
+
+                Assert.IsType<StringFormatValueConverter>(expressionObserver.Converter);
+            }
+        }
+
+        public class When_Binding_To_Non_String_Or_Object
+        {
+            [Fact]
+            public void StringFormatConverter_Should_Not_Be_Used_When_Binding_Has_StringFormat()
+            {
+                var textBlock = new TextBlock
+                {
+                    DataContext = new Class1(),
+                };
+
+                var target = new Binding(nameof(Class1.Foo))
+                {
+                    StringFormat = "Hello {0}",
+                };
+
+                var expressionObserver = (BindingExpression)target.Initiate(
+                    textBlock,
+                    TextBlock.MarginProperty).Observable;
+
+                Assert.Same(DefaultValueConverter.Instance, expressionObserver.Converter);
+            }
+        }
+
+        [Fact]
+        public void StringFormat_Should_Be_Applied()
+        {
+            var textBlock = new TextBlock
+            {
+                DataContext = new Class1(),
+            };
+
+            var target = new Binding(nameof(Class1.Foo))
+            {
+                StringFormat = "Hello {0}",
+            };
+
+            textBlock.Bind(TextBlock.TextProperty, target);
+
+            Assert.Equal("Hello foo", textBlock.Text);
+        }
+
+        [Fact]
+        public void StringFormat_Should_Be_Applied_After_Converter()
+        {
+            var textBlock = new TextBlock
+            {
+                DataContext = new Class1(),
+            };
+
+            var target = new Binding(nameof(Class1.Foo))
+            {
+                Converter = StringConverters.NotNullOrEmpty,
+                StringFormat = "Hello {0}",
+            };
+
+            textBlock.Bind(TextBlock.TextProperty, target);
+
+            Assert.Equal("Hello True", textBlock.Text);
+        }
+
+        private class Class1
+        {
+            public string Foo { get; set; } = "foo";
+        }
+    }
+}

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

@@ -308,5 +308,27 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
                 Assert.Equal(5.6, AttachedPropertyOwner.GetDouble(textBlock));
             }
         }
+
+        [Fact]
+        public void Binding_To_TextBlock_Text_With_StringConverter_Works()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var xaml = @"
+<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'>
+    <TextBlock Name='textBlock' Text='{Binding Foo, StringFormat=Hello \{0\}}'/> 
+</Window>"; 
+                var loader = new AvaloniaXamlLoader();
+                var window = (Window)loader.Load(xaml); 
+                var textBlock = window.FindControl<TextBlock>("textBlock"); 
+
+                textBlock.DataContext = new { Foo = "world" };
+                window.ApplyTemplate(); 
+
+                Assert.Equal("Hello world", textBlock.Text); 
+            }
+        } 
     }
 }