ccea66710c
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
75 lines
2.2 KiB
C++
75 lines
2.2 KiB
C++
/*++
|
|
Copyright (c) Microsoft Corporation
|
|
Licensed under the MIT license.
|
|
|
|
Module Name:
|
|
- conareainfo.h
|
|
|
|
Abstract:
|
|
- This module contains the structures for the console IME conversion area
|
|
- The conversion area is the overlay on the screen where a user attempts to form
|
|
a string that they would like to insert into the buffer.
|
|
|
|
Author:
|
|
- Michael Niksa (MiNiksa) 10-May-2018
|
|
|
|
Revision History:
|
|
- From pieces of convarea.cpp originally authored by KazuM
|
|
--*/
|
|
|
|
#pragma once
|
|
|
|
#include "../buffer/out/OutputCell.hpp"
|
|
#include "../buffer/out/TextAttribute.hpp"
|
|
#include "../renderer/inc/FontInfo.hpp"
|
|
|
|
class SCREEN_INFORMATION;
|
|
class TextBuffer;
|
|
|
|
// Internal structures and definitions used by the conversion area.
|
|
class ConversionAreaBufferInfo final
|
|
{
|
|
public:
|
|
COORD coordCaBuffer;
|
|
SMALL_RECT rcViewCaWindow;
|
|
COORD coordConView;
|
|
|
|
explicit ConversionAreaBufferInfo(const COORD coordBufferSize);
|
|
};
|
|
|
|
class ConversionAreaInfo final
|
|
{
|
|
public:
|
|
ConversionAreaInfo(const COORD bufferSize,
|
|
const COORD windowSize,
|
|
const TextAttribute& fill,
|
|
const TextAttribute& popupFill,
|
|
const FontInfo fontInfo);
|
|
~ConversionAreaInfo() = default;
|
|
ConversionAreaInfo(const ConversionAreaInfo&) = delete;
|
|
ConversionAreaInfo(ConversionAreaInfo&& other);
|
|
ConversionAreaInfo& operator=(const ConversionAreaInfo&) & = delete;
|
|
ConversionAreaInfo& operator=(ConversionAreaInfo&&) & = delete;
|
|
|
|
bool IsHidden() const noexcept;
|
|
void SetHidden(const bool fIsHidden) noexcept;
|
|
void ClearArea() noexcept;
|
|
|
|
[[nodiscard]] HRESULT Resize(const COORD newSize) noexcept;
|
|
|
|
void SetViewPos(const COORD pos) noexcept;
|
|
void SetWindowInfo(const SMALL_RECT view) noexcept;
|
|
void Paint() const noexcept;
|
|
|
|
void WriteText(const std::vector<OutputCell>& text, const SHORT column);
|
|
void SetAttributes(const TextAttribute& attr);
|
|
|
|
const TextBuffer& GetTextBuffer() const noexcept;
|
|
const ConversionAreaBufferInfo& GetAreaBufferInfo() const noexcept;
|
|
|
|
private:
|
|
ConversionAreaBufferInfo _caInfo;
|
|
std::unique_ptr<SCREEN_INFORMATION> _screenBuffer;
|
|
bool _isHidden;
|
|
};
|