Wire up all relevant events

Author: Perksey

sources/Windowing/Windowing/IDisplay.cs

@@ -63,9 +63,4 @@ public interface IDisplay : IEquatable<IDisplay>
     /// An event raised when <see cref="KnownVideoModes" /> changes.
     /// </summary>
     event Action<DisplayVideoModeAvailabilityChangeEvent>? KnownVideoModesChanged;
-
-    /// <summary>
-    /// An event raised when <see cref="VideoMode" /> changes.
-    /// </summary>
-    public event Action<VideoModeChangeEvent>? VideoModeChanged;
 }

sources/Windowing/Windowing/ISurfaceDisplay.cs

@@ -44,4 +44,9 @@ public interface ISurfaceDisplay
     /// An event raised when <see cref="AvailableVideoModes" /> changes.
     /// </summary>
     event Action<DisplayVideoModeAvailabilityChangeEvent>? AvailableVideoModesChanged;
+
+    /// <summary>
+    /// An event raised when <see cref="VideoMode" /> changes.
+    /// </summary>
+    public event Action<VideoModeChangeEvent>? VideoModeChanged;
 }

sources/Windowing/Windowing/ISurfaceScale.cs

@@ -4,11 +4,11 @@ namespace Silk.NET.Windowing;
 /// Provides information pertaining to the surface's graphical scaling.
 /// </summary>
 /// <remarks>
-/// <see cref="ContentScale" /> is typically used to scale UI elements to the correct size for the end user.
+/// <see cref="Content" /> is typically used to scale UI elements to the correct size for the end user.
 /// <see cref="PixelDensity" /> on the other hand is used to scale the entire application to cover the entire client
 /// area in cases where the window client size is smaller than the actual drawable size (i.e. it is high density).
 /// If scaling content for legibility and scaling the application's rendering as a whole are not needed to be separated,
-/// it is recommended to use <see cref="DrawScale" />. Implementations shall always request a high density surface if
+/// it is recommended to use <see cref="Draw" />. Implementations shall always request a high density surface if
 /// given the choice, to account for the platforms where applications may not be able to opt-out of high density.
 /// </remarks>
 public interface ISurfaceScale
@@ -17,33 +17,38 @@ public interface ISurfaceScale
     /// Gets the factor with which the application should scale its content to make the content more legible for the
     /// user. This has no influence on <see cref="Surface.DrawableSize" />.
     /// </summary>
-    /// <seealso cref="DrawScale" />
-    float ContentScale { get; }
+    /// <seealso cref="Draw" />
+    float Content { get; }
 
     /// <summary>
     /// Gets the suggested amplification factor when drawing in terms of <see cref="Surface.DrawableSize" />. This
     /// represents the scale from the pixel resolution to the desired content size, and is typically the multiplication
-    /// of <see cref="PixelDensity" /> and <see cref="ContentScale" />.
+    /// of <see cref="PixelDensity" /> and <see cref="Content" />.
     /// </summary>
     /// <remarks>
     /// For example, if <see cref="PixelDensity" /> is <c>2.0</c> (i.e. there are 2 pixels per screen coordinate)
     /// <i>and</i> the window manager requests that applications scale their content up by <c>2.0</c> to meet the user's
-    /// settings as per <see cref="ContentScale" />, this would be <c>4.0</c>. This is because we're scaling once to
+    /// settings as per <see cref="Content" />, this would be <c>4.0</c>. This is because we're scaling once to
     /// account for the fact that the application has twice the amount of pixels available to it for the given window
     /// size, and then scaling again so that what we are drawing appears zoomed in as per the user's request. Note that
     /// it is rarely the case that an operating system employs both dense pixels <i>and</i> content scale. macOS for
-    /// instance, instead of setting <see cref="ContentScale" />, opts to scale the resolution in the cases where the
+    /// instance, instead of setting <see cref="Content" />, opts to scale the resolution in the cases where the
     /// user wants magnified visuals instead of having the applications scale their content; whereas Windows sets
