Fixes #2489. Create new ScrollBar based on a new Scroll and remove ScrollBarView/ScrollView

Terminal.Gui/View/View.Content.cs

@@ -213,6 +213,7 @@ public ViewportSettings ViewportSettings
             {
                 // Force set Viewport to cause settings to be applied as needed
                 SetViewport (Viewport);
+                SetScrollBarsKeepContentInAllViewport (_viewportSettings);
             }
         }
     }

Terminal.Gui/View/View.ScrollBars.cs

@@ -0,0 +1,209 @@
+#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.PositionChanged += (_, args) =>
+                                            {
+                                                Viewport = Viewport with { X = args.CurrentValue };
+                                            };
+
+                                            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.PositionChanged += (_, args) =>
+                                                                           {
+                                                                               Viewport = Viewport with { Y = args.CurrentValue };
+                                                                           };
+
+                                              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.Position = Viewport.Y;
+            }
+
+            if (_horizontalScrollBar.IsValueCreated)
+            {
+                _horizontalScrollBar.Value.Position = 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;
+            _horizontalScrollBar.Value.ShowScrollIndicator = false;
+        }
+        else if (viewportSettings.HasFlag (ViewportSettings.AllowNegativeY))
+        {
+            _verticalScrollBar.Value.AutoHide = false;
+            _verticalScrollBar.Value.ShowScrollIndicator = false;
+        }
+        else if (viewportSettings.HasFlag (ViewportSettings.AllowNegativeLocation))
+        {
+            _horizontalScrollBar.Value.AutoHide = false;
+            _horizontalScrollBar.Value.ShowScrollIndicator = false;
+            _verticalScrollBar.Value.AutoHide = false;
+            _verticalScrollBar.Value.ShowScrollIndicator = 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;
+        }
+    }
+}

Terminal.Gui/View/View.cs

@@ -135,6 +135,7 @@
 
         DisposeKeyboard ();
         DisposeAdornments ();
