Repair

.classpath

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+	<classpathentry kind="lib" path="contrib/javassist-3.15.0-GA.jar"/>
+	<classpathentry kind="lib" path="contrib/hibernate-jpa-2.0-api-1.0.1.Final.jar"/>
+	<classpathentry kind="lib" path="contrib/cglib-nodep-3.1.jar"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+bin/*
+
+/bin

.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.hwo</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.6

src/org/hwo/BitField.java

@@ -0,0 +1,61 @@
+package org.hwo;
+
+import org.w3c.dom.Element;
+import org.w3c.dom.NodeList;
+
+public class BitField {
+
+	private String[] labels;
+	
+	public BitField()
+	{
+		labels = new String[32];
+		initialize();
+	}
+
+	public String[] getLabels()
+	{
+		return labels;
+	}
+	
+	public BitField(Element element)
+	{
+		labels = new String[32];
+
+		initialize();
+		
+		NodeList bits = element.getElementsByTagName("Bit");
+		for (int i=0;i<bits.getLength();i++)
+		{
+			Element bit = (Element)bits.item(i);
+			
+			labels[ Integer.decode(bit.getAttribute("no")) ] = bit.getTextContent();
+		}
+	}
+	
+	private void initialize()
+	{
+		for (int i=0;i<32;i++)
+			labels[i] = null;
+	}
+	
+	public String toText(Integer value)
+	{
+		StringBuilder sb = new StringBuilder();
+		
+		if (value != null)
+		for (int i=0;i<32;i++)
+		{
+			if (labels[i]!=null)
+			if ((value & 1<<i) != 0)
+			{
+				if (sb.toString().length()>0)
+					sb.append(", ");
+				sb.append(labels[i]);
+			}
+		}
+		
+		return sb.toString();
+	}
+	
+}

src/org/hwo/ChkSum.java

@@ -0,0 +1,33 @@
+package org.hwo;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+public class ChkSum {
+
+	public static short chksum(byte[] buffer)
+	{
+		return chksum(buffer, 0, buffer.length);
+	}
+
+	public static short chksum(byte[] buffer,int offset,int len)
+	{
+		int sum = 0,
+			xor = 0;
+		
+		for (int n = offset; n < (offset + len); n++)
+		{
+			sum += buffer[n];
+			xor ^= buffer[n];
+		}
+		
+		byte[] t = new byte[12];
+		ByteBuffer bb = ByteBuffer.wrap(t).order(ByteOrder.LITTLE_ENDIAN);
+		bb.putInt(0, sum);
+		bb.putInt(4, xor);
+		bb.put(8,bb.get(0));
+		bb.put(9,bb.get(4));
+		
+		return bb.getShort(8);
+	}
+}

src/org/hwo/DBProfile.java

@@ -0,0 +1,118 @@
+package org.hwo;
+
+import java.util.prefs.BackingStoreException;
+import java.util.prefs.Preferences;
+
+
+public class DBProfile
+{
+	private Integer profileno;
+	private String bezeichnung;
+	private String hostname;
+	private String database;
+	private Integer port;
+	private String username;
+	private String password;
+	
+	public DBProfile(Preferences pref,int profileno)
+	{
+		this.setProfileno(profileno);
+		load(pref);
+	}
+
+	public int getProfileno() {
+		return profileno;
+	}
+	
+	public void load(Preferences pref)
+	{
+		Preferences prefs = pref.node("database").node(profileno.toString());
+		
+		hostname = prefs.get("hostname", "localhost");
+		database = prefs.get("database", "hworganizer");
+		username = prefs.get("username", "");
+		password = prefs.get("password", "");
+		port = prefs.getInt("port", 5432);
+		bezeichnung = prefs.get("bezeichnung", "Profil " + profileno.toString());
+	}
+	
+	public void save(Preferences pref)
+	{
+		Preferences prefs = pref.node("database").node(profileno.toString());
+		
+		prefs.put("hostname", hostname);
+		prefs.put("database", database);
+		prefs.put("username", username);
+		prefs.put("password", password);
+		prefs.putInt("port", port);
+		prefs.put("bezeichnung", bezeichnung);
+		
+		try
+		{
+			prefs.flush();
+		} catch (BackingStoreException bse)
+		{
+			System.err.println("Einstellungen konnten nicht gespeichert werden!");
+			System.err.println(bse.toString());
+			bse.printStackTrace();
+		}
+	}
+
+	public void setProfileno(int profileno) {
+		this.profileno = profileno;
+	}
+
+	public String getHostname() {
+		return hostname;
+	}
+
+	public void setHostname(String hostname) {
+		this.hostname = hostname;
+	}
+
+	public String getDatabase() {
+		return database;
+	}
+
+	public void setDatabase(String database) {
+		this.database = database;
+	}
+
+	public String getUsername() {
+		return username;
+	}
+
+	public void setUsername(String username) {
+		this.username = username;
+	}
+
+	public String getPassword() {
+		return password;
+	}
+
+	public void setPassword(String password) {
+		this.password = password;
+	}
+
+	public Integer getPort() {
+		return port;
+	}
+
+	public void setPort(Integer port) {
+		this.port = port;
+	}
+
+	public String getBezeichnung() {
+		return bezeichnung;
+	}
+
+	public void setBezeichnung(String bezeichnung) {
+		this.bezeichnung = bezeichnung;
+	}
+	
+	@Override
+	public String toString() {
+		return getBezeichnung();
+	}
+	
+}

src/org/hwo/Reverse.java

@@ -0,0 +1,39 @@
+package org.hwo;
+
+public class Reverse {
+
+	byte[] reverseTable;
+	
+	public Reverse()
+	{
+		reverseTable = new byte[256];
+		buildReverseTable();
+	}
+	
+	private void buildReverseTable()
+	{
+		for (short i=0;i<256;i++)
+		{
+			short in = i;
+			byte out = 0;			
+			for (int n=0;n<8;n++)
+			{
+				out <<= 1;
+				if ((in & 0x01)==0x01)
+					out |= 0x01;
+				in >>= 1;
+			}
+			reverseTable[in] = out;
+		}
+		
+	}
+	
+	public byte reverse(byte in)
+	{
+		short s = Unsigned.byte2short(in);
+		return reverseTable[s];
+	}
+	
+	
+	
+}

src/org/hwo/Unsigned.java

@@ -0,0 +1,20 @@
+package org.hwo;
+
+public class Unsigned {
+
+	
+	static public short byte2short(byte by)
+	{
+		short s;
+		
+		if (by < 0)
+		{
+			s = (short)(128 | (by & 0x7f));
+		} else
+			s = by;
+
+		return s;
+		
+	}
+	
+}

src/org/hwo/beacon/Beacon.java

@@ -0,0 +1,243 @@
+package org.hwo.beacon;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+import java.util.Date;
+import java.util.Hashtable;
+import java.util.Properties;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.UUID;
+
+import javax.net.SocketFactory;
+
+public class Beacon extends Thread{
+
+	public class BeaconSender
+	{
+		private Properties properties;
+		private InetAddress inetAddress;
+		
+		private Long lastBeacon;
+		
+		public BeaconSender()
+		{
+			properties = new Properties();
+			lastBeacon = 0l;
+		}
+
+		public InetAddress getInetAddress() {
+			return inetAddress;
+		}
+
+		public void setInetAddress(InetAddress inetAddress) {
+			this.inetAddress = inetAddress;
+		}
+
+		public Properties getProperties() {
+			return properties;
+		}
+
+		public void setProperties(Properties properties) {
+			this.properties = properties;
+		}
+
+		public Long getLastBeacon() {
+			return lastBeacon;
+		}
+
+		public void setLastBeacon(Long lastBeacon) {
+			this.lastBeacon = lastBeacon;
+		}
+		
+		
+	}
+	
+	public static void main(String[] args)
+	{
+		int mode = 0;
+		
+		for (String arg:args)
+		{
+			if (arg.equals("-s"))
+				mode = 1;
+		}
+		
+		Beacon beacon = new Beacon(44999);
+		beacon.setBeaconName("Test beacon");
+		
+		if (mode == 1)
+		{
+			beacon.start();
+			
+			System.console().printf("Press Enter to exit!");
+			System.console().readLine();
+			System.console().printf("exiting...");
+			beacon.exit();
+			
+		} else
+		{
+			beacon.ping();
+		}
+	}
+
+	private int port;
+	private boolean exit;
+	private DatagramSocket socket;
+	private Properties properties;
+	private Integer intervall;
+	private String beaconName;
+	private UUID uuid;
+	
+	private Hashtable<String, BeaconSender> beaconSenders;
+	
+	public Beacon(int port)
+	{
+		this.port = port;
+		this.socket = null;
+		this.properties = new Properties();
+		this.intervall = 5000;
+		this.beaconSenders = new Hashtable<String, Beacon.BeaconSender>();
+		this.beaconName = "DefaultBeacon";
+		this.uuid = UUID.randomUUID();
+	}
+	
+	public synchronized void exit()
+	{
+		exit = true;
+	}
+	
+	public synchronized boolean getExit()
+	{
+		return exit;
+	}
+	
+	@Override
+	public void run() {
+		
+		Timer pingTimer = new Timer();
+		pingTimer.schedule(new TimerTask() {
+			
+			@Override
+			public void run() {
+				ping();				
+			}
+		}, intervall, intervall);
+		
+		try {
+			socket = new DatagramSocket(this.port);
+			DatagramPacket packet = new DatagramPacket(new byte[1500], 1500);
+			
+			while (!getExit())
+			{
+				try {
+					socket.receive(packet);
+					
+					ByteArrayInputStream bis = new ByteArrayInputStream(packet.getData(),0,packet.getLength());
+					
+					BeaconSender bs = beaconSenders.get(packet.getAddress().getHostAddress());
+					if (bs == null)
+					{
+						bs = new BeaconSender();
+						bs.setInetAddress(packet.getAddress());
+					}
+					bs.setLastBeacon((new Date()).getTime());
+					bs.getProperties().load(bis);
+					
+					if (bs.getProperties().getProperty("beacon.uuid").equals(uuid.toString()))
+					{
+						System.err.println("Received Local Echo.");
+					} else
+					{
+						System.err.println(String.format("Beacon from %s",packet.getAddress().getHostAddress()));
+						System.err.println(String.format("Beacon: %s", bs.getProperties().getProperty("beacon.name")));
+						beaconSenders.put(packet.getAddress().getHostAddress(), bs);
+					};
+					
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			
+		} catch (SocketException e) {
+			e.printStackTrace();
+		}
+		
+		pingTimer.cancel();
+		
+	}
+	
+	public void ping()
+	{
+		DatagramSocket sock = socket;
+		try {		
+			if (sock == null)
+				sock = new DatagramSocket();
+		} catch (SocketException e1) {
+			e1.printStackTrace();
+		}		
+		
+		properties.setProperty("beacon.name", beaconName);
+		properties.setProperty("beacon.uuid", uuid.toString());
+		
+		try {
+			ByteArrayOutputStream bos = new ByteArrayOutputStream();
+			properties.store(bos, null);
+			
+			byte[] bytes = bos.toByteArray();
+
+			DatagramPacket packet = new DatagramPacket(bytes,bytes.length);
+			
+			packet.setPort(this.port);
+			packet.setAddress(InetAddress.getByName("255.255.255.255"));
+			sock.send(packet);
+			
+		} catch (UnknownHostException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		
+	}
+	
+	public Properties getProperties() {
+		return properties;
+	}
+
+	public void setProperties(Properties properties) {
+		this.properties = properties;
+	}
+
+	public Integer getIntervall() {
+		return intervall;
+	}
+
+	public void setIntervall(Integer intervall) {
+		this.intervall = intervall;
+	}
+
+	public Hashtable<String, BeaconSender> getBeaconSenders() {
+		return beaconSenders;
+	}
+
+	public void setBeaconSenders(Hashtable<String, BeaconSender> beaconSenders) {
+		this.beaconSenders = beaconSenders;
+	}
+
+	public String getBeaconName() {
+		return beaconName;
+	}
+
+	public void setBeaconName(String beaconName) {
+		this.beaconName = beaconName;
+	}
+	
+}

src/org/hwo/buffer/BitStream.java

@@ -0,0 +1,112 @@
+package org.hwo.buffer;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class BitStream {
+
+	private boolean byteOrder;
+	
+	private int pByte;
+	private byte pBit;
+	
+	private List<Byte> buffer;
+	
+	public BitStream()
+	{
+		initialize();
+		
+		buffer = new ArrayList<Byte>();
+	}
+	
+	public BitStream(byte[] source)
+	{
+		initialize();
+		
+		buffer = new ArrayList<Byte>();
+		for (byte b:source)
+			buffer.add(b);
+	}
+	
+	public BitStream(Byte[] source)
+	{
+		initialize();
+		
+		buffer = new ArrayList<Byte>(Arrays.asList(source));
+	}
+	
+	private void initialize()
+	{
+		pByte = 0;
+		pBit = 0;
+	}
+	
+	private short unsigned2short(byte by)
+	{
+		short s;
+		
+		if (by < 0)
+		{
+			s = (short)(128 | (by & 0x7f));
+		} else
+			s = by;
+
+		return s;
+	}
+	
+	public short read(byte bits)
+	{
+		short symbol = 0;
+		byte position = 0;	// Bit-Position im symbol
+		
+		while (bits > 0)
+		{
+			symbol <<= 1;
+			
+			short s = (short)( unsigned2short(buffer.get(pByte)));
+			
+			if (byteOrder)
+			{
+				s >>= pBit;
+				if ((s & 0x01) == 0x01)
+					symbol |= 0x01;				
+			} else
+			{
+				s <<= pBit;
+				if ((s & 0x80) == 0x80)
+					symbol |= 0x01;
+			};
+			
+			pBit++;
+			if (pBit == 8)
+			{
+				pBit = 0;
+				pByte++;
+			}
+			bits--;
+		}
+		return symbol;
+	}
+	
+	
+	
+	public byte[] getBuffer()
+	{
+		int len = buffer.size();
+		byte[] out = new byte[ len ];
+		for (int i=0;i<len;i++)
+			out[i] = buffer.get(i);
+		return out;
+	}
+
+	public boolean isByteOrder() {
+		return byteOrder;
+	}
+
+	public void setByteOrder(boolean byteOrder) {
+		this.byteOrder = byteOrder;
+	}
+	
+	
+}

src/org/hwo/compressor/LZW.java

@@ -0,0 +1,167 @@
+package org.hwo.compressor;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedList;
+
+import org.hwo.Reverse;
+import org.hwo.Unsigned;
+import org.hwo.buffer.BitStream;
+
+public class LZW {
+	
+	static short CLEARCODE = (short)256;
+	static short ENDOFINFORMATION = (short)257;
+	
+	ArrayList<Byte[]> stringTable;
+	ArrayList<Byte>	omega;
+	
+	LinkedList<Byte>	uncompressed;
+	BitStream			compressed;
+	
+	private boolean				byteOrder;
+	
+	public LZW()
+	{
+		stringTable = new ArrayList<Byte[]>();
+		omega = new ArrayList<Byte>();
+		uncompressed = new LinkedList<Byte>();
+		compressed = new BitStream();
+	}
+	
+	private void initializeStringTable()
+	{
+		stringTable.clear();
+		for (short n=0;n<256;n++)
+			stringTable.add(new Byte[]{ (byte)n });
+		
+		stringTable.add(new Byte[0]);
+		stringTable.add(new Byte[0]);
+		
+	}
+	
+	private byte getSymbolLength()
+	{
+		if (stringTable.size() < 511)
+			return 9;
+		if (stringTable.size() < 1023)
+			return 10;
+		if (stringTable.size() < 2047)
+			return 11;
+		return 12;		
+	}
+	
+	public void compress()
+	{
+		
+	}
+	
+	public void decompress()
+	{
+		short symbol,
+			lastsymbol = 0;
+		
+		uncompressed.clear();
+		initializeStringTable();
+		
+		try
+		{
+		
+		while ( (symbol = compressed.read(getSymbolLength())) != ENDOFINFORMATION)
+		{
+			if (symbol == CLEARCODE)
+			{
+				initializeStringTable();
+				symbol = compressed.read(getSymbolLength());
+				if (symbol == ENDOFINFORMATION)
+					break;
+				
+				uncompressed.addAll(Arrays.asList(stringTable.get(symbol)));
+				lastsymbol = symbol;
+			} else
+			{
+				if (symbol < stringTable.size())
+				{
+					Byte[] codeString = stringTable.get(symbol);
+					uncompressed.addAll(Arrays.asList(codeString));
+					
+					Byte[] b = stringTable.get(lastsymbol);
+					Byte[] nb = Arrays.copyOf(b, b.length + 1 );
+					nb[ b.length ] = codeString[0];
+					stringTable.add(nb);
+				} else
+				{
+					Byte[] b = stringTable.get(lastsymbol);
+					Byte[] nb = Arrays.copyOf(b, b.length + 1 );
+					nb[ b.length ] = b[0];
+					stringTable.add(nb);
+					uncompressed.addAll(Arrays.asList(nb));
+				}
+				lastsymbol = symbol;
+			}
+		}
+		
+		
+		} catch (Exception e)
+		{
+			e.printStackTrace();
+		}
+	}
+	
+	
+	
+	public Byte[] getBoxedUncompressedData()
+	{
+		return uncompressed.toArray(new Byte[0]);
+	}
+	public byte[] getUncompressedData()
+	{
+		Byte[] boxed = getBoxedUncompressedData();
+		byte[] unboxed = new byte[ boxed.length ];
+		
+		for (int i=0;i<boxed.length;i++)
+			unboxed[i] = boxed[i];
+			
+		return unboxed;
+	}
+	
+	
+	public void setUncompressedData(Byte[] data)
+	{
+		uncompressed.clear();
+		uncompressed.addAll(Arrays.asList(data));
+	}
+	
+	public Byte[] getBoxedCompressedData()
+	{
+		byte[] unboxed = compressed.getBuffer();
+		Byte[] boxed = new Byte[ unboxed.length ];
+		for (int i=0;i<unboxed.length;i++)
+			boxed[i] = unboxed[i];
+		return boxed;
+	}
+	public byte[] getCompressedData()
+	{
+		return compressed.getBuffer();
+	}
+
+	public void setCompressedData(Byte[] data)
+	{
+		compressed = new BitStream(data);
+	}
+	public void setCompressedData(byte[] data)
+	{
+		compressed = new BitStream(data);
+	}
+
+	public boolean isByteOrder() {
+		return byteOrder;
+	}
+
+	public void setByteOrder(boolean byteOrder) {
+		this.byteOrder = byteOrder;
+		this.compressed.setByteOrder(byteOrder);
+	}
+	
+	
+}

src/org/hwo/csv/CSV.java

@@ -0,0 +1,235 @@
+package org.hwo.csv;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.UnsupportedEncodingException;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Vector;
+
+import javassist.bytecode.EnclosingMethodAttribute;
+
+public class CSV {
+
+	List<String[]> records;
+	
+	private char	separator;
+	private char	enclosedBy;
+	
+	boolean isEnclosed;
+	List<String> parserRecord;
+	List<Character> parserField;
+	char	lastChar;
+	
+	public CSV()
+	{
+		this.records = new LinkedList<String[]>();
+		this.setSeparator(';');
+		this.setEnclosedBy('\"');
+		
+		this.parserRecord = new ArrayList<String>();
+		this.parserField = new ArrayList<Character>();
+	}
+
+	private void nextRecord()
+	{
+		nextField();
+		
+		this.records.add(parserRecord.toArray(new String[]{}));
+		parserRecord.clear();
+	}
+	
+	private void nextField()
+	{
+		char fieldChars[] = new char[ parserField.size() ];
+		
+		for (int i=0;i<parserField.size(); i++)
+			fieldChars[i] = parserField.get(i);
+		
+		parserRecord.add(String.valueOf(fieldChars));
+		parserField.clear();
+	}
+	
+	private void feeder(char ch)
+	{
+		if (ch == getEnclosedBy())
+		{
+			isEnclosed = !isEnclosed;
+
+			if (isEnclosed && lastChar == getEnclosedBy())
+				parserField.add(getEnclosedBy());
+			
+		} else
+		{
+			if (isEnclosed)
+				parserField.add(ch);
+			else
+			{
+				if (ch == '\r')
+				{
+					// Ignore \r
+				} else if (ch == '\n')
+					nextRecord();
+				else if (ch == getSeparator())
+					nextField();
+				else
+					parserField.add(ch);
+			}
+		};		
+		
+		lastChar = ch;
+	}
+	
+	public void readFromFile(String filename)
+	{
+		try {
+			readFromStream(new FileInputStream(filename));
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	public void readFromStream(InputStream is) throws IOException
+	{
+		this.readFromStream(new InputStreamReader(is,"ISO-8859-1"));
+	}
+	
+	public void readFromStream(InputStreamReader isr) throws IOException
+	{
+		BufferedReader br = new BufferedReader(isr);
+		
+		isEnclosed = false;
+		records.clear();
+		parserField.clear();
+		parserRecord.clear();
+		
+		while (br.ready())
+			feeder((char)br.read());
+	}
+	
+	
+	public void saveToFile(String filename)
+	{
+		saveToFile(new File(filename));
+	}
+	
+	public void saveToFile(File output)
+	{
+		try {
+			FileOutputStream fos = new FileOutputStream(output,false);
+			saveToStream(fos);
+		} catch (FileNotFoundException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	
+	public void saveToStream(OutputStream output)
+	{
+		OutputStreamWriter osw;
+		try {
+			osw = new OutputStreamWriter(output,"UTF8");
+			saveToStream(osw);
+		} catch (UnsupportedEncodingException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	
+	public void saveToStream(OutputStreamWriter output)
+	{
+		BufferedWriter writer = new BufferedWriter(output);
+		
+		try {
+			
+			for (String[] record:this.records)
+			{
+				for (int i=0;i<record.length;i++)
+				{
+					if (i>0)
+						writer.write(separator);
+					
+					if (record[i] != null)
+					{
+						if (String.class.isInstance(record[i]))
+							writer.write(enclosedBy);
+						
+						writer.write(record[i]);
+
+						if (String.class.isInstance(record[i]))
+							writer.write(enclosedBy);
+					}
+				}
+				writer.write("\n");
+			}
+			
+			writer.close();
+		} catch (IOException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		
+		
+	}
+	
+	public String getValue(int row,int column)
+	{
+		try
+		{
+			return this.records.get(row)[column];
+		} catch (ArrayIndexOutOfBoundsException ex)
+		{
+			return "";
+		}
+	}
+	
+	public List<String[]> getCells()
+	{
+		return this.records;
+	}
+	
+	public List<Object[]> getCellsAsObjects()
+	{
+		List<Object[]> ol = new ArrayList<Object[]>();
+		
+		for (String[] record:records)
+		{
+			Object[] ro = new Object[record.length];
+			for (int i=0;i<ro.length;i++)
+				ro[i] = record[i];
+			ol.add(ro);
+		}
+		
+		return ol;
+	}
+
+	public char getSeparator() {
+		return separator;
+	}
+
+	public void setSeparator(char separator) {
+		this.separator = separator;
+	}
+
+	public char getEnclosedBy() {
+		return enclosedBy;
+	}
+
+	public void setEnclosedBy(char enclosedBy) {
+		this.enclosedBy = enclosedBy;
+	}
+	
+	
+}

src/org/hwo/datetime/DateTime.java

@@ -0,0 +1,15 @@
+package org.hwo.datetime;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+public class DateTime {
+
+	
+	public static String getDateCode()
+	{
+		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
+		return sdf.format(new Date());
+	}
+	
+}

src/org/hwo/datetime/JTimeOfDay.java

@@ -0,0 +1,162 @@
+package org.hwo.datetime;
+
+import javax.swing.JPanel;
+
+import java.awt.GridBagLayout;
+
+import javax.swing.JSpinner;
+
+import java.awt.GridBagConstraints;
+import java.awt.Insets;
+import java.util.LinkedList;
+
+import javax.swing.JLabel;
+import javax.swing.SpinnerNumberModel;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+public class JTimeOfDay extends JPanel {
+
+	private TimeOfDay timeOfDay;
+	private LinkedList<ChangeListener> changeListeners;
+	private JSpinner spHours;
+	private JSpinner spMinutes;
+	private JSpinner spSeconds;
+	private JLabel lColon2;
+	
+	private boolean hideSeconds;
+	 
+	
+	public JTimeOfDay() {
+		GridBagLayout gridBagLayout = new GridBagLayout();
+		gridBagLayout.columnWidths = new int[]{0, 0, 0, 0, 0, 0};
+		gridBagLayout.rowHeights = new int[]{0, 0};
+		gridBagLayout.columnWeights = new double[]{1.0, 0.0, 1.0, 0.0, 1.0, Double.MIN_VALUE};
+		gridBagLayout.rowWeights = new double[]{1.0, Double.MIN_VALUE};
+		setLayout(gridBagLayout);
+		
+		spHours = new JSpinner();
+		spHours.addChangeListener(new ChangeListener() {
+			public void stateChanged(ChangeEvent e) {
+				timeOfDay.setHours((Integer)spHours.getValue());
+				fireChange();
+			}
+		});
+		spHours.setModel(new SpinnerNumberModel(0, 0, 23, 1));
+		GridBagConstraints gbc_spHours = new GridBagConstraints();
+		gbc_spHours.fill = GridBagConstraints.HORIZONTAL;
+		gbc_spHours.insets = new Insets(0, 0, 0, 5);
+		gbc_spHours.gridx = 0;
+		gbc_spHours.gridy = 0;
+		add(spHours, gbc_spHours);
+		
+		JLabel lblNewLabel = new JLabel(":");
+		GridBagConstraints gbc_lblNewLabel = new GridBagConstraints();
+		gbc_lblNewLabel.insets = new Insets(0, 0, 0, 5);
+		gbc_lblNewLabel.gridx = 1;
+		gbc_lblNewLabel.gridy = 0;
+		add(lblNewLabel, gbc_lblNewLabel);
+		
+		spMinutes = new JSpinner();
+		spMinutes.addChangeListener(new ChangeListener() {
+			public void stateChanged(ChangeEvent e) {
+				timeOfDay.setMinutes((Integer)spMinutes.getValue());
+				fireChange();
+			}
+		});
+		spMinutes.setModel(new SpinnerNumberModel(0, 0, 59, 1));
+		GridBagConstraints gbc_spMinutes = new GridBagConstraints();
+		gbc_spMinutes.fill = GridBagConstraints.HORIZONTAL;
+		gbc_spMinutes.insets = new Insets(0, 0, 0, 5);
+		gbc_spMinutes.gridx = 2;
+		gbc_spMinutes.gridy = 0;
+		add(spMinutes, gbc_spMinutes);
+		
+		lColon2 = new JLabel(":");
+		GridBagConstraints gbc_lColon2 = new GridBagConstraints();
+		gbc_lColon2.insets = new Insets(0, 0, 0, 5);
+		gbc_lColon2.gridx = 3;
+		gbc_lColon2.gridy = 0;
+		add(lColon2, gbc_lColon2);
+		
+		spSeconds = new JSpinner();
+		spSeconds.addChangeListener(new ChangeListener() {
+			public void stateChanged(ChangeEvent e) {
+				timeOfDay.setSeconds((Integer)spSeconds.getValue());
+				fireChange();
+			}
+		});
+		spSeconds.setModel(new SpinnerNumberModel(0, 0, 59, 1));
+		GridBagConstraints gbc_spSeconds = new GridBagConstraints();
+		gbc_spSeconds.fill = GridBagConstraints.HORIZONTAL;
+		gbc_spSeconds.gridx = 4;
+		gbc_spSeconds.gridy = 0;
+		add(spSeconds, gbc_spSeconds);
+		
+		initialize();
+	}
+	
+	void initialize()
+	{
+		setSecondsHidden(false);
+		
+		changeListeners = new LinkedList<ChangeListener>();
+		timeOfDay = new TimeOfDay();
+	}
+	
+	public void addChangeListener(ChangeListener changeListener)
+	{
+		changeListeners.add(changeListener);
+	}
+	public void removeChangeListener(ChangeListener changeListener)
+	{
+		changeListeners.remove(changeListener);
+	}
+
+	public Boolean getSecondsHidden()
+	{
+		return this.hideSeconds;
+	}
+
+	public void setSecondsHidden(Boolean hideSeconds)
+	{
+		this.hideSeconds = hideSeconds;
+		if (hideSeconds)
+		{
+			lColon2.setVisible(false);
+			spSeconds.setVisible(false);
+			spSeconds.setValue(0);
+		} else
+		{
+			lColon2.setVisible(true);
+			spSeconds.setVisible(true);
+		}
+		this.validate();
+	}
+	
+	void fireChange()
+	{
+		for (ChangeListener l:changeListeners)
+			l.stateChanged(new ChangeEvent(this));
+	}
+	
+	void updateView()
+	{
+		spHours.setValue(timeOfDay.getHours());
+		spMinutes.setValue(timeOfDay.getMinutes());
+		spSeconds.setValue(timeOfDay.getSeonds());
+	}
+
+	public TimeOfDay getTimeOfDay()
+	{
+		return timeOfDay;
+	}
+	
+	public void setTimeOfDay(TimeOfDay timeOfDay)
+	{
+		this.timeOfDay = timeOfDay;
+		updateView();
+	}
+	
+	
+}

src/org/hwo/datetime/TimeOfDay.java

@@ -0,0 +1,79 @@
+package org.hwo.datetime;
+
+public class TimeOfDay {
+
+	public static int getHours(int secondsOfDay)
+	{
+		return secondsOfDay / 3600;
+	}
+	public static int getMinutes(int secondsOfDay)
+	{
+		return (secondsOfDay % 3600) / 60;
+	}
+	public static int getSeconds(int secondsOfDay)
+	{
+		return (secondsOfDay % 60);
+	}
+	
+	private int secondsOfDay;
+	
+	public TimeOfDay()
+	{
+		secondsOfDay = 0;
+	}
+	public TimeOfDay(int sod)
+	{
+		secondsOfDay = sod;
+	}
+	public TimeOfDay(int hour,int minute,int second)
+	{
+		initialize(hour, minute, second);
+	}
+	
+	private void initialize(int hour,int minute,int second)
+	{
+		secondsOfDay = (hour * 3600) + (minute * 60) + second;
+	}
+	
+	public int getSeondsOfDay()
+	{
+		return secondsOfDay;
+	}
+	public void setSecondsOfDay(int secondsOfDay)
+	{
+		this.secondsOfDay = secondsOfDay;
+	}
+
+	public int getHours()
+	{
+		return getHours(secondsOfDay);
+	}
+	
+	public int getMinutes()
+	{
+		return getMinutes(secondsOfDay);
+	}
+	
+	public int getSeonds()
+	{
+		return getSeconds(secondsOfDay);
+	}
+	
+	public void setHours(int hours)
+	{
+		initialize(hours, getMinutes(), getSeonds());
+	}
+	
+	public void setMinutes(int minutes)
+	{
+		initialize(getHours(), minutes, getSeonds());
+	}
+	
+	public void setSeconds(int seconds)
+	{
+		initialize(getHours(), getMinutes(), seconds);
+	}
+	
+	
+	
+}

src/org/hwo/fifo/FiFo.java

@@ -0,0 +1,45 @@
+package org.hwo.fifo;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class FiFo<T> {
+
+	private LinkedList<T>	elements;
+	
+	public FiFo()
+	{
+		elements = new LinkedList<T>();
+	}
+	
+	public void push(T element)
+	{
+		elements.add(element);
+	}
+	
+	public T pull()
+	{
+		return elements.poll();
+	}
+	
+	public T peek()
+	{
+		return elements.peek();
+	}
+	
+	public List<T> getElements()
+	{
+		return elements;
+	}
+	
+	public boolean isEmpty()
+	{
+		return elements.isEmpty();
+	}
+	
+	public boolean hasElements()
+	{
+		return !elements.isEmpty();
+	}
+	
+}

src/org/hwo/i18n/Messages.java

@@ -0,0 +1,84 @@
+package org.hwo.i18n;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Locale;
+import java.util.MissingResourceException;
+import java.util.ResourceBundle;
+
+public class Messages {
+	
+	protected static Messages pInstance;
+	protected static List<Messages> instanceList;
+	protected static Locale activeLocale;
+	
+	protected String BUNDLE_NAME = "org.hwo.i18n.messages";
+	
+	
+	private ResourceBundle defaultResourceBundle;
+	private ResourceBundle localeResourceBundle;
+	
+	protected Messages() {
+		initialize();
+	}
+	
+	protected Messages(String bundleName)
+	{
+		BUNDLE_NAME = bundleName;
+		initialize();
+	}
+	
+	private void initialize()
+	{
+		System.err.println(this.getClass().getName() + ": Using Locale:" + activeLocale.getCountry() + " / " + activeLocale.getLanguage());
+		defaultResourceBundle = ResourceBundle.getBundle(BUNDLE_NAME);
+		localeResourceBundle = ResourceBundle.getBundle(BUNDLE_NAME,activeLocale);
+		
+		instanceList.add(this);
+	}
+	
+	public static String getString(String key) {
+		for (Messages messages: instanceList)
+		{
+			if (messages.hasKey(key))
+				return messages.getInstanceString(key);
+		}
+		return '!' + key + '!';
+	}
+	
+	public boolean hasKey(String key)
+	{
+		return localeResourceBundle.containsKey(key) | defaultResourceBundle.containsKey(key);
+	}
+	
+	public String getInstanceString(String key)
+	{
+		try {
+			if (localeResourceBundle.containsKey(key))
+				return localeResourceBundle.getString(key);
+			if (defaultResourceBundle.containsKey(key))
+				return defaultResourceBundle.getString(key);
+			return '!' + key + '!';
+		} catch (MissingResourceException e) {
+			return '!' + key + '!';
+		}
+
+	}
+	
+	public static Messages getInstance()
+	{
+		return pInstance;
+	}
+	
+	static {
+		if (activeLocale == null)
+			activeLocale = Locale.getDefault();
+
+		if (instanceList == null)
+			instanceList = new LinkedList<Messages>();
+		
+		if (pInstance == null)
+			pInstance = new Messages();
+	}
+	
+}

src/org/hwo/i18n/messages.properties

@@ -0,0 +1,6 @@
+org.hwo=HWOs Java Framework
+interface=Schnittstelle
+ok=OK
+cancel=abbrechen
+SerialPortChooser.0=Schnittstelle w\u00E4hlen
+

src/org/hwo/i18n/messages_en_US.properties

@@ -0,0 +1,6 @@
+org.hwo=HWOs Java Framework
+interface=Interface
+ok=OK
+cancel=Cancel
+SerialPortChooser.0=Select Interface
+

src/org/hwo/image/ImageFile.java

@@ -0,0 +1,23 @@
+package org.hwo.image;
+
+import java.awt.image.BufferedImage;
+import java.awt.image.RenderedImage;
+import java.io.File;
+
+public interface ImageFile {
+
+	public ImageFile newInstance();
+	
+	public Boolean identify(File imageFile);
+	
+	public void reset(); 
+	public void load(File imageFile);
+	public void save(File imageFile);
+	
+	public Integer getNumPages();
+	public BufferedImage getPage(Integer pageNo);
+	
+	public void addPage(BufferedImage image);
+	
+	
+}

src/org/hwo/image/ImageProvider.java

@@ -0,0 +1,65 @@
+package org.hwo.image;
+
+import java.awt.image.BufferedImage;
+import java.io.File;
+
+import org.hwo.image.imageio.ImageIOFile;
+import org.hwo.image.tiff.TiffFile;
+
+public class ImageProvider {
+
+	private static ImageProvider imageProvider;
+	
+	public static ImageProvider instance()
+	{
+		if (imageProvider == null)
+			imageProvider = new ImageProvider();
+		return new ImageProvider();
+	}
+	
+	ImageFile[] imageFiles = {
+			new TiffFile(),
+			new ImageIOFile("png"),
+			new ImageIOFile("jpg")
+	};
+	
+	
+	protected ImageProvider()
+	{
+	}
+	
+	public ImageFile load(File file)
+	{
+		for (ImageFile imageFile:imageFiles)
+		{
+			if (imageFile.identify(file))
+			{
+				ImageFile ifile = imageFile.newInstance();
+				ifile.load(file);
+				return ifile;
+			}
+		}
+		return null;
+	}
+	
+	public ImageFile load(String path)
+	{
+		return load(new File(path));
+	}
+	
+	public void save(BufferedImage image,File imageFile)
+	{
+		for (ImageFile ifile:imageFiles)
+		{
+			if (ifile.identify(imageFile))
+			{
+				ImageFile writer = ifile.newInstance();
+				writer.addPage(image);
+				writer.save(imageFile);
+				return;
+			}
+		}
+
+	}
+	
+}

src/org/hwo/image/UnsupportedFormatException.java

@@ -0,0 +1,15 @@
+package org.hwo.image;
+
+public class UnsupportedFormatException extends RuntimeException {
+
+	public UnsupportedFormatException()
+	{
+		super();
+	}
+	
+	public UnsupportedFormatException(String message)
+	{
+		super(message);
+	}
+	
+}

src/org/hwo/image/imageio/ImageIOFile.java

@@ -0,0 +1,111 @@
+package org.hwo.image.imageio;
+
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.util.LinkedList;
+
+import javax.imageio.ImageIO;
+import javax.imageio.ImageReader;
+import javax.imageio.ImageWriter;
+import javax.imageio.stream.ImageInputStream;
+import javax.imageio.stream.ImageOutputStream;
+
+import org.hwo.image.ImageFile;
+
+public class ImageIOFile implements ImageFile {
+	
+	private String imageType;
+	private ImageReader imageReader;
+	private ImageWriter imageWriter;
+	
+	private LinkedList<BufferedImage> images;
+	
+	public ImageIOFile(String imageType)
+	{
+		this.imageType = imageType;
+		imageReader = ImageIO.getImageReadersByFormatName(imageType).next();
+		imageWriter = ImageIO.getImageWritersByFormatName(imageType).next();
+		images = new LinkedList<BufferedImage>();
+	}
+	
+	@Override
+	public ImageFile newInstance() {
+		return new ImageIOFile(imageType);
+	}
+	
+	@Override
+	public Boolean identify(File imageFile) {
+		return imageFile.getName().endsWith("." + imageType);
+	}
+
+	@Override
+	public void reset() {
+		imageReader.reset();
+		imageWriter.reset();
+	}
+
+	@Override
+	public void load(File imageFile) {
+		reset();
+		
+		try
+		{
+			ImageInputStream iis = ImageIO.createImageInputStream(imageFile);
+			imageReader.setInput(iis);
+			
+			images.clear();
+			
+			int nImages = imageReader.getNumImages(true);
+			
+			for (int n=0;n<nImages;n++)
+				images.add(imageReader.read(n));
+			
+			iis.close();
+			
+			imageReader.reset();
+		} catch (IOException ioe)
+		{
+			ioe.printStackTrace();
+		}		
+	}
+
+	@Override
+	public void save(File imageFile) {
+		reset();
+		
+		try
+		{
+			ImageOutputStream ios = ImageIO.createImageOutputStream(imageFile);
+			imageWriter.setOutput(ios);
+			
+			for (int n=0;n<images.size();n++)
+				imageWriter.write(images.get(n));
+			
+			ios.close();
+			
+			imageWriter.reset();
+		} catch (IOException ioe)
+		{
+			ioe.printStackTrace();
+		}
+	}
+
+	@Override
+	public Integer getNumPages() {
+		return images.size();
+	}
+
+	@Override
+	public BufferedImage getPage(Integer pageNo) {
+		return images.get(pageNo);
+	}
+
+	@Override
+	public void addPage(BufferedImage image) {
+		images.add(image);
+	}
+
+	
+	
+}

src/org/hwo/image/tiff/IFD.java

@@ -0,0 +1,358 @@
+package org.hwo.image.tiff;
+
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.UUID;
+
+import javax.imageio.ImageIO;
+
+import org.hwo.Unsigned;
+import org.hwo.image.UnsupportedFormatException;
+
+class IFD
+{
+	final TiffFile tiffFile;
+
+	boolean decoded;
+	
+	Short numEntries;
+	HashMap<Short, IFDEntry> entries;
+	
+	BufferedImage bufferedImage;
+	
+	protected IFD(TiffFile tiffFile)
+	{
+		this.tiffFile = tiffFile;
+		decoded = false;
+		entries = new HashMap<Short, IFDEntry>();
+		bufferedImage = null;
+		
+		numEntries = this.tiffFile.sourceBuffer.getShort();
+		System.err.println(String.format("readIFD(): reading %d entries",numEntries));
+
+		for (int i=0;i<numEntries;i++)
+		{
+			IFDEntry entry = IFDEntry.read(this);
+			if (entry != null)
+				entries.put(entry.tag, entry);
+		}
+		
+		Integer nextIFD = this.tiffFile.sourceBuffer.getInt();
+		if (nextIFD != 0)
+		{
+			this.tiffFile.sourceBuffer.position(nextIFD);
+			this.tiffFile.ifds.add(0,new IFD(this.tiffFile));
+		}
+	}
+	protected IFD(TiffFile tiffFile, BufferedImage image)
+	{
+		this.tiffFile = tiffFile;
+		decoded = true;
+		bufferedImage = image;
+		numEntries = 0;
+		entries = new HashMap<Short, IFDEntry>();
+	}
+	
+	public boolean isDecoded()
+	{
+		return decoded;
+	}
+	
+	private BufferedImage decode()
+	{
+		System.err.println("TiffFile: Decoding...");
+		if (isDecoded())
+			return bufferedImage;
+		
+		int 	width = getWidth(),
+				height = getHeight();
+		
+		Short	compression = getCompression();
+		
+		short[] bitsPerSample = getBitsPerSample();
+		PHOTOMETRIC photometric = getPhotometric();
+		short samplesPerPixel = getSamplesPerPixel();
+		
+		System.err.println(String.format("Size: %dx%d TYPE: %s COMP: %d BPS: %s",width,height,photometric.toString(),compression,Arrays.toString(bitsPerSample)));
+
+		BufferedImage image = new BufferedImage(width, height, getJImageType(photometric, bitsPerSample));
+		
+		int rowsPerStrip = getRowsPerStrip();
+		int[] stripOffsets = getStripOffsets();
+		int[] stripByteCounts = getStripByteCounts();
+		
+		if (stripOffsets.length != stripByteCounts.length)
+			throw new UnsupportedFormatException("StripOffset.length != StripbyteCount.length");
+		
+		if ((stripOffsets.length * rowsPerStrip) < height)
+			throw new UnsupportedFormatException("stripped lines < scanlines");
+		
+		ArrayList<Strip> strips = new ArrayList<Strip>();
+		
+		for (int i=0;i<stripOffsets.length;i++)
+			strips.add(new Strip(this, stripOffsets[i], stripByteCounts[i], rowsPerStrip));
+
+		switch (photometric)
+		{
+		case BLACK:
+		case WHITE:
+			decodeGray(image,strips);
+			break;
+		case RGB:
+			decodeRGB(image,strips);
+			break;
+		default:
+			throw new UnsupportedFormatException("unsupported pixel format");
+		}		
+		return image;
+	}
+	
+	private void decodeGray(BufferedImage image,List<Strip> strips)
+	{
+		PHOTOMETRIC photometric = getPhotometric();
+
+		int 	width = getWidth(),
+				height = getHeight();
+
+		short[] bitsPerSample = getBitsPerSample();
+		short samplesPerPixel = getSamplesPerPixel();
+		
+		
+		
+		switch (bitsPerSample[0])
+		{
+		case 1:
+		case 4:
+		case 8:
+			break;
+		default:
+			throw new UnsupportedFormatException();
+		}
+
+		int y = 0;
+		short predictor = getPredictor();
+		
+		for (Strip strip:strips)
+		{
+			ByteBuffer buffer = strip.getBuffer();
+			int p = 0;
+			
+			for (int row=0; (row < strip.rowcount) && (y + row < height); row++)
+			{
+				int[] lastPixel = new int[0];
+				
+				for (int column = 0; column < width ; column++)
+				{
+					int[] pixel = new int[1];
+					
+					pixel[0] = Unsigned.byte2short(buffer.get(p));
+					if (predictor == 2 && column > 0)
+						pixel[0] += lastPixel[0];
+					 						
+					image.getRaster().setPixel(column, y + row, pixel);
+					
+					p += samplesPerPixel;
+					lastPixel = pixel;
+				}
+			}
+			y += strip.rowcount;
+		}
+		
+		
+		
+	}
+	
+	private void decodeRGB(BufferedImage image,List<Strip> strips)
+	{
+		int 	width = getWidth(),
+				height = getHeight();
+
+		short[] bitsPerSample = getBitsPerSample();
+		short samplesPerPixel = getSamplesPerPixel();
+		
+		switch (samplesPerPixel)
+		{
+		case 3:
+			break;
+		case 4:
+			break;
+		default:
+			throw new UnsupportedFormatException();
+		}
+		
+		for (int i=0;i<samplesPerPixel;i++)
+			if (bitsPerSample[i] != 8)
+				throw new UnsupportedFormatException();
+		
+		int y = 0;
+		
+		short predictor = getPredictor();
+		
+		for (Strip strip:strips)
+		{
+			ByteBuffer buffer = strip.getBuffer();
+			int p = 0;
+			
+			for (int row=0; (row < strip.rowcount) && (y + row < height); row++)
+			{
+				int[] lastPixel = new int[0];
+				
+				for (int column = 0; column < width ; column++)
+				{
+					byte r,g,b,a;
+					
+					int[] pixel = new int[samplesPerPixel];
+					
+					for (int n=0;n<samplesPerPixel;n++)
+					{
+						pixel[n] = Unsigned.byte2short(buffer.get(p + n));
+						if (predictor == 2 && column > 0)
+						{
+							pixel[n] += lastPixel[n];
+						}
+					}
+					 						
+					image.getRaster().setPixel(column, y + row, pixel);
+					
+					p += samplesPerPixel;
+					lastPixel = pixel;
+				}
+			}
+			y += strip.rowcount;
+		}
+	}
+	
+	public BufferedImage getBufferedImage()
+	{
+		if (bufferedImage == null)
+			bufferedImage = decode();
+		return bufferedImage;
+	}
+	
+	int getJImageType(PHOTOMETRIC p,short[] bitsPerSample)
+	{
+		switch (p)
+		{
+		case WHITE:
+		case BLACK:
+			return BufferedImage.TYPE_BYTE_GRAY;
+		case RGB:
+			switch (bitsPerSample.length)
+			{
+			case 3:
+				return BufferedImage.TYPE_3BYTE_BGR;
+			case 4:
+				return BufferedImage.TYPE_4BYTE_ABGR;
+			}
+			break;
+		case PALETTE:
+			return BufferedImage.TYPE_3BYTE_BGR;
+		}
+		throw new UnsupportedFormatException();
+	}
+	
+	IFDEntry getEntry(short tag)
+	{
+		if (entries.containsKey(tag))
+			return entries.get(tag);
+		return null;
+	}
+	
+	int getWidth()
+	{
+		IFDEntry e = getEntry((short)256);
+		if (e == null)
+			throw new UnsupportedFormatException("missing width tag");
+		return ((NumericEntry)e).getInteger();
+	}
+	
+	int getHeight()
+	{
+		IFDEntry e = getEntry((short)257);
+		if (e == null)
+			throw new UnsupportedFormatException("missing width tag");
+		return ((NumericEntry)e).getInteger();		
+	}
+	
+	short getPageNumber()
+	{
+		ShortEntry e = (ShortEntry)entries.get((short)297);
+		if (e == null)
+			return -1;
+		return e.getShort();
+	}
+	
+	
+	PHOTOMETRIC getPhotometric()
+	{
+		ShortEntry e = (ShortEntry)entries.get((short)262);
+		if (e == null)
+			return PHOTOMETRIC.WHITE;
+		return PHOTOMETRIC.fromCode(e.getShort());
+	}
+	
+	short[] getBitsPerSample()
+	{
+		ShortEntry e = (ShortEntry)entries.get((short)258);
+		if (e == null)
+			return new short[]{1};
+		return e.getShortArray();
+	}
+	Integer getRowsPerStrip()
+	{
+		NumericEntry e = (NumericEntry)entries.get((short)278);
+		if (e == null)
+			return 0;
+		return e.getInteger();
+	}
+	short getSamplesPerPixel()
+	{
+		ShortEntry e = (ShortEntry)entries.get((short)277);
+		if (e == null)
+			return 1;
+		return e.getShort();
+	}
+	int[] getStripOffsets()
+	{
+		NumericEntry e = (NumericEntry)entries.get((short)273);
+		if (e == null)
+			return new int[0];
+		return e.getIntArray();
+	}
+	int[] getStripByteCounts()
+	{
+		NumericEntry e = (NumericEntry)entries.get((short)279);
+		if (e == null)
+			return new int[0];
+		return e.getIntArray();			
+	}
+	short getCompression()
+	{
+		ShortEntry e = (ShortEntry)entries.get((short)259);
+		if (e == null)
+			return 1;
+		return e.getShort();
+	}
+	short getPredictor()
+	{
+		ShortEntry e = (ShortEntry)entries.get((short)317);
+		if (e == null)
+			return 1;
+		return e.getShort();
+	}
+	short getFillOrder()
+	{
+		ShortEntry e = (ShortEntry)entries.get((short)266);
+		if (e == null)
+			return 1;
+		return e.getShort();
+	}
+	
+	
+}

src/org/hwo/image/tiff/IFDEntry.java

@@ -0,0 +1,112 @@
+package org.hwo.image.tiff;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+import org.hwo.image.UnsupportedFormatException;
+
+abstract class IFDEntry
+{
+	public static IFDEntry read(IFD ifd)
+	{
+		int save = ifd.tiffFile.sourceBuffer.position(); 
+		
+		ifd.tiffFile.sourceBuffer.getShort();
+		TAGTYPE tagType = TAGTYPE.fromCode(ifd.tiffFile.sourceBuffer.getShort());
+		
+		ifd.tiffFile.sourceBuffer.position(save);
+		
+		switch (tagType)
+		{
+		case ASCII:
+			return new StringEntry(ifd);
+		case LONG:
+			return new IntegerEntry(ifd);
+		case SHORT:
+			return new ShortEntry(ifd);
+		default:	// Skip Entry
+			ifd.tiffFile.sourceBuffer.getInt();
+			ifd.tiffFile.sourceBuffer.getInt();
+			ifd.tiffFile.sourceBuffer.getInt();
+			return null;
+		}
+	}
+	
+	private final IFD ifd;
+	
+	Short		tag;
+	TAGTYPE		tagType;
+		
+	ByteBuffer	buffer;	
+	
+	
+	public IFDEntry(IFD ifd)
+	{
+		this.ifd = ifd;
+		System.err.println(String.format("readIFD(): reading entry at 0x%08x",this.ifd.tiffFile.sourceBuffer.position()));
+		
+		Integer		count,
+					offset;
+		
+		tag = this.ifd.tiffFile.sourceBuffer.getShort();
+		tagType = TAGTYPE.fromCode(this.ifd.tiffFile.sourceBuffer.getShort());
+						
+		System.err.println(String.format("TAG: %d TYPE: %s", tag, tagType));
+		
+		count = this.ifd.tiffFile.sourceBuffer.getInt();
+		offset = this.ifd.tiffFile.sourceBuffer.getInt();
+		
+		int fieldSize = tagType.getSize() * count;
+		
+		byte[] ba = new byte[ fieldSize ];
+		
+		if (fieldSize <= 4)
+			offset = this.ifd.tiffFile.sourceBuffer.position() - 4;
+		
+		int save = this.ifd.tiffFile.sourceBuffer.position();
+		
+		this.ifd.tiffFile.sourceBuffer.position(offset);
+		this.ifd.tiffFile.sourceBuffer.get(ba);
+		
+		this.ifd.tiffFile.sourceBuffer.position(save);
+
+		buffer = ByteBuffer.wrap(ba);
+		buffer.order( this.ifd.tiffFile.bigEndian ? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN );
+		
+		decodeBuffer();
+	}
+	
+	public IFDEntry(IFD ifd,Short tag,TAGTYPE tagType)
+	{
+		this.ifd = ifd;
+		this.tag = tag;
+		this.tagType = tagType;
+	}
+	
+	ByteBuffer getBuffer()
+	{
+		return buffer;
+	}
+	
+	void releaseBuffer()
+	{
+		buffer = null;
+	}
+	
+	protected void decodeBuffer()
+	{
+	}
+	
+	protected void encodeBuffer()
+	{	
+	}
+	
+	abstract public Object getValues();
+	
+	@Override
+	public String toString() {
+		return String.format("TAG: %d TYPE: %s",tag,tagType.toString());
+	}			
+	
+	
+}

src/org/hwo/image/tiff/IntegerEntry.java

@@ -0,0 +1,61 @@
+package org.hwo.image.tiff;
+
+public class IntegerEntry extends NumericEntry{
+
+	int[]	values;
+	
+	public IntegerEntry(IFD ifd)
+	{
+		super(ifd);
+	}
+	
+	public IntegerEntry(IFD ifd,Short tag)
+	{
+		super(ifd,tag,TAGTYPE.LONG);
+	}
+	
+	@Override
+	protected void decodeBuffer()
+	{
+		values = new int[ getBuffer().asIntBuffer().capacity() ];
+		getBuffer().asIntBuffer().get(values);
+		releaseBuffer();
+	}
+	
+	@Override
+	protected void encodeBuffer()
+	{
+	}
+	
+	@Override
+	public int[] getIntArray()
+	{
+		return values;
+	}
+	
+	@Override
+	public short[] getShortArray()
+	{
+		short[] svalues = new short[values.length];
+		for (int i=0;i<values.length;i++)
+			svalues[i] = (short)values[i];
+		return svalues;
+	}
+	
+	@Override
+	public int getInteger()
+	{
+		return values[0];
+	}
+
+	@Override
+	public short getShort()
+	{
+		return (short)values[0];
+	}
+
+	@Override
+	public Object getValues() {
+		return values;
+	}
+}

src/org/hwo/image/tiff/NumericEntry.java

@@ -0,0 +1,25 @@
+package org.hwo.image.tiff;
+
+public abstract class NumericEntry extends IFDEntry {
+
+	protected NumericEntry(IFD ifd)
+	{
+		super(ifd);
+	}
+	
+	protected NumericEntry(IFD ifd,short tag,TAGTYPE tagType)
+	{
+		super(ifd,tag,tagType);
+	}
+	
+	
+	
+	abstract int getInteger();
+	abstract short getShort();
+	
+	abstract int[] getIntArray();
+	abstract short[] getShortArray();
+	
+	
+	
+}

src/org/hwo/image/tiff/PHOTOMETRIC.java

@@ -0,0 +1,24 @@
+package org.hwo.image.tiff;
+
+public enum PHOTOMETRIC { UNKNOWN, WHITE, BLACK, RGB, PALETTE, TRANSPARENCY; 
+
+	public static PHOTOMETRIC fromCode(Short photometric)
+	{
+		switch (photometric)
+		{
+		case 0:
+			return WHITE;
+		case 1:
+			return BLACK;
+		case 2:
+			return RGB;
+		case 3:
+			return PALETTE;
+		case 4:
+			return TRANSPARENCY;
+		default:
+			return UNKNOWN;
+		}
+	}
+
+}

src/org/hwo/image/tiff/ShortEntry.java

@@ -0,0 +1,61 @@
+package org.hwo.image.tiff;
+
+public class ShortEntry extends NumericEntry {
+
+	short[]	values;
+	
+	public ShortEntry(IFD ifd)
+	{
+		super(ifd);
+	}
+	
+	public ShortEntry(IFD ifd,Short tag)
+	{
+		super(ifd,tag,TAGTYPE.LONG);
+	}
+	
+	@Override
+	protected void decodeBuffer()
+	{
+		values = new short[ getBuffer().asShortBuffer().capacity() ];
+		getBuffer().asShortBuffer().get(values);
+		releaseBuffer();
+	}
+	
+	@Override
+	protected void encodeBuffer()
+	{
+	}
+	
+	@Override
+	public short[] getShortArray()
+	{
+		return values;
+	}	
+
+	@Override
+	public int[] getIntArray()
+	{
+		int[] svalues = new int[values.length];
+		for (int i=0;i<values.length;i++)
+			svalues[i] = values[i];
+		return svalues;
+	}
+	
+	@Override
+	public short getShort()
+	{
+		return values[0];
+	}
+
+	@Override
+	public int getInteger()
+	{
+		return values[0];
+	}
+	
+	@Override
+	public Object getValues() {
+		return values;
+	}
+}

src/org/hwo/image/tiff/StringEntry.java

@@ -0,0 +1,30 @@
+package org.hwo.image.tiff;
+
+import java.nio.charset.Charset;
+
+public class StringEntry extends IFDEntry {
+
+	String value;
+	
+	public StringEntry(IFD ifd) {
+		super(ifd);
+	}
+
+	
+	
+	@Override
+	protected void decodeBuffer() {
+		value = new String(buffer.array(),Charset.forName("ASCII"));
+		releaseBuffer();
+	}
+	
+	@Override
+	protected void encodeBuffer() {
+	}
+	
+	
+	@Override
+	public Object getValues() {
+		return value;
+	}
+}

src/org/hwo/image/tiff/Strip.java

@@ -0,0 +1,71 @@
+package org.hwo.image.tiff;
+
+import java.nio.ByteBuffer;
+
+import org.hwo.compressor.LZW;
+import org.hwo.image.UnsupportedFormatException;
+
+class Strip
+{
+	/**
+	 * 
+	 */
+	private final IFD ifd;
+	int offset,
+		length,
+		rowcount;
+	
+	public Strip(IFD ifd, int offset,int length,int rowcount)
+	{
+		this.ifd = ifd;
+		this.offset = offset;
+		this.length = length;
+		this.rowcount = rowcount;
+	}
+	
+	public int getOffset()
+	{
+		return offset;
+	}
+	public int getLength()
+	{
+		return length;
+	}
+	public int getRowCount()
+	{
+		return rowcount;
+	}
+	
+	public ByteBuffer getBuffer()
+	{
+		ByteBuffer result;
+		
+		switch (this.ifd.getCompression())
+		{
+		case 1:
+			this.ifd.tiffFile.sourceBuffer.position(offset);
+			result = this.ifd.tiffFile.sourceBuffer.slice();
+			break;
+		case 5:
+			byte[] source = new byte[ length ];
+			this.ifd.tiffFile.sourceBuffer.position(offset);
+			this.ifd.tiffFile.sourceBuffer.get(source);
+			
+			LZW lzw = new LZW();
+			lzw.setCompressedData(source);
+			
+			if (this.ifd.getFillOrder()==2)
+				lzw.setByteOrder(true);
+			
+			lzw.decompress();
+			
+			result = ByteBuffer.wrap(lzw.getUncompressedData());
+			break;
+		default:
+			throw new UnsupportedFormatException("Unsupported compression scheme");
+		}
+		
+		return result;
+	}
+	
+}

