53 files changed, 7325 insertions, 0 deletions
diff --git a/doc/pddp/all_about_arrays.pd b/doc/pddp/all_about_arrays.pd
new file mode 100644
index 00000000..9ef53ab8
--- /dev/null
+++ b/doc/pddp/all_about_arrays.pd
@@ -0,0 +1,677 @@
+#N canvas 0 0 653 613 12;
+#N canvas 132 0 591 609 What_is_an_array_in_PD 0;
+#X text 27 17 WHAT IS AN ARRAY IN PURE DATA?;
+#X text 45 42 Arrays \, in most programming environments \, are considered
+to be "a sequence of objects all of which have the same variable type"
+wherein each object is called an element and the elements are numbered
+in a row 0 \, 1 \, 2 \, 3 \, etc. These numbers are called indices.
+Each index holds a corresponding value.;
+#X text 46 222 Arrays in PD look like this:;
+#N canvas 0 0 450 300 graph18 0;
+#X array example_array 100 float 0;
+#X coords 0 1 99 -1 200 140 1;
+#X restore 277 225 graph;
+#X text 63 486 1 Right-click on the array and select "Properties" from
+the menu. Two dialogue boxes will open - one called "graph" and one
+called "array".;
+#X text 64 543 2 Then right-click again on the array and select "Help"
+from the menu. The window that opens is the table.pd help document.
+;
+#X text 45 148 All of this is true in PD \, except that arrays in PD
+can only hold floating point data. (other data types in PD are called
+"lists" or "anythings" and require different tools to manipulate them.)
+;
+#X text 45 378 The array above is actually only the horizontal line!
+The rectangle surrounding the array is called a "graph". These two
+objects are separate \, but PD creates both simoultaneously for purposes
+of convenience. These two objects together are called a "table". To
+see what I mean by all of this:;
+#X restore 43 42 pd What_is_an_array_in_PD;
+#N canvas 118 1 608 615 How_to_manipulate_arrays_in_PD 0;
+#X text 13 5 HOW TO MANIPULATE ARRAYS IN PD;
+#N canvas 0 0 452 302 graph28 0;
+#X array exampleArray 67 float 0;
+#X coords 0 2 67 -2 200 140 1;
+#X restore 369 451 graph;
+#N canvas 2 29 722 269 Setting_the_size_of_an_array 0;
+#X msg 44 88 \; exampleArray resize \$1;
+#X floatatom 44 66 5 0 0 0 - - -;
+#X text 16 18 1 The size of an array can be set using the array's dialogue
+box. Or with a [send] message like below.;
+#X text 15 65 2;
+#X text 231 91 same as;
+#X floatatom 305 66 5 0 0 0 - - -;
+#X obj 305 114 s exampleArray;
+#X msg 305 88 resize \$1;
+#X text 19 158 Note that new elements always have a default value of
+zero when you make an array larger. Also note that if you make arrays
+smaller \, you may lose data as each element is deleted from the end
+of the array.;
+#X connect 1 0 0 0;
+#X connect 5 0 7 0;
+#X connect 7 0 6 0;
+#X restore 24 270 pd Setting_the_size_of_an_array;
+#N canvas 4 30 720 447 Concatenate_two_arrays 0;
+#X text 19 10 This example assumes that we already know the size of
+the two arrays which will be concatenated. This process will fill NewArray
+with the contents of exampleArray and concatArray.;
+#N canvas 0 0 450 300 graph33 0;
+#X array concatArray 15 float 1;
+#A 0 -0.700355 -0.371783 -0.443212 -0.700355 -0.714641 -0.386069 0.0425035
+0.399647 0.513933 0.399647 0.128218 -0.128925 -0.21464 -0.0289252 -0.700355
+;
+#X coords 0 1 14 -1 200 140 1;
+#X restore 492 25 graph;
+#N canvas 0 0 450 300 graph34 0;
+#X array NewArray 82 float 0;
+#X coords 0 1 81 -1 300 140 1;
+#X restore 389 267 graph;
+#X obj 125 66 bng 15 250 50 0 empty empty Bang_me 18 7 0 8 -262144
+-1 -1;
+#X obj 28 96 until;
+#X obj 28 171 f;
+#X obj 58 171 + 1;
+#X obj 28 286 tabread exampleArray;
+#X obj 28 340 tabwrite NewArray;
+#X obj 141 311 tabread concatArray;
+#X text 372 194 This example is much more interesting if;
+#X text 373 212 you draw new values into each array with;
+#X text 373 230 your mouse - then reset and bang again.;
+#X obj 150 134 arraysize exampleArray;
+#X obj 125 163 arraysize concatArray;
+#X obj 125 188 +;
+#X msg 178 241 \; NewArray resize \$1;
+#X text 28 75 loop;
+#X obj 28 219 moses;
+#X obj 141 254 -;
+#X obj 125 85 t b b b;
+#X obj 125 212 t f f;
+#X msg 47 144 0;
+#X obj 176 109 s clr1;
+#X obj 47 119 r clr1;
+#X connect 3 0 20 0;
+#X connect 4 0 5 0;
+#X connect 5 0 6 0;
+#X connect 5 0 18 0;
+#X connect 5 0 8 1;
+#X connect 6 0 5 1;
+#X connect 7 0 8 0;
+#X connect 9 0 8 0;
+#X connect 13 0 15 1;
+#X connect 13 0 19 1;
+#X connect 13 0 18 1;
+#X connect 14 0 15 0;
+#X connect 15 0 21 0;
+#X connect 18 0 7 0;
+#X connect 18 1 19 0;
+#X connect 19 0 9 0;
+#X connect 20 0 14 0;
+#X connect 20 1 13 0;
+#X connect 20 2 23 0;
+#X connect 21 0 4 0;
+#X connect 21 1 16 0;
+#X connect 22 0 5 1;
+#X connect 24 0 22 0;
+#X restore 24 371 pd Concatenate_two_arrays;
+#N canvas 4 30 735 395 Join_array_elements_into_a_list 0;
+#X text 16 12 JOIN ARRAY ELEMENTS INTO A LIST;
+#X obj 22 163 bng 15 250 50 0 empty empty Bang_me 18 7 0 8 -24198 -1
+-1;
+#X obj 23 241 until;
+#X obj 24 320 tabread exampleArray;
+#X obj 216 235 pack s f;
+#X obj 216 183 t b f;
+#X obj 24 292 f;
+#X obj 58 292 + 1;
+#X obj 24 348 s \$1-value;
+#X obj 216 157 r \$1-value;
+#X obj 216 261 route list;
+#X obj 519 210 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 519 229 savepanel;
+#X msg 519 252 \; exampleArray write \$1;
+#X obj 283 353 print;
+#X text 289 330 store the list;
+#X obj 283 312 textfile;
+#X msg 345 285 rewind;
+#X obj 216 209 symbol add2;
+#X obj 310 240 bng 15 250 50 0 empty empty THEN_Print_the_list 18 7
+0 8 -24198 -1 -1;
+#X text 451 308 can be achieved by saving the;
+#X text 451 324 array elements to a text file;
+#X text 452 341 using the savepanel and write;
+#X text 453 357 message.;
+#X text 452 292 Alternatively \, a similar result;
+#X obj 22 183 arraysize exampleArray;
+#X msg 129 261 clear;
+#X obj 310 261 t b b;
+#X msg 74 260 0;
+#X text 29 37 In some other programming environments \, including Visual
+Basic and Java (among others) \, there are functions which join all
+elements of an array into a list. This example shows how this functionality
+can be duplicated in PD. This example uses the elements of exampleArray
+from the previous help window. The list can either be printed to the
+terminal window \, or it can be saved to a text file.;
+#X obj 23 214 t f b;
+#X connect 1 0 25 0;
+#X connect 2 0 6 0;
+#X connect 3 0 8 0;
+#X connect 4 0 10 0;
+#X connect 5 0 18 0;
+#X connect 5 1 4 1;
+#X connect 6 0 7 0;
+#X connect 6 0 3 0;
+#X connect 7 0 6 1;
+#X connect 9 0 5 0;
+#X connect 10 0 16 0;
+#X connect 11 0 12 0;
+#X connect 12 0 13 0;
+#X connect 16 0 14 0;
+#X connect 17 0 16 0;
+#X connect 18 0 4 0;
+#X connect 19 0 27 0;
+#X connect 25 0 30 0;
+#X connect 26 0 16 0;
+#X connect 27 0 16 0;
+#X connect 27 1 17 0;
+#X connect 28 0 6 1;
+#X connect 30 0 2 0;
+#X connect 30 1 28 0;
+#X connect 30 1 26 0;
+#X restore 24 397 pd Join_array_elements_into_a_list;
+#N canvas 2 29 719 337 Getting_the_size_of_an_array 0;
+#X text 15 11 GETTING THE SIZE OF AN ARRAY;
+#X text 34 34 If you deal with arrays often \, you will want to download
+the [arraysize] external written by PIX. PD lacks a native object for
+this purpose and I'm afraid that without this external this functionality
+is impossible in PD.;
+#X obj 38 127 arraysize exampleArray;
+#X obj 38 107 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X floatatom 38 152 5 0 0 0 - - -;
+#X text 35 183 Having said that...PD arrays accept a "print" command
+which will output important array information to the terminal window.
+Like below:;
+#X msg 40 258 \; exampleArray print;
+#X connect 2 0 4 0;
+#X connect 3 0 2 0;
+#X restore 24 320 pd Getting_the_size_of_an_array;
+#N canvas 0 31 721 390 Reversing_an_array 0;
+#X text 20 15 REVERSING AN ARRAY;
+#X text 23 35 When an array is reversed \, as the name implies the
+first element becomes the last and the last becomes the first. When
+viewing this example \, please be sure you can see the "exampleArray"
+in the previous window.;
+#X obj 110 109 bng 15 250 50 0 empty empty Reverse_me 18 7 0 8 -262144
+-1 -1;
+#X obj 110 128 arraysize exampleArray;
+#X obj 110 200 until;
+#X obj 176 228 + 1;
+#X obj 144 228 f;
+#X obj 135 176 s \$1-length;
+#X obj 169 281 tabread exampleArray;
+#X obj 313 342 table tempArray;
+#X obj 110 152 t f f f;
+#X obj 234 196 s tempArray;
+#X msg 234 172 resize \$1;
+#X obj 65 308 tabwrite tempArray;
+#X obj 510 41 sel;
+#X obj 586 31 - 1;
+#X obj 586 7 r \$1-length;
+#X obj 144 254 t f f f;
+#X obj 57 278 s \$1-eof;
+#X obj 510 8 r \$1-eof;
+#X obj 510 113 until;
+#X obj 510 88 f;
+#X obj 510 161 f;
+#X obj 542 161 - 1;
+#X obj 561 108 r \$1-length;
+#X obj 529 64 r \$1-length;
+#X obj 510 213 tabread tempArray;
+#X obj 510 345 tabwrite exampleArray;
+#X obj 574 265 f;
+#X obj 593 241 r \$1-length;
+#X obj 574 314 mod;
+#X obj 593 289 r \$1-length;
+#X obj 604 265 + 1;
+#X obj 510 186 t f b;
+#X obj 561 131 - 1;
+#X text 13 346 Copies array to a temporary location.;
+#X msg 327 124 0;
+#X obj 327 148 s clr2;
+#X obj 443 150 r clr2;
+#X obj 163 200 r clr2;
+#X connect 2 0 3 0;
+#X connect 2 0 36 0;
+#X connect 3 0 10 0;
+#X connect 4 0 6 0;
+#X connect 5 0 6 1;
+#X connect 6 0 5 0;
+#X connect 6 0 17 0;
+#X connect 8 0 13 0;
+#X connect 10 0 4 0;
+#X connect 10 1 7 0;
+#X connect 10 2 12 0;
+#X connect 12 0 11 0;
+#X connect 14 0 21 0;
+#X connect 15 0 14 1;
+#X connect 16 0 15 0;
+#X connect 17 0 18 0;
+#X connect 17 1 8 0;
+#X connect 17 2 13 1;
+#X connect 19 0 14 0;
+#X connect 20 0 22 0;
+#X connect 21 0 20 0;
+#X connect 22 0 23 0;
+#X connect 22 0 33 0;
+#X connect 23 0 22 1;
+#X connect 24 0 34 0;
+#X connect 25 0 21 1;
+#X connect 26 0 27 0;
+#X connect 28 0 30 0;
+#X connect 28 0 32 0;
+#X connect 29 0 28 1;
+#X connect 30 0 27 1;
+#X connect 31 0 30 1;
+#X connect 32 0 28 1;
+#X connect 33 0 26 0;
+#X connect 33 1 28 0;
+#X connect 34 0 22 1;
+#X connect 36 0 37 0;
+#X connect 38 0 22 1;
+#X connect 39 0 6 1;
+#X restore 24 474 pd Reversing_an_array;
+#N canvas 2 30 719 390 Popping_and_Pushing_arrays 0;
+#X obj 62 181 bng 15 250 50 0 empty empty Pop_me -18 -6 0 8 -262144
+-1 -1;
+#X obj 134 199 arraysize exampleArray;
+#X obj 134 294 tabread exampleArray;
+#X floatatom 134 318 0 0 0 0 - - -;
+#X obj 99 173 t b b;
+#X obj 51 320 - 1;
+#X msg 51 346 \; exampleArray resize \$1;
+#X floatatom 158 223 0 0 0 0 - - -;
+#X text 175 318 value of last element;
+#X obj 458 188 bng 15 250 50 0 empty empty Push_me 18 7 0 8 -262144
+-1 -1;
+#X text 31 33 I got this idea from Java \, which provides a method
+to "pop" an array. The "pop" method will remove the last element in
+the array and return its value. The interesting thing about this in
+PD is that we need to know the length of the array before we start
+(hence another situation where [arraysize] is an essential tool). "Pushing"
+is the opposite effect and also a tool provided in Java. When an array
+is pushed \, an element is added to the array and the new size is returned.
+;
+#X obj 458 208 arraysize exampleArray;
+#X obj 458 232 + 1;
+#X msg 458 292 \; exampleArray resize \$1;
+#X floatatom 476 258 0 0 0 0 - - -;
+#X text 521 258 new size;
+#X text 16 12 POPPING AND PUSHING AN ARRAY;
+#X obj 158 246 - 1;
+#X text 197 223 # of total elements;
+#X floatatom 158 271 0 0 0 0 - - -;
+#X text 198 273 new size;
+#X connect 0 0 4 0;
+#X connect 1 0 2 0;
+#X connect 1 0 5 0;
+#X connect 1 0 7 0;
+#X connect 2 0 3 0;
+#X connect 4 0 5 0;
+#X connect 4 1 1 0;
+#X connect 5 0 6 0;
+#X connect 7 0 17 0;
+#X connect 9 0 11 0;
+#X connect 11 0 12 0;
+#X connect 12 0 13 0;
+#X connect 12 0 14 0;
+#X connect 17 0 19 0;
+#X restore 24 423 pd Popping_and_Pushing_arrays;
+#N canvas 2 30 722 391 Shifting_an_array 0;
+#X obj 30 90 bng 15 250 50 0 empty empty Shift_me 18 7 0 8 -24198 -1
+-1;
+#X text 16 12 SHIFTING AN ARRAY;
+#X text 20 32 The shift method \, in Java \, will remove the first
+element of the array and return its value. This is opposite of the
+"Pop" method which removes the last element.;
+#X obj 30 272 tabread exampleArray;
+#X obj 30 354 tabwrite tempArray2;
+#X obj 551 11 table tempArray2;
+#X obj 30 110 arraysize exampleArray;
+#X msg 225 160 \; tempArray2 resize \$1;
+#X obj 30 163 until;
+#X obj 30 215 f;
+#X obj 62 215 + 1;
+#X obj 30 136 t f f f;
+#X obj 129 167 s \$1-length;
+#X obj 160 301 spigot;
+#X obj 203 276 < 1;
+#X floatatom 160 328 5 0 0 0 - - -;
+#X text 209 327 First value.;
+#X text 208 345 ...to be deleted.;
+#X obj 304 239 - 1;
+#X obj 304 212 r \$1-length;
+#X obj 30 239 t f f f f;
+#X obj 285 263 sel;
+#X obj 285 288 s \$2-eof;
+#X obj 427 71 r \$2-eof;
+#X obj 427 95 t b b;
+#X msg 419 304 \; tempArray2 resize \$1 \; exampleArray resize \$1
+;
+#X obj 401 256 r \$1-length;
+#X obj 401 280 - 1;
+#X obj 382 304 f;
+#X obj 497 128 until;
+#X obj 497 102 f;
+#X obj 551 69 r \$1-length;
+#X obj 529 155 + 1;
+#X obj 574 156 r \$1-length;
+#X obj 497 184 mod;
+#X obj 497 155 f 1;
+#X obj 497 209 t f f;
+#X obj 497 257 tabread tempArray2;
+#X obj 497 281 tabwrite exampleArray;
+#X obj 551 93 - 1;
+#X obj 574 179 - 1;
+#X obj 497 234 + 1;
+#X msg 223 105 0;
+#X msg 588 118 1;
+#X obj 223 129 s clr;
+#X obj 588 94 r clr;
+#X obj 49 188 r clr;
+#X connect 0 0 6 0;
+#X connect 0 0 42 0;
+#X connect 3 0 4 0;
+#X connect 3 0 13 0;
+#X connect 6 0 11 0;
+#X connect 8 0 9 0;
+#X connect 9 0 10 0;
+#X connect 9 0 20 0;
+#X connect 10 0 9 1;
+#X connect 11 0 8 0;
+#X connect 11 1 12 0;
+#X connect 11 2 7 0;
+#X connect 13 0 15 0;
+#X connect 14 0 13 1;
+#X connect 18 0 21 1;
+#X connect 19 0 18 0;
+#X connect 20 0 3 0;
+#X connect 20 1 4 1;
+#X connect 20 2 14 0;
+#X connect 20 3 21 0;
+#X connect 21 0 22 0;
+#X connect 23 0 24 0;
+#X connect 24 0 28 0;
+#X connect 24 1 30 0;
+#X connect 26 0 27 0;
+#X connect 27 0 28 1;
+#X connect 28 0 25 0;
+#X connect 29 0 35 0;
+#X connect 30 0 29 0;
+#X connect 31 0 39 0;
+#X connect 32 0 35 1;
+#X connect 33 0 40 0;
+#X connect 34 0 36 0;
+#X connect 35 0 32 0;
+#X connect 35 0 34 0;
+#X connect 36 0 41 0;
+#X connect 36 1 38 1;
+#X connect 37 0 38 0;
+#X connect 39 0 30 1;
+#X connect 40 0 34 1;
+#X connect 41 0 37 0;
+#X connect 42 0 44 0;
+#X connect 43 0 35 1;
+#X connect 45 0 43 0;
+#X connect 46 0 9 1;
+#X restore 24 449 pd Shifting_an_array;
+#X text 25 32 Arrays in PD are different than the arrays in other languages
+primarily because \, in PD \, they are designed to be displayed graphically
+on screen. This is due to the nature of audio synthesis - we want to
+see our wave forms and visually understand the data. That's why arrays
+in PD are complicated by other objects like tables \, graphs and widgets.
+PD uses these objects to provide a graphic representation of the array
+data. If you're not interested in seeing the array data within your
+PD patch \, you can use the [table] object to store the array and corresponding
+table in a sub-window. Note that [table]s are more CPU friendly than
+their graphical counterpart.;
+#X text 26 230 Like all programming languages \, PD provides numerous
+tools to manipulate arrays and their data.;
+#N canvas 3 32 718 310 Setting_a_constant_array_value 0;
+#X floatatom 26 151 0 0 0 0 - - -;
+#X obj 26 185 / 100;
+#X msg 26 215 \; exampleArray const \$1;
+#X text 18 16 SETTING A CONSTANT ARRAY VALUE;
+#X text 27 46 By default \, all array element values are zero. However
+\, PD allows you to change that using the "CONST" message.;
+#X text 26 88 This feature is useful to reset all values in an array
+\, or with a little creativity can be used to "delete" a slice \, or
+create silence in audio samples.;
+#X connect 0 0 1 0;
+#X connect 1 0 2 0;
+#X restore 24 345 pd Setting_a_constant_array_value;
+#N canvas 3 26 727 395 Higher_math_using_arrays 0;
+#X text -7 12 HIGHER MATH USING ARRAYS;
+#X text -3 226 Normalize;
+#X text 78 227 (arg: renormer...a number by which all array values
+will be normalized);
+#X msg 6 278 \; exampleArray normalize \$1;
+#X floatatom 6 256 5 0 0 0 - - -;
+#N canvas 5 55 710 432 sine_waves 0;
+#X text 34 188 Sinesum;
+#X text 98 190 (arg 1: Number of Points - arg 2: list of partial strengths)
+;
+#X msg 40 293 \; exampleArray sinesum 64 1 0 0.5 0 0.2 0 0.15;
+#X msg 40 251 \; exampleArray sinesum 64 1 0.5 0.38 0.3 0.28 0.25 0.2
+;
+#X msg 40 210 \; exampleArray sinesum 64 1;
+#X text 26 7 SINE WAVES;
+#X text 29 30 comment;
+#X text 45 29 When the "sinesum" message is sent to the array \, PD
+will want to know two things:;
+#X text 58 65 1 How many samples (array elements) should be used? The
+higher the number is \, the higher the resolution of the wave form.
+;
+#X text 58 122 2 What is the relative strength of each "partial" or
+"overtone" in the sound? For more info about this \, please lookup
+"overtones" or "harmonics" or "partials" on the internet.;
+#X text 250 220 a pure sine wave!;
+#X text 479 259 a triangle wave;
+#X text 412 303 a square wave;
+#X text 33 346 Note that these waves aren't exactly triangular or square...instead
+they are "smoothed" by the sinesum function to more accurately produce
+these wave forms as analog instruments do.;
+#X restore 7 42 pd sine_waves;
+#X text 141 26 Audio signals in a digital realm are created using a
+series of samples. It is digitally possible to create extremely angular
+wave forms using PD arrays \, but the aural result is sometimes distorted
+and unpleasant. Hence \, higher math functions help our digital tools
+to produce data which can effectively be converted to analog signals
+similar to those of our electronic and mechanical predecessors. The
+first and one of the most important mathematic functions in digital
+synthesis is undoubtebly "sinesum". PD provides an easy method for
+us to integrate these higher math functions in our arrays.;
+#N canvas 0 195 750 302 cosine_waves 0;
+#X text 11 22 Cosinesum;
+#X text 91 22 (arg 1: Number of Points - arg 2: list of partial strengths)
+;
+#X text 273 84 pure cosine wave!;
+#X msg 23 117 \; exampleArray cosinesum 64 0 -0.5 0 -0.2 0.1 0;
+#X msg 24 76 \; exampleArray cosinesum 64 0 1;
+#X msg 22 159 \; exampleArray cosinesum 64 -0.15 0.2 0.15 -0.15 0.1
+0.1 0.2 -0.2 0.35 -0.25 -0.1 0.1 0.199;
+#X restore 6 73 pd cosine_waves;
+#X text 222 257 To normalize an audio signal means to alter the average
+amplitude of the signal. For the sake of clear \, undistored sounds
+\, PD would like all of your audio signals to never exceed 1 or -1
+The first step in achieving this is "normalization" \, but can be assisted
+by more drastic tools like compressors \, limiters \, gain multipliers
+\, etc.;
+#X connect 4 0 3 0;
+#X restore 24 499 pd Higher_math_using_arrays;
+#N canvas 2 31 727 416 Files_and_arrays 0;
+#X text 24 14 OTHER IMPORTANT STUFF;
+#X obj 225 91 savepanel;
+#X obj 225 70 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X msg 225 117 \; exampleArray write \$1;
+#X obj 475 70 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 475 89 openpanel;
+#X msg 475 113 \; exampleArray read \$1;
+#X text 26 29 Using text files can be helpful in saving or loading
+arrays in PD. Note that the "read" message does not resize your array
+automatically.;
+#X text 29 160 Audio files can be treated in similar ways by incorporating
+the [soundfiler] object. The soundfiler object provides PD with tools
+to automatically resize arrays \, and read/write audio files in a variety
+of formats.;
+#X obj 77 231 openpanel;
+#X obj 52 232 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 4 280 symbol read;
+#X obj 54 380 soundfiler;
+#X obj 54 355 route list;
+#X obj 54 332 pack s s s s;
+#X obj 100 280 symbol -resize;
+#X obj 78 254 t b b s b;
+#X obj 145 305 symbol exampleArray;
+#X obj 373 231 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 375 378 soundfiler;
+#X obj 375 353 route list;
+#X obj 375 330 pack s s s s;
+#X obj 399 253 t b b s b;
+#X obj 466 303 symbol exampleArray;
+#X obj 398 230 savepanel;
+#X obj 317 278 symbol write;
+#X obj 421 278 symbol -aiff;
+#X connect 1 0 3 0;
+#X connect 2 0 1 0;
+#X connect 4 0 5 0;
+#X connect 5 0 6 0;
+#X connect 9 0 16 0;
+#X connect 10 0 9 0;
+#X connect 11 0 14 0;
+#X connect 13 0 12 0;
+#X connect 14 0 13 0;
+#X connect 15 0 14 1;
+#X connect 16 0 11 0;
+#X connect 16 1 15 0;
+#X connect 16 2 14 2;
+#X connect 16 3 17 0;
+#X connect 17 0 14 3;
+#X connect 18 0 24 0;
+#X connect 20 0 19 0;
+#X connect 21 0 20 0;
+#X connect 22 0 25 0;
+#X connect 22 1 26 0;
+#X connect 22 2 21 2;
+#X connect 22 3 23 0;
+#X connect 23 0 21 3;
+#X connect 24 0 22 0;
+#X connect 25 0 21 0;
+#X connect 26 0 21 1;
+#X restore 24 526 pd Files_and_arrays;
+#N canvas 0 0 719 423 Additional_tools 0;
+#X text 18 14 ADDITIONAL TOOLS;
+#X text 29 38 The "array" object in PD accepts special messages to
+alter the appearance of the array on screen.;
+#X text 19 81 Arrays can be renamed:;
+#X msg 203 78 \; exampleArray rename george;
+#X msg 431 78 \; george rename exampleArray;
+#X msg 303 173 \; exampleArray bounds 0 1 67 -1;
+#X text 20 129 You can set the bounds of the rectangle: (the arguments
+are:;
+#X text 353 146 low x \, high y \, high x \, low y);
+#X msg 58 173 \; exampleArray bounds 0 2 67 -2;
+#X text 18 219 Array graphs can be given "ticks" on both the x and
+y axis to help you visually measure your data. The tick messages require
+3 values: (the index or value of the FIRST large tick \, then the interval
+between ticks \, then finally the number of ticks overall per large
+tick).;
+#X msg 488 243 \; exampleArray xticks 0 5 3;
+#X msg 471 290 \; exampleArray yticks 0 0.5 4;
+#X msg 354 369 \; exampleArray ylabel -5 -2 -1.5 -1 1 1.5 2;
+#X msg 26 369 \; exampleArray xlabel 0 10 20 30 40 50 60;
+#X text 17 325 Arrays can be given labels to describe the x and y axis.
+Give a y value and a bunch of x values or vice versa:;
+#X restore 24 553 pd Additional_tools;
+#N canvas 4 29 717 375 Populating_an_array 0;
+#X text 27 12 POPULATING AN ARRAY;
+#X text 41 37 An array in PD is primarily a storage device for numbers.
+The result is a series of numbers that you can do with whatever you
+wish...but how does one populate an array?;
+#X text 53 185 list element 1 = array[0];
+#X text 53 201 list element 2 = array[1];
+#X text 39 94 Advanced techniques using text or audio files is described
+later \, but for now it's important to know that you can send an array
+a list. Each element in the list will be assigned to the corresponding
+element in the array. Note that the first index in an array is always
+zero!;
+#X msg 39 303 \; exampleArray 0 -1 1 -1 0.5 -0.5 0.5 -0.2 0.2 -0.2
+0.1 -0.1 0;
+#X text 37 232 Note that if your array is larger than your list \,
+then only the first elements will be effected. If your array is smaller
+than your list \, then your list will be truncated.;
+#X restore 24 295 pd Populating_an_array;
+#X restore 41 173 pd How_to_manipulate_arrays_in_PD;
+#N canvas 132 0 587 609 How_to_create_an_array_in_PD 0;
+#X text 22 9 1 Select "array" from the "Put" menu above.;
+#X text 21 288 4 If you want PD to create a new graph for this array
+\, then select "in new graph". If you have another location in mind
+-- for example if you want to overlap two arrays in a single graph
+\, then select "in last graph".;
+#X text 19 361 5 Then click "OK" and place the new array anywhere in
+this window.;
+#X text 19 403 6 Note: if you do not want to see the graph in this
+window \, then you can use the [table] object instead...the array will
+then be created inside the [table] object and will be seen only if
+you manually open the table.;
+#X text 22 31 2 A dialogue box appears where you can type the name
+of the array and the desired size. Names can be anything you want -
+if you want a localized array \, then name it something like \$1-dave
+(the dollar sign indicates that part of the name is a variable which
+is unique to this patch). The size of the array can be anything greater
+than 0 (zero). At a sample rate of 441000 khz \, an array of 882000
+will provide you with 2 seconds of audio data.;
+#X text 21 167 3 The "Save contents" checkbox will inform Pure Data
+that you want the array saved within the source code of this patch.
+This way \, you can ensure that the array will maintain its values
+each time you open this patch. This is recommended only for relatively
+small arrays...larger arrays should be saved to either a text file
+\, or an audio file.;
+#X restore 42 106 pd How_to_create_an_array_in_PD;
+#N canvas 133 1 646 607 Common_uses_for_arrays_in_PD 0;
+#X text 27 26 COMMON USES FOR ARRAYS IN PD;
+#X text 49 60 Arrays are versatile. Their simple structure make them
+useful in countless situations. This page discusses perhaps the most
+common applications.;
+#X text 50 225 2 MIDI Sequencers: array values limited to a range between
+0 and 127 are suitable for MIDI output to be used as pitch \, velocity
+\, or controller numbers. Some MIDI information requires a much larger
+range \, such as pitch benders.;
+#X text 50 306 3 Envelopes: an array with four elements can be used
+effectively as an ADSR enveloper. There are numerous examples of this
+in other PD help documents.;
+#X text 53 377 4 Math and conversion tables: arrays are an excellent
+visual tool when performing fourier analysis and other higher mathematic
+functions.;
+#X text 54 450 5 Wave editing: with proper manipulation of array data
+\, PD can be fully functional wave editor \, complete with mouse-clickable
+cut-n-paste \, pitch-shift \, time expansion \, down/upsampling \,
+and other tools typically found in commercial wave editors.;
+#X text 49 128 1 Audio sample data: when an array's values are limited
+to a range between -1 and 1 \, the numbers are suitable for conversion
+to analog audio signal. These arrays are typically many thousands of
+elements and stored on hard disk in the form of aiff \, wav or pure
+text.;
+#X restore 40 239 pd Common_uses_for_arrays_in_PD;
+#X text 39 309 NOTE: I strongly recommend that you download the [arraysize]
+external to your "pd/extra" folder before continuing. Some of these
+examples are impossible without it -- I personally feel that [arraysize]
+should be considered for permanent inclusion in future PD distributions.
+Check the CVS Repository or Pure-data.org for [arraysize].;
+#X text 40 459 This document is meant to supplement the help documentation
+for [table] \, [tabread] \, [tabwrite] \, [soundfiler] \, [tabsend~]
+\, [tabreceive~] \, [tabplay~] \, etc.;
diff --git a/doc/pddp/help-acoustics.pd b/doc/pddp/help-acoustics.pd
new file mode 100644
index 00000000..094b47b4
--- /dev/null
+++ b/doc/pddp/help-acoustics.pd
@@ -0,0 +1,583 @@
+#N canvas 22 16 828 633 10;
+#X obj 12 58 mtof;
+#X floatatom 12 81 0 0 0;
+#X obj 12 105 ftom;
+#X floatatom 12 126 0 0 0;
+#X text 46 11 ACOUSTIC CONVERSIONS;
+#X text 47 58 -- MIDI note number to frequency converter.;
+#N canvas 37 -4 899 659 understanding_mtof 0;
+#X text 20 13 [mtof] will convert MIDI note numbers to Wave Freqeuency.
+This object exists in PD for the sake of convenience and speed of processing.
+;
+#X obj 37 165 mtof;
+#X floatatom 37 143 5 0 0;
+#X text 77 142 Select a MIDI note: (Middle C is 60).;
+#X floatatom 37 188 5 0 0;
+#X obj 37 207 osc~;
+#X floatatom 99 203 0 0 0;
+#N canvas 397 146 628 393 output 0;
+#X obj 393 156 t b;
+#X obj 393 106 f;
+#X obj 393 56 inlet;
+#X text 399 25 mute;
+#X obj 393 181 f;
+#X msg 480 174 0;
+#X msg 393 81 bang;
+#X obj 393 131 moses 1;
+#X obj 480 149 t b f;
+#X obj 452 113 moses 1;
+#X obj 138 144 dbtorms;
+#X obj 452 88 r master-lvl;
+#X obj 138 38 r master-lvl;
+#X obj 393 206 s master-lvl;
+#X obj 22 181 inlet~;
+#X obj 254 37 inlet;
+#X text 254 14 level;
+#X obj 254 152 s master-lvl;
+#X msg 151 61 set \$1;
+#X obj 151 85 outlet;
+#X obj 138 190 line~;
+#X obj 22 212 *~;
+#X obj 138 167 pack 0 50;
+#X text 34 159 audio;
+#X text 148 106 show level;
+#X obj 73 182 inlet~;
+#X obj 73 213 *~;
+#X obj 22 241 dac~ 1;
+#X obj 73 241 dac~ 2;
+#X msg 290 82 1;
+#X obj 265 59 sel 0;
+#X msg 265 119 \; pd dsp \$1;
+#X msg 265 82 0;
+#X connect 0 0 4 0;
+#X connect 1 0 7 0;
+#X connect 2 0 6 0;
+#X connect 4 0 13 0;
+#X connect 5 0 13 0;
+#X connect 5 0 31 0;
+#X connect 6 0 1 0;
+#X connect 7 0 0 0;
+#X connect 7 1 8 0;
+#X connect 8 0 5 0;
+#X connect 9 1 4 1;
+#X connect 10 0 22 0;
+#X connect 11 0 1 1;
+#X connect 11 0 9 0;
+#X connect 12 0 10 0;
+#X connect 12 0 18 0;
+#X connect 14 0 21 0;
+#X connect 15 0 17 0;
+#X connect 15 0 30 0;
+#X connect 18 0 19 0;
+#X connect 20 0 21 1;
+#X connect 20 0 26 1;
+#X connect 21 0 27 0;
+#X connect 22 0 20 0;
+#X connect 25 0 26 0;
+#X connect 26 0 28 0;
+#X connect 29 0 31 0;
+#X connect 30 0 32 0;
+#X connect 30 1 29 0;
+#X connect 32 0 31 0;
+#X restore 37 232 pd output;
+#X msg 128 204 MUTE;
+#X text 164 203 <-- Turn up your volume here.;
+#X text 15 260 HERE IS THE ALTERNATIVE;
+#X obj 36 321 mtof;
+#X floatatom 36 281 5 0 0;
+#X floatatom 15 345 0 0 0;
+#X floatatom 123 461 0 0 0;
+#X obj 138 312 <= -1500;
+#X obj 138 332 expr 1-$f1;
+#X obj 95 352 spigot;
+#X obj 95 295 t f f;
+#X obj 95 372 min 1499;
+#X obj 95 419 expr (8.17579891564*exp(0.0577622650*$f1));
+#X obj 151 352 s zero;
+#X obj 123 440 r zero;
+#X obj 96 485 bang;
+#X obj 36 482 bang;
+#X obj 36 502 realtime;
+#X floatatom 161 576 0 0 0;
+#X obj 204 499 bang;
+#X obj 161 499 bang;
+#X obj 161 519 realtime;
+#X floatatom 161 540 0 0 0;
+#X obj 365 389 *;
+#X obj 408 342 loadbang;
+#X obj 365 408 exp;
+#X obj 365 428 *;
+#X floatatom 365 448 0 0 0;
+#X obj 397 431 r zero;
+#X text 79 277 Select a MIDI note here.;
+#X obj 477 572 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 477 12 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 496 123 The examples at the botton left are PD structures which
+emulate the source code of the [mtof] object. In one case \, I have
+used the [expr] object to perform the necessary calculation. In the
+other case \, I used PD's Arithmetic objects to perform the calculation.
+;
+#X text 498 291 Secondly \, the incoming MIDI note number is translated
+into a frequency value by the simple equation:;
+#X text 494 330 (8.17579891564 * exp(0.0577622650 * MIDI_note)) = frequency
+;
+#X text 498 355 For curiosity's sake \, I included a timer to show
+how much faster the [mtof] object is compared to the two alternative
+methods.;
+#X text 162 556 Arithmetic is __?__ milliseconds slower than [mtof].
+;
+#X text 159 592 [expr] is __?__ milliseconds slower than [mtof].;
+#X text 12 363 RESULT A;
+#X text 123 476 RESULT B;
+#X text 364 465 RESULT C;
+#X msg 408 363 0.0577623;
+#X msg 408 403 8.1758;
+#X text 504 12 THE ALTERNATIVE EXPLAINED;
+#X text 499 33 The [mtof] object is really just a function defined
+in PD's source code - which is programmed in "C".;
+#X text 497 67 As such \, it operates very quickly. If a similar function
+were to be created using PD's arithmetic objects \, the process would
+be quite a bit slower. How much slower?;
+#X text 498 409 As well \, notice that RESULT C (the output from PD's
+basic arithmetic objects) is not as accurate as the other two methods:
+[mtof] and/or [expr]. This is because the message boxes and the [*]
+object round off the operands because they cannot handle enough decimal
+places.;
+#X text 498 200 The first order of business performed by these examples
+is the filtering out of all numbers less than -1500 and greater than
+1499 (Just like the [mtof] source code). In other words \, "overflows
+and underflows are clipped" as Miller Puckette stated in the original
+documentation for this object.;
+#X text 22 62 MIDI notes usually range between 0 and 127 from an incoming
+MIDI controller. However \, in PD negative numbers to -1500 and positive
+numbers to 1499 are also supported and decimal places can be used to
+achive microtonal pitches.;
+#X text 11 125 CONVENIENT? YES!;
+#X connect 1 0 4 0;
+#X connect 2 0 1 0;
+#X connect 4 0 5 0;
+#X connect 5 0 7 0;
+#X connect 6 0 7 2;
+#X connect 7 0 6 0;
+#X connect 8 0 7 3;
+#X connect 11 0 13 0;
+#X connect 11 0 24 0;
+#X connect 12 0 11 0;
+#X connect 12 0 18 0;
+#X connect 15 0 16 0;
+#X connect 16 0 17 1;
+#X connect 16 0 21 0;
+#X connect 17 0 19 0;
+#X connect 18 0 17 0;
+#X connect 18 1 15 0;
+#X connect 19 0 20 0;
+#X connect 19 0 23 0;
+#X connect 19 0 31 0;
+#X connect 20 0 14 0;
+#X connect 22 0 14 0;
+#X connect 23 0 25 1;
+#X connect 24 0 25 0;
+#X connect 24 0 28 0;
+#X connect 25 0 26 0;
+#X connect 27 0 29 1;
+#X connect 28 0 29 0;
+#X connect 29 0 30 0;
+#X connect 31 0 33 0;
+#X connect 32 0 49 0;
+#X connect 32 0 50 0;
+#X connect 33 0 34 0;
+#X connect 34 0 35 0;
+#X connect 34 0 27 0;
+#X connect 36 0 35 0;
+#X connect 39 0 38 0;
+#X connect 49 0 31 1;
+#X connect 50 0 34 1;
+#X restore 175 75 pd understanding_mtof;
+#X text 47 105 -- Frequency to MIDI note number converter.;
+#N canvas 118 -18 919 630 understanding_ftom 0;
+#X floatatom 38 86 5 0 0;
+#X floatatom 38 131 5 0 0;
+#X text 12 215 HERE IS THE ALTERNATIVE;
+#X floatatom 33 236 5 0 0;
+#X floatatom 12 300 0 0 0;
+#X obj 507 572 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 507 12 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 9 318 RESULT A;
+#X text 534 12 THE ALTERNATIVE EXPLAINED;
+#X text 527 67 As such \, it operates very quickly. If a similar function
+were to be created using PD's arithmetic objects \, the process would
+be quite a bit slower. How much slower?;
+#X text 12 68 CONVENIENT? YES!;
+#X text 22 14 [ftom] will convert Wave/Signal Frequency to MIDI note
+numbers. This object exists in PD for the sake of convenience and speed
+of processing.;
+#X text 78 85 Select a Frequency: (i.e. 440 hz is an "A" above middle
+C);
+#X obj 38 108 ftom;
+#X obj 38 158 makenote 100 500;
+#X obj 38 181 noteout;
+#X text 76 232 Select a FREQUENCY here.;
+#X obj 33 276 ftom;
+#X text 529 33 The [ftom] object is really just a function defined
+in PD's source code - which is programmed in "C".;
+#X text 526 123 The examples at the botton left are PD structures which
+emulate the source code of the [ftom] object. In one case \, I have
+used the [expr] object to perform the necessary calculation. In the
+other case \, I used PD's Arithmetic objects to perform the calculation.
+;
+#X obj 64 256 moses 0;
+#X msg 64 277 -1500;
+#X floatatom 64 408 0 0 0;
+#X floatatom 114 346 0 0 0;
+#X obj 114 313 * 17.3123;
+#X obj 114 273 * 0.122312;
+#X obj 114 293 log;
+#X obj 101 385 expr (17.3123405046*log(.12231220585*$f1));
+#X text 64 423 RESULT B;
+#X text 113 359 RESULT C;
+#X obj 93 449 bang;
+#X obj 33 446 bang;
+#X obj 33 466 realtime;
+#X floatatom 158 540 0 0 0;
+#X obj 201 463 bang;
+#X obj 158 463 bang;
+#X obj 158 483 realtime;
+#X floatatom 158 504 0 0 0;
+#X text 189 520 Arithmetic is __?__ milliseconds slower than [mtof].
+;
+#X text 156 556 [expr] is __?__ milliseconds slower than [mtof].;
+#X text 528 200 Firstly \, the PD source code "clips" overflows and
+underflows. This means simply that frequencies LESS THAN zero cannot
+be tranlated into a MIDI note value - so they're ignored completely
+and the object responds with "-1500".;
+#X text 528 291 Secondly \, the incoming frequency is translated into
+a MIDI note value by the simple equation:;
+#X text 524 330 (17.3123405046 * log(0.12231220585 * Frequency)) =
+MIDI_note;
+#X text 528 355 For curiosity's sake \, I included a timer to show
+how much faster the [ftom] object is compared to the two alternative
+methods.;
+#X text 528 409 As well \, notice that RESULT C (the output from PD's
+basic arithmetic objects) is not as accurate as the other two methods:
+[ftom] and/or [expr]. This is because the message boxes and the [*]
+object round off the operands because they cannot handle enough decimal
+places.;
+#X text 145 119 Note that fractional values have no effect. MIDI controllers
+only accept integers. Perhaps a subroutine could be designed to parse
+the decimal places and manipulate the pitch bend controller to achieve
+microtonal control?;
+#X connect 0 0 13 0;
+#X connect 1 0 14 0;
+#X connect 3 0 17 0;
+#X connect 3 0 20 0;
+#X connect 4 0 31 0;
+#X connect 6 0 5 0;
+#X connect 13 0 1 0;
+#X connect 14 0 15 0;
+#X connect 14 1 15 1;
+#X connect 17 0 4 0;
+#X connect 20 0 21 0;
+#X connect 20 1 25 0;
+#X connect 20 1 27 0;
+#X connect 21 0 22 0;
+#X connect 21 0 23 0;
+#X connect 22 0 30 0;
+#X connect 23 0 34 0;
+#X connect 24 0 23 0;
+#X connect 25 0 26 0;
+#X connect 26 0 24 0;
+#X connect 27 0 22 0;
+#X connect 30 0 32 1;
+#X connect 31 0 32 0;
+#X connect 31 0 35 0;
+#X connect 32 0 33 0;
+#X connect 34 0 36 1;
+#X connect 35 0 36 0;
+#X connect 36 0 37 0;
+#X restore 174 121 pd understanding_ftom;
+#X floatatom 12 37 0 0 0;
+#X floatatom 12 207 0 0 0;
+#X floatatom 12 252 0 0 0;
+#X floatatom 12 163 0 0 0;
+#X obj 12 184 dbtorms;
+#X obj 12 231 rmstodb;
+#N canvas 65 78 423 452 understanding_dbtorms 0;
+#N canvas 0 0 452 302 What_is_a_decibel? 0;
+#X text 24 94 The difficulty in measuring the volume of an instrument
+however is caused by 'distance'. For example \, at one metre away from
+a door bell \, the amplitude might be 70 Decibels \, while at 50 metres
+away the same door bell is just a fraction of that amplitude.;
+#X text 25 33 DECIBELS are units by which we measure amplitude. A human
+voice is approximately 70 Decibels - a snare drum is approximately
+120 Decibels - the threshold of pain for the human ear is approximately
+110 Decibels (poor drummers!);
+#X text 23 174 Literally \, a Decibel is one-tenth of a Bel. A Bel
+\, according to a medical dictionary is approximately the threshold
+of the human ear at 1000 hz. I know that this seems a little vague
+\, and perhaps this isn't the best way to explain it - we might as
+well be measuring "fortnights" and "bunches" and "Alens"! Anyways...I'm
+not an acoustician.;
+#X restore 39 24 pd What_is_a_decibel?;
+#N canvas 0 0 440 242 What_does_RMS_mean? 0;
+#X text 24 21 RMS is an acronym meaning "Root Mean Square".;
+#X text 23 43 In the analog realm \, RMS is the result of an equation
+performed on electrical flow. It is used to measure voltage or current.
+It is important to note however \, that it does NOT measure "power".
+It's also important to recognize that our ears perceive changes in
+amplitude (decibels) more than we perceive changes in RMS levels.;
+#X text 23 133 In the digital realm \, i.e. PD! \, RMS is better defined
+as "a measurement of a signal taken by squaring data points along the
+curve \, finding the mean \, and then determining the square root of
+that mean value.;
+#X restore 39 47 pd What_does_RMS_mean?;
+#X text 19 80 [dbtorms] in PD performs the following equation to convert
+the data: Note that incoming values less than 0 or greater than 485
+are considered overflow or underflow and are clipped/ignored.;
+#X text 22 241 Example:;
+#X floatatom 24 293 0 0 0;
+#X obj 24 313 moses 0;
+#X msg 24 333 0;
+#X obj 86 352 min 485;
+#X text 17 149 (exp((2.302585092994 * 0.05) * (db_value - 100)) = RMS
+;
+#X floatatom 24 397 0 0 0;
+#X obj 151 310 dbtorms;
+#X floatatom 151 330 0 0 0;
+#X obj 86 372 expr (exp((2.302585092994*0.05)*($f1-100)));
+#X text 18 178 On a scale of zero to 100 decibels \, the [dbtorms]
+produces exponential values between 0 and 1;
+#X msg 24 264 0;
+#X msg 57 264 100;
+#X obj 61 332 sel 0;
+#X connect 4 0 5 0;
+#X connect 4 0 10 0;
+#X connect 5 0 6 0;
+#X connect 5 1 16 0;
+#X connect 6 0 9 0;
+#X connect 7 0 12 0;
+#X connect 10 0 11 0;
+#X connect 12 0 9 0;
+#X connect 14 0 4 0;
+#X connect 15 0 4 0;
+#X connect 16 0 6 0;
+#X connect 16 1 7 0;
+#X restore 155 203 pd understanding_dbtorms;
+#X text 66 185 -- Decibels to RMS converter.;
+#X text 66 232 -- RMS to Decibels converter.;
+#X floatatom 12 333 0 0 0;
+#X floatatom 12 378 0 0 0;
+#X floatatom 12 289 0 0 0;
+#X obj 12 310 dbtopow;
+#X obj 12 357 powtodb;
+#N canvas 349 60 423 452 understanding_rmstodb 0;
+#N canvas 0 0 452 302 What_is_a_decibel? 0;
+#X text 24 94 The difficulty in measuring the volume of an instrument
+however is caused by 'distance'. For example \, at one metre away from
+a door bell \, the amplitude might be 70 Decibels \, while at 50 metres
+away the same door bell is just a fraction of that amplitude.;
+#X text 25 33 DECIBELS are units by which we measure amplitude. A human
+voice is approximately 70 Decibels - a snare drum is approximately
+120 Decibels - the threshold of pain for the human ear is approximately
+110 Decibels (poor drummers!);
+#X text 23 174 Literally \, a Decibel is one-tenth of a Bel. A Bel
+\, according to a medical dictionary is approximately the threshold
+of the human ear at 1000 hz. I know that this seems a little vague
+\, and perhaps this isn't the best way to explain it - we might as
+well be measuring "fortnights" and "bunches" and "Alens"! Anyways...I'm
+not an acoustician.;
+#X restore 39 24 pd What_is_a_decibel?;
+#N canvas 0 0 440 242 What_does_RMS_mean? 0;
+#X text 24 21 RMS is an acronym meaning "Root Mean Square".;
+#X text 23 43 In the analog realm \, RMS is the result of an equation
+performed on electrical flow. It is used to measure voltage or current.
+It is important to note however \, that it does NOT measure "power".
+It's also important to recognize that our ears perceive changes in
+amplitude (decibels) more than we perceive changes in RMS levels.;
+#X text 23 133 In the digital realm \, i.e. PD! \, RMS is better defined
+as "a measurement of a signal taken by squaring data points along the
+curve \, finding the mean \, and then determining the square root of
+that mean value.;
+#X restore 39 47 pd What_does_RMS_mean?;
+#X text 22 219 Example:;
+#X floatatom 24 259 0 0 0;
+#X floatatom 24 422 0 0 0;
+#X floatatom 151 354 0 0 0;
+#X msg 68 278 0;
+#X text 19 80 [rmstodb] in PD performs the following equation to convert
+the data: Note that incoming values less than 0 is consider underflow
+and is clipped/ignored.;
+#X text 18 178 On a scale of zero to 1 decibels \, the [rmstodb] produces
+logarithmic values between 0 and 100 \, although higher values can
+also be produced.;
+#X obj 151 334 rmstodb;
+#X obj 24 358 max 0;
+#X obj 24 401 max 0;
+#X obj 24 379 expr (100+((20/2.302585092994)*log($f1)));
+#X text 18 136 (100 + ((20/2.302585092994) * log(RMS_value)));
+#X obj 24 278 / 1000;
+#X floatatom 24 310 0 0 0;
+#X msg 101 278 1;
+#X connect 3 0 14 0;
+#X connect 6 0 15 0;
+#X connect 9 0 5 0;
+#X connect 10 0 12 0;
+#X connect 11 0 4 0;
+#X connect 12 0 11 0;
+#X connect 14 0 15 0;
+#X connect 15 0 9 0;
+#X connect 15 0 10 0;
+#X connect 16 0 15 0;
+#X restore 153 249 pd understanding_rmstodb;
+#X text 66 311 -- Decibels to power converter.;
+#X text 66 358 -- power to Decibels converter.;
+#X text 439 17 Please note: I have no idea why it's necessary for PD
+to measure decibels \, rms \, or power. It seems to me that RMS and
+Power are extremely important in the analog world (so that an engineer
+doesn't blow up a transistor)...but in PD \, these things are just
+numbers which have been abstracted from their original analog counterparts.
+I would really appreciate if somebody could help me understand these
+concepts and finish this document. Why are these objects present in
+PD? WHY should they be used and what benefits to they produce in a
+digital process?;
+#N canvas 460 106 429 458 understanding_dbtopow 0;
+#N canvas 0 0 452 302 What_is_a_decibel? 0;
+#X text 24 94 The difficulty in measuring the volume of an instrument
+however is caused by 'distance'. For example \, at one metre away from
+a door bell \, the amplitude might be 70 Decibels \, while at 50 metres
+away the same door bell is just a fraction of that amplitude.;
+#X text 25 33 DECIBELS are units by which we measure amplitude. A human
+voice is approximately 70 Decibels - a snare drum is approximately
+120 Decibels - the threshold of pain for the human ear is approximately
+110 Decibels (poor drummers!);
+#X text 23 174 Literally \, a Decibel is one-tenth of a Bel. A Bel
+\, according to a medical dictionary is approximately the threshold
+of the human ear at 1000 hz. I know that this seems a little vague
+\, and perhaps this isn't the best way to explain it - we might as
+well be measuring "fortnights" and "bunches" and "Alens"! Anyways...I'm
+not an acoustician.;
+#X restore 39 24 pd What_is_a_decibel?;
+#X floatatom 21 205 0 0 0;
+#X floatatom 21 309 0 0 0;
+#X floatatom 148 242 0 0 0;
+#N canvas 0 0 442 244 What_does_power_mean? 0;
+#X text 30 25 What does power mean? I really don't know? I can't determine
+from my own research or from PD's documentation why or how this data
+is used. All that I do know \, is that PD provides these objects for
+a good reason -- I just don't know the reason.;
+#X text 27 103 Having said that \, I would enjoy learning from somebody
+who DOES know more about these objects and their usage. All that I
+can offer is an explanation of the equation used to perform these conversions.
+;
+#X restore 39 47 pd What_does_power_mean?;
+#X text 18 80 [dbtopow] in PD performs the following equation to convert
+the data: Note that incoming values less than 0 or greater than 870
+are considered overflow or underflow and are clipped/ignored.;
+#X obj 148 222 dbtopow;
+#X obj 21 226 max 0;
+#X obj 21 246 min 870;
+#X text 17 149 exp((2.302585092994 * 0.1) * (db_value - 100)) = Power
+;
+#X obj 21 269 expr exp((2.302585092994*0.1)*($f1-100));
+#X connect 1 0 6 0;
+#X connect 1 0 7 0;
+#X connect 6 0 3 0;
+#X connect 7 0 8 0;
+#X connect 8 0 10 0;
+#X connect 10 0 2 0;
+#X restore 154 330 pd understanding_dbtopow;
+#N canvas 348 60 429 458 understanding_powtodb 0;
+#N canvas 0 0 452 302 What_is_a_decibel? 0;
+#X text 24 94 The difficulty in measuring the volume of an instrument
+however is caused by 'distance'. For example \, at one metre away from
+a door bell \, the amplitude might be 70 Decibels \, while at 50 metres
+away the same door bell is just a fraction of that amplitude.;
+#X text 25 33 DECIBELS are units by which we measure amplitude. A human
+voice is approximately 70 Decibels - a snare drum is approximately
+120 Decibels - the threshold of pain for the human ear is approximately
+110 Decibels (poor drummers!);
+#X text 23 174 Literally \, a Decibel is one-tenth of a Bel. A Bel
+\, according to a medical dictionary is approximately the threshold
+of the human ear at 1000 hz. I know that this seems a little vague
+\, and perhaps this isn't the best way to explain it - we might as
+well be measuring "fortnights" and "bunches" and "Alens"! Anyways...I'm
+not an acoustician.;
+#X restore 39 24 pd What_is_a_decibel?;
+#X text 22 241 Example:;
+#X floatatom 22 261 0 0 0;
+#X floatatom 22 363 0 0 0;
+#X floatatom 149 298 0 0 0;
+#N canvas 0 0 442 244 What_does_power_mean? 0;
+#X text 30 25 What does power mean? I really don't know? I can't determine
+from my own research or from PD's documentation why or how this data
+is used. All that I do know \, is that PD provides these objects for
+a good reason -- I just don't know the reason.;
+#X text 27 103 Having said that \, I would enjoy learning from somebody
+who DOES know more about these objects and their usage. All that I
+can offer is an explanation of the equation used to perform these conversions.
+;
+#X restore 39 47 pd What_does_power_mean?;
+#X text 17 81 [powtodb] in PD performs the following equation to convert
+the data: Note that incoming values less than 0 are considered underflow
+and are clipped/ignored.;
+#X text 17 149 (100 + ((10/2.302585092994) * log(POWER_value))) = Debibels
+;
+#X obj 149 278 powtodb;
+#X obj 22 281 max 0;
+#X obj 22 321 expr (100 + ((10/2.302585092994)*log($f1)));
+#X obj 22 342 max 0;
+#X connect 2 0 8 0;
+#X connect 2 0 9 0;
+#X connect 8 0 4 0;
+#X connect 9 0 10 0;
+#X connect 10 0 11 0;
+#X connect 11 0 3 0;
+#X restore 154 377 pd understanding_powtodb;
+#X text 13 415 RELATED OBJECTS;
+#X obj 14 434 dbtopow~;
+#X obj 68 434 dbtorms~;
+#X obj 123 434 rmstodb~;
+#X obj 178 434 powtodb~;
+#X obj 233 434 mtof~;
+#X obj 270 434 ftom~;
+#X obj 14 459 expr;
+#X obj 46 459 expr~;
+#N canvas 0 0 452 302 other_objects_from_related_libraries 0;
+#X obj 26 39 db2v;
+#X obj 65 38 f2note;
+#X obj 115 39 b2db;
+#X obj 150 40 t3_sig~;
+#X obj 205 40 m2f~;
+#X obj 249 41 tmtof;
+#X text 18 96 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 17 145 The best places to find information about PD's libraries
+is:;
+#X text 14 167 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 15 183 or;
+#X text 16 197 iem.kug.ac.at/pdb/;
+#X restore 14 494 pd other_objects_from_related_libraries;
+#X obj 90 459 rmstopow~;
+#X obj 154 461 powtorms~;
+#X obj 220 461 sig~;
+#X obj 254 461 snapshot~;
+#X text 14 550 This document was updated for PD version 0.35 test 29
+by Dave Sabine as part of a project called pddp proposed to build comprehensive
+documentation for PD.;
+#X connect 0 0 1 0;
+#X connect 1 0 2 0;
+#X connect 2 0 3 0;
+#X connect 9 0 0 0;
+#X connect 10 0 14 0;
+#X connect 12 0 13 0;
+#X connect 13 0 10 0;
+#X connect 14 0 11 0;
+#X connect 18 0 22 0;
+#X connect 20 0 21 0;
+#X connect 21 0 18 0;
+#X connect 22 0 19 0;
diff --git a/doc/pddp/help-adc~.pd b/doc/pddp/help-adc~.pd
new file mode 100644
index 00000000..e281fc9a
--- /dev/null
+++ b/doc/pddp/help-adc~.pd
@@ -0,0 +1,68 @@
+#N canvas 2 1 611 606 12;
+#X obj 104 540 pddp;
+#X obj 8 8 cnv 15 90 553 empty empty empty 20 12 0 14 -233017 -66577
+0;
+#N canvas 85 2 593 609 More_Info 0;
+#X text 16 13 MULTI-CHANNEL AUDIO;
+#X text 32 40 All sound cards are capable of at least two channels
+of audio. PD supports these two channels by default and uses your system's
+generic audio drivers to communicate with your hardware. However \,
+for faster input/output and for more than two channels of audio \,
+PD incorporates the use of "PortAudio" which uses ASIO drivers to communicate
+with your hardware. So \, to instruct PD to use more than two channels
+of audio \, your command line should read like below:;
+#X text 93 182 c:/pd/bin/pd.exe -pa -inchannels 8 -outchannels 8;
+#X text 32 211 The "-pa" switch means "PortAudio". This switch is new
+as of PD version 0.37 TEST 4 and replaces the old "-asio" switch.;
+#X text 32 271 The "-inchannels" and "-outchannels" switches can be
+summarized by using "-channels 8" because currently PortAudio requires
+that the number of incoming and outgoing channels must be equal. This
+may change in the PD's future...;
+#X text 32 361 To further optimize PD's usage of your audio hardware
+\, you can explore the following:;
+#X text 42 402 - audiobuf;
+#X text 43 420 - blocksize;
+#X text 42 436 - audioindev;
+#X text 42 454 - audiooutdev;
+#X text 38 480 With the right hardware \, PD can manage audio input
+and output with lower than 10 milliseconds of latency.;
+#X restore 104 514 pd More_Info;
+#N canvas 85 2 395 244 Related_Objects 0;
+#X text 25 8 Native PD Objects;
+#X text 25 92 Externals and other object libraries;
+#X obj 45 46 dac~;
+#X obj 98 46 switch~;
+#X obj 171 46 block~;
+#X restore 104 488 pd Related_Objects;
+#X text 16 107 ARGUMENTS:;
+#X text 32 188 OUTLETS:;
+#X text 23 344 EXAMPLES:;
+#X text 20 487 SEE ALSO:;
+#X obj 33 20 adc~;
+#X text 30 53 PURPOSE:;
+#X text 108 18 - AUDIO INPUT: ANALOG/DIGITAL CONVERTER SIGNAL;
+#X text 152 541 - Dave Sabine \, May 6 \, 2003;
+#X text 104 53 [adc~] is an acronym meaning "Analog/Digital Converter
+Signal" and is PD's interface to access the audio information arriving
+at your soundcard(s).;
+#X text 106 106 The object defaults to 2 incoming audio channels (usually
+a left and right stereo pair). Any number of arguments (integers) can
+be used to define multiple input channels - each integer corresponds
+to an input channel on your audio hardware.;
+#X text 107 188 Signal: the number of outlets correspond with the number
+of arguments - each outlet represents an input channel on your audio
+hardware which corresponds to the argument you provide. If no arguments
+are provided \, then there are two outlets which represent audio channels
+1 and 2 on your computers sound card.;
+#X text 107 290 The information at each outlet is an audio signal (i.e.
+the object operates at 'audio-rate') and therefore must be connected
+to an audio inlet on a related object.;
+#X obj 109 346 adc~;
+#X text 153 346 default stereo signals: same as;
+#X obj 411 348 adc~ 1 2;
+#X obj 109 373 adc~ 5;
+#X text 167 374 a mono signal from channel 5;
+#X obj 109 404 adc~ 1 3 8 6 11 15 19 22 23 24 36;
+#X text 383 405 11 channels of audio;
+#X obj 109 434 adc~ 1 2 3 4 5 6 7 8;
+#X text 280 435 all channels on an 8-channel device;
diff --git a/doc/pddp/help-adc~_dac~.pd b/doc/pddp/help-adc~_dac~.pd
new file mode 100644
index 00000000..33a21a23
--- /dev/null
+++ b/doc/pddp/help-adc~_dac~.pd
@@ -0,0 +1,108 @@
+#N canvas 3 0 619 592 12;
+#X obj 104 540 pddp;
+#X obj 8 8 cnv 15 90 553 empty empty empty 20 12 0 14 -233017 -66577
+0;
+#N canvas 129 0 415 237 More_Info 0;
+#N canvas 131 29 532 435 sample_rate 0;
+#X text 12 24 SAMPLE RATE;
+#X text 29 46 [adc~] and [dac~] always operate at the sample rate that
+is specified in PD's command line. By default \, the sample rate is
+44100 hz. But PD operates any sample rate supported by standard audio
+hardware. Sample rates cannot be changed at run-time in PD \, but must
+be stated in the command line when PD is instantiated. As well \, two
+or more instances of PD running simoultaneously can each be using different
+sample rates! Having said that \, PD can easily upsample or downsample
+by using the [block~] object. Here are some example of the common sample
+rates:;
+#X text 85 232 c:/pd/bin/pd.exe -r 11025;
+#X text 85 262 c:/pd/bin/pd.exe -r 22050;
+#X text 86 329 c:/pd/bin/pd.exe -r 88200;
+#X text 85 217 c:/pd/bin/pd.exe -r 8000;
+#X text 85 247 c:/pd/bin/pd.exe -r 16000;
+#X text 86 278 c:/pd/bin/pd.exe -r 32000;
+#X text 86 294 c:/pd/bin/pd.exe -r 44100 CD Quality;
+#X text 86 311 c:/pd/bin/pd.exe -r 48000 DAT Quality;
+#X text 87 366 c:/pd/bin/pd.exe -r 192000 DVD-Audio Quality;
+#X text 86 347 c:/pd/bin/pd.exe -r 96000 DVD-Video/Audio Quality;
+#X restore 40 75 pd sample_rate;
+#N canvas 131 31 564 558 multi-channel_audio 0;
+#X text 16 13 MULTI-CHANNEL AUDIO;
+#X text 32 40 All sound cards are capable of at least two channels
+of audio. PD supports these two channels by default and uses your system's
+generic audio drivers to communicate with your hardware. However \,
+for faster input/output and for more than two channels of audio \,
+PD incorporates the use of "PortAudio" which uses ASIO drivers to communicate
+with your hardware. So \, to instruct PD to use more than two channels
+of audio \, your command line should read like below:;
+#X text 93 182 c:/pd/bin/pd.exe -pa -inchannels 8 -outchannels 8;
+#X text 32 211 The "-pa" switch means "PortAudio". This switch is new
+as of PD version 0.37 TEST 4 and replaces the old "-asio" switch.;
+#X text 32 271 The "-inchannels" and "-outchannels" switches can be
+summarized by using "-channels 8" because currently PortAudio requires
+that the number of incoming and outgoing channels must be equal. This
+may change in the PD's future...;
+#X text 32 361 To further optimize PD's usage of your audio hardware
+\, you can explore the following:;
+#X text 42 402 - audiobuf;
+#X text 43 420 - blocksize;
+#X text 42 436 - audioindev;
+#X text 42 454 - audiooutdev;
+#X text 38 480 With the right hardware \, PD can manage audio input
+and output with lower than 10 milliseconds of latency.;
+#X restore 40 112 pd multi-channel_audio;
+#N canvas 132 30 528 211 defeating_audio_computation 0;
+#X text 21 15 -NODAC and -NOADC;
+#X text 26 37 There may be cases when you do not want PD to send or
+receive audio signal with your soundcard. You can manually disable
+the [dac~] and [adc~] objects separately using the "-nodac" and "-noadc"
+switch \, or disable both using the "-nosound" switch.;
+#X restore 41 152 pd defeating_audio_computation;
+#X restore 104 514 pd More_Info;
+#N canvas 85 2 399 248 Related_Objects 0;
+#X text 25 8 Native PD Objects;
+#X text 25 118 Externals and other object libraries;
+#X obj 57 35 bilge;
+#X text 35 143 [shoutcast~];
+#X text 35 166 [oggcast~];
+#X obj 115 35 send~;
+#X obj 169 35 receive~;
+#X obj 58 66 throw~;
+#X obj 121 66 catch~;
+#X obj 185 66 block~;
+#X obj 249 66 switch~;
+#X restore 104 488 pd Related_Objects;
+#X text 14 84 ARGUMENTS:;
+#X text 22 219 EXAMPLES:;
+#X text 21 463 SEE ALSO:;
+#X obj 12 19 adc~;
+#X obj 61 19 dac~;
+#X text 108 18 - AUDIO INPUT/OUTPUT;
+#X text 30 47 PURPOSE:;
+#X text 104 47 [adc~] and [dac~] provide real-time audio input and
+output for PD \, respectively \, whether analog or digital.;
+#X text 152 541 - Dave Sabine \, May 5 \, 2003;
+#X text 104 83 Both of these objects accept arguments (numbers) which
+indicate which audio channels are to be used by PD. By default \, these
+objects are stereo and communicate on audio channels 1 and 2 (left
+and right respectively) but by using arguments \, other channel numbers
+can be specified. These objects can communicate with hundreds of audio
+channels \, but you are likely limited by your audio hardware to 2
+\, 4 \, 6 \, 8 \, 12 \, 16 \, 32 \, 64 \, etc.;
+#X obj 114 222 adc~;
+#X text 162 222 incoming stereo signals;
+#X obj 114 251 dac~;
+#X text 162 252 outgoing stereo signals;
+#X obj 114 280 adc~ 1 2 3 4 5 6 7 8;
+#X text 290 281 eight incoming audio signals;
+#X text 210 314 three outgoing signals on channels 1 \, 5 \, and 6
+;
+#X obj 115 314 dac~ 1 5 6;
+#X text 107 345 The actual number of PD inputs and outputs are set
+on PD's command line. You can open patches that want to use more channels
+\, but channel numbers that out of range will be dropped by [dac~]
+or appears as zero by [adc~].;
+#X text 14 344 IMPORTANT:;
+#X text 108 419 Also \, these objects do not operate unless PD is instructed
+to "Compute Audio".;
+#X obj 104 464 help-adc~;
+#X obj 190 464 help-dac~;
diff --git a/doc/pddp/help-bang.pd b/doc/pddp/help-bang.pd
new file mode 100644
index 00000000..24787bd1
--- /dev/null
+++ b/doc/pddp/help-bang.pd
@@ -0,0 +1,143 @@
+#N canvas 12 2 916 656 10;
+#X obj 502 191 print;
+#X obj 22 14 bang;
+#X msg 514 133 walk the cat;
+#X msg 501 112 45;
+#X obj 502 166 bang;
+#X text 110 13 - SEND "BANG" MESSAGE;
+#X obj 76 14 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 22 38 The bang object is one of the basic building blocks of
+PD and are normally used to activate events. The bang object can be
+created in two different ways.;
+#X obj 45 83 bang;
+#X text 22 82 1;
+#X text 21 141 2;
+#X obj 45 142 bng 15 250 50 0 empty empty empty 18 7 0 8 -262144 -1
+-1;
+#X text 45 107 This version uses minimal CPU but serves essentially
+the same purpose as the GUI version.;
+#X text 43 286 1 Size;
+#X obj 122 289 bng 8 250 50 0 empty empty 8 10 4 0 8 -262144 -1 -1
+;
+#X obj 147 282 bng 15 250 50 0 empty empty 15 17 9 0 8 -262144 -1 -1
+;
+#X obj 182 272 bng 25 250 50 0 empty empty 25 27 20 0 8 -262144 -1
+-1;
+#X text 69 304 Default size is 15 pixels. The minimum size is 8 and
+it does not have a maximum size.;
+#X text 41 465 3 Hold;
+#X obj 111 465 bng 15 50 10 0 empty empty 50 17 8 0 8 -262144 -1 -1
+;
+#X obj 146 465 bng 15 750 50 0 empty empty 750 17 8 0 8 -262144 -1
+-1;
+#X text 41 538 4 Receive Symbol/Send Symbol;
+#X text 67 553 This object can act as its own send or receive object.
+;
+#X obj 69 575 bng 15 250 50 0 link_this_bang empty This_one_sends_a_bang
+17 8 128 8 -262144 -1 -1;
+#X obj 69 596 bng 15 250 50 0 empty link_this_bang This_one_receives_it.
+17 8 64 8 -262144 -1 -1;
+#X text 280 567 Here is the alternative method.;
+#X text 44 644 5 GUI Options;
+#X obj 506 368 bng 8 250 50 0 empty empty empty 0 -6 0 12 -262144 -1
+-1;
+#X msg 679 359 label Name_that_bang;
+#X msg 692 383 label Rename_that_bang;
+#X msg 719 405 size 8;
+#X text 67 666 The other properties are 'name' \, 'x/y offset' \, 'font
+size' \, and colours (for the background \, front \, and labels [name])
+;
+#X obj 471 19 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 471 659 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 495 55 WHAT CAN IT DO?;
+#X text 495 67 The bang object outputs "bang" when it receives something
+in its inlet or its 'internal' receive symbol (GUI version only).;
+#X text 547 190 The output window will print "bang" to demonstrate.
+;
+#X obj 647 162 print;
+#X msg 647 116 walk the cat;
+#X obj 647 141 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 502 215 It is important to note that "bang" is not boolean.
+It's neither a zero or a one \; it's not true or false \; it's just
+"bang". For a boolean object \, you should check out the toggle.;
+#X obj 502 487 loadbang;
+#X obj 643 487 tgl 15 0 empty empty Toggle 0 -6 0 8 -262144 -1 -1 0
+1;
+#X obj 557 487 trigger;
+#X obj 606 487 bang~;
+#X text 502 290 OTHER HELPFUL INFO;
+#X msg 735 427 size 25;
+#X text 502 312 The label and size properties of the bng object (from
+IEM library) can be updated dynamically by sending messages to its
+inlet.;
+#X text 512 461 RELATED OBJECTS;
+#X text 44 165 This version uses a little more CPU than its cousin
+because it lights-up when it receives a message or is clicked on and
+can be coloured \, resized \, or renamed. It is sometimes 'friendlier'
+as well because it can act as its own send and receive object (see
+properties...). This object can be put in a PD patch either by keyboard
+shortcut: ALT+B or by creating and object (CTRL+1) called "bng".;
+#X text 66 482 The default hold is 250 milliseconds. The hold value
+controls the length of time that the bng object stays "lit". Note that
+bng sends its message immediately regardless of the hold value.;
+#X obj 261 621 s linked_bngs;
+#X obj 370 583 r linked_bngs;
+#X text 40 334 2 Interrupt (milliseconds);
+#X text 66 348 If the bng object is "lit" and holding (see "hold" below)
+\, then receives another message before the hold time has passed \,
+the bng will quickly flash again for the duration you set in this interrupt
+property.;
+#X obj 42 421 bng 15 1000 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 65 405 This bng will hold for 1000 milliseconds \, but interrupt
+for 50 milliseconds if it gets a second message during its "hold".
+Click it once...wait. Then click it multiple times rather quickly to
+see the effect.;
+#X obj 261 603 bang;
+#X obj 370 602 bang;
+#X msg 261 584 send a message;
+#X obj 370 620 print;
+#X text 69 143 a.k.a. "bng";
+#X text 43 264 PROPERTIES OF BNG;
+#X text 497 548 This document was updated for PD version 0.35 test
+24 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#N canvas 4 24 432 275 related_objects_from_other_libraries 0;
+#X obj 266 48 oneshot;
+#X obj 259 28 toddle;
+#X obj 18 48 render_trigger;
+#X obj 18 28 metroplus;
+#X obj 78 28 exciter;
+#X obj 127 28 bangfilter1+2;
+#X obj 211 28 counter;
+#X obj 108 48 countund;
+#X obj 163 48 kalashnikov;
+#X obj 236 48 init;
+#X text 18 86 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 17 135 The best places to find information about PD's libraries
+is:;
+#X text 14 157 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 15 173 or;
+#X text 16 187 iem.kug.ac.at/pdb/;
+#X restore 501 513 pd related_objects_from_other_libraries;
+#X connect 2 0 4 0;
+#X connect 3 0 4 0;
+#X connect 4 0 0 0;
+#X connect 28 0 27 0;
+#X connect 29 0 27 0;
+#X connect 30 0 27 0;
+#X connect 32 0 33 0;
+#X connect 38 0 39 0;
+#X connect 39 0 37 0;
+#X connect 46 0 27 0;
+#X connect 52 0 58 0;
+#X connect 57 0 51 0;
+#X connect 58 0 60 0;
+#X connect 59 0 57 0;
diff --git a/doc/pddp/help-bendin.pd b/doc/pddp/help-bendin.pd
new file mode 100644
index 00000000..e14aa01d
--- /dev/null
+++ b/doc/pddp/help-bendin.pd
@@ -0,0 +1,66 @@
+#N canvas 244 81 492 554 10;
+#X text 118 123 outlets:;
+#X floatatom 16 149 5 0 0;
+#X floatatom 59 149 5 0 0;
+#N canvas 240 135 476 472 other_midi_objects 0;
+#X obj 7 29 ctlin;
+#X obj 49 29 pgmin;
+#X obj 92 28 bendin;
+#X obj 143 27 touchin;
+#X obj 204 27 polytouchin;
+#X obj 289 27 midiin;
+#X obj 340 26 sysexin;
+#X obj 6 85 noteout;
+#X obj 63 84 ctlout;
+#X obj 160 84 bendout;
+#X obj 217 83 touchout;
+#X obj 281 82 polytouchout;
+#X obj 370 82 midiout;
+#X obj 113 84 pgmout;
+#X obj 11 153 makenote;
+#X text 10 194 MIDI notes deconstruction:;
+#X text 8 128 MIDI note construction:;
+#X text 8 58 MIDI output:;
+#X text 8 2 MIDI input:;
+#X obj 15 226 stripnote;
+#X text 11 266 Additional useful objects for MIDI processing (Maxlib
+by Olaf Matthes);
+#X obj 148 297 chord;
+#X obj 109 296 borax;
+#X obj 54 296 score o;
+#X obj 13 296 pitch;
+#X text 15 336 Also \, from cyclone (alpha) by Krzysztof Czaja:;
+#X obj 16 359 midiformat;
+#X obj 172 359 midiflush;
+#X obj 98 359 midiparse;
+#X text 15 386 and xeq \, from the same developer;
+#X obj 16 411 xeq;
+#X text 41 402 an experimental MIDI sequencer;
+#X restore 20 401 pd other_midi_objects;
+#X text 18 346 related object;
+#X obj 283 420 midi-basics;
+#X text 18 421 for an explanation of MIDI usage in PD see:;
+#X obj 33 18 bendin;
+#X text 119 103 inlets : none (reads directly from the MIDI port);
+#X obj 23 107 bendin;
+#X text 9 49 The [bendin] object reads incoming pitch bend values and
+reports them. If started with no arguments it reports the channel number
+through the right outlet.;
+#X text 14 192 Arguments: the MIDI channel number from which to read.
+If the argument is present \, the [bendin] object does not show the
+second (right) outlet:;
+#X obj 25 256 bendin 2;
+#X floatatom 25 278 5 0 0;
+#X obj 21 361 bendout;
+#X text 76 279 <-- pitch bend values on channel 2;
+#X text 16 312 Output (int) is a 14-bit pitchbend value;
+#X text 130 142 left: pitchbend value;
+#X text 129 159 right: MIDI channel number (if no argument);
+#X text 81 19 - read incoming pitch bend values.;
+#X text 19 482 This document was updated for PD version 0.35 by Michal
+Seta as part of a project called pddp proposed by Krzysztof Czaja \,
+managed and edited by Dave Sabine \, to build comprehensive documentation
+for PD.;
+#X connect 9 0 1 0;
+#X connect 9 1 2 0;
+#X connect 12 0 13 0;
diff --git a/doc/pddp/help-bendout.pd b/doc/pddp/help-bendout.pd
new file mode 100644
index 00000000..f25791f3
--- /dev/null
+++ b/doc/pddp/help-bendout.pd
@@ -0,0 +1,67 @@
+#N canvas 249 47 492 554 10;
+#X floatatom 17 124 5 0 0;
+#X floatatom 61 141 5 0 0;
+#N canvas 240 135 476 472 other_midi_objects 0;
+#X obj 55 31 ctlin;
+#X obj 97 31 pgmin;
+#X obj 140 30 bendin;
+#X obj 191 29 touchin;
+#X obj 252 29 polytouchin;
+#X obj 337 29 midiin;
+#X obj 388 28 sysexin;
+#X obj 6 85 noteout;
+#X obj 63 84 ctlout;
+#X obj 161 85 touchout;
+#X obj 225 84 polytouchout;
+#X obj 314 84 midiout;
+#X obj 113 84 pgmout;
+#X obj 11 153 makenote;
+#X text 10 194 MIDI notes deconstruction:;
+#X text 8 128 MIDI note construction:;
+#X text 8 58 MIDI output:;
+#X text 8 2 MIDI input:;
+#X obj 15 226 stripnote;
+#X text 11 266 Additional useful objects for MIDI processing (Maxlib
+by Olaf Matthes);
+#X obj 148 297 chord;
+#X obj 109 296 borax;
+#X obj 54 296 score o;
+#X obj 13 296 pitch;
+#X text 15 336 Also \, from cyclone (alpha) by Krzysztof Czaja:;
+#X obj 16 359 midiformat;
+#X obj 172 359 midiflush;
+#X obj 98 359 midiparse;
+#X text 15 386 and xeq \, from the same developer;
+#X obj 16 411 xeq;
+#X text 41 402 an experimental MIDI sequencer;
+#X obj 8 31 midiin;
+#X restore 20 392 pd other_midi_objects;
+#X text 18 337 related object;
+#X obj 282 412 midi-basics;
+#X text 18 412 for an explanation of MIDI usage in PD see:;
+#X floatatom 20 266 5 0 0;
+#X text 111 263 <-- pitch bend values on channel 2;
+#X obj 39 21 bendout;
+#X obj 17 165 bendout;
+#X text 120 114 inlets:;
+#X text 119 165 outlets : none (writes directly to the MIDI port);
+#X text 128 132 left: 14-bit pitchbend value;
+#X text 127 148 right: MIDI channel number;
+#X text 14 198 Arguments: the MIDI channel number to which to write
+to. If no argument is given [bendout] defaults to channel 1 The channel
+can be then chaned byy sending an int to the right inlet:;
+#X obj 20 284 bendout 2;
+#X text 16 314 Output: the output is direct to the MIDI port.;
+#X obj 21 352 bendin;
+#X text 12 51 The [bendout] object takes a pitchbend value (0-127)
+and formats it into a pitchbend MIDI message and sends out the MIDI
+port on the appropriate channel. If no argument is given it defaults
+to channel 1;
+#X text 87 22 - send pitchbend value to the MIDI port;
+#X text 18 482 This document was updated for PD version 0.35 by Michal
+Seta as part of a project called pddp proposed by Krzysztof Czaja \,
+managed and edited by Dave Sabine \, to build comprehensive documentation
+for PD.;
+#X connect 0 0 9 0;
+#X connect 1 0 9 1;
+#X connect 6 0 15 0;
diff --git a/doc/pddp/help-bng.pd b/doc/pddp/help-bng.pd
new file mode 100644
index 00000000..e5ddf65f
--- /dev/null
+++ b/doc/pddp/help-bng.pd
@@ -0,0 +1,269 @@
+#N canvas 60 138 517 433 10;
+#X obj 1 1 cnv 8 100 60 empty empty bng 20 20 1 18 -262144 -1109 0
+;
+#X text 10 288 (c) musil@iem.kug.ac.at;
+#X text 52 301 IEM KUG;
+#X text 118 61 click properties to;
+#X text 106 72 modify geometry \, colors \, etc.;
+#X obj 64 257 print;
+#N canvas 598 330 290 225 once 0;
+#X msg 38 73 1;
+#X obj 38 47 t b b;
+#X obj 68 124 sel 0;
+#X obj 68 103 f 0;
+#X obj 38 24 inlet;
+#X obj 68 154 outlet;
+#X connect 0 0 3 1;
+#X connect 1 0 0 0;
+#X connect 1 1 3 0;
+#X connect 2 0 5 0;
+#X connect 3 0 2 0;
+#X connect 4 0 1 0;
+#X restore 64 234 pd once;
+#X obj 36 258 bng 15 250 50 0 empty empty empty 8 -8 0 10 -262144 -1
+-1;
+#X obj 3 130 bng 15 250 50 0 empty empty empty 8 -8 0 10 -262144 -1
+-1;
+#X obj 36 173 bng 50 950 50 1 foo5_snd foo5_rcv big-bang 63 2 192 12
+-262131 -260818 -143491;
+#X msg 36 53 33;
+#X msg 50 75 -3.14;
+#X msg 73 117 11 22 33.33;
+#X msg 63 95 open xxx;
+#X msg 96 142 funny;
+#X text 101 11 gui-bang:;
+#X obj 202 135 s foo5_rcv;
+#X obj 202 155 r foo5_snd;
+#X obj 202 115 bng 15 250 50 0 empty empty empty 8 -8 0 10 -262144
+-1 -1;
+#X obj 202 175 bng 15 250 50 0 empty empty empty 8 -8 0 10 -262144
+-1 -1;
+#X msg 4 53 0;
+#X text 125 205 UP- \, DOWN- \, LEFT- or RIGHT-key;
+#X text 124 216 for moving selected gui-objects;
+#N canvas 425 170 699 530 edit 0;
+#X obj 39 197 f;
+#X msg 17 176 bang;
+#X floatatom 55 175 3 63 88;
+#X floatatom 90 197 3 0 37;
+#X obj 39 220 pack 0 0;
+#X text 117 197 y-label;
+#X text 83 175 x-label;
+#X floatatom 259 143 3 8 75;
+#X text 286 143 size;
+#X obj 279 236 f;
+#X msg 257 215 bang;
+#X floatatom 295 214 3 -10 10;
+#X floatatom 330 236 3 -10 10;
+#X obj 279 259 pack 0 0;
+#X obj 304 348 f;
+#X msg 282 327 bang;
+#X floatatom 320 326 3 20 90;
+#X floatatom 355 348 3 150 200;
+#X obj 304 371 pack 0 0;
+#X text 323 214 x-delta;
+#X text 357 236 y-delta;
+#X text 348 326 x-position;
+#X text 382 348 y-position;
+#X obj 59 312 f;
+#X msg 37 291 bang;
+#X floatatom 75 290 3 0 2;
+#X floatatom 110 312 3 4 36;
+#X obj 59 335 pack 0 0;
+#X text 103 290 font;
+#X text 139 312 height;
+#X msg 36 399 \; foo5_rcv label blabla;
+#X msg 59 360 \; foo5_rcv label_font \$1 \$2;
+#X msg 39 245 \; foo5_rcv label_pos \$1 \$2;
+#X msg 47 135 \; foo5_rcv color \$1 \$2 \$3;
+#X msg 259 172 \; foo5_rcv size \$1;
+#X msg 279 284 \; foo5_rcv delta \$1 \$2;
+#X msg 304 396 \; foo5_rcv pos \$1 \$2;
+#X msg 483 133 \; foo5_rcv receive foo5a_rcv;
+#X msg 482 171 \; foo5a_rcv receive foo5_rcv;
+#X msg 483 50 \; foo5_rcv send foo5a_snd;
+#X msg 483 88 \; foo5_rcv send foo5_snd;
+#X text 526 349 no init;
+#X msg 505 368 \; foo5_rcv init 0;
+#X msg 512 435 \; foo5_rcv init 1;
+#X obj 493 260 f;
+#X msg 471 239 bang;
+#X floatatom 509 238 4 10 100;
+#X floatatom 544 261 5 100 3000;
+#X obj 493 283 pack 0 0;
+#X msg 493 308 \; foo5_rcv flashtime \$1 \$2;
+#X text 548 237 interrupt-time;
+#X text 585 262 hold-time;
+#X msg 36 435 \; foo5_rcv label big-bang;
+#X text 502 417 init bang on loadbang;
+#X text 519 221 flash-time:;
+#X obj 47 114 pack 0 0 0;
+#X obj 47 86 f;
+#X msg 24 38 bang;
+#X floatatom 63 36 3 0 29;
+#X floatatom 79 56 3 0 29;
+#X floatatom 112 72 3 0 29;
+#X text 91 36 background;
+#X text 106 56 front-color;
+#X text 140 73 label-color;
+#X msg 285 35 back;
+#X msg 285 55 front;
+#X msg 285 75 label;
+#X msg 247 35 bang;
+#N canvas 15 207 606 448 RGB_____________ 0;
+#X obj 97 56 inlet;
+#X obj 262 53 inlet;
+#X obj 339 55 inlet;
+#X obj 405 56 inlet;
+#X obj 97 270 bang;
+#X msg 77 295 0;
+#X msg 104 295 1;
+#X obj 146 268 bang;
+#X msg 132 295 0;
+#X msg 160 295 1;
+#X obj 196 269 bang;
+#X msg 187 295 0;
+#X msg 214 295 1;
+#X obj 265 313 spigot;
+#X obj 312 313 spigot;
+#X obj 359 313 spigot;
+#X obj 249 385 outlet;
+#X text 93 33 select;
+#X text 267 28 red;
+#X text 337 30 green;
+#X text 409 30 blue;
+#X obj 405 102 t b f;
+#X obj 339 160 +;
+#X obj 339 185 t b f;
+#X obj 339 216 +;
+#X obj 296 385 outlet;
+#X obj 343 385 outlet;
+#X obj 28 180 loadbang;
+#X obj 97 135 route back front label bang;
+#X obj 343 362 f;
+#X obj 296 361 f;
+#X obj 249 361 f;
+#X obj 262 79 * -65536;
+#X obj 339 80 * -256;
+#X obj 405 80 * -1;
+#X obj 339 247 - 1;
+#X obj 235 168 t b b b b;
+#X connect 0 0 28 0;
+#X connect 1 0 32 0;
+#X connect 2 0 33 0;
+#X connect 3 0 34 0;
+#X connect 4 0 5 0;
+#X connect 4 0 6 0;
+#X connect 5 0 14 1;
+#X connect 5 0 15 1;
+#X connect 6 0 13 1;
+#X connect 7 0 8 0;
+#X connect 7 0 9 0;
+#X connect 8 0 13 1;
+#X connect 8 0 15 1;
+#X connect 9 0 14 1;
+#X connect 10 0 11 0;
+#X connect 10 0 12 0;
+#X connect 11 0 13 1;
+#X connect 11 0 14 1;
+#X connect 12 0 15 1;
+#X connect 13 0 31 1;
+#X connect 14 0 30 1;
+#X connect 15 0 29 1;
+#X connect 21 0 22 0;
+#X connect 21 1 22 1;
+#X connect 22 0 23 0;
+#X connect 23 0 24 0;
+#X connect 23 1 24 1;
+#X connect 24 0 35 0;
+#X connect 27 0 6 0;
+#X connect 28 0 4 0;
+#X connect 28 1 7 0;
+#X connect 28 2 10 0;
+#X connect 28 3 36 0;
+#X connect 29 0 26 0;
+#X connect 30 0 25 0;
+#X connect 31 0 16 0;
+#X connect 32 0 24 0;
+#X connect 33 0 22 0;
+#X connect 34 0 21 0;
+#X connect 35 0 15 0;
+#X connect 35 0 14 0;
+#X connect 35 0 13 0;
+#X connect 36 0 31 0;
+#X connect 36 1 30 0;
+#X connect 36 2 29 0;
+#X connect 36 3 35 0;
+#X restore 285 96 pd RGB_____________;
+#X floatatom 327 65 3 0 255;
+#X floatatom 370 65 3 0 255;
+#X floatatom 413 66 3 0 255;
+#X text 34 10 preset-colors;
+#X text 296 7 RGB-colors;
+#X text 327 47 red;
+#X text 363 46 green;
+#X text 411 46 blue;
+#X connect 0 0 4 0;
+#X connect 1 0 0 0;
+#X connect 2 0 0 1;
+#X connect 3 0 4 1;
+#X connect 4 0 32 0;
+#X connect 7 0 34 0;
+#X connect 9 0 13 0;
+#X connect 10 0 9 0;
+#X connect 11 0 9 1;
+#X connect 12 0 13 1;
+#X connect 13 0 35 0;
+#X connect 14 0 18 0;
+#X connect 15 0 14 0;
+#X connect 16 0 14 1;
+#X connect 17 0 18 1;
+#X connect 18 0 36 0;
+#X connect 23 0 27 0;
+#X connect 24 0 23 0;
+#X connect 25 0 23 1;
+#X connect 26 0 27 1;
+#X connect 27 0 31 0;
+#X connect 44 0 48 0;
+#X connect 45 0 44 0;
+#X connect 46 0 44 1;
+#X connect 47 0 48 1;
+#X connect 48 0 49 0;
+#X connect 55 0 33 0;
+#X connect 56 0 55 0;
+#X connect 57 0 56 0;
+#X connect 58 0 56 1;
+#X connect 59 0 55 1;
+#X connect 60 0 55 2;
+#X connect 64 0 68 0;
+#X connect 65 0 68 0;
+#X connect 66 0 68 0;
+#X connect 67 0 68 0;
+#X connect 68 0 55 0;
+#X connect 68 1 55 1;
+#X connect 68 2 55 2;
+#X connect 69 0 68 1;
+#X connect 70 0 68 2;
+#X connect 71 0 68 3;
+#X restore 297 144 pd edit;
+#X obj 248 34 bng 15 250 50 0 aaa aaa empty 20 8 192 8 -262144 -1 -1
+;
+#X text 27 313 graz \, austria 2002;
+#X obj 180 11 x_all_guis aaa bbb ccc ddd eee fff ggg hhh iii;
+#X text 366 35 SEE ALSO:;
+#X obj 429 34 bang;
+#X text 22 341 This document was updated for PD version 0.35 test 24
+by Dave Sabine as part of a project called pddp proposed to build comprehensive
+documentation for PD.;
+#X connect 6 0 5 0;
+#X connect 8 0 9 0;
+#X connect 9 0 7 0;
+#X connect 9 0 5 0;
+#X connect 10 0 9 0;
+#X connect 11 0 9 0;
+#X connect 12 0 9 0;
+#X connect 13 0 9 0;
+#X connect 14 0 9 0;
+#X connect 17 0 19 0;
+#X connect 18 0 16 0;
+#X connect 20 0 9 0;
diff --git a/doc/pddp/help-change.pd b/doc/pddp/help-change.pd
new file mode 100644
index 00000000..3f77da07
--- /dev/null
+++ b/doc/pddp/help-change.pd
@@ -0,0 +1,52 @@
+#N canvas 33 5 471 644 10;
+#X floatatom 23 489 0 0 0;
+#X floatatom 23 400 0 0 0;
+#X floatatom 61 416 0 0 0;
+#X obj 66 15 change;
+#X text 114 16 - ELIMINATE REDUNDANCY IN A NUMBER STEAM;
+#X msg 61 438 set \$1;
+#X text 106 438 set the value;
+#X text 60 400 if different from current value \, output and set;
+#X obj 23 510 print;
+#X msg 16 81 1;
+#X msg 44 81 1;
+#X msg 73 81 1;
+#X msg 106 80 0;
+#X text 14 65 Click from left to right...;
+#X obj 16 112 change;
+#X obj 16 133 print;
+#X text 51 133 Watch terminal window.;
+#X text 12 42 The change object outputs its input only when it changes.
+;
+#X text 15 160 [change] will accept a float as a creation argument.
+That creation argument will define the inital value.;
+#X obj 19 225 change 6.5;
+#X obj 19 248 print;
+#X msg 19 196 6.5;
+#X msg 49 196 5.5;
+#X msg 191 285 bang;
+#X text 20 318 It's important to note that when [change] receives a
+number in its inlet \, that number is outputted (if its different than
+the currently stored value) and then stored.;
+#X obj 23 467 change;
+#X text 19 365 The "set" method can be used to store a number in the
+object without outputting that value.;
+#X text 22 585 This document was updated for PD version 0.35 test 26
+by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X text 17 269 Sending a "bang" message to the inlet will force [change]
+to output its current value.;
+#X connect 0 0 8 0;
+#X connect 1 0 25 0;
+#X connect 2 0 5 0;
+#X connect 5 0 25 0;
+#X connect 9 0 14 0;
+#X connect 10 0 14 0;
+#X connect 11 0 14 0;
+#X connect 12 0 14 0;
+#X connect 14 0 15 0;
+#X connect 19 0 20 0;
+#X connect 21 0 19 0;
+#X connect 22 0 19 0;
+#X connect 23 0 19 0;
+#X connect 25 0 0 0;
diff --git a/doc/pddp/help-clip.pd b/doc/pddp/help-clip.pd
new file mode 100644
index 00000000..04f8ddb5
--- /dev/null
+++ b/doc/pddp/help-clip.pd
@@ -0,0 +1,130 @@
+#N canvas 3 0 630 628 12;
+#X obj 114 560 pddp;
+#X obj 8 3 cnv 15 90 578 empty empty empty 20 12 0 14 -233017 -66577
+0;
+#X text 38 36 INLETS:;
+#X text 38 51 - LEFT:;
+#X text 32 230 - RIGHT:;
+#X text 29 346 OUTLETS:;
+#X text 13 281 ARGUMENTS:;
+#X text 20 412 EXAMPLES:;
+#X text 20 508 SEE ALSO:;
+#N canvas 58 0 411 260 Related_Objects 0;
+#X text 25 11 Native PD Objects;
+#X text 23 92 Externals and other object libraries;
+#X obj 45 54 int;
+#X obj 85 53 f;
+#X obj 123 53 min;
+#X obj 166 53 max;
+#X obj 206 53 clip~;
+#X obj 260 53 min~;
+#X obj 308 53 max~;
+#X text 44 125 - none that I am aware of;
+#X restore 114 508 pd Related_Objects;
+#N canvas 57 0 639 620 More_Info 0;
+#X text 26 174 THE MYSTERIOUS RIGHT OUTLET;
+#X obj 158 252 clip;
+#X obj 82 240 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X floatatom 130 203 5 0 0 0 - - -;
+#X symbolatom 195 204 10 0 0 0 - - -;
+#X msg 209 227 list dave peter john;
+#X msg 49 200 message;
+#X floatatom 199 281 5 0 0 0 - - -;
+#X obj 258 278 print;
+#X obj 174 283 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 313 280 no response to any message or atom.;
+#X text 30 347 LOW AND HIGH VALUES;
+#X text 304 34 Consider the following:;
+#X floatatom 101 66 5 0 0 0 - - -;
+#X floatatom 83 147 5 0 0 0 - - -;
+#X obj 83 121 min 50;
+#X obj 83 95 max -50;
+#X text 170 106 same as;
+#X obj 271 104 clip -50 50;
+#X floatatom 271 133 5 0 0 0 - - -;
+#X text 43 18 [clip] is a tool which combines the functionality of
+[min] and [max] into a single object.;
+#X text 46 368 [clip] always assumes that the first argument (second
+inlet) is the low extreme of the range and the second argument (third
+inlet) is the high extreme. However \, strange behaviour should be
+expected if you mix these arguments up.;
+#X obj 54 491 clip -50 50;
+#X obj 180 485 clip 72 -104;
+#X floatatom 54 458 5 0 0 0 - - -;
+#X floatatom 54 520 5 0 0 0 - - -;
+#X floatatom 180 517 5 0 0 0 - - -;
+#X text 50 306 I assume it is there for a reason...but I don't know
+that reason. It might exist for compatiblity with MAX?;
+#X text 185 444 Numbers below 72 are clipped to 72;
+#X text 185 464 Numbers above -104 are clipped to -104;
+#X text 172 565 This could be used effectively to toggle between two
+numbers.;
+#X floatatom 391 543 5 0 0 0 - - -;
+#X obj 360 520 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0
+1;
+#X obj 392 512 clip 1 -1024;
+#X connect 1 1 7 0;
+#X connect 1 1 8 0;
+#X connect 1 1 9 0;
+#X connect 2 0 1 0;
+#X connect 3 0 1 0;
+#X connect 4 0 1 0;
+#X connect 5 0 1 0;
+#X connect 6 0 1 0;
+#X connect 13 0 16 0;
+#X connect 13 0 18 0;
+#X connect 15 0 14 0;
+#X connect 16 0 15 0;
+#X connect 18 0 19 0;
+#X connect 22 0 25 0;
+#X connect 23 0 26 0;
+#X connect 24 0 22 0;
+#X connect 24 0 23 0;
+#X connect 32 0 33 0;
+#X connect 33 0 31 0;
+#X restore 114 534 pd More_Info;
+#X obj 57 11 clip;
+#X text 105 51 Float - A float at the left inlet will be clipped to
+the low and high values stored in the object.;
+#X text 105 82 List - A list at the left inlet will be truncated to
+include only the first three elements. The first element in the list
+is the number which will be clipped. The second element will update
+the value stored at the second inlet. The third element will update
+the value stored at the third inlet.;
+#X text 25 180 - CENTER:;
+#X text 105 180 Float - A float at the second inlet is stored for later
+use. It will be used as either the low or high value at which to clip
+incoming floats at that left inlet.;
+#X text 105 231 Float - A float at the third inlet is stored for later
+use. It will be used as either the low or high value at which to clip
+incoming floats at that left inlet.;
+#X text 104 281 Two - [float] accepts two floats as creation arguments
+which initializes the first values to be stored in the object and duplicate
+the functions of the second and third inlet.;
+#X text 102 346 One - outputs a float which is limited to a range within
+the high and low values of the second and third inlet. (The second
+outlet has no apparent purpose other than cross-compatibility with
+MAX.);
+#X text 108 12 - FORCE A NUMBER INTO A RANGE;
+#X obj 122 448 clip -50 50;
+#X floatatom 122 475 5 0 0 0 - - -;
+#X floatatom 122 424 5 0 0 0 - - -;
+#X text 181 425 creation arguments;
+#X obj 411 486 clip;
+#X floatatom 404 458 5 0 0 0 - - -;
+#X floatatom 460 457 5 0 0 0 - - -;
+#X floatatom 520 457 5 0 0 0 - - -;
+#X floatatom 411 512 5 0 0 0 - - -;
+#X text 464 488 no arguments;
+#X text 494 425 list;
+#X text 158 561 - Dave Sabine \, April 25 \, 2003;
+#X msg 383 425 42 100 500;
+#X connect 20 0 21 0;
+#X connect 22 0 20 0;
+#X connect 24 0 28 0;
+#X connect 25 0 24 0;
+#X connect 26 0 24 1;
+#X connect 27 0 24 2;
+#X connect 32 0 24 0;
diff --git a/doc/pddp/help-cputime.pd b/doc/pddp/help-cputime.pd
new file mode 100644
index 00000000..45e93136
--- /dev/null
+++ b/doc/pddp/help-cputime.pd
@@ -0,0 +1,112 @@
+#N canvas 11 8 939 645 10;
+#X msg 43 113 bang;
+#X msg 18 91 bang;
+#X floatatom 18 157 0 0 0;
+#X text 90 159 Output is in milliseconds;
+#X text 53 91 Click here to start or reset;
+#X obj 52 545 time_measurements;
+#X obj 52 441 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X floatatom 17 572 0 0 0;
+#X floatatom 108 585 0 0 0;
+#X floatatom 175 573 0 0 0;
+#X text 11 358 In the example below \, I've created an abstraction
+which will force each of PD's stop-watches \, [timer] [cputime] and
+[realtime] to measure various processes and report the elapsed time.
+Click on each [bng] to begin the process and wait for the results.
+Notice the discrepancies in the results.;
+#X text 15 587 Logical Time;
+#X text 173 587 Real Time;
+#X text 107 601 CPU Time;
+#X obj 67 477 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 72 435 1 Measures elapsed time between two "bangs" from a [trigger]
+object.;
+#X text 87 469 2 Measures the amount of time PD requires to turn on
+DSP and start an oscillator.;
+#X obj 445 484 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 445 17 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 472 36 WHY THE DISCREPANCIES BETWEEN CLOCKS?;
+#X text 475 59 In a fantasy world \, computers could exist somehow
+beyond the restrictions of time and digital computation could be performed
+in ZERO time. However \, that is not the case. Instead \, every process
+within PD and within your operating system requires at least a few
+nanoseconds of your CPU's time.;
+#X obj 111 509 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 476 144 The [timer] object is like a clock that is not constrained
+to the regular laws of physics and the universal space-time continuum.
+It reports "time" measurements as only PD can see them!;
+#X text 477 203 The [cputime] object is like a clock that measures
+how much time your CPU actually required to carry out your request.
+Keep in mind however that your CPU is busy doing many things simoultaneously
+\, so even though a process might take 5 minutes to complete \, your
+CPU does not pay full attention to that process for the entire 5 minutes.
+Instead \, it simply begins the process \, then refers back to that
+process from time to time until the it is complete. In other cases
+\, your CPU might require a full 5 minutes while PD might report that
+merely a few milliseconds have passed. This type of discrepancy depends
+heavily on your computer's hardware and the type of processing it is
+performing.;
+#X text 478 368 The [realtime] object is as much like your own wrist
+watch as PD can possibly manage. It measures time according to your
+operating system's internal clock.;
+#N canvas 0 0 456 306 related_objects_from_other_libraries 0;
+#X text 27 63 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 26 112 The best places to find information about PD's libraries
+is:;
+#X text 23 134 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 25 149 or;
+#X text 25 164 iem.kug.ac.at/pdb/;
+#X obj 44 24 t3_timer;
+#X text 469 589 This document was updated for PD version 0.35 test
+26 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X restore 482 539 pd related_objects_from_other_libraries;
+#X text 309 580 This document was updated for PD version 0.35 test
+28 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X obj 602 508 metro;
+#X text 481 485 RELATED OBJECTS;
+#X obj 539 508 realtime;
+#X text 132 501 3 Measures the amount of time PD requires count to
+three...please wait for approximately 3 seconds.;
+#X obj 25 15 cputime;
+#X text 80 14 -- measure CPU time;
+#X text 13 44 The [cputime] object measures elapsed CPU time. CPU time
+is the amount of time your computer's CPU requires to perform a task
+-- that's a short definition.;
+#X obj 18 135 cputime;
+#X text 81 114 Click here to get elapsed CPU time. Click again...and
+again...to see periodic measurements from the start or reset time.
+Be patient.;
+#X text 11 185 [cputime] works like essentially like a stop-watch.
+Once it starts \, you can continue to "poll" [cputime] to view the
+elapsed time.;
+#X text 11 232 The odd aspect about comparing [cputime] to a stop-watch
+is that a stop-watch can be stopped! [cputime] can only be started
+or reset. It cannot be stopped.;
+#X text 10 282 As stated above \, [cputime] measures "CPU" time. This
+value may be slightly different than "logical" time or "real" time.
+PD offers two objects which measure "logical" time and "real" time.
+See the reference documents for those objects for more information.
+;
+#X obj 481 509 timer;
+#X text 472 419 MORE INFORMATION;
+#X text 477 438 More information about [cputime] can be found in the
+Pure Documentation reference folder 7.stuff/load-meter.pd;
+#X connect 0 0 34 1;
+#X connect 1 0 34 0;
+#X connect 5 0 7 0;
+#X connect 5 1 8 0;
+#X connect 5 2 9 0;
+#X connect 6 0 5 0;
+#X connect 14 0 5 1;
+#X connect 18 0 17 0;
+#X connect 21 0 5 2;
+#X connect 34 0 2 0;
diff --git a/doc/pddp/help-ctlin.pd b/doc/pddp/help-ctlin.pd
new file mode 100644
index 00000000..136ea95d
--- /dev/null
+++ b/doc/pddp/help-ctlin.pd
@@ -0,0 +1,86 @@
+#N canvas 261 0 448 656 10;
+#N canvas 240 135 476 472 other_midi_objects 0;
+#X obj 55 31 ctlin;
+#X obj 97 31 pgmin;
+#X obj 140 30 bendin;
+#X obj 191 29 touchin;
+#X obj 252 29 polytouchin;
+#X obj 337 29 midiin;
+#X obj 388 28 sysexin;
+#X obj 6 85 noteout;
+#X obj 63 84 ctlout;
+#X obj 161 85 touchout;
+#X obj 225 84 polytouchout;
+#X obj 314 84 midiout;
+#X obj 113 84 pgmout;
+#X obj 11 153 makenote;
+#X text 10 194 MIDI notes deconstruction:;
+#X text 8 128 MIDI note construction:;
+#X text 8 58 MIDI output:;
+#X text 8 2 MIDI input:;
+#X obj 15 226 stripnote;
+#X text 11 266 Additional useful objects for MIDI processing (Maxlib
+by Olaf Matthes);
+#X obj 148 297 chord;
+#X obj 109 296 borax;
+#X obj 54 296 score o;
+#X obj 13 296 pitch;
+#X text 15 336 Also \, from cyclone (alpha) by Krzysztof Czaja:;
+#X obj 16 359 midiformat;
+#X obj 172 359 midiflush;
+#X obj 98 359 midiparse;
+#X text 15 386 and xeq \, from the same developer;
+#X obj 16 411 xeq;
+#X text 41 402 an experimental MIDI sequencer;
+#X obj 8 31 midiin;
+#X restore 88 534 pd other_midi_objects;
+#X obj 280 562 midi-basics;
+#X text 18 562 for an explanation of MIDI usage in PD see:;
+#X obj 28 18 ctlin;
+#X obj 19 226 ctlin;
+#X floatatom 19 252 5 0 0;
+#X floatatom 33 272 5 0 0;
+#X floatatom 49 290 5 0 0;
+#X text 17 127 Arguments (optional): 1st argument (or only argument)
+indicates the controller number to process. The second argument \,
+if present \, indicates the channel number on which the controller
+is to be processed. If the second argument is absent [ctlin] reads
+all channels. If no arguments are preent [ctlin] reads all controller
+data on all channels.;
+#X text 66 221 Inlets: none. Reads data directly from the MIDI port
+;
+#X text 66 235 Outlets:;
+#X text 116 249 1st (leftmost): Controller value;
+#X text 118 265 Middle: controller number;
+#X text 118 285 rightmost: Channel number;
+#X text 17 317 If one comment is given (ctl. number) [ctlin] provides
+the user with only 2 outlets: ctl. value and channel no. If 2 arguments
+are given (ctl. no. & chan. no.) only one outlet (ctl. value) is given:
+;
+#X obj 24 383 ctlin 64;
+#X floatatom 24 417 5 0 0;
+#X floatatom 74 407 5 0 0;
+#X text 97 382 Process only controller no. 64 on all channels;
+#X text 7 430 ctl. value;
+#X text 83 420 Chan. no.;
+#X obj 25 455 ctlin 64 1;
+#X text 102 456 Process only controller 64 on channel 1;
+#X floatatom 25 481 5 0 0;
+#X text 22 496 ctl. value;
+#X obj 21 534 ctlout;
+#X text 18 515 See also:;
+#X text 13 51 The [ctlin] object reads control change messages directly
+from the MIDI port. See a MIDI-specification chart near you for control
+change message numbers and their meannings (MIDI implementation documents
+are freely available on the internet in c=various forms).;
+#X text 69 18 - read incoming Control Change messages;
+#X text 19 586 This document was updated for PD version 0.35 by Michal
+Seta as part of a project called pddp proposed by Krzysztof Czaja \,
+managed and edited by Dave Sabine \, to build comprehensive documentation
+for PD.;
+#X connect 4 0 5 0;
+#X connect 4 1 6 0;
+#X connect 4 2 7 0;
+#X connect 15 0 16 0;
+#X connect 15 1 17 0;
+#X connect 21 0 23 0;
diff --git a/doc/pddp/help-ctlout.pd b/doc/pddp/help-ctlout.pd
new file mode 100644
index 00000000..621fb9d7
--- /dev/null
+++ b/doc/pddp/help-ctlout.pd
@@ -0,0 +1,90 @@
+#N canvas 251 9 495 634 10;
+#N canvas 240 135 476 472 other_midi_objects 0;
+#X obj 55 31 ctlin;
+#X obj 97 31 pgmin;
+#X obj 140 30 bendin;
+#X obj 191 29 touchin;
+#X obj 252 29 polytouchin;
+#X obj 337 29 midiin;
+#X obj 388 28 sysexin;
+#X obj 6 85 noteout;
+#X obj 63 84 ctlout;
+#X obj 161 85 touchout;
+#X obj 225 84 polytouchout;
+#X obj 314 84 midiout;
+#X obj 113 84 pgmout;
+#X obj 11 153 makenote;
+#X text 10 194 MIDI notes deconstruction:;
+#X text 8 128 MIDI note construction:;
+#X text 8 58 MIDI output:;
+#X text 8 2 MIDI input:;
+#X obj 15 226 stripnote;
+#X text 11 266 Additional useful objects for MIDI processing (Maxlib
+by Olaf Matthes);
+#X obj 148 297 chord;
+#X obj 109 296 borax;
+#X obj 54 296 score o;
+#X obj 13 296 pitch;
+#X text 15 336 Also \, from cyclone (alpha) by Krzysztof Czaja:;
+#X obj 16 359 midiformat;
+#X obj 172 359 midiflush;
+#X obj 98 359 midiparse;
+#X text 15 386 and xeq \, from the same developer;
+#X obj 16 411 xeq;
+#X text 41 402 an experimental MIDI sequencer;
+#X obj 8 31 midiin;
+#X restore 89 430 pd other_midi_objects;
+#X obj 285 469 midi-basics;
+#X text 21 469 for an explanation of MIDI usage in PD see:;
+#X obj 18 16 ctlout;
+#X text 14 43 The [ctlout] objects sends control messages to the MIDI
+port. See a MIDI specification chart for various controller numbers/values
+descriptions.;
+#X text 15 89 Arguments (optional):;
+#X text 24 105 1st (or only one) argument represents the controller
+number to transmit to.;
+#X text 24 137 2nd argument designates the channel number to transmit
+on. If no channel is specified it transmits on channel 1;
+#X floatatom 21 181 5 0 0;
+#X obj 21 231 ctlout;
+#X floatatom 39 197 5 0 0;
+#X floatatom 57 213 5 0 0;
+#X text 108 175 Inlets:;
+#X text 107 240 Outlets: none. Transmits directly to the MIDI port.
+;
+#X text 120 192 Left: (int) control value (0-127).;
+#X text 120 207 Middle: (int) controller number.;
+#X text 120 223 Right: (int) channel number.;
+#X text 21 264 NOTE: the left inlet accepts also a list of (2 or 3)
+integers where the first item is controller value \, second controller
+number and third the channel number.;
+#X obj 24 356 ctlout;
+#X obj 116 356 ctlout 64;
+#X obj 218 356 ctlout 64 2;
+#X obj 320 355 ctlout;
+#X msg 43 337 64;
+#X msg 73 337 2;
+#X msg 317 320 67 64 2;
+#X floatatom 218 318 5 0 0;
+#X floatatom 116 316 5 0 0;
+#X floatatom 24 316 5 0 0;
+#X msg 173 333 2;
+#X text 23 379 All these examples will transmit control no 64 on channel
+2 (remember to click the message boxes to initialize).;
+#X text 22 411 See also:;
+#X obj 25 430 ctlin;
+#X text 66 17 - send MIDI control messages to the MIDI port;
+#X text 19 515 This document was updated for PD version 0.35 by Michal
+Seta as part of a project called pddp proposed by Krzysztof Czaja \,
+managed and edited by Dave Sabine \, to build comprehensive documentation
+for PD.;
+#X connect 8 0 9 0;
+#X connect 10 0 9 1;
+#X connect 11 0 9 2;
+#X connect 22 0 18 1;
+#X connect 23 0 18 2;
+#X connect 24 0 21 0;
+#X connect 25 0 20 0;
+#X connect 26 0 19 0;
+#X connect 27 0 18 0;
+#X connect 28 0 19 2;
diff --git a/doc/pddp/help-dac~.pd b/doc/pddp/help-dac~.pd
new file mode 100644
index 00000000..a45a4594
--- /dev/null
+++ b/doc/pddp/help-dac~.pd
@@ -0,0 +1,68 @@
+#N canvas 2 1 613 608 12;
+#X obj 104 540 pddp;
+#X obj 8 8 cnv 15 90 553 empty empty empty 20 12 0 14 -233017 -66577
+0;
+#N canvas 85 2 595 611 More_Info 0;
+#X text 16 13 MULTI-CHANNEL AUDIO;
+#X text 32 40 All sound cards are capable of at least two channels
+of audio. PD supports these two channels by default and uses your system's
+generic audio drivers to communicate with your hardware. However \,
+for faster input/output and for more than two channels of audio \,
+PD incorporates the use of "PortAudio" which uses ASIO drivers to communicate
+with your hardware. So \, to instruct PD to use more than two channels
+of audio \, your command line should read like below:;
+#X text 93 182 c:/pd/bin/pd.exe -pa -inchannels 8 -outchannels 8;
+#X text 32 211 The "-pa" switch means "PortAudio". This switch is new
+as of PD version 0.37 TEST 4 and replaces the old "-asio" switch.;
+#X text 32 271 The "-inchannels" and "-outchannels" switches can be
+summarized by using "-channels 8" because currently PortAudio requires
+that the number of incoming and outgoing channels must be equal. This
+may change in the PD's future...;
+#X text 32 361 To further optimize PD's usage of your audio hardware
+\, you can explore the following:;
+#X text 42 402 - audiobuf;
+#X text 43 420 - blocksize;
+#X text 42 436 - audioindev;
+#X text 42 454 - audiooutdev;
+#X text 38 480 With the right hardware \, PD can manage audio input
+and output with lower than 10 milliseconds of latency.;
+#X restore 104 514 pd More_Info;
+#N canvas 85 2 397 246 Related_Objects 0;
+#X text 25 8 Native PD Objects;
+#X text 25 92 Externals and other object libraries;
+#X obj 98 46 switch~;
+#X obj 171 46 block~;
+#X obj 45 46 adc~;
+#X restore 104 488 pd Related_Objects;
+#X text 16 107 ARGUMENTS:;
+#X text 23 344 EXAMPLES:;
+#X text 20 487 SEE ALSO:;
+#X text 30 53 PURPOSE:;
+#X text 152 541 - Dave Sabine \, May 6 \, 2003;
+#X text 153 346 default stereo signals: same as;
+#X text 280 435 all channels on an 8-channel device;
+#X obj 33 20 dac~;
+#X text 108 18 - AUDIO OUTPUT: DIGITAL/ANALOG CONVERTER SIGNAL;
+#X text 104 53 [dac~] is an acronym meaning "Digital/Analog Converter
+Signal" and is PD's interface to send audio information to the audio
+channels of your soundcard(s).;
+#X text 106 106 The object defaults to 2 outgoing audio channels (usually
+a left and right stereo pair). Any number of arguments (integers) can
+be used to define multiple output channels - each integer corresponds
+to an output channel on your audio hardware.;
+#X text 36 188 INLETS:;
+#X text 108 188 Signal: the number of inlets correspond with the number
+of arguments - each inlet represents an output channel on your audio
+hardware which corresponds to the argument you provide. If no arguments
+are provided \, then there are two inlets which represent audio channels
+1 and 2 on your computer's sound card.;
+#X text 107 290 The information at each inlet should be an audio signal
+(i.e. the object operates at 'audio-rate') and therefore must be connected
+to an audio outlet on a related object.;
+#X obj 109 346 dac~;
+#X obj 411 348 dac~ 1 2;
+#X obj 109 373 dac~ 5;
+#X text 167 374 a mono signal to channel 5;
+#X obj 109 404 dac~ 1 3 8 6 11 15 19 22 23 24 36;
+#X text 383 405 11 channels of output;
+#X obj 109 434 dac~ 1 2 3 4 5 6 7 8;
diff --git a/doc/pddp/help-delay.pd b/doc/pddp/help-delay.pd
new file mode 100644
index 00000000..e6fb50e8
--- /dev/null
+++ b/doc/pddp/help-delay.pd
@@ -0,0 +1,139 @@
+#N canvas 9 3 918 652 10;
+#X obj 22 14 delay;
+#X msg 10 418 bang;
+#X floatatom 75 486 0 0 0;
+#X text 98 511 <-- creation argument initializes delay time;
+#X obj 20 511 delay 1000;
+#X text 56 440 Click here to CANCEL delay's action;
+#X msg 20 440 stop;
+#X msg 31 462 2000;
+#X text 67 462 Number in right inlet sets time and schedules the action.
+;
+#X text 104 486 <-- scroll to change delay time in milliseconds;
+#X text 60 14 - BANG AFTER TIME DELAY;
+#X obj 20 90 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 20 110 delay 2000;
+#X obj 20 133 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 12 42 The [delay] object sends a bang to its outlet after a
+delay in milliseconds specified by its right inlet or its creation
+argument.;
+#X text 15 157 [delay]'s left inlet accepts a number \, or one of two
+messages: "bang" or "stop".;
+#X text 14 238 The "bang" method will inform [delay] to send a "bang"
+to its outlet after the prescribed time (which is set either at its
+right inlet \, or in the creation argument). In the above example \,
+you should notice a delay of 2 seconds \, then a "bang" at the outlet.
+;
+#X text 13 314 [delay] accepts only ONE "bang" at a time. It cannot
+process multiple delays. In other words \, sending a "bang" to a [delay]
+which is already set will reschedule its output \, cancelling the old
+one.;
+#X text 15 379 The "stop" method will inform [delay] to cancel its
+scheduled output.;
+#X text 14 191 If a number is sent to its inlet \, [delay] will set
+the delay time equal to that number and schedule the outgoing "bang".
+;
+#X obj 20 536 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 43 419 "bang" to schedule the action;
+#X obj 414 9 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 414 613 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 445 15 A MAKESHIFT [METRO];
+#X text 433 35 Let's assume for a moment that Miller had forgotten
+to build the [metro] object. (I know that sounds absurd \, but for
+the sake of example...);
+#X text 433 84 [delay] could be used to create a metronome as follows.
+;
+#X obj 463 175 bng 15 50 10 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 463 155 delay 1000;
+#X msg 427 115 bang;
+#X msg 463 115 stop;
+#X obj 671 154 metro 1000;
+#X obj 671 175 bng 15 50 10 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 671 135 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0
+1;
+#X floatatom 726 135 5 0 0;
+#X floatatom 518 137 5 0 0;
+#X text 557 155 is the same as;
+#X text 448 206 A RANDOM IMPULSE GENERATOR;
+#X text 433 223 Some users might be familiar with SC (SuperCollider)
+by James McCartney. For more info about SC \, visit www.audiosynth.com.
+Anyways...SC has a unit generator called "DUST". Dust will produce
+random impulses at a specified "density". I believe that Dust was given
+its name because it creates a sound that is similar to actual dust
+on old vinyl LP's -- you know that old crackling sound like Rice Krispies.
+;
+#X text 432 331 The idea is quite simple. If you want a "very dusty"
+sound \, you make the density quite high...if you want a "slightly
+dusty" sound \, you make the density quite low.;
+#X obj 434 484 delay;
+#X obj 434 506 bng 15 50 10 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 434 423 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0
+1;
+#X text 432 376 Dust.ar(2) in SC will produce 2 dusty impulses randomly
+per second. In the example below \, you'll see a version of this process
+created using PD's delay object.;
+#X obj 434 463 random 500;
+#X obj 434 442 metro 500;
+#X text 13 563 It is important to realize that [delay] only outputs
+a "bang". It cannot be used like an "echo" or to delay messages other
+than "bang". For that purpose \, you should explore;
+#X obj 63 605 pipe;
+#X text 431 528 RELATED OBJECTS;
+#X obj 466 548 timer;
+#X obj 432 548 pipe;
+#X obj 504 548 metro;
+#N canvas 0 0 452 302 related_objects_from_other_libraries 0;
+#X obj 27 25 nop~;
+#X obj 63 25 z~;
+#X obj 93 25 t3_delay;
+#X obj 153 25 idelay~;
+#X text 18 59 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 17 108 The best places to find information about PD's libraries
+is:;
+#X text 14 130 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 16 160 iem.kug.ac.at/pdb/;
+#X restore 432 569 pd related_objects_from_other_libraries;
+#X obj 543 548 makenote;
+#X obj 603 548 delwrite~;
+#X text 445 594 This document was updated for PD version 0.35 test
+28 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X floatatom 504 428 5 0 0;
+#X text 546 421 low numbers will produce a very "dusty" output.;
+#X text 546 433 high numbers will produce a slightly "dusty" output.
+;
+#X text 546 448 Also note that this example merely approximates the
+output of SC's "Dust" object.;
+#X connect 1 0 4 0;
+#X connect 2 0 4 1;
+#X connect 4 0 20 0;
+#X connect 6 0 4 0;
+#X connect 7 0 4 0;
+#X connect 11 0 12 0;
+#X connect 12 0 13 0;
+#X connect 22 0 23 0;
+#X connect 27 0 29 0;
+#X connect 28 0 27 0;
+#X connect 29 0 28 0;
+#X connect 30 0 28 0;
+#X connect 31 0 32 0;
+#X connect 33 0 31 0;
+#X connect 34 0 31 1;
+#X connect 35 0 28 1;
+#X connect 40 0 41 0;
+#X connect 42 0 45 0;
+#X connect 44 0 40 0;
+#X connect 45 0 44 0;
+#X connect 56 0 45 1;
+#X connect 56 0 44 1;
diff --git a/doc/pddp/help-float.pd b/doc/pddp/help-float.pd
new file mode 100644
index 00000000..10630895
--- /dev/null
+++ b/doc/pddp/help-float.pd
@@ -0,0 +1,88 @@
+#N canvas 0 0 626 624 12;
+#X obj 114 560 pddp;
+#X obj 8 3 cnv 15 90 578 empty empty empty 20 12 0 14 -233017 -66577
+0;
+#X floatatom 325 358 5 0 0 0 - - -;
+#X floatatom 484 395 5 0 0 0 - - -;
+#X floatatom 369 462 5 0 0 0 - - -;
+#X msg 304 402 42 7;
+#X obj 366 396 bng 15 250 50 0 empty empty "bang" 0 -6 0 8 -262144
+-1 -1;
+#X floatatom 128 422 5 0 0 0 - - -;
+#X msg 128 373 bang;
+#X obj 46 18 float;
+#X obj 492 17 f;
+#X text 111 18 - STORE A FLOATING POINT NUMBER - abbreviation:;
+#X msg 249 402 7 3 4;
+#X obj 369 436 f;
+#X obj 128 397 float 7;
+#X text 113 484 doc/2.control.examples/sendnumber.pd;
+#X text 371 358 Tip: Shift+drag;
+#X text 37 44 INLETS:;
+#X text 37 59 - LEFT:;
+#X text 104 59 Float - A float at the left inlet will update the stored
+value of the object and will send the number immediately to the outlet.
+;
+#X text 104 114 Bang - A bang at the left inlet will force [float]
+to send its value to the outlet.;
+#X text 104 152 List - A list at the left inlet will be truncated to
+include only the first element. The first element in the list will
+update the stored value of the object and will send the number immediately
+to the outlet.;
+#X text 29 220 - RIGHT:;
+#X text 105 220 Float - A float at the right inlet is stored for later
+use. It will be sent to the left outlet when a float or bang is received
+in the left inlet.;
+#X text 29 324 OUTLETS:;
+#X text 13 272 ARGUMENTS:;
+#X text 20 354 EXAMPLES:;
+#X text 22 484 SEE ALSO:;
+#X text 104 272 One - [float] accepts a single float as a creation
+argument which initializes the first value to be sent out the left
+outlet.;
+#X text 104 325 One - outputs the stored floating point value of the
+object.;
+#X text 249 384 lists;
+#X text 106 355 creation argument;
+#N canvas 58 0 401 250 Related_Objects 0;
+#X text 25 11 Native PD Objects;
+#X text 23 92 Externals and other object libraries;
+#X obj 42 48 int;
+#X obj 109 48 symbol;
+#X text 36 126 [randomF];
+#X restore 114 508 pd Related_Objects;
+#N canvas 57 0 637 618 More_Info 0;
+#X text 43 24 All numbers in PD are kept in 32-bit floating point and
+can represent real numbers between -8 \, 388608 and 8.388.608.00;
+#X text 11 78 WHAT IS A FLOATING POINT NUMBER?;
+#X text 41 267 The following are examples of floating point numbers:
+;
+#X text 61 293 3;
+#X text 62 334 -111.5;
+#X text 61 313 0.5;
+#X text 40 387 3e-005 : This example is a computer shorthand for scientific
+notation. It means 3*10-5 (or 10 to the negative 5th power multiplied
+by 3).;
+#X text 41 108 According to Webopedia.com \, "computers are integer
+machines and are capable of representing real numbers only by using
+complex codes." Hence \, real numbers must be 'approximated' by computers
+using the "floating point standard". In such a number \, the decimal
+point can "float" meaning that there is no fixed number of digits preceding
+or following the decimal. A floating point number is therefore a computer's
+approximation of a real number.;
+#X text 43 453 Interesting side-note: In the early 1990's \, the Intel
+80486 was shipped with a math coprocessor to help accelerate the process
+of computing floating point numbers (which previously required a considerable
+amount of CPU power.) Math coprocessors have since found there way
+into nearly every graphics card and CPU available today.;
+#X text 62 358 10000 to 1e-016;
+#X restore 114 534 pd More_Info;
+#X text 158 561 - Dave Sabine \, November 18 \, 2002;
+#X connect 2 0 13 0;
+#X connect 3 0 13 1;
+#X connect 5 0 13 0;
+#X connect 6 0 13 0;
+#X connect 8 0 14 0;
+#X connect 12 0 13 0;
+#X connect 13 0 4 0;
+#X connect 14 0 7 0;
diff --git a/doc/pddp/help-int.pd b/doc/pddp/help-int.pd
new file mode 100644
index 00000000..9e176a59
--- /dev/null
+++ b/doc/pddp/help-int.pd
@@ -0,0 +1,83 @@
+#N canvas 9 19 907 630 10;
+#X msg 33 230 bang;
+#X floatatom 23 313 0 0 0;
+#X floatatom 23 208 0 0 0;
+#X floatatom 47 255 0 0 0;
+#X text 71 230 You can force the object to output the stored number.
+;
+#X text 68 208 You can set and output the value simoultaneously.;
+#X text 105 255 You can store the number \, without outputting it.
+;
+#X text 488 142 NOTE;
+#X obj 450 8 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 450 547 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 284 568 This document was updated for PD version 0.35 test
+24 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X text 482 480 RELATED OBJECTS;
+#X obj 529 507 symbol;
+#X text 97 11 - STORE AN INTEGER;
+#X obj 55 12 int;
+#X text 19 41 The int object stores an integer (which is set either
+by its creation argument or by the right inlet) and then outputs that
+number when it receives a "bang" message or a new number in its left
+inlet.;
+#X text 18 98 This object acts exactly as its nearest cousin:;
+#X obj 307 97 float;
+#X text 495 159 All numbers in PD are kept in 32-bit floating point
+and can represent real numbers between -8 \, 388 \, 608 and 8 \, 388
+\, 608 Hence \, the [int] object takes about as much CPU as the [float]
+object \; but is useful when numbers need to be truncated and/or when
+patches are being designed to be compatible with PD and MAX/MSP.;
+#X text 18 160 Tip: Press and hold SHIFT while click-n-dragging these
+number boxes to see how the [int] object truncates the number - drops
+decimal places.;
+#X obj 23 287 int 6.5;
+#X text 17 114 with only one exception: All decimal places are dropped!
+All fractions will be truncated \; they will not be 'rounded off'.
+;
+#X obj 491 507 float;
+#X obj 573 506 random;
+#X text 487 10 WHAT IS AN INTEGER?;
+#X text 493 29 Integers are "whole" numbers - numbers which do not
+contain fractions. The following are examples of whole numbers:;
+#X text 494 59 1;
+#X text 494 74 -544;
+#X text 494 103 10024;
+#X text 493 88 420;
+#N canvas 0 0 414 279 related_objects_from_other_libraries 0;
+#X obj 22 19 list2int;
+#X obj 77 19 i2l;
+#X obj 104 19 probalizer;
+#X text 20 56 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 19 105 The best places to find information about PD's libraries
+is:;
+#X text 16 127 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 18 157 iem.kug.ac.at/pdb/;
+#X restore 490 529 pd related_objects_from_other_libraries;
+#X text 496 283 The [int] object can be used as a basis for building
+simple counter mechanisms in PD. In the example below \, the [int]
+object's stored value is incremented by 1 with each "bang".;
+#X text 87 281 The creation argument initializes the object and stores
+the number until the value is reset. The creation argument is optional.
+If no creation argument is provided \, the object defaults to zero.
+;
+#X msg 511 340 bang;
+#X obj 511 369 int;
+#X obj 539 369 + 1;
+#X floatatom 511 395 5 0 0;
+#X text 486 263 EXAMPLE: BUILDING A COUNTER;
+#X connect 0 0 20 0;
+#X connect 2 0 20 0;
+#X connect 3 0 20 1;
+#X connect 8 0 9 0;
+#X connect 20 0 1 0;
+#X connect 33 0 34 0;
+#X connect 34 0 35 0;
+#X connect 34 0 36 0;
+#X connect 35 0 34 1;
diff --git a/doc/pddp/help-line.pd b/doc/pddp/help-line.pd
new file mode 100644
index 00000000..a188ad45
--- /dev/null
+++ b/doc/pddp/help-line.pd
@@ -0,0 +1,166 @@
+#N canvas 70 32 802 522 10;
+#X obj 22 14 line;
+#X text 57 14 -- ramp generator;
+#X text 17 43 [line]'s left inlet defines the "target" value. The right
+inlet defines the "time" value. The "target \, time" pair of numbers
+inform [line] to produce a numeric "ramp" from its current value (whatever
+that might be at any given moment) to the new value within the alloted
+time which is defined at the right inlet.;
+#X text 18 131 It is important to realize that [line] stores only the
+current value...it does not remember the defined "time" (duration of
+the ramp). Hence \, the following works:;
+#X obj 26 246 line;
+#X msg 60 222 1000;
+#X msg 26 222 1000;
+#X obj 26 179 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 26 199 t b b;
+#X floatatom 26 268 5 0 0;
+#X obj 167 254 line;
+#X msg 167 230 1000;
+#X obj 167 210 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X floatatom 167 276 5 0 0;
+#X text 20 293 If [line] receives a new target value without an accompanying
+"time" \, it simply jumps to the new value...as in the example above
+on the right. In the example above on the left \, you'll see that [line]
+will create a numeric ramp from 0 to 1000 over 1000 milliseconds. You
+should also note that if you click that [bng] again a second time \,
+nothing happens. This is because [line] is already at 1000 \, so sending
+it new instructions to ramp to 1000 is meaningless and has no effect.
+;
+#X text 18 419 Having said all of that \, let's just reiterate that
+it's important to send a "time" value to [line] before sending it a
+new "target" value...unless of course you WANT it to jump immediately
+to the new target.;
+#X text 415 20 [line] will accept a list of two numbers. The first
+in the list will be assigned as the new target \, the second in the
+list will be the new time (duration of the ramp) as below:;
+#X obj 387 11 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 387 473 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 420 187 line;
+#X msg 420 99 1000 1000;
+#X floatatom 420 208 5 0 0;
+#X text 486 98 ramp up.;
+#X msg 429 122 0 1000;
+#X text 476 122 ramp down.;
+#X msg 441 166 stop;
+#X text 416 65 [line] will also accept the "stop" message which effectively
+halt the current ramp.;
+#N canvas 51 105 536 509 continuous_ramps 0;
+#X text 29 44 [line] does not schedule its incoming messages. What
+this means is that if you send [line] a new target value mid-way through
+a ramp \, a new ramp is immediatly created to the new target value
+starting from the "current" value.;
+#X text 27 105 In other words \, if [line] receives a message specifying
+some new target and time before reaching the previous target \, it
+takes off from its current value.;
+#X obj 34 254 hsl 128 15 0 127 0 0 empty empty empty -2 -6 0 8 -262144
+-1 -1 0 1;
+#X msg 64 212 stop;
+#X msg 57 192 42;
+#X obj 31 233 line;
+#X msg 31 151 127 5000;
+#X msg 49 172 0 5000;
+#X text 18 23 CONTINUOUS RAMPS;
+#X text 24 278 Due to this unique behavior \, a common construct found
+in PD patches includes the [pack] object as follows:;
+#X obj 38 399 line;
+#X floatatom 38 420 10 0 0;
+#X floatatom 38 313 5 0 0;
+#X obj 38 379 pack f 500;
+#X msg 49 332 50;
+#X msg 57 353 2000;
+#X connect 3 0 5 0;
+#X connect 4 0 5 0;
+#X connect 5 0 2 0;
+#X connect 6 0 5 0;
+#X connect 7 0 5 0;
+#X connect 10 0 11 0;
+#X connect 12 0 13 0;
+#X connect 13 0 10 0;
+#X connect 14 0 13 0;
+#X connect 15 0 13 0;
+#X restore 404 262 pd continuous_ramps;
+#X text 168 180 While this does NOT work unless;
+#X text 166 190 you click "500" first.;
+#X msg 201 230 500;
+#X msg 437 145 42;
+#X text 463 146 jumps to this value immediately.;
+#X text 478 166 stops the current ramp.;
+#X text 403 288 More information about [line] can be found in the Pure
+Documentation folder doc/3.audio.examples.;
+#X text 412 450 This document was updated for PD version 0.35 test
+28 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X text 404 326 RELATED OBJECTS;
+#X obj 405 346 line~;
+#N canvas 0 0 452 302 related_objects_from_other_libraries 0;
+#X obj 23 21 tripleline;
+#X obj 105 20 t3_line~;
+#X obj 171 20 fade~;
+#X obj 219 21 step;
+#X text 17 54 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 16 103 The best places to find information about PD's libraries
+is:;
+#X text 13 125 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 14 141 or;
+#X text 15 155 iem.kug.ac.at/pdb/;
+#X restore 406 370 pd related_objects_from_other_libraries;
+#N canvas 0 0 454 528 grain_rate_and_creation_arguments 0;
+#X text 20 18 GRAIN RATE;
+#X text 32 38 The "grain rate" of [line] is the rate at which it will
+output its values. The faster the grain is \, the smoother the ramp
+will appear. While slower grain rates will produce a more disjunct
+ramp. Of course this setting will alter the amount of CPU that the
+[line] object will require. Higher rates require more computation.
+;
+#X text 33 144 This means simply that [line] will output a new value
+between its current value and your new value once every 20 milliseconds.
+;
+#X text 33 125 The default grain rate is 20 milliseconds.;
+#X text 30 192 [line]'s optional creation arguments can be used to
+reset the grain rate. However \, the grain rate cannot be reset dynamically.
+;
+#X text 32 247 First creation argument is the initial value: the starting
+point of the first ramp.;
+#X text 31 286 The second creation argument sets the grain rate. Observe
+the following two examples to see how the grain rate effects the output.
+;
+#X obj 44 417 line 0 5;
+#X obj 47 450 hsl 128 15 0 127 0 0 empty empty empty -2 -6 0 8 -262144
+-1 -1 0 1;
+#X msg 147 346 127;
+#X msg 179 354 0;
+#X obj 146 382 pack f 5000;
+#X obj 214 450 hsl 128 15 0 127 0 0 empty empty empty -2 -6 0 8 -262144
+-1 -1 0 1;
+#X obj 211 417 line 0 500;
+#X connect 7 0 8 0;
+#X connect 9 0 11 0;
+#X connect 10 0 11 0;
+#X connect 11 0 7 0;
+#X connect 11 0 13 0;
+#X connect 13 0 12 0;
+#X restore 404 235 pd grain_rate_and_creation_arguments;
+#X connect 4 0 9 0;
+#X connect 5 0 4 1;
+#X connect 6 0 4 0;
+#X connect 7 0 8 0;
+#X connect 8 0 6 0;
+#X connect 8 1 5 0;
+#X connect 10 0 13 0;
+#X connect 11 0 10 0;
+#X connect 12 0 11 0;
+#X connect 17 0 18 0;
+#X connect 19 0 21 0;
+#X connect 20 0 19 0;
+#X connect 23 0 19 0;
+#X connect 25 0 19 0;
+#X connect 30 0 10 1;
+#X connect 31 0 19 0;
diff --git a/doc/pddp/help-loadbang.pd b/doc/pddp/help-loadbang.pd
new file mode 100644
index 00000000..e6509ed1
--- /dev/null
+++ b/doc/pddp/help-loadbang.pd
@@ -0,0 +1,97 @@
+#N canvas 2 1 603 598 12;
+#X text 108 18 - SEND "bang" AUTOMATICALLY WHEN PATCH LOADS.;
+#X obj 126 218 loadbang;
+#X obj 126 385 loadbang;
+#X obj 126 410 metro 1000;
+#X obj 126 434 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 126 266 f 1;
+#X obj 169 266 f 4;
+#X obj 126 291 +;
+#X floatatom 126 315 5 0 0 0 - - -;
+#X obj 126 241 t b b;
+#X obj 104 540 pddp;
+#X obj 8 8 cnv 15 90 553 empty empty empty 20 12 0 14 -233017 -66577
+0;
+#X obj 21 18 loadbang;
+#X text 104 464 PD Documentation Chapter 3.6 - doc/1.manual/x3.htm
+;
+#X text 104 53 The inlet is inactive and serves no purpose.;
+#X text 104 81 This object does not accept arguments of any type.;
+#X text 104 112 A "bang" message is sent automatically when the containing
+patch is loaded.;
+#X text 104 161 In this example \, [loadbang] was used to process a
+simple mathematic equation when this patch was loaded. In this case:
+1 + 4 = 5;
+#X text 104 344 In this example \, [loadbang] was used simply to start
+a process automatically when this patch was loaded.;
+#X text 152 541 - Dave Sabine \, November 12 \, 2002;
+#N canvas 85 2 579 656 More_Info 0;
+#X obj 25 152 print foo;
+#X obj 25 104 loadbang;
+#X text 14 188 As well \, the following [float]s were set with a group
+of numbers. Click the [bng] below to verify that the numbers were stored
+in the [float] objects.;
+#X obj 26 355 f;
+#X floatatom 26 380 2 0 0 0 - - -;
+#X obj 65 355 f;
+#X floatatom 65 380 2 0 0 0 - - -;
+#X obj 105 355 f;
+#X floatatom 104 380 2 0 0 0 - - -;
+#X obj 26 263 bng 15 250 50 0 empty empty Click_here_to_see_the_numbers_stored_in_the_float_objects.
+0 -6 0 8 -262144 -1 -1;
+#X obj 195 316 random 10;
+#X obj 104 317 random 10;
+#X text 14 415 IMPORTANT;
+#X text 44 600 c:/pd/pd.exe -noloadbang;
+#X text 14 10 The loadbang object will send a "bang" message when a
+canvas/patch loads and is used most often to 'initialize' or set default
+values in a patch. For example \, when you opened this patch \, the
+message below was immediately printed in the terminal window.;
+#X obj 104 283 loadbang;
+#X obj 288 317 random 10;
+#X text 14 438 Loadbangs are a useful tool to set initial values in
+a patch - however \, there are times when it might be necessary to
+debug a patch and "turn off" all the loadbang objects. This can be
+accomplished by opening PD with the -noloadbang flag.;
+#X text 14 523 For example \, to suppress all loadbangs \, your command
+line might look something like this: (more info about PD's command
+line can be found in Chapter 3.6 of the HTML documentation.;
+#X msg 25 127 you have opened the [loadbang] help document;
+#X connect 1 0 19 0;
+#X connect 3 0 4 0;
+#X connect 5 0 6 0;
+#X connect 7 0 8 0;
+#X connect 9 0 3 0;
+#X connect 9 0 5 0;
+#X connect 9 0 7 0;
+#X connect 10 0 5 1;
+#X connect 11 0 3 1;
+#X connect 15 0 11 0;
+#X connect 15 0 10 0;
+#X connect 15 0 16 0;
+#X connect 16 0 7 1;
+#X connect 19 0 0 0;
+#X restore 104 514 pd More_Info;
+#N canvas 85 2 389 238 Related_Objects 0;
+#X obj 44 49 bang;
+#X obj 102 51 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 143 48 trigger;
+#X text 25 8 Native PD Objects;
+#X text 25 92 Externals and other object libraries;
+#X text 36 126 [init];
+#X restore 104 488 pd Related_Objects;
+#X text 38 53 INLETS:;
+#X text 14 82 ARGUMENTS:;
+#X text 29 112 OUTLETS:;
+#X text 20 161 EXAMPLES:;
+#X text 21 463 SEE ALSO:;
+#X connect 1 0 9 0;
+#X connect 2 0 3 0;
+#X connect 3 0 4 0;
+#X connect 5 0 7 0;
+#X connect 6 0 7 1;
+#X connect 7 0 8 0;
+#X connect 9 0 5 0;
+#X connect 9 1 6 0;
diff --git a/doc/pddp/help-makefilename.pd b/doc/pddp/help-makefilename.pd
new file mode 100644
index 00000000..dc73e3f4
--- /dev/null
+++ b/doc/pddp/help-makefilename.pd
@@ -0,0 +1,244 @@
+#N canvas 2 0 609 604 12;
+#X obj 104 539 pddp;
+#X obj 8 8 cnv 15 90 553 empty empty empty 20 12 0 14 -233017 -66577
+0;
+#X text 104 463 PD Documentation Chapter 3.6 - doc/1.manual/x3.htm
+;
+#N canvas 85 2 593 608 More_Info 1;
+#X text 17 24 COMMON USES;
+#X text 15 417 INNOVATIVE USES;
+#X text 47 47 I believe that this object was developed first to allow
+PD to generate sequential file names - perhaps to be used in conjunction
+with [soundfiler] or [openpanel]. For example \, an audio loop recorder
+might generate a continuous series of sound files to be saved on a
+hard drive...like below:;
+#X obj 54 136 bng 15 250 50 0 empty empty Bang_me 18 7 0 8 -262144
+-1 -1;
+#X obj 54 160 f;
+#X symbolatom 54 215 0 0 0 0 - - -;
+#X text 53 238 This file name could be used when saving the audio data
+to disk.;
+#X obj 87 161 + 1;
+#X obj 54 187 makefilename file-%d.aif;
+#X text 20 280 LIMITATIONS;
+#N canvas 175 3 583 599 spaces_and_multiple_variables 0;
+#X text 25 19 Instead of using spaces \, an underscore will often produce
+a tolerable compromise.;
+#X obj 210 40 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 210 64 f;
+#X symbolatom 210 119 0 0 0 0 - - -;
+#X obj 243 64 + 1;
+#X obj 210 91 makefilename I_am_%d_years_old.;
+#X text 28 143 With careful planning \, multiple variables can be incorporated
+using a stack of [makefilename]s. In the example below \, let's assume
+that this tool is used to generate file names for an audio loop recorder
+which operates 24 hours per day \, every day.;
+#X obj 31 235 loadbang;
+#X obj 31 280 metro 200;
+#X obj 31 261 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 1 1
+;
+#X obj 64 305 + 1;
+#X obj 209 349 route 0 1 2 3 4 5 6;
+#X obj 31 354 mod 24;
+#X floatatom 31 379 5 0 0 0 - - -;
+#X floatatom 31 329 0 0 0 0 - - -;
+#X obj 31 305 f;
+#X obj 53 405 sel 0;
+#X obj 218 269 f;
+#X obj 250 269 + 1;
+#X obj 218 294 mod 7;
+#X obj 218 322 pack f f;
+#X obj 230 498 makefilename Monday_%d.wav;
+#X symbolatom 65 548 0 0 0 0 - - -;
+#X obj 334 374 makefilename Saturday_%d.wav;
+#X obj 314 399 makefilename Friday_%d.wav;
+#X obj 290 326 t b f;
+#X obj 293 424 makefilename Thursday_%d.wav;
+#X obj 272 449 makefilename Wednesday_%d.wav;
+#X obj 251 474 makefilename Tuesday_%d.wav;
+#X obj 209 522 makefilename Sunday_%d.wav;
+#X text 81 377 hour of day;
+#X text 79 330 total hours;
+#X text 199 549 Crude...but effective.;
+#X obj 31 455 s dayHour;
+#X obj 53 430 s weekDay;
+#X obj 218 236 r weekDay;
+#X obj 290 300 r dayHour;
+#X text 284 271 loop through weekdays;
+#X connect 1 0 2 0;
+#X connect 2 0 4 0;
+#X connect 2 0 5 0;
+#X connect 4 0 2 1;
+#X connect 5 0 3 0;
+#X connect 7 0 9 0;
+#X connect 8 0 15 0;
+#X connect 9 0 8 0;
+#X connect 10 0 15 1;
+#X connect 11 0 29 0;
+#X connect 11 1 21 0;
+#X connect 11 2 28 0;
+#X connect 11 3 27 0;
+#X connect 11 4 26 0;
+#X connect 11 5 24 0;
+#X connect 11 6 23 0;
+#X connect 12 0 13 0;
+#X connect 13 0 16 0;
+#X connect 13 0 33 0;
+#X connect 14 0 12 0;
+#X connect 15 0 10 0;
+#X connect 15 0 14 0;
+#X connect 16 0 34 0;
+#X connect 17 0 18 0;
+#X connect 17 0 19 0;
+#X connect 18 0 17 1;
+#X connect 19 0 20 0;
+#X connect 20 0 11 0;
+#X connect 21 0 22 0;
+#X connect 23 0 22 0;
+#X connect 24 0 22 0;
+#X connect 25 0 20 0;
+#X connect 25 1 20 1;
+#X connect 26 0 22 0;
+#X connect 27 0 22 0;
+#X connect 28 0 22 0;
+#X connect 29 0 22 0;
+#X connect 35 0 17 0;
+#X connect 36 0 25 0;
+#X restore 47 445 pd spaces_and_multiple_variables;
+#N canvas 175 4 503 605 help_with_interfaces 1;
+#X text 17 16 Building user interfaces in PD is a difficult balance
+between usability and performance. PD is not winning any awards for
+usability - let's face it: it's powerful \, it's cool \, and that's
+the way we like it. You're not here because you want a colourful \,
+bevelled interface...you want the raw power that object oriented languages
+provide mixed with a few of the conveniences that a graphic environment
+affords.;
+#X obj 17 269 cnv 15 450 300 empty empty empty 20 12 0 14 -261681 -66577
+0;
+#X obj 45 379 tgl 15 0 s_dsp empty DSP 18 7 128 8 -262144 -1 -1 0 1
+;
+#X obj 45 424 vsl 15 128 0 127 0 0 v_slider empty Volume 18 7 128 8
+-262144 -1 -1 0 1;
+#X obj 45 401 bng 15 250 50 0 b_panel empty Open_File 18 7 128 8 -262144
+-1 -1;
+#X obj 40 280 cnv 15 400 20 empty d_canvas DSP 20 12 64 8 -233017 -66577
+0;
+#X obj 40 302 cnv 15 400 20 empty f_canvas FILE_OPEN 20 12 64 8 -233017
+-66577 0;
+#X obj 40 324 cnv 15 400 20 empty v_canvas VOLUME 20 12 64 8 -233017
+-66577 0;
+#X text 187 361 The grey canvases above could;
+#X text 189 383 be used like "status bars" to;
+#X text 189 404 write relevant information to;
+#X text 186 460 [makefilename] helps to format;
+#X text 188 484 the information in a meaningful;
+#X text 189 505 way.;
+#X text 187 426 the screen.;
+#N canvas 217 9 470 320 look_inside 0;
+#X obj 199 14 r b_panel;
+#X obj 235 166 r v_slider;
+#X obj 36 236 s d_canvas;
+#X obj 199 114 s f_canvas;
+#X obj 235 263 s v_canvas;
+#X obj 36 80 sel 0;
+#X obj 71 152 symbol ON;
+#X obj 36 128 symbol OFF;
+#X obj 71 103 bang;
+#X msg 36 210 label \$1;
+#X obj 36 184 makefilename DSP:%s;
+#X obj 36 13 r s_dsp;
+#X msg 45 38 \; pd dsp \$1;
+#X obj 199 40 openpanel;
+#X obj 199 65 makefilename FILE_OPEN:%s;
+#X msg 199 90 label \$1;
+#X msg 235 240 label \$1;
+#X obj 235 192 expr ($f1/128)*100;
+#X obj 235 217 makefilename VOLUME:%d/100;
+#X connect 0 0 13 0;
+#X connect 1 0 17 0;
+#X connect 5 0 7 0;
+#X connect 5 1 8 0;
+#X connect 6 0 10 0;
+#X connect 7 0 10 0;
+#X connect 8 0 6 0;
+#X connect 9 0 2 0;
+#X connect 10 0 9 0;
+#X connect 11 0 5 0;
+#X connect 11 0 12 0;
+#X connect 13 0 14 0;
+#X connect 14 0 15 0;
+#X connect 15 0 3 0;
+#X connect 16 0 4 0;
+#X connect 17 0 18 0;
+#X connect 18 0 16 0;
+#X restore 40 350 pd look_inside;
+#X text 18 156 However \, there are times when sacrifices must be made
+in the area of performance to provide users with on-screen reporting
+\, record keeping \, and sometimes even a few 'pleasantries'. Consider
+the following examples - but always weight the pros and cons when incorporating
+these types of interfaces. Performance vs. Usability.;
+#X restore 47 477 pd help_with_interfaces;
+#X text 45 304 This object does not provide advanced formatting and
+parsing abilities. For example \, you cannot use spaces or odd characters
+in the argument - also the argument can only include ONE variable.
+Although \, these limitations can be easily overcome with a little
+ingenuity and compromise -- see below.;
+#X connect 3 0 4 0;
+#X connect 4 0 7 0;
+#X connect 4 0 8 0;
+#X connect 7 0 4 1;
+#X connect 8 0 5 0;
+#X restore 104 513 pd More_Info;
+#N canvas 85 2 393 242 Related_Objects 0;
+#X text 25 8 Native PD Objects;
+#X text 25 92 Externals and other object libraries;
+#X text 35 125 [strcat];
+#X obj 42 46 symbol;
+#X obj 112 46 int;
+#X obj 156 46 openpanel;
+#X text 34 151 [makesymbol];
+#X restore 104 487 pd Related_Objects;
+#X text 38 53 INLETS:;
+#X text 15 197 ARGUMENTS:;
+#X text 29 316 OUTLETS:;
+#X text 22 342 EXAMPLES:;
+#X text 21 462 SEE ALSO:;
+#X obj 5 18 makefilename;
+#X text 115 18 - FORMAT A STRING WITH A VARIABLE FIELD.;
+#X text 104 316 Symbol - The output is formatted like "symbol YOURSTRING".
+;
+#X floatatom 114 346 0 0 0 0 - - -;
+#X obj 114 400 print;
+#X obj 114 373 makefilename soundfile%d.aif;
+#X text 170 400 numbered filenames;
+#X obj 353 431 print;
+#X text 406 433 text examples;
+#X obj 353 380 symbol;
+#X msg 353 343 dave;
+#X msg 412 341 drums;
+#X msg 479 344 PD;
+#X msg 526 355 cool;
+#X obj 353 404 makefilename %s_PD.aif;
+#X text 107 198 This object generates symbols according to a format
+string (the argument) \, for use as a series of filenames \, table
+names \, or whatnot. You can plug in a variable number or symbol by
+putting "%d" or "%s" in the string. If you put "%s" in the string \,
+be sure to send it a symbol and vice versa... there' no checking. Each
+[makefilename] object can have only one variable.;
+#X text 152 540 - Dave Sabine \, April 25 \, 2003;
+#X text 108 53 Integer - If a number is sent to the inlet \, the argument
+should be written with a "%d" which represents the location of the
+incoming variable number in the outgoing symbol. Floats will be converted
+to integers.;
+#X text 107 126 Symbol - If a symbol is sent to the inlet \, the argument
+should be written with a "%s" which represent the location of the incoming
+variable symbol in the outgoing symbol. Lists will be truncated.;
+#X connect 13 0 15 0;
+#X connect 15 0 14 0;
+#X connect 19 0 24 0;
+#X connect 20 0 19 0;
+#X connect 21 0 19 0;
+#X connect 22 0 19 0;
+#X connect 23 0 19 0;
+#X connect 24 0 17 0;
diff --git a/doc/pddp/help-math.pd b/doc/pddp/help-math.pd
new file mode 100644
index 00000000..48edb0b4
--- /dev/null
+++ b/doc/pddp/help-math.pd
@@ -0,0 +1,162 @@
+#N canvas 3 1 906 656 10;
+#X floatatom 517 224 0 0 0;
+#X floatatom 440 309 0 0 0;
+#X floatatom 440 223 0 0 0;
+#X floatatom 559 464 0 0 0;
+#X floatatom 616 464 0 0 0;
+#X floatatom 710 464 0 0 0;
+#X floatatom 249 242 0 0 0;
+#X floatatom 249 203 0 0 0;
+#X floatatom 478 464 0 0 0;
+#X floatatom 478 414 0 0 0;
+#X floatatom 741 133 0 0 0;
+#X floatatom 648 134 0 0 0;
+#X obj 555 99 sin;
+#X floatatom 432 54 0 0 0;
+#X floatatom 555 133 0 0 0;
+#X obj 432 94 * 6.28319;
+#X obj 432 74 / 360;
+#X obj 648 100 cos;
+#X obj 741 99 tan;
+#X obj 478 444 sqrt;
+#X obj 249 222 atan;
+#X obj 710 445 log;
+#X obj 616 444 exp;
+#X obj 559 444 abs;
+#X obj 440 261 float;
+#X obj 517 261 t b f;
+#X obj 440 289 atan2;
+#X text 32 14 Higher math in Pd --;
+#X obj 162 14 sin;
+#X obj 188 14 cos;
+#X obj 214 14 tan;
+#X obj 241 14 atan;
+#X obj 274 14 atan2;
+#X obj 314 14 exp;
+#X obj 342 14 log;
+#X obj 369 14 abs;
+#X obj 397 14 sqrt;
+#X obj 432 14 pow;
+#X text 495 94 2 x Pi;
+#X text 21 46 Trigonometry functions take input in Radians. To find
+a radian \, simply divide a number by 360 (to make it a fraction of
+a circle) and multiply it by 2(Pi) where Pi is equal to approximately
+3.14159265.;
+#X floatatom 432 114 0 0 0;
+#X text 495 114 Radian;
+#X obj 432 134 s radians;
+#X obj 555 73 r radians;
+#X text 20 139 [tan] will produce a number which represents the tangent
+of an angle.;
+#X text 20 105 [sin] and [cos] will return numbers between -1 and 1:
+the sine and cosine of a number repectively.;
+#X text 20 186 The [atan] object produces the arctangent of a number
+as a numeric value between -Pi/2 and Pi/2.;
+#X text 71 284 The [atan2] object produces the arctangent of the quotient
+of its two arguments. The number produced is a value between Pi and
+-Pi and represents the counterclockwise angle in radians (not degrees)
+between the positive X axis and the point (x \, y). Note that the X
+coordinate is passed to the right inlet and the Y coordinate is passed
+to the left inlet.;
+#X text 425 223 Y;
+#X text 506 223 X;
+#X floatatom 759 329 0 0 0;
+#X obj 759 289 /;
+#X obj 759 309 atan;
+#X obj 759 209 r X_Y;
+#X obj 517 309 s X_Y;
+#X obj 517 288 pack f f;
+#X obj 759 228 unpack f f;
+#X obj 759 247 swap;
+#X text 585 223 This example on the;
+#X text 584 239 right is an alternative;
+#X text 584 257 of finding the arctangent;
+#X text 584 274 of two coordinates \, but;
+#X text 585 291 it runs slightly slower;
+#X text 585 307 than [atan2].;
+#X text 782 290 Y;
+#X text 746 290 X;
+#X floatatom 795 268 0 0 0;
+#X floatatom 759 268 0 0 0;
+#X obj 6 169 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 846 184 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 8 368 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 848 383 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X floatatom 782 463 0 0 0;
+#X text 19 392 [sqrt] will output the square root of a number. Negative
+numbers are ignored.;
+#X text 416 391 [abs] will output the absolute value of a number.;
+#X text 611 488 i;
+#X text 418 491 [exp] will output the value of E where E is Euler's
+constant and i is the value of the inlet.;
+#X text 18 427 [log] will output the natural logarithm (base E) of
+a number. The value of zero will produce "-1000" which represents "negative
+infinity".;
+#X obj 782 443 pow 2;
+#X floatatom 807 423 0 0 0;
+#X text 17 474 [pow] is used to exponentiate a number. 2 to the power
+of 2 = 4 The right inlet or creation argument is the exponent while
+the left inlet is the base.;
+#X obj 10 515 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 850 530 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 16 537 RELATED OBJECTS;
+#X obj 18 557 cos~;
+#X obj 50 557 osc~;
+#X obj 18 577 +;
+#X text 40 577 Other Math Objects;
+#X obj 18 597 <;
+#X text 41 597 Math/Binary operators;
+#X obj 84 557 expr;
+#X text 420 563 This document was updated for PD version 0.35 test
+28 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X connect 0 0 25 0;
+#X connect 2 0 24 0;
+#X connect 7 0 20 0;
+#X connect 9 0 19 0;
+#X connect 9 0 23 0;
+#X connect 9 0 22 0;
+#X connect 9 0 21 0;
+#X connect 9 0 78 0;
+#X connect 12 0 14 0;
+#X connect 13 0 16 0;
+#X connect 15 0 40 0;
+#X connect 16 0 15 0;
+#X connect 17 0 11 0;
+#X connect 18 0 10 0;
+#X connect 19 0 8 0;
+#X connect 20 0 6 0;
+#X connect 21 0 5 0;
+#X connect 22 0 4 0;
+#X connect 23 0 3 0;
+#X connect 24 0 26 0;
+#X connect 24 0 55 0;
+#X connect 25 0 24 0;
+#X connect 25 1 26 1;
+#X connect 25 1 55 1;
+#X connect 26 0 1 0;
+#X connect 40 0 42 0;
+#X connect 43 0 12 0;
+#X connect 43 0 17 0;
+#X connect 43 0 18 0;
+#X connect 51 0 52 0;
+#X connect 52 0 50 0;
+#X connect 53 0 56 0;
+#X connect 55 0 54 0;
+#X connect 56 0 57 0;
+#X connect 56 1 57 1;
+#X connect 57 0 67 0;
+#X connect 57 1 66 0;
+#X connect 66 0 51 1;
+#X connect 67 0 51 0;
+#X connect 68 0 69 0;
+#X connect 70 0 71 0;
+#X connect 78 0 72 0;
+#X connect 79 0 78 1;
+#X connect 81 0 82 0;
diff --git a/doc/pddp/help-metro.pd b/doc/pddp/help-metro.pd
new file mode 100644
index 00000000..bb734751
--- /dev/null
+++ b/doc/pddp/help-metro.pd
@@ -0,0 +1,50 @@
+#N canvas 39 7 462 531 10;
+#X obj 22 294 metro 500;
+#X obj 37 13 metro;
+#X floatatom 71 271 4 0 0;
+#X msg 22 176 1;
+#X text 67 185 nonzero number or "bang" to start;
+#X msg 39 223 0;
+#X msg 28 199 bang;
+#X msg 39 245 stop;
+#X text 111 270 right inlet sets the rate in msec per tick.;
+#X text 76 13 -- send "bang" periodically ala metronome.;
+#X text 19 89 [metro]'s left inlet accepts four different messages:
+;
+#X text 22 105 - "bang": starts the metro/turns it on.;
+#X text 22 118 - "stop": stops the metro/turns it off.;
+#X obj 22 317 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 21 45 The metro object sends a series of bangs at a constant
+rate which is defined in milliseconds at the right inlet or in the
+creation argument.;
+#X text 22 131 - Non-Zero number: starts the metro/turns it on.;
+#X text 22 143 - 0 (zero): stops the metro/turns it off.;
+#X text 78 233 zero or "stop" to stop;
+#X text 90 293 optional creation argument initializes rate in msec
+;
+#X text 19 348 RELATED OBJECTS;
+#N canvas 0 0 454 304 related_objects_from_other_libraries 0;
+#X obj 35 27 metroplus;
+#X obj 102 27 t3_metro;
+#X obj 164 27 pulse;
+#X text 18 56 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 17 105 The best places to find information about PD's libraries
+is:;
+#X text 14 127 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 15 143 or;
+#X text 16 157 iem.kug.ac.at/pdb/;
+#X obj 210 25 exciter;
+#X restore 23 372 pd related_objects_from_other_libraries;
+#X text 18 402 This document was updated for PD version 0.35 test 28
+by Dave Sabine as part of a project called pddp proposed to build comprehensive
+documentation for PD.;
+#X connect 0 0 13 0;
+#X connect 2 0 0 1;
+#X connect 3 0 0 0;
+#X connect 5 0 0 0;
+#X connect 6 0 0 0;
+#X connect 7 0 0 0;
diff --git a/doc/pddp/help-midi.pd b/doc/pddp/help-midi.pd
new file mode 100644
index 00000000..a2d88092
--- /dev/null
+++ b/doc/pddp/help-midi.pd
@@ -0,0 +1,121 @@
+#N canvas 14 15 880 473 10;
+#X text 718 77 off;
+#X floatatom 683 127 0 0 0 0 - - -;
+#X obj 683 232 noteout;
+#X obj 683 206 makenote 64 250;
+#X obj 683 153 metro 500;
+#X msg 683 100 1;
+#X msg 715 100 0;
+#X text 683 77 on;
+#X msg 683 180 60;
+#X text 31 14 MIDI I/O objects;
+#X floatatom 463 129 0 0 0 0 - - -;
+#X floatatom 426 129 0 0 0 0 - - -;
+#X floatatom 536 131 0 0 0 0 - - -;
+#X floatatom 497 129 0 0 0 0 - - -;
+#X floatatom 574 132 0 0 0 0 - - -;
+#X obj 426 102 touchin;
+#X obj 497 103 polytouchin;
+#X text 425 79 channel and poly aftertouch;
+#X floatatom 427 156 0 0 0 0 - - -;
+#X floatatom 498 156 0 0 0 0 - - -;
+#X obj 427 182 touchout;
+#X obj 498 182 polytouchout;
+#X floatatom 537 157 0 0 0 0 - - -;
+#X floatatom 575 157 0 0 0 0 - - -;
+#X obj 428 283 midiin;
+#X floatatom 428 314 0 0 0 0 - - -;
+#X floatatom 459 314 0 0 0 0 - - -;
+#X floatatom 501 312 0 0 0 0 - - -;
+#X floatatom 537 312 0 0 0 0 - - -;
+#X text 424 220 These two are always omni and;
+#X text 423 236 output the port number instead;
+#X obj 503 281 sysexin;
+#X obj 430 404 midiout;
+#X text 428 338 use this to output raw MIDI;
+#X text 423 358 (the second inlet is the port;
+#X text 676 424 updated for Pd release 0.35;
+#X obj 393 23 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 393 426 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 20 46 This document is currently under revision by the PDDP
+(Pure Data Documentation Project). Please stay posted for available
+updates.;
+#X text 20 101 DOCUMENTED MIDI OBJECTS;
+#X text 430 44 MIDI OBJECTS NOT YET DOCUMENTED;
+#X text 424 254 of the channel (Linux only):;
+#X text 426 376 number.) (Linux Only):;
+#X obj 647 23 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 647 426 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 676 44 THE [MAKENOTE] APPARATUS;
+#N canvas 0 0 458 308 window_controls 0;
+#X obj 149 59 inlet;
+#X obj 192 119 inlet;
+#X msg 149 233 \; pd open \$1 \$2;
+#X obj 149 79 pack s;
+#X obj 149 99 makefilename %s.pd;
+#X obj 149 213 pack s s;
+#X obj 192 193 pack s;
+#X obj 251 150 loadbang;
+#X msg 192 173 C:/pd/doc/5.reference;
+#X obj 198 139 delay 20;
+#X connect 0 0 3 0;
+#X connect 1 0 8 0;
+#X connect 1 0 9 0;
+#X connect 3 0 4 0;
+#X connect 4 0 5 0;
+#X connect 5 0 2 0;
+#X connect 6 0 5 1;
+#X connect 7 0 8 0;
+#X connect 8 0 6 0;
+#X connect 9 0 8 0;
+#X restore 40 433 pd window_controls;
+#X text 144 346 If you have installed PD into;
+#X text 143 361 a unique location \, type the path;
+#X text 144 377 here to your 5.reference folder;
+#X text 141 394 and then save this patch.;
+#X text 244 119 Click the object's name;
+#X text 243 135 to view its help document.;
+#X msg 143 413 set C:/pd/doc/5.reference;
+#X msg 161 120 help-bendin;
+#X msg 161 144 help-bendout;
+#X msg 161 169 help-ctlin;
+#X msg 162 194 help-ctlout;
+#X msg 162 219 help-notein;
+#X msg 162 244 help-noteout;
+#X msg 162 269 help-pgmin;
+#X msg 163 295 help-pgmout;
+#X connect 1 0 4 0;
+#X connect 3 0 2 0;
+#X connect 3 1 2 1;
+#X connect 4 0 8 0;
+#X connect 5 0 1 0;
+#X connect 6 0 1 0;
+#X connect 8 0 3 0;
+#X connect 15 0 11 0;
+#X connect 15 1 10 0;
+#X connect 16 0 13 0;
+#X connect 16 1 12 0;
+#X connect 16 2 14 0;
+#X connect 18 0 20 0;
+#X connect 19 0 21 0;
+#X connect 22 0 21 1;
+#X connect 23 0 21 2;
+#X connect 24 0 25 0;
+#X connect 24 1 26 0;
+#X connect 31 0 27 0;
+#X connect 31 1 28 0;
+#X connect 36 0 37 0;
+#X connect 43 0 44 0;
+#X connect 53 0 46 1;
+#X connect 54 0 46 0;
+#X connect 55 0 46 0;
+#X connect 56 0 46 0;
+#X connect 57 0 46 0;
+#X connect 58 0 46 0;
+#X connect 59 0 46 0;
+#X connect 60 0 46 0;
+#X connect 61 0 46 0;
diff --git a/doc/pddp/help-moses.pd b/doc/pddp/help-moses.pd
new file mode 100644
index 00000000..e553fac6
--- /dev/null
+++ b/doc/pddp/help-moses.pd
@@ -0,0 +1,57 @@
+#N canvas 10 0 452 619 10;
+#X obj 29 141 moses 10;
+#X floatatom 29 121 4 0 0;
+#X floatatom 83 120 4 0 0;
+#X floatatom 29 166 4 0 0;
+#X floatatom 83 166 4 0 0;
+#X obj 30 15 moses;
+#X text 71 15 - part a stream of numbers;
+#X text 19 44 Moses takes numbers and outputs them at left if they're
+less than a control value \, and at right if they're greater or equal
+to it. The creation argument initializes the control value (10 in this
+example) and the right inlet changes it.;
+#X obj 27 301 moses 0;
+#X floatatom 27 325 5 0 0;
+#X floatatom 70 325 5 0 0;
+#X floatatom 27 279 5 0 0;
+#X text 17 189 One way to think of [moses] is as a filter. For the
+following example \, imagine that [moses] works as a low pass and high
+pass filter simoultaneously -- for non-audio signals. Below you will
+see that negative numbers will pass through the left outlet while positive
+numbers will pass through the right outlet.;
+#X text 17 348 Before the days of [moses] \, the same effect would
+require a completely different structure \, as in the example below:
+;
+#X floatatom 25 384 5 0 0;
+#X floatatom 25 433 5 0 0;
+#X obj 25 408 min -1;
+#X obj 74 409 max 0;
+#X floatatom 74 433 5 0 0;
+#X text 73 383 An ol'fashioned way of achieving a similar result.;
+#X text 16 474 RELATED OBJECTS;
+#N canvas 0 0 454 304 related_objects_from_other_libraries 0;
+#X obj 34 29 split;
+#X text 18 86 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 17 135 The best places to find information about PD's libraries
+is:;
+#X text 14 157 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 15 173 or;
+#X text 16 187 iem.kug.ac.at/pdb/;
+#X restore 22 494 pd related_objects_from_other_libraries;
+#X text 18 530 This document was updated for PD version 0.35 test 26
+by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X connect 0 0 3 0;
+#X connect 0 1 4 0;
+#X connect 1 0 0 0;
+#X connect 2 0 0 1;
+#X connect 8 0 9 0;
+#X connect 8 1 10 0;
+#X connect 11 0 8 0;
+#X connect 14 0 16 0;
+#X connect 14 0 17 0;
+#X connect 16 0 15 0;
+#X connect 17 0 18 0;
diff --git a/doc/pddp/help-notein.pd b/doc/pddp/help-notein.pd
new file mode 100644
index 00000000..e727db7d
--- /dev/null
+++ b/doc/pddp/help-notein.pd
@@ -0,0 +1,85 @@
+#N canvas 255 1 494 655 10;
+#X obj 32 12 notein;
+#X text 133 97 inlets : none;
+#X text 134 122 outlets:;
+#X text 134 142 left: MIDI note number;
+#X text 135 163 middle: velocity;
+#X text 133 187 right: MIDI channel number;
+#X obj 34 96 notein;
+#X floatatom 35 145 5 0 0;
+#X floatatom 52 166 5 0 0;
+#X floatatom 72 188 5 0 0;
+#X floatatom 42 383 5 0 0;
+#X floatatom 91 383 5 0 0;
+#X obj 42 350 notein 1;
+#X text 105 349 notein listening only to channel 1;
+#X text 7 396 note number;
+#X text 101 396 velocity;
+#N canvas 240 135 478 474 other_midi_objects 0;
+#X obj 7 29 ctlin;
+#X obj 49 29 pgmin;
+#X obj 92 28 bendin;
+#X obj 143 27 touchin;
+#X obj 204 27 polytouchin;
+#X obj 289 27 midiin;
+#X obj 340 26 sysexin;
+#X obj 6 85 noteout;
+#X obj 63 84 ctlout;
+#X obj 160 84 bendout;
+#X obj 217 83 touchout;
+#X obj 281 82 polytouchout;
+#X obj 370 82 midiout;
+#X obj 113 84 pgmout;
+#X obj 11 153 makenote;
+#X text 10 194 MIDI notes deconstruction:;
+#X text 8 128 MIDI note construction:;
+#X text 8 58 MIDI output:;
+#X text 8 2 MIDI input:;
+#X obj 15 226 stripnote;
+#X text 11 266 Additional useful objects for MIDI processing (Maxlib
+by Olaf Matthes);
+#X obj 148 297 chord;
+#X obj 109 296 borax;
+#X obj 54 296 score o;
+#X obj 13 296 pitch;
+#X text 15 336 Also \, from cyclone (alpha) by Krzysztof Czaja:;
+#X obj 16 359 midiformat;
+#X obj 172 359 midiflush;
+#X obj 98 359 midiparse;
+#X text 15 386 and xeq \, from the same developer;
+#X obj 16 411 xeq;
+#X text 41 402 an experimental MIDI sequencer;
+#X restore 144 497 pd other_midi_objects;
+#X obj 17 497 noteout;
+#X obj 13 286 stripnote;
+#X text 78 287 is one of the ways to deal with this situation;
+#X text 11 41 The [notein] object reads incoming MIDI notes and reports
+their note number \, velocity and channel number. Without the argument
+it reads from all MIDI channels (omni).;
+#X obj 280 526 midi-basics;
+#X text 14 526 for an explanation of MIDI usage in PD see:;
+#X text 13 312 Arguments: the MIDI channel number from which to read
+(with no argument it listens to all channels):;
+#X text 80 13 - read incoming stream of MIDI notes.;
+#X text 11 207 Note: remember that a 'note-off' is a note with velocity=0.
+Therefore [notein] reports each note twice (note-on when a key on your
+keyboard is pressed and note-off when the key is released). This could
+be sometimes misleading when tracking notes.;
+#X text 14 480 related objects;
+#X floatatom 44 449 5 0 0;
+#X floatatom 93 449 5 0 0;
+#X text 9 462 note number;
+#X text 103 462 velocity;
+#X obj 44 416 notein 17;
+#X text 107 415 notein listening only to channel 1 on port 2;
+#X text 13 582 This document was created for PD version 0.35 by Michal
+Seta as part of a project called pddp proposed by Krzysztof Czaja \,
+managed and edited by Dave Sabine \, to build comprehensive documentation
+for PD.;
+#X connect 6 0 7 0;
+#X connect 6 1 8 0;
+#X connect 6 2 9 0;
+#X connect 12 0 10 0;
+#X connect 12 1 11 0;
+#X connect 31 0 27 0;
+#X connect 31 1 28 0;
diff --git a/doc/pddp/help-noteout.pd b/doc/pddp/help-noteout.pd
new file mode 100644
index 00000000..43636a3f
--- /dev/null
+++ b/doc/pddp/help-noteout.pd
@@ -0,0 +1,91 @@
+#N canvas 233 2 471 650 10;
+#X obj 40 15 noteout;
+#X obj 41 343 noteout;
+#X obj 287 506 midi-basics;
+#X text 18 505 for an explanation of MIDI usage in PD see:;
+#X text 13 43 The [noteout] objects writes a note-on MIDI message to
+the output port.;
+#X text 13 79 inlets:;
+#X text 65 106 list - 1st number is interpreted as MIDI note number
+\,;
+#X text 108 118 the second as velocity and the third (if present);
+#X text 110 129 as channel number;
+#X text 19 157 right:;
+#X text 13 141 middle:;
+#X text 66 141 int - velocity;
+#X text 21 96 left:;
+#X text 64 94 int - MIDI note number (0-127);
+#X text 66 155 int - channel number;
+#X text 6 175 outlets:;
+#X text 65 175 none;
+#X text 16 205 Arguments:;
+#X text 21 228 MIDI channel number to which a note-on message is to
+be sent. If no argument is provided [noteout] transmits on channel
+1 (default).;
+#X text 12 280 examples:;
+#X msg 42 322 60 100 2;
+#X text 20 372 (all three above) middle-c with velocity 100 sent to
+channel 2;
+#X obj 133 343 noteout 2;
+#X msg 134 322 60 100;
+#X obj 245 287 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X msg 244 326 60;
+#X msg 278 324 100;
+#X obj 243 305 t b b b;
+#X obj 257 345 noteout;
+#X msg 308 325 2;
+#X text 22 406 See also:;
+#X obj 23 427 makenote;
+#X text 92 426 -- format a MIDI note (with a note-off message);
+#X text 21 452 related object;
+#X obj 24 467 notein;
+#N canvas 240 135 476 472 other_midi_objects 0;
+#X obj 7 29 ctlin;
+#X obj 49 29 pgmin;
+#X obj 92 28 bendin;
+#X obj 143 27 touchin;
+#X obj 204 27 polytouchin;
+#X obj 289 27 midiin;
+#X obj 340 26 sysexin;
+#X obj 6 85 noteout;
+#X obj 63 84 ctlout;
+#X obj 160 84 bendout;
+#X obj 217 83 touchout;
+#X obj 281 82 polytouchout;
+#X obj 370 82 midiout;
+#X obj 113 84 pgmout;
+#X obj 11 153 makenote;
+#X text 10 194 MIDI notes deconstruction:;
+#X text 8 128 MIDI note construction:;
+#X text 8 58 MIDI output:;
+#X text 8 2 MIDI input:;
+#X obj 15 226 stripnote;
+#X text 11 266 Additional useful objects for MIDI processing (Maxlib
+by Olaf Matthes);
+#X obj 148 297 chord;
+#X obj 109 296 borax;
+#X obj 54 296 score o;
+#X obj 13 296 pitch;
+#X text 15 336 Also \, from cyclone (alpha) by Krzysztof Czaja:;
+#X obj 16 359 midiformat;
+#X obj 172 359 midiflush;
+#X obj 98 359 midiparse;
+#X text 15 386 and xeq \, from the same developer;
+#X obj 16 411 xeq;
+#X text 41 402 an experimental MIDI sequencer;
+#X restore 119 467 pd other_midi_objects;
+#X text 93 15 - transmit MIDI notes;
+#X text 19 543 This document was updated for PD version 0.35 by Michal
+Seta as part of a project called pddp proposed by Krzysztof Czaja \,
+managed and edited by Dave Sabine \, to build comprehensive documentation
+for PD.;
+#X connect 20 0 1 0;
+#X connect 23 0 22 0;
+#X connect 24 0 27 0;
+#X connect 25 0 28 0;
+#X connect 26 0 28 1;
+#X connect 27 0 25 0;
+#X connect 27 1 26 0;
+#X connect 27 2 29 0;
+#X connect 29 0 28 2;
diff --git a/doc/pddp/help-operators.pd b/doc/pddp/help-operators.pd
new file mode 100644
index 00000000..54742bf9
--- /dev/null
+++ b/doc/pddp/help-operators.pd
@@ -0,0 +1,283 @@
+#N canvas 23 29 920 640 10;
+#X obj 622 350 +~;
+#X obj 626 499 trigger;
+#X text 25 8 ARITHMETIC;
+#X text 30 29 PD's arithmetic objects include:;
+#X obj 231 30 +;
+#X obj 256 30 -;
+#X obj 282 30 *;
+#X obj 308 30 /;
+#X obj 334 30 pow;
+#X obj 359 30 max;
+#X obj 385 30 min;
+#X obj 32 276 +;
+#X floatatom 32 205 0 0 0;
+#X floatatom 32 297 0 0 0;
+#X floatatom 45 228 0 0 0;
+#X msg 63 254 bang;
+#X text 98 255 Bang outputs sum;
+#X text 70 204 Numbers in left inlet add and output sum;
+#X text 87 227 Numbers in right inlet only change the inlet's value
+;
+#X text 29 171 The example below performs basic addition with two numbers:
+i.e. a + b = c;
+#X text 28 54 All of these objects operate the same way. The right
+inlet sets or changes the numeric value of the object. Sending a number
+to the left inlet forces the object to perform the operation with the
+current numeric value of the object and output the result. A "bang"
+will output the result without changing the numeric values at either
+inlet. A creation argument can be used to define the initial numeric
+value of the right inlet.;
+#X text 29 325 The example below incorporates a creation argument:
+i.e. a + 42 = b;
+#X floatatom 29 357 0 0 0;
+#X floatatom 29 400 0 0 0;
+#X obj 29 379 + 42;
+#N canvas 38 134 637 241 basic_examples 0;
+#X obj 44 129 +;
+#X obj 113 129 -;
+#X obj 179 129 *;
+#X obj 244 129 /;
+#X obj 316 129 pow;
+#X obj 394 129 max;
+#X obj 482 129 min;
+#X floatatom 44 32 5 0 0;
+#X floatatom 44 150 0 0 0;
+#X floatatom 113 149 0 0 0;
+#X floatatom 179 149 0 0 0;
+#X floatatom 244 149 0 0 0;
+#X floatatom 316 149 0 0 0;
+#X floatatom 394 150 0 0 0;
+#X floatatom 482 149 0 0 0;
+#X floatatom 495 32 5 0 0;
+#X msg 360 32 bang;
+#X connect 0 0 8 0;
+#X connect 1 0 9 0;
+#X connect 2 0 10 0;
+#X connect 3 0 11 0;
+#X connect 4 0 12 0;
+#X connect 5 0 13 0;
+#X connect 6 0 14 0;
+#X connect 7 0 0 0;
+#X connect 7 0 1 0;
+#X connect 7 0 2 0;
+#X connect 7 0 3 0;
+#X connect 7 0 4 0;
+#X connect 7 0 5 0;
+#X connect 7 0 6 0;
+#X connect 15 0 6 1;
+#X connect 15 0 5 1;
+#X connect 15 0 4 1;
+#X connect 15 0 3 1;
+#X connect 15 0 2 1;
+#X connect 15 0 1 1;
+#X connect 15 0 0 1;
+#X connect 16 0 0 0;
+#X connect 16 0 1 0;
+#X connect 16 0 2 0;
+#X connect 16 0 3 0;
+#X connect 16 0 4 0;
+#X connect 16 0 5 0;
+#X connect 16 0 6 0;
+#X restore 28 542 pd basic_examples;
+#X text 29 425 + - * / are probably self-explanatory...if you are using
+PD \, then it is safe to say that you have passed third grade.;
+#X text 27 463 However \, [pow] \, [max] \, and [min] objects may need
+some explanation.;
+#N canvas 0 0 452 302 understanding_POW 0;
+#X text 12 25 [POW];
+#X obj 17 66 pow 2;
+#X floatatom 17 86 2 0 0;
+#X msg 17 46 2;
+#X text 61 115 - it is important to note that [pow] only works with
+NON-negative mantissas. That is to say that negative floating point
+fractions will be ignored.;
+#X obj 18 153 pow 2;
+#X floatatom 18 173 2 0 0;
+#X msg 13 111 -2;
+#X msg 24 132 -1.5;
+#X text 65 202 - however \, [pow] is capable of computing negative
+exponents!;
+#X floatatom 19 201 0 0 0;
+#X obj 19 221 pow -2;
+#X floatatom 19 242 0 0 0;
+#X text 57 39 - this object is used to exponentiate a number. The object
+returns the value at the left inlet to the power of the right inlet
+where the left inlet is the base and the right inlet is the exponent.
+For example: 2 to the power of 2 = 4 (i.e. 2 Squared);
+#X connect 1 0 2 0;
+#X connect 3 0 1 0;
+#X connect 5 0 6 0;
+#X connect 7 0 5 0;
+#X connect 8 0 5 0;
+#X connect 10 0 11 0;
+#X connect 11 0 12 0;
+#X restore 28 497 pd understanding_POW;
+#N canvas 0 0 474 341 understanding_MAX_and_MIN 0;
+#X text 34 9 [MAX];
+#X obj 32 51 max 10;
+#X floatatom 32 29 5 0 0;
+#X floatatom 32 76 5 0 0;
+#X text 87 26 - [max] returns the greater of the two numbers passed
+to its inlets. For example \, if the creation argument (or right inlet)
+is equal to 10 \, and you send 9 to the left inlet then the object
+will return 10 If you pass it an 11 \, then object returns 11;
+#X floatatom 33 116 5 0 0;
+#X floatatom 33 163 5 0 0;
+#X text 35 96 [MIN];
+#X text 88 113 - [min] returns the lesser of the two numbers passed
+to its inlets. For example \, if the creation argument (or right inlet)
+is equal to 10 \, and you send 9 to the left inlet then the object
+will return 9 If you pass it an 11 \, then object returns 10;
+#X obj 33 138 min 10;
+#X text 32 185 - It is important to note that [max] and [min] output
+a number with every number or "bang" that is sent to the left inlet.
+;
+#X floatatom 35 234 5 0 0;
+#X floatatom 35 282 5 0 0;
+#X obj 35 256 min 10;
+#X obj 76 281 bng 15 50 10 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 80 232 Move this number box above 10;
+#X connect 1 0 3 0;
+#X connect 2 0 1 0;
+#X connect 5 0 9 0;
+#X connect 9 0 6 0;
+#X connect 11 0 13 0;
+#X connect 13 0 12 0;
+#X connect 13 0 14 0;
+#X restore 28 519 pd understanding_MAX_and_MIN;
+#X obj 430 568 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 430 12 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 469 20 THE SUM OF MANY NUMBERS;
+#X text 473 40 PD has wonderful object called [expr] which allows you
+to write mathematical expressions. I would suggest that you investigate
+the [expr] object to process basic mathematical equations with more
+than 2 separate values.;
+#X msg 481 151 bang;
+#X obj 481 203 random 10;
+#X obj 543 203 random 10;
+#X obj 605 203 random 10;
+#X text 509 222 a;
+#X text 571 223 b;
+#X text 632 222 c;
+#X text 512 288 d;
+#X floatatom 481 288 0 0 0;
+#X obj 481 172 t b b b;
+#X obj 481 245 +;
+#X obj 481 266 +;
+#X floatatom 481 223 0 0 0;
+#X floatatom 543 223 0 0 0;
+#X floatatom 605 223 0 0 0;
+#X text 474 102 Having said that \, it IS possible to build equations
+with multiple elements using these basic math objects \, as in the
+example below: (i.e. a + b + c = d);
+#X text 469 324 RELATED OBJECTS;
+#X obj 651 350 -~;
+#X obj 680 350 *~;
+#X obj 708 350 /~;
+#X obj 736 350 max~;
+#X obj 766 350 min~;
+#X text 550 350 Audio Math;
+#X obj 622 374 ==;
+#X obj 680 374 >;
+#X obj 736 374 <;
+#X obj 708 374 >=;
+#X obj 766 373 <=;
+#X obj 652 374 !=;
+#X text 514 375 Relational Tests;
+#X text 508 398 Logical Operators;
+#X obj 623 398 &;
+#X obj 652 398 |;
+#X obj 680 398 &&;
+#X obj 708 398 ||;
+#X obj 736 398 <<;
+#X obj 766 398 >>;
+#X obj 680 499 expr;
+#X obj 622 422 mtof;
+#X obj 653 422 ftom;
+#X obj 684 422 powtodb;
+#X obj 734 422 rmstodb;
+#X obj 784 422 dbtopow;
+#X obj 834 422 dbtorms;
+#X text 455 423 Acoustical Unit Conversion;
+#X text 547 450 Higher Math;
+#X obj 793 374 mod;
+#X obj 820 374 div;
+#X obj 626 449 sin;
+#X obj 652 449 cos;
+#X obj 679 449 tan;
+#X obj 706 449 atan;
+#X obj 625 473 atan2;
+#X obj 716 499 random;
+#X obj 663 473 sqrt;
+#X obj 694 473 log;
+#X obj 720 473 exp;
+#X obj 746 473 abs;
+#X text 580 499 Other;
+#N canvas 181 122 454 304 related_objects_from_other_libraries 0;
+#X obj 37 25 vector+;
+#X obj 37 45 vector-;
+#X obj 37 65 vector*;
+#X obj 85 25 vector/;
+#X obj 85 45 rgb2hsv;
+#X obj 85 65 hsv2rgb;
+#X obj 133 25 abs~;
+#X obj 133 45 db2v;
+#X obj 133 65 v2db;
+#X obj 163 25 avg~;
+#X obj 164 45 tavg~;
+#X obj 164 65 pdf~;
+#X obj 201 24 <~;
+#X obj 201 45 ==~;
+#X obj 201 67 >~;
+#X obj 228 25 &&~;
+#X obj 228 46 ||~;
+#X obj 228 67 matrix~;
+#X obj 280 25 mavg;
+#X obj 280 46 mean;
+#X obj 280 68 divide;
+#X obj 323 27 divmod;
+#X obj 324 47 minus;
+#X obj 324 67 plus;
+#X text 29 104 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 28 153 The best places to find information about PD's libraries
+is:;
+#X text 25 175 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 27 190 or;
+#X text 27 205 iem.kug.ac.at/pdb/;
+#X obj 370 27 q8_rsqrt~;
+#X obj 370 51 q8_sqrt~;
+#X restore 520 537 pd related_objects_from_other_libraries;
+#X obj 763 499 f;
+#X obj 791 499 int;
+#X obj 794 398 %;
+#X obj 251 539 timer;
+#X text 292 584 This document was updated for PD version 0.35 test
+28 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X obj 739 449 pow;
+#X connect 11 0 13 0;
+#X connect 12 0 11 0;
+#X connect 14 0 11 1;
+#X connect 15 0 11 0;
+#X connect 22 0 24 0;
+#X connect 24 0 23 0;
+#X connect 31 0 30 0;
+#X connect 34 0 43 0;
+#X connect 35 0 46 0;
+#X connect 36 0 47 0;
+#X connect 37 0 48 0;
+#X connect 43 0 35 0;
+#X connect 43 1 36 0;
+#X connect 43 2 37 0;
+#X connect 44 0 45 0;
+#X connect 45 0 42 0;
+#X connect 46 0 44 0;
+#X connect 47 0 44 1;
+#X connect 48 0 45 1;
diff --git a/doc/pddp/help-otherbinops.pd b/doc/pddp/help-otherbinops.pd
new file mode 100644
index 00000000..ad1abe8c
--- /dev/null
+++ b/doc/pddp/help-otherbinops.pd
@@ -0,0 +1,435 @@
+#N canvas 16 1 887 655 10;
+#X floatatom 217 438 0 0 0;
+#X floatatom 267 517 0 0 0;
+#X obj 466 28 &;
+#X obj 494 28 |;
+#X obj 574 28 &&;
+#X obj 601 28 ||;
+#X obj 7 25 >;
+#X obj 36 25 >=;
+#X obj 67 24 ==;
+#X obj 125 24 <=;
+#X obj 153 24 <;
+#X obj 217 417 >;
+#X obj 267 496 ==;
+#X obj 96 24 !=;
+#X obj 521 28 <<;
+#X obj 548 28 >>;
+#X obj 627 28 %;
+#X text 464 5 THE LOGICAL OPERATORS -- A.K.A. "Bit Twiddling";
+#X text 6 6 THE RELATIONAL OPERATORS;
+#N canvas 0 0 454 304 understanding_%_modulus 0;
+#X text 24 23 MODULUS - [%];
+#X floatatom 28 187 0 0 0;
+#X text 22 40 - this object has nothing to do with percentage!;
+#X text 20 54 - a modulus is a number by which two given numbers can
+be divided and produce the same remainder.;
+#X text 21 81 - in the example below: 9 / 2 = 4.5 \, and 7 / 2 = 3.5.
+Hence if 7 and 9 are divided by 2 \, then the remainder of both equations
+is .5. Therefore \, the modulus of 7 and 9 is "2".;
+#X msg 28 138 9;
+#X obj 28 166 % 7;
+#X floatatom 62 142 5 0 0;
+#X text 20 222 Note that the modulus operator is not a "bitwise" operator
+\, but a math function.;
+#X connect 5 0 6 0;
+#X connect 6 0 1 0;
+#X connect 7 0 6 0;
+#X restore 476 418 pd understanding_%_modulus;
+#X text 478 252 Below is a brief explanation of each of these logical
+operators.;
+#X text 473 53 These objects are adopted from the mother of all object
+oriented languages: C. They are "bitwise" operators which perform logical
+and shift operations on 32-bit numbers.;
+#X text 467 100 WHAT DOES "BITWISE" MEAN?;
+#X text 478 208 Hence \, performing "bitwise" relational tests means
+that PD can compare "1101" to "1001" instead of operating with the
+integers that are represented by those binary codes.;
+#N canvas 81 197 456 306 understanding_&_AND 0;
+#X obj 33 216 &;
+#X floatatom 87 182 5 0 0;
+#X floatatom 129 183 5 0 0;
+#X msg 33 154 13;
+#X msg 62 155 9;
+#X text 18 18 [&] -- This is the bitwise AND operator which returns
+a "1" for each bit position where the corresponding bits of both its
+operands are "1". For example:;
+#X text 22 67 13 = "1101";
+#X text 28 79 9 = "1001";
+#X text 15 92 Hence:"1001";
+#X obj 33 114 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 33 132 t b b;
+#X text 101 66 When comparing the binary codes for 13 and 9 \, we can
+see that the first and fourth digits of both codes are 1 Hence the
+result will be "1001" -- in other words "9".;
+#X floatatom 33 238 0 0 0;
+#X connect 0 0 12 0;
+#X connect 1 0 0 0;
+#X connect 2 0 0 1;
+#X connect 3 0 0 0;
+#X connect 4 0 0 1;
+#X connect 9 0 10 0;
+#X connect 10 0 3 0;
+#X connect 10 1 4 0;
+#X restore 478 286 pd understanding_&_AND;
+#N canvas 190 317 454 304 understanding_|_OR 0;
+#X floatatom 32 247 0 0 0;
+#X floatatom 86 191 5 0 0;
+#X floatatom 128 192 5 0 0;
+#X msg 32 163 13;
+#X msg 61 164 9;
+#X text 21 76 13 = "1101";
+#X text 27 88 9 = "1001";
+#X obj 32 123 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 32 141 t b b;
+#X text 18 18 [|] -- This is the bitwise OR operator which returns
+a "1" for each bit position where one OR both of the corresponding
+bits of both its operands is a "1". For example:;
+#X text 14 101 Hence:"1101";
+#X text 98 76 When comparing the binary codes for 13 and 9 \, we can
+see that the first and fourth digits of both codes are both 1 and the
+second position of 13 is a one. Hence the result will be "1101" --
+in other words "13".;
+#X obj 32 225 |;
+#X connect 1 0 12 0;
+#X connect 2 0 12 1;
+#X connect 3 0 12 0;
+#X connect 4 0 12 1;
+#X connect 7 0 8 0;
+#X connect 8 0 3 0;
+#X connect 8 1 4 0;
+#X connect 12 0 0 0;
+#X restore 478 307 pd understanding_|_OR;
+#N canvas 0 0 454 304 understanding_<<_LEFT-SHIFT 0;
+#X obj 46 142 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 46 160 t b b;
+#X msg 46 181 13;
+#X obj 46 222 <<;
+#X floatatom 46 244 5 0 0;
+#X msg 74 181 2;
+#X floatatom 112 193 5 0 0;
+#X floatatom 160 193 5 0 0;
+#X text 29 25 [<<] -- This is the left shift operator and it works
+by shifting the digits of the binary representation of the first operand
+(left inlet) to the left by the number of places specified by the second
+operand (right inlet). The spaces created to the right are filled by
+zeros \, and any digits falling off the left are discarded. The following
+code returns 52 as the binary of 13 ("1101") is shifted two places
+to the left giving "110100":;
+#X connect 0 0 1 0;
+#X connect 1 0 2 0;
+#X connect 1 1 5 0;
+#X connect 2 0 3 0;
+#X connect 3 0 4 0;
+#X connect 5 0 3 1;
+#X connect 6 0 3 0;
+#X connect 7 0 3 1;
+#X restore 477 328 pd understanding_<<_LEFT-SHIFT;
+#N canvas 0 0 456 380 understanding_>>_RIGHT-SHIFT 0;
+#X obj 41 155 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 41 173 t b b;
+#X floatatom 41 257 5 0 0;
+#X floatatom 107 206 5 0 0;
+#X floatatom 155 206 5 0 0;
+#X msg 41 194 13;
+#X obj 41 235 >>;
+#X msg 69 194 2;
+#X text 33 21 [>>] -- This is the sign-propagating right shift operator
+which shifts the digits of the binary representation of the first operand
+(left inlet) to the right by the number of places specified by the
+second operand (right inlet) \, discarding any shifted off to the right.
+The copies of the leftmost bit are added on from the left \, thereby
+preserving the sign of the number. This next examples returns 3 ("11")
+as the two right-most bits of 13 ("1101") are shifted off to the right
+and discarded.;
+#X text 33 284 Note that this object preserves negative values for
+negative operands. ("sign-propagating").;
+#X connect 0 0 1 0;
+#X connect 1 0 5 0;
+#X connect 1 1 7 0;
+#X connect 3 0 6 0;
+#X connect 4 0 6 1;
+#X connect 5 0 6 0;
+#X connect 6 0 2 0;
+#X connect 7 0 6 1;
+#X restore 477 350 pd understanding_>>_RIGHT-SHIFT;
+#N canvas 56 51 528 425 understanding_&&_LOGICAL-AND 0;
+#X msg 56 269 5;
+#X obj 25 319 &&;
+#X floatatom 25 339 5 0 0;
+#X floatatom 194 277 5 0 0;
+#X text 12 26 [&&] - This is the logical AND operator \, which returns
+a Boolean true (a one) if both operands are true. Logically it follows
+that if the first operand is false \, then the whole expression is
+false \, and this is how the objects works: It first evaluates the
+left hand operand (left inlet) and if this returns false (zero) then
+\, without going any further \, it returns a false (a zero). Otherwise
+it returns the value of the second operand (right inlet).;
+#X floatatom 237 277 5 0 0;
+#X text 25 364 Note that this is not a bitwise operator. It compares
+floats.;
+#X obj 25 227 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 25 245 t b b;
+#X msg 25 269 17;
+#X text 12 145 In other words \, IF the left inlet is zero \, THEN
+output zero. ELSEIF the left inlet is non-zero AND the right inlet
+is zero \, then output zero. ELSEIF the left inlet is non-zero AND
+the right inlet is non-zero \, THEN output non-zero!;
+#X obj 91 227 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 91 245 t b b;
+#X msg 91 269 17;
+#X msg 122 269 0;
+#X connect 0 0 1 1;
+#X connect 1 0 2 0;
+#X connect 3 0 1 0;
+#X connect 5 0 1 1;
+#X connect 7 0 8 0;
+#X connect 8 0 9 0;
+#X connect 8 1 0 0;
+#X connect 9 0 1 0;
+#X connect 11 0 12 0;
+#X connect 12 0 13 0;
+#X connect 12 1 14 0;
+#X connect 13 0 1 0;
+#X connect 14 0 1 1;
+#X restore 477 373 pd understanding_&&_LOGICAL-AND;
+#N canvas 244 51 530 427 understanding_||_LOGICAL-OR 0;
+#X msg 56 269 5;
+#X floatatom 25 339 5 0 0;
+#X floatatom 196 280 5 0 0;
+#X floatatom 239 280 5 0 0;
+#X text 25 364 Note that this is not a bitwise operator. It compares
+floats.;
+#X obj 25 227 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 25 245 t b b;
+#X msg 25 269 17;
+#X text 17 21 [||] -- This is the logical OR operator and it returns
+a value of true (non-zero) if one or both of the operands is true.
+It works by first evaluating the left-hand operand (left inlet) and
+\, if this is true \, diregarding the right-hand operand (right inlet)
+and returning a non-zero. If \, however \, the left-hand operand (left
+inlet) is false \, then it returns the value of the right-hand operand
+(right inlet).;
+#X text 12 145 In other words \, IF the left inlet is non-zero \, THEN
+output non-zero. ELSEIF the left inlet is zero AND the right inlet
+is zero \, then output zero. ELSEIF the left inlet is zero AND the
+right inlet is non-zero \, THEN output non-zero!;
+#X obj 25 319 ||;
+#X obj 96 226 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 96 244 t b b;
+#X msg 96 268 0;
+#X msg 127 268 0;
+#X connect 0 0 10 1;
+#X connect 2 0 10 0;
+#X connect 3 0 10 1;
+#X connect 5 0 6 0;
+#X connect 6 0 7 0;
+#X connect 6 1 0 0;
+#X connect 7 0 10 0;
+#X connect 10 0 1 0;
+#X connect 11 0 12 0;
+#X connect 12 0 13 0;
+#X connect 12 1 14 0;
+#X connect 13 0 10 0;
+#X connect 14 0 10 1;
+#X restore 477 395 pd understanding_||_LOGICAL-OR;
+#X obj 432 12 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 432 607 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 54 186 == 42;
+#X floatatom 54 165 5 0 0;
+#X floatatom 54 212 2 0 0;
+#X obj 79 211 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X msg 24 161 42;
+#X text 9 143 For example: IF 42 is equal to x \, then "1" (True);
+#X text 99 203 Note that the object outputs 1 or 0 with every incoming
+message.;
+#X text 10 233 All of these objects operate the same way. The right
+inlet or creation argument sets the "condition" to which the incoming
+messages are compared. The left inlet accepts numbers or a "bang" --
+a number will reset the value and output a true or false (1 or 0) depending
+on whether or not the incoming value meets the necessary condition.
+A "bang" will force the object to output a true or false (1 or 0) based
+on the value that is already stored in the left inlet.;
+#X floatatom 25 378 5 0 0;
+#X floatatom 98 345 5 0 0;
+#X text 10 376 a;
+#X text 138 344 b;
+#X text 93 439 Is a greater than b?;
+#X floatatom 242 478 0 0 0;
+#X text 47 478 Is a greater than or equal to b?;
+#X obj 242 457 >=;
+#X text 166 517 Is a equal to b?;
+#X obj 295 534 !=;
+#X floatatom 295 554 0 0 0;
+#X obj 325 367 r a_b;
+#X obj 325 386 unpack f f;
+#X obj 25 395 pack f f;
+#X obj 25 415 s a_b;
+#X obj 98 361 bang;
+#X text 172 555 Is a NOT equal to b?;
+#X floatatom 321 592 0 0 0;
+#X text 215 592 Is a less than b?;
+#X obj 321 572 <;
+#X floatatom 346 631 0 0 0;
+#X obj 346 611 <;
+#X text 168 631 Is a less than or equal to b?;
+#X text 474 583 This document was updated for PD version 0.35 test
+29 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X text 461 460 RELATED OBJECTS;
+#X obj 813 477 +;
+#X text 480 477 Visit the Help document for MATH for more math objects:
+;
+#N canvas 0 0 452 302 related_objects_from_other_libraries 0;
+#X obj 47 34 strcomp;
+#X text 102 33 Relational tests for strings.;
+#X text 29 104 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 28 153 The best places to find information about PD's libraries
+is:;
+#X text 25 175 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 27 190 or;
+#X text 27 205 iem.kug.ac.at/pdb/;
+#X restore 482 501 pd related_objects_from_other_libraries;
+#X text 478 120 Well \, these objects perform "relational" tests on
+the binary forms of 32-bit numbers. For example \, the number 13 is
+represented in your computer's operating system in binary code by "1101"
+and the number 9 is "1001". Each of those binary digits is an 8-bit
+word: 8 bits * 4 digits = 32-bits!;
+#X obj 179 24 mod;
+#X obj 206 24 div;
+#X text 8 84 Most relational operators output a boolean value: true
+or false (1 or 0) depending on the relation between the input (left
+inlet) and the condition (right inlet or creation argument).;
+#N canvas 7 1 506 648 understanding_MOD_and_DIV 0;
+#X text 24 5 [mod] and [div] are helpful objects to determine whether
+or not a fraction produces a remainder \, or to determine the value
+of the remainder.;
+#X text 24 80 while \, 4 / 3 = 1 with a remainder of 1;
+#X text 25 51 For example \, 3 / 3 = 1 with a remainder of zero (i.e.
+no remainder).;
+#X floatatom 26 190 0 0 0;
+#X floatatom 26 232 0 0 0;
+#X floatatom 138 192 0 0 0;
+#X text 68 191 divided by;
+#X text 184 192 has a remainder of;
+#X floatatom 300 193 0 0 0;
+#X obj 26 211 mod;
+#X text 22 103 [mod] takes a number in its left inlet and will divide
+that number by either the creation argument or the number given at
+its left inlet and will produce the value of the remainder at its outlet.
+If no creation argument is given \, then the default value is 1;
+#X obj 88 173 loadbang;
+#X msg 138 173 1;
+#X text 23 255 [div] takes a number in its left inlet and will divide
+that number by either the creation argument or the number given at
+its left inlet and will produce the result without a remainder. If
+no creation argument is given \, then the default value is 1;
+#X floatatom 28 341 0 0 0;
+#X floatatom 28 383 0 0 0;
+#X floatatom 140 343 0 0 0;
+#X text 70 342 divided by;
+#X floatatom 256 344 0 0 0;
+#X obj 90 324 loadbang;
+#X msg 140 324 1;
+#X obj 28 362 div;
+#X text 186 343 is equal to;
+#X text 294 343 with no remainder.;
+#X obj 257 371 /;
+#X floatatom 257 391 0 0 0;
+#X text 237 389 or;
+#X text 310 392 with a remainder.;
+#X text 23 408 In the following example \, I've built a metronome which
+counts bar numbers and beat numbers: default time signature is 4/4
+(Common Time).;
+#X obj 23 489 metro 500;
+#X obj 23 470 tgl 15 0 empty empty Start-Stop 0 -6 0 8 -262144 -1 -1
+0 1;
+#X obj 48 510 + 1;
+#X floatatom 23 530 0 0 0;
+#X text 52 532 Total Beat Count;
+#X obj 23 559 div 4;
+#X obj 134 560 mod 4;
+#X floatatom 219 601 0 0 0;
+#X floatatom 108 600 0 0 0;
+#X obj 23 510 f 1;
+#X msg 107 468 1;
+#X obj 23 579 + 1;
+#X obj 134 579 + 1;
+#X text 131 468 Reset;
+#X text 44 599 Bar number;
+#X text 157 601 Beat Count;
+#X floatatom 339 511 0 0 0;
+#X text 196 511 How many beats per bar?;
+#X connect 3 0 9 0;
+#X connect 4 0 8 0;
+#X connect 5 0 9 1;
+#X connect 9 0 4 0;
+#X connect 11 0 12 0;
+#X connect 12 0 5 0;
+#X connect 14 0 21 0;
+#X connect 14 0 24 0;
+#X connect 15 0 18 0;
+#X connect 16 0 21 1;
+#X connect 16 0 24 1;
+#X connect 19 0 20 0;
+#X connect 20 0 16 0;
+#X connect 21 0 15 0;
+#X connect 24 0 25 0;
+#X connect 29 0 38 0;
+#X connect 30 0 29 0;
+#X connect 31 0 38 1;
+#X connect 32 0 34 0;
+#X connect 32 0 35 0;
+#X connect 34 0 40 0;
+#X connect 35 0 41 0;
+#X connect 38 0 31 0;
+#X connect 38 0 32 0;
+#X connect 39 0 38 1;
+#X connect 40 0 37 0;
+#X connect 41 0 36 0;
+#X connect 45 0 35 1;
+#X connect 45 0 34 1;
+#X restore 9 58 pd understanding_MOD_and_DIV;
+#X connect 11 0 0 0;
+#X connect 12 0 1 0;
+#X connect 30 0 31 0;
+#X connect 32 0 34 0;
+#X connect 32 0 35 0;
+#X connect 33 0 32 0;
+#X connect 36 0 32 0;
+#X connect 40 0 53 0;
+#X connect 41 0 53 1;
+#X connect 41 0 55 0;
+#X connect 47 0 45 0;
+#X connect 49 0 50 0;
+#X connect 51 0 52 0;
+#X connect 52 0 11 0;
+#X connect 52 0 47 0;
+#X connect 52 0 12 0;
+#X connect 52 0 49 0;
+#X connect 52 0 59 0;
+#X connect 52 0 61 0;
+#X connect 52 1 11 1;
+#X connect 52 1 47 1;
+#X connect 52 1 12 1;
+#X connect 52 1 49 1;
+#X connect 52 1 59 1;
+#X connect 52 1 61 1;
+#X connect 53 0 54 0;
+#X connect 55 0 40 0;
+#X connect 59 0 57 0;
+#X connect 61 0 60 0;
diff --git a/doc/pddp/help-pack.pd b/doc/pddp/help-pack.pd
new file mode 100644
index 00000000..0349f3d2
--- /dev/null
+++ b/doc/pddp/help-pack.pd
@@ -0,0 +1,128 @@
+#N canvas 13 -7 937 656 10;
+#X obj 25 11 pack;
+#X text 60 11 - combine several atoms into one message;
+#X msg 24 190 bang;
+#X obj 24 210 pack 100 0 s 42;
+#X text 24 249 In the same example \, this [pack] object will recognize
+floats in the first \, second \, and fourth inlet \; it will recognize
+symbols in the third inlet. If it receives anything else \, then you'll
+see the "no method for ___" error message in the terminal window.;
+#X obj 25 366 pack 100 0 s 42;
+#X msg 25 328 400 1 cat 38;
+#X text 110 328 This works.;
+#X msg 37 347 cat dog 42 earth;
+#X obj 30 534 pack cat;
+#X text 24 419 So \, if [pack] understands that "100" is a float and
+can therefore understand all incoming numbers to that inlet...then
+you might assume that the word "cat" could be written as a creation
+argument and [pack] should understand all incoming symbols. But that's
+NOT the case. If you try to define a [pack] symbol with the word "cat"
+in a creation argument \, you'll get a "bad type" error.;
+#X text 38 516 WRONG;
+#X obj 142 538 pack symbol;
+#X text 222 528 CORRECT;
+#X obj 142 559 print this_package;
+#X msg 142 517 cat;
+#X text 40 382 Note that the "s" above is an abbreviation for "symbol".
+;
+#X obj 30 611 pack bang;
+#X text 29 578 Same problem with bangs! This [pack] object creates
+an error.;
+#X obj 416 14 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 416 604 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 448 106 [pack] can be created with any number of creation arguments.
+There will be one inlet created for each argument and the values of
+each [pack]ed element can be updated at any time using the separate
+inlets \; or they can be updated simoultaneously with a LIST of messages
+to its first inlet.;
+#X text 609 75 is the same as;
+#X obj 24 231 print package_1;
+#X obj 25 399 print package_2;
+#X obj 444 489 print my_package;
+#X msg 467 271 1 2 dog;
+#X text 518 266 This list doesn't contain enough elements \; so it
+resets only the first three elements and then outputs the entire package
+- the undefined elements will simply output their previous values.
+;
+#X obj 444 197 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X floatatom 476 376 5 0 0;
+#X floatatom 474 329 5 0 0;
+#X msg 537 423 100 earth me 42;
+#X text 548 441 Lists can only be sent to the first inlet -- this list
+will cause an error.;
+#X text 520 326 A new value for the first element will reset the first
+element and force [pack] to output the entire package of stored values.
+;
+#X text 451 16 Perhaps the best way to build creation arguments is
+to define the data types that [pack] should expect at each inlet: (i.e.
+floats \, symbols \, or pointers -- or their abbreviations f \, s \,
+or p);
+#X obj 450 75 pack float symbol pointer;
+#X obj 704 76 pack f s p;
+#X msg 457 247 42 24 dog cat 1 2;
+#X obj 444 469 pack f f s s f f;
+#X text 572 247 This list contains new values for each element.;
+#X text 19 127 In the example below \, the creation arguments are "100
+\, 0 \, a symbol \, 42". Hence \, when [pack] receives a bang \, it
+will send that information to its outlet as a list - or 'package' -
+which will be printed in your terminal window.;
+#X text 144 348 This doesn't work - the data types;
+#X text 143 362 don't correspond with the arguments.;
+#X text 17 33 The pack object takes a series of inputs and then outputs
+a concatenated list. The number of creation arguments determines the
+number of inlets while the type of creation arguments determines the
+types of messages that [pack] should expect to receive at each inlet
+- although with some peculiarities described below.;
+#X text 463 191 Any message to the first inlet will force [pack] to
+output its package - its list of values. A bang to the first inlet
+will force [pack] to output the current values without resetting any
+of them.;
+#X text 522 366 This number box will update each of the 'float' values
+and will NOT output the package - because the first inlet is not receiving
+a message - to change this behavior \, you should explore the [trigger]
+object.;
+#X text 443 523 RELATED OBJECTS;
+#X obj 442 546 trigger;
+#X obj 495 546 unpack;
+#N canvas 0 0 452 302 related_objects_from_other_libraries 0;
+#X obj 21 16 pack~;
+#X obj 61 16 unpack~;
+#X obj 113 16 tabdump;
+#X obj 169 16 niagara;
+#X obj 224 16 packel;
+#X obj 21 42 repack;
+#X obj 70 42 drip;
+#X obj 107 42 sort;
+#X text 18 86 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 17 135 The best places to find information about PD's libraries
+is:;
+#X text 14 157 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 15 173 or;
+#X text 16 187 iem.kug.ac.at/pdb/;
+#X restore 440 571 pd related_objects_from_other_libraries;
+#X text 443 601 This document was updated for PD version 0.35 test
+26 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X connect 2 0 3 0;
+#X connect 3 0 23 0;
+#X connect 5 0 24 0;
+#X connect 6 0 5 0;
+#X connect 8 0 5 0;
+#X connect 12 0 14 0;
+#X connect 15 0 12 0;
+#X connect 19 0 20 0;
+#X connect 26 0 38 0;
+#X connect 28 0 38 0;
+#X connect 29 0 38 1;
+#X connect 29 0 38 4;
+#X connect 29 0 38 5;
+#X connect 30 0 38 0;
+#X connect 31 0 38 1;
+#X connect 37 0 38 0;
+#X connect 38 0 25 0;
diff --git a/doc/pddp/help-pgmin.pd b/doc/pddp/help-pgmin.pd
new file mode 100644
index 00000000..71ebe3fb
--- /dev/null
+++ b/doc/pddp/help-pgmin.pd
@@ -0,0 +1,67 @@
+#N canvas 290 -2 492 552 10;
+#X obj 27 16 pgmin;
+#X text 26 47 The [pgmin] object reads incoming program change messages.
+;
+#X text 26 69 Arguments: (optional) int represents the channel number
+to ilsten to. With no argument \, [pgmin] accepts all channels.;
+#X text 26 105 Inlets: none. Receives directly from the MIDI port.
+;
+#X obj 27 142 pgmin;
+#X floatatom 27 182 5 0 0;
+#X floatatom 57 164 5 0 0;
+#X text 101 139 Outlets:;
+#X text 119 156 Right - channel number;
+#X text 28 308 See also:;
+#X obj 29 335 pgmout;
+#X obj 26 215 pgmin 2;
+#X floatatom 26 237 5 0 0;
+#X text 25 258 With one argument (the MIDI channel number) [pgmin]
+creates only one outlet (for program change number received). The channel
+cannot be changed dynamically.;
+#N canvas 240 135 476 472 other_midi_objects 0;
+#X obj 7 29 ctlin;
+#X obj 49 29 pgmin;
+#X obj 92 28 bendin;
+#X obj 143 27 touchin;
+#X obj 204 27 polytouchin;
+#X obj 289 27 midiin;
+#X obj 340 26 sysexin;
+#X obj 6 85 noteout;
+#X obj 63 84 ctlout;
+#X obj 160 84 bendout;
+#X obj 217 83 touchout;
+#X obj 281 82 polytouchout;
+#X obj 370 82 midiout;
+#X obj 113 84 pgmout;
+#X obj 11 153 makenote;
+#X text 10 194 MIDI notes deconstruction:;
+#X text 8 128 MIDI note construction:;
+#X text 8 58 MIDI output:;
+#X text 8 2 MIDI input:;
+#X obj 15 226 stripnote;
+#X text 11 266 Additional useful objects for MIDI processing (Maxlib
+by Olaf Matthes);
+#X obj 148 297 chord;
+#X obj 109 296 borax;
+#X obj 54 296 score o;
+#X obj 13 296 pitch;
+#X text 15 336 Also \, from cyclone (alpha) by Krzysztof Czaja:;
+#X obj 16 359 midiformat;
+#X obj 172 359 midiflush;
+#X obj 98 359 midiparse;
+#X text 15 386 and xeq \, from the same developer;
+#X obj 16 411 xeq;
+#X text 41 402 an experimental MIDI sequencer;
+#X restore 105 333 pd other_midi_objects;
+#X obj 298 380 midi-basics;
+#X text 25 379 for an explanation of MIDI usage in PD see:;
+#X text 120 180 Left - program change number;
+#X text 66 17 - read incoming program change messages from the MIDI
+port;
+#X text 22 453 This document was updated for PD version 0.35 by Michal
+Seta as part of a project called pddp proposed by Krzysztof Czaja \,
+managed and edited by Dave Sabine \, to build comprehensive documentation
+for PD.;
+#X connect 4 0 5 0;
+#X connect 4 1 6 0;
+#X connect 11 0 12 0;
diff --git a/doc/pddp/help-pgmout.pd b/doc/pddp/help-pgmout.pd
new file mode 100644
index 00000000..1498584f
--- /dev/null
+++ b/doc/pddp/help-pgmout.pd
@@ -0,0 +1,68 @@
+#N canvas 293 25 488 486 10;
+#X obj 19 12 pgmout;
+#X obj 19 134 pgmout;
+#X floatatom 19 100 5 0 0;
+#X floatatom 55 116 5 0 0;
+#X text 93 96 Inlets:;
+#X text 105 113 Left: int \, program change value;
+#X text 105 135 Right: int \, MIDI channel to send the program change
+message on.;
+#X obj 25 233 pgmout 2;
+#X text 30 289 See also:;
+#N canvas 240 135 476 472 other_midi_objects 0;
+#X obj 7 29 ctlin;
+#X obj 49 29 pgmin;
+#X obj 92 28 bendin;
+#X obj 143 27 touchin;
+#X obj 204 27 polytouchin;
+#X obj 289 27 midiin;
+#X obj 340 26 sysexin;
+#X obj 6 85 noteout;
+#X obj 63 84 ctlout;
+#X obj 160 84 bendout;
+#X obj 217 83 touchout;
+#X obj 281 82 polytouchout;
+#X obj 370 82 midiout;
+#X obj 113 84 pgmout;
+#X obj 11 153 makenote;
+#X text 10 194 MIDI notes deconstruction:;
+#X text 8 128 MIDI note construction:;
+#X text 8 58 MIDI output:;
+#X text 8 2 MIDI input:;
+#X obj 15 226 stripnote;
+#X text 11 266 Additional useful objects for MIDI processing (Maxlib
+by Olaf Matthes);
+#X obj 148 297 chord;
+#X obj 109 296 borax;
+#X obj 54 296 score o;
+#X obj 13 296 pitch;
+#X text 15 336 Also \, from cyclone (alpha) by Krzysztof Czaja:;
+#X obj 16 359 midiformat;
+#X obj 172 359 midiflush;
+#X obj 98 359 midiparse;
+#X text 15 386 and xeq \, from the same developer;
+#X obj 16 411 xeq;
+#X text 41 402 an experimental MIDI sequencer;
+#X restore 109 316 pd other_midi_objects;
+#X obj 295 354 midi-basics;
+#X text 25 353 for an explanation of MIDI usage in PD see:;
+#X text 92 166 Outlets: None. Sends directly to the MIDI port;
+#X floatatom 25 205 5 0 0;
+#X obj 31 316 pgmin;
+#X text 16 40 Arguments: (optional) and int representing the MIDI channel
+to which the program change should be sent. Without an argument it
+will send on channel 1 by default.;
+#X text 24 262 Send program change message on MIDI channel 2;
+#X floatatom 193 205 5 0 0;
+#X msg 238 204 2;
+#X obj 193 233 pgmout;
+#X text 70 12 - send program change messages to the MIDI port;
+#X text 23 393 This document was updated for PD version 0.35 by Michal
+Seta as part of a project called pddp proposed by Krzysztof Czaja \,
+managed and edited by Dave Sabine \, to build comprehensive documentation
+for PD.;
+#X connect 2 0 1 0;
+#X connect 3 0 1 1;
+#X connect 13 0 7 0;
+#X connect 17 0 19 0;
+#X connect 18 0 19 1;
diff --git a/doc/pddp/help-pipe.pd b/doc/pddp/help-pipe.pd
new file mode 100644
index 00000000..c153a0dc
--- /dev/null
+++ b/doc/pddp/help-pipe.pd
@@ -0,0 +1,117 @@
+#N canvas 1 2 924 627 10;
+#X floatatom 435 307 0 0 0;
+#X floatatom 432 68 0 0 0;
+#X floatatom 432 176 0 0 0;
+#X obj 432 94 t f f f;
+#X obj 460 125 + 1;
+#X obj 488 125 + 2;
+#X floatatom 474 175 0 0 0;
+#X floatatom 517 176 0 0 0;
+#X obj 435 400 pipe 2000;
+#X text 474 305 numbers to store and output later;
+#X text 500 328 output all stored messages immediately;
+#X msg 446 332 flush;
+#X msg 463 378 clear;
+#X text 511 378 forget all stored messages;
+#X obj 436 538 delay;
+#X obj 473 538 timer;
+#X text 81 13 -- delay a message -- a message "delay line";
+#X obj 49 13 pipe;
+#X text 21 40 The Pipe object stores a sequence of messages and outputs
+them after a specified delay time in milliseconds. You can change the
+delay time as you wish. The outputs are sorted automatically.;
+#X text 20 102 BASIC USAGE;
+#X text 20 161 Like water running through a pipe \, it goes in one
+end...runs the length of the pipe...then comes out the other end.;
+#X floatatom 27 206 5 0 0;
+#X obj 27 227 pipe 20;
+#X floatatom 27 249 5 0 0;
+#X text 21 116 The left inlet accepts numbers \, symbols \, pointers
+\, messages \, and lists. The right inlet adjusts the delay time (the
+length of the pipe).;
+#X floatatom 93 210 5 0 0;
+#X text 135 209 Adjust the length of the pipe.;
+#X text 435 192 METHODS OF CONTROL;
+#X text 19 270 Creation arguments can be used to define the data type
+to be expected at the left inlet and to define the initial length of
+delay.;
+#X text 17 314 1 If only one creation argument is used \, it must be
+a number and it defines the initial length of delay.;
+#X obj 22 345 pipe 1000;
+#X text 16 366 2 If a second or third creation argument is used \,
+then they will define the data type to be expected at the inlet. Multiple
+messages can be sent to [pipe] (similar to [pack] in this case) and
+the delay time is the LAST creation argument and can be changed by
+the last inlet.;
+#X obj 19 468 pipe s 1000;
+#X text 92 468 A pipe for symbols.;
+#X obj 19 568 pipe f s 1000;
+#X text 104 568 A pipe for one float \, and one symbol.;
+#X msg 18 438 symbol cat;
+#X msg 90 438 symbol dog;
+#X symbolatom 19 489 10 0 0;
+#X symbolatom 92 589 10 0 0;
+#X floatatom 19 589 5 0 0;
+#X msg 30 547 100 dog;
+#X msg 20 526 42 cat;
+#X text 72 523 messages can be sent as lists like this example.;
+#X obj 432 151 pipe f f f 1000;
+#X text 431 218 [pipe] accepts two very important methods.;
+#X text 434 238 1 "flush": forces [pipe] to output all stored messages
+immediately.;
+#X text 434 267 2 "clear": forces [pipe] to forget all stored messages.
+;
+#X obj 435 421 print;
+#X msg 456 353 bang;
+#X text 492 353 output the most recently stored message;
+#X text 434 286 3 "bang": repeat the most recently stored message again.
+;
+#X text 431 443 RESCHEDULING;
+#X text 437 458 [pipe] schedules its output immediately after storing
+the incoming messages. This means that the delay time can be changed
+at runtime without effecting the messages that have already been scheduled
+for output.;
+#X text 430 11 Miller's original example shows how a list of floats
+can be delayed by [pipe]. Note that the [trigger] object is used to
+ensure that [pipe] receives the messages from right to left order.
+;
+#X text 432 518 RELATED OBJECTS;
+#N canvas 0 0 454 304 related_objects_from_other_libraries 0;
+#X obj 45 31 t3_delay;
+#X text 26 77 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 25 126 The best places to find information about PD's libraries
+is:;
+#X text 22 148 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 24 163 or;
+#X text 24 178 iem.kug.ac.at/pdb/;
+#X restore 437 561 pd related_objects_from_other_libraries;
+#X text 439 579 This document was updated for PD version 0.35 test
+28 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X connect 0 0 8 0;
+#X connect 1 0 3 0;
+#X connect 3 0 44 0;
+#X connect 3 1 4 0;
+#X connect 3 2 5 0;
+#X connect 4 0 44 1;
+#X connect 5 0 44 2;
+#X connect 8 0 48 0;
+#X connect 11 0 8 0;
+#X connect 12 0 8 0;
+#X connect 21 0 22 0;
+#X connect 22 0 23 0;
+#X connect 25 0 22 1;
+#X connect 32 0 38 0;
+#X connect 34 0 40 0;
+#X connect 34 1 39 0;
+#X connect 36 0 32 0;
+#X connect 37 0 32 0;
+#X connect 41 0 34 0;
+#X connect 42 0 34 0;
+#X connect 44 0 2 0;
+#X connect 44 1 6 0;
+#X connect 44 2 7 0;
+#X connect 49 0 8 0;
diff --git a/doc/pddp/help-print.pd b/doc/pddp/help-print.pd
new file mode 100644
index 00000000..b3d620d5
--- /dev/null
+++ b/doc/pddp/help-print.pd
@@ -0,0 +1,50 @@
+#N canvas 11 11 777 611 10;
+#X msg 93 173 walk the dog;
+#X msg 19 173 bang;
+#X msg 60 173 234;
+#X obj 21 10 print;
+#X obj 19 208 print;
+#X text 20 44 The print object is used in PD to send messages to the
+'terminal window'. When the print object receives a message \, its
+output will appear in the terminal window following the name of the
+print object and a colon (:). If the print object does not have a name
+(which you can supply as an argument within the print object itself)
+then the word "print" appears followed by a colon (:) and your message.
+;
+#X msg 92 240 walk the dog;
+#X msg 19 240 bang;
+#X msg 59 240 234;
+#X obj 19 267 print myPrintObject;
+#X text 181 268 A print object with a name.;
+#X text 17 309 When the print object receives a list \, it will output
+the entire list as a single message. Like below:;
+#X obj 17 369 print print_this_list;
+#X msg 17 346 10 20 30 foo;
+#X msg 17 461 10 20 30 foo;
+#X obj 17 514 unpack f f f s;
+#X obj 17 547 print unpack_this_list;
+#X text 66 201 A print object without a name. Be sure you can see the
+terminal window as you click on these messages.;
+#X text 74 9 -- print messages to the terminal window;
+#X obj 411 43 print~;
+#X text 410 22 RELATED OBJECTS;
+#X text 17 408 To output the list as separate elements \, the list
+needs to be unpacked first. Note that [unpack]'s outlets are triggered
+from right to left. Like below:;
+#X text 28 481 The arguments here are used to tell PD what type of
+atom to expect: (f = float \, s = symbol).;
+#X text 402 524 This document was updated for PD version 0.35 test
+24 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X connect 0 0 4 0;
+#X connect 1 0 4 0;
+#X connect 2 0 4 0;
+#X connect 6 0 9 0;
+#X connect 7 0 9 0;
+#X connect 8 0 9 0;
+#X connect 13 0 12 0;
+#X connect 14 0 15 0;
+#X connect 15 0 16 0;
+#X connect 15 1 16 0;
+#X connect 15 2 16 0;
+#X connect 15 3 16 0;
diff --git a/doc/pddp/help-random.pd b/doc/pddp/help-random.pd
new file mode 100644
index 00000000..cb461562
--- /dev/null
+++ b/doc/pddp/help-random.pd
@@ -0,0 +1,182 @@
+#N canvas 14 -1 978 651 10;
+#X obj 20 11 random;
+#X text 70 11 - pseudorandom integer generator;
+#X text 20 47 [random] outputs pseudorandom integers between 0 and
+N-1 where N is the creation argument or the value of the right inlet.
+;
+#X obj 28 117 random 100;
+#X obj 28 98 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X floatatom 28 138 3 0 0;
+#X text 98 117 Generates random numbers between 0 and 99;
+#X obj 28 178 random 100;
+#X obj 28 159 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X floatatom 28 199 3 0 0;
+#X floatatom 83 161 5 0 0;
+#X text 124 159 Changes the 'range' of random numbers.;
+#X text 17 223 SEEDS;
+#X text 21 240 Random numbers are generated via a complex equation
+which produces a pseudo-predictable sequence of numbers. Each [random]
+object's equation is provided with a "seed" which is really just one
+of the variables in the equation which produces the sequence. The "seed"
+is generated by PD based on specific parameters in each patch which
+contains a [random] object. If more than one [random] objects are contained
+within a single patch \, they each get a different "seed".;
+#X text 21 363 However \, "seeds" can be inputted into [random] by
+sending a message \, like below:;
+#X msg 13 420 seed 42;
+#X obj 67 427 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 67 445 random 1000;
+#X floatatom 67 465 3 0 0;
+#X obj 13 400 loadbang;
+#X text 22 490 Seeds are kept locally so that if two [random]s are
+seeded the same \, they will have the same output - as demonstrated
+below. Furthermore \, you can seed the same one twice to repeat the
+output.;
+#X msg 162 556 seed 42;
+#X obj 76 559 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 76 591 random 1000;
+#X floatatom 76 611 3 0 0;
+#X obj 162 536 loadbang;
+#X obj 150 591 random 1000;
+#X floatatom 150 611 3 0 0;
+#X obj 385 12 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 385 620 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 425 18 FERTILE SEEDS!;
+#X text 416 39 While the "default" seed for each [random] is usually
+very effective \, it may be necessary to find better - more unpredictable
+- more indeterminate ways to seed the object to produce a more pleasing
+result.;
+#X text 415 144 Here are some ideas that may improve the implementation
+of [random]:;
+#X floatatom 593 241 0 0 0;
+#X obj 435 182 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 593 221 / 100;
+#X floatatom 435 238 0 0 0;
+#X text 455 181 Both methods here produce random numbers between 0
+and 5;
+#X obj 593 201 random 501;
+#X obj 435 218 random 6;
+#X text 660 201 0 - 500;
+#X text 631 221 divide by 100 to keep output within range.;
+#X text 631 242 produces fractional results between 0 and 5;
+#X text 432 269 between 0 and 5;
+#X text 432 256 Produces whole numbers;
+#X text 401 179 1;
+#X text 405 306 2;
+#X text 416 94 As well \, there are many ways that [random] can be
+incorporated into other structures that change the qualities of the
+results.;
+#X obj 436 315 loadbang;
+#X obj 436 337 timer;
+#X obj 518 318 bng 15 250 50 0 empty empty Click_to_seed 0 -6 0 7 -262144
+-1 -1;
+#X msg 436 357 seed \$1;
+#X obj 497 360 bng 15 250 50 0 empty empty Click_for_output 0 -6 0
+7 -262144 -1 -1;
+#X floatatom 497 400 5 0 0;
+#X obj 497 379 random 42;
+#X text 598 317 "Time is on your side". Using the [timer] object here
+(which is started via loadbang) is an interesting trick.;
+#X text 407 432 3;
+#N canvas 0 0 462 404 weighted_random_numbers 0;
+#X msg 38 77 bang;
+#X text 24 20 You can generate weighted random numbers from uniformly
+distributed ones. If you just want two possible outcomes with a varying
+probability for each one \, you can do as shown:;
+#X obj 38 103 random 100;
+#X obj 37 156 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 104 156 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X floatatom 140 130 3 0 100;
+#X text 185 130 <-- change probablilty;
+#X obj 38 131 moses 80;
+#X text 87 75 <-- click to test;
+#X text 35 184 This outputs a number at left 80% of the time \, otherwise
+at right \, unless you override the "80" using the number box. You
+may extend this to more than two possible outcomes \, for instance
+like this:;
+#X msg 42 247 bang;
+#X obj 42 273 random 100;
+#X obj 42 326 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 132 327 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 91 245 <-- click to test;
+#X obj 42 301 moses 10;
+#X obj 132 302 moses 30;
+#X obj 200 327 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 40 342 10%;
+#X text 130 343 20%;
+#X text 202 342 70%;
+#X connect 0 0 2 0;
+#X connect 2 0 7 0;
+#X connect 5 0 7 1;
+#X connect 7 0 3 0;
+#X connect 7 1 4 0;
+#X connect 10 0 11 0;
+#X connect 11 0 15 0;
+#X connect 15 0 12 0;
+#X connect 15 1 16 0;
+#X connect 16 0 13 0;
+#X connect 16 1 17 0;
+#X restore 443 432 pd weighted_random_numbers;
+#X text 215 556 Click again to repeat output.;
+#X text 409 474 RELATED OBJECTS;
+#N canvas 0 0 454 304 related_objects_from_other_libraries 0;
+#X obj 25 23 randomF;
+#X obj 77 23 tripleRand;
+#X obj 146 23 shuffle;
+#X obj 197 23 mtx_rand;
+#X obj 149 47 pin~;
+#X obj 25 47 randomblock~;
+#X obj 109 47 utime;
+#X text 29 104 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 28 153 The best places to find information about PD's libraries
+is:;
+#X text 25 175 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 27 190 or;
+#X text 27 205 iem.kug.ac.at/pdb/;
+#X restore 408 494 pd related_objects_from_other_libraries;
+#X text 416 592 This document was updated for PD version 0.35 test
+29 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X connect 3 0 5 0;
+#X connect 4 0 3 0;
+#X connect 7 0 9 0;
+#X connect 8 0 7 0;
+#X connect 10 0 7 1;
+#X connect 15 0 17 0;
+#X connect 16 0 17 0;
+#X connect 17 0 18 0;
+#X connect 19 0 15 0;
+#X connect 21 0 23 0;
+#X connect 21 0 26 0;
+#X connect 22 0 23 0;
+#X connect 22 0 26 0;
+#X connect 23 0 24 0;
+#X connect 25 0 21 0;
+#X connect 26 0 27 0;
+#X connect 28 0 29 0;
+#X connect 34 0 38 0;
+#X connect 34 0 39 0;
+#X connect 35 0 33 0;
+#X connect 38 0 35 0;
+#X connect 39 0 36 0;
+#X connect 48 0 49 0;
+#X connect 49 0 51 0;
+#X connect 50 0 49 1;
+#X connect 51 0 54 0;
+#X connect 52 0 54 0;
+#X connect 54 0 53 0;
diff --git a/doc/pddp/help-realtime.pd b/doc/pddp/help-realtime.pd
new file mode 100644
index 00000000..daff3e33
--- /dev/null
+++ b/doc/pddp/help-realtime.pd
@@ -0,0 +1,108 @@
+#N canvas 64 358 939 645 10;
+#X msg 43 113 bang;
+#X msg 18 91 bang;
+#X floatatom 18 157 0 0 0;
+#X text 90 159 Output is in milliseconds;
+#X text 53 91 Click here to start or reset;
+#X obj 52 545 time_measurements;
+#X obj 52 441 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X floatatom 17 572 0 0 0;
+#X floatatom 108 585 0 0 0;
+#X floatatom 175 573 0 0 0;
+#X text 9 357 In the example below \, I've created an abstraction which
+will force each of PD's stop-watches \, [timer] [cputime] and [realtime]
+to measure various processes and report the elapsed time. Click on
+each [bng] to begin the process and wait for the results. Notice the
+discrepancies in the results.;
+#X text 15 587 Logical Time;
+#X text 173 587 Real Time;
+#X text 107 601 CPU Time;
+#X obj 67 477 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 72 435 1 Measures elapsed time between two "bangs" from a [trigger]
+object.;
+#X text 87 469 2 Measures the amount of time PD requires to turn on
+DSP and start an oscillator.;
+#X obj 445 484 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 445 17 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 472 36 WHY THE DISCREPANCIES BETWEEN CLOCKS?;
+#X text 475 59 In a fantasy world \, computers could exist somehow
+beyond the restrictions of time and digital computation could be performed
+in ZERO time. However \, that is not the case. Instead \, every process
+within PD and within your operating system requires at least a few
+nanoseconds of your CPU's time.;
+#X obj 111 509 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 476 144 The [timer] object is like a clock that is not constrained
+to the regular laws of physics and the universal space-time continuum.
+It reports "time" measurements as only PD can see them!;
+#X text 477 204 The [cputime] object is like a clock that measures
+how much time your CPU actually required to carry out your request.
+Keep in mind however that your CPU is busy doing many things simoultaneously
+\, so even though a process might take 5 minutes to complete \, your
+CPU does not pay full attention to that process for the entire 5 minutes.
+Instead \, it simply begins the process \, then refers back to that
+process from time to time until the it is complete. In other cases
+\, your CPU might require a full 5 minutes while PD might report that
+merely a few milliseconds have passed. This type of discrepancy depends
+heavily on your computer's hardware and the type of processing it is
+performing.;
+#X text 478 368 The [realtime] object is as much like your own wrist
+watch as PD can possibly manage. It measures time according to your
+operating system's internal clock.;
+#N canvas 0 0 454 304 related_objects_from_other_libraries 0;
+#X text 27 63 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 26 112 The best places to find information about PD's libraries
+is:;
+#X text 23 134 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 25 149 or;
+#X text 25 164 iem.kug.ac.at/pdb/;
+#X obj 44 24 t3_timer;
+#X text 469 589 This document was updated for PD version 0.35 test
+26 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X restore 505 476 pd related_objects_from_other_libraries;
+#X text 309 580 This document was updated for PD version 0.35 test
+28 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X obj 607 445 metro;
+#X text 504 422 RELATED OBJECTS;
+#X obj 504 446 cputime;
+#X text 132 501 3 Measures the amount of time PD requires count to
+three...please wait for approximately 3 seconds.;
+#X obj 25 15 realtime;
+#X text 83 15 -- ask Operating System for elasped real time;
+#X text 13 44 The [realtime] object measures elapsed "real" time as
+measured by your operating system.;
+#X obj 18 135 realtime;
+#X text 81 114 Click here to get elapsed real time. Click again...and
+again...to see periodic measurements from the start or reset time.
+;
+#X text 11 185 [realtime] works like essentially like a stop-watch.
+Once it starts \, you can continue to "poll" [realtime] to view the
+elapsed time.;
+#X text 11 232 The odd aspect about comparing [realtime] to a stop-watch
+is that a stop-watch can be stopped! [realtime] can only be started
+or reset. It cannot be stopped.;
+#X text 9 282 As stated above \, [realtime] measures "real" or actual
+time. This value may be slightly different that CPU time or "logical"
+time. PD offers two objects which measure CPU time and "logical" time.
+See the reference documents for those objects for more information.
+;
+#X obj 562 445 timer;
+#X connect 0 0 34 1;
+#X connect 1 0 34 0;
+#X connect 5 0 7 0;
+#X connect 5 1 8 0;
+#X connect 5 2 9 0;
+#X connect 6 0 5 0;
+#X connect 14 0 5 1;
+#X connect 18 0 17 0;
+#X connect 21 0 5 2;
+#X connect 34 0 2 0;
diff --git a/doc/pddp/help-receive.pd b/doc/pddp/help-receive.pd
new file mode 100644
index 00000000..4e241c29
--- /dev/null
+++ b/doc/pddp/help-receive.pd
@@ -0,0 +1,11 @@
+#N canvas 62 40 511 244 10;
+#X obj 27 10 receive;
+#X text 79 12 - receive messages without patch cords.;
+#X text 22 63 See;
+#X obj 48 63 send;
+#X text 79 63 for documentation regarding this object.;
+#X text 25 36 This object can be abbreviated as;
+#X obj 233 36 r;
+#X text 21 95 This document was updated for PD version 0.35 by Dave
+Sabine as part of a project called pddp proposed by Krzysztof Czaja
+to build comprehensive documentation for PD.;
diff --git a/doc/pddp/help-route.pd b/doc/pddp/help-route.pd
new file mode 100644
index 00000000..f4f5598a
--- /dev/null
+++ b/doc/pddp/help-route.pd
@@ -0,0 +1,139 @@
+#N canvas 4 7 1003 641 10;
+#X obj 7 331 print x1;
+#X obj 59 331 print x2;
+#X obj 112 331 print x3;
+#X obj 164 331 print x4;
+#X obj 82 273 route 23 54 1;
+#X msg 290 217 54 43;
+#X msg 332 217 1 foo bar;
+#X obj 44 408 route big apple;
+#X msg 422 377 1 2 3;
+#X msg 332 364 big apple pie;
+#X msg 414 235 walk the dog;
+#X text 25 215 numeric arguments:;
+#X text 18 364 symbolic arguments:;
+#X msg 574 287 bang;
+#X msg 575 380 list;
+#X msg 547 208 5;
+#X msg 553 228 float 5;
+#X msg 575 402 list 5;
+#X msg 579 307 symbol pie;
+#X msg 586 327 pie;
+#X msg 561 248 1 2 3;
+#X obj 9 475 print y1;
+#X obj 69 475 print y2;
+#X obj 129 475 print y3;
+#X obj 26 13 route;
+#X text 67 13 - route messages according to their first element;
+#X text 25 108 If a match is found \, and the message contains only
+ONE element \, then a bang is sent out the corresponding outlet. If
+a match if found \, and the message contains multiple elements (a list)
+\, then all the list elements except the first element is sent out
+the corresponding outlet. If no match is found \, then the entire message
+is sent out the right-most outlet - the "rejection" outlet. The number
+of outlets is the number of arguments plus one.;
+#X text 176 265 In this case \, the creation arguments are all numbers
+and [route] will therefore assume that it should attempt to match messages
+that are data type 'number'. All messages that are not numbers will
+be output through the right-most outlet.;
+#X msg 138 217 23 345 456;
+#X msg 216 217 420 34 45;
+#X msg 138 364 apple pie;
+#X msg 202 364 impeach ringo starr;
+#X text 147 408 In this case \, the data type 'symbol' is implied by
+the creation arguments and therefore this [route] object will match
+symbols only. Symbolic messages that do not match any of the arguments
+\, and all numbers \, will be output through the right-most outlet.
+;
+#X obj 526 5 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 526 566 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 704 468 print NO_Match;
+#X text 541 21 If necessary \, messages of different data types can
+be matched by the [route] object if the data type is explictly defined
+in the creation arguments.;
+#X text 540 71 In the example below \, instead of matching the 'value'
+of a message \, the [route] object will match 'data type': i.e. lists
+will be sent through the first outlet \, floats will be sent through
+the second outlet \, symbols through the third outlet \, bangs through
+the fourth outlet. The fifth outlet will then output anything that
+does not match one of the previously defined data types (i.e. the "pie"
+message below is a text message that hasn't been defined as a 'symbol'
+- hence \, PD cannot determine which data type it is and it will be
+output through the right-most outlet).;
+#X text 577 208 a float;
+#X text 605 228 definately a float!;
+#X text 602 247 a list (of floats);
+#X text 611 287 a bang;
+#X text 653 306 a symbol;
+#X text 620 328 none of the above!;
+#X obj 541 448 route float list bang symbol;
+#X obj 541 546 print floats;
+#X obj 581 527 print lists;
+#X obj 622 508 print bangs;
+#X obj 663 488 print symbols;
+#X msg 575 424 list pie;
+#X msg 568 268 list pie earth;
+#X text 660 267 a list of symbols;
+#X text 595 358 SPECIAL CASES OF LISTS.;
+#X text 629 423 A list with only one symbol is translated into a symbol.
+;
+#X text 621 400 A list with only one float is translated into a float
+by PD.;
+#X text 612 379 An empty list is tranlated into a bang by PD.;
+#X text 19 508 RELATED OBJECTS;
+#X obj 23 529 select;
+#X obj 68 529 trigger;
+#X obj 120 529 moses;
+#X text 378 588 This document was updated for PD version 0.35 test
+26 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X text 26 36 Route checks the first element of a message against each
+of its creation arguments \, which may be numbers or symbols (but not
+a mixture of the two unless the data types are defined explicitly)
+\, then sends the messages through the appropriate outlets.;
+#N canvas 0 0 454 304 related_objects_from_other_libraries 0;
+#X obj 26 33 segregate;
+#X text 18 86 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 17 135 The best places to find information about PD's libraries
+is:;
+#X text 14 157 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 15 173 or;
+#X text 16 187 iem.kug.ac.at/pdb/;
+#X restore 23 552 pd related_objects_from_other_libraries;
+#X connect 4 0 0 0;
+#X connect 4 1 1 0;
+#X connect 4 2 2 0;
+#X connect 4 3 3 0;
+#X connect 5 0 4 0;
+#X connect 6 0 4 0;
+#X connect 7 0 21 0;
+#X connect 7 1 22 0;
+#X connect 7 2 23 0;
+#X connect 8 0 7 0;
+#X connect 9 0 7 0;
+#X connect 10 0 4 0;
+#X connect 13 0 44 0;
+#X connect 14 0 44 0;
+#X connect 15 0 44 0;
+#X connect 16 0 44 0;
+#X connect 17 0 44 0;
+#X connect 18 0 44 0;
+#X connect 19 0 44 0;
+#X connect 20 0 44 0;
+#X connect 28 0 4 0;
+#X connect 29 0 4 0;
+#X connect 30 0 7 0;
+#X connect 31 0 7 0;
+#X connect 33 0 34 0;
+#X connect 44 0 45 0;
+#X connect 44 1 46 0;
+#X connect 44 2 47 0;
+#X connect 44 3 48 0;
+#X connect 44 4 35 0;
+#X connect 49 0 44 0;
+#X connect 50 0 44 0;
diff --git a/doc/pddp/help-select.pd b/doc/pddp/help-select.pd
new file mode 100644
index 00000000..8ef0aa4a
--- /dev/null
+++ b/doc/pddp/help-select.pd
@@ -0,0 +1,212 @@
+#N canvas 0 0 1001 659 10;
+#X floatatom 19 530 0 0 0;
+#X msg 83 488 1;
+#X msg 49 488 54;
+#X msg 19 488 23;
+#X msg 52 126 6;
+#X obj 19 165 select 6;
+#X msg 19 125 234;
+#X floatatom 19 147 0 0 0;
+#X obj 19 560 select 23 54 1;
+#X obj 46 10 select;
+#X text 91 9 - compare numbers or symbols;
+#X text 19 38 This object can be abbreviated as;
+#X obj 223 39 sel;
+#X text 19 55 In its simplest form shown below \, [select] checks its
+input agains the constant "6" (which is defined by the creation argument).
+If they match \, the first outlet gives "bang" \; otherwise the input
+is simply sent through to the second outlet.;
+#X obj 19 187 print match;
+#X obj 98 187 print NO_match;
+#X text 21 217 Note that when the input to [select] matches one of
+its creation arguments \, then a "bang" is sent to the outlet \, NOT
+the original message.;
+#X obj 19 579 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 45 579 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 71 579 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X floatatom 98 579 5 0 0;
+#X text 53 516 If you click-n-drag this number box \, you'll notice
+how all numbers except "23" \, "54" \, and "1" are simply sent through
+to the rightmost outlet.;
+#X text 23 411 Several creation arguments can be defined. In effect
+you can use [select] to test the input for many different values. You
+will see an outlet for each test value and finally an outlet for values
+which match none of them (the rightmost outlet).;
+#X obj 635 303 print NO_match;
+#X obj 508 302 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 539 303 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 571 303 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 603 303 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X msg 511 92 symbol dog;
+#X msg 516 111 symbol cat;
+#X msg 524 129 symbol foo;
+#X msg 531 149 symbol earth;
+#X msg 540 168 symbol 400;
+#X obj 508 282 select dog cat foo 400;
+#X msg 536 218 400;
+#X obj 639 580 print NO_match;
+#X obj 512 579 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 543 580 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 575 580 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 607 580 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X msg 508 377 symbol dog;
+#X msg 520 404 symbol cat;
+#X msg 528 423 symbol foo;
+#X msg 535 442 symbol earth;
+#X msg 543 463 symbol 400;
+#X msg 564 496 400;
+#X obj 512 560 select 400 dog cat foo;
+#X text 612 160 Notice that "400" here is defined as a symbol data
+type and the [select] object can successfully match it to the creation
+argment.;
+#X text 563 206 Notice that "400" here is a number and the [select]
+object cannot successfully match it to the creation argument. That
+is because this [select] expects symbols - not numbers.;
+#X obj 486 631 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 486 14 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 508 320 However \, in this case below \, you'll notice that
+the FIRST creation argument is a number. Therefore \, this [select]
+object expects numbers and will ignore the "symbol" data type.;
+#X text 547 264 FIRST CREATION ARGUMENT IS A SYMBOL;
+#X text 555 543 FIRST CREATION ARGUMENT IS A NUMBER;
+#X text 511 9 [select] can also be used to match symbols like the example
+in the upper-right of this patch. It important to note that the FIRST
+creation argument indicates to the [select] object which data type
+to expect. If your first creation argument is a symbol \, like "dog"
+\, then the object will test only symbols and numbers will be ignored!
+;
+#X text 592 490 Notice that "400" here is a number and the [select]
+object can successfully match it to the creation argument.;
+#X text 612 457 Notice that "400" here is a symbol and the [select]
+object cannot successfully match it to the creation argument.;
+#X text 21 260 Also note that in the example abovce \, there is a second
+inlet. This is used to reset the argument's value like below. This
+feature is available only on [select] objects with only ONE creation
+argument -- in other example in this patch you'll notice that this
+second inlet is absent.;
+#X obj 23 373 sel 42;
+#X msg 23 330 42;
+#X obj 23 392 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X floatatom 54 392 5 0 0;
+#X floatatom 31 349 5 0 0;
+#X floatatom 80 351 5 0 0;
+#X text 325 686 This document was updated for PD version 0.35 test
+24 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X obj 514 645 route;
+#X text 513 624 RELATED OBJECTS;
+#X text 22 614 A WORD ABOUT CONDITIONAL OBJECTS;
+#N canvas 245 41 576 578 more 0;
+#X text 22 16 Using the [select] object \, and others listed below
+\, PD users can emulate the "conditional" statements of other programming
+environments.;
+#X text 21 62 Consider the following: (Visual Basic Script);
+#X text 60 80 IF input = 1 THEN;
+#X text 59 91 response.write("Hello");
+#X text 59 104 ELSEIF input = 2 THEN;
+#X text 59 116 response.write("GoodBye");
+#X text 59 130 ELSEIF (input = 3 AND input < 10) THEN;
+#X text 59 153 ELSE;
+#X text 58 177 END IF;
+#X text 23 195 Now the PD equivalent:;
+#X msg 37 218 1;
+#X msg 67 218 2;
+#X floatatom 123 221 5 0 0;
+#X obj 37 286 sel 1 2;
+#X msg 27 418 symbol Hello;
+#X msg 48 388 symbol GoodBye;
+#X symbolatom 288 428 20 0 0;
+#X obj 33 505 ==;
+#X obj 61 505 !=;
+#X obj 88 505 >;
+#X obj 114 505 <;
+#X obj 141 505 >=;
+#X obj 168 505 <=;
+#X text 28 482 OTHER CONDITIONAL/RELATIONAL OBJECTS IN PD;
+#X text 58 164 response.write("No_match_for_me..."& input);
+#X text 59 142 response.write("This_is_cool.");
+#X obj 74 309 moses 3;
+#X msg 84 351 symbol This_is_cool.;
+#X obj 111 328 moses 10;
+#X obj 220 349 makefilename No_match_for_me...%d;
+#X connect 10 0 13 0;
+#X connect 11 0 13 0;
+#X connect 12 0 13 0;
+#X connect 13 0 14 0;
+#X connect 13 1 15 0;
+#X connect 13 2 26 0;
+#X connect 14 0 16 0;
+#X connect 15 0 16 0;
+#X connect 26 1 28 0;
+#X connect 27 0 16 0;
+#X connect 28 0 27 0;
+#X connect 28 1 29 0;
+#X connect 29 0 16 0;
+#X restore 24 632 pd more;
+#N canvas 0 0 452 302 related_objects_from_other_libraries 0;
+#X obj 28 15 multiselect;
+#X text 19 53 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 18 102 The best places to find information about PD's libraries
+is:;
+#X text 15 124 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 16 140 or;
+#X text 17 154 iem.kug.ac.at/pdb/;
+#X restore 554 644 pd related_objects_from_other_libraries;
+#X connect 0 0 8 0;
+#X connect 1 0 0 0;
+#X connect 2 0 0 0;
+#X connect 3 0 0 0;
+#X connect 4 0 7 0;
+#X connect 5 0 14 0;
+#X connect 5 1 15 0;
+#X connect 6 0 7 0;
+#X connect 7 0 5 0;
+#X connect 8 0 17 0;
+#X connect 8 1 18 0;
+#X connect 8 2 19 0;
+#X connect 8 3 20 0;
+#X connect 28 0 33 0;
+#X connect 29 0 33 0;
+#X connect 30 0 33 0;
+#X connect 31 0 33 0;
+#X connect 32 0 33 0;
+#X connect 33 0 24 0;
+#X connect 33 1 25 0;
+#X connect 33 2 26 0;
+#X connect 33 3 27 0;
+#X connect 33 4 23 0;
+#X connect 34 0 33 0;
+#X connect 40 0 46 0;
+#X connect 41 0 46 0;
+#X connect 42 0 46 0;
+#X connect 43 0 46 0;
+#X connect 44 0 46 0;
+#X connect 45 0 46 0;
+#X connect 46 0 36 0;
+#X connect 46 1 37 0;
+#X connect 46 2 38 0;
+#X connect 46 3 39 0;
+#X connect 46 4 35 0;
+#X connect 50 0 49 0;
+#X connect 58 0 60 0;
+#X connect 58 1 61 0;
+#X connect 59 0 58 0;
+#X connect 62 0 58 0;
+#X connect 63 0 58 1;
diff --git a/doc/pddp/help-send.pd b/doc/pddp/help-send.pd
new file mode 100644
index 00000000..f8d8bc92
--- /dev/null
+++ b/doc/pddp/help-send.pd
@@ -0,0 +1,199 @@
+#N canvas -7 -1 1011 660 10;
+#X obj 25 11 send;
+#X text 58 12 - sends messages without patch cords.;
+#X text 481 26 At this point \, it is necessary to explain 'locality'
+and 'scope'. When creating a [send] and/or [receive] object it is helpful
+to determine whether or not the messages you pass through those objects
+will be used by only ONE patch \, or throughout all open patches.;
+#X obj 229 34 s;
+#X text 23 35 This object can be abbreviated as;
+#X text 23 158 Send and recevie objects are given a name to tell them
+who to connect to. Here is a simple example of how these objects work
+together:;
+#X text 25 60 The [send] object \, and its counterpart \, [receive]
+\, are useful for linking objects and subroutines together in a single
+canvas or throughout multiple patches. Understanding these objects
+will help 'clean up' your patches and allow you to communicate messages
+between various modules that you build or between objects where patch
+cords are not possible.;
+#X floatatom 246 223 5 0 0;
+#X floatatom 26 205 5 0 0;
+#X text 67 205 Click-n-drag this number box.;
+#X obj 26 222 send this_number;
+#X obj 246 204 receive this_number;
+#X obj 26 293 send this_symbol;
+#X obj 245 279 receive this_symbol;
+#X symbolatom 245 297 15 0 0;
+#X msg 26 252 symbol dog;
+#X msg 40 272 symbol cat;
+#X text 101 253 Click these messages.;
+#X text 23 323 Also note that you can send messages to a receive object
+by providing the name of the receive object and your message in a message
+box \, like below: (watch the receive object ABOVE);
+#X msg 27 385 \; this_number 20 \; this_symbol symbol foo \;;
+#X msg 230 384 \; this_number 4000 \; this_symbol symbol hello_world
+\;;
+#X msg 27 435 \; this_number 42 \;;
+#X msg 230 434 \; this_symbol symbol Jupiter \;;
+#X obj 436 5 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 436 581 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 473 10 IMPORTANT;
+#N canvas 0 0 248 163 example_a 0;
+#X obj 18 9 r foo;
+#X floatatom 18 34 5 0 0;
+#X obj 24 96 r a-foo;
+#X floatatom 24 116 5 0 0;
+#X connect 0 0 1 0;
+#X connect 2 0 3 0;
+#X restore 561 139 pd example_a;
+#N canvas 2 238 250 157 example_b 0;
+#X obj 12 9 r foo;
+#X floatatom 12 28 5 0 0;
+#X obj 15 74 r b-foo;
+#X floatatom 15 93 5 0 0;
+#X connect 0 0 1 0;
+#X connect 2 0 3 0;
+#X restore 642 140 pd example_b;
+#N canvas -1 473 225 163 example_c 0;
+#X obj 12 8 r foo;
+#X floatatom 12 30 5 0 0;
+#X obj 12 65 r c-foo;
+#X floatatom 12 86 5 0 0;
+#X connect 0 0 1 0;
+#X connect 2 0 3 0;
+#X restore 724 140 pd example_c;
+#X obj 480 240 s foo;
+#X floatatom 480 224 5 0 0;
+#X text 478 196 Click-n-drag these number boxes and notice the appropriate
+receive objects in each open sub-patch.;
+#X floatatom 525 224 5 0 0;
+#X floatatom 581 225 5 0 0;
+#X floatatom 639 225 5 0 0;
+#X obj 525 240 s a-foo;
+#X obj 581 241 s b-foo;
+#X obj 639 241 s c-foo;
+#X text 475 166 TO SEND MESSAGES TO ALL RECEIVES OF THE SAME NAME IN
+ALL OPEN PATCHES - global scope.;
+#X text 482 95 To observe these features \, click on the following
+sub-patches to open each one on your screen. Move them all so that
+you can see each one clearly and also see this main patch.;
+#X text 470 397 TO SEND MESSAGES TO RECEIVE OBJECTS WITHIN A SINGLE
+PATCH - local scope.;
+#X text 480 426 There are many cases where you may want messages to
+be sent within a single patch. For example \, you might have designed
+many modules with a receive object called [r number] but you want that
+'number' to be passed to only the objects within a single module so
+that they don't effect the performance of the other modules.;
+#X text 481 506 In these cases \, you should use "local variables"
+to name your send and receive objects. Local variables are assigned
+using dollar signs and numbers. There is more documentation about this
+in 2.control.examples/locality.pd;
+#X text 23 550 RELATED OBJECTS;
+#X obj 86 574 send~;
+#X obj 123 574 receive~;
+#X obj 179 574 netsend;
+#X obj 228 574 netreceive;
+#X obj 24 574 receive;
+#X obj 23 596 tabsend~;
+#X text 477 262 Send objects simply post their information to the cyberspace
+within your computer (that's one way to look at it!) Receive objects
+simply keep their ears open for all messages floating through that
+cyberspace from send objects of the same name! Hence \, if you name
+a [send] something like "foo" \, then all [receive] objects in open
+patches named "foo" will 'hear' those messages. Also note that the
+term 'open patches' includes all sub-patches \, abstractions and patches
+that are currently open in PD - they don't have to be VISIBLE...they
+only have to be active.;
+#X text 481 585 This document was updated for PD version 0.35 by Dave
+Sabine as part of a project called pddp proposed by Krzysztof Czaja
+to build comprehensive documentation for PD.;
+#X text 21 478 SPECIAL OBJECTS AND THEIR PROPERTIES;
+#X text 27 492 Some objects in PD contain their own internal send and
+receive functionality. Open the following sub-patch for more information:
+;
+#N canvas 129 123 768 452 special-send-and-receives 0;
+#X text 26 18 SPECIAL OBJECTS;
+#X obj 28 41 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 28 66 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 1
+;
+#X obj 28 91 nbx 5 14 -1e+037 1e+037 0 0 empty empty empty 0 -6 0 10
+-262144 -1 -1 0 256;
+#X obj 28 117 vsl 15 128 0 127 0 0 empty empty empty 0 -8 0 8 -262144
+-1 -1 0 1;
+#X obj 21 368 hdl 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1 -1
+0;
+#X obj 159 129 vdl 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1 -1
+0;
+#X obj 24 343 hsl 128 15 0 127 0 0 empty empty empty -2 -6 0 8 -262144
+-1 -1 0 1;
+#X obj 79 208 vu 15 120 empty empty -1 -8 0 8 -66577 -1 1 0;
+#X obj 192 31 cnv 15 100 60 empty empty empty 20 12 0 14 -233017 -66577
+0;
+#X text 54 41 bng;
+#X text 51 66 toggle;
+#X text 93 90 number 2;
+#X text 48 168 Vertical Slider;
+#X text 185 167 Vertical Dial;
+#X text 164 344 Horizontal Slider;
+#X text 154 368 Horizontal Dial;
+#X text 136 261 VU Meter;
+#X text 225 55 canvas;
+#X text 331 28 The objects in this patch \, and likely many more which
+I have not included \, include their own send and receive functionality.
+This functionality can be accessed by right-clicking on the object
+and choosing "Properties" from the menu that appears.;
+#X text 328 101 EXAMPLE;
+#X text 333 117 In other words \, these objects can send and/or receive
+messages without attaching a separate [send] or [receive] object to
+them with a patch cord.;
+#X text 328 161 THE OL'FASHION WAY;
+#X floatatom 330 182 5 0 0;
+#X floatatom 375 200 5 0 0;
+#X obj 330 199 s a;
+#X obj 375 181 r a;
+#X text 330 222 USING THESE OBJECTS' INTERNAL SEND AND RECEIVE FUNCTIONALITY
+;
+#X text 422 181 As you see here \, these number boxes are linked together
+with send and receives objects.;
+#X obj 332 244 nbx 5 14 -1e+037 1e+037 0 0 b empty empty 0 -6 128 10
+-262144 -1 -1 0 256;
+#X obj 394 244 nbx 5 14 -1e+037 1e+037 0 0 empty b empty 0 -6 64 10
+-262144 -1 -1 0 256;
+#X text 334 262 These number boxes are linked together via their 'send'
+or 'receive' property.;
+#X connect 23 0 25 0;
+#X connect 26 0 24 0;
+#X restore 136 523 pd special-send-and-receives;
+#N canvas 0 0 439 206 related_objects_from_other_libraries 0;
+#X text 17 52 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 16 101 The best places to find information about PD's libraries
+is:;
+#X text 13 123 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 15 138 or;
+#X text 15 153 iem.kug.ac.at/pdb/;
+#X obj 16 22 streamout~;
+#X obj 82 22 sendlocal;
+#X obj 144 22 system;
+#X obj 186 22 shoutcast~;
+#X obj 254 22 sendOSC;
+#X obj 304 22 send13~;
+#X restore 172 596 pd related_objects_from_other_libraries;
+#X obj 76 596 throw~;
+#X obj 118 596 catch~;
+#X obj 297 574 value;
+#X connect 8 0 10 0;
+#X connect 11 0 7 0;
+#X connect 13 0 14 0;
+#X connect 15 0 12 0;
+#X connect 16 0 12 0;
+#X connect 23 0 24 0;
+#X connect 30 0 29 0;
+#X connect 32 0 35 0;
+#X connect 33 0 36 0;
+#X connect 34 0 37 0;
diff --git a/doc/pddp/help-spigot.pd b/doc/pddp/help-spigot.pd
new file mode 100644
index 00000000..03629bdf
--- /dev/null
+++ b/doc/pddp/help-spigot.pd
@@ -0,0 +1,119 @@
+#N canvas 94 12 862 647 10;
+#X msg 16 96 0.5 1000;
+#X floatatom 47 160 1 0 0;
+#X obj 16 177 spigot;
+#X obj 16 198 print;
+#X msg 28 136 walk the cat;
+#X msg 22 116 bang;
+#X obj 35 11 spigot;
+#X text 83 11 - pass or block messages;
+#X text 72 160 control: nonzero to pass messages \, zero to stop them
+;
+#X text 12 294 USING [SPIGOT] TO CREATE A GATE.;
+#X text 15 309 Unlike its closest cousin MAX \, PD does not have a
+native [gate] object. There are other PD libraries which include gates
+for both audio and numerical data \, but similar routines can be built
+in PD using [spigot]. The example below shows a two-way gate using
+two [spigots] and the [expr] object.;
+#X obj 95 505 spigot;
+#X floatatom 96 459 1 0 0;
+#X text 113 458 controls: open and close the gates.;
+#X floatatom 31 527 5 0 0;
+#X floatatom 95 527 5 0 0;
+#X obj 15 400 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 1
+;
+#X obj 15 418 metro 200;
+#X obj 15 439 f;
+#X obj 39 439 + 1;
+#X obj 126 484 expr 1-$f1;
+#X text 32 398 Click to start sending info through the gates.;
+#X obj 96 439 loadbang;
+#X text 16 38 [spigot] passes messages from its left inlet to its outlet
+\, as long as a nonzero number is sent to its right inlet. When its
+right inlet gets zero \, incoming messages are "blocked" (i.e. ignored).
+;
+#X text 14 231 [spigot] works essentially like a doorway. When the
+door is open \, messages can pass through. When the door is closed
+\, messages are ignored. By default \, the door is always closed!;
+#X obj 31 505 spigot;
+#X text 13 547 In the example above \, the magic is created by the
+[expr] object which performs a simple calculation using the incoming
+number (1 or 0). Note that the figure "$f1" is a variable which assumes
+the value of the incoming number.;
+#X text 402 36 CREATION ARGUMENTS?;
+#X obj 416 98 spigot 0;
+#X text 404 196 [SPIGOT] FOR AUDIO SIGNALS?;
+#X text 417 213 [spigot] does not work with audio signals. The data
+types which are accepted by this object are floats \, symbols \, lists
+\, bangs \, anythings and pointers. However \, audio signals require
+a completely different treatment.;
+#X text 414 265 PD does not have a [spigot] for audio signals \, but
+the same effect can be created using the following structure:;
+#X obj 418 312 osc~ 800;
+#X obj 386 15 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 386 596 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 418 369 *~;
+#X floatatom 431 352 1 0 0;
+#X obj 400 447 env~;
+#X floatatom 400 468 5 0 0;
+#X msg 628 341 \; pd dsp \$1 \;;
+#X obj 628 322 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0
+1;
+#X obj 445 466 dac~;
+#X obj 445 446 *~ 0.05;
+#X text 645 323 Turn on audio computation first.;
+#X text 449 357 Here is the [spigot].;
+#X text 448 370 When "0" \, audio signal;
+#X text 447 386 is effectively blocked.;
+#X text 448 400 When "1" \, audio signal is;
+#X text 448 415 not effected in any way.;
+#X text 406 498 RELATED OBJECTS;
+#N canvas 0 0 454 304 related_objects_from_other_libraries 0;
+#X obj 40 36 gate;
+#X text 18 86 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 17 135 The best places to find information about PD's libraries
+is:;
+#X text 14 157 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 15 173 or;
+#X text 16 187 iem.kug.ac.at/pdb/;
+#X restore 419 519 pd related_objects_from_other_libraries;
+#X text 453 574 This document was updated for PD version 0.35 test
+26 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X obj 416 170 spigot cat;
+#X obj 490 170 spigot dog;
+#X text 415 119 It also accepts any symbol \, but all of these are
+meaningless and have no effect on the operation of the object.;
+#X text 416 54 [spigot] only accepts one numerical creation argument:
+a zero. At creation time the [spigot] is "closed". So this creation
+argument is not needed and is rather useless.;
+#X connect 0 0 2 0;
+#X connect 1 0 2 1;
+#X connect 2 0 3 0;
+#X connect 4 0 2 0;
+#X connect 5 0 2 0;
+#X connect 11 0 15 0;
+#X connect 12 0 20 0;
+#X connect 12 0 25 1;
+#X connect 16 0 17 0;
+#X connect 17 0 18 0;
+#X connect 18 0 19 0;
+#X connect 18 0 11 0;
+#X connect 18 0 25 0;
+#X connect 19 0 18 1;
+#X connect 20 0 11 1;
+#X connect 22 0 12 0;
+#X connect 25 0 14 0;
+#X connect 32 0 35 0;
+#X connect 33 0 34 0;
+#X connect 35 0 37 0;
+#X connect 35 0 42 0;
+#X connect 36 0 35 1;
+#X connect 37 0 38 0;
+#X connect 40 0 39 0;
+#X connect 42 0 41 0;
diff --git a/doc/pddp/help-swap.pd b/doc/pddp/help-swap.pd
new file mode 100644
index 00000000..5b966254
--- /dev/null
+++ b/doc/pddp/help-swap.pd
@@ -0,0 +1,185 @@
+#N canvas 0 0 625 631 12;
+#X obj 104 572 pddp;
+#X obj 8 8 cnv 15 90 586 empty empty empty 20 12 0 14 -233017 -66577
+0;
+#X text 37 47 INLETS:;
+#X obj 54 18 swap;
+#X text 108 18 - SWAP TWO NUMBERS \, RESPECTING RIGHT-TO-LEFT ORDER
+;
+#X obj 285 470 swap;
+#X floatatom 175 429 5 0 0 0 - - -;
+#X floatatom 372 437 5 0 0 0 - - -;
+#X floatatom 312 497 5 0 0 0 - - -;
+#X floatatom 263 497 5 0 0 0 - - -;
+#X msg 243 427 42 7;
+#X obj 119 438 bng 15 250 50 0 empty empty "bang" 0 -6 0 8 -262144
+-1 -1;
+#X msg 290 415 42 7 3 4;
+#X floatatom 506 491 5 0 0 0 - - -;
+#X floatatom 454 490 5 0 0 0 - - -;
+#X msg 454 436 bang;
+#X obj 454 460 swap 12;
+#X text 37 62 - LEFT:;
+#X text 28 263 - RIGHT:;
+#X text 104 63 Float - A float at the left inlet will send the number
+to the right outlet and then send the number at the right inlet to
+the left outlet.;
+#X text 104 117 Bang - A bang at the left inlet will force [swap] to
+send its values to the outlets \, in reverse order. The value from
+the left inlet will be sent to the right outlet then the value at the
+right inlet will be sent out the left outlet.;
+#X text 104 188 List - A list at the left inlet will update the values
+of both of [swap]'s inlets and send the numbers to the outlets in reverse
+order. Note that lists of 3 or more elements will be truncated.;
+#X text 104 264 Float - A float at the right inlet is stored for later
+use. It will be sent to the left outlet when a float or bang is received
+in the left inlet.;
+#X text 104 317 One - [swap] accepts a single float as a creation argument
+which initializes the first value to be sent out the left outlet.;
+#X text 104 370 Two - outputs the float values of the two inlets in
+reverse order when a float \, list \, or bang is received at the left
+inlet.;
+#X text 371 418 float;
+#X text 174 410 float;
+#X text 244 409 list;
+#X text 428 510 creation argument;
+#N canvas 59 0 397 246 Related_Objects 0;
+#X text 25 11 Native PD Objects;
+#X text 23 92 Externals and other object libraries;
+#X obj 42 48 pack;
+#X obj 104 48 unpack;
+#X text 30 126 [split];
+#X restore 104 522 pd Related_Objects;
+#N canvas 60 0 581 620 More_Info 0;
+#X msg 38 54 42 7;
+#X obj 38 79 swap;
+#X floatatom 38 105 5 0 0 0 - - -;
+#X floatatom 97 105 5 0 0 0 - - -;
+#X obj 38 129 pack f f;
+#X obj 38 153 print;
+#N canvas 154 0 649 595 millers_note-off_parser 0;
+#X obj 27 18 notein;
+#X text 103 14 [notein] is an object which receives incoming MIDI data
+from a MIDI instrument. The three outlets are PITCH \, VELOCITY \,
+and MIDI CHANNEL from left to right. It is important to note however
+that the data is outputted from right to left. Which means that the
+first piece of information to be sent out the object is the MIDI CHANNEL.
+;
+#X obj 26 117 swap;
+#X obj 26 156 pack;
+#X obj 26 200 route 0;
+#X floatatom 26 228 5 0 0 0 - - -;
+#X text 102 117 Here \, [swap] is used to store the VELOCITY until
+the PITCH information comes from [notein]. The next step will pack
+the two together...but we have to ensure that [pack] receives the two
+numbers in the correct order: PITCH first \, then VELOCITY. This way
+\, using [route] we can determine whether or not this incoming MIDI
+data is a "note-off" signal (i.e. VELOCITY = 0).;
+#X obj 26 250 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 46 312 notein;
+#X obj 47 352 pack;
+#X obj 47 377 route 0;
+#X floatatom 47 402 5 0 0 0 - - -;
+#X obj 47 420 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 122 308 The goal of the Miller's example at the bottom left
+\, is to retrieve "note-off" signals from [notein]. To do that \, we
+have to test the incoming data for pitches with a velocity of zero.
+To do that \, we are packing up the incoming PITCH and VELOCITY data
+and sending them to [route]...in effect we achieve the following:;
+#X text 98 420 IF velocity = 0 THEN "bang";
+#X text 127 445 In the example above \, the [pack] object will output
+a list as soon as the VELOCITY information comes from [notein]. As
+a result \, the list will be outputted from pack BEFORE the PITCH information
+is retrieved. [swap] is used to solve this problem by making sure that
+the VELOCITY and PITCH are both received before packing them up and
+sending them to the [route] object.;
+#X text 50 248 This will "bang" only when velocity = 0;
+#X text 22 282 THIS IS WHY THE ALTERNATIVE DOESN'T WORK?;
+#X connect 0 0 2 0;
+#X connect 0 1 2 1;
+#X connect 2 0 3 0;
+#X connect 2 1 3 1;
+#X connect 3 0 4 0;
+#X connect 4 0 5 0;
+#X connect 5 0 7 0;
+#X connect 8 0 9 1;
+#X connect 8 1 9 0;
+#X connect 9 0 10 0;
+#X connect 10 0 11 0;
+#X connect 11 0 12 0;
+#X restore 28 569 pd millers_note-off_parser;
+#X floatatom 44 319 5 0 0 0 - - -;
+#X floatatom 94 319 5 0 0 0 - - -;
+#X floatatom 143 319 5 0 0 0 - - -;
+#X floatatom 112 440 5 0 0 0 - - -;
+#X floatatom 161 440 5 0 0 0 - - -;
+#X floatatom 211 440 5 0 0 0 - - -;
+#X msg 37 243 2 2500 9 420;
+#X obj 43 289 unpack f f f f;
+#X floatatom 193 319 5 0 0 0 - - -;
+#X text 14 10 [swap] is most commonly used to change the order of a
+list. This trick is best suited for a PAIR of numbers.;
+#X obj 166 345 swap;
+#X obj 139 370 swap;
+#X obj 112 394 swap;
+#X obj 196 378 swap;
+#X obj 169 403 swap;
+#X obj 228 408 swap;
+#X floatatom 262 440 5 0 0 0 - - -;
+#X text 230 345 This could quickly become ridiculous!;
+#X msg 165 245 1 2 3 4;
+#X msg 254 258 0 200 3333 1111;
+#X text 14 477 In other settings \, the [swap] object is useful as
+a timing mechanism to ensure that two numbers arrive at their destination
+in a particular order. Miller Puckette provided an excellent example
+of [swap] used to build a 'note-off parser'.;
+#X text 14 185 Lists that are longer than two elements could be sorted
+this way \, but the structure quickly becomes unmanageable. It's probably
+better to find an alternative method.;
+#X connect 0 0 1 0;
+#X connect 1 0 2 0;
+#X connect 1 1 3 0;
+#X connect 2 0 4 0;
+#X connect 3 0 4 1;
+#X connect 4 0 5 0;
+#X connect 7 0 19 0;
+#X connect 8 0 18 0;
+#X connect 9 0 17 0;
+#X connect 13 0 14 0;
+#X connect 14 0 7 0;
+#X connect 14 1 8 0;
+#X connect 14 2 9 0;
+#X connect 14 3 15 0;
+#X connect 15 0 17 1;
+#X connect 17 0 18 1;
+#X connect 17 1 20 1;
+#X connect 18 0 19 1;
+#X connect 18 1 20 0;
+#X connect 19 0 10 0;
+#X connect 19 1 21 0;
+#X connect 20 0 21 1;
+#X connect 20 1 22 1;
+#X connect 21 0 11 0;
+#X connect 21 1 22 0;
+#X connect 22 0 12 0;
+#X connect 22 1 23 0;
+#X connect 25 0 14 0;
+#X connect 26 0 14 0;
+#X restore 104 547 pd More_Info;
+#X text 152 573 - Dave Sabine \, November 12 \, 2002;
+#X text 13 317 ARGUMENTS:;
+#X text 29 369 OUTLETS:;
+#X text 20 427 EXAMPLES:;
+#X text 21 522 SEE ALSO:;
+#X connect 5 0 9 0;
+#X connect 5 1 8 0;
+#X connect 6 0 5 0;
+#X connect 7 0 5 1;
+#X connect 10 0 5 0;
+#X connect 11 0 5 0;
+#X connect 12 0 5 0;
+#X connect 15 0 16 0;
+#X connect 16 0 14 0;
+#X connect 16 1 13 0;
diff --git a/doc/pddp/help-symbol.pd b/doc/pddp/help-symbol.pd
new file mode 100644
index 00000000..474f01af
--- /dev/null
+++ b/doc/pddp/help-symbol.pd
@@ -0,0 +1,67 @@
+#N canvas 15 6 542 640 10;
+#X text 31 576 This document was updated for PD version 0.35 test 24
+by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X obj 55 12 symbol;
+#X text 98 13 - STORE A SYMBOL;
+#X obj 28 259 symbol;
+#X msg 28 112 bang;
+#X text 60 112 "Bang" will force the object to output its value.;
+#X symbolatom 28 314 10 0 0;
+#X obj 28 333 print;
+#X text 22 41 The symbol object stores a symbol (which is set either
+by its creation argument or by the right inlet) and then outputs that
+symbol when it receives a "bang" message or a new symbol in its left
+inlet.;
+#X text 26 394 IMPORTANT NOTE;
+#X obj 165 414 symbol;
+#X symbolatom 290 429 10 0 0;
+#X text 32 447 Please do not get them confused.;
+#X text 75 332 For this example \, I have used the symbol atom to display
+the value that was stored in the symbol object and also printed the
+value to the terminal window.;
+#X text 74 253 The symbols are stored here. When banged \, the symbol
+is outputted through the outlet. Note that a creation argument is optional.
+;
+#X msg 40 137 dog;
+#X msg 48 155 cat;
+#X msg 59 181 symbol horse;
+#X msg 73 199 symbol wolf;
+#X msg 82 217 symbol pig;
+#X text 75 139 Sending a symbol to its left inlet will store AND output
+the value.;
+#X text 24 487 RELATED OBJECTS;
+#X obj 26 513 int;
+#X obj 52 513 float;
+#X obj 89 513 f;
+#X obj 115 513 select;
+#X obj 164 513 makefilename;
+#X text 153 179 Sending new symbols to its right inlet will store the
+values. These values can later be sent via "bang" to its left inlet.
+Note that these symbols are preceded by the word "symbol" to indicate
+the appropriate data type.;
+#X text 31 414 Symbol - the OBJECT -;
+#X text 31 429 is very different than symbol - the ATOM -;
+#N canvas 0 0 454 230 related_objects_from_other_libraries 0;
+#X obj 150 28 makesymbol;
+#X obj 110 29 index;
+#X obj 16 27 ftos;
+#X obj 52 28 unsymbol;
+#X text 17 58 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 16 107 The best places to find information about PD's libraries
+is:;
+#X text 13 129 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 14 145 or;
+#X text 15 159 iem.kug.ac.at/pdb/;
+#X restore 25 536 pd related_objects_from_other_libraries;
+#X connect 3 0 6 0;
+#X connect 4 0 3 0;
+#X connect 6 0 7 0;
+#X connect 15 0 3 0;
+#X connect 16 0 3 0;
+#X connect 17 0 3 1;
+#X connect 18 0 3 1;
+#X connect 19 0 3 1;
diff --git a/doc/pddp/help-tabread.pd b/doc/pddp/help-tabread.pd
new file mode 100644
index 00000000..4f225fed
--- /dev/null
+++ b/doc/pddp/help-tabread.pd
@@ -0,0 +1,93 @@
+#N canvas 2 1 648 608 12;
+#X obj 114 560 pddp;
+#X obj 8 3 cnv 15 90 578 empty empty empty 20 12 0 14 -233017 -66577
+0;
+#X text 14 223 ARGUMENTS:;
+#X text 19 323 EXAMPLES:;
+#X text 22 471 SEE ALSO:;
+#N canvas 58 0 405 254 Related_Objects 0;
+#X text 25 11 Native PD Objects;
+#X text 16 166 Externals and other object libraries;
+#X obj 16 41 tabread~;
+#X obj 90 41 tabread4;
+#X obj 165 41 tabwrite;
+#X obj 240 41 tabwrite~;
+#X obj 16 67 tabsend~;
+#X obj 92 67 tabreceive~;
+#X obj 192 67 tabplay~;
+#X obj 269 67 table;
+#X text 15 124 [array];
+#X obj 16 94 soundfiler;
+#X text 78 124 and fft objects.;
+#X text 21 187 [tabdump];
+#X obj 112 94 tabread4~;
+#X text 20 207 [tabenv];
+#X obj 203 94 getsize;
+#X obj 274 94 setsize;
+#X text 238 207 [arraysize];
+#X text 238 186 [score];
+#X text 114 186 [linear_path];
+#X text 114 207 [plot];
+#X restore 114 508 pd Related_Objects;
+#N canvas 80 0 655 534 More_Info 0;
+#X text 25 16 WHAT IS THE DIFFERENCE BETWEEN A TABLE AND AN ARRAY AND
+A GRAPH AND A TEMPLATE AND A LIST AND A SCALAR AND A WIDGET?;
+#X text 43 56 That question isn't relevant yet \, but I know you're
+probably asking it. Let's just set aside these terms and their uses
+and say the following:;
+#X text 67 114 1 In PD \, the terms "graph" and "table" are almost
+synonymous.;
+#X text 66 164 2 A table in PD is a convenient place to store an array.
+;
+#X text 65 392 5 For more discussion about arrays and tables \, please
+see the help documentation in: doc/2.control.examples/15.arrays.pd
+and doc/5.reference/table.pd;
+#X text 44 487 Also See:;
+#X obj 123 487 all_about_arrays;
+#X text 66 195 3 When you create a table \, an array of 100 elements
+is automatically created inside that table. The name of the table and
+the name of the array are stored separately. This means \, that although
+the table has the same name as the default array \, you can rename
+one or the other individually.;
+#X text 66 307 4 [tabread] is designed to read the numbers from arrays
+- whether they're stored in tables or not! Perhaps we can think of
+this object as [arrayread] instead? Keep in mind that arrays can be
+created separately from tables.;
+#X restore 114 534 pd More_Info;
+#X obj 32 10 tabread;
+#X text 111 10 - READ NUMBERS FROM A TABLE;
+#X text 104 277 One - outputs a floating point number which corresponds
+to the index you query using the inlet.;
+#X obj 161 416 tabread davids_table;
+#X floatatom 161 443 0 0 0 3 - - -;
+#X floatatom 116 364 0 0 99 1 index - -;
+#X msg 241 391 set another_table;
+#X msg 203 366 set davids_table;
+#X text 105 168 Set - the "set <arrayname>" message allows you to read
+from dynamic sources. You can change the source at any time using the
+"set" message.;
+#X text 105 223 One - the argument informs [tabread] which array to
+read. The array must exist in an open PD patch/canvas or an error message
+will appear in the terminal window.;
+#X text 29 278 OUTLETS:;
+#X text 410 433 tables which store \; arrays of the same name.;
+#X obj 413 384 table davids_table;
+#X obj 413 410 table another_table;
+#X text 113 443 value;
+#X text 158 561 - Dave Sabine \, April 25 \, 2003;
+#X text 106 323 Open the tables and use your mouse to draw new values
+in the arrays - otherwise [tabread] will always output "0".;
+#X text 39 34 INLETS:;
+#X text 107 34 Float - A float at the left inlet will move to the corresponding
+index in the table's array. The lowest valid number is "0" which represents
+the first element of the array. The highest valid number is the size
+of the array minus 1 By default \, the size of an array in a table
+is 100 - or 0 to 99 The actual size of the array can be altered using
+the array's dialog box or the resize command. More about arrays can
+be found below.;
+#X text 112 470 doc/2.control.examples/15.arrays.pd;
+#X text 113 489 doc/2.control.examples/16.more.arrays.pd;
+#X connect 10 0 11 0;
+#X connect 12 0 10 0;
+#X connect 13 0 10 0;
+#X connect 14 0 10 0;
diff --git a/doc/pddp/help-tabread4.pd b/doc/pddp/help-tabread4.pd
new file mode 100644
index 00000000..b57ec857
--- /dev/null
+++ b/doc/pddp/help-tabread4.pd
@@ -0,0 +1,148 @@
+#N canvas 2 1 658 618 12;
+#X obj 114 560 pddp;
+#X obj 8 3 cnv 15 90 578 empty empty empty 20 12 0 14 -233017 -66577
+0;
+#X text 14 213 ARGUMENTS:;
+#X text 19 323 EXAMPLES:;
+#X text 22 471 SEE ALSO:;
+#N canvas 58 0 407 256 Related_Objects 0;
+#X text 25 11 Native PD Objects;
+#X text 16 166 Externals and other object libraries;
+#X obj 16 41 tabread~;
+#X obj 165 41 tabwrite;
+#X obj 240 41 tabwrite~;
+#X obj 16 67 tabsend~;
+#X obj 92 67 tabreceive~;
+#X obj 192 67 tabplay~;
+#X obj 269 67 table;
+#X text 15 124 [array];
+#X obj 16 94 soundfiler;
+#X text 78 124 and fft objects.;
+#X text 21 187 [tabdump];
+#X obj 112 94 tabread4~;
+#X text 20 207 [tabenv];
+#X obj 203 94 getsize;
+#X obj 274 94 setsize;
+#X text 238 207 [arraysize];
+#X text 238 186 [score];
+#X text 114 186 [linear_path];
+#X text 114 207 [plot];
+#X obj 90 41 tabread;
+#X restore 114 508 pd Related_Objects;
+#N canvas 80 0 659 614 More_Info 0;
+#X text 46 564 Also See:;
+#X obj 125 564 all_about_arrays;
+#X text 21 8 WHAT IS INTERPOLATION?;
+#X text 38 34 "Interpolation" is a word which described a sophisticated
+way to "connect-the-dots". (This is over simplified \, but effective
+for the time being.);
+#X text 17 85 Let's say for example that we have an array whose values
+are: 0 \, 6 \, 5;
+#X text 36 120 There are 3 elements in this array \, right? Well \,
+using [tabread] we could successfully read only 3 numbers. But interpolation
+allows us to fill in the gaps between those values in a meaningful
+way. For example \, we can assume that between 0 and 6 \, we might
+find 4.5! We can also assume that the slope from 0 to 6 will be sharper
+than the slope from 6 to 5 In this way \, using [tabread4] will allow
+us to create much smoother lines and curves between our "dots".;
+#X text 35 254 However \, this process is much more complicated than
+mere "smoothing". 4-point interpolation incorporates a sophisticated
+formula to intelligently create meaningful increments between values
+in an array. For example: we could draw a few points on a baseball
+diamond between the pitcher's mound and home plate. Those points could
+represent the path a ball travels after a pitch. Using 4-point interpolation
+\, we might be able to assume the positions of the ball between our
+"known" points and determine whether the pitch was a fastball or a
+curve ball.;
+#X text 35 419 There are different formulas used to interpolate arrays.
+Each method has a sort of niche where it is most comfortable and most
+effective. PD \, like most contemporary audio software \, uses 4-point
+interpolation which is also known as "Hermite" interpolation. It is
+the most "intelligent" 2-dimensional method of interpolation.;
+#N canvas 167 0 570 613 What_does_it_really_do? 0;
+#X text 20 10 Let's see [tabread4] at work...;
+#N canvas 0 0 450 300 graph36 0;
+#X array original_array 10 float 1;
+#A 0 -0.324999 -0.274999 -0.0749997 0.174999 -0.624998 0.649998 0.599998
+0.524998 -0.749997 -0.774996;
+#X coords 0 1 9 -1 200 140 1;
+#X restore 292 9 graph;
+#X text 37 158 The array above has only 10 elements. You can draw new
+shapes with your mouse.;
+#X obj 14 202 bng 15 250 50 0 empty empty Bang_me 18 7 0 8 -24198 -1
+-1;
+#X obj 88 246 until;
+#N canvas 0 0 450 300 graph37 0;
+#X array interpolation 1000 float 0;
+#X coords 0 1 999 -1 200 140 1;
+#X restore 304 445 graph;
+#X obj 84 341 tabread4 original_array;
+#X obj 88 270 f;
+#X obj 118 270 + 1;
+#X obj 84 368 tabwrite interpolation;
+#X obj 87 295 t f f;
+#X obj 14 222 t b b;
+#X msg 48 250 0;
+#X obj 86 318 / 100;
+#X msg 88 222 1000;
+#X text 36 395 The array below has 1000 elements. At this resolution
+\, you will see the overall effect of 4-point interpolation.;
+#X connect 3 0 11 0;
+#X connect 4 0 7 0;
+#X connect 6 0 9 0;
+#X connect 7 0 8 0;
+#X connect 7 0 10 0;
+#X connect 8 0 7 1;
+#X connect 10 0 13 0;
+#X connect 10 1 9 1;
+#X connect 11 0 14 0;
+#X connect 11 1 12 0;
+#X connect 12 0 7 1;
+#X connect 13 0 6 0;
+#X connect 14 0 4 0;
+#X restore 36 526 pd What_does_it_really_do?;
+#X restore 114 534 pd More_Info;
+#X floatatom 161 443 0 0 0 3 - - -;
+#X floatatom 116 364 0 0 1000 1 location - -;
+#X msg 286 389 set another_table;
+#X text 106 162 Set - the "set <arrayname>" message allows you to read
+from dynamic sources. You can change the source at any time using the
+"set" message.;
+#X text 29 266 OUTLETS:;
+#X obj 486 442 table another_table;
+#X text 106 323 Open the tables and use your mouse to draw new values
+in the arrays - otherwise [tabread] will always output "0".;
+#X text 39 34 INLETS:;
+#X text 112 470 doc/2.control.examples/15.arrays.pd;
+#X text 113 489 doc/2.control.examples/16.more.arrays.pd;
+#X obj 21 10 tabread4;
+#X text 111 10 - READ NUMBERS FROM A TABLE WITH 4-POINT INTERPOLATION
+;
+#X text 105 213 One - the argument informs [tabread4] which array to
+read. The array must exist in an open PD patch/canvas or an error message
+will appear in the terminal window.;
+#X text 104 265 One - outputs a floating point number representing
+an interpolation of the array value corresponding to the location described
+at the inlet.;
+#X text 107 34 Float - A float at the left inlet will move to the corresponding
+location in the table's array. The lowest valid number is "0" which
+represents the first element of the array. The highest valid number
+is a fraction below the actual length of the array. Each fractional
+increment between the lower and upper bounds of the array will produce
+an interpolation of the actual array values at the outlet.;
+#X msg 248 364 set davids_array;
+#N canvas 0 0 450 300 graph27 0;
+#X array davids_array 10 float 1;
+#A 0 0 0.749989 0 -0.849987 0 -0.349995 0.949986 0 -0.699989 -0.399994
+;
+#X coords 0 1 9 -1 100 40 1;
+#X restore 526 380 graph;
+#X text 249 444 interpolation;
+#X obj 121 390 / 100;
+#X obj 161 416 tabread4 davids_array;
+#X text 158 561 - Dave Sabine \, May 2 \, 2003;
+#X connect 8 0 25 0;
+#X connect 9 0 26 0;
+#X connect 22 0 26 0;
+#X connect 25 0 26 0;
+#X connect 26 0 7 0;
diff --git a/doc/pddp/help-tabwrite.pd b/doc/pddp/help-tabwrite.pd
new file mode 100644
index 00000000..ef8a75c5
--- /dev/null
+++ b/doc/pddp/help-tabwrite.pd
@@ -0,0 +1,98 @@
+#N canvas 2 1 650 610 12;
+#X obj 114 560 pddp;
+#X obj 8 3 cnv 15 90 578 empty empty empty 20 12 0 14 -233017 -66577
+0;
+#X text 14 223 ARGUMENTS:;
+#X text 20 303 EXAMPLES:;
+#X text 22 471 SEE ALSO:;
+#N canvas 58 0 407 256 Related_Objects 0;
+#X text 25 11 Native PD Objects;
+#X text 16 166 Externals and other object libraries;
+#X obj 16 41 tabread~;
+#X obj 90 41 tabread4;
+#X obj 240 41 tabwrite~;
+#X obj 16 67 tabsend~;
+#X obj 92 67 tabreceive~;
+#X obj 192 67 tabplay~;
+#X obj 269 67 table;
+#X text 15 124 [array];
+#X obj 16 94 soundfiler;
+#X text 78 124 and fft objects.;
+#X text 21 187 [tabdump];
+#X obj 112 94 tabread4~;
+#X text 20 207 [tabenv];
+#X obj 203 94 getsize;
+#X obj 274 94 setsize;
+#X text 238 207 [arraysize];
+#X text 238 186 [score];
+#X text 114 186 [linear_path];
+#X text 114 207 [plot];
+#X obj 165 41 tabread;
+#X restore 114 508 pd Related_Objects;
+#N canvas 80 0 661 319 More_Info 0;
+#X text 28 257 Also See:;
+#X obj 107 257 all_about_arrays;
+#X text 26 21 In this help document \, the [tabwrite] object is set
+to write values to one of the two arrays you see on your screen. The
+[tabwrite] will just as easily write values to tables buried in the
+[table] object. This terminology is somewhat confusing \, but the objects
+"array" and "table" exist separately because they offer different speeds
+of performance.;
+#X text 25 150 For example \, the;
+#X obj 163 150 tabread;
+#X text 229 150 documentation shows similar;
+#X text 24 169 functionality using [table] instead of array. In this
+particular document \, I chose to sacrifice speed for the sake of visually
+displaying the effectiveness of [tabwrite].;
+#X restore 114 534 pd More_Info;
+#X obj 32 10 tabread;
+#X floatatom 303 407 0 0 99 1 index - -;
+#X text 29 278 OUTLETS:;
+#X text 107 303 Open the tables and use your mouse to draw new values
+in the arrays - otherwise [tabread] will always output "0".;
+#X text 39 34 INLETS:;
+#X text 112 470 doc/2.control.examples/15.arrays.pd;
+#X text 113 489 doc/2.control.examples/16.more.arrays.pd;
+#X text 111 10 - WRITE NUMBERS TO A TABLE;
+#X text 38 50 - LEFT:;
+#X text 107 51 Float - A float at the left inlet will become the new
+value of the chosen index (whichever index is currently selected at
+the right inlet).;
+#X text 105 101 List - The left inlet also accepts pairs of floats
+(longer lists will be truncated). A number pair represents "value"
+and "index" - corresponding to "left" and "right" inlets.;
+#X text 105 151 Set - the "set <arrayname>" message allows you to write
+to dynamic locations. You can change the table at any time using the
+"set" message.;
+#X text 158 561 - Dave Sabine \, April 29 \, 2003;
+#X text 29 203 - RIGHT:;
+#X text 104 203 Float - selects which index in which to write the new
+value.;
+#X text 105 223 One - the argument informs [tabwrite] which array to
+write to. The array must exist in an open PD patch/canvas or an error
+message will appear in the terminal window.;
+#X text 104 277 None.;
+#X obj 161 437 tabwrite davids_array;
+#X msg 220 375 set another_array;
+#X msg 204 346 set davids_array;
+#X floatatom 148 381 0 0 0 0 value - -;
+#N canvas 0 0 450 300 graph12 0;
+#X array davids_array 100 float 1;
+#A 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2.75 0 0 0 0 0
+0 0 0;
+#X coords 0 1 99 -1 100 70 1;
+#X restore 528 343 graph;
+#N canvas 0 0 450 300 graph12 0;
+#X array another_array 100 float 1;
+#A 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 -0.67 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+0 0 0;
+#X coords 0 1 99 -1 100 70 1;
+#X restore 528 417 graph;
+#X connect 8 0 24 1;
+#X connect 25 0 24 0;
+#X connect 26 0 24 0;
+#X connect 27 0 24 0;
diff --git a/doc/pddp/help-timer.pd b/doc/pddp/help-timer.pd
new file mode 100644
index 00000000..f10b01b6
--- /dev/null
+++ b/doc/pddp/help-timer.pd
@@ -0,0 +1,108 @@
+#N canvas 11 8 937 643 10;
+#X msg 43 113 bang;
+#X msg 18 91 bang;
+#X obj 18 135 timer;
+#X obj 25 15 timer;
+#X floatatom 18 157 0 0 0;
+#X text 90 159 Output is in milliseconds;
+#X text 65 16 -- measure logical time;
+#X text 53 91 Click here to start or reset;
+#X text 13 44 The [timer] object measures elapsed logical time. Logical
+time moves forward as if all computation were instantaneous and as
+if all [delay] and [metro] objects were exact.;
+#X text 11 185 [timer] works like essentially like a stop-watch. Once
+it starts \, you can continue to "poll" the [timer] to view the elapsed
+time.;
+#X text 81 114 Click here to get elapsed logical time. Click again...and
+again...to see periodic measurements from the start or reset time.
+;
+#X text 10 282 As stated above \, [timer] measures "logical" time.
+This value may be slightly different that CPU time or "real" time.
+PD offers two objects which measure CPU time and "real" time. See the
+reference documents for those objects for more information.;
+#X obj 52 545 time_measurements;
+#X obj 52 441 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X floatatom 17 572 0 0 0;
+#X floatatom 108 585 0 0 0;
+#X floatatom 175 573 0 0 0;
+#X text 11 358 In the example below \, I've created an abstraction
+which will force each of PD's stop-watches \, [timer] [cputime] and
+[realtime] to measure various processes and report the elapsed time.
+Click on each [bng] to begin the process and wait for the results.
+Notice the discrepancies in the results.;
+#X text 15 587 Logical Time;
+#X text 173 587 Real Time;
+#X text 107 601 CPU Time;
+#X obj 67 477 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 72 435 1 Measures elapsed time between two "bangs" from a [trigger]
+object.;
+#X text 87 469 2 Measures the amount of time PD requires to turn on
+DSP and start an oscillator.;
+#X obj 445 484 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 445 17 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 472 36 WHY THE DISCREPANCIES BETWEEN CLOCKS?;
+#X text 475 59 In a fantasy world \, computers could exist somehow
+beyond the restrictions of time and digital computation could be performed
+in ZERO time. However \, that is not the case. Instead \, every process
+within PD and within your operating system requires at least a few
+nanoseconds of your CPU's time.;
+#X obj 111 509 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 476 144 The [timer] object is like a clock that is not constrained
+to the regular laws of physics and the universal space-time continuum.
+It reports "time" measurements as only PD can see them!;
+#X text 477 204 The [cputime] object is like a clock that measures
+how much time your CPU actually required to carry out your request.
+Keep in mind however that your CPU is busy doing many things simoultaneously
+\, so even though a process might take 5 minutes to complete \, your
+CPU does not pay full attention to that process for the entire 5 minutes.
+Instead \, it simply begins the process \, then refers back to that
+process from time to time until the it is complete. In other cases
+\, your CPU might require a full 5 minutes while PD might report that
+merely a few milliseconds have passed. This type of discrepancy depends
+heavily on your computer's hardware and the type of processing it is
+performing.;
+#X text 478 368 The [realtime] object is as much like your own wrist
+watch as PD can possibly manage. It measures time according to your
+operating system's internal clock.;
+#N canvas 0 0 454 304 related_objects_from_other_libraries 0;
+#X text 27 63 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 26 112 The best places to find information about PD's libraries
+is:;
+#X text 23 134 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 25 149 or;
+#X text 25 164 iem.kug.ac.at/pdb/;
+#X obj 44 24 t3_timer;
+#X text 469 589 This document was updated for PD version 0.35 test
+26 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X restore 505 476 pd related_objects_from_other_libraries;
+#X text 309 580 This document was updated for PD version 0.35 test
+28 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X text 11 232 The odd aspect about comparing [timer] to a stop-watch
+is that a stop-watch can be stopped! [timer] can only be started or
+reset. It cannot be stopped.;
+#X obj 625 445 metro;
+#X text 504 422 RELATED OBJECTS;
+#X obj 504 446 cputime;
+#X obj 562 445 realtime;
+#X text 132 501 3 Measures the amount of time PD requires count to
+three...please wait for approximately 3 seconds.;
+#X connect 0 0 2 1;
+#X connect 1 0 2 0;
+#X connect 2 0 4 0;
+#X connect 12 0 14 0;
+#X connect 12 1 15 0;
+#X connect 12 2 16 0;
+#X connect 13 0 12 0;
+#X connect 21 0 12 1;
+#X connect 25 0 24 0;
+#X connect 28 0 12 2;
diff --git a/doc/pddp/help-trigger.pd b/doc/pddp/help-trigger.pd
new file mode 100644
index 00000000..a5a10051
--- /dev/null
+++ b/doc/pddp/help-trigger.pd
@@ -0,0 +1,225 @@
+#N canvas 20 8 893 651 10;
+#X obj 26 16 trigger;
+#X text 26 45 The trigger object outputs its input from right to left
+\, converting to the types indicated by its creation arguments. There
+is also a "pointer" argument type (see the pointer object.);
+#X text 24 230 As I see it \, the [trigger] object serves two great
+purposes which aren't really related - but they might be on some level
+that I don't fully understand yet.;
+#X text 97 15 - sequence messages in right-to-left order and convert
+data types.;
+#X text 22 278 1 Sequence a series of bangs - or triggers for symbols
+and/or other messages. In the example below \, you should see that
+it is important that it is important that [metro] gets a tempo setting
+before it is started - but let's assume for a moment that you wanted
+to start the [metro] with only a single click.;
+#X obj 26 481 metro;
+#X msg 51 462 1000;
+#X obj 26 501 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 26 404 tgl 15 0 empty empty On/Off 0 -6 0 7 -262144 -1 -1 0
+1;
+#X text 20 364 Click the toggle to set the tempo and start the metro
+simoultaneously.;
+#X text 24 109 The [trigger] object can be abbreviated as "t" and the
+creation arguments can be abbreviated as follows:;
+#X text 25 135 Floats = f;
+#X text 25 147 Bangs = b;
+#X text 24 159 Symbols = s;
+#X text 25 173 Lists = l;
+#X text 25 201 Anythings = a;
+#X text 25 187 Pointers = p;
+#X obj 103 150 trigger float bang symbol list pointer anything;
+#X text 204 169 is the same as;
+#X obj 207 189 t f b s l p a;
+#X text 65 413 Triggers are sent from right to left...so our tempo
+messages gets sent to [metro] immediately before the numbers from the
+[toggle] to start and stop the [metro].;
+#X obj 26 422 t f b;
+#X text 27 526 This example is simple \, and may not be very practicle
+in most situations \, but it clearly shows how [trigger] can be used
+to create a simple sequence of events. It is important to note however
+that the messages sent from [trigger]'s outlets occur in ZERO time
+with no delay between the events...more at the top right of the page...
+;
+#X obj 430 94 t b b;
+#X msg 430 75 bang;
+#X obj 430 124 timer;
+#X floatatom 430 144 5 0 0;
+#X obj 399 34 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 399 600 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 428 40 Below is a simple structure which will measure the "logical
+time" between bangs from the [trigger] object.;
+#X text 464 75 Click here.;
+#X text 470 141 Watch here.;
+#X text 417 163 Now \, to prove that I'm not crazy...click here >;
+#X msg 705 162 bang;
+#X obj 705 203 timer;
+#X floatatom 705 222 5 0 0;
+#X obj 730 182 delay 2000;
+#X text 543 89 any delay between the first bang and the second bang
+;
+#X text 544 105 from the trigger.;
+#X text 415 179 In this case \, I've simply patched a delay;
+#X text 414 193 object to force a 2 second delay between the;
+#X text 414 207 first and second bangs sent to the [timer].;
+#X text 545 75 In this case \, the [timer] object does not perceive
+;
+#X text 417 290 2 Click this subpatch to read about [trigger]'s second
+great purpose...;
+#N canvas 148 20 927 612 trigger_can_convert_data_types 0;
+#X msg 425 103 2.5;
+#X msg 523 103 bang;
+#X msg 465 103 23 64;
+#X msg 569 103 symbol dog;
+#X obj 425 228 trigger float bang symbol list anything;
+#X text 24 24 All sophisticated programming environments provide tools
+to convert data types. For instance \, Visual Basic has:;
+#X text 24 55 - VarType: to check the data type.;
+#X text 24 70 - CStr: to convert a variable to a string.;
+#X text 23 84 - CDate: to convert a variable to a date.;
+#X text 24 99 - isNumeric: to test whether the variable is a number.
+;
+#X text 22 113 - etc.;
+#X text 19 137 [trigger] is one object in PD which can convert an incoming
+atom to a different type of atom.;
+#X text 422 30 In the example below \, you can see that this [trigger]
+has creation arguments which specify what data type the object should
+output through each outlet. Messages which are sent to the first outlet
+will be floats \; the second outlet will send bangs \; the third \,
+symbols \; etc.;
+#X text 19 172 To prove this \, click on each of the messages below
+and watch your terminal window for the output.;
+#X obj 20 239 t b;
+#X msg 20 210 bang;
+#X msg 57 210 1;
+#X floatatom 90 212 5 0 0;
+#X msg 132 211 symbol cat;
+#X msg 204 211 this is anything;
+#X obj 20 259 print all_messages_are_converted_to_bangs;
+#X text 20 292 Another example showing floats and symbols.;
+#X msg 20 308 bang;
+#X floatatom 90 310 5 0 0;
+#X msg 132 309 symbol cat;
+#X msg 206 319 this is anything;
+#X obj 20 337 t f s;
+#X msg 57 308 1 0;
+#X obj 45 387 print converted_to_symbols;
+#X obj 20 407 print converted_to_floats;
+#X text 62 338 Note that "this is anything" causes an error. That is
+because 'anythings' don't conform to floats \, symbols \, lists \,
+pointers. They can only be converted to "bang".;
+#X text 18 430 In the example above \, note that the trigger object
+does not split a list among the outlets like [unpack] does. Instead
+it sends all list elements through all outlets and converts them as
+necessary.;
+#X text 20 486 Also note that some messages don't convert as nicely
+as others. Hence \, the symbol "cat" converts to a ZERO when [trigger]
+converts that symbol into a float. Likewise \, all numbers will convert
+to a symbol called "float" when sent through [trigger]'s right-most
+outlet.;
+#X floatatom 425 248 5 0 0;
+#X obj 482 248 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X symbolatom 539 286 10 0 0;
+#X floatatom 594 162 5 0 0;
+#X obj 594 200 pack f s;
+#X msg 637 161 symbol earth;
+#X msg 652 181 symbol jupiter;
+#X obj 596 267 print a_list;
+#X floatatom 426 403 5 0 0;
+#X symbolatom 470 403 10 0 0;
+#X obj 514 421 print another_list;
+#X text 630 131 Click on all these.;
+#X obj 426 363 r anythings;
+#X text 425 303 Note how each of the messages sent to this trigger
+are converted appropriately for their receiving atoms boxes. Also note
+that "anythings" are sent to the example below.;
+#X text 430 447 I'e used the [route] object to show how "anythings"
+are converted as they pass through the above [trigger]. Note that all
+messages converted to floats are displayed here in the number box \,
+all symbols are displayed in the symbol box \, and all lists are printed
+to the terminal window.;
+#X obj 654 247 s anythings;
+#X obj 426 383 route float symbol list;
+#X msg 642 103 symbol cat;
+#X connect 0 0 4 0;
+#X connect 1 0 4 0;
+#X connect 2 0 4 0;
+#X connect 3 0 4 0;
+#X connect 4 0 33 0;
+#X connect 4 1 34 0;
+#X connect 4 2 35 0;
+#X connect 4 3 40 0;
+#X connect 4 4 48 0;
+#X connect 14 0 20 0;
+#X connect 15 0 14 0;
+#X connect 16 0 14 0;
+#X connect 17 0 14 0;
+#X connect 18 0 14 0;
+#X connect 19 0 14 0;
+#X connect 22 0 26 0;
+#X connect 23 0 26 0;
+#X connect 24 0 26 0;
+#X connect 25 0 26 0;
+#X connect 26 0 29 0;
+#X connect 26 1 28 0;
+#X connect 27 0 26 0;
+#X connect 36 0 37 0;
+#X connect 37 0 4 0;
+#X connect 38 0 37 1;
+#X connect 39 0 37 1;
+#X connect 45 0 49 0;
+#X connect 49 0 41 0;
+#X connect 49 1 42 0;
+#X connect 49 2 43 0;
+#X connect 50 0 4 0;
+#X restore 421 325 pd trigger_can_convert_data_types;
+#X obj 705 238 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X floatatom 785 164 5 0 0;
+#X text 415 227 You can reset the delay with the number box;
+#X text 415 241 at the top-right to clearly see "logical time";
+#X text 415 254 as measured by [timer].;
+#X text 459 579 This document was updated for PD version 0.35 test
+26 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X text 418 378 RELATED OBJECTS;
+#X obj 503 404 route;
+#X obj 423 404 unpack;
+#X obj 469 404 pack;
+#X obj 544 404 delay;
+#X obj 586 404 pipe;
+#X obj 621 404 float;
+#X obj 661 404 int;
+#X obj 690 404 symbol;
+#N canvas 0 0 456 306 related_objects_from_other_libraries 0;
+#X obj 31 36 exciter;
+#X text 26 77 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 25 126 The best places to find information about PD's libraries
+is:;
+#X text 22 148 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 24 163 or;
+#X text 24 178 iem.kug.ac.at/pdb/;
+#X restore 423 435 pd related_objects_from_other_libraries;
+#X connect 5 0 7 0;
+#X connect 6 0 5 1;
+#X connect 8 0 21 0;
+#X connect 21 0 5 0;
+#X connect 21 1 6 0;
+#X connect 23 0 25 1;
+#X connect 23 1 25 0;
+#X connect 24 0 23 0;
+#X connect 25 0 26 0;
+#X connect 27 0 28 0;
+#X connect 33 0 34 0;
+#X connect 33 0 36 0;
+#X connect 34 0 35 0;
+#X connect 35 0 45 0;
+#X connect 36 0 34 1;
+#X connect 46 0 36 1;
diff --git a/doc/pddp/help-unpack.pd b/doc/pddp/help-unpack.pd
new file mode 100644
index 00000000..29a3c299
--- /dev/null
+++ b/doc/pddp/help-unpack.pd
@@ -0,0 +1,49 @@
+#N canvas 18 16 471 443 10;
+#X floatatom 61 204 0 0 0;
+#X floatatom 186 204 0 0 0;
+#X floatatom 224 204 0 0 0;
+#X floatatom 27 204 0 0 0;
+#X obj 24 294 pack;
+#X obj 41 11 unpack;
+#X msg 27 126 1 2;
+#X msg 65 126 3 4 shut;
+#X msg 145 126 5 6 pick 7 8;
+#X text 90 11 - split a message into atoms;
+#X text 20 41 [unpack] takes lists of atoms and distributes them to
+its outlets. The creation arguments are used to specify the types of
+atoms expected in the incoming list and specify float (any number or
+the symbol 'f') \, pointer (symbol 'p') or symbol (symbol 's').;
+#X symbolatom 103 207 10 0 0;
+#X obj 27 163 unpack 0 0 s f f;
+#X text 23 268 RELATED OBJECTS;
+#X obj 61 294 trigger;
+#N canvas 0 0 452 302 related_objects_from_other_libraries 0;
+#X obj 21 16 pack~;
+#X obj 61 16 unpack~;
+#X obj 113 16 tabdump;
+#X obj 169 16 niagara;
+#X obj 224 16 packel;
+#X obj 21 42 repack;
+#X obj 70 42 drip;
+#X obj 107 42 sort;
+#X text 18 86 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 17 135 The best places to find information about PD's libraries
+is:;
+#X text 14 157 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 15 173 or;
+#X text 16 187 iem.kug.ac.at/pdb/;
+#X restore 24 333 pd related_objects_from_other_libraries;
+#X text 27 363 This document was updated for PD version 0.35 test 26
+by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X connect 6 0 12 0;
+#X connect 7 0 12 0;
+#X connect 8 0 12 0;
+#X connect 12 0 3 0;
+#X connect 12 1 0 0;
+#X connect 12 2 11 0;
+#X connect 12 3 1 0;
+#X connect 12 4 2 0;
diff --git a/doc/pddp/help-until.pd b/doc/pddp/help-until.pd
new file mode 100644
index 00000000..afb562cd
--- /dev/null
+++ b/doc/pddp/help-until.pd
@@ -0,0 +1,89 @@
+#N canvas 59 5 829 645 10;
+#X msg 28 525 bang;
+#X obj 25 13 until;
+#X obj 28 546 until;
+#X text 59 525 start;
+#X obj 28 568 f;
+#X obj 57 568 + 1;
+#X obj 103 570 sel 0;
+#X obj 28 612 print;
+#X obj 57 590 mod 10;
+#X text 19 42 Every modern programming language will have various "looping"
+mechanisms: either in the form of an object \, or as a data structure.
+For example in Visual Basic:;
+#X text 30 100 DO UNTIL i = 100;
+#X text 30 114 i = i + 1;
+#X text 31 85 i = 0;
+#X text 30 129 LOOP;
+#X text 15 210 And now PD's version of the above programming structures:
+;
+#X obj 24 257 until;
+#X msg 24 237 100;
+#X obj 24 277 print i;
+#X text 17 304 If you start [until] with a "bang" \, it will begin
+an infinite loop! Please plan ahead in this case so that there is a
+mechanism in place to stop the loop - otherwise PD will effectively
+freeze.;
+#X text 17 361 HOW TO FREEZE PD;
+#X msg 25 384 bang;
+#X obj 25 404 until;
+#X obj 25 424 print;
+#X text 63 384 DO NOT CLICK. DO NOT CLICK. DO NOT CLICK.;
+#X text 66 404 If you click \, click the "close window" (X) button
+on PD's terminal window - or reboot the computer.;
+#X text 17 145 OR:;
+#X text 29 161 FOR i = 0 TO 100;
+#X text 28 187 NEXT;
+#X text 29 175 ' do something;
+#X text 26 493 The example below includes a method to stop the loop
+to prevent PD from looping infinitely.;
+#X text 434 44 If you start [until] with a number \, it iterates that
+number of times. The [uzi] object in MAX works the same way.;
+#X obj 441 131 until;
+#X msg 441 84 100;
+#X obj 441 151 print i;
+#X msg 469 91 3;
+#X msg 497 98 42;
+#X text 26 451 The [until] object's left inlet starts a loop in which
+it outputs "bang" until its right inlet gets a "bang" which stops it.
+;
+#X obj 413 17 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 413 605 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 67 13 - LOOPing mechanism;
+#X text 442 580 This document was updated for PD version 0.35 test
+26 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X text 436 185 RELATED OBJECTS;
+#X text 441 204 ?? This author does not know of any other native looping
+mechanisms in PD.;
+#N canvas 0 0 452 302 related_objects_from_other_libraries 0;
+#X text 27 63 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 26 112 The best places to find information about PD's libraries
+is:;
+#X text 23 134 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 25 149 or;
+#X text 25 164 iem.kug.ac.at/pdb/;
+#X obj 43 32 for++;
+#X restore 449 244 pd related_objects_from_other_libraries;
+#X connect 0 0 2 0;
+#X connect 2 0 4 0;
+#X connect 4 0 5 0;
+#X connect 4 0 7 0;
+#X connect 5 0 8 0;
+#X connect 6 0 2 1;
+#X connect 8 0 4 1;
+#X connect 8 0 6 0;
+#X connect 15 0 17 0;
+#X connect 16 0 15 0;
+#X connect 20 0 21 0;
+#X connect 21 0 22 0;
+#X connect 31 0 33 0;
+#X connect 32 0 31 0;
+#X connect 34 0 31 0;
+#X connect 35 0 31 0;
+#X connect 37 0 38 0;
diff --git a/doc/pddp/help-value.pd b/doc/pddp/help-value.pd
new file mode 100644
index 00000000..22ad7a3f
--- /dev/null
+++ b/doc/pddp/help-value.pd
@@ -0,0 +1,102 @@
+#N canvas 1 1 889 657 10;
+#X text 62 10 -- nonlocal shared value (named variable);
+#X obj 21 10 value;
+#X text 17 46 [value] is a container. It holds a global variable numeric
+value and can be "polled" at any time with a "bang" message. In other
+words \, [value] is a place where numbers can be stored and then accessed
+by all active PD windows.;
+#X text 16 109 SCOPE;
+#X text 18 127 Understanding "scope" is important while developing
+programmatic applications. In PD there are three levels of "scope":
+;
+#X text 29 170 1 Local Scope: all objects \, subroutines \, data \,
+and variables which exist within a single patch on a single computer
+and do not communicate with other active PD patches.;
+#X text 27 226 2 Global Scope: all objects \, subroutines \, data and
+variables which exist within single or multiple patches on a single
+computer which communicate with other active PD patches.;
+#X text 17 354 As a general rule \, all things are considered "local"
+in PD and if communication between PD windows is necessary \, then
+[send]/[receive] \, or [throw]/[catch] objects are used. Likewise \,
+if communication is necessary between many computers running PD \,
+then objects such as [netsend]/[netreceive] are used.;
+#X text 16 441 The exception to the above rule is [value]. This object
+is a container which makes its data known to all [value] objects of
+the same name in all active PD windows on a single computer: hence
+\, GLOBAL scope.;
+#X text 28 288 3 Network (Universal) Scope: all objects \, subroutines
+\, data and variables which exist within single or multiple patches
+on two or more computers which communicate with other active PD patches
+via a network.;
+#X text 419 15 To create a [value] object \, a name should be defined
+for the variable that it will contain. For example:;
+#X obj 422 54 value my_variable;
+#X text 419 110 To assign a numeric value to that variable \, a number
+box or message can be used \, as follows:;
+#X obj 420 190 value my_variable;
+#X msg 438 167 42;
+#X text 12 523 The [value] object can be abbreviated as follows:;
+#X obj 19 550 v;
+#X text 48 550 is the same as;
+#X obj 142 552 value;
+#X obj 384 12 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X obj 384 583 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 417 77 If no name is given \, then the object will communicate
+with all other [value] objects with no name.;
+#X floatatom 420 214 5 0 0;
+#X floatatom 420 147 5 0 0;
+#X obj 417 304 value my_variable;
+#X floatatom 417 328 5 0 0;
+#X obj 417 284 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X text 464 146 play with me;
+#X text 463 166 or click me;
+#X text 416 237 Notice that the number is not outputted to the outlet
+\; it is merely stored. To retreive the number \, send a "bang" \,
+like below:;
+#X text 414 354 Now \, to show how global scope works \, click the
+sub-patch below and then "bang" the [value] object to retreive the
+current number. While you're in the sub-patch \, change the number
+and then return to this window and click the above "bang". You'll quickly
+see how this variable can be retreived or reset in any active PD window.
+;
+#N canvas 0 0 452 302 global_values 0;
+#X obj 43 127 v my_variable;
+#X floatatom 43 149 5 0 0;
+#X obj 43 86 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X floatatom 61 104 5 0 0;
+#X connect 0 0 1 0;
+#X connect 2 0 0 0;
+#X connect 3 0 0 0;
+#X restore 415 442 pd global_values;
+#X text 414 474;
+#X text 409 490 RELATED OBJECTS;
+#N canvas 73 229 452 302 related_objects_from_other_libraries 0;
+#X obj 28 37 getenv;
+#X text 18 86 These objects are offered in PD only if you have downloaded
+and properly installed the appropriate library. These objects may or
+may not exist in a single library.;
+#X text 17 135 The best places to find information about PD's libraries
+is:;
+#X text 14 157 www.pure-data.org and click on "Downloads" then "Software"
+;
+#X text 15 173 or;
+#X text 16 187 iem.kug.ac.at/pdb/;
+#X restore 413 551 pd related_objects_from_other_libraries;
+#X obj 408 517 send;
+#X obj 441 517 receive;
+#X text 492 504 These objects are actually quite different than [value]
+but it's important to understand that difference in relation to [value].
+;
+#X text 252 603 This document was updated for PD version 0.35 test
+26 by Dave Sabine as part of a project called pddp proposed by Krzysztof
+Czaja to build comprehensive documentation for PD.;
+#X connect 13 0 22 0;
+#X connect 14 0 13 0;
+#X connect 19 0 20 0;
+#X connect 23 0 13 0;
+#X connect 24 0 25 0;
+#X connect 26 0 24 0;
diff --git a/doc/pddp/midi-basics.pd b/doc/pddp/midi-basics.pd
new file mode 100644
index 00000000..0950d9a7
--- /dev/null
+++ b/doc/pddp/midi-basics.pd
@@ -0,0 +1,45 @@
+#N canvas 224 22 443 646 10;
+#X text 59 6 MIDI basics.;
+#X text 11 54 MIDI in PD is handled through the 'raw' midi devices
+(such as /dev/midi*). One could specify which MIDI port PD is supposed
+to use through a command line switch when starting PD \, i.e.:;
+#X text 35 126 pd -midiindev 1 -midioutdev 2;
+#X text 43 287 pd -mididev 1;
+#X text 17 315 This will use the first port for both MIDI input and
+output.;
+#X text 17 397 There is also a little bit of confusion about OSS midi
+(which uses the raw midi - /dev/midi* - devices by default) and ALSA
+(which is becoming very popular). ALSA uses /dev/snd/midiC*D* as their
+raw midi devices. The C* (* = some number) is the device number while
+D* (* = some number) is the port number. Normally the ALSA driver links
+its raw devices to the corresponding /dev/midi* automatically (i.e.:
+/dev/snd/midiC0d0 -> /dev/midi00 \, /dev/snd/midiC0D1 -> /dev/midi01
+etc).;
+#X text 13 150 so \, the above will use the first MIDI device for MIDI
+input (it could be a MIDI controller such as a keyboard \, midi-guitar
+\, midi knob box etc) and the device #2 will be used for outputting
+the MIDI (re)generated or sent by PD.;
+#X text 13 232 For using the same device for MIDI input AND output
+(i.e. when one uses a MIDI keyboard which is also a synthesizer) the
+following command line switch will do:;
+#X text 19 521 MIDI objects in PD (the ones that read and write to
+MIDI ports) take a MIDI channel as an argument. Channels 1-16 use the
+first MIDI device \, 17-32 use the second MIDI device and so on. For
+this to work one must specify which devices PD is supposed to use:
+;
+#X text 39 599 -midiindev 1 \, 2 -- use devices 1 and 2 for input;
+#X text 39 615 -midioutdev 1 \, 2 -- use devices 1 and 2 for output
+;
+#X text 39 631 -mididev 1 \, 2 -- use devices 1 and 2 for input and
+output;
+#X text 17 343 NOTE (Linux): PD counts the MIDI devices starting from
+1 Usually \, the operating system counts them starting with 0 (zero)
+so if you want to use /dev/midi00 \, PD has to be started with -mididev
+1 Always add 1 to the device number.;
+#X text 21 651 NOTE (Windows): -listdev command line option lists all
+available MIDI and audio devices.;
+#X text 19 678 A couple more useful command line options (related to
+MIDI):;
+#X text 21 694 -nomidiin -- do not listen to any midi input;
+#X text 21 706 -nomidiout -- do not send any midi output;
+#X text 21 718 -nomidi -- do not use any MIDI;
diff --git a/doc/pddp/pddp.pd b/doc/pddp/pddp.pd
new file mode 100644
index 00000000..787921e6
--- /dev/null
+++ b/doc/pddp/pddp.pd
@@ -0,0 +1,31 @@
+#N canvas 262 2 490 557 10;
+#X text 14 17 PDDP: Pure Data Documentation Project;
+#X text 25 40 The PDDP was proposed initially in early 2002 by Krzysztof
+Czaja who suggested that Pure Data was in need of comprehensive documentation.
+;
+#X text 45 162 - Michal Seta;
+#X text 45 135 - Miller Puckette;
+#X text 45 148 - Dave Sabine;
+#X text 25 89 The project is now managed un-officially by Dave Sabine
+who acts as primary author and editor. The people involved in this
+project include (alphabetically):;
+#X text 25 184 PDDP will eventually be available in the main PD distribution
+\, but for now is available at Dave's web site: http://www.davesabine.com/media/puredata.asp
+;
+#X text 25 231 All comments \, corrections \, etc. regarding the PDDP
+reference files should be directed to Dave Sabine: dave@davesabine.com
+;
+#X text 14 282 THINGS TO NOTE:;
+#X text 25 308 Authors: If you would like to participate in this project
+\, simply gather together information about objects \, tutorials \,
+examples \, etc. and contact Dave Sabine for info about formatting
+your documents. All documents should then be forwarded to Dave to be
+included in the PDDP download which is available at his web site.;
+#X text 25 396 Externals and other Libraries: Each PDDP document includes
+mention of "related objects from other PD libraries" as well as mention
+of "related native PD objects". The objects from other libraries are
+available only if you download those libraries from their respective
+authors and integrate them properly into your version of PD. We do
+not and cannot maintain a complete list of externals - but we try.
+For more info about externals and other objects \, see http://www.pure-data.org/
+and the Pure Data Base at http://iem.kug.ac.at/pdb/;
diff --git a/doc/pddp/time_measurements.pd b/doc/pddp/time_measurements.pd
new file mode 100644
index 00000000..19f1dbb2
--- /dev/null
+++ b/doc/pddp/time_measurements.pd
@@ -0,0 +1,65 @@
+#N canvas 289 74 815 597 12;
+#X obj 114 34 inlet;
+#X obj 424 31 inlet;
+#X obj 654 100 inlet;
+#X obj 319 494 outlet;
+#X obj 392 493 outlet;
+#X obj 480 493 outlet;
+#X obj 114 64 t b b;
+#X obj 37 134 timer;
+#X obj 104 135 cputime;
+#X obj 183 136 realtime;
+#X obj 299 62 osc~ 800;
+#X msg 424 87 1;
+#X msg 424 114 \; pd dsp \$1 \;;
+#X msg 369 94 0;
+#X obj 424 57 t b b;
+#X obj 312 251 timer;
+#X obj 379 252 cputime;
+#X obj 455 251 realtime;
+#X obj 298 86 env~;
+#X obj 298 110 > 0;
+#X obj 298 135 sel 1;
+#X obj 569 162 delay 3000;
+#X obj 654 132 t b b;
+#X obj 585 242 timer;
+#X obj 652 243 cputime;
+#X obj 728 242 realtime;
+#X connect 0 0 6 0;
+#X connect 1 0 14 0;
+#X connect 2 0 22 0;
+#X connect 6 0 7 1;
+#X connect 6 0 8 1;
+#X connect 6 0 9 1;
+#X connect 6 1 7 0;
+#X connect 6 1 8 0;
+#X connect 6 1 9 0;
+#X connect 7 0 3 0;
+#X connect 8 0 4 0;
+#X connect 9 0 5 0;
+#X connect 10 0 18 0;
+#X connect 11 0 12 0;
+#X connect 13 0 12 0;
+#X connect 14 0 11 0;
+#X connect 14 1 17 0;
+#X connect 14 1 16 0;
+#X connect 14 1 15 0;
+#X connect 15 0 3 0;
+#X connect 16 0 4 0;
+#X connect 17 0 5 0;
+#X connect 18 0 19 0;
+#X connect 19 0 20 0;
+#X connect 20 0 15 1;
+#X connect 20 0 16 1;
+#X connect 20 0 17 1;
+#X connect 20 0 13 0;
+#X connect 21 0 23 1;
+#X connect 21 0 24 1;
+#X connect 21 0 25 1;
+#X connect 22 0 21 0;
+#X connect 22 1 25 0;
+#X connect 22 1 24 0;
+#X connect 22 1 23 0;
+#X connect 23 0 3 0;
+#X connect 24 0 4 0;
+#X connect 25 0 5 0;