[Madsserv-commit] madsserv/src/simulator DialogServer.java,NONE,1.1 DialogSocket.java,NONE,1.1 ErrorPopUp.java,NONE,1.1 MadsservSimulator.java,NONE,1.1 Simulator.java,NONE,1.1 ThreadRead.java,NONE,1.1 ThreadWrite.java,NONE,1.1

[<dep...@us...>]

Update of /cvsroot/madsserv/madsserv/src/simulator
In directory sc8-pr-cvs1:/tmp/cvs-serv32599

Added Files:
	DialogServer.java DialogSocket.java ErrorPopUp.java 
	MadsservSimulator.java Simulator.java ThreadRead.java 
	ThreadWrite.java 
Log Message:
ajout du simulateur qui ne gere pas encore les scripts

--- NEW FILE: DialogServer.java ---
import java.util.*;
import java.io.*;
import java.net.*;
import java.lang.Object.*;
import java.lang.System.*;

/**
 * DialogServer c'est la classe qui herite de la classe dialogSocket et qui gere les dialogues avec le serveur
 */
public class DialogServer
    extends DialogSocket {

  private Simulator simulator;


  /**
   * C'est le constructeur de la classe
   */
  public DialogServer(Socket _socketServer, Simulator _simulator) {
    super(_socketServer);
    simulator = _simulator;
    clientID = -1;
  }

  /**
   * incomingMessage methode qui a ete declare abstraite dans DialogSocket et qui gere l'arivee de nouveaux messages du serveur
   * @param _type type de message qui arrive (c'est un entier)
   * @param _message tableau de chaine de characteres qui contient les messages du serveur
   */
  public void incomingMessage(int _type, String[] _message) {
    int lgth = _message.length;
    int qualityLevel = 0;

    switch (_type) {

      case 5: {
        // if (lgth < 2) raise exception;
        //lecture du deuxieme champ : ClientID
        try {
          clientID = Integer.parseInt(_message[0]);
        }
        catch (NumberFormatException e) {
          System.out.println("Le deuxieme champ du message est incorrect");
        }
        simulator.showError(_message[1]);
        simulator.endConnexion();
        break;
      }

      //message d'effacement d'un client de la table;

      case 3: {
        // if (lgth < 2) raise exception;
        //lecture du deuxieme champ : ClientID
        try {
          clientID = Integer.parseInt(_message[0]);
        }
        catch (NumberFormatException e) {
          System.out.println("Le deuxieme champ du message est incorrect");
        }
        System.out.println("On efface le client : " + clientID);
      //  table.effacerClient(clientID);
        simulator.tableClients.removeClientReport(clientID);
        break;

      }
      case 1: {
        // if (lgth < 2) raise exception;
        //lecture du deuxieme champ : ClientID
        try {
          clientID = Integer.parseInt(_message[0]);
        }
        catch (NumberFormatException e) {
          System.out.println("Le deuxieme champ du message est incorrect");
        }

        // lecture du troisieme champ du message : portBase
        try {
          qualityLevel = Integer.parseInt(_message[1]);
        }
        catch (NumberFormatException e) {
          System.out.println("Le troisieme champ du message est incorrect");
        }
     //   table.ajoutElement(clientID,qualityLevel);
        System.out.println("ClientID : " + clientID);
        System.out.println("Niveau Qualite : " + qualityLevel);
        if (simulator.tableClients.getRowForClient(clientID) == -1)
          simulator.tableClients.newClientRecord(clientID,qualityLevel);
        else {
          simulator.tableClients.updateClientReport(clientID,qualityLevel);
        }

      }
    }
  }
}
--- NEW FILE: DialogSocket.java ---
import java.util.*;
import java.io.*;
import java.net.*;

/**
 * <code>DialogServer</code> fournit le modele d'objet permettant la gestion
 * de la communication par socket entre deux stations grace a deux threads
 * (lecture et ecriture). <code>DialogSocket</code> assure une communication
 * dediee.
 * <p>
 * <code>DialogServer</code> fournit une methode d'envoi de messages sur le
 * socket (par l'intermediaire de {@link ThreadWrite} et declare la methode
 * abstraite de reception des messages.
 * @see ThreadRead
 * @see ThreadWrite
 * @author Julien Carbonell
 */

public abstract class DialogSocket {

  private final int TIME_OUT = 1000;

