e85d8820d46406d5f0f4a8ff13dd0d41f1b9b127
[terminatorX.git] / src / tX_seqpar.h
1 /*
2     terminatorX - realtime audio scratching software
3     Copyright (C) 1999-2016 Alexander K├Ânig
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, see <http://www.gnu.org/licenses/>.
17  
18     File: tX_seqpar.h
19  
20     Description: Header to tX_seqpar.cc
21 */    
22
23 #include <pthread.h>
24 #include <list>
25 #include <gtk/gtk.h>
26 #include "tX_extdial.h"
27 #include "tX_midiin.h"
28 #include "tX_global.h"
29
30 #ifndef _tx_seqpar_h
31 #define _tx_seqpar_h 1
32
33 #define NO_MOUSE_MAPPING 0
34 #define MOUSE_MAPPING_OK 1
35
36 #include <libxml/xmlmemory.h>
37 #include <libxml/parser.h>
38
39 /* required for gcc>=3.0 */
40 using namespace std;
41
42 class tX_seqpar
43 {       
44         public:
45         static list <tX_seqpar *> *all;
46         void *vtt; /* have to make this void as tX_vtt.h includes this */
47
48         tX_midievent bound_midi_event;
49
50         protected:
51         static list <tX_seqpar *> *update;
52         static pthread_mutex_t update_lock;
53                 
54         int touched;
55         int gui_active;
56         
57         float fwd_value;
58         
59         guint32 persistence_id;
60         guint32 touch_timestamp;
61         bool reverse_midi;
62         void *last_event_recorded;
63         
64         public:
65         /* default constructor */
66         tX_seqpar();
67         
68         virtual float get_value();
69         void set_mapping_parameters(float max, float min, float scale, int mappable);
70         virtual ~tX_seqpar();
71         
72         void set_vtt(void *);
73         int is_touched() {return touched;}
74         int is_untouched() {return !touched;}
75         
76         bool get_reverse_midi() {return reverse_midi;}
77         void set_reverse_midi(bool reverse) {reverse_midi=reverse;}
78         
79         void do_touch(); /* can't be inline as requires tX_sequencer.h */
80         void touch() { if (!touched) do_touch();}
81         void untouch() { touched=0; last_event_recorded=NULL; }
82         
83         static void untouch_all();
84         
85         int is_gui_active() { return gui_active; }
86         guint32 get_touch_timestamp() { return touch_timestamp; }
87         
88         static void create_persistence_ids();
89         guint32 get_persistence_id() { return persistence_id; }
90         void set_persistence_id(guint32 pid) { persistence_id=pid; }
91         static tX_seqpar *get_sp_by_persistence_id(unsigned int pid);
92
93         void record_value (const float value);
94         virtual void do_exec(const float value)=0;
95         virtual void exec_value(const float value)=0;   
96         virtual void do_update_graphics()=0;
97         void update_graphics(bool gtk_flush = false);
98         static void update_all_graphics();
99         static void init_all_graphics();
100         
101         /* slot for gui actions */
102         void receive_gui_value(const float value); 
103         
104         /* slot for fastforwarding (no effect for vtt) */
105         virtual void receive_forward_value(const float value);
106         
107         /* slot for mouse and keyboard actions (updating graphics) */
108         virtual void handle_mouse_input(float adjustment);
109         void receive_input_value(const float value);
110 #ifdef USE_ALSA_MIDI_IN 
111         virtual void handle_midi_input( const tX_midievent& );
112 #endif  
113         
114         /* Make it so ;) */
115         static void materialize_forward_values();
116
117         /* info functions for the editor */
118         const char *get_vtt_name();
119         virtual const char *get_name(); 
120         
121         /* For Mouse and MIDI Mapping */
122         protected:
123         float max_value;
124         float min_value;
125         float scale_value;
126
127         bool midi_upper_bound_set;
128         double midi_upper_bound;
129         
130         bool midi_lower_bound_set;
131         double midi_lower_bound;
132         
133         bool is_boolean;
134         
135         public:
136         int is_mappable;        
137         void restore_meta(xmlNodePtr node);
138         void store_meta(FILE *rc, gzFile rz);
139         
140         void set_upper_midi_bound(double val) {
141                 midi_upper_bound=val;
142                 midi_upper_bound_set=true;              
143         }
144         
145         void reset_upper_midi_bound() { midi_upper_bound_set=false; }
146
147         void set_lower_midi_bound(double val) {
148                 midi_lower_bound=val;
149                 midi_lower_bound_set=true;              
150         }
151         
152         void reset_lower_midi_bound() { midi_lower_bound_set=false; }
153         
154         static gboolean tX_seqpar_press(GtkWidget *widget, GdkEventButton *event, gpointer data);
155         
156 #ifdef USE_ALSA_MIDI_IN 
157         static gboolean reverse_midi_binding(GtkWidget *widget, gpointer data);
158         
159         static gboolean remove_midi_binding(GtkWidget *widget, gpointer data);
160         static gboolean learn_midi_binding(GtkWidget *widget, gpointer data);   
161         
162         static gboolean set_midi_upper_bound(GtkWidget *widget, gpointer data);
163         static gboolean reset_midi_upper_bound(GtkWidget *widget, gpointer data);
164         
165         static gboolean set_midi_lower_bound(GtkWidget *widget, gpointer data);
166         static gboolean reset_midi_lower_bound(GtkWidget *widget, gpointer data);       
167 #endif  
168 };
169
170 class tX_seqpar_update : public tX_seqpar
171 {
172         public:
173         virtual void exec_value(const float value);     
174 };
175
176 class tX_seqpar_no_update : public tX_seqpar
177 {
178         virtual void do_update_graphics();
179         virtual void exec_value(const float value);     
180 };
181
182 class tX_seqpar_update_active_forward : public tX_seqpar_update
183 {
184         virtual void receive_forward_value(const float value);
185 };
186
187 class tX_seqpar_no_update_active_forward : public tX_seqpar_no_update
188 {
189         virtual void receive_forward_value(const float value);
190 };
191
192 /* now the classes for *real* sequenceable parameters */
193
194 class tX_seqpar_master_volume : public tX_seqpar_update
195 {
196         public:
197         tX_seqpar_master_volume();
198         virtual void do_exec(const float value);
199         virtual void do_update_graphics();      
200         private:
201         virtual const char *get_name(); 
202 };
203
204 class tX_seqpar_master_pitch : public tX_seqpar_update_active_forward
205 {
206         public:
207         tX_seqpar_master_pitch();
208         virtual void do_exec(const float value);
209         virtual void do_update_graphics();      
210         private:
211     virtual const char *get_name(); 
212 };
213
214 class tX_seqpar_vtt_speed : public tX_seqpar_no_update_active_forward
215 {
216         public:
217         tX_seqpar_vtt_speed();
218         virtual void handle_mouse_input(float adjustment);
219         private:        
220         virtual void do_exec(const float value);
221         virtual const char *get_name(); 
222 };
223
224 class tX_seqpar_spin : public tX_seqpar_no_update_active_forward
225 {
226         public:
227         tX_seqpar_spin();
228         private:        
229         virtual void do_exec(const float value);
230         virtual const char *get_name(); 
231 };
232
233 class tX_seqpar_vtt_volume : public tX_seqpar_update
234 {
235         public:
236         tX_seqpar_vtt_volume();
237         virtual float get_value();
238         private:        
239         virtual void do_exec(const float value);
240         virtual void do_update_graphics();      
241         virtual const char *get_name(); 
242 };
243
244 class tX_seqpar_vtt_pan : public tX_seqpar_update
245 {
246         public:
247         tX_seqpar_vtt_pan();
248         virtual float get_value();
249         private:        
250         virtual void do_exec(const float value);
251         virtual void do_update_graphics();      
252         virtual const char *get_name(); 
253 };
254
255 class tX_seqpar_vtt_pitch : public tX_seqpar_update_active_forward
256 {
257         public:
258         tX_seqpar_vtt_pitch();
259         virtual float get_value();
260         virtual void do_exec(const float value);
261         private:        
262         virtual void do_update_graphics();      
263         virtual const char *get_name(); 
264 };
265
266 class tX_seqpar_vtt_trigger : public tX_seqpar_no_update_active_forward
267 {
268         public:
269         tX_seqpar_vtt_trigger();
270         private:        
271         virtual void do_exec(const float value);
272         virtual const char *get_name(); 
273 };
274
275 class tX_seqpar_vtt_loop : public tX_seqpar_update
276 {
277         public:
278         tX_seqpar_vtt_loop();
279         private:        
280         virtual void do_exec(const float value);
281         virtual void do_update_graphics();      
282         virtual const char *get_name(); 
283 };
284
285 class tX_seqpar_vtt_sync_client : public tX_seqpar_update
286 {
287         public:
288         tX_seqpar_vtt_sync_client();
289         private:        
290         virtual void do_exec(const float value);
291         virtual void do_update_graphics();      
292         virtual const char *get_name(); 
293 };
294
295 class tX_seqpar_vtt_sync_cycles : public tX_seqpar_update
296 {
297         public:
298         tX_seqpar_vtt_sync_cycles();
299         private:        
300         virtual void do_exec(const float value);
301         virtual void do_update_graphics();      
302         virtual const char *get_name(); 
303 };
304
305 class tX_seqpar_vtt_lp_enable : public tX_seqpar_update
306 {
307         public:
308         tX_seqpar_vtt_lp_enable();
309         private:        
310         virtual void do_exec(const float value);
311         virtual void do_update_graphics();      
312         virtual const char *get_name(); 
313 };
314
315 class tX_seqpar_vtt_lp_gain : public tX_seqpar_update
316 {
317         public:
318         tX_seqpar_vtt_lp_gain();
319         virtual float get_value();
320         private:        
321         virtual void do_exec(const float value);
322         virtual void do_update_graphics();      
323         virtual const char *get_name(); 
324 };
325
326 class tX_seqpar_vtt_lp_reso : public tX_seqpar_update
327 {
328         public:
329         tX_seqpar_vtt_lp_reso();
330         virtual float get_value();
331         private:        
332         virtual void do_exec(const float value);
333         virtual void do_update_graphics();      
334         virtual const char *get_name(); 
335 };
336
337 class tX_seqpar_vtt_lp_freq : public tX_seqpar_update
338 {
339         public:
340         virtual float get_value();
341         tX_seqpar_vtt_lp_freq();
342         private:        
343         virtual void do_exec(const float value);
344         virtual void do_update_graphics();      
345         virtual const char *get_name(); 
346 };
347
348 class tX_seqpar_vtt_ec_enable : public tX_seqpar_update
349 {
350         public:
351         tX_seqpar_vtt_ec_enable();
352         private:        
353         virtual void do_exec(const float value);
354         virtual void do_update_graphics();      
355         virtual const char *get_name(); 
356 };
357
358 class tX_seqpar_vtt_ec_length : public tX_seqpar_update
359 {
360         public:
361         tX_seqpar_vtt_ec_length();
362         virtual float get_value();
363         private:        
364         virtual void do_exec(const float value);
365         virtual void do_update_graphics();      
366         virtual const char *get_name(); 
367 };
368
369 class tX_seqpar_vtt_ec_feedback : public tX_seqpar_update
370 {
371         public:
372         tX_seqpar_vtt_ec_feedback();
373         virtual float get_value();
374         private:        
375         virtual void do_exec(const float value);
376         virtual void do_update_graphics();      
377         virtual const char *get_name(); 
378 };
379
380 class tX_seqpar_vtt_ec_pan : public tX_seqpar_update
381 {
382         public:
383         tX_seqpar_vtt_ec_pan();
384         virtual float get_value();
385         private:        
386         virtual void do_exec(const float value);
387         virtual void do_update_graphics();      
388         virtual const char *get_name(); 
389 };
390
391 class tX_seqpar_vtt_ec_volume : public tX_seqpar_update
392 {
393         public:
394         tX_seqpar_vtt_ec_volume();
395         virtual float get_value();
396         private:        
397         virtual void do_exec(const float value);
398         virtual void do_update_graphics();      
399         virtual const char *get_name(); 
400 };
401
402 class tX_seqpar_vtt_mute : public tX_seqpar_no_update
403 {
404         public:
405         tX_seqpar_vtt_mute();
406         private:        
407         virtual void do_exec(const float value);
408         virtual const char *get_name(); 
409 };
410
411 /* Seqpars for the LADSPA Plugins */
412
413 class tX_seqpar_vttfx : public tX_seqpar_update
414 {
415         /* fx_value will be malloc()ed by constructor */        
416         protected:
417         GtkWidget *widget;
418         char label_name[2048];
419         char name[2048];
420         float *fx_value;
421         
422         public:
423         tX_seqpar_vttfx();
424         virtual ~tX_seqpar_vttfx();
425         void set_name(const char *, const char *);
426         GtkWidget *get_widget() { return widget; } 
427         
428         virtual float get_value();
429         float *get_value_ptr() { return fx_value; }
430         
431         private:
432         virtual void create_widget();
433         
434         public:
435         virtual const char *get_name();         
436 };
437
438 class tX_seqpar_vttfx_float : public tX_seqpar_vttfx
439 {
440         private:
441         tX_extdial *mydial;
442         GtkAdjustment *myadj;
443         
444         virtual void create_widget();
445         virtual void do_exec(const float value);
446         virtual void do_update_graphics();              
447         public:
448         virtual ~tX_seqpar_vttfx_float();
449         
450         static GCallback gtk_callback(GtkWidget*, tX_seqpar_vttfx_float *);
451 };
452
453 class tX_seqpar_vttfx_bool : public tX_seqpar_vttfx
454 {
455         private:
456         virtual void create_widget();
457         virtual void do_exec(const float value);
458         virtual void do_update_graphics();      
459
460         static GCallback gtk_callback(GtkWidget*, tX_seqpar_vttfx_bool *);
461
462         public:
463         virtual ~tX_seqpar_vttfx_bool();
464 };
465
466 class tX_seqpar_vttfx_int : public tX_seqpar_vttfx
467 {
468         private:
469         GtkAdjustment *myadj;
470
471         private:
472         virtual void create_widget();
473         virtual void do_exec(const float value);
474         virtual void do_update_graphics();      
475
476         public:
477         virtual ~tX_seqpar_vttfx_int();
478
479         static GCallback gtk_callback(GtkWidget*, tX_seqpar_vttfx_int *);
480 };
481
482 #endif