Add support for OSC777 - send notification

src/cascadia/Remoting/WindowManager.cpp

@@ -801,4 +801,22 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         }
         return nullptr;
     }
+
+    // Attempt to summon an existing window. This static function does NOT
+    // pre-register as the monarch. This is used for activations from a
+    // notification, where this process should NEVER become its own window.
+    bool WindowManager::SummonForNotification(const uint64_t windowId)
+    {
+        auto monarch = create_instance<Remoting::IMonarch>(Monarch_clsid,
+                                                           CLSCTX_LOCAL_SERVER);
+
+        if (monarch == nullptr)
+        {
+            return false;
+        }
+        SummonWindowSelectionArgs args{};
+        args.WindowID(windowId);
+        monarch.SummonWindow(args);
+        return true;
+    }
 }

src/cascadia/Remoting/WindowManager.h

@@ -51,6 +51,8 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         void UpdateActiveTabTitle(winrt::hstring title);
         Windows::Foundation::Collections::IVector<winrt::hstring> GetAllWindowLayouts();
 
+        static bool SummonForNotification(const uint64_t windowId);
+
         TYPED_EVENT(FindTargetWindowRequested, winrt::Windows::Foundation::IInspectable, winrt::Microsoft::Terminal::Remoting::FindTargetWindowArgs);
         TYPED_EVENT(BecameMonarch, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
         TYPED_EVENT(WindowCreated, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);

src/cascadia/Remoting/WindowManager.idl

@@ -23,6 +23,9 @@ namespace Microsoft.Terminal.Remoting
         void UpdateActiveTabTitle(String title);
         Boolean DoesQuakeWindowExist();
         Windows.Foundation.Collections.IVectorView<PeasantInfo> GetPeasantInfos();
+
+        static Boolean SummonForNotification(UInt64 windowId);
+
         event Windows.Foundation.TypedEventHandler<Object, FindTargetWindowArgs> FindTargetWindowRequested;
         event Windows.Foundation.TypedEventHandler<Object, Object> BecameMonarch;
         event Windows.Foundation.TypedEventHandler<Object, Object> WindowCreated;

src/cascadia/TerminalApp/TerminalPage.cpp

@@ -39,6 +39,9 @@ using namespace ::Microsoft::Console;
 using namespace ::Microsoft::Terminal::Core;
 using namespace std::chrono_literals;
 
+using namespace winrt::Windows::UI::Notifications;
+using namespace winrt::Windows::Data::Xml::Dom;
+
 #define HOOKUP_ACTION(action) _actionDispatch->action({ this, &TerminalPage::_Handle##action });
 
 namespace winrt
@@ -1508,6 +1511,7 @@ namespace winrt::TerminalApp::implementation
         });
 
         term.ShowWindowChanged({ get_weak(), &TerminalPage::_ShowWindowChangedHandler });
+        term.SendNotification({ get_weak(), &TerminalPage::_SendNotificationHandler });
     }
 
     // Method Description:
@@ -2419,6 +2423,81 @@ namespace winrt::TerminalApp::implementation
         _ShowWindowChangedHandlers(*this, args);
     }
 
+    winrt::fire_and_forget TerminalPage::_SendNotificationHandler(const IInspectable sender,
+                                                                  const Microsoft::Terminal::Control::SendNotificationArgs args)
+    {
+        auto weakThis = get_weak();
+
+        co_await resume_foreground(Dispatcher());
+        auto page{ weakThis.get() };
+        if (page)
+        {
+            // If the window is inactive, we alway want to send the notification.
+            //
+            // Otherwise, we only want to send the notification for panes in inactive tabs.
+            if (_activated)
+            {
+                auto foundControl = false;
+                if (const auto activeTab{ _GetFocusedTabImpl() })
+                {
+                    activeTab->GetRootPane()->WalkTree([&](auto&& pane) {
+                        if (const auto& term{ pane->GetTerminalControl() })
+                        {
+                            if (term == sender)
+                            {
+                                foundControl = true;
+                                return;
+                            }
+                        }
+                    });
+                }
+
+                // The control that sent this is in the active tab. We
+                // should only send the notification if the window was
+                // inactive.
+                if (foundControl)
+                {
+                    co_return;
+                }
+            }
+
+            _sendNotification(args.Title(), args.Body());
+        }
+    }
+
+    void TerminalPage::_sendNotification(const std::wstring_view title,
+                                         const std::wstring_view body)
+    {
+        static winrt::hstring xmlTemplate{ L"\
+    <toast>\
+        <visual>\
+            <binding template=\"ToastGeneric\">\
+                <text></text>\
+                <text></text>\
+            </binding>\
+        </visual>\
+    </toast>" };
+
+        XmlDocument doc;
+        doc.LoadXml(xmlTemplate);
+        // Populate with text and values
+        auto payload{ fmt::format(L"window={}&tabIndex=0", WindowId()) };
+        doc.DocumentElement().SetAttribute(L"launch", payload);
+        doc.SelectSingleNode(L"//text[1]").InnerText(title);
+        doc.SelectSingleNode(L"//text[2]").InnerText(body);
+
+        // Construct the notification
+        winrt::Windows::UI::Notifications::ToastNotification notif{ doc };
+
+        if (!_toastNotifier)
+        {
+            _toastNotifier = ToastNotificationManager::CreateToastNotifier();
+        }
+
+        // And show it!
+        _toastNotifier.Show(notif);
+    }
+
     // Method Description:
     // - Paste text from the Windows Clipboard to the focused terminal
     void TerminalPage::_PasteText()

