Add a setting to flash the pane when BEL is emitted

doc/cascadia/profiles.schema.json

@@ -37,15 +37,17 @@
             "type": "string",
             "enum": [
               "audible",
-              "visual"
+              "window",
+              "taskbar"
             ]
           }
         },
         {
           "type": "string",
           "enum": [
             "audible",
-            "visual",
+            "taskbar",
+            "window",
             "all",
             "none"
           ]
@@ -1171,7 +1173,7 @@
         },
         "bellStyle": {
           "default": "audible",
-          "description": "Controls what happens when the application emits a BEL character. When set to \"all\", the Terminal will play a sound and flash the taskbar icon. An array of specific behaviors can also be used. Supported array values include `audible` and `visual`. When set to \"none\", nothing will happen.",
+          "description": "Controls what happens when the application emits a BEL character. When set to \"all\", the Terminal will play a sound, flash the taskbar icon (if the terminal window is not in focus) and flash the window. An array of specific behaviors can also be used. Supported array values include `audible`, `window` and `taskbar`. When set to \"none\", nothing will happen.",
           "$ref": "#/definitions/BellStyle"
         },
         "closeOnExit": {

src/cascadia/TerminalApp/Pane.cpp

@@ -378,8 +378,13 @@ void Pane::_ControlWarningBellHandler(const winrt::Windows::Foundation::IInspect
                 PlaySound(soundAlias, NULL, SND_ALIAS_ID | SND_ASYNC | SND_SENTRY);
             }
 
-            // raise the event with the bool value corresponding to the visual flag
-            _PaneRaiseBellHandlers(nullptr, WI_IsFlagSet(paneProfile.BellStyle(), winrt::Microsoft::Terminal::Settings::Model::BellStyle::Visual));
+            if (WI_IsFlagSet(paneProfile.BellStyle(), winrt::Microsoft::Terminal::Settings::Model::BellStyle::Window))
+            {
+                _control.BellLightOn();
+            }
+
+            // raise the event with the bool value corresponding to the taskbar flag
+            _PaneRaiseBellHandlers(nullptr, WI_IsFlagSet(paneProfile.BellStyle(), winrt::Microsoft::Terminal::Settings::Model::BellStyle::Taskbar));
         }
     }
 }

src/cascadia/TerminalControl/TermControl.cpp

@@ -58,7 +58,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         _lastAutoScrollUpdateTime{ std::nullopt },
         _cursorTimer{},
         _blinkTimer{},
-        _searchBox{ nullptr }
+        _searchBox{ nullptr },
+        _bellLightAnimation{ Window::Current().Compositor().CreateScalarKeyFrameAnimation() }
     {
         InitializeComponent();
 
@@ -167,6 +168,11 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         _autoScrollTimer.Interval(AutoScrollUpdateInterval);
         _autoScrollTimer.Tick({ this, &TermControl::_UpdateAutoScroll });
 
+        // Add key frames and a duration to our bell light animation
+        _bellLightAnimation.InsertKeyFrame(0.0, 2.0);
+        _bellLightAnimation.InsertKeyFrame(1.0, 1.0);
+        _bellLightAnimation.Duration(winrt::Windows::Foundation::TimeSpan(std::chrono::milliseconds(TerminalWarningBellInterval)));
+
         _ApplyUISettings(_settings);
     }
 
@@ -2358,6 +2364,42 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         return _core->TaskbarProgress();
     }
 
+    void TermControl::BellLightOn()
+    {
+        Windows::Foundation::Numerics::float2 zeroSize{ 0, 0 };
+        // If the grid has 0 size or if the bell timer is
+        // already active, do nothing
+        if (RootGrid().ActualSize() != zeroSize && !_bellLightTimer)
+        {
+            // Start the timer, when the timer ticks we switch off the light
+            DispatcherTimer invertTimer;
+            invertTimer.Interval(std::chrono::milliseconds(TerminalWarningBellInterval));
+            invertTimer.Tick({ get_weak(), &TermControl::_BellLightOff });
+            invertTimer.Start();
+            _bellLightTimer.emplace(std::move(invertTimer));
+
+            // Switch on the light and animate the intensity to fade out
+            VisualBellLight::SetIsTarget(RootGrid(), true);
+            BellLight().CompositionLight().StartAnimation(L"Intensity", _bellLightAnimation);
+        }
+    }
+
+    void TermControl::_BellLightOff(Windows::Foundation::IInspectable const& /* sender */,
+                                    Windows::Foundation::IInspectable const& /* e */)
+    {
+        if (_bellLightTimer)
+        {
+            // Stop the timer and switch off the light
+            _bellLightTimer->Stop();
+            _bellLightTimer.reset();
+
+            if (!_closing)
+            {
+                VisualBellLight::SetIsTarget(RootGrid(), false);
+            }
+        }
+    }
+
     // Method Description:
     // - Checks whether the control is in a read-only mode (in this mode node input is sent to connection).
     // Return Value:

