Beispiel #1
0
        public void OnEscapeSequence(EscapeCommand command, ReadOnlySpan <byte> intermediates, IgnoredData ignored = default)
        {
            int index;

            switch (command)
            {
            case EscapeCommand.ConfigureAsciiCharSet:
                if (intermediates.Length > 0 &&
                    TryParseCharSetIndex(intermediates[0], out index))
                {
                    _activeCharSets[index] = CharSet.Ascii;
                }
                break;

            case EscapeCommand.ConfigureSpecialCharSet:
                if (intermediates.Length > 0 &&
                    TryParseCharSetIndex(intermediates[0], out index))
                {
                    _activeCharSets[index] = CharSet.SpecialCharacterAndLineDrawing;
                }
                break;

            case EscapeCommand.LineFeed:
                _events.LineFeed?.Invoke();
                break;

            case EscapeCommand.NextLine:
                _events.LineFeed?.Invoke();
                _events.CarriageReturn?.Invoke();
                break;

            case EscapeCommand.ReverseIndex:
                _events.ReverseIndex?.Invoke();
                break;

            case EscapeCommand.IdentifyTerminal:
                _events.IdentifyTerminal?.Invoke();
                break;

            case EscapeCommand.ResetState:
                _events.ResetState?.Invoke();
                break;

            case EscapeCommand.SaveCursorPosition:
                _events.SaveCursorPosition?.Invoke();
                break;

            case EscapeCommand.DecTest when(intermediates.Length != 0 && intermediates[0] == '#'):
                _events.DecTest?.Invoke();

                break;

            case EscapeCommand.RestoreCursorPosition when(intermediates.Length == 0 || intermediates[0] != '#'):
                _events.RestoreCursorPosition?.Invoke();

                break;

            case EscapeCommand.SetKeypadApplicationMode:
                _events.SetKeypadApplicationMode?.Invoke();
                break;

            case EscapeCommand.UnsetKeypadApplicationMode:
                _events.UnsetKeypadApplicationMode?.Invoke();
                break;
            }
        }
