package fenetres;

import javax.swing.ImageIcon;
import javax.swing.JMenu;
import javax.swing.JPopupMenu;

import cXML.node;
import fenetres.create_act.actAddMenuFalse;
import fenetres.create_act.actAddMenuTrue;
import fenetres.create_act.actAllContent;
import fenetres.create_act.actAllContentChilds;
import fenetres.create_act.actAttribut;
import fenetres.create_act.actCoefficient;
import fenetres.create_act.actCollapseAll;
import fenetres.create_act.actCollapseNode;
import fenetres.create_act.actCopy;
import fenetres.create_act.actDeleteNode;
import fenetres.create_act.actDownNode;
import fenetres.create_act.actEvalAncrageNumeroAbsoluePageNon;
import fenetres.create_act.actEvalAncrageNumeroAbsoluePageOui;
import fenetres.create_act.actEvalEnteteActive;
import fenetres.create_act.actEvalEnteteActiveNon;
import fenetres.create_act.actEvalEntetePasActive;
import fenetres.create_act.actEvalEntetePasActiveNon;
import fenetres.create_act.actEvalFirstChildFalse;
import fenetres.create_act.actEvalFirstChildTrue;
import fenetres.create_act.actEvalFormatageDirectNon;
import fenetres.create_act.actEvalFormatageDirectOui;
import fenetres.create_act.actEvalInitialCreator;
import fenetres.create_act.actEvalLastChildFalse;
import fenetres.create_act.actEvalLastChildTrue;
import fenetres.create_act.actEvalNameNodeNon;
import fenetres.create_act.actEvalNameNodeOui;
import fenetres.create_act.actEvalNamePageNon;
import fenetres.create_act.actEvalNamePageOui;
import fenetres.create_act.actEvalNameSequenceNon;
import fenetres.create_act.actEvalNameSequenceOui;
import fenetres.create_act.actEvalNumeroAbsoluePageNon;
import fenetres.create_act.actEvalNumeroAbsoluePageOui;
import fenetres.create_act.actEvalNumeroPageNon;
import fenetres.create_act.actEvalNumeroPageOui;
import fenetres.create_act.actEvalPiedPageActive;
import fenetres.create_act.actEvalPiedPageActiveNon;
import fenetres.create_act.actEvalPiedPagePasActive;
import fenetres.create_act.actEvalPiedPagePasActiveNon;
import fenetres.create_act.actEvalPlacementParagrapheNon;
import fenetres.create_act.actEvalPlacementParagrapheOui;
import fenetres.create_act.actEvalTextUserDefinedNon;
import fenetres.create_act.actEvalTextUserDefinedOui;
import fenetres.create_act.actEvalueFalse;
import fenetres.create_act.actEvalueTrue;
import fenetres.create_act.actEvaluerNomDuStyleHeriteFalse;
import fenetres.create_act.actEvaluerNomDuStyleHeriteTousLesNodesFalse;
import fenetres.create_act.actEvaluerNomDuStyleHeriteTousLesNodesTrue;
import fenetres.create_act.actEvaluerNomDuStyleHeriteTrue;
import fenetres.create_act.actEvaluerStyleFalse;
import fenetres.create_act.actEvaluerStyleTrue;
import fenetres.create_act.actEvaluerTousLesStylesParagraphesFalse;
import fenetres.create_act.actEvaluerTousLesStylesParagraphesTrue;
import fenetres.create_act.actExpandAll;
import fenetres.create_act.actExpandNode;
import fenetres.create_act.actInsereInformationFalse;
import fenetres.create_act.actInsereInformationMultipleFalse;
import fenetres.create_act.actInsereInformationMultipleTrue;
import fenetres.create_act.actInsereInformationTrue;
import fenetres.create_act.actOu;
import fenetres.create_act.actPaste;
import fenetres.create_act.actRechercheAnchorPageNumberFalse;
import fenetres.create_act.actRechercheAnchorPageNumberTrue;
import fenetres.create_act.actRechercheContenuPlusProcheVoisinfalse;
import fenetres.create_act.actRechercheContenuPlusProcheVoisintrue;
import fenetres.create_act.actRechercheContenufalse;
import fenetres.create_act.actRechercheContenutrue;
import fenetres.create_act.actRechercheIndexfalse;
import fenetres.create_act.actRechercheIndextrue;
import fenetres.create_act.actSupprimeTitre;
import fenetres.create_act.actTitre1;
import fenetres.create_act.actTitre2;
import fenetres.create_act.actTitre3;
import fenetres.create_act.actTitrePrincipal;
import fenetres.create_act.actUpNode;
import fenetres.create_act.actevalNameCreator;
import fenetres.create_act.actmarquenodefalse;
import fenetres.create_act.actmarquenodetrue;
import fenetres.create_act.actsautfalse;
import fenetres.create_act.actsautmultiplefalse;
import fenetres.create_act.actsautmultipletrue;
import fenetres.create_act.actsauttrue;
import fenetres.create_act.mnEvaluerATraversAnalyseStyleFalse;
import fenetres.create_act.mnEvaluerATraversAnalyseStyleTrue;
import list.listeDesNodesAllContent;
import list.listeDesNodesAnalyseStyle;
import list.listeDesNodesAncrable;
import list.listeDesNodesAvecEvalNameNode;
import list.listeDesNodesAvecOU;
import list.listeDesNodesContientEnfant;
import list.listeDesNodesEvalPlacement;
import list.listeDesNodesFormatageDirect;
import list.listeDesNodesPourEvaluationEntetePage;
import list.listeDesNodesPourEvaluerPage;
import list.listeDesNodesPourEvaluerPiedDePage;
import list.listeDesNodesRechercheByContenu;
import list.listeDesNotesAEvaluer;
import list.listeEvalNameNode;
import list.listeRechercheParAnchorPageNumber;

