Fixes #2489. New ScrollSlider, Scroll, and ScrollBar - Adds IScrolLBar so any View can have scrollbars

Terminal.Gui/Drawing/Thickness.cs

@@ -236,7 +236,7 @@ public Rectangle GetInside (Rectangle rect)
     }
 
     /// <summary>
-    ///     Gets the total width of the left and right sides of the rectangle. Sets the width of the left and rigth sides
+    ///     Gets the total width of the left and right sides of the rectangle. Sets the width of the left and right sides
     ///     of the rectangle to half the specified value.
     /// </summary>
     public int Horizontal

Terminal.Gui/View/View.Content.cs

@@ -218,6 +218,7 @@ public ViewportSettings ViewportSettings
             {
                 // Force set Viewport to cause settings to be applied as needed
                 SetViewport (Viewport);
+                SetScrollBarsKeepContentInAllViewport (_viewportSettings);
             }
         }
     }
@@ -325,6 +326,10 @@ private void SetViewport (Rectangle viewport)
             Size = newSize
         };
 
+        OnViewportChanged (new (IsInitialized ? Viewport : Rectangle.Empty, oldViewport));
+
+        return;
+
         void ApplySettings (ref Rectangle newViewport)
         {
             if (!ViewportSettings.HasFlag (ViewportSettings.AllowXGreaterThanContentWidth))

Terminal.Gui/View/View.Drawing.Clipping.cs

@@ -104,7 +104,7 @@ public static void SetClip (Region? region)
         if (this is Adornment adornment && adornment.Thickness != Thickness.Empty)
         {
             // Ensure adornments can't draw outside their thickness
-            frameRegion.Exclude (adornment.Thickness.GetInside (Frame));
+            frameRegion.Exclude (adornment.Thickness.GetInside (FrameToScreen()));
         }
 
         SetClip (frameRegion);

Terminal.Gui/View/View.Layout.cs

@@ -96,11 +96,23 @@ private bool SetFrame (in Rectangle frame)
         SetNeedsLayout ();
 
         // BUGBUG: When SetFrame is called from Frame_set, this event gets raised BEFORE OnResizeNeeded. Is that OK?
-        OnViewportChanged (new (IsInitialized ? Viewport : Rectangle.Empty, oldViewport));
-
+        OnFrameChanged (in frame);
+        FrameChanged?.Invoke (this, new (in frame));
         return true;
     }
 
+    /// <summary>
+    ///     Called when <see cref="Frame"/> changes.
+    /// </summary>
+    /// <param name="frame">The new Frame.</param>
+    protected virtual void OnFrameChanged (in Rectangle frame) { }
+
+    /// <summary>
+    ///     Raised when the <see cref="Frame"/> changes. This event is raised after the <see cref="Frame"/> has been
+    ///     updated.
+    /// </summary>
+    public event EventHandler<EventArgs<Rectangle>>? FrameChanged;
+
     /// <summary>Gets the <see cref="Frame"/> with a screen-relative location.</summary>
     /// <returns>The location and size of the view in screen-relative coordinates.</returns>
     public virtual Rectangle FrameToScreen ()

Terminal.Gui/View/View.ScrollBars.cs

