Enable tearing out tabs to create new windows

src/cascadia/Remoting/Monarch.cpp

@@ -1058,7 +1058,8 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
 
     void Monarch::RequestMoveContent(winrt::hstring window,
                                      winrt::hstring content,
-                                     uint32_t tabIndex)
+                                     uint32_t tabIndex,
+                                     const Windows::Foundation::IReference<Windows::Foundation::Rect>& windowBounds)
     {
         TraceLoggingWrite(g_hRemotingProvider,
                           "Monarch_MoveContent_Requested",
@@ -1102,11 +1103,14 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
                               TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE),
                               TraceLoggingKeyword(TIL_KEYWORD_TRACE));
 
-            // TODO GH#5000
-            //
             // In the case where window couldn't be found, then create a window
-            // for that name / ID. Do this as a part of tear-out (different than
-            // drag/drop)
+            // for that name / ID.
+            //
+            // Don't let the window literally be named "-1", because that's silly
+            auto request = winrt::make_self<implementation::WindowRequestedArgs>(window == L"-1" ? L"" : window,
+                                                                                 content,
+                                                                                 windowBounds);
+            _RequestNewWindowHandlers(*this, *request);
         }
     }
 
@@ -1132,16 +1136,14 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         }
         else
         {
+            // We couldn't find the peasant that started the drag. Well that
+            // sure is weird, but that would indicate that the sender closed
+            // after starting the drag. No matter. We can just do nothing.
+
             TraceLoggingWrite(g_hRemotingProvider,
                               "Monarch_SendContent_NoWindow",
                               TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE),
                               TraceLoggingKeyword(TIL_KEYWORD_TRACE));
-
-            // TODO GH#5000
-            //
-            // In the case where window couldn't be found, then create a window
-            // for that name / ID. Do this as a part of tear-out (different than
-            // drag/drop)
         }
     }
 }

src/cascadia/Remoting/Monarch.h

@@ -48,12 +48,22 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
             _args{ command.Commandline() },
             _CurrentDirectory{ command.CurrentDirectory() } {};
 
+        WindowRequestedArgs(const winrt::hstring& window, const winrt::hstring& content, const Windows::Foundation::IReference<Windows::Foundation::Rect>& bounds) :
+            _Id{ 0u },
+            _WindowName{ window },
+            _args{},
+            _CurrentDirectory{},
+            _Content{ content },
+            _InitialBounds{ bounds } {};
+
         void Commandline(const winrt::array_view<const winrt::hstring>& value) { _args = { value.begin(), value.end() }; };
         winrt::com_array<winrt::hstring> Commandline() { return winrt::com_array<winrt::hstring>{ _args.begin(), _args.end() }; }
 
         WINRT_PROPERTY(uint64_t, Id);
         WINRT_PROPERTY(winrt::hstring, WindowName);
         WINRT_PROPERTY(winrt::hstring, CurrentDirectory);
+        WINRT_PROPERTY(winrt::hstring, Content);
+        WINRT_PROPERTY(Windows::Foundation::IReference<Windows::Foundation::Rect>, InitialBounds);
 
     private:
         winrt::com_array<winrt::hstring> _args;
@@ -81,7 +91,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         Windows::Foundation::Collections::IVectorView<winrt::Microsoft::Terminal::Remoting::PeasantInfo> GetPeasantInfos();
         Windows::Foundation::Collections::IVector<winrt::hstring> GetAllWindowLayouts();
 
-        void RequestMoveContent(winrt::hstring window, winrt::hstring content, uint32_t tabIndex);
+        void RequestMoveContent(winrt::hstring window, winrt::hstring content, uint32_t tabIndex, const Windows::Foundation::IReference<Windows::Foundation::Rect>& windowBounds);
         void RequestSendContent(const Remoting::RequestReceiveContentArgs& args);
 
         TYPED_EVENT(FindTargetWindowRequested, winrt::Windows::Foundation::IInspectable, winrt::Microsoft::Terminal::Remoting::FindTargetWindowArgs);

