//***********************************************************************************
//Fichier :			Jeu.java
//Description :		Classe representant un jeu sous forme d'une matrice de caractère
//Environnement :	Eclipse Version: 3.3.2
//***********************************************************************************
//Version :			1.0
//***********************************************************************************
public class Jeu
{
	//Constantes de la classe.
    public static final int DIMENSION = 10;
    public static final int NB_POUR_GAIN = 5;
    
    //Attribut de l'objet
    private char [][] matrice;
    
    /********************************************************************************
     * But:		Construire un jeu avec les attributs par défaut
     * Sortie:	Aucune
     *******************************************************************************/
    public Jeu()
    {
    	//Initialise une matrice au dimension de la constante
    	char[][] temp = new char[DIMENSION][DIMENSION];
    	
    	//Parcourt la matrice dans son ensemble et la remplie d'espace blanc
    	for(int i = 0; i < DIMENSION; i++)
    	{
    		for(int j = 0; j < DIMENSION; j++)
    		{
    			temp[i][j] = ' ';
    		}
    	}
    	matrice = temp;
    }
    
    /********************************************************************************
     * But:		Valide la position i,j pour vérifier si elle est dans les bornes de 
     * 			la matrice
     * Entrée:	i (int):	position en i représentant la ligne
     * 			j (int):	position en j représentant la colonne
     * Sortie:	boolean:	Retourne vrai si la position est situé dans le bornes de 
     * 						la matrice	
     *******************************************************************************/
    public static boolean validerPosition (int i, int j)
    {
    	return(	i < DIMENSION &&
    			j < DIMENSION &&
    			i >= 0 &&
    			j >= 0);
    }

    /********************************************************************************
     * But:		Valide le caractère recut en entrée
     * Entrée:	paramCar (char):	Contient le caractère à valider
     * Sortie:	boolean:			Vérifie si c'est un caractère valide
     *******************************************************************************/
    public static boolean validerCar (char paramCar)
    {
    	return( paramCar == 'R' ||
    			paramCar == 'B' ||
    			paramCar == ' ');
    }
    
	/********************************************************************************
	 *But:		Valide si la position en entrée est un position propice au jeu d'un 
	 *			joueur.		
	 *Entrée:	i (int):	position en i représentant la ligne
	 *			j (int):	position en j représentant la colonne
	 *Sortie:	boolean:	Vérifie si la position est dans les bornes de la matrice 
	 *						et qu'elle contient un espace blanc
	 *******************************************************************************/
    public boolean verifierPositionJouable (int i, int j)
    {
    	return(	validerPosition(i ,j) &&
    			matrice[i][j] == ' ');
    }
    
	/********************************************************************************
	 *But:		Entre le caractère à la position i, j si toutes les données sont 
	 *			valide
	 *Entrée:	paramCar (char):	Caractère a placer dans la matrice
	 *			i (int):			position en i représentant la ligne
	 *			j (int):			position en j représentant la colonne
	 *Sortie:	boolean:			Retourne vrai si toutes les données sont valider 
	 *								et que le palcement du caractère à bien été fait
	 *******************************************************************************/
    public boolean setCar (char paramCar, int i, int j)
    {
    	//Valider le caractère ainsi que la position ou il sera placé
    	boolean ok = validerCar(paramCar) && validerPosition(i, j);
    	
    	//Si le caractère et la position sont valider attribuer la caractère à la 
    	//position
    	if(ok)
    		matrice[i][j] = paramCar;
    	
    	return ok;
    }
    
	/********************************************************************************
	 *But:		Verifie si la matrice contient encore des espace blanc
	 *Entrée:	Aucune
	 *Sortie:	boolean:	Retourne vrai si la matrice est pleine
	 *******************************************************************************/
    public boolean verifierPleine()
    {
    	boolean validation = true;
    	
    	//Parcourt la matrice à la recherche d'espace blanc
    	for(int i = 0; i < DIMENSION; i++)
    	{
    		for(int j = 0; j < DIMENSION; j++)
    		{
    			if(matrice[i][j] == ' ')
    			{
    				validation = false;
    				i = DIMENSION;
    				j = DIMENSION;
    			}
    		}
    	}
    	
    	return validation;
    }
    
