|
|
@@ -0,0 +1,1712 @@
|
|
|
+using Microsoft.VisualBasic.FileIO;
|
|
|
+using System;
|
|
|
+using System.Collections.Generic;
|
|
|
+using System.Diagnostics;
|
|
|
+using System.Linq;
|
|
|
+using System.Text;
|
|
|
+using Unix.Terminal;
|
|
|
+
|
|
|
+namespace Terminal.Gui;
|
|
|
+
|
|
|
+/// <summary>
|
|
|
+/// <see cref="EventArgs"/> for <see cref="Slider{T}"/> <see cref="SliderOption{T}"/> events.
|
|
|
+/// </summary>
|
|
|
+public class SliderOptionEventArgs : EventArgs {
|
|
|
+ /// <summary>
|
|
|
+ /// Gets whether the option is set or not.
|
|
|
+ /// </summary>
|
|
|
+ public bool IsSet { get; }
|
|
|
+
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Initializes a new instance of <see cref="SliderOptionEventArgs"/>
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="isSet"> indicates whether the option is set</param>
|
|
|
+ public SliderOptionEventArgs (bool isSet)
|
|
|
+ {
|
|
|
+ IsSet = isSet;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/// <summary>
|
|
|
+/// Represents an option in a <see cref="Slider{T}"/> .
|
|
|
+/// </summary>
|
|
|
+/// <typeparam name="T">Datatype of the option.</typeparam>
|
|
|
+public class SliderOption<T> {
|
|
|
+ /// <summary>
|
|
|
+ /// Legend of the option.
|
|
|
+ /// </summary>
|
|
|
+ public string Legend { get; set; }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Abbreviation of the Legend. When the <see cref="Slider{T}.InnerSpacing"/> too small to fit <see cref="Legend"/>.
|
|
|
+ /// </summary>
|
|
|
+ public Rune LegendAbbr { get; set; }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Custom data of the option.
|
|
|
+ /// </summary>
|
|
|
+ public T Data { get; set; }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// To Raise the <see cref="Set"/> event from the Slider.
|
|
|
+ /// </summary>
|
|
|
+ internal void OnSet ()
|
|
|
+ {
|
|
|
+ Set?.Invoke (this, new SliderOptionEventArgs (true));
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// To Raise the <see cref="UnSet"/> event from the Slider.
|
|
|
+ /// </summary>
|
|
|
+ internal void OnUnSet ()
|
|
|
+ {
|
|
|
+ UnSet?.Invoke (this, new SliderOptionEventArgs (false));
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// To Raise the <see cref="Changed"/> event from the Slider.
|
|
|
+ /// </summary>
|
|
|
+ internal void OnChanged (bool isSet)
|
|
|
+ {
|
|
|
+ Changed?.Invoke (this, new SliderOptionEventArgs (isSet));
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Event Raised when this option is set.
|
|
|
+ /// </summary>
|
|
|
+ public event EventHandler<SliderOptionEventArgs> Set;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Event Raised when this option is unset.
|
|
|
+ /// </summary>
|
|
|
+ public event EventHandler<SliderOptionEventArgs> UnSet;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Event fired when the an option has changed.
|
|
|
+ /// </summary>
|
|
|
+ public event EventHandler<SliderOptionEventArgs> Changed;
|
|
|
+}
|
|
|
+
|
|
|
+/// <summary>
|
|
|
+/// <see cref="Slider{T}"/> Types
|
|
|
+/// </summary>
|
|
|
+public enum SliderType {
|
|
|
+ /// <summary>
|
|
|
+ /// <code>
|
|
|
+ /// ├─┼─┼─┼─┼─█─┼─┼─┼─┼─┼─┼─┤
|
|
|
+ /// </code>
|
|
|
+ /// </summary>
|
|
|
+ Single,
|
|
|
+ /// <summary>
|
|
|
+ /// <code>
|
|
|
+ /// ├─┼─█─┼─┼─█─┼─┼─┼─┼─█─┼─┤
|
|
|
+ /// </code>
|
|
|
+ /// </summary>
|
|
|
+ Multiple,
|
|
|
+ /// <summary>
|
|
|
+ /// <code>
|
|
|
+ /// ├▒▒▒▒▒▒▒▒▒█─┼─┼─┼─┼─┼─┼─┤
|
|
|
+ /// </code>
|
|
|
+ /// </summary>
|
|
|
+ LeftRange,
|
|
|
+ /// <summary>
|
|
|
+ /// <code>
|
|
|
+ /// ├─┼─┼─┼─┼─█▒▒▒▒▒▒▒▒▒▒▒▒▒┤
|
|
|
+ /// </code>
|
|
|
+ /// </summary>
|
|
|
+ RightRange,
|
|
|
+ /// <summary>
|
|
|
+ /// <code>
|
|
|
+ /// ├─┼─┼─┼─┼─█▒▒▒▒▒▒▒█─┼─┼─┤
|
|
|
+ /// </code>
|
|
|
+ /// </summary>
|
|
|
+ Range
|
|
|
+}
|
|
|
+
|
|
|
+/// <summary>
|
|
|
+/// <see cref="Slider{T}"/> Legend Style
|
|
|
+/// </summary>
|
|
|
+public class SliderAttributes {
|
|
|
+ /// <summary>
|
|
|
+ /// Attribute for when the respective Option is NOT Set.
|
|
|
+ /// </summary>
|
|
|
+ public Attribute? NormalAttribute { get; set; }
|
|
|
+ /// <summary>
|
|
|
+ /// Attribute for when the respective Option is Set.
|
|
|
+ /// </summary>
|
|
|
+ public Attribute? SetAttribute { get; set; }
|
|
|
+ /// <summary>
|
|
|
+ /// Attribute for the Legends Container.
|
|
|
+ /// </summary>
|
|
|
+ public Attribute? EmptyAttribute { get; set; }
|
|
|
+}
|
|
|
+
|
|
|
+/// <summary>
|
|
|
+/// <see cref="Slider{T}"/> Style
|
|
|
+/// </summary>
|
|
|
+public class SliderStyle {
|
|
|
+ /// <summary>
|
|
|
+ /// Legend attributes
|
|
|
+ /// </summary>
|
|
|
+ public SliderAttributes LegendAttributes { get; set; }
|
|
|
+ /// <summary>
|
|
|
+ /// The glyph and the attribute used for empty spaces on the slider.
|
|
|
+ /// </summary>
|
|
|
+ public Cell EmptyChar { get; set; }
|
|
|
+ /// <summary>
|
|
|
+ /// The glyph and the attribute used for each option (tick) on the slider.
|
|
|
+ /// </summary>
|
|
|
+ public Cell OptionChar { get; set; }
|
|
|
+ /// <summary>
|
|
|
+ /// The glyph and the attribute used for options (ticks) that are set on the slider.
|
|
|
+ /// </summary>
|
|
|
+ public Cell SetChar { get; set; }
|
|
|
+ /// <summary>
|
|
|
+ /// The glyph and the attribute to indicate mouse dragging.
|
|
|
+ /// </summary>
|
|
|
+ public Cell DragChar { get; set; }
|
|
|
+ /// <summary>
|
|
|
+ /// The glyph and the attribute used for spaces between options (ticks) on the slider.
|
|
|
+ /// </summary>
|
|
|
+ public Cell SpaceChar { get; set; }
|
|
|
+ /// <summary>
|
|
|
+ /// The glyph and the attribute used for filling in ranges on the slider.
|
|
|
+ /// </summary>
|
|
|
+ public Cell RangeChar { get; set; }
|
|
|
+ /// <summary>
|
|
|
+ /// The glyph and the attribute used for the start of ranges on the slider.
|
|
|
+ /// </summary>
|
|
|
+ public Cell StartRangeChar { get; set; }
|
|
|
+ /// <summary>
|
|
|
+ /// The glyph and the attribute used for the end of ranges on the slider.
|
|
|
+ /// </summary>
|
|
|
+ public Cell EndRangeChar { get; set; }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Constructs a new instance.
|
|
|
+ /// </summary>
|
|
|
+ public SliderStyle ()
|
|
|
+ {
|
|
|
+ LegendAttributes = new SliderAttributes { };
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/// <summary>
|
|
|
+/// All <see cref="Slider{T}"/> configuration are grouped in this class.
|
|
|
+/// </summary>
|
|
|
+internal class SliderConfiguration {
|
|
|
+ internal bool _rangeAllowSingle;
|
|
|
+ internal bool _allowEmpty;
|
|
|
+
|
|
|
+ internal int _mouseClickXOptionThreshold;
|
|
|
+
|
|
|
+ internal bool _autoSize;
|
|
|
+
|
|
|
+ internal int _startSpacing;
|
|
|
+ internal int _endSpacing;
|
|
|
+ internal int _innerSpacing;
|
|
|
+
|
|
|
+ internal bool _showSpacing;
|
|
|
+ internal bool _showLegends;
|
|
|
+ internal bool _showLegendsAbbr;
|
|
|
+
|
|
|
+ internal SliderType _type = SliderType.Single;
|
|
|
+ internal Orientation _sliderOrientation = Orientation.Horizontal;
|
|
|
+ internal Orientation _legendsOrientation = Orientation.Horizontal;
|
|
|
+}
|
|
|
+
|
|
|
+/// <summary>
|
|
|
+/// <see cref="EventArgs"/> for <see cref="Slider{T}"/> events.
|
|
|
+/// </summary>
|
|
|
+public class SliderEventArgs<T> : EventArgs {
|
|
|
+ /// <summary>
|
|
|
+ /// Gets/sets whether the option is set or not.
|
|
|
+ /// </summary>
|
|
|
+ public Dictionary<int, SliderOption<T>> Options { get; set; }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Gets or sets the index of the option that is focused.
|
|
|
+ /// </summary>
|
|
|
+ public int Focused { get; set; }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// If set to true, the focus operation will be canceled, if applicable.
|
|
|
+ /// </summary>
|
|
|
+ public bool Cancel { get; set; }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Initializes a new instance of <see cref="SliderEventArgs{T}"/>
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="options">The current options.</param>
|
|
|
+ /// <param name="focused">Index of the option that is focused. -1 if no option has the focus.</param>
|
|
|
+ public SliderEventArgs (Dictionary<int, SliderOption<T>> options, int focused = -1)
|
|
|
+ {
|
|
|
+ Options = options;
|
|
|
+ Focused = focused;
|
|
|
+ Cancel = false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/// <summary>
|
|
|
+/// <see cref="EventArgs"/> for <see cref="Orientation"/> events.
|
|
|
+/// </summary>
|
|
|
+public class OrientationEventArgs : EventArgs {
|
|
|
+ /// <summary>
|
|
|
+ /// The new orientation.
|
|
|
+ /// </summary>
|
|
|
+ public Orientation Orientation { get; set; }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// If set to true, the orientation change operation will be canceled, if applicable.
|
|
|
+ /// </summary>
|
|
|
+ public bool Cancel { get; set; }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Constructs a new instance.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="orientation">the new orientation</param>
|
|
|
+ public OrientationEventArgs (Orientation orientation)
|
|
|
+ {
|
|
|
+ Orientation = orientation;
|
|
|
+ Cancel = false;
|
|
|
+ }
|
|
|
+}
|
|
|
+/// <summary>
|
|
|
+/// Slider control.
|
|
|
+/// </summary>
|
|
|
+public class Slider : Slider<object> {
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Initializes a new instance of the <see cref="Slider"/> class.
|
|
|
+ /// </summary>
|
|
|
+ public Slider () : base () { }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Initializes a new instance of the <see cref="Slider"/> class.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="options">Initial slider options.</param>
|
|
|
+ /// <param name="orientation">Initial slider options.</param>
|
|
|
+ public Slider (List<object> options, Orientation orientation = Orientation.Horizontal) : base (options, orientation) { }
|
|
|
+}
|
|
|
+
|
|
|
+/// <summary>
|
|
|
+/// Provides a slider control letting the user navigate from a set of typed options in a linear manner using the keyboard or mouse.
|
|
|
+/// </summary>
|
|
|
+/// <typeparam name="T"></typeparam>
|
|
|
+public class Slider<T> : View {
|
|
|
+ SliderConfiguration _config = new SliderConfiguration ();
|
|
|
+ SliderStyle _style = new SliderStyle ();
|
|
|
+
|
|
|
+ // Options
|
|
|
+ List<SliderOption<T>> _options;
|
|
|
+ // List of the current set options.
|
|
|
+ List<int> _setOptions = new List<int> ();
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// The focused option (has the cursor).
|
|
|
+ /// </summary>
|
|
|
+ public int FocusedOption { get; set; }
|
|
|
+
|
|
|
+ #region Events
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Event raised when the slider option/s changed.
|
|
|
+ /// The dictionary contains: key = option index, value = T
|
|
|
+ /// </summary>
|
|
|
+ public event EventHandler<SliderEventArgs<T>> OptionsChanged;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Overridable method called when the slider options have changed. Raises the <see cref="OptionsChanged"/> event.
|
|
|
+ /// </summary>
|
|
|
+ public virtual void OnOptionsChanged ()
|
|
|
+ {
|
|
|
+ OptionsChanged?.Invoke (this, new SliderEventArgs<T> (GetSetOptionDictionary ()));
|
|
|
+ SetNeedsDisplay ();
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Event raised When the option is hovered with the keys or the mouse.
|
|
|
+ /// </summary>
|
|
|
+ public event EventHandler<SliderEventArgs<T>> OptionFocused;
|
|
|
+
|
|
|
+ int _lastFocusedOption; // for Range type; the most recently focused option. Used to determine shrink direction
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Overridable function that fires the <see cref="OptionFocused"/> event.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="args"></param>
|
|
|
+ /// <returns><see langword="true"/> if the focus change was cancelled.</returns>
|
|
|
+ public virtual bool OnOptionFocused (int newFocusedOption, SliderEventArgs<T> args)
|
|
|
+ {
|
|
|
+ if (newFocusedOption > _options.Count - 1 || newFocusedOption < 0) {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ OptionFocused?.Invoke (this, args);
|
|
|
+ if (!args.Cancel) {
|
|
|
+ _lastFocusedOption = FocusedOption;
|
|
|
+ FocusedOption = newFocusedOption;
|
|
|
+ PositionCursor ();
|
|
|
+ }
|
|
|
+ return args.Cancel;
|
|
|
+ }
|
|
|
+
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ #region Constructors
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Initializes a new instance of the <see cref="Slider"/> class.
|
|
|
+ /// </summary>
|
|
|
+ public Slider () : this (new List<T> ())
|
|
|
+ {
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Initializes a new instance of the <see cref="Slider"/> class.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="options">Initial slider options.</param>
|
|
|
+ /// <param name="orientation">Initial slider orientation.</param>
|
|
|
+ public Slider (List<T> options, Orientation orientation = Orientation.Horizontal)
|
|
|
+ {
|
|
|
+ if (options == null) {
|
|
|
+ SetInitialProperties (null, orientation);
|
|
|
+ } else {
|
|
|
+ SetInitialProperties (options.Select (e => {
|
|
|
+ var legend = e.ToString ();
|
|
|
+ return new SliderOption<T> {
|
|
|
+ Data = e,
|
|
|
+ Legend = legend,
|
|
|
+ LegendAbbr = (Rune)(legend?.Length > 0 ? legend [0] : ' '),
|
|
|
+ };
|
|
|
+ }).ToList (), orientation);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ #region Initialize
|
|
|
+ void SetInitialProperties (List<SliderOption<T>> options, Orientation orientation = Orientation.Horizontal)
|
|
|
+ {
|
|
|
+ CanFocus = true;
|
|
|
+
|
|
|
+ this._options = options ?? new List<SliderOption<T>> ();
|
|
|
+
|
|
|
+ _config._sliderOrientation = orientation;
|
|
|
+
|
|
|
+ _config._showLegends = true;
|
|
|
+
|
|
|
+ SetDefaultStyle ();
|
|
|
+ SetCommands ();
|
|
|
+
|
|
|
+ // When we lose focus of the View(Slider), if we are range selecting we stop it.
|
|
|
+ Leave += (object s, FocusEventArgs e) => {
|
|
|
+ //if (_settingRange == true) {
|
|
|
+ // _settingRange = false;
|
|
|
+ //}
|
|
|
+ Driver.SetCursorVisibility (CursorVisibility.Invisible);
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ Enter += (object s, FocusEventArgs e) => {
|
|
|
+ };
|
|
|
+
|
|
|
+ LayoutComplete += (s, e) => {
|
|
|
+ CalcSpacingConfig ();
|
|
|
+ AdjustBestHeight ();
|
|
|
+ AdjustBestWidth ();
|
|
|
+ };
|
|
|
+ }
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ #region Properties
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Allow no selection.
|
|
|
+ /// </summary>
|
|
|
+ public bool AllowEmpty {
|
|
|
+ get => _config._allowEmpty;
|
|
|
+ set {
|
|
|
+ _config._allowEmpty = value;
|
|
|
+ if (!value && _options.Count > 0 && _setOptions.Count == 0) {
|
|
|
+ SetOption (0);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// If <see langword="true"/> the slider will be sized to fit the available space (the Bounds of the the SuperView).
|
|
|
+ /// </summary>
|
|
|
+ /// <remarks>
|
|
|
+ /// For testing, if there is no SuperView, the slider will be sized based on what <see cref="InnerSpacing"/> is
|
|
|
+ /// set to.
|
|
|
+ /// </remarks>
|
|
|
+ public override bool AutoSize {
|
|
|
+ get => _config._autoSize;
|
|
|
+ set => _config._autoSize = value;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Gets or sets the number of rows/columns between <see cref="Options"/>
|
|
|
+ /// </summary>
|
|
|
+ public int InnerSpacing {
|
|
|
+
|
|
|
+ get => _config._innerSpacing;
|
|
|
+ set {
|
|
|
+ _config._innerSpacing = value;
|
|
|
+ CalcSpacingConfig ();
|
|
|
+ Adjust ();
|
|
|
+ SetNeedsDisplay ();
|
|
|
+ SuperView?.SetNeedsLayout ();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Slider Type. <see cref="SliderType"></see>
|
|
|
+ /// </summary>
|
|
|
+ public SliderType Type {
|
|
|
+ get => _config._type;
|
|
|
+ set {
|
|
|
+ _config._type = value;
|
|
|
+
|
|
|
+ // Todo: Custom logic to preserve options.
|
|
|
+ _setOptions.Clear ();
|
|
|
+
|
|
|
+ SetNeedsDisplay ();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Slider Orientation. <see cref="Gui.Orientation"></see>
|
|
|
+ /// </summary>
|
|
|
+ public Orientation Orientation {
|
|
|
+ get => _config._sliderOrientation;
|
|
|
+ set => OnOrientationChanged (value);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Fired when the slider orientation has changed. Can be cancelled by setting <see cref="OrientationEventArgs.Cancel"/> to true.
|
|
|
+ /// </summary>
|
|
|
+ public event EventHandler<OrientationEventArgs> OrientationChanged;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Called when the slider orientation has changed. Invokes the <see cref="OrientationChanged"/> event.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="newOrientation"></param>
|
|
|
+ /// <returns>True of the event was cancelled.</returns>
|
|
|
+ public virtual bool OnOrientationChanged (Orientation newOrientation)
|
|
|
+ {
|
|
|
+ var args = new OrientationEventArgs (newOrientation);
|
|
|
+ OrientationChanged?.Invoke (this, args);
|
|
|
+ if (!args.Cancel) {
|
|
|
+ _config._sliderOrientation = newOrientation;
|
|
|
+ SetKeyBindings ();
|
|
|
+ if (IsInitialized) {
|
|
|
+ CalcSpacingConfig ();
|
|
|
+ Adjust ();
|
|
|
+ SetNeedsDisplay ();
|
|
|
+ SuperView?.SetNeedsLayout ();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return args.Cancel;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Legends Orientation. <see cref="Gui.Orientation"></see>
|
|
|
+ /// </summary>
|
|
|
+ public Orientation LegendsOrientation {
|
|
|
+ get => _config._legendsOrientation;
|
|
|
+ set {
|
|
|
+ _config._legendsOrientation = value;
|
|
|
+ CalcSpacingConfig ();
|
|
|
+ Adjust ();
|
|
|
+ SetNeedsDisplay ();
|
|
|
+ SuperView?.SetNeedsLayout ();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Slider styles. <see cref="SliderStyle"></see>
|
|
|
+ /// </summary>
|
|
|
+ public SliderStyle Style {
|
|
|
+ get {
|
|
|
+ // Note(jmperricone): Maybe SliderStyle should be a struct so we return a copy ???
|
|
|
+ // Or SetStyle() and ( GetStyle() || Style getter copy )
|
|
|
+ return _style;
|
|
|
+ }
|
|
|
+ set {
|
|
|
+ // Note(jmperricone): If the user change a style, he/she must call SetNeedsDisplay(). OK ???
|
|
|
+ _style = value;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Set the slider options.
|
|
|
+ /// </summary>
|
|
|
+ public List<SliderOption<T>> Options {
|
|
|
+ get {
|
|
|
+ // Note(jmperricone): Maybe SliderOption should be a struct so we return a copy ???
|
|
|
+ // Events will be preserved ? Need a test.
|
|
|
+ // Or SetOptions() and ( GetOptions() || Options getter copy )
|
|
|
+ return _options;
|
|
|
+ }
|
|
|
+ set {
|
|
|
+ _options = value;
|
|
|
+
|
|
|
+ if (_options == null || _options.Count == 0) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ CalcSpacingConfig ();
|
|
|
+ Adjust ();
|
|
|
+ SetNeedsDisplay ();
|
|
|
+ SuperView?.SetNeedsLayout ();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Allow range start and end be in the same option, as a single option.
|
|
|
+ /// </summary>
|
|
|
+ public bool RangeAllowSingle {
|
|
|
+ get => _config._rangeAllowSingle;
|
|
|
+ set {
|
|
|
+ _config._rangeAllowSingle = value;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Show/Hide spacing before and after the first and last option.
|
|
|
+ /// </summary>
|
|
|
+ public bool ShowSpacing {
|
|
|
+ get => _config._showSpacing;
|
|
|
+ set {
|
|
|
+ _config._showSpacing = value;
|
|
|
+ SetNeedsDisplay ();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Show/Hide the options legends.
|
|
|
+ /// </summary>
|
|
|
+ public bool ShowLegends {
|
|
|
+ get => _config._showLegends;
|
|
|
+ set {
|
|
|
+ _config._showLegends = value;
|
|
|
+ Adjust ();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Causes the specified option to be set and be focused.
|
|
|
+ /// </summary>
|
|
|
+ public bool SetOption (int optionIndex)
|
|
|
+ {
|
|
|
+ // TODO: Handle range type.
|
|
|
+ // Note: Maybe return false only when optionIndex doesn't exist, otherwise true.
|
|
|
+
|
|
|
+ if (!_setOptions.Contains (optionIndex) && optionIndex >= 0 && optionIndex < _options.Count) {
|
|
|
+ FocusedOption = optionIndex;
|
|
|
+ SetFocusedOption ();
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Causes the specified option to be un-set and be focused.
|
|
|
+ /// </summary>
|
|
|
+ public bool UnSetOption (int optionIndex)
|
|
|
+ {
|
|
|
+ // TODO: Handle range type.
|
|
|
+ if ((!AllowEmpty && _setOptions.Count > 2) && _setOptions.Contains (optionIndex)) {
|
|
|
+ FocusedOption = optionIndex;
|
|
|
+ SetFocusedOption ();
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Get the indexes of the set options.
|
|
|
+ /// </summary>
|
|
|
+ public List<int> GetSetOptions ()
|
|
|
+ {
|
|
|
+ // Copy
|
|
|
+ return _setOptions.OrderBy (e => e).ToList ();
|
|
|
+ }
|
|
|
+
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ #region Helpers
|
|
|
+ void MoveAndAdd (int x, int y, Rune rune)
|
|
|
+ {
|
|
|
+ Move (x, y);
|
|
|
+ Driver?.AddRune (rune);
|
|
|
+ }
|
|
|
+
|
|
|
+ void MoveAndAdd (int x, int y, string str)
|
|
|
+ {
|
|
|
+ Move (x, y);
|
|
|
+ Driver?.AddStr (str);
|
|
|
+ }
|
|
|
+
|
|
|
+ // TODO: Make configurable via ConfigurationManager
|
|
|
+ void SetDefaultStyle ()
|
|
|
+ {
|
|
|
+ switch (_config._sliderOrientation) {
|
|
|
+ case Orientation.Horizontal:
|
|
|
+ _style.SpaceChar = new Cell () { Runes = { CM.Glyphs.HLine } }; // '─'
|
|
|
+ _style.OptionChar = new Cell () { Runes = { CM.Glyphs.BlackCircle } }; // '┼●🗹□⏹'
|
|
|
+ break;
|
|
|
+ case Orientation.Vertical:
|
|
|
+ _style.SpaceChar = new Cell () { Runes = { CM.Glyphs.VLine } };
|
|
|
+ _style.OptionChar = new Cell () { Runes = { CM.Glyphs.BlackCircle } };
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ // TODO(jmperricone) Wide Vertical ???
|
|
|
+ /*
|
|
|
+ │
|
|
|
+ │
|
|
|
+ ┼─ 40
|
|
|
+ │
|
|
|
+ │
|
|
|
+ ███ 30
|
|
|
+ ▒▒▒
|
|
|
+ ▒▒▒
|
|
|
+ ▒▒▒ 20
|
|
|
+ ▒▒▒
|
|
|
+ ▒▒▒
|
|
|
+ ███ 10
|
|
|
+ │
|
|
|
+ │
|
|
|
+ ─●─ 0
|
|
|
+ */
|
|
|
+
|
|
|
+ _config._legendsOrientation = _config._sliderOrientation;
|
|
|
+ _style.EmptyChar = new Cell () { Runes = { new Rune (' ') } };
|
|
|
+ _style.SetChar = new Cell () { Runes = { CM.Glyphs.ContinuousMeterSegment } }; // ■
|
|
|
+ _style.RangeChar = new Cell () { Runes = { CM.Glyphs.Stipple } }; // ░ ▒ ▓ // Medium shade not blinking on curses.
|
|
|
+ _style.StartRangeChar = new Cell () { Runes = { CM.Glyphs.ContinuousMeterSegment } };
|
|
|
+ _style.EndRangeChar = new Cell () { Runes = { CM.Glyphs.ContinuousMeterSegment } };
|
|
|
+ _style.DragChar = new Cell () { Runes = { CM.Glyphs.Diamond } };
|
|
|
+
|
|
|
+ // TODO: Support left & right (top/bottom)
|
|
|
+ // First = '├',
|
|
|
+ // Last = '┤',
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Calculates the spacing configuration (start, inner, end) as well as turning on/off legend abbreviation
|
|
|
+ /// if needed. Behaves differently based on <see cref="AutoSize"/> and <see cref="View.IsInitialized"/>.
|
|
|
+ /// </summary>
|
|
|
+ internal void CalcSpacingConfig ()
|
|
|
+ {
|
|
|
+ int size = 0;
|
|
|
+
|
|
|
+ if (_options.Count == 0) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (_config._autoSize || !IsInitialized) {
|
|
|
+ if (IsInitialized && SuperView != null) {
|
|
|
+ // Calculate the size of the slider based on the size of the SuperView's Bounds.
|
|
|
+ // TODO:
|
|
|
+
|
|
|
+ } else {
|
|
|
+ // Use the config values
|
|
|
+ size = CalcLength ();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ // Fit Slider to the actual width and height.
|
|
|
+ if (_config._sliderOrientation == Orientation.Horizontal) {
|
|
|
+ size = Bounds.Width;
|
|
|
+ } else {
|
|
|
+ size = Bounds.Height;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ int max_legend;
|
|
|
+ if (_config._sliderOrientation == _config._legendsOrientation) {
|
|
|
+ max_legend = _options.Max (e => e.Legend.ToString ().Length);
|
|
|
+ } else {
|
|
|
+ max_legend = 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ var min = (size - max_legend) / (_options.Count - 1);
|
|
|
+
|
|
|
+ string first;
|
|
|
+ string last;
|
|
|
+
|
|
|
+ if (max_legend >= min) {
|
|
|
+ if (_config._sliderOrientation == _config._legendsOrientation) {
|
|
|
+ _config._showLegendsAbbr = true;
|
|
|
+ }
|
|
|
+ first = "x";
|
|
|
+ last = "x";
|
|
|
+ } else {
|
|
|
+ _config._showLegendsAbbr = false;
|
|
|
+ first = _options.First ().Legend;
|
|
|
+ last = _options.Last ().Legend;
|
|
|
+ }
|
|
|
+
|
|
|
+ // --o--
|
|
|
+ // Hello
|
|
|
+ // Left = He
|
|
|
+ // Right = lo
|
|
|
+ var first_left = (first.Length - 1) / 2; // Chars count of the first option to the left.
|
|
|
+ var last_right = (last.Length) / 2; // Chars count of the last option to the right.
|
|
|
+
|
|
|
+ if (_config._sliderOrientation != _config._legendsOrientation) {
|
|
|
+ first_left = 0;
|
|
|
+ last_right = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ var width = size - first_left - last_right - 1;
|
|
|
+
|
|
|
+ _config._startSpacing = first_left;
|
|
|
+ _config._innerSpacing = Math.Max (0, (int)Math.Floor ((double)width / (_options.Count - 1)) - 1);
|
|
|
+ _config._endSpacing = last_right;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Adjust the height of the Slider to the best value.
|
|
|
+ ///</summary>
|
|
|
+ public void AdjustBestHeight ()
|
|
|
+ {
|
|
|
+ // Hack??? Otherwise we can't go back to Dim.Absolute.
|
|
|
+ LayoutStyle = LayoutStyle.Absolute;
|
|
|
+
|
|
|
+ if (_config._sliderOrientation == Orientation.Horizontal) {
|
|
|
+ Bounds = new Rect (Bounds.Location, new Size (Bounds.Width, CalcThickness ()));
|
|
|
+ } else {
|
|
|
+ Bounds = new Rect (Bounds.Location, new Size (Bounds.Width, CalcLength ()));
|
|
|
+ }
|
|
|
+
|
|
|
+ LayoutStyle = LayoutStyle.Computed;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Adjust the height of the Slider to the best value. (Only works if height is DimAbsolute).
|
|
|
+ ///</summary>
|
|
|
+ public void AdjustBestWidth ()
|
|
|
+ {
|
|
|
+ LayoutStyle = LayoutStyle.Absolute;
|
|
|
+
|
|
|
+ if (_config._sliderOrientation == Orientation.Horizontal) {
|
|
|
+ Bounds = new Rect (Bounds.Location, new Size (CalcLength (), Bounds.Height));
|
|
|
+ } else {
|
|
|
+ Bounds = new Rect (Bounds.Location, new Size (CalcThickness (), Bounds.Height));
|
|
|
+ }
|
|
|
+
|
|
|
+ LayoutStyle = LayoutStyle.Computed;
|
|
|
+ }
|
|
|
+
|
|
|
+ void Adjust ()
|
|
|
+ {
|
|
|
+ if (Width is Dim.DimAbsolute) {
|
|
|
+ AdjustBestWidth ();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (Height is Dim.DimAbsolute) {
|
|
|
+ AdjustBestHeight ();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ internal int CalcLength ()
|
|
|
+ {
|
|
|
+ if (_options.Count == 0) {
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ var length = 0;
|
|
|
+ length += _config._startSpacing + _config._endSpacing;
|
|
|
+ length += _options.Count;
|
|
|
+ length += (_options.Count - 1) * _config._innerSpacing;
|
|
|
+ return length;
|
|
|
+ }
|
|
|
+
|
|
|
+ int CalcThickness ()
|
|
|
+ {
|
|
|
+ var thickness = 1; // Always show the slider.
|
|
|
+
|
|
|
+ if (_config._showLegends) {
|
|
|
+ if (_config._legendsOrientation != _config._sliderOrientation && _options.Count > 0) {
|
|
|
+ thickness += _options.Max (s => s.Legend.Length);
|
|
|
+ } else {
|
|
|
+ thickness += 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return thickness;
|
|
|
+ }
|
|
|
+
|
|
|
+ internal bool TryGetPositionByOption (int option, out (int x, int y) position)
|
|
|
+ {
|
|
|
+ position = (-1, -1);
|
|
|
+
|
|
|
+ if (option < 0 || option >= _options.Count ()) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ var offset = 0;
|
|
|
+ offset += _config._startSpacing;
|
|
|
+ offset += option * (_config._innerSpacing + 1);
|
|
|
+
|
|
|
+ if (_config._sliderOrientation == Orientation.Vertical) {
|
|
|
+ position = (0, offset);
|
|
|
+ } else {
|
|
|
+ position = (offset, 0);
|
|
|
+ }
|
|
|
+
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Tries to get the option index by the position.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="x"></param>
|
|
|
+ /// <param name="y"></param>
|
|
|
+ /// <param name="threshold"></param>
|
|
|
+ /// <param name="option_idx"></param>
|
|
|
+ /// <returns></returns>
|
|
|
+ internal bool TryGetOptionByPosition (int x, int y, int threshold, out int option_idx)
|
|
|
+ {
|
|
|
+ // Fix(jmperricone): Not working.
|
|
|
+ option_idx = -1;
|
|
|
+ if (Orientation == Orientation.Horizontal) {
|
|
|
+ if (y != 0) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (int xx = (x - threshold); xx < (x + threshold + 1); xx++) {
|
|
|
+ var cx = xx;
|
|
|
+ cx -= _config._startSpacing;
|
|
|
+
|
|
|
+ var option = cx / (_config._innerSpacing + 1);
|
|
|
+ var valid = cx % (_config._innerSpacing + 1) == 0;
|
|
|
+
|
|
|
+ if (!valid || option < 0 || option > _options.Count - 1) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ option_idx = option;
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ } else {
|
|
|
+ if (x != 0) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (int yy = (y - threshold); yy < (y + threshold + 1); yy++) {
|
|
|
+ var cy = yy;
|
|
|
+ cy -= _config._startSpacing;
|
|
|
+
|
|
|
+ var option = cy / (_config._innerSpacing + 1);
|
|
|
+ var valid = cy % (_config._innerSpacing + 1) == 0;
|
|
|
+
|
|
|
+ if (!valid || option < 0 || option > _options.Count - 1) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ option_idx = option;
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ #region Cursor and Drawing
|
|
|
+
|
|
|
+ /// <inheritdoc/>
|
|
|
+ public override void PositionCursor ()
|
|
|
+ {
|
|
|
+ //base.PositionCursor ();
|
|
|
+
|
|
|
+ if (HasFocus) {
|
|
|
+ Driver?.SetCursorVisibility (CursorVisibility.Default);
|
|
|
+ } else {
|
|
|
+ Driver?.SetCursorVisibility (CursorVisibility.Invisible);
|
|
|
+ }
|
|
|
+ if (TryGetPositionByOption (FocusedOption, out (int x, int y) position)) {
|
|
|
+ if (IsInitialized && Bounds.Contains (position.x, position.y)) {
|
|
|
+ Move (position.x, position.y);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <inheritdoc/>
|
|
|
+ public override void OnDrawContent (Rect contentArea)
|
|
|
+ {
|
|
|
+ // TODO: make this more surgical to reduce repaint
|
|
|
+
|
|
|
+ var normalScheme = ColorScheme?.Normal ?? Application.Current.ColorScheme.Normal;
|
|
|
+
|
|
|
+ if (this._options == null && this._options.Count > 0) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Debug
|
|
|
+#if (DEBUG)
|
|
|
+ Driver.SetAttribute (new Attribute (Color.White, Color.Red));
|
|
|
+ for (var y = 0; y < Bounds.Height; y++) {
|
|
|
+ for (var x = 0; x < Bounds.Width; x++) {
|
|
|
+ // MoveAndAdd (x, y, '·');
|
|
|
+ }
|
|
|
+ }
|
|
|
+#endif
|
|
|
+
|
|
|
+ // Draw Slider
|
|
|
+ DrawSlider ();
|
|
|
+
|
|
|
+ // Draw Legends.
|
|
|
+ if (_config._showLegends) {
|
|
|
+ DrawLegends ();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (_dragPosition.HasValue && _moveRenderPosition.HasValue) {
|
|
|
+ AddRune (_moveRenderPosition.Value.X, _moveRenderPosition.Value.Y, _style.DragChar.Runes [0]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ string AlignText (string text, int width, TextAlignment textAlignment)
|
|
|
+ {
|
|
|
+ if (text == null) {
|
|
|
+ return "";
|
|
|
+ }
|
|
|
+
|
|
|
+ if (text.Length > width) {
|
|
|
+ text = text [0..width];
|
|
|
+ }
|
|
|
+
|
|
|
+ var w = width - text.Length;
|
|
|
+ var s1 = new string (' ', w / 2);
|
|
|
+ var s2 = new string (' ', w % 2);
|
|
|
+
|
|
|
+ // Note: The formatter doesn't handle all of this ???
|
|
|
+ switch (textAlignment) {
|
|
|
+ case TextAlignment.Justified:
|
|
|
+
|
|
|
+ return TextFormatter.Justify (text, width);
|
|
|
+ case TextAlignment.Left:
|
|
|
+ return text + s1 + s1 + s2;
|
|
|
+ case TextAlignment.Centered:
|
|
|
+ if (text.Length % 2 != 0) {
|
|
|
+ return s1 + text + s1 + s2;
|
|
|
+ } else {
|
|
|
+ return s1 + s2 + text + s1;
|
|
|
+ }
|
|
|
+ case TextAlignment.Right:
|
|
|
+ return s1 + s1 + s2 + text;
|
|
|
+ default:
|
|
|
+ return text;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ void DrawSlider ()
|
|
|
+ {
|
|
|
+ // TODO: be more surgical on clear
|
|
|
+ Clear ();
|
|
|
+
|
|
|
+ // Attributes
|
|
|
+ var normalScheme = ColorScheme?.Normal ?? Application.Current.ColorScheme.Normal;
|
|
|
+ //var normalScheme = style.LegendStyle.NormalAttribute ?? ColorScheme.Disabled;
|
|
|
+ var setScheme = _style.SetChar.Attribute ?? ColorScheme.HotNormal;// ColorScheme?.Focus ?? Application.Current.ColorScheme.Focus;
|
|
|
+
|
|
|
+ var isVertical = _config._sliderOrientation == Orientation.Vertical;
|
|
|
+ var isLegendsVertical = _config._legendsOrientation == Orientation.Vertical;
|
|
|
+ var isReverse = _config._sliderOrientation != _config._legendsOrientation;
|
|
|
+
|
|
|
+ var x = 0;
|
|
|
+ var y = 0;
|
|
|
+
|
|
|
+ var isSet = _setOptions.Count > 0;
|
|
|
+
|
|
|
+ // Left Spacing
|
|
|
+ if (_config._showSpacing && _config._startSpacing > 0) {
|
|
|
+
|
|
|
+ Driver.SetAttribute (isSet && _config._type == SliderType.LeftRange ? _style.RangeChar.Attribute ?? normalScheme : _style.SpaceChar.Attribute ?? normalScheme);
|
|
|
+ var rune = isSet && _config._type == SliderType.LeftRange ? _style.RangeChar.Runes [0] : _style.SpaceChar.Runes [0];
|
|
|
+
|
|
|
+ for (var i = 0; i < this._config._startSpacing; i++) {
|
|
|
+ MoveAndAdd (x, y, rune);
|
|
|
+ if (isVertical) y++; else x++;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ Driver.SetAttribute (_style.EmptyChar.Attribute ?? normalScheme);
|
|
|
+ // for (int i = 0; i < this.config.StartSpacing + ((this.config.StartSpacing + this.config.EndSpacing) % 2 == 0 ? 1 : 2); i++) {
|
|
|
+ for (var i = 0; i < this._config._startSpacing; i++) {
|
|
|
+ MoveAndAdd (x, y, _style.EmptyChar.Runes [0]);
|
|
|
+ if (isVertical) y++; else x++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Slider
|
|
|
+ if (_options.Count > 0) {
|
|
|
+ for (var i = 0; i < _options.Count; i++) {
|
|
|
+
|
|
|
+ var drawRange = false;
|
|
|
+
|
|
|
+ if (isSet) {
|
|
|
+ switch (_config._type) {
|
|
|
+ case SliderType.LeftRange when i <= _setOptions [0]:
|
|
|
+ drawRange = i < _setOptions [0];
|
|
|
+ break;
|
|
|
+ case SliderType.RightRange when i >= _setOptions [0]:
|
|
|
+ drawRange = i >= _setOptions [0];
|
|
|
+ break;
|
|
|
+ case SliderType.Range when _setOptions.Count == 1:
|
|
|
+ drawRange = false;
|
|
|
+ break;
|
|
|
+ case SliderType.Range when _setOptions.Count == 2:
|
|
|
+ if ((i >= _setOptions [0] && i <= _setOptions [1]) || (i >= _setOptions [1] && i <= _setOptions [0])) {
|
|
|
+ drawRange = (i >= _setOptions [0] && i < _setOptions [1]) || (i >= _setOptions [1] && i < _setOptions [0]);
|
|
|
+
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ // Is Not a Range.
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Draw Option
|
|
|
+ Driver.SetAttribute (isSet && _setOptions.Contains (i) ? _style.SetChar.Attribute ?? setScheme : drawRange ? _style.RangeChar.Attribute ?? setScheme : _style.OptionChar.Attribute ?? normalScheme);
|
|
|
+
|
|
|
+ // Note(jmperricone): Maybe only for curses, windows inverts actual colors, while curses inverts bg with fg.
|
|
|
+ //if (Application.Driver is CursesDriver) {
|
|
|
+ // if (FocusedOption == i && HasFocus) {
|
|
|
+ // Driver.SetAttribute (ColorScheme.Focus);
|
|
|
+ // }
|
|
|
+ //}
|
|
|
+ Rune rune = drawRange ? _style.RangeChar.Runes [0] : _style.OptionChar.Runes [0];
|
|
|
+ if (isSet) {
|
|
|
+ if (_setOptions [0] == i) {
|
|
|
+ rune = _style.StartRangeChar.Runes [0];
|
|
|
+ } else if (_setOptions.Count > 1 && _setOptions [1] == i) {
|
|
|
+ rune = _style.EndRangeChar.Runes [0];
|
|
|
+ } else if (_setOptions.Contains (i)) {
|
|
|
+ rune = _style.SetChar.Runes [0];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ MoveAndAdd (x, y, rune);
|
|
|
+ if (isVertical) y++; else x++;
|
|
|
+
|
|
|
+ // Draw Spacing
|
|
|
+ if (_config._showSpacing || i < _options.Count - 1) { // Skip if is the Last Spacing.
|
|
|
+ Driver.SetAttribute (drawRange && isSet ? _style.RangeChar.Attribute ?? setScheme : _style.SpaceChar.Attribute ?? normalScheme);
|
|
|
+ for (var s = 0; s < _config._innerSpacing; s++) {
|
|
|
+ MoveAndAdd (x, y, drawRange && isSet ? _style.RangeChar.Runes [0] : _style.SpaceChar.Runes [0]);
|
|
|
+ if (isVertical) y++; else x++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var remaining = isVertical ? Bounds.Height - y : Bounds.Width - x;
|
|
|
+ // Right Spacing
|
|
|
+ if (_config._showSpacing) {
|
|
|
+ Driver.SetAttribute (isSet && _config._type == SliderType.RightRange ? _style.RangeChar.Attribute ?? normalScheme : _style.SpaceChar.Attribute ?? normalScheme);
|
|
|
+ var rune = isSet && _config._type == SliderType.RightRange ? _style.RangeChar.Runes [0] : _style.SpaceChar.Runes [0];
|
|
|
+ for (var i = 0; i < remaining; i++) {
|
|
|
+ MoveAndAdd (x, y, rune);
|
|
|
+ if (isVertical) y++; else x++;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ Driver.SetAttribute (_style.EmptyChar.Attribute ?? normalScheme);
|
|
|
+ for (var i = 0; i < remaining; i++) {
|
|
|
+ MoveAndAdd (x, y, _style.EmptyChar.Runes [0]);
|
|
|
+ if (isVertical) y++; else x++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ void DrawLegends ()
|
|
|
+ {
|
|
|
+ // Attributes
|
|
|
+ var normalScheme = _style.LegendAttributes.NormalAttribute ?? ColorScheme?.Normal ?? ColorScheme.Disabled;
|
|
|
+ var setScheme = _style.LegendAttributes.SetAttribute ?? ColorScheme?.HotNormal ?? ColorScheme.Normal;
|
|
|
+ var spaceScheme = normalScheme;// style.LegendStyle.EmptyAttribute ?? normalScheme;
|
|
|
+
|
|
|
+ var isTextVertical = _config._legendsOrientation == Orientation.Vertical;
|
|
|
+ var isSet = _setOptions.Count > 0;
|
|
|
+
|
|
|
+ var x = 0;
|
|
|
+ var y = 0;
|
|
|
+
|
|
|
+ Move (x, y);
|
|
|
+
|
|
|
+ if (_config._sliderOrientation == Orientation.Horizontal && _config._legendsOrientation == Orientation.Vertical) {
|
|
|
+ x += _config._startSpacing;
|
|
|
+ }
|
|
|
+ if (_config._sliderOrientation == Orientation.Vertical && _config._legendsOrientation == Orientation.Horizontal) {
|
|
|
+ y += _config._startSpacing;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (_config._sliderOrientation == Orientation.Horizontal) {
|
|
|
+ y += 1;
|
|
|
+ } else { // Vertical
|
|
|
+ x += 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (int i = 0; i < _options.Count; i++) {
|
|
|
+
|
|
|
+ bool isOptionSet = false;
|
|
|
+
|
|
|
+ // Check if the Option is Set.
|
|
|
+ switch (_config._type) {
|
|
|
+ case SliderType.Single:
|
|
|
+ case SliderType.Multiple:
|
|
|
+ if (isSet && _setOptions.Contains (i))
|
|
|
+ isOptionSet = true;
|
|
|
+ break;
|
|
|
+ case SliderType.LeftRange:
|
|
|
+ if (isSet && i <= _setOptions [0])
|
|
|
+ isOptionSet = true;
|
|
|
+ break;
|
|
|
+ case SliderType.RightRange:
|
|
|
+ if (isSet && i >= _setOptions [0])
|
|
|
+ isOptionSet = true;
|
|
|
+ break;
|
|
|
+ case SliderType.Range when _setOptions.Count == 1:
|
|
|
+ if (isSet && i == _setOptions [0])
|
|
|
+ isOptionSet = true;
|
|
|
+ break;
|
|
|
+ case SliderType.Range:
|
|
|
+ if (isSet && ((i >= _setOptions [0] && i <= _setOptions [1]) || (i >= _setOptions [1] && i <= _setOptions [0]))) {
|
|
|
+ isOptionSet = true;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Text || Abbreviation
|
|
|
+ string text = string.Empty;
|
|
|
+ if (_config._showLegendsAbbr) {
|
|
|
+ text = _options [i].LegendAbbr.ToString () ?? new Rune (_options [i].Legend.First ()).ToString ();
|
|
|
+ } else {
|
|
|
+ text = _options [i].Legend;
|
|
|
+ }
|
|
|
+
|
|
|
+ switch (_config._sliderOrientation) {
|
|
|
+ case Orientation.Horizontal:
|
|
|
+ switch (_config._legendsOrientation) {
|
|
|
+ case Orientation.Horizontal:
|
|
|
+ text = AlignText (text, _config._innerSpacing + 1, TextAlignment.Centered);
|
|
|
+ break;
|
|
|
+ case Orientation.Vertical:
|
|
|
+ y = 1;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case Orientation.Vertical:
|
|
|
+ switch (_config._legendsOrientation) {
|
|
|
+ case Orientation.Horizontal:
|
|
|
+ x = 1;
|
|
|
+ break;
|
|
|
+ case Orientation.Vertical:
|
|
|
+ text = AlignText (text, _config._innerSpacing + 1, TextAlignment.Centered);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Text
|
|
|
+ var legend_left_spaces_count = text.TakeWhile (e => e == ' ').Count ();
|
|
|
+ var legend_right_spaces_count = text.Reverse ().TakeWhile (e => e == ' ').Count ();
|
|
|
+ text = text.Trim ();
|
|
|
+
|
|
|
+ // TODO(jmperricone): Improve the Orientation check.
|
|
|
+
|
|
|
+ // Calculate Start Spacing
|
|
|
+ if (_config._sliderOrientation == _config._legendsOrientation) {
|
|
|
+ if (i == 0) {
|
|
|
+ // The spacing for the slider use the StartSpacing but...
|
|
|
+ // The spacing for the legends is the StartSpacing MINUS the total chars to the left of the first options.
|
|
|
+ // ●────●────●
|
|
|
+ // Hello Bye World
|
|
|
+ //
|
|
|
+ // chars_left is 2 for Hello => (5 - 1) / 2
|
|
|
+ //
|
|
|
+ // then the spacing is 2 for the slider but 0 for the legends.
|
|
|
+
|
|
|
+ var chars_left = (text.Length - 1) / 2;
|
|
|
+ legend_left_spaces_count = _config._startSpacing - chars_left;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Option Left Spacing
|
|
|
+ if (isTextVertical) y += legend_left_spaces_count;
|
|
|
+ else x += legend_left_spaces_count;
|
|
|
+ //Move (x, y);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Legend
|
|
|
+ Driver.SetAttribute (isOptionSet ? setScheme : normalScheme);
|
|
|
+ foreach (var c in text.EnumerateRunes ()) {
|
|
|
+ MoveAndAdd (x, y, c);
|
|
|
+ //Driver.AddRune (c);
|
|
|
+ if (isTextVertical) y += 1;
|
|
|
+ else x += 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Calculate End Spacing
|
|
|
+ if (i == _options.Count () - 1) {
|
|
|
+ // See Start Spacing explanation.
|
|
|
+ var chars_right = text.Length / 2;
|
|
|
+ legend_right_spaces_count = _config._endSpacing - chars_right;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Option Right Spacing of Option
|
|
|
+ Driver.SetAttribute (spaceScheme);
|
|
|
+ if (isTextVertical) y += legend_right_spaces_count;
|
|
|
+ else x += legend_right_spaces_count;
|
|
|
+
|
|
|
+ if (_config._sliderOrientation == Orientation.Horizontal && _config._legendsOrientation == Orientation.Vertical) {
|
|
|
+ x += _config._innerSpacing + 1;
|
|
|
+ } else if (_config._sliderOrientation == Orientation.Vertical && _config._legendsOrientation == Orientation.Horizontal) {
|
|
|
+ y += _config._innerSpacing + 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ #region Keys and Mouse
|
|
|
+
|
|
|
+ // Mouse coordinates of current drag
|
|
|
+ Point? _dragPosition;
|
|
|
+ // Coordinates of where the "move cursor" is drawn (in OnDrawContent)
|
|
|
+ Point? _moveRenderPosition;
|
|
|
+
|
|
|
+ /// <inheritdoc/>
|
|
|
+ public override bool MouseEvent (MouseEvent mouseEvent)
|
|
|
+ {
|
|
|
+ // Note(jmperricone): Maybe we click to focus the cursor, and on next click we set the option.
|
|
|
+ // That will makes OptionFocused Event more relevant.
|
|
|
+ // (tig: I don't think so. Maybe an option if someone really wants it, but for now that
|
|
|
+ // adss to much friction to UI.
|
|
|
+ // TODO(jmperricone): Make Range Type work with mouse.
|
|
|
+
|
|
|
+ if (!(mouseEvent.Flags.HasFlag (MouseFlags.Button1Clicked) ||
|
|
|
+ mouseEvent.Flags.HasFlag (MouseFlags.Button1Pressed) ||
|
|
|
+ mouseEvent.Flags.HasFlag (MouseFlags.ReportMousePosition) ||
|
|
|
+ mouseEvent.Flags.HasFlag (MouseFlags.Button1Released))) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ Point ClampMovePosition (Point position)
|
|
|
+ {
|
|
|
+ int Clamp (int value, int min, int max) => Math.Max (min, Math.Min (max, value));
|
|
|
+
|
|
|
+ if (Orientation == Orientation.Horizontal) {
|
|
|
+ var left = _config._startSpacing;
|
|
|
+ var width = _options.Count + (_options.Count - 1) * _config._innerSpacing;
|
|
|
+ var right = (left + width - 1);
|
|
|
+ var clampedX = Clamp (position.X, left, right);
|
|
|
+ position = new Point (clampedX, 0);
|
|
|
+ } else {
|
|
|
+ var top = _config._startSpacing;
|
|
|
+ var height = _options.Count + (_options.Count - 1) * _config._innerSpacing;
|
|
|
+ var bottom = (top + height - 1);
|
|
|
+ var clampedY = Clamp (position.Y, top, bottom);
|
|
|
+ position = new Point (0, clampedY);
|
|
|
+ }
|
|
|
+ return position;
|
|
|
+ }
|
|
|
+
|
|
|
+ SetFocus ();
|
|
|
+
|
|
|
+ if (!_dragPosition.HasValue && (mouseEvent.Flags.HasFlag (MouseFlags.Button1Pressed))) {
|
|
|
+
|
|
|
+ if (mouseEvent.Flags.HasFlag (MouseFlags.ReportMousePosition)) {
|
|
|
+ _dragPosition = new Point (mouseEvent.X, mouseEvent.Y);
|
|
|
+ _moveRenderPosition = ClampMovePosition ((Point)_dragPosition);
|
|
|
+ Application.GrabMouse (this);
|
|
|
+ }
|
|
|
+ SetNeedsDisplay ();
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (_dragPosition.HasValue && mouseEvent.Flags.HasFlag (MouseFlags.ReportMousePosition) && mouseEvent.Flags.HasFlag (MouseFlags.Button1Pressed)) {
|
|
|
+
|
|
|
+ // Continue Drag
|
|
|
+ _dragPosition = new Point (mouseEvent.X, mouseEvent.Y);
|
|
|
+ _moveRenderPosition = ClampMovePosition ((Point)_dragPosition);
|
|
|
+
|
|
|
+ var success = false;
|
|
|
+ var option = 0;
|
|
|
+ // how far has user dragged from original location?
|
|
|
+ if (Orientation == Orientation.Horizontal) {
|
|
|
+ success = TryGetOptionByPosition (mouseEvent.X, 0, Math.Max (0, _config._innerSpacing / 2), out option);
|
|
|
+ } else {
|
|
|
+ success = TryGetOptionByPosition (0, mouseEvent.Y, Math.Max (0, _config._innerSpacing / 2), out option);
|
|
|
+ }
|
|
|
+ if (!_config._allowEmpty && success) {
|
|
|
+ if (!OnOptionFocused (option, new SliderEventArgs<T> (GetSetOptionDictionary (), FocusedOption))) {
|
|
|
+ SetFocusedOption ();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ SetNeedsDisplay ();
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if ((_dragPosition.HasValue && mouseEvent.Flags.HasFlag (MouseFlags.Button1Released)) || mouseEvent.Flags.HasFlag (MouseFlags.Button1Clicked)) {
|
|
|
+
|
|
|
+ // End Drag
|
|
|
+ Application.UngrabMouse ();
|
|
|
+ _dragPosition = null;
|
|
|
+ _moveRenderPosition = null;
|
|
|
+
|
|
|
+ // TODO: Add func to calc distance between options to use as the MouseClickXOptionThreshold
|
|
|
+ var success = false;
|
|
|
+ var option = 0;
|
|
|
+ if (Orientation == Orientation.Horizontal) {
|
|
|
+ success = TryGetOptionByPosition (mouseEvent.X, 0, Math.Max (0, _config._innerSpacing / 2), out option);
|
|
|
+ } else {
|
|
|
+ success = TryGetOptionByPosition (0, mouseEvent.Y, Math.Max (0, _config._innerSpacing / 2), out option);
|
|
|
+ }
|
|
|
+ if (success) {
|
|
|
+ if (!OnOptionFocused (option, new SliderEventArgs<T> (GetSetOptionDictionary (), FocusedOption))) {
|
|
|
+ SetFocusedOption ();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ SetNeedsDisplay ();
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ void SetCommands ()
|
|
|
+ {
|
|
|
+ AddCommand (Command.Right, () => MovePlus ());
|
|
|
+ AddCommand (Command.LineDown, () => MovePlus ());
|
|
|
+ AddCommand (Command.Left, () => MoveMinus ());
|
|
|
+ AddCommand (Command.LineUp, () => MoveMinus ());
|
|
|
+ AddCommand (Command.LeftHome, () => MoveStart ());
|
|
|
+ AddCommand (Command.RightEnd, () => MoveEnd ());
|
|
|
+ AddCommand (Command.RightExtend, () => ExtendPlus ());
|
|
|
+ AddCommand (Command.LeftExtend, () => ExtendMinus ());
|
|
|
+ AddCommand (Command.Accept, () => Set ());
|
|
|
+
|
|
|
+ SetKeyBindings ();
|
|
|
+ }
|
|
|
+
|
|
|
+ // This is called during initialization and anytime orientation changes
|
|
|
+ void SetKeyBindings ()
|
|
|
+ {
|
|
|
+ if (_config._sliderOrientation == Orientation.Horizontal) {
|
|
|
+ AddKeyBinding (Key.CursorRight, Command.Right);
|
|
|
+ ClearKeyBinding (Key.CursorDown);
|
|
|
+ AddKeyBinding (Key.CursorLeft, Command.Left);
|
|
|
+ ClearKeyBinding (Key.CursorUp);
|
|
|
+
|
|
|
+ AddKeyBinding (Key.CursorRight | Key.CtrlMask, Command.RightExtend);
|
|
|
+ ClearKeyBinding (Key.CursorDown | Key.CtrlMask);
|
|
|
+ AddKeyBinding (Key.CursorLeft | Key.CtrlMask, Command.LeftExtend);
|
|
|
+ ClearKeyBinding (Key.CursorUp | Key.CtrlMask);
|
|
|
+ } else {
|
|
|
+ ClearKeyBinding (Key.CursorRight);
|
|
|
+ AddKeyBinding (Key.CursorDown, Command.LineDown);
|
|
|
+ ClearKeyBinding (Key.CursorLeft);
|
|
|
+ AddKeyBinding (Key.CursorUp, Command.LineUp);
|
|
|
+
|
|
|
+ ClearKeyBinding (Key.CursorRight | Key.CtrlMask);
|
|
|
+ AddKeyBinding (Key.CursorDown | Key.CtrlMask, Command.RightExtend);
|
|
|
+ ClearKeyBinding (Key.CursorLeft | Key.CtrlMask);
|
|
|
+ AddKeyBinding (Key.CursorUp | Key.CtrlMask, Command.LeftExtend);
|
|
|
+
|
|
|
+ }
|
|
|
+ AddKeyBinding (Key.Home, Command.LeftHome);
|
|
|
+ AddKeyBinding (Key.End, Command.RightEnd);
|
|
|
+ AddKeyBinding (Key.Enter, Command.Accept);
|
|
|
+ AddKeyBinding (Key.Space, Command.Accept);
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <inheritdoc/>
|
|
|
+ public override bool ProcessKey (KeyEvent keyEvent)
|
|
|
+ {
|
|
|
+ if (!CanFocus || !HasFocus) {
|
|
|
+ return base.ProcessKey (keyEvent);
|
|
|
+ }
|
|
|
+
|
|
|
+ var result = InvokeKeybindings (keyEvent);
|
|
|
+ if (result != null) {
|
|
|
+ return (bool)result;
|
|
|
+ }
|
|
|
+ return base.ProcessKey (keyEvent);
|
|
|
+ }
|
|
|
+
|
|
|
+ Dictionary<int, SliderOption<T>> GetSetOptionDictionary () => _setOptions.ToDictionary (e => e, e => _options [e]);
|
|
|
+
|
|
|
+ void SetFocusedOption ()
|
|
|
+ {
|
|
|
+ switch (_config._type) {
|
|
|
+ case SliderType.Single:
|
|
|
+ case SliderType.LeftRange:
|
|
|
+ case SliderType.RightRange:
|
|
|
+
|
|
|
+ if (_setOptions.Count == 1) {
|
|
|
+ var prev = _setOptions [0];
|
|
|
+
|
|
|
+ if (!_config._allowEmpty && prev == FocusedOption) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ _setOptions.Clear ();
|
|
|
+ _options [FocusedOption].OnUnSet ();
|
|
|
+
|
|
|
+ if (FocusedOption != prev) {
|
|
|
+ _setOptions.Add (FocusedOption);
|
|
|
+ _options [FocusedOption].OnSet ();
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ _setOptions.Add (FocusedOption);
|
|
|
+ _options [FocusedOption].OnSet ();
|
|
|
+ }
|
|
|
+
|
|
|
+ // Raise slider changed event.
|
|
|
+ OnOptionsChanged ();
|
|
|
+
|
|
|
+ break;
|
|
|
+ case SliderType.Multiple:
|
|
|
+ if (_setOptions.Contains (FocusedOption)) {
|
|
|
+ if (!_config._allowEmpty && _setOptions.Count () == 1) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ _setOptions.Remove (FocusedOption);
|
|
|
+ _options [FocusedOption].OnUnSet ();
|
|
|
+ } else {
|
|
|
+ _setOptions.Add (FocusedOption);
|
|
|
+ _options [FocusedOption].OnSet ();
|
|
|
+ }
|
|
|
+ OnOptionsChanged ();
|
|
|
+ break;
|
|
|
+
|
|
|
+ case SliderType.Range:
|
|
|
+ if (_config._rangeAllowSingle) {
|
|
|
+ if (_setOptions.Count == 1) {
|
|
|
+ var prev = _setOptions [0];
|
|
|
+
|
|
|
+ if (!_config._allowEmpty && prev == FocusedOption) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if (FocusedOption == prev) {
|
|
|
+ // un-set
|
|
|
+ _setOptions.Clear ();
|
|
|
+ _options [FocusedOption].OnUnSet ();
|
|
|
+ } else {
|
|
|
+ _setOptions [0] = FocusedOption;
|
|
|
+ _setOptions.Add (prev);
|
|
|
+ _setOptions.Sort ();
|
|
|
+ _options [FocusedOption].OnSet ();
|
|
|
+ }
|
|
|
+ } else if (_setOptions.Count == 0) {
|
|
|
+ _setOptions.Add (FocusedOption);
|
|
|
+ _options [FocusedOption].OnSet ();
|
|
|
+ } else {
|
|
|
+ // Extend/Shrink
|
|
|
+ if (FocusedOption < _setOptions [0]) {
|
|
|
+ // extend left
|
|
|
+ _options [_setOptions [0]].OnUnSet ();
|
|
|
+ _setOptions [0] = FocusedOption;
|
|
|
+ } else if (FocusedOption > _setOptions [1]) {
|
|
|
+ // extend right
|
|
|
+ _options [_setOptions [1]].OnUnSet ();
|
|
|
+ _setOptions [1] = FocusedOption;
|
|
|
+ } else if (FocusedOption >= _setOptions [0] && FocusedOption <= _setOptions [1]) {
|
|
|
+ if (FocusedOption < _lastFocusedOption) {
|
|
|
+ // shrink to the left
|
|
|
+ _options [_setOptions [1]].OnUnSet ();
|
|
|
+ _setOptions [1] = FocusedOption;
|
|
|
+
|
|
|
+ } else if (FocusedOption > _lastFocusedOption) {
|
|
|
+ // shrink to the right
|
|
|
+ _options [_setOptions [0]].OnUnSet ();
|
|
|
+ _setOptions [0] = FocusedOption;
|
|
|
+ }
|
|
|
+ if (_setOptions.Count > 1 && _setOptions [0] == _setOptions [1]) {
|
|
|
+ _setOptions.Clear ();
|
|
|
+ _setOptions.Add (FocusedOption);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if (_setOptions.Count == 1) {
|
|
|
+ var prev = _setOptions [0];
|
|
|
+
|
|
|
+ if (!_config._allowEmpty && prev == FocusedOption) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ _setOptions [0] = FocusedOption;
|
|
|
+ _setOptions.Add (prev);
|
|
|
+ _setOptions.Sort ();
|
|
|
+ _options [FocusedOption].OnSet ();
|
|
|
+ } else if (_setOptions.Count == 0) {
|
|
|
+ _setOptions.Add (FocusedOption);
|
|
|
+ _options [FocusedOption].OnSet ();
|
|
|
+ var next = FocusedOption < _options.Count - 1 ? FocusedOption + 1 : FocusedOption - 1;
|
|
|
+ _setOptions.Add (next);
|
|
|
+ _options [next].OnSet ();
|
|
|
+ } else {
|
|
|
+ // Extend/Shrink
|
|
|
+ if (FocusedOption < _setOptions [0]) {
|
|
|
+ // extend left
|
|
|
+ _options [_setOptions [0]].OnUnSet ();
|
|
|
+ _setOptions [0] = FocusedOption;
|
|
|
+ } else if (FocusedOption > _setOptions [1]) {
|
|
|
+ // extend right
|
|
|
+ _options [_setOptions [1]].OnUnSet ();
|
|
|
+ _setOptions [1] = FocusedOption;
|
|
|
+ } else if (FocusedOption >= _setOptions [0] && FocusedOption <= _setOptions [1] && (_setOptions [1] - _setOptions [0] > 1)) {
|
|
|
+ if (FocusedOption < _lastFocusedOption) {
|
|
|
+ // shrink to the left
|
|
|
+ _options [_setOptions [1]].OnUnSet ();
|
|
|
+ _setOptions [1] = FocusedOption;
|
|
|
+
|
|
|
+ } else if (FocusedOption > _lastFocusedOption) {
|
|
|
+ // shrink to the right
|
|
|
+ _options [_setOptions [0]].OnUnSet ();
|
|
|
+ _setOptions [0] = FocusedOption;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ //if (_setOptions.Count > 1 && _setOptions [0] == _setOptions [1]) {
|
|
|
+ // SetFocusedOption ();
|
|
|
+ //}
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Raise Slider Option Changed Event.
|
|
|
+ OnOptionsChanged ();
|
|
|
+
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ throw new ArgumentOutOfRangeException (_config._type.ToString ());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ internal bool ExtendPlus ()
|
|
|
+ {
|
|
|
+ var next = FocusedOption < _options.Count - 1 ? FocusedOption + 1 : FocusedOption;
|
|
|
+ if (next != FocusedOption && !OnOptionFocused (next, new SliderEventArgs<T> (GetSetOptionDictionary (), FocusedOption))) {
|
|
|
+ SetFocusedOption ();
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+
|
|
|
+ //// TODO: Support RangeMultiple
|
|
|
+ //if (_setOptions.Contains (FocusedOption)) {
|
|
|
+ // var next = FocusedOption < _options.Count - 1 ? FocusedOption + 1 : FocusedOption;
|
|
|
+ // if (!_setOptions.Contains (next)) {
|
|
|
+ // if (_config._type == SliderType.Range) {
|
|
|
+ // if (_setOptions.Count == 1) {
|
|
|
+ // if (!OnOptionFocused (next, new SliderEventArgs<T> (GetSetOptionDictionary (), FocusedOption))) {
|
|
|
+ // _setOptions.Add (FocusedOption);
|
|
|
+ // _setOptions.Sort (); // Range Type
|
|
|
+ // OnOptionsChanged ();
|
|
|
+ // }
|
|
|
+ // } else if (_setOptions.Count == 2) {
|
|
|
+ // if (!OnOptionFocused (next, new SliderEventArgs<T> (GetSetOptionDictionary (), FocusedOption))) {
|
|
|
+ // _setOptions [1] = FocusedOption;
|
|
|
+ // _setOptions.Sort (); // Range Type
|
|
|
+ // OnOptionsChanged ();
|
|
|
+ // }
|
|
|
+ // }
|
|
|
+ // } else {
|
|
|
+ // _setOptions.Remove (FocusedOption);
|
|
|
+ // // Note(jmperricone): We are setting the option here, do we send the OptionFocused Event too ?
|
|
|
+
|
|
|
+
|
|
|
+ // if (!OnOptionFocused (next, new SliderEventArgs<T> (GetSetOptionDictionary (), FocusedOption))) {
|
|
|
+ // _setOptions.Add (FocusedOption);
|
|
|
+ // _setOptions.Sort (); // Range Type
|
|
|
+ // OnOptionsChanged ();
|
|
|
+ // }
|
|
|
+ // }
|
|
|
+ // } else {
|
|
|
+ // if (_config._type == SliderType.Range) {
|
|
|
+ // if (!OnOptionFocused (next, new SliderEventArgs<T> (GetSetOptionDictionary (), FocusedOption))) {
|
|
|
+ // _setOptions.Clear();
|
|
|
+ // _setOptions.Add (FocusedOption);
|
|
|
+ // OnOptionsChanged ();
|
|
|
+ // }
|
|
|
+ // } else if (/*_settingRange == true ||*/ !AllowEmpty) {
|
|
|
+ // SetFocusedOption ();
|
|
|
+ // }
|
|
|
+ // }
|
|
|
+ //}
|
|
|
+ //return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ internal bool ExtendMinus ()
|
|
|
+ {
|
|
|
+ var prev = FocusedOption > 0 ? FocusedOption - 1 : FocusedOption;
|
|
|
+ if (prev != FocusedOption && !OnOptionFocused (prev, new SliderEventArgs<T> (GetSetOptionDictionary (), FocusedOption))) {
|
|
|
+ SetFocusedOption ();
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ internal bool Set ()
|
|
|
+ {
|
|
|
+ SetFocusedOption ();
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ internal bool MovePlus ()
|
|
|
+ {
|
|
|
+ var cancelled = OnOptionFocused (FocusedOption + 1, new SliderEventArgs<T> (GetSetOptionDictionary (), FocusedOption));
|
|
|
+ if (cancelled) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!AllowEmpty) {
|
|
|
+ SetFocusedOption ();
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ internal bool MoveMinus ()
|
|
|
+ {
|
|
|
+ var cancelled = OnOptionFocused (FocusedOption - 1, new SliderEventArgs<T> (GetSetOptionDictionary (), FocusedOption));
|
|
|
+ if (cancelled) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!AllowEmpty) {
|
|
|
+ SetFocusedOption ();
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ internal bool MoveStart ()
|
|
|
+ {
|
|
|
+ if (OnOptionFocused (0, new SliderEventArgs<T> (GetSetOptionDictionary (), FocusedOption))) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!AllowEmpty) {
|
|
|
+ SetFocusedOption ();
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ internal bool MoveEnd ()
|
|
|
+ {
|
|
|
+ if (OnOptionFocused (_options.Count - 1, new SliderEventArgs<T> (GetSetOptionDictionary (), FocusedOption))) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!AllowEmpty) {
|
|
|
+ SetFocusedOption ();
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ #endregion
|
|
|
+}
|
Tig Kindel