Merge branch 'main' into dev/migrie/b/13066-SW_FLASH-2

doc/cascadia/profiles.schema.json

@@ -1708,6 +1708,11 @@
           "description": "Force the terminal to use the legacy input encoding. Certain keys in some applications may stop working when enabling this setting.",
           "type": "boolean"
         },
+        "experimental.useBackgroundImageForWindow": {
+          "default": false,
+          "description": "When set to true, the background image for the currently focused profile is expanded to encompass the entire window, beneath other panes.",
+          "type": "boolean"
+        },
         "initialCols": {
           "default": 120,
           "description": "The number of columns displayed in the window upon first load. If \"launchMode\" is set to \"maximized\" (or \"maximizedFocus\"), this property is ignored.",

src/cascadia/TerminalApp/Resources/en-US/Resources.resw

@@ -709,6 +709,9 @@
   <data name="ExportSuccess" xml:space="preserve">
     <value>Successfully exported terminal content</value>
   </data>
+  <data name="FindText" xml:space="preserve">
+    <value>Find</value>
+  </data>
   <data name="PlainText" xml:space="preserve">
     <value>Plain Text</value>
   </data>

src/cascadia/TerminalApp/TabManagement.cpp

@@ -209,6 +209,16 @@ namespace winrt::TerminalApp::implementation
             }
         });
 
+        newTabImpl->FindRequested([weakTab, weakThis{ get_weak() }]() {
+            auto page{ weakThis.get() };
+            auto tab{ weakTab.get() };
+
+            if (page && tab)
+            {
+                page->_Find();
+            }
+        });
+
         auto tabViewItem = newTabImpl->TabViewItem();
         _tabView.TabItems().Append(tabViewItem);
 

src/cascadia/TerminalApp/TerminalTab.cpp

@@ -1273,6 +1273,23 @@ namespace winrt::TerminalApp::implementation
             exportTabMenuItem.Icon(exportTabSymbol);
         }
 
+        Controls::MenuFlyoutItem findMenuItem;
+        {
+            // "Split Tab"
+            Controls::FontIcon findSymbol;
+            findSymbol.FontFamily(Media::FontFamily{ L"Segoe Fluent Icons, Segoe MDL2 Assets" });
+            findSymbol.Glyph(L"\xF78B"); // SearchMedium
+
+            findMenuItem.Click([weakThis](auto&&, auto&&) {
+                if (auto tab{ weakThis.get() })
+                {
+                    tab->_FindRequestedHandlers();
+                }
+            });
+            findMenuItem.Text(RS_(L"FindText"));
+            findMenuItem.Icon(findSymbol);
+        }
+
         // Build the menu
         Controls::MenuFlyout contextMenuFlyout;
         Controls::MenuFlyoutSeparator menuSeparator;
@@ -1281,6 +1298,7 @@ namespace winrt::TerminalApp::implementation
         contextMenuFlyout.Items().Append(duplicateTabMenuItem);
         contextMenuFlyout.Items().Append(splitTabMenuItem);
         contextMenuFlyout.Items().Append(exportTabMenuItem);
+        contextMenuFlyout.Items().Append(findMenuItem);
         contextMenuFlyout.Items().Append(menuSeparator);
 
         // GH#5750 - When the context menu is dismissed with ESC, toss the focus
@@ -1291,7 +1309,7 @@ namespace winrt::TerminalApp::implementation
                 // GH#10112 - if we're opening the tab renamer, don't
                 // immediately toss focus to the control. We don't want to steal
                 // focus from the tab renamer.
-                if (!tab->_headerControl.InRename())
+                if (!tab->_headerControl.InRename() && !tab->GetActiveTerminalControl().SearchBoxEditInFocus())
                 {
                     tab->_RequestFocusActiveControlHandlers();
                 }

src/cascadia/TerminalApp/TerminalTab.h

@@ -102,6 +102,7 @@ namespace winrt::TerminalApp::implementation
         WINRT_CALLBACK(TabRaiseVisualBell, winrt::delegate<>);
         WINRT_CALLBACK(DuplicateRequested, winrt::delegate<>);
         WINRT_CALLBACK(SplitTabRequested, winrt::delegate<>);
+        WINRT_CALLBACK(FindRequested, winrt::delegate<>);
         WINRT_CALLBACK(ExportTabRequested, winrt::delegate<>);
         TYPED_EVENT(TaskbarProgressChanged, IInspectable, IInspectable);
 

src/cascadia/TerminalControl/TermControl.cpp

@@ -197,6 +197,20 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         }
     }
 