src/cascadia/Remoting/Monarch.idl

@@ -26,6 +26,9 @@ namespace Microsoft.Terminal.Remoting
 
         String[] Commandline { get; };
         String CurrentDirectory { get; };
+
+        String Content { get; };
+        Windows.Foundation.IReference<Windows.Foundation.Rect> InitialBounds { get; };
     }
 
     [default_interface] runtimeclass SummonWindowSelectionArgs {
@@ -69,7 +72,7 @@ namespace Microsoft.Terminal.Remoting
         Windows.Foundation.Collections.IVectorView<PeasantInfo> GetPeasantInfos { get; };
         Windows.Foundation.Collections.IVector<String> GetAllWindowLayouts();
 
-        void RequestMoveContent(String window, String content, UInt32 tabIndex);
+        void RequestMoveContent(String window, String content, UInt32 tabIndex, Windows.Foundation.IReference<Windows.Foundation.Rect> bounds);
         void RequestSendContent(RequestReceiveContentArgs args);
 
         event Windows.Foundation.TypedEventHandler<Object, FindTargetWindowArgs> FindTargetWindowRequested;

src/cascadia/Remoting/WindowManager.cpp

@@ -416,10 +416,11 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
 
     winrt::fire_and_forget WindowManager::RequestMoveContent(winrt::hstring window,
                                                              winrt::hstring content,
-                                                             uint32_t tabIndex)
+                                                             uint32_t tabIndex,
+                                                             Windows::Foundation::IReference<Windows::Foundation::Rect> windowBounds)
     {
         co_await winrt::resume_background();
-        _monarch.RequestMoveContent(window, content, tabIndex);
+        _monarch.RequestMoveContent(window, content, tabIndex, windowBounds);
     }
 
     winrt::fire_and_forget WindowManager::RequestSendContent(Remoting::RequestReceiveContentArgs args)

src/cascadia/Remoting/WindowManager.h

@@ -44,7 +44,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         Windows::Foundation::Collections::IVector<winrt::hstring> GetAllWindowLayouts();
         bool DoesQuakeWindowExist();
 
-        winrt::fire_and_forget RequestMoveContent(winrt::hstring window, winrt::hstring content, uint32_t tabIndex);
+        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);
 
         TYPED_EVENT(FindTargetWindowRequested, winrt::Windows::Foundation::IInspectable, winrt::Microsoft::Terminal::Remoting::FindTargetWindowArgs);

src/cascadia/Remoting/WindowManager.idl

@@ -26,7 +26,7 @@ namespace Microsoft.Terminal.Remoting
 
         Boolean DoesQuakeWindowExist();
 
-        void RequestMoveContent(String window, String content, UInt32 tabIndex);
+        void RequestMoveContent(String window, String content, UInt32 tabIndex, Windows.Foundation.IReference<Windows.Foundation.Rect> bounds);
         void RequestSendContent(RequestReceiveContentArgs args);
 
         event Windows.Foundation.TypedEventHandler<Object, FindTargetWindowArgs> FindTargetWindowRequested;

src/cascadia/TerminalApp/TabManagement.cpp

@@ -512,9 +512,9 @@ namespace winrt::TerminalApp::implementation
             _mruTabs.RemoveAt(mruIndex);
         }
 
-        if (_stashedDraggedTab && *_stashedDraggedTab == tab)
+        if (_stashed.draggedTab && *_stashed.draggedTab == tab)
         {
-            _stashedDraggedTab = nullptr;
+            _stashed.draggedTab = nullptr;
         }
 
         _tabs.RemoveAt(tabIndex);

src/cascadia/TerminalApp/TerminalPage.cpp

@@ -250,6 +250,7 @@ namespace winrt::TerminalApp::implementation
         _tabView.TabDragStarting({ this, &TerminalPage::_onTabDragStarting });
         _tabView.TabStripDragOver({ this, &TerminalPage::_onTabStripDragOver });
         _tabView.TabStripDrop({ this, &TerminalPage::_onTabStripDrop });
