/*
 * Créé le 25 juil. 2004
 *
 */
package traitement.section;

import information.DomaineIncompatibleException;
import information.InformationEvent;
import information.InformationExistanteException;
import information.InformationIncompleteException;
import information.InformationListener;
import information.InterfaceInformation;
import information.domaine.DomaineSimple;
import information.domaine.InterfaceContientDomaine;
import information.domaine.InterfaceDomaine;
import information.magnitude.InterfaceContientMagnitude;
import information.magnitude.Magnitude;
import information.magnitude.VectorMagnitude;
import information.type.InterfaceContientType;
import information.type.Type;
import information.type.VectorType;

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

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

import fichier.ContenuFichierIncompatibleException;
import fichier.TypeFichierIncompatibleException;
import fichier.VersionFichierIncompatibleException;
import fichier.flux.RageInputStream;
import fichier.flux.RageOutputStream;
import gui.InterfaceAffichable;
import traitement.InterfaceTraitement;
import traitement.TraitementAdapter;
import traitement.TraitementEvent;
import traitement.TraitementIncompletException;
import traitement.TraitementListener;
import traitement.modele.Modele;

/**
 * permet d'éditer le fichier d'entree d'une SectionInformationExogene.
 * 
 * @author	Vincent Labatut
 * @version	1
 * @see		traitement.section.SectionInformationExogene
 * @see		traitement.section.RepertoireType
  */

