Add an action for identifying windows

src/cascadia/Remoting/Monarch.cpp

@@ -75,6 +75,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
             auto newPeasantsId = peasant.GetID();
             // Add an event listener to the peasant's WindowActivated event.
             peasant.WindowActivated({ this, &Monarch::_peasantWindowActivated });
+            peasant.IdentifyWindowsRequested({ this, &Monarch::_identifyWindows });
 
             _peasants[newPeasantsId] = peasant;
 
@@ -571,4 +572,63 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         result->WindowName(targetWindowName);
         return *result;
     }
+
+    // Method Description:
+    // - Helper for doing something on each and every peasant, with no regard
+    //   for if the peasant is living or dead.
+    // - We'll try calling callback on every peasant.
+    // - If any single peasant is dead, then we'll call errorCallback, and move on.
+    // - We're taking an errorCallback here, because the thing we usually want
+    //   to do is TraceLog a message, but TraceLoggingWrite is actually a macro
+    //   that _requires_ the second arg to be a string literal. It can't just be
+    //   a variable.
+    // Arguments:
+    // - callback: The function to call on each peasant
+    // - errorCallback: The function to call if a peasant is dead.
+    // Return Value:
+    // - <none>
+    void Monarch::_forAllPeasantsIgnoringTheDead(std::function<void(const Remoting::IPeasant&, const uint64_t)> callback,
+                                                 std::function<void(const uint64_t)> errorCallback)
+    {
+        for (const auto& [id, p] : _peasants)
+        {
+            try
+            {
+                callback(p, id);
+            }
+            catch (...)
+            {
+                LOG_CAUGHT_EXCEPTION();
+                // If this fails, we don't _really_ care. Just move on to the
+                // next one. Someone else will clean up the dead peasant.
+                errorCallback(id);
+            }
+        }
+    }
+
+    // Method Description:
+    // - This is an event handler for the IdentifyWindowsRequested event. A
+    //   Peasant may raise that event if they want _all_ windows to identify
+    //   themselves.
+    // - This will tell each and every peasant to identify themselves. This will
+    //   eventually propagate down to TerminalPage::IdentifyWindow.
+    // Arguments:
+    // - <unused>
+    // Return Value:
+    // - <none>
+    void Monarch::_identifyWindows(const winrt::Windows::Foundation::IInspectable& /*sender*/,
+                                   const winrt::Windows::Foundation::IInspectable& /*args*/)
+    {
+        // Notify all the peasants to display their ID.
+        auto callback = [](auto&& p, auto&& /*id*/) {
+            p.DisplayWindowId();
+        };
+        auto onError = [](auto&& id) {
+            TraceLoggingWrite(g_hRemotingProvider,
+                              "Monarch_identifyWindows_Failed",
+                              TraceLoggingInt64(id, "peasantID", "The ID of the peasant which we could not identify"),
+                              TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE));
+        };
+        _forAllPeasantsIgnoringTheDead(callback, onError);
+    }
 }

src/cascadia/Remoting/Monarch.h

@@ -74,6 +74,11 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         void _doHandleActivatePeasant(const winrt::com_ptr<winrt::Microsoft::Terminal::Remoting::implementation::WindowActivatedArgs>& args);
         void _clearOldMruEntries(const uint64_t peasantID);
 
+        void _identifyWindows(const winrt::Windows::Foundation::IInspectable& sender,
+                              const winrt::Windows::Foundation::IInspectable& args);
+
+        void _forAllPeasantsIgnoringTheDead(std::function<void(const winrt::Microsoft::Terminal::Remoting::IPeasant&, const uint64_t)> callback,
+                                            std::function<void(const uint64_t)> errorCallback);
         friend class RemotingUnitTests::RemotingTests;
     };
 }

src/cascadia/Remoting/Peasant.cpp

@@ -117,4 +117,51 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         return _lastActivatedArgs;
     }
 
