[nicht abgeschlossen] Java-Chat

[Router]

Hallo,
ich bin besonders an Java-Chats wie z.B. Spin Chat interesiert. Ich habe in alten Beiträgen hier immer nur gefunden "weiß ich nicht", "müßte man mal sehen" oder "lade das Handbuch runter und versuch es mal", oder "gehört nicht in dieses Forum" LOL.
Ich habe mehrer User angemailt und erfahren, das in diesem Bereich keiner weiter gekommen ist.
Ich denke, das man einige Erfahrung mit Java und /oder CGI Programmierung braucht.

Wer hat also Lust, an diesem Projekt mitzuarbeiten? Mailt mich an oder benutzt ICQ

mfg Router

PS dopefish, toxic, ich hoffe, das das der richtige Weg für ein neues Projekt ist?

[chris]

Hi!
Ich weiß nich, wie das mit deinem Project aussieht und ob du noch Interesse an sowas hast, aber ich wollt auch grad n Topic über sowas aufmachen! Ich dacht mir, 's wär ja nich schlecht ma so'n "Gegenstück" zu Joel's JBB zu schreiben... Ich dachte an sich an einen Chat in "reinem" Perl, hab aber auch schon öfters drüber nachgedacht, die "Engine" als cgi laufen zu lassen und nur die ausgabe als JavaApplet zu machen! Wenn also noch bei wem Interesse bestehen sollte, ich wär auf jeden Fall dabei! ;)
Greetz,
agnusdei

[knt]

Hi,

da würd ich auch mit machen...ein grundgerüst für einen Java Chat habe ich schon..d.h. simples hin und her schieben von daten...aber da soll ja noch mehr rein :) berechtigungen,moderation, ne schicke oberfläche(immo nur console) e.c.

[chris]

Jau super! :) Oberfläche könnt ich besorgen, bisl Erfahrung mit JavaApplets hab ich dank Informatikkurs schon... Poste einfach mal deinen QT wenn's geht, ich werd mich dann mal bemühen, mit der Oberfläche zu beginnen! (Könnte ab morgen eventuell schon zu sehen sein! *g*)
Greetz,
agnusdei

[DarkTom]

Ich hätte da auch Interesse. Nur bin ich momentan ziemlich beschäftigt (Muss unbedingt bis Semesterbeginn noch Haskell lernen). Naja, ein bißchen was von meiner Zeit könnte ich da bestimmt noch irgendwie abknapsen... Poste halt mal den Quelltext und wir sehen weiter.

[knt]

Hi,

Den Quelltext poste ich gerne..doch wenn wir das zusammen schreiben wollen müssen wir uns schon mal genauer überlegen wer was macht..welche klassen wir brauchen, wie die Klassen zusammen hängen, wie das public Interface jeder Klasse aussieht u.s.w
Einfach damit wir net aneinander vorbei coden..stimmts? *s*

Den Code den ich hier hab(jaja kommt ja gleich:) besteht aus 4 Klassen...
CChatServer - lauscht auf verbindungen auf einem beliebigen Port...verwaltet die Clients...passt nachrichten an alle Clients weiter CChatClient - verbindet sich zum Server..schickt user eingaben zum server..stellt text vom server dar CListener - eine Klasse im eigenem Thread..lascht auf daten von der jeweils anderen seite IListenAble - ein Interface..wird von CChatClient und CChatServer implementiert...dient dazu beide in CListener gleich zubehandeln.


Also hier der Code...sorry für die mangelnde kommentierung...ist nicht mehr als eine testumgebung.
-CChatServer-


/*
toDo:

knt:Entfernen der verbindungen zu clients (removeClient)
die daten im vektor rutschen nach d.h. es gibt keinen
festen index für die elemente
Das ansprechen muss anders gesehen ich glaube es gibt eine getObject(obj)
*/
import java.util.*;
import java.io.*;
import java.net.*;