	/********************************************************************************
	 *But:		Vérifier si à partir de la position i, j il y a aumoins 5 caractères 
	 *			consécutifs sur une ligne horizontale
	 *Entrée:	i (int):	position i représentant la ligne
	 *			j (int):	position j représentant la colonne
	 *Sortie:	boolean:	Renvoit vrai si 5 caractère consécutifs on été trouvés.
	 *******************************************************************************/
    private boolean verifierCinqHorizontal(int i, int j)
    {
    	//Identifie qu'elle caractère il faut rechercher
		char car = matrice[i][j];
		
		int nb = 1,	 	//identifie le nombre de caractère trouvé
			saut = 1;	//identifie le deplacement à faire
		//idique si le caractère suivant dans la chaine est bien le même.
		boolean test = false;
		
		//Boucle parcourant la gauche et la droite de la position i, j
		do
		{
			//indique le deplacement à faire
			int deplacer = j + saut;
			
			while(nb < NB_POUR_GAIN &&  //Vérifie si il n'y a pas déjà 5 caractères
				!test &&	//Vérifie si le caractère suivant est le même
				deplacer >= 0 && //Vérifie qu'on ne sorte pas de la matrice 
				deplacer < matrice.length)//Vérifie qu'on ne sorte pas de la matrice
			{
				//Si le caractère est le même incrementer le nombre et effectuer
				//un deplacement
				if(matrice[i][deplacer] == car)
				{
					deplacer += saut;
					nb++;
				}
				//Sinon quitter la boucle
				else
					test = true;
			}
			//Inverse le déplacement dans la matrice
			saut *= -1;
			//Réinitialise pour le déplacement dans le sens opposé
			test = false;
		}
		//Permet de parcourir la matrice dans les 2 sens seulement une fois.
		while(saut == -1);
		
		return (nb == NB_POUR_GAIN );
    }
	
	/********************************************************************************
	 *But:		Vérifier si à partir de la position i, j il y a aumoins 5 caractères 
	 *			consécutifs sur une ligne verticale
	 *Entrée:	i (int):	position i représentant la ligne
	 *			j (int):	position j représentant la colonne
	 *Sortie:	boolean:	Renvoit vrai si 5 caractère consécutifs on été trouvés.
	 *******************************************************************************/
    private boolean verifierCinqVertical(int i, int j)
    {
    	//Identifie qu'elle caractère il faut rechercher
		char car = matrice[i][j];
		
		int nb = 1,		//identifie le nombre de caractère trouvé
			saut = 1;	//identifie le deplacement à faire
		//idique si le caractère suivant dans la chaine est bien le même.
		boolean test = false;
		
		//Boucle parcourant la gauche et la droite de la position i, j
		do
		{
			//indique le deplacement à faire
			int deplacer = i + saut;
			
			while(nb < NB_POUR_GAIN &&  //Vérifie si il n'y a pas déjà 5 caractères
				!test && 	//Vérifie si le caractère suivant est le même
				deplacer >= 0 && //Vérifie qu'on ne sorte pas de la matrice 
				deplacer < matrice.length) //Vérifie qu'on ne sorte pas de la matrice
			{
				//Si le caractère est le même incrementer le nombre et effectuer 
				//un deplacement
				if(matrice[deplacer][j] == car)
				{
					deplacer += saut;
					nb++;
				}
				//Sinon quitter la boucle
				else
					test = true;
			}
			//Inverse le déplacement dans la matrice
			saut *= -1;
			//Réinitialise pour le déplacement dans le sens opposé
			test = false;
		}
		//Permet de parcourir la matrice dans les 2 sens seulement une fois.
		while(saut == -1);
		
		return (nb == NB_POUR_GAIN);
    }
   
