cry/Hyprland
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
Hyprland/src/desktop/DesktopTypes.hpp

27 lines
685 B
C++
Raw Normal View History

Workspace/core: Refactor workspace storage (#5380) * refactor workspaces to use ptrs * clang-format
2024-04-02 20:32:39 +01:00
#pragma once
desktop/DesktopTypes.hpp: fix include (#9104)
2025-01-17 18:35:39 +01:00
#include "../helpers/memory/Memory.hpp"
Workspace/core: Refactor workspace storage (#5380) * refactor workspaces to use ptrs * clang-format
2024-04-02 20:32:39 +01:00
class CWorkspace;
internal: new shared_ptr and weak_ptr implementation (#5883) moves std::shared_ptrs to a new implementation Advantages: - you can dereference a weak_ptr directly. This will obviously segfault on a nullptr deref if it's expired. - this is useful to avoid the .lock() hell where we are 100% sure the pointer _should_ be valid. (and if it isn't, it should throw.) - weak_ptrs are still valid while the SP is being destroyed. - reasoning: while an object (e.g. CWindow) is being destroyed, its `weak_ptr self` should be accessible (the sp is still alive, and so is CWindow), but it's not because by stl it's already expired (to prevent resurrection) - this impl solves it differently. w_p is expired, but can still be dereferenced and used. Creating `s_p`s is not possible anymore, though. - this is useful in destructors and callbacks.
2024-05-05 17:16:00 +01:00
class CWindow;
class CLayerSurface;
internal: Move CMonitor to SP (#8178) * move monitors to sp * XD
2024-10-19 23:03:29 +01:00
class CMonitor;
internal: new shared_ptr and weak_ptr implementation (#5883) moves std::shared_ptrs to a new implementation Advantages: - you can dereference a weak_ptr directly. This will obviously segfault on a nullptr deref if it's expired. - this is useful to avoid the .lock() hell where we are 100% sure the pointer _should_ be valid. (and if it isn't, it should throw.) - weak_ptrs are still valid while the SP is being destroyed. - reasoning: while an object (e.g. CWindow) is being destroyed, its `weak_ptr self` should be accessible (the sp is still alive, and so is CWindow), but it's not because by stl it's already expired (to prevent resurrection) - this impl solves it differently. w_p is expired, but can still be dereferenced and used. Creating `s_p`s is not possible anymore, though. - this is useful in destructors and callbacks.
2024-05-05 17:16:00 +01:00
/* Shared pointer to a workspace */
refactor: replace all `typedef` with `using` (#10594)
2025-05-31 18:02:02 +05:00
using PHLWORKSPACE = SP<CWorkspace>;
internal: new shared_ptr and weak_ptr implementation (#5883) moves std::shared_ptrs to a new implementation Advantages: - you can dereference a weak_ptr directly. This will obviously segfault on a nullptr deref if it's expired. - this is useful to avoid the .lock() hell where we are 100% sure the pointer _should_ be valid. (and if it isn't, it should throw.) - weak_ptrs are still valid while the SP is being destroyed. - reasoning: while an object (e.g. CWindow) is being destroyed, its `weak_ptr self` should be accessible (the sp is still alive, and so is CWindow), but it's not because by stl it's already expired (to prevent resurrection) - this impl solves it differently. w_p is expired, but can still be dereferenced and used. Creating `s_p`s is not possible anymore, though. - this is useful in destructors and callbacks.
2024-05-05 17:16:00 +01:00
/* Weak pointer to a workspace */
refactor: replace all `typedef` with `using` (#10594)
2025-05-31 18:02:02 +05:00
using PHLWORKSPACEREF = WP<CWorkspace>;
internal: new shared_ptr and weak_ptr implementation (#5883) moves std::shared_ptrs to a new implementation Advantages: - you can dereference a weak_ptr directly. This will obviously segfault on a nullptr deref if it's expired. - this is useful to avoid the .lock() hell where we are 100% sure the pointer _should_ be valid. (and if it isn't, it should throw.) - weak_ptrs are still valid while the SP is being destroyed. - reasoning: while an object (e.g. CWindow) is being destroyed, its `weak_ptr self` should be accessible (the sp is still alive, and so is CWindow), but it's not because by stl it's already expired (to prevent resurrection) - this impl solves it differently. w_p is expired, but can still be dereferenced and used. Creating `s_p`s is not possible anymore, though. - this is useful in destructors and callbacks.
2024-05-05 17:16:00 +01:00
/* Shared pointer to a window */
refactor: replace all `typedef` with `using` (#10594)
2025-05-31 18:02:02 +05:00
using PHLWINDOW = SP<CWindow>;
internal: new shared_ptr and weak_ptr implementation (#5883) moves std::shared_ptrs to a new implementation Advantages: - you can dereference a weak_ptr directly. This will obviously segfault on a nullptr deref if it's expired. - this is useful to avoid the .lock() hell where we are 100% sure the pointer _should_ be valid. (and if it isn't, it should throw.) - weak_ptrs are still valid while the SP is being destroyed. - reasoning: while an object (e.g. CWindow) is being destroyed, its `weak_ptr self` should be accessible (the sp is still alive, and so is CWindow), but it's not because by stl it's already expired (to prevent resurrection) - this impl solves it differently. w_p is expired, but can still be dereferenced and used. Creating `s_p`s is not possible anymore, though. - this is useful in destructors and callbacks.
2024-05-05 17:16:00 +01:00
/* Weak pointer to a window */
refactor: replace all `typedef` with `using` (#10594)
2025-05-31 18:02:02 +05:00
using PHLWINDOWREF = WP<CWindow>;
Workspace/core: Refactor workspace storage (#5380) * refactor workspaces to use ptrs * clang-format
2024-04-02 20:32:39 +01:00
internal: new shared_ptr and weak_ptr implementation (#5883) moves std::shared_ptrs to a new implementation Advantages: - you can dereference a weak_ptr directly. This will obviously segfault on a nullptr deref if it's expired. - this is useful to avoid the .lock() hell where we are 100% sure the pointer _should_ be valid. (and if it isn't, it should throw.) - weak_ptrs are still valid while the SP is being destroyed. - reasoning: while an object (e.g. CWindow) is being destroyed, its `weak_ptr self` should be accessible (the sp is still alive, and so is CWindow), but it's not because by stl it's already expired (to prevent resurrection) - this impl solves it differently. w_p is expired, but can still be dereferenced and used. Creating `s_p`s is not possible anymore, though. - this is useful in destructors and callbacks.
2024-05-05 17:16:00 +01:00
/* Shared pointer to a layer surface */
refactor: replace all `typedef` with `using` (#10594)
2025-05-31 18:02:02 +05:00
using PHLLS = SP<CLayerSurface>;
internal: new shared_ptr and weak_ptr implementation (#5883) moves std::shared_ptrs to a new implementation Advantages: - you can dereference a weak_ptr directly. This will obviously segfault on a nullptr deref if it's expired. - this is useful to avoid the .lock() hell where we are 100% sure the pointer _should_ be valid. (and if it isn't, it should throw.) - weak_ptrs are still valid while the SP is being destroyed. - reasoning: while an object (e.g. CWindow) is being destroyed, its `weak_ptr self` should be accessible (the sp is still alive, and so is CWindow), but it's not because by stl it's already expired (to prevent resurrection) - this impl solves it differently. w_p is expired, but can still be dereferenced and used. Creating `s_p`s is not possible anymore, though. - this is useful in destructors and callbacks.
2024-05-05 17:16:00 +01:00
/* Weak pointer to a layer surface */
refactor: replace all `typedef` with `using` (#10594)
2025-05-31 18:02:02 +05:00
using PHLLSREF = WP<CLayerSurface>;
internal: Move CMonitor to SP (#8178) * move monitors to sp * XD
2024-10-19 23:03:29 +01:00
/* Shared pointer to a monitor */
refactor: replace all `typedef` with `using` (#10594)
2025-05-31 18:02:02 +05:00
using PHLMONITOR = SP<CMonitor>;
internal: Move CMonitor to SP (#8178) * move monitors to sp * XD
2024-10-19 23:03:29 +01:00
/* Weak pointer to a monitor */
refactor: replace all `typedef` with `using` (#10594)
2025-05-31 18:02:02 +05:00
using PHLMONITORREF = WP<CMonitor>;
Reference in a new issue Copy permalink