Make the window name _quake special

.github/actions/spelling/expect/expect.txt

@@ -1025,14 +1025,20 @@ hsl
 hstr
 hstring
 hsv
+HTBOTTOMLEFT
+HTBOTTOMRIGHT
 HTCAPTION
 HTCLIENT
+HTLEFT
 htm
 HTMAXBUTTON
 HTMINBUTTON
 html
 HTMLTo
+HTRIGHT
 HTTOP
+HTTOPLEFT
+HTTOPRIGHT
 hu
 hungapp
 HVP

src/cascadia/TerminalApp/AppLogic.cpp

@@ -285,12 +285,21 @@ namespace winrt::TerminalApp::implementation
             // launched _fullscreen_, toggle fullscreen mode. This will make sure
             // that the window size is _first_ set up as something sensible, so
             // leaving fullscreen returns to a reasonable size.
+            //
+            // We know at the start, that the root TerminalPage definitely isn't
+            // in focus nor fullscreen mode. So "Toggle" here will always work
+            // to "enable".
             const auto launchMode = this->GetLaunchMode();
-            if (launchMode == LaunchMode::FullscreenMode)
+            if (IsQuakeWindow())
+            {
+                _root->ToggleFocusMode();
+            }
+            else if (launchMode == LaunchMode::FullscreenMode)
             {
                 _root->ToggleFullscreen();
             }
-            else if (launchMode == LaunchMode::FocusMode || launchMode == LaunchMode::MaximizedFocusMode)
+            else if (launchMode == LaunchMode::FocusMode ||
+                     launchMode == LaunchMode::MaximizedFocusMode)
             {
                 _root->ToggleFocusMode();
             }
@@ -1419,4 +1428,9 @@ namespace winrt::TerminalApp::implementation
         }
     }
 
+    bool AppLogic::IsQuakeWindow() const noexcept
+    {
+        return _root->IsQuakeWindow();
+    }
+
 }

src/cascadia/TerminalApp/AppLogic.h

@@ -66,6 +66,7 @@ namespace winrt::TerminalApp::implementation
         void WindowName(const winrt::hstring& name);
         uint64_t WindowId();
         void WindowId(const uint64_t& id);
+        bool IsQuakeWindow() const noexcept;
 
         Windows::Foundation::Size GetLaunchDimensions(uint32_t dpi);
         bool CenterOnLaunch();
@@ -158,6 +159,7 @@ namespace winrt::TerminalApp::implementation
         FORWARDED_TYPED_EVENT(SetTaskbarProgress, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable, _root, SetTaskbarProgress);
         FORWARDED_TYPED_EVENT(IdentifyWindowsRequested, Windows::Foundation::IInspectable, Windows::Foundation::IInspectable, _root, IdentifyWindowsRequested);
         FORWARDED_TYPED_EVENT(RenameWindowRequested, Windows::Foundation::IInspectable, winrt::TerminalApp::RenameWindowRequestedArgs, _root, RenameWindowRequested);
+        FORWARDED_TYPED_EVENT(IsQuakeWindowChanged, Windows::Foundation::IInspectable, Windows::Foundation::IInspectable, _root, IsQuakeWindowChanged);
 
 #ifdef UNIT_TESTING
         friend class TerminalAppLocalTests::CommandlineTest;

src/cascadia/TerminalApp/AppLogic.idl

@@ -52,6 +52,7 @@ namespace TerminalApp
         String WindowName;
         UInt64 WindowId;
         void RenameFailed();
+        Boolean IsQuakeWindow();
 
         Windows.Foundation.Size GetLaunchDimensions(UInt32 dpi);
         Boolean CenterOnLaunch { get; };
@@ -85,5 +86,6 @@ namespace TerminalApp
         event Windows.Foundation.TypedEventHandler<Object, Object> SetTaskbarProgress;
         event Windows.Foundation.TypedEventHandler<Object, Object> IdentifyWindowsRequested;
         event Windows.Foundation.TypedEventHandler<Object, RenameWindowRequestedArgs> RenameWindowRequested;
+        event Windows.Foundation.TypedEventHandler<Object, Object> IsQuakeWindowChanged;
     }
 }

src/cascadia/TerminalApp/TabManagement.cpp

