Making MIDI Mappings persistent - Alex
[terminatorX.git] / terminatorX / 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         void default_constructor();
65         
66         public:
67         /* default constructor */
68         tX_seqpar();
69         /* to initialize with a vtt 
70         tX_seqpar(void *); */
71         /* to initialize with mapping settings */
72         /* tX_seqpar(float max, float min, float scale, int mappable); */
73         /* to initialize with mapping settings AND a vtt 
74         tX_seqpar (void *mytt, float max, float min, float scale, int mappable); */
75         
76         virtual float get_value();
77         void set_mapping_parameters(float max, float min, float scale, int mappable);
78         virtual ~tX_seqpar();
79         
80         void set_vtt(void *);
81         int is_touched() {return touched;}
82         int is_untouched() {return !touched;}
83         
84         void do_touch(); /* can't be inline as requires tX_sequencer.h */
85         void touch() { if (!touched) do_touch();}
86         void untouch() { touched=0; last_event_recorded=NULL; }
87         
88         static void untouch_all();
89         
90         int is_gui_active() { return gui_active; }
91         guint32 get_touch_timestamp() { return touch_timestamp; }
92         
93         static void create_persistence_ids();
94         guint32 get_persistence_id() { return persistence_id; }
95         void set_persistence_id(guint32 pid) { persistence_id=pid; }
96         static tX_seqpar *get_sp_by_persistence_id(unsigned int pid);
97
98         void record_value (const float value);
99         virtual void do_exec(const float value);
100         virtual void exec_value(const float value);     
101         virtual void do_update_graphics();
102         void update_graphics();
103         static void update_all_graphics();
104         static void init_all_graphics();
105         
106         /* slot for gui actions */
107         void receive_gui_value(const float value); 
108         
109         /* slot for fastforwarding (no effect for vtt) */
110         virtual void receive_forward_value(const float value);
111         
112         /* slot for mouse and keyboard actions (updating graphics) */
113         virtual void handle_mouse_input(float adjustment);
114         void receive_input_value(const float value);
115 #ifdef USE_ALSA_MIDI_IN 
116         virtual void handle_midi_input( const tX_midievent& );
117 #endif  
118         
119         /* Make it so ;) */
120         static void materialize_forward_values();
121
122         /* info functions for the editor */
123         char *get_vtt_name();
124         virtual const char *get_name(); 
125         
126         /* For Mouse and MIDI Mapping */
127         protected:
128         float max_value;
129         float min_value;
130         float scale_value;
131
132         bool is_boolean;
133         
134         public:
135         int is_mappable;        
136         void restore_meta(xmlNodePtr node);
137         void store_meta(FILE *output);
138 };
139
140 class tX_seqpar_update : public tX_seqpar
141 {
142         public:
143         virtual void exec_value(const float value);     
144 };
145
146 class tX_seqpar_no_update : public tX_seqpar
147 {
148         virtual void do_update_graphics();
149         virtual void exec_value(const float value);     
150 };
151
152 class tX_seqpar_update_active_forward : public tX_seqpar_update
153 {
154         virtual void receive_forward_value(const float value);
155 };
156
157 class tX_seqpar_no_update_active_forward : public tX_seqpar_no_update
158 {
159         virtual void receive_forward_value(const float value);
160 };
161
162 /* now the classes for *real* sequenceable parameters */
163
164 class tX_seqpar_master_volume : public tX_seqpar_update
165 {
166         public:
167         tX_seqpar_master_volume();
168         private:
169         virtual void do_exec(const float value);
170         virtual void do_update_graphics();      
171         virtual const char *get_name(); 
172 };
173
174 class tX_seqpar_master_pitch : public tX_seqpar_update_active_forward
175 {
176         public:
177         tX_seqpar_master_pitch();
178         private:
179         virtual void do_exec(const float value);
180         virtual void do_update_graphics();      
181         virtual const char *get_name(); 
182 };
183
184 class tX_seqpar_vtt_speed : public tX_seqpar_no_update_active_forward
185 {
186         public:
187         tX_seqpar_vtt_speed();
188         virtual void handle_mouse_input(float adjustment);
189         private:        
190         virtual void do_exec(const float value);
191         virtual const char *get_name(); 
192 };
193
194 class tX_seqpar_spin : public tX_seqpar_no_update_active_forward
195 {
196         public:
197         tX_seqpar_spin();
198         private:        
199         virtual void do_exec(const float value);
200         virtual const char *get_name(); 
201 };
202
203 class tX_seqpar_vtt_volume : public tX_seqpar_update
204 {
205         public:
206         tX_seqpar_vtt_volume();
207         virtual float get_value();
208         private:        
209         virtual void do_exec(const float value);
210         virtual void do_update_graphics();      
211         virtual const char *get_name(); 
212 };
213
214 class tX_seqpar_vtt_pan : public tX_seqpar_update
215 {
216         public:
217         tX_seqpar_vtt_pan();
218         virtual float get_value();
219         private:        
220         virtual void do_exec(const float value);
221         virtual void do_update_graphics();      
222         virtual const char *get_name(); 
223 };
224
225 class tX_seqpar_vtt_pitch : public tX_seqpar_update_active_forward
226 {
227         public:
228         tX_seqpar_vtt_pitch();
229         virtual float get_value();
230         private:        
231         virtual void do_exec(const float value);
232         virtual void do_update_graphics();      
233         virtual const char *get_name(); 
234 };
235
236 class tX_seqpar_vtt_trigger : public tX_seqpar_no_update_active_forward
237 {
238         public:
239         tX_seqpar_vtt_trigger();
240         private:        
241         virtual void do_exec(const float value);
242         virtual const char *get_name(); 
243 };
244
245 class tX_seqpar_vtt_loop : public tX_seqpar_update
246 {
247         public:
248         tX_seqpar_vtt_loop();
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_sync_client : public tX_seqpar_update
256 {
257         public:
258         tX_seqpar_vtt_sync_client();
259         private:        
260         virtual void do_exec(const float value);
261         virtual void do_update_graphics();      
262         virtual const char *get_name(); 
263 };
264
265 class tX_seqpar_vtt_sync_cycles : public tX_seqpar_update
266 {
267         public:
268         tX_seqpar_vtt_sync_cycles();
269         private:        
270         virtual void do_exec(const float value);
271         virtual void do_update_graphics();      
272         virtual const char *get_name(); 
273 };
274
275 class tX_seqpar_vtt_lp_enable : public tX_seqpar_update
276 {
277         public:
278         tX_seqpar_vtt_lp_enable();
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_lp_gain : public tX_seqpar_update
286 {
287         public:
288         tX_seqpar_vtt_lp_gain();
289         virtual float get_value();
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_lp_reso : public tX_seqpar_update
297 {
298         public:
299         tX_seqpar_vtt_lp_reso();
300         virtual float get_value();
301         private:        
302         virtual void do_exec(const float value);
303         virtual void do_update_graphics();      
304         virtual const char *get_name(); 
305 };
306
307 class tX_seqpar_vtt_lp_freq : public tX_seqpar_update
308 {
309         public:
310         virtual float get_value();
311         tX_seqpar_vtt_lp_freq();
312         private:        
313         virtual void do_exec(const float value);
314         virtual void do_update_graphics();      
315         virtual const char *get_name(); 
316 };
317
318 class tX_seqpar_vtt_ec_enable : public tX_seqpar_update
319 {
320         public:
321         tX_seqpar_vtt_ec_enable();
322         private:        
323         virtual void do_exec(const float value);
324         virtual void do_update_graphics();      
325         virtual const char *get_name(); 
326 };
327
328 class tX_seqpar_vtt_ec_length : public tX_seqpar_update
329 {
330         public:
331         tX_seqpar_vtt_ec_length();
332         virtual float get_value();
333         private:        
334         virtual void do_exec(const float value);
335         virtual void do_update_graphics();      
336         virtual const char *get_name(); 
337 };
338
339 class tX_seqpar_vtt_ec_feedback : public tX_seqpar_update
340 {
341         public:
342         tX_seqpar_vtt_ec_feedback();
343         virtual float get_value();
344         private:        
345         virtual void do_exec(const float value);
346         virtual void do_update_graphics();      
347         virtual const char *get_name(); 
348 };
349
350 class tX_seqpar_vtt_ec_pan : public tX_seqpar_update
351 {
352         public:
353         tX_seqpar_vtt_ec_pan();
354         virtual float get_value();
355         private:        
356         virtual void do_exec(const float value);
357         virtual void do_update_graphics();      
358         virtual const char *get_name(); 
359 };
360
361 class tX_seqpar_vtt_ec_volume : public tX_seqpar_update
362 {
363         public:
364         tX_seqpar_vtt_ec_volume();
365         virtual float get_value();
366         private:        
367         virtual void do_exec(const float value);
368         virtual void do_update_graphics();      
369         virtual const char *get_name(); 
370 };
371
372 class tX_seqpar_vtt_mute : public tX_seqpar_no_update
373 {
374         public:
375         tX_seqpar_vtt_mute();
376         private:        
377         virtual void do_exec(const float value);
378         virtual const char *get_name(); 
379 };
380
381 /* Seqpars for the LADSPA Plugins */
382
383 class tX_seqpar_vttfx : public tX_seqpar_update
384 {
385         /* fx_value will be malloc()ed by constructor */        
386         protected:
387         GtkWidget *widget;
388         char label_name[2048];
389         char name[2048];
390         float *fx_value;
391         
392         public:
393         tX_seqpar_vttfx();
394         virtual ~tX_seqpar_vttfx();
395         void set_name(const char *, const char *);
396         GtkWidget *get_widget() { return widget; } 
397         
398         virtual float get_value();
399         float *get_value_ptr() { return fx_value; }
400         
401         private:
402         virtual void create_widget();
403         
404         public:
405         virtual const char *get_name();         
406 };
407
408 class tX_seqpar_vttfx_float : public tX_seqpar_vttfx
409 {
410         private:
411         tX_extdial *mydial;
412         GtkAdjustment *myadj;
413         
414         virtual void create_widget();
415         virtual void do_exec(const float value);
416         virtual void do_update_graphics();              
417         public:
418         virtual ~tX_seqpar_vttfx_float();
419         
420         static GtkSignalFunc gtk_callback(GtkWidget*, tX_seqpar_vttfx_float *);
421 };
422
423 class tX_seqpar_vttfx_bool : public tX_seqpar_vttfx
424 {
425         private:
426         virtual void create_widget();
427         virtual void do_exec(const float value);
428         virtual void do_update_graphics();      
429
430         static GtkSignalFunc gtk_callback(GtkWidget*, tX_seqpar_vttfx_bool *);
431
432         public:
433         virtual ~tX_seqpar_vttfx_bool();
434 };
435
436 class tX_seqpar_vttfx_int : public tX_seqpar_vttfx
437 {
438         private:
439         GtkAdjustment *myadj;
440
441         private:
442         virtual void create_widget();
443         virtual void do_exec(const float value);
444         virtual void do_update_graphics();      
445
446         public:
447         virtual ~tX_seqpar_vttfx_int();
448
449         static GtkSignalFunc gtk_callback(GtkWidget*, tX_seqpar_vttfx_int *);
450 };
451 #endif 
452
453
454
455