Introduce a ContentManager helper

src/cascadia/TerminalApp/AppLogic.cpp

@@ -721,7 +721,7 @@ namespace winrt::TerminalApp::implementation
                                                           warnings,
                                                           _settings);
 
-        auto window = winrt::make_self<implementation::TerminalWindow>(*ev);
+        auto window = winrt::make_self<implementation::TerminalWindow>(*ev, _contentManager);
 
         this->SettingsChanged({ window->get_weak(), &implementation::TerminalWindow::UpdateSettingsHandler });
         if (_hasSettingsStartupActions)
@@ -731,6 +731,11 @@ namespace winrt::TerminalApp::implementation
         return *window;
     }
 
+    winrt::TerminalApp::ContentManager AppLogic::ContentManager()
+    {
+        return _contentManager;
+    }
+
     bool AppLogic::ShouldUsePersistedLayout() const
     {
         return _settings.GlobalSettings().ShouldUsePersistedLayout();

src/cascadia/TerminalApp/AppLogic.h

@@ -10,6 +10,7 @@
 #include "LanguageProfileNotifier.h"
 #include "AppCommandlineArgs.h"
 #include "TerminalWindow.h"
+#include "ContentManager.h"
 
 #include <inc/cppwinrt_utils.h>
 #include <ThrottledFunc.h>
@@ -70,6 +71,8 @@ namespace winrt::TerminalApp::implementation
 
         TerminalApp::TerminalWindow CreateNewWindow();
 
+        winrt::TerminalApp::ContentManager ContentManager();
+
         TerminalApp::ParseCommandlineResult GetParseCommandlineMessage(array_view<const winrt::hstring> args);
 
         TYPED_EVENT(SettingsChanged, winrt::Windows::Foundation::IInspectable, winrt::TerminalApp::SettingsLoadEventArgs);
@@ -98,6 +101,8 @@ namespace winrt::TerminalApp::implementation
         winrt::com_ptr<LanguageProfileNotifier> _languageProfileNotifier;
         wil::unique_folder_change_reader_nothrow _reader;
 
+        TerminalApp::ContentManager _contentManager{ *winrt::make_self<implementation::ContentManager>() };
+
         static TerminalApp::FindTargetWindowResult _doFindTargetWindow(winrt::array_view<const hstring> args,
                                                                        const Microsoft::Terminal::Settings::Model::WindowingMode& windowingBehavior);
 

src/cascadia/TerminalApp/AppLogic.idl

@@ -34,6 +34,8 @@ namespace TerminalApp
         Boolean IsRunningElevated();
         Boolean CanDragDrop();
 
+        ContentManager ContentManager { get; };
+
         Boolean HasSettingsStartupActions();
 
         Boolean ShouldUsePersistedLayout();

src/cascadia/TerminalApp/ContentManager.cpp

@@ -0,0 +1,53 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#include "pch.h"
+#include "ContentManager.h"
+#include "ContentManager.g.cpp"
+
+#include <wil/token_helpers.h>
+
+#include "../../types/inc/utils.hpp"
+
+using namespace winrt::Windows::ApplicationModel;
+using namespace winrt::Windows::ApplicationModel::DataTransfer;
+using namespace winrt::Windows::UI::Xaml;
+using namespace winrt::Windows::UI::Xaml::Controls;
+using namespace winrt::Windows::UI::Core;
+using namespace winrt::Windows::System;
+using namespace winrt::Microsoft::Terminal;
+using namespace winrt::Microsoft::Terminal::Control;
+using namespace winrt::Microsoft::Terminal::Settings::Model;
+
+namespace winrt
+{
+    namespace MUX = Microsoft::UI::Xaml;
+    using IInspectable = Windows::Foundation::IInspectable;
+}
+namespace winrt::TerminalApp::implementation
+{
+    ControlInteractivity ContentManager::CreateCore(Microsoft::Terminal::Control::IControlSettings settings,
+                                                    IControlAppearance unfocusedAppearance,
+                                                    TerminalConnection::ITerminalConnection connection)
+    {
+        auto content = ControlInteractivity{ settings, unfocusedAppearance, connection };
+        content.Closed({ get_weak(), &ContentManager::_closedHandler });
+        _content.insert(std::make_pair(content.Id(), content));
+        return content;
+    }
+
+    ControlInteractivity ContentManager::LookupCore(winrt::guid id)
+    {
+        return _content.at(id);
+    }
+
+    void ContentManager::_closedHandler(winrt::Windows::Foundation::IInspectable sender,
+                                        winrt::Windows::Foundation::IInspectable e)
+    {
+        if (const auto& content{ sender.try_as<winrt::Microsoft::Terminal::Control::ControlInteractivity>() })
+        {
+            const auto& contentGuid{ content.Id() };
+            _content.erase(contentGuid);
+        }
+    }
+}

src/cascadia/TerminalApp/ContentManager.h

@@ -0,0 +1,44 @@
+/*++
+Copyright (c) Microsoft Corporation
+Licensed under the MIT license.
+
+Class Name:
+- ContentManager.h
+
+Abstract:
+- This is a helper class for tracking all of the terminal "content" instances of
+  the Terminal. These are all the ControlInteractivity & ControlCore's of each
+  of our TermControls. These are each assigned a GUID on creation, and stored in
+  a map for later lookup.
+- This is used to enable moving panes between windows. TermControl's are not
+  thread-agile, so they cannot be reused on other threads. However, the content
+  is. This helper, which exists as a singleton across all the threads in the
+  Terminal app, allows each thread to create content, assign it to a
+  TermControl, detach it from that control, and reattach to new controls on
+  other threads.
+- When you want to create a new TermControl, call CreateCore to instantiate a
+  new content with a GUID for later reparenting.
+--*/
+#pragma once
+
+#include "ContentManager.g.h"
+
+#include <inc/cppwinrt_utils.h>
+namespace winrt::TerminalApp::implementation
+{
+    struct ContentManager : ContentManagerT<ContentManager>
+    {
+    public:
+        ContentManager() = default;
+        Microsoft::Terminal::Control::ControlInteractivity CreateCore(Microsoft::Terminal::Control::IControlSettings settings,
+                                                                      Microsoft::Terminal::Control::IControlAppearance unfocusedAppearance,
+                                                                      Microsoft::Terminal::TerminalConnection::ITerminalConnection connection);
+        Microsoft::Terminal::Control::ControlInteractivity LookupCore(winrt::guid id);
+
+    private:
+        std::unordered_map<winrt::guid, Microsoft::Terminal::Control::ControlInteractivity> _content;
+
+        void _closedHandler(winrt::Windows::Foundation::IInspectable sender,
+                            winrt::Windows::Foundation::IInspectable e);
+    };
+}

src/cascadia/TerminalApp/TerminalAppLib.vcxproj

@@ -138,6 +138,9 @@
     <ClInclude Include="AppLogic.h">
       <DependentUpon>AppLogic.idl</DependentUpon>
     </ClInclude>
+    <ClInclude Include="ContentManager.h">
+      <DependentUpon>TerminalPage.idl</DependentUpon>
+    </ClInclude>
     <ClInclude Include="TerminalWindow.h">
       <DependentUpon>TerminalWindow.idl</DependentUpon>
     </ClInclude>
@@ -237,6 +240,9 @@
     <ClCompile Include="AppLogic.cpp">
       <DependentUpon>AppLogic.idl</DependentUpon>
     </ClCompile>
+    <ClCompile Include="ContentManager.cpp">
+      <DependentUpon>TerminalPage.idl</DependentUpon>
+    </ClCompile>
     <ClCompile Include="TerminalWindow.cpp">
       <DependentUpon>TerminalWindow.idl</DependentUpon>
     </ClCompile>

src/cascadia/TerminalApp/TerminalPage.cpp

@@ -54,10 +54,11 @@ namespace winrt
 
 namespace winrt::TerminalApp::implementation
 {
-    TerminalPage::TerminalPage(TerminalApp::WindowProperties properties) :
+    TerminalPage::TerminalPage(TerminalApp::WindowProperties properties, const TerminalApp::ContentManager& manager) :
         _tabs{ winrt::single_threaded_observable_vector<TerminalApp::TabBase>() },
         _mruTabs{ winrt::single_threaded_observable_vector<TerminalApp::TabBase>() },
         _startupActions{ winrt::single_threaded_vector<ActionAndArgs>() },
+        _manager{ manager },
         _hostingHwnd{},
         _WindowProperties{ std::move(properties) }
     {
@@ -2593,7 +2594,10 @@ namespace winrt::TerminalApp::implementation
         // Do any initialization that needs to apply to _every_ TermControl we
         // create here.
         // TermControl will copy the settings out of the settings passed to it.
-        TermControl term{ settings.DefaultSettings(), settings.UnfocusedSettings(), connection };
+
+        const auto content = _manager.CreateCore(settings.DefaultSettings(), settings.UnfocusedSettings(), connection);
+
+        TermControl term{ content };
 
         // GH#12515: ConPTY assumes it's hidden at the start. If we're not, let it know now.
         if (_visible)

src/cascadia/TerminalApp/TerminalPage.h

@@ -63,7 +63,7 @@ namespace winrt::TerminalApp::implementation
     struct TerminalPage : TerminalPageT<TerminalPage>
     {
     public:
-        TerminalPage(TerminalApp::WindowProperties properties);
+        TerminalPage(TerminalApp::WindowProperties properties, const TerminalApp::ContentManager& manager);
 
         // This implements shobjidl's IInitializeWithWindow, but due to a XAML Compiler bug we cannot
         // put it in our inheritance graph. https://github.com/microsoft/microsoft-ui-xaml/issues/3331
@@ -224,9 +224,10 @@ namespace winrt::TerminalApp::implementation
         bool _renamerPressedEnter{ false };
 
         TerminalApp::WindowProperties _WindowProperties{ nullptr };
-
         PaneResources _paneResources;
 
+        TerminalApp::ContentManager _manager{ nullptr };
+
         winrt::Microsoft::Terminal::TerminalConnection::ConptyConnection::NewConnection_revoker _newConnectionRevoker;
 
         winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::UI::Xaml::Controls::ContentDialogResult> _ShowDialogHelper(const std::wstring_view& name);

src/cascadia/TerminalApp/TerminalPage.idl

@@ -6,6 +6,16 @@ import "IDirectKeyListener.idl";
 namespace TerminalApp
 {
 
+    // See IDialogPresenter and TerminalPage's DialogPresenter for more
+    // information.
+    [default_interface] runtimeclass ContentManager
+    {
+        Microsoft.Terminal.Control.ControlInteractivity CreateCore(Microsoft.Terminal.Control.IControlSettings settings,
+                                                                   Microsoft.Terminal.Control.IControlAppearance unfocusedAppearance,
+                                                                   Microsoft.Terminal.TerminalConnection.ITerminalConnection connection);
+        Microsoft.Terminal.Control.ControlInteractivity LookupCore(Guid id);
+    }
+
     [default_interface] runtimeclass LastTabClosedEventArgs
     {
         Boolean ClearPersistedState { get; };
@@ -33,7 +43,7 @@ namespace TerminalApp
 
     [default_interface] runtimeclass TerminalPage : Windows.UI.Xaml.Controls.Page, Windows.UI.Xaml.Data.INotifyPropertyChanged, IDirectKeyListener
     {
-        TerminalPage(WindowProperties properties);
+        TerminalPage(WindowProperties properties, ContentManager manager);
 
         // XAML bound properties
         String ApplicationDisplayName { get; };

src/cascadia/TerminalApp/TerminalWindow.cpp

@@ -118,8 +118,10 @@ static Documents::Run _BuildErrorRun(const winrt::hstring& text, const ResourceD
 
 namespace winrt::TerminalApp::implementation
 {
-    TerminalWindow::TerminalWindow(const TerminalApp::SettingsLoadEventArgs& settingsLoadedResult) :
+    TerminalWindow::TerminalWindow(const TerminalApp::SettingsLoadEventArgs& settingsLoadedResult,
+                                   const TerminalApp::ContentManager& manager) :
         _settings{ settingsLoadedResult.NewSettings() },
+        _manager{ manager },
         _initialLoadResult{ settingsLoadedResult },
         _WindowProperties{ winrt::make_self<TerminalApp::implementation::WindowProperties>() }
     {
@@ -138,7 +140,7 @@ namespace winrt::TerminalApp::implementation
     HRESULT TerminalWindow::Initialize(HWND hwnd)
     {
         // Now that we know we can do XAML, build our page.
-        _root = winrt::make_self<TerminalPage>(*_WindowProperties);
+        _root = winrt::make_self<TerminalPage>(*_WindowProperties, _manager);
         _dialog = ContentDialog{};
 
         // Pass commandline args into the TerminalPage. If we were supposed to

src/cascadia/TerminalApp/TerminalWindow.h

@@ -58,7 +58,7 @@ namespace winrt::TerminalApp::implementation
     struct TerminalWindow : TerminalWindowT<TerminalWindow, IInitializeWithWindow>
     {
     public:
-        TerminalWindow(const TerminalApp::SettingsLoadEventArgs& settingsLoadedResult);
+        TerminalWindow(const TerminalApp::SettingsLoadEventArgs& settingsLoadedResult, const TerminalApp::ContentManager& manager);
         ~TerminalWindow() = default;
 
         STDMETHODIMP Initialize(HWND hwnd);
@@ -177,6 +177,8 @@ namespace winrt::TerminalApp::implementation
         Microsoft::Terminal::Settings::Model::CascadiaSettings _settings{ nullptr };
         TerminalApp::SettingsLoadEventArgs _initialLoadResult{ nullptr };
 
+        TerminalApp::ContentManager _manager{ nullptr };
+
         void _ShowLoadErrorsDialog(const winrt::hstring& titleKey,
                                    const winrt::hstring& contentKey,
                                    HRESULT settingsLoadedResult,

src/cascadia/TerminalApp/TerminalWindow.idl

@@ -42,7 +42,7 @@ namespace TerminalApp
     // information.
     [default_interface] runtimeclass TerminalWindow : IDirectKeyListener, IDialogPresenter, Windows.UI.Xaml.Data.INotifyPropertyChanged
     {
-        TerminalWindow(SettingsLoadEventArgs result);
+        TerminalWindow(SettingsLoadEventArgs result, ContentManager manager);
 
         // For your own sanity, it's better to do setup outside the ctor.
         // If you do any setup in the ctor that ends up throwing an exception,

src/cascadia/TerminalControl/ControlCore.idl

@@ -126,7 +126,6 @@ namespace Microsoft.Terminal.Control
         String HoveredUriText { get; };
         Windows.Foundation.IReference<Microsoft.Terminal.Core.Point> HoveredCell { get; };
 
-        void Close();
         void BlinkCursor();
         Boolean IsInReadOnlyMode { get; };
         Boolean CursorOn;

src/cascadia/TerminalControl/ControlInteractivity.cpp

@@ -44,9 +44,16 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         _lastMouseClickPos{},
         _selectionNeedsToBeCopied{ false }
     {
+        _guid = ::Microsoft::Console::Utils::CreateGuid();
+
         _core = winrt::make_self<ControlCore>(settings, unfocusedAppearance, connection);
     }
 
+    winrt::guid ControlInteractivity::Id()
+    {
+        return _guid;
+    }
+
     // Method Description:
     // - Updates our internal settings. These settings should be
     //   interactivity-specific. Right now, we primarily update _rowsToScroll
@@ -73,6 +80,15 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         return *_core;
     }
 
+    void ControlInteractivity::Close()
+    {
+        _ClosedHandlers(*this, nullptr);
+        if (_core)
+        {
+            _core->Close();
+        }
+    }
+
     // Method Description:
     // - Returns the number of clicks that occurred (double and triple click support).
     // Every call to this function registers a click.

src/cascadia/TerminalControl/ControlInteractivity.h

@@ -44,6 +44,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         void Initialize();
         Control::ControlCore Core();
 
+        void Close();
+
         Control::InteractivityAutomationPeer OnCreateAutomationPeer();
         ::Microsoft::Console::Render::IRenderData* GetRenderData() const;
 
@@ -85,11 +87,15 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         void SetEndSelectionPoint(const Core::Point pixelPosition);
         bool ManglePathsForWsl();
 
+        winrt::guid Id();
+
         TYPED_EVENT(OpenHyperlink, IInspectable, Control::OpenHyperlinkEventArgs);
         TYPED_EVENT(PasteFromClipboard, IInspectable, Control::PasteFromClipboardEventArgs);
         TYPED_EVENT(ScrollPositionChanged, IInspectable, Control::ScrollPositionChangedArgs);
         TYPED_EVENT(ContextMenuRequested, IInspectable, Control::ContextMenuRequestedEventArgs);
 
+        TYPED_EVENT(Closed, IInspectable, IInspectable);
+
     private:
         // NOTE: _uiaEngine must be ordered before _core.
         //
@@ -130,6 +136,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
         std::optional<interval_tree::IntervalTree<til::point, size_t>::interval> _lastHoveredInterval{ std::nullopt };
 
+        winrt::guid _guid;
+
         unsigned int _numberOfClicks(Core::Point clickPos, Timestamp clickTime);
         void _updateSystemParameterSettings() noexcept;
 

src/cascadia/TerminalControl/ControlInteractivity.idl

@@ -23,6 +23,10 @@ namespace Microsoft.Terminal.Control
         void GotFocus();
         void LostFocus();
 
+        Guid Id { get; };
+
+        void Close();
+
         InteractivityAutomationPeer OnCreateAutomationPeer();
 
         Boolean CopySelectionToClipboard(Boolean singleLine, Windows.Foundation.IReference<CopyFormat> formats);
@@ -65,6 +69,8 @@ namespace Microsoft.Terminal.Control
         event Windows.Foundation.TypedEventHandler<Object, ScrollPositionChangedArgs> ScrollPositionChanged;
         event Windows.Foundation.TypedEventHandler<Object, PasteFromClipboardEventArgs> PasteFromClipboard;
 
+        event Windows.Foundation.TypedEventHandler<Object, Object> Closed;
+
         // Used to communicate to the TermControl, but not necessarily higher up in the stack
         event Windows.Foundation.TypedEventHandler<Object, ContextMenuRequestedEventArgs> ContextMenuRequested;