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