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