src/cascadia/TerminalControl/TermControl.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include "TermControl.g.h"
+#include "XamlLights.h"
 #include "EventArgs.h"
 #include "../../renderer/base/Renderer.hpp"
 #include "../../renderer/dx/DxRenderer.hpp"
@@ -98,6 +99,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                                                                const winrt::hstring& padding,
                                                                const uint32_t dpi);
 
+        void BellLightOn();
+
         bool ReadOnly() const noexcept;
         void ToggleReadOnly();
 
@@ -164,8 +167,11 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         Windows::UI::Xaml::DispatcherTimer _autoScrollTimer;
         std::optional<std::chrono::high_resolution_clock::time_point> _lastAutoScrollUpdateTime;
 
+        winrt::Windows::UI::Composition::ScalarKeyFrameAnimation _bellLightAnimation;
+
         std::optional<Windows::UI::Xaml::DispatcherTimer> _cursorTimer;
         std::optional<Windows::UI::Xaml::DispatcherTimer> _blinkTimer;
+        std::optional<Windows::UI::Xaml::DispatcherTimer> _bellLightTimer;
 
         event_token _coreOutputEventToken;
 
@@ -202,6 +208,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
         void _CursorTimerTick(Windows::Foundation::IInspectable const& sender, Windows::Foundation::IInspectable const& e);
         void _BlinkTimerTick(Windows::Foundation::IInspectable const& sender, Windows::Foundation::IInspectable const& e);
+        void _BellLightOff(Windows::Foundation::IInspectable const& sender, Windows::Foundation::IInspectable const& e);
 
         void _SetEndSelectionPointAtCursor(Windows::Foundation::Point const& cursorPosition);
 

src/cascadia/TerminalControl/TermControl.idl

@@ -63,6 +63,8 @@ namespace Microsoft.Terminal.Control
         void ToggleShaderEffects();
         void SendInput(String input);
 
+        void BellLightOn();
+
         Boolean ReadOnly { get; };
         void ToggleReadOnly();
     }

src/cascadia/TerminalControl/TermControl.xaml

@@ -33,6 +33,9 @@
     -->
 
     <Grid x:Name="RootGrid">
+        <Grid.Lights>
+            <local:VisualBellLight x:Name="BellLight" />
+        </Grid.Lights>
         <Image x:Name="BackgroundImage"
                AutomationProperties.AccessibilityView="Raw" />
         <Grid>

src/cascadia/TerminalControl/TerminalControlLib.vcxproj

@@ -43,6 +43,9 @@
     <ClInclude Include="SearchBoxControl.h">
       <DependentUpon>SearchBoxControl.xaml</DependentUpon>
     </ClInclude>
+    <ClInclude Include="XamlLights.h">
+      <DependentUpon>XamlLights.idl</DependentUpon>
+    </ClInclude>
     <ClInclude Include="TermControl.h">
       <DependentUpon>TermControl.xaml</DependentUpon>
     </ClInclude>
@@ -76,6 +79,9 @@
     <ClCompile Include="SearchBoxControl.cpp">
       <DependentUpon>SearchBoxControl.xaml</DependentUpon>
     </ClCompile>
+    <ClCompile Include="XamlLights.cpp">
+      <DependentUpon>XamlLights.idl</DependentUpon>
+    </ClCompile>
     <ClCompile Include="TermControl.cpp">
       <DependentUpon>TermControl.xaml</DependentUpon>
     </ClCompile>
@@ -102,6 +108,7 @@
     <Midl Include="SearchBoxControl.idl">
       <DependentUpon>SearchBoxControl.xaml</DependentUpon>
     </Midl>
+    <Midl Include="XamlLights.idl" />
     <Midl Include="TermControl.idl">
       <DependentUpon>TermControl.xaml</DependentUpon>
     </Midl>

src/cascadia/TerminalControl/XamlLights.cpp