@@ -272,12 +272,17 @@ namespace winrt::TerminalApp::implementation
                                 (_tabs.Size() > 1) ||
                                 _settings.GlobalSettings().AlwaysShowTabs());
 
-        // collapse/show the tabs themselves
-        _tabView.Visibility(isVisible ? Visibility::Visible : Visibility::Collapsed);
-
-        // collapse/show the row that the tabs are in.
-        // NaN is the special value XAML uses for "Auto" sizing.
-        _tabRow.Height(isVisible ? NAN : 0);
+        if (_tabView)
+        {
+            // collapse/show the tabs themselves
+            _tabView.Visibility(isVisible ? Visibility::Visible : Visibility::Collapsed);
+        }
+        if (_tabRow)
+        {
+            // collapse/show the row that the tabs are in.
+            // NaN is the special value XAML uses for "Auto" sizing.
+            _tabRow.Height(isVisible ? NAN : 0);
+        }
     }
 
     // Method Description:

src/cascadia/TerminalApp/TerminalPage.cpp

@@ -42,6 +42,8 @@ namespace winrt
     using IInspectable = Windows::Foundation::IInspectable;
 }
 
+static constexpr std::wstring_view QuakeWindowName{ L"_quake" };
+
 namespace winrt::TerminalApp::implementation
 {
     TerminalPage::TerminalPage() :
@@ -2049,9 +2051,20 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     void TerminalPage::ToggleFocusMode()
     {
-        _isInFocusMode = !_isInFocusMode;
-        _UpdateTabView();
-        _FocusModeChangedHandlers(*this, nullptr);
+        _SetFocusMode(!_isInFocusMode);
+    }
+
+    void TerminalPage::_SetFocusMode(const bool inFocusMode)
+    {
+        // If we're the quake window, we must always be in focus mode.
+        // Prevent leaving focus mode here.
+        const bool newInFocusMode = inFocusMode || IsQuakeWindow();
+        if (newInFocusMode != FocusMode())
+        {
+            _isInFocusMode = newInFocusMode;
+            _UpdateTabView();
+            _FocusModeChangedHandlers(*this, nullptr);
+        }
     }
 
     // Method Description:
@@ -2596,10 +2609,21 @@ namespace winrt::TerminalApp::implementation
     }
     void TerminalPage::WindowName(const winrt::hstring& value)
     {
+        const bool oldIsQuakeMode = IsQuakeWindow();
         if (_WindowName != value)
         {
             _WindowName = value;
             _PropertyChangedHandlers(*this, WUX::Data::PropertyChangedEventArgs{ L"WindowNameForDisplay" });
+
+            // If we're entering quake mode, or leaving it
+            if (IsQuakeWindow() != oldIsQuakeMode)
+            {
+                // If we're entering Quake Mode from ~Focus Mode, then this will enter Focus Mode
+                // If we're entering Quake Mode from Focus Mode, then this will do nothing
+                // If we're leaving Quake Mode (we're already in Focus Mode), then this will do nothing
+                _SetFocusMode(true);
+                _IsQuakeWindowChangedHandlers(*this, nullptr);
+            }
         }
     }
 
@@ -2735,4 +2759,9 @@ namespace winrt::TerminalApp::implementation
             WindowRenamer().IsOpen(false);
         }
     }
+
+    bool TerminalPage::IsQuakeWindow() const noexcept
+    {
+        return WindowName() == QuakeWindowName;
+    }
 }

src/cascadia/TerminalApp/TerminalPage.h

@@ -107,6 +107,7 @@ namespace winrt::TerminalApp::implementation
         void WindowId(const uint64_t& value);
         winrt::hstring WindowIdForDisplay() const noexcept;
         winrt::hstring WindowNameForDisplay() const noexcept;
+        bool IsQuakeWindow() const noexcept;
 
         WINRT_CALLBACK(PropertyChanged, Windows::UI::Xaml::Data::PropertyChangedEventHandler);
 
@@ -122,6 +123,7 @@ namespace winrt::TerminalApp::implementation
         TYPED_EVENT(Initialized, IInspectable, winrt::Windows::UI::Xaml::RoutedEventArgs);
         TYPED_EVENT(IdentifyWindowsRequested, IInspectable, IInspectable);
         TYPED_EVENT(RenameWindowRequested, Windows::Foundation::IInspectable, winrt::TerminalApp::RenameWindowRequestedArgs);
