Guitarix
gx_parameter.h
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  * This file is part of the guitarix GUI main class
21  * Note: this header file depends on gx_system.h
22  *
23  * ----------------------------------------------------------------------------
24  */
25 
26 #pragma once
27 
28 #ifndef SRC_HEADERS_GX_PARAMETER_H_
29 #define SRC_HEADERS_GX_PARAMETER_H_
30 
31 namespace gx_system { class JsonWriter; class JsonParser; }
32 
33 namespace gx_engine {
34 
35 #ifndef NDEBUG
36 #define debug_check(func, ...) func(__VA_ARGS__)
37 #else
38 #define debug_check(...)
39 #endif
40 
41 /****************************************************************
42  **
43  ** Parameter
44  **
45  */
46 
48  private:
49  map<string, string> groups;
50 
51 #ifndef NDEBUG
52  map<string, bool> used;
53  void group_exists(const string& id);
54  void group_is_new(const string& id);
55  friend string param_group(const string& group_id, bool nowarn);
56 #endif
57 
58  public:
61 
62  inline string get(const string& id) { return groups[id]; }
63  inline string operator[](const string& id) {
65  return groups[id];
66  }
67  inline void insert(const string& id, const string& group) {
69  groups.insert(pair<string, string>(id, group));
70  }
71  bool group_exist(const string& id);
72  inline void erase(const string& id) {
73  if (!group_exist(id)) return;
74 #ifndef NDEBUG // avoid unused variable warning in release mode
75  size_t n = groups.erase(id);
76  assert(n == 1);
77 #else
78  groups.erase(id);
79 #endif
80  }
81 #ifndef NDEBUG
82  void dump();
83 #endif
84 };
85 
86 
88 string param_group(const string& group_id, bool nowarn = false);
89 
90 /****************************************************************
91  ** Parameter
92  */
93 
94 template <class T> class ParameterV;
95 
100 
101 class FloatEnumParameter;
102 class EnumParameter;
103 class FileParameter;
104 
105 /****************************************************************/
106 
107 class Parameter: boost::noncopyable {
108 public:
110  enum toggle_type { OnOff = 0, Constant = 1, Toggle = 2, Commander = 3, _Count = 4 };
111 private:
112  virtual bool midi_set(float n, float high, float llimit, float ulimit); //RT
113  virtual bool midi_set_bpm(float n, float high, float llimit, float ulimit); //RT
114  friend class MidiController;
115 protected:
118  string _id;
119  string _name, _group, _desc;
120  enum value_type v_type : 3;
121  enum ctrl_type c_type : 3;
122  unsigned int d_flags : 2;
123  bool save_in_preset : 1;
124  bool controllable : 1;
125  bool do_not_save : 1;
126  bool blocked : 1;
127  bool midi_blocked : 1;
128  bool output : 1;
129  bool maxlevel : 1;
130  bool nowarn : 1;
131  bool used : 1; // debug
132 protected:
133  void range_warning(float value, float lower, float upper);
134  static gx_system::JsonParser& jp_next(gx_system::JsonParser& jp, const char *key);
135 public:
136  inline std::string group_id() const { return _id.substr(0, _id.find_last_of(".")); }
137  Parameter(const string& id, const string& name, value_type vtp, ctrl_type ctp, bool preset,
138  bool ctrl):
139  boost::noncopyable(),
140  _id(id),
141  _name(name),
143  _desc(),
144  v_type(vtp),
145  c_type(ctp),
146  d_flags(0),
147  save_in_preset(preset),
148  controllable(ctrl),
149  do_not_save(false),
150  blocked(false),
151  midi_blocked(false),
152  output(false),
153  maxlevel(false),
154  used(false) {}
156  virtual ~Parameter();
158  virtual void trigger_changed();
159 
160 #ifndef NDEBUG
161  bool isUsed() const { return used; }
162  void setUsed() { used = true; }
163  friend void compare_parameter(const char* title, Parameter* p1,
164  Parameter* p2, bool all);
166 #endif
167 
168  const char *get_typename() const;
169  bool isFloat() const { return v_type == tp_float; }
170  bool isInt() const { return v_type == tp_int; }
171  bool isBool() const { return v_type == tp_bool; }
172  bool isFile() const { return v_type == tp_file; }
173  bool isString() const { return v_type == tp_string; }
174  ctrl_type getControlType() const { return c_type; }
175  bool isControllable() const { return controllable; }
176  bool isInPreset() const { return save_in_preset; }
177  bool isSavable() const { return !do_not_save; }
178  void setSavable(bool v) { do_not_save = !v; }
179  bool isOutput() const { return output; }
180  void setOutput(bool v) { output = v; }
181  bool isMaxlevel() const { return maxlevel; }
182  void setMaxlevel(bool v) { maxlevel = v; }
183  bool isNoWarning() const { return nowarn; }
184  void setNoWarning(bool v) { nowarn = v; }
185  const string& id() const { return _id; }
186  const string& group() const { return _group; }
187  string l_group() const { return gettext(_group.c_str()); }
188  const string& name() const { return _name; }
189  string l_name() const { return gettext(_name.c_str()); }
190  const string& desc() const { return _desc; }
191  void set_desc(const string& desc) { _desc = desc; }
192  string l_desc() const { return gettext(_desc.c_str()); }
194  bool is_log_display() const { return d_flags & dtp_log; }
195  void set_blocked(bool v) { blocked = v; }
196  bool get_blocked() const { return blocked; }
197  void set_midi_blocked(bool v) { midi_blocked = v; }
198  bool get_midi_blocked() const { return midi_blocked; }
199  bool operator==(const Parameter& p) const { return &p == this; }
200  virtual void stdJSON_value() = 0;
201  virtual bool on_off_value() = 0; //RT
202  virtual void writeJSON(gx_system::JsonWriter& jw) const = 0;
203  virtual void readJSON_value(gx_system::JsonParser& jp) = 0;
204  virtual void setJSON_value() = 0;
205  virtual bool compareJSON_value() = 0;
206  virtual bool hasRange() const;
207  virtual float getLowerAsFloat() const;
208  virtual float getUpperAsFloat() const;
209  virtual float getStepAsFloat() const;
210  virtual const value_pair *getValueNames() const;
211  static inline const char *value_label(const value_pair& vp) {
212  return gettext(vp.value_label ? vp.value_label : vp.value_id);
213  }
215  IntParameter& getInt();
220  sigc::signal<void, float>& signal_changed_float();
221  sigc::signal<void, int>& signal_changed_int();
222  sigc::signal<void, bool>& signal_changed_bool();
223  sigc::signal<void, const Glib::ustring&>& signal_changed_string();
224 };
225 
226 #ifndef NDEBUG
227 void compare_parameter(const char* title, Parameter* p1,
228  Parameter* p2, bool all = false);
229 #endif
230 
231 /****************************************************************/
232 
233 typedef list<Parameter*> paramlist;
234 
235 /****************************************************************/
236 
237 template<class T>
238 class ParameterV: public Parameter {
239 };
240 
241 template<>
242 class ParameterV<float>: public Parameter {
243 private:
244  virtual bool midi_set(float n, float high, float llimit, float ulimit); //RT
245  virtual bool midi_set_bpm(float n, float high, float llimit, float ulimit); //RT
246  virtual void trigger_changed();
247 protected:
248  float json_value;
249  float *value;
250  float std_value;
251  float lower, upper, step;
252  sigc::signal<void, float> changed;
254  friend class ParamRegImpl;
255  friend class GxMachine;
256 public:
257  bool set(float val) const;
258  bool ramp_value(float val);
259  float get_value() const { return *value; }
260  void convert_from_range(float low, float up);
261  void set_zero() { *value = 0; }
262  virtual void stdJSON_value();
263  virtual bool on_off_value();
264  virtual void writeJSON(gx_system::JsonWriter& jw) const;
267  virtual bool compareJSON_value();
268  virtual void setJSON_value();
269  virtual bool hasRange() const;
270  virtual float getLowerAsFloat() const;
271  virtual float getUpperAsFloat() const;
272  virtual float getStepAsFloat() const;
273  virtual float idx_from_id(string v_id);
274  ParameterV(const string& id, const string& name, ctrl_type ctp, bool preset,
275  float *v, float sv, float lv, float uv, float tv, bool ctrl, bool no_init):
276  Parameter(id, name, tp_float, ctp, preset, ctrl),
277  value(v ? v : &value_storage), std_value(sv),lower(lv),upper(uv),step(tv) {
278  assert(lv <= sv && sv <= uv);
279  if (!no_init) {
280  *value = sv;
281  }
282  }
283 #ifndef NDEBUG
284  friend void compare_parameter(const char* title, Parameter* p1,
285  Parameter* p2, bool all);
286 #endif
290  sigc::signal<void, float>& signal_changed() { return changed; }
291 };
292 
293 /****************************************************************/
294 
296 protected:
299 public:
300  virtual void writeJSON(gx_system::JsonWriter& jw) const;
302  virtual const value_pair *getValueNames() const;
303  FloatEnumParameter(const string& id, const string& name, const value_pair* vn, bool preset, float *v,
304  int sv, int low, bool ctrl, bool no_init);
306  virtual float idx_from_id(string v_id);
307 };
308 
309 /****************************************************************/
310 
311 template<>
312 class ParameterV<int>: public Parameter {
313 private:
314  virtual bool midi_set(float n, float high, float llimit, float ulimit); //RT
315  virtual void trigger_changed();
316 protected:
318  int *value;
320  int lower, upper;
321  sigc::signal<void, int> changed;
323  friend class ParamRegImpl;
324 public:
325  bool set(int val) const;
326  int get_value() const { return *value; }
327  virtual void stdJSON_value();
328  virtual bool on_off_value();
329  virtual void writeJSON(gx_system::JsonWriter& jw) const;
331  virtual bool compareJSON_value();
332  virtual void setJSON_value();
333  virtual bool hasRange() const;
334  virtual float getLowerAsFloat() const;
335  virtual float getUpperAsFloat() const;
336  virtual int idx_from_id(string v_id);
337  ParameterV(const string& id, const string& name, ctrl_type ctp, bool preset,
338  int *v, int sv, int lv, int uv, bool ctrl):
339  Parameter(id, name, tp_int, ctp, preset, ctrl),
340  value(v ? v : &value_storage), std_value(sv), lower(lv), upper(uv) {
341  *value = sv;
342  }
346  sigc::signal<void, int>& signal_changed() { return changed; }
347 };
348 
349 /****************************************************************/
350 
352 protected:
355 public:
356  virtual void writeJSON(gx_system::JsonWriter& jw) const;
358  virtual const value_pair *getValueNames() const;
359  virtual int idx_from_id(string v_id);
360  const value_pair& get_pair() { return getValueNames()[get_value()]; }
361  EnumParameter(const string& id, const string& name, const value_pair* vn, bool preset, int *v,
362  int sv, bool ctrl);
364 };
365 
366 /****************************************************************/
367 
368 template<>
369 class ParameterV<bool>: public Parameter {
370 private:
371  virtual bool midi_set(float n, float high, float llimit, float ulimit); //RT
372  virtual void trigger_changed();
373 protected:
375  bool *value;
376  bool std_value;
377  sigc::signal<void, bool> changed;
379  friend class ParamRegImpl;
380 public:
381  bool set(bool val) const;
382  virtual void stdJSON_value();
383  bool get_value() const { return *value; }
384  virtual bool on_off_value();
385  virtual void writeJSON(gx_system::JsonWriter& jw) const;
386  virtual bool compareJSON_value();
387  virtual void setJSON_value();
389  ParameterV(const string& id, const string& name, ctrl_type ctp, bool preset,
390  bool *v, bool sv, bool ctrl):
391  Parameter(id, name, tp_bool, ctp, preset, ctrl),
392  value(v ? v : &value_storage), std_value(sv) {
393  *value = sv;
394  }
398  sigc::signal<void, bool>& signal_changed() { return changed; }
399 };
400 
401 /****************************************************************/
402 
403 /****************************************************************/
404 
405 class FileParameter: public Parameter {
406 protected:
407  Glib::RefPtr<Gio::File> value;
408  Glib::RefPtr<Gio::File> std_value;
409  Glib::RefPtr<Gio::File> json_value;
410  sigc::signal<void> changed;
411 public:
412  sigc::signal<void>& signal_changed() { return changed; }
413  bool set(const Glib::RefPtr<Gio::File>& val);
414  void set_path(const string& path);
415  const Glib::RefPtr<Gio::File>& get() const { return value; }
416  virtual void stdJSON_value();
417  virtual bool on_off_value();
418  virtual void writeJSON(gx_system::JsonWriter& jw) const;
420  virtual bool compareJSON_value();
421  virtual void setJSON_value();
422  FileParameter(const string& id, const string& filename, bool preset = false):
423  Parameter(id, "", tp_file, None, preset, false),
424  value(Gio::File::create_for_path(filename)),
425  std_value(value->dup()) {}
426  FileParameter(const string& id, bool preset = false):
427  Parameter(id, "", tp_file, None, preset, false),
428  value(0),
429  std_value(0) {}
432  void set_standard(const string& filename);
433  bool is_equal(const Glib::RefPtr<Gio::File>& v) const;
434  bool is_standard() const { return is_equal(std_value); }
435  string get_path() const;
436  string get_directory_path() const;
437  string get_parse_name() const;
438  string get_display_name() const;
439  void copy(const string& destination) const;
440 };
441 
442 /****************************************************************/
443 
444 template<>
445 class ParameterV<Glib::ustring>: public Parameter {
446 protected:
447  Glib::ustring json_value;
448  Glib::ustring *value;
449  Glib::ustring std_value;
450  sigc::signal<void, const Glib::ustring&> changed;
451  Glib::ustring value_storage;
452 public:
453  bool set(const Glib::ustring& val) const;
454  const Glib::ustring& get_value() const { return *value; }
455  virtual void stdJSON_value();
456  virtual bool on_off_value();
457  virtual void writeJSON(gx_system::JsonWriter& jw) const;
458  virtual bool compareJSON_value();
459  virtual void setJSON_value();
461  ParameterV(const string& id, const string& name, Glib::ustring *v, const Glib::ustring& sv, bool preset = false)
462  : Parameter(id, name, tp_string, None, preset, false),
463  value(v ? v : &value_storage), std_value(sv) {
464  }
468  sigc::signal<void, const Glib::ustring&>& signal_changed() { return changed; }
469  Glib::ustring& get_json_value() { return json_value; }
470 };
471 
472 
473 /****************************************************************/
474 
476  assert(isFloat());
477  return static_cast<FloatParameter&>(*this);
478 }
479 
481  assert(isInt());
482  return static_cast<IntParameter&>(*this);
483 }
484 
486  EnumParameter *p = dynamic_cast<EnumParameter*>(this);
487  assert(p);
488  return *p;
489 }
490 
492  assert(isBool());
493  return static_cast<BoolParameter&>(*this);
494 }
495 
497  assert(isFile());
498  return static_cast<FileParameter&>(*this);
499 }
500 
502  assert(isString());
503  return static_cast<StringParameter&>(*this);
504 }
505 
506 inline sigc::signal<void, float>& Parameter::signal_changed_float() {
507  FloatParameter *p = dynamic_cast<FloatParameter*>(this);
508  assert(p);
509  return p->signal_changed();
510 }
511 
512 inline sigc::signal<void, int>& Parameter::signal_changed_int() {
513  IntParameter *p = dynamic_cast<IntParameter*>(this);
514  assert(p);
515  return p->signal_changed();
516 }
517 
518 inline sigc::signal<void, bool>& Parameter::signal_changed_bool() {
519  BoolParameter *p = dynamic_cast<BoolParameter*>(this);
520  assert(p);
521  return p->signal_changed();
522 }
523 
524 inline sigc::signal<void, const Glib::ustring&>& Parameter::signal_changed_string() {
525  StringParameter *p = dynamic_cast<StringParameter*>(this);
526  assert(p);
527  return p->signal_changed();
528 }
529 
530 
531 /****************************************************************
532  ** ParamMap
533  */
534 
535 class ParamMap: boost::noncopyable {
536  private:
537  map<string, Parameter*> id_map;
539  sigc::signal<void,Parameter*,bool> insert_remove;
540 #ifndef NDEBUG
541  void unique_id(Parameter* param);
542  void check_id(const string& id);
543  void check_p(const char *p);
544 #endif
545  Parameter *insert(Parameter* param); // private so we can make sure parameters are owned
546 
547  public:
548  template<class T> friend class ParameterV;
555  typedef map<string, Parameter*>::const_iterator iterator;
556  iterator begin() const { return id_map.begin(); }
557  iterator end() const { return id_map.end(); }
558  bool hasId(const string& id) const { return id_map.find(id) != id_map.end(); }
559  bool hasId(const char *p) const { return id_map.find(p) != id_map.end(); }
560  void set_replace_mode(bool mode) { replace_mode = mode; }
561  Parameter& operator[](const string& id) {
562  debug_check(check_id, id);
563  return *id_map[id];
564  }
565  Parameter& operator[](const char *p) {
566  debug_check(check_p, p);
567  return *id_map[p];
568  }
570  void reset_unit(const PluginDef *pdef) const;
571  bool unit_has_std_values(const PluginDef *pdef) const;
572  sigc::signal<void,Parameter*,bool> signal_insert_remove() { return insert_remove; }
574  void unregister(const string& id);
575  inline FloatParameter *reg_par(const string& id, const string& name, float *var, float std,
576  float lower, float upper, float step, bool midi=true) {
577  FloatParameter *p = new FloatParameter(id, name, Parameter::Continuous, true, var, std, lower, upper, step, midi, replace_mode);
578  insert(p);
579  return p;
580  }
582  const string& id, const string& name, float *var, float std, float lower, float upper, float step) {
583  FloatParameter *p = new FloatParameter(id, name, Parameter::Continuous, false, var, std, lower, upper, step, false, replace_mode);
584  insert(p);
585  return p;
586  }
587  inline FloatParameter *reg_par(const string& id, const string& name, float *var, float std = 0, bool midi = true) {
588  FloatParameter *p = new FloatParameter(id, name, Parameter::Switch, true, var, std, 0, 1, 1, midi, replace_mode);
589  insert(p);
590  return p;
591  }
592  inline BoolParameter *reg_par(const string& id, const string& name, bool *var, bool std=false, bool preset=true, bool midi=true) {
593  BoolParameter * p = new BoolParameter(id, name, Parameter::Switch, preset, var, std, midi);
594  insert(p);
595  return p;
596  }
597  inline EnumParameter *reg_enum_par(const string& id, const string& name,
598  const value_pair *vl, int *var, int std = 0, bool midi=true) {
599  EnumParameter *p = new EnumParameter(id, name, vl, true, var, std, midi);
600  insert(p);
601  return p;
602  }
604  const string& id, const string& name, const value_pair *vl,
605  int *var, bool preset, int std = 0) {
606  EnumParameter *p = new EnumParameter(id, name, vl, preset, var, std, false);
607  insert(p);
608  return p;
609  }
610  inline FloatEnumParameter *reg_enum_par(const string& id, const string& name,
611  const value_pair *vl, float *var,
612  int std = 0, int low = 0, bool midi=true) {
613  FloatEnumParameter *p = new FloatEnumParameter(id, name, vl, true, var, std, low, midi, replace_mode);
614  insert(p);
615  return p;
616  }
617  inline BoolParameter *reg_non_midi_par(const string& id, bool *var, bool preset, bool std = false) {
618  BoolParameter *p = new BoolParameter(id, "", Parameter::Switch, preset, var, std, false);
619  insert(p);
620  return p;
621  }
622  inline IntParameter *reg_par(const string& id, const string& name, int *var, int std,
623  int lower, int upper, bool midi) {
624  IntParameter *p = new IntParameter(id, name, Parameter::Continuous, true, var, std, lower, upper, midi);
625  insert(p);
626  return p;
627  }
628  inline IntParameter *reg_par(const string& id, const string& name, int *var, int std, bool midi) {
629  IntParameter *p = new IntParameter(id, name, Parameter::Switch, true, var, std, 0, 1, midi);
630  insert(p);
631  return p;
632  }
633  inline IntParameter *reg_non_midi_par(const string& id, int *var, bool preset, int std, int lower, int upper) {
634  IntParameter *p = new IntParameter(id, "", Parameter::None, preset, var, std, lower, upper, false);
635  insert(p);
636  return p;
637  }
638  inline FloatParameter *reg_non_midi_par(const string& id, float *val, bool preset,
639  float std = 0, float lower = 0, float upper = 1, float step = 0) {
640  FloatParameter *p = new FloatParameter(id, "", Parameter::Continuous, preset, val, std, lower, upper, step, false, replace_mode);
641  insert(p);
642  return p;
643  }
644  inline FileParameter *reg_filepar(const string& id, bool preset = false) {
645  FileParameter *p = new FileParameter(id, preset);
646  insert(p);
647  return p;
648  }
649  inline StringParameter *reg_string(const string& id, const string& name, Glib::ustring *var, const string& sv, bool preset=false) {
650  StringParameter *p = new StringParameter(id, name, var, sv, preset);
651  insert(p);
652  return p;
653  }
654  inline StringParameter *reg_preset_string(const string& id, const string& name, Glib::ustring *var, const string& sv, bool preset=true) {
655  StringParameter *p = new StringParameter(id, name, var, sv, preset);
656  insert(p);
657  return p;
658  }
659 
660 #ifndef NDEBUG
661  void dump(const string& fmt);
662 #endif
663 };
664 
665 /****************************************************************
666  **
667  ** Midi
668  **
669  */
670 
671 
672 /*
673 ** MidiStandardControllers
674 */
675 
676 /****************************************************************/
677 
679  private:
680  struct modstring {
681  string name;
682  bool modified;
683  const char *std;
684  modstring(const string& n, bool m, const char* s): name(n), modified(m), std(s) {}
685  explicit modstring(const char* n): name(n), modified(false), std(n) {}
686  modstring(): name(""), modified(false), std(0) {}
687  };
688  map<int, modstring> m;
689  string midi_to_note(int ctr);
690  string ctr_desc(int ctr);
691  public:
693  const string operator[](int ctr) { return m[ctr].name; }
694  void replace(int ctr, const string& name);
697 };
698 
699 extern MidiStandardControllers midi_std_ctr; // map ctrl num -> standard name
700 
701 /****************************************************************
702 **
703 ** MidiController
704 **/
705 
707  private:
709  float _lower, _upper; //RT
710  bool toggle; //RT
712 
713  public:
714  MidiController(Parameter& p, float l, float u, bool t=false, int tt=0):
715  param(&p), _lower(l), _upper(u), toggle(t), _toggle_behaviour(tt) {}
716  float lower() const { return _lower; }
717  float upper() const { return _upper; }
718  bool is_toggle() const { return toggle; }
719  int toggle_behaviour() const { return _toggle_behaviour; }
720  bool hasParameter(const Parameter& p) const { return *param == p; }
721  Parameter& getParameter() const { return *param; }
723  bool set_midi(int n, int last_value, int *value_set, bool update); //RT
724  bool set_bpm(int n, int last_value); //RT
725  bool set_trans(int n, int last_value); //RT
726  void set(float v, float high) { param->midi_set(v, high, _lower, _upper); }
729 };
730 
731 typedef list<MidiController> midi_controller_list;
732 
733 /****************************************************************
734 **
735 ** MidiControllerList
736 **/
737 
738 
740 private:
741  double time1;
742  double time_diff;
743  int collect;
744  int collect_;
745  double bpm;
746  double bpm_new;
747  bool ret;
748 
749 public:
752  unsigned int rounded(float f);
753  bool time_to_bpm(double time, unsigned int* bpm_);
754 };
755 
756 
757 class ControllerArray: public vector<midi_controller_list> {
758 public:
759  enum { array_size = 328 };
764  int param2controller(Parameter& param, const MidiController** p);
766 };
767 
768 class MidiControllerList: public sigc::trackable {
769 public:
770 private:
775  volatile gint program_change; //RT
776  volatile gint mute_change; //RT
777  volatile gint bank_change; //RT
780  timespec ts1;
781  double time0;
782  unsigned int bpm_;
784  Glib::Dispatcher pgm_chg;
785  Glib::Dispatcher mute_chg;
786  Glib::Dispatcher bank_chg;
787  Glib::Dispatcher val_chg;
788  sigc::signal<void> changed;
789  sigc::signal<void,int> new_program;
790  sigc::signal<void,int> new_mute_state;
791  sigc::signal<void,int> new_bank;
792  sigc::signal<void, int, int> midi_value_changed;
793 private:
794  void on_pgm_chg();
795  void on_mute_chg();
796  void on_bank_chg();
797  void on_val_chg();
799 public:
801  midi_controller_list& operator[](int n) { return map[n]; }
802  int size() { return map.size(); }
803  void set_config_mode(bool mode, int ctl=-1);
804  bool get_config_mode() { return last_midi_control != -2; }
806  void set_current_control(int ctl) { last_midi_control = ctl; }
807  void set_ctr_val(int ctr, int val); //RT
808  void set_bpm_val(unsigned int val); //RT
810  void modifyCurrent(Parameter& param, float lower, float upper, bool toggle, int toggle_behaviour);
811  int param2controller(Parameter& param, const MidiController** p) {
812  return map.param2controller(param, p); }
813  void writeJSON(gx_system::JsonWriter& jw) const { map.writeJSON(jw); }
814  int get_last_midi_control_value(unsigned int n) {
815  assert(n < ControllerArray::array_size); return last_midi_control_value[n]; } //RT
816  void set_last_midi_control_value(unsigned int n, int v) {
820  sigc::signal<void>& signal_changed() { return changed; }
821  sigc::signal<void,int>& signal_new_program() { return new_program; }
822  sigc::signal<void,int>& signal_new_mute_state() { return new_mute_state; }
823  sigc::signal<void,int>& signal_new_bank() { return new_bank; }
824  void compute_midi_in(void* midi_input_port_buf, void *arg); //RT
825  void process_trans(int transport_state); //RT
826  void update_from_controller(int ctr);
828  void set_midi_channel(int s);
830  sigc::signal<void, int, int>& signal_midi_value_changed() { return midi_value_changed; }
831  sigc::signal<void, int, int> trigger_midi_feedback;
832  sigc::signal<void, int, int>& signal_trigger_midi_feedback() { return trigger_midi_feedback; }
834 };
835 
836 } // namespace gx_gui
837 
838 #endif // SRC_HEADERS_GX_PARAMETER_H_
839 
void writeJSON(gx_system::JsonWriter &jw) const
int param2controller(Parameter &param, const MidiController **p)
void readJSON(gx_system::JsonParser &jp, ParamMap &param)
bool deleteParameter(Parameter &p)
virtual const value_pair * getValueNames() const
const value_pair * value_names
Definition: gx_parameter.h:353
virtual void serializeJSON(gx_system::JsonWriter &jw)
EnumParameter(gx_system::JsonParser &jp)
Definition: gx_parameter.h:354
virtual void readJSON_value(gx_system::JsonParser &jp)
EnumParameter(const string &id, const string &name, const value_pair *vn, bool preset, int *v, int sv, bool ctrl)
const value_pair & get_pair()
Definition: gx_parameter.h:360
virtual int idx_from_id(string v_id)
virtual void writeJSON(gx_system::JsonWriter &jw) const
Glib::RefPtr< Gio::File > value
Definition: gx_parameter.h:407
FileParameter(const string &id, const string &filename, bool preset=false)
Definition: gx_parameter.h:422
sigc::signal< void > & signal_changed()
Definition: gx_parameter.h:412
bool set(const Glib::RefPtr< Gio::File > &val)
void set_path(const string &path)
virtual void setJSON_value()
virtual void stdJSON_value()
const Glib::RefPtr< Gio::File > & get() const
Definition: gx_parameter.h:415
FileParameter(gx_system::JsonParser &jp)
void set_standard(const string &filename)
virtual void serializeJSON(gx_system::JsonWriter &jw)
string get_parse_name() const
Glib::RefPtr< Gio::File > json_value
Definition: gx_parameter.h:409
void copy(const string &destination) const
string get_path() const
virtual bool on_off_value()
string get_display_name() const
bool is_equal(const Glib::RefPtr< Gio::File > &v) const
virtual void readJSON_value(gx_system::JsonParser &jp)
Glib::RefPtr< Gio::File > std_value
Definition: gx_parameter.h:408
virtual void writeJSON(gx_system::JsonWriter &jw) const
sigc::signal< void > changed
Definition: gx_parameter.h:410
virtual bool compareJSON_value()
FileParameter(const string &id, bool preset=false)
Definition: gx_parameter.h:426
string get_directory_path() const
virtual const value_pair * getValueNames() const
virtual void serializeJSON(gx_system::JsonWriter &jw)
const value_pair * value_names
Definition: gx_parameter.h:297
FloatEnumParameter(const string &id, const string &name, const value_pair *vn, bool preset, float *v, int sv, int low, bool ctrl, bool no_init)
FloatEnumParameter(gx_system::JsonParser &jp)
Definition: gx_parameter.h:298
virtual void writeJSON(gx_system::JsonWriter &jw) const
virtual void readJSON_value(gx_system::JsonParser &jp)
virtual float idx_from_id(string v_id)
unsigned int rounded(float f)
bool time_to_bpm(double time, unsigned int *bpm_)
bool set_trans(int n, int last_value)
MidiController(Parameter &p, float l, float u, bool t=false, int tt=0)
Definition: gx_parameter.h:714
bool set_bpm(int n, int last_value)
static MidiController * readJSON(gx_system::JsonParser &jp, ParamMap &param)
bool set_midi(int n, int last_value, int *value_set, bool update)
bool hasParameter(const Parameter &p) const
Definition: gx_parameter.h:720
Parameter & getParameter() const
Definition: gx_parameter.h:721
void set(float v, float high)
Definition: gx_parameter.h:726
void writeJSON(gx_system::JsonWriter &jw) const
int changed_midi_control_value[ControllerArray::array_size]
Definition: gx_parameter.h:774
sigc::signal< void > changed
Definition: gx_parameter.h:788
sigc::signal< void, int > & signal_new_program()
Definition: gx_parameter.h:821
sigc::signal< void, int > & signal_new_mute_state()
Definition: gx_parameter.h:822
sigc::signal< void, int, int > & signal_midi_value_changed()
Definition: gx_parameter.h:830
void set_bpm_val(unsigned int val)
void set_config_mode(bool mode, int ctl=-1)
void deleteParameter(Parameter &param)
void writeJSON(gx_system::JsonWriter &jw) const
Definition: gx_parameter.h:813
void compute_midi_in(void *midi_input_port_buf, void *arg)
sigc::signal< void, int, int > & signal_trigger_midi_feedback()
Definition: gx_parameter.h:832
sigc::signal< void, int > & signal_new_bank()
Definition: gx_parameter.h:823
int last_midi_control_value[ControllerArray::array_size]
Definition: gx_parameter.h:772
void modifyCurrent(Parameter &param, float lower, float upper, bool toggle, int toggle_behaviour)
void set_last_midi_control_value(unsigned int n, int v)
Definition: gx_parameter.h:816
sigc::signal< void, int > new_bank
Definition: gx_parameter.h:791
sigc::signal< void, int > new_mute_state
Definition: gx_parameter.h:790
void process_trans(int transport_state)
midi_controller_list & operator[](int n)
Definition: gx_parameter.h:801
void remove_controlled_parameters(paramlist &plist, const ControllerArray *m)
sigc::signal< void, int, int > midi_value_changed
Definition: gx_parameter.h:792
sigc::signal< void > & signal_changed()
Definition: gx_parameter.h:820
void update_from_controller(int ctr)
int param2controller(Parameter &param, const MidiController **p)
Definition: gx_parameter.h:811
sigc::signal< void, int > new_program
Definition: gx_parameter.h:789
void set_ctr_val(int ctr, int val)
int get_last_midi_control_value(unsigned int n)
Definition: gx_parameter.h:814
void set_controller_array(const ControllerArray &m)
sigc::signal< void, int, int > trigger_midi_feedback
Definition: gx_parameter.h:831
void replace(int ctr, const string &name)
void writeJSON(gx_system::JsonWriter &jw) const
const string operator[](int ctr)
Definition: gx_parameter.h:693
void readJSON(gx_system::JsonParser &jp)
StringParameter * reg_string(const string &id, const string &name, Glib::ustring *var, const string &sv, bool preset=false)
Definition: gx_parameter.h:649
sigc::signal< void, Parameter *, bool > insert_remove
Definition: gx_parameter.h:539
FloatParameter * reg_par(const string &id, const string &name, float *var, float std, float lower, float upper, float step, bool midi=true)
Definition: gx_parameter.h:575
Parameter & operator[](const char *p)
Definition: gx_parameter.h:565
bool hasId(const char *p) const
Definition: gx_parameter.h:559
void dump(const string &fmt)
FloatParameter * reg_par(const string &id, const string &name, float *var, float std=0, bool midi=true)
Definition: gx_parameter.h:587
sigc::signal< void, Parameter *, bool > signal_insert_remove()
Definition: gx_parameter.h:572
void writeJSON(gx_system::JsonWriter &jw)
void unregister(const string &id)
BoolParameter * reg_non_midi_par(const string &id, bool *var, bool preset, bool std=false)
Definition: gx_parameter.h:617
bool unit_has_std_values(const PluginDef *pdef) const
StringParameter * reg_preset_string(const string &id, const string &name, Glib::ustring *var, const string &sv, bool preset=true)
Definition: gx_parameter.h:654
map< string, Parameter * > id_map
Definition: gx_parameter.h:537
Parameter * insert(Parameter *param)
IntParameter * reg_non_midi_par(const string &id, int *var, bool preset, int std, int lower, int upper)
Definition: gx_parameter.h:633
IntParameter * reg_par(const string &id, const string &name, int *var, int std, int lower, int upper, bool midi)
Definition: gx_parameter.h:622
map< string, Parameter * >::const_iterator iterator
Definition: gx_parameter.h:555
FloatParameter * reg_non_midi_par(const string &id, float *val, bool preset, float std=0, float lower=0, float upper=1, float step=0)
Definition: gx_parameter.h:638
BoolParameter * reg_par(const string &id, const string &name, bool *var, bool std=false, bool preset=true, bool midi=true)
Definition: gx_parameter.h:592
void check_p(const char *p)
FloatEnumParameter * reg_enum_par(const string &id, const string &name, const value_pair *vl, float *var, int std=0, int low=0, bool midi=true)
Definition: gx_parameter.h:610
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:603
EnumParameter * reg_enum_par(const string &id, const string &name, const value_pair *vl, int *var, int std=0, bool midi=true)
Definition: gx_parameter.h:597
void set_replace_mode(bool mode)
Definition: gx_parameter.h:560
void readJSON(gx_system::JsonParser &jp)
IntParameter * reg_par(const string &id, const string &name, int *var, int std, bool midi)
Definition: gx_parameter.h:628
bool hasId(const string &id) const
Definition: gx_parameter.h:558
Parameter * readJSON_one(gx_system::JsonParser &jp)
void check_id(const string &id)
void reset_unit(const PluginDef *pdef) const
void unregister(Parameter *p)
iterator begin() const
Definition: gx_parameter.h:556
void writeJSON_one(gx_system::JsonWriter &jw, Parameter *p)
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:581
iterator end() const
Definition: gx_parameter.h:557
void unique_id(Parameter *param)
Parameter & operator[](const string &id)
Definition: gx_parameter.h:561
FileParameter * reg_filepar(const string &id, bool preset=false)
Definition: gx_parameter.h:644
void group_is_new(const string &id)
friend string param_group(const string &group_id, bool nowarn)
void group_exists(const string &id)
map< string, string > groups
Definition: gx_parameter.h:49
bool group_exist(const string &id)
string get(const string &id)
Definition: gx_parameter.h:62
void erase(const string &id)
Definition: gx_parameter.h:72
void insert(const string &id, const string &group)
Definition: gx_parameter.h:67
string operator[](const string &id)
Definition: gx_parameter.h:63
map< string, bool > used
Definition: gx_parameter.h:52
bool isString() const
Definition: gx_parameter.h:173
EnumParameter & getEnum()
Definition: gx_parameter.h:485
bool operator==(const Parameter &p) const
Definition: gx_parameter.h:199
void dump(gx_system::JsonWriter *jw)
virtual const value_pair * getValueNames() const
StringParameter & getString()
Definition: gx_parameter.h:501
Parameter(gx_system::JsonParser &jp)
void setNoWarning(bool v)
Definition: gx_parameter.h:184
virtual bool midi_set_bpm(float n, float high, float llimit, float ulimit)
virtual bool hasRange() const
enum value_type v_type
Definition: gx_parameter.h:120
std::string group_id() const
Definition: gx_parameter.h:136
FileParameter & getFile()
Definition: gx_parameter.h:496
bool isInt() const
Definition: gx_parameter.h:170
bool get_midi_blocked() const
Definition: gx_parameter.h:198
virtual float getUpperAsFloat() const
bool isOutput() const
Definition: gx_parameter.h:179
sigc::signal< void, bool > & signal_changed_bool()
Definition: gx_parameter.h:518
virtual bool compareJSON_value()=0
static gx_system::JsonParser & jp_next(gx_system::JsonParser &jp, const char *key)
bool isMaxlevel() const
Definition: gx_parameter.h:181
IntParameter & getInt()
Definition: gx_parameter.h:480
bool get_blocked() const
Definition: gx_parameter.h:196
bool isNoWarning() const
Definition: gx_parameter.h:183
bool isFloat() const
Definition: gx_parameter.h:169
const string & desc() const
Definition: gx_parameter.h:190
virtual void serializeJSON(gx_system::JsonWriter &jw)
FloatParameter & getFloat()
Definition: gx_parameter.h:475
bool isFile() const
Definition: gx_parameter.h:172
sigc::signal< void, float > & signal_changed_float()
Definition: gx_parameter.h:506
BoolParameter & getBool()
Definition: gx_parameter.h:491
virtual void stdJSON_value()=0
string l_name() const
Definition: gx_parameter.h:189
bool isControllable() const
Definition: gx_parameter.h:175
virtual void readJSON_value(gx_system::JsonParser &jp)=0
virtual bool on_off_value()=0
bool isInPreset() const
Definition: gx_parameter.h:176
sigc::signal< void, int > & signal_changed_int()
Definition: gx_parameter.h:512
void range_warning(float value, float lower, float upper)
virtual bool midi_set(float n, float high, float llimit, float ulimit)
Parameter(const string &id, const string &name, value_type vtp, ctrl_type ctp, bool preset, bool ctrl)
Definition: gx_parameter.h:137
void set_midi_blocked(bool v)
Definition: gx_parameter.h:197
void set_desc(const string &desc)
Definition: gx_parameter.h:191
ctrl_type getControlType() const
Definition: gx_parameter.h:174
virtual float getLowerAsFloat() const
bool is_log_display() const
Definition: gx_parameter.h:194
const char * get_typename() const
void setOutput(bool v)
Definition: gx_parameter.h:180
const string & name() const
Definition: gx_parameter.h:188
const string & group() const
Definition: gx_parameter.h:186
friend void compare_parameter(const char *title, Parameter *p1, Parameter *p2, bool all)
enum ctrl_type c_type
Definition: gx_parameter.h:121
virtual void trigger_changed()
string l_group() const
Definition: gx_parameter.h:187
bool isSavable() const
Definition: gx_parameter.h:177
bool isBool() const
Definition: gx_parameter.h:171
bool isUsed() const
Definition: gx_parameter.h:161
string l_desc() const
Definition: gx_parameter.h:192
void setMaxlevel(bool v)
Definition: gx_parameter.h:182
void setSavable(bool v)
Definition: gx_parameter.h:178
static const char * value_label(const value_pair &vp)
Definition: gx_parameter.h:211
virtual float getStepAsFloat() const
unsigned int d_flags
Definition: gx_parameter.h:122
const string & id() const
Definition: gx_parameter.h:185
sigc::signal< void, const Glib::ustring & > & signal_changed_string()
Definition: gx_parameter.h:524
virtual void writeJSON(gx_system::JsonWriter &jw) const =0
void set_blocked(bool v)
Definition: gx_parameter.h:195
virtual void setJSON_value()=0
ParameterV(gx_system::JsonParser &jp)
bool set(const Glib::ustring &val) const
virtual void readJSON_value(gx_system::JsonParser &jp)
virtual void serializeJSON(gx_system::JsonWriter &jw)
virtual void writeJSON(gx_system::JsonWriter &jw) const
sigc::signal< void, const Glib::ustring & > changed
Definition: gx_parameter.h:450
sigc::signal< void, const Glib::ustring & > & signal_changed()
Definition: gx_parameter.h:468
ParameterV(const string &id, const string &name, Glib::ustring *v, const Glib::ustring &sv, bool preset=false)
Definition: gx_parameter.h:461
const Glib::ustring & get_value() const
Definition: gx_parameter.h:454
virtual void serializeJSON(gx_system::JsonWriter &jw)
sigc::signal< void, bool > & signal_changed()
Definition: gx_parameter.h:398
virtual bool midi_set(float n, float high, float llimit, float ulimit)
virtual bool compareJSON_value()
bool set(bool val) const
sigc::signal< void, bool > changed
Definition: gx_parameter.h:377
ParameterV(gx_system::JsonParser &jp)
virtual void readJSON_value(gx_system::JsonParser &jp)
ParameterV(const string &id, const string &name, ctrl_type ctp, bool preset, bool *v, bool sv, bool ctrl)
Definition: gx_parameter.h:389
virtual void writeJSON(gx_system::JsonWriter &jw) const
virtual float getUpperAsFloat() const
virtual void writeJSON(gx_system::JsonWriter &jw) const
ParameterV(const string &id, const string &name, ctrl_type ctp, bool preset, float *v, float sv, float lv, float uv, float tv, bool ctrl, bool no_init)
Definition: gx_parameter.h:274
virtual bool midi_set_bpm(float n, float high, float llimit, float ulimit)
bool set(float val) const
virtual void serializeJSON(gx_system::JsonWriter &jw)
void convert_from_range(float low, float up)
virtual void rampJSON_value(gx_system::JsonParser &jp)
sigc::signal< void, float > & signal_changed()
Definition: gx_parameter.h:290
virtual bool midi_set(float n, float high, float llimit, float ulimit)
ParameterV(gx_system::JsonParser &jp)
virtual float getLowerAsFloat() const
virtual bool hasRange() const
sigc::signal< void, float > changed
Definition: gx_parameter.h:252
virtual void readJSON_value(gx_system::JsonParser &jp)
friend void compare_parameter(const char *title, Parameter *p1, Parameter *p2, bool all)
virtual float idx_from_id(string v_id)
virtual float getStepAsFloat() const
ParameterV(gx_system::JsonParser &jp)
virtual void serializeJSON(gx_system::JsonWriter &jw)
virtual bool compareJSON_value()
virtual bool hasRange() const
virtual void readJSON_value(gx_system::JsonParser &jp)
virtual float getLowerAsFloat() const
virtual void writeJSON(gx_system::JsonWriter &jw) const
ParameterV(const string &id, const string &name, ctrl_type ctp, bool preset, int *v, int sv, int lv, int uv, bool ctrl)
Definition: gx_parameter.h:337
sigc::signal< void, int > changed
Definition: gx_parameter.h:321
virtual int idx_from_id(string v_id)
virtual float getUpperAsFloat() const
bool set(int val) const
virtual void trigger_changed()
sigc::signal< void, int > & signal_changed()
Definition: gx_parameter.h:346
virtual bool midi_set(float n, float high, float llimit, float ulimit)
#define debug_check(func,...)
Definition: gx_parameter.h:36
MidiStandardControllers midi_std_ctr
ParameterV< Glib::ustring > StringParameter
Definition: gx_parameter.h:99
list< MidiController > midi_controller_list
Definition: gx_parameter.h:731
ParameterV< float > FloatParameter
Definition: gx_parameter.h:94
void compare_parameter(const char *title, Parameter *p1, Parameter *p2, bool all=false)
string param_group(const string &group_id, bool nowarn=false)
list< Parameter * > paramlist
Definition: gx_parameter.h:233
ParameterV< int > IntParameter
Definition: gx_parameter.h:97
ParameterV< bool > BoolParameter
Definition: gx_parameter.h:98
ParameterGroups & get_group_table()
modstring(const string &n, bool m, const char *s)
Definition: gx_parameter.h:684
const char * value_label
Definition: gx_plugin.h:119
const char * value_id
Definition: gx_plugin.h:118