-    /// <see cref="ContentScale" /> and instead always keeps <see cref="PixelDensity" /> as <c>1.0</c>. This is down
+    /// <see cref="Content" /> and instead always keeps <see cref="PixelDensity" /> as <c>1.0</c>. This is down
     /// to philosophical differences between the window coordinate systems on platforms as to whether they prefer to
     /// deal in physical device pixels or physical content sizes.
     /// </remarks>
-    float DrawScale { get; }
+    float Draw { get; }
 
     /// <summary>
     /// Gets the ratio of pixels rendered to window size. This shall be equivalent to
     /// <see cref="Surface.DrawableSize" /> divided by <see cref="ISurfaceWindow.ClientSize" />.
     /// </summary>
-    /// <seealso cref="DrawScale" />
+    /// <seealso cref="Draw" />
     float PixelDensity { get; }
+
+    /// <summary>
+    /// An event raised when any scale factor changes.
+    /// </summary>
+    public event Action<ScaleChangedEvent>? Changed;
 }

sources/Windowing/Windowing/ISurfaceWindow.cs

@@ -65,19 +65,26 @@ Vector2 ClientSize
 
     /// <summary>
     /// Gets or sets a value indicating whether, unless set to <c>false</c> before the next <see cref="Surface.Tick" />,
-    /// the window will close resulting in the irrevocable termination of the surface.
+    /// the window will close resulting in the irrevocable termination of the surface. Any children active at this point
+    /// will also be irrevocably terminated, and parent windows should bear this in mind when responding to their
+    /// <see cref="CloseRequested"/> events - not rejecting the closure request shall terminate all child surfaces too.
     /// </summary>
     bool IsCloseRequested { get; set; }
 
+    /// <summary>
+    /// Raised when <see cref="IsCloseRequested" /> is set to <c>true</c>.
+    /// </summary>
+    event Action<WindowToggleEvent>? CloseRequested;
+
     /// <summary>
     /// Gets or sets a value indicating whether the window is visible.
     /// </summary>
     bool IsVisible { get; set; }
 
     /// <summary>
-    /// Raised when <see cref="IsCloseRequested" /> is set to <c>true</c>.
+    /// Raised when <see cref="IsVisible" /> changes.
     /// </summary>
-    event Action<WindowToggleEvent>? CloseRequested;
+    event Action<WindowToggleEvent>? VisibilityChanged;
 
     /// <summary>
     /// Gets or sets a value indicating whether the window currently has input focus. If setting to <c>true</c>, the

sources/Windowing/Windowing/Implementations/SDL3/SdlDisplay.cs

@@ -8,9 +8,22 @@
 
 namespace Silk.NET.Windowing.SDL3;
 
-internal class SdlDisplay(uint id) : IDisplay
+internal class SdlDisplay : IDisplay
 {
-    public uint Id { get; } = id;
+    private Rectangle<float> _bounds;
+    private Rectangle<float> _workArea;
+
+    public SdlDisplay(SdlSurface surface, uint id)
+    {
+        Surface = surface;
+        Id = id;
+        _bounds = Bounds;
+        _workArea = WorkArea;
+    }
+
+    public uint Id { get; }
+    public SdlSurface Surface { get; }
+
     public Rectangle<float> Bounds
     {
         get
@@ -50,14 +63,14 @@ public IReadOnlyList<VideoMode>? KnownVideoModes
                 return _silkModes;
             }
 
-            var videoModes = DisplayModes;
-            var ret = new VideoMode[videoModes.Length + 1];
+            UpdateDisplayModes();
+            var ret = new VideoMode[_displayModes.Length + 1];
             ret[0] = default; // This is to change back to non-fullscreen.
-            for (nuint i = 0; (int)i < videoModes.Length; i++)
+            for (nuint i = 0; (int)i < _displayModes.Length; i++)
             {
-                ref var videoMode = ref videoModes[i].Handle;
+                ref var videoMode = ref _displayModes[i].Handle;
                 ret[i + 1] = new VideoMode(
-                    (int)i,
+                    (int)(i + 1),
                     new Vector2(videoMode.W, videoMode.H),
                     videoMode.RefreshRate
                 );
@@ -67,37 +80,78 @@ public IReadOnlyList<VideoMode>? KnownVideoModes
         }
     }
 