public class createPopupMenu extends JPopupMenu {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	public createPopupMenu(node nod) {
		
		if(nod!=null) {


			//**************************************************************
			//** La popupMenu qui s'affiche sur le tree pour les niveau 1 **
			//**************************************************************
			JPopupMenu mnPopupTree = new JPopupMenu();
			mnPopupTree.add( mnEvaluer());
			if(nod.getLevel()==1 ) {
				mnPopupTree.addSeparator();
				mnPopupTree.add(new actCoefficient());
				mnPopupTree.addSeparator();
				mnPopupTree.add(mnNiveau1());
			}
			
			//********************************************
			//** Pour les nodes de niveau supérieur à 1 **
			//********************************************
			if(nod.getLevel()>1 ) {
				
				// Le groupe représentation dans le feedback
				mnPopupTree.addSeparator();
				mnPopupTree.add(mnPourFeedback(nod));
				
				// Le groupe méthode de recherche
				if(listeDesNodesRechercheByContenu.isRechercheByContenu(nod)||listeRechercheParAnchorPageNumber.isRechercheParAnchorPageNumber(nod)) {
					mnPopupTree.addSeparator();
					mnPopupTree.add(mnGroupeRechercheContenu(nod));
				}
	

				// Le groupe méthode évaluer le node
				if(listeDesNodesAvecEvalNameNode.isEvalNameNode(nod)||listeDesNodesAllContent.isAllContent(nod)||
						listeDesNodesPourEvaluationEntetePage.isEntete(nod) || listeDesNodesPourEvaluerPiedDePage.isPiedDePage(nod)||
						listeDesNodesPourEvaluerPage.isPage(nod) || listeDesNotesAEvaluer.isAEvaluer(nod)) {
					mnPopupTree.addSeparator();
					mnPopupTree.add(mnGroupeMethodeEvaluer(nod));
				}
				
				 // Le groupe méthode évaluer les nodes enfants
				if(listeDesNodesContientEnfant.isContientEnfant(nod)) {
					mnPopupTree.addSeparator();
					mnPopupTree.add(mnGroupeMethodeEvaluerMultiple(nod));
				}
				
				// Le groupe accès aux attributs
				mnPopupTree.addSeparator();
				mnPopupTree.add(new actAttribut());
				
				// Le OU
				if(listeDesNodesAvecOU.isOU(nod)) {
					mnPopupTree.addSeparator();
					mnPopupTree.add(mnOu());
				}
				

			}
			
			// Le groupe Arbre
			mnPopupTree.addSeparator();
			mnPopupTree.add(mnArbre());
			mnPopupTree.addSeparator();
			mnPopupTree.add(new actCopy());
			mnPopupTree.addSeparator();
			mnPopupTree.add(new actPaste());
			mnPopupTree.addSeparator();
			mnPopupTree.add(new actDeleteNode());

			
			//*************************************
			//** Applique le popMenu sur la tree **
			//*************************************
			create.getTree().setComponentPopupMenu(mnPopupTree);
			
		}	
	}
	
	
	
	/**
	 * Menu Evaluer.</br>
	 * @return
	 */
	private JMenu mnEvaluer() {
		JMenu mnEvaluer = new JMenu("Evaluer");
		mnEvaluer.setIcon( new ImageIcon(create.class.getResource("/resources/evaluermini.png")));
		mnEvaluer.add(new actEvalueTrue());
		mnEvaluer.add(new actEvalueFalse());
		return mnEvaluer;
	}
	
	/**
	 * Evauler l'absence ou la présence du formatage direct.</br>
	 * Uniquement présent sur les paragraphes ou les titres.</br>
	 * @return
	 */
	private JMenu mnEvalFormatageDirect() {
		JMenu mnEvalFormatageDirect = new JMenu("Evaluer l'absence ou la présence du formatage direct");
		mnEvalFormatageDirect.setIcon( new ImageIcon(create.class.getResource("/resources/evalformatagedirectmini.png")));
		mnEvalFormatageDirect.add(new actEvalFormatageDirectOui());
		mnEvalFormatageDirect.add(new actEvalFormatageDirectNon());
		return mnEvalFormatageDirect;
	}
	
