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