/*
 * Crťť le 17 aoŻt 2004
 *
 */
package traitement.section;

import information.domaine.DomaineSimple;
import principal.Commun;
import traitement.modele.Modele;
import traitement.noeud.fonctionnel.AbstractNoeudFonctionnelPlein;
import traitement.noeud.fonctionnel.NoeudFonctionnelExogene;
import information.DomaineIncompatibleException;
import information.InformationEvent;
import information.InformationExistanteException;
import information.InformationIncompleteException;
import information.magnitude.Magnitude;
import information.magnitude.VectorMagnitude;
import information.type.Type;
import information.type.VectorType;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Vector;

import principal.copiercoller.CopiableIncompatibleException;
import principal.copiercoller.HomonymeIntrouvableException;
import principal.copiercoller.InterfaceCopiable;
import principal.copiercoller.InterfaceHomonyme;
import principal.copiercoller.Tampon;

import fichier.ContenuFichierIncompatibleException;
import fichier.TypeFichierIncompatibleException;
import fichier.VersionFichierIncompatibleException;
import fichier.flux.RageOutputStream;
import gui.InterfaceAffichable;
import traitement.TraitementEvent;
import traitement.TraitementIncompletException;

/**
 * constituants des NoeudExogenes.
 * Ce type de Section est utilisť pour gťrer la partie d'ťmission d'un NoeudFonctionnelExogene.
 * Une SectionInformationExogene possŤde son propre Domaine, et des historiques de Magnitudes et de Types
 * sous la forme d'un VectorMagnitude et d'un VectorType.
 * Elle peut ťgalement gťrer un fichier d'entrťes.
 * 
 * @author	Vincent Labatut
 * @version	1
 * @see		traitement.noeud.fonctionnel.NoeudFonctionnelExogene
  */