	/**
	 * Menu Arbre.</br>
	 * @return
	 */
	private JMenu mnArbre() {
		JMenu mnManageTree = new JMenu("Arbre");
		mnManageTree.add(new actUpNode());
		mnManageTree.add(new actDownNode());
		mnManageTree.addSeparator();
		mnManageTree.add(new actExpandAll());
		mnManageTree.add(new actExpandNode());
		mnManageTree.addSeparator();
		mnManageTree.add(new actCollapseAll());
		mnManageTree.add(new actCollapseNode());
		return mnManageTree;
	}
	
	/**
	 * Menu saut de ligne.</br>
	 * @return
	 */
	private JMenu mnSaut() {
		JMenu mnSaut = new JMenu("Saut de ligne avant");
		mnSaut.setIcon( new ImageIcon(create.class.getResource("/resources/sautmini.png")));
		mnSaut.add(new actsauttrue());
		mnSaut.add(new actsautfalse());
		return mnSaut;
	}
	
	/**
	 * Menu saut de ligne pour les niveau 1.</br>
	 * @return
	 */
	private JMenu mnSautNiveau1() {
		JMenu mnSautNiveau1 = new JMenu("Saut de ligne avant");
		mnSautNiveau1.setIcon( new ImageIcon(create.class.getResource("/resources/sautmini.png")));
		mnSautNiveau1.add(new actsauttrue());
		mnSautNiveau1.add(new actsautfalse());
		return mnSautNiveau1;
	}
	
	/**
	 * Menu saut de ligne entre les nodes.</br>
	 * @return
	 */
	private JMenu mnSautMultiple() {
		JMenu mnSautMultiple = new JMenu("Saut de ligne entre les nodes");
		mnSautMultiple.setIcon( new ImageIcon(create.class.getResource("/resources/sautmultiplemini.png")));
		mnSautMultiple.add(new actsautmultipletrue());
		mnSautMultiple.add(new actsautmultiplefalse());
		return mnSautMultiple;
	}
	
	/**
	 * Menu Titre.</br>
	 * @return
	 */
	private JMenu mnTitre() {
		JMenu mnTitre = new JMenu("Titre");
		mnTitre.setIcon( new ImageIcon(create.class.getResource("/resources/titremini.png")));
		mnTitre.add(new actTitrePrincipal());
		mnTitre.add(new actTitre1());
		mnTitre.add(new actTitre2());
		mnTitre.add(new actTitre3());
		mnTitre.addSeparator();
		mnTitre.add(new actSupprimeTitre());
		return mnTitre;
	}
	
	/**
	 * Insertion de l'information du node.</br>
	 * @return
	 */
	private JMenu mnInsereInformation() {
		JMenu mnInsereInformation = new JMenu("Insère l'information contenu du node");
		mnInsereInformation.setIcon( new ImageIcon(create.class.getResource("/resources/informationmini.png")));
		mnInsereInformation.add(new actInsereInformationTrue());
		mnInsereInformation.add(new actInsereInformationFalse());
		return mnInsereInformation;
	}
	
	/**
	 * Insertion de l'information sur tous les nodes de la page.</br>
	 * @return
	 */
	private JMenu mnInsereInformationMultiple() {
		JMenu mnInsereInformationMultiple = new JMenu("Insère les informations contenus de tous les nodes enfants");
		mnInsereInformationMultiple.setIcon( new ImageIcon(create.class.getResource("/resources/informationmultiplemini.png")));
		mnInsereInformationMultiple.add(new actInsereInformationMultipleTrue());
		mnInsereInformationMultiple.add(new actInsereInformationMultipleFalse());
		return mnInsereInformationMultiple;
	}
	
	/**
	 * Evaluation de l'ancrage du node dans la page par son numéro absolue.</br>
	 * @return
	 */
	private JMenu mnEvalAncrageNumeroAbsoluPageAncrage() {
		JMenu mnEvalAncrageNumeroAbsoluPageAncrage = new JMenu("Numéro absolue de la page");
		mnEvalAncrageNumeroAbsoluPageAncrage.setIcon(new ImageIcon(create.class.getResource("/resources/evalnumeropageancragemini.png")));
		mnEvalAncrageNumeroAbsoluPageAncrage.add(new actEvalAncrageNumeroAbsoluePageOui());
		mnEvalAncrageNumeroAbsoluPageAncrage.add(new actEvalAncrageNumeroAbsoluePageNon());
		return mnEvalAncrageNumeroAbsoluPageAncrage;
	}
	
	
	/**
	 * Menu Titre pour le niveau 1.</br>
	 * @return
	 */
	private JMenu mnTitreNiveau1() {
		JMenu mnTitreNiveau1 = new JMenu("Titre");
		mnTitreNiveau1.setIcon( new ImageIcon(create.class.getResource("/resources/titremini.png")));
		mnTitreNiveau1.add(new actTitrePrincipal());
		mnTitreNiveau1.add(new actTitre1());
		mnTitreNiveau1.add(new actTitre2());
		mnTitreNiveau1.add(new actTitre3());
		mnTitreNiveau1.addSeparator();
		mnTitreNiveau1.add(new actSupprimeTitre());
		return mnTitreNiveau1;
	}
	