-    [field: AllowNull, MaybeNull]
+    private Ptr<DisplayMode>[]? _displayModes;
+
     internal Ptr<DisplayMode>[] DisplayModes
     {
         get
         {
-            if (field is not null)
+            if (_displayModes is not null)
             {
-                return field;
+                return _displayModes;
             }
 
-            var count = 0;
-            var videoModes = Sdl.GetFullscreenDisplayModes(Id, count.AsRef());
-            if (videoModes == nullptr)
-            {
-                Sdl.ThrowError();
-            }
+            UpdateDisplayModes();
+            return _displayModes;
+        }
+    }
 
-            field = new Ptr<DisplayMode>[count];
-            videoModes.AsSpan(count).CopyTo(field);
-            Sdl.Free((Ref)videoModes);
-            return field;
+    [MemberNotNull(nameof(_displayModes))]
+    private bool UpdateDisplayModes()
+    {
+        DebugPrint();
+        var count = 0;
+        var videoModes = Sdl.GetFullscreenDisplayModes(Id, count.AsRef());
+        if (videoModes == nullptr)
+        {
+            Sdl.ThrowError();
         }
+
+        var span = videoModes.AsSpan(count);
+        if (_displayModes?.Length == count && span.SequenceEqual(_displayModes))
+        {
+            return false;
+        }
+
+        var wasNull = _displayModes is null;
+        _displayModes = new Ptr<DisplayMode>[count];
+        videoModes.AsSpan(count).CopyTo(_displayModes);
+        Sdl.Free((Ref)videoModes);
+        _silkModes = null;
+        if (!wasNull)
+        {
+            DebugPrint("Raising KnownVideoModesChanged");
+            _knownVideoModesChanged?.Invoke(new DisplayVideoModeAvailabilityChangeEvent());
+        }
+
+        return !wasNull;
     }
 
     public bool IsPrimary => Sdl.GetPrimaryDisplay() == Id;
 
     public string Name => Sdl.GetDisplayName(Id).ReadToString();
 
     public event Action<DisplayCoordinatesEvent>? CoordinatesChanged;
-    public event Action<DisplayVideoModeAvailabilityChangeEvent>? KnownVideoModesChanged;
-    public event Action<VideoModeChangeEvent>? VideoModeChanged;
+    private Action<DisplayVideoModeAvailabilityChangeEvent>? _knownVideoModesChanged;
+
+    public event Action<DisplayVideoModeAvailabilityChangeEvent>? KnownVideoModesChanged
+    {
+        add
+        {
+            if (value is null)
+            {
+                return;
+            }
+
+            if (_displayModes is null)
+            {
+                UpdateDisplayModes();
+            }
+
+            _knownVideoModesChanged += value;
+        }
+        remove => _knownVideoModesChanged -= value;
+    }
 
     private bool Equals(SdlDisplay other) => Id == other.Id;
 
@@ -108,4 +162,15 @@ obj is not null
         && (ReferenceEquals(this, obj) || (obj.GetType() == GetType() && Equals((SdlDisplay)obj)));
 
     public override int GetHashCode() => (int)Id;
+
+    public void OnCoordinatesChanged()
+    {
+        DebugPrint("Raising CoordinatesChanged...");
+        CoordinatesChanged?.Invoke(
+            new DisplayCoordinatesEvent(Surface, this, _bounds, Bounds, _workArea, WorkArea)
+        );
+    }
+
+    // If _displayModes is null, user doesn't care.
+    public bool OnModeChanged() => _displayModes is not null && UpdateDisplayModes();
 }