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