	/**
	 * Menu lien de menu vers les niveau 1.</br>
	 * @return
	 */
	private JMenu mnAddMenuNiveau1() {
		JMenu mnAddMenuNiveau1= new JMenu("Lien"); //addMenu
		mnAddMenuNiveau1.setIcon( new ImageIcon(create.class.getResource("/resources/addmenumini.png")));
		mnAddMenuNiveau1.add(new actAddMenuTrue());
		mnAddMenuNiveau1.add(new actAddMenuFalse());
		return mnAddMenuNiveau1;
	}
	
	/**
	 * Menu lien de menu vers les niveau supérieur à 1.</br>
	 * @return
	 */
	private JMenu mnAddMenuNiveauSup1() {
		JMenu mnAddMenuNiveauSup1= new JMenu("Lien"); //addMenu
		mnAddMenuNiveauSup1.setIcon( new ImageIcon(create.class.getResource("/resources/addmenumini.png")));
		mnAddMenuNiveauSup1.add(new actAddMenuTrue());
		mnAddMenuNiveauSup1.add(new actAddMenuFalse());
		return mnAddMenuNiveauSup1;
	}
	
	/**
	 * Menu rechercher par l'index.</br>
	 * @return
	 */
	private JMenu mnRechercheIndex() {
		JMenu mnRechercheIndex = new JMenu("Recherche par l'index");
		mnRechercheIndex.setIcon(new ImageIcon(create.class.getResource("/resources/rechercheindexmini.png")));
		mnRechercheIndex.add( new actRechercheIndextrue())	;
		mnRechercheIndex.add(new actRechercheIndexfalse());
		return mnRechercheIndex;
	}
	
	/**
	 * Menu rechercher par le contenu exact.</br>
	 * Ignore la case et les epaces avant et après.</br>
	 * @return
	 */
	private JMenu mnRechercheContenuExact() {
		JMenu mnRechercheContenu = new JMenu("Recherche par le contenu exact");
		mnRechercheContenu.setIcon(new ImageIcon(create.class.getResource("/resources/recherchecontenumini.png")));
		mnRechercheContenu.add( new actRechercheContenutrue());
		mnRechercheContenu.add( new actRechercheContenufalse());
		return mnRechercheContenu;
	}
	
	/**
	 * Menu rechercher par le contenu du plus proche voisin.</br>
	 * @return
	 */
	private JMenu mnRechercheContenuPlusProcheVoisin() {
		JMenu mnRechercheContenuPlusProcheVoisin2 = new JMenu("Recherche par le plus proche voisin");
		mnRechercheContenuPlusProcheVoisin2.setIcon(new ImageIcon(create.class.getResource("/resources/recherchecontenuplusprochevoisinmini.png")));
		mnRechercheContenuPlusProcheVoisin2.add( new actRechercheContenuPlusProcheVoisintrue());
		mnRechercheContenuPlusProcheVoisin2.add(new actRechercheContenuPlusProcheVoisinfalse());
		return mnRechercheContenuPlusProcheVoisin2;
	}
	
	/**
	 * Menu analyseStyle.</br>
	 * @return
	 */
	private JMenu mnAnalyseStyle() {
		JMenu mnAnalyseStyle = new JMenu("Evaluer le style appliqué");
		mnAnalyseStyle.setIcon(new ImageIcon(create.class.getResource("/resources/evaluerstylemini.png")));
		mnAnalyseStyle.add(new actEvaluerStyleTrue());
		mnAnalyseStyle.add( new actEvaluerStyleFalse());
		return mnAnalyseStyle;
	}
	
	/**
	 * Manue Evaluer un style dans la structure.</br>
	 * @return
	 */
	private JMenu mnEvaluerATraversAnalyseStyle() {
		JMenu mnEvaluerATraversAnalyseStyle = new JMenu("Evaluer le style dans la structure");
		mnEvaluerATraversAnalyseStyle.setIcon(new ImageIcon(create.class.getResource("/resources/atraversanalysestylemini.png")));
		mnEvaluerATraversAnalyseStyle.add(new mnEvaluerATraversAnalyseStyleTrue());
		mnEvaluerATraversAnalyseStyle.add( new mnEvaluerATraversAnalyseStyleFalse());
		return mnEvaluerATraversAnalyseStyle;
	}
	
	/**
	 * Menu entête active.</br>
	 * @return
	 */
	private JMenu mnevalEnteteActive() {
		JMenu mnevalEnteteActive = new JMenu("Entête activé");
		mnevalEnteteActive.setIcon(new ImageIcon(create.class.getResource("/resources/enteteouimini.png")));
		mnevalEnteteActive.add(new actEvalEnteteActive());
		mnevalEnteteActive.add(new actEvalEnteteActiveNon());
		return mnevalEnteteActive;
	}
	
	/**
	 * Menu ent^te pas active.</br>
	 * @return
	 */
	private JMenu mnevalEntetePasActive() {
		JMenu mnevalEntetePasActive = new JMenu("Entête pas activé");
		mnevalEntetePasActive.setIcon(new ImageIcon(create.class.getResource("/resources/entetenonmini.png")));
		mnevalEntetePasActive.add(new actEvalEntetePasActive());
		mnevalEntetePasActive.add(new actEvalEntetePasActiveNon());
		return mnevalEntetePasActive;
	}
	
