Remove manual broadcasting since WriteInputString calls StringSent (!)

I've audited all the events, and the only one that tried to use IControlInteractivity or similar was Paste

src/cascadia/TerminalApp/AppActionHandlers.cpp

@@ -185,7 +185,7 @@ namespace winrt::TerminalApp::implementation
         {
             if (const auto termControl{ _senderOrActiveControl(sender) })
             {
-                termControl.SendInput(realArgs.Input());
+                termControl.WriteInputString(realArgs.Input(), WriteInputStringType::Raw);
                 args.Handled(true);
             }
         }
@@ -452,8 +452,11 @@ namespace winrt::TerminalApp::implementation
     void TerminalPage::_HandlePasteText(const IInspectable& /*sender*/,
                                         const ActionEventArgs& args)
     {
-        _PasteText();
-        args.Handled(true);
+        if (const auto& control{ _GetActiveControl() })
+        {
+            _PasteFromClipboardHandler(control, nullptr);
+            args.Handled(true);
+        }
     }
 
     void TerminalPage::_HandleNewTab(const IInspectable& /*sender*/,

src/cascadia/TerminalApp/Pane.cpp

@@ -3044,14 +3044,15 @@ void Pane::BroadcastChar(const winrt::Microsoft::Terminal::Control::TermControl&
 }
 
 void Pane::BroadcastString(const winrt::Microsoft::Terminal::Control::TermControl& sourceControl,
-                           const winrt::hstring& text)
+                           const winrt::hstring& text,
+                           const winrt::Microsoft::Terminal::Control::WriteInputStringType type)
 {
     WalkTree([&](const auto& pane) {
         if (const auto& termControl{ pane->GetTerminalControl() })
         {
             if (termControl != sourceControl && !termControl.ReadOnly())
             {
-                termControl.RawWriteString(text);
+                termControl.WriteInputStringWithoutBroadcast(text, type);
             }
         }
     });

src/cascadia/TerminalApp/Pane.h

@@ -152,7 +152,7 @@ public:
     void EnableBroadcast(bool enabled);
     void BroadcastKey(const winrt::Microsoft::Terminal::Control::TermControl& sourceControl, const WORD vkey, const WORD scanCode, const winrt::Microsoft::Terminal::Core::ControlKeyStates modifiers, const bool keyDown);
     void BroadcastChar(const winrt::Microsoft::Terminal::Control::TermControl& sourceControl, const wchar_t vkey, const WORD scanCode, const winrt::Microsoft::Terminal::Core::ControlKeyStates modifiers);
-    void BroadcastString(const winrt::Microsoft::Terminal::Control::TermControl& sourceControl, const winrt::hstring& text);
+    void BroadcastString(const winrt::Microsoft::Terminal::Control::TermControl& sourceControl, const winrt::hstring& text, const winrt::Microsoft::Terminal::Control::WriteInputStringType type);
 
     void UpdateResources(const PaneResources& resources);
 

src/cascadia/TerminalApp/Tab.cpp

@@ -2222,7 +2222,8 @@ namespace winrt::TerminalApp::implementation
                 if (tab->_tabStatus.IsInputBroadcastActive())
                 {
                     tab->_rootPane->BroadcastString(sender.try_as<TermControl>(),
-                                                    e.Text());
+                                                    e.Text(),
+                                                    static_cast<winrt::Microsoft::Terminal::Control::WriteInputStringType>(e.Type()));
                 }
             }
         });

src/cascadia/TerminalApp/TerminalPage.cpp

@@ -2945,9 +2945,7 @@ namespace winrt::TerminalApp::implementation
     // - Sends the text back to the TermControl through the event's
     //   `HandleClipboardData` member function.
     // - Does some of this in a background thread, as to not hang/crash the UI thread.
