Adding support for writing zlib compressed set files and fixing audio
[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);
98         virtual void exec_value(const float value);     
99         virtual void do_update_graphics();
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 is_boolean;
131         
132         public:
133         int is_mappable;        
134         void restore_meta(xmlNodePtr node);
135         void store_meta(FILE *rc, gzFile rz);
136 };
137
138 class tX_seqpar_update : public tX_seqpar
139 {
140         public:
141         virtual void exec_value(const float value);     
142 };
143
144 class tX_seqpar_no_update : public tX_seqpar
145 {
146         virtual void do_update_graphics();
147         virtual void exec_value(const float value);     
148 };
149
150 class tX_seqpar_update_active_forward : public tX_seqpar_update
151 {
152         virtual void receive_forward_value(const float value);
153 };
154
155 class tX_seqpar_no_update_active_forward : public tX_seqpar_no_update
156 {
157         virtual void receive_forward_value(const float value);
158 };
159
160 /* now the classes for *real* sequenceable parameters */
161
162 class tX_seqpar_master_volume : public tX_seqpar_update
163 {
164         public:
165         tX_seqpar_master_volume();
166         private:
167         virtual void do_exec(const float value);
168         virtual void do_update_graphics();      
169         virtual const char *get_name(); 
170 };
171
172 class tX_seqpar_master_pitch : public tX_seqpar_update_active_forward
173 {
174         public:
175         tX_seqpar_master_pitch();
176         private:
177         virtual void do_exec(const float value);
178         virtual void do_update_graphics();      
179         virtual const char *get_name(); 
180 };
181
182 class tX_seqpar_vtt_speed : public tX_seqpar_no_update_active_forward
183 {
184         public:
185         tX_seqpar_vtt_speed();
186         virtual void handle_mouse_input(float adjustment);
187         private:        
188         virtual void do_exec(const float value);
189         virtual const char *get_name(); 
190 };
191
192 class tX_seqpar_spin : public tX_seqpar_no_update_active_forward
193 {
194         public:
195         tX_seqpar_spin();
196         private:        
197         virtual void do_exec(const float value);
198         virtual const char *get_name(); 
199 };
200
201 class tX_seqpar_vtt_volume : public tX_seqpar_update
202 {
203         public:
204         tX_seqpar_vtt_volume();
205         virtual float get_value();
206         private:        
207         virtual void do_exec(const float value);
208         virtual void do_update_graphics();      
209         virtual const char *get_name(); 
210 };
211
212 class tX_seqpar_vtt_pan : public tX_seqpar_update
213 {
214         public:
215         tX_seqpar_vtt_pan();
216         virtual float get_value();
217         private:        
218         virtual void do_exec(const float value);
219         virtual void do_update_graphics();      
220         virtual const char *get_name(); 
221 };
222
223 class tX_seqpar_vtt_pitch : public tX_seqpar_update_active_forward
224 {
225         public:
226         tX_seqpar_vtt_pitch();
227         virtual float get_value();
228         private:        
229         virtual void do_exec(const float value);
230         virtual void do_update_graphics();      
231         virtual const char *get_name(); 
232 };
233
234 class tX_seqpar_vtt_trigger : public tX_seqpar_no_update_active_forward
235 {
236         public:
237         tX_seqpar_vtt_trigger();
238         private:        
239         virtual void do_exec(const float value);
240         virtual const char *get_name(); 
241 };
242
243 class tX_seqpar_vtt_loop : public tX_seqpar_update
244 {
245         public:
246         tX_seqpar_vtt_loop();
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_sync_client : public tX_seqpar_update
254 {
255         public:
256         tX_seqpar_vtt_sync_client();
257         private:        
258         virtual void do_exec(const float value);
259         virtual void do_update_graphics();      
260         virtual const char *get_name(); 
261 };
262
263 class tX_seqpar_vtt_sync_cycles : public tX_seqpar_update
264 {
265         public:
266         tX_seqpar_vtt_sync_cycles();
267         private:        
268         virtual void do_exec(const float value);
269         virtual void do_update_graphics();      
270         virtual const char *get_name(); 
271 };
272
273 class tX_seqpar_vtt_lp_enable : public tX_seqpar_update
274 {
275         public:
276         tX_seqpar_vtt_lp_enable();
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_lp_gain : public tX_seqpar_update
284 {
285         public:
286         tX_seqpar_vtt_lp_gain();
287         virtual float get_value();
288         private:        
289         virtual void do_exec(const float value);
290         virtual void do_update_graphics();      
291         virtual const char *get_name(); 
292 };
293
294 class tX_seqpar_vtt_lp_reso : public tX_seqpar_update
295 {
296         public:
297         tX_seqpar_vtt_lp_reso();
298         virtual float get_value();
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_freq : public tX_seqpar_update
306 {
307         public:
308         virtual float get_value();
309         tX_seqpar_vtt_lp_freq();
310         private:        
311         virtual void do_exec(const float value);
312         virtual void do_update_graphics();      
313         virtual const char *get_name(); 
314 };
315
316 class tX_seqpar_vtt_ec_enable : public tX_seqpar_update
317 {
318         public:
319         tX_seqpar_vtt_ec_enable();
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_ec_length : public tX_seqpar_update
327 {
328         public:
329         tX_seqpar_vtt_ec_length();
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_ec_feedback : public tX_seqpar_update
338 {
339         public:
340         tX_seqpar_vtt_ec_feedback();
341         virtual float get_value();
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_pan : public tX_seqpar_update
349 {
350         public:
351         tX_seqpar_vtt_ec_pan();
352         virtual float get_value();
353         private:        
354         virtual void do_exec(const float value);
355         virtual void do_update_graphics();      
356         virtual const char *get_name(); 
357 };
358
359 class tX_seqpar_vtt_ec_volume : public tX_seqpar_update
360 {
361         public:
362         tX_seqpar_vtt_ec_volume();
363         virtual float get_value();
364         private:        
365         virtual void do_exec(const float value);
366         virtual void do_update_graphics();      
367         virtual const char *get_name(); 
368 };
369
370 class tX_seqpar_vtt_mute : public tX_seqpar_no_update
371 {
372         public:
373         tX_seqpar_vtt_mute();
374         private:        
375         virtual void do_exec(const float value);
376         virtual const char *get_name(); 
377 };
378
379 /* Seqpars for the LADSPA Plugins */
380
381 class tX_seqpar_vttfx : public tX_seqpar_update
382 {
383         /* fx_value will be malloc()ed by constructor */        
384         protected:
385         GtkWidget *widget;
386         char label_name[2048];
387         char name[2048];
388         float *fx_value;
389         
390         public:
391         tX_seqpar_vttfx();
392         virtual ~tX_seqpar_vttfx();
393         void set_name(const char *, const char *);
394         GtkWidget *get_widget() { return widget; } 
395         
396         virtual float get_value();
397         float *get_value_ptr() { return fx_value; }
398         
399         private:
400         virtual void create_widget();
401         
402         public:
403         virtual const char *get_name();         
404 };
405
406 class tX_seqpar_vttfx_float : public tX_seqpar_vttfx
407 {
408         private:
409         tX_extdial *mydial;
410         GtkAdjustment *myadj;
411         
412         virtual void create_widget();
413         virtual void do_exec(const float value);
414         virtual void do_update_graphics();              
415         public:
416         virtual ~tX_seqpar_vttfx_float();
417         
418         static GtkSignalFunc gtk_callback(GtkWidget*, tX_seqpar_vttfx_float *);
419 };
420
421 class tX_seqpar_vttfx_bool : public tX_seqpar_vttfx
422 {
423         private:
424         virtual void create_widget();
425         virtual void do_exec(const float value);
426         virtual void do_update_graphics();      
427
428         static GtkSignalFunc gtk_callback(GtkWidget*, tX_seqpar_vttfx_bool *);
429
430         public:
431         virtual ~tX_seqpar_vttfx_bool();
432 };
433
434 class tX_seqpar_vttfx_int : public tX_seqpar_vttfx
435 {
436         private:
437         GtkAdjustment *myadj;
438
439         private:
440         virtual void create_widget();
441         virtual void do_exec(const float value);
442         virtual void do_update_graphics();      
443
444         public:
445         virtual ~tX_seqpar_vttfx_int();
446
447         static GtkSignalFunc gtk_callback(GtkWidget*, tX_seqpar_vttfx_int *);
448 };
449 #endif 
450
451
452
453