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