using System.Diagnostics; namespace Terminal.Gui; /// /// Settings for how scrolling the on the View's Content Area is handled. /// [Flags] public enum ScrollSettings { /// /// Default settings. /// Default = 0, /// /// If set, does not restrict vertical scrolling to .Height. /// NoRestrictVertical = 1, /// /// If set, does not restrict horizontal scrolling to .Width. /// NoRestrictHorizontal = 2, /// /// If set, does not restrict either vertical or horizontal scrolling to . /// NoRestrict = NoRestrictVertical | NoRestrictHorizontal } public partial class View { #region Content Area private Size _contentSize; /// /// Gets or sets the size of the View's content. If the value is Size.Empty the size of the content is /// the same as the size of , and Viewport.Location will always be 0, 0. /// /// /// /// If a positive size is provided, describes the portion of the content currently visible /// to the view. This enables virtual scrolling. /// /// /// Negative sizes are not supported. /// /// public Size ContentSize { get => _contentSize == Size.Empty ? Viewport.Size : _contentSize; set { if (value.Width < 0 || value.Height < 0) { throw new ArgumentException (@"ContentSize cannot be negative.", nameof (value)); } if (value == _contentSize) { return; } _contentSize = value; OnContentSizeChanged (new (_contentSize)); } } /// /// Called when changes. Invokes the event. /// /// /// protected bool? OnContentSizeChanged (SizeChangedEventArgs e) { ContentSizeChanged?.Invoke (this, e); if (e.Cancel != true) { SetNeedsDisplay (); } return e.Cancel; } /// /// Event that is raised when the changes. /// public event EventHandler ContentSizeChanged; /// /// Converts a Content-relative location to a Screen-relative location. /// /// The Content-relative location. /// The Screen-relative location. public Point ContentToScreen (in Point location) { // Subtract the ViewportOffsetFromFrame to get the Viewport-relative location. Point viewportOffset = GetViewportOffsetFromFrame (); Point contentRelativeToViewport = location; contentRelativeToViewport.Offset (-Viewport.X, -Viewport.Y); // Translate to Screen-Relative (our SuperView's Viewport-relative coordinates) Rectangle screen = ViewportToScreen (new (contentRelativeToViewport, Size.Empty)); return screen.Location; } /// Converts a Screen-relative coordinate to a Content-relative coordinate. /// /// Content-relative means relative to the top-left corner of the view's Content, which is /// always at 0, 0. /// /// Column relative to the left side of the Content. /// Row relative to the top of the Content /// The coordinate relative to this view's Content. public Point ScreenToContent (in Point location) { Point viewportOffset = GetViewportOffsetFromFrame (); Point screen = ScreenToFrame (location.X, location.Y); screen.Offset (Viewport.X - viewportOffset.X, Viewport.Y - viewportOffset.Y); return screen; } #endregion Content Area #region Viewport /// /// Gets or sets how scrolling the on the View's Content Area is handled. /// public ScrollSettings ScrollSettings { get; set; } /// /// The location of the viewport into the view's content (0,0) is the top-left corner of the content. The Content /// area's size /// is . /// private Point _viewportLocation; /// /// Gets or sets the rectangle describing the portion of the View's content that is visible to the user. /// The viewport Location is relative to the top-left corner of the inner rectangle of . /// If the viewport Size is the same as the Location will be 0, 0. /// /// /// The rectangle describing the location and size of the viewport into the View's virtual content, described by /// . /// /// /// /// Positive values for the location indicate the visible area is offset into (down-and-right) the View's virtual /// . This enables virtual scrolling. /// /// /// Negative values for the location indicate the visible area is offset above (up-and-left) the View's virtual /// . This enables virtual zoom. /// /// /// The property controls how scrolling is handled. If is /// /// /// If is the value of Viewport is indeterminate until /// the view has been initialized ( is true) and has been /// called. /// /// /// Updates to the Viewport Size updates , and has the same impact as updating the /// . /// /// /// Altering the Viewport Size will eventually (when the view is next laid out) cause the /// and methods to be called. /// /// public virtual Rectangle Viewport { get { #if DEBUG if (LayoutStyle == LayoutStyle.Computed && !IsInitialized) { Debug.WriteLine ( $"WARNING: Viewport is being accessed before the View has been initialized. This is likely a bug in {this}" ); } #endif // DEBUG if (Margin is null || Border is null || Padding is null) { // CreateAdornments has not been called yet. return new (_viewportLocation, Frame.Size); } Thickness thickness = GetAdornmentsThickness (); return new ( _viewportLocation, new ( Math.Max (0, Frame.Size.Width - thickness.Horizontal), Math.Max (0, Frame.Size.Height - thickness.Vertical) )); } set { if (!ScrollSettings.HasFlag (ScrollSettings.NoRestrictVertical)) { if (value.Y + Viewport.Height > ContentSize.Height) { value.Y = ContentSize.Height - Viewport.Height; } if (value.Y < 0) { value.Y = 0; } } if (!ScrollSettings.HasFlag (ScrollSettings.NoRestrictHorizontal)) { if (value.X + Viewport.Width > ContentSize.Width) { value.X = ContentSize.Width - Viewport.Width; } if (value.X < 0) { value.X = 0; } } Thickness thickness = GetAdornmentsThickness (); Size newSize = new ( value.Size.Width + thickness.Horizontal, value.Size.Height + thickness.Vertical); if (newSize == Frame.Size) { // The change is not changing the Frame, so we don't need to update it. // Just call SetNeedsLayout to update the layout. if (_viewportLocation != value.Location) { _viewportLocation = value.Location; SetNeedsLayout (); } return; } _viewportLocation = value.Location; // Update the Frame because we made it bigger or smaller which impacts subviews. Frame = Frame with { Size = newSize }; } } /// /// Converts a -relative location to a screen-relative location. /// /// /// Viewport-relative means relative to the top-left corner of the inner rectangle of the . /// public Rectangle ViewportToScreen (in Rectangle location) { // Translate bounds to Frame (our SuperView's Viewport-relative coordinates) Rectangle screen = FrameToScreen (); Point viewportOffset = GetViewportOffsetFromFrame (); screen.Offset (viewportOffset.X + location.X, viewportOffset.Y + location.Y); return new (screen.Location, location.Size); } /// Converts a screen-relative coordinate to a Viewport-relative coordinate. /// The coordinate relative to this view's . /// /// Viewport-relative means relative to the top-left corner of the inner rectangle of the . /// /// Column relative to the left side of the Viewport. /// Row relative to the top of the Viewport public Point ScreenToViewport (int x, int y) { Point viewportOffset = GetViewportOffsetFromFrame (); Point screen = ScreenToFrame (x, y); screen.Offset (-viewportOffset.X, -viewportOffset.Y); return screen; } /// /// Helper to get the X and Y offset of the Viewport from the Frame. This is the sum of the Left and Top properties /// of , and . /// public Point GetViewportOffsetFromFrame () { return Padding is null ? Point.Empty : Padding.Thickness.GetInside (Padding.Frame).Location; } /// /// Scrolls the view vertically by the specified number of rows. /// /// /// /// /// /// /// if the was changed. public bool? ScrollVertical (int rows) { if (ContentSize == Size.Empty || ContentSize == Viewport.Size) { return false; } Viewport = Viewport with { Y = Viewport.Y + rows }; return true; } /// /// Scrolls the view horizontally by the specified number of columns. /// /// /// /// /// /// /// if the was changed. public bool? ScrollHorizontal (int cols) { if (ContentSize == Size.Empty || ContentSize == Viewport.Size) { return false; } Viewport = Viewport with { X = Viewport.X + cols }; return true; } #endregion Viewport }