From de86cb7754d773a2dba3ae92eb0dfc4cb9d77cbd Mon Sep 17 00:00:00 2001 From: Hans-Christoph Steiner Date: Fri, 29 Aug 2003 13:53:51 +0000 Subject: imported latest version 1.4 direct from Olaf svn path=/trunk/externals/maxlib/; revision=898 --- help/help-allow.pd | 21 ++++ help/help-arraycopy.pd | 62 +++++++++++ help/help-deny.pd | 20 ++++ help/help-listfifo.pd | 26 +++++ help/help-maxlib.pd | 188 +++++++++++++++++++------------ help/help-nchange.pd | 31 ++++++ help/help-remote.pd | 4 +- help/help-sync.pd | 53 +++++++++ src/allow.c | 112 +++++++++++++++++++ src/arbran.c | 11 ++ src/arraycopy.c | 283 +++++++++++++++++++++++++++++++++++++++++++++++ src/average.c | 17 ++- src/beat.c | 18 ++- src/beta.c | 18 ++- src/bilex.c | 14 ++- src/borax.c | 18 ++- src/cauchy.c | 11 +- src/chord.c | 17 ++- src/delta.c | 18 ++- src/deny.c | 114 +++++++++++++++++++ src/dist.c | 17 ++- src/divide.c | 17 ++- src/divmod.c | 17 ++- src/edge.c | 17 ++- src/expo.c | 14 ++- src/fifo.c | 17 ++- src/gauss.c | 15 ++- src/gestalt.c | 18 ++- src/history.c | 23 +++- src/ignore.c | 22 ++-- src/iso.c | 54 ++++++++- src/lifo.c | 21 +++- src/limit.c | 14 ++- src/linear.c | 14 ++- src/listfifo.c | 109 ++++++++++++++++++ src/listfunnel.c | 17 ++- src/match.c | 12 +- src/minus.c | 20 +++- src/mlife.c | 25 ++++- src/multi.c | 20 +++- src/nchange.c | 205 ++++++++++++++++++++++++++++++++++ src/netclient.c | 24 +++- src/netdist.c | 32 ++++-- src/netrec.c | 28 +++-- src/netserver.c | 33 ++++-- src/nroute.c | 22 ++-- src/pitch.c | 17 ++- src/plus.c | 19 +++- src/poisson.c | 14 ++- src/pong.c | 21 ++-- src/pulse.c | 51 +++++++-- src/remote.c | 18 ++- src/rewrap.c | 20 +++- src/rhythm.c | 22 +++- src/scale.c | 15 ++- src/score.c | 26 ++++- src/speedlim.c | 14 ++- src/split.c | 18 ++- src/step.c | 19 +++- src/subst.c | 23 +++- src/sync.c | 294 +++++++++++++++++++++++++++++++++++++++++++++++++ src/temperature.c | 20 +++- src/tilt.c | 22 +++- src/timebang.c | 37 ++++++- src/triang.c | 13 ++- src/unroute.c | 19 +++- src/urn.c | 12 +- src/velocity.c | 17 ++- src/weibull.c | 13 ++- src/wrap.c | 17 ++- 70 files changed, 2352 insertions(+), 292 deletions(-) create mode 100644 help/help-allow.pd create mode 100644 help/help-arraycopy.pd create mode 100644 help/help-deny.pd create mode 100644 help/help-listfifo.pd create mode 100644 help/help-nchange.pd create mode 100644 help/help-sync.pd create mode 100644 src/allow.c create mode 100644 src/arraycopy.c create mode 100644 src/deny.c create mode 100644 src/listfifo.c create mode 100644 src/nchange.c create mode 100644 src/sync.c diff --git a/help/help-allow.pd b/help/help-allow.pd new file mode 100644 index 0000000..084d52f --- /dev/null +++ b/help/help-allow.pd @@ -0,0 +1,21 @@ +#N canvas 358 305 554 308 12; +#X text 24 17 allow :: lets only 'allowed' floats or symbols through +; +#X text 97 34 written by Olaf Matthes ; +#X msg 125 65 cat; +#X msg 147 97 dog; +#X msg 157 126 bird; +#X floatatom 82 269 5 0 0 0 - - -; +#X symbolatom 151 246 10 0 0 0 - - -; +#X obj 114 156 symbol \$1; +#X floatatom 40 81 5 0 0 0 - - -; +#X obj 82 217 route float symbol; +#X obj 82 189 allow 17 cat dog 23; +#X connect 2 0 7 0; +#X connect 3 0 7 0; +#X connect 4 0 7 0; +#X connect 7 0 10 0; +#X connect 8 0 10 0; +#X connect 9 0 5 0; +#X connect 9 1 6 0; +#X connect 10 0 9 0; diff --git a/help/help-arraycopy.pd b/help/help-arraycopy.pd new file mode 100644 index 0000000..6963c69 --- /dev/null +++ b/help/help-arraycopy.pd @@ -0,0 +1,62 @@ +#N canvas 140 43 934 584 12; +#N canvas 0 0 450 300 graph1 0; +#X array array1 20 float 1; +#A 0 0 0 0.342857 0.542857 0.6 -0.442857 -0.485714 0.0142858 -0.428571 +-0.114286 0.0857143 -0.2 -0.214285 0.314285 -0.157143 -0.314285 -0.142857 +-0.0428571 0.114286 -0.685713; +#X coords 0 1 19 -1 200 140 1; +#X restore 680 27 graph; +#N canvas 0 0 450 300 graph2 0; +#X array array2 20 float 1; +#A 0 -0.214286 -0.171429 0.1 0.614286 0.757143 0.757143 0.542857 0.2 +-0.0285714 -0.271429 -0.414286 -0.514286 -0.528571 -0.485714 -0.371429 +-0.157143 0.214286 0.557143 0.714286 0.757143; +#X coords 0 1 19 -1 200 140 1; +#X restore 681 196 graph; +#N canvas 0 0 450 300 graph3 0; +#X array array3 20 float 1; +#A 0 1.86265e-009 1.86265e-009 1.86265e-009 1.86265e-009 1.86265e-009 +-0.0142857 -0.0142857 -0.0142857 -0.0142857 -0.0142857 -0.0142857 -0.0142857 +-0.0142857 -0.0285714 -0.0285714 -0.0285714 -0.0285714 -0.0142857 -0.0142857 +-0.0142857; +#X coords 0 1 19 -1 200 140 1; +#X restore 680 371 graph; +#X obj 22 500 arraycopy array3; +#X text 339 402 set the destination array; +#X text 41 1 arraycopy :: copy data from one array to another; +#X text 146 22 written by Olaf Matthes ; +#X msg 22 109 copy array1; +#X msg 43 139 copy array1 10 15; +#X text 131 109 copy the whole array; +#X text 200 140 copy from value 10 to 15; +#X msg 60 169 copy array1 10 +5; +#X text 217 170 copy from value 10 the next 5 values; +#X msg 85 359 print \$1; +#X obj 85 333 tgl 20 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 1 +; +#X text 116 334 switch console printout on/off; +#X text 281 202 copy from value 10 to 15; +#X msg 73 201 copy array1 10 15 array2; +#X text 280 222 into array2 (starting at 0); +#X text 322 251 copy from value 10 to 15; +#X text 321 271 into array2 starting at 4; +#X msg 92 250 copy array1 10 15 array2 4; +#X msg 368 454 array3; +#X msg 86 414 bang; +#X text 137 412 perform last copy; +#X text 137 429 operation again; +#X text 20 537 creation argument: initial destination array to copy +data to; +#X obj 200 502 symbol; +#X msg 339 428 array2; +#X connect 7 0 3 0; +#X connect 8 0 3 0; +#X connect 11 0 3 0; +#X connect 13 0 3 0; +#X connect 14 0 13 0; +#X connect 17 0 3 0; +#X connect 21 0 3 0; +#X connect 22 0 27 0; +#X connect 23 0 3 0; +#X connect 27 0 3 1; +#X connect 28 0 27 0; diff --git a/help/help-deny.pd b/help/help-deny.pd new file mode 100644 index 0000000..9ca4a29 --- /dev/null +++ b/help/help-deny.pd @@ -0,0 +1,20 @@ +#N canvas 358 305 556 310 12; +#X text 97 34 written by Olaf Matthes ; +#X msg 125 65 cat; +#X msg 147 97 dog; +#X msg 157 126 bird; +#X floatatom 82 269 5 0 0 0 - - -; +#X symbolatom 151 246 10 0 0 0 - - -; +#X obj 114 156 symbol \$1; +#X floatatom 40 81 5 0 0 0 - - -; +#X obj 82 217 route float symbol; +#X obj 82 189 deny 17 cat dog 23; +#X text 32 18 deny :: blocks 'denyed' floats or symbols; +#X connect 1 0 6 0; +#X connect 2 0 6 0; +#X connect 3 0 6 0; +#X connect 6 0 9 0; +#X connect 7 0 9 0; +#X connect 8 0 4 0; +#X connect 8 1 5 0; +#X connect 9 0 8 0; diff --git a/help/help-listfifo.pd b/help/help-listfifo.pd new file mode 100644 index 0000000..a40a609 --- /dev/null +++ b/help/help-listfifo.pd @@ -0,0 +1,26 @@ +#N canvas 476 153 456 307 12; +#X floatatom 104 231 5 0 0 0 - - -; +#X msg 38 46 bang; +#X text 146 152 fifo ; +#X obj 38 152 listfifo 10; +#X text 42 14 listfifo :: first in first out buffer for lists; +#X obj 104 187 unpack f f; +#X floatatom 179 230 5 0 0 0 - - -; +#X obj 38 263 print listfifo_output; +#X text 204 185 output of listfifo; +#X msg 66 76 17.3 23; +#X obj 166 101 pack f f; +#X floatatom 166 70 5 0 0 0 - - -; +#X floatatom 225 70 5 0 0 0 - - -; +#X msg 84 125 \$1 \$2; +#X text 83 46 hit to get next number out of the fifo; +#X connect 1 0 3 0; +#X connect 3 0 5 0; +#X connect 3 0 7 0; +#X connect 5 0 0 0; +#X connect 5 1 6 0; +#X connect 9 0 3 0; +#X connect 10 0 13 0; +#X connect 11 0 10 0; +#X connect 12 0 10 1; +#X connect 13 0 3 0; diff --git a/help/help-maxlib.pd b/help/help-maxlib.pd index 663c605..dfe8564 100644 --- a/help/help-maxlib.pd +++ b/help/help-maxlib.pd @@ -1,73 +1,119 @@ -#N canvas 70 3 889 647 12; -#X obj 290 277 average; -#X obj 19 171 beat; -#X obj 19 196 borax; -#X obj 19 146 chord; -#X obj 472 491 dist; -#X obj 290 172 divide; -#X obj 290 146 divmod; -#X obj 606 171 fifo; -#X obj 290 303 history; -#X obj 17 496 ignore; -#X obj 17 470 iso; -#X obj 605 145 lifo; -#X obj 290 329 match; -#X obj 290 197 minus; -#X obj 609 261 mlife; -#X obj 290 224 multi; -#X obj 472 516 netdist; -#X obj 19 272 pitch; -#X obj 290 251 plus; -#X obj 17 418 pulse; -#X obj 472 542 remote; -#X obj 19 221 rhythm; -#X obj 19 246 score array01; -#X obj 17 444 speedlim; -#X obj 17 522 step; -#X obj 609 236 subst; -#X text 30 27 maxlib 0.8 :: Music Analysis eXtensions LIBrary; +#N canvas 11 6 1106 717 12; +#X obj 274 260 average; +#X obj 18 150 beat; +#X obj 18 175 borax; +#X obj 18 125 chord; +#X obj 15 551 dist; +#X obj 274 155 divide; +#X obj 274 129 divmod; +#X obj 599 149 fifo; +#X obj 274 286 history; +#X obj 601 503 ignore; +#X obj 601 477 iso; +#X obj 598 123 lifo; +#X obj 274 312 match; +#X obj 274 180 minus; +#X obj 600 257 mlife; +#X obj 274 207 multi; +#X obj 15 576 netdist; +#X obj 18 251 pitch; +#X obj 274 234 plus; +#X obj 601 425 pulse; +#X obj 15 600 remote; +#X obj 18 200 rhythm; +#X obj 18 225 score array01; +#X obj 601 451 speedlim; +#X obj 601 529 step; +#X obj 600 232 subst; #X text 140 44 written by Olaf Matthes ; -#X text 139 61 download at http://www.akustische-kunst.de/puredata/maxlib +#X text 71 125 chord detection; +#X text 68 150 beat tracking; +#X text 77 201 beat detection; +#X text 72 176 music analysis; +#X text 135 225 score following; +#X text 72 251 pitch information; +#X text 19 94 MUSIC / MIDI ANALYSIS; +#X text 274 93 MATH; +#X text 341 130 calculate / and %; +#X text 339 155 / for several inputs; +#X text 333 235 + for several inputs; +#X text 333 207 * for several inputs; +#X text 337 181 - for several inputs; +#X text 345 259 average of last N values; +#X text 346 285 average over last N seconds; +#X text 329 312 match input to list of numbers; +#X text 601 399 TIME; +#X text 678 452 lets input through every N milliseconds; +#X text 640 479 play sequence of MIDI notes; +#X text 662 504 ignore too fast changing input; +#X text 63 550 send to list of receive objects; +#X text 84 574 same for netreceive; +#X text 74 599 send to one receive object; +#X text 597 96 BUFFER; +#X text 648 531 a line object that steps; +#X text 599 208 OTHER / EXPERIMENTAL; +#X text 657 231 self-similar substitution; +#X text 656 257 cellular automaton; +#X obj 274 338 scale; +#X text 656 425 a 'better' metro; +#X obj 601 555 history; +#X obj 601 581 velocity; +#X text 670 555 average over last N milliseconds; +#X text 677 581 velocity of input in digits per second; +#X obj 15 624 netrec; +#X text 74 625 netreceive with extra info about sender; +#X obj 274 364 delta; +#X text 139 61 download at http://www.akustische-kunst.org/puredata/maxlib ; -#X text 72 146 chord detection; -#X text 69 171 beat tracking; -#X text 78 222 beat detection; -#X text 73 197 music analysis; -#X text 136 246 score following; -#X text 73 272 pitch information; -#X text 20 115 MUSIC / MIDI ANALYSIS; -#X text 290 110 MATH; -#X text 357 147 calculate / and %; -#X text 355 172 / for several inputs; -#X text 349 252 + for several inputs; -#X text 349 224 * for several inputs; -#X text 353 198 - for several inputs; -#X text 361 276 average of last N values; -#X text 362 302 average over last N seconds; -#X text 345 329 match input to list of numbers; -#X text 17 392 TIME; -#X text 94 445 lets input through every N milliseconds; -#X text 56 472 play sequence of MIDI notes; -#X text 78 497 ignore too fast changing input; -#X text 469 459 CONTROL; -#X text 520 490 send to list of receive objects; -#X text 541 514 same for netreceive; -#X text 531 541 send to one receive object; -#X text 604 118 BUFFER; -#X text 650 145 last in first out; -#X text 653 171 first in first out; -#X text 64 524 a line object that steps; -#X text 606 204 OTHER / EXPERIMENTAL; -#X text 666 235 self-similar substitution; -#X text 665 261 cellular automaton; -#X obj 290 355 scale; -#X text 344 356 scale input to outpur range; -#X text 72 418 a 'better' metro; -#X obj 17 548 history; -#X obj 17 574 velocity; -#X text 86 548 average over last N milliseconds; -#X text 93 574 velocity of input in digits per second; -#X obj 472 569 netrec; -#X text 531 570 netreceive with extra info about sender; -#X obj 290 381 delta; -#X text 344 381 calculate 1st or 2nd order difference; +#X obj 599 174 listfifo; +#X text 677 173 first in first out for lists; +#X text 646 148 first in first out for floats; +#X text 643 123 last in first out for floats; +#X obj 600 607 sync; +#X text 645 609 extended trigger object; +#X text 328 338 scale input to output range; +#X text 13 528 (REMOTE)CONTROL; +#X obj 16 649 netserver; +#X obj 16 676 netclient; +#X text 103 654 bidirectional communication; +#X text 112 669 (client / server based); +#X obj 274 392 wrap; +#X obj 274 419 rewrap; +#X text 320 392 warp a number in a range; +#X text 337 420 warp it back and forth; +#X text 30 26 maxlib 1.3 :: Music Analysis eXtensions LIBrary; +#X text 328 364 calculate 1st or 2nd order diff.; +#X text 600 288 RANDOM; +#X obj 600 312 gauss; +#X obj 600 337 poisson; +#X obj 666 312 linear; +#X obj 666 337 bilex; +#X obj 736 311 expo; +#X obj 785 311 beta; +#X obj 834 312 cauchy; +#X obj 737 338 arbran array01 array02; +#X obj 18 278 gestalt; +#X obj 18 303 edge; +#X text 56 306 detect rising/falling edge; +#X text 84 278 'gestalt' of music; +#X obj 599 365 urn; +#X text 632 366 urn selection model; +#X obj 601 635 timebang; +#X text 680 635 send a bang at given time of day; +#X obj 15 390 split; +#X obj 15 439 unroute; +#X text 81 440 opposit to route; +#X text 67 392 split according to range; +#X obj 15 463 limit; +#X text 63 464 limiter for floats; +#X obj 15 415 nroute; +#X text 69 416 r. according to Nth elem.; +#X text 24 363 ROUTING / CHECKING; +#X obj 600 661 pong; +#X obj 18 330 tilt; +#X obj 600 686 temperature; +#X text 698 687 amount of input changes per time; +#X text 646 662 a bouncing ball model; +#X text 66 333 meassure tilt of input; +#X obj 16 489 listfunnel; +#X text 107 490 Max's funnel for lists; diff --git a/help/help-nchange.pd b/help/help-nchange.pd new file mode 100644 index 0000000..cfcf00b --- /dev/null +++ b/help/help-nchange.pd @@ -0,0 +1,31 @@ +#N canvas 271 238 519 310 12; +#X obj 30 213 nchange f; +#X obj 371 215 nchange l; +#X msg 367 144 bla foo dog; +#X msg 387 169 bla foo 23; +#X msg 348 121 bla foo dog 17; +#X obj 200 214 nchange s; +#X obj 200 185 symbol; +#X msg 200 126 dog; +#X msg 216 153 cat; +#X obj 162 15 change; +#X obj 371 253 print list; +#X obj 200 255 print symbol; +#X msg 30 152 0; +#X msg 43 180 1; +#X obj 30 257 print float; +#X text 100 34 written by Olaf Matthes ; +#X text 12 15 nchange :: a 'new'; +#X text 22 77 The creation argument specifies whether nchange works +for floats \, symbols or lists.; +#X connect 0 0 14 0; +#X connect 1 0 10 0; +#X connect 2 0 1 0; +#X connect 3 0 1 0; +#X connect 4 0 1 0; +#X connect 5 0 11 0; +#X connect 6 0 5 0; +#X connect 7 0 6 0; +#X connect 8 0 6 0; +#X connect 12 0 0 0; +#X connect 13 0 0 0; diff --git a/help/help-remote.pd b/help/help-remote.pd index 54a7caf..6ee5b8f 100644 --- a/help/help-remote.pd +++ b/help/help-remote.pd @@ -1,4 +1,4 @@ -#N canvas 472 309 456 306 12; +#N canvas 472 309 567 308 12; #X text 9 9 remote :: send data to any receive object; #X obj 32 224 remote; #X obj 216 222 receive bla; @@ -11,6 +11,8 @@ #X text 253 91 with data of any type; #X text 89 26 written by Olaf Matthes ; #X msg 61 147 foo five is 2 more than 3; +#X msg 294 146 \; bla 17.3 23; +#X text 296 168 this does the same...; #X connect 2 0 4 0; #X connect 3 0 5 0; #X connect 6 0 1 0; diff --git a/help/help-sync.pd b/help/help-sync.pd new file mode 100644 index 0000000..d82521e --- /dev/null +++ b/help/help-sync.pd @@ -0,0 +1,53 @@ +#N canvas 142 53 830 657 12; +#X text 78 16 sync :: extended trigger object based; +#X text 143 35 on sync from jMax; +#X floatatom 18 485 5 0 0 0 - - -; +#X floatatom 39 457 5 0 0 0 - - -; +#X floatatom 61 433 5 0 0 0 - - -; +#X floatatom 18 124 5 0 0 0 - - -; +#X floatatom 39 152 5 0 0 0 - - -; +#X floatatom 61 177 5 0 0 0 - - -; +#X msg 205 143 mode any; +#X msg 187 116 mode all; +#X msg 216 169 mode left; +#X msg 229 198 mode right; +#X msg 243 226 mode none; +#X text 295 142 any input triggers the outputs; +#X text 305 169 trigger output when left inlet changes; +#X text 325 199 trigger output when right inlet changes; +#X text 333 228 never trigger output; +#X obj 18 404 sync 3; +#X text 146 415 the creation argument determines the number of inlets +/ outlets sync will have.; +#X obj 149 462 sync 23 17.3; +#X text 147 490 alternatively it's possible to specify the number of +inlets / outlets by giving initial values for every outlet. these values +will be output in case no input has been received in the corresponding +inlet until the time when the output is triggered.; +#X text 274 116 all inputs have to change to trigger output (default) +; +#X msg 223 270 trigger 2; +#X msg 230 335 require 1; +#X text 324 320 additionally another input can be defined to be required +for the trigger event to take place. i.e. the second inlet (inlet #1) +from the left must have been changed since the last triggering occured. +; +#X text 324 265 use this message to make the n-th input (counting from +0 to ) a triggering input. only one input at +a time can be triggering!; +#X text 212 90 the easy way:; +#X msg 228 299 trigger 1; +#X connect 5 0 17 0; +#X connect 6 0 17 1; +#X connect 7 0 17 2; +#X connect 8 0 17 0; +#X connect 9 0 17 0; +#X connect 10 0 17 0; +#X connect 11 0 17 0; +#X connect 12 0 17 0; +#X connect 17 0 2 0; +#X connect 17 1 3 0; +#X connect 17 2 4 0; +#X connect 22 0 17 0; +#X connect 23 0 17 0; +#X connect 27 0 17 0; diff --git a/src/allow.c b/src/allow.c new file mode 100644 index 0000000..c5d57ac --- /dev/null +++ b/src/allow.c @@ -0,0 +1,112 @@ +/* ---------------------------- allow --------------------------------------- */ +/* */ +/* Lets only floats/symbols through that are allowed to do so. */ +/* Written by Olaf Matthes */ +/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */ +/* */ +/* This program is free software; you can redistribute it and/or */ +/* modify it under the terms of the GNU General Public License */ +/* as published by the Free Software Foundation; either version 2 */ +/* of the License, or (at your option) any later version. */ +/* */ +/* This program is distributed in the hope that it will be useful, */ +/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ +/* GNU General Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License */ +/* along with this program; if not, write to the Free Software */ +/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +/* */ +/* Based on PureData by Miller Puckette and others. */ +/* */ +/* ---------------------------------------------------------------------------- */ + +#include "m_pd.h" +#include + +static char *version = "allow v0.1, written by Olaf Matthes "; + +typedef struct allow +{ + t_object x_obj; + t_outlet *x_out; + t_atom *x_elem; // list of elemets that are allowed to pass + t_int x_numelem; // the number of elemetns in our allow-list +} t_allow; + + /* we got a symbol... */ +static void allow_symbol(t_allow *x, t_symbol *s) +{ + int i; + for(i = 0; i < x->x_numelem; i++) + { + if(x->x_elem[i].a_type == A_SYMBOL) // compare with all symbols in our list + if(atom_getsymbolarg(i, x->x_numelem, x->x_elem) == s) + { + outlet_symbol(x->x_out, s); + return; + } + } +} + + /* we got a float... */ +static void allow_float(t_allow *x, t_floatarg f) +{ + int i; + for(i = 0; i < x->x_numelem; i++) + { + if(x->x_elem[i].a_type == A_FLOAT) // compare with all floats in our list + if(atom_getfloatarg(i, x->x_numelem, x->x_elem) == f) + { + outlet_float(x->x_out, f); + return; + } + } +} + +static t_class *allow_class; + +static void allow_free(t_allow *x) +{ + freebytes(x->x_elem, x->x_numelem*sizeof(t_atom)); +} + +static void *allow_new(t_symbol *s, int argc, t_atom *argv) +{ + t_allow *x = (t_allow *)pd_new(allow_class); + + x->x_numelem = argc; // get the number of elements + x->x_elem = getbytes(argc*sizeof(t_atom)); + memcpy(x->x_elem, argv, argc*sizeof(t_atom)); + + x->x_out = outlet_new(&x->x_obj, gensym("anything")); + + // post("allow: got %d elements", x->x_numelem); + + return (x); +} + +#ifndef MAXLIB +void allow_setup(void) +{ + /* the object's class: */ + allow_class = class_new(gensym("allow"), (t_newmethod)allow_new, + (t_method)allow_free, sizeof(t_allow), 0, A_GIMME, 0); +#else +void maxlib_allow_setup(void) +{ + /* the object's class: */ + allow_class = class_new(gensym("maxlib_allow"), (t_newmethod)allow_new, + (t_method)allow_free, sizeof(t_allow), 0, A_GIMME, 0); + class_addcreator((t_newmethod)allow_new, gensym("allow"), A_GIMME, 0); +#endif + class_addsymbol(allow_class, allow_symbol); + class_addfloat(allow_class, allow_float); +#ifndef MAXLIB + class_sethelpsymbol(allow_class, gensym("help-allow.pd")); + post(version); +#else + class_sethelpsymbol(allow_class, gensym("maxlib/help-allow.pd")); +#endif +} \ No newline at end of file diff --git a/src/arbran.c b/src/arbran.c index c37dee4..b4e4b2c 100644 --- a/src/arbran.c +++ b/src/arbran.c @@ -164,14 +164,25 @@ static void *rand_arbran_new(t_symbol *s1, t_symbol *s2) return (x); } +#ifndef MAXLIB void arbran_setup(void) { rand_arbran_class = class_new(gensym("arbran"), (t_newmethod)rand_arbran_new, 0, sizeof(t_rand_arbran), 0, A_SYMBOL, A_SYMBOL, 0); +#else +void maxlib_arbran_setup(void) +{ + rand_arbran_class = class_new(gensym("maxlib_arbran"), (t_newmethod)rand_arbran_new, 0, + sizeof(t_rand_arbran), 0, A_SYMBOL, A_SYMBOL, 0); +#endif class_addbang(rand_arbran_class, rand_arbran_bang); class_addmethod(rand_arbran_class, (t_method)rand_arbran_pdfscale, gensym("pdfscale"), 0); class_addmethod(rand_arbran_class, (t_method)rand_arbran_setarrays, gensym("set"), A_SYMBOL, A_SYMBOL, 0); #ifndef MAXLIB + class_sethelpsymbol(rand_arbran_class, gensym("help-arbran.pd")); post(version); +#else + class_addcreator((t_newmethod)rand_arbran_new, gensym("arbran"), A_SYMBOL, A_SYMBOL, 0); + class_sethelpsymbol(rand_arbran_class, gensym("maxlib/help-arbran.pd")); #endif } diff --git a/src/arraycopy.c b/src/arraycopy.c new file mode 100644 index 0000000..cc36913 --- /dev/null +++ b/src/arraycopy.c @@ -0,0 +1,283 @@ +/* ------------------------- arraycopy --------------------------------------- */ +/* */ +/* Copy data from one array to another . */ +/* Written by Olaf Matthes */ +/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */ +/* */ +/* This program is free software; you can redistribute it and/or */ +/* modify it under the terms of the GNU General Public License */ +/* as published by the Free Software Foundation; either version 2 */ +/* of the License, or (at your option) any later version. */ +/* */ +/* This program is distributed in the hope that it will be useful, */ +/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ +/* GNU General Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License */ +/* along with this program; if not, write to the Free Software */ +/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +/* */ +/* Based on PureData by Miller Puckette and others. */ +/* */ +/* ---------------------------------------------------------------------------- */ + +#include "m_pd.h" +#include + +static char *version = "arraycopy v0.2, written by Olaf Matthes "; + +typedef struct arraycopy +{ + t_object x_obj; + t_symbol *x_destarray; + t_symbol *x_sourcearray; + t_garray *x_destbuf; + t_garray *x_sourcebuf; + t_int x_start; + t_int x_end; + t_int x_pos; + short x_print; +} t_arraycopy; + + /* choose the destination array to copy to */ +static void arraycopy_setdestarray(t_arraycopy *x, t_symbol *s) +{ + t_garray *b; + + if ((b = (t_garray *)pd_findbyclass(s, garray_class))) + { + // post("arraycopy: destination array set to \"%s\"", s->s_name); + x->x_destbuf = b; + } else { + post("arraycopy: no array \"%s\" (error %d)", s->s_name, b); + x->x_destbuf = 0; + } +} + +static void arraycopy_setdest(t_arraycopy *x, t_symbol *s) +{ + x->x_destarray = s; + arraycopy_setdestarray(x, x->x_destarray); +} + + /* choose the source array to copy from */ +static void arraycopy_setsourcearray(t_arraycopy *x, t_symbol *s) +{ + t_garray *b; + + if ((b = (t_garray *)pd_findbyclass(s, garray_class))) + { + // post("arraycopy: source array set to \"%s\"", s->s_name); + x->x_sourcebuf = b; + } else { + post("arraycopy: no array \"%s\" (error %d)", s->s_name, b); + x->x_sourcebuf = 0; + } +} + + /* this is the routine that actually does the copying */ + /* get's called directly when we get a 'bang' */ +static void arraycopy_docopy(t_arraycopy *x) +{ + t_garray *b; /* make local copy of array */ + t_float *tab; /* the content itselfe */ + t_int items, i; + t_garray *A; + int npoints; + t_float *vec; + + if(!x->x_destarray) + { + post("arraycopy: no destination array specified"); + return; + } + if(!x->x_sourcearray) + { + post("arraycopy: no source array specified"); + return; + } + + A = x->x_destbuf; + + if ((b = (t_garray *)pd_findbyclass(x->x_sourcearray, garray_class))) + { + // post("arraycopy: source array set to \"%s\"", x->x_sourcearray->s_name); + } else { + post("arraycopy: no array \"%s\" (error %d)", x->x_sourcearray->s_name, b); + return; + } + + // read from our array + if (!garray_getfloatarray(b, &items, &tab)) + { + post("arraycopy: couldn't read from source array!"); + return; + } + + if (!(A = (t_garray *)pd_findbyclass(x->x_destarray, garray_class))) + error("arraycopy: %s: no such array", x->x_destarray->s_name); + else if (!garray_getfloatarray(A, &npoints, &vec)) + error("arraycopy: %s: bad template ", x->x_destarray->s_name); + else + { + if(x->x_start > items) // check start point + { + post("arraycopy: source start point out of range for the array given"); + return; + } + if(x->x_end) // end point is specified + { + if(x->x_end > items) // check start point + { + post("arraycopy: source end point out of range for the array given"); + x->x_end = items; + } + } + else x->x_end = items; + + if(x->x_pos) + vec += x->x_pos; + + for(i = x->x_start; i < x->x_end; i++) + { + *vec++ = tab[i]; + } + garray_redraw(A); + if(x->x_print)post("arraycopy: copied %d values from array \"%s\" to array \"%s\"", + x->x_end-x->x_start, x->x_sourcearray->s_name, x->x_destarray->s_name); + } +} + +static void arraycopy_list(t_arraycopy *x, t_symbol *s, int argc, t_atom *argv) +{ + if(argc > 1) { + x->x_sourcearray = atom_getsymbolarg(0, argc, argv); + x->x_destarray = atom_getsymbolarg(1, argc, argv); + } +} + +static void arraycopy_source(t_arraycopy *x, t_symbol *s) +{ + x->x_sourcearray = s; + x->x_start = x->x_end = x->x_pos = 0; + arraycopy_docopy(x); +} + +static void arraycopy_print(t_arraycopy *x, t_floatarg f) +{ + if(f) + x->x_print = 1; + else + x->x_print = 0; +} + +static void arraycopy_copy(t_arraycopy *x, t_symbol *s, int argc, t_atom *argv) +{ + if(argc == 1) // source array name supplied + { + x->x_sourcearray = atom_getsymbolarg(0, argc, argv); + x->x_start = x->x_end = x->x_pos = 0; + } + else if(argc == 2) // array name and start point supplied + { + x->x_sourcearray = atom_getsymbolarg(0, argc, argv); + x->x_start = atom_getfloatarg(1, argc, argv); + x->x_end = x->x_pos = 0; + } + else if(argc == 3) // arrayname and start & end point supplied + { + x->x_sourcearray = atom_getsymbolarg(0, argc, argv); + x->x_start = atom_getfloatarg(1, argc, argv); + if(argv[2].a_type == A_FLOAT) // real position + { + x->x_end = atom_getfloatarg(2, argc, argv); + } + else // offset given + { + t_symbol *offset = atom_getsymbolarg(2, argc, argv); + x->x_end = (t_int)atoi(offset->s_name) + x->x_start; + } + x->x_pos = 0; + } + else if(argc == 4) // as above & dest. array + { + x->x_sourcearray = atom_getsymbolarg(0, argc, argv); + x->x_start = atom_getfloatarg(1, argc, argv); + if(argv[2].a_type == A_FLOAT) // real position + { + x->x_end = atom_getfloatarg(2, argc, argv); + } + else // offset given + { + t_symbol *offset = atom_getsymbolarg(2, argc, argv); + x->x_end = (t_int)atoi(offset->s_name) + x->x_start; + } + x->x_destarray = atom_getsymbolarg(3, argc, argv); + arraycopy_setdestarray(x, x->x_destarray); + x->x_pos = 0; + } + else if(argc == 5) // as above & dest. array & pos. in dest. + { + x->x_sourcearray = atom_getsymbolarg(0, argc, argv); + x->x_start = atom_getfloatarg(1, argc, argv); + if(argv[2].a_type == A_FLOAT) // real position + { + x->x_end = atom_getfloatarg(2, argc, argv); + } + else // offset given + { + t_symbol *offset = atom_getsymbolarg(2, argc, argv); + x->x_end = (t_int)atoi(offset->s_name) + x->x_start; + } + x->x_destarray = atom_getsymbolarg(3, argc, argv); + arraycopy_setdestarray(x, x->x_destarray); + x->x_pos = atom_getfloatarg(4, argc, argv); + } + else post("arraycopy: copy: wrong number of arguments"); + + arraycopy_docopy(x); +} + +static t_class *arraycopy_class; + +static void *arraycopy_new(t_symbol *s, int argc, t_atom *argv) +{ + t_arraycopy *x = (t_arraycopy *)pd_new(arraycopy_class); + + if (argc > 0) { + x->x_destarray = atom_getsymbolarg(0, argc, argv); + arraycopy_setdestarray(x, x->x_destarray); + } + inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("symbol"), gensym("dest")); + x->x_start = x->x_end = x->x_pos = x->x_print = 0; + return (x); +} + +#ifndef MAXLIB +void arraycopy_setup(void) +{ + /* the object's class: */ + arraycopy_class = class_new(gensym("arraycopy"), (t_newmethod)arraycopy_new, + 0, sizeof(t_arraycopy), 0, A_GIMME, 0); +#else +void maxlib_arraycopy_setup(void) +{ + /* the object's class: */ + arraycopy_class = class_new(gensym("maxlib_arraycopy"), (t_newmethod)arraycopy_new, + 0, sizeof(t_arraycopy), 0, A_GIMME, 0); + class_addcreator((t_newmethod)arraycopy_new, gensym("arraycopy"), A_GIMME, 0); +#endif + class_addmethod(arraycopy_class, (t_method)arraycopy_copy, gensym("copy"), A_GIMME, 0); + class_addmethod(arraycopy_class, (t_method)arraycopy_print, gensym("print"), A_FLOAT, 0); + class_addmethod(arraycopy_class, (t_method)arraycopy_setdest, gensym("dest"), A_SYMBOL, 0); + class_addsymbol(arraycopy_class, arraycopy_source); + class_addbang(arraycopy_class, arraycopy_docopy); + // class_addlist(arraycopy_class, arraycopy_list); +#ifndef MAXLIB + class_sethelpsymbol(arraycopy_class, gensym("help-arraycopy.pd")); + post(version); +#else + class_sethelpsymbol(arraycopy_class, gensym("maxlib/help-arraycopy.pd")); +#endif +} \ No newline at end of file diff --git a/src/average.c b/src/average.c index f38772c..781f9d5 100644 --- a/src/average.c +++ b/src/average.c @@ -171,21 +171,32 @@ static void *average_new(t_floatarg f) x->x_inpointer = 0; x->x_average = 0; x->x_mode = 0; -#ifndef MAXLIB - post(version); -#endif return (void *)x; } +#ifndef MAXLIB void average_setup(void) { average_class = class_new(gensym("average"), (t_newmethod)average_new, (t_method)average_free, sizeof(t_average), 0, A_DEFFLOAT, 0); +#else +void maxlib_average_setup(void) +{ + average_class = class_new(gensym("maxlib_average"), (t_newmethod)average_new, + (t_method)average_free, sizeof(t_average), 0, A_DEFFLOAT, 0); +#endif class_addmethod(average_class, (t_method)average_reset, gensym("reset"), 0); class_addmethod(average_class, (t_method)average_linear, gensym("linear"), 0); class_addmethod(average_class, (t_method)average_geometric, gensym("geometric"), 0); class_addmethod(average_class, (t_method)average_weight, gensym("weight"), 0); class_addfloat(average_class, average_float); class_addmethod(average_class, (t_method)average_index, gensym("index"), A_FLOAT, 0); +#ifndef MAXLIB + post(version); + class_sethelpsymbol(average_class, gensym("help-average.pd")); +#else + class_addcreator((t_newmethod)average_new, gensym("average"), A_DEFFLOAT, 0); + class_sethelpsymbol(average_class, gensym("maxlib/help-average.pd")); +#endif } diff --git a/src/beat.c b/src/beat.c index 8a225e6..3ca552c 100644 --- a/src/beat.c +++ b/src/beat.c @@ -372,22 +372,32 @@ static void *beat_new(t_floatarg f) x->x_band_percent = 4; /* allow 4% 'jitter' by default */ if(f)x->x_band_percent = (t_int)f; -#ifndef MAXLIB - post(version); -#endif post("beat: band percentage set to %d", x->x_band_percent); return (void *)x; } +#ifndef MAXLIB void beat_setup(void) { beat_class = class_new(gensym("beat"), (t_newmethod)beat_new, (t_method)beat_free, sizeof(t_beat), 0, A_DEFFLOAT, 0); - class_addcreator((t_newmethod)beat_new, gensym("max.beat"), A_DEFFLOAT, 0); +#else +void maxlib_beat_setup(void) +{ + beat_class = class_new(gensym("maxlib_beat"), (t_newmethod)beat_new, + (t_method)beat_free, sizeof(t_beat), 0, A_DEFFLOAT, 0); +#endif class_addfloat(beat_class, beat_float); class_addmethod(beat_class, (t_method)beat_ft1, gensym("ft1"), A_FLOAT, 0); class_addmethod(beat_class, (t_method)beat_reset, gensym("reset"), 0); class_addmethod(beat_class, (t_method)beat_print, gensym("print"), 0); +#ifndef MAXLIB + class_sethelpsymbol(beat_class, gensym("help-beat.pd")); + post(version); +#else + class_addcreator((t_newmethod)beat_new, gensym("beat"), A_DEFFLOAT, 0); + class_sethelpsymbol(beat_class, gensym("maxlib/help-beat.pd")); +#endif } diff --git a/src/beta.c b/src/beta.c index bb965aa..ebc7a14 100644 --- a/src/beta.c +++ b/src/beta.c @@ -1,6 +1,6 @@ -/* ---------------------------- rand_beta ----------------------------------- */ +/* ---------------------------- rand_beta ------------------------------------- */ /* */ -/* rand_beta generates a beta distributed random variable. */ +/* rand_beta generates a beta distributed random variable. */ /* Written by Olaf Matthes (olaf.matthes@gmx.de) */ /* Based on code found in Dodge/Jerse "Computer Music" */ /* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */ @@ -86,12 +86,22 @@ static void rand_beta_bang(t_rand_beta *x) outlet_float(x->x_obj.ob_outlet, y1/sum); } +#ifndef MAXLIB void beta_setup(void) { rand_beta_class = class_new(gensym("beta"), (t_newmethod)rand_beta_new, 0, sizeof(t_rand_beta), 0, A_DEFFLOAT, A_DEFFLOAT, 0); class_addbang(rand_beta_class, rand_beta_bang); -#ifndef MAXLIB + class_sethelpsymbol(rand_beta_class, gensym("help-beta.pd")); post(version); -#endif } +#else +void maxlib_beta_setup(void) +{ + rand_beta_class = class_new(gensym("maxlib_beta"), (t_newmethod)rand_beta_new, 0, + sizeof(t_rand_beta), 0, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addbang(rand_beta_class, rand_beta_bang); + class_addcreator((t_newmethod)rand_beta_new, gensym("beta"), A_DEFFLOAT, A_DEFFLOAT, 0); + class_sethelpsymbol(rand_beta_class, gensym("maxlib/help-beta.pd")); +} +#endif \ No newline at end of file diff --git a/src/bilex.c b/src/bilex.c index ca2afd3..ed7484f 100644 --- a/src/bilex.c +++ b/src/bilex.c @@ -70,12 +70,22 @@ static void rand_bilex_bang(t_rand_bilex *x) outlet_float(x->x_obj.ob_outlet, s*log(u)/l); } +#ifndef MAXLIB void bilex_setup(void) { rand_bilex_class = class_new(gensym("bilex"), (t_newmethod)rand_bilex_new, 0, sizeof(t_rand_bilex), 0, A_DEFFLOAT, 0); class_addbang(rand_bilex_class, rand_bilex_bang); -#ifndef MAXLIB + class_sethelpsymbol(rand_bilex_class, gensym("help-bilex.pd")); post(version); -#endif } +#else +void maxlib_bilex_setup(void) +{ + rand_bilex_class = class_new(gensym("maxlib_bilex"), (t_newmethod)rand_bilex_new, 0, + sizeof(t_rand_bilex), 0, A_DEFFLOAT, 0); + class_addbang(rand_bilex_class, rand_bilex_bang); + class_addcreator((t_newmethod)rand_bilex_new, gensym("bilex"), A_DEFFLOAT, 0); + class_sethelpsymbol(rand_bilex_class, gensym("maxlib/help-bilex.pd")); +} +#endif diff --git a/src/borax.c b/src/borax.c index 151f269..a5143a9 100644 --- a/src/borax.c +++ b/src/borax.c @@ -209,20 +209,30 @@ static void *borax_new(void) x->x_timecount = 0; x->x_timeval = 0; -#ifndef MAXLIB - post(version); -#endif return (void *)x; } +#ifndef MAXLIB void borax_setup(void) { borax_class = class_new(gensym("borax"), (t_newmethod)borax_new, 0, sizeof(t_borax), 0, 0); +#else +void maxlib_borax_setup(void) +{ + borax_class = class_new(gensym("maxlib_borax"), (t_newmethod)borax_new, + 0, sizeof(t_borax), 0, 0); +#endif class_addmethod(borax_class, (t_method)borax_reset, gensym("reset"), 0); class_addmethod(borax_class, (t_method)borax_ft1, gensym("ft1"), A_FLOAT, 0); class_addmethod(borax_class, (t_method)borax_reset, gensym("ft2"), A_GIMME, 0); class_addfloat(borax_class, borax_float); - +#ifndef MAXLIB + class_sethelpsymbol(borax_class, gensym("help-borax.pd")); + post(version); +#else + class_addcreator((t_newmethod)borax_new, gensym("borax"), 0); + class_sethelpsymbol(borax_class, gensym("maxlib/help-borax.pd")); +#endif } diff --git a/src/cauchy.c b/src/cauchy.c index 82592e3..7d85321 100644 --- a/src/cauchy.c +++ b/src/cauchy.c @@ -69,12 +69,21 @@ static void rand_cauchy_bang(t_rand_cauchy *x) outlet_float(x->x_obj.ob_outlet, x->x_alpha*tan(u)); } +#ifndef MAXLIB void cauchy_setup(void) { rand_cauchy_class = class_new(gensym("cauchy"), (t_newmethod)rand_cauchy_new, 0, sizeof(t_rand_cauchy), 0, A_DEFFLOAT, 0); class_addbang(rand_cauchy_class, rand_cauchy_bang); -#ifndef MAXLIB + class_sethelpsymbol(rand_cauchy_class, gensym("help-cauchy.pd")); post(version); +#else +void maxlib_cauchy_setup(void) +{ + rand_cauchy_class = class_new(gensym("maxlib_cauchy"), (t_newmethod)rand_cauchy_new, 0, + sizeof(t_rand_cauchy), 0, A_DEFFLOAT, 0); + class_addbang(rand_cauchy_class, rand_cauchy_bang); + class_addcreator((t_newmethod)rand_cauchy_new, gensym("cauchy"), A_DEFFLOAT, 0); + class_sethelpsymbol(rand_cauchy_class, gensym("maxlib/help-cauchy.pd")); #endif } diff --git a/src/chord.c b/src/chord.c index 3244686..f0dc4a3 100644 --- a/src/chord.c +++ b/src/chord.c @@ -1785,17 +1785,28 @@ static void *chord_new(t_floatarg f) if(x->x_split == 0)x->x_split = 128; for(i = 0; i < MAX_POLY; i++)x->x_alloctable[i] = -1; -#ifndef MAXLIB - post(version); -#endif return (void *)x; } +#ifndef MAXLIB void chord_setup(void) { chord_class = class_new(gensym("chord"), (t_newmethod)chord_new, 0, sizeof(t_chord), 0, A_DEFFLOAT, 0); +#else +void maxlib_chord_setup(void) +{ + chord_class = class_new(gensym("maxlib_chord"), (t_newmethod)chord_new, + 0, sizeof(t_chord), 0, A_DEFFLOAT, 0); +#endif class_addfloat(chord_class, chord_float); class_addmethod(chord_class, (t_method)chord_ft1, gensym("ft1"), A_FLOAT, 0); +#ifndef MAXLIB + class_sethelpsymbol(chord_class, gensym("help-chord.pd")); + post(version); +#else + class_addcreator((t_newmethod)chord_new, gensym("chord"), A_DEFFLOAT, 0); + class_sethelpsymbol(chord_class, gensym("maxlib/help-chord.pd")); +#endif } diff --git a/src/delta.c b/src/delta.c index 2a509e5..7bbe19f 100644 --- a/src/delta.c +++ b/src/delta.c @@ -110,18 +110,30 @@ static void *delta_new(t_floatarg f) x->x_clearflag = 1; x->x_delta = 0; -#ifndef MAXLIB - post(version); -#endif return (void *)x; } +#ifndef MAXLIB void delta_setup(void) { delta_class = class_new(gensym("delta"), (t_newmethod)delta_new, 0, sizeof(t_delta), 0, A_DEFFLOAT, 0); +#else +void maxlib_delta_setup(void) +{ + delta_class = class_new(gensym("maxlib_delta"), (t_newmethod)delta_new, + 0, sizeof(t_delta), 0, A_DEFFLOAT, 0); +#endif class_addfloat(delta_class, delta_float); class_addbang(delta_class, (t_method)delta_bang); class_addmethod(delta_class, (t_method)delta_clear, gensym("clear"), 0); + class_sethelpsymbol(delta_class, gensym("maxlib/help-delta.pd")); +#ifndef MAXLIB + class_sethelpsymbol(delta_class, gensym("help-delta.pd")); + post(version); +#else + class_addcreator((t_newmethod)delta_new, gensym("delta"), A_DEFFLOAT, 0); + class_sethelpsymbol(delta_class, gensym("maxlib/help-delta.pd")); +#endif } diff --git a/src/deny.c b/src/deny.c new file mode 100644 index 0000000..9d0ef35 --- /dev/null +++ b/src/deny.c @@ -0,0 +1,114 @@ +/* ---------------------------- deny --------------------------------------- */ +/* */ +/* Lets only floats/symbols through that are denyed to do so. */ +/* Written by Olaf Matthes */ +/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */ +/* */ +/* This program is free software; you can redistribute it and/or */ +/* modify it under the terms of the GNU General Public License */ +/* as published by the Free Software Foundation; either version 2 */ +/* of the License, or (at your option) any later version. */ +/* */ +/* This program is distributed in the hope that it will be useful, */ +/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ +/* GNU General Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License */ +/* along with this program; if not, write to the Free Software */ +/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +/* */ +/* Based on PureData by Miller Puckette and others. */ +/* */ +/* ---------------------------------------------------------------------------- */ + +#include "m_pd.h" +#include + +static char *version = "deny v0.1, written by Olaf Matthes "; + +typedef struct deny +{ + t_object x_obj; + t_outlet *x_out; + t_atom *x_elem; // list of elemets that are denyed to pass + t_int x_numelem; // the number of elemetns in our deny-list +} t_deny; + + /* we got a symbol... */ +static void deny_symbol(t_deny *x, t_symbol *s) +{ + int i, deny = 0; + for(i = 0; i < x->x_numelem; i++) + { + if(x->x_elem[i].a_type == A_SYMBOL) // compare with all symbols in our list + if(atom_getsymbolarg(i, x->x_numelem, x->x_elem) == s) + { + deny = 1; + return; + } + } + if(!deny)outlet_symbol(x->x_out, s); +} + + /* we got a float... */ +static void deny_float(t_deny *x, t_floatarg f) +{ + int i, deny = 0; + for(i = 0; i < x->x_numelem; i++) + { + if(x->x_elem[i].a_type == A_FLOAT) // compare with all floats in our list + if(atom_getfloatarg(i, x->x_numelem, x->x_elem) == f) + { + deny = 1; // input is in deny-list + return; + } + } + if(!deny)outlet_float(x->x_out, f); +} + +static t_class *deny_class; + +static void deny_free(t_deny *x) +{ + freebytes(x->x_elem, x->x_numelem*sizeof(t_atom)); +} + +static void *deny_new(t_symbol *s, int argc, t_atom *argv) +{ + t_deny *x = (t_deny *)pd_new(deny_class); + + x->x_numelem = argc; // get the number of elements + x->x_elem = getbytes(argc*sizeof(t_atom)); + memcpy(x->x_elem, argv, argc*sizeof(t_atom)); + + x->x_out = outlet_new(&x->x_obj, gensym("anything")); + + // post("deny: got %d elements", x->x_numelem); + + return (x); +} + +#ifndef MAXLIB +void deny_setup(void) +{ + /* the object's class: */ + deny_class = class_new(gensym("deny"), (t_newmethod)deny_new, + (t_method)deny_free, sizeof(t_deny), 0, A_GIMME, 0); +#else +void maxlib_deny_setup(void) +{ + /* the object's class: */ + deny_class = class_new(gensym("maxlib_deny"), (t_newmethod)deny_new, + (t_method)deny_free, sizeof(t_deny), 0, A_GIMME, 0); + class_addcreator((t_newmethod)deny_new, gensym("deny"), A_GIMME, 0); +#endif + class_addsymbol(deny_class, deny_symbol); + class_addfloat(deny_class, deny_float); +#ifndef MAXLIB + class_sethelpsymbol(deny_class, gensym("help-deny.pd")); + post(version); +#else + class_sethelpsymbol(deny_class, gensym("maxlib/help-deny.pd")); +#endif +} \ No newline at end of file diff --git a/src/dist.c b/src/dist.c index da62d1f..e04e317 100644 --- a/src/dist.c +++ b/src/dist.c @@ -243,16 +243,20 @@ static void *dist_new(t_symbol *s, int argc, t_atom *argv) x->x_sym[i] = atom_getsymbolarg(i, argc, argv); x->x_rec++; } -#ifndef MAXLIB - post(version); -#endif return (x); } +#ifndef MAXLIB void dist_setup(void) { dist_class = class_new(gensym("dist"), (t_newmethod)dist_new, 0, sizeof(t_dist), 0, A_GIMME, 0); +#else +void maxlib_dist_setup(void) +{ + dist_class = class_new(gensym("maxlib_dist"), (t_newmethod)dist_new, 0, + sizeof(t_dist), 0, A_GIMME, 0); +#endif class_addcreator((t_newmethod)dist_new, gensym("d"), A_GIMME, 0); class_addbang(dist_class, dist_bang); class_addfloat(dist_class, dist_float); @@ -265,4 +269,11 @@ void dist_setup(void) class_addmethod(dist_class, (t_method)dist_print, gensym("print"), 0); class_addmethod(dist_class, (t_method)dist_send, gensym("send"), A_GIMME, 0); class_addanything(dist_class, dist_anything); +#ifndef MAXLIB + class_sethelpsymbol(dist_class, gensym("help-dist.pd")); + post(version); +#else + class_addcreator((t_newmethod)dist_new, gensym("dist"), A_GIMME, 0); + class_sethelpsymbol(dist_class, gensym("maxlib/help-dist.pd")); +#endif } diff --git a/src/divide.c b/src/divide.c index 40e5360..2a3bf10 100644 --- a/src/divide.c +++ b/src/divide.c @@ -82,18 +82,29 @@ static void *divide_new(t_symbol *s, t_int argc, t_atom* argv) } x->x_numvalues = i; -#ifndef MAXLIB - post(version); -#endif return (void *)x; } +#ifndef MAXLIB void divide_setup(void) { divide_class = class_new(gensym("divide"), (t_newmethod)divide_new, 0, sizeof(t_divide), 0, A_GIMME, 0); +#else +void maxlib_divide_setup(void) +{ + divide_class = class_new(gensym("maxlib_divide"), (t_newmethod)divide_new, + 0, sizeof(t_divide), 0, A_GIMME, 0); +#endif class_addfloat(divide_class, divide_float); class_addmethod(divide_class, (t_method)divide_ft1, gensym("ft1"), A_FLOAT, 0); class_addbang(divide_class, (t_method)divide_bang); +#ifndef MAXLIB + class_sethelpsymbol(divide_class, gensym("help-divide.pd")); + post(version); +#else + class_addcreator((t_newmethod)divide_new, gensym("divide"), A_GIMME, 0); + class_sethelpsymbol(divide_class, gensym("maxlib/help-divide.pd")); +#endif } diff --git a/src/divmod.c b/src/divmod.c index f84862c..ee552e7 100644 --- a/src/divmod.c +++ b/src/divmod.c @@ -72,18 +72,29 @@ static void *divmod_new(t_floatarg fl, t_floatarg fr) x->x_rightvalue = fr; x->x_leftvalue = fl; -#ifndef MAXLIB - post(version); -#endif return (void *)x; } +#ifndef MAXLIB void divmod_setup(void) { divmod_class = class_new(gensym("divmod"), (t_newmethod)divmod_new, 0, sizeof(t_divmod), 0, A_DEFFLOAT, A_DEFFLOAT, 0); +#else +void maxlib_divmod_setup(void) +{ + divmod_class = class_new(gensym("maxlib_divmod"), (t_newmethod)divmod_new, + 0, sizeof(t_divmod), 0, A_DEFFLOAT, A_DEFFLOAT, 0); +#endif class_addfloat(divmod_class, divmod_float); class_addmethod(divmod_class, (t_method)divmod_ft1, gensym("ft1"), A_FLOAT, 0); class_addbang(divmod_class, (t_method)divmod_bang); +#ifndef MAXLIB + class_sethelpsymbol(divmod_class, gensym("help-divmod.pd")); + post(version); +#else + class_addcreator((t_newmethod)divmod_new, gensym("divmod"), A_DEFFLOAT, A_DEFFLOAT, 0); + class_sethelpsymbol(divmod_class, gensym("maxlib/help-divmod.pd")); +#endif } diff --git a/src/edge.c b/src/edge.c index 308ee59..0f067a8 100644 --- a/src/edge.c +++ b/src/edge.c @@ -57,19 +57,26 @@ static void *edge_new(t_floatarg f) x->x_lastval = f; -#ifndef MAXLIB - post(version); -#endif return (void *)x; } +#ifndef MAXLIB void edge_setup(void) { edge_class = class_new(gensym("edge"), (t_newmethod)edge_new, 0, sizeof(t_edge), 0, A_DEFFLOAT, 0); class_addfloat(edge_class, edge_float); -#ifndef MAXLIB + class_sethelpsymbol(edge_class, gensym("help-edge.pd")); + post(version); +} #else -#endif +void maxlib_edge_setup(void) +{ + edge_class = class_new(gensym("maxlib_edge"), (t_newmethod)edge_new, + 0, sizeof(t_edge), 0, A_DEFFLOAT, 0); + class_addfloat(edge_class, edge_float); + class_addcreator((t_newmethod)edge_new, gensym("edge"), A_DEFFLOAT, 0); + class_sethelpsymbol(edge_class, gensym("maxlib/help-edge.pd")); } +#endif diff --git a/src/expo.c b/src/expo.c index f9c7844..7100417 100644 --- a/src/expo.c +++ b/src/expo.c @@ -65,12 +65,22 @@ static void rand_expo_bang(t_rand_expo *x) outlet_float(x->x_obj.ob_outlet, -log(u)/l); } +#ifndef MAXLIB void expo_setup(void) { rand_expo_class = class_new(gensym("expo"), (t_newmethod)rand_expo_new, 0, sizeof(t_rand_expo), 0, A_DEFFLOAT, 0); class_addbang(rand_expo_class, rand_expo_bang); -#ifndef MAXLIB + class_sethelpsymbol(rand_expo_class, gensym("help-expo.pd")); post(version); -#endif } +#else +void maxlib_expo_setup(void) +{ + rand_expo_class = class_new(gensym("maxlib_expo"), (t_newmethod)rand_expo_new, 0, + sizeof(t_rand_expo), 0, A_DEFFLOAT, 0); + class_addbang(rand_expo_class, rand_expo_bang); + class_addcreator((t_newmethod)rand_expo_new, gensym("expo"), A_DEFFLOAT, 0); + class_sethelpsymbol(rand_expo_class, gensym("maxlib/help-expo.pd")); +} +#endif \ No newline at end of file diff --git a/src/fifo.c b/src/fifo.c index 5cfab84..c0f73be 100644 --- a/src/fifo.c +++ b/src/fifo.c @@ -70,16 +70,27 @@ static void *fifo_new(t_floatarg n) x->getal = (t_float *)getbytes(x->size * sizeof(t_float)); x->out = outlet_new(&x->d_ob, gensym("float")); -#ifndef MAXLIB - post(version); -#endif return (x); } +#ifndef MAXLIB void fifo_setup(void) { fifo_class = class_new(gensym("fifo"), (t_newmethod)fifo_new, (t_method)fifo_free, sizeof(t_fifo), 0, A_DEFFLOAT, 0); class_addfloat(fifo_class, fifo_int); class_addbang(fifo_class, fifo_bang); + class_sethelpsymbol(fifo_class, gensym("help-fifo.pd")); + post(version); +} +#else +void maxlib_fifo_setup(void) +{ + fifo_class = class_new(gensym("maxlib_fifo"), (t_newmethod)fifo_new, + (t_method)fifo_free, sizeof(t_fifo), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)fifo_new, gensym("fifo"), A_DEFFLOAT, 0); + class_addfloat(fifo_class, fifo_int); + class_addbang(fifo_class, fifo_bang); + class_sethelpsymbol(fifo_class, gensym("maxlib/help-fifo.pd")); } +#endif \ No newline at end of file diff --git a/src/gauss.c b/src/gauss.c index ec81e70..2a441c4 100644 --- a/src/gauss.c +++ b/src/gauss.c @@ -66,12 +66,23 @@ static void rand_gauss_bang(t_rand_gauss *x) outlet_float(x->x_obj.ob_outlet, x->x_sigma*scale*(sum-halfN)+x->x_mu); } +#ifndef MAXLIB void gauss_setup(void) { rand_gauss_class = class_new(gensym("gauss"), (t_newmethod)rand_gauss_new, 0, sizeof(t_rand_gauss), 0, A_DEFFLOAT, A_DEFFLOAT, 0); class_addbang(rand_gauss_class, rand_gauss_bang); -#ifndef MAXLIB + class_sethelpsymbol(rand_gauss_class, gensym("help-gauss.pd")); post(version); -#endif } +#else +void maxlib_gauss_setup(void) +{ + rand_gauss_class = class_new(gensym("maxlib_gauss"), (t_newmethod)rand_gauss_new, 0, + sizeof(t_rand_gauss), 0, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)rand_gauss_new, gensym("gauss"), A_DEFFLOAT, 0); + class_addbang(rand_gauss_class, rand_gauss_bang); + class_sethelpsymbol(rand_gauss_class, gensym("maxlib/help-gauss.pd")); +} +#endif + diff --git a/src/gestalt.c b/src/gestalt.c index cd07969..650efdb 100644 --- a/src/gestalt.c +++ b/src/gestalt.c @@ -91,12 +91,10 @@ static void *gestalt_new(t_floatarg f) x->x_reftime = f; if(x->x_reftime < 1) x->x_reftime = 1; -#ifndef MAXLIB - post(version); -#endif return (void *)x; } +#ifndef MAXLIB void gestalt_setup(void) { gestalt_class = class_new(gensym("gestalt"), (t_newmethod)gestalt_new, @@ -104,5 +102,19 @@ void gestalt_setup(void) class_addfloat(gestalt_class, gestalt_float); class_addmethod(gestalt_class, (t_method)gestalt_ft1, gensym("ft1"), A_FLOAT, 0); class_addmethod(gestalt_class, (t_method)gestalt_ft2, gensym("ft2"), A_FLOAT, 0); + class_sethelpsymbol(gestalt_class, gensym("help-gestalt.pd")); + post(version); +} +#else +void maxlib_gestalt_setup(void) +{ + gestalt_class = class_new(gensym("maxlib_gestalt"), (t_newmethod)gestalt_new, + 0, sizeof(t_gestalt), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)gestalt_new, gensym("gestalt"), A_DEFFLOAT, 0); + class_addfloat(gestalt_class, gestalt_float); + class_addmethod(gestalt_class, (t_method)gestalt_ft1, gensym("ft1"), A_FLOAT, 0); + class_addmethod(gestalt_class, (t_method)gestalt_ft2, gensym("ft2"), A_FLOAT, 0); + class_sethelpsymbol(gestalt_class, gensym("maxlib/help-gestalt.pd")); } +#endif diff --git a/src/history.c b/src/history.c index 8221ad3..4f93b89 100644 --- a/src/history.c +++ b/src/history.c @@ -236,12 +236,11 @@ static void *history_new(t_floatarg f) x->x_average = 0; x->x_mode = 0; clock_delay(x->x_clock, 0); -#ifndef MAXLIB - post(version); -#endif + return (void *)x; } +#ifndef MAXLIB void history_setup(void) { history_class = class_new(gensym("history"), (t_newmethod)history_new, @@ -252,5 +251,21 @@ void history_setup(void) class_addmethod(history_class, (t_method)history_weight, gensym("weight"), 0); class_addfloat(history_class, history_float); class_addmethod(history_class, (t_method)history_time, gensym("time"), A_FLOAT, 0); + class_sethelpsymbol(history_class, gensym("help-history.pd")); + post(version); } - +#else +void maxlib_history_setup(void) +{ + history_class = class_new(gensym("maxlib_history"), (t_newmethod)history_new, + (t_method)history_free, sizeof(t_history), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)history_new, gensym("history"), A_DEFFLOAT, 0); + class_addmethod(history_class, (t_method)history_reset, gensym("reset"), 0); + class_addmethod(history_class, (t_method)history_linear, gensym("linear"), 0); + class_addmethod(history_class, (t_method)history_geometric, gensym("geometric"), 0); + class_addmethod(history_class, (t_method)history_weight, gensym("weight"), 0); + class_addfloat(history_class, history_float); + class_addmethod(history_class, (t_method)history_time, gensym("time"), A_FLOAT, 0); + class_sethelpsymbol(history_class, gensym("maxlib/help-history.pd")); +} +#endif diff --git a/src/ignore.c b/src/ignore.c index d428e50..3e3c0e7 100644 --- a/src/ignore.c +++ b/src/ignore.c @@ -24,9 +24,6 @@ #include "m_pd.h" -#define MAX_ARG 16 /* maximum number of items to ignore */ -#define IN_SIZE 32 /* size of array that stores the incoming values */ - static char *version = "ignore v0.1, written by Olaf Matthes "; typedef struct ignore @@ -90,16 +87,13 @@ static void *ignore_new(t_floatarg f) x->x_outfloat = outlet_new(&x->x_ob, gensym("float")); x->x_clock = clock_new(x, (t_method)ignore_tick); -#ifndef MAXLIB - post(version); -#endif - x->x_time = (t_int)f; x->x_lastinput = 0; return (void *)x; } +#ifndef MAXLIB void ignore_setup(void) { ignore_class = class_new(gensym("ignore"), (t_newmethod)ignore_new, @@ -107,5 +101,19 @@ void ignore_setup(void) class_addmethod(ignore_class, (t_method)ignore_reset, gensym("reset"), 0); class_addmethod(ignore_class, (t_method)ignore_time, gensym("time"), A_FLOAT, 0); class_addfloat(ignore_class, ignore_float); + class_sethelpsymbol(ignore_class, gensym("help-ignore.pd")); + post(version); +} +#else +void maxlib_ignore_setup(void) +{ + ignore_class = class_new(gensym("maxlib_ignore"), (t_newmethod)ignore_new, + (t_method)ignore_free, sizeof(t_ignore), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)ignore_new, gensym("ignore"), A_DEFFLOAT, 0); + class_addmethod(ignore_class, (t_method)ignore_reset, gensym("reset"), 0); + class_addmethod(ignore_class, (t_method)ignore_time, gensym("time"), A_FLOAT, 0); + class_addfloat(ignore_class, ignore_float); + class_sethelpsymbol(ignore_class, gensym("maxlib/help-ignore.pd")); } +#endif diff --git a/src/iso.c b/src/iso.c index f335c63..b206bb4 100644 --- a/src/iso.c +++ b/src/iso.c @@ -1,6 +1,27 @@ -/* iso.c ---- queue up pitch and attack point series */ -/* by Charlie Baker (baker@foxtrot.ccmrc.ucsb.edu) */ -/* Pd port by Olaf Matthes */ +/* ---------------------------- iso ------------------------------------------- */ +/* */ +/* Queue up pitch and attack point series. */ +/* Written by Olaf Matthes (olaf.matthes@gmx.de) */ +/* Based on iso for Max by Charlie Baker (baker@foxtrot.ccmrc.ucsb.edu). */ +/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */ +/* */ +/* This program is free software; you can redistribute it and/or */ +/* modify it under the terms of the GNU General Public License */ +/* as published by the Free Software Foundation; either version 2 */ +/* of the License, or (at your option) any later version. */ +/* */ +/* This program is distributed in the hope that it will be useful, */ +/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ +/* GNU General Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License */ +/* along with this program; if not, write to the Free Software */ +/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +/* */ +/* Based on PureData by Miller Puckette and others. */ +/* */ +/* ---------------------------------------------------------------------------- */ #include "m_pd.h" #include @@ -148,9 +169,7 @@ static void *iso_new(void) { x->pitches[0] = 60; x->atks[0] = 500; x->duty = 1.0; -#ifndef MAXLIB - post(version); -#endif + return (x); /* always return a copy of the created object */ } @@ -159,6 +178,7 @@ static void iso_free(t_iso *x) { clock_free(x->iso_clock); } +#ifndef MAXLIB void iso_setup(void) { iso_class = class_new(gensym("iso"), (t_newmethod)iso_new, @@ -174,4 +194,26 @@ void iso_setup(void) { class_addmethod(iso_class, (t_method)iso_hook, gensym("hook"), A_FLOAT, 0); class_addbang(iso_class, iso_bang); class_addlist(iso_class, iso_pitch); + class_sethelpsymbol(iso_class, gensym("help-iso.pd")); + post(version); } +#else +void maxlib_iso_setup(void) { + + iso_class = class_new(gensym("maxlib_iso"), (t_newmethod)iso_new, + (t_method)iso_free, sizeof(t_iso), 0, 0); + class_addcreator((t_newmethod)iso_new, gensym("iso"), 0); + class_addmethod(iso_class, (t_method)iso_duty, gensym("duty"), A_FLOAT, 0); + class_addmethod(iso_class, (t_method)iso_list, gensym("attack"), A_GIMME, 0); + class_addmethod(iso_class, (t_method)iso_start, gensym("start"), A_GIMME, 0); + class_addmethod(iso_class, (t_method)iso_stop, gensym("stop"), 0); + class_addmethod(iso_class, (t_method)iso_pause, gensym("pause"), 0); + class_addmethod(iso_class, (t_method)iso_loop, gensym("loop"), 0); + class_addmethod(iso_class, (t_method)iso_unloop, gensym("unloop"), 0); + class_addmethod(iso_class, (t_method)iso_resume, gensym("resume"), 0); + class_addmethod(iso_class, (t_method)iso_hook, gensym("hook"), A_FLOAT, 0); + class_addbang(iso_class, iso_bang); + class_addlist(iso_class, iso_pitch); + class_sethelpsymbol(iso_class, gensym("maxlib/help-iso.pd")); +} +#endif diff --git a/src/lifo.c b/src/lifo.c index b219fed..d2983e4 100644 --- a/src/lifo.c +++ b/src/lifo.c @@ -20,7 +20,7 @@ /* */ /* Based on PureData by Miller Puckette and others. */ /* */ -/* Fifi-code based St. Rainstick fifi.c for Max, */ +/* Fifi-code based St. Rainstick fifo.c for Max, */ /* copyright St. Rainstick, Amsterdam 1995 */ /* */ /* ---------------------------------------------------------------------------- */ @@ -78,12 +78,11 @@ static void *lifo_new(t_floatarg n) x->count = 0; x->getal = (t_float *)getbytes(x->size * sizeof(t_float)); x->out = outlet_new(&x->d_ob, gensym("float")); -#ifndef MAXLIB - post(version); -#endif + return (x); } +#ifndef MAXLIB void lifo_setup(void) { lifo_class = class_new(gensym("lifo"), (t_newmethod)lifo_new, @@ -91,4 +90,18 @@ void lifo_setup(void) class_addfloat(lifo_class, lifo_int); class_addbang(lifo_class, lifo_bang); class_addmethod(lifo_class, (t_method)lifo_clear, gensym("clear"), 0); + class_sethelpsymbol(lifo_class, gensym("help-lifo.pd")); + post(version); +} +#else +void maxlib_lifo_setup(void) +{ + lifo_class = class_new(gensym("maxlib_lifo"), (t_newmethod)lifo_new, + (t_method)lifo_free, sizeof(t_lifo), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)lifo_new, gensym("lifo"), A_DEFFLOAT, 0); + class_addfloat(lifo_class, lifo_int); + class_addbang(lifo_class, lifo_bang); + class_addmethod(lifo_class, (t_method)lifo_clear, gensym("clear"), 0); + class_sethelpsymbol(lifo_class, gensym("maxlib/help-lifo.pd")); } +#endif \ No newline at end of file diff --git a/src/limit.c b/src/limit.c index e4d22e2..9d14f1d 100644 --- a/src/limit.c +++ b/src/limit.c @@ -98,20 +98,28 @@ static void *limit_new(t_floatarg fol, t_floatarg foh, t_floatarg fr) x->x_ratio = fr; x->x_f = 0; -#ifndef MAXLIB - post(version); -#endif return (void *)x; } +#ifndef MAXLIB void limit_setup(void) { limit_class = class_new(gensym("limit"), (t_newmethod)limit_new, 0, sizeof(t_limit), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); +#else +void maxlib_limit_setup(void) +{ + limit_class = class_new(gensym("maxlib_limit"), (t_newmethod)limit_new, + 0, sizeof(t_limit), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)limit_new, gensym("limit"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); +#endif class_addfloat(limit_class, limit_float); class_addbang(limit_class, limit_bang); #ifndef MAXLIB + class_sethelpsymbol(limit_class, gensym("help-limit.pd")); + post(version); #else + class_sethelpsymbol(limit_class, gensym("maxlib/help-limit.pd")); #endif } diff --git a/src/linear.c b/src/linear.c index 1f86c7d..a5869a2 100644 --- a/src/linear.c +++ b/src/linear.c @@ -60,12 +60,22 @@ static void rand_linear_bang(t_rand_linear *x) outlet_float(x->x_obj.ob_outlet, u1); } +#ifndef MAXLIB void linear_setup(void) { rand_linear_class = class_new(gensym("linear"), (t_newmethod)rand_linear_new, 0, sizeof(t_rand_linear), 0, A_DEFFLOAT, 0); class_addbang(rand_linear_class, rand_linear_bang); -#ifndef MAXLIB + class_sethelpsymbol(rand_linear_class, gensym("help-linear.pd")); post(version); -#endif } +#else +void maxlib_linear_setup(void) +{ + rand_linear_class = class_new(gensym("maxlib_linear"), (t_newmethod)rand_linear_new, 0, + sizeof(t_rand_linear), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)rand_linear_new, gensym("linear"), A_DEFFLOAT, 0); + class_addbang(rand_linear_class, rand_linear_bang); + class_sethelpsymbol(rand_linear_class, gensym("maxlib/help-linear.pd")); +} +#endif \ No newline at end of file diff --git a/src/listfifo.c b/src/listfifo.c new file mode 100644 index 0000000..dda9eeb --- /dev/null +++ b/src/listfifo.c @@ -0,0 +1,109 @@ +/* ---------------------------- listfifo -------------------------------------- */ +/* */ +/* Fifo buffer of lists, empties itselfe on every bang (in order of coming in) */ +/* Written by Olaf Matthes (olaf.matthes@gmx.de) */ +/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */ +/* */ +/* This program is free software; you can redistribute it and/or */ +/* modify it under the terms of the GNU General Public License */ +/* as published by the Free Software Foundation; either version 2 */ +/* of the License, or (at your option) any later version. */ +/* */ +/* This program is distributed in the hope that it will be useful, */ +/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ +/* GNU General Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License */ +/* along with this program; if not, write to the Free Software */ +/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +/* */ +/* Based on PureData by Miller Puckette and others. */ +/* */ +/* ---------------------------------------------------------------------------- */ + +#include "m_pd.h" + +#define MAX_ELEM 256 /* maximum number of list elements to pass on */ + +static char *version = "listfifo v0.1, written by Olaf Matthes "; + +typedef struct listfifo +{ + t_object d_ob; + t_atom *getal; /* stores the list values */ + t_int *getsize; /* stores the number of elements in list */ + t_int count, end, size; + t_outlet *out; + +}t_listfifo; + +static t_class *listfifo_class; + +static void listfifo_list(t_listfifo *x, t_symbol *s, int argc, t_atom *argv) +{ + int i; + if(argc > MAX_ELEM) + { + post("listfifo: to many arguments in list, ignored"); + return; + } + for(i = 0; i < argc; i++) + x->getal[(x->count * MAX_ELEM) + i] = argv[i]; + x->getsize[x->count] = argc; + x->count = (x->count + 1) % x->size; + // post("got %d elements", argc); +} + +static void listfifo_bang(t_listfifo *x) +{ + // post("count = %d, end = %d", x->count, x->end); + if (x->end != x->count){ + outlet_list(x->out, NULL, x->getsize[x->end], x->getal+(x->end * MAX_ELEM)); + x->end = (x->end + 1) % x->size; + } +} + +static void listfifo_free(t_listfifo *x) +{ + freebytes(x->getsize, x->size * sizeof(t_int)); + freebytes(x->getal, x->size * sizeof(t_float) * MAX_ELEM); +} + +static void *listfifo_new(t_floatarg n) +{ + int i; + + t_listfifo *x = (t_listfifo *)pd_new(listfifo_class); + if (n<10) n = 10; + x->size = (t_int)n; + x->end = 0; + x->count = 0; + x->getsize = (t_int *)getbytes(x->size * sizeof(t_int)); + x->getal = (t_atom *)getbytes(x->size * sizeof(t_atom) * MAX_ELEM); + x->out = outlet_new(&x->d_ob, gensym("list")); + + return (x); +} + +#ifndef MAXLIB +void listfifo_setup(void) +{ + listfifo_class = class_new(gensym("listfifo"), (t_newmethod)listfifo_new, + (t_method)listfifo_free, sizeof(t_listfifo), 0, A_DEFFLOAT, 0); + class_addbang(listfifo_class, listfifo_bang); + class_addlist(listfifo_class, listfifo_list); + class_sethelpsymbol(listfifo_class, gensym("help-listfifo.pd")); + post(version); +} +#else +void maxlib_listfifo_setup(void) +{ + listfifo_class = class_new(gensym("maxlib_listfifo"), (t_newmethod)listfifo_new, + (t_method)listfifo_free, sizeof(t_listfifo), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)listfifo_new, gensym("listfifo"), A_DEFFLOAT, 0); + class_addbang(listfifo_class, listfifo_bang); + class_addlist(listfifo_class, listfifo_list); + class_sethelpsymbol(listfifo_class, gensym("maxlib/help-listfifo.pd")); +} +#endif \ No newline at end of file diff --git a/src/listfunnel.c b/src/listfunnel.c index a31b4ee..d9ba656 100644 --- a/src/listfunnel.c +++ b/src/listfunnel.c @@ -65,17 +65,28 @@ static void *listfunnel_new(void) t_listfunnel *x = (t_listfunnel *)pd_new(listfunnel_class); x->x_outlet = outlet_new(&x->x_ob, gensym("float")); -#ifndef MAXLIB - post(version); -#endif return (void *)x; } +#ifndef MAXLIB void listfunnel_setup(void) { listfunnel_class = class_new(gensym("listfunnel"), (t_newmethod)listfunnel_new, 0, sizeof(t_listfunnel), 0, 0, 0); class_addfloat(listfunnel_class, listfunnel_float); class_addlist(listfunnel_class, listfunnel_list); + class_sethelpsymbol(listfunnel_class, gensym("help-listfunnel.pd")); + post(version); } +#else +void maxlib_listfunnel_setup(void) +{ + listfunnel_class = class_new(gensym("maxlib_listfunnel"), (t_newmethod)listfunnel_new, + 0, sizeof(t_listfunnel), 0, 0, 0); + class_addcreator((t_newmethod)listfunnel_new, gensym("listfunnel"), 0); + class_addfloat(listfunnel_class, listfunnel_float); + class_addlist(listfunnel_class, listfunnel_list); + class_sethelpsymbol(listfunnel_class, gensym("maxlib/help-listfunnel.pd")); +} +#endif diff --git a/src/match.c b/src/match.c index 6fb7933..623ca87 100644 --- a/src/match.c +++ b/src/match.c @@ -29,11 +29,9 @@ * For information on usage and redistribution, and for a DISCLAIMER OF ALL * WARRANTIES, see the file, "LICENSE.txt," in this distribution. */ -/* LATER compare with match.c from max sdk */ #include #include "m_pd.h" -// #include "hammer.h" #define MATCH_INISIZE 16 /* LATER rethink */ @@ -250,10 +248,18 @@ static void *match_new(t_symbol *s, int ac, t_atom *av) return (x); } +#ifndef MAXLIB void match_setup(void) { match_class = class_new(gensym("match"), (t_newmethod)match_new, (t_method)match_free, sizeof(t_match), 0, A_GIMME, 0); +#else +void maxlib_match_setup(void) +{ + match_class = class_new(gensym("maxlib_match"), (t_newmethod)match_new, + (t_method)match_free, sizeof(t_match), 0, A_GIMME, 0); + class_addcreator((t_newmethod)match_new, gensym("match"), A_GIMME, 0); +#endif class_addfloat(match_class, match_float); class_addsymbol(match_class, match_symbol); class_addlist(match_class, match_list); @@ -261,6 +267,8 @@ void match_setup(void) class_addmethod(match_class, (t_method)match_set, gensym("set"), A_GIMME, 0); class_addmethod(match_class, (t_method)match_clear, gensym("clear"), 0); #ifndef MAXLIB + class_sethelpsymbol(match_class, gensym("help-match.pd")); #else + class_sethelpsymbol(match_class, gensym("maxlib/help-match.pd")); #endif } diff --git a/src/minus.c b/src/minus.c index 17db861..596ee10 100644 --- a/src/minus.c +++ b/src/minus.c @@ -82,12 +82,11 @@ static void *minus_new(t_symbol *s, t_int argc, t_atom* argv) x->x_minusvalue[i] = atom_getfloatarg(i, argc, argv); } x->x_numvalues = i; -#ifndef MAXLIB - post(version); -#endif + return (void *)x; } +#ifndef MAXLIB void minus_setup(void) { minus_class = class_new(gensym("minus"), (t_newmethod)minus_new, @@ -95,5 +94,18 @@ void minus_setup(void) class_addfloat(minus_class, minus_float); class_addmethod(minus_class, (t_method)minus_ft1, gensym("ft1"), A_FLOAT, 0); class_addbang(minus_class, (t_method)minus_bang); + class_sethelpsymbol(minus_class, gensym("help-minus.pd")); + post(version); } - +#else +void maxlib_minus_setup(void) +{ + minus_class = class_new(gensym("maxlib_minus"), (t_newmethod)minus_new, + 0, sizeof(t_minus), 0, A_GIMME, 0); + class_addcreator((t_newmethod)minus_new, gensym("minus"), A_GIMME, 0); + class_addfloat(minus_class, minus_float); + class_addmethod(minus_class, (t_method)minus_ft1, gensym("ft1"), A_FLOAT, 0); + class_addbang(minus_class, (t_method)minus_bang); + class_sethelpsymbol(minus_class, gensym("maxlib/help-minus.pd")); +} +#endif diff --git a/src/mlife.c b/src/mlife.c index 66243ef..47960dd 100644 --- a/src/mlife.c +++ b/src/mlife.c @@ -460,9 +460,6 @@ static void *ml_new(t_floatarg size, t_floatarg view_start, t_floatarg view_size post("mlife: INTSIZE=%ld, LONGSIZE=%ld", (long)INTSIZE, (long)LONGSIZE); #endif -#ifndef MAXLIB - post(version); -#endif post("mlife: defaults are: lo=%ld, hi=%ld, nset=%ld", (long)DEFAULT_DIE_LO, (long)DEFAULT_DIE_HI, DEFAULT_N_SIZE); return(mlp); // always return a copy of the created object @@ -479,6 +476,7 @@ static void ml_free(t_maxlife *mlp) freeobject(mlp->out[i]); */ } +#ifndef MAXLIB void mlife_setup(void) { mlife_class = class_new(gensym("mlife"), (t_newmethod)ml_new, @@ -493,4 +491,25 @@ void mlife_setup(void) class_addmethod(mlife_class, (t_method)ml_display, gensym("display"), 0); class_addfloat(mlife_class, ml_int); class_addbang(mlife_class, ml_bang); + class_sethelpsymbol(mlife_class, gensym("help-mlife.pd")); + post(version); +} +#else +void maxlib_mlife_setup(void) +{ + mlife_class = class_new(gensym("maxlib_mlife"), (t_newmethod)ml_new, + (t_method)ml_free, sizeof(t_maxlife), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)ml_new, gensym("mlife"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(mlife_class, (t_method)ml_randfill, gensym("randfill"), 0); + class_addmethod(mlife_class, (t_method)ml_fill, gensym("fill"), A_FLOAT, 0); + class_addmethod(mlife_class, (t_method)ml_set_die_lo, gensym("lo"), A_FLOAT, 0); + class_addmethod(mlife_class, (t_method)ml_set_die_hi, gensym("hi"), A_FLOAT, 0); + class_addmethod(mlife_class, (t_method)ml_set_neighbourhood, gensym("nset"), A_FLOAT, 0); + class_addmethod(mlife_class, (t_method)ml_randseed, gensym("randseed"), A_FLOAT, 0); + class_addmethod(mlife_class, (t_method)ml_seed, gensym("seed"), A_FLOAT, A_FLOAT, 0); + class_addmethod(mlife_class, (t_method)ml_display, gensym("display"), 0); + class_addfloat(mlife_class, ml_int); + class_addbang(mlife_class, ml_bang); + class_sethelpsymbol(mlife_class, gensym("maxlib/help-mlife.pd")); } +#endif \ No newline at end of file diff --git a/src/multi.c b/src/multi.c index 543ffa3..2f5db67 100644 --- a/src/multi.c +++ b/src/multi.c @@ -81,12 +81,11 @@ static void *multi_new(t_symbol *s, t_int argc, t_atom* argv) x->x_multivalue[i] = atom_getfloatarg(i, argc, argv);; } x->x_numvalues = i; -#ifndef MAXLIB - post(version); -#endif + return (void *)x; } +#ifndef MAXLIB void multi_setup(void) { multi_class = class_new(gensym("multi"), (t_newmethod)multi_new, @@ -94,5 +93,18 @@ void multi_setup(void) class_addfloat(multi_class, multi_float); class_addmethod(multi_class, (t_method)multi_ft1, gensym("ft1"), A_FLOAT, 0); class_addbang(multi_class, (t_method)multi_bang); + class_sethelpsymbol(multi_class, gensym("help-multi.pd")); + post(version); } - +#else +void maxlib_multi_setup(void) +{ + multi_class = class_new(gensym("maxlib_multi"), (t_newmethod)multi_new, + 0, sizeof(t_multi), 0, A_GIMME, 0); + class_addcreator((t_newmethod)multi_new, gensym("multi"), A_GIMME, 0); + class_addfloat(multi_class, multi_float); + class_addmethod(multi_class, (t_method)multi_ft1, gensym("ft1"), A_FLOAT, 0); + class_addbang(multi_class, (t_method)multi_bang); + class_sethelpsymbol(multi_class, gensym("maxlib/help-multi.pd")); +} +#endif diff --git a/src/nchange.c b/src/nchange.c new file mode 100644 index 0000000..a7e7eb5 --- /dev/null +++ b/src/nchange.c @@ -0,0 +1,205 @@ +/* ------------------------- ignore ------------------------------------------- */ +/* */ +/* A 'new' change object for more than just floats. */ +/* Written by Olaf Matthes */ +/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */ +/* */ +/* This program is free software; you can redistribute it and/or */ +/* modify it under the terms of the GNU General Public License */ +/* as published by the Free Software Foundation; either version 2 */ +/* of the License, or (at your option) any later version. */ +/* */ +/* This program is distributed in the hope that it will be useful, */ +/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ +/* GNU General Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License */ +/* along with this program; if not, write to the Free Software */ +/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +/* */ +/* Based on PureData by Miller Puckette and others. */ +/* */ +/* ---------------------------------------------------------------------------- */ + +#define A_LIST 254; +#define A_ANYTHING 255; + +#include "m_pd.h" + +// #include +// #include + +/* -------------------------- nchange ------------------------------ */ +static char *version = "nchange v0.1, written by Olaf Matthes "; + +static t_class *nchange_class; + +typedef struct _nchange +{ + t_object x_obj; + t_atom x_a[256]; + int x_c; + int x_type; +} t_nchange; + +static void *nchange_new(t_symbol *s) +{ + int i; + + t_nchange *x = (t_nchange *)pd_new(nchange_class); + + if(s == gensym("s")) + { + x->x_type = A_SYMBOL; + outlet_new(&x->x_obj, &s_symbol); + } + else if(s == gensym("f")) + { + x->x_type = A_FLOAT; + outlet_new(&x->x_obj, &s_float); + } + else if(s == gensym("l")) + { + x->x_type = A_LIST; + outlet_new(&x->x_obj, &s_list); + } + else + { + x->x_type = A_ANYTHING; + outlet_new(&x->x_obj, &s_anything); + } + + return (x); +} + +static void nchange_bang(t_nchange *x) +{ + if (x->x_type == A_FLOAT) + outlet_float(x->x_obj.ob_outlet, x->x_a->a_w.w_float); + else if (x->x_type == A_SYMBOL) + outlet_symbol(x->x_obj.ob_outlet, x->x_a->a_w.w_symbol); + else + outlet_list(x->x_obj.ob_outlet, NULL, x->x_c, x->x_a); +} + +static void nchange_float(t_nchange *x, t_float f) +{ + if (x->x_type == A_FLOAT) + { + if (f != x->x_a->a_w.w_float) + { + // x->x_f = f; + SETFLOAT(x->x_a, f); + outlet_float(x->x_obj.ob_outlet, x->x_a->a_w.w_float); + } + } +} + +static void nchange_symbol(t_nchange *x, t_symbol *s) +{ + if (x->x_type == A_SYMBOL) + { + if (s != x->x_a->a_w.w_symbol) + { + // x->x_s = s; + SETSYMBOL(x->x_a, s); + outlet_symbol(x->x_obj.ob_outlet, x->x_a->a_w.w_symbol); + } + } +} + +static void nchange_list(t_nchange *x, t_symbol *s, int argc, t_atom *argv) +{ + int i, change = 0; + int c = argc; + + if(c == x->x_c) // same number of elements + for (i = 0; i < c; i++) + { + /* if(x->x_a[i].a_type != argv[i].a_type) + { + change = 1; + break; + } */ + if (x->x_a[i].a_type == A_FLOAT) + { + if (argv[i].a_type != A_FLOAT || x->x_a[i].a_w.w_float != argv[i].a_w.w_float) + { + change = 1; + break; + } + } + else if (x->x_a[i].a_type == A_SYMBOL) + { + if (argv[i].a_type != A_SYMBOL || x->x_a[i].a_w.w_symbol != argv[i].a_w.w_symbol) + { + change = 1; + break; + } + } + } + else change = 1; // different number of elems. + + if (change) + { + x->x_c = c; + for (i = 0; i < c; i++) // same new list + { + x->x_a[i] = argv[i]; + } + outlet_list(x->x_obj.ob_outlet, s, argc, argv); + } +} + +static void nchange_set(t_nchange *x, t_symbol *s, int argc, t_atom *argv) +{ + int i; + + if (x->x_type == A_SYMBOL) + { + SETSYMBOL(x->x_a, argv->a_w.w_symbol); + } + else if (x->x_type == A_FLOAT) + { + SETFLOAT(x->x_a, argv->a_w.w_float); + } + else // list or anything + { + x->x_c = argc; + for (i = 0; i < argc; i++) + { + x->x_a[i] = argv[i]; + } + } +} + +#ifndef MAXLIB +void nchange_setup(void) +{ + nchange_class = class_new(gensym("nchange"), (t_newmethod)nchange_new, 0, + sizeof(t_nchange), 0, A_SYMBOL, 0); + class_addbang(nchange_class, nchange_bang); + class_addfloat(nchange_class, nchange_float); + class_addsymbol(nchange_class, nchange_symbol); + class_addlist(nchange_class, nchange_list); + class_addanything(nchange_class, nchange_list); + class_addmethod(nchange_class, (t_method)nchange_set, gensym("set"), A_GIMME, 0); + class_sethelpsymbol(nchange_class, gensym("help-nchange.pd")); + post(version); +} +#else +void maxlib_nchange_setup(void) +{ + nchange_class = class_new(gensym("maxlib_nchange"), (t_newmethod)nchange_new, 0, + sizeof(t_nchange), 0, A_SYMBOL, 0); + class_addcreator((t_newmethod)nchange_new, gensym("nchange"), A_SYMBOL, 0); + class_addbang(nchange_class, nchange_bang); + class_addfloat(nchange_class, nchange_float); + class_addsymbol(nchange_class, nchange_symbol); + class_addlist(nchange_class, nchange_list); + class_addanything(nchange_class, nchange_list); + class_addmethod(nchange_class, (t_method)nchange_set, gensym("set"), A_GIMME, 0); + class_sethelpsymbol(nchange_class, gensym("maxlib/help-nchange.pd")); +} +#endif \ No newline at end of file diff --git a/src/netclient.c b/src/netclient.c index 6e71e59..406ae19 100644 --- a/src/netclient.c +++ b/src/netclient.c @@ -29,7 +29,7 @@ #include #include #include -#if defined(UNIX) || defined(unix) +#ifdef UNIX #include #include #include @@ -71,7 +71,7 @@ static void sys_sockerror(char *s) int err = WSAGetLastError(); if (err == 10054) return; #endif -#if defined(UNIX) || defined(unix) +#ifdef UNIX int err = errno; #endif post("%s: %s (%d)\n", s, strerror(err), err); @@ -79,7 +79,7 @@ static void sys_sockerror(char *s) static void sys_closesocket(int fd) { -#if defined(UNIX) || defined(unix) +#ifdef UNIX close(fd); #endif #ifdef NT @@ -334,6 +334,7 @@ static void netclient_free(t_netclient *x) clock_free(x->x_clock); } +#ifndef MAXLIB void netclient_setup(void) { netclient_class = class_new(gensym("netclient"), (t_newmethod)netclient_new, @@ -344,4 +345,21 @@ void netclient_setup(void) class_addmethod(netclient_class, (t_method)netclient_send, gensym("send"), A_GIMME, 0); class_addmethod(netclient_class, (t_method)netclient_rcv, gensym("receive"), 0); class_addmethod(netclient_class, (t_method)netclient_rcv, gensym("rcv"), 0); + class_sethelpsymbol(netclient_class, gensym("help-netclient.pd")); + post(version); } +#else +void maxlib_netclient_setup(void) +{ + netclient_class = class_new(gensym("maxlib_netclient"), (t_newmethod)netclient_new, + (t_method)netclient_free, + sizeof(t_netclient), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)netclient_new, gensym("netclient"), A_DEFFLOAT, 0); + class_addmethod(netclient_class, (t_method)netclient_connect, gensym("connect"), A_SYMBOL, A_FLOAT, 0); + class_addmethod(netclient_class, (t_method)netclient_disconnect, gensym("disconnect"), 0); + class_addmethod(netclient_class, (t_method)netclient_send, gensym("send"), A_GIMME, 0); + class_addmethod(netclient_class, (t_method)netclient_rcv, gensym("receive"), 0); + class_addmethod(netclient_class, (t_method)netclient_rcv, gensym("rcv"), 0); + class_sethelpsymbol(netclient_class, gensym("maxlib/help-netclient.pd")); +} +#endif \ No newline at end of file diff --git a/src/netdist.c b/src/netdist.c index 0c7e55c..a585734 100644 --- a/src/netdist.c +++ b/src/netdist.c @@ -29,7 +29,7 @@ #include #include #include -#if defined(UNIX) || defined(unix) +#ifdef UNIX #include #include #include @@ -67,7 +67,7 @@ static void sys_sockerror(char *s) int err = WSAGetLastError(); if (err == 10054) return; #endif -#if defined(UNIX) || defined(unix) +#ifdef UNIX int err = errno; #endif post("%s: %s (%d)\n", s, strerror(err), err); @@ -75,7 +75,7 @@ static void sys_sockerror(char *s) static void sys_closesocket(int fd) { -#if defined(UNIX) || defined(unix) +#ifdef UNIX close(fd); #endif #ifdef NT @@ -98,10 +98,8 @@ static void *netdist_new(t_floatarg udpflag) for(i = 0; i < MAX_REC; i++)x->x_fd[i] = -1; x->x_numconnect = -1; x->x_protocol = (udpflag != 0 ? SOCK_DGRAM : SOCK_STREAM); -#ifndef MAXLIB - post(version); -#endif - /* prepare child thread */ + + /* prepare child thread */ if(pthread_attr_init(&x->x_threadattr) < 0) post("netdist: warning: could not prepare child thread" ); if(pthread_attr_setdetachstate(&x->x_threadattr, PTHREAD_CREATE_DETACHED) < 0) @@ -288,6 +286,7 @@ static void netdist_free(t_netdist *x) clock_free(x->x_clock); } +#ifndef MAXLIB void netdist_setup(void) { netdist_class = class_new(gensym("netdist"), (t_newmethod)netdist_new, @@ -297,7 +296,20 @@ void netdist_setup(void) class_addmethod(netdist_class, (t_method)netdist_send, gensym("send"), A_GIMME, 0); class_addmethod(netdist_class, (t_method)netdist_clear, gensym("clear"), 0); class_addmethod(netdist_class, (t_method)netdist_print, gensym("print"), 0); + class_sethelpsymbol(netdist_class, gensym("help-netdist.pd")); + post(version); } - - - +#else +void maxlib_netdist_setup(void) +{ + netdist_class = class_new(gensym("maxlib_netdist"), (t_newmethod)netdist_new, + (t_method)netdist_free, sizeof(t_netdist), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)netdist_new, gensym("netdist"), A_DEFFLOAT, 0); + class_addmethod(netdist_class, (t_method)netdist_connect, gensym("connect"), A_SYMBOL, A_FLOAT, 0); + class_addmethod(netdist_class, (t_method)netdist_disconnect, gensym("disconnect"), A_SYMBOL, A_FLOAT, 0); + class_addmethod(netdist_class, (t_method)netdist_send, gensym("send"), A_GIMME, 0); + class_addmethod(netdist_class, (t_method)netdist_clear, gensym("clear"), 0); + class_addmethod(netdist_class, (t_method)netdist_print, gensym("print"), 0); + class_sethelpsymbol(netdist_class, gensym("maxlib/help-netdist.pd")); +} +#endif diff --git a/src/netrec.c b/src/netrec.c index d409140..c747736 100644 --- a/src/netrec.c +++ b/src/netrec.c @@ -22,14 +22,11 @@ /* */ /* ---------------------------------------------------------------------------- */ +#ifndef PD_0_36 #include "m_pd.h" - -#if defined(PD_VERSION) && (PD_MAJOR_VERSION >= 0 && PD_MINOR_VERSION > 36) -#include -#include -#else -#include "m_imp.h" +#include "s_stuff.h" #endif +#include "m_imp.h" #include #include @@ -38,7 +35,7 @@ #include #include #include -#if defined(UNIX) || defined(unix) +#ifdef UNIX #include #include #include @@ -416,9 +413,7 @@ static void *netrec_new(t_symbol *compatflag, x->x_nconnections = 0; x->x_udp = udp; for(i = 0; i < MAX_CONNECT; i++)x->x_fd[i] = -1; -#ifndef MAXLIB - post(version); -#endif + return (x); } @@ -433,9 +428,22 @@ static void netrec_free(t_netrec *x) binbuf_free(inbinbuf); } +#ifndef MAXLIB void netrec_setup(void) { netrec_class = class_new(gensym("netrec"),(t_newmethod)netrec_new, (t_method)netrec_free, sizeof(t_netrec), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFSYM, 0); class_addmethod(netrec_class, (t_method)netrec_print, gensym("print"), 0); + class_sethelpsymbol(netrec_class, gensym("help-netrec.pd")); + post(version); +} +#else +void maxlib_netrec_setup(void) +{ + netrec_class = class_new(gensym("maxlib_netrec"),(t_newmethod)netrec_new, (t_method)netrec_free, + sizeof(t_netrec), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFSYM, 0); + class_addcreator((t_newmethod)netrec_new, gensym("netrec"), A_DEFFLOAT, A_DEFFLOAT, A_DEFSYM, 0); + class_addmethod(netrec_class, (t_method)netrec_print, gensym("print"), 0); + class_sethelpsymbol(netrec_class, gensym("maxlib/help-netrec.pd")); } +#endif \ No newline at end of file diff --git a/src/netserver.c b/src/netserver.c index 71447b4..c8e22f6 100644 --- a/src/netserver.c +++ b/src/netserver.c @@ -23,14 +23,11 @@ /* */ /* ---------------------------------------------------------------------------- */ -#include -#if defined(PD_VERSION) && (PD_MAJOR_VERSION >= 0 && PD_MINOR_VERSION > 36) -#include -#include -#else -#include +#ifndef PD_0_36 +#include "m_pd.h" +#include "s_stuff.h" #endif - +#include "m_imp.h" #include #include @@ -40,7 +37,7 @@ #include #include #include -#if defined(UNIX) || defined(unix) +#ifdef UNIX #include #include #include @@ -541,9 +538,7 @@ static void *netserver_new(t_floatarg fportno) x->x_connectsocket = sockfd; x->x_nconnections = 0; for(i = 0; i < MAX_CONNECT; i++)x->x_fd[i] = -1; -#ifndef MAXLIB - post(version); -#endif + return (x); } @@ -563,6 +558,7 @@ static void netserver_free(t_netserver *x) binbuf_free(inbinbuf); } +#ifndef MAXLIB void netserver_setup(void) { netserver_class = class_new(gensym("netserver"),(t_newmethod)netserver_new, (t_method)netserver_free, @@ -571,4 +567,19 @@ void netserver_setup(void) class_addmethod(netserver_class, (t_method)netserver_send, gensym("send"), A_GIMME, 0); class_addmethod(netserver_class, (t_method)netserver_client_send, gensym("client"), A_GIMME, 0); class_addmethod(netserver_class, (t_method)netserver_broadcast, gensym("broadcast"), A_GIMME, 0); + class_sethelpsymbol(netserver_class, gensym("help-netserver.pd")); + post(version); +} +#else +void maxlib_netserver_setup(void) +{ + netserver_class = class_new(gensym("maxlib_netserver"),(t_newmethod)netserver_new, (t_method)netserver_free, + sizeof(t_netserver), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)netserver_new, gensym("netserver"), A_DEFFLOAT, 0); + class_addmethod(netserver_class, (t_method)netserver_print, gensym("print"), 0); + class_addmethod(netserver_class, (t_method)netserver_send, gensym("send"), A_GIMME, 0); + class_addmethod(netserver_class, (t_method)netserver_client_send, gensym("client"), A_GIMME, 0); + class_addmethod(netserver_class, (t_method)netserver_broadcast, gensym("broadcast"), A_GIMME, 0); + class_sethelpsymbol(netserver_class, gensym("maxlib/help-netserver.pd")); } +#endif \ No newline at end of file diff --git a/src/nroute.c b/src/nroute.c index 5836ed7..c8c94c5 100644 --- a/src/nroute.c +++ b/src/nroute.c @@ -124,10 +124,6 @@ static void *nroute_new(t_symbol *s, int argc, t_atom *argv) t_nroute *x = (t_nroute *)pd_new(nroute_class); t_proxy *inlet = (t_proxy *)pd_new(proxy_class); /* for the proxy inlet */ -#ifndef MAXLIB - post(version); -#endif - inlet->x = x; /* make x visible to the proxy inlets */ x->pos = 1; @@ -150,14 +146,23 @@ static void *nroute_new(t_symbol *s, int argc, t_atom *argv) x->out2 = outlet_new(&x->x_obj, gensym("list")); return (x); } - + +#ifndef MAXLIB void nroute_setup(void) { /* the object's class: */ nroute_class = class_new(gensym("nroute"), (t_newmethod)nroute_new, 0, sizeof(t_nroute), 0, A_GIMME, 0); +#else +void maxlib_nroute_setup(void) +{ + /* the object's class: */ + nroute_class = class_new(gensym("maxlib_nroute"), (t_newmethod)nroute_new, + 0, sizeof(t_nroute), 0, A_GIMME, 0); + class_addcreator((t_newmethod)nroute_new, gensym("nroute"), A_GIMME, 0); +#endif /* a class for the proxy inlet: */ - proxy_class = class_new(gensym("proxy"), NULL, NULL, sizeof(t_proxy), + proxy_class = class_new(gensym("maxlib_nroute_proxy"), NULL, NULL, sizeof(t_proxy), CLASS_PD|CLASS_NOINLET, A_NULL); class_addmethod(nroute_class, (t_method)nroute_setpos, gensym("right"), A_FLOAT, 0); @@ -166,6 +171,9 @@ void nroute_setup(void) class_addanything(nroute_class, nroute_any); class_addanything(proxy_class, nroute_setmatch); #ifndef MAXLIB + class_sethelpsymbol(nroute_class, gensym("help-nroute.pd")); + post(version); #else + class_sethelpsymbol(nroute_class, gensym("maxlib/help-nroute.pd")); #endif -} +} \ No newline at end of file diff --git a/src/pitch.c b/src/pitch.c index bd95e1e..95fac90 100644 --- a/src/pitch.c +++ b/src/pitch.c @@ -90,16 +90,25 @@ static void *pitch_new(t_floatarg f) x->x_lastpitch = f; -#ifndef MAXLIB - post(version); -#endif return (void *)x; } +#ifndef MAXLIB void pitch_setup(void) { pitch_class = class_new(gensym("pitch"), (t_newmethod)pitch_new, 0, sizeof(t_pitch), 0, A_DEFFLOAT, 0); class_addfloat(pitch_class, pitch_float); + class_sethelpsymbol(pitch_class, gensym("help-pitch.pd")); + post(version); } - +#else +void maxlib_pitch_setup(void) +{ + pitch_class = class_new(gensym("maxlib_pitch"), (t_newmethod)pitch_new, + 0, sizeof(t_pitch), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)pitch_new, gensym("pitch"), A_DEFFLOAT, 0); + class_addfloat(pitch_class, pitch_float); + class_sethelpsymbol(pitch_class, gensym("maxlib/help-pitch.pd")); +} +#endif \ No newline at end of file diff --git a/src/plus.c b/src/plus.c index 3fdf93b..b34ffbf 100644 --- a/src/plus.c +++ b/src/plus.c @@ -82,12 +82,10 @@ static void *plus_new(t_symbol *s, t_int argc, t_atom* argv) } x->x_numvalues = i; -#ifndef MAXLIB - post(version); -#endif return (void *)x; } +#ifndef MAXLIB void plus_setup(void) { plus_class = class_new(gensym("plus"), (t_newmethod)plus_new, @@ -95,5 +93,18 @@ void plus_setup(void) class_addfloat(plus_class, plus_float); class_addmethod(plus_class, (t_method)plus_ft1, gensym("ft1"), A_FLOAT, 0); class_addbang(plus_class, (t_method)plus_bang); + class_sethelpsymbol(plus_class, gensym("help-plus.pd")); + post(version); } - +#else +void maxlib_plus_setup(void) +{ + plus_class = class_new(gensym("maxlib_plus"), (t_newmethod)plus_new, + 0, sizeof(t_plus), 0, A_GIMME, 0); + class_addcreator((t_newmethod)plus_new, gensym("plus"), A_GIMME, 0); + class_addfloat(plus_class, plus_float); + class_addmethod(plus_class, (t_method)plus_ft1, gensym("ft1"), A_FLOAT, 0); + class_addbang(plus_class, (t_method)plus_bang); + class_sethelpsymbol(plus_class, gensym("maxlib/help-plus.pd")); +} +#endif \ No newline at end of file diff --git a/src/poisson.c b/src/poisson.c index ce4e7bc..d7164ef 100644 --- a/src/poisson.c +++ b/src/poisson.c @@ -70,12 +70,22 @@ static void rand_poisson_bang(t_rand_poisson *x) outlet_float(x->x_obj.ob_outlet, n); } +#ifndef MAXLIB void poisson_setup(void) { rand_poisson_class = class_new(gensym("poisson"), (t_newmethod)rand_poisson_new, 0, sizeof(t_rand_poisson), 0, A_DEFFLOAT, 0); class_addbang(rand_poisson_class, rand_poisson_bang); -#ifndef MAXLIB + class_sethelpsymbol(rand_poisson_class, gensym("help-poisson.pd")); post(version); -#endif } +#else +void maxlib_poisson_setup(void) +{ + rand_poisson_class = class_new(gensym("maxlib_poisson"), (t_newmethod)rand_poisson_new, 0, + sizeof(t_rand_poisson), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)rand_poisson_new, gensym("poisson"), A_DEFFLOAT, 0); + class_addbang(rand_poisson_class, rand_poisson_bang); + class_sethelpsymbol(rand_poisson_class, gensym("maxlib/help-poisson.pd")); +} +#endif \ No newline at end of file diff --git a/src/pong.c b/src/pong.c index 2ff3109..c2deb50 100644 --- a/src/pong.c +++ b/src/pong.c @@ -1,6 +1,6 @@ /* --------------------------- pong ------------------------------------------ */ /* */ -/* Route input according to Nth element. */ +/* A virtual bouncing ball. */ /* Written by Olaf Matthes */ /* Based on pong (for Max) version 1.5 written by Richard Dudas. */ /* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */ @@ -253,10 +253,6 @@ static void *pong_new(t_floatarg n) { t_pong *x = (t_pong *)pd_new(pong_class); -#ifndef MAXLIB - post(version); -#endif - x->p_klok = clock_new(x, (t_method)pong_tick); inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym("dist")); // distance @@ -299,11 +295,19 @@ static void *pong_new(t_floatarg n) return (x); } - + +#ifndef MAXLIB void pong_setup(void) { pong_class = class_new(gensym("pong"), (t_newmethod)pong_new, 0, sizeof(t_pong), 0, A_DEFFLOAT, 0); +#else +void maxlib_pong_setup(void) +{ + pong_class = class_new(gensym("maxlib_pong"), (t_newmethod)pong_new, + 0, sizeof(t_pong), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)pong_new, gensym("pong"), A_DEFFLOAT, 0); +#endif /* method handlers for inlets */ class_addmethod(pong_class, (t_method)pong_initdist, gensym("dist"), A_FLOAT, 0); class_addmethod(pong_class, (t_method)pong_initvel, gensym("velo"), A_FLOAT, 0); @@ -320,6 +324,9 @@ void pong_setup(void) class_addfloat(pong_class, pong_onoff); class_addbang(pong_class, pong_bang); #ifndef MAXLIB + class_sethelpsymbol(pong_class, gensym("help-pong.pd")); + post(version); #else + class_sethelpsymbol(pong_class, gensym("maxlib/help-pong.pd")); #endif -} +} \ No newline at end of file diff --git a/src/pulse.c b/src/pulse.c index fc5ca96..afa133c 100644 --- a/src/pulse.c +++ b/src/pulse.c @@ -1,13 +1,35 @@ +/* --------------------------- pong ------------------------------------------ */ +/* */ +/* A more accurate replacement for the tempo object. */ +/* Written by Olaf Matthes */ +/* Based on pulse for Max written by James McCartney. */ +/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */ +/* */ +/* This program is free software; you can redistribute it and/or */ +/* modify it under the terms of the GNU General Public License */ +/* as published by the Free Software Foundation; either version 2 */ +/* of the License, or (at your option) any later version. */ +/* */ +/* This program is distributed in the hope that it will be useful, */ +/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ +/* GNU General Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License */ +/* along with this program; if not, write to the Free Software */ +/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +/* */ +/* Based on PureData by Miller Puckette and others. */ +/* */ +/* ---------------------------------------------------------------------------- */ + /* pulse.c ---- a more accurate replacement for the tempo object */ /* updated for CW 68K / PPC summer 96 -RD */ /* written for Max by James McCartney */ -/* ported to Pd by Olaf Matthes */ #include "m_pd.h" #include -#define MAXSIZE 32 - static char *version = "pulse v0.1b, written by James McCartney for Max \n" " ported to Pd by Olaf Matthes "; @@ -244,12 +266,11 @@ static void *pulse_new(t_floatarg t, t_floatarg n, t_floatarg d, t_floatarg b) x->p_changenumer = 0; x->p_changedenom = 0; x->p_onoff = 0; -#ifndef MAXLIB - post(version); -#endif + return (x); /* always return a copy of the created object */ } +#ifndef MAXLIB void pulse_setup(void) { pulse_class = class_new(gensym("pulse"), (t_newmethod)pulse_new, @@ -260,5 +281,21 @@ void pulse_setup(void) class_addmethod(pulse_class, (t_method)pulse_tempo, gensym("tempo"), A_FLOAT, 0); class_addfloat(pulse_class, pulse_onoff); class_addbang(pulse_class, pulse_bang); + class_sethelpsymbol(pulse_class, gensym("help-pulse.pd")); + post(version); } - +#else +void maxlib_pulse_setup(void) +{ + pulse_class = class_new(gensym("maxlib_pulse"), (t_newmethod)pulse_new, + (t_method)pulse_free, sizeof(Pulse), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)pulse_new, gensym("pulse"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(pulse_class, (t_method)pulse_beat, gensym("beat"), A_FLOAT, 0); + class_addmethod(pulse_class, (t_method)pulse_denom, gensym("denom"), A_FLOAT, 0); + class_addmethod(pulse_class, (t_method)pulse_numer, gensym("numer"), A_FLOAT, 0); + class_addmethod(pulse_class, (t_method)pulse_tempo, gensym("tempo"), A_FLOAT, 0); + class_addfloat(pulse_class, pulse_onoff); + class_addbang(pulse_class, pulse_bang); + class_sethelpsymbol(pulse_class, gensym("maxlib/help-pulse.pd")); +} +#endif \ No newline at end of file diff --git a/src/remote.c b/src/remote.c index 85a38b6..d4c5771 100644 --- a/src/remote.c +++ b/src/remote.c @@ -28,7 +28,7 @@ #include #define MAX_REC 64 /* maximum number of receive objects */ -#define MAX_ARG 32 /* maximum number of arguments to pass on */ +#define MAX_ARG 64 /* maximum number of arguments to pass on */ static char *version = "remote v0.2, written by Olaf Matthes "; @@ -84,15 +84,25 @@ static void *remote_new(t_symbol *s) if(x->x_prefix) x->x_prepend = 1; else x->x_prepend = 0; -#ifndef MAXLIB - post(version); -#endif return (x); } +#ifndef MAXLIB void remote_setup(void) { remote_class = class_new(gensym("remote"), (t_newmethod)remote_new, 0, sizeof(t_remote), 0, A_DEFSYM, 0); class_addanything(remote_class, remote_anything); + class_sethelpsymbol(remote_class, gensym("help-remote.pd")); + post(version); +} +#else +void maxlib_remote_setup(void) +{ + remote_class = class_new(gensym("maxlib_remote"), (t_newmethod)remote_new, 0, + sizeof(t_remote), 0, A_DEFSYM, 0); + class_addcreator((t_newmethod)remote_new, gensym("remote"), A_DEFSYM, 0); + class_addanything(remote_class, remote_anything); + class_sethelpsymbol(remote_class, gensym("maxlib/help-remote.pd")); } +#endif \ No newline at end of file diff --git a/src/rewrap.c b/src/rewrap.c index f15b8dc..b8d3242 100644 --- a/src/rewrap.c +++ b/src/rewrap.c @@ -127,12 +127,10 @@ static void *rewrap_new(t_floatarg fmin, t_floatarg fmax) x->x_min = fmin; rewrap_b(x, fmax); -#ifndef MAXLIB - post(version); -#endif return (void *)x; } +#ifndef MAXLIB void rewrap_setup(void) { rewrap_class = class_new(gensym("rewrap"), (t_newmethod)rewrap_new, @@ -140,8 +138,18 @@ void rewrap_setup(void) class_addfloat(rewrap_class, rewrap_float); class_addmethod(rewrap_class, (t_method)rewrap_a, gensym("a"), A_FLOAT, 0); class_addmethod(rewrap_class, (t_method)rewrap_b, gensym("b"), A_FLOAT, 0); -#ifndef MAXLIB + class_sethelpsymbol(rewrap_class, gensym("help-rewrap.pd")); + post(version); +} #else -#endif +void maxlib_rewrap_setup(void) +{ + rewrap_class = class_new(gensym("maxlib_rewrap"), (t_newmethod)rewrap_new, + 0, sizeof(t_rewrap), 0, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)rewrap_new, gensym("rewrap"), A_DEFFLOAT, A_DEFFLOAT, 0); + class_addfloat(rewrap_class, rewrap_float); + class_addmethod(rewrap_class, (t_method)rewrap_a, gensym("a"), A_FLOAT, 0); + class_addmethod(rewrap_class, (t_method)rewrap_b, gensym("b"), A_FLOAT, 0); + class_sethelpsymbol(rewrap_class, gensym("maxlib/help-rewrap.pd")); } - +#endif \ No newline at end of file diff --git a/src/rhythm.c b/src/rhythm.c index cd9d6e2..7796a61 100644 --- a/src/rhythm.c +++ b/src/rhythm.c @@ -297,9 +297,6 @@ static void *rhythm_new(t_floatarg f) rhythm_reset(x); -#ifndef MAXLIB - post(version); -#endif if(f == 1) { x->x_model = 1; /* Toiviainen model */ @@ -314,15 +311,30 @@ static void *rhythm_new(t_floatarg f) return (void *)x; } +#ifndef MAXLIB void rhythm_setup(void) { rhythm_class = class_new(gensym("rhythm"), (t_newmethod)rhythm_new, (t_method)rhythm_free, sizeof(t_rhythm), 0, A_DEFFLOAT, 0); - class_addcreator((t_newmethod)rhythm_new, gensym("max.rhythm"), A_DEFFLOAT, 0); class_addfloat(rhythm_class, rhythm_float); class_addmethod(rhythm_class, (t_method)rhythm_ft1, gensym("ft1"), A_FLOAT, 0); class_addmethod(rhythm_class, (t_method)rhythm_model, gensym("model"), A_FLOAT, 0); class_addmethod(rhythm_class, (t_method)rhythm_reset, gensym("reset"), 0); class_addmethod(rhythm_class, (t_method)rhythm_print, gensym("print"), 0); + class_sethelpsymbol(rhythm_class, gensym("help-rhythm.pd")); + post(version); } - +#else +void maxlib_rhythm_setup(void) +{ + rhythm_class = class_new(gensym("maxlib_rhythm"), (t_newmethod)rhythm_new, + (t_method)rhythm_free, sizeof(t_rhythm), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)rhythm_new, gensym("rhythm"), A_DEFFLOAT, 0); + class_addfloat(rhythm_class, rhythm_float); + class_addmethod(rhythm_class, (t_method)rhythm_ft1, gensym("ft1"), A_FLOAT, 0); + class_addmethod(rhythm_class, (t_method)rhythm_model, gensym("model"), A_FLOAT, 0); + class_addmethod(rhythm_class, (t_method)rhythm_reset, gensym("reset"), 0); + class_addmethod(rhythm_class, (t_method)rhythm_print, gensym("print"), 0); + class_sethelpsymbol(rhythm_class, gensym("maxlib/help-rhythm.pd")); +} +#endif diff --git a/src/scale.c b/src/scale.c index 4fbfaec..4d72485 100644 --- a/src/scale.c +++ b/src/scale.c @@ -112,20 +112,27 @@ static void *scale_new(t_floatarg fil, t_floatarg fih, t_floatarg fol, t_floatar x->x_logcoeff = flc; x->x_f = 0; -#ifndef MAXLIB - post(version); -#endif return (void *)x; } +#ifndef MAXLIB void scale_setup(void) { scale_class = class_new(gensym("scale"), (t_newmethod)scale_new, 0, sizeof(t_scale), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); class_addfloat(scale_class, scale_float); class_addbang(scale_class, scale_bang); -#ifndef MAXLIB + class_sethelpsymbol(scale_class, gensym("help-scale.pd")); + post(version); #else +void maxlib_scale_setup(void) +{ + scale_class = class_new(gensym("maxlib_scale"), (t_newmethod)scale_new, + 0, sizeof(t_scale), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)scale_new, gensym("scale"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addfloat(scale_class, scale_float); + class_addbang(scale_class, scale_bang); + class_sethelpsymbol(scale_class, gensym("maxlib/help-scale.pd")); #endif } diff --git a/src/score.c b/src/score.c index 80722ac..0f96229 100644 --- a/src/score.c +++ b/src/score.c @@ -255,9 +255,7 @@ static void *score_new(t_symbol *s, t_floatarg fskipindex, t_floatarg fskiptime) x->x_inreset = inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("bang"), gensym("reset")); x->x_outindex = outlet_new(&x->x_ob, gensym("float")); x->x_outerror = outlet_new(&x->x_ob, gensym("float")); -#ifndef MAXLIB - post(version); -#endif + x->x_sym = s; /* get name of array */ score_set(x,x->x_sym); /* set array */ if(!fskipindex)fskipindex = 2; @@ -276,6 +274,7 @@ static void *score_new(t_symbol *s, t_floatarg fskipindex, t_floatarg fskiptime) return (void *)x; } +#ifndef MAXLIB void score_setup(void) { score_class = class_new(gensym("score"), (t_newmethod)score_new, @@ -288,6 +287,23 @@ void score_setup(void) class_addmethod(score_class, (t_method)score_reset, gensym("reset"), A_GIMME, 0); class_addmethod(score_class, (t_method)score_set, gensym("set"), A_SYMBOL, 0); class_addfloat(score_class, score_float); - + class_sethelpsymbol(score_class, gensym("help-score.pd")); + post(version); } - +#else +void maxlib_score_setup(void) +{ + score_class = class_new(gensym("maxlib_score"), (t_newmethod)score_new, + (t_method)score_free, sizeof(t_score), 0, A_SYMBOL, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)score_new, gensym("score"), A_SYMBOL, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(score_class, (t_method)score_reset, gensym("reset"), 0); + class_addmethod(score_class, (t_method)score_resume, gensym("resume"), 0); + class_addmethod(score_class, (t_method)score_start, gensym("start"), A_GIMME, 0); + class_addmethod(score_class, (t_method)score_stop, gensym("stop"), 0); + class_addmethod(score_class, (t_method)score_ft1, gensym("ft1"), A_FLOAT, 0); + class_addmethod(score_class, (t_method)score_reset, gensym("reset"), A_GIMME, 0); + class_addmethod(score_class, (t_method)score_set, gensym("set"), A_SYMBOL, 0); + class_addfloat(score_class, score_float); + class_sethelpsymbol(score_class, gensym("maxlib/help-score.pd")); +} +#endif \ No newline at end of file diff --git a/src/speedlim.c b/src/speedlim.c index 3055166..c4a4385 100644 --- a/src/speedlim.c +++ b/src/speedlim.c @@ -27,16 +27,16 @@ /* Based on PureData by Miller Puckette and others. */ /* */ /* ---------------------------------------------------------------------------- */ + /* this is the original copyright notice: */ + /* Copyright (c) 1997-2002 Miller Puckette and others. * For information on usage and redistribution, and for a DISCLAIMER OF ALL * WARRANTIES, see the file, "LICENSE.txt," in this distribution. */ -/* LATER 'clock' method */ #include #include "m_pd.h" -// #include "hammer.h" #define SPEEDLIM_INISIZE 32 /* LATER rethink */ #define SPEEDLIM_MAXSIZE 256 /* not used */ @@ -209,10 +209,18 @@ static void *speedlim_new(t_floatarg f) return (x); } +#ifndef MAXLIB 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); +#else +void maxlib_speedlim_setup(void) +{ + speedlim_class = class_new(gensym("maxlib_speedlim"), (t_newmethod)speedlim_new, + (t_method)speedlim_free, sizeof(t_speedlim), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)speedlim_new, gensym("speedlim"), A_DEFFLOAT, 0); +#endif class_addbang(speedlim_class, speedlim_bang); class_addfloat(speedlim_class, speedlim_float); class_addsymbol(speedlim_class, speedlim_symbol); @@ -220,6 +228,8 @@ void speedlim_setup(void) class_addanything(speedlim_class, speedlim_anything); class_addmethod(speedlim_class, (t_method)speedlim_ft1, gensym("ft1"), A_FLOAT, 0); #ifndef MAXLIB + class_sethelpsymbol(speedlim_class, gensym("help-speedlim.pd")); #else + class_sethelpsymbol(speedlim_class, gensym("maxlib/help-speedlim.pd")); #endif } diff --git a/src/split.c b/src/split.c index 3a0d822..93f3a3d 100644 --- a/src/split.c +++ b/src/split.c @@ -71,19 +71,25 @@ static void *split_new(t_floatarg fmin, t_floatarg fmax) x->x_min = fmin; x->x_max = fmax; -#ifndef MAXLIB - post(version); -#endif return (void *)x; } +#ifndef MAXLIB void split_setup(void) { split_class = class_new(gensym("split"), (t_newmethod)split_new, 0, sizeof(t_split), 0, A_DEFFLOAT, A_DEFFLOAT, 0); class_addfloat(split_class, split_float); -#ifndef MAXLIB + class_sethelpsymbol(split_class, gensym("help-split.pd")); + post(version); +} #else -#endif +void maxlib_split_setup(void) +{ + split_class = class_new(gensym("maxlib_split"), (t_newmethod)split_new, + 0, sizeof(t_split), 0, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)split_new, gensym("split"), A_DEFFLOAT, A_DEFFLOAT, 0); + class_addfloat(split_class, split_float); + class_sethelpsymbol(split_class, gensym("maxlib/help-split.pd")); } - +#endif diff --git a/src/step.c b/src/step.c index 8886ecb..819a157 100644 --- a/src/step.c +++ b/src/step.c @@ -149,12 +149,10 @@ static void *step_new(t_floatarg f, t_floatarg step, t_floatarg grain) outlet_new(&x->x_obj, gensym("float")); inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym("ft1")); inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym("ft2")); -#ifndef MAXLIB - post(version); -#endif return (x); } +#ifndef MAXLIB void step_setup(void) { step_class = class_new(gensym("step"), (t_newmethod)step_new, @@ -163,4 +161,19 @@ void step_setup(void) class_addmethod(step_class, (t_method)step_ft2, gensym("ft2"), A_FLOAT, 0); class_addmethod(step_class, (t_method)step_stop, gensym("stop"), 0); class_addfloat(step_class, (t_method)step_float); + class_sethelpsymbol(step_class, gensym("help-step.pd")); + post(version); +} +#else +void maxlib_step_setup(void) +{ + step_class = class_new(gensym("maxlib_step"), (t_newmethod)step_new, + (t_method)step_free, sizeof(t_step), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)step_new, gensym("step"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(step_class, (t_method)step_ft1, gensym("ft1"), A_FLOAT, 0); + class_addmethod(step_class, (t_method)step_ft2, gensym("ft2"), A_FLOAT, 0); + class_addmethod(step_class, (t_method)step_stop, gensym("stop"), 0); + class_addfloat(step_class, (t_method)step_float); + class_sethelpsymbol(step_class, gensym("maxlib/help-step.pd")); } +#endif \ No newline at end of file diff --git a/src/subst.c b/src/subst.c index 0a4acf4..f473d53 100644 --- a/src/subst.c +++ b/src/subst.c @@ -366,9 +366,6 @@ static void *subst_new(t_symbol *s, int argc, t_atom *argv) long i; t_symbol *sym; t_subst *x = (t_subst *)pd_new(subst_class); -#ifndef MAXLIB - post(version); -#endif // read in order... x->x_order = 3; if(argc == 1) @@ -391,8 +388,10 @@ static void *subst_new(t_symbol *s, int argc, t_atom *argv) static void subst_free(t_subst *x) { + /* nothing to do */ } +#ifndef MAXLIB void subst_setup(void) { subst_class = class_new(gensym("subst"), (t_newmethod)subst_new, @@ -404,4 +403,22 @@ void subst_setup(void) class_addmethod(subst_class, (t_method)subst_display, gensym("display"), 0); class_addlist(subst_class, subst_list); class_addbang(subst_class, subst_bang); + class_sethelpsymbol(subst_class, gensym("help-subst.pd")); + post(version); +} +#else +void maxlib_subst_setup(void) +{ + subst_class = class_new(gensym("maxlib_subst"), (t_newmethod)subst_new, + (t_method)subst_free, sizeof(t_subst), 0, A_GIMME, 0); + class_addcreator((t_newmethod)subst_new, gensym("subst"), A_GIMME, 0); + class_addmethod(subst_class, (t_method)subst_set_order, gensym("order"), A_FLOAT, 0); + class_addmethod(subst_class, (t_method)subst_intv, gensym("interval"), A_FLOAT, 0); + class_addmethod(subst_class, (t_method)subst_set, gensym("set"), A_SYMBOL, 0); + class_addmethod(subst_class, (t_method)subst_load, gensym("load"), A_SYMBOL, 0); + class_addmethod(subst_class, (t_method)subst_display, gensym("display"), 0); + class_addlist(subst_class, subst_list); + class_addbang(subst_class, subst_bang); + class_sethelpsymbol(subst_class, gensym("maxlib/help-subst.pd")); } +#endif \ No newline at end of file diff --git a/src/sync.c b/src/sync.c new file mode 100644 index 0000000..21e05f9 --- /dev/null +++ b/src/sync.c @@ -0,0 +1,294 @@ +/* ------------------------- sync ------------------------------------------- */ +/* */ +/* syncronises outputs depending on inputs. */ +/* Written by Olaf Matthes */ +/* Based on 'sync' from jMax. */ +/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */ +/* */ +/* This program is free software; you can redistribute it and/or */ +/* modify it under the terms of the GNU General Public License */ +/* as published by the Free Software Foundation; either version 2 */ +/* of the License, or (at your option) any later version. */ +/* */ +/* This program is distributed in the hope that it will be useful, */ +/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ +/* GNU General Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License */ +/* along with this program; if not, write to the Free Software */ +/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +/* */ +/* Based on PureData by Miller Puckette and others. */ +/* */ +/* ---------------------------------------------------------------------------- */ + +#include "m_pd.h" +#include +#include + +#define SYNC_MAX_SIZE (sizeof(unsigned int) * 8) + +static char *version = "sync v0.1, written by Olaf Matthes \n" + " based on sync from jMax"; + +typedef struct sync +{ + t_object x_ob; + t_float x_min; /* low border of input range */ + t_float x_max; /* high border of input range */ + t_outlet *x_outlet[SYNC_MAX_SIZE]; + + t_int x_n; + unsigned int x_trigger; /* control bits: trigger on input at given inlets */ + unsigned int x_require; /* control bits: require input on given inlets */ + unsigned int x_reset; /* control bits: reset memory of given inputs after on each input */ + unsigned int x_wait; /* status bits: wait for input at given inlet before output */ + t_atom x_a[SYNC_MAX_SIZE]; + enum {mode_all, mode_select} mode; +} t_sync; + +typedef struct proxy +{ + t_object obj; + t_int index; /* number of proxy inlet(s) */ + t_sync *x; /* we'll put the other struct in here */ +} t_proxy; + +static void sync_output(t_sync *x) +{ + int i; + + for(i=x->x_n-1; i>=0; i--) + if(x->x_a[i].a_type != A_SEMI) + outlet_list(x->x_outlet[i], NULL, 1, x->x_a + i); +} + +static void sync_input(t_proxy *p, t_symbol *s, int ac, t_atom *at) +{ + t_sync *x = (t_sync *)(p->x); + int winlet = p->index; + + if(ac) + { + unsigned int bit = 1 << winlet; + + x->x_a[winlet] = at[0]; + + x->x_wait &= ~bit; + + if(!x->x_wait && (x->x_trigger & bit)) + { + sync_output(x); + x->x_wait |= x->x_reset & x->x_require; + } + } +} + +static void sync_float_input(t_proxy *p, t_floatarg f) +{ + t_sync *x = (t_sync *)(p->x); + int winlet = p->index; + + { + unsigned int bit = 1 << winlet; + + SETFLOAT(x->x_a + winlet, f); + + x->x_wait &= ~bit; + + if(!x->x_wait && (x->x_trigger & bit)) + { + sync_output(x); + x->x_wait |= x->x_reset & x->x_require; + } + } +} + +static void sync_set_bits(unsigned int *bits, int n, t_atom *at, int sign) +{ + if(at->a_type == A_SYMBOL) + { + t_symbol *mode = atom_getsymbol(at); + + if(mode == gensym("all")) + *bits = (1 << n) - 1; + else if(mode == gensym("none")) + *bits = 0; + } + else if(at->a_type == A_FLOAT) + { + int in = (int)atom_getfloat(at) * sign; + + if(in >= 0 && in < n) + *bits = 1 << in; + } + else if(at->a_type == A_GIMME) + { + int size = n; + int i; + + *bits = 0; + + for(i=0; i= 0 && in < n) + *bits |= 1 << in; + } + } + } +} + +static void sync_set_trigger(t_sync *x, t_symbol *s, int ac, t_atom *at) +{ + sync_set_bits(&x->x_trigger, x->x_n, at, 1); +} + +static void sync_set_require(t_sync *x, t_symbol *s, int ac, t_atom *at) +{ + unsigned int once = 0; + + sync_set_bits(&x->x_require, x->x_n, at, 1); + sync_set_bits(&once, x->x_n, at, -1); + + x->x_reset = ~once; + x->x_wait = x->x_require | once; +} + +static void sync_set_mode(t_sync *x, t_symbol *mode) +{ + if(mode == gensym("any")) + { + x->x_trigger = (1 << x->x_n) - 1; + x->x_reset = 0; + x->x_require = 0; + } + else if(mode == gensym("all")) + x->x_trigger = x->x_require = x->x_reset = x->x_wait = (1 << x->x_n) - 1; + else if(mode == gensym("left")) + { + x->x_trigger = 1; + x->x_reset = 0; + x->x_require = 0; + } + else if(mode == gensym("right")) + { + x->x_trigger = (1 << (x->x_n - 1)); + x->x_reset = 0; + x->x_require = 0; + } + + x->x_wait = x->x_require; +} + +static void sync_float(t_sync *x, t_floatarg f) +{ + unsigned int bit = 1 << 0; + + SETFLOAT(x->x_a, f); + + x->x_wait &= ~bit; + + if(!x->x_wait && (x->x_trigger & bit)) + { + sync_output(x); + x->x_wait |= x->x_reset & x->x_require; + } +} + +static t_class *sync_class; +static t_class *proxy_class; + +static void *sync_new(t_symbol *s, int ac, t_atom *at) +{ + int n = 0; + int i; + t_sync *x = (t_sync *)pd_new(sync_class); + t_proxy *inlet[SYNC_MAX_SIZE]; + + /* void state - we fill with SEMI and treat this as 'void' */ + for(i=0; ix_a + i); + + if(ac == 1) + { + if(at->a_type == A_FLOAT) + { + n = atom_getfloat(at); + + if(n < 2) + n = 2; + else if(n > SYNC_MAX_SIZE) + n = SYNC_MAX_SIZE; + } + else + { + post("sync: wrong argument"); + return (0); + } + } + else if(ac > 1) + { + if(ac > SYNC_MAX_SIZE) + ac = SYNC_MAX_SIZE; + + n = ac; + + for(i=0; ix_a[i] = at[i]; + } + + x->x_n = n; + x->x_trigger = x->x_require = x->x_reset = x->x_wait = (1 << n) - 1; + + x->x_outlet[0] = outlet_new(&x->x_ob, gensym("list")); + + for(i=1; ix = x; /* make t_sync *x visible to the proxy inlets */ + inlet[i]->index = i; /* remember it's number */ + /* it belongs to the object t_sync but the destination is t_proxy */ + inlet_new(&x->x_ob, &inlet[i]->obj.ob_pd, 0,0); + + x->x_outlet[i] = outlet_new(&x->x_ob, gensym("list")); + } + + return (void *)x; +} + +#ifndef MAXLIB +void sync_setup(void) +{ + sync_class = class_new(gensym("sync"), (t_newmethod)sync_new, + 0, sizeof(t_sync), 0, A_GIMME, 0); +#else +void maxlib_sync_setup(void) +{ + sync_class = class_new(gensym("maxlib_sync"), (t_newmethod)sync_new, + 0, sizeof(t_sync), 0, A_GIMME, 0); +#endif + /* a class for the proxy inlet: */ + proxy_class = class_new(gensym("maxlib_sync_proxy"), NULL, NULL, sizeof(t_proxy), + CLASS_PD|CLASS_NOINLET, A_NULL); + + class_addfloat(proxy_class, sync_float_input); + class_addanything(proxy_class, sync_input); + + class_addfloat(sync_class, sync_float); + class_addmethod(sync_class, (t_method)sync_set_trigger, gensym("trigger"), A_GIMME, 0); + class_addmethod(sync_class, (t_method)sync_set_require, gensym("require"), A_GIMME, 0); + class_addmethod(sync_class, (t_method)sync_set_mode, gensym("mode"), A_SYMBOL, 0); +#ifndef MAXLIB + class_sethelpsymbol(sync_class, gensym("help-sync.pd")); + post(version); +#else + class_addcreator((t_newmethod)sync_new, gensym("sync"), A_GIMME, 0); + class_sethelpsymbol(sync_class, gensym("maxlib/help-sync.pd")); +#endif +} + diff --git a/src/temperature.c b/src/temperature.c index 28a9352..509db76 100644 --- a/src/temperature.c +++ b/src/temperature.c @@ -90,12 +90,10 @@ static void *temperature_new(t_floatarg f) } x->x_index = 0; clock_delay(x->x_clock, x->x_time); -#ifndef MAXLIB - post(version); -#endif return (void *)x; } +#ifndef MAXLIB void temperature_setup(void) { temperature_class = class_new(gensym("temperature"), (t_newmethod)temperature_new, @@ -104,5 +102,19 @@ void temperature_setup(void) class_addfloat(temperature_class, temperature_float); class_addmethod(temperature_class, (t_method)temperature_time, gensym("time"), A_FLOAT, 0); class_addanything(temperature_class, temperature_anything); + class_sethelpsymbol(temperature_class, gensym("help-temperature.pd")); + post(version); } - +#else +void maxlib_temperature_setup(void) +{ + temperature_class = class_new(gensym("maxlib_temperature"), (t_newmethod)temperature_new, + (t_method)temperature_free, sizeof(t_temperature), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)temperature_new, gensym("temperature"), A_DEFFLOAT, 0); + class_addmethod(temperature_class, (t_method)temperature_reset, gensym("reset"), 0); + class_addfloat(temperature_class, temperature_float); + class_addmethod(temperature_class, (t_method)temperature_time, gensym("time"), A_FLOAT, 0); + class_addanything(temperature_class, temperature_anything); + class_sethelpsymbol(temperature_class, gensym("maxlib/help-temperature.pd")); +} +#endif \ No newline at end of file diff --git a/src/tilt.c b/src/tilt.c index 048022e..ca67914 100644 --- a/src/tilt.c +++ b/src/tilt.c @@ -154,13 +154,11 @@ static void *tilt_new(t_floatarg f, t_floatarg f2) x->x_hi_limit = x->x_low_limit = x->x_trip_point = 0; clock_delay(x->x_clock, x->x_wait); /* wait 4 sec and start calculation */ -#ifndef MAXLIB - post(version); -#endif post("tilt: set interval to %g msec", x->x_wait); return (void *)x; } +#ifndef MAXLIB void tilt_setup(void) { tilt_class = class_new(gensym("tilt"), (t_newmethod)tilt_new, @@ -171,5 +169,21 @@ void tilt_setup(void) class_addmethod(tilt_class, (t_method)tilt_hi_limit, gensym("hi"), A_FLOAT, 0); class_addmethod(tilt_class, (t_method)tilt_low_limit, gensym("low"), A_FLOAT, 0); class_addmethod(tilt_class, (t_method)tilt_trip_point, gensym("trip"), A_FLOAT, 0); + class_sethelpsymbol(tilt_class, gensym("help-tilt.pd")); + post(version); } - +#else +void maxlib_tilt_setup(void) +{ + tilt_class = class_new(gensym("maxlib_tilt"), (t_newmethod)tilt_new, + (t_method)tilt_free, sizeof(t_tilt), 0, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)tilt_new, gensym("tilt"), A_DEFFLOAT, A_DEFFLOAT, 0); + class_addfloat(tilt_class, tilt_float); + class_addmethod(tilt_class, (t_method)tilt_intv, gensym("intv"), A_FLOAT, 0); + class_addmethod(tilt_class, (t_method)tilt_tilt, gensym("tilt"), A_FLOAT, 0); + class_addmethod(tilt_class, (t_method)tilt_hi_limit, gensym("hi"), A_FLOAT, 0); + class_addmethod(tilt_class, (t_method)tilt_low_limit, gensym("low"), A_FLOAT, 0); + class_addmethod(tilt_class, (t_method)tilt_trip_point, gensym("trip"), A_FLOAT, 0); + class_sethelpsymbol(tilt_class, gensym("maxlib/help-tilt.pd")); +} +#endif \ No newline at end of file diff --git a/src/timebang.c b/src/timebang.c index e1f9b9c..3a679b1 100644 --- a/src/timebang.c +++ b/src/timebang.c @@ -29,7 +29,7 @@ #define MAX_TIMES 256 /* maximum number of times to process */ -static char *version = "timebang v0.1, written by Olaf Matthes "; +static char *version = "timebang v0.2, written by Olaf Matthes "; typedef struct timebang { @@ -76,6 +76,27 @@ static void timebang_tick(t_timebang *x) static void timebang_set(t_timebang *x, t_symbol *s, int ac, t_atom *av) { + int i; + + if(ac == x->x_notimes * 3) + { + for(i = 0; i < ac; i += 3) + { + if (av[i].a_type == A_FLOAT) x->x_hour[x->x_notimes] = av[i].a_w.w_float; + else { post ("timebang: first argument must be (int) hours"); return; } + if (av[i+1].a_type == A_FLOAT) x->x_min[x->x_notimes] = av[i+1].a_w.w_float; + else { post ("timebang: second argument must be (int) minutes"); return; } + if (av[i+2].a_type == A_FLOAT) x->x_sec[x->x_notimes] = av[i+2].a_w.w_float; + else { post ("timebang: third argument must be (int) seconds"); return; } + x->x_over[i] = 0; + } + post("timebang: read in %d times of day:", x->x_notimes); + for(i = 0; i < x->x_notimes; i++) + { + post(" %02d:%02d:%02d", x->x_hour[i], x->x_min[i], x->x_sec[i]); + } + } + else post("timebang: wrong number of parameter"); } static void timebang_bang(t_timebang *x) @@ -94,9 +115,6 @@ static void *timebang_new(t_symbol *s, int ac, t_atom *av) x->x_clock = clock_new(x, (t_method)timebang_tick); -#ifndef MAXLIB - post(version); -#endif if(ac > MAX_TIMES * 3) { post("timebang: too many creation arguments"); @@ -132,14 +150,25 @@ static void timebang_free(t_timebang *x) clock_free(x->x_clock); } +#ifndef MAXLIB void timebang_setup(void) { timebang_class = class_new(gensym("timebang"), (t_newmethod)timebang_new, (t_method)timebang_free, sizeof(t_timebang), 0, A_GIMME, 0); +#else +void maxlib_timebang_setup(void) +{ + timebang_class = class_new(gensym("maxlib_timebang"), (t_newmethod)timebang_new, + (t_method)timebang_free, sizeof(t_timebang), 0, A_GIMME, 0); + class_addcreator((t_newmethod)timebang_new, gensym("timebang"), A_GIMME, 0); +#endif class_addmethod(timebang_class, (t_method)timebang_set, gensym("set"), A_GIMME, 0); class_addbang(timebang_class, (t_method)timebang_bang); #ifndef MAXLIB + class_sethelpsymbol(timebang_class, gensym("help-timebang.pd")); + post(version); #else + class_sethelpsymbol(timebang_class, gensym("maxlib/help-timebang.pd")); #endif } diff --git a/src/triang.c b/src/triang.c index 9ecbf65..832bced 100644 --- a/src/triang.c +++ b/src/triang.c @@ -58,12 +58,23 @@ static void rand_triang_bang(t_rand_triang *x) outlet_float(x->x_obj.ob_outlet, 0.5*(u1+u2)); } +#ifndef MAXLIB void triang_setup(void) { rand_triang_class = class_new(gensym("triang"), (t_newmethod)rand_triang_new, 0, sizeof(t_rand_triang), 0, A_DEFFLOAT, 0); +#else +void maxlib_triang_setup(void) +{ + rand_triang_class = class_new(gensym("maxlib_triang"), (t_newmethod)rand_triang_new, 0, + sizeof(t_rand_triang), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)rand_triang_new, gensym("triang"), A_DEFFLOAT, 0); +#endif class_addbang(rand_triang_class, rand_triang_bang); #ifndef MAXLIB + class_sethelpsymbol(rand_triang_class, gensym("help-triang.pd")); post(version); +#else + class_sethelpsymbol(rand_triang_class, gensym("maxlib/help-triang.pd")); #endif -} +} \ No newline at end of file diff --git a/src/unroute.c b/src/unroute.c index 9a68a61..e6131e4 100644 --- a/src/unroute.c +++ b/src/unroute.c @@ -142,19 +142,22 @@ static void *unroute_new(t_symbol *s, int argc, t_atom *argv) } x->x_outlet = outlet_new(&x->x_obj, gensym("float")); -#ifndef MAXLIB - post(version); -#endif return (void *)x; } +#ifndef MAXLIB void unroute_setup(void) { unroute_class = class_new(gensym("unroute"), (t_newmethod)unroute_new, 0, sizeof(t_unroute), 0, A_GIMME, 0); - +#else +void maxlib_unroute_setup(void) +{ + unroute_class = class_new(gensym("maxlib_unroute"), (t_newmethod)unroute_new, + 0, sizeof(t_unroute), 0, A_GIMME, 0); +#endif /* a class for the proxy inlet: */ - proxy_class = class_new(gensym("proxy"), NULL, NULL, sizeof(t_proxy), + proxy_class = class_new(gensym("maxlib_unroute_proxy"), NULL, NULL, sizeof(t_proxy), CLASS_PD|CLASS_NOINLET, A_NULL); class_addanything(proxy_class, unroute_input); @@ -163,6 +166,10 @@ void unroute_setup(void) class_addlist(unroute_class, unroute_list); class_addanything(unroute_class, unroute_any); #ifndef MAXLIB + class_sethelpsymbol(unroute_class, gensym("help-unroute.pd")); + post(version); #else + class_addcreator((t_newmethod)unroute_new, gensym("unroute"), A_GIMME, 0); + class_sethelpsymbol(unroute_class, gensym("maxlib/help-unroute.pd")); #endif -} +} \ No newline at end of file diff --git a/src/urn.c b/src/urn.c index 4a09387..a657d42 100644 --- a/src/urn.c +++ b/src/urn.c @@ -127,16 +127,26 @@ notify: outlet_bang(x->x_notify); } +#ifndef MAXLIB void urn_setup(void) { urn_class = class_new(gensym("urn"), (t_newmethod)urn_new, 0, sizeof(t_urn), 0, A_DEFFLOAT, 0); +#else +void maxlib_urn_setup(void) +{ + urn_class = class_new(gensym("maxlib_urn"), (t_newmethod)urn_new, 0, + sizeof(t_urn), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)urn_new, gensym("urn"), A_DEFFLOAT, 0); +#endif class_addbang(urn_class, urn_bang); class_addmethod(urn_class, (t_method)urn_f, gensym("f"), A_FLOAT, 0); class_addmethod(urn_class, (t_method)urn_clear, gensym("clear"), 0); class_addmethod(urn_class, (t_method)urn_seed, gensym("seed"), A_FLOAT, 0); #ifndef MAXLIB + class_sethelpsymbol(urn_class, gensym("help-urn.pd")); post(version); #else + class_sethelpsymbol(urn_class, gensym("maxlib/help-urn.pd")); #endif -} +} \ No newline at end of file diff --git a/src/velocity.c b/src/velocity.c index a01aae5..7a003d0 100644 --- a/src/velocity.c +++ b/src/velocity.c @@ -83,19 +83,30 @@ static void *velocity_new(t_floatarg f) { t_velocity *x = (t_velocity *)pd_new(velocity_class); x->x_out = outlet_new(&x->x_ob, gensym("float")); -#ifndef MAXLIB - post(version); -#endif x->x_lasttime = clock_getlogicaltime(); return (void *)x; } +#ifndef MAXLIB void velocity_setup(void) { velocity_class = class_new(gensym("velocity"), (t_newmethod)velocity_new, (t_method)velocity_free, sizeof(t_velocity), 0, A_DEFFLOAT, 0); +#else +void maxlib_velocity_setup(void) +{ + velocity_class = class_new(gensym("maxlib_velocity"), (t_newmethod)velocity_new, + (t_method)velocity_free, sizeof(t_velocity), 0, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)velocity_new, gensym("velocity"), A_DEFFLOAT, 0); +#endif class_addfloat(velocity_class, velocity_float); class_addbang(velocity_class, velocity_bang); +#ifndef MAXLIB + class_sethelpsymbol(velocity_class, gensym("help-velocity.pd")); + post(version); +#else + class_sethelpsymbol(velocity_class, gensym("maxlib/help-velocity.pd")); +#endif } diff --git a/src/weibull.c b/src/weibull.c index 8df527e..1dbf4aa 100644 --- a/src/weibull.c +++ b/src/weibull.c @@ -73,12 +73,23 @@ static void rand_weibull_bang(t_rand_weibull *x) outlet_float(x->x_obj.ob_outlet, x->x_s*pow(log(a), tinv)); } +#ifndef MAXLIB void weibull_setup(void) { rand_weibull_class = class_new(gensym("weibull"), (t_newmethod)rand_weibull_new, 0, sizeof(t_rand_weibull), 0, A_DEFFLOAT, A_DEFFLOAT, 0); - class_addbang(rand_weibull_class, rand_weibull_bang); +#else +void maxlib_weibull_setup(void) +{ + rand_weibull_class = class_new(gensym("maxlib_weibull"), (t_newmethod)rand_weibull_new, 0, + sizeof(t_rand_weibull), 0, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)rand_weibull_new, gensym("weibull"), A_DEFFLOAT, A_DEFFLOAT, 0); +#endif + class_addbang(rand_weibull_class, rand_weibull_bang); #ifndef MAXLIB + class_sethelpsymbol(rand_weibull_class, gensym("help-weibull.pd")); post(version); +#else + class_sethelpsymbol(rand_weibull_class, gensym("maxlib/help-weibull.pd")); #endif } diff --git a/src/wrap.c b/src/wrap.c index cf94e6c..310772b 100644 --- a/src/wrap.c +++ b/src/wrap.c @@ -114,18 +114,29 @@ static void *wrap_new(t_floatarg fmin, t_floatarg fmax) x->x_min = fmin; wrap_b(x, fmax); -#ifndef MAXLIB - post(version); -#endif return (void *)x; } +#ifndef MAXLIB void wrap_setup(void) { wrap_class = class_new(gensym("wrap"), (t_newmethod)wrap_new, 0, sizeof(t_wrap), 0, A_DEFFLOAT, A_DEFFLOAT, 0); +#else +void maxlib_wrap_setup(void) +{ + wrap_class = class_new(gensym("maxlib_wrap"), (t_newmethod)wrap_new, + 0, sizeof(t_wrap), 0, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addcreator((t_newmethod)wrap_new, gensym("wrap"), A_DEFFLOAT, A_DEFFLOAT, 0); +#endif class_addfloat(wrap_class, wrap_float); class_addmethod(wrap_class, (t_method)wrap_a, gensym("a"), A_FLOAT, 0); class_addmethod(wrap_class, (t_method)wrap_b, gensym("b"), A_FLOAT, 0); +#ifndef MAXLIB + class_sethelpsymbol(wrap_class, gensym("help-wrap.pd")); + post(version); +#else + class_sethelpsymbol(wrap_class, gensym("maxlib/help-wrap.pd")); +#endif } -- cgit v1.2.1