	/**
	 * Menu pied de page active.</br>
	 * @return
	 */
	private JMenu mnEvalPiedPageActive() {
		JMenu mnEvalPiedPageActive = new JMenu("Pied page activé");
		mnEvalPiedPageActive.setIcon(new ImageIcon(create.class.getResource("/resources/piedpageouimini.png")));
		mnEvalPiedPageActive.add(new actEvalPiedPageActive());
		mnEvalPiedPageActive.add(new actEvalPiedPageActiveNon());
		return mnEvalPiedPageActive;
	}
	
	/**
	 * Menu pied de page pas active.</br>
	 * @return
	 */
	private JMenu mnEvalPiedPagePasActive() {
		JMenu mnEvalPiedPagePasActive = new JMenu("Pied page pas activé");
		mnEvalPiedPagePasActive.setIcon(new ImageIcon(create.class.getResource("/resources/piedpagenonmini.png")));
		mnEvalPiedPagePasActive.add(new actEvalPiedPagePasActive());
		mnEvalPiedPagePasActive.add(new actEvalPiedPagePasActiveNon());
		return mnEvalPiedPagePasActive;
	}
	
	/**
	 * Menu évaluer le nom du node.</br>
	 * Revient à évaluer la présence du node.</br>
	 * @return
	 */
	private JMenu mnEvalNameNode() {
		JMenu mnEvalNameNode = new JMenu("Evaluer la présence du node");
		mnEvalNameNode.setIcon(new ImageIcon(create.class.getResource("/resources/evalnodemini.png")));
		mnEvalNameNode.add(new actEvalNameNodeOui());
		mnEvalNameNode.add(new actEvalNameNodeNon());
		return mnEvalNameNode;
	}
	
	/**
	 * Menu évaluer une variable de séquence.</br>
	 * @return
	 */
	private JMenu mnEvalNameSequence() {
		JMenu mnEvalNameSequence = new JMenu("Evaluer le nom de la séquence");
		mnEvalNameSequence.setIcon(new ImageIcon(create.class.getResource("/resources/evalnamesequencemini.png")));
		mnEvalNameSequence.add(new actEvalNameSequenceOui());
		mnEvalNameSequence.add(new actEvalNameSequenceNon());
		return mnEvalNameSequence;
	}
	
	/**
	 * Menu évaluer le nom de la page.</br>
	 * @return
	 */
	private JMenu mnEvalNamePage() {
		JMenu mnEvalNamePage = new JMenu("Evaluer le nom du style de la page");
		mnEvalNamePage.setIcon(new ImageIcon(create.class.getResource("/resources/evalnamepagemini.png")));
		mnEvalNamePage.add(new actEvalNamePageOui());
		mnEvalNamePage.add(new actEvalNamePageNon());
		return mnEvalNamePage;
	}
	
	/**
	 * Menu évaluer le numéro de la page.</br>
	 * @return
	 */
	private JMenu mnEvalNumeroPage() {
		JMenu mnEvalNumeroPage = new JMenu("Evaluer le numéro de la page");
		mnEvalNumeroPage.setIcon(new ImageIcon(create.class.getResource("/resources/evalnumeropagemini.png")));
		mnEvalNumeroPage.add(new actEvalNumeroPageOui());
		mnEvalNumeroPage.add(new actEvalNumeroPageNon());
		return mnEvalNumeroPage;
	}
	
	/*
	 * Menu évaluer le numéro absolu de la page.</br>
	 */
	private JMenu mnEvalNumeroAbsoluePage() {
		JMenu mnEvalNumeroAbsoluePage = new JMenu("Evaluer le numéro absolue de la page");
		mnEvalNumeroAbsoluePage.setIcon(new ImageIcon(create.class.getResource("/resources/evalnumeroabsoluepagemini.png")));
		mnEvalNumeroAbsoluePage.add(new actEvalNumeroAbsoluePageOui());
		mnEvalNumeroAbsoluePage.add(new actEvalNumeroAbsoluePageNon());
		return mnEvalNumeroAbsoluePage;
	}
	
	/**
	 * Evaluer la propriété personnalisé.</br>
	 * @return
	 */
	private JMenu mnEvalTextUserDefined() {
		JMenu mnEvalTextUserDefined = new JMenu("Evaluer la valeur de la propriété");
		mnEvalTextUserDefined.setIcon(new ImageIcon(create.class.getResource("/resources/evaltextuserdefinedmini.png")));
		mnEvalTextUserDefined.add(new actEvalTextUserDefinedOui());
		mnEvalTextUserDefined.add(new actEvalTextUserDefinedNon());
		return mnEvalTextUserDefined;
	}
	
