Add support for renaming windows

doc/cascadia/profiles.schema.json

@@ -85,12 +85,14 @@
         "openNewTabDropdown",
         "openSettings",
         "openTabColorPicker",
+        "openWindowRenamer",
         "paste",
         "prevTab",
         "renameTab",
         "openTabRenamer",
         "resetFontSize",
         "resizePane",
+        "renameWindow",
         "scrollDown",
         "scrollDownPage",
         "scrollUp",
@@ -651,6 +653,38 @@
         }
       ]
     },
+    "RenameTabAction": {
+      "description": "Arguments corresponding to a renameTab Action",
+      "allOf": [
+        { "$ref": "#/definitions/ShortcutAction" },
+        {
+          "properties": {
+            "action": { "type": "string", "pattern": "renameTab" },
+            "title": {
+              "type": "string",
+              "default": "",
+              "description": "A title to assign to the tab. If omitted or null, this action will restore the tab's title to the original value."
+            }
+          }
+        }
+      ]
+    },
+    "RenameWindowAction": {
+      "description": "Arguments corresponding to a renameWindow Action",
+      "allOf": [
+        { "$ref": "#/definitions/ShortcutAction" },
+        {
+          "properties": {
+            "action": { "type": "string", "pattern": "renameWindow" },
+            "name": {
+              "type": "string",
+              "default": "",
+              "description": "A name to assign to the window."
+            }
+          }
+        }
+      ]
+    },
     "Keybinding": {
       "additionalProperties": false,
       "properties": {
@@ -679,6 +713,8 @@
               { "$ref": "#/definitions/NewWindowAction" },
               { "$ref": "#/definitions/NextTabAction" },
               { "$ref": "#/definitions/PrevTabAction" },
+              { "$ref": "#/definitions/RenameTabAction" },
+              { "$ref": "#/definitions/RenameWindowAction" },
               { "type": "null" }
             ]
         },

src/cascadia/LocalTests_TerminalApp/TabTests.cpp

@@ -85,6 +85,9 @@ namespace TerminalAppLocalTests
         TEST_METHOD(NextMRUTab);
         TEST_METHOD(VerifyCommandPaletteTabSwitcherOrder);
 
+        TEST_METHOD(TestWindowRenameSuccessful);
+        TEST_METHOD(TestWindowRenameFailure);
+
         TEST_CLASS_SETUP(ClassSetup)
         {
             return true;
@@ -948,4 +951,57 @@ namespace TerminalAppLocalTests
         // will also dismiss itself immediately when that's called. So we can't
         // really inspect the contents of the list in this test, unfortunately.
     }
+
+    void TabTests::TestWindowRenameSuccessful()
+    {
+        auto page = _commonSetup();
+        page->RenameWindowRequested([&page](auto&&, const winrt::TerminalApp::RenameWindowRequestedArgs args) {
+            // In the real terminal, this would bounce up to the monarch and
+            // come back down. Instead, immediately call back and set the name.
+            page->WindowName(args.ProposedName());
+        });
+
+        bool windowNameChanged = false;
+        page->PropertyChanged([&page, &windowNameChanged](auto&&, const winrt::WUX::Data::PropertyChangedEventArgs& args) mutable {
+            if (args.PropertyName() == L"WindowNameForDisplay")
+            {
+                windowNameChanged = true;
+            }
+        });
+
+        TestOnUIThread([&page]() {
+            page->_RequestWindowRename(winrt::hstring{ L"Foo" });
+        });
+        TestOnUIThread([&]() {
+            VERIFY_ARE_EQUAL(L"Foo", page->_WindowName);
+            VERIFY_IS_TRUE(windowNameChanged,
+                           L"The window name should have changed, and we should have raised a notification that WindowNameForDisplay changed");
+        });
+    }
+    void TabTests::TestWindowRenameFailure()
+    {
+        auto page = _commonSetup();
+        page->RenameWindowRequested([&page](auto&&, auto&&) {
+            // In the real terminal, this would bounce up to the monarch and
+            // come back down. Instead, immediately call back to tell the terminal it failed.
+            page->RenameFailed();
+        });
+
+        bool windowNameChanged = false;
+
+        page->PropertyChanged([&page, &windowNameChanged](auto&&, const winrt::WUX::Data::PropertyChangedEventArgs& args) mutable {
+            if (args.PropertyName() == L"WindowNameForDisplay")
+            {
+                windowNameChanged = true;
+            }
+        });
+
+        TestOnUIThread([&page]() {
+            page->_RequestWindowRename(winrt::hstring{ L"Foo" });
+        });
+        TestOnUIThread([&]() {
+            VERIFY_IS_FALSE(windowNameChanged,
+                            L"The window name should not have changed, we should have rejected the change.");
+        });
+    }
 }

