rendu du projet

rename
remove old files, add app .jar
2021-02-16 00:08:15 +01:00 · 2021-02-15 23:35:20 +01:00 · 2021-02-15 23:32:36 +01:00
47 changed files with 18 additions and 3273 deletions
--- a/POO/src/communication/filetransfer/FileTransferClient.java
+++ b/POO/src/communication/filetransfer/FileTransferClient.java
@ -1,38 +0,0 @@
 package communication.filetransfer;
 import java.io.File;
 import java.io.IOException;
 import java.net.UnknownHostException;
 import java.util.ArrayList;
 import observers.ObserverInputMessage;
 public class FileTransferClient {
 	private int port;
 	private ArrayList<File> files = null;
 	private ObserverInputMessage obsInput;
 	public FileTransferClient(int port, ArrayList<File> filesToSend, ObserverInputMessage obs) throws UnknownHostException, IOException {
 		this.port = port;
 		this.files = filesToSend;
 		this.obsInput = obs;
 	}
 	public void sendFiles() throws IOException, InterruptedException {
 		for(File f: this.files) {
 			FileTransferSendingThread ftc = new FileTransferSendingThread(this.port, f,this.obsInput);
 			ftc.start();
 			ftc.join();
 		}
 	}
 }
--- a/POO/src/communication/filetransfer/FileTransferReceivingThread.java
+++ b/POO/src/communication/filetransfer/FileTransferReceivingThread.java
@ -1,80 +0,0 @@
 package communication.filetransfer;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.nio.ByteBuffer;
 import java.nio.channels.FileChannel;
 import java.nio.channels.SocketChannel;
 import messages.Message;
 import messages.MessageFichier;
 import observers.ObserverInputMessage;
 public class FileTransferReceivingThread extends Thread {
 	private SocketChannel sockTransfert;
 	private ObserverInputMessage obsInput;
 	public FileTransferReceivingThread(SocketChannel sock, ObserverInputMessage obs) {
 		this.sockTransfert = sock;
 		this.obsInput = obs;
 	}
 	public void run() {
 		try {
 			int nbByteRead = 0;
 			ByteBuffer fileData = ByteBuffer.allocate(4 * FileTransferUtils.KB_SIZE);
 			ObjectInputStream inputFileInformation = new ObjectInputStream(
 					this.sockTransfert.socket().getInputStream());
 			int nbTotalBytesRead;
 			nbTotalBytesRead = 0;
 			Object o = inputFileInformation.readObject();
 			MessageFichier m = (MessageFichier) o;
 			String[] fileInfo = this.processFileInformation(m);
 			String filePath = FileTransferUtils.DOWNLOADS_RELATIVE_PATH + fileInfo[0];
 			long fileSize = Long.parseLong(fileInfo[1]);
 			FileOutputStream fOutStream = new FileOutputStream(filePath);
 			FileChannel fileWriter = fOutStream.getChannel();
 			while (nbTotalBytesRead < fileSize && (nbByteRead = this.sockTransfert.read(fileData)) > 0) {
 				fileData.flip();
 				fileWriter.write(fileData);
 				fileData.clear();
 				nbTotalBytesRead += nbByteRead;
 			}
 			fileWriter.close();
 			Message mUpdate = FileTransferUtils.processMessageToDisplay(new File(filePath));
 			mUpdate.setSender("other");
 			this.obsInput.update(this, mUpdate);
 		} catch (IOException | ClassNotFoundException e) {
 			e.printStackTrace();
 		} finally {
 			try {
 				this.sockTransfert.close();
 			} catch (IOException e) {
 				e.printStackTrace();
 			}
 		}
 	}
 	private String[] processFileInformation(MessageFichier m) {
 		return m.getContenu().split(";");
 	}
 }
--- a/POO/src/communication/filetransfer/FileTransferSendingThread.java
+++ b/POO/src/communication/filetransfer/FileTransferSendingThread.java
@ -1,74 +0,0 @@
 package communication.filetransfer;
 import java.io.File;
 import java.io.IOException;
 import java.io.ObjectOutputStream;
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
 import java.nio.ByteBuffer;
 import java.nio.channels.FileChannel;
 import java.nio.channels.SocketChannel;
 import java.nio.file.Paths;
 import messages.MauvaisTypeMessageException;
 import messages.Message;
 import messages.MessageFichier;
 import messages.Message.TypeMessage;
 import observers.ObserverInputMessage;
 public class FileTransferSendingThread extends Thread{
 	private SocketChannel sockTransfert;
 	private File file;
 	private ObserverInputMessage obsInput;
 	public FileTransferSendingThread(int port, File fileToSend, ObserverInputMessage obs) throws IOException {
 		SocketChannel sock = SocketChannel.open();
 		SocketAddress addr = new InetSocketAddress(port);
 		sock.connect(addr);
 		this.sockTransfert = sock;
 		this.file = fileToSend;
 		this.obsInput = obs;
 	}
 	public void run() {
 		try {
 			ByteBuffer fileData = ByteBuffer.allocate(4 * FileTransferUtils.KB_SIZE);
 			ObjectOutputStream outputFileInformation = new ObjectOutputStream(
 					this.sockTransfert.socket().getOutputStream());
 			FileChannel fileReader = FileChannel.open(Paths.get(file.getPath()));
 			String str = file.getName() + ";" + file.getTotalSpace();
 			// Send file datas (name + size);
 			outputFileInformation.writeObject(new MessageFichier(TypeMessage.FICHIER, str, ""));
 			while (fileReader.read(fileData) > 0) {
 				fileData.flip();
 				this.sockTransfert.write(fileData);
 				fileData.clear();
 			}
 			fileReader.close();
 			Message mUpdate = FileTransferUtils.processMessageToDisplay(this.file);
 			mUpdate.setSender("Moi");
 			this.obsInput.update(this, mUpdate);
 		} catch (IOException | MauvaisTypeMessageException e) {
 			e.printStackTrace();
 		} finally {
 			try {
 				this.sockTransfert.close();
 			} catch (IOException e) {
 				e.printStackTrace();
 			}
 		}
 	}
 }
--- a/POO/src/communication/filetransfer/FileTransferServer.java
+++ b/POO/src/communication/filetransfer/FileTransferServer.java
@ -1,46 +0,0 @@
 package communication.filetransfer;
 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.net.UnknownHostException;
 import java.nio.channels.ServerSocketChannel;
 import java.nio.channels.SocketChannel;
 import observers.ObserverInputMessage;
 public class FileTransferServer extends Thread {
 	private ServerSocketChannel sockFTListen;
 	private int nbFile;
 	private ObserverInputMessage obsInput;
 	public FileTransferServer(int nbFile, ObserverInputMessage obs) throws UnknownHostException, IOException {
 		this.sockFTListen = ServerSocketChannel.open();
 		this.sockFTListen.socket().bind(new InetSocketAddress(0));
 		this.nbFile = nbFile;
 		this.obsInput = obs;
 	}
 	public int getPort() {
 		return this.sockFTListen.socket().getLocalPort();
 	}
 	@Override
 	public void run() {
 		try {
 			for (int i = 0; i < this.nbFile; i++) {
 				SocketChannel sock = this.sockFTListen.accept();
 				Thread ft = new FileTransferReceivingThread(sock, this.obsInput);
 				ft.start();
 				ft.join();
 			}
 			this.sockFTListen.close();
 		} catch (IOException | InterruptedException e) {
 			e.printStackTrace();
 		}
 	}
 }
--- a/POO/src/communication/filetransfer/FileTransferUtils.java
+++ b/POO/src/communication/filetransfer/FileTransferUtils.java
@ -1,112 +0,0 @@
 package communication.filetransfer;
 import java.awt.Graphics2D;
 import java.awt.GraphicsConfiguration;
 import java.awt.GraphicsDevice;
 import java.awt.GraphicsEnvironment;
 import java.awt.geom.AffineTransform;
 import java.awt.image.BufferedImage;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.Base64;
 import java.util.List;
 import javax.imageio.ImageIO;
 import messages.MessageFichier;
 import messages.MauvaisTypeMessageException;
 import messages.Message.TypeMessage;
 public class FileTransferUtils {
 	protected static final String DOWNLOADS_RELATIVE_PATH = "../downloads/";
 	protected static final ArrayList<String> IMAGE_EXTENSIONS = new ArrayList<String>(List.of("tif","tiff","bmp","jpg","jpeg","gif", "png", "eps", "svg"));
 	protected static final int KB_SIZE = 1024;
 	protected static MessageFichier processMessageToDisplay(File file) throws IOException {
 		String nameFile = file.getName();
 		String extension = processFileExtension(nameFile); 
 		TypeMessage type;
 		String contenu;
 		if(IMAGE_EXTENSIONS.contains(extension)) {
 			type = TypeMessage.IMAGE;
 			BufferedImage img = ImageIO.read(file);
 			contenu = encodeImage(createThumbnail(img), extension) ;
 		}else {
 			type = TypeMessage.FICHIER;
 			contenu = nameFile;
 		}
 		try {
 			//return new MessageFichier(type, contenu, extension);
 			return new MessageFichier(type, contenu, extension);
 		} catch (MauvaisTypeMessageException e) {
 			System.out.println("Should never go in");
 			e.printStackTrace();
 		}
 		return null;
 	}
 	protected static String processFileExtension(String fileName) {
 		String extension = "";
 		int i = fileName.indexOf('.');
 		if (i >= 0 || i != -1) {
 		    extension = fileName.substring(i+1).toLowerCase();
 		}
 		return extension;
 	}
 	private static BufferedImage createThumbnail(BufferedImage image){
 		float w = image.getWidth();
 		float ratio = (w > 150) ? (150F/w) : 1;
 		BufferedImage scaled = scale(image, ratio);
 		return scaled;
 	}
 	private static String encodeImage(BufferedImage img, String extension) throws IOException {
 		ByteArrayOutputStream bos = new ByteArrayOutputStream();
 		ImageIO.write(img, extension, bos);
 		String imgString = Base64.getEncoder().encodeToString(bos.toByteArray());
 		bos.close();
 		return imgString;
 	}
 	public static BufferedImage decodeImage(String imageString) throws IOException {
 		byte[] imgData = Base64.getDecoder().decode(imageString);
 		InputStream is = new ByteArrayInputStream(imgData);
        BufferedImage img = ImageIO.read(is);
        is.close();
        return img;
 	}
 	private static BufferedImage scale(BufferedImage source, double ratio) {
 		int w = (int) (source.getWidth() * ratio);
 		int h = (int) (source.getHeight() * ratio);
 		BufferedImage bi = getCompatibleImage(w, h);
 		Graphics2D g2d = bi.createGraphics();
 		double xScale = (double) w / source.getWidth();
 		double yScale = (double) h / source.getHeight();
 		AffineTransform at = AffineTransform.getScaleInstance(xScale, yScale);
 		g2d.drawRenderedImage(source, at);
 		g2d.dispose();
 		return bi;
 	}
 	private static BufferedImage getCompatibleImage(int w, int h) {
 		GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
 		GraphicsDevice gd = ge.getDefaultScreenDevice();
 		GraphicsConfiguration gc = gd.getDefaultConfiguration();
 		BufferedImage image = gc.createCompatibleImage(w, h);
 		return image;
 	}
 }
--- a/POO/src/communication/tcp/TCPClient.java
+++ b/POO/src/communication/tcp/TCPClient.java
@ -1,80 +0,0 @@
 package communication.tcp;
 import java.io.File;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.net.InetAddress;
 import java.net.Socket;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import observers.ObserverInputMessage;
 import observers.ObserverSocketState;
 import messages.MessageTexte;
 import messages.MauvaisTypeMessageException;
 import messages.Message;
 import messages.Message.TypeMessage;
 public class TCPClient {
 	private Socket sockTCP;
 	private ObjectOutputStream output;
 	private TCPInputThread inputThread;
 	public TCPClient(Socket sockTCP) throws IOException {
 		this.sockTCP = sockTCP;
 		this.output = new ObjectOutputStream(sockTCP.getOutputStream());
 		ObjectInputStream input = new ObjectInputStream(sockTCP.getInputStream());
 		this.inputThread = new TCPInputThread(input);
 	}
 	public TCPClient(InetAddress addr, int port) throws IOException {
 		this(new Socket(addr, port));
 	}
 	public void startInputThread() {
 		this.inputThread.start();
 	}
 	public void sendMessage(Message message) throws IOException, MauvaisTypeMessageException {
 		System.out.println("dans write");
 		this.output.writeObject(message);
 	}
 	public void setObserverInputThread(ObserverInputMessage o) {
 		this.inputThread.setObserverInputMessage(o);
 	}
 	public void setObserverSocketState(ObserverSocketState o) {
 		this.inputThread.setObserverSocketState(o);
 	}
 	public void destroyAll() {
 		try {
 			if (!this.sockTCP.isClosed()) {
 				this.output.close();
 				this.sockTCP.close();
 				this.inputThread.setObserverSocketState(null);
 			}
 			this.inputThread = null;
 			this.sockTCP = null;
 			this.output = null;
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 	}
 }
--- a/POO/src/communication/tcp/TCPInputThread.java
+++ b/POO/src/communication/tcp/TCPInputThread.java
@ -1,72 +0,0 @@
 package communication.tcp;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import observers.ObserverInputMessage;
 import observers.ObserverSocketState;
 public class TCPInputThread extends Thread {
 	private ObjectInputStream input;
 	private boolean running;
 	private ObserverInputMessage obsInput;
 	private ObserverSocketState obsState;
 	public TCPInputThread(ObjectInputStream input) {
 		this.input = input;
 		this.running = true;
 	}
 	@Override
 	public void run() {
 		while (this.running) {
 			try {
 				System.out.println("dans read");
 				Object o =  this.input.readObject();
 				this.obsInput.update(this, o);
 			} catch (IOException | ClassNotFoundException e) {
 				this.interrupt();
 			}
 		}
 	}
 	@Override
 	public void interrupt() {
 		try {
 			//Stop the thread
 			this.running = false;
 			//Close the stream and the socket
 			this.input.close();
 			if(this.obsState != null) {
 				//Send an update to the controller
 				this.obsState.updateSocketState(this, true);
 			}
 			//Set every attribute to null so they're collected by the GC
 			this.obsInput = null;
 			this.obsState = null;
 			this.input = null;
 		} catch (IOException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 	}
 	protected void setObserverInputMessage(ObserverInputMessage o) {
 		this.obsInput = o;
 	}
 	protected void setObserverSocketState(ObserverSocketState o) {
 		this.obsState = o;
 	}
 }
--- a/POO/src/communication/tcp/TCPServer.java
+++ b/POO/src/communication/tcp/TCPServer.java
@ -1,40 +0,0 @@
 package communication.tcp;
 import java.io.IOException;
 import java.net.InetAddress;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.net.UnknownHostException;
 import observers.ObserverInputMessage;
 public class TCPServer extends Thread {
 	private ServerSocket sockListenTCP;
 	private ObserverInputMessage obs;
 	public TCPServer(int port) throws UnknownHostException, IOException {
 		this.sockListenTCP = new ServerSocket(port, 5, InetAddress.getLocalHost());
 	}
 	@Override
 	public void run() {
 		System.out.println("TCP running");
 		Socket sockAccept;
 		while(true) {
 			try {
 				sockAccept = this.sockListenTCP.accept();
 				this.obs.update(this, sockAccept);
 			} catch (IOException e) {
 				// TODO Auto-generated catch block
 				e.printStackTrace();
 			}
 		}
 	}
 	public void addObserver(ObserverInputMessage obs) {
 		this.obs = obs;
 	}
 }
--- a/POO/src/communication/udp/CommunicationUDP.java
+++ b/POO/src/communication/udp/CommunicationUDP.java
@ -1,206 +0,0 @@
 package communication.udp;
 import java.io.IOException;
 import java.net.InetAddress;
 import java.net.UnknownHostException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import main.Utilisateur;
 import standard.VueStandard;
 import messages.*;
 import observers.ObserverUserList;
 public class CommunicationUDP extends Thread {
 	// public enum Mode {PREMIERE_CONNEXION, CHANGEMENT_PSEUDO, DECONNEXION};
 	private UDPClient client;
 	private int portServer;
 	private ArrayList<Integer> portOthers;
 	private ArrayList<Utilisateur> users = new ArrayList<Utilisateur>();
 	private ObserverUserList observer;
 	public CommunicationUDP(int portClient, int portServer, int[] portsOther) throws IOException {
 		this.portServer = portServer;
 		this.portOthers = this.getArrayListFromArray(portsOther);
 		new UDPServer(portServer, this).start();
 		this.client = new UDPClient(portClient);
 	}
 	private ArrayList<Integer> getArrayListFromArray(int ports[]) {
 		ArrayList<Integer> tmp = new ArrayList<Integer>();
 		for (int port : ports) {
 			tmp.add(port);
 		}
 		tmp.remove(Integer.valueOf(portServer));
 		return tmp;
 	}
 	public void setObserver (ObserverUserList obs) {
 		this.observer=obs;
 	}
 	//-------------- USER LIST UPDATE FUNCTION --------------//
 	protected synchronized void addUser(String idClient, String pseudoClient, InetAddress ipClient, int port) throws IOException {
 		users.add(new Utilisateur(idClient, pseudoClient, ipClient, port));
 		observer.updateList(this, users);
 	}
 	protected synchronized void changePseudoUser(String idClient, String pseudoClient, InetAddress ipClient, int port) {
 		int index = getIndexFromID(idClient);
 		users.get(index).setPseudo(pseudoClient);
 		observer.updateList(this, users);
 	}
 	protected synchronized void removeUser(String idClient, String pseudoClient,InetAddress ipClient, int port) {
 		int index = getIndexFromIP(ipClient);
 		if( index != -1) {
 			users.remove(index);
 		}
 		observer.updateList(this, users);
 	}
 	public void removeAll(){
 		int oSize = users.size();
 		for(int i=0; i<oSize;i++) {
 			users.remove(0);
 		}
 	}
 	//-------------- CHECKERS --------------//
 	protected boolean containsUserFromID(String id) {
 		for(Utilisateur u : users) {
 			if(u.getId().equals(id) ) {
 				return true;
 			}
 		}
 		return false;
 	}
 	public boolean containsUserFromPseudo(String pseudo) {
 		for(Utilisateur u : users) {
 			if(u.getPseudo().toLowerCase().equals(pseudo) ) {
 				return true;
 			}
 		}
 		return false;
 	}
 	//-------------- GETTERS --------------//
 	public Utilisateur getUserFromPseudo(String pseudo) {
 		for(int i=0; i < users.size() ; i++) {
 			if(users.get(i).getPseudo().equals(pseudo) ) {
 				return users.get(i);
 			}
 		}
 		return null;
 	}
 	private int getIndexFromID(String id) {
 		for(int i=0; i < users.size() ; i++) {
 			if(users.get(i).getId().equals(id) ) {
 				return i;
 			}
 		}
 		return -1;
 	}
 	private int getIndexFromIP(InetAddress ip) {
 		for(int i=0; i < users.size() ; i++) {
 			if(users.get(i).getIp().equals(ip)) {
 				return i;
 			}
 		}
 		return -1;
 	}
 	public void sendMessageConnecte() throws UnknownHostException, IOException {
 		for(int port : this.portOthers) {
 			try {
 				this.client.sendMessageUDP_local(new MessageSysteme(Message.TypeMessage.JE_SUIS_CONNECTE), port, InetAddress.getLocalHost());
 			} catch (MauvaisTypeMessageException e) {/*Si ça marche pas essayer là*/}
 		}
 	}
 	// Send the message "add,id,pseudo" to localhost on all the ports in
 	// "portOthers"
 	// This allows the receivers' agent (portOthers) to create or modify an entry with the
 	// data of this agent
 	//Typically used to notify of a name change
 	public void sendMessageInfoPseudo() throws UnknownHostException, IOException {
 		Utilisateur self = Utilisateur.getSelf();
 		String pseudoSelf =self.getPseudo();
 		String idSelf = self.getId();
 		int portSelf = self.getPort();
 		Message msout = null;
 		try {
 			msout = new MessageSysteme(Message.TypeMessage.INFO_PSEUDO, pseudoSelf, idSelf, portSelf);
 			for(int port : this.portOthers) {
 				this.client.sendMessageUDP_local(msout, port, InetAddress.getLocalHost());
 			}
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 	}
 	//Same, but on only one port
 	//Typically used to give your current name and id to a newly arrived host
 	public void sendMessageInfoPseudo(int portOther) throws UnknownHostException, IOException {
 		Utilisateur self = Utilisateur.getSelf();
 		try {
 			Message msout = new MessageSysteme(Message.TypeMessage.INFO_PSEUDO, self.getPseudo(), self.getId(), self.getPort());
 			this.client.sendMessageUDP_local(msout, portOther, InetAddress.getLocalHost());
 		} catch (MauvaisTypeMessageException e) {e.printStackTrace();}
 	}
 	// Send the message "del,id,pseudo" to localhost on all the ports in
 	// "portOthers"
 	// This allows the receivers' agent (portOthers) to delete the entry
 	// corresponding to this agent
 	public void sendMessageDelete() throws UnknownHostException, IOException {
 		for(int port : this.portOthers) {
 			try {
 				this.client.sendMessageUDP_local(new MessageSysteme(Message.TypeMessage.JE_SUIS_DECONNECTE), port, InetAddress.getLocalHost());
 			} catch (MauvaisTypeMessageException e) {/*Si ça marche pas essayer là*/}
 		}
 	}
 	//Pas encore adapte message
 //	private void sendIDPseudo_broadcast(String prefixe) throws UnknownHostException, IOException {
 //		Utilisateur self = Utilisateur.getSelf();
 //		String idSelf = self.getId();
 //		String pseudoSelf = self.getPseudo();
 //
 //		String message = prefixe+","+idSelf + "," + pseudoSelf;
 //		
 //		
 //		this.client.sendMessageUDP_broadcast(message, this.portServer);
 //		
 //	}
 //	public synchronized void createSenderUDP(int port, Mode mode) throws SocketException {
 //		new SenderUDP(mode, port).start();
 //	}
 }
--- a/POO/src/communication/udp/UDPClient.java
+++ b/POO/src/communication/udp/UDPClient.java
@ -1,41 +0,0 @@
 package communication.udp;
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;
 import java.net.NetworkInterface;
 import java.net.SocketException;
 import java.net.UnknownHostException;
 import messages.*;
 public class UDPClient {
 	private DatagramSocket sockUDP;
 	private InetAddress broadcast;
 	public UDPClient(int port) throws SocketException, UnknownHostException {
 		this.sockUDP = new DatagramSocket(port);
 		InetAddress localHost = InetAddress.getLocalHost();
 		NetworkInterface networkInterface = NetworkInterface.getByInetAddress(localHost);
 		this.broadcast = networkInterface.getInterfaceAddresses().get(0).getBroadcast();
 	}
 	//Send a message casted as string to the specified port on localhost
 	protected void sendMessageUDP_local(Message message, int port, InetAddress clientAddress) throws IOException {
 		String messageString= message.toString();
 		DatagramPacket outpacket = new DatagramPacket(messageString.getBytes(), messageString.length(), clientAddress, port);
 		this.sockUDP.send(outpacket);
 	}
 //	protected void sendMessageUDP_broadcast(String message, int port) throws IOException{
 //		String messageString=message.toString();
 //		DatagramPacket outpacket = new DatagramPacket(messageString.getBytes(), messageString.length(), this.broadcast, port);
 //		this.sockUDP.send(outpacket);
 //	}
 }
--- a/POO/src/communication/udp/UDPServer.java
+++ b/POO/src/communication/udp/UDPServer.java
@ -1,71 +0,0 @@
 package communication.udp;
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.SocketException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import messages.*;
 public class UDPServer extends Thread {
 	private DatagramSocket sockUDP;
 	private CommunicationUDP commUDP;
 	private byte[] buffer;
 	public UDPServer(int port, CommunicationUDP commUDP) throws SocketException {
 		this.commUDP = commUDP;
 		this.sockUDP = new DatagramSocket(port);
 		this.buffer = new byte[256];
 	}
 	@Override
 	public void run() {
 		while (true) {
 			try {
 				DatagramPacket inPacket = new DatagramPacket(buffer, buffer.length);
 				this.sockUDP.receive(inPacket);
 				String msgString = new String(inPacket.getData(), 0, inPacket.getLength());
 				Message msg = Message.stringToMessage(msgString);
 				switch(msg.getTypeMessage()) {
 				case JE_SUIS_CONNECTE :	
 					//System.out.println("first co");
 					int portClient = inPacket.getPort();
 					int portServer = portClient+1;
 					this.commUDP.sendMessageInfoPseudo(portServer);
 					break;
 				case INFO_PSEUDO :
 					if (this.commUDP.containsUserFromID(((MessageSysteme) msg).getId())) {
 						this.commUDP.changePseudoUser(((MessageSysteme) msg).getId(), ((MessageSysteme) msg).getPseudo(), inPacket.getAddress(),((MessageSysteme) msg).getPort()); 
 					}
 					else {
 						this.commUDP.addUser(((MessageSysteme) msg).getId(), ((MessageSysteme) msg).getPseudo(), inPacket.getAddress(), ((MessageSysteme) msg).getPort() );
 						System.out.println(((MessageSysteme) msg).getId()+", "+((MessageSysteme) msg).getPseudo());
 					}
 					break;
 				case JE_SUIS_DECONNECTE :
 					this.commUDP.removeUser( ((MessageSysteme) msg).getId() , ((MessageSysteme) msg).getPseudo(), inPacket.getAddress(), inPacket.getPort());
 					break;
 				default : //Others types of messages are ignored because they are supposed to be transmitted by TCP and not UDP
 				}
 			} catch (IOException e) {
 				System.out.println("receive exception");
 			}
 		}
 	}
 }
--- a/POO/src/database/SQLiteCreateTables.java
+++ b/POO/src/database/SQLiteCreateTables.java
@ -1,73 +0,0 @@
 package database;
 import java.sql.Connection;
 import java.sql.SQLException;
 import java.sql.Statement;
 class SQLiteCreateTables {
 	protected static void createTableUser(Connection connec) throws SQLException {
 		String createTableUser = "CREATE TABLE IF NOT EXISTS user (\r\n"
 				+ "    id                     INTEGER       PRIMARY KEY AUTOINCREMENT,\r\n"
 				+ "    username               VARCHAR (50) NOT NULL\r\n"
 				+ "                                      UNIQUE ON CONFLICT ROLLBACK,\r\n"
 				+ "    pwd_salt               BLOB,\r\n"
 				+ "    db_datakey_salt        BLOB,\r\n"
 				+ "    encrypted_pwd_hashsalt BLOB,\r\n"
 				+ "    encrypted_db_datakey   BLOB,\r\n"
 				+ "    iv_datakey             BLOB\r\n"
 				+ ");";
 		Statement stmt = connec.createStatement();
 		stmt.execute(createTableUser);
 	}
 	protected static void createTableConversation(Connection connec) throws SQLException {
 		String createTableConversation = "CREATE TABLE IF NOT EXISTS conversation (\r\n"
 				+ "    id_conversation INTEGER PRIMARY KEY AUTOINCREMENT,\r\n"
 				+ "    id_emetteur     INTEGER REFERENCES user (id) \r\n" 
 				+ "                            NOT NULL,\r\n"
 				+ "    id_recepteur    INTEGER REFERENCES user (id) \r\n" 
 				+ "                            NOT NULL,\r\n"
 				+"     iv_conversation BLOB NOT NULL"
 				+ ");";
 		Statement stmt = connec.createStatement();
 		stmt.execute(createTableConversation);
 	}
 	protected static void createTableMessage(Connection connec) throws SQLException {
 		String createTableMessage = "CREATE TABLE IF NOT EXISTS message (\r\n"
 				+ "    id_message      INTEGER      PRIMARY KEY AUTOINCREMENT,\r\n"
 				+ "    id_conversation INTEGER      REFERENCES conversation (id_conversation) \r\n"
 				+ "                                 NOT NULL,\r\n"
 				+ "    id_type         INTEGER      REFERENCES type (id_type) \r\n"
 				+ "                                 NOT NULL,\r\n"
 				+ "    content         BLOB,\r\n"
 				+ "    date            INTEGER      NOT NULL,\r\n"
 				+ "    extension       VARCHAR (20) \r\n"
 				+ ");\r\n";
 		Statement stmt = connec.createStatement();
 		stmt.execute(createTableMessage);
 	}
 	protected static void createTableType(Connection connec) throws SQLException {
 		String createTableType = "CREATE TABLE IF NOT EXISTS type (\r\n" + "    id_type INTEGER      PRIMARY KEY,\r\n"
 				+ "    label VARCHAR (20) NOT NULL\r\n" + ");";
 		Statement stmt = connec.createStatement();
 		stmt.execute(createTableType);
 		String typeText = "INSERT OR IGNORE INTO type (id_type, label) " + "VALUES (0, 'text');";
 		String typeFile = "INSERT OR IGNORE INTO type (id_type, label) " + "VALUES (1, 'file');";
 		String typeImage = "INSERT OR IGNORE INTO type (id_type, label) " + "VALUES (2, 'image');";
 		stmt.execute(typeText);
 		stmt.execute(typeFile);
 		stmt.execute(typeImage);
 	}
 }
--- a/POO/src/database/SQLiteEncprytion.java
+++ b/POO/src/database/SQLiteEncprytion.java
@ -1,84 +0,0 @@
 package database;
 import java.util.Base64;
 import java.util.Random;
 import javax.crypto.*;
 import javax.crypto.spec.*;
 import java.security.*;
 import java.security.spec.*;
 class SQLiteEncprytion {
 	private static final Random RANDOM = new SecureRandom();
 	private static final int ITERATIONS = 10000;
 	private static final int KEY_LENGTH = 256;
 	protected static final String encryptAlgorithm = "AES/CBC/PKCS5Padding";
 	protected static byte[] getNextSalt() {
 		byte[] salt = new byte[24];
 		RANDOM.nextBytes(salt); 
 		return salt;
 	}
 	protected static byte[] hash(char[] password, byte[] salt) {
 		return SQLiteEncprytion.getKey(password, salt).getEncoded();
 	}
 	protected static SecretKey getKey(char[] password, byte[] salt) {
 		PBEKeySpec saltpwd = new PBEKeySpec(password, salt, ITERATIONS, KEY_LENGTH);
 		try {
 			SecretKeyFactory skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
 			SecretKey tmp = skf.generateSecret(saltpwd);
 			SecretKey key = new SecretKeySpec(tmp.getEncoded(), "AES");
 			return key;
 		} catch (InvalidKeySpecException | NoSuchAlgorithmException e) {
 			e.printStackTrace();
 		} finally {
 			saltpwd.clearPassword();
 		}
 		return null;
 	}
 	public static IvParameterSpec generateIv() {
 	    byte[] iv = new byte[16];
 	    new SecureRandom().nextBytes(iv);
 	    return new IvParameterSpec(iv);
 	}
 	protected static byte[] encrypt(String algorithm, byte[] input, SecretKey key, IvParameterSpec iv) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException{
 		Cipher cipher = Cipher.getInstance(algorithm);
 		cipher.init(Cipher.ENCRYPT_MODE, key, iv);
 		byte[] cipherText = cipher.doFinal(input);
 		return Base64.getEncoder().encode(cipherText);
 	}
 	protected static byte[] decryptByte(String algorithm, byte[] cipherText, SecretKey key, IvParameterSpec iv) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException{
 		Cipher cipher = Cipher.getInstance(algorithm);
 		cipher.init(Cipher.DECRYPT_MODE, key, iv);
 		byte[] plainText = cipher.doFinal(Base64.getDecoder().decode(cipherText));
 		return plainText;
 	}
 	protected static String decryptString(String algorithm, byte[] cipherText, SecretKey key, IvParameterSpec iv) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
 		return new String(SQLiteEncprytion.decryptByte(algorithm, cipherText, key, iv) );
 	}
 	public static byte[] keyToByte(SecretKey key) {
 		return Base64.getEncoder().encode(key.getEncoded());
 	}
 	public static SecretKey byteToKey(byte[] encodedKey) {
 		byte[] decodedKey = Base64.getDecoder().decode(encodedKey);
 		return new SecretKeySpec(decodedKey, 0, decodedKey.length, "AES");
 	}
 }
--- a/POO/src/database/SQLiteManager.java
+++ b/POO/src/database/SQLiteManager.java
@ -1,559 +0,0 @@
 package database;
 import java.io.File;
 import java.security.InvalidAlgorithmParameterException;
 import java.security.InvalidKeyException;
 import java.security.NoSuchAlgorithmException;
 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import javax.crypto.BadPaddingException;
 import javax.crypto.IllegalBlockSizeException;
 import javax.crypto.KeyGenerator;
 import javax.crypto.NoSuchPaddingException;
 import javax.crypto.SecretKey;
 import javax.crypto.spec.IvParameterSpec;
 import main.Utilisateur;
 import messages.MauvaisTypeMessageException;
 import messages.Message;
 import messages.MessageTexte;
 import messages.Message.TypeMessage;
 import messages.MessageFichier;
 public class SQLiteManager {
 	private static final String DATABASE_RELATIVE_PATH = "../database";
 	private Connection connec;
 	private int numDatabase;
 	private SecretKey dbDataKey;
 	public SQLiteManager(int numDatabase) {
 		this.numDatabase = numDatabase;
 		this.openConnection();
 		try {
 			SQLiteCreateTables.createTableUser(this.connec);
 			SQLiteCreateTables.createTableConversation(this.connec);
 			SQLiteCreateTables.createTableType(this.connec);
 			SQLiteCreateTables.createTableMessage(this.connec);
 		} catch (SQLException e) {
 			this.closeConnection();
 			File db = new File("../database"+this.numDatabase+".db");
 			if(db.delete()) {
 				System.out.println("supp");
 			}else {
 				System.out.println("no supp");
 			}
 			e.printStackTrace();
 		}
 		this.closeConnection();
 	}
 	private void openConnection() {
 		String url = "jdbc:sqlite:"+ DATABASE_RELATIVE_PATH + this.numDatabase + ".db";
 		try {
 			this.connec = DriverManager.getConnection(url);
 //			System.out.println("Connection to bdd established");
 		} catch (SQLException e) {
 			System.out.println(e.getMessage());
 		}
 	}
 	private void closeConnection() {
 		try {
 			if (this.connec != null) {
 				this.connec.close();
 			}
 		} catch (SQLException e) {
 			System.out.println(e.getMessage());
 		}
 	}
 	public int insertAllMessages(ArrayList<Message> messages, String usernameSender, String usernameReceiver) throws SQLException{
 		int nbRows = 0;
 		this.openConnection();
 		int idSender = this.getIDUser(usernameSender);
 		int idReceiver = this.getIDUser(usernameReceiver);
 		if(idSender == -1) {
 			this.insertUser(usernameSender);
 			idSender = this.getIDUser(usernameSender);
 		}
 		if(idReceiver == -1) {
 			this.insertUser(usernameReceiver);
 			idReceiver = this.getIDUser(usernameReceiver);		
 		}
 		int idConversation = getIDConversation(idSender, idReceiver);
 		if(idConversation == -1) {
 			this.insertConversation(idSender, idReceiver);
 			idConversation = getIDConversation(idSender, idReceiver);
 		}
 		IvParameterSpec ivConversation = this.getIvConversation(idConversation);
 		this.connec.setAutoCommit(false);
 		for(Message m : messages) {
 			try {
 				nbRows += this.insertMessage(idConversation, m, ivConversation);
 			} catch (SQLException e) {
 				e.printStackTrace();
 				this.connec.rollback();
 			}
 		}
 		this.connec.commit();
 		this.closeConnection();
 		//System.out.println("Nombre de message(s) insérée(s) : " + nbRows);
 		return nbRows;
 	}
 	public ArrayList<Message> getHistoriquesMessages(String usernameOther, String pseudoOther) throws SQLException {
 		this.openConnection();
 		ArrayList<Message> messages = new ArrayList<Message>();
 		String usernameSelf = Utilisateur.getSelf().getId();
 		int idSelf = this.getIDUser(usernameSelf);
 		int idOther = this.getIDUser(usernameOther);
 		int idConversationSelf = this.getIDConversation(idSelf, idOther);
 		int idConversationOther = this.getIDConversation(idOther, idSelf);
 		IvParameterSpec ivConversation = this.getIvConversation(idConversationSelf);
 //		String str = "datetime(d1,'unixepoch','localtime')";
 		String getHistoriqueRequest = "SELECT id_conversation, id_type, content, date, extension "
 									+ "FROM message "
 									+ "WHERE id_conversation IN (?,?) "
 									+ "ORDER by date";
 		PreparedStatement prepStmt = this.connec.prepareStatement(getHistoriqueRequest);
 		prepStmt.setInt(1, idConversationSelf);
 		prepStmt.setInt(2, idConversationOther);
 		ResultSet res = prepStmt.executeQuery();
 		//Retrieve the messages one by one
 		//Create the appropriate message object depending on the type and sender/receiver
 		//and add the message in the list
 		while(res.next()) {
 			int idType = res.getInt("id_type");
 			String type = this.getType(idType);
 			String content = null;
 			try {
 				content = this.bytesToStringContent(res.getBytes("content"), ivConversation);
 			} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
 					| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException
 					| SQLException e1) {
 				//System.out.println("erreur déchiffrement");
 			}
 			Message message = null;
 			String extension;
 			if(!type.equals("")) {
 				try {
 					switch(type) {
 						case "text": 
 							message = new MessageTexte(TypeMessage.TEXTE, content);
 							break;
 						case "file": 
 							extension = res.getString("extension");
 							message = new MessageFichier(TypeMessage.FICHIER, content, extension);
 							break;
 						default:
 							extension = res.getString("extension");
 							message = new MessageFichier(TypeMessage.IMAGE, content, extension);	
 					}	 
 				} catch (MauvaisTypeMessageException e) {
 					e.printStackTrace();
 				}
 			}
 			if(res.getInt("id_conversation") == idConversationSelf) {
 				message.setSender("Moi");
 			}else{
 				message.setSender(pseudoOther);
 			}
 			message.setDateMessage(res.getString("date"));	
 			if(content != null) {
 				messages.add(message);
 			}
 		}
 		this.closeConnection();
 		return messages;
 	}
 	private void insertUser(String username) throws SQLException {
 		String insertUserRequest = "INSERT INTO user (username) " + "VALUES (?);";
 		PreparedStatement prepStmt = this.connec.prepareStatement(insertUserRequest);
 		prepStmt.setString(1, username);
 		prepStmt.executeUpdate();
 	}
 	private int getIDUser(String username) throws SQLException {
 		String getIDRequest = "SELECT id " + " FROM user" + " WHERE username = ? ;";
 		PreparedStatement prepStmt = this.connec.prepareStatement(getIDRequest);
 		prepStmt.setString(1, username);
 		ResultSet res = prepStmt.executeQuery();
 		if (res.next()) {
 			return res.getInt("id");
 		}
 		return -1;
 	}
 	private void insertConversation(int idSender, int idReceiver) throws SQLException {
 		String insertConversationRequest = "INSERT INTO conversation (id_emetteur, id_recepteur, iv_conversation) " + "VALUES "
 				+ "(?, ?, ?),"
 				+ "(?, ?, ?);";
 		byte[] ivConversation = SQLiteEncprytion.generateIv().getIV();
 		PreparedStatement prepStmt = this.connec.prepareStatement(insertConversationRequest);
 		prepStmt.setInt(1, idSender);
 		prepStmt.setInt(2, idReceiver);
 		prepStmt.setBytes(3, ivConversation);
 		prepStmt.setInt(4, idReceiver);
 		prepStmt.setInt(5, idSender);
 		prepStmt.setBytes(6, ivConversation);
 		prepStmt.executeUpdate();
 	}
 	private int getIDConversation(int idSender, int idReceiver) throws SQLException {
 		String getIDRequest = "SELECT id_conversation " + "FROM conversation " + "WHERE id_emetteur = ? "
 				+ "AND id_recepteur = ? ;";
 		PreparedStatement prepStmt = this.connec.prepareStatement(getIDRequest);
 		prepStmt.setInt(1, idSender);
 		prepStmt.setInt(2, idReceiver);
 		ResultSet res = prepStmt.executeQuery();
 		if (res.next()) {
 			return res.getInt("id_conversation");
 		}
 		return -1;
 	}
 	private IvParameterSpec getIvConversation(int idConversation) throws SQLException {
 		String getIvRequest = "SELECT iv_conversation " + "FROM conversation " + "WHERE id_conversation = ?;";
 		PreparedStatement prepStmt = this.connec.prepareStatement(getIvRequest);
 		prepStmt.setInt(1, idConversation);
 		ResultSet res = prepStmt.executeQuery();
 		if (res.next()) {
 			return new IvParameterSpec(res.getBytes("iv_conversation"));
 		}
 		return null;
 	}
 	private int getIDType(String label) throws SQLException {
 		String getIDRequest = "SELECT id_type FROM type WHERE label = ?;";
 		PreparedStatement prepStmt = this.connec.prepareStatement(getIDRequest);
 		prepStmt.setString(1, label);
 		ResultSet res = prepStmt.executeQuery();
 		if (res.next()) {
 			return res.getInt("id_type");
 		}
 		return -1;
 	}
 	private String getType(int idType) throws SQLException {
 		String getTypeRequest = "SELECT label FROM type WHERE id_type = ?;";
 		PreparedStatement prepStmt = this.connec.prepareStatement(getTypeRequest);
 		prepStmt.setInt(1, idType);
 		ResultSet res = prepStmt.executeQuery();
 		if(res.next()) {
 			return res.getString("label");
 		}
 		return "";
 	}
 	private byte[] stringToBytesContent(Message m, IvParameterSpec iv) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
 		String content;
 		if (m.getTypeMessage() == TypeMessage.TEXTE) {
 			MessageTexte messageTxt = (MessageTexte) m;
 			content = messageTxt.getContenu();
 		}else {
 			MessageFichier messageFichier = (MessageFichier) m;
 			content = messageFichier.getContenu();
 		}
 		byte[] encryptedContent = SQLiteEncprytion.encrypt(SQLiteEncprytion.encryptAlgorithm, content.getBytes(), this.dbDataKey, iv);
 		return encryptedContent;
 	}
 	private String bytesToStringContent(byte[] encryptedContent, IvParameterSpec iv) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
 		return SQLiteEncprytion.decryptString(SQLiteEncprytion.encryptAlgorithm, encryptedContent, this.dbDataKey, iv);
 	}
 	private String processMessageType(Message m) {
 		switch (m.getTypeMessage()) {
 		case TEXTE: return "text";
 		case FICHIER: return "file";			
 		case IMAGE: return "image";
 		default: return "";
 		}
 	}
 	private String processExtension(Message m) {
 		if(m.getTypeMessage() == TypeMessage.TEXTE) {
 			return null;
 		}else {
 			MessageFichier mFile = (MessageFichier) m;
 			return mFile.getExtension();
 		}
 	}
 	private int insertMessage(int idConversation, Message m, IvParameterSpec iv) throws SQLException {
 			String dateMessage = m.getDateMessage();
 			String extension = this.processExtension(m);
 			String type = this.processMessageType(m);
 			int idType = this.getIDType(type);
 			byte[] content = null;
 			try {
 				content = this.stringToBytesContent(m, iv);
 			} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
 					| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
 				e.printStackTrace();
 			}
 			String insertMessageRequest = "INSERT INTO message(id_conversation, id_type, content, date, extension) "
 					+ "VALUES (?, ?, ?, ?, ?);";
 			PreparedStatement prepStmt = this.connec.prepareStatement(insertMessageRequest);
 			prepStmt.setInt(1, idConversation);
 			prepStmt.setInt(2, idType);
 			prepStmt.setBytes(3, content);
 			prepStmt.setString(4, dateMessage);
 			prepStmt.setString(5, extension);
 			int nbRows = prepStmt.executeUpdate();
 		return nbRows;
 	}
 	public void createNewUserEncrypt(String username, String password) {
 		String algo = SQLiteEncprytion.encryptAlgorithm;
 		KeyGenerator keyGen = null;
 		try {
 			keyGen = KeyGenerator.getInstance("AES");
 			keyGen.init(256);
 		} catch (NoSuchAlgorithmException e) {
 			e.printStackTrace();
 		}
 		byte[] passwordSalt = SQLiteEncprytion.getNextSalt();
 		byte[] dbDataKeySalt = SQLiteEncprytion.getNextSalt();
 		SecretKey dbDataKey = keyGen.generateKey(); 
 		SecretKey dbDataEncryptKey = SQLiteEncprytion.getKey(password.toCharArray(), dbDataKeySalt);
 		IvParameterSpec ivDbDataKey = SQLiteEncprytion.generateIv();
 		byte[] passwordHash = SQLiteEncprytion.hash(password.toCharArray(), passwordSalt);
 		byte[] dbDataKeyEncrypted = null;
 		byte[] encryptedPasswordHash = null;
 		try {
 			dbDataKeyEncrypted = SQLiteEncprytion.encrypt(
 					algo, SQLiteEncprytion.keyToByte(dbDataKey), dbDataEncryptKey, ivDbDataKey);
 			encryptedPasswordHash = SQLiteEncprytion.encrypt(
 					algo, passwordHash , dbDataKey, ivDbDataKey);
 		} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
 				| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 		this.openConnection();
 		String createUserRequest = "INSERT INTO user(username, pwd_salt, db_datakey_salt, encrypted_pwd_hashsalt, encrypted_db_datakey, iv_datakey) "
 				+ "VALUES (?, ?, ?, ?, ?, ?); ";
 		PreparedStatement prepStmt = null;
 		try {
 			prepStmt = this.connec.prepareStatement(createUserRequest);
 			prepStmt.setString(1, username);
 			prepStmt.setBytes(2, passwordSalt);
 			prepStmt.setBytes(3, dbDataKeySalt);
 			prepStmt.setBytes(4, encryptedPasswordHash);
 			prepStmt.setBytes(5, dbDataKeyEncrypted);
 			prepStmt.setBytes(6, ivDbDataKey.getIV());
 		} catch (SQLException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 		try {
 			prepStmt.executeUpdate();
 		} catch (SQLException e) {
 			System.out.println("Nom d'utilisateur déjà pris");
 		}
 		this.closeConnection();
 	}
 	public int checkPwd(String username, char[] password) throws SQLException {
 		this.openConnection();
 		String selectUserDataRequest = "SELECT pwd_salt, db_datakey_salt, encrypted_pwd_hashsalt, encrypted_db_datakey, iv_datakey "
 									+ "FROM user "
 									+ "WHERE username = ?;";
 		PreparedStatement prepStmt;
 		prepStmt = this.connec.prepareStatement(selectUserDataRequest);
 		prepStmt.setString(1, username);
 		ResultSet res = prepStmt.executeQuery();
 		if(!res.next()) {
 			return -1;
 		}
 		byte[] passwordSalt = res.getBytes("pwd_salt");
 		byte[] dbDataKeySalt = res.getBytes("db_datakey_salt");
 		SecretKey dbDataEncryptKey = SQLiteEncprytion.getKey(password, dbDataKeySalt);
 		IvParameterSpec iv = new IvParameterSpec(res.getBytes("iv_datakey"));
 		byte[] encryptedDbDataKey = res.getBytes("encrypted_db_datakey");
 		SecretKey dbDataKey = null;
 		try {
 			 dbDataKey = SQLiteEncprytion.byteToKey(
 					SQLiteEncprytion.decryptByte(SQLiteEncprytion.encryptAlgorithm, encryptedDbDataKey, dbDataEncryptKey, iv)
 					);
 		} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
 				| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
 			//System.out.println("Problème déchiffrement clé db");
 		}
 		this.dbDataKey = dbDataKey;
 		byte[] encryptedPasswordHash = res.getBytes("encrypted_pwd_hashsalt");
 		byte[] passwordHash = SQLiteEncprytion.hash(password, passwordSalt);
 		this.closeConnection();
 		boolean checkHash = this.checkHashPwd(passwordHash ,encryptedPasswordHash, dbDataKey, iv);
 		if(checkHash) {
 			return 1;
 		}
 		return 0;	
 	}
 	private boolean checkHashPwd(byte[] passwordHash, byte[] encryptedPasswordHash, SecretKey dbDataKey, IvParameterSpec iv) {
 		byte[] expectedHash = null;
 		try {
 			expectedHash = SQLiteEncprytion.decryptByte(SQLiteEncprytion.encryptAlgorithm, encryptedPasswordHash, dbDataKey, iv);
 		} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
 				| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 		if (passwordHash.length != expectedHash.length) return false;
 	    for (int i = 0; i < passwordHash.length; i++) {
 	      if (passwordHash[i] != expectedHash[i]) return false;
 	    }
 	    return true;
 	}
 	public static void main(String[] args) {
 		String username = "Mirasio" ;
 		String password = "12345" ;
 		SQLiteManager sqlManager = new SQLiteManager(1);
 		sqlManager.createNewUserEncrypt(username, password);
 		try {
 			int returnVal = sqlManager.checkPwd(username, password.toCharArray());
 			if(returnVal == -1) {
 				System.out.println("utilisateur inexistant");
 			}else if(returnVal == 0) {
 				System.out.println("mot de passe incorrect");
 			}else {
 				System.out.println("mot de passe correct");
 			}
 		} catch (SQLException e) {
 			System.out.println("erreur recherche utilisateur");
 			e.printStackTrace();
 		}
 	}
 }
