diff --git a/src/Hy3Layout.cpp b/src/Hy3Layout.cpp index 5088955..8da9759 100644 --- a/src/Hy3Layout.cpp +++ b/src/Hy3Layout.cpp @@ -1,16 +1,17 @@ -#include -#include #include #include +#include +#include + #include #include #include +#include "BitFlag.hpp" #include "Hy3Layout.hpp" #include "SelectionHook.hpp" -#include "globals.hpp" #include "conversions.hpp" -#include "BitFlag.hpp" +#include "globals.hpp" std::unique_ptr renderHookPtr = std::make_unique(Hy3Layout::renderHook); @@ -346,9 +347,7 @@ void Hy3Layout::onWindowRemovedTiling(CWindow* window) { } } -void Hy3Layout::onWindowRemovedFloating(CWindow *window) { - this->m_focusIntercepts.erase(window); -} +void Hy3Layout::onWindowRemovedFloating(CWindow* window) { this->m_focusIntercepts.erase(window); } void Hy3Layout::onWindowFocusChange(CWindow* window) { auto* node = this->getNodeFromWindow(window); @@ -380,7 +379,7 @@ void Hy3Layout::recalculateMonitor(const int& monitor_id) { // todo: refactor this auto* top_node = this->getWorkspaceRootGroup(monitor->activeWorkspace); - if(top_node == nullptr) { + if (top_node == nullptr) { top_node = this->getWorkspaceRootGroup(monitor->specialWorkspaceID); } @@ -409,57 +408,61 @@ ShiftDirection reverse(ShiftDirection direction) { } } -void executeResizeOperation(const Vector2D& delta, eRectCorner corner, Hy3Node *node, CMonitor* monitor) { +void executeResizeOperation( + const Vector2D& delta, + eRectCorner corner, + Hy3Node* node, + CMonitor* monitor +) { if (node == nullptr) return; if (monitor == nullptr) return; - const bool display_left = - STICKS(node->position.x, monitor->vecPosition.x + monitor->vecReservedTopLeft.x); - const bool display_right = STICKS( - node->position.x + node->size.x, - monitor->vecPosition.x + monitor->vecSize.x - monitor->vecReservedBottomRight.x - ); - const bool display_top = - STICKS(node->position.y, monitor->vecPosition.y + monitor->vecReservedTopLeft.y); - const bool display_bottom = STICKS( - node->position.y + node->size.y, - monitor->vecPosition.y + monitor->vecSize.y - monitor->vecReservedBottomRight.y - ); + const bool display_left = + STICKS(node->position.x, monitor->vecPosition.x + monitor->vecReservedTopLeft.x); + const bool display_right = STICKS( + node->position.x + node->size.x, + monitor->vecPosition.x + monitor->vecSize.x - monitor->vecReservedBottomRight.x + ); + const bool display_top = + STICKS(node->position.y, monitor->vecPosition.y + monitor->vecReservedTopLeft.y); + const bool display_bottom = STICKS( + node->position.y + node->size.y, + monitor->vecPosition.y + monitor->vecSize.y - monitor->vecReservedBottomRight.y + ); - Vector2D resize_delta = delta; - bool node_is_root = (node->data.type == Hy3NodeType::Group && node->parent == nullptr) - || (node->data.type == Hy3NodeType::Window - && (node->parent == nullptr || node->parent->parent == nullptr)); + Vector2D resize_delta = delta; + bool node_is_root = (node->data.type == Hy3NodeType::Group && node->parent == nullptr) + || (node->data.type == Hy3NodeType::Window + && (node->parent == nullptr || node->parent->parent == nullptr)); - if (node_is_root) { - if (display_left && display_right) resize_delta.x = 0; - if (display_top && display_bottom) resize_delta.y = 0; + if (node_is_root) { + if (display_left && display_right) resize_delta.x = 0; + if (display_top && display_bottom) resize_delta.y = 0; + } + + // Don't execute the logic unless there's something to do + if (resize_delta.x != 0 || resize_delta.y != 0) { + ShiftDirection target_edge_x; + ShiftDirection target_edge_y; + + // Determine the direction in which we're going to look for the neighbor node + // that will be resized + if (corner == CORNER_NONE) { // It's probably a keyboard event. + target_edge_x = display_right ? ShiftDirection::Left : ShiftDirection::Right; + target_edge_y = display_bottom ? ShiftDirection::Up : ShiftDirection::Down; + + // If the anchor is not at the top/left then reverse the delta + if (target_edge_x == ShiftDirection::Left) resize_delta.x = -resize_delta.x; + if (target_edge_y == ShiftDirection::Up) resize_delta.y = -resize_delta.y; + } else { // It's probably a mouse event + // Resize against the edges corresponding to the selected corner + target_edge_x = corner == CORNER_TOPLEFT || corner == CORNER_BOTTOMLEFT + ? ShiftDirection::Left + : ShiftDirection::Right; + target_edge_y = corner == CORNER_TOPLEFT || corner == CORNER_TOPRIGHT ? ShiftDirection::Up + : ShiftDirection::Down; } - // Don't execute the logic unless there's something to do - if (resize_delta.x != 0 || resize_delta.y != 0) { - ShiftDirection target_edge_x; - ShiftDirection target_edge_y; - - // Determine the direction in which we're going to look for the neighbor node - // that will be resized - if (corner == CORNER_NONE) { // It's probably a keyboard event. - target_edge_x = display_right ? ShiftDirection::Left : ShiftDirection::Right; - target_edge_y = display_bottom ? ShiftDirection::Up : ShiftDirection::Down; - - // If the anchor is not at the top/left then reverse the delta - if (target_edge_x == ShiftDirection::Left) resize_delta.x = -resize_delta.x; - if (target_edge_y == ShiftDirection::Up) resize_delta.y = -resize_delta.y; - } else { // It's probably a mouse event - // Resize against the edges corresponding to the selected corner - target_edge_x = corner == CORNER_TOPLEFT || corner == CORNER_BOTTOMLEFT - ? ShiftDirection::Left - : ShiftDirection::Right; - target_edge_y = corner == CORNER_TOPLEFT || corner == CORNER_TOPRIGHT - ? ShiftDirection::Up - : ShiftDirection::Down; - } - // Find the neighboring node in each axis, which will be either above or at the // same level as the initiating node in the layout hierarchy. These are the nodes // which must get resized (rather than the initiator) because they are the @@ -467,13 +470,13 @@ void executeResizeOperation(const Vector2D& delta, eRectCorner corner, Hy3Node * auto horizontal_neighbor = node->findNeighbor(target_edge_x); auto vertical_neighbor = node->findNeighbor(target_edge_y); - static const auto animate = ConfigValue("misc:animate_manual_resizes"); + static const auto animate = ConfigValue("misc:animate_manual_resizes"); - // Note that the resize direction is reversed, because from the neighbor's perspective - // the edge to be moved is the opposite way round. However, the delta is still the same. - if (horizontal_neighbor) { - horizontal_neighbor->resize(reverse(target_edge_x), resize_delta.x, *animate == 0); - } + // Note that the resize direction is reversed, because from the neighbor's perspective + // the edge to be moved is the opposite way round. However, the delta is still the same. + if (horizontal_neighbor) { + horizontal_neighbor->resize(reverse(target_edge_x), resize_delta.x, *animate == 0); + } if (vertical_neighbor) { vertical_neighbor->resize(reverse(target_edge_y), resize_delta.y, *animate == 0); @@ -484,17 +487,19 @@ void executeResizeOperation(const Vector2D& delta, eRectCorner corner, Hy3Node * void Hy3Layout::resizeNode(const Vector2D& delta, eRectCorner corner, Hy3Node* node) { // Is the intended target really a node or a floating window? auto window = g_pCompositor->m_pLastWindow; - if(window && window->m_bIsFloating) { + if (window && window->m_bIsFloating) { this->resizeActiveWindow(delta, corner, window); } else if (node) { - auto monitor = g_pCompositor->getMonitorFromID(g_pCompositor->getWorkspaceByID(node->workspace_id)->m_iMonitorID); + auto monitor = g_pCompositor->getMonitorFromID( + g_pCompositor->getWorkspaceByID(node->workspace_id)->m_iMonitorID + ); executeResizeOperation(delta, corner, node, monitor); } } void Hy3Layout::resizeActiveWindow(const Vector2D& delta, eRectCorner corner, CWindow* pWindow) { auto window = pWindow ? pWindow : g_pCompositor->m_pLastWindow; - if(window == nullptr || ! g_pCompositor->windowValidMapped(window)) return; + if (window == nullptr || !g_pCompositor->windowValidMapped(window)) return; if (window->m_bIsFloating) { // Use the same logic as the `main` layout for floating windows @@ -504,8 +509,13 @@ void Hy3Layout::resizeActiveWindow(const Vector2D& delta, eRectCorner corner, CW ); window->m_vRealSize = required_size; g_pXWaylandManager->setWindowSize(window, required_size); - } else if (auto* node = this->getNodeFromWindow(window);node != nullptr) { - executeResizeOperation(delta, corner, &node->getExpandActor(), g_pCompositor->getMonitorFromID(window->m_iMonitorID)); + } else if (auto* node = this->getNodeFromWindow(window); node != nullptr) { + executeResizeOperation( + delta, + corner, + &node->getExpandActor(), + g_pCompositor->getMonitorFromID(window->m_iMonitorID) + ); } } @@ -896,50 +906,51 @@ void Hy3Layout::shiftNode(Hy3Node& node, ShiftDirection direction, bool once, bo void shiftFloatingWindow(CWindow* window, ShiftDirection direction) { static const auto kbd_shift_delta = ConfigValue("plugin:hy3:kbd_shift_delta"); - if(!window) return; + if (!window) return; Vector2D bounds {0, 0}; // BUG: Assumes horizontal monitor layout // BUG: Ignores monitor reserved space - for(auto m: g_pCompositor->m_vMonitors) { + for (auto m: g_pCompositor->m_vMonitors) { bounds.x = std::max(bounds.x, m->vecPosition.x + m->vecSize.x); - if(m->ID == window->m_iMonitorID) { + if (m->ID == window->m_iMonitorID) { bounds.y = m->vecPosition.y + m->vecSize.y; } } - const int delta = getSearchDirection(direction) == SearchDirection::Forwards - ? *kbd_shift_delta: -*kbd_shift_delta; + const int delta = getSearchDirection(direction) == SearchDirection::Forwards ? *kbd_shift_delta + : -*kbd_shift_delta; - Vector2D movement_delta = (getAxis(direction) == Axis::Horizontal) - ? Vector2D{ delta, 0 } : Vector2D{ 0, delta }; + Vector2D movement_delta = + (getAxis(direction) == Axis::Horizontal) ? Vector2D {delta, 0} : Vector2D {0, delta}; auto window_pos = window->m_vRealPosition.vec(); auto window_size = window->m_vRealSize.vec(); // Keep at least `delta` pixels visible - if (window_pos.x + window_size.x + delta < 0 || window_pos.x + delta > bounds.x) movement_delta.x = 0; - if (window_pos.y + window_size.y + delta < 0 || window_pos.y + delta > bounds.y) movement_delta.y = 0; - if(movement_delta.x != 0 || movement_delta.y != 0) { + if (window_pos.x + window_size.x + delta < 0 || window_pos.x + delta > bounds.x) + movement_delta.x = 0; + if (window_pos.y + window_size.y + delta < 0 || window_pos.y + delta > bounds.y) + movement_delta.y = 0; + if (movement_delta.x != 0 || movement_delta.y != 0) { auto new_pos = window_pos + movement_delta; // Do we need to change the workspace? const auto new_monitor = g_pCompositor->getMonitorFromVector(new_pos); - if(new_monitor && new_monitor->ID != window->m_iMonitorID) { + if (new_monitor && new_monitor->ID != window->m_iMonitorID) { // Ignore the movement request if the new workspace is special - if(! new_monitor->specialWorkspaceID) { + if (!new_monitor->specialWorkspaceID) { const auto old_workspace = g_pCompositor->getWorkspaceByID(window->m_iWorkspaceID); const auto new_workspace = g_pCompositor->getWorkspaceByID(new_monitor->activeWorkspace); const auto previous_monitor = g_pCompositor->getMonitorFromID(window->m_iMonitorID); const auto original_new_pos = new_pos; - if(new_workspace && previous_monitor) { - switch (direction) - { - case ShiftDirection::Left: new_pos.x += new_monitor->vecSize.x; break; - case ShiftDirection::Right: new_pos.x -= previous_monitor->vecSize.x; break; - case ShiftDirection::Up: new_pos.y += new_monitor->vecSize.y; break; - case ShiftDirection::Down: new_pos.y -= previous_monitor->vecSize.y; break; - default: UNREACHABLE(); + if (new_workspace && previous_monitor) { + switch (direction) { + case ShiftDirection::Left: new_pos.x += new_monitor->vecSize.x; break; + case ShiftDirection::Right: new_pos.x -= previous_monitor->vecSize.x; break; + case ShiftDirection::Up: new_pos.y += new_monitor->vecSize.y; break; + case ShiftDirection::Down: new_pos.y -= previous_monitor->vecSize.y; break; + default: UNREACHABLE(); } } @@ -947,7 +958,8 @@ void shiftFloatingWindow(CWindow* window, ShiftDirection direction) { g_pCompositor->moveWindowToWorkspaceSafe(window, new_workspace); g_pCompositor->setActiveMonitor(new_monitor); - const static auto allow_workspace_cycles = ConfigValue("binds:allow_workspace_cycles"); + const static auto allow_workspace_cycles = + ConfigValue("binds:allow_workspace_cycles"); if (*allow_workspace_cycles) new_workspace->rememberPrevWorkspace(old_workspace); } } else { @@ -968,16 +980,16 @@ void Hy3Layout::shiftWindow(int workspace_id, ShiftDirection direction, bool onc } void Hy3Layout::focusMonitor(CMonitor* monitor) { - if(monitor == nullptr) return; + if (monitor == nullptr) return; g_pCompositor->setActiveMonitor(monitor); const auto focusedNode = this->getWorkspaceFocusedNode(monitor->activeWorkspace); - if(focusedNode != nullptr) { + if (focusedNode != nullptr) { focusedNode->focus(); } else { auto* workspace = g_pCompositor->getWorkspaceByID(monitor->activeWorkspace); CWindow* next_window = nullptr; - if(workspace != nullptr) { + if (workspace != nullptr) { workspace->setActive(true); if (workspace->m_bHasFullscreenWindow) { next_window = g_pCompositor->getFullscreenWindowOnWorkspace(workspace->m_iID); @@ -987,8 +999,8 @@ void Hy3Layout::focusMonitor(CMonitor* monitor) { } else { for (auto& w: g_pCompositor->m_vWindows | std::views::reverse) { if (w->m_bIsMapped && !w->isHidden() && w->m_bIsFloating && w->m_iX11Type != 2 - && w->m_iWorkspaceID == next_window->m_iWorkspaceID && !w->m_bX11ShouldntFocus - && !w->m_sAdditionalConfigData.noFocus) + && w->m_iWorkspaceID == next_window->m_iWorkspaceID && !w->m_bX11ShouldntFocus + && !w->m_sAdditionalConfigData.noFocus) { next_window = w.get(); break; @@ -999,13 +1011,13 @@ void Hy3Layout::focusMonitor(CMonitor* monitor) { } } -CWindow *getFocusedWindow(const Hy3Node *node) { +CWindow* getFocusedWindow(const Hy3Node* node) { auto search = node; - while(search != nullptr && search->data.type == Hy3NodeType::Group) { + while (search != nullptr && search->data.type == Hy3NodeType::Group) { search = search->data.as_group.focused_child; } - if(search == nullptr || search->data.type != Hy3NodeType::Window) { + if (search == nullptr || search->data.type != Hy3NodeType::Window) { return nullptr; } @@ -1025,32 +1037,31 @@ bool shiftMatchesLayout(Hy3GroupLayout layout, ShiftDirection direction) { || (layout != Hy3GroupLayout::SplitV && !shiftIsVertical(direction)); } - -bool covers(const CBox &outer, const CBox &inner) { - return outer.x <= inner.x - && outer.y <= inner.y - && outer.x + outer.w >= inner.x + inner.w - && outer.y + outer.h >= inner.y + inner.h; +bool covers(const CBox& outer, const CBox& inner) { + return outer.x <= inner.x && outer.y <= inner.y && outer.x + outer.w >= inner.x + inner.w + && outer.y + outer.h >= inner.y + inner.h; } -bool isObscured (CWindow* window) { - if(!window) return false; +bool isObscured(CWindow* window) { + if (!window) return false; const auto inner_box = window->getWindowMainSurfaceBox(); bool is_obscured = false; - for(auto& w :g_pCompositor->m_vWindows | std::views::reverse) { - if(w.get() == window) { - // Don't go any further if this is a floating window, because m_vWindows is sorted bottom->top per Compositor.cpp - if(window->m_bIsFloating) break; else continue; + for (auto& w: g_pCompositor->m_vWindows | std::views::reverse) { + if (w.get() == window) { + // Don't go any further if this is a floating window, because m_vWindows is sorted bottom->top + // per Compositor.cpp + if (window->m_bIsFloating) break; + else continue; } - if(!w->m_bIsFloating) continue; + if (!w->m_bIsFloating) continue; const auto outer_box = w->getWindowMainSurfaceBox(); is_obscured = covers(outer_box, inner_box); - if(is_obscured) break; + if (is_obscured) break; }; return is_obscured; @@ -1063,45 +1074,54 @@ bool isObscured(Hy3Node* node) { bool isNotObscured(CWindow* window) { return !isObscured(window); } bool isNotObscured(Hy3Node* node) { return !isObscured(node); } -CWindow* getWindowInDirection(CWindow* source, ShiftDirection direction, BitFlag layers_same_monitor, BitFlag layers_other_monitors) { - if(!source) return nullptr; - if(layers_other_monitors == Layer::None && layers_same_monitor == Layer::None) return nullptr; +CWindow* getWindowInDirection( + CWindow* source, + ShiftDirection direction, + BitFlag layers_same_monitor, + BitFlag layers_other_monitors +) { + if (!source) return nullptr; + if (layers_other_monitors == Layer::None && layers_same_monitor == Layer::None) return nullptr; - CWindow *target_window = nullptr; + CWindow* target_window = nullptr; const auto source_middle = source->middle(); std::optional target_distance; - const auto static focus_policy = ConfigValue("plugin:hy3:focus_obscured_windows_policy"); - bool permit_obscured_windows = *focus_policy == 0 || (*focus_policy == 2 && layers_same_monitor.HasNot(Layer::Floating | Layer::Tiled)); + const auto static focus_policy = + ConfigValue("plugin:hy3:focus_obscured_windows_policy"); + bool permit_obscured_windows = + *focus_policy == 0 + || (*focus_policy == 2 && layers_same_monitor.HasNot(Layer::Floating | Layer::Tiled)); const auto source_monitor = g_pCompositor->getMonitorFromID(source->m_iMonitorID); - const auto next_monitor = layers_other_monitors.HasAny(Layer::Floating | Layer::Tiled) - ? g_pCompositor->getMonitorInDirection(source_monitor, directionToChar(direction)) - : nullptr; + const auto next_monitor = + layers_other_monitors.HasAny(Layer::Floating | Layer::Tiled) + ? g_pCompositor->getMonitorInDirection(source_monitor, directionToChar(direction)) + : nullptr; - const auto next_workspace = next_monitor - ? next_monitor->specialWorkspaceID ? next_monitor->specialWorkspaceID - : next_monitor->activeWorkspace - : WORKSPACE_INVALID; + const auto next_workspace = next_monitor ? next_monitor->specialWorkspaceID + ? next_monitor->specialWorkspaceID + : next_monitor->activeWorkspace + : WORKSPACE_INVALID; auto isCandidate = [=, mon = source->m_iMonitorID](CWindow* w) { const auto window_layer = w->m_bIsFloating ? Layer::Floating : Layer::Tiled; const auto monitor_flags = w->m_iMonitorID == mon ? layers_same_monitor : layers_other_monitors; - return (monitor_flags.Has(window_layer)) - && w->m_bIsMapped - && w->m_iX11Type != 2 - && !w->m_sAdditionalConfigData.noFocus - && !w->isHidden() - && !w->m_bX11ShouldntFocus - && (w->m_bPinned || w->m_iWorkspaceID == source->m_iWorkspaceID || w->m_iWorkspaceID == next_workspace); + return (monitor_flags.Has(window_layer)) && w->m_bIsMapped && w->m_iX11Type != 2 + && !w->m_sAdditionalConfigData.noFocus && !w->isHidden() && !w->m_bX11ShouldntFocus + && (w->m_bPinned || w->m_iWorkspaceID == source->m_iWorkspaceID + || w->m_iWorkspaceID == next_workspace); }; - for(auto &pw: g_pCompositor->m_vWindows) { + for (auto& pw: g_pCompositor->m_vWindows) { auto w = pw.get(); - if(w != source && isCandidate(w)) { - auto dist = Distance { direction, source_middle, w->middle() }; - if((target_distance.has_value() ? dist < target_distance.value() : dist.isInDirection(direction)) && (permit_obscured_windows || isNotObscured(w)) ) { + if (w != source && isCandidate(w)) { + auto dist = Distance {direction, source_middle, w->middle()}; + if ((target_distance.has_value() ? dist < target_distance.value() + : dist.isInDirection(direction)) + && (permit_obscured_windows || isNotObscured(w))) + { target_window = w; target_distance = dist; } @@ -1111,19 +1131,32 @@ CWindow* getWindowInDirection(CWindow* source, ShiftDirection direction, BitFlag hy3_log(LOG, "getWindowInDirection: closest window to {} is {}", source, target_window); // If the closest window is on a different monitor and the nearest edge has the same position - // as the last focused window on that monitor's workspace then choose the last focused window instead; this - // allows seamless back-and-forth by direction keys - if(target_window && target_window->m_iMonitorID != source->m_iMonitorID) { + // as the last focused window on that monitor's workspace then choose the last focused window + // instead; this allows seamless back-and-forth by direction keys + if (target_window && target_window->m_iMonitorID != source->m_iMonitorID) { if (auto new_workspace = g_pCompositor->getWorkspaceByID(next_workspace)) { if (auto last_focused = new_workspace->getLastFocusedWindow()) { - auto target_bounds = CBox(target_window->m_vRealPosition.vec(), target_window->m_vRealSize.vec()); - auto last_focused_bounds = CBox(last_focused->m_vRealPosition.vec(), last_focused->m_vRealSize.vec()); + auto target_bounds = + CBox(target_window->m_vRealPosition.vec(), target_window->m_vRealSize.vec()); + auto last_focused_bounds = + CBox(last_focused->m_vRealPosition.vec(), last_focused->m_vRealSize.vec()); - if((direction == ShiftDirection::Left && STICKS(target_bounds.x + target_bounds.w, last_focused_bounds.x + last_focused_bounds.w)) - || (direction == ShiftDirection::Right && STICKS(target_bounds.x, last_focused_bounds.x)) - || (direction == ShiftDirection::Up && STICKS(target_bounds.y + target_bounds.h, last_focused_bounds.y + last_focused_bounds.h)) - || (direction == ShiftDirection::Down && STICKS(target_bounds.y, last_focused_bounds.y))) { - target_window = last_focused; + if ((direction == ShiftDirection::Left + && STICKS( + target_bounds.x + target_bounds.w, + last_focused_bounds.x + last_focused_bounds.w + )) + || (direction == ShiftDirection::Right && STICKS(target_bounds.x, last_focused_bounds.x) + ) + || (direction == ShiftDirection::Up + && STICKS( + target_bounds.y + target_bounds.h, + last_focused_bounds.y + last_focused_bounds.h + )) + || (direction == ShiftDirection::Down && STICKS(target_bounds.y, last_focused_bounds.y) + )) + { + target_window = last_focused; } } } @@ -1134,15 +1167,20 @@ CWindow* getWindowInDirection(CWindow* source, ShiftDirection direction, BitFlag void Hy3Layout::shiftFocusToMonitor(ShiftDirection direction) { auto target_monitor = g_pCompositor->getMonitorInDirection(directionToChar(direction)); - if(target_monitor) this->focusMonitor(target_monitor); + if (target_monitor) this->focusMonitor(target_monitor); } -void Hy3Layout::shiftFocus(int workspace, ShiftDirection direction, bool visible, BitFlag eligible_layers) { - Hy3Node *candidate_node = nullptr; - CWindow *closest_window = nullptr; - Hy3Node *source_node = nullptr; - CWindow *source_window = g_pCompositor->m_pLastWindow; - CWorkspace *source_workspace = g_pCompositor->getWorkspaceByID(workspace); +void Hy3Layout::shiftFocus( + int workspace, + ShiftDirection direction, + bool visible, + BitFlag eligible_layers +) { + Hy3Node* candidate_node = nullptr; + CWindow* closest_window = nullptr; + Hy3Node* source_node = nullptr; + CWindow* source_window = g_pCompositor->m_pLastWindow; + CWorkspace* source_workspace = g_pCompositor->getWorkspaceByID(workspace); if (source_workspace) { source_window = source_workspace->m_pLastFocusedWindow; @@ -1155,56 +1193,66 @@ void Hy3Layout::shiftFocus(int workspace, ShiftDirection direction, bool visible return; } - hy3_log(LOG, - "shiftFocus: Source: {} ({}), workspace: {}, direction: {}, visible: {}", - source_window, - source_window->m_bIsFloating ? "floating" : "tiled", - workspace, - (int)direction, - visible + hy3_log( + LOG, + "shiftFocus: Source: {} ({}), workspace: {}, direction: {}, visible: {}", + source_window, + source_window->m_bIsFloating ? "floating" : "tiled", + workspace, + (int) direction, + visible ); // If no eligible_layers specified then choose the same layer as the source window - if(eligible_layers == Layer::None) eligible_layers = source_window->m_bIsFloating ? Layer::Floating : Layer::Tiled; + if (eligible_layers == Layer::None) + eligible_layers = source_window->m_bIsFloating ? Layer::Floating : Layer::Tiled; - const auto static focus_policy = ConfigValue("plugin:hy3:focus_obscured_windows_policy"); - bool skip_obscured = *focus_policy == 1 || (*focus_policy == 2 && eligible_layers.Has(Layer::Floating | Layer::Tiled)); + const auto static focus_policy = + ConfigValue("plugin:hy3:focus_obscured_windows_policy"); + bool skip_obscured = *focus_policy == 1 + || (*focus_policy == 2 && eligible_layers.Has(Layer::Floating | Layer::Tiled)); // Determine the starting point for looking for a tiled node - it's either the // workspace's focused node or the floating window's focus entry point (which may be null) if (eligible_layers.Has(Layer::Tiled)) { source_node = source_window->m_bIsFloating ? getFocusOverride(source_window, direction) - : getWorkspaceFocusedNode(workspace); + : getWorkspaceFocusedNode(workspace); - if(source_node) { + if (source_node) { candidate_node = this->shiftOrGetFocus(*source_node, direction, false, false, visible); - while(candidate_node && skip_obscured && isObscured(candidate_node)) { + while (candidate_node && skip_obscured && isObscured(candidate_node)) { candidate_node = this->shiftOrGetFocus(*candidate_node, direction, false, false, visible); } } } BitFlag this_monitor = eligible_layers & Layer::Floating; - if(source_window->m_bIsFloating && !candidate_node) this_monitor |= (eligible_layers & Layer::Tiled); + if (source_window->m_bIsFloating && !candidate_node) + this_monitor |= (eligible_layers & Layer::Tiled); BitFlag other_monitors; - if(!candidate_node) other_monitors |= eligible_layers; + if (!candidate_node) other_monitors |= eligible_layers; // Find the closest window in the right direction. Consider other monitors // if we don't have a tiled candidate closest_window = getWindowInDirection(source_window, direction, this_monitor, other_monitors); - // If there's a window in the right direction then choose between that window and the tiled candidate. + // If there's a window in the right direction then choose between that window and the tiled + // candidate. bool focus_closest_window = false; - if(closest_window) { - if(candidate_node) { - // If the closest window is tiled then focus the tiled node which was obtained from `shiftOrGetFocus`, - // otherwise focus whichever is closer - if(closest_window->m_bIsFloating) { - Distance distanceToClosestWindow(direction, source_window->middle(), closest_window->middle()); + if (closest_window) { + if (candidate_node) { + // If the closest window is tiled then focus the tiled node which was obtained from + // `shiftOrGetFocus`, otherwise focus whichever is closer + if (closest_window->m_bIsFloating) { + Distance distanceToClosestWindow( + direction, + source_window->middle(), + closest_window->middle() + ); Distance distanceToTiledNode(direction, source_window->middle(), candidate_node->middle()); - if(distanceToClosestWindow < distanceToTiledNode) { + if (distanceToClosestWindow < distanceToTiledNode) { focus_closest_window = true; } } @@ -1214,14 +1262,15 @@ void Hy3Layout::shiftFocus(int workspace, ShiftDirection direction, bool visible } std::optional new_monitor_id; - if(focus_closest_window) { + if (focus_closest_window) { new_monitor_id = closest_window->m_iMonitorID; setFocusOverride(closest_window, direction, source_node); g_pCompositor->focusWindow(closest_window); - } else if(candidate_node) { - if(candidate_node->data.type == Hy3NodeType::Window) { + } else if (candidate_node) { + if (candidate_node->data.type == Hy3NodeType::Window) { new_monitor_id = candidate_node->data.as_window->m_iMonitorID; - } else if(auto *workspace = g_pCompositor->getWorkspaceByID(candidate_node->getRoot()->workspace_id)) { + } else if (auto* workspace = g_pCompositor->getWorkspaceByID(candidate_node->getRoot()->workspace_id)) + { new_monitor_id = workspace->m_iMonitorID; } candidate_node->focusWindow(); @@ -1230,23 +1279,27 @@ void Hy3Layout::shiftFocus(int workspace, ShiftDirection direction, bool visible shiftFocusToMonitor(direction); } - if(new_monitor_id && new_monitor_id.value() != source_window->m_iMonitorID) { - if(auto *monitor = g_pCompositor->getMonitorFromID(new_monitor_id.value())) { + if (new_monitor_id && new_monitor_id.value() != source_window->m_iMonitorID) { + if (auto* monitor = g_pCompositor->getMonitorFromID(new_monitor_id.value())) { g_pCompositor->setActiveMonitor(monitor); } } } Hy3Node* Hy3Layout::getFocusOverride(CWindow* src, ShiftDirection direction) { - if(auto intercept = this->m_focusIntercepts.find(src); intercept != this->m_focusIntercepts.end()) { + if (auto intercept = this->m_focusIntercepts.find(src); + intercept != this->m_focusIntercepts.end()) + { Hy3Node** accessor = intercept->second.forDirection(direction); - if(auto override = *accessor) { + if (auto override = *accessor) { // If the root isn't valid or is on a different workspsace then update the intercept data - if(override->workspace_id != src->m_iWorkspaceID || !std::ranges::contains(this->nodes, *override)) { + if (override->workspace_id != src->m_iWorkspaceID + || !std::ranges::contains(this->nodes, *override)) + { *accessor = nullptr; // If there are no remaining overrides then discard the intercept - if(intercept->second.isEmpty()) { + if (intercept->second.isEmpty()) { this->m_focusIntercepts.erase(intercept); } } @@ -1259,16 +1312,17 @@ Hy3Node* Hy3Layout::getFocusOverride(CWindow* src, ShiftDirection direction) { } void Hy3Layout::setFocusOverride(CWindow* src, ShiftDirection direction, Hy3Node* dest) { - if(auto intercept = this->m_focusIntercepts.find(src);intercept != this->m_focusIntercepts.end()) { + if (auto intercept = this->m_focusIntercepts.find(src); + intercept != this->m_focusIntercepts.end()) + { *intercept->second.forDirection(direction) = dest; } else { FocusOverride override; *override.forDirection(direction) = dest; - this->m_focusIntercepts.insert({ src, override }); + this->m_focusIntercepts.insert({src, override}); } } - void changeNodeWorkspaceRecursive(Hy3Node& node, CWorkspace* workspace) { node.workspace_id = workspace->m_iID; @@ -2006,7 +2060,7 @@ Hy3Node* Hy3Layout::shiftOrGetFocus( } insert = parent_group.children.begin(); } else if (break_origin == parent_group.children.back() && shiftIsForward(direction)) { - if (!shift) { + if (!shift) { return nullptr; } insert = parent_group.children.end(); @@ -2030,7 +2084,7 @@ Hy3Node* Hy3Layout::shiftOrGetFocus( if (shiftIsForward(direction)) insert = iter; else insert = std::next(iter); } - } else { + } else { return (*iter)->getFocusedNode(); } } else { diff --git a/src/Hy3Layout.hpp b/src/Hy3Layout.hpp index 9eeb7a5..7ba19c3 100644 --- a/src/Hy3Layout.hpp +++ b/src/Hy3Layout.hpp @@ -1,9 +1,10 @@ #pragma once #include +#include #include #include -#include + #include "BitFlag.hpp" class Hy3Layout; @@ -21,27 +22,15 @@ enum class ShiftDirection { Right, }; -enum class SearchDirection { - None, - Forwards, - Backwards -}; +enum class SearchDirection { None, Forwards, Backwards }; enum class Axis { None, Horizontal, Vertical }; -enum class Layer { - None = 0, - Tiled = 1 << 0, - Floating = 1 << 1 -}; +enum class Layer { None = 0, Tiled = 1 << 0, Floating = 1 << 1 }; -inline Layer operator| (Layer a, Layer b) { - return static_cast((int)a | (int)b); -} +inline Layer operator|(Layer a, Layer b) { return static_cast((int) a | (int) b); } -inline Layer operator& (Layer a, Layer b) { - return static_cast((int)a & (int)b); -} +inline Layer operator&(Layer a, Layer b) { return static_cast((int) a & (int) b); } #include "Hy3Node.hpp" #include "TabGroup.hpp" @@ -90,27 +79,24 @@ enum class ExpandFullscreenOption { }; struct FocusOverride { - Hy3Node *left = nullptr; - Hy3Node *up = nullptr; - Hy3Node *right = nullptr; - Hy3Node *down = nullptr; + Hy3Node* left = nullptr; + Hy3Node* up = nullptr; + Hy3Node* right = nullptr; + Hy3Node* down = nullptr; - Hy3Node **forDirection(ShiftDirection direction) { - switch(direction) { - case ShiftDirection::Left: return &left; - case ShiftDirection::Up: return &up; - case ShiftDirection::Right: return &right; - case ShiftDirection::Down: return &down; - default: UNREACHABLE(); + Hy3Node** forDirection(ShiftDirection direction) { + switch (direction) { + case ShiftDirection::Left: return &left; + case ShiftDirection::Up: return &up; + case ShiftDirection::Right: return &right; + case ShiftDirection::Down: return &down; + default: UNREACHABLE(); } } - bool isEmpty() { - return !(left || right || up || down); - } + bool isEmpty() { return !(left || right || up || down); } }; - class Hy3Layout: public IHyprLayout { public: virtual void onWindowCreated(CWindow*, eDirection = DIRECTION_DEFAULT); @@ -121,7 +107,8 @@ public: virtual bool isWindowTiled(CWindow*); virtual void recalculateMonitor(const int& monitor_id); virtual void recalculateWindow(CWindow*); - virtual void resizeActiveWindow(const Vector2D& delta, eRectCorner corner, CWindow* pWindow = nullptr); + virtual void + resizeActiveWindow(const Vector2D& delta, eRectCorner corner, CWindow* pWindow = nullptr); virtual void fullscreenRequestForWindow(CWindow*, eFullscreenMode, bool enable_fullscreen); virtual std::any layoutMessage(SLayoutMessageHeader header, std::string content); virtual SWindowRenderLayoutHints requestRenderHints(CWindow*); diff --git a/src/Hy3Node.cpp b/src/Hy3Node.cpp index f6c93cc..d61fa72 100644 --- a/src/Hy3Node.cpp +++ b/src/Hy3Node.cpp @@ -862,9 +862,7 @@ int directionToIteratorIncrement(ShiftDirection direction) { } } -Vector2D Hy3Node::middle() { - return this->position + this->size / 2.f; -} +Vector2D Hy3Node::middle() { return this->position + this->size / 2.f; } void Hy3Node::resize(ShiftDirection direction, double delta, bool no_animation) { auto& parent_node = this->parent; @@ -899,7 +897,12 @@ void Hy3Node::resize(ShiftDirection direction, double delta, bool no_animation) parent_node->recalcSizePosRecursive(no_animation); } else { - hy3_log(WARN, "Requested size ratio {} or {} out of bounds, ignoring", requested_size_ratio, requested_neighbor_size_ratio); + hy3_log( + WARN, + "Requested size ratio {} or {} out of bounds, ignoring", + requested_size_ratio, + requested_neighbor_size_ratio + ); } } } @@ -925,17 +928,17 @@ void Hy3Node::swapData(Hy3Node& a, Hy3Node& b) { } bool Hy3Node::hasChild(Hy3Node* node) { - if(this->data.type == Hy3NodeType::Window) return false; + if (this->data.type == Hy3NodeType::Window) return false; auto n = node; - while(n != nullptr && n->parent != this) n = n->parent; + while (n != nullptr && n->parent != this) n = n->parent; return n != nullptr; } Hy3Node* Hy3Node::getRoot() { Hy3Node* maybeRoot = this; - while(maybeRoot->parent) maybeRoot = maybeRoot->parent; + while (maybeRoot->parent) maybeRoot = maybeRoot->parent; return maybeRoot; } \ No newline at end of file diff --git a/src/Hy3Node.hpp b/src/Hy3Node.hpp index 42f3c9c..651c763 100644 --- a/src/Hy3Node.hpp +++ b/src/Hy3Node.hpp @@ -147,14 +147,18 @@ struct Distance { secondary_axis = getAxis(direction) == Axis::Horizontal ? dist.y : dist.x; } - bool operator< (Distance other) { + bool operator<(Distance other) { return signbit(primary_axis) == signbit(other.primary_axis) - && (abs(primary_axis) < abs(other.primary_axis) || (primary_axis == other.primary_axis && abs(secondary_axis) < abs(other.secondary_axis))); + && (abs(primary_axis) < abs(other.primary_axis) + || (primary_axis == other.primary_axis + && abs(secondary_axis) < abs(other.secondary_axis))); } - bool operator> (Distance other) { + bool operator>(Distance other) { return signbit(primary_axis) == signbit(other.primary_axis) - && (abs(primary_axis) > abs(other.primary_axis) || (primary_axis == other.primary_axis && abs(secondary_axis) > abs(other.secondary_axis))); + && (abs(primary_axis) > abs(other.primary_axis) + || (primary_axis == other.primary_axis + && abs(secondary_axis) > abs(other.secondary_axis))); } bool isSameDirection(Distance other) { @@ -162,6 +166,7 @@ struct Distance { } bool isInDirection(ShiftDirection direction) { - return std::signbit(primary_axis) == (getSearchDirection(direction) == SearchDirection::Forwards); + return std::signbit(primary_axis) + == (getSearchDirection(direction) == SearchDirection::Forwards); } }; \ No newline at end of file diff --git a/src/conversions.cpp b/src/conversions.cpp index 07bdccc..46785b3 100644 --- a/src/conversions.cpp +++ b/src/conversions.cpp @@ -1,47 +1,35 @@ #include "Hy3Node.hpp" Axis getAxis(Hy3GroupLayout layout) { - switch (layout) - { - case Hy3GroupLayout::SplitH: - return Axis::Horizontal; - case Hy3GroupLayout::SplitV: - return Axis::Vertical; - default: - return Axis::None; + switch (layout) { + case Hy3GroupLayout::SplitH: return Axis::Horizontal; + case Hy3GroupLayout::SplitV: return Axis::Vertical; + default: return Axis::None; } } Axis getAxis(ShiftDirection direction) { - switch (direction) - { + switch (direction) { case ShiftDirection::Left: - case ShiftDirection::Right: - return Axis::Horizontal; + case ShiftDirection::Right: return Axis::Horizontal; case ShiftDirection::Down: - case ShiftDirection::Up: - return Axis::Vertical; - default: - return Axis::None; + case ShiftDirection::Up: return Axis::Vertical; + default: return Axis::None; } } SearchDirection getSearchDirection(ShiftDirection direction) { - switch(direction) { - case ShiftDirection::Left: - case ShiftDirection::Up: - return SearchDirection::Backwards; - case ShiftDirection::Right: - case ShiftDirection::Down: - return SearchDirection::Forwards; - default: - return SearchDirection::None; + switch (direction) { + case ShiftDirection::Left: + case ShiftDirection::Up: return SearchDirection::Backwards; + case ShiftDirection::Right: + case ShiftDirection::Down: return SearchDirection::Forwards; + default: return SearchDirection::None; } } char directionToChar(ShiftDirection direction) { - switch (direction) - { + switch (direction) { case ShiftDirection::Left: return 'l'; case ShiftDirection::Up: return 'u'; case ShiftDirection::Down: return 'd'; diff --git a/src/dispatchers.cpp b/src/dispatchers.cpp index 74787f8..fc8e73b 100644 --- a/src/dispatchers.cpp +++ b/src/dispatchers.cpp @@ -8,7 +8,7 @@ int workspace_for_action(bool allow_fullscreen = false) { if (g_pLayoutManager->getCurrentLayout() != g_Hy3Layout.get()) return -1; - if(!g_pCompositor->m_pLastMonitor) return -1; + if (!g_pCompositor->m_pLastMonitor) return -1; int workspace_id = g_pCompositor->m_pLastMonitor->activeWorkspace; @@ -128,14 +128,15 @@ void dispatch_movefocus(std::string value) { bool visible; BitFlag layers; - for(auto arg: args) { - if(arg == "visible") visible = true; + for (auto arg: args) { + if (arg == "visible") visible = true; else if ((layerArg = parseLayerArg(arg))) layers |= layerArg.value(); } - if(!layerArg) { - const static auto default_movefocus_layer = ConfigValue("plugin:hy3:default_movefocus_layer"); - if((layerArg = parseLayerArg(*default_movefocus_layer))) layers |= layerArg.value(); + if (!layerArg) { + const static auto default_movefocus_layer = + ConfigValue("plugin:hy3:default_movefocus_layer"); + if ((layerArg = parseLayerArg(*default_movefocus_layer))) layers |= layerArg.value(); } g_Hy3Layout->shiftFocus(workspace, shift.value(), visible, layers); @@ -275,7 +276,7 @@ void dispatch_resizenode(std::string value) { auto* node = g_Hy3Layout->getWorkspaceFocusedNode(workspace, false, true); const auto delta = g_pCompositor->parseWindowVectorArgsRelative(value, Vector2D(0, 0)); - hy3_log(LOG, "resizeNode: node: {:x}, delta: {:X}", (uintptr_t)node, delta); + hy3_log(LOG, "resizeNode: node: {:x}, delta: {:X}", (uintptr_t) node, delta); g_Hy3Layout->resizeNode(delta, CORNER_NONE, node); }