  // identite du client
  protected int clientID;

  // socket gere par DialogSocket
  protected Socket mySocket;

  // streams d'entree et de sortie
  protected PrintWriter output;
  protected InputStreamReader input;
  protected BufferedReader binput;

  // Thread d'entree et thread de sortie
  protected ThreadRead threadInput;
  protected ThreadWrite threadOutput;

  /**
   * Constructeur de <code>DialogSocket</code>.
   * @param _mySocket le {@link Socket} de communication.
   */

  public DialogSocket(Socket _mySocket) {
    mySocket = _mySocket;

    try {
      //mySocket.setSoTimeout(TIME_OUT);
      output = new PrintWriter(mySocket.getOutputStream());
      input = new InputStreamReader(mySocket.getInputStream());
      binput = new BufferedReader(input);

      threadInput = new ThreadRead("Thread d'ecoute ID", binput, this);
    }
    catch (IOException e) {
      System.out.println(e.getMessage());
    }
    /*catch (SocketException e) {
      System.out.println(e.getMessage());
    }*/

  }

  /**
   * Traite l'arrivee d'un nouveau message sur le socket.
   * @param _type le type du message.
   * @param _message le tableau de <code>String</code> contenant les champs du
   * message reçu.
   */

  public abstract void incomingMessage(int _type, String[] _message);

  /**
   * Traite la demande d'envoi d'un message sur le socket. Le message a envoyer
   * est fourni sous la forme d'un tableau de {@link String} contenant les
   * champs du message
   * @param _type le type du message.
   * @param _message le tableau de <code>String</code> contenant les champs du
   * message a envoyer.
   */

  public void sendMessage(int _type, String[] _message) {
    threadOutput = new ThreadWrite("Thread d'ecriture ID", output, this);
  /*  String[] messageToSend;
    if (_message == null) {
      messageToSend = new String[1];
      messageToSend[0] = String.valueOf(clientID);
    }
    else {
      messageToSend = new String[_message.length + 1];
      messageToSend[0] = String.valueOf(clientID);
      for (int i = 0; i < _message.length; i++) {
        messageToSend[i + 1] = _message[i];
      }
    }*/
    threadOutput.setMessageToSend(_type, _message);
    threadOutput.start();

  }

  /**
   * Renvoie l'ID du client.
   * @return ID du client.
   */

  public int getClientID() {
    return clientID;
  }

  /**
   * Demarre l'ecoute du socket
   */

  public void start() {
    threadInput.start();
  }

  /**
   * Stoppe le gestion de la communication et ferme le socket.
   */

  public synchronized void stop() {
    try {
      System.err.println("j'entre dans le stop de dialog socket");
      //threadInput = null;
      //System.gc();

      //threadInput.interrupt();
      //threadInput.setEnd();
      System.err.println("le thread est mort");
      Thread.sleep(1000);
      //binput.close();
      //System.err.println("le binput est mort");
      if (!mySocket.isClosed())
        mySocket.close();
      System.err.println("le socket est mort");
      //System.err.println("le socket est ferme " + mySocket.isClosed());
      System.out.println("Fin DialogServer ");
    }
    catch (Exception e) {}
  }

}
--- NEW FILE: ErrorPopUp.java ---
import java.awt.*;
import java.net.*;
import java.awt.event.*;
import java.awt.Component.*;
import java.awt.TextComponent.*;
import java.awt.geom.Point2D.*;
import java.awt.Point.*;

/**
 * <code>ErrorPopUp</code> est une popup qui apparait lorsque des erreurs apparaissent.
 * @author Xavier Deplancq
 */

