Guitarix
gx_preset.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2009, 2010 Hermann Meyer, James Warden, Andreas Degert
3  * Copyright (C) 2011 Pete Shorthose
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18  * --------------------------------------------------------------------------
19  */
20 
21 /* --------------------------------------------------------------------------
22 
23  This is the gx_head preset handling functions
24 
25  ---------------------------------------------------------------------------*/
26 
27 #include <sys/stat.h>
28 
29 #include "engine.h" // NOLINT
30 
31 #ifndef SCHED_IDLE
32 #define SCHED_IDLE SCHED_OTHER // non-linux systems
33 #endif
34 
35 namespace gx_preset {
36 
37 /****************************************************************
38  ** class PresetIO
39  */
40 
43  gx_engine::ParamMap& param_,
45  UnitRacks& rack_units_)
46  : gx_system::AbstractPresetIO(),
47  mctrl(mctrl_),
48  convolver(cvr_),
49  param(param_),
50  opt(opt_),
51  plist(),
52  m(0),
53  rack_units(rack_units_) {
54 }
55 
57  clear();
58 }
59 
60 void PresetIO::clear() {
61  plist.clear();
62  delete m;
63  m = 0;
64 }
65 
66 bool PresetIO::midi_in_preset() {
67  const char *i = "system.midi_in_preset";
68  if (param.hasId(i)) {
69  return param[i].getBool().get_value();
70  } else {
71  return false;
72  }
73 }
74 
76  clear();
77  for (gx_engine::ParamMap::iterator i = param.begin(); i != param.end(); ++i) {
78  if (i->second->isInPreset() && i->second->isSavable()) {
79  i->second->stdJSON_value();
80  plist.push_back(i->second);
81  }
82  }
83  read_intern(jp, 0, head);
84 }
85 
86 void PresetIO::fixup_parameters(const gx_system::SettingsFileHeader& head) {
87  assert(param.hasId("jconv.wet_dry"));
88  if (head.is_current()) {
89  return;
90  }
91  if (head.get_major() == 1 && head.get_minor() < 2) {
92  if (param.hasId("jconv.wet_dry")) {
93  gx_engine::Parameter& p = param["jconv.wet_dry"];
94  if (p.isFloat()) {
95  p.getFloat().convert_from_range(-1, 1);
96  }
97  }
98  }
99 }
100 
101 static std::string replaced_id(const std::string& s) {
102  const char *old_new[][2] = {
103  { "beat_detector.stepper", "midi_out.beat_detector.stepper" },
104  { "beat_detector.note_off", "midi_out.beat_detector.note_off" },
105  { "beat_detector.atack_gain", "midi_out.beat_detector.atack_gain" },
106  { "beat_detector.beat_gain", "midi_out.beat_detector.beat_gain" },
107  { "beat_detector.midi_gain", "midi_out.beat_detector.midi_gain" },
108  // begin ui.*
109  // ui.<name> -> ui.<id> (rack unit visible)
110  { "ui.3 Band EQ", "ui.tonemodul" },
111  { "ui.BiQuad Filter", "ui.biquad" },
112  { "ui.Cabinet", "ui.cab" },
113  { "ui.Preamp", "ui.pre" },
114  { "ui.Chorus", "ui.chorus" },
115  { "ui.Chorus Mono", "ui.chorus_mono" },
116  { "ui.Compressor", "ui.compressor" },
117  { "ui.Convolver", "ui.jconv" },
118  { "ui.Crybaby", "ui.crybaby" },
119  { "ui.Delay", "ui.delay" },
120  { "ui.Echo", "ui.echo" },
121  { "ui.Feedback", "ui.feedback" },
122  { "ui.Flanger", "ui.flanger" },
123  { "ui.Flanger Mono", "ui.flanger_mono" },
124  { "ui.Freeverb", "ui.freeverb" },
125  { "ui.ImpulseResponse", "ui.IR" },
126  { "ui.Midi Out", "ui.midi_out" },
127  { "ui.Moog Filter", "ui.moog" },
128  { "ui.Multi Band Distortion", "ui.gx_distortion" },
129  { "ui.Oscilloscope", "ui.oscilloscope" },
130  { "ui.Overdrive", "ui.overdrive" },
131  { "ui.Phaser", "ui.phaser" },
132  { "ui.Phaser Mono", "ui.phaser_mono" },
133  { "ui.Postamp", "ui.ampmodul" },
134  { "ui.Scaleable EQ", "ui.eqs" },
135  { "ui.Stereo Delay", "ui.stereodelay" },
136  { "ui.Stereo Echo", "ui.stereoecho" },
137  { "ui.Stereo Verb", "ui.stereoverb" },
138  { "ui.Tonestack", "ui.amp.tonestack" },
139  { "ui.Tremolo", "ui.tremolo" },
140  { "ui.Vibe", "ui.univibe" },
141  { "ui.Vibe Mono", "ui.univibe_mono" },
142  { "ui.Zita Rev1", "ui.zita_rev1" },
143  { "ui.abGate", "ui.abgate" },
144  { "ui.low high pass", "ui.low_highpass" },
145  { "Rev.Rocket.s_h", "rev_rocket.s_h"},
146  { "Rev.Rocket.position", "rev_rocket.position"},
147  { "Rev.Rocket.pp", "rev_rocket.pp"},
148  { "ui.Rev.Rocket", "ui.rev_rocket"},
149  {0}
150  };
151  for (const char *(*p)[2] = old_new; (*p)[0]; ++p) {
152  if (s == (*p)[0]) {
153  return (*p)[1];
154  }
155  }
156  return "";
157 }
158 
159 class UnitPositionID: public UnitPosition {
160 public:
161  std::string id;
162  int weight;
163  UnitPositionID(const string& id_, const UnitPosition& u);
164  bool operator<(const UnitPositionID& v) const { return weight < v.weight; }
165 };
166 
167 UnitPositionID::UnitPositionID(const string& id_, const UnitPosition& u)
168  : UnitPosition(u),
169  id(id_),
170  weight(position - 1000 * pp) {
171 }
172 
173 void UnitsCollector::get_list(std::vector<std::string>& l, bool stereo, gx_engine::ParamMap& param) {
174  std::vector<UnitPositionID> v;
175  for (std::map<std::string,UnitPosition>::iterator i = m.begin(); i != m.end(); ++i) {
176  if (i->first == "jconv" && i->second.position < 0) {
177  i->second.position = 99; // very old presets
179  jp.get_ostream() << i->second.position;
180  jp.start_parser();
181  param[i->first+".position"].readJSON_value(jp);
182  }
183  if (i->first == "cab") {
184  if (i->second.position < 0) {
185  i->second.position = 98; // very old presets
187  jp.get_ostream() << i->second.position;
188  jp.start_parser();
189  param[i->first+".position"].readJSON_value(jp);
190  }
191  if (i->second.pp < 0) {
192  i->second.pp = 0;
194  jp.get_ostream() << i->second.pp;
195  jp.start_parser();
196  param[i->first+".pp"].readJSON_value(jp);
197  }
198  }
199  if (i->second.position >= 0 && i->second.show) {
200  if ((stereo && i->second.pp < 0) || (!stereo && i->second.pp >= 0)) {
201  if (!i->second.visible) { // make sure ui.XX is set for old presets
202  i->second.visible = true;
204  jp.put('1');
205  jp.start_parser();
206  param["ui."+i->first].readJSON_value(jp);
207  }
208  v.push_back(UnitPositionID(i->first, i->second));
209  }
210  }
211  }
212  l.clear();
213  std::sort(v.begin(), v.end());
214  int pp = 1;
215  for (std::vector<UnitPositionID>::iterator j = v.begin(); j != v.end(); ++j) {
216  if (!stereo && j->pp != pp) {
217  pp = j->pp;
218  l.push_back("ampstack");
219  }
220  l.push_back(j->id);
221  }
222  if (!stereo && pp) {
223  l.push_back("ampstack");
224  }
225  /*
226  cerr << "SL";
227  for (std::vector<std::string>::iterator ii = l.begin(); ii != l.end(); ++ii) {
228  cerr << " '" << *ii << "'";
229  }
230  cerr << endl;
231  */
232 }
233 
234 bool PresetIO::convert_old(gx_system::JsonParser &jp) {
235  const std::string& s = jp.current_value();
236  if (s == "system.mainwin_x") {
238  opt.mainwin_x = jp.current_value_int();
239  return true;
240  }
241  if (s == "system.mainwin_y") {
243  opt.mainwin_y = jp.current_value_int();
244  return true;
245  }
246  if (s == "system.mainwin_height") {
249  return true;
250  }
251  if (s == "system.mainwin_rack_height") {
253  opt.window_height = jp.current_value_int();
254  return true;
255  }
256  if (s == "system.preset_window_height") {
259  return true;
260  }
261  if (s == "oscilloscope.bufferset") {
263  opt.mul_buffer = jp.current_value_int();
264  return true;
265  }
266  if (s == "ui.skin_name") {
268  opt.skin_name = jp.current_value();
269  return true;
270  }
271  if (s == "ui.latency_nowarn") {
274  return true;
275  }
276  if (s == "system.order_rack_h") {
279  return true;
280  }
281  if (s == "system.show_value") {
284  return true;
285  }
286  if (s == "system.show_tooltips") {
289  return true;
290  }
291  if (s == "system.animations") {
294  return true;
295  }
296  if (s == "system.show_presets") {
299  return true;
300  }
301  if (s == "system.show_toolbar") {
304  return true;
305  }
306  if (s == "system.show_rack") {
309  return true;
310  }
311 
312  return false;
313 }
314 
315 static inline bool endswith(const std::string& s, int n, const char *t) {
316  return s.compare(std::max<int>(0, s.size()-n), n, t) == 0;
317 }
318 
319 static inline bool startswith(const std::string& s, int n, const char *t) {
320  return s.compare(0, n, t) == 0;
321 }
322 
323 void PresetIO::collectRackOrder(gx_engine::Parameter *p, gx_system::JsonParser &jp, UnitsCollector& u) {
324  const std::string& s = p->id();
325  if (startswith(s, 3, "ui.")) {
326  if (jp.current_value_int()) {
327  std::string ss = s.substr(3);
328  u.set_visible(ss, true);
329  u.set_show(ss, true);
330  }
331  } else if (endswith(s, 7, ".on_off")) {
332  if (jp.current_value_int()) {
333  u.set_show(s.substr(0, s.size()-7), true);
334  }
335  } else if (endswith(s, 9, ".position")) {
336  u.set_position(s.substr(0, s.size()-9), jp.current_value_int());
337  } else if (endswith(s, 3, ".pp")) {
338  u.set_pp(s.substr(0, s.size()-3), (jp.current_value() == "pre" ? 1 : 0));
339  }
340 }
341 
342 void PresetIO::read_parameters(gx_system::JsonParser &jp, bool preset) {
343  UnitsCollector u;
345  do {
348  if (!param.hasId(jp.current_value())) {
349  if (convert_old(jp)) {
350  continue;
351  }
352  std::string s = replaced_id(jp.current_value());
353  if (s.empty()) {
355  _("recall settings"),
356  _("unknown parameter: ")+jp.current_value());
357  jp.skip_object();
358  continue;
359  }
360  p = &param[s];
361  } else {
362  p = &param[jp.current_value()];
363  }
364  if (!preset and p->isInPreset()) {
366  _("recall settings"),
367  _("preset-parameter ")+p->id()+_(" in settings"));
368  jp.skip_object();
369  continue;
370  } else if (preset and !p->isInPreset()) {
372  _("recall settings"),
373  _("non preset-parameter ")+p->id()+_(" in preset"));
374  jp.skip_object();
375  continue;
376  } else if (!p->isSavable()) {
378  _("recall settings"),
379  _("non saveable parameter ")+p->id()+_(" in settings"));
380  jp.skip_object();
381  continue;
382  }
383  if (p->id() == "amp2.stage1.Pregain" || p->id() == "gxdistortion.drive") {
385  pf.rampJSON_value(jp);
386  } else {
387  p->readJSON_value(jp);
388  }
389  collectRackOrder(p, jp, u);
390  } while (jp.peek() == gx_system::JsonParser::value_key);
392  u.get_list(rack_units.mono, false, param);
393  u.get_list(rack_units.stereo, true, param);
394 }
395 
396 void PresetIO::write_parameters(gx_system::JsonWriter &w, bool preset) {
397  w.begin_object(true);
398 #if 0
399  int n = 0;
400  int pp = 1;
401  for (std::vector<std::string>::iterator j = mono_rack_units.begin(); j != mono_rack_units.end(); ++j) {
402  if (*j == "ampstack") {
403  n = 1;
404  pp = 0;
405  }
406  w.write_key("ui."+*j);
407  w.write(1);
408  w.write_key(*j+".pp");
409  w.write(pp);
410  w.write_key(*j+".position");
411  w.write(n);
412  n++;
413  }
414 #endif
415  for (gx_engine::ParamMap::iterator i = param.begin();
416  i != param.end(); ++i) {
417  gx_engine::Parameter *param = i->second;
418  if (!param->isSavable()) {
419  continue;
420  }
421  if ((preset and param->isInPreset()) or(!preset and !param->isInPreset())) {
422  param->writeJSON(w);
423  w.newline();
424  }
425  }
426  w.end_object(true);
427 }
428 
429 
431  std::string NAME_;
432  std::string FILE_;
433  std::string INFO_;
434  std::string AUTHOR_;
435  ifstream is(opt.get_online_config_filename().c_str());
436  ofstream os(opt.get_online_presets_filename().c_str());
437  if (!is.fail() && !os.fail()) {
438  gx_system::JsonParser jp(&is);
439  try {
441  do {
443  do {
445  if (jp.current_value() == "name") {
446  jp.read_kv("name", NAME_);
447  } else if (jp.current_value() == "description") {
448  jp.read_kv("description", INFO_);
449  } else if (jp.current_value() == "author") {
450  jp.read_kv("author", AUTHOR_);
451  } else if (jp.current_value() == "file") {
452  jp.read_kv("file", FILE_);
453  INFO_ += "Author : " + AUTHOR_;
454  // olp.push_back(std::tuple<std::string,std::string,std::string>(NAME_,FILE_,INFO_));
455  os << "\n<<NAME>> \n" << NAME_ << "\n<<FILE>> \n" << FILE_ << "\n<<INFO>> \n" << INFO_ << "\n<<END>> \n" << "\n";
456  } else {
457  //gx_print_warning("read_online", "unknown key: " + jp.current_value());
458  jp.skip_object();
459  }
460  } while (jp.peek() == gx_system::JsonParser::value_key);
462  } while (jp.peek() == gx_system::JsonParser::begin_object);
463  } catch (gx_system::JsonException& e) {
464  cerr << "JsonException: " << e.what() << ": '" << jp.current_value() << "'" << endl;
465  assert(false);
466  }
467  is.close();
468  os.close();
469  } else {
470  gx_print_warning(_("load online"),_("fail to open: "));
471  }
472 }
473 
474 void PresetIO::read_intern(gx_system::JsonParser &jp, bool *has_midi, const gx_system::SettingsFileHeader& head) {
475  bool use_midi = (has_midi != 0) || midi_in_preset();
476  if (has_midi) {
477  *has_midi = false;
478  }
480  do {
482  if (jp.current_value() == "engine") {
483  read_parameters(jp, true);
484  } else if (jp.current_value() == "jconv") { // for backwards compatibility
485  dynamic_cast<gx_engine::JConvParameter*>(&param["jconv.convolver"])->readJSON_value(jp);
486  } else if (jp.current_value() == "seq") {
487  dynamic_cast<gx_engine::SeqParameter*>(&param["seq.sequencer"])->readJSON_value(jp);
488  //fprintf(stderr,"seq.sequencer found\n");
489  } else if (jp.current_value() == "midi_controller") {
490  if (use_midi) {
491  m = new gx_engine::ControllerArray();
492  m->readJSON(jp, param);
493  if (has_midi) {
494  *has_midi = true;
495  }
496  } else {
497  jp.skip_object();
498  }
499  } else {
501  _("recall settings"),
502  _("unknown preset section: ") + jp.current_value());
503  jp.skip_object();
504  }
505  } while (jp.peek() == gx_system::JsonParser::value_key);
507  fixup_parameters(head);
508 }
509 
511  for (gx_engine::paramlist::iterator i = plist.begin(); i != plist.end(); ++i) {
512  (*i)->setJSON_value();
513  }
514  if (m) {
515  mctrl.set_controller_array(*m);
516  }
517  clear();
518  mctrl.update_from_controllers();
519 }
520 
521 void PresetIO::write_intern(gx_system::JsonWriter &w, bool write_midi) {
522  w.begin_object(true);
523  w.write_key("engine");
524  write_parameters(w, true);
525  if (write_midi) {
526  w.write_key("midi_controller");
527  mctrl.writeJSON(w);
528  }
529  w.newline();
530  w.end_object(true);
531 }
532 
534  write_intern(jw, midi_in_preset());
535 }
536 
538  gx_system::JsonWriter &jw) {
539  param.set_init_values();
540  bool has_midi;
541  clear();
542  read_intern(jp, &has_midi, head);
543  commit_preset();
544  write_intern(jw, has_midi);
545 }
546 
547 
548 /****************************************************************
549  ** class StateIO
550  */
551 
554  gx_jack::GxJack& jack_, gx_system::CmdlineOptions& opt_, UnitRacks& rack_units)
555  : PresetIO(mctrl, cvr, param, opt_, rack_units),
556  midi_std_control(mstdctr),
557  jack(jack_) {
558 }
559 
561 }
562 
564  clear();
565  for (gx_engine::ParamMap::iterator i = param.begin(); i != param.end(); ++i) {
566  if (i->second->isSavable()) {
567  i->second->stdJSON_value();
568  plist.push_back(i->second);
569  }
570  }
571  do {
573  if (jp.current_value() == "settings") {
574  read_parameters(jp, false);
575  } else if (jp.current_value() == "current_preset") {
576  read_intern(jp, 0, head);
577  } else if (jp.current_value() == "midi_controller") {
578  m = new gx_engine::ControllerArray();
579  m->readJSON(jp, param);
580  } else if (jp.current_value() == "midi_ctrl_names") {
581  midi_std_control.readJSON(jp);
582  } else if (jp.current_value() == "jack_connections") {
583  jack.read_connections(jp);
584  } else {
586  _("recall settings"),
587  _("unknown section: ") + jp.current_value());
588  jp.skip_object();
589  }
590  } while (jp.peek() == gx_system::JsonParser::value_string);
591 }
592 
593 void StateIO::commit_state() {
594  commit_preset();
595 }
596 
597 void StateIO::write_state(gx_system::JsonWriter &jw, bool no_preset) {
598  jw.write("settings");
599  write_parameters(jw, false);
600 
601  jw.write("midi_controller");
602  mctrl.writeJSON(jw);
603 
604  jw.write("midi_ctrl_names");
605  midi_std_control.writeJSON(jw);
606 
607  if (!no_preset) {
608  jw.write("current_preset");
609  write_intern(jw, false);
610  }
611 
612  jw.write("jack_connections");
613  jack.write_connections(jw);
614 
615  jw.newline();
616 }
617 
618 
619 /****************************************************************
620  ** class PluginPresetList
621  */
622 
623 PluginPresetList::PluginPresetList(const std::string& fname, gx_engine::ParamMap& pmap_,
625  : filename(fname), pmap(pmap_), mctrl(mctrl_), is(), jp(&is) {
626 }
627 
629  is.close();
630  is.open(filename.c_str());
631  jp.set_streampos(0);
632  if (is.fail()) {
633  return false;
634  }
635  try {
638  if (jp.current_value() != "gx_plugin_version") {
639  throw gx_system::JsonException("invalid gx_plugin file header");
640  }
642  } catch (gx_system::JsonException& e) {
643  gx_print_error(filename.c_str(), _("parse error"));
644  return false;
645  }
646  return true;
647 }
648 
649 bool PluginPresetList::next(Glib::ustring& name, bool *is_set) {
650  try {
652  name = "";
653  if (is_set) {
654  *is_set = false;
655  }
656  return false;
657  }
659  name = jp.current_value();
660  if (is_set) {
662  *is_set = true;
663  while (jp.peek() != gx_system::JsonParser::end_object) {
665  if (!pmap.hasId(jp.current_value())) {
667  _("recall plugin settings"),
668  _("unknown parameter: ")+jp.current_value());
669  jp.skip_object();
670  continue;
671  }
672  gx_engine::Parameter& p = pmap[jp.current_value()];
673  p.readJSON_value(jp);
674  if (!p.compareJSON_value()) {
675  *is_set = false;
676  }
677  }
679  } else {
680  jp.skip_object();
681  }
682  } catch (gx_system::JsonException& e) {
683  gx_print_error(filename.c_str(), _("parse error"));
684  return false;
685  }
686  return true;
687 }
688 
689 bool PluginPresetList::set(const Glib::ustring& name) {
690  gx_engine::paramlist plist;
691  if (!start()) {
692  return false;
693  }
694  bool ret = false;
695  try {
696  while (jp.peek() != gx_system::JsonParser::end_array) {
698  if (jp.current_value() != name) {
699  jp.skip_object();
700  } else {
701  ret = true;
703  while (jp.peek() != gx_system::JsonParser::end_object) {
705  if (pmap.hasId(jp.current_value())) {
706  gx_engine::Parameter& p = pmap[jp.current_value()];
707  p.readJSON_value(jp);
708  plist.push_back(&p);
709  }
710  }
712  }
713  }
716  } catch (gx_system::JsonException& e) {
717  gx_print_error(filename.c_str(), _("parse error"));
718  return false;
719  }
720  mctrl.remove_controlled_parameters(plist, 0);
721  for (gx_engine::paramlist::iterator i = plist.begin(); i != plist.end(); ++i) {
722  (*i)->setJSON_value();
723  }
724  return ret;
725 }
726 
727 static const int GX_PLUGIN_VERSION = 1;
728 
729 static inline bool compare_groups(const std::string& id, const char **groups) { //FIXME (is copy from gx_paramtable.cpp
730  if (!groups) {
731  return false;
732  }
733  for (const char **g = groups; *g; g += 2) {
734  const char *p = *g;
735  if ((*p) != '.') {
736  continue;
737  }
738  p++;
739  int n = strlen(p);
740  if (strncmp(id.c_str(), p, n) == 0 && id[n] == '.') {
741  return true;
742  }
743  }
744  return false;
745 }
746 
747 void PluginPresetList::write_values(gx_system::JsonWriter& jw, std::string id, const char **groups) {
748  id += ".";
749  string on_off = id + "on_off";
750  string pp = id + "pp";
751  std::string position = id + "position";
752  jw.begin_object(true);
753  for (gx_engine::ParamMap::iterator i = pmap.begin(); i != pmap.end(); ++i) {
754  if (i->first.compare(0, id.size(), id) == 0 || compare_groups(i->first, groups)) {
755  if (i->second->isInPreset() && i->second->isSavable()) {
756  if (i->first != on_off && i->first != pp && i->first != position) {
757  i->second->writeJSON(jw);
758  jw.newline();
759  }
760  }
761  }
762  }
763  jw.end_object(true);
764 }
765 
766 void PluginPresetList::save(const Glib::ustring& name, const std::string& id, const char **groups) {
767  try {
768  std::string tmpfile(filename + "_tmp");
769  ofstream os(tmpfile.c_str());
770  gx_system::JsonWriter jw(&os);
771  jw.begin_array();
772  jw.write("gx_plugin_version");
773  jw.write(GX_PLUGIN_VERSION, true);
774  bool found = false;
775  if (start()) {
776  while (jp.peek() != gx_system::JsonParser::end_array) {
778  jw.write(jp.current_value());
779  if (jp.current_value() == name) {
780  found = true;
781  write_values(jw, id, groups);
782  jp.skip_object();
783  } else {
784  jp.copy_object(jw);
785  }
786  }
787  }
788  if (!found) {
789  jw.write(name);
790  write_values(jw, id, groups);
791  }
792  jw.end_array(true);
793  jw.close();
794  os.close();
795  if (!os.good()) {
796  gx_print_error(_("save plugin preset"),
797  boost::format(_("couldn't write %1%")) % tmpfile);
798  return;
799  }
800  int rc = rename(tmpfile.c_str(), filename.c_str());
801  if (rc != 0) {
802  gx_print_error(_("save plugin preset"),
803  boost::format(_("couldn't rename %1% to %2%"))
804  % tmpfile % filename);
805  }
806  } catch (gx_system::JsonException& e) {
807  gx_print_error(filename.c_str(), _("parse error"));
808  }
809 }
810 
811 bool PluginPresetList::remove(const Glib::ustring& name) {
812  bool ret = false;
813  if (start()) {
814  try {
815  std::string tmpfile(filename + "_tmp");
816  ofstream os(tmpfile.c_str());
817  gx_system::JsonWriter jw(&os);
818  jw.begin_array();
819  jw.write("gx_plugin_version");
820  jw.write(GX_PLUGIN_VERSION, true);
821  while (jp.peek() != gx_system::JsonParser::end_array) {
823  if (jp.current_value() == name) {
824  jp.skip_object();
825  ret = true;
826  } else {
827  jw.write(jp.current_value());
828  jp.copy_object(jw);
829  }
830  }
833  jw.end_array(true);
834  jw.close();
835  os.close();
836  if (!os.good()) {
837  gx_print_error(_("remove plugin preset"),
838  boost::format(_("couldn't write %1%")) % tmpfile);
839  return false;
840  }
841  int rc = rename(tmpfile.c_str(), filename.c_str());
842  if (rc != 0) {
843  gx_print_error(_("remove plugin preset"),
844  boost::format(_("couldn't rename %1% to %2%"))
845  % tmpfile % filename);
846  return false;
847  }
848  } catch (gx_system::JsonException& e) {
849  gx_print_error(filename.c_str(), _("parse error"));
850  }
851  return ret;
852  } else {
853  return false;
854  }
855 }
856 
857 
858 /****************************************************************
859  ** GxSettings
860  */
861 
862 static const char *scratchpad_name = N_("Scratchpad");
863 static const char *scratchpad_file = "scratchpad.gx";
864 static const char *statename_postfix = "_rc";
865 static const char *bank_list = "banklist.js";
866 
870  : sigc::trackable(),
871  GxSettingsBase(seq_),
872  param(seq_.get_param()),
873  preset_io(mctrl_, cvr, param, opt, rack_units),
874  state_io(mctrl_, cvr, param, mstdctr, jack_, opt, rack_units),
875  state_loaded(false),
876  no_autosave(false),
877  jack(jack_),
878  mctrl(mctrl_),
879  options(opt),
880  preset_parameter(*param.reg_string("system.current_preset", "?", &current_name, "")),
881  bank_parameter(*param.reg_string("system.current_bank", "?", &current_bank, "")),
882  sync_name(""),
883  set_preset(),
884  get_sequencer_p(),
885  sequencer_max(24),
886  sequencer_pos(0) {
887  set_io(&state_io, &preset_io);
888  statefile.set_filename(make_default_state_filename());
889  banks.parse(opt.get_preset_filepath(bank_list), opt.get_preset_dir(), opt.get_factory_dir(),
890  scratchpad_name, scratchpad_file);
891  instance = this;
892  GxExit::get_instance().signal_exit().connect(
893  sigc::mem_fun(*this, &GxSettings::exit_handler));
894  jack.signal_client_change().connect(
895  sigc::mem_fun(*this, &GxSettings::jack_client_changed));
896  set_preset.connect(sigc::mem_fun(*this, &GxSettings::preset_sync_set));
897  get_sequencer_p.connect(sigc::mem_fun(*this, &GxSettings::on_get_sequencer_pos));
898 }
899 
900 GxSettings *GxSettings::instance = 0;
901 
903  instance = 0;
904  auto_save_state();
905 }
906 
908  if (state_loaded) {
909  if (setting_is_preset()) {
912  !pf->get_flags()) {
913  save(*pf, current_name);
914  }
915  }
916  if (!no_autosave) {
917  save_to_state();
918  }
919  }
920 }
921 
922 void GxSettings::exit_handler(bool otherthread) {
923  if (otherthread) {
924  return;
925  }
926  auto_save_state();
927 }
928 
929 void GxSettings::jack_client_changed() {
930  string fn = make_state_filename();
931  if (state_loaded && fn == statefile.get_filename()) {
933  return;
934  }
935  if (!state_loaded && access(fn.c_str(), R_OK|W_OK) != 0) {
936  string defname = make_default_state_filename();
937  if (access(defname.c_str(), R_OK) == 0) {
938  statefile.set_filename(defname);
939  loadsetting(0, "");
940  }
941  }
943  loadstate();
944 }
945 
946 string GxSettings::make_default_state_filename() {
947  if (!options.get_loadfile().empty()) {
948  return options.get_loadfile();
949  }
950  std::string s = options.get_jack_instancename();
951  if (!s.empty()) {
952  s = options.get_user_filepath(s + statename_postfix);
953  if (access(s.c_str(), R_OK|W_OK) == 0) {
954  return s;
955  }
956  }
957  return options.get_user_filepath(
958  jack.get_default_instancename() + statename_postfix);
959 }
960 
961 string GxSettings::make_state_filename() {
962  if (!options.get_loadfile().empty()) {
963  return options.get_loadfile();
964  }
965  return options.get_user_filepath(
966  jack.get_instancename() + statename_postfix);
967 }
968 
969 bool GxSettings::check_create_config_dir(const Glib::ustring& dir) {
970  if (access((Glib::build_filename(dir, ".")).c_str(), R_OK|W_OK|X_OK) != 0) {
971  if (errno != ENOENT) {
972  throw GxFatalError(
973  boost::format(_("no read/write access in guitarix config dir '%1%'"))
974  % dir);
975  }
976  if (mkdir(dir.c_str(), 0777) != 0) {
977  throw GxFatalError(
978  boost::format(_("can't create guitarix config dir '%1%'"))
979  % dir);
980  }
981  return true;
982  }
983  return false;
984 }
985 
987  save(*banks.get_file(scratchpad_name), "livebuffer1");
988 }
989 
990 static inline std::vector<std::string>::iterator find_unit(std::vector<std::string>& r, const std::string& unit) {
991  std::vector<std::string>::iterator i = r.begin();
992  for (; i != r.end(); ++i) {
993  if (unit == *i) {
994  break;
995  }
996  }
997  return i;
998 }
999 
1000 bool GxSettings::remove_rack_unit(const std::string& unit, bool stereo) {
1001  std::vector<std::string>& r = stereo ? rack_units.stereo : rack_units.mono;
1002  std::vector<std::string>::iterator i = find_unit(r, unit);
1003  if (i != r.end()) {
1004  r.erase(i);
1005  return true;
1006  }
1007  return false;
1008 }
1009 
1010 void GxSettings::insert_rack_unit(const std::string& unit, const std::string& before, bool stereo) {
1011  std::vector<std::string>& r = stereo ? rack_units.stereo : rack_units.mono;
1012  remove_rack_unit(unit, stereo);
1013  if (before.empty()) {
1014  r.push_back(unit);
1015  } else {
1016  r.insert(find_unit(r, before), unit);
1017  }
1018 }
1019 
1020 Glib::RefPtr<Gio::File> GxSettings::uri_to_name_filename(const Glib::ustring& uri, Glib::ustring& name, std::string& filename) {
1021  Glib::RefPtr<Gio::File> rem = Gio::File::create_for_uri(uri);
1022  filename = rem->get_basename();
1023  banks.strip_preset_postfix(filename);
1024  name = gx_system::decode_filename(filename);
1025  banks.make_valid_utf8(name);
1026  banks.make_bank_unique(name, &filename);
1027  return rem;
1028 }
1029 
1030 gx_system::PresetFile* GxSettings::bank_insert_uri(const Glib::ustring& uri, bool move) {
1031  Glib::ustring name;
1032  std::string filename;
1033  Glib::RefPtr<Gio::File> rem = uri_to_name_filename(uri, name, filename);
1034  Glib::RefPtr<Gio::File> dest = Gio::File::create_for_path(filename);
1035  try {
1036  rem->copy(dest);
1037  } catch (Gio::Error& e) {
1038  gx_print_error(e.what().c_str(), _("can't copy to config dir"));
1039  return 0;
1040  }
1042  if (f->open_file(name, filename, gx_system::PresetFile::PRESET_FILE, 0)) {
1043  banks.insert(f);
1044  } else {
1045  delete f;
1046  try {
1047  dest->remove();
1048  } catch (Gio::Error& e) {
1049  gx_print_error(e.what().c_str(), _("can't remove copied file!?"));
1050  }
1051  return 0;
1052  }
1053  if (move) {
1054  try {
1055  rem->remove();
1056  } catch (Gio::Error& e) {
1057  gx_print_error(e.what().c_str(), _("can't move; file has been copied"));
1058  }
1059  }
1060  return f;
1061 }
1062 
1063 gx_system::PresetFile* GxSettings::bank_insert_content(const Glib::ustring& uri, const std::string content) {
1064  Glib::ustring name;
1065  std::string filename;
1066  uri_to_name_filename(uri, name, filename);
1067  Glib::RefPtr<Gio::File> dest = Gio::File::create_for_path(filename);
1068  try {
1069  Glib::RefPtr<Gio::FileOutputStream> s = dest->create_file();
1070  s->write(content);
1071  s->close();
1072  } catch (Gio::Error& e) {
1073  gx_print_error(e.what().c_str(), _("can't bank"));
1074  return 0;
1075  }
1077  if (f->open_file(name, filename, gx_system::PresetFile::PRESET_FILE, 0)) {
1078  banks.insert(f);
1079  } else {
1080  delete f;
1081  try {
1082  dest->remove();
1083  } catch (Gio::Error& e) {
1084  gx_print_error(e.what().c_str(), _("can't remove copied file!?"));
1085  }
1086  return 0;
1087  }
1088  return f;
1089 }
1090 
1091 gx_system::PresetFile *GxSettings::bank_insert_new(const Glib::ustring& name) {
1092  Glib::ustring newname = name;
1093  std::string newfile;
1094  banks.make_bank_unique(newname, &newfile);
1096  if (f->create_file(newname, newfile, gx_system::PresetFile::PRESET_FILE, 0)) {
1097  banks.insert(f);
1098  return f;
1099  } else {
1100  delete f;
1101  return 0;
1102  }
1103 }
1104 
1105 bool GxSettings::rename_bank(const Glib::ustring& oldname, Glib::ustring& newname) {
1106  std::string newfile;
1107  banks.make_bank_unique(newname, &newfile);
1108  return GxSettingsBase::rename_bank(oldname, newname, newfile);
1109 }
1110 
1111 //static
1112 bool GxSettings::check_settings_dir(gx_system::CmdlineOptions& opt, bool *need_new_preset) {
1113  bool copied_from_old = false;
1114  std::string oldpreset;
1115  *need_new_preset = false;
1116  if (check_create_config_dir(opt.get_user_dir())) {
1117  check_create_config_dir(opt.get_preset_dir());
1118  check_create_config_dir(opt.get_plugin_dir());
1119  check_create_config_dir(opt.get_pluginpreset_dir());
1120  check_create_config_dir(opt.get_lv2_preset_dir());
1121  check_create_config_dir(opt.get_loop_dir());
1122  check_create_config_dir(opt.get_user_IR_dir());
1123  check_create_config_dir(opt.get_temp_dir());
1124  std::string fname = gx_jack::GxJack::get_default_instancename() + statename_postfix;
1125  if (access(Glib::build_filename(opt.get_old_user_dir(), fname).c_str(), R_OK) == 0) {
1126  copied_from_old = true;
1127  Glib::RefPtr<Gio::File> f = Gio::File::create_for_path(
1128  Glib::build_filename(opt.get_old_user_dir(), fname));
1129  try {
1130  f->copy(Gio::File::create_for_path(opt.get_user_filepath(fname)));
1131  } catch (Gio::Error& e) {
1132  gx_print_error(e.what().c_str(), _("can't copy to new config dir"));
1133  }
1134  }
1135  fname = Glib::build_filename(
1136  opt.get_old_user_dir(),
1138  if (access(fname.c_str(), R_OK) == 0) {
1139  Glib::RefPtr<Gio::File> f = Gio::File::create_for_path(fname);
1140  oldpreset = opt.get_preset_filepath("oldpresets.gx");
1141  try {
1142  f->copy(Gio::File::create_for_path(oldpreset));
1143  } catch (Gio::Error& e) {
1144  gx_print_error(e.what().c_str(), _("can't copy to new config preset dir"));
1145  oldpreset = "";
1146  }
1147  }
1148  } else {
1149  check_create_config_dir(opt.get_preset_dir());
1150  check_create_config_dir(opt.get_plugin_dir());
1151  check_create_config_dir(opt.get_pluginpreset_dir());
1152  check_create_config_dir(opt.get_lv2_preset_dir());
1153  check_create_config_dir(opt.get_loop_dir());
1154  check_create_config_dir(opt.get_user_IR_dir());
1155  check_create_config_dir(opt.get_temp_dir());
1156  }
1157  std::string fname = opt.get_preset_filepath(scratchpad_file);
1158  if (access(fname.c_str(), R_OK) != 0) {
1160  throw GxFatalError(
1161  boost::format(_("can't create file in '%1%' !!??")) % opt.get_preset_dir());
1162  }
1163  *need_new_preset = true;
1164  }
1165  fname = opt.get_preset_filepath(bank_list);
1166  if (access(fname.c_str(), R_OK) != 0) {
1167  ofstream f(fname.c_str());
1168  if (!f.good()) {
1169  throw GxFatalError(
1170  boost::format(_("can't create '%1%' in directory '%2%'"))
1171  % bank_list % opt.get_preset_dir());
1172  }
1174  pre.open_file(scratchpad_name, opt.get_preset_filepath(scratchpad_file), gx_system::PresetFile::PRESET_SCRATCH, 0);
1175  gx_system::JsonWriter jw(&f);
1176  jw.begin_array(true);
1177  pre.writeJSON(jw);
1178  if (!oldpreset.empty() && pre.open_file("copied presets", oldpreset, gx_system::PresetFile::PRESET_FILE, 0)) {
1179  pre.writeJSON(jw);
1180  }
1181  jw.end_array(true);
1182  jw.close();
1183  f.close();
1184  }
1185  return copied_from_old;
1186 }
1187 
1188 void GxSettings::loadstate() {
1189  GxSettingsBase::loadstate();
1190 #if 0
1191  /* This following code is commented out because
1192  **
1193  ** o its debatable which of state file or scratch preset should have
1194  ** priority in case both differ because 2 different instantiations
1195  ** accessed the same scratch preset but different statefiles.
1196  **
1197  ** o if the scratch preset has priority, the autosave function would
1198  ** have to save to statefile *and* scratch preset (in case of the
1199  ** current preset being a scratch preset).
1200  **
1201  ** As an aside: load_preset() would have to be changed to not save
1202  ** to the scratch preset before loading in the case that this code
1203  ** is activated.
1204  */
1205  if (setting_is_preset()) {
1207  if (pf && pf->get_type() == gx_system::PresetFile::PRESET_SCRATCH) {
1208  /* make sure we see the content of the scratchpad,
1209  ** not the state file (in case someone changed the
1210  ** scratchpad while working with a different state file)
1211  */
1213  }
1214  }
1215 #endif
1216  state_loaded = true;
1217 }
1218 
1219 void GxSettings::add_plugin_preset_list(gx_preset::PluginPresetList& l,
1220  UnitPresetList &presetnames) {
1221  if (l.start()) {
1222  Glib::ustring name;
1223  bool is_set;
1224  while (l.next(name, &is_set)) {
1225  presetnames.push_back(PluginPresetEntry(name, is_set));
1226  }
1227  }
1228 }
1229 
1230 void GxSettings::plugin_preset_list_load(const PluginDef *pdef, UnitPresetList &presetnames) {
1231  PluginPresetList lv2sets(options.get_lv2_preset_filepath(pdef->id), param, mctrl);
1232  add_plugin_preset_list(lv2sets, presetnames);
1233  PluginPresetList user(options.get_pluginpreset_filepath(pdef->id, false), param, mctrl);
1234  add_plugin_preset_list(user, presetnames);
1235  presetnames.push_back(PluginPresetEntry("", false));
1236  PluginPresetList factory(options.get_pluginpreset_filepath(pdef->id, true), param, mctrl);
1237  add_plugin_preset_list(factory, presetnames);
1238 }
1239 
1240 void GxSettings::preset_sync_set() {
1241  PluginPresetList(options.get_pluginpreset_filepath("seq", false), param, mctrl).set(sync_name);
1242 }
1243 
1244 void GxSettings::on_get_sequencer_pos() {
1245  gx_system::atomic_set(&sequencer_pos,(int)param["seq.step"].getFloat().get_value());
1246 }
1247 
1248 void *GxSettings::sync_run() {
1249  while (true) {
1250  get_sequencer_p();
1251  usleep(50000);
1252  if (gx_system::atomic_get(sequencer_pos) == 0) {
1253  set_preset();
1254  break;
1255  }
1256  }
1257  return NULL;
1258 }
1259 
1260 void *GxSettings::preset_sync_run(void *p) {
1261  struct sched_param spar;
1262  spar.sched_priority = 0;
1263  pthread_setschedparam(pthread_self(), SCHED_IDLE, &spar);
1264  (reinterpret_cast< GxSettings*>(p))->sync_run();
1265  pthread_exit(NULL);
1266  return NULL;
1267 }
1268 
1269 void GxSettings::plugin_preset_list_sync_set(const PluginDef *pdef, bool factory, const Glib::ustring& name) {
1270  if(strcmp(pdef->id,"seq")==0) {
1271  sync_name = name;
1272  pthread_t pthr;
1273  gx_system::atomic_set(&sequencer_max,(int)param["seq.asequences"].getFloat().get_value()-1);
1274  if (pthread_create(&pthr, NULL, preset_sync_run, reinterpret_cast<void*>(this))) {
1275  gx_print_error("GxSettings sync", _("can't create thread"));
1276  }
1277  }
1278 }
1279 
1280 void GxSettings::plugin_preset_list_set(const PluginDef *pdef, bool factory, const Glib::ustring& name) {
1281  if (!PluginPresetList(options.get_pluginpreset_filepath(pdef->id, factory), param, mctrl).set(name))
1282  PluginPresetList(options.get_lv2_preset_filepath(pdef->id), param, mctrl).set(name);
1283 }
1284 
1285 void GxSettings::plugin_preset_list_save(const PluginDef *pdef, const Glib::ustring& name) {
1286  PluginPresetList(options.get_pluginpreset_filepath(pdef->id, false), param, mctrl).save(name, pdef->id, pdef->groups);
1287 }
1288 
1289 void GxSettings::plugin_preset_list_remove(const PluginDef *pdef, const Glib::ustring& name) {
1290  // remove loop files when delete a plugin preset
1291  if(strcmp(pdef->id,"dubber")==0) {
1292  std::string pPath = options.get_loop_dir();
1293  pPath += name;
1294  std::remove((pPath + "1.wav").c_str());
1295  std::remove((pPath + "2.wav").c_str());
1296  std::remove((pPath + "3.wav").c_str());
1297  std::remove((pPath + "4.wav").c_str());
1298  }
1299  if (!PluginPresetList(options.get_pluginpreset_filepath(pdef->id, false), param, mctrl).remove(name))
1300  PluginPresetList(options.get_lv2_preset_filepath(pdef->id), param, mctrl).remove(name);
1301 }
1302 
1303 
1304 /* ----------------------------------------------------------------*/
1305 } /* end of gx_preset namespace */
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
GxExit::get_instance
static GxExit & get_instance()
Definition: gx_logging.cpp:203
gx_system::JsonParser::copy_object
void copy_object(JsonWriter &jw)
Definition: gx_json.cpp:577
gx_engine::ParameterV< float >::convert_from_range
void convert_from_range(float low, float up)
Definition: gx_paramtable.cpp:1267
gx_system::JsonParser::value_key
Definition: gx_json.h:129
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_preset::PluginPresetList::remove
bool remove(const Glib::ustring &name)
Definition: gx_preset.cpp:808
gx_system::BasicOptions::get_user_filepath
std::string get_user_filepath(const std::string &basename) const
Definition: gx_system.h:367
gx_system::GxSettingsBase::save
void save(PresetFile &pf, const Glib::ustring &name)
Definition: gx_json.cpp:1883
gx_preset::GxSettings::uri_to_name_filename
Glib::RefPtr< Gio::File > uri_to_name_filename(const Glib::ustring &uri, Glib::ustring &name, std::string &filename)
Definition: gx_preset.cpp:1016
gx_preset::GxSettings::auto_save_state
void auto_save_state()
Definition: gx_preset.cpp:903
gx_system::JsonParser::end_token
Definition: gx_json.h:122
gx_engine::ControllerArray::readJSON
void readJSON(gx_system::JsonParser &jp, ParamMap &param)
Definition: gx_paramtable.cpp:371
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_system::JsonStringParser
Definition: gx_json.h:201
gx_system::JsonWriter::begin_object
void begin_object(bool nl=false)
Definition: gx_json.cpp:167
gx_system::JsonParser::value_string
Definition: gx_json.h:127
gx_system::CmdlineOptions::get_pluginpreset_dir
const std::string & get_pluginpreset_dir() const
Definition: gx_system.h:472
gx_preset::UnitPositionID::id
std::string id
Definition: gx_preset.cpp:160
gx_system::atomic_set
void atomic_set(volatile int *p, int v)
Definition: gx_system.h:89
gx_system::JsonStringParser::start_parser
void start_parser()
Definition: gx_json.h:208
gx_system::SettingsFileHeader::is_current
bool is_current() const
Definition: gx_json.h:247
gx_preset::UnitRacks::stereo
std::vector< std::string > stereo
Definition: gx_preset.h:39
gx_preset::StateIO::read_state
void read_state(gx_system::JsonParser &jp, const gx_system::SettingsFileHeader &)
Definition: gx_preset.cpp:561
gx_engine::Parameter::isInPreset
bool isInPreset() const
Definition: gx_parameter.h:168
gx_system::PresetBanks::parse
void parse(const std::string &bank_path, const std::string &preset_dir, const std::string &factory_path, const char *scratchpad_name, const char *scratchpad_file)
Definition: gx_json.cpp:1417
gx_system::GxSettingsBase::set_io
void set_io(AbstractStateIO *st, AbstractPresetIO *pr)
Definition: gx_json.h:472
gx_preset::PresetIO::copy_preset
void copy_preset(gx_system::JsonParser &jp, const gx_system::SettingsFileHeader &, gx_system::JsonWriter &jw)
Definition: gx_preset.cpp:536
gx_jack::GxJack::write_connections
void write_connections(gx_system::JsonWriter &w)
Definition: gx_jack.cpp:215
GxExit::signal_exit
sigc::signal< void, bool > & signal_exit()
Definition: gx_logging.h:115
gx_system::CmdlineOptions::system_show_toolbar
bool system_show_toolbar
Definition: gx_system.h:450
gx_engine::ParameterV< float >::rampJSON_value
virtual void rampJSON_value(gx_system::JsonParser &jp)
Definition: gx_paramtable.cpp:1243
gx_system::GxSettingsBase::selection_changed
sigc::signal< void > selection_changed
Definition: gx_json.h:467
gx_preset::PluginPresetList::next
bool next(Glib::ustring &name, bool *is_set=0)
Definition: gx_preset.cpp:646
gx_preset::GxSettings::GxSettings
GxSettings(gx_system::CmdlineOptions &opt, gx_jack::GxJack &jack, gx_engine::ConvolverAdapter &cvr, gx_engine::MidiStandardControllers &mstdctr, gx_engine::MidiControllerList &mctrl, gx_engine::ModuleSequencer &seq)
Definition: gx_preset.cpp:863
gx_preset::PresetIO::commit_preset
void commit_preset()
Definition: gx_preset.cpp:509
gx_system::JsonParser::current_value
string current_value() const
Definition: gx_json.h:142
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_preset::GxSettings::~GxSettings
~GxSettings()
Definition: gx_preset.cpp:898
gx_system::CmdlineOptions::system_show_rack
bool system_show_rack
Definition: gx_system.h:451
gx_system::CmdlineOptions::get_lv2_preset_filepath
std::string get_lv2_preset_filepath(const std::string &id) const
Definition: gx_system.h:467
gx_preset::GxSettings::plugin_preset_list_load
void plugin_preset_list_load(const PluginDef *pdef, UnitPresetList &presetnames)
Definition: gx_preset.cpp:1226
gx_system::JsonWriter::write
void write(float v, bool nl=false)
Definition: gx_json.cpp:115
gx_system::StateFile::get_filename
string get_filename() const
Definition: gx_json.h:266
gx_preset::PluginPresetList
Definition: gx_preset.h:109
gx_preset::PluginPresetList::set
bool set(const Glib::ustring &name)
Definition: gx_preset.cpp:686
gx_preset::UnitPositionID
Definition: gx_preset.cpp:158
gx_preset::PresetIO::read_preset
void read_preset(gx_system::JsonParser &jp, const gx_system::SettingsFileHeader &)
Definition: gx_preset.cpp:74
gx_system::JsonException::what
virtual const char * what() const
Definition: gx_json.h:47
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_system::GxSettingsBase::banks
PresetBanks banks
Definition: gx_json.h:463
gx_print_warning
void gx_print_warning(const char *, const std::string &)
Definition: gx_logging.cpp:160
gx_preset::UnitPresetList
std::vector< PluginPresetEntry > UnitPresetList
Definition: gx_preset.h:134
gx_engine::MidiControllerList::writeJSON
void writeJSON(gx_system::JsonWriter &jw) const
Definition: gx_parameter.h:775
gx_system::PresetFile
Definition: gx_json.h:297
gx_engine::MidiControllerList::update_from_controllers
void update_from_controllers()
Definition: gx_paramtable.cpp:571
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_plugin_dir
const std::string & get_plugin_dir() const
Definition: gx_system.h:470
gx_system::BasicOptions::get_user_IR_dir
const std::string & get_user_IR_dir() const
Definition: gx_system.h:371
gx_system::SettingsFileHeader::make_empty_settingsfile
static bool make_empty_settingsfile(const string &name)
Definition: gx_json.cpp:680
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
gx_system::JsonStringParser::get_ostream
std::ostream & get_ostream()
Definition: gx_json.h:207
PluginDef
Definition: gx_plugin.h:183
gx_system::CmdlineOptions::mainwin_x
int mainwin_x
Definition: gx_system.h:437
gx_preset::GxSettings::bank_insert_uri
gx_system::PresetFile * bank_insert_uri(const Glib::ustring &uri, bool move)
Definition: gx_preset.cpp:1026
gx_system::JsonException
Definition: gx_json.h:39
gx_preset::GxSettings::bank_insert_new
gx_system::PresetFile * bank_insert_new(const Glib::ustring &name)
Definition: gx_preset.cpp:1087
gx_system::PresetBanks::insert
void insert(PresetFile *f)
Definition: gx_json.h:447
gx_preset::GxSettings::bank_insert_content
gx_system::PresetFile * bank_insert_content(const Glib::ustring &uri, const std::string content)
Definition: gx_preset.cpp:1059
gx_system::JsonWriter::end_object
void end_object(bool nl=false)
Definition: gx_json.cpp:175
gx_system::GxSettingsBase::statefile
StateFile statefile
Definition: gx_json.h:462
gx_system::CmdlineOptions::system_order_rack_h
bool system_order_rack_h
Definition: gx_system.h:445
gx_preset::UnitPositionID::operator<
bool operator<(const UnitPositionID &v) const
Definition: gx_preset.cpp:163
gx_preset::UnitsCollector::get_list
void get_list(std::vector< std::string > &l, bool stereo, gx_engine::ParamMap &param)
Definition: gx_preset.cpp:172
gx_system::JsonWriter::close
virtual void close()
Definition: gx_json.cpp:67
gx_system::decode_filename
std::string decode_filename(const std::string &s)
Definition: gx_system.cpp:1040
gx_system::PresetFile::get_flags
int get_flags() const
Definition: gx_json.h:356
gx_preset::GxSettings::check_settings_dir
static bool check_settings_dir(gx_system::CmdlineOptions &opt, bool *need_new_preset)
Definition: gx_preset.cpp:1108
gx_system::PresetBanks::make_valid_utf8
static void make_valid_utf8(Glib::ustring &s)
Definition: gx_json.cpp:1428
gx_system::CmdlineOptions::mainwin_y
int mainwin_y
Definition: gx_system.h:438
gx_preset::PluginPresetList::save
void save(const Glib::ustring &name, const std::string &id, const char **groups)
Definition: gx_preset.cpp:763
gx_engine::ParameterV< float >
Definition: gx_parameter.h:228
gx_preset::UnitPosition
Definition: gx_preset.h:43
gx_preset::PluginPresetList::start
bool start()
Definition: gx_preset.cpp:625
N_
#define N_(String)
Definition: gx_faust_support.h:23
gx_jack::GxJack
Definition: gx_jack.h:109
gx_system::SettingsFileHeader
Definition: gx_json.h:222
PluginDef::groups
const char ** groups
Definition: gx_plugin.h:189
gx_system::JsonParser::next
token next(token expect=no_token)
Definition: gx_json.cpp:493
gx_system::CmdlineOptions::no_warn_latency
bool no_warn_latency
Definition: gx_system.h:444
gx_preset::PresetIO::read_online
void read_online(gx_system::JsonParser &jp)
Definition: gx_preset.cpp:429
gx_preset::GxSettings::rename_bank
bool rename_bank(const Glib::ustring &oldname, Glib::ustring &newname)
Definition: gx_preset.cpp:1101
gx_system::GxSettingsBase::current_bank
Glib::ustring current_bank
Definition: gx_json.h:464
gx_engine::ParamMap::end
iterator end() const
Definition: gx_parameter.h:535
gx_engine::Parameter::getFloat
FloatParameter & getFloat()
Definition: gx_parameter.h:453
gx_jack::GxJack::signal_client_change
sigc::signal< void > & signal_client_change()
Definition: gx_jack.h:209
gx_system::CmdlineOptions::get_preset_dir
const std::string & get_preset_dir() const
Definition: gx_system.h:471
gx_engine::MidiControllerList
Definition: gx_parameter.h:731
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::CmdlineOptions::get_online_config_filename
std::string get_online_config_filename() const
Definition: gx_system.h:478
gx_system::PresetFile::PRESET_FILE
Definition: gx_json.h:299
gx_preset::StateIO::commit_state
void commit_state()
Definition: gx_preset.cpp:591
gx_system::PresetFile::open_file
bool open_file(const Glib::ustring &name, const std::string &path, int tp, int flags)
Definition: gx_json.cpp:974
gx_preset::PresetIO::PresetIO
PresetIO(gx_engine::MidiControllerList &mctrl, gx_engine::ConvolverAdapter &cvr, gx_engine::ParamMap &param, gx_system::CmdlineOptions &opt, UnitRacks &rack_units)
Definition: gx_preset.cpp:40
gx_jack::GxJack::read_connections
void read_connections(gx_system::JsonParser &jp)
Definition: gx_jack.cpp:155
gx_system::JsonStringParser::put
void put(char c)
Definition: gx_json.h:206
gx_system::BasicOptions::get_user_dir
const std::string & get_user_dir() const
Definition: gx_system.h:370
gx_system::JsonParser
Definition: gx_json.h:111
gx_system::CmdlineOptions::get_temp_dir
const std::string & get_temp_dir() const
Definition: gx_system.h:475
gx_preset::GxSettings::create_default_scratch_preset
void create_default_scratch_preset()
Definition: gx_preset.cpp:982
gx_engine::MidiStandardControllers
Definition: gx_parameter.h:643
gx_preset::StateIO::write_state
void write_state(gx_system::JsonWriter &jw, bool preserve_preset)
Definition: gx_preset.cpp:595
gx_print_error
void gx_print_error(const char *, const std::string &)
Definition: gx_logging.cpp:165
gx_system::JsonParser::begin_array
Definition: gx_json.h:125
gx_system::PresetBanks::make_bank_unique
void make_bank_unique(Glib::ustring &name, std::string *file=0)
Definition: gx_json.cpp:1451
gx_system::JsonParser::read_kv
bool read_kv(const char *key, float &v)
Definition: gx_json.cpp:508
gx_system::JsonWriter::begin_array
void begin_array(bool nl=false)
Definition: gx_json.cpp:183
gx_system::SettingsFileHeader::get_minor
int get_minor() const
Definition: gx_json.h:243
gx_preset::GxSettings
Definition: gx_preset.h:136
gx_engine::MidiStandardControllers::readJSON
void readJSON(gx_system::JsonParser &jp)
Definition: gx_paramtable.cpp:170
gx_preset::UnitRacks::mono
std::vector< std::string > mono
Definition: gx_preset.h:38
PluginDef::id
const char * id
Definition: gx_plugin.h:187
gx_system::PresetFile::get_type
int get_type() const
Definition: gx_json.h:359
gx_engine::ControllerArray
Definition: gx_parameter.h:720
gx_system::JsonParser::end_array
Definition: gx_json.h:126
gx_system::JsonParser::end_object
Definition: gx_json.h:124
gx_system::CmdlineOptions::get_factory_dir
const std::string & get_factory_dir() const
Definition: gx_system.h:476
gx_jack::GxJack::get_instancename
const string & get_instancename()
Definition: gx_jack.h:200
gx_preset::UnitRacks
Definition: gx_preset.h:35
gx_system::GxSettingsBase::current_name
Glib::ustring current_name
Definition: gx_json.h:465
gx_engine::Parameter::readJSON_value
virtual void readJSON_value(gx_system::JsonParser &jp)=0
gx_system::CmdlineOptions::skin_name
Glib::ustring skin_name
Definition: gx_system.h:443
gx_system::CmdlineOptions::system_show_tooltips
bool system_show_tooltips
Definition: gx_system.h:447
gx_engine::MidiControllerList::set_controller_array
void set_controller_array(const ControllerArray &m)
Definition: gx_paramtable.cpp:676
gx_system::CmdlineOptions::get_jack_instancename
const Glib::ustring & get_jack_instancename() const
Definition: gx_system.h:494
gx_engine::MidiStandardControllers::writeJSON
void writeJSON(gx_system::JsonWriter &jw) const
Definition: gx_paramtable.cpp:158
gx_engine::ParamMap
Definition: gx_parameter.h:512
gx_engine::Parameter::writeJSON
virtual void writeJSON(gx_system::JsonWriter &jw) const =0
gx_system
Definition: gx_json.h:33
gx_system::atomic_get
int atomic_get(volatile int &p)
Definition: gx_system.h:97
gx_system::CmdlineOptions
Definition: gx_system.h:377
gx_system::CmdlineOptions::mul_buffer
int mul_buffer
Definition: gx_system.h:442
gx_engine::Parameter::id
const string & id() const
Definition: gx_parameter.h:171
gx_system::PresetBanks::strip_preset_postfix
static bool strip_preset_postfix(std::string &name)
Definition: gx_json.cpp:1443
gx_system::JsonParser::value_number
Definition: gx_json.h:128
SCHED_IDLE
#define SCHED_IDLE
Definition: gx_preset.cpp:32
gx_engine::Parameter::isFloat
bool isFloat() const
Definition: gx_parameter.h:161
GxFatalError
Definition: gx_logging.h:89
gx_engine::Parameter::isSavable
bool isSavable() const
Definition: gx_parameter.h:169
gx_system::GxSettingsBase::load_preset
void load_preset(PresetFile *pf, const Glib::ustring &name)
Definition: gx_json.cpp:1762
gx_engine::ModuleSequencer
Definition: gx_modulesequencer.h:290
gx_system::CmdlineOptions::get_preset_filepath
std::string get_preset_filepath(const std::string &basename) const
Definition: gx_system.h:461
gx_system::JsonParser::current_value_int
int current_value_int()
Definition: gx_json.h:143
gx_system::CmdlineOptions::mainwin_height
int mainwin_height
Definition: gx_system.h:439
gx_system::CmdlineOptions::window_height
int window_height
Definition: gx_system.h:440
gx_system::GxSettingsBase::save_to_state
void save_to_state(bool preserve_preset=false)
Definition: gx_json.cpp:1822
gx_system::CmdlineOptions::system_show_value
bool system_show_value
Definition: gx_system.h:446
gx_engine::paramlist
list< Parameter * > paramlist
Definition: gx_parameter.h:219
gx_preset::PresetIO::write_preset
void write_preset(gx_system::JsonWriter &jw)
Definition: gx_preset.cpp:532
gx_preset::UnitPositionID::weight
int weight
Definition: gx_preset.cpp:161
gx_engine::Parameter::compareJSON_value
virtual bool compareJSON_value()=0
gx_system::CmdlineOptions::get_online_presets_filename
std::string get_online_presets_filename() const
Definition: gx_system.h:479
gx_system::CmdlineOptions::get_old_user_dir
const std::string & get_old_user_dir() const
Definition: gx_system.h:469
gx_system::CmdlineOptions::system_show_presets
bool system_show_presets
Definition: gx_system.h:449
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_system::JsonParser::set_streampos
void set_streampos(streampos pos)
Definition: gx_json.cpp:568
engine.h
gx_engine::ParamMap::iterator
map< string, Parameter * >::const_iterator iterator
Definition: gx_parameter.h:533
gx_system::GxSettingsBase::loadsetting
bool loadsetting(PresetFile *p, const Glib::ustring &name)
Definition: gx_json.cpp:1711
gx_system::GxSettingsBase::get_current_bank_file
PresetFile * get_current_bank_file()
Definition: gx_json.h:481
gx_system::JsonParser::skip_object
void skip_object()
Definition: gx_json.cpp:608
gx_system::CmdlineOptions::get_lv2_preset_dir
const std::string & get_lv2_preset_dir() const
Definition: gx_system.h:473
gx_system::PresetFile::PRESET_SCRATCH
Definition: gx_json.h:299
gx_preset::UnitPositionID::UnitPositionID
UnitPositionID(const string &id_, const UnitPosition &u)
Definition: gx_preset.cpp:166
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_system::PresetFile::create_file
bool create_file(const Glib::ustring &name, const std::string &path, int tp, int flags)
Definition: gx_json.cpp:988
gx_preset::StateIO::~StateIO
~StateIO()
Definition: gx_preset.cpp:558
gx_system::CmdlineOptions::preset_window_height
int preset_window_height
Definition: gx_system.h:441
gx_preset::PresetIO
Definition: gx_preset.h:64
gx_system::SettingsFileHeader::get_major
int get_major() const
Definition: gx_json.h:242
gx_engine::ConvolverAdapter
Definition: gx_internal_plugins.h:377
gx_preset::PresetIO::~PresetIO
~PresetIO()
Definition: gx_preset.cpp:55
gx_engine::MidiControllerList::remove_controlled_parameters
void remove_controlled_parameters(paramlist &plist, const ControllerArray *m)
Definition: gx_paramtable.cpp:688
gx_engine::Parameter
Definition: gx_parameter.h:104
gx_system::JsonWriter::newline
void newline()
Definition: gx_json.h:94
gx_preset
Definition: gx_preset.h:30
gx_system::CmdlineOptions::get_loop_dir
const std::string & get_loop_dir() const
Definition: gx_system.h:474
gx_preset::StateIO::StateIO
StateIO(gx_engine::MidiControllerList &mctrl, gx_engine::ConvolverAdapter &cvr, gx_engine::ParamMap &param, gx_engine::MidiStandardControllers &mstdctr, gx_jack::GxJack &jack, gx_system::CmdlineOptions &opt, UnitRacks &rack_units)
Definition: gx_preset.cpp:550
gx_system::CmdlineOptions::system_animations
bool system_animations
Definition: gx_system.h:448
gx_system::PresetFile::writeJSON
void writeJSON(JsonWriter &jw)
Definition: gx_json.cpp:1043
gx_system::StateFile::set_filename
void set_filename(const string &fn)
Definition: gx_json.cpp:741
gx_system::CmdlineOptions::get_pluginpreset_filepath
std::string get_pluginpreset_filepath(const std::string &id, bool factory) const
Definition: gx_system.h:465
gx_system::GxSettingsBase::setting_is_preset
bool setting_is_preset()
Definition: gx_json.h:487
gx_system::CmdlineOptions::get_loadfile
const std::string & get_loadfile() const
Definition: gx_system.h:493
gx_preset::PluginPresetList::PluginPresetList
PluginPresetList(const std::string &fname, gx_engine::ParamMap &pmap, gx_engine::MidiControllerList &mctrl_)
Definition: gx_preset.cpp:620