public class CChatServer implements IListenAble
{
private int port;
private Vector clientList = new Vector();
private ServerSocket clientListener;

//konstruktor
CChatServer(int port)
{
try
{clientListener = new ServerSocket(port);}
catch(IOException ioe)
{System.out.println ("** Fehler beim initialisieren: " +ioe);}
System.out.println("** chatServer auf Port " + port + " initialisiert");

}

//lauscht nach neuen clients
public void listen()
{
Socket clientSock;

System.out.println("** chatServer lauscht auf verbindungen");
System.out.println("***************************************\n");
try
{
while(true)
{
clientSock = clientListener.accept();
System.out.println("accept: " + clientSock.toString());
addClient(clientSock);
}
}
catch(IOException ioe)
{System.out.println("** Fehler beim lauschen auf verbindunen: " + ioe);}
}

//erstellt eine Verbindung zu einem Client
//und fügt diesen zu einem Vector hinzu
private boolean addClient(Socket clientSock)
{
CListener l;
int id;
try
{
//BufferedReader in = new BufferedReader(new InputStreamReader(clientSock.getInputStream()));
PrintWriter out = new PrintWriter(clientSock.getOutputStream());

clientList.addElement(out);
id = clientList.size()-1;
Thread t = new Thread(l = new CListener(clientSock, this, id));
t.start();
System.out.println("verbindung zu client " + id +" erstellt");
}
catch(IOException e)
{System.out.println("** Fehler beim erstellen der Verbindung: " + e);}

return true;
}

//beendet eine Verbinung zu einem Client
//und löscht diesen aus dem Vector
public boolean removeClient(int clientId)
{
System.out.println ("** connection zu client: " + clientId + " abgebrochen.");

try
{clientList.removeElementAt(clientId);}
catch (Exception e)
{System.out.println ("Fehler beim Entfernen eines Clients\nClientID: " + clientId + "\nClientListrSize: " + clientList.size());}

return true;
}

//sendet einen String an alle Clients
//public void boardcaste(String line, int id)
public void processLine(String line)
{
try
{
for (int x=0;x<=clientList.size()-1;x++)
{
PrintWriter out = (PrintWriter) clientList.elementAt(x);
out.println(line);
out.flush();
System.out.println("** client send \"" + line + "\" to client "+ x);
}
}
catch (Exception e)
{System.out.println ("Fehler beim senden der Nachricht");}
}

public void endConnection(int Id)
{
removeClient(Id);
}

//die main parst die argumente und startet den Server
public static void main(String[] args)
{
CChatServer srv;
int port;

System.out.println("** chatServer 0.1 by knt at 04.03.01 **");
System.out.println("***************************************\n");

if (args.length < 1)
{// zuwenig oder falsche Argumente
System.out.println("Du hast zuwenig Argumente um mich zu nutzen.\n Aufruf:\tserver port");
return;
}

port = Integer.parseInt(args[0]);

srv = new CChatServer(port);

srv.listen();

System.out.println("/nTschau!");
}
}


-CChatClient-


import java.io.*;
import java.net.*;

public class CChatClient implements IListenAble
{
public static void main(String[] args)
{
if (args.length < 2)
{// zuwenig oder falsche Argumente
System.out.println("Du hast zuwenig Argumente um mich zu nutzen.\n Aufruf:\tclient ip port");
return;
}

String ip = args[0];
int port = Integer.parseInt(args[1]);

CChatClient obj = new CChatClient();
obj.listen(ip, port);
System.out.println("Tschau!\n");

}


public void listen(String ip, int Port)
{
Socket serverSock;
BufferedReader stIN;
String line;
System.out.println("HI!\n");

try
{
serverSock = new Socket(ip, Port);

PrintWriter out = new PrintWriter(serverSock.getOutputStream());

Thread t = new Thread(new CListener(serverSock, this, 0));
t.start();

stIN = new BufferedReader(new InputStreamReader(System.in));
while((line = stIN.readLine()) != null)
{
out.println(line);
out.flush();
}


}
catch(IOException ioe)
{System.out.println("Fehler beim verbinden zum Server.");}

}


public void processLine(String line)
{
System.out.println("##:" +line);
}

public void endConnection(int id)
{
System.out.println("Verbindung zum Server verloren...");
}
}


-CListener-


import java.io.*;
import java.net.*;

public class CListener implements Runnable
{
private BufferedReader in;
private Socket clientSock;
private IListenAble obj;
private int id;

CListener(Socket clientSock, IListenAble obj, int id) throws IOException
{
this.in = new BufferedReader(new InputStreamReader(clientSock.getInputStream()));
this.clientSock = clientSock;
this.obj = obj;
this.id = id;
}

public void run()
{
String line;
try
{
while((line = in.readLine()) != null)
{
this.obj.processLine(line);
}
}
catch(IOException ioe)
{}
this.obj.endConnection(this.id);
}
}


-IListenAble-


