Screens API refactor

api/Avalonia.nupkg.xml

@@ -1093,6 +1093,12 @@
     <Left>baseline/netstandard2.0/Avalonia.Base.dll</Left>
     <Right>target/netstandard2.0/Avalonia.Base.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:Avalonia.Controls.Screens.#ctor(Avalonia.Platform.IScreenImpl)</Target>
+    <Left>baseline/netstandard2.0/Avalonia.Controls.dll</Left>
+    <Right>target/netstandard2.0/Avalonia.Controls.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0006</DiagnosticId>
     <Target>M:Avalonia.Platform.IAssetLoader.InvalidateAssemblyCache</Target>
@@ -1141,4 +1147,10 @@
     <Left>baseline/netstandard2.0/Avalonia.Controls.dll</Left>
     <Right>target/netstandard2.0/Avalonia.Controls.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0009</DiagnosticId>
+    <Target>T:Avalonia.Controls.Screens</Target>
+    <Left>baseline/netstandard2.0/Avalonia.Controls.dll</Left>
+    <Right>target/netstandard2.0/Avalonia.Controls.dll</Right>
+  </Suppression>
 </Suppressions>

native/Avalonia.Native/src/OSX/Screens.mm

@@ -1,36 +1,62 @@
 #include "common.h"
+#include "AvnString.h"
 
 class Screens : public ComSingleObject<IAvnScreens, &IID_IAvnScreens>
 {
-    public:
-    FORWARD_IUNKNOWN()
-
+private:
+    ComPtr<IAvnScreenEvents> _events;
 public:
-    virtual HRESULT GetScreenCount (int* ret) override
+    FORWARD_IUNKNOWN()
+
+    Screens(IAvnScreenEvents* events) {
+        _events = events;
+        CGDisplayRegisterReconfigurationCallback(CGDisplayReconfigurationCallBack, this);
+    }
+
+    virtual HRESULT GetScreenIds (
+        unsigned int* ptrFirstResult,
+        int* screenCound) override
     {
         START_COM_CALL;
 
         @autoreleasepool
         {
-            *ret = (int)[NSScreen screens].count;
-
+            auto screens = [NSScreen screens];
+            *screenCound = (int)screens.count;
+
+            if (ptrFirstResult == nil)
+                return S_OK;
+
+            for (int i = 0; i < screens.count; i++) {
+                ptrFirstResult[i] = [[screens objectAtIndex:i] av_displayId];
+            }
+
             return S_OK;
         }
     }
-
-    virtual HRESULT GetScreen (int index, AvnScreen* ret) override
-    {
+
+    virtual HRESULT GetScreen (
+       CGDirectDisplayID displayId,
+       void** localizedName,
+       AvnScreen* ret
+    ) override {
         START_COM_CALL;
 
         @autoreleasepool
         {
-            if(index < 0 || index >= [NSScreen screens].count)
-            {
-                return E_INVALIDARG;
+            NSScreen* screen;
+            for (NSScreen *s in NSScreen.screens) {
+                if (s.av_displayId == displayId)
+                {
+                    screen = s;
+                    break;
+                }
             }
 
-            auto screen = [[NSScreen screens] objectAtIndex:index];
-
+            if (screen == nil) {
+                return E_INVALIDARG;
+            }
+
             ret->Bounds.Height = [screen frame].size.height;
             ret->Bounds.Width = [screen frame].size.width;
             ret->Bounds.X = [screen frame].origin.x;
@@ -43,14 +69,45 @@ virtual HRESULT GetScreen (int index, AvnScreen* ret) override
 
             ret->Scaling = 1;
 
-            ret->IsPrimary = index == 0;
-
+            ret->IsPrimary = CGDisplayIsMain(displayId);
+
+            // Compute natural orientation:
+            auto naturalScreenSize = CGDisplayScreenSize(displayId);
+            auto isNaturalLandscape = naturalScreenSize.width > naturalScreenSize.height;
+            // Normalize rotation:
+            auto rotation = (int)CGDisplayRotation(displayId) % 360;
+            if (rotation < 0) rotation = 360 - rotation;
+            // Get current orientation relative to the natural
+            if (rotation >= 0 && rotation < 90) {
+                ret->Orientation = isNaturalLandscape ? AvnScreenOrientation::Landscape : AvnScreenOrientation::Portrait;
+            } else if (rotation >= 90 && rotation < 180) {
+                ret->Orientation = isNaturalLandscape ? AvnScreenOrientation::Portrait : AvnScreenOrientation::Landscape;
+            } else if (rotation >= 180 && rotation < 270) {
+                ret->Orientation = isNaturalLandscape ? AvnScreenOrientation::LandscapeFlipped : AvnScreenOrientation::PortraitFlipped;
+            } else {
+                ret->Orientation = isNaturalLandscape ? AvnScreenOrientation::PortraitFlipped : AvnScreenOrientation::LandscapeFlipped;
+            }
+
+            if (@available(macOS 10.15, *)) {
+                *localizedName = CreateAvnString([screen localizedName]);
+            }
+
             return S_OK;
         }
     }
+
+private:
+    static void CGDisplayReconfigurationCallBack(CGDirectDisplayID display, CGDisplayChangeSummaryFlags flags, void *screens)
+    {
+        auto object = (Screens *)screens;
+        auto events = object->_events;
+        if (events != nil) {
+            events->OnChanged();
+        }
+    }
 };
 
-extern IAvnScreens* CreateScreens()
+extern IAvnScreens* CreateScreens(IAvnScreenEvents* events)
 {
-    return new Screens();
+    return new Screens(events);
 }

native/Avalonia.Native/src/OSX/TopLevelImpl.h

@@ -58,7 +58,8 @@ class TopLevelImpl : public virtual ComObject,
     virtual HRESULT PointToScreen(AvnPoint point, AvnPoint *ret) override;
 
     virtual HRESULT SetTransparencyMode(AvnWindowTransparencyMode mode) override;
-
+
+    virtual HRESULT GetCurrentDisplayId (CGDirectDisplayID* ret) override;
 protected:
     NSCursor *cursor;
     virtual void UpdateAppearance();

native/Avalonia.Native/src/OSX/TopLevelImpl.mm

@@ -258,6 +258,15 @@
     return S_OK;
 }
 
+HRESULT TopLevelImpl::GetCurrentDisplayId (CGDirectDisplayID* ret) {
+    START_COM_CALL;
+
+    auto window = [View window];
+    *ret = [window.screen av_displayId];
+
+    return S_OK;
+}
+
 void TopLevelImpl::UpdateAppearance() {
 
 }

native/Avalonia.Native/src/OSX/common.h

@@ -15,7 +15,7 @@ extern IAvnTopLevel* CreateAvnTopLevel(IAvnTopLevelEvents* events);
 extern IAvnWindow* CreateAvnWindow(IAvnWindowEvents*events);
 extern IAvnPopup* CreateAvnPopup(IAvnWindowEvents*events);
 extern IAvnSystemDialogs* CreateSystemDialogs();
-extern IAvnScreens* CreateScreens();
+extern IAvnScreens* CreateScreens(IAvnScreenEvents* cb);
 extern IAvnClipboard* CreateClipboard(NSPasteboard*, NSPasteboardItem*);
 extern NSPasteboardItem* TryGetPasteboardItem(IAvnClipboard*);
 extern NSObject<NSDraggingSource>* CreateDraggingSource(NSDragOperation op, IAvnDndResultCallback* cb, void* handle);
@@ -89,6 +89,13 @@ template<typename T> class ObjCWrapper {
 - (void) action;
 @end
 
+@implementation NSScreen (AvNSScreen)
+- (CGDirectDisplayID)av_displayId
+{
+    return [self.deviceDescription[@"NSScreenNumber"] unsignedIntValue];
+}
+@end
+
 class AvnInsidePotentialDeadlock
 {
 public:

native/Avalonia.Native/src/OSX/main.mm

@@ -287,13 +287,13 @@ virtual HRESULT CreateSystemDialogs(IAvnSystemDialogs** ppv) override
         }
     }
 
-    virtual HRESULT CreateScreens (IAvnScreens** ppv) override
+    virtual HRESULT CreateScreens (IAvnScreenEvents* cb, IAvnScreens** ppv) override
     {
         START_COM_CALL;
 
         @autoreleasepool
         {
-            *ppv = ::CreateScreens ();
+            *ppv = ::CreateScreens (cb);
             return S_OK;
         }
     }

native/Avalonia.Native/src/OSX/menu.mm

@@ -1,4 +1,5 @@
 
+
 #include "common.h"
 #include "menu.h"
 #include "KeyTransform.h"

samples/ControlCatalog/MainView.xaml

@@ -196,6 +196,9 @@
       <TabItem Header="HeaderedContentControl">
         <pages:HeaderedContentPage />
       </TabItem>
+      <TabItem Header="Screens">
+        <pages:ScreenPage />
+      </TabItem>
       <FlyoutBase.AttachedFlyout>
         <Flyout>
           <StackPanel Width="152" Spacing="8">

samples/ControlCatalog/MainView.xaml.cs

@@ -25,16 +25,6 @@ public MainView()
 
             var sideBar = this.Get<TabControl>("Sidebar");
 
-            if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime)
-            {
-                var tabItems = (sideBar.Items as IList);
-                tabItems?.Add(new TabItem()
-                {
-                    Header = "Screens",
-                    Content = new ScreenPage()
-                });
-            }
-
             var themes = this.Get<ComboBox>("Themes");
             themes.SelectedItem = App.CurrentTheme;
             themes.SelectionChanged += (sender, e) =>