+    // Method Description:
+    // Find if search box text edit currently is in focus
+    // Return Value:
+    // - true, if search box text edit is in focus
+    bool TermControl::SearchBoxEditInFocus() const
+    {
+        if (!_searchBox)
+        {
+            return false;
+        }
+
+        return _searchBox->TextBox().FocusState() == FocusState::Keyboard;
+    }
+
     // Method Description:
     // - Search text in text buffer. This is triggered if the user click
     //   search button or press enter.

src/cascadia/TerminalControl/TermControl.h

@@ -90,6 +90,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
         void SearchMatch(const bool goForward);
 
+        bool SearchBoxEditInFocus() const;
+
         bool OnDirectKeyEvent(const uint32_t vkey, const uint8_t scanCode, const bool down);
 
         bool OnMouseWheel(const Windows::Foundation::Point location, const int32_t delta, const bool leftButtonDown, const bool midButtonDown, const bool rightButtonDown);

src/cascadia/TerminalControl/TermControl.idl

@@ -62,6 +62,7 @@ namespace Microsoft.Terminal.Control
         void ScrollViewport(Int32 viewTop);
 
         void CreateSearchBoxControl();
+        Boolean SearchBoxEditInFocus();
 
         void SearchMatch(Boolean goForward);
 

src/host/getset.cpp

@@ -719,6 +719,10 @@ void ApiRoutines::GetLargestConsoleWindowSizeImpl(const SCREEN_INFORMATION& cont
                                     position.Y < 0));
         // clang-format on
 
+        // MSFT: 15813316 - Try to use this SetCursorPosition call to inherit the cursor position.
+        auto& gci = ServiceLocator::LocateGlobals().getConsoleInformation();
+        RETURN_IF_FAILED(gci.GetVtIo()->SetCursorPosition(position));
+
         RETURN_IF_NTSTATUS_FAILED(buffer.SetCursorPosition(position, true));
 
         LOG_IF_FAILED(ConsoleImeResizeCompStrView());

src/inc/til/at.h

@@ -34,24 +34,24 @@ namespace til
     // gsl::at will do the check again. As will .at(). And using [] will have a warning in audit.
     // This template is explicitly disabled if T is of type gsl::span, as it would interfere with
     // the overload below.
-    template<class T, std::enable_if_t<!details::is_span<T>::value, int> = 0>
-    constexpr auto at(T& cont, const size_t i) -> decltype(cont[cont.size()])
+    template<typename T, typename I>
+    constexpr auto at(T&& cont, const I i) noexcept -> decltype(auto)
     {
-#pragma warning(suppress : 26482) // Suppress bounds.2 check for indexing with constant expressions
-#pragma warning(suppress : 26446) // Suppress bounds.4 check for subscript operator.
-#pragma warning(suppress : 26445) // Suppress lifetime check for a reference to gsl::span or std::string_view
-        return cont[i];
-    }
-
 #ifdef GSL_SPAN_H
-    // This is an overload of til::at for span that access its backing buffer directly (UNCHECKED)
-    template<typename ElementType, size_t Extent>
-    constexpr auto at(gsl::span<ElementType, Extent> span, const std::ptrdiff_t i) -> decltype(span[span.size()])
-    {
+        if constexpr (details::is_span<T>::value)
+        {
 #pragma warning(suppress : 26481) // Suppress bounds.1 check for doing pointer arithmetic
 #pragma warning(suppress : 26482) // Suppress bounds.2 check for indexing with constant expressions
 #pragma warning(suppress : 26446) // Suppress bounds.4 check for subscript operator.
-        return span.data()[i];
-    }
+            return cont.data()[i];
+        }
+        else
 #endif
+        {
+#pragma warning(suppress : 26482) // Suppress bounds.2 check for indexing with constant expressions
+#pragma warning(suppress : 26446) // Suppress bounds.4 check for subscript operator.
+#pragma warning(suppress : 26445) // Suppress lifetime check for a reference to gsl::span or std::string_view
+            return cont[i];
+        }
+    }
 }

src/inc/til/bit.h

@@ -5,10 +5,20 @@
 
 namespace til
 {
+    // bit_cast is a backport of the STL's std::bit_cast to C++17.
     template<class To, class From, std::enable_if_t<std::conjunction_v<std::bool_constant<sizeof(To) == sizeof(From)>, std::is_trivially_copyable<To>, std::is_trivially_copyable<From>>, int> = 0>
     [[nodiscard]] constexpr To bit_cast(const From& _Val) noexcept
     {
         // TODO: Replace til::bit_cast and __builtin_bit_cast with std::bit_cast
         return __builtin_bit_cast(To, _Val);
     }
+
+    // When you cast a signed integer to an unsigned one, the compiler will use "sign extension"
+    // so that -1 translates to all bits being set, no matter the size of the target type.
+    // Sometimes you don't need or want that, which is when you can use this function.
+    template<typename T>
+    [[nodiscard]] constexpr auto as_unsigned(const T& v) noexcept
+    {
+        return bit_cast<std::make_unsigned_t<T>>(v);
+    }
 }