public interface IListenAble
{
public void processLine(String line);
public void endConnection(int Id);
}


Jedes Bit dieses Codes ist frei.Es darf tuen was es will und wann es will. Sollte ein Bit Fehlerhaft sein so bitte ich es es mir zu sagen. Sollte ein Bit so fehlerhaft sein das es mir nicht mehr sagen kann das es fehlerhaft ist so bitte ich die nachbarBits mir von dem Fehler zu berichten :)

future Features:
registieren eines Users mit Nick und Passwort mehrere chaträume private msg's, ach zwischen mehr als 2 usern Moderation: kick, ban, voice verschiedene userer rechte: guest, user, mod Logging, es ist möglich das log eines chats in einer datei zu speichern esay UI


Als Datenbank würd ich gerne XML nutzen, ist leicht..billig..schnell..schön(ich liebe TAGS).

folgende klassen schwirren mir durch den kopf...nur so als brainstorming:

class server - lauschen und verwalten auf clients class connection - daten austausch zwischen server und client class client - UI des Chats class Command - ein kommando von client an server oder umgedreht class guest <- class user <- class mod - durch vererbung mit einander verbunden...jeweils die einzelnen aktionen implementiert. class chatRoom - sammlung mehrerer connections oder users


Ich bin die nächsten 5 Tage in Berlin, ohne netz, urlaub im wald :)...da werde ich mir mal gedanken über das Klassen Design machen...wäre schön wenn ihr das auch tun würdet :) dann setzen wir uns am do zusammen(irc oder so) und planen das project mal. Ich stelle mir das so vor das nach dem wir das Design abgesprochen haben jeder eine oder mehrere Classen codet die wir dann am schluss zusammen packen.

Bin gespannt was ihr dazu meint
grüsse

[chris]

super super! *big klatsch* :t
Ich würde wenn niemand was gegen hat gern die GUI (das meintest du wohl mit UI *g*) sowie die Klasse user und mod machen! Bin zwar eher noch Java Anfänger, aber ich denke, das sollte ich doch noch ganz gut hinkriegen! *g*
Code folgt demnächst... zur Zeit is echt ziehmlich stressig was die Zeit angeht... ;)
Greetz,
agnusdei

[Router]

^k dann lasst uns mal die icq # austauschen, is wohl das schnellste..

:> )) Router

[chris]

Steht zwar auch im Profil, aber ==>78932741, pleaze keine H4x0rz-Anfragen (an alle ausser router, knt und DarkTom! :D

[DarkTom]

Bin immer noch icq-los ... und ganz glücklich dabei. Ich wäre aber grundsätzlich bereit, mir nen IRC-Client zu instalieren (Ja, ich hab noch keinen. Es gibt halt Leute, die nicht so viel Zeit zum Chatten haben *g*) Ach ja, MSN wäre sonst auch vorhanden.

Ich hab mir übrigens schon Gedanken zu den Klassen gemacht und es gibt an dem Quelltext von knt so ein, zwei Sachen, die mir nicht ganz passen ... aber die Diskussion sollten wir wirklich nicht hier führen. Javadoc wär übrigens noch ein Stichwort. Wer hat schon mal damit gearbeitet?

[DarkTom]

Hallo Leute,
ich hab nochmal ein bißchen nachgedacht (konnte nicht schlafen *g*).
Folgender Vorschlag einer Klassenstruktur:

interface ChatCommands
hier stehen alle Chatbefehle als Methoden drin
z.B.
void chat(String message)
void login(String user, String password)

interface ChatReceiver
Ein Interface für Klassen, die den Chat empfangen. wird z.B. von ChatGUI implementiert, aber z.B. auch von einer Klasse, die den Chat loggt.
hat nur eine Methode: doChat(String text)

class ChatGUI
implementiert ChatReceiver
GUI halt, besitzt einen ChatClient, bei dem es sich auch als Receiver anmeldet. Useraktionen resultieren in Funktionsaufrufen des Clients

class ChatClient
implementiert ChatCommands
erstellt Verbindung zum Server. Funktionsaufrufe resultieren darin, daß in den Stream (siehe Quelltext knt) geschrieben wird. Befehle sollten geeignet codiert werden.
Ausserdem die Methode addChatReceiver, durch die sich Receiver anmelden. Wenn was vom Server reinkommt, sollte es an alle angemeldeten Receiver weitergeleitet werden. Und dann noch irgendwas, um Fehlermeldungen des Servers zu bearbeiten, die sollten vom Chat getrennt sein.

static class ChatDecoder
Sollte den gleichen Autor wie ChatClient haben. Besitzt eine statische Methode decode(String command, ChatCommands server), die den im ChatClient kodierten Befehl in einen Funktionaufruf im server umwandelt.

class ChatServer
implements ChatCommands
Lauscht auf neue Clients. Für solche wird ein neuer Thread erstellt, der auch Userinfo enthält. Außerdem Benutzerverwaltung, Räume, Statistik, ...


Vorteile:
GUI unabhängig vom Rest, man könnte sogar verschiedene schreiben, sogar reine Konsolenanwendungen mit eigenen Befehlen Man könnte verschiedene Receiver schreiben, mit eigenen Filterfunktionen oder eben einen Receiver, der nur in eine Datei schreibt. Die Formatierung des Datenstroms ist recht kompakt, Änderungen sind daher leichter zu handhaben.


Nachteile:
Es hängt noch ziemlich viel Arbeit in der Serverklasse, dort ist das ganze auch noch ziemlich 'schwammig' Es ist noch ungeklärt, wie der Server antwortet. Denkbar wäre ein Sonderzeichen zu benutzen, damit der ChatClient den Text entsprechend anders interpretiert


Ach ja, hat jemand ne Idee, wo der Server nachher laufen soll? Ich hatte erst an http://www.mycgiserver.com gedacht, aber die hosten wohl nur Servlets. Und wenn wir keinen Host haben, können wir uns die Benutzerverwaltung und Administration ja sparen, denn dann macht man ja wohl eher mal spontan Server, wenn man mit ein paar anderen chatten will...

[knt]

Hi,



und es gibt an dem Quelltext von knt so ein, zwei Sachen, die mir nicht ganz passen

da bin ich aba gespannt, freu immer über kritik.:)