public class SectionInformationExogene extends AbstractSectionInformation 
{	/**
	 * Editeur de fichier d'entrťe.
	  */
	private EditeurEntree entreeEditeur;
	/**
	 * Rťpertoire contenant le fichier d'entrťe.
	  */
	private File repertoireEntree;
	
//	----------------------------------------	
//	Constructeurs
//	----------------------------------------
	/**
	 * Constructeur pour crťer une SectionInformationExogene de parent le NoeudFonctionnelExogene
	 * passť en paramŤtre.
	 * 
	 * @param	p	parent de cette SectionInformationExogene
	 * 
	  */
	public SectionInformationExogene(NoeudFonctionnelExogene p)
	{	
    	parent = p;
		//
		vectorTraitementListener = new Vector();
		//
		// domaine
		domaine = new DomaineSimple(this);
		domaine.addInformationListener(this);
		// historiques
		vectorMagnitude = new VectorMagnitude();
		Magnitude mag = new Magnitude(this);
		mag.addInformationListener(this);
		vectorMagnitude.addMagnitude(mag);
		vectorType = new VectorType();
		Type type = new Type(this);
		type.addInformationListener(this);
		vectorType.addType(type);
		//
		File repertoire = ((NoeudFonctionnelExogene)parent).getRepertoireEntree();
		if (repertoire != null)
			repertoireEntree = new File(((NoeudFonctionnelExogene)parent).getRepertoireEntree().getPath()
				+ Commun.STRING_SEPARATEUR
				+ Commun.STRING_EMISSION);
		else
			repertoireEntree = null;
		//
		entreeEditeur = new EditeurEntree(this);
		entreeEditeur.addTraitementListener(this);
		setModifie();
	}

//	----------------------------------------	
//	EditeurEntree
//	----------------------------------------
	/**
	 * renvoie l'ťditeur d'Entree de cette Section.
	 * 
	 * @return	l'EditeurEntree de cette Section.
	  */
	public EditeurEntree getEntreeEditeur()
	{	return entreeEditeur;
	}
	/**
	 * remplace l'ťditeur d'Entree de cette Section par
	 * celui passť en paramŤtre.
	 * Emission de TraitementEvent de complťtude et de raffraichissement
	 * 
	 * @param	editeur	le nouvel ťditeur d'Entree de cette Section.
	  */
	public void setEntreeEditeur(EditeurEntree editeur) throws DomaineIncompatibleException, IOException
	{	entreeEditeur.removeTraitementListener(this);
		entreeEditeur.remove();
		entreeEditeur = editeur;
		entreeEditeur.addTraitementListener(this);
		entreeEditeur.setParent(this);
		setModifie();
	    fireTraitementRaffr(new TraitementEvent(this));
	}
	/**
	 * renvoie le fichier d'entrťe.
	 * 
	 * @return	le fichier d'entrťe.
	  */
	public File getEntreeFichier()
	{	return entreeEditeur.getEntreeFichier();
	}
	/**
	 * remplace l'ancien fichier d'entrťe par celui passť en paramŤtre.
	 * Si l'editeur d'entree est actif, il est dťsactivť.
	 * Emission de TraitementEvents de raffraichissement et de complťtude.
	 * 
	 * @param	f	le nouvau fichier d'entrťe.
	 * @throws	IOException si une erreur se produit lors de la vťrification du fichier.
	 * @throws	ClassNotFoundException une erreur se produit lors de la vťrification du fichier.
	 * @throws	VersionFichierIncompatibleException le fichier n'est pas d'une version compatible.
	 * @throws	TypeFichierIncompatibleException le fichier n'est pas un fichier d'observation.
	 * @throws	ContenuFichierIncompatibleException  le contenu du fichier est erronť.
	  */
	public void setEntreeFichier(File f) throws IOException, ContenuFichierIncompatibleException, VersionFichierIncompatibleException, TypeFichierIncompatibleException 
	{	entreeEditeur.setEntreeFichier(f);
	}
	/**
	 * renvoie le nombre d'entrťes contenues dans le fichier d'entrťe.
	 * Si aucun fichier n'a encore ťtť dťfini, la taille est de 0.
	 * 
	 * @return	la taille du fichier d'entrťe.
	  */
	public int getEntreeTaille()
	{	return entreeEditeur.getEntreeTaille(); 
	}	
	/**
	 * teste si le fichier passť en paramŤtre est valide 
	 * pour devenir le fichier d'entrťe.
	 * structure d'un fichier de stimulation :
	 *	- String : version
	 *	- String : type de fichier
	 *	- DomaineSimple : domaine d'ťmission
	 *(	- Magnitude : magnitude d'ťmission
	 *	- Type : type d'ťmission ) n fois
	 *
	 * @param	f	le fichier d'entrťe ŗ tester.
	 * @return : la taille du fichier.
	 * @throws	IOException si une erreur se produit lors de la vťrification du fichier.
	 * @throws	ClassNotFoundException une erreur se produit lors de la vťrification du fichier.
	 * @throws	VersionFichierIncompatibleException le fichier n'est pas d'une version compatible.
	 * @throws	TypeFichierIncompatibleException le fichier n'est pas un fichier d'observation.
	 * @throws	ContenuFichierIncompatibleException  le contenu du fichier est erronť.
	  */
	public int testerEntreeFichier(File f) throws VersionFichierIncompatibleException, TypeFichierIncompatibleException, ContenuFichierIncompatibleException, TraitementIncompletException, InformationExistanteException, DomaineIncompatibleException, IOException, ClassNotFoundException, InformationIncompleteException
	{	return entreeEditeur.testerEntreeFichier(f);
	}
	/**
	 * crťe un nouveau fichier d'entrťe.
	 * Ce fichier est vide d'entrťe.
	 * 
	 * @throws	IOException si une erreur se produit lors de la vťrification du fichier.
	  */
	public void newEntreeFichier() throws IOException 
	{	entreeEditeur.newEntreeFichier();
	}
	/**
	 * lit l'entrťe de l'instant suivant
	 * dans le fichier d'entrťe.
	 * 
	 * @throws	IOException si une erreur se produit lors de la vťrification du fichier.
	 * @throws	ClassNotFoundException une erreur se produit lors de la vťrification du fichier.
	 * @throws	ContenuFichierIncompatibleException le contenu du fichier est erronť.
	  */
	public Vector lireEntreeFichier() throws IOException, ClassNotFoundException, ContenuFichierIncompatibleException
	{	return entreeEditeur.lireEntreeFichier();
	}
	/**
	 * enregistre fichier d'entrťe.
	 * 
	 * @throws	IOException si une erreur se produit lors de l'accŤs au fichier.
	  */
	public void enregistrerEntreeFichier() throws IOException
	{	entreeEditeur.enregistrerEntreeFichier();
	}
	/**
	 * enregistre fichier d'entrťe sous un nom/path diffťrent.
	 * 
	 * @throws	IOException si une erreur se produit lors de l'accŤs au fichier.
	  */
	public void exporterEntreeFichier(File fichier) throws IOException
	{	entreeEditeur.exporterEntreeFichier(fichier);
	}

//	----------------------------------------	
//	  This
//	----------------------------------------
	/*
	 * 
	 */
	public void remove()
	{	fireTraitementSuppr(new TraitementEvent(this));
		//
		getMagnitudeInitiale().removeInformationListener(this);
		while (vectorMagnitude.size() != 0)
		{	vectorMagnitude.getMagnitude(0).remove();
			vectorMagnitude.removeMagnitude(0);
		}
		vectorMagnitude = null;
		//
		getTypeInitial().removeInformationListener(this);
		while (vectorType.size() != 0)
		{	vectorType.getType(0).remove();
			vectorType.removeType(0);
		}
		vectorType = null;
		// Entree
		entreeEditeur.removeTraitementListener(this);
		entreeEditeur.remove();
		entreeEditeur = null;
		// domaine
		domaine.removeInformationListener(this);
		domaine.remove();
		domaine = null;
		// 
		parent = null;
		//
		if (vueType != null)
			vueType.remove();
		if (vueMagnitude != null)
			vueMagnitude.remove();
		//
		
	}

//	----------------------------------------	
//	InformationListener
//	----------------------------------------
	/*
	 * appelťe lors de la rťception d'un InformationEvent de modification de constituant.
	 * Cette SectionInformationExogene ťcoute ses Types et Magnitudes initiaux,
	 * ainsi que son Domaine.
	 * Le Type ou le Domaine peuvent ťmettre ce type d'InformationEvent.
	 * Ils dťclenchent alors l'ťmission d'un TraitementEvent de raffraichissement
	 * et d'un TraitementEvent de complťtude.
	  */
	public void informationEltModif(InformationEvent e)
	{	setModifie();
		fireTraitementRaffr(new TraitementEvent(this));
	}

//	----------------------------------------	
//	Simulation
//	----------------------------------------
	/*
	 * dťtermine si cette SectionInformationExogene est complŤtement dťfinie.
	 * Cette mťthode est appellťe juste avant la simulation.
	 * Une SectionInformationExogene est complete si son domaine est complet, 
	 * si ses historiques contiennent au moins
	 * un ťlťment chacun, et que ces ťlťments sont complets,
	 * enfin si le fichier d'entrťe
	 * est valide. 
	  */
	public boolean estComplet()
	{	boolean resultat;
		
		resultat = super.estComplet();
		if (!entreeEditeur.estComplet())
				resultat = false;
		return(resultat);
	}
	/**
	 * dťtermine si cette Section est complŤtement dťfinie.
	 * Elle est destinťe ŗ Ítre appelťe par la GUI, et par consťquent 
	 * les tests effectuťs sont moins stricts que dans le cas de la
	 * mťthode estComplet, qui est, elle, destinťe ŗ prťvenir la simulation
	 * de tout problŤme. En particulier, ici, on ne teste pas le contenu
	 * des fichiers dans la mťthode.
	 * 
	 * @return 	vrai si cette Section est complŤtement dťfinie.
	  */
	public boolean estCompletInterface()
	{	boolean resultat;
		
		resultat = super.estComplet();
		if (!entreeEditeur.estCompletInterface())
				resultat = false;
		return(resultat);
	}

