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