public class ErrorPopUp
    extends Frame {
  private Container contentPane;
  private Panel panelNorth = new Panel();
  private Panel panelSouth = new Panel();
  private Label errorMessage = new Label();
  private BorderLayout borderLayout1 = new BorderLayout();
  private Button OK;

  /**
   * Constructeur de la classe ErrorPopUp
   * @param errMessage le Message qui doit etre affiche
   * @param _client la reference du client
   */

  public ErrorPopUp(String errMessage, Simulator _simulator) {
    enableEvents(AWTEvent.WINDOW_EVENT_MASK);

    errorMessage.setText(errMessage);
    panelNorth.add(errorMessage);
    OK = new Button("OK");
    OK.setSize(new Dimension(60, 15));
    OK.addActionListener(new ErrorPopUp_OK_ActionAdapter(this));
    panelSouth.add(OK);
    contentPane = this;
    this.setSize(260, 120);
    panelNorth.setBackground(new Color(236, 233, 216));
    panelSouth.setBackground(new Color(236, 233, 216));

    contentPane.setLayout(borderLayout1);
    contentPane.add(panelNorth, borderLayout1.CENTER);
    contentPane.add(panelSouth, borderLayout1.SOUTH);

    Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
    Dimension simulatorSize = _simulator.getSize();
    Dimension popupSize = this.getSize();

    double simulatorPlaceX = _simulator.getX();
    double simulatorPlaceY = _simulator.getY();
    if (popupSize.height > simulatorSize.height) {
      popupSize.height = simulatorSize.height;
    }
    if (popupSize.width > simulatorSize.width) {
      popupSize.width = simulatorSize.width;
    }
    this.setLocation( (int) (simulatorPlaceX) + (popupSize.height) / 2,
                     (int) (simulatorPlaceY) + simulatorSize.width / 2);

    showWindow();
  }

  /**
   * OK_actionPerformed qui sert lorsque l'on appuie sur le bouton OK
   * @param e l'evenement
   */

  public void OK_actionPerformed(ActionEvent e) {
    setVisible(false);
  }

  /**
   * processWindowEvent c est une methode qui est appele lorsque l'on ferme la boite de dialogue
   * @param l evenement qui indique que l'on ferme la fenetre
   */

  protected void processWindowEvent(WindowEvent e) {
    super.processWindowEvent(e);
    if (e.getID() == WindowEvent.WINDOW_CLOSING) {
      OK_actionPerformed(null);
    }
  }

  /**
   * Methode qui affiche la boite de dialogue
   */

  public void showWindow() {
    setVisible(true);
  }

  /**
   * Classe qui ecoute si l'on appui sur le bouton OK
   */

  class ErrorPopUp_OK_ActionAdapter
      implements ActionListener {
    ErrorPopUp adaptee;

    ErrorPopUp_OK_ActionAdapter(ErrorPopUp adaptee) {
      this.adaptee = adaptee;
    }

    public void actionPerformed(ActionEvent e) {
      adaptee.OK_actionPerformed(e);
    }
  }

}

--- NEW FILE: MadsservSimulator.java ---
//package madsserv_planification;

import javax.swing.UIManager;
import java.awt.*;
import java.net.*;

/**
 * <p>Title: </p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2003</p>
 * <p>Company: </p>
 * @author Christele Champagnat et Xavier Deplancq
 * @version 1.0
 **/

/**
 * MadsservSimulator c'est la classe MadsservSimulator
 */
public class MadsservSimulator {
  /**
   * champs de la classe MadsservSimulator
   */
  private boolean packFrame = false;
  //private Socket mySocket;

  /**
   * MadsservSimulator constructeur de la calsse
   */
  public MadsservSimulator() {

    Simulator simulator = new Simulator();

    //Validate frames that have preset sizes
    //Pack frames that have useful preferred size info, e.g. from their layout
    if (packFrame) {
      simulator.pack();
    }
    else {
      // String[] request = new String[1];
      // request[0] = "";
      simulator.validate();
      // dialogServer.start();
      // dialogServer.sendMessage(0,request);
    }

    //on centre ici la fenetre
    Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
    Dimension simulatorSize = simulator.getSize();
    if (simulatorSize.height > screenSize.height) {
      simulatorSize.height = screenSize.height;
    }
    if (simulatorSize.width > screenSize.width) {
      simulatorSize.width = screenSize.width;
    }
    simulator.setLocation( (screenSize.width - simulatorSize.width) / 2,
                      (screenSize.height - simulatorSize.height) / 2);
    simulator.setVisible(true);
  }

  /**
   * Methode main du Simulateur
   */

  public static void main(String[] args) {
    try {
      UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
    }
    catch (Exception e) {
      e.printStackTrace();
    }
    new MadsservSimulator();
  }

/*  static void prUsage() {
    System.err.println("Usage: ClientRTPManager <session> <session> ...");
    System.err.println("     <session>: <address>/<port>/<ttl>");
    System.exit(0);
  }*/

}
--- NEW FILE: Simulator.java ---
//package madsserv_planification;

