picrate 0.9.0-java → 1.0.0-java

data/src/main/java/monkstone/videoevent/CaptureEvent.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2015-19 Martin Prout
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * http://creativecommons.org/licenses/LGPL/2.1/
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package monkstone.videoevent;
+import processing.video.Capture;
+
+@FunctionalInterface
+public interface CaptureEvent{
+    public void captureEvent(Capture capture);
+}

data/src/main/java/monkstone/videoevent/{VideoInterface.java → MovieEvent.java}

@@ -1,42 +1,32 @@
-/* 
- * Copyright (c) 2018-19 Martin Prout
- * 
+/*
+ * Copyright (c) 2015-19 Martin Prout
+ *
  * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
+ * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
- * version 3.0 of the License, or (at your option) any later version.
- * 
+ * version 2.1 of the License, or (at your option) any later version.
+ *
  * http://creativecommons.org/licenses/LGPL/2.1/
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU General Public
+ *
+ * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
 package monkstone.videoevent;
 import processing.video.Movie;
-import processing.video.Capture;
+
 /**
  * This interface makes it easier/possible to use the reflection methods
- * from Movie and Capture classes in Processing::App in picrate
- *
+ * from Movie and Capture classes in Processing::App in JRubyArt
+ * @author Martin Prout
  */
-public interface VideoInterface {
-    /**
-     * Used to implement reflection method in PApplet
-     * @see processing.video.Movie
-     * @param movie Movie
-     */
+@FunctionalInterface
+public interface MovieEvent {
     public void movieEvent(Movie movie);
-    /**
-     * Used to implement reflection method in PApplet
-     * @see processing.video.Capture
-     * @param capture Capture
-     */
-    public void captureEvent(Capture capture);    
 }

data/src/main/java/processing/net/Client.java

@@ -1,6 +1,6 @@
 /* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
 
- /*
+/*
   Client - basic network client implementation
   Part of the Processing project - http://processing.org
 
@@ -21,736 +21,724 @@
   Public License along with this library; if not, write to the
   Free Software Foundation, Inc., 59 Temple Place, Suite 330,
   Boston, MA  02111-1307  USA
- */
+*/
+
 package processing.net;
+import processing.core.*;
 
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.net.Socket;
-import java.net.SocketException;
-import processing.core.PApplet;
+import java.io.*;
+import java.lang.reflect.*;
+import java.net.*;
 
 /**
- * ( begin auto-generated from Client.xml )
- *
- * A client connects to a server and sends data back and forth. If anything goes
- * wrong with the connection, for example the host is not there or is listening
- * on a different port, an exception is thrown.
- *
- * ( end auto-generated )
- *
+   * ( begin auto-generated from Client.xml )
+   * 
+   * A client connects to a server and sends data back and forth. If anything 
+   * goes wrong with the connection, for example the host is not there or is 
+   * listening on a different port, an exception is thrown.
+   * 
+   * ( end auto-generated )
  * @webref net
- * @brief The client class is used to create client Objects which connect to a
- * server to exchange data.
+ * @brief The client class is used to create client Objects which connect to a server to exchange data. 
  * @instanceName client any variable of type Client
  * @usage Application
  * @see_external LIB_net/clientEvent
  */
 public class Client implements Runnable {
 
-    protected static final int MAX_BUFFER_SIZE = 1 << 27; // 128 MB
-
-    PApplet parent;
-    Method clientEventMethod;
-    Method disconnectEventMethod;
-
-    volatile Thread thread;
-    Socket socket;
-    int port;
-    String host;
-
-    public InputStream input;
-    public OutputStream output;
-
-    final Object bufferLock = new Object[0];
-
-    byte buffer[] = new byte[32768];
-    int bufferIndex;
-    int bufferLast;
-
-    boolean disposeRegistered = false;
-
-    /**
-     * @param parent typically use "this"
-     * @param host address of the server
-     * @param port port to read/write from on the server
-     */
-    public Client(PApplet parent, String host, int port) {
-        this.parent = parent;
-        this.host = host;
-        this.port = port;
-
-        try {
-            socket = new Socket(this.host, this.port);
-            input = socket.getInputStream();
-            output = socket.getOutputStream();
-
-            thread = new Thread(this);
-            thread.start();
-
-            parent.registerMethod("dispose", this);
-            disposeRegistered = true;
-
-            // reflection to check whether host sketch has a call for
-            // public void clientEvent(processing.net.Client)
-            // which would be called each time an event comes in
-            try {
-                clientEventMethod
-                        = parent.getClass().getMethod("clientEvent", Client.class);
-            } catch (NoSuchMethodException | SecurityException e) {
-                // no such method, or an error.. which is fine, just ignore
-            }
-            // do the same for disconnectEvent(Client c);
-            try {
-                disconnectEventMethod
-                        = parent.getClass().getMethod("disconnectEvent", Client.class);
-            } catch (NoSuchMethodException | SecurityException e) {
-                // no such method, or an error.. which is fine, just ignore
-            }
-
-        } catch (IOException e) {
-            dispose();
-        }
+  protected static final int MAX_BUFFER_SIZE = 1 << 27; // 128 MB
+
+  PApplet parent;
+  Method clientEventMethod;
+  Method disconnectEventMethod;
+
+  volatile Thread thread;
+  Socket socket;
+  int port;
+  String host;
+
+  public InputStream input;
+  public OutputStream output;
+
+  final Object bufferLock = new Object[0];
+
+  byte buffer[] = new byte[32768];
+  int bufferIndex;
+  int bufferLast;
+
+  boolean disposeRegistered = false;
+  
+  
+  /**
+   * @param parent typically use "this"
+   * @param host address of the server
+   * @param port port to read/write from on the server
+   */
+  public Client(PApplet parent, String host, int port) {
+    this.parent = parent;
+    this.host = host;
+    this.port = port;
+
+    try {
+      socket = new Socket(this.host, this.port);
+      input = socket.getInputStream();
+      output = socket.getOutputStream();
+
+      thread = new Thread(this);
+      thread.start();
+
+      parent.registerMethod("dispose", this);
+      disposeRegistered = true;
+
+      // reflection to check whether host sketch has a call for
+      // public void clientEvent(processing.net.Client)
+      // which would be called each time an event comes in
+      try {
+        clientEventMethod =
+          parent.getClass().getMethod("clientEvent", Client.class);
+      } catch (Exception e) {
+        // no such method, or an error.. which is fine, just ignore
+      }
+      // do the same for disconnectEvent(Client c);
+      try {
+        disconnectEventMethod =
+          parent.getClass().getMethod("disconnectEvent", Client.class);
+      } catch (Exception e) {
+        // no such method, or an error.. which is fine, just ignore
+      }
+
+    } catch (IOException e) {
+      e.printStackTrace();
+      dispose();
     }
-
-    /**
-     * @param socket any object of type
-     * @param parent
-     * @throws IOException
-     */
-    public Client(PApplet parent, Socket socket) throws IOException {
-        this.parent = parent;
-        this.socket = socket;
-
-        input = socket.getInputStream();
-        output = socket.getOutputStream();
-
-        thread = new Thread(this);
-        thread.start();
-
-        // reflection to check whether host sketch has a call for
-        // public void clientEvent(processing.net.Client)
-        // which would be called each time an event comes in
-        try {
-            clientEventMethod
-                    = parent.getClass().getMethod("clientEvent", Client.class);
-        } catch (NoSuchMethodException | SecurityException e) {
-            // no such method, or an error.. which is fine, just ignore
-        }
-        // do the same for disconnectEvent(Client c);
-        try {
-            disconnectEventMethod
-                    = parent.getClass().getMethod("disconnectEvent", Client.class);
-        } catch (NoSuchMethodException | SecurityException e) {
-            // no such method, or an error.. which is fine, just ignore
-        }
+  }
+
+  
+  /**
+   * @param socket any object of type Socket
+   * @throws IOException
+   */
+  public Client(PApplet parent, Socket socket) throws IOException {
+    this.parent = parent;
+    this.socket = socket;
+
+    input = socket.getInputStream();
+    output = socket.getOutputStream();
+
+    thread = new Thread(this);
+    thread.start();
+
+    // reflection to check whether host sketch has a call for
+    // public void clientEvent(processing.net.Client)
+    // which would be called each time an event comes in
+    try {
+      clientEventMethod =
+          parent.getClass().getMethod("clientEvent", Client.class);
+    } catch (Exception e) {
+      // no such method, or an error.. which is fine, just ignore
     }
-
-    /**
-     * ( begin auto-generated from Client_stop.xml )
-     *
-     * Disconnects from the server. Use to shut the connection when you're
-     * finished with the Client.
-     *
-     * ( end auto-generated )
-     *
-     * @webref client:client
-     * @brief Disconnects from the server
-     * @usage application
-     */
-    public void stop() {
-        if (disconnectEventMethod != null && thread != null) {
-            try {
-                disconnectEventMethod.invoke(parent, this);
-            } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
-                Throwable cause = e;
-                // unwrap the exception if it came from the user code
-                if (e instanceof InvocationTargetException && e.getCause() != null) {
-                    cause = e.getCause();
-                }
-                disconnectEventMethod = null;
-            }
-        }
-        if (disposeRegistered) {
-            parent.unregisterMethod("dispose", this);
-            disposeRegistered = false;
-        }
-        dispose();
+    // do the same for disconnectEvent(Client c);
+    try {
+      disconnectEventMethod =
+        parent.getClass().getMethod("disconnectEvent", Client.class);
+    } catch (Exception e) {
+      // no such method, or an error.. which is fine, just ignore
     }
-
-    /**
-     * Disconnect from the server: internal use only.
-     * <P>
-     * This should only be called by the internal functions in PApplet, use
-     * stop() instead from within your own applets.
-     */
-    public void dispose() {
-        thread = null;
-        try {
-            if (input != null) {
-                input.close();
-                input = null;
-            }
-        } catch (IOException e) {
-        }
-
-        try {
-            if (output != null) {
-                output.close();
-                output = null;
-            }
-        } catch (IOException e) {
-        }
-
-        try {
-            if (socket != null) {
-                socket.close();
-                socket = null;
-            }
-        } catch (IOException e) {
+  }
+
+
+  /**
+   * ( begin auto-generated from Client_stop.xml )
+   * 
+   * Disconnects from the server. Use to shut the connection when you're 
+   * finished with the Client.
+   * 
+   * ( end auto-generated )
+   * @webref client:client
+   * @brief Disconnects from the server
+   * @usage application
+   */
+  public void stop() {    
+    if (disconnectEventMethod != null && thread != null){
+      try {
+        disconnectEventMethod.invoke(parent, this);
+      } catch (Exception e) {
+        Throwable cause = e;
+        // unwrap the exception if it came from the user code
+        if (e instanceof InvocationTargetException && e.getCause() != null) {
+          cause = e.getCause();
         }
+        cause.printStackTrace();
+        disconnectEventMethod = null;
+      }
     }
-
-    @Override
-    public void run() {
-        byte[] readBuffer;
-        { // make the read buffer same size as socket receive buffer so that
-            // we don't waste cycles calling listeners when there is more data waiting
-            int readBufferSize = 1 << 16; // 64 KB (default socket receive buffer size)
-            try {
-                readBufferSize = socket.getReceiveBufferSize();
-            } catch (SocketException ignore) {
-            }
-            readBuffer = new byte[readBufferSize];
-        }
-        while (Thread.currentThread() == thread) {
-            try {
-                while (input != null) {
-                    int readCount;
-
-                    // try to read a byte using a blocking read. 
-                    // An exception will occur when the sketch is exits.
-                    try {
-                        readCount = input.read(readBuffer, 0, readBuffer.length);
-                    } catch (SocketException e) {
-                        System.err.println("Client SocketException: " + e.getMessage());
-                        // the socket had a problem reading so don't try to read from it again.
-                        stop();
-                        return;
-                    }
-
-                    // read returns -1 if end-of-stream occurs (for example if the host disappears)
-                    if (readCount == -1) {
-                        System.err.println("Client got end-of-stream.");
-                        stop();
-                        return;
-                    }
-
-                    synchronized (bufferLock) {
-                        int freeBack = buffer.length - bufferLast;
-                        if (readCount > freeBack) {
-                            // not enough space at the back
-                            int bufferLength = bufferLast - bufferIndex;
-                            byte[] targetBuffer = buffer;
-                            if (bufferLength + readCount > buffer.length) {
-                                // can't fit even after compacting, resize the buffer
-                                // find the next power of two which can fit everything in
-                                int newSize = Integer.highestOneBit(bufferLength + readCount - 1) << 1;
-                                if (newSize > MAX_BUFFER_SIZE) {
-                                    // buffer is full because client is not reading (fast enough)
-                                    System.err.println("Client: can't receive more data, buffer is full. "
-                                            + "Make sure you read the data from the client.");
-                                    stop();
-                                    return;
-                                }
-                                targetBuffer = new byte[newSize];
-                            }
-                            // compact the buffer (either in-place or into the new bigger buffer)
-                            System.arraycopy(buffer, bufferIndex, targetBuffer, 0, bufferLength);
-                            bufferLast -= bufferIndex;
-                            bufferIndex = 0;
-                            buffer = targetBuffer;
-                        }
-                        // copy all newly read bytes into the buffer
-                        System.arraycopy(readBuffer, 0, buffer, bufferLast, readCount);
-                        bufferLast += readCount;
-                    }
-
-                    // now post an event
-                    if (clientEventMethod != null) {
-                        try {
-                            clientEventMethod.invoke(parent, this);
-                        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
-                            System.err.println("error, disabling clientEvent() for " + host);
-                            Throwable cause = e;
-                            // unwrap the exception if it came from the user code
-                            if (e instanceof InvocationTargetException && e.getCause() != null) {
-                                cause = e.getCause();
-                            }
-                            clientEventMethod = null;
-                        }
-                    }
-                }
-            } catch (IOException e) {
-                //errorMessage("run", e);
-
-            }
-        }
+    if (disposeRegistered) {
+      parent.unregisterMethod("dispose", this);
+      disposeRegistered = false;
     }
-
-    /**
-     * ( begin auto-generated from Client_active.xml )
-     *
-     * Returns true if this client is still active and hasn't run into any
-     * trouble.( end auto-generated )
-     *
-     *
-     * @return
-     * @webref client:client
-     * @brief Returns true if this client is still active
-     * @usage application
-     */
-    public boolean active() {
-        return (thread != null);
+    dispose();
+  }
+
+
+  /**
+   * Disconnect from the server: internal use only.
+   * <P>
+   * This should only be called by the internal functions in PApplet,
+   * use stop() instead from within your own applets.
+   */
+  public void dispose() {
+    thread = null;
+    try {
+      if (input != null) {
+        input.close();
+        input = null;
+      }
+    } catch (Exception e) {
+      e.printStackTrace();
     }
 
-    /**
-     * ( begin auto-generated from Client_ip.xml )
-     *
-     * Returns the IP address of the computer to which the Client is attached.(
-     * end auto-generated )
-     *
-     *
-     * @return
-     * @webref client:client
-     * @usage application
-     * @brief Returns the IP address of the machine as a String
-     */
-    public String ip() {
-        if (socket != null) {
-            return socket.getInetAddress().getHostAddress();
-        }
-        return null;
+    try {
+      if (output != null) {
+        output.close();
+        output = null;
+      }
+    } catch (Exception e) {
+      e.printStackTrace();
     }
-
-    /**
-     * ( begin auto-generated from Client_available.xml )
-     *
-     * Returns the number of bytes available.When any client has bytes available
-     * from the server, it returns the number of bytes. ( end auto-generated )
-     *
-     * @return
-     * @webref client:client
-     * @usage application
-     * @brief Returns the number of bytes in the buffer waiting to be read
-     */
-    public int available() {
-        synchronized (bufferLock) {
-            return (bufferLast - bufferIndex);
-        }
+    
+    try {
+      if (socket != null) {
+        socket.close();
+        socket = null;
+      }
+    } catch (Exception e) {
+      e.printStackTrace();
     }
-
-    /**
-     * ( begin auto-generated from Client_clear.xml )
-     *
-     * Empty the buffer, removes all the data stored there.
-     *
-     * ( end auto-generated )
-     *
-     * @webref client:client
-     * @usage application
-     * @brief Clears the buffer
-     */
-    public void clear() {
-        synchronized (bufferLock) {
-            bufferLast = 0;
-            bufferIndex = 0;
-        }
+  }
+
+
+  @Override
+  public void run() {
+    byte[] readBuffer;
+    { // make the read buffer same size as socket receive buffer so that
+      // we don't waste cycles calling listeners when there is more data waiting
+      int readBufferSize = 1 << 16; // 64 KB (default socket receive buffer size)
+      try {
+        readBufferSize = socket.getReceiveBufferSize();
+      } catch (SocketException ignore) { }
+      readBuffer = new byte[readBufferSize];
     }
-
-    /**
-     * ( begin auto-generated from Client_read.xml )
-     *
-     * Returns a number between 0 and 255 for the next byte that's waiting in
-     * the buffer.Returns -1 if there is no byte, although this should be
-     * avoided by first cheacking <b>available()</b> to see if any data is
-     * available. ( end auto-generated )
-     *
-     * @return
-     * @webref client:client
-     * @usage application
-     * @brief Returns a value from the buffer
-     */
-    public int read() {
-        synchronized (bufferLock) {
-            if (bufferIndex == bufferLast) {
-                return -1;
+    while (Thread.currentThread() == thread) {
+      try {
+        while (input != null) {
+          int readCount;
+
+          // try to read a byte using a blocking read. 
+          // An exception will occur when the sketch is exits.
+          try {
+            readCount = input.read(readBuffer, 0, readBuffer.length);
+          } catch (SocketException e) {
+             System.err.println("Client SocketException: " + e.getMessage());
+             // the socket had a problem reading so don't try to read from it again.
+             stop();
+             return;
+          }
+        
+          // read returns -1 if end-of-stream occurs (for example if the host disappears)
+          if (readCount == -1) {
+            System.err.println("Client got end-of-stream.");
+            stop();
+            return;
+          }
+
+          synchronized (bufferLock) {
+            int freeBack = buffer.length - bufferLast;
+            if (readCount > freeBack) {
+              // not enough space at the back
+              int bufferLength = bufferLast - bufferIndex;
+              byte[] targetBuffer = buffer;
+              if (bufferLength + readCount > buffer.length) {
+                // can't fit even after compacting, resize the buffer
+                // find the next power of two which can fit everything in
+                int newSize = Integer.highestOneBit(bufferLength + readCount - 1) << 1;
+                if (newSize > MAX_BUFFER_SIZE) {
+                  // buffer is full because client is not reading (fast enough)
+                  System.err.println("Client: can't receive more data, buffer is full. " +
+                                         "Make sure you read the data from the client.");
+                  stop();
+                  return;
+                }
+                targetBuffer = new byte[newSize];
+              }
+              // compact the buffer (either in-place or into the new bigger buffer)
+              System.arraycopy(buffer, bufferIndex, targetBuffer, 0, bufferLength);
+              bufferLast -= bufferIndex;
+              bufferIndex = 0;
+              buffer = targetBuffer;
             }
+            // copy all newly read bytes into the buffer
+            System.arraycopy(readBuffer, 0, buffer, bufferLast, readCount);
+            bufferLast += readCount;
+          }
 
-            int outgoing = buffer[bufferIndex++] & 0xff;
-            if (bufferIndex == bufferLast) {  // rewind
-                bufferIndex = 0;
-                bufferLast = 0;
+          // now post an event
+          if (clientEventMethod != null) {
+            try {
+              clientEventMethod.invoke(parent, this);
+            } catch (Exception e) {
+              System.err.println("error, disabling clientEvent() for " + host);
+              Throwable cause = e;
+              // unwrap the exception if it came from the user code
+              if (e instanceof InvocationTargetException && e.getCause() != null) {
+                cause = e.getCause();
+              }
+              cause.printStackTrace();
+              clientEventMethod = null;
             }
-            return outgoing;
+          }
         }
+      } catch (IOException e) {
+        //errorMessage("run", e);
+        e.printStackTrace();
+      }
     }
-
-    /**
-     * ( begin auto-generated from Client_readChar.xml )
-     *
-     * Returns the next byte in the buffer as a char.Returns -1 or 0xffff if
-     * nothing is there. ( end auto-generated )
-     *
-     * @return
-     * @webref client:client
-     * @usage application
-     * @brief Returns the next byte in the buffer as a char
-     */
-    public char readChar() {
-        synchronized (bufferLock) {
-            if (bufferIndex == bufferLast) {
-                return (char) (-1);
-            }
-            return (char) read();
-        }
+  }
+
+
+  /**
+   * ( begin auto-generated from Client_active.xml )
+   * 
+   * Returns true if this client is still active and hasn't run
+   * into any trouble.
+   * 
+   * ( end auto-generated )
+   * @webref client:client
+   * @brief Returns true if this client is still active
+   * @usage application
+   */
+  public boolean active() {
+    return (thread != null);
+  }
+
+
+  /**
+   * ( begin auto-generated from Client_ip.xml )
+   * 
+   * Returns the IP address of the computer to which the Client is attached.
+   * 
+   * ( end auto-generated )
+   * @webref client:client
+   * @usage application
+   * @brief Returns the IP address of the machine as a String
+   */
+  public String ip() {
+    if (socket != null){
+      return socket.getInetAddress().getHostAddress();
     }
-
-    /**
-     * ( begin auto-generated from Client_readBytes.xml )
-     *
-     * Reads a group of bytes from the buffer.The version with no parameters
-     * returns a byte array of all data in the buffer. This is not efficient,
-     * but is easy to use. The version with the <b>byteBuffer</b> parameter is
-     * more memory and time efficient. It grabs the data in the buffer and puts
-     * it into the byte array passed in and returns an int value for the number
-     * of bytes read. If more bytes are available than can fit into the
-     * <b>byteBuffer</b>, only those that fit are read.
-     *
-     * ( end auto-generated )
-     * <h3>Advanced</h3>
-     * Return a byte array of anything that's in the serial buffer. Not
-     * particularly memory/speed efficient, because it creates a byte array on
-     * each read, but it's easier to use than readBytes(byte b[]) (see below).
-     *
-     * @return
-     * @webref client:client
-     * @usage application
-     * @brief Reads everything in the buffer
-     */
-    public byte[] readBytes() {
-        synchronized (bufferLock) {
-            if (bufferIndex == bufferLast) {
-                return null;
-            }
-
-            int length = bufferLast - bufferIndex;
-            byte outgoing[] = new byte[length];
-            System.arraycopy(buffer, bufferIndex, outgoing, 0, length);
-
-            bufferIndex = 0;  // rewind
-            bufferLast = 0;
-            return outgoing;
-        }
+    return null;
+  }
+
+
+  /**
+   * ( begin auto-generated from Client_available.xml )
+   * 
+   * Returns the number of bytes available. When any client has bytes 
+   * available from the server, it returns the number of bytes.
+   * 
+   * ( end auto-generated )
+   * @webref client:client
+   * @usage application
+   * @brief Returns the number of bytes in the buffer waiting to be read
+   */
+  public int available() {
+    synchronized (bufferLock) {
+      return (bufferLast - bufferIndex);
     }
-
-    /**
-     * <h3>Advanced</h3>
-     * Return a byte array of anything that's in the serial buffer up to the
-     * specified maximum number of bytes. Not particularly memory/speed
-     * efficient, because it creates a byte array on each read, but it's easier
-     * to use than readBytes(byte b[]) (see below).
-     *
-     * @param max the maximum number of bytes to read
-     * @return
-     */
-    public byte[] readBytes(int max) {
-        synchronized (bufferLock) {
-            if (bufferIndex == bufferLast) {
-                return null;
-            }
-
-            int length = bufferLast - bufferIndex;
-            if (length > max) {
-                length = max;
-            }
-            byte outgoing[] = new byte[length];
-            System.arraycopy(buffer, bufferIndex, outgoing, 0, length);
-
-            bufferIndex += length;
-            if (bufferIndex == bufferLast) {
-                bufferIndex = 0;  // rewind
-                bufferLast = 0;
-            }
-
-            return outgoing;
-        }
+  }
+
+
+  /**
+   * ( begin auto-generated from Client_clear.xml )
+   * 
+   * Empty the buffer, removes all the data stored there.
+   * 
+   * ( end auto-generated )
+   * @webref client:client
+   * @usage application
+   * @brief Clears the buffer
+   */
+  public void clear() {
+    synchronized (bufferLock) {
+      bufferLast = 0;
+      bufferIndex = 0;
     }
-
-    /**
-     * <h3>Advanced</h3>
-     * Grab whatever is in the serial buffer, and stuff it into a byte buffer
-     * passed in by the user. This is more memory/time efficient than
-     * readBytes() returning a byte[] array.
-     *
-     * Returns an int for how many bytes were read. If more bytes are available
-     * than can fit into the byte array, only those that will fit are read.
-     *
-     * @param bytebuffer passed in byte array to be altered
-     * @return
-     */
-    public int readBytes(byte bytebuffer[]) {
-        synchronized (bufferLock) {
-            if (bufferIndex == bufferLast) {
-                return 0;
-            }
-
-            int length = bufferLast - bufferIndex;
-            if (length > bytebuffer.length) {
-                length = bytebuffer.length;
-            }
-            System.arraycopy(buffer, bufferIndex, bytebuffer, 0, length);
-
-            bufferIndex += length;
-            if (bufferIndex == bufferLast) {
-                bufferIndex = 0;  // rewind
-                bufferLast = 0;
-            }
-            return length;
-        }
+  }
+
+
+  /**
+   * ( begin auto-generated from Client_read.xml )
+   * 
+   * Returns a number between 0 and 255 for the next byte that's waiting in 
+   * the buffer. Returns -1 if there is no byte, although this should be 
+   * avoided by first cheacking <b>available()</b> to see if any data is available.
+   * 
+   * ( end auto-generated )
+   * @webref client:client
+   * @usage application
+   * @brief Returns a value from the buffer
+   */
+  public int read() {
+    synchronized (bufferLock) {
+      if (bufferIndex == bufferLast) return -1;
+
+      int outgoing = buffer[bufferIndex++] & 0xff;
+      if (bufferIndex == bufferLast) {  // rewind
+        bufferIndex = 0;
+        bufferLast = 0;
+      }
+      return outgoing;
     }
-
-    /**
-     * ( begin auto-generated from Client_readBytesUntil.xml )
-     *
-     * Reads from the port into a buffer of bytes up to and including a
-     * particular character.If the character isn't in the buffer, 'null' is
-     * returned. The version with no <b>byteBuffer</b> parameter returns a byte
-     * array of all data up to and including the <b>interesting</b> byte. This
-     * is not efficient, but is easy to use. The version with the
-     * <b>byteBuffer</b> parameter is more memory and time efficient. It grabs
-     * the data in the buffer and puts it into the byte array passed in and
-     * returns an int value for the number of bytes read. If the byte buffer is
-     * not large enough, -1 is returned and an error is printed to the message
-     * area. If nothing is in the buffer, 0 is returned.
-     *
-     * ( end auto-generated )
-     *
-     * @return
-     * @webref client:client
-     * @usage application
-     * @brief Reads from the buffer of bytes up to and including a particular
-     * character
-     * @param interesting character designated to mark the end of the data
-     */
-    public byte[] readBytesUntil(int interesting) {
-        byte what = (byte) interesting;
-
-        synchronized (bufferLock) {
-            if (bufferIndex == bufferLast) {
-                return null;
-            }
-
-            int found = -1;
-            for (int k = bufferIndex; k < bufferLast; k++) {
-                if (buffer[k] == what) {
-                    found = k;
-                    break;
-                }
-            }
-            if (found == -1) {
-                return null;
-            }
-
-            int length = found - bufferIndex + 1;
-            byte outgoing[] = new byte[length];
-            System.arraycopy(buffer, bufferIndex, outgoing, 0, length);
-
-            bufferIndex += length;
-            if (bufferIndex == bufferLast) {
-                bufferIndex = 0; // rewind
-                bufferLast = 0;
-            }
-            return outgoing;
-        }
+  }
+
+
+  /**
+   * ( begin auto-generated from Client_readChar.xml )
+   * 
+   * Returns the next byte in the buffer as a char. Returns -1 or 0xffff if 
+   * nothing is there.
+   * 
+   * ( end auto-generated )
+   * @webref client:client
+   * @usage application
+   * @brief Returns the next byte in the buffer as a char
+   */
+  public char readChar() {
+    synchronized (bufferLock) {
+      if (bufferIndex == bufferLast) return (char) (-1);
+      return (char) read();
     }
-
-    /**
-     * <h3>Advanced</h3>
-     * Reads from the serial port into a buffer of bytes until a particular
-     * character. If the character isn't in the serial buffer, then 'null' is
-     * returned.
-     *
-     * If outgoing[] is not big enough, then -1 is returned, and an error
-     * message is printed on the console. If nothing is in the buffer, zero is
-     * returned. If 'interesting' byte is not in the buffer, then 0 is returned.
-     *
-     * @param interesting
-     * @param byteBuffer passed in byte array to be altered
-     * @return
-     */
-    public int readBytesUntil(int interesting, byte byteBuffer[]) {
-        byte what = (byte) interesting;
-
-        synchronized (bufferLock) {
-            if (bufferIndex == bufferLast) {
-                return 0;
-            }
-
-            int found = -1;
-            for (int k = bufferIndex; k < bufferLast; k++) {
-                if (buffer[k] == what) {
-                    found = k;
-                    break;
-                }
-            }
-            if (found == -1) {
-                return 0;
-            }
-
-            int length = found - bufferIndex + 1;
-            if (length > byteBuffer.length) {
-                System.err.println("readBytesUntil() byte buffer is"
-                        + " too small for the " + length
-                        + " bytes up to and including char " + interesting);
-                return -1;
-            }
-            //byte outgoing[] = new byte[length];
-            System.arraycopy(buffer, bufferIndex, byteBuffer, 0, length);
-
-            bufferIndex += length;
-            if (bufferIndex == bufferLast) {
-                bufferIndex = 0;  // rewind
-                bufferLast = 0;
-            }
-            return length;
-        }
+  }
+
+
+  /**
+   * ( begin auto-generated from Client_readBytes.xml )
+   * 
+   * Reads a group of bytes from the buffer. The version with no parameters 
+   * returns a byte array of all data in the buffer. This is not efficient, 
+   * but is easy to use. The version with the <b>byteBuffer</b> parameter is 
+   * more memory and time efficient. It grabs the data in the buffer and puts 
+   * it into the byte array passed in and returns an int value for the number 
+   * of bytes read. If more bytes are available than can fit into the 
+   * <b>byteBuffer</b>, only those that fit are read.
+   * 
+   * ( end auto-generated )
+   * <h3>Advanced</h3>
+   * Return a byte array of anything that's in the serial buffer.
+   * Not particularly memory/speed efficient, because it creates
+   * a byte array on each read, but it's easier to use than
+   * readBytes(byte b[]) (see below).
+   * 
+   * @webref client:client
+   * @usage application
+   * @brief Reads everything in the buffer
+   */
+  public byte[] readBytes() {
+    synchronized (bufferLock) {
+      if (bufferIndex == bufferLast) return null;
+
+      int length = bufferLast - bufferIndex;
+      byte outgoing[] = new byte[length];
+      System.arraycopy(buffer, bufferIndex, outgoing, 0, length);
+
+      bufferIndex = 0;  // rewind
+      bufferLast = 0;
+      return outgoing;
     }
-
-    /**
-     * ( begin auto-generated from Client_readString.xml )
-     *
-     * Returns the all the data from the buffer as a String.This method assumes
-     * the incoming characters are ASCII. If you want to transfer Unicode data,
-     * first convert the String to a byte stream in the representation of your
-     * choice (i.e. UTF8 or two-byte Unicode data), and send it as a byte array.
-     *
-     * ( end auto-generated )
-     *
-     * @return
-     * @webref client:client
-     * @usage application
-     * @brief Returns the buffer as a String
-     */
-    public String readString() {
-        byte b[] = readBytes();
-        if (b == null) {
-            return null;
-        }
-        return new String(b);
+  }
+
+
+  /**
+   * <h3>Advanced</h3>
+   * Return a byte array of anything that's in the serial buffer
+   * up to the specified maximum number of bytes.
+   * Not particularly memory/speed efficient, because it creates
+   * a byte array on each read, but it's easier to use than
+   * readBytes(byte b[]) (see below).
+   *
+   * @param max the maximum number of bytes to read
+   */
+  public byte[] readBytes(int max) {
+    synchronized (bufferLock) {
+      if (bufferIndex == bufferLast) return null;
+
+      int length = bufferLast - bufferIndex;
+      if (length > max) length = max;
+      byte outgoing[] = new byte[length];
+      System.arraycopy(buffer, bufferIndex, outgoing, 0, length);
+
+      bufferIndex += length;
+      if (bufferIndex == bufferLast) {
+        bufferIndex = 0;  // rewind
+        bufferLast = 0;
+      }
+
+      return outgoing;
     }
-
-    /**
-     * ( begin auto-generated from Client_readStringUntil.xml )
-     *
-     * Combination of <b>readBytesUntil()</b> and <b>readString()</b>.Returns
-     * <b>null</b> if it doesn't find what you're looking for. ( end
-     * auto-generated )
-     * <h3>Advanced</h3>
-     *
-     * If you want to move Unicode data, you can first convert the String to a
-     * byte stream in the representation of your choice (i.e. UTF8 or two-byte
-     * Unicode data), and send it as a byte array.
-     *
-     * @return
-     * @webref client:client
-     * @usage application
-     * @brief Returns the buffer as a String up to and including a particular
-     * character
-     * @param interesting character designated to mark the end of the data
-     */
-    public String readStringUntil(int interesting) {
-        byte b[] = readBytesUntil(interesting);
-        if (b == null) {
-            return null;
+  }
+
+
+  /**
+   * <h3>Advanced</h3>
+   * Grab whatever is in the serial buffer, and stuff it into a
+   * byte buffer passed in by the user. This is more memory/time
+   * efficient than readBytes() returning a byte[] array.
+   *
+   * Returns an int for how many bytes were read. If more bytes
+   * are available than can fit into the byte array, only those
+   * that will fit are read.
+   * 
+   * @param bytebuffer passed in byte array to be altered
+   */
+  public int readBytes(byte bytebuffer[]) {
+    synchronized (bufferLock) {
+      if (bufferIndex == bufferLast) return 0;
+
+      int length = bufferLast - bufferIndex;
+      if (length > bytebuffer.length) length = bytebuffer.length;
+      System.arraycopy(buffer, bufferIndex, bytebuffer, 0, length);
+
+      bufferIndex += length;
+      if (bufferIndex == bufferLast) {
+        bufferIndex = 0;  // rewind
+        bufferLast = 0;
+      }
+      return length;
+    }
+  }
+
+
+  /**
+   * ( begin auto-generated from Client_readBytesUntil.xml )
+   * 
+   * Reads from the port into a buffer of bytes up to and including a 
+   * particular character. If the character isn't in the buffer, 'null' is 
+   * returned. The version with no <b>byteBuffer</b> parameter returns a byte 
+   * array of all data up to and including the <b>interesting</b> byte. This 
+   * is not efficient, but is easy to use. The version with the 
+   * <b>byteBuffer</b> parameter is more memory and time efficient. It grabs 
+   * the data in the buffer and puts it into the byte array passed in and 
+   * returns an int value for the number of bytes read. If the byte buffer is 
+   * not large enough, -1 is returned and an error is printed to the message 
+   * area. If nothing is in the buffer, 0 is returned.
+   * 
+   * ( end auto-generated )
+   * @webref client:client
+   * @usage application
+   * @brief Reads from the buffer of bytes up to and including a particular character
+   * @param interesting character designated to mark the end of the data
+   */
+  public byte[] readBytesUntil(int interesting) {
+    byte what = (byte)interesting;
+
+    synchronized (bufferLock) {
+      if (bufferIndex == bufferLast) return null;
+
+      int found = -1;
+      for (int k = bufferIndex; k < bufferLast; k++) {
+        if (buffer[k] == what) {
+          found = k;
+          break;
         }
-        return new String(b);
+      }
+      if (found == -1) return null;
+
+      int length = found - bufferIndex + 1;
+      byte outgoing[] = new byte[length];
+      System.arraycopy(buffer, bufferIndex, outgoing, 0, length);
+
+      bufferIndex += length;
+      if (bufferIndex == bufferLast) {
+        bufferIndex = 0; // rewind
+        bufferLast = 0;
+      }
+      return outgoing;
     }
-
-    /**
-     * ( begin auto-generated from Client_write.xml )
-     *
-     * Writes data to a server specified when constructing the client.
-     *
-     * ( end auto-generated )
-     *
-     * @webref client:client
-     * @usage application
-     * @brief Writes bytes, chars, ints, bytes[], Strings
-     * @param data data to write
-     */
-    public void write(int data) {  // will also cover char
-        try {
-            output.write(data & 0xff);  // for good measure do the &
-            output.flush();   // hmm, not sure if a good idea
-
-        } catch (IOException e) { // null pointer or serial port dead
-            //errorMessage("write", e);
-            //e.printStackTrace();
-            //dispose();
-            //disconnect(e);
-            stop();
+  }
+
+
+  /**
+   * <h3>Advanced</h3>
+   * Reads from the serial port into a buffer of bytes until a
+   * particular character. If the character isn't in the serial
+   * buffer, then 'null' is returned.
+   *
+   * If outgoing[] is not big enough, then -1 is returned,
+   *   and an error message is printed on the console.
+   * If nothing is in the buffer, zero is returned.
+   * If 'interesting' byte is not in the buffer, then 0 is returned.
+   * 
+   * @param byteBuffer passed in byte array to be altered
+   */
+  public int readBytesUntil(int interesting, byte byteBuffer[]) {
+    byte what = (byte)interesting;
+
+    synchronized (bufferLock) {
+      if (bufferIndex == bufferLast) return 0;
+
+      int found = -1;
+      for (int k = bufferIndex; k < bufferLast; k++) {
+        if (buffer[k] == what) {
+          found = k;
+          break;
         }
+      }
+      if (found == -1) return 0;
+
+      int length = found - bufferIndex + 1;
+      if (length > byteBuffer.length) {
+        System.err.println("readBytesUntil() byte buffer is" +
+                           " too small for the " + length +
+                           " bytes up to and including char " + interesting);
+        return -1;
+      }
+      //byte outgoing[] = new byte[length];
+      System.arraycopy(buffer, bufferIndex, byteBuffer, 0, length);
+
+      bufferIndex += length;
+      if (bufferIndex == bufferLast) {
+        bufferIndex = 0;  // rewind
+        bufferLast = 0;
+      }
+      return length;
     }
+  }
+
+
+  /**
+   * ( begin auto-generated from Client_readString.xml )
+   * 
+   * Returns the all the data from the buffer as a String. This method 
+   * assumes the incoming characters are ASCII. If you want to transfer 
+   * Unicode data, first convert the String to a byte stream in the 
+   * representation of your choice (i.e. UTF8 or two-byte Unicode data), and 
+   * send it as a byte array.
+   * 
+   * ( end auto-generated )
+   * @webref client:client
+   * @usage application
+   * @brief Returns the buffer as a String
+   */
+  public String readString() {
+    byte b[] = readBytes();
+    if (b == null) return null;
+    return new String(b);
+  }
+
+
+  /**
+   * ( begin auto-generated from Client_readStringUntil.xml )
+   * 
+   * Combination of <b>readBytesUntil()</b> and <b>readString()</b>. Returns 
+   * <b>null</b> if it doesn't find what you're looking for.
+   * 
+   * ( end auto-generated )
+   * <h3>Advanced</h3>
+   * <p/>
+   * If you want to move Unicode data, you can first convert the
+   * String to a byte stream in the representation of your choice
+   * (i.e. UTF8 or two-byte Unicode data), and send it as a byte array.
+   * 
+   * @webref client:client
+   * @usage application
+   * @brief Returns the buffer as a String up to and including a particular character
+   * @param interesting character designated to mark the end of the data
+   */
+  public String readStringUntil(int interesting) {
+    byte b[] = readBytesUntil(interesting);
+    if (b == null) return null;
+    return new String(b);
+  }
+
+
+  /**
+   * ( begin auto-generated from Client_write.xml )
+   * 
+   * Writes data to a server specified when constructing the client.
+   * 
+   * ( end auto-generated )
+   * @webref client:client
+   * @usage application
+   * @brief  	Writes bytes, chars, ints, bytes[], Strings
+   * @param data data to write
+   */
+  public void write(int data) {  // will also cover char
+    try {
+      output.write(data & 0xff);  // for good measure do the &
+      output.flush();   // hmm, not sure if a good idea
+
+    } catch (Exception e) { // null pointer or serial port dead
+      //errorMessage("write", e);
+      //e.printStackTrace();
+      //dispose();
+      //disconnect(e);
+      e.printStackTrace();
+      stop();
+    }
+  }
 
-    public void write(byte data[]) {
-        try {
-            output.write(data);
-            output.flush();   // hmm, not sure if a good idea
 
-        } catch (IOException e) { // null pointer or serial port dead
-            stop();
-        }
-    }
+  public void write(byte data[]) {
+    try {
+      output.write(data);
+      output.flush();   // hmm, not sure if a good idea
 
-    /**
-     * <h3>Advanced</h3>
-     * Write a String to the output. Note that this doesn't account for Unicode
-     * (two bytes per char), nor will it send UTF8 characters.. It assumes that
-     * you mean to send a byte buffer (most often the case for networking and
-     * serial i/o) and will only use the bottom 8 bits of each char in the
-     * string. (Meaning that internally it uses String.getBytes)
-     *
-     * If you want to move Unicode data, you can first convert the String to a
-     * byte stream in the representation of your choice (i.e. UTF8 or two-byte
-     * Unicode data), and send it as a byte array.
-     *
-     * @param data
-     */
-    public void write(String data) {
-        write(data.getBytes());
+    } catch (Exception e) { // null pointer or serial port dead
+      //errorMessage("write", e);
+      //e.printStackTrace();
+      //disconnect(e);
+      e.printStackTrace();
+      stop();
     }
-
-    /**
-     * Handle disconnect due to an Exception being thrown.
-     */
-    /*
+  }
+
+
+  /**
+   * <h3>Advanced</h3>
+   * Write a String to the output. Note that this doesn't account
+   * for Unicode (two bytes per char), nor will it send UTF8
+   * characters.. It assumes that you mean to send a byte buffer
+   * (most often the case for networking and serial i/o) and
+   * will only use the bottom 8 bits of each char in the string.
+   * (Meaning that internally it uses String.getBytes)
+   *
+   * If you want to move Unicode data, you can first convert the
+   * String to a byte stream in the representation of your choice
+   * (i.e. UTF8 or two-byte Unicode data), and send it as a byte array.
+   */
+  public void write(String data) {
+    write(data.getBytes());
+  }
+
+
+  /**
+   * Handle disconnect due to an Exception being thrown.
+   */
+  /*
     protected void disconnect(Exception e) {
     dispose();
     if (e != null) {
     e.printStackTrace();
     }
     }
-     */
-    /**
-     * General error reporting, all corralled here just in case I think of
-     * something slightly more intelligent to do.
-     */
-    //public void errorMessage(String where, Exception e) {
-    //parent.die("Error inside Client." + where + "()", e);
-    //e.printStackTrace(System.err);
-    //}
+  */
+
+
+  /**
+   * General error reporting, all corralled here just in case
+   * I think of something slightly more intelligent to do.
+   */
+  //public void errorMessage(String where, Exception e) {
+  //parent.die("Error inside Client." + where + "()", e);
+  //e.printStackTrace(System.err);
+  //}
 }