	/**
	 * Menu rechercher par le numéro de la page ancrer.</br>
	 * Ce menu est utilisé pour les frames.</br>
	 * @return
	 */
	private JMenu mnRechercheParNumeroPageAncrer() {
		JMenu mnRechercheParNumeroPageAncrer = new JMenu("Recherche par le numéro de la page");
		mnRechercheParNumeroPageAncrer.setIcon(new ImageIcon(create.class.getResource("/resources/rechercheancragepagemini.png")));
		mnRechercheParNumeroPageAncrer.add( new actRechercheAnchorPageNumberTrue());
		mnRechercheParNumeroPageAncrer.addSeparator();
		mnRechercheParNumeroPageAncrer.add( new actRechercheAnchorPageNumberFalse());
		return mnRechercheParNumeroPageAncrer;
	}
	
	/**
	 * Menu pour la représentation dans les feedbacks des étudiants.</br>
	 * Ce menu apparaît dans tous nodes supérieur à 1.</br>
	 * @return
	 */
	private JMenu mnPourFeedback(node nod) {
		JMenu mnPourFeedback = new JMenu("Pour représentation feedback");
		mnPourFeedback.setIcon(new ImageIcon(create.class.getResource("/resources/feedbackmini.png")));
		mnPourFeedback.add(mnSaut());
		mnPourFeedback.addSeparator();
		mnPourFeedback.add(mnInsereInformation());
		mnPourFeedback.addSeparator();
		mnPourFeedback.add(mnTitre());
		mnPourFeedback.addSeparator();
		mnPourFeedback.add(mnAddMenuNiveauSup1());
		if(listeDesNodesPourEvaluerPage.isPage(nod)) {
			mnPourFeedback.addSeparator();
			mnPourFeedback.add(mnInsereInformationMultiple());
			mnPourFeedback.addSeparator();
			mnPourFeedback.add(mnSautMultiple());
			mnPourFeedback.addSeparator();
			mnPourFeedback.add(mnMarqueNode());
		}
		return mnPourFeedback;
	}
	
	/**
	 * Menu pour évaluer les tous les styles de paragraphe ou de titre.</br>
	 * Ce menu apparaît uniquement dans le node page de la structurepage.</br>
	 * @return
	 */
	private JMenu mnEvaluerStylesParagraphes() {
		JMenu mnEvaluerStylesParagraphes = new JMenu("Evaluer tous les styles (paragraphes ou titres).");
		mnEvaluerStylesParagraphes.setIcon(new ImageIcon(create.class.getResource("/resources/evaluertouslesstylesparagraphesmini.png")));
		mnEvaluerStylesParagraphes.add( new actEvaluerTousLesStylesParagraphesTrue());
		mnEvaluerStylesParagraphes.add( new actEvaluerTousLesStylesParagraphesFalse());
		return mnEvaluerStylesParagraphes;
	}
	
	
	/**
	 * Menu permettant insérer le node OU.</br>
	 * Uniquement accésible pour les nodes avec recherche par contenu.</br>
	 * @return
	 */
	private JMenu mnOu() {
		JMenu mnOu = new JMenu("Insérer un node OU");
		mnOu.setIcon(new ImageIcon(create.class.getResource("/resources/oumini.png")));
		mnOu.add( new actOu());
		return mnOu;
	}
	
	/**
	 * Menu respecter l'ordre des paragraphes.</br>
	 * Vérification le placement du node par rapport à la présence :</br>
	 *  1-du node précédent (avant).</br>
	 * @return
	 */
	private JMenu mnPlacementParagraphe() {
		JMenu mnPlacementParagraphe = new JMenu("Placement des paragraphes");
		mnPlacementParagraphe.setIcon(new ImageIcon(create.class.getResource("/resources/ordreparagraphemini.png")));
		mnPlacementParagraphe.add(new actEvalPlacementParagrapheOui());
		mnPlacementParagraphe.add(new actEvalPlacementParagrapheNon());
		return mnPlacementParagraphe;
	}
	
	/**
	 * Menu pour évaluer si le node est le dernier enfant.</br>
	 * @return
	 */
	private JMenu mnEvaluerDernierEnfant() {
		JMenu mnEvaluerDernierEnfant = new JMenu("Le node est le dernier enfant");
		mnEvaluerDernierEnfant.setIcon(new ImageIcon(create.class.getResource("/resources/dernierenfantmini.png")));
		mnEvaluerDernierEnfant.add(new actEvalLastChildTrue());
		mnEvaluerDernierEnfant.add(new actEvalLastChildFalse());
		return mnEvaluerDernierEnfant;
	}
	
	/**
	 * Menu pour évaluer si le node est le dernier enfant.</br>
	 * @return
	 */
	private JMenu mnEvaluerPremierEnfant() {
		JMenu mnEvaluerPremierEnfant = new JMenu("Le node est le premier enfant");
		mnEvaluerPremierEnfant.setIcon(new ImageIcon(create.class.getResource("/resources/premierenfantmini.png")));
		mnEvaluerPremierEnfant.add(new actEvalFirstChildTrue());
		mnEvaluerPremierEnfant.add(new actEvalFirstChildFalse());
		return mnEvaluerPremierEnfant;
	}
	
