Guitarix
machine.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2013 Andreas Degert
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17  */
18 
19 #include "guitarix.h"
20 #include <sys/mman.h>
21 #include "jsonrpc_methods.h"
22 #include <netinet/in.h>
23 #include <netinet/tcp.h>
24 #include <sys/ioctl.h>
25 #ifdef HAVE_BLUEZ
26 #include <bluetooth/bluetooth.h>
27 #include <bluetooth/rfcomm.h>
28 #endif
29 
31  extern char __rt_text__start[], __rt_text__end[];
32  extern char __rt_data__start[], __rt_data__end[];
33  struct {
34  char *start;
35  long len;
36  } regions[] = {
37  { __rt_text__start, __rt_text__end - __rt_text__start },
38  { __rt_data__start, __rt_data__end - __rt_data__start },
39  };
40  for (unsigned int i = 0; i < sizeof(regions)/sizeof(regions[0]); i++) {
41  if (mlock(regions[i].start, regions[i].len) != 0) {
43  "system init",
44  boost::format(_("failed to lock memory: %1%")) % strerror(errno));
45  }
46  }
47 }
48 
49 
50 namespace gx_engine {
51 
53  : impresp_list() {
54 }
55 
57 }
58 
59 
60 /****************************************************************
61  ** GxMachine
62  */
63 
65  p.set(s == kEngineOff);
66 }
67 
68 void on_engine_mute_changed(bool s, GxEngine& engine) {
69  if (s) {
70  engine.set_state(kEngineOff);
71  } else {
72  if (engine.get_state() == kEngineOff) {
73  engine.set_state(kEngineOn);
74  }
75  }
76 }
77 
78 void on_engine_bypass_changed(bool s, GxEngine& engine) {
79  if (s) {
80  engine.set_state(kEngineBypass);
81  } else {
82  if (engine.get_state() == kEngineBypass) {
83  engine.set_state(kEngineOn);
84  }
85  }
86 }
87 
89  GxMachineBase(),
90  options(options_),
91  engine(options.get_plugin_dir(), gx_engine::get_group_table(), options),
92  jack(engine),
93  settings(options, jack, engine.stereo_convolver, gx_engine::midi_std_ctr,
94  engine.controller_map, engine),
95  tuner_switcher(settings, engine),
96  sock(0),
97 #ifdef HAVE_AVAHI
98  avahi_service(0),
99 #endif
100  pmap(engine.get_param()) {
101  engine.set_jack(&jack);
102 
103  /*
104  ** setup parameters
105  */
106 
107  static value_pair starter[] = {
108  { "other", "other" },
109  { "qjackctl", "qjackctl" },
110  { "autostart", "autostart" },
111  {0}
112  };
114  "ui.jack_starter_idx", "", starter, static_cast<int*>(0), false, 1);
115  pmap.reg_non_midi_par("ui.ask_for_jack_starter", (bool*)0, false, true);
116  pmap.reg_string("ui.jack_starter", "", 0, "");
117 
118  // rack tuner
119  gx_engine::get_group_table().insert("racktuner", N_("Rack Tuner"));
120  static const value_pair streaming_labels[] = {{"scale"}, {"stream"}, {0}};
121  pmap.reg_non_midi_enum_par("racktuner.streaming", "Streaming Mode", streaming_labels, (int*)0, false, 1);
122  static const value_pair tuning_labels[] = {{"(Chromatic)"},{"Standard"}, {"Standard/Es"}, {"Open E"},
123  {"Drop D"},{"Half Step Down"},{"Full Step Down"},{"1 and 1/2 Steps Down"},{"Double Drop D"},{"Drop C"},
124  {"Drop C#"},{"Drop B"},{"Drop A#"},{"Drop A"},{"Open D"},{"Open D Minor"}, {"Open G"},{"Open G Minor"},
125  {"Open C"},{"Open C#"},{"Open C Minor"},{"Open E7"},{"Open E Minor7"},{"Open G Major7"},{"Open A Minor"},
126  {"Open A Minor7"},{"Open A"},{"C Tuning"},{"C# Tuning"},{"Bb Tuning"},{"A to A (Baritone)"},{"Open Dsus2"},
127  {"Open Gsus2"},{"G6"},{"Modal G"},{"Overtone"},{"Pentatonic"},{"Minor Third"},{"Major Third"},{"All Fourths"},
128  {"Augmented Fourths"},{"Slow Motion"},{"Admiral"},{"Buzzard"},{"Face"},{"Four and Twenty"},{"Ostrich"},{"Capo 200"},
129  {"Balalaika"},{"Cittern One"},{"Cittern Two"},{"Dobro"},{"Lefty"},{"Mandoguitar"},{"Rusty Cage"},{"Hardcore"}, {0}};
130  pmap.reg_non_midi_enum_par("racktuner.tuning", "Tuning", tuning_labels, (int*)0, false, 0);
131  static const value_pair tuning_temperament[] = {{"12-ET"},{"19-ET"},{"24-ET"},{"31-ET"},{"53-ET"}, {0}};
132  pmap.reg_non_midi_enum_par("racktuner.temperament", "Temperament", tuning_temperament, (int*)0, false, 0);
133  pmap.reg_par_non_preset("racktuner.scale_lim", "Limit", 0, 3.0, 1.0, 10.0, 1.0);
134  pmap.reg_par_non_preset("ui.tuner_reference_pitch", "?Tuner Reference Pitch", 0, 440, 225, 453, 0.1);
135  //pmap.reg_par("racktuner.scale_lim", "Limit", &scale_lim, 3.0, 1.0, 10.0, 1.0); FIXME add in detail view?
136 
137  pmap.reg_par("ui.live_play_switcher", "Liveplay preset mode" , (bool*)0, false, false)->setSavable(false);
138  pmap.reg_par("ui.racktuner", N_("Tuner on/off"), (bool*)0, false, false);
139  pmap.reg_non_midi_par("system.show_tuner", (bool*)0, false);
140  pmap.reg_non_midi_par("system.midi_in_preset", (bool*)0, false, false);
141  pmap.reg_par_non_preset("ui.liveplay_brightness", "?liveplay_brightness", 0, 1.0, 0.5, 1.0, 0.01);
142  pmap.reg_par_non_preset("ui.liveplay_background", "?liveplay_background", 0, 0.8, 0.0, 1.0, 0.01);
143  BoolParameter& p = pmap.reg_par(
144  "engine.mute", "Mute", 0, engine.get_state() == gx_engine::kEngineOff
145  )->getBool();
146  p.setSavable(false);
147  engine.signal_state_change().connect(
148  sigc::bind(sigc::ptr_fun(set_engine_mute), sigc::ref(p)));
149  p.signal_changed().connect(
150  sigc::bind(sigc::ptr_fun(on_engine_mute_changed), sigc::ref(engine)));
151  BoolParameter& pb = pmap.reg_par(
152  "engine.bypass", "Bypass", 0, engine.get_state() == gx_engine::kEngineBypass
153  )->getBool();
154  pb.setSavable(false);
155  pb.signal_changed().connect(
156  sigc::bind(sigc::ptr_fun(on_engine_bypass_changed), sigc::ref(engine)));
157  pmap.reg_non_midi_par("ui.mp_s_h", (bool*)0, false);
158  BoolParameter& ip = pmap.reg_par(
159  "engine.insert", N_("switch insert ports on/off"), (bool*)0, false, false)->getBool();
160  ip.signal_changed().connect(
161  sigc::mem_fun(this, &GxMachine::set_jack_insert));
162 
163 #ifndef NDEBUG
164  // ------ time measurement (debug) ------
166 #endif
167  lock_rt_memory();
168 
169  engine.controller_map.signal_new_program().connect(
170  sigc::mem_fun(this, &GxMachine::do_program_change));
171  engine.controller_map.signal_new_mute_state().connect(
172  sigc::mem_fun(this, &GxMachine::set_mute_state));
173  engine.controller_map.signal_new_bank().connect(
174  sigc::mem_fun(this, &GxMachine::do_bank_change));
175  pmap["ui.live_play_switcher"].signal_changed_bool().connect(
176  sigc::mem_fun(this, &GxMachine::edge_toggle_tuner));
177  engine.midiaudiobuffer.signal_jack_load_change().connect(
178  sigc::mem_fun(this, &GxMachine::on_jack_load_change));
179  switch_bank = settings.get_current_bank();
180 
181 }
182 
184  stop_socket();
185 #ifndef NDEBUG
186  if (options.dump_parameter) {
187  pmap.dump("json");
188  }
189 #endif
190 }
191 
192 void GxMachine::on_jack_load_change() {
196  }
197  jack_load_change(l);
198 }
199 
200 void GxMachine::edge_toggle_tuner(bool v) {
201  if (v) {
202  tuner_switcher.toggle(engine.tuner.used_for_display());
203  }
204 }
205 
206 void GxMachine::do_program_change(int pgm) {
207  Glib::ustring bank = settings.get_current_bank();
208  if ((bank != switch_bank) && !switch_bank.empty()) {
209  bank = switch_bank;
210  }
211  bool in_preset = !bank.empty();
213  if (in_preset) {
214  f = settings.banks.get_file(bank);
215  in_preset = pgm < f->size();
216  }
217  if (in_preset) {
218  settings.load_preset(f, f->get_name(pgm));
219  set_parameter_value("system.current_bank",bank);
220  if (engine.get_state() == gx_engine::kEngineBypass) {
222  }
223  } // do nothing when bank/preset is out of range
224  // else if (engine.get_state() == gx_engine::kEngineOn) {
225  // engine.set_state(gx_engine::kEngineBypass);
226  //}
227 }
228 
229 void GxMachine::reset_switch_bank() {
230  switch_bank = settings.get_current_bank();
231 }
232 
233 void GxMachine::do_bank_change(int pgm) {
234  if (!get_bank_name(pgm).empty()) {
235  switch_bank = get_bank_name(pgm);
236  Glib::signal_timeout().connect_once(
237  sigc::mem_fun(this,&GxMachine::reset_switch_bank), 50);
238  } else {
239  switch_bank = settings.get_current_bank();
240  }
241 }
242 
243 void GxMachine::set_mute_state(int mute) {
244  if (mute == 0) {
246  } else {
248  }
249 }
250 
252  engine.set_state(state);
253 }
254 
256  return engine.get_state();
257 }
258 
259 void GxMachine::load_ladspalist(std::vector<std::string>& old_not_found, ladspa::LadspaPluginList& pluginlist) {
260  pluginlist.load(options, old_not_found);
261 }
262 
264  pluginlist.save(options);
265 }
266 
268  if (sock) {
269  sock->ladspaloader_update_plugins(0, 0);
270  } else {
272  }
273 }
274 
275 sigc::signal<void,Plugin*,PluginChange::pc>& GxMachine::signal_plugin_changed() {
276  return engine.signal_plugin_changed();
277 }
278 
279 Plugin *GxMachine::pluginlist_lookup_plugin(const std::string& id) const {
280  return engine.pluginlist.lookup_plugin(id);
281 }
282 
284  return builder.load_unit(pdef);
285 }
286 
288  engine.pluginlist.append_rack(ui);
289 }
290 
292  return engine.tuner.get_freq();
293 }
294 
296  engine.oscilloscope.set_mul_buffer(a, jack.get_jack_bs());
297 }
298 
300  return engine.oscilloscope.get_mul_buffer();
301 }
302 
304  return engine.oscilloscope.get_buffer();
305 }
306 
308  engine.oscilloscope.clear_buffer();
309 }
310 
312  return engine.oscilloscope.plugin.get_box_visible();
313 }
314 
315 sigc::signal<void, int>& GxMachine::signal_oscilloscope_post_pre() {
316  return pmap[engine.oscilloscope.plugin.id_effect_post_pre()].signal_changed_int();
317 }
318 
319 sigc::signal<void, bool>& GxMachine::signal_oscilloscope_visible() {
320  return pmap[engine.oscilloscope.plugin.id_box_visible()].signal_changed_bool();
321 }
322 
323 sigc::signal<int, bool>& GxMachine::signal_oscilloscope_activation() {
324  return engine.oscilloscope.activation;
325 }
326 
327 sigc::signal<void, unsigned int>& GxMachine::signal_oscilloscope_size_change() {
328  return engine.oscilloscope.size_change;
329 }
330 
331 void GxMachine::maxlevel_get(int channels, float *values) {
332  if (sock) {
333  sock->update_maxlevel();
334  for (int i = 0; i < channels; i++) {
335  values[i] = sock->get_maxlevel(i);
336  }
337  } else {
338  for (int i = 0; i < channels; i++) {
339  values[i] = engine.maxlevel.get(i);
340  }
341  }
342 }
343 
344 void GxMachine::get_oscilloscope_info(int& load, int& frames, bool& is_rt, jack_nframes_t& bsize) {
345  load = static_cast<int>(round(jack.get_jcpu_load()));
346  frames = jack.get_time_is()/100000;
347  is_rt = jack.get_is_rt();
348  bsize = jack.get_jack_bs();
349 }
350 
352  return options;
353 }
354 
355 void GxMachine::exit_handler(bool otherthread) {
356  if (!otherthread) {
357  delete sock;
358  sock = 0;
359  }
360 }
361 
363 #ifdef HAVE_AVAHI
364  delete avahi_service;
365  avahi_service = 0;
366 #endif
367  delete sock;
368  sock = 0;
369 }
370 
371 void GxMachine::start_socket(sigc::slot<void> quit_mainloop, const Glib::ustring& host, int port) {
372  if (sock) {
373  return;
374  }
375  sock = new GxService(settings, jack, tuner_switcher, quit_mainloop, host, &port);
376  sock->start();
377  GxExit::get_instance().signal_exit().connect(
378  sigc::mem_fun(*this, &GxMachine::exit_handler));
379 #ifdef HAVE_AVAHI
380  if (port > 0) {
381  std::string name = "Guitarix";
382  if (jack.get_default_instancename() != jack.get_instancename()) {
383  name += ": " + jack.get_instancename();
384  }
385  avahi_service = new AvahiService;
386  avahi_service->register_service(name, port);
387  }
388 #endif
389 }
390 
391 sigc::signal<void,const Glib::ustring&,const Glib::ustring&>& GxMachine::tuner_switcher_signal_display() {
392  return tuner_switcher.signal_display();
393 }
394 
395 sigc::signal<void,TunerSwitcher::SwitcherState>& GxMachine::tuner_switcher_signal_set_state() {
396  return tuner_switcher.signal_set_state();
397 }
398 
400  return tuner_switcher.signal_selection_done();
401 }
402 
403 sigc::signal<void,GxEngineState>& GxMachine::signal_state_change() {
404  return engine.signal_state_change();
405 }
406 
408  engine.tuner.used_for_display(on);
409 }
410 
411 const std::vector<std::string>& GxMachine::get_rack_unit_order(PluginType type) {
412  return settings.get_rack_unit_order(type == PLUGIN_TYPE_STEREO);
413 }
414 
415 sigc::signal<void,bool>& GxMachine::signal_rack_unit_order_changed() {
416  return settings.signal_rack_unit_order_changed();
417 }
418 
419 void GxMachine::remove_rack_unit(const std::string& unit, PluginType type) {
420  if (!settings.remove_rack_unit(unit, type == PLUGIN_TYPE_STEREO)) {
421  return;
422  }
423  if (sock) {
424  sock->send_rack_changed(type == PLUGIN_TYPE_STEREO, 0);
425  }
426 }
427 
428 void GxMachine::insert_rack_unit(const std::string& unit, const std::string& before, PluginType type) {
429  settings.insert_rack_unit(unit, before, type == PLUGIN_TYPE_STEREO);
430  if (sock) {
431  sock->send_rack_changed(type == PLUGIN_TYPE_STEREO, 0);
432  }
433 }
434 
435 // tuner_switcher
437  return tuner_switcher.get_active();
438 }
439 
441  tuner_switcher.activate(v);
442 }
443 
445  tuner_switcher.deactivate();
446 }
447 
449  tuner_switcher.toggle(v);
450 }
451 
452 // preset
454  return settings.setting_is_preset();
455 }
456 
457 
458 const Glib::ustring& GxMachine::get_current_bank() {
459  return settings.get_current_bank();
460 }
461 
463  return settings.get_current_bank_file()->get_guiwrapper();
464 }
465 
466 const Glib::ustring& GxMachine::get_current_name() {
467  return settings.get_current_name();
468 }
469 
470 gx_system::PresetFileGui* GxMachine::get_bank_file(const Glib::ustring& bank) const {
471  return settings.banks.get_file(bank)->get_guiwrapper();
472 }
473 
474 Glib::ustring GxMachine::get_bank_name(int n) {
475  return settings.banks.get_name(n);
476 }
477 
478 int GxMachine::get_bank_num(Glib::ustring num) {
479  Glib::ustring array = "abcdefghijklmnopqrstuvwxyz" ;
480  int i = 0;
481  for(i=0;i<26;i++) {
482  if(num.compare(array.substr(i,1))==0) break;
483  }
484  return bank_size() -i -1;
485 }
486 
487 void GxMachine::msend_midi_cc(int cc, int pgn, int bgn, int num) {
488  jack.send_midi_cc(cc, pgn, bgn, num);
489 }
490 
491 void GxMachine::load_preset(gx_system::PresetFileGui *pf, const Glib::ustring& name) {
492  int n = get_bank_index(get_current_bank());
493  settings.load_preset(pf, name);
494 #ifdef USE_MIDI_CC_OUT
495  if (get_bank_index(pf->get_name()) != n) {
496  msend_midi_cc(0xB0, 32, get_bank_index(pf->get_name()),3);
497  }
498  msend_midi_cc(0xC0, pf->get_index(name),0,2);
499 #endif
500 }
501 
503  settings.load_online_presets();
504 }
505 
507  settings.loadstate();
508  if (!options.get_setbank().empty()) {
509  Glib::ustring sbank = options.get_setbank();
510  int bl = get_bank_num(sbank.substr(0,1).lowercase());
511  int pgm = max(0,atoi(sbank.substr(2,Glib::ustring::npos).raw().c_str())-1);
512  switch_bank = settings.banks.get_name(bl);
513  do_program_change(pgm);
514  }
515 }
516 
518  return settings.banks.size();
519 }
520 
521 int GxMachine::get_bank_index(const Glib::ustring& bank) {
522  return settings.banks.get_index(bank);
523 }
524 
527 }
528 
529 void GxMachine::set_statefilename(const std::string& fn) {
530  settings.set_statefilename(fn);
531 }
532 
533 void GxMachine::save_to_state(bool preserve_preset) {
534  settings.save_to_state(preserve_preset);
535 }
536 
538  settings.plugin_preset_list_load(pdef, presetnames);
539 }
540 
541 void GxMachine::plugin_preset_list_set(const PluginDef *pdef, bool factory, const Glib::ustring& name) {
542  settings.plugin_preset_list_set(pdef, factory, name);
543 }
544 
545 void GxMachine::plugin_preset_list_save(const PluginDef *pdef, const Glib::ustring& name) {
546  settings.plugin_preset_list_save(pdef, name);
547 }
548 
549 void GxMachine::plugin_preset_list_remove(const PluginDef *pdef, const Glib::ustring& name) {
550  settings.plugin_preset_list_remove(pdef, name);
551 }
552 
554  settings.disable_autosave(v);
555 }
556 
557 sigc::signal<void>& GxMachine::signal_selection_changed() {
558  return settings.signal_selection_changed();
559 }
560 
562  return settings.signal_presetlist_changed();
563 }
564 
565 gx_system::PresetFileGui* GxMachine::bank_insert_uri(const Glib::ustring& uri, bool move) {
566  gx_system::PresetFile *f = settings.bank_insert_uri(uri, move);
567  if (f) {
568  return f->get_guiwrapper();
569  } else {
570  return 0;
571  }
572 }
573 
575  gx_system::PresetFile *f = settings.bank_insert_new(name);
576  if (f) {
577  return f->get_guiwrapper();
578  } else {
579  return 0;
580  }
581 }
582 
583 bool GxMachine::rename_bank(const Glib::ustring& oldname, Glib::ustring& newname) {
584  return settings.rename_bank(oldname, newname);
585 }
586 
587 bool GxMachine::rename_preset(gx_system::PresetFileGui& pf, const Glib::ustring& oldname, const Glib::ustring& newname) {
588  return settings.rename_preset(pf, oldname, newname);
589 }
590 
591 void GxMachine::bank_reorder(const std::vector<Glib::ustring>& neworder) {
592  settings.banks.reorder(neworder);
593 }
594 
595 void GxMachine::reorder_preset(gx_system::PresetFileGui& pf, const std::vector<Glib::ustring>& neworder) {
596  settings.reorder_preset(pf, neworder);
597 }
598 
600  return settings.banks.check_reparse();
601 }
602 
603 void GxMachine::erase_preset(gx_system::PresetFileGui& pf, const Glib::ustring& name) {
604  settings.erase_preset(pf, name);
605 }
606 
608  static_cast<gx_system::PresetFile*>(pf)->set_flag(flag, v);
609  settings.banks.save();
610 }
611 
612 std::string GxMachine::bank_get_filename(const Glib::ustring& bank) {
613  return settings.banks.get_file(bank)->get_filename();
614 }
615 
617 }
618 
619 gx_system::PresetFileGui *GxMachine::bank_get_file(const Glib::ustring& bank) const {
620  return settings.banks.get_file(bank)->get_guiwrapper();
621 }
622 
624  return bank_iterator(settings.banks.begin());
625 }
626 
628  return bank_iterator(settings.banks.end());
629 }
630 
631 void GxMachine::pf_append(gx_system::PresetFileGui& pf, const Glib::ustring& src, gx_system::PresetFileGui& pftgt, const Glib::ustring& name) {
632  settings.append(pf, src, pftgt, name);
633 }
634 
635 void GxMachine::pf_insert_before(gx_system::PresetFileGui& pf, const Glib::ustring& src, gx_system::PresetFileGui& pftgt, const Glib::ustring& pos, const Glib::ustring& name) {
636  settings.insert_before(pf, src, pftgt, pos, name);
637 }
638 
639 void GxMachine::pf_insert_after(gx_system::PresetFileGui& pf, const Glib::ustring& src, gx_system::PresetFileGui& pftgt, const Glib::ustring& pos, const Glib::ustring& name) {
640  settings.insert_after(pf, src, pftgt, pos, name);
641 }
642 
644  return settings.convert_preset(pf);
645 }
646 
647 bool GxMachine::bank_remove(const Glib::ustring& bank) {
648  return settings.remove_bank(bank);
649 }
650 
652  settings.banks.save();
653 }
654 
655 void GxMachine::pf_save(gx_system::PresetFileGui& pf, const Glib::ustring& name) {
656  settings.save(pf, name);
657 }
658 
659 
660 // jack
662  return &jack;
663 }
664 
666  return jack.set_jack_insert(v);
667 }
668 
669 // pmap
671  return pmap[p];
672 }
673 
674 Parameter& GxMachine::get_parameter(const std::string& id) {
675  return pmap[id];
676 }
677 
679  pmap.set_init_values();
680 }
681 
682 bool GxMachine::parameter_hasId(const char *p) {
683  return pmap.hasId(p);
684 }
685 
686 bool GxMachine::parameter_hasId(const std::string& id) {
687  return pmap.hasId(id);
688 }
689 
690 void GxMachine::reset_unit(const PluginDef *pdef) const {
691  pmap.reset_unit(pdef);
692 }
693 
695  return pmap.unit_has_std_values(pdef);
696 }
697 
698 void GxMachine::set_parameter_value(const std::string& id, int value) {
699  pmap[id].getInt().set(value);
700 }
701 
702 void GxMachine::set_parameter_value(const std::string& id, bool value) {
703  pmap[id].getBool().set(value);
704 }
705 
706  //bool GxMachine::ui_f_update(const std::string& id, float value) {
707  // pmap[id].getFloat().set(value);
708  // return false;
709  //}
710 
711 void GxMachine::set_parameter_value(const std::string& id, float value) {
712  // Glib::signal_timeout().connect(
713  // sigc::bind<const std::string&>(sigc::bind<float>(
714  // sigc::mem_fun (*this, &GxMachine::ui_f_update),value),id), 20);
715  pmap[id].getFloat().set(value);
716 }
717 
718 void GxMachine::set_parameter_value(const std::string& id, const std::string& value) {
719  pmap[id].getString().set(value);
720 }
721 
722 int GxMachine::_get_parameter_value_int(const std::string& id) {
723  return pmap[id].getInt().get_value();
724 }
725 
726 int GxMachine::_get_parameter_value_bool(const std::string& id) {
727  return pmap[id].getBool().get_value();
728 }
729 
730 float GxMachine::_get_parameter_value_float(const std::string& id) {
731  return pmap[id].getFloat().get_value();
732 }
733 
734 std::string GxMachine::_get_parameter_value_string(const std::string& id) {
735  return pmap[id].getString().get_value();
736 }
737 
738 sigc::signal<void, int>& GxMachine::_signal_parameter_value_int(const std::string& id) {
739  return pmap[id].signal_changed_int();
740 }
741 
742 sigc::signal<void, bool>& GxMachine::_signal_parameter_value_bool(const std::string& id) {
743  return pmap[id].signal_changed_bool();
744 }
745 
746 sigc::signal<void, float>& GxMachine::_signal_parameter_value_float(const std::string& id) {
747  return pmap[id].signal_changed_float();
748 }
749 
750 // MidiControllerList
752  if (engine.controller_map.get_config_mode()) {
753  *ctl = engine.controller_map.get_current_control();
754  return true;
755  }
756  return false;
757 }
758 
759 void GxMachine::midi_set_config_mode(bool v, int ctl) {
760  engine.controller_map.set_config_mode(v, ctl);
761 }
762 
763 sigc::signal<void>& GxMachine::signal_midi_changed() {
764  return engine.controller_map.signal_changed();
765 }
766 
767 sigc::signal<void, int, int>& GxMachine::signal_midi_value_changed() {
769 }
770 
773 }
774 
776  return engine.controller_map.size();
777 }
778 
780  return engine.controller_map[n];
781 }
782 
784  engine.controller_map.deleteParameter(param);
785 }
786 
789 }
790 
791 void GxMachine::midi_modifyCurrent(Parameter& param, float lower, float upper,
792  bool toggle, int toggle_behaviour) {
793  engine.controller_map.modifyCurrent(param, lower, upper, toggle, toggle_behaviour);
794 }
795 
797  return engine.controller_map.param2controller(param, p);
798 }
799 
800 // Convolver
801 
802 void GxMachine::on_impresp(const std::string& path) {
803  gx_system::IRFileListing l(path);
804  impresp_list(path, l.get_listing());
805 }
806 
807 void GxMachine::reload_impresp_list(const std::string& path) {
808  Glib::signal_idle().connect_once(
809  sigc::bind(
810  sigc::mem_fun(this, &GxMachine::on_impresp), path));
811 }
812 
813 void GxMachine::load_impresp_dirs(std::vector<gx_system::FileName>& dirs) {
814  assert(false);
815 }
816 
817 bool GxMachine::read_audio(const std::string& filename, unsigned int *audio_size, int *audio_chan,
818  int *audio_type, int *audio_form, int *audio_rate, float **buffer) {
819  return gx_engine::read_audio(filename, audio_size, audio_chan, audio_type, audio_form, audio_rate, buffer);
820 }
821 
822 
823 /****************************************************************
824  ** GxMachineRemote
825  */
826 
827 #ifdef NDEBUG
828 #define START_NOTIFY(m) { start_call(RPNM_##m)
829 #else
830 #define START_NOTIFY(m) { const jsonrpc_method_def& _md = start_call(RPNM_##m)
831 #endif
832 
833 #define SEND() assert(!_md.has_result); send(); }
834 
835 #define START_CALL(m) { const jsonrpc_method_def& _md = start_call(RPCM_##m)
836 
837 #define START_RECEIVE(s) assert(_md.has_result); send(); { \
838  gx_system::JsonStringParser *jp = receive();\
839  if (!jp) { return s; }\
840  try {
841 
842 #define END_RECEIVE(s) } catch (const gx_system::JsonException& e) { report_rpc_error(jp, e, _md.name); } \
843  delete jp; s; }}
844 
845 
847  : GxMachineBase(),
848  options(options_),
849  pmap(),
850  pluginlist(),
851  banks(),
852  engine_state_change(),
853  selection_changed(),
854  presetlist_changed(),
855  socket(),
856  writebuf(),
857  os(),
858  jw(0),
859  notify_list(),
860  idle_conn(),
861  rack_units(),
862  midi_changed(),
863  midi_value_changed(),
864  current_bank(),
865  current_preset(),
866  bank_drag_get_counter(),
867  bank_drag_get_path(),
868  oscilloscope_activation(),
869  oscilloscope_size_change(),
870  oscilloscope_buffer(0),
871  oscilloscope_buffer_size(0),
872  tuner_switcher_display(),
873  tuner_switcher_set_state(),
874  tuner_switcher_selection_done() {
875  if (options.get_rpcaddress().compare(0, 3, "BT:") == 0) {
876  create_bluetooth_socket(options.get_rpcaddress().substr(3));
877  } else {
878  create_tcp_socket();
879  }
880  socket->set_blocking(true);
881  writebuf = new __gnu_cxx::stdio_filebuf<char>(socket->get_fd(), std::ios::out);
882  os = new ostream(writebuf);
883  jw = new gx_system::JsonWriter(os, false);
884 
885  START_CALL(parameterlist);
886  START_RECEIVE();
887  pmap.readJSON(*jp);
888  END_RECEIVE();
889  current_bank = pmap["system.current_bank"].getString().get_value();
890  current_preset = pmap["system.current_preset"].getString().get_value();
891  START_CALL(pluginlist);
892  START_RECEIVE();
893  pluginlist.readJSON(*jp, pmap);
894  END_RECEIVE();
895  START_CALL(banks);
896  START_RECEIVE();
897  banks.readJSON_remote(*jp);
898  END_RECEIVE();
899  START_CALL(get_midi_controller_map);
900  START_RECEIVE();
901  midi_controller_map.readJSON(*jp, pmap);
902  END_RECEIVE();
903  START_NOTIFY(listen);
904  jw->write("preset");
905  jw->write("state");
906  //we don't need "freq"
907  jw->write("display");
908  jw->write("tuner");
909  jw->write("presetlist_changed");
910  jw->write("logger");
911  jw->write("midi");
912  jw->write("oscilloscope");
913  jw->write("jack_load");
914  jw->write("param");
915  jw->write("plugins_changed");
916  jw->write("misc");
917  jw->write("units_changed");
918  SEND();
919 }
920 
922  jw->close();
923  delete jw;
924  writebuf->close();
925  delete os;
926  delete writebuf;
927 }
928 
929 #ifdef NDEBUG
930 inline void debug_trace_param(Parameter *p) {}
931 #else
932 inline void debug_trace_param(Parameter *p) {
933  const char *q = getenv("GUITARIX_TRACE");
934  if (!q) {
935  return;
936  }
937  if (*q && q != p->id()) {
938  return;
939  }
940  cerr << "set " << p->id() << " = ";
941  if (p->isInt()) {
942  cerr << p->getInt().get_value();
943  } else if (p->isBool()) {
944  cerr << p->getBool().get_value();
945  } else if (p->isFloat()) {
946  cerr << p->getFloat().get_value();
947  } else if (p->isString()) {
948  cerr << p->getString().get_value();
949  } else if (dynamic_cast<JConvParameter*>(p) != 0) {
950  cerr << dynamic_cast<JConvParameter*>(p)->get_value().getFullIRPath();
951  } else if (dynamic_cast<SeqParameter*>(p) != 0) {
952  cerr << dynamic_cast<SeqParameter*>(p)->get_value();
953  } else {
954  assert(false);
955  }
956  if (p->get_blocked()) {
957  cerr << " (blocked)";
958  }
959  cerr << endl;
960 }
961 #endif
962 
963 #if HAVE_BLUEZ
964 void GxMachineRemote::create_bluetooth_socket(const Glib::ustring& bdaddr) {
965  struct sockaddr_rc addr = { 0 };
966  addr.rc_family = AF_BLUETOOTH;
967  str2ba(bdaddr.c_str(), &addr.rc_bdaddr);
968  int error = EBUSY;
969  for (int channel = 1; channel <= 9; channel++) {
970  addr.rc_channel = (uint8_t)channel;
971  int s = ::socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
972  if (connect(s, (const struct sockaddr *)&addr, sizeof(addr)) < 0) {
973  error = errno;
974  close(s);
975  if (error != EBUSY) {
976  break;
977  }
978  } else {
979  socket = Gio::Socket::create_from_fd(s);
980  return;
981  }
982  }
983  char buf[100];
984  throw GxFatalError(
985  Glib::ustring::compose(
986  _("Remote Connection: cannot connect to bluetooth %1: %2"),
987  bdaddr, strerror_r(error, buf, sizeof(buf))));
988 }
989 #else // !HAVE_BLUEZ
990 void GxMachineRemote::create_bluetooth_socket(const Glib::ustring& bdaddr) {
992  _("frontend"),
993  _("Bluetooth not available; rebuild Guitarix with Bluetooth support"));
994 }
995 #endif // HAVE_BLUEZ
996 
997 void GxMachineRemote::create_tcp_socket() {
998  socket = Gio::Socket::create(Gio::SOCKET_FAMILY_IPV4, Gio::SOCKET_TYPE_STREAM, Gio::SOCKET_PROTOCOL_TCP);
999  int flag = 1;
1000  setsockopt(socket->get_fd(), IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(int));
1001  typedef std::vector< Glib::RefPtr<Gio::InetAddress> > adr_list;
1002  adr_list al;
1003  try {
1004  al = Gio::Resolver::get_default()->lookup_by_name(options.get_rpcaddress());
1005  } catch (Glib::Error e) {
1006  gx_print_fatal(_("Remote Connection"), e.what());
1007  }
1008  Glib::ustring msg;
1009  bool error = true;
1010  for (adr_list::iterator i = al.begin(); i != al.end(); ++i) {
1011  try {
1012  socket->connect(Gio::InetSocketAddress::create(*i, options.get_rpcport()));
1013  error = false;
1014  } catch (Gio::Error e) {
1015  msg = e.what();
1016  error = true;
1017  }
1018  }
1019  if (error) {
1020  gx_print_fatal(_("Remote Connection"), msg);
1021  }
1022 }
1023 
1024 void GxMachineRemote::param_signal(Parameter *p) {
1025  debug_trace_param(p);
1026  if (p->get_blocked()) {
1027  return;
1028  }
1029  START_NOTIFY(set);
1030  jw->write(p->id());
1031  if (p->isInt()) {
1032  jw->write(p->getInt().get_value());
1033  } else if (p->isBool()) {
1034  jw->write(p->getBool().get_value());
1035  } else if (p->isFloat()) {
1036  jw->write(p->getFloat().get_value());
1037  } else if (p->isString()) {
1038  jw->write(p->getString().get_value());
1039  } else if (dynamic_cast<JConvParameter*>(p) != 0) {
1040  dynamic_cast<JConvParameter*>(p)->get_value().writeJSON(*jw);
1041  } else if (dynamic_cast<SeqParameter*>(p) != 0) {
1042  dynamic_cast<SeqParameter*>(p)->get_value().writeJSON(*jw);
1043  } else {
1044  assert(false);
1045  }
1046  SEND();
1047 }
1048 
1049 void GxMachineRemote::parameter_changed(gx_system::JsonStringParser *jp) {
1050  Parameter& p = pmap[jp->current_value()];
1051  p.set_blocked(true);
1052  if (p.isFloat()) {
1053  float v;
1054  switch (jp->next()) {
1056  v = dynamic_cast<FloatEnumParameter*>(&p)->idx_from_id(jp->current_value());
1057  break;
1059  v = jp->current_value_float();
1060  break;
1061  default:
1062  assert(false);
1063  v = 0;
1064  }
1065  p.getFloat().set(v);
1066  } else if (p.isInt()) {
1067  int v;
1068  switch (jp->next()) {
1070  v = p.getEnum().idx_from_id(jp->current_value());
1071  break;
1073  v = jp->current_value_int();
1074  break;
1075  default:
1076  assert(false);
1077  v = 0;
1078  }
1079  p.getInt().set(v);
1080  } else if (p.isBool()) {
1082  p.getBool().set(jp->current_value_int());
1083  } else if (p.isString()) {
1085  p.getString().set(jp->current_value());
1086  } else if (p.isFile()) {
1087  cerr << "change file parameter " << p.id() << endl;
1088  } else if (dynamic_cast<JConvParameter*>(&p) != 0) {
1089  JConvParameter* pj = dynamic_cast<JConvParameter*>(&p);
1090  pj->readJSON_value(*jp);
1091  pj->setJSON_value();
1092  } else if (dynamic_cast<SeqParameter*>(&p) != 0) {
1093  SeqParameter* pj = dynamic_cast<SeqParameter*>(&p);
1094  pj->readJSON_value(*jp);
1095  pj->setJSON_value();
1096  } else {
1097  cerr << "change special type parameter " << p.id() << endl;
1098  }
1099  p.set_blocked(false);
1100 }
1101 
1102 void GxMachineRemote::handle_notify(gx_system::JsonStringParser *jp) {
1104  std::string method = jp->current_value();
1105  jp->next(gx_system::JsonParser::value_key); // "params"
1107  if (method == "state_changed") {
1109  engine_state_change(string_to_engine_state(jp->current_value()));
1110  } else if (method == "message") {
1113  if (jp->current_value() == "info") {
1114  msgtype = GxLogger::kInfo;
1115  } else if (jp->current_value() == "warning") {
1116  msgtype = GxLogger::kWarning;
1117  }
1119  GxLogger::get_logger().print(jp->current_value(), msgtype);
1120  } else if (method == "preset_changed") {
1121  jp->next();
1122  Glib::ustring new_bank = jp->current_value();
1124  Glib::ustring new_preset = jp->current_value();
1126  current_bank = new_bank;
1127  current_preset = new_preset;
1128  selection_changed();
1129  } else if (method == "presetlist_changed") {
1130  START_CALL(banks);
1131  START_RECEIVE();
1132  banks.readJSON_remote(*jp);
1133  END_RECEIVE();
1134  presetlist_changed();
1135  } else if (method == "set") {
1136  while (jp->peek() != gx_system::JsonParser::end_array) {
1138  parameter_changed(jp);
1139  }
1140  } else if (method == "rack_units_changed") {
1143  bool stereo = jp->current_value_int();
1144  std::vector<std::string>& l = (stereo ? rack_units.stereo : rack_units.mono);
1145  l.clear();
1146  while (jp->peek() != gx_system::JsonParser::end_array) {
1148  l.push_back(jp->current_value());
1149  }
1151  rack_units.rack_unit_order_changed(stereo);
1152  } else if (method == "midi_changed") {
1153  midi_controller_map.readJSON(*jp, pmap);
1154  midi_changed();
1155  } else if (method == "midi_value_changed") {
1158  int ctl = jp->current_value_int();
1160  int value = jp->current_value_int();
1162  midi_value_changed(ctl, value);
1163  } else if (method == "osc_activation") {
1165  oscilloscope_activation(jp->current_value_int());
1166  } else if (method == "osc_size_changed") {
1168  unsigned int sz = jp->current_value_int();
1169  if (oscilloscope_buffer_size != sz) {
1170  delete oscilloscope_buffer;
1171  oscilloscope_buffer = new float[sz];
1172  oscilloscope_buffer_size = sz;
1173  }
1174  oscilloscope_size_change(sz);
1175  } else if (method == "show_tuner") {
1177  tuner_switcher_selection_done(jp->current_value_int());
1178  } else if (method == "set_display_state") {
1181  if (jp->current_value() == "normal_mode") {
1183  } else if (jp->current_value() == "wait_start") {
1184  state = TunerSwitcher::wait_start;
1185  } else if (jp->current_value() == "listening") {
1186  state = TunerSwitcher::listening;
1187  } else if (jp->current_value() == "wait_stop") {
1188  state = TunerSwitcher::wait_stop;
1189  } else {
1190  assert(false);
1191  }
1192  tuner_switcher_set_state(state);
1193  } else if (method == "display_bank_preset") {
1195  Glib::ustring bank = jp->current_value();
1197  tuner_switcher_display(bank, jp->current_value());
1198  } else if (method == "impresp_list") {
1199  std::vector<gx_system::FileName> l;
1201  std::string path = jp->current_value();
1202  while (jp->peek() == gx_system::JsonParser::begin_array) {
1205  std::string filename = jp->current_value();
1207  l.push_back(gx_system::FileName(filename, jp->current_value()));
1209  }
1210  impresp_list(path, l);
1211  } else if (method == "plugins_changed") {
1212  update_plugins(jp);
1213  } else if (method == "jack_load_changed") {
1215  jack_load_change(static_cast<gx_engine::MidiAudioBuffer::Load>(jp->current_value_int()));
1216  } else if (method == "server_shutdown") {
1217  Gtk::Main::quit();
1218  } else {
1219  cerr << "> " << jp->get_string() << endl;
1220  }
1221 }
1222 
1223 static int socket_get_available_bytes(const Glib::RefPtr<Gio::Socket>& socket) {
1224  // return socket->get_available_bytes(); // Glib 2.32
1225  int avail;
1226  ioctl(socket->get_fd(), FIONREAD, &avail);
1227  int ret = ioctl(socket->get_fd(), FIONREAD, &avail);
1228  if (ret != 0) {
1229  return -1;
1230  }
1231  return avail;
1232 }
1233 
1234 bool GxMachineRemote::socket_input_handler(Glib::IOCondition cond) {
1235  if (cond & (Glib::IO_HUP|Glib::IO_ERR|Glib::IO_NVAL)) {
1236  socket_error(0);
1237  return false;
1238  }
1239  int n = socket_get_available_bytes(socket);
1240  if (n == 0) {
1241  return true;
1242  } else if (n < 0) {
1243  socket_error(1);
1244  }
1245  char buf[10000];
1247  while (true) {
1248  try {
1249  n = socket->receive(buf, sizeof(buf));
1250  } catch(Glib::Error e) {
1251  delete jp;
1252  socket_error(2);
1253  return false;
1254  }
1255  if (n <= 0) {
1256  delete jp;
1257  socket_error(3);
1258  return false;
1259  }
1260  char *p = buf;
1261  while (n-- > 0) {
1262  jp->put(*p);
1263  if (*p == '\n') {
1264  jp->start_parser();
1265  try {
1267  jp->next(gx_system::JsonParser::value_key); // "jsonrpc"
1269  jp->next(gx_system::JsonParser::value_key); // "method"
1270  handle_notify(jp);
1271  } catch (gx_system::JsonException e) {
1272  cerr << "JsonException: " << e.what() << ": '" << jp->get_string() << "'" << endl;
1273  assert(false);
1274  }
1275  if (n == 0) {
1276  int avail = socket_get_available_bytes(socket);
1277  if (avail == 0) {
1278  delete jp;
1279  return true;
1280  } else if (avail < 0) {
1281  socket_error(4);
1282  }
1283  }
1284  delete jp;
1285  jp = new gx_system::JsonStringParser;
1286  }
1287  p++;
1288  }
1289  }
1290 }
1291 
1292 const jsonrpc_method_def& GxMachineRemote::start_call(jsonrpc_method m) {
1293  const jsonrpc_method_def& md = jsonrpc_method_list[m];
1294  jw->begin_object();
1295  jw->write_kv("jsonrpc", "2.0");
1296  if (md.has_result) {
1297  jw->write_kv("id", "1");
1298  }
1299  jw->write_kv("method", md.name);
1300  jw->write_key("params");
1301  jw->begin_array();
1302  return md;
1303 }
1304 
1305 void GxMachineRemote::send() {
1306  jw->end_array();
1307  jw->end_object();
1308  *os << endl;
1309  if (os->fail()) {
1310  socket_error(5);
1311  }
1312  jw->reset();
1313 }
1314 
1315 void GxMachineRemote::report_rpc_error(gx_system::JsonStringParser *jp, const gx_system::JsonException& e, const char *method) {
1316  if (method) {
1317  cerr << "RPC Error in " << method << "(): ";
1318  } else {
1319  cerr << "RPC Error: ";
1320  }
1321  cerr << e.what() << ": '" << jp->get_string() << "'" << endl;
1322  assert(false);
1323 }
1324 
1325 bool GxMachineRemote::idle_notify_handler() {
1326  for (unsigned int i = 0; i < notify_list.size(); ++i) {
1327  gx_system::JsonStringParser *jp = notify_list[i];
1328  handle_notify(jp);
1329  delete jp;
1330  }
1331  notify_list.clear();
1332  return false;
1333 }
1334 
1335 void GxMachineRemote::add_idle_handler() {
1336  if (!idle_conn.connected()) {
1337  idle_conn = Glib::signal_idle().connect(
1338  sigc::mem_fun(this, &GxMachineRemote::idle_notify_handler));
1339  }
1340 }
1341 
1342 void GxMachineRemote::throw_error(gx_system::JsonStringParser *jp) {
1344  int code = 0;
1345  Glib::ustring message;
1346  while (jp->peek() != gx_system::JsonParser::end_object) {
1348  if (jp->current_value() == "code") {
1350  code = jp->current_value_int();
1351  } else if (jp->current_value() == "message") {
1353  message = jp->current_value();
1354  }
1355  }
1357  cerr << jp->get_string() << std::flush;
1359  Glib::ustring::compose("RPC error %1 : %2", code, message));
1360 }
1361 
1362 void GxMachineRemote::socket_error(int loc) {
1363  if (!socket->is_closed()) {
1364  socket->close();
1365  }
1366  gx_print_fatal("Network", Glib::ustring::compose("Server has closed connection (%1)", loc));
1367 }
1368 
1369 gx_system::JsonStringParser *GxMachineRemote::receive() {
1370  char buf[10000];
1371  bool error = false;
1372  gx_system::JsonStringParser *jp_ret = 0;
1374  try {
1375  while (true) {
1376  int n;
1377  try {
1378  n = socket->receive(buf, sizeof(buf));
1379  } catch(Glib::Error e) {
1380  cerr << "Glib receive error: " << e.what() << endl;
1381  return 0;
1382  }
1383  if (n <= 0) {
1384  socket_error(6);
1385  return 0;
1386  }
1387  char *p = buf;
1388  while (n-- > 0) {
1389  jp->put(*p);
1390  if (*p == '\n') {
1391  jp->start_parser();
1393  jp->next(gx_system::JsonParser::value_key); // "jsonrpc"
1396  if (jp->current_value() == "id") {
1397  jp->next(); // id or null
1399  if (jp->current_value() == "error") {
1400  error = true;
1401  }
1402  assert(jp_ret == 0);
1403  jp_ret = jp;
1404  } else {
1405  assert(jp->current_value() == "method");
1406  notify_list.push_back(jp);
1407  add_idle_handler();
1408  }
1409  if (n == 0 && jp_ret) {
1410  if (error) {
1411  throw_error(jp_ret);
1412  }
1413  return jp_ret;
1414  }
1415  jp = new gx_system::JsonStringParser;
1416  }
1417  p++;
1418  }
1419  }
1420  } catch (const gx_system::JsonException& e) {
1421  report_rpc_error(jp, e);
1422  delete jp;
1423  return 0;
1424  }
1425 }
1426 
1427 bool GxMachineRemote::get_bool(gx_system::JsonStringParser *jp) {
1429  return bool(jp->current_value_int());
1430 }
1431 
1433  START_NOTIFY(setstate);
1434  jw->write(engine_state_to_string(state));
1435  SEND();
1436 }
1437 
1439  START_CALL(getstate);
1442  return string_to_engine_state(jp->current_value());
1444 }
1445 
1446 
1447 /*
1448 ** LadspaLoader
1449 */
1450 
1451 void GxMachineRemote::load_ladspalist(std::vector<std::string>& old_not_found, ladspa::LadspaPluginList& pluginlist) {
1453  START_RECEIVE();
1455  while (jp->peek() != gx_system::JsonParser::end_array) {
1457  old_not_found.push_back(jp->current_value());
1458  }
1460  pluginlist.readJSON(*jp);
1461  END_RECEIVE();
1462 }
1463 
1466  pluginlist.writeJSON(*jw);
1467  SEND();
1468 }
1469 
1470 void GxMachineRemote::update_plugins(gx_system::JsonParser *jp) {
1471  // deleted parameters
1473  while (jp->peek() != gx_system::JsonParser::end_array) {
1475  pmap.unregister(jp->current_value());
1476  }
1478  // inserted parameters
1480  pmap.set_replace_mode(true);
1481  while (jp->peek() != gx_system::JsonParser::end_array) {
1482  pmap.readJSON_one(*jp);
1483  }
1484  pmap.set_replace_mode(false);
1486  // updated plugins
1488  while (jp->peek() != gx_system::JsonParser::end_array) {
1491  PluginChange::pc c = static_cast<PluginChange::pc>(jp->current_value_int());
1492  if (c == PluginChange::remove) {
1494  Plugin *p = pluginlist.lookup_plugin(jp->current_value());
1495  plugin_changed(p, c);
1496  pluginlist.delete_module(p);
1497  } else {
1498  Plugin *p = new Plugin(*jp, pmap);
1499  if (c == PluginChange::add) {
1500  pluginlist.insert_plugin(p);
1501  } else {
1502  pluginlist.update_plugin(p);
1503  }
1504  plugin_changed(p, c);
1505  }
1507  }
1509  plugin_changed(0, PluginChange::update);
1510 }
1511 
1513  START_CALL(ladspaloader_update_plugins);
1514  START_RECEIVE();
1516  update_plugins(jp);
1518  END_RECEIVE();
1519 }
1520 
1521 sigc::signal<void,Plugin*,PluginChange::pc>& GxMachineRemote::signal_plugin_changed() {
1522  return plugin_changed;
1523 }
1524 
1525 
1526 /*
1527 ** PluginList
1528 */
1529 
1530 Plugin *GxMachineRemote::pluginlist_lookup_plugin(const std::string& id) const {
1531  return pluginlist.lookup_plugin(id);
1532 }
1533 
1535  pluginlist.append_rack(ui);
1536 }
1537 
1538 /*
1539 // unused now,
1540 static const char *next_char_pointer(gx_system::JsonParser *jp) {
1541  switch (jp->next()) {
1542  case gx_system::JsonParser::value_string: return jp->current_value().c_str();
1543  case gx_system::JsonParser::value_null: return 0;
1544  default: jp->throw_unexpected(gx_system::JsonParser::value_string); return 0;
1545  }
1546 }
1547 */
1548 
1549 static const std::string next_string(gx_system::JsonParser *jp) {
1552  }
1553  return jp->current_value();
1554 }
1555 
1556 int GxMachineRemote::load_remote_ui_static (const UiBuilder& builder, int form) {
1557  GxMachineRemote *m = dynamic_cast<GxMachineRemote*>(&static_cast<const gx_gui::UiBuilderImpl*>(&builder)->main.get_machine());
1558  return m->load_remote_ui(builder, form);
1559 }
1560 
1561 int GxMachineRemote::load_remote_ui(const UiBuilder& builder, int form) {
1562  START_CALL(plugin_load_ui);
1563  jw->write(builder.plugin->id);
1564  jw->write(form);
1565  START_RECEIVE(-1);
1567  while (jp->peek() != gx_system::JsonParser::end_array) {
1570  if (jp->current_value() == "openTabBox") {
1571  builder.openTabBox(next_string(jp).c_str());
1572  } else if (jp->current_value() == "openVerticalBox") {
1573  builder.openVerticalBox(next_string(jp).c_str());
1574  } else if (jp->current_value() == "openVerticalBox1") {
1575  builder.openVerticalBox1(next_string(jp).c_str());
1576  } else if (jp->current_value() == "openVerticalBox2") {
1577  builder.openVerticalBox2(next_string(jp).c_str());
1578  } else if (jp->current_value() == "openHorizontalhideBox") {
1579  builder.openHorizontalhideBox(next_string(jp).c_str());
1580  } else if (jp->current_value() == "openHorizontalTableBox") {
1581  builder.openHorizontalTableBox(next_string(jp).c_str());
1582  } else if (jp->current_value() == "openFrameBox") {
1583  builder.openFrameBox(next_string(jp).c_str());
1584  } else if (jp->current_value() == "openFlipLabelBox") {
1585  builder.openFlipLabelBox(next_string(jp).c_str());
1586  } else if (jp->current_value() == "openpaintampBox") {
1587  builder.openpaintampBox(next_string(jp).c_str());
1588  } else if (jp->current_value() == "openHorizontalBox") {
1589  builder.openHorizontalBox(next_string(jp).c_str());
1590  } else if (jp->current_value() == "insertSpacer") {
1591  builder.insertSpacer();
1592  } else if (jp->current_value() == "set_next_flags") {
1594  builder.set_next_flags(jp->current_value_int());
1595  } else if (jp->current_value() == "create_mid_rackknob") {
1596  std::string id = next_string(jp);
1597  std::string lab = next_string(jp);
1598  builder.create_mid_rackknob(id.c_str(), lab.c_str());
1599  } else if (jp->current_value() == "create_small_rackknob") {
1600  std::string id = next_string(jp);
1601  std::string lab = next_string(jp);
1602  builder.create_small_rackknob(id.c_str(), lab.c_str());
1603  } else if (jp->current_value() == "create_small_rackknobr") {
1604  std::string id = next_string(jp);
1605  std::string lab = next_string(jp);
1606  builder.create_small_rackknobr(id.c_str(), lab.c_str());
1607  } else if (jp->current_value() == "create_big_rackknob") {
1608  std::string id = next_string(jp);
1609  std::string lab = next_string(jp);
1610  builder.create_big_rackknob(id.c_str(), lab.c_str());
1611  } else if (jp->current_value() == "create_master_slider") {
1612  std::string id = next_string(jp);
1613  std::string lab = next_string(jp);
1614  builder.create_master_slider(id.c_str(), lab.c_str());
1615  } else if (jp->current_value() == "create_feedback_slider") {
1616  std::string id = next_string(jp);
1617  std::string lab = next_string(jp);
1618  builder.create_feedback_slider(id.c_str(), lab.c_str());
1619  } else if (jp->current_value() == "create_selector_no_caption") {
1620  std::string id = next_string(jp);
1621  builder.create_selector_no_caption(id.c_str());
1622  } else if (jp->current_value() == "create_selector") {
1623  std::string id = next_string(jp);
1624  std::string lab = next_string(jp);
1625  builder.create_selector(id.c_str(), lab.c_str());
1626  } else if (jp->current_value() == "create_simple_meter") {
1627  std::string id = next_string(jp);
1628  builder.create_simple_meter(id.c_str());
1629  } else if (jp->current_value() == "create_simple_c_meter") {
1630  std::string id = next_string(jp);
1631  std::string idl = next_string(jp);
1632  std::string lab = next_string(jp);
1633  builder.create_simple_c_meter(id.c_str(),idl.c_str(), lab.c_str());
1634  } else if (jp->current_value() == "create_spin_value") {
1635  std::string id = next_string(jp);
1636  std::string lab = next_string(jp);
1637  builder.create_spin_value(id.c_str(), lab.c_str());
1638  } else if (jp->current_value() == "create_switch_no_caption") {
1639  std::string sw_type = next_string(jp);
1640  std::string id = next_string(jp);
1641  builder.create_switch_no_caption(sw_type.c_str(), id.c_str());
1642  } else if (jp->current_value() == "create_feedback_switch") {
1643  std::string sw_type = next_string(jp);
1644  std::string id = next_string(jp);
1645  builder.create_feedback_switch(sw_type.c_str(), id.c_str());
1646  } else if (jp->current_value() == "create_fload_switch") {
1647  std::string sw_type = next_string(jp);
1648  std::string id = next_string(jp);
1649  std::string idf = next_string(jp);
1650  builder.create_fload_switch(sw_type.c_str(), id.c_str(), idf.c_str());
1651  } else if (jp->current_value() == "create_switch") {
1652  std::string sw_type = next_string(jp);
1653  std::string id = next_string(jp);
1654  std::string lab = next_string(jp);
1655  builder.create_switch(sw_type.c_str(), id.c_str(), lab.c_str());
1656  } else if (jp->current_value() == "create_wheel") {
1657  std::string id = next_string(jp);
1658  std::string lab = next_string(jp);
1659  builder.create_wheel(id.c_str(), lab.c_str());
1660  } else if (jp->current_value() == "create_port_display") {
1661  std::string id = next_string(jp);
1662  std::string lab = next_string(jp);
1663  builder.create_port_display(id.c_str(), lab.c_str());
1664  } else if (jp->current_value() == "create_p_display") {
1665  std::string id = next_string(jp);
1666  std::string idl = next_string(jp);
1667  std::string idh = next_string(jp);
1668  builder.create_p_display(id.c_str(),idl.c_str(),idh.c_str());
1669  } else if (jp->current_value() == "create_simple_spin_value") {
1670  std::string id = next_string(jp);
1671  builder.create_simple_spin_value(id.c_str());
1672  } else if (jp->current_value() == "create_eq_rackslider_no_caption") {
1673  std::string id = next_string(jp);
1674  builder.create_eq_rackslider_no_caption(id.c_str());
1675  } else if (jp->current_value() == "closeBox") {
1676  builder.closeBox();
1677  } else if (jp->current_value() == "load_glade") {
1679  builder.load_glade(jp->current_value().c_str());
1680  } else {
1681  cerr << "unknown uiBuilder function " << jp->current_value() << endl;
1682  jp->skip_object();
1683  }
1685  }
1687  return 0;
1688  END_RECEIVE(return -1);
1689 }
1690 
1692  pdef->load_ui = load_remote_ui_static;
1693  return builder.load_unit(pdef);
1694 }
1695 
1696 
1697 /*
1698 ** Oscilloscope
1699 */
1700 
1703  jw->write(a);
1704  SEND();
1705 }
1706 
1709  START_RECEIVE(1);
1710  return get_bool(jp);
1711  END_RECEIVE(return 1);
1712 }
1713 
1715  return oscilloscope_buffer;
1716 }
1717 
1720  SEND();
1721 }
1722 
1724  return pluginlist.lookup_plugin("oscilloscope")->get_box_visible();
1725 }
1726 
1728  return pmap["oscilloscope.pp"].signal_changed_int();
1729 }
1730 
1732  return pmap["ui.oscilloscope"].signal_changed_bool();
1733 }
1734 
1736  return oscilloscope_activation;
1737 }
1738 
1739 sigc::signal<void, unsigned int>& GxMachineRemote::signal_oscilloscope_size_change() {
1740  return oscilloscope_size_change;
1741 }
1742 
1745  START_RECEIVE(0);
1747  return jp->current_value_float();
1748  END_RECEIVE(return 0);
1749 }
1750 
1751 void GxMachineRemote::maxlevel_get(int channels, float *values) {
1752  START_CALL(get_max_output_level);
1753  jw->write(channels);
1754  START_RECEIVE();
1756  for (int i = 0; i < channels; i++) {
1757  if (jp->peek() != gx_system::JsonParser::end_array) {
1759  values[i] = jp->current_value_float();
1760  } else {
1761  values[i] = 0.0;
1762  }
1763  }
1764  END_RECEIVE();
1765 }
1766 
1767 void GxMachineRemote::get_oscilloscope_info(int& load, int& frames, bool& is_rt, jack_nframes_t& bsize) {
1769  START_RECEIVE();
1772  load = jp->current_value_int();
1774  frames = jp->current_value_int();
1776  is_rt = jp->current_value_int();
1778  bsize = jp->current_value_int();
1780  unsigned int sz = jp->current_value_int();
1781  if (oscilloscope_buffer_size != sz) {
1782  delete oscilloscope_buffer;
1783  oscilloscope_buffer = new float[sz];
1784  oscilloscope_buffer_size = sz;
1785  oscilloscope_size_change(sz);
1786  }
1788  float *p = oscilloscope_buffer;
1789  while (jp->peek() != gx_system::JsonParser::end_array) {
1791  *p++ = jp->current_value_float();
1792  }
1795  END_RECEIVE();
1796 }
1797 
1799  return options;
1800 }
1801 
1802 void GxMachineRemote::start_socket(sigc::slot<void> quit_mainloop, const Glib::ustring& host, int port) {
1803  assert(false);
1804 }
1805 
1807 }
1808 
1809 sigc::signal<void,const Glib::ustring&,const Glib::ustring&>& GxMachineRemote::tuner_switcher_signal_display() {
1810  return tuner_switcher_display;
1811 }
1812 
1813 sigc::signal<void,TunerSwitcher::SwitcherState>& GxMachineRemote::tuner_switcher_signal_set_state() {
1814  return tuner_switcher_set_state;
1815 }
1816 
1818  return tuner_switcher_selection_done;
1819 }
1820 
1821 sigc::signal<void,GxEngineState>& GxMachineRemote::signal_state_change() {
1822  return engine_state_change;
1823 }
1824 
1827  jw->write(on);
1828  SEND();
1829 }
1830 
1831 const std::vector<std::string>& GxMachineRemote::get_rack_unit_order(PluginType type) {
1832  bool stereo = (type == PLUGIN_TYPE_STEREO);
1833  std::vector<std::string>& l = (stereo ? rack_units.stereo : rack_units.mono);
1834  l.clear();
1836  jw->write(stereo);
1837  START_RECEIVE(l);
1838  try {
1840  while (jp->peek() != gx_system::JsonParser::end_array) {
1842  l.push_back(jp->current_value());
1843  }
1845  } catch (gx_system::JsonException e) {
1846  cerr << "JsonException: " << e.what() << ": '" << jp->get_string() << "'" << endl;
1847  assert(false);
1848  }
1849  return l;
1850  END_RECEIVE(return l);
1851 }
1852 
1854  return rack_units.rack_unit_order_changed;
1855 }
1856 
1857 void GxMachineRemote::remove_rack_unit(const std::string& unit, PluginType type) {
1859  jw->write(unit);
1860  jw->write(type == PLUGIN_TYPE_STEREO);
1861  SEND();
1862 }
1863 
1864 void GxMachineRemote::insert_rack_unit(const std::string& unit, const std::string& before, PluginType type) {
1866  jw->write(unit);
1867  jw->write(before);
1868  jw->write(type == PLUGIN_TYPE_STEREO);
1869  SEND();
1870 }
1871 
1872 // tuner_switcher
1875  START_RECEIVE(false);
1876  return get_bool(jp);
1877  END_RECEIVE(return false);
1878 }
1879 
1882  jw->write(v);
1883  SEND();
1884 }
1885 
1888  SEND();
1889 }
1890 
1893  jw->write(v);
1894  SEND();
1895 }
1896 
1897 // preset
1899  return (!get_current_bank().empty());
1900 }
1901 
1902 static const Glib::ustring empty_string;
1903 
1904 const Glib::ustring& GxMachineRemote::get_current_bank() {
1905  return current_bank;
1906 }
1907 
1909  return get_bank_file(get_current_bank());
1910 }
1911 
1912 const Glib::ustring& GxMachineRemote::get_current_name() {
1913  return current_preset;
1914 }
1915 
1916 gx_system::PresetFileGui* GxMachineRemote::get_bank_file(const Glib::ustring& bank) const { //FIXME
1917  return banks.get_file(bank)->get_guiwrapper();
1918 }
1919 
1920 Glib::ustring GxMachineRemote::get_bank_name(int n) {
1921  return banks.get_name(n);
1922 }
1923 
1924 void GxMachineRemote::msend_midi_cc(int cc, int pgn, int bgn, int num) {
1925  START_NOTIFY(sendcc);
1926  jw->write(cc);
1927  jw->write(pgn);
1928  jw->write(bgn);
1929  jw->write(num);
1930  SEND();
1931 }
1932 
1933 void GxMachineRemote::load_preset(gx_system::PresetFileGui *pf, const Glib::ustring& name) {
1934  int n = get_bank_index(get_current_bank());
1935  START_NOTIFY(setpreset);
1936  jw->write(pf->get_name());
1937  jw->write(name);
1938  SEND();
1939 #ifdef USE_MIDI_CC_OUT
1940  if (get_bank_index(pf->get_name()) != n) {
1941  msend_midi_cc(0xB0, 32, get_bank_index(pf->get_name()),3);
1942  }
1943  msend_midi_cc(0xC0, pf->get_index(name),0,2);
1944 #endif
1945 }
1946 
1948  START_NOTIFY(set_online_presets);
1949  SEND();
1950  // FIXME
1951 }
1952 
1954  /* noop */
1955 }
1956 
1958  return banks.size();
1959 }
1960 
1961 int GxMachineRemote::get_bank_index(const Glib::ustring& bank) {
1962  return banks.get_index(bank);
1963 }
1964 
1966  /* noop */
1967 }
1968 
1969 void GxMachineRemote::set_statefilename(const std::string& fn) {
1970  //FIXME move jack session handling inside machine
1971  /* noop */
1972 }
1973 
1974 void GxMachineRemote::save_to_state(bool preserve_preset) {
1975  //FIXME move jack session handling inside machine
1976  /* noop */
1977 }
1978 
1981  jw->write(pdef->id);
1982  START_RECEIVE();
1984  while (jp->peek() != gx_system::JsonParser::end_array) {
1987  Glib::ustring name = jp->current_value();
1989  presetnames.push_back(gx_preset::PluginPresetEntry(name, jp->current_value_int()));
1991  }
1993  END_RECEIVE();
1994 }
1995 
1996 void GxMachineRemote::plugin_preset_list_set(const PluginDef *pdef, bool factory, const Glib::ustring& name) {
1998  jw->write(pdef->id);
1999  jw->write(factory);
2000  jw->write(name);
2001  SEND();
2002 }
2003 
2004 void GxMachineRemote::plugin_preset_list_save(const PluginDef *pdef, const Glib::ustring& name) {
2006  jw->write(pdef->id);
2007  jw->write(name);
2008  SEND();
2009 }
2010 
2011 void GxMachineRemote::plugin_preset_list_remove(const PluginDef *pdef, const Glib::ustring& name) {
2013  jw->write(pdef->id);
2014  jw->write(name);
2015  SEND();
2016 }
2017 
2019  //FIXME: move inside machine
2020  /* noop */
2021 }
2022 
2024  return selection_changed;
2025 }
2026 
2028  return presetlist_changed;
2029 }
2030 
2031 gx_system::PresetFileGui *GxMachineRemote::bank_insert_uri(const Glib::ustring& uri, bool move) {
2032  START_CALL(bank_insert_content);
2033  jw->write(uri);
2034  Glib::RefPtr<Gio::File> rem = Gio::File::create_for_uri(uri);
2035  fstream f(rem->get_path().c_str());
2036  stringstream s;
2037  s << f.rdbuf();
2038  jw->write(s.str());
2039  START_RECEIVE(0);
2041  return 0;
2042  }
2044  pf->readJSON_remote(*jp);
2045  banks.insert(pf);
2046  return pf->get_guiwrapper();
2047  END_RECEIVE(return 0);
2048 }
2049 
2052  jw->write(newname);
2053  START_RECEIVE(0);
2055  pf->readJSON_remote(*jp);
2056  banks.insert(pf);
2057  return pf->get_guiwrapper();
2058  END_RECEIVE(return 0);
2059 }
2060 
2061 bool GxMachineRemote::rename_bank(const Glib::ustring& oldname, Glib::ustring& newname) {
2063  jw->write(oldname);
2064  jw->write(newname);
2065  START_RECEIVE(false);
2068  bool ret = jp->current_value_int();
2070  newname = jp->current_value();
2072  if (ret) {
2073  banks.get_file(oldname)->name = newname;
2074  }
2075  return ret;
2076  END_RECEIVE(return false);
2077 }
2078 
2079 bool GxMachineRemote::rename_preset(gx_system::PresetFileGui& pf, const Glib::ustring& oldname, const Glib::ustring& newname) {
2081  jw->write(pf.get_name());
2082  jw->write(oldname);
2083  jw->write(newname);
2084  START_RECEIVE(false);
2085  bool ret = get_bool(jp);
2086  if (ret) {
2087  int idx = pf.get_index(oldname);
2088  assert(idx >= 0);
2089  pf.entries[idx].name = newname;
2090  }
2091  return ret;
2092  END_RECEIVE(return false);
2093 }
2094 
2095 void GxMachineRemote::bank_reorder(const std::vector<Glib::ustring>& neworder) {
2097  for (std::vector<Glib::ustring>::const_iterator i = neworder.begin(); i != neworder.end(); ++i) {
2098  jw->write(*i);
2099  }
2100  SEND();
2101  banks.reorder(neworder);
2102 }
2103 
2104 void GxMachineRemote::reorder_preset(gx_system::PresetFileGui& pf, const std::vector<Glib::ustring>& neworder) {
2106  jw->write(pf.get_name());
2107  for (std::vector<Glib::ustring>::const_iterator i = neworder.begin(); i != neworder.end(); ++i) {
2108  jw->write(*i);
2109  }
2110  SEND();
2111  int n = 0;
2112  for (std::vector<Glib::ustring>::const_iterator i = neworder.begin(); i != neworder.end(); ++i) {
2113  pf.entries[n++].name = *i;
2114  }
2115  presetlist_changed();
2116 }
2117 
2120  START_RECEIVE(false);
2121  return get_bool(jp);
2122  END_RECEIVE(return false);
2123 }
2124 
2125 void GxMachineRemote::erase_preset(gx_system::PresetFileGui& pf, const Glib::ustring& name) {
2127  jw->write(pf.get_name());
2128  jw->write(name);
2129  SEND();
2130  for (gx_system::PresetFile::iterator i = pf.begin(); i != pf.end(); ++i) {
2131  if (i->name == name) {
2132  pf.entries.erase(i);
2133  break;
2134  }
2135  }
2136 }
2137 
2140  jw->write(pf->get_name());
2141  jw->write(flag);
2142  jw->write(v);
2143  SEND();
2144  pf->set_flag(flag, v);
2145 }
2146 
2147 std::string GxMachineRemote::bank_get_filename(const Glib::ustring& bank) {
2148  // FIXME Gtk3: bank_get_filename is used in DnD bank operation, and the
2149  // first request is due to an internal window of the DnD mechanism but
2150  // there seems to be no way to detect this. Skip this first request so
2151  // that no contents is send for a DnD reorder operation. Recheck for Gtk3
2152  switch (bank_drag_get_counter) {
2153  case 0:
2154  bank_drag_get_counter++;
2155  return "";
2156  case 1:
2157  bank_drag_get_counter++;
2158  START_CALL(bank_get_contents);
2159  jw->write(bank);
2160  START_RECEIVE(empty_string);
2163  Glib::RefPtr<Gio::File> target = Gio::File::create_for_path(
2164  options.get_temp_filepath(
2165  Gio::File::create_for_path(jp->current_value())->get_basename()));
2167  Glib::RefPtr<Gio::FileOutputStream> s = target->replace(
2168  "", false, Gio::FILE_CREATE_REPLACE_DESTINATION);
2169  s->write(jp->current_value());
2170  s->close();
2172  bank_drag_get_path = target->get_path();
2173  END_RECEIVE(return empty_string);
2174  }
2175  return bank_drag_get_path;
2176 }
2177 
2179  bank_drag_get_counter = 0;
2180  bank_drag_get_path.clear();
2181 }
2182 
2184  return banks.get_file(bank)->get_guiwrapper();
2185 }
2186 
2188  return banks.begin();
2189 }
2190 
2192  return banks.end();
2193 }
2194 
2195 void GxMachineRemote::pf_append(gx_system::PresetFileGui& pf, const Glib::ustring& src, gx_system::PresetFileGui& pftgt, const Glib::ustring& name) {
2197  jw->write(pf.get_name());
2198  jw->write(src);
2199  jw->write(pftgt.get_name());
2200  jw->write(name);
2201  SEND();
2202  pftgt.entries.push_back(gx_system::PresetFile::Position(name,0));
2203 }
2204 
2205 void GxMachineRemote::pf_insert_before(gx_system::PresetFileGui& pf, const Glib::ustring& src, gx_system::PresetFileGui& pftgt, const Glib::ustring& pos, const Glib::ustring& name) {
2207  jw->write(pf.get_name());
2208  jw->write(src);
2209  jw->write(pftgt.get_name());
2210  jw->write(pos);
2211  jw->write(name);
2212  SEND();
2213  for (gx_system::PresetFile::iterator i = pftgt.begin(); i != pftgt.end(); ++i) {
2214  if (i->name == pos) {
2215  pftgt.entries.insert(i, gx_system::PresetFile::Position(name, 0));
2216  break;
2217  }
2218  }
2219 }
2220 
2221 void GxMachineRemote::pf_insert_after(gx_system::PresetFileGui& pf, const Glib::ustring& src, gx_system::PresetFileGui& pftgt, const Glib::ustring& pos, const Glib::ustring& name) {
2223  jw->write(pf.get_name());
2224  jw->write(src);
2225  jw->write(pftgt.get_name());
2226  jw->write(pos);
2227  jw->write(name);
2228  SEND();
2229  for (gx_system::PresetFile::iterator i = pftgt.begin(); i != pftgt.end(); ++i) {
2230  if (i->name == pos) {
2231  pftgt.entries.insert(++i, gx_system::PresetFile::Position(name, 0));
2232  break;
2233  }
2234  }
2235 }
2236 
2239  jw->write(pf.get_name());
2240  START_RECEIVE(false);
2241  bool ret = get_bool(jp);
2242  if (ret) {
2244  }
2245  return ret;
2246  END_RECEIVE(return false);
2247 }
2248 
2249 bool GxMachineRemote::bank_remove(const Glib::ustring& bank) {
2250  gx_system::PresetFile *f = banks.get_file(bank);
2252  jw->write(bank);
2253  START_RECEIVE(false);
2254  bool ret = get_bool(jp);
2255  if (ret) {
2256  banks.banklist.remove(f);
2257  delete f;
2258  }
2259  return ret;
2260  END_RECEIVE(return false);
2261 }
2262 
2265  SEND();
2266 }
2267 
2268 void GxMachineRemote::pf_save(gx_system::PresetFileGui& pf, const Glib::ustring& name) {
2270  jw->write(pf.get_name());
2271  jw->write(name);
2272  SEND();
2273 }
2274 
2275 
2276 // jack
2278  return 0;
2279 }
2280 
2283  jw->write(v);
2284  SEND();
2285 }
2286 
2287 // pmap
2289  return pmap[p];
2290 }
2291 
2293  return pmap[id];
2294 }
2295 
2297  for (ParamMap::iterator i = pmap.begin(); i != pmap.end(); ++i) {
2298  Parameter *p = i->second;
2299  if (p->isFloat()) {
2300  FloatParameter& pf = p->getFloat();
2301  pf.signal_changed()(pf.get_value());
2302  } else if (p->isInt()) {
2303  IntParameter& pi = p->getInt();
2304  pi.signal_changed()(pi.get_value());
2305  } else if (p->isBool()) {
2306  BoolParameter& pb = p->getBool();
2307  pb.signal_changed()(pb.get_value());
2308  } else if (p->isString()) {
2309  StringParameter& ps = p->getString();
2310  ps.signal_changed()(ps.get_value());
2311  } else if (p->isFile()) {
2312  FileParameter& fp = p->getFile();
2313  fp.signal_changed()();
2314  } else if (dynamic_cast<JConvParameter*>(i->second) != 0) {
2315  JConvParameter* pj = dynamic_cast<JConvParameter*>(i->second);
2316  pj->signal_changed()(&pj->get_value());
2317  } else if (dynamic_cast<SeqParameter*>(i->second) != 0) {
2318  SeqParameter* pj = dynamic_cast<SeqParameter*>(i->second);
2319  pj->signal_changed()(&pj->get_value());
2320  }
2321  }
2322  selection_changed(); // give preset window a chance to catch up on current preset
2323  Glib::signal_io().connect(
2324  sigc::mem_fun(this, &GxMachineRemote::socket_input_handler),
2325  socket->get_fd(), Glib::IO_IN);
2326  for (ParamMap::iterator i = pmap.begin(); i != pmap.end(); ++i) {
2327  if (i->second->isInt()) {
2328  i->second->getInt().signal_changed().connect(
2329  sigc::hide(
2330  sigc::bind(
2331  sigc::mem_fun(this, &GxMachineRemote::param_signal), i->second)));
2332  } else if (i->second->isBool()) {
2333  i->second->getBool().signal_changed().connect(
2334  sigc::hide(
2335  sigc::bind(
2336  sigc::mem_fun(this, &GxMachineRemote::param_signal), i->second)));
2337  } else if (i->second->isFloat()) {
2338  i->second->getFloat().signal_changed().connect(
2339  sigc::hide(
2340  sigc::bind(
2341  sigc::mem_fun(this, &GxMachineRemote::param_signal), i->second)));
2342  } else if (i->second->isString()) {
2343  i->second->getString().signal_changed().connect(
2344  sigc::hide(
2345  sigc::bind(
2346  sigc::mem_fun(this, &GxMachineRemote::param_signal), i->second)));
2347  } else if (dynamic_cast<JConvParameter*>(i->second) != 0) {
2348  dynamic_cast<JConvParameter*>(i->second)->signal_changed().connect(
2349  sigc::hide(
2350  sigc::bind(
2351  sigc::mem_fun(this, &GxMachineRemote::param_signal), i->second)));
2352  } else if (dynamic_cast<SeqParameter*>(i->second) != 0) {
2353  dynamic_cast<SeqParameter*>(i->second)->signal_changed().connect(
2354  sigc::hide(
2355  sigc::bind(
2356  sigc::mem_fun(this, &GxMachineRemote::param_signal), i->second)));
2357  }
2358  }
2359 }
2360 
2362  return pmap.hasId(p);
2363 }
2364 
2365 bool GxMachineRemote::parameter_hasId(const std::string& id) {
2366  return pmap.hasId(id);
2367 }
2368 
2369 void GxMachineRemote::reset_unit(const PluginDef *pdef) const {
2370  pmap.reset_unit(pdef);
2371 }
2372 
2374  return pmap.unit_has_std_values(pdef);
2375 }
2376 
2377 void GxMachineRemote::set_parameter_value(const std::string& id, int value) {
2378  pmap[id].getInt().set(value);
2379 }
2380 
2381 void GxMachineRemote::set_parameter_value(const std::string& id, bool value) {
2382  pmap[id].getBool().set(value);
2383 }
2384 
2385 void GxMachineRemote::set_parameter_value(const std::string& id, float value) {
2386  pmap[id].getFloat().set(value);
2387 }
2388 
2389 void GxMachineRemote::set_parameter_value(const std::string& id, const std::string& value) {
2390  if (!pmap[id].getString().set(value)) {
2391  return;
2392  }
2393  START_NOTIFY(set);
2394  jw->write(id);
2395  jw->write(value);
2396  SEND();
2397 }
2398 
2399 int GxMachineRemote::_get_parameter_value_int(const std::string& id) {
2400  START_CALL(get);
2401  jw->write(id);
2402  START_RECEIVE(0);
2405  int v;
2406  switch (jp->next()) {
2408  v = pmap[id].getEnum().idx_from_id(jp->current_value());
2409  break;
2411  v = jp->current_value_int();
2412  break;
2413  default:
2414  assert(false);
2415  return 0;
2416  }
2417  return v;
2418  END_RECEIVE(return 0);
2419 }
2420 
2421 int GxMachineRemote::_get_parameter_value_bool(const std::string& id) {
2422  START_CALL(get);
2423  jw->write(id);
2424  START_RECEIVE(false);
2428  return jp->current_value_int();
2429  END_RECEIVE(return false);
2430 }
2431 
2432 float GxMachineRemote::_get_parameter_value_float(const std::string& id) {
2433  START_CALL(get);
2434  jw->write(id);
2435  START_RECEIVE(0);
2438  float v;
2439  switch (jp->next()) {
2441  v = dynamic_cast<FloatEnumParameter*>(&pmap[id])->idx_from_id(jp->current_value());
2442  break;
2444  v = jp->current_value_float();
2445  break;
2446  default:
2447  assert(false);
2448  return 0;
2449  }
2450  return v;
2451  END_RECEIVE(return 0);
2452 }
2453 
2454 std::string GxMachineRemote::_get_parameter_value_string(const std::string& id) {
2455  START_CALL(get);
2456  jw->write(id);
2457  START_RECEIVE(empty_string);
2461  return jp->current_value();
2462  END_RECEIVE(return empty_string);
2463 }
2464 
2465 sigc::signal<void, int>& GxMachineRemote::_signal_parameter_value_int(const std::string& id) {
2466  return pmap[id].signal_changed_int();
2467 }
2468 
2469 sigc::signal<void, bool>& GxMachineRemote::_signal_parameter_value_bool(const std::string& id) {
2470  return pmap[id].signal_changed_bool();
2471 }
2472 
2473 sigc::signal<void, float>& GxMachineRemote::_signal_parameter_value_float(const std::string& id) {
2474  return pmap[id].signal_changed_float();
2475 }
2476 
2477 // MidiControllerList
2480  START_RECEIVE(false);
2482  bool ret = get_bool(jp);
2484  if (ret && ctl) {
2485  *ctl = jp->current_value_int();
2486  }
2488  return ret;
2489  END_RECEIVE(return false);
2490 }
2491 
2494  jw->write(v);
2495  jw->write(ctl);
2496  SEND();
2497 }
2498 
2500  return midi_changed;
2501 }
2502 
2503 sigc::signal<void, int, int>& GxMachineRemote::signal_midi_value_changed() {
2504  return midi_value_changed;
2505 }
2506 
2509  SEND();
2510 }
2511 
2513  return midi_controller_map.size();
2514 }
2515 
2517  return midi_controller_map[n];
2518 }
2519 
2522  jw->write(param.id());
2523  SEND();
2524 }
2525 
2528  jw->write(v);
2529  SEND();
2530 }
2531 
2532 void GxMachineRemote::midi_modifyCurrent(Parameter& param, float lower, float upper, bool toggle, int toggle_behaviour) {
2534  jw->write(param.id());
2535  jw->write(lower);
2536  jw->write(upper);
2537  jw->write(toggle);
2538  jw->write(toggle_behaviour);
2539  SEND();
2540 }
2541 
2543  return midi_controller_map.param2controller(param, p);
2544 }
2545 
2546 // Convolver
2547 
2548 void GxMachineRemote::reload_impresp_list(const std::string& path) {
2550  jw->write(path);
2551  SEND();
2552 }
2553 
2554 void GxMachineRemote::load_impresp_dirs(std::vector<gx_system::FileName>& dirs) {
2556  START_RECEIVE();
2558  while (jp->peek() != gx_system::JsonParser::end_array) {
2561  std::string filename = jp->current_value();
2563  dirs.push_back(gx_system::FileName(filename, jp->current_value()));
2565  }
2567  END_RECEIVE();
2568 }
2569 
2570 bool GxMachineRemote::read_audio(const std::string& filename, unsigned int *audio_size, int *audio_chan,
2571  int *audio_type, int *audio_form, int *audio_rate, float **buffer) {
2573  jw->write(filename);
2574  START_RECEIVE(false);
2576  *audio_size = 0;
2577  *audio_chan = *audio_type = *audio_form = *audio_rate = 0;
2578  *buffer = 0;
2579  return false;
2580  }
2583  *audio_size = jp->current_value_int();
2585  *audio_chan = jp->current_value_int();
2587  *audio_type = jp->current_value_int();
2589  *audio_form = jp->current_value_int();
2591  *audio_rate = jp->current_value_int();
2593  *buffer = new float[*audio_size * *audio_chan];
2594  float *p = *buffer;
2595  while (jp->peek() != gx_system::JsonParser::end_array) {
2597  *p++ = jp->current_value_float();
2598  }
2601  return true;
2602  END_RECEIVE(return false);
2603 }
2604 
2605 } // namespace gx_engine
iterator end()
Definition: gx_json.h:366
void write_kv(const char *key, float v)
Definition: gx_json.h:81
bool register_service(std::string name, int port)
virtual void plugin_preset_list_set(const PluginDef *pdef, bool factory, const Glib::ustring &name)
Definition: machine.cpp:1996
virtual Glib::ustring get_bank_name(int n)
Definition: machine.cpp:474
virtual void bank_set_flag(gx_system::PresetFileGui *pf, int flag, bool v)
Definition: machine.cpp:2138
virtual void midi_set_current_control(int v)
Definition: machine.cpp:787
gx_system::PresetFile * bank_insert_uri(const Glib::ustring &uri, bool move)
Definition: gx_preset.cpp:1014
virtual void tuner_used_for_display(bool on)
Definition: machine.cpp:407
void readJSON_remote(JsonParser &jp)
Definition: gx_json.cpp:877
virtual const Glib::ustring & get_current_name()
Definition: machine.cpp:1912
CmdConnection::msg_type start
Definition: jsonrpc.cpp:255
virtual void start_socket(sigc::slot< void > quit_mainloop, const Glib::ustring &host, int port)
Definition: machine.cpp:371
void throw_unexpected(token expect)
Definition: gx_json.cpp:303
virtual void load_ladspalist(std::vector< std::string > &old_not_found, ladspa::LadspaPluginList &pluginlist)
Definition: machine.cpp:259
void begin_array(bool nl=false)
Definition: gx_json.cpp:184
Definition: gx_preset.h:128
void save(PresetFile &pf, const Glib::ustring &name)
Definition: gx_json.cpp:1891
void modifyCurrent(Parameter &param, float lower, float upper, bool toggle, int toggle_behaviour)
PresetFile * get_current_bank_file()
Definition: gx_json.h:483
virtual void insert_rack_unit(const std::string &unit, const std::string &before, PluginType type)
Definition: machine.cpp:1864
bool rename_preset(PresetFile &pf, const Glib::ustring &oldname, const Glib::ustring &newname)
Definition: gx_json.cpp:2009
virtual void msend_midi_cc(int cc, int pgn, int bgn, int num)
Definition: machine.cpp:487
int param2controller(Parameter &param, const MidiController **p)
Glib::Dispatcher & signal_jack_load_change()
virtual void reorder_preset(gx_system::PresetFileGui &pf, const std::vector< Glib::ustring > &neworder)
Definition: machine.cpp:2104
virtual void disable_autosave(bool v)
Definition: machine.cpp:2018
virtual void save_ladspalist(ladspa::LadspaPluginList &pluginlist)
Definition: machine.cpp:1464
virtual float get_tuner_freq()
Definition: machine.cpp:291
virtual bool rename_preset(gx_system::PresetFileGui &pf, const Glib::ustring &oldname, const Glib::ustring &newname)
Definition: machine.cpp:2079
virtual int idx_from_id(string v_id)
virtual void stop_socket()
Definition: machine.cpp:362
virtual sigc::signal< void > & signal_midi_changed()
Definition: machine.cpp:763
bool remove_rack_unit(const std::string &unit, bool stereo)
Definition: gx_preset.cpp:984
virtual int midi_param2controller(Parameter &param, const MidiController **p)
Definition: machine.cpp:796
sigc::signal< void > & signal_changed()
Definition: gx_parameter.h:781
virtual Plugin * pluginlist_lookup_plugin(const std::string &id) const
Definition: machine.cpp:279
void disable_autosave(bool v)
Definition: gx_preset.h:169
void writeJSON(gx_system::JsonWriter &jw)
OscilloscopeAdapter oscilloscope
Definition: gx_engine.h:89
TunerAdapter tuner
Definition: gx_engine.h:86
BoolParameter * reg_non_midi_par(const string &id, bool *var, bool preset, bool std=false)
Definition: gx_parameter.h:594
sigc::signal< void, const std::string &, std::vector< gx_system::FileName > > impresp_list
Definition: machine.h:53
void(* insertSpacer)()
Definition: gx_plugin.h:78
virtual void load_impresp_dirs(std::vector< gx_system::FileName > &dirs)
Definition: machine.cpp:2554
virtual void pf_insert_after(gx_system::PresetFileGui &pf, const Glib::ustring &src, gx_system::PresetFileGui &pftgt, const Glib::ustring &pos, const Glib::ustring &name)
Definition: machine.cpp:639
MidiStandardControllers midi_std_ctr
virtual const float * get_oscilloscope_buffer()
Definition: machine.cpp:1714
virtual void set_state(GxEngineState state)
Definition: machine.cpp:251
map< string, Parameter * >::const_iterator iterator
Definition: gx_parameter.h:532
void setSavable(bool v)
Definition: gx_parameter.h:171
sigc::signal< void, SwitcherState > & signal_set_state()
Definition: tunerswitcher.h:71
virtual bool parameter_unit_has_std_values(const PluginDef *pdef) const
Definition: machine.cpp:2373
Parameter * readJSON_one(gx_system::JsonParser &jp)
void create_default_scratch_preset()
Definition: gx_preset.cpp:970
PluginDef * plugin
Definition: gx_plugin.h:64
std::vector< std::string > & get_rack_unit_order(bool stereo)
Definition: gx_preset.h:176
void insert(PresetFile *f)
Definition: gx_json.h:449
void unregister(Parameter *p)
void(* create_fload_switch)(const char *sw_type, const char *id, const char *idf)
Definition: gx_plugin.h:102
void(* load_glade)(const char *data)
Definition: gx_plugin.h:65
virtual void midi_set_current_control(int v)
Definition: machine.cpp:2526
virtual sigc::signal< void, bool > & signal_rack_unit_order_changed()
Definition: machine.cpp:415
gx_engine::GxEngineState string_to_engine_state(const std::string &s)
Definition: jsonrpc.cpp:39
void end_array(bool nl=false)
Definition: gx_json.cpp:192
bool get_is_rt()
Definition: gx_jack.h:181
void set_config_mode(bool mode, int ctl=-1)
virtual int get_oscilloscope_mul_buffer()
Definition: machine.cpp:299
bool load_unit(PluginDef *pl)
void dump(const string &fmt)
virtual int bank_size()
Definition: machine.cpp:517
virtual void maxlevel_get(int channels, float *values)
Definition: machine.cpp:331
bool isBool() const
Definition: gx_parameter.h:164
virtual void load_online_presets()
Definition: machine.cpp:502
virtual void midi_modifyCurrent(Parameter &param, float lower, float upper, bool toggle, int toggle_behaviour)
Definition: machine.cpp:2532
void activate(bool tuner_active)
virtual void start_socket(sigc::slot< void > quit_mainloop, const Glib::ustring &host, int port)
Definition: machine.cpp:1802
FloatParameter * reg_par_non_preset(const string &id, const string &name, float *var, float std, float lower, float upper, float step)
Definition: gx_parameter.h:558
#define END_RECEIVE(s)
Definition: machine.cpp:842
bool isFile() const
Definition: gx_parameter.h:165
virtual sigc::signal< void > & signal_midi_changed()
Definition: machine.cpp:2499
virtual void reset_unit(const PluginDef *pdef) const
Definition: machine.cpp:690
void readJSON(gx_system::JsonParser &jp, ParamMap &param)
void(* openFlipLabelBox)(const char *label)
Definition: gx_plugin.h:75
void on_engine_bypass_changed(bool s, GxEngine &engine)
Definition: machine.cpp:78
virtual bool rename_bank(const Glib::ustring &oldname, Glib::ustring &newname)
Definition: machine.cpp:583
virtual std::string bank_get_filename(const Glib::ustring &bank)
Definition: machine.cpp:2147
virtual void disable_autosave(bool v)
Definition: machine.cpp:553
virtual void plugin_preset_list_save(const PluginDef *pdef, const Glib::ustring &name)
Definition: machine.cpp:2004
virtual sigc::signal< void, GxEngineState > & signal_state_change()
Definition: machine.cpp:403
std::vector< PluginPresetEntry > UnitPresetList
Definition: gx_preset.h:135
#define N_(String)
Glib::ustring name
Definition: gx_json.h:314
virtual void stop_socket()
Definition: machine.cpp:1806
bool remove_bank(const Glib::ustring &bank)
Definition: gx_json.cpp:1999
virtual void bank_save()
Definition: machine.cpp:2263
virtual void commit_ladspa_changes()
Definition: machine.cpp:1512
virtual bool midi_get_config_mode(int *ctl=0)
Definition: machine.cpp:2478
virtual bool parameter_unit_has_std_values(const PluginDef *pdef) const
Definition: machine.cpp:694
PresetFile * get_file(const Glib::ustring &bank) const
Definition: gx_json.cpp:1623
void(* openTabBox)(const char *label)
Definition: gx_plugin.h:67
MaxLevel maxlevel
Definition: gx_engine.h:88
virtual void set_statefilename(const std::string &fn)
Definition: machine.cpp:529
void(* create_feedback_switch)(const char *sw_type, const char *id)
Definition: gx_plugin.h:90
void reorder(const std::vector< Glib::ustring > &neworder)
Definition: gx_json.cpp:1669
virtual void set_init_values()
Definition: machine.cpp:2296
virtual void erase_preset(gx_system::PresetFileGui &pf, const Glib::ustring &name)
Definition: machine.cpp:603
virtual bool parameter_hasId(const char *p)
Definition: machine.cpp:682
bool set(const Glib::ustring &val) const
float get_maxlevel(unsigned int channel)
Definition: jsonrpc.h:179
virtual bank_iterator bank_begin()
Definition: machine.cpp:623
#define SEND()
Definition: machine.cpp:833
virtual void set_jack_insert(bool v)
Definition: machine.cpp:665
virtual void set_jack_insert(bool v)
Definition: machine.cpp:2281
FileParameter & getFile()
Definition: gx_parameter.h:473
virtual int midi_param2controller(Parameter &param, const MidiController **p)
Definition: machine.cpp:2542
bool isString() const
Definition: gx_parameter.h:166
void(* create_switch_no_caption)(const char *sw_type, const char *id)
Definition: gx_plugin.h:89
virtual midi_controller_list & midi_get(int n)
Definition: machine.cpp:2516
int param2controller(Parameter &param, const MidiController **p)
Definition: gx_parameter.h:772
GxMachine(gx_system::CmdlineOptions &options)
Definition: machine.cpp:88
void set_flag(int flag, bool v)
Definition: gx_json.h:360
Glib::ustring get_name(int n)
Definition: gx_json.cpp:1687
virtual bool read_audio(const std::string &filename, unsigned int *audio_size, int *audio_chan, int *audio_type, int *audio_form, int *audio_rate, float **buffer)
Definition: machine.cpp:817
virtual sigc::signal< void, bool > & tuner_switcher_signal_selection_done()
Definition: machine.cpp:399
virtual void clear_oscilloscope_buffer()
Definition: machine.cpp:1718
sigc::signal< void, bool > & signal_selection_done()
Definition: tunerswitcher.h:72
jack_nframes_t get_jack_bs()
Definition: gx_jack.h:179
sigc::signal< void, bool > rack_unit_order_changed
Definition: gx_preset.h:40
void append(PresetFile &pf, const Glib::ustring &src, PresetFile &pftgt, const Glib::ustring &name)
Definition: gx_json.cpp:1844
std::vector< Position >::iterator iterator
Definition: gx_json.h:321
virtual bool bank_remove(const Glib::ustring &bank)
Definition: machine.cpp:647
bool rename_bank(const Glib::ustring &oldname, Glib::ustring &newname)
Definition: gx_preset.cpp:1089
virtual void set_oscilloscope_mul_buffer(int a)
Definition: machine.cpp:1701
bool read_audio(const std::string &filename, unsigned int *audio_size, int *audio_chan, int *audio_type, int *audio_form, int *audio_rate, float **buffer)
std::vector< std::string > mono
Definition: gx_preset.h:38
virtual Plugin * pluginlist_lookup_plugin(const std::string &id) const
Definition: machine.cpp:1530
bool get_box_visible() const
virtual gx_system::PresetFileGui * bank_insert_uri(const Glib::ustring &uri, bool move)
Definition: machine.cpp:565
iterator end() const
Definition: gx_parameter.h:534
void load(gx_system::CmdlineOptions &options, std::vector< std::string > &old_not_found)
void(* create_p_display)(const char *id, const char *idl, const char *idh)
Definition: gx_plugin.h:93
void(* closeBox)()
Definition: gx_plugin.h:77
sigc::signal< void, int > & signal_new_program()
Definition: gx_parameter.h:782
virtual void pf_append(gx_system::PresetFileGui &pf, const Glib::ustring &src, gx_system::PresetFileGui &pftgt, const Glib::ustring &name)
Definition: machine.cpp:2195
bool isInt() const
Definition: gx_parameter.h:163
void write_key(const char *p, bool nl=false)
Definition: gx_json.cpp:200
void set_jack_insert(bool v)
Definition: gx_jack.h:191
void update_maxlevel(CmdConnection *cmd=0)
Definition: jsonrpc.cpp:2188
PluginType
Definition: machine.h:32
void ladspaloader_update_plugins(gx_system::JsonWriter *jw, CmdConnection *cmd)
Definition: jsonrpc.cpp:1807
virtual GxEngineState get_state()
Definition: machine.cpp:255
virtual ~GxMachineBase()
Definition: machine.cpp:56
std::vector< Position > entries
Definition: gx_json.h:313
sigc::signal< void, const GxJConvSettings * > & signal_changed()
virtual void tuner_used_for_display(bool on)
Definition: machine.cpp:1825
virtual void plugin_preset_list_set(const PluginDef *pdef, bool factory, const Glib::ustring &name)
Definition: machine.cpp:541
virtual void remove_rack_unit(const std::string &unit, PluginType type)
Definition: machine.cpp:419
void gx_print_fatal(const char *, const std::string &)
Definition: gx_logging.cpp:177
virtual sigc::signal< void, int, int > & signal_midi_value_changed()
Definition: machine.cpp:767
virtual gx_system::PresetFileGui * get_bank_file(const Glib::ustring &bank) const
Definition: machine.cpp:1916
sigc::signal< void, float > & signal_changed()
Definition: gx_parameter.h:270
virtual void save_ladspalist(ladspa::LadspaPluginList &pluginlist)
Definition: machine.cpp:263
virtual bool read_audio(const std::string &filename, unsigned int *audio_size, int *audio_chan, int *audio_type, int *audio_form, int *audio_rate, float **buffer)
Definition: machine.cpp:2570
float get_jcpu_load()
Definition: gx_jack.h:180
const Glib::ustring & get_rpcaddress()
Definition: gx_system.h:492
int insert_plugin(Plugin *pvars)
StringParameter * reg_string(const string &id, const string &name, Glib::ustring *var, const string &sv, bool preset=false)
Definition: gx_parameter.h:615
bool get_active()
Definition: tunerswitcher.h:66
virtual const std::vector< std::string > & get_rack_unit_order(PluginType type)
Definition: machine.cpp:1831
sigc::signal< void > & signal_selection_changed()
Definition: gx_json.h:476
virtual void midi_set_config_mode(bool v, int ctl=-1)
Definition: machine.cpp:2492
virtual gx_system::PresetFileGui * bank_insert_uri(const Glib::ustring &uri, bool move)
Definition: machine.cpp:2031
virtual void readJSON_value(gx_system::JsonParser &jp)
sigc::signal< void, Plugin *, PluginChange::pc > & signal_plugin_changed()
Definition: gx_engine.h:107
virtual void remove_rack_unit(const std::string &unit, PluginType type)
Definition: machine.cpp:1857
virtual void set_statefilename(const std::string &fn)
Definition: machine.cpp:1969
virtual void reset_unit(const PluginDef *pdef) const
Definition: machine.cpp:2369
virtual void maxlevel_get(int channels, float *values)
Definition: machine.cpp:1751
sigc::signal< void, int, int > & signal_midi_value_changed()
Definition: gx_parameter.h:789
void gx_print_error(const char *, const std::string &)
Definition: gx_logging.cpp:166
virtual bool get_tuner_switcher_active()
Definition: machine.cpp:1873
sigc::signal< int, bool > activation
virtual void plugin_preset_list_save(const PluginDef *pdef, const Glib::ustring &name)
Definition: machine.cpp:545
virtual bool bank_remove(const Glib::ustring &bank)
Definition: machine.cpp:2249
void insert(const string &id, const string &group)
Definition: gx_parameter.h:67
static string get_default_instancename()
Definition: gx_jack.cpp:46
virtual bool setting_is_preset()
Definition: machine.cpp:1898
virtual bool bank_check_reparse()
Definition: machine.cpp:2118
sigc::signal< void > & signal_changed()
Definition: gx_parameter.h:390
static GxLogger & get_logger()
Definition: gx_logging.cpp:50
gx_system::PresetFile * bank_insert_new(const Glib::ustring &name)
Definition: gx_preset.cpp:1075
ParameterGroups & get_group_table()
virtual bank_iterator bank_begin()
Definition: machine.cpp:2187
void(* create_wheel)(const char *id, const char *label)
Definition: gx_plugin.h:99
virtual ~GxMachine()
Definition: machine.cpp:183
void plugin_preset_list_load(const PluginDef *pdef, UnitPresetList &presetnames)
Definition: gx_preset.cpp:1214
virtual void bank_reorder(const std::vector< Glib::ustring > &neworder)
Definition: machine.cpp:2095
void(* create_selector)(const char *id, const char *label)
Definition: gx_plugin.h:95
virtual void set_init_values()
Definition: machine.cpp:678
virtual void pf_insert_before(gx_system::PresetFileGui &pf, const Glib::ustring &src, gx_system::PresetFileGui &pftgt, const Glib::ustring &pos, const Glib::ustring &name)
Definition: machine.cpp:635
virtual void request_midi_value_update()
Definition: machine.cpp:2507
void(* openHorizontalBox)(const char *label)
Definition: gx_plugin.h:71
const std::string & id_box_visible() const
virtual void midi_modifyCurrent(Parameter &param, float lower, float upper, bool toggle, int toggle_behaviour)
Definition: machine.cpp:791
virtual bool parameter_hasId(const char *p)
Definition: machine.cpp:2361
int get_index(const Glib::ustring &name)
Definition: gx_json.cpp:1134
virtual bool setting_is_preset()
Definition: machine.cpp:453
PresetFileGui * get_guiwrapper()
Definition: gx_json.h:393
virtual bool load_unit(gx_gui::UiBuilderImpl &builder, PluginDef *pdef)
Definition: machine.cpp:283
const char * id
Definition: gx_plugin.h:185
void send_midi_cc(int cc_num, int pgm_num, int bgn, int num)
Definition: gx_jack.cpp:846
bool isFloat() const
Definition: gx_parameter.h:162
bool hasId(const string &id) const
Definition: gx_parameter.h:535
void send_rack_changed(bool stereo, CmdConnection *cmd)
Definition: jsonrpc.cpp:1833
virtual void readJSON_value(gx_system::JsonParser &jp)
virtual void pf_append(gx_system::PresetFileGui &pf, const Glib::ustring &src, gx_system::PresetFileGui &pftgt, const Glib::ustring &name)
Definition: machine.cpp:631
void readJSON(gx_system::JsonParser &jp)
virtual int get_oscilloscope_mul_buffer()
Definition: machine.cpp:1707
virtual void set_parameter_value(const std::string &id, int value)
Definition: machine.cpp:698
void on_engine_mute_changed(bool s, GxEngine &engine)
Definition: machine.cpp:68
virtual void reorder_preset(gx_system::PresetFileGui &pf, const std::vector< Glib::ustring > &neworder)
Definition: machine.cpp:595
void plugin_preset_list_save(const PluginDef *pdef, const Glib::ustring &name)
Definition: gx_preset.cpp:1229
virtual void set_parameter_value(const std::string &id, int value)
Definition: machine.cpp:2377
#define max(x, y)
virtual void get_oscilloscope_info(int &load, int &frames, bool &is_rt, jack_nframes_t &bsize)
Definition: machine.cpp:1767
void(* create_port_display)(const char *id, const char *label)
Definition: gx_plugin.h:92
void delete_module(Plugin *pl)
virtual void load_online_presets()
Definition: machine.cpp:1947
virtual sigc::signal< void, bool > & signal_rack_unit_order_changed()
Definition: machine.cpp:1853
sigc::signal< void, bool > & signal_changed()
Definition: gx_parameter.h:376
void set_replace_mode(bool mode)
Definition: gx_parameter.h:537
virtual Glib::ustring get_bank_name(int n)
Definition: machine.cpp:1920
StringParameter & getString()
Definition: gx_parameter.h:478
virtual void close()
Definition: gx_json.cpp:68
void save(gx_system::CmdlineOptions &options)
void set_engine_mute(GxEngineState s, BoolParameter &p)
Definition: machine.cpp:64
void insert_rack_unit(const std::string &unit, const std::string &before, bool stereo)
Definition: gx_preset.cpp:994
virtual float get_tuner_freq()
Definition: machine.cpp:1743
virtual void bank_drag_begin()
Definition: machine.cpp:616
bool convert_preset(PresetFile &pf)
Definition: gx_json.cpp:1954
void(* openFrameBox)(const char *label)
Definition: gx_plugin.h:74
virtual sigc::signal< void, unsigned int > & signal_oscilloscope_size_change()
Definition: machine.cpp:327
void ladspaloader_update_plugins()
Definition: gx_engine.cpp:467
std::vector< std::string > stereo
Definition: gx_preset.h:39
void begin_object(bool nl=false)
Definition: gx_json.cpp:168
void(* create_small_rackknobr)(const char *id, const char *label)
Definition: gx_plugin.h:98
void insert_after(PresetFile &pf, const Glib::ustring &src, PresetFile &pftgt, const Glib::ustring &pos, const Glib::ustring &name)
Definition: gx_json.cpp:1882
void readJSON(gx_system::JsonParser &jp, ParamMap &pmap)
sigc::signal< void > & signal_presetlist_changed()
Definition: gx_json.h:478
MidiAudioBuffer midiaudiobuffer
Definition: gx_engine.h:87
void(* create_simple_spin_value)(const char *id)
Definition: gx_plugin.h:100
virtual sigc::signal< void > & signal_selection_changed()
Definition: machine.cpp:557
void(* create_simple_meter)(const char *id)
Definition: gx_plugin.h:96
static GxExit & get_instance()
Definition: gx_logging.cpp:205
virtual sigc::signal< void, int > & signal_oscilloscope_post_pre()
Definition: machine.cpp:315
GxMachineRemote(gx_system::CmdlineOptions &options)
Definition: machine.cpp:846
void set_statefilename(const std::string &fn)
Definition: gx_json.h:485
virtual void tuner_switcher_deactivate()
Definition: machine.cpp:1886
void set_jack(gx_jack::GxJack *jack)
Definition: gx_engine.h:105
virtual void bank_reorder(const std::vector< Glib::ustring > &neworder)
Definition: machine.cpp:591
virtual void clear_oscilloscope_buffer()
Definition: machine.cpp:307
void load_preset(PresetFile *pf, const Glib::ustring &name)
Definition: gx_json.cpp:1770
virtual void plugin_preset_list_load(const PluginDef *pdef, gx_preset::UnitPresetList &presetnames)
Definition: machine.cpp:1979
void(* create_mid_rackknob)(const char *id, const char *label)
Definition: gx_plugin.h:103
virtual sigc::signal< void, bool > & tuner_switcher_signal_selection_done()
Definition: machine.cpp:1817
Plugin * lookup_plugin(const std::string &id) const
virtual int get_bank_index(const Glib::ustring &bank)
Definition: machine.cpp:521
virtual Parameter & get_parameter(const char *p)
Definition: machine.cpp:670
void(* openVerticalBox2)(const char *label)
Definition: gx_plugin.h:70
virtual sigc::signal< void, GxEngineState > & signal_state_change()
Definition: machine.cpp:1821
sigc::signal< void, int > & signal_new_bank()
Definition: gx_parameter.h:784
virtual const Glib::ustring & get_current_bank()
Definition: machine.cpp:1904
const std::string & id_effect_post_pre() const
virtual void writeJSON(gx_system::JsonWriter &jw) const
virtual void pf_insert_after(gx_system::PresetFileGui &pf, const Glib::ustring &src, gx_system::PresetFileGui &pftgt, const Glib::ustring &pos, const Glib::ustring &name)
Definition: machine.cpp:2221
virtual int midi_size()
Definition: machine.cpp:775
virtual gx_system::CmdlineOptions & get_options() const
Definition: machine.cpp:351
virtual const char * what() const
Definition: gx_json.h:46
FloatParameter * reg_par(const string &id, const string &name, float *var, float std, float lower, float upper, float step)
Definition: gx_parameter.h:552
MidiControllerList controller_map
Definition: gx_engine.h:76
virtual void midi_deleteParameter(Parameter &param)
Definition: machine.cpp:783
void set_state(GxEngineState state)
std::string get_string()
Definition: gx_json.h:210
sigc::signal< void, bool > & signal_rack_unit_order_changed()
Definition: gx_preset.h:177
virtual void pf_save(gx_system::PresetFileGui &pf, const Glib::ustring &name)
Definition: machine.cpp:655
virtual void commit_ladspa_changes()
Definition: machine.cpp:267
void(* create_small_rackknob)(const char *id, const char *label)
Definition: gx_plugin.h:86
virtual Parameter & get_parameter(const char *p)
Definition: machine.cpp:2288
sigc::signal< void, unsigned int > size_change
void readJSON_remote(gx_system::JsonParser &jp)
Definition: gx_json.cpp:1374
void update_plugin(Plugin *pvars)
virtual void create_default_scratch_preset()
Definition: machine.cpp:525
virtual void load_ladspalist(std::vector< std::string > &old_not_found, ladspa::LadspaPluginList &pluginlist)
Definition: machine.cpp:1451
virtual void loadstate()
Definition: machine.cpp:506
#define START_CALL(m)
Definition: machine.cpp:835
int get_index(const Glib::ustring &bank) const
Definition: gx_json.cpp:1632
virtual bool rename_preset(gx_system::PresetFileGui &pf, const Glib::ustring &oldname, const Glib::ustring &newname)
Definition: machine.cpp:587
virtual void get_oscilloscope_info(int &load, int &frames, bool &is_rt, jack_nframes_t &bsize)
Definition: machine.cpp:344
virtual void bank_drag_begin()
Definition: machine.cpp:2178
virtual void save_to_state(bool preserve_preset=false)
Definition: machine.cpp:1974
virtual bool midi_get_config_mode(int *ctl=0)
Definition: machine.cpp:751
sigc::signal< void, GxEngineState > & signal_state_change()
virtual bool rename_bank(const Glib::ustring &oldname, Glib::ustring &newname)
Definition: machine.cpp:2061
void(* openpaintampBox)(const char *label)
Definition: gx_plugin.h:76
std::vector< FileName > & get_listing()
Definition: gx_system.h:341
virtual sigc::signal< void, int, int > & signal_midi_value_changed()
Definition: machine.cpp:2503
FloatParameter & getFloat()
Definition: gx_parameter.h:452
void(* openHorizontalhideBox)(const char *label)
Definition: gx_plugin.h:72
list< MidiController > midi_controller_list
Definition: gx_parameter.h:696
virtual void plugin_preset_list_remove(const PluginDef *pdef, const Glib::ustring &name)
Definition: machine.cpp:2011
static float get(unsigned int channel)
virtual void tuner_switcher_toggle(bool v)
Definition: machine.cpp:1891
const char * engine_state_to_string(gx_engine::GxEngineState s)
Definition: jsonrpc.cpp:29
virtual void plugin_preset_list_load(const PluginDef *pdef, gx_preset::UnitPresetList &presetnames)
Definition: machine.cpp:537
virtual gx_system::PresetFileGui * get_current_bank_file()
Definition: machine.cpp:1908
virtual const Glib::ustring & get_current_bank()
Definition: machine.cpp:458
virtual sigc::signal< void, const Glib::ustring &, const Glib::ustring & > & tuner_switcher_signal_display()
Definition: machine.cpp:1809
virtual void tuner_switcher_activate(bool v)
Definition: machine.cpp:440
sigc::signal< void, bool > & signal_exit()
Definition: gx_logging.h:116
virtual bank_iterator bank_end()
Definition: machine.cpp:2191
virtual gx_system::PresetFileGui * bank_insert_new(const Glib::ustring &newname)
Definition: machine.cpp:574
const jsonrpc_method_def jsonrpc_method_list[]
const string & get_instancename()
Definition: gx_jack.h:202
const GxJConvSettings & get_value() const
virtual void msend_midi_cc(int cc, int pgn, int bgn, int num)
Definition: machine.cpp:1924
int main(int argc, char *argv[])
Definition: gxw_demo.cc:62
virtual gx_system::PresetFileGui * get_bank_file(const Glib::ustring &bank) const
Definition: machine.cpp:470
void lock_rt_memory()
Definition: machine.cpp:30
const Glib::ustring & get_current_name()
Definition: gx_json.h:484
void(* create_feedback_slider)(const char *id, const char *label)
Definition: gx_plugin.h:85
void set_blocked(bool v)
Definition: gx_parameter.h:182
virtual void pluginlist_append_rack(UiBuilderBase &ui)
Definition: machine.cpp:287
void(* create_spin_value)(const char *id, const char *label)
Definition: gx_plugin.h:91
std::string get_temp_filepath(const std::string &basename) const
Definition: gx_system.h:466
virtual void pf_save(gx_system::PresetFileGui &pf, const Glib::ustring &name)
Definition: machine.cpp:2268
virtual gx_system::PresetFileGui * bank_get_file(const Glib::ustring &bank) const
Definition: machine.cpp:619
virtual void bank_save()
Definition: machine.cpp:651
virtual GxEngineState get_state()
Definition: machine.cpp:1438
virtual sigc::signal< int, bool > & signal_oscilloscope_activation()
Definition: machine.cpp:1735
virtual void tuner_switcher_activate(bool v)
Definition: machine.cpp:1880
const Glib::ustring & get_setbank()
Definition: gx_system.h:487
void print(const char *func, const std::string &msg, MsgType msgtype)
Definition: gx_logging.cpp:130
string current_value() const
Definition: gx_json.h:143
virtual gx_system::PresetFileGui * bank_get_file(const Glib::ustring &bank) const
Definition: machine.cpp:2183
virtual void pluginlist_append_rack(UiBuilderBase &ui)
Definition: machine.cpp:1534
IntParameter & getInt()
Definition: gx_parameter.h:457
virtual sigc::signal< void, int > & signal_oscilloscope_post_pre()
Definition: machine.cpp:1727
#define START_RECEIVE(s)
Definition: machine.cpp:837
virtual midi_controller_list & midi_get(int n)
Definition: machine.cpp:779
sigc::signal< void, MidiAudioBuffer::Load > jack_load_change
Definition: machine.h:54
virtual sigc::signal< void, Plugin *, PluginChange::pc > & signal_plugin_changed()
Definition: machine.cpp:275
iterator begin() const
Definition: gx_parameter.h:533
virtual void midi_set_config_mode(bool v, int ctl=-1)
Definition: machine.cpp:759
void(* create_big_rackknob)(const char *id, const char *label)
Definition: gx_plugin.h:87
void(* openHorizontalTableBox)(const char *label)
Definition: gx_plugin.h:73
void(* set_next_flags)(int flags)
Definition: gx_plugin.h:79
virtual void insert_rack_unit(const std::string &unit, const std::string &before, PluginType type)
Definition: machine.cpp:428
void debug_trace_param(Parameter *p)
Definition: machine.cpp:932
virtual const Glib::ustring & get_current_name()
Definition: machine.cpp:466
virtual sigc::signal< void, TunerSwitcher::SwitcherState > & tuner_switcher_signal_set_state()
Definition: machine.cpp:395
EnumParameter & getEnum()
Definition: gx_parameter.h:462
void plugin_preset_list_remove(const PluginDef *pdef, const Glib::ustring &name)
Definition: gx_preset.cpp:1233
virtual gx_jack::GxJack * get_jack()
Definition: machine.cpp:2277
const Glib::ustring & get_name(int n)
Definition: gx_json.cpp:1129
virtual void set_state(GxEngineState state)
Definition: machine.cpp:1432
virtual int get_bank_index(const Glib::ustring &bank)
Definition: machine.cpp:1961
virtual gx_system::PresetFileGui * bank_insert_new(const Glib::ustring &newname)
Definition: machine.cpp:2050
sigc::signal< void, int > & signal_new_mute_state()
Definition: gx_parameter.h:783
sigc::signal< void, const Glib::ustring & > & signal_changed()
Definition: gx_parameter.h:446
virtual bool bank_check_reparse()
Definition: machine.cpp:599
virtual void load_preset(gx_system::PresetFileGui *pf, const Glib::ustring &name)
Definition: machine.cpp:1933
sigc::signal< void, const GxSeqSettings * > & signal_changed()
virtual void reload_impresp_list(const std::string &path)
Definition: machine.cpp:807
#define START_NOTIFY(m)
Definition: machine.cpp:830
int flag
Definition: ladspaback.cpp:55
const Glib::ustring & get_value() const
Definition: gx_parameter.h:432
virtual void loadstate()
Definition: machine.cpp:1953
virtual sigc::signal< void > & signal_presetlist_changed()
Definition: machine.cpp:561
virtual void save_to_state(bool preserve_preset=false)
Definition: machine.cpp:533
virtual const std::vector< std::string > & get_rack_unit_order(PluginType type)
Definition: machine.cpp:411
virtual void bank_set_flag(gx_system::PresetFileGui *pf, int flag, bool v)
Definition: machine.cpp:607
virtual sigc::signal< void, unsigned int > & signal_oscilloscope_size_change()
Definition: machine.cpp:1739
virtual void tuner_switcher_deactivate()
Definition: machine.cpp:444
float current_value_float()
Definition: gx_json.h:146
virtual void erase_preset(gx_system::PresetFileGui &pf, const Glib::ustring &name)
Definition: machine.cpp:2125
sigc::signal< void, const Glib::ustring &, const Glib::ustring & > & signal_display()
Definition: tunerswitcher.h:70
virtual bool oscilloscope_plugin_box_visible()
Definition: machine.cpp:1723
void(* create_simple_c_meter)(const char *id, const char *idl, const char *label)
Definition: gx_plugin.h:97
void deleteParameter(Parameter &param)
virtual bool get_tuner_switcher_active()
Definition: machine.cpp:436
virtual sigc::signal< void, TunerSwitcher::SwitcherState > & tuner_switcher_signal_set_state()
Definition: machine.cpp:1813
token next(token expect=no_token)
Definition: gx_json.cpp:496
BoolParameter & getBool()
Definition: gx_parameter.h:468
virtual void load_preset(gx_system::PresetFileGui *pf, const Glib::ustring &name)
Definition: machine.cpp:491
void write(float v, bool nl=false)
Definition: gx_json.cpp:116
void(* create_eq_rackslider_no_caption)(const char *id)
Definition: gx_plugin.h:101
bool unit_has_std_values(const PluginDef *pdef) const
void add_time_measurement()
Definition: gx_system.cpp:146
virtual void tuner_switcher_toggle(bool v)
Definition: machine.cpp:448
virtual void request_midi_value_update()
Definition: machine.cpp:771
const string & id() const
Definition: gx_parameter.h:172
virtual void set_oscilloscope_mul_buffer(int a)
Definition: machine.cpp:295
virtual bank_iterator bank_end()
Definition: machine.cpp:627
void insert_before(PresetFile &pf, const Glib::ustring &src, PresetFile &pftgt, const Glib::ustring &pos, const Glib::ustring &name)
Definition: gx_json.cpp:1862
void(* create_switch)(const char *sw_type, const char *id, const char *label)
Definition: gx_plugin.h:94
iterator begin()
Definition: gx_json.h:443
virtual std::string bank_get_filename(const Glib::ustring &bank)
Definition: machine.cpp:612
uiloader load_ui
Definition: gx_plugin.h:201
virtual gx_jack::GxJack * get_jack()
Definition: machine.cpp:661
void toggle(bool tuner_active)
virtual void reload_impresp_list(const std::string &path)
Definition: machine.cpp:2548
virtual void plugin_preset_list_remove(const PluginDef *pdef, const Glib::ustring &name)
Definition: machine.cpp:549
const GxSeqSettings & get_value() const
const std::string & get_filename() const
Definition: gx_json.h:337
EnumParameter * reg_non_midi_enum_par(const string &id, const string &name, const value_pair *vl, int *var, bool preset, int std=0)
Definition: gx_parameter.h:580
virtual bool load_unit(gx_gui::UiBuilderImpl &builder, PluginDef *pdef)
Definition: machine.cpp:1691
virtual void load_impresp_dirs(std::vector< gx_system::FileName > &dirs)
Definition: machine.cpp:813
void(* openVerticalBox1)(const char *label)
Definition: gx_plugin.h:69
virtual gx_system::CmdlineOptions & get_options() const
Definition: machine.cpp:1798
virtual sigc::signal< void, bool > & signal_oscilloscope_visible()
Definition: machine.cpp:1731
void append_rack(UiBuilderBase &ui)
sigc::signal< void, int > & signal_changed()
Definition: gx_parameter.h:325
virtual sigc::signal< void > & signal_presetlist_changed()
Definition: machine.cpp:2027
virtual sigc::signal< int, bool > & signal_oscilloscope_activation()
Definition: machine.cpp:323
void readJSON(gx_system::JsonParser &jp)
void set_mul_buffer(int a, unsigned int b)
virtual void pf_insert_before(gx_system::PresetFileGui &pf, const Glib::ustring &src, gx_system::PresetFileGui &pftgt, const Glib::ustring &pos, const Glib::ustring &name)
Definition: machine.cpp:2205
virtual gx_system::PresetFileGui * get_current_bank_file()
Definition: machine.cpp:462
virtual void create_default_scratch_preset()
Definition: machine.cpp:1965
void(* create_master_slider)(const char *id, const char *label)
Definition: gx_plugin.h:84
jack_nframes_t get_time_is()
Definition: gx_jack.h:182
virtual sigc::signal< void, const Glib::ustring &, const Glib::ustring & > & tuner_switcher_signal_display()
Definition: machine.cpp:391
void end_object(bool nl=false)
Definition: gx_json.cpp:176
void reset_unit(const PluginDef *pdef) const
virtual void midi_deleteParameter(Parameter &param)
Definition: machine.cpp:2520
virtual sigc::signal< void > & signal_selection_changed()
Definition: machine.cpp:2023
virtual const float * get_oscilloscope_buffer()
Definition: machine.cpp:303
const Glib::ustring & get_current_bank()
Definition: gx_json.h:482
void save_to_state(bool preserve_preset=false)
Definition: gx_json.cpp:1830
void(* create_selector_no_caption)(const char *id)
Definition: gx_plugin.h:88
virtual bool convert_preset(gx_system::PresetFileGui &pf)
Definition: machine.cpp:2237
void(* openVerticalBox)(const char *label)
Definition: gx_plugin.h:68
void plugin_preset_list_set(const PluginDef *pdef, bool factory, const Glib::ustring &name)
Definition: gx_preset.cpp:1224
void reorder_preset(PresetFile &pf, const std::vector< Glib::ustring > &neworder)
Definition: gx_json.cpp:1916
virtual void writeJSON(gx_system::JsonWriter &jw) const
virtual bool convert_preset(gx_system::PresetFileGui &pf)
Definition: machine.cpp:643
void erase_preset(const Glib::ustring &name)
virtual sigc::signal< void, Plugin *, PluginChange::pc > & signal_plugin_changed()
Definition: machine.cpp:1521
virtual bool oscilloscope_plugin_box_visible()
Definition: machine.cpp:311
virtual sigc::signal< void, bool > & signal_oscilloscope_visible()
Definition: machine.cpp:319