Beispiel #2
0
        public void OnControlSequenceCommand(ControlSequenceCommand command, ReadOnlySpan <byte> intermediates, ReadOnlySpan <long> parameters, IgnoredData ignored = default)
        {
            var priv = intermediates.Optional(0).GetValueOrDefault(0) == '?';

            long?row, column;

            switch (command)
            {
            case ControlSequenceCommand.InsertBlank:
                _events.InsertBlank?.Invoke(parameters.Optional(0).GetValueOrDefault(1));
                break;

            case ControlSequenceCommand.MoveUp:
                _events.MoveUp?.Invoke(parameters.Optional(0).GetValueOrDefault(1), false);
                break;

            case ControlSequenceCommand.RepeatPrecedingCharacter:
                if (_precedingChar.HasValue)
                {
                    var count = parameters.Optional(0).GetValueOrDefault(1);
                    var c     = _precedingChar.Value;
                    ReadOnlySpan <char> chr = MapCharacters(MemoryMarshal.CreateReadOnlySpan(ref c, 1));
                    for (var i = 0; i < count; i++)
                    {
                        _events.Input?.Invoke(chr);
                    }
                }
                break;

            case ControlSequenceCommand.MoveDown1:
            case ControlSequenceCommand.MoveDown2:
                _events.MoveDown?.Invoke(parameters.Optional(0).GetValueOrDefault(1), false);
                break;

            case ControlSequenceCommand.IdentifyTerminal:
                _events.IdentifyTerminal?.Invoke();
                break;

            case ControlSequenceCommand.MoveForward1:
            case ControlSequenceCommand.MoveForward2:
                _events.MoveForward?.Invoke(parameters.Optional(0).GetValueOrDefault(1), false);
                break;

            case ControlSequenceCommand.MoveBackward:
                _events.MoveBackward?.Invoke(parameters.Optional(0).GetValueOrDefault(1), false);
                break;

            case ControlSequenceCommand.MoveDownAndCr:
                _events.MoveDown?.Invoke(parameters.Optional(0).GetValueOrDefault(1), true);
                break;

            case ControlSequenceCommand.MoveUpAndCr:
                _events.MoveUp?.Invoke(parameters.Optional(0).GetValueOrDefault(1), true);
                break;

            case ControlSequenceCommand.ClearTabulation:
                var tabClearMode = (TabulationClearMode)parameters.Optional(0).GetValueOrDefault(0);
                _events.ClearTabulation?.Invoke(tabClearMode);
                break;

            case ControlSequenceCommand.GotoColumn1:
            case ControlSequenceCommand.GotoColumn2:
                column = parameters.Optional(0).GetValueOrDefault(1) - 1;
                _events.Goto?.Invoke(column: column);
                break;

            case ControlSequenceCommand.Goto1:
            case ControlSequenceCommand.Goto2:
                column = parameters.Optional(0).GetValueOrDefault(1) - 1;
                row    = parameters.Optional(1).GetValueOrDefault(1) - 1;
                _events.Goto?.Invoke(column, row);
                break;

            case ControlSequenceCommand.MoveForwardTabs:
                _events.MoveForward?.Invoke(parameters.Optional(0).GetValueOrDefault(1), true);
                break;

            case ControlSequenceCommand.ClearScreen:
                var clearScreenMode = (ClearMode)parameters.Optional(0).GetValueOrDefault(0);
                _events.ClearScreen?.Invoke(clearScreenMode);
                break;

            case ControlSequenceCommand.ClearLine:
                var clearLineMode = (LineClearMode)parameters.Optional(0).GetValueOrDefault(0);
                _events.ClearLine?.Invoke(clearLineMode);
                break;

            case ControlSequenceCommand.ScrollUp:
                _events.ScrollUp?.Invoke(parameters.Optional(0).GetValueOrDefault(1));
                break;

            case ControlSequenceCommand.ScrollDown:
                _events.ScrollDown?.Invoke(parameters.Optional(0).GetValueOrDefault(1));
                break;

            case ControlSequenceCommand.InsertBlankLines:
                _events.InsertBlankLines?.Invoke(parameters.Optional(0).GetValueOrDefault(1));
                break;

            case ControlSequenceCommand.UnsetMode:
                for (var i = 0; i < parameters.Length; i++)
                {
                    _events.UnsetMode?.Invoke((Mode)parameters[i]);
                }
                break;

            case ControlSequenceCommand.DeleteLines:
                _events.DeleteLines?.Invoke(parameters.Optional(0).GetValueOrDefault(1));
                break;

            case ControlSequenceCommand.EraseChars:
                _events.EraseCharacters?.Invoke(parameters.Optional(0).GetValueOrDefault(1));
                break;

            case ControlSequenceCommand.DeleteChars:
                _events.DeleteCharacters?.Invoke(parameters.Optional(0).GetValueOrDefault(1));
                break;

            case ControlSequenceCommand.MoveBackwardTabs:
                _events.MoveBackward?.Invoke(parameters.Optional(0).GetValueOrDefault(1), true);
                break;

            case ControlSequenceCommand.GotoLine:
                _events.Goto?.Invoke(line: parameters.Optional(0).GetValueOrDefault(1) - 1);
                break;

            case ControlSequenceCommand.SetMode:
                for (var i = 0; i < parameters.Length; i++)
                {
                    _events.SetMode?.Invoke((Mode)parameters[i]);
                }
                break;

            case ControlSequenceCommand.TerminalAttribute:
                if (parameters.Length == 0)
                {
                    _events.TerminalAttribute?.Invoke(
                        TerminalAttribute.Reset);
                    break;
                }

                for (var i = 0; i < parameters.Length; i++)
                {
                    var index = parameters[i];

                    if (index < 30)
                    {
                        _events.TerminalAttribute?.Invoke(
                            (TerminalAttribute)index);
                        continue;
                    }

                    if (index == 38 || index == 48)
                    {
                        var consumed = TryParseColor(parameters.Slice(i), out NamedColor? ix, out Color? color);
                        if (consumed == 0)
                        {
                            break;
                        }
                        _events.TerminalAttribute?.Invoke(
                            (TerminalAttribute)index, index: ix, color: color);
                        i += consumed;
                        continue;
                    }

                    if (index == 39)
                    {
                        _events.TerminalAttribute?.Invoke(
                            TerminalAttribute.SetForeground, index: NamedColor.Foreground);
                        continue;
                    }

                    if (index < 40)
                    {
                        var ix = (NamedColor)(index - 30);
                        _events.TerminalAttribute?.Invoke(
                            TerminalAttribute.SetForeground, index: ix);
                        continue;
                    }

                    if (index == 49)
                    {
                        _events.TerminalAttribute?.Invoke(
                            TerminalAttribute.SetBackground, index: NamedColor.Background);
                        continue;
                    }

                    if (index < 50)
                    {
                        var ix = (NamedColor)(index - 40);
                        _events.TerminalAttribute?.Invoke(
                            TerminalAttribute.SetForeground, index: ix);
                        continue;
                    }

                    if (index < 90)
                    {
                        continue;
                    }

                    if (index < 100)
                    {
                        var ix = (NamedColor)(index - 90 + (int)NamedColor.BrightBlack);
                        _events.TerminalAttribute?.Invoke(
                            TerminalAttribute.SetForeground, index: ix);
                        continue;
                    }

                    if (index < 108)
                    {
                        var ix = (NamedColor)(index - 100 + (int)NamedColor.BrightBlack);
                        _events.TerminalAttribute?.Invoke(
                            TerminalAttribute.SetBackground, index: ix);
                        continue;
                    }
                }
                break;

            case ControlSequenceCommand.DeviceStatus:
                _events.DeviceStatus?.Invoke(parameters.Optional(0).GetValueOrDefault(0));
                break;

            case ControlSequenceCommand.SetScrollingRegion:
                if (priv)
                {
                    break;
                }
                _events.SetScrollingRegion?.Invoke(
                    parameters.Optional(0) - 1,
                    parameters.Optional(1) - 1);
                break;

            case ControlSequenceCommand.SaveCursorPosition:
                _events.SaveCursorPosition?.Invoke();
                break;

            case ControlSequenceCommand.RestoreCursorPosition:
                _events.RestoreCursorPosition?.Invoke();
                break;

            case ControlSequenceCommand.SetCursorStyle:
                switch (parameters.Optional(0).GetValueOrDefault(0))
                {
                case 0: _events.SetCursorStyle?.Invoke(default); break;

                case 1:
                case 2: _events.SetCursorStyle?.Invoke(CursorStyle.Block); break;

                case 3:
                case 4: _events.SetCursorStyle?.Invoke(CursorStyle.Underline); break;

                case 5:
                case 6: _events.SetCursorStyle?.Invoke(CursorStyle.Beam); break;
                }
                break;
            }
        }
