Add support for OSC777 - send notification

.github/actions/spelling/allow/allow.txt

@@ -117,6 +117,7 @@ uiatextrange
 UIs
 und
 unregister
+urxvt
 versioned
 vsdevcmd
 walkthrough

src/cascadia/Remoting/WindowManager.cpp

@@ -461,4 +461,35 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         co_await winrt::resume_background();
         _monarch.RequestSendContent(args);
     }
+
+    // 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);
+
+        // Summon the window...
+        // * On its current desktop
+        // * Without a dropdown
+        // * On the monitor it is already on
+        // * Do not toggle, just make visible.
+        const Remoting::SummonWindowBehavior summonArgs{};
+        summonArgs.MoveToCurrentDesktop(false);
+        summonArgs.DropdownDuration(0);
+        summonArgs.ToMonitor(Remoting::MonitorBehavior::InPlace);
+        summonArgs.ToggleVisibility(false);
+
+        args.SummonBehavior(summonArgs);
+        monarch.SummonWindow(args);
+        return true;
+    }
 }

src/cascadia/Remoting/WindowManager.h

@@ -47,6 +47,8 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         winrt::fire_and_forget RequestMoveContent(winrt::hstring window, winrt::hstring content, uint32_t tabIndex, Windows::Foundation::IReference<Windows::Foundation::Rect> windowBounds);
         winrt::fire_and_forget RequestSendContent(Remoting::RequestReceiveContentArgs args);
 
+        static bool SummonForNotification(const uint64_t windowId);
+
         TYPED_EVENT(FindTargetWindowRequested, winrt::Windows::Foundation::IInspectable, winrt::Microsoft::Terminal::Remoting::FindTargetWindowArgs);
 
         TYPED_EVENT(WindowCreated, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);

src/cascadia/Remoting/WindowManager.idl

@@ -29,6 +29,8 @@ namespace Microsoft.Terminal.Remoting
         void RequestMoveContent(String window, String content, UInt32 tabIndex, Windows.Foundation.IReference<Windows.Foundation.Rect> bounds);
         void RequestSendContent(RequestReceiveContentArgs args);
 
+        static Boolean SummonForNotification(UInt64 windowId);
+
         event Windows.Foundation.TypedEventHandler<Object, FindTargetWindowArgs> FindTargetWindowRequested;
 
         event Windows.Foundation.TypedEventHandler<Object, Object> WindowCreated;

src/cascadia/TerminalApp/TerminalPage.cpp

@@ -14,6 +14,7 @@
 
 #include <inc/WindowingBehavior.h>
 #include <LibraryResources.h>
+#include <WtExeUtils.h>
 #include <TerminalCore/ControlKeyStates.hpp>
 #include <til/latch.h>
 
@@ -45,6 +46,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
@@ -1671,6 +1675,7 @@ namespace winrt::TerminalApp::implementation
         {
             term.CompletionsChanged({ get_weak(), &TerminalPage::_ControlCompletionsChangedHandler });
         }
+
         winrt::weak_ref<TermControl> weakTerm{ term };
         term.ContextMenu().Opening([weak = get_weak(), weakTerm](auto&& sender, auto&& /*args*/) {
             if (const auto& page{ weak.get() })
@@ -1684,6 +1689,7 @@ namespace winrt::TerminalApp::implementation
                 page->_PopulateContextMenu(weakTerm.get(), sender.try_as<MUX::Controls::CommandBarFlyout>(), true);
             }
         });
+        term.SendNotification({ get_weak(), &TerminalPage::_SendNotificationHandler });
     }
 
     // Method Description:
@@ -2958,6 +2964,110 @@ namespace winrt::TerminalApp::implementation
         _ShowWindowChangedHandlers(*this, args);
     }
 
