diff --git a/src/jcl/Classification.java b/src/jcl/Classification.java
index 453241b9c7a6a4b22a4513a5d2492c3d90f303cf..d09a43795fddff5fb04d25fd224bc267dba6230e 100644
--- a/src/jcl/Classification.java
+++ b/src/jcl/Classification.java
@@ -4,6 +4,7 @@ import java.awt.Color;
 import java.io.IOException;
 import java.io.Serializable;
 import java.text.NumberFormat;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Observable;
 import java.util.Vector;
@@ -19,6 +20,8 @@ import jcl.jcld.RmiServer;
 import jcl.jcld.database.SSHParameters;
 import jcl.learning.LearningMethod;
 import jcl.learning.methods.ClassifierUtils;
+import jcl.utils.ProgressMonitor;
+import jcl.utils.Progressable;
 import jcl.utils.exceptions.JCLFormatException;
 import jcl.utils.exceptions.MethodNotImplementedException;
 
@@ -32,10 +35,12 @@ import jcl.utils.exceptions.MethodNotImplementedException;
  * </p>
  * 
  * @author WEMMERT Cedric
+ * 
+ * Implementation progressable avec liste de sous-processus progressable à suivre par Jean-Noël Balanche
  */
 
 public abstract class Classification extends Observable implements
