mirror of
https://github.com/Trensa-Organization/hy3.git
synced 2025-03-15 18:53:40 +01:00
Run clang-format
This commit is contained in:
outfoxxed
parent
f306ecc689
commit
a726135c86
6 changed files with 302 additions and 264 deletions
|
|
@ -1,16 +1,17 @@
|
|||
#include <regex>
|
||||
#include <set>
|
||||
#include <functional>
|
||||
#include <numeric>
|
||||
#include <regex>
|
||||
#include <set>
|
||||
|
||||
#include <hyprland/src/Compositor.hpp>
|
||||
#include <hyprland/src/plugins/PluginAPI.hpp>
|
||||
#include <ranges>
|
||||
|
||||
#include "BitFlag.hpp"
|
||||
#include "Hy3Layout.hpp"
|
||||
#include "SelectionHook.hpp"
|
||||
#include "globals.hpp"
|
||||
#include "conversions.hpp"
|
||||
#include "BitFlag.hpp"
|
||||
#include "globals.hpp"
|
||||
|
||||
std::unique_ptr<HOOK_CALLBACK_FN> renderHookPtr =
|
||||
std::make_unique<HOOK_CALLBACK_FN>(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,7 +408,12 @@ 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;
|
||||
|
||||
|
|
@ -455,8 +459,7 @@ void executeResizeOperation(const Vector2D& delta, eRectCorner corner, Hy3Node *
|
|||
target_edge_x = corner == CORNER_TOPLEFT || corner == CORNER_BOTTOMLEFT
|
||||
? ShiftDirection::Left
|
||||
: ShiftDirection::Right;
|
||||
target_edge_y = corner == CORNER_TOPLEFT || corner == CORNER_TOPRIGHT
|
||||
? ShiftDirection::Up
|
||||
target_edge_y = corner == CORNER_TOPLEFT || corner == CORNER_TOPRIGHT ? ShiftDirection::Up
|
||||
: ShiftDirection::Down;
|
||||
}
|
||||
|
||||
|
|
@ -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,45 +906,46 @@ void Hy3Layout::shiftNode(Hy3Node& node, ShiftDirection direction, bool once, bo
|
|||
void shiftFloatingWindow(CWindow* window, ShiftDirection direction) {
|
||||
static const auto kbd_shift_delta = ConfigValue<Hyprlang::INT>("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)
|
||||
{
|
||||
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;
|
||||
|
|
@ -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<Hyprlang::INT>("binds:allow_workspace_cycles");
|
||||
const static auto allow_workspace_cycles =
|
||||
ConfigValue<Hyprlang::INT>("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);
|
||||
|
|
@ -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
|
||||
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,24 +1074,33 @@ 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<Layer> layers_same_monitor, BitFlag<Layer> 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<Layer> layers_same_monitor,
|
||||
BitFlag<Layer> 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<Distance> target_distance;
|
||||
|
||||
const auto static focus_policy = ConfigValue<Hyprlang::INT>("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<Hyprlang::INT>("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)
|
||||
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
|
||||
const auto next_workspace = next_monitor ? next_monitor->specialWorkspaceID
|
||||
? next_monitor->specialWorkspaceID
|
||||
: next_monitor->activeWorkspace
|
||||
: WORKSPACE_INVALID;
|
||||
|
||||
|
|
@ -1088,20 +1108,20 @@ CWindow* getWindowInDirection(CWindow* source, ShiftDirection direction, BitFlag
|
|||
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,18 +1131,31 @@ 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))) {
|
||||
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<Layer> 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<Layer> 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,20 +1193,24 @@ void Hy3Layout::shiftFocus(int workspace, ShiftDirection direction, bool visible
|
|||
return;
|
||||
}
|
||||
|
||||
hy3_log(LOG,
|
||||
hy3_log(
|
||||
LOG,
|
||||
"shiftFocus: Source: {} ({}), workspace: {}, direction: {}, visible: {}",
|
||||
source_window,
|
||||
source_window->m_bIsFloating ? "floating" : "tiled",
|
||||
workspace,
|
||||
(int)direction,
|
||||
(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<Hyprlang::INT>("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<Hyprlang::INT>("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)
|
||||
|
|
@ -1176,35 +1218,41 @@ void Hy3Layout::shiftFocus(int workspace, ShiftDirection direction, bool visible
|
|||
source_node = source_window->m_bIsFloating ? getFocusOverride(source_window, direction)
|
||||
: 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<Layer> 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<Layer> 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<uint64_t> 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;
|
||||
|
||||
|
|
|
|||
|
|
@ -1,9 +1,10 @@
|
|||
#pragma once
|
||||
#include <list>
|
||||
#include <map>
|
||||
#include <set>
|
||||
|
||||
#include <hyprland/src/layout/IHyprLayout.hpp>
|
||||
#include <map>
|
||||
|
||||
#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<Layer>((int)a | (int)b);
|
||||
}
|
||||
inline Layer operator|(Layer a, Layer b) { return static_cast<Layer>((int) a | (int) b); }
|
||||
|
||||
inline Layer operator& (Layer a, Layer b) {
|
||||
return static_cast<Layer>((int)a & (int)b);
|
||||
}
|
||||
inline Layer operator&(Layer a, Layer b) { return static_cast<Layer>((int) a & (int) b); }
|
||||
|
||||
#include "Hy3Node.hpp"
|
||||
#include "TabGroup.hpp"
|
||||
|
|
@ -90,13 +79,13 @@ 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) {
|
||||
Hy3Node** forDirection(ShiftDirection direction) {
|
||||
switch (direction) {
|
||||
case ShiftDirection::Left: return &left;
|
||||
case ShiftDirection::Up: return &up;
|
||||
case ShiftDirection::Right: return &right;
|
||||
|
|
@ -105,12 +94,9 @@ struct FocusOverride {
|
|||
}
|
||||
}
|
||||
|
||||
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*);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
};
|
||||
|
|
@ -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) {
|
||||
switch (direction) {
|
||||
case ShiftDirection::Left:
|
||||
case ShiftDirection::Up:
|
||||
return SearchDirection::Backwards;
|
||||
case ShiftDirection::Up: return SearchDirection::Backwards;
|
||||
case ShiftDirection::Right:
|
||||
case ShiftDirection::Down:
|
||||
return SearchDirection::Forwards;
|
||||
default:
|
||||
return SearchDirection::None;
|
||||
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';
|
||||
|
|
|
|||
|
|
@ -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<Layer> 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<Hyprlang::STRING>("plugin:hy3:default_movefocus_layer");
|
||||
if((layerArg = parseLayerArg(*default_movefocus_layer))) layers |= layerArg.value();
|
||||
if (!layerArg) {
|
||||
const static auto default_movefocus_layer =
|
||||
ConfigValue<Hyprlang::STRING>("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);
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue