<repo_name>EtsSimon9/BoardPro<file_sep>/BoardPro/src/map/ComposantMap.java
package map;

import utilitaire.Images;

/**
 * classe abstraite de composantes contenant les proprietes propres a une map de
 * celles-ci
 *
 * @author <NAME>
 *
 */
public abstract class ComposantMap implements Comparable<ComposantMap>, Point {

	private short coordonneX;
	private short coordonneY;
	private Images image;
	
	public ComposantMap(short x, short y,Images image) {
		if (image != null) {
			this.setImage(image);
		}
		setCoordonneX(x);
		setCoordonneY(y);
	}



	
	public Images getImage() {
		return image;
	}




	public void setImage(Images image) {
		this.image = image;
	}




	@Override
	public short getCoordonneY() {
		return coordonneY;
	}


	@Override
	public short getCoordonneX() {
		return coordonneX;
	}


	@Override
	public void setCoordonneX(short coordonnex) {
		this.coordonneX = coordonnex;
	}


	@Override
	public void setCoordonneY(short coordonney) {
		this.coordonneY = coordonney;
	}


	@Override
	public int compareTo(ComposantMap obj) {
		return (Math.sqrt(coordonneX) + Math.sqrt(coordonneY)) >= (Math.sqrt(obj.getCoordonneX())
				+ Math.sqrt(obj.getCoordonneY())) ? 1 : 0;
	}

}
<file_sep>/BoardPro/src/tests/CalculTest.java
package tests;

import static org.junit.Assert.*;

import org.junit.Test;

import utilitaire.Calcul;
import exceptions.MathException;

public class CalculTest {

	@Test
	public void testFrequenceTofrequenceAngulaire() {
		float f = 20;
		assertTrue(Calcul.frequenceTofrequenceAngulaire(f) == (float) (f * 2 * Math.PI));
	}

	@Test
	public void testFrequenceAngulaireTofrequence() {
		float fa = 20;
		assertTrue(Calcul.frequenceAngulaireTofrequence(fa) == (float) (fa / (2 * Math.PI)));
	}

	@Test
	public void testCapaciteCondensateur() {
		float ddp = 20;
		float q = 40;
		try {
			assertTrue(Calcul.capaciteCondensateur(ddp, q) == 2);
		} catch (MathException e) {
			fail();
		}

		try {
			Calcul.capaciteCondensateur(0, q);
			fail();
		} catch (MathException e) {

		}
	}

	@Test
	public void testChargeCondensateur() {
		assertTrue(Calcul.chargeCondensateur(20, 10) == 200);

	}

	@Test
	public void testDdpCondensateur() {
		try {
			assertTrue(Calcul.ddpCondensateur(10, 200) == 20);
		} catch (MathException e) {
			fail();
		}

		try {
			Calcul.ddpCondensateur(0, 20);
			fail();
		} catch (MathException e) {
		}

	}