src/cascadia/LocalTests_TerminalApp/pch.h

@@ -45,6 +45,7 @@ Author(s):
 #include <winrt/Windows.ui.input.h>
 #include <winrt/Windows.UI.Xaml.Controls.h>
 #include <winrt/Windows.UI.Xaml.Controls.Primitives.h>
+#include <winrt/Windows.UI.Xaml.Data.h>
 #include <winrt/Windows.ui.xaml.media.h>
 #include <winrt/Windows.ui.xaml.input.h>
 #include <winrt/Windows.UI.Xaml.Markup.h>

src/cascadia/Remoting/Microsoft.Terminal.RemotingLib.vcxproj

@@ -25,6 +25,9 @@
     <ClInclude Include="ProposeCommandlineResult.h">
       <DependentUpon>Monarch.idl</DependentUpon>
     </ClInclude>
+    <ClInclude Include="RenameRequestArgs.h">
+      <DependentUpon>Peasant.idl</DependentUpon>
+    </ClInclude>
     <ClInclude Include="WindowActivatedArgs.h">
       <DependentUpon>Peasant.idl</DependentUpon>
     </ClInclude>
@@ -51,6 +54,9 @@
     <ClCompile Include="ProposeCommandlineResult.cpp">
       <DependentUpon>Monarch.idl</DependentUpon>
     </ClCompile>
+    <ClCompile Include="RenameRequestArgs.cpp">
+      <DependentUpon>Peasant.idl</DependentUpon>
+    </ClCompile>
     <ClCompile Include="WindowActivatedArgs.cpp">
       <DependentUpon>Peasant.idl</DependentUpon>
     </ClCompile>

src/cascadia/Remoting/Monarch.cpp

@@ -76,6 +76,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
             // Add an event listener to the peasant's WindowActivated event.
             peasant.WindowActivated({ this, &Monarch::_peasantWindowActivated });
             peasant.IdentifyWindowsRequested({ this, &Monarch::_identifyWindows });
+            peasant.RenameRequested({ this, &Monarch::_renameRequested });
 
             _peasants[newPeasantsId] = peasant;
 
@@ -631,4 +632,52 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         };
         _forAllPeasantsIgnoringTheDead(callback, onError);
     }
+
+    // Method Description:
+    // - This is an event handler for the RenameRequested event. A
+    //   Peasant may raise that event when they want to be renamed to something else.
+    // - We will check if there are any other windows with this name. If there
+    //   are, then we'll reject the rename by setting args.Succeeded=false.
+    // - If there aren't any other windows with this name, then we'll set
+    //   args.Succeeded=true, allowing the window to keep this name.
+    // Arguments:
+    // - args: Contains the requested window name and a boolean (Succeeded)
+    //   indicating if the request was successful.
+    // Return Value:
+    // - <none>
+    void Monarch::_renameRequested(const winrt::Windows::Foundation::IInspectable& /*sender*/,
+                                   const winrt::Microsoft::Terminal::Remoting::RenameRequestArgs& args)
+    {
+        bool successfullyRenamed = false;
+
+        try
+        {
+            args.Succeeded(false);
+            const auto name{ args.NewName() };
+            // Try to find a peasant that currently has this name
+            const auto id = _lookupPeasantIdForName(name);
+            if (_getPeasant(id) == nullptr)
+            {
+                // If there is one, then oh no! The requestor is not allowed to
+                // be renamed.
+                args.Succeeded(true);
+                successfullyRenamed = true;
+            }
+
+            TraceLoggingWrite(g_hRemotingProvider,
+                              "Monarch_renameRequested",
+                              TraceLoggingWideString(name.c_str(), "name", "The newly proposed name"),
+                              TraceLoggingInt64(successfullyRenamed, "successfullyRenamed", "true if the peasant is allowed to rename themselves to that name."),
+                              TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE));
+        }
+        catch (...)
+        {
+            LOG_CAUGHT_EXCEPTION();
+            // If this fails, we don't _really_ care. The peasant died, but
+            // they're the only one who cares about the result.
+            TraceLoggingWrite(g_hRemotingProvider,
+                              "Monarch_renameRequested_Failed",
+                              TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE));
+        }
+    }
 }

src/cascadia/Remoting/Monarch.h

@@ -74,11 +74,15 @@ 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 _forAllPeasantsIgnoringTheDead(std::function<void(const winrt::Microsoft::Terminal::Remoting::IPeasant&, const uint64_t)> callback,
+                                            std::function<void(const uint64_t)> errorCallback);
+
         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);
+        void _renameRequested(const winrt::Windows::Foundation::IInspectable& sender,
+                              const winrt::Microsoft::Terminal::Remoting::RenameRequestArgs& args);
+
         friend class RemotingUnitTests::RemotingTests;
     };
 }