Javadoc:
Richtig gearbeitet habe ich mit javadoc noch nicht...nur einen klein test..bin aber dafür das zu nurzen..erscheint mir praktisch.



Ach ja, hat jemand ne Idee, wo der Server nachher laufen soll?

Nope, leider noch nicht. Admins tun sich schwer wenn es darum geht server auf ihren rechnern laufen zu lassen, ihr wisst bestimmt besser als ich warum ;)

Ich werd mal auf arbeit fragen, und mich auch sonst danach umhören.
Ich will den chat nämlich schon in einer kleinen community einsetzen. Ich spiele ein RPG das immo die SpinChats nutzt, wie die sind wisst ihr ja wohl...ausserdem will ich diesen chat wenn er mal steht um einen FightGameMaster erweitern so das man Kämpfe im Chat spielen kann...aba das ist zukunftsmusik..

Klassendesign:


Die Formatierung des Datenstroms ist recht kompakt, Änderungen sind daher leichter zu handhaben.
[/qoute]
Verstehe ich nicht. Was meinst du?

[quote]
Es hängt noch ziemlich viel Arbeit in der Serverklasse, dort ist das ganze auch noch ziemlich 'schwammig'

Es gibt kommados die nur der Server und nur der Raum bearbeiten kann(siehe meinen vorschlag unten)



Es ist noch ungeklärt, wie der Server antwortet. Denkbar wäre ein Sonderzeichen zu benutzen, damit der ChatClient den Text entsprechend anders interpretiert

Es können drei instanzen antworten..der server(hello,pleas login), der raum(blah has joined), und ein user(na du nachtkappe?).

Ich finde das format /<befehl> <param>
ganz nett

Also z.b.:
user->server: /join myRoom
room->user's: /join usrName
oder
user->server: /spk Hallo Leute!
room->user's: /spk usrName Hallo Leute

Wie versprochen hab ich mir in den lezten Tagen auch gedanken dazu gemacht das hier ist rausgekommen:



/*
*
Interfaces
*
*/

interface IServerCommands //cmd's die der Server ausführen kann
public String[] listRooms() //eine liste der räume
public boolean multicastMsgToServer() //msg's über die räume hinweg
public boolean joinRoom() //einen raum betreten

interface IRoomCommands //cmd's die ein Raum ausführen kann
public String[] listUsers() //eine liste der user
public boolean multicastMsgToRoom() //msg's innerhalb eines raumes zu einem oder mehreren(o. allen) usern
public boolean setUserState() //op, deop, kick, bann e.c.
public boolean setRoomState() //free, moderated, ruled

