2019-05-03 00:29:04 +02:00
|
|
|
/*++
|
|
|
|
|
Copyright (c) Microsoft Corporation
|
|
|
|
|
Licensed under the MIT license.
|
|
|
|
|
|
|
|
|
|
Module Name:
|
|
|
|
|
- outputStream.hpp
|
|
|
|
|
|
|
|
|
|
Abstract:
|
|
|
|
|
- Classes to process text written into the console on the attached application's output stream (usually STDOUT).
|
|
|
|
|
|
|
|
|
|
Author:
|
|
|
|
|
- Michael Niksa <miniksa> July 27 2015
|
|
|
|
|
--*/
|
|
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
|
|
#include "..\terminal\adapter\adaptDefaults.hpp"
|
|
|
|
|
#include "..\types\inc\IInputEvent.hpp"
|
|
|
|
|
#include "..\inc\conattrs.hpp"
|
|
|
|
|
#include "IIoProvider.hpp"
|
|
|
|
|
|
|
|
|
|
class SCREEN_INFORMATION;
|
|
|
|
|
|
|
|
|
|
// The WriteBuffer class provides helpers for writing text into the TextBuffer that is backing a particular console screen buffer.
|
|
|
|
|
class WriteBuffer : public Microsoft::Console::VirtualTerminal::AdaptDefaults
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
WriteBuffer(_In_ Microsoft::Console::IIoProvider& io);
|
|
|
|
|
|
|
|
|
|
// Implement Adapter callbacks for default cases (non-escape sequences)
|
|
|
|
|
void Print(const wchar_t wch) override;
|
2019-12-19 23:12:53 +01:00
|
|
|
void PrintString(const std::wstring_view string) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
void Execute(const wchar_t wch) override;
|
|
|
|
|
|
2019-06-11 22:27:09 +02:00
|
|
|
[[nodiscard]] NTSTATUS GetResult() { return _ntstatus; };
|
2019-05-03 00:29:04 +02:00
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
void _DefaultCase(const wchar_t wch);
|
2019-12-19 23:12:53 +01:00
|
|
|
void _DefaultStringCase(const std::wstring_view string);
|
2019-05-03 00:29:04 +02:00
|
|
|
|
|
|
|
|
Microsoft::Console::IIoProvider& _io;
|
|
|
|
|
NTSTATUS _ntstatus;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#include "..\terminal\adapter\conGetSet.hpp"
|
|
|
|
|
|
|
|
|
|
// The ConhostInternalGetSet is for the Conhost process to call the entrypoints for its own Get/Set APIs.
|
|
|
|
|
// Normally, these APIs are accessible from the outside of the conhost process (like by the process being "hosted") through
|
|
|
|
|
// the kernelbase/32 exposed public APIs and routed by the console driver (condrv) to this console host.
|
|
|
|
|
// But since we're trying to call them from *inside* the console host itself, we need to get in the way and route them straight to the
|
|
|
|
|
// v-table inside this process instance.
|
|
|
|
|
class ConhostInternalGetSet final : public Microsoft::Console::VirtualTerminal::ConGetSet
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
ConhostInternalGetSet(_In_ Microsoft::Console::IIoProvider& io);
|
|
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool GetConsoleScreenBufferInfoEx(CONSOLE_SCREEN_BUFFER_INFOEX& screenBufferInfo) const override;
|
|
|
|
|
bool SetConsoleScreenBufferInfoEx(const CONSOLE_SCREEN_BUFFER_INFOEX& screenBufferInfo) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool SetConsoleCursorPosition(const COORD position) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool GetConsoleCursorInfo(CONSOLE_CURSOR_INFO& cursorInfo) const override;
|
|
|
|
|
bool SetConsoleCursorInfo(const CONSOLE_CURSOR_INFO& cursorInfo) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool SetConsoleTextAttribute(const WORD attr) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateSetLegacyAttributes(const WORD attr,
|
|
|
|
|
const bool foreground,
|
|
|
|
|
const bool background,
|
|
|
|
|
const bool meta) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateSetDefaultAttributes(const bool foreground,
|
|
|
|
|
const bool background) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool SetConsoleXtermTextAttribute(const int xtermTableEntry,
|
|
|
|
|
const bool isForeground) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool SetConsoleRGBTextAttribute(const COLORREF rgbColor,
|
|
|
|
|
const bool isForeground) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateBoldText(const bool bolded) override;
|
|
|
|
|
bool PrivateGetExtendedTextAttributes(ExtendedAttributes& attrs) override;
|
|
|
|
|
bool PrivateSetExtendedTextAttributes(const ExtendedAttributes attrs) override;
|
|
|
|
|
bool PrivateGetTextAttributes(TextAttribute& attrs) const override;
|
|
|
|
|
bool PrivateSetTextAttributes(const TextAttribute& attrs) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateWriteConsoleInputW(std::deque<std::unique_ptr<IInputEvent>>& events,
|
|
|
|
|
size_t& eventsWritten) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool SetConsoleWindowInfo(bool const absolute,
|
|
|
|
|
const SMALL_RECT& window) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateSetCursorKeysMode(const bool applicationMode) override;
|
|
|
|
|
bool PrivateSetKeypadMode(const bool applicationMode) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
Add support for the DECSCNM screen mode (#3817)
## Summary of the Pull Request
This adds support for the [`DECSCNM`](https://vt100.net/docs/vt510-rm/DECSCNM.html) private mode escape sequence, which toggles the display between normal and reverse screen modes. When reversed, the background and foreground colors are switched. Tested manually, with [Vttest](https://invisible-island.net/vttest/), and with some new unit tests.
## References
This also fixes issue #72 for the most part, although if you toggle the mode too fast, there is no discernible flash.
## PR Checklist
* [x] Closes #3773
* [x] CLA signed. If not, go over [here](https://cla.opensource.microsoft.com/microsoft/Terminal) and sign the CLA
* [x] Tests added/passed
* [ ] Requires documentation to be updated
* [ ] I've discussed this with core contributors already. If not checked, I'm ready to accept this work might be rejected in favor of a different grand plan. Issue number where discussion took place: #xxx
## Detailed Description of the Pull Request / Additional comments
I've implemented this as a new flag in the `Settings` class, along with updates to the `LookupForegroundColor` and `LookupBackgroundColor` methods, to switch the returned foreground and background colors when that flag is set.
It also required a new private API in the `ConGetSet` interface to toggle the setting. And that API is then called from the `AdaptDispatch` class when the screen mode escape sequence is received.
The last thing needed was to add a step to the `HardReset` method, to reset the mode back to normal, which is one of the `RIS` requirements.
Note that this does currently work in the Windows Terminal, but once #2661 is implemented that may no longer be the case. It might become necessary to let the mode change sequences pass through conpty, and handle the color reversing on the client side.
## Validation Steps Performed
I've added a state machine test to make sure the escape sequence is dispatched correctly, and a screen buffer test to confirm that the mode change does alter the interpretation of colors as expected.
I've also confirmed that the various "light background" tests in Vttest now display correctly, and that the `tput flash` command (in a bash shell) does actually cause the screen to flash.
2020-01-22 23:29:50 +01:00
|
|
|
bool PrivateSetScreenMode(const bool reverseMode) override;
|
Add support for VT100 Auto Wrap Mode (DECAWM) (#3943)
## Summary of the Pull Request
This adds support for the [`DECAWM`](https://vt100.net/docs/vt510-rm/DECAWM) private mode escape sequence, which controls whether or not the output wraps to the next line when the cursor reaches the right edge of the screen. Tested manually, with [Vttest](https://invisible-island.net/vttest/), and with some new unit tests.
## PR Checklist
* [x] Closes #3826
* [x] CLA signed. If not, go over [here](https://cla.opensource.microsoft.com/microsoft/Terminal) and sign the CLA
* [x] Tests added/passed
* [ ] Requires documentation to be updated
* [x] I've discussed this with core contributors already. If not checked, I'm ready to accept this work might be rejected in favor of a different grand plan. Issue number where discussion took place: #3826
## Detailed Description of the Pull Request / Additional comments
The idea was to repurpose the existing `ENABLE_WRAP_AT_EOL_OUTPUT` mode, but the problem with that was it didn't work in VT mode - specifically, disabling it didn't prevent the wrapping from happening. This was because in VT mode the `WC_DELAY_EOL_WRAP` behaviour takes affect, and that bypasses the usual codepath where `ENABLE_WRAP_AT_EOL_OUTPUT` is checked,
To fix this, I had to add additional checks in the `WriteCharsLegacy` function (7dbefe06e41f191a0e83cfefe4896b66094c4089) to make sure the `WC_DELAY_EOL_WRAP` mode is only activated when `ENABLE_WRAP_AT_EOL_OUTPUT` is also set.
Once that was fixed, though, another issue came to light: the `ENABLE_WRAP_AT_EOL_OUTPUT` mode doesn't actually work as documented. According to the docs, "if this mode is disabled, the last character in the row is overwritten with any subsequent characters". What actually happens is the cursor jumps back to the position at the start of the write, which could be anywhere on the line.
This seems completely broken to me, but I've checked in the Windows XP, and it has the same behaviour, so it looks like that's the way it has always been. So I've added a fix for this (9df98497ca38f7d0ea42623b723a8e2ecf9a4ab9), but it is only applied in VT mode.
Once that basic functionality was in place, though, we just needed a private API in the `ConGetSet` interface to toggle the mode, and then that API could be called from the `AdaptDispatch` class when the `DECAWM` escape sequence was received.
One last thing was to reenable the mode in reponse to a `DECSTR` soft reset. Technically the auto wrap mode was disabled by default on many of the DEC terminals, and some documentation suggests that `DECSTR` should reset it to that state, But most modern terminals (including XTerm) expect the wrapping to be enabled by default, and `DECSTR` reenables that state, so that's the behaviour I've copied.
## Validation Steps Performed
I've add a state machine test to confirm the `DECAWM` escape is dispatched correctly, and a screen buffer test to make sure the output is wrapped or clamped as appropriate for the two states.
I've also confirmed that the "wrap around" test is now working correctly in the _Test of screen features_ in Vttest.
2020-02-04 01:20:21 +01:00
|
|
|
bool PrivateSetAutoWrapMode(const bool wrapAtEOL) override;
|
Add support for the DECSCNM screen mode (#3817)
## Summary of the Pull Request
This adds support for the [`DECSCNM`](https://vt100.net/docs/vt510-rm/DECSCNM.html) private mode escape sequence, which toggles the display between normal and reverse screen modes. When reversed, the background and foreground colors are switched. Tested manually, with [Vttest](https://invisible-island.net/vttest/), and with some new unit tests.
## References
This also fixes issue #72 for the most part, although if you toggle the mode too fast, there is no discernible flash.
## PR Checklist
* [x] Closes #3773
* [x] CLA signed. If not, go over [here](https://cla.opensource.microsoft.com/microsoft/Terminal) and sign the CLA
* [x] Tests added/passed
* [ ] Requires documentation to be updated
* [ ] I've discussed this with core contributors already. If not checked, I'm ready to accept this work might be rejected in favor of a different grand plan. Issue number where discussion took place: #xxx
## Detailed Description of the Pull Request / Additional comments
I've implemented this as a new flag in the `Settings` class, along with updates to the `LookupForegroundColor` and `LookupBackgroundColor` methods, to switch the returned foreground and background colors when that flag is set.
It also required a new private API in the `ConGetSet` interface to toggle the setting. And that API is then called from the `AdaptDispatch` class when the screen mode escape sequence is received.
The last thing needed was to add a step to the `HardReset` method, to reset the mode back to normal, which is one of the `RIS` requirements.
Note that this does currently work in the Windows Terminal, but once #2661 is implemented that may no longer be the case. It might become necessary to let the mode change sequences pass through conpty, and handle the color reversing on the client side.
## Validation Steps Performed
I've added a state machine test to make sure the escape sequence is dispatched correctly, and a screen buffer test to confirm that the mode change does alter the interpretation of colors as expected.
I've also confirmed that the various "light background" tests in Vttest now display correctly, and that the `tput flash` command (in a bash shell) does actually cause the screen to flash.
2020-01-22 23:29:50 +01:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateShowCursor(const bool show) noexcept override;
|
|
|
|
|
bool PrivateAllowCursorBlinking(const bool enable) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateSetScrollingRegion(const SMALL_RECT& scrollMargins) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
Dispatch more C0 control characters from the VT state machine (#4171)
This commit moves the handling of the `BEL`, `BS`, `TAB`, and `CR`
controls characters into the state machine (when in VT mode), instead of
forwarding them on to the default string writer, which would otherwise
have to parse them out all over again.
This doesn't cover all the control characters, but `ESC`, `SUB`, and
`CAN` are already an integral part of the `StateMachine` itself; `NUL`
is filtered out by the `OutputStateMachineEngine`; and `LF`, `FF`, and
`VT` are due to be implemented as part of PR #3271.
Once all of these controls are handled at the state machine level, we
can strip out all the VT-specific code from the `WriteCharsLegacy`
function, which should simplify it considerably. This would also let us
simplify the `Terminal::_WriteBuffer` implementation, and the planned
replacement stream writer for issue #780.
On the conhost side, the implementation is handled as follows:
* The `BS` control is dispatched to the existing `CursorBackward`
method, with a distance of 1.
* The `TAB` control is dispatched to the existing `ForwardTab` method,
with a tab count of 1.
* The `CR` control required a new dispatch method, but the
implementation was a simple call to the new `_CursorMovePosition` method
from PR #3628.
* The `BEL` control also required a new dispatch method, as well as an
additional private API in the `ConGetSet` interface. But that's mostly
boilerplate code - ultimately it just calls the `SendNotifyBeep` method.
On the Windows Terminal side, not all dispatch methods are implemented.
* There is an existing `CursorBackward` implementation, so `BS` works
OK.
* There isn't a `ForwardTab` implementation, but `TAB` isn't currently
required by the conpty protocol.
* I had to implement the `CarriageReturn` dispatch method, but that was
a simple call to `Terminal::SetCursorPosition`.
* The `WarningBell` method I've left unimplemented, because that
functionality wasn't previously supported anyway, and there's an
existing issue for that (#4046).
## Validation Steps Performed
I've added a state machine test to confirm that the updated control
characters are now forwarded to the appropriate dispatch handlers. But
since the actual implementation is mostly relying on existing
functionality, I'm assuming that code is already adequately tested
elsewhere. That said, I have also run various manual tests of my own,
and confirmed that everything still worked as well as before.
References #3271
References #780
References #3628
References #4046
2020-01-17 02:43:21 +01:00
|
|
|
bool PrivateWarningBell() override;
|
|
|
|
|
|
Add support for all the line feed control sequences (#3271)
## Summary of the Pull Request
This adds support for the `FF` (form feed) and `VT` (vertical tab) [control characters](https://vt100.net/docs/vt510-rm/chapter4.html#T4-1), as well as the [`NEL` (Next Line)](https://vt100.net/docs/vt510-rm/NEL.html) and [`IND` (Index)](https://vt100.net/docs/vt510-rm/IND.html) escape sequences.
## References
#976 discusses the conflict between VT100 Index sequence and the VT52 cursor back sequence.
## PR Checklist
* [x] Closes #3189
* [x] CLA signed. If not, go over [here](https://cla.opensource.microsoft.com/microsoft/Terminal) and sign the CLA
* [x] Tests added/passed
* [ ] Requires documentation to be updated
* [x] I've discussed this with core contributors already. If not checked, I'm ready to accept this work might be rejected in favor of a different grand plan. Issue number where discussion took place: #3189
## Detailed Description of the Pull Request / Additional comments
I've added a `LineFeed` method to the `ITermDispatch` interface, with an enum parameter specifying the required line feed type (i.e. with carriage return, without carriage return, or dependent on the [`LNM` mode](https://vt100.net/docs/vt510-rm/LNM.html)). The output state machine can then call that method to handle the various line feed control characters (parsed in the `ActionExecute` method), as well the `NEL` and `IND` escape sequences (parsed in the `ActionEscDispatch` method).
The `AdaptDispatch` implementation of `LineFeed` then forwards the call to a new `PrivateLineFeed` method in the `ConGetSet` interface, which simply takes a bool parameter specifying whether a carriage return is required or not. In the case of mode-dependent line feeds, the `AdaptDispatch` implementation determines whether the return is necessary or not, based on the existing _AutoReturnOnNewLine_ setting (which I'm obtaining via another new `PrivateGetLineFeedMode` method).
Ultimately we'll want to support changing the mode via the [`LNM` escape sequence](https://vt100.net/docs/vt510-rm/LNM.html), but there's no urgent need for that now. And using the existing _AutoReturnOnNewLine_ setting as a substitute for the mode gives us backwards compatible behaviour, since that will be true for the Windows shells (which expect a linefeed to also generate a carriage return), and false in a WSL bash shell (which won't want the carriage return by default).
As for the actual `PrivateLineFeed` implementation, that is just a simplified version of how the line feed would previously have been executed in the `WriteCharsLegacy` function. This includes setting the cursor to "On" (with `Cursor::SetIsOn`), potentially clearing the wrap property of the line being left (with `CharRow::SetWrapForced` false), and then setting the new position using `AdjustCursorPosition` with the _fKeepCursorVisible_ parameter set to false.
I'm unsure whether the `SetIsOn` call is really necessary, and I think the way the forced wrap is handled needs a rethink in general, but for now this should at least be compatible with the existing behaviour.
Finally, in order to make this all work in the _Windows Terminal_ app, I also had to add a basic implementation of the `ITermDispatch::LineFeed` method in the `TerminalDispatch` class. There is currently no need to support mode-specific line feeds here, so this simply forwards a `\n` or `\r\n` to the `Execute` method, which is ultimately handled by the `Terminal::_WriteBuffer` implementation.
## Validation Steps Performed
I've added output engine tests which confirm that the various control characters and escape sequences trigger the dispatch method correctly. Then I've added adapter tests which confirm the various dispatch options trigger the `PrivateLineFeed` API correctly. And finally I added some screen buffer tests that check the actual results of the `NEL` and `IND` sequences, which covers both forms of the `PrivateLineFeed` API (i.e. with and without a carriage return).
I've also run the _Test of cursor movements_ in the [Vttest](https://invisible-island.net/vttest/) utility, and confirmed that screens 1, 2, and 5 are now working correctly. The first two depend on `NEL` and `IND` being supported, and screen 5 requires the `VT` control character.
2020-01-15 14:41:55 +01:00
|
|
|
bool PrivateGetLineFeedMode() const override;
|
|
|
|
|
bool PrivateLineFeed(const bool withReturn) override;
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateReverseLineFeed() override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool SetConsoleTitleW(const std::wstring_view title) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateUseAlternateScreenBuffer() override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateUseMainScreenBuffer() override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateHorizontalTabSet();
|
|
|
|
|
bool PrivateForwardTab(const size_t numTabs) override;
|
|
|
|
|
bool PrivateBackwardsTab(const size_t numTabs) override;
|
|
|
|
|
bool PrivateTabClear(const bool clearAll) override;
|
|
|
|
|
bool PrivateSetDefaultTabStops() override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateEnableVT200MouseMode(const bool enabled) override;
|
|
|
|
|
bool PrivateEnableUTF8ExtendedMouseMode(const bool enabled) override;
|
|
|
|
|
bool PrivateEnableSGRExtendedMouseMode(const bool enabled) override;
|
|
|
|
|
bool PrivateEnableButtonEventMouseMode(const bool enabled) override;
|
|
|
|
|
bool PrivateEnableAnyEventMouseMode(const bool enabled) override;
|
|
|
|
|
bool PrivateEnableAlternateScroll(const bool enabled) override;
|
|
|
|
|
bool PrivateEraseAll() override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateGetConsoleScreenBufferAttributes(WORD& attributes) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivatePrependConsoleInput(std::deque<std::unique_ptr<IInputEvent>>& events,
|
|
|
|
|
size_t& eventsWritten) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool SetCursorStyle(CursorType const style) override;
|
|
|
|
|
bool SetCursorColor(COLORREF const color) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateRefreshWindow() override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateSuppressResizeRepaint() override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateWriteConsoleControlInput(const KeyEvent key) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool GetConsoleOutputCP(unsigned int& codepage) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool IsConsolePty(bool& isPty) const override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool DeleteLines(const size_t count) override;
|
|
|
|
|
bool InsertLines(const size_t count) override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool MoveToBottom() const override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateSetColorTableEntry(const short index, const COLORREF value) const noexcept override;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateSetDefaultForeground(const COLORREF value) const noexcept override;
|
2019-05-24 18:53:00 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateSetDefaultBackground(const COLORREF value) const noexcept override;
|
2019-05-24 18:53:00 +02:00
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateFillRegion(const COORD startPosition,
|
Correct fill attributes when scrolling and erasing (#3100)
## Summary of the Pull Request
Operations that erase areas of the screen are typically meant to do so using the current color attributes, but with the rendition attributes reset (what we refer to as meta attributes). This also includes scroll operations that have to clear the area of the screen that has scrolled into view. The only exception is the _Erase Scrollback_ operation, which needs to reset the buffer with the default attributes. This PR updates all of these cases to apply the correct attributes when scrolling and erasing.
## PR Checklist
* [x] Closes #2553
* [x] CLA signed. If not, go over [here](https://cla.opensource.microsoft.com/microsoft/Terminal) and sign the CLA
* [x] Tests added/passed
* [ ] Requires documentation to be updated
* [ ] I've not really discussed this with core contributors. I'm ready to accept this work might be rejected in favor of a different grand plan.
## Detailed Description of the Pull Request / Additional comments
My initial plan was to use a special case legacy attribute value to indicate the "standard erase attribute" which could safely be passed through the legacy APIs. But this wouldn't cover the cases that required default attributes to be used. And then with the changes in PR #2668 and #2987, it became clear that our requirements could be better achieved with a couple of new private APIs that wouldn't have to depend on legacy attribute hacks at all.
To that end, I've added the `PrivateFillRegion` and `PrivateScrollRegion` APIs to the `ConGetSet` interface. These are just thin wrappers around the existing `SCREEN_INFORMATION::Write` method and the `ScrollRegion` function respectively, but with a simple boolean parameter to choose between filling with default attributes or the standard erase attributes (i.e the current colors but with meta attributes reset).
With those new APIs in place, I could then update most scroll operations to use `PrivateScrollRegion`, and most erase operations to use `PrivateFillRegion`.
The functions affected by scrolling included:
* `DoSrvPrivateReverseLineFeed` (the RI command)
* `DoSrvPrivateModifyLinesImpl` (the IL and DL commands)
* `AdaptDispatch::_InsertDeleteHelper` (the ICH and DCH commands)
* `AdaptDispatch::_ScrollMovement` (the SU and SD commands)
The functions affected by erasing included:
* `AdaptDispatch::_EraseSingleLineHelper` (the EL command, and most ED variants)
* `AdaptDispatch::EraseCharacters` (the ECH command)
While updating these erase methods, I noticed that both of them also required boundary fixes similar to those in PR #2505 (i.e. the horizontal extent of the erase operation should apply to the full width of the buffer, and not just the current viewport width), so I've addressed that at the same time.
In addition to the changes above, there were also a few special cases, the first being the line feed handling, which required updating in a number of places to use the correct erase attributes:
* `SCREEN_INFORMATION::InitializeCursorRowAttributes` - this is used to initialise the rows that pan into view when the viewport is moved down the buffer.
* `TextBuffer::IncrementCircularBuffer` - this occurs when we scroll passed the very end of the buffer, and a recycled row now needs to be reinitialised.
* `AdjustCursorPosition` - when within margin boundaries, this relies on a couple of direct calls to `ScrollRegion` which needed to be passed the correct fill attributes.
The second special case was the full screen erase sequence (`ESC 2 J`), which is handled separately from the other ED sequences. This required updating the `SCREEN_INFORMATION::VtEraseAll` method to use the standard erase attributes, and also required changes to the horizontal extent of the filled area, since it should have been clearing the full buffer width (the same issue as the other erase operations mentioned above).
Finally, there was the `AdaptDispatch::_EraseScrollback` method, which uses both scroll and fill operations, which could now be handled by the new `PrivateScrollRegion` and `PrivateFillRegion` APIs. But in this case we needed to fill with the default attributes rather than the standard erase attributes. And again this implementation needed some changes to make sure the full width of the active area was retained after the erase, similar to the horizontal boundary issues with the other erase operations.
Once all these changes were made, there were a few areas of the code that could then be simplified quite a bit. The `FillConsoleOutputCharacterW`, `FillConsoleOutputAttribute`, and `ScrollConsoleScreenBufferW` were no longer needed in the `ConGetSet` interface, so all of that code could now be removed. The `_EraseSingleLineDistanceHelper` and `_EraseAreaHelper` methods in the `AdaptDispatch` class were also no longer required and could be removed.
Then there were the hacks to handle legacy default colors in the `FillConsoleOutputAttributeImpl` and `ScrollConsoleScreenBufferWImpl` implementations. Since those hacks were only needed for VT operations, and the VT code no longer calls those methods, there was no longer a need to retain that behaviour (in fact there are probably some edge cases where that behaviour might have been considered a bug when reached via the public console APIs).
## Validation Steps Performed
For most of the scrolling operations there were already existing tests in place, and those could easily be extended to check that the meta attributes were correctly reset when filling the revealed lines of the scrolling region.
In the screen buffer tests, I made updates of that sort to the `ScrollOperations` method (handling SU, SD, IL, DL, and RI), the `InsertChars` and `DeleteChars` methods (ICH and DCH), and the `VtNewlinePastViewport` method (LF). I also added a new `VtNewlinePastEndOfBuffer` test to check the case where the line feed causes the viewport to pan past the end of the buffer.
The erase operations, however, were being covered by adapter tests, and those aren't really suited for this kind of functionality (the same sort of issue came up in PR #2505). As a result I've had to reimplement those tests as screen buffer tests.
Most of the erase operations are covered by the `EraseTests` method, except the for the scrollback erase which has a dedicated `EraseScrollbackTests` method. I've also had to replace the `HardReset` adapter test, but that was already mostly covered by the `HardResetBuffer` screen buffer test, which I've now extended slightly (it could do with some more checks, but I think that can wait for a future PR when we're fixing other RIS issues).
2019-12-11 00:14:40 +01:00
|
|
|
const size_t fillLength,
|
|
|
|
|
const wchar_t fillChar,
|
|
|
|
|
const bool standardFillAttrs) noexcept override;
|
|
|
|
|
|
2019-12-19 23:12:53 +01:00
|
|
|
bool PrivateScrollRegion(const SMALL_RECT scrollRect,
|
Correct fill attributes when scrolling and erasing (#3100)
## Summary of the Pull Request
Operations that erase areas of the screen are typically meant to do so using the current color attributes, but with the rendition attributes reset (what we refer to as meta attributes). This also includes scroll operations that have to clear the area of the screen that has scrolled into view. The only exception is the _Erase Scrollback_ operation, which needs to reset the buffer with the default attributes. This PR updates all of these cases to apply the correct attributes when scrolling and erasing.
## PR Checklist
* [x] Closes #2553
* [x] CLA signed. If not, go over [here](https://cla.opensource.microsoft.com/microsoft/Terminal) and sign the CLA
* [x] Tests added/passed
* [ ] Requires documentation to be updated
* [ ] I've not really discussed this with core contributors. I'm ready to accept this work might be rejected in favor of a different grand plan.
## Detailed Description of the Pull Request / Additional comments
My initial plan was to use a special case legacy attribute value to indicate the "standard erase attribute" which could safely be passed through the legacy APIs. But this wouldn't cover the cases that required default attributes to be used. And then with the changes in PR #2668 and #2987, it became clear that our requirements could be better achieved with a couple of new private APIs that wouldn't have to depend on legacy attribute hacks at all.
To that end, I've added the `PrivateFillRegion` and `PrivateScrollRegion` APIs to the `ConGetSet` interface. These are just thin wrappers around the existing `SCREEN_INFORMATION::Write` method and the `ScrollRegion` function respectively, but with a simple boolean parameter to choose between filling with default attributes or the standard erase attributes (i.e the current colors but with meta attributes reset).
With those new APIs in place, I could then update most scroll operations to use `PrivateScrollRegion`, and most erase operations to use `PrivateFillRegion`.
The functions affected by scrolling included:
* `DoSrvPrivateReverseLineFeed` (the RI command)
* `DoSrvPrivateModifyLinesImpl` (the IL and DL commands)
* `AdaptDispatch::_InsertDeleteHelper` (the ICH and DCH commands)
* `AdaptDispatch::_ScrollMovement` (the SU and SD commands)
The functions affected by erasing included:
* `AdaptDispatch::_EraseSingleLineHelper` (the EL command, and most ED variants)
* `AdaptDispatch::EraseCharacters` (the ECH command)
While updating these erase methods, I noticed that both of them also required boundary fixes similar to those in PR #2505 (i.e. the horizontal extent of the erase operation should apply to the full width of the buffer, and not just the current viewport width), so I've addressed that at the same time.
In addition to the changes above, there were also a few special cases, the first being the line feed handling, which required updating in a number of places to use the correct erase attributes:
* `SCREEN_INFORMATION::InitializeCursorRowAttributes` - this is used to initialise the rows that pan into view when the viewport is moved down the buffer.
* `TextBuffer::IncrementCircularBuffer` - this occurs when we scroll passed the very end of the buffer, and a recycled row now needs to be reinitialised.
* `AdjustCursorPosition` - when within margin boundaries, this relies on a couple of direct calls to `ScrollRegion` which needed to be passed the correct fill attributes.
The second special case was the full screen erase sequence (`ESC 2 J`), which is handled separately from the other ED sequences. This required updating the `SCREEN_INFORMATION::VtEraseAll` method to use the standard erase attributes, and also required changes to the horizontal extent of the filled area, since it should have been clearing the full buffer width (the same issue as the other erase operations mentioned above).
Finally, there was the `AdaptDispatch::_EraseScrollback` method, which uses both scroll and fill operations, which could now be handled by the new `PrivateScrollRegion` and `PrivateFillRegion` APIs. But in this case we needed to fill with the default attributes rather than the standard erase attributes. And again this implementation needed some changes to make sure the full width of the active area was retained after the erase, similar to the horizontal boundary issues with the other erase operations.
Once all these changes were made, there were a few areas of the code that could then be simplified quite a bit. The `FillConsoleOutputCharacterW`, `FillConsoleOutputAttribute`, and `ScrollConsoleScreenBufferW` were no longer needed in the `ConGetSet` interface, so all of that code could now be removed. The `_EraseSingleLineDistanceHelper` and `_EraseAreaHelper` methods in the `AdaptDispatch` class were also no longer required and could be removed.
Then there were the hacks to handle legacy default colors in the `FillConsoleOutputAttributeImpl` and `ScrollConsoleScreenBufferWImpl` implementations. Since those hacks were only needed for VT operations, and the VT code no longer calls those methods, there was no longer a need to retain that behaviour (in fact there are probably some edge cases where that behaviour might have been considered a bug when reached via the public console APIs).
## Validation Steps Performed
For most of the scrolling operations there were already existing tests in place, and those could easily be extended to check that the meta attributes were correctly reset when filling the revealed lines of the scrolling region.
In the screen buffer tests, I made updates of that sort to the `ScrollOperations` method (handling SU, SD, IL, DL, and RI), the `InsertChars` and `DeleteChars` methods (ICH and DCH), and the `VtNewlinePastViewport` method (LF). I also added a new `VtNewlinePastEndOfBuffer` test to check the case where the line feed causes the viewport to pan past the end of the buffer.
The erase operations, however, were being covered by adapter tests, and those aren't really suited for this kind of functionality (the same sort of issue came up in PR #2505). As a result I've had to reimplement those tests as screen buffer tests.
Most of the erase operations are covered by the `EraseTests` method, except the for the scrollback erase which has a dedicated `EraseScrollbackTests` method. I've also had to replace the `HardReset` adapter test, but that was already mostly covered by the `HardResetBuffer` screen buffer test, which I've now extended slightly (it could do with some more checks, but I think that can wait for a future PR when we're fixing other RIS issues).
2019-12-11 00:14:40 +01:00
|
|
|
const std::optional<SMALL_RECT> clipRect,
|
|
|
|
|
const COORD destinationOrigin,
|
|
|
|
|
const bool standardFillAttrs) noexcept override;
|
|
|
|
|
|
2019-05-03 00:29:04 +02:00
|
|
|
private:
|
|
|
|
|
Microsoft::Console::IIoProvider& _io;
|
|
|
|
|
};
|