	/********************************************************************************
	 *But:		Vérifier si à partir de la position i, j il y a aumoins 5 caractères 
	 *			consécutifs sur une ligne diagonale de droite a gauche.
	 *Entrée:	i (int):	position i représentant la ligne
	 *			j (int):	position j représentant la colonne
	 *Sortie:	boolean:	Renvoit vrai si 5 caractère consécutifs on été trouvés.
	 *******************************************************************************/
    private boolean verifierCinqDiagonaleDG(int i, int j)
    {
    	//Identifie qu'elle caractère il faut rechercher
		char car = matrice[i][j];
		
		int nb = 1, //identifie le nombre de caractère trouvé
			sautVerticale = -1, //identifie le deplacement verticale à faire
			sautHorizontale = 1; //identifie le deplacement horizontale à faire
		//idique si le caractère suivant dans la chaine est bien le même.
		boolean test = false;
		
		//Boucle parcourant la gauche et la droite de la position i, j
		do
		{
			//identifie le deplacement verticale à faire
			int deplacerVerticale = i + sautVerticale;
			//identifie le deplacement horizontale à faire
			int	deplacerHorizontale = j + sautHorizontale;
			
			while(nb < NB_POUR_GAIN && //Vérifie si il n'y a pas déjà 5 caractères
				!test && 	//Vérifie si le caractère suivant est le même
				deplacerVerticale >= 0 && //Vérifie qu'on ne sorte pas de la matrice 
				deplacerVerticale < matrice.length && //Vérifie qu'on ne sorte pas
				deplacerHorizontale >= 0 &&//Vérifie qu'on ne sorte pas de la matrice
				deplacerHorizontale < matrice.length)//Vérifie qu'on ne sorte pas
			{
				//Si le caractère est le même incrementer le nombre et effectuer
				//les deplacements
				if(matrice[deplacerVerticale][deplacerHorizontale] == car)
				{
					deplacerVerticale += sautVerticale;
					deplacerHorizontale += sautHorizontale;
					nb++;
				}
				//Sinon quitter la boucle
				else
					test = true;
			}
			//Inverse le déplacement horizontale dans la matrice
			sautHorizontale *= -1;
			//Inverse le déplacement verticale dans la matrice
			sautVerticale *= -1;
			//Réinitialise pour le déplacement dans le sens opposé
			test = false;
		}
		//Permet de parcourir la matrice dans les 2 sens seulement une fois.
		while(sautHorizontale == -1);
		
		return (nb == NB_POUR_GAIN );
    }
   
	/********************************************************************************
	 *But:		Vérifier si à partir de la position i, j il y a aumoins 5 caractères 
	 *			consécutifs sur une ligne diagonale de gauche à droite
	 *Entrée:	i (int):	position i représentant la ligne
	 *			j (int):	position j représentant la colonne
	 *Sortie:	boolean:	Renvoit vrai si 5 caractère consécutifs on été trouvés.
	 *******************************************************************************/
    private boolean verifierCinqDiagonaleGD(int i, int j)
    {
    	//Identifie qu'elle caractère il faut rechercher
    	char car = matrice[i][j];
    	
		int nb = 1, 	//identifie le nombre de caractère trouvé
			saut = 1;	//identifie le deplacement à faire
		//idique si le caractère suivant dans la chaine est bien le même.
		boolean test = false;
		
		//Boucle parcourant la gauche et la droite de la position i, j
		do
		{
			//identifie le deplacement verticale à faire
			int deplacerVerticale = i + saut;
			//identifie le deplacement horizontale à faire
			int	deplacerHorizontale = j + saut;
			
			
			while(nb < NB_POUR_GAIN &&  //Vérifie si il n'y a pas déjà 5 caractères
				!test && 	//Vérifie si le caractère suivant est le même
				deplacerVerticale >= 0 && //Vérifie qu'on ne sorte pas de la matrice 
				deplacerVerticale < matrice.length && //Vérifie qu'on ne sorte pas
				deplacerHorizontale >= 0 &&//Vérifie qu'on ne sorte pas de la matrice 
				deplacerHorizontale < matrice.length)//Vérifie qu'on ne sorte pas
			{
				//Si le caractère est le même incrementer le nombre et effectuer 
				//les deplacements
				if(matrice[deplacerVerticale][deplacerHorizontale] == car)
				{
					deplacerVerticale += saut;
					deplacerHorizontale += saut;
					nb++;
				}
				//Sinon quitter la boucle
				else
					test = true;
			}
			//Inverse le déplacement dans la matrice
			saut *= -1;
			//Réinitialise pour le déplacement dans le sens opposé
			test = false;
		}
		//Permet de parcourir la matrice dans les 2 sens seulement une fois.
		while(saut == -1);
		
		return (nb == NB_POUR_GAIN );
    }
        
	/********************************************************************************
	 *But:		Vérifier si à partir de la position i, j il y a eu un suite 
	 *			consécutif de 5 caractères et ça peut importe la direction
	 *Entrée:	i (int):	position i représentant la ligne
	 *			j (int):	position j représentant la colonne
	 *Sortie:	boolean:	Renvoit vrai si 5 caractère consécutifs on été trouvés.
	 *******************************************************************************/
    public boolean verifierGain(int i, int j)
    {
    	return(	verifierCinqHorizontal(i, j) 	||
    			verifierCinqVertical(i, j) 		||
    			verifierCinqDiagonaleGD(i, j) 	||
    			verifierCinqDiagonaleDG(i, j));
    }
    