-    // Arguments:
-    // - eventArgs: the PasteFromClipboard event sent from the TermControl
-    safe_void_coroutine TerminalPage::_PasteFromClipboardHandler(const IInspectable sender, const PasteFromClipboardEventArgs eventArgs)
+    safe_void_coroutine TerminalPage::_PasteFromClipboardHandler(const IInspectable sender, const IInspectable /* args */)
     try
     {
         // The old Win32 clipboard API as used below is somewhere in the order of 300-1000x faster than
@@ -2955,8 +2953,13 @@ namespace winrt::TerminalApp::implementation
         const auto weakThis = get_weak();
         const auto dispatcher = Dispatcher();
         const auto globalSettings = _settings.GlobalSettings();
-        const auto bracketedPaste = eventArgs.BracketedPasteEnabled();
-        const auto sourceId = sender.try_as<ControlInteractivity>().Id();
+        const auto control = sender.as<TermControl>();
+        // TODO GH#20164 these were added to ease the transition to broadcast group management; fill them in
+        // Used to determine whether to emit empty pastes and strip extra whitespace
+        const auto anyHasBracketedPaste = control && !control.ReadOnly() && control.BracketedPasteEnabled();
+        // Used to determine whether to warn on multi-line paste
+        // If none lack bracketed paste, we can skip the warning.
+        const auto anyHasUnbracketedPaste = !anyHasBracketedPaste;
 
         // GetClipboardData might block for up to 30s for delay-rendered contents.
         co_await winrt::resume_background();
@@ -2967,8 +2970,11 @@ namespace winrt::TerminalApp::implementation
             text = clipboard::read();
         }
 
-        if (!bracketedPaste && globalSettings.TrimPaste())
+        if (!anyHasBracketedPaste && globalSettings.TrimPaste())
         {
+            // Warning - when broadcast is enabled, this will trim the paste for all receivers.
+            // Until we propagate this decision-making elsewhere, this is safer; broadcast will not auto-submit commands in other panes.
+            // Tracked in GH#20164
             text = winrt::hstring{ Utils::TrimPaste(text) };
         }
 
@@ -2976,7 +2982,7 @@ namespace winrt::TerminalApp::implementation
         // Bracketed Paste provides an application a way to know whether the
         // user pasted, even if there was no applicable content on it. This
         // behavior is observed in GNOME Terminal, among others.
-        if (!bracketedPaste && text.empty())
+        if (!anyHasBracketedPaste && text.empty())
         {
             co_return;
         }
@@ -2988,7 +2994,7 @@ namespace winrt::TerminalApp::implementation
             // NOTE that this is unsafe, because a shell that doesn't support bracketed paste
             // will allow an attacker to enable the mode, not realize that, and then accept
             // the paste as if it was a series of legitimate commands. See GH#13014.
-            warnMultiLine = !bracketedPaste;
+            warnMultiLine = anyHasUnbracketedPaste;
             break;
         case WarnAboutMultiLinePaste::Always:
             warnMultiLine = true;
@@ -3058,30 +3064,7 @@ namespace winrt::TerminalApp::implementation
         // This will end up calling ConptyConnection::WriteInput which calls WriteFile which may block for
         // an indefinite amount of time. Avoid freezes and deadlocks by running this on a background thread.
         assert(!dispatcher.HasThreadAccess());
-        eventArgs.HandleClipboardData(text);
-
-        // GH#18821: If broadcast input is active, paste the same text into all other
-        // panes on the tab. We do this here (rather than re-reading the
-        // clipboard per-pane) so that only one paste warning is shown.
-        co_await wil::resume_foreground(dispatcher);
-        if (const auto strongThis = weakThis.get())
-        {
-            if (const auto& tab{ strongThis->_GetFocusedTabImpl() })
-            {
-                if (tab->TabStatus().IsInputBroadcastActive())
-                {
-                    tab->GetRootPane()->WalkTree([&](auto&& pane) {
-                        if (const auto control = pane->GetTerminalControl())
-                        {
-                            if (control.ContentId() != sourceId && !control.ReadOnly())
-                            {
-                                control.RawWriteString(text);
-                            }
-                        }
-                    });
-                }
-            }
-        }
+        control.WriteInputString(text, WriteInputStringType::Clipboard);
     }
     CATCH_LOG();
 
@@ -3436,16 +3419,6 @@ namespace winrt::TerminalApp::implementation
         }
     }
 
