This PR provides a faster algorithm for converting 8-bit and 24-bit colors into the 4-bit legacy values that are required by the Win32 console APIs. It also fixes areas of the code that were incorrectly using a simple 16-color conversion that didn't handle 8-bit and 24-bit values. The faster conversion algorithm should be an improvement for issues #783 and #3950. One of the main points of this PR was to fix the `ReadConsoleOutputAttribute` API, which was using a simplified legacy color conversion (the original `TextAttribute:GetLegacyAttributes` method), which could only handle values from the 16-color table. RGB values, and colors from the 256-color table, would be mapped to completely nonsensical values. This API has now been updated to use the more correct `Settings::GenerateLegacyAttributes` method. But there were also a couple of other places in the code that were using `GetLegacyAttributes` when they really had no reason to be working with legacy attributes at all. This could result in colors being downgraded to 4-bit values (often badly, as explained above), when the code was already perfectly capable of displaying the full 24-bits. This included the fill colors in the IME composer (in `ConsoleImeInfo`), and the construction of the highlighting colors in the color search/selection handler (`Selection::_HandleColorSelection`). I also got rid of some legacy attribute code in the `Popup` class, which was originally intended to update colors below the popup when the settings changed, but actually caused more problems than it solved. The other major goal of this PR was to improve the performance of the `GenerateLegacyAttributes` method, since the existing implementation could be quite slow when dealing with RGB values. The simple cases are handled much the same as they were before. For an `IsDefault` color, we get the default index from the `Settings::_wFillAttribute` field. For an `IsIndex16` color, the index can just be returned as is. For an `IsRgb` color, the RGB components are compressed down to 8 bits (3 red, 3 green, 2 blue), simply by dropping the least significant bits. This 8-bit value is then used to lookup a representative 16-color value from a hard-coded table. An `IsIndex256` color is also converted with a lookup table, just using the existing 8-bit index. The RGB mapping table was calculated by taking each compressed 8-bit color, and picking a entry from the _Campbell_ palette that best approximated that color. This was done by looking at a range of 24-bit colors that mapped to the 8-bit value, finding the best _Campbell_ match for each of them (using a [CIEDE2000] color difference calculation), and then the most common match became the index that the 8-bit value would map to. The 256-color table was just a simpler version of this process. For each entry in the table, we take the default RGB palette value, and find it's closest match in the _Campbell_ palette. Because these tables are hard-coded, the results won't adjust to changes in the palette. However, they should still produce reasonable results for palettes that follow the standard ANSI color range. And since they're only a very loose approximation of the colors anyway, the exact value really isn't that important. That said, I have tried to make sure that if you take an RGB value for a particular index in a reasonable color scheme, then the legacy color mapped from that value should ideally match the same index. This will never be possible for all color schemes, but I have tweaked a few of the table entries to improve the results for some of the common schemes. One other point worth making regarding the hard-coded tables: even if we wanted to take the active palette into account, that wouldn't actually be possible over a conpty connection, because we can't easily know what color scheme the client application is using. At least this way the results in conhost are guaranteed to be the same as in the Windows Terminal. [CIEDE2000]: https://en.wikipedia.org/wiki/Color_difference#CIEDE2000 ## Validation Steps Performed This code still passes the `TextAttributeTests` that check the basic `GetLegacyAttribute` behaviour and verify the all legacy attributes roundtrip correctly. However, some of the values in the `RgbColorTests` had to be updated, since we're now intentionally returning different values as a result of the changes to the RGB conversion algorithm. I haven't added additional unit tests, but I have done a lot of manual testing to see how well the new algorithm works with a range of colors and a variety of different color schemes. It's not perfect in every situation, but I think it works well enough for the purpose it serves. I've also confirmed that the issues reported in #5940 and #6247 are now fixed by these changes. Closes #5940 Closes #6247
156 lines
5.4 KiB
C++
156 lines
5.4 KiB
C++
/*++
|
|
Copyright (c) Microsoft Corporation
|
|
Licensed under the MIT license.
|
|
|
|
Module Name:
|
|
- cmdline.h
|
|
|
|
Abstract:
|
|
- This file contains the internal structures and definitions used by command line input and editing.
|
|
|
|
Author:
|
|
- Therese Stowell (ThereseS) 15-Nov-1991
|
|
|
|
Revision History:
|
|
- Mike Griese (migrie) Jan 2018:
|
|
Refactored the history and alias functionality into their own files.
|
|
- Michael Niksa (miniksa) May 2018:
|
|
Split apart popup information. Started encapsulating command line things. Removed 0 length buffers.
|
|
Notes:
|
|
The input model for the command line editing popups is complex.
|
|
Here is the relevant pseudocode:
|
|
|
|
CookedReadWaitRoutine
|
|
if (CookedRead->Popup)
|
|
Status = (*CookedRead->Popup->Callback)();
|
|
if (Status == CONSOLE_STATUS_READ_COMPLETE)
|
|
return STATUS_SUCCESS;
|
|
return Status;
|
|
|
|
CookedRead
|
|
if (Command Line Editing Key)
|
|
ProcessCommandLine
|
|
else
|
|
process regular key
|
|
|
|
ProcessCommandLine
|
|
if F7
|
|
return Popup
|
|
|
|
Popup
|
|
draw popup
|
|
return ProcessCommandListInput
|
|
|
|
ProcessCommandListInput
|
|
while (TRUE)
|
|
GetChar
|
|
if (wait)
|
|
return wait
|
|
switch (char)
|
|
.
|
|
.
|
|
.
|
|
--*/
|
|
|
|
#pragma once
|
|
|
|
#include "input.h"
|
|
#include "screenInfo.hpp"
|
|
#include "server.h"
|
|
|
|
#include "history.h"
|
|
#include "alias.h"
|
|
#include "readDataCooked.hpp"
|
|
#include "popup.h"
|
|
|
|
class CommandLine
|
|
{
|
|
public:
|
|
~CommandLine();
|
|
|
|
static CommandLine& Instance();
|
|
|
|
bool IsEditLineEmpty() const;
|
|
void Hide(const bool fUpdateFields);
|
|
void Show();
|
|
bool IsVisible() const noexcept;
|
|
|
|
[[nodiscard]] NTSTATUS ProcessCommandLine(COOKED_READ_DATA& cookedReadData,
|
|
_In_ WCHAR wch,
|
|
const DWORD dwKeyState);
|
|
|
|
[[nodiscard]] HRESULT StartCommandNumberPopup(COOKED_READ_DATA& cookedReadData);
|
|
|
|
bool HasPopup() const noexcept;
|
|
Popup& GetPopup();
|
|
|
|
void EndCurrentPopup();
|
|
void EndAllPopups();
|
|
|
|
void DeletePromptAfterCursor(COOKED_READ_DATA& cookedReadData) noexcept;
|
|
COORD DeleteFromRightOfCursor(COOKED_READ_DATA& cookedReadData) noexcept;
|
|
|
|
protected:
|
|
CommandLine();
|
|
|
|
// delete these because we don't want to accidentally get copies of the singleton
|
|
CommandLine(CommandLine const&) = delete;
|
|
CommandLine& operator=(CommandLine const&) = delete;
|
|
|
|
[[nodiscard]] NTSTATUS _startCommandListPopup(COOKED_READ_DATA& cookedReadData);
|
|
[[nodiscard]] NTSTATUS _startCopyFromCharPopup(COOKED_READ_DATA& cookedReadData);
|
|
[[nodiscard]] NTSTATUS _startCopyToCharPopup(COOKED_READ_DATA& cookedReadData);
|
|
|
|
void _processHistoryCycling(COOKED_READ_DATA& cookedReadData, const CommandHistory::SearchDirection searchDirection);
|
|
void _setPromptToOldestCommand(COOKED_READ_DATA& cookedReadData);
|
|
void _setPromptToNewestCommand(COOKED_READ_DATA& cookedReadData);
|
|
COORD _deletePromptBeforeCursor(COOKED_READ_DATA& cookedReadData) noexcept;
|
|
COORD _moveCursorToEndOfPrompt(COOKED_READ_DATA& cookedReadData) noexcept;
|
|
COORD _moveCursorToStartOfPrompt(COOKED_READ_DATA& cookedReadData) noexcept;
|
|
COORD _moveCursorLeftByWord(COOKED_READ_DATA& cookedReadData) noexcept;
|
|
COORD _moveCursorLeft(COOKED_READ_DATA& cookedReadData);
|
|
COORD _moveCursorRightByWord(COOKED_READ_DATA& cookedReadData) noexcept;
|
|
COORD _moveCursorRight(COOKED_READ_DATA& cookedReadData) noexcept;
|
|
void _insertCtrlZ(COOKED_READ_DATA& cookedReadData) noexcept;
|
|
void _deleteCommandHistory(COOKED_READ_DATA& cookedReadData) noexcept;
|
|
void _fillPromptWithPreviousCommandFragment(COOKED_READ_DATA& cookedReadData) noexcept;
|
|
COORD _cycleMatchingCommandHistoryToPrompt(COOKED_READ_DATA& cookedReadData);
|
|
|
|
#ifdef UNIT_TESTING
|
|
friend class CommandLineTests;
|
|
friend class CommandNumberPopupTests;
|
|
#endif
|
|
|
|
private:
|
|
std::deque<std::unique_ptr<Popup>> _popups;
|
|
bool _isVisible;
|
|
};
|
|
|
|
void DeleteCommandLine(COOKED_READ_DATA& cookedReadData, const bool fUpdateFields);
|
|
|
|
void RedrawCommandLine(COOKED_READ_DATA& cookedReadData);
|
|
|
|
// Values for WriteChars(), WriteCharsLegacy() dwFlags
|
|
#define WC_DESTRUCTIVE_BACKSPACE 0x01
|
|
#define WC_KEEP_CURSOR_VISIBLE 0x02
|
|
#define WC_ECHO 0x04
|
|
|
|
// This is no longer necessary. The buffer will always be Unicode. We don't need to perform special work to check if we're in a raster font
|
|
// and convert the entire buffer to match (and all insertions).
|
|
//#define WC_FALSIFY_UNICODE 0x08
|
|
|
|
#define WC_LIMIT_BACKSPACE 0x10
|
|
//#define WC_NONDESTRUCTIVE_TAB 0x20 - This is not needed anymore, because the VT code handles tabs internally now.
|
|
//#define WC_NEWLINE_SAVE_X 0x40 - This has been replaced with an output mode flag instead as it's line discipline behavior that may not necessarily be coupled with VT.
|
|
#define WC_DELAY_EOL_WRAP 0x80
|
|
|
|
// Word delimiters
|
|
bool IsWordDelim(const wchar_t wch);
|
|
bool IsWordDelim(const std::wstring_view charData);
|
|
|
|
[[nodiscard]] HRESULT DoSrvSetConsoleTitleW(const std::wstring_view title) noexcept;
|
|
|
|
bool IsValidStringBuffer(_In_ bool Unicode, _In_reads_bytes_(Size) PVOID Buffer, _In_ ULONG Size, _In_ ULONG Count, ...);
|
|
|
|
void SetCurrentCommandLine(COOKED_READ_DATA& cookedReadData, _In_ SHORT Index);
|