src/org/hwo/image/tiff/TAGTYPE.java

@@ -0,0 +1,50 @@
+package org.hwo.image.tiff;
+
+public enum TAGTYPE { UNKNOWN(0), BYTE(1), ASCII(1), SHORT(2), LONG(4), RATIONAL(8), SBYTE(1), UNDEFINED(1), SSHORT(2), SLONG(4), SRATIONAL(8), FLOAT(4), DOUBLE(4);
+
+	static public TAGTYPE fromCode(Short code)
+	{
+		switch (code)
+		{
+		case 1:
+			return BYTE;
+		case 2:
+			return ASCII;
+		case 3:
+			return SHORT;
+		case 4:
+			return LONG;
+		case 5:
+			return RATIONAL;
+		case 6:
+			return SBYTE;
+		case 7:
+			return UNDEFINED;
+		case 8:
+			return SSHORT;
+		case 9:
+			return SLONG;
+		case 10:
+			return SRATIONAL;
+		case 11:
+			return FLOAT;
+		case 12:
+			return DOUBLE;
+		default:
+			return UNKNOWN;
+		}
+	}
+	
+	int size;
+	
+	private TAGTYPE(int size)
+	{
+		this.size = size;
+	}
+	
+	public int getSize()
+	{
+		return size;
+	}
+
+}