public class EditeurEntree extends TraitementAdapter implements InterfaceTraitement, TraitementListener, InformationListener, InterfaceContientMagnitude, InterfaceContientType, InterfaceAffichable, InterfaceContientDomaine, InterfaceCollable
{	/**
	* Fichier d'entrée.
	 */
   private File entreeFichier;
   /**
	* Taille du fichier d'entrée.
	 */
   private int entreeTaille;
   /**
	* Flux du fichier d'entrée.
	 */
   private	RageInputStream entreeInput;
   /**
   * Liste des Types d'entrée, sous forme d'un VectorType.
	*/
   private VectorType vType;
	/**
	* Liste des Magnitudes d'entrée, sous forme d'un VectorMagnitude.
	 */
	private VectorMagnitude vMagnitude;
	/**
	* Répertoire de Types utilisé pour facilité l'édition.
	 */
	private RepertoireType repertoire;
	/**
	* Liste des TraitementListeners ŕ l'écoute de cet EditeurObservation.
	 */
	private Vector vectorTraitementListener;
	/**
	* SectionInformationEndogene parent de cet EditeurObservation.
	 */
	private SectionInformationExogene parent;
	/**
	* Compteur utilisé pour définir les noms de Types nouvellement créés.
	 */
	private int compteur;
	/**
	* Indicateur permettant de savoir si un fichier a été 
	* affecté ŕ l'Editeur.
	 */
	private boolean entreeFichierAffecte;
	/**
	 * indique si cet objet a été modifé depuis sa derničre sauvegarde.
	  */
	private boolean modifie;
	
//	----------------------------------------	
//	Constructeurs
//	----------------------------------------
	/**
	 * Constructeur pour créer un EditeurEntree
	 * de parent la SectionInformationExogene
	 * passée en paramčtre.
	 * 
	 * @param	n	parent de cet EditeurEntree.
	 * 
	  */
	public EditeurEntree(SectionInformationExogene n) 
	{	
    	parent = n;
		//
		vType = new VectorType();
		vMagnitude = new VectorMagnitude();
		//
		vectorTraitementListener = new Vector();
		//
		compteur = 0;
		//
		entreeTaille = 0;
		//
		File rep = parent.getRepertoireEntree();
		if (rep != null)
			entreeFichier = new File(rep.getPath()
				+ Commun.EXT_OBSERVATION);
		else
			entreeFichier = null;
		//
		entreeFichierAffecte = false;
		setModifie();
	}

//	----------------------------------------	
//	Fichier
//	----------------------------------------
	/**
	 * renvoie le fichier d'entrée.
	 * 
	 * @return	le fichier d'entrée.
	  */
	public File getEntreeFichier()
	{	return entreeFichier;
	}
	/**
	 * remplace l'ancien fichier d'entrée par celui passé en paramčtre.
	 * On ouvre le fichier et le copie en mémoire, puis on le referme.
	 * 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 
	{	// on vire l'ancien fichier et l'ancien contenu de cet Editeur
		removeEntreeFichier();
		// si le nouveau fichier est vide
		if (f == null)
			// on met en place le nouveau fichier
			entreeFichierAffecte = false;
		// s'il n'est pas vide
		else
		{	FileInputStream in = null;
			try
			{	// on le teste de façon moins stricte que dans test
				// et on le remplit
				// on ouvre le flux
				in = new FileInputStream(entreeFichier);			
				RageInputStream input = new RageInputStream(in,getModele().getCreerReferenceSiAbsente(),true);
		
				// on récupčre la version du fichier
				Float version = (Float)input.readObject();
				if (version.compareTo(Commun.VERSION)>0)
					throw new VersionFichierIncompatibleException(entreeFichier.getPath());
		
				// on récupčre le type de fichier
				String typeFichier = (String)input.readObject();
				if (!typeFichier.equals(Commun.FICHIER_CODE_ENTREE))
					throw new TypeFichierIncompatibleException(entreeFichier.getPath());
		
				// on récupčre le DomaineSimple du fichier
				DomaineSimple domaineEmission = (DomaineSimple)getDomaine();
				DomaineSimple dom;
				dom = input.readDomaineSimple(this);
				if (!dom.egaleDomaine(domaineEmission))
					throw new ContenuFichierIncompatibleException(entreeFichier.getPath());
				// on n'a plus besoin de ce Domaine, il ne sert que pour le test.
				dom.remove();
		
				// on récupčre le répertoire
				setRepertoire(input.readRepertoireType(this));
		
				// pour chaque couple (Magnitude,Type), 
				// on stocke dans le vecteur correspondant
				try
				{	while (true)
					{	Magnitude tempMag = input.readMagnitude(this);
						Type tempType = input.readType(this);
						if (!tempType.getDomaine().egaleDomaine(domaineEmission))
							throw new ContenuFichierIncompatibleException(entreeFichier.getPath());
	//					if (!tempType.estComplet())
	//						throw new ContenuFichierIncompatibleException();
						vMagnitude.addMagnitude(tempMag);
						tempMag.setParent(this);
						tempMag.addInformationListener(this);
						// si le répertoire contient le Type lu,
						// on rajoute plutot celui du répertoire
						if (repertoire.containsType(tempType.getNom()))
						{	tempType.remove();
							tempType = repertoire.getType(tempType.getNom()); 						
						} 
						else
							tempType.setParent(this); 
						vType.addType(tempType);
						tempType.addInformationListener(this);
					}
				}
				catch (EOFException e)
				{	// ok
				}
				in.close();
			}
			catch (FileNotFoundException e)
			{	if (in != null)
					in.close();
				setEntreeFichier(null);	
				throw e;
			}
			catch (IOException e)
			{	if (in != null)
					in.close();
				setEntreeFichier(null);	
				throw e;
			}
			catch (ClassNotFoundException e)
			{	if (in != null)
					in.close();
				setEntreeFichier(null);	
				throw new ContenuFichierIncompatibleException(f.getPath());
			}
			catch (VersionFichierIncompatibleException e)
			{	if (in != null)
					in.close();
				setEntreeFichier(null);	
				throw e;
			}
			catch (TypeFichierIncompatibleException e) 
			{	if (in != null)
					in.close();
				setEntreeFichier(null);	
				throw e;
			}
			catch (ContenuFichierIncompatibleException e) 
			{	if (in != null)
					in.close();
				setEntreeFichier(null);	
				throw e;
			}
			catch (InformationIncompleteException e) 
			{	if (in != null)
					in.close();
				setEntreeFichier(null);	
				throw new ContenuFichierIncompatibleException(f.getPath());
			}
			catch (DomaineIncompatibleException e) 
			{	if (in != null)
					in.close();
				setEntreeFichier(null);	
				throw new ContenuFichierIncompatibleException(f.getPath());
			}
			catch (InformationExistanteException e) 
			{	if (in != null)
					in.close();
				setEntreeFichier(null);	
				throw new ContenuFichierIncompatibleException(f.getPath());
			}
			
			entreeTaille = size();
			// test ok, on copie le fichier au bon endroit
			// si le fichier existait déjŕ, on le copie en .back
			// sauf si f==observationFichier
			if (!f.getPath().equals(entreeFichier.getPath()))
			{	if (entreeFichier.exists())
					Commun.copierFichier(entreeFichier,new File(entreeFichier.getPath()+Commun.EXT_BACK));
				// copie
				try
				{	Commun.copierFichier(f,entreeFichier);
				}
				catch (IOException e1)
				{	setEntreeFichier(null);	
					throw e1;
				}
			}
			//
			entreeFichierAffecte = true;
		}
		setModifie();
	    fireTraitementRaffr(new TraitementEvent(this));
	}

	/**
	 * réinitialise le fichier d'entrée ŕ null.
	 * Les Magnitudes et Types d'entrée contenues dans cet Editeur sont supprimées,
	 * de męme que le répertoire
	 * 
	  */
	public void removeEntreeFichier()
	{	
		while (vMagnitude.size()!=0)
			removeEntree(0);
		removeRepertoire();
		entreeFichierAffecte = false;
		entreeTaille = 0;
	}
	/**
	 * 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
	{	if (f == null)
			throw new FileNotFoundException();
		// ouvrir et vérifier le fichier		
		// on ouvre le flux
		FileInputStream in = new FileInputStream(f);			
		RageInputStream input = new RageInputStream(in,getModele().getCreerReferenceSiAbsente(),true);
		
		// on récupčre la version du fichier
		Float version = (Float)input.readObject();
		if (version.compareTo(Commun.VERSION)>0)
			throw new VersionFichierIncompatibleException(f.getPath());
		
		// on récupčre le type de fichier
		String typeFichier = (String)input.readObject();
		if (!typeFichier.equals(Commun.FICHIER_CODE_ENTREE))
			throw new TypeFichierIncompatibleException(f.getPath());
				
		// on récupčre le DomaineSimple du fichier
		DomaineSimple dom;
		dom = input.readDomaineSimple(this);
		if (!dom.egaleDomaine(getDomaine()))
			throw new ContenuFichierIncompatibleException(f.getPath());
		// on peut supprimer le domaine, y en a plus besoin
		dom.remove();
		// on récupčre le répertoire
		RepertoireType repertoireTemp = input.readRepertoireType(this);
		// on efface le repertoire inutile
		repertoireTemp.removeTraitementListener(this);
		repertoireTemp.remove();	

		// pour chaque couple (Magnitude,Type), on teste que le type est du bon domaine
		// et on en profite pour mettre la taille du fichier ŕ jour
		int resultat = -1;
		try
		{	while (true)
			{	Magnitude tempMag = input.readMagnitude(this);
				Type tempType = input.readType(this);
				if (!tempType.getDomaine().egaleDomaine(getDomaine()))
					throw new ContenuFichierIncompatibleException(f.getPath());
				if (!tempType.estComplet())
					throw new ContenuFichierIncompatibleException(f.getPath());
				// on peut supprimer ces infos dont on n'a pas besoin
				tempMag.remove();
				tempType.remove();
				resultat ++;
			}
		}
		catch (EOFException e)
		{	// ok
		}
		catch (InformationIncompleteException e)
		{	throw new ContenuFichierIncompatibleException(f.getPath());
		}
		catch (DomaineIncompatibleException e)
		{	e.printStackTrace();
		}		
		// on referme
		in.close();
		return resultat;
	}
	/**
	 * 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 
	{	// si le fichier existait déjŕ, on le copie en .back
		if (entreeFichier.exists())
			try
			{	Commun.copierFichier(entreeFichier,new File(entreeFichier.getPath()+Commun.EXT_BACK));
			}
			catch (IOException e1)
			{	// si ça foire, tant pis
				//e1.printStackTrace();
			}
		
		//création éventuelle du répertoire
		//creerRepertoire();
		entreeFichier.getParentFile().mkdirs();
		
		// on ouvre le flux
		FileOutputStream out = null;
		RepertoireType rep = null;
		try
		{	out = new FileOutputStream(entreeFichier);
			RageOutputStream output = new RageOutputStream(out);
		
			// on écrit la version du fichier
			output.writeObject(Commun.VERSION);
		
			// on écrit le type de fichier
			output.writeObject(Commun.FICHIER_CODE_ENTREE);
		
			// on écrit le DomaineSimple du fichier
			output.writeDomaine(getDomaine());

			// on écrit un répertoire vide
			rep = new RepertoireType(this);
			output.writeRepertoireType(rep);
		
			// on referme
			out.close();
		}
		catch (IOException e)
		{	if (out != null)
				out.close();
			throw e;
		}			

		// on affecte le fichier ŕ this
		try
		{	setRepertoire(rep);
		}
		catch (DomaineIncompatibleException e)
		{	e.printStackTrace();
		}

		//
		entreeTaille = size();
		//
		entreeFichierAffecte = true;
		setModifie();
	    fireTraitementRaffr(new TraitementEvent(this));
	}
	/**
	 * 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
	{	// on init
		Vector resultat = new Vector();
		// on lit
		Magnitude m = entreeInput.readMagnitude(this);
		resultat.add(m);
		Type t;
		try
		{	t = entreeInput.readType(this);
			resultat.add(t);
		}
		catch (InformationIncompleteException e)
		{	throw new ContenuFichierIncompatibleException(entreeFichier.getPath());
		}
		catch (DomaineIncompatibleException e)
		{	throw new ContenuFichierIncompatibleException(entreeFichier.getPath());
		}		
		// on renvoie
		return resultat;
	}
	 /**
	 * enregistre le contenu de ce Editeur dans 
	 * le fichier.
	 * 
	 * @throws	IOException	si une erreur se produit durant l'écriture.
	 * 
	  */
	public void enregistrerEntreeFichier() throws IOException
	{	// on ne le fait que si le fichier est affecté
	    if (estEntreeFichierAffecte())
	    {	//création éventuelle du répertoire
	        //creerRepertoire();
	        entreeFichier.getParentFile().mkdirs();
		
			//on ouvre le flux
			FileOutputStream out = null;
			try
			{	out = new FileOutputStream(entreeFichier);
				RageOutputStream output = new RageOutputStream(out);
			
				// on écrit la version du fichier
				output.writeObject(Commun.VERSION);
			
				// on écrit le type de fichier
				output.writeObject(Commun.FICHIER_CODE_ENTREE);
			
				// on écrit le DomaineSimple du fichier
				DomaineSimple domaineEmission = (DomaineSimple)getDomaine();
				output.writeDomaine(domaineEmission);
			
				// on écrit le RepertoireType
				output.writeRepertoireType(repertoire);
	
				// pour chaque couple (Magnitude,Type), 
				// on stocke dans le fichier
				for (int i=0;i<size();i++)
				{	output.writeMagnitude(vMagnitude.getMagnitude(i));
					output.writeType(vType.getType(i));
				}
			
				// on referme
				out.close();
			}
			catch (IOException e)
			{	if (out!=null)
					out.close();
				throw e;				
			}			
			setNonModifie();
	    }
	}
	 /**
	 * enregistre le contenu de ce Editeur dans 
	 * un fichier différent du fichier qui lui est affecté.
	 * Ce fichier est passé en paramčtre.
	 * 
	 * @param	fichier	fichier dans lequel enregistrer le contenu de cet Editeur.
	 * @throws	IOException	si une erreur se produit durant l'écriture.
	 * 
	  */
	public void exporterEntreeFichier(File fichier) throws IOException
	{	// on s'assure de la présence de l'extension
		if (!fichier.getPath().endsWith(Commun.EXT_ENTREE))
			fichier = new File(fichier.getPath()+Commun.EXT_ENTREE);
	
		// ouvrir et vérifier le fichier		
		// on ouvre le flux
		FileOutputStream out = null;
		try
		{	out = new FileOutputStream(fichier);
			RageOutputStream output = new RageOutputStream(out);
		
			// on écrit la version du fichier
			output.writeObject(Commun.VERSION);
		
			// on écrit le type de fichier
			output.writeObject(Commun.FICHIER_CODE_ENTREE);
		
			// on écrit le DomaineSimple du fichier
			DomaineSimple domaineEmission = (DomaineSimple)getDomaine();
			output.writeDomaine(domaineEmission);
		
			// on écrit le répertoire
			output.writeRepertoireType(repertoire);

			// pour chaque couple (Magnitude,Type), 
			// on stocke dans le fichier
			for (int i=0;i<size();i++)
			{	output.writeMagnitude(vMagnitude.getMagnitude(i));
				output.writeType(vType.getType(i));
			}
		
			// on referme
			out.close();
		}
		catch (IOException e)
		{	if (out!=null)
				out.close();
			throw e;
		}			
	}
	
