Screen implementation

samples/ControlCatalog/ControlCatalog.csproj

@@ -75,6 +75,9 @@
     <EmbeddedResource Include="Pages\SliderPage.xaml">
       <SubType>Designer</SubType>
     </EmbeddedResource>
+    <EmbeddedResource Include="Pages\ScreenPage.xaml">
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
     <EmbeddedResource Include="Pages\TextBoxPage.xaml">
       <SubType>Designer</SubType>
     </EmbeddedResource>
@@ -136,7 +139,10 @@
     </Compile>
     <Compile Include="Pages\SliderPage.xaml.cs">
       <DependentUpon>SliderPage.xaml</DependentUpon>
-    </Compile>    
+    </Compile>
+    <Compile Include="Pages\ScreenPage.xaml.cs">
+      <DependentUpon>ScreenPage.xaml</DependentUpon>
+    </Compile>
     <Compile Include="Pages\TreeViewPage.xaml.cs">
       <DependentUpon>TreeViewPage.xaml</DependentUpon>
     </Compile>

samples/ControlCatalog/MainView.xaml.cs

@@ -13,11 +13,20 @@ public MainView()
         {
             this.InitializeComponent();
             if (AvaloniaLocator.Current.GetService<IRuntimePlatform>().GetRuntimeInfo().IsDesktop)
-                ((IList) this.FindControl<TabControl>("Sidebar").Items).Add(new TabItem()
-                {
-                    Header = "Dialogs",
-                    Content = new DialogsPage()
-                });
+            {
+                IList tabItems = ((IList)this.FindControl<TabControl>("Sidebar").Items);
+                tabItems.Add(new TabItem()
+                                                                           {
+                                                                               Header = "Dialogs",
+                                                                               Content = new DialogsPage()
+                                                                           });
+                tabItems.Add(new TabItem()
+                             {
+                                 Header = "Screens",
+                                 Content = new ScreenPage()
+                             });
+
+            }
         }
 
         private void InitializeComponent()

samples/ControlCatalog/MainWindow.xaml.cs

@@ -11,7 +11,7 @@ public MainWindow()
         {
             this.InitializeComponent();
             this.AttachDevTools();
-            //Renderer.DrawDirtyRects = Renderer.DrawFps = true;
+            Renderer.DrawDirtyRects = Renderer.DrawFps = true;
         }
 
         private void InitializeComponent()

samples/ControlCatalog/Pages/ScreenPage.xaml

@@ -0,0 +1,3 @@
+<UserControl xmlns="https://github.com/avaloniaui">
+
+</UserControl>

samples/ControlCatalog/Pages/ScreenPage.xaml.cs

@@ -0,0 +1,72 @@
+using System;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+using Avalonia.Media;
+using Avalonia.Platform;
+
+namespace ControlCatalog.Pages
+{
+    public class ScreenPage : UserControl
+    {
+        private double leftMost;
+
+        public ScreenPage()
+        {
+            this.InitializeComponent();
+        }
+
+        private void InitializeComponent()
+        {
+            AvaloniaXamlLoader.Load(this);
+        }
+
+        protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
+        {
+            base.OnAttachedToVisualTree(e);
+            Window w = (Window)VisualRoot;
+            w.PositionChanged += (sender, args) => InvalidateVisual();
+        }
+
+        public override void Render(DrawingContext context)
+        {
+            base.Render(context);
+            Window w = (Window)VisualRoot;
+            Screen[] screens = w.Screens.All;
+
+            Pen p = new Pen(Brushes.Black);
+            if (screens != null)
+                foreach (Screen screen in screens)
+                {
+                    if (screen.Bounds.X / 10f < leftMost)
+                    {
+                        leftMost = screen.Bounds.X / 10f;
+                        InvalidateVisual();
+                        return;
+                    }
+
+                    Rect boundsRect = new Rect(screen.Bounds.X / 10f + Math.Abs(leftMost), screen.Bounds.Y / 10f, screen.Bounds.Width / 10f,
+                                      screen.Bounds.Height / 10f);
+                    Rect workingAreaRect = new Rect(screen.WorkingArea.X / 10f + Math.Abs(leftMost), screen.WorkingArea.Y / 10f, screen.WorkingArea.Width / 10f,
+                                       screen.WorkingArea.Height / 10f);
+                    context.DrawRectangle(p, boundsRect);
+                    context.DrawRectangle(p, workingAreaRect);
+
+                    FormattedText text = new FormattedText();
+                    text.Text = $"Bounds: {screen.Bounds.Width}:{screen.Bounds.Height}";
+                    context.DrawText(Brushes.Black, boundsRect.Position.WithY(boundsRect.Size.Height), text);
+
+                    text.Text = $"WorkArea: {screen.WorkingArea.Width}:{screen.WorkingArea.Height}";
+                    context.DrawText(Brushes.Black, boundsRect.Position.WithY(boundsRect.Size.Height + 20), text);
+
+                    text.Text = $"Primary: {screen.Primary}";
+                    context.DrawText(Brushes.Black, boundsRect.Position.WithY(boundsRect.Size.Height + 40), text);
+
+                    text.Text = $"Current: {screen.Equals(w.Screens.ScreenFromBounds(new Rect(w.Position, w.Bounds.Size)))}";
+                    context.DrawText(Brushes.Black, boundsRect.Position.WithY(boundsRect.Size.Height + 60), text);
+                }
+
+            context.DrawRectangle(p, new Rect(w.Position.X / 10f + Math.Abs(leftMost), w.Position.Y / 10, w.Bounds.Width / 10, w.Bounds.Height / 10));
+        }
+    }
+}