-		Serializable, Cloneable {
+		Progressable, Serializable, Cloneable {
 
 	/**	 */
 	private static final long serialVersionUID = 1L;
@@ -49,7 +54,7 @@ public abstract class Classification extends Observable implements
 	/** paramtre de la connection ssh si besoin */
 	public SSHParameters sshParameters = null;
 
-	/** panel ou il faut afficher la non disponibiliter du server rmi */
+	/** panel ou il faut afficher la non disponibilite du server rmi */
 	transient public JPanel container_;
 
 	/** titre de la classid pour le tabedpane en hybridclassification */
@@ -68,7 +73,24 @@ public abstract class Classification extends Observable implements
 	/** Le nom de la classification */
 	private String name = "";
 	
+	/**
+	 * Parametre de progression pour l'affichage eventuel d'une barre de
+	 * progression
+	 */
+	protected int 						progress 					= 0;
+
+	/** Valeur maximale de la progression */
+	protected int 						progressM 					= 100;
+	
+	/** Name of the current step of learning */
+	protected String						statusName					= "Loading";
+	
+	/**
+	 * The list of all the progressable to monitor
+	 */
+	protected ArrayList<Progressable> progressableList = new ArrayList<Progressable>();
 
+	
 	/**
 	 * <p>
 	 * Methode utilisee pour le debuggage. Affiche le contenu de la memoire.
@@ -767,5 +789,113 @@ public abstract class Classification extends Observable implements
 	 * @return the Classification generated
 	 */
 	public abstract Classification ImportResult(String model, int classifIndex) throws MethodNotImplementedException, JCLFormatException;
+	
+	/**
+	 * <p>
+	 * Fin de la progression.
+	 * </p>
+	 */
+	@Override
+	public void endProgress() {
+		this.progress = this.progressM;
+	}
+
+	/**
+	 * <p>
+	 * Incrementation du niveau de progression.
+	 * </p>
+	 */
+	@Override
+	public void incProgress() {
+		this.progress++;
+	}
+	
+	/**
+	 * <p>
+	 * Remise e zero du niveau de progression.
+	 * </p>
+	 */
+	@Override
+	public void resetProgress() {
+		this.progress = 0;
+	}
+	
+	@Override
+	public void setProgress(final int value) {
+		this.progress = value;
+	}
+	
+	@Override
+	public void setStatus(String status)
+	{
+		this.statusName = status;
+		
+	}
+
+	@Override
+	public String getStatus()
+	{
+		String status = "Preparing ... ";
+		boolean allEnded = true; //boolean for the stop condition
+
+		if(!this.progressableList.isEmpty()) {
+			for (int i = 0 ; i < this.progressableList.size(); i++) {
+				if (this.progressableList.get(i) != null) {
+					if (this.progressableList.get(i).getProgress() != 100) {
+						status = "Step "+ (i+1) + "/" + (this.progressableList.size()+1) + " : " + this.progressableList.get(i).getStatus();
+						allEnded = false;
+					}
+				}
+			} 
+		}
+		if(allEnded) {//return the usual value (this.status) when all progressables are done (to monitor the final step which is displaying the result)
+			status = this.statusName;
+		}
+		return status;
+	}
+
 
+	@Override
+	public int getProgress() 
+	{
+		int progress = 0;
+		boolean allEnded = true; //boolean for the stop condition
+		
+		if(!this.progressableList.isEmpty()) {
+			for (Progressable p : this.progressableList) {
+				if(p!=null) {
+					if (p.getProgress() != 100) {
+						progress=p.getProgress();
+						allEnded=false;
+					}
+				}
+			}
+		}
+		if(allEnded) {//return the usual value (this.progress) when all progressables are done (to monitor the final step which is displaying the result)
+			progress = this.progress;
+			//System.out.println("all progressable ended");
+		}
+		return progress;
+	}
+	
+	/**
+	 * Add a progressable to monitor
+	 * @param p the progressable to add
+	 */
+	public void addProgressable(Progressable p) {
+		this.progressableList.add(p);
+	}
+	
+	/**
+	 * Get the list of all the progressables to monitor in this classification
+	 * @return the progressable list
+	 */
+	public ArrayList<Progressable> getProgressableList(){
+		return this.progressableList;
+	}
+	
+	
+	
+
+	
 }
diff --git a/src/jcl/evaluation/clustering/ClusteringEvaluation.java b/src/jcl/evaluation/clustering/ClusteringEvaluation.java
index caaa278e950a293504d0e5b2e614ca660f769e42..5cff735c91b7c256952140f54b2c5933dfef7c7f 100644
--- a/src/jcl/evaluation/clustering/ClusteringEvaluation.java
+++ b/src/jcl/evaluation/clustering/ClusteringEvaluation.java
@@ -1170,7 +1170,6 @@ public class ClusteringEvaluation {
 		int CPindex = 2;
 
 		ClusteringResult clusteringResult = classification.getClusteringResult();
-		
 		Iterator<DataObject> iter = clusteringResult.getData().getWholeSourceDataObjects();
 		
 		// initialization for WG
@@ -1184,11 +1183,13 @@ public class ClusteringEvaluation {
 		for (int k = 0; k < clusteringResult.getNbClusters(); k++) {
 			clustersSE[k] = 0;
 		}
+		
+		double step  = 100./clusteringResult.getNbObjects();
+		double progress = classification.getProgress()+step;
 
 		for(int n = 0 ; iter.hasNext() ; n++) {
 			DataObject object = iter.next();
-			int currentCluster = clusteringResult.getClusterMap(false)[n];
-			
+			int currentCluster = clusteringResult.getClusterMap(false)[n];			
 			
 			// compute for WG 
 			double distMinWG = Double.MAX_VALUE;
@@ -1212,7 +1213,12 @@ public class ClusteringEvaluation {
 			// compute for Square Error
 			final double distanceSE = clusteringResult.getCluster(currentCluster).distance(currentCluster);
 			qualities[SEindex] += (distanceSE * distanceSE);
-			
+			/* 
+			 * increments classification's progressable (for the "Displaying" step) 
+			 */
+			progress+=step;
+			classification.setProgress((int)progress);
+
 		}
 		
 		// merge result for WG
diff --git a/src/jcl/learning/LearningMethod.java b/src/jcl/learning/LearningMethod.java
index 0581af8f4ffcb2ae892b29232a8acb2b0da3aa83..6a5f990a060284085af70d302aed28fd32dc31d5 100644
--- a/src/jcl/learning/LearningMethod.java
+++ b/src/jcl/learning/LearningMethod.java
@@ -365,7 +365,7 @@ public abstract class LearningMethod implements Progressable, Cloneable,
 	 */
 	@Override
 	public void setProgress(final int value) {
-		this.progressM = value;
+		this.progress = value;
 	}
 	
 	@Override
diff --git a/src/jcl/learning/LearningResult.java b/src/jcl/learning/LearningResult.java
index 543cf67410722bfea127ead31c88baa19f78d500..96857973cd32a11b67ae06b7c4c77a72d2450f71 100644
--- a/src/jcl/learning/LearningResult.java
+++ b/src/jcl/learning/LearningResult.java
@@ -7,6 +7,7 @@ import java.util.List;
 import jcl.Classification;
 import jcl.clustering.ClusteringResult;
 import jcl.data.Data;
+import jcl.utils.Progressable;
 import jcl.utils.exceptions.JCLFormatException;
 import jcl.utils.exceptions.MethodNotImplementedException;
 import jcl.weights.ClassificationWeights;
@@ -21,7 +22,7 @@ import jcl.weights.ClassificationWeights;
  * @author WEMMERT Cedric
  */
 
-public abstract class LearningResult extends Object implements Serializable {
+public abstract class LearningResult extends Object implements Progressable,Serializable {
 
 	/**	 */
 	private static final long 			serialVersionUID = 1L;
@@ -46,7 +47,20 @@ public abstract class LearningResult extends Object implements Serializable {
 	
 	/** allow to specify a specific set of colors to all clustering result generated by this model */
 	protected List<Color>				colors = null;
+	
+	/**
+	 * Parametre de progression pour l'affichage eventuel d'une barre de
+	 * progression
+	 */
+	protected int 						progress 					= 0;
 
+	/** Valeur maximale de la progression */
+	protected int 						progressM 					= 100;
+	
+	/** Name of the current step of learning */
+	private String						statusName					= "Classifying";
+	
+	
 	/**
 	 * <p>
 	 * Constructeur a partir d'un ensemble de parametres et de ponderations.
@@ -204,4 +218,72 @@ public abstract class LearningResult extends Object implements Serializable {
 	 * @return the LearningResult generated
 	 */
 	protected abstract LearningResult ImportResult(String model) throws MethodNotImplementedException, JCLFormatException;
+	
+	/**
+	 * <p>
+	 * Fin de la progression.
+	 * </p>
+	 */
+	@Override
+	public void endProgress() {
+		this.progress = this.progressM;
+	}
+	
+	/**
+	 * <p>
+	 * Accesseur au niveau de progression des calculs.
+	 * </p>
+	 * 
+	 * @return le compteur de progression
+	 */
+	@Override
+	public int getProgress() {
+		return (int) (((double) this.progress / (double) this.progressM) * 100.0);
+	}
+
+	/**
+	 * <p>
+	 * Incrementation du niveau de progression.
+	 * </p>
+	 */
+	@Override
+	public void incProgress() {
+		this.progress++;
+	}
+	
+	/**
+	 * <p>
+	 * Remise e zero du niveau de progression.
+	 * </p>
+	 */
+	@Override
+	public void resetProgress() {
+		this.progress = 0;
+	}
+	
+	/**
+	 * <p>
+	 * Modification du niveau de progression des calculs.
+	 * </p>
+	 * 
+	 * @param value
+	 *            la nouvelle valeur du compteur de progression
+	 */
+	@Override
+	public void setProgress(final int value) {
+		this.progress = value;
+	}
+	
+	@Override
+	public void setStatus(String status)
+	{
+		statusName = status;
+		
+	}
+
+	@Override
+	public String getStatus()
+	{
+		return statusName;
+	}
 }
diff --git a/src/jcl/learning/methods/monostrategy/SingleClassification.java b/src/jcl/learning/methods/monostrategy/SingleClassification.java
index 06d901d89dc8d3026453d9868e940d44c47e7cb3..0f0aca8d18cb1a45c0f51aa52863ae89289ddc25 100644
--- a/src/jcl/learning/methods/monostrategy/SingleClassification.java
+++ b/src/jcl/learning/methods/monostrategy/SingleClassification.java
@@ -7,6 +7,7 @@ import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.util.ArrayList;
+import java.util.Date;
 import java.util.Vector;
 
 import javax.naming.Context;
@@ -26,6 +27,7 @@ import jcl.learning.methods.ClassifierUtils;
 import jcl.learning.methods.monostrategy.ahc.LearningResultAHC;
 import jcl.learning.methods.monostrategy.ahc.ParametersAHC;
 import jcl.learning.methods.monostrategy.kmeans.LearningResultKmeans;
+import jcl.utils.Progressable;
 import jcl.utils.exceptions.JCLFormatException;
 import jcl.utils.exceptions.MethodNotImplementedException;
 import jcl.weights.ClassificationWeights;
@@ -322,6 +324,12 @@ public class SingleClassification extends Classification {
 
 	@Override
 	public void classify() {
+		/* 
+		 * Add all the processes to monitor in the list (they have to implement progressable) 
+		 */
+		this.addProgressable(this.learningMethod);
+		this.addProgressable(null);// had null because this.learningResult is not defined yet
+
 		if (this.useRmi() && !this.isMaclaw()) {
 			if (this.sshParameters == null) {
 				this.rmiClassify();
@@ -330,16 +338,19 @@ public class SingleClassification extends Classification {
 			}
 		} else {
 			if (this.learningResult == null) {
-				// System.out.println("debut learn");
+//				System.out.println("debut learn "+new Date().toString());
 				this.learn();
-				// System.out.println("fin learn");
+//				System.out.println("fin learn "+new Date().toString());
 			}
-
+			
+			this.progressableList.set(1, this.learningResult);// now this.learningResult isn't null anymore so we can add him
+			
+//			System.out.println("debut classify "+new Date().toString());
 			this.clusteringResult = this.learningResult
 					.classify(this.classificationData, false);
-
+//			System.out.println("fin classify "+new Date().toString());
+			
 			this.clusteringResult.setMethode(this.learningMethod.getType());
-
 			/*
 			 * si l'utilisateur souhaite une classification hierarchique, il
 			 * faut encore appliquer l'algorithme de classification hierarchique
@@ -459,7 +470,7 @@ public class SingleClassification extends Classification {
 			this.learningMethod.sshparameters = this.sshParameters;
 			this.learningMethod.container_ = this.container_;
 		}
-		// System.out.println(this.learningMethod.getName()+" starts to learn");
+//		System.out.println(this.learningMethod.getName()+" starts to learn");
 		this.learningResult = this.learningMethod
 				.learn(this.classificationData);
 	}
@@ -610,4 +621,8 @@ public class SingleClassification extends Classification {
 		return result;
 	}
 
+	
+	
+	
+
 }
diff --git a/src/jcl/learning/methods/monostrategy/kmeans/ClassifierKmeans.java b/src/jcl/learning/methods/monostrategy/kmeans/ClassifierKmeans.java
index 97da418d567579810573c26e626ca413d2c8f847..6a38a2ba1d99fa416f84ecd8975dbdf61f358d06 100644
--- a/src/jcl/learning/methods/monostrategy/kmeans/ClassifierKmeans.java
+++ b/src/jcl/learning/methods/monostrategy/kmeans/ClassifierKmeans.java
@@ -281,6 +281,7 @@ public class ClassifierKmeans extends LearningMethod {
 	@Override
 	public LearningResult learn(Data data) {
 		this.progressM = this.getNbIters();
+		
 		LearningResultKmeans result = new LearningResultKmeans(data, (ParametersKmeans) this.parameters, this.samples);
 
 		this.initViewers(result);
diff --git a/src/jcl/learning/methods/monostrategy/kmeans/LearningResultKmeans.java b/src/jcl/learning/methods/monostrategy/kmeans/LearningResultKmeans.java
index 356e26baaafaf33688ae5ce738ea5c535531e3b6..dbe24991778755cbe4c0b64a8b72d00c4ca36688 100644
--- a/src/jcl/learning/methods/monostrategy/kmeans/LearningResultKmeans.java
+++ b/src/jcl/learning/methods/monostrategy/kmeans/LearningResultKmeans.java
@@ -139,7 +139,6 @@ public class LearningResultKmeans extends LearningResult {
 
 	@Override
 	public ClusteringResult classify(Data data, boolean fromSample) {
-		
 		for (int i = 0 ; i < this.seeds.size() ; i++) {
 			if (this.seeds.get(i) instanceof LightHardSeed) {
 				((LightHardSeed) this.seeds.get(i)).setId(i);
@@ -147,10 +146,9 @@ public class LearningResultKmeans extends LearningResult {
 		}
 //		long startT = System.nanoTime(); 
 //		System.out.println("start at "+startT);
-		int clusterMap[] = this.clusterAffectation(data,fromSample);
+		int clusterMap[] = this.clusterAffectation(data,fromSample);// !!!
 //		long endT = System.nanoTime();
 //		System.out.println("endat "+ endT + " total of "+ (endT - startT)/1000000000l);
-		
 		ClusteringResult result = null;
 
 		if (((ParametersKmeans) this.params).fuzzy) {
@@ -163,7 +161,6 @@ public class LearningResultKmeans extends LearningResult {
 			result = ClusteringResult.gerenerateDefaultClusteringResult(this, clusterMap, null, this.weights,
 					this.seeds.size(), null, data, this.qualityIndices, getColors());
 		}
-
 		return result;
 	}
 
@@ -257,8 +254,11 @@ public class LearningResultKmeans extends LearningResult {
 		} else {
 			nbObjects = data.getWholeDataNbObjects();
 		}
-		int clusterMap[] = new int[nbObjects];
+		
+		this.progressM=nbObjects;
+		this.resetProgress();
 
+		int clusterMap[] = new int[nbObjects];
 		int nbThreads = ((ParametersKmeans) this.params).nbThreads;
 		nbThreads = 1;
 		if (((ParametersKmeans) this.params).fuzzy) {
@@ -347,7 +347,7 @@ public class LearningResultKmeans extends LearningResult {
 							this.weights, this.seeds);
 				}
 				tabThreads[nbThreads - 1].start();
-
+				
 				for (int th = 0; th < nbThreads; th++) {
 					try {
 						tabThreads[th].join();
@@ -899,6 +899,7 @@ public class LearningResultKmeans extends LearningResult {
 				threadGlobalDistance += distMin;
 
 				//((HardSeed) seeds.get(clusterMap[i])).addObject(obj);
+				incProgress();
 				i++;
 			}
 //			writer.close();
diff --git a/src/jcl/utils/ProgressMonitor.java b/src/jcl/utils/ProgressMonitor.java
new file mode 100644
index 0000000000000000000000000000000000000000..9d17cd6e5c4878e0647b98d9904bf1fa9f47c096
--- /dev/null
+++ b/src/jcl/utils/ProgressMonitor.java
@@ -0,0 +1,75 @@
+package jcl.utils;
+
+/**
+ * ??
+ * @author Jean-Noël Balanche
+ *
+ */
+
+
+public interface ProgressMonitor {
+	/**
+	 * ??
+	 * @param id ??
+	 */
+	public void incProgress(int id);
+	
+	/**
+	 * <p>
+	 * Methode de decrementation de l'indice de progression.
+	 * </p>
+	 * 
+	 */
+	public void endMonitorProgress();
+
+	/**
+	 * <p>
+	 * Methode d'acces au pourcentage en cours de la progression.
+	 * </p>
+	 * 
+	 * @return le pourcentage (entre 0 et 100) de la progression
+	 */
+	public int getMonitorProgress();
+
+	/**
+	 * <p>
+	 * Methode d'incrementation de l'indice de progression.
+	 * </p>
+	 */
+	public void incMonitorProgress();
+
+	/**
+	 * <p>
+	 * Methode de remise a zero de l'indice de progression.
+	 * </p>
+	 */
+	public void resetMonitorProgress();
+
+	/**
+	 * <p>
+	 * Methode de modification du pourcentage de progression.
+	 * </p>
+	 * 
+	 * @param value
+	 *            la nouvelle valeur
+	 */
+	public void setMonitorProgress(int value);
+	
+	/**
+	 * <p>
+	 * Methode de modification du status.
+	 * </p>
+	 * 
+	 * @param status
+	 */
+	public void setMonitorStatus(String status);
+	
+	/**
+	 * <p>
+	 * Methode d'acces au status.
+	 * </p>
+	 * 
+	 * @param status
+	 */
+	public String getMonitorStatus();
+}
\ No newline at end of file