	/**
	 * Menu pour la représentation des nodes de niveau 1.</br>
	 * Permet de modifier le coefficient du node de niveua 1.</br>
	 * @return
	 */
	private JMenu mnNiveau1 () {
		JMenu mnNiveau1 = new JMenu("Pour représentation & coefficient");
		mnNiveau1.setIcon( new ImageIcon(create.class.getResource("/resources/feedbackmini.png"))); ///resources/attributanalysewritermini.png
		mnNiveau1.add(mnSautNiveau1());
		mnNiveau1.addSeparator();
		mnNiveau1.add(mnTitreNiveau1());
		mnNiveau1.addSeparator();
		mnNiveau1.add(mnAddMenuNiveau1());
		return mnNiveau1;
	}
	
	/**
	 * Menu pour marquer les nodes évaluer dans le feedback des étudiants.</br>
	 * Permet d'identifier les nodes évaluer pendant le création du fichier d'analyse.</br>
	 * @return
	 */
	private JMenu mnMarqueNode() {
		JMenu mnMarqueNode = new JMenu("Marque le node évalué dans le feedback");
		mnMarqueNode.setIcon( new ImageIcon(create.class.getResource("/resources/marquenodemini.png")));
		mnMarqueNode.add(new actmarquenodetrue());
		mnMarqueNode.add(new actmarquenodefalse());
		return mnMarqueNode;
	}
	
	/**
	 * Menu pour évaluer le nom du style hérité.</br>
	 * Permet d'évaluer les formatages directs sans utiliser analyseStyle.</br>
	 * @return
	 */
	private JMenu mnEvalNameLegacyStyle() {
		JMenu mnevalNameLegacyStyle = new JMenu("Evaluer le nom du style hérité");
		mnevalNameLegacyStyle.setIcon( new ImageIcon(create.class.getResource("/resources/heritagestylemini.png")));
		mnevalNameLegacyStyle.add(new actEvaluerNomDuStyleHeriteTrue());
		mnevalNameLegacyStyle.add( new actEvaluerNomDuStyleHeriteFalse());
		return mnevalNameLegacyStyle;
	}
	
	/**
	 * Menu pour évaluer le nom du style hérité de tous les nodes text:p, text:h, text:span (voir plus tard text:list).</br>
	 * Permet d'évaluer les formatages directs sans utiliser analyseStyle.</br>
	 * @return
	 */
	private JMenu mnEvalNameLegacyStyleTousLesNodes() {
		JMenu mnevalNameLegacyStyle = new JMenu("Evaluer les noms de tous des styles hérités, de tous les nodes");
		mnevalNameLegacyStyle.setIcon( new ImageIcon(create.class.getResource("/resources/heritagestyletouslesnodesmini.png")));
		mnevalNameLegacyStyle.add(new actEvaluerNomDuStyleHeriteTousLesNodesTrue());
		mnevalNameLegacyStyle.add( new actEvaluerNomDuStyleHeriteTousLesNodesFalse());
		return mnevalNameLegacyStyle;
	}
	
	
	
	/**
	 * Menu regroupant les menus permettant de recherche un node par son contenu textuel.</br>
	 * Ce menu apparaît uniquement pour les node de la liste recherche par contenu.</br>
	 * @return
	 */
	private JMenu mnGroupeRechercheContenu(node nod) {
		JMenu mnGroupeRechercheContenu = new JMenu("Recherche le node");
		mnGroupeRechercheContenu.setIcon( new ImageIcon(create.class.getResource("/resources/recherchemini.png")));
		
		if(listeDesNodesRechercheByContenu.isRechercheByContenu(nod)) {
			if(nod.retourneLesContenusEnfants("").length()>0) {
				mnGroupeRechercheContenu.add(mnRechercheContenuExact());
				mnGroupeRechercheContenu.addSeparator();
				mnGroupeRechercheContenu.add(mnRechercheContenuPlusProcheVoisin());
			}
			mnGroupeRechercheContenu.addSeparator();
			mnGroupeRechercheContenu.add(mnRechercheIndex());
		}
		if(listeRechercheParAnchorPageNumber.isRechercheParAnchorPageNumber(nod)) {
			mnGroupeRechercheContenu.addSeparator();
			mnGroupeRechercheContenu.add(mnRechercheParNumeroPageAncrer());
		}

		return mnGroupeRechercheContenu;
	}
	