import java.awt.*;
import java.net.*;
import java.awt.event.*;
import java.awt.Component.*;
import java.awt.TextComponent.*;
import java.awt.Checkbox.*;
import java.awt.CheckboxGroup.*;
import javax.swing.UIManager;
import javax.swing.*;
import javax.swing.JComponent.*;
import javax.swing.JTable.*;
import javax.swing.table.*;
import javax.swing.border.*;
import java.util.Vector.*;

public class Simulator
    extends Frame {
  private Container contentPane;

  //Declaration de la fenetre
  private Panel panelSouth = new Panel();
  private Panel panelNorth = new Panel();
  private Panel panelEmpty = new Panel();

  private JPanel jPanelReport = new JPanel();

  //Declaration des types de menu
  private MenuBar menuBar1 = new MenuBar();
  private Menu menuFile = new Menu();
  private MenuItem itemOpenClient = new MenuItem();
  private MenuItem itemExit = new MenuItem();
  private Button go;

  //Declaration de la zone de texte
  private TextField qualityChoice;
  private TextField clientId;
  private TextField script;
  private TextField AdServer;
  private Label qualityLabel = new Label( /*"qualité client"*/);
  private Label clientIDLabel = new Label( /*"identite client"*/);
  private Label erreurLabel = new Label( /*"erreur"*/);
  private Label AdLabel = new Label();
  private Label nivQualiteLabel = new Label();
  private Label tabClientIdLabel = new Label();

//graphique
  private GridLayout gridLayout2 = new GridLayout(1, 1);
  private BorderLayout borderLayout1 = new BorderLayout();
  private GridBagLayout gridBagLayoutNorth = new GridBagLayout();
  private GridBagLayout gridBagLayoutSouth = new GridBagLayout();

  //Socket
  private Socket mySocket = null;
  private DialogServer dialogServer;

  TableClients tableClients = new TableClients();

  /* public static void main(String[] args) {
   Simulator simulator;
   boolean packFrame=false;
     try {
       UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
     }
     catch(Exception e) {
       e.printStackTrace();
     }
    simulator = new Simulator();
    if (packFrame) {
       simulator.pack();
     }
     else {
       simulator.validate();
     }
     //Center the window
     Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
     Dimension frameSize = simulator.getSize();
     if (frameSize.height > screenSize.height) {
       frameSize.height = screenSize.height;
     }
     if (frameSize.width > screenSize.width) {
       frameSize.width = screenSize.width;
     }
     simulator.setLocation((screenSize.width - frameSize.width) / 2, (screenSize.height - frameSize.height) / 2);
     simulator.setVisible(true);
   }*/

// Construction du simulateur
  public Simulator() {
    enableEvents(AWTEvent.WINDOW_EVENT_MASK);

    try {
      jbInit();
     // afficheTable();
    }
    catch (Exception e) {
      e.printStackTrace();
    }
  }

  //initialisation de la fenetre
  private void jbInit() throws Exception {
    contentPane = this;
    contentPane.setLayout(borderLayout1);
    this.setSize(new Dimension(480, 640));
    this.setTitle("Madsserv Simulator");
    jPanelReport.setLayout(gridLayout2);
    tableClients.setgraph(jPanelReport);

    //création de la zone de texte
    qualityChoice = new TextField("");
    clientId = new TextField("");
    script = new TextField("");

    //nommage des menus
    menuFile.setLabel("File");

    itemExit.setLabel("Exit");
    itemOpenClient.setLabel("open client");
    itemExit.addActionListener(new Simulator_itemExit_ActionAdapter(this));

    //construction des menus
    menuFile.add(itemOpenClient);
    menuFile.add(itemExit);

    menuBar1.add(menuFile);

    this.setMenuBar(menuBar1);

    //création du boutton GO
    go = new Button("Start!");
    go.setSize(new Dimension(60, 15));
    go.addActionListener(new Simulator_boutongo_ActionAdapter(this));

    qualityLabel.setText("qualité client :");
    clientIDLabel.setText("Identité client:");
    erreurLabel.setText("script:");
    AdLabel.setText("Serv :");
    tabClientIdLabel.setText("Client");
    nivQualiteLabel.setText("Qualite ");

    AdServer = new TextField("Dronej.rezel.com:4998");
    qualityLabel.setSize(new Dimension(50, 15));
    clientIDLabel.setSize(new Dimension(50, 15));
    erreurLabel.setSize(new Dimension(50, 15));
    AdLabel.setSize(new Dimension(50, 15));

    panelNorth.setBackground(new Color(236, 230, 230));
    panelSouth.setBackground(new Color(236, 230, 230));

    panelSouth.setLayout(gridBagLayoutSouth);
    GridBagConstraints c = new GridBagConstraints();
    c.fill = GridBagConstraints.BOTH;
    c.insets = new Insets(1, 5, 1, 5);
    c.weightx = 0.0;
    c.weighty = 1.0;
    panelSouth.add(clientIDLabel, c);
    c.gridwidth = GridBagConstraints.REMAINDER;
    c.weightx = 1.0;
    panelSouth.add(clientId, c);
    c.gridwidth = GridBagConstraints.RELATIVE;
    c.weightx = 0.0;
    panelSouth.add(qualityLabel, c);
    c.weightx = 1.0;
    panelSouth.add(qualityChoice, c);
    c.gridwidth = GridBagConstraints.RELATIVE;

    panelNorth.setLayout(gridBagLayoutNorth);
    c.fill = GridBagConstraints.BOTH;
    c.insets = new Insets(1, 5, 1, 5);
    c.weightx = 0.0;
    c.weighty = 1.0;
    panelNorth.add(erreurLabel, c);
    c.gridwidth = GridBagConstraints.REMAINDER;
    c.weightx = 1.0;
    panelNorth.add(script, c);

    c.gridwidth = GridBagConstraints.RELATIVE;
    c.weightx = 0.0;
    panelNorth.add(AdLabel, c);
    c.weightx = 1.0;
    c.gridwidth = GridBagConstraints.REMAINDER;
    panelNorth.add(AdServer, c);

    c.weightx = 0.0;
    //c.gridwidth = GridBagConstraints.REMAINDER;
    panelNorth.add(go, c);

    contentPane.add(panelSouth, BorderLayout.SOUTH);
    contentPane.add(panelNorth, BorderLayout.NORTH);
    contentPane.add(jPanelReport, BorderLayout.CENTER);
  }

  public void itemExit_actionPerformed(ActionEvent e) {
    try {
      String messageToSend[] = new String[1];
      messageToSend[0] = "fin de la connexion";
      dialogServer.sendMessage(4, messageToSend);
      System.exit(0);
    }
    catch (Exception ex) {
      System.exit(0);
    }

  }

  protected void processWindowEvent(WindowEvent e) {
    super.processWindowEvent(e);
    if (e.getID() == WindowEvent.WINDOW_CLOSING) {
      itemExit_actionPerformed(null);
    }
  }

  public void boutongo_actionPerformed(ActionEvent evt) {
    String q, clId;
    String fo1 = "", fo2 = "";
    String[] messageToSend;

    q = qualityChoice.getText();
    clId = clientId.getText();

    System.out.println(q);
    System.out.println(clId);

    if (mySocket == null) {
      try {
        mySocket = new Socket(getAddressServer(), getServerPort());
        System.out.println("Simulateur demarre");
      }
      catch (Exception e) {
        showError("serveur ou port incorrect");
      }

      dialogServer = new DialogServer(mySocket, this);
      dialogServer.start();
    }

    else {
      if (((getClientId().compareTo("")) != 0) && ((getqualityClient().compareTo("")) != 0))
      {
      messageToSend = new String[2];
      messageToSend[0] = getClientId();
      messageToSend[1] = getqualityClient();
      dialogServer.sendMessage(2, messageToSend);
      }
    }

  }

  /**
   * getAddressServer, cette methode permet d'obtenir l'InetAddress du serveur sur lequel il faut se connecter, cette adresse est rentré à la main dans une zone de texte sur l'interface graphique du client
   * @return InetAddress du server
   */
  public InetAddress getAddressServer() {
    String host;
    int columnPosition;

    host = AdServer.getText();
    columnPosition = host.indexOf(':');
    try {
      return (InetAddress.getByName(host.substring(0, columnPosition)));
    }

    catch (UnknownHostException e) {
      return (null);
    }
  }

  /**
   * getServerPorrt est une methode qui permet d'obtenir le Numero de port du serveur, ce numero de port est rentre dans une zone de texte sur l'interface graphique du client
   * @return int le numero du port sur lequel, on doit se connecter au serveur
   */
  public int getServerPort() {
    String host;
    int columnPosition;

    host = AdServer.getText();
    columnPosition = host.indexOf(':');

    return (Integer.parseInt(host.substring(columnPosition + 1)));

  }

  public String getqualityClient() {
    String q;
    q = qualityChoice.getText();
    return q;
  }

  public String getClientId() {
    String clId;
    clId = clientId.getText();
    return clId;
  }

  public void endConnexion() {
    dialogServer.stop();
    mySocket = null;
  }

  public void showError(String messageErreur) {
    ErrorPopUp errorPopUp = new ErrorPopUp(messageErreur, this);
  }
}