+    // Method Description:
+    // - Handler for a control's SendNotification event. `args` will contain the
+    //   title and body of the notification requested by the client application.
+    // - This will only actually send a notification when the sender is
+    //   - in an inactive window OR
+    //   - in an inactive tab.
+    winrt::fire_and_forget TerminalPage::_SendNotificationHandler(const IInspectable sender,
+                                                                  const Microsoft::Terminal::Control::SendNotificationArgs args)
+    {
+        // This never works as expected when we're an elevated instance. The
+        // notification will end up launching an unelevated instance to handle
+        // it, and there's no good way to get back to the elevated one.
+        // Possibly revisit after GH #13276.
+        //
+        // We're using CanDragDrop, because TODO! I bet this works with UAC disabled
+        if (!CanDragDrop())
+        {
+            co_return;
+        }
+
+        auto weakThis = get_weak();
+
+        co_await resume_foreground(Dispatcher());
+        auto page{ weakThis.get() };
+        if (page)
+        {
+            // If the window is inactive, we always 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());
+        }
+    }
+
+    // Actually write the payload to a XML doc and load it into a ToastNotification.
+    void TerminalPage::_sendNotification(const std::wstring_view title,
+                                         const std::wstring_view body)
+    {
+        // ToastNotificationManager::CreateToastNotifier doesn't work in
+        // unpackaged scenarios without an AUMID. We probably don't have one if
+        // we're unpackaged. Unpackaged isn't a wholly supported scenario
+        // anyways, so let's just bail.
+
+        if (!IsPackaged())
+        {
+            return;
+        }
+
+        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", WindowProperties().WindowId()) };
+        doc.DocumentElement().SetAttribute(L"launch", payload);
+        doc.SelectSingleNode(L"//text[1]").InnerText(title);
+        doc.SelectSingleNode(L"//text[2]").InnerText(body);
+
+        // Construct the notification
+        ToastNotification notification{ doc };
+
+        // lazy-init
+        if (!_toastNotifier)
+        {
+            _toastNotifier = ToastNotificationManager::CreateToastNotifier();
+        }
+
+        // And show it!
+        _toastNotifier.Show(notification);
+    }
+
     // Method Description:
     // - Paste text from the Windows Clipboard to the focused terminal
     void TerminalPage::_PasteText()

src/cascadia/TerminalApp/TerminalPage.h

@@ -287,6 +287,9 @@ namespace winrt::TerminalApp::implementation
         __declspec(noinline) SuggestionsControl _loadSuggestionsElementSlowPath();
         bool _suggestionsControlIs(winrt::Windows::UI::Xaml::Visibility visibility);
 
+        // todo! maybe move to TerminalWindow
+        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();
@@ -543,6 +546,9 @@ namespace winrt::TerminalApp::implementation
         winrt::Microsoft::Terminal::Control::TermControl _senderOrActiveControl(const winrt::Windows::Foundation::IInspectable& sender);
         winrt::com_ptr<TerminalTab> _senderOrFocusedTab(const IInspectable& sender);
 
+        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/pch.h

@@ -27,6 +27,8 @@
 
 #include <winrt/Windows.ApplicationModel.h>
 #include <winrt/Windows.ApplicationModel.DataTransfer.h>
+#include <winrt/Windows.ApplicationModel.Activation.h>
+#include <winrt/Windows.Data.Xml.Dom.h>
 #include <winrt/Windows.Foundation.h>
 #include <winrt/Windows.Foundation.Collections.h>
 #include <winrt/Windows.Foundation.Metadata.h>
@@ -35,6 +37,7 @@
 #include <winrt/Windows.System.h>
 #include <winrt/Windows.UI.Core.h>
 #include <winrt/Windows.UI.Input.h>
+#include <winrt/Windows.UI.Notifications.h>
 #include <winrt/Windows.UI.Text.h>
 #include <winrt/Windows.UI.ViewManagement.h>
 #include <winrt/Windows.UI.Xaml.Automation.Peers.h>

src/cascadia/TerminalControl/ControlCore.cpp

@@ -126,6 +126,9 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         auto pfnCompletionsChanged = [=](auto&& menuJson, auto&& replaceLength) { _terminalCompletionsChanged(menuJson, replaceLength); };
         _terminal->CompletionsChangedCallback(pfnCompletionsChanged);
 
