From d6b088044e161a27d49df537bbb6d998a8d0e50d Mon Sep 17 00:00:00 2001 From: musil Date: Sat, 9 Dec 2006 02:00:52 +0000 Subject: // class_sethelpsymbol(); changed help-*.pd to *-help.pd chanded file structure to standard 1st step remove old svn path=/trunk/externals/iemlib/; revision=6756 --- iemlib2/$n-help.pd | 95 +++++ iemlib2/LFO_noise~-help.pd | 38 ++ iemlib2/add2_comma-help.pd | 57 +++ iemlib2/any-help.pd | 140 +++++++ iemlib2/bpe-help.pd | 49 +++ iemlib2/dollarg-help.pd | 95 +++++ iemlib2/exp_inc-help.pd | 83 ++++ iemlib2/fade~-help.pd | 50 +++ iemlib2/float24-help.pd | 77 ++++ iemlib2/iem_anything-help.pd | 140 +++++++ iemlib2/iem_append-help.pd | 75 ++++ iemlib2/iem_blocksize~-help.pd | 40 ++ iemlib2/iem_i_route-help.pd | 135 +++++++ iemlib2/iem_pbank_csv-help.pd | 164 ++++++++ iemlib2/iem_prepend-help.pd | 75 ++++ iemlib2/iem_r-help.pd | 45 +++ iemlib2/iem_receive-help.pd | 45 +++ iemlib2/iem_route-help.pd | 48 +++ iemlib2/iem_s-help.pd | 68 ++++ iemlib2/iem_samplerate~-help.pd | 40 ++ iemlib2/iem_sel_any-help.pd | 56 +++ iemlib2/iem_send-help.pd | 68 ++++ iemlib2/ii-help.pd | 49 +++ iemlib2/iiroute-help.pd | 135 +++++++ iemlib2/init-help.pd | 49 +++ iemlib2/list2send-help.pd | 105 +++++ iemlib2/m2f~-help.pd | 31 ++ iemlib2/mergefilename-help.pd | 50 +++ iemlib2/modulo_counter-help.pd | 24 ++ iemlib2/parent$0-help.pd | 27 ++ iemlib2/parentdollarzero-help.pd | 27 ++ iemlib2/post_netreceive-help.pd | 116 ++++++ iemlib2/pp-help.pd | 75 ++++ iemlib2/pre_inlet-help.pd | 42 ++ iemlib2/pre_netsend-help.pd | 53 +++ iemlib2/prepend-help.pd | 75 ++++ iemlib2/prepend_ascii-help.pd | 45 +++ iemlib2/receive2list-help.pd | 121 ++++++ iemlib2/round_zero-help.pd | 21 + iemlib2/speedlim-help.pd | 33 ++ iemlib2/splitfilename-help.pd | 89 +++++ iemlib2/src/LFO_noise~.c | 122 ++++++ iemlib2/src/add2_comma.c | 116 ++++++ iemlib2/src/bpe.c | 119 ++++++ iemlib2/src/dollarg.c | 105 +++++ iemlib2/src/exp_inc.c | 132 ++++++ iemlib2/src/fade~.c | 176 ++++++++ iemlib2/src/float24.c | 81 ++++ iemlib2/src/iem_anything.c | 137 +++++++ iemlib2/src/iem_append.c | 355 +++++++++++++++++ iemlib2/src/iem_blocksize~.c | 55 +++ iemlib2/src/iem_i_route.c | 105 +++++ iemlib2/src/iem_pbank_csv.c | 798 +++++++++++++++++++++++++++++++++++++ iemlib2/src/iem_prepend.c | 246 ++++++++++++ iemlib2/src/iem_receive.c | 175 ++++++++ iemlib2/src/iem_route.c | 192 +++++++++ iemlib2/src/iem_samplerate~.c | 55 +++ iemlib2/src/iem_sel_any.c | 108 +++++ iemlib2/src/iem_send.c | 158 ++++++++ iemlib2/src/iemlib.h | 108 +++++ iemlib2/src/iemlib2.c | 103 +++++ iemlib2/src/iemlib2.dsp | 85 ++++ iemlib2/src/iemlib2.dsw | 29 ++ iemlib2/src/init.c | 196 +++++++++ iemlib2/src/list2send.c | 245 ++++++++++++ iemlib2/src/m2f~.c | 119 ++++++ iemlib2/src/makefile | 4 + iemlib2/src/makefile_linux | 82 ++++ iemlib2/src/makefile_win | 68 ++++ iemlib2/src/mergefilename.c | 223 +++++++++++ iemlib2/src/modulo_counter.c | 82 ++++ iemlib2/src/parentdollarzero.c | 53 +++ iemlib2/src/post_netreceive.c | 234 +++++++++++ iemlib2/src/pre_inlet.c | 91 +++++ iemlib2/src/prepend_ascii.c | 121 ++++++ iemlib2/src/protect_against_open.c | 99 +++++ iemlib2/src/receive2list.c | 216 ++++++++++ iemlib2/src/round_zero.c | 60 +++ iemlib2/src/speedlim.c | 100 +++++ iemlib2/src/splitfilename.c | 130 ++++++ iemlib2/src/stripfilename.c | 77 ++++ iemlib2/src/toggle_mess.c | 114 ++++++ iemlib2/src/transf_fader.c | 147 +++++++ iemlib2/src/unsymbol.c | 40 ++ iemlib2/src/wrap.c | 63 +++ iemlib2/stripfilename-help.pd | 26 ++ iemlib2/toggle_mess-help.pd | 72 ++++ iemlib2/transf_fader-help.pd | 33 ++ iemlib2/unsymbol-help.pd | 23 ++ iemlib2/wrap-help.pd | 19 + 90 files changed, 9147 insertions(+) create mode 100644 iemlib2/$n-help.pd create mode 100644 iemlib2/LFO_noise~-help.pd create mode 100644 iemlib2/add2_comma-help.pd create mode 100644 iemlib2/any-help.pd create mode 100644 iemlib2/bpe-help.pd create mode 100644 iemlib2/dollarg-help.pd create mode 100644 iemlib2/exp_inc-help.pd create mode 100644 iemlib2/fade~-help.pd create mode 100644 iemlib2/float24-help.pd create mode 100644 iemlib2/iem_anything-help.pd create mode 100644 iemlib2/iem_append-help.pd create mode 100644 iemlib2/iem_blocksize~-help.pd create mode 100644 iemlib2/iem_i_route-help.pd create mode 100644 iemlib2/iem_pbank_csv-help.pd create mode 100644 iemlib2/iem_prepend-help.pd create mode 100644 iemlib2/iem_r-help.pd create mode 100644 iemlib2/iem_receive-help.pd create mode 100644 iemlib2/iem_route-help.pd create mode 100644 iemlib2/iem_s-help.pd create mode 100644 iemlib2/iem_samplerate~-help.pd create mode 100644 iemlib2/iem_sel_any-help.pd create mode 100644 iemlib2/iem_send-help.pd create mode 100644 iemlib2/ii-help.pd create mode 100644 iemlib2/iiroute-help.pd create mode 100644 iemlib2/init-help.pd create mode 100644 iemlib2/list2send-help.pd create mode 100644 iemlib2/m2f~-help.pd create mode 100644 iemlib2/mergefilename-help.pd create mode 100644 iemlib2/modulo_counter-help.pd create mode 100644 iemlib2/parent$0-help.pd create mode 100644 iemlib2/parentdollarzero-help.pd create mode 100644 iemlib2/post_netreceive-help.pd create mode 100644 iemlib2/pp-help.pd create mode 100644 iemlib2/pre_inlet-help.pd create mode 100644 iemlib2/pre_netsend-help.pd create mode 100644 iemlib2/prepend-help.pd create mode 100644 iemlib2/prepend_ascii-help.pd create mode 100644 iemlib2/receive2list-help.pd create mode 100644 iemlib2/round_zero-help.pd create mode 100644 iemlib2/speedlim-help.pd create mode 100644 iemlib2/splitfilename-help.pd create mode 100644 iemlib2/src/LFO_noise~.c create mode 100644 iemlib2/src/add2_comma.c create mode 100644 iemlib2/src/bpe.c create mode 100644 iemlib2/src/dollarg.c create mode 100644 iemlib2/src/exp_inc.c create mode 100644 iemlib2/src/fade~.c create mode 100644 iemlib2/src/float24.c create mode 100644 iemlib2/src/iem_anything.c create mode 100644 iemlib2/src/iem_append.c create mode 100644 iemlib2/src/iem_blocksize~.c create mode 100644 iemlib2/src/iem_i_route.c create mode 100644 iemlib2/src/iem_pbank_csv.c create mode 100644 iemlib2/src/iem_prepend.c create mode 100644 iemlib2/src/iem_receive.c create mode 100644 iemlib2/src/iem_route.c create mode 100644 iemlib2/src/iem_samplerate~.c create mode 100644 iemlib2/src/iem_sel_any.c create mode 100644 iemlib2/src/iem_send.c create mode 100644 iemlib2/src/iemlib.h create mode 100644 iemlib2/src/iemlib2.c create mode 100644 iemlib2/src/iemlib2.dsp create mode 100644 iemlib2/src/iemlib2.dsw create mode 100644 iemlib2/src/init.c create mode 100644 iemlib2/src/list2send.c create mode 100644 iemlib2/src/m2f~.c create mode 100644 iemlib2/src/makefile create mode 100644 iemlib2/src/makefile_linux create mode 100644 iemlib2/src/makefile_win create mode 100644 iemlib2/src/mergefilename.c create mode 100644 iemlib2/src/modulo_counter.c create mode 100644 iemlib2/src/parentdollarzero.c create mode 100644 iemlib2/src/post_netreceive.c create mode 100644 iemlib2/src/pre_inlet.c create mode 100644 iemlib2/src/prepend_ascii.c create mode 100644 iemlib2/src/protect_against_open.c create mode 100644 iemlib2/src/receive2list.c create mode 100644 iemlib2/src/round_zero.c create mode 100644 iemlib2/src/speedlim.c create mode 100644 iemlib2/src/splitfilename.c create mode 100644 iemlib2/src/stripfilename.c create mode 100644 iemlib2/src/toggle_mess.c create mode 100644 iemlib2/src/transf_fader.c create mode 100644 iemlib2/src/unsymbol.c create mode 100644 iemlib2/src/wrap.c create mode 100644 iemlib2/stripfilename-help.pd create mode 100644 iemlib2/toggle_mess-help.pd create mode 100644 iemlib2/transf_fader-help.pd create mode 100644 iemlib2/unsymbol-help.pd create mode 100644 iemlib2/wrap-help.pd (limited to 'iemlib2') diff --git a/iemlib2/$n-help.pd b/iemlib2/$n-help.pd new file mode 100644 index 0000000..21d5ede --- /dev/null +++ b/iemlib2/$n-help.pd @@ -0,0 +1,95 @@ +#N canvas 50 236 958 401 10; +#X floatatom 27 77 5 -14 14 0 - - -; +#X obj 98 81 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 471 151 5 0 0 0 - - -; +#X obj 471 179 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X symbolatom 202 218 10 0 0 0 - - -; +#X floatatom 150 219 5 0 0 0 - - -; +#X obj 98 156 route list float symbol; +#X obj 98 181 pp set; +#X obj 75 261 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 150 242 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 202 240 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 98 113 test_dollarg aa bb cc dd ee ff gg 33 44 55 66 77 88 99 +; +#X text 93 7 receives the parent initial arguments \, like a +$n; +#X text 168 92 open test_dollarg abstraction; +#X obj 330 45 dollarg; +#X text 398 44 abbrv.; +#X obj 448 44 $n 1; +#X text 490 46 1.arg: n (optional \, default 0); +#X msg 98 261; +#N canvas 8 40 450 300 reset________ 0; +#X obj 48 41 inlet; +#X obj 53 210 outlet; +#X obj 48 73 route list float symbol; +#X obj 121 212 outlet; +#X obj 197 212 outlet; +#X msg 53 187 set; +#X obj 48 99 bang; +#X obj 100 97 bang; +#X obj 152 97 bang; +#X msg 121 187 set 0; +#X msg 197 186 set symbol; +#X connect 0 0 2 0; +#X connect 2 0 6 0; +#X connect 2 1 7 0; +#X connect 2 2 8 0; +#X connect 5 0 1 0; +#X connect 6 0 10 0; +#X connect 6 0 9 0; +#X connect 7 0 5 0; +#X connect 7 0 10 0; +#X connect 8 0 5 0; +#X connect 8 0 9 0; +#X connect 9 0 3 0; +#X connect 10 0 4 0; +#X restore 125 134 pd reset________; +#X msg 27 53 0; +#X msg 63 53 1; +#X msg 96 53 2; +#X msg 211 53 -1; +#X text 451 6 (like float \$1 \, or symbol \$1); +#X text 559 91 eg. m = number of parent arguments + 1; +#X text 531 64 if (n = 0) -> dollarg output all parent arguments; +#X text 531 78 if (n > 0) -> dollarg output the n-th parent argument +; +#X text 532 102 if (n < 0) -> dollarg output the (m+n)-th parent argument +; +#X msg 173 53 -2; +#X msg 135 53 12; +#X text 343 267 IEM KUG; +#X text 327 255 musil; +#X text 357 255 @; +#X text 363 255 iem.at; +#X text 278 244 (c) Thomas Musil 2000 - 2005; +#X text 326 277 Graz \, Austria; +#X text 7 8 $n = dollarg; +#X connect 0 0 11 0; +#X connect 1 0 11 0; +#X connect 2 0 3 0; +#X connect 4 0 10 0; +#X connect 5 0 9 0; +#X connect 6 0 7 0; +#X connect 6 1 5 0; +#X connect 6 2 4 0; +#X connect 7 0 18 0; +#X connect 7 0 8 0; +#X connect 11 0 6 0; +#X connect 11 0 19 0; +#X connect 11 1 2 0; +#X connect 19 0 18 0; +#X connect 19 1 5 0; +#X connect 19 2 4 0; +#X connect 20 0 0 0; +#X connect 21 0 0 0; +#X connect 22 0 0 0; +#X connect 23 0 0 0; +#X connect 29 0 0 0; +#X connect 30 0 0 0; diff --git a/iemlib2/LFO_noise~-help.pd b/iemlib2/LFO_noise~-help.pd new file mode 100644 index 0000000..1081390 --- /dev/null +++ b/iemlib2/LFO_noise~-help.pd @@ -0,0 +1,38 @@ +#N canvas 299 177 455 328 10; +#X text 38 49 dsp ON/OFF; +#X floatatom 212 173 7 0 0 0 - - -; +#X text 279 175 dB; +#X floatatom 21 89 5 0 0 0 - - -; +#X text 69 90 % cpu; +#X obj 21 69 dsp; +#X obj 21 49 tgl 15 0 empty empty empty 8 -8 0 10 -262144 -1 -1 0 1 +; +#X obj 32 230 dac~; +#X obj 32 205 gainvu~ 300; +#X obj 259 51 vu 15 120 empty empty 8 -8 0 10 -66577 -1 1 0; +#X obj 352 74 vsl 15 128 0 127 0 1 empty empty empty 8 -8 0 10 -262144 +-1 -1 9000 1; +#X floatatom 324 223 7 0 0 0 - - -; +#X text 382 225 dB; +#X obj 32 142 LFO_noise~ 2; +#X text 121 141 1.arg: cutoff-freq.; +#X floatatom 32 116 4 0 500 0 - - -; +#X text 15 7 LFO_noise~ : 2-point-interpolated time-stretched white +noise; +#X text 118 21 between -0.5 and +0.5; +#X text 106 285 IEM KUG; +#X text 90 273 musil; +#X text 120 273 @; +#X text 126 273 iem.at; +#X text 41 262 (c) Thomas Musil 2000 - 2005; +#X text 89 295 Graz \, Austria; +#X connect 5 0 3 0; +#X connect 6 0 5 0; +#X connect 8 0 7 0; +#X connect 8 0 7 1; +#X connect 8 1 11 0; +#X connect 8 2 9 0; +#X connect 9 1 1 0; +#X connect 10 0 8 1; +#X connect 13 0 8 0; +#X connect 15 0 13 0; diff --git a/iemlib2/add2_comma-help.pd b/iemlib2/add2_comma-help.pd new file mode 100644 index 0000000..31c4e1a --- /dev/null +++ b/iemlib2/add2_comma-help.pd @@ -0,0 +1,57 @@ +#N canvas 115 227 780 417 10; +#X msg 25 63 aaa; +#X msg 61 65 345; +#X msg 103 66 symbol www; +#X msg 199 65 123 987 3.14159; +#X msg 238 126 open file 456; +#X msg 199 91 1.9 -8.2; +#X msg 243 154 write 67; +#X msg 389 56 aaa; +#X msg 425 58 345; +#X msg 467 59 symbol www; +#X msg 563 58 123 987 3.14159; +#X msg 602 119 open file 456; +#X msg 563 84 1.9 -8.2; +#X msg 607 147 write 67; +#X obj 458 158 add2_comma; +#X obj 363 58 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 6 64 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 -1 +; +#X msg 55 223 set; +#X msg 27 248 add2 abc; +#X msg 24 278 add2 11.55; +#X obj 24 198 loadbang; +#X text 13 4 add2_comma; +#X text 110 4 add a comma after a message; +#X msg 90 309; +#X msg 457 187; +#X obj 86 180 add2_comma; +#X text 263 267 IEM KUG; +#X text 247 255 musil; +#X text 277 255 @; +#X text 283 255 iem.at; +#X text 198 244 (c) Thomas Musil 2000 - 2005; +#X text 246 277 Graz \, Austria; +#X connect 0 0 25 0; +#X connect 1 0 25 0; +#X connect 2 0 25 0; +#X connect 3 0 25 0; +#X connect 4 0 25 0; +#X connect 5 0 25 0; +#X connect 6 0 25 0; +#X connect 7 0 14 0; +#X connect 8 0 14 0; +#X connect 9 0 14 0; +#X connect 10 0 14 0; +#X connect 11 0 14 0; +#X connect 12 0 14 0; +#X connect 13 0 14 0; +#X connect 14 0 24 0; +#X connect 15 0 14 0; +#X connect 16 0 25 0; +#X connect 17 0 23 0; +#X connect 18 0 23 0; +#X connect 19 0 23 0; +#X connect 20 0 17 0; +#X connect 25 0 23 0; diff --git a/iemlib2/any-help.pd b/iemlib2/any-help.pd new file mode 100644 index 0000000..79ccc4c --- /dev/null +++ b/iemlib2/any-help.pd @@ -0,0 +1,140 @@ +#N canvas 194 199 779 617 10; +#X obj 21 148 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 -1 +-1; +#X obj 48 148 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 -1 +-1; +#X obj 89 206 print; +#X obj 89 148 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 -1 +-1; +#X obj 292 148 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 +-1 -1; +#X obj 292 208 print; +#X msg 343 210; +#X obj 369 155 loadbang; +#X msg 369 176 set; +#X obj 26 225 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 -1 +-1; +#X obj 26 280 print; +#X obj 400 382 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 +-1 -1; +#X obj 457 491 print; +#X msg 457 56 88; +#X msg 457 132 symbol www; +#X msg 457 75 float 77; +#X obj 137 148 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 +-1 -1; +#X msg 457 94 list 66; +#X msg 457 113 www; +#X msg 457 151 list www; +#X msg 457 189 list 99 888 hhh; +#X msg 457 208 float 99 888 hhh; +#X msg 457 227 symbol 99 888 hhh; +#X msg 457 170 99 888 hhh; +#X msg 457 246 kkk jjj 345; +#X msg 457 265 symbol kkk jjj 345; +#X msg 457 284 list kkk jjj 345; +#X msg 90 432; +#X obj 137 376 loadbang; +#X msg 123 401 set; +#X obj 26 252 any open filename 55; +#X obj 457 463 iem_anything; +#X obj 90 400 any; +#X obj 27 342 bang; +#X obj 27 366 del 999; +#X msg 620 205 88; +#X msg 619 281 symbol www; +#X msg 619 224 float 77; +#X msg 619 243 list 66; +#X msg 619 262 www; +#X msg 619 300 list www; +#X msg 619 338 list 99 888 hhh; +#X msg 619 357 float 99 888 hhh; +#X msg 619 376 symbol 99 888 hhh; +#X msg 619 319 99 888 hhh; +#X msg 619 395 kkk jjj 345; +#X msg 619 414 symbol kkk jjj 345; +#X msg 619 433 list kkk jjj 345; +#X msg 361 383 bang; +#X obj 540 363 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 +-1 -1; +#X msg 501 364 bang; +#X msg 106 307 set display this with 1 second delay; +#X obj 123 342 bang; +#X text 296 9 (like f or float for -messages); +#X text 131 9 is a latch for anything; +#X obj 229 376 del 4999; +#X text 298 19 (or like symbol for -messages); +#X obj 104 85 iem_anything; +#X text 195 85 arguments: any message; +#X text 96 67 <-hot; +#X text 146 67 cold->; +#X text 134 35 abbr. any; +#X obj 21 175 any; +#X obj 48 175 any 88; +#X obj 89 175 any www; +#X obj 137 175 any symbol www; +#X obj 292 175 any set 88; +#X text 184 524 IEM KUG; +#X text 168 512 musil; +#X text 198 512 @; +#X text 204 512 iem.at; +#X text 119 501 (c) Thomas Musil 2000 - 2005; +#X text 167 534 Graz \, Austria; +#X text 23 11 iem_any; +#X connect 0 0 62 0; +#X connect 1 0 63 0; +#X connect 3 0 64 0; +#X connect 4 0 66 0; +#X connect 7 0 8 0; +#X connect 8 0 6 0; +#X connect 9 0 30 0; +#X connect 11 0 31 0; +#X connect 13 0 31 0; +#X connect 14 0 31 0; +#X connect 15 0 31 0; +#X connect 16 0 65 0; +#X connect 17 0 31 0; +#X connect 18 0 31 0; +#X connect 19 0 31 0; +#X connect 20 0 31 0; +#X connect 21 0 31 0; +#X connect 22 0 31 0; +#X connect 23 0 31 0; +#X connect 24 0 31 0; +#X connect 25 0 31 0; +#X connect 26 0 31 0; +#X connect 28 0 29 0; +#X connect 29 0 27 0; +#X connect 30 0 10 0; +#X connect 31 0 12 0; +#X connect 32 0 27 0; +#X connect 33 0 34 0; +#X connect 33 0 55 0; +#X connect 34 0 32 0; +#X connect 35 0 31 1; +#X connect 36 0 31 1; +#X connect 37 0 31 1; +#X connect 38 0 31 1; +#X connect 39 0 31 1; +#X connect 40 0 31 1; +#X connect 41 0 31 1; +#X connect 42 0 31 1; +#X connect 43 0 31 1; +#X connect 44 0 31 1; +#X connect 45 0 31 1; +#X connect 46 0 31 1; +#X connect 47 0 31 1; +#X connect 48 0 31 0; +#X connect 49 0 31 1; +#X connect 50 0 31 1; +#X connect 51 0 33 0; +#X connect 51 0 32 1; +#X connect 51 0 52 0; +#X connect 52 0 29 0; +#X connect 55 0 29 0; +#X connect 62 0 2 0; +#X connect 63 0 2 0; +#X connect 64 0 2 0; +#X connect 65 0 2 0; +#X connect 66 0 5 0; +#X connect 66 0 6 0; diff --git a/iemlib2/bpe-help.pd b/iemlib2/bpe-help.pd new file mode 100644 index 0000000..fa10a04 --- /dev/null +++ b/iemlib2/bpe-help.pd @@ -0,0 +1,49 @@ +#N canvas 112 77 530 449 10; +#X obj 118 183 bng 15 250 50 0 empty empty empty 8 -8 0 10 -262144 +-1 -1; +#X obj 365 93 bng 15 250 50 0 empty empty empty 8 -8 0 10 -262144 -1 +-1; +#X msg 57 87 0 0 1 1000 1 1000 2 500 1 500 1 2000 0 1000; +#X obj 57 264 vsl 15 128 0 2 0 0 empty empty empty 8 -8 0 10 -262144 +-1 -1 0 1; +#X text 9 4 bpe; +#X text 59 4 break-point-envelope; +#X text 49 51 list of pairs: value + relative time [ms]; +#X text 75 64 beginning with a pair: initial-value at 0 ms; +#X text 346 78 a bang starts the envelope; +#N canvas 0 0 450 300 graph1 0; +#X array array99 61 float 0; +#X coords 0 2 60 0 120 60 1; +#X restore 127 293 graph; +#X obj 57 231 line 0 100; +#X obj 274 338 tabwrite array99; +#X obj 365 295 timer; +#X obj 365 317 * 0.01; +#X obj 274 268 t f b; +#X text 85 207 outlet 1 and 2: pair of value and time in ms; +#X text 135 182 outlet 3: bang: end of envelope; +#X obj 57 148 bpe _______; +#X text 132 146 no arg.; +#X msg 78 113 stop; +#X obj 57 209 pack; +#X text 106 112 stops envelope; +#X text 184 414 IEM KUG; +#X text 168 402 musil; +#X text 198 402 @; +#X text 204 402 iem.at; +#X text 119 391 (c) Thomas Musil 2000 - 2005; +#X text 167 424 Graz \, Austria; +#X connect 1 0 12 0; +#X connect 1 0 17 0; +#X connect 2 0 17 0; +#X connect 10 0 3 0; +#X connect 10 0 14 0; +#X connect 12 0 13 0; +#X connect 13 0 11 1; +#X connect 14 0 11 0; +#X connect 14 1 12 1; +#X connect 17 0 20 0; +#X connect 17 1 20 1; +#X connect 17 2 0 0; +#X connect 19 0 17 0; +#X connect 20 0 10 0; diff --git a/iemlib2/dollarg-help.pd b/iemlib2/dollarg-help.pd new file mode 100644 index 0000000..63af06d --- /dev/null +++ b/iemlib2/dollarg-help.pd @@ -0,0 +1,95 @@ +#N canvas 20 0 958 401 10; +#X floatatom 27 77 5 -14 14 0 - - -; +#X obj 98 81 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 471 151 5 0 0 0 - - -; +#X obj 471 179 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X symbolatom 202 218 10 0 0 0 - - -; +#X floatatom 150 219 5 0 0 0 - - -; +#X obj 98 156 route list float symbol; +#X obj 98 181 pp set; +#X obj 75 261 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 150 242 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 202 240 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 98 113 test_dollarg aa bb cc dd ee ff gg 33 44 55 66 77 88 99 +; +#X text 11 6 dollarg; +#X text 93 7 receives the parent initial arguments \, like a +$n; +#X text 168 92 open test_dollarg abstraction; +#X obj 330 45 dollarg; +#X text 398 44 abbrv.; +#X obj 448 44 $n 1; +#X text 490 46 1.arg: n (optional \, default 0); +#X msg 98 261; +#N canvas 8 40 450 300 reset________ 0; +#X obj 48 41 inlet; +#X obj 53 210 outlet; +#X obj 48 73 route list float symbol; +#X obj 121 212 outlet; +#X obj 197 212 outlet; +#X msg 53 187 set; +#X obj 48 99 bang; +#X obj 100 97 bang; +#X obj 152 97 bang; +#X msg 121 187 set 0; +#X msg 197 186 set symbol; +#X connect 0 0 2 0; +#X connect 2 0 6 0; +#X connect 2 1 7 0; +#X connect 2 2 8 0; +#X connect 5 0 1 0; +#X connect 6 0 10 0; +#X connect 6 0 9 0; +#X connect 7 0 5 0; +#X connect 7 0 10 0; +#X connect 8 0 5 0; +#X connect 8 0 9 0; +#X connect 9 0 3 0; +#X connect 10 0 4 0; +#X restore 125 134 pd reset________; +#X msg 27 53 0; +#X msg 63 53 1; +#X msg 96 53 2; +#X msg 211 53 -1; +#X text 451 6 (like float \$1 \, or symbol \$1); +#X text 559 91 eg. m = number of parent arguments + 1; +#X text 531 64 if (n = 0) -> dollarg output all parent arguments; +#X text 531 78 if (n > 0) -> dollarg output the n-th parent argument +; +#X text 532 102 if (n < 0) -> dollarg output the (m+n)-th parent argument +; +#X msg 173 53 -2; +#X msg 135 53 12; +#X text 384 254 IEM KUG; +#X text 368 242 musil; +#X text 398 242 @; +#X text 404 242 iem.at; +#X text 319 231 (c) Thomas Musil 2000 - 2005; +#X text 367 264 Graz \, Austria; +#X connect 0 0 11 0; +#X connect 1 0 11 0; +#X connect 2 0 3 0; +#X connect 4 0 10 0; +#X connect 5 0 9 0; +#X connect 6 0 7 0; +#X connect 6 1 5 0; +#X connect 6 2 4 0; +#X connect 7 0 19 0; +#X connect 7 0 8 0; +#X connect 11 0 6 0; +#X connect 11 0 20 0; +#X connect 11 1 2 0; +#X connect 20 0 19 0; +#X connect 20 1 5 0; +#X connect 20 2 4 0; +#X connect 21 0 0 0; +#X connect 22 0 0 0; +#X connect 23 0 0 0; +#X connect 24 0 0 0; +#X connect 30 0 0 0; +#X connect 31 0 0 0; diff --git a/iemlib2/exp_inc-help.pd b/iemlib2/exp_inc-help.pd new file mode 100644 index 0000000..d720964 --- /dev/null +++ b/iemlib2/exp_inc-help.pd @@ -0,0 +1,83 @@ +#N canvas 117 75 610 474 10; +#X msg 23 256 reset; +#X obj 64 255 bng 15 250 50 0 empty empty empty 8 -8 0 10 -262144 -1 +-1; +#X floatatom 189 282 6 0 0 0 - - -; +#X floatatom 198 83 6 0 0 0 - - -; +#X floatatom 103 340 6 0 0 0 - - -; +#X obj 103 367 bng 15 250 50 0 empty empty empty 8 -8 0 10 -262144 +-1 -1; +#X text 62 238 start; +#X floatatom 107 281 6 0 0 0 - - -; +#X text 197 44 abs. inc; +#X text 185 241 rel. incr [%]; +#X text 31 389 initial-val needs reset and a bang for output it.; +#X text 32 406 current-val outputs after next bang.; +#X floatatom 272 280 6 0 0 0 - - -; +#X obj 272 258 init 0; +#X text 271 241 min-val; +#X floatatom 332 283 6 0 0 0 - - -; +#X text 331 244 max-val; +#X obj 189 260 init 100; +#X obj 107 259 init 625; +#X text 108 242 initial-val; +#X msg 25 60 reset; +#X obj 66 59 bng 15 250 50 0 empty empty empty 8 -8 0 10 -262144 -1 +-1; +#X floatatom 105 144 6 0 0 0 - - -; +#X obj 105 171 bng 15 250 50 0 empty empty empty 8 -8 0 10 -262144 +-1 -1; +#X text 64 42 start; +#X floatatom 109 85 6 0 0 0 - - -; +#X floatatom 274 84 6 0 0 0 - - -; +#X text 273 45 min-val; +#X floatatom 334 87 6 0 0 0 - - -; +#X text 333 48 max-val; +#X text 110 46 initial-val; +#X obj 109 63 init 8500; +#X obj 198 61 init -250; +#X text 13 6 exp_inc; +#X text 77 6 linear and/or exponetial increment-counter \, bang controled +; +#X text 305 118 linear; +#X text 297 312 exponetial; +#X obj 274 62 init 300; +#X obj 334 65 init 12000; +#X obj 105 116 exp_inc 8500 0 -250 300 12000; +#X obj 332 261 init 17000; +#X obj 103 312 exp_inc 625 100 0 300 17000; +#X text 195 160 1.arg: initial-val; +#X text 194 171 2.arg: relative increment [%]; +#X text 194 182 3.arg: absolute increment; +#X text 196 194 4.arg: min-val; +#X text 196 205 5.arg: max-val; +#X text 454 414 IEM KUG; +#X text 438 402 musil; +#X text 468 402 @; +#X text 474 402 iem.at; +#X text 389 391 (c) Thomas Musil 2000 - 2005; +#X text 437 424 Graz \, Austria; +#X connect 0 0 41 0; +#X connect 1 0 41 0; +#X connect 2 0 41 1; +#X connect 3 0 39 2; +#X connect 4 0 5 0; +#X connect 7 0 41 0; +#X connect 12 0 41 3; +#X connect 13 0 12 0; +#X connect 15 0 41 4; +#X connect 17 0 2 0; +#X connect 18 0 7 0; +#X connect 20 0 39 0; +#X connect 21 0 39 0; +#X connect 22 0 23 0; +#X connect 25 0 39 0; +#X connect 26 0 39 3; +#X connect 28 0 39 4; +#X connect 31 0 25 0; +#X connect 32 0 3 0; +#X connect 37 0 26 0; +#X connect 38 0 28 0; +#X connect 39 0 22 0; +#X connect 40 0 15 0; +#X connect 41 0 4 0; diff --git a/iemlib2/fade~-help.pd b/iemlib2/fade~-help.pd new file mode 100644 index 0000000..a7ba8bc --- /dev/null +++ b/iemlib2/fade~-help.pd @@ -0,0 +1,50 @@ +#N canvas 184 90 594 538 10; +#X obj 93 163 line~; +#X obj 16 85 dsp; +#X floatatom 16 112 5 0 0 0 - - -; +#X obj 16 59 tgl 15 0 empty empty empty 8 -8 0 10 -262144 -1 -1 0 1 +; +#X obj 59 269 tabwrite~ array99; +#X obj 59 164 bang; +#X msg 83 66 0 \, 1 10; +#X msg 111 103 1 \, 0 10; +#X msg 169 110 set _lin; +#X msg 169 131 set _linsqrt; +#X msg 169 152 set _sqrt; +#X msg 169 172 set _sin; +#X msg 170 193 set _sinhann; +#X msg 170 215 set _hann; +#X obj 93 242 fade~ _lin; +#X obj 283 14 loadbang; +#X text 332 459 Samples; +#X text 11 6 fade~ a special signal waveshaper; +#X text 59 19 input-range: 0 .. 1; +#N canvas 0 0 452 302 graph1 0; +#X array array99 442 float 0; +#X coords 0 1 441 0 256 140 1; +#X restore 64 318 graph; +#X msg 282 39 \; array99 resize 442 \; array99 bounds 0 1 441 0 \; +array99 xticks 0 100 5 \; array99 yticks 0 0.1 5 \; array99 xlabel +-0.08 0 100 200 300 400 \; array99 ylabel -15.1 0 0.5 1; +#X text 354 264 IEM KUG; +#X text 338 252 musil; +#X text 368 252 @; +#X text 374 252 iem.at; +#X text 289 241 (c) Thomas Musil 2000 - 2005; +#X text 337 274 Graz \, Austria; +#X connect 0 0 14 0; +#X connect 1 0 2 0; +#X connect 3 0 1 0; +#X connect 5 0 4 0; +#X connect 6 0 0 0; +#X connect 6 0 5 0; +#X connect 7 0 0 0; +#X connect 7 0 5 0; +#X connect 8 0 14 0; +#X connect 9 0 14 0; +#X connect 10 0 14 0; +#X connect 11 0 14 0; +#X connect 12 0 14 0; +#X connect 13 0 14 0; +#X connect 14 0 4 0; +#X connect 15 0 20 0; diff --git a/iemlib2/float24-help.pd b/iemlib2/float24-help.pd new file mode 100644 index 0000000..cbee6e5 --- /dev/null +++ b/iemlib2/float24-help.pd @@ -0,0 +1,77 @@ +#N canvas 53 141 918 394 10; +#X obj 91 95 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 11 6 float24; +#X floatatom 150 259 9 0 0 0 - - -; +#X obj 91 117 float24 0.999999 762; +#X obj 103 191 -; +#X obj 91 145 t b f; +#X obj 91 167 1; +#X obj 227 116 float 1; +#X obj 227 96 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 239 186 -; +#X obj 227 140 t b f; +#X obj 227 162 1; +#X text 277 112 then save and close the patch; +#X text 277 123 then open the pach \, and click on both bangs; +#X text 277 88 try to type the argument "0.999 999 762" without the +spaces; +#X text 278 100 into a float-object \,; +#X text 79 7 concatenate a list of float-fragment-strings to a 23 bit +accurate mantissa (usefull to save a number into an object with more +then 6 decimals [7 .. 8 decimals]); +#X obj 697 123 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 697 167 9 0 0 0 - - -; +#X obj 697 144 float24 -12.3 4 56; +#X obj 698 194 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 698 238 11 0 0 0 - - -; +#X obj 698 264 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 698 330 11 0 0 0 - - -; +#X obj 698 215 float24 0.00314159 26538; +#X obj 698 285 float24 3.14159 26538; +#X obj 698 308 cos; +#X obj 694 16 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 694 82 11 0 0 0 - - -; +#X obj 694 60 cos; +#X obj 694 37 float 1.5708; +#X obj 779 18 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 779 84 11 0 0 0 - - -; +#X obj 779 62 cos; +#X obj 779 39 float24 1.5707 963268; +#X text 398 227 IEM KUG; +#X text 382 215 musil; +#X text 412 215 @; +#X text 418 215 iem.at; +#X text 333 204 (c) Thomas Musil 2000 - 2005; +#X text 381 237 Graz \, Austria; +#X connect 0 0 3 0; +#X connect 3 0 5 0; +#X connect 4 0 2 0; +#X connect 5 0 6 0; +#X connect 5 1 4 1; +#X connect 6 0 4 0; +#X connect 7 0 10 0; +#X connect 8 0 7 0; +#X connect 9 0 2 0; +#X connect 10 0 11 0; +#X connect 10 1 9 1; +#X connect 11 0 9 0; +#X connect 17 0 19 0; +#X connect 19 0 18 0; +#X connect 20 0 24 0; +#X connect 22 0 25 0; +#X connect 24 0 21 0; +#X connect 25 0 26 0; +#X connect 26 0 23 0; +#X connect 27 0 30 0; +#X connect 29 0 28 0; +#X connect 30 0 29 0; +#X connect 31 0 34 0; +#X connect 33 0 32 0; +#X connect 34 0 33 0; diff --git a/iemlib2/iem_anything-help.pd b/iemlib2/iem_anything-help.pd new file mode 100644 index 0000000..64eb57b --- /dev/null +++ b/iemlib2/iem_anything-help.pd @@ -0,0 +1,140 @@ +#N canvas 194 199 779 617 10; +#X obj 21 148 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 -1 +-1; +#X obj 48 148 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 -1 +-1; +#X obj 89 206 print; +#X obj 89 148 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 -1 +-1; +#X obj 292 148 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 +-1 -1; +#X obj 292 208 print; +#X msg 343 210; +#X obj 369 155 loadbang; +#X msg 369 176 set; +#X obj 26 225 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 -1 +-1; +#X obj 26 280 print; +#X obj 400 382 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 +-1 -1; +#X obj 457 491 print; +#X msg 457 56 88; +#X msg 457 132 symbol www; +#X msg 457 75 float 77; +#X obj 137 148 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 +-1 -1; +#X msg 457 94 list 66; +#X msg 457 113 www; +#X msg 457 151 list www; +#X msg 457 189 list 99 888 hhh; +#X msg 457 208 float 99 888 hhh; +#X msg 457 227 symbol 99 888 hhh; +#X msg 457 170 99 888 hhh; +#X msg 457 246 kkk jjj 345; +#X msg 457 265 symbol kkk jjj 345; +#X msg 457 284 list kkk jjj 345; +#X msg 90 432; +#X obj 137 376 loadbang; +#X msg 123 401 set; +#X obj 26 252 any open filename 55; +#X obj 457 463 iem_anything; +#X obj 90 400 any; +#X obj 27 342 bang; +#X obj 27 366 del 999; +#X msg 620 205 88; +#X msg 619 281 symbol www; +#X msg 619 224 float 77; +#X msg 619 243 list 66; +#X msg 619 262 www; +#X msg 619 300 list www; +#X msg 619 338 list 99 888 hhh; +#X msg 619 357 float 99 888 hhh; +#X msg 619 376 symbol 99 888 hhh; +#X msg 619 319 99 888 hhh; +#X msg 619 395 kkk jjj 345; +#X msg 619 414 symbol kkk jjj 345; +#X msg 619 433 list kkk jjj 345; +#X msg 361 383 bang; +#X obj 540 363 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 +-1 -1; +#X msg 501 364 bang; +#X msg 106 307 set display this with 1 second delay; +#X obj 123 342 bang; +#X text 296 9 (like f or float for -messages); +#X text 131 9 is a latch for anything; +#X obj 229 376 del 4999; +#X text 298 19 (or like symbol for -messages); +#X text 23 11 iem_anything; +#X obj 104 85 iem_anything; +#X text 195 85 arguments: any message; +#X text 96 67 <-hot; +#X text 146 67 cold->; +#X text 134 35 abbr. any; +#X obj 21 175 any; +#X obj 48 175 any 88; +#X obj 89 175 any www; +#X obj 137 175 any symbol www; +#X obj 292 175 any set 88; +#X text 184 524 IEM KUG; +#X text 168 512 musil; +#X text 198 512 @; +#X text 204 512 iem.at; +#X text 119 501 (c) Thomas Musil 2000 - 2005; +#X text 167 534 Graz \, Austria; +#X connect 0 0 63 0; +#X connect 1 0 64 0; +#X connect 3 0 65 0; +#X connect 4 0 67 0; +#X connect 7 0 8 0; +#X connect 8 0 6 0; +#X connect 9 0 30 0; +#X connect 11 0 31 0; +#X connect 13 0 31 0; +#X connect 14 0 31 0; +#X connect 15 0 31 0; +#X connect 16 0 66 0; +#X connect 17 0 31 0; +#X connect 18 0 31 0; +#X connect 19 0 31 0; +#X connect 20 0 31 0; +#X connect 21 0 31 0; +#X connect 22 0 31 0; +#X connect 23 0 31 0; +#X connect 24 0 31 0; +#X connect 25 0 31 0; +#X connect 26 0 31 0; +#X connect 28 0 29 0; +#X connect 29 0 27 0; +#X connect 30 0 10 0; +#X connect 31 0 12 0; +#X connect 32 0 27 0; +#X connect 33 0 34 0; +#X connect 33 0 55 0; +#X connect 34 0 32 0; +#X connect 35 0 31 1; +#X connect 36 0 31 1; +#X connect 37 0 31 1; +#X connect 38 0 31 1; +#X connect 39 0 31 1; +#X connect 40 0 31 1; +#X connect 41 0 31 1; +#X connect 42 0 31 1; +#X connect 43 0 31 1; +#X connect 44 0 31 1; +#X connect 45 0 31 1; +#X connect 46 0 31 1; +#X connect 47 0 31 1; +#X connect 48 0 31 0; +#X connect 49 0 31 1; +#X connect 50 0 31 1; +#X connect 51 0 33 0; +#X connect 51 0 32 1; +#X connect 51 0 52 0; +#X connect 52 0 29 0; +#X connect 55 0 29 0; +#X connect 63 0 2 0; +#X connect 64 0 2 0; +#X connect 65 0 2 0; +#X connect 66 0 2 0; +#X connect 67 0 5 0; +#X connect 67 0 6 0; diff --git a/iemlib2/iem_append-help.pd b/iemlib2/iem_append-help.pd new file mode 100644 index 0000000..7580edd --- /dev/null +++ b/iemlib2/iem_append-help.pd @@ -0,0 +1,75 @@ +#N canvas 231 172 613 503 10; +#X obj 117 376 print; +#X msg 117 61 1; +#X obj 238 41 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 117 40 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X msg 117 149 11 22; +#X msg 238 150 33 44; +#X msg 238 63 3; +#X msg 117 105 symbol foo; +#X msg 238 107 symbol zyx; +#X msg 117 83 float 1.1; +#X msg 238 85 float 3.3; +#X msg 117 127 set; +#X msg 238 128 open; +#X msg 117 172 list -55 -66; +#X msg 238 172 list -77 -88; +#X msg 238 195 list bbb 987; +#X msg 117 195 list aaa 123; +#X msg 117 218 jkl 555 uuu; +#X msg 238 218 poi 777 ttt; +#X obj 191 377 route bang float symbol list; +#X obj 242 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 281 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 324 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 367 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 421 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 400 376 anything; +#X text 262 39 bang clears message-buffer; +#X text 218 302 initials-arguments:; +#X text 109 7 merge the head-message in front of the tail-message; +#X text 224 275 <- cold inlet; +#X text 122 274 <- hot inlet; +#X text 13 7 iem_append; +#X text 34 284 head of output-message; +#X text 226 285 tail of output-message; +#X text 213 313 tail of output-message; +#X obj 117 300 iem_append 0.5; +#X text 136 445 IEM KUG; +#X text 120 433 musil; +#X text 150 433 @; +#X text 156 433 iem.at; +#X text 71 422 (c) Thomas Musil 2000 - 2005; +#X text 119 455 Graz \, Austria; +#X connect 1 0 35 0; +#X connect 2 0 35 1; +#X connect 3 0 35 0; +#X connect 4 0 35 0; +#X connect 5 0 35 1; +#X connect 6 0 35 1; +#X connect 7 0 35 0; +#X connect 8 0 35 1; +#X connect 9 0 35 0; +#X connect 10 0 35 1; +#X connect 11 0 35 0; +#X connect 12 0 35 1; +#X connect 13 0 35 0; +#X connect 14 0 35 1; +#X connect 15 0 35 1; +#X connect 16 0 35 0; +#X connect 17 0 35 0; +#X connect 18 0 35 1; +#X connect 19 0 20 0; +#X connect 19 1 21 0; +#X connect 19 2 22 0; +#X connect 19 3 23 0; +#X connect 19 4 24 0; +#X connect 35 0 0 0; +#X connect 35 0 19 0; diff --git a/iemlib2/iem_blocksize~-help.pd b/iemlib2/iem_blocksize~-help.pd new file mode 100644 index 0000000..b42396f --- /dev/null +++ b/iemlib2/iem_blocksize~-help.pd @@ -0,0 +1,40 @@ +#N canvas 184 90 493 300 10; +#X obj 12 66 dsp; +#X floatatom 12 93 5 0 0 0 - - -; +#X obj 12 40 tgl 15 0 empty empty empty 8 -8 0 10 -262144 -1 -1 0 1 +; +#X obj 92 106 osc~ 440; +#X floatatom 92 163 7 0 0 0 - - -; +#X obj 92 183 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 40 37 <- toggle here; +#N canvas 383 167 454 304 down 0; +#X obj 98 74 inlet~; +#X obj 188 79 block~ 32 1 0.5; +#X obj 98 161 outlet; +#X obj 98 132 iem_blocksize~; +#X connect 0 0 3 0; +#X connect 3 0 2 0; +#X restore 305 132 pd down; +#X floatatom 305 162 7 0 0 0 - - -; +#X obj 305 182 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 11 6 iem_blocksize~; +#X text 131 8 output the current blocksize of a window; +#X obj 92 131 iem_blocksize~; +#X text 143 163 Samples; +#X text 354 161 Samples; +#X text 136 245 IEM KUG; +#X text 120 233 musil; +#X text 150 233 @; +#X text 156 233 iem.at; +#X text 71 222 (c) Thomas Musil 2000 - 2005; +#X text 119 255 Graz \, Austria; +#X connect 0 0 1 0; +#X connect 2 0 0 0; +#X connect 3 0 7 0; +#X connect 3 0 12 0; +#X connect 4 0 5 0; +#X connect 7 0 8 0; +#X connect 8 0 9 0; +#X connect 12 0 4 0; diff --git a/iemlib2/iem_i_route-help.pd b/iemlib2/iem_i_route-help.pd new file mode 100644 index 0000000..289f64d --- /dev/null +++ b/iemlib2/iem_i_route-help.pd @@ -0,0 +1,135 @@ +#N canvas 167 225 753 369 10; +#X floatatom 25 136 4 0 0 0 - - -; +#X obj 25 161 iem_i_route 3 7; +#X obj 25 197 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 -1 +-1; +#X obj 45 197 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 -1 +-1; +#X obj 65 197 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 -1 +-1; +#X obj 85 197 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 -1 +-1; +#X obj 105 197 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 +-1 -1; +#X floatatom 133 189 4 0 0 0 - - -; +#X obj 133 214 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 +-1 -1; +#X floatatom 201 135 4 0 0 0 - - -; +#X obj 569 132 print rejected; +#X floatatom 469 20 4 0 0 0 - - -; +#X obj 191 204 iiroute 2 5 _______; +#X obj 191 182 pack 0 0; +#X obj 201 157 t f f; +#X floatatom 191 230 2 0 0 0 - - -; +#X obj 191 255 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 +-1 -1; +#X floatatom 223 230 2 0 0 0 - - -; +#X obj 223 255 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 +-1 -1; +#X floatatom 255 230 2 0 0 0 - - -; +#X obj 255 255 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 +-1 -1; +#X floatatom 287 230 2 0 0 0 - - -; +#X obj 287 255 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 +-1 -1; +#X obj 319 230 print rejected; +#X obj 469 42 t f b f; +#X obj 469 86 pack 0 s 0; +#X obj 487 65 symbol gain; +#X obj 469 108 iiroute 4 6 10; +#X floatatom 469 300 5 0 0 0 - - -; +#X floatatom 495 239 5 0 0 0 - - -; +#X obj 469 318 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 319 252 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 495 257 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 521 178 5 0 0 0 - - -; +#X obj 521 196 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 550 133 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 521 156 route gain delay; +#X obj 495 218 route gain delay; +#X obj 469 278 route gain delay; +#X floatatom 566 176 5 0 0 0 - - -; +#X obj 566 194 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 540 239 5 0 0 0 - - -; +#X obj 540 257 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 514 300 5 0 0 0 - - -; +#X obj 514 318 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 620 7 4 0 0 0 - - -; +#X obj 620 29 t f b f; +#X obj 624 93 pack 0 s 0; +#X obj 638 52 symbol delay; +#X obj 718 47 - 8; +#X text 53 39 1.arg: first route-item; +#X text 53 52 2.arg: last route-item; +#X text 11 8 iem_i_route; +#X text 102 8 route only list with prepending floats (integers); +#X text 215 76 (opt. \, default 0); +#X text 53 64 3.arg: offset \, adding to first and last; +#X obj 562 62 - 5; +#X text 76 305 IEM KUG; +#X text 60 293 musil; +#X text 90 293 @; +#X text 96 293 iem.at; +#X text 11 282 (c) Thomas Musil 2000 - 2005; +#X text 59 315 Graz \, Austria; +#X connect 0 0 1 0; +#X connect 1 0 2 0; +#X connect 1 1 3 0; +#X connect 1 2 4 0; +#X connect 1 3 5 0; +#X connect 1 4 6 0; +#X connect 1 5 7 0; +#X connect 7 0 8 0; +#X connect 9 0 14 0; +#X connect 11 0 24 0; +#X connect 12 0 15 0; +#X connect 12 1 17 0; +#X connect 12 2 19 0; +#X connect 12 3 21 0; +#X connect 12 4 23 0; +#X connect 12 4 31 0; +#X connect 13 0 12 0; +#X connect 14 0 13 0; +#X connect 14 1 13 1; +#X connect 15 0 16 0; +#X connect 17 0 18 0; +#X connect 19 0 20 0; +#X connect 21 0 22 0; +#X connect 24 0 25 0; +#X connect 24 1 26 0; +#X connect 24 2 56 0; +#X connect 25 0 27 0; +#X connect 26 0 25 1; +#X connect 27 0 38 0; +#X connect 27 1 37 0; +#X connect 27 2 36 0; +#X connect 27 3 10 0; +#X connect 27 3 35 0; +#X connect 28 0 30 0; +#X connect 29 0 32 0; +#X connect 33 0 34 0; +#X connect 36 0 33 0; +#X connect 36 1 39 0; +#X connect 37 0 29 0; +#X connect 37 1 41 0; +#X connect 38 0 28 0; +#X connect 38 1 43 0; +#X connect 39 0 40 0; +#X connect 41 0 42 0; +#X connect 43 0 44 0; +#X connect 45 0 46 0; +#X connect 46 0 47 0; +#X connect 46 1 48 0; +#X connect 46 2 49 0; +#X connect 47 0 27 0; +#X connect 48 0 47 1; +#X connect 49 0 47 2; +#X connect 56 0 25 2; diff --git a/iemlib2/iem_pbank_csv-help.pd b/iemlib2/iem_pbank_csv-help.pd new file mode 100644 index 0000000..790612b --- /dev/null +++ b/iemlib2/iem_pbank_csv-help.pd @@ -0,0 +1,164 @@ +#N canvas 24 9 934 571 10; +#X obj 188 46 pp 0; +#X floatatom 188 23 5 0 0 0 - - -; +#X floatatom 224 31 5 0 0 0 - - -; +#X floatatom 260 43 5 0 0 0 - - -; +#X floatatom 295 52 5 0 0 0 - - -; +#X floatatom 330 61 5 0 0 0 - - -; +#X obj 224 54 pp 1; +#X obj 260 66 pp 2; +#X obj 295 75 pp 3; +#X obj 330 84 pp 4; +#X text 25 482 2.arg: nr. of lines = parameter-sets; +#X text 329 31 input: of para-index; +#X text 370 43 + parameter; +#X obj 593 112 openpanel; +#X obj 593 91 bng 15 250 50 0 empty empty empty 20 8 0 8 -262144 -1 +-1; +#X obj 681 94 bng 15 250 50 0 empty empty empty 20 8 0 8 -262144 -1 +-1; +#X obj 681 115 savepanel; +#X obj 227 421 print out; +#X floatatom 378 347 5 0 9 0 - - -; +#X text 380 328 line number for recall and store; +#X msg 346 222 recall; +#X msg 323 247 store; +#X text 654 221 the 2nd symbol of read- or write-message; +#X text 655 235 should have 3 characters:; +#X text 656 251 1st char is the kind of separator:; +#X text 672 262 b .. blank or space; +#X text 671 272 c .. colon; +#X text 671 281 s .. semicolon; +#X text 671 291 t .. tabulator; +#X text 429 339 0 <= n < number of lines; +#X text 251 119 prepend column-number of parameter; +#X text 654 309 2nd char is the kind of end_of_line:; +#X text 669 320 b .. blank or space + return; +#X text 668 330 c .. colon + return; +#X text 668 339 s .. semicolon + return; +#X text 668 349 r .. return only; +#X text 655 364 3nd char is the kind of operating-system:; +#X text 670 375 l .. linux; +#X text 669 384 w .. windows; +#X text 671 395 m .. macintosh; +#X text 8 2 iem_pbank_csv; +#X text 109 2 parameter-bank with csv-syntax; +#X obj 39 282 pp 0; +#X msg 369 195 recall 1 5; +#X floatatom 366 71 5 0 0 0 - - -; +#X obj 366 94 pp 5; +#X symbolatom 401 78 10 0 0 0 - - -; +#X obj 401 102 pp 6; +#X msg 593 137 read \$1 csl; +#X obj 398 394 loadbang; +#X obj 398 436 pp add; +#X msg 398 415 0 aaa \, 1 bbb \, 2 ccc \, 3 ddd \, 4 eee \, 5 fff \, +6 ggg; +#X obj 479 482 r aaa; +#X floatatom 479 505 5 0 0 0 - - -; +#X floatatom 514 505 5 0 0 0 - - -; +#X obj 514 482 r bbb; +#X floatatom 549 505 5 0 0 0 - - -; +#X obj 549 482 r ccc; +#X symbolatom 692 505 10 0 0 0 - - -; +#X obj 479 526 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 514 527 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 549 527 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 692 528 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 692 482 r ggg; +#X floatatom 585 505 5 0 0 0 - - -; +#X floatatom 620 505 5 0 0 0 - - -; +#X floatatom 655 505 5 0 0 0 - - -; +#X obj 585 526 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 620 527 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 655 527 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 585 482 r ddd; +#X obj 620 482 r eee; +#X obj 655 482 r fff; +#X obj 227 372 iem_pbank_csv 7 10; +#X obj 330 457 list2send 7; +#X msg 16 197 1.1 2.1 3.1 4.1 5.1 6.1 aa1; +#X msg 39 220 1.2 2.2 3.2 4.2 5.2 6.2 bb2; +#X msg 61 244 1.3 2.3 3.3 4.3 5.3 6.3 cc3; +#X text 386 55 stored in input-buffer; +#X text 25 472 1.arg: nr. of parameters; +#X text 18 168 list of all parameters of a line; +#X text 41 179 stored in input-buffer; +#X msg 682 137 write \$1 csl; +#X text 361 246 store input-buffer to memory-line of 2nd input; +#X text 390 222 recall memory-line to input-buffer; +#X text 398 231 and output all parameter of this line; +#X obj 330 403 pp from; +#X msg 542 167 read iemhelp/help-iem_pbank.pbank csl; +#X msg 547 190 read help-iem_pbank.pbank csl; +#X obj 21 357 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 38 355 output input-buffer; +#X msg 387 168 recall 3 2; +#X obj 130 424 print zzz; +#X text 136 525 IEM KUG; +#X text 120 513 musil; +#X text 150 513 @; +#X text 156 513 iem.at; +#X text 71 502 (c) Thomas Musil 2000 - 2005; +#X text 119 535 Graz \, Austria; +#X connect 0 0 73 0; +#X connect 1 0 0 0; +#X connect 2 0 6 0; +#X connect 3 0 7 0; +#X connect 4 0 8 0; +#X connect 5 0 9 0; +#X connect 6 0 73 0; +#X connect 7 0 73 0; +#X connect 8 0 73 0; +#X connect 9 0 73 0; +#X connect 13 0 48 0; +#X connect 14 0 13 0; +#X connect 15 0 16 0; +#X connect 16 0 82 0; +#X connect 18 0 73 1; +#X connect 20 0 73 0; +#X connect 21 0 73 0; +#X connect 42 0 73 0; +#X connect 43 0 73 0; +#X connect 44 0 45 0; +#X connect 45 0 73 0; +#X connect 46 0 47 0; +#X connect 47 0 73 0; +#X connect 48 0 73 0; +#X connect 49 0 51 0; +#X connect 50 0 74 0; +#X connect 51 0 50 0; +#X connect 52 0 53 0; +#X connect 53 0 59 0; +#X connect 54 0 60 0; +#X connect 55 0 54 0; +#X connect 56 0 61 0; +#X connect 57 0 56 0; +#X connect 58 0 62 0; +#X connect 63 0 58 0; +#X connect 64 0 67 0; +#X connect 65 0 68 0; +#X connect 66 0 69 0; +#X connect 70 0 64 0; +#X connect 71 0 65 0; +#X connect 72 0 66 0; +#X connect 73 0 17 0; +#X connect 73 1 86 0; +#X connect 73 1 92 0; +#X connect 75 0 42 0; +#X connect 76 0 42 0; +#X connect 77 0 42 0; +#X connect 82 0 73 0; +#X connect 86 0 74 0; +#X connect 87 0 73 0; +#X connect 88 0 73 0; +#X connect 89 0 73 0; +#X connect 91 0 73 0; diff --git a/iemlib2/iem_prepend-help.pd b/iemlib2/iem_prepend-help.pd new file mode 100644 index 0000000..cb1eb78 --- /dev/null +++ b/iemlib2/iem_prepend-help.pd @@ -0,0 +1,75 @@ +#N canvas 231 172 617 507 10; +#X obj 117 376 print; +#X msg 117 61 1; +#X obj 238 41 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 117 40 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X msg 117 149 11 22; +#X msg 238 150 33 44; +#X msg 238 63 3; +#X msg 117 105 symbol foo; +#X msg 238 107 symbol zyx; +#X msg 117 83 float 1.1; +#X msg 238 85 float 3.3; +#X msg 117 127 set; +#X msg 238 128 open; +#X msg 117 172 list -55 -66; +#X msg 238 172 list -77 -88; +#X msg 238 195 list bbb 987; +#X msg 117 195 list aaa 123; +#X msg 117 218 jkl 555 uuu; +#X msg 238 218 poi 777 ttt; +#X obj 191 377 route bang float symbol list; +#X obj 242 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 281 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 324 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 367 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 421 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 400 376 anything; +#X text 262 39 bang clears message-buffer; +#X text 175 319 head of output-message; +#X text 180 308 initials-arguments:; +#X text 5 281 tail of output-message; +#X text 183 287 head of output-message; +#X text 181 277 <- cold inlet; +#X obj 117 300 pp set; +#X text 115 448 IEM KUG; +#X text 99 436 musil; +#X text 129 436 @; +#X text 135 436 iem.at; +#X text 50 425 (c) Thomas Musil 2000 - 2005; +#X text 98 458 Graz \, Austria; +#X text 151 8 merge the head-message in front of the tail-message; +#X text 42 273 hot inlet ->; +#X text 13 7 iem_prepend; +#X connect 1 0 32 0; +#X connect 2 0 32 1; +#X connect 3 0 32 0; +#X connect 4 0 32 0; +#X connect 5 0 32 1; +#X connect 6 0 32 1; +#X connect 7 0 32 0; +#X connect 8 0 32 1; +#X connect 9 0 32 0; +#X connect 10 0 32 1; +#X connect 11 0 32 0; +#X connect 12 0 32 1; +#X connect 13 0 32 0; +#X connect 14 0 32 1; +#X connect 15 0 32 1; +#X connect 16 0 32 0; +#X connect 17 0 32 0; +#X connect 18 0 32 1; +#X connect 19 0 20 0; +#X connect 19 1 21 0; +#X connect 19 2 22 0; +#X connect 19 3 23 0; +#X connect 19 4 24 0; +#X connect 32 0 0 0; +#X connect 32 0 19 0; diff --git a/iemlib2/iem_r-help.pd b/iemlib2/iem_r-help.pd new file mode 100644 index 0000000..d862f00 --- /dev/null +++ b/iemlib2/iem_r-help.pd @@ -0,0 +1,45 @@ +#N canvas 115 112 577 404 10; +#X obj 64 200 iem_receive aaa; +#X obj 224 200 iem_r bbb; +#X floatatom 64 232 5 0 0 0 - - -; +#X floatatom 224 232 5 0 0 0 - - -; +#X msg 68 56 \; aaa 33 \; bbb 44; +#X obj 110 228 print a; +#X obj 273 227 print b; +#X msg 64 168 set ccc; +#X msg 224 169 set ddd; +#X msg 403 57 \; ccc 55 \; ddd 66; +#X msg 37 143 set aaa; +#X msg 202 143 set bbb; +#X msg 126 174 clear; +#X msg 289 174 clear; +#X text 13 8 iem_receive; +#X text 108 8 receive-object with changeable receive-label; +#X text 289 200 1.arg: or receive-label; +#X floatatom 84 253 5 0 0 0 - - -; +#X obj 56 256 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 238 257 5 0 0 0 - - -; +#X obj 210 260 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X msg 157 56 \; aaa set 11 \; bbb set 22; +#X text 138 331 IEM KUG; +#X text 122 319 musil; +#X text 152 319 @; +#X text 158 319 iem.at; +#X text 73 308 (c) Thomas Musil 2000 - 2005; +#X text 121 341 Graz \, Austria; +#X connect 0 0 2 0; +#X connect 0 0 5 0; +#X connect 1 0 3 0; +#X connect 1 0 6 0; +#X connect 2 0 17 0; +#X connect 2 0 18 0; +#X connect 3 0 19 0; +#X connect 3 0 20 0; +#X connect 7 0 0 0; +#X connect 8 0 1 0; +#X connect 10 0 0 0; +#X connect 11 0 1 0; +#X connect 12 0 0 0; +#X connect 13 0 1 0; diff --git a/iemlib2/iem_receive-help.pd b/iemlib2/iem_receive-help.pd new file mode 100644 index 0000000..d862f00 --- /dev/null +++ b/iemlib2/iem_receive-help.pd @@ -0,0 +1,45 @@ +#N canvas 115 112 577 404 10; +#X obj 64 200 iem_receive aaa; +#X obj 224 200 iem_r bbb; +#X floatatom 64 232 5 0 0 0 - - -; +#X floatatom 224 232 5 0 0 0 - - -; +#X msg 68 56 \; aaa 33 \; bbb 44; +#X obj 110 228 print a; +#X obj 273 227 print b; +#X msg 64 168 set ccc; +#X msg 224 169 set ddd; +#X msg 403 57 \; ccc 55 \; ddd 66; +#X msg 37 143 set aaa; +#X msg 202 143 set bbb; +#X msg 126 174 clear; +#X msg 289 174 clear; +#X text 13 8 iem_receive; +#X text 108 8 receive-object with changeable receive-label; +#X text 289 200 1.arg: or receive-label; +#X floatatom 84 253 5 0 0 0 - - -; +#X obj 56 256 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 238 257 5 0 0 0 - - -; +#X obj 210 260 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X msg 157 56 \; aaa set 11 \; bbb set 22; +#X text 138 331 IEM KUG; +#X text 122 319 musil; +#X text 152 319 @; +#X text 158 319 iem.at; +#X text 73 308 (c) Thomas Musil 2000 - 2005; +#X text 121 341 Graz \, Austria; +#X connect 0 0 2 0; +#X connect 0 0 5 0; +#X connect 1 0 3 0; +#X connect 1 0 6 0; +#X connect 2 0 17 0; +#X connect 2 0 18 0; +#X connect 3 0 19 0; +#X connect 3 0 20 0; +#X connect 7 0 0 0; +#X connect 8 0 1 0; +#X connect 10 0 0 0; +#X connect 11 0 1 0; +#X connect 12 0 0 0; +#X connect 13 0 1 0; diff --git a/iemlib2/iem_route-help.pd b/iemlib2/iem_route-help.pd new file mode 100644 index 0000000..17c385c --- /dev/null +++ b/iemlib2/iem_route-help.pd @@ -0,0 +1,48 @@ +#N canvas 318 30 519 372 10; +#X obj 22 99 route red black; +#X msg 22 65 red; +#X msg 57 65 black; +#X msg 22 125 3; +#X msg 72 125 4; +#X floatatom 22 159 4 0 0 0 - - -; +#X obj 153 101 route red black; +#X msg 153 67 red; +#X msg 188 67 black; +#X floatatom 153 161 4 0 0 0 - - -; +#X obj 153 130 f 3; +#X obj 203 129 f 4; +#X text 26 197 OK; +#X text 152 196 failed !; +#X msg 295 67 red; +#X msg 330 67 black; +#X floatatom 295 161 4 0 0 0 - - -; +#X obj 295 130 f 3; +#X obj 359 128 f 4; +#X obj 295 101 iem_route red black; +#X text 294 195 that's the difference; +#X text 18 6 iem_route quite similar to route \, except....; +#X text 132 261 IEM KUG; +#X text 116 249 musil; +#X text 146 249 @; +#X text 152 249 iem.at; +#X text 67 238 (c) Thomas Musil 2000 - 2005; +#X text 115 271 Graz \, Austria; +#X text 71 25 obsolete since pd 0.38; +#X connect 0 0 3 0; +#X connect 0 1 4 0; +#X connect 1 0 0 0; +#X connect 2 0 0 0; +#X connect 3 0 5 0; +#X connect 4 0 5 0; +#X connect 6 0 10 0; +#X connect 6 1 11 0; +#X connect 7 0 6 0; +#X connect 8 0 6 0; +#X connect 10 0 9 0; +#X connect 11 0 9 0; +#X connect 14 0 19 0; +#X connect 15 0 19 0; +#X connect 17 0 16 0; +#X connect 18 0 16 0; +#X connect 19 0 17 0; +#X connect 19 1 18 0; diff --git a/iemlib2/iem_s-help.pd b/iemlib2/iem_s-help.pd new file mode 100644 index 0000000..e31f5a4 --- /dev/null +++ b/iemlib2/iem_s-help.pd @@ -0,0 +1,68 @@ +#N canvas 115 112 614 418 10; +#X floatatom 44 249 5 0 0 0 - - -; +#X msg 137 109 set ccc; +#X msg 364 106 set ddd; +#X msg 110 84 set aaa; +#X msg 342 80 set bbb; +#X msg 199 115 clear; +#X msg 429 111 clear; +#X floatatom 58 274 5 0 0 0 - - -; +#X obj 30 277 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 43 146 iem_send aaa; +#X obj 293 146 iem_s bbb; +#X obj 44 223 r aaa; +#X obj 168 223 r bbb; +#X obj 322 226 r ccc; +#X obj 458 226 r ddd; +#X floatatom 168 248 5 0 0 0 - - -; +#X floatatom 182 273 5 0 0 0 - - -; +#X obj 154 276 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 322 250 5 0 0 0 - - -; +#X floatatom 336 275 5 0 0 0 - - -; +#X obj 308 278 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 458 251 5 0 0 0 - - -; +#X floatatom 472 276 5 0 0 0 - - -; +#X obj 444 279 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 358 146 1.arg: or send-label; +#X floatatom 15 78 5 0 0 0 - - -; +#X text 12 14 iem_send; +#X text 107 14 send-object with changeable send-label; +#X floatatom 49 79 5 0 0 0 - - -; +#X msg 49 100 set \$1; +#X floatatom 262 82 5 0 0 0 - - -; +#X floatatom 296 83 5 0 0 0 - - -; +#X msg 296 104 set \$1; +#X text 137 337 IEM KUG; +#X text 121 325 musil; +#X text 151 325 @; +#X text 157 325 iem.at; +#X text 72 314 (c) Thomas Musil 2000 - 2005; +#X text 120 347 Graz \, Austria; +#X connect 0 0 7 0; +#X connect 0 0 8 0; +#X connect 1 0 9 1; +#X connect 2 0 10 1; +#X connect 3 0 9 1; +#X connect 4 0 10 1; +#X connect 5 0 9 1; +#X connect 6 0 10 1; +#X connect 11 0 0 0; +#X connect 12 0 15 0; +#X connect 13 0 18 0; +#X connect 14 0 21 0; +#X connect 15 0 16 0; +#X connect 15 0 17 0; +#X connect 18 0 19 0; +#X connect 18 0 20 0; +#X connect 21 0 22 0; +#X connect 21 0 23 0; +#X connect 25 0 9 0; +#X connect 28 0 29 0; +#X connect 29 0 9 0; +#X connect 30 0 10 0; +#X connect 31 0 32 0; +#X connect 32 0 10 0; diff --git a/iemlib2/iem_samplerate~-help.pd b/iemlib2/iem_samplerate~-help.pd new file mode 100644 index 0000000..f7059b3 --- /dev/null +++ b/iemlib2/iem_samplerate~-help.pd @@ -0,0 +1,40 @@ +#N canvas 184 90 493 300 10; +#X obj 12 66 dsp; +#X floatatom 12 93 5 0 0 0 - - -; +#X obj 12 40 tgl 15 0 empty empty empty 8 -8 0 10 -262144 -1 -1 0 1 +; +#X obj 92 131 iem_samplerate~; +#X obj 92 106 osc~ 440; +#X floatatom 92 163 7 0 0 0 - - -; +#X text 143 163 Hz; +#X obj 92 183 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 40 37 <- toggle here; +#N canvas 383 167 452 302 down 0; +#X obj 98 74 inlet~; +#X obj 188 79 block~ 32 1 0.5; +#X obj 98 132 iem_samplerate~; +#X obj 98 161 outlet; +#X connect 0 0 2 0; +#X connect 2 0 3 0; +#X restore 305 132 pd down; +#X floatatom 305 162 7 0 0 0 - - -; +#X text 356 162 Hz; +#X obj 305 182 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 131 8 output the current samplerate of a window; +#X text 11 6 iem_samplerate~; +#X text 136 245 IEM KUG; +#X text 120 233 musil; +#X text 150 233 @; +#X text 156 233 iem.at; +#X text 71 222 (c) Thomas Musil 2000 - 2005; +#X text 119 255 Graz \, Austria; +#X connect 0 0 1 0; +#X connect 2 0 0 0; +#X connect 3 0 5 0; +#X connect 4 0 3 0; +#X connect 4 0 9 0; +#X connect 5 0 7 0; +#X connect 9 0 10 0; +#X connect 10 0 12 0; diff --git a/iemlib2/iem_sel_any-help.pd b/iemlib2/iem_sel_any-help.pd new file mode 100644 index 0000000..4636957 --- /dev/null +++ b/iemlib2/iem_sel_any-help.pd @@ -0,0 +1,56 @@ +#N canvas 480 230 733 409 10; +#X obj 356 313 print; +#X obj 145 137 modulo_counter 4 0; +#X floatatom 145 159 2 0 3 0 - - -; +#X obj 472 46 loadbang; +#X obj 145 111 bang; +#X floatatom 237 87 5 0 3 0 - - -; +#X obj 237 110 t b f; +#X obj 237 66 init 0; +#X msg 90 152 0; +#X msg 90 173 1; +#X msg 90 193 2; +#X msg 90 214 3; +#X text 371 290 2.outlet: pure message (symbol becomes anything-selector) +; +#X text 234 284 1.outlet:; +#X text 12 7 iem_sel_any; +#X obj 472 96 pp add; +#X msg 472 71 0 aa \, 1 bbb \, 2 cccc \, 3 ddddd; +#X text 162 7 control a message-box with multiple content; +#X text 378 267 1.arg: max. number of messages; +#X msg 396 206 clear; +#X text 401 223 message : clears content; +#X text 171 171 message-index; +#X text 511 141 adds a new entry into object; +#X obj 277 268 iem_sel_any 10; +#X text 462 126 message + index + entry; +#X text 147 295 message + entry; +#X text 45 84 click here ->; +#X obj 145 84 cnv 15 34 17 empty empty empty 20 12 0 14 -225280 -66577 +0; +#X msg 145 84 aa; +#X text 136 345 IEM KUG; +#X text 120 333 musil; +#X text 150 333 @; +#X text 156 333 iem.at; +#X text 71 322 (c) Thomas Musil 2000 - 2005; +#X text 119 355 Graz \, Austria; +#X connect 1 0 2 0; +#X connect 2 0 23 0; +#X connect 3 0 16 0; +#X connect 4 0 1 0; +#X connect 5 0 6 0; +#X connect 6 0 1 0; +#X connect 6 1 1 1; +#X connect 7 0 5 0; +#X connect 8 0 23 0; +#X connect 9 0 23 0; +#X connect 10 0 23 0; +#X connect 11 0 23 0; +#X connect 15 0 23 0; +#X connect 16 0 15 0; +#X connect 19 0 23 0; +#X connect 23 0 28 0; +#X connect 23 1 0 0; +#X connect 28 0 4 0; diff --git a/iemlib2/iem_send-help.pd b/iemlib2/iem_send-help.pd new file mode 100644 index 0000000..e31f5a4 --- /dev/null +++ b/iemlib2/iem_send-help.pd @@ -0,0 +1,68 @@ +#N canvas 115 112 614 418 10; +#X floatatom 44 249 5 0 0 0 - - -; +#X msg 137 109 set ccc; +#X msg 364 106 set ddd; +#X msg 110 84 set aaa; +#X msg 342 80 set bbb; +#X msg 199 115 clear; +#X msg 429 111 clear; +#X floatatom 58 274 5 0 0 0 - - -; +#X obj 30 277 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 43 146 iem_send aaa; +#X obj 293 146 iem_s bbb; +#X obj 44 223 r aaa; +#X obj 168 223 r bbb; +#X obj 322 226 r ccc; +#X obj 458 226 r ddd; +#X floatatom 168 248 5 0 0 0 - - -; +#X floatatom 182 273 5 0 0 0 - - -; +#X obj 154 276 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 322 250 5 0 0 0 - - -; +#X floatatom 336 275 5 0 0 0 - - -; +#X obj 308 278 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 458 251 5 0 0 0 - - -; +#X floatatom 472 276 5 0 0 0 - - -; +#X obj 444 279 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 358 146 1.arg: or send-label; +#X floatatom 15 78 5 0 0 0 - - -; +#X text 12 14 iem_send; +#X text 107 14 send-object with changeable send-label; +#X floatatom 49 79 5 0 0 0 - - -; +#X msg 49 100 set \$1; +#X floatatom 262 82 5 0 0 0 - - -; +#X floatatom 296 83 5 0 0 0 - - -; +#X msg 296 104 set \$1; +#X text 137 337 IEM KUG; +#X text 121 325 musil; +#X text 151 325 @; +#X text 157 325 iem.at; +#X text 72 314 (c) Thomas Musil 2000 - 2005; +#X text 120 347 Graz \, Austria; +#X connect 0 0 7 0; +#X connect 0 0 8 0; +#X connect 1 0 9 1; +#X connect 2 0 10 1; +#X connect 3 0 9 1; +#X connect 4 0 10 1; +#X connect 5 0 9 1; +#X connect 6 0 10 1; +#X connect 11 0 0 0; +#X connect 12 0 15 0; +#X connect 13 0 18 0; +#X connect 14 0 21 0; +#X connect 15 0 16 0; +#X connect 15 0 17 0; +#X connect 18 0 19 0; +#X connect 18 0 20 0; +#X connect 21 0 22 0; +#X connect 21 0 23 0; +#X connect 25 0 9 0; +#X connect 28 0 29 0; +#X connect 29 0 9 0; +#X connect 30 0 10 0; +#X connect 31 0 32 0; +#X connect 32 0 10 0; diff --git a/iemlib2/ii-help.pd b/iemlib2/ii-help.pd new file mode 100644 index 0000000..3151183 --- /dev/null +++ b/iemlib2/ii-help.pd @@ -0,0 +1,49 @@ +#N canvas 156 133 536 355 10; +#X msg 81 54 2.5; +#X msg 20 54 bang; +#X msg 121 55 23 64; +#X text 55 249 the above can be abbreviated as:; +#X msg 168 55 symbol dog; +#X msg 260 55 open myfile 888; +#X obj 20 106 init; +#X obj 287 249 ii; +#X obj 20 133 print x1; +#X obj 95 107 init 44; +#X obj 95 132 print x2; +#X obj 190 134 print x3; +#X obj 190 109 init www; +#X obj 274 110 init symbol www; +#X obj 274 134 print x4; +#X obj 21 179 ii open file 22; +#X obj 21 203 print x5; +#X obj 144 180 ii list open file 22; +#X obj 144 203 print x6; +#X obj 301 181 ii list 6 7 8; +#X obj 301 204 print x7; +#X obj 409 181 ii 9 8 7; +#X obj 409 204 print x8; +#X obj 412 138 print x9; +#X obj 412 112 init float 77; +#X msg 389 58 11 22 33 aa bb cc; +#X text 18 17 init : initialize anything by loadbang; +#X text 106 305 IEM KUG; +#X text 90 293 musil; +#X text 120 293 @; +#X text 126 293 iem.at; +#X text 41 282 (c) Thomas Musil 2000 - 2005; +#X text 89 315 Graz \, Austria; +#X connect 0 0 6 0; +#X connect 1 0 6 0; +#X connect 2 0 6 0; +#X connect 4 0 6 0; +#X connect 5 0 6 0; +#X connect 6 0 8 0; +#X connect 9 0 10 0; +#X connect 12 0 11 0; +#X connect 13 0 14 0; +#X connect 15 0 16 0; +#X connect 17 0 18 0; +#X connect 19 0 20 0; +#X connect 21 0 22 0; +#X connect 24 0 23 0; +#X connect 25 0 6 0; diff --git a/iemlib2/iiroute-help.pd b/iemlib2/iiroute-help.pd new file mode 100644 index 0000000..2f18d73 --- /dev/null +++ b/iemlib2/iiroute-help.pd @@ -0,0 +1,135 @@ +#N canvas 167 225 753 369 10; +#X floatatom 25 136 4 0 0 0 - - -; +#X obj 25 161 iem_i_route 3 7; +#X obj 25 197 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 -1 +-1; +#X obj 45 197 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 -1 +-1; +#X obj 65 197 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 -1 +-1; +#X obj 85 197 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 -1 +-1; +#X obj 105 197 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 +-1 -1; +#X floatatom 133 189 4 0 0 0 - - -; +#X obj 133 214 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 +-1 -1; +#X floatatom 201 135 4 0 0 0 - - -; +#X obj 569 132 print rejected; +#X floatatom 469 20 4 0 0 0 - - -; +#X obj 191 204 iiroute 2 5 _______; +#X obj 191 182 pack 0 0; +#X obj 201 157 t f f; +#X floatatom 191 230 2 0 0 0 - - -; +#X obj 191 255 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 +-1 -1; +#X floatatom 223 230 2 0 0 0 - - -; +#X obj 223 255 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 +-1 -1; +#X floatatom 255 230 2 0 0 0 - - -; +#X obj 255 255 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 +-1 -1; +#X floatatom 287 230 2 0 0 0 - - -; +#X obj 287 255 bng 15 250 50 0 empty empty empty 20 8 0 10 -262144 +-1 -1; +#X obj 319 230 print rejected; +#X obj 469 42 t f b f; +#X obj 469 86 pack 0 s 0; +#X obj 487 65 symbol gain; +#X obj 469 108 iiroute 4 6 10; +#X floatatom 469 300 5 0 0 0 - - -; +#X floatatom 495 239 5 0 0 0 - - -; +#X obj 469 318 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 319 252 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 495 257 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 521 178 5 0 0 0 - - -; +#X obj 521 196 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 550 133 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 521 156 route gain delay; +#X obj 495 218 route gain delay; +#X obj 469 278 route gain delay; +#X floatatom 566 176 5 0 0 0 - - -; +#X obj 566 194 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 540 239 5 0 0 0 - - -; +#X obj 540 257 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 514 300 5 0 0 0 - - -; +#X obj 514 318 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 620 7 4 0 0 0 - - -; +#X obj 620 29 t f b f; +#X obj 624 93 pack 0 s 0; +#X obj 638 52 symbol delay; +#X obj 718 47 - 8; +#X text 53 39 1.arg: first route-item; +#X text 53 52 2.arg: last route-item; +#X text 11 8 iem_i_route; +#X text 102 8 route only list with prepending floats (integers); +#X text 215 76 (opt. \, default 0); +#X text 53 64 3.arg: offset \, adding to first and last; +#X obj 562 62 - 5; +#X text 106 305 IEM KUG; +#X text 90 293 musil; +#X text 120 293 @; +#X text 126 293 iem.at; +#X text 41 282 (c) Thomas Musil 2000 - 2005; +#X text 89 315 Graz \, Austria; +#X connect 0 0 1 0; +#X connect 1 0 2 0; +#X connect 1 1 3 0; +#X connect 1 2 4 0; +#X connect 1 3 5 0; +#X connect 1 4 6 0; +#X connect 1 5 7 0; +#X connect 7 0 8 0; +#X connect 9 0 14 0; +#X connect 11 0 24 0; +#X connect 12 0 15 0; +#X connect 12 1 17 0; +#X connect 12 2 19 0; +#X connect 12 3 21 0; +#X connect 12 4 23 0; +#X connect 12 4 31 0; +#X connect 13 0 12 0; +#X connect 14 0 13 0; +#X connect 14 1 13 1; +#X connect 15 0 16 0; +#X connect 17 0 18 0; +#X connect 19 0 20 0; +#X connect 21 0 22 0; +#X connect 24 0 25 0; +#X connect 24 1 26 0; +#X connect 24 2 56 0; +#X connect 25 0 27 0; +#X connect 26 0 25 1; +#X connect 27 0 38 0; +#X connect 27 1 37 0; +#X connect 27 2 36 0; +#X connect 27 3 10 0; +#X connect 27 3 35 0; +#X connect 28 0 30 0; +#X connect 29 0 32 0; +#X connect 33 0 34 0; +#X connect 36 0 33 0; +#X connect 36 1 39 0; +#X connect 37 0 29 0; +#X connect 37 1 41 0; +#X connect 38 0 28 0; +#X connect 38 1 43 0; +#X connect 39 0 40 0; +#X connect 41 0 42 0; +#X connect 43 0 44 0; +#X connect 45 0 46 0; +#X connect 46 0 47 0; +#X connect 46 1 48 0; +#X connect 46 2 49 0; +#X connect 47 0 27 0; +#X connect 48 0 47 1; +#X connect 49 0 47 2; +#X connect 56 0 25 2; diff --git a/iemlib2/init-help.pd b/iemlib2/init-help.pd new file mode 100644 index 0000000..77d6b3b --- /dev/null +++ b/iemlib2/init-help.pd @@ -0,0 +1,49 @@ +#N canvas 156 133 534 353 10; +#X msg 81 54 2.5; +#X msg 20 54 bang; +#X msg 121 55 23 64; +#X text 55 249 the above can be abbreviated as:; +#X msg 168 55 symbol dog; +#X msg 260 55 open myfile 888; +#X obj 20 106 init; +#X obj 287 249 ii; +#X obj 20 133 print x1; +#X obj 95 107 init 44; +#X obj 95 132 print x2; +#X obj 190 134 print x3; +#X obj 190 109 init www; +#X obj 274 110 init symbol www; +#X obj 274 134 print x4; +#X obj 21 179 ii open file 22; +#X obj 21 203 print x5; +#X obj 144 180 ii list open file 22; +#X obj 144 203 print x6; +#X obj 301 181 ii list 6 7 8; +#X obj 301 204 print x7; +#X obj 409 181 ii 9 8 7; +#X obj 409 204 print x8; +#X obj 412 138 print x9; +#X obj 412 112 init float 77; +#X msg 389 58 11 22 33 aa bb cc; +#X text 18 17 init : initialize anything by loadbang; +#X text 106 305 IEM KUG; +#X text 90 293 musil; +#X text 120 293 @; +#X text 126 293 iem.at; +#X text 41 282 (c) Thomas Musil 2000 - 2005; +#X text 89 315 Graz \, Austria; +#X connect 0 0 6 0; +#X connect 1 0 6 0; +#X connect 2 0 6 0; +#X connect 4 0 6 0; +#X connect 5 0 6 0; +#X connect 6 0 8 0; +#X connect 9 0 10 0; +#X connect 12 0 11 0; +#X connect 13 0 14 0; +#X connect 15 0 16 0; +#X connect 17 0 18 0; +#X connect 19 0 20 0; +#X connect 21 0 22 0; +#X connect 24 0 23 0; +#X connect 25 0 6 0; diff --git a/iemlib2/list2send-help.pd b/iemlib2/list2send-help.pd new file mode 100644 index 0000000..7d6704a --- /dev/null +++ b/iemlib2/list2send-help.pd @@ -0,0 +1,105 @@ +#N canvas 163 45 800 564 10; +#X msg 393 139 0 aaa \, 1 bbb \, 2 ccc \, 3 ddd \, 4 eee; +#X text 480 117 init; +#X obj 393 118 loadbang; +#X msg 444 165 clear; +#X text 279 59 the corresponding prepend-floats and receive-symbols +; +#X text 279 46 with a prepended float.; +#X text 10 13 list2send; +#X obj 393 160 pp add; +#X obj 68 351 r aaa; +#X floatatom 68 374 5 0 0 0 - - -; +#X obj 103 351 r bbb; +#X floatatom 208 374 5 0 0 0 - - -; +#X obj 208 351 r ccc; +#X obj 267 350 r ddd; +#X floatatom 267 375 8 0 0 0 - - -; +#X obj 351 351 r eee; +#X symbolatom 351 374 10 0 0 0 - - -; +#X obj 68 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 208 396 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 267 397 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 351 397 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 23 143 pp 0; +#X floatatom 23 125 5 0 0 0 - - -; +#X obj 64 195 pp 1; +#X floatatom 178 127 5 0 0 0 - - -; +#X obj 178 145 pp 2; +#X floatatom 221 127 8 0 0 0 - - -; +#X obj 221 146 pp 3; +#X symbolatom 279 128 10 0 0 0 - - -; +#X obj 279 148 pp 4; +#X floatatom 181 220 5 0 0 0 - - -; +#X msg 335 255 set_all 1.1 2.2 3.3 4.4444 abcdefg; +#X msg 344 275 all 0.1 0.2 0.3 0.45678 zyxwvu; +#X msg 370 315 from 3 0.9876 lmnop; +#X msg 358 295 set_from 3 2.2222 zzzzzz; +#X text 131 14 convert some kind of lists to a sended message; +#X text 439 218 1.arg: max. number of sended parameters; +#X text 280 73 have to be inputed via an add message.; +#X obj 359 217 list2send 10; +#X floatatom 103 404 5 0 0 0 - - -; +#X floatatom 64 125 5 0 0 0 - - -; +#X floatatom 136 404 5 0 0 0 - - -; +#X obj 64 175 pack 0 0 0; +#X floatatom 99 125 5 0 0 0 - - -; +#X floatatom 134 125 5 0 0 0 - - -; +#X obj 99 144 t b f; +#X obj 134 147 t b f; +#X obj 103 373 unpack 0 0 0; +#X floatatom 170 404 5 0 0 0 - - -; +#X msg 279 98 symbol zyx; +#X obj 181 238 pp set 2; +#X msg 535 116 0 xaaa \, 1 xbbb \, 2 xccc \, 3 xddd \, 4 xeee; +#X text 106 455 IEM KUG; +#X text 90 443 musil; +#X text 120 443 @; +#X text 126 443 iem.at; +#X text 41 432 (c) Thomas Musil 2000 - 2005; +#X text 89 465 Graz \, Austria; +#X connect 0 0 7 0; +#X connect 2 0 0 0; +#X connect 3 0 38 0; +#X connect 7 0 38 0; +#X connect 8 0 9 0; +#X connect 9 0 17 0; +#X connect 10 0 47 0; +#X connect 11 0 18 0; +#X connect 12 0 11 0; +#X connect 13 0 14 0; +#X connect 14 0 19 0; +#X connect 15 0 16 0; +#X connect 16 0 20 0; +#X connect 21 0 38 0; +#X connect 22 0 21 0; +#X connect 23 0 38 0; +#X connect 24 0 25 0; +#X connect 25 0 38 0; +#X connect 26 0 27 0; +#X connect 27 0 38 0; +#X connect 28 0 29 0; +#X connect 29 0 38 0; +#X connect 30 0 50 0; +#X connect 31 0 38 0; +#X connect 32 0 38 0; +#X connect 33 0 38 0; +#X connect 34 0 38 0; +#X connect 40 0 42 0; +#X connect 42 0 23 0; +#X connect 43 0 45 0; +#X connect 44 0 46 0; +#X connect 45 0 42 0; +#X connect 45 1 42 1; +#X connect 46 0 42 0; +#X connect 46 1 42 2; +#X connect 47 0 39 0; +#X connect 47 1 41 0; +#X connect 47 2 48 0; +#X connect 49 0 28 0; +#X connect 50 0 38 0; +#X connect 51 0 7 0; diff --git a/iemlib2/m2f~-help.pd b/iemlib2/m2f~-help.pd new file mode 100644 index 0000000..a1f7789 --- /dev/null +++ b/iemlib2/m2f~-help.pd @@ -0,0 +1,31 @@ +#N canvas 0 0 442 356 10; +#X floatatom 125 148 0 0 0 0 - - -; +#X floatatom 125 59 0 0 0 0 - - -; +#X obj 125 82 sig~; +#X obj 12 76 dsp; +#X floatatom 12 123 5 0 0 0 - - -; +#X obj 12 50 tgl 15 0 empty empty empty 8 -8 0 10 -262144 -1 -1 1 1 +; +#X text 106 249 IEM KUG; +#X text 90 237 musil; +#X text 120 237 @; +#X text 126 237 iem.at; +#X text 89 259 Graz \, Austria; +#X floatatom 25 103 5 0 0 0 - - -; +#X obj 125 125 unsig~; +#X obj 303 102 mtof~; +#X text 271 102 like; +#X text 41 226 (c) Thomas Musil 2000 - 2006; +#X obj 125 103 m2f~; +#X text 114 4 convert MIDI pitch to frequency (in signal); +#X text 17 8 m2f~; +#X text 154 58 MIDI pitch; +#X text 187 148 Hz; +#X text 218 20 (obsolete); +#X connect 1 0 2 0; +#X connect 2 0 16 0; +#X connect 3 0 4 0; +#X connect 3 1 11 0; +#X connect 5 0 3 0; +#X connect 12 0 0 0; +#X connect 16 0 12 0; diff --git a/iemlib2/mergefilename-help.pd b/iemlib2/mergefilename-help.pd new file mode 100644 index 0000000..6d04ca7 --- /dev/null +++ b/iemlib2/mergefilename-help.pd @@ -0,0 +1,50 @@ +#N canvas 82 111 634 456 10; +#X msg 389 153 separator $; +#X msg 389 88 separator @; +#X msg 389 109 separator :; +#X obj 33 316 mergefilename; +#X msg 22 82 C:/program/pd/my_project my_foo.pd; +#X obj 33 338 print path+file; +#X msg 389 46 separator /; +#N canvas 4 20 450 300 /SUBPATCH/ 0; +#X obj 101 31 inlet; +#X obj 100 59 outlet; +#X connect 0 0 1 0; +#X restore 389 276 pd; +#X msg 389 174 separator z; +#X msg 389 195 separator _; +#X msg 389 216 separator .; +#X text 8 1 mergefilename: merge a list of symbols and floats to a +; +#X msg 404 241 separator; +#X msg 389 67 separator space; +#X msg 55 111 /home/me my_first_patch.pd; +#X msg 389 131 separator 2; +#X text 134 317 1.arg: separator-character (opt.); +#X msg 91 159 aaa bbb ccc ddd eeee; +#X msg 119 204 11 22 33 44; +#X text 466 45 <- click here; +#X obj 423 318 mergefilename /; +#X text 80 17 symbol \, connected by a separator (default: ""); +#X text 115 398 IEM KUG; +#X text 99 386 musil; +#X text 129 386 @; +#X text 135 386 iem.at; +#X text 50 375 (c) Thomas Musil 2000 - 2005; +#X text 98 408 Graz \, Austria; +#X connect 0 0 7 0; +#X connect 1 0 7 0; +#X connect 2 0 7 0; +#X connect 3 0 5 0; +#X connect 4 0 3 0; +#X connect 6 0 7 0; +#X connect 7 0 3 0; +#X connect 8 0 7 0; +#X connect 9 0 7 0; +#X connect 10 0 7 0; +#X connect 12 0 7 0; +#X connect 13 0 7 0; +#X connect 14 0 3 0; +#X connect 15 0 7 0; +#X connect 17 0 3 0; +#X connect 18 0 3 0; diff --git a/iemlib2/modulo_counter-help.pd b/iemlib2/modulo_counter-help.pd new file mode 100644 index 0000000..c95d5c7 --- /dev/null +++ b/iemlib2/modulo_counter-help.pd @@ -0,0 +1,24 @@ +#N canvas 167 267 525 297 10; +#X msg 27 97 bang; +#X floatatom 75 164 5 0 0 0 - - -; +#X floatatom 75 72 5 1 100 0 - - -; +#X floatatom 203 76 5 0 99 0 - - -; +#X obj 75 135 modulo_counter 10 5; +#X text 261 195 (optional) default 0; +#X text 161 182 2.arg: initial-value (0 .. max - 1); +#X text 161 168 1.arg: maximum; +#X text 36 54 maximum; +#X text 202 56 initial-value (0 .. max - 1); +#X text 115 238 IEM KUG; +#X text 99 226 musil; +#X text 129 226 @; +#X text 135 226 iem.at; +#X text 50 215 (c) Thomas Musil 2000 - 2005; +#X text 98 248 Graz \, Austria; +#X text 13 12 modulo_counter; +#X text 137 11 increments counter-number from 0 to max-1 by a bang +; +#X connect 0 0 4 0; +#X connect 2 0 4 0; +#X connect 3 0 4 1; +#X connect 4 0 1 0; diff --git a/iemlib2/parent$0-help.pd b/iemlib2/parent$0-help.pd new file mode 100644 index 0000000..aff09fe --- /dev/null +++ b/iemlib2/parent$0-help.pd @@ -0,0 +1,27 @@ +#N canvas 272 366 632 308 10; +#X obj 35 111 test-parentdollarzero; +#X obj 299 107 f \$0; +#X obj 299 88 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 299 129 5 0 0 0 - - -; +#X symbolatom 35 132 10 0 0 0 - - -; +#X obj 35 91 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 460 113 parent$0; +#X text 436 96 use this in an abstraction; +#X text 55 94 open this abstraction; +#X text 15 10 parentdollarzero; +#X text 156 12 receives the parent \$0 symbol; +#X text 14 28 (abbr. parent$0); +#X text 23 148 output: of unique number; +#X text 241 148 output: of unique number; +#X text 115 238 IEM KUG; +#X text 99 226 musil; +#X text 129 226 @; +#X text 135 226 iem.at; +#X text 50 215 (c) Thomas Musil 2000 - 2005; +#X text 98 248 Graz \, Austria; +#X connect 0 0 4 0; +#X connect 1 0 3 0; +#X connect 2 0 1 0; +#X connect 5 0 0 0; diff --git a/iemlib2/parentdollarzero-help.pd b/iemlib2/parentdollarzero-help.pd new file mode 100644 index 0000000..9d72108 --- /dev/null +++ b/iemlib2/parentdollarzero-help.pd @@ -0,0 +1,27 @@ +#N canvas 272 366 628 304 10; +#X obj 35 111 test-parentdollarzero; +#X obj 299 107 f \$0; +#X obj 299 88 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 299 129 5 0 0 0 - - -; +#X symbolatom 35 132 10 0 0 0 - - -; +#X obj 35 91 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 460 113 parent$0; +#X text 436 96 use this in an abstraction; +#X text 55 94 open this abstraction; +#X text 15 10 parentdollarzero; +#X text 156 12 receives the parent \$0 symbol; +#X text 14 28 (abbr. parent$0); +#X text 23 148 output: of unique number; +#X text 241 148 output: of unique number; +#X text 115 228 IEM KUG; +#X text 99 216 musil; +#X text 129 216 @; +#X text 135 216 iem.at; +#X text 50 205 (c) Thomas Musil 2000 - 2005; +#X text 98 238 Graz \, Austria; +#X connect 0 0 4 0; +#X connect 1 0 3 0; +#X connect 2 0 1 0; +#X connect 5 0 0 0; diff --git a/iemlib2/post_netreceive-help.pd b/iemlib2/post_netreceive-help.pd new file mode 100644 index 0000000..ee0647f --- /dev/null +++ b/iemlib2/post_netreceive-help.pd @@ -0,0 +1,116 @@ +#N canvas 153 56 750 556 10; +#X msg 4 186 clear; +#X floatatom 33 95 5 0 0 0 - - -; +#X obj 82 124 pp 1; +#X floatatom 82 98 5 0 0 0 - - -; +#X floatatom 135 100 5 0 0 0 - - -; +#X obj 33 121 pp 0; +#X obj 135 126 pp 2; +#X obj 15 345 r aaa; +#X floatatom 15 368 5 0 0 0 - - -; +#X floatatom 61 367 5 0 0 0 - - -; +#X floatatom 108 367 5 0 0 0 - - -; +#X obj 61 344 r bbbb; +#X obj 108 344 r ccccc; +#X obj 305 62 loadbang; +#X text 37 39 to sended messages without this float-index; +#X obj 135 421 nbx 5 28 -1e+037 1e+037 0 0 aaa aaa aaa -68 13 0 28 +-225280 -1109 -260818 0 256; +#X obj 135 457 nbx 5 28 -1e+037 1e+037 0 0 bbbb bbbb bbbb -88 13 0 +28 -225280 -1109 -260818 0 256; +#X obj 135 492 nbx 5 28 -1e+037 1e+037 0 0 ccccc ccccc ccccc -110 13 +0 28 -225280 -1109 -260818 0 256; +#X msg 295 112 bbbb 1; +#X msg 287 89 aaa 0; +#X msg 481 186 fetch_all_parameters 3; +#X obj 55 317 print abc; +#X floatatom 178 394 5 0 0 0 - - -; +#X obj 182 345 r vu_level; +#X msg 306 133 set ccccc 2; +#X msg 318 156 vu_level 3; +#X floatatom 183 82 5 0 0 0 - - -; +#X msg 196 105 \$1 \$1; +#X obj 186 131 pp 3; +#X obj 182 368 unpack; +#X floatatom 221 394 5 0 0 0 - - -; +#X obj 382 392 vu 15 120 vu_level empty 35 8 0 8 -66577 -1 1 0; +#X floatatom 15 393 5 0 0 0 - - -; +#X floatatom 61 392 5 0 0 0 - - -; +#X floatatom 108 392 5 0 0 0 - - -; +#X obj 55 295 post_netreceive 0 80; +#X msg 471 226 all_parameters 1 2 3; +#X msg 441 272 set_all_parameters 21 22 23; +#X obj 217 208 pp set_item_name; +#X msg 482 162 fetch_all_parameters 5; +#X obj 432 168 pp 4; +#X msg 409 120 33 44 55; +#X msg 496 120 99 88 77; +#X msg 331 180 gg_list 4; +#X obj 489 359 r gg_list; +#X obj 489 381 unpack 0 0 0; +#X floatatom 489 412 5 0 0 0 - - -; +#X floatatom 527 410 5 0 0 0 - - -; +#X floatatom 567 407 5 0 0 0 - - -; +#X text 11 6 post_netreceive; +#X text 27 26 convert message-lists with a prepended float-index; +#X text 193 294 1.arg: minimum-index; +#X text 193 306 2.arg: maximum-index; +#X text 441 292 output to the first 3 send-symbols; +#X text 441 301 these 3 numbers with a prepended set message; +#X text 474 241 output to the first 3 send-symbols; +#X text 474 249 these 3 numbers; +#X text 487 203 send the first 3 parameters; +#X text 21 64 send the number; +#X text 15 73 to the corresp. send-sym; +#X text 361 57 set_item_name: send-symbol + para-index; +#X msg 348 110 ccccc 2; +#X text 546 491 IEM KUG; +#X text 530 479 musil; +#X text 560 479 @; +#X text 566 479 iem.at; +#X text 481 468 (c) Thomas Musil 2000 - 2005; +#X text 529 501 Graz \, Austria; +#X text 145 5 obsolete \, replaced by list2receive; +#X connect 0 0 35 0; +#X connect 1 0 5 0; +#X connect 2 0 35 0; +#X connect 3 0 2 0; +#X connect 4 0 6 0; +#X connect 5 0 35 0; +#X connect 6 0 35 0; +#X connect 7 0 8 0; +#X connect 8 0 32 0; +#X connect 9 0 33 0; +#X connect 10 0 34 0; +#X connect 11 0 9 0; +#X connect 12 0 10 0; +#X connect 13 0 19 0; +#X connect 13 0 18 0; +#X connect 13 0 24 0; +#X connect 13 0 25 0; +#X connect 13 0 43 0; +#X connect 18 0 38 0; +#X connect 19 0 38 0; +#X connect 20 0 35 0; +#X connect 23 0 29 0; +#X connect 24 0 38 0; +#X connect 25 0 38 0; +#X connect 26 0 27 0; +#X connect 27 0 28 0; +#X connect 28 0 35 0; +#X connect 29 0 22 0; +#X connect 29 1 30 0; +#X connect 35 0 21 0; +#X connect 36 0 35 0; +#X connect 37 0 35 0; +#X connect 38 0 35 0; +#X connect 39 0 35 0; +#X connect 40 0 35 0; +#X connect 41 0 40 0; +#X connect 42 0 40 0; +#X connect 43 0 38 0; +#X connect 44 0 45 0; +#X connect 45 0 46 0; +#X connect 45 1 47 0; +#X connect 45 2 48 0; +#X connect 61 0 38 0; diff --git a/iemlib2/pp-help.pd b/iemlib2/pp-help.pd new file mode 100644 index 0000000..d43ff66 --- /dev/null +++ b/iemlib2/pp-help.pd @@ -0,0 +1,75 @@ +#N canvas 231 172 617 507 10; +#X obj 117 376 print; +#X msg 117 61 1; +#X obj 238 41 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 117 40 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X msg 117 149 11 22; +#X msg 238 150 33 44; +#X msg 238 63 3; +#X msg 117 105 symbol foo; +#X msg 238 107 symbol zyx; +#X msg 117 83 float 1.1; +#X msg 238 85 float 3.3; +#X msg 117 127 set; +#X msg 238 128 open; +#X msg 117 172 list -55 -66; +#X msg 238 172 list -77 -88; +#X msg 238 195 list bbb 987; +#X msg 117 195 list aaa 123; +#X msg 117 218 jkl 555 uuu; +#X msg 238 218 poi 777 ttt; +#X obj 191 377 route bang float symbol list; +#X obj 242 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 281 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 324 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 367 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 421 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 400 376 anything; +#X text 262 39 bang clears message-buffer; +#X text 175 319 head of output-message; +#X text 180 308 initials-arguments:; +#X text 5 281 tail of output-message; +#X text 183 287 head of output-message; +#X text 181 277 <- cold inlet; +#X obj 117 300 pp set; +#X text 115 448 IEM KUG; +#X text 99 436 musil; +#X text 129 436 @; +#X text 135 436 iem.at; +#X text 50 425 (c) Thomas Musil 2000 - 2005; +#X text 98 458 Graz \, Austria; +#X text 151 8 merge the head-message in front of the tail-message; +#X text 13 7 pp = iem_prepend; +#X text 42 273 hot inlet ->; +#X connect 1 0 32 0; +#X connect 2 0 32 1; +#X connect 3 0 32 0; +#X connect 4 0 32 0; +#X connect 5 0 32 1; +#X connect 6 0 32 1; +#X connect 7 0 32 0; +#X connect 8 0 32 1; +#X connect 9 0 32 0; +#X connect 10 0 32 1; +#X connect 11 0 32 0; +#X connect 12 0 32 1; +#X connect 13 0 32 0; +#X connect 14 0 32 1; +#X connect 15 0 32 1; +#X connect 16 0 32 0; +#X connect 17 0 32 0; +#X connect 18 0 32 1; +#X connect 19 0 20 0; +#X connect 19 1 21 0; +#X connect 19 2 22 0; +#X connect 19 3 23 0; +#X connect 19 4 24 0; +#X connect 32 0 0 0; +#X connect 32 0 19 0; diff --git a/iemlib2/pre_inlet-help.pd b/iemlib2/pre_inlet-help.pd new file mode 100644 index 0000000..37ef138 --- /dev/null +++ b/iemlib2/pre_inlet-help.pd @@ -0,0 +1,42 @@ +#N canvas 231 172 610 466 10; +#X msg 79 243 jkl 555 uuu; +#X text 13 7 pre_inlet; +#X obj 66 272 pre_inlet 1 0; +#X obj 66 348 print first; +#X obj 195 272 pre_inlet 1 1; +#X obj 195 348 print second; +#X obj 320 272 pre_inlet 1 2; +#X msg 208 243 abc ghj 78; +#X msg 333 243 zyx 3.17; +#X obj 320 348 print third; +#X text 104 48 you can use it for externals with more than one message-inlets +; +#X text 117 182 2.arg: number (0 .. 8.0e+06) \, you can interprete +as; +#X text 175 195 the inlet-index (inlet-selector-number); +#X text 100 9 before an incoming message will be relesed to outlet +\,; +#X text 112 23 a message of 2 items (symbol + float) will be sent; +#X msg 485 242 sss 3.17; +#X obj 472 271 pre_inlet 3 123; +#X obj 472 347 print xxx; +#X text 115 125 1.arg: ascii-number (1 .. 255) \, which will +be; +#X text 154 140 interpreted as a character \, which will be used as +a; +#X text 155 153 selector-symbol for a message (creates a denormal symbol) +; +#X text 115 408 IEM KUG; +#X text 99 396 musil; +#X text 129 396 @; +#X text 135 396 iem.at; +#X text 50 385 (c) Thomas Musil 2000 - 2005; +#X text 98 418 Graz \, Austria; +#X connect 0 0 2 0; +#X connect 2 0 3 0; +#X connect 4 0 5 0; +#X connect 6 0 9 0; +#X connect 7 0 4 0; +#X connect 8 0 6 0; +#X connect 15 0 16 0; +#X connect 16 0 17 0; diff --git a/iemlib2/pre_netsend-help.pd b/iemlib2/pre_netsend-help.pd new file mode 100644 index 0000000..b616ce4 --- /dev/null +++ b/iemlib2/pre_netsend-help.pd @@ -0,0 +1,53 @@ +#N canvas 59 233 595 316 10; +#X msg 294 123 clear; +#X obj 369 51 loadbang; +#X obj 340 173 pre_netsend 80; +#X obj 31 206 r aaa; +#X floatatom 31 229 5 0 0 0 - - -; +#X floatatom 93 231 5 0 0 0 - - -; +#X floatatom 168 231 5 0 0 0 - - -; +#X obj 93 208 r bbbb; +#X obj 168 209 r ccccc; +#X msg 226 206 \; bbbb 5.556; +#X obj 340 227 unpack 0 0; +#X floatatom 340 249 5 0 0 0 - - -; +#X floatatom 405 250 5 0 0 0 - - -; +#X obj 340 198 route send; +#X obj 340 148 pp set_item_name; +#X msg 350 81 aaa 0; +#X msg 359 103 bbbb 1; +#X msg 369 125 ccccc 2; +#X text 4 3 pre_netsend; +#X text 99 2 receive messages without prepended float-index and; +#X text 87 15 convert to message-lists with a prepended float-index +; +#X obj 125 77 nbx 5 28 -1e+037 1e+037 0 0 aaa aaa aaa -68 13 0 28 -225280 +-1109 -260818 0 256; +#X obj 125 113 nbx 5 28 -1e+037 1e+037 0 0 bbbb bbbb bbbb -88 13 0 +28 -225280 -1109 -260818 0 256; +#X obj 125 148 nbx 5 28 -1e+037 1e+037 0 0 ccccc ccccc ccccc -110 13 +0 28 -225280 -1109 -260818 0 256; +#X text 305 35 set_item_name: receive-symbol + para-index; +#X text 115 278 IEM KUG; +#X text 99 266 musil; +#X text 129 266 @; +#X text 135 266 iem.at; +#X text 50 255 (c) Thomas Musil 2000 - 2005; +#X text 98 288 Graz \, Austria; +#X text 447 1 obsolete \, replaced by; +#X text 474 13 receive2list; +#X connect 0 0 2 0; +#X connect 1 0 15 0; +#X connect 1 0 16 0; +#X connect 1 0 17 0; +#X connect 2 0 13 0; +#X connect 3 0 4 0; +#X connect 7 0 5 0; +#X connect 8 0 6 0; +#X connect 10 0 11 0; +#X connect 10 1 12 0; +#X connect 13 0 10 0; +#X connect 14 0 2 0; +#X connect 15 0 14 0; +#X connect 16 0 14 0; +#X connect 17 0 14 0; diff --git a/iemlib2/prepend-help.pd b/iemlib2/prepend-help.pd new file mode 100644 index 0000000..41b1b54 --- /dev/null +++ b/iemlib2/prepend-help.pd @@ -0,0 +1,75 @@ +#N canvas 231 172 617 507 10; +#X obj 117 376 print; +#X msg 117 61 1; +#X obj 238 41 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 117 40 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X msg 117 149 11 22; +#X msg 238 150 33 44; +#X msg 238 63 3; +#X msg 117 105 symbol foo; +#X msg 238 107 symbol zyx; +#X msg 117 83 float 1.1; +#X msg 238 85 float 3.3; +#X msg 117 127 set; +#X msg 238 128 open; +#X msg 117 172 list -55 -66; +#X msg 238 172 list -77 -88; +#X msg 238 195 list bbb 987; +#X msg 117 195 list aaa 123; +#X msg 117 218 jkl 555 uuu; +#X msg 238 218 poi 777 ttt; +#X obj 191 377 route bang float symbol list; +#X obj 242 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 281 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 324 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 367 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 421 395 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 400 376 anything; +#X text 262 39 bang clears message-buffer; +#X text 175 319 head of output-message; +#X text 180 308 initials-arguments:; +#X text 5 281 tail of output-message; +#X text 183 287 head of output-message; +#X text 181 277 <- cold inlet; +#X obj 117 300 pp set; +#X text 115 448 IEM KUG; +#X text 99 436 musil; +#X text 129 436 @; +#X text 135 436 iem.at; +#X text 50 425 (c) Thomas Musil 2000 - 2005; +#X text 98 458 Graz \, Austria; +#X text 151 8 merge the head-message in front of the tail-message; +#X text 42 273 hot inlet ->; +#X text 13 7 prepend; +#X connect 1 0 32 0; +#X connect 2 0 32 1; +#X connect 3 0 32 0; +#X connect 4 0 32 0; +#X connect 5 0 32 1; +#X connect 6 0 32 1; +#X connect 7 0 32 0; +#X connect 8 0 32 1; +#X connect 9 0 32 0; +#X connect 10 0 32 1; +#X connect 11 0 32 0; +#X connect 12 0 32 1; +#X connect 13 0 32 0; +#X connect 14 0 32 1; +#X connect 15 0 32 1; +#X connect 16 0 32 0; +#X connect 17 0 32 0; +#X connect 18 0 32 1; +#X connect 19 0 20 0; +#X connect 19 1 21 0; +#X connect 19 2 22 0; +#X connect 19 3 23 0; +#X connect 19 4 24 0; +#X connect 32 0 0 0; +#X connect 32 0 19 0; diff --git a/iemlib2/prepend_ascii-help.pd b/iemlib2/prepend_ascii-help.pd new file mode 100644 index 0000000..1b193c4 --- /dev/null +++ b/iemlib2/prepend_ascii-help.pd @@ -0,0 +1,45 @@ +#N canvas 244 76 687 466 10; +#X msg 94 245 jkl 555 uuu; +#X msg 208 243 abc ghj 78; +#X msg 433 242 zyx 3.17; +#X text 118 104 1.arg: ascii-number (1 .. 255) \, which will +be; +#X text 157 119 interpreted as a character \, which will be used as +a; +#X text 158 132 selector-symbol for a message (creates a denormal symbol) +; +#X text 13 7 prepend_ascii; +#X obj 66 272 prepend_ascii 1; +#X obj 195 272 prepend_ascii 2 open ttt 666; +#X obj 52 241 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X msg 68 215 44; +#X msg 99 214 symbol hhh; +#X obj 420 271 prepend_ascii 3 55 66; +#X obj 66 348 print xxx; +#X obj 195 348 print yyy; +#X obj 420 347 print zzz; +#X text 127 9 prepends the list-arguments in front of an incomming +; +#X text 128 22 message \, the first item of the arguments has to be +; +#X text 126 36 a integer between 1 and 255 and will be interpreted +; +#X text 125 51 as a ascii-character \, which will be converted to; +#X text 126 64 a selector-symbol; +#X text 105 160 nth.arg: anything; +#X text 115 408 IEM KUG; +#X text 99 396 musil; +#X text 129 396 @; +#X text 135 396 iem.at; +#X text 50 385 (c) Thomas Musil 2000 - 2005; +#X text 98 418 Graz \, Austria; +#X connect 0 0 7 0; +#X connect 1 0 8 0; +#X connect 2 0 12 0; +#X connect 7 0 13 0; +#X connect 8 0 14 0; +#X connect 9 0 7 0; +#X connect 10 0 7 0; +#X connect 11 0 7 0; +#X connect 12 0 15 0; diff --git a/iemlib2/receive2list-help.pd b/iemlib2/receive2list-help.pd new file mode 100644 index 0000000..8c399fa --- /dev/null +++ b/iemlib2/receive2list-help.pd @@ -0,0 +1,121 @@ +#N canvas 107 27 840 566 10; +#X floatatom 340 478 5 0 0 0 - - -; +#X floatatom 356 439 5 0 0 0 - - -; +#X floatatom 372 367 5 0 0 0 - - -; +#X floatatom 388 330 5 0 0 0 - - -; +#X text 427 93 init; +#X floatatom 14 151 5 0 0 0 - - -; +#X obj 14 171 s aaa; +#X floatatom 53 99 5 0 0 0 - - -; +#X floatatom 163 151 5 0 0 0 - - -; +#X floatatom 202 130 5 0 0 0 - - -; +#X obj 53 171 s bbb; +#X obj 163 171 s ccc; +#X obj 202 172 s ddd; +#X obj 244 172 s eee; +#X msg 244 79 symbol abc; +#X msg 250 101 symbol xyz; +#X obj 340 94 loadbang; +#X text 10 13 receive2list; +#X text 119 11 convert received message to a list; +#X text 121 38 the corresponding prepend-floats and receive-symbols +; +#X text 121 25 with a prepended float.; +#X obj 202 150 pp set; +#X obj 340 497 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 372 384 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 388 348 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X msg 402 143 clear; +#X floatatom 413 348 5 0 0 0 - - -; +#X floatatom 364 499 5 0 0 0 - - -; +#X floatatom 389 439 5 0 0 0 - - -; +#X floatatom 393 385 5 0 0 0 - - -; +#X msg 611 119 300 xxx; +#X obj 340 136 pp add; +#X symbolatom 404 285 10 0 0 0 - - -; +#X symbolatom 425 310 10 0 0 0 - - -; +#X obj 404 310 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X obj 453 261 symbol; +#X symbolatom 264 151 10 0 0 0 - - -; +#X floatatom 32 312 5 0 0 0 - - -; +#X msg 59 351 22 33 44 55; +#X obj 67 375 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X msg 261 125 set fgh; +#X obj 420 216 print out5; +#X obj 32 401 s fff; +#X symbolatom 44 329 10 0 0 0 - - -; +#X msg 340 115 0 aaa \, 1 bbb \, 2 ccc \, 3 ddd \, 4 eee; +#X obj 340 188 route 0 1 2 3 4 5; +#X obj 404 240 route set; +#X obj 404 261 pp set; +#X text 438 164 1.arg: max. number of receiveable parameters +; +#X obj 53 149 pack 0 0 0; +#X floatatom 88 99 5 0 0 0 - - -; +#X floatatom 123 99 5 0 0 0 - - -; +#X obj 88 118 t b f; +#X obj 123 121 t b f; +#X obj 356 408 unpack 0 0 0; +#X floatatom 423 439 5 0 0 0 - - -; +#X obj 340 164 receive2list 10; +#X text 122 52 have to be inputed via an add message.; +#X msg 531 41 0 xaaa \, 1 xbbb \, 2 xccc \, 3 xddd \, 4 xeee; +#X text 115 488 IEM KUG; +#X text 99 476 musil; +#X text 129 476 @; +#X text 135 476 iem.at; +#X text 50 465 (c) Thomas Musil 2000 - 2005; +#X text 98 498 Graz \, Austria; +#X connect 0 0 22 0; +#X connect 0 0 27 0; +#X connect 2 0 23 0; +#X connect 2 0 29 0; +#X connect 3 0 24 0; +#X connect 3 0 26 0; +#X connect 5 0 6 0; +#X connect 7 0 49 0; +#X connect 8 0 11 0; +#X connect 9 0 21 0; +#X connect 14 0 13 0; +#X connect 15 0 13 0; +#X connect 16 0 44 0; +#X connect 21 0 12 0; +#X connect 25 0 56 0; +#X connect 30 0 31 0; +#X connect 31 0 56 0; +#X connect 32 0 33 0; +#X connect 32 0 34 0; +#X connect 35 0 32 0; +#X connect 36 0 13 0; +#X connect 37 0 42 0; +#X connect 38 0 42 0; +#X connect 39 0 42 0; +#X connect 40 0 13 0; +#X connect 43 0 42 0; +#X connect 44 0 31 0; +#X connect 45 0 0 0; +#X connect 45 1 54 0; +#X connect 45 2 2 0; +#X connect 45 3 3 0; +#X connect 45 4 46 0; +#X connect 45 5 41 0; +#X connect 46 0 47 0; +#X connect 46 1 35 0; +#X connect 47 0 32 0; +#X connect 49 0 10 0; +#X connect 50 0 52 0; +#X connect 51 0 53 0; +#X connect 52 0 49 0; +#X connect 52 1 49 1; +#X connect 53 0 49 0; +#X connect 53 1 49 2; +#X connect 54 0 1 0; +#X connect 54 1 28 0; +#X connect 54 2 55 0; +#X connect 56 0 45 0; +#X connect 58 0 31 0; diff --git a/iemlib2/round_zero-help.pd b/iemlib2/round_zero-help.pd new file mode 100644 index 0000000..a67378d --- /dev/null +++ b/iemlib2/round_zero-help.pd @@ -0,0 +1,21 @@ +#N canvas 158 131 558 330 10; +#X obj 55 160 round_zero 1e-006; +#X msg 55 78 -1e-007; +#X text 10 8 round_zero; +#X obj 55 183 print rounded; +#X msg 116 78 1e-007; +#X msg 67 114 -1e-005; +#X msg 128 114 1e-005; +#X text 122 9 round very small numbers between plus and minus first +argument to zero; +#X text 115 268 IEM KUG; +#X text 99 256 musil; +#X text 129 256 @; +#X text 135 256 iem.at; +#X text 50 245 (c) Thomas Musil 2000 - 2005; +#X text 98 278 Graz \, Austria; +#X connect 0 0 3 0; +#X connect 1 0 0 0; +#X connect 4 0 0 0; +#X connect 5 0 0 0; +#X connect 6 0 0 0; diff --git a/iemlib2/speedlim-help.pd b/iemlib2/speedlim-help.pd new file mode 100644 index 0000000..ff35286 --- /dev/null +++ b/iemlib2/speedlim-help.pd @@ -0,0 +1,33 @@ +#N canvas 465 200 400 313 10; +#X msg 173 43 1000; +#X msg 176 65 200; +#X floatatom 67 86 4 0 0 0 - - -; +#X floatatom 46 152 4 0 0 0 - - -; +#X obj 95 150 t f b b; +#X obj 117 174 timer; +#X obj 95 200 pack 0 0; +#X obj 95 225 print; +#X msg 179 86 20; +#X obj 67 115 speedlim 20; +#X text 6 7 speedlim : speedlimit for float-message; +#X text 153 115 1.arg: lock-time in ms; +#X obj 46 171 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X text 235 248 IEM KUG; +#X text 219 236 musil; +#X text 249 236 @; +#X text 255 236 iem.at; +#X text 170 225 (c) Thomas Musil 2000 - 2005; +#X text 218 258 Graz \, Austria; +#X connect 0 0 9 1; +#X connect 1 0 9 1; +#X connect 2 0 9 0; +#X connect 3 0 12 0; +#X connect 4 0 6 0; +#X connect 4 1 5 0; +#X connect 4 2 5 1; +#X connect 5 0 6 1; +#X connect 6 0 7 0; +#X connect 8 0 9 1; +#X connect 9 0 3 0; +#X connect 9 0 4 0; diff --git a/iemlib2/splitfilename-help.pd b/iemlib2/splitfilename-help.pd new file mode 100644 index 0000000..23bbe5f --- /dev/null +++ b/iemlib2/splitfilename-help.pd @@ -0,0 +1,89 @@ +#N canvas 235 44 685 574 10; +#X text 9 1 splitfilename: split into path and filename; +#X obj 53 391 print path; +#X obj 139 391 print file; +#X msg 389 153 separator $; +#X msg 389 88 separator @; +#X msg 389 109 separator :; +#X msg 25 74 C:/program/pd/my_project my_foo.pd; +#X obj 63 338 print path+file; +#X msg 389 46 separator /; +#N canvas 4 20 450 300 /SUBPATCH/ 0; +#X obj 101 31 inlet; +#X obj 100 59 outlet; +#X connect 0 0 1 0; +#X restore 389 276 pd; +#X msg 389 174 separator z; +#X msg 389 195 separator _; +#X msg 389 216 separator .; +#X text 120 19 (separator is last "/"); +#X msg 389 67 separator space; +#X msg 54 98 /home/me my_first_patch.pd; +#X text 156 368 1.arg: separator-character (opt. \, default +"/"); +#X msg 405 250 separator; +#X msg 389 131 separator 2; +#X msg 534 78 separator backslash; +#X msg 534 97 separator leftbrace; +#X msg 534 116 separator rightbrace; +#X msg 534 135 separator dollar; +#X msg 534 154 separator comma; +#X msg 534 173 separator semi; +#N canvas 4 20 450 300 /SUBPATCH/ 0; +#X obj 101 31 inlet; +#X obj 100 59 outlet; +#X connect 0 0 1 0; +#X restore 534 255 pd; +#X obj 53 315 mergefilename /; +#X obj 53 368 splitfilename /; +#X text 115 458 IEM KUG; +#X text 99 446 musil; +#X text 129 446 @; +#X text 135 446 iem.at; +#X text 50 435 (c) Thomas Musil 2000 - 2005; +#X text 98 468 Graz \, Austria; +#X floatatom 273 196 5 0 255 0 - - -; +#N canvas 191 208 354 235 ASCII_separator 0; +#X obj 138 55 inlet; +#X obj 138 143 outlet; +#X obj 138 76 clip 0 255; +#X obj 138 98 - 32; +#X msg 138 121 separator \$1; +#X obj 37 121 makefilename %c; +#X obj 37 143 outlet; +#X connect 0 0 2 0; +#X connect 2 0 3 0; +#X connect 2 0 5 0; +#X connect 3 0 4 0; +#X connect 4 0 1 0; +#X connect 5 0 6 0; +#X restore 273 216 pd ASCII_separator; +#X symbolatom 273 240 0 0 0 0 - - -; +#X connect 3 0 9 0; +#X connect 4 0 9 0; +#X connect 5 0 9 0; +#X connect 6 0 26 0; +#X connect 8 0 9 0; +#X connect 9 0 26 0; +#X connect 9 0 27 0; +#X connect 10 0 9 0; +#X connect 11 0 9 0; +#X connect 12 0 9 0; +#X connect 14 0 9 0; +#X connect 15 0 26 0; +#X connect 17 0 9 0; +#X connect 18 0 9 0; +#X connect 19 0 25 0; +#X connect 20 0 25 0; +#X connect 21 0 25 0; +#X connect 22 0 25 0; +#X connect 23 0 25 0; +#X connect 24 0 25 0; +#X connect 25 0 9 0; +#X connect 26 0 7 0; +#X connect 26 0 27 0; +#X connect 27 0 1 0; +#X connect 27 1 2 0; +#X connect 34 0 35 0; +#X connect 35 0 36 0; +#X connect 35 1 9 0; diff --git a/iemlib2/src/LFO_noise~.c b/iemlib2/src/LFO_noise~.c new file mode 100644 index 0000000..f07ffbe --- /dev/null +++ b/iemlib2/src/LFO_noise~.c @@ -0,0 +1,122 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" + + +/* -------------------- LFO_noise~ --------------------- */ +/* ---- outputs a 2 point interpolated white noise ----- */ +/* -- with lower cutoff frequency than 0.5 samplerate -- */ + +static t_class *LFO_noise_tilde_class; + +typedef struct _LFO_noise_tilde +{ + t_object x_obj; + double x_range; + double x_rcp_range; + unsigned int x_state; + t_float x_fact; + t_float x_incr; + t_float x_y1; + t_float x_y2; + t_float x_phase; +} t_LFO_noise_tilde; + +static int LFO_noise_tilde_makeseed(void) +{ + static unsigned int LFO_noise_tilde_nextseed = 1489853723; + + LFO_noise_tilde_nextseed = LFO_noise_tilde_nextseed * 435898247 + 938284287; + return(LFO_noise_tilde_nextseed & 0x7fffffff); +} + +static float LFO_noise_tilde_new_rand(t_LFO_noise_tilde *x) +{ + unsigned int state = x->x_state; + double new_val, range = x->x_range; + + x->x_state = state = state * 472940017 + 832416023; + new_val = range * ((double)state) * (1./4294967296.); + if(new_val >= range) + new_val = range-1; + new_val -= 32767.0; + return(new_val*(1.0/32767.0)); +} + +static void *LFO_noise_tilde_new(t_float freq) +{ + t_LFO_noise_tilde *x = (t_LFO_noise_tilde *)pd_new(LFO_noise_tilde_class); + + x->x_range = 65535.0; + x->x_rcp_range = (double)x->x_range * (1.0/4294967296.0); + x->x_state = LFO_noise_tilde_makeseed(); + x->x_fact = 2.0f / 44100.0f; + x->x_incr = freq * x->x_fact; + if(x->x_incr < 0.0f) + x->x_incr = 0.0f; + else if(x->x_incr > 0.1f) + x->x_incr = 0.1f; + x->x_y1 = LFO_noise_tilde_new_rand(x); + x->x_y2 = LFO_noise_tilde_new_rand(x); + x->x_phase = 0.0f; + outlet_new(&x->x_obj, gensym("signal")); + return (x); +} + +static t_int *LFO_noise_tilde_perform(t_int *w) +{ + t_float *out = (t_float *)(w[1]); + t_LFO_noise_tilde *x = (t_LFO_noise_tilde *)(w[2]); + int n = (int)(w[3]); + t_float phase = x->x_phase; + t_float x_y1 = x->x_y1; + t_float x_y2 = x->x_y2; + t_float incr = x->x_incr; + + while(n--) + { + if(phase > 1.0f) + { + x_y1 = x_y2; + x_y2 = LFO_noise_tilde_new_rand(x); + phase -= 1.0; + } + *out++ = (x_y2 - x_y1) * phase + x_y1; + phase += incr; + } + x->x_phase = phase; + x->x_y1 = x_y1; + x->x_y2 = x_y2; + return (w+4); +} + +static void LFO_noise_tilde_float(t_LFO_noise_tilde *x, t_floatarg freq) +{ + x->x_incr = freq * x->x_fact; + if(x->x_incr < 0.0f) + x->x_incr = 0.0f; + else if(x->x_incr > 0.1f) + x->x_incr = 0.1f; +} + +static void LFO_noise_tilde_dsp(t_LFO_noise_tilde *x, t_signal **sp) +{ + x->x_fact = 2.0f / sp[0]->s_sr; + dsp_add(LFO_noise_tilde_perform, 3, sp[0]->s_vec, x, sp[0]->s_n); +} + +void LFO_noise_tilde_setup(void) +{ + LFO_noise_tilde_class = class_new(gensym("LFO_noise~"), + (t_newmethod)LFO_noise_tilde_new, 0, + sizeof(t_LFO_noise_tilde), 0, A_DEFFLOAT, 0); + class_addmethod(LFO_noise_tilde_class, (t_method)LFO_noise_tilde_dsp, + gensym("dsp"), 0); + class_addfloat(LFO_noise_tilde_class, (t_method)LFO_noise_tilde_float); +// class_sethelpsymbol(LFO_noise_tilde_class, gensym("iemhelp/help-LFO_noise~")); +} diff --git a/iemlib2/src/add2_comma.c b/iemlib2/src/add2_comma.c new file mode 100644 index 0000000..5868003 --- /dev/null +++ b/iemlib2/src/add2_comma.c @@ -0,0 +1,116 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + +#include "m_pd.h" +#include "iemlib.h" + + +/* --------------------------------- add2_comma ----------------------------------- */ +/* -- a special add2-message for messageboxes, which append a comma to a message -- */ + +static t_class *add2_comma_class; + +typedef struct _add2_comma +{ + t_object x_obj; + int x_size; + t_atom *x_at; + t_symbol *x_sym; + t_atomtype x_type; +} t_add2_comma; + +static void add2_comma_bang(t_add2_comma *x) +{ + SETCOMMA(x->x_at); + outlet_anything(x->x_obj.ob_outlet, x->x_sym, 1, x->x_at); +} + +static void add2_comma_float(t_add2_comma *x, t_floatarg f) +{ + SETCOMMA(x->x_at); + SETFLOAT(x->x_at+1, f); + outlet_anything(x->x_obj.ob_outlet, x->x_sym, 2, x->x_at); +} + +static void add2_comma_symbol(t_add2_comma *x, t_symbol *s) +{ + SETCOMMA(x->x_at); + SETSYMBOL(x->x_at+1, s); + outlet_anything(x->x_obj.ob_outlet, x->x_sym, 2, x->x_at); +} + +/*static void add2_comma_pointer(t_add2_comma *x, t_gpointer *gp) +{ +if(!x->x_at) +{ +x->x_n = 1; +x->x_at = (t_atom *)getbytes(sizeof(t_atom)); +} +x->x_ac = 1; +SETPOINTER(x->x_at, gp); +x->x_sym = &s_pointer; +outlet_pointer(x->x_obj.ob_outlet, gp); +}*/ + +static void add2_comma_list(t_add2_comma *x, t_symbol *s, int ac, t_atom *av) +{ + int i; + + if((ac+1) > x->x_size) + { + x->x_at = (t_atom *)resizebytes(x->x_at, x->x_size*sizeof(t_atom), (ac+2)*sizeof(t_atom)); + x->x_size = ac+2; + } + SETCOMMA(x->x_at); + for(i=1; i<=ac; i++) + x->x_at[i] = av[i-1]; + outlet_anything(x->x_obj.ob_outlet, x->x_sym, ac+1, x->x_at); +} + +static void add2_comma_anything(t_add2_comma *x, t_symbol *s, int ac, t_atom *av) +{ + int i; + + if((ac+2) > x->x_size) + { + x->x_at = (t_atom *)resizebytes(x->x_at, x->x_size*sizeof(t_atom), (ac+3)*sizeof(t_atom)); + x->x_size = ac+3; + } + SETCOMMA(x->x_at); + SETSYMBOL(x->x_at+1, s); + for(i=1; i<=ac; i++) + x->x_at[i+1] = av[i-1]; + outlet_anything(x->x_obj.ob_outlet, x->x_sym, ac+2, x->x_at); +} + +static void add2_comma_free(t_add2_comma *x) +{ + if(x->x_at) + freebytes(x->x_at, x->x_size * sizeof(t_atom)); +} + +static void *add2_comma_new(void) +{ + t_add2_comma *x = (t_add2_comma *)pd_new(add2_comma_class); + + x->x_size = 10; + x->x_at = (t_atom *)getbytes(x->x_size * sizeof(t_atom)); + x->x_sym = gensym("add2"); + outlet_new(&x->x_obj, &s_list); + return(x); +} + +void add2_comma_setup(void) +{ + add2_comma_class = class_new(gensym("add2_comma"), (t_newmethod)add2_comma_new, + (t_method)add2_comma_free, sizeof(t_add2_comma), 0, 0); + class_addbang(add2_comma_class, (t_method)add2_comma_bang); + class_addanything(add2_comma_class, add2_comma_anything); + class_addlist(add2_comma_class, add2_comma_list); + /*class_addpointer(add2_comma_class, add2_comma_pointer);*/ + class_addfloat(add2_comma_class, (t_method)add2_comma_float); + class_addsymbol(add2_comma_class, add2_comma_symbol); +// class_sethelpsymbol(add2_comma_class, gensym("iemhelp/help-add2_comma")); +} diff --git a/iemlib2/src/bpe.c b/iemlib2/src/bpe.c new file mode 100644 index 0000000..a1311cc --- /dev/null +++ b/iemlib2/src/bpe.c @@ -0,0 +1,119 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + +#include "m_pd.h" +#include "iemlib.h" + + +/* --------------------------- bpe -------------------------------- */ +/* -- break-point-envelope, convert a list of value-time-doubles -- */ +/* ------- into a time-scheduled stream of value-time-pairs ------- */ + +static t_class *bpe_class; + +typedef struct _bpe +{ + t_object x_obj; + t_clock *x_clock; + int x_maxnum; + int x_curnum; + int x_curindex; + t_atom *x_beg; + void *x_out_val; + void *x_out_time; + void *x_out_finished; +} t_bpe; + +static void bpe_stop(t_bpe *x) +{ + clock_unset(x->x_clock); +} + +static void bpe_tick(t_bpe *x) +{ + t_atom *vec = x->x_beg; + t_float val, time; + + if(x->x_curindex >= x->x_curnum) + { + bpe_stop(x); + outlet_bang(x->x_out_finished); + } + else + { + vec += x->x_curindex; + val = atom_getfloat(vec++); + time = atom_getfloat(vec); + outlet_float(x->x_out_time, time); + outlet_float(x->x_out_val, val); + x->x_curindex += 2; + clock_delay(x->x_clock, time); + } +} + +static void bpe_bang(t_bpe *x) +{ + t_atom *vec = x->x_beg; + t_float val, time; + + if(x->x_curnum) + { + x->x_curindex = 2; + val = atom_getfloat(vec++); + time = atom_getfloat(vec); + outlet_float(x->x_out_time, time); + outlet_float(x->x_out_val, val); + clock_delay(x->x_clock, time); + } +} + +static void bpe_list(t_bpe *x, t_symbol *s, int ac, t_atom *av) +{ + int n = ac & 0xfffffffe, i; + t_atom *vec = x->x_beg; + if(n > x->x_maxnum) + { + freebytes(x->x_beg, x->x_maxnum*sizeof(t_atom)); + x->x_maxnum = 2 + n; + x->x_beg = (t_atom *)getbytes(x->x_maxnum*sizeof(t_atom)); + vec = x->x_beg; + } + x->x_curnum = n; + for(i=0; ix_beg, x->x_maxnum*sizeof(t_atom)); + clock_free(x->x_clock); +} + +static void *bpe_new(void) +{ + t_bpe *x = (t_bpe *)pd_new(bpe_class); + + x->x_curindex = 0; + x->x_maxnum = 20; + x->x_curnum = 0; + x->x_beg = (t_atom *)getbytes(x->x_maxnum*sizeof(t_atom)); + x->x_clock = clock_new(x, (t_method)bpe_tick); + x->x_out_val = outlet_new(&x->x_obj, &s_float); + x->x_out_time = outlet_new(&x->x_obj, &s_float); + x->x_out_finished = outlet_new(&x->x_obj, &s_bang); + return (x); +} + +void bpe_setup(void) +{ + bpe_class = class_new(gensym("bpe"), (t_newmethod)bpe_new, + (t_method)bpe_free, sizeof(t_bpe), 0, 0); + class_addmethod(bpe_class, (t_method)bpe_stop, gensym("stop"), 0); + class_addbang(bpe_class, bpe_bang); + class_addlist(bpe_class, (t_method)bpe_list); +// class_sethelpsymbol(bpe_class, gensym("iemhelp/help-bpe")); +} diff --git a/iemlib2/src/dollarg.c b/iemlib2/src/dollarg.c new file mode 100644 index 0000000..102a680 --- /dev/null +++ b/iemlib2/src/dollarg.c @@ -0,0 +1,105 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + +#include "m_pd.h" +#include "g_canvas.h" +#include "iemlib.h" + + +/* ------------------------- dollarg ---------------------------- */ +/* --- dollar-arguments, output the initial-arguments and the --- */ +/* ------- number of them of the parent abstraction-patch ------- */ + +static t_class *dollarg_class; + +typedef struct _dollarg +{ + t_object x_obj; + void *x_outlet_ac; + t_atom *x_at; + int x_ac; +} t_dollarg; + +static void dollarg_float(t_dollarg *x, t_floatarg f) +{ + int i = (int)f; + + if(!i) + { + outlet_float(x->x_outlet_ac, x->x_ac); + if(x->x_ac) + outlet_list(x->x_obj.ob_outlet, &s_list, x->x_ac, x->x_at); + } + else if(i > 0) + { + if(i <= x->x_ac) + { + outlet_float(x->x_outlet_ac, i); + if(IS_A_FLOAT(x->x_at, i-1)) + outlet_float(x->x_obj.ob_outlet, atom_getfloatarg(i-1, x->x_ac, x->x_at)); + else if(IS_A_SYMBOL(x->x_at, i-1)) + outlet_symbol(x->x_obj.ob_outlet, atom_getsymbolarg(i-1, x->x_ac, x->x_at)); + } + else + outlet_float(x->x_outlet_ac, 0); + } + else + { + int j = x->x_ac + i; + + if(j >= 0) + { + outlet_float(x->x_outlet_ac, j+1); + if(IS_A_FLOAT(x->x_at, j)) + outlet_float(x->x_obj.ob_outlet, atom_getfloatarg(j, x->x_ac, x->x_at)); + else if(IS_A_SYMBOL(x->x_at, j)) + outlet_symbol(x->x_obj.ob_outlet, atom_getsymbolarg(j, x->x_ac, x->x_at)); + } + else + outlet_float(x->x_outlet_ac, 0); + } +} + +static void dollarg_bang(t_dollarg *x) +{ + dollarg_float(x, 0.0f); +} + +static void dollarg_free(t_dollarg *x) +{ + if(x->x_ac) + freebytes(x->x_at, x->x_ac * sizeof(t_atom)); +} + +static void *dollarg_new(void) +{ + t_dollarg *x = (t_dollarg *)pd_new(dollarg_class); + t_glist *glist=(t_glist *)canvas_getcurrent(); + t_canvas *canvas=glist_getcanvas(glist); + int pargc; + t_atom *pargv, *at; + + canvas_setcurrent(canvas); + canvas_getargs(&pargc, &pargv); + canvas_unsetcurrent(canvas); + x->x_at = (t_atom *)getbytes(pargc*sizeof(t_atom)); + x->x_ac = pargc; + at = x->x_at; + while(pargc--) + *at++ = *pargv++; + outlet_new(&x->x_obj, &s_list); + x->x_outlet_ac = outlet_new(&x->x_obj, &s_float); + return (x); +} + +void dollarg_setup(void) +{ + dollarg_class = class_new(gensym("dollarg"), (t_newmethod)dollarg_new, + (t_method)dollarg_free, sizeof(t_dollarg), 0, 0); + class_addcreator((t_newmethod)dollarg_new, gensym("$n"), 0); + class_addbang(dollarg_class, (t_method)dollarg_bang); + class_addfloat(dollarg_class, (t_method)dollarg_float); +// class_sethelpsymbol(dollarg_class, gensym("iemhelp/help-dollarg")); +} diff --git a/iemlib2/src/exp_inc.c b/iemlib2/src/exp_inc.c new file mode 100644 index 0000000..e222071 --- /dev/null +++ b/iemlib2/src/exp_inc.c @@ -0,0 +1,132 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + +#include "m_pd.h" +#include "iemlib.h" + + +/* ------------------------ exp_inc ---------------------------- */ +/* ------- exponetial/linear-incremental-bang-counter ---------- */ + + +static t_class *exp_inc_class; + +typedef struct _exp_inc +{ + t_object x_obj; + t_float x_initialval; + t_float x_currentval; + t_float x_mulfactor; + t_float x_addincrement; + t_float x_min; + t_float x_max; +} t_exp_inc; + +static void exp_inc_bang(t_exp_inc *x) +{ + outlet_float(x->x_obj.ob_outlet, x->x_currentval); + x->x_currentval = x->x_currentval * x->x_mulfactor + x->x_addincrement; + if(x->x_currentval < x->x_min) + x->x_currentval = x->x_min; + if(x->x_currentval > x->x_max) + x->x_currentval = x->x_max; +} + +static void exp_inc_reset(t_exp_inc *x) +{ + x->x_currentval = x->x_initialval; + if(x->x_currentval < x->x_min) + x->x_currentval = x->x_min; + if(x->x_currentval > x->x_max) + x->x_currentval = x->x_max; +} + +static void exp_inc_float(t_exp_inc *x, t_floatarg f) +{ + x->x_initialval = (t_float)f; + x->x_currentval = x->x_initialval; + if(x->x_currentval < x->x_min) + x->x_currentval = x->x_min; + if(x->x_currentval > x->x_max) + x->x_currentval = x->x_max; +} + +static void exp_inc_ft1(t_exp_inc *x, t_floatarg f) +{ + x->x_mulfactor = 1.0 + 0.01*(t_float)f; +} + +static void exp_inc_ft2(t_exp_inc *x, t_floatarg f) +{ + x->x_addincrement = (t_float)f; +} + +static void exp_inc_ft3(t_exp_inc *x, t_floatarg f) +{ + x->x_min = (t_float)f; + if(x->x_currentval < x->x_min) + x->x_currentval = x->x_min; +} + +static void exp_inc_ft4(t_exp_inc *x, t_floatarg f) +{ + x->x_max = (t_float)f; + if(x->x_currentval > x->x_max) + x->x_currentval = x->x_max; +} + +static void exp_inc_list(t_exp_inc *x, t_symbol *s, int ac, t_atom *av) +{ + if((ac == 5)&&IS_A_FLOAT(av,0)&&IS_A_FLOAT(av,1)&&IS_A_FLOAT(av,2) + &&IS_A_FLOAT(av,3)&&IS_A_FLOAT(av,4)) + { + exp_inc_ft4(x, atom_getfloatarg(4, ac, av)); + exp_inc_ft3(x, atom_getfloatarg(3, ac, av)); + exp_inc_ft2(x, atom_getfloatarg(2, ac, av)); + exp_inc_ft1(x, atom_getfloatarg(1, ac, av)); + exp_inc_float(x, atom_getfloatarg(0, ac, av)); + } +} + +static void *exp_inc_new(t_symbol *s, int ac, t_atom *av) +{ + t_exp_inc *x = (t_exp_inc *)pd_new(exp_inc_class); + + x->x_currentval = 10.0; + x->x_mulfactor = 1.0; + x->x_addincrement = 0.0; + x->x_min = 0.0; + x->x_max = 1000.0; + if((ac == 5)&&IS_A_FLOAT(av,0)&&IS_A_FLOAT(av,1)&&IS_A_FLOAT(av,2) + &&IS_A_FLOAT(av,3)&&IS_A_FLOAT(av,4)) + { + exp_inc_ft4(x, atom_getfloatarg(4, ac, av)); + exp_inc_ft3(x, atom_getfloatarg(3, ac, av)); + exp_inc_ft2(x, atom_getfloatarg(2, ac, av)); + exp_inc_ft1(x, atom_getfloatarg(1, ac, av)); + exp_inc_float(x, atom_getfloatarg(0, ac, av)); + } + outlet_new(&x->x_obj, &s_float); + inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("ft1")); + inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("ft2")); + inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("ft3")); + inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("ft4")); + return (x); +} + +void exp_inc_setup(void) +{ + exp_inc_class = class_new(gensym("exp_inc"), (t_newmethod)exp_inc_new, + 0, sizeof(t_exp_inc), 0, A_GIMME, 0); + class_addbang(exp_inc_class, exp_inc_bang); + class_addlist(exp_inc_class, (t_method)exp_inc_list); + class_addmethod(exp_inc_class, (t_method)exp_inc_reset, gensym("reset"), 0); + class_addfloat(exp_inc_class, (t_method)exp_inc_float); + class_addmethod(exp_inc_class, (t_method)exp_inc_ft1, gensym("ft1"), A_FLOAT, 0); + class_addmethod(exp_inc_class, (t_method)exp_inc_ft2, gensym("ft2"), A_FLOAT, 0); + class_addmethod(exp_inc_class, (t_method)exp_inc_ft3, gensym("ft3"), A_FLOAT, 0); + class_addmethod(exp_inc_class, (t_method)exp_inc_ft4, gensym("ft4"), A_FLOAT, 0); +// class_sethelpsymbol(exp_inc_class, gensym("iemhelp/help-exp_inc")); +} diff --git a/iemlib2/src/fade~.c b/iemlib2/src/fade~.c new file mode 100644 index 0000000..5ff4fa5 --- /dev/null +++ b/iemlib2/src/fade~.c @@ -0,0 +1,176 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + +#include "m_pd.h" +#include "iemlib.h" +#include + +/* ------------------------- fade~ ----------------------------- */ +/* --- signal lookup tabel object with input range of 0 to 1 --- */ +/* ---- converts a linear signal ramp to the half of a : ------ */ +/* -- sine-wave, hanning-wave, squareroot-wave or mixes of it -- */ + +t_float *iem_fade_tilde_table_lin=(t_float *)0L; +t_float *iem_fade_tilde_table_linsqrt=(t_float *)0L; +t_float *iem_fade_tilde_table_sqrt=(t_float *)0L; +t_float *iem_fade_tilde_table_sin=(t_float *)0L; +t_float *iem_fade_tilde_table_sinhann=(t_float *)0L; +t_float *iem_fade_tilde_table_hann=(t_float *)0L; + +static t_class *fade_tilde_class; + +typedef struct _fade_tilde +{ + t_object x_obj; + t_float *x_table; + t_float x_f; +} t_fade_tilde; + +static void fade_tilde_set(t_fade_tilde *x, t_symbol *s) +{ + if(s == gensym("_lin")) + x->x_table = iem_fade_tilde_table_lin; + else if(s == gensym("_linsqrt")) + x->x_table = iem_fade_tilde_table_linsqrt; + else if(s == gensym("_sqrt")) + x->x_table = iem_fade_tilde_table_sqrt; + else if(s == gensym("_sin")) + x->x_table = iem_fade_tilde_table_sin; + else if(s == gensym("_sinhann")) + x->x_table = iem_fade_tilde_table_sinhann; + else if(s == gensym("_hann")) + x->x_table = iem_fade_tilde_table_hann; +} + +static void *fade_tilde_new(t_symbol *s) +{ + t_fade_tilde *x = (t_fade_tilde *)pd_new(fade_tilde_class); + outlet_new(&x->x_obj, gensym("signal")); + x->x_f = 0; + x->x_table = iem_fade_tilde_table_lin; + fade_tilde_set(x, s); + return (x); +} + +static t_int *fade_tilde_perform(t_int *w) +{ + t_float *in = (t_float *)(w[1]); + t_float *out = (t_float *)(w[2]); + t_fade_tilde *x = (t_fade_tilde *)(w[3]); + int n = (int)(w[4]); + t_float *tab = x->x_table, *addr, f1, f2, frac; + double dphase; + int normhipart; + union tabfudge tf; + + tf.tf_d = UNITBIT32; + normhipart = tf.tf_i[HIOFFSET]; + +#if 0 /* this is the readable version of the code. */ + while (n--) + { + dphase = (double)(*in++ * (t_float)(COSTABSIZE) * 0.99999) + UNITBIT32; + tf.tf_d = dphase; + addr = tab + (tf.tf_i[HIOFFSET] & (COSTABSIZE-1)); + tf.tf_i[HIOFFSET] = normhipart; + frac = tf.tf_d - UNITBIT32; + f1 = addr[0]; + f2 = addr[1]; + *out++ = f1 + frac * (f2 - f1); + } +#endif +#if 1 /* this is the same, unwrapped by hand. */ + dphase = (double)(*in++ * (t_float)(COSTABSIZE) * 0.99999) + UNITBIT32; + tf.tf_d = dphase; + addr = tab + (tf.tf_i[HIOFFSET] & (COSTABSIZE-1)); + tf.tf_i[HIOFFSET] = normhipart; + while (--n) + { + dphase = (double)(*in++ * (t_float)(COSTABSIZE) * 0.99999) + UNITBIT32; + frac = tf.tf_d - UNITBIT32; + tf.tf_d = dphase; + f1 = addr[0]; + f2 = addr[1]; + addr = tab + (tf.tf_i[HIOFFSET] & (COSTABSIZE-1)); + *out++ = f1 + frac * (f2 - f1); + tf.tf_i[HIOFFSET] = normhipart; + } + frac = tf.tf_d - UNITBIT32; + f1 = addr[0]; + f2 = addr[1]; + *out++ = f1 + frac * (f2 - f1); +#endif + return (w+5); +} + +static void fade_tilde_dsp(t_fade_tilde *x, t_signal **sp) +{ + dsp_add(fade_tilde_perform, 4, sp[0]->s_vec, sp[1]->s_vec, x, sp[0]->s_n); +} + +static void fade_tilde_maketable(void) +{ + int i; + t_float *fp, phase, fff,phsinc = 0.5*3.141592653 / ((t_float)COSTABSIZE*0.99999); + union tabfudge tf; + + if(!iem_fade_tilde_table_sin) + { + iem_fade_tilde_table_sin = (t_float *)getbytes(sizeof(t_float) * (COSTABSIZE+1)); + for(i=COSTABSIZE+1, fp=iem_fade_tilde_table_sin, phase=0; i--; fp++, phase+=phsinc) + *fp = sin(phase); + } + if(!iem_fade_tilde_table_sinhann) + { + iem_fade_tilde_table_sinhann = (t_float *)getbytes(sizeof(t_float) * (COSTABSIZE+1)); + for(i=COSTABSIZE+1, fp=iem_fade_tilde_table_sinhann, phase=0; i--; fp++, phase+=phsinc) + { + fff = sin(phase); + *fp = fff*sqrt(fff); + } + } + if(!iem_fade_tilde_table_hann) + { + iem_fade_tilde_table_hann = (t_float *)getbytes(sizeof(t_float) * (COSTABSIZE+1)); + for(i=COSTABSIZE+1, fp=iem_fade_tilde_table_hann, phase=0; i--; fp++, phase+=phsinc) + { + fff = sin(phase); + *fp = fff*fff; + } + } + phsinc = 1.0 / ((t_float)COSTABSIZE*0.99999); + if(!iem_fade_tilde_table_lin) + { + iem_fade_tilde_table_lin = (t_float *)getbytes(sizeof(t_float) * (COSTABSIZE+1)); + for(i=COSTABSIZE+1, fp=iem_fade_tilde_table_lin, phase=0; i--; fp++, phase+=phsinc) + *fp = phase; + } + if(!iem_fade_tilde_table_linsqrt) + { + iem_fade_tilde_table_linsqrt = (t_float *)getbytes(sizeof(t_float) * (COSTABSIZE+1)); + for(i=COSTABSIZE+1, fp=iem_fade_tilde_table_linsqrt, phase=0; i--; fp++, phase+=phsinc) + *fp = pow(phase, 0.75); + } + if(!iem_fade_tilde_table_sqrt) + { + iem_fade_tilde_table_sqrt = (t_float *)getbytes(sizeof(t_float) * (COSTABSIZE+1)); + for(i=COSTABSIZE+1, fp=iem_fade_tilde_table_sqrt, phase=0; i--; fp++, phase+=phsinc) + *fp = sqrt(phase); + } + tf.tf_d = UNITBIT32 + 0.5; + if((unsigned)tf.tf_i[LOWOFFSET] != 0x80000000) + bug("fade~: unexpected machine alignment"); +} + +void fade_tilde_setup(void) +{ + fade_tilde_class = class_new(gensym("fade~"), (t_newmethod)fade_tilde_new, 0, + sizeof(t_fade_tilde), 0, A_DEFSYM, 0); + CLASS_MAINSIGNALIN(fade_tilde_class, t_fade_tilde, x_f); + class_addmethod(fade_tilde_class, (t_method)fade_tilde_dsp, gensym("dsp"), 0); + class_addmethod(fade_tilde_class, (t_method)fade_tilde_set, gensym("set"), A_DEFSYM, 0); +// class_sethelpsymbol(fade_tilde_class, gensym("iemhelp/help-fade~")); + fade_tilde_maketable(); +} diff --git a/iemlib2/src/float24.c b/iemlib2/src/float24.c new file mode 100644 index 0000000..2095e14 --- /dev/null +++ b/iemlib2/src/float24.c @@ -0,0 +1,81 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + +#include "m_pd.h" +#include "iemlib.h" +#include +#include +#include +#include + +/* -------------------------- float24 ----------------------- */ +/* ----------- float-object with 24 bit accuracy ------------ */ +/* -- concaternate a list of float-arguments to one string -- */ +/* ----------- and convert it to a float-number ------------- */ + +typedef struct _float24 +{ + t_object x_obj; + t_float x_arg; +} t_float24; + +static t_class *float24_class; + +static float float24_calc_sum(int argc, t_atom *argv) +{ + int i; + char str[1000], buf[100]; + + str[0] = 0; + for(i=0; ix_obj.ob_outlet, x->x_arg); +} + +static void float24_float(t_float24 *x, t_float f) +{ + x->x_arg = f; + float24_bang(x); +} + +static void float24_list(t_float24 *x, t_symbol *s, int argc, t_atom *argv) +{ + if(argc > 0) + x->x_arg = float24_calc_sum(argc, argv); + float24_bang(x); +} + +static void *float24_new(t_symbol *s, int argc, t_atom *argv) +{ + t_float24 *x = (t_float24 *)pd_new(float24_class); + + outlet_new(&x->x_obj, &s_float); + x->x_arg = 0.0f; + if(argc > 0) + x->x_arg = float24_calc_sum(argc, argv); + return (x); +} + +void float24_setup(void) +{ + float24_class = class_new(gensym("float24"), (t_newmethod)float24_new, 0, + sizeof(t_float24), 0, A_GIMME, 0); + class_addcreator((t_newmethod)float24_new, gensym("f24"), A_GIMME, 0); + class_addbang(float24_class, (t_method)float24_bang); + class_addfloat(float24_class, (t_method)float24_float); + class_addlist(float24_class, (t_method)float24_list); +// class_sethelpsymbol(float24_class, gensym("iemhelp/help-float24")); +} diff --git a/iemlib2/src/iem_anything.c b/iemlib2/src/iem_anything.c new file mode 100644 index 0000000..a6dc66b --- /dev/null +++ b/iemlib2/src/iem_anything.c @@ -0,0 +1,137 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + +#include "m_pd.h" +#include "iemlib.h" + +/* ------------------------------- iem_anything ---------------------------------- */ +/* -- storage object for any message (bang, float, symbol, list, selector-list) -- */ +/* ---------- with a hot and a cold inlet (like object float or symbol) ---------- */ +/* ----------- initial arguments are equal to a message of cold inlet ------------ */ + +struct _iem_anything_proxy; + +static t_class *iem_anything_class; +static t_class *iem_anything_proxy_class; + +typedef struct _iem_anything +{ + t_object x_obj; + struct _iem_anything_proxy *x_proxy_inlet; + int x_size; + int x_ac; + t_atom *x_at; + t_symbol *x_selector_sym; +} t_iem_anything; + +typedef struct _iem_anything_proxy +{ + t_object p_obj; + t_iem_anything *p_owner; +} t_iem_anything_proxy; + +static void iem_anything_atcopy(t_atom *src, t_atom *dst, int n) +{ + while(n--) + *dst++ = *src++; +} + +static void iem_anything_anything(t_iem_anything *x, t_symbol *s, int ac, t_atom *av) +{ + if(ac > x->x_size) + { + x->x_at = (t_atom *)resizebytes(x->x_at, x->x_size*sizeof(t_atom), (10 + ac)*sizeof(t_atom)); + x->x_size = 10 + ac; + } + x->x_ac = ac; + x->x_selector_sym = s; + iem_anything_atcopy(av, x->x_at, ac); + outlet_anything(x->x_obj.ob_outlet, s, ac, av); +} + +static void iem_anything_bang(t_iem_anything *x) +{ + if((x->x_selector_sym == &s_bang) && !x->x_ac) + { + outlet_bang(x->x_obj.ob_outlet); + } + else + { + outlet_anything(x->x_obj.ob_outlet, x->x_selector_sym, x->x_ac, x->x_at); + } +} + +/* begin of proxy methods (anything inlets) */ + +static void iem_anything_proxy_anything(t_iem_anything_proxy *p, t_symbol *s, int ac, t_atom *av) +{ + t_iem_anything *x = p->p_owner; + + if(ac > x->x_size) + { + x->x_at = (t_atom *)resizebytes(x->x_at, x->x_size*sizeof(t_atom), (10 + ac)*sizeof(t_atom)); + x->x_size = 10 + ac; + } + x->x_ac = ac; + x->x_selector_sym = s; + iem_anything_atcopy(av, x->x_at, ac); +} + +/* end of proxy methods (anything inlets) */ + +static void iem_anything_free(t_iem_anything *x) +{ + if(x->x_at) + freebytes(x->x_at, x->x_size * sizeof(t_atom)); + if(x->x_proxy_inlet) + pd_free((t_pd *)x->x_proxy_inlet); +} + +static void *iem_anything_new(t_symbol *s, int ac, t_atom *av) +{ + t_iem_anything *x = (t_iem_anything *)pd_new(iem_anything_class); + t_iem_anything_proxy *p = (t_iem_anything_proxy *)pd_new(iem_anything_proxy_class); + + x->x_proxy_inlet = p; + p->p_owner = x; + + x->x_size = 10 + ac; + x->x_at = (t_atom *)getbytes(x->x_size * sizeof(t_atom)); + x->x_ac = ac; + if(!ac) + { + x->x_selector_sym = &s_bang; + } + else if(IS_A_SYMBOL(av, 0)) + { + x->x_selector_sym = atom_getsymbol(av); + x->x_ac--; + iem_anything_proxy_anything(p, x->x_selector_sym, x->x_ac, av+1); + } + else + { + x->x_selector_sym = &s_list; + iem_anything_proxy_anything(p, x->x_selector_sym, x->x_ac, av); + } + inlet_new((t_object *)x, (t_pd *)p, 0, 0); + outlet_new(&x->x_obj, &s_list); + return (x); +} + +void iem_anything_setup(void) +{ + iem_anything_class = class_new(gensym("iem_anything"), + (t_newmethod)iem_anything_new, (t_method)iem_anything_free, + sizeof(t_iem_anything), 0, A_GIMME, 0); + class_addcreator((t_newmethod)iem_anything_new, gensym("any"), A_GIMME, 0); + + class_addanything(iem_anything_class, iem_anything_anything); + class_addbang(iem_anything_class, iem_anything_bang); +// class_sethelpsymbol(iem_anything_class, gensym("iemhelp/help-iem_anything")); + + iem_anything_proxy_class = class_new(gensym("_iem_anything_proxy"), + 0, 0, sizeof(t_iem_anything_proxy), CLASS_PD | CLASS_NOINLET, 0); + class_addanything(iem_anything_proxy_class, iem_anything_proxy_anything); +} diff --git a/iemlib2/src/iem_append.c b/iemlib2/src/iem_append.c new file mode 100644 index 0000000..af944f3 --- /dev/null +++ b/iemlib2/src/iem_append.c @@ -0,0 +1,355 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + +#include "m_pd.h" +#include "iemlib.h" + + +/* ----------------------- iem_append -------------------------- */ +/* -- concatenates message from hot (left) inlet with message -- */ +/* ------ from cold (right) inlet and outputs it; initial ----- */ +/* -- arguments (appendix) are eqal to message of cold inlet --- */ + + +struct _iem_append_proxy; + +static t_class *iem_append_class; +static t_class *iem_append_proxy_class; + +typedef struct _iem_append +{ + t_object x_obj; + struct _iem_append_proxy *x_proxy_inlet; + int x_size12; + int x_size2; + int x_ac1; + int x_ac2; + t_atom *x_at12; + t_atom *x_at2; + t_symbol *x_selector_sym1; + t_symbol *x_selector_sym2; + t_atomtype x_type1; + t_atomtype x_type2; +} t_iem_append; + +typedef struct _iem_append_proxy +{ + t_object p_obj; + t_iem_append *p_owner; +} t_iem_append_proxy; + +static void iem_append_atcopy(t_atom *src, t_atom *dst, int n) +{ + while(n--) + *dst++ = *src++; +} + +static void iem_append_merge(t_iem_append *x, int off) +{ + if((x->x_ac1+x->x_ac2+1) > x->x_size12) + { + x->x_at12 = (t_atom *)resizebytes(x->x_at12, x->x_size12*sizeof(t_atom), 2*(x->x_ac1+x->x_ac2+1)*sizeof(t_atom)); + x->x_size12 = 2*(x->x_ac1+x->x_ac2+1); + } + if(off) + SETSYMBOL(x->x_at12 + x->x_ac1, x->x_selector_sym2); + iem_append_atcopy(x->x_at2, x->x_at12 + x->x_ac1 + off, x->x_ac2); +} + +static void iem_append_out(t_iem_append *x) +{ + int off=0; + + if(x->x_type1 == A_GIMME) + { + if(x->x_type2 == A_COMMA) + off = 1; + else + off = 0; + iem_append_merge(x, off); + outlet_list(x->x_obj.ob_outlet, &s_list, x->x_ac1+x->x_ac2+off, x->x_at12); + } + else if(x->x_type1 == A_COMMA) + { + if(x->x_type2 == A_COMMA) + off = 1; + else + off = 0; + iem_append_merge(x, off); + outlet_anything(x->x_obj.ob_outlet, x->x_selector_sym1, x->x_ac1+x->x_ac2+off, x->x_at12); + } + else if(x->x_type1 == A_NULL)/*depends on 2.part*/ + { + iem_append_merge(x, 0); + if(x->x_type2 == A_GIMME) + outlet_list(x->x_obj.ob_outlet, &s_list, x->x_ac2, x->x_at12); + else if(x->x_type2 == A_COMMA) + outlet_anything(x->x_obj.ob_outlet, x->x_selector_sym2, x->x_ac2, x->x_at12); + else if(x->x_type2 == A_FLOAT) + outlet_float(x->x_obj.ob_outlet, atom_getfloat(x->x_at12)); + else if(x->x_type2 == A_SYMBOL) + outlet_symbol(x->x_obj.ob_outlet, atom_getsymbol(x->x_at12)); + else if(x->x_type2 == A_NULL) + outlet_bang(x->x_obj.ob_outlet); + else if(x->x_type2 == A_POINTER) + outlet_pointer(x->x_obj.ob_outlet, (t_gpointer *)x->x_at12->a_w.w_gpointer); + } + else + { + if(x->x_type2 == A_COMMA) + off = 1; + else + off = 0; + iem_append_merge(x, off); + if(x->x_type2 == A_NULL) + { + if(x->x_type1 == A_FLOAT) + outlet_float(x->x_obj.ob_outlet, atom_getfloat(x->x_at12)); + else if(x->x_type1 == A_SYMBOL) + outlet_symbol(x->x_obj.ob_outlet, atom_getsymbol(x->x_at12)); + else if(x->x_type1 == A_POINTER) + outlet_pointer(x->x_obj.ob_outlet, (t_gpointer *)x->x_at12->a_w.w_gpointer); + } + else + outlet_list(x->x_obj.ob_outlet, &s_list, x->x_ac1+x->x_ac2+off, x->x_at12); + } +} + +static void iem_append_bang(t_iem_append *x) +{ + x->x_ac1 = 0; + x->x_type1 = A_NULL; + iem_append_out(x); +} + +static void iem_append_float(t_iem_append *x, t_float f) +{ + x->x_ac1 = 1; + x->x_type1 = A_FLOAT; + SETFLOAT(x->x_at12, f); + iem_append_out(x); +} + +static void iem_append_symbol(t_iem_append *x, t_symbol *s) +{ + x->x_ac1 = 1; + x->x_type1 = A_SYMBOL; + SETSYMBOL(x->x_at12, s); + iem_append_out(x); +} + +static void iem_append_pointer(t_iem_append *x, t_gpointer *gp) +{ + x->x_ac1 = 1; + x->x_type1 = A_POINTER; + SETPOINTER(x->x_at12, gp); + iem_append_out(x); +} + +static void iem_append_list(t_iem_append *x, t_symbol *s, int ac, t_atom *av) +{ + if((x->x_size2+ac+1) > x->x_size12) + { + x->x_at12 = (t_atom *)resizebytes(x->x_at12, x->x_size12*sizeof(t_atom), (x->x_size2+ac+11)*sizeof(t_atom)); + x->x_size12 = x->x_size2+ac+11; + } + x->x_ac1 = ac; + x->x_type1 = A_GIMME; + iem_append_atcopy(av, x->x_at12, ac); + x->x_selector_sym1 = &s_list; + iem_append_out(x); +} + +static void iem_append_anything(t_iem_append *x, t_symbol *s, int ac, t_atom *av) +{ + if((x->x_size2+ac+2) > x->x_size12) + { + x->x_at12 = (t_atom *)resizebytes(x->x_at12, x->x_size12*sizeof(t_atom), (x->x_size2+ac+12)*sizeof(t_atom)); + x->x_size12 = x->x_size2+ac+12; + } + x->x_ac1 = ac; + x->x_type1 = A_COMMA; + iem_append_atcopy(av, x->x_at12, ac); + x->x_selector_sym1 = s; + iem_append_out(x); +} + +/* begin of proxy methods (anything inlets) */ + +static void iem_append_proxy_bang(t_iem_append_proxy *p) +{ + t_iem_append *x = p->p_owner; + + x->x_ac2 = 0; + x->x_type2 = A_NULL; + x->x_selector_sym2 = &s_list; +} + +static void iem_append_proxy_float(t_iem_append_proxy *p, t_float f) +{ + t_iem_append *x = p->p_owner; + + x->x_ac2 = 1; + x->x_type2 = A_FLOAT; + SETFLOAT(x->x_at2, f); + x->x_selector_sym2 = &s_list; +} + +static void iem_append_proxy_symbol(t_iem_append_proxy *p, t_symbol *s) +{ + t_iem_append *x = p->p_owner; + + x->x_ac2 = 1; + x->x_type2 = A_SYMBOL; + SETSYMBOL(x->x_at2, s); + x->x_selector_sym2 = &s_list; +} + +static void iem_append_proxy_pointer(t_iem_append_proxy *p, t_gpointer *gp) +{ + t_iem_append *x = p->p_owner; + + x->x_ac2 = 1; + x->x_type2 = A_POINTER; + SETPOINTER(x->x_at2, gp); + x->x_selector_sym2 = &s_list; +} + +static void iem_append_proxy_list(t_iem_append_proxy *p, t_symbol *s, int ac, t_atom *av) +{ + t_iem_append *x = p->p_owner; + + if(ac > x->x_size2) + { + x->x_at2 = (t_atom *)resizebytes(x->x_at2, x->x_size2*sizeof(t_atom), (ac+10)*sizeof(t_atom)); + x->x_size2 = (ac+10); + } + x->x_ac2 = ac; + x->x_type2 = A_GIMME; + x->x_selector_sym2 = &s_list; + iem_append_atcopy(av, x->x_at2, ac); +} + +static void iem_append_proxy_anything(t_iem_append_proxy *p, t_symbol *s, int ac, t_atom *av) +{ + t_iem_append *x = p->p_owner; + + if((ac+1) > x->x_size2) + { + x->x_at2 = (t_atom *)resizebytes(x->x_at2, x->x_size2*sizeof(t_atom), (ac+11)*sizeof(t_atom)); + x->x_size2 = ac+11; + } + x->x_ac2 = ac; + x->x_type2 = A_COMMA; + x->x_selector_sym2 = s; + iem_append_atcopy(av, x->x_at2, ac); +} + +/* end of proxy methods (anything inlets) */ + +static void iem_append_free(t_iem_append *x) +{ + if(x->x_at12) + freebytes(x->x_at12, x->x_size12 * sizeof(t_atom)); + if(x->x_at2) + freebytes(x->x_at2, x->x_size2 * sizeof(t_atom)); + if(x->x_proxy_inlet) + pd_free((t_pd *)x->x_proxy_inlet); +} + +static void *iem_append_new(t_symbol *s, int ac, t_atom *av) +{ + t_iem_append *x = (t_iem_append *)pd_new(iem_append_class); + t_iem_append_proxy *p = (t_iem_append_proxy *)pd_new(iem_append_proxy_class); + + x->x_proxy_inlet = p; + p->p_owner = x; + + x->x_type1 = A_NULL; + x->x_selector_sym1 = &s_list; + x->x_size2 = 10; + if(ac > 5) + x->x_size2 = 2*ac; + x->x_at2 = (t_atom *)getbytes(x->x_size2 * sizeof(t_atom)); + x->x_size12 = x->x_size2 + 10; + x->x_at12 = (t_atom *)getbytes(x->x_size12 * sizeof(t_atom)); + x->x_ac1 = 0; + + if(ac <= 0) + { + x->x_type2 = A_NULL; + x->x_ac2 = 0; + x->x_selector_sym2 = &s_list; + } + else + { + if(IS_A_FLOAT(av, 0)) + { + if(ac == 1) + iem_append_proxy_float(p, atom_getfloat(av)); + else + iem_append_proxy_list(p, &s_list, ac, av); + } + else if(IS_A_SYMBOL(av, 0)) + { + t_symbol *xsym=atom_getsymbol(av); + + if(xsym == &s_symbol) + { + if(ac > 1) + iem_append_proxy_symbol(p, atom_getsymbol(av+1)); + else + iem_append_proxy_symbol(p, gensym("")); + } + else if(xsym == &s_float) + { + if(ac > 1) + { + if(IS_A_FLOAT(av, 1)) + iem_append_proxy_float(p, atom_getfloat(av+1)); + else + iem_append_proxy_float(p, 0.0f); + } + else + iem_append_proxy_float(p, 0.0f); + } + else if(xsym == &s_list) + { + iem_append_proxy_list(p, &s_list, ac-1, av+1); + } + else + { + iem_append_proxy_anything(p, xsym, ac-1, av+1); + } + } + } + inlet_new((t_object *)x, (t_pd *)p, 0, 0); + outlet_new(&x->x_obj, &s_list); + return (x); +} + +void iem_append_setup(void) +{ + iem_append_class = class_new(gensym("iem_append"), + (t_newmethod)iem_append_new, (t_method)iem_append_free, + sizeof(t_iem_append), 0, A_GIMME, 0); + class_addcreator((t_newmethod)iem_append_new, gensym("merge_any"), A_GIMME, 0); + class_addbang(iem_append_class, (t_method)iem_append_bang); + class_addpointer(iem_append_class, iem_append_pointer); + class_addfloat(iem_append_class, (t_method)iem_append_float); + class_addsymbol(iem_append_class, iem_append_symbol); + class_addlist(iem_append_class, iem_append_list); + class_addanything(iem_append_class, iem_append_anything); +// class_sethelpsymbol(iem_append_class, gensym("iemhelp/help-iem_append")); + + iem_append_proxy_class = class_new(gensym("_iem_append_proxy"), + 0, 0, sizeof(t_iem_append_proxy), CLASS_PD | CLASS_NOINLET, 0); + class_addbang(iem_append_proxy_class, (t_method)iem_append_proxy_bang); + class_addpointer(iem_append_proxy_class, iem_append_proxy_pointer); + class_addfloat(iem_append_proxy_class, (t_method)iem_append_proxy_float); + class_addsymbol(iem_append_proxy_class, iem_append_proxy_symbol); + class_addlist(iem_append_proxy_class, iem_append_proxy_list); + class_addanything(iem_append_proxy_class, iem_append_proxy_anything); +} diff --git a/iemlib2/src/iem_blocksize~.c b/iemlib2/src/iem_blocksize~.c new file mode 100644 index 0000000..81637f0 --- /dev/null +++ b/iemlib2/src/iem_blocksize~.c @@ -0,0 +1,55 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" + +/* ------------------- iem_blocksize~ -------------------- */ +/* -- outputs the current signal-blocksize of a window --- */ + +static t_class *iem_blocksize_tilde_class; + +typedef struct _iem_blocksize_tilde +{ + t_object x_obj; + t_float x_blocksize; + t_clock *x_clock; + t_float x_f; +} t_iem_blocksize_tilde; + +static void iem_blocksize_tilde_out(t_iem_blocksize_tilde *x) +{ + outlet_float(x->x_obj.ob_outlet, x->x_blocksize); +} + +static void iem_blocksize_tilde_free(t_iem_blocksize_tilde *x) +{ + clock_free(x->x_clock); +} + +static void *iem_blocksize_tilde_new(t_symbol *s) +{ + t_iem_blocksize_tilde *x = (t_iem_blocksize_tilde *)pd_new(iem_blocksize_tilde_class); + x->x_clock = clock_new(x, (t_method)iem_blocksize_tilde_out); + outlet_new(&x->x_obj, &s_float); + x->x_blocksize = 64.0f; + x->x_f = 0.0f; + return (x); +} + +static void iem_blocksize_tilde_dsp(t_iem_blocksize_tilde *x, t_signal **sp) +{ + x->x_blocksize = (t_float)(sp[0]->s_n); + clock_delay(x->x_clock, 0.0f); +} + +void iem_blocksize_tilde_setup(void) +{ + iem_blocksize_tilde_class = class_new(gensym("iem_blocksize~"), (t_newmethod)iem_blocksize_tilde_new, + (t_method)iem_blocksize_tilde_free, sizeof(t_iem_blocksize_tilde), 0, 0); + CLASS_MAINSIGNALIN(iem_blocksize_tilde_class, t_iem_blocksize_tilde, x_f); + class_addmethod(iem_blocksize_tilde_class, (t_method)iem_blocksize_tilde_dsp, gensym("dsp"), 0); +} diff --git a/iemlib2/src/iem_i_route.c b/iemlib2/src/iem_i_route.c new file mode 100644 index 0000000..ca4ed71 --- /dev/null +++ b/iemlib2/src/iem_i_route.c @@ -0,0 +1,105 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" + + +/* -------------------------- iem_i_route ------------------------------ */ +/* ---- routes a list beginning with a float to an outlet, which is ---- */ +/* -- defined by the 3 initial arguments first index, last index and --- */ +/* ---------------------- offset index --------------------------------- */ + +static t_class *iem_i_route_class; + +typedef struct _iem_i_route +{ + t_object x_obj; + int x_first_element; + int x_last_element; + t_outlet **x_out; +} t_iem_i_route; + +static void iem_i_route_list(t_iem_i_route *x, t_symbol *sel, int argc, t_atom *argv) +{ + t_outlet **out; + int first, last, i; + + if(!argc) + return; + i = (int)atom_getintarg(0, argc, argv); + first = x->x_first_element; + last = x->x_last_element; + out = x->x_out; + if((i >= first)&&(i <= last)) + { + out += i - first; + if(argc >= 3) + { + if(IS_A_FLOAT(argv,1)) + outlet_list(*out, &s_list, argc-1, argv+1); + else if(IS_A_SYMBOL(argv,1)) + outlet_anything(*out, atom_getsymbolarg(1, argc, argv), argc-2, argv+2); + } + else if(argc >= 2) + { + if(IS_A_FLOAT(argv,1)) + outlet_float(*out, (float)atom_getfloatarg(1, argc, argv)); + else if(IS_A_SYMBOL(argv,1)) + outlet_anything(*out, atom_getsymbolarg(1, argc, argv), 0, argv+2); + } + else + outlet_bang(*out); + } + else + { + out += last - first + 1; + outlet_list(*out, &s_list, argc, argv); + } +} + +static void iem_i_route_free(t_iem_i_route *x) +{ + freebytes(x->x_out, (x->x_last_element-x->x_first_element+2) * sizeof(t_outlet *)); +} + +static void *iem_i_route_new(t_symbol *s, int argc, t_atom *argv) +{ + int n, i; + t_outlet **out; + t_iem_i_route *x = (t_iem_i_route *)pd_new(iem_i_route_class); + + if((argc >= 2)&&IS_A_FLOAT(argv,0)&&IS_A_FLOAT(argv,1)) + { + x->x_first_element = (int)atom_getintarg(0, argc, argv); + x->x_last_element = (int)atom_getintarg(1, argc, argv); + if((argc >= 3)&&IS_A_FLOAT(argv,2)) + { + i = (int)atom_getintarg(2, argc, argv); + x->x_first_element += i; + x->x_last_element += i; + } + x->x_out = (t_outlet **)getbytes((x->x_last_element-x->x_first_element+2) * sizeof(t_outlet *)); + n = x->x_last_element - x->x_first_element + 2; + for(i=0, out=x->x_out; ix_obj, &s_list); + return (x); + } + else + { + post("iem_i_route-ERROR: needs 3 floats!!"); + return(0); + } +} + +void iem_i_route_setup(void) +{ + iem_i_route_class = class_new(gensym("iem_i_route"), (t_newmethod)iem_i_route_new, + (t_method)iem_i_route_free, sizeof(t_iem_i_route), 0, A_GIMME, 0); + class_addcreator((t_newmethod)iem_i_route_new, gensym("iiroute"), A_GIMME, 0); + class_addlist(iem_i_route_class, iem_i_route_list); +// class_sethelpsymbol(iem_i_route_class, gensym("iemhelp/help-iem_i_route")); +} diff --git a/iemlib2/src/iem_pbank_csv.c b/iemlib2/src/iem_pbank_csv.c new file mode 100644 index 0000000..d5f834a --- /dev/null +++ b/iemlib2/src/iem_pbank_csv.c @@ -0,0 +1,798 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" +#include +#include +#include +#include + + +/* ---------------------------- iem_pbank_csv ------------------------------- */ +/* -- is a list storage and management object, can store an array of lists -- */ +/* ------------------------------- as an csv file --------------------------- */ + +/* read and write method needs 2 symbols, +1. symbol is a filename, +2. symbol is a 3 character descriptor + + 1.char: 'b'...for blank as ITEM_SEPARATOR (" ") + 1.char: 'c'...for comma as ITEM_SEPARATOR (",") + 1.char: 's'...for semicolon as ITEM_SEPARATOR (";") + 1.char: 't'...for tabulator as ITEM_SEPARATOR (" " = 0x09) + + 2.char: 'b'...for blank,return as END_OF_LINE (" \n") + 2.char: 'r'...for return-only as END_OF_LINE ("\n") + 2.char: 's'...for semicolon,return as END_OF_LINE (";\n") + + 3.char: 'l'...for linux RETURN (0x0A) + 3.char: 'w'...for windows RETURN (0x0D,0x0A) + 3.char: 'm'...for mac RETURN (0x0D) + + + + change: recall + offset + number +*/ + +static t_class *iem_pbank_csv_class; + +typedef struct _iem_pbank_csv +{ + t_object x_obj; + int x_nr_para; + int x_nr_line; + int x_line; + t_atom *x_atbegmem; + t_atom *x_atbegbuf; + t_atom *x_atbegout; + t_canvas *x_canvas; + void *x_list_out; + void *x_offset_list_out; +} t_iem_pbank_csv; + +static void iem_pbank_csv_write(t_iem_pbank_csv *x, t_symbol *filename, t_symbol *format) +{ + char completefilename[400], eol[4], sep, mode[4], string[200]; + int size, p, l, nrl=x->x_nr_line, nrp=x->x_nr_para; + int state, max=nrl*nrp, org_size, eollen; + FILE *fh; + t_atom *ap=x->x_atbegmem; + char formattext[100]; + + strcpy(mode, "bsl"); /*blank-separator, semicolon-return-eol, linux_return*/ + sep = ' '; + eol[0] = ';'; + eol[1] = 0x0a; + eol[2] = 0; + if(filename->s_name[0] == '/') + { + strcpy(completefilename, filename->s_name); + } + else if(((filename->s_name[0] >= 'A')&&(filename->s_name[0] <= 'Z')|| + (filename->s_name[0] >= 'a')&&(filename->s_name[0] <= 'z'))&& + (filename->s_name[1] == ':')&&(filename->s_name[2] == '/')) + { + strcpy(completefilename, filename->s_name); + } + else + { + strcpy(completefilename, canvas_getdir(x->x_canvas)->s_name); + strcat(completefilename, "/"); + strcat(completefilename, filename->s_name); + } + + fh = fopen(completefilename,"wb"); + if(!fh) + { + post("iem_pbank_csv_write: cannot create %s !!\n", completefilename); + } + else + { + if(strlen(format->s_name) >= 3) + { + for(p=0; p<3; p++) + { + if((format->s_name[p] >= 'A')&&(format->s_name[p] <= 'Z')) + format->s_name[p] += 'a' - 'A'; + } + if((format->s_name[0] == 'b')||(format->s_name[0] == 'c')||(format->s_name[0] == 's')||(format->s_name[0] == 't')) + mode[0] = format->s_name[0]; + if((format->s_name[1] == 'b')||(format->s_name[1] == 'r')||(format->s_name[1] == 's')) + mode[1] = format->s_name[1]; + if((format->s_name[2] == 'l')||(format->s_name[2] == 'w')||(format->s_name[2] == 'm')) + mode[2] = format->s_name[2]; + } + else + post("iem_pbank_csv_write: use default format %s !!\n", mode); + + if(mode[0] == 'b') + { + sep = ' '; + strcpy(formattext, "item-separator = BLANK; "); + } + else if(mode[0] == 'c') + { + sep = ','; + strcpy(formattext, "item-separator = COMMA; "); + } + else if(mode[0] == 's') + { + sep = ';'; + strcpy(formattext, "item-separator = SEMICOLON; "); + } + else if(mode[0] == 't') + { + sep = 0x09; + strcpy(formattext, "item-separator = TABULATOR; "); + } + + eollen = 1; + if(mode[1] == 'b') + { + eol[0] = ' '; + strcat(formattext, "end_of_line_terminator = BLANK-RETURN in "); + } + else if(mode[1] == 'r') + { + eollen = 0; + strcat(formattext, "end_of_line_terminator = RETURN in "); + } + else if(mode[1] == 's') + { + eol[0] = ';'; + strcat(formattext, "end_of_line_terminator = SEMICOLON-RETURN in "); + } + + if(mode[2] == 'l') + { + eol[eollen++] = 0x0a; + strcat(formattext, "LINUX-Format."); + } + else if(mode[2] == 'w') + { + eol[eollen++] = 0x0d; + eol[eollen++] = 0x0a; + strcat(formattext, "WINDOWS-Format."); + } + else if(mode[2] == 'm') + { + eol[eollen++] = 0x0d; + strcat(formattext, "MACINTOSH-Format."); + } + eol[eollen] = 0; + + ap = x->x_atbegmem; + for(l=0; la_w.w_float, sep); + else if(IS_A_SYMBOL(ap, 0)) + fprintf(fh, "%s%c", ap->a_w.w_symbol->s_name, sep); + ap++; + } + if(IS_A_FLOAT(ap, 0)) + fprintf(fh, "%g%s", ap->a_w.w_float, eol); + else if(IS_A_SYMBOL(ap, 0)) + fprintf(fh, "%s%s", ap->a_w.w_symbol->s_name, eol); + ap++; + } + fclose(fh); + post("iem_pbank_csv: wrote %d parameters x %d lines to file:\n%s\nwith following format:\n%s\n", nrp, nrl, completefilename, formattext); + } +} + +int iem_pbank_csv_text2atom(char *text, int text_size, t_atom **at_beg, + int *nalloc, char sep, char eol) +{ + char buf[MAXPDSTRING+1], *bufp, *ebuf = buf+MAXPDSTRING; + const char *textp = text, *etext = text + text_size; + int natom = 0; + t_atom *ap = *at_beg; + t_float f; + + while(1) + { + int type; + + if(textp == etext) + break; + if(*textp == eol) + { + SETSEMI(ap); + textp++; + } + else if(*textp == sep) + { + SETCOMMA(ap); + textp++; + } + else + { + char c; + int flst = 0, slash = 0, lastslash = 0; + int firstslash = (*textp == '\\'); + + bufp = buf; + do + { + c = *bufp = *textp++; + lastslash = slash; + slash = (c == '\\'); + + if (flst >= 0) + { + int digit = (c >= '0' && c <= '9'), + dot = (c == '.'), minus = (c == '-'), + plusminus = (minus || (c == '+')), + expon = (c == 'e' || c == 'E'); + if (flst == 0) /* beginning */ + { + if (minus) flst = 1; + else if (digit) flst = 2; + else if (dot) flst = 3; + else flst = -1; + } + else if (flst == 1) /* got minus */ + { + if (digit) flst = 2; + else if (dot) flst = 3; + else flst = -1; + } + else if (flst == 2) /* got digits */ + { + if (dot) flst = 4; + else if (expon) flst = 6; + else if (!digit) flst = -1; + } + else if (flst == 3) /* got '.' without digits */ + { + if (digit) flst = 5; + else flst = -1; + } + else if (flst == 4) /* got '.' after digits */ + { + if (digit) flst = 5; + else if (expon) flst = 6; + else flst = -1; + } + else if (flst == 5) /* got digits after . */ + { + if (expon) flst = 6; + else if (!digit) flst = -1; + } + else if (flst == 6) /* got 'e' */ + { + if (plusminus) flst = 7; + else if (digit) flst = 8; + else flst = -1; + } + else if (flst == 7) /* got plus or minus */ + { + if (digit) flst = 8; + else flst = -1; + } + else if (flst == 8) /* got digits */ + { + if (!digit) flst = -1; + } + } + if (!slash) bufp++; + } + while (textp != etext && bufp != ebuf && *textp != ' ' && + (slash || (*textp != sep && *textp != eol))); + *bufp = 0; + + if(*buf == '$' && buf[1] >= '0' && buf[1] <= '9' && !firstslash) + { + for (bufp = buf+2; *bufp; bufp++) + if (*bufp < '0' || *bufp > '9') + { + SETDOLLSYM(ap, gensym(buf+1)); + goto iem_pbank_csv_didit; + } + SETDOLLAR(ap, atoi(buf+1)); +iem_pbank_csv_didit: ; + } + else + { + if(flst == 2 || flst == 4 || flst == 5 || flst == 8) + { + f = atof(buf); + if((f < 1.0e-20)&&(f > -1.0e-20)) + f = 0.0; + SETFLOAT(ap, f); + } + else + SETSYMBOL(ap, gensym(buf)); + } + } + + ap++; + natom++; + if(natom == *nalloc) + { + *at_beg = t_resizebytes(*at_beg, *nalloc * sizeof(t_atom), + *nalloc * (2*sizeof(t_atom))); + *nalloc = *nalloc * 2; + ap = *at_beg + natom; + } + if(textp == etext) + break; + } + return(natom); +} + +/*static char myq(t_atom *a, int off) +{ +char c='0'; + + if(IS_A_SEMI(a,off)) + c = 's'; + else if(IS_A_COMMA(a,off)) + c = 'c'; + else if(IS_A_FLOAT(a,off)) + c = 'f'; + else if(IS_A_SYMBOL(a,off)) + c = 'y'; + return(c); +} */ + +static void iem_pbank_csv_read(t_iem_pbank_csv *x, t_symbol *filename, t_symbol *format) +{ + char completefilename[400], eol[4], sep, mode[4], *txbuf1, *txbuf2, *txvec_src, *txvec_dst; + int size, p, l, i, j, nrl=x->x_nr_line, nrp=x->x_nr_para, atlen=0; + int txlen, txalloc, hat_alloc, max, eollen; + FILE *fh; + t_atom *ap, *hap, *at; + char formattext[100]; + + strcpy(mode, "bsl"); /*blank-separator, semicolon-return-eol, linux_return*/ + sep = ' '; + eol[0] = ';'; + eol[1] = 0x0a; + eol[2] = 0; + if(filename->s_name[0] == '/')/*make complete path + filename*/ + { + strcpy(completefilename, filename->s_name); + } + else if(((filename->s_name[0] >= 'A')&&(filename->s_name[0] <= 'Z')|| + (filename->s_name[0] >= 'a')&&(filename->s_name[0] <= 'z'))&& + (filename->s_name[1] == ':')&&(filename->s_name[2] == '/')) + { + strcpy(completefilename, filename->s_name); + } + else + { + strcpy(completefilename, canvas_getdir(x->x_canvas)->s_name); + strcat(completefilename, "/"); + strcat(completefilename, filename->s_name); + } + + fh = fopen(completefilename,"rb"); + if(!fh) + { + post("iem_pbank_csv_read: cannot open %s !!\n", completefilename); + } + else + { + if(strlen(format->s_name) >= 3) + { + for(p=0; p<3; p++) + { + if((format->s_name[p] >= 'A')&&(format->s_name[p] <= 'Z')) + format->s_name[p] += 'a' - 'A'; + } + if((format->s_name[0] == 'b')||(format->s_name[0] == 'c')||(format->s_name[0] == 's')||(format->s_name[0] == 't')) + mode[0] = format->s_name[0]; + if((format->s_name[1] == 'b')||(format->s_name[1] == 'r')||(format->s_name[1] == 's')) + mode[1] = format->s_name[1]; + if((format->s_name[2] == 'l')||(format->s_name[2] == 'w')||(format->s_name[2] == 'm')) + mode[2] = format->s_name[2]; + } + else + post("iem_pbank_csv_read: use default format %s !!\n", mode); + if(mode[0] == 'b') + { + sep = ' '; + strcpy(formattext, "item-separator = BLANK; "); + } + else if(mode[0] == 'c') + { + sep = ','; + strcpy(formattext, "item-separator = COMMA; "); + } + else if(mode[0] == 's') + { + sep = ';'; + strcpy(formattext, "item-separator = SEMICOLON; "); + } + else if(mode[0] == 't') + { + sep = 0x09; + strcpy(formattext, "item-separator = TABULATOR; "); + } + + eollen = 1; + if(mode[1] == 'b') + { + eol[0] = ' '; + strcat(formattext, "end_of_line_terminator = BLANK-RETURN in "); + } + else if(mode[1] == 'r') + { + eollen = 0; + strcat(formattext, "end_of_line_terminator = RETURN in "); + } + else if(mode[1] == 's') + { + eol[0] = ';'; + strcat(formattext, "end_of_line_terminator = SEMICOLON-RETURN in "); + } + + if(mode[2] == 'l') + { + eol[eollen++] = 0x0a; + strcat(formattext, "LINUX-Format."); + } + else if(mode[2] == 'w') + { + eol[eollen++] = 0x0d; + eol[eollen++] = 0x0a; + strcat(formattext, "WINDOWS-Format."); + } + else if(mode[2] == 'm') + { + eol[eollen++] = 0x0d; + strcat(formattext, "MACINTOSH-Format."); + } + eol[eollen] = 0; + + fseek(fh, 0, SEEK_END); + txalloc = ftell(fh); + fseek(fh,0,SEEK_SET); + txbuf1 = (char *)getbytes(2 * txalloc * sizeof(char)); + txbuf2 = (char *)getbytes(2 * txalloc * sizeof(char)); + fread(txbuf1, sizeof(char), txalloc, fh); + fclose(fh); + + txvec_src = txbuf1; + txvec_dst = txbuf2; + p = 0; + for(l=0; l= 20) + { + post("%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c",myq(ap,0),myq(ap,1),myq(ap,2),myq(ap,3),myq(ap,4),myq(ap,5),myq(ap,6),myq(ap,7),myq(ap,8),myq(ap,9),myq(ap,10),myq(ap,11),myq(ap,12),myq(ap,13),myq(ap,14),myq(ap,15),myq(ap,16),myq(ap,17),myq(ap,18),myq(ap,19)); + ap += 20; + i -= 20; + } */ + + at = x->x_atbegmem; + for(l=0; lx_atbegmem; + ap = hap; + nrp++; + i = 0; /* atom-counter */ + j = 0; + for(l=0; la_w.w_float); + /*post("float");*/ + p++; + i++; + at++; + } + else if(IS_A_SYMBOL(ap,0)) + { + SETSYMBOL(at, ap->a_w.w_symbol); + /*post("sym");*/ + p++; + i++; + at++; + } + else if(IS_A_SEMI(ap,0)) + { + /*post("semi");*/ + for(; px_nr_para; + t_atom *atbuf=x->x_atbegbuf, *atmem=x->x_atbegmem; + t_atom *atout=x->x_atbegout; + + if(ac >= 2) + nrp = atom_getintarg(1, ac, av); + if(ac >= 1) + beg = atom_getintarg(0, ac, av); + if(beg < 0) + beg = 0; + else if(beg >= x->x_nr_para) + beg = x->x_nr_para - 1; + if(nrp < 0) + nrp = 0; + else if((beg+nrp) > x->x_nr_para) + nrp = x->x_nr_para - beg; + atmem += x->x_nr_para * x->x_line + beg; + atbuf += beg; + SETFLOAT(atout, (t_float)beg); + atout++; + for(i=0; ix_offset_list_out, &s_list, nrp+1, x->x_atbegout); + outlet_list(x->x_list_out, &s_list, nrp, x->x_atbegout+1); +} + +static void iem_pbank_csv_bang(t_iem_pbank_csv *x) +{ + int i, nrp=x->x_nr_para; + t_atom *atbuf=x->x_atbegbuf; + t_atom *atout=x->x_atbegout; + + SETFLOAT(atout, 0.0f); + atout++; + for(i=0; ix_offset_list_out, &s_list, nrp+1, x->x_atbegout); + outlet_list(x->x_list_out, &s_list, nrp, x->x_atbegout+1); +} + +static void iem_pbank_csv_store(t_iem_pbank_csv *x, t_symbol *s, int ac, t_atom *av) +{ + int i, beg=0, nrp=x->x_nr_para; + t_atom *atbuf=x->x_atbegbuf, *atmem=x->x_atbegmem; + + if(ac >= 2) + nrp = atom_getintarg(1, ac, av); + if(ac >= 1) + beg = atom_getintarg(0, ac, av); + if(beg < 0) + beg = 0; + else if(beg >= x->x_nr_para) + beg = x->x_nr_para - 1; + if(nrp < 0) + nrp = 0; + else if((beg+nrp) > x->x_nr_para) + nrp = x->x_nr_para - beg; + atmem += x->x_nr_para * x->x_line; + atmem += beg; + atbuf += beg; + for(i=0; i= 2) + { + int para_index = atom_getintarg(0, ac, av); + + if(para_index >= 0) + { + if((para_index+ac-1) <= x->x_nr_para) + { + int i; + + for(i=1; ix_atbegbuf[para_index] = av[i]; + para_index++; + } + } + } + } +} + +static void iem_pbank_csv_ft1(t_iem_pbank_csv *x, t_floatarg fline_nr) +{ + int line = (int)fline_nr; + + if(line < 0) + line = 0; + else if(line >= x->x_nr_line) + line = x->x_nr_line - 1; + x->x_line = line; +} + +static void iem_pbank_csv_free(t_iem_pbank_csv *x) +{ + freebytes(x->x_atbegmem, x->x_nr_para * x->x_nr_line * sizeof(t_atom)); + freebytes(x->x_atbegbuf, x->x_nr_para * sizeof(t_atom)); + freebytes(x->x_atbegout, (x->x_nr_para+1) * sizeof(t_atom)); +} + +static void *iem_pbank_csv_new(t_symbol *s, int ac, t_atom *av) +{ + t_iem_pbank_csv *x = (t_iem_pbank_csv *)pd_new(iem_pbank_csv_class); + int nrpp=0, nrp=10, nrl=10, p, l, i; + t_atom *ap; + + if((ac >= 1) && IS_A_FLOAT(av,0)) + nrp = atom_getintarg(0, ac, av); + if((ac >= 2) && IS_A_FLOAT(av,1)) + nrl = atom_getintarg(1, ac, av); + if(nrp <= 0) + nrp = 10; + if(nrl <= 0) + nrl = 10; + x->x_line = 0; + x->x_nr_para = nrp; + x->x_nr_line = nrl; + x->x_atbegmem = (t_atom *)getbytes(x->x_nr_para * x->x_nr_line * sizeof(t_atom)); + x->x_atbegbuf = (t_atom *)getbytes(x->x_nr_para * sizeof(t_atom)); + x->x_atbegout = (t_atom *)getbytes((x->x_nr_para+1) * sizeof(t_atom)); + ap = x->x_atbegmem; + for(l=0; lx_atbegbuf; + for(p=0; px_list_out = outlet_new(&x->x_obj, &s_list); /*left out*/ + x->x_offset_list_out = outlet_new(&x->x_obj, &s_list); /*right out*/ + inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("ft1")); + x->x_canvas = canvas_getcurrent(); + return (x); +} + +/* ---------------- global setup function -------------------- */ + +void iem_pbank_csv_setup(void ) +{ + iem_pbank_csv_class = class_new(gensym("iem_pbank_csv"), (t_newmethod)iem_pbank_csv_new, + (t_method)iem_pbank_csv_free, sizeof(t_iem_pbank_csv), 0, A_GIMME, 0); + class_addmethod(iem_pbank_csv_class, (t_method)iem_pbank_csv_recall, gensym("recall"), A_GIMME, 0); + class_addmethod(iem_pbank_csv_class, (t_method)iem_pbank_csv_store, gensym("store"), A_GIMME, 0); + class_addmethod(iem_pbank_csv_class, (t_method)iem_pbank_csv_read, gensym("read"), A_SYMBOL, A_DEFSYM, 0); + class_addmethod(iem_pbank_csv_class, (t_method)iem_pbank_csv_write, gensym("write"), A_SYMBOL, A_DEFSYM, 0); + class_addlist(iem_pbank_csv_class, iem_pbank_csv_list); + class_addbang(iem_pbank_csv_class, iem_pbank_csv_bang); + class_addmethod(iem_pbank_csv_class, (t_method)iem_pbank_csv_ft1, gensym("ft1"), A_FLOAT, 0); +// class_sethelpsymbol(iem_pbank_csv_class, gensym("iemhelp/help-iem_pbank_csv")); +} diff --git a/iemlib2/src/iem_prepend.c b/iemlib2/src/iem_prepend.c new file mode 100644 index 0000000..8b97b93 --- /dev/null +++ b/iemlib2/src/iem_prepend.c @@ -0,0 +1,246 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" + + +/* ----------------------- iem_prepend --------------------------- */ +/* -- concatenates message from cold (right) inlet with message -- */ +/* ------- from hot (left) inlet and outputs it; initial ------- */ +/* --- arguments (prependix) are eqal to message of cold inlet --- */ + +struct _iem_prepend_proxy; + +static t_class *iem_prepend_class; +static t_class *iem_prepend_proxy_class; + +typedef struct _iem_prepend +{ + t_object x_obj; + struct _iem_prepend_proxy *x_proxy_inlet; + int x_size; + int x_ac; + t_atom *x_at; + t_symbol *x_selector_sym; +} t_iem_prepend; + +typedef struct _iem_prepend_proxy +{ + t_object p_obj; + t_iem_prepend *p_owner; +} t_iem_prepend_proxy; + +static void iem_prepend_atcopy(t_atom *src, t_atom *dst, int n) +{ + while(n--) + *dst++ = *src++; +} + +static void iem_prepend_bang(t_iem_prepend *x) +{ + outlet_anything(x->x_obj.ob_outlet, x->x_selector_sym, x->x_ac, x->x_at); +} + +static void iem_prepend_float(t_iem_prepend *x, t_floatarg f) +{ + if(x->x_selector_sym == &s_bang) + outlet_float(x->x_obj.ob_outlet, f); + else + { + SETFLOAT(x->x_at+x->x_ac, f); + outlet_anything(x->x_obj.ob_outlet, x->x_selector_sym, x->x_ac+1, x->x_at); + } +} + +static void iem_prepend_symbol(t_iem_prepend *x, t_symbol *s) +{ + if(x->x_selector_sym == &s_bang) + outlet_symbol(x->x_obj.ob_outlet, s); + else + { + SETSYMBOL(x->x_at+x->x_ac, s); + outlet_anything(x->x_obj.ob_outlet, x->x_selector_sym, x->x_ac+1, x->x_at); + } +} + +static void iem_prepend_pointer(t_iem_prepend *x, t_gpointer *gp) +{ + if(x->x_selector_sym == &s_bang) + outlet_pointer(x->x_obj.ob_outlet, gp); + else + { + SETPOINTER(x->x_at+x->x_ac, gp); + outlet_anything(x->x_obj.ob_outlet, x->x_selector_sym, x->x_ac+1, x->x_at); + } +} + +static void iem_prepend_list(t_iem_prepend *x, t_symbol *s, int ac, t_atom *av) +{ + if((ac+x->x_ac+1) >= x->x_size) + { + x->x_at = (t_atom *)resizebytes(x->x_at, x->x_size*sizeof(t_atom), (ac+x->x_ac+11)*sizeof(t_atom)); + x->x_size = ac + x->x_ac + 11; + } + if(x->x_selector_sym == &s_bang) + outlet_anything(x->x_obj.ob_outlet, &s_list, ac, av); + else + { + iem_prepend_atcopy(av, x->x_at + x->x_ac, ac); + outlet_anything(x->x_obj.ob_outlet, x->x_selector_sym, x->x_ac+ac, x->x_at); + } +} + +static void iem_prepend_anything(t_iem_prepend *x, t_symbol *s, int ac, t_atom *av) +{ + if((ac+x->x_ac+2) >= x->x_size) + { + x->x_at = (t_atom *)resizebytes(x->x_at, x->x_size*sizeof(t_atom), (ac+x->x_ac+12)*sizeof(t_atom)); + x->x_size = ac + x->x_ac + 12; + } + if(x->x_selector_sym == &s_bang) + outlet_anything(x->x_obj.ob_outlet, s, ac, av); + else + { + SETSYMBOL(x->x_at + x->x_ac, s); + iem_prepend_atcopy(av, x->x_at+x->x_ac+1, ac); + outlet_anything(x->x_obj.ob_outlet, x->x_selector_sym, x->x_ac+ac+1, x->x_at); + } +} + +/* begin of proxy methods (anything inlets) */ + +static void iem_prepend_proxy_bang(t_iem_prepend_proxy *p) +{ + t_iem_prepend *x = p->p_owner; + + x->x_ac = 0; + x->x_selector_sym = &s_bang; +} + +static void iem_prepend_proxy_float(t_iem_prepend_proxy *p, t_floatarg f) +{ + t_iem_prepend *x = p->p_owner; + + x->x_ac = 1; + SETFLOAT(x->x_at, f); + x->x_selector_sym = &s_list; +} + +static void iem_prepend_proxy_symbol(t_iem_prepend_proxy *p, t_symbol *s) +{ + t_iem_prepend *x = p->p_owner; + + x->x_ac = 1; + SETSYMBOL(x->x_at, s); + x->x_selector_sym = &s_list; +} + +static void iem_prepend_proxy_pointer(t_iem_prepend_proxy *p, t_gpointer *gp) +{ + t_iem_prepend *x = p->p_owner; + + x->x_ac = 1; + SETPOINTER(x->x_at, gp); + x->x_selector_sym = &s_list; +} + +static void iem_prepend_proxy_list(t_iem_prepend_proxy *p, t_symbol *s, int ac, t_atom *av) +{ + t_iem_prepend *x = p->p_owner; + + if((2*ac+10) > x->x_size) + { + x->x_at = (t_atom *)resizebytes(x->x_at, x->x_size*sizeof(t_atom), (2*ac+10)*sizeof(t_atom)); + x->x_size = 2*ac+10; + } + x->x_ac = ac; + x->x_selector_sym = &s_list; + iem_prepend_atcopy(av, x->x_at, ac); +} + +static void iem_prepend_proxy_anything(t_iem_prepend_proxy *p, t_symbol *s, int ac, t_atom *av) +{ + t_iem_prepend *x = p->p_owner; + + if((2*ac+11) > x->x_size) + { + x->x_at = (t_atom *)resizebytes(x->x_at, x->x_size*sizeof(t_atom), (2*ac+11)*sizeof(t_atom)); + x->x_size = 2*ac + 11; + } + x->x_ac = ac; + x->x_selector_sym = s; + iem_prepend_atcopy(av, x->x_at, ac); +} + +/* end of proxy methods (anything inlets) */ + +static void iem_prepend_free(t_iem_prepend *x) +{ + if(x->x_at) + freebytes(x->x_at, x->x_size * sizeof(t_atom)); + if(x->x_proxy_inlet) + pd_free((t_pd *)x->x_proxy_inlet); +} + +static void *iem_prepend_new(t_symbol *s, int ac, t_atom *av) +{ + t_iem_prepend *x = (t_iem_prepend *)pd_new(iem_prepend_class); + t_iem_prepend_proxy *p = (t_iem_prepend_proxy *)pd_new(iem_prepend_proxy_class); + + x->x_proxy_inlet = p; + p->p_owner = x; + + x->x_size = 30; + if(ac > 10) + x->x_size = 2*ac + 10; + x->x_at = (t_atom *)getbytes(x->x_size * sizeof(t_atom)); + if(!ac) + { + x->x_ac = 0; + x->x_selector_sym = &s_bang; + } + else + { + if(IS_A_FLOAT(av, 0)) + { + iem_prepend_proxy_list(p, &s_list, ac, av); + } + else if(IS_A_SYMBOL(av, 0)) + { + iem_prepend_proxy_anything(p, atom_getsymbol(av), ac-1, av+1); + } + } + inlet_new((t_object *)x, (t_pd *)p, 0, 0); + outlet_new(&x->x_obj, &s_list); + return (x); +} + +void iem_prepend_setup(void) +{ + iem_prepend_class = class_new(gensym("iem_prepend"), + (t_newmethod)iem_prepend_new, (t_method)iem_prepend_free, + sizeof(t_iem_prepend), 0, A_GIMME, 0); + class_addcreator((t_newmethod)iem_prepend_new, gensym("pp"), A_GIMME, 0); + class_addcreator((t_newmethod)iem_prepend_new, gensym("prepend"), A_GIMME, 0); + + class_addbang(iem_prepend_class, (t_method)iem_prepend_bang); + class_addpointer(iem_prepend_class, iem_prepend_pointer); + class_addfloat(iem_prepend_class, (t_method)iem_prepend_float); + class_addsymbol(iem_prepend_class, iem_prepend_symbol); + class_addlist(iem_prepend_class, iem_prepend_list); + class_addanything(iem_prepend_class, iem_prepend_anything); +// class_sethelpsymbol(iem_prepend_class, gensym("iemhelp/help-iem_prepend")); + + iem_prepend_proxy_class = class_new(gensym("_iem_prepend_proxy"), + 0, 0, sizeof(t_iem_prepend_proxy), CLASS_PD | CLASS_NOINLET, 0); + class_addbang(iem_prepend_proxy_class, (t_method)iem_prepend_proxy_bang); + class_addpointer(iem_prepend_proxy_class, iem_prepend_proxy_pointer); + class_addfloat(iem_prepend_proxy_class, (t_method)iem_prepend_proxy_float); + class_addsymbol(iem_prepend_proxy_class, iem_prepend_proxy_symbol); + class_addlist(iem_prepend_proxy_class, iem_prepend_proxy_list); + class_addanything(iem_prepend_proxy_class, iem_prepend_proxy_anything); +} diff --git a/iemlib2/src/iem_receive.c b/iemlib2/src/iem_receive.c new file mode 100644 index 0000000..b69de6d --- /dev/null +++ b/iemlib2/src/iem_receive.c @@ -0,0 +1,175 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" +#include +#include +#include + +/* ------------------------ iem_receive ---------------------------- */ +/* -------- like millers r, but with setable receive label --------- */ + +struct _iem_receive_proxy; + +static t_class *iem_receive_class; +static t_class *iem_receive_proxy_class; + +typedef struct _iem_receive +{ + t_object x_obj; + struct _iem_receive_proxy *x_proxy_receiver; + t_symbol *x_receive_label_sym; +} t_iem_receive; + +typedef struct _iem_receive_proxy +{ + t_object p_obj; + t_iem_receive *p_owner; +} t_iem_receive_proxy; + +static void iem_receive_clear(t_iem_receive *x, t_symbol *s, int ac, t_atom *av) +{ + t_iem_receive_proxy *p=x->x_proxy_receiver; + + if(x->x_receive_label_sym) + pd_unbind(&p->p_obj.ob_pd, x->x_receive_label_sym); + x->x_receive_label_sym = 0; +} + +static void iem_receive_set(t_iem_receive *x, t_symbol *s, int ac, t_atom *av) +{ + t_iem_receive_proxy *p=x->x_proxy_receiver; + + if(ac > 0) + { + if(IS_A_SYMBOL(av,0)) + { + if(x->x_receive_label_sym) + pd_unbind(&p->p_obj.ob_pd, x->x_receive_label_sym); + x->x_receive_label_sym = atom_getsymbol(av); + pd_bind(&p->p_obj.ob_pd, x->x_receive_label_sym); + } + else if(IS_A_FLOAT(av,0)) + { + char str[32]; + + if(x->x_receive_label_sym) + pd_unbind(&p->p_obj.ob_pd, x->x_receive_label_sym); + sprintf(str, "%g", atom_getfloat(av)); + x->x_receive_label_sym = gensym(str); + pd_bind(&p->p_obj.ob_pd, x->x_receive_label_sym); + } + } +} + +/* begin of proxy methods (anything inlets) */ + +static void iem_receive_proxy_bang(t_iem_receive_proxy *p) +{ + t_iem_receive *x = p->p_owner; + + outlet_bang(x->x_obj.ob_outlet); +} + +static void iem_receive_proxy_float(t_iem_receive_proxy *p, t_floatarg f) +{ + t_iem_receive *x = p->p_owner; + + outlet_float(x->x_obj.ob_outlet, f); +} + +static void iem_receive_proxy_symbol(t_iem_receive_proxy *p, t_symbol *s) +{ + t_iem_receive *x = p->p_owner; + + outlet_symbol(x->x_obj.ob_outlet, s); +} + +static void iem_receive_proxy_pointer(t_iem_receive_proxy *p, t_gpointer *gp) +{ + t_iem_receive *x = p->p_owner; + + outlet_pointer(x->x_obj.ob_outlet, gp); +} + +static void iem_receive_proxy_list(t_iem_receive_proxy *p, t_symbol *s, int argc, t_atom *argv) +{ + t_iem_receive *x = p->p_owner; + + outlet_list(x->x_obj.ob_outlet, &s_list, argc, argv); +} + +static void iem_receive_proxy_anything(t_iem_receive_proxy *p, t_symbol *s, int argc, t_atom *argv) +{ + t_iem_receive *x = p->p_owner; + + outlet_anything(x->x_obj.ob_outlet, s, argc, argv); +} + +/* end of proxy methods (anything inlets) */ + +static void iem_receive_free(t_iem_receive *x) +{ + t_iem_receive_proxy *p=x->x_proxy_receiver; + + if(x->x_receive_label_sym) + pd_unbind(&p->p_obj.ob_pd, x->x_receive_label_sym); + if(x->x_proxy_receiver) + pd_free((t_pd *)x->x_proxy_receiver); +} + +static void *iem_receive_new(t_symbol *s, int ac, t_atom *av) +{ + t_iem_receive *x = (t_iem_receive *)pd_new(iem_receive_class); + t_iem_receive_proxy *p = (t_iem_receive_proxy *)pd_new(iem_receive_proxy_class); + + x->x_proxy_receiver = p; + p->p_owner = x; + + if(ac > 0) + { + if(IS_A_SYMBOL(av,0)) + { + x->x_receive_label_sym = atom_getsymbol(av); + pd_bind(&p->p_obj.ob_pd, x->x_receive_label_sym); + } + else if(IS_A_FLOAT(av,0)) + { + char str[100]; + + sprintf(str, "%g", atom_getfloat(av)); + x->x_receive_label_sym = gensym(str); + pd_bind(&p->p_obj.ob_pd, x->x_receive_label_sym); + } + else + x->x_receive_label_sym = 0; + } + else + x->x_receive_label_sym = 0; + + outlet_new(&x->x_obj, &s_list); + return (x); +} + +void iem_receive_setup(void) +{ + iem_receive_class = class_new(gensym("iem_receive"), (t_newmethod)iem_receive_new, + (t_method)iem_receive_free, sizeof(t_iem_receive), 0, A_GIMME, 0); + class_addcreator((t_newmethod)iem_receive_new, gensym("iem_r"), A_GIMME, 0); + class_addmethod(iem_receive_class, (t_method)iem_receive_clear, gensym("clear"), A_GIMME, 0); + class_addmethod(iem_receive_class, (t_method)iem_receive_set, gensym("set"), A_GIMME, 0); +// class_sethelpsymbol(iem_receive_class, gensym("iemhelp/help-iem_receive")); + + iem_receive_proxy_class = class_new(gensym("_iem_receive_proxy"), + 0, 0, sizeof(t_iem_receive_proxy), CLASS_PD | CLASS_NOINLET, 0); + class_addbang(iem_receive_proxy_class, iem_receive_proxy_bang); + class_addfloat(iem_receive_proxy_class, iem_receive_proxy_float); + class_addsymbol(iem_receive_proxy_class, iem_receive_proxy_symbol); + class_addpointer(iem_receive_proxy_class, iem_receive_proxy_pointer); + class_addlist(iem_receive_proxy_class, iem_receive_proxy_list); + class_addanything(iem_receive_proxy_class, iem_receive_proxy_anything); +} diff --git a/iemlib2/src/iem_route.c b/iemlib2/src/iem_route.c new file mode 100644 index 0000000..2405261 --- /dev/null +++ b/iemlib2/src/iem_route.c @@ -0,0 +1,192 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" + + +/* -------------------------- iem_route ------------------------------ */ +/* -------- like millers route, but can output bangs ----------------- */ + +static t_class *iem_route_class; + +typedef struct _iem_routeelement +{ + t_word e_w; + t_outlet *e_outlet; +} t_iem_routeelement; + +typedef struct _iem_route +{ + t_object x_obj; + t_atomtype x_type; + t_int x_nelement; + t_iem_routeelement *x_vec; + t_outlet *x_rejectout; +} t_iem_route; + +static void iem_route_anything(t_iem_route *x, t_symbol *sel, int argc, t_atom *argv) +{ + t_iem_routeelement *e; + int nelement; + + if(x->x_type == A_SYMBOL) + { + for(nelement = x->x_nelement, e = x->x_vec; nelement--; e++) + { + if(e->e_w.w_symbol == sel) + { + if(!argc) + outlet_bang(e->e_outlet); + else + { + if(argc == 1) + { + if(argv[0].a_type == A_FLOAT) + outlet_float(e->e_outlet, argv[0].a_w.w_float); + else + outlet_anything(e->e_outlet, argv[0].a_w.w_symbol, 0, argv+1); + } + else + { + if(argv[0].a_type == A_SYMBOL) + outlet_anything(e->e_outlet, argv[0].a_w.w_symbol, argc-1, argv+1); + else + outlet_list(e->e_outlet, &s_list, argc, argv); + } + } + return; + } + } + } + outlet_anything(x->x_rejectout, sel, argc, argv); +} + +static void iem_route_list(t_iem_route *x, t_symbol *sel, int argc, t_atom *argv) +{ + t_iem_routeelement *e; + int nelement; + + if (x->x_type == A_FLOAT) + { + t_float f; + + if(!argc) + return; + f = atom_getfloat(argv); + for(nelement = x->x_nelement, e = x->x_vec; nelement--; e++) + { + if(e->e_w.w_float == f) + { + if(argc > 1 && argv[1].a_type == A_SYMBOL) + outlet_anything(e->e_outlet, argv[1].a_w.w_symbol, argc-2, argv+2); + else + { + if(argc == 1) + outlet_bang(e->e_outlet); + else if(argc == 2) + outlet_float(e->e_outlet, atom_getfloat(argv+1)); + else + outlet_list(e->e_outlet, &s_list, argc-1, argv+1); + } + return; + } + } + } + else /* symbol arguments */ + { + if(argc > 1) /* 2 or more args: treat as "list" */ + { + for(nelement = x->x_nelement, e = x->x_vec; nelement--; e++) + { + if(e->e_w.w_symbol == &s_list) + { + if(argv[0].a_type == A_SYMBOL) + outlet_anything(e->e_outlet, argv[0].a_w.w_symbol, argc-1, argv+1); + else + outlet_list(e->e_outlet, &s_list, argc, argv); + return; + } + } + } + else if(argc == 0) /* no args: treat as "bang" */ + { + for (nelement = x->x_nelement, e = x->x_vec; nelement--; e++) + { + if (e->e_w.w_symbol == &s_bang) + { + outlet_bang(e->e_outlet); + return; + } + } + } + else if (argv[0].a_type == A_FLOAT) /* one float arg */ + { + for (nelement = x->x_nelement, e = x->x_vec; nelement--; e++) + { + if (e->e_w.w_symbol == &s_float) + { + outlet_float(e->e_outlet, argv[0].a_w.w_float); + return; + } + } + } + else + { + for (nelement = x->x_nelement, e = x->x_vec; nelement--; e++) + { + if (e->e_w.w_symbol == &s_symbol) + { + outlet_symbol(e->e_outlet, argv[0].a_w.w_symbol); + return; + } + } + } + } + outlet_list(x->x_rejectout, &s_list, argc, argv); +} + + +static void iem_route_free(t_iem_route *x) +{ + freebytes(x->x_vec, x->x_nelement * sizeof(*x->x_vec)); +} + +static void *iem_route_new(t_symbol *s, int argc, t_atom *argv) +{ + int n; + t_iem_routeelement *e; + t_iem_route *x = (t_iem_route *)pd_new(iem_route_class); + t_atom a; + if (argc == 0) + { + argc = 1; + SETFLOAT(&a, 0); + argv = &a; + } + x->x_type = argv[0].a_type; + x->x_nelement = argc; + x->x_vec = (t_iem_routeelement *)getbytes(argc * sizeof(*x->x_vec)); + for (n = 0, e = x->x_vec; n < argc; n++, e++) + { + e->e_outlet = outlet_new(&x->x_obj, &s_list); + if (x->x_type == A_FLOAT) + e->e_w.w_float = atom_getfloatarg(n, argc, argv); + else e->e_w.w_symbol = atom_getsymbolarg(n, argc, argv); + } + x->x_rejectout = outlet_new(&x->x_obj, &s_list); + return (x); +} + +void iem_route_setup(void) +{ + iem_route_class = class_new(gensym("iem_route"), (t_newmethod)iem_route_new, + (t_method)iem_route_free, sizeof(t_iem_route), 0, A_GIMME, 0); + class_addcreator((t_newmethod)iem_route_new, gensym("ir"), A_GIMME, 0); + class_addlist(iem_route_class, iem_route_list); + class_addanything(iem_route_class, iem_route_anything); +// class_sethelpsymbol(iem_route_class, gensym("iemhelp/help-iem_route")); +} diff --git a/iemlib2/src/iem_samplerate~.c b/iemlib2/src/iem_samplerate~.c new file mode 100644 index 0000000..20da902 --- /dev/null +++ b/iemlib2/src/iem_samplerate~.c @@ -0,0 +1,55 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" + +/* --------------- iem_samplerate~ ----------------- */ +/* -- outputs the current samplerate of a window --- */ + +static t_class *iem_samplerate_tilde_class; + +typedef struct _iem_samplerate_tilde +{ + t_object x_obj; + t_float x_samplerate; + t_clock *x_clock; + t_float x_f; +} t_iem_samplerate_tilde; + +static void iem_samplerate_tilde_out(t_iem_samplerate_tilde *x) +{ + outlet_float(x->x_obj.ob_outlet, x->x_samplerate); +} + +static void iem_samplerate_tilde_free(t_iem_samplerate_tilde *x) +{ + clock_free(x->x_clock); +} + +static void *iem_samplerate_tilde_new(t_symbol *s) +{ + t_iem_samplerate_tilde *x = (t_iem_samplerate_tilde *)pd_new(iem_samplerate_tilde_class); + x->x_clock = clock_new(x, (t_method)iem_samplerate_tilde_out); + outlet_new(&x->x_obj, &s_float); + x->x_samplerate = 44100.0f; + x->x_f = 0.0f; + return (x); +} + +static void iem_samplerate_tilde_dsp(t_iem_samplerate_tilde *x, t_signal **sp) +{ + x->x_samplerate = (t_float)(sp[0]->s_sr); + clock_delay(x->x_clock, 0.0f); +} + +void iem_samplerate_tilde_setup(void) +{ + iem_samplerate_tilde_class = class_new(gensym("iem_samplerate~"), (t_newmethod)iem_samplerate_tilde_new, + (t_method)iem_samplerate_tilde_free, sizeof(t_iem_samplerate_tilde), 0, 0); + CLASS_MAINSIGNALIN(iem_samplerate_tilde_class, t_iem_samplerate_tilde, x_f); + class_addmethod(iem_samplerate_tilde_class, (t_method)iem_samplerate_tilde_dsp, gensym("dsp"), 0); +} diff --git a/iemlib2/src/iem_sel_any.c b/iemlib2/src/iem_sel_any.c new file mode 100644 index 0000000..2a00b49 --- /dev/null +++ b/iemlib2/src/iem_sel_any.c @@ -0,0 +1,108 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" +#include +#include +#include +#include + +/* ------------------------ iem_sel_any ---------------------------- */ +/* -- stores an array of symbols, random access by index ----------- */ + +static t_class *iem_sel_any_class; + +typedef struct _iem_sel_any +{ + t_object x_obj; + int x_ac; + int x_max_ac; + t_symbol **x_any; + t_symbol *x_set; + void *x_out_any; + void *x_out_set_any; +} t_iem_sel_any; + + +static void iem_sel_any_float(t_iem_sel_any *x, t_floatarg f) +{ + int i = (int)f; + t_atom at; + + if(x->x_ac > 0) + { + if(i < 0) + i = 0; + if(i >= x->x_ac) + i = x->x_ac - 1; + SETSYMBOL(&at, x->x_any[i]); + outlet_anything(x->x_out_any, x->x_any[i], 0, 0); + outlet_anything(x->x_out_set_any, x->x_set, 1, &at); + } +} + +static void iem_sel_any_add(t_iem_sel_any *x, t_symbol *s, int ac, t_atom *av) +{ + if((ac >= 2) && (IS_A_FLOAT(av, 0))) + { + int i = (int)atom_getintarg(0, ac, av); + + if((i >= 0) && (i < x->x_max_ac)) + { + if(IS_A_SYMBOL(av, 1)) + x->x_any[i] = atom_getsymbolarg(1, ac, av); + else if(IS_A_FLOAT(av, 1)) + { + char str[100]; + + sprintf(str, "%g", atom_getfloatarg(1, ac, av)); + x->x_any[i] = gensym(str); + } + if(i >= x->x_ac) + x->x_ac = i+1; + } + } +} + +static void iem_sel_any_clear(t_iem_sel_any *x) +{ + x->x_ac = 0; +} + +static void iem_sel_any_free(t_iem_sel_any *x) +{ + freebytes(x->x_any, x->x_max_ac * sizeof(t_symbol *)); +} + +static void *iem_sel_any_new(t_floatarg fmax) +{ + t_iem_sel_any *x = (t_iem_sel_any *)pd_new(iem_sel_any_class); + int i; + t_symbol *default_sym=gensym("no_entry"); + + if(fmax <= 0.0) + fmax = 10.0; + x->x_max_ac = (int)fmax; + x->x_any = (t_symbol **)getbytes(x->x_max_ac * sizeof(t_symbol *)); + x->x_ac = 0; + x->x_set = gensym("set"); + for(i=0; ix_max_ac; i++) + x->x_any[i] = default_sym; + x->x_out_set_any = outlet_new(&x->x_obj, &s_list); + x->x_out_any = outlet_new(&x->x_obj, &s_list); + return (x); +} + +void iem_sel_any_setup(void) +{ + iem_sel_any_class = class_new(gensym("iem_sel_any"), (t_newmethod)iem_sel_any_new, + (t_method)iem_sel_any_free, sizeof(t_iem_sel_any), 0, A_DEFFLOAT, 0); + class_addmethod(iem_sel_any_class, (t_method)iem_sel_any_add, gensym("add"), A_GIMME, 0); + class_addmethod(iem_sel_any_class, (t_method)iem_sel_any_clear, gensym("clear"), 0); + class_addfloat(iem_sel_any_class, (t_method)iem_sel_any_float); +// class_sethelpsymbol(iem_sel_any_class, gensym("iemhelp/help-iem_sel_any")); +} diff --git a/iemlib2/src/iem_send.c b/iemlib2/src/iem_send.c new file mode 100644 index 0000000..69a91b1 --- /dev/null +++ b/iemlib2/src/iem_send.c @@ -0,0 +1,158 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" +#include +#include +#include + +/* -------------------- iem_send ------------------------------ */ +/* ------- like millers s, but with setable send label -------- */ + +struct _iem_send_proxy; + +static t_class *iem_send_class; +static t_class *iem_send_proxy_class; + +typedef struct _iem_send +{ + t_object x_obj; + struct _iem_send_proxy *x_proxy_inlet; + t_symbol *x_send_label_sym; +} t_iem_send; + +typedef struct _iem_send_proxy +{ + t_object p_obj; + t_iem_send *p_owner; +} t_iem_send_proxy; + +static void iem_send_bang(t_iem_send *x) +{ + if(x->x_send_label_sym) + if(x->x_send_label_sym->s_thing) + pd_bang(x->x_send_label_sym->s_thing); +} + +static void iem_send_float(t_iem_send *x, t_floatarg f) +{ + if(x->x_send_label_sym) + if(x->x_send_label_sym->s_thing) + pd_float(x->x_send_label_sym->s_thing, f); +} + +static void iem_send_symbol(t_iem_send *x, t_symbol *s) +{ + if(x->x_send_label_sym) + if(x->x_send_label_sym->s_thing) + pd_symbol(x->x_send_label_sym->s_thing, s); +} + +static void iem_send_pointer(t_iem_send *x, t_gpointer *gp) +{ + if(x->x_send_label_sym) + if(x->x_send_label_sym->s_thing) + pd_pointer(x->x_send_label_sym->s_thing, gp); +} + +static void iem_send_list(t_iem_send *x, t_symbol *s, int argc, t_atom *argv) +{ + if(x->x_send_label_sym) + if(x->x_send_label_sym->s_thing) + pd_list(x->x_send_label_sym->s_thing, s, argc, argv); +} + +static void iem_send_anything(t_iem_send *x, t_symbol *s, int argc, t_atom *argv) +{ + if(x->x_send_label_sym) + if(x->x_send_label_sym->s_thing) + typedmess(x->x_send_label_sym->s_thing, s, argc, argv); +} + +/* begin of proxy methods (anything inlets) */ + +static void iem_send_proxy_clear(t_iem_send_proxy *p, t_symbol *s, int ac, t_atom *av) +{ + t_iem_send *x = p->p_owner; + + x->x_send_label_sym = 0; +} + +static void iem_send_proxy_set(t_iem_send_proxy *p, t_symbol *s, int ac, t_atom *av) +{ + t_iem_send *x = p->p_owner; + + if(ac > 0) + { + if(IS_A_SYMBOL(av,0)) + x->x_send_label_sym = atom_getsymbol(av); + else if(IS_A_FLOAT(av,0)) + { + char str[32]; + + sprintf(str, "%g", atom_getfloat(av)); + x->x_send_label_sym = gensym(str); + } + } +} + +/* end of proxy methods (anything inlets) */ + +static void iem_send_free(t_iem_send *x) +{ + if(x->x_proxy_inlet) + pd_free((t_pd *)x->x_proxy_inlet); +} + +static void *iem_send_new(t_symbol *s, int ac, t_atom *av) +{ + t_iem_send *x = (t_iem_send *)pd_new(iem_send_class); + t_iem_send_proxy *p = (t_iem_send_proxy *)pd_new(iem_send_proxy_class); + + x->x_proxy_inlet = p; + p->p_owner = x; + + if(ac > 0) + { + if(IS_A_SYMBOL(av,0)) + { + x->x_send_label_sym = atom_getsymbol(av); + } + else if(IS_A_FLOAT(av,0)) + { + char str[32]; + + sprintf(str, "%g", atom_getfloat(av)); + x->x_send_label_sym = gensym(str); + } + else + x->x_send_label_sym = 0; + } + else + x->x_send_label_sym = 0; + inlet_new((t_object *)x, (t_pd *)p, 0, 0); + return (x); +} + +void iem_send_setup(void) +{ + iem_send_class = class_new(gensym("iem_send"), (t_newmethod)iem_send_new, (t_method)iem_send_free, + sizeof(t_iem_send), 0, A_GIMME, 0); + class_addcreator((t_newmethod)iem_send_new, gensym("iem_s"), A_GIMME, 0); + class_addbang(iem_send_class, iem_send_bang); + class_addfloat(iem_send_class, iem_send_float); + class_addsymbol(iem_send_class, iem_send_symbol); + class_addpointer(iem_send_class, iem_send_pointer); + class_addlist(iem_send_class, iem_send_list); + class_addanything(iem_send_class, iem_send_anything); +// class_sethelpsymbol(iem_send_class, gensym("iemhelp/help-iem_send")); + + iem_send_proxy_class = class_new(gensym("_iem_send_proxy"), + 0, 0, sizeof(t_iem_send_proxy), CLASS_PD | CLASS_NOINLET, 0); + class_addmethod(iem_send_proxy_class, (t_method)iem_send_proxy_clear, gensym("clear"), A_GIMME, 0); + class_addmethod(iem_send_proxy_class, (t_method)iem_send_proxy_set, gensym("set"), A_GIMME, 0); +} diff --git a/iemlib2/src/iemlib.h b/iemlib2/src/iemlib.h new file mode 100644 index 0000000..36d47ca --- /dev/null +++ b/iemlib2/src/iemlib.h @@ -0,0 +1,108 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + +#ifndef __IEMLIB_H__ +#define __IEMLIB_H__ + + +#define IS_A_POINTER(atom,index) ((atom+index)->a_type == A_POINTER) +#define IS_A_FLOAT(atom,index) ((atom+index)->a_type == A_FLOAT) +#define IS_A_SYMBOL(atom,index) ((atom+index)->a_type == A_SYMBOL) +#define IS_A_DOLLAR(atom,index) ((atom+index)->a_type == A_DOLLAR) +#define IS_A_DOLLSYM(atom,index) ((atom+index)->a_type == A_DOLLSYM) +#define IS_A_SEMI(atom,index) ((atom+index)->a_type == A_SEMI) +#define IS_A_COMMA(atom,index) ((atom+index)->a_type == A_COMMA) + + +#ifdef NT +int sys_noloadbang; +//t_symbol *iemgui_key_sym=0; +#include +#else +extern int sys_noloadbang; +//extern t_symbol *iemgui_key_sym; +#include +#endif + +#define DEFDELVS 64 +#define XTRASAMPS 4 +#define SAMPBLK 4 + + +#define UNITBIT32 1572864. /* 3*2^19; bit 32 has place value 1 */ + +/* machine-dependent definitions. These ifdefs really +should have been by CPU type and not by operating system! */ +#ifdef IRIX +/* big-endian. Most significant byte is at low address in memory */ +#define HIOFFSET 0 /* word offset to find MSB */ +#define LOWOFFSET 1 /* word offset to find LSB */ +#define int32 long /* a data type that has 32 bits */ +#else +#ifdef MSW +/* little-endian; most significant byte is at highest address */ +#define HIOFFSET 1 +#define LOWOFFSET 0 +#define int32 long +#else +#ifdef __FreeBSD__ +#include +#if BYTE_ORDER == LITTLE_ENDIAN +#define HIOFFSET 1 +#define LOWOFFSET 0 +#else +#define HIOFFSET 0 /* word offset to find MSB */ +#define LOWOFFSET 1 /* word offset to find LSB */ +#endif /* BYTE_ORDER */ +#include +#define int32 int32_t +#endif +#ifdef __linux__ + +#include + +#if !defined(__BYTE_ORDER) || !defined(__LITTLE_ENDIAN) +#error No byte order defined +#endif + +#if __BYTE_ORDER == __LITTLE_ENDIAN +#define HIOFFSET 1 +#define LOWOFFSET 0 +#else +#define HIOFFSET 0 /* word offset to find MSB */ +#define LOWOFFSET 1 /* word offset to find LSB */ +#endif /* __BYTE_ORDER */ + +#include +#define int32 int32_t + +#else +#ifdef __APPLE__ +#define HIOFFSET 0 /* word offset to find MSB */ +#define LOWOFFSET 1 /* word offset to find LSB */ +#define int32 int /* a data type that has 32 bits */ + +#endif /* __APPLE__ */ +#endif /* __linux__ */ +#endif /* MSW */ +#endif /* SGI */ + +union tabfudge +{ + double tf_d; + int32 tf_i[2]; +}; + +#ifdef __i386__ +#define IEM_DENORMAL(f) ((((*(unsigned int*)&(f))&0x60000000)==0) || \ +(((*(unsigned int*)&(f))&0x60000000)==0x60000000)) +/* more stringent test: anything not between 1e-19 and 1e19 in absolute val */ +#else + +#define IEM_DENORMAL(f) 0 + +#endif + +#endif diff --git a/iemlib2/src/iemlib2.c b/iemlib2/src/iemlib2.c new file mode 100644 index 0000000..e398045 --- /dev/null +++ b/iemlib2/src/iemlib2.c @@ -0,0 +1,103 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + +#include "m_pd.h" +#include "iemlib.h" + + +static t_class *iemlib2_class; + +static void *iemlib2_new(void) +{ + t_object *x = (t_object *)pd_new(iemlib2_class); + + return (x); +} + +void add2_comma_setup(void); +void bpe_setup(void); +void dollarg_setup(void); +void exp_inc_setup(void); +void fade_tilde_setup(void); +void float24_setup(void); +void iem_anything_setup(void); +void iem_append_setup(void); +void iem_blocksize_tilde_setup(void); +void iem_i_route_setup(void); +void iem_pbank_csv_setup(void); +void iem_prepend_setup(void); +void iem_receive_setup(void); +void iem_route_setup(void); +void iem_samplerate_tilde_setup(void); +void iem_sel_any_setup(void); +void iem_send_setup(void); +void init_setup(void); +void LFO_noise_tilde_setup(void); +void list2send_setup(void); +void m2f_tilde_setup(void); +void mergefilename_setup(void); +void modulo_counter_setup(void); +void parentdollarzero_setup(void); +void post_netreceive_setup(void); +void pre_inlet_setup(void); +void prepend_ascii_setup(void); +void protect_against_open_setup(void); +void receive2list_setup(void); +void round_zero_setup(void); +void speedlim_setup(void); +void splitfilename_setup(void); +void stripfilename_setup(void); +void toggle_mess_setup(void); +void transf_fader_setup(void); +void unsymbol_setup(void); +void wrap_setup(void); + +/* ------------------------ setup routine ------------------------- */ + +void iemlib2_setup(void) +{ + iemlib2_class = class_new(gensym("iemlib2"), iemlib2_new, 0, sizeof(t_object), CLASS_NOINLET, 0); + + add2_comma_setup(); + bpe_setup(); + dollarg_setup(); + exp_inc_setup(); + fade_tilde_setup(); + float24_setup(); + iem_anything_setup(); + iem_append_setup(); + iem_blocksize_tilde_setup(); + iem_i_route_setup(); + iem_pbank_csv_setup(); + iem_prepend_setup(); + iem_receive_setup(); + iem_route_setup(); + iem_samplerate_tilde_setup(); + iem_sel_any_setup(); + iem_send_setup(); + init_setup(); + LFO_noise_tilde_setup(); + list2send_setup(); + m2f_tilde_setup(); + mergefilename_setup(); + modulo_counter_setup(); + parentdollarzero_setup(); + post_netreceive_setup(); + pre_inlet_setup(); + prepend_ascii_setup(); + protect_against_open_setup(); + receive2list_setup(); + round_zero_setup(); + speedlim_setup(); + splitfilename_setup(); + stripfilename_setup(); + toggle_mess_setup(); + transf_fader_setup(); + unsymbol_setup(); + wrap_setup(); + + post("iemlib2 (R-1.17) library loaded! (c) Thomas Musil 11.2006"); + post(" musil%ciem.at iem KUG Graz Austria", '@'); +} diff --git a/iemlib2/src/iemlib2.dsp b/iemlib2/src/iemlib2.dsp new file mode 100644 index 0000000..0eee8d0 --- /dev/null +++ b/iemlib2/src/iemlib2.dsp @@ -0,0 +1,85 @@ +# Microsoft Developer Studio Project File - Name="iemlib2" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** NICHT BEARBEITEN ** + +# TARGTYPE "Win32 (x86) External Target" 0x0106 + +CFG=iemlib2 - Win32 Debug +!MESSAGE Dies ist kein gültiges Makefile. Zum Erstellen dieses Projekts mit NMAKE +!MESSAGE verwenden Sie den Befehl "Makefile exportieren" und führen Sie den Befehl +!MESSAGE +!MESSAGE NMAKE /f "iemlib2.mak". +!MESSAGE +!MESSAGE Sie können beim Ausführen von NMAKE eine Konfiguration angeben +!MESSAGE durch Definieren des Makros CFG in der Befehlszeile. Zum Beispiel: +!MESSAGE +!MESSAGE NMAKE /f "iemlib2.mak" CFG="iemlib2 - Win32 Debug" +!MESSAGE +!MESSAGE Für die Konfiguration stehen zur Auswahl: +!MESSAGE +!MESSAGE "iemlib2 - Win32 Release" (basierend auf "Win32 (x86) External Target") +!MESSAGE "iemlib2 - Win32 Debug" (basierend auf "Win32 (x86) External Target") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" + +!IF "$(CFG)" == "iemlib2 - Win32 Release" + +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Cmd_Line "NMAKE /f makefile_win" +# PROP BASE Rebuild_Opt "/a" +# PROP BASE Target_File "makefile_win.exe" +# PROP BASE Bsc_Name "makefile_win.bsc" +# PROP BASE Target_Dir "" +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "Release" +# PROP Intermediate_Dir "Release" +# PROP Cmd_Line "NMAKE /f makefile_win" +# PROP Rebuild_Opt "/a" +# PROP Target_File "iemlib2.exe" +# PROP Bsc_Name "iemlib2.bsc" +# PROP Target_Dir "" + +!ELSEIF "$(CFG)" == "iemlib2 - Win32 Debug" + +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "Debug" +# PROP BASE Intermediate_Dir "Debug" +# PROP BASE Cmd_Line "NMAKE /f makefile_win" +# PROP BASE Rebuild_Opt "/a" +# PROP BASE Target_File "makefile_win.exe" +# PROP BASE Bsc_Name "makefile_win.bsc" +# PROP BASE Target_Dir "" +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "Debug" +# PROP Intermediate_Dir "Debug" +# PROP Cmd_Line "NMAKE /f makefile_win" +# PROP Rebuild_Opt "/a" +# PROP Target_File "iemlib2.exe" +# PROP Bsc_Name "iemlib2.bsc" +# PROP Target_Dir "" + +!ENDIF + +# Begin Target + +# Name "iemlib2 - Win32 Release" +# Name "iemlib2 - Win32 Debug" + +!IF "$(CFG)" == "iemlib2 - Win32 Release" + +!ELSEIF "$(CFG)" == "iemlib2 - Win32 Debug" + +!ENDIF + +# Begin Source File + +SOURCE=.\makefile_win +# End Source File +# End Target +# End Project diff --git a/iemlib2/src/iemlib2.dsw b/iemlib2/src/iemlib2.dsw new file mode 100644 index 0000000..4cf6c56 --- /dev/null +++ b/iemlib2/src/iemlib2.dsw @@ -0,0 +1,29 @@ +Microsoft Developer Studio Workspace File, Format Version 6.00 +# WARNUNG: DIESE ARBEITSBEREICHSDATEI DARF NICHT BEARBEITET ODER GELÖSCHT WERDEN! + +############################################################################### + +Project: "iemlib2"=.\iemlib2.dsp - Package Owner=<4> + +Package=<5> +{{{ +}}} + +Package=<4> +{{{ +}}} + +############################################################################### + +Global: + +Package=<5> +{{{ +}}} + +Package=<3> +{{{ +}}} + +############################################################################### + diff --git a/iemlib2/src/init.c b/iemlib2/src/init.c new file mode 100644 index 0000000..58e66df --- /dev/null +++ b/iemlib2/src/init.c @@ -0,0 +1,196 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + +#include "m_pd.h" +#include "iemlib.h" + + +/* ------------------------ init ---------------------------- */ +/* -------- a combination of loadbang and any --------------- */ + +static t_class *init_class; + +typedef struct _init +{ + t_object x_obj; + int x_n; + int x_ac; + t_atom *x_at; + t_symbol *x_sym; + t_atomtype x_type; +} t_init; + +static void init_bang(t_init *x) +{ + if(x->x_type == A_FLOAT) + outlet_float(x->x_obj.ob_outlet, atom_getfloat(x->x_at)); + else if(x->x_type == A_SYMBOL) + outlet_symbol(x->x_obj.ob_outlet, atom_getsymbol(x->x_at)); + else if(x->x_type == A_NULL) + outlet_bang(x->x_obj.ob_outlet); + else if(x->x_type == A_COMMA) + outlet_anything(x->x_obj.ob_outlet, x->x_sym, x->x_ac, x->x_at); + else if(x->x_type == A_GIMME) + outlet_list(x->x_obj.ob_outlet, &s_list, x->x_ac, x->x_at); + else if(x->x_type == A_POINTER) + outlet_pointer(x->x_obj.ob_outlet, (t_gpointer *)x->x_at->a_w.w_gpointer); +} + +static void init_loadbang(t_init *x) +{ + if(!sys_noloadbang) + init_bang(x); +} + +static void init_float(t_init *x, t_floatarg f) +{ + x->x_ac = 1; + SETFLOAT(x->x_at, f); + x->x_sym = &s_float; + x->x_type = A_FLOAT; + outlet_float(x->x_obj.ob_outlet, f); +} + +static void init_symbol(t_init *x, t_symbol *s) +{ + x->x_ac = 1; + SETSYMBOL(x->x_at, s); + x->x_sym = &s_symbol; + x->x_type = A_SYMBOL; + outlet_symbol(x->x_obj.ob_outlet, s); +} + +static void init_pointer(t_init *x, t_gpointer *gp) +{ + x->x_ac = 1; + SETPOINTER(x->x_at, gp); + x->x_sym = &s_pointer; + x->x_type = A_POINTER; + outlet_pointer(x->x_obj.ob_outlet, gp); +} + +static void init_list(t_init *x, t_symbol *s, int ac, t_atom *av) +{ + t_atom *at; + + if(ac > x->x_n) + { + if(x->x_at) + freebytes(x->x_at, x->x_n * sizeof(t_atom)); + x->x_n = ac; + x->x_at = (t_atom *)getbytes(x->x_n * sizeof(t_atom)); + } + x->x_ac = ac; + x->x_sym = &s_list; + at = x->x_at; + while(ac--) + *at++ = *av++; + x->x_type = A_GIMME; + outlet_list(x->x_obj.ob_outlet, &s_list, x->x_ac, x->x_at); +} + +static void init_anything(t_init *x, t_symbol *s, int ac, t_atom *av) +{ + t_atom *at; + + if(ac > x->x_n) + { + if(x->x_at) + freebytes(x->x_at, x->x_n * sizeof(t_atom)); + x->x_n = ac; + x->x_at = (t_atom *)getbytes(x->x_n * sizeof(t_atom)); + } + x->x_ac = ac; + x->x_sym = s; + at = x->x_at; + while(ac--) + *at++ = *av++; + x->x_type = A_COMMA; + outlet_anything(x->x_obj.ob_outlet, x->x_sym, x->x_ac, x->x_at); +} + +static void init_free(t_init *x) +{ + if(x->x_at) + freebytes(x->x_at, x->x_n * sizeof(t_atom)); +} + +static void *init_new(t_symbol *s, int ac, t_atom *av) +{ + t_init *x = (t_init *)pd_new(init_class); + int i; + + x->x_type = A_NULL; + if(!ac) + { + x->x_type = A_NULL; + x->x_sym = &s_bang; + x->x_n = 1; + x->x_ac = 0; + x->x_at = (t_atom *)getbytes(x->x_n * sizeof(t_atom)); + } + else if(ac == 1) + { + if(IS_A_SYMBOL(av,0)) + { + x->x_type = A_COMMA; + x->x_sym = atom_getsymbol(av); + x->x_n = 1; + x->x_ac = 0; + x->x_at = (t_atom *)getbytes(x->x_n * sizeof(t_atom)); + } + else + { + if(IS_A_FLOAT(av,0)) + { + x->x_type = A_FLOAT; + x->x_sym = &s_float; + } + else if(IS_A_POINTER(av,0)) + { + x->x_type = A_POINTER; + x->x_sym = &s_pointer; + } + x->x_n = x->x_ac = 1; + x->x_at = (t_atom *)getbytes(x->x_n * sizeof(t_atom)); + x->x_at[0] = *av; + } + } + else + { + if(IS_A_SYMBOL(av,0)) + { + x->x_type = A_COMMA;/*for anything*/ + x->x_sym = atom_getsymbol(av++); + ac--; + } + else + { + x->x_type = A_GIMME; + x->x_sym = &s_list; + } + x->x_n = x->x_ac = ac; + x->x_at = (t_atom *)getbytes(x->x_n * sizeof(t_atom)); + for(i=0; ix_at[i] = *av++; + } + outlet_new(&x->x_obj, &s_list); + return (x); +} + +void init_setup(void) +{ + init_class = class_new(gensym("init"), (t_newmethod)init_new, + (t_method)init_free, sizeof(t_init), 0, A_GIMME, 0); + class_addcreator((t_newmethod)init_new, gensym("ii"), A_GIMME, 0); + class_addmethod(init_class, (t_method)init_loadbang, gensym("loadbang"), 0); + class_addbang(init_class, (t_method)init_bang); + class_addanything(init_class, init_anything); + class_addlist(init_class, init_list); + class_addpointer(init_class, init_pointer); + class_addfloat(init_class, (t_method)init_float); + class_addsymbol(init_class, init_symbol); +// class_sethelpsymbol(init_class, gensym("iemhelp/help-init")); +} diff --git a/iemlib2/src/list2send.c b/iemlib2/src/list2send.c new file mode 100644 index 0000000..09e5698 --- /dev/null +++ b/iemlib2/src/list2send.c @@ -0,0 +1,245 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" +#include +#include +#include + +/* ------------------------- list2send ----------------------------- */ +/* -- via an array of send labels, an incomming list with leading -- */ +/* -- float index will be sent to a receive object with the label -- */ +/* ------------ name of the index-th entry of the array ------------ */ + +static t_class *list2send_class; + +typedef struct _list2send +{ + t_object x_obj; + int x_max; + char *x_snd_able; + t_symbol **x_send_entries; + t_symbol *x_set; +} t_list2send; + +static void list2send_list(t_list2send *x, t_symbol *s, int ac, t_atom *av) +{ + if((ac >= 2) && (IS_A_FLOAT(av,0))) + { + int identifier_index = (int)atom_getintarg(0, ac, av); + + if(identifier_index < x->x_max) + { + if(x->x_snd_able[identifier_index]) + { + t_symbol *sender = x->x_send_entries[identifier_index]; + + if(sender->s_thing) + { + if(ac == 2) + { + if(IS_A_FLOAT(av, 1)) + pd_float(sender->s_thing, atom_getfloatarg(1, ac, av)); + else if(IS_A_SYMBOL(av, 1)) + pd_symbol(sender->s_thing, atom_getsymbolarg(1, ac, av)); + } + else + pd_list(sender->s_thing, &s_list, ac-1, av+1); + } + } + } + } +} + +static void list2send_set(t_list2send *x, t_symbol *s, int ac, t_atom *av) +{ + if((ac >= 2) && (IS_A_FLOAT(av,0))) + { + int identifier_index = (int)atom_getintarg(0, ac, av); + + if(identifier_index < x->x_max) + { + if(x->x_snd_able[identifier_index]) + { + t_symbol *sender = x->x_send_entries[identifier_index]; + + if(sender->s_thing) + typedmess(sender->s_thing, s, ac-1, av+1); + } + } + } +} + +static void list2send_all(t_list2send *x, t_symbol *s, int ac, t_atom *av) +{ + int i, n=x->x_max; + + if(ac == n) + { + for(i=n-1; i>=0; i--)/*change*/ + { + if(x->x_snd_able[i]) + { + t_symbol *sender = x->x_send_entries[i]; + + if(sender->s_thing) + { + if(IS_A_FLOAT(av, i)) + pd_float(sender->s_thing, atom_getfloatarg(i, ac, av)); + else if(IS_A_SYMBOL(av, i)) + pd_symbol(sender->s_thing, atom_getsymbolarg(i, ac, av)); + } + } + } + } +} + +static void list2send_set_all(t_list2send *x, t_symbol *s, int ac, t_atom *av) +{ + int i, n=x->x_max; + + if(ac == n) + { + for(i=n-1; i>=0; i--)/*change*/ + { + if(x->x_snd_able[i]) + { + t_symbol *sender = x->x_send_entries[i]; + + if(sender->s_thing) + typedmess(sender->s_thing, x->x_set, 1, av+i); + } + } + } +} + +static void list2send_from(t_list2send *x, t_symbol *s, int ac, t_atom *av) +{ + int n=x->x_max; + + if(ac >= 1) + { + int i, j, beg=(int)atom_getintarg(0, ac, av); + + if((beg + ac - 1) <= n) + { + for(i=ac-1,j=beg+ac-2; i>=1; i--,j--)/*change*/ + { + if(x->x_snd_able[j]) + { + t_symbol *sender = x->x_send_entries[j]; + + if(sender->s_thing) + { + if(IS_A_FLOAT(av, i)) + pd_float(sender->s_thing, atom_getfloatarg(i, ac, av)); + else if(IS_A_SYMBOL(av, i)) + pd_symbol(sender->s_thing, atom_getsymbolarg(i, ac, av)); + } + } + } + } + } +} + +static void list2send_set_from(t_list2send *x, t_symbol *s, int ac, t_atom *av) +{ + int n=x->x_max; + + if(ac >= 1) + { + int i, j, beg=(int)atom_getintarg(0, ac, av); + + if((beg + ac - 1) <= n) + { + for(i=ac-1,j=beg+ac-2; i>=1; i--,j--)/*change*/ + { + if(x->x_snd_able[j]) + { + t_symbol *sender = x->x_send_entries[j]; + + if(sender->s_thing) + typedmess(sender->s_thing, x->x_set, 1, av+i); + } + } + } + } +} + +static void list2send_add(t_list2send *x, t_symbol *s, int ac, t_atom *av) +{ + if((ac > 1) && (IS_A_FLOAT(av, 0))) + { + int identifier_index = (int)atom_getintarg(0, ac, av); + + if(identifier_index < x->x_max) + { + if(IS_A_SYMBOL(av, 1)) + { + x->x_send_entries[identifier_index] = atom_getsymbolarg(1, ac, av); + x->x_snd_able[identifier_index] = 1; + } + else if(IS_A_FLOAT(av, 1)) + { + char str[100]; + + sprintf(str, "%g", atom_getfloatarg(1, ac, av)); + x->x_send_entries[identifier_index] = gensym(str); + x->x_snd_able[identifier_index] = 1; + } + } + } +} + +static void list2send_clear(t_list2send *x) +{ + int i, n=x->x_max; + + for(i=0; ix_snd_able[i]) + x->x_snd_able[i] = 0; + } +} + +static void list2send_free(t_list2send *x) +{ + freebytes(x->x_snd_able, x->x_max * sizeof(char)); + freebytes(x->x_send_entries, x->x_max * sizeof(t_symbol *)); +} + +static void *list2send_new(t_floatarg fmax) +{ + t_list2send *x = (t_list2send *)pd_new(list2send_class); + int i, max = (int)fmax; + t_atom *ap; + + if(max <= 0) + max = 80; + x->x_max = max; + x->x_snd_able = (char *)getbytes(max * sizeof(char)); + x->x_send_entries = (t_symbol **)getbytes(max * sizeof(t_symbol *)); + for(i=0; ix_snd_able[i] = 0; + x->x_set = gensym("set"); + return (x); +} + +void list2send_setup(void) +{ + list2send_class = class_new(gensym("list2send"), (t_newmethod)list2send_new, + (t_method)list2send_free, sizeof(t_list2send), 0, A_DEFFLOAT, 0); + class_addlist(list2send_class, list2send_list); + class_addmethod(list2send_class, (t_method)list2send_add, gensym("add"), A_GIMME, 0); + class_addmethod(list2send_class, (t_method)list2send_set, gensym("set"), A_GIMME, 0); + class_addmethod(list2send_class, (t_method)list2send_all, gensym("all"), A_GIMME, 0); + class_addmethod(list2send_class, (t_method)list2send_set_all, gensym("set_all"), A_GIMME, 0); + class_addmethod(list2send_class, (t_method)list2send_from, gensym("from"), A_GIMME, 0); + class_addmethod(list2send_class, (t_method)list2send_set_from, gensym("set_from"), A_GIMME, 0); + class_addmethod(list2send_class, (t_method)list2send_clear, gensym("clear"), 0); +// class_sethelpsymbol(list2send_class, gensym("iemhelp/help-list2send")); +} diff --git a/iemlib2/src/m2f~.c b/iemlib2/src/m2f~.c new file mode 100644 index 0000000..47060e5 --- /dev/null +++ b/iemlib2/src/m2f~.c @@ -0,0 +1,119 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" +#include + +/* ----------- m2f~ ----------- */ +/* --------- obsolete --------- */ + +#define M2FTILDETABSIZE 2048 + +t_float *iem_m2f_tilde_table=(t_float *)0L; + +static t_class *m2f_tilde_class; + +typedef struct _m2f +{ + t_object x_obj; + t_float x_msi; +} t_m2f_tilde; + +static void *m2f_tilde_new(void) +{ + t_m2f_tilde *x = (t_m2f_tilde *)pd_new(m2f_tilde_class); + outlet_new(&x->x_obj, gensym("signal")); + x->x_msi = 0; + return (x); +} + +static t_int *m2f_tilde_perform(t_int *w) +{ + t_float *in = (t_float *)(w[1]); + t_float *out = (t_float *)(w[2]); + t_m2f_tilde *x = (t_m2f_tilde *)(w[3]); + int n = (int)(w[4]); + t_float *tab = iem_m2f_tilde_table, *addr, f1, f2, frac, iinn; + double dphase; + int normhipart; + union tabfudge tf; + + tf.tf_d = UNITBIT32; + normhipart = tf.tf_i[HIOFFSET]; + +#if 0 /* this is the readable version of the code. */ + while (n--) + { + iinn = (*in++)*10.0+670.0; + dphase = (double)iinn + UNITBIT32; + tf.tf_d = dphase; + addr = tab + (tf.tf_i[HIOFFSET] & (M2FTILDETABSIZE-1)); + tf.tf_i[HIOFFSET] = normhipart; + frac = tf.tf_d - UNITBIT32; + f1 = addr[0]; + f2 = addr[1]; + *out++ = f1 + frac * (f2 - f1); + } +#endif +#if 1 /* this is the same, unwrapped by hand. */ + iinn = (*in++)*10.0+670.0; + dphase = (double)iinn + UNITBIT32; + tf.tf_d = dphase; + addr = tab + (tf.tf_i[HIOFFSET] & (M2FTILDETABSIZE-1)); + tf.tf_i[HIOFFSET] = normhipart; + while (--n) + { + iinn = (*in++)*10.0+670.0; + dphase = (double)iinn + UNITBIT32; + frac = tf.tf_d - UNITBIT32; + tf.tf_d = dphase; + f1 = addr[0]; + f2 = addr[1]; + addr = tab + (tf.tf_i[HIOFFSET] & (M2FTILDETABSIZE-1)); + *out++ = f1 + frac * (f2 - f1); + tf.tf_i[HIOFFSET] = normhipart; + } + frac = tf.tf_d - UNITBIT32; + f1 = addr[0]; + f2 = addr[1]; + *out++ = f1 + frac * (f2 - f1); +#endif + return (w+5); +} + +static void m2f_tilde_dsp(t_m2f_tilde *x, t_signal **sp) +{ + dsp_add(m2f_tilde_perform, 4, sp[0]->s_vec, sp[1]->s_vec, x, sp[0]->s_n); +} + +static void m2f_tilde_maketable(void) +{ + union tabfudge tf; + + if(!iem_m2f_tilde_table) + { + int i; + t_float *fp, midi, refexp=440.0*exp(-5.75*log(2.0)); + + iem_m2f_tilde_table = (t_float *)getbytes(sizeof(t_float) * (M2FTILDETABSIZE+1)); + for(i=0, fp=iem_m2f_tilde_table, midi=-67.0; i<=M2FTILDETABSIZE; i++, fp++, midi+=0.1) + *fp = refexp * exp(0.057762265047 * midi); + } + tf.tf_d = UNITBIT32 + 0.5; + if((unsigned)tf.tf_i[LOWOFFSET] != 0x80000000) + bug("m2f~: unexpected machine alignment"); +} + +void m2f_tilde_setup(void) +{ + m2f_tilde_class = class_new(gensym("m2f~"), (t_newmethod)m2f_tilde_new, 0, + sizeof(t_m2f_tilde), 0, 0); + CLASS_MAINSIGNALIN(m2f_tilde_class, t_m2f_tilde, x_msi); + class_addmethod(m2f_tilde_class, (t_method)m2f_tilde_dsp, gensym("dsp"), 0); + m2f_tilde_maketable(); +// class_sethelpsymbol(m2f_tilde_class, gensym("iemhelp/help-m2f~")); +} diff --git a/iemlib2/src/makefile b/iemlib2/src/makefile new file mode 100644 index 0000000..19e7f63 --- /dev/null +++ b/iemlib2/src/makefile @@ -0,0 +1,4 @@ +TARGET = iemlib2 + +include ../../Make.include + diff --git a/iemlib2/src/makefile_linux b/iemlib2/src/makefile_linux new file mode 100644 index 0000000..ea9e468 --- /dev/null +++ b/iemlib2/src/makefile_linux @@ -0,0 +1,82 @@ +current: all + +.SUFFIXES: .pd_linux + +INCLUDE = -I. -I/usr/local/src/pd/src + +LDFLAGS = -export-dynamic -shared +LIB = -ldl -lm -lpthread + +#select either the DBG and OPT compiler flags below: + +CFLAGS = -DPD -DUNIX -W -Werror -Wno-unused \ + -Wno-parentheses -Wno-switch -O6 -funroll-loops -fomit-frame-pointer -fno-strict-aliasing \ + -DDL_OPEN + +SYSTEM = $(shell uname -m) + +# the sources + +SRC = add2_comma.c \ + bpe.c \ + dollarg.c \ + exp_inc.c \ + fade~.c \ + float24.c \ + iem_anything.c \ + iem_append.c \ + iem_blocksize~.c \ + iem_i_route.c \ + iem_pbank_csv.c \ + iem_prepend.c \ + iem_receive.c \ + iem_route.c \ + iem_samplerate~.c \ + iem_sel_any.c \ + iem_send.c \ + init.c \ + LFO_noise~.c \ + list2send.c \ + m2f~.c \ + mergefilename.c \ + modulo_counter.c \ + parentdollarzero.c \ + post_netreceive.c \ + pre_inlet.c \ + prepend_ascii.c \ + protect_against_open.c \ + receive2list.c \ + round_zero.c \ + speedlim.c \ + splitfilename.c \ + stripfilename.c \ + toggle_mess.c \ + transf_fader.c \ + unsymbol.c \ + wrap.c \ + iemlib2.c + +TARGET = iemlib2.pd_linux + + +OBJ = $(SRC:.c=.o) + +# +# ------------------ targets ------------------------------------ +# + +clean: + rm $(TARGET) + rm *.o + +all: $(OBJ) + @echo :: $(OBJ) + $(LD) $(LDFLAGS) -o $(TARGET) *.o $(LIB) + strip --strip-unneeded $(TARGET) + +$(OBJ) : %.o : %.c + $(CC) $(CFLAGS) $(INCLUDE) -c -o $*.o $*.c + + + + diff --git a/iemlib2/src/makefile_win b/iemlib2/src/makefile_win new file mode 100644 index 0000000..f07fa7a --- /dev/null +++ b/iemlib2/src/makefile_win @@ -0,0 +1,68 @@ + +all: ..\iemlib2.dll + +VIS_CPP_PATH = "C:\Programme\Microsoft Visual Studio\Vc98" +PD_INST_PATH = "C:\Programme\pd-0.39-2" +PD_WIN_INCLUDE_PATH = /I. /I$(PD_INST_PATH)\src /I$(VIS_CPP_PATH)\include +PD_WIN_C_FLAGS = /nologo /W3 /WX /DMSW /DNT /DPD /DWIN32 /DWINDOWS /Ox -DPA_LITTLE_ENDIAN +PD_WIN_L_FLAGS = /nologo + +PD_WIN_LIB = /NODEFAULTLIB:libc /NODEFAULTLIB:oldnames /NODEFAULTLIB:kernel /NODEFAULTLIB:uuid \ + $(VIS_CPP_PATH)\lib\libc.lib \ + $(VIS_CPP_PATH)\lib\oldnames.lib \ + $(VIS_CPP_PATH)\lib\kernel32.lib \ + $(VIS_CPP_PATH)\lib\wsock32.lib \ + $(VIS_CPP_PATH)\lib\winmm.lib \ + $(PD_INST_PATH)\bin\pthreadVC.lib \ + $(PD_INST_PATH)\bin\pd.lib + +SRC = add2_comma.c \ + bpe.c \ + dollarg.c \ + exp_inc.c \ + fade~.c \ + float24.c \ + iem_anything.c \ + iem_append.c \ + iem_blocksize~.c \ + iem_i_route.c \ + iem_pbank_csv.c \ + iem_prepend.c \ + iem_receive.c \ + iem_route.c \ + iem_samplerate~.c \ + iem_sel_any.c \ + iem_send.c \ + init.c \ + LFO_noise~.c \ + list2send.c \ + m2f~.c \ + mergefilename.c \ + modulo_counter.c \ + parentdollarzero.c \ + post_netreceive.c \ + pre_inlet.c \ + prepend_ascii.c \ + protect_against_open.c \ + receive2list.c \ + round_zero.c \ + speedlim.c \ + splitfilename.c \ + stripfilename.c \ + toggle_mess.c \ + transf_fader.c \ + unsymbol.c \ + wrap.c \ + iemlib2.c + +OBJ = $(SRC:.c=.obj) + +.c.obj: + cl $(PD_WIN_C_FLAGS) $(PD_WIN_INCLUDE_PATH) /c $*.c + +..\iemlib2.dll: $(OBJ) + link $(PD_WIN_L_FLAGS) /dll /export:iemlib2_setup \ + /out:..\iemlib2.dll $(OBJ) $(PD_WIN_LIB) + +clean: + del *.obj diff --git a/iemlib2/src/mergefilename.c b/iemlib2/src/mergefilename.c new file mode 100644 index 0000000..1070b41 --- /dev/null +++ b/iemlib2/src/mergefilename.c @@ -0,0 +1,223 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" +#include +#include + + +/* -------------------------- mergefilename ------------------------------ */ +/* ------------ concatenates a list of symbols to one symbol ------------- */ +/* ----- between the linked symbols, there is a variable character ------- */ + +static t_class *mergefilename_class; + +typedef struct _mergefilename +{ + t_object x_obj; + char x_sep[2]; + char x_mem[MAXPDSTRING]; +} t_mergefilename; + +static void mergefilename_separator(t_mergefilename *x, t_symbol *s, int ac, t_atom *av) +{ + if(ac > 0) + { + if(IS_A_SYMBOL(av, 0)) + { + char *name=av->a_w.w_symbol->s_name; + + if(strlen(name) == 1) + x->x_sep[0] = name[0]; + else if(!strcmp(name, "backslash")) + x->x_sep[0] = '\\'; + else if(!strcmp(name, "slash")) + x->x_sep[0] = '/'; + else if(!strcmp(name, "blank")) + x->x_sep[0] = ' '; + else if(!strcmp(name, "space")) + x->x_sep[0] = ' '; + else if(!strcmp(name, "dollar")) + x->x_sep[0] = '$'; + else if(!strcmp(name, "comma")) + x->x_sep[0] = ','; + else if(!strcmp(name, "semi")) + x->x_sep[0] = ';'; + else if(!strcmp(name, "leftbrace")) + x->x_sep[0] = '{'; + else if(!strcmp(name, "rightbrace")) + x->x_sep[0] = '}'; + else + x->x_sep[0] = 0; + } + else if(IS_A_FLOAT(av, 0)) + { + t_int i=atom_getintarg(0, ac, av); + + x->x_sep[0] = (char)i + '0'; + } + } + else + x->x_sep[0] = 0; +} + +static void mergefilename_float(t_mergefilename *x, t_floatarg f) +{ + char flt_buf[30]; + + flt_buf[0] = 0; + sprintf(flt_buf, "%g", f); + outlet_symbol(x->x_obj.ob_outlet, gensym(flt_buf)); +} + +static void mergefilename_symbol(t_mergefilename *x, t_symbol *s) +{ + outlet_symbol(x->x_obj.ob_outlet, s); +} + +static void mergefilename_list(t_mergefilename *x, t_symbol *s, int ac, t_atom *av) +{ + char flt_buf[30]; + t_int i, length, accu_size=0; + + x->x_mem[0] = 0; + if(ac > 0) + { + for(i=0; i 0) + { + strcat(x->x_mem, x->x_sep); + } + + if(IS_A_SYMBOL(av, 0)) + { + length = strlen(av->a_w.w_symbol->s_name); + if((accu_size + length) > (MAXPDSTRING - 2)) + { + strncat(x->x_mem, av->a_w.w_symbol->s_name, MAXPDSTRING - 2 - accu_size); + accu_size = MAXPDSTRING - 2; + i = ac + 1; + } + else + { + strcat(x->x_mem, av->a_w.w_symbol->s_name); + accu_size += length; + } + } + else if(IS_A_FLOAT(av, 0)) + { + sprintf(flt_buf, "%g", av->a_w.w_float); + length = strlen(flt_buf); + if((accu_size + length) > (MAXPDSTRING - 2)) + { + strncat(x->x_mem, flt_buf, MAXPDSTRING - 2 - accu_size); + accu_size = MAXPDSTRING - 2; + i = ac + 1; + } + else + { + strcat(x->x_mem, flt_buf); + accu_size += length; + } + } + av++; + } + } + outlet_symbol(x->x_obj.ob_outlet, gensym(x->x_mem)); +} + +static void mergefilename_anything(t_mergefilename *x, t_symbol *s, int ac, t_atom *av) +{ + char flt_buf[30]; + t_int i, length, accu_size=0; + + x->x_mem[0] = 0; + length = strlen(s->s_name); + if(length > (MAXPDSTRING - 2)) + { + strncat(x->x_mem, s->s_name, MAXPDSTRING - 2); + accu_size = MAXPDSTRING - 2; + i = ac + 1; + } + else + { + strcat(x->x_mem, s->s_name); + accu_size = length; + } + + if(ac > 0) + { + for(i=0; ix_mem, x->x_sep); + if(IS_A_SYMBOL(av, 0)) + { + length = strlen(av->a_w.w_symbol->s_name); + if((accu_size + length) > (MAXPDSTRING - 2)) + { + strncat(x->x_mem, av->a_w.w_symbol->s_name, MAXPDSTRING - 2 - accu_size); + accu_size = MAXPDSTRING - 2; + i = ac + 1; + } + else + { + strcat(x->x_mem, av->a_w.w_symbol->s_name); + accu_size += length; + } + } + else if(IS_A_FLOAT(av, 0)) + { + sprintf(flt_buf, "%g", av->a_w.w_float); + length = strlen(flt_buf); + if((accu_size + length) > (MAXPDSTRING - 2)) + { + strncat(x->x_mem, flt_buf, MAXPDSTRING - 2 - accu_size); + accu_size = MAXPDSTRING - 2; + i = ac + 1; + } + else + { + strcat(x->x_mem, flt_buf); + accu_size += length; + } + } + av++; + } + } + outlet_symbol(x->x_obj.ob_outlet, gensym(x->x_mem)); +} + +static void mergefilename_free(t_mergefilename *x) +{ +} + +static void *mergefilename_new(t_symbol *s, int ac, t_atom *av) +{ + t_mergefilename *x = (t_mergefilename *)pd_new(mergefilename_class); + + x->x_sep[0] = 0; + x->x_sep[1] = 0; + if(ac > 0) + mergefilename_separator(x, s, ac, av); + x->x_mem[0] = 0; + outlet_new(&x->x_obj, &s_symbol); + return (x); +} + +void mergefilename_setup(void) +{ + mergefilename_class = class_new(gensym("mergefilename"), (t_newmethod)mergefilename_new, + 0, sizeof(t_mergefilename), 0, A_GIMME, 0); + class_addmethod(mergefilename_class, (t_method)mergefilename_separator, gensym("separator"), A_GIMME, 0); + class_addmethod(mergefilename_class, (t_method)mergefilename_separator, gensym("sep"), A_GIMME, 0); + class_addfloat(mergefilename_class, mergefilename_float); + class_addsymbol(mergefilename_class, mergefilename_symbol); + class_addlist(mergefilename_class, mergefilename_list); + class_addanything(mergefilename_class, mergefilename_anything); +// class_sethelpsymbol(mergefilename_class, gensym("iemhelp/help-mergefilename")); +} diff --git a/iemlib2/src/modulo_counter.c b/iemlib2/src/modulo_counter.c new file mode 100644 index 0000000..435ac37 --- /dev/null +++ b/iemlib2/src/modulo_counter.c @@ -0,0 +1,82 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + +#include "m_pd.h" +#include "iemlib.h" + +/* ---------------- modulo-counter. ----------------- */ +/* -------- counter increments if input a bang ------ */ +/* -------- output is a modulo function. ------------ */ + +static t_class *modulo_counter_class; + +typedef struct _modulo_counter +{ + t_object x_obj; + int x_max; + int x_cur; +} t_modulo_counter; + +static void modulo_counter_bang(t_modulo_counter *x) +{ + outlet_float(x->x_obj.ob_outlet, x->x_cur++); + x->x_cur = x->x_cur % x->x_max; +} + +static void modulo_counter_float(t_modulo_counter *x, t_floatarg max) +{ + int i = (int)max; + + if(i < 1) + i = 1; + if(x->x_cur >= i) + x->x_cur = i - 1; + x->x_max = i; +} + +static void modulo_counter_ft1(t_modulo_counter *x, t_floatarg set_init) +{ + int i = (int)set_init; + + if(i < 0) + i = 0; + if(i >= x->x_max) + i = x->x_max - 1; + x->x_cur = i; +} + +static void *modulo_counter_new(t_symbol *s, int ac, t_atom *av) +{ + t_modulo_counter *x = (t_modulo_counter *)pd_new(modulo_counter_class); + int max = 1, cur = 0; + + if((ac > 0) && IS_A_FLOAT(av, 0)) + max = atom_getintarg(0, ac, av); + if((ac > 1) && IS_A_FLOAT(av, 1)) + cur = atom_getintarg(1, ac, av); + if(max < 1) + x->x_max = 1; + else + x->x_max = max; + if(cur < 0) + cur = 0; + if(cur >= x->x_max) + cur = x->x_max - 1; + x->x_cur = cur; + outlet_new(&x->x_obj, &s_float); + inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("ft1")); + return (x); +} + +void modulo_counter_setup(void) +{ + modulo_counter_class = class_new(gensym("modulo_counter"), + (t_newmethod)modulo_counter_new, 0, + sizeof(t_modulo_counter), 0, A_GIMME, 0); + class_addbang(modulo_counter_class, (t_method)modulo_counter_bang); + class_addfloat(modulo_counter_class, (t_method)modulo_counter_float); + class_addmethod(modulo_counter_class, (t_method)modulo_counter_ft1, gensym("ft1"), A_FLOAT, 0); +// class_sethelpsymbol(modulo_counter_class, gensym("iemhelp/help-modulo_counter")); +} diff --git a/iemlib2/src/parentdollarzero.c b/iemlib2/src/parentdollarzero.c new file mode 100644 index 0000000..85b79e9 --- /dev/null +++ b/iemlib2/src/parentdollarzero.c @@ -0,0 +1,53 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "g_canvas.h" +#include "iemlib.h" + + +/* -------------- parentdollarzero --------------- */ +/* -- receives the $0 value of the parent canvas --*/ + +static t_class *parentdollarzero_class; + +typedef struct _parentdollarzero +{ + t_object x_obj; + t_symbol *s_parent_unique; + unsigned int x_is_there_a_parent; +} t_parentdollarzero; + +static void parentdollarzero_bang(t_parentdollarzero *x) +{ + if(x->x_is_there_a_parent) + outlet_symbol(x->x_obj.ob_outlet, x->s_parent_unique); +} + +static void *parentdollarzero_new(void) +{ + t_parentdollarzero *x = (t_parentdollarzero *)pd_new(parentdollarzero_class); + t_glist *glist = (t_glist *)canvas_getcurrent(); + t_canvas *this_canvas = glist_getcanvas(glist); + + x->x_is_there_a_parent = (unsigned int)(0!=this_canvas->gl_owner); + + if(x->x_is_there_a_parent) + x->s_parent_unique = canvas_realizedollar((t_canvas *)this_canvas->gl_owner, gensym("$0")); + else + x->s_parent_unique = gensym(""); + outlet_new(&x->x_obj, &s_symbol); + return (x); +} + +void parentdollarzero_setup(void) +{ + parentdollarzero_class = class_new(gensym("parentdollarzero"), (t_newmethod)parentdollarzero_new, + 0, sizeof(t_parentdollarzero), 0, 0); + class_addcreator((t_newmethod)parentdollarzero_new, gensym("parent$0"), 0); + class_addbang(parentdollarzero_class, (t_method)parentdollarzero_bang); +// class_sethelpsymbol(parentdollarzero_class, gensym("iemhelp/help-parentdollarzero")); +} diff --git a/iemlib2/src/post_netreceive.c b/iemlib2/src/post_netreceive.c new file mode 100644 index 0000000..94b3696 --- /dev/null +++ b/iemlib2/src/post_netreceive.c @@ -0,0 +1,234 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" + + +/* ------------------------ post_netreceive ---------------------------- */ +static t_class *post_netreceive_class; + +typedef struct _post_netreceive +{ + t_object x_obj; + int x_max_send_entries; + int x_min_send_entries; + char *x_snd_able; + t_symbol **x_send_entries; + t_symbol **x_plus_entries; + t_symbol *x_set; + t_atom x_at[2]; + t_atom *x_atbuf; + t_symbol *x_send; + t_symbol *x_setall; +} t_post_netreceive; + +static void post_netreceive_list(t_post_netreceive *x, t_symbol *s, int ac, t_atom *av) +{ + int identifier_index = (int)atom_getintarg(0, ac, av); + t_symbol *sender=0; + + if((identifier_index >= x->x_min_send_entries) && (identifier_index < x->x_max_send_entries)) + { + if(x->x_snd_able[identifier_index] == 1) + { + sender = x->x_send_entries[identifier_index]; + if(sender->s_thing) + { + if(ac == 2) + pd_float(sender->s_thing, atom_getfloatarg(1, ac, av)); + else + pd_list(sender->s_thing, &s_list, ac-1, av+1); + } + } + else if(x->x_snd_able[identifier_index] == 2) + { + sender = x->x_send_entries[identifier_index]; + if(sender->s_thing) + { + typedmess(sender->s_thing, x->x_plus_entries[identifier_index], ac-1, av+1); + } + } + if(IS_A_FLOAT(av,1)) + SETFLOAT(x->x_atbuf+identifier_index+1, atom_getfloatarg(1, ac, av)); + else if(IS_A_SYMBOL(av,1)) + SETSYMBOL(x->x_atbuf+identifier_index+1, atom_getsymbolarg(1, ac, av)); + } +} + +/*static void post_netreceive_set_item_name(t_post_netreceive *x, t_symbol *snd, t_float findex) +{ +int index = (int)findex; + + if((index >= 0) && (index < x->x_max_send_entries)) + { + x->x_send_entries[index] = snd; + x->x_snd_able[index] = 1; + } +}*/ + +static void post_netreceive_set_item_name(t_post_netreceive *x, t_symbol *s, int ac, t_atom *av) +{ + if(ac == 2) + { + int identifier_index = (int)atom_getintarg(1, ac, av); + + if((identifier_index >= x->x_min_send_entries) && (identifier_index < x->x_max_send_entries)) + { + x->x_send_entries[identifier_index] = atom_getsymbolarg(0, ac, av); + x->x_snd_able[identifier_index] = 1; + } + } + else if(ac >= 3) + { + int identifier_index = (int)atom_getintarg(2, ac, av); + + if((identifier_index >= 0) && (identifier_index < x->x_max_send_entries)) + { + x->x_send_entries[identifier_index] = atom_getsymbolarg(1, ac, av); + x->x_snd_able[identifier_index] = 2; + x->x_plus_entries[identifier_index] = atom_getsymbolarg(0, ac, av); + } + } +} + +static void post_netreceive_all_parameters(t_post_netreceive *x, t_symbol *s, int ac, t_atom *av) +{ + int i, min = x->x_min_send_entries, max = x->x_max_send_entries; + t_symbol *sendname=0; + + if(min > ac) + min = ac; + if(max > ac) + max = ac; + for(i=min; ix_snd_able[i] == 1) + { + sendname = x->x_send_entries[i]; + if(sendname->s_thing) + { + pd_float(sendname->s_thing, atom_getfloatarg(i, ac, av)); + } + } + else if(x->x_snd_able[i] == 2) + { + sendname = x->x_send_entries[i]; + if(sendname->s_thing) + { + typedmess(sendname->s_thing, x->x_plus_entries[i], 1, av+i); + } + } + if(IS_A_FLOAT(av,i)) + SETFLOAT(x->x_atbuf+i+1, atom_getfloatarg(i, ac, av)); + else if(IS_A_SYMBOL(av,i)) + SETSYMBOL(x->x_atbuf+i+1, atom_getsymbolarg(i, ac, av)); + } +} + +static void post_netreceive_set_all_parameters(t_post_netreceive *x, t_symbol *s, int ac, t_atom *av) +{ + int i, min = x->x_min_send_entries, max = x->x_max_send_entries; + t_symbol *sendname; + + if(min > ac) + min = ac; + if(max > ac) + max = ac; + for(i=min; ix_snd_able[i]) + { + sendname = x->x_send_entries[i]; + if(sendname->s_thing) + { + typedmess(sendname->s_thing, x->x_set, 1, av+i); + } + } + } +} + +static void post_netreceive_clear(t_post_netreceive *x) +{ + int i, max = x->x_max_send_entries; + + for(i=0; ix_snd_able[i]) + { + x->x_snd_able[i] = 0; + } + } +} + +static void post_netreceive_fetch_all_parameters(t_post_netreceive *x, t_floatarg nr_sended_para) +{ + int nrsp=(int)nr_sended_para; + t_atom *ap=x->x_atbuf+x->x_min_send_entries; + + if(nrsp <= 0) + nrsp = 1; + if(nrsp > (x->x_max_send_entries - x->x_min_send_entries)) + nrsp = (x->x_max_send_entries - x->x_min_send_entries); + outlet_anything(x->x_obj.ob_outlet, x->x_send, nrsp+1, x->x_atbuf); +} + +static void post_netreceive_free(t_post_netreceive *x) +{ + freebytes(x->x_snd_able, x->x_max_send_entries * sizeof(char)); + freebytes(x->x_send_entries, x->x_max_send_entries * sizeof(t_symbol *)); + freebytes(x->x_atbuf, (x->x_max_send_entries+2) * sizeof(t_atom)); + freebytes(x->x_plus_entries, x->x_max_send_entries * sizeof(t_symbol *)); +} + +static void *post_netreceive_new(t_floatarg fmin, t_floatarg fmax) +{ + t_post_netreceive *x = (t_post_netreceive *)pd_new(post_netreceive_class); + int i, min = (int)fmin, max = (int)fmax; + t_atom *ap; + + if(min < 0) + min = 0; + if(max <= 0) + max = 80; + x->x_min_send_entries = min; + x->x_max_send_entries = max; + x->x_atbuf = (t_atom *)getbytes((x->x_max_send_entries+2) * sizeof(t_atom)); + x->x_snd_able = (char *)getbytes(x->x_max_send_entries * sizeof(char)); + x->x_send_entries = (t_symbol **)getbytes(x->x_max_send_entries * sizeof(t_symbol *)); + x->x_plus_entries = (t_symbol **)getbytes(x->x_max_send_entries * sizeof(t_symbol *)); + x->x_set = gensym("set"); + x->x_setall = gensym("set_all_parameters"); + x->x_send = gensym("send"); + ap = x->x_atbuf; + SETSYMBOL(ap, x->x_setall); + ap++; + for(i=1; i<=max; i++) + { + SETFLOAT(ap, 0.0); + ap++; + } + for(i=0; ix_snd_able[i] = 0; + x->x_plus_entries[i] = x->x_set; + } + outlet_new(&x->x_obj, &s_list); + return (x); +} + +void post_netreceive_setup(void) +{ + post_netreceive_class = class_new(gensym("post_netreceive"), (t_newmethod)post_netreceive_new, + (t_method)post_netreceive_free, sizeof(t_post_netreceive), 0, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addlist(post_netreceive_class, post_netreceive_list); + class_addmethod(post_netreceive_class, (t_method)post_netreceive_set_item_name, gensym("set_item_name"), A_GIMME, 0); + class_addmethod(post_netreceive_class, (t_method)post_netreceive_all_parameters, gensym("all_parameters"), A_GIMME, 0); + class_addmethod(post_netreceive_class, (t_method)post_netreceive_set_all_parameters, gensym("set_all_parameters"), A_GIMME, 0); + class_addmethod(post_netreceive_class, (t_method)post_netreceive_fetch_all_parameters, gensym("fetch_all_parameters"), A_DEFFLOAT, 0); + class_addmethod(post_netreceive_class, (t_method)post_netreceive_clear, gensym("clear"), 0); +// class_sethelpsymbol(post_netreceive_class, gensym("iemhelp/help-post_netreceive")); +} diff --git a/iemlib2/src/pre_inlet.c b/iemlib2/src/pre_inlet.c new file mode 100644 index 0000000..f56915d --- /dev/null +++ b/iemlib2/src/pre_inlet.c @@ -0,0 +1,91 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + +#include "m_pd.h" +#include "iemlib.h" + + +/* ------------------------ pre_inlet ---------------------------- */ +/* --------- any incoming message produce additionally a --------- */ +/* ----- special anything message at output, followed by the ----- */ +/* --- original message. this pre message contains a selector ---- */ +/* ---- symbol made of one character of the m-th entry of the ---- */ +/* --- ASCII-table, followed by one float atom list entry with --- */ +/* ---- with value n. "m" and "n" are the 2 initial arguments ---- */ + +static t_class *pre_inlet_class; + +typedef struct _pre_inlet +{ + t_object x_obj; + t_atom x_at; + t_symbol *x_sym; +} t_pre_inlet; + +static void pre_inlet_bang(t_pre_inlet *x) +{ + outlet_anything(x->x_obj.ob_outlet, x->x_sym, 1, &x->x_at); + outlet_bang(x->x_obj.ob_outlet); +} + +static void pre_inlet_float(t_pre_inlet *x, t_floatarg f) +{ + outlet_anything(x->x_obj.ob_outlet, x->x_sym, 1, &x->x_at); + outlet_float(x->x_obj.ob_outlet, f); +} + +static void pre_inlet_symbol(t_pre_inlet *x, t_symbol *s) +{ + outlet_anything(x->x_obj.ob_outlet, x->x_sym, 1, &x->x_at); + outlet_symbol(x->x_obj.ob_outlet, s); +} + +static void pre_inlet_pointer(t_pre_inlet *x, t_gpointer *gp) +{ + outlet_anything(x->x_obj.ob_outlet, x->x_sym, 1, &x->x_at); + outlet_pointer(x->x_obj.ob_outlet, gp); +} + +static void pre_inlet_list(t_pre_inlet *x, t_symbol *s, int ac, t_atom *av) +{ + outlet_anything(x->x_obj.ob_outlet, x->x_sym, 1, &x->x_at); + outlet_list(x->x_obj.ob_outlet, s, ac, av); +} + +static void pre_inlet_anything(t_pre_inlet *x, t_symbol *s, int ac, t_atom *av) +{ + outlet_anything(x->x_obj.ob_outlet, x->x_sym, 1, &x->x_at); + outlet_anything(x->x_obj.ob_outlet, s, ac, av); +} + +static void pre_inlet_free(t_pre_inlet *x) +{ +} + +static void *pre_inlet_new(t_floatarg fsym, t_floatarg finlet) +{ + t_pre_inlet *x = (t_pre_inlet *)pd_new(pre_inlet_class); + char str[2]; + + SETFLOAT(&x->x_at, finlet); + str[0] = (char)((int)(fsym)&0xff); + str[1] = 0; + x->x_sym = gensym(str); + outlet_new(&x->x_obj, &s_list); + return (x); +} + +void pre_inlet_setup(void) +{ + pre_inlet_class = class_new(gensym("pre_inlet"), (t_newmethod)pre_inlet_new, + (t_method)pre_inlet_free, sizeof(t_pre_inlet), 0, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addbang(pre_inlet_class, (t_method)pre_inlet_bang); + class_addfloat(pre_inlet_class, (t_method)pre_inlet_float); + class_addsymbol(pre_inlet_class, pre_inlet_symbol); + class_addpointer(pre_inlet_class, pre_inlet_pointer); + class_addlist(pre_inlet_class, pre_inlet_list); + class_addanything(pre_inlet_class, pre_inlet_anything); +// class_sethelpsymbol(pre_inlet_class, gensym("iemhelp/help-pre_inlet")); +} diff --git a/iemlib2/src/prepend_ascii.c b/iemlib2/src/prepend_ascii.c new file mode 100644 index 0000000..5c5d647 --- /dev/null +++ b/iemlib2/src/prepend_ascii.c @@ -0,0 +1,121 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" + +/* ------------------------- prepend_ascii ---------------------------- */ +/* -- this object prepends to any incoming message a selector symbol -- */ +/* --- containing the n-th character of the ASCII-table. "n" is the --- */ +/* ----------------- first initial argument (integer) ----------------- */ + +static t_class *prepend_ascii_class; + +typedef struct _prepend_ascii +{ + t_object x_obj; + t_atom *x_at; + int x_size; + int x_ac; + t_symbol *x_sym; +} t_prepend_ascii; + +static void prepend_ascii_atcopy(t_atom *src, t_atom *dst, int n) +{ + while(n--) + *dst++ = *src++; +} + +static void prepend_ascii_bang(t_prepend_ascii *x) +{ + outlet_anything(x->x_obj.ob_outlet, x->x_sym, x->x_ac, x->x_at); +} + +static void prepend_ascii_float(t_prepend_ascii *x, t_floatarg f) +{ + SETFLOAT(x->x_at+x->x_ac, f); + outlet_anything(x->x_obj.ob_outlet, x->x_sym, x->x_ac+1, x->x_at); +} + +static void prepend_ascii_symbol(t_prepend_ascii *x, t_symbol *s) +{ + SETSYMBOL(x->x_at+x->x_ac, s); + outlet_anything(x->x_obj.ob_outlet, x->x_sym, x->x_ac+1, x->x_at); +} + +static void prepend_ascii_pointer(t_prepend_ascii *x, t_gpointer *gp) +{ + SETPOINTER(x->x_at+x->x_ac, gp); + outlet_anything(x->x_obj.ob_outlet, x->x_sym, x->x_ac+1, x->x_at); +} + +static void prepend_ascii_list(t_prepend_ascii *x, t_symbol *s, int ac, t_atom *av) +{ + if((ac+x->x_ac) > x->x_size) + { + x->x_at = (t_atom *)resizebytes(x->x_at, x->x_size*sizeof(t_atom), (ac+x->x_ac)*sizeof(t_atom)); + x->x_size = (ac+x->x_ac); + } + prepend_ascii_atcopy(av, x->x_at+x->x_ac, ac); + outlet_anything(x->x_obj.ob_outlet, x->x_sym, ac+x->x_ac, x->x_at); +} + +static void prepend_ascii_anything(t_prepend_ascii *x, t_symbol *s, int ac, t_atom *av) +{ + if((ac+x->x_ac+1) > x->x_size) + { + x->x_at = (t_atom *)resizebytes(x->x_at, x->x_size*sizeof(t_atom), (ac+x->x_ac+1)*sizeof(t_atom)); + x->x_size = (ac+x->x_ac+1); + } + SETSYMBOL(x->x_at+x->x_ac, s); + prepend_ascii_atcopy(av, x->x_at+x->x_ac+1, ac); + outlet_anything(x->x_obj.ob_outlet, x->x_sym, ac+x->x_ac+1, x->x_at); +} + +static void prepend_ascii_free(t_prepend_ascii *x) +{ + if(x->x_at) + freebytes(x->x_at, x->x_size * sizeof(t_atom)); +} + +static void *prepend_ascii_new(t_symbol *s, int ac, t_atom *av) +{ + if((ac <= 0) || (!IS_A_FLOAT(av,0))) + { + post("ERROR: prepend_ascii need a float between 1 and 255 as 1. arg. !!!"); + return(0); + } + else + { + t_prepend_ascii *x = (t_prepend_ascii *)pd_new(prepend_ascii_class); + char str[2]; + int i; + + x->x_size = 10 + ac; + x->x_at = (t_atom *)getbytes(x->x_size * sizeof(t_atom)); + str[0] = (char)((int)(atom_getfloatarg(0,ac,av))&0xff); + str[1] = 0; + x->x_sym = gensym(str); + x->x_ac = ac - 1; + for(i=1; ix_at[i-1] = av[i]; + outlet_new(&x->x_obj, &s_list); + return (x); + } +} + +void prepend_ascii_setup(void) +{ + prepend_ascii_class = class_new(gensym("prepend_ascii"), (t_newmethod)prepend_ascii_new, + (t_method)prepend_ascii_free, sizeof(t_prepend_ascii), 0, A_GIMME, 0); + class_addbang(prepend_ascii_class, (t_method)prepend_ascii_bang); + class_addfloat(prepend_ascii_class, (t_method)prepend_ascii_float); + class_addsymbol(prepend_ascii_class, prepend_ascii_symbol); + class_addpointer(prepend_ascii_class, prepend_ascii_pointer); + class_addlist(prepend_ascii_class, prepend_ascii_list); + class_addanything(prepend_ascii_class, prepend_ascii_anything); +// class_sethelpsymbol(prepend_ascii_class, gensym("iemhelp/help-prepend_ascii")); +} diff --git a/iemlib2/src/protect_against_open.c b/iemlib2/src/protect_against_open.c new file mode 100644 index 0000000..046bf95 --- /dev/null +++ b/iemlib2/src/protect_against_open.c @@ -0,0 +1,99 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" +#include "g_canvas.h" +#include "g_all_guis.h" +#include + +#ifdef _MSC_VER +#include +#else +#include +#endif + +/* ---------------------- protect_against_open ----------------------- */ +/* -- if you putting this object into a subpatch or an abstraction, -- */ +/* ------------ you cannot open again this subpatch ------------------ */ + +t_widgetbehavior protect_against_open_widgetbehavior; +static t_class *protect_against_open_class; + +typedef struct _protect_against_open +{ + t_object x_obj; + t_symbol *x_sym; + t_pd *x_owner; + void *x_clock; +} t_protect_against_open; + +/* ------------------------ cnv widgetbehaviour----------------------------- */ + +static void protect_against_open_tick(t_protect_against_open *x) +{ + t_symbol *sym = gensym("vis"); + t_atom at[1]; + + SETFLOAT(at, 0.0); + typedmess(x->x_sym->s_thing, sym, 1, at); + clock_unset(x->x_clock); +} + +static void protect_against_open_vis(t_gobj *z, t_glist *glist, int vis) +{ + t_protect_against_open *x = (t_protect_against_open *)z; + + if(vis) + clock_delay(x->x_clock, 5); +} + +static void *protect_against_open_new(t_symbol *s, int ac, t_atom *av) +{ + t_protect_against_open *x = (t_protect_against_open *)pd_new(protect_against_open_class); + t_glist *glist = (t_glist *)canvas_getcurrent(); + t_canvas *this_canvas = glist_getcanvas(glist); + t_symbol *s_unique; + char str[100]; + + x->x_owner = (t_pd *)glist; + s_unique = canvas_realizedollar(glist_getcanvas(glist), gensym("$0")); + strcpy(str, s_unique->s_name); + strcat(str, "-quabla"); + x->x_sym = gensym(str); + if(*x->x_sym->s_name) + pd_bind(x->x_owner, x->x_sym); + x->x_clock = clock_new(x, (t_method)protect_against_open_tick); + return(x); +} + +static void protect_against_open_ff(t_protect_against_open *x) +{ + if(*x->x_sym->s_name) + pd_unbind(x->x_owner, x->x_sym); + clock_free(x->x_clock); +} + +void protect_against_open_setup(void) +{ + protect_against_open_class = class_new(gensym("protect_against_open"), (t_newmethod)protect_against_open_new, + (t_method)protect_against_open_ff, sizeof(t_protect_against_open), 0, A_GIMME, 0); + + protect_against_open_widgetbehavior.w_getrectfn = NULL; + protect_against_open_widgetbehavior.w_displacefn = NULL; + protect_against_open_widgetbehavior.w_selectfn = NULL; + protect_against_open_widgetbehavior.w_activatefn = NULL; + protect_against_open_widgetbehavior.w_deletefn = NULL; + protect_against_open_widgetbehavior.w_visfn = protect_against_open_vis; + protect_against_open_widgetbehavior.w_clickfn = NULL; +#if defined(PD_MAJOR_VERSION) && (PD_MINOR_VERSION >= 37) + +#else + protect_against_open_widgetbehavior.w_propertiesfn = NULL; + protect_against_open_widgetbehavior.w_savefn = NULL; +#endif + class_setwidget(protect_against_open_class, &protect_against_open_widgetbehavior); +} diff --git a/iemlib2/src/receive2list.c b/iemlib2/src/receive2list.c new file mode 100644 index 0000000..a8975f9 --- /dev/null +++ b/iemlib2/src/receive2list.c @@ -0,0 +1,216 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + +#include "m_pd.h" +#include "iemlib.h" +#include +#include +#include + +/* -------------------------- receive2list ------------------------------ */ +/* -- converts received message to a list with a prepended float index -- */ + +struct _receive2list_proxy; + +static t_class *receive2list_class; +static t_class *receive2list_proxy_class; + +typedef struct _receive2list +{ + t_object x_obj; + int x_max; + struct _receive2list_proxy **x_proxy_receiver; + int x_size; + t_atom *x_at; +} t_receive2list; + +typedef struct _receive2list_proxy +{ + t_object p_obj; + t_receive2list *p_owner; + t_symbol *p_receive_label_sym; + int p_index; +} t_receive2list_proxy; + +static void receive2list_atcopy(t_atom *src, t_atom *dst, int n) +{ + while(n--) + *dst++ = *src++; +} + +static void receive2list_clear(t_receive2list *x, t_symbol *s, int ac, t_atom *av) +{ + t_receive2list_proxy *p; + int i, max=x->x_max; + + for(i=0; ix_proxy_receiver[i]; + if(p->p_receive_label_sym) + pd_unbind(&p->p_obj.ob_pd, p->p_receive_label_sym); + p->p_receive_label_sym = 0; + } +} + +static void receive2list_add(t_receive2list *x, t_symbol *s, int ac, t_atom *av) +{ + t_receive2list_proxy *p; + int i; + + if((ac > 1)&&(IS_A_FLOAT(av,0))) + { + i = atom_getint(av); + if((i >= 0)&&(i < x->x_max)) + { + p = x->x_proxy_receiver[i]; + if(IS_A_SYMBOL(av,1)) + { + if(p->p_receive_label_sym) + pd_unbind(&p->p_obj.ob_pd, p->p_receive_label_sym); + p->p_receive_label_sym = atom_getsymbol(av+1); + pd_bind(&p->p_obj.ob_pd, p->p_receive_label_sym); + } + else if(IS_A_FLOAT(av,1)) + { + char str[32]; + + if(p->p_receive_label_sym) + pd_unbind(&p->p_obj.ob_pd, p->p_receive_label_sym); + sprintf(str, "%g", atom_getfloat(av+1)); + p->p_receive_label_sym = gensym(str); + pd_bind(&p->p_obj.ob_pd, p->p_receive_label_sym); + } + } + } +} + +/* begin of proxy methods (anything inlets) */ + +static void receive2list_proxy_bang(t_receive2list_proxy *p) +{ + t_receive2list *x = p->p_owner; + + SETFLOAT(x->x_at, p->p_index); + outlet_list(x->x_obj.ob_outlet, &s_list, 1, x->x_at); +} + +static void receive2list_proxy_float(t_receive2list_proxy *p, t_floatarg f) +{ + t_receive2list *x = p->p_owner; + + SETFLOAT(x->x_at, p->p_index); + SETFLOAT(x->x_at+1, f); + outlet_list(x->x_obj.ob_outlet, &s_list, 2, x->x_at); +} + +static void receive2list_proxy_symbol(t_receive2list_proxy *p, t_symbol *s) +{ + t_receive2list *x = p->p_owner; + + SETFLOAT(x->x_at, p->p_index); + SETSYMBOL(x->x_at+1, s); + outlet_list(x->x_obj.ob_outlet, &s_list, 2, x->x_at); +} + +static void receive2list_proxy_pointer(t_receive2list_proxy *p, t_gpointer *gp) +{ + t_receive2list *x = p->p_owner; + + SETFLOAT(x->x_at, p->p_index); + SETPOINTER(x->x_at+1, gp); + outlet_list(x->x_obj.ob_outlet, &s_list, 2, x->x_at); +} + +static void receive2list_proxy_list(t_receive2list_proxy *p, t_symbol *s, int argc, t_atom *argv) +{ + t_receive2list *x = p->p_owner; + + if((argc+1) >= x->x_size) + { + x->x_at = (t_atom *)resizebytes(x->x_at, x->x_size*sizeof(t_atom), (argc+11)*sizeof(t_atom)); + x->x_size = argc + 11; + } + SETFLOAT(x->x_at, p->p_index); + receive2list_atcopy(argv, x->x_at+1, argc); + outlet_list(x->x_obj.ob_outlet, &s_list, argc+1, x->x_at); +} + +static void receive2list_proxy_anything(t_receive2list_proxy *p, t_symbol *s, int argc, t_atom *argv) +{ + t_receive2list *x = p->p_owner; + + if((argc+2) >= x->x_size) + { + x->x_at = (t_atom *)resizebytes(x->x_at, x->x_size*sizeof(t_atom), (argc+12)*sizeof(t_atom)); + x->x_size = argc + 12; + } + SETFLOAT(x->x_at, p->p_index); + SETSYMBOL(x->x_at+1, s); + receive2list_atcopy(argv, x->x_at+2, argc); + outlet_list(x->x_obj.ob_outlet, &s_list, argc+2, x->x_at); +} + +/* end of proxy methods (anything inlets) */ + +static void receive2list_free(t_receive2list *x) +{ + t_receive2list_proxy *p; + int i, max = x->x_max; + + for(i=0; ix_proxy_receiver[i]; + if(p->p_receive_label_sym) + pd_unbind(&p->p_obj.ob_pd, p->p_receive_label_sym); + if(x->x_proxy_receiver[i]) + pd_free((t_pd *)x->x_proxy_receiver[i]); + } + if(x->x_proxy_receiver) + freebytes(x->x_proxy_receiver, x->x_max * sizeof(t_receive2list_proxy *)); + if(x->x_at) + freebytes(x->x_at, x->x_size * sizeof(t_atom)); +} + +static void *receive2list_new(t_floatarg fmax) +{ + t_receive2list *x = (t_receive2list *)pd_new(receive2list_class); + t_receive2list_proxy *p; + int i, max = (int)fmax; + + if(max <= 0) + max = 80; + x->x_max = max; + x->x_proxy_receiver = (t_receive2list_proxy **)getbytes(x->x_max * sizeof(t_receive2list_proxy *)); + x->x_size = 12; + x->x_at = (t_atom *)getbytes(x->x_size * sizeof(t_atom)); + for(i=0; ix_proxy_receiver[i] = (t_receive2list_proxy *)pd_new(receive2list_proxy_class); + p = x->x_proxy_receiver[i]; + p->p_owner = x; + p->p_receive_label_sym = 0; + p->p_index = i; + } + outlet_new(&x->x_obj, &s_list); + return (x); +} + +void receive2list_setup(void) +{ + receive2list_class = class_new(gensym("receive2list"), (t_newmethod)receive2list_new, + (t_method)receive2list_free, sizeof(t_receive2list), 0, A_DEFFLOAT, 0); + class_addmethod(receive2list_class, (t_method)receive2list_clear, gensym("clear"), A_GIMME, 0); + class_addmethod(receive2list_class, (t_method)receive2list_add, gensym("add"), A_GIMME, 0); +// class_sethelpsymbol(receive2list_class, gensym("iemhelp/help-receive2list")); + + receive2list_proxy_class = class_new(gensym("_receive2list_proxy"), + 0, 0, sizeof(t_receive2list_proxy), CLASS_PD | CLASS_NOINLET, 0); + class_addbang(receive2list_proxy_class, receive2list_proxy_bang); + class_addfloat(receive2list_proxy_class, receive2list_proxy_float); + class_addsymbol(receive2list_proxy_class, receive2list_proxy_symbol); + class_addpointer(receive2list_proxy_class, receive2list_proxy_pointer); + class_addlist(receive2list_proxy_class, receive2list_proxy_list); + class_addanything(receive2list_proxy_class, receive2list_proxy_anything); +} diff --git a/iemlib2/src/round_zero.c b/iemlib2/src/round_zero.c new file mode 100644 index 0000000..1bd4f24 --- /dev/null +++ b/iemlib2/src/round_zero.c @@ -0,0 +1,60 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + +#include "m_pd.h" +#include "iemlib.h" + + +/* ------------------------ round_zero ---------------------------- */ +/* ------ small float numbers of an anything message within ------- */ +/* ---- plus minus initial argument will be truncated to zero ----- */ + +static t_class *round_zero_class; + +typedef struct _round_zero +{ + t_object x_obj; + t_float x_bound; +} t_round_zero; + +static void round_zero_anything(t_round_zero *x, t_symbol *s, int ac, t_atom *av) +{ + int i; + t_float f, bound=x->x_bound; + + for(i=0; i= -bound)) + { + f = 0.0f; + SETFLOAT(av+i, f); + } + } + } + outlet_anything(x->x_obj.ob_outlet, s, ac, av); +} + +static void *round_zero_new(t_floatarg bound) +{ + t_round_zero *x = (t_round_zero *)pd_new(round_zero_class); + + if(bound < 0.0f) + x->x_bound = -bound; + else + x->x_bound = bound; + outlet_new(&x->x_obj, &s_list); + return (x); +} + +void round_zero_setup(void) +{ + round_zero_class = class_new(gensym("round_zero"), (t_newmethod)round_zero_new, + 0, sizeof(t_round_zero), 0, A_DEFFLOAT, 0); + class_addanything(round_zero_class, round_zero_anything); +// class_sethelpsymbol(round_zero_class, gensym("iemhelp/help-round_zero")); +} diff --git a/iemlib2/src/speedlim.c b/iemlib2/src/speedlim.c new file mode 100644 index 0000000..2328ffa --- /dev/null +++ b/iemlib2/src/speedlim.c @@ -0,0 +1,100 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" + +/* ----------------------- speedlim -------------------------- */ +/* -- reduces the flow of float-messages to one message per -- */ +/* ----------------- initial argument time in ms ------------- */ + +static t_class *speedlim_class; + +typedef struct _speedlim +{ + t_object x_obj; + t_clock *x_clock; + float x_delay; + int x_output_is_locked; + int x_there_was_n_event; + t_float x_curval; + t_float x_lastout; +} t_speedlim; + +static void speedlim_stop(t_speedlim *x) +{ + x->x_output_is_locked = 0; + x->x_there_was_n_event = 0; + clock_unset(x->x_clock); +} + +static void speedlim_tick(t_speedlim *x) +{ + if(x->x_there_was_n_event) + { + x->x_output_is_locked = 1; + x->x_there_was_n_event = 0; + outlet_float(x->x_obj.ob_outlet, x->x_curval); + clock_delay(x->x_clock, x->x_delay); + } + else + { + x->x_output_is_locked = 0; + x->x_there_was_n_event = 0; + } +} + +static void speedlim_float(t_speedlim *x, t_floatarg val) +{ + x->x_curval = val; + if(!x->x_output_is_locked) + { + x->x_output_is_locked = 1; + x->x_there_was_n_event = 0; + outlet_float(x->x_obj.ob_outlet, x->x_curval); + clock_delay(x->x_clock, x->x_delay); + } + else + x->x_there_was_n_event = 1; +} + +static void speedlim_ft1(t_speedlim *x, t_floatarg delay) +{ + if(delay < 0.0) + delay = 0.0; + x->x_delay = delay; +} + +static void speedlim_free(t_speedlim *x) +{ + clock_free(x->x_clock); +} + +static void *speedlim_new(t_floatarg delay) +{ + t_speedlim *x = (t_speedlim *)pd_new(speedlim_class); + + if(delay < 0.0) + delay = 0.0; + x->x_delay = delay; + x->x_curval = 0.0f; + x->x_output_is_locked = 0; + x->x_there_was_n_event = 0; + x->x_clock = clock_new(x, (t_method)speedlim_tick); + outlet_new(&x->x_obj, &s_float); + inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("ft1")); + return (x); +} + +void speedlim_setup(void) +{ + speedlim_class = class_new(gensym("speedlim"), (t_newmethod)speedlim_new, + (t_method)speedlim_free, sizeof(t_speedlim), 0, A_DEFFLOAT, 0); + class_addmethod(speedlim_class, (t_method)speedlim_stop, gensym("stop"), 0); + class_addfloat(speedlim_class, (t_method)speedlim_float); + class_addmethod(speedlim_class, (t_method)speedlim_ft1, gensym("ft1"), A_FLOAT, 0); +// class_sethelpsymbol(speedlim_class, gensym("iemhelp/help-speedlim")); +} diff --git a/iemlib2/src/splitfilename.c b/iemlib2/src/splitfilename.c new file mode 100644 index 0000000..0f5ad2a --- /dev/null +++ b/iemlib2/src/splitfilename.c @@ -0,0 +1,130 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" +#include + + +/* ----------------------- splitfilename -------------------------- */ +/* -- splits a symbol into 2 parts (path + file) at the position -- */ +/* -- of the first separator-character beginnig from the right ---- */ +/* ---------- eliminating the separator-character ----------------- */ + +static t_class *splitfilename_class; + +typedef struct _splitfilename +{ + t_object x_obj; + char x_sep[2]; + char x_mem[MAXPDSTRING]; + t_outlet *x_outpath; + t_outlet *x_outfile; +} t_splitfilename; + +static void splitfilename_separator(t_splitfilename *x, t_symbol *s, int ac, t_atom *av) +{ + if(ac > 0) + { + if(IS_A_SYMBOL(av, 0)) + { + char *name=av->a_w.w_symbol->s_name; + + if(strlen(name) == 1) + x->x_sep[0] = name[0]; + else if(!strcmp(name, "backslash")) + x->x_sep[0] = '\\'; + else if(!strcmp(name, "slash")) + x->x_sep[0] = '/'; + else if(!strcmp(name, "blank")) + x->x_sep[0] = ' '; + else if(!strcmp(name, "space")) + x->x_sep[0] = ' '; + else if(!strcmp(name, "dollar")) + x->x_sep[0] = '$'; + else if(!strcmp(name, "comma")) + x->x_sep[0] = ','; + else if(!strcmp(name, "semi")) + x->x_sep[0] = ';'; + else if(!strcmp(name, "leftbrace")) + x->x_sep[0] = '{'; + else if(!strcmp(name, "rightbrace")) + x->x_sep[0] = '}'; + else + x->x_sep[0] = '/'; + } + else if(IS_A_FLOAT(av, 0)) + { + t_int i=atom_getintarg(0, ac, av); + + x->x_sep[0] = (char)i + '0';/* you can set any separator-char by setting a number between -32 ... 223 */ + } + } + else + x->x_sep[0] = 0; +} + +static void splitfilename_symbol(t_splitfilename *x, t_symbol *s) +{ + t_int length = strlen(s->s_name); + + if(length) + { + if(x->x_sep[0]) + { + char *sep_ptr=x->x_mem; + + if(length > (MAXPDSTRING - 2)) + strncpy(x->x_mem, s->s_name, MAXPDSTRING - 2 - length); + else + strcpy(x->x_mem, s->s_name); + + sep_ptr = strrchr(x->x_mem, x->x_sep[0]);/* points to the leftest separator-char-index of string */ + if((!sep_ptr) || ((sep_ptr - x->x_mem) < 0) || ((sep_ptr - x->x_mem) >= length)) + { /* JMZ: 20050701 : removed typecast (char*) to (int); this is not portable */ + outlet_symbol(x->x_outfile, &s_); + outlet_symbol(x->x_outpath, gensym(x->x_mem)); + } + else + { + *sep_ptr = 0; + sep_ptr++; + outlet_symbol(x->x_outfile, gensym(sep_ptr)); + outlet_symbol(x->x_outpath, gensym(x->x_mem)); + } + } + else + { + outlet_symbol(x->x_outfile, &s_); + outlet_symbol(x->x_outpath, s); + } + } +} + +static void *splitfilename_new(t_symbol *s, int ac, t_atom *av) +{ + t_splitfilename *x = (t_splitfilename *)pd_new(splitfilename_class); + + x->x_sep[0] = 0; + x->x_sep[1] = 0; + if(ac == 0) + x->x_sep[0] = '/'; + else + splitfilename_separator(x, s, ac, av); + x->x_outpath = (t_outlet *)outlet_new(&x->x_obj, &s_symbol); + x->x_outfile = (t_outlet *)outlet_new(&x->x_obj, &s_symbol); + return (x); +} + +void splitfilename_setup(void) +{ + splitfilename_class = class_new(gensym("splitfilename"), (t_newmethod)splitfilename_new, + 0, sizeof(t_splitfilename), 0, A_GIMME, 0); + class_addsymbol(splitfilename_class, splitfilename_symbol); + class_addmethod(splitfilename_class, (t_method)splitfilename_separator, gensym("separator"), A_GIMME, 0); + class_addmethod(splitfilename_class, (t_method)splitfilename_separator, gensym("sep"), A_GIMME, 0); +// class_sethelpsymbol(splitfilename_class, gensym("iemhelp/help-splitfilename")); +} diff --git a/iemlib2/src/stripfilename.c b/iemlib2/src/stripfilename.c new file mode 100644 index 0000000..c611e3d --- /dev/null +++ b/iemlib2/src/stripfilename.c @@ -0,0 +1,77 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + +#include "m_pd.h" +#include "iemlib.h" +#include + +/* -------------------------- stripfilename ----------------------- */ +/* -- strips the first n or last n characters, depending on sign -- */ +/* ------- of the initial argument (set message argument) --------- */ + +static t_class *stripfilename_class; + +typedef struct _stripfilename +{ + t_object x_obj; + int x_nr_char; + char x_mem[MAXPDSTRING]; +} t_stripfilename; + +static void stripfilename_symbol(t_stripfilename *x, t_symbol *s) +{ + if(x->x_nr_char < 0)/* cuts the string from the back */ + { + int len = strlen(s->s_name); + int i=len + x->x_nr_char; + + if(len > (MAXPDSTRING - 2)) + strncpy(x->x_mem, s->s_name, MAXPDSTRING - 2 - len); + else + strcpy(x->x_mem, s->s_name); + if(i < 0) + i = 0; + x->x_mem[i] = 0; + outlet_symbol(x->x_obj.ob_outlet, gensym(x->x_mem)); + } + else if(x->x_nr_char > 0)/* starts the string at this new offset */ + { + int len = strlen(s->s_name); + int i=x->x_nr_char; + + if(len > (MAXPDSTRING - 2)) + strncpy(x->x_mem, s->s_name, MAXPDSTRING - 2 - len); + else + strcpy(x->x_mem, s->s_name); + if(i > len) + i = len; + outlet_symbol(x->x_obj.ob_outlet, gensym(x->x_mem+i)); + } + else + outlet_symbol(x->x_obj.ob_outlet, s); +} + +static void stripfilename_set(t_stripfilename *x, t_floatarg nr_char) +{ + x->x_nr_char = (int)nr_char; +} + +static void *stripfilename_new(t_floatarg nr_char) +{ + t_stripfilename *x = (t_stripfilename *)pd_new(stripfilename_class); + + stripfilename_set(x, nr_char); + outlet_new(&x->x_obj, &s_symbol); + return (x); +} + +void stripfilename_setup(void) +{ + stripfilename_class = class_new(gensym("stripfilename"), (t_newmethod)stripfilename_new, + 0, sizeof(t_stripfilename), 0, A_DEFFLOAT, 0); + class_addsymbol(stripfilename_class, stripfilename_symbol); + class_addmethod(stripfilename_class, (t_method)stripfilename_set, gensym("set"), A_FLOAT, 0); +// class_sethelpsymbol(stripfilename_class, gensym("iemhelp/help-stripfilename")); +} diff --git a/iemlib2/src/toggle_mess.c b/iemlib2/src/toggle_mess.c new file mode 100644 index 0000000..b6ffb95 --- /dev/null +++ b/iemlib2/src/toggle_mess.c @@ -0,0 +1,114 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" + +/* ------------------------ toggle_mess ---------------------------- */ +/* -- inital arguments building a set of messages, any incomming --- */ +/* -- increments the internal counter and outputs the n-th initial --*/ +/* -- message. -- */ + +static t_class *toggle_mess_class; + +typedef struct _toggle_mess +{ + t_object x_obj; + int x_index; + int x_ac; + t_atom *x_at; + void *x_out_mid_sym; + void *x_out_rght_flt; + t_symbol *x_set; +} t_toggle_mess; + +static void toggle_mess_bang(t_toggle_mess *x) +{ + int i = x->x_index; + + outlet_float(x->x_out_rght_flt, (t_float)i); + if(IS_A_FLOAT(x->x_at, i)) + outlet_float(x->x_out_mid_sym, atom_getfloat(&x->x_at[i])); + else + outlet_anything(x->x_out_mid_sym, atom_getsymbol(&x->x_at[i]), 0, x->x_at); + outlet_anything(x->x_obj.ob_outlet, x->x_set, 1, &x->x_at[i]); +} + +static void toggle_mess_float(t_toggle_mess *x, t_floatarg f) +{ + x->x_index++; + if(x->x_index >= x->x_ac) + x->x_index = 0; + toggle_mess_bang(x); +} + +static void toggle_mess_set(t_toggle_mess *x, t_symbol *s, int ac, t_atom *av) +{ + if((ac >= 1) && (IS_A_FLOAT(av, 0))) + { + int x_index = (int)atom_getint(av); + + if(x_index < 0) + x_index = 0; + else if(x_index >= x->x_ac) + x_index = x->x_ac; + x->x_index = x_index; + outlet_anything(x->x_obj.ob_outlet, x->x_set, 1, &x->x_at[x_index]); + } + else + toggle_mess_float(x, 0); +} + +static void toggle_mess_symbol(t_toggle_mess *x, t_symbol *s) +{ + toggle_mess_float(x, 0); +} + +static void toggle_mess_anything(t_toggle_mess *x, t_symbol *s, int ac, t_atom *av) +{ + toggle_mess_float(x, 0); +} + +static void toggle_mess_free(t_toggle_mess *x) +{ + freebytes(x->x_at, x->x_ac * sizeof(t_atom)); +} + +static void *toggle_mess_new(t_symbol *s, int ac, t_atom *av) +{ + t_toggle_mess *x = (t_toggle_mess *)pd_new(toggle_mess_class); + int i; + + if(!ac) + { + post("toggle_mess-ERROR: must have at least one argument!"); + x->x_at = (t_atom *)0; + return(0); + } + x->x_ac = ac; + x->x_at = (t_atom *)getbytes(ac * sizeof(t_atom)); + for(i=0; ix_at[i] = *av++; + x->x_index = 0; + x->x_set = gensym("set"); + outlet_new(&x->x_obj, &s_list); + x->x_out_mid_sym = outlet_new(&x->x_obj, &s_list); + x->x_out_rght_flt = outlet_new(&x->x_obj, &s_float); + return(x); +} + +void toggle_mess_setup(void) +{ + toggle_mess_class = class_new(gensym("toggle_mess"), (t_newmethod)toggle_mess_new, + (t_method)toggle_mess_free, sizeof(t_toggle_mess), 0, A_GIMME, 0); + class_addcreator((t_newmethod)toggle_mess_new, gensym("tm"), A_GIMME, 0); + class_addbang(toggle_mess_class, (t_method)toggle_mess_bang); + class_addmethod(toggle_mess_class, (t_method)toggle_mess_set, gensym("set"), A_GIMME, 0); + class_addfloat(toggle_mess_class, (t_method)toggle_mess_float); + class_addsymbol(toggle_mess_class, toggle_mess_symbol); + class_addanything(toggle_mess_class, toggle_mess_anything); +// class_sethelpsymbol(toggle_mess_class, gensym("iemhelp/help-toggle_mess")); +} diff --git a/iemlib2/src/transf_fader.c b/iemlib2/src/transf_fader.c new file mode 100644 index 0000000..6aed491 --- /dev/null +++ b/iemlib2/src/transf_fader.c @@ -0,0 +1,147 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" + + +/* ------------------------ transf_fader ----------------------- */ +/* -- this loopkup tabel objekt makes a 2-point interpolation -- */ +/* --------- between the pairs of determinating points --------- */ + +typedef struct _transf_fader +{ + t_object x_obj; + int x_size; + int x_message; + t_float *x_array; +} t_transf_fader; + +static t_class *transf_fader_class; + +static void transf_fader_pairs(t_transf_fader *x, t_symbol *s, int argc, t_atom *argv) +{ + if(argc >= 4) + { + int i, j, k, ac=argc/2; + int n=1000; + int i_prev=0; + int first=1; + int i_delta; + t_float val_delta; + t_float delta; + t_float val_prev=0.0f; + t_float val=0.0f; + t_float *vec=x->x_array; + t_float fad_in, fad_out; + + for(j=0; j 1000.0f) + fad_in = 1000.0f; + + fad_out = atom_getfloat(argv++); + while(fad_out < -123455.0f) + fad_out = -123455.0f; + + i = (int)fad_in; + vec[i] = fad_out; + } + + for(j=0; j -123456.0f) + { + if(first) + { + first = 0; + i_prev = j; + val_prev = vec[j]; + } + else + { + i = j; + val = vec[j]; + i_delta = i - i_prev; + val_delta = val - val_prev; + if(i_delta > 1) + { + delta = val_delta / (t_float)i_delta; + for(k=i_prev+1; kx_message) + post("transf_fader-ERROR: less than 2 pairs make no sense"); + } +} + +static void transf_fader_float(t_transf_fader *x, t_floatarg fad_in) +{ + t_float fad_out; + t_float *vec=x->x_array; + t_float fract; + int i; + + while(fad_in < 0.0f) + fad_in = 0.0f; + while(fad_in > 999.0f) + fad_in = 999.0f; + + i = (int)fad_in; + fract = fad_in - (t_float)i; + fad_out = vec[i] + fract*(vec[i+1] - vec[i]); + if(fad_out > -123455.0f) + outlet_float(x->x_obj.ob_outlet, fad_out); +} + +static void transf_fader_free(t_transf_fader *x) +{ + freebytes(x->x_array, x->x_size * sizeof(t_float)); +} + +static void *transf_fader_new(t_symbol *s, int argc, t_atom *argv) +{ + t_transf_fader *x = (t_transf_fader *)pd_new(transf_fader_class); + int i, n; + + x->x_size = 1001; + x->x_message = 0; + x->x_array = (t_float *)getbytes(x->x_size * sizeof(t_float)); + n = x->x_size; + for(i=0; ix_array[i] = -123456.0f; + transf_fader_pairs(x, gensym("pairs"), argc, argv); + x->x_message = 1; + outlet_new(&x->x_obj, &s_float); + return (x); +} + +void transf_fader_setup(void) +{ + transf_fader_class = class_new(gensym("transf_fader"), (t_newmethod)transf_fader_new, (t_method)transf_fader_free, + sizeof(t_transf_fader), 0, A_GIMME, 0); + class_addfloat(transf_fader_class, (t_method)transf_fader_float); + class_addmethod(transf_fader_class, (t_method)transf_fader_pairs, gensym("pairs"), A_GIMME, 0); +// class_sethelpsymbol(transf_fader_class, gensym("iemhelp/help-transf_fader")); +} diff --git a/iemlib2/src/unsymbol.c b/iemlib2/src/unsymbol.c new file mode 100644 index 0000000..eaec6bf --- /dev/null +++ b/iemlib2/src/unsymbol.c @@ -0,0 +1,40 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + +#include "m_pd.h" +#include "iemlib.h" + +/* ----------- unsymbol ------------------------- */ +/* -- converts a symbol to an anything message -- */ + +static t_class *unsymbol_class; + +typedef struct _unsymbol +{ + t_object x_obj; + t_atom x_at; +} t_unsymbol; + +static void unsymbol_symbol(t_unsymbol *x, t_symbol *s) +{ + outlet_anything(x->x_obj.ob_outlet, s, 0, &(x->x_at)); +} + +static void *unsymbol_new(void) +{ + t_unsymbol *x = (t_unsymbol *)pd_new(unsymbol_class); + + outlet_new(&x->x_obj, &s_list); + return (x); +} + +void unsymbol_setup(void) +{ + unsymbol_class = class_new(gensym("unsymbol"), (t_newmethod)unsymbol_new, + 0, sizeof(t_unsymbol), 0, 0); + class_addcreator((t_newmethod)unsymbol_new, gensym("unsym"), 0); + class_addsymbol(unsymbol_class, unsymbol_symbol); +// class_sethelpsymbol(unsymbol_class, gensym("iemhelp/help-unsymbol")); +} diff --git a/iemlib2/src/wrap.c b/iemlib2/src/wrap.c new file mode 100644 index 0000000..748836f --- /dev/null +++ b/iemlib2/src/wrap.c @@ -0,0 +1,63 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "iemlib.h" +#include +#include +#include + +/* ------------------------ wrap ----------------- */ +/* -- leave the fractal part of a float message -- */ + +typedef struct _wrap +{ + t_object x_obj; + t_float x_f; +} t_wrap; + +static t_class *wrap_class; + +static void wrap_bang(t_wrap *x) +{ + outlet_float(x->x_obj.ob_outlet, x->x_f); +} + +static void wrap_float(t_wrap *x, t_floatarg f) +{ + int i=(int)f; + + if(f > 0.0) + x->x_f = f - (t_float)i; + else + x->x_f = f - (t_float)(i - 1); + wrap_bang(x); +} + +static void wrap_list(t_wrap *x, t_symbol *s, int argc, t_atom *argv) +{ + if((argc > 0) && (IS_A_FLOAT(argv, 0))) + wrap_float(x, atom_getfloat(argv)); +} + +static void *wrap_new(void) +{ + t_wrap *x = (t_wrap *)pd_new(wrap_class); + + outlet_new(&x->x_obj, &s_float); + x->x_f = 0.0; + return (x); +} + +void wrap_setup(void) +{ + wrap_class = class_new(gensym("wrap"), (t_newmethod)wrap_new, 0, + sizeof(t_wrap), 0, 0); + class_addbang(wrap_class, (t_method)wrap_bang); + class_addfloat(wrap_class, (t_method)wrap_float); + class_addlist(wrap_class, (t_method)wrap_list); +// class_sethelpsymbol(wrap_class, gensym("iemhelp/help-wrap")); +} diff --git a/iemlib2/stripfilename-help.pd b/iemlib2/stripfilename-help.pd new file mode 100644 index 0000000..863ed17 --- /dev/null +++ b/iemlib2/stripfilename-help.pd @@ -0,0 +1,26 @@ +#N canvas 183 294 494 268 10; +#X obj 87 75 symbol; +#X msg 87 43 abcdefghijk; +#X msg 26 59 set 2; +#X text 116 14 characters of a symbol; +#X text 10 1 stripfilename: strip the first or last; +#X obj 47 138 stripfilename -5; +#X msg 11 39 set -7; +#X obj 47 160 print; +#X text 190 92 1.arg: number of first; +#X text 227 105 or last characters to strip; +#X text 218 132 if positiv -> first; +#X text 218 144 if negativ -> last; +#X msg 40 81 set 8; +#X text 115 218 IEM KUG; +#X text 99 206 musil; +#X text 129 206 @; +#X text 135 206 iem.at; +#X text 50 195 (c) Thomas Musil 2000 - 2005; +#X text 98 228 Graz \, Austria; +#X connect 0 0 5 0; +#X connect 1 0 0 0; +#X connect 2 0 5 0; +#X connect 5 0 7 0; +#X connect 6 0 5 0; +#X connect 12 0 5 0; diff --git a/iemlib2/toggle_mess-help.pd b/iemlib2/toggle_mess-help.pd new file mode 100644 index 0000000..b140547 --- /dev/null +++ b/iemlib2/toggle_mess-help.pd @@ -0,0 +1,72 @@ +#N canvas 339 48 610 576 10; +#X obj 222 135 print color; +#X obj 138 310 print sentence; +#X obj 113 499 print number; +#X obj 48 446 tm 4 8 99 2 -77; +#X obj 40 100 toggle_mess red 178 green 333 blue -999; +#X obj 174 135 pp set; +#X msg 174 157 green; +#X obj 128 333 pp set; +#X msg 128 355 this; +#X msg 40 197 this; +#X obj 98 521 pp set; +#X msg 98 543 4; +#X msg 48 403 4; +#X obj 93 398 init set 0; +#X obj 178 42 init set 2; +#X floatatom 308 129 4 0 0 0 - - -; +#X floatatom 217 281 4 0 0 0 - - -; +#X floatatom 148 471 4 0 0 0 - - -; +#X text 8 7 toggle_mess :; +#X text 259 253 n arguments: or ; +#X text 279 329 left outlet: to message-inlet; +#X text 281 342 middle outlet: float or symbol as anything; +#X text 281 355 right outlet: float circle-index; +#X text 300 158 left inlet: from message-outlet; +#X text 300 172 set-message: initiate internal index; +#X text 301 187 bang: output without increment; +#X text 300 203 anything-message: output with; +#X text 386 217 incrementation of index; +#X msg 110 43 set 3; +#X obj 106 69 t b a; +#X obj 84 223 t b a; +#X obj 84 202 init set 1; +#X obj 93 420 t b a; +#X text 120 6 control a message-box with circular different content +; +#X msg 40 53 green; +#X obj 40 252 tm print this word by word; +#X text 305 508 IEM KUG; +#X text 289 496 musil; +#X text 319 496 @; +#X text 325 496 iem.at; +#X text 240 485 (c) Thomas Musil 2000 - 2005; +#X text 288 518 Graz \, Austria; +#X connect 3 0 12 0; +#X connect 3 1 2 0; +#X connect 3 1 10 0; +#X connect 3 2 17 0; +#X connect 4 0 34 0; +#X connect 4 1 0 0; +#X connect 4 1 5 0; +#X connect 4 2 15 0; +#X connect 5 0 6 0; +#X connect 7 0 8 0; +#X connect 9 0 35 0; +#X connect 10 0 11 0; +#X connect 12 0 3 0; +#X connect 13 0 32 0; +#X connect 14 0 29 0; +#X connect 28 0 29 0; +#X connect 29 0 4 0; +#X connect 29 1 4 0; +#X connect 30 0 35 0; +#X connect 30 1 35 0; +#X connect 31 0 30 0; +#X connect 32 0 3 0; +#X connect 32 1 3 0; +#X connect 34 0 4 0; +#X connect 35 0 9 0; +#X connect 35 1 1 0; +#X connect 35 1 7 0; +#X connect 35 2 16 0; diff --git a/iemlib2/transf_fader-help.pd b/iemlib2/transf_fader-help.pd new file mode 100644 index 0000000..f385b4e --- /dev/null +++ b/iemlib2/transf_fader-help.pd @@ -0,0 +1,33 @@ +#N canvas 69 66 633 395 10; +#X floatatom 69 56 9 0 0 0 - - -; +#X floatatom 69 214 9 0 0 0 - - -; +#X obj 69 152 transf_fader; +#X text 12 8 transf_fader; +#X text 123 9 transforms a slider range; +#X obj 493 118 vu 15 120 empty empty -1 -8 0 8 -66577 -1 1 0; +#X text 68 36 input from slider 0..147; +#X text 63 239 output to dbtorms; +#X obj 476 110 vsl 15 128 0 127 0 0 empty empty empty 0 -8 0 8 -262144 +-1 -1 0 1; +#X obj 502 262 - 100; +#X msg 103 88 pairs 0 0 6 40 24 70 36 80 48 88 60 94 72 98 96 102 108 +106 111 107.5 114 109 117 112 147 142; +#X obj 444 271 dbtorms; +#X obj 570 310 v2db; +#X obj 561 120 vu 15 120 empty empty -1 -8 0 8 -66577 -1 1 0; +#X text 160 127 pairs of break-points: input / output; +#X text 175 328 IEM KUG; +#X text 159 316 musil; +#X text 189 316 @; +#X text 195 316 iem.at; +#X text 110 305 (c) Thomas Musil 2000 - 2005; +#X text 158 338 Graz \, Austria; +#X connect 0 0 2 0; +#X connect 1 0 9 0; +#X connect 1 0 11 0; +#X connect 2 0 1 0; +#X connect 8 0 0 0; +#X connect 9 0 5 1; +#X connect 10 0 2 0; +#X connect 11 0 12 0; +#X connect 12 0 13 1; diff --git a/iemlib2/unsymbol-help.pd b/iemlib2/unsymbol-help.pd new file mode 100644 index 0000000..4414473 --- /dev/null +++ b/iemlib2/unsymbol-help.pd @@ -0,0 +1,23 @@ +#N canvas 402 159 306 245 10; +#X obj 10 71 symbol; +#X msg 10 44 blabla; +#X obj 10 99 print a; +#X obj 88 71 symbol; +#X msg 88 44 foo3; +#X obj 88 125 print b; +#X obj 158 100 unsym; +#X obj 88 100 unsymbol; +#X text 72 17 to an anything selector; +#X text 2 4 unsymbol: converts a symbol; +#X text 225 100 no arg.; +#X text 105 188 IEM KUG; +#X text 89 176 musil; +#X text 119 176 @; +#X text 125 176 iem.at; +#X text 40 165 (c) Thomas Musil 2000 - 2005; +#X text 88 198 Graz \, Austria; +#X connect 0 0 2 0; +#X connect 1 0 0 0; +#X connect 3 0 7 0; +#X connect 4 0 3 0; +#X connect 7 0 5 0; diff --git a/iemlib2/wrap-help.pd b/iemlib2/wrap-help.pd new file mode 100644 index 0000000..3237ab0 --- /dev/null +++ b/iemlib2/wrap-help.pd @@ -0,0 +1,19 @@ +#N canvas 69 66 338 328 10; +#X floatatom 40 70 9 0 0 0 - - -; +#X floatatom 40 156 9 0 0 0 - - -; +#X obj 40 92 / 100; +#X floatatom 40 115 9 0 0 0 - - -; +#X text 76 10 wraparound between 0 and +1; +#X text 78 132 no arg.; +#X obj 40 133 wrap; +#X text 11 9 wrap; +#X text 195 268 IEM KUG; +#X text 179 256 musil; +#X text 209 256 @; +#X text 215 256 iem.at; +#X text 130 245 (c) Thomas Musil 2000 - 2005; +#X text 178 278 Graz \, Austria; +#X connect 0 0 2 0; +#X connect 2 0 3 0; +#X connect 3 0 6 0; +#X connect 6 0 1 0; -- cgit v1.2.1