src/Android/Avalonia.Android/Platform/SkiaPlatform/PopupImpl.cs

@@ -36,6 +36,8 @@ public void Resize(Size value)
             _clientSize = value;
             UpdateParams();
         }
+
+        public IScreenImpl Screen { get; }
 
         public Point Position
         {

src/Avalonia.Controls/Platform/IScreenImpl.cs

@@ -0,0 +1,9 @@
+namespace Avalonia.Platform
+{
+    public interface IScreenImpl
+    {
+        int ScreenCount { get; }
+
+        Screen[] AllScreens { get; }
+    }
+}

src/Avalonia.Controls/Platform/IWindowBaseImpl.cs

@@ -65,5 +65,10 @@ public interface IWindowBaseImpl : ITopLevelImpl
         /// Sets the client size of the toplevel.
         /// </summary>
         void Resize(Size clientSize);
+
+        /// <summary>
+        /// Gets platform specific display information
+        /// </summary>
+        IScreenImpl Screen { get; }
     }
 }

src/Avalonia.Controls/Platform/Screen.cs

@@ -0,0 +1,18 @@
+namespace Avalonia.Platform
+{
+    public class Screen
+    {
+        public Rect Bounds { get; }
+
+        public Rect WorkingArea { get; }
+
+        public bool Primary { get; }
+
+        public Screen(Rect bounds, Rect workingArea, bool primary)
+        {
+            this.Bounds = bounds;
+            this.WorkingArea = workingArea;
+            this.Primary = primary;
+        } 
+    }
+}

src/Avalonia.Controls/Screens.cs

@@ -0,0 +1,54 @@
+using System.Linq;
+using Avalonia.Platform;
+using Avalonia.Utilities;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Controls
+{
+    public class Screens
+    {
+        private readonly IScreenImpl _iScreenImpl;
+
+        public int ScreenCount => _iScreenImpl.ScreenCount;
+        public Screen[] All => _iScreenImpl?.AllScreens;
+        public Screen Primary => All.FirstOrDefault(x => x.Primary);
+
+        public Screens(IScreenImpl iScreenImpl)
+        {
+            _iScreenImpl = iScreenImpl;
+        }
+
+        public Screen ScreenFromBounds(Rect bounds){
+
+            Screen currMaxScreen = null;
+            double maxAreaSize = 0;
+            foreach (Screen screen in All)
+            {
+                double left = MathUtilities.Clamp(bounds.X, screen.Bounds.X, screen.Bounds.X + screen.Bounds.Width);
+                double top = MathUtilities.Clamp(bounds.Y, screen.Bounds.Y, screen.Bounds.Y + screen.Bounds.Height);
+                double right = MathUtilities.Clamp(bounds.X + bounds.Width, screen.Bounds.X, screen.Bounds.X + screen.Bounds.Width);
+                double bottom = MathUtilities.Clamp(bounds.Y + bounds.Height, screen.Bounds.Y, screen.Bounds.Y + screen.Bounds.Height);
+                double area = (right - left) * (bottom - top);
+                if (area > maxAreaSize)
+                {
+                    maxAreaSize = area;
+                    currMaxScreen = screen;
+                }
+            }
+
+            return currMaxScreen;
+        }
+
+        public Screen SceenFromPoint(Point point)
+        {
+            return All.FirstOrDefault(x=>x.Bounds.Contains(point));        
+        }
+
+        public Screen ScreenFromVisual(IVisual visual)
+        {
+            Point tl = visual.PointToScreen(visual.Bounds.TopLeft);
+            Point br = visual.PointToScreen(visual.Bounds.BottomRight);
+            return ScreenFromBounds(new Rect(tl,br));
+        }
+    }
+}

