2353349fe5
This commit introduces "AtlasEngine", a new text renderer based on DxEngine. But unlike it, DirectWrite and Direct2D are only used to rasterize glyphs. Blending and placing these glyphs into the target view is being done using Direct3D and a simple HLSL shader. Since this new renderer more aggressively assumes that the text is monospace, it simplifies the implementation: The viewport is divided into cells, and its data is stored as a simple matrix. Modifications to this matrix involve only simple pointer arithmetic and is easy to understand. But just like with DxEngine however, DirectWrite related code remains extremely complex and hard to understand. Supported features: * Basic text rendering with grayscale AA * Foreground and background colors * Emojis, including zero width joiners * Underline, dotted underline, strikethrough * Custom font axes and features * Selections * All cursor styles * Full alpha support for all colors * _Should_ work with Windows 7 Unsupported features: * A more conservative GPU memory usage The backing texture atlas for glyphs is grow-only and will not shrink. After 256MB of memory is used up (~20k glyphs) text output will be broken until the renderer is restarted. * ClearType * Remaining gridlines (left, right, top, bottom, double underline) * Hyperlinks don't get full underlines if hovered in WT * Softfonts * Non-default line renditions Performance: * Runs at up to native display refresh rate Unfortunately the frame rate often drops below refresh rate, due us fighting over the buffer lock with other parts of the application. * CPU consumption is up to halved compared to DxEngine AtlasEngine is still highly unoptimized. Glyph hashing consumes up to a third of the current CPU time. * No regressions in WT performance VT parsing and related buffer management takes up most of the CPU time (~85%), due to which the AtlasEngine can't show any further improvements. * ~2x improvement in raw text throughput in OpenConsole compared to DxEngine running at 144 FPS * ≥10x improvement in colored VT output in WT/OpenConsole compared to DxEngine running at 144 FPS
416 lines
18 KiB
C++
416 lines
18 KiB
C++
// Copyright (c) Microsoft Corporation.
|
|
// Licensed under the MIT license.
|
|
|
|
#include "pch.h"
|
|
#include "TerminalSettings.h"
|
|
#include "../../types/inc/colorTable.hpp"
|
|
|
|
#include "TerminalSettings.g.cpp"
|
|
#include "TerminalSettingsCreateResult.g.cpp"
|
|
|
|
using namespace winrt::Microsoft::Terminal::Control;
|
|
using namespace Microsoft::Console::Utils;
|
|
|
|
namespace winrt::Microsoft::Terminal::Settings::Model::implementation
|
|
{
|
|
static std::tuple<Windows::UI::Xaml::HorizontalAlignment, Windows::UI::Xaml::VerticalAlignment> ConvertConvergedAlignment(ConvergedAlignment alignment)
|
|
{
|
|
// extract horizontal alignment
|
|
Windows::UI::Xaml::HorizontalAlignment horizAlign;
|
|
switch (alignment & static_cast<ConvergedAlignment>(0x0F))
|
|
{
|
|
case ConvergedAlignment::Horizontal_Left:
|
|
horizAlign = Windows::UI::Xaml::HorizontalAlignment::Left;
|
|
break;
|
|
case ConvergedAlignment::Horizontal_Right:
|
|
horizAlign = Windows::UI::Xaml::HorizontalAlignment::Right;
|
|
break;
|
|
case ConvergedAlignment::Horizontal_Center:
|
|
default:
|
|
horizAlign = Windows::UI::Xaml::HorizontalAlignment::Center;
|
|
break;
|
|
}
|
|
|
|
// extract vertical alignment
|
|
Windows::UI::Xaml::VerticalAlignment vertAlign;
|
|
switch (alignment & static_cast<ConvergedAlignment>(0xF0))
|
|
{
|
|
case ConvergedAlignment::Vertical_Top:
|
|
vertAlign = Windows::UI::Xaml::VerticalAlignment::Top;
|
|
break;
|
|
case ConvergedAlignment::Vertical_Bottom:
|
|
vertAlign = Windows::UI::Xaml::VerticalAlignment::Bottom;
|
|
break;
|
|
case ConvergedAlignment::Vertical_Center:
|
|
default:
|
|
vertAlign = Windows::UI::Xaml::VerticalAlignment::Center;
|
|
break;
|
|
}
|
|
|
|
return { horizAlign, vertAlign };
|
|
}
|
|
|
|
// Method Description:
|
|
// - Create a TerminalSettingsCreateResult for the provided profile guid. We'll
|
|
// use the guid to look up the profile that should be used to
|
|
// create these TerminalSettings. Then, we'll apply settings contained in the
|
|
// global and profile settings to the instance.
|
|
// Arguments:
|
|
// - appSettings: the set of settings being used to construct the new terminal
|
|
// - profileGuid: the unique identifier (guid) of the profile
|
|
// - keybindings: the keybinding handler
|
|
// Return Value:
|
|
// - A TerminalSettingsCreateResult, which contains a pair of TerminalSettings objects,
|
|
// one for when the terminal is focused and the other for when the terminal is unfocused
|
|
Model::TerminalSettingsCreateResult TerminalSettings::CreateWithProfile(const Model::CascadiaSettings& appSettings, const Model::Profile& profile, const IKeyBindings& keybindings)
|
|
{
|
|
auto settings{ winrt::make_self<TerminalSettings>() };
|
|
settings->_KeyBindings = keybindings;
|
|
|
|
const auto globals = appSettings.GlobalSettings();
|
|
settings->_ApplyProfileSettings(profile);
|
|
settings->_ApplyGlobalSettings(globals);
|
|
settings->_ApplyAppearanceSettings(profile.DefaultAppearance(), globals.ColorSchemes());
|
|
|
|
Model::TerminalSettings child{ nullptr };
|
|
if (const auto& unfocusedAppearance{ profile.UnfocusedAppearance() })
|
|
{
|
|
auto childImpl = settings->CreateChild();
|
|
childImpl->_ApplyAppearanceSettings(unfocusedAppearance, globals.ColorSchemes());
|
|
child = *childImpl;
|
|
}
|
|
|
|
return winrt::make<TerminalSettingsCreateResult>(*settings, child);
|
|
}
|
|
|
|
// Method Description:
|
|
// - Create a TerminalSettings object for the provided newTerminalArgs. We'll
|
|
// use the newTerminalArgs to look up the profile that should be used to
|
|
// create these TerminalSettings. Then, we'll apply settings contained in the
|
|
// newTerminalArgs to the profile's settings, to enable customization on top
|
|
// of the profile's default values.
|
|
// Arguments:
|
|
// - appSettings: the set of settings being used to construct the new terminal
|
|
// - newTerminalArgs: An object that may contain a profile name or GUID to
|
|
// actually use. If the Profile value is not a guid, we'll treat it as a name,
|
|
// and attempt to look the profile up by name instead.
|
|
// * Additionally, we'll use other values (such as Commandline,
|
|
// StartingDirectory) in this object to override the settings directly from
|
|
// the profile.
|
|
// - keybindings: the keybinding handler
|
|
// Return Value:
|
|
// - A TerminalSettingsCreateResult object, which contains a pair of TerminalSettings
|
|
// objects. One for when the terminal is focused and one for when the terminal is unfocused.
|
|
Model::TerminalSettingsCreateResult TerminalSettings::CreateWithNewTerminalArgs(const CascadiaSettings& appSettings,
|
|
const NewTerminalArgs& newTerminalArgs,
|
|
const IKeyBindings& keybindings)
|
|
{
|
|
const auto profile = appSettings.GetProfileForArgs(newTerminalArgs);
|
|
auto settingsPair{ CreateWithProfile(appSettings, profile, keybindings) };
|
|
auto defaultSettings = settingsPair.DefaultSettings();
|
|
|
|
if (newTerminalArgs)
|
|
{
|
|
// Override commandline, starting directory if they exist in newTerminalArgs
|
|
if (!newTerminalArgs.Commandline().empty())
|
|
{
|
|
defaultSettings.Commandline(newTerminalArgs.Commandline());
|
|
}
|
|
if (!newTerminalArgs.StartingDirectory().empty())
|
|
{
|
|
defaultSettings.StartingDirectory(newTerminalArgs.StartingDirectory());
|
|
}
|
|
if (!newTerminalArgs.TabTitle().empty())
|
|
{
|
|
defaultSettings.StartingTitle(newTerminalArgs.TabTitle());
|
|
}
|
|
else
|
|
{
|
|
// There was no title, and no profile from which to infer the title.
|
|
// Per GH#6776, promote the first component of the command line to the title.
|
|
// This will ensure that the tab we spawn has a name (since it didn't get one from its profile!)
|
|
if (newTerminalArgs.Profile().empty() && !newTerminalArgs.Commandline().empty())
|
|
{
|
|
const std::wstring_view commandLine{ newTerminalArgs.Commandline() };
|
|
const auto start{ til::at(commandLine, 0) == L'"' ? 1 : 0 };
|
|
const auto terminator{ commandLine.find_first_of(start ? L'"' : L' ', start) }; // look past the first character if it starts with "
|
|
// We have to take a copy here; winrt::param::hstring requires a null-terminated string
|
|
const std::wstring firstComponent{ commandLine.substr(start, terminator - start) };
|
|
defaultSettings.StartingTitle(firstComponent);
|
|
}
|
|
}
|
|
if (newTerminalArgs.TabColor())
|
|
{
|
|
defaultSettings.StartingTabColor(winrt::Windows::Foundation::IReference<winrt::Microsoft::Terminal::Core::Color>{ til::color{ newTerminalArgs.TabColor().Value() } });
|
|
}
|
|
if (newTerminalArgs.SuppressApplicationTitle())
|
|
{
|
|
defaultSettings.SuppressApplicationTitle(newTerminalArgs.SuppressApplicationTitle().Value());
|
|
}
|
|
if (!newTerminalArgs.ColorScheme().empty())
|
|
{
|
|
const auto schemes = appSettings.GlobalSettings().ColorSchemes();
|
|
if (const auto& scheme = schemes.TryLookup(newTerminalArgs.ColorScheme()))
|
|
{
|
|
defaultSettings.ApplyColorScheme(scheme);
|
|
}
|
|
}
|
|
}
|
|
|
|
return settingsPair;
|
|
}
|
|
|
|
void TerminalSettings::_ApplyAppearanceSettings(const IAppearanceConfig& appearance, const Windows::Foundation::Collections::IMapView<winrt::hstring, ColorScheme>& schemes)
|
|
{
|
|
_CursorShape = appearance.CursorShape();
|
|
_CursorHeight = appearance.CursorHeight();
|
|
if (!appearance.ColorSchemeName().empty())
|
|
{
|
|
if (const auto scheme = schemes.TryLookup(appearance.ColorSchemeName()))
|
|
{
|
|
ApplyColorScheme(scheme);
|
|
}
|
|
}
|
|
if (appearance.Foreground())
|
|
{
|
|
_DefaultForeground = til::color{ appearance.Foreground().Value() };
|
|
}
|
|
if (appearance.Background())
|
|
{
|
|
_DefaultBackground = til::color{ appearance.Background().Value() };
|
|
}
|
|
if (appearance.SelectionBackground())
|
|
{
|
|
_SelectionBackground = til::color{ appearance.SelectionBackground().Value() };
|
|
}
|
|
if (appearance.CursorColor())
|
|
{
|
|
_CursorColor = til::color{ appearance.CursorColor().Value() };
|
|
}
|
|
if (!appearance.BackgroundImagePath().empty())
|
|
{
|
|
_BackgroundImage = appearance.ExpandedBackgroundImagePath();
|
|
}
|
|
|
|
_BackgroundImageOpacity = appearance.BackgroundImageOpacity();
|
|
_BackgroundImageStretchMode = appearance.BackgroundImageStretchMode();
|
|
std::tie(_BackgroundImageHorizontalAlignment, _BackgroundImageVerticalAlignment) = ConvertConvergedAlignment(appearance.BackgroundImageAlignment());
|
|
|
|
_RetroTerminalEffect = appearance.RetroTerminalEffect();
|
|
_PixelShaderPath = winrt::hstring{ wil::ExpandEnvironmentStringsW<std::wstring>(appearance.PixelShaderPath().c_str()) };
|
|
|
|
_IntenseIsBold = WI_IsFlagSet(appearance.IntenseTextStyle(), Microsoft::Terminal::Settings::Model::IntenseStyle::Bold);
|
|
_IntenseIsBright = WI_IsFlagSet(appearance.IntenseTextStyle(), Microsoft::Terminal::Settings::Model::IntenseStyle::Bright);
|
|
|
|
_AdjustIndistinguishableColors = appearance.AdjustIndistinguishableColors();
|
|
_Opacity = appearance.Opacity();
|
|
}
|
|
|
|
// Method Description:
|
|
// - Creates a TerminalSettingsCreateResult from a parent TerminalSettingsCreateResult
|
|
// - The returned defaultSettings inherits from the parent's defaultSettings, and the
|
|
// returned unfocusedSettings inherits from the returned defaultSettings
|
|
// - Note that the unfocused settings needs to be entirely unchanged _except_ we need to
|
|
// set its parent to the other settings object that we return. This is because the overrides
|
|
// made by the control will live in that other settings object, so we want to make
|
|
// sure the unfocused settings inherit from that.
|
|
// - Another way to think about this is that initially we have UnfocusedSettings inherit
|
|
// from DefaultSettings. This function simply adds another TerminalSettings object
|
|
// in the middle of these two, so UnfocusedSettings now inherits from the new object
|
|
// and the new object inherits from the DefaultSettings. And this new object is what
|
|
// the control can put overrides in.
|
|
// Arguments:
|
|
// - parent: the TerminalSettingsCreateResult that we create a new one from
|
|
// Return Value:
|
|
// - A TerminalSettingsCreateResult object that contains a defaultSettings that inherits
|
|
// from parent's defaultSettings, and contains an unfocusedSettings that inherits from
|
|
// its defaultSettings
|
|
Model::TerminalSettingsCreateResult TerminalSettings::CreateWithParent(const Model::TerminalSettingsCreateResult& parent)
|
|
{
|
|
THROW_HR_IF_NULL(E_INVALIDARG, parent);
|
|
|
|
auto defaultImpl{ get_self<TerminalSettings>(parent.DefaultSettings()) };
|
|
auto defaultChild = defaultImpl->CreateChild();
|
|
if (parent.UnfocusedSettings())
|
|
{
|
|
parent.UnfocusedSettings().SetParent(*defaultChild);
|
|
}
|
|
return winrt::make<TerminalSettingsCreateResult>(*defaultChild, parent.UnfocusedSettings());
|
|
}
|
|
|
|
// Method Description:
|
|
// - Sets our parent to the provided TerminalSettings
|
|
// Arguments:
|
|
// - parent: our new parent
|
|
void TerminalSettings::SetParent(const Model::TerminalSettings& parent)
|
|
{
|
|
ClearParents();
|
|
com_ptr<TerminalSettings> parentImpl;
|
|
parentImpl.copy_from(get_self<TerminalSettings>(parent));
|
|
InsertParent(parentImpl);
|
|
}
|
|
|
|
Model::TerminalSettings TerminalSettings::GetParent()
|
|
{
|
|
if (_parents.size() > 0)
|
|
{
|
|
return *_parents.at(0);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
// Method Description:
|
|
// - Apply Profile settings, as well as any colors from our color scheme, if we have one.
|
|
// Arguments:
|
|
// - profile: the profile settings we're applying
|
|
// - schemes: a map of schemes to look for our color scheme in, if we have one.
|
|
// Return Value:
|
|
// - <none>
|
|
void TerminalSettings::_ApplyProfileSettings(const Profile& profile)
|
|
{
|
|
// Fill in the Terminal Setting's CoreSettings from the profile
|
|
_HistorySize = profile.HistorySize();
|
|
_SnapOnInput = profile.SnapOnInput();
|
|
_AltGrAliasing = profile.AltGrAliasing();
|
|
|
|
// Fill in the remaining properties from the profile
|
|
_ProfileName = profile.Name();
|
|
_ProfileSource = profile.Source();
|
|
_UseAcrylic = profile.UseAcrylic();
|
|
|
|
_FontFace = profile.FontInfo().FontFace();
|
|
_FontSize = profile.FontInfo().FontSize();
|
|
_FontWeight = profile.FontInfo().FontWeight();
|
|
_FontFeatures = profile.FontInfo().FontFeatures();
|
|
_FontAxes = profile.FontInfo().FontAxes();
|
|
_Padding = profile.Padding();
|
|
|
|
_Commandline = profile.Commandline();
|
|
|
|
_StartingDirectory = profile.EvaluatedStartingDirectory();
|
|
|
|
// GH#2373: Use the tabTitle as the starting title if it exists, otherwise
|
|
// use the profile name
|
|
_StartingTitle = !profile.TabTitle().empty() ? profile.TabTitle() : profile.Name();
|
|
|
|
if (profile.SuppressApplicationTitle())
|
|
{
|
|
_SuppressApplicationTitle = profile.SuppressApplicationTitle();
|
|
}
|
|
|
|
_UseAtlasEngine = profile.UseAtlasEngine();
|
|
_ScrollState = profile.ScrollState();
|
|
|
|
_AntialiasingMode = profile.AntialiasingMode();
|
|
|
|
if (profile.TabColor())
|
|
{
|
|
const til::color colorRef{ profile.TabColor().Value() };
|
|
_TabColor = static_cast<winrt::Microsoft::Terminal::Core::Color>(colorRef);
|
|
}
|
|
}
|
|
|
|
// Method Description:
|
|
// - Applies appropriate settings from the globals into the TerminalSettings object.
|
|
// Arguments:
|
|
// - globalSettings: the global property values we're applying.
|
|
// Return Value:
|
|
// - <none>
|
|
void TerminalSettings::_ApplyGlobalSettings(const Model::GlobalAppSettings& globalSettings) noexcept
|
|
{
|
|
_InitialRows = globalSettings.InitialRows();
|
|
_InitialCols = globalSettings.InitialCols();
|
|
|
|
_WordDelimiters = globalSettings.WordDelimiters();
|
|
_CopyOnSelect = globalSettings.CopyOnSelect();
|
|
_FocusFollowMouse = globalSettings.FocusFollowMouse();
|
|
_ForceFullRepaintRendering = globalSettings.ForceFullRepaintRendering();
|
|
_SoftwareRendering = globalSettings.SoftwareRendering();
|
|
_ForceVTInput = globalSettings.ForceVTInput();
|
|
_TrimBlockSelection = globalSettings.TrimBlockSelection();
|
|
_DetectURLs = globalSettings.DetectURLs();
|
|
}
|
|
|
|
// Method Description:
|
|
// - Apply a given ColorScheme's values to the TerminalSettings object.
|
|
// Sets the foreground, background, and color table of the settings object.
|
|
// Arguments:
|
|
// - scheme: the ColorScheme we are applying to the TerminalSettings object
|
|
// Return Value:
|
|
// - <none>
|
|
void TerminalSettings::ApplyColorScheme(const Model::ColorScheme& scheme)
|
|
{
|
|
// If the scheme was nullptr, then just clear out the current color
|
|
// settings.
|
|
if (scheme == nullptr)
|
|
{
|
|
ClearAppliedColorScheme();
|
|
ClearDefaultForeground();
|
|
ClearDefaultBackground();
|
|
ClearSelectionBackground();
|
|
ClearCursorColor();
|
|
_ColorTable = std::nullopt;
|
|
}
|
|
else
|
|
{
|
|
AppliedColorScheme(scheme);
|
|
_DefaultForeground = til::color{ scheme.Foreground() };
|
|
_DefaultBackground = til::color{ scheme.Background() };
|
|
_SelectionBackground = til::color{ scheme.SelectionBackground() };
|
|
_CursorColor = til::color{ scheme.CursorColor() };
|
|
|
|
const auto table = scheme.Table();
|
|
std::array<winrt::Microsoft::Terminal::Core::Color, COLOR_TABLE_SIZE> colorTable{};
|
|
std::transform(table.cbegin(), table.cend(), colorTable.begin(), [](auto&& color) {
|
|
return static_cast<winrt::Microsoft::Terminal::Core::Color>(til::color{ color });
|
|
});
|
|
ColorTable(colorTable);
|
|
}
|
|
}
|
|
|
|
winrt::Microsoft::Terminal::Core::Color TerminalSettings::GetColorTableEntry(int32_t index) noexcept
|
|
{
|
|
return ColorTable().at(index);
|
|
}
|
|
|
|
void TerminalSettings::ColorTable(std::array<winrt::Microsoft::Terminal::Core::Color, 16> colors)
|
|
{
|
|
_ColorTable = colors;
|
|
}
|
|
|
|
std::array<winrt::Microsoft::Terminal::Core::Color, COLOR_TABLE_SIZE> TerminalSettings::ColorTable()
|
|
{
|
|
auto span = _getColorTableImpl();
|
|
std::array<winrt::Microsoft::Terminal::Core::Color, COLOR_TABLE_SIZE> colorTable{};
|
|
if (span.size() > 0)
|
|
{
|
|
std::copy(span.begin(), span.end(), colorTable.begin());
|
|
}
|
|
else
|
|
{
|
|
const auto campbellSpan = CampbellColorTable();
|
|
std::transform(campbellSpan.begin(), campbellSpan.end(), colorTable.begin(), [](auto&& color) {
|
|
return static_cast<winrt::Microsoft::Terminal::Core::Color>(til::color{ color });
|
|
});
|
|
}
|
|
return colorTable;
|
|
}
|
|
|
|
gsl::span<winrt::Microsoft::Terminal::Core::Color> TerminalSettings::_getColorTableImpl()
|
|
{
|
|
if (_ColorTable.has_value())
|
|
{
|
|
return gsl::make_span(*_ColorTable);
|
|
}
|
|
for (auto&& parent : _parents)
|
|
{
|
|
auto parentSpan = parent->_getColorTableImpl();
|
|
if (parentSpan.size() > 0)
|
|
{
|
|
return parentSpan;
|
|
}
|
|
}
|
|
return {};
|
|
}
|
|
}
|