src/cascadia/TerminalApp/TerminalPage.h

@@ -230,6 +230,8 @@ namespace winrt::TerminalApp::implementation
         int _renamerLayoutCount{ 0 };
         bool _renamerPressedEnter{ false };
 
+        winrt::Windows::UI::Notifications::ToastNotifier _toastNotifier{ nullptr };
+
         winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::UI::Xaml::Controls::ContentDialogResult> _ShowDialogHelper(const std::wstring_view& name);
 
         void _ShowAboutDialog();
@@ -457,7 +459,9 @@ namespace winrt::TerminalApp::implementation
         void _updateTabCloseButton(const winrt::Microsoft::UI::Xaml::Controls::TabViewItem& tabViewItem);
 
         winrt::fire_and_forget _ShowWindowChangedHandler(const IInspectable sender, const winrt::Microsoft::Terminal::Control::ShowWindowArgs args);
+        winrt::fire_and_forget _SendNotificationHandler(const IInspectable sender, const winrt::Microsoft::Terminal::Control::SendNotificationArgs args);
 
+        void _sendNotification(const std::wstring_view title, const std::wstring_view body);
 #pragma region ActionHandlers
         // These are all defined in AppActionHandlers.cpp
 #define ON_ALL_ACTIONS(action) DECLARE_ACTION_HANDLER(action);

src/cascadia/TerminalApp/TerminalTab.cpp

@@ -18,6 +18,9 @@ using namespace winrt::Microsoft::Terminal::Settings::Model;
 using namespace winrt::Microsoft::UI::Xaml::Controls;
 using namespace winrt::Windows::System;
 
+using namespace winrt::Windows::UI::Notifications;
+using namespace winrt::Windows::Data::Xml::Dom;
+
 namespace winrt
 {
     namespace MUX = Microsoft::UI::Xaml;
@@ -905,7 +908,7 @@ namespace winrt::TerminalApp::implementation
             }
         });
 
