Examples
--------

This directory contains a number of subdirectories, each with a specific
example.
   * Example 1 : Contains a simple "FortuneCookie" protocol system. Includes
     a server and client as part of a single system.

   * Example 2 : This has much the same structure, but rather than serve
     and display fortune cookies, serves (ogg vorbis) audio over a TCP
     connection to a client which decodes and plays back the audio.

   * Example 3 : Splits the structure in example 2 into a specific server
     application and a client application. This puts the two halves at odds,
     *competing* with each other for CPU time. Thus if both are run on the
     same (single CPU) system you will hear audio breakage. If run on
     separate machines (as client and server(!)) you won't hear this. In
     practice, part of the issue is that there is no buffering in the
     receiver.

   * Example 4 : Simple multicast based streaming system. Since it uses raw
     ogg vorbis with no resends and no codebook facility, you will need to
     *start all the client machines first* and *then* the server.
     Uses the multicast transceiver object exclusively.

     Example 4a - MulticastStreamingSystem_SRM.py
     * This is a modification to the multicast streaming system that uses
       the SimpleReliableMulticast protocol, to add a thin skein of
       reliability over multicast. Passes basic lab tests, but needs real
       world testing to be certain.

   * Example 5 : An introspecting version of Examples 2/3. This creates a
     simple streaming system, and looks inside to see what components are
     running/active, and passes the resulting information over a network
     connection to an Axon Visualisation server.

   * Example 6 : This is a simple/generic topology visualisation server. The
     server listens on port 1500, and accepts the following commands:

     ADD NODE id label auto -
     ADD LINK id id
     DEL NODE id
     DEL ALL

     As this stands this is pretty useful, but that's pretty much everything
     it does like this.

   * Example 7 : This shows how the visualisation subsystem can be extended
     to work in different ways. What this does by default when run is
     randomly create new nodes and new linkages quite quickly, allowing you
     to see how the system works.

   * Example 8 : Sample slideshow/presentation tool. Unlike traditional
     slideshow/presentation tools, you can modify this to run arbitrary
     components. An example of how this can work is provided - allowing
     stepping through some graph visualisations along with the presentation.

   * Example 9 : Simple component based game using pygame. Not quite fully
     integrated with the other pygame code (will be), but fully reusable &
     reconfigurable code and it's a useful start for people wanting to see
     how to write things varying from games through other interactive
     systems.

     * Simple bouncing images game. Designed for very small children who are
       amused by things take beep and react when you press left/right mouse
       buttons.
     * Forms a demonstration of the new BasicSprite and SpriteScheduler
       components, along with the associated EventHandler code, which is a
       substantial subsystem. Shutdown of active bouncing sprites and their
       associated components controlling them is controlled by a fanout
       component. Also contains a nice demonstration of the flexibility of
       Graphline

   * Example 10: Simple dirac player. Shows how to play a specific file.

   * Examples 11 - Ticker.py
     * Simple example showing how to use the ticker. First developed for
       showing subtitles.

   * Example 12 - SimpleMultiFileStreamer.py
     * Simple streamer that repeatedly streams (3 times) the same audio
       file.
     * This is a mainly a demonstration of how to use the
       JoinChooserToCarousel Chassis, and the
       FixedRateControlledReusableFileReader
     * What really happens is a "chooser" takes a playlist of things to
       serve, and the filereader asks the chooser what file it should be
       reading next when it finishes reading a file.

     Examples 12 -- ClientStreamToFile.py
     * Simple client for the above streamer


Updated: Michael, October 2005