samples/ControlCatalog/Pages/ScreenPage.cs

@@ -20,33 +20,62 @@ public class ScreenPage : UserControl
         private IPen _activePen = new Pen(Brushes.Black);
         private IPen _defaultPen = new Pen(Brushes.DarkGray);
 
+        public ScreenPage()
+        {
+            var button = new Button();
+            button.Content = "Request ScreenDetails";
+            button.VerticalAlignment = Avalonia.Layout.VerticalAlignment.Top;
+            button.Click += async (sender, args) =>
+            {
+                var success = TopLevel.GetTopLevel(this)!.Screens is { } screens ?
+                    await screens.RequestScreenDetails() :
+                    false;
+                button.Content = "Request ScreenDetails: " + (success ? "Granted" : "Denied");
+            };
+            Content = button;
+        }
+
         protected override bool BypassFlowDirectionPolicies => true;
 
         protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
         {
             base.OnAttachedToVisualTree(e);
-            if(VisualRoot is Window w)
+
+            var topLevel = TopLevel.GetTopLevel(this);
+            if (topLevel is Window w)
             {
                 w.PositionChanged += (_, _) => InvalidateVisual();
             }
+
+            if (topLevel?.Screens is { } screens)
+            {
+                screens.Changed += (_, _) =>
+                {
+                    Console.WriteLine("Screens Changed");
+                    InvalidateVisual();
+                };
+            }
         }
 
         public override void Render(DrawingContext context)
         {
             base.Render(context);
-            if (!(VisualRoot is Window w))
+            double beginOffset = (Content as Visual)?.Bounds.Height + 10 ?? 0;
+
+            var topLevel = TopLevel.GetTopLevel(this)!;
+            if (topLevel.Screens is not { } screens)
             {
+                var formattedText = CreateFormattedText("Current platform doesn't support Screens API.");
+                context.DrawText(formattedText, new Point(15, 15 + beginOffset));
                 return;
             }
-            var screens = w.Screens.All;
-            var scaling = ((IRenderRoot)w).RenderScaling;
 
-            var activeScreen = w.Screens.ScreenFromBounds(new PixelRect(w.Position, PixelSize.FromSize(w.Bounds.Size, scaling)));
+            var activeScreen = screens.ScreenFromTopLevel(topLevel);
             double maxBottom = 0;
 
-            for (int i = 0; i<screens.Count; i++ )
+            for (int i = 0; i<screens.ScreenCount; i++ )
             {
-                var screen = screens[i];
+                var screen = screens.All[i];
 
                 if (screen.Bounds.X / 10f < _leftMost)
                 {
@@ -63,31 +92,39 @@ public override void Render(DrawingContext context)
                 bool primary = screen.IsPrimary;
                 bool active = screen.Equals(activeScreen);
 
-                Rect boundsRect = new Rect(screen.Bounds.X / 10f + Math.Abs(_leftMost), screen.Bounds.Y / 10f+Math.Abs(_topMost), screen.Bounds.Width / 10f,
+                Rect boundsRect = new Rect(screen.Bounds.X / 10f + Math.Abs(_leftMost), screen.Bounds.Y / 10f+Math.Abs(_topMost) + beginOffset, screen.Bounds.Width / 10f,
                                   screen.Bounds.Height / 10f);
-                Rect workingAreaRect = new Rect(screen.WorkingArea.X / 10f + Math.Abs(_leftMost), screen.WorkingArea.Y / 10f+Math.Abs(_topMost), screen.WorkingArea.Width / 10f,
+                Rect workingAreaRect = new Rect(screen.WorkingArea.X / 10f + Math.Abs(_leftMost), screen.WorkingArea.Y / 10f+Math.Abs(_topMost) + beginOffset, screen.WorkingArea.Width / 10f,
                                    screen.WorkingArea.Height / 10f);
 
                 context.DrawRectangle(primary ? _primaryBrush : _defaultBrush, active ? _activePen : _defaultPen, boundsRect);
                 context.DrawRectangle(primary ? _primaryBrush : _defaultBrush, active ? _activePen : _defaultPen, workingAreaRect);
-
+ 
                 var identifier = CreateScreenIdentifier((i+1).ToString(), primary);
-                var center = boundsRect.Center - new Point(identifier.Width / 2.0f, identifier.Height / 2.0f);
+                var center = boundsRect.Center - new Point(identifier.Width / 2.0f, identifier.Height / 2.0f + beginOffset);
 
                 context.DrawText(identifier, center);
                 maxBottom = Math.Max(maxBottom, boundsRect.Bottom);
             }
 
             double currentHeight = maxBottom;
 
-            for(int i = 0; i< screens.Count; i++)
+            for(int i = 0; i< screens.ScreenCount; i++)
             {
-                var screen = screens[i];
+                var screen = screens.All[i];
 
                 var formattedText = CreateFormattedText($"Screen {i+1}", 18);
                 context.DrawText(formattedText, new Point(0, currentHeight));
                 currentHeight += 25;
 
+                formattedText = CreateFormattedText($"DisplayName: {screen.DisplayName}");
+                context.DrawText(formattedText, new Point(15, currentHeight));
+                currentHeight += 20;
+
+                formattedText = CreateFormattedText($"Handle: {screen.TryGetPlatformHandle()}");
+                context.DrawText(formattedText, new Point(15, currentHeight));
+                currentHeight += 20;
+
                 formattedText = CreateFormattedText($"Bounds: {screen.Bounds.Width}:{screen.Bounds.Height}");
                 context.DrawText(formattedText, new Point(15, currentHeight));
                 currentHeight += 20;
@@ -101,17 +138,26 @@ public override void Render(DrawingContext context)
                 currentHeight += 20;
 
                 formattedText = CreateFormattedText($"IsPrimary: {screen.IsPrimary}");
-
+                context.DrawText(formattedText, new Point(15, currentHeight));
+                currentHeight += 20;
+
+                formattedText = CreateFormattedText($"CurrentOrientation: {screen.CurrentOrientation}");
                 context.DrawText(formattedText, new Point(15, currentHeight));
                 currentHeight += 20;
 
                 formattedText = CreateFormattedText( $"Current: {screen.Equals(activeScreen)}");
                 context.DrawText(formattedText, new Point(15, currentHeight));
                 currentHeight += 30;
-
             }
 
-            context.DrawRectangle(_activePen, new Rect(w.Position.X / 10f + Math.Abs(_leftMost), w.Position.Y / 10f+Math.Abs(_topMost), w.Bounds.Width / 10, w.Bounds.Height / 10));
+            if (topLevel is Window w)
+            {
+                var wPos = w.Position;
+                var wSize = PixelSize.FromSize(w.FrameSize ?? w.ClientSize, w.DesktopScaling);
+                context.DrawRectangle(_activePen,
+                    new Rect(wPos.X / 10f + Math.Abs(_leftMost), wPos.Y / 10f + Math.Abs(_topMost) + beginOffset,
+                        wSize.Width / 10d, wSize.Height / 10d));
+            }
         }
 
         private static FormattedText CreateFormattedText(string textToFormat, double size = 12)