mirror of
https://github.com/gui-cs/Terminal.Gui.git
synced 2025-12-26 15:57:56 +01:00
793 lines
23 KiB
C#
793 lines
23 KiB
C#
using System.ComponentModel;
|
|
using System.Threading.Channels;
|
|
|
|
namespace Terminal.Gui;
|
|
|
|
/// <summary>
|
|
/// Displays a command, help text, and a key binding. When the key specified by <see cref="Key"/> is pressed, the command will be invoked. Useful for
|
|
/// displaying a command in <see cref="Bar"/> such as a
|
|
/// menu, toolbar, or status bar.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// The following user actions will invoke the <see cref="Command.Accept"/>, causing the
|
|
/// <see cref="View.Accept"/> event to be fired:
|
|
/// - Clicking on the <see cref="Shortcut"/>.
|
|
/// - Pressing the key specified by <see cref="Key"/>.
|
|
/// - Pressing the HotKey specified by <see cref="CommandView"/>.
|
|
/// </para>
|
|
/// <para>
|
|
/// If <see cref="KeyBindingScope"/> is <see cref="KeyBindingScope.Application"/>, <see cref="Key"/> will invoked <see cref="Command.Accept"/>
|
|
/// command regardless of what View has focus, enabling an application-wide keyboard shortcut.
|
|
/// </para>
|
|
/// <para>
|
|
/// By default, a Shortcut displays the command text on the left side, the help text in the middle, and the key
|
|
/// binding on the
|
|
/// right side. Set <see cref="AlignmentModes"/> to <see cref="AlignmentModes.EndToStart"/> to reverse the order.
|
|
/// </para>
|
|
/// <para>
|
|
/// The command text can be set by setting the <see cref="CommandView"/>'s Text property or by setting
|
|
/// <see cref="View.Title"/>.
|
|
/// </para>
|
|
/// <para>
|
|
/// The help text can be set by setting the <see cref="HelpText"/> property or by setting <see cref="View.Text"/>.
|
|
/// </para>
|
|
/// <para>
|
|
/// The key text is set by setting the <see cref="Key"/> property.
|
|
/// If the <see cref="Key"/> is <see cref="Key.Empty"/>, the <see cref="Key"/> text is not displayed.
|
|
/// </para>
|
|
/// </remarks>
|
|
public class Shortcut : View
|
|
{
|
|
/// <summary>
|
|
/// Creates a new instance of <see cref="Shortcut"/>.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// This is a helper API that mimics the V1 API for creating StatusItems.
|
|
/// </para>
|
|
/// </remarks>
|
|
/// <param name="key"></param>
|
|
/// <param name="commandText"></param>
|
|
/// <param name="action"></param>
|
|
/// <param name="helpText"></param>
|
|
public Shortcut (Key key, string commandText, Action action, string helpText = null)
|
|
{
|
|
Id = "_shortcut";
|
|
HighlightStyle = HighlightStyle.Pressed;
|
|
Highlight += Shortcut_Highlight;
|
|
CanFocus = true;
|
|
Width = GetWidthDimAuto ();
|
|
Height = Dim.Auto (DimAutoStyle.Content, 1);
|
|
|
|
AddCommand (Command.HotKey, ctx => OnAccept (ctx));
|
|
AddCommand (Command.Accept, ctx => OnAccept (ctx));
|
|
AddCommand (Command.Select, ctx => OnSelect (ctx));
|
|
KeyBindings.Add (KeyCode.Enter, Command.Accept);
|
|
KeyBindings.Add (KeyCode.Space, Command.Select);
|
|
|
|
TitleChanged += Shortcut_TitleChanged; // This needs to be set before CommandView is set
|
|
|
|
CommandView = new ()
|
|
{
|
|
Width = Dim.Auto (),
|
|
Height = Dim.Auto ()
|
|
};
|
|
|
|
HelpView.Id = "_helpView";
|
|
HelpView.CanFocus = false;
|
|
HelpView.Text = helpText;
|
|
Add (HelpView);
|
|
|
|
KeyView.Id = "_keyView";
|
|
KeyView.CanFocus = false;
|
|
Add (KeyView);
|
|
|
|
// If the user clicks anywhere on the Shortcut, other than the CommandView, invoke the Command
|
|
MouseClick += Shortcut_MouseClick;
|
|
HelpView.MouseClick += Subview_MouseClick;
|
|
KeyView.MouseClick += Subview_MouseClick;
|
|
LayoutStarted += OnLayoutStarted;
|
|
Initialized += OnInitialized;
|
|
|
|
if (key is null)
|
|
{
|
|
key = Key.Empty;
|
|
}
|
|
|
|
Key = key;
|
|
Title = commandText;
|
|
Action = action;
|
|
|
|
return;
|
|
|
|
void OnInitialized (object sender, EventArgs e)
|
|
{
|
|
SuperViewRendersLineCanvas = true;
|
|
Border.Settings &= ~BorderSettings.Title;
|
|
|
|
ShowHide ();
|
|
|
|
// Force Width to DimAuto to calculate natural width and then set it back
|
|
Dim savedDim = Width;
|
|
Width = GetWidthDimAuto ();
|
|
_minimumDimAutoWidth = Frame.Width;
|
|
Width = savedDim;
|
|
|
|
SetCommandViewDefaultLayout ();
|
|
SetHelpViewDefaultLayout ();
|
|
SetKeyViewDefaultLayout ();
|
|
|
|
SetColors ();
|
|
}
|
|
|
|
// Helper to set Width consistently
|
|
Dim GetWidthDimAuto ()
|
|
{
|
|
// TODO: PosAlign.CalculateMinDimension is a hack. Need to figure out a better way of doing this.
|
|
return Dim.Auto (
|
|
DimAutoStyle.Content,
|
|
Dim.Func (() => PosAlign.CalculateMinDimension (0, Subviews, Dimension.Width)),
|
|
Dim.Func (() => PosAlign.CalculateMinDimension (0, Subviews, Dimension.Width)));
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Creates a new instance of <see cref="Shortcut"/>.
|
|
/// </summary>
|
|
public Shortcut () : this (Key.Empty, string.Empty, null) { }
|
|
|
|
private Orientation _orientation = Orientation.Horizontal;
|
|
|
|
/// <summary>
|
|
/// Gets or sets the <see cref="Orientation"/> for this <see cref="Shortcut"/>. The default is
|
|
/// <see cref="Orientation.Horizontal"/>, which is ideal for status bar, menu bar, and tool bar items If set to
|
|
/// <see cref="Orientation.Vertical"/>,
|
|
/// the Shortcut will be configured for vertical layout, which is ideal for menu items.
|
|
/// </summary>
|
|
public Orientation Orientation
|
|
{
|
|
get => _orientation;
|
|
set
|
|
{
|
|
_orientation = value;
|
|
|
|
// TODO: Determine what, if anything, is opinionated about the orientation.
|
|
}
|
|
}
|
|
|
|
private AlignmentModes _alignmentModes = AlignmentModes.StartToEnd | AlignmentModes.IgnoreFirstOrLast;
|
|
|
|
/// <summary>
|
|
/// Gets or sets the <see cref="AlignmentModes"/> for this <see cref="Shortcut"/>.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// The default is <see cref="AlignmentModes.StartToEnd"/>. This means that the CommandView will be on the left,
|
|
/// HelpView in the middle, and KeyView on the right.
|
|
/// </para>
|
|
/// </remarks>
|
|
public AlignmentModes AlignmentModes
|
|
{
|
|
get => _alignmentModes;
|
|
set
|
|
{
|
|
_alignmentModes = value;
|
|
SetCommandViewDefaultLayout ();
|
|
SetHelpViewDefaultLayout ();
|
|
SetKeyViewDefaultLayout ();
|
|
}
|
|
}
|
|
|
|
// When one of the subviews is "empty" we don't want to show it. So we
|
|
// Use Add/Remove. We need to be careful to add them in the right order
|
|
// so Pos.Align works correctly.
|
|
internal void ShowHide ()
|
|
{
|
|
RemoveAll ();
|
|
|
|
if (CommandView.Visible)
|
|
{
|
|
Add (CommandView);
|
|
}
|
|
|
|
if (HelpView.Visible && !string.IsNullOrEmpty (HelpView.Text))
|
|
{
|
|
Add (HelpView);
|
|
}
|
|
|
|
if (KeyView.Visible && Key != Key.Empty)
|
|
{
|
|
Add (KeyView);
|
|
}
|
|
}
|
|
|
|
// This is used to calculate the minimum width of the Shortcut when the width is NOT Dim.Auto
|
|
private int? _minimumDimAutoWidth;
|
|
|
|
// When layout starts, we need to adjust the layout of the HelpView and KeyView
|
|
private void OnLayoutStarted (object sender, LayoutEventArgs e)
|
|
{
|
|
if (Width is DimAuto widthAuto)
|
|
{
|
|
_minimumDimAutoWidth = Frame.Width;
|
|
}
|
|
else
|
|
{
|
|
if (string.IsNullOrEmpty (HelpView.Text))
|
|
{
|
|
return;
|
|
}
|
|
|
|
int currentWidth = Frame.Width;
|
|
|
|
// If our width is smaller than the natural width then reduce width of HelpView first.
|
|
// Then KeyView.
|
|
// Don't ever reduce CommandView (it should spill).
|
|
// When Horizontal, Key is first, then Help, then Command.
|
|
// When Vertical, Command is first, then Help, then Key.
|
|
// BUGBUG: This does not do what the above says.
|
|
// TODO: Add Unit tests for this.
|
|
if (currentWidth < _minimumDimAutoWidth)
|
|
{
|
|
int delta = _minimumDimAutoWidth.Value - currentWidth;
|
|
int maxHelpWidth = int.Max (0, HelpView.Text.GetColumns () + Margin.Thickness.Horizontal - delta);
|
|
|
|
switch (maxHelpWidth)
|
|
{
|
|
case 0:
|
|
// Hide HelpView
|
|
HelpView.Visible = false;
|
|
HelpView.X = 0;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
// Scrunch it by removing margins
|
|
HelpView.Margin.Thickness = new (0, 0, 0, 0);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
// Scrunch just the right margin
|
|
Thickness t = GetMarginThickness ();
|
|
HelpView.Margin.Thickness = new (t.Right, t.Top, t.Left - 1, t.Bottom);
|
|
|
|
break;
|
|
|
|
default:
|
|
// Default margin
|
|
HelpView.Margin.Thickness = GetMarginThickness ();
|
|
|
|
break;
|
|
}
|
|
|
|
if (maxHelpWidth > 0)
|
|
{
|
|
HelpView.X = Pos.Align (Alignment.End, AlignmentModes);
|
|
|
|
// Leverage Dim.Auto's max:
|
|
HelpView.Width = Dim.Auto (DimAutoStyle.Text, maximumContentDim: maxHelpWidth);
|
|
HelpView.Visible = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Reset to default
|
|
//SetCommandViewDefaultLayout();
|
|
SetHelpViewDefaultLayout ();
|
|
|
|
//SetKeyViewDefaultLayout ();
|
|
}
|
|
}
|
|
}
|
|
|
|
private Thickness GetMarginThickness ()
|
|
{
|
|
if (Orientation == Orientation.Vertical)
|
|
{
|
|
return new (1, 0, 1, 0);
|
|
}
|
|
|
|
return new (1, 0, 1, 0);
|
|
}
|
|
|
|
private Color? _savedForeColor;
|
|
|
|
private void Shortcut_Highlight (object sender, CancelEventArgs<HighlightStyle> e)
|
|
{
|
|
if (e.CurrentValue.HasFlag (HighlightStyle.Pressed))
|
|
{
|
|
if (!_savedForeColor.HasValue)
|
|
{
|
|
_savedForeColor = base.ColorScheme.Normal.Foreground;
|
|
}
|
|
|
|
var cs = new ColorScheme (base.ColorScheme)
|
|
{
|
|
Normal = new (ColorScheme.Normal.Foreground.GetHighlightColor (), base.ColorScheme.Normal.Background)
|
|
};
|
|
base.ColorScheme = cs;
|
|
}
|
|
|
|
if (e.CurrentValue == HighlightStyle.None && _savedForeColor.HasValue)
|
|
{
|
|
var cs = new ColorScheme (base.ColorScheme)
|
|
{
|
|
Normal = new (_savedForeColor.Value, base.ColorScheme.Normal.Background)
|
|
};
|
|
base.ColorScheme = cs;
|
|
}
|
|
|
|
SuperView?.SetNeedsDisplay ();
|
|
e.Cancel = true;
|
|
}
|
|
|
|
private void Shortcut_MouseClick (object sender, MouseEventEventArgs e)
|
|
{
|
|
// When the Shortcut is clicked, we want to invoke the Command and Set focus
|
|
var view = sender as View;
|
|
|
|
if (!e.Handled)
|
|
{
|
|
// If the subview (likely CommandView) didn't handle the mouse click, invoke the command.
|
|
e.Handled = InvokeCommand (Command.Accept) == true;
|
|
}
|
|
|
|
if (CanFocus)
|
|
{
|
|
SetFocus ();
|
|
}
|
|
}
|
|
|
|
private void Subview_MouseClick (object sender, MouseEventEventArgs e)
|
|
{
|
|
// TODO: Remove. This does nothing.
|
|
return;
|
|
}
|
|
|
|
#region Command
|
|
|
|
private View _commandView = new ();
|
|
|
|
/// <summary>
|
|
/// Gets or sets the View that displays the command text and hotkey.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// By default, the <see cref="View.Title"/> of the <see cref="CommandView"/> is displayed as the Shortcut's
|
|
/// command text.
|
|
/// </para>
|
|
/// <para>
|
|
/// By default, the CommandView is a <see cref="View"/> with <see cref="View.CanFocus"/> set to
|
|
/// <see langword="false"/>.
|
|
/// </para>
|
|
/// <para>
|
|
/// Setting the <see cref="CommandView"/> will add it to the <see cref="Shortcut"/> and remove any existing
|
|
/// <see cref="CommandView"/>.
|
|
/// </para>
|
|
/// </remarks>
|
|
/// <example>
|
|
/// <para>
|
|
/// This example illustrates how to add a <see cref="Shortcut"/> to a <see cref="StatusBar"/> that toggles the
|
|
/// <see cref="Application.Force16Colors"/> property.
|
|
/// </para>
|
|
/// <code>
|
|
/// var force16ColorsShortcut = new Shortcut
|
|
/// {
|
|
/// Key = Key.F6,
|
|
/// KeyBindingScope = KeyBindingScope.HotKey,
|
|
/// CommandView = new CheckBox { Text = "Force 16 Colors" }
|
|
/// };
|
|
/// var cb = force16ColorsShortcut.CommandView as CheckBox;
|
|
/// cb.Checked = Application.Force16Colors;
|
|
///
|
|
/// cb.Toggled += (s, e) =>
|
|
/// {
|
|
/// var cb = s as CheckBox;
|
|
/// Application.Force16Colors = cb!.Checked == true;
|
|
/// Application.Refresh();
|
|
/// };
|
|
/// StatusBar.Add(force16ColorsShortcut);
|
|
/// </code>
|
|
/// </example>
|
|
|
|
public View CommandView
|
|
{
|
|
get => _commandView;
|
|
set
|
|
{
|
|
if (value == null)
|
|
{
|
|
throw new ArgumentNullException ();
|
|
}
|
|
|
|
if (_commandView is { })
|
|
{
|
|
Remove (_commandView);
|
|
_commandView?.Dispose ();
|
|
}
|
|
|
|
_commandView = value;
|
|
_commandView.Id = "_commandView";
|
|
|
|
// The default behavior is for CommandView to not get focus. I
|
|
// If you want it to get focus, you need to set it.
|
|
_commandView.CanFocus = false;
|
|
|
|
_commandView.HotKeyChanged += (s, e) =>
|
|
{
|
|
if (e.NewKey != Key.Empty)
|
|
{
|
|
// Add it
|
|
AddKeyBindingsForHotKey (e.OldKey, e.NewKey);
|
|
}
|
|
};
|
|
|
|
_commandView.HotKeySpecifier = new ('_');
|
|
|
|
Title = _commandView.Text;
|
|
|
|
SetCommandViewDefaultLayout ();
|
|
SetHelpViewDefaultLayout ();
|
|
SetKeyViewDefaultLayout ();
|
|
ShowHide ();
|
|
UpdateKeyBinding ();
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void SetCommandViewDefaultLayout ()
|
|
{
|
|
CommandView.Margin.Thickness = GetMarginThickness ();
|
|
CommandView.X = Pos.Align (Alignment.End, AlignmentModes);
|
|
CommandView.Y = 0; //Pos.Center ();
|
|
}
|
|
|
|
private void Shortcut_TitleChanged (object sender, EventArgs<string> e)
|
|
{
|
|
// If the Title changes, update the CommandView text.
|
|
// This is a helper to make it easier to set the CommandView text.
|
|
// CommandView is public and replaceable, but this is a convenience.
|
|
_commandView.Text = Title;
|
|
}
|
|
|
|
#endregion Command
|
|
|
|
#region Help
|
|
|
|
/// <summary>
|
|
/// The subview that displays the help text for the command. Internal for unit testing.
|
|
/// </summary>
|
|
internal View HelpView { get; } = new ();
|
|
|
|
private void SetHelpViewDefaultLayout ()
|
|
{
|
|
HelpView.Margin.Thickness = GetMarginThickness ();
|
|
HelpView.X = Pos.Align (Alignment.End, AlignmentModes);
|
|
HelpView.Y = 0; //Pos.Center ();
|
|
HelpView.Width = Dim.Auto (DimAutoStyle.Text);
|
|
HelpView.Height = CommandView?.Visible == true ? Dim.Height (CommandView) : 1;
|
|
|
|
HelpView.Visible = true;
|
|
HelpView.VerticalTextAlignment = Alignment.Center;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the help text displayed in the middle of the Shortcut. Identical in function to <see cref="HelpText"/>
|
|
/// .
|
|
/// </summary>
|
|
public override string Text
|
|
{
|
|
get => HelpView?.Text;
|
|
set
|
|
{
|
|
if (HelpView is {})
|
|
{
|
|
HelpView.Text = value;
|
|
ShowHide ();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the help text displayed in the middle of the Shortcut.
|
|
/// </summary>
|
|
public string HelpText
|
|
{
|
|
get => HelpView?.Text;
|
|
set
|
|
{
|
|
if (HelpView is {})
|
|
{
|
|
HelpView.Text = value;
|
|
ShowHide ();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Help
|
|
|
|
#region Key
|
|
|
|
private Key _key = Key.Empty;
|
|
|
|
/// <summary>
|
|
/// Gets or sets the <see cref="Key"/> that will be bound to the <see cref="Command.Accept"/> command.
|
|
/// </summary>
|
|
public Key Key
|
|
{
|
|
get => _key;
|
|
set
|
|
{
|
|
if (value == null)
|
|
{
|
|
throw new ArgumentNullException ();
|
|
}
|
|
|
|
_key = value;
|
|
|
|
UpdateKeyBinding ();
|
|
|
|
KeyView.Text = Key == Key.Empty ? string.Empty : $"{Key}";
|
|
ShowHide ();
|
|
}
|
|
}
|
|
|
|
private KeyBindingScope _keyBindingScope = KeyBindingScope.HotKey;
|
|
|
|
/// <summary>
|
|
/// Gets or sets the scope for the key binding for how <see cref="Key"/> is bound to <see cref="Command"/>.
|
|
/// </summary>
|
|
public KeyBindingScope KeyBindingScope
|
|
{
|
|
get => _keyBindingScope;
|
|
set
|
|
{
|
|
_keyBindingScope = value;
|
|
|
|
UpdateKeyBinding ();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the subview that displays the key. Internal for unit testing.
|
|
/// </summary>
|
|
|
|
internal View KeyView { get; } = new ();
|
|
|
|
private int _minimumKeyTextSize;
|
|
|
|
/// <summary>
|
|
/// Gets or sets the minimum size of the key text. Useful for aligning the key text with other <see cref="Shortcut"/>s.
|
|
/// </summary>
|
|
public int MinimumKeyTextSize
|
|
{
|
|
get => _minimumKeyTextSize;
|
|
set
|
|
{
|
|
if (value == _minimumKeyTextSize)
|
|
{
|
|
//return;
|
|
}
|
|
|
|
_minimumKeyTextSize = value;
|
|
SetKeyViewDefaultLayout ();
|
|
CommandView.SetNeedsLayout ();
|
|
HelpView.SetNeedsLayout ();
|
|
KeyView.SetNeedsLayout ();
|
|
SetSubViewNeedsDisplay ();
|
|
}
|
|
}
|
|
|
|
private int GetMinimumKeyViewSize () { return MinimumKeyTextSize; }
|
|
|
|
private void SetKeyViewDefaultLayout ()
|
|
{
|
|
KeyView.Margin.Thickness = GetMarginThickness ();
|
|
KeyView.X = Pos.Align (Alignment.End, AlignmentModes);
|
|
KeyView.Y = 0; //Pos.Center ();
|
|
KeyView.Width = Dim.Auto (DimAutoStyle.Text, Dim.Func (GetMinimumKeyViewSize));
|
|
KeyView.Height = CommandView?.Visible == true ? Dim.Height (CommandView) : 1;
|
|
|
|
KeyView.Visible = true;
|
|
|
|
// Right align the text in the keyview
|
|
KeyView.TextAlignment = Alignment.End;
|
|
KeyView.VerticalTextAlignment = Alignment.Center;
|
|
KeyView.KeyBindings.Clear ();
|
|
}
|
|
|
|
private void UpdateKeyBinding ()
|
|
{
|
|
if (Key != null)
|
|
{
|
|
// Disable the command view key bindings
|
|
CommandView.KeyBindings.Remove (Key);
|
|
CommandView.KeyBindings.Remove (CommandView.HotKey);
|
|
KeyBindings.Remove (Key);
|
|
KeyBindings.Add (Key, KeyBindingScope | KeyBindingScope.HotKey, Command.Accept);
|
|
//KeyBindings.Add (Key, KeyBindingScope.HotKey, Command.Accept);
|
|
}
|
|
}
|
|
|
|
#endregion Key
|
|
|
|
#region Accept Handling
|
|
|
|
/// <summary>
|
|
/// Called when the <see cref="Command.Accept"/> command is received. This
|
|
/// occurs
|
|
/// - if the user clicks anywhere on the shortcut with the mouse
|
|
/// - if the user presses Key
|
|
/// - if the user presses the HotKey specified by CommandView
|
|
/// - if HasFocus and the user presses Space or Enter (or any other key bound to Command.Accept).
|
|
/// </summary>
|
|
protected bool? OnAccept (CommandContext ctx)
|
|
{
|
|
var cancel = false;
|
|
|
|
switch (ctx.KeyBinding?.Scope)
|
|
{
|
|
case KeyBindingScope.Application:
|
|
cancel = base.OnAccept () == true;
|
|
|
|
break;
|
|
|
|
case KeyBindingScope.Focused:
|
|
base.OnAccept ();
|
|
|
|
// cancel if we're focused
|
|
cancel = true;
|
|
|
|
break;
|
|
|
|
case KeyBindingScope.HotKey:
|
|
cancel = base.OnAccept () == true;
|
|
|
|
if (CanFocus)
|
|
{
|
|
SetFocus ();
|
|
cancel = true;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
// Mouse
|
|
cancel = base.OnAccept () == true;
|
|
|
|
break;
|
|
}
|
|
|
|
CommandView.InvokeCommand (Command.Accept, ctx.Key, ctx.KeyBinding);
|
|
|
|
if (Action is { })
|
|
{
|
|
Action.Invoke ();
|
|
// Assume if there's a subscriber to Action, it's handled.
|
|
cancel = true;
|
|
}
|
|
|
|
return cancel;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the action to be invoked when the shortcut key is pressed or the shortcut is clicked on with the
|
|
/// mouse.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Note, the <see cref="View.Accept"/> event is fired first, and if cancelled, the event will not be invoked.
|
|
/// </remarks>
|
|
[CanBeNull]
|
|
public Action Action { get; set; }
|
|
|
|
#endregion Accept Handling
|
|
|
|
private bool? OnSelect (CommandContext ctx)
|
|
{
|
|
if (CommandView.GetSupportedCommands ().Contains (Command.Select))
|
|
{
|
|
return CommandView.InvokeCommand (Command.Select, ctx.Key, ctx.KeyBinding);
|
|
}
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
#region Focus
|
|
|
|
/// <inheritdoc/>
|
|
public override ColorScheme ColorScheme
|
|
{
|
|
get => base.ColorScheme;
|
|
set
|
|
{
|
|
base.ColorScheme = value;
|
|
SetColors ();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// </summary>
|
|
internal void SetColors ()
|
|
{
|
|
// Border should match superview.
|
|
Border.ColorScheme = SuperView?.ColorScheme;
|
|
|
|
if (HasFocus)
|
|
{
|
|
// When we have focus, we invert the colors
|
|
base.ColorScheme = new (base.ColorScheme)
|
|
{
|
|
Normal = base.ColorScheme.Focus,
|
|
HotNormal = base.ColorScheme.HotFocus,
|
|
HotFocus = base.ColorScheme.HotNormal,
|
|
Focus = base.ColorScheme.Normal
|
|
};
|
|
}
|
|
else
|
|
{
|
|
base.ColorScheme = SuperView?.ColorScheme ?? base.ColorScheme;
|
|
}
|
|
|
|
// Set KeyView's colors to show "hot"
|
|
if (IsInitialized && base.ColorScheme is { })
|
|
{
|
|
var cs = new ColorScheme (base.ColorScheme)
|
|
{
|
|
Normal = base.ColorScheme.HotNormal,
|
|
HotNormal = base.ColorScheme.Normal
|
|
};
|
|
KeyView.ColorScheme = cs;
|
|
}
|
|
}
|
|
|
|
View _lastFocusedView;
|
|
/// <inheritdoc/>
|
|
public override bool OnEnter (View view)
|
|
{
|
|
SetColors ();
|
|
_lastFocusedView = view;
|
|
|
|
return base.OnEnter (view);
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public override bool OnLeave (View view)
|
|
{
|
|
SetColors ();
|
|
_lastFocusedView = this;
|
|
|
|
return base.OnLeave (view);
|
|
}
|
|
|
|
#endregion Focus
|
|
|
|
/// <inheritdoc/>
|
|
protected override void Dispose (bool disposing)
|
|
{
|
|
if (disposing)
|
|
{
|
|
if (CommandView?.IsAdded == false)
|
|
{
|
|
CommandView.Dispose ();
|
|
}
|
|
|
|
if (HelpView?.IsAdded == false)
|
|
{
|
|
HelpView.Dispose ();
|
|
}
|
|
|
|
if (KeyView?.IsAdded == false)
|
|
{
|
|
KeyView.Dispose ();
|
|
}
|
|
}
|
|
|
|
base.Dispose (disposing);
|
|
}
|
|
}
|