diff --git a/doc/cascadia/profiles.schema.json b/doc/cascadia/profiles.schema.json index 03c57b649e..4b6ac02710 100644 --- a/doc/cascadia/profiles.schema.json +++ b/doc/cascadia/profiles.schema.json @@ -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, diff --git a/src/cascadia/TerminalCore/ICoreSettings.idl b/src/cascadia/TerminalCore/ICoreSettings.idl index 47ae7f403e..2c12804910 100644 --- a/src/cascadia/TerminalCore/ICoreSettings.idl +++ b/src/cascadia/TerminalCore/ICoreSettings.idl @@ -119,7 +119,7 @@ namespace Microsoft.Terminal.Core Int32 InitialCols { get; }; Boolean SnapOnInput { get; }; - Boolean AllowCursorBlinking { get; }; + Windows.Foundation.IReference CursorBlinkInterval { get; }; Boolean AltGrAliasing { get; }; String AnswerbackMessage { get; }; diff --git a/src/cascadia/TerminalCore/Terminal.cpp b/src/cascadia/TerminalCore/Terminal.cpp index 5051178c3d..23b7812790 100644 --- a/src/cascadia/TerminalCore/Terminal.cpp +++ b/src/cascadia/TerminalCore/Terminal.cpp @@ -106,6 +106,11 @@ void Terminal::UpdateSettings(ICoreSettings settings) _rainbowSuggestions = settings.RainbowSuggestions(); _clipboardOperationsAllowed = settings.AllowVtClipboardWrite(); + const auto cursorBlinkInterval = settings.CursorBlinkInterval(); + _cursorBlinkIntervalOverride = cursorBlinkInterval ? + std::optional{ 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(); diff --git a/src/cascadia/TerminalCore/Terminal.hpp b/src/cascadia/TerminalCore/Terminal.hpp index 8f4ca627a2..4978093681 100644 --- a/src/cascadia/TerminalCore/Terminal.hpp +++ b/src/cascadia/TerminalCore/Terminal.hpp @@ -364,6 +364,7 @@ private: CursorType _defaultCursorShape = CursorType::Legacy; std::optional _cursorBlinkInterval; + std::optional _cursorBlinkIntervalOverride; til::enumset _systemMode{ Mode::AutoWrap }; diff --git a/src/cascadia/TerminalCore/terminalrenderdata.cpp b/src/cascadia/TerminalCore/terminalrenderdata.cpp index 6422734f96..27b022885c 100644 --- a/src/cascadia/TerminalCore/terminalrenderdata.cpp +++ b/src/cascadia/TerminalCore/terminalrenderdata.cpp @@ -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); diff --git a/src/cascadia/TerminalSettingsAppAdapterLib/TerminalSettings.cpp b/src/cascadia/TerminalSettingsAppAdapterLib/TerminalSettings.cpp index 6353f61a4e..a43c273f40 100644 --- a/src/cascadia/TerminalSettingsAppAdapterLib/TerminalSettings.cpp +++ b/src/cascadia/TerminalSettingsAppAdapterLib/TerminalSettings.cpp @@ -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(); diff --git a/src/cascadia/TerminalSettingsEditor/Appearances.xaml b/src/cascadia/TerminalSettingsEditor/Appearances.xaml index e903ffa8e6..080b1e4185 100644 --- a/src/cascadia/TerminalSettingsEditor/Appearances.xaml +++ b/src/cascadia/TerminalSettingsEditor/Appearances.xaml @@ -580,15 +580,30 @@ - - - + + + + + + + + diff --git a/src/cascadia/TerminalSettingsEditor/ProfileViewModel.cpp b/src/cascadia/TerminalSettingsEditor/ProfileViewModel.cpp index d85618293b..2a134ab702 100644 --- a/src/cascadia/TerminalSettingsEditor/ProfileViewModel.cpp +++ b/src/cascadia/TerminalSettingsEditor/ProfileViewModel.cpp @@ -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(CursorBlinkIntervalValue()); + switch (index) + { + case 0: + CursorBlinkInterval(nullptr); + break; + case 1: + CursorBlinkInterval(IReference{ 0u }); + break; + case 2: + CursorBlinkInterval(IReference{ _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(std::clamp(value, 1.0, 10000.0)); + // Two-way binding also writes back on model changes. Preserve inherited values. + if (CursorBlinkIntervalValue() != _lastCursorBlinkInterval) + { + CursorBlinkInterval(IReference{ _lastCursorBlinkInterval }); + } + } + _NotifyChanges(L"CursorBlinkIntervalValue"); + } + void ProfileViewModel::LeftPadding(double value) noexcept { if (std::abs(_parsedPadding.Left - value) >= .0001) diff --git a/src/cascadia/TerminalSettingsEditor/ProfileViewModel.h b/src/cascadia/TerminalSettingsEditor/ProfileViewModel.h index 36645f53f6..f9c070150f 100644 --- a/src/cascadia/TerminalSettingsEditor/ProfileViewModel.h +++ b/src/cascadia/TerminalSettingsEditor/ProfileViewModel.h @@ -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; diff --git a/src/cascadia/TerminalSettingsEditor/ProfileViewModel.idl b/src/cascadia/TerminalSettingsEditor/ProfileViewModel.idl index 2dc04140ea..1dba0c3efc 100644 --- a/src/cascadia/TerminalSettingsEditor/ProfileViewModel.idl +++ b/src/cascadia/TerminalSettingsEditor/ProfileViewModel.idl @@ -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, 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, BellSound); diff --git a/src/cascadia/TerminalSettingsEditor/Resources/en-US/Resources.resw b/src/cascadia/TerminalSettingsEditor/Resources/en-US/Resources.resw index df5dc93e3d..d38a138d61 100644 --- a/src/cascadia/TerminalSettingsEditor/Resources/en-US/Resources.resw +++ b/src/cascadia/TerminalSettingsEditor/Resources/en-US/Resources.resw @@ -911,13 +911,37 @@ Browse... Button label that opens a file picker in a new window. The "..." is standard to mean it will open a new window. - - Allow blinking - Header for a toggle in the Cursor section that allows the text cursor to blink. + + Cursor blinking + Header for the cursor blink interval setting in the Cursor section. - - Allow the cursor to blink when requested by the application and enabled in Windows. When disabled, applications can still show or hide the cursor. - Description for the cursor blinking override. + + Use the Windows setting, disable blinking, or set a custom interval. Applications can still request a steady cursor or hide it. + Description for the cursor blink interval override. + + + Cursor blinking + Accessible name for the cursor blinking mode dropdown. + + + Use Windows setting + Cursor blinking option that follows the system blink interval, including disabled blinking. + + + Disabled (steady cursor) + Cursor blinking option that disables blinking without changing cursor visibility. + + + Custom interval + Cursor blinking option that exposes a custom interval in milliseconds. + + + Cursor blink interval (milliseconds) + Accessible name for the custom cursor blink interval input. + + + Interval (ms) + Label for the custom cursor blink interval input. The interval is the time between visibility changes, not a full blink cycle. Cursor height diff --git a/src/cascadia/TerminalSettingsModel/MTSMSettings.h b/src/cascadia/TerminalSettingsModel/MTSMSettings.h index c9598eb6dd..8e47846e3e 100644 --- a/src/cascadia/TerminalSettingsModel/MTSMSettings.h +++ b/src/cascadia/TerminalSettingsModel/MTSMSettings.h @@ -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, CursorBlinkInterval, "cursorBlinkInterval", nullptr) \ X(bool, AltGrAliasing, "altGrAliasing", true) \ X(hstring, AnswerbackMessage, "answerbackMessage") \ X(hstring, Commandline, "commandline", L"%SystemRoot%\\System32\\cmd.exe") \ diff --git a/src/cascadia/TerminalSettingsModel/Profile.idl b/src/cascadia/TerminalSettingsModel/Profile.idl index 3d5e83361c..00b31ca979 100644 --- a/src/cascadia/TerminalSettingsModel/Profile.idl +++ b/src/cascadia/TerminalSettingsModel/Profile.idl @@ -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, CursorBlinkInterval); INHERITABLE_PROFILE_SETTING(Boolean, AltGrAliasing); INHERITABLE_PROFILE_SETTING(String, AnswerbackMessage); INHERITABLE_PROFILE_SETTING(BellStyle, BellStyle); diff --git a/src/cascadia/UnitTests_SettingsModel/TerminalSettingsTests.cpp b/src/cascadia/UnitTests_SettingsModel/TerminalSettingsTests.cpp index f0a88c75b0..6cf5de772f 100644 --- a/src/cascadia/UnitTests_SettingsModel/TerminalSettingsTests.cpp +++ b/src/cascadia/UnitTests_SettingsModel/TerminalSettingsTests.cpp @@ -672,49 +672,67 @@ namespace SettingsModelUnitTests void TerminalSettingsTests::CursorBlinkingProfileSetting() { - VERIFY_IS_TRUE(winrt::make().AllowCursorBlinking()); + VERIFY_IS_NULL(winrt::make().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(settingsJson); - VERIFY_ARE_EQUAL(2u, settings->ActiveProfiles().Size()); + VERIFY_ARE_EQUAL(4u, settings->ActiveProfiles().Size()); const auto defaultsJson = winrt::get_self(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(profile)->ToJson(); - VERIFY_ARE_EQUAL(expected, json.isMember("allowCursorBlinking")); + const std::array, 4> intervals{ 0u, 275u, std::nullopt, 0u }; + const auto verifyInterval = [](const std::optional expected, const winrt::Windows::Foundation::IReference& actual) { + VERIFY_ARE_EQUAL(expected.has_value(), static_cast(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(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()); } } diff --git a/src/cascadia/UnitTests_TerminalCore/TerminalApiTest.cpp b/src/cascadia/UnitTests_TerminalCore/TerminalApiTest.cpp index ab9922d2c9..56546a936c 100644 --- a/src/cascadia/UnitTests_TerminalCore/TerminalApiTest.cpp +++ b/src/cascadia/UnitTests_TerminalCore/TerminalApiTest.cpp @@ -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(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(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(0, 100, 100); - settings->AllowCursorBlinking(false); + settings->CursorBlinkInterval(uint32_t{ 0 }); term.CreateFromSettings(*settings, renderer); renderer._viewport = term.GetViewport(); renderer.AllowCursorVisibility(InhibitionSource::Host, true); diff --git a/src/cascadia/inc/ControlProperties.h b/src/cascadia/inc/ControlProperties.h index 3657ef2fd8..fbe5e35d29 100644 --- a/src/cascadia/inc/ControlProperties.h +++ b/src/cascadia/inc/ControlProperties.h @@ -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, CursorBlinkInterval, nullptr) \ X(bool, AltGrAliasing, true) \ X(winrt::hstring, AnswerbackMessage) \ X(winrt::hstring, WordDelimiters, DEFAULT_WORD_DELIMITERS) \ diff --git a/src/renderer/base/renderer.cpp b/src/renderer/base/renderer.cpp index 809bd6f1de..26b81dd78a 100644 --- a/src/renderer/base/renderer.cpp +++ b/src/renderer/base/renderer.cpp @@ -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; } }