/*
 * Créé le 18 nov. 03
 *
 */
package fonction.similitude;

import java.util.Vector;

import principal.Commun;
import principal.copiercoller.Tampon;
import traitement.similitude.InterfaceContientSimilitude;
import traitement.similitude.InterfaceSimilitude;
import traitement.similitude.Similitude0Lineaire;

import fonction.FonctionEvent;
import fonction.FonctionListener;
import fonction.InterfaceFonctionFils;
import fonction.magnitude.VectorFonctionFilsMagnitude;
import gui.InterfaceAffichable;
import gui.menu.IChoixDefinition;
import gui.menu.IChoixProposition;
import gui.menu.IGroupe;
import gui.menu.IMethode;
import gui.menu.IVectorMethode;

/**
 * représente une Similitude linéaire. 
 * 
 * @author	Vincent Labatut
 * @version	1
  */
public class SimilitudeSimilitude0Lineaire extends AbstractFonctionFilsSimilitude implements FonctionListener, InterfaceContientSimilitude 
{	/**
	* représentation textuelle de cette fonction.
	 */
	public static final String NOM_FONCTION = "Sim0Lin";
	
//	----------------------------------------	
//	Constructeurs
//	----------------------------------------
	/**
	 * crée une fonction de parent la fonction passée en paramčtre.
	 * 
	 * @param	p	parent de cette fonction.	
	 * 
	  */
	public SimilitudeSimilitude0Lineaire(InterfaceFonctionParentSimilitude p)
	{	super(p);
		similitude = new Similitude0Lineaire(this);
	}	

//	----------------------------------------	
//	Parent
//	----------------------------------------
	/*
	 *
	 */
	public void setParent(InterfaceFonctionParentSimilitude p)
	{	boolean flag = (p.getModele() != getModele());
		// on positione le nouveau parent
		parent =  p;
		//
		similitude.setParent(this);
		if (flag)
			fireFonctionChangementModele(new FonctionEvent(this));
	}

//	----------------------------------------	
//	This
//	----------------------------------------
	/*
	 *
	 */
	 public void remove()
	 {	fireFonctionSuppr(new FonctionEvent(this));
		//
		similitude.remove();
	 	similitude = null;
	 	//
		parent = null;
	 }

//	----------------------------------------	
//	Interface Graphique
//	----------------------------------------
	 /*
	 *
	 */
	public IVectorMethode getVectorMethode()
	{	IMethode im;
		IGroupe ig;
		IChoixProposition ic;
		IChoixDefinition ic2;
		Class[] parameterTypes;
		boolean autorisation;
		
		IVectorMethode vectorMethode = new IVectorMethode();
		try
		{// supprimer
			// IMethode(Method, String, boolean)
			im = new IMethode(getClass().getMethod("supprimer", null), "Supprimer", editable);
			vectorMethode.addMethode(im);
		
		// remplacer 
			if (editable)
			{    parameterTypes = new Class[1]; //nbre param
				 parameterTypes[0] = Class.class;
				 im = new IMethode(getClass().getMethod("substituer", parameterTypes), "Remplacer par", true);			
				 ig = new IGroupe();
				 im.addGroupe(ig);
				 Vector vclass = Commun.VECTOR_IFF_SIMILITUDE;
				 for (int i=0;i<vclass.size();i++)
				 {	Class c = (Class) vclass.get(i);
					 ic = new IChoixProposition((String) c.getField("NOM_FONCTION").get(null));
					 ic.addValeur(c);
					 ig.addChoix(ic);
				 }
			}
			else
				 im = new IMethode(null, "Remplacer par", false);			
			vectorMethode.addMethode(im);	
		 
		 // copier
			im = new IMethode(getClass().getMethod("copier", null), "Copier", true);
			vectorMethode.addMethode(im);
		 
		 // couper
			im = new IMethode(getClass().getMethod("couper", null), "Couper", editable);
			vectorMethode.addMethode(im);
		 
		 // coller
			// condition : Class du buffer adéquate
			if (editable)
			{	autorisation = true; 
				Tampon tmp = getNoeud().getModele().getTampon();
				if (!tmp.estVide())
				{	Class classe = tmp.get().getClass();
					if (InterfaceFonctionFilsSimilitude.class.isAssignableFrom(classe))
						autorisation = true;
				}
			}
			else
				autorisation = false;
			im = new IMethode(getClass().getMethod("coller", null), "Coller", autorisation);
			vectorMethode.addMethode(im);
		} 
		catch (SecurityException e)
		{	e.printStackTrace();
		}
		catch (NoSuchMethodException e)
		{	e.printStackTrace();
		}
		catch (IllegalArgumentException e)
		{	e.printStackTrace();
		}
		catch (IllegalAccessException e)
		{	e.printStackTrace();
		}
		catch (NoSuchFieldException e)
		{	e.printStackTrace();
		}
		return vectorMethode;
	}
   	
//	----------------------------------------	
//	Simulation
//	----------------------------------------
	/*
	 *
	 */
	public boolean estComplet()
	{	boolean resultat = false;
		
		if (similitude != null)
			resultat = true;
		return(resultat); 
	}	
	/*
	 *
	 */
	public InterfaceSimilitude evaluer(int instant)
	{	return similitude.cloner();
	}
	/*
	 *
	 */
	public VectorFonctionFilsMagnitude getMagnitudeBruit()
	{	return new VectorFonctionFilsMagnitude();
	}

//	----------------------------------------	
//	InterfaceAffichable
//	----------------------------------------
	/*
	 *
	 */
	public void remplacer(InterfaceAffichable nouveau)
	{	if (nouveau instanceof SimilitudeSimilitude0Lineaire)
		{	similitude.remplacer(((SimilitudeSimilitude0Lineaire)nouveau).getSimilitude());
		} 
		else //InterfaceFonctionReel
		{	 similitude.cacher();
		}
		fireFonctionRempl(new FonctionEvent(this,(InterfaceFonctionFils)nouveau));
	}
	/*
	 *
	 */
	public void cacher()
	{	similitude.cacher();
		fireFonctionCache(new FonctionEvent(this));
	}

//	----------------------------------------	
//	Divers
//	----------------------------------------
	/*
	 *
	 */
	public InterfaceFonctionFils cloner()
	{	SimilitudeSimilitude0Lineaire resultat;
		resultat = new SimilitudeSimilitude0Lineaire((InterfaceFonctionParentSimilitude)getParent());
		resultat.setEditable(editable);
		resultat.setNonModifie();
		return(resultat);
	}
	/*
	 *
	 */
	public String toString()
	{	return NOM_FONCTION;
	}
	/*
	 *
	 */
	public String getNom()
	{	return NOM_FONCTION;
	}

//	----------------------------------------	
//	Modification
//	----------------------------------------
	/*
	 *
	 */
	public void setNonModifie()
	{	modifie = false;
    	fireFonctionRaffr(new FonctionEvent(this));
	}
}