-    // Method Description:
-    // - Paste text from the Windows Clipboard to the focused terminal
-    void TerminalPage::_PasteText()
-    {
-        if (const auto& control{ _GetActiveControl() })
-        {
-            control.PasteTextFromClipboard();
-        }
-    }
-
     // Function Description:
     // - Called when the settings button is clicked. ShellExecutes the settings
     //   file, as to open it in the default editor for .json files. Does this in

src/cascadia/TerminalApp/TerminalPage.h

@@ -420,7 +420,7 @@ namespace winrt::TerminalApp::implementation
         void _SetAcceleratorForMenuItem(Windows::UI::Xaml::Controls::MenuFlyoutItem& menuItem, const winrt::Microsoft::Terminal::Control::KeyChord& keyChord);
 
         safe_void_coroutine _PasteFromClipboardHandler(const IInspectable sender,
-                                                       const Microsoft::Terminal::Control::PasteFromClipboardEventArgs eventArgs);
+                                                       const IInspectable eventArgs);
 
         safe_void_coroutine _OpenHyperlinkHandler(const IInspectable sender, const Microsoft::Terminal::Control::OpenHyperlinkEventArgs eventArgs);
         static bool _IsUriSupported(const winrt::Windows::Foundation::Uri& parsedUri);

src/cascadia/TerminalControl/ControlCore.cpp

@@ -498,7 +498,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     // - wstr: the string of characters to write to the terminal connection.
     // Return Value:
     // - <none>
-    void ControlCore::SendInput(const std::wstring_view wstr)
+    void ControlCore::_sendInput(const std::wstring_view wstr)
     {
         if (wstr.empty())
         {
@@ -554,7 +554,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         }
         if (out)
         {
-            SendInput(*out);
+            _sendInput(*out);
             return true;
         }
         return false;
@@ -712,7 +712,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         }
         if (out)
         {
-            SendInput(*out);
+            _sendInput(*out);
             return true;
         }
         return false;
@@ -731,7 +731,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         }
         if (out)
         {
-            SendInput(*out);
+            _sendInput(*out);
             return true;
         }
         return false;
@@ -1451,24 +1451,34 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     // Method Description:
     // - Pre-process text pasted (presumably from the clipboard)
     //   before sending it over the terminal's connection.
-    void ControlCore::PasteText(const winrt::hstring& hstr)
+    void ControlCore::WriteInputString(const std::wstring_view& str, WriteInputStringType type)
     {
-        using namespace ::Microsoft::Console::Utils;
-
-        auto filtered = FilterStringForPaste(hstr, CarriageReturnNewline | ControlCodes);
-        if (BracketedPasteEnabled())
+        switch (type)
         {
-            filtered.insert(0, L"\x1b[200~");
-            filtered.append(L"\x1b[201~");
+        case WriteInputStringType::Clipboard:
+        {
+            using namespace ::Microsoft::Console::Utils;
+
+            auto filtered = FilterStringForPaste(str, CarriageReturnNewline | ControlCodes);
+            if (BracketedPasteEnabled())
+            {
+                filtered.insert(0, L"\x1b[200~");
+                filtered.append(L"\x1b[201~");
+            }
+
+            // It's important to not hold the terminal lock while calling this function as sending the data may take a long time.
+            _sendInput(filtered);
+
+            const auto lock = _terminal->LockForWriting();
+            _terminal->ClearSelection();
+            _updateSelectionUI();
+            _terminal->TrySnapOnInput();
+            return;
+        }
+        case WriteInputStringType::Raw:
+            _sendInput(str);
+            return;
         }
-
-        // It's important to not hold the terminal lock while calling this function as sending the data may take a long time.
-        SendInput(filtered);
-
-        const auto lock = _terminal->LockForWriting();
-        _terminal->ClearSelection();
-        _updateSelectionUI();
-        _terminal->TrySnapOnInput();
     }
 
     FontInfo ControlCore::GetFont() const
@@ -2197,7 +2207,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                     // Sending input requires that we're unlocked, because
                     // writing the input pipe may block indefinitely.
                     const auto suspension = _terminal->SuspendLock();
-                    SendInput(buffer);
+                    _sendInput(buffer);
                 }
             }
         }

src/cascadia/TerminalControl/ControlCore.h