	/**
	 * 
	 * @param nod
	 * @return
	 */
	private JMenu mnGroupeMethodeEvaluer(node nod) {
		JMenu mnGroupeMethodeEvaluer = new JMenu("Evaluer le node");
		
		//Imag pour evaluer le node
		mnGroupeMethodeEvaluer.setIcon( new ImageIcon(create.class.getResource("/resources/evaluatemini.png")));
		
		
		// Pour la méthode AllContent
		if(listeDesNodesAllContent.isAllContent(nod) ) {
			mnGroupeMethodeEvaluer.addSeparator();
			mnGroupeMethodeEvaluer.add(new actAllContent());			
		}
		
		if(listeDesNodesAncrable.isAncrable(nod)) {
			mnGroupeMethodeEvaluer.addSeparator();
			mnGroupeMethodeEvaluer.add(mnEvalAncrageNumeroAbsoluPageAncrage());
		}
		
		if(listeDesNodesFormatageDirect.isFormatageDirect(nod)) {
			mnGroupeMethodeEvaluer.addSeparator();
			mnGroupeMethodeEvaluer.add(mnEvalFormatageDirect());
		}
		
		if(listeEvalNameNode.isNodeEvalNameNode(nod)) {
			mnGroupeMethodeEvaluer.addSeparator();
			mnGroupeMethodeEvaluer.add(mnEvalNameNode());
		}
		
		if(listeDesNodesAnalyseStyle.isAnalyseStyle(nod)) {
			mnGroupeMethodeEvaluer.addSeparator();
			mnGroupeMethodeEvaluer.add(mnAnalyseStyle());
			mnGroupeMethodeEvaluer.addSeparator();
			mnGroupeMethodeEvaluer.add(mnEvalNameLegacyStyle());
		}
		
		if(listeDesNodesEvalPlacement.isPlacement(nod)) {
			mnGroupeMethodeEvaluer.addSeparator();
			mnGroupeMethodeEvaluer.add(mnEvaluerPremierEnfant());
			mnGroupeMethodeEvaluer.addSeparator();
			mnGroupeMethodeEvaluer.add(mnEvaluerDernierEnfant());
		}	

		if(listeDesNodesPourEvaluerPage.isPage(nod)) {
			mnGroupeMethodeEvaluer.addSeparator();
			mnGroupeMethodeEvaluer.add(mnEvalNamePage());
			mnGroupeMethodeEvaluer.addSeparator();
			mnGroupeMethodeEvaluer.add(mnEvalNumeroPage());
			mnGroupeMethodeEvaluer.addSeparator();
			mnGroupeMethodeEvaluer.add(mnEvalNumeroAbsoluePage());
		}
		
		if(listeDesNodesPourEvaluationEntetePage.isEntete(nod)) {
			mnGroupeMethodeEvaluer.add(mnevalEnteteActive());
			mnGroupeMethodeEvaluer.addSeparator();
			mnGroupeMethodeEvaluer.add(mnevalEntetePasActive());
		}
		
		if(listeDesNodesPourEvaluerPiedDePage.isPiedDePage(nod)) {
			mnGroupeMethodeEvaluer.addSeparator();
			mnGroupeMethodeEvaluer.add(mnEvalPiedPageActive());
			mnGroupeMethodeEvaluer.addSeparator();
			mnGroupeMethodeEvaluer.add(mnEvalPiedPagePasActive());
		}
		
		if(nod.getNomElt().equals("style:style")) {
			mnGroupeMethodeEvaluer.addSeparator();
			mnGroupeMethodeEvaluer.add(mnEvaluerATraversAnalyseStyle());
		}
		
		if(nod.getNomElt().equals("meta:initial-creator")) {
			mnGroupeMethodeEvaluer.addSeparator();
			mnGroupeMethodeEvaluer.add(new actEvalInitialCreator());
		}
		if(nod.getNomElt().equals("dc:creator")) {
			mnGroupeMethodeEvaluer.addSeparator();
			mnGroupeMethodeEvaluer.add(new actevalNameCreator());
		}

		if(nod.getNomElt().equals("text:sequence-decl")) {
			mnGroupeMethodeEvaluer.addSeparator();
			mnGroupeMethodeEvaluer.add(mnEvalNameSequence());
		}

		if(nod.getNomElt().equals("text:user-defined") && nod.chemin().contains("structurepage")) {
			mnGroupeMethodeEvaluer.addSeparator();
			mnGroupeMethodeEvaluer.add(mnEvalTextUserDefined());
		}
			
		
		
		
		
		
		return mnGroupeMethodeEvaluer;
	}
	
	
	private JMenu mnGroupeMethodeEvaluerMultiple(node nod) {
		JMenu mnGroupeMethodeEvaluerMultiple = new JMenu("Evaluer les nodes enfants");
		
		//Image pour evaluer les nodes enfants
		mnGroupeMethodeEvaluerMultiple.setIcon( new ImageIcon(create.class.getResource("/resources/evaluatemultiplemini.png")));
		
		if(listeDesNodesAllContent.isAllContent(nod) ) {			
			if(listeDesNodesPourEvaluerPage.isPage(nod)) {
				mnGroupeMethodeEvaluerMultiple.addSeparator();
				mnGroupeMethodeEvaluerMultiple.add(new actAllContentChilds());
			}
		}
		
		if(listeDesNodesEvalPlacement.isPlacement(nod)) {
			if(listeDesNodesPourEvaluerPage.isPage(nod)) {
				mnGroupeMethodeEvaluerMultiple.addSeparator();
				mnGroupeMethodeEvaluerMultiple.add(mnPlacementParagraphe());
			}
		}
		
		if(listeDesNodesPourEvaluerPage.isPage(nod)) {
			mnGroupeMethodeEvaluerMultiple.addSeparator();
			mnGroupeMethodeEvaluerMultiple.add(mnEvaluerStylesParagraphes());
			mnGroupeMethodeEvaluerMultiple.addSeparator();
			mnGroupeMethodeEvaluerMultiple.add(mnEvalNameLegacyStyleTousLesNodes());
		}

		
		return mnGroupeMethodeEvaluerMultiple;
	}
}