summaryrefslogtreecommitdiff
path: root/src/config/ConfigManager.hpp
blob: 7f51f7e7f45ec9a308cbac60f3685d97a187085b (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
#pragma once

#define CONFIG_MANAGER_H

#include <map>
#include "../debug/Log.hpp"
#include <unordered_map>
#include "../defines.hpp"
#include <vector>
#include <deque>
#include <algorithm>
#include <regex>
#include "../Window.hpp"

#include "defaultConfig.hpp"

#define STRVAL_EMPTY "[[EMPTY]]"

struct SConfigValue {
    int64_t intValue = -1;
    float floatValue = -1;
    std::string strValue = "";

    bool set = false; // used for device configs
};

struct SMonitorRule {
    std::string name = "";
    Vector2D    resolution = Vector2D(1280,720);
    Vector2D    offset = Vector2D(0,0);
    float       scale = 1;
    float       refreshRate = 60;
    std::string defaultWorkspace = "";
    bool        disabled = false;
    wl_output_transform transform = WL_OUTPUT_TRANSFORM_NORMAL;
};

struct SMonitorAdditionalReservedArea {
    int         top = 0;
    int         bottom = 0;
    int         left = 0;
    int         right = 0;
};

struct SWindowRule {
    std::string szRule;
    std::string szValue;
};

class CConfigManager {
public:
    CConfigManager();

    void                tick();
    void                init();

    int                 getInt(const std::string&);
    float               getFloat(const std::string&);
    std::string         getString(const std::string&);
    void                setFloat(std::string, float);
    void                setInt(std::string, int);
    void                setString(std::string, std::string);

    int                 getDeviceInt(const std::string&, const std::string&);
    float               getDeviceFloat(const std::string&, const std::string&);
    std::string         getDeviceString(const std::string&, const std::string&);
    bool                deviceConfigExists(const std::string&);
    bool                shouldBlurLS(const std::string&);

    SConfigValue*       getConfigValuePtr(std::string);

    SMonitorRule        getMonitorRuleFor(std::string);

    std::vector<SWindowRule> getMatchingRules(CWindow*);

    std::unordered_map<std::string, SMonitorAdditionalReservedArea> m_mAdditionalReservedAreas;

    // no-op when done.
    void                dispatchExecOnce();

    void                performMonitorReload();
    bool                m_bWantsMonitorReload = false;
    bool                m_bForceReload = false;

    std::string         parseKeyword(const std::string&, const std::string&, bool dynamic = false);

private:
    std::deque<std::string>                       configPaths; // stores all the config paths
    std::unordered_map<std::string, time_t>       configModifyTimes; // stores modify times
    std::unordered_map<std::string, std::string>  configDynamicVars; // stores dynamic vars declared by the user
    std::unordered_map<std::string, SConfigValue> configValues;
    std::unordered_map<std::string, std::unordered_map<std::string, SConfigValue>> deviceConfigs; // stores device configs

    std::string                                   configCurrentPath;

    std::string currentCategory = "";  // For storing the category of the current item

    std::string parseError = "";  // For storing a parse error to display later

    std::string m_szCurrentSubmap = ""; // For storing the current keybind submap

    bool isFirstLaunch = true;  // For exec-once

    std::deque<SMonitorRule> m_dMonitorRules;
    std::deque<SWindowRule> m_dWindowRules;
    std::deque<std::string> m_dBlurLSNamespaces;

    bool firstExecDispatched = false;
    std::deque<std::string> firstExecRequests;

    // internal methods
    void                setDefaultVars();
    void                setDeviceDefaultVars(const std::string&);

    void                applyUserDefinedVars(std::string&, const size_t);
    void                loadConfigLoadVars();
    SConfigValue        getConfigValueSafe(const std::string&);
    SConfigValue        getConfigValueSafeDevice(const std::string&, const std::string&);
    void                parseLine(std::string&);
    void                configSetValueSafe(const std::string&, const std::string&);
    void                handleDeviceConfig(const std::string&, const std::string&);
    void                handleRawExec(const std::string&, const std::string&);
    void                handleMonitor(const std::string&, const std::string&);
    void                handleBind(const std::string&, const std::string&);
    void                handleUnbind(const std::string&, const std::string&);
    void                handleWindowRule(const std::string&, const std::string&);
    void                handleDefaultWorkspace(const std::string&, const std::string&);
    void                handleBezier(const std::string&, const std::string&);
    void                handleAnimation(const std::string&, const std::string&);
    void                handleSource(const std::string&, const std::string&);
    void                handleSubmap(const std::string&, const std::string&);
    void                handleBlurLS(const std::string&, const std::string&);
};

inline std::unique_ptr<CConfigManager> g_pConfigManager;