interface IUserCommands implements IRoomCommands, IRoomCommands //cmd's die ein User ausführen kann
public boolean speak()
public boolean wisper()
public boolean doAction()

/*
*
Klassen
*
*/

class CServer implements IServerCommands //der server
private IRoomCommands[] rooms //liste der räume (ich glaub falscher java syn:)
public boolean insertRoom() //einen raum in die liste einfügen
public boolean removeRoom() //einen raum aus der liste entfernen
public void listenClient() //nach clients lauschen
public boolean loginUser() //einen user einloggen

class CRoom implements IRoomCommands //der Raum
private IUserCommands users //liste der users
public IServerCommands server //ref zum server
public boolean insertUser() //user einfügen
public boolean removeUser() //user entfernen

class CUser implement IUserCommands //der User
private IRoomCommands room //ref zum raum
private CConnection con //ref zur connection

class CConnection implements Runnable //die Connection
private IUserCommands receiver //ref zum User
public PrintWriter out //oder eine geeignetere Stream Klasse //stream zum senden
public void run() //von Runnable, lauscht auf eingehende msg's,
//decodiert das Chat protokol und ruft fn's von IUserCommands auf

class CClient implements IUserCommands //die GUI
private CConnection con //ref zur connection
[...]


Also wann wollen wir uns treffen und aus den vorschlägen das vorläufig endgültige :) herrausschälen?

Mir ist egal welches Chatsystem, ich kann täglich ab etwa 22Uhr. Wie wärs mit morgen um
diese urzeit im Buha Chanle?

grüsse

[chris]

Original erstellt von knt:
Mir ist egal welches Chatsystem, ich kann täglich ab etwa 22Uhr. Wie wärs mit morgen um
diese urzeit im Buha Chanle?


Is gebongt! http://www.buhaboard.de/NonCGI/Smilies/biggrin.gif

Ich weiss nimmer ob ich das schonmal gesagt hatte, aber da ich das ganze auch unter anderem für nen homepage-projekt von mir gebrauchen würd, was eher für "fun internetuser" als für pc-profies erschaffen wurde, fänd ich's ne ganz gute Idee, wenn man das so benutzerfreundlich wie möglich machen würde! In fact heißt das, dass man keine Befehle wie im irc machen sollte, die man erst alle auswendiglernen müsste, sondern dass man das ganze über hübsche Menüführung machen würd sowie die Möglichkeit, "persönliche Befehle" unter den Tasten F1 - F 12 speichern zu können um net immer wieder erst im Menü rumklicken zu müssen!

Dann man alle auf innen #buha-chan! http://www.buhaboard.de/NonCGI/Smilies/wink.gif

[DarkTom]

Dark Tom:
Die Formatierung des Datenstroms ist recht
kompakt, Änderungen sind daher leichter zu handhaben.

knt:
Verstehe ich nicht. Was meinst du?

Es geht mir darum, daß die Art wie Befehle übertragen werden nur in den Klassen ChatClient und ChatDecoder drinsteht. Sagen wir mal, am Anfang sagen wir, der Chatbefehl heißt "chat text", später ändern wir das aber auf "c text" oder sonstwas. Änderungen sind dann nur in den beiden Klssen notwendig. Die GUI kann ihre eigenen Befehle definieren, die dem user angenehm sind. Entweder per Eingaben, wie die, die agnusdei vorschlägt, oder Buttons für jeden einzelenen Befehl, oder ...
Wichtig ist mir, das die Benutzeroberfläche (und die Befehle die der user tippt, klickt oder nur als Mausbewegung ausführt) absolut _unabhängig_ von den übertragenen Befehlen ist. Die GUI weiß einfach, daß sie, wenn der User den Raum wechseln will, die Raumwechselmethode des Clients aufruft. Wie der Befehl dann an den Server übertragen wird, kann ihr egal sein. Letztendlich liegt die Komfortabilität (tolles Wort) also in der Implementierung der GUI ... und da kann es verschiedene geben, die aber alle auf dem selben ChatClient aufsetzen. Ich hoffe, das ist jetzt soweit verständlich.

Ich werd mir dann gleich noch nen IRC-CLient installieren und mal sehen, wie ich damit zurechtkomme. Mit morgen (bzw inzwischen schon heute) abend gibt es eventuell ein Problem, aber das weiß ich erst später genau. Wenn ihr von mir nichts mehr hört, werde ich kommen.

