aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/layout/IHyprLayout.hpp
blob: a58783e454dc59cebff01bd86e68baa6d07e0bda (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
#pragma once

#include "../defines.hpp"
#include "../Window.hpp"
#include <any>

struct SWindowRenderLayoutHints {
    bool   isBorderColor = false;
    CColor borderColor;
};

struct SLayoutMessageHeader {
    CWindow* pWindow = nullptr;
};

enum eFullscreenMode : uint8_t;

interface IHyprLayout {
  public:
    virtual ~IHyprLayout()                       = 0;
    virtual void                     onEnable()  = 0;
    virtual void                     onDisable() = 0;

    /*
        Called when a window is created (mapped)
        The layout HAS TO set the goal pos and size (anim mgr will use it)
        If !animationinprogress, then the anim mgr will not apply an anim.
    */
    virtual void                     onWindowCreated(CWindow*);
    virtual void                     onWindowCreatedTiling(CWindow*) = 0;
    virtual void                     onWindowCreatedFloating(CWindow*);

    /*
        Return tiled status
    */
    virtual bool                     isWindowTiled(CWindow*) = 0;

    /*
        Called when a window is removed (unmapped)
    */
    virtual void                     onWindowRemoved(CWindow*);
    virtual void                     onWindowRemovedTiling(CWindow*) = 0;
    virtual void                     onWindowRemovedFloating(CWindow*);
    /*
        Called when the monitor requires a layout recalculation
        this usually means reserved area changes
    */
    virtual void                     recalculateMonitor(const int&) = 0;

    /*
        Called when the compositor requests a window
        to be recalculated, e.g. when pseudo is toggled.
    */
    virtual void                     recalculateWindow(CWindow*) = 0;

    /*
        Called when a window is requested to be floated
    */
    virtual void                     changeWindowFloatingMode(CWindow*);
    /*
        Called when a window is clicked on, beginning a drag
        this might be a resize, move, whatever the layout defines it
        as.
    */
    virtual void                     onBeginDragWindow();
    /*
        Called when a user requests a resize of the current window by a vec
        Vector2D holds pixel values
        Optional pWindow for a specific window
    */
    virtual void                     resizeActiveWindow(const Vector2D&, CWindow* pWindow = nullptr) = 0;
    /*
        Called when a user requests a move of the current window by a vec
        Vector2D holds pixel values
        Optional pWindow for a specific window
    */
    virtual void                     moveActiveWindow(const Vector2D&, CWindow* pWindow = nullptr);
    /*
        Called when a window is ended being dragged
        (mouse up)
    */
    virtual void                     onEndDragWindow();
    /*
        Called whenever the mouse moves, should the layout want to
        do anything with it.
        Useful for dragging.
    */
    virtual void                     onMouseMove(const Vector2D&);

    /*
        Called when a window / the user requests to toggle the fullscreen state of a window
        The layout sets all the fullscreen flags.
        It can either accept or ignore.
    */
    virtual void                     fullscreenRequestForWindow(CWindow*, eFullscreenMode, bool) = 0;

    /*
        Called when a dispatcher requests a custom message
        The layout is free to ignore.
        std::any is the reply. Can be empty.
    */
    virtual std::any                 layoutMessage(SLayoutMessageHeader, std::string) = 0;

    /*
        Required to be handled, but may return just SWindowRenderLayoutHints()
        Called when the renderer requests any special draw flags for
        a specific window, e.g. border color for groups.
    */
    virtual SWindowRenderLayoutHints requestRenderHints(CWindow*) = 0;

    /*
        Called when the user requests two windows to be swapped places.
        The layout is free to ignore.
    */
    virtual void                     switchWindows(CWindow*, CWindow*) = 0;

    /*
        Called when the user requests to change the splitratio by X
        on a window
    */
    virtual void                     alterSplitRatioBy(CWindow*, float) = 0;

    /*
        Called when something wants the current layout's name
    */
    virtual std::string              getLayoutName() = 0;

    /*
        Called for getting the next candidate for a focus
    */
    virtual CWindow*                 getNextWindowCandidate(CWindow*);

    /*
        Internal: called when window focus changes
    */
    virtual void                     onWindowFocusChange(CWindow*);

  private:
    Vector2D m_vBeginDragXY;
    Vector2D m_vLastDragXY;
    Vector2D m_vBeginDragPositionXY;
    Vector2D m_vBeginDragSizeXY;
    int      m_iGrabbedCorner = 0;

    CWindow* m_pLastTiledWindow = nullptr;
};