hy3/src/Hy3Layout.hpp

172 lines
4.3 KiB
C++
Raw Normal View History

#pragma once
2023-06-07 03:22:17 -07:00
#include <hyprland/src/layout/IHyprLayout.hpp>
#include <list>
2023-05-16 03:02:26 -07:00
struct Hy3Node;
#include "TabGroup.hpp"
class Hy3Layout;
struct Hy3Node;
enum class Hy3GroupLayout {
SplitH,
SplitV,
Tabbed,
};
enum class ShiftDirection {
Left,
Up,
Down,
Right,
};
struct Hy3GroupData {
Hy3GroupLayout layout = Hy3GroupLayout::SplitH;
std::list<Hy3Node*> children;
bool group_focused = true;
Hy3Node* focused_child = nullptr;
Hy3TabGroup* tab_bar = nullptr;
bool hasChild(Hy3Node* child);
Hy3GroupData(Hy3GroupLayout layout);
~Hy3GroupData();
private:
Hy3GroupData(Hy3GroupData&&);
Hy3GroupData(const Hy3GroupData&) = delete;
friend class Hy3NodeData;
};
class Hy3NodeData {
public:
enum { Group, Window } type;
union {
Hy3GroupData as_group;
CWindow* as_window;
};
bool operator==(const Hy3NodeData&) const;
Hy3NodeData();
~Hy3NodeData();
Hy3NodeData(CWindow*);
Hy3NodeData(Hy3GroupLayout);
Hy3NodeData& operator=(CWindow*);
Hy3NodeData& operator=(Hy3GroupLayout);
2023-06-07 03:22:17 -07:00
// private: - I give up, C++ wins
Hy3NodeData(Hy3GroupData);
Hy3NodeData(Hy3NodeData&&);
2023-05-16 03:02:26 -07:00
Hy3NodeData& operator=(Hy3NodeData&&);
};
struct Hy3Node {
Hy3Node* parent = nullptr;
Hy3NodeData data;
Vector2D position;
Vector2D size;
2023-06-04 21:32:30 -07:00
Vector2D gap_pos_offset;
Vector2D gap_size_offset;
float size_ratio = 1.0;
int workspace_id = -1;
bool hidden = false;
bool valid = true;
Hy3Layout* layout = nullptr;
void recalcSizePosRecursive(bool force = false);
2023-04-19 01:58:22 -07:00
std::string debugNode();
2023-04-26 00:57:24 -07:00
void markFocused();
void focus();
2023-05-31 01:31:22 -07:00
bool focusWindow();
2023-04-26 00:57:24 -07:00
void raiseToTop();
Hy3Node* getFocusedNode();
void updateDecos();
2023-05-16 03:02:26 -07:00
void setHidden(bool hidden);
2023-06-04 17:28:26 -07:00
void updateTabBar();
void updateTabBarRecursive();
2023-05-16 03:02:26 -07:00
bool isUrgent();
bool isIndirectlyFocused();
Hy3Node* findNodeForTabGroup(Hy3TabGroup&);
2023-05-16 03:02:26 -07:00
std::string getTitle();
bool operator==(const Hy3Node&) const;
2023-04-23 21:02:51 -07:00
// Attempt to swallow a group. returns true if swallowed
static bool swallowGroups(Hy3Node*);
// Remove this node from its parent, deleting the parent if it was
2023-06-07 03:22:17 -07:00
// the only child and recursing if the parent was the only child of it's
// parent.
2023-04-23 21:02:51 -07:00
Hy3Node* removeFromParentRecursive();
// Replace this node with a group, returning this node's new address.
Hy3Node* intoGroup(Hy3GroupLayout);
2023-04-23 21:02:51 -07:00
static void swapData(Hy3Node&, Hy3Node&);
};
2023-04-19 02:07:47 -07:00
class Hy3Layout: public IHyprLayout {
public:
virtual void onWindowCreatedTiling(CWindow*);
virtual void onWindowRemovedTiling(CWindow*);
virtual void onWindowFocusChange(CWindow*);
virtual bool isWindowTiled(CWindow*);
virtual void recalculateMonitor(const int&);
virtual void recalculateWindow(CWindow*);
virtual void onBeginDragWindow();
virtual void resizeActiveWindow(const Vector2D&, CWindow* pWindow = nullptr);
virtual void fullscreenRequestForWindow(CWindow*, eFullscreenMode, bool);
virtual std::any layoutMessage(SLayoutMessageHeader, std::string);
virtual SWindowRenderLayoutHints requestRenderHints(CWindow*);
virtual void switchWindows(CWindow*, CWindow*);
virtual void alterSplitRatio(CWindow*, float, bool);
virtual std::string getLayoutName();
2023-04-16 23:53:22 -07:00
virtual CWindow* getNextWindowCandidate(CWindow*);
virtual void replaceWindowDataWith(CWindow*, CWindow*);
virtual void onEnable();
virtual void onDisable();
void makeGroupOnWorkspace(int, Hy3GroupLayout);
void makeOppositeGroupOnWorkspace(int);
void makeGroupOn(Hy3Node*, Hy3GroupLayout);
void makeOppositeGroupOn(Hy3Node*);
2023-05-10 00:42:53 -07:00
void shiftWindow(int, ShiftDirection, bool);
2023-04-26 00:57:24 -07:00
void shiftFocus(int, ShiftDirection);
void raiseFocus(int);
void focusTab(int);
2023-04-26 00:57:24 -07:00
bool shouldRenderSelected(CWindow*);
2023-04-19 01:58:22 -07:00
Hy3Node* getWorkspaceRootGroup(const int&);
Hy3Node* getWorkspaceFocusedNode(const int&);
2023-04-19 01:58:22 -07:00
2023-05-16 03:02:26 -07:00
static void renderHook(void*, std::any);
2023-06-04 17:28:26 -07:00
static void windowTitleHook(void*, std::any);
2023-05-30 23:23:46 -07:00
static void tickHook(void*, std::any);
2023-05-16 03:02:26 -07:00
std::list<Hy3Node> nodes;
std::list<Hy3TabGroup> tab_groups;
2023-06-07 03:22:17 -07:00
private:
struct {
bool started = false;
bool xExtent = false;
bool yExtent = false;
} drag_flags;
int getWorkspaceNodeCount(const int&);
Hy3Node* getNodeFromWindow(CWindow*);
void applyNodeDataToWindow(Hy3Node*, bool force = false);
2023-06-07 03:22:17 -07:00
// if shift is true, shift the window in the given direction, returning
// nullptr, if shift is false, return the window in the given direction or
// nullptr. if once is true, only one group will be broken out of / into
2023-05-10 00:42:53 -07:00
Hy3Node* shiftOrGetFocus(Hy3Node&, ShiftDirection, bool, bool);
2023-04-23 21:02:51 -07:00
friend struct Hy3Node;
};