Beispiel #3
0
        public void OnOsCommand(OsCommand command, ReadOnlySpan <ReadOnlyMemory <byte> > parameters, IgnoredData ignored = default)
        {
            Color color;
            ReadOnlySpan <char> characters;

            switch (command)
            {
            case OsCommand.SetWindowIconAndTitle:
            case OsCommand.SetWindowTitle:
                // Set window title.
                if (parameters.Length > 0 &&
                    _utf8(parameters[0].Span, out characters))
                {
                    _events.SetTitle?.Invoke(characters);
                }
                break;

            case OsCommand.SetWindowIcon: break;

            case OsCommand.SetColor:
                // Set color index.
                if (parameters.Length % 2 != 0)
                {
                    break;
                }
                for (var i = 0; i < parameters.Length; i += 2)
                {
                    if (TryParseByte(parameters[i].Span, out var index) &&
                        TryParseColor(parameters[i + 1].Span, out color))
                    {
                        _events.SetColor?.Invoke((NamedColor)index, color);
                    }
                }
                break;

            case OsCommand.SetForegroundColor:
                if (parameters.Length > 0 &&
                    TryParseColor(parameters[0].Span, out color))
                {
                    _events.SetColor?.Invoke(NamedColor.Foreground, color);
                }
                break;

            case OsCommand.SetBackgroundColor:
                if (parameters.Length > 0 &&
                    TryParseColor(parameters[0].Span, out color))
                {
                    _events.SetColor?.Invoke(NamedColor.Background, color);
                }
                break;

            case OsCommand.SetCursorColor:
                if (parameters.Length > 0 &&
                    TryParseColor(parameters[0].Span, out color))
                {
                    _events.SetColor?.Invoke(NamedColor.Cursor, color);
                }
                break;

            case OsCommand.SetCursorStyle:
                if (parameters.Length > 0 && parameters[0].Length > _cursorShape.Length &&
                    parameters[0].Span.Slice(0, _cursorShape.Length).SequenceEqual(_cursorShape))
                {
                    switch ((CursorStyle)(parameters[0].Span[12] - (byte)'0'))
                    {
                    case CursorStyle.Beam:
                        _events.SetCursor?.Invoke(CursorStyle.Beam);
                        break;

                    case CursorStyle.Block:
                        _events.SetCursor?.Invoke(CursorStyle.Block);
                        break;

                    case CursorStyle.Underline:
                        _events.SetCursor?.Invoke(CursorStyle.Underline);
                        break;
                    }
                }
                break;

            case OsCommand.SetClipboard:
                if (parameters.Length > 1 &&
                    (parameters[1].Length == 0 || parameters[1].Span[0] != '?') &&
                    TryParseBase64(parameters[1].Span, out ReadOnlySpan <byte> base64) &&
                    _utf8(base64, out characters))
                {
                    _events.SetClipboard?.Invoke(characters);
                }
                break;

            case OsCommand.ResetColor:
                if (parameters.Length == 0)
                {
                    for (var i = 0; i < 257; i++)
                    {
                        _events.ResetColor?.Invoke((NamedColor)i);
                    }
                    break;
                }

                for (var i = 0; i < parameters.Length; i++)
                {
                    if (TryParseByte(parameters[i].Span, out var index))
                    {
                        _events.ResetColor?.Invoke((NamedColor)index);
                    }
                }
                break;

            case OsCommand.ResetForegroundColor:
                _events.ResetColor?.Invoke(NamedColor.Foreground);
                break;

            case OsCommand.ResetBackgroundColor:
                _events.ResetColor?.Invoke(NamedColor.Background);
                break;

            case OsCommand.ResetCursorColor:
                _events.ResetColor?.Invoke(NamedColor.Cursor);
                break;
            }
        }