+        TYPED_EVENT(IsQuakeWindowChanged, IInspectable, IInspectable);
 
     private:
         friend struct TerminalPageT<TerminalPage>; // for Xaml to bind events
@@ -330,6 +332,8 @@ namespace winrt::TerminalApp::implementation
 
         void _UpdateTeachingTipTheme(winrt::Windows::UI::Xaml::FrameworkElement element);
 
+        void _SetFocusMode(const bool inFocusMode);
+
 #pragma region ActionHandlers
         // These are all defined in AppActionHandlers.cpp
 #define ON_ALL_ACTIONS(action) DECLARE_ACTION_HANDLER(action);

src/cascadia/TerminalApp/TerminalPage.idl

@@ -33,6 +33,7 @@ namespace TerminalApp
         String WindowNameForDisplay { get; };
         String WindowIdForDisplay { get; };
         void RenameFailed();
+        Boolean IsQuakeWindow();
 
         // We cannot use the default XAML APIs because we want to make sure
         // that there's only one application-global dialog visible at a time,
@@ -54,5 +55,6 @@ namespace TerminalApp
         event Windows.Foundation.TypedEventHandler<Object, Object> SetTaskbarProgress;
         event Windows.Foundation.TypedEventHandler<Object, Object> IdentifyWindowsRequested;
         event Windows.Foundation.TypedEventHandler<Object, RenameWindowRequestedArgs> RenameWindowRequested;
+        event Windows.Foundation.TypedEventHandler<Object, Object> IsQuakeWindowChanged;
     }
 }

src/cascadia/WindowsTerminal/AppHost.cpp

@@ -57,6 +57,9 @@ AppHost::AppHost() noexcept :
         _window = std::make_unique<IslandWindow>();
     }
 
