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
|
/*
* This file is part of the PulseView project.
*
* Copyright (C) 2015 Joel Holdsworth <joel@airwebreathe.org.uk>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#include <cassert>
#include <iostream>
#include <utility>
#include <boost/none_t.hpp>
#include <libsigrokcxx/libsigrokcxx.hpp>
#include <pv/prop/bool.hpp>
#include <pv/prop/double.hpp>
#include <pv/prop/enum.hpp>
#include <pv/prop/int.hpp>
#include <pv/prop/string.hpp>
#include "inputoutput.hpp"
using boost::none;
using std::map;
using std::pair;
using std::shared_ptr;
using std::string;
using std::vector;
using Glib::VariantBase;
using Glib::VariantType;
using sigrok::Option;
using pv::prop::Bool;
using pv::prop::Double;
using pv::prop::Enum;
using pv::prop::Int;
using pv::prop::Property;
using pv::prop::String;
namespace pv {
namespace binding {
InputOutput::InputOutput(
const map<string, shared_ptr<Option>> &options)
{
for (const pair<string, shared_ptr<Option>>& o : options) {
const shared_ptr<Option> &opt = o.second;
assert(opt);
const QString name = QString::fromStdString(opt->name());
const QString desc = QString::fromStdString(opt->description());
const VariantBase def_val = opt->default_value();
const vector<VariantBase> values = opt->values();
options_[opt->id()] = def_val;
const Property::Getter get = [&, opt]() {
return options_[opt->id()]; };
const Property::Setter set = [&, opt](VariantBase value) {
options_[opt->id()] = value; };
shared_ptr<Property> prop;
if (!opt->values().empty())
prop = bind_enum(name, desc, values, get, set);
else if (def_val.is_of_type(VariantType("b")))
prop = shared_ptr<Property>(new Bool(name, desc, get, set));
else if (def_val.is_of_type(VariantType("d")))
prop = shared_ptr<Property>(new Double(name, desc, 2, "",
none, none, get, set));
else if (def_val.is_of_type(VariantType("i")) ||
def_val.is_of_type(VariantType("t")) ||
def_val.is_of_type(VariantType("u")))
prop = shared_ptr<Property>(
new Int(name, desc, "", none, get, set));
else if (def_val.is_of_type(VariantType("s")))
prop = shared_ptr<Property>(
new String(name, desc, get, set));
else
continue;
properties_.push_back(prop);
}
}
const map<string, VariantBase>& InputOutput::options() const
{
return options_;
}
shared_ptr<Property> InputOutput::bind_enum(
const QString &name, const QString &desc, const vector<VariantBase> &values,
Property::Getter getter, Property::Setter setter)
{
vector< pair<VariantBase, QString> > enum_vals;
for (VariantBase var : values)
enum_vals.emplace_back(var, print_gvariant(var));
return shared_ptr<Property>(new Enum(name, desc, enum_vals, getter, setter));
}
} // namespace binding
} // namespace pv
|