src/org/hwo/image/tiff/TiffFile.java

@@ -0,0 +1,152 @@
+package org.hwo.image.tiff;
+
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.FileInputStream;
+import java.lang.reflect.Array;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.ShortBuffer;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.hwo.image.ImageFile;
+import org.hwo.image.UnsupportedFormatException;
+
+public class TiffFile implements ImageFile {
+
+	ByteBuffer	sourceBuffer;
+	
+	boolean	bigEndian;
+	LinkedList<IFD> ifds;
+	List<BufferedImage> pages;
+	
+	
+	public TiffFile()
+	{
+		reset();
+	}
+	
+	@Override
+	public ImageFile newInstance() {
+		return new TiffFile();
+	}
+
+	@Override
+	public void reset() {
+		bigEndian = false;
+		ifds = new LinkedList<IFD>();
+		
+		pages = new LinkedList<BufferedImage>();
+		sourceBuffer = null;
+	}
+
+	@Override
+	public void load(File imageFile) {
+		
+		if (!identify(imageFile))
+			throw new UnsupportedFormatException();
+		
+		Integer firstIFD = sourceBuffer.getInt(0x0004);
+		sourceBuffer.position(firstIFD);
+		
+		ifds.add(0, new IFD(this));
+		
+		reorderPages();
+		
+	}
+		
+	private void reorderPages()
+	{
+		System.err.println("Testing Page Order");
+		
+		if (ifds.size() == 0)	// Keine Seiten vorhanden
+			return;
+		
+		if (ifds.get(0).getPageNumber() == -1)	// Keine Seitenzahlen angegeben
+			return;
+		
+		System.err.println("Reorder...");
+		
+		IFD[] ifdsOrdered = new IFD[ ifds.size() ];
+		
+		for (int n=0; n<ifdsOrdered.length; n++)
+			ifdsOrdered[ ifds.get(n).getPageNumber() ] = ifds.get(n);
+		
+		ifds.clear();
+		ifds.addAll(Arrays.asList(ifdsOrdered));
+	}
+	
+
+	@Override
+	public void save(File imageFile) {
+
+		
+	}
+
+	@Override
+	public Integer getNumPages() {
+		return ifds.size();
+	}
+
+	@Override
+	public BufferedImage getPage(Integer pageNo) {
+		if (pageNo < ifds.size())
+		{
+			return ifds.get(pageNo).getBufferedImage();
+		}
+		return null;
+	}
+
+	@Override
+	public void addPage(BufferedImage image) {
+		ifds.add(new IFD(this, image));
+	}
+	
+	@Override
+	public Boolean identify(File imageFile) {
+		
+		reset();
+		
+		if (!imageFile.exists())
+			if (imageFile.getName().endsWith(".tiff"))
+				return true;
+			else
+				return false;
+		
+		byte[] buffer = new byte[ (int)imageFile.length() ];
+
+		try
+		{
+			FileInputStream input = new FileInputStream(imageFile);
+			input.read(buffer);
+			input.close();
+			
+			sourceBuffer = ByteBuffer.wrap(buffer);
+			
+			if (sourceBuffer.getShort(0) == 0x4D4D)
+				bigEndian = true;
+			else if (sourceBuffer.getShort(0) == 0x4949)
+				bigEndian = false;
+			else			
+				return false;
+			
+			if (bigEndian)
+				sourceBuffer.order(ByteOrder.BIG_ENDIAN);
+			else
+				sourceBuffer.order(ByteOrder.LITTLE_ENDIAN);
+			
+			
+			if (sourceBuffer.getShort(0x0002) != 42)
+				return false;
+		} catch (Exception e)
+		{
+			e.printStackTrace();
+			return false;
+		}
+		return true;
+	}	
+	
+	
+}

src/org/hwo/interactiveobjects/IInteractiveObjectEditor.java

@@ -0,0 +1,10 @@
+package org.hwo.interactiveobjects;
+
+public interface IInteractiveObjectEditor {
+
+	public void setInteractiveObject(Object o);
+	public Object getInteractiveObject();
+	
+	public void setVisible(boolean visible);
+	
+}

src/org/hwo/interactiveobjects/InteractiveObject.java

@@ -0,0 +1,13 @@
+package org.hwo.interactiveobjects;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface InteractiveObject {
+	
+	public boolean			keywordSearch() default false; 
+	
+	public Class<? extends IInteractiveObjectEditor>	editor();
+	
+}

src/org/hwo/interactiveobjects/InteractiveObjectHelper.java

@@ -0,0 +1,62 @@
+package org.hwo.interactiveobjects;
+
+import java.util.Hashtable;
+
+public class InteractiveObjectHelper {
+
+	
+	private static Hashtable<Object, IInteractiveObjectEditor> p_editors = new Hashtable<Object, IInteractiveObjectEditor>();
+		
+	private static InteractiveObject getInteractiveObject(Class<?> clazz)
+	{
+		InteractiveObject io = clazz.getAnnotation(InteractiveObject.class);
+		if (io != null)
+			return io;
+		if (clazz.getSuperclass() != null)
+			return getInteractiveObject(clazz.getSuperclass());
+		return null;
+	}
+	
+	private static InteractiveObject getInteractiveObject(Object item)
+	{
+		Class<?> clazz = item.getClass();
+		return getInteractiveObject(clazz);
+	}	
+	
+	public static boolean isInteractiveObject(Class<?> clazz)
+	{
+		return (getInteractiveObject(clazz)!=null);
+	}
+	
+	public static IInteractiveObjectEditor getEditor(Object item)
+	{
+		InteractiveObject io = getInteractiveObject(item); 
+
+		if (io != null)
+		{
+			if (!p_editors.containsKey(item))
+			{
+				try
+				{
+					IInteractiveObjectEditor editor = io.editor().newInstance();
+					p_editors.put(item, editor);
+				} catch (Exception ex)
+				{
+					System.err.println(ex.toString());
+					ex.printStackTrace();
+					return null;
+				}
+			}
+			return p_editors.get(item);
+		}
+		return null;
+	}
+
+	public static void showEditor(Object o)
+	{
+		IInteractiveObjectEditor editor = getEditor(o);
+		editor.setInteractiveObject(o);
+		editor.setVisible(true);		
+	}
+	
+}

src/org/hwo/io/NativeSerialPort.java