	/********************************************************************************
	 *But:		Faire les test unitaire sur la classe
	 *Entrée:	Aucune
	 *Sortie:	Aucune
	 *******************************************************************************/
    public static void main (String [] arg)
    {
    }
    
}

//***********************************************************************************
//Fichier :			Joueur.java
//Description :		Classe représentant un joueur avec nom, caractère et gain.
//Environnement :	Eclipse Version: 3.3.2
//***********************************************************************************
//Version :			1.0
//***********************************************************************************

//Packtage d'extension Java.
import javax.swing.JOptionPane;

public class Joueur
{
	//Constantes de classe.
	public static final String 	NOM_DEFAUT = "Votre nom";
	public static final int 	LONGUEUR_NOM_MIN = 2;
	public static final int 	LONGUEUR_NOM_MAX = 15;
	public static final int 	NOMBRE_GAIN_DEFAUT = 0;
	public static final int 	NOMBRE_GAIN_MIN = 0;
	public static final char 	CARACTERE_DEFAUT = 'R';
	
    //Les attributs de l'objet.
	private String 	nom ;
	private int 	gain;
	private char 	caractere;
	
    //*******************************************************************************
    // But:		Construire un joueur avec les attributs par défaut.
    // Sortie :	Aucune.
    //*******************************************************************************
	public Joueur()
	{ 
		this(NOM_DEFAUT, NOMBRE_GAIN_DEFAUT, CARACTERE_DEFAUT);
	}
	
    //*******************************************************************************
    // But:		Construire un joueur avec l'attribut nom et caractère reçus en entrée
    // Sortie :	Aucune.
    //*******************************************************************************
	public Joueur(String paramNom, char paramCaractere)
	{
		this(paramNom, NOMBRE_GAIN_DEFAUT, paramCaractere);
	}
	
    //*******************************************************************************
    // But:		Construire un joueur avec les attributs reçus en entrée.
    // Sortie :	Aucune.
    //*******************************************************************************
	public Joueur(String paramNom, int paramGain, char paramCaractere)
	{
    	//Valider les paramètres reçus et les assigner aux attributs de l'objet, 
    	//s'ils sont tous valides.
		boolean ok =	setNom(paramNom) &&
						setGain(paramGain) &&
						setCaractere(paramCaractere);
		
        //Sinon, attribuer les valeurs par défauts aux attributs de l'objet.
		if(!ok)
		{
			setNom(NOM_DEFAUT);
			setGain(NOMBRE_GAIN_DEFAUT);
			setCaractere(CARACTERE_DEFAUT);
		}
	}
	
    //*******************************************************************************
    // But:		Retourner le nom du joueur.
    // Sortie :	nom (String) : le nom actuelle du joueur.
    //*******************************************************************************
	public String getNom()
	{
		return nom;
	}
	
    //*******************************************************************************
    // But:		Retourner les gains du joueur.
    // Sortie :	gain (int) : les gains actuelle du joueur.
    //*******************************************************************************
	public int getGain()
    {
		return gain;
	}

    //*******************************************************************************
    // But:		Retourner le caractère assigner au joueur.
    // Sortie :	caractere (char) : le caractère du joueur.
    //*******************************************************************************
	public char getCaractere()
    {
		return caractere;
	}
	
    //*******************************************************************************
    // But:		Modifier le nom du joueur à partir de celui reçue en entrée.
    // Sortie :	ok (booléen) : 	indique vrai si le nom du joueur a été modifié.
    //*******************************************************************************
	public boolean setNom(String paramNom)
	{
    	//Valider le nom reçue en entrée.
		boolean ok = validerNom(paramNom);
		
        //Si il est valide, attribuer sa valeur à l'attribut nom.
		if(ok)
		{
			nom = paramNom;
		}
		
		return ok;
	}
	
    //*******************************************************************************
    // But:		Modifier les gains du joueur à partir de celui reçue en entrée.
    // Sortie :	ok (booléen) : 	indique vrai si les gains du joueur a été modifié.
    //*******************************************************************************
	public boolean setGain(int paramGain)
	{
		//Valider le gain reçue en entrée.
		boolean ok = validerGain(paramGain);
		
        //Si il est valide, attribuer sa valeur à l'attribut gain.
		if(ok)
		{
			gain = paramGain;
		}
		
		return ok;
	}