+        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
@@ -1585,6 +1588,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)
+    {
+        const auto e = winrt::make_self<implementation::SendNotificationArgs>(title, body);
+        _SendNotificationHandlers(*this, *e);
+    }
+
     bool ControlCore::HasSelection() const
     {
         const auto lock = _terminal->LockForReading();

src/cascadia/TerminalControl/ControlCore.h

@@ -280,6 +280,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         TYPED_EVENT(RestartTerminalRequested,    IInspectable, IInspectable);
 
         TYPED_EVENT(Attached,                  IInspectable, IInspectable);
+
+        TYPED_EVENT(SendNotification,          IInspectable, Control::SendNotificationArgs);
         // clang-format on
 
     private:
@@ -372,6 +374,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
         winrt::fire_and_forget _terminalCompletionsChanged(std::wstring_view menuJson, unsigned int replaceLength);
 
+        void _terminalSendNotification(const std::wstring_view title,
+                                       const std::wstring_view body);
 #pragma endregion
 
         MidiAudio _midiAudio;

src/cascadia/TerminalControl/ControlCore.idl

@@ -190,5 +190,7 @@ namespace Microsoft.Terminal.Control
 
         event Windows.Foundation.TypedEventHandler<Object, CompletionsChangedEventArgs> CompletionsChanged;
 
+        event Windows.Foundation.TypedEventHandler<Object, SendNotificationArgs> SendNotification;
+
     };
 }

src/cascadia/TerminalControl/EventArgs.cpp

@@ -20,3 +20,4 @@
 #include "KeySentEventArgs.g.cpp"
 #include "CharSentEventArgs.g.cpp"
 #include "StringSentEventArgs.g.cpp"
+#include "SendNotificationArgs.g.cpp"

src/cascadia/TerminalControl/EventArgs.h

@@ -20,6 +20,7 @@
 #include "KeySentEventArgs.g.h"
 #include "CharSentEventArgs.g.h"
 #include "StringSentEventArgs.g.h"
+#include "SendNotificationArgs.g.h"
 
 namespace winrt::Microsoft::Terminal::Control::implementation
 {
@@ -251,6 +252,20 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
         WINRT_PROPERTY(winrt::hstring, Text);
     };
+
+    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);
+    };
 }
 
 namespace winrt::Microsoft::Terminal::Control::factory_implementation

src/cascadia/TerminalControl/EventArgs.idl

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

src/cascadia/TerminalControl/TermControl.cpp

@@ -104,6 +104,14 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
         _revokers.PasteFromClipboard = _interactivity.PasteFromClipboard(winrt::auto_revoke, { get_weak(), &TermControl::_bubblePasteFromClipboard });
 
+        // 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

@@ -194,6 +194,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         TYPED_EVENT(KeySent,                   IInspectable, Control::KeySentEventArgs);
         TYPED_EVENT(CharSent,                  IInspectable, Control::CharSentEventArgs);
         TYPED_EVENT(StringSent,                IInspectable, Control::StringSentEventArgs);
+        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

@@ -58,6 +58,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<Object, CompletionsChangedEventArgs> CompletionsChanged;
 

src/cascadia/TerminalCore/ICoreSettings.idl

@@ -28,6 +28,7 @@ namespace Microsoft.Terminal.Core
         Windows.Foundation.IReference<Microsoft.Terminal.Core.Color> StartingTabColor;
 
         Boolean AutoMarkPrompts;
+        Boolean AllowNotifications;
 
     };
 

src/cascadia/TerminalCore/Terminal.cpp

@@ -95,6 +95,7 @@ void Terminal::UpdateSettings(ICoreSettings settings)
     _startingTitle = settings.StartingTitle();
     _trimBlockSelection = settings.TrimBlockSelection();
     _autoMarkPrompts = settings.AutoMarkPrompts();
+    _allowNotifications = settings.AllowNotifications();
 
     _getTerminalInput().ForceDisableWin32InputMode(settings.ForceVTInput());
 
@@ -1160,6 +1161,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);
+}
+
 void Terminal::BlinkCursor() noexcept
 {
     if (_selectionMode != SelectionInteractionMode::Mark)