	@Test
	public void testCapaciteCondensateurPlan() {
		try {
			Calcul.capaciteCondensateurPlan(50, 0);
			fail();
		} catch (MathException e) {
		}

		try {
			assertTrue(Calcul.capaciteCondensateurPlan(20, 20) == (float) Calcul.epsilon);
		} catch (MathException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	@Test
	public void testCapaciteCondensateurCylindrique() {
		try {
			Calcul.capaciteCondensateurCylindrique(20, 20, -1);
			fail();
		} catch (MathException e) {
		}

		try {
			assertTrue(Calcul.capaciteCondensateurCylindrique(20, 20, 40) == (float) (10 / ((Calcul.k) * Math.log(2))));
		} catch (MathException e) {
			fail();
		}
	}

	@Test
	public void testCapaciteCondensateurSpherique() {
		try {
			Calcul.capaciteCondensateurSpherique(20, -20);
			fail();
		} catch (MathException e) {
		}
		
		try {
			assertTrue(Calcul.capaciteCondensateurSpherique(20, 40) == (float) (4*Math.PI*Calcul.epsilon*20*40/(20)));
		} catch (MathException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	@Test
	public void testCalculResistance() {
		try {
			Calcul.calculResistance(20, 20, 0);
			fail();
		} catch (MathException e) {
		}
		
		try {
			assertTrue(Calcul.calculResistance(20, 20, 2) == (float) (400/(Math.PI*4)));
		} catch (MathException e) {
			fail();
		}
	}

	@Test
	public void testResistiviteEtTemperature() {
		assertTrue(Calcul.resistiviteEtTemperature(2, 20, 30, 5) == 102);
	}

	@Test
	public void testLoiOhmR() {
		try {
			Calcul.loiOhmR(20, 0);
			fail();
		} catch (MathException e) {
		}
		
		try {
			assertTrue(Calcul.loiOhmR(20, 2) == (float) (10));
		} catch (MathException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	@Test
	public void testLoiOhmDDP() {
		assertTrue(Calcul.loiOhmDDP(20, 2) == 40);
	}

	@Test
	public void testLoiOhmI() {
		try {
			Calcul.loiOhmI(0, 40);
			fail();
		} catch (MathException e) {
		}
		
		try {
			assertTrue(Calcul.loiOhmI(20, 40) == 2);
		} catch (MathException e) {
			fail();
		}
	}

	@Test
	public void testChargeCondensateurDecharge() {
	}

	@Test
	public void testDdpCondesateurDecharge() {
	}

	@Test
	public void testCourantCondensateurDecharge() {
	}

	@Test
	public void testChargeCondensateurCharge() {
	}

	@Test
	public void testDdpCondesateurCharge() {
	}

	@Test
	public void testCourantCondensateurCharge() {
	}

	@Test
	public void testCourantDeplug() {
	}

	@Test
	public void testCourantPlug() {
	}

	@Test
	public void testImpedanceCircuitRLC() {
	}

	@Test
	public void testImpedanceCondensateur() {
	}

	@Test
	public void testImpedanceBobine() {
	}

}
<file_sep>/BoardPro/src/utilitaire/Calcul.java
package utilitaire;

import exceptions.MathException;
import vue.ControleurVue;

/**
 * Classe remplit de calcul utile en �lectricit�, toutes les formules et quelque
 * constante utile vue lors de notre cours d'�lectricit� y sont. Des
 * commentaires s�pares les sections pour mieux s'y retrouver. Ajouter des
 * m�thode de calculs au besoins.
 *
 * @author <NAME>
 *
 */
public class Calcul {
	public static final double chargeE = 1.602 * Math.pow(10, -19);
	public static final double masseElectron = 9.109 * Math.pow(10, -31);
	public static final double masseProton = 1.672 * Math.pow(10, -27);
	public static final double k = 9 * Math.pow(10, 9);
	public static final double epsilon = 8.854 * Math.pow(10, -12);

	/*
	 * Section calcul de fr�quence
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 */
	/**
	 * Prend une fr�quence (en Hz) et retourne la fr�quence angulaire (en rad/s)
	 */
	public static float frequenceTofrequenceAngulaire(float frequence) {
		return (float) (2 * Math.PI * frequence);
	}

	/**
	 * Prend une fr�quence angulaire (en rad/s) et retourne la fr�quence (en Hz)
	 */
	public static float frequenceAngulaireTofrequence(float frequenceAngulaire) {
		return (float) (frequenceAngulaire / (2 * Math.PI));
	}

	/*
	 * Section Condensateur
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 */
	/**
	 * Donne la capacit� du condensateur, ce calcul � besoin de la diff�rence de
	 * potentielle et la charge sur le condensateur
	 */
	public static float capaciteCondensateur(float ddp, float q) throws MathException {
		float c = 0;
		if (ddp != 0) {
			c = q / ddp;
		} else {
			throw new MathException("Charge du condensateur null!");
		}
		return c;
	}

	/**
	 * Donne la charge sur le condensateur, ce calcul � besoin de la diff�rence de
	 * potentielle et la capacit� du condensateur
	 */
	public static float chargeCondensateur(float ddp, float c) {
		return ddp * c;
	}

	/**
	 * Donne la diff�rence de potentielle au bornes du condensateur, ce cacul �
	 * besoin de la capacit� du condensateur et de la charge sur celui-ci.
	 */
	public static float ddpCondensateur(float c, float q) throws MathException {
		float ddp = 0;
		if (c != 0) {
			ddp = q / c;
		} else {
			throw new MathException("Charge du condensateur = 0!");
		}
		return ddp;
	}

	/**
	 * Utile pour des condensateurs customs, calcul de la capacite d'un condensateur
	 * plan. Ce calcul � besoin de l'aire des branches qui peuvent �tre
	 * carr�,rectangle,cercle donc on se contente de recevoir l'aire en param, et
	 * aussi la distance entre les deux branches
	 */
	public static float capaciteCondensateurPlan(float aire, float distance) throws MathException {
		float capacite = 0;
		if (distance != 0) {
			capacite = (float) (Calcul.epsilon * aire / distance);
		} else {
			throw new MathException("distance entre 2 armatures de condensateur null!");
		}
		return capacite;
	}

	/**
	 * Utile pour des condensateurs customs, calcul de la capacite d'un condensateur
	 * cylindrique Ce calcul � besoin de la longueur des cylindres, le rayonA du
	 * plus petit et le rayonB du plus grand.
	 */
	public static float capaciteCondensateurCylindrique(float longueur, float rayonA, float rayonB)
			throws MathException {
		float capacite = 0;
		if (rayonA > 0 && rayonB > 0) {
			capacite = (float) (longueur / (2 * Calcul.k * Math.log(rayonB / rayonA)));
		} else {
			throw new MathException("Rayon du condensateur cylindrique invalide");
		}
		return capacite;
	}

	/**
	 * Utile pour des condensateurs customs, calcul de la capacit� d'un condensateur
	 * spherique. Ce calcul � besoin du rayon de la petite sph�re rayonA et du rayon
	 * de la grande sph�re rayonB
	 */
	public static float capaciteCondensateurSpherique(float rayonA, float rayonB) throws MathException {
		float capacite = 0;
		if (rayonB > rayonA) {
			capacite = (float) (4 * Math.PI * Calcul.epsilon * rayonA * rayonB / (rayonB - rayonA));
		} else {
			throw new MathException("Rayon du condensateur cylindrique invalide");
		}
		return capacite;
	}

	/*
	 * Section r�sistor
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 */

	/**
	 * Calcul de la r�sistance d'une r�sistance custom. Ce calcul � besoin de la
	 * r�sistivit� du mat�riau p, de la longueur de la r�sistance et du rayon du
	 * fil/r�sistor
	 * @throws MathException 
	 */
	public static float calculResistance(double p, float l, float rayon) throws MathException {
		float r = 0;
		if (rayon != 0) {
			r = (float) ((p * l) / (Math.PI * rayon * rayon));
		} else {
			throw new MathException("Rayon de la résistance null!");
		}
		return r;
	}

	/**
	 * Calcul de la r�sistivit� (variant avec la temp�rature) custom d'une
	 * r�sistance custom. Ce calcul � besoin de la r�sistvit� du mat�riaux � 20� pi,
	 * de la temp�rature initiale ti (20� souvent) , de la temp�rature finale et du
	 * coefficient thermique (le symbole est alpha) Voir p.199 du Lafrance pour +
	 * d'info.
	 */
	public static double resistiviteEtTemperature(double resisti, float ti, float tf, double coef) {
		float deltaT = tf - ti;
		return (resisti * (1 + (coef * deltaT)));
	}

	/**
	 * Calcul loi d'ohm trouvant la r�sistance
	 */
	public static float loiOhmR(float ddp, float i) throws MathException {
		float retour;

		if (i != 0) {
			retour = ddp / i;
		} else {
			throw new MathException("division par zero!");
		}
		return retour;
	}

	/**
	 * Calcul loi d'ohm trouvant la diff�rence de potentielle
	 */
	public static float loiOhmDDP(float r, float i) {
		return r * i;
	}

	/**
	 * Calcul loi d'ohm trouvant le courant I
	 */
	public static float loiOhmI(float r, float ddp) throws MathException {
		float retour;

		if (r != 0) {
			retour = ddp / r;
		} else {
			throw new MathException("division par zero!");
		}
		return retour;
	}

	/*
	 * Section circuit RC : r�sistance condensateur
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 */
	/**
	 * Circuit RC Calcul trouvant la charge d'un condensateur qui est en d�charge,
	 * cette charge varie dans le temps selon une exponentielle inverse. Ce calcul �
	 * besoin de la charge maximale du condensateur, du temps �coul� depuis le d�but
	 * de la d�charge, de la r�sistance du r�sistor dans le circuit et de la
	 * capacit� du condensateur
	 */
	public static float ChargeCondensateurDecharge(float ChargeMax, float t, float R, float C) {
		return (float) (ChargeMax * Math.exp((-t) / (R * C)));
	}

	/**
	 * Circuit RC Calcul trouvant la diff�rence de potentielle d'un condensateur qui
	 * est en d�charge, cette DDP varie dans le temps selon une exponentielle
	 * inverse. Ce calcul � besoin de la diff�rence de potentielle maximale du
	 * condensateur, du temps �coul� depuis le d�but de la d�charge, de la
	 * r�sistance du r�sistor dans le circuit et de la capacit� du condensateur
	 */
	public static float ddpCondesateurDecharge(float ddpMax, float t, float R, float C) {
		return (float) (ddpMax * Math.exp((-t) / (R * C)));
	}

	/**
	 * Circuit RC Calcul trouvant le courant d'un condensateur qui est en d�charge,
	 * ce courant varie dans le temps selon une exponentielle inverse. Ce calcul �
	 * besoin du courant maximal du condensateur, du temps �coul� depuis le d�but de
	 * la d�charge, de la r�sistance du r�sistor dans le circuit et de la capacit�
	 * du condensateur
	 */
	public static float courantCondensateurDecharge(float courantMax, float t, float R, float C) {
		return (float) (courantMax * Math.exp((-t) / (R * C)));
	}

	/**
	 * Circuit RC Calcul trouvant la charge d'un condensateur qui est en charge,
	 * cette charge varie dans le temps selon un exponentielle. Ce calcul � besoin
	 * de la charge maximal du condensateur, du temps �coul� depuis le d�but de la
	 * charge, de la r�sistance du r�sistor dans le circuit et de la capacit� du
	 * condensateur
	 */
	public static float ChargeCondensateurCharge(float ChargeMax, float t, float R, float C) {
		return (float) (ChargeMax * (1 - Math.exp((-t) / (R * C))));
	}

	/**
	 * Circuit RC Calcul trouvant la diff�rence de potentielle d'un condensateur qui
	 * est en charge, cette DDP varie dans le temps selon un exponentielle. Ce
	 * calcul � besoin de la DDP maximal du condensateur, du temps �coul� depuis le
	 * d�but de la charge, de la r�sistance du r�sistor dans le circuit et de la
	 * capacit� du condensateur.
	 */
	public static float ddpCondesateurCharge(float ddpMax, float t, float R, float C) {
		return (float) (ddpMax * (1 - Math.exp((-t) / (R * C))));
	}

	/**
	 * Circuit RC Calcul trouvant le courant dans un d'un condensateur qui est en
	 * charge, ce courant varie dans le temps selon un exponentielle. Ce calcul �
	 * besoin du courant maximal du condensateur, du temps �coul� depuis le d�but de
	 * la charge, de la r�sistance du r�sistor dans le circuit et de la capacit� du
	 * condensateur.
	 */
	public static float courantCondensateurCharge(float courantMax, float t, float R, float C) {
		return (float) (courantMax * (1 - Math.exp((-t) / (R * C))));
	}

	/*
	 * Section circuit RL: r�sistance bobine d'inductance
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 */
	/**
	 * Circuit RL Calcul trouvant le courant dans le circuit RL suite � l'ouverture
	 * du circuit, ce courant varie dans le temps selon une exponentiel inverser
	 * (chute de courant amortie, max a min avec courbe)
	 */
	public static float CourantDeplug(float CourantMax, float t, float R, float L) {
		return (float) (CourantMax * Math.exp((-t * R) / L));
	}

	/**
	 * Circuit RL Calcul trouvant le courant dans le circuit RL suite � la fermeture
	 * du circuit Le cournat varie dans le temps selon une exponentiel (augmentation
	 * rapide de courant amortie)
	 */
	public static float CourantPlug(float CourantMax, float t, float R, float L) {
		return (float) (1 - (CourantMax * Math.exp((-t * R) / L)));
	}

	/*
	 * Section circuit RLC: R�sistance, bobine d'inductance et condensateur
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 *
	 */
	/**
	 * Circuit RLC Trouve l'impedance/r�sistance d'un circuit RLC
	 */
	public static float impedanceCircuitRLC(float resistance, float inductance, float capacite, float frequence)
			throws MathException {
		float z = 0;
		if (resistance >= 0 && capacite >= 0 && inductance >= 0) {
			float freqAngulaire = Calcul.frequenceTofrequenceAngulaire(frequence);
			float xc = Calcul.impedanceCondensateur(freqAngulaire, capacite);
			float xl = Calcul.impedanceBobine(freqAngulaire, inductance);
			z = (float) Math.sqrt(Math.pow(resistance, 2) + Math.pow(xl-xc, 2) );
		} else {
			throw new MathException("Resistance, inductance ou capacite n�gative dans le calcul d'imp�dence RLC");
		}
		return z;
	}

	/**
	 * Calcul l'impedance d'un condensateur
	 */
	public static float impedanceCondensateur(float frequence, float capacite) throws MathException {
		float impedanceCondensateur = 0;
		if (frequence != 0 && capacite != 0) {
			float freqangulaire = Calcul.frequenceTofrequenceAngulaire(frequence);
			impedanceCondensateur = 1 / (freqangulaire * capacite);
		} else {
			throw new MathException("frequence ou capacite nul!");
		}
		return impedanceCondensateur;

	}

	/**
	 * Calcul l'impedance d'une bobine
	 */
	public static float impedanceBobine(float frequence, float inductance) {
		float impedanceBobine = 0;

		float freqangulaire = Calcul.frequenceTofrequenceAngulaire(frequence);
		impedanceBobine = freqangulaire * inductance;
		return impedanceBobine;

	}
	
	/**
	 * Puisque la méthode get des gridPanes n'existe pas et on doit aller dans la liste des childrens,
	 * cette méthode s'occupe de nous dire à quel position une composante est dans la children list en fonction
	 * de sa position
	 * @param x
	 * @param y
	 * @return Retourne la position ou -1 si pas trouver
	 */
	public static int positionDansGrille(int x,int y,ControleurVue vue) {
		int position = -1;
		
		for (int i = 0; i < vue.gridP.getChildren().size();i++) {
			int px = (int) (Math.floor((vue.gridP.getChildren().get(i).getLayoutX() + 50) / 75));
			int py = (int) (Math.floor((vue.gridP.getChildren().get(i).getLayoutY() + 20 )/ 75));
			if (px == x && py == y) {
				position = i;
			}
		}
		
		return position;
	}
}
<file_sep>/BoardPro/src/application/MainApp.java
package application;

import controleur.ControleurBoardPro;
import javafx.application.Application;
import javafx.stage.Stage;
import javafx.stage.StageStyle;
import javafx.stage.Window;
import vue.ControleurVue;

public class MainApp extends Application {

	private ControleurBoardPro controleur;
	private ControleurVue vue;

	public static void main(String[] args) {
		Application.launch(args);
	}

	@Override
	public void start(Stage primaryStage) throws Exception {
		controleur = new ControleurBoardPro();
		vue = controleur.getVue();
		controleur.masterHandler();

		primaryStage.setScene(vue.getScene());
		primaryStage.initStyle(StageStyle.UNDECORATED);
		primaryStage.show();
		primaryStage.setResizable(false);
	}

	public static Window getStage() {
		// TODO Auto-generated method stub
		return null;
	}

}
<file_sep>/BoardPro/src/utilitaire/Images.java
package utilitaire;

import java.util.ArrayList;
import java.util.HashSet;

import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import map.ComposantMap;

public class Images {
	public enum Composante {
		FilH, FilV, FilBD, FilBG, FilHG, FilHD, FilGBD, FilGHD, FilBGH, FilBDH, FilAll, Résistance, Condensateur,
		Bobine, Ampoule, Source
	};

	private byte positionX;
	private byte positionY;
	private ImageView view;
	private Image image;
	private Composante nom;
	private static final short DIMMENSIONS = 75;
	private int rotation = 0;
	private String equationDDP = "";
	private ComposantMap c;
	/**
	 * dghb :Droite Gauche Haut Bas, si une image est directement à gauche de cette
	 * image, la 2e valeur de l'arraylist est 1, sinon 0. Droite:1er position,
	 * Gauche 2e position, Haut 3e et Bas 4e dans l'array
	 */
	private byte[] dghb;

	public Images(Composante nom, byte px, byte py) {
		if (nom != null) {
			this.setNom(nom);
		}
		dghb = new byte[4];
		this.setPositionX(px);
		this.setPositionY(py);
		creerImage(nom);
		creerView();
	}

	
	
	public ComposantMap getC() {
		return c;
	}



	public void setC(ComposantMap c) {
		this.c = c;
	}



	public String getEquationDDP() {
		return equationDDP;
	}


	public void setEquationDDP(String equationDDP) {
		this.equationDDP = equationDDP;
	}


	public int getRotation() {
		return rotation;
	}

	public void setRotation(int rotation) {
		this.rotation = rotation;
	}

	public Composante getNom() {
		return nom;
	}

	public void setNom(Composante nom) {
		this.nom = nom;
	}

	public byte getPositionX() {
		return positionX;
	}

	public void setPositionX(byte positionX) {
		this.positionX = positionX;
	}

	public byte getPositionY() {
		return positionY;
	}

	public void setPositionY(byte positionY) {
		this.positionY = positionY;
	}

	public ImageView getView() {
		return view;
	}

	public void setView(ImageView view) {
		this.view = view;
	}

	public Image getImage() {
		return image;
	}

	public void setImage(Image image) {
		this.image = image;
	}

	public void creerImage(Composante nom) {
		Image i = null;

		if (nom.equals(Composante.Résistance)) {
			i = new Image("/img/Composante_resistance.png");
		} else if (nom.equals(Composante.Condensateur)) {
			i = new Image("/img/condensateur.png");
		} else if (nom.equals(Composante.Bobine)) {
			i = new Image("/img/bobine.png");
		} else if (nom.equals(Composante.FilAll)) {
			i = new Image("/img/4way.png");
		} else if (nom.equals(Composante.FilH)) {
			i = new Image("/img/Composante_fil.png");
			this.setRotation(0);
			
		} else if (nom.equals(Composante.FilV)) {
			i = new Image("/img/Composante_fil.png");
			this.setRotation(90);
		} else if (nom.equals(Composante.FilBD)) {
			i = new Image("/img/coin.png");
			this.setRotation(180);
		} else if (nom.equals(Composante.FilBG)) {
			i = new Image("/img/coin.png");
			this.setRotation(270);
		} else if (nom.equals(Composante.FilHD)) {
			i = new Image("/img/coin.png");
			this.setRotation(90);
		} else if (nom.equals(Composante.FilHG)) {
			i = new Image("/img/coin.png");
			this.setRotation(0);
		} else if (nom.equals(Composante.FilBGH)) {
			i = new Image("/img/3 way.png");
			this.setRotation(270);
		} else if (nom.equals(Composante.FilBDH)) {
			i = new Image("/img/3 way.png");
			this.setRotation(90);
		} else if (nom.equals(Composante.FilGBD)) {
			i = new Image("/img/3 way.png");
			this.setRotation(180);
		} else if (nom.equals(Composante.FilGHD)) {
			i = new Image("/img/3 way.png");
			this.setRotation(0);
		} else if (nom.equals(Composante.Source)) {
			i = new Image("/img/source.png");
		} else if (nom.equals(Composante.Ampoule)) {
			i = new Image("/img/ampouleEteinte.png");
		}
		this.setImage(i);
	}

	public void creerView() {
		ImageView v = null;
		if (image != null) {
			v = new ImageView(this.getImage());
			v.setFitWidth(DIMMENSIONS);
			v.setFitHeight(DIMMENSIONS);
			v.setRotate(this.getRotation());
		}
		this.setView(v);
	}

	public byte[] getDghb() {
		return dghb;
	}

	public void setDghb(byte[] dghb) {
		this.dghb = dghb;
	}

	/**
	 * 
	 * @param listeImage
	 * @return Retourne un tableau des index des composantes qui doivent être
	 *         changer (on a ajouter qq chose près)
	 */
	public HashSet<Byte> composanteProche(ArrayList<Images> listeImage) {
		HashSet<Byte> indexaModif = new HashSet<Byte>();
		// Vérification à Droite
		for (int i = 0; i < listeImage.size(); i++) {
			if (listeImage.get(i).getPositionX() == positionX + 1 && listeImage.get(i).getPositionY() == positionY) {
				this.dghb[0] = 1;
				// Puisque l'image à gauche doit aussi considérer l'image actuelle à sa droite
				listeImage.get(i).getDghb()[1] = 1;
				indexaModif.add((byte) i);
			}
		}

		// Vérification à Gauche
		for (int i = 0; i < listeImage.size(); i++) {
			if (listeImage.get(i).getPositionX() == positionX - 1 && listeImage.get(i).getPositionY() == positionY) {
				this.dghb[1] = 1;
				// Puisque l'image à gauche doit aussi considérer l'image actuelle à sa droite
				listeImage.get(i).getDghb()[0] = 1;
				indexaModif.add((byte) i);
			}
		}

		// Vérification Haut
		for (int i = 0; i < listeImage.size(); i++) {
			if (listeImage.get(i).getPositionX() == positionX && listeImage.get(i).getPositionY() == positionY - 1) {
				this.dghb[2] = 1;
				// Puisque l'image à gauche doit aussi considérer l'image actuelle à sa gauche
				listeImage.get(i).getDghb()[3] = 1;
				indexaModif.add((byte) i);
			}
		}

		// Vérification Bas
		for (int i = 0; i < listeImage.size(); i++) {
			if (listeImage.get(i).getPositionX() == positionX && listeImage.get(i).getPositionY() == positionY + 1) {
				this.dghb[3] = 1;
				// Puisque l'image à gauche doit aussi considérer l'image actuelle à sa gauche
				listeImage.get(i).getDghb()[2] = 1;
				indexaModif.add((byte) i);
			}
		}
		return indexaModif;
	}

	public Composante choisirImage(Images i) {
		Composante retour = null;

		if (i.dghb[2] == 1 || i.dghb[3] == 1) {
			i.setRotation(90);
		}
		if (i.dghb[0] == 1 || i.dghb[1] == 1) {
			i.setRotation(0);
		}
		if (i.dghb[2] == 1 && i.dghb[3] == 1) {
			i.setRotation(90);
		}
		if (i.dghb[0] == 1 && i.dghb[1] == 1) {
			i.setRotation(0);
		}
		if (i.getNom().toString().substring(0, 3).equals("Fil")) {
			retour = choisirImageFil(i);
		}

		else if (i.getNom().equals(Composante.Condensateur)) {
			retour = Composante.Condensateur;

		} else if (i.getNom().equals(Composante.Ampoule)) {
			retour = Composante.Ampoule;
		} else if (i.getNom().equals(Composante.Bobine)) {
			retour = Composante.Bobine;
		} else if (i.getNom().equals(Composante.Résistance)) {
			retour = Composante.Résistance;
		} else if (i.getNom().equals(Composante.Source)) {
			retour = Composante.Source;
		}
		return retour;
	}

	public Composante choisirImageFil(Images i) {
		Composante retour = Composante.FilH;

		if (i.getDghb()[0] == 1 && i.getDghb()[1] == 1 && i.getDghb()[2] == 1 && i.getDghb()[3] == 1) {
			retour = Composante.FilAll;

		} else if (i.getDghb()[0] == 1 && i.getDghb()[1] == 1 && i.getDghb()[2] == 1
				&& i.getDghb()[3] == 0) {
			retour = Composante.FilGHD;

		} else if (i.getDghb()[0] == 1 && i.getDghb()[1] == 1 && i.getDghb()[2] == 0
				&& i.getDghb()[3] == 1) {
			retour = Composante.FilGBD;

		} else if (i.getDghb()[0] == 1 && i.getDghb()[1] == 0 && i.getDghb()[2] == 1
				&& i.getDghb()[3] == 1) {
			retour = Composante.FilBDH;

		} else if (i.getDghb()[0] == 0 && i.getDghb()[1] == 1 && i.getDghb()[2] == 1
				&& i.getDghb()[3] == 1) {
			retour = Composante.FilBGH;

		} else if (i.getDghb()[0] == 1 && i.getDghb()[1] == 0 && i.getDghb()[2] == 0
				&& i.getDghb()[3] == 1) {
			retour = Composante.FilBD;

		} else if (i.getDghb()[0] == 0 && i.getDghb()[1] == 1 && i.getDghb()[2] == 0
				&& i.getDghb()[3] == 1) {
			retour = Composante.FilBG;

		} else if (i.getDghb()[0] == 0 && i.getDghb()[1] == 1 && i.getDghb()[2] == 1
				&& i.getDghb()[3] == 0) {
			retour = Composante.FilHG;

		} else if (i.getDghb()[0] == 1 && i.getDghb()[1] == 0 && i.getDghb()[2] == 1
				&& i.getDghb()[3] == 0) {
			retour = Composante.FilHD;

		}
		if (i.getDghb()[0] == 1 && i.getDghb()[1] == 1 && i.getDghb()[2] == 0 && i.getDghb()[3] == 0) {
			retour = Composante.FilH;

		} else if (i.getDghb()[0] == 0 && i.getDghb()[1] == 0 && i.getDghb()[2] == 1
				&& i.getDghb()[3] == 1) {
			retour = Composante.FilV;

		} else if (i.getDghb()[0] == 0 && i.getDghb()[1] == 0 && i.getDghb()[2] == 1
				&& i.getDghb()[3] == 0) {
			retour = Composante.FilV;
		} else if (i.getDghb()[0] == 0 && i.getDghb()[1] == 0 && i.getDghb()[2] == 0
				&& i.getDghb()[3] == 1) {
			retour = Composante.FilV;
		}
		return retour;
	}
	
	public HashSet<Byte> modifierAutourRetrait(ArrayList<Images> listeImage) {
		HashSet<Byte> indexaModif = new HashSet<Byte>();
		// Vérification à Droite
				for (int i = 0; i < listeImage.size(); i++) {
					if (listeImage.get(i).getPositionX() == positionX + 1 && listeImage.get(i).getPositionY() == positionY) {
						listeImage.get(i).getDghb()[1] = 0;
						indexaModif.add((byte) i);
					}
				}

				// Vérification à Gauche
				for (int i = 0; i < listeImage.size(); i++) {
					if (listeImage.get(i).getPositionX() == positionX - 1 && listeImage.get(i).getPositionY() == positionY) {
						// Puisque l'image à gauche doit aussi considérer l'image actuelle à sa droite
						listeImage.get(i).getDghb()[0] = 0;
						indexaModif.add((byte) i);
					}
				}

				// Vérification Haut
				for (int i = 0; i < listeImage.size(); i++) {
					if (listeImage.get(i).getPositionX() == positionX && listeImage.get(i).getPositionY() == positionY - 1) {
						// Puisque l'image à gauche doit aussi considérer l'image actuelle à sa gauche
						listeImage.get(i).getDghb()[3] = 0;
						indexaModif.add((byte) i);
					}
				}

				// Vérification Bas
				for (int i = 0; i < listeImage.size(); i++) {
					if (listeImage.get(i).getPositionX() == positionX && listeImage.get(i).getPositionY() == positionY + 1) {
						// Puisque l'image à gauche doit aussi considérer l'image actuelle à sa gauche
						listeImage.get(i).getDghb()[2] = 0;
						indexaModif.add((byte) i);
					}
				}
				return indexaModif;
	}
}
<file_sep>/BoardPro/src/tests/MapParcourableTest.java
package tests;


import static org.junit.Assert.assertTrue;

// --------

import java.util.ArrayList;

import org.ejml.simple.SimpleMatrix;
import org.junit.Before;
import org.junit.Test;

import composantesCircuit.Fil;
import composantesCircuit.Resistance;
import exceptions.ComposantException;
import map.ComposantMap;
import map.MapParcourable;
import utilitaire.MatriceUtilitaires;

public class MapParcourableTest {
	MapParcourable map1, map2, map3,map4;
	Resistance res1, res2, res3, res4, res5;

	@Before
	public void mapParcourableTest() {
		map1 = new MapParcourable();
		map2 = new MapParcourable();
		map3 = new MapParcourable();
		map4 = new MapParcourable();
		try {
			res1 = new Resistance(0,(short) 0, (short) 0,null);
			res2 = new Resistance(0,(short) 0, (short) 1,null);
			res3 = new Resistance(0,(short) 1, (short) 0,null);
			res4 = new Resistance(0,(short) 1, (short) 3,null);
			res5 = new Resistance(0,(short) 3, (short) 1,null);
		} catch (ComposantException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	
	@Test 
	public void testgenrerNoeuds() {
		Fil fil1, fil3, fil5, fil7;
		Resistance res6 = null, res8 = null;
		// voici un circtuit de forme
		//
		// o-o
		// | |
		// o-o
		// les {-,|} sont des resistances et {o} representent des composantes

		try {
			fil1 = new Fil((short) 30, (short) 30,null);

		res2 = new Resistance(0,(short) 30, (short) 31,null);
		fil3 = new Fil((short) 30, (short) 32,null);
		res4 = new Resistance(0,(short) 31, (short) 32,null);
		res4.setSens(true);
		fil5 = new Fil((short) 32, (short) 32,null);
		res6 = new Resistance(0,(short) 32, (short) 31,null);
		fil7 = new Fil((short) 32, (short) 30,null);
		res8 = new Resistance(0,(short) 31, (short) 30,null);
		res8.setSens(true);
		map1.addComposant(fil1);
		map1.addComposant(res2);
		map1.addComposant(fil3);
		map1.addComposant(res4);
		map1.addComposant(fil5);
		map1.addComposant(res6);
		map1.addComposant(fil7);
		map1.addComposant(res8);

		} catch (ComposantException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	map1.genrerNoeuds();
	assertTrue(map1.getNoeudsCircuit().size()==0);
	Fil fil10, fil12;
	Resistance res9, res11 = null, res13 = null;
	try {
		// voici un circtuit de forme
		//
		// o-o-o
		// | | |
		// o-o-o
		// les {-,|} sont des resistances et {o} representent des composantes

		fil1 = new Fil((short) 0, (short) 0,null);
		res2 = new Resistance(0,(short) 0, (short) 1,null);
		fil3 = new Fil((short) 0, (short) 2,null);
		res4 = new Resistance(0,(short) 1, (short) 2,null);
		res4.setSens(true);
		fil5 = new Fil((short) 2, (short) 2,null);
		res6 = new Resistance(0,(short) 2, (short) 1,null);
		fil7 = new Fil((short) 2, (short) 0,null);
		res8 = new Resistance(0,(short) 1, (short) 0,null);
		res8.setSens(true);
		res9 = new Resistance(0,(short) 0, (short) 3,null);
		fil10 = new Fil((short) 0, (short) 4,null);
		res11 = new Resistance(0,(short) 1, (short) 4,null);
		res11.setSens(true);
		fil12 = new Fil((short) 2, (short) 4,null);
		res13 = new Resistance(0,(short) 2, (short) 3,null);

		map2.addComposant(fil1);
		map2.addComposant(res2);
		map2.addComposant(fil3);
		map2.addComposant(res4);
		map2.addComposant(fil5);
		map2.addComposant(res6);
		map2.addComposant(fil7);
		map2.addComposant(res8);
		map2.addComposant(res9);
		map2.addComposant(fil10);
		map2.addComposant(res11);
		map2.addComposant(fil12);
		map2.addComposant(res13);

	} catch (ComposantException e1) {
		// TODO Auto-generated catch block
		e1.printStackTrace();
	}
	map2.genrerNoeuds();
	assertTrue(map2.getNoeudsCircuit().size()==2);

	}


	
	@Test
	public void testGetMaillsesCircuitsFermes() {
		Fil fil1, fil3, fil5, fil7;
		Resistance res6, res8;
		try {
			// voici un circtuit de forme
			//
			// o-o
			// | |
			// o-o
			// les {-,|} sont des resistances et {o} representent des composantes

			fil1 = new Fil((short) 30, (short) 30,null);
			res2 = new Resistance(0,(short) 30, (short) 31,null);
			fil3 = new Fil((short) 30, (short) 32,null);
			res4 = new Resistance(0,(short) 31, (short) 32,null);
			res4.setSens(true);
			fil5 = new Fil((short) 32, (short) 32,null);
			res6 = new Resistance(0,(short) 32, (short) 31,null);
			fil7 = new Fil((short) 32, (short) 30,null);
			res8 = new Resistance(0,(short) 31, (short) 30,null);
			res8.setSens(true);
			map1.addComposant(fil1);
			map1.addComposant(res2);
			map1.addComposant(fil3);
			map1.addComposant(res4);
			map1.addComposant(fil5);
			map1.addComposant(res6);
			map1.addComposant(fil7);
			map1.addComposant(res8);

		} catch (ComposantException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}

		map1.genererMailles();
		map3.setMaillesCircuitsFermes(map1.getMaillesCircuitsFermes());
		assertTrue(map3.getMaillesCircuitsFermes() == map1.getMaillesCircuitsFermes());
	}

	@Test
	public void testSetMaillsesCircuitsFermes() {

		Fil fil1, fil3, fil5, fil7;
		Resistance res6, res8;
		try {
			// voici un circtuit de forme
			//
			// o-o
			// | |
			// o-o
			// les {-,|} sont des resistances et {o} representent des composantes

			fil1 = new Fil((short) 5, (short) 5,null);
			res2 = new Resistance(0,(short) 5, (short) 6,null);
			fil3 = new Fil((short) 5, (short) 7,null);
			res4 = new Resistance(0,(short) 6, (short) 7,null);
			res4.setSens(true);
			fil5 = new Fil((short) 7, (short) 7,null);
			res6 = new Resistance(0,(short) 7, (short) 6,null);
			fil7 = new Fil((short) 7, (short) 5,null);
			res8 = new Resistance(0,(short) 6, (short) 5,null);
			res8.setSens(true);
			map1.addComposant(fil1);
			map1.addComposant(res2);
			map1.addComposant(fil3);
			map1.addComposant(res4);
			map1.addComposant(fil5);
			map1.addComposant(res6);
			map1.addComposant(fil7);
			map1.addComposant(res8);

		} catch (ComposantException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}

		map1.genererMailles();
		map2.setMaillesCircuitsFermes(map1.getMaillesCircuitsFermes());
		assertTrue(map2.getMaillesCircuitsFermes() == map1.getMaillesCircuitsFermes());
	}

	@Test
	public void testGenrerNoeuds() {
		// Test pas encore disponible puisque cette partie n est pas a faire pour le
		// deuxieme sprint
	}

	@Test
	public void testGenererMailles() {

		try {
			map3.addComposant(res1);
			map3.addComposant(res2);
			map3.addComposant(res3);
			map3.addComposant(res4);
			map3.addComposant(res5);
		} catch (ComposantException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		map3.genererMailles();
		assertTrue(map3.getMaillesCircuitsFermes().size() == 0);
		Fil fil1, fil3, fil5, fil7;
		Resistance res6, res8;
		try {

			// voici un circtuit de forme
			//
			// o-o
			// | |
			// o-o
			// les {-,|} sont des resistances et {o} representent des composantes

			fil1 = new Fil((short) 0, (short) 0,null);
			res2 = new Resistance(0,(short) 0, (short) 1,null);
			res2.setSens(true);
			fil3 = new Fil((short) 0, (short) 2,null);
			res4 = new Resistance(0,(short) 1, (short) 2,null);
			fil5 = new Fil((short) 2, (short) 2,null);
			res6 = new Resistance(0,(short) 2, (short) 1,null);
			res6.setSens(true);
			fil7 = new Fil((short) 2, (short) 0,null);
			res8 = new Resistance(0,(short) 1, (short) 0,null);

			map1.addComposant(fil1);
			map1.addComposant(res2);
			map1.addComposant(fil3);
			map1.addComposant(res4);
			map1.addComposant(fil5);
			map1.addComposant(res6);
			map1.addComposant(fil7);
			map1.addComposant(res8);

		} catch (ComposantException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}

		map1.genererMailles();
		ArrayList<ComposantMap> composantsActuels = map1.getComposantsActuels();
		ArrayList<ArrayList<ComposantMap>> maillsesCircuitsFermes = map1.getMaillesCircuitsFermes();

		for (int i = 0; i < maillsesCircuitsFermes.size(); i++) {
			for (ComposantMap comp : maillsesCircuitsFermes.get(i)) {
				assertTrue(composantsActuels.contains(comp));
			}
			assertTrue(maillsesCircuitsFermes.get(i).size() == 8);
		}

		Fil fil10, fil12;
		Resistance res9, res11, res13;
		try {
			// voici un circtuit de forme
			//
			// o-o-o
			// | | |
			// o-o-o
			// les {-,|} sont des resistances et {o} representent des composantes

			fil1 = new Fil((short) 0, (short) 0,null);
			res2 = new Resistance(0,(short) 0, (short) 1,null);
			res2.setSens(true);
			fil3 = new Fil((short) 0, (short) 2,null);
			res4 = new Resistance(0,(short) 1, (short) 2,null);
			fil5 = new Fil((short) 2, (short) 2,null);
			res6 = new Resistance(0,(short) 2, (short) 1,null);
			res6.setSens(true);
			fil7 = new Fil((short) 2, (short) 0,null);
			res8 = new Resistance(0,(short) 1, (short) 0,null);
			res9 = new Resistance(0,(short) 0, (short) 3,null);
			res9.setSens(true);
			fil10 = new Fil((short) 0, (short) 4,null);
			res11 = new Resistance(0,(short) 1, (short) 4,null);
			fil12 = new Fil((short) 2, (short) 4,null);
			res13 = new Resistance(0,(short) 2, (short) 3,null);
			res13.setSens(true);

			map2.addComposant(fil1);
			map2.addComposant(res2);
			map2.addComposant(fil3);
			map2.addComposant(res4);
			map2.addComposant(fil5);
			map2.addComposant(res6);
			map2.addComposant(fil7);
			map2.addComposant(res8);
			map2.addComposant(res9);
			map2.addComposant(fil10);
			map2.addComposant(res11);
			map2.addComposant(fil12);
			map2.addComposant(res13);

		} catch (ComposantException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		map2.genererMailles();
		maillsesCircuitsFermes = map2.getMaillesCircuitsFermes();
		// verifie qu il y a 6 mailles produites
		assertTrue(maillsesCircuitsFermes.size() == 6);
		byte nombreMaillesDeHuit = 4;
		byte nombreMaillesDeDouze = 2;

		for (int i = 0; i < maillsesCircuitsFermes.size(); i++) {
			if (maillsesCircuitsFermes.get(i).size() == 8) {
				nombreMaillesDeHuit--;
			}
			if (maillsesCircuitsFermes.get(i).size() == 12) {
				nombreMaillesDeDouze--;
			}
		}
		// veririfie qu il y a 2 maille de 12 composantes et 4 de 8
		assertTrue(nombreMaillesDeHuit == 0);
		assertTrue(nombreMaillesDeDouze == 0);

		Fil fil15, fil17;
		Resistance res14, res16, res18;
		// voici un circtuit de forme
		// o-o
		// | |
		// o-o-o
		// | | | 
		// o-o-o
		// les {-,|} sont des resistances et {o} representent des composantes
		try {
			fil1 = new Fil((short) 0, (short) 0,null);
			res2 = new Resistance(0,(short) 0, (short) 1,null);
			res2.setSens(true);
			fil3 = new Fil((short) 0, (short) 2,null);
			res4 = new Resistance(0,(short) 1, (short) 2,null);
			fil5 = new Fil((short) 2, (short) 2,null);
			res6 = new Resistance(0,(short) 2, (short) 1,null);
			res6.setSens(true);
			fil7 = new Fil((short) 2, (short) 0,null);
			res8 = new Resistance(0,(short) 1, (short) 0,null);
			res9 = new Resistance(0,(short) 0, (short) 3,null);
			res9.setSens(true);
			fil10 = new Fil((short) 0, (short) 4,null);
			res11 = new Resistance(0,(short) 1, (short) 4,null);
			fil12 = new Fil((short) 2, (short) 4,null);
			res13 = new Resistance(0,(short) 2, (short) 3,null);
			res13.setSens(true);
			
			res14 = new Resistance(0,(short) 3, (short) 0,null);
			fil15 = new Fil((short) 4, (short) 0,null);
			res16 = new Resistance(0,(short) 4, (short) 1,null);
			res16.setSens(true);

			fil17 = new Fil((short) 4, (short) 2,null);
			res18 = new Resistance(0,(short) 3, (short) 2,null);

			map4.addComposant(fil1);
			map4.addComposant(res2);
			map4.addComposant(fil3);
			map4.addComposant(res4);
			map4.addComposant(fil5);
			map4.addComposant(res6);
			map4.addComposant(fil7);
			map4.addComposant(res8);
			map4.addComposant(res9);
			map4.addComposant(fil10);
			map4.addComposant(res11);
			map4.addComposant(fil12);
			map4.addComposant(res13);
			map4.addComposant(res14);
			map4.addComposant(fil15);
			map4.addComposant(res16);
			map4.addComposant(fil17);
			map4.addComposant(res18);

		} catch (ComposantException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		map4.genererMailles();
		maillsesCircuitsFermes = map4.getMaillesCircuitsFermes();
		assertTrue(maillsesCircuitsFermes.size()==12);
		
		 nombreMaillesDeHuit = 6;
		 nombreMaillesDeDouze = 4;
		 byte nombreMaillesDeSeize = 2;
		
		for (int i = 0; i < maillsesCircuitsFermes.size(); i++) {
			if (maillsesCircuitsFermes.get(i).size() == 8) {
				nombreMaillesDeHuit--;
			}
			if (maillsesCircuitsFermes.get(i).size() == 12) {
				nombreMaillesDeDouze--;
			}
			if (maillsesCircuitsFermes.get(i).size() == 16) {
				nombreMaillesDeSeize--;
			}
		}
		assertTrue(nombreMaillesDeHuit == 0);
		assertTrue(nombreMaillesDeDouze == 0);
		assertTrue(nombreMaillesDeSeize == 0);	

	}

	@Test
	public void testAddComposant() {

		try {
			map2.addComposant(res1);
			map2.addComposant(res2);
			map2.addComposant(res3);
			map2.addComposant(res4);
			map2.addComposant(res5);
		} catch (ComposantException e) {
			e.printStackTrace();
		}
		boolean estDedant1 = false;
		boolean estDedant2 = false;
		boolean estDedant3 = false;
		boolean estDedant4 = false;
		boolean estDedant5 = false;
		for (ComposantMap comp : map2.getComposantsActuels()) {
			if (comp == res1) {
				estDedant1 = true;
			}
			if (comp == res2) {
				estDedant2 = true;
			}
			if (comp == res3) {
				estDedant3 = true;
			}
			if (comp == res4) {
				estDedant4 = true;
			}
			if (comp == res5) {
				estDedant5 = true;
			}

		}
		assertTrue(estDedant1);
		assertTrue(estDedant2);
		assertTrue(estDedant3);
		assertTrue(estDedant4);
		assertTrue(estDedant5);
	}

	
	
	
	@Test
	public void testEstDansMap() {
		map1 = new MapParcourable();
		try {
			map1.addComposant(res1);
		} catch (ComposantException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		assertTrue(map1.estDansMap(res1));
		try {
			map1.addComposant(res2);
		} catch (ComposantException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		assertTrue(map1.estDansMap(res2));
		try {

			map1.addComposant(res3);
		} catch (ComposantException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		assertTrue(map1.estDansMap(res3));

		try {
			map1.addComposant(res4);
		} catch (ComposantException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		assertTrue(map1.estDansMap(res4));

		try {
			map1.addComposant(res5);
		} catch (ComposantException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		assertTrue(map1.estDansMap(res4));

	}

	@Test
	public void testGetComposantsActuels() {
		ArrayList<ComposantMap> truc = new ArrayList<ComposantMap>();
		truc.add(res1);
		truc.add(res2);
		truc.add(res3);
		truc.add(res4);
		truc.add(res5);
		map1.setComposantsActuels(truc);
		assertTrue(map1.getComposantsActuels() == truc);
	}

	@Test
	public void testSetComposantsActuels() {
		ArrayList<ComposantMap> truc = new ArrayList<ComposantMap>();
		truc.add(res1);
		truc.add(res2);
		truc.add(res3);
		truc.add(res4);
		truc.add(res5);
		map1.setComposantsActuels(truc);
		assertTrue(map1.getComposantsActuels() == truc);

	}
	
	
	////////////////////////////////// test GetBranches

	@Test 
	public void testerGetBranches() {
		try {
			map3.addComposant(res1);
			map3.addComposant(res2);
			map3.addComposant(res3);
			map3.addComposant(res4);
			map3.addComposant(res5);
		} catch (ComposantException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		map3.genererMailles();
		assertTrue(map3.getMaillesCircuitsFermes().size() == 0);
		Fil fil1, fil3, fil5, fil7;
		Resistance res6, res8;
		try {

			// voici un circtuit de forme
			//
			// o-o
			// | |
			// o-o
			// les {-,|} sont des resistances et {o} representent des composantes

			fil1 = new Fil((short) 0, (short) 0,null);
			res2 = new Resistance(0,(short) 0, (short) 1,null);
			res2.setSens(true);
			fil3 = new Fil((short) 0, (short) 2,null);
			res4 = new Resistance(0,(short) 1, (short) 2,null);
			fil5 = new Fil((short) 2, (short) 2,null);
			res6 = new Resistance(0,(short) 2, (short) 1,null);
			res6.setSens(true);
			fil7 = new Fil((short) 2, (short) 0,null);
			res8 = new Resistance(0,(short) 1, (short) 0,null);

			map1.addComposant(fil1);
			map1.addComposant(res2);
			map1.addComposant(fil3);
			map1.addComposant(res4);
			map1.addComposant(fil5);
			map1.addComposant(res6);
			map1.addComposant(fil7);
			map1.addComposant(res8);

		} catch (ComposantException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}

		assertTrue(map1.getBranches().size()==1);

		Fil fil10, fil12;
		Resistance res9, res11, res13;
		try {
			// voici un circtuit de forme
			//
			// o-o-o
			// | | |
			// o-o-o
			// les {-,|} sont des resistances et {o} representent des composantes

			fil1 = new Fil((short) 0, (short) 0,null);
			res2 = new Resistance(0,(short) 0, (short) 1,null);
			res2.setSens(true);
			fil3 = new Fil((short) 0, (short) 2,null);
			res4 = new Resistance(0,(short) 1, (short) 2,null);
			fil5 = new Fil((short) 2, (short) 2,null);
			res6 = new Resistance(0,(short) 2, (short) 1,null);
			res6.setSens(true);
			fil7 = new Fil((short) 2, (short) 0,null);
			res8 = new Resistance(0,(short) 1, (short) 0,null);
			res9 = new Resistance(0,(short) 0, (short) 3,null);
			res9.setSens(true);
			fil10 = new Fil((short) 0, (short) 4,null);
			res11 = new Resistance(0,(short) 1, (short) 4,null);
			fil12 = new Fil((short) 2, (short) 4,null);
			res13 = new Resistance(0,(short) 2, (short) 3,null);
			res13.setSens(true);

			map2.addComposant(fil1);
			map2.addComposant(res2);
			map2.addComposant(fil3);
			map2.addComposant(res4);
			map2.addComposant(fil5);
			map2.addComposant(res6);
			map2.addComposant(fil7);
			map2.addComposant(res8);
			map2.addComposant(res9);
			map2.addComposant(fil10);
			map2.addComposant(res11);
			map2.addComposant(fil12);
			map2.addComposant(res13);

		} catch (ComposantException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		// vérifie qu'il y a bel et bien 12  branches différentes (2fois le nombre de branches présentes dans chaque maille(2))


		assertTrue(map2.getBranches().size()==3);
		
		map2.genererMailles();
		map2.genrerNoeuds();
		System.out.println(map2.toString());
		float[][] matrice = map2.toMatrice();
		float[][] reponse = new float[map2.getBranches().size()][1];
	       
		String s ="";
		for(int i = 0; i < matrice.length; i++){
			for(int j = 0; j < matrice[i].length; j++){
				s+=matrice[i][j]+ " ";
			}
			s += "\n";
		}
		System.out.println(s);
//System.out.println(MatriceUtilitaires.resolveEquation(matrice, reponse));
		Fil fil15, fil17;
		Resistance res14, res16, res18;
		// voici un circtuit de forme
		// o-o
		// | |
		// o-o-o
		// | | | 
		// o-o-o
		// les {-,|} sont des resistances et {o} representent des composantes
		try {
			fil1 = new Fil((short) 0, (short) 0,null);
			res2 = new Resistance(0,(short) 0, (short) 1,null);
			res2.setSens(true);
			fil3 = new Fil((short) 0, (short) 2,null);
			res4 = new Resistance(0,(short) 1, (short) 2,null);
			fil5 = new Fil((short) 2, (short) 2,null);
			res6 = new Resistance(0,(short) 2, (short) 1,null);
			res6.setSens(true);
			fil7 = new Fil((short) 2, (short) 0,null);
			res8 = new Resistance(0,(short) 1, (short) 0,null);
			res9 = new Resistance(0,(short) 0, (short) 3,null);
			res9.setSens(true);
			fil10 = new Fil((short) 0, (short) 4,null);
			res11 = new Resistance(0,(short) 1, (short) 4,null);
			fil12 = new Fil((short) 2, (short) 4,null);
			res13 = new Resistance(0,(short) 2, (short) 3,null);
			res13.setSens(true);
			
			res14 = new Resistance(0,(short) 3, (short) 0,null);
			fil15 = new Fil((short) 4, (short) 0,null);
			res16 = new Resistance(0,(short) 4, (short) 1,null);
			res16.setSens(true);

			fil17 = new Fil((short) 4, (short) 2,null);
			res18 = new Resistance(0,(short) 3, (short) 2,null);

			map4.addComposant(fil1);
			map4.addComposant(res2);
			map4.addComposant(fil3);
			map4.addComposant(res4);
			map4.addComposant(fil5);
			map4.addComposant(res6);
			map4.addComposant(fil7);
			map4.addComposant(res8);
			map4.addComposant(res9);
			map4.addComposant(fil10);
			map4.addComposant(res11);
			map4.addComposant(fil12);
			map4.addComposant(res13);
			map4.addComposant(res14);
			map4.addComposant(fil15);
			map4.addComposant(res16);
			map4.addComposant(fil17);
			map4.addComposant(res18);

		} catch (ComposantException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
//vériife que le nombre de branches produites est de 12 (2 fois le nombre de mailles)
		assertTrue(map4.getBranches().size()==5);
		
	}
	
	
	
}
//--------<file_sep>/BoardPro/src/vue/ControleurDrawerVue.java
package vue;

import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;

import com.jfoenix.transitions.hamburger.HamburgerBackArrowBasicTransition;

import controleur.ControleurBoardPro;
import graphics.Axes;
import graphics.GraphiqueTemps;
import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader;
import javafx.scene.Scene;
import javafx.scene.control.ToggleButton;
import javafx.scene.control.ToggleGroup;
import javafx.scene.input.ClipboardContent;
import javafx.scene.input.Dragboard;
import javafx.scene.input.MouseEvent;
import javafx.scene.input.TransferMode;
import javafx.scene.layout.AnchorPane;
import javafx.scene.layout.VBox;

public class ControleurDrawerVue {

	@FXML
	public ToggleButton btnfil;
	@FXML
	public ToggleButton btnresistance;
	@FXML
	public ToggleButton btnsource;
	@FXML
	public ToggleButton btncondensateur;
	@FXML
	public ToggleButton btnbobine;
	@FXML
	public ToggleButton btnampoule;

	public ToggleButton btnfil1;

	@FXML
	void dragDetectedF(MouseEvent event) {
		ControleurBoardPro.composante = "fil";
		Dragboard db = ((ToggleButton) event.getSource()).startDragAndDrop(TransferMode.ANY);
		ClipboardContent content = new ClipboardContent();
		content.putString("THIS HAS BEEN DROPPED");
		db.setContent(content);
		event.consume();
	}
	@FXML
	void dragDetectedR(MouseEvent event) {
		ControleurBoardPro.composante = "resistance";
		Dragboard db = ((ToggleButton) event.getSource()).startDragAndDrop(TransferMode.ANY);
		ClipboardContent content = new ClipboardContent();
		content.putString("THIS HAS BEEN DROPPED");
		db.setContent(content);
		event.consume();
	}
	@FXML
	void dragDetectedC(MouseEvent event) {
		ControleurBoardPro.composante = "condensateur";
		Dragboard db = ((ToggleButton) event.getSource()).startDragAndDrop(TransferMode.ANY);
		ClipboardContent content = new ClipboardContent();
		content.putString("THIS HAS BEEN DROPPED");
		db.setContent(content);
		event.consume();
	}
	@FXML
	void dragDetectedB(MouseEvent event) {
		ControleurBoardPro.composante = "bobine";
		Dragboard db = ((ToggleButton) event.getSource()).startDragAndDrop(TransferMode.ANY);
		ClipboardContent content = new ClipboardContent();
		content.putString("THIS HAS BEEN DROPPED");
		db.setContent(content);
		event.consume();
	}
	@FXML
	void dragDetectedA(MouseEvent event) {
		ControleurBoardPro.composante = "ampoule";
		Dragboard db = ((ToggleButton) event.getSource()).startDragAndDrop(TransferMode.ANY);
		ClipboardContent content = new ClipboardContent();
		content.putString("THIS HAS BEEN DROPPED");
		db.setContent(content);
		event.consume();
	}
	@FXML
	void dragDetectedS(MouseEvent event) {
		ControleurBoardPro.composante = "source";
		Dragboard db = ((ToggleButton) event.getSource()).startDragAndDrop(TransferMode.ANY);
		ClipboardContent content = new ClipboardContent();
		content.putString("THIS HAS BEEN DROPPED");
		db.setContent(content);
		event.consume();
	}
	

	@FXML
	private void selectWire(ActionEvent event) {
		ControleurBoardPro.composante = ("fil");
	}

	@FXML
	private void selectResistor(ActionEvent event) {
		ControleurBoardPro.composante = ("resistance");
	}

	@FXML
	private void selectSource(ActionEvent event) {
		ControleurBoardPro.composante = ("source");
	}

	@FXML
	private void selectCondensator(ActionEvent event) {
		ControleurBoardPro.composante = ("condensateur");
	}

	@FXML
	private void selectBobine(ActionEvent event) {
		ControleurBoardPro.composante = ("bobine");
	}

	@FXML
	private void selectAmpoule(ActionEvent event) {
		ControleurBoardPro.composante = ("ampoule");
	}

	public ToggleGroup cGroup;
	public ControleurBoardPro controleur2;
	public VBox box;

	public void initialize() {
		/*
		 * cGroup = new ToggleGroup();
		 * 
		 * btnfil.setToggleGroup(cGroup); btnresistance.setToggleGroup(cGroup);
		 * btnsource.setToggleGroup(cGroup); btncondensateur.setToggleGroup(cGroup);
		 * btnbobine.setToggleGroup(cGroup); btnampoule.setToggleGroup(cGroup);
		 */
	}

	public VBox getBox() {
		return box;
	}

}
<file_sep>/BoardPro/src/exceptions/MathException.java
package exceptions;

public class MathException extends Exception {

	/**
	 *
	 */
	private static final long serialVersionUID = -1916688105817411016L;

	public MathException() {
		super("Erreur de type: MathException");
	}

	public MathException(String message) {
		super(message);
	}
}
<file_sep>/BoardPro/src/vue/ControleurPopRes.java
package vue;

import com.jfoenix.controls.JFXButton;
import com.jfoenix.controls.JFXTextField;
import application.MainApp;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.scene.control.ChoiceBox;
import javafx.scene.input.KeyEvent;
import javafx.stage.Modality;
import javafx.stage.Stage;
import javafx.stage.StageStyle;

public class ControleurPopRes {
	@FXML
	public JFXTextField PopResLongueur;
	@FXML
	public JFXTextField PopResTemperature;
	@FXML
	public JFXTextField PopResRayon;
	@FXML
	public ChoiceBox<String> choixMateriaux;
	@FXML
	public JFXTextField PopResOhmTF;
	@FXML
	public JFXTextField PopResTestTF;
	@FXML
	public JFXButton PopExit;
	@FXML
	public JFXButton PopResSave;

	@FXML
	void exitBtn(ActionEvent event) {
		stage.close();
	}

	@FXML
	void saveBtn(ActionEvent event) {

	}

	public void show() {
		stage.showAndWait();
	}

	private Stage stage;
	private Parent root;

	public ControleurPopRes() {

		FXMLLoader loader = new FXMLLoader(getClass().getResource("/vue/PopResOverview.fxml"));
		loader.setController(this);

		try {
			root = loader.load();
		} catch (Exception e) {
			e.printStackTrace();
		}

		Scene scene = new Scene(root);
		choixMateriaux.getItems().addAll("Aluminium", "Cuivre", "Fer", "Laiton", "Nichrome", "Nickel", "Or", "Platine",
				"Plomb", "Tungstene", "Argent");

		scene.getStylesheets().add(getClass().getResource("/css/style.css").toExternalForm());
		stage = new Stage(StageStyle.UTILITY);
		stage.initStyle(StageStyle.UNDECORATED);
		stage.setScene(scene);
		stage.sizeToScene();
		stage.setAlwaysOnTop(true);
		stage.initOwner(MainApp.getStage());
		stage.initModality(Modality.WINDOW_MODAL);
	}

	public void initialize() {
		PopResOhmTF.setPromptText("Default number");
		PopResOhmTF.setOnKeyTyped(tfNumOnly());
	}

	private EventHandler<KeyEvent> tfNumOnly() {
		EventHandler<KeyEvent> retour = new EventHandler<KeyEvent>() {
			@Override
			public void handle(KeyEvent event) {
				String c = event.getCharacter();
				for (int i = 0; i < 10; i++) {
					if ((c.equals(String.valueOf(0))) || (c.equals(String.valueOf(1))) || (c.equals(String.valueOf(2)))
							|| (c.equals(String.valueOf(3))) || (c.equals(String.valueOf(4)))
							|| (c.equals(String.valueOf(5))) || (c.equals(String.valueOf(6)))
							|| (c.equals(String.valueOf(7))) || (c.equals(String.valueOf(8)))
							|| (c.equals(String.valueOf(9)))) {
					} else {
						event.consume();
					}
				}
			}
		};
		return retour;
	}

}<file_sep>/BoardPro/src/utilitaire/Materiaux.java
package utilitaire;

/**
 * La r�sistivit� est exposant 10^-8 et le coefficient thermique exposant 10^-3
 * Les m�thodes get s'occupent de ces multiplications. Faite donc attention en vous servant
 * de ces chiffres, DE SI PETIT NOMBRE PEUVENT SEULEMENT AVOIR DES DOUBLES COMME TYPE.
 * 
 * @author <NAME>
 */
public enum Materiaux {

	ALUMINIUM(2.65, 3.9, "Aluminium"), ARGENT(1.59, 3.8, "Argent"), CUIVRE(1.68, 3.9, "Cuivre"), FER(8.57, 5, "Fer"),
	LAITON(6.08, 2, "Laiton"), NICHROME(108, 0.4, "Nichrome"), NICKEL(6.93, 5.9, "Nickel"), OR(2.21, 3.4, "Or"),
	PLATINE(10.5, 3.92, "Platine"), PLOMB(19.2, 4.3, "Plomb"), TUNGSTENE(5.28, 4.5, "Tungstène");

	private double resistivite;
	private double coefThermique;
	private String nom;

	/**
	 *
	 * @param p   r�sitivit� du mat�riaux
	 * @param a   coefficient thermique du mat�riaux
	 * @param nom nom du mat�riaux
	 */
	private Materiaux(double p, double a, String nom) {
		this.setResistivite(p);
		this.setCoefThermique(a);
		this.setNom(nom);
	}

	public double getResistivite() {
		return resistivite * Math.pow(10, -8);
	}

	private void setResistivite(double resistivite) {
		this.resistivite = resistivite;
	}

	public double getCoefThermique() {
		return coefThermique * Math.pow(10, -3);
	}

	private void setCoefThermique(double coefThermique) {
		this.coefThermique = coefThermique;
	}

	public String getNom() {
		return nom;
	}

	private void setNom(String nom) {
		this.nom = nom;
	}

	/**
	 * Simplement pour les tests jUnit
	 */
	@Override
	public String toString() {
		String s = "";
		s += "Le mat�riaux est " + this.getNom() + ", sa r�sistivit� est de " + this.getResistivite()
				+ " et son coefficient thermique est de " + this.getCoefThermique() + ".";

		return s;
	}

}<file_sep>/BoardPro/src/graphics/GraphiqueTemps.java
package graphics;

import javafx.concurrent.ScheduledService;
import javafx.concurrent.Task;
import temps.Temps;

public class GraphiqueTemps {
	Graphique graph;
	Axes axes;
	Temps temp;
	int fps;

	public GraphiqueTemps(String fonction, Axes axes, int fps) {
		super();
		this.graph = new Graphique(fonction, axes);
		graph.setStyle("-fx-background-color: rgb(35, 39, 50);");
		this.axes = axes;
		fps = 1000 / fps;
	}

	public Graphique getGraphique() {
		return this.graph;
	}

	public void start() {
		temp = new Temps();
		temps.setOnSucceeded(e -> {
			graph.tirerGraphique(-(float) (temp.getDeltaT() * axes.getMesurePixelUnite() * axes.getBonds()));
			temp.setTZero();
		});
		temps.start();

	}

	public void stop() {
		temps.cancel();
	}
	
	public void reset() {
		temps.reset();
	}

	ScheduledService<Void> temps = new ScheduledService<Void>() {
		@Override
		protected Task<Void> createTask() {
			// TODO Auto-generated method stub
			return new Task<Void>() {
				@Override
				protected Void call() throws Exception {
					try {
						Thread.sleep(fps);
					} catch (InterruptedException ie) {
					}
					return null;
				}
			};
		}

	};

}
<file_sep>/BoardPro/src/tests/ResistanceTest.java
package tests;

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;

import composantesCircuit.Resistance;
import exceptions.ComposantException;
import utilitaire.Materiaux;

public class ResistanceTest {
	Resistance r1;

	@Before
	public void creerResistor() {
		try {
			r1 = new Resistance(0,(short) 10, (short) 10,null);
		} catch (ComposantException e) {
			// Pas sens� se rendre ici
			fail();
		}
	}

	@Test
	public void testResistor() {
		assertTrue(r1.getImpedence() == 20);
		assertTrue(r1.getCourant() == 0);
		assertTrue(r1.getDdp() == 0);
	}

	@Test
	public void testResistorCustom() {
		// Test 1
		float longueur = 20;
		float rayon = 2;
		float t = 20;
		Materiaux m = Materiaux.ALUMINIUM;
		float resistanceCalc = (float) ((20 * m.getResistivite()) / (Math.PI * rayon * rayon));
		Resistance r = new Resistance((short) 0, (short) 0, longueur, rayon, m, t,null);
		assertTrue(r.getImpedence() == resistanceCalc);

		// Test 2
		t = 50;
		double nouveauP =(m.getResistivite() * (1 + (m.getCoefThermique() * 30)));
		resistanceCalc = (float) ((20 * nouveauP) / (Math.PI * rayon * rayon));
		r = new Resistance((short) 0, (short) 0, longueur, rayon, m, t,null);
		assertTrue(r.getImpedence() == resistanceCalc);
	}

}
<file_sep>/BoardPro/src/controleur/ControleurBoardPro.java
package controleur;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;

import composante.CE2Entrees;
import composantesCircuit.Bobine;
import composantesCircuit.Condensateur;
import composantesCircuit.Fil;
import composantesCircuit.Resistance;
import composantesCircuit.SourceCourant;
import exceptions.ComposantException;
import javafx.animation.Animation;
import javafx.animation.FadeTransition;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.embed.swing.SwingFXUtils;
import javafx.event.ActionEvent;
import javafx.event.Event;
import javafx.event.EventHandler;
import javafx.scene.Group;
import javafx.scene.Node;
import javafx.scene.SnapshotParameters;
import javafx.scene.control.ChoiceBox;
import javafx.scene.control.Label;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import javafx.scene.image.WritableImage;
import javafx.scene.input.DragEvent;
import javafx.scene.input.Dragboard;
import javafx.scene.input.MouseButton;
import javafx.scene.input.MouseEvent;
import javafx.scene.input.ScrollEvent;
import javafx.scene.input.TransferMode;
import javafx.scene.text.Font;
import javafx.scene.transform.Scale;
import javafx.stage.FileChooser;
import javafx.util.Duration;
import map.ComposantMap;
import map.MapParcourable;
import utilitaire.Images;
import utilitaire.Images.Composante;
import utilitaire.Materiaux;
import vue.ControleurDrawerVue;
import vue.ControleurPopAmp;
import vue.ControleurPopBob;
import vue.ControleurPopCon;
import vue.ControleurPopRes;
import vue.ControleurPopSrc;
import vue.ControleurVue;

public class ControleurBoardPro {

	private ControleurVue vue;
	private ControleurDrawerVue vue2;
	double OgScale = 1;
	public static String composante = "fil";
	private ArrayList<Images> listeImage = new ArrayList<Images>();
	public int numero = 1;
	MapParcourable map = new MapParcourable();
	Label nom = new Label();
	boolean effacer = false;
	boolean playing = false;
	ArrayList<FadeTransition> listeFade = new ArrayList<FadeTransition>();
	ComposantMap enModif;

	public ControleurBoardPro() {
		vue = new ControleurVue(this);
	}

	public ControleurVue getVue() {
		return vue;
	}

	public ControleurDrawerVue getVue2() {
		return vue2;
	}

	public void masterHandler() {
		vue.exitBtn.setOnMouseClicked(genererExitButton());
		nom.setFont(new Font(50));
		nom.setTranslateX(150);
		vue.paneGraph.getChildren().add(nom);
		vue.scrollP.setHvalue(0.5);
		vue.scrollP.setVvalue(0.5);
		vue.gridP.setOnScroll(genererZoomHandler());
		vue.gridP.setOnMouseClicked(genererOnMouseClicked());
		vue.tbReset.setOnAction(resetHandler());
		vue.tbRemove.setOnAction(enleverHandler());
		vue.tbPlay.setOnAction(play());
		vue.rlc.setOnMouseClicked(rlcHandler());
		vue.rl.setOnMouseClicked(rlHandler());
		vue.rc.setOnMouseClicked(rcHandler());
		vue.r.setOnMouseClicked(rHandler());
		vue.c.setOnMouseClicked(cHandler());
		vue.l.setOnMouseClicked(lHandler());
		vue.gridP.setOnDragDropped(dragDropped());
		vue.gridP.setOnDragOver(dragOver());

		vue.tbEnregistrer.setOnAction(enregistrerHandler());
		vue.tbOuvrir.setOnAction(ouvrirHandler());
		vue.tbReset.setOnAction(resetHandler());
		vue.tbScreenShot.setOnAction(screenshotHandler());
	}

	private EventHandler<ActionEvent> play() {
		EventHandler<ActionEvent> retour = new EventHandler<ActionEvent>() {

			@Override
			public void handle(ActionEvent event) {

				if (playing == false) {
					map.genererMailles();
					if (map.getMaille().size() != 0) {

						playing = true;
						vue.tbPlay.setStyle("-fx-background-color:c4c297");
						vue.graphiqueTemps.reset();
						vue.graphiqueTemps.start();
						byte compteur = 0;
						for (int a = 0; a < listeImage.size(); a++) {
							for (int b = 0; b < map.getMaille().size(); b++) {
								if (map.getMaille().get(b).contains(listeImage.get(a).getC())
										|| !listeImage.get(a).getNom().toString().substring(0, 3).equals("Fil")) {
									if (listeImage.get(a).getView().getId() != null
											&& listeImage.get(a).getView().getId().equals("/img/ampouleEteinte.png")) {
										listeImage.get(a).setImage(new Image("/img/ampouleAlumer.png"));
									}
									if (compteur >= listeImage.size()) {
										break;
									}

									FadeTransition fadeTransition = new FadeTransition(Duration.seconds(0.8),
											listeImage.get(a).getView());
									fadeTransition.setFromValue(1.0);
									fadeTransition.setToValue(0.3);
									fadeTransition.setAutoReverse(true);
									fadeTransition.setCycleCount(Animation.INDEFINITE);
									listeFade.add(fadeTransition);
									fadeTransition.play();
								}
							}
						}

					}
				} else {
					for (int i = 1; i < vue.gridP.getChildren().size(); i++) {
						ImageView v = (ImageView) vue.gridP.getChildren().get(i);
						if (v.getId() != null && v.getId().equals("Ampoule")) {
							v.setImage(new Image("/img/ampouleEteinte.png"));
						}
					}
					playing = false;
					vue.tbPlay.setStyle(null);
					vue.graphiqueTemps.stop();
					for (FadeTransition i : listeFade) {
						i.pause();
						i.jumpTo(Duration.ZERO);
					}
				}
			}

		};
		return retour;
	}

	private EventHandler<ActionEvent> enleverHandler() {
		EventHandler<ActionEvent> retour = new EventHandler<ActionEvent>() {

			@Override
			public void handle(ActionEvent event) {
				vue.tbRemove.setStyle("-fx-background-color:c4c297");

				if (!effacer) {
					effacer = true;
					// Activer handler enlève pour la grille
					vue.gridP.setOnMouseClicked(new EventHandler<MouseEvent>() {

						@Override
						public void handle(MouseEvent event) {
							byte positionX = (byte) (Math.floor(event.getX() / 75));
							byte positionY = (byte) (Math.floor(event.getY() / 75));

							for (byte i = 0; i < listeImage.size(); i++) {
								if (listeImage.get(i).getPositionX() == positionX
										&& listeImage.get(i).getPositionY() == positionY) {
									enlever(listeImage.get(i));
								}
							}

						}

					});
				} else {
					effacer = false;
					vue.gridP.setOnMouseClicked(genererOnMouseClicked());
					vue.tbRemove.setStyle(null);
				}

			}

		};
		return retour;
	}

	private EventHandler<ActionEvent> resetHandler() {
		EventHandler<ActionEvent> retour = new EventHandler<ActionEvent>() {

			@Override
			public void handle(ActionEvent event) {
				reset();
			}

		};
		return retour;
	}

	private EventHandler<ActionEvent> screenshotHandler() {
		EventHandler<ActionEvent> retour = new EventHandler<ActionEvent>() {

			@Override
			public void handle(ActionEvent event) {

				FileChooser fichierSelecteur = new FileChooser();

				FileChooser.ExtensionFilter extFilter = new FileChooser.ExtensionFilter("*.png", "*.jpg");
				fichierSelecteur.getExtensionFilters().add(extFilter);

				File fichier = fichierSelecteur.showSaveDialog(vue.getScene().getWindow());

				if (fichier != null) {
					Group g = new Group();
					for (int i = 0; i < listeImage.size(); i++) {
						g.getChildren().add(listeImage.get(i).getView());
					}
					WritableImage image = g.snapshot(new SnapshotParameters(), null);
					try {
						ImageIO.write(SwingFXUtils.fromFXImage(image, null), "png", fichier);
						g = null;
						for (int i = 0; i < listeImage.size(); i++) {
							vue.gridP.add(listeImage.get(i).getView(), listeImage.get(i).getPositionX(),
									listeImage.get(i).getPositionY());
						}

					} catch (IOException e) {

					}
				}
			}

		};
		return retour;
	}

	private EventHandler<ActionEvent> ouvrirHandler() {
		EventHandler<ActionEvent> retour = new EventHandler<ActionEvent>() {

			@Override
			public void handle(ActionEvent event) {

				FileChooser fichierSelecteur = new FileChooser();

				FileChooser.ExtensionFilter extFilter = new FileChooser.ExtensionFilter("TXT files (*.txt)", "*.txt");
				fichierSelecteur.getExtensionFilters().add(extFilter);

				File fichier = fichierSelecteur.showOpenDialog(vue.getScene().getWindow());

				if (fichier != null) {
					reset();
					ouvrirTexte(fichier);
				}
			}

		};
		return retour;
	}

	private void ouvrirTexte(File fichier) {

		BufferedReader br;

		try {
			br = new BufferedReader(new FileReader(fichier));
			String st;
			while ((st = br.readLine()) != null) {
				String nom = st;
				Composante c = null;
				if (nom.equals("FilH")) {
					c = Composante.FilH;
				} else if (nom.equals("FilV")) {
					c = Composante.FilV;
				} else if (nom.equals("FilHD")) {
					c = Composante.FilHD;

				} else if (nom.equals("FilHG")) {
					c = Composante.FilHG;

				} else if (nom.equals("FilBD")) {
					c = Composante.FilBD;

				} else if (nom.equals("FilBG")) {
					c = Composante.FilBG;

				} else if (nom.equals("FilGBD")) {
					c = Composante.FilGBD;

				} else if (nom.equals("FilGHD")) {
					c = Composante.FilGHD;

				} else if (nom.equals("FilBGH")) {
					c = Composante.FilBGH;

				} else if (nom.equals("FilBDH")) {
					c = Composante.FilBDH;

				} else if (nom.equals("FilAll")) {
					c = Composante.FilAll;

				} else if (nom.equals("Résistance")) {
					c = Composante.Résistance;

				} else if (nom.equals("Condensateur")) {
					c = Composante.Condensateur;

				} else if (nom.equals("Ampoule")) {
					c = Composante.Ampoule;

				} else if (nom.equals("Source")) {
					c = Composante.Source;

				} else if (nom.equals("Bobine")) {
					c = Composante.Bobine;
				}

				st = br.readLine();
				if (st != null) {
					byte posX = (byte) Integer.parseInt(st);
					st = br.readLine();
					if (st != null) {
						byte posY = (byte) Integer.parseInt(st);
						genererAutre(posX, posY, c);
					}
				}

			}
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	private EventHandler<ActionEvent> enregistrerHandler() {
		EventHandler<ActionEvent> retour = new EventHandler<ActionEvent>() {

			@Override
			public void handle(ActionEvent event) {
				String texte = "";
				for (int i = 0; i < listeImage.size(); i++) {
					texte += listeImage.get(i).getNom() + "\n";
					texte += listeImage.get(i).getPositionX() + "\n";
					texte += listeImage.get(i).getPositionY() + "\n";
				}

				FileChooser fichierSelecteur = new FileChooser();
				FileChooser.ExtensionFilter extFilter = new FileChooser.ExtensionFilter("TXT files (*.txt)", "*.txt");
				fichierSelecteur.getExtensionFilters().add(extFilter);

				File fichier = fichierSelecteur.showSaveDialog(vue.getScene().getWindow());

				if (fichier != null) {
					enregistrerTexte(texte, fichier);
				}
			}
		};
		return retour;
	}

	private void enregistrerTexte(String contenu, File fichier) {
		try {
			PrintWriter writer;
			writer = new PrintWriter(fichier);
			writer.println(contenu);
			writer.close();
		} catch (IOException ex) {
			Logger.getLogger(ControleurBoardPro.class.getName()).log(Level.SEVERE, null, ex);
		}
	}

	private EventHandler<DragEvent> dragOver() {
		EventHandler<DragEvent> retour = new EventHandler<DragEvent>() {

			@Override
			public void handle(DragEvent event) {
				Dragboard db = event.getDragboard();
				if (db.hasString()) {
					event.acceptTransferModes(TransferMode.COPY_OR_MOVE);
				}
				event.consume();
			}

		};
		return retour;
	}

	private EventHandler<DragEvent> dragDropped() {
		EventHandler<DragEvent> retour = new EventHandler<DragEvent>() {

			@Override
			public void handle(DragEvent event) {
				Dragboard db = event.getDragboard();
				if (db.hasString()) {
					event.acceptTransferModes(TransferMode.COPY_OR_MOVE);
				}
				event.consume();
				byte positionX = (byte) (Math.floor(event.getX() / 75));
				byte positionY = (byte) (Math.floor(event.getY() / 75));

				if (composante.equals("fil")) {
					genererFil(positionX, positionY);
				} else if (composante.equals("resistance")) {
					genererAutre(positionX, positionY, Composante.Résistance);
				} else if (composante.equals("condensateur")) {
					genererAutre(positionX, positionY, Composante.Condensateur);
				} else if (composante.equals("bobine")) {
					genererAutre(positionX, positionY, Composante.Bobine);
				} else if (composante.equals("source")) {
					genererAutre(positionX, positionY, Composante.Source);
				} else if (composante.equals("ampoule")) {
					genererAutre(positionX, positionY, Composante.Ampoule);
				}
			}

		};
		return retour;
	}

	private EventHandler<ScrollEvent> genererZoomHandler() {
		EventHandler<ScrollEvent> retour = new EventHandler<ScrollEvent>() {
			@Override
			public void handle(ScrollEvent event) {

				double zoomPower = 1.03092783505;
				double delta_y = event.getDeltaY();

				if (delta_y < 0) {
					zoomPower = 0.97;
					if (OgScale > .80) {
						OgScale = OgScale * zoomPower;
					}
				}
				if (delta_y > 0) {
					OgScale = OgScale * zoomPower;
				}

				Scale newScale = new Scale();
				newScale.setPivotX(vue.gridP.getWidth() / 2);
				newScale.setPivotY(vue.gridP.getHeight() / 2);
				newScale.setX(vue.gridP.getScaleX() * zoomPower);
				newScale.setY(vue.gridP.getScaleY() * zoomPower);

				if (OgScale > .80) {
					vue.gridP.getTransforms().add(newScale);
				} else {
					OgScale = .81;
				}

				event.consume();
			}
		};
		return retour;
	}

	private EventHandler<MouseEvent> genererExitButton() {
		EventHandler<MouseEvent> retour = new EventHandler<MouseEvent>() {
			@Override
			public void handle(MouseEvent event) {
				// vue.boardToolb.setVisible(false);
				// vue.tbCompList.setExpanded(true);
				// vue.tbCompList.depthProperty().set(1);
				System.exit(1);
			}
		};
		return retour;
	}

	private EventHandler<MouseEvent> genererOnMouseClicked() {
		EventHandler<MouseEvent> retour = new EventHandler<MouseEvent>() {
			@Override
			public void handle(MouseEvent event) {
				byte positionX = (byte) (Math.floor(event.getX() / 75));
				byte positionY = (byte) (Math.floor(event.getY() / 75));
				// Clique droit
				if (event.getButton().equals(MouseButton.SECONDARY)) {
					nom.setText("");
					for (int i = 0; i < listeImage.size(); i++) {
						if (listeImage.get(i).getPositionX() == positionX
								&& listeImage.get(i).getPositionY() == positionY) {
							String text = listeImage.get(i).getNom().toString();
							if (text.substring(0, 3).equals("Fil")) {
								text = "Fil";
							}
							if (event.isControlDown() == true) {
								enModif = map.getComposantsActuels().get(i);
								if (text.equals("Résistance")) {
									ControleurPopRes popup = new ControleurPopRes();

									popup.PopResSave.setOnAction(modifierResistance((Resistance) enModif, popup));
									popup.show();
								} else if (text.equals("Condensateur")) {
									ControleurPopCon popup = new ControleurPopCon();

									popup.PopSave.setOnAction(modifierCondensateur((Condensateur) enModif, popup));
									popup.show();
								} else if (text.equals("Bobine")) {
									ControleurPopBob popup = new ControleurPopBob();

									popup.PopSave.setOnAction(modifierBobine((Bobine) enModif, popup));
									popup.show();
								} else if (text.equals("Source")) {
									ControleurPopSrc popup = new ControleurPopSrc();

									popup.PopSave.setOnAction(modifierSource((SourceCourant) enModif, popup));
									popup.show();
								} else if (text.equals("Ampoule")) {
									ControleurPopAmp popup = new ControleurPopAmp();
									popup.show();
								}
							} else {
								text += " à la position (X, Y): (" + listeImage.get(i).getPositionX() + ", "
										+ listeImage.get(i).getPositionY() + ")";
								nom.setText(text);
								vue.tabView.getSelectionModel().select(1);

							}
							vue.graphiqueTemps.getGraphique().changerFonction("");
							vue.graphiqueTemps.getGraphique().changerFonction("5sin(30x)");

						}

					}
				}
				// Clique gauche
				else {

					if (composante.equals("fil")) {
						genererFil(positionX, positionY);
					} else if (composante.equals("resistance")) {
						genererAutre(positionX, positionY, Composante.Résistance);
					} else if (composante.equals("condensateur")) {
						genererAutre(positionX, positionY, Composante.Condensateur);
					} else if (composante.equals("bobine")) {
						genererAutre(positionX, positionY, Composante.Bobine);
					} else if (composante.equals("source")) {
						genererAutre(positionX, positionY, Composante.Source);
					} else if (composante.equals("ampoule")) {
						genererAutre(positionX, positionY, Composante.Ampoule);
					}
				}
			}
		};
		return retour;
	}

	private void genererAutre(byte x, byte y, Composante nom) {
		Images i = new Images(nom, x, y);
		HashSet<Byte> aChanger = i.composanteProche(listeImage);
		changerImage(aChanger);
		i.choisirImage(i);
		Composante n = i.choisirImage(i);
		i.setNom(n);
		i.creerImage(i.getNom());
		i.creerView();
		ajoutComposante(i, null);
	}

	private void genererFil(byte x, byte y) {
		Images image = new Images(Composante.FilH, x, y);

		/*
		 * Cette ligne fait deux chose, trouve les composantes proches de l'image (1) et
		 * puisque ces images proches doivent peut-être changer, garde la liste des
		 * images a changer
		 */
		HashSet<Byte> aChanger = image.composanteProche(listeImage);
		changerImage(aChanger);

		Composante nom = image.choisirImage(image);
		image.setNom(nom);
		image.creerImage(image.getNom());
		image.creerView();
		ajoutComposante(image, null);

	}

	private void changerImage(HashSet<Byte> lesIndexs) {
		ArrayList<Images> liste = new ArrayList<Images>();

		for (Byte i : lesIndexs) {
			liste.add(listeImage.get(i));
		}
		for (int j = 0; j < liste.size(); j++) {

			Composante avant = liste.get(j).getNom();
			int rotAvant = liste.get(j).getRotation();

			Composante apres = liste.get(j).choisirImage(liste.get(j));
			int rotApres = liste.get(j).getRotation();
			if (!avant.equals(apres) || rotAvant != rotApres) {
				ImageView aEnlever = liste.get(j).getView();
				liste.get(j).setNom(apres);
				liste.get(j).creerImage(apres);
				liste.get(j).creerView();
				ajoutComposante(liste.get(j), aEnlever);
			}
		}
	}

	private void ajoutComposante(Images image, ImageView aEnlever) {
		// Remove si à la meme position
		for (byte i = 0; i < listeImage.size(); i++) {
			if (listeImage.get(i) == image || (listeImage.get(i).getPositionX() == image.getPositionX()
					&& listeImage.get(i).getPositionY() == image.getPositionY())) {

				map.removeComposante(i);
				vue.gridP.getChildren().remove(listeImage.get(i).getView());

				if (aEnlever == null) {
					aEnlever = listeImage.get(i).getView();
				}
				vue.gridP.getChildren().remove(aEnlever);
				listeImage.remove(i);

			}
		}

		listeImage.add(image);
		ImageView v = image.getView();
		v.setRotate(image.getRotation());
		vue.gridP.add(v, image.getPositionX(), image.getPositionY());

		// -----------------------Ajout dans composante Map--------------------
		try {
			ComposantMap compo = null;
			CE2Entrees composante = null;
			if (image.getNom().equals(Composante.Ampoule)) {
				composante = new Resistance((short) image.getPositionX(), (short) image.getPositionY(), image);
				composante.getImage().getView().setId("Ampoule");
				if (composante.getImage().getRotation() == 90) {
					composante.setSens(true);
				}
			} else if (image.getNom().equals(Composante.Bobine)) {
				composante = new Bobine((short) image.getPositionX(), (short) image.getPositionY(), image);
				if (composante.getImage().getRotation() == 90) {
					composante.setSens(true);
				}
			} else if (image.getNom().equals(Composante.Condensateur)) {
				composante = new Condensateur((short) image.getPositionX(), (short) image.getPositionY(), image);
				if (composante.getImage().getRotation() == 90) {
					composante.setSens(true);
				}
			} else if (image.getNom().equals(Composante.Résistance)) {
				composante = new Resistance((short) image.getPositionX(), (short) image.getPositionY(), image);
				if (composante.getImage().getRotation() == 90) {
					composante.setSens(true);
				}
			} else if (image.getNom().equals(Composante.Source)) {
				composante = new SourceCourant((short) image.getPositionX(), (short) image.getPositionY(), image);
				if (composante.getImage().getRotation() == 90) {
					composante.setSens(true);
				}
			} else {
				compo = new Fil((short) image.getPositionX(), (short) image.getPositionY(), image);
			}
			if (compo != null) {
				map.addComposant(compo);
				image.setC(compo);

			}
			if (composante != null) {
				map.addComposant(composante);
			}
		} catch (ComposantException e) {
			e.printStackTrace();
		}

	}

	private void reset() {
		listeImage.clear();
		map.getComposantsActuels().clear();
		nom.setText("");
		Node n = vue.gridP.getChildren().get(0);
		vue.gridP.getChildren().clear();
		vue.gridP.add(n, 0, 0);
	}

	private void enlever(Images image) {
		HashSet<Byte> aModif = image.modifierAutourRetrait(listeImage);
		changerImage(aModif);
		vue.gridP.getChildren().remove(image.getView());
		map.getComposantsActuels().remove(listeImage.indexOf(image));
		listeImage.remove(image);
	}

	private EventHandler<MouseEvent> rlcHandler() {
		EventHandler<MouseEvent> retour = new EventHandler<MouseEvent>() {

			@Override
			public void handle(MouseEvent event) {
				reset();
				File f = new File("./res/circuitPrefait/RLC.txt");
				ouvrirTexte(f);
				vue.tabView.getSelectionModel().select(0);

				// Résistance 16
				listeImage.get(16).setEquationDDP("");
				// Bobine 17
				listeImage.get(17).setEquationDDP("");
				// Condensateur 19
				listeImage.get(19).setEquationDDP("");
			}

		};
		return retour;
	}

	private EventHandler<MouseEvent> rlHandler() {
		EventHandler<MouseEvent> retour = new EventHandler<MouseEvent>() {

			@Override
			public void handle(MouseEvent event) {
				reset();
				File f = new File("./res/circuitPrefait/RL.txt");
				ouvrirTexte(f);
				vue.tabView.getSelectionModel().select(0);

				// Résistance
				listeImage.get(18).setEquationDDP("");
				// Bobine
				listeImage.get(19).setEquationDDP("");
			}

		};
		return retour;
	}

	private EventHandler<MouseEvent> rcHandler() {
		EventHandler<MouseEvent> retour = new EventHandler<MouseEvent>() {

			@Override
			public void handle(MouseEvent event) {
				reset();
				File f = new File("./res/circuitPrefait/RC.txt");
				ouvrirTexte(f);
				vue.tabView.getSelectionModel().select(0);

				// Résistance
				listeImage.get(18).setEquationDDP("");
				// Condensateur
				listeImage.get(19).setEquationDDP("");
			}

		};
		return retour;
	}

	private EventHandler<MouseEvent> rHandler() {
		EventHandler<MouseEvent> retour = new EventHandler<MouseEvent>() {

			@Override
			public void handle(MouseEvent event) {
				reset();
				File f = new File("./res/circuitPrefait/R.txt");
				ouvrirTexte(f);
				vue.tabView.getSelectionModel().select(0);
				listeImage.get(19).setEquationDDP("");
			}

		};
		return retour;
	}

	private EventHandler<MouseEvent> cHandler() {
		EventHandler<MouseEvent> retour = new EventHandler<MouseEvent>() {

			@Override
			public void handle(MouseEvent event) {
				reset();
				File f = new File("./res/circuitPrefait/C.txt");
				ouvrirTexte(f);
				vue.tabView.getSelectionModel().select(0);
				listeImage.get(19).setEquationDDP("");

			}

		};
		return retour;
	}

	private EventHandler<MouseEvent> lHandler() {
		EventHandler<MouseEvent> retour = new EventHandler<MouseEvent>() {

			@Override
			public void handle(MouseEvent event) {
				reset();
				File f = new File("./res/circuitPrefait/L.txt");
				ouvrirTexte(f);
				vue.tabView.getSelectionModel().select(0);
				listeImage.get(19).setEquationDDP("");
			}

		};
		return retour;
	}

	private EventHandler<ActionEvent> modifierCondensateur(Condensateur s, ControleurPopCon p) {
		EventHandler<ActionEvent> retour = new EventHandler<ActionEvent>() {

			@Override
			public void handle(ActionEvent event) {
				try {
					s.setCapacite(Float.parseFloat(p.PopConCap.getText()));
				} catch (Exception e) {
					s.setCapacite(100);
				}

			}

		};
		return retour;
	}

	private EventHandler<ActionEvent> modifierBobine(Bobine s, ControleurPopBob p) {
		EventHandler<ActionEvent> retour = new EventHandler<ActionEvent>() {

			@Override
			public void handle(ActionEvent event) {
				try {
					s.setInductence(Float.parseFloat(p.PopBobInd.getText()));
				} catch (Exception e) {
					s.setInductence(20);
				}

			}

		};
		return retour;
	}

	private EventHandler<ActionEvent> modifierSource(SourceCourant s, ControleurPopSrc p) {
		EventHandler<ActionEvent> retour = new EventHandler<ActionEvent>() {

			@Override
			public void handle(ActionEvent event) {
				try {
					s.setCourant(Float.parseFloat(p.PopSrcAmp.getText()));
					s.setDdp(Float.parseFloat(p.PopSrcVol.getText()));
					s.setFrequence(Float.parseFloat(p.frequence.getText()));
				} catch (Exception e) {
					s.setCourant(0);
					s.setDdp(0);
					s.setFrequence(0);
				}

			}

		};
		return retour;
	}

	private EventHandler<ActionEvent> modifierResistance(Resistance r, ControleurPopRes p) {

		EventHandler<ActionEvent> retour = new EventHandler<ActionEvent>() {

			@Override
			public void handle(ActionEvent event) {
				if (p.PopResLongueur.getText().equals("") || p.PopResTemperature.getText().equals("")
						|| (p.PopResRayon.getText().equals(""))) {
					try {
						float res = Float.parseFloat(p.PopResOhmTF.getText());
						r.setImpedence(res);
					} catch (Exception e) {
						r.setImpedence(20);
					}

				} else {
					try {
						r.setTemperature(273 + Float.parseFloat(p.PopResTemperature.getText()));
						r.setRayon(Float.parseFloat(p.PopResRayon.getText()));
						r.setLongueur(Float.parseFloat(p.PopResLongueur.getText()));

						String materiaux = p.choixMateriaux.getValue();

						if (materiaux.equals("Argent")) {
							r.setMateriau(Materiaux.ARGENT);
						} else if (materiaux.equals("Aluminium")) {
							r.setMateriau(Materiaux.ALUMINIUM);
						} else if (materiaux.equals("Cuivre")) {
							r.setMateriau(Materiaux.CUIVRE);
						} else if (materiaux.equals("Fer")) {
							r.setMateriau(Materiaux.FER);
						} else if (materiaux.equals("Laiton")) {
							r.setMateriau(Materiaux.LAITON);
						} else if (materiaux.equals("Nichrome")) {
							r.setMateriau(Materiaux.NICHROME);
						} else if (materiaux.equals("Nickel")) {
							r.setMateriau(Materiaux.NICKEL);
						} else if (materiaux.equals("Or")) {
							r.setMateriau(Materiaux.OR);
						} else if (materiaux.equals("Platine")) {
							r.setMateriau(Materiaux.PLATINE);
						} else if (materiaux.equals("Plomb")) {
							r.setMateriau(Materiaux.PLOMB);
						} else if (materiaux.equals("Tungstène")) {
							r.setMateriau(Materiaux.TUNGSTENE);
						}

					} catch (Exception e) {
						r.setImpedence(20);
					}
				}

			}
		};
		return retour;
	}
}
<file_sep>/BoardPro/src/utilitaire/SolveurEquations.java
package utilitaire;

import java.util.*;
import java.io.IOException;
import java.text.*;

/**
 *
 * @author lx_user
 */
public class SolveurEquations {

	static HashMap<String, Integer> opPrecedence = new HashMap<String, Integer>();

	public static void initPrecedence() {
		opPrecedence.put("^", 4);
		opPrecedence.put("*", 3);
		opPrecedence.put("/", 3);
		opPrecedence.put("+", 2);
		opPrecedence.put("-", 2);
		opPrecedence.put(")", 1);
		opPrecedence.put("(", 1);
	}



	private static String[] convvertirSymboles(String expression) {
		ArrayList<String> symboles = new ArrayList<String>();
		String[] output;
		int outputSize = 0;
		boolean prevWasOperator = true; // use this to check for unary operators (-)
		for (int i = 0; i < expression.length(); i++) {
			switch (expression.charAt(i)) {
			case '^':
				symboles.add("^");
				symboles.add("");
				prevWasOperator = true;
				break;
			case '*':
				symboles.add("*");
				symboles.add("");
				prevWasOperator = true;
				break;
			case '/':
				symboles.add("/");
				symboles.add("");
				prevWasOperator = true;
				break;
			case '+':
				symboles.add("+");
				symboles.add("");
				prevWasOperator = true;
				break;
			case '-':
				if (prevWasOperator && expression.charAt(i + 1) != '(') {
					symboles.add("-");
				} else if (prevWasOperator && expression.charAt(i + 1) == '(') {
					symboles.add("-1");
					symboles.add("*");
				} else {
					symboles.add("-");
					symboles.add("");
					prevWasOperator = true;
				}
				break;
			case '(':
				symboles.add("(");
				symboles.add("");
				prevWasOperator = true;
				break;
			case ')':
				symboles.add(")");
				symboles.add("");
				prevWasOperator = false;
				break;
			case ' ':
				// remove whitespace
				break;
			case '[':
				String scientificNotation = "";
				for (int j = i + 1; j < expression.length(); j++) {
					if (expression.charAt(j) == ']') {
						i = j;
						break;
					}
					scientificNotation += expression.charAt(j);
				}
				symboles.add(scientificNotation);
				prevWasOperator = false;
				break;
			default: // alphanumeric characters
				if (symboles.size() < 1)
					symboles.add("");
				String item = symboles.get(symboles.size() - 1) + expression.charAt(i);
				symboles.remove(symboles.size() - 1);
				symboles.add(item);
				prevWasOperator = false;
			}
		}
		for (int i = 0; i < symboles.size(); i++) {
			if (symboles.get(i).length() > 0)
				outputSize++;
		}
		output = new String[outputSize];
		int j = 0;
		for (int i = 0; i < symboles.size(); i++) {
			if (symboles.get(i).length() > 0) {
				output[j] = symboles.get(i);
				j++;
			}
		}
		return output;
	}

	private static String infixToPostfix(String expression) {
		if (expression == "") // empty string
			return "";
		Stack<String> operationStack = new Stack<String>();
		String[] lettres = convvertirSymboles(expression);
		String ret = "";
		for (String let : lettres) {
			if (let.equals("(")) {
				operationStack.push(let);
			} else if (let.equals(")")) {
				while (!operationStack.peek().equals("("))
					ret += operationStack.pop() + " ";
				operationStack.pop();
			} else if (opPrecedence.containsKey(let)) {
				while (!operationStack.isEmpty() && opPrecedence.get(operationStack.peek()) >= opPrecedence.get(let))
					ret += operationStack.pop() + " ";
				operationStack.push(let);
			} else {
				ret += let + " ";
			}
		}
		while (!operationStack.isEmpty())
			ret += operationStack.pop() + " ";
		return ret;
	}

	private static double evaluaterPostfix(String expression) {
		if (expression == "")
			return 0;
		Stack<Double> operandStack = new Stack<Double>();
		String[] tokens = expression.split(" ");
		for (String tok : tokens) {
			double num1, num2;
			switch (tok) {
			case "+":
				num2 = (double) operandStack.pop();
				num1 = (double) operandStack.pop();
				operandStack.push(num1 + num2);
				break;
			case "-":
				num2 = (double) operandStack.pop();
				num1 = (double) operandStack.pop();
				operandStack.push(num1 - num2);
				break;
			case "*":
				num2 = (double) operandStack.pop();
				num1 = (double) operandStack.pop();
				operandStack.push(num1 * num2);
				break;
			case "/":
				num2 = (double) operandStack.pop();
				num1 = (double) operandStack.pop();
				operandStack.push(num1 / num2);
				break;
			case "^":
				num2 = (double) operandStack.pop();
				num1 = (double) operandStack.pop();
				operandStack.push(Math.pow(num1, num2));
				break;
			default:
				operandStack.push(Double.parseDouble(tok));
			}
		}
		return (double) operandStack.pop();
	}

	private static boolean possedeFonction(String expression) {
		return expression.contains("log") || expression.contains("sin") || expression.contains("cos")
				|| expression.contains("tan") || expression.contains("abs")
		
		;
	}

	private static boolean isOperator(char c) {
		return c == '^' || c == '*' || c == '/' || c == '-' || c == '+';
	}

	private static boolean isTerm2(char c) {
		return c == '(' || c == '[' || (c - 'a' < 26 && c - 'a' >= 0);
	}

	private static boolean isTerm1(char c) {
		return c == ')' || c == ']' || (c - '0' <= 9 && c - '0' >= 0);
	}

	private static String getMultiplicationImplicite(String expression) {
		String ret = expression;
		boolean scanned = false;
		do {
			scanned = false;
			for (int i = 1; i < ret.length(); i++) {
				if (isTerm2(ret.charAt(i)) && isTerm1(ret.charAt(i - 1))
						|| isTerm1(ret.charAt(i - 1)) && isTerm2(ret.charAt(i))) {
					ret = ret.substring(0, i) + "*" + ret.substring(i);
					scanned = true;
					break;
				}
			}
		} while (scanned);
		return ret;
	}

	public static double evaluer(String expression) {
		return evaluaterUtile(getMultiplicationImplicite(expression));
	}

	private static double evaluaterUtile(String expression) {
		while (possedeFonction(expression)) {
			String expressionDouble = expression;
			int start = 0;
			Stack<Integer> bracketStack = new Stack<Integer>();
			if (expression.indexOf("log") != -1)
				start = expression.indexOf("log");
			else if (expression.indexOf("sin") != -1)
				start = expression.indexOf("sin");
			else if (expression.indexOf("cos") != -1)
				start = expression.indexOf("cos");
			else if (expression.indexOf("tan") != -1)
				start = expression.indexOf("tan");
			else if (expression.indexOf("abs") != -1)
				start = expression.indexOf("abs");
			for (int i = start + 3; i < expression.length(); i++) {
				if (expression.charAt(i) == '(')
					bracketStack.push(i);
				else if (expression.charAt(i) == ')')
					bracketStack.pop();
				if (bracketStack.isEmpty()) {
					String expressionSimplifie = "";
					String function = expression.substring(start, start + 3);
					expressionSimplifie += expression.substring(0, start);
					switch (function) {
					case "sin":
						expressionSimplifie += Math.sin(evaluer(expression.substring(start + 4, i)));
						break;
					case "log":
						expressionSimplifie += Math.log10(evaluer(expression.substring(start + 4, i)));
						break;
					case "cos":
						expressionSimplifie += Math.cos(evaluer(expression.substring(start + 4, i)));
						break;
					case "tan":
						expressionSimplifie += Math.tan(evaluer(expression.substring(start + 4, i)));
						break;
					case "abs":
						expressionSimplifie += Math.abs(evaluer(expression.substring(start + 4, i)));
						break;
					}
					expressionSimplifie += expression.substring(i + 1);
					return evaluer(expressionSimplifie);
				}
			}
			if(expressionDouble.equals(expression)) {
				throw new NumberFormatException();
			}
		}
		return evaluaterPostfix(infixToPostfix(expression));
	}

}<file_sep>/BoardPro/src/tests/MatriceUtilitairesTest.java
package tests;

import static org.junit.Assert.*;

import org.junit.Test;

import utilitaire.MatriceUtilitaires;

public class MatriceUtilitairesTest {
	int[][] mat4;
	int[][] mat1 = { { 1, 3, 7 }, { 2, 4, 8 }, { 5, 0, 6 } };
	int[][] mat2 = { { 1, 2, 1, 0 }, { 0, 3, 1, 1 }, { -1, 0, 3, 1 }, { 3, 1, 2, 0 } };
	int[][] mat3 = { { 1, 2 }, { 2, -2 } };
	int[][] mat7 = { { 7 } };

	@Test
	public void testToStringMat() {

		int[][] mat6 = {};
		assertTrue(MatriceUtilitaires.toStringMat(mat4).isEmpty());
		assertTrue(MatriceUtilitaires.toStringMat(mat6).isEmpty());
		assertTrue(MatriceUtilitaires.toStringMat(null).isEmpty());
	}

	@Test
	public void testGetMatTranspose() {
		int[][] mat13 = { { 1, 3 }, { 2, -2 } };
		int[][] mat14 = { { 1, 2 }, { 3, -2 } };
		int[][] mat5 = { { 1, 2, 5 }, { 3, 4, 0 }, { 7, 8, 6 } };
		assertTrue((MatriceUtilitaires.toStringMat(MatriceUtilitaires.getMatTranspose(mat13)))
				.equalsIgnoreCase(MatriceUtilitaires.toStringMat(mat14)));
		assertTrue((MatriceUtilitaires.toStringMat(MatriceUtilitaires.getMatTranspose(mat1)))
				.equalsIgnoreCase(MatriceUtilitaires.toStringMat(mat5)));
		assertTrue(MatriceUtilitaires.toStringMat(MatriceUtilitaires.getMatTranspose(null)) == "");
	}

	@Test
	public void testGetMatMultScalaire() {
		int[][] mat13 = { { 2, 4 }, { 4, -4 } };
		int[][] mat5 = { { 2, 6, 14 }, { 4, 8, 16 }, { 10, 0, 12 } };
		assertTrue(MatriceUtilitaires.toStringMat(MatriceUtilitaires.getMatMultScalaire(mat1, 2))
				.equalsIgnoreCase(MatriceUtilitaires.toStringMat(mat5)));
		assertTrue(MatriceUtilitaires.toStringMat(MatriceUtilitaires.getMatMultScalaire(mat3, 2))
				.equalsIgnoreCase(MatriceUtilitaires.toStringMat(mat13)));
		assertTrue(MatriceUtilitaires.toStringMat(MatriceUtilitaires.getMatMultScalaire(null, 2)) == "");
	}

	@Test
	public void testGetMatModuloX() {
		int[][] mat13 = { { 1, 0 }, { 0, 0 } };
		int[][] mat5 = { { 1, 1, 1 }, { 0, 0, 0 }, { 1, 0, 0 } };
		assertTrue(MatriceUtilitaires.toStringMat(MatriceUtilitaires.getMatModuloX(mat1, 2))
				.equalsIgnoreCase(MatriceUtilitaires.toStringMat(mat5)));
		assertTrue(MatriceUtilitaires.toStringMat(MatriceUtilitaires.getMatModuloX(mat3, 2))
				.equalsIgnoreCase(MatriceUtilitaires.toStringMat(mat13)));
		assertTrue(MatriceUtilitaires.toStringMat(MatriceUtilitaires.getMatModuloX(null, 2)) == "");

	}

	@Test
	public void testGetDeterminant() {
		assertTrue(MatriceUtilitaires.getDeterminant(mat2) == 16);
		assertTrue(MatriceUtilitaires.getDeterminant(mat3) == -6);
		assertTrue(MatriceUtilitaires.getDeterminant(mat7) == 7);

	}

	@Test
	public void testGetMatCofacteurs() {
		int[][] mat5 = { { 1, 2, 5 }, { 3, 4, 0 }, { 7, 8, 6 } };
		int[][] mat5Cofacteur = { { 24, -18, -4 }, { 28, -29, 6 }, { -20, 15, -2 } };
		assertTrue((MatriceUtilitaires.toStringMat(MatriceUtilitaires.getMatCofacteurs(mat5)))
				.equalsIgnoreCase(MatriceUtilitaires.toStringMat(mat5Cofacteur)));
		assertTrue(MatriceUtilitaires.toStringMat(MatriceUtilitaires.getMatCofacteurs(null)) == "");

	}

	@Test
	public void testGetMatAdjointe() {
		int[][] mat5 = { { 24, -18, -4 }, { 28, -29, 6 }, { -20, 15, -2 } };
		assertTrue(MatriceUtilitaires.toStringMat(MatriceUtilitaires.getMatAdjointe(mat1))
				.equalsIgnoreCase(MatriceUtilitaires.toStringMat(mat5)));
		assertTrue(MatriceUtilitaires.toStringMat(MatriceUtilitaires.getMatAdjointe(null)) == "");


	}

}
<file_sep>/BoardPro/src/composantesCircuit/Fil.java
package composantesCircuit;

import composante.CE2Entrees;
import composante.ComposanteElectrique;
import exceptions.ComposantException;
import utilitaire.Images;

/**
 * Classe des fils
 * @author <NAME>
 *
 */

  public class Fil extends ComposanteElectrique {
	/**
	 * TRUE si l'on n�glige la r�sistance des fils
	 */
	private boolean neglige = true;
	/**
	 * Quand nous changerons la variable imp�dence d'un fil, nous devrons changer
	 * r�sistance aussi. R�sistance est seulement utile pour garder la valeur de la
	 * r�sistance car si l'on n�glige le fil on met l'imp�dence � 0, si on ne
	 * n�glige plus le fil on a encore la valeur de la r�sistance.
	 */
	private float resistance;

	/**
	 * Constructeur par d�faut des fils, utile lorsque l'on place un fil dans la
	 * zone de dessin on cr�era ce fil automatiquement avec cette classe.
	 * @throws ComposantException
	 */
	private static final float RESISTANCE_DEFAUT = 2f;

	public Fil(short x, short y, Images image) throws ComposantException {
		super(RESISTANCE_DEFAUT,x,y,image);
		this.setResistance(this.getImpedence());
	}

	public boolean isNeglige() {
		return neglige;
	}

	/**
	 * Le set s'occupe aussi de changer l'impedence du fil � 0 si l'on veut n�gliger
	 * les r�sistances Puisque la classe stock la valeur de l'imp�dence avec la
	 * variable Resistance, la classe est capable de reprendre l'imp�dence du fil
	 * sans en entr�e une nouvelle lorsqu'on remet n�gliger � false.
	 *
	 * @param neglige
	 */
	public void setNeglige(boolean neglige) {
		if (neglige == true) {
			this.setImpedence(0);
		}
		if (neglige == false) {
			this.setImpedence(this.resistance);
		}
		this.neglige = neglige;
	}

	public float getResistance() {
		return resistance;
	}

	public void setResistance(float resistance) {
		this.resistance = resistance;
	}

	@Override
	public String toString() {
		return "";
	}

	
}