@@ -0,0 +1,106 @@
+package org.hwo.io;
+
+import java.io.File;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.concurrent.TimeoutException;
+
+import org.hwo.fifo.FiFo;
+import org.hwo.nativeloader.NativeLoader;
+
+public class NativeSerialPort extends SerialPort {
+	
+	class SerialPortInputStream extends InputStream
+	{
+		@Override
+		public int read() throws IOException {
+			if (!isOpen())
+				throw new IOException("Port nicht gešffnet!");
+			
+			int ch = native_getch(nativeHandle,getTimeout());
+			//System.err.println(String.format("RX: 0x%08x", ch));
+			if (ch < 0)
+				throw new IOException(String.format("native_getch: returned: %d",ch));
+			return ch;
+		}
+		
+	}
+	
+	class SerialPortOutputStream extends OutputStream
+	{
+		@Override
+		public void write(int arg0) throws IOException {
+			if (!isOpen())
+				throw new IOException("Port nicht gešffnet!");
+			//System.err.println(String.format("TX: 0x%08x", arg0));
+			native_putch(nativeHandle, getTimeout(), arg0);
+		}
+	}
+	
+	
+	private static native int native_open(String portName);
+	private static native int native_close(int handle);
+	private static native int native_send(int handle,byte[] data);
+	private static native int native_recv(int handle,byte[] data);
+	
+	private static native int native_getch(int handle,int timeout);
+	private static native int native_putch(int handle,int timeout,int ch);
+	
+	private int nativeHandle;
+	
+	private SerialPortInputStream inputStream;
+	private SerialPortOutputStream outputStream;
+	
+	public NativeSerialPort()
+	{
+		nativeHandle = -1;
+		inputStream = new SerialPortInputStream();
+		outputStream = new SerialPortOutputStream();
+	}
+	
+	@Override
+	public boolean isOpen() {
+		return (nativeHandle >= 0);
+	}
+	
+	@Override
+	public boolean open() {
+		if (isOpen())
+			return false;
+		
+		nativeHandle = native_open(getPortName());
+		System.err.println(String.format("NativeSerialPort: nativeHandle: %d",nativeHandle));
+		if (nativeHandle < 0)
+			return false;
+		
+		return true;
+	}
+
+	@Override
+	public void close() {
+		if (nativeHandle >= 0)
+		{
+			System.err.println(String.format("NativeSerialPort: Closing nativeHandle %d",nativeHandle));
+			native_close(nativeHandle);
+		}
+		nativeHandle = -1;
+	}
+	
+	@Override
+	public InputStream getInputStream() {
+		return inputStream;
+	}
+	
+	@Override
+	public OutputStream getOutputStream() {
+		return outputStream;
+	}
+	
+	static {
+		NativeLoader.loadLibrary("hwoio");
+	}
+
+}

src/org/hwo/io/SerialPort.java

@@ -0,0 +1,76 @@
+package org.hwo.io;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import org.hwo.os.OsDetect;
+
+public abstract class SerialPort {
+
+	static public String[] getPortNames()
+	{
+		switch (OsDetect.getOperatingSystem())
+		{
+		case OSX:
+			return SerialPortOSX.getPortNames();
+		case WINDOWS:
+			return SerialPortWINDOWS.getPortNames();
+		case LINUX:
+			return SerialPortLINUX.getPortNames();
+		default:
+			return new String[]{};
+		}
+	}
+	
+	static public SerialPort newInstance()
+	{
+		switch (OsDetect.getOperatingSystem())
+		{
+		case OSX:
+			return new SerialPortOSX();
+		case WINDOWS:
+			return new SerialPortWINDOWS();
+		case LINUX:
+			return new SerialPortLINUX();
+		default:
+			return null;
+		}
+	}
+	
+	private String portName;
+	private int timeout;	// 0 = Non-Blocking, -1 = Block forever
+	
+	protected SerialPort()
+	{
+		this.portName = "";
+		this.timeout = -1;
+	}
+	
+	abstract public boolean isOpen();
+	abstract public boolean open();
+	abstract public void close();
+	
+	abstract public InputStream getInputStream();
+	abstract public OutputStream getOutputStream();
+	
+	
+
+	public String getPortName() {
+		return portName;
+	}
+
+	public void setPortName(String portName) {
+		this.portName = portName;
+	}
+
+	public int getTimeout() {
+		return timeout;
+	}
+
+	public void setTimeout(int timeout) {
+		this.timeout = timeout;
+	}
+	
+	
+
+	
+}

src/org/hwo/io/SerialPortChooser.java

@@ -0,0 +1,153 @@
+package org.hwo.io;
+
+import java.awt.BorderLayout;
+import java.awt.FlowLayout;
+
+import javax.swing.JButton;
+import javax.swing.JDialog;
+import javax.swing.JPanel;
+import javax.swing.border.EmptyBorder;
+
+import java.awt.Dialog.ModalExclusionType;
+import java.awt.Dialog.ModalityType;
+import java.awt.GridBagLayout;
+
+import org.hwo.i18n.Messages;
+import org.hwo.ui.JComboBoxEx;
+
+import java.awt.GridBagConstraints;
+
+import javax.swing.JLabel;
+
+import java.awt.Insets;
+import java.awt.event.ActionListener;
+import java.awt.event.ActionEvent;
+
+public class SerialPortChooser extends JDialog {
+
+	
+	public static SerialPort execute()
+	{
+		return execute(null);
+	}
+	public static SerialPort execute(String selectedPortName)
+	{
+		SerialPortChooser spc = new SerialPortChooser();
+		
+		if (selectedPortName != null)
+			spc.setSelectedSerialPort(selectedPortName);
+		
+		spc.setVisible(true);
+		
+		return spc.getSelectedSerialPort();
+	}
+	
+	
+	private final JPanel contentPanel = new JPanel();
+
+	private SerialPort selectedSerialPort;
+	private JComboBoxEx cbPortList;
+	
+	/**
+	 * Create the dialog.
+	 */
+	public SerialPortChooser() {
+		setTitle(Messages.getString("SerialPortChooser.0"));
+		setModalityType(ModalityType.APPLICATION_MODAL);
+		setModalExclusionType(ModalExclusionType.APPLICATION_EXCLUDE);
+		setModal(true);
+		setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
+		setBounds(100, 100, 491, 169);
+		getContentPane().setLayout(new BorderLayout());
+		contentPanel.setBorder(new EmptyBorder(5, 5, 5, 5));
+		getContentPane().add(contentPanel, BorderLayout.CENTER);
+		GridBagLayout gbl_contentPanel = new GridBagLayout();
+		gbl_contentPanel.columnWidths = new int[]{0, 0, 0};
+		gbl_contentPanel.rowHeights = new int[]{0, 0};
+		gbl_contentPanel.columnWeights = new double[]{0.0, 1.0, Double.MIN_VALUE};
+		gbl_contentPanel.rowWeights = new double[]{0.0, Double.MIN_VALUE};
+		contentPanel.setLayout(gbl_contentPanel);
+		{
+			JLabel lblSchnittstelle = new JLabel(Messages.getString("interface"));
+			GridBagConstraints gbc_lblSchnittstelle = new GridBagConstraints();
+			gbc_lblSchnittstelle.insets = new Insets(0, 0, 0, 5);
+			gbc_lblSchnittstelle.anchor = GridBagConstraints.EAST;
+			gbc_lblSchnittstelle.gridx = 0;
+			gbc_lblSchnittstelle.gridy = 0;
+			contentPanel.add(lblSchnittstelle, gbc_lblSchnittstelle);
+		}
+		{
+			cbPortList = new JComboBoxEx();
+			GridBagConstraints gbc_cbPortList = new GridBagConstraints();
+			gbc_cbPortList.fill = GridBagConstraints.HORIZONTAL;
+			gbc_cbPortList.gridx = 1;
+			gbc_cbPortList.gridy = 0;
+			contentPanel.add(cbPortList, gbc_cbPortList);
+		}
+		{
+			JPanel buttonPane = new JPanel();
+			buttonPane.setLayout(new FlowLayout(FlowLayout.RIGHT));
+			getContentPane().add(buttonPane, BorderLayout.SOUTH);
+			{
+				JButton okButton = new JButton(Messages.getString("ok"));
+				okButton.addActionListener(new ActionListener() {
+					public void actionPerformed(ActionEvent arg0) {
+						accept();
+					}
+				});
+				okButton.setActionCommand("OK");
+				buttonPane.add(okButton);
+				getRootPane().setDefaultButton(okButton);
+			}
+			{
+				JButton cancelButton = new JButton(Messages.getString("cancel"));
+				cancelButton.addActionListener(new ActionListener() {
+					public void actionPerformed(ActionEvent e) {
+						cancel();
+					}
+				});
+				cancelButton.setActionCommand("Cancel");
+				buttonPane.add(cancelButton);
+			}
+		}
+		
+		initialize();
+	}
+	
+	private void initialize()
+	{
+		selectedSerialPort = null;
+		
+		cbPortList.removeAllItems();
+		
+		for (String portName: SerialPort.getPortNames())
+			cbPortList.addItem(portName);
+	}
+	
+	private void accept()
+	{
+		selectedSerialPort = SerialPort.newInstance();
+		selectedSerialPort.setPortName(cbPortList.getSelectedItem().toString());
+		
+		setVisible(false);
+	}
+	
+	private void cancel()
+	{
+		selectedSerialPort = null;
+		setVisible(false);
+	}
+
+	public SerialPort getSelectedSerialPort() {
+		return selectedSerialPort;
+	}
+
+	public void setSelectedSerialPort(SerialPort selectedSerialPort) {
+		cbPortList.selectEqualItem(selectedSerialPort.getPortName());
+	}
+
+	public void setSelectedSerialPort(String portName) {
+		cbPortList.selectEqualItem(portName);
+	}
+
+}

src/org/hwo/io/SerialPortLINUX.java

@@ -0,0 +1,31 @@
+package org.hwo.io;
+
+import java.io.File;
+import java.io.FilenameFilter;
+import java.util.ArrayList;
+
+public class SerialPortLINUX extends NativeSerialPort{
+
+	static public String[] getPortNames()
+	{
+		ArrayList<String> portNames = new ArrayList<String>();
+		
+		File devDir = new File("/dev");
+		File[] list = devDir.listFiles(new FilenameFilter() {
+			
+			@Override
+			public boolean accept(File arg0, String arg1) {
+				if (arg1.startsWith("ttyS") || arg1.startsWith("ttyACM"))
+					return true;
+				return false;
+			}
+		});
+		
+		for (File file:list)
+			portNames.add("/dev/" + file.getName());
+		
+		return portNames.toArray(new String[0]);		
+	}
+	
+	
+}

src/org/hwo/io/SerialPortOSX.java

@@ -0,0 +1,31 @@
+package org.hwo.io;
+
+import java.io.File;
+import java.io.FilenameFilter;
+import java.util.ArrayList;
+
+public class SerialPortOSX extends NativeSerialPort {
+
+	static public String[] getPortNames()
+	{
+		ArrayList<String> portNames = new ArrayList<String>();
+		
+		File devDir = new File("/dev");
+		File[] list = devDir.listFiles(new FilenameFilter() {
+			
+			@Override
+			public boolean accept(File arg0, String arg1) {
+				if (arg1.startsWith("tty."))
+					return true;
+				return false;
+			}
+		});
+		
+		for (File file:list)
+			portNames.add("/dev/" + file.getName());
+		
+		return portNames.toArray(new String[0]);		
+	}	
+	
+	
+}

src/org/hwo/io/SerialPortWINDOWS.java

@@ -0,0 +1,31 @@
+package org.hwo.io;
+
+import java.io.File;
+import java.io.FilenameFilter;
+import java.util.ArrayList;
+
+public class SerialPortWINDOWS extends NativeSerialPort {
+
+	
+	static public String[] getPortNames()
+	{
+		ArrayList<String> portNames = new ArrayList<String>();
+		
+		SerialPortWINDOWS sp = new SerialPortWINDOWS();
+		
+		for (int i = 1; i < 32; i++)
+		{
+			sp.setPortName(String.format("COM%d:",i));
+			if (sp.open())
+			{
+				portNames.add(String.format("COM%d:",i));
+				sp.close();
+			}
+		}
+		
+		return portNames.toArray(new String[0]);		
+	}
+	
+	
+	
+}

src/org/hwo/io/servicelink/BitFieldEditor.java

@@ -0,0 +1,120 @@
+package org.hwo.io.servicelink;
+
+import java.awt.Component;
+import java.util.Arrays;
+
+import javax.swing.JCheckBox;
+import javax.swing.JPanel;
+
+import org.hwo.io.servicelink.ServiceLink.ServiceNode;
+import org.hwo.io.servicelink.ServiceLink.ServiceNode.ServiceNodeRegister;
+import java.awt.FlowLayout;
+import javax.swing.JScrollPane;
+import java.awt.GridBagLayout;
+import java.awt.GridBagConstraints;
+import javax.swing.BoxLayout;
+
+public class BitFieldEditor extends JPanel implements RegisterEditorControl {
+
+	private ServiceNodeRegister serviceNodeRegister;
+	
+	private JCheckBox[] checkboxes;
+	private JScrollPane scrollPane;
+	private JPanel pBits;
+	
+	public BitFieldEditor() {
+		GridBagLayout gridBagLayout = new GridBagLayout();
+		gridBagLayout.columnWidths = new int[]{0, 0};
+		gridBagLayout.rowHeights = new int[]{0, 0};
+		gridBagLayout.columnWeights = new double[]{1.0, Double.MIN_VALUE};
+		gridBagLayout.rowWeights = new double[]{1.0, Double.MIN_VALUE};
+		setLayout(gridBagLayout);
+		
+		scrollPane = new JScrollPane();
+		GridBagConstraints gbc_scrollPane = new GridBagConstraints();
+		gbc_scrollPane.fill = GridBagConstraints.BOTH;
+		gbc_scrollPane.gridx = 0;
+		gbc_scrollPane.gridy = 0;
+		add(scrollPane, gbc_scrollPane);
+		
+		pBits = new JPanel();
+		scrollPane.setViewportView(pBits);
+		pBits.setLayout(new BoxLayout(pBits, BoxLayout.Y_AXIS));
+		
+		checkboxes = new JCheckBox[0];
+	}
+	
+	private void initialize()
+	{
+		for (JCheckBox cb:checkboxes)
+		{
+			remove(cb);
+		}
+		
+		if (serviceNodeRegister != null)
+		{
+			checkboxes = new JCheckBox[32];
+			for (int i=0;i<32;i++)
+			{
+				if (serviceNodeRegister.getBitField().getLabels()[i]!=null)
+				{
+					checkboxes[i] = new JCheckBox();
+					checkboxes[i].setText(serviceNodeRegister.getBitField().getLabels()[i]);
+					
+					pBits.add(checkboxes[i]);
+				};
+			}
+			synchronize();
+		}
+		invalidate();
+	}
+	
+	public void synchronize()
+	{
+		for (int i=0;i<32;i++)
+		{
+			if (checkboxes[i]!=null)
+				checkboxes[i].setSelected(
+						(serviceNodeRegister.getIntValue() & (1<<i))!=0
+						);
+		}
+	}
+
+	@Override
+	public void setRegister(ServiceNodeRegister serviceNodeRegister) {
+		setServiceNodeRegister(serviceNodeRegister);
+	}
+
+	@Override
+	public void updateRegister() {
+		Integer v = serviceNodeRegister.getIntValue();
+		
+		for (int i=0;i<32;i++)
+		{
+			if (checkboxes[i]!=null)
+			{
+				if (checkboxes[i].isSelected())
+					v |= 1<<i;
+				else
+					v &= ~(1<<i);
+			}
+		}
+		serviceNodeRegister.setIntValue(v);
+		
+	}
+
+	@Override
+	public Component getComponent() {
+		return this;
+	}
+
+	public ServiceNodeRegister getServiceNodeRegister() {
+		return serviceNodeRegister;
+	}
+
+	public void setServiceNodeRegister(ServiceNodeRegister serviceNodeRegister) {
+		this.serviceNodeRegister = serviceNodeRegister;
+		initialize();
+	}
+
+}

src/org/hwo/io/servicelink/FloatEditor.java

@@ -0,0 +1,59 @@
+package org.hwo.io.servicelink;
+
+import java.awt.Component;
+import java.awt.event.FocusEvent;
+import java.awt.event.FocusListener;
+
+import javax.swing.JTextField;
+
+import org.hwo.io.servicelink.ServiceLink.ServiceNode.ServiceNodeRegister;
+
+public class FloatEditor extends JTextField implements RegisterEditorControl {
+
+	private ServiceNodeRegister serviceNodeRegister;
+	
+	public FloatEditor()
+	{
+		super();
+		
+		addFocusListener(new FocusListener() {
+			
+			@Override
+			public void focusLost(FocusEvent arg0) {
+			}
+			
+			@Override
+			public void focusGained(FocusEvent arg0) {
+				selectAll();
+			}
+		});
+	}
+	
+	@Override
+	public void setRegister(ServiceNodeRegister serviceNodeRegister) {
+		setServiceNodeRegister(serviceNodeRegister);
+	}
+
+	public ServiceNodeRegister getServiceNodeRegister() {
+		return serviceNodeRegister;
+	}
+
+	public void setServiceNodeRegister(ServiceNodeRegister serviceNodeRegister) {
+		this.serviceNodeRegister = serviceNodeRegister;
+		setText(serviceNodeRegister.getFloatValue().toString());
+	}
+
+	@Override
+	public void updateRegister() {
+		Float f = Float.parseFloat(getText());
+		if (f!=null)
+			serviceNodeRegister.setFloatValue(f);
+
+	}
+
+	@Override
+	public Component getComponent() {
+		return this;
+	}
+
+}

src/org/hwo/io/servicelink/IntegerEditor.java

@@ -0,0 +1,59 @@
+package org.hwo.io.servicelink;
+
+import java.awt.Component;
+import java.awt.event.FocusEvent;
+import java.awt.event.FocusListener;
+
+import javax.swing.JTextField;
+
+import org.hwo.io.servicelink.ServiceLink.ServiceNode.ServiceNodeRegister;
+
+public class IntegerEditor extends JTextField implements RegisterEditorControl {
+
+	private ServiceNodeRegister serviceNodeRegister;
+	
+	public IntegerEditor()
+	{
+		super();
+		
+		addFocusListener(new FocusListener() {
+			
+			@Override
+			public void focusLost(FocusEvent arg0) {
+			}
+			
+			@Override
+			public void focusGained(FocusEvent arg0) {
+				selectAll();
+			}
+		});
+	}
+	
+	@Override
+	public void setRegister(ServiceNodeRegister serviceNodeRegister) {
+		setServiceNodeRegister(serviceNodeRegister);
+	}
+
+	public ServiceNodeRegister getServiceNodeRegister() {
+		return serviceNodeRegister;
+	}
+
+	public void setServiceNodeRegister(ServiceNodeRegister serviceNodeRegister) {
+		this.serviceNodeRegister = serviceNodeRegister;
+		setText(serviceNodeRegister.getIntValue().toString());
+	}
+
+	@Override
+	public void updateRegister() {
+		Integer i = Integer.decode(getText());
+		if (i!=null)
+			serviceNodeRegister.setIntValue(i);
+
+	}
+
+	@Override
+	public Component getComponent() {
+		return this;
+	}
+
+}

src/org/hwo/io/servicelink/RegisterEditor.java