--- a/POO/src/main/Main.java
+++ b/POO/src/main/Main.java
@ -1,70 +0,0 @@
 package main;
 import java.io.IOException;
 import java.sql.SQLException;
 import database.SQLiteManager;
 import standard.VueStandard;
 import javax.swing.UIManager;
 import javax.swing.UIManager.*;
 public class Main {
 	private static int portServersUDP[] = {1526,1501,1551,1561};
 	private static String ids[] = {"Raijila", "titi33", "Semtexx", "Salam"};
 	private static String pseudo[] = {"Raijila", "Mirasio", "Semtexx", "Xaegon"};
 	private static String pwd[] = {"azertyuiop","12345","abcde","toto"};
 	private static int portServersTCP[] = {1625,1600,1650,1660};
 	public static void main(String[] args) {
 		try {
 		    for (LookAndFeelInfo info : UIManager.getInstalledLookAndFeels()) {
 		        if ("Nimbus".equals(info.getName())) {
 		            UIManager.setLookAndFeel(info.getClassName());
 		            break;
 		        }
 		    }
 		} catch (Exception e) {
 		    // If Nimbus is not available, you can set the GUI to another look and feel.
 		}
 		switch(args[0]) {
 		case "0": 
 			Main.createApp(0);
 			break;
 		case "1":
 			Main.createApp(1);
 			break;
 		case "2":
 			Main.createApp(2);
 			break;
 		default:
 			Main.createApp(3);
 		}
 	}
 	private static void createApp(int i) {
 		try {
 			Utilisateur.setSelf(Main.ids[i], Main.pseudo[i], "localhost", Main.portServersTCP[i]);
 			SQLiteManager sqlManager = new SQLiteManager(i);
 			try {
 				sqlManager.createNewUserEncrypt(Main.ids[i], Main.pwd[i]);
 				sqlManager.checkPwd(Main.ids[i], Main.pwd[i].toCharArray());
 			} catch (SQLException e) {
 				System.out.println("erreur recherche utilisateur");
 				e.printStackTrace();
 			}
 			new VueStandard("Application", Main.portServersUDP[i]-1, Main.portServersUDP[i], Main.portServersUDP, Main.portServersTCP[i], sqlManager);	
 		} catch (IOException e) {
 			System.out.println(e.toString());	
 		}
 	}
 }
