Foxdot

- Improved behaviour of `TimeVar`, `Pvar`, and `PvarGenerator` classes when created via mathematical operators.
- SynthDefs can be read loaded into FoxDot from SuperCollider using the `FileSynthDef` and `CompiledSynthDef` classes (see `SynthDef.py`).
- `DefaultServer` instance has a `forward` attribute that, when not `None`, sends any outgoing OSC message to. Example:
python
Sends any OSC message going to SuperCollider to the address
DefaultServer.forward = OSCClient(("localhost", 57890))

- Adding values to a player performs the whole operation as opposed to adding each value in turn when the Player is called. This improves efficiency when using data structures such as `TimeVar`s as it only creates a new once `TimeVar` when the addition is done.
- Improved usability of `PlayerKey` class, accessed when get the attribute of a Player e.g. `p1.degree`.
- Sleep time set to small value. 0 sleep time would crash FoxDot on startup on some systems.
- Made the behaviour of the `every` method more consistent rather than just starting the cycle at the next bar.

- Pattern "zipping" behaviour changed. A `PGroup` within a sequence is extended when zipped with another instead of nesting it. e.g.
python
Old style
>>> P[(0,1),(2,3)].zip([(4,5)])
P[P(0, 1, P(4, 5)), P(2, 3, P(4, 5))]
New style
>>> P[(0,1),(2,3)].zip([(4,5)])
P[P(0, 1, 4, 5), P(2, 3, 4, 5)]

- Consequently, sample player strings can use the `<>` arrows to play multiple sequences together using one string.
python
This plays three patterns together
d1 >> play("<x >< o[ o]>< -(-=)>", sample=(0,1,2))

- To use a different sample value for each pattern use a group of values as in the example above. Each value in relates to each pattern e.g. the "x" used sample 0, the "o" pattern uses sample 1 and the "-" pattern uses sample 2. If you want to use multiple values just use a group within a group:

Plays the snare drum in both channels at different rates
d1 >> play("<x x>< o >", pan=(0, (-1,1)), rate=(1, (1,.9))

- Network synchronisation introduced! This is still quite a beta feature and feedback would be appreciated if you come across any issues. Here's how to do it:

To connect to another instance of FoxDot over the network you need one user to be the master clock. The master clock user needs to go from the menu to "Language" then "Listen for connections". This will start listening for connections from other FoxDot instances. It will print the IP address and port number to the console; give this information to your live coding partner. They need to run the following code using the IP address on the master clock machine:
python
Clock.connect("<ip address>")

This will copy some data, e.g. tempo, from the master clock and also adjust for the differences in local machine time (if your clocks are out of sync). The latter will depend on the latency of the connection between your machines. If you are out of time slightly, set the `Clock.nudge` value to a small value (+-0.01) until the clocks are in sync. Now whenever you change the `Clock.bpm` value, the change will propagate to everyone on the next bar.

- Pattern getitem method now allows Patterns to be indexed using a Player Key e.g. `P[0,1,2,3][p1.degree]` that will return the item in the Pattern based on the integer values of the key (`p1.degree` in this example).
- Added `future` method. Like `schedule` it adds a callable object to the queue but doesn't need the exact beat occurrence, just how many beats in the future from "now". First argument is time, followed by the object, arguments, and keyword arguments.
- Player object `stop` method properly removes the player from `Clock.playing` list.
- Using Player Key `__getitem__` returns a player key whose calculation function is `__getitem__`. This is useful if you want to use just one of the values of another player if they are in a group. e.g.

python
p1 >> pads((0,2,4) + var([0,4,5,3]))
b1 >> bass(p1.degree[0]) Only plays the "root" note of the chord


- SuperCollider bus number resets to 4 instead of 1 to prevent feedback loops when using reverb.
- Changed "verb" keyword to "mix" for reverb effect. Default is changed from 0.25 to 0.1.
- `GeneratorPattern` `new` method converts the `other` argument to a Pattern so you can use lists/tuples as opposed to just Patterns/PGroups when performing operations e.g. `PWalk() + (0,4)`.
- Fixed `newline` method to only add an indent if the INSERT index was in brackets or following a colon instead of doing so if the line had open brackets / colon. Evaluated code no longer highlights any empty preceeding lines.
- Python 3 uses xrange as range

- Moved demo files into main package to fix install from pip.

- `Player.stop_calling` is now `Player.never`. If a `Player` is calling its own method (implemented by the `every` method e.g. `p1 >> pads().every(4, "reverse")` you can now stop the repeated call by using `p1.never("reverse")`.
- Fixed circular referencing bug when using PGroups e.g. `p1 >> pads(p1.degree + (0,4))`
- Window transparency can now be toggled from the "Edit" menu
- Added Tutorial files that can be loaded from the menu
- Multiple uses of the `every` method with the same method name can be used together by specifying an `ident` keyword, which can be any hashable value i.e. a string or integer.

python
The second "stutter" no longer overrides the first
d1 >> play("x-u-").every(8, "stutter", 8).every(3, "stutter", 4, dur=1, degree="y", ident=1)


- Fix `group_modi` function to test for `TimeVar` instances instead of trying and failing to index their contents so that `TimeVar`s with strings in their contents don't get into an infinite recursive call.