@@ -122,8 +122,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         til::color ForegroundColor() const;
         til::color BackgroundColor() const;
 
-        void SendInput(std::wstring_view wstr);
-        void PasteText(const winrt::hstring& hstr);
+        void WriteInputString(const std::wstring_view& str, WriteInputStringType type);
         bool CopySelectionToClipboard(bool singleLine, bool withControlSequences, const CopyFormat formats);
         void SelectAll();
         void ClearSelection();
@@ -320,6 +319,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
         void _handleControlC();
         void _sendInputToConnection(std::wstring_view wstr);
+        void _sendInput(std::wstring_view wstr);
 
 #pragma region TerminalCoreCallbacks
         void _terminalWarningBell();

src/cascadia/TerminalControl/ControlCore.idl

@@ -68,6 +68,14 @@ namespace Microsoft.Terminal.Control
         Boolean SearchRegexInvalid;
     };
 
+    enum WriteInputStringType
+    {
+        // Text which is to be passed through unmodified.
+        Raw,
+        // Text which is to be treated as clipboard input, stripped and formatted according to the application's wishes.
+        Clipboard,
+    };
+
     [default_interface] runtimeclass SelectionColor
     {
         SelectionColor();
@@ -128,8 +136,7 @@ namespace Microsoft.Terminal.Control
         Boolean SendCharEvent(Char ch,
                               Int16 scanCode,
                               Microsoft.Terminal.Core.ControlKeyStates modifiers);
-        void SendInput(String text);
-        void PasteText(String text);
+        void WriteInputString(String text, WriteInputStringType type);
         void SelectAll();
         void ClearSelection();
         Boolean ToggleBlockSelection();

src/cascadia/TerminalControl/ControlInteractivity.cpp

@@ -242,14 +242,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     // - Initiate a paste operation.
     void ControlInteractivity::RequestPasteTextFromClipboard()
     {
-        auto args = winrt::make<PasteFromClipboardEventArgs>(
-            [core = _core](const winrt::hstring& wstr) {
-                core->PasteText(wstr);
-            },
-            _core->BracketedPasteEnabled());
-
         // send paste event up to TermApp
-        PasteFromClipboard.raise(*this, std::move(args));
+        PasteFromClipboard.raise(*this, nullptr);
     }
 
     void ControlInteractivity::PointerPressed(const uint32_t /*pointerId*/,

src/cascadia/TerminalControl/ControlInteractivity.h

@@ -92,7 +92,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         void AttachToNewControl();
 
         til::typed_event<IInspectable, Control::OpenHyperlinkEventArgs> OpenHyperlink;
-        til::typed_event<IInspectable, Control::PasteFromClipboardEventArgs> PasteFromClipboard;
+        til::typed_event<IInspectable, IInspectable> PasteFromClipboard;
         til::typed_event<IInspectable, Control::ScrollPositionChangedArgs> ScrollPositionChanged;
         til::typed_event<IInspectable, Control::ContextMenuRequestedEventArgs> ContextMenuRequested;
 

src/cascadia/TerminalControl/ControlInteractivity.idl

@@ -68,7 +68,7 @@ namespace Microsoft.Terminal.Control
 
         event Windows.Foundation.TypedEventHandler<Object, OpenHyperlinkEventArgs> OpenHyperlink;
         event Windows.Foundation.TypedEventHandler<Object, ScrollPositionChangedArgs> ScrollPositionChanged;
-        event Windows.Foundation.TypedEventHandler<Object, PasteFromClipboardEventArgs> PasteFromClipboard;
+        event Windows.Foundation.TypedEventHandler<Object, Object> PasteFromClipboard;
 
         event Windows.Foundation.TypedEventHandler<Object, Object> Closed;
 

src/cascadia/TerminalControl/EventArgs.cpp

@@ -7,7 +7,6 @@
 #include "TitleChangedEventArgs.g.cpp"
 #include "ContextMenuRequestedEventArgs.g.cpp"
 #include "WriteToClipboardEventArgs.g.cpp"
-#include "PasteFromClipboardEventArgs.g.cpp"
 #include "OpenHyperlinkEventArgs.g.cpp"
 #include "NoticeEventArgs.g.cpp"
 #include "ScrollPositionChangedArgs.g.cpp"

src/cascadia/TerminalControl/EventArgs.h

@@ -7,7 +7,6 @@
 #include "TitleChangedEventArgs.g.h"
 #include "ContextMenuRequestedEventArgs.g.h"
 #include "WriteToClipboardEventArgs.g.h"
-#include "PasteFromClipboardEventArgs.g.h"
 #include "OpenHyperlinkEventArgs.g.h"
 #include "NoticeEventArgs.g.h"
 #include "ScrollPositionChangedArgs.g.h"
@@ -83,24 +82,6 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         std::string _rtf;
     };
 
-    struct PasteFromClipboardEventArgs : public PasteFromClipboardEventArgsT<PasteFromClipboardEventArgs>
-    {
-    public:
-        PasteFromClipboardEventArgs(std::function<void(const hstring&)> clipboardDataHandler, bool bracketedPasteEnabled) :
-            m_clipboardDataHandler(clipboardDataHandler),
-            _BracketedPasteEnabled{ bracketedPasteEnabled } {}
-
-        void HandleClipboardData(hstring value)
-        {
-            m_clipboardDataHandler(value);
-        };
-
-        WINRT_PROPERTY(bool, BracketedPasteEnabled, false);
-
-    private:
-        std::function<void(const hstring&)> m_clipboardDataHandler;
-    };
-
     struct OpenHyperlinkEventArgs : public OpenHyperlinkEventArgsT<OpenHyperlinkEventArgs>
     {
     public:
@@ -235,10 +216,11 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     struct StringSentEventArgs : public StringSentEventArgsT<StringSentEventArgs>
     {
     public:
-        StringSentEventArgs(const winrt::hstring& text) :
-            _Text(text) {}
+        StringSentEventArgs(const winrt::hstring& text, uint32_t type) :
+            _Text(text), _Type(type) {}
 
         WINRT_PROPERTY(winrt::hstring, Text);
+        WINRT_PROPERTY(uint32_t, Type);
     };
 
     struct SearchMissingCommandEventArgs : public SearchMissingCommandEventArgsT<SearchMissingCommandEventArgs>

src/cascadia/TerminalControl/EventArgs.idl

@@ -68,12 +68,6 @@ namespace Microsoft.Terminal.Control
         byte[] Rtf { get; }; // UTF-8, as required by "Rich Text Format"
     }
 
-    runtimeclass PasteFromClipboardEventArgs
-    {
-        void HandleClipboardData(String data);
-        Boolean BracketedPasteEnabled { get; };
-    }
-
     runtimeclass OpenHyperlinkEventArgs
     {
         OpenHyperlinkEventArgs(String uri);
@@ -152,6 +146,7 @@ namespace Microsoft.Terminal.Control
     runtimeclass StringSentEventArgs
     {
         String Text { get; };
+        UInt32 Type { get; }; // We cannot forward-declare WriteInputStringType, and as of GH#20164 this whole event is getting deleted anyway.
     }
 
     runtimeclass SearchMissingCommandEventArgs

src/cascadia/TerminalControl/TermControl.cpp

@@ -238,7 +238,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         {
             return;
         }
-        core->SendInput(text);
+        core->WriteInputString(text, WriteInputStringType::Raw);
     }
 
     ::Microsoft::Console::Render::Renderer* TsfDataProvider::GetRenderer()
@@ -912,19 +912,25 @@ namespace winrt::Microsoft::Terminal::Control::implementation
     // - wstr: the string of characters to write to the terminal connection.
     // Return Value:
     // - <none>
-    void TermControl::SendInput(const winrt::hstring& wstr)
+    void TermControl::WriteInputString(const winrt::hstring& wstr, WriteInputStringType type)
     {
-        // Dismiss any previewed input.
-        PreviewInput(hstring{});
+        WriteInputStringWithoutBroadcast(wstr, type);
 
         // only broadcast if there's an actual listener. Saves the overhead of some object creation.
         if (StringSent)
         {
-            StringSent.raise(*this, winrt::make<StringSentEventArgs>(wstr));
+            StringSent.raise(*this, winrt::make<StringSentEventArgs>(wstr, static_cast<uint32_t>(type)));
         }
-
-        RawWriteString(wstr);
     }
+
+    void TermControl::WriteInputStringWithoutBroadcast(const winrt::hstring& wstr, WriteInputStringType type)
+    {
+        // Dismiss any previewed input.
+        PreviewInput(hstring{});
+
+        _core.WriteInputString(wstr, type);
+    }
+
     void TermControl::ClearBuffer(Control::ClearBufferType clearType)
     {
         _core.ClearBuffer(clearType);
@@ -1524,11 +1530,6 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         return _core.SendCharEvent(character, scanCode, modifiers);
     }
 
-    void TermControl::RawWriteString(const winrt::hstring& text)
-    {
-        _core.SendInput(text);
-    }
-
     // Method Description:
     // - Manually handles key events for certain keys that can't be passed to us
     //   normally. Namely, the keys we're concerned with are F7 down and Alt up.
@@ -1675,7 +1676,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                 // If it encounters a string that isn't, cppwinrt will abort().
                 // It should already be null-terminated, but let's make sure to not crash.
                 buf[buf_len] = L'\0';
-                _core.SendInput(std::wstring_view{ &buf[0], buf_len });
+                _core.WriteInputString(std::wstring_view{ &buf[0], buf_len }, WriteInputStringType::Raw);
             }
 
             s = {};