--- a/POO/src/main/Utilisateur.java
+++ b/POO/src/main/Utilisateur.java
@ -1,57 +0,0 @@
 package main;
 import java.io.Serializable;
 import java.net.*;
 public class Utilisateur implements Serializable{
 	/**
 	 * 
 	 */
 	private static final long serialVersionUID = 1L;
 	private String id;
 	private String pseudo;
 	private InetAddress ip;
 	private int port;
 	private static Utilisateur self;
 	public Utilisateur(String id, String pseudo, InetAddress ip, int port) throws UnknownHostException {
 		this.id = id;
 		this.pseudo = pseudo;
 		this.ip = ip;
 		this.port = port;
 		System.out.println(InetAddress.getLocalHost());
 	}
 	public String getId() {
 		return id;
 	}
 	public String getPseudo() {
 		return pseudo;
 	}
 	public void setPseudo(String pseudo) {
 		this.pseudo = pseudo;
 	}
 	public InetAddress getIp() {
 		return ip;
 	}
 	public int getPort() {
 		return port;
 	}
 	public static void setSelf(String id, String pseudo, String host, int port) throws UnknownHostException {
 		if(Utilisateur.self == null) {
 			Utilisateur.self = new Utilisateur(id, pseudo, InetAddress.getByName(host), port);
 		}
 	}
 	public static Utilisateur getSelf() {
 		return Utilisateur.self;
 	}
 }