+    // Update our own internal state tracking if we're in quake mode or not.
+    _IsQuakeWindowChanged(nullptr, nullptr);
+
     // Tell the window to callback to us when it's about to handle a WM_CREATE
     auto pfn = std::bind(&AppHost::_HandleCreateWindow,
                          this,
@@ -251,6 +254,7 @@ void AppHost::Initialize()
     _logic.SetTaskbarProgress({ this, &AppHost::SetTaskbarProgress });
     _logic.IdentifyWindowsRequested({ this, &AppHost::_IdentifyWindowsRequested });
     _logic.RenameWindowRequested({ this, &AppHost::_RenameWindowRequested });
+    _logic.IsQuakeWindowChanged({ this, &AppHost::_IsQuakeWindowChanged });
 
     _window->UpdateTitle(_logic.Title());
 
@@ -379,39 +383,58 @@ void AppHost::_HandleCreateWindow(const HWND hwnd, RECT proposedRect, LaunchMode
 
     // Get the size of a window we'd need to host that client rect. This will
     // add the titlebar space.
-    const auto nonClientSize = _window->GetTotalNonClientExclusiveSize(dpix);
-    adjustedWidth = islandWidth + nonClientSize.cx;
-    adjustedHeight = islandHeight + nonClientSize.cy;
+    const til::size nonClientSize = _window->GetTotalNonClientExclusiveSize(dpix);
+    adjustedWidth = islandWidth + nonClientSize.width<long>();
+    adjustedHeight = islandHeight + nonClientSize.height<long>();
+
+    til::size dimensions{ Utils::ClampToShortMax(adjustedWidth, 1),
+                          Utils::ClampToShortMax(adjustedHeight, 1) };
+
+    // Find nearest monitor for the position that we've actually settled on
+    HMONITOR hMonNearest = MonitorFromRect(&proposedRect, MONITOR_DEFAULTTONEAREST);
+    MONITORINFO nearestMonitorInfo;
+    nearestMonitorInfo.cbSize = sizeof(MONITORINFO);
+    // Get monitor dimensions:
+    GetMonitorInfo(hMonNearest, &nearestMonitorInfo);
+    const til::size desktopDimensions{ gsl::narrow<short>(nearestMonitorInfo.rcWork.right - nearestMonitorInfo.rcWork.left),
+                                       gsl::narrow<short>(nearestMonitorInfo.rcWork.bottom - nearestMonitorInfo.rcWork.top) };
 
-    const COORD dimensions{ Utils::ClampToShortMax(adjustedWidth, 1),
-                            Utils::ClampToShortMax(adjustedHeight, 1) };
+    til::point origin{ ::base::saturated_cast<ptrdiff_t>(proposedRect.left),
+                       ::base::saturated_cast<ptrdiff_t>(proposedRect.top) };
 
-    if (centerOnLaunch)
+    if (_logic.IsQuakeWindow())
+    {
+        // If we just use rcWork by itself, we'll fail to account for the invisible
+        // space reserved for the resize handles. So retrieve that size here.
+        const til::size ncSize{ _window->GetTotalNonClientExclusiveSize(dpix) };
+        const til::size availableSpace = desktopDimensions + nonClientSize;
+
+        origin = til::point{
+            ::base::saturated_cast<ptrdiff_t>(nearestMonitorInfo.rcWork.left - (nonClientSize.width() / 2)),
+            ::base::saturated_cast<ptrdiff_t>(nearestMonitorInfo.rcWork.top)
+        };
+        dimensions = til::size{
+            availableSpace.width(),
+            availableSpace.height() / 2
+        };
+        launchMode = LaunchMode::FocusMode;
+    }
+    else if (centerOnLaunch)
     {
-        // Find nearest monitor for the position that we've actually settled on
-        HMONITOR hMonNearest = MonitorFromRect(&proposedRect, MONITOR_DEFAULTTONEAREST);
-        MONITORINFO nearestMonitorInfo;
-        nearestMonitorInfo.cbSize = sizeof(MONITORINFO);
-        // Get monitor dimensions:
-        GetMonitorInfo(hMonNearest, &nearestMonitorInfo);
-        const COORD desktopDimensions{ gsl::narrow<short>(nearestMonitorInfo.rcWork.right - nearestMonitorInfo.rcWork.left),
-                                       gsl::narrow<short>(nearestMonitorInfo.rcWork.bottom - nearestMonitorInfo.rcWork.top) };
         // Move our proposed location into the center of that specific monitor.
-        proposedRect.left = nearestMonitorInfo.rcWork.left +
-                            ((desktopDimensions.X / 2) - (dimensions.X / 2));
-        proposedRect.top = nearestMonitorInfo.rcWork.top +
-                           ((desktopDimensions.Y / 2) - (dimensions.Y / 2));
+        origin = til::point{
+            ::base::saturated_cast<ptrdiff_t>(nearestMonitorInfo.rcWork.left + ((desktopDimensions.width() / 2) - (dimensions.width() / 2))),
+            ::base::saturated_cast<ptrdiff_t>(nearestMonitorInfo.rcWork.top + ((desktopDimensions.height() / 2) - (dimensions.height() / 2)))
+        };
     }
-    const COORD origin{ gsl::narrow<short>(proposedRect.left),
-                        gsl::narrow<short>(proposedRect.top) };
 
-    const auto newPos = Viewport::FromDimensions(origin, dimensions);
+    const til::rectangle newRect{ origin, dimensions };
     bool succeeded = SetWindowPos(hwnd,
                                   nullptr,
-                                  newPos.Left(),
-                                  newPos.Top(),
-                                  newPos.Width(),
-                                  newPos.Height(),
+                                  newRect.left<int>(),
+                                  newRect.top<int>(),
+                                  newRect.width<int>(),
+                                  newRect.height<int>(),
                                   SWP_NOACTIVATE | SWP_NOZORDER);
 
     // Refresh the dpi of HWND because the dpi where the window will launch may be different
@@ -674,3 +697,9 @@ winrt::fire_and_forget AppHost::_RenameWindowRequested(const winrt::Windows::Fou
         }
     }
 }
+
+void AppHost::_IsQuakeWindowChanged(const winrt::Windows::Foundation::IInspectable&,
+                                    const winrt::Windows::Foundation::IInspectable&)
+{
+    _window->IsQuakeWindow(_logic.IsQuakeWindow());
+}

src/cascadia/WindowsTerminal/AppHost.h

@@ -59,4 +59,7 @@ class AppHost
                                                   const winrt::TerminalApp::RenameWindowRequestedArgs args);
 
     GUID _CurrentDesktopGuid();
+
+    void _IsQuakeWindowChanged(const winrt::Windows::Foundation::IInspectable& sender,
+                               const winrt::Windows::Foundation::IInspectable& args);
 };