+        DisposeScrollBars ();
 
         for (int i = InternalSubviews.Count - 1; i >= 0; i--)
         {
@@ -178,13 +179,15 @@
     ///         control the size and location of the view.
     ///     </para>
     /// </remarks>
     public View ()
     {
         SetupAdornments ();
         SetupKeyboard ();
 
         //SetupMouse ();
         SetupText ();
+
+        SetupScrollBars ();
     }
 
     /// <summary>

Terminal.Gui/View/ViewportSettings.cs

@@ -15,43 +15,35 @@ public enum ViewportSettings
     ///     If set, <see cref="View.Viewport"/><c>.X</c> can be set to negative values enabling scrolling beyond the left of
     ///     the
     ///     content area.
-    /// </summary>
-    /// <remarks>
     ///     <para>
     ///         When not set, <see cref="View.Viewport"/><c>.X</c> is constrained to positive values.
     ///     </para>
-    /// </remarks>
+    /// </summary>
     AllowNegativeX = 1,
 
     /// <summary>
     ///     If set, <see cref="View.Viewport"/><c>.Y</c> can be set to negative values enabling scrolling beyond the top of the
     ///     content area.
-    /// </summary>
-    /// <remarks>
     ///     <para>
     ///         When not set, <see cref="View.Viewport"/><c>.Y</c> is constrained to positive values.
     ///     </para>
-    /// </remarks>
+    /// </summary>
     AllowNegativeY = 2,
 
     /// <summary>
     ///     If set, <see cref="View.Viewport"/><c>.Size</c> can be set to negative coordinates enabling scrolling beyond the
     ///     top-left of the
     ///     content area.
-    /// </summary>
-    /// <remarks>
     ///     <para>
     ///         When not set, <see cref="View.Viewport"/><c>.Size</c> is constrained to positive coordinates.
     ///     </para>
-    /// </remarks>
+    /// </summary>
     AllowNegativeLocation = AllowNegativeX | AllowNegativeY,
 
     /// <summary>
     ///     If set, <see cref="View.Viewport"/><c>.X</c> can be set values greater than <see cref="View.GetContentSize ()"/>
     ///     <c>.Width</c> enabling scrolling beyond the right
     ///     of the content area.
-    /// </summary>
-    /// <remarks>
     ///     <para>
     ///         When not set, <see cref="View.Viewport"/><c>.X</c> is constrained to <see cref="View.GetContentSize ()"/>
     ///         <c>.Width - 1</c>.
@@ -61,15 +53,13 @@ public enum ViewportSettings
     ///     <para>
     ///         The practical effect of this is that the last column of the content will always be visible.
     ///     </para>
-    /// </remarks>
+    /// </summary>
     AllowXGreaterThanContentWidth = 4,
 
     /// <summary>
     ///     If set, <see cref="View.Viewport"/><c>.Y</c> can be set values greater than <see cref="View.GetContentSize ()"/>
     ///     <c>.Height</c> enabling scrolling beyond the right
     ///     of the content area.
-    /// </summary>
-    /// <remarks>
     ///     <para>
     ///         When not set, <see cref="View.Viewport"/><c>.Y</c> is constrained to <see cref="View.GetContentSize ()"/>
     ///         <c>.Height - 1</c>.
@@ -79,21 +69,19 @@ public enum ViewportSettings
     ///     <para>
     ///         The practical effect of this is that the last row of the content will always be visible.
     ///     </para>
-    /// </remarks>
+    /// </summary>
     AllowYGreaterThanContentHeight = 8,
 
     /// <summary>
     ///     If set, <see cref="View.Viewport"/><c>.Size</c> can be set values greater than <see cref="View.GetContentSize ()"/>
     ///     enabling scrolling beyond the bottom-right
     ///     of the content area.
-    /// </summary>
-    /// <remarks>
     ///     <para>
     ///         When not set, <see cref="View.Viewport"/> is constrained to <see cref="View.GetContentSize ()"/><c> -1</c>.
     ///         This means the last column and row of the content will remain visible even if there is an attempt to
     ///         scroll the Viewport past the last column or row.
     ///     </para>
-    /// </remarks>
+    /// </summary>
     AllowLocationGreaterThanContentSize = AllowXGreaterThanContentWidth | AllowYGreaterThanContentHeight,
 
     /// <summary>
@@ -106,10 +94,27 @@ public enum ViewportSettings
     ///     If set <see cref="View.Clear()"/> will clear only the portion of the content
     ///     area that is visible within the <see cref="View.Viewport"/>. This is useful for views that have a
     ///     content area larger than the Viewport and want the area outside the content to be visually distinct.
-    /// </summary>
-    /// <remarks>
     ///     <see cref="ClipContentOnly"/> must be set for this setting to work (clipping beyond the visible area must be
     ///     disabled).
-    /// </remarks>
-    ClearContentOnly = 32
+    /// </summary>
+    ClearContentOnly = 32,
+
+    /// <summary>
+    ///     If set, the vertical scroll bar (see <see cref="View.HorizontalScrollBar"/>) will be enabled and automatically made visible
+    ///     when the dimension of the <see cref="View.Viewport"/> is smaller than the dimension of <see cref="View.GetContentSize()"/>.
+    /// </summary>
+    EnableHorizontalScrollBar = 64,
+
+    /// <summary>
+    ///     If set, the vertical scroll bar (see <see cref="View.VerticalScrollBar"/>) will be enabled and automatically made visible
+    ///     when the dimension of the <see cref="View.Viewport"/> is smaller than the dimension of <see cref="View.GetContentSize()"/>.
+    /// </summary>
+    EnableVerticalScrollBar = 128,
+
+    /// <summary>
+    ///     If set, the horizontal and vertical scroll bars (see cref="View.HorizontalScrollBar"/> and <see cref="View.VerticalScrollBar"/>)
+    ///     will be enabled and automatically made visible when the dimension of the <see cref="View.Viewport"/> is smaller than the
+    ///     dimension of <see cref="View.GetContentSize()"/>.
+    /// </summary>
+    EnableScrollBars = EnableHorizontalScrollBar | EnableVerticalScrollBar
 }