--- a/POO/src/main/Vue.java
+++ b/POO/src/main/Vue.java
@ -1,16 +0,0 @@
 package main;
 import javax.swing.JFrame;
 public class Vue extends JFrame{
 	public Vue(String title) {
 		super(title);
 		this.setDefaultCloseOperation(EXIT_ON_CLOSE);
 	}
 	public void reduireAgent() {}
 	public void fermerAgent() {}
 }
--- a/POO/src/messages/MauvaisTypeMessageException.java
+++ b/POO/src/messages/MauvaisTypeMessageException.java
@ -1,8 +0,0 @@
 package messages;
 public class MauvaisTypeMessageException extends Exception {
 	private static final long serialVersionUID = 1L;
 }
--- a/POO/src/messages/Message.java
+++ b/POO/src/messages/Message.java
@ -1,99 +0,0 @@
 package messages;
 import java.io.Serializable;
 import java.lang.instrument.Instrumentation;
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.Arrays;
 import messages.Message.TypeMessage;
 public abstract class Message implements Serializable {
 	public enum TypeMessage {JE_SUIS_CONNECTE, JE_SUIS_DECONNECTE, INFO_PSEUDO, TEXTE, IMAGE, FICHIER, MESSAGE_NUL, FICHIER_INIT, FICHIER_ANSWER}
 	protected TypeMessage type;
 	private String dateMessage;
 	private String sender;
 	private static final long serialVersionUID = 1L;
 	private static Instrumentation inst;
 	public static String getDateAndTime() {
 		DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
 		LocalDateTime now = LocalDateTime.now();
 		return dtf.format(now);
 	}
 	public TypeMessage getTypeMessage() {
 		return this.type;
 	}
 	public void setDateMessage(String dateMessage) {
 		this.dateMessage = dateMessage;
 	}
 	public String getDateMessage() {
 		return this.dateMessage;
 	}
 	public String getSender() {
 		return this.sender ;
 	}
 	public void setSender(String sender) {
 		this.sender = sender;
 	}
 	protected abstract String attributsToString();
 	public String toString() {
 		return this.type+"###"+this.attributsToString();
 	}	
 	public static Message stringToMessage(String messageString) {
 		try {
 			String[] parts = messageString.split("###");
 			switch (parts[0]) {
 			case "JE_SUIS_CONNECTE" :
 				return new MessageSysteme(TypeMessage.JE_SUIS_CONNECTE);
 			case "JE_SUIS_DECONNECTE" :
 				return new MessageSysteme(TypeMessage.JE_SUIS_DECONNECTE);
 			case "INFO_PSEUDO" :
 				return new MessageSysteme(TypeMessage.INFO_PSEUDO, parts[1], parts[2], Integer.parseInt(parts[3]) );
 			case "TEXTE" :
 				return new MessageTexte(TypeMessage.TEXTE, parts[1]);
 			case "IMAGE" :
 				return new MessageFichier(TypeMessage.IMAGE, parts[1], parts[2]);
 			case "FICHIER" :
 				return new MessageFichier(TypeMessage.FICHIER, parts[1], parts[2]);
 			}
 		} catch (MauvaisTypeMessageException e) {}
 			return null;
 	}
 	//tests ici
 	public static void main(String[] args) throws MauvaisTypeMessageException {		
 		Message m1 = new MessageSysteme(TypeMessage.JE_SUIS_CONNECTE);
 		Message m2 = new MessageSysteme(TypeMessage.JE_SUIS_DECONNECTE);
 		Message m3 = new MessageSysteme(TypeMessage.INFO_PSEUDO, "pseudo156434518", "id236", 1500);
 		Message m4 = new MessageTexte(TypeMessage.TEXTE, "blablabla");
 		Message m5 = new MessageFichier(TypeMessage.FICHIER, "truc", ".pdf");
 		System.out.println(Message.stringToMessage(m1.toString()));
 		System.out.println(Message.stringToMessage(m2.toString()));
 		System.out.println(Message.stringToMessage(m3.toString()));
 		System.out.println(Message.stringToMessage(m4.toString()));
 		System.out.println(Message.stringToMessage(m5.toString()));
 	}
 }
--- a/POO/src/messages/MessageFichier.java
+++ b/POO/src/messages/MessageFichier.java
@ -1,48 +0,0 @@
 package messages;
 import main.Utilisateur;
 public class MessageFichier extends Message {
 	private static final long serialVersionUID = 1L;
 	private String contenu;
 	private String extension;
 	public MessageFichier(TypeMessage type, String contenu, String extension) throws MauvaisTypeMessageException{
 		if ((type==TypeMessage.IMAGE)||(type==TypeMessage.FICHIER) ||(type==TypeMessage.FICHIER_INIT) || (type==TypeMessage.FICHIER_ANSWER) ) {
 			this.type=type;
 			this.contenu=contenu;
 			this.extension=extension;
 			this.setDateMessage(Message.getDateAndTime());
 		}
 		else throw new MauvaisTypeMessageException();
 	}
 	public String getContenu() {
 		return this.contenu;
 	}
 	public String getExtension() {
 		return this.extension;
 	}
 	@Override
 	protected String attributsToString() {
 		return this.contenu+"###"+this.extension;
 	}
 	public String toString() {
 		if(this.type == TypeMessage.IMAGE) {
 			return this.contenu;
 		}else {
 			String suffixe;
 			if(this.getSender().equals("Moi")) {
 				suffixe = "envoyé\n";
 			}else {
 				suffixe = "reçu\n";
 			}
 			return "<"+this.getDateMessage()+"> : "+this.contenu+" "+suffixe;
 		}
 	}
 }
--- a/POO/src/messages/MessageSysteme.java
+++ b/POO/src/messages/MessageSysteme.java
@ -1,46 +0,0 @@
 package messages;
 public class MessageSysteme extends Message {
 	private static final long serialVersionUID = 1L;
 	private String pseudo;
 	private String id;
 	private int port;
 	public MessageSysteme(TypeMessage type) throws MauvaisTypeMessageException{
 		if ((type==TypeMessage.JE_SUIS_CONNECTE)||(type==TypeMessage.JE_SUIS_DECONNECTE)||(type==TypeMessage.MESSAGE_NUL)) {
 			this.type=type;
 			this.pseudo="";
 			this.id="";
 			this.port = -1;
 		}
 		else throw new MauvaisTypeMessageException();
 	}
 	public MessageSysteme(TypeMessage type, String pseudo, String id, int port) throws MauvaisTypeMessageException {
 		if (type==TypeMessage.INFO_PSEUDO) {
 			this.type=type;
 			this.pseudo=pseudo;
 			this.id=id;
 			this.port = port;
 		}
 		else throw new MauvaisTypeMessageException();
 	}
 	public String getPseudo() {
 		return this.pseudo;
 	}
 	public String getId() {
 		return this.id;
 	}
 	public int getPort() {
 		return this.port;
 	}
 	@Override
 	protected String attributsToString() {
 		return this.pseudo+"###"+this.id+"###"+this.port;
 	}
 }
--- a/POO/src/messages/MessageTexte.java
+++ b/POO/src/messages/MessageTexte.java
@ -1,34 +0,0 @@
 package messages;
 public class MessageTexte extends Message {
 	private static final long serialVersionUID = 1L;
 	private String contenu;
 	public MessageTexte(TypeMessage type, String contenu) throws MauvaisTypeMessageException{
 		if (type==TypeMessage.TEXTE) {
 			this.type=type;
 			this.contenu=contenu;
 			this.setDateMessage(Message.getDateAndTime());
 		}
 		else throw new MauvaisTypeMessageException();
 	}
 	public String getContenu() {
 		return this.contenu;
 	}
 	@Override
 	protected String attributsToString() {
 		return this.contenu;
 	}
 	@Override
 	public String toString() {
 		return "<"+this.getDateMessage()+"> "+this.getSender()+" : "+this.contenu+"\n";
 	}
 }
--- a/POO/src/observers/ObserverInputMessage.java
+++ b/POO/src/observers/ObserverInputMessage.java
@ -1,5 +0,0 @@
 package observers;
 public interface ObserverInputMessage {
 	public void update(Object o, Object arg);
 }
--- a/POO/src/observers/ObserverSocketState.java
+++ b/POO/src/observers/ObserverSocketState.java
@ -1,9 +0,0 @@
 package observers;
 import java.net.Socket;
 public interface ObserverSocketState {
 	public void updateSocketState(Object o, Object arg);
 }
--- a/POO/src/observers/ObserverUserList.java
+++ b/POO/src/observers/ObserverUserList.java
@ -1,11 +0,0 @@
 package observers;
 import java.util.ArrayList;
 import main.Utilisateur;
 public interface ObserverUserList {
 	public void updateList(Object o, ArrayList<Utilisateur> userList);
 }
