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