ConsoleGui.cs

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;

using Microsoft.PowerShell.ConsoleGuiTools.Models;

using Terminal.Gui;

namespace Microsoft.PowerShell.ConsoleGuiTools
{

    internal sealed class ConsoleGui : IDisposable
    {
        private const string FILTER_LABEL = "Filter";
        // This adjusts the left margin of all controls
        private const int MARGIN_LEFT = 1;
        // Width of Terminal.Gui ListView selection/check UI elements (old == 4, new == 2)
        private const int CHECK_WIDTH = 2;
        private bool _cancelled;
        private Label _filterLabel;
        private TextField _filterField;
        private ListView _listView;
        // _inputSource contains the full set of Input data and tracks any items the user
        // marks. When the cmdlet exits, any marked items are returned. When a filter is 
        // active, the list view shows a copy of _inputSource that includes both the items
        // matching the filter AND any items previously marked. 
        private GridViewDataSource _inputSource;

        // _listViewSource is a filtered copy of _inputSource that ListView.Source is set to. 
        // Changes to IsMarked are propagated back to _inputSource.
        private GridViewDataSource _listViewSource;
        private ApplicationData _applicationData;

        public IEnumerable<int> Start(ApplicationData applicationData)
        {
            _applicationData = applicationData;
            // Note, in Terminal.Gui v2, this property is renamed to Application.UseNetDriver, hence
            // using that terminology here.
            Application.UseSystemConsole = _applicationData.UseNetDriver;
            Application.Init();

            var (gridViewHeader, gridViewDataSource) = GridViewHelpers.CreateGridViewInputs(
                // If OutputMode is Single or Multiple, then we make items selectable. If we make them selectable,
                // 2 columns are required for the check/selection indicator and space.
                listViewOffset: _applicationData.OutputMode != OutputModeOption.None ? MARGIN_LEFT + CHECK_WIDTH : MARGIN_LEFT,
                applicationData: _applicationData,
                properties: _applicationData.Properties,
                leftMargin: MARGIN_LEFT
                );

            Window win = CreateTopLevelWindow();

            // Copy the input DataTable into our master ListView source list; upon exit any items
            // that are IsMarked are returned (if Outputmode is set)
            _inputSource = gridViewDataSource;

            if (!_applicationData.MinUI)
            {
                // Add Filter UI
                AddFilter(win);
                // Add Header UI
                AddHeaders(win, gridViewHeader);
            }

            // Add ListView
            AddListView(win);

            // Status bar is where our key-bindings are handled
            AddStatusBar(!_applicationData.MinUI);

            // We *always* apply a filter, even if the -Filter parameter is not set or Filtering is not
            // available. The ListView always shows a filtered version of _inputSource even if there is no
            // actual filter. 
            ApplyFilter();

            _listView.SetFocus();

            // Run the GUI.
            Application.Run();
            Application.Shutdown();

            // Return results of selection if required.            
            if (_cancelled)
            {
                return Enumerable.Empty<int>();
            }

            // Return any items that were selected.
            return _inputSource.GridViewRowList
                .Where(gvr => gvr.IsMarked)
                .Select(gvr => gvr.OriginalIndex);
        }

        private void ApplyFilter()
        {
            // The ListView is always filled with a (filtered) copy of _inputSource.
            // We listen for `MarkChanged` events on this filtered list and apply those changes up to _inputSource.

            if (_listViewSource != null)
            {
                _listViewSource.MarkChanged -= ListViewSource_MarkChanged;
                _listViewSource = null;
            }

            _listViewSource = new GridViewDataSource(GridViewHelpers.FilterData(_inputSource.GridViewRowList, _applicationData.Filter ?? string.Empty));
            _listViewSource.MarkChanged += ListViewSource_MarkChanged;
            _listView.Source = _listViewSource;
        }

        private void ListViewSource_MarkChanged(object s, GridViewDataSource.RowMarkedEventArgs a)
        {
            _inputSource.GridViewRowList[a.Row.OriginalIndex].IsMarked = a.Row.IsMarked;
        }

        private static void Accept()
        {
            Application.RequestStop();
        }

        private void Close()
        {
            _cancelled = true;
            Application.RequestStop();
        }

        private Window CreateTopLevelWindow()
        {
            // Creates the top-level window to show
            var win = new Window(_applicationData.Title)
            {
                X = _applicationData.MinUI ? -1 : 0,
                Y = _applicationData.MinUI ? -1 : 0,

                // By using Dim.Fill(), it will automatically resize without manual intervention
                Width = Dim.Fill(_applicationData.MinUI ? -1 : 0),
                Height = Dim.Fill(_applicationData.MinUI ? -1 : 1)
            };

            if (_applicationData.MinUI)
            {
                win.Border.BorderStyle = BorderStyle.None;
            }

            Application.Top.Add(win);
            return win;
        }