src/inc/til/hash.h

@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include "bit.h"
+
 namespace til
 {
     template<typename T>
@@ -129,7 +131,11 @@ namespace til
     {
         // This runs murmurhash3's finalizer (fmix32/fmix64) on a single integer.
         // It's fast, public domain and produces good results.
-        auto h = static_cast<size_t>(v);
+        //
+        // Using til::as_unsigned here allows the compiler to drop the first
+        // `>> 33` mix for all Ts which are >= 32 bits.
+        // The existence of sign extension shouldn't change hash quality.
+        size_t h = til::as_unsigned(v);
         if constexpr (sizeof(size_t) == 4)
         {
             h ^= h >> 16;

src/inc/til/point.h

@@ -65,6 +65,11 @@ namespace til // Terminal Implementation Library. Also: "Today I Learned"
             return __builtin_memcmp(this, &rhs, sizeof(rhs)) != 0;
         }
 
+        constexpr explicit operator bool() const noexcept
+        {
+            return (x > 0) & (y > 0);
+        }
+
         constexpr bool operator<(const point other) const noexcept
         {
             return y < other.y || (y == other.y && x < other.x);
@@ -87,71 +92,69 @@ namespace til // Terminal Implementation Library. Also: "Today I Learned"
 
         constexpr point operator+(const point other) const
         {
-            return point{
-                details::extract(::base::CheckAdd(x, other.x)),
-                details::extract(::base::CheckAdd(y, other.y)),
-            };
+            auto copy = *this;
+            copy += other;
+            return copy;
         }
 
         constexpr point& operator+=(const point other)
         {
-            *this = *this + other;
+            x = details::extract(::base::CheckAdd(x, other.x));
+            y = details::extract(::base::CheckAdd(y, other.y));
             return *this;
         }
 
         constexpr point operator-(const point other) const
         {
-            return point{
-                details::extract(::base::CheckSub(x, other.x)),
-                details::extract(::base::CheckSub(y, other.y)),
-            };
+            auto copy = *this;
+            copy -= other;
+            return copy;
         }
 
         constexpr point& operator-=(const point other)
         {
-            *this = *this - other;
+            x = details::extract(::base::CheckSub(x, other.x));
+            y = details::extract(::base::CheckSub(y, other.y));
             return *this;
         }
 
         constexpr point operator*(const point other) const
         {
-            return point{
-                details::extract(::base::CheckMul(x, other.x)),
-                details::extract(::base::CheckMul(y, other.y)),
-            };
+            auto copy = *this;
+            copy *= other;
+            return copy;
         }
 
         constexpr point& operator*=(const point other)
         {
-            *this = *this * other;
+            x = details::extract(::base::CheckMul(x, other.x));
+            y = details::extract(::base::CheckMul(y, other.y));
             return *this;
         }
 
         constexpr point operator/(const point other) const
         {
-            return point{
-                details::extract(::base::CheckDiv(x, other.x)),
-                details::extract(::base::CheckDiv(y, other.y)),
-            };
+            auto copy = *this;
+            copy /= other;
+            return copy;
         }
 
         constexpr point& operator/=(const point other)
         {
-            *this = *this / other;
+            x = details::extract(::base::CheckDiv(x, other.x));
+            y = details::extract(::base::CheckDiv(y, other.y));
             return *this;
         }
 
-        template<typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
-        constexpr point operator*(const T scale) const
+        constexpr point operator*(const til::CoordType scale) const
         {
             return point{
                 details::extract(::base::CheckMul(x, scale)),
                 details::extract(::base::CheckMul(y, scale)),
             };
         }
 
-        template<typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
-        constexpr point operator/(const T scale) const
+        constexpr point operator/(const til::CoordType scale) const
         {
             return point{
                 details::extract(::base::CheckDiv(x, scale)),
@@ -193,6 +196,19 @@ namespace til // Terminal Implementation Library. Also: "Today I Learned"
         {
             return { x, y };
         }
+
+        // til::point and POINT have the exact same layout at the time of writing,
+        // so this function lets you unsafely "view" this point as a POINT
+        // if you need to pass it to a Win32 function.
+        //
+        // Use as_win32_point() as sparingly as possible because it'll be a pain to hack
+        // it out of this code base once til::point and POINT aren't the same anymore.
+        // Prefer casting to POINT and back to til::point instead if possible.
+        POINT* as_win32_point() noexcept
+        {
+#pragma warning(suppress : 26490) // Don't use reinterpret_cast (type.1).
+            return std::launder(reinterpret_cast<POINT*>(this));
+        }
 #endif
 
 #ifdef DCOMMON_H_INCLUDED