aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/Compositor.hpp
blob: 216e5e59a870503dd5e066d1dd05c28a8a90bba8 (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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
#pragma once

#include <memory>
#include <deque>
#include <list>

#include "defines.hpp"
#include "debug/Log.hpp"
#include "events/Events.hpp"
#include "config/ConfigManager.hpp"
#include "managers/ThreadManager.hpp"
#include "managers/XWaylandManager.hpp"
#include "managers/input/InputManager.hpp"
#include "managers/LayoutManager.hpp"
#include "managers/KeybindManager.hpp"
#include "managers/AnimationManager.hpp"
#include "managers/EventManager.hpp"
#include "debug/HyprDebugOverlay.hpp"
#include "helpers/Monitor.hpp"
#include "helpers/Workspace.hpp"
#include "Window.hpp"
#include "render/Renderer.hpp"
#include "render/OpenGL.hpp"
#include "hyprerror/HyprError.hpp"

class CCompositor {
public:
    CCompositor();
    ~CCompositor();

    // ------------------ WLR BASICS ------------------ //
    wl_display*                      m_sWLDisplay;
    wl_event_loop*                   m_sWLEventLoop;
    wlr_backend*                     m_sWLRBackend;
    wlr_session*                     m_sWLRSession;
    wlr_renderer*                    m_sWLRRenderer;
    wlr_allocator*                   m_sWLRAllocator;
    wlr_compositor*                  m_sWLRCompositor;
    wlr_subcompositor*               m_sWLRSubCompositor;
    wlr_data_device_manager*         m_sWLRDataDevMgr;
    wlr_drm*                         m_sWRLDRM;
    wlr_drm_lease_v1_manager*        m_sWRLDRMLeaseMgr;
    wlr_xdg_activation_v1*           m_sWLRXDGActivation;
    wlr_output_layout*               m_sWLROutputLayout;
    wlr_idle*                        m_sWLRIdle;
    wlr_layer_shell_v1*              m_sWLRLayerShell;
    wlr_xdg_shell*                   m_sWLRXDGShell;
    wlr_cursor*                      m_sWLRCursor;
    wlr_xcursor_manager*             m_sWLRXCursorMgr;
    wlr_virtual_keyboard_manager_v1* m_sWLRVKeyboardMgr;
    wlr_output_manager_v1*           m_sWLROutputMgr;
    wlr_presentation*                m_sWLRPresentation;
    wlr_scene*                       m_sWLRScene;
    wlr_input_inhibit_manager*       m_sWLRInhibitMgr;
    wlr_keyboard_shortcuts_inhibit_manager_v1* m_sWLRKbShInhibitMgr;
    wlr_egl*                         m_sWLREGL;
    int                              m_iDRMFD;
    wlr_ext_workspace_manager_v1*    m_sWLREXTWorkspaceMgr;
    wlr_pointer_constraints_v1*      m_sWLRPointerConstraints;
    wlr_relative_pointer_manager_v1* m_sWLRRelPointerMgr;
    wlr_server_decoration_manager*   m_sWLRServerDecoMgr;
    wlr_xdg_decoration_manager_v1*   m_sWLRXDGDecoMgr;
    wlr_virtual_pointer_manager_v1*  m_sWLRVirtPtrMgr;
    wlr_foreign_toplevel_manager_v1* m_sWLRToplevelMgr;
    wlr_tablet_manager_v2*           m_sWLRTabletManager;
    wlr_xdg_foreign_registry*        m_sWLRForeignRegistry;
    wlr_idle_inhibit_manager_v1*     m_sWLRIdleInhibitMgr;
    wlr_pointer_gestures_v1*         m_sWLRPointerGestures;
    wlr_output_power_manager_v1*     m_sWLROutputPowerMgr;
    wlr_input_method_manager_v2*     m_sWLRIMEMgr;
    wlr_text_input_manager_v3*       m_sWLRTextInputMgr;
    // ------------------------------------------------- //


    const char*             m_szWLDisplaySocket;
    std::string             m_szInstanceSignature = "";
    std::string             m_szCurrentSplash = "error";

    std::vector<std::shared_ptr<CMonitor>>      m_vMonitors;
    std::vector<std::shared_ptr<CMonitor>>      m_vRealMonitors; // for all monitors, even those turned off
    std::vector<std::unique_ptr<CWindow>>       m_vWindows;
    std::deque<std::unique_ptr<CWindow>>        m_dUnmanagedX11Windows;
    std::vector<std::unique_ptr<SXDGPopup>>     m_vXDGPopups;
    std::vector<std::unique_ptr<CWorkspace>>    m_vWorkspaces;
    std::vector<std::unique_ptr<SSubsurface>>   m_vSubsurfaces;
    std::vector<CWindow*>                       m_vWindowsFadingOut;
    std::vector<SLayerSurface*>                 m_vSurfacesFadingOut;

    void                    startCompositor(); 
    void                    cleanup();

    wlr_surface*            m_pLastFocus = nullptr;
    CWindow*                m_pLastWindow = nullptr;
    CMonitor*               m_pLastMonitor = nullptr;
    
    SSeat                   m_sSeat;

    bool                    m_bReadyToProcess = false;
    bool                    m_bSessionActive = true;
    bool                    m_bDPMSStateON = true;
    bool                    m_bUnsafeState = false; // unsafe state is when there is no monitors.
    bool                    m_bIsShuttingDown = false;
    std::deque<uint64_t>    m_dProcessPIDsOnShutdown; // stores PIDs of apps to kill later when shutting down

    // ------------------------------------------------- //

    CMonitor*               getMonitorFromID(const int&);
    CMonitor*               getMonitorFromName(const std::string&);
    CMonitor*               getMonitorFromCursor();
    CMonitor*               getMonitorFromVector(const Vector2D&);
    void                    removeWindowFromVectorSafe(CWindow*);
    void                    focusWindow(CWindow*, wlr_surface* pSurface = nullptr);
    void                    focusSurface(wlr_surface*, CWindow* pWindowOwner = nullptr);
    bool                    windowExists(CWindow*);
    bool                    windowValidMapped(CWindow*);
    CWindow*                vectorToWindow(const Vector2D&);
    CWindow*                vectorToWindowIdeal(const Vector2D&); // used only for finding a window to focus on, basically a "findFocusableWindow"
    CWindow*                vectorToWindowTiled(const Vector2D&);
    wlr_surface*            vectorToLayerSurface(const Vector2D&, std::vector<std::unique_ptr<SLayerSurface>>*, Vector2D*, SLayerSurface**);
    wlr_surface*            vectorWindowToSurface(const Vector2D&, CWindow*, Vector2D& sl);
    CWindow*                windowFromCursor();
    CWindow*                windowFloatingFromCursor();
    CMonitor*               getMonitorFromOutput(wlr_output*);
    CWindow*                getWindowForPopup(wlr_xdg_popup*);
    CWindow*                getWindowFromSurface(wlr_surface*);
    bool                    isWorkspaceVisible(const int&);
    CWorkspace*             getWorkspaceByID(const int&);
    CWorkspace*             getWorkspaceByName(const std::string&);
    CWorkspace*             getWorkspaceByString(const std::string&);
    void                    sanityCheckWorkspaces();
    void                    updateWorkspaceWindowDecos(const int&);
    int                     getWindowsOnWorkspace(const int&);
    CWindow*                getFirstWindowOnWorkspace(const int&);
    CWindow*                getFullscreenWindowOnWorkspace(const int&);
    bool                    doesSeatAcceptInput(wlr_surface*);
    bool                    isWindowActive(CWindow*);
    void                    moveWindowToTop(CWindow*);
    void                    cleanupFadingOut(const int& monid);
    CWindow*                getWindowInDirection(CWindow*, char);
    void                    deactivateAllWLRWorkspaces(wlr_ext_workspace_handle_v1* exclude = nullptr);
    CWindow*                getNextWindowOnWorkspace(CWindow*);
    CWindow*                getPrevWindowOnWorkspace(CWindow*);
    int                     getNextAvailableNamedWorkspace();
    bool                    isPointOnAnyMonitor(const Vector2D&);
    CWindow*                getConstraintWindow(SMouse*);
    CMonitor*               getMonitorInDirection(const char&);
    void                    updateAllWindowsAnimatedDecorationValues();
    void                    updateWindowAnimatedDecorationValues(CWindow*);
    int                     getNextAvailableMonitorID();
    void                    moveWorkspaceToMonitor(CWorkspace*, CMonitor*);
    void                    swapActiveWorkspaces(CMonitor*, CMonitor*);
    CMonitor*               getMonitorFromString(const std::string&);
    bool                    workspaceIDOutOfBounds(const int&);
    void                    setWindowFullscreen(CWindow*, bool, eFullscreenMode);
    void                    moveUnmanagedX11ToWindows(CWindow*);
    CWindow*                getX11Parent(CWindow*);
    void                    scheduleFrameForMonitor(CMonitor*);
    void                    addToFadingOutSafe(SLayerSurface*);
    void                    addToFadingOutSafe(CWindow*);
    CWindow*                getWindowByRegex(const std::string&);
    void                    warpCursorTo(const Vector2D&);
    SLayerSurface*          getLayerSurfaceFromWlr(wlr_layer_surface_v1*);
    SLayerSurface*          getLayerSurfaceFromSurface(wlr_surface*);
    void                    closeWindow(CWindow*);
    Vector2D                parseWindowVectorArgsRelative(const std::string&, const Vector2D&);
    void                    forceReportSizesToWindowsOnWorkspace(const int&);
    bool                    cursorOnReservedArea();
    

    std::string             explicitConfigPath;

    void                    startHyprCtlTick();

private:
    void                    initAllSignals();
    void                    setRandomSplash();   

    uint64_t                m_iHyprlandPID = 0; 
};


inline std::unique_ptr<CCompositor> g_pCompositor;

// For XWayland
inline std::map<std::string, xcb_atom_t> HYPRATOMS = {
    HYPRATOM("_NET_WM_WINDOW_TYPE"),
    HYPRATOM("_NET_WM_WINDOW_TYPE_NORMAL"),
    HYPRATOM("_NET_WM_WINDOW_TYPE_DOCK"),
    HYPRATOM("_NET_WM_WINDOW_TYPE_DIALOG"),
    HYPRATOM("_NET_WM_WINDOW_TYPE_UTILITY"),
    HYPRATOM("_NET_WM_WINDOW_TYPE_TOOLBAR"),
    HYPRATOM("_NET_WM_WINDOW_TYPE_SPLASH"),
    HYPRATOM("_NET_WM_WINDOW_TYPE_MENU"),
    HYPRATOM("_NET_WM_WINDOW_TYPE_DROPDOWN_MENU"),
    HYPRATOM("_NET_WM_WINDOW_TYPE_POPUP_MENU"),
    HYPRATOM("_NET_WM_WINDOW_TYPE_TOOLTIP"),
    HYPRATOM("_NET_WM_WINDOW_TYPE_NOTIFICATION")};