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 
425 const float *GxMachine::get_oscilloscope_buffer() {
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 
484 void GxMachine::stop_socket() {
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 
521 sigc::signal<void, bool>& GxMachine::tuner_switcher_signal_selection_done() {
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 
529 void GxMachine::tuner_used_for_display(bool on) {
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 
628 void GxMachine::loadstate() {
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 
639 int GxMachine::bank_size() {
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 
685 void GxMachine::disable_autosave(bool v) {
686  settings.disable_autosave(v);
687 }
688 
689 sigc::signal<void>& GxMachine::signal_selection_changed() {
690  return settings.signal_selection_changed();
691 }
692 
693 sigc::signal<void>& GxMachine::signal_presetlist_changed() {
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 
706 gx_system::PresetFileGui *GxMachine::bank_insert_new(const Glib::ustring& name) {
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 
783 void GxMachine::bank_save() {
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 
797 void GxMachine::set_jack_insert(bool v) {
798  return jack.set_jack_insert(v);
799 }
800 
801 // pmap
802 Parameter& GxMachine::get_parameter(const char *p) {
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 
826 bool GxMachine::parameter_unit_has_std_values(const PluginDef *pdef) const {
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
883 bool GxMachine::midi_get_config_mode(int *ctl) {
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 
907 int GxMachine::midi_size() {
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 
932 void GxMachine::set_midi_channel(int s) {
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();
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());
1573 
1575  START_NOTIFY(setstate);
1576  jw->write(engine_state_to_string(state));
1577  SEND();
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();
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);
1653 
1655  START_CALL(ladspaloader_update_plugins);
1656  START_RECEIVE();
1658  update_plugins(jp);
1660  END_RECEIVE();
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);
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);
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();
1848 
1851  START_RECEIVE(1);
1852  return get_bool(jp);
1853  END_RECEIVE(return 1);
1855 
1857  return oscilloscope_buffer;
1859 
1862  SEND();
1864 
1866  return pluginlist.lookup_plugin("oscilloscope")->get_box_visible();
1868 
1869 sigc::signal<void, int>& GxMachineRemote::signal_oscilloscope_post_pre() {
1870  return pmap["oscilloscope.pp"].signal_changed_int();
1872 
1873 sigc::signal<void, bool>& GxMachineRemote::signal_oscilloscope_visible() {
1874  return pmap["ui.oscilloscope"].signal_changed_bool();
1876 
1877 sigc::signal<int, bool>& GxMachineRemote::signal_oscilloscope_activation() {
1878  return oscilloscope_activation;
1880 
1881 sigc::signal<void, unsigned int>& GxMachineRemote::signal_oscilloscope_size_change() {
1882  return oscilloscope_size_change;
1884 
1887  START_RECEIVE(0);
1889  return jp->current_value_float();
1890  END_RECEIVE(return 0);
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();
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();
1939 
1941  return options;
1943 
1944 void GxMachineRemote::start_socket(sigc::slot<void> quit_mainloop, const Glib::ustring& host, int port) {
1945  assert(false);
1947 
1950 
1951 sigc::signal<void,const Glib::ustring&,const Glib::ustring&>& GxMachineRemote::tuner_switcher_signal_display() {
1952  return tuner_switcher_display;
1954 
1955 sigc::signal<void,TunerSwitcher::SwitcherState>& GxMachineRemote::tuner_switcher_signal_set_state() {
1956  return tuner_switcher_set_state;
1958 
1959 sigc::signal<void, bool>& GxMachineRemote::tuner_switcher_signal_selection_done() {
1960  return tuner_switcher_selection_done;
1962 
1963 sigc::signal<void,GxEngineState>& GxMachineRemote::signal_state_change() {
1964  return engine_state_change;
1966 
1969  jw->write(on);
1970  SEND();
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);
1994 
1995 sigc::signal<void,bool>& GxMachineRemote::signal_rack_unit_order_changed() {
1996  return rack_units.rack_unit_order_changed;
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();
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 }
2014 // tuner_switcher
2017  START_RECEIVE(false);
2018  return get_bool(jp);
2019  END_RECEIVE(return false);
2021 
2024  jw->write(v);
2025  SEND();
2027 
2030  SEND();
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));
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));
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  }
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 }
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;
2081 
2083  return get_bank_file(get_current_bank());
2085 
2086 const Glib::ustring& GxMachineRemote::get_current_name() {
2087  return current_preset;
2089 
2090 gx_system::PresetFileGui* GxMachineRemote::get_bank_file(const Glib::ustring& bank) const { //FIXME
2091  return banks.get_file(bank)->get_guiwrapper();
2093 
2094 Glib::ustring GxMachineRemote::get_bank_name(int n) {
2095  return banks.get_name(n);
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();
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
2120 
2122  START_NOTIFY(set_online_presets);
2123  SEND();
2125 
2127  /* noop */
2129 
2131  return banks.size();
2133 
2134 int GxMachineRemote::get_bank_index(const Glib::ustring& bank) {
2135  return banks.get_index(bank);
2137 
2140  SEND();
2142 
2143 void GxMachineRemote::set_statefilename(const std::string& fn) {
2144  //FIXME move jack session handling inside machine
2145  /* noop */
2147 
2148 void GxMachineRemote::save_to_state(bool preserve_preset) {
2149  //FIXME move jack session handling inside machine
2150  /* noop */
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();
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();
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();
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));
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();
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();
2204 
2205 void GxMachineRemote::disable_autosave(bool v) {
2206  //FIXME: move inside machine
2207  /* noop */
2209 
2210 sigc::signal<void>& GxMachineRemote::signal_selection_changed() {
2211  return selection_changed;
2213 
2214 sigc::signal<void>& GxMachineRemote::signal_presetlist_changed() {
2215  return presetlist_changed;
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);
2236 
2237 gx_system::PresetFileGui *GxMachineRemote::bank_insert_new(const Glib::ustring& newname) {
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);
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);
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);
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);
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();
2304 
2307  START_RECEIVE(false);
2308  return get_bool(jp);
2309  END_RECEIVE(return false);
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  }
2324 
2327  jw->write(pf->get_name());
2328  jw->write(flag);
2329  jw->write(v);
2330  SEND();
2331  pf->set_flag(flag, v);
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;
2364 
2366  bank_drag_get_counter = 0;
2367  bank_drag_get_path.clear();
2369 
2370 gx_system::PresetFileGui *GxMachineRemote::bank_get_file(const Glib::ustring& bank) const {
2371  return banks.get_file(bank)->get_guiwrapper();
2373 
2375  return banks.begin();
2377 
2379  return banks.end();
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));
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  }
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  }
2423 
2426  jw->write(pf.get_name());
2427  START_RECEIVE(false);
2428  bool ret = get_bool(jp);
2429  if (ret) {
2430  pf.set_flag(gx_system::PRESET_FLAG_VERSIONDIFF, false);
2431  }
2432  return ret;
2433  END_RECEIVE(return false);
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);
2449 
2452  SEND();
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 
2463 // jack
2465  return 0;
2467 
2468 void GxMachineRemote::set_jack_insert(bool v) {
2470  jw->write(v);
2471  SEND();
2472 }
2474 // pmap
2475 Parameter& GxMachineRemote::get_parameter(const char *p) {
2476  return pmap[p];
2478 
2479 Parameter& GxMachineRemote::get_parameter(const std::string& id) {
2480  return pmap[id];
2481 }
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())));
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  }
2567 
2568 bool GxMachineRemote::parameter_hasId(const char *p) {
2569  return pmap.hasId(p);
2571 
2572 bool GxMachineRemote::parameter_hasId(const std::string& id) {
2573  return pmap.hasId(id);
2575 
2576 void GxMachineRemote::reset_unit(const PluginDef *pdef) const {
2577  pmap.reset_unit(pdef);
2579 
2581  return pmap.unit_has_std_values(pdef);
2583 
2584 void GxMachineRemote::set_parameter_value(const std::string& id, int value) {
2585  pmap[id].getInt().set(value);
2587 
2588 void GxMachineRemote::set_parameter_value(const std::string& id, bool value) {
2589  pmap[id].getBool().set(value);
2591 
2592 void GxMachineRemote::set_parameter_value(const std::string& id, float value) {
2593  pmap[id].getFloat().set(value);
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 }
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);
2698 
2699 void GxMachineRemote::midi_set_config_mode(bool v, int ctl) {
2701  jw->write(v);
2702  jw->write(ctl);
2703  SEND();
2705 
2706 sigc::signal<void>& GxMachineRemote::signal_midi_changed() {
2707  return midi_changed;
2709 
2710 sigc::signal<void, int, int>& GxMachineRemote::signal_midi_value_changed() {
2711  return midi_value_changed;
2713 
2716  SEND();
2718 
2720  return midi_controller_map.size();
2722 
2724  return midi_controller_map[n];
2726 
2729  jw->write(param.id());
2730  SEND();
2732 
2735  jw->write(v);
2736  SEND();
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();
2748 
2750  return midi_controller_map.param2controller(param, p);
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();
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();
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
ladspa::LadspaPluginList::save
void save(gx_system::CmdlineOptions &options)
Definition: ladspaback.cpp:1764
gx_engine::MidiAudioBuffer::jack_load_status
Load jack_load_status()
Definition: gx_internal_plugins.h:192
gx_print_fatal
void gx_print_fatal(const char *, const std::string &)
Definition: gx_logging.cpp:176
gx_engine::Plugin::get_box_visible
bool get_box_visible() const
Definition: gx_pluginloader.h:60
gx_engine::GxMachineRemote::get_bank_file
virtual gx_system::PresetFileGui * get_bank_file(const Glib::ustring &bank) const
Definition: machine.cpp:2088
gx_engine::PluginChange::update
Definition: gx_engine.h:64
gx_preset::GxSettings::plugin_preset_list_set
void plugin_preset_list_set(const PluginDef *pdef, bool factory, const Glib::ustring &name)
Definition: gx_preset.cpp:1276
gx_engine::MidiControllerList::request_midi_value_update
void request_midi_value_update()
Definition: gx_paramtable.cpp:639
GxExit::get_instance
static GxExit & get_instance()
Definition: gx_logging.cpp:203
gx_gui::UiBuilderImpl
Definition: gx_ui_builder.h:199
gx_engine::GxMachineRemote::set_oscilloscope_mul_buffer
virtual void set_oscilloscope_mul_buffer(int a)
Definition: machine.cpp:1841
gx_engine::MidiControllerList::set_current_control
void set_current_control(int ctl)
Definition: gx_parameter.h:768
gx_engine::MidiControllerList::signal_changed
sigc::signal< void > & signal_changed()
Definition: gx_parameter.h:782
gx_system::JsonStringParser::get_string
std::string get_string()
Definition: gx_json.h:209
gx_system::JsonParser::value_key
Definition: gx_json.h:129
gx_engine::GxMachine::maxlevel_get
virtual void maxlevel_get(int channels, float *values)
Definition: machine.cpp:452
END_RECEIVE
#define END_RECEIVE(s)
Definition: machine.cpp:976
gx_engine::GxMachineRemote::bank_get_filename
virtual std::string bank_get_filename(const Glib::ustring &bank)
Definition: machine.cpp:2332
gx_engine::GxMachine::plugin_preset_list_save
virtual void plugin_preset_list_save(const PluginDef *pdef, const Glib::ustring &name)
Definition: machine.cpp:676
gx_system::CmdlineOptions::get_setbank
const Glib::ustring & get_setbank()
Definition: gx_system.h:486
gx_engine::MidiControllerList::get_current_control
int get_current_control()
Definition: gx_parameter.h:767
gx_preset::GxSettings::insert_rack_unit
void insert_rack_unit(const std::string &unit, const std::string &before, bool stereo)
Definition: gx_preset.cpp:1006
gx_engine::GxMachineRemote::plugin_preset_list_save
virtual void plugin_preset_list_save(const PluginDef *pdef, const Glib::ustring &name)
Definition: machine.cpp:2189
gx_engine::GxMachineRemote::midi_set_config_mode
virtual void midi_set_config_mode(bool v, int ctl=-1)
Definition: machine.cpp:2697
gx_system::GxSettingsBase::save
void save(PresetFile &pf, const Glib::ustring &name)
Definition: gx_json.cpp:1883
TunerSwitcher::wait_start
Definition: tunerswitcher.h:32
gx_engine::on_engine_mute_changed
void on_engine_mute_changed(bool s, GxEngine &engine)
Definition: machine.cpp:120
UiBuilder::openHorizontalTableBox
void(* openHorizontalTableBox)(const char *label)
Definition: gx_plugin.h:73
gx_engine::ControllerArray::readJSON
void readJSON(gx_system::JsonParser &jp, ParamMap &param)
Definition: gx_paramtable.cpp:371
UiBuilder::create_port_display
void(* create_port_display)(const char *id, const char *label)
Definition: gx_plugin.h:92
gx_jack::GxJack::get_default_instancename
static string get_default_instancename()
Definition: gx_jack.cpp:45
gx_system::JsonParser::begin_object
Definition: gx_json.h:123
gx_engine::GxMachine::bank_get_filename
virtual std::string bank_get_filename(const Glib::ustring &bank)
Definition: machine.cpp:743
gx_engine::ParamMap::set_replace_mode
void set_replace_mode(bool mode)
Definition: gx_parameter.h:538
gx_system::JsonStringParser
Definition: gx_json.h:201
gx_system::JsonWriter::begin_object
void begin_object(bool nl=false)
Definition: gx_json.cpp:167
gx_engine::MidiControllerList::set_midi_channel
void set_midi_channel(int s)
Definition: gx_paramtable.cpp:716
gx_engine::GxMachine::pluginlist_lookup_plugin
virtual Plugin * pluginlist_lookup_plugin(const std::string &id) const
Definition: machine.cpp:400
gx_engine::GxMachine::signal_midi_value_changed
virtual sigc::signal< void, int, int > & signal_midi_value_changed()
Definition: machine.cpp:898
gx_system::GxSettingsBase::reorder_preset
void reorder_preset(PresetFile &pf, const std::vector< Glib::ustring > &neworder)
Definition: gx_json.cpp:1908
gx_engine::GxMachine::midi_param2controller
virtual int midi_param2controller(Parameter &param, const MidiController **p)
Definition: machine.cpp:927
gx_engine::ParamMap::reg_par_non_preset
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
gx_system::JsonParser::value_string
Definition: gx_json.h:127
gx_engine::TunerAdapter::used_for_display
void used_for_display(bool on)
Definition: gx_internal_plugins.h:87
UiBuilder::create_wheel
void(* create_wheel)(const char *id, const char *label)
Definition: gx_plugin.h:99
gx_engine::GxMachineRemote::set_init_values
virtual void set_init_values()
Definition: machine.cpp:2501
gx_engine::GxMachine::parameter_hasId
virtual bool parameter_hasId(const char *p)
Definition: machine.cpp:813
gx_engine::MidiAudioBuffer::load_high
Definition: gx_internal_plugins.h:176
gx_engine::GxMachineRemote::bank_set_flag
virtual void bank_set_flag(gx_system::PresetFileGui *pf, int flag, bool v)
Definition: machine.cpp:2323
string_to_engine_state
gx_engine::GxEngineState string_to_engine_state(const std::string &s)
Definition: jsonrpc.cpp:41
GxService::get_maxlevel
float get_maxlevel(unsigned int channel)
Definition: jsonrpc.h:179
gx_engine::GxMachine::stop_socket
virtual void stop_socket()
Definition: machine.cpp:483
gx_engine::GxMachineRemote::set_state
virtual void set_state(GxEngineState state)
Definition: machine.cpp:1572
gx_engine::GxMachineRemote::set_jack_insert
virtual void set_jack_insert(bool v)
Definition: machine.cpp:2466
gx_system::CmdlineOptions::dump_parameter
bool dump_parameter
Definition: gx_system.h:432
gx_engine::MidiControllerList::get_config_mode
bool get_config_mode()
Definition: gx_parameter.h:766
gx_engine::GxMachine::signal_midi_changed
virtual sigc::signal< void > & signal_midi_changed()
Definition: machine.cpp:894
gx_engine::GxMachineRemote::msend_midi_cc
virtual void msend_midi_cc(int cc, int pgn, int bgn, int num)
Definition: machine.cpp:2096
UiBuilder::openVerticalBox
void(* openVerticalBox)(const char *label)
Definition: gx_plugin.h:68
gx_engine::GxMachine::set_statefilename
virtual void set_statefilename(const std::string &fn)
Definition: machine.cpp:650
gx_system::JsonStringParser::start_parser
void start_parser()
Definition: gx_json.h:208
gx_engine::GxMachine::next_preset_switch
virtual void next_preset_switch()
Definition: machine.cpp:297
gx_engine::GxMachineBase
Definition: machine.h:53
gx_engine::MidiControllerList::set_config_mode
void set_config_mode(bool mode, int ctl=-1)
Definition: gx_paramtable.cpp:601
gx_engine::PluginChange::pc
pc
Definition: gx_engine.h:64
gx_engine::GxMachine::get_bank_index
virtual int get_bank_index(const Glib::ustring &bank)
Definition: machine.cpp:642
gx_engine::PluginChange::remove
Definition: gx_engine.h:64
TunerSwitcher::normal_mode
Definition: tunerswitcher.h:32
gx_engine::GxMachine::signal_oscilloscope_size_change
virtual sigc::signal< void, unsigned int > & signal_oscilloscope_size_change()
Definition: machine.cpp:448
gx_engine::GxMachine::get_oscilloscope_info
virtual void get_oscilloscope_info(int &load, int &frames, bool &is_rt, jack_nframes_t &bsize)
Definition: machine.cpp:465
GxLogger::print
void print(const char *func, const std::string &msg, MsgType msgtype)
Definition: gx_logging.cpp:129
UiBuilder::create_switch_no_caption
void(* create_switch_no_caption)(const char *sw_type, const char *id)
Definition: gx_plugin.h:89
gx_engine::GxMachineRemote::get_options
virtual gx_system::CmdlineOptions & get_options() const
Definition: machine.cpp:1938
gx_preset::UnitRacks::stereo
std::vector< std::string > stereo
Definition: gx_preset.h:39
gx_engine::GxMachineRemote::signal_oscilloscope_visible
virtual sigc::signal< void, bool > & signal_oscilloscope_visible()
Definition: machine.cpp:1871
gx_engine::GxMachine::get_state
virtual GxEngineState get_state()
Definition: machine.cpp:376
gx_engine::GxMachineRemote::signal_oscilloscope_activation
virtual sigc::signal< int, bool > & signal_oscilloscope_activation()
Definition: machine.cpp:1875
gx_engine::GxMachineRemote::tuner_switcher_activate
virtual void tuner_switcher_activate(bool v)
Definition: machine.cpp:2020
gx_engine::GxMachine::oscilloscope_plugin_box_visible
virtual bool oscilloscope_plugin_box_visible()
Definition: machine.cpp:432
UiBuilder::create_mid_rackknob
void(* create_mid_rackknob)(const char *id, const char *label)
Definition: gx_plugin.h:103
gx_engine::GxMachineBase::GxMachineBase
GxMachineBase()
Definition: machine.cpp:105
gx_engine::GxEngine::midiaudiobuffer
MidiAudioBuffer midiaudiobuffer
Definition: gx_engine.h:85
gx_engine::GxMachine::tuner_switcher_signal_set_state
virtual sigc::signal< void, TunerSwitcher::SwitcherState > & tuner_switcher_signal_set_state()
Definition: machine.cpp:516
gx_engine::ParamMap::reg_string
StringParameter * reg_string(const string &id, const string &name, Glib::ustring *var, const string &sv, bool preset=false)
Definition: gx_parameter.h:616
gx_engine::GxMachineRemote::signal_oscilloscope_post_pre
virtual sigc::signal< void, int > & signal_oscilloscope_post_pre()
Definition: machine.cpp:1867
gx_engine::GxMachineRemote::next_preset_switch
virtual void next_preset_switch()
Definition: machine.cpp:2039
gx_engine::GxMachineRemote::get_oscilloscope_mul_buffer
virtual int get_oscilloscope_mul_buffer()
Definition: machine.cpp:1847
gx_engine::GxMachine::pf_save
virtual void pf_save(gx_system::PresetFileGui &pf, const Glib::ustring &name)
Definition: machine.cpp:786
value_pair
Definition: gx_plugin.h:117
gx_system::GxSettingsBase::append
void append(PresetFile &pf, const Glib::ustring &src, PresetFile &pftgt, const Glib::ustring &name)
Definition: gx_json.cpp:1836
jsonrpc_method_list
const jsonrpc_method_def jsonrpc_method_list[]
Definition: jsonrpc_methods-generated.cc:239
gx_engine::OscilloscopeAdapter::get_buffer
float * get_buffer()
Definition: gx_internal_plugins.h:236
gx_engine::GxMachine::reload_impresp_list
virtual void reload_impresp_list(const std::string &path)
Definition: machine.cpp:942
gx_engine::GxMachine::bank_remove
virtual bool bank_remove(const Glib::ustring &bank)
Definition: machine.cpp:778
gx_engine::UiBuilderBase
Definition: gx_pluginloader.h:86
gx_engine::GxMachine::reset_unit
virtual void reset_unit(const PluginDef *pdef) const
Definition: machine.cpp:821
gx_engine::GxMachine::plugin_preset_list_set_on_idle
virtual void plugin_preset_list_set_on_idle(const PluginDef *pdef, bool factory, const Glib::ustring &name)
Definition: machine.cpp:670
gx_engine::Parameter::getString
StringParameter & getString()
Definition: gx_parameter.h:479
gx_engine::GxMachineRemote::bank_remove
virtual bool bank_remove(const Glib::ustring &bank)
Definition: machine.cpp:2434
GxExit::signal_exit
sigc::signal< void, bool > & signal_exit()
Definition: gx_logging.h:115
gx_engine::GxMachineRemote::signal_rack_unit_order_changed
virtual sigc::signal< void, bool > & signal_rack_unit_order_changed()
Definition: machine.cpp:1993
gx_engine::GxMachineRemote::bank_size
virtual int bank_size()
Definition: machine.cpp:2128
gx_engine::GxMachineRemote::get_bank_name
virtual Glib::ustring get_bank_name(int n)
Definition: machine.cpp:2092
gx_engine::GxMachine::rename_bank
virtual bool rename_bank(const Glib::ustring &oldname, Glib::ustring &newname)
Definition: machine.cpp:714
gx_engine::GxMachine::get_current_name
virtual const Glib::ustring & get_current_name()
Definition: machine.cpp:587
TunerSwitcher::get_active
bool get_active()
Definition: tunerswitcher.h:66
gx_system::GxSettingsBase::insert_after
void insert_after(PresetFile &pf, const Glib::ustring &src, PresetFile &pftgt, const Glib::ustring &pos, const Glib::ustring &name)
Definition: gx_json.cpp:1874
TunerSwitcher::listening
Definition: tunerswitcher.h:32
gx_engine::ModuleSequencer::signal_state_change
sigc::signal< void, GxEngineState > & signal_state_change()
Definition: gx_modulesequencer.h:340
gx_system::PresetBanks::begin
iterator begin()
Definition: gx_json.h:441
gx_engine::GxMachineRemote::midi_set_current_control
virtual void midi_set_current_control(int v)
Definition: machine.cpp:2731
gx_engine::GxMachine::get_jack
virtual gx_jack::GxJack * get_jack()
Definition: machine.cpp:792
gx_engine::GxMachine::midi_deleteParameter
virtual void midi_deleteParameter(Parameter &param)
Definition: machine.cpp:914
gx_engine::GxMachineRemote::load_preset
virtual void load_preset(gx_system::PresetFileGui *pf, const Glib::ustring &name)
Definition: machine.cpp:2105
gx_engine::SeqParameter
ParameterV< GxSeqSettings > SeqParameter
Definition: gx_internal_plugins.h:292
gx_engine::GxMachine::signal_presetlist_changed
virtual sigc::signal< void > & signal_presetlist_changed()
Definition: machine.cpp:692
UiBuilder::create_p_display
void(* create_p_display)(const char *id, const char *idl, const char *idh)
Definition: gx_plugin.h:93
gx_engine::GxMachine::bank_end
virtual bank_iterator bank_end()
Definition: machine.cpp:758
gx_engine::GxMachine::get_tuner_switcher_active
virtual bool get_tuner_switcher_active()
Definition: machine.cpp:557
gx_engine::ControllerArray::param2controller
int param2controller(Parameter &param, const MidiController **p)
Definition: gx_paramtable.cpp:408
gx_engine::ParameterV< GxJConvSettings >
Definition: gx_internal_plugins.h:344
TunerSwitcher::deactivate
void deactivate()
Definition: tunerswitcher.cpp:232
gx_engine::GxMachineRemote::reload_impresp_list
virtual void reload_impresp_list(const std::string &path)
Definition: machine.cpp:2759
gx_jack::GxJack::get_time_is
jack_nframes_t get_time_is()
Definition: gx_jack.h:180
TunerSwitcher::signal_selection_done
sigc::signal< void, bool > & signal_selection_done()
Definition: tunerswitcher.h:72
gx_system::PresetBanks::get_index
int get_index(const Glib::ustring &bank) const
Definition: gx_json.cpp:1625
gx_engine::GxMachineRemote::plugin_preset_list_set_on_idle
virtual void plugin_preset_list_set_on_idle(const PluginDef *pdef, bool factory, const Glib::ustring &name)
Definition: machine.cpp:2184
gx_engine::GxMachine::signal_rack_unit_order_changed
virtual sigc::signal< void, bool > & signal_rack_unit_order_changed()
Definition: machine.cpp:536
gx_system::GxSettingsBase::remove_bank
bool remove_bank(const Glib::ustring &bank)
Definition: gx_json.cpp:1991
gx_engine::MidiControllerList::param2controller
int param2controller(Parameter &param, const MidiController **p)
Definition: gx_parameter.h:773
gx_engine::GxMachineRemote::insert_rack_unit
virtual void insert_rack_unit(const std::string &unit, const std::string &before, PluginType type)
Definition: machine.cpp:2004
gx_engine::GxMachine::get_bank_name
virtual Glib::ustring get_bank_name(int n)
Definition: machine.cpp:595
gx_engine::MidiAudioBuffer::Load
Load
Definition: gx_internal_plugins.h:176
gx_engine::GxMachineRemote::disable_autosave
virtual void disable_autosave(bool v)
Definition: machine.cpp:2203
gx_engine::GxMachine::tuner_switcher_toggle
virtual void tuner_switcher_toggle(bool v)
Definition: machine.cpp:569
gx_engine::Parameter::signal_changed_int
sigc::signal< void, int > & signal_changed_int()
Definition: gx_parameter.h:490
gx_system::JsonParser::current_value
string current_value() const
Definition: gx_json.h:142
UiBuilder::openVerticalBox2
void(* openVerticalBox2)(const char *label)
Definition: gx_plugin.h:70
gx_engine::midi_controller_list
list< MidiController > midi_controller_list
Definition: gx_parameter.h:695
gx_preset::GxSettings::plugin_preset_list_save
void plugin_preset_list_save(const PluginDef *pdef, const Glib::ustring &name)
Definition: gx_preset.cpp:1281
gx_engine::ParamMap::readJSON
void readJSON(gx_system::JsonParser &jp)
Definition: gx_paramtable.cpp:1940
PluginType
PluginType
Definition: machine.h:34
gx_engine::GxMachine::convert_preset
virtual bool convert_preset(gx_system::PresetFileGui &pf)
Definition: machine.cpp:774
PluginDef::load_ui
uiloader load_ui
Definition: gx_plugin.h:203
gx_system::GxSettingsBase::erase_preset
void erase_preset(const Glib::ustring &name)
gx_engine::GxMachine::start_socket
virtual void start_socket(sigc::slot< void > quit_mainloop, const Glib::ustring &host, int port)
Definition: machine.cpp:492
gx_preset::GxSettings::plugin_preset_list_load
void plugin_preset_list_load(const PluginDef *pdef, UnitPresetList &presetnames)
Definition: gx_preset.cpp:1226
gx_engine::GxMachine::save_ladspalist
virtual void save_ladspalist(ladspa::LadspaPluginList &pluginlist)
Definition: machine.cpp:384
gx_engine::ParameterV< GxJConvSettings >::get_value
const GxJConvSettings & get_value() const
Definition: gx_internal_plugins.h:362
gx_engine::GxMachineRemote::pf_insert_before
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:2390
gx_engine::GxMachineRemote::oscilloscope_plugin_box_visible
virtual bool oscilloscope_plugin_box_visible()
Definition: machine.cpp:1863
gx_system::JsonWriter::write
void write(float v, bool nl=false)
Definition: gx_json.cpp:115
gx_engine::GxMachine::bank_save
virtual void bank_save()
Definition: machine.cpp:782
gx_engine::GxMachine::clear_oscilloscope_buffer
virtual void clear_oscilloscope_buffer()
Definition: machine.cpp:428
TunerSwitcher::wait_stop
Definition: tunerswitcher.h:32
gx_engine::GxMachineRemote::midi_deleteParameter
virtual void midi_deleteParameter(Parameter &param)
Definition: machine.cpp:2725
gx_engine::GxMachine::bank_begin
virtual bank_iterator bank_begin()
Definition: machine.cpp:754
UiBuilder::openpaintampBox
void(* openpaintampBox)(const char *label)
Definition: gx_plugin.h:76
UiBuilder::create_feedback_slider
void(* create_feedback_slider)(const char *id, const char *label)
Definition: gx_plugin.h:85
gx_engine::ParameterV< bool >
Definition: gx_parameter.h:349
gx_engine::PluginListBase::append_rack
void append_rack(UiBuilderBase &ui)
Definition: gx_pluginloader.cpp:700
gx_engine::GxMachineRemote::parameter_unit_has_std_values
virtual bool parameter_unit_has_std_values(const PluginDef *pdef) const
Definition: machine.cpp:2578
gx_engine::GxMachineRemote::get_tuner_freq
virtual float get_tuner_freq()
Definition: machine.cpp:1883
gx_engine::GxMachineRemote::previus_preset_switch
virtual void previus_preset_switch()
Definition: machine.cpp:2046
gx_engine::GxMachine::tuner_used_for_display
virtual void tuner_used_for_display(bool on)
Definition: machine.cpp:528
gx_system::JsonException::what
virtual const char * what() const
Definition: gx_json.h:47
gx_engine::GxMachineRemote::get_tuner_switcher_active
virtual bool get_tuner_switcher_active()
Definition: machine.cpp:2013
gx_engine::MidiControllerList::size
int size()
Definition: gx_parameter.h:764
gx_engine::GxMachine::set_midi_channel
virtual void set_midi_channel(int s)
Definition: machine.cpp:931
gx_preset::GxSettings::plugin_preset_list_remove
void plugin_preset_list_remove(const PluginDef *pdef, const Glib::ustring &name)
Definition: gx_preset.cpp:1285
gx_engine::GxMachineRemote::plugin_preset_list_sync_set
virtual void plugin_preset_list_sync_set(const PluginDef *pdef, bool factory, const Glib::ustring &name)
Definition: machine.cpp:2176
gx_system::GxSettingsBase::banks
PresetBanks banks
Definition: gx_json.h:463
gx_engine::GxMachine::get_parameter
virtual Parameter & get_parameter(const char *p)
Definition: machine.cpp:801
gx_engine::GxMachineBase::jack_load_change
sigc::signal< void, MidiAudioBuffer::Load > jack_load_change
Definition: machine.h:56
gx_preset::UnitPresetList
std::vector< PluginPresetEntry > UnitPresetList
Definition: gx_preset.h:134
gx_engine::MidiControllerList::signal_new_program
sigc::signal< void, int > & signal_new_program()
Definition: gx_parameter.h:783
SEND
#define SEND()
Definition: machine.cpp:967
gx_engine::GxMachine::set_parameter_value
virtual void set_parameter_value(const std::string &id, int value)
Definition: machine.cpp:829
ladspa::flag
int flag
Definition: ladspaback.cpp:56
gx_system::PresetFile
Definition: gx_json.h:297
gx_engine::OscilloscopeAdapter::plugin
Plugin plugin
Definition: gx_internal_plugins.h:231
gx_engine::ModuleSequencer::get_state
GxEngineState get_state()
Definition: gx_engine_audio.cpp:770
gx_engine::GxMachineRemote::tuner_switcher_deactivate
virtual void tuner_switcher_deactivate()
Definition: machine.cpp:2026
gx_engine::GxMachineRemote::bank_reorder
virtual void bank_reorder(const std::vector< Glib::ustring > &neworder)
Definition: machine.cpp:2280
gx_engine::ParameterV< GxSeqSettings >::get_value
const GxSeqSettings & get_value() const
Definition: gx_internal_plugins.h:283
gx_preset::GxSettings::loadstate
void loadstate()
Definition: gx_preset.cpp:1184
gx_engine::ParamMap::begin
iterator begin() const
Definition: gx_parameter.h:534
gx_system::CmdlineOptions::get_rpcport
int get_rpcport() const
Definition: gx_system.h:489
gx_engine::GxEngineState
GxEngineState
Definition: gx_modulesequencer.h:283
gx_engine::GxMachine::bank_drag_begin
virtual void bank_drag_begin()
Definition: machine.cpp:747
gx_engine::GxMachineRemote::midi_get
virtual midi_controller_list & midi_get(int n)
Definition: machine.cpp:2721
gx_system::PresetFileGui::get_name
const Glib::ustring & get_name(int n)
Definition: gx_json.cpp:1123
gx_engine::GxMachineRemote::read_audio
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:2781
AvahiService
Definition: avahi_register.h:29
gx_engine::GxMachineRemote::signal_midi_changed
virtual sigc::signal< void > & signal_midi_changed()
Definition: machine.cpp:2704
gx_engine::ParameterV< float >::signal_changed
sigc::signal< void, float > & signal_changed()
Definition: gx_parameter.h:271
ladspa::LadspaPluginList
Definition: ladspaback.h:198
gx_engine::PluginListBase::update_plugin
void update_plugin(Plugin *pvars)
Definition: gx_pluginloader.cpp:507
gx_system::PresetFile::iterator
std::vector< Position >::iterator iterator
Definition: gx_json.h:319
gx_preset::GxSettings::plugin_preset_list_sync_set
void plugin_preset_list_sync_set(const PluginDef *pdef, bool factory, const Glib::ustring &name)
Definition: gx_preset.cpp:1265
UiBuilder::openFrameBox
void(* openFrameBox)(const char *label)
Definition: gx_plugin.h:74
gx_engine::GxMachineRemote::signal_presetlist_changed
virtual sigc::signal< void > & signal_presetlist_changed()
Definition: machine.cpp:2212
gx_engine::GxMachineRemote::bank_end
virtual bank_iterator bank_end()
Definition: machine.cpp:2376
unlock_rt_memory
void unlock_rt_memory()
Definition: machine.cpp:77
PluginDef
Definition: gx_plugin.h:183
GxLogger::kInfo
Definition: gx_logging.h:39
gx_engine::ParamMap::reset_unit
void reset_unit(const PluginDef *pdef) const
Definition: gx_paramtable.cpp:2125
gx_engine::GxMachine::midi_get_config_mode
virtual bool midi_get_config_mode(int *ctl=0)
Definition: machine.cpp:882
gx_engine::ParameterV< GxSeqSettings >
Definition: gx_internal_plugins.h:267
gx_engine::GxMachine::get_options
virtual gx_system::CmdlineOptions & get_options() const
Definition: machine.cpp:472
gx_preset::GxSettings::bank_insert_uri
gx_system::PresetFile * bank_insert_uri(const Glib::ustring &uri, bool move)
Definition: gx_preset.cpp:1026
gx_engine::GxMachine::load_impresp_dirs
virtual void load_impresp_dirs(std::vector< gx_system::FileName > &dirs)
Definition: machine.cpp:948
gx_engine::GxMachine::get_current_bank
virtual const Glib::ustring & get_current_bank()
Definition: machine.cpp:579
gx_engine::ParameterV< GxSeqSettings >::signal_changed
sigc::signal< void, const GxSeqSettings * > & signal_changed()
Definition: gx_internal_plugins.h:279
gx_system::GxSettingsBase::signal_selection_changed
sigc::signal< void > & signal_selection_changed()
Definition: gx_json.h:474
gx_system::JsonException
Definition: gx_json.h:39
gx_engine::ParameterGroups::insert
void insert(const string &id, const string &group)
Definition: gx_parameter.h:69
gx_preset::GxSettings::bank_insert_new
gx_system::PresetFile * bank_insert_new(const Glib::ustring &name)
Definition: gx_preset.cpp:1087
gx_engine::GxMachine::get_oscilloscope_mul_buffer
virtual int get_oscilloscope_mul_buffer()
Definition: machine.cpp:420
gx_engine::GxMachineRemote::midi_get_config_mode
virtual bool midi_get_config_mode(int *ctl=0)
Definition: machine.cpp:2683
gx_engine::GxEngine::controller_map
MidiControllerList controller_map
Definition: gx_engine.h:74
max
#define max(x, y)
Definition: gx_faust_support.h:5
gx_engine::GxMachineRemote::signal_plugin_changed
virtual sigc::signal< void, Plugin *, PluginChange::pc > & signal_plugin_changed()
Definition: machine.cpp:1661
gx_system::GxSettingsBase::signal_presetlist_changed
sigc::signal< void > & signal_presetlist_changed()
Definition: gx_json.h:476
gx_engine::GxMachineBase::~GxMachineBase
virtual ~GxMachineBase()
Definition: machine.cpp:109
gx_system::PresetBanks::insert
void insert(PresetFile *f)
Definition: gx_json.h:447
gx_engine::GxMachine::get_current_bank_file
virtual gx_system::PresetFileGui * get_current_bank_file()
Definition: machine.cpp:583
gx_engine::ParamMap::unregister
void unregister(Parameter *p)
Definition: gx_paramtable.cpp:2061
gx_engine::GxMachine::set_oscilloscope_mul_buffer
virtual void set_oscilloscope_mul_buffer(int a)
Definition: machine.cpp:416
lock_rt_memory
void lock_rt_memory()
Definition: machine.cpp:50
gx_engine::bank_iterator
Definition: machine.h:41
UiBuilder::create_fload_switch
void(* create_fload_switch)(const char *sw_type, const char *id, const char *idf)
Definition: gx_plugin.h:102
gx_engine::GxMachineRemote::bank_check_reparse
virtual bool bank_check_reparse()
Definition: machine.cpp:2303
gx_system::GxSettingsBase::convert_preset
bool convert_preset(PresetFile &pf)
Definition: gx_json.cpp:1946
gx_engine::GxMachineRemote::pluginlist_append_rack
virtual void pluginlist_append_rack(UiBuilderBase &ui)
Definition: machine.cpp:1674
gx_system::JsonWriter::end_object
void end_object(bool nl=false)
Definition: gx_json.cpp:175
gx_engine::OscilloscopeAdapter::activation
sigc::signal< int, bool > activation
Definition: gx_internal_plugins.h:232
gx_engine::GxMachineRemote::bank_begin
virtual bank_iterator bank_begin()
Definition: machine.cpp:2372
GxService::update_maxlevel
void update_maxlevel(CmdConnection *cmd=0)
Definition: jsonrpc.cpp:2217
GxService::ladspaloader_update_plugins
void ladspaloader_update_plugins(gx_system::JsonWriter *jw, CmdConnection *cmd)
Definition: jsonrpc.cpp:1835
gx_engine::GxMachine::bank_check_reparse
virtual bool bank_check_reparse()
Definition: machine.cpp:730
gx_system::JsonWriter::close
virtual void close()
Definition: gx_json.cpp:67
UiBuilder::create_spin_value
void(* create_spin_value)(const char *id, const char *label)
Definition: gx_plugin.h:91
gx_engine::GxMachineRemote::signal_midi_value_changed
virtual sigc::signal< void, int, int > & signal_midi_value_changed()
Definition: machine.cpp:2708
gx_engine::MidiAudioBuffer::load_low
Definition: gx_internal_plugins.h:176
gx_engine::kEngineOff
Definition: gx_modulesequencer.h:285
AvahiService::register_service
bool register_service(std::string name, int port)
Definition: avahi_register.cpp:75
gx_engine::GxMachineRemote::midi_param2controller
virtual int midi_param2controller(Parameter &param, const MidiController **p)
Definition: machine.cpp:2747
gx_engine::GxMachine::GxMachine
GxMachine(gx_system::CmdlineOptions &options)
Definition: machine.cpp:140
gx_preset::GxSettings::disable_autosave
void disable_autosave(bool v)
Definition: gx_preset.h:178
gx_engine::ParameterV< float >
Definition: gx_parameter.h:228
gx_engine::GxMachineRemote::rename_preset
virtual bool rename_preset(gx_system::PresetFileGui &pf, const Glib::ustring &oldname, const Glib::ustring &newname)
Definition: machine.cpp:2264
gx_engine::GxMachine::bank_set_flag
virtual void bank_set_flag(gx_system::PresetFileGui *pf, int flag, bool v)
Definition: machine.cpp:738
gx_gui::UiBuilderImpl::load_unit
bool load_unit(PluginDef *pl)
Definition: gx_ui_builder.cpp:100
gx_engine::GxMachineRemote::midi_size
virtual int midi_size()
Definition: machine.cpp:2717
N_
#define N_(String)
Definition: gx_faust_support.h:23
gx_system::CmdlineOptions::get_temp_filepath
std::string get_temp_filepath(const std::string &basename) const
Definition: gx_system.h:464
gx_jack::GxJack
Definition: gx_jack.h:109
GxService::send_rack_changed
void send_rack_changed(bool stereo, CmdConnection *cmd)
Definition: jsonrpc.cpp:1861
gx_engine::Parameter::getBool
BoolParameter & getBool()
Definition: gx_parameter.h:469
gx_engine::ParameterV< bool >::get_value
bool get_value() const
Definition: gx_parameter.h:362
jsonrpc_method_def::has_result
bool has_result
Definition: jsonrpc_methods-generated.h:97
gx_engine::GxMachineRemote::pf_insert_after
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:2406
UiBuilder::create_small_rackknob
void(* create_small_rackknob)(const char *id, const char *label)
Definition: gx_plugin.h:86
gx_engine::GxMachine::erase_preset
virtual void erase_preset(gx_system::PresetFileGui &pf, const Glib::ustring &name)
Definition: machine.cpp:734
gx_engine::GxMachine::get_bank_file
virtual gx_system::PresetFileGui * get_bank_file(const Glib::ustring &bank) const
Definition: machine.cpp:591
gx_engine::ParameterV< GxJConvSettings >::signal_changed
sigc::signal< void, const GxJConvSettings * > & signal_changed()
Definition: gx_internal_plugins.h:358
gx_system::JsonParser::next
token next(token expect=no_token)
Definition: gx_json.cpp:493
START_RECEIVE
#define START_RECEIVE(s)
Definition: machine.cpp:971
gx_engine::GxMachine::plugin_preset_list_set
virtual void plugin_preset_list_set(const PluginDef *pdef, bool factory, const Glib::ustring &name)
Definition: machine.cpp:662
gx_engine::ParamMap::reg_non_midi_enum_par
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
gx_engine::debug_trace_param
void debug_trace_param(Parameter *p)
Definition: machine.cpp:1071
gx_engine::GxMachineRemote::maxlevel_get
virtual void maxlevel_get(int channels, float *values)
Definition: machine.cpp:1891
gx_engine::MidiControllerList::signal_midi_value_changed
sigc::signal< void, int, int > & signal_midi_value_changed()
Definition: gx_parameter.h:791
gx_engine::GxMachineRemote::bank_save
virtual void bank_save()
Definition: machine.cpp:2448
UiBuilder::create_feedback_switch
void(* create_feedback_switch)(const char *sw_type, const char *id)
Definition: gx_plugin.h:90
gx_engine::GxMachine::load_preset
virtual void load_preset(gx_system::PresetFileGui *pf, const Glib::ustring &name)
Definition: machine.cpp:612
gx_engine::GxMachine::commit_ladspa_changes
virtual void commit_ladspa_changes()
Definition: machine.cpp:388
gx_engine::Parameter::isInt
bool isInt() const
Definition: gx_parameter.h:162
UiBuilder::create_small_rackknobr
void(* create_small_rackknobr)(const char *id, const char *label)
Definition: gx_plugin.h:98
gx_jack::GxJack::get_jack_bs
jack_nframes_t get_jack_bs()
Definition: gx_jack.h:177
gx_engine::GxMachine::setting_is_preset
virtual bool setting_is_preset()
Definition: machine.cpp:574
gx_engine::ParameterV< int >
Definition: gx_parameter.h:293
gx_engine::GxMachine::bank_reorder
virtual void bank_reorder(const std::vector< Glib::ustring > &neworder)
Definition: machine.cpp:722
gx_system::PresetBanks::size
int size()
Definition: gx_json.h:445
gx_preset::GxSettings::rename_bank
bool rename_bank(const Glib::ustring &oldname, Glib::ustring &newname)
Definition: gx_preset.cpp:1101
gx_system::GxSettingsBase::rename_preset
bool rename_preset(PresetFile &pf, const Glib::ustring &oldname, const Glib::ustring &newname)
Definition: gx_json.cpp:2001
gx_engine::GxMachine::load_unit
virtual bool load_unit(gx_gui::UiBuilderImpl &builder, PluginDef *pdef)
Definition: machine.cpp:404
gx_engine
Definition: gx_convolver.h:33
UiBuilder::create_eq_rackslider_no_caption
void(* create_eq_rackslider_no_caption)(const char *id)
Definition: gx_plugin.h:101
gx_engine::PluginListBase::delete_module
void delete_module(Plugin *pl)
Definition: gx_pluginloader.cpp:477
gx_engine::GxEngine::oscilloscope
OscilloscopeAdapter oscilloscope
Definition: gx_engine.h:89
gx_engine::GxMachineRemote::rename_bank
virtual bool rename_bank(const Glib::ustring &oldname, Glib::ustring &newname)
Definition: machine.cpp:2246
UiBuilder::create_selector_no_caption
void(* create_selector_no_caption)(const char *id)
Definition: gx_plugin.h:88
gx_engine::GxMachineRemote::~GxMachineRemote
virtual ~GxMachineRemote()
Definition: machine.cpp:1060
TunerSwitcher::activate
void activate(bool tuner_active)
Definition: tunerswitcher.cpp:214
gx_engine::GxMachine::signal_oscilloscope_visible
virtual sigc::signal< void, bool > & signal_oscilloscope_visible()
Definition: machine.cpp:440
gx_engine::ParamMap::end
iterator end() const
Definition: gx_parameter.h:535
gx_engine::GxMachine::create_default_scratch_preset
virtual void create_default_scratch_preset()
Definition: machine.cpp:646
gx_system::PresetBanks::readJSON_remote
void readJSON_remote(gx_system::JsonParser &jp)
Definition: gx_json.cpp:1367
gx_system::CmdlineOptions::get_rpcaddress
const Glib::ustring & get_rpcaddress()
Definition: gx_system.h:491
gx_system::JsonWriter::write_kv
void write_kv(const char *key, float v)
Definition: gx_json.h:80
gx_engine::Parameter::getFloat
FloatParameter & getFloat()
Definition: gx_parameter.h:453
gx_engine::PluginListBase::insert_plugin
int insert_plugin(Plugin *pvars)
Definition: gx_pluginloader.cpp:494
gx_engine::GxMachine::pf_insert_before
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:766
gx_system::PresetFile::get_name
const Glib::ustring & get_name(int n)
Definition: gx_json.cpp:1123
gx_engine::GxMachineRemote::request_midi_value_update
virtual void request_midi_value_update()
Definition: machine.cpp:2712
UiBuilder::plugin
PluginDef * plugin
Definition: gx_plugin.h:64
gx_engine::GxMachineRemote::get_jack
virtual gx_jack::GxJack * get_jack()
Definition: machine.cpp:2462
gx_engine::GxMachineRemote::midi_modifyCurrent
virtual void midi_modifyCurrent(Parameter &param, float lower, float upper, bool toggle, int toggle_behaviour)
Definition: machine.cpp:2737
gx_system::JsonWriter
Definition: gx_json.h:54
gx_system::PresetBanks::get_file
PresetFile * get_file(const Glib::ustring &bank) const
Definition: gx_json.cpp:1616
gx_system::PresetBanks::check_reparse
bool check_reparse()
Definition: gx_json.cpp:1381
gx_engine::GxMachineRemote::plugin_preset_list_remove
virtual void plugin_preset_list_remove(const PluginDef *pdef, const Glib::ustring &name)
Definition: machine.cpp:2196
gx_engine::GxMachineRemote::start_socket
virtual void start_socket(sigc::slot< void > quit_mainloop, const Glib::ustring &host, int port)
Definition: machine.cpp:1942
gx_system::JsonParser::throw_unexpected
void throw_unexpected(token expect)
Definition: gx_json.cpp:300
START_NOTIFY
#define START_NOTIFY(m)
Definition: machine.cpp:964
gx_engine::EngineControl::pluginlist
PluginList pluginlist
Definition: gx_modulesequencer.h:255
gx_engine::GxMachine::tuner_switcher_activate
virtual void tuner_switcher_activate(bool v)
Definition: machine.cpp:561
gx_system::PresetBanks::reorder
void reorder(const std::vector< Glib::ustring > &neworder)
Definition: gx_json.cpp:1662
gx_system::GxSettingsBase::insert_before
void insert_before(PresetFile &pf, const Glib::ustring &src, PresetFile &pftgt, const Glib::ustring &pos, const Glib::ustring &name)
Definition: gx_json.cpp:1854
gx_engine::GxMachine::set_jack_insert
virtual void set_jack_insert(bool v)
Definition: machine.cpp:796
gx_engine::GxMachineRemote::tuner_switcher_signal_display
virtual sigc::signal< void, const Glib::ustring &, const Glib::ustring & > & tuner_switcher_signal_display()
Definition: machine.cpp:1949
gx_engine::GxMachineRemote::signal_state_change
virtual sigc::signal< void, GxEngineState > & signal_state_change()
Definition: machine.cpp:1961
gx_engine::GxMachineRemote::clear_oscilloscope_buffer
virtual void clear_oscilloscope_buffer()
Definition: machine.cpp:1858
gx_engine::MidiControllerList::signal_new_bank
sigc::signal< void, int > & signal_new_bank()
Definition: gx_parameter.h:785
gx_engine::GxMachineRemote::get_rack_unit_order
virtual const std::vector< std::string > & get_rack_unit_order(PluginType type)
Definition: machine.cpp:1971
gx_jack::GxJack::get_is_rt
bool get_is_rt()
Definition: gx_jack.h:179
gx_engine::ParameterGroups::group_exist
bool group_exist(const string &id)
Definition: gx_paramtable.cpp:862
gx_engine::GxMachineRemote::bank_insert_uri
virtual gx_system::PresetFileGui * bank_insert_uri(const Glib::ustring &uri, bool move)
Definition: machine.cpp:2216
gx_system::JsonStringParser::put
void put(char c)
Definition: gx_json.h:206
gx_engine::ParameterV< float >::get_value
float get_value() const
Definition: gx_parameter.h:244
gx_system::JsonParser
Definition: gx_json.h:111
gx_engine::Parameter::setSavable
void setSavable(bool v)
Definition: gx_parameter.h:170
gx_engine::GxMachineRemote::remove_rack_unit
virtual void remove_rack_unit(const std::string &unit, PluginType type)
Definition: machine.cpp:1997
gx_engine::GxMachine::tuner_switcher_deactivate
virtual void tuner_switcher_deactivate()
Definition: machine.cpp:565
gx_engine::GxMachineRemote::set_statefilename
virtual void set_statefilename(const std::string &fn)
Definition: machine.cpp:2141
jsonrpc_method_def::name
const char * name
Definition: jsonrpc_methods-generated.h:96
gx_engine::GxMachine::process_next_preset_switch
virtual void process_next_preset_switch(bool s)
Definition: machine.cpp:311
gx_engine::GxMachineRemote::reset_unit
virtual void reset_unit(const PluginDef *pdef) const
Definition: machine.cpp:2574
gx_system::PresetFileGui
Definition: gx_json.h:369
gx_engine::ParameterV< Glib::ustring >::get_value
const Glib::ustring & get_value() const
Definition: gx_parameter.h:433
gx_engine::GxMachineRemote::set_parameter_value
virtual void set_parameter_value(const std::string &id, int value)
Definition: machine.cpp:2582
gx_engine::GxMachineRemote::commit_ladspa_changes
virtual void commit_ladspa_changes()
Definition: machine.cpp:1652
gx_engine::GxMachineRemote::signal_oscilloscope_size_change
virtual sigc::signal< void, unsigned int > & signal_oscilloscope_size_change()
Definition: machine.cpp:1879
gx_engine::GxMachine::get_tuner_freq
virtual float get_tuner_freq()
Definition: machine.cpp:412
gx_engine::EnumParameter
Definition: gx_parameter.h:331
gx_preset::GxSettings::create_default_scratch_preset
void create_default_scratch_preset()
Definition: gx_preset.cpp:982
gx_engine::PluginChange::add
Definition: gx_engine.h:64
gx_engine::GxMachineRemote::pf_save
virtual void pf_save(gx_system::PresetFileGui &pf, const Glib::ustring &name)
Definition: machine.cpp:2453
gx_engine::GxMachine::set_init_values
virtual void set_init_values()
Definition: machine.cpp:809
gx_engine::FileParameter::signal_changed
sigc::signal< void > & signal_changed()
Definition: gx_parameter.h:391
gx_print_error
void gx_print_error(const char *, const std::string &)
Definition: gx_logging.cpp:165
START_CALL
#define START_CALL(m)
Definition: machine.cpp:969
gx_jack::GxJack::send_midi_cc
void send_midi_cc(int cc_num, int pgm_num, int bgn, int num)
Definition: gx_jack.cpp:909
gx_engine::GxMachine::midi_modifyCurrent
virtual void midi_modifyCurrent(Parameter &param, float lower, float upper, bool toggle, int toggle_behaviour)
Definition: machine.cpp:922
gx_system::PresetFile::size
int size()
Definition: gx_json.cpp:1086
gx_system::JsonParser::begin_array
Definition: gx_json.h:125
gx_engine::JConvParameter
ParameterV< GxJConvSettings > JConvParameter
Definition: gx_internal_plugins.h:371
gx_engine::GxMachine::pluginlist_append_rack
virtual void pluginlist_append_rack(UiBuilderBase &ui)
Definition: machine.cpp:408
gx_engine::GxMachineRemote::pf_append
virtual void pf_append(gx_system::PresetFileGui &pf, const Glib::ustring &src, gx_system::PresetFileGui &pftgt, const Glib::ustring &name)
Definition: machine.cpp:2380
gx_engine::GxMachine::get_oscilloscope_buffer
virtual const float * get_oscilloscope_buffer()
Definition: machine.cpp:424
gx_engine::GxMachineRemote::signal_selection_changed
virtual sigc::signal< void > & signal_selection_changed()
Definition: machine.cpp:2208
gx_system::PresetFileGui::end
iterator end()
Definition: gx_json.h:364
gx_system::PresetFile::get_filename
const std::string & get_filename() const
Definition: gx_json.h:335
jsonrpc_method
jsonrpc_method
Definition: jsonrpc_methods-generated.h:8
gx_engine::GxMachineRemote::convert_preset
virtual bool convert_preset(gx_system::PresetFileGui &pf)
Definition: machine.cpp:2422
gx_engine::GxMachine::set_state
virtual void set_state(GxEngineState state)
Definition: machine.cpp:372
gx_engine::GxMachine::read_audio
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:952
gx_engine::GxMachine::signal_oscilloscope_activation
virtual sigc::signal< int, bool > & signal_oscilloscope_activation()
Definition: machine.cpp:444
gx_engine::kEngineOn
Definition: gx_modulesequencer.h:286
ladspa::LadspaPluginList::writeJSON
void writeJSON(gx_system::JsonWriter &jw)
Definition: ladspaback.cpp:1827
gx_engine::midi_std_ctr
MidiStandardControllers midi_std_ctr
Definition: gx_paramtable.cpp:37
gx_engine::get_group_table
ParameterGroups & get_group_table()
Definition: gx_paramtable.cpp:848
UiBuilder::closeBox
void(* closeBox)()
Definition: gx_plugin.h:77
gx_engine::Parameter::getFile
FileParameter & getFile()
Definition: gx_parameter.h:474
gx_engine::MidiAudioBuffer::get_midistat
bool get_midistat()
Definition: gx_internal_plugins.h:191
gx_engine::GxMachine::save_to_state
virtual void save_to_state(bool preserve_preset=false)
Definition: machine.cpp:654
ladspa::LadspaPluginList::readJSON
void readJSON(gx_system::JsonParser &jp)
Definition: ladspaback.cpp:1819
gx_engine::kEngineBypass
Definition: gx_modulesequencer.h:287
gx_engine::GxMachine::bank_insert_new
virtual gx_system::PresetFileGui * bank_insert_new(const Glib::ustring &newname)
Definition: machine.cpp:705
gx_engine::GxMachineRemote::tuner_used_for_display
virtual void tuner_used_for_display(bool on)
Definition: machine.cpp:1965
gx_system::JsonWriter::begin_array
void begin_array(bool nl=false)
Definition: gx_json.cpp:183
gx_engine::ParamMap::unit_has_std_values
bool unit_has_std_values(const PluginDef *pdef) const
Definition: gx_paramtable.cpp:2102
gx_engine::GxMachine::midi_set_config_mode
virtual void midi_set_config_mode(bool v, int ctl=-1)
Definition: machine.cpp:890
gx_engine::GxMachine::msend_midi_cc
virtual void msend_midi_cc(int cc, int pgn, int bgn, int num)
Definition: machine.cpp:608
gx_engine::ParameterV< Glib::ustring >::signal_changed
sigc::signal< void, const Glib::ustring & > & signal_changed()
Definition: gx_parameter.h:447
UiBuilder::openVerticalBox1
void(* openVerticalBox1)(const char *label)
Definition: gx_plugin.h:69
gx_engine::GxMachine::load_ladspalist
virtual void load_ladspalist(std::vector< std::string > &old_not_found, ladspa::LadspaPluginList &pluginlist)
Definition: machine.cpp:380
gx_engine::ParamMap::set_init_values
void set_init_values()
Definition: gx_paramtable.cpp:2077
gx_engine::PluginListBase::readJSON
void readJSON(gx_system::JsonParser &jp, ParamMap &pmap)
Definition: gx_pluginloader.cpp:764
gx_preset::UnitRacks::mono
std::vector< std::string > mono
Definition: gx_preset.h:38
gx_engine::GxMachineRemote::tuner_switcher_signal_selection_done
virtual sigc::signal< void, bool > & tuner_switcher_signal_selection_done()
Definition: machine.cpp:1957
gx_engine::GxMachine::process_previus_preset_switch
virtual void process_previus_preset_switch(bool s)
Definition: machine.cpp:319
PluginDef::id
const char * id
Definition: gx_plugin.h:187
gx_engine::GxMachineBase::impresp_list
sigc::signal< void, const std::string &, std::vector< gx_system::FileName > > impresp_list
Definition: machine.h:55
gx_engine::GxMachine::tuner_switcher_signal_display
virtual sigc::signal< void, const Glib::ustring &, const Glib::ustring & > & tuner_switcher_signal_display()
Definition: machine.cpp:512
gx_engine::GxEngine::tuner
TunerAdapter tuner
Definition: gx_engine.h:84
gx_engine::GxMachine::~GxMachine
virtual ~GxMachine()
Definition: machine.cpp:262
gx_system::JsonParser::end_array
Definition: gx_json.h:126
gx_engine::GxEngine::signal_plugin_changed
sigc::signal< void, Plugin *, PluginChange::pc > & signal_plugin_changed()
Definition: gx_engine.h:108
gx_system::PresetFileGui::begin
iterator begin()
Definition: gx_json.cpp:1339
gx_system::PresetFile::name
Glib::ustring name
Definition: gx_json.h:312
gx_engine::GxMachineRemote::pluginlist_lookup_plugin
virtual Plugin * pluginlist_lookup_plugin(const std::string &id) const
Definition: machine.cpp:1670
gx_engine::GxMachineRemote::get_current_bank
virtual const Glib::ustring & get_current_bank()
Definition: machine.cpp:2076
gx_engine::GxMachine::bank_get_file
virtual gx_system::PresetFileGui * bank_get_file(const Glib::ustring &bank) const
Definition: machine.cpp:750
gx_jack::GxJack::set_jack_insert
void set_jack_insert(bool v)
Definition: gx_jack.h:189
gx_system::JsonParser::end_object
Definition: gx_json.h:124
gx_jack::GxJack::get_instancename
const string & get_instancename()
Definition: gx_jack.h:200
gx_engine::GxMachine::get_rack_unit_order
virtual const std::vector< std::string > & get_rack_unit_order(PluginType type)
Definition: machine.cpp:532
gx_system::PresetFileGui::get_index
int get_index(const Glib::ustring &name)
Definition: gx_json.cpp:1128
gx_engine::ParameterV< bool >::set
bool set(bool val) const
Definition: gx_paramtable.cpp:1617
gx_engine::GxEngine::set_jack
void set_jack(gx_jack::GxJack *jack)
Definition: gx_engine.h:106
gx_engine::GxMachineRemote::reorder_preset
virtual void reorder_preset(gx_system::PresetFileGui &pf, const std::vector< Glib::ustring > &neworder)
Definition: machine.cpp:2289
gx_engine::GxMachineRemote::save_ladspalist
virtual void save_ladspalist(ladspa::LadspaPluginList &pluginlist)
Definition: machine.cpp:1604
gx_preset::GxSettings::get_rack_unit_order
std::vector< std::string > & get_rack_unit_order(bool stereo)
Definition: gx_preset.h:186
gx_engine::GxMachineRemote::load_online_presets
virtual void load_online_presets()
Definition: machine.cpp:2119
gx_engine::GxMachine::signal_state_change
virtual sigc::signal< void, GxEngineState > & signal_state_change()
Definition: machine.cpp:524
gx_engine::GxMachineRemote::create_default_scratch_preset
virtual void create_default_scratch_preset()
Definition: machine.cpp:2136
gx_engine::OscilloscopeAdapter::size_change
sigc::signal< void, unsigned int > size_change
Definition: gx_internal_plugins.h:233
gx_system::PresetFile::readJSON_remote
void readJSON_remote(JsonParser &jp)
Definition: gx_json.cpp:871
GxLogger::kWarning
Definition: gx_logging.h:40
gx_engine::GxMachineRemote::get_parameter
virtual Parameter & get_parameter(const char *p)
Definition: machine.cpp:2473
gx_engine::on_engine_bypass_changed
void on_engine_bypass_changed(bool s, GxEngine &engine)
Definition: machine.cpp:130
gx_engine::GxMachine::loadstate
virtual void loadstate()
Definition: machine.cpp:627
gx_engine::GxMachine::midi_get
virtual midi_controller_list & midi_get(int n)
Definition: machine.cpp:910
TunerSwitcher::signal_set_state
sigc::signal< void, SwitcherState > & signal_set_state()
Definition: tunerswitcher.h:71
UiBuilder::create_simple_meter
void(* create_simple_meter)(const char *id)
Definition: gx_plugin.h:96
gx_system::GxSettingsBase::get_current_bank
const Glib::ustring & get_current_bank()
Definition: gx_json.h:480
gx_engine::GxMachineRemote::load_ladspalist
virtual void load_ladspalist(std::vector< std::string > &old_not_found, ladspa::LadspaPluginList &pluginlist)
Definition: machine.cpp:1591
gx_engine::GxMachine::plugin_preset_list_remove
virtual void plugin_preset_list_remove(const PluginDef *pdef, const Glib::ustring &name)
Definition: machine.cpp:680
gx_engine::ParameterV< int >::get_value
int get_value() const
Definition: gx_parameter.h:306
gx_engine::GxMachine::rename_preset
virtual bool rename_preset(gx_system::PresetFileGui &pf, const Glib::ustring &oldname, const Glib::ustring &newname)
Definition: machine.cpp:718
gx_engine::GxMachineRemote::bank_drag_begin
virtual void bank_drag_begin()
Definition: machine.cpp:2363
gx_engine::ParamMap::readJSON_one
Parameter * readJSON_one(gx_system::JsonParser &jp)
Definition: gx_paramtable.cpp:1912
GxService
Definition: jsonrpc.h:117
gx_system::CmdlineOptions
Definition: gx_system.h:377
gx_engine::OscilloscopeAdapter::get_mul_buffer
int get_mul_buffer()
Definition: gx_internal_plugins.h:237
gx_engine::GxMachine::midi_size
virtual int midi_size()
Definition: machine.cpp:906
gx_engine::GxMachine::disable_autosave
virtual void disable_autosave(bool v)
Definition: machine.cpp:684
gx_engine::Parameter::id
const string & id() const
Definition: gx_parameter.h:171
gx_engine::GxMachine::load_online_presets
virtual void load_online_presets()
Definition: machine.cpp:623
TunerSwitcher::toggle
void toggle(bool tuner_active)
Definition: tunerswitcher.cpp:247
gx_engine::GxMachineRemote::bank_insert_new
virtual gx_system::PresetFileGui * bank_insert_new(const Glib::ustring &newname)
Definition: machine.cpp:2235
gx_preset::UnitRacks::rack_unit_order_changed
sigc::signal< void, bool > rack_unit_order_changed
Definition: gx_preset.h:40
PLUGIN_TYPE_STEREO
Definition: machine.h:36
gx_system::JsonParser::value_number
Definition: gx_json.h:128
gx_engine::MidiControllerList::signal_new_mute_state
sigc::signal< void, int > & signal_new_mute_state()
Definition: gx_parameter.h:784
UiBuilder::openFlipLabelBox
void(* openFlipLabelBox)(const char *label)
Definition: gx_plugin.h:75
gx_engine::Parameter::isFloat
bool isFloat() const
Definition: gx_parameter.h:161
gx_engine::read_audio
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: gx_convolver.cpp:122
gx_system::PresetBanks::get_name
Glib::ustring get_name(int n)
Definition: gx_json.cpp:1680
GxFatalError
Definition: gx_logging.h:89
gx_engine::ParamMap::dump
void dump(const string &fmt)
Definition: gx_paramtable.cpp:1967
UiBuilder::create_simple_spin_value
void(* create_simple_spin_value)(const char *id)
Definition: gx_plugin.h:100
gx_system::GxSettingsBase::set_statefilename
void set_statefilename(const std::string &fn)
Definition: gx_json.h:483
gx_system::PresetFile::Position
Definition: gx_json.h:301
gx_system::GxSettingsBase::load_online_presets
void load_online_presets()
Definition: gx_json.cpp:1749
UiBuilder
Definition: gx_plugin.h:63
gx_system::GxSettingsBase::load_preset
void load_preset(PresetFile *pf, const Glib::ustring &name)
Definition: gx_json.cpp:1762
gx_engine::MidiAudioBuffer::signal_jack_load_change
Glib::Dispatcher & signal_jack_load_change()
Definition: gx_internal_plugins.h:193
gx_engine::GxMachineRemote::loadstate
virtual void loadstate()
Definition: machine.cpp:2124
gx_system::JsonParser::current_value_int
int current_value_int()
Definition: gx_json.h:143
gx_engine::GxMachineRemote::load_unit
virtual bool load_unit(gx_gui::UiBuilderImpl &builder, PluginDef *pdef)
Definition: machine.cpp:1831
GxLogger::get_logger
static GxLogger & get_logger()
Definition: gx_logging.cpp:49
gx_engine::Parameter::isFile
bool isFile() const
Definition: gx_parameter.h:164
gx_engine::GxEngine::maxlevel
MaxLevel maxlevel
Definition: gx_engine.h:88
gx_system::GxSettingsBase::save_to_state
void save_to_state(bool preserve_preset=false)
Definition: gx_json.cpp:1822
TunerSwitcher::signal_display
sigc::signal< void, const Glib::ustring &, const Glib::ustring & > & signal_display()
Definition: tunerswitcher.h:70
gx_engine::GxEngine
Definition: gx_engine.h:67
gx_engine::GxMachineRemote::get_state
virtual GxEngineState get_state()
Definition: machine.cpp:1578
gx_engine::GxMachine::tuner_switcher_signal_selection_done
virtual sigc::signal< void, bool > & tuner_switcher_signal_selection_done()
Definition: machine.cpp:520
gx_system::PresetBanks::end
iterator end()
Definition: gx_json.h:442
gx_engine::GxMachineRemote::erase_preset
virtual void erase_preset(gx_system::PresetFileGui &pf, const Glib::ustring &name)
Definition: machine.cpp:2310
gx_system::JsonParser::current_value_float
float current_value_float()
Definition: gx_json.h:145
gx_engine::GxMachineRemote::setting_is_preset
virtual bool setting_is_preset()
Definition: machine.cpp:2070
gx_engine::GxMachineRemote::load_impresp_dirs
virtual void load_impresp_dirs(std::vector< gx_system::FileName > &dirs)
Definition: machine.cpp:2765
gx_engine::GxMachineRemote::bank_get_file
virtual gx_system::PresetFileGui * bank_get_file(const Glib::ustring &bank) const
Definition: machine.cpp:2368
start
CmdConnection::msg_type start
Definition: jsonrpc.cpp:255
gx_engine::GxMachine::bank_insert_uri
virtual gx_system::PresetFileGui * bank_insert_uri(const Glib::ustring &uri, bool move)
Definition: machine.cpp:696
gx_engine::GxMachineRemote::tuner_switcher_signal_set_state
virtual sigc::signal< void, TunerSwitcher::SwitcherState > & tuner_switcher_signal_set_state()
Definition: machine.cpp:1953
gx_system::add_time_measurement
void add_time_measurement()
Definition: gx_system.cpp:145
gx_system::JsonParser::peek
token peek()
Definition: gx_json.h:138
gx_system::JsonWriter::write_key
void write_key(const char *p, bool nl=false)
Definition: gx_json.cpp:199
gx_engine::GxMachine::pf_insert_after
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:770
gx_engine::TunerAdapter::get_freq
float get_freq()
Definition: gx_internal_plugins.h:93
gx_engine::MidiControllerList::deleteParameter
void deleteParameter(Parameter &param)
Definition: gx_paramtable.cpp:610
gx_engine::GxMachine::plugin_preset_list_sync_set
virtual void plugin_preset_list_sync_set(const PluginDef *pdef, bool factory, const Glib::ustring &name)
Definition: machine.cpp:666
engine_state_to_string
const char * engine_state_to_string(gx_engine::GxEngineState s)
Definition: jsonrpc.cpp:31
UiBuilder::set_next_flags
void(* set_next_flags)(int flags)
Definition: gx_plugin.h:79
gx_system::JsonWriter::reset
void reset()
Definition: gx_json.cpp:58
gx_engine::GxMachineRemote::GxMachineRemote
GxMachineRemote(gx_system::CmdlineOptions &options)
Definition: machine.cpp:980
gx_engine::ParamMap::iterator
map< string, Parameter * >::const_iterator iterator
Definition: gx_parameter.h:533
gx_system::IRFileListing
Definition: gx_system.h:331
TunerSwitcher::SwitcherState
SwitcherState
Definition: tunerswitcher.h:31
UiBuilder::create_master_slider
void(* create_master_slider)(const char *id, const char *label)
Definition: gx_plugin.h:84
gx_system::GxSettingsBase::get_current_bank_file
PresetFile * get_current_bank_file()
Definition: gx_json.h:481
gx_engine::GxMachineRemote::parameter_hasId
virtual bool parameter_hasId(const char *p)
Definition: machine.cpp:2566
gx_system::JsonParser::skip_object
void skip_object()
Definition: gx_json.cpp:608
GxLogger::kError
Definition: gx_logging.h:41
UiBuilder::openHorizontalBox
void(* openHorizontalBox)(const char *label)
Definition: gx_plugin.h:71
gx_engine::MaxLevel::get
static float get(unsigned int channel)
Definition: gx_internal_plugins.h:57
gx_engine::GxMachineRemote::tuner_switcher_toggle
virtual void tuner_switcher_toggle(bool v)
Definition: machine.cpp:2031
gx_engine::GxMachine::midi_set_current_control
virtual void midi_set_current_control(int v)
Definition: machine.cpp:918
gx_engine::GxMachine::request_midi_value_update
virtual void request_midi_value_update()
Definition: machine.cpp:902
gx_engine::GxMachine::bank_size
virtual int bank_size()
Definition: machine.cpp:638
UiBuilder::openHorizontalhideBox
void(* openHorizontalhideBox)(const char *label)
Definition: gx_plugin.h:72
gx_engine::GxMachineRemote::plugin_preset_list_set
virtual void plugin_preset_list_set(const PluginDef *pdef, bool factory, const Glib::ustring &name)
Definition: machine.cpp:2168
gx_engine::GxMachine::previus_preset_switch
virtual void previus_preset_switch()
Definition: machine.cpp:304
gx_system::GxSettingsBase::get_current_name
const Glib::ustring & get_current_name()
Definition: gx_json.h:482
gx_engine::Plugin
Definition: gx_pluginloader.h:44
gx_engine::FileParameter
Definition: gx_parameter.h:384
gx_engine::ParamMap::reg_non_midi_par
BoolParameter * reg_non_midi_par(const string &id, bool *var, bool preset, bool std=false)
Definition: gx_parameter.h:595
UiBuilder::create_big_rackknob
void(* create_big_rackknob)(const char *id, const char *label)
Definition: gx_plugin.h:87
gx_preset::GxSettings::remove_rack_unit
bool remove_rack_unit(const std::string &unit, bool stereo)
Definition: gx_preset.cpp:996
gx_system::JsonWriter::end_array
void end_array(bool nl=false)
Definition: gx_json.cpp:191
gx_engine::ParamMap::hasId
bool hasId(const string &id) const
Definition: gx_parameter.h:536
gx_engine::ParamMap::reg_par
FloatParameter * reg_par(const string &id, const string &name, float *var, float std, float lower, float upper, float step)
Definition: gx_parameter.h:553
gx_system::PresetFileGui::size
int size()
Definition: gx_json.cpp:1086
gx_engine::GxMachine::reorder_preset
virtual void reorder_preset(gx_system::PresetFileGui &pf, const std::vector< Glib::ustring > &neworder)
Definition: machine.cpp:726
gx_engine::GxMachine::pf_append
virtual void pf_append(gx_system::PresetFileGui &pf, const Glib::ustring &src, gx_system::PresetFileGui &pftgt, const Glib::ustring &name)
Definition: machine.cpp:762
gx_system::FileName
Definition: gx_system.h:323
gx_engine::GxMachine::parameter_unit_has_std_values
virtual bool parameter_unit_has_std_values(const PluginDef *pdef) const
Definition: machine.cpp:825
gx_engine::ParameterV< int >::signal_changed
sigc::signal< void, int > & signal_changed()
Definition: gx_parameter.h:326
gx_engine::GxMachineRemote::get_oscilloscope_info
virtual void get_oscilloscope_info(int &load, int &frames, bool &is_rt, jack_nframes_t &bsize)
Definition: machine.cpp:1907
gx_engine::ParameterV< Glib::ustring >
Definition: gx_parameter.h:424
gx_engine::GxMachineRemote::process_previus_preset_switch
virtual void process_previus_preset_switch(bool s)
Definition: machine.cpp:2061
gx_engine::set_engine_mute
void set_engine_mute(GxEngineState s, BoolParameter &p)
Definition: machine.cpp:116
gx_engine::GxMachine::insert_rack_unit
virtual void insert_rack_unit(const std::string &unit, const std::string &before, PluginType type)
Definition: machine.cpp:549
gx_engine::Parameter::getInt
IntParameter & getInt()
Definition: gx_parameter.h:458
gx_engine::GxMachineRemote::set_midi_channel
virtual void set_midi_channel(int s)
Definition: machine.cpp:2751
gx_engine::OscilloscopeAdapter::set_mul_buffer
void set_mul_buffer(int a, unsigned int b)
Definition: gx_internal_plugins.h:238
gx_engine::GxMachineRemote::stop_socket
virtual void stop_socket()
Definition: machine.cpp:1946
gx_system::PresetFile::get_guiwrapper
PresetFileGui * get_guiwrapper()
Definition: gx_json.h:391
gx_engine::GxMachine::plugin_preset_list_load
virtual void plugin_preset_list_load(const PluginDef *pdef, gx_preset::UnitPresetList &presetnames)
Definition: machine.cpp:658
jsonrpc_method_def
Definition: jsonrpc_methods-generated.h:95
gx_engine::Plugin::id_box_visible
const std::string & id_box_visible() const
Definition: gx_pluginloader.h:70
UiBuilder::create_simple_c_meter
void(* create_simple_c_meter)(const char *id, const char *idl, const char *label)
Definition: gx_plugin.h:97
gx_engine::MidiController
Definition: gx_parameter.h:670
gx_engine::GxMachineRemote::get_oscilloscope_buffer
virtual const float * get_oscilloscope_buffer()
Definition: machine.cpp:1854
guitarix.h
gx_engine::GxMachine::signal_plugin_changed
virtual sigc::signal< void, Plugin *, PluginChange::pc > & signal_plugin_changed()
Definition: machine.cpp:396
gx_engine::ModuleSequencer::set_state
void set_state(GxEngineState state)
Definition: gx_engine_audio.cpp:747
ladspa::LadspaPluginList::load
void load(gx_system::CmdlineOptions &options, std::vector< std::string > &old_not_found)
Definition: ladspaback.cpp:1634
UiBuilder::load_glade
void(* load_glade)(const char *data)
Definition: gx_plugin.h:65
gx_engine::GxMachineRemote::save_to_state
virtual void save_to_state(bool preserve_preset=false)
Definition: machine.cpp:2146
gx_engine::Parameter
Definition: gx_parameter.h:104
gx_engine::Parameter::isBool
bool isBool() const
Definition: gx_parameter.h:163
gx_engine::GxMachineRemote::process_next_preset_switch
virtual void process_next_preset_switch(bool s)
Definition: machine.cpp:2053
UiBuilder::openTabBox
void(* openTabBox)(const char *label)
Definition: gx_plugin.h:67
gx_engine::GxMachine::remove_rack_unit
virtual void remove_rack_unit(const std::string &unit, PluginType type)
Definition: machine.cpp:540
gx_engine::GxMachineRemote::plugin_preset_list_load
virtual void plugin_preset_list_load(const PluginDef *pdef, gx_preset::UnitPresetList &presetnames)
Definition: machine.cpp:2151
GxLogger::MsgType
MsgType
Definition: gx_logging.h:37
UiBuilder::create_switch
void(* create_switch)(const char *sw_type, const char *id, const char *label)
Definition: gx_plugin.h:94
gx_engine::GxMachineRemote::get_bank_index
virtual int get_bank_index(const Glib::ustring &bank)
Definition: machine.cpp:2132
gx_engine::GxMachine::signal_oscilloscope_post_pre
virtual sigc::signal< void, int > & signal_oscilloscope_post_pre()
Definition: machine.cpp:436
gx_engine::PluginListBase::lookup_plugin
Plugin * lookup_plugin(const std::string &id) const
Definition: gx_pluginloader.cpp:396
UiBuilder::create_selector
void(* create_selector)(const char *id, const char *label)
Definition: gx_plugin.h:95
gx_engine::Plugin::id_effect_post_pre
const std::string & id_effect_post_pre() const
Definition: gx_pluginloader.h:74
gx_jack::GxJack::get_jcpu_load
float get_jcpu_load()
Definition: gx_jack.h:178
main
int main(int argc, char *argv[])
Definition: gxw_demo.cc:67
gx_engine::GxEngine::ladspaloader_update_plugins
void ladspaloader_update_plugins()
Definition: gx_engine.cpp:476
gx_engine::GxMachineRemote::get_current_name
virtual const Glib::ustring & get_current_name()
Definition: machine.cpp:2084
gx_engine::ParameterV< bool >::signal_changed
sigc::signal< void, bool > & signal_changed()
Definition: gx_parameter.h:377
gx_engine::GxMachineRemote::get_current_bank_file
virtual gx_system::PresetFileGui * get_current_bank_file()
Definition: machine.cpp:2080
gx_engine::GxMachine::signal_selection_changed
virtual sigc::signal< void > & signal_selection_changed()
Definition: machine.cpp:688
gx_engine::GxMachineRemote::insert_param
virtual void insert_param(Glib::ustring group, Glib::ustring name)
Definition: machine.cpp:2482
gx_system::PresetBanks::save
void save()
Definition: gx_json.cpp:1510
gx_preset::PluginPresetEntry
Definition: gx_preset.h:127
gx_engine::GxMachine::insert_param
virtual void insert_param(Glib::ustring group, Glib::ustring name)
Definition: machine.cpp:272
gx_preset::GxSettings::signal_rack_unit_order_changed
sigc::signal< void, bool > & signal_rack_unit_order_changed()
Definition: gx_preset.h:187
UiBuilder::insertSpacer
void(* insertSpacer)()
Definition: gx_plugin.h:78
gx_engine::OscilloscopeAdapter::clear_buffer
void clear_buffer()
Definition: gx_internal_ui_plugins.cpp:228
gx_system::GxSettingsBase::setting_is_preset
bool setting_is_preset()
Definition: gx_json.h:487
gx_system::PRESET_FLAG_VERSIONDIFF
Definition: gx_json.h:290
gx_engine::MidiControllerList::modifyCurrent
void modifyCurrent(Parameter &param, float lower, float upper, bool toggle, int toggle_behaviour)
Definition: gx_paramtable.cpp:623
gx_engine::Parameter::isString
bool isString() const
Definition: gx_parameter.h:165
set_memory_allocation
void set_memory_allocation()
Definition: machine.cpp:35