+    // Method Description:
+    // - Tell this window to display it's window ID. We'll raise a
+    //   DisplayWindowIdRequested event, which will get handled in the AppHost,
+    //   and used to tell the app to display the ID toast.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    void Peasant::DisplayWindowId()
+    {
+        // Not worried about try/catching this. The handler is in AppHost, which
+        // is in-proc for us.
+        _DisplayWindowIdRequestedHandlers(*this, nullptr);
+    }
+
+    // Method Description:
+    // - Raises an event to ask that all windows be identified. This will come
+    //   back to us when the Monarch handles the event and calls our
+    //   DisplayWindowId method.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    void Peasant::RequestIdentifyWindows()
+    {
+        bool successfullyNotified = false;
+
+        try
+        {
+            // Try/catch this, because the other side of this event is handled
+            // by the monarch. The monarch might have died. If they have, this
+            // will throw an exception. Just eat it, the election thread will
+            // handle hooking up the new one.
+            _IdentifyWindowsRequestedHandlers(*this, nullptr);
+            successfullyNotified = true;
+        }
+        catch (...)
+        {
+            LOG_CAUGHT_EXCEPTION();
+        }
+        TraceLoggingWrite(g_hRemotingProvider,
+                          "Peasant_RequestIdentifyWindows",
+                          TraceLoggingUInt64(GetID(), "peasantID", "Our ID"),
+                          TraceLoggingBoolean(successfullyNotified, "successfullyNotified", "true if we successfully notified the monarch"),
+                          TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE));
+    }
+
 }

src/cascadia/Remoting/Peasant.h

@@ -22,6 +22,8 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
 
         bool ExecuteCommandline(const winrt::Microsoft::Terminal::Remoting::CommandlineArgs& args);
         void ActivateWindow(const winrt::Microsoft::Terminal::Remoting::WindowActivatedArgs& args);
+        void RequestIdentifyWindows();
+        void DisplayWindowId();
 
         winrt::Microsoft::Terminal::Remoting::WindowActivatedArgs GetLastActivatedArgs();
 
@@ -30,6 +32,8 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
 
         TYPED_EVENT(WindowActivated, winrt::Windows::Foundation::IInspectable, winrt::Microsoft::Terminal::Remoting::WindowActivatedArgs);
         TYPED_EVENT(ExecuteCommandlineRequested, winrt::Windows::Foundation::IInspectable, winrt::Microsoft::Terminal::Remoting::CommandlineArgs);
+        TYPED_EVENT(IdentifyWindowsRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
+        TYPED_EVENT(DisplayWindowIdRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
 
     private:
         Peasant(const uint64_t testPID);

src/cascadia/Remoting/Peasant.idl

@@ -34,9 +34,13 @@ namespace Microsoft.Terminal.Remoting
         void ActivateWindow(WindowActivatedArgs args);
         WindowActivatedArgs GetLastActivatedArgs();
         String WindowName { get; };
+        void RequestIdentifyWindows(); // Tells us to raise a IdentifyWindowsRequested
+        void DisplayWindowId(); // Tells us to display its own ID (which causes a DisplayWindowIdRequested to be raised)
 
         event Windows.Foundation.TypedEventHandler<Object, WindowActivatedArgs> WindowActivated;
         event Windows.Foundation.TypedEventHandler<Object, CommandlineArgs> ExecuteCommandlineRequested;
+        event Windows.Foundation.TypedEventHandler<Object, Object> IdentifyWindowsRequested;
+        event Windows.Foundation.TypedEventHandler<Object, Object> DisplayWindowIdRequested;
     };
 
     [default_interface] runtimeclass Peasant : IPeasant

src/cascadia/TerminalApp/AppActionHandlers.cpp

@@ -552,8 +552,8 @@ namespace winrt::TerminalApp::implementation
         }
     }
 
-    void TerminalPage::_HandleOpenTabSearch(const IInspectable& /*sender*/,
-                                            const ActionEventArgs& args)
+    void TerminalPage::_HandleTabSearch(const IInspectable& /*sender*/,
+                                        const ActionEventArgs& args)
     {
         CommandPalette().SetTabs(_tabs, _mruTabs);
         CommandPalette().EnableTabSearchMode();
@@ -675,4 +675,37 @@ namespace winrt::TerminalApp::implementation
         actionArgs.Handled(true);
     }
 
+    // Method Description:
+    // - Raise a IdentifyWindowsRequested event. This will bubble up to the
+    //   AppLogic, to the AppHost, to the Peasant, to the Monarch, then get
+    //   distributed down to _all_ the Peasants, as to display info about the
+    //   window in _every_ Peasant window.
+    // - This action is also buggy right now, because TeachingTips behave
+    //   weird in XAML Islands. See microsoft-ui-xaml#4382
+    // Arguments:
+    // - <unused>
+    // Return Value:
+    // - <none>
+    void TerminalPage::_HandleIdentifyWindows(const IInspectable& /*sender*/,
+                                              const ActionEventArgs& args)
+    {
+        _IdentifyWindowsRequestedHandlers(*this, nullptr);
+        args.Handled(true);
+    }
+
+    // Method Description:
+    // - Display the "Toast" with the name and ID of this window.
+    // - Unlike _HandleIdentifyWindow**s**, this event just displays the window
+    //   ID and name in the current window. It does not involve any bubbling
+    //   up/down the page/logic/host/manager/peasant/monarch.
+    // Arguments:
+    // - <unused>
+    // Return Value:
+    // - <none>
+    void TerminalPage::_HandleIdentifyWindow(const IInspectable& /*sender*/,
+                                             const ActionEventArgs& args)
+    {
+        IdentifyWindow();
+        args.Handled(true);
+    }
 }