--- a/POO/src/session/ControleurSession.java
+++ b/POO/src/session/ControleurSession.java
@ -1,276 +0,0 @@
 package session;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.event.KeyEvent;
 import java.awt.event.KeyListener;
 import java.io.File;
 import java.io.IOException;
 import java.net.Socket;
 import java.sql.SQLException;
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.ArrayList;
 import java.util.Collections;
 import javax.swing.JButton;
 import javax.swing.JFileChooser;
 import communication.filetransfer.FileTransferClient;
 import communication.filetransfer.FileTransferServer;
 import communication.tcp.TCPClient;
 import database.SQLiteManager;
 import main.Utilisateur;
 import messages.MauvaisTypeMessageException;
 import messages.Message;
 import messages.MessageFichier;
 import messages.MessageTexte;
 import messages.Message.TypeMessage;
 import observers.ObserverInputMessage;
 import observers.ObserverSocketState;
 public class ControleurSession implements ActionListener, ObserverInputMessage, ObserverSocketState, KeyListener {
 	private VueSession vue;
 	private String idOther;
 	private String pseudoOther;
 	private TCPClient tcpClient;
 	private ArrayList<Message> messagesIn;
 	private ArrayList<Message> messagesOut;
 	private SQLiteManager sqlManager;
 	private ArrayList<File> files;
 	protected ControleurSession(VueSession vue, Socket socketComm, String idOther, String pseudoOther, SQLiteManager sqlManager) throws IOException {
 		this.vue = vue;
 		this.tcpClient = new TCPClient(socketComm);
 		this.tcpClient.setObserverInputThread(this);
 		this.tcpClient.setObserverSocketState(this);
 		this.tcpClient.startInputThread();
 		this.messagesIn = new ArrayList<Message>();
 		this.messagesOut = new ArrayList<Message>();
 		this.idOther = idOther;
 		this.pseudoOther = pseudoOther;
 		this.sqlManager = sqlManager;
 		this.files = new ArrayList<File>();
 	}
 	// ---------- ACTION LISTENER OPERATIONS ----------//
 	@Override
 	public void actionPerformed(ActionEvent e) {
 		//Quand le bouton envoyer est presse
 		if ((JButton) e.getSource() == this.vue.getButtonEnvoyer()) {
 			String messageContent = this.vue.getInputedText();
 			System.out.println(messageContent);
 			if(!this.files.isEmpty()) {
 				this.processSelectedFiles(messageContent);
 				if(!this.files.isEmpty()) {
 					this.askFileTransfer();
 					this.vue.resetZoneSaisie();
 					messageContent = "";
 				}
 			}
 			//If the text field is not empty
 			if (!messageContent.equals("")) {
 				//Retrieve the date and prepare the messages to send/display
 				MessageTexte messageOut = null;
 				try {
 					messageOut = new MessageTexte(TypeMessage.TEXTE, messageContent);
 					messageOut.setSender(Utilisateur.getSelf().getPseudo());
 				} catch (MauvaisTypeMessageException e2) {
 					e2.printStackTrace();
 				}
 				try {
 					this.tcpClient.sendMessage(messageOut);	
 				} catch (MauvaisTypeMessageException | IOException e1) {
 					// TODO Auto-generated catch block
 					e1.printStackTrace();
 				}
 				messageOut.setSender("Moi");
 				this.vue.appendMessage(messageOut);
 				this.vue.resetZoneSaisie();
 				this.messagesOut.add(messageOut);
 			}
 		}
 		if((JButton) e.getSource() == this.vue.getButtonImportFile()) {
 			JFileChooser fc = new JFileChooser();
 			fc.setMultiSelectionEnabled(true);
 			int returVal = fc.showDialog(this.vue, "Importer");
 			if(returVal == JFileChooser.APPROVE_OPTION) {
 				File[] files = fc.getSelectedFiles();
 				Collections.addAll(this.files, files);
 				for(File file : files) {
 					this.vue.appendInputedText(file.getName());
 					this.vue.appendInputedText(";");
 				}
 			}
 		}
 	}
 	@Override
 	public void keyTyped(KeyEvent e) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void keyPressed(KeyEvent e) {
 		if(e.getKeyCode() == KeyEvent.VK_ENTER) {
 			if(!e.isShiftDown()) {
 				this.vue.getButtonEnvoyer().doClick();
 			}
 		}	
 	}
 	@Override
 	public void keyReleased(KeyEvent e) {
 		// TODO Auto-generated method stub
 	}
 	protected ArrayList<Message> getHistorique(){
 		try {
 			ArrayList<Message> historique = this.sqlManager.getHistoriquesMessages(idOther, pseudoOther);
 			return historique;
 		} catch (SQLException e) {
 			e.printStackTrace();
 			return new ArrayList<Message>();
 		}
 	}
 	private void processSelectedFiles(String input) {
 			int nbFile = this.files.size();
 			String[] tmp = input.split(";");
 			ArrayList<String> potentialFiles = new ArrayList<String>();
 			Collections.addAll(potentialFiles, tmp);
 			for(File file: this.files) {
 				if(!potentialFiles.contains(file.getName()) ) {
 					this.files.remove(file);
 				}
 			}
 	}
 	private void askFileTransfer() {
 		try {
 			MessageFichier messageOut = new MessageFichier(TypeMessage.FICHIER_INIT, ""+this.files.size(), "");
 			this.tcpClient.sendMessage(messageOut);
 		} catch (MauvaisTypeMessageException | IOException e1) {
 			e1.printStackTrace();
 		}
 	}
 	private void answerFileTransfer(int port) {
 		try {
 			MessageFichier messageOut = new MessageFichier(TypeMessage.FICHIER_ANSWER, ""+port, "");
 			this.tcpClient.sendMessage(messageOut);
 		} catch (MauvaisTypeMessageException | IOException e1) {
 			e1.printStackTrace();
 		}
 	}
 	//Methode appelee quand l'inputStream de la socket de communication recoit des donnees
 	@Override
 	public void update(Object o, Object arg) {
 		Message message = (Message) arg;
 		switch(message.getTypeMessage()) {
 		case TEXTE:
 			System.out.println(message.toString());
 			this.vue.appendMessage(message);
 			this.messagesIn.add(message);
 			break;
 		case IMAGE:
 			this.vue.appendImage(message);
 			if(message.getSender().equals("Moi")) {
 				this.messagesOut.add(message);
 			}else {
 				this.messagesIn.add(message);
 			}
 			break;
 		case FICHIER:
 			this.vue.appendMessage(message);
 			if(message.getSender().equals("Moi")) {
 				this.messagesOut.add(message);
 			}else {
 				this.messagesIn.add(message);
 			}
 			break;
 		case FICHIER_INIT:
 			try {
 				MessageFichier mFichier = (MessageFichier) arg;
 				int nbFile = Integer.parseInt(mFichier.getContenu());
 				FileTransferServer fts = new FileTransferServer(nbFile, this);
 				int port = fts.getPort();
 				fts.start();
 				this.answerFileTransfer(port);
 			} catch (IOException e) {
 				e.printStackTrace();
 			}
 			break;
 		case FICHIER_ANSWER:
 			try {
 				MessageFichier mFichier = (MessageFichier) arg;
 				int port = Integer.parseInt(mFichier.getContenu());
 				FileTransferClient ftc = new FileTransferClient(port ,(ArrayList<File>) this.files.clone(), this);
 				ftc.sendFiles();
 				this.files.clear();
 			} catch (IOException | InterruptedException e) {
 				e.printStackTrace();
 			}
 			break;
 		default:
 		}
 	}
 	@Override
 	public void updateSocketState(Object o, Object arg) {
 		this.vue.endSession(this.pseudoOther);	
 	}
 	protected void destroyAll() {
 		String idSelf = Utilisateur.getSelf().getId();
 		String idOther = this.idOther;
 		try {
 			this.sqlManager.insertAllMessages(messagesOut, idSelf, idOther);
 			this.sqlManager.insertAllMessages(messagesIn, idOther, idSelf);
 		} catch (SQLException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 		this.vue = null;
 		this.tcpClient.destroyAll();
 		this.tcpClient = null;
 	}
 }
--- a/POO/src/session/FileComponent.java
+++ b/POO/src/session/FileComponent.java
@ -1,44 +0,0 @@
 package session;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import javax.swing.JButton;
 import javax.swing.JLabel;
 import javax.swing.JPanel;
 import javax.swing.JTextPane;
 import javax.swing.text.BadLocationException;
 public class FileComponent extends JPanel {
 	private JTextPane container;
 	JPanel self;
 	public FileComponent(JTextPane container,String label) {
 		super();
 		this.self = this;
 		this.container = container;
 		JLabel l = new JLabel(label);
 		l.setEnabled(false);
 		JButton close = new JButton("X");
 		close.addActionListener(new ActionListener() {
 			@Override
 			public void actionPerformed(ActionEvent e) {
 				try {
 					container.getDocument().remove(container.getDocument().getLength()-3, 1);
 				} catch (BadLocationException e1) {
 					// TODO Auto-generated catch block
 					e1.printStackTrace();
 				}
 				container.repaint();
 			}
 		});
 		this.add(l);
 		this.add(close);
 	}
 }
--- a/POO/src/session/VueSession.java
+++ b/POO/src/session/VueSession.java
@ -1,267 +0,0 @@
 package session;
 import java.awt.*;
 import java.awt.event.KeyEvent;
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.IOException;
 import java.net.Socket;
 import java.util.ArrayList;
 import javax.imageio.ImageIO;
 import javax.swing.Icon;
 import javax.swing.ImageIcon;
 import javax.swing.JButton;
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
 import javax.swing.JTextArea;
 import javax.swing.JTextPane;
 import javax.swing.KeyStroke;
 import javax.swing.ScrollPaneConstants;
 import javax.swing.border.EmptyBorder;
 import javax.swing.text.AbstractDocument;
 import javax.swing.text.BadLocationException;
 import javax.swing.text.BoxView;
 import javax.swing.text.ComponentView;
 import javax.swing.text.Document;
 import javax.swing.text.Element;
 import javax.swing.text.IconView;
 import javax.swing.text.LabelView;
 import javax.swing.text.ParagraphView;
 import javax.swing.text.SimpleAttributeSet;
 import javax.swing.text.Style;
 import javax.swing.text.StyleConstants;
 import javax.swing.text.StyleContext;
 import javax.swing.text.StyledDocument;
 import javax.swing.text.StyledEditorKit;
 import javax.swing.text.View;
 import javax.swing.text.ViewFactory;
 import communication.filetransfer.FileTransferUtils;
 import database.SQLiteManager;
 import messages.Message;
 import messages.Message.TypeMessage;
 import messages.MessageFichier;
 import messages.MessageTexte;
 public class VueSession extends JPanel {
 	/**
 	 * 
 	 */
 	private static final long serialVersionUID = 1L;
 	private JButton sendMessage;
 	private JButton importFile;
 	private JTextPane chatWindow;
 	private JTextArea chatInput;
 	private ControleurSession c;
 	public VueSession(Socket socketComm, String idOther, String pseudoOther, SQLiteManager sqlManager)
 			throws IOException {
 		this.c = new ControleurSession(this, socketComm, idOther, pseudoOther, sqlManager);
 		this.setBorder(new EmptyBorder(5, 5, 5, 5));
 		this.setLayout(new BorderLayout(0, 0));
 		this.chatInput = new JTextArea();
 		this.chatInput.setColumns(10);
 		this.chatInput.setLineWrap(true);
 		this.chatInput.setWrapStyleWord(true);
 		this.chatInput.addKeyListener(this.c);
 		this.chatWindow = new JTextPane();
 		this.chatWindow.setEditable(false);
 		this.chatWindow.setEditorKit(new WrapEditorKit());
 		JScrollPane chatScroll = new JScrollPane(this.chatWindow);
 		chatScroll.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);
 		JPanel bottom = new JPanel();
 		bottom.setLayout(new BorderLayout(0, 0));
 		// remap "ENTER" to "none" to avoid "\n" in the input area after sending message
 		KeyStroke enter = KeyStroke.getKeyStroke("ENTER");
 		this.chatInput.getInputMap().put(enter, "none");
 		KeyStroke shiftEnter = KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, KeyEvent.SHIFT_DOWN_MASK);
 		this.chatInput.getInputMap().put(shiftEnter, "insert-break");
 		this.importFile = new JButton("Importer..");
 		this.importFile.addActionListener(this.c);
 		JScrollPane inputScroll = new JScrollPane(this.chatInput);
 		inputScroll.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
 		this.sendMessage = new JButton("Envoyer");
 		this.sendMessage.addActionListener(this.c);
 		bottom.add(this.importFile, BorderLayout.WEST);
 		bottom.add(inputScroll, BorderLayout.CENTER);
 		bottom.add(this.sendMessage, BorderLayout.EAST);
 		this.add(chatScroll, BorderLayout.CENTER);
 		this.add(bottom, BorderLayout.SOUTH);
 		this.setPreferredSize(new Dimension(500, 500));
 		this.displayHistorique();
 	}
 	protected JButton getButtonEnvoyer() {
 		return this.sendMessage;
 	}
 	protected JButton getButtonImportFile() {
 		return this.importFile;
 	}
 	protected String getInputedText() {
 		return this.chatInput.getText();
 	}
 	protected void appendInputedText(String str) {
 		this.chatInput.append(str);
 	}
 	protected void resetZoneSaisie() {
 		this.chatInput.setText("");
 	}
 	private void setCaretToEnd() {
 		this.chatWindow.setCaretPosition(this.chatWindow.getDocument().getLength());
 	}
 	protected void appendString(String str) {
 		try {
 			Document doc = this.chatWindow.getDocument();
 			doc.insertString(doc.getLength(), str, null);
 		} catch (BadLocationException e) {
 			e.printStackTrace();
 		}
 	}
 	protected void appendMessage(Message message) {
 		try {
 			StyledDocument sdoc = this.chatWindow.getStyledDocument();
 			// sdoc.setParagraphAttributes(sdoc.getLength(), message.toString().length()-1,
 			// style, false);
 			sdoc.insertString(sdoc.getLength(), message.toString(), null);
 		} catch (BadLocationException e) {
 			e.printStackTrace();
 		}
 	}
 	protected void appendImage(Message message) {
 		this.setCaretToEnd();
 		String imgString = message.toString();
 		Icon ic;
 		try {
 			BufferedImage img = FileTransferUtils.decodeImage(imgString);
 			ic = new ImageIcon(img);
 			this.chatWindow.insertIcon(ic);
 			this.appendString("\n");
 		} catch (IOException e) {
 			e.printStackTrace();
 		}
 	}
 	private void printLineSeparator() {
 		this.appendString("------------------------------------------\n");
 	}
 	protected void endSession(String pseudoOther) {
 		this.printLineSeparator();
 		this.appendString(pseudoOther + " a mis fin à la session.");
 		this.chatInput.setEnabled(false);
 		this.chatInput.setFocusable(false);
 		this.sendMessage.setEnabled(false);
 		this.importFile.setEnabled(false);
 	}
 	private void displayHistorique() {
 		ArrayList<Message> historique = this.c.getHistorique();
 		for (Message m : historique) {
 			if(m.getTypeMessage() == TypeMessage.IMAGE) {
 				this.appendImage(m);
 			}else {
 				this.appendMessage(m);
 			}
 		}
 		if (historique.size() > 0) {
 			this.printLineSeparator();
 		}
 	}
 	public void destroyAll() {
 		if (this.c != null) {
 			this.c.destroyAll();
 		}
 		this.c = null;
 		this.chatInput = null;
 		this.chatWindow = null;
 		this.sendMessage = null;
 	}
 	// ------------- PRIVATE CLASS TO WRAP TEXT -------------//
 	class WrapEditorKit extends StyledEditorKit {
 		ViewFactory defaultFactory = new WrapColumnFactory();
 		public ViewFactory getViewFactory() {
 			return defaultFactory;
 		}
 	}
 	class WrapColumnFactory implements ViewFactory {
 		public View create(Element elem) {
 			String kind = elem.getName();
 			if (kind != null) {
 				if (kind.equals(AbstractDocument.ContentElementName)) {
 					return new WrapLabelView(elem);
 				} else if (kind.equals(AbstractDocument.ParagraphElementName)) {
 					return new ParagraphView(elem);
 				} else if (kind.equals(AbstractDocument.SectionElementName)) {
 					return new BoxView(elem, View.Y_AXIS);
 				} else if (kind.equals(StyleConstants.ComponentElementName)) {
 					return new ComponentView(elem);
 				} else if (kind.equals(StyleConstants.IconElementName)) {
 					return new IconView(elem);
 				}
 			}
 			// default to text display
 			return new LabelView(elem);
 		}
 	}
 	class WrapLabelView extends LabelView {
 		public WrapLabelView(Element elem) {
 			super(elem);
 		}
 		public float getMinimumSpan(int axis) {
 			switch (axis) {
 			case View.X_AXIS:
 				return 0;
 			case View.Y_AXIS:
 				return super.getMinimumSpan(axis);
 			default:
 				throw new IllegalArgumentException("Invalid axis: " + axis);
 			}
 		}
 	}
 }
