Add property to control dropdown speed of global summon

.github/actions/spelling/dictionary/apis.txt

@@ -34,6 +34,7 @@ HIGHCONTRASTON
 HIGHCONTRASTW
 hotkeys
 href
+hrgn
 IActivation
 IApp
 IAppearance
@@ -77,6 +78,7 @@ NOASYNC
 NOCHANGEDIR
 NOPROGRESS
 NOREDIRECTIONBITMAP
+NOREPEAT
 ntprivapi
 oaidl
 ocidl

NOTICE.md

@@ -251,3 +251,33 @@ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 DEALINGS IN THE SOFTWARE.
 
 ```
+
+## `VirtualDesktopUtils`
+
+**Source**: [https://github.com/microsoft/PowerToys](https://github.com/microsoft/PowerToys)
+
+### License
+
+```
+The MIT License
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+```

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

@@ -25,6 +25,12 @@
     <ClInclude Include="ProposeCommandlineResult.h">
       <DependentUpon>Monarch.idl</DependentUpon>
     </ClInclude>
+    <ClInclude Include="SummonWindowSelectionArgs.h">
+      <DependentUpon>Monarch.idl</DependentUpon>
+    </ClInclude>
+    <ClInclude Include="SummonWindowBehavior.h">
+      <DependentUpon>Peasant.idl</DependentUpon>
+    </ClInclude>
     <ClInclude Include="RenameRequestArgs.h">
       <DependentUpon>Peasant.idl</DependentUpon>
     </ClInclude>
@@ -54,6 +60,12 @@
     <ClCompile Include="ProposeCommandlineResult.cpp">
       <DependentUpon>Monarch.idl</DependentUpon>
     </ClCompile>
+    <ClCompile Include="SummonWindowSelectionArgs.cpp">
+      <DependentUpon>Monarch.idl</DependentUpon>
+    </ClCompile>
+    <ClCompile Include="SummonWindowBehavior.cpp">
+      <DependentUpon>Peasant.idl</DependentUpon>
+    </ClCompile>
     <ClCompile Include="RenameRequestArgs.cpp">
       <DependentUpon>Peasant.idl</DependentUpon>
     </ClCompile>

src/cascadia/Remoting/Monarch.cpp

@@ -375,7 +375,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
                 continue;
             }
 
-            if (peasant.WindowName() == L"_quake")
+            if (peasant.WindowName() == QuakeWindowName)
             {
                 // The _quake window should never be treated as the MRU window.
                 // Skip it if we see it. Users can still target it with `wt -w
@@ -686,4 +686,54 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
                               TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE));
         }
     }
+
+    // Method Description:
+    // - Attempt to summon a window. `args` contains information about which
+    //   window we should try to summon:
+    //   * if a WindowName is provided, we'll try to find a window with exactly
+    //     that name, and fail if there isn't one.
+    // - Calls Peasant::Summon on the matching peasant (which might be an RPC call)
+    // - This should only ever be called by the WindowManager in the monarch
+    //   process itself. The monarch is the one registering for global hotkeys,
+    //   so it's the one calling this method.
+    // Arguments:
+    // - args: contains information about the window that should be summoned.
+    // Return Value:
+    // - <none>
+    // - Sets args.FoundMatch when a window matching args is found successfully.
+    void Monarch::SummonWindow(const Remoting::SummonWindowSelectionArgs& args)
+    {
+        const auto searchedForName{ args.WindowName() };
+        try
+        {
+            args.FoundMatch(false);
+            uint64_t windowId = 0;
+            // If no name was provided, then just summon the MRU window.
+            if (searchedForName.empty())
+            {
+                // Use the value of the `desktop` arg to determine if we should
+                // limit to the current desktop (desktop:onCurrent) or not
+                // (desktop:any or desktop:toCurrent)
+                windowId = _getMostRecentPeasantID(args.OnCurrentDesktop());
+            }
+            else
+            {
+                // Try to find a peasant that currently has this name
+                windowId = _lookupPeasantIdForName(searchedForName);
+            }
+            if (auto targetPeasant{ _getPeasant(windowId) })
+            {
+                targetPeasant.Summon(args.SummonBehavior());
+                args.FoundMatch(true);
+            }
+        }
+        catch (...)
+        {
+            LOG_CAUGHT_EXCEPTION();
+            TraceLoggingWrite(g_hRemotingProvider,
+                              "Monarch_SummonWindow_Failed",
+                              TraceLoggingWideString(searchedForName.c_str(), "searchedForName", "The name of the window we tried to summon"),
+                              TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE));
+        }
+    }
 }

src/cascadia/Remoting/Monarch.h

