using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using NStack;
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 on the Frame value.
///
Absolute,
///
/// The position and size of the view will be computed based on the
/// X, Y, Width and Height properties and set on the Frame.
///
Computed
}
///
/// View is the base class for all views on the screen and represents a visible element that can render itself and
/// contains zero or more nested views.
///
///
///
/// The View defines the base functionality for user interface elements in Terminal.Gui. Views
/// can contain one or more subviews, can respond to user input and render themselves on the screen.
///
///
/// Views supports two layout styles: or .
/// The choice as to which layout style is used by the View
/// is determined when the View is initialized. To create a View using Absolute layout, call a constructor that takes a
/// Rect parameter to specify the absolute position and size (the View.). To create a View
/// using Computed layout use a constructor that does not take a Rect parameter and set the X, Y, Width and Height
/// properties on the view. Both approaches use coordinates that are relative to the container they are being added to.
///
///
/// To switch between Absolute and Computed layout, use the property.
///
///
/// Computed layout is more flexible and supports dynamic console apps where controls adjust layout
/// as the terminal resizes or other Views change size or position. The X, Y, Width and Height
/// properties are Dim and Pos objects that dynamically update the position of a view.
/// The X and Y properties are of type
/// and you can use either absolute positions, percentages or anchor
/// points. The Width and Height properties are of type
/// and can use absolute position,
/// percentages and anchors. These are useful as they will take
/// care of repositioning views when view's frames are resized or
/// if the terminal size changes.
///
///
/// Absolute layout requires specifying coordinates and sizes of Views explicitly, and the
/// View will typically stay in a fixed position and size. To change the position and size use the
/// property.
///
///
/// Subviews (child views) can be added to a View by calling the method.
/// The container of a View can be accessed with the property.
///
///
/// To flag a region of the View's to be redrawn call .
/// To flag the entire view for redraw call .
///
///
/// Views have a property that defines the default colors that subviews
/// should use for rendering. This ensures that the views fit in the context where
/// they are being used, and allows for themes to be plugged in. For example, the
/// default colors for windows and toplevels uses a blue background, while it uses
/// a white background for dialog boxes and a red background for errors.
///
///
/// Subclasses should not rely on being
/// set at construction time. If a is not set on a view, the view will inherit the
/// value from its and the value might only be valid once a view has been
/// added to a SuperView.
///
///
/// By using applications will work both
/// in color as well as black and white displays.
///
///
/// Views that are focusable should implement the to make sure that
/// the cursor is placed in a location that makes sense. Unix terminals do not have
/// a way of hiding the cursor, so it can be distracting to have the cursor left at
/// the last focused view. So views should make sure that they place the cursor
/// in a visually sensible place.
///
///
/// The method is invoked when the size or layout of a view has
/// changed. The default processing system will keep the size and dimensions
/// for views that use the , and will recompute the
/// frames for the vies that use .
///
///
public partial class View : Responder, ISupportInitializeNotification {
internal enum Direction {
Forward,
Backward
}
// container == SuperView
View container = null;
View focused = null;
Direction focusDirection;
bool autoSize;
ShortcutHelper shortcutHelper;
///
/// Event fired when a subview is being added to this view.
///
public event Action Added;
///
/// Event fired when a subview is being removed from this view.
///
public event Action Removed;
///
/// Event fired when the view gets focus.
///
public event Action Enter;
///
/// Event fired when the view looses focus.
///
public event Action Leave;
///
/// Event fired when the view receives the mouse event for the first time.
///
public event Action MouseEnter;
///
/// Event fired when the view receives a mouse event for the last time.
///
public event Action MouseLeave;
///
/// Event fired when a mouse event is generated.
///
public event Action MouseClick;
///
/// Event fired when the value is being changed.
///
public event Action CanFocusChanged;
///
/// Event fired when the value is being changed.
///
public event Action EnabledChanged;
///
/// Event fired when the value is being changed.
///
public event Action VisibleChanged;
///
/// Event invoked when the is changed.
///
public event Action HotKeyChanged;
Key hotKey = Key.Null;
///
/// Gets or sets the HotKey defined for this view. A user pressing HotKey on the keyboard while this view has focus will cause the Clicked event to fire.
///
public virtual Key HotKey {
get => hotKey;
set {
if (hotKey != value) {
hotKey = TextFormatter.HotKey = (value == Key.Unknown ? Key.Null : value);
}
}
}
///
/// Gets or sets the specifier character for the hotkey (e.g. '_'). Set to '\xffff' to disable hotkey support for this View instance. The default is '\xffff'.
///
public virtual Rune HotKeySpecifier {
get => TextFormatter.HotKeySpecifier;
set {
TextFormatter.HotKeySpecifier = value;
SetHotKey ();
}
}
///
/// This is the global setting that can be used as a global shortcut to invoke an action if provided.
///
public Key Shortcut {
get => shortcutHelper.Shortcut;
set {
if (shortcutHelper.Shortcut != value && (ShortcutHelper.PostShortcutValidation (value) || value == Key.Null)) {
shortcutHelper.Shortcut = value;
}
}
}
///
/// The keystroke combination used in the as string.
///
public ustring ShortcutTag => ShortcutHelper.GetShortcutTag (shortcutHelper.Shortcut);
///
/// The action to run if the is defined.
///
public virtual Action ShortcutAction { get; set; }
///
/// Gets or sets arbitrary data for the view.
///
/// This property is not used internally.
public object Data { get; set; }
internal Direction FocusDirection {
get => SuperView?.FocusDirection ?? focusDirection;
set {
if (SuperView != null)
SuperView.FocusDirection = value;
else
focusDirection = value;
}
}
///
/// Points to the current driver in use by the view, it is a convenience property
/// for simplifying the development of new views.
///
public static ConsoleDriver Driver => Application.Driver;
static readonly IList empty = new List (0).AsReadOnly ();
// This is null, and allocated on demand.
List subviews;
///
/// This returns a list of the subviews contained by this view.
///
/// The subviews.
public IList Subviews => subviews?.AsReadOnly () ?? empty;
// Internally, we use InternalSubviews rather than subviews, as we do not expect us
// to make the same mistakes our users make when they poke at the Subviews.
internal IList InternalSubviews => subviews ?? empty;
// This is null, and allocated on demand.
List tabIndexes;
///
/// Configurable keybindings supported by the control
///
private Dictionary KeyBindings { get; set; } = new Dictionary ();
private Dictionary> CommandImplementations { get; set; } = new Dictionary> ();
///
/// This returns a tab index list of the subviews contained by this view.
///
/// The tabIndexes.
public IList TabIndexes => tabIndexes?.AsReadOnly () ?? empty;
int tabIndex = -1;
///
/// Indicates the index of the current from the list.
///
public int TabIndex {
get { return tabIndex; }
set {
if (!CanFocus) {
tabIndex = -1;
return;
} else if (SuperView?.tabIndexes == null || SuperView?.tabIndexes.Count == 1) {
tabIndex = 0;
return;
} else if (tabIndex == value) {
return;
}
tabIndex = value > SuperView.tabIndexes.Count - 1 ? SuperView.tabIndexes.Count - 1 : value < 0 ? 0 : value;
tabIndex = GetTabIndex (tabIndex);
if (SuperView.tabIndexes.IndexOf (this) != tabIndex) {
SuperView.tabIndexes.Remove (this);
SuperView.tabIndexes.Insert (tabIndex, this);
SetTabIndex ();
}
}
}
int GetTabIndex (int idx)
{
var i = 0;
foreach (var v in SuperView.tabIndexes) {
if (v.tabIndex == -1 || v == this) {
continue;
}
i++;
}
return Math.Min (i, idx);
}
void SetTabIndex ()
{
var i = 0;
foreach (var v in SuperView.tabIndexes) {
if (v.tabIndex == -1) {
continue;
}
v.tabIndex = i;
i++;
}
}
bool tabStop = true;
///
/// This only be if the is also
/// and the focus can be avoided by setting this to
///
public bool TabStop {
get => tabStop;
set {
if (tabStop == value) {
return;
}
tabStop = CanFocus && value;
}
}
bool oldCanFocus;
int oldTabIndex;
///
public override bool CanFocus {
get => base.CanFocus;
set {
if (!addingView && IsInitialized && SuperView?.CanFocus == false && value) {
throw new InvalidOperationException ("Cannot set CanFocus to true if the SuperView CanFocus is false!");
}
if (base.CanFocus != value) {
base.CanFocus = value;
switch (value) {
case false when tabIndex > -1:
TabIndex = -1;
break;
case true when SuperView?.CanFocus == false && addingView:
SuperView.CanFocus = true;
break;
}
if (value && tabIndex == -1) {
TabIndex = SuperView != null ? SuperView.tabIndexes.IndexOf (this) : -1;
}
TabStop = value;
if (!value && SuperView?.Focused == this) {
SuperView.focused = null;
}
if (!value && HasFocus) {
SetHasFocus (false, this);
SuperView?.EnsureFocus ();
if (SuperView != null && SuperView.Focused == null) {
SuperView.FocusNext ();
if (SuperView.Focused == null) {
Application.Current.FocusNext ();
}
Application.EnsuresTopOnFront ();
}
}
if (subviews != null && IsInitialized) {
foreach (var view in subviews) {
if (view.CanFocus != value) {
if (!value) {
view.oldCanFocus = view.CanFocus;
view.oldTabIndex = view.tabIndex;
view.CanFocus = false;
view.tabIndex = -1;
} else {
if (addingView) {
view.addingView = true;
}
view.CanFocus = view.oldCanFocus;
view.tabIndex = view.oldTabIndex;
view.addingView = false;
}
}
}
}
OnCanFocusChanged ();
SetNeedsDisplay ();
}
}
}
internal Rect NeedDisplay { get; private set; } = Rect.Empty;
// The frame for the object. Superview relative.
Rect frame;
///
/// Gets or sets an identifier for the view;
///
/// The identifier.
/// The id should be unique across all Views that share a SuperView.
public ustring Id { get; set; } = "";
///
/// Returns a value indicating if this View is currently on Top (Active)
///
public bool IsCurrentTop => Application.Current == this;
///
/// Gets or sets a value indicating whether this wants mouse position reports.
///
/// if want mouse position reports; otherwise, .
public virtual bool WantMousePositionReports { get; set; }
///
/// Gets or sets a value indicating whether this want continuous button pressed event.
///
public virtual bool WantContinuousButtonPressed { get; set; }
///
/// Gets or sets the frame for the view. The frame is relative to the view's container ().
///
/// The frame.
///
///
/// Change the Frame when using the layout style to move or resize views.
///
///
/// Altering the Frame of a view will trigger the redrawing of the
/// view as well as the redrawing of the affected regions of the .
///
///
public virtual Rect Frame {
get => frame;
set {
var rect = GetMaxNeedDisplay (frame, value);
frame = new Rect (value.X, value.Y, Math.Max (value.Width, 0), Math.Max (value.Height, 0));
TextFormatter.Size = GetBoundsTextFormatterSize ();
SetNeedsLayout ();
SetNeedsDisplay (rect);
}
}
/////
///// Gets an enumerator that enumerates the subviews in this view.
/////
///// The enumerator.
//public IEnumerator GetEnumerator ()
//{
// foreach (var v in InternalSubviews)
// yield return v;
//}
LayoutStyle layoutStyle;
///
/// Controls how the View's is computed during the LayoutSubviews method, if the style is set to
/// ,
/// LayoutSubviews does not change the . If the style is
/// the is updated using
/// the , , , and properties.
///
/// The layout style.
public LayoutStyle LayoutStyle {
get => layoutStyle;
set {
layoutStyle = value;
SetNeedsLayout ();
}
}
///
/// The bounds represent the View-relative rectangle used for this view; the area inside of the view.
///
/// The bounds.
///
///
/// Updates to the Bounds update the ,
/// and has the same side effects as updating the .
///
///
/// 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 and coordinates of the client area of the
/// control for tasks such as drawing on the surface of the control.
///
///
public Rect Bounds {
get => new Rect (Point.Empty, Frame.Size);
set => Frame = new Rect (frame.Location, value.Size);
}
Pos x, y;
///
/// Gets or sets the X position for the view (the column). Only used if the is .
///
/// The X Position.
///
/// If is changing this property has no effect and its value is indeterminate.
///
public Pos X {
get => x;
set {
if (ForceValidatePosDim && !ValidatePosDim (x, value)) {
throw new ArgumentException ();
}
x = value;
ProcessResizeView ();
}
}
///
/// Gets or sets the Y position for the view (the row). Only used if the is .
///
/// The y position (line).
///
/// If is changing this property has no effect and its value is indeterminate.
///
public Pos Y {
get => y;
set {
if (ForceValidatePosDim && !ValidatePosDim (y, value)) {
throw new ArgumentException ();
}
y = value;
ProcessResizeView ();
}
}
Dim width, height;
///
/// Gets or sets the width of the view. Only used the is .
///
/// The width.
///
/// If is changing this property has no effect and its value is indeterminate.
///
public Dim Width {
get => width;
set {
if (ForceValidatePosDim && !ValidatePosDim (width, value)) {
throw new ArgumentException ("ForceValidatePosDim is enabled", nameof (Width));
}
width = value;
if (ForceValidatePosDim) {
var isValidNewAutSize = autoSize && IsValidAutoSizeWidth (width);
if (IsAdded && autoSize && !isValidNewAutSize) {
throw new InvalidOperationException ("Must set AutoSize to false before set the Width.");
}
}
ProcessResizeView ();
}
}
///
/// Gets or sets the height of the view. Only used the is .
///
/// The height.
/// If is changing this property has no effect and its value is indeterminate.
public Dim Height {
get => height;
set {
if (ForceValidatePosDim && !ValidatePosDim (height, value)) {
throw new ArgumentException ("ForceValidatePosDim is enabled", nameof (Height));
}
height = value;
if (ForceValidatePosDim) {
var isValidNewAutSize = autoSize && IsValidAutoSizeHeight (height);
if (IsAdded && autoSize && !isValidNewAutSize) {
throw new InvalidOperationException ("Must set AutoSize to false before set the Height.");
}
}
ProcessResizeView ();
}
}
///
/// Forces validation with layout
/// to avoid breaking the and settings.
///
public bool ForceValidatePosDim { get; set; }
bool ValidatePosDim (object oldValue, object newValue)
{
if (!IsInitialized || layoutStyle == LayoutStyle.Absolute || oldValue == null || oldValue.GetType () == newValue.GetType () || this is Toplevel) {
return true;
}
if (layoutStyle == LayoutStyle.Computed) {
if (oldValue.GetType () != newValue.GetType () && !(newValue is Pos.PosAbsolute || newValue is Dim.DimAbsolute)) {
return true;
}
}
return false;
}
///
/// Verifies if the minimum width or height can be sets in the view.
///
/// The size.
/// if the size can be set, otherwise.
public bool GetMinWidthHeight (out Size size)
{
size = Size.Empty;
if (!AutoSize && !ustring.IsNullOrEmpty (TextFormatter.Text)) {
switch (TextFormatter.IsVerticalDirection (TextDirection)) {
case true:
var colWidth = TextFormatter.GetSumMaxCharWidth (new List { TextFormatter.Text }, 0, 1);
if (frame.Width < colWidth && (Width == null || (Bounds.Width >= 0 && Width is Dim.DimAbsolute
&& Width.Anchor (0) >= 0 && Width.Anchor (0) < colWidth))) {
size = new Size (colWidth, Bounds.Height);
return true;
}
break;
default:
if (frame.Height < 1 && (Height == null || (Height is Dim.DimAbsolute && Height.Anchor (0) == 0))) {
size = new Size (Bounds.Width, 1);
return true;
}
break;
}
}
return false;
}
///
/// Sets the minimum width or height if the view can be resized.
///
/// if the size can be set, otherwise.
public bool SetMinWidthHeight ()
{
if (GetMinWidthHeight (out Size size)) {
Bounds = new Rect (Bounds.Location, size);
TextFormatter.Size = GetBoundsTextFormatterSize ();
return true;
}
return false;
}
///
/// Gets or sets the which can be handled differently by any derived class.
///
public TextFormatter TextFormatter { get; set; }
///
/// Returns the container for this view, or null if this view has not been added to a container.
///
/// The super view.
public View SuperView => container;
///
/// Initializes a new instance of a class with the absolute
/// dimensions specified in the parameter.
///
/// The region covered by this view.
///
/// This constructor initialize a View with a of .
/// Use to initialize a View with of
///
public View (Rect frame)
{
Initialize (ustring.Empty, frame, LayoutStyle.Absolute, TextDirection.LeftRight_TopBottom);
}
///
/// Initializes a new instance of using layout.
///
///
///
/// Use , , , and properties to dynamically control the size and location of the view.
/// The will be created using
/// coordinates. The initial size () will be
/// adjusted to fit the contents of , including newlines ('\n') for multiple lines.
///
///
/// If is greater than one, word wrapping is provided.
///
///
/// This constructor initialize a View with a of .
/// Use , , , and properties to dynamically control the size and location of the view.
///
///
public View () : this (text: string.Empty, direction: TextDirection.LeftRight_TopBottom) { }
///
/// Initializes a new instance of using layout.
///
///
///
/// The will be created at the given
/// coordinates with the given string. The size () will be
/// adjusted to fit the contents of , including newlines ('\n') for multiple lines.
///
///
/// No line wrapping is provided.
///
///
/// column to locate the View.
/// row to locate the View.
/// text to initialize the property with.
public View (int x, int y, ustring text) : this (TextFormatter.CalcRect (x, y, text), text) { }
///
/// Initializes a new instance of using layout.
///
///
///
/// The will be created at the given
/// coordinates with the given string. The initial size () will be
/// adjusted to fit the contents of , including newlines ('\n') for multiple lines.
///
///
/// If rect.Height is greater than one, word wrapping is provided.
///
///
/// Location.
/// text to initialize the property with.
/// The .
public View (Rect rect, ustring text, Border border = null)
{
Initialize (text, rect, LayoutStyle.Absolute, TextDirection.LeftRight_TopBottom, border);
}
///
/// Initializes a new instance of using layout.
///
///
///
/// The will be created using
/// coordinates with the given string. The initial size () will be
/// adjusted to fit the contents of , including newlines ('\n') for multiple lines.
///
///
/// If is greater than one, word wrapping is provided.
///
///
/// text to initialize the property with.
/// The text direction.
/// The .
public View (ustring text, TextDirection direction = TextDirection.LeftRight_TopBottom, Border border = null)
{
Initialize (text, Rect.Empty, LayoutStyle.Computed, direction, border);
}
void Initialize (ustring text, Rect rect, LayoutStyle layoutStyle = LayoutStyle.Computed,
TextDirection direction = TextDirection.LeftRight_TopBottom, Border border = null)
{
TextFormatter = new TextFormatter ();
TextFormatter.HotKeyChanged += TextFormatter_HotKeyChanged;
TextDirection = direction;
Border = border;
if (Border != null) {
Border.Child = this;
}
shortcutHelper = new ShortcutHelper ();
CanFocus = false;
TabIndex = -1;
TabStop = false;
LayoutStyle = layoutStyle;
// BUGBUG: CalcRect doesn't account for line wrapping
var r = rect.IsEmpty ? TextFormatter.CalcRect (0, 0, text, direction) : rect;
Frame = r;
Text = text;
UpdateTextFormatterText ();
ProcessResizeView ();
}
///
/// Can be overridden if the has
/// different format than the default.
///
protected virtual void UpdateTextFormatterText ()
{
TextFormatter.Text = text;
}
///
/// Can be overridden if the view resize behavior is
/// different than the default.
///
protected virtual void ProcessResizeView ()
{
var actX = x is Pos.PosAbsolute ? x.Anchor (0) : frame.X;
var actY = y is Pos.PosAbsolute ? y.Anchor (0) : frame.Y;
Rect oldFrame = frame;
if (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));
} else {
var w = width is Dim.DimAbsolute ? width.Anchor (0) : frame.Width;
var h = height is Dim.DimAbsolute ? height.Anchor (0) : frame.Height;
frame = new Rect (new Point (actX, actY), new Size (w, h));
SetMinWidthHeight ();
}
TextFormatter.Size = GetBoundsTextFormatterSize ();
SetNeedsLayout ();
SetNeedsDisplay (GetMaxNeedDisplay (oldFrame, frame));
}
Rect GetMaxNeedDisplay (Rect oldFrame, Rect newFrame)
{
var rect = new Rect () {
X = Math.Min (oldFrame.X, newFrame.X),
Y = Math.Min (oldFrame.Y, newFrame.Y),
Width = Math.Max (oldFrame.Width, newFrame.Width),
Height = Math.Max (oldFrame.Height, newFrame.Height)
};
rect.Width += Math.Max (oldFrame.X - newFrame.X, 0);
rect.Height += Math.Max (oldFrame.Y - newFrame.Y, 0);
return rect;
}
void TextFormatter_HotKeyChanged (Key obj)
{
HotKeyChanged?.Invoke (obj);
}
///
/// Sets a flag indicating this view needs to be redisplayed because its state has changed.
///
public void SetNeedsDisplay ()
{
SetNeedsDisplay (Bounds);
}
internal bool LayoutNeeded { get; private set; } = true;
internal void SetNeedsLayout ()
{
if (LayoutNeeded)
return;
LayoutNeeded = true;
if (SuperView == null)
return;
SuperView.SetNeedsLayout ();
foreach (var view in Subviews) {
view.SetNeedsLayout ();
}
TextFormatter.NeedsFormat = true;
}
///
/// Removes the setting on this view.
///
protected void ClearLayoutNeeded ()
{
LayoutNeeded = false;
}
///
/// Flags the view-relative region on this View as needing to be repainted.
///
/// The view-relative region that must be flagged for repaint.
public void SetNeedsDisplay (Rect region)
{
if (NeedDisplay.IsEmpty)
NeedDisplay = region;
else {
var x = Math.Min (NeedDisplay.X, region.X);
var y = Math.Min (NeedDisplay.Y, region.Y);
var w = Math.Max (NeedDisplay.Width, region.Width);
var h = Math.Max (NeedDisplay.Height, region.Height);
NeedDisplay = new Rect (x, y, w, h);
}
container?.SetChildNeedsDisplay ();
if (subviews == null)
return;
foreach (var view in subviews)
if (view.Frame.IntersectsWith (region)) {
var childRegion = Rect.Intersect (view.Frame, region);
childRegion.X -= view.Frame.X;
childRegion.Y -= view.Frame.Y;
view.SetNeedsDisplay (childRegion);
}
}
internal bool ChildNeedsDisplay { get; private set; }
///
/// Indicates that any child views (in the list) need to be repainted.
///
public void SetChildNeedsDisplay ()
{
ChildNeedsDisplay = true;
if (container != null)
container.SetChildNeedsDisplay ();
}
internal bool addingView;
///
/// Adds a subview (child) to this view.
///
///
/// The Views that have been added to this view can be retrieved via the property.
/// See also
///
public virtual void Add (View view)
{
if (view == null)
return;
if (subviews == null) {
subviews = new List ();
}
if (tabIndexes == null) {
tabIndexes = new List ();
}
subviews.Add (view);
tabIndexes.Add (view);
view.container = this;
if (view.CanFocus) {
addingView = true;
if (SuperView?.CanFocus == false) {
SuperView.addingView = true;
SuperView.CanFocus = true;
SuperView.addingView = false;
}
CanFocus = true;
view.tabIndex = tabIndexes.IndexOf (view);
addingView = false;
}
SetNeedsLayout ();
SetNeedsDisplay ();
OnAdded (view);
if (IsInitialized) {
view.BeginInit ();
view.EndInit ();
}
}
///
/// Adds the specified views (children) to the view.
///
/// Array of one or more views (can be optional parameter).
///
/// The Views that have been added to this view can be retrieved via the property.
/// See also
///
public void Add (params View [] views)
{
if (views == null)
return;
foreach (var view in views)
Add (view);
}
///
/// Removes all subviews (children) added via or from this View.
///
public virtual void RemoveAll ()
{
if (subviews == null)
return;
while (subviews.Count > 0) {
Remove (subviews [0]);
}
}
///
/// Removes a subview added via or from this View.
///
///
///
public virtual void Remove (View view)
{
if (view == null || subviews == null)
return;
var touched = view.Frame;
subviews.Remove (view);
tabIndexes.Remove (view);
view.container = null;
view.tabIndex = -1;
SetNeedsLayout ();
SetNeedsDisplay ();
if (subviews.Count < 1) {
CanFocus = false;
}
foreach (var v in subviews) {
if (v.Frame.IntersectsWith (touched))
view.SetNeedsDisplay ();
}
OnRemoved (view);
if (focused == view) {
focused = null;
}
}
void PerformActionForSubview (View subview, Action action)
{
if (subviews.Contains (subview)) {
action (subview);
}
SetNeedsDisplay ();
subview.SetNeedsDisplay ();
}
///
/// Brings the specified subview to the front so it is drawn on top of any other views.
///
/// The subview to send to the front
///
/// .
///
public void BringSubviewToFront (View subview)
{
PerformActionForSubview (subview, x => {
subviews.Remove (x);
subviews.Add (x);
});
}
///
/// Sends the specified subview to the front so it is the first view drawn
///
/// The subview to send to the front
///
/// .
///
public void SendSubviewToBack (View subview)
{
PerformActionForSubview (subview, x => {
subviews.Remove (x);
subviews.Insert (0, subview);
});
}
///
/// Moves the subview backwards in the hierarchy, only one step
///
/// The subview to send backwards
///
/// If you want to send the view all the way to the back use SendSubviewToBack.
///
public void SendSubviewBackwards (View subview)
{
PerformActionForSubview (subview, x => {
var idx = subviews.IndexOf (x);
if (idx > 0) {
subviews.Remove (x);
subviews.Insert (idx - 1, x);
}
});
}
///
/// Moves the subview backwards in the hierarchy, only one step
///
/// The subview to send backwards
///
/// If you want to send the view all the way to the back use SendSubviewToBack.
///
public void BringSubviewForward (View subview)
{
PerformActionForSubview (subview, x => {
var idx = subviews.IndexOf (x);
if (idx + 1 < subviews.Count) {
subviews.Remove (x);
subviews.Insert (idx + 1, x);
}
});
}
///
/// Clears the view region with the current color.
///
///
///
/// This clears the entire region used by this view.
///
///
public void Clear ()
{
var h = Frame.Height;
var w = Frame.Width;
for (var line = 0; line < h; line++) {
Move (0, line);
for (var col = 0; col < w; col++)
Driver.AddRune (' ');
}
}
///
/// Clears the specified region with the current color.
///
///
///
/// The screen-relative region to clear.
public void Clear (Rect regionScreen)
{
var h = regionScreen.Height;
var w = regionScreen.Width;
for (var line = regionScreen.Y; line < regionScreen.Y + h; line++) {
Driver.Move (regionScreen.X, line);
for (var col = 0; col < w; col++)
Driver.AddRune (' ');
}
}
///
/// Converts a view-relative (col,row) position to a screen-relative position (col,row). The values are optionally clamped to the screen dimensions.
///
/// View-relative column.
/// View-relative row.
/// Absolute column; screen-relative.
/// Absolute row; screen-relative.
/// Whether to clip the result of the ViewToScreen method, if set to , the rcol, rrow values are clamped to the screen (terminal) dimensions (0..TerminalDim-1).
internal void ViewToScreen (int col, int row, out int rcol, out int rrow, bool clipped = true)
{
// Computes the real row, col relative to the screen.
rrow = row + frame.Y;
rcol = col + frame.X;
var curContainer = container;
while (curContainer != null) {
rrow += curContainer.frame.Y;
rcol += curContainer.frame.X;
curContainer = curContainer.container;
}
// The following ensures that the cursor is always in the screen boundaries.
if (clipped) {
rrow = Math.Min (rrow, Driver.Rows - 1);
rcol = Math.Min (rcol, Driver.Cols - 1);
}
}
///
/// Converts a point from screen-relative coordinates to view-relative coordinates.
///
/// The mapped point.
/// X screen-coordinate point.
/// Y screen-coordinate point.
public Point ScreenToView (int x, int y)
{
if (SuperView == null) {
return new Point (x - Frame.X, y - frame.Y);
} else {
var parent = SuperView.ScreenToView (x, y);
return new Point (parent.X - frame.X, parent.Y - frame.Y);
}
}
///
/// Converts a region in view-relative coordinates to screen-relative coordinates.
///
internal Rect ViewToScreen (Rect region)
{
ViewToScreen (region.X, region.Y, out var x, out var y, clipped: false);
return new Rect (x, y, region.Width, region.Height);
}
// Clips a rectangle in screen coordinates to the dimensions currently available on the screen
internal Rect ScreenClip (Rect regionScreen)
{
var x = regionScreen.X < 0 ? 0 : regionScreen.X;
var y = regionScreen.Y < 0 ? 0 : regionScreen.Y;
var w = regionScreen.X + regionScreen.Width >= Driver.Cols ? Driver.Cols - regionScreen.X : regionScreen.Width;
var h = regionScreen.Y + regionScreen.Height >= Driver.Rows ? Driver.Rows - regionScreen.Y : regionScreen.Height;
return new Rect (x, y, w, h);
}
///
/// Sets the 's clip region to the current View's .
///
/// The existing driver's clip region, which can be then re-applied by setting .Clip ().
///
/// is View-relative.
///
public Rect ClipToBounds ()
{
return SetClip (Bounds);
}
///
/// Sets the clip region to the specified view-relative region.
///
/// The previous screen-relative clip region.
/// View-relative clip region.
public Rect SetClip (Rect region)
{
var previous = Driver.Clip;
Driver.Clip = Rect.Intersect (previous, ViewToScreen (region));
return previous;
}
///
/// Draws a frame in the current view, clipped by the boundary of this view
///
/// View-relative region for the frame to be drawn.
/// The padding to add around the outside of the drawn frame.
/// If set to it fill will the contents.
public void DrawFrame (Rect region, int padding = 0, bool fill = false)
{
var scrRect = ViewToScreen (region);
var savedClip = ClipToBounds ();
Driver.DrawWindowFrame (scrRect, padding + 1, padding + 1, padding + 1, padding + 1, border: true, fill: fill);
Driver.Clip = savedClip;
}
///
/// Utility function to draw strings that contain a hotkey.
///
/// String to display, the hotkey specifier before a letter flags the next letter as the hotkey.
/// Hot color.
/// Normal color.
///
/// The hotkey is any character following the hotkey specifier, which is the underscore ('_') character by default.
/// The hotkey specifier can be changed via
///
public void DrawHotString (ustring text, Attribute hotColor, Attribute normalColor)
{
var hotkeySpec = HotKeySpecifier == (Rune)0xffff ? (Rune)'_' : HotKeySpecifier;
Application.Driver.SetAttribute (normalColor);
foreach (var rune in text) {
if (rune == hotkeySpec) {
Application.Driver.SetAttribute (hotColor);
continue;
}
Application.Driver.AddRune (rune);
Application.Driver.SetAttribute (normalColor);
}
}
///
/// Utility function to draw strings that contains a hotkey using a and the "focused" state.
///
/// String to display, the underscore before a letter flags the next letter as the hotkey.
/// If set to this uses the focused colors from the color scheme, otherwise the regular ones.
/// The color scheme to use.
public void DrawHotString (ustring text, bool focused, ColorScheme scheme)
{
if (focused)
DrawHotString (text, scheme.HotFocus, scheme.Focus);
else
DrawHotString (text, Enabled ? scheme.HotNormal : scheme.Disabled, Enabled ? scheme.Normal : scheme.Disabled);
}
///
/// This moves the cursor to the specified column and row in the view.
///
/// The move.
/// Col.
/// Row.
/// Whether to clip the result of the ViewToScreen method,
/// if set to , the col, row values are clamped to the screen (terminal) dimensions (0..TerminalDim-1).
public void Move (int col, int row, bool clipped = true)
{
if (Driver.Rows == 0) {
return;
}
ViewToScreen (col, row, out var rCol, out var rRow, clipped);
Driver.Move (rCol, rRow);
}
///
/// Positions the cursor in the right position based on the currently focused view in the chain.
///
/// Views that are focusable should override to ensure
/// the cursor is placed in a location that makes sense. Unix terminals do not have
/// a way of hiding the cursor, so it can be distracting to have the cursor left at
/// the last focused view. Views should make sure that they place the cursor
/// in a visually sensible place.
public virtual void PositionCursor ()
{
if (!CanBeVisible (this) || !Enabled) {
return;
}
if (focused?.Visible == true && focused?.Enabled == true && focused?.Frame.Width > 0 && focused.Frame.Height > 0) {
focused.PositionCursor ();
} else {
if (CanFocus && HasFocus && Visible && Frame.Width > 0 && Frame.Height > 0) {
Move (TextFormatter.HotKeyPos == -1 ? 0 : TextFormatter.CursorPosition, 0);
} else {
Move (frame.X, frame.Y);
}
}
}
bool hasFocus;
///
public override bool HasFocus => hasFocus;
void SetHasFocus (bool value, View view, bool force = false)
{
if (hasFocus != value || force) {
hasFocus = value;
if (value) {
OnEnter (view);
} else {
OnLeave (view);
}
SetNeedsDisplay ();
}
// Remove focus down the chain of subviews if focus is removed
if (!value && focused != null) {
var f = focused;
f.OnLeave (view);
f.SetHasFocus (false, view);
focused = null;
}
}
///
/// Defines the event arguments for
///
public class FocusEventArgs : EventArgs {
///
/// Constructs.
///
/// The view that gets or loses focus.
public FocusEventArgs (View view) { View = view; }
///
/// Indicates if the current focus event has already been processed and the driver should stop notifying any other event subscriber.
/// Its important to set this value to true specially when updating any View's layout from inside the subscriber method.
///
public bool Handled { get; set; }
///
/// Indicates the current view that gets or loses focus.
///
public View View { get; set; }
}
///
/// Method invoked when a subview is being added to this view.
///
/// The subview being added.
public virtual void OnAdded (View view)
{
view.IsAdded = true;
view.x = view.x ?? view.frame.X;
view.y = view.y ?? view.frame.Y;
view.width = view.width ?? view.frame.Width;
view.height = view.height ?? view.frame.Height;
view.Added?.Invoke (this);
}
///
/// Method invoked when a subview is being removed from this view.
///
/// The subview being removed.
public virtual void OnRemoved (View view)
{
view.IsAdded = false;
view.Removed?.Invoke (this);
}
///
public override bool OnEnter (View view)
{
var args = new FocusEventArgs (view);
Enter?.Invoke (args);
if (args.Handled)
return true;
if (base.OnEnter (view))
return true;
return false;
}
///
public override bool OnLeave (View view)
{
var args = new FocusEventArgs (view);
Leave?.Invoke (args);
if (args.Handled)
return true;
if (base.OnLeave (view))
return true;
return false;
}
///
/// Returns the currently focused view inside this view, or null if nothing is focused.
///
/// The focused.
public View Focused => focused;
///
/// Returns the most focused view in the chain of subviews (the leaf view that has the focus).
///
/// The most focused View.
public View MostFocused {
get {
if (Focused == null)
return null;
var most = Focused.MostFocused;
if (most != null)
return most;
return Focused;
}
}
ColorScheme colorScheme;
///
/// The color scheme for this view, if it is not defined, it returns the 's
/// color scheme.
///
public virtual ColorScheme ColorScheme {
get {
if (colorScheme == null) {
return SuperView?.ColorScheme;
}
return colorScheme;
}
set {
if (colorScheme != value) {
colorScheme = value;
SetNeedsDisplay ();
}
}
}
///
/// Displays the specified character in the specified column and row of the View.
///
/// Column (view-relative).
/// Row (view-relative).
/// Ch.
public void AddRune (int col, int row, Rune ch)
{
if (row < 0 || col < 0)
return;
if (row > frame.Height - 1 || col > frame.Width - 1)
return;
Move (col, row);
Driver.AddRune (ch);
}
///
/// Removes the and the setting on this view.
///
protected void ClearNeedsDisplay ()
{
NeedDisplay = Rect.Empty;
ChildNeedsDisplay = false;
}
///
/// Redraws this view and its subviews; only redraws the views that have been flagged for a re-display.
///
/// The bounds (view-relative region) to redraw.
///
///
/// Always use (view-relative) when calling , NOT (superview-relative).
///
///
/// Views should set the color that they want to use on entry, as otherwise this will inherit
/// the last color that was set globally on the driver.
///
///
/// Overrides of must ensure they do not set Driver.Clip to a clip region
/// larger than the