+        _tabView.TabDroppedOutside({ this, &TerminalPage::_onTabDroppedOutside });
 
         _CreateNewTabFlyout();
 
@@ -1985,13 +1986,18 @@ namespace winrt::TerminalApp::implementation
     //   and should be expected to be empty after this call.
     void TerminalPage::_MoveContent(std::vector<Settings::Model::ActionAndArgs>&& actions,
                                     const winrt::hstring& windowName,
-                                    const uint32_t tabIndex)
+                                    const uint32_t tabIndex,
+                                    const std::optional<til::point>& dragPoint)
     {
         const auto winRtActions{ winrt::single_threaded_vector<ActionAndArgs>(std::move(actions)) };
         const auto str{ ActionAndArgs::Serialize(winRtActions) };
         const auto request = winrt::make_self<RequestMoveContentArgs>(windowName,
                                                                       str,
                                                                       tabIndex);
+        if (dragPoint.has_value())
+        {
+            request->WindowPosition(dragPoint->to_winrt_point());
+        }
         _RequestMoveContentHandlers(*this, *request);
     }
 
@@ -2026,6 +2032,11 @@ namespace winrt::TerminalApp::implementation
         return true;
     }
 
+    uint32_t TerminalPage::NumberOfTabs() const
+    {
+        return _tabs.Size();
+    }
+
     // Method Description:
     // - Called when it is determined that an existing tab or pane should be
     //   attached to our window. content represents a blob of JSON describing
@@ -2036,11 +2047,9 @@ namespace winrt::TerminalApp::implementation
     //   reattach instead of create new content, so this method simply needs to
     //   parse the JSON and pump it into our action handler. Almost the same as
     //   doing something like `wt -w 0 nt`.