Gruß
Dark Tom

[toxic]

Ich schlage vor ihr trefft euch im "Projektechannel" #buha-interactive, da ist weniger los...

[knt]

Hi,



Wichtig ist mir, das die Benutzeroberfläche (und die Befehle die der user tippt, klickt oder nur als Mausbewegung ausführt) absolut _unabhängig_ von den übertragenen Befehlen ist.

Ja da haste recht, es ist sinnvoller das noch einmal zu trennen.
Es gibt also Server und Clientseitig je eine Klasse die Funktionsaufrufe in chatbefehle und chatbefehle in Funktionsaufrufe umwandelt.

Naja werden wa heut abend sehn...bis den

grüsse

[DarkTom]

Ich stelle hier mal die Interfaces für die möglichen Befehle zur Diskussion. Vermisst jemand noch Befehle bzw will etwas anders haben?


Hab auch mal die API davon ins Netz gestellt. Ist leichter zu lesen. Sorry wegen den Bannern, aber ich hatte bei prohosting halt noch nen Account.
http://odin.prohosting.com/sirdark/chatapi/


[code]/**
* Das Interface für alle Kommandos, die vom Server an den Client gesendet
* werden können.
* <br><br>
* Alle in diesem Interface definierten Methoden haben den Rückgabetyp <tt>void</tt>,
* da Antworten des Clients nur über eine Implementierung des Interfaces
* <tt>ClientCommands</tt> empfangen werden können.
*
* @see ClientCommands
* @author DarkTom
*/
public interface ServerCommands{
//Konstanten:

/**
* Konstante zur Identifikation des Status: user
*
* @see #statusInfo(String, int)
*/
public static int STATUS_USER = 0;

/**
* Konstante zur Identifikation des Status: Moderator
*
* @see #statusInfo(String, int)
*/
public static int STATUS_MOD = 1;

/**
* Konstante zur Identifikation des Status: Administrator
*
* @see #statusInfo(String, int)
*/
public static int STATUS_ADMIN = 2;

/**
* Konstante zur Identifikation einer Aktion
*
* @see #confirmAction(int, String)
* @see #notifyOfAction(int, String)
*/
public static int ACTION_ROOM_LEAVE = 10;

/**
* Konstante zur Identifikation einer Aktion
*
* @see #confirmAction(int, String)
* @see #notifyOfAction(int, String)
*/
public static int ACTION_ROOM_ENTER = 11;

/**
* Konstante zur Identifikation einer Aktion
*
* @see #confirmAction(int, String)
* @see #notifyOfAction(int, String, String)
*/
public static int ACTION_BAN = 20;

/**
* Konstante zur Identifikation einer Aktion
*
* @see #confirmAction(int, String)
* @see #notifyOfAction(int, String, String)
*/
public static int ACTION_KICK = 21;

/**
* Konstante zur Identifikation einer Aktion
*
* @see #confirmAction(int, String)
* @see #notifyOfAction(int, String, String)
*/
public static int ACTION_MOD_ASSIGNMENT = 22;

/**
* Konstante zur Identifikation einer Aktion
*
* @see #confirmAction(int, String)
* @see #notifyOfAction(int, String, String)
*/
public static int ACTION_GAG = 23;

/**
* Konstante zur Identifikation einer Aktion
*
* @see #confirmAction(int, String)
* @see #notifyOfAction(int, String, String)
*/
public static int ACTION_UNGAG = 24;

//

[DarkTom]

Tja, liebe Leute,

ich glaube es ist an der Zeit, dieses Projekt endgültig für tot zu erklären. Aufgrund Zeitmangels war es zunächst aufgeschoben worden, mir der ernsten Absicht es später weiterzuführen. Allerdings kann ich jetzt immer noch nicht genügend Zeit (und Motivation) aufbringen, um mich ernsthaft damit zu beschäftigen. Wenn knt also nicht alleine weiter machen will (wovon ich ausgehe), sollten wir den Chat in Frieden ruhen lassen, bis es irgendwem einfällt, ihn wiederzuerwecken.

Tom

[funcollect]

hättet ihr lust mir mal die files zu schicken?
ich würde mir das ganze mal gerne anschauen....

[DarkTom]

Wegen mir kannst du die Quelltexte haben. Ich bräuchte nur deine email-Adresse. Die Mailfunktion des Boards unterstützt keine Anhänge.