@@ -0,0 +1,209 @@
+package org.hwo.io.servicelink;
+
+import java.awt.BorderLayout;
+import java.awt.EventQueue;
+
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+import javax.swing.border.EmptyBorder;
+
+import org.hwo.interactiveobjects.IInteractiveObjectEditor;
+import org.hwo.io.servicelink.ServiceLink.ServiceNode.ServiceNodeRegister;
+
+import java.awt.GridBagLayout;
+
+import javax.swing.JLabel;
+
+import java.awt.GridBagConstraints;
+import java.awt.Insets;
+
+import javax.swing.JTextField;
+import javax.swing.JButton;
+import javax.xml.ws.ServiceMode;
+
+import java.awt.event.ActionListener;
+import java.awt.event.ActionEvent;
+import java.awt.event.WindowFocusListener;
+import java.awt.event.WindowEvent;
+
+public class RegisterEditor extends JFrame implements IInteractiveObjectEditor{
+
+	private JPanel contentPane;
+	private JTextField tfRegister;
+	private JLabel lblLabel;
+	private JTextField tfValueAct;
+
+	ServiceNodeRegister serviceNodeRegister;
+	private JPanel pEditor;
+	
+	private RegisterEditorControl editorControl;
+	
+	public RegisterEditor() {
+		addWindowFocusListener(new WindowFocusListener() {
+			public void windowGainedFocus(WindowEvent arg0) {
+				if (editorControl != null)
+					editorControl.requestFocusInWindow();
+			}
+			public void windowLostFocus(WindowEvent arg0) {
+			}
+		});
+		setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
+		setBounds(100, 100, 628, 304);
+		contentPane = new JPanel();
+		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
+		setContentPane(contentPane);
+		GridBagLayout gbl_contentPane = new GridBagLayout();
+		gbl_contentPane.columnWidths = new int[]{0, 0, 0};
+		gbl_contentPane.rowHeights = new int[]{0, 0, 0, 0, 0, 0};
+		gbl_contentPane.columnWeights = new double[]{1.0, 1.0, Double.MIN_VALUE};
+		gbl_contentPane.rowWeights = new double[]{0.0, 0.0, 0.0, 1.0, 0.0, Double.MIN_VALUE};
+		contentPane.setLayout(gbl_contentPane);
+		
+		JLabel lblRegister = new JLabel("Register:");
+		GridBagConstraints gbc_lblRegister = new GridBagConstraints();
+		gbc_lblRegister.anchor = GridBagConstraints.EAST;
+		gbc_lblRegister.insets = new Insets(0, 0, 5, 5);
+		gbc_lblRegister.gridx = 0;
+		gbc_lblRegister.gridy = 0;
+		contentPane.add(lblRegister, gbc_lblRegister);
+		
+		tfRegister = new JTextField();
+		tfRegister.setEditable(false);
+		GridBagConstraints gbc_tfRegister = new GridBagConstraints();
+		gbc_tfRegister.insets = new Insets(0, 0, 5, 0);
+		gbc_tfRegister.fill = GridBagConstraints.HORIZONTAL;
+		gbc_tfRegister.gridx = 1;
+		gbc_tfRegister.gridy = 0;
+		contentPane.add(tfRegister, gbc_tfRegister);
+		tfRegister.setColumns(10);
+		
+		JLabel lblBezeichnung = new JLabel("Bezeichnung:");
+		GridBagConstraints gbc_lblBezeichnung = new GridBagConstraints();
+		gbc_lblBezeichnung.anchor = GridBagConstraints.EAST;
+		gbc_lblBezeichnung.insets = new Insets(0, 0, 5, 5);
+		gbc_lblBezeichnung.gridx = 0;
+		gbc_lblBezeichnung.gridy = 1;
+		contentPane.add(lblBezeichnung, gbc_lblBezeichnung);
+		
+		lblLabel = new JLabel("N/A");
+		GridBagConstraints gbc_lblLabel = new GridBagConstraints();
+		gbc_lblLabel.insets = new Insets(0, 0, 5, 0);
+		gbc_lblLabel.gridx = 1;
+		gbc_lblLabel.gridy = 1;
+		contentPane.add(lblLabel, gbc_lblLabel);
+		
+		JLabel lblAlterWert = new JLabel("Alter Wert:");
+		GridBagConstraints gbc_lblAlterWert = new GridBagConstraints();
+		gbc_lblAlterWert.anchor = GridBagConstraints.EAST;
+		gbc_lblAlterWert.insets = new Insets(0, 0, 5, 5);
+		gbc_lblAlterWert.gridx = 0;
+		gbc_lblAlterWert.gridy = 2;
+		contentPane.add(lblAlterWert, gbc_lblAlterWert);
+		
+		tfValueAct = new JTextField();
+		tfValueAct.setEditable(false);
+		GridBagConstraints gbc_tfValueAct = new GridBagConstraints();
+		gbc_tfValueAct.anchor = GridBagConstraints.NORTH;
+		gbc_tfValueAct.insets = new Insets(0, 0, 5, 0);
+		gbc_tfValueAct.fill = GridBagConstraints.HORIZONTAL;
+		gbc_tfValueAct.gridx = 1;
+		gbc_tfValueAct.gridy = 2;
+		contentPane.add(tfValueAct, gbc_tfValueAct);
+		tfValueAct.setColumns(10);
+		
+		JLabel lblNeuerWert = new JLabel("Neuer Wert:");
+		GridBagConstraints gbc_lblNeuerWert = new GridBagConstraints();
+		gbc_lblNeuerWert.anchor = GridBagConstraints.NORTHEAST;
+		gbc_lblNeuerWert.insets = new Insets(0, 0, 5, 5);
+		gbc_lblNeuerWert.gridx = 0;
+		gbc_lblNeuerWert.gridy = 3;
+		contentPane.add(lblNeuerWert, gbc_lblNeuerWert);
+		
+		pEditor = new JPanel();
+		GridBagConstraints gbc_pEditor = new GridBagConstraints();
+		gbc_pEditor.insets = new Insets(0, 0, 5, 0);
+		gbc_pEditor.fill = GridBagConstraints.BOTH;
+		gbc_pEditor.gridx = 1;
+		gbc_pEditor.gridy = 3;
+		contentPane.add(pEditor, gbc_pEditor);
+		pEditor.setLayout(new BorderLayout(0, 0));
+		
+		JPanel panel = new JPanel();
+		GridBagConstraints gbc_panel = new GridBagConstraints();
+		gbc_panel.gridwidth = 2;
+		gbc_panel.fill = GridBagConstraints.BOTH;
+		gbc_panel.gridx = 0;
+		gbc_panel.gridy = 4;
+		contentPane.add(panel, gbc_panel);
+		GridBagLayout gbl_panel = new GridBagLayout();
+		gbl_panel.columnWidths = new int[]{0, 0, 0};
+		gbl_panel.rowHeights = new int[]{0, 0};
+		gbl_panel.columnWeights = new double[]{1.0, 1.0, Double.MIN_VALUE};
+		gbl_panel.rowWeights = new double[]{0.0, Double.MIN_VALUE};
+		panel.setLayout(gbl_panel);
+		
+		JButton btnNewButton = new JButton("schreiben...");
+		btnNewButton.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				editorControl.updateRegister();
+				serviceNodeRegister.write();
+				setVisible(false);
+			}
+		});
+		GridBagConstraints gbc_btnNewButton = new GridBagConstraints();
+		gbc_btnNewButton.insets = new Insets(0, 0, 0, 5);
+		gbc_btnNewButton.gridx = 0;
+		gbc_btnNewButton.gridy = 0;
+		panel.add(btnNewButton, gbc_btnNewButton);
+		
+		JButton btnNewButton_1 = new JButton("abbrechen");
+		btnNewButton_1.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				setVisible(false);
+			}
+		});
+		GridBagConstraints gbc_btnNewButton_1 = new GridBagConstraints();
+		gbc_btnNewButton_1.gridx = 1;
+		gbc_btnNewButton_1.gridy = 0;
+		panel.add(btnNewButton_1, gbc_btnNewButton_1);
+
+	}
+
+
+	@Override
+	public void setInteractiveObject(Object o) {
+		serviceNodeRegister = (ServiceNodeRegister)o;
+		
+		serviceNodeRegister.read();
+		
+		tfRegister.setText(serviceNodeRegister.register.toString());
+		lblLabel.setText(serviceNodeRegister.label);
+		tfValueAct.setText(serviceNodeRegister.value());
+		
+		if (editorControl != null)
+			pEditor.remove(editorControl.getComponent());
+		
+		if (serviceNodeRegister.isInteger())
+		{
+			editorControl = new IntegerEditor();
+		} else if (serviceNodeRegister.isFloat())
+		{
+			editorControl = new FloatEditor();
+		} else if (serviceNodeRegister.isBitField())
+		{
+			editorControl = new BitFieldEditor();
+		}
+		editorControl.setRegister(serviceNodeRegister);
+		pEditor.add(editorControl.getComponent());
+		pEditor.invalidate();
+
+		
+	}
+
+
+	@Override
+	public Object getInteractiveObject() {
+		return serviceNodeRegister;
+	}
+
+}

src/org/hwo/io/servicelink/RegisterEditorControl.java

@@ -0,0 +1,16 @@
+package org.hwo.io.servicelink;
+
+import java.awt.Component;
+
+import javax.tools.JavaCompiler;
+
+import org.hwo.io.servicelink.ServiceLink.ServiceNode.ServiceNodeRegister;
+
+public interface RegisterEditorControl {
+
+	public void setRegister(ServiceNodeRegister serviceNodeRegister);
+	public boolean requestFocusInWindow();
+	public void updateRegister();
+	
+	public Component getComponent();
+}

src/org/hwo/io/servicelink/ServiceLink.java

@@ -0,0 +1,491 @@
+package org.hwo.io.servicelink;
+
+import java.io.IOException;
+import java.lang.ref.ReferenceQueue;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.hwo.BitField;
+import org.hwo.ChkSum;
+import org.hwo.interactiveobjects.InteractiveObject;
+import org.hwo.io.SerialPort;
+import org.hwo.models.TableMapper.TableColumn;
+
+/* ServiceLink
+ * 
+ * Kommunikation via USB mit RegBus fŠhigem System
+ * 
+ * †bertragungssicherheit wird durch USB sichergestellt
+ * 
+ * †bertragen werden Telegramme mit folgendem Aufbau:
+ * 
+ * Offset	Type		Inhalt
+ * 0		Byte		RequestTyp	( 0 = NoOP, 1 = Wert lesen, 2 = Wert schreiben, 3 = Ereignis senden )
+ * 1		Byte		Achse
+ * 2		Byte		Knoten
+ * 3		Short		Register Nummer
+ * 5		Int32/Float	Wert (nur bei schreiben oder lesen antwort)
+ * 
+ */
+
+
+public class ServiceLink {
+	
+	static int REQ_READ = 0x01;
+	static int REQ_WRITE = 0x02;
+	static int REQ_EVENT = 0x04;
+	static int REQ_FAIL = 0x08;
+	
+	static int REQ_INT = 0x10;
+	static int REQ_FLOAT = 0x20;
+	static int REQ_ACK = 0x40;
+	
+	static int SL_MAGIC = 0x66;
+	
+	
+	class ServiceTelegram
+	{
+		byte request;
+		byte achse;
+		byte knoten;
+		int register;
+		byte[] value;
+		
+		public ServiceTelegram()
+		{
+			request = 0;
+			achse = 0;
+			knoten = 0;
+			register = 0;
+			value = new byte[4];
+			ByteBuffer.wrap(value).asIntBuffer().put(0);
+		}
+		
+		public void send()
+		{
+			byte[] txbuffer = new byte[12];
+			ByteBuffer bb = ByteBuffer.wrap(txbuffer).order(ByteOrder.LITTLE_ENDIAN);
+
+			bb.put( (byte)SL_MAGIC );
+			bb.put(request);
+			bb.put(achse);
+			bb.put(knoten);
+			bb.putShort((short)register);
+			if ((request & REQ_WRITE) == REQ_WRITE)
+				bb.put(value);
+			
+			short chk = ChkSum.chksum(txbuffer, 1, bb.position()-1);
+			bb.putShort(chk);
+
+			try
+			{			
+				getSerialPort().getOutputStream().write(txbuffer,0,bb.position());
+			} catch (IOException ex)
+			{
+				getSerialPort().close();
+				System.err.println(ex.toString());
+			}
+			
+		}
+		
+		public void recv() throws ServiceLinkException
+		{
+			byte[] rxbuffer = new byte[12];			
+			ByteBuffer bb = ByteBuffer.wrap(rxbuffer).order(ByteOrder.LITTLE_ENDIAN);
+			
+			try {
+				int ch = getSerialPort().getInputStream().read();
+				
+				while ((ch != SL_MAGIC) && (ch >= 0))
+					ch = getSerialPort().getInputStream().read();
+				
+				getSerialPort().getInputStream().read(rxbuffer,0,5);
+				
+				request = bb.get();
+				achse = bb.get();
+				knoten = bb.get();
+				register = bb.getShort();
+				
+				if ((request & (REQ_READ | REQ_ACK)) == (REQ_READ | REQ_ACK))
+				{
+					getSerialPort().getInputStream().read(rxbuffer,bb.position(),4);
+					bb.get(value);
+				};
+				getSerialPort().getInputStream().read(rxbuffer,bb.position(),2);
+				short chksum = bb.getShort();
+				
+				if (chksum != ChkSum.chksum(rxbuffer, 0, bb.position() - 2))
+					throw new ServiceLinkException();
+				
+			} catch (IOException e) {
+				getSerialPort().close();
+
+				System.err.println(e.toString());
+				throw new ServiceLinkException(e);
+			}
+		}
+		
+	}
+		
+	public class ServiceNode
+	{
+		@InteractiveObject(editor=RegisterEditor.class)
+		public class ServiceNodeRegister
+		{
+			@TableColumn(label="Register",readonly=true,width=60)
+			Integer register;
+			@TableColumn(label="Bezeichnung",readonly=true,width=150)
+			String label;
+			
+			private Float floatValue;
+			private Integer intValue;
+			
+			boolean floatType;
+			
+			private BitField bitField;
+			
+			public ServiceNodeRegister(int register,boolean floatType)
+			{
+				this.label = String.format("%d", register);
+				this.register = register;
+				this.floatType = floatType;
+			}
+			public ServiceNodeRegister(int register,String label,boolean floatType)
+			{
+				this.label = label;
+				this.register = register;
+				this.floatType = floatType;
+			}
+			
+			public boolean isBitField()
+			{
+				return (bitField != null);
+			}
+			
+			public boolean isFloat()
+			{
+				return floatType;
+			}
+			
+			public boolean isInteger()
+			{
+				return (!isBitField() && !isFloat());
+			}
+			
+			@TableColumn(label="Wert",width=500)
+			public String value()
+			{
+				if (bitField != null)
+					return bitField.toText(intValue);
+				if (intValue != null)
+					return String.format("%d", intValue);
+				if (floatValue != null)
+					return String.format("%f", floatValue);
+				return "N/A";
+			}
+			
+			public void setValue(String value)
+			{
+				if (floatType)
+					floatValue = new Float(value);
+				else
+					intValue = new Integer(value);
+			}
+			
+			public void read()
+			{
+				try {
+					if (floatType)
+						floatValue = ServiceNode.this.readFloat(register);
+					else
+						intValue = ServiceNode.this.readInt(register);
+				} catch (Exception e) {
+					floatValue = null;
+					intValue = 0;
+					e.printStackTrace();
+				};
+			}
+			
+			public void write()
+			{
+				try
+				{
+					if (floatType)
+						ServiceNode.this.writeFloat(register, floatValue);
+					else
+						ServiceNode.this.writeInt(register, intValue);
+				} catch (Exception e)
+				{
+					e.printStackTrace();
+				}
+			}
+			public BitField getBitField() {
+				return bitField;
+			}
+			public void setBitField(BitField bitField) {
+				this.bitField = bitField;
+			}
+			public Integer getIntValue() {
+				return intValue;
+			}
+			public void setIntValue(Integer intValue) {
+				this.intValue = intValue;
+			}
+			public Float getFloatValue() {
+				return floatValue;
+			}
+			public void setFloatValue(Float floatValue) {
+				this.floatValue = floatValue;
+			}
+			
+			
+		}
+
+		private byte achse;
+		private byte knoten;
+		
+		List<ServiceNodeRegister> registers;
+		
+		public ServiceNode(byte achse,byte knoten)
+		{
+			this.achse = achse;
+			this.knoten = knoten;
+			this.registers = new ArrayList<ServiceLink.ServiceNode.ServiceNodeRegister>();
+		}
+		
+		public ServiceNodeRegister createRegister(int register,String label,boolean floatType)
+		{
+			return new ServiceNodeRegister(register, label, floatType);
+		}
+		
+		public List<ServiceNodeRegister> getRegisters()
+		{
+			return registers;
+		}
+		
+		public void read()
+		{
+			for (ServiceNodeRegister r:registers)
+				r.read();				
+		}
+		
+		public ServiceLink getServiceLink()
+		{
+			return ServiceLink.this;
+		}
+		
+		public int readInt(int register) throws IOException, ServiceLinkException
+		{
+			for (int n=0;n<retries;n++)
+			{
+				try
+				{
+					return ServiceLink.this.readInt(achse, knoten, register);
+				} catch (ServiceLinkException e)
+				{
+					if (n == (retries -1))
+						throw e;
+				}
+			}
+			throw new ServiceLinkException();
+		}
+		
+		public float readFloat(int register) throws IOException, ServiceLinkException
+		{
+			for (int n=0;n<retries;n++)
+			{
+				try
+				{
+					return ServiceLink.this.readFloat(achse, knoten, register);
+				} catch (ServiceLinkException e)
+				{
+					if (n == (retries -1))
+						throw e;
+				}
+			}
+			throw new ServiceLinkException();
+		}
+		
+		public void writeInt(int register,int value) throws IOException, ServiceLinkException
+		{
+			for (int n=0;n<retries;n++)
+			{
+				try
+				{
+					ServiceLink.this.writeInt(achse, knoten, register, value);
+					return;
+				} catch (ServiceLinkException e)
+				{
+					if (n == (retries -1))
+						throw e;
+				}
+			}
+			throw new ServiceLinkException();
+		}
+		
+		public void writeFloat(int register,float value) throws IOException, ServiceLinkException
+		{
+			for (int n=0;n<retries;n++)
+			{
+				try
+				{
+					ServiceLink.this.writeFloat(achse, knoten, register,value);
+					return;
+				} catch (ServiceLinkException e)
+				{
+					if (n == (retries -1))
+						throw e;
+				}
+			}
+			throw new ServiceLinkException();
+		}
+
+		public byte getAchse() {
+			return achse;
+		}
+
+		public void setAchse(byte achse) {
+			this.achse = achse;
+		}
+
+		public byte getKnoten() {
+			return knoten;
+		}
+
+		public void setKnoten(byte knoten) {
+			this.knoten = knoten;
+		}
+		
+	}
+	
+	
+	
+	private SerialPort serialPort;
+	int			retries;
+	
+	public ServiceLink(SerialPort serialPort)
+	{
+		this.retries = 3;
+		this.serialPort = serialPort;
+		this.serialPort.setTimeout(500);
+		
+		try
+		{
+			System.err.println(String.format("BRKVAL : 0x%04x",readInt((byte)0,(byte)0,(short)0x200)));
+			System.err.println(String.format("SPLIMIT: 0x%04x",readInt((byte)0,(byte)0,(short)0x201)));
+		} catch (Exception e)
+		{
+			e.printStackTrace();
+		}
+	}
+	
+	public void open() throws ServiceLinkException
+	{
+		if (serialPort != null)
+			serialPort.open();
+		throwNotOpen();
+	}
+	
+	public void close()
+	{
+		if (serialPort != null)
+			serialPort.close();
+	}
+	
+	@Override
+	protected void finalize() throws Throwable {
+		if (serialPort.isOpen())
+			serialPort.close();
+	}
+	
+	public ServiceNode getServiceNode(byte achse,byte knoten)
+	{		
+		return new ServiceNode(achse, knoten);
+	}
+	
+	public Integer readInt(byte achse,byte knoten,int register) throws IOException, ServiceLinkException, ServiceLinkRequestFailedException
+	{
+		throwNotOpen();	
+		return ByteBuffer.wrap( request((byte)(REQ_READ | REQ_INT), achse, knoten, register).value ).order(ByteOrder.LITTLE_ENDIAN).asIntBuffer().get();
+	}
+
+	public Float readFloat(byte achse,byte knoten,int register) throws IOException, ServiceLinkException, ServiceLinkRequestFailedException
+	{
+		throwNotOpen();
+		return ByteBuffer.wrap( request((byte)(REQ_READ | REQ_FLOAT), achse, knoten, register).value ).order(ByteOrder.LITTLE_ENDIAN).asFloatBuffer().get();
+	}
+	
+	public void writeInt(byte achse,byte knoten,int register,int value) throws IOException, ServiceLinkException, ServiceLinkRequestFailedException
+	{
+		throwNotOpen();
+		
+		byte[] v = new byte[4];
+		ByteBuffer bb = ByteBuffer.wrap(v).order(ByteOrder.LITTLE_ENDIAN);
+		bb.putInt(value);
+		
+		ServiceTelegram telegram = request((byte)(REQ_WRITE | REQ_INT), achse, knoten, register, v);
+	}
+
+	public void writeFloat(byte achse,byte knoten,int register,float value) throws IOException, ServiceLinkException, ServiceLinkRequestFailedException
+	{
+		throwNotOpen();
+		
+		byte[] v = new byte[4];
+		ByteBuffer bb = ByteBuffer.wrap(v).order(ByteOrder.LITTLE_ENDIAN);
+		bb.putFloat(value);
+		
+		ServiceTelegram telegram = request((byte)(REQ_WRITE | REQ_FLOAT), achse, knoten, register, v);		
+	}
+		
+	private synchronized ServiceTelegram request(byte request,byte achse,byte knoten,int register) throws IOException, ServiceLinkException, ServiceLinkRequestFailedException
+	{
+		return request(request,achse,knoten,register,new byte[0]);
+	}
+	private synchronized ServiceTelegram request(byte request,byte achse,byte knoten,int register,byte[] value) throws IOException, ServiceLinkException, ServiceLinkRequestFailedException
+	{
+		ServiceTelegram telegram = new ServiceTelegram();
+		
+		telegram.request = request;
+		telegram.achse = achse;
+		telegram.knoten = knoten;
+		telegram.register = register;
+		
+		if (value.length == 4)
+			telegram.value = value;
+		
+		
+		telegram.send();
+		telegram.recv();
+		
+		if ((telegram.request & REQ_ACK)==0)
+			throw new ServiceLinkRequestFailedException();
+		
+		return telegram;
+	}
+
+	public SerialPort getSerialPort() {
+		return serialPort;
+	}
+
+	public void setSerialPort(SerialPort serialPort) {
+		if (isOpen())
+			this.serialPort.close();
+		
+		this.serialPort = serialPort;
+	}
+	
+	private void throwNotOpen() throws ServiceLinkException
+	{
+		if (!isOpen())
+			throw new ServiceLinkException("Port not Opened!");		
+	}
+	
+	public boolean isOpen()
+	{
+		return this.serialPort.isOpen();
+	}
+	
+	
+}

src/org/hwo/io/servicelink/ServiceLinkException.java

@@ -0,0 +1,23 @@
+package org.hwo.io.servicelink;
+
+import java.io.IOException;
+
+public class ServiceLinkException extends Exception {
+
+	public ServiceLinkException()
+	{
+	}
+	
+	public ServiceLinkException(String message)
+	{
+		super(message);
+	}
+	
+	public ServiceLinkException(Throwable e) {
+		super(e);
+	}
+
+	
+	
+	
+}

src/org/hwo/io/servicelink/ServiceLinkRequestFailedException.java

@@ -0,0 +1,5 @@
+package org.hwo.io.servicelink;
+
+public class ServiceLinkRequestFailedException extends ServiceLinkException {
+
+}

src/org/hwo/layout/TextLayouter.java

@@ -0,0 +1,73 @@
+package org.hwo.layout;
+
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.Graphics2D;
+import java.awt.font.GlyphVector;
+import java.awt.image.BufferedImage;
+import java.util.LinkedList;
+
+public class TextLayouter {
+
+	private Font font;
+	private FontMetrics metrics;
+	
+	private char[] characters;
+	
+	private GlyphVector[] glyphs;
+	
+	private int position;
+	
+	public TextLayouter(String text)
+	{
+		this.setFont(new Font("Arial", 0, 50));
+		this.characters = text.toCharArray();
+	}
+	
+	public TextLayouter(String text,Font font)
+	{
+		this.characters = text.toCharArray();
+		this.setFont(font);
+	}
+
+	public int getPosition() {
+		return position;
+	}
+
+	public void setPosition(int position) {
+		this.position = position;
+	}
+	
+	public String getLine(float width)
+	{
+		LinkedList<Character> lineCharacters = new LinkedList<Character>();
+		float x = 0;
+		
+		while ( position < characters.length )
+		{
+		
+		}
+		
+		
+		
+		//return String.valueOf(lineCharacters.toArray(new char[0]));
+		return "";
+	}
+
+	public Font getFont() {
+		return font;
+	}
+
+	public void setFont(Font font) {
+		this.font = font;
+		
+		BufferedImage img = new BufferedImage(5, 5, BufferedImage.TYPE_INT_RGB);
+		Graphics2D g2d = img.createGraphics();
+		g2d.setFont(font);
+		this.metrics = g2d.getFontMetrics(); 
+	}
+	
+	
+	
+	
+}

src/org/hwo/models/Column.java

