c53cfe685342975bffc62409117619a6ace9b6e6
[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
29 #ifndef _tx_seqpar_h
30 #define _tx_seqpar_h 1
31
32 #define NO_MOUSE_MAPPING 0
33 #define MOUSE_MAPPING_OK 1
34
35 /* required for gcc>=3.0 */
36 using namespace std;
37
38 class tX_seqpar
39 {       
40         public:
41         static list <tX_seqpar *> all;
42         void *vtt; /* have to make this void as tX_vtt.h includes this */
43         protected:
44         static list <tX_seqpar *> update;
45         static pthread_mutex_t update_lock;
46                 
47         int touched;
48         int gui_active;
49         
50         float fwd_value;
51         
52         guint32 persistence_id;
53         guint32 touch_timestamp;                
54         void *last_event_recorded;
55
56         void default_constructor();
57         
58         public:
59         /* default constructor */
60         tX_seqpar();
61         /* to initialize with a vtt 
62         tX_seqpar(void *); */
63         /* to initialize with mapping settings */
64         /* tX_seqpar(float max, float min, float scale, int mappable); */
65         /* to initialize with mapping settings AND a vtt 
66         tX_seqpar (void *mytt, float max, float min, float scale, int mappable); */
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         void do_touch(); /* can't be inline as requires tX_sequencer.h */
77         void touch() { if (!touched) do_touch();}
78         void untouch() { touched=0; last_event_recorded=NULL; }
79         
80         static void untouch_all();
81         
82         int is_gui_active() { return gui_active; }
83         guint32 get_touch_timestamp() { return touch_timestamp; }
84         
85         static void create_persistence_ids();
86         guint32 get_persistence_id() { return persistence_id; }
87         unsigned int set_persistence_id(guint32 pid) { persistence_id=pid; }
88         static tX_seqpar *get_sp_by_persistence_id(int pid);
89
90         void record_value (const float value);
91         virtual void do_exec(const float value);
92         virtual void exec_value(const float value);     
93         virtual void do_update_graphics();
94         void update_graphics();
95         static void update_all_graphics();
96         static void init_all_graphics();
97         
98         /* slot for gui actions */
99         void receive_gui_value(const float value); 
100         
101         /* slot for fastforwarding (no effect for vtt) */
102         virtual void receive_forward_value(const float value);
103         
104         /* slot for mouse and keyboard actions (updating graphics) */
105         virtual void handle_mouse_input(float adjustment);
106         void receive_input_value(const float value); 
107         
108         /* Make it so ;) */
109         static void materialize_forward_values();
110
111         /* info functions for the editor */
112         char *get_vtt_name();
113         virtual const char *get_name(); 
114         
115         /* For Mouse and MIDI Mapping */
116         protected:
117         float max_value;
118         float min_value;
119         float scale_value;
120         public:
121         int is_mappable;        
122 };
123
124 class tX_seqpar_update : public tX_seqpar
125 {
126         public:
127         virtual void exec_value(const float value);     
128 };
129
130 class tX_seqpar_no_update : public tX_seqpar
131 {
132         virtual void do_update_graphics();
133         virtual void exec_value(const float value);     
134 };
135
136 class tX_seqpar_update_active_forward : public tX_seqpar_update
137 {
138         virtual void receive_forward_value(const float value);
139 };
140
141 class tX_seqpar_no_update_active_forward : public tX_seqpar_no_update
142 {
143         virtual void receive_forward_value(const float value);
144 };
145
146 /* now the classes for *real* sequenceable parameters */
147
148 class tX_seqpar_master_volume : public tX_seqpar_update
149 {
150         public:
151         tX_seqpar_master_volume();
152         private:
153         virtual void do_exec(const float value);
154         virtual void do_update_graphics();      
155         virtual const char *get_name(); 
156 };
157
158 class tX_seqpar_master_pitch : public tX_seqpar_update_active_forward
159 {
160         public:
161         tX_seqpar_master_pitch();
162         private:
163         virtual void do_exec(const float value);
164         virtual void do_update_graphics();      
165         virtual const char *get_name(); 
166 };
167
168 class tX_seqpar_vtt_speed : public tX_seqpar_no_update_active_forward
169 {
170         public:
171         tX_seqpar_vtt_speed();
172         virtual void handle_mouse_input(float adjustment);
173         private:        
174         virtual void do_exec(const float value);
175         virtual const char *get_name(); 
176 };
177
178 class tX_seqpar_spin : public tX_seqpar_no_update_active_forward
179 {
180         public:
181         tX_seqpar_spin();
182         private:        
183         virtual void do_exec(const float value);
184         virtual const char *get_name(); 
185 };
186
187 class tX_seqpar_vtt_volume : public tX_seqpar_update
188 {
189         public:
190         tX_seqpar_vtt_volume();
191         virtual float get_value();
192         private:        
193         virtual void do_exec(const float value);
194         virtual void do_update_graphics();      
195         virtual const char *get_name(); 
196 };
197
198 class tX_seqpar_vtt_pan : public tX_seqpar_update
199 {
200         public:
201         tX_seqpar_vtt_pan();
202         virtual float get_value();
203         private:        
204         virtual void do_exec(const float value);
205         virtual void do_update_graphics();      
206         virtual const char *get_name(); 
207 };
208
209 class tX_seqpar_vtt_pitch : public tX_seqpar_update_active_forward
210 {
211         public:
212         tX_seqpar_vtt_pitch();
213         virtual float get_value();
214         private:        
215         virtual void do_exec(const float value);
216         virtual void do_update_graphics();      
217         virtual const char *get_name(); 
218 };
219
220 class tX_seqpar_vtt_trigger : public tX_seqpar_no_update_active_forward
221 {
222         public:
223         tX_seqpar_vtt_trigger();
224         private:        
225         virtual void do_exec(const float value);
226         virtual const char *get_name(); 
227 };
228
229 class tX_seqpar_vtt_loop : public tX_seqpar_update
230 {
231         public:
232         tX_seqpar_vtt_loop();
233         private:        
234         virtual void do_exec(const float value);
235         virtual void do_update_graphics();      
236         virtual const char *get_name(); 
237 };
238
239 class tX_seqpar_vtt_sync_client : public tX_seqpar_update
240 {
241         public:
242         tX_seqpar_vtt_sync_client();
243         private:        
244         virtual void do_exec(const float value);
245         virtual void do_update_graphics();      
246         virtual const char *get_name(); 
247 };
248
249 class tX_seqpar_vtt_sync_cycles : public tX_seqpar_update
250 {
251         public:
252         tX_seqpar_vtt_sync_cycles();
253         private:        
254         virtual void do_exec(const float value);
255         virtual void do_update_graphics();      
256         virtual const char *get_name(); 
257 };
258
259 class tX_seqpar_vtt_lp_enable : public tX_seqpar_update
260 {
261         public:
262         tX_seqpar_vtt_lp_enable();
263         private:        
264         virtual void do_exec(const float value);
265         virtual void do_update_graphics();      
266         virtual const char *get_name(); 
267 };
268
269 class tX_seqpar_vtt_lp_gain : public tX_seqpar_update
270 {
271         public:
272         tX_seqpar_vtt_lp_gain();
273         virtual float get_value();
274         private:        
275         virtual void do_exec(const float value);
276         virtual void do_update_graphics();      
277         virtual const char *get_name(); 
278 };
279
280 class tX_seqpar_vtt_lp_reso : public tX_seqpar_update
281 {
282         public:
283         tX_seqpar_vtt_lp_reso();
284         virtual float get_value();
285         private:        
286         virtual void do_exec(const float value);
287         virtual void do_update_graphics();      
288         virtual const char *get_name(); 
289 };
290
291 class tX_seqpar_vtt_lp_freq : public tX_seqpar_update
292 {
293         public:
294         virtual float get_value();
295         tX_seqpar_vtt_lp_freq();
296         private:        
297         virtual void do_exec(const float value);
298         virtual void do_update_graphics();      
299         virtual const char *get_name(); 
300 };
301
302 class tX_seqpar_vtt_ec_enable : public tX_seqpar_update
303 {
304         public:
305         tX_seqpar_vtt_ec_enable();
306         private:        
307         virtual void do_exec(const float value);
308         virtual void do_update_graphics();      
309         virtual const char *get_name(); 
310 };
311
312 class tX_seqpar_vtt_ec_length : public tX_seqpar_update
313 {
314         public:
315         tX_seqpar_vtt_ec_length();
316         virtual float get_value();
317         private:        
318         virtual void do_exec(const float value);
319         virtual void do_update_graphics();      
320         virtual const char *get_name(); 
321 };
322
323 class tX_seqpar_vtt_ec_feedback : public tX_seqpar_update
324 {
325         public:
326         tX_seqpar_vtt_ec_feedback();
327         virtual float get_value();
328         private:        
329         virtual void do_exec(const float value);
330         virtual void do_update_graphics();      
331         virtual const char *get_name(); 
332 };
333
334 class tX_seqpar_vtt_ec_pan : public tX_seqpar_update
335 {
336         public:
337         tX_seqpar_vtt_ec_pan();
338         virtual float get_value();
339         private:        
340         virtual void do_exec(const float value);
341         virtual void do_update_graphics();      
342         virtual const char *get_name(); 
343 };
344
345 class tX_seqpar_vtt_ec_volume : public tX_seqpar_update
346 {
347         public:
348         tX_seqpar_vtt_ec_volume();
349         virtual float get_value();
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_mute : public tX_seqpar_no_update
357 {
358         public:
359         tX_seqpar_vtt_mute();
360         private:        
361         virtual void do_exec(const float value);
362         virtual const char *get_name(); 
363 };
364
365 /* Seqpars for the LADSPA Plugins */
366
367 class tX_seqpar_vttfx : public tX_seqpar_update
368 {
369         /* fx_value will be malloc()ed by constructor */        
370         protected:
371         GtkWidget *widget;
372         char label_name[2048];
373         char name[2048];
374         float *fx_value;
375         
376         public:
377         tX_seqpar_vttfx();
378         virtual ~tX_seqpar_vttfx();
379         void set_name(const char *, const char *);
380         GtkWidget *get_widget() { return widget; } 
381         
382         virtual float get_value();
383         float *get_value_ptr() { return fx_value; }
384         
385         private:
386         virtual void create_widget();
387         virtual const char *get_name();         
388 };
389
390 class tX_seqpar_vttfx_float : public tX_seqpar_vttfx
391 {
392         private:
393         tX_extdial *mydial;
394         GtkAdjustment *myadj;
395         
396         virtual void create_widget();
397         virtual void do_exec(const float value);
398         virtual void do_update_graphics();              
399         public:
400         virtual ~tX_seqpar_vttfx_float();
401         
402         static GtkSignalFunc gtk_callback(GtkWidget*, tX_seqpar_vttfx_float *);
403 };
404
405 class tX_seqpar_vttfx_bool : public tX_seqpar_vttfx
406 {
407         private:
408         virtual void create_widget();
409         virtual void do_exec(const float value);
410         virtual void do_update_graphics();      
411
412         static GtkSignalFunc gtk_callback(GtkWidget*, tX_seqpar_vttfx_bool *);
413
414         public:
415         virtual ~tX_seqpar_vttfx_bool();
416 };
417
418 class tX_seqpar_vttfx_int : public tX_seqpar_vttfx
419 {
420         private:
421         GtkAdjustment *myadj;
422
423         private:
424         virtual void create_widget();
425         virtual void do_exec(const float value);
426         virtual void do_update_graphics();      
427
428         public:
429         virtual ~tX_seqpar_vttfx_int();
430
431         static GtkSignalFunc gtk_callback(GtkWidget*, tX_seqpar_vttfx_int *);
432 };
433 #endif 
434
435
436
437