aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/managers/SessionLockManager.hpp
blob: 9b3b882cc1d64ae9f80d64b254d8000006840669 (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
#pragma once

#include "../defines.hpp"
#include "../helpers/Timer.hpp"
#include "../helpers/signal/Signal.hpp"
#include <cstdint>
#include <unordered_map>
#include <unordered_set>

class CSessionLockSurface;
class CSessionLock;
class CWLSurfaceResource;

struct SSessionLockSurface {
    SSessionLockSurface(SP<CSessionLockSurface> surface_);

    WP<CSessionLockSurface> surface;
    WP<CWLSurfaceResource>  pWlrSurface;
    uint64_t                iMonitorID = -1;

    bool                    mapped = false;

    struct {
        CHyprSignalListener map;
        CHyprSignalListener destroy;
        CHyprSignalListener commit;
    } listeners;
};

struct SSessionLock {
    WP<CSessionLock>                                  lock;

    std::vector<std::unique_ptr<SSessionLockSurface>> vSessionLockSurfaces;
    std::unordered_map<uint64_t, CTimer>              mMonitorsWithoutMappedSurfaceTimers;

    struct {
        CHyprSignalListener newSurface;
        CHyprSignalListener unlock;
        CHyprSignalListener destroy;
    } listeners;

    bool                         m_hasSentLocked = false;
    std::unordered_set<uint64_t> m_lockedMonitors;
};

class CSessionLockManager {
  public:
    CSessionLockManager();
    ~CSessionLockManager() = default;

    SSessionLockSurface* getSessionLockSurfaceForMonitor(uint64_t);

    float                getRedScreenAlphaForMonitor(uint64_t);

    bool                 isSessionLocked();
    bool                 isSessionLockPresent();
    bool                 isSurfaceSessionLock(SP<CWLSurfaceResource>);
    bool                 anySessionLockSurfacesPresent();

    void                 removeSessionLockSurface(SSessionLockSurface*);

    void                 onLockscreenRenderedOnMonitor(uint64_t id);

  private:
    UP<SSessionLock> m_pSessionLock;

    struct {
        CHyprSignalListener newLock;
    } listeners;

    void onNewSessionLock(SP<CSessionLock> pWlrLock);
};

inline std::unique_ptr<CSessionLockManager> g_pSessionLockManager;