@@ -0,0 +1,107 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#include "pch.h"
+#include "TermControl.h"
+#include "XamlLights.h"
+#include "VisualBellLight.g.cpp"
+
+using namespace winrt::Windows::UI::Xaml;
+using namespace winrt::Windows::UI::Xaml::Media;
+
+namespace winrt::Microsoft::Terminal::Control::implementation
+{
+    DependencyProperty VisualBellLight::_IsTargetProperty{ nullptr };
+
+    VisualBellLight::VisualBellLight()
+    {
+        _InitializeProperties();
+    }
+
+    void VisualBellLight::_InitializeProperties()
+    {
+        // Initialize any dependency properties here.
+        // This performs a lazy load on these properties, instead of
+        // initializing them when the DLL loads.
+        if (!_IsTargetProperty)
+        {
+            _IsTargetProperty =
+                DependencyProperty::RegisterAttached(
+                    L"IsTarget",
+                    winrt::xaml_typename<bool>(),
+                    winrt::xaml_typename<Control::VisualBellLight>(),
+                    PropertyMetadata{ winrt::box_value(false), PropertyChangedCallback{ &VisualBellLight::OnIsTargetChanged } });
+        }
+    }
+
+    // Method Description:
+    // - This function is called when the first target UIElement is shown on the screen,
+    //   this enables delaying composition object creation until it's actually necessary.
+    // Arguments:
+    // - newElement: unused
+    void VisualBellLight::OnConnected(UIElement const& /* newElement */)
+    {
+        if (!CompositionLight())
+        {
+            auto spotLight{ Window::Current().Compositor().CreateAmbientLight() };
+            spotLight.Color(Windows::UI::Colors::White());
+            CompositionLight(spotLight);
+        }
+    }
+
+    // Method Description:
+    // - This function is called when there are no more target UIElements on the screen
+    // - Disposes of composition resources when no longer in use
+    // Arguments:
+    // - oldElement: unused
+    void VisualBellLight::OnDisconnected(UIElement const& /* oldElement */)
+    {
+        if (CompositionLight())
+        {
+            CompositionLight(nullptr);
+        }
+    }
+
+    winrt::hstring VisualBellLight::GetId()
+    {
+        return VisualBellLight::GetIdStatic();
+    }
+
+    void VisualBellLight::OnIsTargetChanged(DependencyObject const& d, DependencyPropertyChangedEventArgs const& e)
+    {
+        const auto uielem{ d.try_as<UIElement>() };
+        const auto brush{ d.try_as<Brush>() };
+
+        if (!uielem && !brush)
+        {
+            // terminate early
+            return;
+        }
+
+        const auto isAdding = winrt::unbox_value<bool>(e.NewValue());
+        const auto id = GetIdStatic();
+
+        if (isAdding)
+        {
+            if (uielem)
+            {
+                XamlLight::AddTargetElement(id, uielem);
+            }
+            else
+            {
+                XamlLight::AddTargetBrush(id, brush);
+            }
+        }
+        else
+        {
+            if (uielem)
+            {
+                XamlLight::RemoveTargetElement(id, uielem);
+            }
+            else
+            {
+                XamlLight::RemoveTargetBrush(id, brush);
+            }
+        }
+    }
+}

src/cascadia/TerminalControl/XamlLights.h

@@ -0,0 +1,49 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#pragma once
+
+#include "cppwinrt_utils.h"
+#include "VisualBellLight.g.h"
+
+namespace winrt::Microsoft::Terminal::Control::implementation
+{
+    struct VisualBellLight : VisualBellLightT<VisualBellLight>
+    {
+        VisualBellLight();
+
+        winrt::hstring GetId();
+
+        static Windows::UI::Xaml::DependencyProperty IsTargetProperty() { return _IsTargetProperty; }
+
+        static bool GetIsTarget(Windows::UI::Xaml::DependencyObject const& target)
+        {
+            return winrt::unbox_value<bool>(target.GetValue(_IsTargetProperty));
+        }
+
+        static void SetIsTarget(Windows::UI::Xaml::DependencyObject const& target, bool value)
+        {
+            target.SetValue(_IsTargetProperty, winrt::box_value(value));
+        }
+
+        void OnConnected(Windows::UI::Xaml::UIElement const& newElement);
+        void OnDisconnected(Windows::UI::Xaml::UIElement const& oldElement);
+
+        static void OnIsTargetChanged(Windows::UI::Xaml::DependencyObject const& d, Windows::UI::Xaml::DependencyPropertyChangedEventArgs const& e);
+
+        inline static winrt::hstring GetIdStatic()
+        {
+            // This specifies the unique name of the light. In most cases you should use the type's full name.
+            return winrt::xaml_typename<winrt::Microsoft::Terminal::Control::VisualBellLight>().Name;
+        }
+
+    private:
+        static void _InitializeProperties();
+        static Windows::UI::Xaml::DependencyProperty _IsTargetProperty;
+    };
+}
+
+namespace winrt::Microsoft::Terminal::Control::factory_implementation
+{
+    BASIC_FACTORY(VisualBellLight);
+}

src/cascadia/TerminalControl/XamlLights.idl

@@ -0,0 +1,13 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+namespace Microsoft.Terminal.Control
+{
+    [default_interface] runtimeclass VisualBellLight : Windows.UI.Xaml.Media.XamlLight
+    {
+        VisualBellLight();
+        static Windows.UI.Xaml.DependencyProperty IsTargetProperty { get; };
+        static Boolean GetIsTarget(Windows.UI.Xaml.DependencyObject target);
+        static void SetIsTarget(Windows.UI.Xaml.DependencyObject target, Boolean value);
+    }
+}