@@ -49,6 +49,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
 
         winrt::Microsoft::Terminal::Remoting::ProposeCommandlineResult ProposeCommandline(const winrt::Microsoft::Terminal::Remoting::CommandlineArgs& args);
         void HandleActivatePeasant(const winrt::Microsoft::Terminal::Remoting::WindowActivatedArgs& args);
+        void SummonWindow(const Remoting::SummonWindowSelectionArgs& args);
 
         TYPED_EVENT(FindTargetWindowRequested, winrt::Windows::Foundation::IInspectable, winrt::Microsoft::Terminal::Remoting::FindTargetWindowArgs);
 

src/cascadia/Remoting/Monarch.idl

@@ -18,13 +18,27 @@ namespace Microsoft.Terminal.Remoting
         Boolean ShouldCreateWindow { get; }; // If you name this `CreateWindow`, the compiler will explode
     }
 
+    [default_interface] runtimeclass SummonWindowSelectionArgs {
+        SummonWindowSelectionArgs();
+        SummonWindowSelectionArgs(String windowName);
+        String WindowName;
+        Boolean OnCurrentDesktop;
+        // TODO GH#8888 Other options:
+        // * CurrentMonitor
+
+        Boolean FoundMatch;
+        SummonWindowBehavior SummonBehavior;
+    }
+
+
     [default_interface] runtimeclass Monarch {
         Monarch();
 
         UInt64 GetPID();
         UInt64 AddPeasant(IPeasant peasant);
         ProposeCommandlineResult ProposeCommandline(CommandlineArgs args);
         void HandleActivatePeasant(WindowActivatedArgs args);
+        void SummonWindow(SummonWindowSelectionArgs args);
 
         event Windows.Foundation.TypedEventHandler<Object, FindTargetWindowArgs> FindTargetWindowRequested;
     };

src/cascadia/Remoting/Peasant.cpp

@@ -4,6 +4,7 @@
 #include "pch.h"
 #include "Peasant.h"
 #include "CommandlineArgs.h"
+#include "SummonWindowBehavior.h"
 #include "Peasant.g.cpp"
 #include "../../types/inc/utils.hpp"
 
@@ -117,6 +118,28 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         return _lastActivatedArgs;
     }
 
+    // Method Description:
+    // - Summon this peasant to become the active window. Currently, it just
+    //   causes the peasant to become the active window wherever the window
+    //   already was.
+    // - Will raise a SummonRequested event to ask the hosting window to handle for us.
+    // Arguments:
+    // - <none>
+    // Return Value:
+    // - <none>
+    void Peasant::Summon(const Remoting::SummonWindowBehavior& summonBehavior)
+    {
+        auto localCopy = winrt::make<implementation::SummonWindowBehavior>(summonBehavior);
+
+        TraceLoggingWrite(g_hRemotingProvider,
+                          "Peasant_Summon",
+                          TraceLoggingUInt64(GetID(), "peasantID", "Our ID"),
+                          TraceLoggingUInt64(localCopy->MoveToCurrentDesktop(), "MoveToCurrentDesktop", "true if we should move to the current desktop"),
+                          TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE));
+
+        _SummonRequestedHandlers(*this, localCopy);
+    }
+
     // Method Description:
     // - Tell this window to display it's window ID. We'll raise a
     //   DisplayWindowIdRequested event, which will get handled in the AppHost,

src/cascadia/Remoting/Peasant.h

@@ -23,6 +23,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 Summon(const Remoting::SummonWindowBehavior& summonBehavior);
         void RequestIdentifyWindows();
         void DisplayWindowId();
         void RequestRename(const winrt::Microsoft::Terminal::Remoting::RenameRequestArgs& args);
@@ -37,6 +39,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         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);
+        TYPED_EVENT(SummonRequested, winrt::Windows::Foundation::IInspectable, winrt::Microsoft::Terminal::Remoting::SummonWindowBehavior);
 
     private:
         Peasant(const uint64_t testPID);

src/cascadia/Remoting/Peasant.idl

@@ -30,6 +30,15 @@ namespace Microsoft.Terminal.Remoting
         Windows.Foundation.DateTime ActivatedTime { get; };
     };
 
+    [default_interface] runtimeclass SummonWindowBehavior {
+        SummonWindowBehavior();
+        Boolean MoveToCurrentDesktop;
+        Boolean ToggleVisibility;
+        UInt32 DropdownDuration;
+        // Other options:
+        // * CurrentMonitor
+    }
+
     interface IPeasant
     {
         CommandlineArgs InitialArgs { get; };
@@ -40,17 +49,20 @@ namespace Microsoft.Terminal.Remoting
         Boolean ExecuteCommandline(CommandlineArgs args);
         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)
 