src/Avalonia.Controls/Window.cs

@@ -119,6 +119,7 @@ public Window(IWindowImpl impl)
             : base(impl)
         {
             _maxPlatformClientSize = PlatformImpl?.MaxClientSize ?? default(Size);
+            Screens = new Screens(PlatformImpl?.Screen);
         }
 
         /// <inheritdoc/>
@@ -135,6 +136,8 @@ public Window(IWindowImpl impl)
             remove { _nameScope.Unregistered -= value; }
         }
 
+        public Screens Screens { get; private set; }
+
         /// <summary>
         /// Gets the platform-specific window implementation.
         /// </summary>

src/Avalonia.Controls/WindowBase.cs

@@ -90,7 +90,7 @@ public Point Position
                     impl.Position = value;
             }
         }
-
+        
         /// <summary>
         /// Whether an auto-size operation is in progress.
         /// </summary>

src/Gtk/Avalonia.Gtk/Avalonia.Gtk.csproj

@@ -48,6 +48,7 @@
     <Compile Include="FramebufferManager.cs" />
     <Compile Include="IconImpl.cs" />
     <Compile Include="KeyTransform.cs" />
+    <Compile Include="ScreenImpl.cs" />
     <Compile Include="SurfaceFramebuffer.cs" />
     <Compile Include="SystemDialogImpl.cs" />
     <Compile Include="CursorFactory.cs" />

src/Gtk/Avalonia.Gtk/ScreenImpl.cs

@@ -0,0 +1,42 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Platform;
+using Avalonia.Utilities;
+using Gdk;
+using Screen = Avalonia.Platform.Screen;
+using Window = Gtk.Window;
+
+namespace Avalonia.Gtk
+{
+    internal class ScreenImpl : IScreenImpl
+    {
+        private Window window;
+
+        public int ScreenCount
+        {
+            get => window.Display.DefaultScreen.NMonitors;
+        }
+        public Screen[] AllScreens {
+            get
+            {
+                Screen[] screens = new Screen[ScreenCount];
+                var screen = window.Display.DefaultScreen;
+
+                for (short i = 0; i < screens.Length; i++)
+                {
+                    Rectangle geometry = screen.GetMonitorGeometry(i);
+                    Rect geometryRect = new Rect(geometry.X, geometry.Y, geometry.Width, geometry.Height);
+                    Screen s = new Screen(geometryRect, geometryRect, false);
+                    screens[i] = s;
+                }
+
+                return screens;
+            }
+        }
+
+        public ScreenImpl(Window window)
+        {
+            this.window = window;
+        }
+    }
+}

src/Gtk/Avalonia.Gtk/WindowImpl.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Reactive.Disposables;
+using Avalonia.Controls;
 using Avalonia.Platform;
 using Gdk;
 
@@ -66,6 +67,8 @@ public override Size ClientSize
             }
         }
 
+        public IScreenImpl Screen => new ScreenImpl(Window);
+
         public void Resize(Size value)
         {
             Window.Resize((int)value.Width, (int)value.Height);

src/Gtk/Avalonia.Gtk3/Avalonia.Gtk3.csproj

@@ -53,6 +53,8 @@
     <Compile Include="WindowBaseImpl.cs" />
     <Compile Include="Interop\Utf8Buffer.cs" />
     <Compile Include="WindowImpl.cs" />
+    <Compile Include="ScreenImpl.cs" />
+    <Compile Include="GtkScreen.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\Avalonia.Base\Avalonia.Base.csproj" />

src/Gtk/Avalonia.Gtk3/GtkScreen.cs

@@ -0,0 +1,24 @@
+using Avalonia.Platform;
+
+namespace Avalonia.Gtk3
+{
+    public class GtkScreen : Screen
+    {
+        private readonly int _screenId;
+
+        public GtkScreen(Rect bounds, Rect workingArea, bool primary, int screenId) : base(bounds, workingArea, primary)
+        {
+            this._screenId = screenId;
+        }
+
+        public override int GetHashCode()
+        {
+            return _screenId;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return (obj is GtkScreen screen) ? this._screenId == screen._screenId : base.Equals(obj);
+        }
+    }
+}