diff -r 0f44b7360c8d -r 925b7ee746e3 front_processing/extern/TUIO_JAVA/src/com/illposed/osc/utility/OSCJavaToByteArrayConverter.java
--- a/front_processing/extern/TUIO_JAVA/src/com/illposed/osc/utility/OSCJavaToByteArrayConverter.java	Thu Mar 22 18:15:53 2012 +0100
+++ b/front_processing/extern/TUIO_JAVA/src/com/illposed/osc/utility/OSCJavaToByteArrayConverter.java	Fri Mar 23 16:24:36 2012 +0100
@@ -1,310 +1,310 @@
-/**
- * @author cramakrishnan
- *
- * Copyright (C) 2003, C. Ramakrishnan / Illposed Software
- * All rights reserved.
- * 
- * See license.txt (or license.rtf) for license information.
- * 
- * 
- * OSCJavaToByteArrayConverter is a helper class that translates
- * from Java types to the format the OSC spec specifies for those
- * types.
- *
- * This implementation is based on Markus Gaelli and
- * Iannis Zannos' OSC implementation in Squeak:
- * http://www.emergent.de/Goodies/
- */
-
-package com.illposed.osc.utility;
-
-import java.io.IOException;
-import java.io.ByteArrayOutputStream;
-import java.math.BigInteger;
-import java.util.Enumeration;
-import java.util.Vector;
-
-
-public class OSCJavaToByteArrayConverter {
-
-    protected ByteArrayOutputStream stream = new ByteArrayOutputStream();
-    private byte[] intBytes = new byte[4];
-
-    /*public OSCJavaToByteArrayConverter() {
-        super();
-    }*/
-
-    /**
-     * Creation date: (2/23/2001 2:43:25 AM)
-     * @param anArray java.lang.Object[]
-     *
-     */
-    public void appendNullCharToAlignStream() {
-        int mod = stream.size() % 4;
-        int pad = 4 - mod;
-        for (int i = 0; i < pad; i++)
-            stream.write(0);
-    }
-
-    /**
-     * Creation date: (2/23/2001 2:21:53 AM)
-     * @return byte[]
-     */
-    public byte[] toByteArray() {
-        return stream.toByteArray();
-    }
-
-    /**
-     * Creation date: (2/23/2001 2:14:23 AM)
-     * @param bytes byte[]
-     */
-    public void write(byte[] bytes) {
-        writeBigEndToFourByteBoundry(bytes);
-    }
-
-    /**
-     * Creation date: (2/23/2001 2:21:04 AM)
-     * @param i int
-     */
-    public void write(int i) {
-        writeIntegerToByteArray(i);
-    }
-
-    /**
-     * Creation date: (2/23/2001 2:03:57 AM)
-     * @param f java.lang.Float
-     */
-    public void write(Float f) {
-        writeIntegerToByteArray(Float.floatToIntBits(f.floatValue()));
-    }
-
-    /**
-     * Creation date: (2/23/2001 2:08:36 AM)
-     * @param i java.lang.Integer
-     */
-    public void write(Integer i) {
-        writeIntegerToByteArray(i.intValue());
-    }
-
-    /**
-     * Creation date: (2/23/2001 1:57:35 AM)
-     * @param str java.lang.String
-     */
-    public void write(String str) {
-        writeLittleEndToFourByteBoundry(str.getBytes());
-    }
-
-    /**
-     * Creation date: (2/23/2001 2:08:36 AM)
-     * @param c char
-     */
-    public void write(char c) {
-        stream.write(c);
-    }
-
-    /**
-     * Creation date: (2/23/2001 2:02:54 AM)
-     * @param anObject java.lang.Object
-     */
-    public void write(Object anObject) {
-        // Can't do switch on class
-        if (null == anObject)
-            return;
-        if (anObject instanceof Float) {
-            write((Float) anObject);
-            return;
-        }
-        if (anObject instanceof String) {
-            write((String) anObject);
-            return;
-        }
-        if (anObject instanceof Integer) {
-            write((Integer) anObject);
-            return;
-        }
-    }
-
-    /**
-     * Creation date: (2/23/2001 2:43:25 AM)
-     * @param aClass Class
-     */
-    public void writeType(Class c) {
-        // A big ol' case statement -- what's polymorphism mean, again?
-        // I really wish I could extend the base classes!
-
-        // use the appropriate flags to tell SuperCollider what kind of 
-        // thing it is looking at
-
-        if (Integer.class.equals(c)) {
-            stream.write('i');
-            return;
-        }
-        if (java.math.BigInteger.class.equals(c)) {
-            stream.write('h');
-            return;
-        }
-        if (Float.class.equals(c)) {
-            stream.write('f');
-            return;
-        }
-        if (Double.class.equals(c)) {
-            stream.write('d');
-            return;
-        }
-        if (String.class.equals(c)) {
-            stream.write('s');
-            return;
-        }
-        if (Character.class.equals(c)) {
-            stream.write('c');
-            return;
-        }
-    }
-
-    /**
-     * Creation date: (2/23/2001 2:43:25 AM)
-     * @param anArray java.lang.Object[]
-     */
-    public void writeTypesArray(Object[] array) {
-        // A big ol' case statement in a for loop -- what's polymorphism mean, again?
-        // I really wish I could extend the base classes!
-
-        for (int i = 0; i < array.length; i++) {
-            if (null == array[i])
-                continue;
-            // if the array at i is a type of array write a [
-            // This is used for nested arguments
-            if (array[i].getClass().isArray()) {
-                stream.write('[');
-                // fill the [] with the SuperCollider types corresponding to the object
-                // (i.e. Object of type String needs -s).
-                writeTypesArray((Object[]) array[i]);
-                // close the array
-                stream.write(']');
-                continue;
-            }
-            // Create a way to deal with Boolean type objects
-            if (Boolean.TRUE.equals(array[i])) {
-                stream.write('T');
-                continue;
-            }
-            if (Boolean.FALSE.equals(array[i])) {
-                stream.write('F');
-                continue;
-            }
-            // go through the array and write the superCollider types as shown in the 
-            // above method. the Classes derived here are used as the arg to the above method
-            writeType(array[i].getClass());
-        }
-        // align the stream with padded bytes
-        appendNullCharToAlignStream();
-    }
-    
-    /**
-     * Same as writeSuperColliderTypes(Object[]), just that it takes a vector (for jdk1.1
-     * compatibility), rather than an array.
-     * @param vector  the collection I am to write out types for
-     */
-    public void writeTypes(Vector vector) {
-        // A big ol' case statement in a for loop -- what's polymorphism mean, again?
-        // I really wish I could extend the base classes!
-
-        Enumeration enm = vector.elements();
-        Object nextObject;
-        while (enm.hasMoreElements()) {
-            nextObject = enm.nextElement();
-            if (null == nextObject)
-                continue;
-            // if the array at i is a type of array write a [
-            // This is used for nested arguments
-            if (nextObject.getClass().isArray()) {
-                stream.write('[');
-                // fill the [] with the SuperCollider types corresponding to the object
-                // (e.g., Object of type String needs -s).
-                writeTypesArray((Object[]) nextObject);
-                // close the array
-                stream.write(']');
-                continue;
-            }
-            // Create a way to deal with Boolean type objects
-            if (Boolean.TRUE.equals(nextObject)) {
-                stream.write('T');
-                continue;
-            }
-            if (Boolean.FALSE.equals(nextObject)) {
-                stream.write('F');
-                continue;
-            }
-            // go through the array and write the superCollider types as shown in the 
-            // above method. the Classes derived here are used as the arg to the above method
-            writeType(nextObject.getClass());
-        }
-        // align the stream with padded bytes
-        appendNullCharToAlignStream();
-    }
-
-    /**
-     * convert an integer to byte array
-     *
-     * @param value int
-     */
-    private void writeIntegerToByteArray(int value) {
-        byte[] intBytes = new byte[4];
-
-        intBytes[3] = (byte)value; value>>>=8;
-        intBytes[2] = (byte)value; value>>>=8;
-        intBytes[1] = (byte)value; value>>>=8;
-        intBytes[0] = (byte)value;
-
-        try {
-            stream.write(intBytes);
-        } catch (IOException e) {
-            throw new RuntimeException("You're screwed: IOException writing to a ByteArrayOutputStream");
-        }
-    }
-    
-    /**
-     * Line up the BigEnd of the bytes to a 4 byte boundry
-     *
-     * @param bytes byte[]
-     */
-    private void writeBigEndToFourByteBoundry(byte[] bytes) {
-        int mod = bytes.length % 4;
-        // if the remainder == 0 write the bytes
-        if (mod == 0) {
-            try { stream.write(bytes); } catch (IOException e)
-            { throw new RuntimeException("You're screwed: IOException writing to a ByteArrayOutputStream"); }
-            return;
-        }
-        // pad the bytes to lineup correctly
-        int pad = 4 - mod;
-        byte[] newBytes = new byte[pad + bytes.length];
-        System.arraycopy(bytes,0,newBytes,pad,bytes.length);
-
-        try { stream.write(newBytes); } catch (IOException e)
-        { throw new RuntimeException("You're screwed: IOException writing to a ByteArrayOutputStream"); }
-    }
-
-    /**
-     * Line up the LittleEnd of the bytes to a 4 byte boundry
-     * 
-     * @param bytes byte[]
-     */
-    private void writeLittleEndToFourByteBoundry(byte[] bytes) {
-        int mod = bytes.length % 4;
-        // if the remainder == 0 write the bytes
-        if (mod == 4) {
-            try { stream.write(bytes); } catch (IOException e)
-            { throw new RuntimeException("You're screwed: IOException writing to a ByteArrayOutputStream"); }
-            return;
-        }
-        // pad the bytes to lineup correctly
-        int pad = 4 - mod;
-        byte[] newBytes = new byte[pad + bytes.length];
-        System.arraycopy(bytes,0,newBytes,0,bytes.length);
-
-        try { stream.write(newBytes); } catch (IOException e)
-        { throw new RuntimeException("You're screwed: IOException writing to a ByteArrayOutputStream"); }
-    }
-
-}
+/**
+ * @author cramakrishnan
+ *
+ * Copyright (C) 2003, C. Ramakrishnan / Illposed Software
+ * All rights reserved.
+ * 
+ * See license.txt (or license.rtf) for license information.
+ * 
+ * 
+ * OSCJavaToByteArrayConverter is a helper class that translates
+ * from Java types to the format the OSC spec specifies for those
+ * types.
+ *
+ * This implementation is based on Markus Gaelli and
+ * Iannis Zannos' OSC implementation in Squeak:
+ * http://www.emergent.de/Goodies/
+ */
+
+package com.illposed.osc.utility;
+
+import java.io.IOException;
+import java.io.ByteArrayOutputStream;
+import java.math.BigInteger;
+import java.util.Enumeration;
+import java.util.Vector;
+
+
+public class OSCJavaToByteArrayConverter {
+
+    protected ByteArrayOutputStream stream = new ByteArrayOutputStream();
+    private byte[] intBytes = new byte[4];
+
+    /*public OSCJavaToByteArrayConverter() {
+        super();
+    }*/
+
+    /**
+     * Creation date: (2/23/2001 2:43:25 AM)
+     * @param anArray java.lang.Object[]
+     *
+     */
+    public void appendNullCharToAlignStream() {
+        int mod = stream.size() % 4;
+        int pad = 4 - mod;
+        for (int i = 0; i < pad; i++)
+            stream.write(0);
+    }
+
+    /**
+     * Creation date: (2/23/2001 2:21:53 AM)
+     * @return byte[]
+     */
+    public byte[] toByteArray() {
+        return stream.toByteArray();
+    }
+
+    /**
+     * Creation date: (2/23/2001 2:14:23 AM)
+     * @param bytes byte[]
+     */
+    public void write(byte[] bytes) {
+        writeBigEndToFourByteBoundry(bytes);
+    }
+
+    /**
+     * Creation date: (2/23/2001 2:21:04 AM)
+     * @param i int
+     */
+    public void write(int i) {
+        writeIntegerToByteArray(i);
+    }
+
+    /**
+     * Creation date: (2/23/2001 2:03:57 AM)
+     * @param f java.lang.Float
+     */
+    public void write(Float f) {
+        writeIntegerToByteArray(Float.floatToIntBits(f.floatValue()));
+    }
+
+    /**
+     * Creation date: (2/23/2001 2:08:36 AM)
+     * @param i java.lang.Integer
+     */
+    public void write(Integer i) {
+        writeIntegerToByteArray(i.intValue());
+    }
+
+    /**
+     * Creation date: (2/23/2001 1:57:35 AM)
+     * @param str java.lang.String
+     */
+    public void write(String str) {
+        writeLittleEndToFourByteBoundry(str.getBytes());
+    }
+
+    /**
+     * Creation date: (2/23/2001 2:08:36 AM)
+     * @param c char
+     */
+    public void write(char c) {
+        stream.write(c);
+    }
+
+    /**
+     * Creation date: (2/23/2001 2:02:54 AM)
+     * @param anObject java.lang.Object
+     */
+    public void write(Object anObject) {
+        // Can't do switch on class
+        if (null == anObject)
+            return;
+        if (anObject instanceof Float) {
+            write((Float) anObject);
+            return;
+        }
+        if (anObject instanceof String) {
+            write((String) anObject);
+            return;
+        }
+        if (anObject instanceof Integer) {
+            write((Integer) anObject);
+            return;
+        }
+    }
+
+    /**
+     * Creation date: (2/23/2001 2:43:25 AM)
+     * @param aClass Class
+     */
+    public void writeType(Class c) {
+        // A big ol' case statement -- what's polymorphism mean, again?
+        // I really wish I could extend the base classes!
+
+        // use the appropriate flags to tell SuperCollider what kind of 
+        // thing it is looking at
+
+        if (Integer.class.equals(c)) {
+            stream.write('i');
+            return;
+        }
+        if (java.math.BigInteger.class.equals(c)) {
+            stream.write('h');
+            return;
+        }
+        if (Float.class.equals(c)) {
+            stream.write('f');
+            return;
+        }
+        if (Double.class.equals(c)) {
+            stream.write('d');
+            return;
+        }
+        if (String.class.equals(c)) {
+            stream.write('s');
+            return;
+        }
+        if (Character.class.equals(c)) {
+            stream.write('c');
+            return;
+        }
+    }
+
+    /**
+     * Creation date: (2/23/2001 2:43:25 AM)
+     * @param anArray java.lang.Object[]
+     */
+    public void writeTypesArray(Object[] array) {
+        // A big ol' case statement in a for loop -- what's polymorphism mean, again?
+        // I really wish I could extend the base classes!
+
+        for (int i = 0; i < array.length; i++) {
+            if (null == array[i])
+                continue;
+            // if the array at i is a type of array write a [
+            // This is used for nested arguments
+            if (array[i].getClass().isArray()) {
+                stream.write('[');
+                // fill the [] with the SuperCollider types corresponding to the object
+                // (i.e. Object of type String needs -s).
+                writeTypesArray((Object[]) array[i]);
+                // close the array
+                stream.write(']');
+                continue;
+            }
+            // Create a way to deal with Boolean type objects
+            if (Boolean.TRUE.equals(array[i])) {
+                stream.write('T');
+                continue;
+            }
+            if (Boolean.FALSE.equals(array[i])) {
+                stream.write('F');
+                continue;
+            }
+            // go through the array and write the superCollider types as shown in the 
+            // above method. the Classes derived here are used as the arg to the above method
+            writeType(array[i].getClass());
+        }
+        // align the stream with padded bytes
+        appendNullCharToAlignStream();
+    }
+    
+    /**
+     * Same as writeSuperColliderTypes(Object[]), just that it takes a vector (for jdk1.1
+     * compatibility), rather than an array.
+     * @param vector  the collection I am to write out types for
+     */
+    public void writeTypes(Vector vector) {
+        // A big ol' case statement in a for loop -- what's polymorphism mean, again?
+        // I really wish I could extend the base classes!
+
+        Enumeration enm = vector.elements();
+        Object nextObject;
+        while (enm.hasMoreElements()) {
+            nextObject = enm.nextElement();
+            if (null == nextObject)
+                continue;
+            // if the array at i is a type of array write a [
+            // This is used for nested arguments
+            if (nextObject.getClass().isArray()) {
+                stream.write('[');
+                // fill the [] with the SuperCollider types corresponding to the object
+                // (e.g., Object of type String needs -s).
+                writeTypesArray((Object[]) nextObject);
+                // close the array
+                stream.write(']');
+                continue;
+            }
+            // Create a way to deal with Boolean type objects
+            if (Boolean.TRUE.equals(nextObject)) {
+                stream.write('T');
+                continue;
+            }
+            if (Boolean.FALSE.equals(nextObject)) {
+                stream.write('F');
+                continue;
+            }
+            // go through the array and write the superCollider types as shown in the 
+            // above method. the Classes derived here are used as the arg to the above method
+            writeType(nextObject.getClass());
+        }
+        // align the stream with padded bytes
+        appendNullCharToAlignStream();
+    }
+
+    /**
+     * convert an integer to byte array
+     *
+     * @param value int
+     */
+    private void writeIntegerToByteArray(int value) {
+        byte[] intBytes = new byte[4];
+
+        intBytes[3] = (byte)value; value>>>=8;
+        intBytes[2] = (byte)value; value>>>=8;
+        intBytes[1] = (byte)value; value>>>=8;
+        intBytes[0] = (byte)value;
+
+        try {
+            stream.write(intBytes);
+        } catch (IOException e) {
+            throw new RuntimeException("You're screwed: IOException writing to a ByteArrayOutputStream");
+        }
+    }
+    
+    /**
+     * Line up the BigEnd of the bytes to a 4 byte boundry
+     *
+     * @param bytes byte[]
+     */
+    private void writeBigEndToFourByteBoundry(byte[] bytes) {
+        int mod = bytes.length % 4;
+        // if the remainder == 0 write the bytes
+        if (mod == 0) {
+            try { stream.write(bytes); } catch (IOException e)
+            { throw new RuntimeException("You're screwed: IOException writing to a ByteArrayOutputStream"); }
+            return;
+        }
+        // pad the bytes to lineup correctly
+        int pad = 4 - mod;
+        byte[] newBytes = new byte[pad + bytes.length];
+        System.arraycopy(bytes,0,newBytes,pad,bytes.length);
+
+        try { stream.write(newBytes); } catch (IOException e)
+        { throw new RuntimeException("You're screwed: IOException writing to a ByteArrayOutputStream"); }
+    }
+
+    /**
+     * Line up the LittleEnd of the bytes to a 4 byte boundry
+     * 
+     * @param bytes byte[]
+     */
+    private void writeLittleEndToFourByteBoundry(byte[] bytes) {
+        int mod = bytes.length % 4;
+        // if the remainder == 0 write the bytes
+        if (mod == 4) {
+            try { stream.write(bytes); } catch (IOException e)
+            { throw new RuntimeException("You're screwed: IOException writing to a ByteArrayOutputStream"); }
+            return;
+        }
+        // pad the bytes to lineup correctly
+        int pad = 4 - mod;
+        byte[] newBytes = new byte[pad + bytes.length];
+        System.arraycopy(bytes,0,newBytes,0,bytes.length);
+
+        try { stream.write(newBytes); } catch (IOException e)
+        { throw new RuntimeException("You're screwed: IOException writing to a ByteArrayOutputStream"); }
+    }
+
+}