src/cascadia/TerminalApp/AppLogic.cpp

@@ -1369,4 +1369,34 @@ namespace winrt::TerminalApp::implementation
         return _root ? _root->AlwaysOnTop() : false;
     }
 
+    void AppLogic::IdentifyWindow()
+    {
+        if (_root)
+        {
+            _root->IdentifyWindow();
+        }
+    }
+
+    winrt::hstring AppLogic::WindowName()
+    {
+        return _root ? _root->WindowName() : L"";
+    }
+    void AppLogic::WindowName(const winrt::hstring& name)
+    {
+        if (_root)
+        {
+            _root->WindowName(name);
+        }
+    }
+    uint64_t AppLogic::WindowId()
+    {
+        return _root ? _root->WindowId() : 0;
+    }
+    void AppLogic::WindowId(const uint64_t& id)
+    {
+        if (_root)
+        {
+            _root->WindowId(id);
+        }
+    }
 }

src/cascadia/TerminalApp/AppLogic.h

@@ -60,6 +60,12 @@ namespace winrt::TerminalApp::implementation
         bool Fullscreen() const;
         bool AlwaysOnTop() const;
 
+        void IdentifyWindow();
+        winrt::hstring WindowName();
+        void WindowName(const winrt::hstring& name);
+        uint64_t WindowId();
+        void WindowId(const uint64_t& id);
+
         Windows::Foundation::Size GetLaunchDimensions(uint32_t dpi);
         bool CenterOnLaunch();
         TerminalApp::InitialPosition GetInitialPosition(int64_t defaultInitialX, int64_t defaultInitialY);
@@ -149,6 +155,7 @@ namespace winrt::TerminalApp::implementation
         FORWARDED_TYPED_EVENT(AlwaysOnTopChanged, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable, _root, AlwaysOnTopChanged);
         FORWARDED_TYPED_EVENT(RaiseVisualBell, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable, _root, RaiseVisualBell);
         FORWARDED_TYPED_EVENT(SetTaskbarProgress, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable, _root, SetTaskbarProgress);
+        FORWARDED_TYPED_EVENT(IdentifyWindowsRequested, Windows::Foundation::IInspectable, Windows::Foundation::IInspectable, _root, IdentifyWindowsRequested);
 
 #ifdef UNIT_TESTING
         friend class TerminalAppLocalTests::CommandlineTest;

src/cascadia/TerminalApp/AppLogic.idl

@@ -48,6 +48,10 @@ namespace TerminalApp
         Boolean Fullscreen { get; };
         Boolean AlwaysOnTop { get; };
 
+        void IdentifyWindow();
+        String WindowName;
+        UInt64 WindowId;
+
         Windows.Foundation.Size GetLaunchDimensions(UInt32 dpi);
         Boolean CenterOnLaunch { get; };
 
@@ -78,5 +82,6 @@ namespace TerminalApp
         event Windows.Foundation.TypedEventHandler<Object, Object> AlwaysOnTopChanged;
         event Windows.Foundation.TypedEventHandler<Object, Object> RaiseVisualBell;
         event Windows.Foundation.TypedEventHandler<Object, Object> SetTaskbarProgress;
+        event Windows.Foundation.TypedEventHandler<Object, Object> IdentifyWindowsRequested;
     }
 }

src/cascadia/TerminalApp/Resources/en-US/Resources.resw

@@ -588,6 +588,14 @@
   <data name="CommandPalette_MoreOptions.[using:Windows.UI.Xaml.Automation]AutomationProperties.HelpText" xml:space="preserve">
     <value>More options</value>
   </data>
+  <data name="WindowIdLabel" xml:space="preserve">
+    <value>Window</value>
+    <comment>This is displayed as a label for a number, like "Window: 10"</comment>
+  </data>
+  <data name="UnnamedWindowName" xml:space="preserve">
+    <value>unnamed window</value>
+    <comment>text used to identify when a window hasn't been assigned a name by the user</comment>
+  </data>
   <data name="WindowMaximizeButtonToolTip" xml:space="preserve">
     <value>Maximize</value>
   </data>