src/cascadia/Remoting/Peasant.cpp

@@ -164,4 +164,34 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
                           TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE));
     }
 
+    void Peasant::RequestRename(const winrt::Microsoft::Terminal::Remoting::RenameRequestArgs& args)
+    {
+        bool successfullyNotified = false;
+        const auto oldName{ _WindowName };
+        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.
+            _RenameRequestedHandlers(*this, args);
+            if (args.Succeeded())
+            {
+                _WindowName = args.NewName();
+            }
+            successfullyNotified = true;
+        }
+        catch (...)
+        {
+            LOG_CAUGHT_EXCEPTION();
+        }
+        TraceLoggingWrite(g_hRemotingProvider,
+                          "Peasant_RequestRename",
+                          TraceLoggingUInt64(GetID(), "peasantID", "Our ID"),
+                          TraceLoggingWideString(oldName.c_str(), "oldName", "Our old name"),
+                          TraceLoggingWideString(args.NewName().c_str(), "newName", "The proposed name"),
+                          TraceLoggingBoolean(args.Succeeded(), "succeeded", "true if the monarch ok'd this new name for us."),
+                          TraceLoggingBoolean(successfullyNotified, "successfullyNotified", "true if we successfully notified the monarch"),
+                          TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE));
+    }
 }

src/cascadia/Remoting/Peasant.h

@@ -5,6 +5,7 @@
 
 #include "Peasant.g.h"
 #include "../cascadia/inc/cppwinrt_utils.h"
+#include "RenameRequestArgs.h"
 
 namespace RemotingUnitTests
 {
@@ -24,6 +25,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         void ActivateWindow(const winrt::Microsoft::Terminal::Remoting::WindowActivatedArgs& args);
         void RequestIdentifyWindows();
         void DisplayWindowId();
+        void RequestRename(const winrt::Microsoft::Terminal::Remoting::RenameRequestArgs& args);
 
         winrt::Microsoft::Terminal::Remoting::WindowActivatedArgs GetLastActivatedArgs();
 
@@ -34,6 +36,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         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);
+        TYPED_EVENT(RenameRequested, winrt::Windows::Foundation::IInspectable, winrt::Microsoft::Terminal::Remoting::RenameRequestArgs);
 
     private:
         Peasant(const uint64_t testPID);

src/cascadia/Remoting/Peasant.idl

@@ -13,6 +13,13 @@ namespace Microsoft.Terminal.Remoting
         String CurrentDirectory();
     };
 
+    runtimeclass RenameRequestArgs
+    {
+        RenameRequestArgs(String newName);
+        String NewName { get; };
+        Boolean Succeeded;
+    };
+
     runtimeclass WindowActivatedArgs
     {
         WindowActivatedArgs(UInt64 peasantID, Guid desktopID, Windows.Foundation.DateTime activatedTime);
@@ -37,10 +44,13 @@ namespace Microsoft.Terminal.Remoting
         void RequestIdentifyWindows(); // Tells us to raise a IdentifyWindowsRequested
         void DisplayWindowId(); // Tells us to display its own ID (which causes a DisplayWindowIdRequested to be raised)
 
+        void RequestRename(RenameRequestArgs args); // Tells us to raise a RenameRequested
+
         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;
+        event Windows.Foundation.TypedEventHandler<Object, RenameRequestArgs> RenameRequested;
     };
 
     [default_interface] runtimeclass Peasant : IPeasant

src/cascadia/Remoting/RenameRequestArgs.cpp

@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+#include "pch.h"
+#include "RenameRequestArgs.h"
+#include "RenameRequestArgs.g.cpp"

src/cascadia/Remoting/RenameRequestArgs.h

@@ -0,0 +1,30 @@
+/*++
+Copyright (c) Microsoft Corporation
+Licensed under the MIT license.
+
+Class Name:
+- RenameRequestArgs.h
+
+--*/
+#pragma once
+
+#include "RenameRequestArgs.g.h"
+#include "../cascadia/inc/cppwinrt_utils.h"
+
+namespace winrt::Microsoft::Terminal::Remoting::implementation
+{
+    struct RenameRequestArgs : public RenameRequestArgsT<RenameRequestArgs>
+    {
+        WINRT_PROPERTY(winrt::hstring, NewName);
+        WINRT_PROPERTY(bool, Succeeded, false);
+
+    public:
+        RenameRequestArgs(winrt::hstring newName) :
+            _NewName{ newName } {};
+    };
+}
+
+namespace winrt::Microsoft::Terminal::Remoting::factory_implementation
+{
+    BASIC_FACTORY(RenameRequestArgs);
+}