45 static struct midi_std_init {
49 { 0,
"Bank Select MSB"},
50 { 1,
"Modulation MSB"},
51 { 2,
"Breath Controller"},
53 { 4,
"Foot Controller MSB"},
54 { 5,
"Portamento Time MSB"},
55 { 6,
"Data Entry MSB"},
61 {12,
"Effect Control 1"},
62 {13,
"Effect Control 2"},
64 {22,
"Midi Beat Clock"},
65 {23,
"Clock start/stop"},
66 {24,
"Jack Transport"},
68 {32,
"Bank Select LSB"},
74 {68,
"Legato Footswitch"},
76 {70,
"Sound Contr. 1"},
77 {71,
"Sound Contr. 2"},
78 {72,
"Sound Contr. 3"},
79 {73,
"Sound Contr. 4"},
80 {74,
"Sound Contr. 5"},
81 {75,
"Sound Contr. 6"},
82 {76,
"Sound Contr. 7"},
83 {77,
"Sound Contr. 8"},
84 {78,
"Sound Contr. 9"},
85 {79,
"Sound Contr. 10"},
87 {84,
"Portamento Control"},
101 {120,
"All Sounds Off"},
102 {121,
"Controller Reset"},
103 {122,
"Local Control"},
104 {123,
"All Notes Off"},
107 {126,
"Mono On (Poly Off)"},
108 {127,
"Poly On (Mono Off)"},
111 string MidiStandardControllers::midi_to_note(
int ctr) {
112 static const char* notes[12] = {
"C",
"C#",
"D",
"D#",
"E",
"F",
"F#",
"G",
"G#",
"A",
"A#",
"B" };
113 int octave = (ctr / 12) - 1;
116 string p = b.str().substr(0, 1);
117 int index = (ctr % 12);
118 string note = notes[index];
122 string MidiStandardControllers::ctr_desc(
int ctr) {
123 string p = midi_to_note(ctr-200);
124 return "Note On ( " + p +
" )";
128 for (
unsigned int i = 0; i <
sizeof(midi_std_itab)/
sizeof(midi_std_itab[0]); i++) {
129 m.insert(pair<int, modstring>(midi_std_itab[i].ctrl, modstring(midi_std_itab[i].name)));
131 for (
unsigned int i = 0; i < 127; i++) {
132 const int mm = i + 200;
133 m.insert(pair<int, modstring>(mm, modstring(ctr_desc(mm).c_str())));
138 map<int, modstring>::iterator i = m.find(ctr);
141 if (i->second.modified) {
143 i->second.name = m[ctr].std;
144 m[ctr].modified =
false;
152 m[ctr] = modstring(name,
true, 0);
154 i->second.modified =
true;
155 i->second.name = name;
162 for (map<int, modstring>::const_iterator i = m.begin(); i != m.end(); ++i) {
163 if (i->second.modified) {
166 jw.
write_kv(ostr.str().c_str(), i->second.name);
203 jw.
write(_toggle_behaviour);
212 if (!pmap.
hasId(
id)) {
214 _(
"unknown parameter: ") +
id);
218 Parameter& pm = pmap[id];
232 pmin = pm.getLowerAsFloat();
233 pmax = pm.getUpperAsFloat();
244 }
else if (
lower < pmin) {
251 }
else if (
upper < pmin) {
288 _(
"recall MIDI state"),
289 _(
"invalid format, Parameter skipped: ") +
id);
294 _(
"recall MIDI state"),
295 _(
"Parameter range outside bounds, changed: ") +
id);
304 switch (_toggle_behaviour) {
305 case Parameter::toggle_type::OnOff: {
306 bool s_o = (2*last_value > 127);
307 bool s_n = (2*n > 127);
310 ret = param->midi_set(0, 127, _lower, _upper);
312 ret = param->midi_set(127, 127, _lower, _upper);
317 case Parameter::toggle_type::Constant: {
318 if (n == last_value || last_value == -1) {
320 if (!update) ret = param->midi_set(0, n, _lower, _upper);
321 else ret = param->midi_set(127, n, _lower, _upper);
323 if (!update) ret = param->midi_set(127, n, _lower, _upper);
324 else ret = param->midi_set(0, n, _lower, _upper);
334 ret = param->midi_set(n, 127, _lower, _upper);
335 param->trigger_changed();
344 if (strcmp(param->
id().c_str(),
"engine.mute")==0) {
345 if ( n == 0) n = 127;
348 ret = param->midi_set(n, 127, _lower, _upper);
356 bool s_o = (2*last_value > 360);
357 bool s_n = (2*n > 360);
360 ret = param->midi_set_bpm(0, 360, _lower, _upper);
362 ret = param->midi_set_bpm(360, 360, _lower, _upper);
366 ret = param->midi_set_bpm(n, 360, _lower, _upper);
376 for (
unsigned int n = 0; n <
array_size; n++) {
377 operator[](n).clear();
398 for (
unsigned int n = 0; n <
array_size; n++) {
404 for (midi_controller_list::const_iterator i = cl.begin(); i != cl.end(); ++i)
413 for (ControllerArray::size_type n = 0; n < size(); ++n) {
415 for (midi_controller_list::const_iterator i = cl.begin(); i != cl.end(); ++i) {
416 if (i->hasParameter(param)) {
428 for (iterator pctr = begin(); pctr !=
end(); ++pctr) {
429 for (midi_controller_list::iterator i = pctr->begin(); i != pctr->end(); ++i) {
430 if (i->hasParameter(p)) {
455 if (f >= 0x1.0p23)
return (
unsigned int) f;
456 return (
unsigned int) (f + 0.49999997f);
462 if ((time-time1)> (1.05*time_diff) || (time-time1)*1.05 < (time_diff)) {
467 bpm_new = ((1000000000. / (time-time1) / 24) * 60);
471 if (collect >= (bpm_new*bpm_new*0.0002)+1) {
482 time_diff = time-time1;
493 last_midi_control_value(),
494 last_midi_control(-2),
495 changed_midi_control_value(),
510 midi_value_changed() {
512 last_midi_control_value[i] = -1;
513 changed_midi_control_value[i] = 0;
515 pgm_chg.connect(sigc::mem_fun(*
this, &MidiControllerList::on_pgm_chg));
516 mute_chg.connect(sigc::mem_fun(*
this, &MidiControllerList::on_mute_chg));
517 bank_chg.connect(sigc::mem_fun(*
this, &MidiControllerList::on_bank_chg));
518 val_chg.connect(sigc::mem_fun(*
this, &MidiControllerList::on_val_chg));
523 bool MidiControllerList::check_midi_values() {
526 if (changed_midi_control_value[n]) {
527 changed_midi_control_value[n] = 0;
528 saved_values[n] = last_midi_control_value[n];
529 midi_value_changed(n, saved_values[n]);
532 for (midi_controller_list::iterator i = ctr_list.begin(); i != ctr_list.end(); ++i) {
534 && i->toggle_behaviour() == Parameter::toggle_type::Constant) {
535 midi_value_changed(n, i->getParameter().on_off_value() * 127);
537 i->trigger_changed();
545 void MidiControllerList::on_val_chg() {
548 if (changed_midi_control_value[n]) {
549 changed_midi_control_value[n] = 0;
550 saved_values[n] = last_midi_control_value[n];
551 midi_value_changed(n, saved_values[n]);
554 for (midi_controller_list::iterator i = ctr_list.begin(); i != ctr_list.end(); ++i) {
556 && i->toggle_behaviour() == Parameter::toggle_type::Constant) {
557 midi_value_changed(n, i->getParameter().on_off_value() * 127);
559 i->trigger_changed();
571 for (midi_controller_list::iterator i = cl.begin(); i != cl.end(); ++i) {
572 i->set_midi(v, v,
true);
578 for (
unsigned int n = 0; n < map.size(); n++) {
583 void MidiControllerList::on_pgm_chg() {
588 if (pgm>=0) new_program(pgm);
591 void MidiControllerList::on_mute_chg() {
596 new_mute_state(mute);
599 void MidiControllerList::on_bank_chg() {
604 if (bk>=0) new_bank(bk);
610 last_midi_control = ctl;
612 last_midi_control = -2;
630 float lower,
float upper,
bool toggle,
int toggle_behaviour) {
637 if (last_midi_control < 0)
640 map[last_midi_control].push_front(
MidiController(param, lower, upper, toggle, toggle_behaviour));
647 int v = last_midi_control_value[n];
649 for (midi_controller_list::iterator i = ctr_list.begin(); i != ctr_list.end(); ++i) {
650 if (i->is_toggle()) {
651 v = i->getParameter().on_off_value() * 127;
653 midi_value_changed(n, v);
660 last_midi_control = ctr;
663 for (midi_controller_list::iterator i = ctr_list.begin(); i != ctr_list.end(); ++i) {
672 last_midi_control = 22;
675 for (midi_controller_list::iterator i = ctr_list.begin(); i != ctr_list.end(); ++i) {
695 const ControllerArray *new_m) {
696 std::set<Parameter*> pset;
697 for (
unsigned int i = 0; i < map.size(); i++) {
699 for (midi_controller_list::iterator j = ctr.begin(); j != ctr.end(); ++j) {
702 for (midi_controller_list::const_iterator jn = ctr_new.begin();
703 jn != ctr_new.end(); ++jn) {
704 if (j->getParameter() == jn->getParameter()) {
705 pset.insert(&j->getParameter());
710 pset.insert(&j->getParameter());
714 for (paramlist::iterator n = plist.begin(); n != plist.end(); ) {
715 paramlist::iterator n1 = n++;
716 if (pset.find(*n1) != pset.end()) {
727 unsigned int val = 0;
728 switch (transport_state) {
729 case JackTransportStopped:
732 case JackTransportRolling:
735 case JackTransportStarting:
742 last_midi_control = 24;
745 for (midi_controller_list::iterator i = ctr_list.begin(); i != ctr_list.end(); ++i) {
755 jack_midi_event_t in_event;
756 jack_nframes_t event_count = jack_midi_get_event_count(midi_input_port_buf);
758 for (i = 0; i < event_count; i++) {
759 jack_midi_event_get(&in_event, midi_input_port_buf, i);
761 if (channel_select>0) {
762 if ((channel_select) != (
int(in_event.buffer[0]&0x0f)+1)) {
766 if ((in_event.buffer[0] & 0xf0) == 0xc0 && ch) {
769 }
else if ((in_event.buffer[0] & 0xf0) == 0xb0 && ch) {
770 if (in_event.buffer[1]== 120) {
773 }
else if (in_event.buffer[1]== 32 && ch) {
777 set_ctr_val(in_event.buffer[1], in_event.buffer[2]);
780 }
else if ((in_event.buffer[0] & 0xf0) == 0x90 && ch) {
784 }
else if ((in_event.buffer[0] ) > 0xf0) {
785 if ((in_event.buffer[0] ) == 0xf8) {
786 clock_gettime(CLOCK_MONOTONIC, &ts1);
789 time0 = (ts1.tv_sec*1000000000.0)+(ts1.tv_nsec)+
790 (1000000000.0/(
double)(sr/(double)in_event.time));
795 }
else if ((in_event.buffer[0] ) == 0xfa) {
798 }
else if ((in_event.buffer[0] ) == 0xfb) {
800 }
else if ((in_event.buffer[0] ) == 0xfc) {
803 }
else if ((in_event.buffer[0] ) == 0xf2) {
818 insert(
"ui.amp",
N_(
"User Interface"));
819 insert(
"engine",
N_(
"Audio Engine"));
824 for (map<string, bool>::iterator i = used.begin(); i != used.end(); ++i) {
833 void ParameterGroups::group_exists(
const string&
id) {
834 if (groups.find(
id) == groups.end()) {
841 void ParameterGroups::group_is_new(
const string&
id) {
842 if (groups.find(
id) != groups.end()) {
848 for (map<string, string>::iterator i = groups.begin(); i != groups.end(); ++i) {
849 printf(
"PG %s: %s\n", i->first.c_str(), i->second.c_str());
860 string param_group(
const string& group_id,
bool nowarn) {
863 return groups.get(group_id);
865 return groups[group_id];
870 if (groups.find(
id) == groups.end()) {
907 : boost::noncopyable(),
915 save_in_preset(true),
944 "Parameter", Glib::ustring::compose(
"%1: unknown key: %2",
_id, jp.
current_value()));
954 bool Parameter::midi_set(
float n,
float high,
float llimit,
float ulimit) {
959 bool Parameter::midi_set_bpm(
float n,
float high,
float llimit,
float ulimit) {
964 void Parameter::trigger_changed() {
969 for (
int n = 0; ; n++) {
970 if (!vn[n].value_id) {
979 Glib::ustring::compose(_(
"parameter %1: value %2 out of range [%3, %4]"),
980 _id, value, lower, upper));
984 static const char *tpname[] = {
985 "float",
"int",
"bool",
"bool",
"filename",
"string",
"special"};
1011 void compare_parameter(
const char *title, Parameter* p1, Parameter* p2,
bool all) {
1012 if (p1->_id != p2->_id) {
1014 title, Glib::ustring::compose(
"Different ID's: %2 / %3",
1017 if (p1->_name != p2->_name) {
1019 title, Glib::ustring::compose(
"[%1]: Different name: %2 / %3",
1020 p1->_id, p1->_name, p2->_name));
1022 if (p1->_group != p2->_group) {
1024 title, Glib::ustring::compose(
"[%1]: Different group: %2 / %3",
1025 p1->_id, p1->_group, p2->_group));
1027 if (p1->_desc != p2->_desc) {
1029 title, Glib::ustring::compose(
"[%1]: Different desc: %2 / %3",
1030 p1->_id, p1->_desc, p2->_desc));
1032 if (p1->save_in_preset != p2->save_in_preset) {
1034 title, Glib::ustring::compose(
"[%1]: save_in_preset different: %2 / %3",
1035 p1->_id, p1->save_in_preset, p2->save_in_preset));
1037 if (p1->controllable != p2->controllable) {
1039 title, Glib::ustring::compose(
"[%1]: controllable different: %2 / %3",
1040 p1->_id, p1->controllable, p2->controllable));
1042 if (p1->used != p2->used) {
1044 title, Glib::ustring::compose(
"[%1]: used different: %2 / %3",
1045 p1->_id, p1->used, p2->used));
1047 if (p1->c_type != p2->c_type) {
1049 title, Glib::ustring::compose(
"[%1]: c_type different: %2 / %3",
1050 p1->_id, p1->c_type, p2->c_type));
1052 if (p1->v_type != p2->v_type) {
1054 title, Glib::ustring::compose(
"[%1]: v_type different: %2 / %3",
1055 p1->_id, p1->v_type, p2->v_type));
1058 if (p1->isFloat()) {
1061 if (f1.value != f2.value) {
1063 title, Glib::ustring::compose(
"[%1]: value address different: %2 / %3",
1064 p1->_id, f1.value, f2.value));
1066 if (f1.lower != f2.lower) {
1069 title, Glib::ustring::compose(
"[%1]: float lower different: %2 / %3",
1070 p1->_id, f1.lower, f2.lower));
1072 if (f1.upper != f2.upper) {
1074 title, Glib::ustring::compose(
"[%1]: float upper different: %2 / %3",
1075 p1->_id, f1.upper, f2.upper));
1077 if (f1.step != f2.step) {
1079 title, Glib::ustring::compose(
"[%1]: float step different: %2 / %3",
1080 p1->_id, f1.step, f2.step));
1082 if (f1.std_value != f2.std_value) {
1084 title, Glib::ustring::compose(
"[%1]: float std value different: %2 / %3",
1085 p1->_id, f1.std_value, f2.std_value));
1088 if (f1.value != f2.value) {
1090 title, Glib::ustring::compose(
"[%1]: float value different: %2 / %3",
1091 p1->_id, *f1.value, *f2.value));
1093 if (f1.json_value != f2.json_value) {
1095 title, Glib::ustring::compose(
"[%1]: float json value different: %2 / %3",
1096 p1->_id, f1.json_value, f2.json_value));
1126 jw.
write_kv(
"std_value", std_value);
1131 :
Parameter(jp_next(jp,
"Parameter")), json_value(0), value(&value_storage), std_value(0), lower(), upper(), step() {
1134 if (jp.
read_kv(
"lower", lower) ||
1137 jp.
read_kv(
"value", *value) ||
1138 jp.
read_kv(
"std_value", std_value)) {
1141 "FloatParameter", Glib::ustring::compose(
"%1: unknown key: %2",
_id, jp.
current_value()));
1152 float v =
min(
max(val, lower), upper);
1170 bool FloatParameter::midi_set(
float n,
float high,
float llimit,
float ulimit) {
1174 assert(n >= 0 && n <= high);
1175 v = llimit + (n / high) * (ulimit - llimit);
1178 v = (2*n > high ? 1.0 : 0.0);
1181 v = lower +
min(n, upper-lower);
1194 bool FloatParameter::midi_set_bpm(
float n,
float high,
float llimit,
float ulimit) {
1198 assert(n >= 0 && n <= high);
1199 if (high <= ulimit) {
1200 v =
max(llimit,
min(ulimit,n));
1202 v = llimit + (n / high) * (ulimit - llimit);
1206 v = (2*n > high ? 1.0 : 0.0);
1209 v = lower +
min(n, upper-lower);
1222 void FloatParameter::trigger_changed() {
1227 json_value = std_value;
1235 if (std::abs(json_value - val) < 10*FLT_EPSILON || std::abs(json_value )> std::abs(val)) {
1239 }
else if (val<=std_value) {
1244 float v = val * 0.1;
1253 json_value = std_value;
1254 Glib::signal_timeout().connect(sigc::bind<float>(
1261 if (json_value < lower-std::abs(5*FLT_EPSILON*lower) || json_value > upper+std::abs(5*FLT_EPSILON*upper)) {
1263 json_value = std_value;
1268 return std::abs(json_value - *value) < 5*FLT_EPSILON;
1276 json_value = lower + (json_value - low) / (up - low) * (upper - lower);
1321 float *v,
int sv,
int low,
bool ctrl,
bool no_init):
1322 FloatParameter(id, name, Enum, preset, v, sv, low, low+get_upper(vn), 1, ctrl, no_init),
1335 int up = static_cast<int>(round(
upper));
1336 int low = static_cast<int>(round(
lower));
1338 for (; n <= up-low; n++) {
1357 _(
"read parameter"), (boost::format(_(
"parameter %1%: unknown enum value: %2%"))
1372 jw.
write_kv(
"std_value", std_value);
1377 :
Parameter(jp_next(jp,
"Parameter")), json_value(0), value(&value_storage), std_value(0), lower(), upper() {
1380 if (jp.
read_kv(
"lower", lower) ||
1382 jp.
read_kv(
"value", *value) ||
1383 jp.
read_kv(
"std_value", std_value)) {
1386 "IntParameter", Glib::ustring::compose(
"%1: unknown key: %2",
_id, jp.
current_value()));
1397 int v =
min(
max(val, lower), upper);
1415 bool IntParameter::midi_set(
float n,
float high,
float llimit,
float ulimit) {
1425 v = lower +
min(static_cast<int>(n), upper-lower);
1438 void IntParameter::trigger_changed() {
1443 json_value = std_value;
1453 if (json_value < lower || json_value > upper) {
1459 return json_value == *value;
1488 int *v,
int sv,
bool ctrl):
1489 IntParameter(id, name, Enum, preset, v, sv, 0, get_upper(vn), ctrl),
1522 _(
"read parameter"), (boost::format(_(
"parameter %1%: unknown enum value: %2%"))
1531 typedef std::pair<std::string,std::string>
id_label;
1543 value_array.push_back(
id_label(value_id, value_label));
1548 "EnumValueNames", Glib::ustring::compose(
"unknown key: %1", jp.
current_value()));
1555 for (std::vector<id_label>::iterator i = value_array.begin(); i != value_array.end(); ++i) {
1565 std::vector<id_label> value_array;
1582 std::vector<id_label> value_array;
1604 jw.
write_kv(
"std_value", std_value);
1609 :
Parameter(jp_next(jp,
"Parameter")), json_value(0), value(&value_storage), std_value(0) {
1612 if (jp.
read_kv(
"value", *value) || jp.
read_kv(
"std_value", std_value)) {
1615 "BoolParameter", Glib::ustring::compose(
"%1: unknown key: %2",
_id, jp.
current_value()));
1626 if (val != *value) {
1638 bool BoolParameter::midi_set(
float n,
float high,
float llimit,
float ulimit) {
1655 void BoolParameter::trigger_changed() {
1660 json_value = std_value;
1676 return json_value == *value;
1695 :
Parameter(jp_next(jp,
"Parameter")), value(0), std_value(0), json_value(0) {
1706 "FileParameter", Glib::ustring::compose(
"%1: unknown key: %2",
_id, jp.
current_value()));
1714 Glib::RefPtr<Gio::File> v = Gio::File::create_for_path(path);
1732 std_value = Gio::File::create_for_path(filename);
1765 static string get_file_id(
const Glib::RefPtr<Gio::File>& f) {
1766 return f->query_info(G_FILE_ATTRIBUTE_ID_FILE)->get_attribute_string(G_FILE_ATTRIBUTE_ID_FILE);
1772 id = get_file_id(
value);
1773 }
catch(Gio::Error& ex) {
1777 id2 = get_file_id(v);
1778 }
catch(Gio::Error& ex) {
1785 return value->get_path();
1789 return value->get_parent()->get_path();
1793 return value->get_parse_name();
1797 return value->query_info(G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME)->get_display_name();
1801 value->copy(Gio::File::create_for_path(destination));
1811 jw.
write_kv(
"std_value", std_value);
1816 :
Parameter(jp_next(jp,
"Parameter")), json_value(
""), value(&value_storage), std_value(
"") {
1819 if (jp.
read_kv(
"value", *value) || jp.
read_kv(
"std_value", std_value)) {
1822 "StringParameter", Glib::ustring::compose(
"%1: unknown key: %2",
_id, jp.
current_value()));
1833 if (val != *value) {
1842 return !value->empty();
1846 json_value = std_value;
1859 return json_value == *value;
1872 replace_mode(false) {
1876 for (
iterator i = id_map.begin(); i != id_map.end(); ++i) {
1884 jw.
write(
"FloatEnum");
1888 }
else if (p->isInt()) {
1894 }
else if (p->isBool()) {
1896 }
else if (p->isFile()) {
1898 }
else if (p->isString()) {
1900 }
else if (dynamic_cast<JConvParameter*>(p) != 0) {
1902 }
else if (dynamic_cast<SeqParameter*>(p) != 0) {
1906 cerr <<
"skipping " << p->id() << endl;
1910 p->serializeJSON(jw);
1915 for (
iterator i = id_map.begin(); i != id_map.end(); ++i) {
1928 return insert(
new EnumParameterD(jp));
1934 return insert(
new FileParameter(jp));
1943 "ParamMap", Glib::ustring::compose(
"unknown parameter type: %1", jp.
current_value()));
1958 void ParamMap::unique_id(Parameter* param) {
1959 if (id_map.find(param->id()) != id_map.end()) {
1960 gx_print_error(
"Debug Check",
"id registered twice: " + param->id());
1964 void ParamMap::check_id(
const string&
id) {
1966 cerr <<
"string-id not found: " <<
id << endl;
1970 void ParamMap::check_p(
const char *p) {
1972 cerr <<
"char-id not found: " << p << endl;
1979 if (fmt ==
"json") {
1985 printf(
"parameter map dump\n");
1987 for (
iterator i = id_map.begin(); i != id_map.end(); ++i) {
1994 printf(
"---------------------\n");
2007 default: assert(
false);
2010 jw->
write(
"preset");
2013 jw->
write(
"control");
2035 for (
int n = 0; ; ++n) {
2036 if (!vn[n].value_id) {
2040 jw->
write(vn[n].value_id);
2054 Parameter *ParamMap::insert(Parameter* param) {
2056 map<string, Parameter*>::iterator ii = id_map.find(param->id());
2057 if (ii != id_map.end()) {
2058 Parameter *p = ii->second;
2059 insert_remove(p,
false);
2065 id_map.insert(pair<string, Parameter*>(param->id(), param));
2066 insert_remove(param,
true);
2074 insert_remove(p,
false);
2075 id_map.erase(p->id());
2087 for (
iterator i = id_map.begin(); i != id_map.end(); ++i) {
2088 i->second->stdJSON_value();
2089 i->second->setJSON_value();
2093 static inline bool compare_groups(
const std::string&
id,
const char **groups) {
2097 for (
const char **g = groups; *g; g += 2) {
2104 if (strncmp(
id.c_str(), p, n) == 0 &&
id[n] ==
'.') {
2112 std::string group_id(pdef->
id);
2114 std::string on_off = group_id +
"on_off";
2115 std::string pp = group_id +
"pp";
2116 std::string position = group_id +
"position";
2118 if (i->first.compare(0, group_id.size(), group_id) == 0 || compare_groups(i->first, pdef->
groups)) {
2119 if (i->second->isInPreset()) {
2120 if (i->first != on_off && i->first != pp && i->first != position) {
2121 i->second->stdJSON_value();
2122 if (!i->second->compareJSON_value()) {
2135 std::string group_id(pdef->
id);
2137 std::string on_off = group_id +
"on_off";
2138 std::string pp = group_id +
"pp";
2139 std::string position = group_id +
"position";
2141 if (i->first.compare(0, group_id.size(), group_id) == 0 || compare_groups(i->first, pdef->
groups)) {
2142 if (i->second->isInPreset()) {
2143 if (i->first != on_off && i->first != pp && i->first != position) {
2144 i->second->stdJSON_value();
2145 i->second->setJSON_value();