--- a/POO/src/standard/ControleurStandard.java
+++ b/POO/src/standard/ControleurStandard.java
@ -1,328 +0,0 @@
 package standard;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.event.WindowEvent;
 import java.awt.event.WindowListener;
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.PrintWriter;
 import java.net.InetAddress;
 import java.net.Socket;
 import java.util.ArrayList;
 import javax.swing.JButton;
 import javax.swing.JList;
 import javax.swing.event.ListSelectionEvent;
 import javax.swing.event.ListSelectionListener;
 import communication.tcp.TCPServer;
 import communication.udp.CommunicationUDP;
 import database.SQLiteManager;
 import main.Utilisateur;
 import observers.ObserverInputMessage;
 import observers.ObserverSocketState;
 import observers.ObserverUserList;
 import session.VueSession;
 public class ControleurStandard implements ActionListener, ListSelectionListener, WindowListener, ObserverInputMessage, ObserverUserList, ObserverSocketState {
 	private enum ModifPseudo {
 		TERMINE, EN_COURS
 	}
 	private ModifPseudo modifPseudo;
 	private VueStandard vue;
 	private CommunicationUDP commUDP;
 	private String lastPseudo;
 	private TCPServer tcpServ;
 	private ArrayList<String> idsSessionEnCours;
 	private SQLiteManager sqlManager;
 	public ControleurStandard(VueStandard vue, int portClientUDP, int portServerUDP, int[] portsOther, int portServerTCP, SQLiteManager sqlManager) throws IOException {
 		this.vue = vue;
 		this.tcpServ = new TCPServer(portServerTCP);
 		this.tcpServ.addObserver(this);
 		this.tcpServ.start();
 		this.commUDP = new CommunicationUDP(portClientUDP,portServerUDP, portsOther);
 		this.commUDP.setObserver(this);
 		this.commUDP.sendMessageConnecte();
 		this.commUDP.sendMessageInfoPseudo();
 		this.idsSessionEnCours = new ArrayList<String>();
 		this.sqlManager = sqlManager;
 		this.modifPseudo = ModifPseudo.TERMINE;
 	}
 	//---------- LISTSELECTION LISTENER OPERATIONS ----------//
 	@Override
 	public void valueChanged(ListSelectionEvent e) {
 		int a = 5;
 		//Case when a list element is selected
 		if (this.vue.getActiveUsersList().isFocusOwner() && !e.getValueIsAdjusting() && this.vue.getActiveUsersList().getSelectedValue() != null) {
 			JList<String> list = this.vue.getActiveUsersList();
 			String pseudoOther = list.getSelectedValue();
 			Utilisateur other = this.commUDP.getUserFromPseudo(pseudoOther);
 			String idOther = other.getId();
 			//Check if we are already asking for a session/chatting with the person selected
 			//null condition because the list.clearSelection() generates an event
 			if(!this.idsSessionEnCours.contains(idOther)) {
 				int choix = this.vue.displayJOptionSessionCreation(pseudoOther);
 				System.out.println("choix : "+choix);
 				if(choix == 0) {
 					int port = other.getPort();
 					System.out.println("port = "+port);
 					try {
 						Socket socketComm = new Socket(InetAddress.getLocalHost(), port);
 						this.sendMessage(socketComm, Utilisateur.getSelf().getPseudo());
 						String reponse = this.readMessage(socketComm);
 						System.out.println("reponse : " + reponse);
 						if(reponse.equals("accepted")) {
 							this.idsSessionEnCours.add(idOther);
 							VueSession session = new VueSession(socketComm, idOther, pseudoOther, this.sqlManager);
 							this.vue.addSession(pseudoOther, session);
 							this.vue.displayJOptionResponse("acceptee");
 						}else{
 							this.vue.displayJOptionResponse("refusee");
 							socketComm.close();
 							System.out.println("refused");
 						}
 					} catch (IOException e1) {
 						e1.printStackTrace();
 					}
 				}
 			}
 			list.clearSelection();
 			System.out.println("pseudo de la personne a atteindre : " + pseudoOther);
 		}
 	}
 	//---------- ACTION LISTENER OPERATIONS ----------//
 	@Override
 	public void actionPerformed(ActionEvent e) {
 		//Cas Modifier Pseudo
 		if ((JButton) e.getSource() == this.vue.getButtonModifierPseudo()) {
 			JButton modifierPseudo = (JButton) e.getSource();
 			if (this.modifPseudo == ModifPseudo.TERMINE) {
 				this.lastPseudo = Utilisateur.getSelf().getPseudo();
 				modifierPseudo.setText("OK");
 				this.modifPseudo = ModifPseudo.EN_COURS;
 			} else {
 				if (this.vue.getDisplayedPseudo().length() >= 1 && !this.commUDP.containsUserFromPseudo(this.vue.getDisplayedPseudo().toLowerCase())) {
 					Utilisateur.getSelf().setPseudo(this.vue.getDisplayedPseudo());
 					try {
 						this.commUDP.sendMessageInfoPseudo();
 					} catch (IOException e1) {
 						// TODO Auto-generated catch block
 						e1.printStackTrace();
 					}
 				} else {
 					this.vue.setDisplayedPseudo(this.lastPseudo);
 				}
 				modifierPseudo.setText("Modifier");
 				this.modifPseudo = ModifPseudo.TERMINE;
 			}
 			this.vue.toggleEditPseudo();
 		}
 		//Cas deconnexion
 		else if((JButton) e.getSource() == this.vue.getButtonDeconnexion() ) {
 			try {
 				this.commUDP.sendMessageDelete();
 				this.commUDP.removeAll();
 				this.vue.removeAllUsers();
 				Utilisateur.getSelf().setPseudo("");
 				//Ajouter code pour passer à la vue de connexion
 				//
 				//
 				this.vue.toggleEnableButtonConnexion();
 				this.vue.toggleEnableButtonDeconnexion();
 			} catch (IOException e1) {
 				e1.printStackTrace();
 			}
 		}
 		//Cas connexion
 		if((JButton) e.getSource() == this.vue.getButtonConnexion() ) {
 			try {
 				Utilisateur.getSelf().setPseudo(this.vue.getDisplayedPseudo());
 				this.commUDP.sendMessageConnecte();
 				this.commUDP.sendMessageInfoPseudo();
 				this.vue.toggleEnableButtonConnexion();
 				this.vue.toggleEnableButtonDeconnexion();
 			} catch (IOException e1) {
 				e1.printStackTrace();
 			}
 		}
 		else if(this.vue.isButtonTab(e.getSource()) ){
 			JButton button = (JButton) e.getSource();
 			int index = this.vue.removeSession(button);
 			this.idsSessionEnCours.remove(index);
 		}
 	}
 	//---------- WINDOW LISTENER OPERATIONS ----------//
 	@Override
 	public void windowClosing(WindowEvent e) {
 		try {
 			this.commUDP.sendMessageDelete();
 		} catch (IOException e1) {
 			// TODO Auto-generated catch block
 			e1.printStackTrace();
 		}
 	}
 	@Override
 	public void windowOpened(WindowEvent e) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void windowClosed(WindowEvent e) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void windowIconified(WindowEvent e) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void windowDeiconified(WindowEvent e) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void windowActivated(WindowEvent e) {
 		// TODO Auto-generated method stub
 	}
 	@Override
 	public void windowDeactivated(WindowEvent e) {
 		// TODO Auto-generated method stub
 	}
 	//------------SOCKET-------------//
 	private void sendMessage(Socket sock, String message) throws IOException {
 		PrintWriter output= new PrintWriter(sock.getOutputStream(), true);
 			output.println(message);
 	}
 	private String readMessage(Socket sock) throws IOException {
 		BufferedReader input = new BufferedReader(new InputStreamReader( sock.getInputStream() ));
 		return input.readLine();
 	}
 	//------------OBSERVERS-------------//
 	@Override
 	public void update(Object o, Object arg) {
 		if(o == this.tcpServ) {
 			Socket sockAccept = (Socket) arg;
 			try {
 				String pseudoOther = this.readMessage(sockAccept);
 				String idOther = this.commUDP.getUserFromPseudo(pseudoOther).getId();
 				int reponse;
 				if(!this.idsSessionEnCours.contains(idOther)) {
 					reponse = this.vue.displayJOptionAskForSession(pseudoOther);
 					System.out.println("reponse : " + reponse);
 				}else {
 					reponse = 1;
 				}
 				if(reponse == 0) {
 					this.idsSessionEnCours.add(idOther);
 					this.sendMessage(sockAccept, "accepted");
 					VueSession session = new VueSession(sockAccept, idOther, pseudoOther, this.sqlManager);
 					this.vue.addSession(pseudoOther, session);
 				}else {
 					this.sendMessage(sockAccept, "refused");
 					sockAccept.close();
 				}
 			} catch (IOException e) {
 				e.printStackTrace();
 			}
 		}
 	}
 	@Override
 	public void updateList(Object o, ArrayList<Utilisateur> userList) {
 		if(o == this.commUDP) {
 			ArrayList<String> pseudos = new ArrayList<String>();
 			for (Utilisateur u : userList) {
 				pseudos.add(u.getPseudo());
 			}
 			this.vue.setActiveUsersList(pseudos);
 		}
 	}
 	@Override
 	public void updateSocketState(Object o, Object arg) {
 		VueSession session = (VueSession) arg;
 		int index = this.vue.removeSession(session);
 		this.idsSessionEnCours.remove(index);
 	}
 }
