using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
namespace Terminal.Gui;
///
/// Determines the LayoutStyle for a , if Absolute, during , the
/// value from the will be used, if the value is Computed, then
/// will be updated from the X, Y objects and the Width and Height objects.
///
public enum LayoutStyle
{
///
/// The position and size of the view are based .
///
Absolute,
///
/// The position and size of the view will be computed based on
/// , , , and .
/// will
/// provide the absolute computed values.
///
Computed
}
public partial class View
{
bool _autoSize;
///
/// Backing property for Frame - The frame for the object. Relative to the SuperView's Bounds.
///
Rect _frame;
///
/// Gets or sets location and size of the view. The frame is relative to the 's
/// .
///
///
/// The rectangle describing the location and size of the view, in coordinates relative to the
/// .
///
///
///
/// Change the Frame when using the layout style to move or resize views.
///
///
/// Altering the Frame will change to .
/// Additionally, , , , and will be set
/// to the values of the Frame (using and ).
///
///
/// Altering the Frame will eventually (when the view is next drawn) cause the
///
/// and methods to be called.
///
///
public virtual Rect Frame
{
get => _frame;
set
{
_frame = new Rect(value.X, value.Y, Math.Max(value.Width, 0), Math.Max(value.Height, 0));
// If Frame gets set, by definition, the View is now LayoutStyle.Absolute, so
// set all Pos/Dim to Absolute values.
_x = _frame.X;
_y = _frame.Y;
_width = _frame.Width;
_height = _frame.Height;
if (IsInitialized || LayoutStyle == LayoutStyle.Absolute)
{
LayoutFrames();
TextFormatter.Size = GetTextFormatterSizeNeededForTextAndHotKey();
SetNeedsLayout();
SetNeedsDisplay();
}
}
}
///
/// The frame (specified as a ) that separates a View from other SubViews of the same SuperView.
/// The margin offsets the from the .
///
///
///
/// The frames (, , and ) are not part of the View's
/// content
/// and are not clipped by the View's Clip Area.
///
///
/// Changing the size of a frame (, , or )
/// will change the size of the and trigger to update the layout
/// of the
/// and its .
///
///
public Frame Margin { get; private set; }
///
/// The frame (specified as a ) inside of the view that offsets the from the
/// .
/// The Border provides the space for a visual border (drawn using line-drawing glyphs) and the Title.
/// The Border expands inward; in other words if `Border.Thickness.Top == 2` the border and
/// title will take up the first row and the second row will be filled with spaces.
///
///
///
/// provides a simple helper for turning a simple border frame on or off.
///
///
/// The frames (, , and ) are not part of the View's
/// content
/// and are not clipped by the View's Clip Area.
///
///
/// Changing the size of a frame (, , or )
/// will change the size of the and trigger to update the layout
/// of the
/// and its .
///
///
public Frame Border { get; private set; }
///
/// Gets or sets whether the view has a one row/col thick border.
///
///
///
/// This is a helper for manipulating the view's . Setting this property to any value other
/// than
/// is equivalent to setting 's
/// to `1` and to the value.
///
///
/// Setting this property to is equivalent to setting 's
///
/// to `0` and to .
///
///
/// For more advanced customization of the view's border, manipulate see directly.
///
///
public LineStyle BorderStyle
{
get => Border?.BorderStyle ?? LineStyle.None;
set
{
if (Border == null)
{
throw new InvalidOperationException("Border is null; this is likely a bug.");
}
if (value != LineStyle.None)
{
Border.Thickness = new Thickness(1);
}
else
{
Border.Thickness = new Thickness(0);
}
Border.BorderStyle = value;
LayoutFrames();
SetNeedsLayout();
}
}
///
/// The frame (specified as a ) inside of the view that offsets the from the
/// .
///
///
///
/// The frames (, , and ) are not part of the View's
/// content
/// and are not clipped by the View's Clip Area.
///
///
/// Changing the size of a frame (, , or )
/// will change the size of the and trigger to update the layout
/// of the
/// and its .
///
///
public Frame Padding { get; private set; }
///
/// Controls how the View's is computed during . If the style is set to
/// , LayoutSubviews does not change the .
/// If the style is the is updated using
/// the , , , and properties.
///
///
///
/// Setting this property to will cause to determine the
/// size and position of the view. and will be set to
/// using .
///
///
/// Setting this property to will cause the view to use the
/// method to
/// size and position of the view. If either of the and properties are `null` they
/// will be set to using
/// the current value of .
/// If either of the and properties are `null` they will be set to
/// using .
///
///
/// The layout style.
public LayoutStyle LayoutStyle
{
get
{
if (_x is Pos.PosAbsolute && _y is Pos.PosAbsolute && _width is Dim.DimAbsolute && _height is Dim.DimAbsolute)
{
return LayoutStyle.Absolute;
}
else
{
return LayoutStyle.Computed;
}
}
set
{
// TODO: Remove this setter and make LayoutStyle read-only for real.
throw new InvalidOperationException("LayoutStyle is read-only.");
}
}
///
/// The bounds represent the View-relative rectangle used for this view; the area inside of the view where subviews and
/// content are presented.
///
/// The rectangle describing the location and size of the area where the views' subviews and content are drawn.
///
///
/// If is the value of Bounds is indeterminate until
/// the
/// view has been initialized ( is true) and has been
/// called.
///
///
/// Updates to the Bounds updates , and has the same side effects as updating the
/// .
///
///
/// Altering the Bounds will eventually (when the view is next drawn) cause the
///
/// and methods to be called.
///
///
/// Because coordinates are relative to the upper-left corner of the ,
/// the coordinates of the upper-left corner of the rectangle returned by this property are (0,0).
/// Use this property to obtain the size of the area of the view for tasks such as drawing the view's contents.
///
///
public virtual Rect Bounds
{
get
{
#if DEBUG
if (LayoutStyle == LayoutStyle.Computed && !IsInitialized)
{
Debug.WriteLine($"WARNING: Bounds is being accessed before the View has been initialized. This is likely a bug in {this}");
}
#endif // DEBUG
//var frameRelativeBounds = Padding?.Thickness.GetInside (Padding.Frame) ?? new Rect (default, Frame.Size);
var frameRelativeBounds = FrameGetInsideBounds();
return new Rect(default, frameRelativeBounds.Size);
}
set
{
// BUGBUG: Margin etc.. can be null (if typeof(Frame))
Frame = new Rect(Frame.Location,
new Size(
value.Size.Width + Margin.Thickness.Horizontal + Border.Thickness.Horizontal + Padding.Thickness.Horizontal,
value.Size.Height + Margin.Thickness.Vertical + Border.Thickness.Vertical + Padding.Thickness.Vertical
)
);
}
}
Pos _x = Pos.At(0);
///
/// Gets or sets the X position for the view (the column).
///
/// The object representing the X position.
///
///
/// If is the value is indeterminate until the
/// view has been initialized ( is true) and has been
/// called.
///
///
/// Changing this property will eventually (when the view is next drawn) cause the
/// and
/// methods to be called.
///
///
/// If is changing this property will cause the
/// to be updated. If
/// the new value is not of type the will change to
/// .
///
///
/// is the same as Pos.Absolute(0).
///
///
public Pos X
{
get => VerifyIsInitialized(_x, nameof(X));
set
{
_x = value ?? throw new ArgumentNullException(nameof(value), @$"{nameof(X)} cannot be null");
OnResizeNeeded();
}
}
Pos _y = Pos.At(0);
///
/// Gets or sets the Y position for the view (the row).
///
/// The object representing the Y position.
///
///
/// If is the value is indeterminate until the
/// view has been initialized ( is true) and has been
/// called.
///
///
/// Changing this property will eventually (when the view is next drawn) cause the
/// and
/// methods to be called.
///
///
/// If is changing this property will cause the
/// to be updated. If
/// the new value is not of type the will change to
/// .
///
///
/// is the same as Pos.Absolute(0).
///
///
public Pos Y
{
get => VerifyIsInitialized(_y, nameof(Y));
set
{
_y = value ?? throw new ArgumentNullException(nameof(value), @$"{nameof(Y)} cannot be null");
OnResizeNeeded();
}
}
Dim _width = Dim.Sized(0);
///
/// Gets or sets the width of the view.
///
/// The object representing the width of the view (the number of columns).
///
///
/// If is the value is indeterminate until the
/// view has been initialized ( is true) and has been
/// called.
///
///
/// Changing this property will eventually (when the view is next drawn) cause the
///
/// and methods to be called.
///
///
/// If is changing this property will cause the
/// to be updated. If
/// the new value is not of type the will change to
/// .
///
///
public Dim Width
{
get => VerifyIsInitialized(_width, nameof(Width));
set
{
_width = value ?? throw new ArgumentNullException(nameof(value), @$"{nameof(Width)} cannot be null");
if (ValidatePosDim)
{
var isValidNewAutSize = AutoSize && IsValidAutoSizeWidth(_width);
if (IsAdded && AutoSize && !isValidNewAutSize)
{
throw new InvalidOperationException("Must set AutoSize to false before set the Width.");
}
}
OnResizeNeeded();
}
}
Dim _height = Dim.Sized(0);
///
/// Gets or sets the height of the view.
///
/// The object representing the height of the view (the number of rows).
///
///
/// If is the value is indeterminate until the
/// view has been initialized ( is true) and has been
/// called.
///
///
/// Changing this property will eventually (when the view is next drawn) cause the
///
/// and methods to be called.
///
///
/// If is changing this property will cause the
/// to be updated. If
/// the new value is not of type the will change to
/// .
///
///
public Dim Height
{
get => VerifyIsInitialized(_height, nameof(Height));
set
{
_height = value ?? throw new ArgumentNullException(nameof(value), @$"{nameof(Height)} cannot be null");
if (ValidatePosDim)
{
var isValidNewAutSize = AutoSize && IsValidAutoSizeHeight(_height);
if (IsAdded && AutoSize && !isValidNewAutSize)
{
throw new InvalidOperationException("Must set AutoSize to false before setting the Height.");
}
}
OnResizeNeeded();
}
}
///
/// Gets or sets whether validation of and occurs.
///
///
/// Setting this to will enable validation of , , ,
/// and
/// during set operations and in .If invalid settings are discovered exceptions will be thrown
/// indicating the error.
/// This will impose a performance penalty and thus should only be used for debugging.
///
public bool ValidatePosDim { get; set; }
internal bool LayoutNeeded { get; private set; } = true;
///
/// Gets or sets a flag that determines whether the View will be automatically resized to fit the
/// within
///
/// The default is . Set to to turn on AutoSize. If
/// then
/// and will be used if can fit;
/// if won't fit the view will be resized as needed.
///
///
/// In addition, if is the new values of and
/// must be of the same types of the existing one to avoid breaking the settings.
///
///
public virtual bool AutoSize
{
get => _autoSize;
set
{
var v = ResizeView(value);
TextFormatter.AutoSize = v;
if (_autoSize != v)
{
_autoSize = v;
TextFormatter.NeedsFormat = true;
UpdateTextFormatterText();
OnResizeNeeded();
}
}
}
///
/// Event called only once when the is being initialized for the first time.
/// Allows configurations and assignments to be performed before the being shown.
/// This derived from to allow notify all the views that are being
/// initialized.
///
public event EventHandler Initialized;
///
/// Helper to get the total thickness of the , , and .
///
/// A thickness that describes the sum of the Frames' thicknesses.
public Thickness GetFramesThickness()
{
var left = Margin.Thickness.Left + Border.Thickness.Left + Padding.Thickness.Left;
var top = Margin.Thickness.Top + Border.Thickness.Top + Padding.Thickness.Top;
var right = Margin.Thickness.Right + Border.Thickness.Right + Padding.Thickness.Right;
var bottom = Margin.Thickness.Bottom + Border.Thickness.Bottom + Padding.Thickness.Bottom;
return new Thickness(left, top, right, bottom);
}
///
/// Helper to get the X and Y offset of the Bounds from the Frame. This is the sum of the Left and Top properties of
/// , and .
///
public Point GetBoundsOffset() => new(Padding?.Thickness.GetInside(Padding.Frame).X ?? 0, Padding?.Thickness.GetInside(Padding.Frame).Y ?? 0);
///
/// Creates the view's objects. This internal method is overridden by Frame to do nothing
/// to prevent recursion during View construction.
///
internal virtual void CreateFrames()
{
void ThicknessChangedHandler(object sender, EventArgs e)
{
if (IsInitialized)
{
LayoutFrames();
}
SetNeedsLayout();
SetNeedsDisplay();
}
if (Margin != null)
{
Margin.ThicknessChanged -= ThicknessChangedHandler;
Margin.Dispose();
}
Margin = new Frame { Id = "Margin", Thickness = new Thickness(0) };
Margin.ThicknessChanged += ThicknessChangedHandler;
Margin.Parent = this;
if (Border != null)
{
Border.ThicknessChanged -= ThicknessChangedHandler;
Border.Dispose();
}
Border = new Frame { Id = "Border", Thickness = new Thickness(0) };
Border.ThicknessChanged += ThicknessChangedHandler;
Border.Parent = this;
// TODO: Create View.AddAdornment
if (Padding != null)
{
Padding.ThicknessChanged -= ThicknessChangedHandler;
Padding.Dispose();
}
Padding = new Frame { Id = "Padding", Thickness = new Thickness(0) };
Padding.ThicknessChanged += ThicknessChangedHandler;
Padding.Parent = this;
}
Rect FrameGetInsideBounds()
{
if (Margin == null || Border == null || Padding == null)
{
return new Rect(default, Frame.Size);
}
var width = Math.Max(0, Frame.Size.Width - Margin.Thickness.Horizontal - Border.Thickness.Horizontal - Padding.Thickness.Horizontal);
var height = Math.Max(0, Frame.Size.Height - Margin.Thickness.Vertical - Border.Thickness.Vertical - Padding.Thickness.Vertical);
return new Rect(Point.Empty, new Size(width, height));
}
// Diagnostics to highlight when X or Y is read before the view has been initialized
Pos VerifyIsInitialized(Pos pos, string member)
{
#if DEBUG
if (LayoutStyle == LayoutStyle.Computed && !IsInitialized)
{
Debug.WriteLine($"WARNING: \"{this}\" has not been initialized; {member} is indeterminate {pos}. This is potentially a bug.");
}
#endif // DEBUG
return pos;
}
// Diagnostics to highlight when Width or Height is read before the view has been initialized
Dim VerifyIsInitialized(Dim dim, string member)
{
#if DEBUG
if (LayoutStyle == LayoutStyle.Computed && !IsInitialized)
{
Debug.WriteLine($"WARNING: \"{this}\" has not been initialized; {member} is indeterminate: {dim}. This is potentially a bug.");
}
#endif // DEBUG
return dim;
}
///
/// Throws an if is or
/// .
/// Used when is turned on to verify correct behavior.
///
///
/// Does not verify if this view is Toplevel (WHY??!?).
///
/// The property name.
///
///
void CheckAbsolute(string prop, object oldValue, object newValue)
{
if (!IsInitialized || !ValidatePosDim || oldValue == null || oldValue.GetType() == newValue.GetType() || this is Toplevel)
{
return;
}
if (oldValue.GetType() != newValue.GetType() && newValue is (Pos.PosAbsolute or Dim.DimAbsolute))
{
throw new ArgumentException($@"{prop} must not be Absolute if LayoutStyle is Computed", prop);
}
}
///
/// Called whenever the view needs to be resized. Sets and
/// triggers a call.
///
///
/// Can be overridden if the view resize behavior is different than the default.
///
protected virtual void OnResizeNeeded()
{
var actX = _x is Pos.PosAbsolute ? _x.Anchor(0) : _frame.X;
var actY = _y is Pos.PosAbsolute ? _y.Anchor(0) : _frame.Y;
if (AutoSize)
{
//if (TextAlignment == TextAlignment.Justified) {
// throw new InvalidOperationException ("TextAlignment.Justified cannot be used with AutoSize");
//}
var s = GetAutoSize();
var w = _width is Dim.DimAbsolute && _width.Anchor(0) > s.Width ? _width.Anchor(0) : s.Width;
var h = _height is Dim.DimAbsolute && _height.Anchor(0) > s.Height ? _height.Anchor(0) : s.Height;
_frame = new Rect(new Point(actX, actY), new Size(w, h)); // Set frame, not Frame!
}
else
{
var w = _width is Dim.DimAbsolute ? _width.Anchor(0) : _frame.Width;
var h = _height is Dim.DimAbsolute ? _height.Anchor(0) : _frame.Height;
//// BUGBUG: v2 - ? - If layoutstyle is absolute, this overwrites the current frame h/w with 0. Hmmm...
//// This is needed for DimAbsolute values by setting the frame before LayoutSubViews.
_frame = new Rect(new Point(actX, actY), new Size(w, h)); // Set frame, not Frame!
}
//// BUGBUG: I think these calls are redundant or should be moved into just the AutoSize case
if (IsInitialized || LayoutStyle == LayoutStyle.Absolute)
{
SetFrameToFitText();
LayoutFrames();
TextFormatter.Size = GetTextFormatterSizeNeededForTextAndHotKey();
SetNeedsLayout();
SetNeedsDisplay();
}
}
internal void SetNeedsLayout()
{
if (LayoutNeeded)
{
return;
}
LayoutNeeded = true;
foreach (var view in Subviews)
{
view.SetNeedsLayout();
}
TextFormatter.NeedsFormat = true;
SuperView?.SetNeedsLayout();
}
///
/// Indicates that the view does not need to be laid out.
///
protected void ClearLayoutNeeded() => LayoutNeeded = false;
///
/// Converts a screen-relative coordinate to a Frame-relative coordinate. Frame-relative means
/// relative to the View's 's .
///
/// The coordinate relative to the 's .
/// Screen-relative column.
/// Screen-relative row.
public Point ScreenToFrame(int x, int y)
{
var superViewBoundsOffset = SuperView?.GetBoundsOffset() ?? Point.Empty;
var ret = new Point(x - Frame.X - superViewBoundsOffset.X, y - Frame.Y - superViewBoundsOffset.Y);
if (SuperView != null)
{
var superFrame = SuperView.ScreenToFrame(x - superViewBoundsOffset.X, y - superViewBoundsOffset.Y);
ret = new Point(superFrame.X - Frame.X, superFrame.Y - Frame.Y);
}
return ret;
}
///
/// Converts a screen-relative coordinate to a bounds-relative coordinate.
///
/// The coordinate relative to this view's .
/// Screen-relative column.
/// Screen-relative row.
public Point ScreenToBounds(int x, int y)
{
var screen = ScreenToFrame(x, y);
var boundsOffset = GetBoundsOffset();
return new Point(screen.X - boundsOffset.X, screen.Y - boundsOffset.Y);
}
///
/// Converts a -relative coordinate to a screen-relative coordinate. The output is optionally clamped
/// to the screen dimensions.
///
/// -relative column.
/// -relative row.
/// Absolute column; screen-relative.
/// Absolute row; screen-relative.
///
/// If , and will be clamped to the
/// screen dimensions (will never be negative and will always be less than and
/// , respectively.
///
public virtual void BoundsToScreen(int x, int y, out int rx, out int ry, bool clamped = true)
{
var boundsOffset = GetBoundsOffset();
rx = x + Frame.X + boundsOffset.X;
ry = y + Frame.Y + boundsOffset.Y;
var super = SuperView;
while (super != null)
{
boundsOffset = super.GetBoundsOffset();
rx += super.Frame.X + boundsOffset.X;
ry += super.Frame.Y + boundsOffset.Y;
super = super.SuperView;
}
// The following ensures that the cursor is always in the screen boundaries.
if (clamped)
{
ry = Math.Min(ry, Driver.Rows - 1);
rx = Math.Min(rx, Driver.Cols - 1);
}
}
///
/// Converts a -relative region to a screen-relative region.
///
public Rect BoundsToScreen(Rect region)
{
BoundsToScreen(region.X, region.Y, out var x, out var y, false);
return new Rect(x, y, region.Width, region.Height);
}
///
/// Gets the with a screen-relative location.
///
/// The location and size of the view in screen-relative coordinates.
public virtual Rect FrameToScreen()
{
var ret = Frame;
var super = SuperView;
while (super != null)
{
var boundsOffset = super.GetBoundsOffset();
ret.X += super.Frame.X + boundsOffset.X;
ret.Y += super.Frame.Y + boundsOffset.Y;
super = super.SuperView;
}
return ret;
}
// TODO: Come up with a better name for this method. "SetRelativeLayout" lacks clarity and confuses. AdjustSizeAndPosition?
///
/// Applies the view's position (, ) and dimension (, and
/// ) to
/// , given a rectangle describing the SuperView's Bounds (nominally the same as
/// this.SuperView.Bounds).
///
///
/// The rectangle describing the SuperView's Bounds (nominally the same as
/// this.SuperView.Bounds).
///
internal void SetRelativeLayout(Rect superviewBounds)
{
Debug.Assert(_x != null);
Debug.Assert(_y != null);
Debug.Assert(_width != null);
Debug.Assert(_height != null);
int newX, newW, newY, newH;
var autosize = Size.Empty;
if (AutoSize)
{
// Note this is global to this function and used as such within the local functions defined
// below. In v2 AutoSize will be re-factored to not need to be dealt with in this function.
autosize = GetAutoSize();
}
// TODO: Since GetNewLocationAndDimension does not depend on View, it can be moved into PosDim.cs
// TODO: to make architecture more clean. Do this after DimAuto is implemented and the
// TODO: View.AutoSize stuff is removed.
// Returns the new dimension (width or height) and location (x or y) for the View given
// the superview's Bounds
// the current Pos (View.X or View.Y)
// the current Dim (View.Width or View.Height)
// This method is called recursively if pos is Pos.PosCombine
(int newLocation, int newDimension) GetNewLocationAndDimension(bool width, Rect superviewBounds, Pos pos, Dim dim, int autosizeDimension)
{
// Gets the new dimension (width or height, dependent on `width`) of the given Dim given:
// location: the current location (x or y)
// dimension: the current dimension (width or height)
// autosize: the size to use if autosize = true
// This mehod is recursive if d is Dim.DimCombine
int GetNewDimension(Dim d, int location, int dimension, int autosize)
{
int newDimension;
switch (d)
{
case Dim.DimCombine combine:
// TODO: Move combine logic into DimCombine?
var leftNewDim = GetNewDimension(combine._left, location, dimension, autosize);
var rightNewDim = GetNewDimension(combine._right, location, dimension, autosize);
if (combine._add)
{
newDimension = leftNewDim + rightNewDim;
}
else
{
newDimension = leftNewDim - rightNewDim;
}
newDimension = AutoSize && autosize > newDimension ? autosize : newDimension;
break;
case Dim.DimFactor factor when !factor.IsFromRemaining():
newDimension = d.Anchor(dimension);
newDimension = AutoSize && autosize > newDimension ? autosize : newDimension;
break;
case Dim.DimFill:
case Dim.DimAbsolute:
default:
newDimension = Math.Max(d.Anchor(dimension - location), 0);
newDimension = AutoSize && autosize > newDimension ? autosize : newDimension;
break;
}
return newDimension;
}
int newDimension, newLocation;
var superviewDimension = width ? superviewBounds.Width : superviewBounds.Height;
// Determine new location
switch (pos)
{
case Pos.PosCenter posCenter:
// For Center, the dimension is dependent on location, but we need to force getting the dimension first
// using a location of 0
newDimension = Math.Max(GetNewDimension(dim, 0, superviewDimension, autosizeDimension), 0);
newLocation = posCenter.Anchor(superviewDimension - newDimension);
newDimension = Math.Max(GetNewDimension(dim, newLocation, superviewDimension, autosizeDimension), 0);
break;
case Pos.PosCombine combine:
// TODO: Move combine logic into PosCombine?
int left, right;
(left, newDimension) = GetNewLocationAndDimension(width, superviewBounds, combine._left, dim, autosizeDimension);
(right, newDimension) = GetNewLocationAndDimension(width, superviewBounds, combine._right, dim, autosizeDimension);
if (combine._add)
{
newLocation = left + right;
}
else
{
newLocation = left - right;
}
newDimension = Math.Max(GetNewDimension(dim, newLocation, superviewDimension, autosizeDimension), 0);
break;
case Pos.PosAnchorEnd:
case Pos.PosAbsolute:
case Pos.PosFactor:
case Pos.PosFunc:
case Pos.PosView:
default:
newLocation = pos?.Anchor(superviewDimension) ?? 0;
newDimension = Math.Max(GetNewDimension(dim, newLocation, superviewDimension, autosizeDimension), 0);
break;
}
return (newLocation, newDimension);
}
// horizontal/width
(newX, newW) = GetNewLocationAndDimension(true, superviewBounds, _x, _width, autosize.Width);
// vertical/height
(newY, newH) = GetNewLocationAndDimension(false, superviewBounds, _y, _height, autosize.Height);
var r = new Rect(newX, newY, newW, newH);
if (Frame != r)
{
Frame = r;
// BUGBUG: Why is this AFTER setting Frame? Seems duplicative.
if (!SetFrameToFitText())
{
TextFormatter.Size = GetTextFormatterSizeNeededForTextAndHotKey();
}
}
}
///
/// Fired after the View's method has completed.
///
///
/// Subscribe to this event to perform tasks when the has been resized or the layout has otherwise
/// changed.
///
public event EventHandler LayoutStarted;
///
/// Raises the event. Called from before any subviews have been
/// laid out.
///
internal virtual void OnLayoutStarted(LayoutEventArgs args) => LayoutStarted?.Invoke(this, args);
///
/// Fired after the View's method has completed.
///
///
/// Subscribe to this event to perform tasks when the has been resized or the layout has otherwise
/// changed.
///
public event EventHandler LayoutComplete;
///
/// Raises the event. Called from before all sub-views have been
/// laid out.
///
internal virtual void OnLayoutComplete(LayoutEventArgs args) => LayoutComplete?.Invoke(this, args);
internal void CollectPos(Pos pos, View from, ref HashSet nNodes, ref HashSet<(View, View)> nEdges)
{
switch (pos)
{
case Pos.PosView pv:
// See #2461
//if (!from.InternalSubviews.Contains (pv.Target)) {
// throw new InvalidOperationException ($"View {pv.Target} is not a subview of {from}");
//}
if (pv.Target != this)
{
nEdges.Add((pv.Target, from));
}
return;
case Pos.PosCombine pc:
CollectPos(pc._left, from, ref nNodes, ref nEdges);
CollectPos(pc._right, from, ref nNodes, ref nEdges);
break;
}
}
internal void CollectDim(Dim dim, View from, ref HashSet nNodes, ref HashSet<(View, View)> nEdges)
{
switch (dim)
{
case Dim.DimView dv:
// See #2461
//if (!from.InternalSubviews.Contains (dv.Target)) {
// throw new InvalidOperationException ($"View {dv.Target} is not a subview of {from}");
//}
if (dv.Target != this)
{
nEdges.Add((dv.Target, from));
}
return;
case Dim.DimCombine dc:
CollectDim(dc._left, from, ref nNodes, ref nEdges);
CollectDim(dc._right, from, ref nNodes, ref nEdges);
break;
}
}
internal void CollectAll(View from, ref HashSet nNodes, ref HashSet<(View, View)> nEdges)
{
// BUGBUG: This should really only work on initialized subviews
foreach (var v in from.InternalSubviews /*.Where(v => v.IsInitialized)*/)
{
nNodes.Add(v);
if (v.LayoutStyle != LayoutStyle.Computed)
{
continue;
}
CollectPos(v.X, v, ref nNodes, ref nEdges);
CollectPos(v.Y, v, ref nNodes, ref nEdges);
CollectDim(v.Width, v, ref nNodes, ref nEdges);
CollectDim(v.Height, v, ref nNodes, ref nEdges);
}
}
// https://en.wikipedia.org/wiki/Topological_sorting
internal static List TopologicalSort(View superView, IEnumerable nodes, ICollection<(View From, View To)> edges)
{
var result = new List();
// Set of all nodes with no incoming edges
var noEdgeNodes = new HashSet(nodes.Where(n => edges.All(e => !e.To.Equals(n))));
while (noEdgeNodes.Any())
{
// remove a node n from S
var n = noEdgeNodes.First();
noEdgeNodes.Remove(n);
// add n to tail of L
if (n != superView)
{
result.Add(n);
}
// for each node m with an edge e from n to m do
foreach (var e in edges.Where(e => e.From.Equals(n)).ToArray())
{
var m = e.To;
// remove edge e from the graph
edges.Remove(e);
// if m has no other incoming edges then
if (edges.All(me => !me.To.Equals(m)) && m != superView)
{
// insert m into S
noEdgeNodes.Add(m);
}
}
}
if (!edges.Any())
{
return result;
}
foreach ((var from, var to) in edges)
{
if (from == to)
{
// if not yet added to the result, add it and remove from edge
if (result.Find(v => v == from) == null)
{
result.Add(from);
}
edges.Remove((from, to));
}
else if (from.SuperView == to.SuperView)
{
// if 'from' is not yet added to the result, add it
if (result.Find(v => v == from) == null)
{
result.Add(from);
}
// if 'to' is not yet added to the result, add it
if (result.Find(v => v == to) == null)
{
result.Add(to);
}
// remove from edge
edges.Remove((from, to));
}
else if (from != superView?.GetTopSuperView(to, from) && !ReferenceEquals(from, to))
{
if (ReferenceEquals(from.SuperView, to))
{
throw new InvalidOperationException($"ComputedLayout for \"{superView}\": \"{to}\" references a SubView (\"{from}\").");
}
throw new InvalidOperationException($"ComputedLayout for \"{superView}\": \"{from}\" linked with \"{to}\" was not found. Did you forget to add it to {superView}?");
}
}
// return L (a topologically sorted order)
return result;
} // TopologicalSort
///
/// Overriden by to do nothing, as the does not have frames.
///
internal virtual void LayoutFrames()
{
if (Margin == null)
{
return; // CreateFrames() has not been called yet
}
if (Margin.Frame.Size != Frame.Size)
{
Margin._frame = new Rect(Point.Empty, Frame.Size);
Margin.X = 0;
Margin.Y = 0;
Margin.Width = Frame.Size.Width;
Margin.Height = Frame.Size.Height;
Margin.SetNeedsLayout();
Margin.SetNeedsDisplay();
}
var border = Margin.Thickness.GetInside(Margin.Frame);
if (border != Border.Frame)
{
Border._frame = new Rect(new Point(border.Location.X, border.Location.Y), border.Size);
Border.X = border.Location.X;
Border.Y = border.Location.Y;
Border.Width = border.Size.Width;
Border.Height = border.Size.Height;
Border.SetNeedsLayout();
Border.SetNeedsDisplay();
}
var padding = Border.Thickness.GetInside(Border.Frame);
if (padding != Padding.Frame)
{
Padding._frame = new Rect(new Point(padding.Location.X, padding.Location.Y), padding.Size);
Padding.X = padding.Location.X;
Padding.Y = padding.Location.Y;
Padding.Width = padding.Size.Width;
Padding.Height = padding.Size.Height;
Padding.SetNeedsLayout();
Padding.SetNeedsDisplay();
}
}
///
/// Invoked when a view starts executing or when the dimensions of the view have changed, for example in
/// response to the container view or terminal resizing.
///
///
///
/// The position and dimensions of the view are indeterminate until the view has been initialized. Therefore,
/// the behavior of this method is indeterminate if is .
///
///
/// Raises the event) before it returns.
///
///
public virtual void LayoutSubviews()
{
if (!IsInitialized)
{
Debug.WriteLine($"WARNING: LayoutSubviews called before view has been initialized. This is likely a bug in {this}");
}
if (!LayoutNeeded)
{
return;
}
LayoutFrames();
var oldBounds = Bounds;
OnLayoutStarted(new LayoutEventArgs { OldBounds = oldBounds });
TextFormatter.Size = GetTextFormatterSizeNeededForTextAndHotKey();
// Sort out the dependencies of the X, Y, Width, Height properties
var nodes = new HashSet();
var edges = new HashSet<(View, View)>();
CollectAll(this, ref nodes, ref edges);
var ordered = TopologicalSort(SuperView, nodes, edges);
foreach (var v in ordered)
{
LayoutSubview(v, new Rect(GetBoundsOffset(), Bounds.Size));
}
// If the 'to' is rooted to 'from' and the layoutstyle is Computed it's a special-case.
// Use LayoutSubview with the Frame of the 'from'
if (SuperView != null && GetTopSuperView() != null && LayoutNeeded && edges.Count > 0)
{
foreach ((var from, var to) in edges)
{
LayoutSubview(to, from.Frame);
}
}
LayoutNeeded = false;
OnLayoutComplete(new LayoutEventArgs { OldBounds = oldBounds });
}
void LayoutSubview(View v, Rect contentArea)
{
if (v.LayoutStyle == LayoutStyle.Computed)
{
v.SetRelativeLayout(contentArea);
}
v.LayoutSubviews();
v.LayoutNeeded = false;
}
bool ResizeView(bool autoSize)
{
if (!autoSize)
{
return false;
}
var boundsChanged = true;
var newFrameSize = GetAutoSize();
if (IsInitialized && newFrameSize != Frame.Size)
{
if (ValidatePosDim)
{
// BUGBUG: This ain't right, obviously. We need to figure out how to handle this.
boundsChanged = ResizeBoundsToFit(newFrameSize);
}
else
{
Height = newFrameSize.Height;
Width = newFrameSize.Width;
}
}
return boundsChanged;
}
///
/// Resizes the View to fit the specified size. Factors in the HotKey.
///
///
/// whether the Bounds was changed or not
bool ResizeBoundsToFit(Size size)
{
var boundsChanged = false;
var canSizeW = TrySetWidth(size.Width - GetHotKeySpecifierLength(), out var rW);
var canSizeH = TrySetHeight(size.Height - GetHotKeySpecifierLength(false), out var rH);
if (canSizeW)
{
boundsChanged = true;
_width = rW;
}
if (canSizeH)
{
boundsChanged = true;
_height = rH;
}
if (boundsChanged)
{
Bounds = new Rect(Bounds.X, Bounds.Y, canSizeW ? rW : Bounds.Width, canSizeH ? rH : Bounds.Height);
}
return boundsChanged;
}
///
/// Gets the Frame dimensions required to fit within using the text
/// specified by the
/// property and accounting for any characters.
///
/// The of the view required to fit the text.
public Size GetAutoSize()
{
var x = 0;
var y = 0;
if (IsInitialized)
{
x = Bounds.X;
y = Bounds.Y;
}
var rect = TextFormatter.CalcRect(x, y, TextFormatter.Text, TextFormatter.Direction);
var newWidth = rect.Size.Width - GetHotKeySpecifierLength() + Margin.Thickness.Horizontal + Border.Thickness.Horizontal + Padding.Thickness.Horizontal;
var newHeight = rect.Size.Height - GetHotKeySpecifierLength(false) + Margin.Thickness.Vertical + Border.Thickness.Vertical + Padding.Thickness.Vertical;
return new Size(newWidth, newHeight);
}
bool IsValidAutoSize(out Size autoSize)
{
var rect = TextFormatter.CalcRect(_frame.X, _frame.Y, TextFormatter.Text, TextDirection);
autoSize = new Size(rect.Size.Width - GetHotKeySpecifierLength(),
rect.Size.Height - GetHotKeySpecifierLength(false));
return !(ValidatePosDim && (!(Width is Dim.DimAbsolute) || !(Height is Dim.DimAbsolute)) ||
_frame.Size.Width != rect.Size.Width - GetHotKeySpecifierLength() ||
_frame.Size.Height != rect.Size.Height - GetHotKeySpecifierLength(false));
}
bool IsValidAutoSizeWidth(Dim width)
{
var rect = TextFormatter.CalcRect(_frame.X, _frame.Y, TextFormatter.Text, TextDirection);
var dimValue = width.Anchor(0);
return !(ValidatePosDim && !(width is Dim.DimAbsolute) || dimValue != rect.Size.Width - GetHotKeySpecifierLength());
}
bool IsValidAutoSizeHeight(Dim height)
{
var rect = TextFormatter.CalcRect(_frame.X, _frame.Y, TextFormatter.Text, TextDirection);
var dimValue = height.Anchor(0);
return !(ValidatePosDim && !(height is Dim.DimAbsolute) || dimValue != rect.Size.Height - GetHotKeySpecifierLength(false));
}
///
/// Determines if the View's can be set to a new value.
///
///
///
/// Contains the width that would result if were set to
/// "/>
///
///
/// if the View's can be changed to the specified value. False
/// otherwise.
///
internal bool TrySetWidth(int desiredWidth, out int resultWidth)
{
var w = desiredWidth;
bool canSetWidth;
switch (Width)
{
case Dim.DimCombine _:
case Dim.DimView _:
case Dim.DimFill _:
// It's a Dim.DimCombine and so can't be assigned. Let it have it's Width anchored.
w = Width.Anchor(w);
canSetWidth = !ValidatePosDim;
break;
case Dim.DimFactor factor:
// Tries to get the SuperView Width otherwise the view Width.
var sw = SuperView != null ? SuperView.Frame.Width : w;
if (factor.IsFromRemaining())
{
sw -= Frame.X;
}
w = Width.Anchor(sw);
canSetWidth = !ValidatePosDim;
break;
default:
canSetWidth = true;
break;
}
resultWidth = w;
return canSetWidth;
}
///
/// Determines if the View's can be set to a new value.
///
///
///
/// Contains the width that would result if were set to
/// "/>
///
///
/// if the View's can be changed to the specified value. False
/// otherwise.
///
internal bool TrySetHeight(int desiredHeight, out int resultHeight)
{
var h = desiredHeight;
bool canSetHeight;
switch (Height)
{
case Dim.DimCombine _:
case Dim.DimView _:
case Dim.DimFill _:
// It's a Dim.DimCombine and so can't be assigned. Let it have it's height anchored.
h = Height.Anchor(h);
canSetHeight = !ValidatePosDim;
break;
case Dim.DimFactor factor:
// Tries to get the SuperView height otherwise the view height.
var sh = SuperView != null ? SuperView.Frame.Height : h;
if (factor.IsFromRemaining())
{
sh -= Frame.Y;
}
h = Height.Anchor(sh);
canSetHeight = !ValidatePosDim;
break;
default:
canSetHeight = true;
break;
}
resultHeight = h;
return canSetHeight;
}
///
/// Finds which view that belong to the superview at the provided location.
///
/// The superview where to look for.
/// The column location in the superview.
/// The row location in the superview.
/// The found view screen relative column location.
/// The found view screen relative row location.
///
/// The view that was found at the and coordinates.
/// if no view was found.
///
public static View FindDeepestView(View start, int x, int y, out int resx, out int resy)
{
resy = resx = 0;
if (start == null || !start.Frame.Contains(x, y))
{
return null;
}
var startFrame = start.Frame;
if (start.InternalSubviews != null)
{
var count = start.InternalSubviews.Count;
if (count > 0)
{
var boundsOffset = start.GetBoundsOffset();
var rx = x - (startFrame.X + boundsOffset.X);
var ry = y - (startFrame.Y + boundsOffset.Y);
for (var i = count - 1; i >= 0; i--)
{
var v = start.InternalSubviews[i];
if (v.Visible && v.Frame.Contains(rx, ry))
{
var deep = FindDeepestView(v, rx, ry, out resx, out resy);
if (deep == null)
{
return v;
}
return deep;
}
}
}
}
resx = x - startFrame.X;
resy = y - startFrame.Y;
return start;
}
}