	/**
	 * prťpare la Section ŗ la simulation. 
	 * 
	  */
	public int preparerSimulation() throws IOException, ContenuFichierIncompatibleException
	{	int resultat;
	    // on prťpare le rťpertoire de simulation
		setRepertoireSimulation(new File
			(	getParent().getRepertoireSimulation().getPath()
				+File.separator
				+Commun.STRING_EMISSION
			));
		//
		resultat = entreeEditeur.preparerSimulation();
		getTypeInitial().normaliser();
		return resultat;
	}
	/**
	 * interrompt la simulation, c'est ŗ dire que les Noeuds doivent
	 * Ítre rťinitialisťs et les fichiers ouverts doivent Ítre fermťs.
	 * 
	 * @throws	 IOException	si une erreur survient lors de l'accŤs au fichier.
	 * @throws	 ContenuFichierIncompatibleException	si le contenu du fichier est erronť.
	 * @throws	 VersionFichierIncompatibleException	si la version de Rage qui a gťnťrť le fichier n'est pas compatible avec cette version-ci.
	 * @throws	 TypeFichierIncompatibleException	le fichier n'est pas un fichier de resultats.
	  */
	public void interrompreSimulation() throws ContenuFichierIncompatibleException, VersionFichierIncompatibleException, TypeFichierIncompatibleException, IOException
	{	entreeEditeur.interrompreSimulation();

		// on supprime toutes les valeurs sauf l'initiale
		while (vectorType.size()>1)
		{	vectorType.getType(1).remove();
			vectorType.removeType(1);
		}
		while (vectorMagnitude.size()>1)
		{	vectorMagnitude.getMagnitude(1).remove();
			vectorMagnitude.removeMagnitude(1);
		}
	}
	/**
	 * finalise la simulation dans cette Section. 
	 * 
	 * @throws	 IOException	si une erreur survient lors de l'accŤs au fichier.
	 * @throws	 ContenuFichierIncompatibleException	si le contenu du fichier est erronť.
	 * @throws	 VersionFichierIncompatibleException	si la version de Rage qui a gťnťrť le fichier n'est pas compatible avec cette version-ci.
	 * @throws	 TypeFichierIncompatibleException	le fichier n'est pas un fichier de resultats.
	  */
	public void terminerSimulation() throws IOException, ContenuFichierIncompatibleException, VersionFichierIncompatibleException, TypeFichierIncompatibleException
	{	// on enregistre les rťsultats de Type
		File fichier = new File
			(	getRepertoireSimulation().getPath()
				+"-"
				+Commun.STRING_TYPE
				+Commun.EXT_RESULTAT);	
		FileOutputStream out = null;
		RageOutputStream outputStream;
		try
		{	out = new FileOutputStream(fichier);
			outputStream = new RageOutputStream(out);
			// on ťcrit la version du fichier
			outputStream.writeObject(Commun.VERSION);
			// on ťcrit le type de fichier
			outputStream.writeObject(Commun.FICHIER_CODE_RESULTAT);
			// le Domaine d'emission
			outputStream.writeDomaine(getDomaine());
			// la taille du Vector ŗ ťcrire
			outputStream.writeObject(new Integer(vectorType.size()));
			// et enfin chaque information			
			for (int i=0;i<vectorType.size();i++)
				outputStream.writeType(vectorType.getType(i));
			out.close();
		}
		catch (FileNotFoundException e)
		{	if (out != null)
				out.close();
			effacerHistorique();
			entreeEditeur.terminerSimulation();
			throw e;
		}
		catch (IOException e)
		{	if (out != null)
				out.close();
			effacerHistorique();
			entreeEditeur.terminerSimulation();
			throw e;
		}

		// on enregistre les rťsultats de Magnitude
		fichier = new File
			(	getRepertoireSimulation().getPath()
				+"-"
				+Commun.STRING_MAGNITUDE
				+Commun.EXT_RESULTAT);
		try
		{	out = new FileOutputStream(fichier);
			outputStream = new RageOutputStream(out);
			// on ťcrit la version du fichier
			outputStream.writeObject(Commun.VERSION);
			// on ťcrit le type de fichier
			outputStream.writeObject(Commun.FICHIER_CODE_RESULTAT);
			// la taille du Vector ŗ ťcrire
			outputStream.writeObject(new Integer(vectorMagnitude.size()));
			// et enfin chaque information			
			for (int i=0;i<vectorMagnitude.size();i++)
				outputStream.writeMagnitude(vectorMagnitude.getMagnitude(i));
			out.close();
		}
		catch (FileNotFoundException e)
		{	if (out != null)
				out.close();
			effacerHistorique();
			entreeEditeur.terminerSimulation();
			throw e;
		}
		catch (IOException e)
		{	if (out != null)
				out.close();
			effacerHistorique();
			entreeEditeur.terminerSimulation();
			throw e;
		}
		//
		effacerHistorique();
		//
		entreeEditeur.terminerSimulation();			
	}
	/*
	 * 
	 */
	public void recupererResultat() throws VersionFichierIncompatibleException, TypeFichierIncompatibleException, ContenuFichierIncompatibleException, IOException, ClassNotFoundException, InformationIncompleteException, TraitementIncompletException
	{	setRepertoireSimulation(new File
		(	getParent().getRepertoireSimulation().getPath()
			+File.separator
			+Commun.STRING_EMISSION
		));
		super.recupererResultat();
	}
	
//	----------------------------------------	
//	  Copier/Coller
//	----------------------------------------
	/*
	 * renvoie une copie de cette SectionInformationExogene.
	 * La nouvelle SectionInformationExogene a le mÍme parent que cette SectionInformationExogene, 
	 * mais c'est temporaire : la copie est destinťe ŗ 
	 * Ítre insťrťe dans un autre Noeud.
	 * Les historiques, et le Domaine qui composent 
	 * la copie sont des copies de celles de cette SectionInformationExogene.
	 * Le fichier d'entrťe est le mÍme.
	 * Le Domaine doit Ítre clonť en premier.
	  */
	public AbstractSectionInformation cloner()
	{	SectionInformationExogene resultat;
		
		// COPIE
		resultat = new SectionInformationExogene((NoeudFonctionnelExogene)parent);
		try
		{	// Domaines
			//resultat.setDomaine(domaine.cloner()); inutile de cloner puisque le domaine est recopiť
		    resultat.setDomaine(domaine);
			// Historiques
			resultat.setMagnitudeInitiale(getMagnitudeInitiale().cloner());
			resultat.setTypeInitial(getTypeInitial().cloner());
/*
			for (int i=0;i<vectorMagnitude.size();i++)
				resultat.addMagnitude(vectorMagnitude.getMagnitude(i).cloner());
			for (int i=0;i<vectorType.size();i++)
				resultat.addType(vectorType.getType(i).cloner());
*/				
			// entrees
			EditeurEntree temp = entreeEditeur.cloner();
			resultat.setEntreeEditeur(temp);
		}
		catch (DomaineIncompatibleException e)
		{	e.printStackTrace();
		}
		catch (IOException e)
		{	e.printStackTrace();
		}
		resultat.setNonModifie();
		return resultat;
	}

//	NOTE quand on supprime un modele/noeud, on supprime le fichier d'entrťe/observation correspondant ?
//	NOTE quand on modifie le nom d'un modele/noeud, on dťplace le fichier d'entrťe/observation correspondant ?

