From 9a6ab3b333e64c24ee86d929d9387ef367c76ce0 Mon Sep 17 00:00:00 2001 From: mescalinum Date: Tue, 18 Aug 2009 15:08:04 +0000 Subject: import sources svn path=/trunk/externals/ffext/; revision=11945 --- composer/arraylist.h | 118 ++++++++++ composer/common.h | 166 ++++++++++++++ composer/composer.c | 45 ++++ composer/makefile | 25 +++ composer/pattern.c | 142 ++++++++++++ composer/song.c | 61 +++++ composer/song_proxy.c | 69 ++++++ composer/track.c | 79 +++++++ composer/track_proxy.c | 518 ++++++++++++++++++++++++++++++++++++++++++ composer/window.tk | 599 +++++++++++++++++++++++++++++++++++++++++++++++++ 10 files changed, 1822 insertions(+) create mode 100644 composer/arraylist.h create mode 100644 composer/common.h create mode 100644 composer/composer.c create mode 100644 composer/makefile create mode 100644 composer/pattern.c create mode 100644 composer/song.c create mode 100644 composer/song_proxy.c create mode 100644 composer/track.c create mode 100644 composer/track_proxy.c create mode 100644 composer/window.tk diff --git a/composer/arraylist.h b/composer/arraylist.h new file mode 100644 index 0000000..a4b4362 --- /dev/null +++ b/composer/arraylist.h @@ -0,0 +1,118 @@ +/* ------------------------------------------------------------------------ */ +/* Copyright (c) 2009 Federico Ferri. */ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL */ +/* WARRANTIES, see the file, "LICENSE.txt," in this distribution. */ +/* */ +/* composer: a music composition framework for pure-data */ +/* */ +/* This program is free software; you can redistribute it and/or */ +/* modify it under the terms of the GNU General Public License */ +/* as published by the Free Software Foundation; either version 2 */ +/* of the License, or (at your option) any later version. */ +/* */ +/* See file LICENSE for further informations on licensing terms. */ +/* */ +/* This program is distributed in the hope that it will be useful, */ +/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ +/* GNU General Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License */ +/* along with this program; if not, write to the Free Software Foundation, */ +/* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +/* */ +/* Based on PureData by Miller Puckette and others. */ +/* ------------------------------------------------------------------------ */ + +#include "common.h" + +#ifndef __ARRAYLIST_H_INCLUDED_ +#define __ARRAYLIST_H_INCLUDED_ + +#define ArrayListDeclare(name, type, sizetype) \ + type* name; \ + sizetype name ## _maxsize; \ + sizetype name ## _count + +#define ArrayListDeclareWithPrefix(prefix, name, type, sizetype) \ + prefix type* name; \ + prefix sizetype name ## _maxsize; \ + prefix sizetype name ## _count + +#define ArrayListInit(arrName, type, initSize) \ + arrName ## _maxsize = initSize; \ + arrName = (type*)getbytes(sizeof(type) * (initSize)); \ + arrName ## _count = 0 + +#define ArrayListAdd(arrName, type, objToAdd) \ + if(arrName ## _count >= arrName ## _maxsize) { \ + arrName = (type*)resizebytes(arrName, arrName ## _maxsize, (arrName ## _maxsize)*2); \ + }; \ + arrName[ arrName ## _count ++ ] = (type) objToAdd; \ + +#define ArrayListRemove(arrName, objToRem) \ + { \ + int i,j; \ + for(i=0; i< arrName ## _count; i++) \ + if(arrName[i] == objToRem) { \ + for(j=i; j< arrName ## _count - 1; j++) { \ + arrName[j] = arrName[j+1]; \ + } \ + arrName[ arrName ## _count -- ] = 0L; \ + break; \ + } \ + } + +#define ArrayListRemoveByIndex(arrName, index) \ + { \ + int i,j; \ + for(i=0; i< arrName ## _count; i++) \ + if(i == index) { \ + for(j=i; j< arrName ## _count - 1; j++) { \ + arrName[j] = arrName[j+1]; \ + } \ + arrName[ arrName ## _count -- ] = 0L; \ + break; \ + } \ + } + +#define ArrayListRemoveByName(arrName, name) \ + { \ + int i,j; \ + for(i=0; i< arrName ## _count; i++) \ + if(arrName[i] && arrName[i]->x_name == name) { \ + for(j=i; j< arrName ## _count - 1; j++) { \ + arrName[j] = arrName[j+1]; \ + } \ + arrName[ arrName ## _count -- ] = 0L; \ + break; \ + } \ + } + +#define ArrayListGetByName(arrName, n, type, result) \ + type result = (type) 0L; \ + if(arrName) { \ + int i; \ + for(i=0; i< arrName ## _count; i++) { \ + if(arrName[i] && arrName[i]->x_name == n) { \ + result = arrName[i]; break; \ + } \ + } \ + } + +#define ArrayListGetIndexByName(arrName, n, type, result) \ + type result = (type) -1; \ + if(arrName) { \ + int i; \ + for(i=0; i< arrName ## _count; i++) { \ + if(arrName[i] && arrName[i]->x_name == n) { \ + result = i; \ + break; \ + } \ + } \ + } + +#define ArrayListFree(arrName, type) \ + freebytes(arrName, arrName ## _maxsize * sizeof(type)) + +#endif // __ARRAYLIST_H_INCLUDED_ diff --git a/composer/common.h b/composer/common.h new file mode 100644 index 0000000..b149265 --- /dev/null +++ b/composer/common.h @@ -0,0 +1,166 @@ +/* ------------------------------------------------------------------------ */ +/* Copyright (c) 2009 Federico Ferri. */ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL */ +/* WARRANTIES, see the file, "LICENSE.txt," in this distribution. */ +/* */ +/* composer: a music composition framework for pure-data */ +/* */ +/* This program is free software; you can redistribute it and/or */ +/* modify it under the terms of the GNU General Public License */ +/* as published by the Free Software Foundation; either version 2 */ +/* of the License, or (at your option) any later version. */ +/* */ +/* See file LICENSE for further informations on licensing terms. */ +/* */ +/* This program is distributed in the hope that it will be useful, */ +/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ +/* GNU General Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License */ +/* along with this program; if not, write to the Free Software Foundation, */ +/* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +/* */ +/* Based on PureData by Miller Puckette and others. */ +/* ------------------------------------------------------------------------ */ + +#ifndef COMPOSER_COMMON_H_INCLUDED +#define COMPOSER_COMMON_H_INCLUDED + +#include +#include +#include +#include "m_pd.h" +#include "m_imp.h" +#include "g_canvas.h" +#include "s_stuff.h" +#include "t_tk.h" +#include +#include +#include "arraylist.h" + +#define PTR "0x%x" +#ifdef DEBUG +#define debugprint(args...) post( args ) +#define DEBUG_BOOL 1 +#else +#define debugprint(args...) +#define DEBUG_BOOL 0 +#endif + +#define STRINGIFY(x) #x + +#define WRAP(v, w) (((v) < 0 ? (1+(int)((-(v))/(w)))*(w) : (v)) % w) + +#define TRACK_SELECTOR "#TRACK" +#define SONG_SELECTOR "#SONG" + +extern t_symbol s_list; + +struct _track; +struct _pattern; + +typedef struct _song +{ + t_symbol* x_name; + ArrayListDeclare(x_tracks, struct _track*, t_int); +} t_song; + +typedef struct _song_proxy +{ + t_object x_obj; + t_outlet* outlet; + t_song* x_song; + t_int b_editor_open; +} t_song_proxy; + +typedef struct _track +{ + t_symbol* x_name; + t_song* x_song; + t_int x_ncolumns; + t_outlet* outlet; + ArrayListDeclare(x_patterns, struct _pattern*, t_int); + t_float x_currentpat; +} t_track; + +typedef struct _track_proxy +{ + t_object x_obj; + t_outlet* outlet; + t_track* x_track; + t_int b_editor_open; + t_symbol* rcv; +} t_track_proxy; + +typedef struct _pattern +{ + t_symbol* x_name; + t_track* x_track; + ArrayListDeclare(x_rows, t_atom*, t_int); +} t_pattern; + +static t_song* song_new(t_symbol* song_name); +static void song_free(t_song* x); +static t_song* song_get(t_symbol* song_name); +static int song_exists(t_symbol* song_name); + +static t_track* track_new(t_symbol* song_name, t_symbol* track_name, t_int columns); +static void track_free(t_track* x); +static t_track* track_get(t_symbol* song_name, t_symbol* track_name); +static int track_exists(t_symbol* song_name, t_symbol* track_name); + +static t_pattern* pattern_new(t_track* track, t_symbol* name, t_int rows); +static t_pattern* pattern_clone(t_pattern* src, t_symbol* newname); +static void pattern_free(t_pattern* x); +static void pattern_rename(t_pattern* x, t_symbol* newname); +static void pattern_resize(t_pattern *x, t_int newsize); +static void pattern_new_empty_row(t_pattern* x); +static t_atom* pattern_getrow(t_pattern* x, t_int row); +static t_atom* pattern_clone_row(t_pattern* x, t_atom* row); +static t_atom* pattern_getcell(t_pattern* x, t_int row, t_int col); +static void pattern_setrow(t_pattern* x, t_int row, t_atom* rowdata); +static void pattern_setcell(t_pattern* x, t_int row, t_int col, t_atom* a); +static t_pattern* pattern_get(t_symbol* song_name, t_symbol* track_name, t_symbol* pattern_name); +static int pattern_exists(t_symbol* song_name, t_symbol* track_name, t_symbol* pattern_name); + +void song_proxy_setup(void); +static t_song_proxy* song_proxy_new(t_symbol* song_name); +static void song_proxy_free(t_song_proxy* x); +static void song_proxy_float(t_song_proxy* x, t_floatarg f); +static void song_proxy_properties(t_gobj* z, t_glist* owner); +static void song_proxy_save(t_gobj* z, t_binbuf* b); + +void track_proxy_setup(void); +static t_track_proxy* track_proxy_new(t_symbol* song_name, t_symbol* track_name, t_floatarg cols); +static void track_proxy_free(t_track_proxy* x); +static void track_proxy_reload(t_track_proxy* x); +static void track_proxy_properties(t_gobj* z, t_glist* owner); +static void track_proxy_properties_close(t_gobj* z, t_glist* owner); +static void track_proxy_save(t_gobj* z, t_binbuf* b); +static void track_proxy_sendrow(t_track_proxy* x, t_pattern* pat, t_int row); +static void track_proxy_anything(t_track_proxy* x, t_symbol* s, int argc, t_atom* argv); +static void track_proxy_loaddata(t_track_proxy* x, t_symbol* s, int argc, t_atom* argv); +static t_atom* track_proxy_getpatternlength(t_track_proxy* x, t_symbol* pat_name); +static void track_proxy_editcmd(t_track_proxy* x, t_symbol* s, int argc, t_atom* argv); +static void track_proxy_sendgui(t_track_proxy* x, t_symbol* s, int argc, t_atom* argv); +static void track_proxy_float(t_track_proxy* x, t_floatarg f); +static void track_proxy_setrow(t_track_proxy* x, t_symbol* sel, int argc, t_atom* argv); +static t_atom* track_proxy_getrow(t_track_proxy* x, t_symbol* pat_name, t_floatarg rownum); +static t_atom* track_proxy_getrow_with_header(t_track_proxy* x, t_symbol* pat_name, t_floatarg rownum); +static void track_proxy_getrow_o(t_track_proxy* x, t_symbol* pat_name, t_floatarg rownum); +static void track_proxy_setcell(t_track_proxy* x, t_symbol* sel, int argc, t_atom* argv); +static t_atom* track_proxy_getcell(t_track_proxy* x, t_symbol* pat_name, t_floatarg rownum, t_floatarg colnum); +static t_atom* track_proxy_getcell_with_header(t_track_proxy* x, t_symbol* pat_name, t_floatarg rownum, t_floatarg colnum); +static void track_proxy_getcell_o(t_track_proxy* x, t_symbol* pat_name, t_floatarg rownum, t_floatarg colnum); +static t_pattern* track_proxy_addpattern(t_track_proxy* x, t_symbol* name, t_floatarg rows); +static int track_proxy_removepattern(t_track_proxy* x, t_symbol* name); +static t_pattern* track_proxy_resizepattern(t_track_proxy* x, t_symbol* name, t_floatarg rows); +static t_pattern* track_proxy_renamepattern(t_track_proxy* x, t_symbol* name, t_symbol* newname); +static t_pattern* track_proxy_copypattern(t_track_proxy* x, t_symbol* src, t_symbol* dst); + +ArrayListDeclareWithPrefix(extern, songs, t_song*, int); + +void composer_setup(void); + +#endif // COMPOSER_COMMON_H_INCLUDED diff --git a/composer/composer.c b/composer/composer.c new file mode 100644 index 0000000..493ae37 --- /dev/null +++ b/composer/composer.c @@ -0,0 +1,45 @@ +/* ------------------------------------------------------------------------ */ +/* Copyright (c) 2009 Federico Ferri. */ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL */ +/* WARRANTIES, see the file, "LICENSE.txt," in this distribution. */ +/* */ +/* composer: a music composition framework for pure-data */ +/* */ +/* This program is free software; you can redistribute it and/or */ +/* modify it under the terms of the GNU General Public License */ +/* as published by the Free Software Foundation; either version 2 */ +/* of the License, or (at your option) any later version. */ +/* */ +/* See file LICENSE for further informations on licensing terms. */ +/* */ +/* This program is distributed in the hope that it will be useful, */ +/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ +/* GNU General Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License */ +/* along with this program; if not, write to the Free Software Foundation, */ +/* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +/* */ +/* Based on PureData by Miller Puckette and others. */ +/* ------------------------------------------------------------------------ */ + +#include "common.h" + +#include "song.c" +#include "track.c" +#include "pattern.c" +#include "song_proxy.c" +#include "track_proxy.c" + +ArrayListDeclare(songs, t_song*, int); + +t_symbol s_list = {"list", 0, 0}; + +void composer_setup(void) { + debugprint("loading composer library for pd"); +/* #include "window.tk2c" */ + sys_vgui("source {window.tk}\n"); + song_proxy_setup(); + track_proxy_setup(); +} diff --git a/composer/makefile b/composer/makefile new file mode 100644 index 0000000..28e45f8 --- /dev/null +++ b/composer/makefile @@ -0,0 +1,25 @@ +all: pd_linux + +.SUFFIXES: .pd_linux + +pd_linux: composer.pd_linux + +LINUXCFLAGS = -DPD -DUNIX -DDEBUG -DPIC -fPIC \ + -funroll-loops -fomit-frame-pointer \ + -Wall -W -Wno-shadow -Wstrict-prototypes \ + -Wno-unused -Wno-parentheses -Wno-switch \ +#LINUXINCLUDE = -I/usr/include +LINUXINCLUDE = -I/usr/src/pd/0.41.4/src +LINUXLDFLAGS = -export_dynamic -shared + +composer.pd_linux: song.c track.c pattern.c \ + song_proxy.c track_proxy.c \ + composer.c common.h arraylist.h + $(CC) $(LINUXCFLAGS) $(LINUXINCLUDE) -o composer.o -c composer.c + $(LD) $(LINUXLDFLAGS) -o composer.pd_linux composer.o -lc -lm + strip --strip-unneeded composer.pd_linux + +clean: + rm -f *.o *.pd_linux + + diff --git a/composer/pattern.c b/composer/pattern.c new file mode 100644 index 0000000..134b802 --- /dev/null +++ b/composer/pattern.c @@ -0,0 +1,142 @@ +/* ------------------------------------------------------------------------ */ +/* Copyright (c) 2009 Federico Ferri. */ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL */ +/* WARRANTIES, see the file, "LICENSE.txt," in this distribution. */ +/* */ +/* composer: a music composition framework for pure-data */ +/* */ +/* This program is free software; you can redistribute it and/or */ +/* modify it under the terms of the GNU General Public License */ +/* as published by the Free Software Foundation; either version 2 */ +/* of the License, or (at your option) any later version. */ +/* */ +/* See file LICENSE for further informations on licensing terms. */ +/* */ +/* This program is distributed in the hope that it will be useful, */ +/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ +/* GNU General Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License */ +/* along with this program; if not, write to the Free Software Foundation, */ +/* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +/* */ +/* Based on PureData by Miller Puckette and others. */ +/* ------------------------------------------------------------------------ */ + +#include "common.h" + +static t_pattern* pattern_new(t_track* track, t_symbol* name, t_int rows) { + ArrayListGetByName(track->x_patterns, name, t_pattern*, obj); + debugprint("pattern_new - object lookup {{%s}} => " PTR, name->s_name, obj); + if(obj) return obj; + + t_pattern* x = (t_pattern*)getbytes(sizeof(t_pattern)); + x->x_name = name; + x->x_track = track; + ArrayListInit(x->x_rows, t_atom*, rows); + + int i; + for(i = 0; i < rows; i++) { + debugprint("x->x_rows[%d] = " PTR, i, x->x_rows[i]); + pattern_new_empty_row(x); + debugprint("x->x_rows[%d] <- " PTR, i, x->x_rows[i]); + } + + debugprint("created new pattern " PTR " with %d rows (x_rows = " PTR ")", x, x->x_rows_count, x->x_rows); + + // add pattern to track's pattern list + ArrayListAdd(x->x_track->x_patterns, t_pattern*, x); + return x; +} + +static t_pattern* pattern_clone(t_pattern* src, t_symbol* newname) { + t_pattern* x = (t_pattern*)getbytes(sizeof(t_pattern)); + x->x_name = newname; + x->x_track = src->x_track; + ArrayListInit(x->x_rows, t_atom*, src->x_rows_count); + + int i; + for(i = 0; i < src->x_rows_count; i++) { + ArrayListAdd(x->x_rows, t_atom*, pattern_clone_row(x, src->x_rows[i])); + } + + ArrayListAdd(x->x_track->x_patterns, t_pattern*, x); + return x; +} + +static void pattern_free(t_pattern* x) { + // free rows memory + ArrayListFree(x->x_rows, t_atom*); + // remove pattern from track's pattern list + ArrayListRemove(x->x_track->x_patterns, x); +} + +static void pattern_rename(t_pattern* x, t_symbol* newname) { + x->x_name = newname; +} + +static void pattern_resize(t_pattern *x, t_int newsize) { + debugprint("pattern_resize(" PTR ", %d)", x, newsize); + debugprint("initial size: %d", x->x_rows_count); + while(x->x_rows_count < newsize) + pattern_new_empty_row(x); + while(x->x_rows_count > newsize) + ArrayListRemoveByIndex(x->x_rows, x->x_rows_count - 1); + debugprint("final size: %d", x->x_rows_count); +} + +static void pattern_new_empty_row(t_pattern* x) { + t_atom* rowdata = (t_atom*)getbytes(sizeof(t_atom) * x->x_track->x_ncolumns); + SETSYMBOL(&(rowdata[0]), gensym("test")); + int j; + for(j = 1; j < x->x_track->x_ncolumns; j++) + SETFLOAT(&(rowdata[j]), j); + ArrayListAdd(x->x_rows, t_atom*, rowdata); +} + +static t_atom* pattern_getrow(t_pattern* x, t_int row) { + debugprint("pattern_getrow(" PTR ", %d)", x, row); + row = WRAP(row, x->x_rows_count); + t_atom* rowdata = x->x_rows[row]; + return rowdata; +} + +static t_atom* pattern_clone_row(t_pattern* x, t_atom* rowdata) { + debugprint("pattern_clone_row(" PTR ", " PTR ")", x, rowdata); + t_atom* clone = (t_atom*)copybytes(rowdata, sizeof(t_atom) * x->x_track->x_ncolumns); + return clone; +} + +static t_atom* pattern_getcell(t_pattern* x, t_int row, t_int col) { + row = WRAP(row, x->x_rows_count); + col = WRAP(col, x->x_track->x_ncolumns); + return &(x->x_rows[row][col]); +} + +static void pattern_setrow(t_pattern* x, t_int row, t_atom* rowdata) { + debugprint("pattern_setrow(" PTR ", %d, " PTR ")", x, row, rowdata); + row = WRAP(row, x->x_rows_count); + debugprint("x->x_rows[%d] = " PTR, row, x->x_rows[row]); + t_atom *myrowdata = x->x_rows[row]; + memcpy(myrowdata, rowdata, sizeof(t_atom) * x->x_track->x_ncolumns); + debugprint("x->x_rows[%d] <- " PTR, row, x->x_rows[row]); +} + +static void pattern_setcell(t_pattern* x, t_int row, t_int col, t_atom* a) { + row = WRAP(row, x->x_rows_count); + col = WRAP(col, x->x_track->x_ncolumns); + debugprint("about to write an atom (size=%d) at address " PTR, sizeof(t_atom), &(x->x_rows[row][col])); + memcpy(&(x->x_rows[row][col]), a, sizeof(t_atom)); +} + +static t_pattern* pattern_get(t_symbol* song_name, t_symbol* track_name, t_symbol* pattern_name) { + t_track* track = track_get(song_name, track_name); + if(!track || !track->x_patterns) return (t_pattern*) 0L; + ArrayListGetByName(track->x_patterns, pattern_name, t_pattern*, result); + return result; +} + +static int pattern_exists(t_symbol* song_name, t_symbol* track_name, t_symbol* pattern_name) { + return pattern_get(song_name, track_name, pattern_name) != 0L; +} diff --git a/composer/song.c b/composer/song.c new file mode 100644 index 0000000..7c99877 --- /dev/null +++ b/composer/song.c @@ -0,0 +1,61 @@ +/* ------------------------------------------------------------------------ */ +/* Copyright (c) 2009 Federico Ferri. */ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL */ +/* WARRANTIES, see the file, "LICENSE.txt," in this distribution. */ +/* */ +/* composer: a music composition framework for pure-data */ +/* */ +/* This program is free software; you can redistribute it and/or */ +/* modify it under the terms of the GNU General Public License */ +/* as published by the Free Software Foundation; either version 2 */ +/* of the License, or (at your option) any later version. */ +/* */ +/* See file LICENSE for further informations on licensing terms. */ +/* */ +/* This program is distributed in the hope that it will be useful, */ +/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ +/* GNU General Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License */ +/* along with this program; if not, write to the Free Software Foundation, */ +/* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +/* */ +/* Based on PureData by Miller Puckette and others. */ +/* ------------------------------------------------------------------------ */ + +#include "common.h" + +static t_song* song_new(t_symbol* song_name) { + ArrayListGetByName(songs, song_name, t_song*, obj); + debugprint("song_new - object lookup {{%s}} => " PTR, song_name->s_name, obj); + if(obj) return obj; + + t_song* x = (t_song*)getbytes(sizeof(t_song)); + x->x_name = song_name; + ArrayListInit(x->x_tracks, struct _track*, 16); + + debugprint("created a song object (" PTR "), " + "creation args: {{%s}}", + x, x->x_name->s_name); + + ArrayListAdd(songs, t_song*, x); + debugprint("registered song object to global song collection"); + return x; +} + +static void song_free(t_song* x) { + // free tracks memory + ArrayListFree(x->x_tracks, t_track*); + // remove song from global song collection + ArrayListRemove(songs, x); +} + +static t_song* song_get(t_symbol* song_name) { + ArrayListGetByName(songs, song_name, t_song*, result); + return result; +} + +static int song_exists(t_symbol* song_name) { + return song_get(song_name) != 0L; +} diff --git a/composer/song_proxy.c b/composer/song_proxy.c new file mode 100644 index 0000000..9d40215 --- /dev/null +++ b/composer/song_proxy.c @@ -0,0 +1,69 @@ +/* ------------------------------------------------------------------------ */ +/* Copyright (c) 2009 Federico Ferri. */ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL */ +/* WARRANTIES, see the file, "LICENSE.txt," in this distribution. */ +/* */ +/* composer: a music composition framework for pure-data */ +/* */ +/* This program is free software; you can redistribute it and/or */ +/* modify it under the terms of the GNU General Public License */ +/* as published by the Free Software Foundation; either version 2 */ +/* of the License, or (at your option) any later version. */ +/* */ +/* See file LICENSE for further informations on licensing terms. */ +/* */ +/* This program is distributed in the hope that it will be useful, */ +/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ +/* GNU General Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License */ +/* along with this program; if not, write to the Free Software Foundation, */ +/* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +/* */ +/* Based on PureData by Miller Puckette and others. */ +/* ------------------------------------------------------------------------ */ + +#include "common.h" + +t_class* song_proxy_class; + +void song_proxy_setup(void) { + debugprint("registering 'song' class..."); + song_proxy_class = class_new( + gensym("song"), + (t_newmethod)song_proxy_new, + (t_method)song_proxy_free, + sizeof(t_song_proxy), + CLASS_DEFAULT, //0, + A_SYMBOL, + 0 + ); + class_addfloat(song_proxy_class, song_proxy_float); +#if PD_MINOR_VERSION >= 37 + class_setpropertiesfn(song_proxy_class, song_proxy_properties); + class_setsavefn(song_proxy_class, song_proxy_save); +#endif + class_sethelpsymbol(song_proxy_class, gensym("song.pd")); +} + +static t_song_proxy* song_proxy_new(t_symbol* song_name) { + t_song_proxy *x = (t_song_proxy*)pd_new(song_proxy_class); + x->outlet = outlet_new(&x->x_obj, &s_list); + x->x_song = song_new(song_name); + x->b_editor_open = 0; + debugprint("created an instance of t_song_proxy: " PTR, x); + return x; +} + +static void song_proxy_free(t_song_proxy* x) { +} + +static void song_proxy_float(t_song_proxy* x, t_floatarg f) { +} + +static void song_proxy_properties(t_gobj* z, t_glist* owner) { +} + +static void song_proxy_save(t_gobj* z, t_binbuf* b) { +} diff --git a/composer/track.c b/composer/track.c new file mode 100644 index 0000000..a3f5ddc --- /dev/null +++ b/composer/track.c @@ -0,0 +1,79 @@ +/* ------------------------------------------------------------------------ */ +/* Copyright (c) 2009 Federico Ferri. */ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL */ +/* WARRANTIES, see the file, "LICENSE.txt," in this distribution. */ +/* */ +/* composer: a music composition framework for pure-data */ +/* */ +/* This program is free software; you can redistribute it and/or */ +/* modify it under the terms of the GNU General Public License */ +/* as published by the Free Software Foundation; either version 2 */ +/* of the License, or (at your option) any later version. */ +/* */ +/* See file LICENSE for further informations on licensing terms. */ +/* */ +/* This program is distributed in the hope that it will be useful, */ +/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ +/* GNU General Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License */ +/* along with this program; if not, write to the Free Software Foundation, */ +/* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +/* */ +/* Based on PureData by Miller Puckette and others. */ +/* ------------------------------------------------------------------------ */ + +#include "common.h" + +static t_track* track_new(t_symbol* song_name, t_symbol* track_name, t_int columns) { + t_song* song = song_new(song_name); + + ArrayListGetByName(song->x_tracks, track_name, t_track*, obj); + debugprint("track_new - object lookup {{%s} {%s} {%d}} => " PTR, song_name->s_name, track_name->s_name, columns, obj); + if(obj) return obj; + + t_track* x = (t_track*)getbytes(sizeof(t_track)); + x->x_name = track_name; + x->x_song = song; + x->x_ncolumns = columns; + ArrayListInit(x->x_patterns, struct _pattern*, 4); + x->x_currentpat = 0; + + debugprint("created a track object (" PTR "), " + "creation args: {{%s} {%s} {%d}}", + x, x->x_song->x_name->s_name, x->x_name->s_name, x->x_ncolumns); + + // att track to song's track list + ArrayListAdd(song->x_tracks, t_track*, x); + return x; +} + +static void track_free(t_track* x) { + // free patterns memory + ArrayListFree(x->x_patterns, t_pattern*); + // remove track from song's track list + ArrayListRemove(x->x_song->x_tracks, x); +} + +static t_int track_get_pattern_count(t_track* x) { + return x->x_patterns_count; +} + +static void track_get_pattern_names(t_track* x, t_atom* /* OUT */ out) { + int i; + for(i = 0; i < x->x_patterns_count; i++) { + SETSYMBOL(&out[i], x->x_patterns[i]->x_name); + } +} + +static t_track* track_get(t_symbol* song_name, t_symbol* track_name) { + t_song* song = song_get(song_name); + if(!song || !song->x_tracks) return (t_track*) 0L; + ArrayListGetByName(song->x_tracks, track_name, t_track*, result); + return result; +} + +static int track_exists(t_symbol* song_name, t_symbol* track_name) { + return track_get(song_name, track_name) != 0L; +} diff --git a/composer/track_proxy.c b/composer/track_proxy.c new file mode 100644 index 0000000..1f1d769 --- /dev/null +++ b/composer/track_proxy.c @@ -0,0 +1,518 @@ +/* ------------------------------------------------------------------------ */ +/* Copyright (c) 2009 Federico Ferri. */ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL */ +/* WARRANTIES, see the file, "LICENSE.txt," in this distribution. */ +/* */ +/* composer: a music composition framework for pure-data */ +/* */ +/* This program is free software; you can redistribute it and/or */ +/* modify it under the terms of the GNU General Public License */ +/* as published by the Free Software Foundation; either version 2 */ +/* of the License, or (at your option) any later version. */ +/* */ +/* See file LICENSE for further informations on licensing terms. */ +/* */ +/* This program is distributed in the hope that it will be useful, */ +/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ +/* GNU General Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License */ +/* along with this program; if not, write to the Free Software Foundation, */ +/* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +/* */ +/* Based on PureData by Miller Puckette and others. */ +/* ------------------------------------------------------------------------ */ + +#include "common.h" + +t_class* track_proxy_class; + +void track_proxy_setup(void) { + debugprint("registering 'track' class..."); + ArrayListInit(songs, t_song*, 10); + track_proxy_class = class_new( + gensym("track"), + (t_newmethod)track_proxy_new, + (t_method)track_proxy_free, + sizeof(t_track_proxy), + CLASS_DEFAULT, //0, + A_SYMBOL, A_SYMBOL, A_FLOAT, + 0 + ); + class_addfloat(track_proxy_class, track_proxy_float); + class_addanything(track_proxy_class, track_proxy_anything); + class_addmethod(track_proxy_class, (t_method)track_proxy_properties, \ + gensym("editor-open"), 0); + class_addmethod(track_proxy_class, (t_method)track_proxy_properties_close, \ + gensym("editor-close"), 0); + class_addmethod(track_proxy_class, (t_method)track_proxy_reload, \ + gensym("reload"), 0); + class_addmethod(track_proxy_class, (t_method)track_proxy_setrow, \ + gensym("setrow"), A_GIMME, 0); + class_addmethod(track_proxy_class, (t_method)track_proxy_getrow_o, \ + gensym("getrow"), A_SYMBOL, A_FLOAT, 0); + class_addmethod(track_proxy_class, (t_method)track_proxy_setcell, \ + gensym("setcell"), A_GIMME, 0); + class_addmethod(track_proxy_class, (t_method)track_proxy_getcell_o, \ + gensym("getcell"), A_SYMBOL, A_FLOAT, A_FLOAT, 0); + class_addmethod(track_proxy_class, (t_method)track_proxy_addpattern, \ + gensym("addpattern"), A_SYMBOL, A_FLOAT, 0); + class_addmethod(track_proxy_class, (t_method)track_proxy_removepattern, \ + gensym("removepattern"), A_SYMBOL, 0); + class_addmethod(track_proxy_class, (t_method)track_proxy_resizepattern, \ + gensym("resizepattern"), A_SYMBOL, A_FLOAT, 0); + class_addmethod(track_proxy_class, (t_method)track_proxy_renamepattern, \ + gensym("renamepattern"), A_SYMBOL, A_SYMBOL, 0); + class_addmethod(track_proxy_class, (t_method)track_proxy_copypattern, \ + gensym("copypattern"), A_SYMBOL, A_SYMBOL, 0); +#if PD_MINOR_VERSION >= 37 + class_setpropertiesfn(track_proxy_class, track_proxy_properties); + class_setsavefn(track_proxy_class, track_proxy_save); +#endif + class_sethelpsymbol(track_proxy_class, gensym("track.pd")); +} + +static t_track_proxy* track_proxy_new(t_symbol* song_name, t_symbol* track_name, t_floatarg cols) { + t_track_proxy *x = (t_track_proxy*)pd_new(track_proxy_class); + x->outlet = outlet_new(&x->x_obj, &s_list); + x->x_track = track_new(song_name, track_name, (t_int)cols); + x->b_editor_open = 0; + char rcv_buf[80]; + sprintf(rcv_buf, "track_proxy-%s-%s", x->x_track->x_song->x_name->s_name, x->x_track->x_name->s_name); + x->rcv = gensym(rcv_buf); + pd_bind(&x->x_obj.ob_pd, x->rcv); + debugprint("created an instance of t_track_proxy " PTR ", to_track = " PTR, x, x->x_track); + + track_proxy_properties_close((t_gobj*) x, NULL); + + pd_bind(&x->x_obj.ob_pd, gensym(TRACK_SELECTOR)); + + sys_vgui("pd::composer::init %s %s %s %d %d\n", x->rcv->s_name, x->x_track->x_song->x_name->s_name, x->x_track->x_name->s_name, x->x_track->x_ncolumns, DEBUG_BOOL); + + return x; +} + +static void track_proxy_free(t_track_proxy* x) { + track_proxy_properties_close((t_gobj*) x, NULL); + + pd_unbind(&x->x_obj.ob_pd, gensym(TRACK_SELECTOR)); + /* LATER find a way to get #TRACK unbound earlier (at end of load?) */ + t_pd* x2; + while (x2 = pd_findbyclass(gensym(TRACK_SELECTOR), track_proxy_class)) + pd_unbind(x2, gensym(TRACK_SELECTOR)); + + pd_unbind(&x->x_obj.ob_pd, x->rcv); +} + +static void track_proxy_sendgui_pattern_names(t_track_proxy* x) { + debugprint("track_proxy_sendgui_pattern_names(" PTR ")", x); + t_int n = track_get_pattern_count(x->x_track); + t_atom* a = (t_atom*)getbytes(sizeof(t_atom)*n); + track_get_pattern_names(x->x_track, a); + track_proxy_sendgui(x, gensym("patterns"), n, a); + freebytes(a, sizeof(t_atom)*n); +} + +static void track_proxy_reload(t_track_proxy* x) { + sys_vgui("source {window.tk}\n"); +} + +static void track_proxy_properties(t_gobj* z, t_glist* owner) { + t_track_proxy* x = (t_track_proxy*)z; + sys_vgui("pd::composer::openWindow %s\n", x->rcv->s_name); + x->b_editor_open = 1; +} + +static void track_proxy_properties_close(t_gobj* z, t_glist* owner) { + t_track_proxy* x = (t_track_proxy*)z; + debugprint("track_proxy_properties_close(" PTR ", " PTR ") [editor is %s]", z, owner, x->b_editor_open ? "open" : "closed"); + if(x->b_editor_open) { + debugprint("closing..."); + sys_vgui("pd::composer::closeWindow %s\n", x->rcv->s_name); + x->b_editor_open = 0; + } +} + +static void track_proxy_save(t_gobj* z, t_binbuf* b) { + t_track_proxy* x = (t_track_proxy*)z; + t_track* t = x->x_track; + + binbuf_addv(b, "ssiisssi;", gensym("#X"), gensym("obj"), + (t_int)x->x_obj.te_xpix, (t_int)x->x_obj.te_ypix, + gensym("track"), t->x_song->x_name, t->x_name, t->x_ncolumns); + + // data format: + // #TRACK DATA [ RxC_atoms]*n + + binbuf_addv(b, "ssi", gensym(TRACK_SELECTOR), gensym("DATA"), t->x_patterns_count); + + int i,j,k; + for(i = 0; i < t->x_patterns_count; i++) { + t_pattern* pat = t->x_patterns[i]; + binbuf_addv(b, "si", pat->x_name, pat->x_rows_count); + for(j = 0; j < pat->x_rows_count; j++) { + for(k = 0; k < t->x_ncolumns; k++) { + switch(pat->x_rows[j][k].a_type) { + case A_FLOAT: binbuf_addv(b, "i", pat->x_rows[j][k].a_w.w_float); break; + case A_SYMBOL: binbuf_addv(b, "s", pat->x_rows[j][k].a_w.w_symbol); break; + default: binbuf_addv(b, "s", gensym("?")); break; + } + } + } + } + + binbuf_addv(b, ";"); +} + +static void track_proxy_sendrow(t_track_proxy* x, t_pattern* pat, t_int row) { + t_track* t = x->x_track; + if(row < 0) row = 0; + row = row % pat->x_rows_count; + outlet_list(x->outlet, &s_list, t->x_ncolumns, pat->x_rows[row]); +} + +static void track_proxy_anything(t_track_proxy* x, t_symbol* s, int argc, t_atom* argv) { + debugprint("track_proxy_anything(" PTR ", %s, %d, " PTR ")", s, s->s_name, argc, argv); + + if(s == gensym("DATA")) { + track_proxy_loaddata(x, s, argc, argv); + return; + } else if(s == gensym("EDIT")) { + track_proxy_editcmd(x, s, argc, argv); + return; + } else { + error("unrecognized command for anything method: %s ", s->s_name); + return; + } +} + +static void track_proxy_loaddata(t_track_proxy* x, t_symbol* s, int argc, t_atom* argv) { + int i,base; + base = 0; + + if(argc < (base+1) || argv[base].a_type != A_FLOAT) { + error("track: data format error 2"); + return; + } + + t_int npatterns = (t_int)argv[base].a_w.w_float; + debugprint("track: %d patterns to read", npatterns); + base += 1; + + t_symbol* patname; + t_int patrows; + t_pattern* pat; + + debugprint("track_proxy_loaddata(" PTR ", %s, %d, " PTR ")", x, s->s_name, argc, argv); + for(i = 0; i < npatterns; i++) { + debugprint("reading pattern %d...", i); + if(argc < (base + 2)) { + error("track: data format error 3 (i=%d)", i); + return; + } + if(argv[base+0].a_type != A_SYMBOL || argv[base+1].a_type != A_FLOAT) { + error("track: data format error 4 (i=%d)", i); + return; + } + patname = argv[base+0].a_w.w_symbol; + patrows = (t_int)argv[base+1].a_w.w_float; + debugprint("pattern %d: name='%s', length=%d, RxC=%d", i, patname->s_name, patrows, + patrows * x->x_track->x_ncolumns); + base += 2; + if(argc >= (base + patrows * x->x_track->x_ncolumns) && patrows > 0) { + pat = pattern_new(x->x_track, patname, patrows); + debugprint("created new pattern " PTR " ('%s', %d rows) for track " PTR, pat, patname->s_name, patrows, x->x_track); + int j,h,k; + for(h = 0, j = base; j < (base + patrows * x->x_track->x_ncolumns); j += x->x_track->x_ncolumns, h++) { + debugprint(" working on row %d", h); + for(k = 0; k < x->x_track->x_ncolumns; k++) { + pattern_setcell(pat, h, k, &argv[j+k]); + } + } + base += patrows * x->x_track->x_ncolumns; + } else { + error("track: data format error 8 (i=%d)", i); + return; + } + } +} + +static t_atom* track_proxy_getpatternlength(t_track_proxy* x, t_symbol* pat_name) { + /*if(argc < 1 || argv[0].a_type != A_SYMBOL) { + error("track: getpatternlength: usage: getpatternlength "); + return NULL; + } + t_symbol* pat_name = argv[0].a_w.w_symbol;*/ + ArrayListGetByName(x->x_track->x_patterns, pat_name, t_pattern*, pat); + if(!pat) { + error("track: getpatternlength: no such pattern: '%s'", pat_name->s_name); + return NULL; + } + t_atom* pl = (t_atom*)getbytes(sizeof(t_atom) * 2); + SETSYMBOL(&pl[0], pat->x_name); + SETFLOAT(&pl[1], pat->x_rows_count); + return pl; +} + +static void track_proxy_editcmd(t_track_proxy* x, t_symbol* s_, int argc, t_atom* argv_) { + if(argc < 1 || argv_[0].a_type != A_SYMBOL) { + error("track: editcmd: missing method selector"); + return; + } + /*if(argc < 2) { + error("track: editcmd: missing data after selector"); + return; + }*/ + + // route -> selector + t_symbol* s = argv_[0].a_w.w_symbol; + t_atom* argv = &argv_[1]; + argc--; + + t_symbol *s1 = (argc >= 1 && argv[0].a_type == A_SYMBOL) ? argv[0].a_w.w_symbol : NULL; + t_symbol *s2 = (argc >= 2 && argv[1].a_type == A_SYMBOL) ? argv[1].a_w.w_symbol : NULL; + t_float f2 = (argc >= 2 && argv[1].a_type == A_FLOAT) ? argv[1].a_w.w_float : 0; + t_float f3 = (argc >= 3 && argv[2].a_type == A_FLOAT) ? argv[2].a_w.w_float : 0; + + t_pattern* p = NULL; + int i,j; + + if(s == gensym("editor-open")) { + track_proxy_properties((t_gobj*) x, NULL); + } else if(s == gensym("editor-close")) { + track_proxy_properties_close((t_gobj*) x, NULL); + } else if(s == gensym("getpatterns")) { + track_proxy_sendgui_pattern_names(x); + } else if(s == gensym("getpatternlength")) { + track_proxy_sendgui(x, gensym("patternlength"), 2, track_proxy_getpatternlength(x, s1)); + } else if(s == gensym("getrow")) { + track_proxy_sendgui(x, gensym("row"), x->x_track->x_ncolumns + 2, track_proxy_getrow_with_header(x, s1, f2)); + } else if(s == gensym("setrow")) { + track_proxy_setrow(x, s, argc, argv); + } else if(s == gensym("getcell")) { + track_proxy_sendgui(x, gensym("cell"), 4, track_proxy_getcell_with_header(x, s1, f2, f3)); + } else if(s == gensym("setcell")) { + track_proxy_setcell(x, s, argc, argv); + } else if(s == gensym("addpattern")) { + p = track_proxy_addpattern(x, s1, f2); + if(p) { + debugprint("BAMBOLOOOOOO"); + //for(i = 0; i < p->x_rows_count; i++) + // track_proxy_sendgui(x, gensym("row"), x->x_track->x_ncolumns + 2, track_proxy_getrow_with_header(x, p->x_name, i)); + track_proxy_sendgui_pattern_names(x); + } + } else if(s == gensym("removepattern")) { + j = track_proxy_removepattern(x, s1); + if(j) { + track_proxy_sendgui_pattern_names(x); + } + } else if(s == gensym("resizepattern")) { + p = track_proxy_resizepattern(x, s1, f2); + if(p) { + track_proxy_sendgui(x, gensym("patternlength"), 2, track_proxy_getpatternlength(x, p->x_name)); + } + } else if(s == gensym("renamepattern")) { + p = track_proxy_renamepattern(x, s1, s2); + if(p) { + track_proxy_sendgui_pattern_names(x); + } + } else if(s == gensym("copypattern")) { + p = track_proxy_copypattern(x, s1, s2); + if(p) { + //for(i = 0; i < p->x_rows_count; i++) + // track_proxy_sendgui(x, gensym("row"), x->x_track->x_ncolumns + 2, track_proxy_getrow_with_header(x, p->x_name, i)); + track_proxy_sendgui_pattern_names(x); + } + } else { + error("track: editcmd: unknown command: %s", s->s_name); + } +} + +static void track_proxy_sendgui(t_track_proxy* x, t_symbol* s, int argc, t_atom* argv) { + static const unsigned int tmpsz = 80; + static const unsigned int bufsz = 8*MAXPDSTRING; + char* tmp; + char buf[bufsz]; + int i,j; + buf[0] = '\0'; + strncat(buf, s->s_name, bufsz); + strncat(buf, " ", bufsz); + for(i = 0; i < argc; i++) { + if(i > 0) strncat(buf, " ", bufsz); + if(argv[i].a_type == A_FLOAT) { + tmp = (char*)getbytes(tmpsz*sizeof(char)); + if(argv[i].a_w.w_float == (t_float)(t_int)argv[i].a_w.w_float) + sprintf(tmp, "%ld", (t_int)argv[i].a_w.w_float); + else + sprintf(tmp, "%f", argv[i].a_w.w_float); + strncat(buf, tmp, bufsz); + } else if(argv[i].a_type == A_SYMBOL) { + strncat(buf, argv[i].a_w.w_symbol->s_name, bufsz); + } else { + strncat(buf, "null", bufsz); + } + } + if(strlen(buf) >= bufsz) { + bug("track: sendgui: message too long"); + return; + } + sys_vgui("pd::composer::dispatch %s %s\n", x->rcv->s_name, buf); +} + +static void track_proxy_float(t_track_proxy* x, t_floatarg f) { + t_track* t = x->x_track; + if(t->x_patterns_count < 1) return; + + t_int curpat_i = (t_int) t->x_currentpat; + + if(curpat_i < 0) curpat_i = 0; + curpat_i = curpat_i % t->x_patterns_count; + + t_pattern* curpat = t->x_patterns[curpat_i]; + track_proxy_sendrow(x, curpat, (t_int) f); +} + +static void track_proxy_setrow(t_track_proxy* x, t_symbol* sel, int argc, t_atom* argv) { + if(argc < 2 || argv[0].a_type != A_SYMBOL || argv[1].a_type != A_FLOAT) { + error("track: setrow: usage: setrow ..."); + return; + } + if((argc - 2) != x->x_track->x_ncolumns) { + post("argc=%d, ncolumns=%d", argc, x->x_track->x_ncolumns); + error("track: setrow: input error: must provide exactly %d elements for the row", x->x_track->x_ncolumns); + return; + } + t_symbol* pat_name = argv[0].a_w.w_symbol; + t_int rownum = (t_int)argv[1].a_w.w_float; + ArrayListGetByName(x->x_track->x_patterns, pat_name, t_pattern*, pat); + if(!pat) { + error("track: setrow: no such pattern: '%s'", pat_name->s_name); + return; + } + pattern_setrow(pat, rownum, &argv[2]); +} + +static t_atom* track_proxy_getrow(t_track_proxy* x, t_symbol* pat_name, t_floatarg rownum) { + ArrayListGetByName(x->x_track->x_patterns, pat_name, t_pattern*, pat); + if(!pat) { + error("track: getrow: no such pattern: '%s'", pat_name->s_name); + return NULL; + } + t_atom* row = pattern_getrow(pat, (t_int)rownum); + debugprint("track_proxy_getrow returning " PTR, row); + return row; +} + +static t_atom* track_proxy_getrow_with_header(t_track_proxy* x, t_symbol* pat_name, t_floatarg rownum) { + t_atom* row = track_proxy_getrow(x, pat_name, rownum); + if(!row) { + error("track: getrow: nu such patern: '%s'", pat_name->s_name); + return NULL; + } + t_atom* row_with_hdr = (t_atom*)getbytes(sizeof(t_atom) * (x->x_track->x_ncolumns + 2)); + SETSYMBOL(&row_with_hdr[0], pat_name); + SETFLOAT(&row_with_hdr[1], rownum); + memcpy(&row_with_hdr[2], row, sizeof(t_atom) * x->x_track->x_ncolumns); + return row_with_hdr; +} + +static void track_proxy_getrow_o(t_track_proxy* x, t_symbol* pat_name, t_floatarg rownum) { + t_atom* row = track_proxy_getrow(x, pat_name, rownum); + if(row) + outlet_list(x->outlet, &s_list, x->x_track->x_ncolumns, row); +} + +static void track_proxy_setcell(t_track_proxy* x, t_symbol* sel, int argc, t_atom* argv) { + debugprint("track_proxy_setcell, s=%s", sel->s_name); + if(argc < 4 || argv[0].a_type != A_SYMBOL || argv[1].a_type != A_FLOAT || argv[2].a_type != A_FLOAT) { + error("track: setcell: usage: setcell "); + return; + } + t_symbol* pat_name = argv[0].a_w.w_symbol; + t_int rownum = (t_int)argv[1].a_w.w_float; + t_int colnum = (t_int)argv[2].a_w.w_float; + ArrayListGetByName(x->x_track->x_patterns, pat_name, t_pattern*, pat); + if(!pat) { + error("track: setcell: no such pattern: '%s'", pat_name->s_name); + return; + } + pattern_setcell(pat, (t_int)rownum, (t_int)colnum, &argv[3]); +} + +static t_atom* track_proxy_getcell(t_track_proxy* x, t_symbol* pat_name, t_floatarg rownum, t_floatarg colnum) { + ArrayListGetByName(x->x_track->x_patterns, pat_name, t_pattern*, pat); + if(!pat) { + error("track: getcell: no such pattern: '%s'", pat_name->s_name); + return NULL; + } + return pattern_getcell(pat, (t_int)rownum, (t_int)colnum); +} + +static t_atom* track_proxy_getcell_with_header(t_track_proxy* x, t_symbol* pat_name, t_floatarg rownum, t_floatarg colnum) { + t_atom* cell = track_proxy_getcell(x, pat_name, rownum, colnum); + if(!cell) { + error("track: getcell: nu such patern: '%s'", pat_name->s_name); + return NULL; + } + t_atom* row_with_hdr = (t_atom*)getbytes(sizeof(t_atom) * 4); + SETSYMBOL(&row_with_hdr[0], pat_name); + SETFLOAT(&row_with_hdr[1], rownum); + SETFLOAT(&row_with_hdr[2], colnum); + memcpy(&row_with_hdr[3], cell, sizeof(t_atom)); + return row_with_hdr; +} + +static void track_proxy_getcell_o(t_track_proxy* x, t_symbol* pat_name, t_floatarg rownum, t_floatarg colnum) { + t_atom* cell = track_proxy_getcell(x, pat_name, rownum, colnum); + if(cell) + outlet_list(x->outlet, &s_list, 1, cell); +} + +static t_pattern* track_proxy_addpattern(t_track_proxy* x, t_symbol* name, t_floatarg rows) { + return pattern_new(x->x_track, name, (t_int)rows); +} + +static int track_proxy_removepattern(t_track_proxy* x, t_symbol* name) { + ArrayListGetByName(x->x_track->x_patterns, name, t_pattern*, pat); + if(!pat) { + error("track: removepattern: no such pattern: '%s'", name->s_name); + return 0; //FAIL + } + pattern_free(pat); + return 1; //OK +} + +static t_pattern* track_proxy_resizepattern(t_track_proxy* x, t_symbol* name, t_floatarg rows) { + ArrayListGetByName(x->x_track->x_patterns, name, t_pattern*, pat); + if(!pat) { + error("track: resizepattern: no such pattern: '%s'", name->s_name); + return NULL; + } + pattern_resize(pat, (t_int)rows); + return pat; +} + +static t_pattern* track_proxy_renamepattern(t_track_proxy* x, t_symbol* name, t_symbol* newname) { + ArrayListGetByName(x->x_track->x_patterns, name, t_pattern*, pat); + if(!pat) { + error("track: renamepattern: no such pattern: '%s'", name->s_name); + return NULL; + } + pattern_rename(pat, newname); + return pat; +} + +static t_pattern* track_proxy_copypattern(t_track_proxy* x, t_symbol* src, t_symbol* dst) { + ArrayListGetByName(x->x_track->x_patterns, src, t_pattern*, pat); + if(!pat) { + error("track: copypattern: no such pattern: '%s'", src->s_name); + return NULL; + } + ArrayListGetByName(x->x_track->x_patterns, dst, t_pattern*, pat2); + if(pat2) { + error("track: copypattern: destination '%s' exists", pat2->x_name->s_name); + return NULL; + } + return pattern_clone(pat, dst); +} diff --git a/composer/window.tk b/composer/window.tk new file mode 100644 index 0000000..7e6b3eb --- /dev/null +++ b/composer/window.tk @@ -0,0 +1,599 @@ +# ------------------------------------------------------------------------ +# Copyright (c) 2009 Federico Ferri. +# For information on usage and redistribution, and for a DISCLAIMER OF ALL +# WARRANTIES, see the file, "LICENSE.txt," in this distribution. +# +# composer: a music composition framework for pure-data +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# See file LICENSE for further informations on licensing terms. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# Based on PureData by Miller Puckette and others. +# ------------------------------------------------------------------------ + +package require Tcl 8.5 +package require Tk 8.5 +package require Tktable 2.9 + +if {1 || ![info exists pd] && [info exists netsend]} { + set ::sendgui "netsend" +} else { + set ::sendgui "pd" +} + +namespace eval pd::composer { + variable debug + variable w + array set w {} + variable songname + array set songname {} + variable trackname + array set trackname {} + variable currentpattern + array set currentpattern {} + variable length + array set length {} + variable columns + array set columns {} + variable patterns + array set patterns {} + + variable quirks_fix_int_floats 0 + + proc debugPrint {args} { + variable debug + if {![info exists debug]} {set debug 0} + if {$debug} {puts stderr "composer-TCL: $args"} + } + + proc createPattern {id name len} { + debugPrint [info level 0] + variable length + variable patterns + + if {$name in $patterns($id)} { + return -code error "Pattern '$name' already exists" + } + set len [expr {int($len)}] + if {$len <= 0} { + return -code error "Length must be positive integer" + } + + $::sendgui [concat $id EDIT addpattern $name $len \;] + #lappend patterns($id) $name + #dict set length($id) $name $len + #$w($id).f.p configure -values $patterns($id) + } + + proc removePattern {id name} { + debugPrint [info level 0] + variable length; + variable patterns; + + $::sendgui [concat $id EDIT removepattern $name \;] + + #set oldidx [lsearch -exact $patterns($id) $name] + #set length($id) [dict remove $length($id) $name] + #set patterns($id) [lsearch -all -inline -not -exact $patterns($id) $name] + #while {$oldidx >= [llength $patterns($id)]} {incr oldidx -1} + #if {$oldidx < 0} {set oldidx 0} + #displayPattern $id [lindex $patterns($id) $oldidx] + } + + proc copyPattern {id src dst} { + debugPrint [info level 0] + variable length; + #upvar 0 $::datavar($w)_$src SRC + #upvar 0 $::datavar($w)_$dst DST + + $::sendgui [concat $id EDIT copypattern $src $dst \;] + + #createPattern $w $dst [dict get $length($id) $src] + #array set DST [array get SRC] + } + + proc resizePattern {id name newSize} { + debugPrint [info level 0] + variable currentpattern; + variable length; + + if {$newSize == [dict get $length($id) $name]} return + + set len [expr {int($newSize)}] + if {$len <= 0} { + return -code error "Length must pe positive integer" + } + + $::sendgui [concat $id EDIT resizepattern $name $len \;] + + #dict set length($id) $name $len + #if {$name == $currentpattern($id)} { + # refresh stuff + # displayPattern $id $name + #} + } + + proc renamePattern {id name newName} { + debugPrint [info level 0] + variable length; + variable patterns; + #upvar 0 $::datavar($w)_$name SRC + #upvar 0 $::datavar($w)_$newName DST + + if {$name == $newName} return + if {$newName in $patterns($id)} { + return -code error "Pattern name '$newName' already exists" + } + set idx [lsearch -exact $patterns($id) $name] + if {$idx == -1} { + return -code error "No such pattern: '$name'" + } + + $::sendgui [concat $id EDIT renamepattern $name $newName \;] + + #lset patterns($id) $idx $newName + #array set DST [array get SRC] + #array unset SRC + + #dict set length($id) $newName [dict get $length($id) $name] + #set length($id) [dict remove $length($id) $name] + + #displayPattern $id $newName + } + + proc generateNewPatternName {id} { + debugPrint [info level 0] + variable patterns; + set n 0 + while 1 { + set t "P[format %.02d $n]" + if {$t in $patterns($id)} {incr n} else {return $t} + } + } + + proc displayPattern {id name} { + debugPrint "request-pattern-length" + $::sendgui [concat $id EDIT getpatternlength $name \;] + } + + proc displayPattern_async {id name} { + debugPrint [info level 0] + variable currentpattern + variable patterns + variable length + variable columns + variable w + variable songname + variable trackname + variable [getDataVar $id] + + wm title $w($id) "Song: $songname($id) Track: $trackname($id)" + debugPrint "checkExit" + if {$name == {}} {return} + if {$name ni $patterns($id)} { + debugPrint "Pattern '$name' does not exist" + return -code error "Pattern '$name' does not exist" + } + debugPrint "s1" + set rows [dict get $length($id) $name] + set cols $columns($id) + debugPrint "resizing tktable widget to ${rows}x${cols}" + grid $w($id).t -row 10 -column 0 -sticky news + $w($id).t configure -state normal -variable [getDataVar $id] -rows $rows -cols [expr {1+$cols}] + debugPrint "s2" + $w($id).f.p configure -values $patterns($id) + debugPrint "s3" + $w($id).f.p current [lsearch -exact $patterns($id) $name] + debugPrint "setCurPattern" + set currentpattern($id) $name + debugPrint "setTitle" + wm title $w($id) "Song: $songname($id) Track: $trackname($id) Pattern: $name" + } + + proc displayCurrentPattern {id} { + debugPrint [info level 0] + variable currentpattern + variable w + debugPrint "current pattern is {$currentpattern($id)}" + displayPattern $id $currentpattern($id) + } + + proc rowTag {id r} { + debugPrint [info level 0] + if {$r % $::div1 == 0} {return "alt0"} + if {$r % $::div2 == 0} {return "alt1"} + } + + proc refreshGrid {id} { + debugPrint [info level 0] + variable currentpattern + debugPrint "currentPattern is {$currentpattern($id)}" + variable w + $w($id).t configure -padx [$w($id).t cget -padx] + } + + proc edit {id r c bwrite value} { + # NOT USED + #if {$bwrite} { + # $::sendgui [concat $id EDIT setcell $currentpattern($id) $r $c $value \;] + #} else { + #} + } + + proc getDataVar {id {P {}}} { + variable currentpattern + variable songname + variable trackname + if {$P == ""} {set P $currentpattern($id)} + set n "[namespace current]::data_$songname($id)_$trackname($id)_$P" + if {![info exists $n]} {array set $n {}} + return $n + } + + proc createMainWindow {id} { + debugPrint [info level 0] + variable currentpattern; + variable w + variable songname + variable trackname + variable patterns + variable [getDataVar $id] + + catch {destroy $w($id)} + debugPrint "creating window with path = '$w($id)'" + toplevel $w($id) + + debugPrint "top-toolbar(frame)" + grid [ttk::frame $w($id).f] \ + -row 5 -columnspan 2 -sticky news + debugPrint "label" + grid [ttk::label $w($id).f.l -text "Pattern: "] \ + -row 0 -column 0 -in $w($id).f + debugPrint "combobox patterns" + grid [ttk::combobox $w($id).f.p -textvariable "[namespace current]::currentpattern($id)"] \ + -row 0 -column 1 -in $w($id).f + debugPrint "divs" + grid [ttk::label $w($id).f.ld1 -text "Div1: "] \ + -row 0 -column 2 -in $w($id).f + grid [spinbox $w($id).f.d1 -command "[namespace current]::refreshGrid $id" -from 8 -to 64 \ + -increment 1 -format %3.0f -width 3 -textvar ::div1] \ + -row 0 -column 3 -in $w($id).f + grid [ttk::label $w($id).f.ld2 -text "Div2: "] \ + -row 0 -column 4 -in $w($id).f + grid [spinbox $w($id).f.d2 -command "[namespace current]::refreshGrid $id" -from 2 -to 64 \ + -increment 1 -format %3.0f -width 3 -textvar ::div2] \ + -row 0 -column 5 -in $w($id).f + + debugPrint "step2" + $w($id).f.p state readonly + + # movet to async counterpart + #$w($id).f.p configure -values $patterns($id) + + debugPrint "request-patterns" + $::sendgui [concat $id EDIT getpatterns \;] + + debugPrint "bindevent" + bind $w($id).f.p <> "[namespace current]::displayCurrentPattern $id" + debugPrint "table" + #grid [ + table $w($id).t -state disabled \ + -insertofftime 0 \ + -bordercursor sb_h_double_arrow \ + -colorigin -1 -sparsearray 1 \ + -relief ridge -takefocus 1 -borderwidth 1 -colwidth 4 \ + -browsecmd "[namespace current]::activeCellChanges $id %r %c" \ + -cols 0 -rows 0 \ + -cache 0 \ + -usecommand 0 -command "[namespace current]::edit $id %r %c %i %s" \ + -colstretchmode none -rowstretchmode none \ + -flashmode 1 -flashtime 2 -autoclear 1 \ + -justify left -multiline 0 -resizeborders col \ + -selectmode extended -selecttype cell \ + -titlecols 1 -titlerows 0 -validate 1 \ + -validatecommand "[namespace current]::validateCommand $id %r %c %s %S" \ + -variable [getDataVar $id] -exportselection 1 \ + -xscrollcommand "$w($id).hscroll set" \ + -yscrollcommand "$w($id).vscroll set" \ + -rowtagcommand "[namespace current]::rowTag $id" \ + + #] -row 10 -column 0 -sticky news + + #grid $w($id).t -row 10 -column 0 -sticky news + + debugPrint "scrollbars" + grid [ttk::scrollbar $w($id).vscroll -orient vertical -command "$w($id).t yview"] -row 10 -column 1 -sticky ns + grid [ttk::scrollbar $w($id).hscroll -orient horizontal -command "$w($id).t xview"] -row 15 -column 0 -sticky ew + #grid [ttk::sizegrip $w($id).resize] -row 15 -column 1 -sticky se + + grid [ttk::entry $w($id).eval] -row 20 -columnspan 2 -sticky ew + bind $w($id).eval "set cmd \[$w($id).eval get]; namespace eval [namespace current] \$cmd; $w($id).eval delete 0 end" + + debugPrint "grid" + grid columnconfigure $w($id) 0 -weight 1 + grid rowconfigure $w($id) 10 -weight 1 + + debugPrint "table-tags" + $w($id).t tag configure active -relief solid -background gray -foreground black + $w($id).t tag configure flash -background red -foreground white + $w($id).t tag configure sel -background blue -foreground white + $w($id).t tag configure title -background gray -foreground white -justify right + $w($id).t tag configure alt0 -background "#20a8b8" + $w($id).t tag configure alt1 -background "#0f7f9f" + $w($id).t tag configure notecol -background "#dddded" + + debugPrint "wm" + wm minsize $w($id) 300 150 + wm protocol $w($id) WM_DELETE_WINDOW "$::sendgui $id EDIT editor-close \\;" + + debugPrint "menu" + menu $w($id).m -tearoff 0 + $w($id).m add command -label "New pattern..." \ + -command "[namespace current]::newPatternDialog $id" + $w($id).m add command -label "Pattern properties..." \ + -command "[namespace current]::patternPropertiesDialog $id" + $w($id).m add command -label "Remove pattern..." \ + -command "[namespace current]::removePatternConfirm $id" + $w($id).m add command -label "Create copy..." \ + -command "[namespace current]::copyPatternDialog $id" + + menu $w($id).mb + $w($id) configure -menu $w($id).mb + menu $w($id).mb.tools -tearoff 0 + $w($id).mb.tools add command -label {Reload} \ + -command {uplevel 0 {source $argv0}} + $w($id).mb add cascade -label {Pattern} -menu $w($id).m + $w($id).mb add cascade -label {Utils} -menu $w($id).mb.tools + + debugPrint "more-bind-events" + bind $w($id).t "$w($id).t activate @%x,%y; tk_popup $w($id).m %X %Y" + bind $w($id).t "switchColumnType $id" + + return $w($id) + } + + proc switchColumnType {id} { + debugPrint [info level 0] + variable w + global colType + set curcol [$w($id).t index active col] + set tag {} + if {![info exists colType(c$curcol)]} { + set colType(c$curcol) {notes} + set tag {notecol} + } elseif {$colType(c$curcol) == {notes}} { + unset colType(c$curcol) + } + + $w($id).t tag col $tag $curcol + #refreshGrid + } + + proc activeCellChanges {id row col} { + debugPrint [info level 0] + variable w + if {$col < 0} {$w($id).t activate $row,[incr col]} + } + + proc validateCommand {id row col curVal newVal} { + debugPrint [info level 0] + variable currentpattern + + $::sendgui [concat $id EDIT setcell $currentpattern($id) $row $col $newVal \;] + + return 1 + } + + proc patternPropertiesDialog_common {id options} { + debugPrint [info level 0] + variable currentpattern + variable w + set bname 1 + set blength 1 + set old_name {} + catch {set old_name $currentpattern($id)} + set vname {} + set vlength {} + set action_cancel {destroy %w} + set action_ok $action_cancel + + set opts {vname vlength bname blength action_ok action_cancel} + foreach opt $opts { + catch {set $opt [dict get $options $opt]} + } + foreach {o v} $options { + if {$o ni $opts} { + return -code error "Invalid option: $o" + } + } + + set w_ $w($id).patternProps + catch {destroy $w_} + toplevel $w_ + + foreach v {action_ok action_cancel} { + set $v [string map [list %ns [namespace current] %id $id %w $w_ %old_name $old_name] [set $v]] + } + + grid [ttk::label $w_.lname -text "Name: "] -row 0 -column 0 + grid [ttk::label $w_.llength -text "Rows: "] -row 1 -column 0 + grid [ttk::entry $w_.ename] -row 0 -column 1 + grid [ttk::entry $w_.elength] -row 1 -column 1 + grid [ttk::frame $w_.b] -row 2 -columnspan 2 + grid [ttk::button $w_.b.ok -text Ok -command $action_ok] -row 0 -column 0 -in $w_.b + grid [ttk::button $w_.b.cancel -text Cancel -command $action_cancel] -row 0 -column 1 -in $w_.b + + $w_.ename insert 0 $vname + $w_.elength insert 0 $vlength + + if {!$bname} {$w_.ename configure -state disabled} + if {!$blength} {$w_.elength configure -state disabled} + } + + proc patternPropertiesDialog {id {options {}}} { + debugPrint [info level 0] + variable currentpattern; + variable length; + + dict set options action_ok { + %ns::resizePattern %id %old_name [%w.elength get] + %ns::renamePattern %id %old_name [%w.ename get] + destroy %w + } + dict set options vname $currentpattern($id) + dict set options vlength [dict get $length($id) $currentpattern($id)] + patternPropertiesDialog_common $id $options + } + + proc copyPatternDialog {id {options {}}} { + debugPrint [info level 0] + variable w; + variable length; + + dict set options blength 0 + dict set options vname [generateNewPatternName $id] + dict set options vlength [dict get $length($id) $currentpattern($id)] + dict set options action_ok { + %ns::copyPattern %id %old_name [%w.ename get] + %ns::displayPattern %id [%w.ename get] + destroy %w + } + patternPropertiesDialog_common $id $options + } + + proc removePatternConfirm {id} { + debugPrint [info level 0] + variable currentpattern; + if {[tk_messageBox \ + -type yesno -default no \ + -title "Question" \ + -icon question -message "Do you confirm pattern delete?" \ + -detail "The operation cannot be undone" \ + -parent $w] == {yes}} { + removePattern $id $currentpattern($id) + } + } + + proc newPatternDialog {id {options {}}} { + debugPrint [info level 0] + dict set options action_ok { + %ns::createPattern %id [%w.ename get] [%w.elength get] + destroy %w + } + # %ns::displayPattern %id [%w.ename get] + dict set options vname [generateNewPatternName $id] + dict set options vlength 16 + patternPropertiesDialog_common $id $options + } + + #entrypoint + proc init {id song_name track_name cols debug_flag} { + debugPrint [info level 0] + variable debug + set debug [expr {$debug_flag != 0}] + variable w + variable songname + variable trackname + variable length + variable currentpattern + variable columns + set w($id) .w_${song_name}_${track_name} + set songname($id) $song_name + set trackname($id) $track_name + set currentpattern($id) {} + set length($id) {} + set columns($id) $cols + } + + proc openWindow {id} { + debugPrint [info level 0] + createMainWindow $id + } + + proc closeWindow {id} { + debugPrint [info level 0] + variable w + destroy $w($id) + } + + proc dispatch {id args} { + debugPrint [info level 0] + variable w + variable patterns + variable length + variable currentpattern + variable quirks_fix_int_floats + switch -exact [lindex $args 0] { + patterns { + set patterns($id) [lrange $args 1 end] + debugPrint "tk::patterns <- $patterns($id)" + $w($id).f.p configure -values $patterns($id) + if {0 && [llength $patterns($id)] > 0 && $currentpattern($id) == {}} { + set firstpat [lindex $patterns($id) 0] + debugPrint "showing pattern '$firstpat'" + displayPattern $id $firstpat + } + } + patternlength { + set pat_name [lindex $args 1] + set pat_length [lindex $args 2] + debugPrint "got patternlength: '$pat_name' (len=$pat_length)" + if {![dict exists $length($id) $pat_name] || [dict get $length($id) $pat_name] != $pat_length} { + dict set length($id) $pat_name $pat_length + for {set i 0} {$i < $pat_length} {incr i} { + $::sendgui [concat $id EDIT getrow $pat_name $i \;] + } + } + displayPattern_async $id $pat_name + } + row { + set pat_name [lindex $args 1] + if {$quirks_fix_int_floats} { + set row_num [expr {int([lindex $args 2])}] + } else { + set row_num [lindex $args 2] + } + set row [lrange $args 3 end] + debugPrint "got row: '$pat_name' ($row_num) {$row}" + debugPrint "dataVar = [getDataVar $id $pat_name]" + upvar 0 [getDataVar $id $pat_name] data + set data($row_num,-1) [expr {1+$row_num}] + for {set i 0} {$i < [llength $row]} {incr i} { + debugPrint "set data($row_num,$i) [lindex $row $i]" + set data($row_num,$i) [lindex $row $i] + } + if {$row_num + 1 == [dict get $length($id) $pat_name]} { + #refreshGrid $id + } + } + cell { + set pat_name [lindex $args 1] + if {$quirks_fix_int_floats} { + set row_num [expr {int([lindex $args 2])}] + set col_num [expr {int([lindex $args 3])}] + } else { + set row_num [lindex $args 2] + set col_num [lindex $args 3] + } + set cell [lindex $args 4] + debugPrint "got cell: '$pat_name' ($row_num,$col_num) {$cell}" + debugPrint "dataVar = [getDataVar $id $pat_name]" + upvar 0 [getDataVar $id $pat_name] data + set data($row_num,$col_num) $cell + } + } + } +} -- cgit v1.2.1