Style fixes
[pulseview.git] / pv / prop / enum.cpp
1 /*
2  * This file is part of the PulseView project.
3  *
4  * Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <cassert>
21 #include <cfloat>
22 #include <cmath>
23 #include <limits>
24 #include <vector>
25
26 #include <QComboBox>
27 #include <QDebug>
28 #include <QHBoxLayout>
29 #include <QLabel>
30 #include <QSlider>
31
32 #include <libsigrokcxx/libsigrokcxx.hpp>
33
34 #include "enum.hpp"
35
36 using std::abs;
37 // Note that "using std::isnan;" is _not_ put here since that would break
38 // compilation on some platforms. Use "std::isnan()" instead in checks below.
39 using std::numeric_limits;
40 using std::pair;
41 using std::vector;
42
43 namespace pv {
44 namespace prop {
45
46 Enum::Enum(QString name, QString desc,
47         vector<pair<Glib::VariantBase, QString> > values,
48         Getter getter, Setter setter) :
49         Property(name, desc, getter, setter),
50         values_(values),
51         is_range_(false),
52         selector_(nullptr),
53         slider_layout_widget_(nullptr),
54         slider_(nullptr),
55         slider_label_(nullptr)
56 {
57         // Try to determine whether the values make up a range, created by e.g.
58         // std_gvar_min_max_step_thresholds()
59
60         vector<double> deltas;
61         double prev_value = 0;
62
63         for (const pair<Glib::VariantBase, QString> &v : values_) {
64                 gdouble value;
65                 if (v.first.is_of_type(Glib::VariantType("d"))) {
66                         g_variant_get((GVariant*)(v.first.gobj()), "d", &value);
67                 } else if (v.first.is_of_type(Glib::VariantType("(dd)"))) {
68                         gdouble dummy;
69                         g_variant_get((GVariant*)(v.first.gobj()), "(dd)", &value, &dummy);
70                 } else
71                         break; // Type not d or (dd), so not a range that we can handle
72                 deltas.push_back(value - prev_value);
73                 prev_value = value;
74         }
75
76         if (deltas.size() > 0) {
77                 bool constant_delta = true;
78                 double prev_delta = numeric_limits<double>::quiet_NaN();
79
80                 bool skip_first = true;
81                 for (double delta : deltas) {
82                         // First value is incorrect, it's the delta to 0 since no
83                         // previous value existed yet
84                         if (skip_first) {
85                                 skip_first = false;
86                                 continue;
87                         }
88                         if (std::isnan(prev_delta))
89                                 prev_delta = delta;
90
91                         // 2*DBL_EPSILON doesn't work here, so use a workaround
92                         if (abs(delta - prev_delta) > (delta/10))
93                                 constant_delta = false;
94
95                         prev_delta = delta;
96                 }
97
98                 if (constant_delta)
99                         is_range_ = true;
100         }
101 }
102
103 QWidget* Enum::get_widget(QWidget *parent, bool auto_commit)
104 {
105         if (!getter_)
106                 return nullptr;
107
108         Glib::VariantBase variant;
109
110         try {
111                  variant = getter_();
112         } catch (const sigrok::Error &e) {
113                 qWarning() << tr("Querying config key %1 resulted in %2").arg(name_, e.what());
114                 return nullptr;
115         }
116
117         if (!variant.gobj())
118                 return nullptr;
119
120         if (is_range_) {
121                 // Use slider
122                 if (slider_layout_widget_)
123                         return slider_layout_widget_;
124
125                 slider_ = new QSlider();
126                 // Sliders can't handle float values, so we just use it to specify
127                 // the number of steps that we're away from the range's beginning
128                 slider_->setOrientation(Qt::Horizontal);
129                 slider_->setMinimum(0);
130                 slider_->setMaximum(values_.size() - 1);
131                 slider_->setSingleStep(1);
132
133                 slider_label_ = new QLabel();
134
135                 slider_layout_widget_ = new QWidget(parent);
136                 QHBoxLayout *layout = new QHBoxLayout(slider_layout_widget_);
137                 layout->addWidget(slider_);
138                 layout->addWidget(slider_label_);
139
140                 update_widget();
141
142                 if (auto_commit)
143                         connect(slider_, SIGNAL(valueChanged(int)),
144                                 this, SLOT(on_value_changed(int)));
145
146                 return slider_layout_widget_;
147
148         } else {
149                 // Use combo box
150                 if (selector_)
151                         return selector_;
152
153                 selector_ = new QComboBox(parent);
154                 for (unsigned int i = 0; i < values_.size(); i++) {
155                         const pair<Glib::VariantBase, QString> &v = values_[i];
156                         selector_->addItem(v.second, qVariantFromValue(v.first));
157                 }
158
159                 update_widget();
160
161                 if (auto_commit)
162                         connect(selector_, SIGNAL(currentIndexChanged(int)),
163                                 this, SLOT(on_current_index_changed(int)));
164
165                 return selector_;
166         }
167 }
168
169 void Enum::update_widget()
170 {
171         Glib::VariantBase variant;
172
173         try {
174                 variant = getter_();
175         } catch (const sigrok::Error &e) {
176                 qWarning() << tr("Querying config key %1 resulted in %2").arg(name_, e.what());
177                 return;
178         }
179
180         assert(variant.gobj());
181
182         if (is_range_) {
183
184                 // Use slider
185                 if (!slider_layout_widget_)
186                         return;
187
188                 for (unsigned int i = 0; i < values_.size(); i++) {
189                         const pair<Glib::VariantBase, QString> &v = values_[i];
190
191                         // g_variant_equal() doesn't handle floating point properly
192                         if (v.first.is_of_type(Glib::VariantType("d"))) {
193                                 gdouble a, b;
194                                 g_variant_get(variant.gobj(), "d", &a);
195                                 g_variant_get((GVariant*)(v.first.gobj()), "d", &b);
196
197                                 if (abs(a - b) <= 2 * DBL_EPSILON) {
198                                         slider_->setValue(i);
199                                         slider_label_->setText(v.second);
200                                 }
201                         } else {
202                                 // Check for "(dd)" type and handle it if it's found
203                                 if (v.first.is_of_type(Glib::VariantType("(dd)"))) {
204                                         gdouble a1, a2, b1, b2;
205                                         g_variant_get(variant.gobj(), "(dd)", &a1, &a2);
206                                         g_variant_get((GVariant*)(v.first.gobj()), "(dd)", &b1, &b2);
207
208                                         if ((abs(a1 - b1) <= 2 * DBL_EPSILON) && \
209                                                 (abs(a2 - b2) <= 2 * DBL_EPSILON)) {
210                                                 slider_->setValue(i);
211                                                 slider_label_->setText(v.second);
212                                         }
213
214                                 } else {
215                                         qWarning() << "Enum property" << name() << "encountered unsupported type";
216                                         return;
217                                 }
218                         }
219                 }
220
221         } else {
222                 // Use combo box
223                 if (!selector_)
224                         return;
225
226                 for (unsigned int i = 0; i < values_.size(); i++) {
227                         const pair<Glib::VariantBase, QString> &v = values_[i];
228
229                         // g_variant_equal() doesn't handle floating point properly
230                         if (v.first.is_of_type(Glib::VariantType("d"))) {
231                                 gdouble a, b;
232                                 g_variant_get(variant.gobj(), "d", &a);
233                                 g_variant_get((GVariant*)(v.first.gobj()), "d", &b);
234                                 if (abs(a - b) <= 2 * DBL_EPSILON)
235                                         selector_->setCurrentIndex(i);
236                         } else {
237                                 // Check for "(dd)" type and handle it if it's found
238                                 if (v.first.is_of_type(Glib::VariantType("(dd)"))) {
239                                         gdouble a1, a2, b1, b2;
240                                         g_variant_get(variant.gobj(), "(dd)", &a1, &a2);
241                                         g_variant_get((GVariant*)(v.first.gobj()), "(dd)", &b1, &b2);
242                                         if ((abs(a1 - b1) <= 2 * DBL_EPSILON) && \
243                                                 (abs(a2 - b2) <= 2 * DBL_EPSILON))
244                                                 selector_->setCurrentIndex(i);
245
246                                 } else
247                                         // Handle all other types
248                                         if (v.first.equal(variant))
249                                                 selector_->setCurrentIndex(i);
250                         }
251                 }
252         }
253 }
254
255 void Enum::commit()
256 {
257         assert(setter_);
258
259         if (is_range_) {
260                 // Use slider
261                 if (!slider_layout_widget_)
262                         return;
263
264                 setter_(values_.at(slider_->value()).first);
265
266                 update_widget();
267         } else {
268                 // Use combo box
269                 if (!selector_)
270                         return;
271
272                 const int index = selector_->currentIndex();
273                 if (index < 0)
274                         return;
275
276                 setter_(selector_->itemData(index).value<Glib::VariantBase>());
277
278                 // The combo box needs no update, it already shows the current value
279                 // by definition: the user picked it
280         }
281 }
282
283 void Enum::on_current_index_changed(int)
284 {
285         commit();
286 }
287
288 void Enum::on_value_changed(int)
289 {
290         commit();
291 }
292
293 }  // namespace prop
294 }  // namespace pv