@@ -0,0 +1,215 @@
+#nullable enable
+namespace Terminal.Gui;
+
+public partial class View
+{
+    private Lazy<ScrollBar> _horizontalScrollBar;
+    private Lazy<ScrollBar> _verticalScrollBar;
+
+    /// <summary>
+    ///     Initializes the ScrollBars of the View. Called by the constructor.
+    /// </summary>
+    private void SetupScrollBars ()
+    {
+        _horizontalScrollBar = new (
+                                    () =>
+                                    {
+                                        var scrollBar = new ScrollBar
+                                        {
+                                            Orientation = Orientation.Horizontal,
+                                            X = 0,
+                                            Y = Pos.AnchorEnd (),
+                                            Width = Dim.Fill (
+                                                              Dim.Func (
+                                                                        () =>
+                                                                        {
+                                                                            if (_verticalScrollBar.IsValueCreated)
+                                                                            {
+                                                                                return _verticalScrollBar.Value.Visible ? 1 : 0;
+                                                                            }
+
+                                                                            return 0;
+                                                                        })),
+                                            Size = GetContentSize ().Width,
+                                            Visible = false
+                                        };
+
+                                        Padding?.Add (scrollBar);
+
+                                        scrollBar.Initialized += (_, _) =>
+                                        {
+                                            Padding!.Thickness = Padding.Thickness with
+                                            {
+                                                Bottom = scrollBar.Visible ? Padding.Thickness.Bottom + 1 : 0
+                                            };
+
+                                            scrollBar.ContentPositionChanged += (_, args) =>
+                                                                                {
+                                                                                    Viewport = Viewport with
+                                                                                    {
+                                                                                        X = Math.Min (
+                                                                                                      args.CurrentValue,
+                                                                                                      GetContentSize ().Width - (Viewport.Width))
+                                                                                    };
+                                                                                };
+
+                                            scrollBar.VisibleChanged += (_, _) =>
+                                            {
+                                                Padding.Thickness = Padding.Thickness with
+                                                {
+                                                    Bottom = scrollBar.Visible
+                                                        ? Padding.Thickness.Bottom + 1
+                                                        : Padding.Thickness.Bottom - 1
+                                                };
+                                            };
+                                        };
+
+                                        return scrollBar;
+                                    });
+
+        _verticalScrollBar = new (
+                                  () =>
+                                  {
+                                      var scrollBar = new ScrollBar
+                                      {
+                                          Orientation = Orientation.Vertical,
+                                          X = Pos.AnchorEnd (),
+                                          Y = Pos.Func (() => Padding.Thickness.Top),
+                                          Height = Dim.Fill (
+                                                             Dim.Func (
+                                                                       () =>
+                                                                       {
+                                                                           if (_horizontalScrollBar.IsValueCreated)
+                                                                           {
+                                                                               return _horizontalScrollBar.Value.Visible ? 1 : 0;
+                                                                           }
+
+                                                                           return 0;
+                                                                       })),
+                                          Size = GetContentSize ().Height,
+                                          Visible = false
+                                      };
+
+                                      Padding?.Add (scrollBar);
+
+                                      scrollBar.Initialized += (_, _) =>
+                                      {
+                                          if (Padding is { })
+                                          {
+                                              Padding.Thickness = Padding.Thickness with
+                                              {
+                                                  Right = scrollBar.Visible ? Padding.Thickness.Right + 1 : 0
+                                              };
+
+                                              scrollBar.ContentPositionChanged += (_, args) =>
+                                                                                  {
+                                                                                      Viewport = Viewport with
+                                                                                      {
+                                                                                          Y = Math.Min (
+                                                                                                        args.CurrentValue,
+                                                                                                        GetContentSize ().Height - (Viewport.Height))
+                                                                                      };
+                                                                                  };
+
+                                              scrollBar.VisibleChanged += (_, _) =>
+                                                                          {
+                                                                              Padding.Thickness = Padding.Thickness with
+                                                                              {
+                                                                                  Right = scrollBar.Visible
+                                                                                              ? Padding.Thickness.Right + 1
+                                                                                              : Padding.Thickness.Right - 1
+                                                                              };
+                                                                          };
+                                          }
+                                      };
+
+                                      return scrollBar;
+                                  });
+
+        ViewportChanged += (_, _) =>
+        {
+            if (_verticalScrollBar.IsValueCreated)
+            {
+                _verticalScrollBar.Value.ContentPosition = Viewport.Y;
+            }
+
+            if (_horizontalScrollBar.IsValueCreated)
+            {
+                _horizontalScrollBar.Value.ContentPosition = Viewport.X;
+            }
+        };
+
+        ContentSizeChanged += (_, _) =>
+        {
+            if (_verticalScrollBar.IsValueCreated)
+            {
+                _verticalScrollBar.Value.Size = GetContentSize ().Height;
+            }
+            if (_horizontalScrollBar.IsValueCreated)
+            {
+                _horizontalScrollBar.Value.Size = GetContentSize ().Width;
+            }
+        };
+    }
+
+    /// <summary>
+    /// </summary>
+    public ScrollBar HorizontalScrollBar => _horizontalScrollBar.Value;
+
+    /// <summary>
+    /// </summary>
+    public ScrollBar VerticalScrollBar => _verticalScrollBar.Value;
+
+    /// <summary>
+    ///     Clean up the ScrollBars of the View. Called by View.Dispose.
+    /// </summary>
+    private void DisposeScrollBars ()
+    {
+        if (_horizontalScrollBar.IsValueCreated)
+        {
+            Padding?.Remove (_horizontalScrollBar.Value);
+            _horizontalScrollBar.Value.Dispose ();
+        }
+
+        if (_verticalScrollBar.IsValueCreated)
+        {
+            Padding?.Remove (_verticalScrollBar.Value);
+            _verticalScrollBar.Value.Dispose ();
+        }
+    }
+
+    private void SetScrollBarsKeepContentInAllViewport (ViewportSettings viewportSettings)
+    {
+        if (viewportSettings == ViewportSettings.None)
+        {
+            _horizontalScrollBar.Value.KeepContentInAllViewport = true;
+            _verticalScrollBar.Value.KeepContentInAllViewport = true;
+        }
+        else if (viewportSettings.HasFlag (ViewportSettings.AllowNegativeX))
+        {
+            _horizontalScrollBar.Value.AutoHide = false;
+        }
+        else if (viewportSettings.HasFlag (ViewportSettings.AllowNegativeY))
+        {
+            _verticalScrollBar.Value.AutoHide = false;
+        }
+        else if (viewportSettings.HasFlag (ViewportSettings.AllowNegativeLocation))
+        {
+            _horizontalScrollBar.Value.AutoHide = false;
+            _verticalScrollBar.Value.AutoHide = false;
+        }
+        else if (viewportSettings.HasFlag (ViewportSettings.AllowXGreaterThanContentWidth))
+        {
+            _horizontalScrollBar.Value.KeepContentInAllViewport = false;
+        }
+        else if (viewportSettings.HasFlag (ViewportSettings.AllowYGreaterThanContentHeight))
+        {
+            _verticalScrollBar.Value.KeepContentInAllViewport = false;
+        }
+        else if (viewportSettings.HasFlag (ViewportSettings.AllowLocationGreaterThanContentSize))
+        {
+            _horizontalScrollBar.Value.KeepContentInAllViewport = false;
+            _verticalScrollBar.Value.KeepContentInAllViewport = false;
+        }
+    }
+}