@@ -3102,7 +3103,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                 auto link{ co_await e.DataView().GetApplicationLinkAsync() };
                 if (const auto strong = weak.get())
                 {
-                    _pasteTextWithBroadcast(link.AbsoluteUri());
+                    WriteInputString(link.AbsoluteUri(), WriteInputStringType::Clipboard);
                 }
             }
             CATCH_LOG();
@@ -3114,7 +3115,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                 auto link{ co_await e.DataView().GetWebLinkAsync() };
                 if (const auto strong = weak.get())
                 {
-                    _pasteTextWithBroadcast(link.AbsoluteUri());
+                    WriteInputString(link.AbsoluteUri(), WriteInputStringType::Clipboard);
                 }
             }
             CATCH_LOG();
@@ -3126,7 +3127,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                 auto text{ co_await e.DataView().GetTextAsync() };
                 if (const auto strong = weak.get())
                 {
-                    _pasteTextWithBroadcast(text);
+                    WriteInputString(text, WriteInputStringType::Clipboard);
                 }
             }
             CATCH_LOG();
@@ -3224,27 +3225,11 @@ namespace winrt::Microsoft::Terminal::Control::implementation
                     }
                 }
 
-                _pasteTextWithBroadcast(winrt::hstring{ allPathsString });
+                WriteInputString(winrt::hstring{ allPathsString }, WriteInputStringType::Clipboard);
             }
         }
     }
 
