Trensa-Organization/hy3
1
0
Fork 0
mirror of https://github.com/Trensa-Organization/hy3.git synced 2025-03-15 18:53:40 +01:00
Code Issues Projects Releases Packages Wiki Activity

Give Hy3NodeType its own enum class

Browse source 
Was previously an anonymous enum
This commit is contained in:
outfoxxed 2023-06-28 18:11:48 -07:00
parent b3be42109f
commit ae2409d037
No known key found for this signature in database
GPG key ID: 4C88A185FB89301E
3 changed files with 70 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

124
src/Hy3Layout.cpp
View file

@ -37,9 +37,9 @@ Hy3GroupData::~Hy3GroupData() {
Hy3NodeData::Hy3NodeData(): Hy3NodeData((CWindow*) nullptr) {} Hy3NodeData::Hy3NodeData(): Hy3NodeData((CWindow*) nullptr) {}
Hy3NodeData::Hy3NodeData(CWindow* window): type(Hy3NodeData::Window) { this->as_window = window; } Hy3NodeData::Hy3NodeData(CWindow* window): type(Hy3NodeType::Window) { this->as_window = window; }
Hy3NodeData::Hy3NodeData(Hy3GroupData group): type(Hy3NodeData::Group) { Hy3NodeData::Hy3NodeData(Hy3GroupData group): type(Hy3NodeType::Group) {
new (&this->as_group) Hy3GroupData(std::move(group)); new (&this->as_group) Hy3GroupData(std::move(group));
} }
@ -47,12 +47,12 @@ Hy3NodeData::Hy3NodeData(Hy3GroupLayout layout): Hy3NodeData(Hy3GroupData(layout
Hy3NodeData::~Hy3NodeData() { Hy3NodeData::~Hy3NodeData() {
switch (this->type) { switch (this->type) {
case Hy3NodeData::Window: break; case Hy3NodeType::Window: break;
case Hy3NodeData::Group: case Hy3NodeType::Group:
this->as_group.~Hy3GroupData(); this->as_group.~Hy3GroupData();
// who ever thought calling the dtor after a move was a good idea? // who ever thought calling the dtor after a move was a good idea?
this->type = Hy3NodeData::Window; this->type = Hy3NodeType::Window;
break; break;
} }
} }
@ -62,12 +62,12 @@ Hy3NodeData::Hy3NodeData(Hy3NodeData&& from): type(from.type) {
LOG, LOG,
"Move CTor type matches? %d is group? %d", "Move CTor type matches? %d is group? %d",
this->type == from.type, this->type == from.type,
this->type == Hy3NodeData::Group this->type == Hy3NodeType::Group
); );
switch (from.type) { switch (from.type) {
case Hy3NodeData::Window: this->as_window = from.as_window; break; case Hy3NodeType::Window: this->as_window = from.as_window; break;
case Hy3NodeData::Group: new (&this->as_group) Hy3GroupData(std::move(from.as_group)); break; case Hy3NodeType::Group: new (&this->as_group) Hy3GroupData(std::move(from.as_group)); break;
} }
} }
@ -76,18 +76,18 @@ Hy3NodeData& Hy3NodeData::operator=(Hy3NodeData&& from) {
LOG, LOG,
"operator= type matches? %d is group? %d", "operator= type matches? %d is group? %d",
this->type == from.type, this->type == from.type,
this->type == Hy3NodeData::Group this->type == Hy3NodeType::Group
); );
if (this->type == Hy3NodeData::Group) { if (this->type == Hy3NodeType::Group) {
this->as_group.~Hy3GroupData(); this->as_group.~Hy3GroupData();
} }
this->type = from.type; this->type = from.type;
switch (this->type) { switch (this->type) {
case Hy3NodeData::Window: this->as_window = from.as_window; break; case Hy3NodeType::Window: this->as_window = from.as_window; break;
case Hy3NodeData::Group: new (&this->as_group) Hy3GroupData(std::move(from.as_group)); break; case Hy3NodeType::Group: new (&this->as_group) Hy3GroupData(std::move(from.as_group)); break;
} }
return *this; return *this;
@ -136,7 +136,7 @@ void Hy3Node::recalcSizePosRecursive(bool no_animation) {
double tab_height_offset = *tab_bar_height + *tab_bar_padding; double tab_height_offset = *tab_bar_height + *tab_bar_padding;
if (this->data.type != Hy3NodeData::Group) { if (this->data.type != Hy3NodeType::Group) {
this->data.as_window->setHidden(this->hidden); this->data.as_window->setHidden(this->hidden);
this->layout->applyNodeDataToWindow(this, no_animation); this->layout->applyNodeDataToWindow(this, no_animation);
return; return;
@ -246,7 +246,7 @@ void Hy3Node::recalcSizePosRecursive(bool no_animation) {
void Hy3Node::setHidden(bool hidden) { void Hy3Node::setHidden(bool hidden) {
this->hidden = hidden; this->hidden = hidden;
if (this->data.type == Hy3NodeData::Group) { if (this->data.type == Hy3NodeType::Group) {
for (auto* child: this->data.as_group.children) { for (auto* child: this->data.as_group.children) {
child->setHidden(hidden); child->setHidden(hidden);
} }
@ -255,8 +255,8 @@ void Hy3Node::setHidden(bool hidden) {
bool Hy3Node::isUrgent() { bool Hy3Node::isUrgent() {
switch (this->data.type) { switch (this->data.type) {
case Hy3NodeData::Window: return this->data.as_window->m_bIsUrgent; case Hy3NodeType::Window: return this->data.as_window->m_bIsUrgent;
case Hy3NodeData::Group: case Hy3NodeType::Group:
for (auto* child: this->data.as_group.children) { for (auto* child: this->data.as_group.children) {
if (child->isUrgent()) return true; if (child->isUrgent()) return true;
} }
@ -280,8 +280,8 @@ bool Hy3Node::isIndirectlyFocused() {
std::string Hy3Node::getTitle() { std::string Hy3Node::getTitle() {
switch (this->data.type) { switch (this->data.type) {
case Hy3NodeData::Window: return this->data.as_window->m_szTitle; case Hy3NodeType::Window: return this->data.as_window->m_szTitle;
case Hy3NodeData::Group: case Hy3NodeType::Group:
std::string title; std::string title;
switch (this->data.as_group.layout) { switch (this->data.as_group.layout) {
@ -304,8 +304,8 @@ std::string Hy3Node::getTitle() {
void Hy3Node::appendAllWindows(std::vector<CWindow*>& list) { void Hy3Node::appendAllWindows(std::vector<CWindow*>& list) {
switch (this->data.type) { switch (this->data.type) {
case Hy3NodeData::Window: list.push_back(this->data.as_window); break; case Hy3NodeType::Window: list.push_back(this->data.as_window); break;
case Hy3NodeData::Group: case Hy3NodeType::Group:
for (auto* child: this->data.as_group.children) { for (auto* child: this->data.as_group.children) {
child->appendAllWindows(list); child->appendAllWindows(list);
} }
@ -316,7 +316,7 @@ void Hy3Node::appendAllWindows(std::vector<CWindow*>& list) {
void markGroupFocusedRecursive(Hy3GroupData& group) { void markGroupFocusedRecursive(Hy3GroupData& group) {
group.group_focused = true; group.group_focused = true;
for (auto& child: group.children) { for (auto& child: group.children) {
if (child->data.type == Hy3NodeData::Group) markGroupFocusedRecursive(child->data.as_group); if (child->data.type == Hy3NodeType::Group) markGroupFocusedRecursive(child->data.as_group);
} }
} }
@ -328,7 +328,7 @@ void Hy3Node::markFocused() {
while (root->parent != nullptr) root = root->parent; while (root->parent != nullptr) root = root->parent;
// update focus // update focus
if (this->data.type == Hy3NodeData::Group) { if (this->data.type == Hy3NodeType::Group) {
markGroupFocusedRecursive(this->data.as_group); markGroupFocusedRecursive(this->data.as_group);
} }
@ -346,11 +346,11 @@ void Hy3Node::focus() {
this->markFocused(); this->markFocused();
switch (this->data.type) { switch (this->data.type) {
case Hy3NodeData::Window: case Hy3NodeType::Window:
this->data.as_window->setHidden(false); this->data.as_window->setHidden(false);
g_pCompositor->focusWindow(this->data.as_window); g_pCompositor->focusWindow(this->data.as_window);
break; break;
case Hy3NodeData::Group: case Hy3NodeType::Group:
g_pCompositor->focusWindow(nullptr); g_pCompositor->focusWindow(nullptr);
this->raiseToTop(); this->raiseToTop();
break; break;
@ -359,12 +359,12 @@ void Hy3Node::focus() {
bool Hy3Node::focusWindow() { bool Hy3Node::focusWindow() {
switch (this->data.type) { switch (this->data.type) {
case Hy3NodeData::Window: case Hy3NodeType::Window:
this->markFocused(); this->markFocused();
g_pCompositor->focusWindow(this->data.as_window); g_pCompositor->focusWindow(this->data.as_window);
return true; return true;
case Hy3NodeData::Group: case Hy3NodeType::Group:
if (this->data.as_group.layout == Hy3GroupLayout::Tabbed) { if (this->data.as_group.layout == Hy3GroupLayout::Tabbed) {
if (this->data.as_group.focused_child != nullptr) { if (this->data.as_group.focused_child != nullptr) {
return this->data.as_group.focused_child->focusWindow(); return this->data.as_group.focused_child->focusWindow();
@ -381,8 +381,8 @@ bool Hy3Node::focusWindow() {
void Hy3Node::raiseToTop() { void Hy3Node::raiseToTop() {
switch (this->data.type) { switch (this->data.type) {
case Hy3NodeData::Window: g_pCompositor->moveWindowToTop(this->data.as_window); break; case Hy3NodeType::Window: g_pCompositor->moveWindowToTop(this->data.as_window); break;
case Hy3NodeData::Group: case Hy3NodeType::Group:
for (auto* child: this->data.as_group.children) { for (auto* child: this->data.as_group.children) {
child->raiseToTop(); child->raiseToTop();
} }
@ -392,8 +392,8 @@ void Hy3Node::raiseToTop() {
Hy3Node* Hy3Node::getFocusedNode() { Hy3Node* Hy3Node::getFocusedNode() {
switch (this->data.type) { switch (this->data.type) {
case Hy3NodeData::Window: return this; case Hy3NodeType::Window: return this;
case Hy3NodeData::Group: case Hy3NodeType::Group:
if (this->data.as_group.focused_child == nullptr || this->data.as_group.group_focused) { if (this->data.as_group.focused_child == nullptr || this->data.as_group.group_focused) {
return this; return this;
} else { } else {
@ -403,7 +403,7 @@ Hy3Node* Hy3Node::getFocusedNode() {
} }
bool Hy3Node::swallowGroups(Hy3Node* into) { bool Hy3Node::swallowGroups(Hy3Node* into) {
if (into == nullptr || into->data.type != Hy3NodeData::Group if (into == nullptr || into->data.type != Hy3NodeType::Group
|| into->data.as_group.children.size() != 1) || into->data.as_group.children.size() != 1)
return false; return false;
@ -411,7 +411,7 @@ bool Hy3Node::swallowGroups(Hy3Node* into) {
// a lot of segfaulting happens once the assumption that the root node is a // a lot of segfaulting happens once the assumption that the root node is a
// group is wrong. // group is wrong.
if (into->parent == nullptr && child->data.type != Hy3NodeData::Group) return false; if (into->parent == nullptr && child->data.type != Hy3NodeType::Group) return false;
Debug::log(LOG, "Swallowing %p into %p", child, into); Debug::log(LOG, "Swallowing %p into %p", child, into);
Hy3Node::swapData(*into, *child); Hy3Node::swapData(*into, *child);
@ -523,7 +523,7 @@ bool Hy3GroupData::hasChild(Hy3Node* node) {
for (auto child: this->children) { for (auto child: this->children) {
if (child == node) return true; if (child == node) return true;
if (child->data.type == Hy3NodeData::Group) { if (child->data.type == Hy3NodeType::Group) {
if (child->data.as_group.hasChild(node)) return true; if (child->data.as_group.hasChild(node)) return true;
} }
} }
@ -536,13 +536,13 @@ void Hy3Node::swapData(Hy3Node& a, Hy3Node& b) {
a.data = std::move(b.data); a.data = std::move(b.data);
b.data = std::move(aData); b.data = std::move(aData);
if (a.data.type == Hy3NodeData::Group) { if (a.data.type == Hy3NodeType::Group) {
for (auto child: a.data.as_group.children) { for (auto child: a.data.as_group.children) {
child->parent = &a; child->parent = &a;
} }
} }
if (b.data.type == Hy3NodeData::Group) { if (b.data.type == Hy3NodeType::Group) {
for (auto child: b.data.as_group.children) { for (auto child: b.data.as_group.children) {
child->parent = &b; child->parent = &b;
} }
@ -556,7 +556,7 @@ struct FindTopWindowInNodeResult {
void findTopWindowInNode(Hy3Node& node, FindTopWindowInNodeResult& result) { void findTopWindowInNode(Hy3Node& node, FindTopWindowInNodeResult& result) {
switch (node.data.type) { switch (node.data.type) {
case Hy3NodeData::Window: { case Hy3NodeType::Window: {
auto* window = node.data.as_window; auto* window = node.data.as_window;
auto& windows = g_pCompositor->m_vWindows; auto& windows = g_pCompositor->m_vWindows;
@ -568,7 +568,7 @@ void findTopWindowInNode(Hy3Node& node, FindTopWindowInNodeResult& result) {
} }
} break; } break;
case Hy3NodeData::Group: { case Hy3NodeType::Group: {
auto& group = node.data.as_group; auto& group = node.data.as_group;
if (group.layout == Hy3GroupLayout::Tabbed) { if (group.layout == Hy3GroupLayout::Tabbed) {
@ -583,7 +583,7 @@ void findTopWindowInNode(Hy3Node& node, FindTopWindowInNodeResult& result) {
} }
void Hy3Node::updateTabBar(bool no_animation) { void Hy3Node::updateTabBar(bool no_animation) {
if (this->data.type == Hy3NodeData::Group) { if (this->data.type == Hy3NodeType::Group) {
auto& group = this->data.as_group; auto& group = this->data.as_group;
if (group.layout == Hy3GroupLayout::Tabbed) { if (group.layout == Hy3GroupLayout::Tabbed) {
@ -612,11 +612,11 @@ void Hy3Node::updateTabBarRecursive() {
void Hy3Node::updateDecos() { void Hy3Node::updateDecos() {
switch (this->data.type) { switch (this->data.type) {
case Hy3NodeData::Window: case Hy3NodeType::Window:
if (this->data.as_window->m_bIsMapped) if (this->data.as_window->m_bIsMapped)
g_pCompositor->updateWindowAnimatedDecorationValues(this->data.as_window); g_pCompositor->updateWindowAnimatedDecorationValues(this->data.as_window);
break; break;
case Hy3NodeData::Group: case Hy3NodeType::Group:
for (auto* child: this->data.as_group.children) { for (auto* child: this->data.as_group.children) {
child->updateDecos(); child->updateDecos();
} }
@ -637,7 +637,7 @@ int Hy3Layout::getWorkspaceNodeCount(const int& id) {
Hy3Node* Hy3Layout::getNodeFromWindow(CWindow* window) { Hy3Node* Hy3Layout::getNodeFromWindow(CWindow* window) {
for (auto& node: this->nodes) { for (auto& node: this->nodes) {
if (node.data.type == Hy3NodeData::Window && node.data.as_window == window) { if (node.data.type == Hy3NodeType::Window && node.data.as_window == window) {
return &node; return &node;
} }
} }
@ -648,7 +648,7 @@ Hy3Node* Hy3Layout::getNodeFromWindow(CWindow* window) {
Hy3Node* Hy3Layout::getWorkspaceRootGroup(const int& workspace) { Hy3Node* Hy3Layout::getWorkspaceRootGroup(const int& workspace) {
for (auto& node: this->nodes) { for (auto& node: this->nodes) {
if (node.workspace_id == workspace && node.parent == nullptr if (node.workspace_id == workspace && node.parent == nullptr
&& node.data.type == Hy3NodeData::Group) && node.data.type == Hy3NodeType::Group)
{ {
return &node; return &node;
} }
@ -664,7 +664,7 @@ Hy3Node* Hy3Layout::getWorkspaceFocusedNode(const int& workspace) {
} }
void Hy3Layout::applyNodeDataToWindow(Hy3Node* node, bool no_animation) { void Hy3Layout::applyNodeDataToWindow(Hy3Node* node, bool no_animation) {
if (node->data.type != Hy3NodeData::Window) return; if (node->data.type != Hy3NodeType::Window) return;
CWindow* window = node->data.as_window; CWindow* window = node->data.as_window;
CMonitor* monitor = nullptr; CMonitor* monitor = nullptr;
@ -709,7 +709,7 @@ void Hy3Layout::applyNodeDataToWindow(Hy3Node* node, bool no_animation) {
auto root_node = this->getWorkspaceRootGroup(window->m_iWorkspaceID); auto root_node = this->getWorkspaceRootGroup(window->m_iWorkspaceID);
auto only_node = root_node->data.as_group.children.size() == 1 auto only_node = root_node->data.as_group.children.size() == 1
&& root_node->data.as_group.children.front()->data.type == Hy3NodeData::Window; && root_node->data.as_group.children.front()->data.type == Hy3NodeType::Window;
if (!g_pCompositor->isWorkspaceSpecial(window->m_iWorkspaceID) if (!g_pCompositor->isWorkspaceSpecial(window->m_iWorkspaceID)
&& ((*single_window_no_gaps && only_node) && ((*single_window_no_gaps && only_node)
@ -826,7 +826,7 @@ void Hy3Layout::onWindowCreatedTiling(CWindow* window) {
} }
} }
if (opening_into->data.type != Hy3NodeData::Group) { if (opening_into->data.type != Hy3NodeType::Group) {
Debug::log(ERR, "opening_into node %p was not of type Group", opening_into); Debug::log(ERR, "opening_into node %p was not of type Group", opening_into);
errorNotif(); errorNotif();
return; return;
@ -905,7 +905,7 @@ void Hy3Layout::onWindowRemovedTiling(CWindow* window) {
parent->recalcSizePosRecursive(); parent->recalcSizePosRecursive();
if (parent->data.as_group.children.size() == 1 if (parent->data.as_group.children.size() == 1
&& parent->data.as_group.children.front()->data.type == Hy3NodeData::Group) && parent->data.as_group.children.front()->data.type == Hy3NodeType::Group)
{ {
auto* target_parent = parent; auto* target_parent = parent;
while (target_parent != nullptr && Hy3Node::swallowGroups(target_parent)) { while (target_parent != nullptr && Hy3Node::swallowGroups(target_parent)) {
@ -923,8 +923,8 @@ CWindow* Hy3Layout::getNextWindowCandidate(CWindow* window) {
if (node == nullptr) return nullptr; if (node == nullptr) return nullptr;
switch (node->data.type) { switch (node->data.type) {
case Hy3NodeData::Window: return node->data.as_window; case Hy3NodeType::Window: return node->data.as_window;
case Hy3NodeData::Group: return nullptr; case Hy3NodeType::Group: return nullptr;
} }
} }
@ -1373,7 +1373,7 @@ void Hy3Layout::onDisable() {
selection_hook::disable(); selection_hook::disable();
for (auto& node: this->nodes) { for (auto& node: this->nodes) {
if (node.data.type == Hy3NodeData::Window) { if (node.data.type == Hy3NodeType::Window) {
node.data.as_window->setHidden(false); node.data.as_window->setHidden(false);
} }
} }
@ -1563,7 +1563,7 @@ Hy3Node* Hy3Layout::shiftOrGetFocus(
if (shiftIsForward(direction)) iter = std::next(iter); if (shiftIsForward(direction)) iter = std::next(iter);
else iter = std::prev(iter); else iter = std::prev(iter);
if ((*iter)->data.type == Hy3NodeData::Window || (shift && once && has_broken_once)) { if ((*iter)->data.type == Hy3NodeType::Window || (shift && once && has_broken_once)) {
if (shift) { if (shift) {
if (target_group == node.parent) { if (target_group == node.parent) {
if (shiftIsForward(direction)) insert = std::next(iter); if (shiftIsForward(direction)) insert = std::next(iter);
@ -1618,7 +1618,7 @@ Hy3Node* Hy3Layout::shiftOrGetFocus(
break; break;
} }
if ((*iter)->data.type == Hy3NodeData::Window) { if ((*iter)->data.type == Hy3NodeType::Window) {
if (shift) { if (shift) {
if (shift_after) insert = std::next(iter); if (shift_after) insert = std::next(iter);
else insert = iter; else insert = iter;
@ -1686,7 +1686,7 @@ void Hy3Layout::changeFocus(int workspace, FocusShift shift) {
} }
return; return;
case FocusShift::Lower: case FocusShift::Lower:
if (node->data.type == Hy3NodeData::Group && node->data.as_group.focused_child != nullptr) if (node->data.type == Hy3NodeType::Group && node->data.as_group.focused_child != nullptr)
node->data.as_group.focused_child->focus(); node->data.as_group.focused_child->focus();
return; return;
case FocusShift::Tab: case FocusShift::Tab:
@ -1716,7 +1716,7 @@ void Hy3Layout::changeFocus(int workspace, FocusShift shift) {
} }
bottom: bottom:
while (node->data.type == Hy3NodeData::Group && node->data.as_group.focused_child != nullptr) { while (node->data.type == Hy3NodeType::Group && node->data.as_group.focused_child != nullptr) {
node = node->data.as_group.focused_child; node = node->data.as_group.focused_child;
} }
@ -1725,7 +1725,7 @@ bottom:
} }
Hy3Node* Hy3Node::findNodeForTabGroup(Hy3TabGroup& tab_group) { Hy3Node* Hy3Node::findNodeForTabGroup(Hy3TabGroup& tab_group) {
if (this->data.type == Hy3NodeData::Group) { if (this->data.type == Hy3NodeType::Group) {
if (this->hidden) return nullptr; if (this->hidden) return nullptr;
auto& group = this->data.as_group; auto& group = this->data.as_group;
@ -1759,7 +1759,7 @@ Hy3Node* findTabBarAt(Hy3Node& node, Vector2D pos, Hy3Node** focused_node) {
inset += *gaps_in; inset += *gaps_in;
} }
if (node.data.type == Hy3NodeData::Group) { if (node.data.type == Hy3NodeType::Group) {
if (node.hidden) return nullptr; if (node.hidden) return nullptr;
// note: tab bar clicks ignore animations // note: tab bar clicks ignore animations
if (node.position.x > pos.x || node.position.y > pos.y || node.position.x + node.size.x < pos.x if (node.position.x > pos.x || node.position.y > pos.y || node.position.x + node.size.x < pos.x
@ -1833,7 +1833,7 @@ void Hy3Layout::focusTab(
&& tab_node->parent != nullptr) && tab_node->parent != nullptr)
tab_node = tab_node->parent; tab_node = tab_node->parent;
if (tab_node == nullptr || tab_node->data.type != Hy3NodeData::Group if (tab_node == nullptr || tab_node->data.type != Hy3NodeType::Group
|| tab_node->data.as_group.layout != Hy3GroupLayout::Tabbed) || tab_node->data.as_group.layout != Hy3GroupLayout::Tabbed)
return; return;
} }
@ -1882,7 +1882,7 @@ hastab:
} }
auto* focus = tab_focused_node; auto* focus = tab_focused_node;
while (focus->data.type == Hy3NodeData::Group && !focus->data.as_group.group_focused while (focus->data.type == Hy3NodeType::Group && !focus->data.as_group.group_focused
&& focus->data.as_group.focused_child != nullptr) && focus->data.as_group.focused_child != nullptr)
focus = focus->data.as_group.focused_child; focus = focus->data.as_group.focused_child;
@ -1913,13 +1913,13 @@ bool Hy3Layout::shouldRenderSelected(CWindow* window) {
if (root == nullptr || root->data.as_group.focused_child == nullptr) return false; if (root == nullptr || root->data.as_group.focused_child == nullptr) return false;
auto* focused = root->getFocusedNode(); auto* focused = root->getFocusedNode();
if (focused == nullptr if (focused == nullptr
|| (focused->data.type == Hy3NodeData::Window || (focused->data.type == Hy3NodeType::Window
&& focused->data.as_window != g_pCompositor->m_pLastWindow)) && focused->data.as_window != g_pCompositor->m_pLastWindow))
return false; return false;
switch (focused->data.type) { switch (focused->data.type) {
case Hy3NodeData::Window: return focused->data.as_window == window; case Hy3NodeType::Window: return focused->data.as_window == window;
case Hy3NodeData::Group: case Hy3NodeType::Group:
auto* node = this->getNodeFromWindow(window); auto* node = this->getNodeFromWindow(window);
if (node == nullptr) return false; if (node == nullptr) return false;
return focused->data.as_group.hasChild(node); return focused->data.as_group.hasChild(node);
@ -2000,7 +2000,7 @@ std::string Hy3Node::debugNode() {
std::stringstream buf; std::stringstream buf;
std::string addr = "0x" + std::to_string((size_t) this); std::string addr = "0x" + std::to_string((size_t) this);
switch (this->data.type) { switch (this->data.type) {
case Hy3NodeData::Window: case Hy3NodeType::Window:
buf << "window("; buf << "window(";
buf << std::hex << this; buf << std::hex << this;
buf << ") [hypr "; buf << ") [hypr ";
@ -2008,7 +2008,7 @@ std::string Hy3Node::debugNode() {
buf << "] size ratio: "; buf << "] size ratio: ";
buf << this->size_ratio; buf << this->size_ratio;
break; break;
case Hy3NodeData::Group: case Hy3NodeType::Group:
buf << "group("; buf << "group(";
buf << std::hex << this; buf << std::hex << this;
buf << ") ["; buf << ") [";

7
src/Hy3Layout.hpp
View file

@ -15,6 +15,11 @@ enum class Hy3GroupLayout {
Tabbed, Tabbed,
}; };
enum class Hy3NodeType {
Window,
Group,
};
enum class ShiftDirection { enum class ShiftDirection {
Left, Left,
Up, Up,
@ -65,7 +70,7 @@ private:
class Hy3NodeData { class Hy3NodeData {
public: public:
enum { Group, Window } type; Hy3NodeType type;
union { union {
Hy3GroupData as_group; Hy3GroupData as_group;
CWindow* as_window; CWindow* as_window;

4
src/TabGroup.cpp
View file

@ -647,8 +647,8 @@ void Hy3TabGroup::renderTabBar() {
void findOverlappingWindows(Hy3Node& node, float height, std::vector<CWindow*>& windows) { void findOverlappingWindows(Hy3Node& node, float height, std::vector<CWindow*>& windows) {
switch (node.data.type) { switch (node.data.type) {
case Hy3NodeData::Window: windows.push_back(node.data.as_window); break; case Hy3NodeType::Window: windows.push_back(node.data.as_window); break;
case Hy3NodeData::Group: case Hy3NodeType::Group:
auto& group = node.data.as_group; auto& group = node.data.as_group;
switch (group.layout) { switch (group.layout) {