class Simulator_itemExit_ActionAdapter
    implements ActionListener {
  Simulator adaptee;
  Simulator_itemExit_ActionAdapter(Simulator adaptee) {
    this.adaptee = adaptee;
  }

  public void actionPerformed(ActionEvent e) {
    adaptee.itemExit_actionPerformed(e);
  }
}

class Simulator_boutongo_ActionAdapter
    implements ActionListener {
  Simulator adaptee;

  Simulator_boutongo_ActionAdapter(Simulator adaptee) {
    this.adaptee = adaptee;
  }

  public void actionPerformed(ActionEvent evt) {
    adaptee.boutongo_actionPerformed(evt);
  }
}

  class TableClients
    extends JTable {
  private boolean DEBUG = false;
  private String[] columnNames = {
      "ID Client",
      "Niveau de qualite"};

  private Object[][] data = {
      {
      new Integer(-2), new Integer(-2)}
  };
  private MyTableModel myModel = null;

  public TableClients() {
    super();
    myModel = new MyTableModel(data, columnNames);
    setModel(myModel);
    // setPreferredScrollableViewportSize(new Dimension(500, 70));

  }

  public void newClientRecord(int _clientID, int _quality) {
    Object[] newRow = {
        new Integer(_clientID), new Integer(_quality)};
    myModel.insertRow(0, newRow);
  }

  public int getRowForClient(int _clientID) {
    for (int i = 0; i < myModel.getRowCount(); i++) {
      if (_clientID == ( (Integer) myModel.getValueAt(i, 0)).intValue()) {
        return i;
      }
    }
    return -1;
  }

  public void removeClientReport(int _clientID) {
    ( (DefaultTableModel) getModel()).removeRow(getRowForClient(
        _clientID));
  }

  public void updateClientReport(int _clientID, int _qualityLevel) {
    int row = getRowForClient(_clientID);

    if (_qualityLevel != -1) {
      setValue(new Integer(_qualityLevel), row, 5); ;
    }
  }

  public void setValue(Object value, int row, int col) {
    myModel.setValueAt(value, row, col);
  }

  public void setgraph(JPanel jp) {
    JScrollPane sc = new JScrollPane(this);
    jp.add(sc);
  }

  /* public void modifyValue(Object _value, int _row, int _col) {
     setValueAt(_value, _row, _col);
   }*/

  class MyTableModel
      extends DefaultTableModel {

    public MyTableModel() {
      super();
    }

    public MyTableModel(Object[][] data, Object[] columnNames) {
      super(data, columnNames);
    }

    /*
     * JTable uses this method to determine the default renderer/
     * editor for each cell.  If we didn't implement this method,
     * then the last column would contain text ("true"/"false"),
     * rather than a check box.
     */
    public Class getColumnClass(int c) {
      return getValueAt(0, c).getClass();
    }

    public boolean isCellEditable(int row, int column) {
      return false;
    }

    private void printDebugData() {
      int numRows = getRowCount();
      int numCols = getColumnCount();

      for (int i = 0; i < numRows; i++) {
        System.out.print("    row " + i + ":");
        for (int j = 0; j < numCols; j++) {
          System.out.print("  " + data[i][j]);
        }
        System.out.println();
      }
      System.out.println("--------------------------");
    }
  }


    }