-    // Method Description:
-    // - Paste this text, and raise a StringSent, to potentially broadcast this
-    //   text to other controls in the app. For certain interactions, like
-    //   drag/dropping a file, we want to act like we "pasted" the text (even if
-    //   the text didn't come from the clipboard). This lets those interactions
-    //   broadcast as well.
-    void TermControl::_pasteTextWithBroadcast(const winrt::hstring& text)
-    {
-        // only broadcast if there's an actual listener. Saves the overhead of some object creation.
-        if (StringSent)
-        {
-            StringSent.raise(*this, winrt::make<StringSentEventArgs>(text));
-        }
-        _core.PasteText(text);
-    }
-
     // Method Description:
     // - Handle the DragOver event. We'll signal that the drag operation we
     //   support is the "copy" operation, and we'll also customize the

src/cascadia/TerminalControl/TermControl.h

@@ -125,7 +125,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         void ResetFontSize();
         winrt::Windows::Foundation::Size GetFontSize() const;
 
-        void SendInput(const winrt::hstring& input);
+        void WriteInputString(const winrt::hstring& wstr, WriteInputStringType type);
+        void WriteInputStringWithoutBroadcast(const winrt::hstring& wstr, WriteInputStringType type);
         void ClearBuffer(Control::ClearBufferType clearType);
 
         void ToggleShaderEffects();
