Or, as a slider

This commit is contained in:
Mike Griese
2026-10-16 12:41:03 -05:00
parent da0ab93d8b
commit 45a2dbbe43
17 changed files with 288 additions and 60 deletions

View File

@@ -3250,10 +3250,15 @@
"description": "When set to true, the window will scroll to the command input line when typing. When set to false, the window will not scroll when you start typing.",
"type": "boolean"
},
"allowCursorBlinking": {
"default": true,
"description": "Allows the cursor to blink when requested by the application and enabled in Windows. When false, the cursor does not blink, but the application can still show or hide it. Changes apply immediately to running terminals.",
"type": "boolean"
"cursorBlinkInterval": {
"default": null,
"description": "Time in milliseconds between cursor visibility changes while blinking. Null uses the Windows cursor blink settings; 0 disables blinking. A positive value overrides the Windows interval, but applications can still request a steady cursor or hide it. Values above 10000 are clamped to 10000. Changes apply immediately to running terminals.",
"minimum": 0,
"maximum": 10000,
"type": [
"integer",
"null"
]
},
"altGrAliasing": {
"default": true,

View File

@@ -119,7 +119,7 @@ namespace Microsoft.Terminal.Core
Int32 InitialCols { get; };
Boolean SnapOnInput { get; };
Boolean AllowCursorBlinking { get; };
Windows.Foundation.IReference<UInt32> CursorBlinkInterval { get; };
Boolean AltGrAliasing { get; };
String AnswerbackMessage { get; };

View File

@@ -106,6 +106,11 @@ void Terminal::UpdateSettings(ICoreSettings settings)
_rainbowSuggestions = settings.RainbowSuggestions();
_clipboardOperationsAllowed = settings.AllowVtClipboardWrite();
const auto cursorBlinkInterval = settings.CursorBlinkInterval();
_cursorBlinkIntervalOverride = cursorBlinkInterval ?
std::optional<TimerDuration>{ std::chrono::milliseconds{ std::min(cursorBlinkInterval.Value(), 10000u) } } :
std::nullopt;
if (_stateMachine)
{
SetOptionalFeatures(settings);
@@ -145,7 +150,7 @@ void Terminal::UpdateSettings(ICoreSettings settings)
// Regenerate the pattern tree for the new buffer size
if (_mainBuffer)
{
_mainBuffer->GetRenderer()->AllowCursorBlinking(InhibitionSource::User, settings.AllowCursorBlinking());
_mainBuffer->NotifyPaintFrame();
// Clear the patterns first
_detectURLs = settings.DetectURLs();

View File

@@ -364,6 +364,7 @@ private:
CursorType _defaultCursorShape = CursorType::Legacy;
std::optional<Microsoft::Console::Render::TimerDuration> _cursorBlinkInterval;
std::optional<Microsoft::Console::Render::TimerDuration> _cursorBlinkIntervalOverride;
til::enumset<Mode> _systemMode{ Mode::AutoWrap };

View File

@@ -40,6 +40,11 @@ void Terminal::SetFontInfo(const FontInfo& fontInfo)
TimerDuration Terminal::GetBlinkInterval() noexcept
{
if (_cursorBlinkIntervalOverride)
{
return *_cursorBlinkIntervalOverride;
}
if (!_cursorBlinkInterval)
{
const auto enabled = GetSystemMetrics(SM_CARETBLINKINGENABLED);

View File

@@ -305,7 +305,7 @@ namespace winrt::Microsoft::Terminal::Settings
// Fill in the Terminal Setting's CoreSettings from the profile
_HistorySize = profile.HistorySize();
_SnapOnInput = profile.SnapOnInput();
_AllowCursorBlinking = profile.AllowCursorBlinking();
_CursorBlinkInterval = profile.CursorBlinkInterval();
_AltGrAliasing = profile.AltGrAliasing();
_AnswerbackMessage = profile.AnswerbackMessage();

View File

@@ -580,15 +580,30 @@
<TextBlock x:Uid="Profile_CursorHeader"
Style="{StaticResource TextBlockSubHeaderStyle}" />
<StackPanel Style="{StaticResource SettingsStackStyle}">
<local:SettingsCard x:Name="AllowCursorBlinking"
x:Uid="Profile_AllowCursorBlinking"
<local:SettingsCard x:Name="CursorBlinkInterval"
x:Uid="Profile_CursorBlinkInterval"
Style="{StaticResource ExpanderAlignedSettingsCardStyle}"
Visibility="{x:Bind Appearance.IsDefault, Mode=OneWay}">
<StackPanel Style="{StaticResource SettingControlStackStyle}">
<ToggleSwitch VerticalAlignment="Center"
IsOn="{x:Bind SourceProfile.AllowCursorBlinking, Mode=TwoWay}"
Style="{StaticResource ToggleSwitchInExpanderStyle}" />
<local:SettingResetButton SettingName="AllowCursorBlinking"
<StackPanel Spacing="8">
<ComboBox x:Uid="Profile_CursorBlinkMode"
SelectedIndex="{x:Bind SourceProfile.CursorBlinkModeIndex, Mode=TwoWay}"
Style="{StaticResource ComboBoxSettingStyle}">
<ComboBoxItem x:Uid="Profile_CursorBlinkModeSystem" />
<ComboBoxItem x:Uid="Profile_CursorBlinkModeDisabled" />
<ComboBoxItem x:Uid="Profile_CursorBlinkModeCustom" />
</ComboBox>
<muxc:NumberBox x:Uid="Profile_CursorBlinkIntervalBox"
LargeChange="100"
Maximum="10000"
Minimum="1"
SmallChange="50"
Style="{StaticResource NumberBoxSettingStyle}"
Visibility="{x:Bind SourceProfile.UseCustomCursorBlinkInterval, Mode=OneWay}"
Value="{x:Bind SourceProfile.CursorBlinkIntervalValue, Mode=TwoWay}" />
</StackPanel>
<local:SettingResetButton VerticalAlignment="Top"
SettingName="CursorBlinkInterval"
Target="{x:Bind SourceProfile}" />
</StackPanel>
</local:SettingsCard>

View File

@@ -60,6 +60,10 @@ namespace winrt::Microsoft::Terminal::Settings::Editor::implementation
// NOTE: this is similar to what is done with BackgroundImagePath above
_NotifyChanges(L"UseParentProcessDirectory", L"CurrentStartingDirectoryPreview");
}
else if (viewModelProperty == L"CursorBlinkInterval")
{
_NotifyChanges(L"CursorBlinkModeIndex", L"UseCustomCursorBlinkInterval", L"CursorBlinkIntervalValue");
}
else if (viewModelProperty == L"AntialiasingMode")
{
_NotifyChanges(L"CurrentAntiAliasingMode");
@@ -159,6 +163,63 @@ namespace winrt::Microsoft::Terminal::Settings::Editor::implementation
_defaultAppearanceViewModel.IsDefault(true);
}
int32_t ProfileViewModel::CursorBlinkModeIndex() const
{
const auto interval = CursorBlinkInterval();
if (!interval)
{
return 0;
}
return interval.Value() == 0 ? 1 : 2;
}
void ProfileViewModel::CursorBlinkModeIndex(const int32_t index)
{
if (index == CursorBlinkModeIndex())
{
return;
}
_lastCursorBlinkInterval = static_cast<uint32_t>(CursorBlinkIntervalValue());
switch (index)
{
case 0:
CursorBlinkInterval(nullptr);
break;
case 1:
CursorBlinkInterval(IReference<uint32_t>{ 0u });
break;
case 2:
CursorBlinkInterval(IReference<uint32_t>{ _lastCursorBlinkInterval });
break;
}
}
bool ProfileViewModel::UseCustomCursorBlinkInterval() const
{
return CursorBlinkModeIndex() == 2;
}
double ProfileViewModel::CursorBlinkIntervalValue() const
{
const auto interval = CursorBlinkInterval();
return interval && interval.Value() != 0 ? std::min(interval.Value(), 10000u) : _lastCursorBlinkInterval;
}
void ProfileViewModel::CursorBlinkIntervalValue(const double value)
{
// Clearing a NumberBox produces NaN; restore the current interval instead.
if (UseCustomCursorBlinkInterval() && !std::isnan(value))
{
_lastCursorBlinkInterval = static_cast<uint32_t>(std::clamp(value, 1.0, 10000.0));
// Two-way binding also writes back on model changes. Preserve inherited values.
if (CursorBlinkIntervalValue() != _lastCursorBlinkInterval)
{
CursorBlinkInterval(IReference<uint32_t>{ _lastCursorBlinkInterval });
}
}
_NotifyChanges(L"CursorBlinkIntervalValue");
}
void ProfileViewModel::LeftPadding(double value) noexcept
{
if (std::abs(_parsedPadding.Left - value) >= .0001)

View File

@@ -90,6 +90,12 @@ namespace winrt::Microsoft::Terminal::Settings::Editor::implementation
bool UseParentProcessDirectory() const;
void UseParentProcessDirectory(const bool useParent);
int32_t CursorBlinkModeIndex() const;
void CursorBlinkModeIndex(int32_t index);
bool UseCustomCursorBlinkInterval() const;
double CursorBlinkIntervalValue() const;
void CursorBlinkIntervalValue(double value);
// general profile knowledge
winrt::guid OriginalProfileGuid() const noexcept;
bool CanDeleteProfile() const;
@@ -147,7 +153,7 @@ namespace winrt::Microsoft::Terminal::Settings::Editor::implementation
X(_profile.DefaultAppearance(), UseAcrylic) \
X(_profile, HistorySize) \
X(_profile, SnapOnInput) \
X(_profile, AllowCursorBlinking) \
X(_profile, CursorBlinkInterval) \
X(_profile, AltGrAliasing) \
X(_profile, BellStyle) \
X(_profile, BellSound) \
@@ -184,6 +190,7 @@ namespace winrt::Microsoft::Terminal::Settings::Editor::implementation
winrt::guid _originalProfileGuid{};
winrt::hstring _lastBgImagePath;
winrt::hstring _lastStartingDirectoryPath;
uint32_t _lastCursorBlinkInterval{ 500 };
Editor::AppearanceViewModel _defaultAppearanceViewModel;
Windows::UI::Core::CoreDispatcher _dispatcher;

View File

@@ -80,6 +80,10 @@ namespace Microsoft.Terminal.Settings.Editor
String CurrentStartingDirectoryPreview { get; };
Boolean UseParentProcessDirectory;
Int32 CursorBlinkModeIndex;
Boolean UseCustomCursorBlinkInterval { get; };
Double CursorBlinkIntervalValue;
Boolean CanDeleteProfile { get; };
Boolean FocusDeleteButton;
Boolean IsBaseLayer;
@@ -132,7 +136,7 @@ namespace Microsoft.Terminal.Settings.Editor
OBSERVABLE_PROJECTED_PROFILE_SETTING(Microsoft.Terminal.Control.TextAntialiasingMode, AntialiasingMode);
OBSERVABLE_PROJECTED_PROFILE_SETTING(Int32, HistorySize);
OBSERVABLE_PROJECTED_PROFILE_SETTING(Boolean, SnapOnInput);
OBSERVABLE_PROJECTED_PROFILE_SETTING(Boolean, AllowCursorBlinking);
OBSERVABLE_PROJECTED_PROFILE_SETTING(Windows.Foundation.IReference<UInt32>, CursorBlinkInterval);
OBSERVABLE_PROJECTED_PROFILE_SETTING(Boolean, AltGrAliasing);
OBSERVABLE_PROJECTED_PROFILE_SETTING(Microsoft.Terminal.Settings.Model.BellStyle, BellStyle);
OBSERVABLE_PROJECTED_PROFILE_SETTING(Windows.Foundation.Collections.IVector<Microsoft.Terminal.Settings.Model.IMediaResource>, BellSound);

View File

@@ -911,13 +911,37 @@
<value>Browse...</value>
<comment>Button label that opens a file picker in a new window. The "..." is standard to mean it will open a new window.</comment>
</data>
<data name="Profile_AllowCursorBlinking.Header" xml:space="preserve">
<value>Allow blinking</value>
<comment>Header for a toggle in the Cursor section that allows the text cursor to blink.</comment>
<data name="Profile_CursorBlinkInterval.Header" xml:space="preserve">
<value>Cursor blinking</value>
<comment>Header for the cursor blink interval setting in the Cursor section.</comment>
</data>
<data name="Profile_AllowCursorBlinking.Description" xml:space="preserve">
<value>Allow the cursor to blink when requested by the application and enabled in Windows. When disabled, applications can still show or hide the cursor.</value>
<comment>Description for the cursor blinking override.</comment>
<data name="Profile_CursorBlinkInterval.Description" xml:space="preserve">
<value>Use the Windows setting, disable blinking, or set a custom interval. Applications can still request a steady cursor or hide it.</value>
<comment>Description for the cursor blink interval override.</comment>
</data>
<data name="Profile_CursorBlinkMode.[using:Windows.UI.Xaml.Automation]AutomationProperties.Name" xml:space="preserve">
<value>Cursor blinking</value>
<comment>Accessible name for the cursor blinking mode dropdown.</comment>
</data>
<data name="Profile_CursorBlinkModeSystem.Content" xml:space="preserve">
<value>Use Windows setting</value>
<comment>Cursor blinking option that follows the system blink interval, including disabled blinking.</comment>
</data>
<data name="Profile_CursorBlinkModeDisabled.Content" xml:space="preserve">
<value>Disabled (steady cursor)</value>
<comment>Cursor blinking option that disables blinking without changing cursor visibility.</comment>
</data>
<data name="Profile_CursorBlinkModeCustom.Content" xml:space="preserve">
<value>Custom interval</value>
<comment>Cursor blinking option that exposes a custom interval in milliseconds.</comment>
</data>
<data name="Profile_CursorBlinkIntervalBox.[using:Windows.UI.Xaml.Automation]AutomationProperties.Name" xml:space="preserve">
<value>Cursor blink interval (milliseconds)</value>
<comment>Accessible name for the custom cursor blink interval input.</comment>
</data>
<data name="Profile_CursorBlinkIntervalBox.Header" xml:space="preserve">
<value>Interval (ms)</value>
<comment>Label for the custom cursor blink interval input. The interval is the time between visibility changes, not a full blink cycle.</comment>
</data>
<data name="Profile_CursorHeight.Header" xml:space="preserve">
<value>Cursor height</value>

View File

@@ -92,7 +92,7 @@ Author(s):
#define MTSM_PROFILE_SETTINGS(X) \
X(int32_t, HistorySize, "historySize", DEFAULT_HISTORY_SIZE) \
X(bool, SnapOnInput, "snapOnInput", true) \
X(bool, AllowCursorBlinking, "allowCursorBlinking", true) \
X(Windows::Foundation::IReference<uint32_t>, CursorBlinkInterval, "cursorBlinkInterval", nullptr) \
X(bool, AltGrAliasing, "altGrAliasing", true) \
X(hstring, AnswerbackMessage, "answerbackMessage") \
X(hstring, Commandline, "commandline", L"%SystemRoot%\\System32\\cmd.exe") \

View File

@@ -71,7 +71,7 @@ namespace Microsoft.Terminal.Settings.Model
INHERITABLE_PROFILE_SETTING(Int32, HistorySize);
INHERITABLE_PROFILE_SETTING(Boolean, SnapOnInput);
INHERITABLE_PROFILE_SETTING(Boolean, AllowCursorBlinking);
INHERITABLE_PROFILE_SETTING(Windows.Foundation.IReference<UInt32>, CursorBlinkInterval);
INHERITABLE_PROFILE_SETTING(Boolean, AltGrAliasing);
INHERITABLE_PROFILE_SETTING(String, AnswerbackMessage);
INHERITABLE_PROFILE_SETTING(BellStyle, BellStyle);

View File

@@ -672,49 +672,67 @@ namespace SettingsModelUnitTests
void TerminalSettingsTests::CursorBlinkingProfileSetting()
{
VERIFY_IS_TRUE(winrt::make<implementation::Profile>().AllowCursorBlinking());
VERIFY_IS_NULL(winrt::make<implementation::Profile>().CursorBlinkInterval());
static constexpr std::string_view settingsJson{ R"({
"profiles": {
"defaults": {
"allowCursorBlinking": false,
"cursorBlinkInterval": 0,
"unfocusedAppearance": {}
},
"list": [
{ "name": "inherited" },
{ "name": "overridden", "allowCursorBlinking": true }
{ "name": "custom", "cursorBlinkInterval": 275 },
{ "name": "system", "cursorBlinkInterval": null },
{ "name": "disabled", "cursorBlinkInterval": 0 }
]
}
})" };
const auto settings = winrt::make_self<implementation::CascadiaSettings>(settingsJson);
VERIFY_ARE_EQUAL(2u, settings->ActiveProfiles().Size());
VERIFY_ARE_EQUAL(4u, settings->ActiveProfiles().Size());
const auto defaultsJson = winrt::get_self<implementation::Profile>(settings->ProfileDefaults())->ToJson();
VERIFY_IS_TRUE(defaultsJson.isMember("allowCursorBlinking"));
VERIFY_IS_FALSE(defaultsJson["allowCursorBlinking"].asBool());
VERIFY_IS_TRUE(defaultsJson.isMember("cursorBlinkInterval"));
VERIFY_ARE_EQUAL(0u, defaultsJson["cursorBlinkInterval"].asUInt());
for (auto i = 0u; i < 2u; ++i)
{
const auto profile = settings->ActiveProfiles().GetAt(i);
const auto expected = i == 1;
VERIFY_ARE_EQUAL(expected, profile.AllowCursorBlinking());
VERIFY_ARE_EQUAL(expected, profile.HasAllowCursorBlinking());
const auto json = winrt::get_self<implementation::Profile>(profile)->ToJson();
VERIFY_ARE_EQUAL(expected, json.isMember("allowCursorBlinking"));
const std::array<std::optional<uint32_t>, 4> intervals{ 0u, 275u, std::nullopt, 0u };
const auto verifyInterval = [](const std::optional<uint32_t> expected, const winrt::Windows::Foundation::IReference<uint32_t>& actual) {
VERIFY_ARE_EQUAL(expected.has_value(), static_cast<bool>(actual));
if (expected)
{
VERIFY_IS_TRUE(json["allowCursorBlinking"].asBool());
VERIFY_ARE_EQUAL(*expected, actual.Value());
}
};
for (auto i = 0u; i < intervals.size(); ++i)
{
const auto profile = settings->ActiveProfiles().GetAt(i);
const auto expected = intervals[i];
verifyInterval(expected, profile.CursorBlinkInterval());
VERIFY_ARE_EQUAL(i != 0, profile.HasCursorBlinkInterval());
const auto json = winrt::get_self<implementation::Profile>(profile)->ToJson();
VERIFY_ARE_EQUAL(i != 0, json.isMember("cursorBlinkInterval"));
if (i != 0)
{
if (expected)
{
VERIFY_ARE_EQUAL(*expected, json["cursorBlinkInterval"].asUInt());
}
else
{
VERIFY_IS_TRUE(json["cursorBlinkInterval"].isNull());
}
verifyInterval(expected, implementation::Profile::FromJson(json)->CursorBlinkInterval());
}
const auto result = TerminalSettings::CreateWithProfile(*settings, settings->WindowSettingsDefaults(), profile);
VERIFY_ARE_EQUAL(expected, result.DefaultSettings()->AllowCursorBlinking());
verifyInterval(expected, result.DefaultSettings()->CursorBlinkInterval());
VERIFY_IS_NOT_NULL(result.UnfocusedSettings());
VERIFY_ARE_EQUAL(expected, result.UnfocusedSettings()->AllowCursorBlinking());
verifyInterval(expected, result.UnfocusedSettings()->CursorBlinkInterval());
profile.ClearAllowCursorBlinking();
VERIFY_IS_FALSE(profile.AllowCursorBlinking());
VERIFY_IS_FALSE(profile.HasAllowCursorBlinking());
profile.ClearCursorBlinkInterval();
verifyInterval(0u, profile.CursorBlinkInterval());
VERIFY_IS_FALSE(profile.HasCursorBlinkInterval());
}
}

View File

@@ -29,6 +29,7 @@ namespace TerminalCoreUnitTests
TEST_METHOD(CursorVisibilityViaStateMachine);
TEST_METHOD(CursorBlinkingOverride);
TEST_METHOD(CursorBlinkingDisabledOnCreation);
TEST_METHOD(CursorBlinkIntervalHotReload);
// Terminal::_WriteBuffer used to enter infinite loops under certain conditions.
// This test ensures that Terminal::_WriteBuffer doesn't get stuck when
@@ -182,7 +183,7 @@ void TerminalApiTest::CursorBlinkingOverride()
Terminal term{ Terminal::TestDummyMarker{} };
DummyRenderer renderer{ &term };
auto settings = winrt::make_self<MockTermSettings>(0, 100, 100);
VERIFY_IS_TRUE(settings->AllowCursorBlinking());
VERIFY_IS_NULL(settings->CursorBlinkInterval());
term.CreateFromSettings(*settings, renderer);
term._cursorBlinkInterval = std::chrono::milliseconds{ 500 };
renderer._viewport = term.GetViewport();
@@ -203,7 +204,7 @@ void TerminalApiTest::CursorBlinkingOverride()
// Reload while the cursor is in its off phase.
renderer._cursorBlinkerOn = false;
settings->AllowCursorBlinking(false);
settings->CursorBlinkInterval(uint32_t{ 0 });
term.UpdateSettings(*settings);
verifyCursor(false, true);
VERIFY_IS_TRUE(term.GetTextBuffer().GetCursor().IsBlinking());
@@ -215,64 +216,145 @@ void TerminalApiTest::CursorBlinkingOverride()
stateMachine.ProcessString(L"\x1b[?12l");
verifyCursor(false, true);
settings->AllowCursorBlinking(true);
settings->CursorBlinkInterval(nullptr);
term.UpdateSettings(*settings);
verifyCursor(false, true);
VERIFY_IS_FALSE(term.GetTextBuffer().GetCursor().IsBlinking());
stateMachine.ProcessString(L"\x1b[?12h");
verifyCursor(true, true);
settings->AllowCursorBlinking(false);
settings->CursorBlinkInterval(uint32_t{ 0 });
term.UpdateSettings(*settings);
stateMachine.ProcessString(L"\x1b[2 q");
verifyCursor(false, true);
settings->AllowCursorBlinking(true);
settings->CursorBlinkInterval(nullptr);
term.UpdateSettings(*settings);
verifyCursor(false, true);
settings->AllowCursorBlinking(false);
settings->CursorBlinkInterval(uint32_t{ 0 });
term.UpdateSettings(*settings);
stateMachine.ProcessString(L"\x1b[1 q");
verifyCursor(false, true);
VERIFY_IS_TRUE(term.GetTextBuffer().GetCursor().IsBlinking());
stateMachine.ProcessString(L"\x1b[?25l");
settings->AllowCursorBlinking(true);
settings->CursorBlinkInterval(nullptr);
term.UpdateSettings(*settings);
verifyCursor(false, false);
stateMachine.ProcessString(L"\x1b[?25h");
verifyCursor(true, true);
settings->AllowCursorBlinking(false);
settings->CursorBlinkInterval(uint32_t{ 0 });
term.UpdateSettings(*settings);
stateMachine.ProcessString(L"\x1b" L"c");
stateMachine.ProcessString(L"\x1b"
L"c");
verifyCursor(false, true);
stateMachine.ProcessString(L"\x1b[?1049h");
verifyCursor(false, true);
stateMachine.ProcessString(L"\x1b[?1049l");
verifyCursor(false, true);
stateMachine.ProcessString(L"\x1b[?1049h");
settings->AllowCursorBlinking(true);
settings->CursorBlinkInterval(nullptr);
term.UpdateSettings(*settings);
verifyCursor(true, true);
stateMachine.ProcessString(L"\x1b[?1049l");
verifyCursor(true, true);
renderer.AllowCursorVisibility(InhibitionSource::Host, false);
settings->AllowCursorBlinking(false);
settings->CursorBlinkInterval(uint32_t{ 0 });
term.UpdateSettings(*settings);
verifyCursor(false, false);
renderer.AllowCursorVisibility(InhibitionSource::Host, true);
verifyCursor(false, true);
term._cursorBlinkInterval = TimerDuration::max();
settings->AllowCursorBlinking(true);
settings->CursorBlinkInterval(nullptr);
term.UpdateSettings(*settings);
verifyCursor(false, true);
term._cursorBlinkInterval = std::chrono::milliseconds{ 500 };
verifyCursor(true, true);
}
void TerminalApiTest::CursorBlinkIntervalHotReload()
{
using namespace Microsoft::Console::Render;
using namespace std::chrono_literals;
Terminal term{ Terminal::TestDummyMarker{} };
DummyRenderer renderer{ &term };
auto settings = winrt::make_self<MockTermSettings>(0, 100, 100);
settings->CursorBlinkInterval(uint32_t{ 250 });
term.CreateFromSettings(*settings, renderer);
term._cursorBlinkInterval = 500ms;
renderer._viewport = term.GetViewport();
renderer.AllowCursorVisibility(InhibitionSource::Host, true);
const auto verifyInterval = [&](const uint32_t milliseconds) {
renderer._updateCursorInfo();
VERIFY_IS_TRUE(term.GetBlinkInterval() == std::chrono::milliseconds{ milliseconds });
VERIFY_IS_TRUE(renderer.GetTimerInterval(renderer._cursorBlinker) == std::chrono::milliseconds{ milliseconds });
VERIFY_IS_TRUE(renderer.IsTimerRunning(renderer._cursorBlinker));
};
verifyInterval(250);
// Change a running timer without output or cursor mutations.
renderer._redraw.store(false, std::memory_order_relaxed);
settings->CursorBlinkInterval(uint32_t{ 750 });
term.UpdateSettings(*settings);
VERIFY_IS_TRUE(renderer._redraw.load(std::memory_order_relaxed));
verifyInterval(750);
renderer._cursorBlinkerOn = false;
settings->CursorBlinkInterval(uint32_t{ 0 });
term.UpdateSettings(*settings);
renderer._updateCursorInfo();
VERIFY_IS_FALSE(renderer.IsTimerRunning(renderer._cursorBlinker));
VERIFY_IS_TRUE(renderer._currentCursorOptions.isOn);
settings->CursorBlinkInterval(uint32_t{ 750 });
term.UpdateSettings(*settings);
verifyInterval(750);
settings->CursorBlinkInterval(nullptr);
term.UpdateSettings(*settings);
verifyInterval(500);
// A custom interval overrides Windows disabling blinking.
term._cursorBlinkInterval = TimerDuration::max();
renderer._updateCursorInfo();
VERIFY_IS_FALSE(renderer.IsTimerRunning(renderer._cursorBlinker));
VERIFY_IS_TRUE(renderer._currentCursorOptions.isOn);
settings->CursorBlinkInterval(uint32_t{ 250 });
term.UpdateSettings(*settings);
verifyInterval(250);
std::ignore = term.FocusChanged(true);
verifyInterval(250);
term._stateMachine->ProcessString(L"\x1b[?1049h");
settings->CursorBlinkInterval(uint32_t{ 10000 });
term.UpdateSettings(*settings);
verifyInterval(10000);
term._stateMachine->ProcessString(L"\x1b[?1049l");
verifyInterval(10000);
settings->CursorBlinkInterval(UINT32_MAX);
term.UpdateSettings(*settings);
verifyInterval(10000);
settings->CursorBlinkInterval(uint32_t{ 1 });
term.UpdateSettings(*settings);
verifyInterval(1);
term._stateMachine->ProcessString(L"\x1b[?12l");
settings->CursorBlinkInterval(uint32_t{ 250 });
term.UpdateSettings(*settings);
renderer._updateCursorInfo();
VERIFY_IS_FALSE(renderer.IsTimerRunning(renderer._cursorBlinker));
VERIFY_IS_TRUE(renderer._currentCursorOptions.isOn);
term._stateMachine->ProcessString(L"\x1b[?12h");
verifyInterval(250);
}
void TerminalApiTest::CursorBlinkingDisabledOnCreation()
{
using namespace Microsoft::Console::Render;
@@ -280,7 +362,7 @@ void TerminalApiTest::CursorBlinkingDisabledOnCreation()
Terminal term{ Terminal::TestDummyMarker{} };
DummyRenderer renderer{ &term };
auto settings = winrt::make_self<MockTermSettings>(0, 100, 100);
settings->AllowCursorBlinking(false);
settings->CursorBlinkInterval(uint32_t{ 0 });
term.CreateFromSettings(*settings, renderer);
renderer._viewport = term.GetViewport();
renderer.AllowCursorVisibility(InhibitionSource::Host, true);

View File

@@ -37,7 +37,7 @@
X(int32_t, InitialRows, 30) \
X(int32_t, InitialCols, 80) \
X(bool, SnapOnInput, true) \
X(bool, AllowCursorBlinking, true) \
X(winrt::Windows::Foundation::IReference<uint32_t>, CursorBlinkInterval, nullptr) \
X(bool, AltGrAliasing, true) \
X(winrt::hstring, AnswerbackMessage) \
X(winrt::hstring, WordDelimiters, DEFAULT_WORD_DELIMITERS) \

View File

@@ -1599,7 +1599,7 @@ void Renderer::_updateCursorInfo()
{
StopTimer(_cursorBlinker);
}
else if (!IsTimerRunning(_cursorBlinker))
else
{
const auto actual = GetTimerInterval(_cursorBlinker);
const auto expected = _pData->GetBlinkInterval();
@@ -1613,7 +1613,8 @@ void Renderer::_updateCursorInfo()
}
else
{
// If blinking is disabled due to the OS settings, then we force-enable it.
StopTimer(_cursorBlinker);
// A disabled blink interval means steady-on, not frozen in the off phase.
_cursorBlinkerOn = true;
}
}