@@ -0,0 +1,132 @@
+package org.hwo.models;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class Column {
+	private int MODE_FIELD = 1;
+	private int MODE_GETSET = 2;
+	
+	private int mode;
+	private String fieldName;
+	private boolean readonly;
+	private Class p_class;
+	private Field field;
+	private Method getter;
+	private Method setter;
+		
+	public Column(Class classInfo,String fieldName,boolean readonly) throws NoSuchFieldException
+	{
+		this.fieldName = fieldName;
+		this.readonly = readonly;
+		this.p_class = classInfo;
+		this.getter = null;
+		this.setter = null;
+		
+		try
+		{
+			mode = MODE_FIELD;
+			this.field = this.p_class.getDeclaredField(fieldName);
+			this.field.setAccessible(true);
+		} catch (NoSuchFieldException nsfex)
+		{
+			mode = MODE_GETSET;
+			// Kein deklariertes Feld, also suchen wir eine get... und set... Methode...
+			Method[] methods = this.p_class.getDeclaredMethods();
+			for (Method method : methods) {
+				// passender getter?
+				if (("get"+fieldName.toLowerCase()).equals(method.getName().toLowerCase()))
+					getter = method;
+				// passender setter?
+				if (("set"+fieldName.toLowerCase()).equals(method.getName().toLowerCase()))
+					setter = method;
+			}
+			if (getter == null)
+				throw nsfex;
+		}
+	}
+	
+	
+	public String getFieldName()
+	{
+		return this.fieldName;
+	}
+	
+	public boolean getReadOnly()
+	{
+		if ((mode == MODE_GETSET) && (setter == null))
+			return true;
+		
+		return this.readonly;
+	}
+	public void setReadOnly(boolean readOnly)
+	{
+		this.readonly = readOnly;
+	}
+	
+	public Class getColumnClass()
+	{
+		if (mode == MODE_GETSET)
+			return this.getter.getReturnType();
+		
+		return this.field.getType();
+	}
+	
+	Object getValue(Object o)
+	{
+		try
+		{
+			if (mode == MODE_GETSET)
+			{
+				try
+				{
+					Object ro = this.getter.invoke(o, null);
+					return ro;
+				} catch (InvocationTargetException itex)
+				{
+					System.err.println(itex.toString());
+					itex.printStackTrace();					
+				}
+			}
+			return this.field.get(o);
+		} catch (IllegalArgumentException e) {
+			System.err.println("IllegalArgument! " + e.toString());
+			e.printStackTrace();
+		} catch (IllegalAccessException e) {
+			// TODO Auto-generated catch block
+			System.err.println("IllegalAccess! " + e.toString());
+			e.printStackTrace();
+		}
+		return null;
+	}
+	void setValue(Object o,Object value)
+	{
+		try
+		{
+			if (mode == MODE_GETSET)
+			{
+				if (this.setter != null)
+				{
+					try
+					{
+						this.setter.invoke(o,new Object[]{ value });
+					} catch (InvocationTargetException itex)
+					{
+						System.err.println(itex.toString());
+						itex.printStackTrace();						
+					}
+				}
+			}
+			this.field.set(o,value);
+		} catch (IllegalArgumentException e) {
+			System.err.println("IllegalArgument! " + e.toString());
+			e.printStackTrace();
+		} catch (IllegalAccessException e) {
+			// TODO Auto-generated catch block
+			System.err.println("IllegalAccess! " + e.toString());
+			e.printStackTrace();
+		}
+		return;
+	}
+}

src/org/hwo/models/FlexibleObjectListModel.java

@@ -0,0 +1,55 @@
+package org.hwo.models;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.swing.AbstractListModel;
+
+public class FlexibleObjectListModel<T> extends AbstractListModel {
+
+	private List<T> items;
+	
+	public FlexibleObjectListModel() {
+		this.items = new ArrayList<T>();
+	}
+	
+	@Override
+	public Object getElementAt(int index) {
+		return this.items.get(index);
+	}
+
+	@Override
+	public int getSize() {
+		return this.items.size();
+	}
+	
+	public void clear()
+	{
+		this.items.clear();
+		fireContentsChanged(this, 0, getSize());
+	}
+
+	public List<T> getItems() {
+		return items;
+	}
+
+	public void setItems(List<T> items) {
+		this.items = items;
+		fireContentsChanged(this, 0, getSize());
+	}
+
+	public void addItem(T o)
+	{
+		this.items.add(o);
+		fireContentsChanged(this, 0, getSize());
+	}
+	
+	public void removeItem(T o)
+	{
+		int index = this.items.indexOf(o);
+		this.items.remove(o);
+		fireContentsChanged(this, 0, getSize());
+	}
+	
+	
+	
+}

src/org/hwo/models/FlexibleObjectTableModel.java

@@ -0,0 +1,115 @@
+package org.hwo.models;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.swing.table.AbstractTableModel;
+
+public class FlexibleObjectTableModel<T> extends AbstractTableModel{
+
+	List<Column> columns;
+	List<T>	rows;
+	
+	Class p_classinfo;
+	
+	public FlexibleObjectTableModel(Class tClass)
+	{
+		this.columns = new ArrayList<Column>();
+		this.rows = new ArrayList<T>();
+		
+		this.p_classinfo = tClass;		
+	}
+	
+	
+	public void addColumn(String fieldName)
+	{
+		this.addColumn(fieldName,true);
+	}
+	public void addColumn(String fieldName,boolean readOnly)
+	{
+		try
+		{
+			this.columns.add(new Column(this.p_classinfo,fieldName,readOnly));
+			fireTableStructureChanged();
+		} catch (NoSuchFieldException nsfex)
+		{
+			System.err.println(nsfex.toString());
+			nsfex.printStackTrace();
+		}
+	}
+
+	
+	public List<T> getRows()
+	{
+		return this.rows;
+	}
+	public void setRows(List<T> rows)
+	{
+		this.rows = rows;
+		this.fireTableDataChanged();
+	}
+
+	public int indexOf(Object o)
+	{
+		return this.rows.indexOf(o);
+	}
+	
+	public void addRow(T o)
+	{
+		this.rows.add(o);
+		this.fireTableDataChanged();
+	}
+	
+	public void removeRow(T o)
+	{
+		this.rows.remove(o);
+		this.fireTableDataChanged();
+	}
+	public void removeRow(int row)
+	{
+		this.rows.remove(row);
+		this.fireTableDataChanged();
+	}
+	
+	@Override
+	public int getColumnCount() {
+		return this.columns.size();
+	}
+
+	@Override
+	public int getRowCount() {
+		return this.rows.size();
+	}
+
+	@Override
+	public Object getValueAt(int arg0, int arg1) {
+			return this.columns.get(arg1).getValue(this.rows.get(arg0));
+	}
+	
+	@Override
+	public String getColumnName(int columnIndex)
+	{
+		return this.columns.get(columnIndex).getFieldName();
+	}
+
+	@Override
+	public void setValueAt(Object aValue,
+            int rowIndex,
+            int columnIndex)
+	{
+		this.columns.get(columnIndex).setValue(this.rows.get(rowIndex), aValue);
+	}
+	
+	@Override
+	public boolean isCellEditable(int rowIndex,int columnIndex)
+	{
+		return !this.columns.get(columnIndex).getReadOnly();
+	}	
+	
+	@Override
+	public Class getColumnClass(int columnIndex)
+	{
+		return this.columns.get(columnIndex).getColumnClass();
+	}
+	
+	
+}

src/org/hwo/models/ListTableModel.java

@@ -0,0 +1,56 @@
+package org.hwo.models;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.swing.table.AbstractTableModel;
+
+public class ListTableModel extends AbstractTableModel {
+
+	private List<Object[]> rows;
+	
+	public ListTableModel()
+	{
+		rows = new ArrayList<Object[]>();
+		rows.add(new Object[]{"Eins","Zwei","Drei"});
+	}
+	
+	
+	private Integer calcColumnCount()
+	{
+		Integer max = 0;
+		
+		for (Object[] record:rows)
+			if (record.length > max)
+				max = record.length;
+		
+		return max;
+	}
+	
+	@Override
+	public int getColumnCount() {
+		return calcColumnCount();
+	}
+
+	@Override
+	public int getRowCount() {
+		return rows.size();
+	}
+
+	@Override
+	public Object getValueAt(int rowIndex, int columnIndex) {
+		return rows.get(rowIndex)[columnIndex];
+	}
+
+
+	public List<Object[]> getRows() {
+		return rows;
+	}
+
+
+	public void setRows(List<Object[]> rows) {
+		this.rows = rows;
+		fireTableStructureChanged();
+	}
+
+}

src/org/hwo/models/TableMapper/AbstractTableMapperListener.java

@@ -0,0 +1,10 @@
+package org.hwo.models.TableMapper;
+
+public abstract class AbstractTableMapperListener implements
+		TableMapperListener {
+
+	@Override
+	public void ValueChanged(int row, int column) {
+	}
+
+}

src/org/hwo/models/TableMapper/TableColumn.java

@@ -0,0 +1,17 @@
+package org.hwo.models.TableMapper;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface TableColumn {
+	
+	String 		label() default "";
+	boolean		readonly() default false;
+	boolean		visible() default true;
+	int			width() default 100;
+	String		after() default "";
+	boolean		firstColumn() default false;
+}
+
+

src/org/hwo/models/TableMapper/TableMapper.java

