mirror of
https://github.com/hyprwm/Hyprland
synced 2024-11-05 13:26:00 +01:00
Vaxry
5edc32930d
Makes all the pointers smart to avoid memory issues Refactors layerSurface code to live inside desktop/layersurface
225 lines
12 KiB
C++
225 lines
12 KiB
C++
#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 "managers/ProtocolManager.hpp"
|
|
#include "managers/SessionLockManager.hpp"
|
|
#include "managers/HookSystemManager.hpp"
|
|
#include "debug/HyprDebugOverlay.hpp"
|
|
#include "debug/HyprNotificationOverlay.hpp"
|
|
#include "helpers/Monitor.hpp"
|
|
#include "desktop/Workspace.hpp"
|
|
#include "desktop/Window.hpp"
|
|
#include "render/Renderer.hpp"
|
|
#include "render/OpenGL.hpp"
|
|
#include "hyprerror/HyprError.hpp"
|
|
#include "plugins/PluginSystem.hpp"
|
|
#include "helpers/Watchdog.hpp"
|
|
|
|
enum eManagersInitStage {
|
|
STAGE_PRIORITY = 0,
|
|
STAGE_LATE
|
|
};
|
|
|
|
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_output_layout* m_sWLROutputLayout;
|
|
wlr_layer_shell_v1* m_sWLRLayerShell;
|
|
wlr_xdg_shell* m_sWLRXDGShell;
|
|
wlr_cursor* m_sWLRCursor;
|
|
wlr_virtual_keyboard_manager_v1* m_sWLRVKeyboardMgr;
|
|
wlr_output_manager_v1* m_sWLROutputMgr;
|
|
wlr_presentation* m_sWLRPresentation;
|
|
wlr_egl* m_sWLREGL;
|
|
int m_iDRMFD;
|
|
wlr_server_decoration_manager* m_sWLRServerDecoMgr;
|
|
wlr_virtual_pointer_manager_v1* m_sWLRVirtPtrMgr;
|
|
wlr_tablet_manager_v2* m_sWLRTabletManager;
|
|
wlr_xdg_foreign_registry* m_sWLRForeignRegistry;
|
|
wlr_input_method_manager_v2* m_sWLRIMEMgr;
|
|
wlr_linux_dmabuf_v1* m_sWLRLinuxDMABuf;
|
|
wlr_backend* m_sWLRHeadlessBackend;
|
|
wlr_session_lock_manager_v1* m_sWLRSessionLockMgr;
|
|
// ------------------------------------------------- //
|
|
|
|
std::string m_szHyprTempDataRoot = "";
|
|
|
|
std::string m_szWLDisplaySocket = "";
|
|
std::string m_szInstanceSignature = "";
|
|
std::string m_szInstancePath = "";
|
|
std::string m_szCurrentSplash = "error";
|
|
|
|
std::vector<SP<CMonitor>> m_vMonitors;
|
|
std::vector<SP<CMonitor>> m_vRealMonitors; // for all monitors, even those turned off
|
|
std::vector<PHLWINDOW> m_vWindows;
|
|
std::vector<PHLWORKSPACE> m_vWorkspaces;
|
|
std::vector<PHLWINDOWREF> m_vWindowsFadingOut;
|
|
std::vector<PHLLSREF> m_vSurfacesFadingOut;
|
|
|
|
std::unordered_map<std::string, uint64_t> m_mMonitorIDMap;
|
|
|
|
void initServer();
|
|
void startCompositor();
|
|
void cleanup();
|
|
void createLockFile();
|
|
void removeLockFile();
|
|
|
|
wlr_surface* m_pLastFocus = nullptr;
|
|
PHLWINDOWREF m_pLastWindow;
|
|
CMonitor* m_pLastMonitor = nullptr;
|
|
|
|
std::vector<PHLWINDOWREF> m_vWindowFocusHistory; // first element is the most recently focused.
|
|
|
|
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_bNextIsUnsafe = false; // because wlroots
|
|
CMonitor* m_pUnsafeOutput = nullptr; // fallback output for the unsafe state
|
|
bool m_bExitTriggered = false; // For exit dispatcher
|
|
bool m_bIsShuttingDown = false;
|
|
|
|
// ------------------------------------------------- //
|
|
|
|
CMonitor* getMonitorFromID(const int&);
|
|
CMonitor* getMonitorFromName(const std::string&);
|
|
CMonitor* getMonitorFromDesc(const std::string&);
|
|
CMonitor* getMonitorFromCursor();
|
|
CMonitor* getMonitorFromVector(const Vector2D&);
|
|
void removeWindowFromVectorSafe(PHLWINDOW);
|
|
void focusWindow(PHLWINDOW, wlr_surface* pSurface = nullptr);
|
|
void focusSurface(wlr_surface*, PHLWINDOW pWindowOwner = nullptr);
|
|
bool monitorExists(CMonitor*);
|
|
PHLWINDOW vectorToWindowUnified(const Vector2D&, uint8_t properties, PHLWINDOW pIgnoreWindow = nullptr);
|
|
wlr_surface* vectorToLayerSurface(const Vector2D&, std::vector<PHLLS>*, Vector2D*, PHLLS*);
|
|
wlr_surface* vectorToLayerPopupSurface(const Vector2D&, CMonitor* monitor, Vector2D*, PHLLS*);
|
|
wlr_surface* vectorWindowToSurface(const Vector2D&, PHLWINDOW, Vector2D& sl);
|
|
Vector2D vectorToSurfaceLocal(const Vector2D&, PHLWINDOW, wlr_surface*);
|
|
CMonitor* getMonitorFromOutput(wlr_output*);
|
|
CMonitor* getRealMonitorFromOutput(wlr_output*);
|
|
PHLWINDOW getWindowFromSurface(wlr_surface*);
|
|
PHLWINDOW getWindowFromHandle(uint32_t);
|
|
bool isWorkspaceVisible(PHLWORKSPACE);
|
|
PHLWORKSPACE getWorkspaceByID(const int&);
|
|
PHLWORKSPACE getWorkspaceByName(const std::string&);
|
|
PHLWORKSPACE getWorkspaceByString(const std::string&);
|
|
void sanityCheckWorkspaces();
|
|
void updateWorkspaceWindowDecos(const int&);
|
|
void updateWorkspaceSpecialRenderData(const int&);
|
|
int getWindowsOnWorkspace(const int& id, std::optional<bool> onlyTiled = {}, std::optional<bool> onlyVisible = {});
|
|
int getGroupsOnWorkspace(const int& id, std::optional<bool> onlyTiled = {}, std::optional<bool> onlyVisible = {});
|
|
PHLWINDOW getUrgentWindow();
|
|
bool hasUrgentWindowOnWorkspace(const int&);
|
|
PHLWINDOW getFirstWindowOnWorkspace(const int&);
|
|
PHLWINDOW getTopLeftWindowOnWorkspace(const int&);
|
|
PHLWINDOW getFullscreenWindowOnWorkspace(const int&);
|
|
bool doesSeatAcceptInput(wlr_surface*);
|
|
bool isWindowActive(PHLWINDOW);
|
|
void changeWindowZOrder(PHLWINDOW, bool);
|
|
void cleanupFadingOut(const int& monid);
|
|
PHLWINDOW getWindowInDirection(PHLWINDOW, char);
|
|
PHLWINDOW getNextWindowOnWorkspace(PHLWINDOW, bool focusableOnly = false, std::optional<bool> floating = {});
|
|
PHLWINDOW getPrevWindowOnWorkspace(PHLWINDOW, bool focusableOnly = false, std::optional<bool> floating = {});
|
|
int getNextAvailableNamedWorkspace();
|
|
bool isPointOnAnyMonitor(const Vector2D&);
|
|
bool isPointOnReservedArea(const Vector2D& point, const CMonitor* monitor = nullptr);
|
|
CMonitor* getMonitorInDirection(const char&);
|
|
CMonitor* getMonitorInDirection(CMonitor*, const char&);
|
|
void updateAllWindowsAnimatedDecorationValues();
|
|
void updateWorkspaceWindows(const int64_t& id);
|
|
void updateWindowAnimatedDecorationValues(PHLWINDOW);
|
|
int getNextAvailableMonitorID(std::string const& name);
|
|
void moveWorkspaceToMonitor(PHLWORKSPACE, CMonitor*, bool noWarpCursor = false);
|
|
void swapActiveWorkspaces(CMonitor*, CMonitor*);
|
|
CMonitor* getMonitorFromString(const std::string&);
|
|
bool workspaceIDOutOfBounds(const int64_t&);
|
|
void setWindowFullscreen(PHLWINDOW, bool, eFullscreenMode mode = FULLSCREEN_INVALID);
|
|
void updateFullscreenFadeOnWorkspace(PHLWORKSPACE);
|
|
PHLWINDOW getX11Parent(PHLWINDOW);
|
|
void scheduleFrameForMonitor(CMonitor*);
|
|
void addToFadingOutSafe(PHLLS);
|
|
void addToFadingOutSafe(PHLWINDOW);
|
|
PHLWINDOW getWindowByRegex(const std::string&);
|
|
void warpCursorTo(const Vector2D&, bool force = false);
|
|
PHLLS getLayerSurfaceFromWlr(wlr_layer_surface_v1*);
|
|
PHLLS getLayerSurfaceFromSurface(wlr_surface*);
|
|
void closeWindow(PHLWINDOW);
|
|
Vector2D parseWindowVectorArgsRelative(const std::string&, const Vector2D&);
|
|
void forceReportSizesToWindowsOnWorkspace(const int&);
|
|
PHLWORKSPACE createNewWorkspace(const int&, const int&, const std::string& name = ""); // will be deleted next frame if left empty and unfocused!
|
|
void renameWorkspace(const int&, const std::string& name = "");
|
|
void setActiveMonitor(CMonitor*);
|
|
bool isWorkspaceSpecial(const int&);
|
|
int getNewSpecialID();
|
|
void performUserChecks();
|
|
void moveWindowToWorkspaceSafe(PHLWINDOW pWindow, PHLWORKSPACE pWorkspace);
|
|
PHLWINDOW getForceFocus();
|
|
void arrangeMonitors();
|
|
void enterUnsafeState();
|
|
void leaveUnsafeState();
|
|
void setPreferredScaleForSurface(wlr_surface* pSurface, double scale);
|
|
void setPreferredTransformForSurface(wlr_surface* pSurface, wl_output_transform transform);
|
|
void updateSuspendedStates();
|
|
PHLWINDOW windowForCPointer(CWindow*);
|
|
|
|
std::string explicitConfigPath;
|
|
|
|
private:
|
|
void initAllSignals();
|
|
void removeAllSignals();
|
|
void setRandomSplash();
|
|
void initManagers(eManagersInitStage stage);
|
|
void prepareFallbackOutput();
|
|
|
|
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"),
|
|
HYPRATOM("_KDE_NET_WM_WINDOW_TYPE_OVERRIDE"),
|
|
HYPRATOM("_NET_SUPPORTING_WM_CHECK"),
|
|
HYPRATOM("_NET_WM_NAME"),
|
|
HYPRATOM("UTF8_STRING")};
|