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