--- NEW FILE: ThreadRead.java ---
import java.util.*;
import java.io.*;
import java.net.*;

/**
 * <code>ThreadRead</code> definit un thread d'ecoute sur un {@link BufferedReader}.
 * Il effectue une ecoute permanente.
 * <p>
 * Il gere l'extraction du message en isolant les elements protocolaires de la
 * transmission du message.
 * @see ThreadWrite
 * @see DialogSocket
 * @author Julien Carbonell
 */

public class ThreadRead
    extends Thread {

  boolean end = false;

  // objet parent qui gere les entrees-sorties sur le socket
  protected DialogSocket parent;

  // BufferedReader sur lequel sont lus les messages
  protected BufferedReader binput;

  protected String temp = "";
  protected String message = "";
  protected boolean waitingMessage = true;
  protected int messageType = -1;

  /**
   * Constructeur de <code>ThreadRead</code>.
   * @param _name le nom du thread.
   * @param _binput le {@link BufferedReader} sur lequel lit <code>ThreadRead</code>.
       * @param _parent le {@link DialogSocket} qui gere le <code>ThreadRead</code>.
   */
  public ThreadRead(String _name, BufferedReader _binput,
                    DialogSocket _parent) {
    super(_name + _parent.getClientID());
    parent = _parent;
    binput = _binput;
  }

  /**
       * Redefinit la methode <code>run</code> de la classe parent <code>Thread</code>.
   */
  public void run() {
    try {
      while ( (temp = binput.readLine()) != null) {
        if (temp != null) {
            if (waitingMessage && (temp.charAt(0) == '#')) {
              // un nouveau message commence
              waitingMessage = false;
            }
            else {
              if (!waitingMessage && (temp.charAt(0) == '#')) {
                waitingMessage = true;
                messageType = Integer.parseInt(message.substring(0,
                    message.indexOf('\n')));
                System.out.println("Le Thread Read a recu\n" + message);
                message = message.substring(message.indexOf('\n') + 1,
                                            message.length() - 1);
                parent.incomingMessage(messageType, parseMessage(message));
                message = "";
              }
              else {
                message = message.concat(temp + "\n");
              }
            }
          }

        }
      }
  /*  catch (SocketTimeoutException e) {
      System.out.println(e.getMessage());
    }*/
    catch (Exception e) {
      e.printStackTrace();
    }
    finally {
      try {
      //  binput.close();
        System.out.println(getName() + Thread.currentThread() +
                           " : Stopped !!! ");
      }
      catch (Exception e) {
        System.out.println(e.getMessage());
      }
    }

  }

  protected String[] parseMessage(String _message) {
    return _message.split("\n");
  }

}
--- NEW FILE: ThreadWrite.java ---
import java.util.*;
import java.io.*;
import java.net.*;