	/**
	 * renvoie le nombre d'entrées contenues dans le fichier.
	 * Cette méthode est appelée juste avant la simulation.
	 * 
	 * @return	la taille du fichier d'observation de la Magnitude d'activation.
	  */
	public int getEntreeTaille()
	{	return entreeTaille;
	}

//	----------------------------------------	
//	Repertoire
//	----------------------------------------
	/**
	 * renvoie le Repertoire de cet EditeurEntree.
	 * 
	 * @return	le Repertoire de cet EditeurEntre.
	  */
	public RepertoireType getRepertoire()
	{	return repertoire;
	}
	/**
	 * remplace le Repertoire de cet EditeurEntree par
	 * le Repertoire passé en paramčtre.
	 * Il faut que les Types contenus dans ce repertoire soient
	 * d'un Domaine compatible avec le Domaine utilisé dans cet
	 * EditeurEntree, sinon une DomaineIncompatibleException est levée.
	 * 
	 * @param	nouveau	le nouveau Repertoire de cet EditeurEntre.
	 * @throws	DomaineIncompatibleException	si le Domaine du nouveau Repertoire est incompatible avec l'ancien.
	  */
	public void setRepertoire(RepertoireType nouveau) throws DomaineIncompatibleException
	{	removeRepertoire();
		repertoire = nouveau;
		repertoire.setParent(this);
		repertoire.addTraitementListener(this);
	}
	/**
	 * supprime le Repertoire actuel et son contenu.
	 * (ceci est dű ŕ une fermeture de fichier oů ŕ 
	 * une suppression de cet EditeurEntree.
	 * 
	  */
	public void removeRepertoire()
	{	if (repertoire !=null)
		{	repertoire.removeTraitementListener(this);
			repertoire.remove();
			repertoire = null;
		} 
	}
	
//	----------------------------------------	
//	Entrées
//	----------------------------------------
	/*
	 * 
	 */
	public Magnitude getMagnitude(int instant)
	{	return vMagnitude.getMagnitude(instant);
	}
	/*
	 * 
	 */
	public Type getType(int instant)
	{	return vType.getType(instant);
	}
	/**
	 * ajoute une Magnitude et un Type ŕ la liste des entrées,
	 * ŕ l'instant spécifié en paramčtre.
	 * 
	 * @param	mag		la Magnitude d'entrée ŕ rajouter.
	 * @param	t2		le Type d'entrée ŕ rajouter.
	 * @throws 	DomaineIncompatibleException si le Domaine du Type n'est pas compatible avec le Domaine du parent.
	  */
	public void addEntree(Magnitude mag, Type t2) throws DomaineIncompatibleException
	{	if (!getDomaine().estCompatibleDomaine(t2.getDomaine()))
			throw new DomaineIncompatibleException(getIdentification()+":"+t2.getIdentification());
		vMagnitude.addMagnitude(mag);
		mag.setParent(this);
		mag.addInformationListener(this);
		// on vérifie que le répertoire n'est pas déjŕ le parent		
		Type t = t2;
		// si le répertoire ne contient pas le type lui męme
		if (!(repertoire.containsObjet(t)))
			// mais un type de męme nom
			if (repertoire.containsType(t.getNom()))
			{	Type typeTemp = repertoire.getType(t.getNom());
				//alors si ce type est structurellement identique,
				if (t.estCompatibleType(typeTemp))
					// on rajoute celui du répertoire
					t = typeTemp;
				// sinon, on rajoute le type passé en paramčtre, mais en changeant son nom
				else
				{	t.setNom(Commun.STRING_ANONYME);  
					t.setParent(this);
				}
			}
			// sinon, on anonymise le nom
			else
			{	t.setNom(Commun.STRING_ANONYME);  
				t.setParent(this);
			}
		vType.addType(t);
		t.addInformationListener(this);
		//
		setModifie();
	    fireTraitementEltModif(new TraitementEvent(this,TraitementEvent.ELT_INSER,size()-1));
	}
	/**
	 * crée et ajoute une nouvelle entrée ŕ la fin
	 * de la liste.
	 * 
	  */
	public void newEntree()
	{	try
		{	addEntree(new Magnitude(this),new Type(this));
		}
		catch (DomaineIncompatibleException e)
		{	e.printStackTrace();
		}
	}
	/**
	 * remplace le Type de l'entrée ŕ l'instant passé en paramčtre.
	 * 
	 * @param	instant	instant du Type ŕ échanger.
	 * @param	t2		nouveau Type de cette entrée.
	 * @throws	DomaineIncompatibleException si le nouveau Type n'a pas le bon Domaine.
	  */
	public void setType(int instant,Type t2) throws DomaineIncompatibleException
	{	if (!getDomaine().estCompatibleDomaine(t2.getDomaine()))
			throw new DomaineIncompatibleException(getIdentification()+t2.getIdentification());
		vType.getType(instant).removeInformationListener(this);
		// on ne supprime vraiment le Type que s'il n'apparait pas dans le répertoire		
		if (!repertoire.containsObjet(vType.getType(instant)))
			vType.getType(instant).remove();
		// on vérifie que le répertoire n'est pas déjŕ le parent		
		Type t = t2;
		// si le répertoire ne contient pas le type lui męme
		if (!(repertoire.containsObjet(t)))
			// mais un type de męme nom
			if (repertoire.containsType(t.getNom()))
			{	Type typeTemp = repertoire.getType(t.getNom());
				//alors si ce type est structurellement identique,
				if (typeTemp.estCompatibleType(t))
					// on rajoute celui du répertoire
					t = typeTemp;
				// sinon, on rajoute le type passé en paramčtre, mais en changeant son nom
				else
				{	t.setNom(Commun.STRING_ANONYME);  
					t.setParent(this);
				}
			}
			// sinon, on anonymise le nom
			else
			{	t.setNom(Commun.STRING_ANONYME);  
				t.setParent(this);
			}
		vType.setType(instant,t);
		t.addInformationListener(this);
		//
		setModifie();
	    fireTraitementEltModif(new TraitementEvent(this,TraitementEvent.ELT_REMPL,instant));
	}
	/**
	 * supprime une Entrée de la liste,
	 * ŕ l'instant spécifié.
	 * 
	 * @param	instant	instant de l'entrée ŕ supprimer.
	  */
	public void removeEntree(int instant)
	{	Magnitude tempMagnitude = vMagnitude.getMagnitude(instant);
		tempMagnitude.removeInformationListener(this);
		vMagnitude.removeMagnitude(instant);
		//
		Type tempType = vType.getType(instant);
		tempType.removeInformationListener(this);
		vType.removeType(instant);
		// on ne supprime vraiment le Type que s'il n'apparait pas dans le répertoire		
		if (!repertoire.containsObjet(tempType))
			tempType.remove();
		//
		tempMagnitude.remove();
		setModifie();
	    fireTraitementEltModif(new TraitementEvent(this,TraitementEvent.ELT_SUPPR,instant));
	}
	/**
	 * remplace toutes les occurrences d'un Type 
	 * appartenant au répertoire,
	 * par un Type vierge.
	 * 
	 * @param	type	Type ŕ ré-initialiser.
	  */
	public void viderType(Type type)
	{	for (int i=0;i<size();i++)
			if (getType(i) == type)
			{	Type tempType = new Type(this);
				tempType.setNom(Commun.STRING_VIDE);
				try
				{	setType(i,tempType);
				}
				catch (DomaineIncompatibleException e)
				{	e.printStackTrace();
				}
				getType(i).removeInformationListener(this);				
			}
		setModifie();
    	fireTraitementRaffr(new TraitementEvent(this));
	}
	/**
	 * renvoie le nombre d'entrées.
	 * 
	 * @return	la nombre d'entrées.
	  */
	public int size()
	{	return vMagnitude.size();
	}

//	----------------------------------------	
//	Domaine
//	----------------------------------------
	/*
	 * 
	 */
	public InterfaceDomaine getDomaine()
	{	InterfaceDomaine resultat = null;
		resultat = parent.getDomaine();
		return resultat;
	}
	/**
	 * méthode fantôme.
	 * la possession de Domaine est trčs temporaire, elle sert au traitement.
	 * Le Domaine n'est pas conservé, donc cette méthode est inutile.
	 * 
	 * @param	d	l'homonyme de cet Editeur dans un autre Modele.  
	 * 
	  */
	  public void setDomaine(InterfaceDomaine d)
	  {			
	  }
	
//	----------------------------------------	
//	This
//	----------------------------------------
		/*
		 * 
		 */
  public void remove()
  {	fireTraitementSuppr(new TraitementEvent(this));
  	// on efface tous les liens
	  removeEntreeFichier();
	  parent = null;
	  vType = null;
	  vMagnitude = null;
	  entreeFichier = null;
	  entreeInput = null;
	  
  }
  
//	----------------------------------------	
//	Simulation
//	----------------------------------------
	/*
	 * 
	 */
	public boolean estComplet()
	{	boolean resultat = true;
		
		try
		{	testerEntreeFichier(entreeFichier);
		}
		catch (Exception e)
		{
			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.
	 * 
	 * @return 	vrai si cette Section est complčtement définie.
	  */
	public boolean estCompletInterface()
	{	boolean resultat = true;
		if (!entreeFichierAffecte)
			resultat = false;
		else
		{	int i=0;
			while (resultat && i<vMagnitude.size())
			{	if (getMagnitude(i).estComplet() && getType(i).estComplet())
					i++;
				else
					resultat = false;
			}
		}
		return resultat;
	}

	/**
	 * ouvre le fichier d'entrée
	 * et le prépare pour la simulation en consommant 
	 * certaines données inutiles pour la 
	 * simulation et contenues au début du fichier. 
	 * A ce stade, le fichier a été testé
	 * et est supposé ętre valide.
	 * 
	  */
	public int preparerSimulation() throws IOException, ContenuFichierIncompatibleException
	{	FileInputStream in = null;
		try
		{	//on normalise les types
			for (int i=0;i<vType.size();i++)
				getType(i).normaliser();
			// on supprime le contenu de cet editeur
			int taille = size();
			File fichier = entreeFichier;
			removeEntreeFichier();
			entreeFichier = fichier;
			entreeTaille = taille;
			// puis on ouvre le fichier et on le lit en flux tendu
			in = new FileInputStream(entreeFichier);
			entreeInput = new RageInputStream(in,getModele().getCreerReferenceSiAbsente(),true);
			// on se positionne au début de la série de mag,type
			Float version = (Float)entreeInput.readObject();
			String typeFichier = (String)entreeInput.readObject();
			// on lit le domaine
			DomaineSimple dom = entreeInput.readDomaineSimple(this);
			// on n'a pas besoin du domaine
			dom.remove();
			// on lit le répertoire
			RepertoireType repertoireTemp = entreeInput.readRepertoireType(this);
			// on n'a pas besoin du répertoire non plus
			repertoireTemp.remove();
		}
		catch (InformationExistanteException e)
		{	if (in!= null)
				in.close();
			throw new ContenuFichierIncompatibleException(entreeFichier.getPath());
		}
		catch (DomaineIncompatibleException e)
		{	if (in!= null)
				in.close();
			throw new ContenuFichierIncompatibleException(entreeFichier.getPath());
		}
		catch (InformationIncompleteException e)
		{	if (in!= null)
				in.close();
			throw new ContenuFichierIncompatibleException(entreeFichier.getPath());
		}
		catch (ClassNotFoundException e)
		{	if (in!= null)
				in.close();
			throw new ContenuFichierIncompatibleException(entreeFichier.getPath());
		}
		catch (FileNotFoundException e)
		{	if (in!= null)
				in.close();
			throw e;
		}
		catch (IOException e)
		{	if (in!= null)
				in.close();
			throw e;
		}
		return entreeTaille;
	}	
	/**
	 * 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 
	{	entreeInput.close();
		setEntreeFichier(entreeFichier);
	}
	/**
	 * ferme le fichier d'entrée ŕ la fin de la simulation.
	 * Il est réouvert en suivant en tant qu'éditeur, au cas oů
	 * l'utilisateur continuerait l'édition en suivant de la simulation.
	 * 
	 * @throws	IOException si une erreur se produit lors de la vérification du fichier.
	  */
	public void terminerSimulation() throws IOException, ContenuFichierIncompatibleException, VersionFichierIncompatibleException, TypeFichierIncompatibleException
	{	entreeInput.close();
		setEntreeFichier(entreeFichier);
	}

//	----------------------------------------	
//	Parent
//	----------------------------------------
	/**
	 * renvoie la SectionInformationEndogene parent de cet Editeur.
	 * 
	 * @return 	la SectionInformationEndogene parent.
	  */
	public SectionInformationExogene getParent()
	{	return parent;
	}
	/**
	 * modifie la SectionInformationEndogene qui contient cet Editeur (i.e. son parent).
	 * Les Types et le répertoire sont également mis ŕ jour afin de raffraichir le domaine écouté.
	 * Un TraitementEvent de raffraichissement est émis.
	 * 
	 * @param	p nouveau parent de cette SectionInformationEndogene.
	 * @throws	DomaineIncompatibleException si le Domaine des Types contenus dans cet EditeurEntree
	 * 			n'est pas compatible avec le Domaine du nouveau parent. 
	  */
	public void setParent(SectionInformationExogene p) throws DomaineIncompatibleException, IOException
	{	// si le Domaine du parent n'est pas compatible avec les Types actuellement en mémoire
		// on lčve une DomaineIncompatibleException
		if (size()>0)
			if (!p.getDomaine().estCompatibleDomaine(getDomaine()))
				throw new DomaineIncompatibleException(getIdentification()+":"+p.getIdentification());
		parent = p;
		for (int i=0;i<size();i++)
			getType(i).setParent(this);
		if (repertoire != null)
			repertoire.setParent(this);
		raffraichirRepertoireEntree();
		setModifie();
	    fireTraitementRaffr(new TraitementEvent(this));
	}

//	----------------------------------------	
//	Modele
//	----------------------------------------
	/*
	 * 
	 */
	public Modele getModele()
	{	return parent.getModele();
	}

//	----------------------------------------	
//	InterfaceTraitement
//	----------------------------------------
	/*
	 * 
	 */
	public void addTraitementListener(TraitementListener i)
	{	vectorTraitementListener.add(i);
	}
	/*
	 * 
	 */
	public void removeTraitementListener(TraitementListener i)
	{	vectorTraitementListener.remove(i);
	}
	/**
	 * annonce la suppression de cet EditeurEntree.
	 * Chaque TraitementListener doit se supprimer lui-męme de la liste des listeners de cet EditeurObservation.  
	 * 
	 * @param 	e	le TraitementEvent qui est émis vers les TraitementListeners. 
	  */
	private void fireTraitementSuppr(TraitementEvent e)
	{	
	    while (vectorTraitementListener.size()!=0)
			try {
				((TraitementListener) vectorTraitementListener.get(0)).traitementSuppr(e);
			} catch (TraitementIncompletException e1) {
				e1.printStackTrace();
			}
	}
	/**
	 * annonce une modification d'un des constituants de cet EditeurEntree.
	 * 
	 * @param 	e	le TraitementEvent qui est émis vers les TraitementListeners. 
	  */
	private void fireTraitementEltModif(TraitementEvent e)
	{	
	    for (int i=0;i<vectorTraitementListener.size();i++)
			try {
				((TraitementListener) vectorTraitementListener.get(i)).traitementEltModif(e);
			} catch (TraitementIncompletException e1) {
				e1.printStackTrace();
			}
	}
	/**
	 * annonce un raffraichissement de cet EditeurEntree.
	 * 
	 * @param 	e	le TraitementEvent qui est émis vers les TraitementListeners. 
	  */
	private void fireTraitementRaffr(TraitementEvent e)
	{	
	    for (int i=0;i<vectorTraitementListener.size();i++)
			try
			{	((TraitementListener) vectorTraitementListener.get(i)).traitementRaffr(e);
			}
			catch (TraitementIncompletException e1)
			{
				e1.printStackTrace();
			}
	}
	/**
	 * annonce un échange.
	 * 
	 * @param 	e	l'TraitementEvent qui est émis vers les TraitementListeners. 
	  */
	private void fireTraitementRempl(TraitementEvent e)
	{	for (int i=0;i<vectorTraitementListener.size();i++)
			try
			{	((TraitementListener) vectorTraitementListener.get(i)).traitementRempl(e);
			}
			catch (TraitementIncompletException e1)
			{	e1.printStackTrace();
			}
	}
	/**
	 * annonce un masquage.
	 * 
	 * @param 	e	l'TraitementEvent qui est émis vers les TraitementListeners. 
	  */
	private void fireTraitementCache(TraitementEvent e)
	{	for (int i=0;i<vectorTraitementListener.size();i++)
			try
			{	((TraitementListener) vectorTraitementListener.get(i)).traitementCache(e);
			}
			catch (TraitementIncompletException e1)
			{	e1.printStackTrace();
			}
	}

//	----------------------------------------	
//	InformationListener
//	----------------------------------------
	/*
	 * appelée lors de la réception d'un InformationEvent de suppression.
	 * cet EditeurEntree écoute ses Types et Magnitudes d'entrée.
	 * Il est possible qu'un Type soit supprimé d'un répertoire.
	 * Dans ce cas lŕ, il doit ętre remplacé par des Types vides dans cet EditeurEntree.
	  */
	public void informationSuppr(InformationEvent e)
	{	if (e.getSource() instanceof Type)
		{	Type tempType = (Type)e.getSource();
			if (tempType.getParent() == repertoire)
				viderType(tempType);
		}
	}
	/*
	 * appelée lors de la réception d'un InformationEvent de modification de constituant.
	 * cet EditeurEntree écoute ses Types et Magnitudes d'entrée.
	 * Méthode inutile ici.
	  */
	public void informationEltModif(InformationEvent e)
	{	setModifie();
		fireTraitementRaffr(new TraitementEvent(this));
	}
	/*
	 * appelée lors de la réception d'un InformationEvent de raffraichissement.
	 * cet EditeurEntree écoute ses Types et Magnitudes d'entrée.
	 * On lčve un TraitementEvent de raffraichissement
	  */
	public void informationRaffr(InformationEvent e)
	{	if (e.getSource().estModifie())
		{    setModifie();
			fireTraitementRaffr(new TraitementEvent(this));
		}
	}
	/*
	 * appelée lors de la réception d'un InformationEvent de remplacement.
	 * cet EditeurEntree écoute ses Types et Magnitudes d'entrée.
	  */
	public void informationRempl(InformationEvent e) throws InformationIncompleteException
	{	
	}
	/*
	 * appelée lors de la réception d'un InformationEvent de masquage.
	 * cet EditeurEntree écoute ses Types et Magnitudes d'entrée.
	  */
	public void informationCache(InformationEvent e) throws InformationIncompleteException
	{	
	}
	/*
	 * appelée lors de la réception d'un InformationEvent de changement de Modele.
	 * cet EditeurEntree écoute ses Types et Magnitudes d'entrée.
	 * Tous les liens vers la Magnitude ou le Type
	 * sont supprimés.
	  */
	public void informationChangementModele(InformationEvent e)
	{	InterfaceInformation temp = (InterfaceInformation)e.getSource();
		try
		{	if (temp.getModele() != getModele())
			{	temp.removeInformationListener(this); 
				if (temp instanceof Type)
				{	int index = vType.indexOfObjet((Type)temp);
					vMagnitude.getMagnitude(index).removeInformationListener(this);
					vMagnitude.removeMagnitude(index);
					vType.removeType((Type)temp); 
				} 
				else if (temp instanceof Magnitude)
				{	int index = vMagnitude.indexOfObjet((Magnitude)temp);
					vType.getType(index).removeInformationListener(this);
					vType.removeType(index);
					vMagnitude.removeMagnitude((Magnitude)temp);
				} 
			} 
		}
		catch (InformationIncompleteException e1)
		{	e1.printStackTrace();
		}	
	}

//	----------------------------------------	
//	InterfaceContientMagnitude
//	----------------------------------------
	/*
	 * 
	 */
	public int indexOfMagnitude(Magnitude magnitude)
	{	return vMagnitude.indexOfObjet(magnitude);
	}

//	----------------------------------------	
//	InterfaceContientType
//	----------------------------------------
	/*
	 * 
	 */
	public int indexOfType(Type type)
	{	return vType.indexOfObjet(type);
	}	

//	----------------------------------------	
//	InterfaceAffichable
//	----------------------------------------
	/*
	 * 
	 */
	public void remplacer(InterfaceAffichable d)
	{	repertoire.remplacer(((EditeurEntree)d).getRepertoire());
		fireTraitementRempl(new TraitementEvent(this,(EditeurEntree)d));
	}
	/*
	 * 
	 */
	public void cacher()
	{	if (repertoire != null)
			repertoire.cacher();
		fireTraitementCache(new TraitementEvent(this));
	}

//	----------------------------------------	
//	TraitementListener
//	----------------------------------------
	/*
	 * appelée lors de la réception d'un TraitementEvent de suppression.
	 * L'EditeurEntree écoute son Repertoire.
	 * S'il est supprimé, c'est forcément par l'Editeur, donc cette méthode est inutile ici
	  */
	public void traitementSuppr(TraitementEvent e)
	{	
	}
	/*
	 * appelée lors de la réception d'un TraitementEvent de modification de constituant.
	 * L'EditeurEntree écoute son Repertoire.
	 * Rien de spécial ŕ faire ici.
	  */
	public void traitementEltModif(TraitementEvent e)
	{	setModifie();
		fireTraitementRaffr(new TraitementEvent(this));
	}
	/*
	 * appelée lors de la réception d'un TraitementEvent de raffraichissement.
	 * L'EditeurEntree écoute son Repertoire.
	 * On transmet l'évčnement.
	  */
	public void traitementRaffr(TraitementEvent e)
	{	if (e.getSource().estModifie())
		{    setModifie();
			fireTraitementRaffr(new TraitementEvent(this));
		}
	}
	/*
	 * appelée lorsqu'un Modele réalise une itération de simulation.
	 * Inutile ici.
	  */
	public void traitementSimulation(TraitementEvent e)
	{	
	}



//----------------------------------------	
//Copier/Coller/Undo
//----------------------------------------
	/*
	 * 
	 */
  public EditeurEntree cloner()
  {	EditeurEntree resultat;
		
	  // COPIE
	  resultat = new EditeurEntree(parent);
	  try
	  {	// on clone le fichier
	  	resultat.setclonerEntreeFichier(new File(entreeFichier.getPath()));
	  	resultat.setclonerEstEntreeFichierAffecte(entreeFichierAffecte);
	  	// la taille
	  	resultat.setclonerEntreeTaille(entreeTaille);
		// le Repertoire
		resultat.setRepertoire(repertoire.cloner());
		// les Magnitudes
		VectorMagnitude tempVmagnitude = new VectorMagnitude();
		for (int i=0;i<size();i++)
		{	Magnitude magnitude = getMagnitude(i).cloner();
			tempVmagnitude.addMagnitude(magnitude);
			magnitude.setParent(resultat);
			magnitude.addInformationListener(resultat);
		}
		resultat.setclonerVectorMagnitude(tempVmagnitude);
		// les Types
		VectorType tempVtype = new VectorType();
		for (int i=0;i<size();i++)
		{	Type type = getType(i);
			// le type n'est pas dans le répertoire
			if (type.getParent()==this)
			{	type = type.cloner(); 
				type.setParent(resultat);
			} 
			// le type est dans le répertoire
			else
				type = resultat.getRepertoire().getType(type.getNom());
			tempVtype.addType(type);
			type.addInformationListener(resultat);
		}
		resultat.setclonerVectorType(tempVtype);
	  }
	  catch (Exception e)
	  {	// tant pis, on ne met pas de fichier
	  }
	  resultat.setNonModifie();
	  return resultat;
  }
  /**
   * utilisée lors du clonage pour modifier un champ 
   * de façon directe.
   * 
	*/
  public void setclonerEntreeFichier(File fichier)
  {	entreeFichier = fichier;
  }
  /**
   * utilisée lors du clonage pour modifier un champ 
   * de façon directe.
   * 
	*/
  public void setclonerEntreeTaille(int taille)
  {	entreeTaille = taille;
  }
  /**
   * utilisée lors du clonage pour modifier un champ 
   * de façon directe.
   * 
	*/
  public void setclonerVectorMagnitude(VectorMagnitude v)
  {	vMagnitude = v;
  }
  /**
   * utilisée lors du clonage pour modifier un champ 
   * de façon directe.
   * 
	*/
  public void setclonerVectorType(VectorType v)
  {	vType = v;
  }
  /**
   * utilisée lors du clonage pour modifier un champ 
   * de façon directe.
   * 
	*/
	public void setclonerEstEntreeFichierAffecte(boolean b)
	{	entreeFichierAffecte = b;
	}
	/*
	 * 
	 */
  public InterfaceHomonyme getHomonyme(Modele m) throws HomonymeIntrouvableException
	{	InterfaceHomonyme resultat;
		if (m == getModele())
		    resultat = this;
		else
		{	resultat = ((SectionInformationExogene)parent.getHomonyme(m)).getEntreeEditeur(); 
		}
		return resultat;
	}
	/*
	 *
	 */
	public boolean estCollable()
	{	boolean resultat = true;
	    Tampon tampon = getModele().getTampon();
		if (tampon.estVide())
			resultat = false;
		else
		{	InterfaceCopiable buffer = tampon.get();
			if (buffer instanceof Type)
			{	if (getDomaine().estCompatibleDomaine(((Type)buffer).getDomaine()))
					resultat = true;
				else
				    resultat = false;
			}
			else if (buffer instanceof Magnitude)
			{	resultat = true;
			}
			else
				resultat = false;
		}
		return resultat;
	}
  /*
   * colle dans cet Editeur une Magnitude ou un Type contenu dans le Tampon, 
   * qui vient se placer ŕ la fin du Vector correspondant.
   * 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;
	  	//temp.setNom(Type.SANS_NOM);
	  	try
	  	{	addEntree(new Magnitude(this),temp);
		}
		catch (DomaineIncompatibleException e)
		{	throw new CopiableIncompatibleException(getIdentification());
		}
	  }
	  else if (buffer instanceof Magnitude)
	  {	Magnitude temp = (Magnitude) buffer;
		try
		{	addEntree(temp,new Type(this));
		}
		catch (DomaineIncompatibleException e)
		{	throw new CopiableIncompatibleException(getIdentification());
		}
	  }
	  else
		  throw new CopiableIncompatibleException(getIdentification());
  }
	/**
	 * 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 cet Editeur.  
	 * 
	 * @throws	IOException	si une erreur se produit lors de l'accčs au répertoire.
	 * 
	  */
  public void raffraichirRepertoireEntree() throws IOException
  {	File repertoire = parent.getRepertoireEntree();  
  	if (repertoire != null)
  	{	File repertoireEntree = new File(repertoire.getPath()
			  + Commun.EXT_ENTREE);
	  if (!repertoireEntree.getPath().equals(entreeFichier.getPath()))
	  {	File temp = entreeFichier;
		// de toute façon, on change le nom du fichier d'entree 			
		entreeFichier = repertoireEntree;
	  	// si un fichier a été affecté
		if (entreeFichierAffecte)
		{	//création éventuelle du répertoire
			//creerRepertoire();
entreeFichier.getParentFile().mkdirs();
		//on le copie au nouvel emplacement
			Commun.copierFichier(temp,entreeFichier);
		}
	  }
	}
	else
	{	removeEntreeFichier();
		entreeFichier = null;
		entreeFichierAffecte = false;
	}
  	setModifie();
    fireTraitementRaffr(new TraitementEvent(this));
  }
	/**
	 * renvoie vrai si cet Editeur dispose d'un fichier
	 * d'entrée.  
	 *
	 * @return	vrai si cet Editeur a un fichier d'entrée. 
	  */
  public boolean estEntreeFichierAffecte()
  {	return entreeFichierAffecte;
  }
	/**
	 * modifie l'indicateur d'entrée de cet Editeur 
	 * 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
  {	if (entreeFichier != null)
  	{	entreeFichierAffecte = flag;
		if (flag)
			setEntreeFichier(entreeFichier);
		else
			removeEntreeFichier();
		setModifie();
	    fireTraitementRaffr(new TraitementEvent(this));
  	}
  }
	/*
	 * 
	 */
  public String getIdentification()
  {	return parent.getIdentification()+">"+Commun.STRING_EDITEUR+" "+Commun.STRING_ENTREES;
  }

	//	----------------------------------------	
	//	Modification
	//	----------------------------------------
	/*
	 * 
	 */
	public void setModifie()
	{	modifie = true;
	}
	/*
	 * 
	 */
	public boolean estModifie()
	{	return modifie;  
	}
	/*
	 * 
	 */
	public void setNonModifie()
	{	modifie = false;
		if (repertoire != null)
		    repertoire.setNonModifie();
		for (int i=0;i<size();i++)
		{	getMagnitude(i).setNonModifie();
			getType(i).setNonModifie();
		}
		fireTraitementRaffr(new TraitementEvent(this));
	}
}