@@ -179,7 +180,6 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
         bool RawWriteKeyEvent(const WORD vkey, const WORD scanCode, const winrt::Microsoft::Terminal::Core::ControlKeyStates modifiers, const bool keyDown);
         bool RawWriteChar(const wchar_t character, const WORD scanCode, const winrt::Microsoft::Terminal::Core::ControlKeyStates modifiers);
-        void RawWriteString(const winrt::hstring& text);
 
         void ShowContextMenu();
         bool OpenQuickFixMenu();
@@ -229,7 +229,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         BUBBLED_FORWARDED_TYPED_EVENT(CompletionsChanged,       IInspectable, Control::CompletionsChangedEventArgs);
         BUBBLED_FORWARDED_TYPED_EVENT(RestartTerminalRequested, IInspectable, IInspectable);
         BUBBLED_FORWARDED_TYPED_EVENT(WriteToClipboard,         IInspectable, Control::WriteToClipboardEventArgs);
-        BUBBLED_FORWARDED_TYPED_EVENT(PasteFromClipboard,       IInspectable, Control::PasteFromClipboardEventArgs);
+        BUBBLED_FORWARDED_TYPED_EVENT(PasteFromClipboard,       IInspectable, IInspectable);
 
         // clang-format on
 
@@ -429,8 +429,6 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         winrt::Windows::Foundation::Point _toPosInDips(const Core::Point terminalCellPos);
         void _throttledUpdateScrollbar(const ScrollBarUpdate& update);
 
-        void _pasteTextWithBroadcast(const winrt::hstring& text);
-
         void _contextMenuHandler(IInspectable sender, Control::ContextMenuRequestedEventArgs args);
         void _showContextMenuAt(const winrt::Windows::Foundation::Point& controlRelativePos);
 

src/cascadia/TerminalControl/TermControl.idl

@@ -64,7 +64,7 @@ namespace Microsoft.Terminal.Control
 
         event Windows.Foundation.TypedEventHandler<Object, TitleChangedEventArgs> TitleChanged;
         event Windows.Foundation.TypedEventHandler<Object, WriteToClipboardEventArgs> WriteToClipboard;
-        event Windows.Foundation.TypedEventHandler<Object, PasteFromClipboardEventArgs> PasteFromClipboard;
+        event Windows.Foundation.TypedEventHandler<Object, Object> PasteFromClipboard;
         event Windows.Foundation.TypedEventHandler<Object, OpenHyperlinkEventArgs> OpenHyperlink;
         event Windows.Foundation.TypedEventHandler<Object, Object> SetTaskbarProgress;
         event Windows.Foundation.TypedEventHandler<Object, NoticeEventArgs> RaiseNotice;
@@ -127,10 +127,12 @@ namespace Microsoft.Terminal.Control
         void ResetFontSize();
 
         void ToggleShaderEffects();
-        void SendInput(String input);
         Boolean RawWriteKeyEvent(UInt16 vkey, UInt16 scanCode, Microsoft.Terminal.Core.ControlKeyStates modifiers, Boolean keyDown);
         Boolean RawWriteChar(Char character, UInt16 scanCode, Microsoft.Terminal.Core.ControlKeyStates modifiers);
-        void RawWriteString(String text);
+        void WriteInputString(String text, WriteInputStringType type);
+        // This is a stopgap until GH#20164 removes StringSent
+        // It prevents us from entering an infinite broadcast loop
+        void WriteInputStringWithoutBroadcast(String text, WriteInputStringType type);
 
         void BellLightOn();
 

src/cascadia/inc/cppwinrt_utils.h

@@ -153,9 +153,9 @@ public:
 //    _core.TitleChanged({ get_weak(), &TermControl::_bubbleTitleChanged });
 #define BUBBLED_FORWARDED_TYPED_EVENT(name, sender, args) \
     TYPED_EVENT(name, sender, args)                       \
-    void _bubble##name(const sender& s, const args& a)    \
+    void _bubble##name(const sender&, const args& a)      \
     {                                                     \
-        _##name##Handlers(s, a);                          \
+        _##name##Handlers(*this, a);                      \
     }
 
 // Use this macro to quick implement both the getter and setter for a property.