@@ -0,0 +1,637 @@
+package org.hwo.models.TableMapper;
+
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+import java.io.File;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Hashtable;
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.swing.JTable;
+import javax.swing.event.ListSelectionListener;
+import javax.swing.table.AbstractTableModel;
+
+import org.hwo.csv.CSV;
+import org.hwo.interactiveobjects.InteractiveObjectHelper;
+
+public class TableMapper extends AbstractTableModel
+{
+
+	private static final long serialVersionUID = -6556060772230310664L;
+
+	public class ColumnInfo
+	{
+		private TableColumn p_annotation;
+		
+		private Field	p_field;
+		private Method 	p_method;
+		private String	p_label;
+		private boolean p_readonly;
+		private Class<?> p_columnclass;
+		private int width;
+		private TableColumn tableColumn;
+		
+		private ColumnInfo nextColumn;
+		
+		protected ColumnInfo(TableColumn tc,Field field)
+		{
+			tableColumn = tc;
+			p_annotation = field.getAnnotation(TableColumn.class);
+
+			p_method = null;
+			p_field = field;
+			p_columnclass = field.getType();
+			
+			initialize();
+
+			if (p_label.equals(""))
+				p_label = field.getName();
+			
+			field.setAccessible(true);
+		}
+		protected ColumnInfo(TableColumn tc,Method method)
+		{
+			tableColumn = tc;
+			p_annotation = method.getAnnotation(TableColumn.class);
+			
+			p_method = method;
+			p_field = null;
+			p_columnclass = method.getReturnType();
+
+			initialize();
+
+			if (p_label.equals(""))
+				p_label = method.getName();
+
+			method.setAccessible(true);
+			
+			p_readonly = true;
+		}
+
+		private void initialize()
+		{
+			p_label = p_annotation.label();
+			p_readonly = p_annotation.readonly();
+			setWidth(p_annotation.width());
+		}
+		
+		public void appendAtEnd(ColumnInfo column)
+		{
+			if (nextColumn == null)
+				nextColumn = column;
+			else
+				nextColumn.appendAtEnd(column);
+		}
+		
+		public List<ColumnInfo> toList()
+		{
+			List<ColumnInfo> list = new LinkedList<TableMapper.ColumnInfo>();
+			appendToList(list);
+			return list;
+		}
+		
+		public void appendToList(List<ColumnInfo> list)
+		{
+			list.add(this);
+			if (nextColumn != null)
+				nextColumn.appendToList(list);
+		}
+		
+		public void removeColumn(ColumnInfo ci)
+		{
+			if (nextColumn == ci)
+			{
+				nextColumn = ci.nextColumn;
+				ci.nextColumn = null;
+			} else if (nextColumn != null)
+				nextColumn.removeColumn(ci);
+		}
+		
+		public ColumnInfo findColumnByName(String name)
+		{
+			if (this.p_label.equals(name))
+				return this;
+			if (nextColumn!=null)
+				return nextColumn.findColumnByName(name);
+			else
+				return null;
+		}
+		
+		public void append(ColumnInfo ci)
+		{
+			ci.nextColumn = nextColumn;
+			nextColumn = ci;
+		}
+		
+
+		public String getLabel()
+		{
+			return this.p_label;
+		}
+		public void setLabel(String label)
+		{
+			this.p_label = label;
+		}
+	
+		public boolean getReadOnly()
+		{
+			return this.p_readonly;
+		}
+		public void setReadOnly(boolean readOnly)
+		{
+			this.p_readonly = readOnly;
+		}
+		
+		public void setColumnClass(Class<?> cl)
+		{
+			this.p_columnclass = cl;
+		}
+		public Class<?> getColumnClass()
+		{
+			return this.p_columnclass;
+		}
+		
+		public Object getValue(Object instance) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException
+		{
+			if (p_field != null)
+				return p_field.get(instance);
+			if (p_method != null)
+				return p_method.invoke(instance, null);
+			return null;
+		}
+		
+		public void setValue(Object instance,Object value) throws IllegalAccessException
+		{
+			if (p_field != null)
+				p_field.set(instance, value);
+		}
+
+		public int getWidth() {
+			return width;
+		}
+
+		public void setWidth(int width) {
+			this.width = width;
+		}
+
+		public ColumnInfo getNextColumn() {
+			return nextColumn;
+		}
+
+		public void setNextColumn(ColumnInfo nextColumn) {
+			this.nextColumn = nextColumn;
+		}
+
+		public TableColumn getTableColumn() {
+			return tableColumn;
+		}
+
+		public void setTableColumn(TableColumn tableColumn) {
+			this.tableColumn = tableColumn;
+		}
+
+	}
+	
+	
+	private Class<?> p_class;
+	
+	private ColumnInfo firstColumn;
+	
+	private List<Object>	p_rows;
+	private List<ColumnInfo> 	p_columns; 
+	private boolean				p_readonly;	// Table readonly...
+
+	private TableMapperColumnModel
+								columnModel;
+	
+	private JTable			jTable;
+	
+	private TableMapperObject
+							tableMapperObject;
+	private Field			editorObjectField;
+	private Class<?>		editorObjectClass;
+	
+	private MouseAdapter	mouseAdapter;
+	
+	private boolean			editorEnabled;
+	
+	private LinkedList<TableMapperListener> tableMapperListeners;
+	
+	public TableMapper(Class<?> clazz,JTable table)
+	{
+		this.tableMapperListeners = new LinkedList<TableMapperListener>();
+		this.p_class = clazz;
+		this.jTable = table;
+		
+		this.firstColumn = null;
+		
+		this.p_rows = new LinkedList<Object>();
+		this.p_columns = new ArrayList<TableMapper.ColumnInfo>();
+		this.p_readonly = false;
+		
+		initializeMapper();
+		initializeColumnInfo();
+				
+		table.setModel(this);
+		table.setColumnModel(new TableMapperColumnModel(this));
+		
+		table.setAutoCreateRowSorter(true);
+
+		mouseAdapter = new MouseAdapter() {
+			
+			@Override
+			public void mouseClicked(MouseEvent e) {
+				switch (e.getButton())
+				{
+				case 1:
+					if (e.getClickCount()==2)
+					{
+						openEditor();
+					}
+				}
+			}
+		};
+
+		
+		if (InteractiveObjectHelper.isInteractiveObject(editorObjectClass))
+			setEditorEnabled(true);
+		
+	}
+	
+	private void initializeMapper()
+	{
+		tableMapperObject = p_class.getAnnotation(TableMapperObject.class);
+		if (tableMapperObject != null)
+		{
+			if (tableMapperObject.editorField() != null)
+			{
+				try {
+					editorObjectField = p_class.getDeclaredField(tableMapperObject.editorField());
+					editorObjectField.setAccessible(true);
+					
+					editorObjectClass = editorObjectField.getType();
+					
+				} catch (SecurityException e) {
+					// TODO Auto-generated catch block
+					e.printStackTrace();
+				} catch (NoSuchFieldException e) {
+					// TODO Auto-generated catch block
+					e.printStackTrace();
+				}
+				
+			}
+		} else
+		{
+			editorObjectClass = p_class;
+		}
+		
+	}
+	
+	public void addListSelectionListener(ListSelectionListener listener)
+	{
+		jTable.getSelectionModel().addListSelectionListener(listener);
+	}
+	public void removeListSelectionListener(ListSelectionListener listener)
+	{
+		jTable.getSelectionModel().removeListSelectionListener(listener);
+	}
+	
+	public void addTableMapperListener(TableMapperListener listener)
+	{
+		tableMapperListeners.add(listener);
+	}
+	public void removeTableMapperListener(TableMapperListener listener)
+	{
+		tableMapperListeners.remove(listener);
+	}
+	
+	protected void fireValueChanged(int row,int column)
+	{
+		for (TableMapperListener listener: tableMapperListeners)
+			listener.ValueChanged(row, column);
+	}
+	
+	private Object getEditorObject()
+	{
+		if (jTable.getSelectedRow()!=-1)
+		{
+			int row = jTable.convertRowIndexToModel(jTable.getSelectedRow());
+			Object rowObject = p_rows.get(row);
+			if (editorObjectField == null)
+				return rowObject;
+			
+			try {
+				Object editorObject = editorObjectField.get(rowObject);
+				return editorObject;
+				
+			} catch (IllegalArgumentException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			} catch (IllegalAccessException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+			
+		}
+		return null;
+	}
+	
+	private void openEditor()
+	{
+		Object editorObject = getEditorObject();
+		if (editorObject!=null)
+			InteractiveObjectHelper.showEditor(editorObject);
+	}
+	
+	public List<ColumnInfo> getColumnInfo()
+	{
+		return p_columns;
+	}
+	
+	public void setRows(List rows)
+	{
+		this.p_rows = rows;
+		fireTableDataChanged();
+	}
+	public List getRows()
+	{
+		return this.p_rows;
+	}
+	
+	public <T> List<T> getRows(Class<T> clazz)
+	{
+		return (List<T>) p_rows;	
+	}
+	
+	public void clear()
+	{
+		this.p_rows.clear();
+		fireTableDataChanged();
+	}
+	
+	public boolean isEditorEnabled()
+	{
+		return editorEnabled;
+	}
+	
+	public void setEditorEnabled(boolean enabled)
+	{
+		if (enabled)
+			jTable.addMouseListener(mouseAdapter);
+		else
+			jTable.removeMouseListener(mouseAdapter);
+		
+		editorEnabled = enabled;
+	}
+	
+	private void addColumnInfo(ColumnInfo ci)
+	{
+		if (ci.getTableColumn().firstColumn())
+			p_columns.add(0,ci);
+		else
+			p_columns.add(ci);
+		/*
+		if (firstColumn == null)
+			firstColumn = ci;
+		else
+		{
+			if (ci.getTableColumn().firstColumn())
+			{
+				ci.setNextColumn(firstColumn);
+				firstColumn = ci;
+			} else
+				firstColumn.appendAtEnd(ci);
+		}
+		*/
+	}
+	
+	private void addFieldsOfClass(Class<?> clazz)
+	{
+		if (clazz.getSuperclass() != null)
+			addFieldsOfClass(clazz.getSuperclass());
+		
+		for (Field field: clazz.getDeclaredFields())
+		{
+			if (field.getAnnotation(TableColumn.class)!=null)
+			{
+				ColumnInfo ci = new ColumnInfo(field.getAnnotation(TableColumn.class),field);
+				addColumnInfo(ci);
+			}
+		}		
+		
+		for (Method method: clazz.getDeclaredMethods())
+		{
+			if (method.getAnnotation(TableColumn.class)!=null)
+			{
+				ColumnInfo ci = new ColumnInfo(method.getAnnotation(TableColumn.class),method);
+				addColumnInfo(ci);
+			}
+		}
+		
+	}
+	
+
+	private int findColumnIndexByName(String name)
+	{
+		for (int i=0;i<p_columns.size();i++)
+		{
+			if (p_columns.get(i).p_label.equals(name))
+				return i;
+		}
+		return -1;
+	}
+	
+	private void reorderColumns()
+	{
+		List<ColumnInfo> lc = new ArrayList<TableMapper.ColumnInfo>(p_columns);
+		
+		for (ColumnInfo ci:lc)
+		{
+			if (!ci.getTableColumn().after().equals(""))
+			{
+				int indColumn = p_columns.indexOf(ci);
+				int indBefore = findColumnIndexByName(ci.getTableColumn().after());
+				if (indBefore != -1)
+				{
+					if (indBefore < indColumn)
+					{
+						List<ColumnInfo> subset = new ArrayList<TableMapper.ColumnInfo>(p_columns.subList(indColumn, p_columns.size()));
+						p_columns.removeAll(subset);
+						p_columns.addAll(indBefore+1, subset);
+					} else
+					{
+						List<ColumnInfo> subset = new ArrayList<TableMapper.ColumnInfo>(p_columns.subList(indColumn, indBefore));
+						p_columns.removeAll(subset);
+						p_columns.addAll(indColumn+1, subset);
+					}
+				}
+			}
+		}
+	}
+	
+	private void initializeColumnInfo()
+	{
+		addFieldsOfClass(p_class);
+		reorderColumns();
+	}
+	
+	public void setReadOnly(boolean readOnly)
+	{
+		this.p_readonly = readOnly;
+	}
+	public boolean getReadOnly()
+	{
+		return this.p_readonly;
+	}
+	
+	public void addRow(Object row)
+	{
+		this.p_rows.add(row);
+		//fireTableRowsInserted(getRowCount()-1, getRowCount()-1);
+		fireTableDataChanged();
+	}
+	public void removeRow(Object row)
+	{
+		int index = this.p_rows.indexOf(row);
+		if (index != -1)
+		{
+			this.p_rows.remove(index);
+			fireTableRowsDeleted(index, index);
+		};
+	}
+	
+	public Object getRow(int index)
+	{
+		return this.p_rows.get(index);
+	}
+
+	public <T> T getRow(int index,Class<T> clazz)
+	{
+		return (T)this.p_rows.get(index);
+	}
+	
+	public Object appendNewInstance()
+	{
+		try
+		{
+			Object instance = this.p_class.newInstance();
+			if (instance != null)			
+				addRow(instance);
+			return instance;
+		} catch (Exception ex)
+		{
+			return null;
+		}
+	}
+	
+	
+	
+	@Override
+	public int getColumnCount() {
+		return this.p_columns.size();
+	}
+
+	@Override
+	public int getRowCount() {
+		return this.p_rows.size();
+	}
+
+	@Override
+	public Object getValueAt(int rowIndex, int columnIndex) {
+		if ( (rowIndex < this.p_rows.size()) && (columnIndex < this.p_columns.size()))
+		{
+			try
+			{
+				return this.p_columns.get(columnIndex).getValue(this.p_rows.get(rowIndex));
+			} catch (Exception ex)
+			{
+				System.err.println("Exception: " + ex);
+				ex.printStackTrace();
+			}
+		}
+		return "";
+	}
+
+	
+	@Override
+	public void setValueAt(Object aValue,
+            int rowIndex,
+            int columnIndex)
+	{
+		try
+		{
+			this.p_columns.get(columnIndex).setValue(this.p_rows.get(rowIndex), aValue);
+			fireValueChanged(rowIndex, columnIndex);
+		} catch (IllegalAccessException ex)
+		{
+			System.err.println("IllegalAccessException: " + ex);
+			ex.printStackTrace();			
+		}
+	}
+	
+	@Override
+	public boolean isCellEditable(int rowIndex,int columnIndex)
+	{
+		if (this.p_readonly)
+			return false;
+		return !this.p_columns.get(columnIndex).getReadOnly();
+	}	
+	
+	@Override
+	public Class<?> getColumnClass(int columnIndex)
+	{
+		Class<?> c = this.p_columns.get(columnIndex).getColumnClass(); 
+		return c;
+	}
+	
+	@Override
+	public String getColumnName(int columnIndex)
+	{
+		return this.p_columns.get(columnIndex).getLabel();
+	}
+	
+	public Object getSelectedRow()
+	{
+		if (jTable.getSelectedRow()!=-1)
+		{
+			return this.p_rows.get(jTable.convertRowIndexToModel(jTable.getSelectedRow()));
+		}
+		return null;
+	}
+	
+	public boolean exportToFile(File exportFile)
+	{
+		CSV csv = new CSV();
+		
+		List<String[]> cells = csv.getCells();
+		
+		String[] header = new String[ getColumnCount() ];
+		for (int i=0;i<getColumnCount();i++)
+			header[i] = p_columns.get(i).getLabel();
+
+		cells.add( header );
+		
+		for (int row=0;row<getRowCount();row++)
+		{
+			String[] record = new String[ getColumnCount() ];
+			
+			for (int column=0;column<getColumnCount();column++)
+				if (getValueAt(row, column)!=null)
+					record[column] = getValueAt(row, column).toString();
+				else
+					record[column] = "";
+			
+			cells.add(record);
+		}
+		
+		csv.saveToFile(exportFile);
+		return true;			
+	}
+	
+	
+};

src/org/hwo/models/TableMapper/TableMapperColumnModel.java

@@ -0,0 +1,170 @@
+package org.hwo.models.TableMapper;
+
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.LinkedList;
+import java.util.Vector;
+
+import javax.swing.DefaultListSelectionModel;
+import javax.swing.ListSelectionModel;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.TableColumnModelListener;
+import javax.swing.table.TableColumn;
+import javax.swing.table.TableColumnModel;
+
+import org.hwo.models.TableMapper.TableMapper.ColumnInfo;
+
+class TableMapperColumnModel implements TableColumnModel{
+
+	private TableMapper tableMapper;
+	private LinkedList<TableColumnModelListener> listeners;
+	
+	private ArrayList<TableColumn> tableColumns;
+	
+	private int margin;
+	
+	private ListSelectionModel listSelectionModel;
+	
+	public TableMapperColumnModel(TableMapper tableMapper)
+	{
+		this.tableMapper = tableMapper;
+		this.listeners = new LinkedList<TableColumnModelListener>();
+		this.tableColumns = new ArrayList<TableColumn>();
+		this.listSelectionModel = new DefaultListSelectionModel();
+
+		for (int i=0;i<tableMapper.getColumnCount();i++)
+		{
+			ColumnInfo ci = tableMapper.getColumnInfo().get(i);
+			TableColumn tc = new TableColumn(i, ci.getWidth());
+			tc.setPreferredWidth(ci.getWidth());
+			tc.setHeaderValue(ci.getLabel());
+			tc.addPropertyChangeListener(new PropertyChangeListener() {
+				
+				@Override
+				public void propertyChange(PropertyChangeEvent arg0) {
+					fireColumnMarginChanged();
+				}
+			});
+			tableColumns.add(tc);
+		}
+		
+	}
+	
+	protected void fireColumnMarginChanged()
+	{
+		for (TableColumnModelListener listener:listeners)
+			listener.columnMarginChanged(new ChangeEvent(this));
+	}
+	
+	@Override
+	public void addColumn(TableColumn aColumn) {
+	}
+
+	@Override
+	public void addColumnModelListener(TableColumnModelListener x) {
+		listeners.add(x);
+	}
+
+	@Override
+	public void removeColumnModelListener(TableColumnModelListener x) {
+		listeners.remove(x);
+	}
+
+
+
+	@Override
+	public TableColumn getColumn(int columnIndex) {
+		return tableColumns.get(columnIndex);
+	}
+
+	@Override
+	public int getColumnCount() {
+		return tableColumns.size();
+	}
+
+	@Override
+	public int getColumnIndex(Object columnIdentifier) {
+		return 0;
+	}
+
+	@Override
+	public int getColumnIndexAtX(int xPosition) {
+		int pos = 0;
+		for (int i=0;i<tableColumns.size();i++)
+		{
+			pos += tableColumns.get(i).getWidth();
+			
+			if (xPosition < pos)
+				return i;
+			
+		}
+		return -1;
+	}
+
+	@Override
+	public int getColumnMargin() {
+		return margin;
+	}
+
+	@Override
+	public boolean getColumnSelectionAllowed() {
+		return false;
+	}
+
+	@Override
+	public Enumeration<TableColumn> getColumns() {
+		return new Vector<TableColumn>(tableColumns).elements();
+	}
+
+	@Override
+	public int getSelectedColumnCount() {
+		return 0;
+	}
+
+	@Override
+	public int[] getSelectedColumns() {
+		return new int[0];
+	}
+
+	@Override
+	public ListSelectionModel getSelectionModel() {
+		return listSelectionModel;
+	}
+
+	@Override
+	public int getTotalColumnWidth() {
+		int width = 0;
+		for (TableColumn tc:tableColumns)
+			width += tc.getWidth();
+		return width;
+	}
+
+	@Override
+	public void moveColumn(int columnIndex, int newIndex) {
+		
+	}
+
+	@Override
+	public void removeColumn(TableColumn column) {
+		
+	}
+
+	@Override
+	public void setColumnMargin(int newMargin) {
+		margin = newMargin;
+		fireColumnMarginChanged();
+	}
+
+	@Override
+	public void setColumnSelectionAllowed(boolean flag) {
+		
+	}
+
+	@Override
+	public void setSelectionModel(ListSelectionModel newModel) {
+		listSelectionModel = newModel;
+	}
+
+}

src/org/hwo/models/TableMapper/TableMapperListener.java

@@ -0,0 +1,7 @@
+package org.hwo.models.TableMapper;
+
+public interface TableMapperListener {
+
+	public void ValueChanged(int row,int column);
+	
+}

src/org/hwo/models/TableMapper/TableMapperObject.java

@@ -0,0 +1,11 @@
+package org.hwo.models.TableMapper;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface TableMapperObject {
+
+	String editorField();
+	
+}

src/org/hwo/nativeloader/NativeLoader.java

@@ -0,0 +1,80 @@
+package org.hwo.nativeloader;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import javax.management.RuntimeErrorException;
+
+import org.hwo.os.OsDetect;
+
+public class NativeLoader {
+
+	public static void loadLibrary(String libName)
+	{
+		try
+		{
+			System.loadLibrary(libName);
+			return;
+		} catch (UnsatisfiedLinkError e)
+		{
+			System.err.println("Native Library not found, trying to load from JAR-File");
+			System.err.println(e);
+			e.printStackTrace();
+		}
+		
+		String platformLibName;
+		String resourcePath;
+		
+		switch (OsDetect.getOperatingSystem())
+		{
+		case LINUX:
+			platformLibName = String.format("lib%s.so",libName);
+			break;
+		case OSX:
+			platformLibName = String.format("lib%s.dylib",libName);
+			break;
+		case WINDOWS:
+			platformLibName = String.format("%s.dll",libName);
+			break;
+		default:
+			throw new RuntimeException("Betriebssystem nicht unterstŸtzt!");
+		}
+		
+		System.err.println(String.format("NativeLoader: Platform dependent Name: %s",platformLibName));
+		
+		resourcePath = "/native/" + platformLibName;
+		System.err.println(String.format("NativeLoader: Resource name: %s",resourcePath));
+		
+		InputStream libInputStream = NativeLoader.class.getResourceAsStream(resourcePath);
+		if (libInputStream == null)
+		{
+			System.err.println("Resource wurde nicht gefunden!");
+		}
+		
+		try {
+			File tempLibFile = File.createTempFile("native-", platformLibName);
+			FileOutputStream fos = new FileOutputStream(tempLibFile);
+			
+			System.err.println(String.format("Using Temp File: %s",tempLibFile.getAbsoluteFile()));
+			System.err.println(String.format("Size: %d",libInputStream.available()));
+			
+			byte[] buffer = new byte[libInputStream.available()];
+			libInputStream.read(buffer);
+			fos.write(buffer);
+			fos.close();
+			
+			System.err.println(String.format("Loading: %s", tempLibFile.getAbsolutePath()));
+			System.load(tempLibFile.getAbsolutePath());
+			
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+			
+		}
+
+	}
+	
+	
+}

src/org/hwo/net/ServerObject.java

@@ -0,0 +1,19 @@
+package org.hwo.net;
+
+import java.io.IOException;
+
+import org.hwo.net.serverobjects.ServerObjectRequest;
+
+public interface ServerObject {
+
+	public ServerObject getRootObject();
+	public ServerObject getParent();
+	public ServerObject[] getChildren();
+	public ServerObject getNamedChild(String childName);
+	
+	public void	addNamedChild(String childName,ServerObject serverObject);
+	
+	public void climb(ServerObjectRequest request) throws IOException;
+	public void request(ServerObjectRequest request) throws IOException;	
+	
+}

src/org/hwo/net/ServerObjectProvider.java

@@ -0,0 +1,7 @@
+package org.hwo.net;
+
+public interface ServerObjectProvider {
+
+	
+	
+}

src/org/hwo/net/http/HttpRequestURI.java

@@ -0,0 +1,66 @@
+package org.hwo.net.http;
+
+import java.util.Arrays;
+
+public class HttpRequestURI {
+
+	private String requestPath;
+	private HttpServerRequest request;
+	
+	private String path;
+	private String[] elements;
+	private String queryString;
+	private String hostname;
+	private Integer port;
+	
+	public HttpRequestURI(HttpServerRequest request,String path)
+	{	
+		this.requestPath = path;
+		this.request = request;
+	}
+
+	public void decode()
+	{
+		if (requestPath.indexOf('?')>0)
+		{
+			queryString = requestPath.substring(requestPath.indexOf('?')+1);
+			this.path = requestPath.substring(0,requestPath.indexOf('?'));
+		} else
+		{
+			queryString = "";
+			this.path = requestPath;
+		}
+		
+		String ptokens[] = this.path.split("/");
+		if (ptokens.length>0)
+			elements = Arrays.copyOfRange(ptokens, 1, ptokens.length);
+		else
+			elements = new String[0];
+		
+		hostname = request.getRequestHeader("Host");
+		if (hostname.indexOf(':')>0)
+		{
+			String[] tokens = hostname.split(":");
+			hostname = tokens[0];
+			port = Integer.parseInt(tokens[1]);
+		}
+	}
+	
+	public String getPath()
+	{
+		return path;
+	}
+	
+	public String getQueryString()
+	{
+		return queryString;
+	}
+	
+	public String[] getPathElements()
+	{
+		return elements;
+	}
+	
+	
+	
+}

src/org/hwo/net/http/HttpServer.java

@@ -0,0 +1,90 @@
+package org.hwo.net.http;
+
+import java.io.IOException;
+import java.net.HttpRetryException;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+import org.hwo.net.requesthandler.ServerObjectHandler;
+import org.hwo.net.serverobjects.VirtualRootObject;
+
+public class HttpServer extends Thread {
+
+	private int port;
+	private ServerSocket serverSocket;
+	
+	private HttpServerConnectionFactory connectionFactory;
+	private HttpServerRequestFactory requestFactory;
+	private HttpServerRequestHandler requestHandler;
+	
+	public HttpServer(int port)
+	{
+		this.port = port;
+		this.connectionFactory = new HttpServerConnection.Factory();
+		this.requestFactory = new HttpServerRequest.Factory();
+		
+		this.requestHandler = new HttpServerRequestHandler() {
+			
+			@Override
+			public void doRequest(HttpServerRequest httpRequest) throws IOException{
+				httpRequest.setResponseHeader("Content-Type", "text/plain");
+				httpRequest.getResponseWriter().write("This Page has no other content than this text.");
+			}
+		};
+	}
+	
+	public HttpServerConnectionFactory getConnectionFactory()
+	{
+		return connectionFactory;
+	}
+	public void setConnectionFactory(HttpServerConnectionFactory factory)
+	{
+		connectionFactory = factory;
+	}
+	
+	
+	public HttpServerRequestFactory getRequestFactory()
+	{
+		return requestFactory;
+	}
+	public void setRequestFactory(HttpServerRequestFactory factory)
+	{
+		requestFactory = factory;
+	}
+	
+	public HttpServerRequestHandler getRequestHandler() {
+		return requestHandler;
+	}
+
+	public void setRequestHandler(HttpServerRequestHandler requestHandler) {
+		this.requestHandler = requestHandler;
+	}
+
+	@Override
+	public void run() {
+		
+		try {
+			serverSocket = new ServerSocket(port);
+			
+			while (true)
+			{
+				Socket clientSocket = serverSocket.accept();
+				
+				HttpServerConnection connection = getConnectionFactory().createHttpServerConnection(this, clientSocket);
+				connection.start();	
+			}
+			
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	public static void main(String[] args) {
+		HttpServer httpServer = new HttpServer(8080);
+		ServerObjectHandler soh = new ServerObjectHandler();
+		
+		httpServer.setRequestHandler(soh);
+		
+		httpServer.start();
+	}
+}

src/org/hwo/net/http/HttpServerConnection.java

@@ -0,0 +1,89 @@
+package org.hwo.net.http;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.net.Socket;
+
+public class HttpServerConnection extends Thread {
+
+	public static class Factory implements HttpServerConnectionFactory
+	{
+		@Override
+		public HttpServerConnection createHttpServerConnection(
+				HttpServer httpServer, Socket clientSocket) throws IOException {
+			return new HttpServerConnection(httpServer, clientSocket);
+		}
+	}
+	
+	private HttpServer httpServer;
+	private Socket clientSocket;
+	
+	private BufferedReader bufferedReader;
+	private BufferedWriter bufferedWriter;
+	
+	public HttpServerConnection(HttpServer httpServer,Socket clientSocket) throws IOException
+	{
+		this.httpServer = httpServer;
+		this.clientSocket = clientSocket;
+		this.bufferedReader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
+		this.bufferedWriter = new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream()));
+	}
+	
+	public HttpServer getHttpServer()
+	{
+		return httpServer;
+	}
+	
+	public Socket getClientSocket()
+	{
+		return clientSocket;
+	}
+	
+	public BufferedReader getBufferedReader()
+	{
+		return bufferedReader;
+	}
+	
+	public BufferedWriter getBufferedWriter()
+	{
+		return bufferedWriter;
+	}
+	
+	
+	private void close() throws IOException
+	{
+		clientSocket.close();
+	}
+	
+	
+	@Override
+	public void run() {
+		
+		try
+		{
+			while (!clientSocket.isClosed())
+			{
+				HttpServerRequest request = httpServer.getRequestFactory().createRequest(this);				
+				
+				doRequest(request);
+				
+				request.sendResponse();
+			}
+			
+			close();
+		} catch (IOException exception)
+		{
+			exception.printStackTrace();
+		}
+	}
+	
+	public void doRequest(HttpServerRequest httpRequest) throws IOException
+	{
+		httpServer.getRequestHandler().doRequest(httpRequest);
+	}
+	
+}

src/org/hwo/net/http/HttpServerConnectionFactory.java

@@ -0,0 +1,10 @@
+package org.hwo.net.http;
+
+import java.io.IOException;
+import java.net.Socket;
+
+public interface HttpServerConnectionFactory {
+
+	public HttpServerConnection createHttpServerConnection(HttpServer httpServer,Socket clientSocket) throws IOException;
+	
+}

src/org/hwo/net/http/HttpServerRequest.java

@@ -0,0 +1,188 @@
+package org.hwo.net.http;
+
+import java.io.BufferedWriter;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.util.Arrays;
+import java.util.Enumeration;
+import java.util.Properties;
+
+public class HttpServerRequest {
+
+	public static class Factory implements HttpServerRequestFactory
+	{
+		@Override
+		public HttpServerRequest createRequest(HttpServerConnection connection) throws IOException {
+			return new HttpServerRequest(connection);
+		}
+	}
+	
+	HttpServerConnection connection;
+	
+	String	requestLine;
+	String	requestMethod;
+	String	requestProtocol;
+	HttpRequestURI
+			requestURI;
+	
+	Properties header;
+	
+	Integer		resultCode;
+	Properties	responseHeader;
+	byte[]		responseBody;
+	
+	ByteArrayOutputStream
+				responseOutputStream;
+	BufferedWriter
+				responseBufferedWriter;
+	
+	boolean		responseSent;
+	
+	
+	public HttpServerRequest(HttpServerConnection httpServerConnection) throws IOException
+	{
+		this.connection = httpServerConnection;
+		this.header = new Properties();
+		
+		readRequest();
+		readHeader();
+		
+		requestURI.decode();
+		
+		resultCode = 400;
+		responseHeader = new Properties();
+		responseOutputStream = new ByteArrayOutputStream();
+		responseBufferedWriter = new BufferedWriter(new OutputStreamWriter(responseOutputStream));
+		
+	}
+	
+	public boolean isResponseSent()
+	{
+		return responseSent;
+	}
+	
+	private void readRequest() throws IOException
+	{
+		this.requestLine = connection.getBufferedReader().readLine();
+		String[] tokens = this.requestLine.split(" ",3);
+		requestMethod = tokens[0];
+		if (tokens.length > 1)
+			requestURI = new HttpRequestURI(this,tokens[1]);
+		if (tokens.length > 2)
+			requestProtocol = tokens[2];
+		
+	}
+	
+	private void readHeader() throws IOException
+	{
+		String line;
+		String headerName = null;
+		StringBuilder headerValue = new StringBuilder();
+		
+		while (true)
+		{
+			line = connection.getBufferedReader().readLine();
+			if ((line.length() == 0) || (line.charAt(0) > 32))
+			{
+				if (headerName != null)
+				{
+					header.setProperty(headerName, headerValue.toString());
+				}
+				if (line.length() > 0)
+				{
+					headerName = line.substring(0,line.indexOf(':'));
+					headerValue = new StringBuilder();
+					headerValue.append(line.substring(line.indexOf(':')+1).trim());
+				} else
+					return;
+			} else
+			{
+				if (headerName != null)
+					headerValue.append(line.trim());
+			}
+			
+			
+		}
+	}
+	
+	public HttpRequestURI getRequestURI()
+	{
+		return requestURI;
+	}
+
+	public String getRequestHeader(String headerName)
+	{
+		return header.getProperty(headerName);
+	}
+	
+	
+	public OutputStream getResponseOutputStream()
+	{
+		return responseOutputStream;
+	}
+	public BufferedWriter getResponseWriter()
+	{
+		return responseBufferedWriter;
+	}
+	
+	public void setResponseHeader(String headerName,String headerValue)
+	{
+		responseHeader.setProperty(headerName, headerValue);
+	}
+	
+	
+	public void sendResponse(int code,byte[] responseBody) throws IOException
+	{
+		this.responseBody = responseBody;
+		this.resultCode = code;
+		sendResponse();
+	}
+	
+	public void sendResponse(int code) throws IOException
+	{
+		this.resultCode = code;		
+		sendResponse();
+	}
+	
+	
+	public void sendResponse() throws IOException
+	{
+		if (responseSent)
+			throw new IOException("The Response has already been sent.");
+		
+		responseSent = true;
+		
+		if (responseBody == null)
+		{
+			responseBufferedWriter.flush();
+			if (responseOutputStream.size() > 0)
+			{
+				responseBody = responseOutputStream.toByteArray();
+			} else
+				responseBody = new byte[0];
+		}
+		
+		responseHeader.setProperty("Content-Length", String.format("%d", responseBody.length));
+
+		String protocol = "HTTP/1.0";
+		if (requestProtocol != null)
+			protocol = requestProtocol;
+		
+		connection.getBufferedWriter().write(String.format("%s %d\r\n", protocol, resultCode));
+
+		Enumeration<?> headerEnum = responseHeader.keys();
+		
+		while (headerEnum.hasMoreElements())
+		{
+			String headerName = (String)headerEnum.nextElement();
+			connection.getBufferedWriter().write(String.format("%s: %s\r\n", headerName, responseHeader.getProperty(headerName)));
+		}
+		
+		connection.getBufferedWriter().write("\r\n");
+		connection.getBufferedWriter().flush();
+		connection.getClientSocket().getOutputStream().write(responseBody);
+	}
+	
+}

src/org/hwo/net/http/HttpServerRequestFactory.java

@@ -0,0 +1,9 @@
+package org.hwo.net.http;
+
+import java.io.IOException;
+
+public interface HttpServerRequestFactory {
+
+	public HttpServerRequest createRequest(HttpServerConnection connection) throws IOException;
+	
+}

src/org/hwo/net/http/HttpServerRequestHandler.java

@@ -0,0 +1,10 @@
+package org.hwo.net.http;
+
+import java.io.IOException;
+
+public interface HttpServerRequestHandler {
+
+	public void doRequest(HttpServerRequest httpRequest) throws IOException;
+	
+	
+}

src/org/hwo/net/requesthandler/ServerObjectHandler.java

@@ -0,0 +1,47 @@
+package org.hwo.net.requesthandler;
+
+import java.io.IOException;
+import java.util.HashMap;
+
+import org.hwo.net.ServerObject;
+import org.hwo.net.http.HttpServerRequest;
+import org.hwo.net.http.HttpServerRequestHandler;
+import org.hwo.net.serverobjects.ServerObjectRequest;
+import org.hwo.net.serverobjects.VirtualRootObject;
+
+public class ServerObjectHandler implements HttpServerRequestHandler{
+
+	private ServerObject rootObject;
+	private HashMap<Integer, ServerObject> errorObjects;
+	private ServerObject defaultErrorObject;
+	
+	
+	public ServerObjectHandler()
+	{
+		rootObject = new VirtualRootObject();
+	}
+	
+	public ServerObject getRootObject()
+	{
+		return rootObject;
+	}
+	
+	public ServerObject getErrorObject(Integer code)
+	{
+		if (errorObjects.containsKey(code))
+			return errorObjects.get(code);
+		return defaultErrorObject;
+	}
+	
+	
+	@Override
+	public void doRequest(HttpServerRequest httpRequest) throws IOException {
+		ServerObjectRequest sor = new ServerObjectRequest(httpRequest);
+		
+		rootObject.climb(sor);
+	}
+
+	
+	
+	
+}

src/org/hwo/net/serverobjects/AbstractServerObject.java

@@ -0,0 +1,68 @@
+package org.hwo.net.serverobjects;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import org.hwo.net.ServerObject;
+import org.hwo.net.http.HttpServerRequest;
+
+public abstract class AbstractServerObject implements ServerObject {
+
+	private ServerObject parentObject;
+	HashMap<String, ServerObject> mappedChildren;
+	
+	public AbstractServerObject()
+	{
+		mappedChildren = new HashMap<String, ServerObject>();
+	}
+	
+	
+	@Override
+	public ServerObject getRootObject() {
+		if (getParent() == null)
+			return this;
+		return getParent().getRootObject();
+	}
+	
+	@Override
+	public ServerObject getParent() {
+		return parentObject;
+	}
+
+	@Override
+	public ServerObject[] getChildren() {
+		return (new ArrayList<ServerObject>(mappedChildren.values())).toArray(new ServerObject[0]);
+	}
+
+	@Override
+	public void addNamedChild(String childName, ServerObject serverObject) {
+		mappedChildren.put(childName, serverObject);
+		
+	}	
+	
+	@Override
+	public ServerObject getNamedChild(String childName) {
+		if (!mappedChildren.containsKey(childName))
+			return null;
+		return mappedChildren.get(childName);
+	}
+
+	@Override
+	public void climb(ServerObjectRequest request) throws IOException {
+		String nextChildName = request.popNextElement();
+		
+		if (nextChildName == null)
+		{
+			request(request);
+		} else
+		{
+			ServerObject nextChild = getNamedChild(nextChildName);
+			if (nextChild == null)
+				throw new ServerObjectNotFoundException(request,nextChildName);
+			nextChild.climb(request);
+		}
+		
+	}
+
+}

src/org/hwo/net/serverobjects/ServerObjectNotFoundException.java

@@ -0,0 +1,24 @@
+package org.hwo.net.serverobjects;
+
+public class ServerObjectNotFoundException extends RuntimeException {
+
+	private ServerObjectRequest objectRequest;
+	private String childName;
+	
+	public ServerObjectNotFoundException(ServerObjectRequest request)
+	{
+		objectRequest = request;
+		childName = null;
+	}
+	public ServerObjectNotFoundException(ServerObjectRequest request,String childName)
+	{
+		objectRequest = request;
+		this.childName = childName;
+	}
+	
+	public ServerObjectRequest getObjectRequest()
+	{
+		return objectRequest;
+	}
+	
+}

src/org/hwo/net/serverobjects/ServerObjectRequest.java

@@ -0,0 +1,51 @@
+package org.hwo.net.serverobjects;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Stack;
+
+import org.hwo.net.http.HttpServerRequest;
+
+public class ServerObjectRequest {
+
+	private HttpServerRequest httpRequest;
+	
+	private Stack<String> pathToClimb;
+	private Stack<String> pathClimbed;
+	
+	public ServerObjectRequest(HttpServerRequest httpRequest)
+	{
+		this.httpRequest = httpRequest;
+		pathToClimb = new Stack<String>();
+		pathClimbed = new Stack<String>();
+		
+		initialize();
+	}
+	
+	private void initialize()
+	{
+		pathToClimb = new Stack<String>();
+		pathToClimb.addAll(Arrays.asList(httpRequest.getRequestURI().getPathElements()));
+	}
+	
+	public HttpServerRequest getHttpRequest()
+	{
+		return httpRequest;
+	}
+	
+	public String popNextElement()
+	{
+		if (pathToClimb.empty())
+			return null;
+		String n = pathToClimb.pop();
+		return n;
+	}
+	
+	public void pushLastElement(String element)
+	{
+		pathClimbed.push(element);
+	}
+	
+}

src/org/hwo/net/serverobjects/VirtualRootObject.java

@@ -0,0 +1,17 @@
+package org.hwo.net.serverobjects;
+
+import java.io.IOException;
+
+import org.hwo.net.ServerObject;
+import org.hwo.net.http.HttpServerRequest;
+
+public class VirtualRootObject extends AbstractServerObject {
+
+
+	@Override
+	public void request(ServerObjectRequest request) throws IOException{
+		request.getHttpRequest().setResponseHeader("Content-Type", "text/plain");
+		request.getHttpRequest().getResponseWriter().write("This is the virtual root of this application server.");		
+	}
+	
+}

src/org/hwo/os/OsDetect.java

@@ -0,0 +1,19 @@
+package org.hwo.os;
+
+public class OsDetect {
+
+	public enum OsType { UNKNOWN, LINUX, OSX, WINDOWS};
+	
+	public static OsType getOperatingSystem()
+	{
+		if (System.getProperty("os.name").equals("Mac OS X"))
+			return OsType.OSX;
+		if (System.getProperty("os.name").equals("Linux"))
+			return OsType.LINUX;
+		if (System.getProperty("os.name").startsWith("Windows"))
+			return OsType.WINDOWS;
+		
+		return OsType.UNKNOWN;
+	}
+	
+}

src/org/hwo/proxy/AbstractInterceptor.java

@@ -0,0 +1,20 @@
+package org.hwo.proxy;
+
+import java.lang.reflect.Method;
+
+public abstract class AbstractInterceptor implements Interceptor {
+
+	
+	@Override
+	public abstract Object invoke(Method method, Object target, Object[] params);
+	
+	public Object invokeTarget(Method method, Object target, Object[] params)
+	{
+		try {
+			return method.invoke(target, params);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+	
+}

src/org/hwo/proxy/Interceptor.java

@@ -0,0 +1,10 @@
+package org.hwo.proxy;
+
+import java.lang.reflect.Method;
+
+
+public interface Interceptor {
+
+	public Object invoke(Method method,Object target,Object[] params);
+	
+}

src/org/hwo/proxy/ProxyTest.java

@@ -0,0 +1,27 @@
+package org.hwo.proxy;
+
+import java.lang.reflect.Method;
+
+import org.hwo.buffer.BitStream;
+import org.hwo.fifo.FiFo;
+
+public class ProxyTest {
+
+	public static void main(String[] args) {
+		
+		Interceptor mi = new AbstractInterceptor() {
+			
+			@Override
+			public Object invoke(Method method, Object target, Object[] params) {
+				System.err.println("INVOKE: " + method.getName());
+				return invokeTarget(method, target, params);
+			}
+		};
+		
+		
+		
+		
+	}
+	
+	
+}

src/org/hwo/proxy/ProxyWrapper.java

@@ -0,0 +1,31 @@
+package org.hwo.proxy;
+
+import java.lang.reflect.Method;
+
+import net.sf.cglib.proxy.Enhancer;
+import net.sf.cglib.proxy.MethodInterceptor;
+import net.sf.cglib.proxy.MethodProxy;
+
+public class ProxyWrapper {
+
+	public ProxyWrapper()
+	{
+	}
+		
+	public <U> U proxyForObject(Class<U> clazz,U object)
+	{
+		Enhancer e = new Enhancer();
+		e.setSuperclass(clazz);
+		e.setCallback(new MethodInterceptor() {
+			@Override
+			public Object intercept(Object proxy, Method method, Object[] args,
+					MethodProxy methodProxy) throws Throwable {
+				return null;
+			}
+		});
+		return clazz.cast(e.create()); 
+	}
+
+	
+	
+}

src/org/hwo/tasklet/Tasklet.java

@@ -0,0 +1,7 @@
+package org.hwo.tasklet;
+
+public interface Tasklet {
+
+	public void run(Object arg);
+	
+}

src/org/hwo/tasklet/TaskletThread.java

@@ -0,0 +1,70 @@
+package org.hwo.tasklet;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Stack;
+
+import org.hwo.fifo.FiFo;
+
+public class TaskletThread extends Thread {
+
+	private class QueuedTasklet
+	{
+		private Tasklet tasklet;
+		private Object argument;
+		
+		public QueuedTasklet(Tasklet tasklet,Object argument)
+		{
+			this.tasklet = tasklet;
+			this.argument = argument;
+		}
+	}
+	
+	private FiFo<QueuedTasklet> queuedTasklets = new FiFo<QueuedTasklet>();
+	
+	public TaskletThread() {
+		start();
+	}
+	
+	public void queue(Tasklet tasklet,Object arg)
+	{
+		synchronized (queuedTasklets) {
+			queuedTasklets.push(new QueuedTasklet(tasklet,arg));
+		}
+		queuedTasklets.notify();
+	}
+	
+	@Override
+	public void run() {
+		while (true)
+		{
+			QueuedTasklet queuedTasklet = null;
+			
+			synchronized (queuedTasklets) {
+				try {
+					queuedTasklets.wait(100);
+					queuedTasklet = queuedTasklets.pull();
+				} catch (InterruptedException e) {
+					e.printStackTrace();
+				}
+			}
+			
+			if (queuedTasklet != null)
+			{
+				try
+				{
+					queuedTasklet.tasklet.run(queuedTasklet.argument);
+				} catch (Exception ex)
+				{
+					System.err.println("Tasklet throwed Exception: " + ex.toString());
+					ex.printStackTrace();
+				}
+			}
+			
+			if (isInterrupted())
+				return;
+		}
+	}
+	
+	
+}

src/org/hwo/test/BitStreamTest.java

@@ -0,0 +1,17 @@
+package org.hwo.test;
+
+import org.hwo.buffer.BitStream;
+
+public class BitStreamTest {
+
+	public static void main(String[] args) {
+
+		BitStream bs = new BitStream(new byte[]{ 0x55,0x55,0x55,0x55 });
+		
+		for (int i=0;i<6;i++)
+			System.err.println(String.format("Pattern: 0x%x",bs.read((byte)i)));
+		
+
+	}
+
+}

src/org/hwo/thread/ThreadedOperation.java

@@ -0,0 +1,70 @@
+package org.hwo.thread;
+
+import java.util.ArrayList;
+import java.util.EventListener;
+import java.util.List;
+
+public abstract class ThreadedOperation extends Thread{
+
+	List<ThreadedOperationUpdateListener> updateListeners;
+	private String operationName;
+	
+	
+	public ThreadedOperation()
+	{
+		updateListeners = new ArrayList<ThreadedOperationUpdateListener>();
+		operationName = "AktivitŠt...";
+	}
+	
+	public void addThreadedOperationUpdateListener(ThreadedOperationUpdateListener listener)
+	{
+		updateListeners.add(listener);
+	}
+	public void removeThreadedOperationUpdateListener(ThreadedOperationUpdateListener listener)
+	{
+		updateListeners.remove(listener);
+	}
+	
+	protected void fireUpdate(ThreadedOperationUpdateArgs updateArgs)
+	{
+		for (ThreadedOperationUpdateListener listener:updateListeners)
+			listener.threadedOperationUpdate(updateArgs);
+	}
+	protected void fireUpdate(Integer progressOperation,Integer progressStep)
+	{
+		fireUpdate(new ThreadedOperationUpdateArgs(progressOperation,progressStep));
+	}
+	
+	protected void fireUpdate(Integer progressOperation,Integer progressStep,String statusText)
+	{
+		fireUpdate(new ThreadedOperationUpdateArgs(progressOperation,progressStep,statusText));
+	}
+	
+	protected void fireUpdate(Integer progressOperation,Integer progressStep,String statusText,String stepLabel)
+	{
+		fireUpdate(new ThreadedOperationUpdateArgs(progressOperation,progressStep,statusText,stepLabel));		
+	}
+	
+	protected void fireFinished(int code)
+	{
+		for (ThreadedOperationUpdateListener listener:updateListeners)
+			listener.threadedOperationFinished(code);
+	}
+	protected void fireFinished()
+	{
+		fireFinished(0);
+	}
+	
+	public abstract void run();
+
+	public String getOperationName() {
+		return operationName;
+	}
+
+	public void setOperationName(String operationName) {
+		this.operationName = operationName;
+	}
+	
+	
+	
+}

src/org/hwo/thread/ThreadedOperationUpdateArgs.java

@@ -0,0 +1,77 @@
+package org.hwo.thread;
+
+public class ThreadedOperationUpdateArgs {
+
+	private Integer progressOperation;
+	private Integer progressStep;
+	private String	stepLabel;
+	private String	statusText;
+	private String	titleText;
+	
+	public ThreadedOperationUpdateArgs()
+	{
+	}
+	public ThreadedOperationUpdateArgs(Integer progressStep)
+	{
+		this.progressStep = progressStep;
+	}	
+	public ThreadedOperationUpdateArgs(Integer progressOperation,Integer progressStep)
+	{
+		this.progressOperation = progressOperation;
+		this.progressStep = progressStep;
+	}
+	public ThreadedOperationUpdateArgs(Integer progressOperation,Integer progressStep,String statusText)
+	{
+		this.progressOperation = progressOperation;
+		this.progressStep = progressStep;
+		this.statusText = statusText;
+	}
+	public ThreadedOperationUpdateArgs(Integer progressOperation,Integer progressStep,String statusText,String stepLabel)
+	{
+		this.progressOperation = progressOperation;
+		this.progressStep = progressStep;
+		this.statusText = statusText;
+		this.stepLabel = stepLabel;
+	}	
+
+	public String getStepLabel() {
+		return stepLabel;
+	}
+
+	public void setStepLabel(String stepLabel) {
+		this.stepLabel = stepLabel;
+	}
+
+	public Integer getProgressStep() {
+		return progressStep;
+	}
+
+	public void setProgressStep(Integer progressStep) {
+		this.progressStep = progressStep;
+	}
+
+	public Integer getProgressOperation() {
+		return progressOperation;
+	}
+
+	public void setProgressOperation(Integer progressOperation) {
+		this.progressOperation = progressOperation;
+	}
+
+	public String getStatusText() {
+		return statusText;
+	}
+
+	public void setStatusText(String statusText) {
+		this.statusText = statusText;
+	}
+
+	public String getTitleText() {
+		return titleText;
+	}
+
+	public void setTitleText(String titleText) {
+		this.titleText = titleText;
+	}
+	
+}

src/org/hwo/thread/ThreadedOperationUpdateListener.java

@@ -0,0 +1,6 @@
+package org.hwo.thread;
+
+public interface ThreadedOperationUpdateListener {
+	public void threadedOperationUpdate(ThreadedOperationUpdateArgs args);
+	public void threadedOperationFinished(int result);
+}

src/org/hwo/ui/CellEditor.java

@@ -0,0 +1,16 @@
+package org.hwo.ui;
+
+import java.awt.Rectangle;
+
+import org.hwo.ui.treetable.TreeTable;
+
+public interface CellEditor {
+
+	public void addCellEditorListener(CellEditorListener listener);
+	public void removeCellEditorListener(CellEditorListener listener);
+	
+	public boolean	editBegin(TreeTable treeTable,Rectangle rect,Object value);
+	public void		editCancel();
+	public void		editFinish();
+	
+}

src/org/hwo/ui/CellEditorArgs.java

@@ -0,0 +1,40 @@
+package org.hwo.ui;
+
+import org.hwo.ui.treetable.TreeTable;
+
+public class CellEditorArgs {
+
+	private CellEditor 	cellEditor;
+	private Object		value;
+	private TreeTable	treeTable;
+	
+	public CellEditorArgs(CellEditor cellEditor,Object value,TreeTable treeTable)
+	{
+		this.cellEditor	= cellEditor;
+		this.value		= value;
+		this.treeTable	= treeTable;
+	}
+	
+	public CellEditor getCellEditor() {
+		return cellEditor;
+	}
+	public void setCellEditor(CellEditor cellEditor) {
+		this.cellEditor = cellEditor;
+	}
+	public Object getValue() {
+		return value;
+	}
+	public void setValue(Object value) {
+		this.value = value;
+	}
+	public TreeTable getTreeTable() {
+		return treeTable;
+	}
+	public void setTreeTable(TreeTable treeTable) {
+		this.treeTable = treeTable;
+	}
+	
+	
+	
+	
+}

src/org/hwo/ui/CellEditorListener.java

@@ -0,0 +1,9 @@
+package org.hwo.ui;
+
+public interface CellEditorListener {
+
+	public void editBegin(CellEditorArgs args);
+	public void editCanceled(CellEditorArgs args);
+	public void editFinished(CellEditorArgs args);
+	
+}

src/org/hwo/ui/CellRenderer.java

@@ -0,0 +1,11 @@
+package org.hwo.ui;
+
+import java.awt.Graphics;
+import java.awt.Rectangle;
+
+public interface CellRenderer {
+
+	public void renderCell(Graphics g,int row,int column,Rectangle cellRect,Object value,Object rowObject);
+	
+	
+}

src/org/hwo/ui/DefaultCellEditor.java

@@ -0,0 +1,108 @@
+package org.hwo.ui;
+
+import java.awt.Container;
+import java.awt.Rectangle;
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.swing.JTextField;
+
+import org.hwo.ui.treetable.TreeTable;
+
+public class DefaultCellEditor implements CellEditor {
+
+	private List<CellEditorListener> editorListeners;
+	
+	private JTextField	textField;
+	private TreeTable	treeTable;
+	private Object		value;
+	
+	public DefaultCellEditor()
+	{
+		editorListeners = new LinkedList<CellEditorListener>();
+	}
+	
+	@Override
+	public void addCellEditorListener(CellEditorListener listener) {
+		editorListeners.add(listener);
+	}
+
+	@Override
+	public void removeCellEditorListener(CellEditorListener listener) {
+		editorListeners.remove(listener);
+	}
+	
+	private void fireEditBegin()
+	{
+		CellEditorArgs args = new CellEditorArgs(this, value, treeTable);
+		for (CellEditorListener listener: editorListeners)
+			listener.editBegin(args);
+	}
+	private void fireEditFinish()
+	{
+		CellEditorArgs args = new CellEditorArgs(this, value, treeTable);
+		for (CellEditorListener listener: editorListeners)
+			listener.editFinished(args);
+	}
+	private void fireEditCancel()
+	{
+		CellEditorArgs args = new CellEditorArgs(this, value, treeTable);
+		for (CellEditorListener listener: editorListeners)
+			listener.editCanceled(args);
+	}
+	
+	private void destroyTextField()
+	{
+		textField.setVisible(false);
+		Container parent = textField.getParent();
+		
+		parent.remove(textField);
+		
+		textField = null;
+	}
+
+	@Override
+	public boolean editBegin(TreeTable treeTable, Rectangle rect, Object value) {
+		if (textField != null)
+			editCancel();
+		
+		this.treeTable = treeTable;
+		this.value = value;
+		
+		this.textField = new JTextField();
+		treeTable.add(textField);
+		
+		textField.setBounds(rect);
+		textField.requestFocusInWindow();
+		textField.repaint();
+		
+		fireEditBegin();
+		
+		return true;
+	}
+
+	@Override
+	public void editCancel() {
+		if (textField != null)
+		{
+			destroyTextField();
+			
+			fireEditCancel();
+		}
+		
+	}
+
+	@Override
+	public void editFinish() {
+		if (this.textField != null)
+		{
+			this.value = this.textField.getText();
+			destroyTextField();
+					
+			fireEditFinish();			
+		}
+	}
+
+	
+	
+}

src/org/hwo/ui/DefaultCellRenderer.java

@@ -0,0 +1,23 @@
+package org.hwo.ui;
+
+import java.awt.Graphics;
+import java.awt.Rectangle;
+
+public class DefaultCellRenderer implements CellRenderer{
+
+	@Override
+	public void renderCell(Graphics g,int row,int column, Rectangle cellRect, Object value,Object rowObject)
+	{
+		if (value != null)
+		{
+			g.drawString(	value.toString(),
+						cellRect.x + 2,
+						cellRect.y + cellRect.height - 4
+					);
+		};
+		
+	}
+
+	
+	
+}

src/org/hwo/ui/FlexibleJTable.java

@@ -0,0 +1,66 @@
+package org.hwo.ui;
+
+import java.util.List;
+
+import javax.swing.JTable;
+import javax.swing.event.ListSelectionListener;
+
+import org.hwo.models.FlexibleObjectTableModel;
+
+public class FlexibleJTable<T> extends JTable {
+	private FlexibleObjectTableModel<T> model;
+		
+	public FlexibleJTable(Class class_t)
+	{
+		this.model = new FlexibleObjectTableModel<T>(class_t);
+		this.setModel(this.model);
+	}
+	
+	public FlexibleObjectTableModel<T> getModel()
+	{
+		return this.model;
+	}
+
+	public T getSelectedObject()
+	{
+		if (this.getSelectedRow()==-1)
+			return null;
+		return this.model.getRows().get(this.getSelectedRow());
+	}
+	
+	public void addListSelectionListener(ListSelectionListener listener)
+	{
+		this.getSelectionModel().addListSelectionListener(listener);
+	}
+	
+	public void removeListSelectionListener(ListSelectionListener listener)
+	{
+		this.getSelectionModel().removeListSelectionListener(listener);
+	}
+
+	public void addColumn(String column)
+	{
+		this.addColumn(column, true);
+	}
+	
+	public void addColumn(String column,boolean readonly)
+	{
+		this.model.addColumn(column,readonly);
+	}
+	
+	public void setRows(List<T> rows)
+	{
+		this.model.setRows(rows);
+	}
+	
+	public void addRow(T o)
+	{
+		this.model.addRow(o);
+	}
+	
+	public int getRowCount()
+	{
+		return this.model.getRowCount();
+	}
+	
+}