/**
 * <code>ThreadWrite</code> definit un thread d'ecriture sur un {@link PrintWriter}.
 * Sa duree d'execution est celle de l'envoi d'un message.
 * <p>
 * Il gere l'encapsulation du message en ajoutant les elements protocolaires de la
 * transmission du message.
 * @see ThreadRead
 * @see DialogSocket
 * @author Julien Carbonell
 */

public class ThreadWrite
    extends Thread {

  // objet parent qui gere les entrees-sorties sur le socket
  protected DialogSocket parent;

  // objet sur lequel sont dirigees les ecritures
  protected PrintWriter output;

  protected String messageToSend = "";

  /**
   * Constructeur de <code>ThreadWrite</code>.
   * @param _name le nom du thread.
   * @param _binput le {@link PrinterWriter} sur lequel ecrit <code>ThreadWrite</code>.
   * @param _parent le {@link DialogSocket} qui gere le <code>ThreadWrite</code>.
   */
  public ThreadWrite(String _name, PrintWriter _output,
                     DialogSocket _parent) {
    super(_name + _parent.getClientID());
    parent = _parent;
    output = _output;
  }

  // met a jour le message a envoyer
  public synchronized void setMessageToSend(int _type, String[] _message) {
    messageToSend="";
    messageToSend = _type + "\n";
    for(int i = 0; i< _message.length; i++) {
      messageToSend = messageToSend.concat(_message[i] + "\n");
    }
  }

  /**
   * Redefinit la methode <code>run</code> de la classe parent <code>Thread</code>.
   */
  public void run() {
    try {
      if (messageToSend.compareTo("") != 0) {
        System.out.println("Message envoye par le thread output " + "#\n" +
                          messageToSend + "#");
       output.println("#\n" + messageToSend + "#");
       output.flush();
     }
   }
   catch (Exception e) {
     e.printStackTrace();
   }
   finally {
     try {
       System.out.println(getName() + Thread.currentThread() +
                          " : Stopped !!! ");
     }
     catch (Exception e) {
     }
   }
 }

}