    //*******************************************************************************
    // But:		Modifier le caractère du joueur à partir de celui reçue en entrée.
    // Sortie :	ok (booléen) : 	indique vrai si le caractère du joueur a été modifié.
    //*******************************************************************************
	public boolean setCaractere(char paramCaractere)
	{
		//Valider le caractère reçue en entrée.
		boolean ok = validerCaractere(paramCaractere);
		
		//Si il est valide, attribuer sa valeur à l'attribut caractere.
		if(ok)
		{
			caractere = paramCaractere;
		}
		
		return ok;
	}
        
	public String toString()
	{
            String temp = getNom() + " : " + getGain() + " Gain(s)";
            return temp;  
	}

    //*******************************************************************************
    // But:		Vérifier si le nom reçue en entreé est valide.
    // Sortie :	Un bolléen : indiquant vrai si c'est un nom valide.
    //*******************************************************************************
	public static boolean validerNom(String paramNom)
	{
        return (paramNom.length() >= LONGUEUR_NOM_MIN && 
                paramNom.length() <= LONGUEUR_NOM_MAX);
	}
	
    //*******************************************************************************
    // But:		Vérifier si le gain reçue en entreé est valide.
    // Sortie :	Un bolléen : indiquant vrai si c'est un gain valide.
    //*******************************************************************************
	public static boolean validerGain(int paramGain)
	{
        return (paramGain >= NOMBRE_GAIN_MIN);
	}

    //*******************************************************************************
    // But:		Vérifier si le caractère reçue en entreé est valide.
    // Sortie :	Un bolléen : indiquant vrai si c'est un caractère valide.
    //*******************************************************************************
	public static boolean validerCaractere(char paramCaractere)
	{
		return (paramCaractere == 'R' ||
				paramCaractere == 'B');
	}
	
    //*******************************************************************************
    // But:		Incrémente le nombre de gain du joueur.
    // Sortie :	Aucune.
    //*******************************************************************************
	public void incrementerGain()
	{
		setGain(gain +1);
	}
	
    //*******************************************************************************
    // But:		Demande un nom à l'utilisateur et vérifie si il est valide.
	// Entrée:	message (string) : message incitant l'utilisateur à entrer le nom du 
	//							   joueur.
    // Sortie :	Un bolléen : indiquant vrai si c'est le nom valide.
    //*******************************************************************************
	public boolean demanderNom(String message)
	{
    	String name;
    	
    	//Demande le nom à l'utilisateur et le stock dans name.
    	name = JOptionPane.showInputDialog(null, 
    			 			message,
    			 			"Saisie",
    			 			JOptionPane.QUESTION_MESSAGE);
    	
    	//Vérifie si l'utilisateur n'a pas clicer sur annuler ou entrée un chaine 
    	//vide. Puis vérifie si le nom est valide. Si non on entre dans la boucle.
    	while (name != null && !setNom(name.toUpperCase()))
    	{
    		//Message d'erreur indiquant que le nom n'est pas valide
    		JOptionPane.showMessageDialog(null,
    					"Ce nom n'est pas valide!",
    					"Erreur",
    					JOptionPane.ERROR_MESSAGE);
    		
        	//Demande le nom à l'utilisateur et le stock dans name.
    		name = JOptionPane.showInputDialog(null, 
		 						message,
		 						"Saisie",
		 						JOptionPane.QUESTION_MESSAGE);
    	}
    	
    	//Retourne faux si l'utilisateur a annulé et vrai sinon.
    	return (name != null);
	}
	
    //*******************************************************************************
    // But:		Faire les tests unitaires sur la classe
    // Sortie :	Aucune
    //*******************************************************************************
	public static void main(String[] args)
	{
	}
	
    //*******************************************************************************
    //But :		Afficher les attributs d'un joueur pour les tests unitaires.
    //Sortie :	Aucune.
    //*******************************************************************************
    public void afficher()
    {
    	//Permet d'afficher les attributs d'un objet de type joueur.
    	System.out.println(nom + "\t" + gain + "\t" + caractere);
    }
}

//***********************************************************************************
//Fichier: 			TakeFive.java
//Description:		Cette classe permet de créer un interface graphique du jeu 
//					TakeFive
//Environement:		Eclipse SDK 3.3.2
//***********************************************************************************
//Version :			2.0
//***********************************************************************************