        private void AddStatusBar(bool visible)
        {
            var statusItems = new List<StatusItem>();
            if (_applicationData.OutputMode != OutputModeOption.None)
            {
                // Use Key.Unknown for SPACE with no delegate because ListView already
                // handles SPACE
                statusItems.Add(new StatusItem(Key.Unknown, "~SPACE~ Select Item", null));
            }

            if (_applicationData.OutputMode == OutputModeOption.Multiple)
            {
                statusItems.Add(new StatusItem(Key.A | Key.CtrlMask, "~CTRL-A~ Select All", () =>
                {
                    // This selects only the items that match the Filter
                    var gvds = _listView.Source as GridViewDataSource;
                    gvds.GridViewRowList.ForEach(i => i.IsMarked = true);
                    _listView.SetNeedsDisplay();
                }));

                // Ctrl-D is commonly used in GUIs for select-none 
                statusItems.Add(new StatusItem(Key.D | Key.CtrlMask, "~CTRL-D~ Select None", () =>
                {
                    // This un-selects only the items that match the Filter
                    var gvds = _listView.Source as GridViewDataSource;
                    gvds.GridViewRowList.ForEach(i => i.IsMarked = false);
                    _listView.SetNeedsDisplay();
                }));
            }

            if (_applicationData.OutputMode != OutputModeOption.None)
            {
                statusItems.Add(new StatusItem(Key.Enter, "~ENTER~ Accept", () =>
                {
                    if (Application.Top.MostFocused == _listView)
                    {
                        // If nothing was explicitly marked, we return the item that was selected
                        // when ENTER is pressed in Single mode. If something was previously selected
                        // (using SPACE) then honor that as the single item to return
                        if (_applicationData.OutputMode == OutputModeOption.Single &&
                            _inputSource.GridViewRowList.Find(i => i.IsMarked) == null)
                        {
                            _listView.MarkUnmarkRow();
                        }
                        Accept();
                    }
                    else if (Application.Top.MostFocused == _filterField)
                    {
                        _listView.SetFocus();
                    }
                }));
            }

            statusItems.Add(new StatusItem(Key.Esc, "~ESC~ Close", () => Close()));
            if (_applicationData.Verbose || _applicationData.Debug)
            {
                statusItems.Add(new StatusItem(Key.Null, $" v{_applicationData.ModuleVersion}", null));
                statusItems.Add(new StatusItem(Key.Null,
                $"{Application.Driver} v{FileVersionInfo.GetVersionInfo(Assembly.GetAssembly(typeof(Application)).Location).ProductVersion}", null));
            }

            var statusBar = new StatusBar(statusItems.ToArray())
            {
                Visible = visible
            };

            Application.Top.Add(statusBar);
        }

        private void AddFilter(Window win)
        {
            _filterLabel = new Label(FILTER_LABEL)
            {
                X = MARGIN_LEFT,
                Y = 0
            };

            _filterField = new TextField(_applicationData.Filter ?? string.Empty)
            {
                X = Pos.Right(_filterLabel) + 1,
                Y = Pos.Top(_filterLabel),
                CanFocus = true,
                Width = Dim.Fill() - 1
            };

            // TextField captures Ctrl-A (select all text) and Ctrl-D (delete backwards)
            // In OCGV these are used for select-all/none of items. Selecting items is more
            // common than editing the filter field so we turn them off in the filter textview. 
            // BACKSPACE still works for delete backwards
            _filterField.ClearKeybinding(Key.A | Key.CtrlMask);
            _filterField.ClearKeybinding(Key.D | Key.CtrlMask);

            var filterErrorLabel = new Label(string.Empty)
            {
                X = Pos.Right(_filterLabel) + 1,
                Y = Pos.Top(_filterLabel) + 1,
                ColorScheme = Colors.Base,
                Width = Dim.Fill() - _filterLabel.Text.Length
            };

            _filterField.TextChanged += (str) =>
            {
                // str is the OLD value
                string filterText = _filterField.Text?.ToString();
                try
                {
                    filterErrorLabel.Text = " ";
                    filterErrorLabel.ColorScheme = Colors.Base;
                    filterErrorLabel.Redraw(filterErrorLabel.Bounds);
                    _applicationData.Filter = filterText;
                    ApplyFilter();

                }
                catch (Exception ex)
                {
                    filterErrorLabel.Text = ex.Message;
                    filterErrorLabel.ColorScheme = Colors.Error;
                    filterErrorLabel.Redraw(filterErrorLabel.Bounds);
                }
            };

            win.Add(_filterLabel, _filterField, filterErrorLabel);

            _filterField.Text = _applicationData.Filter ?? string.Empty;
            _filterField.CursorPosition = _filterField.Text.Length;
        }

        private void AddHeaders(Window win, GridViewHeader gridViewHeader)
        {
            var header = new Label(gridViewHeader.HeaderText)
            {
                X = 0,
                Y = _applicationData.MinUI ? 0 : 2
            };

            win.Add(header);

            if (_applicationData.MinUI)
            {
                return;
            }

            var headerLine = new Label(gridViewHeader.HeaderUnderLine)
            {
                X = 0,
                Y = Pos.Bottom(header)
            };

            win.Add(headerLine);
        }

        private void AddListView(Window win)
        {
            _listView = new ListView(_inputSource);
            _listView.X = MARGIN_LEFT;
            if (!_applicationData.MinUI)
            {
                _listView.Y = Pos.Bottom(_filterLabel) + 3; // 1 for space, 1 for header, 1 for header underline
            }
            else
            {
                _listView.Y = 1; // 1 for space, 1 for header, 1 for header underline
            }
            _listView.Width = Dim.Fill(1);
            _listView.Height = Dim.Fill();
            _listView.AllowsMarking = _applicationData.OutputMode != OutputModeOption.None;
            _listView.AllowsMultipleSelection = _applicationData.OutputMode == OutputModeOption.Multiple;
            _listView.AddKeyBinding(Key.Space, Command.ToggleChecked, Command.LineDown);

            win.Add(_listView);
        }

        public void Dispose()
        {
            if (!Console.IsInputRedirected)
            {
                // By emitting this, we fix two issues:
                // 1. An issue where arrow keys don't work in the console because .NET
                //    requires application mode to support Arrow key escape sequences.
                //    Esc[?1h sets the cursor key to application mode
                //    See http://ascii-table.com/ansi-escape-sequences-vt-100.php
                // 2. An issue where moving the mouse causes characters to show up because
                //    mouse tracking is still on. Esc[?1003l turns it off.
                //    See https://www.xfree86.org/current/ctlseqs.html#Mouse%20Tracking
                Console.Write("\u001b[?1h\u001b[?1003l");
            }
        }
    }
}