-        events.taskbarToken = control.SetTaskbarProgress([dispatcher, weakThis](auto&&, auto&&) -> winrt::fire_and_forget {
+        events.taskbarToken = control.SetTaskbarProgress([dispatcher, weakThis](auto&&, auto &&) -> winrt::fire_and_forget {
             co_await wil::resume_foreground(dispatcher);
             // Check if Tab's lifetime has expired
             if (auto tab{ weakThis.get() })
@@ -1110,7 +1113,7 @@ namespace winrt::TerminalApp::implementation
         // Add a Closed event handler to the Pane. If the pane closes out from
         // underneath us, and it's zoomed, we want to be able to make sure to
         // update our state accordingly to un-zoom that pane. See GH#7252.
-        auto closedToken = pane->Closed([weakThis, weakPane](auto&& /*s*/, auto&& /*e*/) -> winrt::fire_and_forget {
+        auto closedToken = pane->Closed([weakThis, weakPane](auto&& /*s*/, auto && /*e*/) -> winrt::fire_and_forget {
             if (auto tab{ weakThis.get() })
             {
                 if (tab->_zoomedPane)

src/cascadia/TerminalApp/pch.h

@@ -50,6 +50,10 @@
 #include <winrt/Windows.Media.Core.h>
 #include <winrt/Windows.Media.Playback.h>
 
+#include "winrt/Windows.Data.Xml.Dom.h"
+#include "winrt/Windows.UI.Notifications.h"
+#include "winrt/Windows.ApplicationModel.Activation.h"
+
 #include <winrt/Microsoft.Toolkit.Win32.UI.XamlHost.h>
 #include <winrt/Microsoft.UI.Xaml.Controls.h>
 #include <winrt/Microsoft.UI.Xaml.Controls.Primitives.h>

src/cascadia/TerminalControl/ControlCore.cpp

@@ -147,6 +147,9 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         auto pfnPlayMidiNote = std::bind(&ControlCore::_terminalPlayMidiNote, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
         _terminal->SetPlayMidiNoteCallback(pfnPlayMidiNote);
 
+        auto pfnSendNotification = std::bind(&ControlCore::_terminalSendNotification, this, std::placeholders::_1, std::placeholders::_2);
+        _terminal->SetSendNotificationCallback(pfnSendNotification);
+
         // MSFT 33353327: Initialize the renderer in the ctor instead of Initialize().
         // We need the renderer to be ready to accept new engines before the SwapChainPanel is ready to go.
         // If we wait, a screen reader may try to get the AutomationPeer (aka the UIA Engine), and we won't be able to attach
@@ -1420,6 +1423,13 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         _midiAudio.PlayNote(reinterpret_cast<HWND>(_owningHwnd), noteNumber, velocity, std::chrono::duration_cast<std::chrono::milliseconds>(duration));
     }
 
+    void ControlCore::_terminalSendNotification(const std::wstring_view title,
+                                                const std::wstring_view body)
+    {
+        auto e = winrt::make_self<implementation::SendNotificationArgs>(title, body);
+        _SendNotificationHandlers(*this, *e);
+    }
+
     bool ControlCore::HasSelection() const
     {
         return _terminal->IsSelectionActive();

src/cascadia/TerminalControl/ControlCore.h

@@ -232,6 +232,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         TYPED_EVENT(ShowWindowChanged,         IInspectable, Control::ShowWindowArgs);
         TYPED_EVENT(UpdateSelectionMarkers,    IInspectable, Control::UpdateSelectionMarkersEventArgs);
         TYPED_EVENT(OpenHyperlink,             IInspectable, Control::OpenHyperlinkEventArgs);
+        TYPED_EVENT(SendNotification,          IInspectable, Control::SendNotificationArgs);
         // clang-format on
 
     private:
@@ -304,6 +305,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         void _terminalPlayMidiNote(const int noteNumber,
                                    const int velocity,
                                    const std::chrono::microseconds duration);
+        void _terminalSendNotification(const std::wstring_view title,
+                                       const std::wstring_view body);
 #pragma endregion
 
         MidiAudio _midiAudio;

src/cascadia/TerminalControl/ControlCore.idl

@@ -161,5 +161,6 @@ namespace Microsoft.Terminal.Control
         event Windows.Foundation.TypedEventHandler<Object, ShowWindowArgs> ShowWindowChanged;
         event Windows.Foundation.TypedEventHandler<Object, UpdateSelectionMarkersEventArgs> UpdateSelectionMarkers;
         event Windows.Foundation.TypedEventHandler<Object, OpenHyperlinkEventArgs> OpenHyperlink;
+        event Windows.Foundation.TypedEventHandler<Object, SendNotificationArgs> SendNotification;
     };
 }

src/cascadia/TerminalControl/EventArgs.cpp

@@ -14,3 +14,4 @@
 #include "FoundResultsArgs.g.cpp"
 #include "ShowWindowArgs.g.cpp"
 #include "UpdateSelectionMarkersEventArgs.g.cpp"
+#include "SendNotificationArgs.g.cpp"

src/cascadia/TerminalControl/EventArgs.h

@@ -14,6 +14,7 @@
 #include "FoundResultsArgs.g.h"
 #include "ShowWindowArgs.g.h"
 #include "UpdateSelectionMarkersEventArgs.g.h"
+#include "SendNotificationArgs.g.h"
 
 namespace winrt::Microsoft::Terminal::Control::implementation
 {
@@ -169,4 +170,19 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
         WINRT_PROPERTY(bool, ClearMarkers, false);
     };
+
+    struct SendNotificationArgs : public SendNotificationArgsT<SendNotificationArgs>
+    {
+    public:
+        SendNotificationArgs(const std::wstring_view title,
+                             const std::wstring_view body) :
+            _Title(title),
+            _Body(body)
+        {
+        }
+
+        WINRT_PROPERTY(winrt::hstring, Title);
+        WINRT_PROPERTY(winrt::hstring, Body);
+    };
+
 }

src/cascadia/TerminalControl/EventArgs.idl

@@ -83,4 +83,10 @@ namespace Microsoft.Terminal.Control
     {
         Boolean ClearMarkers { get; };
     }
+
+    runtimeclass SendNotificationArgs
+    {
+        String Title { get; };
+        String Body { get; };
+    }
 }

src/cascadia/TerminalControl/TermControl.cpp

@@ -88,6 +88,14 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         _interactivity.OpenHyperlink({ this, &TermControl::_HyperlinkHandler });
         _interactivity.ScrollPositionChanged({ this, &TermControl::_ScrollPositionChanged });
 
+        // Re-raise the event with us as the sender.
+        _core.SendNotification([weakThis = get_weak()](auto s, auto e) {
+            if (auto self{ weakThis.get() })
+            {
+                self->_SendNotificationHandlers(*self, e);
+            }
+        });
+
         // Initialize the terminal only once the swapchainpanel is loaded - that
         //      way, we'll be able to query the real pixel size it got on layout
         _layoutUpdatedRevoker = SwapChainPanel().LayoutUpdated(winrt::auto_revoke, [this](auto /*s*/, auto /*e*/) {

src/cascadia/TerminalControl/TermControl.h

@@ -159,6 +159,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         TYPED_EVENT(FocusFollowMouseRequested, IInspectable, IInspectable);
         TYPED_EVENT(Initialized,               Control::TermControl, Windows::UI::Xaml::RoutedEventArgs);
         TYPED_EVENT(WarningBell,               IInspectable, IInspectable);
+        TYPED_EVENT(SendNotification,          IInspectable, Control::SendNotificationArgs);
         // clang-format on
 
         WINRT_OBSERVABLE_PROPERTY(winrt::Windows::UI::Xaml::Media::Brush, BackgroundBrush, _PropertyChangedHandlers, nullptr);

src/cascadia/TerminalControl/TermControl.idl

@@ -44,6 +44,7 @@ namespace Microsoft.Terminal.Control
         event Windows.Foundation.TypedEventHandler<Object, Object> TabColorChanged;
         event Windows.Foundation.TypedEventHandler<Object, Object> ReadOnlyChanged;
         event Windows.Foundation.TypedEventHandler<Object, Object> FocusFollowMouseRequested;
+        event Windows.Foundation.TypedEventHandler<Object, SendNotificationArgs> SendNotification;
 
         event Windows.Foundation.TypedEventHandler<TermControl, Windows.UI.Xaml.RoutedEventArgs> Initialized;
         // This is an event handler forwarder for the underlying connection.

src/cascadia/TerminalCore/Terminal.cpp

@@ -1378,6 +1378,11 @@ void Terminal::SetPlayMidiNoteCallback(std::function<void(const int, const int,
     _pfnPlayMidiNote.swap(pfn);
 }
 
+void Terminal::SetSendNotificationCallback(std::function<void(std::wstring_view, std::wstring_view)> pfn) noexcept
+{
+    _pfnSendNotification.swap(pfn);
+}
+
 // Method Description:
 // - Sets the cursor to be currently on. On/Off is tracked independently of
 //   cursor visibility (hidden/visible). On/off is controlled by the cursor

src/cascadia/TerminalCore/Terminal.hpp

@@ -138,6 +138,7 @@ class Microsoft::Terminal::Core::Terminal final :
     bool IsConsolePty() const noexcept override;
     bool IsVtInputEnabled() const noexcept override;
     void NotifyAccessibilityChange(const til::rect& changedRect) noexcept override;
+    void SendNotification(const std::wstring_view title, const std::wstring_view body) override;
 #pragma endregion
 
     void ClearMark();
@@ -215,6 +216,7 @@ class Microsoft::Terminal::Core::Terminal final :
     void TaskbarProgressChangedCallback(std::function<void()> pfn) noexcept;
     void SetShowWindowCallback(std::function<void(bool)> pfn) noexcept;
     void SetPlayMidiNoteCallback(std::function<void(const int, const int, const std::chrono::microseconds)> pfn) noexcept;
+    void SetSendNotificationCallback(std::function<void(std::wstring_view, std::wstring_view)> pfn) noexcept;
 
     void SetCursorOn(const bool isOn);
     bool IsCursorBlinkingAllowed() const noexcept;
@@ -312,6 +314,7 @@ class Microsoft::Terminal::Core::Terminal final :
     std::function<void()> _pfnTaskbarProgressChanged;
     std::function<void(bool)> _pfnShowWindowChanged;
     std::function<void(const int, const int, const std::chrono::microseconds)> _pfnPlayMidiNote;
+    std::function<void(std::wstring_view, std::wstring_view)> _pfnSendNotification;
 
     RenderSettings _renderSettings;
     std::unique_ptr<::Microsoft::Console::VirtualTerminal::StateMachine> _stateMachine;

src/cascadia/TerminalCore/TerminalApi.cpp

@@ -332,3 +332,12 @@ void Terminal::NotifyAccessibilityChange(const til::rect& /*changedRect*/) noexc
 {
     // This is only needed in conhost. Terminal handles accessibility in another way.
 }
+
+void Terminal::SendNotification(const std::wstring_view title,
+                                const std::wstring_view body)
+{
+    if (_pfnSendNotification)
+    {
+        _pfnSendNotification(title, body);
+    }
+}