-    winrt::fire_and_forget TerminalPage::AttachContent(winrt::hstring content,
+    winrt::fire_and_forget TerminalPage::AttachContent(IVector<Settings::Model::ActionAndArgs> args,
                                                        uint32_t tabIndex)
     {
-        auto args = ActionAndArgs::Deserialize(content);
-
         if (args == nullptr ||
             args.Size() == 0)
         {
@@ -2064,18 +2073,6 @@ namespace winrt::TerminalApp::implementation
         {
             _SelectTab(tabIndex);
         }
-        else
-        {
-            if (firstIsSplitPane)
-            {
-                // Create the equivalent NewTab action.
-                const auto newAction = Settings::Model::ActionAndArgs{ Settings::Model::ShortcutAction::NewTab,
-                                                                       Settings::Model::NewTabArgs(firstAction.Args() ?
-                                                                                                       firstAction.Args().try_as<Settings::Model::SplitPaneArgs>().TerminalArgs() :
-                                                                                                       nullptr) };
-                args.SetAt(0, newAction);
-            }
-        }
 
         for (const auto& action : args)
         {
@@ -4611,7 +4608,23 @@ namespace winrt::TerminalApp::implementation
         {
             // First: stash the tab we started dragging.
             // We're going to be asked for this.
-            _stashedDraggedTab = tabImpl;
+            _stashed.draggedTab = tabImpl;
+
+            // Stash the offset from where we started the drag to the
+            // tab's origin. We'll use that offset in the future to help
+            // position the dropped window.
+
+            // First, the position of the pointer, from the CoreWindow
+            const til::point pointerPosition{ til::math::rounding, CoreWindow::GetForCurrentThread().PointerPosition() };
+            // Next, the position of the tab itself:
+            const til::point tabPosition{ til::math::rounding, eventTab.TransformToVisual(nullptr).TransformPoint({ 0, 0 }) };
+            // Now, we need to add the origin of our CoreWindow to the tab
+            // position.
+            const auto& coreWindowBounds{ CoreWindow::GetForCurrentThread().Bounds() };
+            const til::point windowOrigin{ til::math::rounding, coreWindowBounds.X, coreWindowBounds.Y };
+            const auto realTabPosition = windowOrigin + tabPosition;
+            // Subtract the two to get the offset.
+            _stashed.dragOffset = til::point{ pointerPosition - realTabPosition };
 
             // Into the DataPackage, let's stash our own window ID.
             const auto id{ _WindowProperties.WindowId() };
@@ -4630,7 +4643,8 @@ namespace winrt::TerminalApp::implementation
             //      to ask us to send our content to them.
             //  * We'll get a TabDroppedOutside to indicate that this tab was
             //    dropped _not_ on a TabView.
-            //    * This we can't handle yet, and is the last point of TODO GH#5000
+            //    * This will be handled by _onTabDroppedOutside, which will
+            //      raise a MoveContent (to a new window) event.
         }
     }
 
@@ -4736,7 +4750,36 @@ namespace winrt::TerminalApp::implementation
         {
             co_return;
         }
-        if (!_stashedDraggedTab)
+        if (!_stashed.draggedTab)
+        {
+            co_return;
+        }
+
+        // must do the work of adding/removing tabs on the UI thread.
+        auto weakThis{ get_weak() };
+        co_await wil::resume_foreground(Dispatcher(), CoreDispatcherPriority::Normal);
+        if (const auto& page{ weakThis.get() })
+        {
+            // `this` is safe to use in here.
+
+            _sendDraggedTabToWindow(winrt::hstring{ fmt::format(L"{}", args.TargetWindow()) },
+                                    args.TabIndex(),
+                                    std::nullopt);
+        }
+    }
+
+    winrt::fire_and_forget TerminalPage::_onTabDroppedOutside(winrt::IInspectable sender,
+                                                              winrt::MUX::Controls::TabViewTabDroppedOutsideEventArgs e)
+    {
+        // Get the current pointer point from the CoreWindow
+        const auto& pointerPoint{ CoreWindow::GetForCurrentThread().PointerPosition() };
+
+        // This is called when a tab FROM OUR WINDOW was dropped outside the
+        // tabview. We already know which tab was being dragged. We'll just
+        // invoke a moveTab action with the target window being -1. That will
+        // force the creation of a new window.
+
+        if (!_stashed.draggedTab)
         {
             co_return;
         }
@@ -4747,12 +4790,29 @@ namespace winrt::TerminalApp::implementation
         if (const auto& page{ weakThis.get() })
         {
             // `this` is safe to use in here.
-            auto startupActions = _stashedDraggedTab->BuildStartupActions(true);
-            _DetachTabFromWindow(_stashedDraggedTab);
-            _MoveContent(std::move(startupActions), winrt::hstring{ fmt::format(L"{}", args.TargetWindow()) }, args.TabIndex());
-            // _RemoveTab will make sure to null out the _stashedDraggedTab
-            _RemoveTab(*_stashedDraggedTab);
+
+            // We need to convert the pointer point to a point that we can use
+            // to position the new window. We'll use the drag offset from before
+            // so that the tab in the new window is positioned so that it's
+            // basically still directly under the cursor.
+
+            // -1 is the magic number for "new window"
+            // 0 as the tab index, because we don't care. It's making a new window. It'll be the only tab.
+            const til::point adjusted = til::point{ til::math::rounding, pointerPoint } - _stashed.dragOffset;
+            _sendDraggedTabToWindow(winrt::hstring{ L"-1" }, 0, adjusted);
         }
     }
 
+    void TerminalPage::_sendDraggedTabToWindow(const winrt::hstring& windowId,
+                                               const uint32_t tabIndex,
+                                               std::optional<til::point> dragPoint)
+    {
+        auto startupActions = _stashed.draggedTab->BuildStartupActions(true);
+        _DetachTabFromWindow(_stashed.draggedTab);
+
+        _MoveContent(std::move(startupActions), windowId, tabIndex, dragPoint);
+        // _RemoveTab will make sure to null out the _stashed.draggedTab
+        _RemoveTab(*_stashed.draggedTab);
+    }
+
 }

src/cascadia/TerminalApp/TerminalPage.h

@@ -67,6 +67,7 @@ namespace winrt::TerminalApp::implementation
         WINRT_PROPERTY(winrt::hstring, Window);
         WINRT_PROPERTY(winrt::hstring, Content);
         WINRT_PROPERTY(uint32_t, TabIndex);
+        WINRT_PROPERTY(Windows::Foundation::IReference<Windows::Foundation::Point>, WindowPosition);
 
     public:
         RequestMoveContentArgs(const winrt::hstring window, const winrt::hstring content, uint32_t tabIndex) :
@@ -162,9 +163,11 @@ namespace winrt::TerminalApp::implementation
 
         bool OnDirectKeyEvent(const uint32_t vkey, const uint8_t scanCode, const bool down);
 
-        winrt::fire_and_forget AttachContent(winrt::hstring content, uint32_t tabIndex);
+        winrt::fire_and_forget AttachContent(Windows::Foundation::Collections::IVector<Microsoft::Terminal::Settings::Model::ActionAndArgs> args, uint32_t tabIndex);
         winrt::fire_and_forget SendContentToOther(winrt::TerminalApp::RequestReceiveContentArgs args);
 
+        uint32_t NumberOfTabs() const;
+
         WINRT_CALLBACK(PropertyChanged, Windows::UI::Xaml::Data::PropertyChangedEventHandler);
 
         // -------------------------------- WinRT Events ---------------------------------
@@ -263,7 +266,11 @@ namespace winrt::TerminalApp::implementation
 
         TerminalApp::ContentManager _manager{ nullptr };
 
-        winrt::com_ptr<winrt::TerminalApp::implementation::TabBase> _stashedDraggedTab{ nullptr };
+        struct StashedDragData
+        {
+            winrt::com_ptr<winrt::TerminalApp::implementation::TabBase> draggedTab{ nullptr };
+            til::point dragOffset{ 0, 0 };
+        } _stashed;
 
         winrt::Microsoft::Terminal::TerminalConnection::ConptyConnection::NewConnection_revoker _newConnectionRevoker;
 
@@ -503,10 +510,15 @@ namespace winrt::TerminalApp::implementation
         void _onTabDragStarting(const winrt::Microsoft::UI::Xaml::Controls::TabView& sender, const winrt::Microsoft::UI::Xaml::Controls::TabViewTabDragStartingEventArgs& e);
         void _onTabStripDragOver(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::UI::Xaml::DragEventArgs& e);
         winrt::fire_and_forget _onTabStripDrop(winrt::Windows::Foundation::IInspectable sender, winrt::Windows::UI::Xaml::DragEventArgs e);
+        winrt::fire_and_forget _onTabDroppedOutside(winrt::Windows::Foundation::IInspectable sender, winrt::Microsoft::UI::Xaml::Controls::TabViewTabDroppedOutsideEventArgs e);
 
         void _DetachPaneFromWindow(std::shared_ptr<Pane> pane);
         void _DetachTabFromWindow(const winrt::com_ptr<TabBase>& terminalTab);
-        void _MoveContent(std::vector<winrt::Microsoft::Terminal::Settings::Model::ActionAndArgs>&& actions, const winrt::hstring& windowName, const uint32_t tabIndex);
+        void _MoveContent(std::vector<winrt::Microsoft::Terminal::Settings::Model::ActionAndArgs>&& actions,
+                          const winrt::hstring& windowName,
+                          const uint32_t tabIndex,
+                          const std::optional<til::point>& dragPoint = std::nullopt);
+        void _sendDraggedTabToWindow(const winrt::hstring& windowId, const uint32_t tabIndex, std::optional<til::point> dragPoint);
 
         void _ContextMenuOpened(const IInspectable& sender, const IInspectable& args);
         void _SelectionMenuOpened(const IInspectable& sender, const IInspectable& args);