MIDI set_sync_client fix, cleanups, compilation fixes for gcc 2.95 - Alex
[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         
159 #ifdef USE_ALSA_MIDI_IN 
160         static gboolean remove_midi_binding(GtkWidget *widget, gpointer data);
161         static gboolean learn_midi_binding(GtkWidget *widget, gpointer data);   
162         
163         static gboolean set_midi_upper_bound(GtkWidget *widget, gpointer data);
164         static gboolean reset_midi_upper_bound(GtkWidget *widget, gpointer data);
165         
166         static gboolean set_midi_lower_bound(GtkWidget *widget, gpointer data);
167         static gboolean reset_midi_lower_bound(GtkWidget *widget, gpointer data);       
168 #endif  
169 };
170
171 class tX_seqpar_update : public tX_seqpar
172 {
173         public:
174         virtual void exec_value(const float value);     
175 };
176
177 class tX_seqpar_no_update : public tX_seqpar
178 {
179         virtual void do_update_graphics();
180         virtual void exec_value(const float value);     
181 };
182
183 class tX_seqpar_update_active_forward : public tX_seqpar_update
184 {
185         virtual void receive_forward_value(const float value);
186 };
187
188 class tX_seqpar_no_update_active_forward : public tX_seqpar_no_update
189 {
190         virtual void receive_forward_value(const float value);
191 };
192
193 /* now the classes for *real* sequenceable parameters */
194
195 class tX_seqpar_master_volume : public tX_seqpar_update
196 {
197         public:
198         tX_seqpar_master_volume();
199         virtual void do_exec(const float value);
200         virtual void do_update_graphics();      
201         private:
202         virtual const char *get_name(); 
203 };
204
205 class tX_seqpar_master_pitch : public tX_seqpar_update_active_forward
206 {
207         public:
208         tX_seqpar_master_pitch();
209         virtual void do_exec(const float value);
210         virtual void do_update_graphics();      
211         private:
212     virtual const char *get_name(); 
213 };
214
215 class tX_seqpar_vtt_speed : public tX_seqpar_no_update_active_forward
216 {
217         public:
218         tX_seqpar_vtt_speed();
219         virtual void handle_mouse_input(float adjustment);
220         private:        
221         virtual void do_exec(const float value);
222         virtual const char *get_name(); 
223 };
224
225 class tX_seqpar_spin : public tX_seqpar_no_update_active_forward
226 {
227         public:
228         tX_seqpar_spin();
229         private:        
230         virtual void do_exec(const float value);
231         virtual const char *get_name(); 
232 };
233
234 class tX_seqpar_vtt_volume : public tX_seqpar_update
235 {
236         public:
237         tX_seqpar_vtt_volume();
238         virtual float get_value();
239         private:        
240         virtual void do_exec(const float value);
241         virtual void do_update_graphics();      
242         virtual const char *get_name(); 
243 };
244
245 class tX_seqpar_vtt_pan : public tX_seqpar_update
246 {
247         public:
248         tX_seqpar_vtt_pan();
249         virtual float get_value();
250         private:        
251         virtual void do_exec(const float value);
252         virtual void do_update_graphics();      
253         virtual const char *get_name(); 
254 };
255
256 class tX_seqpar_vtt_pitch : public tX_seqpar_update_active_forward
257 {
258         public:
259         tX_seqpar_vtt_pitch();
260         virtual float get_value();
261         virtual void do_exec(const float value);
262         private:        
263         virtual void do_update_graphics();      
264         virtual const char *get_name(); 
265 };
266
267 class tX_seqpar_vtt_trigger : public tX_seqpar_no_update_active_forward
268 {
269         public:
270         tX_seqpar_vtt_trigger();
271         private:        
272         virtual void do_exec(const float value);
273         virtual const char *get_name(); 
274 };
275
276 class tX_seqpar_vtt_loop : public tX_seqpar_update
277 {
278         public:
279         tX_seqpar_vtt_loop();
280         private:        
281         virtual void do_exec(const float value);
282         virtual void do_update_graphics();      
283         virtual const char *get_name(); 
284 };
285
286 class tX_seqpar_vtt_sync_client : public tX_seqpar_update
287 {
288         public:
289         tX_seqpar_vtt_sync_client();
290         private:        
291         virtual void do_exec(const float value);
292         virtual void do_update_graphics();      
293         virtual const char *get_name(); 
294 };
295
296 class tX_seqpar_vtt_sync_cycles : public tX_seqpar_update
297 {
298         public:
299         tX_seqpar_vtt_sync_cycles();
300         private:        
301         virtual void do_exec(const float value);
302         virtual void do_update_graphics();      
303         virtual const char *get_name(); 
304 };
305
306 class tX_seqpar_vtt_lp_enable : public tX_seqpar_update
307 {
308         public:
309         tX_seqpar_vtt_lp_enable();
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_lp_gain : public tX_seqpar_update
317 {
318         public:
319         tX_seqpar_vtt_lp_gain();
320         virtual float get_value();
321         private:        
322         virtual void do_exec(const float value);
323         virtual void do_update_graphics();      
324         virtual const char *get_name(); 
325 };
326
327 class tX_seqpar_vtt_lp_reso : public tX_seqpar_update
328 {
329         public:
330         tX_seqpar_vtt_lp_reso();
331         virtual float get_value();
332         private:        
333         virtual void do_exec(const float value);
334         virtual void do_update_graphics();      
335         virtual const char *get_name(); 
336 };
337
338 class tX_seqpar_vtt_lp_freq : public tX_seqpar_update
339 {
340         public:
341         virtual float get_value();
342         tX_seqpar_vtt_lp_freq();
343         private:        
344         virtual void do_exec(const float value);
345         virtual void do_update_graphics();      
346         virtual const char *get_name(); 
347 };
348
349 class tX_seqpar_vtt_ec_enable : public tX_seqpar_update
350 {
351         public:
352         tX_seqpar_vtt_ec_enable();
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_length : public tX_seqpar_update
360 {
361         public:
362         tX_seqpar_vtt_ec_length();
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_ec_feedback : public tX_seqpar_update
371 {
372         public:
373         tX_seqpar_vtt_ec_feedback();
374         virtual float get_value();
375         private:        
376         virtual void do_exec(const float value);
377         virtual void do_update_graphics();      
378         virtual const char *get_name(); 
379 };
380
381 class tX_seqpar_vtt_ec_pan : public tX_seqpar_update
382 {
383         public:
384         tX_seqpar_vtt_ec_pan();
385         virtual float get_value();
386         private:        
387         virtual void do_exec(const float value);
388         virtual void do_update_graphics();      
389         virtual const char *get_name(); 
390 };
391
392 class tX_seqpar_vtt_ec_volume : public tX_seqpar_update
393 {
394         public:
395         tX_seqpar_vtt_ec_volume();
396         virtual float get_value();
397         private:        
398         virtual void do_exec(const float value);
399         virtual void do_update_graphics();      
400         virtual const char *get_name(); 
401 };
402
403 class tX_seqpar_vtt_mute : public tX_seqpar_no_update
404 {
405         public:
406         tX_seqpar_vtt_mute();
407         private:        
408         virtual void do_exec(const float value);
409         virtual const char *get_name(); 
410 };
411
412 /* Seqpars for the LADSPA Plugins */
413
414 class tX_seqpar_vttfx : public tX_seqpar_update
415 {
416         /* fx_value will be malloc()ed by constructor */        
417         protected:
418         GtkWidget *widget;
419         char label_name[2048];
420         char name[2048];
421         float *fx_value;
422         
423         public:
424         tX_seqpar_vttfx();
425         virtual ~tX_seqpar_vttfx();
426         void set_name(const char *, const char *);
427         GtkWidget *get_widget() { return widget; } 
428         
429         virtual float get_value();
430         float *get_value_ptr() { return fx_value; }
431         
432         private:
433         virtual void create_widget();
434         
435         public:
436         virtual const char *get_name();         
437 };
438
439 class tX_seqpar_vttfx_float : public tX_seqpar_vttfx
440 {
441         private:
442         tX_extdial *mydial;
443         GtkAdjustment *myadj;
444         
445         virtual void create_widget();
446         virtual void do_exec(const float value);
447         virtual void do_update_graphics();              
448         public:
449         virtual ~tX_seqpar_vttfx_float();
450         
451         static GtkSignalFunc gtk_callback(GtkWidget*, tX_seqpar_vttfx_float *);
452 };
453
454 class tX_seqpar_vttfx_bool : public tX_seqpar_vttfx
455 {
456         private:
457         virtual void create_widget();
458         virtual void do_exec(const float value);
459         virtual void do_update_graphics();      
460
461         static GtkSignalFunc gtk_callback(GtkWidget*, tX_seqpar_vttfx_bool *);
462
463         public:
464         virtual ~tX_seqpar_vttfx_bool();
465 };
466
467 class tX_seqpar_vttfx_int : public tX_seqpar_vttfx
468 {
469         private:
470         GtkAdjustment *myadj;
471
472         private:
473         virtual void create_widget();
474         virtual void do_exec(const float value);
475         virtual void do_update_graphics();      
476
477         public:
478         virtual ~tX_seqpar_vttfx_int();
479
480         static GtkSignalFunc gtk_callback(GtkWidget*, tX_seqpar_vttfx_int *);
481 };
482
483 #endif