	/*
	 * 
	 */
	public InterfaceHomonyme getHomonyme(Modele modele) throws HomonymeIntrouvableException
	{	InterfaceHomonyme resultat = null;
		
		if (modele==getModele())
			resultat = this;
		else
			resultat = ((NoeudFonctionnelExogene)parent.getHomonyme(modele)).getSectionEmission();
								
		return resultat;
	}
	/*
	 * colle dans cette SectionInformationExogene un Type ou une Magnitude contenue dans le Tampon, 
	 * qui vient remplacer le Type ou la Magnitude inital.
	 * Le Domaine ne peut pas Ítre collť.
	 * Une ObjetRageIncompatibleException est levťe si l'objet n'est 
	 * pas une Magnitude ou un Type, ou plus gťnťralement s'il est incompatible.
	  */
	public void coller() throws CopiableIncompatibleException
	{	Tampon tampon = getModele().getTampon();
		if (tampon.estVide())
			throw new CopiableIncompatibleException(getIdentification());
		InterfaceCopiable buffer = tampon.get();
		if (buffer instanceof Type)
		{	Type temp = (Type) buffer;
			try
			{	setTypeInitial(temp);
			}
			catch (DomaineIncompatibleException e)
			{	throw new CopiableIncompatibleException(getIdentification());
			}					
		}
		else if (buffer instanceof Magnitude)
		{	Magnitude temp = (Magnitude) buffer;
			setMagnitudeInitiale(temp);
		}
		else
			throw new CopiableIncompatibleException(getIdentification());
	}

//	----------------------------------------	
//	InterfaceAffichable
//	----------------------------------------
	/*
	 * 
	 */
	public void remplacer(InterfaceAffichable a)
	{	SectionInformationExogene sif = (SectionInformationExogene) a;
		getMagnitudeInitiale().remplacer(sif.getMagnitudeInitiale());
		//
		getTypeInitial().remplacer(sif.getTypeInitial());
		// Entree
		entreeEditeur.cacher();
		// domaine
		domaine.remplacer(sif.getDomaine());
		//
		fireTraitementRempl(new TraitementEvent(this,(SectionInformationExogene)a));
	}
	/*
	 * 
	 */
	public void cacher()
	{	getMagnitudeInitiale().cacher();
		//
		getTypeInitial().cacher();
		// Observation
		entreeEditeur.cacher();
		// domaine
		domaine.cacher();
		//
		fireTraitementCache(new TraitementEvent(this));
	}


//	----------------------------------------	
//	Divers
//	----------------------------------------
	/*
	 * 
	 */
	public String toString()
	{	StringBuffer resultat;
		
		resultat = new StringBuffer();
		resultat.append("Domaine : "+domaine.getNom());
		resultat.append("Type initial : "+getTypeInitial());
		resultat.append("Magnitude initiale : "+getMagnitudeInitiale());
		if (entreeEditeur.getEntreeFichier() != null)
			resultat.append("Fichier d'observation : "+entreeEditeur.getEntreeFichier().getName());
		else
			resultat.append("Pas de fichier d'entrťe dťfini");
		return(resultat.toString());
	}
	/**
	 * rťcupŤre le rťpertoire d'entrťe du parent et le complŤte de maniŤre
	 * ŗ construire le rťpertoire d'entrťe de cette Section.  
	 * 
	 * @throws	IOException	si une erreur se produit lors de l'accŤs au rťpertoire.
	 * 
	  */
	public void raffraichirRepertoireEntree() throws IOException
	{	File repertoire = ((NoeudFonctionnelExogene)parent).getRepertoireEntree();
		if (repertoire != null)
		{	repertoireEntree = new File(repertoire.getPath()
				+ Commun.STRING_SEPARATEUR
				+ Commun.STRING_EMISSION);
		}
		else
			repertoireEntree = null;
		entreeEditeur.raffraichirRepertoireEntree();
	}
	/**
	 * renvoie le rťpertoire contenant le fichier d'entrťe de cette Section.  
	 * 
	 * @return	le rťpertoire du fichier d'entrťe.
	 * 
	  */
	public File getRepertoireEntree()
	{	return repertoireEntree;
	}
	
//	----------------------------------------	
//	Parent
//	----------------------------------------
	/*
	 * 
	 */
	public void setParent(AbstractNoeudFonctionnelPlein n)
	{	super.setParent(n);
		try
		{	raffraichirRepertoireEntree();
		}
		catch (IOException e)
		{	e.printStackTrace();
		}
	}
	/**
	 * renvoie vrai si un fichier d'entrťe a ťtť dťfini pour cette Section.
	 *
	 * @return	vrai si cette Section possŤde un fichier d'entrťe. 
	  */
	public boolean estEntreeFichierAffecte()
	{	return entreeEditeur.estEntreeFichierAffecte();
	}
	/**
	 * modifie l'indicateur d'entrťe de cette Section ŗ vrai ou faux suivant
	 * la valeur passťe en paramŤtre.  
	 *
	 * @param	flag	nouvelle valeur de l'indicateur d'entrťe. 
	  */
	public void setEntreeFichierAffecte(boolean flag) throws VersionFichierIncompatibleException, TypeFichierIncompatibleException, ContenuFichierIncompatibleException, IOException, ClassNotFoundException, InformationIncompleteException, TraitementIncompletException
	{	entreeEditeur.setEntreeFichierAffecte(flag);
	}
	/*
	 * 
	 */
	public String getIdentification()
	{	return parent.getIdentification()+">"+Commun.STRING_EMISSION;
	}

//	----------------------------------------	
//	Modification
//	----------------------------------------
	/*
	 * 
	 */
  public void setNonModifie()
  {	modifie = false;
	getMagnitudeInitiale().setNonModifie();
	getTypeInitial().setNonModifie();
	entreeEditeur.setNonModifie();
    domaine.setNonModifie();
	fireTraitementRaffr(new TraitementEvent(this));
  }

//	----------------------------------------	
//	TraitementListener
//	----------------------------------------
	/*
	 * appelťe lors de la rťception d'un TraitementEvent de raffraichissement.
	 * La SectionInformationExogene ťcoute son EditeurEntree.
	 * On transmet l'ťvŤnement.
	  */
	public void traitementRaffr(TraitementEvent e)
	{	if (e.getSource().estModifie())
		{    setModifie();
			fireTraitementRaffr(new TraitementEvent(this));
		}
	}
}