--- a/POO/src/standard/VueStandard.java
+++ b/POO/src/standard/VueStandard.java
@ -1,378 +0,0 @@
 package standard;
 import java.awt.*;
 import java.awt.event.KeyEvent;
 import java.awt.event.KeyListener;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
 import java.awt.event.MouseListener;
 import java.io.IOException;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import javax.swing.AbstractButton;
 import javax.swing.BorderFactory;
 import javax.swing.DefaultListModel;
 import javax.swing.JButton;
 import javax.swing.JLabel;
 import javax.swing.JList;
 import javax.swing.JOptionPane;
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
 import javax.swing.JTabbedPane;
 import javax.swing.JTextField;
 import javax.swing.ListSelectionModel;
 import javax.swing.ScrollPaneConstants;
 import javax.swing.plaf.basic.BasicButtonUI;
 import database.SQLiteManager;
 import main.Utilisateur;
 import main.Vue;
 import session.VueSession;
 public class VueStandard extends Vue {
 	/**
 	 * 
 	 */
 	private static final long serialVersionUID = 1L;
 	private JList<String> activeUsersList;
 	private JTextField pseudoSelf;
 	private JTabbedPane zoneSessions;
 	private JButton modifierPseudo;
 	private JButton seConnecter;
 	private JButton seDeconnecter;
 	private ControleurStandard c;
 	private ArrayList<JButton> tabButtons;
 	private ArrayList<VueSession> sessions;
 //	private HashMap<JButton,VueSession> sessions;
 	private DefaultListModel<String> userList = new DefaultListModel<String>();
 	//------------ CONSTRUCTEUR -------------//
 	public VueStandard(String title, int portClientUDP, int portServerUDP, int[] portsOther, int portServerTCP, SQLiteManager sqlManager) throws IOException {
 		super(title);
 		this.tabButtons = new ArrayList<JButton>();
 		this.sessions = new ArrayList<VueSession>();
 //		this.sessions = new HashMap<JButton,VueSession>();
 		this.c = new ControleurStandard(this, portClientUDP, portServerUDP, portsOther, portServerTCP, sqlManager);
 		getContentPane().setLayout(new GridBagLayout());
 		JPanel left = new JPanel(new BorderLayout());
 		//left.setBackground(Color.red);
 		this.zoneSessions = new JTabbedPane();
 		this.zoneSessions.setTabPlacement(JTabbedPane.BOTTOM);
 		//this.zoneSessions.setBackground(Color.WHITE);
 		this.zoneSessions.setPreferredSize(new Dimension(600, 600));
 		//--------Panel haut pseudo--------//
 		JPanel self = new JPanel(new FlowLayout());
 		this.pseudoSelf = new JTextField(Utilisateur.getSelf().getPseudo());
 		this.pseudoSelf.setPreferredSize(new Dimension(100, 30));
 		this.pseudoSelf.setEditable(false);
 		this.pseudoSelf.setFocusable(false);
 		this.modifierPseudo = new JButton("Modifier");
 		this.modifierPseudo.addActionListener(this.c); 
 		self.add(new JLabel("Moi : "));
 		self.add(this.pseudoSelf);
 		self.add(this.modifierPseudo);
 		this.pseudoSelf.addKeyListener(new KeyListener() {
 			@Override
 			public void keyTyped(KeyEvent e) {				
 			}
 			@Override
 			public void keyReleased(KeyEvent e) {			
 			}
 			@Override
 			public void keyPressed(KeyEvent e) {
 				if(e.getKeyCode() == KeyEvent.VK_ENTER) {
 					modifierPseudo.doClick();
 				}
 			}
 		});
 		//--------Panel milieu liste utilisateurs--------//
 		this.activeUsersList = new JList<String>(this.userList);
 		this.activeUsersList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 		this.activeUsersList.setLayoutOrientation(JList.VERTICAL);
 		this.activeUsersList.addListSelectionListener(this.c);
 		System.out.println("listener ajouté userlist");
 		JScrollPane listScroller = new JScrollPane(this.activeUsersList);
 		listScroller.setPreferredSize(new Dimension(50,50));
 		listScroller.setAlignmentX(LEFT_ALIGNMENT);
 		listScroller.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
 		listScroller.setBorder(BorderFactory.createCompoundBorder(
 	            BorderFactory.createTitledBorder("Utilisateurs Actifs"), 
 	            BorderFactory.createEmptyBorder(5,2,2,2)));
 		//--------Panel bas deconnexion--------//
 		JPanel deconnexion = new JPanel(new GridLayout(1, 2));
 		this.seConnecter = new JButton("Se Connecter");
 		this.seConnecter.setEnabled(false);
 		this.seConnecter.addActionListener(this.c);
 		this.seDeconnecter = new JButton("Se Déconnecter");
 		this.seDeconnecter.addActionListener(this.c);
 		deconnexion.add(this.seConnecter);
 		deconnexion.add(this.seDeconnecter);
 		//--------Ajout à la vue--------//
 		left.add(self, BorderLayout.PAGE_START);
 		left.add(listScroller, BorderLayout.CENTER);
 		left.add(deconnexion, BorderLayout.PAGE_END);
 		GridBagConstraints gridBagConstraintLeft = new GridBagConstraints();
 		GridBagConstraints gridBagConstraintSessions = new GridBagConstraints();
 		gridBagConstraintLeft.fill = GridBagConstraints.BOTH;
 		gridBagConstraintLeft.gridx = 0;
 		gridBagConstraintLeft.gridy = 0;
 		gridBagConstraintLeft.gridwidth = 1;
 		gridBagConstraintLeft.gridheight = 4;
 		gridBagConstraintLeft.weightx = 0.33;
 		gridBagConstraintLeft.weighty = 1;
 		getContentPane().add(left,gridBagConstraintLeft);
 		gridBagConstraintSessions.fill = GridBagConstraints.BOTH;
 		gridBagConstraintSessions.gridx = 1;
 		gridBagConstraintSessions.gridy = 0;
 		gridBagConstraintSessions.gridwidth = 2;
 		gridBagConstraintSessions.gridheight = 4;
 		gridBagConstraintSessions.weightx = 0.66;
 		gridBagConstraintSessions.weighty = 1;
 		getContentPane().add(this.zoneSessions,gridBagConstraintSessions);
 		this.pack();
 		this.setVisible(true);
 		this.addWindowListener(c);
 	}
 	//------------ GETTERS -------------//
 	protected JList<String> getActiveUsersList(){
 		return this.activeUsersList;
 	}
 	protected JButton getButtonModifierPseudo() {
 		return this.modifierPseudo;
 	}
 	protected JButton getButtonDeconnexion() {
 		return this.seDeconnecter;
 	}
 	protected JButton getButtonConnexion() {
 		return this.seConnecter;
 	}
 	protected String getDisplayedPseudo() {
 		return this.pseudoSelf.getText();
 	}
 	//------------ SETTERS -------------//
 	protected void setActiveUsersList(ArrayList<String> users) {
 		this.removeAllUsers();
 		this.userList.addAll(users);
 	}
 	protected void setDisplayedPseudo(String pseudo) {
 		this.pseudoSelf.setText(pseudo);
 	}
 	//------------ JOPTIONS -------------//
 	protected int displayJOptionSessionCreation(String pseudo) {
 		return JOptionPane.showConfirmDialog(this, 
 				"Voulez vous créer une session avec "+pseudo+" ?",
 				"Confirmation session",
 				JOptionPane.YES_NO_OPTION);
 	}
 	protected int displayJOptionAskForSession(String pseudo) {
 		return JOptionPane.showConfirmDialog(this, 
 				pseudo+" souhaite creer une session avec vous.",
 				"Accepter demande",
 				JOptionPane.YES_NO_OPTION);
 	}
 	protected void displayJOptionResponse(String reponse) {
 		JOptionPane.showMessageDialog(this, "Demande de session "+reponse);
 	}
 	//------------ TOGGLEBUTTONS -------------//
 	protected void toggleEditPseudo() {
 		this.pseudoSelf.setEditable(!this.pseudoSelf.isEditable());
 		this.pseudoSelf.setFocusable(!this.pseudoSelf.isFocusable());
 	}
 	protected void toggleEnableButtonDeconnexion() {
 		this.seDeconnecter.setEnabled(!this.seDeconnecter.isEnabled());
 	}
 	protected void toggleEnableButtonConnexion() {
 		this.seConnecter.setEnabled(!this.seConnecter.isEnabled());
 	}
 	//------------SESSION-------------//
 	protected boolean isButtonTab(Object o) {
 		return this.tabButtons.contains(o);
 	}
 	protected int removeSession(JButton button) {
 		int index = this.tabButtons.indexOf(button);
 		VueSession vue = this.sessions.get(index);
 		vue.destroyAll();
 		this.zoneSessions.remove(vue);
 		this.sessions.remove(index);
 		this.tabButtons.remove(index);
 		return index;
 	}
 	protected int removeSession(VueSession vue) {
 		int index = this.sessions.indexOf(vue);
 		vue.destroyAll();
 		this.zoneSessions.remove(vue);
 		this.sessions.remove(index);
 		this.tabButtons.remove(index);
 		return index;
 	}
 	protected void addSession(String pseudo, VueSession session) {
 		JPanel tabTitle = new JPanel();
 		TabButton closeTab = new TabButton();
 		tabTitle.add(new JLabel(pseudo));
 		tabTitle.add(closeTab);
 		this.zoneSessions.addTab(pseudo, session);
 		this.zoneSessions.setTabComponentAt(this.zoneSessions.getTabCount()-1, tabTitle);
 		this.tabButtons.add(closeTab);
 		this.sessions.add(session);
 		session.requestFocus();
 	}
 	//------------ OTHERS -------------//
 	protected void removeAllUsers() {
 		this.userList.removeAllElements();
 	}
 	//------------- PRIVATE CLASSES FOR THE TABS BUTTON -------------//
 	 private class TabButton extends JButton{
 	        public TabButton() {
 	            int size = 17;
 	            setPreferredSize(new Dimension(size, size));
 	            setToolTipText("close this tab");
 	            //Make the button looks the same for all Laf's
 	            setUI(new BasicButtonUI());
 	            //Make it transparent
 	            setContentAreaFilled(false);
 	            //No need to be focusable
 	            setFocusable(false);
 	            setBorder(BorderFactory.createEtchedBorder());
 	            setBorderPainted(false);
 	            addMouseListener(VueStandard.buttonMouseListener);
 	            //Making nice rollover effect
 	            //we use the same listener for all buttons
 	            addActionListener(c);
 	            setRolloverEnabled(true);
 	        }
 	        //we don't want to update UI for this button
 	        public void updateUI() {
 	        }
 	        //paint the cross
 	        protected void paintComponent(Graphics g) {
 	            super.paintComponent(g);
 	            Graphics2D g2 = (Graphics2D) g.create();
 	            //shift the image for pressed buttons
 	            if (getModel().isPressed()) {
 	                g2.translate(1, 1);
 	            }
 	            g2.setStroke(new BasicStroke(2));
 	            g2.setColor(Color.BLACK);
 	            if (getModel().isRollover()) {
 	                g2.setColor(Color.MAGENTA);
 	            }
 	            int delta = 6;
 	            g2.drawLine(delta, delta, getWidth() - delta - 1, getHeight() - delta - 1);
 	            g2.drawLine(getWidth() - delta - 1, delta, delta, getHeight() - delta - 1);
 	            g2.dispose();
 	        }
 	    }
 	 private final static MouseListener buttonMouseListener = new MouseAdapter() {
 	        public void mouseEntered(MouseEvent e) {
 	            Component component = e.getComponent();
 	            if (component instanceof AbstractButton) {
 	                AbstractButton button = (AbstractButton) component;
 	                button.setBorderPainted(true);
 	            }
 	        }
 	        public void mouseExited(MouseEvent e) {
 	            Component component = e.getComponent();
 	            if (component instanceof AbstractButton) {
 	                AbstractButton button = (AbstractButton) component;
 	                button.setBorderPainted(false);
 	            }
 	        }
 	    };
 }
--- a/README.md
+++ b/README.md
@ -1,3 +1,20 @@
 # Projet_COO_POO
 Projet de 4ème année : Conception et programmation orientée objet d'un systeme de clavardage distribué interactif multi-utilisateur temps réel 
 Contenu (branche master):
 Dossier rapports : rapports de conception et de projet
 Dossier application : archives .jar permettant d'exécuter l'application (version classique)
 Dossier serveur_presence : archives .jar et .war permettant d'exécuter respectivement l'application (version compatible avec le serveur) et le serveur de présence
 Pour récupérer les codes sources :
 - De l'application classique : branche application
 - Du serveur et de l'application modifiée : branche serveur_presence (l'application est dans le projet POO, le servlet dans le projet POO_Server) 
 Toutes les autres branches concernent des versions obsolètes de l'application, merci de ne pas en tenir compte.
--- a/application/chat.jar
+++ b/application/chat.jar
--- a/application/chat_lib/sqlite-jdbc-3.32.3.2.jar
+++ b/application/chat_lib/sqlite-jdbc-3.32.3.2.jar
--- a/application/create_users.jar
+++ b/application/create_users.jar
--- a/modelisation/Diagramme_Structure_Composite.png
+++ b/modelisation/Diagramme_Structure_Composite.png
--- a/modelisation/Diagramme_d_etats.PNG
+++ b/modelisation/Diagramme_d_etats.PNG
--- a/modelisation/Diagramme_de_classe_projet_coo_poo.png
+++ b/modelisation/Diagramme_de_classe_projet_coo_poo.png
--- a/modelisation/Diagramme_de_sequence_afficher_utilisateurs.PNG
+++ b/modelisation/Diagramme_de_sequence_afficher_utilisateurs.PNG
--- a/modelisation/Diagramme_de_sequence_authentification.png
+++ b/modelisation/Diagramme_de_sequence_authentification.png
--- a/modelisation/Diagramme_de_sequence_choix_pseudo_interface.png
+++ b/modelisation/Diagramme_de_sequence_choix_pseudo_interface.png
--- a/modelisation/Diagramme_de_sequence_session_clavardage.png
+++ b/modelisation/Diagramme_de_sequence_session_clavardage.png
--- a/modelisation/Uses_Case_Diagram.png
+++ b/modelisation/Uses_Case_Diagram.png
--- a/modelisation/dossmod.txt
+++ b/modelisation/dossmod.txt
--- a/rapports/rapport_conception.pdf
+++ b/rapports/rapport_conception.pdf
--- a/rapports/rapport_poo.pdf
+++ b/rapports/rapport_poo.pdf
--- a/serveur_presence/application.jar
+++ b/serveur_presence/application.jar
--- a/serveur_presence/serveurpresence.war
+++ b/serveur_presence/serveurpresence.war
Author	SHA1	Message	Date
m-gues	566b89c382	rendu du projet	2021-02-16 00:08:15 +01:00
Cavailles Kevin	61e069d6ec	rename	2021-02-15 23:35:20 +01:00
Cavailles Kevin	16204aa9ac	remove old files, add app .jar	2021-02-15 23:32:36 +01:00