Line data Source code
1 : #pragma once
2 :
3 : #include "Selectable.hpp"
4 : #include <AH/Containers/Updatable.hpp>
5 : #include <AH/Debug/Debug.hpp>
6 : #include <Def/Def.hpp>
7 :
8 : BEGIN_CS_NAMESPACE
9 :
10 : /**
11 : * @brief An enumeration to set the behavior of selectors that are incremented
12 : * (decremented) beyond their maximum (minimum) setting.
13 : */
14 : enum class Wrap : bool {
15 : Clamp = false, ///< When the maximum (minimum) setting is reached,
16 : ///< clamp to the maximum (minimum) setting.
17 : Wrap = true, ///< When the maximum (minimum) setting is reached,
18 : ///< wrap around to the minimum (maximum) setting.
19 : NoWrap = false,
20 : };
21 :
22 : /// A callback for the GenericSelector class that does nothing.
23 : struct EmptySelectorCallback {
24 : /// Initialize.
25 7 : void begin() {}
26 : /// Refresh, called periodically.
27 26 : void update() {}
28 : /// Called when the setting changes.
29 23 : void update(setting_t oldSetting, setting_t newSetting) {
30 : (void)oldSetting, (void)newSetting;
31 23 : }
32 : };
33 :
34 : /// Base class for all Selectors exposing the `get` method, so it can be used
35 : /// by display elements etc, without having to provide the full generic type.
36 : ///
37 : /// A `set` method is not provided, because that would require either more
38 : /// virtual functions, or a rather large refactoring.
39 : class SelectorBase {
40 : protected:
41 : /// Constructor.
42 19 : SelectorBase() = default;
43 :
44 : public:
45 : /// Get the current selection/setting.
46 44 : setting_t get() const { return setting; }
47 :
48 : protected:
49 : /// The selection of the selector. It is saved in the selector as well as
50 : /// the selectable, because you need it in order to implement
51 : /// increment/decrement methods.
52 : setting_t setting = 0;
53 : };
54 :
55 : template <setting_t N, class Callback = EmptySelectorCallback>
56 : class GenericSelector : public SelectorBase, public AH::Updatable<> {
57 : public:
58 : /**
59 : * @brief Constructor.
60 : *
61 : * @param selectable
62 : * The selectable object to manage. When the value of the selector
63 : * changes, it changes the selection of this selectable.
64 : * @param callback
65 : * The callback to call when the value changes. Used for (visual)
66 : * feedback from the selector (e.g. LEDs or some different kind of
67 : * display).
68 : */
69 19 : GenericSelector(Selectable<N> &selectable, const Callback &callback)
70 19 : : selectable(selectable), callback(callback) {}
71 :
72 7 : void begin() override {
73 7 : callback.begin();
74 7 : reset();
75 7 : }
76 :
77 26 : void update() override { callback.update(); }
78 :
79 : /// Reset the selection to the initial selection.
80 8 : void reset() {
81 8 : setting_t initialSelection = selectable.getInitialSelection();
82 8 : selectable.select(initialSelection);
83 8 : callback.update(initialSelection, initialSelection);
84 8 : this->setting = initialSelection;
85 8 : }
86 :
87 : /**
88 : * @brief Select the given selection
89 : *
90 : * @param newSetting
91 : * The new setting to select [0, N-1].
92 : */
93 15 : void set(setting_t newSetting) {
94 15 : newSetting = selectable.validateSetting(newSetting);
95 15 : selectable.select(newSetting);
96 15 : if (get() != newSetting) {
97 15 : callback.update(get(), newSetting);
98 15 : this->setting = newSetting;
99 : }
100 15 : }
101 :
102 : /**
103 : * @brief Add one to the setting, wrap around or clamp, depending on the
104 : * parameter, if the new setting would be out of range.
105 : *
106 : * @param wrap
107 : * Wrap or clamp if the new setting would be out of range.
108 : */
109 8 : void increment(Wrap wrap) {
110 8 : setting_t setting = this->get();
111 8 : setting++;
112 8 : if (setting == N) {
113 3 : if (wrap == Wrap::Wrap)
114 2 : setting = 0;
115 : else
116 1 : return;
117 : }
118 7 : this->set(setting);
119 : }
120 :
121 : /**
122 : * @brief Subtract one from the setting, wrap around or clamp, depending
123 : * on the parameter, if the new setting would be out of range.
124 : *
125 : * @param wrap
126 : * Wrap or clamp if the new setting would be out of range.
127 : */
128 5 : void decrement(Wrap wrap) {
129 5 : setting_t setting = this->get();
130 5 : if (setting == 0) {
131 2 : if (wrap == Wrap::Wrap)
132 1 : setting = N;
133 : else
134 1 : return;
135 : }
136 4 : setting--;
137 4 : this->set(setting);
138 : }
139 :
140 : private:
141 : Selectable<N> &selectable;
142 :
143 : public:
144 : Callback callback;
145 : };
146 :
147 : /**
148 : * @brief A Selector with an empty callback.
149 : *
150 : * @tparam N
151 : * The number of possible settings.
152 : */
153 : template <setting_t N>
154 : class Selector : public GenericSelector<N> {
155 : public:
156 : /// Constructor
157 : Selector(Selectable<N> &selectable) : GenericSelector<N> {selectable, {}} {}
158 : };
159 :
160 : END_CS_NAMESPACE
|
