algo/scrolling: various scrolling view related bugfixes (#13974)

* fix scrolling view move when a grouped window is closed - prevent redundant space assignment for a grouped window that's about to be unmapped, add a `FOCUS_REASON` for unmapping grouped windows

* fix focus_fallback after unmapping a window floating moving view

* fix view change when changing workspaces (special and normal).

add an optional `RECALCULATE_REASON` parameter to `recalculate()` calls of all algorithms.
add an optional `RECALCULATE_MONITOR_REASON` parameter to `recalculateMonitor()` calls.
add 2 new `FOCUS_REASON`s, for workspace change and special workspace toggle

* Fix hyprctl keyword causing scrolling view move.
rename INPUT_MODE_KB to INPUT_MODE_HARD since it seems to have little to do with keybinds

* fix fullscreen/maximise moving the scrolling view

* fix opening of layer 3 programs moving scrolling view

* refactor, clean up and clang-format

* fix bad decisions

* fix includes, clang-format.

* remove TODO

* `focuswindow` no longer moves scrolling view when `follow_focus = 0`

* fix: changes in a group's current window no longer casues scrolling view shift when `follow_focus = 0`

* fix: `moveintogroup`, `movewindoworgroup` no longer causes scrolling view change if `follow_focus = 0`

* clang-format

* add `RECALCULATE_REASON_UNKNOWN`, `RECALCULATE_MONITOR_REASON_UNKNOWN`, `REMOVE_FROM_GROUP_REASON_UNKNOWN`

remove optional wrapper from their enums, refactor code to work with the change

* dispatches that call `switchtoWindow()` in CKeybindManager no longer cause scrolling view to move if `follow_focus = 0`.

They still cause the move if `follow_focus = 1`

Dispatches effected by this: `movefocus`, `cyclenext`, `focuscurrentorlast`, `focuscurrentorurgent`

* Fix for Lua: switchToWondow

* Fix for Lua: focus({window})

* Fix for Lua: Move Window Into Group

* clang-format

* Drop `hyprctl keyword` change

* test: `focus({window})` with `follow_focus = false`

* test: `focus({window})` with `follow_focus = true`

* test: test Focus Fallback

* test: Focus Fallback with groups

* test: workspace change

* test: special workspace toggle

* test: workspace change - special to special

also minor refactoring

* test: close window in a group

* test: move window into group `follow_focus = false`

minor fix in test: expect -> assert

* test: move window into group `follow_focus = true`

* test: new layer

* test: maximise

fix in test: expect to assert.

* test: fullscreen

* test: `dispatch window.focus({ direction })` when `follow_focus = false`

* test: `dispatch window.focus({ direction })` when `follow_focus = true`

test-fix: expect -> assert

* test: move focus within group when `follow_focus = false`

* test: move focus within group when `follow_focus = true`

* test-fix: kill all layers before killing all windows in layers test. prevents internal post test cleanup function failing to kill all layers

test-fix: maximized and fullscreen swapped between their tests

test-fix: testScrollingViewBehaviourMoveFocusInGroupFollowFocusTrue missing layout initialization

test-fix: testScrollingViewBehaviourWorkspaceChange, testScrollingViewBehaviourCloseWindowInGroup have stale window class in a comment

clang-format

* catch up with main: move to new test function

* clean-up the clean-up part of the tests: redundant

* clang-format

* pain

* suffering: fix rebase fail

* test: manually kill all layers since the cleanup function fails

* remove test: fullscreen and maximise. scrolling has its own behaviour now

1 files changed, 18 insertions, 3 deletions

diff --git a/src/layout/space/Space.cpp b/src/layout/space/Space.cpp
index 35741a14..f4785d76 100644
--- a/src/layout/space/Space.cpp
+++ b/src/layout/space/Space.cpp
@@ -146,11 +146,11 @@ SP<CAlgorithm> CSpace::algorithm() const {
     return m_algorithm;
 }
 
-void CSpace::recalculate() {
+void CSpace::recalculate(eRecalculateReason reason) {
     recheckWorkArea();
 
     if (m_algorithm)
-        m_algorithm->recalculate();
+        m_algorithm->recalculate(reason);
 }
 
 eFullscreenRequestResult CSpace::setFullscreen(SP<ITarget> t, eFullscreenMode currentEffectiveMode, eFullscreenMode mode) {
@@ -173,7 +173,7 @@ eFullscreenRequestResult CSpace::setFullscreen(SP<ITarget> t, eFullscreenMode cu
     if (mode == FSMODE_NONE && m_algorithm && t->floating())
         m_algorithm->recenter(t);
 
-    recalculate();
+    recalculate(RECALCULATE_REASON_TOGGLE_FULLSCREEN);
 
     return REQUEST_RESULT;
 }
@@ -218,6 +218,21 @@ SP<ITarget> CSpace::getNextCandidate(SP<ITarget> old) {
     return !m_algorithm ? nullptr : m_algorithm->getNextCandidate(old);
 }
 
+bool Layout::isHardRecalculateReason(eRecalculateReason reason) {
+    return reason != RECALCULATE_REASON_WORKSPACE_CHANGE && reason != RECALCULATE_REASON_SPECIAL_WORKSPACE_TOGGLE && reason != RECALCULATE_REASON_TOGGLE_FULLSCREEN &&
+        reason != RECALCULATE_REASON_INVALIDATE_MONITOR_GEOMETRIES && reason != RECALCULATE_REASON_RENDER_MOINTOR;
+}
+
 const std::vector<WP<ITarget>>& CSpace::targets() const {
     return m_targets;
 }
+
+eRecalculateReason Layout::recalcMonitorReasonToRecalcReason(CLayoutManager::eRecalculateMonitorReason reason) {
+    // If eRecalculateMonitorReason doesn't have a eRecalculateReason pair, it'll return nullopt
+    switch (reason) {
+        case CLayoutManager::RECALCULATE_MONITOR_REASON_TOGGLE_SPECIAL_WORKSPACE: return RECALCULATE_REASON_SPECIAL_WORKSPACE_TOGGLE;
+        case CLayoutManager::RECALCULATE_MONITOR_REASON_WORKSPACE_CHANGE: return RECALCULATE_REASON_WORKSPACE_CHANGE;
+        case CLayoutManager::RECALCULATE_MONITOR_REASON_TOGGLE_FULLSCREEN: return RECALCULATE_REASON_TOGGLE_FULLSCREEN;
+        default: return RECALCULATE_REASON_UNKNOWN;
+    }
+}
\ No newline at end of file