//Packtage d'extention Java. 
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class TakeFive extends JFrame
{
   public static final int DIMENSION = Jeu.DIMENSION;  // dimension de la grille
   
   // Déclarer les éléments de l'interface
   private JPanel   panneauNord = null,             // Libellés et message
                    panneauNordNord = null, 	    // Libellés
                    panneauNordCentre = null, 	    // Message
                    panneauCentreCentre = null,     // Grille de boutons
                    panneauCentreSud = null; 	    // Boutons du bas 
   
   private JButton[][]  matBouton = null;
   
   private JButton 	btnNouveau = null,
                  	btnAnnuler = null,
                    btnQuitter = null;
   
   private JLabel 	lblNom1 = null, 	  // Nom et gains du joueur1 
                    lblNom2 = null, 	  // Nom et gains du joueur2
                    lblMessage = null;	  // Pour les messages
   
   private EcouteurGrilleBouton btnGrilleEcouteur = null;
   private EcouteurBoutonBas 	btnAction = null;
   private EcouteurFenetre 		ecouteurFenetre = null;
   
   // Les objets de l'application
   private Joueur joueur1; 
   private Joueur joueur2;
   private Jeu unJeu;
   private Color couleur; // couleur courante à jouer
   
   private static int player = 1;

   /********************************************************************************
	*But:		Construire une fenêtre graphique simple.
	*Entrée:	Aucune
	*Sortie:	Aucune
	 *******************************************************************************/
   public TakeFive()
   {
	   //Donner un titre, une dimension et une position àla fenêtre.
	   this.setTitle("TAKE FIVE");
	   this.setSize(600, 400);
	   this.setLocation(0, 0);
	   
	   //Instancier les écouteurs
	   btnGrilleEcouteur = new EcouteurGrilleBouton();
	   btnAction = new EcouteurBoutonBas();
	   ecouteurFenetre = new EcouteurFenetre();
	   
	   //Relier l'écouteur à la fenêtre
	   this.addWindowListener(ecouteurFenetre);
	   
	   //Initialiser le panneau principale de la fenêtre au conteur par défaut
	   Container panPrincipal = this.getContentPane();
	   
	   //Créer les composants graphiques du panneau panneauCentreSud et les ajouter
	   btnNouveau = new JButton("Commencer une partie");
	   btnNouveau.addActionListener(btnAction);
	   btnAnnuler = new JButton("Anuller la partie");
	   btnAnnuler.addActionListener(btnAction);
	   btnAnnuler.setEnabled(false);
	   btnQuitter = new JButton("Quitter");
	   btnQuitter.addActionListener(btnAction);
	   panneauCentreSud = new JPanel();
	   panneauCentreSud.add(btnNouveau);
	   panneauCentreSud.add(btnAnnuler);
	   panneauCentreSud.add(btnQuitter);
	   
	   //Créer les composants du panneau panneauCentreCentre et les ajouter
	   matBouton = new JButton[DIMENSION][DIMENSION];
	   panneauCentreCentre = new JPanel();
	   panneauCentreCentre.setLayout(new GridLayout(10, 10));
	   //Parcourt la matrice et ajoute les boutons 
	   for(int i = 0; i < matBouton.length; i++)
	   {
		   for(int j = 0; j < matBouton[i].length; j++)
		   {
			   matBouton[i][j] = new JButton();
			   matBouton[i][j].setEnabled(false);
			   matBouton[i][j].addActionListener(btnGrilleEcouteur);
			   matBouton[i][j].setBackground(Color.WHITE);
			   panneauCentreCentre.add(matBouton[i][j]);
		   }
	   }
	   
	   //Créer les composants du panneauNordNord et les ajouter
	   panneauNordNord = new JPanel();
	   panneauNordNord.setLayout(new BorderLayout());
	   lblNom1 = new JLabel();
	   lblNom2 = new JLabel();
	   panneauNordNord.add(lblNom1, BorderLayout.WEST);
	   panneauNordNord.add(lblNom2, BorderLayout.EAST);
	   
	   //Créer les composant du panneauNordCentre et les ajouter
	   panneauNordCentre = new JPanel();
	   panneauNordCentre.setLayout(new BorderLayout());
	   lblMessage = new JLabel();
	   panneauNordCentre.add(lblMessage, BorderLayout.WEST);
	   
	   //Ajouter les panneaux au panneauNord
	   panneauNord = new JPanel();
	   panneauNord.setLayout(new BorderLayout());
	   panneauNord.add(panneauNordNord, BorderLayout.NORTH);
	   panneauNord.add(panneauNordCentre, BorderLayout.CENTER);
	   
	   //Ajouter les panneaux au container Principale.
	   panPrincipal.add(panneauNord, BorderLayout.NORTH);
	   panPrincipal.add(panneauCentreSud, BorderLayout.SOUTH);
	   panPrincipal.add(panneauCentreCentre, BorderLayout.CENTER);
	  
   }
     
   /********************************************************************************
    * But:		Initialise la fenêtre pour les besoins d'un début de partie
    * Sortie: 	Aucune
    * Entrée:	Aucune
    *******************************************************************************/
   public void gererNouveau()
   {
	   //Initialise les 2 joueurs.
	   Joueur joueurTemp1 = new Joueur();
	   Joueur joueurTemp2 = new Joueur();
	   
	   //Demande les nom et verifie si ils sont valide.
	   if(joueurTemp1.demanderNom("Tapez le nom du premier joueur:") && 
		  joueurTemp2.demanderNom("Tapez le nom du deuxième joueur:"))
	   {
		   //Création d'une partie
		   unJeu = new Jeu();
		   
		   //Passe les informations de joueurTemp au vrai joueurs.
		   joueur1 = joueurTemp1;
		   joueur2 = joueurTemp2;
		   
		   //Permet l'utilisation du bouton annuler.
		   btnAnnuler.setEnabled(true);
		   
		   //
		   lblNom1.setText(joueur1.toString());
		   lblNom2.setText(joueur2.toString());
		   lblNom1.setForeground(Color.BLUE);
		   lblNom2.setForeground(Color.RED);
		   
		   lblMessage.setText("Message: " + joueur1.getNom() + " à jouer");
		   lblMessage.setForeground(Color.BLUE);
		   
		   //Parcourt la matrice et attribut le couleur blanche au bouttons 
		   //et les rend jouable
		   for(int i = 0; i < matBouton.length; i++)
		   {
			   for(int j = 0; j < matBouton[i].length; j++)
			   {
				   matBouton[i][j].setBackground(Color.WHITE);
				   matBouton[i][j].setEnabled(true);
			   }
		   }  
	   }
	   
   }

   /********************************************************************************
    *But:		Effectuer les coups des joueurs sur la grille.		
	*Entrée: 	i (int):	position en i représentant la ligne	
	*		 	j (int):	position en j représentant la colonne
	*Sortie:	Aucune	
	*******************************************************************************/
   public void jouer(int i, int j)
   {
	   char paramCar = ' ';
	   
	   //Definie les information relative au joueur courant.
	   if(player == 1)
	   {
		   couleur = Color.BLUE;
		   paramCar = 'B';
	   }
	   else
	   {
		   couleur = Color.RED;
		   paramCar = 'R';
	   }
	   
	   //Véerifie si la position clicer est jouable.
	   if(unJeu.verifierPositionJouable (i, j))
	   {
		   //Joue le coup du joueur
		   unJeu.setCar(paramCar, i, j);
		   //Atttribut la bonne couleur au bouton
		   matBouton[i][j].setBackground(couleur);
		   
		   //Vérifie si le coup joué entraine une victoire de la part du joueur.
		   if(unJeu.verifierGain(i, j))
		   {
			   if(player == 1)
			   {
				   joueur1.incrementerGain();
				   JOptionPane.showMessageDialog(null, 
						   "Bravo! " + joueur1.getNom() + " tu as gagné la partie.",
						   "Take Five",
						   JOptionPane.INFORMATION_MESSAGE);
				   lblNom1.setText(joueur1.toString());
				   gererAnnuler();
			   }
			   else
			   {
				   joueur2.incrementerGain();
				   JOptionPane.showMessageDialog(null, 
						   	"Bravo! " + joueur2.getNom() + " tu as gagné la partie.", 
						   	"Take Five", 
						   	JOptionPane.INFORMATION_MESSAGE);
				   lblNom2.setText(joueur2.toString());
				   gererAnnuler();
			   }
		   }
		   
		   //Vérifie si le jeu est plein affiche le message de partie nulle et 
		   //réinitialise une partie
		   if(unJeu.verifierPleine())
		   {
			   JOptionPane.showMessageDialog(null,
					   		"Partie nulle, meilleur chance la prochaine fois !", 
					   		"Take Five", 
					   		JOptionPane.INFORMATION_MESSAGE);
			   gererAnnuler();
		   }
		   
		   //Inverse le joueur
		   player *= -1;
		   
		   //Modifie l'affichage suite au coup joué
		   if(player == 1)
		   {
			   lblMessage.setForeground(Color.BLUE);
			   lblMessage.setText("Message: " + joueur1.getNom() + " à jouer");
		   }
		   else
		   {
			   lblMessage.setForeground(Color.RED);
			   lblMessage.setText("Message: " + joueur2.getNom() + " à jouer");
		   }
	   }
   }
  
	/********************************************************************************
	*But:		Classe permettant de créer des objets d'écouteur d'événements sur une 
    * 			fenêtre. Elle implemente l'interface WindowListener par l'entremise 
    * 			de la classe WindowAdapter.
	*Entrée:	Aucune
	*Sortie:	Aucune
	*******************************************************************************/
   private class EcouteurFenetre extends WindowAdapter
   {
   	/********************************************************************************
   	 * But:		Redéfinir la méthode invoquée lors de sa fermeture.
   	 * Sortie: 	Aucune.	
   	 ********************************************************************************/
     public void windowClosing(WindowEvent Event)
     {
         System.exit(0);
     }
   }
   
   /********************************************************************************
    * But:		Classe permettant de créer des objets d'écoute d'événements sur un 
    * 			bouton de la matrice. Elle implémente l'interface ActionListener.
    * Entrée:	Aucune
    * Sortie:	Aucune
    *******************************************************************************/
   private class EcouteurGrilleBouton implements ActionListener
   {
	  
      public void actionPerformed(ActionEvent Event)
      {
    	  //Récupère l'adresse de l'evenement.
    	  Object adresse = Event.getSource();
    	  
    	  //Parcourt la matrice à la recherche de l'adresse
    	  for(int i = 0; i < matBouton.length; i++)
    	  {
    		  for(int j = 0; j < matBouton[i].length; j++)
    		  {
    			  if(adresse == matBouton[i][j])
    			  {
    				  //Joue le coup du joueur à la position pris pas l'adresse
    				  jouer(i, j);
    				  
    				  //Permet de quitter la boucle une fois l'adresse trouvé
    				  j = DIMENSION - 1;
    				  i = DIMENSION - 1;
    			  }
    		  }
    	  }
      }
    }
    
   /********************************************************************************
    * But:		Classe permettant de créer des objets d'écoute d'événements sur un 
    * 			bouton. Elle implémente l'interface ActionListener.
    * Entrée:	Aucune
    * Sortie:	Aucune
    *******************************************************************************/
   private class EcouteurBoutonBas implements ActionListener
   {
   	/****************************************************************************
   	 * But :	Redéfinir la méthode invoquée lors d'un clic sur un bouton.
   	 * Sortie :	Aucune.
   	 ***************************************************************************/
     public void actionPerformed(ActionEvent Event)
     {
    	 if(Event.getSource() == btnNouveau)
    	 {
     		 gererNouveau();
    	 }
    	 else if(Event.getSource() == btnAnnuler)
    	 {
    		 gererAnnuler();
    	 }
    	 else if(Event.getSource() == btnQuitter)
    	 {
    		 gererQuitter();
    	 }
     }
   }
   
   /********************************************************************************
   *But:		Réinitialise la tableau du jeu pour une nouvelle partie.
   *Entrée:		Aucune
   *Sortie:		Aucune
   *******************************************************************************/
   public void gererAnnuler()
   {
	   for(int i = 0; i < matBouton.length; i++)
	   {
		   for(int j = 0; j < matBouton[i].length; j++)
		   {
			   matBouton[i][j].setBackground(Color.WHITE);
			   unJeu.setCar(' ', i, j);
		   }
	   } 
	   
   }
   
   /********************************************************************************
    *But:		Permet de quitter le programe si l'utilisateur répond oui à la 
    *			confirmation. Cette méthode est appelées lorseque le bouton Quitter 
    *			est pressé.
	*Entrée:	Aucune	
	*Sortie:	Aucune
	*******************************************************************************/
   public void gererQuitter()
   {
   	int reponse;
   	
   	reponse = JOptionPane.showConfirmDialog(null,
   			"Voulez-vous vraiment quitter ?",
   			"LINGO", JOptionPane.YES_NO_OPTION);
   	
   	if(reponse == JOptionPane.YES_OPTION)
   		System.exit(0);
   }
   
   
   /********************************************************************************
    *But:		Créer une instance de TakeFive
	*Entrée:	Aucune
	*Sortie:	Aucune
	*******************************************************************************/
   public static void main(String arg[])
   {
	   TakeFive app = new TakeFive();
	   app.setVisible(true);
   } 
}