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