+        String WindowName { get; };
+        void RequestIdentifyWindows(); // Tells us to raise a IdentifyWindowsRequested
         void RequestRename(RenameRequestArgs args); // Tells us to raise a RenameRequested
+        void Summon(SummonWindowBehavior behavior);
 
         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;
+        event Windows.Foundation.TypedEventHandler<Object, SummonWindowBehavior> SummonRequested;
     };
 
     [default_interface] runtimeclass Peasant : IPeasant

src/cascadia/Remoting/SummonWindowBehavior.cpp

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

src/cascadia/Remoting/SummonWindowBehavior.h

@@ -0,0 +1,39 @@
+/*++
+Copyright (c) Microsoft Corporation
+Licensed under the MIT license.
+
+Class Name:
+- SummonWindowBehavior.h
+
+Abstract:
+- TODO!
+
+--*/
+
+#pragma once
+
+#include "SummonWindowBehavior.g.h"
+#include "../cascadia/inc/cppwinrt_utils.h"
+
+namespace winrt::Microsoft::Terminal::Remoting::implementation
+{
+    struct SummonWindowBehavior : public SummonWindowBehaviorT<SummonWindowBehavior>
+    {
+    public:
+        SummonWindowBehavior() = default;
+        WINRT_PROPERTY(bool, MoveToCurrentDesktop, true);
+        WINRT_PROPERTY(bool, ToggleVisibility, true);
+        WINRT_PROPERTY(uint32_t, DropdownDuration, 0);
+
+    public:
+        SummonWindowBehavior(const Remoting::SummonWindowBehavior& other) :
+            _MoveToCurrentDesktop{ other.MoveToCurrentDesktop() },
+            _DropdownDuration{ other.DropdownDuration() },
+            _ToggleVisibility{ other.ToggleVisibility() } {};
+    };
+}
+
+namespace winrt::Microsoft::Terminal::Remoting::factory_implementation
+{
+    BASIC_FACTORY(SummonWindowBehavior);
+}

src/cascadia/Remoting/SummonWindowSelectionArgs.cpp

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

src/cascadia/Remoting/SummonWindowSelectionArgs.h

@@ -0,0 +1,43 @@
+/*++
+Copyright (c) Microsoft Corporation
+Licensed under the MIT license.
+
+Class Name:
+- SummonWindowSelectionArgs.h
+
+Abstract:
+- This is a helper class for determining which window a should be summoned when
+  a global hotkey is pressed. Parameters from a GlobalSummon action will be
+  filled in here. The Monarch will use these to find the window that matches
+  these args, and Summon() that Peasant.
+- When the monarch finds a match, it will set FoundMatch to true. If it doesn't,
+  then the Monarch window might need to create a new window matching these args
+  instead.
+--*/
+
+#pragma once
+
+#include "SummonWindowSelectionArgs.g.h"
+#include "../cascadia/inc/cppwinrt_utils.h"
+
+namespace winrt::Microsoft::Terminal::Remoting::implementation
+{
+    struct SummonWindowSelectionArgs : public SummonWindowSelectionArgsT<SummonWindowSelectionArgs>
+    {
+    public:
+        SummonWindowSelectionArgs() = default;
+        SummonWindowSelectionArgs(winrt::hstring name) :
+            _WindowName{ name } {};
+
+        WINRT_PROPERTY(winrt::hstring, WindowName);
+
+        WINRT_PROPERTY(bool, FoundMatch, false);
+        WINRT_PROPERTY(bool, OnCurrentDesktop, false);
+        WINRT_PROPERTY(SummonWindowBehavior, SummonBehavior);
+    };
+}
+
+namespace winrt::Microsoft::Terminal::Remoting::factory_implementation
+{
+    BASIC_FACTORY(SummonWindowSelectionArgs);
+}

src/cascadia/Remoting/WindowManager.cpp

@@ -247,6 +247,8 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         // window, and when the current monarch dies.
 
         _monarch.FindTargetWindowRequested({ this, &WindowManager::_raiseFindTargetWindowRequested });
+
+        _BecameMonarchHandlers(*this, nullptr);
     }
 
     bool WindowManager::_areWeTheKing()
@@ -478,4 +480,18 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
     {
         _FindTargetWindowRequestedHandlers(sender, args);
     }
+
+    bool WindowManager::IsMonarch()
+    {
+        return _isKing;
+    }
+
+    void WindowManager::SummonWindow(const Remoting::SummonWindowSelectionArgs& args)
+    {
+        // We should only ever get called when we are the monarch, because only
+        // the monarch ever registers for the global hotkey. So the monarch is
+        // the only window that will be calling this.
+        _monarch.SummonWindow(args);
+    }
+
 }